From f9842d5d09edeb40f296e9f09be9cc22ac810d41 Mon Sep 17 00:00:00 2001 From: dartraiden Date: Wed, 19 Oct 2022 23:10:42 +0300 Subject: Rename WhatsAppWeb to WhatsApp --- bin15/mir_full.sln | 2 +- bin15/mir_icons.sln | 2 +- bin16/mir_full.sln | 2 +- bin16/mir_icons.sln | 2 +- bin17/mir_full.sln | 2 +- bin17/mir_icons.sln | 2 +- protocols/WhatsApp/WhatsApp.vcxproj | 94 + protocols/WhatsApp/WhatsApp.vcxproj.filters | 96 + protocols/WhatsApp/proto_whatsapp/CMakeLists.txt | 2 + .../WhatsApp/proto_whatsapp/Proto_WhatsApp.vcxproj | 32 + .../proto_whatsapp/Proto_WhatsApp.vcxproj.filters | 18 + protocols/WhatsApp/proto_whatsapp/res/Away.ico | Bin 0 -> 5430 bytes .../WhatsApp/proto_whatsapp/res/Invisible.ico | Bin 0 -> 5430 bytes protocols/WhatsApp/proto_whatsapp/res/Offline.ico | Bin 0 -> 5430 bytes protocols/WhatsApp/proto_whatsapp/res/Online.ico | Bin 0 -> 5430 bytes .../WhatsApp/proto_whatsapp/res/Proto_WhatsApp.rc | 72 + protocols/WhatsApp/proto_whatsapp/src/resource.h | 20 + protocols/WhatsApp/res/version.rc | 9 + protocols/WhatsApp/res/whatsapp.ico | Bin 0 -> 1150 bytes protocols/WhatsApp/res/whatsapp.rc | 171 + protocols/WhatsApp/src/avatars.cpp | 158 + protocols/WhatsApp/src/chats.cpp | 99 + protocols/WhatsApp/src/crypt.cpp | 140 + protocols/WhatsApp/src/db.h | 43 + protocols/WhatsApp/src/dicts.h | 194 + protocols/WhatsApp/src/iq.cpp | 709 + protocols/WhatsApp/src/main.cpp | 69 + protocols/WhatsApp/src/message.cpp | 130 + protocols/WhatsApp/src/noise.cpp | 203 + protocols/WhatsApp/src/options.cpp | 68 + protocols/WhatsApp/src/pmsg.pb.cc | 100321 ++++++++++++++ protocols/WhatsApp/src/pmsg.pb.h | 125385 ++++++++++++++++++ protocols/WhatsApp/src/pmsg.proto | 2361 + protocols/WhatsApp/src/proto.cpp | 333 + protocols/WhatsApp/src/proto.h | 425 + protocols/WhatsApp/src/qrcode.cpp | 124 + protocols/WhatsApp/src/resource.h | 26 + protocols/WhatsApp/src/server.cpp | 329 + protocols/WhatsApp/src/signal.cpp | 529 + protocols/WhatsApp/src/stdafx.cxx | 8 + protocols/WhatsApp/src/stdafx.h | 81 + protocols/WhatsApp/src/utils.cpp | 373 + protocols/WhatsApp/src/utils.h | 199 + protocols/WhatsApp/src/version.h | 14 + protocols/WhatsApp/src/wanode.cpp | 599 + protocols/WhatsAppWeb/WhatsAppWeb.vcxproj | 94 - protocols/WhatsAppWeb/WhatsAppWeb.vcxproj.filters | 96 - .../WhatsAppWeb/proto_whatsapp/CMakeLists.txt | 2 - .../proto_whatsapp/Proto_WhatsApp.vcxproj | 32 - .../proto_whatsapp/Proto_WhatsApp.vcxproj.filters | 18 - protocols/WhatsAppWeb/proto_whatsapp/res/Away.ico | Bin 5430 -> 0 bytes .../WhatsAppWeb/proto_whatsapp/res/Invisible.ico | Bin 5430 -> 0 bytes .../WhatsAppWeb/proto_whatsapp/res/Offline.ico | Bin 5430 -> 0 bytes .../WhatsAppWeb/proto_whatsapp/res/Online.ico | Bin 5430 -> 0 bytes .../proto_whatsapp/res/Proto_WhatsApp.rc | 72 - .../WhatsAppWeb/proto_whatsapp/src/resource.h | 20 - protocols/WhatsAppWeb/res/version.rc | 9 - protocols/WhatsAppWeb/res/whatsapp.ico | Bin 1150 -> 0 bytes protocols/WhatsAppWeb/res/whatsapp.rc | 171 - protocols/WhatsAppWeb/src/avatars.cpp | 158 - protocols/WhatsAppWeb/src/chats.cpp | 99 - protocols/WhatsAppWeb/src/crypt.cpp | 140 - protocols/WhatsAppWeb/src/db.h | 43 - protocols/WhatsAppWeb/src/dicts.h | 194 - protocols/WhatsAppWeb/src/iq.cpp | 709 - protocols/WhatsAppWeb/src/main.cpp | 69 - protocols/WhatsAppWeb/src/message.cpp | 130 - protocols/WhatsAppWeb/src/noise.cpp | 203 - protocols/WhatsAppWeb/src/options.cpp | 68 - protocols/WhatsAppWeb/src/pmsg.pb.cc | 100321 -------------- protocols/WhatsAppWeb/src/pmsg.pb.h | 125385 ------------------ protocols/WhatsAppWeb/src/pmsg.proto | 2361 - protocols/WhatsAppWeb/src/proto.cpp | 333 - protocols/WhatsAppWeb/src/proto.h | 425 - protocols/WhatsAppWeb/src/qrcode.cpp | 124 - protocols/WhatsAppWeb/src/resource.h | 26 - protocols/WhatsAppWeb/src/server.cpp | 329 - protocols/WhatsAppWeb/src/signal.cpp | 529 - protocols/WhatsAppWeb/src/stdafx.cxx | 8 - protocols/WhatsAppWeb/src/stdafx.h | 81 - protocols/WhatsAppWeb/src/utils.cpp | 373 - protocols/WhatsAppWeb/src/utils.h | 199 - protocols/WhatsAppWeb/src/version.h | 14 - protocols/WhatsAppWeb/src/wanode.cpp | 599 - 84 files changed, 233440 insertions(+), 233440 deletions(-) create mode 100644 protocols/WhatsApp/WhatsApp.vcxproj create mode 100644 protocols/WhatsApp/WhatsApp.vcxproj.filters create mode 100644 protocols/WhatsApp/proto_whatsapp/CMakeLists.txt create mode 100644 protocols/WhatsApp/proto_whatsapp/Proto_WhatsApp.vcxproj create mode 100644 protocols/WhatsApp/proto_whatsapp/Proto_WhatsApp.vcxproj.filters create mode 100644 protocols/WhatsApp/proto_whatsapp/res/Away.ico create mode 100644 protocols/WhatsApp/proto_whatsapp/res/Invisible.ico create mode 100644 protocols/WhatsApp/proto_whatsapp/res/Offline.ico create mode 100644 protocols/WhatsApp/proto_whatsapp/res/Online.ico create mode 100644 protocols/WhatsApp/proto_whatsapp/res/Proto_WhatsApp.rc create mode 100644 protocols/WhatsApp/proto_whatsapp/src/resource.h create mode 100644 protocols/WhatsApp/res/version.rc create mode 100644 protocols/WhatsApp/res/whatsapp.ico create mode 100644 protocols/WhatsApp/res/whatsapp.rc create mode 100644 protocols/WhatsApp/src/avatars.cpp create mode 100644 protocols/WhatsApp/src/chats.cpp create mode 100644 protocols/WhatsApp/src/crypt.cpp create mode 100644 protocols/WhatsApp/src/db.h create mode 100644 protocols/WhatsApp/src/dicts.h create mode 100644 protocols/WhatsApp/src/iq.cpp create mode 100644 protocols/WhatsApp/src/main.cpp create mode 100644 protocols/WhatsApp/src/message.cpp create mode 100644 protocols/WhatsApp/src/noise.cpp create mode 100644 protocols/WhatsApp/src/options.cpp create mode 100644 protocols/WhatsApp/src/pmsg.pb.cc create mode 100644 protocols/WhatsApp/src/pmsg.pb.h create mode 100644 protocols/WhatsApp/src/pmsg.proto create mode 100644 protocols/WhatsApp/src/proto.cpp create mode 100644 protocols/WhatsApp/src/proto.h create mode 100644 protocols/WhatsApp/src/qrcode.cpp create mode 100644 protocols/WhatsApp/src/resource.h create mode 100644 protocols/WhatsApp/src/server.cpp create mode 100644 protocols/WhatsApp/src/signal.cpp create mode 100644 protocols/WhatsApp/src/stdafx.cxx create mode 100644 protocols/WhatsApp/src/stdafx.h create mode 100644 protocols/WhatsApp/src/utils.cpp create mode 100644 protocols/WhatsApp/src/utils.h create mode 100644 protocols/WhatsApp/src/version.h create mode 100644 protocols/WhatsApp/src/wanode.cpp delete mode 100644 protocols/WhatsAppWeb/WhatsAppWeb.vcxproj delete mode 100644 protocols/WhatsAppWeb/WhatsAppWeb.vcxproj.filters delete mode 100644 protocols/WhatsAppWeb/proto_whatsapp/CMakeLists.txt delete mode 100644 protocols/WhatsAppWeb/proto_whatsapp/Proto_WhatsApp.vcxproj delete mode 100644 protocols/WhatsAppWeb/proto_whatsapp/Proto_WhatsApp.vcxproj.filters delete mode 100644 protocols/WhatsAppWeb/proto_whatsapp/res/Away.ico delete mode 100644 protocols/WhatsAppWeb/proto_whatsapp/res/Invisible.ico delete mode 100644 protocols/WhatsAppWeb/proto_whatsapp/res/Offline.ico delete mode 100644 protocols/WhatsAppWeb/proto_whatsapp/res/Online.ico delete mode 100644 protocols/WhatsAppWeb/proto_whatsapp/res/Proto_WhatsApp.rc delete mode 100644 protocols/WhatsAppWeb/proto_whatsapp/src/resource.h delete mode 100644 protocols/WhatsAppWeb/res/version.rc delete mode 100644 protocols/WhatsAppWeb/res/whatsapp.ico delete mode 100644 protocols/WhatsAppWeb/res/whatsapp.rc delete mode 100644 protocols/WhatsAppWeb/src/avatars.cpp delete mode 100644 protocols/WhatsAppWeb/src/chats.cpp delete mode 100644 protocols/WhatsAppWeb/src/crypt.cpp delete mode 100644 protocols/WhatsAppWeb/src/db.h delete mode 100644 protocols/WhatsAppWeb/src/dicts.h delete mode 100644 protocols/WhatsAppWeb/src/iq.cpp delete mode 100644 protocols/WhatsAppWeb/src/main.cpp delete mode 100644 protocols/WhatsAppWeb/src/message.cpp delete mode 100644 protocols/WhatsAppWeb/src/noise.cpp delete mode 100644 protocols/WhatsAppWeb/src/options.cpp delete mode 100644 protocols/WhatsAppWeb/src/pmsg.pb.cc delete mode 100644 protocols/WhatsAppWeb/src/pmsg.pb.h delete mode 100644 protocols/WhatsAppWeb/src/pmsg.proto delete mode 100644 protocols/WhatsAppWeb/src/proto.cpp delete mode 100644 protocols/WhatsAppWeb/src/proto.h delete mode 100644 protocols/WhatsAppWeb/src/qrcode.cpp delete mode 100644 protocols/WhatsAppWeb/src/resource.h delete mode 100644 protocols/WhatsAppWeb/src/server.cpp delete mode 100644 protocols/WhatsAppWeb/src/signal.cpp delete mode 100644 protocols/WhatsAppWeb/src/stdafx.cxx delete mode 100644 protocols/WhatsAppWeb/src/stdafx.h delete mode 100644 protocols/WhatsAppWeb/src/utils.cpp delete mode 100644 protocols/WhatsAppWeb/src/utils.h delete mode 100644 protocols/WhatsAppWeb/src/version.h delete mode 100644 protocols/WhatsAppWeb/src/wanode.cpp diff --git a/bin15/mir_full.sln b/bin15/mir_full.sln index a2d6d45a18..de637c8f7d 100644 --- a/bin15/mir_full.sln +++ b/bin15/mir_full.sln @@ -446,7 +446,7 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "VoiceService", "..\plugins\ EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libqrencode", "..\libs\libqrencode\libqrencode.vcxproj", "{4D3554DE-6E14-4F94-A909-A4B19151A47E}" EndProject -Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "WhatsAppWeb", "..\protocols\WhatsAppWeb\WhatsAppWeb.vcxproj", "{13E796AD-BEA4-4213-A1B8-E18E2397E544}" +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "WhatsApp", "..\protocols\WhatsApp\WhatsApp.vcxproj", "{13E796AD-BEA4-4213-A1B8-E18E2397E544}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution diff --git a/bin15/mir_icons.sln b/bin15/mir_icons.sln index 02da7db172..b35c646d90 100644 --- a/bin15/mir_icons.sln +++ b/bin15/mir_icons.sln @@ -60,7 +60,7 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Proto_MRA", "..\protocols\I EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Proto_Facebook", "..\protocols\Facebook\proto_facebook\Proto_Facebook.vcxproj", "{44298314-7DD4-4EF7-B576-30E503257223}" EndProject -Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Proto_WhatsApp", "..\protocols\WhatsAppWeb\proto_whatsapp\Proto_WhatsApp.vcxproj", "{64A2B403-90AF-4CF8-BC69-4E8D33872D64}" +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Proto_WhatsApp", "..\protocols\WhatsApp\proto_whatsapp\Proto_WhatsApp.vcxproj", "{64A2B403-90AF-4CF8-BC69-4E8D33872D64}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution diff --git a/bin16/mir_full.sln b/bin16/mir_full.sln index 75d24832fa..3e80648832 100644 --- a/bin16/mir_full.sln +++ b/bin16/mir_full.sln @@ -446,7 +446,7 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "VoiceService", "..\plugins\ EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libqrencode", "..\libs\libqrencode\libqrencode.vcxproj", "{4D3554DE-6E14-4F94-A909-A4B19151A47E}" EndProject -Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "WhatsAppWeb", "..\protocols\WhatsAppWeb\WhatsAppWeb.vcxproj", "{13E796AD-BEA4-4213-A1B8-E18E2397E544}" +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "WhatsApp", "..\protocols\WhatsApp\WhatsApp.vcxproj", "{13E796AD-BEA4-4213-A1B8-E18E2397E544}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution diff --git a/bin16/mir_icons.sln b/bin16/mir_icons.sln index eb62b723fb..4badb33778 100644 --- a/bin16/mir_icons.sln +++ b/bin16/mir_icons.sln @@ -60,7 +60,7 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Proto_MRA", "..\protocols\I EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Proto_Facebook", "..\protocols\Facebook\proto_facebook\Proto_Facebook.vcxproj", "{44298314-7DD4-4EF7-B576-30E503257223}" EndProject -Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Proto_WhatsApp", "..\protocols\WhatsAppWeb\proto_whatsapp\Proto_WhatsApp.vcxproj", "{64A2B403-90AF-4CF8-BC69-4E8D33872D64}" +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Proto_WhatsApp", "..\protocols\WhatsApp\proto_whatsapp\Proto_WhatsApp.vcxproj", "{64A2B403-90AF-4CF8-BC69-4E8D33872D64}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution diff --git a/bin17/mir_full.sln b/bin17/mir_full.sln index fce1e55825..6fc262cad5 100644 --- a/bin17/mir_full.sln +++ b/bin17/mir_full.sln @@ -446,7 +446,7 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "VoiceService", "..\plugins\ EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libqrencode", "..\libs\libqrencode\libqrencode.vcxproj", "{4D3554DE-6E14-4F94-A909-A4B19151A47E}" EndProject -Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "WhatsAppWeb", "..\protocols\WhatsAppWeb\WhatsAppWeb.vcxproj", "{13E796AD-BEA4-4213-A1B8-E18E2397E544}" +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "WhatsApp", "..\protocols\WhatsApp\WhatsApp.vcxproj", "{13E796AD-BEA4-4213-A1B8-E18E2397E544}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution diff --git a/bin17/mir_icons.sln b/bin17/mir_icons.sln index 7d7bed4901..2bf1ecf27d 100644 --- a/bin17/mir_icons.sln +++ b/bin17/mir_icons.sln @@ -60,7 +60,7 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Proto_MRA", "..\protocols\I EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Proto_Facebook", "..\protocols\Facebook\proto_facebook\Proto_Facebook.vcxproj", "{44298314-7DD4-4EF7-B576-30E503257223}" EndProject -Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Proto_WhatsApp", "..\protocols\WhatsAppWeb\proto_whatsapp\Proto_WhatsApp.vcxproj", "{64A2B403-90AF-4CF8-BC69-4E8D33872D64}" +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Proto_WhatsApp", "..\protocols\WhatsApp\proto_whatsapp\Proto_WhatsApp.vcxproj", "{64A2B403-90AF-4CF8-BC69-4E8D33872D64}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution diff --git a/protocols/WhatsApp/WhatsApp.vcxproj b/protocols/WhatsApp/WhatsApp.vcxproj new file mode 100644 index 0000000000..a3c27bbfc6 --- /dev/null +++ b/protocols/WhatsApp/WhatsApp.vcxproj @@ -0,0 +1,94 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + + {4d3554de-6e14-4f94-a909-a4b19151a47e} + + + {620e0be7-3763-4f35-9dbd-4770104e269c} + + + {e2a369cd-eda3-414f-8ad0-e732cd7ee68c} + + + + + + + {13E796AD-BEA4-4213-A1B8-E18E2397E544} + WhatsApp + + + false + x86-windows + $(Configuration) + + + false + x64-windows + $(Configuration) + + + + + + + Sync + + + + + NotUsing + + + + + + + + + + + NotUsing + + + + + + + Create + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/protocols/WhatsApp/WhatsApp.vcxproj.filters b/protocols/WhatsApp/WhatsApp.vcxproj.filters new file mode 100644 index 0000000000..a86fb8be96 --- /dev/null +++ b/protocols/WhatsApp/WhatsApp.vcxproj.filters @@ -0,0 +1,96 @@ + + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + + + Resource Files + + + Resource Files + + + + + Resource Files + + + \ No newline at end of file diff --git a/protocols/WhatsApp/proto_whatsapp/CMakeLists.txt b/protocols/WhatsApp/proto_whatsapp/CMakeLists.txt new file mode 100644 index 0000000000..5193619806 --- /dev/null +++ b/protocols/WhatsApp/proto_whatsapp/CMakeLists.txt @@ -0,0 +1,2 @@ +set(TARGET Proto_WhatsApp) +include(${CMAKE_SOURCE_DIR}/cmake/icons.cmake) \ No newline at end of file diff --git a/protocols/WhatsApp/proto_whatsapp/Proto_WhatsApp.vcxproj b/protocols/WhatsApp/proto_whatsapp/Proto_WhatsApp.vcxproj new file mode 100644 index 0000000000..c802604562 --- /dev/null +++ b/protocols/WhatsApp/proto_whatsapp/Proto_WhatsApp.vcxproj @@ -0,0 +1,32 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + Proto_WhatsApp + {64A2B403-90AF-4CF8-BC69-4E8D33872D64} + + + + + + + + + \ No newline at end of file diff --git a/protocols/WhatsApp/proto_whatsapp/Proto_WhatsApp.vcxproj.filters b/protocols/WhatsApp/proto_whatsapp/Proto_WhatsApp.vcxproj.filters new file mode 100644 index 0000000000..5a286dab98 --- /dev/null +++ b/protocols/WhatsApp/proto_whatsapp/Proto_WhatsApp.vcxproj.filters @@ -0,0 +1,18 @@ + + + + + + Header Files + + + Source Files + + + Resource Files + + + Resource Files + + + \ No newline at end of file diff --git a/protocols/WhatsApp/proto_whatsapp/res/Away.ico b/protocols/WhatsApp/proto_whatsapp/res/Away.ico new file mode 100644 index 0000000000..9c07e3fa13 Binary files /dev/null and b/protocols/WhatsApp/proto_whatsapp/res/Away.ico differ diff --git a/protocols/WhatsApp/proto_whatsapp/res/Invisible.ico b/protocols/WhatsApp/proto_whatsapp/res/Invisible.ico new file mode 100644 index 0000000000..cb743a4bfe Binary files /dev/null and b/protocols/WhatsApp/proto_whatsapp/res/Invisible.ico differ diff --git a/protocols/WhatsApp/proto_whatsapp/res/Offline.ico b/protocols/WhatsApp/proto_whatsapp/res/Offline.ico new file mode 100644 index 0000000000..4019c68283 Binary files /dev/null and b/protocols/WhatsApp/proto_whatsapp/res/Offline.ico differ diff --git a/protocols/WhatsApp/proto_whatsapp/res/Online.ico b/protocols/WhatsApp/proto_whatsapp/res/Online.ico new file mode 100644 index 0000000000..2143ea1438 Binary files /dev/null and b/protocols/WhatsApp/proto_whatsapp/res/Online.ico differ diff --git a/protocols/WhatsApp/proto_whatsapp/res/Proto_WhatsApp.rc b/protocols/WhatsApp/proto_whatsapp/res/Proto_WhatsApp.rc new file mode 100644 index 0000000000..469a8d4484 --- /dev/null +++ b/protocols/WhatsApp/proto_whatsapp/res/Proto_WhatsApp.rc @@ -0,0 +1,72 @@ +// Microsoft Visual C++ generated resource script. +// +#include "..\src\resource.h" + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#include "afxres.h" + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +///////////////////////////////////////////////////////////////////////////// +// Russian (Russia) resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_RUS) +LANGUAGE LANG_RUSSIAN, SUBLANG_DEFAULT + +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +1 TEXTINCLUDE +BEGIN + "..\\src\\resource.h\0" +END + +2 TEXTINCLUDE +BEGIN + "#include ""afxres.h""\r\n" + "\0" +END + +3 TEXTINCLUDE +BEGIN + "\r\n" + "\0" +END + +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// Icon +// + +// Icon with lowest ID value placed first to ensure application icon +// remains consistent on all systems. +IDI_ICON1 ICON "Offline.ico" +IDI_ICON2 ICON "Online.ico" +IDI_ICON3 ICON "Away.ico" +IDI_ICON4 ICON "Invisible.ico" +#endif // Russian (Russia) resources +///////////////////////////////////////////////////////////////////////////// + + + +#ifndef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 3 resource. +// + + +///////////////////////////////////////////////////////////////////////////// +#endif // not APSTUDIO_INVOKED + diff --git a/protocols/WhatsApp/proto_whatsapp/src/resource.h b/protocols/WhatsApp/proto_whatsapp/src/resource.h new file mode 100644 index 0000000000..e9d1373ca0 --- /dev/null +++ b/protocols/WhatsApp/proto_whatsapp/src/resource.h @@ -0,0 +1,20 @@ +//{{NO_DEPENDENCIES}} +// Microsoft Visual C++ generated include file. +// Used by Proto_WhatsApp.rc +// +#define IDI_ICON1 105 +#define IDI_ICON2 104 +#define IDI_ICON3 128 +#define IDI_ICON4 130 +//#define IDI_ICON5 1002 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 106 +#define _APS_NEXT_COMMAND_VALUE 40001 +#define _APS_NEXT_CONTROL_VALUE 1001 +#define _APS_NEXT_SYMED_VALUE 101 +#endif +#endif diff --git a/protocols/WhatsApp/res/version.rc b/protocols/WhatsApp/res/version.rc new file mode 100644 index 0000000000..5a5ddd63ed --- /dev/null +++ b/protocols/WhatsApp/res/version.rc @@ -0,0 +1,9 @@ +// Microsoft Visual C++ generated resource script. +// +#ifdef APSTUDIO_INVOKED +#error this file is not editable by Microsoft Visual C++ +#endif //APSTUDIO_INVOKED + +#include "..\src\version.h" + +#include "..\..\build\Version.rc" diff --git a/protocols/WhatsApp/res/whatsapp.ico b/protocols/WhatsApp/res/whatsapp.ico new file mode 100644 index 0000000000..7a0dc4c68d Binary files /dev/null and b/protocols/WhatsApp/res/whatsapp.ico differ diff --git a/protocols/WhatsApp/res/whatsapp.rc b/protocols/WhatsApp/res/whatsapp.rc new file mode 100644 index 0000000000..1d32f6b828 --- /dev/null +++ b/protocols/WhatsApp/res/whatsapp.rc @@ -0,0 +1,171 @@ +// Microsoft Visual C++ generated resource script. +// +#pragma code_page(65001) + +#include "..\src\resource.h" + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#include "afxres.h" + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +///////////////////////////////////////////////////////////////////////////// +// English (United States) resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US + +///////////////////////////////////////////////////////////////////////////// +// +// Dialog +// + +IDD_SHOWQR DIALOGEX 0, 0, 318, 337 +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Dialog" +FONT 8, "MS Shell Dlg", 400, 0, 0x1 +BEGIN + CONTROL "",IDC_QRPIC,"Static",SS_BITMAP | SS_NOTIFY | SS_CENTERIMAGE | SS_REALSIZEIMAGE | SS_SUNKEN,7,7,304,304 + CTEXT "Open WhatsApp application on your mobile phone and use it to read this QR code\nA window will disappear automatically after it",IDC_STATIC,8,314,302,17 +END + +IDD_ACCMGRUI DIALOGEX 0, 0, 188, 144 +STYLE DS_SETFONT | DS_FIXEDSYS | WS_CHILD +EXSTYLE WS_EX_CONTROLPARENT +FONT 8, "MS Shell Dlg", 400, 0, 0x0 +BEGIN + LTEXT "Nick:",IDC_STATIC,3,6,55,10 + EDITTEXT IDC_NICK,61,4,119,12,ES_AUTOHSCROLL + LTEXT "Default group:",IDC_STATIC,4,23,55,10 + EDITTEXT IDC_DEFGROUP,62,21,119,12,ES_AUTOHSCROLL + CONTROL "Do not open chat windows on creation",IDC_HIDECHATS, + "Button",BS_AUTOCHECKBOX | WS_TABSTOP,0,37,182,10 +END + +IDD_OPTIONS DIALOGEX 0, 0, 305, 188 +STYLE DS_SETFONT | DS_FIXEDSYS | WS_CHILD +EXSTYLE WS_EX_CONTROLPARENT +FONT 8, "MS Shell Dlg", 0, 0, 0x1 +BEGIN + LTEXT "Nick:",IDC_STATIC,5,6,79,10 + EDITTEXT IDC_NICK,87,5,211,12,ES_AUTOHSCROLL + LTEXT "Default group:",IDC_STATIC,5,24,79,10 + EDITTEXT IDC_DEFGROUP,87,23,211,12,ES_AUTOHSCROLL + CONTROL "Do not open chat windows on creation",IDC_HIDECHATS, + "Button",BS_AUTOCHECKBOX | WS_TABSTOP,4,43,294,10 +END + +IDD_GROUPCHAT_INVITE DIALOGEX 0, 0, 215, 170 +STYLE DS_SETFONT | DS_MODALFRAME | DS_SETFOREGROUND | DS_FIXEDSYS | DS_CENTER | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU +CAPTION "Invite users" +FONT 8, "MS Shell Dlg", 0, 0, 0x1 +BEGIN + GROUPBOX "Choose a user",IDC_STATIC,4,2,208,130 + CONTROL "",IDC_CLIST,"CListControl",WS_TABSTOP | 0x1,12,12,192,112,WS_EX_CLIENTEDGE + LTEXT "Other user:",IDC_STATIC,4,138,55,8 + EDITTEXT IDC_NEWJID,60,136,152,12,ES_AUTOHSCROLL + DEFPUSHBUTTON "&Invite",IDOK,108,152,50,14 + PUSHBUTTON "Cancel",IDCANCEL,162,152,50,14 +END + + +///////////////////////////////////////////////////////////////////////////// +// +// Icon +// + +// Icon with lowest ID value placed first to ensure application icon +// remains consistent on all systems. +IDI_WHATSAPP ICON "whatsapp.ico" + + +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +1 TEXTINCLUDE +BEGIN + "..\\src\\resource.h\0" +END + +2 TEXTINCLUDE +BEGIN + "#include ""afxres.h""\r\n" + "\0" +END + +3 TEXTINCLUDE +BEGIN + "\r\n" + "\0" +END + +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// DESIGNINFO +// + +#ifdef APSTUDIO_INVOKED +GUIDELINES DESIGNINFO +BEGIN + IDD_SHOWQR, DIALOG + BEGIN + BOTTOMMARGIN, 332 + END + + IDD_ACCMGRUI, DIALOG + BEGIN + END + + IDD_OPTIONS, DIALOG + BEGIN + END +END +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// AFX_DIALOG_LAYOUT +// + +IDD_SHOWQR AFX_DIALOG_LAYOUT +BEGIN + 0 +END + +IDD_ACCMGRUI AFX_DIALOG_LAYOUT +BEGIN + 0 +END + +IDD_OPTIONS AFX_DIALOG_LAYOUT +BEGIN + 0 +END + +#endif // English (United States) resources +///////////////////////////////////////////////////////////////////////////// + + + +#ifndef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 3 resource. +// + + +///////////////////////////////////////////////////////////////////////////// +#endif // not APSTUDIO_INVOKED + diff --git a/protocols/WhatsApp/src/avatars.cpp b/protocols/WhatsApp/src/avatars.cpp new file mode 100644 index 0000000000..09a693a0d0 --- /dev/null +++ b/protocols/WhatsApp/src/avatars.cpp @@ -0,0 +1,158 @@ +/* + +WhatsApp plugin for Miranda NG +Copyright © 2019-22 George Hazan + +*/ + +#include "stdafx.h" + +void WhatsAppProto::OnGetAvatarInfo(const JSONNode &root, void *pUserInfo) +{ + if (!root) return; + + MCONTACT hContact = (UINT_PTR)pUserInfo; + + PROTO_AVATAR_INFORMATION ai = {}; + ai.hContact = hContact; + ai.format = PA_FORMAT_JPEG; + wcsncpy_s(ai.filename, GetAvatarFileName(hContact), _TRUNCATE); + + DWORD dwLastChangeTime = _wtoi(root["tag"].as_mstring()); + + CMStringA szUrl(root["eurl"].as_mstring()); + if (szUrl.IsEmpty()) { + setDword(hContact, DBKEY_AVATAR_TAG, 0); // avatar doesn't exist, don't check it later + +LBL_Error: + ProtoBroadcastAck(hContact, ACKTYPE_AVATAR, ACKRESULT_FAILED, HANDLE(&ai)); + return; + } + + // if avatar was changed or not present at all, download it + if (dwLastChangeTime > getDword(hContact, DBKEY_AVATAR_TAG)) { + if (!g_plugin.SaveFile(szUrl, ai)) + goto LBL_Error; + + // set timestamp of avatar being saved + setDword(hContact, DBKEY_AVATAR_TAG, dwLastChangeTime); + } + ProtoBroadcastAck(hContact, ACKTYPE_AVATAR, ACKRESULT_SUCCESS, HANDLE(&ai)); +} + +INT_PTR WhatsAppProto::GetAvatarInfo(WPARAM wParam, LPARAM lParam) +{ + PROTO_AVATAR_INFORMATION *pai = (PROTO_AVATAR_INFORMATION*)lParam; + + ptrA id(getStringA(pai->hContact, isChatRoom(pai->hContact) ? "ChatRoomID" : DBKEY_JID)); + if (id == NULL) + return GAIR_NOAVATAR; + + CMStringW tszFileName(GetAvatarFileName(pai->hContact)); + wcsncpy_s(pai->filename, tszFileName.c_str(), _TRUNCATE); + pai->format = PA_FORMAT_JPEG; + + DWORD dwTag = getDword(pai->hContact, DBKEY_AVATAR_TAG, -1); + if (dwTag == -1 || (wParam & GAIF_FORCE) != 0) + if (pai->hContact != NULL && isOnline()) { + // WSSend(CMStringA(FORMAT, "[\"query\",\"ProfilePicThumb\",\"%s\"]", id.get()), &WhatsAppProto::OnGetAvatarInfo, (void*)pai->hContact); + return GAIR_WAITFOR; + } + + debugLogA("No avatar"); + return GAIR_NOAVATAR; +} + +///////////////////////////////////////////////////////////////////////////////////////// + +INT_PTR WhatsAppProto::GetAvatarCaps(WPARAM wParam, LPARAM lParam) +{ + switch (wParam) { + case AF_PROPORTION: + return PIP_SQUARE; + + case AF_FORMATSUPPORTED: // Jabber supports avatars of virtually all formats + return PA_FORMAT_JPEG; + + case AF_ENABLED: + return TRUE; + + case AF_MAXSIZE: + POINT *size = (POINT*)lParam; + if (size) + size->x = size->y = 640; + return 0; + } + return -1; +} + +CMStringW WhatsAppProto::GetAvatarFileName(MCONTACT hContact) +{ + CMStringW result = m_tszAvatarFolder + L"\\"; + + CMStringA jid; + if (hContact != NULL) { + ptrA szId(getStringA(hContact, isChatRoom(hContact) ? "ChatRoomID" : DBKEY_JID)); + if (szId == NULL) + return L""; + + jid = szId; + } + else jid = m_szJid; + + return result + _A2T(jid.c_str()) + L".jpg"; +} + +INT_PTR WhatsAppProto::GetMyAvatar(WPARAM wParam, LPARAM lParam) +{ + std::wstring tszOwnAvatar(m_tszAvatarFolder + L"\\myavatar.jpg"); + wcsncpy_s((wchar_t*)wParam, lParam, tszOwnAvatar.c_str(), _TRUNCATE); + return 0; +} + +INT_PTR WhatsAppProto::SetMyAvatar(WPARAM, LPARAM) +{ + return 0; +} + +///////////////////////////////////////////////////////////////////////////////////////// + +bool CMPlugin::SaveFile(const char *pszUrl, PROTO_AVATAR_INFORMATION &ai) +{ + NETLIBHTTPREQUEST req = {}; + req.cbSize = sizeof(req); + req.flags = NLHRF_NODUMP | NLHRF_PERSISTENT | NLHRF_SSL | NLHRF_HTTP11 | NLHRF_REDIRECT; + req.requestType = REQUEST_GET; + req.szUrl = (char*)pszUrl; + req.nlc = hAvatarConn; + + NETLIBHTTPREQUEST *pReply = Netlib_HttpTransaction(hAvatarUser, &req); + if (pReply == nullptr) { + hAvatarConn = nullptr; + debugLogA("Failed to retrieve avatar from url: %s", pszUrl); + return false; + } + + hAvatarConn = pReply->nlc; + + bool bSuccess = false; + if (pReply->resultCode == 200 && pReply->pData && pReply->dataLength) { + if (auto *pszHdr = Netlib_GetHeader(pReply, "Content-Type")) + ai.format = ProtoGetAvatarFormatByMimeType(pszHdr); + + if (ai.format != PA_FORMAT_UNKNOWN) { + FILE *fout = _wfopen(ai.filename, L"wb"); + if (fout) { + fwrite(pReply->pData, 1, pReply->dataLength, fout); + fclose(fout); + bSuccess = true; + } + else debugLogA("Error saving avatar to file %S", ai.filename); + } + else debugLogA("unknown avatar mime type"); + } + else debugLogA("Error %d reading avatar from url: %s", pReply->resultCode, pszUrl); + + Netlib_FreeHttpRequest(pReply); + return bSuccess; +} diff --git a/protocols/WhatsApp/src/chats.cpp b/protocols/WhatsApp/src/chats.cpp new file mode 100644 index 0000000000..3df2a954ee --- /dev/null +++ b/protocols/WhatsApp/src/chats.cpp @@ -0,0 +1,99 @@ +/* + +WhatsApp plugin for Miranda NG +Copyright © 2019-22 George Hazan + +*/ + +#include "stdafx.h" + +void WhatsAppProto::InitChat(WAUser *pUser) +{ + CMStringA jid = ""; + CMStringW wszId(Utf2T(jid.c_str())), wszNick(Utf2T("")); + + setWString(pUser->hContact, "Nick", wszNick); + + pUser->si = Chat_NewSession(GCW_CHATROOM, m_szModuleName, wszId, wszNick); + + Chat_AddGroup(pUser->si, TranslateT("Owner")); + Chat_AddGroup(pUser->si, TranslateT("SuperAdmin")); + Chat_AddGroup(pUser->si, TranslateT("Admin")); + Chat_AddGroup(pUser->si, TranslateT("Participant")); + + Chat_Control(m_szModuleName, wszId, m_bHideGroupchats ? WINDOW_HIDDEN : SESSION_INITDONE); + Chat_Control(m_szModuleName, wszId, SESSION_ONLINE); + + if (!pUser->bInited) { + // CMStringA query(FORMAT, "[\"query\",\"GroupMetadata\",\"%s\"]", jid.c_str()); + // WSSend(query, &WhatsAppProto::OnGetChatInfo, pUser); + } +} + +void WhatsAppProto::OnGetChatInfo(const JSONNode &root, void *param) +{ + auto *pChatUser = (WAUser *)param; + pChatUser->bInited = true; + + CMStringW wszOwner(root["owner"].as_mstring()), wszNick; + + for (auto &it : root["participants"]) { + CMStringW jid(it["id"].as_mstring()); + CMStringA szJid(jid); + + GCEVENT gce = { m_szModuleName, 0, GC_EVENT_JOIN }; + gce.pszID.w = pChatUser->si->ptszID; + gce.pszUID.w = jid; + gce.bIsMe = (szJid == m_szJid); + + if (jid == wszOwner) + gce.pszStatus.w = L"Owner"; + else if (it["isSuperAdmin"].as_bool()) + gce.pszStatus.w = L"SuperAdmin"; + else if (it["isAdmin"].as_bool()) + gce.pszStatus.w = L"Admin"; + else + gce.pszStatus.w = L"Participant"; + + if (gce.bIsMe) + wszNick = getMStringW(DBKEY_NICK); + else if (auto *pUser = FindUser(szJid)) + wszNick = Clist_GetContactDisplayName(pUser->hContact); + else { + int iPos = jid.Find('@'); + wszNick = (iPos != -1) ? jid.Left(iPos - 1) : jid; + } + + gce.pszNick.w = wszNick; + Chat_Event(&gce); + } + + if (pChatUser->arHistory.getCount()) { + for (auto &it : pChatUser->arHistory) { + CMStringW jid(it->jid), text(Utf2T(it->text)); + + GCEVENT gce = { m_szModuleName, 0, GC_EVENT_MESSAGE }; + gce.pszID.w = pChatUser->si->ptszID; + gce.dwFlags = GCEF_ADDTOLOG; + gce.pszUID.w = jid; + gce.pszText.w = text; + gce.time = it->timestamp; + gce.bIsMe = (it->jid == m_szJid); + Chat_Event(&gce); + } + pChatUser->arHistory.destroy(); + } + + CMStringW wszSubject(root["subject"].as_mstring()); + if (!wszSubject.IsEmpty()) { + time_t iSubjectTime(root["subjectTime"].as_int()); + CMStringW wszSubjectSet(root["subjectOwner"].as_mstring()); + + GCEVENT gce = { m_szModuleName, 0, GC_EVENT_TOPIC }; + gce.pszID.w = pChatUser->si->ptszID; + gce.pszUID.w = wszSubjectSet; + gce.pszText.w = wszSubject; + gce.time = iSubjectTime; + Chat_Event(&gce); + } +} diff --git a/protocols/WhatsApp/src/crypt.cpp b/protocols/WhatsApp/src/crypt.cpp new file mode 100644 index 0000000000..09a14f53b0 --- /dev/null +++ b/protocols/WhatsApp/src/crypt.cpp @@ -0,0 +1,140 @@ +/* + +WhatsApp plugin for Miranda NG +Copyright © 2019-22 George Hazan + +*/ + +#include "stdafx.h" + +MBinBuffer aesDecrypt( + const EVP_CIPHER *cipher, + const uint8_t *key, + const uint8_t *iv, + const void *data, size_t dataLen, + const void *additionalData, size_t additionalLen) +{ + int tag_len = 0, dec_len = 0, final_len = 0; + EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new(); + EVP_DecryptInit_ex(ctx, cipher, NULL, key, iv); + + if (additionalLen) + EVP_DecryptUpdate(ctx, nullptr, &tag_len, (uint8_t *)additionalData, (int)additionalLen); + + dataLen -= 16; + EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_TAG, 16, (uint8_t *)data + dataLen); + + MBinBuffer ret; + uint8_t outbuf[2000]; + for (size_t len = 0; len < dataLen; len += 1024) { + size_t portionSize = dataLen - len; + EVP_DecryptUpdate(ctx, outbuf, &dec_len, (uint8_t *)data + len, (int)min(portionSize, 1024)); + ret.append(outbuf, dec_len); + } + + EVP_DecryptFinal_ex(ctx, outbuf, &final_len); + if (final_len) + ret.append(outbuf, final_len); + + EVP_CIPHER_CTX_free(ctx); + return ret; +} + +///////////////////////////////////////////////////////////////////////////////////////// + +static unsigned char *HKDF_Extract(const EVP_MD *evp_md, + const unsigned char *salt, size_t salt_len, + const unsigned char *key, size_t key_len, + unsigned char *prk, size_t *prk_len) +{ + unsigned int tmp_len; + + if (!HMAC(evp_md, salt, (int)salt_len, key, (int)key_len, prk, &tmp_len)) + return NULL; + + *prk_len = tmp_len; + return prk; +} + +static unsigned char *HKDF_Expand(const EVP_MD *evp_md, + const unsigned char *prk, size_t prk_len, + const unsigned char *info, size_t info_len, + unsigned char *okm, size_t okm_len) +{ + HMAC_CTX *hmac; + unsigned char *ret = NULL; + + unsigned int i; + + unsigned char prev[EVP_MAX_MD_SIZE]; + + size_t done_len = 0, dig_len = EVP_MD_size(evp_md); + + size_t n = okm_len / dig_len; + if (okm_len % dig_len) + n++; + + if (n > 255 || okm == NULL) + return NULL; + + if ((hmac = HMAC_CTX_new()) == NULL) + return NULL; + + if (!HMAC_Init_ex(hmac, prk, (int)prk_len, evp_md, NULL)) + goto err; + + for (i = 1; i <= n; i++) { + size_t copy_len; + const unsigned char ctr = i; + + if (i > 1) { + if (!HMAC_Init_ex(hmac, NULL, 0, NULL, NULL)) + goto err; + + if (!HMAC_Update(hmac, prev, dig_len)) + goto err; + } + + if (!HMAC_Update(hmac, info, info_len)) + goto err; + + if (!HMAC_Update(hmac, &ctr, 1)) + goto err; + + if (!HMAC_Final(hmac, prev, NULL)) + goto err; + + copy_len = (done_len + dig_len > okm_len) ? + okm_len - done_len : + dig_len; + + memcpy(okm + done_len, prev, copy_len); + + done_len += copy_len; + } + ret = okm; + +err: + OPENSSL_cleanse(prev, sizeof(prev)); + HMAC_CTX_free(hmac); + return ret; +} + +unsigned char *HKDF(const EVP_MD *evp_md, + const unsigned char *salt, size_t salt_len, + const unsigned char *key, size_t key_len, + const unsigned char *info, size_t info_len, + unsigned char *okm, size_t okm_len) +{ + unsigned char prk[EVP_MAX_MD_SIZE]; + unsigned char *ret; + size_t prk_len; + + if (!HKDF_Extract(evp_md, salt, salt_len, key, key_len, prk, &prk_len)) + return NULL; + + ret = HKDF_Expand(evp_md, prk, prk_len, info, info_len, okm, okm_len); + OPENSSL_cleanse(prk, sizeof(prk)); + + return ret; +} diff --git a/protocols/WhatsApp/src/db.h b/protocols/WhatsApp/src/db.h new file mode 100644 index 0000000000..c8cb6e249c --- /dev/null +++ b/protocols/WhatsApp/src/db.h @@ -0,0 +1,43 @@ +/* + +WhatsApp plugin for Miranda NG +Copyright © 2019-22 George Hazan + +*/ + +#define MODULENAME "WhatsApp" + +// DB keys +#define DBKEY_JID "jid" +#define DBKEY_DEVICE_ID "DeviceId" +#define DBKEY_EPHEMERAL_TS "EphemeralTS" +#define DBKEY_EPHEMERAL_EXPIRE "EphemeralExpire" + +#define DBKEY_NOISE_PUB "NoisePublicKey" +#define DBKEY_NOISE_PRIV "NoisePrivateKey" + +#define DBKEY_SIGNED_IDENTITY_PUB "SignedIdentityPublicKey" +#define DBKEY_SIGNED_IDENTITY_PRIV "SignedIdentityPrivateKey" + +#define DBKEY_PREKEY "SignedPreKey0" +#define DBKEY_PREKEY_NEXT_ID "PrekeyNextId" +#define DBKEY_PREKEY_UPLOAD_ID "PrekeyUploadId" + +#define DBKEY_REG_ID "RegistrationId" +#define DBKEY_SECRET_KEY "AdvSecretKey" + +#define DBKEY_NICK "Nick" +#define DBKEY_DEF_GROUP "DefaultGroup" +#define DBKEY_AUTORUNCHATS "AutoRunChats" +#define DBKEY_AVATAR_TAG "AvatarTag" + +#define DBKEY_EVENT_CLIENT_COLBACK "PopupClientColorBack" +#define DBKEY_EVENT_CLIENT_COLTEXT "PopupClientColorText" +#define DBKEY_EVENT_CLIENT_TIMEOUT "PopupClientTimeout" +#define DBKEY_EVENT_CLIENT_DEFAULT "PopupClientColorDefault" + +#define DBKEY_EVENT_OTHER_COLBACK "PopupOtherColorBack" +#define DBKEY_EVENT_OTHER_COLTEXT "PopupOtherColorText" +#define DBKEY_EVENT_OTHER_TIMEOUT "PopupOtherTimeout" +#define DBKEY_EVENT_OTHER_DEFAULT "PopupOtherColorDefault" + diff --git a/protocols/WhatsApp/src/dicts.h b/protocols/WhatsApp/src/dicts.h new file mode 100644 index 0000000000..7b84487d14 --- /dev/null +++ b/protocols/WhatsApp/src/dicts.h @@ -0,0 +1,194 @@ +/* + +WhatsApp plugin for Miranda NG +Copyright © 2019-22 George Hazan + +*/ + +static char *SingleByteTokens[] = { + "", "xmlstreamstart", "xmlstreamend", "s.whatsapp.net", "type", "participant", "from", "receipt", "id", "broadcast", "status", "message", "notification", "notify", "to", "jid", "user", + "class", "offline", "g.us", "result", "mediatype", "enc", "skmsg", "off_cnt", "xmlns", "presence", "participants", "ack", "t", "iq", "device_hash", "read", "value", "media", "picture", + "chatstate", "unavailable", "text", "urn:xmpp:whatsapp:push", "devices", "verified_name", "contact", "composing", "edge_routing", "routing_info", "item", "image", "verified_level", + "get", "fallback_hostname", "2", "media_conn", "1", "v", "handshake", "fallback_class", "count", "config", "offline_preview", "download_buckets", "w:profile:picture", "set", + "creation", "location", "fallback_ip4", "msg", "urn:xmpp:ping", "fallback_ip6", "call-creator", "relaylatency", "success", "subscribe", "video", "business_hours_config", + "platform", "hostname", "version", "unknown", "0", "ping", "hash", "edit", "subject", "max_buckets", "download", "delivery", "props", "sticker", "name", "last", "contacts", + "business", "primary", "preview", "w:p", "pkmsg", "call-id", "retry", "prop", "call", "auth_ttl", "available", "relay_id", "last_id", "day_of_week", "w", "host", "seen", + "bits", "list", "atn", "upload", "is_new", "w:stats", "key", "paused", "specific_hours", "multicast", "stream:error", "mmg.whatsapp.net", "code", "deny", "played", "profile", + "fna", "device-list", "close_time", "latency", "gcm", "pop", "audio", "26", "w:web", "open_time", "error", "auth", "ip4", "update", "profile_options", "config_value", "category", + "catalog_not_created", "00", "config_code", "mode", "catalog_status", "ip6", "blocklist", "registration", "7", "web", "fail", "w:m", "cart_enabled", "ttl", "gif", "300", + "device_orientation", "identity", "query", "401", "media-gig2-1.cdn.whatsapp.net", "in", "3", "te2", "add", "fallback", "categories", "ptt", "encrypt", "notice", + "thumbnail-document", "item-not-found", "12", "thumbnail-image", "stage", "thumbnail-link", "usync", "out", "thumbnail-video", "8", "01", "context", "sidelist", + "thumbnail-gif", "terminate", "not-authorized", "orientation", "dhash", "capability", "side_list", "md-app-state", "description", "serial", "readreceipts", "te", + "business_hours", "md-msg-hist", "tag", "attribute_padding", "document", "open_24h", "delete", "expiration", "active", "prev_v_id", "true", "passive", "index", "4", + "conflict", "remove", "w:gp2", "config_expo_key", "screen_height", "replaced", "02", "screen_width", "uploadfieldstat", "2:47DEQpj8", "media-bog1-1.cdn.whatsapp.net", + "encopt", "url", "catalog_exists", "keygen", "rate", "offer", "opus", "media-mia3-1.cdn.whatsapp.net", "privacy", "media-mia3-2.cdn.whatsapp.net", "signature", + "preaccept", "token_id", "media-eze1-1.cdn.whatsapp.net" +}; + +static char *dict0[] = { + "media-for1-1.cdn.whatsapp.net", "relay", "media-gru2-2.cdn.whatsapp.net", "uncompressed", "medium", "voip_settings", "device", "reason", + "media-lim1-1.cdn.whatsapp.net", "media-qro1-2.cdn.whatsapp.net", "media-gru1-2.cdn.whatsapp.net", "action", "features", "media-gru2-1.cdn.whatsapp.net", + "media-gru1-1.cdn.whatsapp.net", "media-otp1-1.cdn.whatsapp.net", "kyc-id", "priority", "phash", "mute", "token", "100", "media-qro1-1.cdn.whatsapp.net", + "none", "media-mrs2-2.cdn.whatsapp.net", "sign_credential", "03", "media-mrs2-1.cdn.whatsapp.net", "protocol", "timezone", "transport", "eph_setting", "1080", + "original_dimensions", "media-frx5-1.cdn.whatsapp.net", "background", "disable", "original_image_url", "5", "transaction-id", "direct_path", "103", "appointment_only", + "request_image_url", "peer_pid", "address", "105", "104", "102", "media-cdt1-1.cdn.whatsapp.net", "101", "109", "110", "106", "background_location", "v_id", "sync", + "status-old", "111", "107", "ppic", "media-scl2-1.cdn.whatsapp.net", "business_profile", "108", "invite", "04", "audio_duration", "media-mct1-1.cdn.whatsapp.net", + "media-cdg2-1.cdn.whatsapp.net", "media-los2-1.cdn.whatsapp.net", "invis", "net", "voip_payload_type", "status-revoke-delay", "404", "state", "use_correct_order_for_hmac_sha1", + "ver", "media-mad1-1.cdn.whatsapp.net", "order", "540", "skey", "blinded_credential", "android", "contact_remove", "enable_downlink_relay_latency_only", "duration", + "enable_vid_one_way_codec_nego", "6", "media-sof1-1.cdn.whatsapp.net", "accept", "all", "signed_credential", "media-atl3-1.cdn.whatsapp.net", "media-lhr8-1.cdn.whatsapp.net", + "website", "05", "latitude", "media-dfw5-1.cdn.whatsapp.net", "forbidden", "enable_audio_piggyback_network_mtu_fix", "media-dfw5-2.cdn.whatsapp.net", "note.m4r", + "media-atl3-2.cdn.whatsapp.net", "jb_nack_discard_count_fix", "longitude", "Opening.m4r", "media-arn2-1.cdn.whatsapp.net", "email", "timestamp", "admin", + "media-pmo1-1.cdn.whatsapp.net", "America/Sao_Paulo", "contact_add", "media-sin6-1.cdn.whatsapp.net", "interactive", "8000", "acs_public_key", + "sigquit_anr_detector_release_rollover_percent", "media.fmed1-2.fna.whatsapp.net", "groupadd", "enabled_for_video_upgrade", "latency_update_threshold", + "media-frt3-2.cdn.whatsapp.net", "calls_row_constraint_layout", "media.fgbb2-1.fna.whatsapp.net", "mms4_media_retry_notification_encryption_enabled", "timeout", + "media-sin6-3.cdn.whatsapp.net", "audio_nack_jitter_multiplier", "jb_discard_count_adjust_pct_rc", "audio_reserve_bps", "delta", "account_sync", "default", + "media.fjed4-6.fna.whatsapp.net", "06", "lock_video_orientation", "media-frt3-1.cdn.whatsapp.net", "w:g2", "media-sin6-2.cdn.whatsapp.net", "audio_nack_algo_mask", + "media.fgbb2-2.fna.whatsapp.net", "media.fmed1-1.fna.whatsapp.net", "cond_range_target_bitrate", "mms4_server_error_receipt_encryption_enabled", "vid_rc_dyn", "fri", + "cart_v1_1_order_message_changes_enabled", "reg_push", "jb_hist_deposit_value", "privatestats", "media.fist7-2.fna.whatsapp.net", "thu", "jb_discard_count_adjust_pct", + "mon", "group_call_video_maximization_enabled", "mms_cat_v1_forward_hot_override_enabled", "audio_nack_new_rtt", "media.fsub2-3.fna.whatsapp.net", + "media_upload_aggressive_retry_exponential_backoff_enabled", "tue", "wed", "media.fruh4-2.fna.whatsapp.net", "audio_nack_max_seq_req", "max_rtp_audio_packet_resends", + "jb_hist_max_cdf_value", "07", "audio_nack_max_jb_delay", "mms_forward_partially_downloaded_video", "media-lcy1-1.cdn.whatsapp.net", "resume", "jb_inband_fec_aware", + "new_commerce_entry_point_enabled", "480", "payments_upi_generate_qr_amount_limit", "sigquit_anr_detector_rollover_percent", "media.fsdu2-1.fna.whatsapp.net", "fbns", + "aud_pkt_reorder_pct", "dec", "stop_probing_before_accept_send", "media_upload_max_aggressive_retries", "edit_business_profile_new_mode_enabled", + "media.fhex4-1.fna.whatsapp.net", "media.fjed4-3.fna.whatsapp.net", "sigquit_anr_detector_64bit_rollover_percent", "cond_range_ema_jb_last_delay", + "watls_enable_early_data_http_get", "media.fsdu2-2.fna.whatsapp.net", "message_qr_disambiguation_enabled", "media-mxp1-1.cdn.whatsapp.net", "sat", "vertical", + "media.fruh4-5.fna.whatsapp.net", "200", "media-sof1-2.cdn.whatsapp.net", "-1", "height", "product_catalog_hide_show_items_enabled", "deep_copy_frm_last", + "tsoffline", "vp8/h.264", "media.fgye5-3.fna.whatsapp.net", "media.ftuc1-2.fna.whatsapp.net", "smb_upsell_chat_banner_enabled", "canonical", "08", "9", ".", + "media.fgyd4-4.fna.whatsapp.net", "media.fsti4-1.fna.whatsapp.net", "mms_vcache_aggregation_enabled", "mms_hot_content_timespan_in_seconds", "nse_ver", "rte", + "third_party_sticker_web_sync", "cond_range_target_total_bitrate", "media_upload_aggressive_retry_enabled", "instrument_spam_report_enabled", "disable_reconnect_tone", + "move_media_folder_from_sister_app", "one_tap_calling_in_group_chat_size", "10", "storage_mgmt_banner_threshold_mb", "enable_backup_passive_mode", "sharechat_inline_player_enabled", + "media.fcnq2-1.fna.whatsapp.net", "media.fhex4-2.fna.whatsapp.net", "media.fist6-3.fna.whatsapp.net", "ephemeral_drop_column_stage", "reconnecting_after_network_change_threshold_ms", + "media-lhr8-2.cdn.whatsapp.net", "cond_jb_last_delay_ema_alpha", "entry_point_block_logging_enabled", "critical_event_upload_log_config", "respect_initial_bitrate_estimate", + "smaller_image_thumbs_status_enabled", "media.fbtz1-4.fna.whatsapp.net", "media.fjed4-1.fna.whatsapp.net", "width", "720", "enable_frame_dropper", "enable_one_side_mode", + "urn:xmpp:whatsapp:dirty", "new_sticker_animation_behavior_v2", "media.flim3-2.fna.whatsapp.net", "media.fuio6-2.fna.whatsapp.net", "skip_forced_signaling", "dleq_proof", + "status_video_max_bitrate", "lazy_send_probing_req", "enhanced_storage_management", "android_privatestats_endpoint_dit_enabled", "media.fscl13-2.fna.whatsapp.net", "video_duration" +}; + +static char *dict1[] = { + "group_call_discoverability_enabled", "media.faep9-2.fna.whatsapp.net", "msgr", "bloks_loggedin_access_app_id", "db_status_migration_step", "watls_prefer_ip6", + "jabber:iq:privacy", "68", "media.fsaw1-11.fna.whatsapp.net", "mms4_media_conn_persist_enabled", "animated_stickers_thread_clean_up", "media.fcgk3-2.fna.whatsapp.net", + "media.fcgk4-6.fna.whatsapp.net", "media.fgye5-2.fna.whatsapp.net", "media.flpb1-1.fna.whatsapp.net", "media.fsub2-1.fna.whatsapp.net", "media.fuio6-3.fna.whatsapp.net", + "not-allowed", "partial_pjpeg_bw_threshold", "cap_estimated_bitrate", "mms_chatd_resume_check_over_thrift", "smb_upsell_business_profile_enabled", "product_catalog_webclient", + "groups", "sigquit_anr_detector_release_updated_rollout", "syncd_key_rotation_enabled", "media.fdmm2-1.fna.whatsapp.net", "media-hou1-1.cdn.whatsapp.net", + "remove_old_chat_notifications", "smb_biztools_deeplink_enabled", "use_downloadable_filters_int", "group_qr_codes_enabled", "max_receipt_processing_time", + "optimistic_image_processing_enabled", "smaller_video_thumbs_status_enabled", "watls_early_data", "reconnecting_before_relay_failover_threshold_ms", "cond_range_packet_loss_pct", + "groups_privacy_blacklist", "status-revoke-drop", "stickers_animated_thumbnail_download", "dedupe_transcode_shared_images", "dedupe_transcode_shared_videos", + "media.fcnq2-2.fna.whatsapp.net", "media.fgyd4-1.fna.whatsapp.net", "media.fist7-1.fna.whatsapp.net", "media.flim3-3.fna.whatsapp.net", "add_contact_by_qr_enabled", + "https://faq.whatsapp.com/payments", "multicast_limit_global", "sticker_notification_preview", "smb_better_catalog_list_adapters_enabled", "bloks_use_minscript_android", + "pen_smoothing_enabled", "media.fcgk4-5.fna.whatsapp.net", "media.fevn1-3.fna.whatsapp.net", "media.fpoj7-1.fna.whatsapp.net", "media-arn2-2.cdn.whatsapp.net", + "reconnecting_before_network_change_threshold_ms", "android_media_use_fresco_for_gifs", "cond_in_congestion", "status_image_max_edge", "sticker_search_enabled", + "starred_stickers_web_sync", "db_blank_me_jid_migration_step", "media.fist6-2.fna.whatsapp.net", "media.ftuc1-1.fna.whatsapp.net", "09", "anr_fast_logs_upload_rollout", + "camera_core_integration_enabled", "11", "third_party_sticker_caching", "thread_dump_contact_support", "wam_privatestats_enabled", "vcard_as_document_size_kb", "maxfpp", + "fbip", "ephemeral_allow_group_members", "media-bom1-2.cdn.whatsapp.net", "media-xsp1-1.cdn.whatsapp.net", "disable_prewarm", "frequently_forwarded_max", + "media.fbtz1-5.fna.whatsapp.net", "media.fevn7-1.fna.whatsapp.net", "media.fgyd4-2.fna.whatsapp.net", "sticker_tray_animation_fully_visible_items", + "green_alert_banner_duration", "reconnecting_after_p2p_failover_threshold_ms", "connected", "share_biz_vcard_enabled", "stickers_animation", "0a", "1200", "WhatsApp", + "group_description_length", "p_v_id", "payments_upi_intent_transaction_limit", "frequently_forwarded_messages", "media-xsp1-2.cdn.whatsapp.net", + "media.faep8-1.fna.whatsapp.net", "media.faep8-2.fna.whatsapp.net", "media.faep9-1.fna.whatsapp.net", "media.fdmm2-2.fna.whatsapp.net", "media.fgzt3-1.fna.whatsapp.net", + "media.flim4-2.fna.whatsapp.net", "media.frao1-1.fna.whatsapp.net", "media.fscl9-2.fna.whatsapp.net", "media.fsub2-2.fna.whatsapp.net", "superadmin", + "media.fbog10-1.fna.whatsapp.net", "media.fcgh28-1.fna.whatsapp.net", "media.fjdo10-1.fna.whatsapp.net", "third_party_animated_sticker_import", "delay_fec", + "attachment_picker_refresh", "android_linked_devices_re_auth_enabled", "rc_dyn", "green_alert_block_jitter", "add_contact_logging_enabled", "biz_message_logging_enabled", + "conversation_media_preview_v2", "media-jnb1-1.cdn.whatsapp.net", "ab_key", "media.fcgk4-2.fna.whatsapp.net", "media.fevn1-1.fna.whatsapp.net", "media.fist6-1.fna.whatsapp.net", + "media.fruh4-4.fna.whatsapp.net", "media.fsti4-2.fna.whatsapp.net", "mms_vcard_autodownload_size_kb", "watls_enabled", "notif_ch_override_off", "media.fsaw1-14.fna.whatsapp.net", + "media.fscl13-1.fna.whatsapp.net", "db_group_participant_migration_step", "1020", "cond_range_sterm_rtt", "invites_logging_enabled", "triggered_block_enabled", + "group_call_max_participants", "media-iad3-1.cdn.whatsapp.net", "product_catalog_open_deeplink", "shops_required_tos_version", "image_max_kbytes", + "cond_low_quality_vid_mode", "db_receipt_migration_step", "jb_early_prob_hist_shrink", "media.fdmm2-3.fna.whatsapp.net", "media.fdmm2-4.fna.whatsapp.net", + "media.fruh4-1.fna.whatsapp.net", "media.fsaw2-2.fna.whatsapp.net", "remove_geolocation_videos", "new_animation_behavior", "fieldstats_beacon_chance", "403", + "authkey_reset_on_ban", "continuous_ptt_playback", "reconnecting_after_relay_failover_threshold_ms", "false", "group", "sun", "conversation_swipe_to_reply", + "ephemeral_messages_setting", "smaller_video_thumbs_enabled", "md_device_sync_enabled", "bloks_shops_pdp_url_regex", "lasso_integration_enabled", + "media-bom1-1.cdn.whatsapp.net", "new_backup_format_enabled", "256", "media.faep6-1.fna.whatsapp.net", "media.fasr1-1.fna.whatsapp.net", "media.fbtz1-7.fna.whatsapp.net", + "media.fesb4-1.fna.whatsapp.net", "media.fjdo1-2.fna.whatsapp.net", "media.frba2-1.fna.whatsapp.net", "watls_no_dns", "600", "db_broadcast_me_jid_migration_step", + "new_wam_runtime_enabled", "group_update", "enhanced_block_enabled", "sync_wifi_threshold_kb", "mms_download_nc_cat", "bloks_minification_enabled", + "ephemeral_messages_enabled", "reject", "voip_outgoing_xml_signaling", "creator", "dl_bw", "payments_request_messages", "target_bitrate", "bloks_rendercore_enabled", + "media-hbe1-1.cdn.whatsapp.net", "media-hel3-1.cdn.whatsapp.net", "media-kut2-2.cdn.whatsapp.net", "media-lax3-1.cdn.whatsapp.net", "media-lax3-2.cdn.whatsapp.net", + "sticker_pack_deeplink_enabled", "hq_image_bw_threshold", "status_info", "voip", "dedupe_transcode_videos", "grp_uii_cleanup", "linked_device_max_count", + "media.flim1-1.fna.whatsapp.net", "media.fsaw2-1.fna.whatsapp.net", "reconnecting_after_call_active_threshold_ms", "1140", "catalog_pdp_new_design", + "media.fbtz1-10.fna.whatsapp.net", "media.fsaw1-15.fna.whatsapp.net", "0b", "consumer_rc_provider", "mms_async_fast_forward_ttl", "jb_eff_size_fix", + "voip_incoming_xml_signaling", "media_provider_share_by_uuid", "suspicious_links", "dedupe_transcode_images", "green_alert_modal_start", "media-cgk1-1.cdn.whatsapp.net", + "media-lga3-1.cdn.whatsapp.net", "template_doc_mime_types", "important_messages", "user_add", "vcard_max_size_kb", "media.fada2-1.fna.whatsapp.net", + "media.fbog2-5.fna.whatsapp.net", "media.fbtz1-3.fna.whatsapp.net", "media.fcgk3-1.fna.whatsapp.net", "media.fcgk7-1.fna.whatsapp.net", "media.flim1-3.fna.whatsapp.net", + "media.fscl9-1.fna.whatsapp.net", "ctwa_context_enterprise_enabled", "media.fsaw1-13.fna.whatsapp.net", "media.fuio11-2.fna.whatsapp.net", "status_collapse_muted", + "db_migration_level_force", "recent_stickers_web_sync", "bloks_session_state", "bloks_shops_enabled", "green_alert_setting_deep_links_enabled", "restrict_groups", + "battery", "green_alert_block_start", "refresh", "ctwa_context_enabled", "md_messaging_enabled", "status_image_quality", "md_blocklist_v2_server", + "media-del1-1.cdn.whatsapp.net", "13", "userrate", "a_v_id", "cond_rtt_ema_alpha", "invalid" +}; + +static char *dict2[] = { + "media.fada1-1.fna.whatsapp.net", "media.fadb3-2.fna.whatsapp.net", "media.fbhz2-1.fna.whatsapp.net", "media.fcor2-1.fna.whatsapp.net", "media.fjed4-2.fna.whatsapp.net", + "media.flhe4-1.fna.whatsapp.net", "media.frak1-2.fna.whatsapp.net", "media.fsub6-3.fna.whatsapp.net", "media.fsub6-7.fna.whatsapp.net", "media.fvvi1-1.fna.whatsapp.net", + "search_v5_eligible", "wam_real_time_enabled", "report_disk_event", "max_tx_rott_based_bitrate", "product", "media.fjdo10-2.fna.whatsapp.net", "video_frame_crc_sample_interval", + "media_max_autodownload", "15", "h.264", "wam_privatestats_buffer_count", "md_phash_v2_enabled", "account_transfer_enabled", "business_product_catalog", + "enable_non_dyn_codec_param_fix", "is_user_under_epd_jurisdiction", "media.fbog2-4.fna.whatsapp.net", "media.fbtz1-2.fna.whatsapp.net", "media.fcfc1-1.fna.whatsapp.net", + "media.fjed4-5.fna.whatsapp.net", "media.flhe4-2.fna.whatsapp.net", "media.flim1-2.fna.whatsapp.net", "media.flos5-1.fna.whatsapp.net", "android_key_store_auth_ver", + "010", "anr_process_monitor", "delete_old_auth_key", "media.fcor10-3.fna.whatsapp.net", "storage_usage_enabled", "android_camera2_support_level", "dirty", + "consumer_content_provider", "status_video_max_duration", "0c", "bloks_cache_enabled", "media.fadb2-2.fna.whatsapp.net", "media.fbko1-1.fna.whatsapp.net", + "media.fbtz1-9.fna.whatsapp.net", "media.fcgk4-4.fna.whatsapp.net", "media.fesb4-2.fna.whatsapp.net", "media.fevn1-2.fna.whatsapp.net", "media.fist2-4.fna.whatsapp.net", + "media.fjdo1-1.fna.whatsapp.net", "media.fruh4-6.fna.whatsapp.net", "media.fsrg5-1.fna.whatsapp.net", "media.fsub6-6.fna.whatsapp.net", "minfpp", "5000", "locales", + "video_max_bitrate", "use_new_auth_key", "bloks_http_enabled", "heartbeat_interval", "media.fbog11-1.fna.whatsapp.net", "ephemeral_group_query_ts", "fec_nack", + "search_in_storage_usage", "c", "media-amt2-1.cdn.whatsapp.net", "linked_devices_ui_enabled", "14", "async_data_load_on_startup", "voip_incoming_xml_ack", "16", + "db_migration_step", "init_bwe", "max_participants", "wam_buffer_count", "media.fada2-2.fna.whatsapp.net", "media.fadb3-1.fna.whatsapp.net", "media.fcor2-2.fna.whatsapp.net", + "media.fdiy1-2.fna.whatsapp.net", "media.frba3-2.fna.whatsapp.net", "media.fsaw2-3.fna.whatsapp.net", "1280", "status_grid_enabled", "w:biz", "product_catalog_deeplink", + "media.fgye10-2.fna.whatsapp.net", "media.fuio11-1.fna.whatsapp.net", "optimistic_upload", "work_manager_init", "lc", "catalog_message", "cond_net_medium", + "enable_periodical_aud_rr_processing", "cond_range_ema_rtt", "media-tir2-1.cdn.whatsapp.net", "frame_ms", "group_invite_sending", "payments_web_enabled", + "wallpapers_v2", "0d", "browser", "hq_image_max_edge", "image_edit_zoom", "linked_devices_re_auth_enabled", "media.faly3-2.fna.whatsapp.net", + "media.fdoh5-3.fna.whatsapp.net", "media.fesb3-1.fna.whatsapp.net", "media.fknu1-1.fna.whatsapp.net", "media.fmex3-1.fna.whatsapp.net", "media.fruh4-3.fna.whatsapp.net", + "255", "web_upgrade_to_md_modal", "audio_piggyback_timeout_msec", "enable_audio_oob_fec_feature", "from_ip", "image_max_edge", "message_qr_enabled", "powersave", + "receipt_pre_acking", "video_max_edge", "full", "011", "012", "enable_audio_oob_fec_for_sender", "md_voip_enabled", "enable_privatestats", "max_fec_ratio", + "payments_cs_faq_url", "media-xsp1-3.cdn.whatsapp.net", "hq_image_quality", "media.fasr1-2.fna.whatsapp.net", "media.fbog3-1.fna.whatsapp.net", + "media.ffjr1-6.fna.whatsapp.net", "media.fist2-3.fna.whatsapp.net", "media.flim4-3.fna.whatsapp.net", "media.fpbc2-4.fna.whatsapp.net", "media.fpku1-1.fna.whatsapp.net", + "media.frba1-1.fna.whatsapp.net", "media.fudi1-1.fna.whatsapp.net", "media.fvvi1-2.fna.whatsapp.net", "gcm_fg_service", "enable_dec_ltr_size_check", "clear", "lg", + "media.fgru11-1.fna.whatsapp.net", "18", "media-lga3-2.cdn.whatsapp.net", "pkey", "0e", "max_subject", "cond_range_lterm_rtt", "announcement_groups", "biz_profile_options", + "s_t", "media.fabv2-1.fna.whatsapp.net", "media.fcai3-1.fna.whatsapp.net", "media.fcgh1-1.fna.whatsapp.net", "media.fctg1-4.fna.whatsapp.net", "media.fdiy1-1.fna.whatsapp.net", + "media.fisb4-1.fna.whatsapp.net", "media.fpku1-2.fna.whatsapp.net", "media.fros9-1.fna.whatsapp.net", "status_v3_text", "usync_sidelist", "17", "announcement", "...", + "md_group_notification", "0f", "animated_pack_in_store", "013", "America/Mexico_City", "1260", "media-ams4-1.cdn.whatsapp.net", "media-cgk1-2.cdn.whatsapp.net", + "media-cpt1-1.cdn.whatsapp.net", "media-maa2-1.cdn.whatsapp.net", "media.fgye10-1.fna.whatsapp.net", "e", "catalog_cart", "hfm_string_changes", "init_bitrate", + "packless_hsm", "group_info", "America/Belem", "50", "960", "cond_range_bwe", "decode", "encode", "media.fada1-8.fna.whatsapp.net", "media.fadb1-2.fna.whatsapp.net", + "media.fasu6-1.fna.whatsapp.net", "media.fbog4-1.fna.whatsapp.net", "media.fcgk9-2.fna.whatsapp.net", "media.fdoh5-2.fna.whatsapp.net", "media.ffjr1-2.fna.whatsapp.net", + "media.fgua1-1.fna.whatsapp.net", "media.fgye1-1.fna.whatsapp.net", "media.fist1-4.fna.whatsapp.net", "media.fpbc2-2.fna.whatsapp.net", "media.fres2-1.fna.whatsapp.net", + "media.fsdq1-2.fna.whatsapp.net", "media.fsub6-5.fna.whatsapp.net", "profilo_enabled", "template_hsm", "use_disorder_prefetching_timer", "video_codec_priority", + "vpx_max_qp", "ptt_reduce_recording_delay", "25", "iphone", "Windows", "s_o", "Africa/Lagos", "abt", "media-kut2-1.cdn.whatsapp.net", "media-mba1-1.cdn.whatsapp.net", + "media-mxp1-2.cdn.whatsapp.net", "md_blocklist_v2", "url_text", "enable_short_offset", "group_join_permissions", "enable_audio_piggyback_feature", "image_quality", + "media.fcgk7-2.fna.whatsapp.net", "media.fcgk8-2.fna.whatsapp.net", "media.fclo7-1.fna.whatsapp.net", "media.fcmn1-1.fna.whatsapp.net", "media.feoh1-1.fna.whatsapp.net", + "media.fgyd4-3.fna.whatsapp.net", "media.fjed4-4.fna.whatsapp.net", "media.flim1-4.fna.whatsapp.net", "media.flim2-4.fna.whatsapp.net", "media.fplu6-1.fna.whatsapp.net", + "media.frak1-1.fna.whatsapp.net", "media.fsdq1-1.fna.whatsapp.net", "to_ip", "015", "vp8", "19", "21", "1320", "auth_key_ver", "message_processing_dedup", "server-error", + "wap4_enabled", "420", "014", "cond_range_rtt", "ptt_fast_lock_enabled", "media-ort2-1.cdn.whatsapp.net", "fwd_ui_start_ts" +}; + +static char *dict3[] = { + "contact_blacklist", "Asia/Jakarta", "media.fepa10-1.fna.whatsapp.net", "media.fmex10-3.fna.whatsapp.net", "disorder_prefetching_start_when_empty", "America/Bogota", + "use_local_probing_rx_bitrate", "America/Argentina/Buenos_Aires", "cross_post", "media.fabb1-1.fna.whatsapp.net", "media.fbog4-2.fna.whatsapp.net", "media.fcgk9-1.fna.whatsapp.net", + "media.fcmn2-1.fna.whatsapp.net", "media.fdel3-1.fna.whatsapp.net", "media.ffjr1-1.fna.whatsapp.net", "media.fgdl5-1.fna.whatsapp.net", "media.flpb1-2.fna.whatsapp.net", + "media.fmex2-1.fna.whatsapp.net", "media.frba2-2.fna.whatsapp.net", "media.fros2-2.fna.whatsapp.net", "media.fruh2-1.fna.whatsapp.net", "media.fybz2-2.fna.whatsapp.net", + "options", "20", "a", "017", "018", "mute_always", "user_notice", "Asia/Kolkata", "gif_provider", "locked", "media-gua1-1.cdn.whatsapp.net", "piggyback_exclude_force_flush", + "24", "media.frec39-1.fna.whatsapp.net", "user_remove", "file_max_size", "cond_packet_loss_pct_ema_alpha", "media.facc1-1.fna.whatsapp.net", "media.fadb2-1.fna.whatsapp.net", + "media.faly3-1.fna.whatsapp.net", "media.fbdo6-2.fna.whatsapp.net", "media.fcmn2-2.fna.whatsapp.net", "media.fctg1-3.fna.whatsapp.net", "media.ffez1-2.fna.whatsapp.net", + "media.fist1-3.fna.whatsapp.net", "media.fist2-2.fna.whatsapp.net", "media.flim2-2.fna.whatsapp.net", "media.fmct2-3.fna.whatsapp.net", "media.fpei3-1.fna.whatsapp.net", + "media.frba3-1.fna.whatsapp.net", "media.fsdu8-2.fna.whatsapp.net", "media.fstu2-1.fna.whatsapp.net", "media_type", "receipt_agg", "016", "enable_pli_for_crc_mismatch", + "live", "enc_rekey", "frskmsg", "d", "media.fdel11-2.fna.whatsapp.net", "proto", "2250", "audio_piggyback_enable_cache", "skip_nack_if_ltrp_sent", "mark_dtx_jb_frames", + "web_service_delay", "7282", "catalog_send_all", "outgoing", "360", "30", "LIMITED", "019", "audio_picker", "bpv2_phase", "media.fada1-7.fna.whatsapp.net", + "media.faep7-1.fna.whatsapp.net", "media.fbko1-2.fna.whatsapp.net", "media.fbni1-2.fna.whatsapp.net", "media.fbtz1-1.fna.whatsapp.net", "media.fbtz1-8.fna.whatsapp.net", + "media.fcjs3-1.fna.whatsapp.net", "media.fesb3-2.fna.whatsapp.net", "media.fgdl5-4.fna.whatsapp.net", "media.fist2-1.fna.whatsapp.net", "media.flhe2-2.fna.whatsapp.net", + "media.flim2-1.fna.whatsapp.net", "media.fmex1-1.fna.whatsapp.net", "media.fpat3-2.fna.whatsapp.net", "media.fpat3-3.fna.whatsapp.net", "media.fros2-1.fna.whatsapp.net", + "media.fsdu8-1.fna.whatsapp.net", "media.fsub3-2.fna.whatsapp.net", "payments_chat_plugin", "cond_congestion_no_rtcp_thr", "green_alert", "not-a-biz", "..", + "shops_pdp_urls_config", "source", "media-dus1-1.cdn.whatsapp.net", "mute_video", "01b", "currency", "max_keys", "resume_check", "contact_array", "qr_scanning", "23", + "b", "media.fbfh15-1.fna.whatsapp.net", "media.flim22-1.fna.whatsapp.net", "media.fsdu11-1.fna.whatsapp.net", "media.fsdu15-1.fna.whatsapp.net", "Chrome", "fts_version", + "60", "media.fada1-6.fna.whatsapp.net", "media.faep4-2.fna.whatsapp.net", "media.fbaq5-1.fna.whatsapp.net", "media.fbni1-1.fna.whatsapp.net", "media.fcai3-2.fna.whatsapp.net", + "media.fdel3-2.fna.whatsapp.net", "media.fdmm3-2.fna.whatsapp.net", "media.fhex3-1.fna.whatsapp.net", "media.fisb4-2.fna.whatsapp.net", "media.fkhi5-2.fna.whatsapp.net", + "media.flos2-1.fna.whatsapp.net", "media.fmct2-1.fna.whatsapp.net", "media.fntr7-1.fna.whatsapp.net", "media.frak3-1.fna.whatsapp.net", "media.fruh5-2.fna.whatsapp.net", + "media.fsub6-1.fna.whatsapp.net", "media.fuab1-2.fna.whatsapp.net", "media.fuio1-1.fna.whatsapp.net", "media.fver1-1.fna.whatsapp.net", "media.fymy1-1.fna.whatsapp.net", + "product_catalog", "1380", "audio_oob_fec_max_pkts", "22", "254", "media-ort2-2.cdn.whatsapp.net", "media-sjc3-1.cdn.whatsapp.net", "1600", "01a", "01c", "405", + "key_frame_interval", "body", "media.fcgh20-1.fna.whatsapp.net", "media.fesb10-2.fna.whatsapp.net", "125", "2000", "media.fbsb1-1.fna.whatsapp.net", + "media.fcmn3-2.fna.whatsapp.net", "media.fcpq1-1.fna.whatsapp.net", "media.fdel1-2.fna.whatsapp.net", "media.ffor2-1.fna.whatsapp.net", "media.fgdl1-4.fna.whatsapp.net", + "media.fhex2-1.fna.whatsapp.net", "media.fist1-2.fna.whatsapp.net", "media.fjed5-2.fna.whatsapp.net", "media.flim6-4.fna.whatsapp.net", "media.flos2-2.fna.whatsapp.net", + "media.fntr6-2.fna.whatsapp.net", "media.fpku3-2.fna.whatsapp.net", "media.fros8-1.fna.whatsapp.net", "media.fymy1-2.fna.whatsapp.net", "ul_bw", "ltrp_qp_offset", + "request", "nack", "dtx_delay_state_reset", "timeoffline", "28", "01f", "32", "enable_ltr_pool", "wa_msys_crypto", "01d", "58", "dtx_freeze_hg_update", + "nack_if_rpsi_throttled", "253", "840", "media.famd15-1.fna.whatsapp.net", "media.fbog17-2.fna.whatsapp.net", "media.fcai19-2.fna.whatsapp.net", "media.fcai21-4.fna.whatsapp.net", + "media.fesb10-4.fna.whatsapp.net", "media.fesb10-5.fna.whatsapp.net", "media.fmaa12-1.fna.whatsapp.net", "media.fmex11-3.fna.whatsapp.net", "media.fpoa33-1.fna.whatsapp.net", + "1050", "021", "clean", "cond_range_ema_packet_loss_pct", "media.fadb6-5.fna.whatsapp.net", "media.faqp4-1.fna.whatsapp.net", "media.fbaq3-1.fna.whatsapp.net", + "media.fbel2-1.fna.whatsapp.net", "media.fblr4-2.fna.whatsapp.net", "media.fclo8-1.fna.whatsapp.net", "media.fcoo1-2.fna.whatsapp.net", "media.ffjr1-4.fna.whatsapp.net", + "media.ffor9-1.fna.whatsapp.net", "media.fisb3-1.fna.whatsapp.net", "media.fkhi2-2.fna.whatsapp.net", "media.fkhi4-1.fna.whatsapp.net", "media.fpbc1-2.fna.whatsapp.net", + "media.fruh2-2.fna.whatsapp.net", "media.fruh5-1.fna.whatsapp.net", "media.fsub3-1.fna.whatsapp.net", "payments_transaction_limit", "252", "27", "29", "tintagel", "01e", + "237", "780", "callee_updated_payload", "020", "257", "price", "025", "239", "payments_cs_phone_number", "mediaretry", "w:auth:backup:token", "Glass.caf", "max_bitrate", + "240", "251", "660", "media.fbog16-1.fna.whatsapp.net", "media.fcgh21-1.fna.whatsapp.net", "media.fkul19-2.fna.whatsapp.net", "media.flim21-2.fna.whatsapp.net", + "media.fmex10-4.fna.whatsapp.net", "64", "33", "34", "35", "interruption", "media.fabv3-1.fna.whatsapp.net", "media.fadb6-1.fna.whatsapp.net", "media.fagr1-1.fna.whatsapp.net", + "media.famd1-1.fna.whatsapp.net", "media.famm6-1.fna.whatsapp.net", "media.faqp2-3.fna.whatsapp.net" +}; diff --git a/protocols/WhatsApp/src/iq.cpp b/protocols/WhatsApp/src/iq.cpp new file mode 100644 index 0000000000..9daff6b6ba --- /dev/null +++ b/protocols/WhatsApp/src/iq.cpp @@ -0,0 +1,709 @@ +/* + +WhatsApp plugin for Miranda NG +Copyright © 2019-22 George Hazan + +*/ + +#include "stdafx.h" + +void WhatsAppProto::OnAccountSync(const WANode &node) +{ + m_arDevices.destroy(); + + for (auto &it : node.getChild("devices")->getChildren()) + if (it->title == "device") + m_arDevices.insert(new WADevice(it->getAttr("jid"), it->getAttrInt("key-index"))); +} + +///////////////////////////////////////////////////////////////////////////////////////// + +void WhatsAppProto::OnIqBlockList(const WANode &node) +{ + for (auto &it : node.getChild("list")->getChildren()) { + auto *pUser = AddUser(it->getAttr("jid"), false); + Contact::Hide(pUser->hContact); + } +} + +///////////////////////////////////////////////////////////////////////////////////////// + +void WhatsAppProto::OnIqCountPrekeys(const WANode &node) +{ + int iCount = node.getChild("count")->getAttrInt("value"); + if (iCount < 5) + UploadMorePrekeys(); +} + +void WhatsAppProto::UploadMorePrekeys() +{ + WANodeIq iq(IQ::SET, "encrypt"); + + auto regId = encodeBigEndian(getDword(DBKEY_REG_ID)); + iq.addChild("registration")->content.append(regId.c_str(), regId.size()); + + iq.addChild("type")->content.append(KEY_BUNDLE_TYPE, 1); + iq.addChild("identity")->content.append(m_signalStore.signedIdentity.pub); + + const int PORTION = 10; + m_signalStore.generatePrekeys(PORTION); + + int iStart = getDword(DBKEY_PREKEY_UPLOAD_ID, 1); + auto *n = iq.addChild("list"); + for (int i = 0; i < PORTION; i++) { + auto *nKey = n->addChild("key"); + + int keyId = iStart + i; + auto encId = encodeBigEndian(keyId, 3); + nKey->addChild("id")->content.append(encId.c_str(), encId.size()); + nKey->addChild("value")->content.append(getBlob(CMStringA(FORMAT, "PreKey%dPublic", keyId))); + } + setDword(DBKEY_PREKEY_UPLOAD_ID, iStart + PORTION); + + auto *skey = iq.addChild("skey"); + + auto encId = encodeBigEndian(m_signalStore.preKey.keyid, 3); + skey->addChild("id")->content.append(encId.c_str(), encId.size()); + skey->addChild("value")->content.append(m_signalStore.preKey.pub); + skey->addChild("signature")->content.append(m_signalStore.preKey.signature); + + WSSendNode(iq, &WhatsAppProto::OnIqDoNothing); +} + +///////////////////////////////////////////////////////////////////////////////////////// + +void WhatsAppProto::OnIqDoNothing(const WANode &) +{ +} + +///////////////////////////////////////////////////////////////////////////////////////// + +void WhatsAppProto::OnNotifyEncrypt(const WANode &node) +{ + auto *pszFrom = node.getAttr("from"); + if (!mir_strcmp(pszFrom, S_WHATSAPP_NET)) { + + } +} + +///////////////////////////////////////////////////////////////////////////////////////// + +void WhatsAppProto::OnReceiveInfo(const WANode &node) +{ + if (auto *pChild = node.getFirstChild()) { + if (pChild->title == "offline") + debugLogA("Processed %d offline events", pChild->getAttrInt("count")); + } +} + +///////////////////////////////////////////////////////////////////////////////////////// + +void WhatsAppProto::OnReceiveMessage(const WANode &node) +{ + auto *msgId = node.getAttr("id"); + auto *msgType = node.getAttr("type"); + auto *msgFrom = node.getAttr("from"); + auto *category = node.getAttr("category"); + auto *recipient = node.getAttr("recipient"); + auto *participant = node.getAttr("participant"); + + if (msgType == nullptr || msgFrom == nullptr || msgId == nullptr) { + debugLogA("bad message received: <%s> <%s> <%s>", msgType, msgFrom, msgId); + return; + } + + WAMSG type; + WAJid jid(msgFrom); + CMStringA szAuthor, szChatId; + + if (node.getAttr("offline")) + type.bOffline = true; + + // message from one user to another + if (jid.isUser()) { + if (recipient) { + if (m_szJid != msgFrom) { + debugLogA("strange message: with recipient, but not from me"); + return; + } + szChatId = recipient; + } + else szChatId = msgFrom; + + type.bPrivateChat = true; + szAuthor = msgFrom; + } + else if (jid.isGroup()) { + if (!participant) { + debugLogA("strange message: from group, but without participant"); + return; + } + + type.bGroupChat = true; + szAuthor = participant; + szChatId = msgFrom; + } + else if (jid.isBroadcast()) { + if (!participant) { + debugLogA("strange message: from group, but without participant"); + return; + } + + bool bIsMe = m_szJid == participant; + if (jid.isStatusBroadcast()) { + if (bIsMe) + type.bDirectStatus = true; + else + type.bOtherStatus = true; + } + else { + if (bIsMe) + type.bPeerBroadcast = true; + else + type.bOtherBroadcast = true; + } + szChatId = msgFrom; + szAuthor = participant; + } + else { + debugLogA("invalid message type"); + return; + } + + CMStringA szSender = (type.bPrivateChat) ? szAuthor : szChatId; + bool bFromMe = (m_szJid == msgFrom); + if (!bFromMe && participant) + bFromMe = m_szJid == participant; + + auto *pKey = new proto::MessageKey(); + pKey->set_remotejid(szChatId); + pKey->set_id(msgId); + pKey->set_fromme(bFromMe); + if (participant) + pKey->set_participant(participant); + + proto::WebMessageInfo msg; + msg.set_allocated_key(pKey); + msg.set_messagetimestamp(_atoi64(node.getAttr("t"))); + msg.set_pushname(node.getAttr("notify")); + if (bFromMe) + msg.set_status(proto::WebMessageInfo_Status_SERVER_ACK); + + int iDecryptable = 0; + + for (auto &it: node.getChildren()) { + if (it->title == "verified_name") { + proto::VerifiedNameCertificate cert; + cert << it->content; + + proto::VerifiedNameCertificate::Details details; + details.ParseFromString(cert.details()); + + msg.set_verifiedbizname(details.verifiedname()); + continue; + } + + if (it->title != "enc" || it->content.length() == 0) + continue; + + SignalBuffer msgBody; + auto *pszType = it->getAttr("type"); + try { + if (!mir_strcmp(pszType, "pkmsg") || !mir_strcmp(pszType, "msg")) { + CMStringA szUser = (WAJid(szSender).isUser()) ? szSender : szAuthor; + msgBody = m_signalStore.decryptSignalProto(szUser, pszType, it->content); + } + else if (!mir_strcmp(pszType, "skmsg")) { + msgBody = m_signalStore.decryptGroupSignalProto(szSender, szAuthor, it->content); + } + else throw "Invalid e2e type"; + + if (!msgBody) + throw "Invalid e2e message"; + + iDecryptable++; + + // remove message padding + if (size_t len = msgBody.len()) { + size_t c = msgBody.data()[len - 1]; + if (c < len) + msgBody.reset(len - c); + } + + proto::Message encMsg; + encMsg.ParseFromArray(msgBody.data(), msgBody.len()); + if (encMsg.devicesentmessage().has_message()) + msg.set_allocated_message(new proto::Message(encMsg.devicesentmessage().message())); + else + msg.set_allocated_message(new proto::Message(encMsg)); + + if (encMsg.has_senderkeydistributionmessage()) + m_signalStore.processSenderKeyMessage(encMsg.senderkeydistributionmessage()); + + ProcessMessage(type, msg); + msg.clear_message(); + + // send receipt + const char *pszReceiptType = nullptr, *pszReceiptTo = participant; + if (!mir_strcmp(category, "peer")) + pszReceiptType = "peer_msg"; + else if (bFromMe) { + // message was sent by me from a different device + pszReceiptType = "sender"; + if (WAJid(szChatId).isUser()) + pszReceiptTo = szAuthor; + } + else if (!m_hServerConn) + pszReceiptType = "inactive"; + + SendReceipt(szChatId, pszReceiptTo, msgId, pszReceiptType); + } + catch (const char *pszError) { + debugLogA("Message cannot be parsed: %s", pszError); + } + + if (!iDecryptable) { + debugLogA("Nothing to decrypt"); + return; + } + } +} + +///////////////////////////////////////////////////////////////////////////////////////// + +void WhatsAppProto::OnStreamError(const WANode &node) +{ + m_bTerminated = true; + + if (auto *pszCode = node.getAttr("code")) { + switch (atoi(pszCode)) { + case 401: + debugLogA("Connection logged out from another device, exiting"); + break; + + case 408: + debugLogA("Connection lost, exiting"); + break; + + case 411: + debugLogA("Conflict between two devices, exiting"); + break; + + case 428: + debugLogA("Connection forcibly closed by the server, exiting"); + break; + + case 440: + debugLogA("Connection replaced from another device, exiting"); + break; + + case 515: + debugLogA("Server required to restart immediately, leaving thread"); + m_bRespawn = true; + break; + } + } +} + +///////////////////////////////////////////////////////////////////////////////////////// + +void WhatsAppProto::OnIqResult(const WANode &node) +{ + if (auto *pszId = node.getAttr("id")) + for (auto &it: m_arPacketQueue) + if (it->szPacketId == pszId) + (this->*it->pHandler)(node); +} + +///////////////////////////////////////////////////////////////////////////////////////// + +void WhatsAppProto::OnIqPairDevice(const WANode &node) +{ + WSSendNode(WANodeIq(IQ::RESULT) << CHAR_PARAM("id", node.getAttr("id"))); + + if (auto *pRef = node.getChild("pair-device")->getChild("ref")) { + ShowQrCode(pRef->getBody()); + } + else { + debugLogA("OnIqPairDevice: got reply without ref, exiting"); + ShutdownSession(); + } +} + +void WhatsAppProto::OnIqPairSuccess(const WANode &node) +{ + CloseQrDialog(); + + auto *pRoot = node.getChild("pair-success"); + + try { + if (auto *pPlatform = pRoot->getChild("platform")) + debugLogA("Got response from platform: %s", pPlatform->getBody().c_str()); + + if (auto *pBiz = pRoot->getChild("biz")) + if (auto *pszName = pBiz->getAttr("name")) + setUString("Nick", pszName); + + if (auto *pDevice = pRoot->getChild("device")) { + if (auto *pszJid = pDevice->getAttr("jid")) { + WAJid jid(pszJid); + m_szJid = jid.user + "@" + jid.server; + setUString(DBKEY_JID, m_szJid); + setDword(DBKEY_DEVICE_ID, jid.device); + } + } + else throw "OnIqPairSuccess: got reply without device info, exiting"; + + if (auto *pIdentity = pRoot->getChild("device-identity")) { + proto::ADVSignedDeviceIdentityHMAC payload; + if (!payload.ParseFromArray(pIdentity->content.data(), (int)pIdentity->content.length())) + throw "OnIqPairSuccess: got reply with invalid identity, exiting"; + + auto &hmac = payload.hmac(); + auto &details = payload.details(); + { + // check details signature using HMAC + uint8_t signature[32]; + unsigned int out_len = sizeof(signature); + MBinBuffer secret(getBlob(DBKEY_SECRET_KEY)); + HMAC(EVP_sha256(), secret.data(), (int)secret.length(), (BYTE *)details.c_str(), (int)details.size(), signature, &out_len); + if (memcmp(hmac.c_str(), signature, sizeof(signature))) + throw "OnIqPairSuccess: got reply with invalid details signature, exiting"; + } + + proto::ADVSignedDeviceIdentity account; + if (!account.ParseFromString(details)) + throw "OnIqPairSuccess: got reply with invalid account, exiting"; + + auto &deviceDetails = account.details(); + auto &accountSignature = account.accountsignature(); + auto &accountSignatureKey = account.accountsignaturekey(); + { + MBinBuffer buf; + buf.append("\x06\x00", 2); + buf.append(deviceDetails.c_str(), deviceDetails.size()); + buf.append(m_signalStore.signedIdentity.pub); + + ec_public_key key = {}; + memcpy(key.data, accountSignatureKey.c_str(), sizeof(key.data)); + if (1 != curve_verify_signature(&key, (BYTE *)buf.data(), buf.length(), (BYTE *)accountSignature.c_str(), accountSignature.size())) + throw "OnIqPairSuccess: got reply with invalid account signature, exiting"; + } + debugLogA("Received valid account signature"); + { + MBinBuffer buf; + buf.append("\x06\x01", 2); + buf.append(deviceDetails.c_str(), deviceDetails.size()); + buf.append(m_signalStore.signedIdentity.pub); + buf.append(accountSignatureKey.c_str(), accountSignatureKey.size()); + + signal_buffer *result; + ec_private_key key = {}; + memcpy(key.data, m_signalStore.signedIdentity.priv.data(), m_signalStore.signedIdentity.priv.length()); + if (curve_calculate_signature(m_signalStore.CTX(), &result, &key, (BYTE *)buf.data(), buf.length()) != 0) + throw "OnIqPairSuccess: cannot calculate account signature, exiting"; + + account.set_devicesignature(result->data, result->len); + signal_buffer_free(result); + } + + setDword("SignalDeviceId", 0); + { + MBinBuffer key; + if (accountSignatureKey.size() == 32) + key.append(KEY_BUNDLE_TYPE, 1); + key.append(accountSignatureKey.c_str(), accountSignatureKey.size()); + db_set_blob(0, m_szModuleName, "SignalIdentifierKey", key.data(), (int)key.length()); + } + + account.clear_accountsignaturekey(); + + MBinBuffer accountEnc(account.ByteSize()); + account.SerializeToArray(accountEnc.data(), (int)accountEnc.length()); + db_set_blob(0, m_szModuleName, "WAAccount", accountEnc.data(), (int)accountEnc.length()); + + proto::ADVDeviceIdentity deviceIdentity; + deviceIdentity.ParseFromString(deviceDetails); + + WANodeIq reply(IQ::RESULT); reply << CHAR_PARAM("id", node.getAttr("id")); + + WANode *nodePair = reply.addChild("pair-device-sign"); + + WANode *nodeDeviceIdentity = nodePair->addChild("device-identity"); + nodeDeviceIdentity->addAttr("key-index", deviceIdentity.keyindex()); + nodeDeviceIdentity->content.append(accountEnc.data(), accountEnc.length()); + WSSendNode(reply); + } + else throw "OnIqPairSuccess: got reply without identity, exiting"; + } + catch (const char *pErrMsg) { + debugLogA(pErrMsg); + ShutdownSession(); + } +} + +///////////////////////////////////////////////////////////////////////////////////////// + +void WhatsAppProto::OnProcessHandshake(const void *pData, int cbLen) +{ + proto::HandshakeMessage msg; + if (!msg.ParseFromArray(pData, cbLen)) { + debugLogA("Error parsing data, exiting"); + +LBL_Error: + ShutdownSession(); + return; + } + + auto &static_ = msg.serverhello().static_(); + auto &payload_ = msg.serverhello().payload(); + auto &ephemeral_ = msg.serverhello().ephemeral(); + + m_noise->updateHash(ephemeral_.c_str(), ephemeral_.size()); + m_noise->mixIntoKey(m_noise->ephemeral.priv.data(), ephemeral_.c_str()); + + MBinBuffer decryptedStatic = m_noise->decrypt(static_.c_str(), static_.size()); + m_noise->mixIntoKey(m_noise->ephemeral.priv.data(), decryptedStatic.data()); + + MBinBuffer decryptedCert = m_noise->decrypt(payload_.c_str(), payload_.size()); + + proto::CertChain cert; cert.ParseFromArray(decryptedCert.data(), (int)decryptedCert.length()); + proto::CertChain::NoiseCertificate::Details details; details.ParseFromString(cert.intermediate().details()); + if (details.issuerserial() != 0) { + debugLogA("Invalid certificate serial number, exiting"); + goto LBL_Error; + } + + MBinBuffer encryptedPub = m_noise->encrypt(m_noise->noiseKeys.pub.data(), m_noise->noiseKeys.pub.length()); + m_noise->mixIntoKey(m_noise->noiseKeys.priv.data(), ephemeral_.c_str()); + + // create reply + proto::ClientPayload node; + + MFileVersion v; + Miranda_GetFileVersion(&v); + + // not received our jid from server? generate registration packet then + if (m_szJid.IsEmpty()) { + uint8_t appVersion[16]; + mir_md5_hash((BYTE *)APP_VERSION, sizeof(APP_VERSION) - 1, appVersion); + + auto *pAppVersion = new proto::DeviceProps_AppVersion(); + pAppVersion->set_primary(v[0]); + pAppVersion->set_secondary(v[1]); + pAppVersion->set_tertiary(v[2]); + pAppVersion->set_quaternary(v[3]); + + proto::DeviceProps pCompanion; + pCompanion.set_os("Miranda"); + pCompanion.set_allocated_version(pAppVersion); + pCompanion.set_platformtype(proto::DeviceProps_PlatformType_DESKTOP); + pCompanion.set_requirefullsync(false); + + MBinBuffer buf(pCompanion.ByteSize()); + pCompanion.SerializeToArray(buf.data(), (int)buf.length()); + + auto *pPairingData = new proto::ClientPayload_DevicePairingRegistrationData(); + pPairingData->set_deviceprops(buf.data(), buf.length()); + pPairingData->set_buildhash(appVersion, sizeof(appVersion)); + pPairingData->set_eregid(encodeBigEndian(getDword(DBKEY_REG_ID))); + pPairingData->set_ekeytype(KEY_BUNDLE_TYPE); + pPairingData->set_eident(m_signalStore.signedIdentity.pub.data(), m_signalStore.signedIdentity.pub.length()); + pPairingData->set_eskeyid(encodeBigEndian(m_signalStore.preKey.keyid)); + pPairingData->set_eskeyval(m_signalStore.preKey.pub.data(), m_signalStore.preKey.pub.length()); + pPairingData->set_eskeysig(m_signalStore.preKey.signature.data(), m_signalStore.preKey.signature.length()); + node.set_allocated_devicepairingdata(pPairingData); + + node.set_passive(false); + } + // generate login packet + else { + WAJid jid(m_szJid); + node.set_username(_atoi64(jid.user)); + node.set_device(getDword(DBKEY_DEVICE_ID)); + node.set_passive(true); + } + + auto *pUserVersion = new proto::ClientPayload_UserAgent_AppVersion(); + pUserVersion->set_primary(2); + pUserVersion->set_secondary(2230); + pUserVersion->set_tertiary(15); + + auto *pUserAgent = new proto::ClientPayload_UserAgent(); + pUserAgent->set_allocated_appversion(pUserVersion); + pUserAgent->set_platform(proto::ClientPayload_UserAgent_Platform_WEB); + pUserAgent->set_releasechannel(proto::ClientPayload_UserAgent_ReleaseChannel_RELEASE); + pUserAgent->set_mcc("000"); + pUserAgent->set_mnc("000"); + pUserAgent->set_osversion("0.1"); + pUserAgent->set_osbuildnumber("0.1"); + pUserAgent->set_manufacturer(""); + pUserAgent->set_device("Desktop"); + pUserAgent->set_localelanguageiso6391("en"); + pUserAgent->set_localecountryiso31661alpha2("US"); + + auto *pWebInfo = new proto::ClientPayload_WebInfo(); + pWebInfo->set_websubplatform(proto::ClientPayload_WebInfo_WebSubPlatform_WEB_BROWSER); + + node.set_connecttype(proto::ClientPayload_ConnectType_WIFI_UNKNOWN); + node.set_connectreason(proto::ClientPayload_ConnectReason_USER_ACTIVATED); + node.set_allocated_useragent(pUserAgent); + node.set_allocated_webinfo(pWebInfo); + + MBinBuffer payload(node.ByteSize()); + node.SerializeToArray(payload.data(), (int)payload.length()); + + MBinBuffer payloadEnc = m_noise->encrypt(payload.data(), payload.length()); + + auto *pFinish = new proto::HandshakeMessage_ClientFinish(); + pFinish->set_payload(payloadEnc.data(), payloadEnc.length()); + pFinish->set_static_(encryptedPub.data(), encryptedPub.length()); + + proto::HandshakeMessage handshake; + handshake.set_allocated_clientfinish(pFinish); + WSSend(handshake); + + m_noise->finish(); +} + +///////////////////////////////////////////////////////////////////////////////////////// + +void WhatsAppProto::OnServerSync(const WANode &node) +{ + OBJLIST task(1); + + for (auto &it : node.getChildren()) + if (it->title == "collection") + task.insert(new WACollection(it->getAttr("name"), it->getAttrInt("version"))); + + ResyncServer(task); +} + +void WhatsAppProto::ResyncServer(const OBJLIST &task) +{ + WANodeIq iq(IQ::SET, "w:sync:app:state"); + + auto *pList = iq.addChild("sync"); + for (auto &it : task) { + auto *pCollection = m_arCollections.find(it); + if (pCollection == nullptr) + m_arCollections.insert(pCollection = new WACollection(it->szName, 0)); + + if (pCollection->version < it->version) { + auto *pNode = pList->addChild("collection"); + *pNode << CHAR_PARAM("name", it->szName) << INT_PARAM("version", pCollection->version) + << CHAR_PARAM("return_snapshot", (!pCollection->version) ? "true" : "false"); + } + } + + if (pList->getFirstChild() != nullptr) + WSSendNode(iq, &WhatsAppProto::OnIqServerSync); +} + +void WhatsAppProto::OnIqServerSync(const WANode &node) +{ + for (auto &coll : node.getChild("sync")->getChildren()) { + if (coll->title != "collection") + continue; + + auto *pszName = coll->getAttr("name"); + + auto *pCollection = FindCollection(pszName); + if (pCollection == nullptr) { + pCollection = new WACollection(pszName, 0); + m_arCollections.insert(pCollection); + } + + int dwVersion = 0; + + CMStringW wszSnapshotPath(GetTmpFileName("collection", pszName)); + if (auto *pSnapshot = coll->getChild("snapshot")) { + proto::ExternalBlobReference body; + body << pSnapshot->content; + if (!body.has_directpath() || !body.has_mediakey()) { + debugLogA("Invalid snapshot data, skipping"); + continue; + } + + MBinBuffer buf = DownloadEncryptedFile(directPath2url(body.directpath().c_str()), body.mediakey(), "App State"); + if (!buf.data()) { + debugLogA("Invalid downloaded snapshot data, skipping"); + continue; + } + + proto::SyncdSnapshot snapshot; + snapshot << buf; + + dwVersion = snapshot.version().version(); + if (dwVersion > pCollection->version) { + auto &hash = snapshot.mac(); + pCollection->hash.assign(hash.c_str(), hash.size()); + + for (auto &it : snapshot.records()) + pCollection->parseRecord(it, true); + } + } + + if (auto *pPatchList = coll->getChild("patches")) { + for (auto &it : pPatchList->getChildren()) { + proto::SyncdPatch patch; + patch << it->content; + + dwVersion = patch.version().version(); + if (dwVersion > pCollection->version) + for (auto &jt : patch.mutations()) + pCollection->parseRecord(jt.record(), jt.operation() == proto::SyncdMutation_SyncdOperation::SyncdMutation_SyncdOperation_SET); + } + } + + CMStringA szSetting(FORMAT, "Collection_%s", pszName); + // setDword(szSetting, dwVersion); + + JSONNode jsonRoot, jsonMap; + for (auto &it : pCollection->indexValueMap) + jsonMap << CHAR_PARAM(ptrA(mir_base64_encode(it.first.c_str(), it.first.size())), ptrA(mir_base64_encode(it.second.c_str(), it.second.size()))); + jsonRoot << INT_PARAM("version", dwVersion) << JSON_PARAM("indexValueMap", jsonMap); + + // string2file(jsonRoot.write(), GetTmpFileName("collection", CMStringA(pszName) + ".json")); + } +} + +void WACollection::parseRecord(const ::proto::SyncdRecord &rec, bool bSet) +{ + // auto &id = rec.keyid().id(); + auto &index = rec.index().blob(); + auto &value = rec.value().blob(); + + if (bSet) { + indexValueMap[index] = value.substr(0, value.size() - 32); + } + else indexValueMap.erase(index); +} + +///////////////////////////////////////////////////////////////////////////////////////// + +void WhatsAppProto::OnSuccess(const WANode &) +{ + OnLoggedIn(); + + WSSendNode(WANodeIq(IQ::SET, "passive") << XCHILD("active"), &WhatsAppProto::OnIqDoNothing); +} + +///////////////////////////////////////////////////////////////////////////////////////// + +void WhatsAppProto::InitPersistentHandlers() +{ + m_arPersistent.insert(new WAPersistentHandler("iq", "set", "md", "pair-device", &WhatsAppProto::OnIqPairDevice)); + m_arPersistent.insert(new WAPersistentHandler("iq", "set", "md", "pair-success", &WhatsAppProto::OnIqPairSuccess)); + + m_arPersistent.insert(new WAPersistentHandler("notification", "encrypt", 0, 0, &WhatsAppProto::OnNotifyEncrypt)); + m_arPersistent.insert(new WAPersistentHandler("notification", "account_sync", 0, 0, &WhatsAppProto::OnAccountSync)); + m_arPersistent.insert(new WAPersistentHandler("notification", "server_sync", 0, 0, &WhatsAppProto::OnServerSync)); + + m_arPersistent.insert(new WAPersistentHandler("ib", 0, 0, 0, &WhatsAppProto::OnReceiveInfo)); + m_arPersistent.insert(new WAPersistentHandler("message", 0, 0, 0, &WhatsAppProto::OnReceiveMessage)); + m_arPersistent.insert(new WAPersistentHandler("stream:error", 0, 0, 0, &WhatsAppProto::OnStreamError)); + m_arPersistent.insert(new WAPersistentHandler("success", 0, 0, 0, &WhatsAppProto::OnSuccess)); + + m_arPersistent.insert(new WAPersistentHandler(0, "result", 0, 0, &WhatsAppProto::OnIqResult)); +} diff --git a/protocols/WhatsApp/src/main.cpp b/protocols/WhatsApp/src/main.cpp new file mode 100644 index 0000000000..e166fc73c3 --- /dev/null +++ b/protocols/WhatsApp/src/main.cpp @@ -0,0 +1,69 @@ +/* + +WhatsApp plugin for Miranda NG +Copyright © 2019-22 George Hazan + +*/ + +#include "stdafx.h" +#include "version.h" + +#ifdef _DEBUG +#pragma comment(lib, "libprotobufd.lib") +#else +#pragma comment(lib, "libprotobuf.lib") +#endif + +CMPlugin g_plugin; + +PLUGININFOEX pluginInfo = { + sizeof(PLUGININFOEX), + __PLUGIN_NAME, + PLUGIN_MAKE_VERSION(__MAJOR_VERSION, __MINOR_VERSION, __RELEASE_NUM, __BUILD_NUM), + __DESCRIPTION, + __AUTHOR, + __AUTHOREMAIL, + __COPYRIGHT, + UNICODE_AWARE, //not transient + // {008B9CE1-154B-44E4-9823-97C1AAB00C3C} + { 0x8b9ce1, 0x154b, 0x44e4, { 0x98, 0x23, 0x97, 0xc1, 0xaa, 0xb0, 0xc, 0x3c }} +}; + +///////////////////////////////////////////////////////////////////////////////////////// +// Interface information + +extern "C" __declspec(dllexport) const MUUID MirandaInterfaces[] = { MIID_PROTOCOL, MIID_LAST }; + +///////////////////////////////////////////////////////////////////////////////////////// + +CMPlugin::CMPlugin() : + ACCPROTOPLUGIN(MODULENAME, pluginInfo) +{ + SetUniqueId(DBKEY_JID); +} + +///////////////////////////////////////////////////////////////////////////////////////// +// Load + +int CMPlugin::Load() +{ + // InitIcons(); + // InitContactMenus(); + + NETLIBUSER nlu = {}; + nlu.flags = NUF_INCOMING | NUF_OUTGOING | NUF_HTTPCONNS | NUF_UNICODE; + nlu.szSettingsModule = "WhatsApp"; + nlu.szDescriptiveName.w = TranslateT("WhatsApp (HTTP)"); + hAvatarUser = Netlib_RegisterUser(&nlu); + return 0; +} + +///////////////////////////////////////////////////////////////////////////////////////// +// Unload + +int CMPlugin::Unload() +{ + Netlib_CloseHandle(hAvatarConn); + Netlib_CloseHandle(hAvatarUser); + return 0; +} diff --git a/protocols/WhatsApp/src/message.cpp b/protocols/WhatsApp/src/message.cpp new file mode 100644 index 0000000000..e3440a7207 --- /dev/null +++ b/protocols/WhatsApp/src/message.cpp @@ -0,0 +1,130 @@ +/* + +WhatsApp plugin for Miranda NG +Copyright © 2019-22 George Hazan + +*/ + +#include "stdafx.h" + +static const proto::Message& getBody(const proto::Message &message) +{ + if (message.has_ephemeralmessage()) { + auto &pMsg = message.ephemeralmessage().message(); + return (pMsg.has_viewoncemessage()) ? pMsg.viewoncemessage().message() : pMsg; + } + + if (message.has_viewoncemessage()) + return message.viewoncemessage().message(); + + return message; +} + +void WhatsAppProto::ProcessMessage(WAMSG type, const proto::WebMessageInfo &msg) +{ + auto &key = msg.key(); + auto &body = getBody(msg.message()); + bool bFromMe = key.fromme(); + + debugLogA("Got a message: %s", msg.Utf8DebugString().c_str()); + + uint32_t timestamp = msg.messagetimestamp(); + auto &participant = key.participant(); + auto &chatId = key.remotejid(); + auto &msgId = key.id(); + + WAUser *pUser = FindUser(chatId.c_str()); + if (pUser == nullptr) { + if (type.bPrivateChat) + pUser = AddUser(chatId.c_str(), false, false); + else if (type.bGroupChat) + pUser = AddUser(chatId.c_str(), false, true); + } + + if (!bFromMe && msg.has_pushname() && pUser && !pUser->bIsGroupChat) + setUString(pUser->hContact, "Nick", msg.pushname().c_str()); + + // try to extract some text + if (body.has_conversation()) { + auto &conversation = body.conversation(); + if (!conversation.empty()) { + PROTORECVEVENT pre = {}; + pre.timestamp = timestamp; + pre.szMessage = (char*)conversation.c_str(); + pre.szMsgId = msgId.c_str(); + if (type.bOffline) + pre.flags |= PREF_CREATEREAD; + if (bFromMe) + pre.flags |= PREF_SENT; + ProtoChainRecvMsg(pUser->hContact, &pre); + } + } + + if (body.has_protocolmessage()) { + auto &protoMsg = body.protocolmessage(); + switch (protoMsg.type()) { + case proto::Message_ProtocolMessage_Type_APP_STATE_SYNC_KEY_SHARE: + if (protoMsg.appstatesynckeyshare().keys_size()) { + for (auto &it : protoMsg.appstatesynckeyshare().keys()) { + auto &keyid = it.keyid().keyid(); + auto &keydata = it.keydata().keydata(); + + CMStringA szSetting(FORMAT, "AppSyncKey%d", decodeBigEndian(keyid)); + db_set_blob(0, m_szModuleName, szSetting, keydata.c_str(), (unsigned)keydata.size()); + } + } + break; + + case proto::Message_ProtocolMessage_Type_HISTORY_SYNC_NOTIFICATION: + debugLogA("History sync notification"); + break; + + case proto::Message_ProtocolMessage_Type_REVOKE: + break; + + case proto::Message_ProtocolMessage_Type_EPHEMERAL_SETTING: + if (pUser) { + setDword(pUser->hContact, DBKEY_EPHEMERAL_TS, timestamp); + setDword(pUser->hContact, DBKEY_EPHEMERAL_EXPIRE, protoMsg.ephemeralexpiration()); + } + break; + } + } + else if (body.has_reactionmessage()) { + debugLogA("Got a reaction to a message"); + } + else if (msg.has_messagestubtype()) { + switch (msg.messagestubtype()) { + case proto::WebMessageInfo::GROUP_PARTICIPANT_LEAVE: + case proto::WebMessageInfo::GROUP_PARTICIPANT_REMOVE: + debugLogA("Participant %s removed from chat", participant.c_str()); + break; + + case proto::WebMessageInfo::GROUP_PARTICIPANT_ADD: + case proto::WebMessageInfo::GROUP_PARTICIPANT_INVITE: + case proto::WebMessageInfo::GROUP_PARTICIPANT_ADD_REQUEST_JOIN: + debugLogA("Participant %s added to chat", participant.c_str()); + break; + + case proto::WebMessageInfo::GROUP_PARTICIPANT_DEMOTE: + debugLogA("Participant %s demoted", participant.c_str()); + break; + + case proto::WebMessageInfo::GROUP_PARTICIPANT_PROMOTE: + debugLogA("Participant %s promoted", participant.c_str()); + break; + + case proto::WebMessageInfo::GROUP_CHANGE_ANNOUNCE: + debugLogA("Groupchat announce", participant.c_str()); + break; + + case proto::WebMessageInfo::GROUP_CHANGE_RESTRICT: + debugLogA("Groupchat restriction", participant.c_str()); + break; + + case proto::WebMessageInfo::GROUP_CHANGE_SUBJECT: + debugLogA("Groupchat subject was changed", participant.c_str()); + break; + } + } +} diff --git a/protocols/WhatsApp/src/noise.cpp b/protocols/WhatsApp/src/noise.cpp new file mode 100644 index 0000000000..db08716050 --- /dev/null +++ b/protocols/WhatsApp/src/noise.cpp @@ -0,0 +1,203 @@ +/* + +WhatsApp plugin for Miranda NG +Copyright © 2019-22 George Hazan + +WANoise class implementation + +*/ + +#include "stdafx.h" + +static uint8_t intro_header[] = {87, 65, 6, DICT_VERSION}; +static uint8_t noise_init[] = "Noise_XX_25519_AESGCM_SHA256\0\0\0\0"; + +WANoise::WANoise(WhatsAppProto *_ppro) : + ppro(_ppro) +{ + salt.assign(noise_init, 32); + encKey.assign(noise_init, 32); + decKey.assign(noise_init, 32); + + // generate ephemeral keys: public & private + ec_key_pair *pKeys; + curve_generate_key_pair(ppro->m_signalStore.CTX(), &pKeys); + + auto *pPubKey = ec_key_pair_get_public(pKeys); + ephemeral.pub.assign(pPubKey->data, sizeof(pPubKey->data)); + + auto *pPrivKey = ec_key_pair_get_private(pKeys); + ephemeral.priv.assign(pPrivKey->data, sizeof(pPrivKey->data)); + ec_key_pair_destroy((signal_type_base*)pKeys); + + // prepare hash + memcpy(hash, noise_init, 32); + updateHash(intro_header, 4); + updateHash(ephemeral.pub.data(), ephemeral.pub.length()); +} + +///////////////////////////////////////////////////////////////////////////////////////// +// libsignal data initialization + +void WANoise::init() +{ + // no data? generate them + if (ppro->getDword(DBKEY_REG_ID, 0xFFFF) == 0xFFFF) { + // generate registration id + uint32_t regId; + Utils_GetRandom(®Id, sizeof(regId)); + ppro->setDword(DBKEY_REG_ID, regId & 0x3FFF); + + // generate secret key + uint8_t secretKey[32]; + Utils_GetRandom(secretKey, sizeof(secretKey)); + db_set_blob(0, ppro->m_szModuleName, DBKEY_SECRET_KEY, secretKey, sizeof(secretKey)); + + // generate noise keys (private & public) + ec_key_pair *pKeys; + curve_generate_key_pair(ppro->m_signalStore.CTX(), &pKeys); + + auto *pPubKey = ec_key_pair_get_public(pKeys); + db_set_blob(0, ppro->m_szModuleName, DBKEY_NOISE_PUB, pPubKey->data, sizeof(pPubKey->data)); + + auto *pPrivKey = ec_key_pair_get_private(pKeys); + db_set_blob(0, ppro->m_szModuleName, DBKEY_NOISE_PRIV, pPrivKey->data, sizeof(pPrivKey->data)); + ec_key_pair_destroy((signal_type_base *)pKeys); + } + + noiseKeys.pub = ppro->getBlob(DBKEY_NOISE_PUB); + noiseKeys.priv = ppro->getBlob(DBKEY_NOISE_PRIV); +} + +void WANoise::finish() +{ + deriveKey("", 0, encKey, decKey); + readCounter = writeCounter = 0; + memset(hash, 0, sizeof(hash)); + bInitFinished = true; +} + +void WANoise::deriveKey(const void *pData, size_t cbLen, MBinBuffer &write, MBinBuffer &read) +{ + size_t outlen = 64; + uint8_t out[64]; + HKDF(EVP_sha256(), (BYTE *)salt.data(), (int)salt.length(), (BYTE *)pData, (int)cbLen, (BYTE *)"", 0, out, outlen); + + write.assign(out, 32); + read.assign(out + 32, 32); +} + +void WANoise::mixIntoKey(const void *n, const void *p) +{ + uint8_t tmp[32]; + curve25519_donna((unsigned char *)tmp, (const unsigned char *)n, (const unsigned char *)p); + + deriveKey(tmp, sizeof(tmp), salt, encKey); + decKey.assign(encKey.data(), encKey.length()); + readCounter = writeCounter = 0; +} + +MBinBuffer WANoise::decrypt(const void *pData, size_t cbLen) +{ + uint8_t iv[12]; + generateIV(iv, (bInitFinished) ? readCounter : writeCounter); + + MBinBuffer res; + if (!bInitFinished) + res = aesDecrypt(EVP_aes_256_gcm(), (BYTE *)decKey.data(), iv, pData, cbLen, hash, sizeof(hash)); + else + res = aesDecrypt(EVP_aes_256_gcm(), (BYTE *)decKey.data(), iv, pData, cbLen); + + updateHash(pData, cbLen); + return res; +} + +size_t WANoise::decodeFrame(const void *&pData, size_t &cbLen) +{ + auto *p = (const uint8_t *)pData; + + if (cbLen < 3) + return 0; + + size_t payloadLen = 0; + for (int i = 0; i < 3; i++) { + payloadLen <<= 8; + payloadLen += p[i]; + } + + // ppro->debugLogA("got payload of size %d", payloadLen); + + cbLen -= 3; + if (payloadLen > cbLen) { + ppro->debugLogA("payload length %d exceeds capacity %d", payloadLen, cbLen); + return 0; + } + + pData = p + 3; + return payloadLen; +} + +MBinBuffer WANoise::encodeFrame(const void *pData, size_t cbLen) +{ + MBinBuffer res; + if (!bSendIntro) { + bSendIntro = true; + res.append(intro_header, 4); + } + + uint8_t buf[3]; + size_t foo = cbLen; + for (int i = 0; i < 3; i++) { + buf[2 - i] = foo & 0xFF; + foo >>= 8; + } + res.append(buf, 3); + res.append(pData, cbLen); + return res; +} + +MBinBuffer WANoise::encrypt(const void *pData, size_t cbLen) +{ + uint8_t iv[12]; + generateIV(iv, writeCounter); + + MBinBuffer res; + uint8_t outbuf[1024 + 64]; + + int enc_len = 0, final_len = 0; + EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new(); + EVP_EncryptInit_ex(ctx, EVP_aes_256_gcm(), NULL, (BYTE *)encKey.data(), iv); + + if (!bInitFinished) + EVP_EncryptUpdate(ctx, NULL, &enc_len, hash, sizeof(hash)); + + for (size_t len = 0; len < cbLen; len += 1024) { + size_t portionSize = cbLen - len; + EVP_EncryptUpdate(ctx, outbuf, &enc_len, (BYTE *)pData + len, (int)min(portionSize, 1024)); + res.append(outbuf, enc_len); + } + EVP_EncryptFinal_ex(ctx, outbuf, &final_len); + if (final_len) + res.append(outbuf, final_len); + + uint8_t tag[16]; + EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_GET_TAG, sizeof(tag), tag); + res.append(tag, sizeof(tag)); + + EVP_CIPHER_CTX_free(ctx); + + updateHash(res.data(), res.length()); + return res; +} + +void WANoise::updateHash(const void *pData, size_t cbLen) +{ + if (bInitFinished) + return; + + SHA256_CTX ctx; + SHA256_Init(&ctx); + SHA256_Update(&ctx, hash, sizeof(hash)); + SHA256_Update(&ctx, pData, cbLen); + SHA256_Final(hash, &ctx); +} diff --git a/protocols/WhatsApp/src/options.cpp b/protocols/WhatsApp/src/options.cpp new file mode 100644 index 0000000000..0b9aaef264 --- /dev/null +++ b/protocols/WhatsApp/src/options.cpp @@ -0,0 +1,68 @@ +/* + +WhatsApp plugin for Miranda NG +Copyright © 2019-22 George Hazan + +*/ + +#include "stdafx.h" + +///////////////////////////////////////////////////////////////////////////////////////// + +class COptionsDlg : public CProtoDlgBase +{ + CCtrlCheck chkHideChats; + CCtrlEdit edtGroup, edtNick; + ptrW m_wszOldGroup; + +public: + COptionsDlg(WhatsAppProto *ppro, int iDlgID, bool bFullDlg) : + CProtoDlgBase(ppro, iDlgID), + chkHideChats(this, IDC_HIDECHATS), + edtNick(this, IDC_NICK), + edtGroup(this, IDC_DEFGROUP), + m_wszOldGroup(mir_wstrdup(ppro->m_wszDefaultGroup)) + { + CreateLink(edtNick, ppro->m_wszNick); + CreateLink(edtGroup, ppro->m_wszDefaultGroup); + + if (bFullDlg) + CreateLink(chkHideChats, ppro->m_bHideGroupchats); + } + + bool OnApply() override + { + if (mir_wstrlen(m_proto->m_wszNick)) { + SetFocus(edtNick.GetHwnd()); + return false; + } + + if (mir_wstrcmp(m_proto->m_wszDefaultGroup, m_wszOldGroup)) + Clist_GroupCreate(0, m_proto->m_wszDefaultGroup); + return true; + } +}; + +///////////////////////////////////////////////////////////////////////////////////////// + +INT_PTR WhatsAppProto::SvcCreateAccMgrUI(WPARAM, LPARAM hwndParent) +{ + auto *pDlg = new COptionsDlg(this, IDD_ACCMGRUI, false); + pDlg->SetParent((HWND)hwndParent); + pDlg->Create(); + return (INT_PTR)pDlg->GetHwnd(); +} + +int WhatsAppProto::OnOptionsInit(WPARAM wParam, LPARAM) +{ + OPTIONSDIALOGPAGE odp = {}; + odp.szTitle.w = m_tszUserName; + odp.flags = ODPF_UNICODE; + odp.szGroup.w = LPGENW("Network"); + + odp.position = 1; + odp.szTab.w = LPGENW("Account"); + odp.pDialog = new COptionsDlg(this, IDD_OPTIONS, true); + g_plugin.addOptions(wParam, &odp); + return 0; +} diff --git a/protocols/WhatsApp/src/pmsg.pb.cc b/protocols/WhatsApp/src/pmsg.pb.cc new file mode 100644 index 0000000000..6c4a99abc5 --- /dev/null +++ b/protocols/WhatsApp/src/pmsg.pb.cc @@ -0,0 +1,100321 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: pmsg.proto + +#include "pmsg.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include + +PROTOBUF_PRAGMA_INIT_SEG + +namespace _pb = ::PROTOBUF_NAMESPACE_ID; +namespace _pbi = _pb::internal; + +namespace proto { +PROTOBUF_CONSTEXPR ADVDeviceIdentity::ADVDeviceIdentity( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.timestamp_)*/uint64_t{0u} + , /*decltype(_impl_.rawid_)*/0u + , /*decltype(_impl_.keyindex_)*/0u} {} +struct ADVDeviceIdentityDefaultTypeInternal { + PROTOBUF_CONSTEXPR ADVDeviceIdentityDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ADVDeviceIdentityDefaultTypeInternal() {} + union { + ADVDeviceIdentity _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ADVDeviceIdentityDefaultTypeInternal _ADVDeviceIdentity_default_instance_; +PROTOBUF_CONSTEXPR ADVKeyIndexList::ADVKeyIndexList( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.validindexes_)*/{} + , /*decltype(_impl_._validindexes_cached_byte_size_)*/{0} + , /*decltype(_impl_.timestamp_)*/uint64_t{0u} + , /*decltype(_impl_.rawid_)*/0u + , /*decltype(_impl_.currentindex_)*/0u} {} +struct ADVKeyIndexListDefaultTypeInternal { + PROTOBUF_CONSTEXPR ADVKeyIndexListDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ADVKeyIndexListDefaultTypeInternal() {} + union { + ADVKeyIndexList _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ADVKeyIndexListDefaultTypeInternal _ADVKeyIndexList_default_instance_; +PROTOBUF_CONSTEXPR ADVSignedDeviceIdentity::ADVSignedDeviceIdentity( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.details_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.accountsignaturekey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.accountsignature_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.devicesignature_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct ADVSignedDeviceIdentityDefaultTypeInternal { + PROTOBUF_CONSTEXPR ADVSignedDeviceIdentityDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ADVSignedDeviceIdentityDefaultTypeInternal() {} + union { + ADVSignedDeviceIdentity _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ADVSignedDeviceIdentityDefaultTypeInternal _ADVSignedDeviceIdentity_default_instance_; +PROTOBUF_CONSTEXPR ADVSignedDeviceIdentityHMAC::ADVSignedDeviceIdentityHMAC( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.details_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.hmac_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct ADVSignedDeviceIdentityHMACDefaultTypeInternal { + PROTOBUF_CONSTEXPR ADVSignedDeviceIdentityHMACDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ADVSignedDeviceIdentityHMACDefaultTypeInternal() {} + union { + ADVSignedDeviceIdentityHMAC _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ADVSignedDeviceIdentityHMACDefaultTypeInternal _ADVSignedDeviceIdentityHMAC_default_instance_; +PROTOBUF_CONSTEXPR ADVSignedKeyIndexList::ADVSignedKeyIndexList( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.details_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.accountsignature_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct ADVSignedKeyIndexListDefaultTypeInternal { + PROTOBUF_CONSTEXPR ADVSignedKeyIndexListDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ADVSignedKeyIndexListDefaultTypeInternal() {} + union { + ADVSignedKeyIndexList _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ADVSignedKeyIndexListDefaultTypeInternal _ADVSignedKeyIndexList_default_instance_; +PROTOBUF_CONSTEXPR ActionLink::ActionLink( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.buttontitle_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct ActionLinkDefaultTypeInternal { + PROTOBUF_CONSTEXPR ActionLinkDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ActionLinkDefaultTypeInternal() {} + union { + ActionLink _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ActionLinkDefaultTypeInternal _ActionLink_default_instance_; +PROTOBUF_CONSTEXPR AutoDownloadSettings::AutoDownloadSettings( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.downloadimages_)*/false + , /*decltype(_impl_.downloadaudio_)*/false + , /*decltype(_impl_.downloadvideo_)*/false + , /*decltype(_impl_.downloaddocuments_)*/false} {} +struct AutoDownloadSettingsDefaultTypeInternal { + PROTOBUF_CONSTEXPR AutoDownloadSettingsDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~AutoDownloadSettingsDefaultTypeInternal() {} + union { + AutoDownloadSettings _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AutoDownloadSettingsDefaultTypeInternal _AutoDownloadSettings_default_instance_; +PROTOBUF_CONSTEXPR BizAccountLinkInfo::BizAccountLinkInfo( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.whatsappacctnumber_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.whatsappbizacctfbid_)*/uint64_t{0u} + , /*decltype(_impl_.issuetime_)*/uint64_t{0u} + , /*decltype(_impl_.hoststorage_)*/0 + , /*decltype(_impl_.accounttype_)*/0} {} +struct BizAccountLinkInfoDefaultTypeInternal { + PROTOBUF_CONSTEXPR BizAccountLinkInfoDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~BizAccountLinkInfoDefaultTypeInternal() {} + union { + BizAccountLinkInfo _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BizAccountLinkInfoDefaultTypeInternal _BizAccountLinkInfo_default_instance_; +PROTOBUF_CONSTEXPR BizAccountPayload::BizAccountPayload( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.bizacctlinkinfo_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.vnamecert_)*/nullptr} {} +struct BizAccountPayloadDefaultTypeInternal { + PROTOBUF_CONSTEXPR BizAccountPayloadDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~BizAccountPayloadDefaultTypeInternal() {} + union { + BizAccountPayload _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BizAccountPayloadDefaultTypeInternal _BizAccountPayload_default_instance_; +PROTOBUF_CONSTEXPR BizIdentityInfo::BizIdentityInfo( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.vnamecert_)*/nullptr + , /*decltype(_impl_.vlevel_)*/0 + , /*decltype(_impl_.signed__)*/false + , /*decltype(_impl_.revoked_)*/false + , /*decltype(_impl_.hoststorage_)*/0 + , /*decltype(_impl_.actualactors_)*/0 + , /*decltype(_impl_.privacymodets_)*/uint64_t{0u} + , /*decltype(_impl_.featurecontrols_)*/uint64_t{0u}} {} +struct BizIdentityInfoDefaultTypeInternal { + PROTOBUF_CONSTEXPR BizIdentityInfoDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~BizIdentityInfoDefaultTypeInternal() {} + union { + BizIdentityInfo _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BizIdentityInfoDefaultTypeInternal _BizIdentityInfo_default_instance_; +PROTOBUF_CONSTEXPR CertChain_NoiseCertificate_Details::CertChain_NoiseCertificate_Details( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.key_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.serial_)*/0u + , /*decltype(_impl_.issuerserial_)*/0u + , /*decltype(_impl_.notbefore_)*/uint64_t{0u} + , /*decltype(_impl_.notafter_)*/uint64_t{0u}} {} +struct CertChain_NoiseCertificate_DetailsDefaultTypeInternal { + PROTOBUF_CONSTEXPR CertChain_NoiseCertificate_DetailsDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~CertChain_NoiseCertificate_DetailsDefaultTypeInternal() {} + union { + CertChain_NoiseCertificate_Details _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CertChain_NoiseCertificate_DetailsDefaultTypeInternal _CertChain_NoiseCertificate_Details_default_instance_; +PROTOBUF_CONSTEXPR CertChain_NoiseCertificate::CertChain_NoiseCertificate( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.details_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.signature_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct CertChain_NoiseCertificateDefaultTypeInternal { + PROTOBUF_CONSTEXPR CertChain_NoiseCertificateDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~CertChain_NoiseCertificateDefaultTypeInternal() {} + union { + CertChain_NoiseCertificate _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CertChain_NoiseCertificateDefaultTypeInternal _CertChain_NoiseCertificate_default_instance_; +PROTOBUF_CONSTEXPR CertChain::CertChain( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.leaf_)*/nullptr + , /*decltype(_impl_.intermediate_)*/nullptr} {} +struct CertChainDefaultTypeInternal { + PROTOBUF_CONSTEXPR CertChainDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~CertChainDefaultTypeInternal() {} + union { + CertChain _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CertChainDefaultTypeInternal _CertChain_default_instance_; +PROTOBUF_CONSTEXPR Chain::Chain( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.messagekeys_)*/{} + , /*decltype(_impl_.senderratchetkey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.senderratchetkeyprivate_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.chainkey_)*/nullptr} {} +struct ChainDefaultTypeInternal { + PROTOBUF_CONSTEXPR ChainDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ChainDefaultTypeInternal() {} + union { + Chain _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ChainDefaultTypeInternal _Chain_default_instance_; +PROTOBUF_CONSTEXPR ChainKey::ChainKey( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.key_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.index_)*/0u} {} +struct ChainKeyDefaultTypeInternal { + PROTOBUF_CONSTEXPR ChainKeyDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ChainKeyDefaultTypeInternal() {} + union { + ChainKey _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ChainKeyDefaultTypeInternal _ChainKey_default_instance_; +PROTOBUF_CONSTEXPR ClientPayload_DNSSource::ClientPayload_DNSSource( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.dnsmethod_)*/0 + , /*decltype(_impl_.appcached_)*/false} {} +struct ClientPayload_DNSSourceDefaultTypeInternal { + PROTOBUF_CONSTEXPR ClientPayload_DNSSourceDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ClientPayload_DNSSourceDefaultTypeInternal() {} + union { + ClientPayload_DNSSource _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientPayload_DNSSourceDefaultTypeInternal _ClientPayload_DNSSource_default_instance_; +PROTOBUF_CONSTEXPR ClientPayload_DevicePairingRegistrationData::ClientPayload_DevicePairingRegistrationData( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.eregid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.ekeytype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.eident_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.eskeyid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.eskeyval_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.eskeysig_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.buildhash_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.deviceprops_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct ClientPayload_DevicePairingRegistrationDataDefaultTypeInternal { + PROTOBUF_CONSTEXPR ClientPayload_DevicePairingRegistrationDataDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ClientPayload_DevicePairingRegistrationDataDefaultTypeInternal() {} + union { + ClientPayload_DevicePairingRegistrationData _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientPayload_DevicePairingRegistrationDataDefaultTypeInternal _ClientPayload_DevicePairingRegistrationData_default_instance_; +PROTOBUF_CONSTEXPR ClientPayload_UserAgent_AppVersion::ClientPayload_UserAgent_AppVersion( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.primary_)*/0u + , /*decltype(_impl_.secondary_)*/0u + , /*decltype(_impl_.tertiary_)*/0u + , /*decltype(_impl_.quaternary_)*/0u + , /*decltype(_impl_.quinary_)*/0u} {} +struct ClientPayload_UserAgent_AppVersionDefaultTypeInternal { + PROTOBUF_CONSTEXPR ClientPayload_UserAgent_AppVersionDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ClientPayload_UserAgent_AppVersionDefaultTypeInternal() {} + union { + ClientPayload_UserAgent_AppVersion _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientPayload_UserAgent_AppVersionDefaultTypeInternal _ClientPayload_UserAgent_AppVersion_default_instance_; +PROTOBUF_CONSTEXPR ClientPayload_UserAgent::ClientPayload_UserAgent( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.mcc_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.mnc_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.osversion_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.manufacturer_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.device_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.osbuildnumber_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.phoneid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.localelanguageiso6391_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.localecountryiso31661alpha2_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.deviceboard_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.appversion_)*/nullptr + , /*decltype(_impl_.platform_)*/0 + , /*decltype(_impl_.releasechannel_)*/0} {} +struct ClientPayload_UserAgentDefaultTypeInternal { + PROTOBUF_CONSTEXPR ClientPayload_UserAgentDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ClientPayload_UserAgentDefaultTypeInternal() {} + union { + ClientPayload_UserAgent _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientPayload_UserAgentDefaultTypeInternal _ClientPayload_UserAgent_default_instance_; +PROTOBUF_CONSTEXPR ClientPayload_WebInfo_WebdPayload::ClientPayload_WebInfo_WebdPayload( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.documenttypes_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.features_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.usesparticipantinkey_)*/false + , /*decltype(_impl_.supportsstarredmessages_)*/false + , /*decltype(_impl_.supportsdocumentmessages_)*/false + , /*decltype(_impl_.supportsurlmessages_)*/false + , /*decltype(_impl_.supportsmediaretry_)*/false + , /*decltype(_impl_.supportse2eimage_)*/false + , /*decltype(_impl_.supportse2evideo_)*/false + , /*decltype(_impl_.supportse2eaudio_)*/false + , /*decltype(_impl_.supportse2edocument_)*/false} {} +struct ClientPayload_WebInfo_WebdPayloadDefaultTypeInternal { + PROTOBUF_CONSTEXPR ClientPayload_WebInfo_WebdPayloadDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ClientPayload_WebInfo_WebdPayloadDefaultTypeInternal() {} + union { + ClientPayload_WebInfo_WebdPayload _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientPayload_WebInfo_WebdPayloadDefaultTypeInternal _ClientPayload_WebInfo_WebdPayload_default_instance_; +PROTOBUF_CONSTEXPR ClientPayload_WebInfo::ClientPayload_WebInfo( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.reftoken_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.version_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.webdpayload_)*/nullptr + , /*decltype(_impl_.websubplatform_)*/0} {} +struct ClientPayload_WebInfoDefaultTypeInternal { + PROTOBUF_CONSTEXPR ClientPayload_WebInfoDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ClientPayload_WebInfoDefaultTypeInternal() {} + union { + ClientPayload_WebInfo _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientPayload_WebInfoDefaultTypeInternal _ClientPayload_WebInfo_default_instance_; +PROTOBUF_CONSTEXPR ClientPayload::ClientPayload( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.shards_)*/{} + , /*decltype(_impl_.pushname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.fbcat_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.fbuseragent_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.fbdeviceid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.paddingbytes_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.useragent_)*/nullptr + , /*decltype(_impl_.webinfo_)*/nullptr + , /*decltype(_impl_.dnssource_)*/nullptr + , /*decltype(_impl_.devicepairingdata_)*/nullptr + , /*decltype(_impl_.username_)*/uint64_t{0u} + , /*decltype(_impl_.sessionid_)*/0 + , /*decltype(_impl_.connecttype_)*/0 + , /*decltype(_impl_.connectreason_)*/0 + , /*decltype(_impl_.connectattemptcount_)*/0u + , /*decltype(_impl_.passive_)*/false + , /*decltype(_impl_.shortconnect_)*/false + , /*decltype(_impl_.oc_)*/false + , /*decltype(_impl_.pull_)*/false + , /*decltype(_impl_.device_)*/0u + , /*decltype(_impl_.product_)*/0 + , /*decltype(_impl_.lc_)*/0 + , /*decltype(_impl_.fbappid_)*/uint64_t{0u} + , /*decltype(_impl_.iosappextension_)*/0} {} +struct ClientPayloadDefaultTypeInternal { + PROTOBUF_CONSTEXPR ClientPayloadDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ClientPayloadDefaultTypeInternal() {} + union { + ClientPayload _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientPayloadDefaultTypeInternal _ClientPayload_default_instance_; +PROTOBUF_CONSTEXPR ContextInfo_AdReplyInfo::ContextInfo_AdReplyInfo( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.advertisername_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.jpegthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.caption_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.mediatype_)*/0} {} +struct ContextInfo_AdReplyInfoDefaultTypeInternal { + PROTOBUF_CONSTEXPR ContextInfo_AdReplyInfoDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ContextInfo_AdReplyInfoDefaultTypeInternal() {} + union { + ContextInfo_AdReplyInfo _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ContextInfo_AdReplyInfoDefaultTypeInternal _ContextInfo_AdReplyInfo_default_instance_; +PROTOBUF_CONSTEXPR ContextInfo_ExternalAdReplyInfo::ContextInfo_ExternalAdReplyInfo( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.body_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.thumbnailurl_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.mediaurl_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.thumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.sourcetype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.sourceid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.sourceurl_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.mediatype_)*/0 + , /*decltype(_impl_.containsautoreply_)*/false + , /*decltype(_impl_.renderlargerthumbnail_)*/false + , /*decltype(_impl_.showadattribution_)*/false} {} +struct ContextInfo_ExternalAdReplyInfoDefaultTypeInternal { + PROTOBUF_CONSTEXPR ContextInfo_ExternalAdReplyInfoDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ContextInfo_ExternalAdReplyInfoDefaultTypeInternal() {} + union { + ContextInfo_ExternalAdReplyInfo _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ContextInfo_ExternalAdReplyInfoDefaultTypeInternal _ContextInfo_ExternalAdReplyInfo_default_instance_; +PROTOBUF_CONSTEXPR ContextInfo::ContextInfo( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.mentionedjid_)*/{} + , /*decltype(_impl_.stanzaid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.participant_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.remotejid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.conversionsource_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.conversiondata_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.ephemeralsharedsecret_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.entrypointconversionsource_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.entrypointconversionapp_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.groupsubject_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.parentgroupjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.quotedmessage_)*/nullptr + , /*decltype(_impl_.quotedad_)*/nullptr + , /*decltype(_impl_.placeholderkey_)*/nullptr + , /*decltype(_impl_.externaladreply_)*/nullptr + , /*decltype(_impl_.disappearingmode_)*/nullptr + , /*decltype(_impl_.actionlink_)*/nullptr + , /*decltype(_impl_.conversiondelayseconds_)*/0u + , /*decltype(_impl_.forwardingscore_)*/0u + , /*decltype(_impl_.isforwarded_)*/false + , /*decltype(_impl_.expiration_)*/0u + , /*decltype(_impl_.ephemeralsettingtimestamp_)*/int64_t{0} + , /*decltype(_impl_.entrypointconversiondelayseconds_)*/0u} {} +struct ContextInfoDefaultTypeInternal { + PROTOBUF_CONSTEXPR ContextInfoDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ContextInfoDefaultTypeInternal() {} + union { + ContextInfo _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ContextInfoDefaultTypeInternal _ContextInfo_default_instance_; +PROTOBUF_CONSTEXPR Conversation::Conversation( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.messages_)*/{} + , /*decltype(_impl_.participant_)*/{} + , /*decltype(_impl_.id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.newjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.oldjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.phash_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.tctoken_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.contactprimaryidentitykey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.createdby_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.description_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.parentgroupid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.displayname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.pnjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.disappearingmode_)*/nullptr + , /*decltype(_impl_.wallpaper_)*/nullptr + , /*decltype(_impl_.lastmsgtimestamp_)*/uint64_t{0u} + , /*decltype(_impl_.unreadcount_)*/0u + , /*decltype(_impl_.ephemeralexpiration_)*/0u + , /*decltype(_impl_.ephemeralsettingtimestamp_)*/int64_t{0} + , /*decltype(_impl_.endofhistorytransfertype_)*/0 + , /*decltype(_impl_.readonly_)*/false + , /*decltype(_impl_.endofhistorytransfer_)*/false + , /*decltype(_impl_.notspam_)*/false + , /*decltype(_impl_.archived_)*/false + , /*decltype(_impl_.conversationtimestamp_)*/uint64_t{0u} + , /*decltype(_impl_.unreadmentioncount_)*/0u + , /*decltype(_impl_.pinned_)*/0u + , /*decltype(_impl_.tctokentimestamp_)*/uint64_t{0u} + , /*decltype(_impl_.muteendtime_)*/uint64_t{0u} + , /*decltype(_impl_.mediavisibility_)*/0 + , /*decltype(_impl_.markedasunread_)*/false + , /*decltype(_impl_.suspended_)*/false + , /*decltype(_impl_.terminated_)*/false + , /*decltype(_impl_.support_)*/false + , /*decltype(_impl_.tctokensendertimestamp_)*/uint64_t{0u} + , /*decltype(_impl_.createdat_)*/uint64_t{0u} + , /*decltype(_impl_.isparentgroup_)*/false + , /*decltype(_impl_.isdefaultsubgroup_)*/false + , /*decltype(_impl_.selfpnexposed_)*/false} {} +struct ConversationDefaultTypeInternal { + PROTOBUF_CONSTEXPR ConversationDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ConversationDefaultTypeInternal() {} + union { + Conversation _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ConversationDefaultTypeInternal _Conversation_default_instance_; +PROTOBUF_CONSTEXPR DeviceListMetadata::DeviceListMetadata( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.senderkeyindexes_)*/{} + , /*decltype(_impl_._senderkeyindexes_cached_byte_size_)*/{0} + , /*decltype(_impl_.recipientkeyindexes_)*/{} + , /*decltype(_impl_._recipientkeyindexes_cached_byte_size_)*/{0} + , /*decltype(_impl_.senderkeyhash_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.recipientkeyhash_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.sendertimestamp_)*/uint64_t{0u} + , /*decltype(_impl_.recipienttimestamp_)*/uint64_t{0u}} {} +struct DeviceListMetadataDefaultTypeInternal { + PROTOBUF_CONSTEXPR DeviceListMetadataDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~DeviceListMetadataDefaultTypeInternal() {} + union { + DeviceListMetadata _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeviceListMetadataDefaultTypeInternal _DeviceListMetadata_default_instance_; +PROTOBUF_CONSTEXPR DeviceProps_AppVersion::DeviceProps_AppVersion( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.primary_)*/0u + , /*decltype(_impl_.secondary_)*/0u + , /*decltype(_impl_.tertiary_)*/0u + , /*decltype(_impl_.quaternary_)*/0u + , /*decltype(_impl_.quinary_)*/0u} {} +struct DeviceProps_AppVersionDefaultTypeInternal { + PROTOBUF_CONSTEXPR DeviceProps_AppVersionDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~DeviceProps_AppVersionDefaultTypeInternal() {} + union { + DeviceProps_AppVersion _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeviceProps_AppVersionDefaultTypeInternal _DeviceProps_AppVersion_default_instance_; +PROTOBUF_CONSTEXPR DeviceProps::DeviceProps( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.os_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.version_)*/nullptr + , /*decltype(_impl_.platformtype_)*/0 + , /*decltype(_impl_.requirefullsync_)*/false} {} +struct DevicePropsDefaultTypeInternal { + PROTOBUF_CONSTEXPR DevicePropsDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~DevicePropsDefaultTypeInternal() {} + union { + DeviceProps _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DevicePropsDefaultTypeInternal _DeviceProps_default_instance_; +PROTOBUF_CONSTEXPR DisappearingMode::DisappearingMode( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.initiator_)*/0} {} +struct DisappearingModeDefaultTypeInternal { + PROTOBUF_CONSTEXPR DisappearingModeDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~DisappearingModeDefaultTypeInternal() {} + union { + DisappearingMode _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DisappearingModeDefaultTypeInternal _DisappearingMode_default_instance_; +PROTOBUF_CONSTEXPR EphemeralSetting::EphemeralSetting( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.timestamp_)*/int64_t{0} + , /*decltype(_impl_.duration_)*/0} {} +struct EphemeralSettingDefaultTypeInternal { + PROTOBUF_CONSTEXPR EphemeralSettingDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~EphemeralSettingDefaultTypeInternal() {} + union { + EphemeralSetting _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EphemeralSettingDefaultTypeInternal _EphemeralSetting_default_instance_; +PROTOBUF_CONSTEXPR ExitCode::ExitCode( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.text_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.code_)*/uint64_t{0u}} {} +struct ExitCodeDefaultTypeInternal { + PROTOBUF_CONSTEXPR ExitCodeDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ExitCodeDefaultTypeInternal() {} + union { + ExitCode _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ExitCodeDefaultTypeInternal _ExitCode_default_instance_; +PROTOBUF_CONSTEXPR ExternalBlobReference::ExternalBlobReference( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.handle_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.filesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.fileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.filesizebytes_)*/uint64_t{0u}} {} +struct ExternalBlobReferenceDefaultTypeInternal { + PROTOBUF_CONSTEXPR ExternalBlobReferenceDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ExternalBlobReferenceDefaultTypeInternal() {} + union { + ExternalBlobReference _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ExternalBlobReferenceDefaultTypeInternal _ExternalBlobReference_default_instance_; +PROTOBUF_CONSTEXPR GlobalSettings::GlobalSettings( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.lightthemewallpaper_)*/nullptr + , /*decltype(_impl_.darkthemewallpaper_)*/nullptr + , /*decltype(_impl_.autodownloadwifi_)*/nullptr + , /*decltype(_impl_.autodownloadcellular_)*/nullptr + , /*decltype(_impl_.autodownloadroaming_)*/nullptr + , /*decltype(_impl_.mediavisibility_)*/0 + , /*decltype(_impl_.showindividualnotificationspreview_)*/false + , /*decltype(_impl_.showgroupnotificationspreview_)*/false + , /*decltype(_impl_.disappearingmodetimestamp_)*/int64_t{0} + , /*decltype(_impl_.disappearingmodeduration_)*/0} {} +struct GlobalSettingsDefaultTypeInternal { + PROTOBUF_CONSTEXPR GlobalSettingsDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~GlobalSettingsDefaultTypeInternal() {} + union { + GlobalSettings _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GlobalSettingsDefaultTypeInternal _GlobalSettings_default_instance_; +PROTOBUF_CONSTEXPR GroupParticipant::GroupParticipant( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.userjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.rank_)*/0} {} +struct GroupParticipantDefaultTypeInternal { + PROTOBUF_CONSTEXPR GroupParticipantDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~GroupParticipantDefaultTypeInternal() {} + union { + GroupParticipant _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GroupParticipantDefaultTypeInternal _GroupParticipant_default_instance_; +PROTOBUF_CONSTEXPR HandshakeMessage_ClientFinish::HandshakeMessage_ClientFinish( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.static__)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.payload_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct HandshakeMessage_ClientFinishDefaultTypeInternal { + PROTOBUF_CONSTEXPR HandshakeMessage_ClientFinishDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~HandshakeMessage_ClientFinishDefaultTypeInternal() {} + union { + HandshakeMessage_ClientFinish _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HandshakeMessage_ClientFinishDefaultTypeInternal _HandshakeMessage_ClientFinish_default_instance_; +PROTOBUF_CONSTEXPR HandshakeMessage_ClientHello::HandshakeMessage_ClientHello( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.ephemeral_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.static__)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.payload_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct HandshakeMessage_ClientHelloDefaultTypeInternal { + PROTOBUF_CONSTEXPR HandshakeMessage_ClientHelloDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~HandshakeMessage_ClientHelloDefaultTypeInternal() {} + union { + HandshakeMessage_ClientHello _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HandshakeMessage_ClientHelloDefaultTypeInternal _HandshakeMessage_ClientHello_default_instance_; +PROTOBUF_CONSTEXPR HandshakeMessage_ServerHello::HandshakeMessage_ServerHello( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.ephemeral_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.static__)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.payload_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct HandshakeMessage_ServerHelloDefaultTypeInternal { + PROTOBUF_CONSTEXPR HandshakeMessage_ServerHelloDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~HandshakeMessage_ServerHelloDefaultTypeInternal() {} + union { + HandshakeMessage_ServerHello _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HandshakeMessage_ServerHelloDefaultTypeInternal _HandshakeMessage_ServerHello_default_instance_; +PROTOBUF_CONSTEXPR HandshakeMessage::HandshakeMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.clienthello_)*/nullptr + , /*decltype(_impl_.serverhello_)*/nullptr + , /*decltype(_impl_.clientfinish_)*/nullptr} {} +struct HandshakeMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR HandshakeMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~HandshakeMessageDefaultTypeInternal() {} + union { + HandshakeMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HandshakeMessageDefaultTypeInternal _HandshakeMessage_default_instance_; +PROTOBUF_CONSTEXPR HistorySync::HistorySync( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.conversations_)*/{} + , /*decltype(_impl_.statusv3messages_)*/{} + , /*decltype(_impl_.pushnames_)*/{} + , /*decltype(_impl_.recentstickers_)*/{} + , /*decltype(_impl_.pastparticipants_)*/{} + , /*decltype(_impl_.threadidusersecret_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.globalsettings_)*/nullptr + , /*decltype(_impl_.synctype_)*/0 + , /*decltype(_impl_.chunkorder_)*/0u + , /*decltype(_impl_.progress_)*/0u + , /*decltype(_impl_.threaddstimeframeoffset_)*/0u} {} +struct HistorySyncDefaultTypeInternal { + PROTOBUF_CONSTEXPR HistorySyncDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~HistorySyncDefaultTypeInternal() {} + union { + HistorySync _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HistorySyncDefaultTypeInternal _HistorySync_default_instance_; +PROTOBUF_CONSTEXPR HistorySyncMsg::HistorySyncMsg( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.message_)*/nullptr + , /*decltype(_impl_.msgorderid_)*/uint64_t{0u}} {} +struct HistorySyncMsgDefaultTypeInternal { + PROTOBUF_CONSTEXPR HistorySyncMsgDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~HistorySyncMsgDefaultTypeInternal() {} + union { + HistorySyncMsg _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HistorySyncMsgDefaultTypeInternal _HistorySyncMsg_default_instance_; +PROTOBUF_CONSTEXPR HydratedTemplateButton_HydratedCallButton::HydratedTemplateButton_HydratedCallButton( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.displaytext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.phonenumber_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct HydratedTemplateButton_HydratedCallButtonDefaultTypeInternal { + PROTOBUF_CONSTEXPR HydratedTemplateButton_HydratedCallButtonDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~HydratedTemplateButton_HydratedCallButtonDefaultTypeInternal() {} + union { + HydratedTemplateButton_HydratedCallButton _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HydratedTemplateButton_HydratedCallButtonDefaultTypeInternal _HydratedTemplateButton_HydratedCallButton_default_instance_; +PROTOBUF_CONSTEXPR HydratedTemplateButton_HydratedQuickReplyButton::HydratedTemplateButton_HydratedQuickReplyButton( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.displaytext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct HydratedTemplateButton_HydratedQuickReplyButtonDefaultTypeInternal { + PROTOBUF_CONSTEXPR HydratedTemplateButton_HydratedQuickReplyButtonDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~HydratedTemplateButton_HydratedQuickReplyButtonDefaultTypeInternal() {} + union { + HydratedTemplateButton_HydratedQuickReplyButton _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HydratedTemplateButton_HydratedQuickReplyButtonDefaultTypeInternal _HydratedTemplateButton_HydratedQuickReplyButton_default_instance_; +PROTOBUF_CONSTEXPR HydratedTemplateButton_HydratedURLButton::HydratedTemplateButton_HydratedURLButton( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.displaytext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct HydratedTemplateButton_HydratedURLButtonDefaultTypeInternal { + PROTOBUF_CONSTEXPR HydratedTemplateButton_HydratedURLButtonDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~HydratedTemplateButton_HydratedURLButtonDefaultTypeInternal() {} + union { + HydratedTemplateButton_HydratedURLButton _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HydratedTemplateButton_HydratedURLButtonDefaultTypeInternal _HydratedTemplateButton_HydratedURLButton_default_instance_; +PROTOBUF_CONSTEXPR HydratedTemplateButton::HydratedTemplateButton( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.index_)*/0u + , /*decltype(_impl_.hydratedButton_)*/{} + , /*decltype(_impl_._oneof_case_)*/{}} {} +struct HydratedTemplateButtonDefaultTypeInternal { + PROTOBUF_CONSTEXPR HydratedTemplateButtonDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~HydratedTemplateButtonDefaultTypeInternal() {} + union { + HydratedTemplateButton _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HydratedTemplateButtonDefaultTypeInternal _HydratedTemplateButton_default_instance_; +PROTOBUF_CONSTEXPR IdentityKeyPairStructure::IdentityKeyPairStructure( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.publickey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.privatekey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct IdentityKeyPairStructureDefaultTypeInternal { + PROTOBUF_CONSTEXPR IdentityKeyPairStructureDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~IdentityKeyPairStructureDefaultTypeInternal() {} + union { + IdentityKeyPairStructure _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IdentityKeyPairStructureDefaultTypeInternal _IdentityKeyPairStructure_default_instance_; +PROTOBUF_CONSTEXPR InteractiveAnnotation::InteractiveAnnotation( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.polygonvertices_)*/{} + , /*decltype(_impl_.action_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_._oneof_case_)*/{}} {} +struct InteractiveAnnotationDefaultTypeInternal { + PROTOBUF_CONSTEXPR InteractiveAnnotationDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~InteractiveAnnotationDefaultTypeInternal() {} + union { + InteractiveAnnotation _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 InteractiveAnnotationDefaultTypeInternal _InteractiveAnnotation_default_instance_; +PROTOBUF_CONSTEXPR KeepInChat::KeepInChat( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.devicejid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.key_)*/nullptr + , /*decltype(_impl_.servertimestamp_)*/int64_t{0} + , /*decltype(_impl_.keeptype_)*/0} {} +struct KeepInChatDefaultTypeInternal { + PROTOBUF_CONSTEXPR KeepInChatDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~KeepInChatDefaultTypeInternal() {} + union { + KeepInChat _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 KeepInChatDefaultTypeInternal _KeepInChat_default_instance_; +PROTOBUF_CONSTEXPR KeyId::KeyId( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct KeyIdDefaultTypeInternal { + PROTOBUF_CONSTEXPR KeyIdDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~KeyIdDefaultTypeInternal() {} + union { + KeyId _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 KeyIdDefaultTypeInternal _KeyId_default_instance_; +PROTOBUF_CONSTEXPR LocalizedName::LocalizedName( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.lg_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.lc_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.verifiedname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct LocalizedNameDefaultTypeInternal { + PROTOBUF_CONSTEXPR LocalizedNameDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~LocalizedNameDefaultTypeInternal() {} + union { + LocalizedName _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LocalizedNameDefaultTypeInternal _LocalizedName_default_instance_; +PROTOBUF_CONSTEXPR Location::Location( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.degreeslatitude_)*/0 + , /*decltype(_impl_.degreeslongitude_)*/0} {} +struct LocationDefaultTypeInternal { + PROTOBUF_CONSTEXPR LocationDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~LocationDefaultTypeInternal() {} + union { + Location _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LocationDefaultTypeInternal _Location_default_instance_; +PROTOBUF_CONSTEXPR MediaData::MediaData( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.localpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct MediaDataDefaultTypeInternal { + PROTOBUF_CONSTEXPR MediaDataDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~MediaDataDefaultTypeInternal() {} + union { + MediaData _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MediaDataDefaultTypeInternal _MediaData_default_instance_; +PROTOBUF_CONSTEXPR MediaRetryNotification::MediaRetryNotification( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.stanzaid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.result_)*/0} {} +struct MediaRetryNotificationDefaultTypeInternal { + PROTOBUF_CONSTEXPR MediaRetryNotificationDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~MediaRetryNotificationDefaultTypeInternal() {} + union { + MediaRetryNotification _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MediaRetryNotificationDefaultTypeInternal _MediaRetryNotification_default_instance_; +PROTOBUF_CONSTEXPR Message_AppStateFatalExceptionNotification::Message_AppStateFatalExceptionNotification( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.collectionnames_)*/{} + , /*decltype(_impl_.timestamp_)*/int64_t{0}} {} +struct Message_AppStateFatalExceptionNotificationDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_AppStateFatalExceptionNotificationDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_AppStateFatalExceptionNotificationDefaultTypeInternal() {} + union { + Message_AppStateFatalExceptionNotification _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_AppStateFatalExceptionNotificationDefaultTypeInternal _Message_AppStateFatalExceptionNotification_default_instance_; +PROTOBUF_CONSTEXPR Message_AppStateSyncKeyData::Message_AppStateSyncKeyData( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.keydata_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.fingerprint_)*/nullptr + , /*decltype(_impl_.timestamp_)*/int64_t{0}} {} +struct Message_AppStateSyncKeyDataDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_AppStateSyncKeyDataDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_AppStateSyncKeyDataDefaultTypeInternal() {} + union { + Message_AppStateSyncKeyData _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_AppStateSyncKeyDataDefaultTypeInternal _Message_AppStateSyncKeyData_default_instance_; +PROTOBUF_CONSTEXPR Message_AppStateSyncKeyFingerprint::Message_AppStateSyncKeyFingerprint( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.deviceindexes_)*/{} + , /*decltype(_impl_._deviceindexes_cached_byte_size_)*/{0} + , /*decltype(_impl_.rawid_)*/0u + , /*decltype(_impl_.currentindex_)*/0u} {} +struct Message_AppStateSyncKeyFingerprintDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_AppStateSyncKeyFingerprintDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_AppStateSyncKeyFingerprintDefaultTypeInternal() {} + union { + Message_AppStateSyncKeyFingerprint _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_AppStateSyncKeyFingerprintDefaultTypeInternal _Message_AppStateSyncKeyFingerprint_default_instance_; +PROTOBUF_CONSTEXPR Message_AppStateSyncKeyId::Message_AppStateSyncKeyId( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.keyid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct Message_AppStateSyncKeyIdDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_AppStateSyncKeyIdDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_AppStateSyncKeyIdDefaultTypeInternal() {} + union { + Message_AppStateSyncKeyId _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_AppStateSyncKeyIdDefaultTypeInternal _Message_AppStateSyncKeyId_default_instance_; +PROTOBUF_CONSTEXPR Message_AppStateSyncKeyRequest::Message_AppStateSyncKeyRequest( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.keyids_)*/{} + , /*decltype(_impl_._cached_size_)*/{}} {} +struct Message_AppStateSyncKeyRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_AppStateSyncKeyRequestDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_AppStateSyncKeyRequestDefaultTypeInternal() {} + union { + Message_AppStateSyncKeyRequest _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_AppStateSyncKeyRequestDefaultTypeInternal _Message_AppStateSyncKeyRequest_default_instance_; +PROTOBUF_CONSTEXPR Message_AppStateSyncKeyShare::Message_AppStateSyncKeyShare( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.keys_)*/{} + , /*decltype(_impl_._cached_size_)*/{}} {} +struct Message_AppStateSyncKeyShareDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_AppStateSyncKeyShareDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_AppStateSyncKeyShareDefaultTypeInternal() {} + union { + Message_AppStateSyncKeyShare _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_AppStateSyncKeyShareDefaultTypeInternal _Message_AppStateSyncKeyShare_default_instance_; +PROTOBUF_CONSTEXPR Message_AppStateSyncKey::Message_AppStateSyncKey( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.keyid_)*/nullptr + , /*decltype(_impl_.keydata_)*/nullptr} {} +struct Message_AppStateSyncKeyDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_AppStateSyncKeyDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_AppStateSyncKeyDefaultTypeInternal() {} + union { + Message_AppStateSyncKey _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_AppStateSyncKeyDefaultTypeInternal _Message_AppStateSyncKey_default_instance_; +PROTOBUF_CONSTEXPR Message_AudioMessage::Message_AudioMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.mimetype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.filesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.fileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.streamingsidecar_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.waveform_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.contextinfo_)*/nullptr + , /*decltype(_impl_.filelength_)*/uint64_t{0u} + , /*decltype(_impl_.seconds_)*/0u + , /*decltype(_impl_.ptt_)*/false + , /*decltype(_impl_.mediakeytimestamp_)*/int64_t{0}} {} +struct Message_AudioMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_AudioMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_AudioMessageDefaultTypeInternal() {} + union { + Message_AudioMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_AudioMessageDefaultTypeInternal _Message_AudioMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_ButtonsMessage_Button_ButtonText::Message_ButtonsMessage_Button_ButtonText( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.displaytext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct Message_ButtonsMessage_Button_ButtonTextDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_ButtonsMessage_Button_ButtonTextDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_ButtonsMessage_Button_ButtonTextDefaultTypeInternal() {} + union { + Message_ButtonsMessage_Button_ButtonText _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ButtonsMessage_Button_ButtonTextDefaultTypeInternal _Message_ButtonsMessage_Button_ButtonText_default_instance_; +PROTOBUF_CONSTEXPR Message_ButtonsMessage_Button_NativeFlowInfo::Message_ButtonsMessage_Button_NativeFlowInfo( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.paramsjson_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct Message_ButtonsMessage_Button_NativeFlowInfoDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_ButtonsMessage_Button_NativeFlowInfoDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_ButtonsMessage_Button_NativeFlowInfoDefaultTypeInternal() {} + union { + Message_ButtonsMessage_Button_NativeFlowInfo _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ButtonsMessage_Button_NativeFlowInfoDefaultTypeInternal _Message_ButtonsMessage_Button_NativeFlowInfo_default_instance_; +PROTOBUF_CONSTEXPR Message_ButtonsMessage_Button::Message_ButtonsMessage_Button( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.buttonid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.buttontext_)*/nullptr + , /*decltype(_impl_.nativeflowinfo_)*/nullptr + , /*decltype(_impl_.type_)*/0} {} +struct Message_ButtonsMessage_ButtonDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_ButtonsMessage_ButtonDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_ButtonsMessage_ButtonDefaultTypeInternal() {} + union { + Message_ButtonsMessage_Button _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ButtonsMessage_ButtonDefaultTypeInternal _Message_ButtonsMessage_Button_default_instance_; +PROTOBUF_CONSTEXPR Message_ButtonsMessage::Message_ButtonsMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.buttons_)*/{} + , /*decltype(_impl_.contenttext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.footertext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.contextinfo_)*/nullptr + , /*decltype(_impl_.headertype_)*/0 + , /*decltype(_impl_.header_)*/{} + , /*decltype(_impl_._oneof_case_)*/{}} {} +struct Message_ButtonsMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_ButtonsMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_ButtonsMessageDefaultTypeInternal() {} + union { + Message_ButtonsMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ButtonsMessageDefaultTypeInternal _Message_ButtonsMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_ButtonsResponseMessage::Message_ButtonsResponseMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.selectedbuttonid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.contextinfo_)*/nullptr + , /*decltype(_impl_.type_)*/0 + , /*decltype(_impl_.response_)*/{} + , /*decltype(_impl_._oneof_case_)*/{}} {} +struct Message_ButtonsResponseMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_ButtonsResponseMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_ButtonsResponseMessageDefaultTypeInternal() {} + union { + Message_ButtonsResponseMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ButtonsResponseMessageDefaultTypeInternal _Message_ButtonsResponseMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_Call::Message_Call( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.callkey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.conversionsource_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.conversiondata_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.conversiondelayseconds_)*/0u} {} +struct Message_CallDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_CallDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_CallDefaultTypeInternal() {} + union { + Message_Call _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_CallDefaultTypeInternal _Message_Call_default_instance_; +PROTOBUF_CONSTEXPR Message_CancelPaymentRequestMessage::Message_CancelPaymentRequestMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.key_)*/nullptr} {} +struct Message_CancelPaymentRequestMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_CancelPaymentRequestMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_CancelPaymentRequestMessageDefaultTypeInternal() {} + union { + Message_CancelPaymentRequestMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_CancelPaymentRequestMessageDefaultTypeInternal _Message_CancelPaymentRequestMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_Chat::Message_Chat( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.displayname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct Message_ChatDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_ChatDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_ChatDefaultTypeInternal() {} + union { + Message_Chat _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ChatDefaultTypeInternal _Message_Chat_default_instance_; +PROTOBUF_CONSTEXPR Message_ContactMessage::Message_ContactMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.displayname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.vcard_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.contextinfo_)*/nullptr} {} +struct Message_ContactMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_ContactMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_ContactMessageDefaultTypeInternal() {} + union { + Message_ContactMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ContactMessageDefaultTypeInternal _Message_ContactMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_ContactsArrayMessage::Message_ContactsArrayMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.contacts_)*/{} + , /*decltype(_impl_.displayname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.contextinfo_)*/nullptr} {} +struct Message_ContactsArrayMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_ContactsArrayMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_ContactsArrayMessageDefaultTypeInternal() {} + union { + Message_ContactsArrayMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ContactsArrayMessageDefaultTypeInternal _Message_ContactsArrayMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_DeclinePaymentRequestMessage::Message_DeclinePaymentRequestMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.key_)*/nullptr} {} +struct Message_DeclinePaymentRequestMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_DeclinePaymentRequestMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_DeclinePaymentRequestMessageDefaultTypeInternal() {} + union { + Message_DeclinePaymentRequestMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_DeclinePaymentRequestMessageDefaultTypeInternal _Message_DeclinePaymentRequestMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_DeviceSentMessage::Message_DeviceSentMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.destinationjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.phash_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.message_)*/nullptr} {} +struct Message_DeviceSentMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_DeviceSentMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_DeviceSentMessageDefaultTypeInternal() {} + union { + Message_DeviceSentMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_DeviceSentMessageDefaultTypeInternal _Message_DeviceSentMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_DocumentMessage::Message_DocumentMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.mimetype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.filesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.filename_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.fileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.thumbnaildirectpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.thumbnailsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.thumbnailencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.jpegthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.caption_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.contextinfo_)*/nullptr + , /*decltype(_impl_.filelength_)*/uint64_t{0u} + , /*decltype(_impl_.pagecount_)*/0u + , /*decltype(_impl_.contactvcard_)*/false + , /*decltype(_impl_.mediakeytimestamp_)*/int64_t{0} + , /*decltype(_impl_.thumbnailheight_)*/0u + , /*decltype(_impl_.thumbnailwidth_)*/0u} {} +struct Message_DocumentMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_DocumentMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_DocumentMessageDefaultTypeInternal() {} + union { + Message_DocumentMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_DocumentMessageDefaultTypeInternal _Message_DocumentMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_ExtendedTextMessage::Message_ExtendedTextMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.text_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.matchedtext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.canonicalurl_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.description_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.jpegthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.thumbnaildirectpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.thumbnailsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.thumbnailencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.invitelinkparentgroupsubjectv2_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.invitelinkparentgroupthumbnailv2_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.contextinfo_)*/nullptr + , /*decltype(_impl_.textargb_)*/0u + , /*decltype(_impl_.backgroundargb_)*/0u + , /*decltype(_impl_.font_)*/0 + , /*decltype(_impl_.previewtype_)*/0 + , /*decltype(_impl_.donotplayinline_)*/false + , /*decltype(_impl_.thumbnailheight_)*/0u + , /*decltype(_impl_.mediakeytimestamp_)*/int64_t{0} + , /*decltype(_impl_.thumbnailwidth_)*/0u + , /*decltype(_impl_.invitelinkgrouptype_)*/0 + , /*decltype(_impl_.invitelinkgrouptypev2_)*/0} {} +struct Message_ExtendedTextMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_ExtendedTextMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_ExtendedTextMessageDefaultTypeInternal() {} + union { + Message_ExtendedTextMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ExtendedTextMessageDefaultTypeInternal _Message_ExtendedTextMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_FutureProofMessage::Message_FutureProofMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.message_)*/nullptr} {} +struct Message_FutureProofMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_FutureProofMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_FutureProofMessageDefaultTypeInternal() {} + union { + Message_FutureProofMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_FutureProofMessageDefaultTypeInternal _Message_FutureProofMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_GroupInviteMessage::Message_GroupInviteMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.groupjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.invitecode_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.groupname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.jpegthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.caption_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.contextinfo_)*/nullptr + , /*decltype(_impl_.inviteexpiration_)*/int64_t{0} + , /*decltype(_impl_.grouptype_)*/0} {} +struct Message_GroupInviteMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_GroupInviteMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_GroupInviteMessageDefaultTypeInternal() {} + union { + Message_GroupInviteMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_GroupInviteMessageDefaultTypeInternal _Message_GroupInviteMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.currencycode_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.amount1000_)*/int64_t{0}} {} +struct Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrencyDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrencyDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrencyDefaultTypeInternal() {} + union { + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrencyDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency_default_instance_; +PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.year_)*/0u + , /*decltype(_impl_.month_)*/0u + , /*decltype(_impl_.dayofmonth_)*/0u + , /*decltype(_impl_.hour_)*/0u + , /*decltype(_impl_.minute_)*/0u + , /*decltype(_impl_.dayofweek_)*/1 + , /*decltype(_impl_.calendar_)*/1} {} +struct Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponentDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponentDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponentDefaultTypeInternal() {} + union { + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponentDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_default_instance_; +PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.timestamp_)*/int64_t{0}} {} +struct Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpochDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpochDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpochDefaultTypeInternal() {} + union { + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpochDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch_default_instance_; +PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.datetimeOneof_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_._oneof_case_)*/{}} {} +struct Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTimeDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTimeDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTimeDefaultTypeInternal() {} + union { + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTimeDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_default_instance_; +PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter::Message_HighlyStructuredMessage_HSMLocalizableParameter( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.default__)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.paramOneof_)*/{} + , /*decltype(_impl_._oneof_case_)*/{}} {} +struct Message_HighlyStructuredMessage_HSMLocalizableParameterDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameterDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_HighlyStructuredMessage_HSMLocalizableParameterDefaultTypeInternal() {} + union { + Message_HighlyStructuredMessage_HSMLocalizableParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_HighlyStructuredMessage_HSMLocalizableParameterDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_default_instance_; +PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage::Message_HighlyStructuredMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.params_)*/{} + , /*decltype(_impl_.localizableparams_)*/{} + , /*decltype(_impl_.namespace__)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.elementname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.fallbacklg_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.fallbacklc_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.deterministiclg_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.deterministiclc_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.hydratedhsm_)*/nullptr} {} +struct Message_HighlyStructuredMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_HighlyStructuredMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_HighlyStructuredMessageDefaultTypeInternal() {} + union { + Message_HighlyStructuredMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_HighlyStructuredMessageDefaultTypeInternal _Message_HighlyStructuredMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_HistorySyncNotification::Message_HistorySyncNotification( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.filesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.fileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.originalmessageid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.filelength_)*/uint64_t{0u} + , /*decltype(_impl_.synctype_)*/0 + , /*decltype(_impl_.chunkorder_)*/0u + , /*decltype(_impl_.progress_)*/0u} {} +struct Message_HistorySyncNotificationDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_HistorySyncNotificationDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_HistorySyncNotificationDefaultTypeInternal() {} + union { + Message_HistorySyncNotification _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_HistorySyncNotificationDefaultTypeInternal _Message_HistorySyncNotification_default_instance_; +PROTOBUF_CONSTEXPR Message_ImageMessage::Message_ImageMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.interactiveannotations_)*/{} + , /*decltype(_impl_.scanlengths_)*/{} + , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.mimetype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.caption_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.filesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.fileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.jpegthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.firstscansidecar_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.scanssidecar_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.midqualityfilesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.midqualityfileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.thumbnaildirectpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.thumbnailsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.thumbnailencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.staticurl_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.contextinfo_)*/nullptr + , /*decltype(_impl_.filelength_)*/uint64_t{0u} + , /*decltype(_impl_.height_)*/0u + , /*decltype(_impl_.width_)*/0u + , /*decltype(_impl_.mediakeytimestamp_)*/int64_t{0} + , /*decltype(_impl_.firstscanlength_)*/0u + , /*decltype(_impl_.experimentgroupid_)*/0u + , /*decltype(_impl_.viewonce_)*/false} {} +struct Message_ImageMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_ImageMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_ImageMessageDefaultTypeInternal() {} + union { + Message_ImageMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ImageMessageDefaultTypeInternal _Message_ImageMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_InitialSecurityNotificationSettingSync::Message_InitialSecurityNotificationSettingSync( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.securitynotificationenabled_)*/false} {} +struct Message_InitialSecurityNotificationSettingSyncDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_InitialSecurityNotificationSettingSyncDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_InitialSecurityNotificationSettingSyncDefaultTypeInternal() {} + union { + Message_InitialSecurityNotificationSettingSync _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InitialSecurityNotificationSettingSyncDefaultTypeInternal _Message_InitialSecurityNotificationSettingSync_default_instance_; +PROTOBUF_CONSTEXPR Message_InteractiveMessage_Body::Message_InteractiveMessage_Body( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.text_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct Message_InteractiveMessage_BodyDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_InteractiveMessage_BodyDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_InteractiveMessage_BodyDefaultTypeInternal() {} + union { + Message_InteractiveMessage_Body _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveMessage_BodyDefaultTypeInternal _Message_InteractiveMessage_Body_default_instance_; +PROTOBUF_CONSTEXPR Message_InteractiveMessage_CollectionMessage::Message_InteractiveMessage_CollectionMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.bizjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.messageversion_)*/0} {} +struct Message_InteractiveMessage_CollectionMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_InteractiveMessage_CollectionMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_InteractiveMessage_CollectionMessageDefaultTypeInternal() {} + union { + Message_InteractiveMessage_CollectionMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveMessage_CollectionMessageDefaultTypeInternal _Message_InteractiveMessage_CollectionMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_InteractiveMessage_Footer::Message_InteractiveMessage_Footer( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.text_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct Message_InteractiveMessage_FooterDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_InteractiveMessage_FooterDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_InteractiveMessage_FooterDefaultTypeInternal() {} + union { + Message_InteractiveMessage_Footer _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveMessage_FooterDefaultTypeInternal _Message_InteractiveMessage_Footer_default_instance_; +PROTOBUF_CONSTEXPR Message_InteractiveMessage_Header::Message_InteractiveMessage_Header( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.subtitle_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.hasmediaattachment_)*/false + , /*decltype(_impl_.media_)*/{} + , /*decltype(_impl_._oneof_case_)*/{}} {} +struct Message_InteractiveMessage_HeaderDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_InteractiveMessage_HeaderDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_InteractiveMessage_HeaderDefaultTypeInternal() {} + union { + Message_InteractiveMessage_Header _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveMessage_HeaderDefaultTypeInternal _Message_InteractiveMessage_Header_default_instance_; +PROTOBUF_CONSTEXPR Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.buttonparamsjson_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct Message_InteractiveMessage_NativeFlowMessage_NativeFlowButtonDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_InteractiveMessage_NativeFlowMessage_NativeFlowButtonDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_InteractiveMessage_NativeFlowMessage_NativeFlowButtonDefaultTypeInternal() {} + union { + Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveMessage_NativeFlowMessage_NativeFlowButtonDefaultTypeInternal _Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton_default_instance_; +PROTOBUF_CONSTEXPR Message_InteractiveMessage_NativeFlowMessage::Message_InteractiveMessage_NativeFlowMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.buttons_)*/{} + , /*decltype(_impl_.messageparamsjson_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.messageversion_)*/0} {} +struct Message_InteractiveMessage_NativeFlowMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_InteractiveMessage_NativeFlowMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_InteractiveMessage_NativeFlowMessageDefaultTypeInternal() {} + union { + Message_InteractiveMessage_NativeFlowMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveMessage_NativeFlowMessageDefaultTypeInternal _Message_InteractiveMessage_NativeFlowMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_InteractiveMessage_ShopMessage::Message_InteractiveMessage_ShopMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.surface_)*/0 + , /*decltype(_impl_.messageversion_)*/0} {} +struct Message_InteractiveMessage_ShopMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_InteractiveMessage_ShopMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_InteractiveMessage_ShopMessageDefaultTypeInternal() {} + union { + Message_InteractiveMessage_ShopMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveMessage_ShopMessageDefaultTypeInternal _Message_InteractiveMessage_ShopMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_InteractiveMessage::Message_InteractiveMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.header_)*/nullptr + , /*decltype(_impl_.body_)*/nullptr + , /*decltype(_impl_.footer_)*/nullptr + , /*decltype(_impl_.contextinfo_)*/nullptr + , /*decltype(_impl_.interactiveMessage_)*/{} + , /*decltype(_impl_._oneof_case_)*/{}} {} +struct Message_InteractiveMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_InteractiveMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_InteractiveMessageDefaultTypeInternal() {} + union { + Message_InteractiveMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveMessageDefaultTypeInternal _Message_InteractiveMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_InteractiveResponseMessage_Body::Message_InteractiveResponseMessage_Body( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.text_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct Message_InteractiveResponseMessage_BodyDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_InteractiveResponseMessage_BodyDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_InteractiveResponseMessage_BodyDefaultTypeInternal() {} + union { + Message_InteractiveResponseMessage_Body _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveResponseMessage_BodyDefaultTypeInternal _Message_InteractiveResponseMessage_Body_default_instance_; +PROTOBUF_CONSTEXPR Message_InteractiveResponseMessage_NativeFlowResponseMessage::Message_InteractiveResponseMessage_NativeFlowResponseMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.paramsjson_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.version_)*/0} {} +struct Message_InteractiveResponseMessage_NativeFlowResponseMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_InteractiveResponseMessage_NativeFlowResponseMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_InteractiveResponseMessage_NativeFlowResponseMessageDefaultTypeInternal() {} + union { + Message_InteractiveResponseMessage_NativeFlowResponseMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveResponseMessage_NativeFlowResponseMessageDefaultTypeInternal _Message_InteractiveResponseMessage_NativeFlowResponseMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_InteractiveResponseMessage::Message_InteractiveResponseMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.body_)*/nullptr + , /*decltype(_impl_.contextinfo_)*/nullptr + , /*decltype(_impl_.interactiveResponseMessage_)*/{} + , /*decltype(_impl_._oneof_case_)*/{}} {} +struct Message_InteractiveResponseMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_InteractiveResponseMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_InteractiveResponseMessageDefaultTypeInternal() {} + union { + Message_InteractiveResponseMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveResponseMessageDefaultTypeInternal _Message_InteractiveResponseMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_InvoiceMessage::Message_InvoiceMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.note_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.token_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.attachmentmimetype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.attachmentmediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.attachmentfilesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.attachmentfileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.attachmentdirectpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.attachmentjpegthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.attachmentmediakeytimestamp_)*/int64_t{0} + , /*decltype(_impl_.attachmenttype_)*/0} {} +struct Message_InvoiceMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_InvoiceMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_InvoiceMessageDefaultTypeInternal() {} + union { + Message_InvoiceMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InvoiceMessageDefaultTypeInternal _Message_InvoiceMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_KeepInChatMessage::Message_KeepInChatMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.key_)*/nullptr + , /*decltype(_impl_.timestampms_)*/int64_t{0} + , /*decltype(_impl_.keeptype_)*/0} {} +struct Message_KeepInChatMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_KeepInChatMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_KeepInChatMessageDefaultTypeInternal() {} + union { + Message_KeepInChatMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_KeepInChatMessageDefaultTypeInternal _Message_KeepInChatMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_ListMessage_ProductListHeaderImage::Message_ListMessage_ProductListHeaderImage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.productid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.jpegthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct Message_ListMessage_ProductListHeaderImageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_ListMessage_ProductListHeaderImageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_ListMessage_ProductListHeaderImageDefaultTypeInternal() {} + union { + Message_ListMessage_ProductListHeaderImage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ListMessage_ProductListHeaderImageDefaultTypeInternal _Message_ListMessage_ProductListHeaderImage_default_instance_; +PROTOBUF_CONSTEXPR Message_ListMessage_ProductListInfo::Message_ListMessage_ProductListInfo( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.productsections_)*/{} + , /*decltype(_impl_.businessownerjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.headerimage_)*/nullptr} {} +struct Message_ListMessage_ProductListInfoDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_ListMessage_ProductListInfoDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_ListMessage_ProductListInfoDefaultTypeInternal() {} + union { + Message_ListMessage_ProductListInfo _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ListMessage_ProductListInfoDefaultTypeInternal _Message_ListMessage_ProductListInfo_default_instance_; +PROTOBUF_CONSTEXPR Message_ListMessage_ProductSection::Message_ListMessage_ProductSection( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.products_)*/{} + , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct Message_ListMessage_ProductSectionDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_ListMessage_ProductSectionDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_ListMessage_ProductSectionDefaultTypeInternal() {} + union { + Message_ListMessage_ProductSection _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ListMessage_ProductSectionDefaultTypeInternal _Message_ListMessage_ProductSection_default_instance_; +PROTOBUF_CONSTEXPR Message_ListMessage_Product::Message_ListMessage_Product( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.productid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct Message_ListMessage_ProductDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_ListMessage_ProductDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_ListMessage_ProductDefaultTypeInternal() {} + union { + Message_ListMessage_Product _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ListMessage_ProductDefaultTypeInternal _Message_ListMessage_Product_default_instance_; +PROTOBUF_CONSTEXPR Message_ListMessage_Row::Message_ListMessage_Row( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.description_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.rowid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct Message_ListMessage_RowDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_ListMessage_RowDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_ListMessage_RowDefaultTypeInternal() {} + union { + Message_ListMessage_Row _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ListMessage_RowDefaultTypeInternal _Message_ListMessage_Row_default_instance_; +PROTOBUF_CONSTEXPR Message_ListMessage_Section::Message_ListMessage_Section( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.rows_)*/{} + , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct Message_ListMessage_SectionDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_ListMessage_SectionDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_ListMessage_SectionDefaultTypeInternal() {} + union { + Message_ListMessage_Section _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ListMessage_SectionDefaultTypeInternal _Message_ListMessage_Section_default_instance_; +PROTOBUF_CONSTEXPR Message_ListMessage::Message_ListMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.sections_)*/{} + , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.description_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.buttontext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.footertext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.productlistinfo_)*/nullptr + , /*decltype(_impl_.contextinfo_)*/nullptr + , /*decltype(_impl_.listtype_)*/0} {} +struct Message_ListMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_ListMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_ListMessageDefaultTypeInternal() {} + union { + Message_ListMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ListMessageDefaultTypeInternal _Message_ListMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_ListResponseMessage_SingleSelectReply::Message_ListResponseMessage_SingleSelectReply( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.selectedrowid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct Message_ListResponseMessage_SingleSelectReplyDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_ListResponseMessage_SingleSelectReplyDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_ListResponseMessage_SingleSelectReplyDefaultTypeInternal() {} + union { + Message_ListResponseMessage_SingleSelectReply _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ListResponseMessage_SingleSelectReplyDefaultTypeInternal _Message_ListResponseMessage_SingleSelectReply_default_instance_; +PROTOBUF_CONSTEXPR Message_ListResponseMessage::Message_ListResponseMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.description_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.singleselectreply_)*/nullptr + , /*decltype(_impl_.contextinfo_)*/nullptr + , /*decltype(_impl_.listtype_)*/0} {} +struct Message_ListResponseMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_ListResponseMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_ListResponseMessageDefaultTypeInternal() {} + union { + Message_ListResponseMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ListResponseMessageDefaultTypeInternal _Message_ListResponseMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_LiveLocationMessage::Message_LiveLocationMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.caption_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.jpegthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.contextinfo_)*/nullptr + , /*decltype(_impl_.degreeslatitude_)*/0 + , /*decltype(_impl_.degreeslongitude_)*/0 + , /*decltype(_impl_.accuracyinmeters_)*/0u + , /*decltype(_impl_.speedinmps_)*/0 + , /*decltype(_impl_.degreesclockwisefrommagneticnorth_)*/0u + , /*decltype(_impl_.timeoffset_)*/0u + , /*decltype(_impl_.sequencenumber_)*/int64_t{0}} {} +struct Message_LiveLocationMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_LiveLocationMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_LiveLocationMessageDefaultTypeInternal() {} + union { + Message_LiveLocationMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_LiveLocationMessageDefaultTypeInternal _Message_LiveLocationMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_LocationMessage::Message_LocationMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.address_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.comment_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.jpegthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.contextinfo_)*/nullptr + , /*decltype(_impl_.degreeslatitude_)*/0 + , /*decltype(_impl_.degreeslongitude_)*/0 + , /*decltype(_impl_.islive_)*/false + , /*decltype(_impl_.accuracyinmeters_)*/0u + , /*decltype(_impl_.speedinmps_)*/0 + , /*decltype(_impl_.degreesclockwisefrommagneticnorth_)*/0u} {} +struct Message_LocationMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_LocationMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_LocationMessageDefaultTypeInternal() {} + union { + Message_LocationMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_LocationMessageDefaultTypeInternal _Message_LocationMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_OrderMessage::Message_OrderMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.orderid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.thumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.message_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.ordertitle_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.sellerjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.token_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.totalcurrencycode_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.contextinfo_)*/nullptr + , /*decltype(_impl_.totalamount1000_)*/int64_t{0} + , /*decltype(_impl_.itemcount_)*/0 + , /*decltype(_impl_.status_)*/1 + , /*decltype(_impl_.surface_)*/1} {} +struct Message_OrderMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_OrderMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_OrderMessageDefaultTypeInternal() {} + union { + Message_OrderMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_OrderMessageDefaultTypeInternal _Message_OrderMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_PaymentInviteMessage::Message_PaymentInviteMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.expirytimestamp_)*/int64_t{0} + , /*decltype(_impl_.servicetype_)*/0} {} +struct Message_PaymentInviteMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_PaymentInviteMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_PaymentInviteMessageDefaultTypeInternal() {} + union { + Message_PaymentInviteMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_PaymentInviteMessageDefaultTypeInternal _Message_PaymentInviteMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_PollCreationMessage_Option::Message_PollCreationMessage_Option( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.optionname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct Message_PollCreationMessage_OptionDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_PollCreationMessage_OptionDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_PollCreationMessage_OptionDefaultTypeInternal() {} + union { + Message_PollCreationMessage_Option _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_PollCreationMessage_OptionDefaultTypeInternal _Message_PollCreationMessage_Option_default_instance_; +PROTOBUF_CONSTEXPR Message_PollCreationMessage::Message_PollCreationMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.options_)*/{} + , /*decltype(_impl_.enckey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.contextinfo_)*/nullptr + , /*decltype(_impl_.selectableoptionscount_)*/0u} {} +struct Message_PollCreationMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_PollCreationMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_PollCreationMessageDefaultTypeInternal() {} + union { + Message_PollCreationMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_PollCreationMessageDefaultTypeInternal _Message_PollCreationMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_PollEncValue::Message_PollEncValue( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.encpayload_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.enciv_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct Message_PollEncValueDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_PollEncValueDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_PollEncValueDefaultTypeInternal() {} + union { + Message_PollEncValue _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_PollEncValueDefaultTypeInternal _Message_PollEncValue_default_instance_; +PROTOBUF_CONSTEXPR Message_PollUpdateMessageMetadata::Message_PollUpdateMessageMetadata( + ::_pbi::ConstantInitialized) {} +struct Message_PollUpdateMessageMetadataDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_PollUpdateMessageMetadataDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_PollUpdateMessageMetadataDefaultTypeInternal() {} + union { + Message_PollUpdateMessageMetadata _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_PollUpdateMessageMetadataDefaultTypeInternal _Message_PollUpdateMessageMetadata_default_instance_; +PROTOBUF_CONSTEXPR Message_PollUpdateMessage::Message_PollUpdateMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.pollcreationmessagekey_)*/nullptr + , /*decltype(_impl_.vote_)*/nullptr + , /*decltype(_impl_.metadata_)*/nullptr + , /*decltype(_impl_.sendertimestampms_)*/int64_t{0}} {} +struct Message_PollUpdateMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_PollUpdateMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_PollUpdateMessageDefaultTypeInternal() {} + union { + Message_PollUpdateMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_PollUpdateMessageDefaultTypeInternal _Message_PollUpdateMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_PollVoteMessage::Message_PollVoteMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.selectedoptions_)*/{} + , /*decltype(_impl_._cached_size_)*/{}} {} +struct Message_PollVoteMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_PollVoteMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_PollVoteMessageDefaultTypeInternal() {} + union { + Message_PollVoteMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_PollVoteMessageDefaultTypeInternal _Message_PollVoteMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_ProductMessage_CatalogSnapshot::Message_ProductMessage_CatalogSnapshot( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.description_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.catalogimage_)*/nullptr} {} +struct Message_ProductMessage_CatalogSnapshotDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_ProductMessage_CatalogSnapshotDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_ProductMessage_CatalogSnapshotDefaultTypeInternal() {} + union { + Message_ProductMessage_CatalogSnapshot _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ProductMessage_CatalogSnapshotDefaultTypeInternal _Message_ProductMessage_CatalogSnapshot_default_instance_; +PROTOBUF_CONSTEXPR Message_ProductMessage_ProductSnapshot::Message_ProductMessage_ProductSnapshot( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.productid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.description_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.currencycode_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.retailerid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.firstimageid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.productimage_)*/nullptr + , /*decltype(_impl_.priceamount1000_)*/int64_t{0} + , /*decltype(_impl_.salepriceamount1000_)*/int64_t{0} + , /*decltype(_impl_.productimagecount_)*/0u} {} +struct Message_ProductMessage_ProductSnapshotDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_ProductMessage_ProductSnapshotDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_ProductMessage_ProductSnapshotDefaultTypeInternal() {} + union { + Message_ProductMessage_ProductSnapshot _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ProductMessage_ProductSnapshotDefaultTypeInternal _Message_ProductMessage_ProductSnapshot_default_instance_; +PROTOBUF_CONSTEXPR Message_ProductMessage::Message_ProductMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.businessownerjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.body_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.footer_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.product_)*/nullptr + , /*decltype(_impl_.catalog_)*/nullptr + , /*decltype(_impl_.contextinfo_)*/nullptr} {} +struct Message_ProductMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_ProductMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_ProductMessageDefaultTypeInternal() {} + union { + Message_ProductMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ProductMessageDefaultTypeInternal _Message_ProductMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_ProtocolMessage::Message_ProtocolMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.key_)*/nullptr + , /*decltype(_impl_.historysyncnotification_)*/nullptr + , /*decltype(_impl_.appstatesynckeyshare_)*/nullptr + , /*decltype(_impl_.appstatesynckeyrequest_)*/nullptr + , /*decltype(_impl_.initialsecuritynotificationsettingsync_)*/nullptr + , /*decltype(_impl_.appstatefatalexceptionnotification_)*/nullptr + , /*decltype(_impl_.disappearingmode_)*/nullptr + , /*decltype(_impl_.requestmediauploadmessage_)*/nullptr + , /*decltype(_impl_.requestmediauploadresponsemessage_)*/nullptr + , /*decltype(_impl_.type_)*/0 + , /*decltype(_impl_.ephemeralexpiration_)*/0u + , /*decltype(_impl_.ephemeralsettingtimestamp_)*/int64_t{0}} {} +struct Message_ProtocolMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_ProtocolMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_ProtocolMessageDefaultTypeInternal() {} + union { + Message_ProtocolMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ProtocolMessageDefaultTypeInternal _Message_ProtocolMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_ReactionMessage::Message_ReactionMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.text_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.groupingkey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.key_)*/nullptr + , /*decltype(_impl_.sendertimestampms_)*/int64_t{0}} {} +struct Message_ReactionMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_ReactionMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_ReactionMessageDefaultTypeInternal() {} + union { + Message_ReactionMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ReactionMessageDefaultTypeInternal _Message_ReactionMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_RequestMediaUploadMessage::Message_RequestMediaUploadMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.filesha256_)*/{} + , /*decltype(_impl_.rmrsource_)*/0} {} +struct Message_RequestMediaUploadMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_RequestMediaUploadMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_RequestMediaUploadMessageDefaultTypeInternal() {} + union { + Message_RequestMediaUploadMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_RequestMediaUploadMessageDefaultTypeInternal _Message_RequestMediaUploadMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.filesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.stickermessage_)*/nullptr + , /*decltype(_impl_.mediauploadresult_)*/0} {} +struct Message_RequestMediaUploadResponseMessage_RequestMediaUploadResultDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_RequestMediaUploadResponseMessage_RequestMediaUploadResultDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_RequestMediaUploadResponseMessage_RequestMediaUploadResultDefaultTypeInternal() {} + union { + Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_RequestMediaUploadResponseMessage_RequestMediaUploadResultDefaultTypeInternal _Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult_default_instance_; +PROTOBUF_CONSTEXPR Message_RequestMediaUploadResponseMessage::Message_RequestMediaUploadResponseMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.reuploadresult_)*/{} + , /*decltype(_impl_.stanzaid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.rmrsource_)*/0} {} +struct Message_RequestMediaUploadResponseMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_RequestMediaUploadResponseMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_RequestMediaUploadResponseMessageDefaultTypeInternal() {} + union { + Message_RequestMediaUploadResponseMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_RequestMediaUploadResponseMessageDefaultTypeInternal _Message_RequestMediaUploadResponseMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_RequestPaymentMessage::Message_RequestPaymentMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.currencycodeiso4217_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.requestfrom_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.notemessage_)*/nullptr + , /*decltype(_impl_.amount_)*/nullptr + , /*decltype(_impl_.background_)*/nullptr + , /*decltype(_impl_.amount1000_)*/uint64_t{0u} + , /*decltype(_impl_.expirytimestamp_)*/int64_t{0}} {} +struct Message_RequestPaymentMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_RequestPaymentMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_RequestPaymentMessageDefaultTypeInternal() {} + union { + Message_RequestPaymentMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_RequestPaymentMessageDefaultTypeInternal _Message_RequestPaymentMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_RequestPhoneNumberMessage::Message_RequestPhoneNumberMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.contextinfo_)*/nullptr} {} +struct Message_RequestPhoneNumberMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_RequestPhoneNumberMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_RequestPhoneNumberMessageDefaultTypeInternal() {} + union { + Message_RequestPhoneNumberMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_RequestPhoneNumberMessageDefaultTypeInternal _Message_RequestPhoneNumberMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_SendPaymentMessage::Message_SendPaymentMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.notemessage_)*/nullptr + , /*decltype(_impl_.requestmessagekey_)*/nullptr + , /*decltype(_impl_.background_)*/nullptr} {} +struct Message_SendPaymentMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_SendPaymentMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_SendPaymentMessageDefaultTypeInternal() {} + union { + Message_SendPaymentMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_SendPaymentMessageDefaultTypeInternal _Message_SendPaymentMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_SenderKeyDistributionMessage::Message_SenderKeyDistributionMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.groupid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.axolotlsenderkeydistributionmessage_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct Message_SenderKeyDistributionMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_SenderKeyDistributionMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_SenderKeyDistributionMessageDefaultTypeInternal() {} + union { + Message_SenderKeyDistributionMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_SenderKeyDistributionMessageDefaultTypeInternal _Message_SenderKeyDistributionMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_StickerMessage::Message_StickerMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.filesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.fileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.mimetype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.firstframesidecar_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.pngthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.contextinfo_)*/nullptr + , /*decltype(_impl_.height_)*/0u + , /*decltype(_impl_.width_)*/0u + , /*decltype(_impl_.filelength_)*/uint64_t{0u} + , /*decltype(_impl_.mediakeytimestamp_)*/int64_t{0} + , /*decltype(_impl_.firstframelength_)*/0u + , /*decltype(_impl_.isanimated_)*/false} {} +struct Message_StickerMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_StickerMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_StickerMessageDefaultTypeInternal() {} + union { + Message_StickerMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_StickerMessageDefaultTypeInternal _Message_StickerMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_StickerSyncRMRMessage::Message_StickerSyncRMRMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.filehash_)*/{} + , /*decltype(_impl_.rmrsource_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.requesttimestamp_)*/int64_t{0}} {} +struct Message_StickerSyncRMRMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_StickerSyncRMRMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_StickerSyncRMRMessageDefaultTypeInternal() {} + union { + Message_StickerSyncRMRMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_StickerSyncRMRMessageDefaultTypeInternal _Message_StickerSyncRMRMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_TemplateButtonReplyMessage::Message_TemplateButtonReplyMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.selectedid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.selecteddisplaytext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.contextinfo_)*/nullptr + , /*decltype(_impl_.selectedindex_)*/0u} {} +struct Message_TemplateButtonReplyMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_TemplateButtonReplyMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_TemplateButtonReplyMessageDefaultTypeInternal() {} + union { + Message_TemplateButtonReplyMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_TemplateButtonReplyMessageDefaultTypeInternal _Message_TemplateButtonReplyMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_TemplateMessage_FourRowTemplate::Message_TemplateMessage_FourRowTemplate( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.buttons_)*/{} + , /*decltype(_impl_.content_)*/nullptr + , /*decltype(_impl_.footer_)*/nullptr + , /*decltype(_impl_.title_)*/{} + , /*decltype(_impl_._oneof_case_)*/{}} {} +struct Message_TemplateMessage_FourRowTemplateDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_TemplateMessage_FourRowTemplateDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_TemplateMessage_FourRowTemplateDefaultTypeInternal() {} + union { + Message_TemplateMessage_FourRowTemplate _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_TemplateMessage_FourRowTemplateDefaultTypeInternal _Message_TemplateMessage_FourRowTemplate_default_instance_; +PROTOBUF_CONSTEXPR Message_TemplateMessage_HydratedFourRowTemplate::Message_TemplateMessage_HydratedFourRowTemplate( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.hydratedbuttons_)*/{} + , /*decltype(_impl_.hydratedcontenttext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.hydratedfootertext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.templateid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.title_)*/{} + , /*decltype(_impl_._oneof_case_)*/{}} {} +struct Message_TemplateMessage_HydratedFourRowTemplateDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_TemplateMessage_HydratedFourRowTemplateDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_TemplateMessage_HydratedFourRowTemplateDefaultTypeInternal() {} + union { + Message_TemplateMessage_HydratedFourRowTemplate _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_TemplateMessage_HydratedFourRowTemplateDefaultTypeInternal _Message_TemplateMessage_HydratedFourRowTemplate_default_instance_; +PROTOBUF_CONSTEXPR Message_TemplateMessage::Message_TemplateMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.contextinfo_)*/nullptr + , /*decltype(_impl_.hydratedtemplate_)*/nullptr + , /*decltype(_impl_.format_)*/{} + , /*decltype(_impl_._oneof_case_)*/{}} {} +struct Message_TemplateMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_TemplateMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_TemplateMessageDefaultTypeInternal() {} + union { + Message_TemplateMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_TemplateMessageDefaultTypeInternal _Message_TemplateMessage_default_instance_; +PROTOBUF_CONSTEXPR Message_VideoMessage::Message_VideoMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.interactiveannotations_)*/{} + , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.mimetype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.filesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.caption_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.fileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.jpegthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.streamingsidecar_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.thumbnaildirectpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.thumbnailsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.thumbnailencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.staticurl_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.contextinfo_)*/nullptr + , /*decltype(_impl_.filelength_)*/uint64_t{0u} + , /*decltype(_impl_.seconds_)*/0u + , /*decltype(_impl_.height_)*/0u + , /*decltype(_impl_.width_)*/0u + , /*decltype(_impl_.gifplayback_)*/false + , /*decltype(_impl_.viewonce_)*/false + , /*decltype(_impl_.mediakeytimestamp_)*/int64_t{0} + , /*decltype(_impl_.gifattribution_)*/0} {} +struct Message_VideoMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR Message_VideoMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~Message_VideoMessageDefaultTypeInternal() {} + union { + Message_VideoMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_VideoMessageDefaultTypeInternal _Message_VideoMessage_default_instance_; +PROTOBUF_CONSTEXPR Message::Message( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.conversation_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.senderkeydistributionmessage_)*/nullptr + , /*decltype(_impl_.imagemessage_)*/nullptr + , /*decltype(_impl_.contactmessage_)*/nullptr + , /*decltype(_impl_.locationmessage_)*/nullptr + , /*decltype(_impl_.extendedtextmessage_)*/nullptr + , /*decltype(_impl_.documentmessage_)*/nullptr + , /*decltype(_impl_.audiomessage_)*/nullptr + , /*decltype(_impl_.videomessage_)*/nullptr + , /*decltype(_impl_.call_)*/nullptr + , /*decltype(_impl_.chat_)*/nullptr + , /*decltype(_impl_.protocolmessage_)*/nullptr + , /*decltype(_impl_.contactsarraymessage_)*/nullptr + , /*decltype(_impl_.highlystructuredmessage_)*/nullptr + , /*decltype(_impl_.fastratchetkeysenderkeydistributionmessage_)*/nullptr + , /*decltype(_impl_.sendpaymentmessage_)*/nullptr + , /*decltype(_impl_.livelocationmessage_)*/nullptr + , /*decltype(_impl_.requestpaymentmessage_)*/nullptr + , /*decltype(_impl_.declinepaymentrequestmessage_)*/nullptr + , /*decltype(_impl_.cancelpaymentrequestmessage_)*/nullptr + , /*decltype(_impl_.templatemessage_)*/nullptr + , /*decltype(_impl_.stickermessage_)*/nullptr + , /*decltype(_impl_.groupinvitemessage_)*/nullptr + , /*decltype(_impl_.templatebuttonreplymessage_)*/nullptr + , /*decltype(_impl_.productmessage_)*/nullptr + , /*decltype(_impl_.devicesentmessage_)*/nullptr + , /*decltype(_impl_.messagecontextinfo_)*/nullptr + , /*decltype(_impl_.listmessage_)*/nullptr + , /*decltype(_impl_.viewoncemessage_)*/nullptr + , /*decltype(_impl_.ordermessage_)*/nullptr + , /*decltype(_impl_.listresponsemessage_)*/nullptr + , /*decltype(_impl_.ephemeralmessage_)*/nullptr + , /*decltype(_impl_.invoicemessage_)*/nullptr + , /*decltype(_impl_.buttonsmessage_)*/nullptr + , /*decltype(_impl_.buttonsresponsemessage_)*/nullptr + , /*decltype(_impl_.paymentinvitemessage_)*/nullptr + , /*decltype(_impl_.interactivemessage_)*/nullptr + , /*decltype(_impl_.reactionmessage_)*/nullptr + , /*decltype(_impl_.stickersyncrmrmessage_)*/nullptr + , /*decltype(_impl_.interactiveresponsemessage_)*/nullptr + , /*decltype(_impl_.pollcreationmessage_)*/nullptr + , /*decltype(_impl_.pollupdatemessage_)*/nullptr + , /*decltype(_impl_.keepinchatmessage_)*/nullptr + , /*decltype(_impl_.documentwithcaptionmessage_)*/nullptr + , /*decltype(_impl_.requestphonenumbermessage_)*/nullptr + , /*decltype(_impl_.viewoncemessagev2_)*/nullptr} {} +struct MessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR MessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~MessageDefaultTypeInternal() {} + union { + Message _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MessageDefaultTypeInternal _Message_default_instance_; +PROTOBUF_CONSTEXPR MessageContextInfo::MessageContextInfo( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.messagesecret_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.paddingbytes_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.devicelistmetadata_)*/nullptr + , /*decltype(_impl_.devicelistmetadataversion_)*/0} {} +struct MessageContextInfoDefaultTypeInternal { + PROTOBUF_CONSTEXPR MessageContextInfoDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~MessageContextInfoDefaultTypeInternal() {} + union { + MessageContextInfo _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MessageContextInfoDefaultTypeInternal _MessageContextInfo_default_instance_; +PROTOBUF_CONSTEXPR MessageKey::MessageKey( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.remotejid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.participant_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.fromme_)*/false} {} +struct MessageKeyDefaultTypeInternal { + PROTOBUF_CONSTEXPR MessageKeyDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~MessageKeyDefaultTypeInternal() {} + union { + MessageKey _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MessageKeyDefaultTypeInternal _MessageKey_default_instance_; +PROTOBUF_CONSTEXPR Money::Money( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.currencycode_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.value_)*/int64_t{0} + , /*decltype(_impl_.offset_)*/0u} {} +struct MoneyDefaultTypeInternal { + PROTOBUF_CONSTEXPR MoneyDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~MoneyDefaultTypeInternal() {} + union { + Money _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MoneyDefaultTypeInternal _Money_default_instance_; +PROTOBUF_CONSTEXPR MsgOpaqueData_PollOption::MsgOpaqueData_PollOption( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct MsgOpaqueData_PollOptionDefaultTypeInternal { + PROTOBUF_CONSTEXPR MsgOpaqueData_PollOptionDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~MsgOpaqueData_PollOptionDefaultTypeInternal() {} + union { + MsgOpaqueData_PollOption _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MsgOpaqueData_PollOptionDefaultTypeInternal _MsgOpaqueData_PollOption_default_instance_; +PROTOBUF_CONSTEXPR MsgOpaqueData::MsgOpaqueData( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.polloptions_)*/{} + , /*decltype(_impl_.body_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.caption_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.paymentnotemsgbody_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.canonicalurl_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.matchedtext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.description_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.futureproofbuffer_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.clienturl_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.loc_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.pollname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.messagesecret_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.pollupdateparentkey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.encpollvote_)*/nullptr + , /*decltype(_impl_.lng_)*/0 + , /*decltype(_impl_.lat_)*/0 + , /*decltype(_impl_.islive_)*/false + , /*decltype(_impl_.paymentamount1000_)*/0 + , /*decltype(_impl_.sendertimestampms_)*/int64_t{0} + , /*decltype(_impl_.pollselectableoptionscount_)*/0u} {} +struct MsgOpaqueDataDefaultTypeInternal { + PROTOBUF_CONSTEXPR MsgOpaqueDataDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~MsgOpaqueDataDefaultTypeInternal() {} + union { + MsgOpaqueData _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MsgOpaqueDataDefaultTypeInternal _MsgOpaqueData_default_instance_; +PROTOBUF_CONSTEXPR MsgRowOpaqueData::MsgRowOpaqueData( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.currentmsg_)*/nullptr + , /*decltype(_impl_.quotedmsg_)*/nullptr} {} +struct MsgRowOpaqueDataDefaultTypeInternal { + PROTOBUF_CONSTEXPR MsgRowOpaqueDataDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~MsgRowOpaqueDataDefaultTypeInternal() {} + union { + MsgRowOpaqueData _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MsgRowOpaqueDataDefaultTypeInternal _MsgRowOpaqueData_default_instance_; +PROTOBUF_CONSTEXPR NoiseCertificate_Details::NoiseCertificate_Details( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.issuer_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.subject_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.key_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.expires_)*/uint64_t{0u} + , /*decltype(_impl_.serial_)*/0u} {} +struct NoiseCertificate_DetailsDefaultTypeInternal { + PROTOBUF_CONSTEXPR NoiseCertificate_DetailsDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~NoiseCertificate_DetailsDefaultTypeInternal() {} + union { + NoiseCertificate_Details _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NoiseCertificate_DetailsDefaultTypeInternal _NoiseCertificate_Details_default_instance_; +PROTOBUF_CONSTEXPR NoiseCertificate::NoiseCertificate( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.details_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.signature_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct NoiseCertificateDefaultTypeInternal { + PROTOBUF_CONSTEXPR NoiseCertificateDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~NoiseCertificateDefaultTypeInternal() {} + union { + NoiseCertificate _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NoiseCertificateDefaultTypeInternal _NoiseCertificate_default_instance_; +PROTOBUF_CONSTEXPR NotificationMessageInfo::NotificationMessageInfo( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.participant_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.key_)*/nullptr + , /*decltype(_impl_.message_)*/nullptr + , /*decltype(_impl_.messagetimestamp_)*/uint64_t{0u}} {} +struct NotificationMessageInfoDefaultTypeInternal { + PROTOBUF_CONSTEXPR NotificationMessageInfoDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~NotificationMessageInfoDefaultTypeInternal() {} + union { + NotificationMessageInfo _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NotificationMessageInfoDefaultTypeInternal _NotificationMessageInfo_default_instance_; +PROTOBUF_CONSTEXPR PastParticipant::PastParticipant( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.userjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.leavets_)*/uint64_t{0u} + , /*decltype(_impl_.leavereason_)*/0} {} +struct PastParticipantDefaultTypeInternal { + PROTOBUF_CONSTEXPR PastParticipantDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~PastParticipantDefaultTypeInternal() {} + union { + PastParticipant _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PastParticipantDefaultTypeInternal _PastParticipant_default_instance_; +PROTOBUF_CONSTEXPR PastParticipants::PastParticipants( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.pastparticipants_)*/{} + , /*decltype(_impl_.groupjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct PastParticipantsDefaultTypeInternal { + PROTOBUF_CONSTEXPR PastParticipantsDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~PastParticipantsDefaultTypeInternal() {} + union { + PastParticipants _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PastParticipantsDefaultTypeInternal _PastParticipants_default_instance_; +PROTOBUF_CONSTEXPR PaymentBackground_MediaData::PaymentBackground_MediaData( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.filesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.fileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.mediakeytimestamp_)*/int64_t{0}} {} +struct PaymentBackground_MediaDataDefaultTypeInternal { + PROTOBUF_CONSTEXPR PaymentBackground_MediaDataDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~PaymentBackground_MediaDataDefaultTypeInternal() {} + union { + PaymentBackground_MediaData _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PaymentBackground_MediaDataDefaultTypeInternal _PaymentBackground_MediaData_default_instance_; +PROTOBUF_CONSTEXPR PaymentBackground::PaymentBackground( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.mimetype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.mediadata_)*/nullptr + , /*decltype(_impl_.filelength_)*/uint64_t{0u} + , /*decltype(_impl_.width_)*/0u + , /*decltype(_impl_.height_)*/0u + , /*decltype(_impl_.placeholderargb_)*/0u + , /*decltype(_impl_.textargb_)*/0u + , /*decltype(_impl_.subtextargb_)*/0u + , /*decltype(_impl_.type_)*/0} {} +struct PaymentBackgroundDefaultTypeInternal { + PROTOBUF_CONSTEXPR PaymentBackgroundDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~PaymentBackgroundDefaultTypeInternal() {} + union { + PaymentBackground _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PaymentBackgroundDefaultTypeInternal _PaymentBackground_default_instance_; +PROTOBUF_CONSTEXPR PaymentInfo::PaymentInfo( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.receiverjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.currency_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.requestmessagekey_)*/nullptr + , /*decltype(_impl_.primaryamount_)*/nullptr + , /*decltype(_impl_.exchangeamount_)*/nullptr + , /*decltype(_impl_.amount1000_)*/uint64_t{0u} + , /*decltype(_impl_.currencydeprecated_)*/0 + , /*decltype(_impl_.status_)*/0 + , /*decltype(_impl_.transactiontimestamp_)*/uint64_t{0u} + , /*decltype(_impl_.expirytimestamp_)*/uint64_t{0u} + , /*decltype(_impl_.futureproofed_)*/false + , /*decltype(_impl_.usenovifiatformat_)*/false + , /*decltype(_impl_.txnstatus_)*/0} {} +struct PaymentInfoDefaultTypeInternal { + PROTOBUF_CONSTEXPR PaymentInfoDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~PaymentInfoDefaultTypeInternal() {} + union { + PaymentInfo _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PaymentInfoDefaultTypeInternal _PaymentInfo_default_instance_; +PROTOBUF_CONSTEXPR PendingKeyExchange::PendingKeyExchange( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.localbasekey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.localbasekeyprivate_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.localratchetkey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.localratchetkeyprivate_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.localidentitykey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.localidentitykeyprivate_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.sequence_)*/0u} {} +struct PendingKeyExchangeDefaultTypeInternal { + PROTOBUF_CONSTEXPR PendingKeyExchangeDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~PendingKeyExchangeDefaultTypeInternal() {} + union { + PendingKeyExchange _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PendingKeyExchangeDefaultTypeInternal _PendingKeyExchange_default_instance_; +PROTOBUF_CONSTEXPR PendingPreKey::PendingPreKey( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.basekey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.prekeyid_)*/0u + , /*decltype(_impl_.signedprekeyid_)*/0} {} +struct PendingPreKeyDefaultTypeInternal { + PROTOBUF_CONSTEXPR PendingPreKeyDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~PendingPreKeyDefaultTypeInternal() {} + union { + PendingPreKey _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PendingPreKeyDefaultTypeInternal _PendingPreKey_default_instance_; +PROTOBUF_CONSTEXPR PhotoChange::PhotoChange( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.oldphoto_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.newphoto_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.newphotoid_)*/0u} {} +struct PhotoChangeDefaultTypeInternal { + PROTOBUF_CONSTEXPR PhotoChangeDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~PhotoChangeDefaultTypeInternal() {} + union { + PhotoChange _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PhotoChangeDefaultTypeInternal _PhotoChange_default_instance_; +PROTOBUF_CONSTEXPR Point::Point( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.xdeprecated_)*/0 + , /*decltype(_impl_.ydeprecated_)*/0 + , /*decltype(_impl_.x_)*/0 + , /*decltype(_impl_.y_)*/0} {} +struct PointDefaultTypeInternal { + PROTOBUF_CONSTEXPR PointDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~PointDefaultTypeInternal() {} + union { + Point _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PointDefaultTypeInternal _Point_default_instance_; +PROTOBUF_CONSTEXPR PollAdditionalMetadata::PollAdditionalMetadata( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.pollinvalidated_)*/false} {} +struct PollAdditionalMetadataDefaultTypeInternal { + PROTOBUF_CONSTEXPR PollAdditionalMetadataDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~PollAdditionalMetadataDefaultTypeInternal() {} + union { + PollAdditionalMetadata _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PollAdditionalMetadataDefaultTypeInternal _PollAdditionalMetadata_default_instance_; +PROTOBUF_CONSTEXPR PollEncValue::PollEncValue( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.encpayload_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.enciv_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct PollEncValueDefaultTypeInternal { + PROTOBUF_CONSTEXPR PollEncValueDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~PollEncValueDefaultTypeInternal() {} + union { + PollEncValue _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PollEncValueDefaultTypeInternal _PollEncValue_default_instance_; +PROTOBUF_CONSTEXPR PollUpdate::PollUpdate( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.pollupdatemessagekey_)*/nullptr + , /*decltype(_impl_.vote_)*/nullptr + , /*decltype(_impl_.sendertimestampms_)*/int64_t{0}} {} +struct PollUpdateDefaultTypeInternal { + PROTOBUF_CONSTEXPR PollUpdateDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~PollUpdateDefaultTypeInternal() {} + union { + PollUpdate _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PollUpdateDefaultTypeInternal _PollUpdate_default_instance_; +PROTOBUF_CONSTEXPR PreKeyRecordStructure::PreKeyRecordStructure( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.publickey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.privatekey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.id_)*/0u} {} +struct PreKeyRecordStructureDefaultTypeInternal { + PROTOBUF_CONSTEXPR PreKeyRecordStructureDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~PreKeyRecordStructureDefaultTypeInternal() {} + union { + PreKeyRecordStructure _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PreKeyRecordStructureDefaultTypeInternal _PreKeyRecordStructure_default_instance_; +PROTOBUF_CONSTEXPR Pushname::Pushname( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.pushname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct PushnameDefaultTypeInternal { + PROTOBUF_CONSTEXPR PushnameDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~PushnameDefaultTypeInternal() {} + union { + Pushname _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PushnameDefaultTypeInternal _Pushname_default_instance_; +PROTOBUF_CONSTEXPR Reaction::Reaction( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.text_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.groupingkey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.key_)*/nullptr + , /*decltype(_impl_.sendertimestampms_)*/int64_t{0} + , /*decltype(_impl_.unread_)*/false} {} +struct ReactionDefaultTypeInternal { + PROTOBUF_CONSTEXPR ReactionDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ReactionDefaultTypeInternal() {} + union { + Reaction _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ReactionDefaultTypeInternal _Reaction_default_instance_; +PROTOBUF_CONSTEXPR RecentEmojiWeight::RecentEmojiWeight( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.emoji_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.weight_)*/0} {} +struct RecentEmojiWeightDefaultTypeInternal { + PROTOBUF_CONSTEXPR RecentEmojiWeightDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~RecentEmojiWeightDefaultTypeInternal() {} + union { + RecentEmojiWeight _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RecentEmojiWeightDefaultTypeInternal _RecentEmojiWeight_default_instance_; +PROTOBUF_CONSTEXPR RecordStructure::RecordStructure( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.previoussessions_)*/{} + , /*decltype(_impl_.currentsession_)*/nullptr} {} +struct RecordStructureDefaultTypeInternal { + PROTOBUF_CONSTEXPR RecordStructureDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~RecordStructureDefaultTypeInternal() {} + union { + RecordStructure _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RecordStructureDefaultTypeInternal _RecordStructure_default_instance_; +PROTOBUF_CONSTEXPR SenderChainKey::SenderChainKey( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.seed_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.iteration_)*/0u} {} +struct SenderChainKeyDefaultTypeInternal { + PROTOBUF_CONSTEXPR SenderChainKeyDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SenderChainKeyDefaultTypeInternal() {} + union { + SenderChainKey _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SenderChainKeyDefaultTypeInternal _SenderChainKey_default_instance_; +PROTOBUF_CONSTEXPR SenderKeyRecordStructure::SenderKeyRecordStructure( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.senderkeystates_)*/{} + , /*decltype(_impl_._cached_size_)*/{}} {} +struct SenderKeyRecordStructureDefaultTypeInternal { + PROTOBUF_CONSTEXPR SenderKeyRecordStructureDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SenderKeyRecordStructureDefaultTypeInternal() {} + union { + SenderKeyRecordStructure _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SenderKeyRecordStructureDefaultTypeInternal _SenderKeyRecordStructure_default_instance_; +PROTOBUF_CONSTEXPR SenderKeyStateStructure::SenderKeyStateStructure( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.sendermessagekeys_)*/{} + , /*decltype(_impl_.senderchainkey_)*/nullptr + , /*decltype(_impl_.sendersigningkey_)*/nullptr + , /*decltype(_impl_.senderkeyid_)*/0u} {} +struct SenderKeyStateStructureDefaultTypeInternal { + PROTOBUF_CONSTEXPR SenderKeyStateStructureDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SenderKeyStateStructureDefaultTypeInternal() {} + union { + SenderKeyStateStructure _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SenderKeyStateStructureDefaultTypeInternal _SenderKeyStateStructure_default_instance_; +PROTOBUF_CONSTEXPR SenderMessageKey::SenderMessageKey( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.seed_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.iteration_)*/0u} {} +struct SenderMessageKeyDefaultTypeInternal { + PROTOBUF_CONSTEXPR SenderMessageKeyDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SenderMessageKeyDefaultTypeInternal() {} + union { + SenderMessageKey _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SenderMessageKeyDefaultTypeInternal _SenderMessageKey_default_instance_; +PROTOBUF_CONSTEXPR SenderSigningKey::SenderSigningKey( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.public__)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.private__)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct SenderSigningKeyDefaultTypeInternal { + PROTOBUF_CONSTEXPR SenderSigningKeyDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SenderSigningKeyDefaultTypeInternal() {} + union { + SenderSigningKey _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SenderSigningKeyDefaultTypeInternal _SenderSigningKey_default_instance_; +PROTOBUF_CONSTEXPR ServerErrorReceipt::ServerErrorReceipt( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.stanzaid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct ServerErrorReceiptDefaultTypeInternal { + PROTOBUF_CONSTEXPR ServerErrorReceiptDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~ServerErrorReceiptDefaultTypeInternal() {} + union { + ServerErrorReceipt _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ServerErrorReceiptDefaultTypeInternal _ServerErrorReceipt_default_instance_; +PROTOBUF_CONSTEXPR SessionStructure::SessionStructure( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.receiverchains_)*/{} + , /*decltype(_impl_.localidentitypublic_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.remoteidentitypublic_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.rootkey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.alicebasekey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.senderchain_)*/nullptr + , /*decltype(_impl_.pendingkeyexchange_)*/nullptr + , /*decltype(_impl_.pendingprekey_)*/nullptr + , /*decltype(_impl_.sessionversion_)*/0u + , /*decltype(_impl_.previouscounter_)*/0u + , /*decltype(_impl_.remoteregistrationid_)*/0u + , /*decltype(_impl_.localregistrationid_)*/0u + , /*decltype(_impl_.needsrefresh_)*/false} {} +struct SessionStructureDefaultTypeInternal { + PROTOBUF_CONSTEXPR SessionStructureDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SessionStructureDefaultTypeInternal() {} + union { + SessionStructure _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SessionStructureDefaultTypeInternal _SessionStructure_default_instance_; +PROTOBUF_CONSTEXPR SignedPreKeyRecordStructure::SignedPreKeyRecordStructure( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.publickey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.privatekey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.signature_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.timestamp_)*/uint64_t{0u} + , /*decltype(_impl_.id_)*/0u} {} +struct SignedPreKeyRecordStructureDefaultTypeInternal { + PROTOBUF_CONSTEXPR SignedPreKeyRecordStructureDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SignedPreKeyRecordStructureDefaultTypeInternal() {} + union { + SignedPreKeyRecordStructure _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SignedPreKeyRecordStructureDefaultTypeInternal _SignedPreKeyRecordStructure_default_instance_; +PROTOBUF_CONSTEXPR StatusPSA::StatusPSA( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.campaignid_)*/uint64_t{0u} + , /*decltype(_impl_.campaignexpirationtimestamp_)*/uint64_t{0u}} {} +struct StatusPSADefaultTypeInternal { + PROTOBUF_CONSTEXPR StatusPSADefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~StatusPSADefaultTypeInternal() {} + union { + StatusPSA _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StatusPSADefaultTypeInternal _StatusPSA_default_instance_; +PROTOBUF_CONSTEXPR StickerMetadata::StickerMetadata( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.filesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.fileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.mimetype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.height_)*/0u + , /*decltype(_impl_.width_)*/0u + , /*decltype(_impl_.filelength_)*/uint64_t{0u} + , /*decltype(_impl_.weight_)*/0} {} +struct StickerMetadataDefaultTypeInternal { + PROTOBUF_CONSTEXPR StickerMetadataDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~StickerMetadataDefaultTypeInternal() {} + union { + StickerMetadata _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StickerMetadataDefaultTypeInternal _StickerMetadata_default_instance_; +PROTOBUF_CONSTEXPR SyncActionData::SyncActionData( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.index_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.padding_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.value_)*/nullptr + , /*decltype(_impl_.version_)*/0} {} +struct SyncActionDataDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncActionDataDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncActionDataDefaultTypeInternal() {} + union { + SyncActionData _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionDataDefaultTypeInternal _SyncActionData_default_instance_; +PROTOBUF_CONSTEXPR SyncActionValue_AgentAction::SyncActionValue_AgentAction( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.deviceid_)*/0 + , /*decltype(_impl_.isdeleted_)*/false} {} +struct SyncActionValue_AgentActionDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncActionValue_AgentActionDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncActionValue_AgentActionDefaultTypeInternal() {} + union { + SyncActionValue_AgentAction _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_AgentActionDefaultTypeInternal _SyncActionValue_AgentAction_default_instance_; +PROTOBUF_CONSTEXPR SyncActionValue_AndroidUnsupportedActions::SyncActionValue_AndroidUnsupportedActions( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.allowed_)*/false} {} +struct SyncActionValue_AndroidUnsupportedActionsDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncActionValue_AndroidUnsupportedActionsDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncActionValue_AndroidUnsupportedActionsDefaultTypeInternal() {} + union { + SyncActionValue_AndroidUnsupportedActions _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_AndroidUnsupportedActionsDefaultTypeInternal _SyncActionValue_AndroidUnsupportedActions_default_instance_; +PROTOBUF_CONSTEXPR SyncActionValue_ArchiveChatAction::SyncActionValue_ArchiveChatAction( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.messagerange_)*/nullptr + , /*decltype(_impl_.archived_)*/false} {} +struct SyncActionValue_ArchiveChatActionDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncActionValue_ArchiveChatActionDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncActionValue_ArchiveChatActionDefaultTypeInternal() {} + union { + SyncActionValue_ArchiveChatAction _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_ArchiveChatActionDefaultTypeInternal _SyncActionValue_ArchiveChatAction_default_instance_; +PROTOBUF_CONSTEXPR SyncActionValue_ClearChatAction::SyncActionValue_ClearChatAction( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.messagerange_)*/nullptr} {} +struct SyncActionValue_ClearChatActionDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncActionValue_ClearChatActionDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncActionValue_ClearChatActionDefaultTypeInternal() {} + union { + SyncActionValue_ClearChatAction _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_ClearChatActionDefaultTypeInternal _SyncActionValue_ClearChatAction_default_instance_; +PROTOBUF_CONSTEXPR SyncActionValue_ContactAction::SyncActionValue_ContactAction( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.fullname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.firstname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct SyncActionValue_ContactActionDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncActionValue_ContactActionDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncActionValue_ContactActionDefaultTypeInternal() {} + union { + SyncActionValue_ContactAction _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_ContactActionDefaultTypeInternal _SyncActionValue_ContactAction_default_instance_; +PROTOBUF_CONSTEXPR SyncActionValue_DeleteChatAction::SyncActionValue_DeleteChatAction( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.messagerange_)*/nullptr} {} +struct SyncActionValue_DeleteChatActionDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncActionValue_DeleteChatActionDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncActionValue_DeleteChatActionDefaultTypeInternal() {} + union { + SyncActionValue_DeleteChatAction _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_DeleteChatActionDefaultTypeInternal _SyncActionValue_DeleteChatAction_default_instance_; +PROTOBUF_CONSTEXPR SyncActionValue_DeleteMessageForMeAction::SyncActionValue_DeleteMessageForMeAction( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.messagetimestamp_)*/int64_t{0} + , /*decltype(_impl_.deletemedia_)*/false} {} +struct SyncActionValue_DeleteMessageForMeActionDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncActionValue_DeleteMessageForMeActionDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncActionValue_DeleteMessageForMeActionDefaultTypeInternal() {} + union { + SyncActionValue_DeleteMessageForMeAction _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_DeleteMessageForMeActionDefaultTypeInternal _SyncActionValue_DeleteMessageForMeAction_default_instance_; +PROTOBUF_CONSTEXPR SyncActionValue_KeyExpiration::SyncActionValue_KeyExpiration( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.expiredkeyepoch_)*/0} {} +struct SyncActionValue_KeyExpirationDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncActionValue_KeyExpirationDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncActionValue_KeyExpirationDefaultTypeInternal() {} + union { + SyncActionValue_KeyExpiration _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_KeyExpirationDefaultTypeInternal _SyncActionValue_KeyExpiration_default_instance_; +PROTOBUF_CONSTEXPR SyncActionValue_LabelAssociationAction::SyncActionValue_LabelAssociationAction( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.labeled_)*/false} {} +struct SyncActionValue_LabelAssociationActionDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncActionValue_LabelAssociationActionDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncActionValue_LabelAssociationActionDefaultTypeInternal() {} + union { + SyncActionValue_LabelAssociationAction _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_LabelAssociationActionDefaultTypeInternal _SyncActionValue_LabelAssociationAction_default_instance_; +PROTOBUF_CONSTEXPR SyncActionValue_LabelEditAction::SyncActionValue_LabelEditAction( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.color_)*/0 + , /*decltype(_impl_.predefinedid_)*/0 + , /*decltype(_impl_.deleted_)*/false} {} +struct SyncActionValue_LabelEditActionDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncActionValue_LabelEditActionDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncActionValue_LabelEditActionDefaultTypeInternal() {} + union { + SyncActionValue_LabelEditAction _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_LabelEditActionDefaultTypeInternal _SyncActionValue_LabelEditAction_default_instance_; +PROTOBUF_CONSTEXPR SyncActionValue_LocaleSetting::SyncActionValue_LocaleSetting( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.locale_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct SyncActionValue_LocaleSettingDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncActionValue_LocaleSettingDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncActionValue_LocaleSettingDefaultTypeInternal() {} + union { + SyncActionValue_LocaleSetting _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_LocaleSettingDefaultTypeInternal _SyncActionValue_LocaleSetting_default_instance_; +PROTOBUF_CONSTEXPR SyncActionValue_MarkChatAsReadAction::SyncActionValue_MarkChatAsReadAction( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.messagerange_)*/nullptr + , /*decltype(_impl_.read_)*/false} {} +struct SyncActionValue_MarkChatAsReadActionDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncActionValue_MarkChatAsReadActionDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncActionValue_MarkChatAsReadActionDefaultTypeInternal() {} + union { + SyncActionValue_MarkChatAsReadAction _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_MarkChatAsReadActionDefaultTypeInternal _SyncActionValue_MarkChatAsReadAction_default_instance_; +PROTOBUF_CONSTEXPR SyncActionValue_MuteAction::SyncActionValue_MuteAction( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.muteendtimestamp_)*/int64_t{0} + , /*decltype(_impl_.muted_)*/false} {} +struct SyncActionValue_MuteActionDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncActionValue_MuteActionDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncActionValue_MuteActionDefaultTypeInternal() {} + union { + SyncActionValue_MuteAction _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_MuteActionDefaultTypeInternal _SyncActionValue_MuteAction_default_instance_; +PROTOBUF_CONSTEXPR SyncActionValue_NuxAction::SyncActionValue_NuxAction( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.acknowledged_)*/false} {} +struct SyncActionValue_NuxActionDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncActionValue_NuxActionDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncActionValue_NuxActionDefaultTypeInternal() {} + union { + SyncActionValue_NuxAction _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_NuxActionDefaultTypeInternal _SyncActionValue_NuxAction_default_instance_; +PROTOBUF_CONSTEXPR SyncActionValue_PinAction::SyncActionValue_PinAction( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.pinned_)*/false} {} +struct SyncActionValue_PinActionDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncActionValue_PinActionDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncActionValue_PinActionDefaultTypeInternal() {} + union { + SyncActionValue_PinAction _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_PinActionDefaultTypeInternal _SyncActionValue_PinAction_default_instance_; +PROTOBUF_CONSTEXPR SyncActionValue_PrimaryFeature::SyncActionValue_PrimaryFeature( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.flags_)*/{} + , /*decltype(_impl_._cached_size_)*/{}} {} +struct SyncActionValue_PrimaryFeatureDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncActionValue_PrimaryFeatureDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncActionValue_PrimaryFeatureDefaultTypeInternal() {} + union { + SyncActionValue_PrimaryFeature _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_PrimaryFeatureDefaultTypeInternal _SyncActionValue_PrimaryFeature_default_instance_; +PROTOBUF_CONSTEXPR SyncActionValue_PrimaryVersionAction::SyncActionValue_PrimaryVersionAction( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.version_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct SyncActionValue_PrimaryVersionActionDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncActionValue_PrimaryVersionActionDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncActionValue_PrimaryVersionActionDefaultTypeInternal() {} + union { + SyncActionValue_PrimaryVersionAction _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_PrimaryVersionActionDefaultTypeInternal _SyncActionValue_PrimaryVersionAction_default_instance_; +PROTOBUF_CONSTEXPR SyncActionValue_PushNameSetting::SyncActionValue_PushNameSetting( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct SyncActionValue_PushNameSettingDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncActionValue_PushNameSettingDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncActionValue_PushNameSettingDefaultTypeInternal() {} + union { + SyncActionValue_PushNameSetting _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_PushNameSettingDefaultTypeInternal _SyncActionValue_PushNameSetting_default_instance_; +PROTOBUF_CONSTEXPR SyncActionValue_QuickReplyAction::SyncActionValue_QuickReplyAction( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.keywords_)*/{} + , /*decltype(_impl_.shortcut_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.message_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.count_)*/0 + , /*decltype(_impl_.deleted_)*/false} {} +struct SyncActionValue_QuickReplyActionDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncActionValue_QuickReplyActionDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncActionValue_QuickReplyActionDefaultTypeInternal() {} + union { + SyncActionValue_QuickReplyAction _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_QuickReplyActionDefaultTypeInternal _SyncActionValue_QuickReplyAction_default_instance_; +PROTOBUF_CONSTEXPR SyncActionValue_RecentEmojiWeightsAction::SyncActionValue_RecentEmojiWeightsAction( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.weights_)*/{} + , /*decltype(_impl_._cached_size_)*/{}} {} +struct SyncActionValue_RecentEmojiWeightsActionDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncActionValue_RecentEmojiWeightsActionDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncActionValue_RecentEmojiWeightsActionDefaultTypeInternal() {} + union { + SyncActionValue_RecentEmojiWeightsAction _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_RecentEmojiWeightsActionDefaultTypeInternal _SyncActionValue_RecentEmojiWeightsAction_default_instance_; +PROTOBUF_CONSTEXPR SyncActionValue_SecurityNotificationSetting::SyncActionValue_SecurityNotificationSetting( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.shownotification_)*/false} {} +struct SyncActionValue_SecurityNotificationSettingDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncActionValue_SecurityNotificationSettingDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncActionValue_SecurityNotificationSettingDefaultTypeInternal() {} + union { + SyncActionValue_SecurityNotificationSetting _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_SecurityNotificationSettingDefaultTypeInternal _SyncActionValue_SecurityNotificationSetting_default_instance_; +PROTOBUF_CONSTEXPR SyncActionValue_StarAction::SyncActionValue_StarAction( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.starred_)*/false} {} +struct SyncActionValue_StarActionDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncActionValue_StarActionDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncActionValue_StarActionDefaultTypeInternal() {} + union { + SyncActionValue_StarAction _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_StarActionDefaultTypeInternal _SyncActionValue_StarAction_default_instance_; +PROTOBUF_CONSTEXPR SyncActionValue_StickerAction::SyncActionValue_StickerAction( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.fileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.mimetype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.height_)*/0u + , /*decltype(_impl_.width_)*/0u + , /*decltype(_impl_.filelength_)*/uint64_t{0u} + , /*decltype(_impl_.isfavorite_)*/false + , /*decltype(_impl_.deviceidhint_)*/0u} {} +struct SyncActionValue_StickerActionDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncActionValue_StickerActionDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncActionValue_StickerActionDefaultTypeInternal() {} + union { + SyncActionValue_StickerAction _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_StickerActionDefaultTypeInternal _SyncActionValue_StickerAction_default_instance_; +PROTOBUF_CONSTEXPR SyncActionValue_SubscriptionAction::SyncActionValue_SubscriptionAction( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.expirationdate_)*/int64_t{0} + , /*decltype(_impl_.isdeactivated_)*/false + , /*decltype(_impl_.isautorenewing_)*/false} {} +struct SyncActionValue_SubscriptionActionDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncActionValue_SubscriptionActionDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncActionValue_SubscriptionActionDefaultTypeInternal() {} + union { + SyncActionValue_SubscriptionAction _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_SubscriptionActionDefaultTypeInternal _SyncActionValue_SubscriptionAction_default_instance_; +PROTOBUF_CONSTEXPR SyncActionValue_SyncActionMessageRange::SyncActionValue_SyncActionMessageRange( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.messages_)*/{} + , /*decltype(_impl_.lastmessagetimestamp_)*/int64_t{0} + , /*decltype(_impl_.lastsystemmessagetimestamp_)*/int64_t{0}} {} +struct SyncActionValue_SyncActionMessageRangeDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncActionValue_SyncActionMessageRangeDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncActionValue_SyncActionMessageRangeDefaultTypeInternal() {} + union { + SyncActionValue_SyncActionMessageRange _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_SyncActionMessageRangeDefaultTypeInternal _SyncActionValue_SyncActionMessageRange_default_instance_; +PROTOBUF_CONSTEXPR SyncActionValue_SyncActionMessage::SyncActionValue_SyncActionMessage( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.key_)*/nullptr + , /*decltype(_impl_.timestamp_)*/int64_t{0}} {} +struct SyncActionValue_SyncActionMessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncActionValue_SyncActionMessageDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncActionValue_SyncActionMessageDefaultTypeInternal() {} + union { + SyncActionValue_SyncActionMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_SyncActionMessageDefaultTypeInternal _SyncActionValue_SyncActionMessage_default_instance_; +PROTOBUF_CONSTEXPR SyncActionValue_TimeFormatAction::SyncActionValue_TimeFormatAction( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.istwentyfourhourformatenabled_)*/false} {} +struct SyncActionValue_TimeFormatActionDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncActionValue_TimeFormatActionDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncActionValue_TimeFormatActionDefaultTypeInternal() {} + union { + SyncActionValue_TimeFormatAction _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_TimeFormatActionDefaultTypeInternal _SyncActionValue_TimeFormatAction_default_instance_; +PROTOBUF_CONSTEXPR SyncActionValue_UnarchiveChatsSetting::SyncActionValue_UnarchiveChatsSetting( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.unarchivechats_)*/false} {} +struct SyncActionValue_UnarchiveChatsSettingDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncActionValue_UnarchiveChatsSettingDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncActionValue_UnarchiveChatsSettingDefaultTypeInternal() {} + union { + SyncActionValue_UnarchiveChatsSetting _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_UnarchiveChatsSettingDefaultTypeInternal _SyncActionValue_UnarchiveChatsSetting_default_instance_; +PROTOBUF_CONSTEXPR SyncActionValue_UserStatusMuteAction::SyncActionValue_UserStatusMuteAction( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.muted_)*/false} {} +struct SyncActionValue_UserStatusMuteActionDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncActionValue_UserStatusMuteActionDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncActionValue_UserStatusMuteActionDefaultTypeInternal() {} + union { + SyncActionValue_UserStatusMuteAction _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_UserStatusMuteActionDefaultTypeInternal _SyncActionValue_UserStatusMuteAction_default_instance_; +PROTOBUF_CONSTEXPR SyncActionValue::SyncActionValue( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.staraction_)*/nullptr + , /*decltype(_impl_.contactaction_)*/nullptr + , /*decltype(_impl_.muteaction_)*/nullptr + , /*decltype(_impl_.pinaction_)*/nullptr + , /*decltype(_impl_.securitynotificationsetting_)*/nullptr + , /*decltype(_impl_.pushnamesetting_)*/nullptr + , /*decltype(_impl_.quickreplyaction_)*/nullptr + , /*decltype(_impl_.recentemojiweightsaction_)*/nullptr + , /*decltype(_impl_.labeleditaction_)*/nullptr + , /*decltype(_impl_.labelassociationaction_)*/nullptr + , /*decltype(_impl_.localesetting_)*/nullptr + , /*decltype(_impl_.archivechataction_)*/nullptr + , /*decltype(_impl_.deletemessageformeaction_)*/nullptr + , /*decltype(_impl_.keyexpiration_)*/nullptr + , /*decltype(_impl_.markchatasreadaction_)*/nullptr + , /*decltype(_impl_.clearchataction_)*/nullptr + , /*decltype(_impl_.deletechataction_)*/nullptr + , /*decltype(_impl_.unarchivechatssetting_)*/nullptr + , /*decltype(_impl_.primaryfeature_)*/nullptr + , /*decltype(_impl_.androidunsupportedactions_)*/nullptr + , /*decltype(_impl_.agentaction_)*/nullptr + , /*decltype(_impl_.subscriptionaction_)*/nullptr + , /*decltype(_impl_.userstatusmuteaction_)*/nullptr + , /*decltype(_impl_.timeformataction_)*/nullptr + , /*decltype(_impl_.nuxaction_)*/nullptr + , /*decltype(_impl_.primaryversionaction_)*/nullptr + , /*decltype(_impl_.stickeraction_)*/nullptr + , /*decltype(_impl_.timestamp_)*/int64_t{0}} {} +struct SyncActionValueDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncActionValueDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncActionValueDefaultTypeInternal() {} + union { + SyncActionValue _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValueDefaultTypeInternal _SyncActionValue_default_instance_; +PROTOBUF_CONSTEXPR SyncdIndex::SyncdIndex( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.blob_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct SyncdIndexDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncdIndexDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncdIndexDefaultTypeInternal() {} + union { + SyncdIndex _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncdIndexDefaultTypeInternal _SyncdIndex_default_instance_; +PROTOBUF_CONSTEXPR SyncdMutation::SyncdMutation( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.record_)*/nullptr + , /*decltype(_impl_.operation_)*/0} {} +struct SyncdMutationDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncdMutationDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncdMutationDefaultTypeInternal() {} + union { + SyncdMutation _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncdMutationDefaultTypeInternal _SyncdMutation_default_instance_; +PROTOBUF_CONSTEXPR SyncdMutations::SyncdMutations( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.mutations_)*/{} + , /*decltype(_impl_._cached_size_)*/{}} {} +struct SyncdMutationsDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncdMutationsDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncdMutationsDefaultTypeInternal() {} + union { + SyncdMutations _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncdMutationsDefaultTypeInternal _SyncdMutations_default_instance_; +PROTOBUF_CONSTEXPR SyncdPatch::SyncdPatch( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.mutations_)*/{} + , /*decltype(_impl_.snapshotmac_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.patchmac_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.version_)*/nullptr + , /*decltype(_impl_.externalmutations_)*/nullptr + , /*decltype(_impl_.keyid_)*/nullptr + , /*decltype(_impl_.exitcode_)*/nullptr + , /*decltype(_impl_.deviceindex_)*/0u} {} +struct SyncdPatchDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncdPatchDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncdPatchDefaultTypeInternal() {} + union { + SyncdPatch _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncdPatchDefaultTypeInternal _SyncdPatch_default_instance_; +PROTOBUF_CONSTEXPR SyncdRecord::SyncdRecord( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.index_)*/nullptr + , /*decltype(_impl_.value_)*/nullptr + , /*decltype(_impl_.keyid_)*/nullptr} {} +struct SyncdRecordDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncdRecordDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncdRecordDefaultTypeInternal() {} + union { + SyncdRecord _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncdRecordDefaultTypeInternal _SyncdRecord_default_instance_; +PROTOBUF_CONSTEXPR SyncdSnapshot::SyncdSnapshot( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.records_)*/{} + , /*decltype(_impl_.mac_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.version_)*/nullptr + , /*decltype(_impl_.keyid_)*/nullptr} {} +struct SyncdSnapshotDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncdSnapshotDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncdSnapshotDefaultTypeInternal() {} + union { + SyncdSnapshot _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncdSnapshotDefaultTypeInternal _SyncdSnapshot_default_instance_; +PROTOBUF_CONSTEXPR SyncdValue::SyncdValue( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.blob_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct SyncdValueDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncdValueDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncdValueDefaultTypeInternal() {} + union { + SyncdValue _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncdValueDefaultTypeInternal _SyncdValue_default_instance_; +PROTOBUF_CONSTEXPR SyncdVersion::SyncdVersion( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.version_)*/uint64_t{0u}} {} +struct SyncdVersionDefaultTypeInternal { + PROTOBUF_CONSTEXPR SyncdVersionDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~SyncdVersionDefaultTypeInternal() {} + union { + SyncdVersion _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncdVersionDefaultTypeInternal _SyncdVersion_default_instance_; +PROTOBUF_CONSTEXPR TemplateButton_CallButton::TemplateButton_CallButton( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.displaytext_)*/nullptr + , /*decltype(_impl_.phonenumber_)*/nullptr} {} +struct TemplateButton_CallButtonDefaultTypeInternal { + PROTOBUF_CONSTEXPR TemplateButton_CallButtonDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~TemplateButton_CallButtonDefaultTypeInternal() {} + union { + TemplateButton_CallButton _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemplateButton_CallButtonDefaultTypeInternal _TemplateButton_CallButton_default_instance_; +PROTOBUF_CONSTEXPR TemplateButton_QuickReplyButton::TemplateButton_QuickReplyButton( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.displaytext_)*/nullptr} {} +struct TemplateButton_QuickReplyButtonDefaultTypeInternal { + PROTOBUF_CONSTEXPR TemplateButton_QuickReplyButtonDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~TemplateButton_QuickReplyButtonDefaultTypeInternal() {} + union { + TemplateButton_QuickReplyButton _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemplateButton_QuickReplyButtonDefaultTypeInternal _TemplateButton_QuickReplyButton_default_instance_; +PROTOBUF_CONSTEXPR TemplateButton_URLButton::TemplateButton_URLButton( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.displaytext_)*/nullptr + , /*decltype(_impl_.url_)*/nullptr} {} +struct TemplateButton_URLButtonDefaultTypeInternal { + PROTOBUF_CONSTEXPR TemplateButton_URLButtonDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~TemplateButton_URLButtonDefaultTypeInternal() {} + union { + TemplateButton_URLButton _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemplateButton_URLButtonDefaultTypeInternal _TemplateButton_URLButton_default_instance_; +PROTOBUF_CONSTEXPR TemplateButton::TemplateButton( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.index_)*/0u + , /*decltype(_impl_.button_)*/{} + , /*decltype(_impl_._oneof_case_)*/{}} {} +struct TemplateButtonDefaultTypeInternal { + PROTOBUF_CONSTEXPR TemplateButtonDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~TemplateButtonDefaultTypeInternal() {} + union { + TemplateButton _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemplateButtonDefaultTypeInternal _TemplateButton_default_instance_; +PROTOBUF_CONSTEXPR UserReceipt::UserReceipt( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.pendingdevicejid_)*/{} + , /*decltype(_impl_.delivereddevicejid_)*/{} + , /*decltype(_impl_.userjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.receipttimestamp_)*/int64_t{0} + , /*decltype(_impl_.readtimestamp_)*/int64_t{0} + , /*decltype(_impl_.playedtimestamp_)*/int64_t{0}} {} +struct UserReceiptDefaultTypeInternal { + PROTOBUF_CONSTEXPR UserReceiptDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~UserReceiptDefaultTypeInternal() {} + union { + UserReceipt _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UserReceiptDefaultTypeInternal _UserReceipt_default_instance_; +PROTOBUF_CONSTEXPR VerifiedNameCertificate_Details::VerifiedNameCertificate_Details( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.localizednames_)*/{} + , /*decltype(_impl_.issuer_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.verifiedname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.serial_)*/uint64_t{0u} + , /*decltype(_impl_.issuetime_)*/uint64_t{0u}} {} +struct VerifiedNameCertificate_DetailsDefaultTypeInternal { + PROTOBUF_CONSTEXPR VerifiedNameCertificate_DetailsDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~VerifiedNameCertificate_DetailsDefaultTypeInternal() {} + union { + VerifiedNameCertificate_Details _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 VerifiedNameCertificate_DetailsDefaultTypeInternal _VerifiedNameCertificate_Details_default_instance_; +PROTOBUF_CONSTEXPR VerifiedNameCertificate::VerifiedNameCertificate( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.details_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.signature_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.serversignature_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} +struct VerifiedNameCertificateDefaultTypeInternal { + PROTOBUF_CONSTEXPR VerifiedNameCertificateDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~VerifiedNameCertificateDefaultTypeInternal() {} + union { + VerifiedNameCertificate _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 VerifiedNameCertificateDefaultTypeInternal _VerifiedNameCertificate_default_instance_; +PROTOBUF_CONSTEXPR WallpaperSettings::WallpaperSettings( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.filename_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.opacity_)*/0u} {} +struct WallpaperSettingsDefaultTypeInternal { + PROTOBUF_CONSTEXPR WallpaperSettingsDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~WallpaperSettingsDefaultTypeInternal() {} + union { + WallpaperSettings _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WallpaperSettingsDefaultTypeInternal _WallpaperSettings_default_instance_; +PROTOBUF_CONSTEXPR WebFeatures::WebFeatures( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.labelsdisplay_)*/0 + , /*decltype(_impl_.voipindividualoutgoing_)*/0 + , /*decltype(_impl_.groupsv3_)*/0 + , /*decltype(_impl_.groupsv3create_)*/0 + , /*decltype(_impl_.changenumberv2_)*/0 + , /*decltype(_impl_.querystatusv3thumbnail_)*/0 + , /*decltype(_impl_.livelocations_)*/0 + , /*decltype(_impl_.queryvname_)*/0 + , /*decltype(_impl_.voipindividualincoming_)*/0 + , /*decltype(_impl_.quickrepliesquery_)*/0 + , /*decltype(_impl_.payments_)*/0 + , /*decltype(_impl_.stickerpackquery_)*/0 + , /*decltype(_impl_.livelocationsfinal_)*/0 + , /*decltype(_impl_.labelsedit_)*/0 + , /*decltype(_impl_.mediaupload_)*/0 + , /*decltype(_impl_.mediauploadrichquickreplies_)*/0 + , /*decltype(_impl_.vnamev2_)*/0 + , /*decltype(_impl_.videoplaybackurl_)*/0 + , /*decltype(_impl_.statusranking_)*/0 + , /*decltype(_impl_.voipindividualvideo_)*/0 + , /*decltype(_impl_.thirdpartystickers_)*/0 + , /*decltype(_impl_.frequentlyforwardedsetting_)*/0 + , /*decltype(_impl_.groupsv4joinpermission_)*/0 + , /*decltype(_impl_.recentstickers_)*/0 + , /*decltype(_impl_.catalog_)*/0 + , /*decltype(_impl_.starredstickers_)*/0 + , /*decltype(_impl_.voipgroupcall_)*/0 + , /*decltype(_impl_.templatemessage_)*/0 + , /*decltype(_impl_.templatemessageinteractivity_)*/0 + , /*decltype(_impl_.ephemeralmessages_)*/0 + , /*decltype(_impl_.e2enotificationsync_)*/0 + , /*decltype(_impl_.recentstickersv2_)*/0 + , /*decltype(_impl_.recentstickersv3_)*/0 + , /*decltype(_impl_.usernotice_)*/0 + , /*decltype(_impl_.support_)*/0 + , /*decltype(_impl_.groupuiicleanup_)*/0 + , /*decltype(_impl_.groupdogfoodinginternalonly_)*/0 + , /*decltype(_impl_.settingssync_)*/0 + , /*decltype(_impl_.archivev2_)*/0 + , /*decltype(_impl_.ephemeralallowgroupmembers_)*/0 + , /*decltype(_impl_.ephemeral24hduration_)*/0 + , /*decltype(_impl_.mdforceupgrade_)*/0 + , /*decltype(_impl_.disappearingmode_)*/0 + , /*decltype(_impl_.externalmdoptinavailable_)*/0 + , /*decltype(_impl_.nodeletemessagetimelimit_)*/0} {} +struct WebFeaturesDefaultTypeInternal { + PROTOBUF_CONSTEXPR WebFeaturesDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~WebFeaturesDefaultTypeInternal() {} + union { + WebFeatures _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WebFeaturesDefaultTypeInternal _WebFeatures_default_instance_; +PROTOBUF_CONSTEXPR WebMessageInfo::WebMessageInfo( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.messagestubparameters_)*/{} + , /*decltype(_impl_.labels_)*/{} + , /*decltype(_impl_.userreceipt_)*/{} + , /*decltype(_impl_.reactions_)*/{} + , /*decltype(_impl_.pollupdates_)*/{} + , /*decltype(_impl_.participant_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.pushname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.mediaciphertextsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.verifiedbizname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.futureproofdata_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.agentid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.messagesecret_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.originalselfauthoruserjidstring_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} + , /*decltype(_impl_.key_)*/nullptr + , /*decltype(_impl_.message_)*/nullptr + , /*decltype(_impl_.paymentinfo_)*/nullptr + , /*decltype(_impl_.finallivelocation_)*/nullptr + , /*decltype(_impl_.quotedpaymentinfo_)*/nullptr + , /*decltype(_impl_.mediadata_)*/nullptr + , /*decltype(_impl_.photochange_)*/nullptr + , /*decltype(_impl_.quotedstickerdata_)*/nullptr + , /*decltype(_impl_.statuspsa_)*/nullptr + , /*decltype(_impl_.polladditionalmetadata_)*/nullptr + , /*decltype(_impl_.keepinchat_)*/nullptr + , /*decltype(_impl_.messagetimestamp_)*/uint64_t{0u} + , /*decltype(_impl_.messagec2stimestamp_)*/uint64_t{0u} + , /*decltype(_impl_.status_)*/0 + , /*decltype(_impl_.ignore_)*/false + , /*decltype(_impl_.starred_)*/false + , /*decltype(_impl_.broadcast_)*/false + , /*decltype(_impl_.multicast_)*/false + , /*decltype(_impl_.messagestubtype_)*/0 + , /*decltype(_impl_.urltext_)*/false + , /*decltype(_impl_.urlnumber_)*/false + , /*decltype(_impl_.clearmedia_)*/false + , /*decltype(_impl_.ephemeralofftoon_)*/false + , /*decltype(_impl_.duration_)*/0u + , /*decltype(_impl_.ephemeralduration_)*/0u + , /*decltype(_impl_.ephemeralstarttimestamp_)*/uint64_t{0u} + , /*decltype(_impl_.bizprivacystatus_)*/0 + , /*decltype(_impl_.ephemeraloutofsync_)*/false + , /*decltype(_impl_.statusalreadyviewed_)*/false + , /*decltype(_impl_.revokemessagetimestamp_)*/uint64_t{0u}} {} +struct WebMessageInfoDefaultTypeInternal { + PROTOBUF_CONSTEXPR WebMessageInfoDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~WebMessageInfoDefaultTypeInternal() {} + union { + WebMessageInfo _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WebMessageInfoDefaultTypeInternal _WebMessageInfo_default_instance_; +PROTOBUF_CONSTEXPR WebNotificationsInfo::WebNotificationsInfo( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_._has_bits_)*/{} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_.notifymessages_)*/{} + , /*decltype(_impl_.timestamp_)*/uint64_t{0u} + , /*decltype(_impl_.unreadchats_)*/0u + , /*decltype(_impl_.notifymessagecount_)*/0u} {} +struct WebNotificationsInfoDefaultTypeInternal { + PROTOBUF_CONSTEXPR WebNotificationsInfoDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~WebNotificationsInfoDefaultTypeInternal() {} + union { + WebNotificationsInfo _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WebNotificationsInfoDefaultTypeInternal _WebNotificationsInfo_default_instance_; +} // namespace proto +static ::_pb::Metadata file_level_metadata_pmsg_2eproto[224]; +static const ::_pb::EnumDescriptor* file_level_enum_descriptors_pmsg_2eproto[53]; +static constexpr ::_pb::ServiceDescriptor const** file_level_service_descriptors_pmsg_2eproto = nullptr; + +const uint32_t TableStruct_pmsg_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + PROTOBUF_FIELD_OFFSET(::proto::ADVDeviceIdentity, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::ADVDeviceIdentity, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::ADVDeviceIdentity, _impl_.rawid_), + PROTOBUF_FIELD_OFFSET(::proto::ADVDeviceIdentity, _impl_.timestamp_), + PROTOBUF_FIELD_OFFSET(::proto::ADVDeviceIdentity, _impl_.keyindex_), + 1, + 0, + 2, + PROTOBUF_FIELD_OFFSET(::proto::ADVKeyIndexList, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::ADVKeyIndexList, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::ADVKeyIndexList, _impl_.rawid_), + PROTOBUF_FIELD_OFFSET(::proto::ADVKeyIndexList, _impl_.timestamp_), + PROTOBUF_FIELD_OFFSET(::proto::ADVKeyIndexList, _impl_.currentindex_), + PROTOBUF_FIELD_OFFSET(::proto::ADVKeyIndexList, _impl_.validindexes_), + 1, + 0, + 2, + ~0u, + PROTOBUF_FIELD_OFFSET(::proto::ADVSignedDeviceIdentity, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::ADVSignedDeviceIdentity, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::ADVSignedDeviceIdentity, _impl_.details_), + PROTOBUF_FIELD_OFFSET(::proto::ADVSignedDeviceIdentity, _impl_.accountsignaturekey_), + PROTOBUF_FIELD_OFFSET(::proto::ADVSignedDeviceIdentity, _impl_.accountsignature_), + PROTOBUF_FIELD_OFFSET(::proto::ADVSignedDeviceIdentity, _impl_.devicesignature_), + 0, + 1, + 2, + 3, + PROTOBUF_FIELD_OFFSET(::proto::ADVSignedDeviceIdentityHMAC, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::ADVSignedDeviceIdentityHMAC, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::ADVSignedDeviceIdentityHMAC, _impl_.details_), + PROTOBUF_FIELD_OFFSET(::proto::ADVSignedDeviceIdentityHMAC, _impl_.hmac_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::ADVSignedKeyIndexList, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::ADVSignedKeyIndexList, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::ADVSignedKeyIndexList, _impl_.details_), + PROTOBUF_FIELD_OFFSET(::proto::ADVSignedKeyIndexList, _impl_.accountsignature_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::ActionLink, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::ActionLink, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::ActionLink, _impl_.url_), + PROTOBUF_FIELD_OFFSET(::proto::ActionLink, _impl_.buttontitle_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::AutoDownloadSettings, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::AutoDownloadSettings, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::AutoDownloadSettings, _impl_.downloadimages_), + PROTOBUF_FIELD_OFFSET(::proto::AutoDownloadSettings, _impl_.downloadaudio_), + PROTOBUF_FIELD_OFFSET(::proto::AutoDownloadSettings, _impl_.downloadvideo_), + PROTOBUF_FIELD_OFFSET(::proto::AutoDownloadSettings, _impl_.downloaddocuments_), + 0, + 1, + 2, + 3, + PROTOBUF_FIELD_OFFSET(::proto::BizAccountLinkInfo, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::BizAccountLinkInfo, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::BizAccountLinkInfo, _impl_.whatsappbizacctfbid_), + PROTOBUF_FIELD_OFFSET(::proto::BizAccountLinkInfo, _impl_.whatsappacctnumber_), + PROTOBUF_FIELD_OFFSET(::proto::BizAccountLinkInfo, _impl_.issuetime_), + PROTOBUF_FIELD_OFFSET(::proto::BizAccountLinkInfo, _impl_.hoststorage_), + PROTOBUF_FIELD_OFFSET(::proto::BizAccountLinkInfo, _impl_.accounttype_), + 1, + 0, + 2, + 3, + 4, + PROTOBUF_FIELD_OFFSET(::proto::BizAccountPayload, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::BizAccountPayload, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::BizAccountPayload, _impl_.vnamecert_), + PROTOBUF_FIELD_OFFSET(::proto::BizAccountPayload, _impl_.bizacctlinkinfo_), + 1, + 0, + PROTOBUF_FIELD_OFFSET(::proto::BizIdentityInfo, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::BizIdentityInfo, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::BizIdentityInfo, _impl_.vlevel_), + PROTOBUF_FIELD_OFFSET(::proto::BizIdentityInfo, _impl_.vnamecert_), + PROTOBUF_FIELD_OFFSET(::proto::BizIdentityInfo, _impl_.signed__), + PROTOBUF_FIELD_OFFSET(::proto::BizIdentityInfo, _impl_.revoked_), + PROTOBUF_FIELD_OFFSET(::proto::BizIdentityInfo, _impl_.hoststorage_), + PROTOBUF_FIELD_OFFSET(::proto::BizIdentityInfo, _impl_.actualactors_), + PROTOBUF_FIELD_OFFSET(::proto::BizIdentityInfo, _impl_.privacymodets_), + PROTOBUF_FIELD_OFFSET(::proto::BizIdentityInfo, _impl_.featurecontrols_), + 1, + 0, + 2, + 3, + 4, + 5, + 6, + 7, + PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate_Details, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate_Details, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate_Details, _impl_.serial_), + PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate_Details, _impl_.issuerserial_), + PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate_Details, _impl_.key_), + PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate_Details, _impl_.notbefore_), + PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate_Details, _impl_.notafter_), + 1, + 2, + 0, + 3, + 4, + PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate, _impl_.details_), + PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate, _impl_.signature_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::CertChain, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::CertChain, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::CertChain, _impl_.leaf_), + PROTOBUF_FIELD_OFFSET(::proto::CertChain, _impl_.intermediate_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::Chain, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Chain, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Chain, _impl_.senderratchetkey_), + PROTOBUF_FIELD_OFFSET(::proto::Chain, _impl_.senderratchetkeyprivate_), + PROTOBUF_FIELD_OFFSET(::proto::Chain, _impl_.chainkey_), + PROTOBUF_FIELD_OFFSET(::proto::Chain, _impl_.messagekeys_), + 0, + 1, + 2, + ~0u, + PROTOBUF_FIELD_OFFSET(::proto::ChainKey, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::ChainKey, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::ChainKey, _impl_.index_), + PROTOBUF_FIELD_OFFSET(::proto::ChainKey, _impl_.key_), + 1, + 0, + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DNSSource, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DNSSource, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DNSSource, _impl_.dnsmethod_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DNSSource, _impl_.appcached_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DevicePairingRegistrationData, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DevicePairingRegistrationData, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DevicePairingRegistrationData, _impl_.eregid_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DevicePairingRegistrationData, _impl_.ekeytype_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DevicePairingRegistrationData, _impl_.eident_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DevicePairingRegistrationData, _impl_.eskeyid_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DevicePairingRegistrationData, _impl_.eskeyval_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DevicePairingRegistrationData, _impl_.eskeysig_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DevicePairingRegistrationData, _impl_.buildhash_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DevicePairingRegistrationData, _impl_.deviceprops_), + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent_AppVersion, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent_AppVersion, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent_AppVersion, _impl_.primary_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent_AppVersion, _impl_.secondary_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent_AppVersion, _impl_.tertiary_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent_AppVersion, _impl_.quaternary_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent_AppVersion, _impl_.quinary_), + 0, + 1, + 2, + 3, + 4, + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.platform_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.appversion_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.mcc_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.mnc_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.osversion_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.manufacturer_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.device_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.osbuildnumber_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.phoneid_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.releasechannel_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.localelanguageiso6391_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.localecountryiso31661alpha2_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.deviceboard_), + 11, + 10, + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 12, + 7, + 8, + 9, + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.usesparticipantinkey_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.supportsstarredmessages_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.supportsdocumentmessages_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.supportsurlmessages_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.supportsmediaretry_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.supportse2eimage_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.supportse2evideo_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.supportse2eaudio_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.supportse2edocument_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.documenttypes_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.features_), + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo, _impl_.reftoken_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo, _impl_.version_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo, _impl_.webdpayload_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo, _impl_.websubplatform_), + 0, + 1, + 2, + 3, + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.username_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.passive_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.useragent_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.webinfo_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.pushname_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.sessionid_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.shortconnect_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.connecttype_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.connectreason_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.shards_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.dnssource_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.connectattemptcount_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.device_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.devicepairingdata_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.product_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.fbcat_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.fbuseragent_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.oc_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.lc_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.iosappextension_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.fbappid_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.fbdeviceid_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.pull_), + PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.paddingbytes_), + 9, + 14, + 5, + 6, + 0, + 10, + 15, + 11, + 12, + ~0u, + 7, + 13, + 18, + 8, + 19, + 1, + 2, + 16, + 20, + 22, + 21, + 3, + 17, + 4, + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_AdReplyInfo, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_AdReplyInfo, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_AdReplyInfo, _impl_.advertisername_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_AdReplyInfo, _impl_.mediatype_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_AdReplyInfo, _impl_.jpegthumbnail_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_AdReplyInfo, _impl_.caption_), + 0, + 3, + 1, + 2, + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.title_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.body_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.mediatype_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.thumbnailurl_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.mediaurl_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.thumbnail_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.sourcetype_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.sourceid_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.sourceurl_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.containsautoreply_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.renderlargerthumbnail_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.showadattribution_), + 0, + 1, + 8, + 2, + 3, + 4, + 5, + 6, + 7, + 9, + 10, + 11, + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.stanzaid_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.participant_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.quotedmessage_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.remotejid_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.mentionedjid_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.conversionsource_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.conversiondata_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.conversiondelayseconds_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.forwardingscore_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.isforwarded_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.quotedad_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.placeholderkey_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.expiration_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.ephemeralsettingtimestamp_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.ephemeralsharedsecret_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.externaladreply_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.entrypointconversionsource_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.entrypointconversionapp_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.entrypointconversiondelayseconds_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.disappearingmode_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.actionlink_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.groupsubject_), + PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.parentgroupjid_), + 0, + 1, + 10, + 2, + ~0u, + 3, + 4, + 16, + 17, + 18, + 11, + 12, + 19, + 20, + 5, + 13, + 6, + 7, + 21, + 14, + 15, + 8, + 9, + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.id_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.messages_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.newjid_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.oldjid_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.lastmsgtimestamp_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.unreadcount_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.readonly_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.endofhistorytransfer_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.ephemeralexpiration_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.ephemeralsettingtimestamp_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.endofhistorytransfertype_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.conversationtimestamp_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.name_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.phash_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.notspam_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.archived_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.disappearingmode_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.unreadmentioncount_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.markedasunread_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.participant_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.tctoken_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.tctokentimestamp_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.contactprimaryidentitykey_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.pinned_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.muteendtime_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.wallpaper_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.mediavisibility_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.tctokensendertimestamp_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.suspended_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.terminated_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.createdat_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.createdby_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.description_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.support_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.isparentgroup_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.isdefaultsubgroup_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.parentgroupid_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.displayname_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.pnjid_), + PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.selfpnexposed_), + 0, + ~0u, + 1, + 2, + 14, + 15, + 19, + 20, + 16, + 17, + 18, + 23, + 3, + 4, + 21, + 22, + 12, + 24, + 29, + ~0u, + 5, + 26, + 6, + 25, + 27, + 13, + 28, + 33, + 30, + 31, + 34, + 7, + 8, + 32, + 35, + 36, + 9, + 10, + 11, + 37, + PROTOBUF_FIELD_OFFSET(::proto::DeviceListMetadata, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::DeviceListMetadata, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::DeviceListMetadata, _impl_.senderkeyhash_), + PROTOBUF_FIELD_OFFSET(::proto::DeviceListMetadata, _impl_.sendertimestamp_), + PROTOBUF_FIELD_OFFSET(::proto::DeviceListMetadata, _impl_.senderkeyindexes_), + PROTOBUF_FIELD_OFFSET(::proto::DeviceListMetadata, _impl_.recipientkeyhash_), + PROTOBUF_FIELD_OFFSET(::proto::DeviceListMetadata, _impl_.recipienttimestamp_), + PROTOBUF_FIELD_OFFSET(::proto::DeviceListMetadata, _impl_.recipientkeyindexes_), + 0, + 2, + ~0u, + 1, + 3, + ~0u, + PROTOBUF_FIELD_OFFSET(::proto::DeviceProps_AppVersion, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::DeviceProps_AppVersion, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::DeviceProps_AppVersion, _impl_.primary_), + PROTOBUF_FIELD_OFFSET(::proto::DeviceProps_AppVersion, _impl_.secondary_), + PROTOBUF_FIELD_OFFSET(::proto::DeviceProps_AppVersion, _impl_.tertiary_), + PROTOBUF_FIELD_OFFSET(::proto::DeviceProps_AppVersion, _impl_.quaternary_), + PROTOBUF_FIELD_OFFSET(::proto::DeviceProps_AppVersion, _impl_.quinary_), + 0, + 1, + 2, + 3, + 4, + PROTOBUF_FIELD_OFFSET(::proto::DeviceProps, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::DeviceProps, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::DeviceProps, _impl_.os_), + PROTOBUF_FIELD_OFFSET(::proto::DeviceProps, _impl_.version_), + PROTOBUF_FIELD_OFFSET(::proto::DeviceProps, _impl_.platformtype_), + PROTOBUF_FIELD_OFFSET(::proto::DeviceProps, _impl_.requirefullsync_), + 0, + 1, + 2, + 3, + PROTOBUF_FIELD_OFFSET(::proto::DisappearingMode, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::DisappearingMode, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::DisappearingMode, _impl_.initiator_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::EphemeralSetting, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::EphemeralSetting, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::EphemeralSetting, _impl_.duration_), + PROTOBUF_FIELD_OFFSET(::proto::EphemeralSetting, _impl_.timestamp_), + 1, + 0, + PROTOBUF_FIELD_OFFSET(::proto::ExitCode, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::ExitCode, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::ExitCode, _impl_.code_), + PROTOBUF_FIELD_OFFSET(::proto::ExitCode, _impl_.text_), + 1, + 0, + PROTOBUF_FIELD_OFFSET(::proto::ExternalBlobReference, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::ExternalBlobReference, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::ExternalBlobReference, _impl_.mediakey_), + PROTOBUF_FIELD_OFFSET(::proto::ExternalBlobReference, _impl_.directpath_), + PROTOBUF_FIELD_OFFSET(::proto::ExternalBlobReference, _impl_.handle_), + PROTOBUF_FIELD_OFFSET(::proto::ExternalBlobReference, _impl_.filesizebytes_), + PROTOBUF_FIELD_OFFSET(::proto::ExternalBlobReference, _impl_.filesha256_), + PROTOBUF_FIELD_OFFSET(::proto::ExternalBlobReference, _impl_.fileencsha256_), + 0, + 1, + 2, + 5, + 3, + 4, + PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_.lightthemewallpaper_), + PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_.mediavisibility_), + PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_.darkthemewallpaper_), + PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_.autodownloadwifi_), + PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_.autodownloadcellular_), + PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_.autodownloadroaming_), + PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_.showindividualnotificationspreview_), + PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_.showgroupnotificationspreview_), + PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_.disappearingmodeduration_), + PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_.disappearingmodetimestamp_), + 0, + 5, + 1, + 2, + 3, + 4, + 6, + 7, + 9, + 8, + PROTOBUF_FIELD_OFFSET(::proto::GroupParticipant, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::GroupParticipant, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::GroupParticipant, _impl_.userjid_), + PROTOBUF_FIELD_OFFSET(::proto::GroupParticipant, _impl_.rank_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ClientFinish, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ClientFinish, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ClientFinish, _impl_.static__), + PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ClientFinish, _impl_.payload_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ClientHello, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ClientHello, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ClientHello, _impl_.ephemeral_), + PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ClientHello, _impl_.static__), + PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ClientHello, _impl_.payload_), + 0, + 1, + 2, + PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ServerHello, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ServerHello, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ServerHello, _impl_.ephemeral_), + PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ServerHello, _impl_.static__), + PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ServerHello, _impl_.payload_), + 0, + 1, + 2, + PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage, _impl_.clienthello_), + PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage, _impl_.serverhello_), + PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage, _impl_.clientfinish_), + 0, + 1, + 2, + PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.synctype_), + PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.conversations_), + PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.statusv3messages_), + PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.chunkorder_), + PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.progress_), + PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.pushnames_), + PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.globalsettings_), + PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.threadidusersecret_), + PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.threaddstimeframeoffset_), + PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.recentstickers_), + PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.pastparticipants_), + 2, + ~0u, + ~0u, + 3, + 4, + ~0u, + 1, + 0, + 5, + ~0u, + ~0u, + PROTOBUF_FIELD_OFFSET(::proto::HistorySyncMsg, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::HistorySyncMsg, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::HistorySyncMsg, _impl_.message_), + PROTOBUF_FIELD_OFFSET(::proto::HistorySyncMsg, _impl_.msgorderid_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedCallButton, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedCallButton, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedCallButton, _impl_.displaytext_), + PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedCallButton, _impl_.phonenumber_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedQuickReplyButton, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedQuickReplyButton, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedQuickReplyButton, _impl_.displaytext_), + PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedQuickReplyButton, _impl_.id_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedURLButton, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedURLButton, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedURLButton, _impl_.displaytext_), + PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedURLButton, _impl_.url_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton, _impl_._oneof_case_[0]), + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton, _impl_.index_), + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton, _impl_.hydratedButton_), + 0, + ~0u, + ~0u, + ~0u, + PROTOBUF_FIELD_OFFSET(::proto::IdentityKeyPairStructure, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::IdentityKeyPairStructure, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::IdentityKeyPairStructure, _impl_.publickey_), + PROTOBUF_FIELD_OFFSET(::proto::IdentityKeyPairStructure, _impl_.privatekey_), + 0, + 1, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::proto::InteractiveAnnotation, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::proto::InteractiveAnnotation, _impl_._oneof_case_[0]), + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::InteractiveAnnotation, _impl_.polygonvertices_), + ::_pbi::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::proto::InteractiveAnnotation, _impl_.action_), + PROTOBUF_FIELD_OFFSET(::proto::KeepInChat, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::KeepInChat, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::KeepInChat, _impl_.keeptype_), + PROTOBUF_FIELD_OFFSET(::proto::KeepInChat, _impl_.servertimestamp_), + PROTOBUF_FIELD_OFFSET(::proto::KeepInChat, _impl_.key_), + PROTOBUF_FIELD_OFFSET(::proto::KeepInChat, _impl_.devicejid_), + 3, + 2, + 1, + 0, + PROTOBUF_FIELD_OFFSET(::proto::KeyId, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::KeyId, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::KeyId, _impl_.id_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::LocalizedName, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::LocalizedName, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::LocalizedName, _impl_.lg_), + PROTOBUF_FIELD_OFFSET(::proto::LocalizedName, _impl_.lc_), + PROTOBUF_FIELD_OFFSET(::proto::LocalizedName, _impl_.verifiedname_), + 0, + 1, + 2, + PROTOBUF_FIELD_OFFSET(::proto::Location, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Location, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Location, _impl_.degreeslatitude_), + PROTOBUF_FIELD_OFFSET(::proto::Location, _impl_.degreeslongitude_), + PROTOBUF_FIELD_OFFSET(::proto::Location, _impl_.name_), + 1, + 2, + 0, + PROTOBUF_FIELD_OFFSET(::proto::MediaData, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::MediaData, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::MediaData, _impl_.localpath_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::MediaRetryNotification, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::MediaRetryNotification, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::MediaRetryNotification, _impl_.stanzaid_), + PROTOBUF_FIELD_OFFSET(::proto::MediaRetryNotification, _impl_.directpath_), + PROTOBUF_FIELD_OFFSET(::proto::MediaRetryNotification, _impl_.result_), + 0, + 1, + 2, + PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateFatalExceptionNotification, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateFatalExceptionNotification, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateFatalExceptionNotification, _impl_.collectionnames_), + PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateFatalExceptionNotification, _impl_.timestamp_), + ~0u, + 0, + PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyData, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyData, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyData, _impl_.keydata_), + PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyData, _impl_.fingerprint_), + PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyData, _impl_.timestamp_), + 0, + 1, + 2, + PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyFingerprint, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyFingerprint, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyFingerprint, _impl_.rawid_), + PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyFingerprint, _impl_.currentindex_), + PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyFingerprint, _impl_.deviceindexes_), + 0, + 1, + ~0u, + PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyId, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyId, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyId, _impl_.keyid_), + 0, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyRequest, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyRequest, _impl_.keyids_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyShare, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyShare, _impl_.keys_), + PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKey, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKey, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKey, _impl_.keyid_), + PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKey, _impl_.keydata_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.url_), + PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.mimetype_), + PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.filesha256_), + PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.filelength_), + PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.seconds_), + PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.ptt_), + PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.mediakey_), + PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.fileencsha256_), + PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.directpath_), + PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.mediakeytimestamp_), + PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.contextinfo_), + PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.streamingsidecar_), + PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.waveform_), + 0, + 1, + 2, + 9, + 10, + 11, + 3, + 4, + 5, + 12, + 8, + 6, + 7, + PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button_ButtonText, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button_ButtonText, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button_ButtonText, _impl_.displaytext_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button_NativeFlowInfo, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button_NativeFlowInfo, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button_NativeFlowInfo, _impl_.name_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button_NativeFlowInfo, _impl_.paramsjson_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button, _impl_.buttonid_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button, _impl_.buttontext_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button, _impl_.type_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button, _impl_.nativeflowinfo_), + 0, + 1, + 3, + 2, + PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage, _impl_._oneof_case_[0]), + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage, _impl_.contenttext_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage, _impl_.footertext_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage, _impl_.contextinfo_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage, _impl_.buttons_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage, _impl_.headertype_), + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage, _impl_.header_), + 0, + 1, + 2, + ~0u, + 3, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsResponseMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsResponseMessage, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsResponseMessage, _impl_._oneof_case_[0]), + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsResponseMessage, _impl_.selectedbuttonid_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsResponseMessage, _impl_.contextinfo_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsResponseMessage, _impl_.type_), + ::_pbi::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsResponseMessage, _impl_.response_), + 0, + 1, + 2, + ~0u, + PROTOBUF_FIELD_OFFSET(::proto::Message_Call, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_Call, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_Call, _impl_.callkey_), + PROTOBUF_FIELD_OFFSET(::proto::Message_Call, _impl_.conversionsource_), + PROTOBUF_FIELD_OFFSET(::proto::Message_Call, _impl_.conversiondata_), + PROTOBUF_FIELD_OFFSET(::proto::Message_Call, _impl_.conversiondelayseconds_), + 0, + 1, + 2, + 3, + PROTOBUF_FIELD_OFFSET(::proto::Message_CancelPaymentRequestMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_CancelPaymentRequestMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_CancelPaymentRequestMessage, _impl_.key_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::Message_Chat, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_Chat, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_Chat, _impl_.displayname_), + PROTOBUF_FIELD_OFFSET(::proto::Message_Chat, _impl_.id_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::Message_ContactMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ContactMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_ContactMessage, _impl_.displayname_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ContactMessage, _impl_.vcard_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ContactMessage, _impl_.contextinfo_), + 0, + 1, + 2, + PROTOBUF_FIELD_OFFSET(::proto::Message_ContactsArrayMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ContactsArrayMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_ContactsArrayMessage, _impl_.displayname_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ContactsArrayMessage, _impl_.contacts_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ContactsArrayMessage, _impl_.contextinfo_), + 0, + ~0u, + 1, + PROTOBUF_FIELD_OFFSET(::proto::Message_DeclinePaymentRequestMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_DeclinePaymentRequestMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_DeclinePaymentRequestMessage, _impl_.key_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::Message_DeviceSentMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_DeviceSentMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_DeviceSentMessage, _impl_.destinationjid_), + PROTOBUF_FIELD_OFFSET(::proto::Message_DeviceSentMessage, _impl_.message_), + PROTOBUF_FIELD_OFFSET(::proto::Message_DeviceSentMessage, _impl_.phash_), + 0, + 2, + 1, + PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.url_), + PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.mimetype_), + PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.title_), + PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.filesha256_), + PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.filelength_), + PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.pagecount_), + PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.mediakey_), + PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.filename_), + PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.fileencsha256_), + PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.directpath_), + PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.mediakeytimestamp_), + PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.contactvcard_), + PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.thumbnaildirectpath_), + PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.thumbnailsha256_), + PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.thumbnailencsha256_), + PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.jpegthumbnail_), + PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.contextinfo_), + PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.thumbnailheight_), + PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.thumbnailwidth_), + PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.caption_), + 0, + 1, + 2, + 3, + 14, + 15, + 4, + 5, + 6, + 7, + 17, + 16, + 8, + 9, + 10, + 11, + 13, + 18, + 19, + 12, + PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.text_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.matchedtext_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.canonicalurl_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.description_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.title_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.textargb_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.backgroundargb_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.font_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.previewtype_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.jpegthumbnail_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.contextinfo_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.donotplayinline_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.thumbnaildirectpath_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.thumbnailsha256_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.thumbnailencsha256_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.mediakey_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.mediakeytimestamp_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.thumbnailheight_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.thumbnailwidth_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.invitelinkgrouptype_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.invitelinkparentgroupsubjectv2_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.invitelinkparentgroupthumbnailv2_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.invitelinkgrouptypev2_), + 0, + 1, + 2, + 3, + 4, + 13, + 14, + 15, + 16, + 5, + 12, + 17, + 6, + 7, + 8, + 9, + 19, + 18, + 20, + 21, + 10, + 11, + 22, + PROTOBUF_FIELD_OFFSET(::proto::Message_FutureProofMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_FutureProofMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_FutureProofMessage, _impl_.message_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::Message_GroupInviteMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_GroupInviteMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_GroupInviteMessage, _impl_.groupjid_), + PROTOBUF_FIELD_OFFSET(::proto::Message_GroupInviteMessage, _impl_.invitecode_), + PROTOBUF_FIELD_OFFSET(::proto::Message_GroupInviteMessage, _impl_.inviteexpiration_), + PROTOBUF_FIELD_OFFSET(::proto::Message_GroupInviteMessage, _impl_.groupname_), + PROTOBUF_FIELD_OFFSET(::proto::Message_GroupInviteMessage, _impl_.jpegthumbnail_), + PROTOBUF_FIELD_OFFSET(::proto::Message_GroupInviteMessage, _impl_.caption_), + PROTOBUF_FIELD_OFFSET(::proto::Message_GroupInviteMessage, _impl_.contextinfo_), + PROTOBUF_FIELD_OFFSET(::proto::Message_GroupInviteMessage, _impl_.grouptype_), + 0, + 1, + 6, + 2, + 3, + 4, + 5, + 7, + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency, _impl_.currencycode_), + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency, _impl_.amount1000_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _impl_.dayofweek_), + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _impl_.year_), + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _impl_.month_), + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _impl_.dayofmonth_), + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _impl_.hour_), + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _impl_.minute_), + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _impl_.calendar_), + 5, + 0, + 1, + 2, + 3, + 4, + 6, + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch, _impl_.timestamp_), + 0, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime, _impl_._oneof_case_[0]), + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime, _impl_.datetimeOneof_), + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter, _impl_._oneof_case_[0]), + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter, _impl_.default__), + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter, _impl_.paramOneof_), + 0, + ~0u, + ~0u, + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _impl_.namespace__), + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _impl_.elementname_), + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _impl_.params_), + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _impl_.fallbacklg_), + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _impl_.fallbacklc_), + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _impl_.localizableparams_), + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _impl_.deterministiclg_), + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _impl_.deterministiclc_), + PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _impl_.hydratedhsm_), + 0, + 1, + ~0u, + 2, + 3, + ~0u, + 4, + 5, + 6, + PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _impl_.filesha256_), + PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _impl_.filelength_), + PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _impl_.mediakey_), + PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _impl_.fileencsha256_), + PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _impl_.directpath_), + PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _impl_.synctype_), + PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _impl_.chunkorder_), + PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _impl_.originalmessageid_), + PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _impl_.progress_), + 0, + 5, + 1, + 2, + 3, + 6, + 7, + 4, + 8, + PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.url_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.mimetype_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.caption_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.filesha256_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.filelength_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.height_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.width_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.mediakey_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.fileencsha256_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.interactiveannotations_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.directpath_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.mediakeytimestamp_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.jpegthumbnail_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.contextinfo_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.firstscansidecar_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.firstscanlength_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.experimentgroupid_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.scanssidecar_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.scanlengths_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.midqualityfilesha256_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.midqualityfileencsha256_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.viewonce_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.thumbnaildirectpath_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.thumbnailsha256_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.thumbnailencsha256_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.staticurl_), + 0, + 1, + 2, + 3, + 17, + 18, + 19, + 4, + 5, + ~0u, + 6, + 20, + 7, + 16, + 8, + 21, + 22, + 9, + ~0u, + 10, + 11, + 23, + 12, + 13, + 14, + 15, + PROTOBUF_FIELD_OFFSET(::proto::Message_InitialSecurityNotificationSettingSync, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InitialSecurityNotificationSettingSync, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_InitialSecurityNotificationSettingSync, _impl_.securitynotificationenabled_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Body, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Body, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Body, _impl_.text_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_CollectionMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_CollectionMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_CollectionMessage, _impl_.bizjid_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_CollectionMessage, _impl_.id_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_CollectionMessage, _impl_.messageversion_), + 0, + 1, + 2, + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Footer, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Footer, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Footer, _impl_.text_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Header, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Header, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Header, _impl_._oneof_case_[0]), + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Header, _impl_.title_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Header, _impl_.subtitle_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Header, _impl_.hasmediaattachment_), + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Header, _impl_.media_), + 0, + 1, + 2, + ~0u, + ~0u, + ~0u, + ~0u, + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton, _impl_.name_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton, _impl_.buttonparamsjson_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_NativeFlowMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_NativeFlowMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_NativeFlowMessage, _impl_.buttons_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_NativeFlowMessage, _impl_.messageparamsjson_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_NativeFlowMessage, _impl_.messageversion_), + ~0u, + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_ShopMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_ShopMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_ShopMessage, _impl_.id_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_ShopMessage, _impl_.surface_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_ShopMessage, _impl_.messageversion_), + 0, + 1, + 2, + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage, _impl_._oneof_case_[0]), + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage, _impl_.header_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage, _impl_.body_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage, _impl_.footer_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage, _impl_.contextinfo_), + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage, _impl_.interactiveMessage_), + 0, + 1, + 2, + 3, + ~0u, + ~0u, + ~0u, + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage_Body, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage_Body, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage_Body, _impl_.text_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage, _impl_.name_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage, _impl_.paramsjson_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage, _impl_.version_), + 0, + 1, + 2, + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage, _impl_._oneof_case_[0]), + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage, _impl_.body_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage, _impl_.contextinfo_), + ::_pbi::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage, _impl_.interactiveResponseMessage_), + 0, + 1, + ~0u, + PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_.note_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_.token_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_.attachmenttype_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_.attachmentmimetype_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_.attachmentmediakey_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_.attachmentmediakeytimestamp_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_.attachmentfilesha256_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_.attachmentfileencsha256_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_.attachmentdirectpath_), + PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_.attachmentjpegthumbnail_), + 0, + 1, + 9, + 2, + 3, + 8, + 4, + 5, + 6, + 7, + PROTOBUF_FIELD_OFFSET(::proto::Message_KeepInChatMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_KeepInChatMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_KeepInChatMessage, _impl_.key_), + PROTOBUF_FIELD_OFFSET(::proto::Message_KeepInChatMessage, _impl_.keeptype_), + PROTOBUF_FIELD_OFFSET(::proto::Message_KeepInChatMessage, _impl_.timestampms_), + 0, + 2, + 1, + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductListHeaderImage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductListHeaderImage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductListHeaderImage, _impl_.productid_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductListHeaderImage, _impl_.jpegthumbnail_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductListInfo, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductListInfo, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductListInfo, _impl_.productsections_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductListInfo, _impl_.headerimage_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductListInfo, _impl_.businessownerjid_), + ~0u, + 1, + 0, + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductSection, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductSection, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductSection, _impl_.title_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductSection, _impl_.products_), + 0, + ~0u, + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Product, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Product, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Product, _impl_.productid_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Row, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Row, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Row, _impl_.title_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Row, _impl_.description_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Row, _impl_.rowid_), + 0, + 1, + 2, + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Section, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Section, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Section, _impl_.title_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Section, _impl_.rows_), + 0, + ~0u, + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage, _impl_.title_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage, _impl_.description_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage, _impl_.buttontext_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage, _impl_.listtype_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage, _impl_.sections_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage, _impl_.productlistinfo_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage, _impl_.footertext_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage, _impl_.contextinfo_), + 0, + 1, + 2, + 6, + ~0u, + 4, + 3, + 5, + PROTOBUF_FIELD_OFFSET(::proto::Message_ListResponseMessage_SingleSelectReply, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ListResponseMessage_SingleSelectReply, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_ListResponseMessage_SingleSelectReply, _impl_.selectedrowid_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::Message_ListResponseMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ListResponseMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_ListResponseMessage, _impl_.title_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ListResponseMessage, _impl_.listtype_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ListResponseMessage, _impl_.singleselectreply_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ListResponseMessage, _impl_.contextinfo_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ListResponseMessage, _impl_.description_), + 0, + 4, + 2, + 3, + 1, + PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_.degreeslatitude_), + PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_.degreeslongitude_), + PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_.accuracyinmeters_), + PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_.speedinmps_), + PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_.degreesclockwisefrommagneticnorth_), + PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_.caption_), + PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_.sequencenumber_), + PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_.timeoffset_), + PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_.jpegthumbnail_), + PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_.contextinfo_), + 3, + 4, + 5, + 6, + 7, + 0, + 9, + 8, + 1, + 2, + PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.degreeslatitude_), + PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.degreeslongitude_), + PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.name_), + PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.address_), + PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.url_), + PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.islive_), + PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.accuracyinmeters_), + PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.speedinmps_), + PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.degreesclockwisefrommagneticnorth_), + PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.comment_), + PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.jpegthumbnail_), + PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.contextinfo_), + 6, + 7, + 0, + 1, + 2, + 8, + 9, + 10, + 11, + 3, + 4, + 5, + PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.orderid_), + PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.thumbnail_), + PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.itemcount_), + PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.status_), + PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.surface_), + PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.message_), + PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.ordertitle_), + PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.sellerjid_), + PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.token_), + PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.totalamount1000_), + PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.totalcurrencycode_), + PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.contextinfo_), + 0, + 1, + 9, + 10, + 11, + 2, + 3, + 4, + 5, + 8, + 6, + 7, + PROTOBUF_FIELD_OFFSET(::proto::Message_PaymentInviteMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_PaymentInviteMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_PaymentInviteMessage, _impl_.servicetype_), + PROTOBUF_FIELD_OFFSET(::proto::Message_PaymentInviteMessage, _impl_.expirytimestamp_), + 1, + 0, + PROTOBUF_FIELD_OFFSET(::proto::Message_PollCreationMessage_Option, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_PollCreationMessage_Option, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_PollCreationMessage_Option, _impl_.optionname_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::Message_PollCreationMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_PollCreationMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_PollCreationMessage, _impl_.enckey_), + PROTOBUF_FIELD_OFFSET(::proto::Message_PollCreationMessage, _impl_.name_), + PROTOBUF_FIELD_OFFSET(::proto::Message_PollCreationMessage, _impl_.options_), + PROTOBUF_FIELD_OFFSET(::proto::Message_PollCreationMessage, _impl_.selectableoptionscount_), + PROTOBUF_FIELD_OFFSET(::proto::Message_PollCreationMessage, _impl_.contextinfo_), + 0, + 1, + ~0u, + 3, + 2, + PROTOBUF_FIELD_OFFSET(::proto::Message_PollEncValue, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_PollEncValue, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_PollEncValue, _impl_.encpayload_), + PROTOBUF_FIELD_OFFSET(::proto::Message_PollEncValue, _impl_.enciv_), + 0, + 1, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::proto::Message_PollUpdateMessageMetadata, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_PollUpdateMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_PollUpdateMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_PollUpdateMessage, _impl_.pollcreationmessagekey_), + PROTOBUF_FIELD_OFFSET(::proto::Message_PollUpdateMessage, _impl_.vote_), + PROTOBUF_FIELD_OFFSET(::proto::Message_PollUpdateMessage, _impl_.metadata_), + PROTOBUF_FIELD_OFFSET(::proto::Message_PollUpdateMessage, _impl_.sendertimestampms_), + 0, + 1, + 2, + 3, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::proto::Message_PollVoteMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_PollVoteMessage, _impl_.selectedoptions_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_CatalogSnapshot, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_CatalogSnapshot, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_CatalogSnapshot, _impl_.catalogimage_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_CatalogSnapshot, _impl_.title_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_CatalogSnapshot, _impl_.description_), + 2, + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.productimage_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.productid_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.title_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.description_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.currencycode_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.priceamount1000_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.retailerid_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.url_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.productimagecount_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.firstimageid_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.salepriceamount1000_), + 7, + 0, + 1, + 2, + 3, + 8, + 4, + 5, + 10, + 6, + 9, + PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage, _impl_.product_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage, _impl_.businessownerjid_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage, _impl_.catalog_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage, _impl_.body_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage, _impl_.footer_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage, _impl_.contextinfo_), + 3, + 0, + 4, + 1, + 2, + 5, + PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.key_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.type_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.ephemeralexpiration_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.ephemeralsettingtimestamp_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.historysyncnotification_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.appstatesynckeyshare_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.appstatesynckeyrequest_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.initialsecuritynotificationsettingsync_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.appstatefatalexceptionnotification_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.disappearingmode_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.requestmediauploadmessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.requestmediauploadresponsemessage_), + 0, + 9, + 10, + 11, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + PROTOBUF_FIELD_OFFSET(::proto::Message_ReactionMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ReactionMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_ReactionMessage, _impl_.key_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ReactionMessage, _impl_.text_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ReactionMessage, _impl_.groupingkey_), + PROTOBUF_FIELD_OFFSET(::proto::Message_ReactionMessage, _impl_.sendertimestampms_), + 2, + 0, + 1, + 3, + PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadMessage, _impl_.filesha256_), + PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadMessage, _impl_.rmrsource_), + ~0u, + 0, + PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult, _impl_.filesha256_), + PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult, _impl_.mediauploadresult_), + PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult, _impl_.stickermessage_), + 0, + 2, + 1, + PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadResponseMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadResponseMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadResponseMessage, _impl_.rmrsource_), + PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadResponseMessage, _impl_.stanzaid_), + PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadResponseMessage, _impl_.reuploadresult_), + 1, + 0, + ~0u, + PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPaymentMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPaymentMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPaymentMessage, _impl_.notemessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPaymentMessage, _impl_.currencycodeiso4217_), + PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPaymentMessage, _impl_.amount1000_), + PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPaymentMessage, _impl_.requestfrom_), + PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPaymentMessage, _impl_.expirytimestamp_), + PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPaymentMessage, _impl_.amount_), + PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPaymentMessage, _impl_.background_), + 2, + 0, + 5, + 1, + 6, + 3, + 4, + PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPhoneNumberMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPhoneNumberMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPhoneNumberMessage, _impl_.contextinfo_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::Message_SendPaymentMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_SendPaymentMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_SendPaymentMessage, _impl_.notemessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message_SendPaymentMessage, _impl_.requestmessagekey_), + PROTOBUF_FIELD_OFFSET(::proto::Message_SendPaymentMessage, _impl_.background_), + 0, + 1, + 2, + PROTOBUF_FIELD_OFFSET(::proto::Message_SenderKeyDistributionMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_SenderKeyDistributionMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_SenderKeyDistributionMessage, _impl_.groupid_), + PROTOBUF_FIELD_OFFSET(::proto::Message_SenderKeyDistributionMessage, _impl_.axolotlsenderkeydistributionmessage_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.url_), + PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.filesha256_), + PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.fileencsha256_), + PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.mediakey_), + PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.mimetype_), + PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.height_), + PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.width_), + PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.directpath_), + PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.filelength_), + PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.mediakeytimestamp_), + PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.firstframelength_), + PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.firstframesidecar_), + PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.isanimated_), + PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.pngthumbnail_), + PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.contextinfo_), + 0, + 1, + 2, + 3, + 4, + 9, + 10, + 5, + 11, + 12, + 13, + 6, + 14, + 7, + 8, + PROTOBUF_FIELD_OFFSET(::proto::Message_StickerSyncRMRMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_StickerSyncRMRMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_StickerSyncRMRMessage, _impl_.filehash_), + PROTOBUF_FIELD_OFFSET(::proto::Message_StickerSyncRMRMessage, _impl_.rmrsource_), + PROTOBUF_FIELD_OFFSET(::proto::Message_StickerSyncRMRMessage, _impl_.requesttimestamp_), + ~0u, + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateButtonReplyMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateButtonReplyMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateButtonReplyMessage, _impl_.selectedid_), + PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateButtonReplyMessage, _impl_.selecteddisplaytext_), + PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateButtonReplyMessage, _impl_.contextinfo_), + PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateButtonReplyMessage, _impl_.selectedindex_), + 0, + 1, + 2, + 3, + PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_FourRowTemplate, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_FourRowTemplate, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_FourRowTemplate, _impl_._oneof_case_[0]), + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_FourRowTemplate, _impl_.content_), + PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_FourRowTemplate, _impl_.footer_), + PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_FourRowTemplate, _impl_.buttons_), + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_FourRowTemplate, _impl_.title_), + 0, + 1, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_HydratedFourRowTemplate, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_HydratedFourRowTemplate, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_HydratedFourRowTemplate, _impl_._oneof_case_[0]), + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_HydratedFourRowTemplate, _impl_.hydratedcontenttext_), + PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_HydratedFourRowTemplate, _impl_.hydratedfootertext_), + PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_HydratedFourRowTemplate, _impl_.hydratedbuttons_), + PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_HydratedFourRowTemplate, _impl_.templateid_), + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_HydratedFourRowTemplate, _impl_.title_), + 0, + 1, + ~0u, + 2, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage, _impl_._oneof_case_[0]), + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage, _impl_.contextinfo_), + PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage, _impl_.hydratedtemplate_), + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage, _impl_.format_), + 0, + 1, + ~0u, + ~0u, + PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.url_), + PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.mimetype_), + PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.filesha256_), + PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.filelength_), + PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.seconds_), + PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.mediakey_), + PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.caption_), + PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.gifplayback_), + PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.height_), + PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.width_), + PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.fileencsha256_), + PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.interactiveannotations_), + PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.directpath_), + PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.mediakeytimestamp_), + PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.jpegthumbnail_), + PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.contextinfo_), + PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.streamingsidecar_), + PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.gifattribution_), + PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.viewonce_), + PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.thumbnaildirectpath_), + PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.thumbnailsha256_), + PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.thumbnailencsha256_), + PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.staticurl_), + 0, + 1, + 2, + 14, + 15, + 3, + 4, + 18, + 16, + 17, + 5, + ~0u, + 6, + 20, + 7, + 13, + 8, + 21, + 19, + 9, + 10, + 11, + 12, + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.conversation_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.senderkeydistributionmessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.imagemessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.contactmessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.locationmessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.extendedtextmessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.documentmessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.audiomessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.videomessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.call_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.chat_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.protocolmessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.contactsarraymessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.highlystructuredmessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.fastratchetkeysenderkeydistributionmessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.sendpaymentmessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.livelocationmessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.requestpaymentmessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.declinepaymentrequestmessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.cancelpaymentrequestmessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.templatemessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.stickermessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.groupinvitemessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.templatebuttonreplymessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.productmessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.devicesentmessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.messagecontextinfo_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.listmessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.viewoncemessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.ordermessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.listresponsemessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.ephemeralmessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.invoicemessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.buttonsmessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.buttonsresponsemessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.paymentinvitemessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.interactivemessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.reactionmessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.stickersyncrmrmessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.interactiveresponsemessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.pollcreationmessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.pollupdatemessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.keepinchatmessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.documentwithcaptionmessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.requestphonenumbermessage_), + PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.viewoncemessagev2_), + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + PROTOBUF_FIELD_OFFSET(::proto::MessageContextInfo, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::MessageContextInfo, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::MessageContextInfo, _impl_.devicelistmetadata_), + PROTOBUF_FIELD_OFFSET(::proto::MessageContextInfo, _impl_.devicelistmetadataversion_), + PROTOBUF_FIELD_OFFSET(::proto::MessageContextInfo, _impl_.messagesecret_), + PROTOBUF_FIELD_OFFSET(::proto::MessageContextInfo, _impl_.paddingbytes_), + 2, + 3, + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::MessageKey, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::MessageKey, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::MessageKey, _impl_.remotejid_), + PROTOBUF_FIELD_OFFSET(::proto::MessageKey, _impl_.fromme_), + PROTOBUF_FIELD_OFFSET(::proto::MessageKey, _impl_.id_), + PROTOBUF_FIELD_OFFSET(::proto::MessageKey, _impl_.participant_), + 0, + 3, + 1, + 2, + PROTOBUF_FIELD_OFFSET(::proto::Money, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Money, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Money, _impl_.value_), + PROTOBUF_FIELD_OFFSET(::proto::Money, _impl_.offset_), + PROTOBUF_FIELD_OFFSET(::proto::Money, _impl_.currencycode_), + 1, + 2, + 0, + PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData_PollOption, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData_PollOption, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData_PollOption, _impl_.name_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.body_), + PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.caption_), + PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.lng_), + PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.islive_), + PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.lat_), + PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.paymentamount1000_), + PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.paymentnotemsgbody_), + PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.canonicalurl_), + PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.matchedtext_), + PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.title_), + PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.description_), + PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.futureproofbuffer_), + PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.clienturl_), + PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.loc_), + PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.pollname_), + PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.polloptions_), + PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.pollselectableoptionscount_), + PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.messagesecret_), + PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.sendertimestampms_), + PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.pollupdateparentkey_), + PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.encpollvote_), + 0, + 1, + 14, + 16, + 15, + 17, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + ~0u, + 19, + 11, + 18, + 12, + 13, + PROTOBUF_FIELD_OFFSET(::proto::MsgRowOpaqueData, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::MsgRowOpaqueData, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::MsgRowOpaqueData, _impl_.currentmsg_), + PROTOBUF_FIELD_OFFSET(::proto::MsgRowOpaqueData, _impl_.quotedmsg_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate_Details, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate_Details, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate_Details, _impl_.serial_), + PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate_Details, _impl_.issuer_), + PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate_Details, _impl_.expires_), + PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate_Details, _impl_.subject_), + PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate_Details, _impl_.key_), + 4, + 0, + 3, + 1, + 2, + PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate, _impl_.details_), + PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate, _impl_.signature_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::NotificationMessageInfo, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::NotificationMessageInfo, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::NotificationMessageInfo, _impl_.key_), + PROTOBUF_FIELD_OFFSET(::proto::NotificationMessageInfo, _impl_.message_), + PROTOBUF_FIELD_OFFSET(::proto::NotificationMessageInfo, _impl_.messagetimestamp_), + PROTOBUF_FIELD_OFFSET(::proto::NotificationMessageInfo, _impl_.participant_), + 1, + 2, + 3, + 0, + PROTOBUF_FIELD_OFFSET(::proto::PastParticipant, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::PastParticipant, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::PastParticipant, _impl_.userjid_), + PROTOBUF_FIELD_OFFSET(::proto::PastParticipant, _impl_.leavereason_), + PROTOBUF_FIELD_OFFSET(::proto::PastParticipant, _impl_.leavets_), + 0, + 2, + 1, + PROTOBUF_FIELD_OFFSET(::proto::PastParticipants, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::PastParticipants, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::PastParticipants, _impl_.groupjid_), + PROTOBUF_FIELD_OFFSET(::proto::PastParticipants, _impl_.pastparticipants_), + 0, + ~0u, + PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground_MediaData, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground_MediaData, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground_MediaData, _impl_.mediakey_), + PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground_MediaData, _impl_.mediakeytimestamp_), + PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground_MediaData, _impl_.filesha256_), + PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground_MediaData, _impl_.fileencsha256_), + PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground_MediaData, _impl_.directpath_), + 0, + 4, + 1, + 2, + 3, + PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_.id_), + PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_.filelength_), + PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_.width_), + PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_.height_), + PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_.mimetype_), + PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_.placeholderargb_), + PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_.textargb_), + PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_.subtextargb_), + PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_.mediadata_), + PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_.type_), + 0, + 3, + 4, + 5, + 1, + 6, + 7, + 8, + 2, + 9, + PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.currencydeprecated_), + PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.amount1000_), + PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.receiverjid_), + PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.status_), + PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.transactiontimestamp_), + PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.requestmessagekey_), + PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.expirytimestamp_), + PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.futureproofed_), + PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.currency_), + PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.txnstatus_), + PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.usenovifiatformat_), + PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.primaryamount_), + PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.exchangeamount_), + 6, + 5, + 0, + 7, + 8, + 2, + 9, + 10, + 1, + 12, + 11, + 3, + 4, + PROTOBUF_FIELD_OFFSET(::proto::PendingKeyExchange, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::PendingKeyExchange, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::PendingKeyExchange, _impl_.sequence_), + PROTOBUF_FIELD_OFFSET(::proto::PendingKeyExchange, _impl_.localbasekey_), + PROTOBUF_FIELD_OFFSET(::proto::PendingKeyExchange, _impl_.localbasekeyprivate_), + PROTOBUF_FIELD_OFFSET(::proto::PendingKeyExchange, _impl_.localratchetkey_), + PROTOBUF_FIELD_OFFSET(::proto::PendingKeyExchange, _impl_.localratchetkeyprivate_), + PROTOBUF_FIELD_OFFSET(::proto::PendingKeyExchange, _impl_.localidentitykey_), + PROTOBUF_FIELD_OFFSET(::proto::PendingKeyExchange, _impl_.localidentitykeyprivate_), + 6, + 0, + 1, + 2, + 3, + 4, + 5, + PROTOBUF_FIELD_OFFSET(::proto::PendingPreKey, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::PendingPreKey, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::PendingPreKey, _impl_.prekeyid_), + PROTOBUF_FIELD_OFFSET(::proto::PendingPreKey, _impl_.signedprekeyid_), + PROTOBUF_FIELD_OFFSET(::proto::PendingPreKey, _impl_.basekey_), + 1, + 2, + 0, + PROTOBUF_FIELD_OFFSET(::proto::PhotoChange, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::PhotoChange, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::PhotoChange, _impl_.oldphoto_), + PROTOBUF_FIELD_OFFSET(::proto::PhotoChange, _impl_.newphoto_), + PROTOBUF_FIELD_OFFSET(::proto::PhotoChange, _impl_.newphotoid_), + 0, + 1, + 2, + PROTOBUF_FIELD_OFFSET(::proto::Point, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Point, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Point, _impl_.xdeprecated_), + PROTOBUF_FIELD_OFFSET(::proto::Point, _impl_.ydeprecated_), + PROTOBUF_FIELD_OFFSET(::proto::Point, _impl_.x_), + PROTOBUF_FIELD_OFFSET(::proto::Point, _impl_.y_), + 0, + 1, + 2, + 3, + PROTOBUF_FIELD_OFFSET(::proto::PollAdditionalMetadata, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::PollAdditionalMetadata, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::PollAdditionalMetadata, _impl_.pollinvalidated_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::PollEncValue, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::PollEncValue, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::PollEncValue, _impl_.encpayload_), + PROTOBUF_FIELD_OFFSET(::proto::PollEncValue, _impl_.enciv_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::PollUpdate, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::PollUpdate, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::PollUpdate, _impl_.pollupdatemessagekey_), + PROTOBUF_FIELD_OFFSET(::proto::PollUpdate, _impl_.vote_), + PROTOBUF_FIELD_OFFSET(::proto::PollUpdate, _impl_.sendertimestampms_), + 0, + 1, + 2, + PROTOBUF_FIELD_OFFSET(::proto::PreKeyRecordStructure, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::PreKeyRecordStructure, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::PreKeyRecordStructure, _impl_.id_), + PROTOBUF_FIELD_OFFSET(::proto::PreKeyRecordStructure, _impl_.publickey_), + PROTOBUF_FIELD_OFFSET(::proto::PreKeyRecordStructure, _impl_.privatekey_), + 2, + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::Pushname, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Pushname, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Pushname, _impl_.id_), + PROTOBUF_FIELD_OFFSET(::proto::Pushname, _impl_.pushname_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::Reaction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::Reaction, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::Reaction, _impl_.key_), + PROTOBUF_FIELD_OFFSET(::proto::Reaction, _impl_.text_), + PROTOBUF_FIELD_OFFSET(::proto::Reaction, _impl_.groupingkey_), + PROTOBUF_FIELD_OFFSET(::proto::Reaction, _impl_.sendertimestampms_), + PROTOBUF_FIELD_OFFSET(::proto::Reaction, _impl_.unread_), + 2, + 0, + 1, + 3, + 4, + PROTOBUF_FIELD_OFFSET(::proto::RecentEmojiWeight, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::RecentEmojiWeight, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::RecentEmojiWeight, _impl_.emoji_), + PROTOBUF_FIELD_OFFSET(::proto::RecentEmojiWeight, _impl_.weight_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::RecordStructure, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::RecordStructure, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::RecordStructure, _impl_.currentsession_), + PROTOBUF_FIELD_OFFSET(::proto::RecordStructure, _impl_.previoussessions_), + 0, + ~0u, + PROTOBUF_FIELD_OFFSET(::proto::SenderChainKey, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SenderChainKey, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SenderChainKey, _impl_.iteration_), + PROTOBUF_FIELD_OFFSET(::proto::SenderChainKey, _impl_.seed_), + 1, + 0, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::proto::SenderKeyRecordStructure, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SenderKeyRecordStructure, _impl_.senderkeystates_), + PROTOBUF_FIELD_OFFSET(::proto::SenderKeyStateStructure, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SenderKeyStateStructure, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SenderKeyStateStructure, _impl_.senderkeyid_), + PROTOBUF_FIELD_OFFSET(::proto::SenderKeyStateStructure, _impl_.senderchainkey_), + PROTOBUF_FIELD_OFFSET(::proto::SenderKeyStateStructure, _impl_.sendersigningkey_), + PROTOBUF_FIELD_OFFSET(::proto::SenderKeyStateStructure, _impl_.sendermessagekeys_), + 2, + 0, + 1, + ~0u, + PROTOBUF_FIELD_OFFSET(::proto::SenderMessageKey, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SenderMessageKey, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SenderMessageKey, _impl_.iteration_), + PROTOBUF_FIELD_OFFSET(::proto::SenderMessageKey, _impl_.seed_), + 1, + 0, + PROTOBUF_FIELD_OFFSET(::proto::SenderSigningKey, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SenderSigningKey, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SenderSigningKey, _impl_.public__), + PROTOBUF_FIELD_OFFSET(::proto::SenderSigningKey, _impl_.private__), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::ServerErrorReceipt, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::ServerErrorReceipt, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::ServerErrorReceipt, _impl_.stanzaid_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.sessionversion_), + PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.localidentitypublic_), + PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.remoteidentitypublic_), + PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.rootkey_), + PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.previouscounter_), + PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.senderchain_), + PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.receiverchains_), + PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.pendingkeyexchange_), + PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.pendingprekey_), + PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.remoteregistrationid_), + PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.localregistrationid_), + PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.needsrefresh_), + PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.alicebasekey_), + 7, + 0, + 1, + 2, + 8, + 4, + ~0u, + 5, + 6, + 9, + 10, + 11, + 3, + PROTOBUF_FIELD_OFFSET(::proto::SignedPreKeyRecordStructure, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SignedPreKeyRecordStructure, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SignedPreKeyRecordStructure, _impl_.id_), + PROTOBUF_FIELD_OFFSET(::proto::SignedPreKeyRecordStructure, _impl_.publickey_), + PROTOBUF_FIELD_OFFSET(::proto::SignedPreKeyRecordStructure, _impl_.privatekey_), + PROTOBUF_FIELD_OFFSET(::proto::SignedPreKeyRecordStructure, _impl_.signature_), + PROTOBUF_FIELD_OFFSET(::proto::SignedPreKeyRecordStructure, _impl_.timestamp_), + 4, + 0, + 1, + 2, + 3, + PROTOBUF_FIELD_OFFSET(::proto::StatusPSA, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::StatusPSA, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::StatusPSA, _impl_.campaignid_), + PROTOBUF_FIELD_OFFSET(::proto::StatusPSA, _impl_.campaignexpirationtimestamp_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_.url_), + PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_.filesha256_), + PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_.fileencsha256_), + PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_.mediakey_), + PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_.mimetype_), + PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_.height_), + PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_.width_), + PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_.directpath_), + PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_.filelength_), + PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_.weight_), + 0, + 1, + 2, + 3, + 4, + 6, + 7, + 5, + 8, + 9, + PROTOBUF_FIELD_OFFSET(::proto::SyncActionData, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionData, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionData, _impl_.index_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionData, _impl_.value_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionData, _impl_.padding_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionData, _impl_.version_), + 0, + 2, + 1, + 3, + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_AgentAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_AgentAction, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_AgentAction, _impl_.name_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_AgentAction, _impl_.deviceid_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_AgentAction, _impl_.isdeleted_), + 0, + 1, + 2, + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_AndroidUnsupportedActions, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_AndroidUnsupportedActions, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_AndroidUnsupportedActions, _impl_.allowed_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ArchiveChatAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ArchiveChatAction, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ArchiveChatAction, _impl_.archived_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ArchiveChatAction, _impl_.messagerange_), + 1, + 0, + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ClearChatAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ClearChatAction, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ClearChatAction, _impl_.messagerange_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ContactAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ContactAction, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ContactAction, _impl_.fullname_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ContactAction, _impl_.firstname_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_DeleteChatAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_DeleteChatAction, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_DeleteChatAction, _impl_.messagerange_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_DeleteMessageForMeAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_DeleteMessageForMeAction, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_DeleteMessageForMeAction, _impl_.deletemedia_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_DeleteMessageForMeAction, _impl_.messagetimestamp_), + 1, + 0, + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_KeyExpiration, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_KeyExpiration, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_KeyExpiration, _impl_.expiredkeyepoch_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LabelAssociationAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LabelAssociationAction, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LabelAssociationAction, _impl_.labeled_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LabelEditAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LabelEditAction, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LabelEditAction, _impl_.name_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LabelEditAction, _impl_.color_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LabelEditAction, _impl_.predefinedid_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LabelEditAction, _impl_.deleted_), + 0, + 1, + 2, + 3, + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LocaleSetting, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LocaleSetting, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LocaleSetting, _impl_.locale_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_MarkChatAsReadAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_MarkChatAsReadAction, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_MarkChatAsReadAction, _impl_.read_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_MarkChatAsReadAction, _impl_.messagerange_), + 1, + 0, + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_MuteAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_MuteAction, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_MuteAction, _impl_.muted_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_MuteAction, _impl_.muteendtimestamp_), + 1, + 0, + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_NuxAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_NuxAction, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_NuxAction, _impl_.acknowledged_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PinAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PinAction, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PinAction, _impl_.pinned_), + 0, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PrimaryFeature, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PrimaryFeature, _impl_.flags_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PrimaryVersionAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PrimaryVersionAction, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PrimaryVersionAction, _impl_.version_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PushNameSetting, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PushNameSetting, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PushNameSetting, _impl_.name_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_QuickReplyAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_QuickReplyAction, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_QuickReplyAction, _impl_.shortcut_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_QuickReplyAction, _impl_.message_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_QuickReplyAction, _impl_.keywords_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_QuickReplyAction, _impl_.count_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_QuickReplyAction, _impl_.deleted_), + 0, + 1, + ~0u, + 2, + 3, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_RecentEmojiWeightsAction, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_RecentEmojiWeightsAction, _impl_.weights_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SecurityNotificationSetting, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SecurityNotificationSetting, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SecurityNotificationSetting, _impl_.shownotification_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StarAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StarAction, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StarAction, _impl_.starred_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_.url_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_.fileencsha256_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_.mediakey_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_.mimetype_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_.height_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_.width_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_.directpath_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_.filelength_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_.isfavorite_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_.deviceidhint_), + 0, + 1, + 2, + 3, + 5, + 6, + 4, + 7, + 8, + 9, + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SubscriptionAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SubscriptionAction, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SubscriptionAction, _impl_.isdeactivated_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SubscriptionAction, _impl_.isautorenewing_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SubscriptionAction, _impl_.expirationdate_), + 1, + 2, + 0, + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SyncActionMessageRange, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SyncActionMessageRange, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SyncActionMessageRange, _impl_.lastmessagetimestamp_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SyncActionMessageRange, _impl_.lastsystemmessagetimestamp_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SyncActionMessageRange, _impl_.messages_), + 0, + 1, + ~0u, + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SyncActionMessage, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SyncActionMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SyncActionMessage, _impl_.key_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SyncActionMessage, _impl_.timestamp_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_TimeFormatAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_TimeFormatAction, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_TimeFormatAction, _impl_.istwentyfourhourformatenabled_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_UnarchiveChatsSetting, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_UnarchiveChatsSetting, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_UnarchiveChatsSetting, _impl_.unarchivechats_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_UserStatusMuteAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_UserStatusMuteAction, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_UserStatusMuteAction, _impl_.muted_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.timestamp_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.staraction_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.contactaction_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.muteaction_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.pinaction_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.securitynotificationsetting_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.pushnamesetting_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.quickreplyaction_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.recentemojiweightsaction_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.labeleditaction_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.labelassociationaction_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.localesetting_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.archivechataction_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.deletemessageformeaction_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.keyexpiration_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.markchatasreadaction_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.clearchataction_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.deletechataction_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.unarchivechatssetting_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.primaryfeature_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.androidunsupportedactions_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.agentaction_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.subscriptionaction_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.userstatusmuteaction_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.timeformataction_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.nuxaction_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.primaryversionaction_), + PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.stickeraction_), + 27, + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + PROTOBUF_FIELD_OFFSET(::proto::SyncdIndex, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncdIndex, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncdIndex, _impl_.blob_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::SyncdMutation, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncdMutation, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncdMutation, _impl_.operation_), + PROTOBUF_FIELD_OFFSET(::proto::SyncdMutation, _impl_.record_), + 1, + 0, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::proto::SyncdMutations, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncdMutations, _impl_.mutations_), + PROTOBUF_FIELD_OFFSET(::proto::SyncdPatch, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncdPatch, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncdPatch, _impl_.version_), + PROTOBUF_FIELD_OFFSET(::proto::SyncdPatch, _impl_.mutations_), + PROTOBUF_FIELD_OFFSET(::proto::SyncdPatch, _impl_.externalmutations_), + PROTOBUF_FIELD_OFFSET(::proto::SyncdPatch, _impl_.snapshotmac_), + PROTOBUF_FIELD_OFFSET(::proto::SyncdPatch, _impl_.patchmac_), + PROTOBUF_FIELD_OFFSET(::proto::SyncdPatch, _impl_.keyid_), + PROTOBUF_FIELD_OFFSET(::proto::SyncdPatch, _impl_.exitcode_), + PROTOBUF_FIELD_OFFSET(::proto::SyncdPatch, _impl_.deviceindex_), + 2, + ~0u, + 3, + 0, + 1, + 4, + 5, + 6, + PROTOBUF_FIELD_OFFSET(::proto::SyncdRecord, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncdRecord, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncdRecord, _impl_.index_), + PROTOBUF_FIELD_OFFSET(::proto::SyncdRecord, _impl_.value_), + PROTOBUF_FIELD_OFFSET(::proto::SyncdRecord, _impl_.keyid_), + 0, + 1, + 2, + PROTOBUF_FIELD_OFFSET(::proto::SyncdSnapshot, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncdSnapshot, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncdSnapshot, _impl_.version_), + PROTOBUF_FIELD_OFFSET(::proto::SyncdSnapshot, _impl_.records_), + PROTOBUF_FIELD_OFFSET(::proto::SyncdSnapshot, _impl_.mac_), + PROTOBUF_FIELD_OFFSET(::proto::SyncdSnapshot, _impl_.keyid_), + 1, + ~0u, + 0, + 2, + PROTOBUF_FIELD_OFFSET(::proto::SyncdValue, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncdValue, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncdValue, _impl_.blob_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::SyncdVersion, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::SyncdVersion, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::SyncdVersion, _impl_.version_), + 0, + PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_CallButton, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_CallButton, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_CallButton, _impl_.displaytext_), + PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_CallButton, _impl_.phonenumber_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_QuickReplyButton, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_QuickReplyButton, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_QuickReplyButton, _impl_.displaytext_), + PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_QuickReplyButton, _impl_.id_), + 1, + 0, + PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_URLButton, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_URLButton, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_URLButton, _impl_.displaytext_), + PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_URLButton, _impl_.url_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::TemplateButton, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::TemplateButton, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::proto::TemplateButton, _impl_._oneof_case_[0]), + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::TemplateButton, _impl_.index_), + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::proto::TemplateButton, _impl_.button_), + 0, + ~0u, + ~0u, + ~0u, + PROTOBUF_FIELD_OFFSET(::proto::UserReceipt, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::UserReceipt, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::UserReceipt, _impl_.userjid_), + PROTOBUF_FIELD_OFFSET(::proto::UserReceipt, _impl_.receipttimestamp_), + PROTOBUF_FIELD_OFFSET(::proto::UserReceipt, _impl_.readtimestamp_), + PROTOBUF_FIELD_OFFSET(::proto::UserReceipt, _impl_.playedtimestamp_), + PROTOBUF_FIELD_OFFSET(::proto::UserReceipt, _impl_.pendingdevicejid_), + PROTOBUF_FIELD_OFFSET(::proto::UserReceipt, _impl_.delivereddevicejid_), + 0, + 1, + 2, + 3, + ~0u, + ~0u, + PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate_Details, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate_Details, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate_Details, _impl_.serial_), + PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate_Details, _impl_.issuer_), + PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate_Details, _impl_.verifiedname_), + PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate_Details, _impl_.localizednames_), + PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate_Details, _impl_.issuetime_), + 2, + 0, + 1, + ~0u, + 3, + PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate, _impl_.details_), + PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate, _impl_.signature_), + PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate, _impl_.serversignature_), + 0, + 1, + 2, + PROTOBUF_FIELD_OFFSET(::proto::WallpaperSettings, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::WallpaperSettings, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::WallpaperSettings, _impl_.filename_), + PROTOBUF_FIELD_OFFSET(::proto::WallpaperSettings, _impl_.opacity_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.labelsdisplay_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.voipindividualoutgoing_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.groupsv3_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.groupsv3create_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.changenumberv2_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.querystatusv3thumbnail_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.livelocations_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.queryvname_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.voipindividualincoming_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.quickrepliesquery_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.payments_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.stickerpackquery_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.livelocationsfinal_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.labelsedit_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.mediaupload_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.mediauploadrichquickreplies_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.vnamev2_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.videoplaybackurl_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.statusranking_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.voipindividualvideo_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.thirdpartystickers_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.frequentlyforwardedsetting_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.groupsv4joinpermission_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.recentstickers_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.catalog_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.starredstickers_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.voipgroupcall_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.templatemessage_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.templatemessageinteractivity_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.ephemeralmessages_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.e2enotificationsync_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.recentstickersv2_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.recentstickersv3_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.usernotice_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.support_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.groupuiicleanup_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.groupdogfoodinginternalonly_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.settingssync_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.archivev2_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.ephemeralallowgroupmembers_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.ephemeral24hduration_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.mdforceupgrade_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.disappearingmode_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.externalmdoptinavailable_), + PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.nodeletemessagetimelimit_), + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.key_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.message_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.messagetimestamp_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.status_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.participant_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.messagec2stimestamp_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.ignore_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.starred_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.broadcast_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.pushname_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.mediaciphertextsha256_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.multicast_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.urltext_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.urlnumber_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.messagestubtype_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.clearmedia_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.messagestubparameters_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.duration_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.labels_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.paymentinfo_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.finallivelocation_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.quotedpaymentinfo_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.ephemeralstarttimestamp_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.ephemeralduration_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.ephemeralofftoon_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.ephemeraloutofsync_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.bizprivacystatus_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.verifiedbizname_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.mediadata_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.photochange_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.userreceipt_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.reactions_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.quotedstickerdata_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.futureproofdata_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.statuspsa_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.pollupdates_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.polladditionalmetadata_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.agentid_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.statusalreadyviewed_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.messagesecret_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.keepinchat_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.originalselfauthoruserjidstring_), + PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.revokemessagetimestamp_), + 8, + 9, + 19, + 21, + 0, + 20, + 22, + 23, + 24, + 1, + 2, + 25, + 27, + 28, + 26, + 29, + ~0u, + 31, + ~0u, + 10, + 11, + 12, + 33, + 32, + 30, + 35, + 34, + 3, + 13, + 14, + ~0u, + ~0u, + 15, + 4, + 16, + ~0u, + 17, + 5, + 36, + 6, + 18, + 7, + 37, + PROTOBUF_FIELD_OFFSET(::proto::WebNotificationsInfo, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::proto::WebNotificationsInfo, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::proto::WebNotificationsInfo, _impl_.timestamp_), + PROTOBUF_FIELD_OFFSET(::proto::WebNotificationsInfo, _impl_.unreadchats_), + PROTOBUF_FIELD_OFFSET(::proto::WebNotificationsInfo, _impl_.notifymessagecount_), + PROTOBUF_FIELD_OFFSET(::proto::WebNotificationsInfo, _impl_.notifymessages_), + 0, + 1, + 2, + ~0u, +}; +static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + { 0, 9, -1, sizeof(::proto::ADVDeviceIdentity)}, + { 12, 22, -1, sizeof(::proto::ADVKeyIndexList)}, + { 26, 36, -1, sizeof(::proto::ADVSignedDeviceIdentity)}, + { 40, 48, -1, sizeof(::proto::ADVSignedDeviceIdentityHMAC)}, + { 50, 58, -1, sizeof(::proto::ADVSignedKeyIndexList)}, + { 60, 68, -1, sizeof(::proto::ActionLink)}, + { 70, 80, -1, sizeof(::proto::AutoDownloadSettings)}, + { 84, 95, -1, sizeof(::proto::BizAccountLinkInfo)}, + { 100, 108, -1, sizeof(::proto::BizAccountPayload)}, + { 110, 124, -1, sizeof(::proto::BizIdentityInfo)}, + { 132, 143, -1, sizeof(::proto::CertChain_NoiseCertificate_Details)}, + { 148, 156, -1, sizeof(::proto::CertChain_NoiseCertificate)}, + { 158, 166, -1, sizeof(::proto::CertChain)}, + { 168, 178, -1, sizeof(::proto::Chain)}, + { 182, 190, -1, sizeof(::proto::ChainKey)}, + { 192, 200, -1, sizeof(::proto::ClientPayload_DNSSource)}, + { 202, 216, -1, sizeof(::proto::ClientPayload_DevicePairingRegistrationData)}, + { 224, 235, -1, sizeof(::proto::ClientPayload_UserAgent_AppVersion)}, + { 240, 259, -1, sizeof(::proto::ClientPayload_UserAgent)}, + { 272, 289, -1, sizeof(::proto::ClientPayload_WebInfo_WebdPayload)}, + { 300, 310, -1, sizeof(::proto::ClientPayload_WebInfo)}, + { 314, 344, -1, sizeof(::proto::ClientPayload)}, + { 368, 378, -1, sizeof(::proto::ContextInfo_AdReplyInfo)}, + { 382, 400, -1, sizeof(::proto::ContextInfo_ExternalAdReplyInfo)}, + { 412, 441, -1, sizeof(::proto::ContextInfo)}, + { 464, 510, -1, sizeof(::proto::Conversation)}, + { 550, 562, -1, sizeof(::proto::DeviceListMetadata)}, + { 568, 579, -1, sizeof(::proto::DeviceProps_AppVersion)}, + { 584, 594, -1, sizeof(::proto::DeviceProps)}, + { 598, 605, -1, sizeof(::proto::DisappearingMode)}, + { 606, 614, -1, sizeof(::proto::EphemeralSetting)}, + { 616, 624, -1, sizeof(::proto::ExitCode)}, + { 626, 638, -1, sizeof(::proto::ExternalBlobReference)}, + { 644, 660, -1, sizeof(::proto::GlobalSettings)}, + { 670, 678, -1, sizeof(::proto::GroupParticipant)}, + { 680, 688, -1, sizeof(::proto::HandshakeMessage_ClientFinish)}, + { 690, 699, -1, sizeof(::proto::HandshakeMessage_ClientHello)}, + { 702, 711, -1, sizeof(::proto::HandshakeMessage_ServerHello)}, + { 714, 723, -1, sizeof(::proto::HandshakeMessage)}, + { 726, 743, -1, sizeof(::proto::HistorySync)}, + { 754, 762, -1, sizeof(::proto::HistorySyncMsg)}, + { 764, 772, -1, sizeof(::proto::HydratedTemplateButton_HydratedCallButton)}, + { 774, 782, -1, sizeof(::proto::HydratedTemplateButton_HydratedQuickReplyButton)}, + { 784, 792, -1, sizeof(::proto::HydratedTemplateButton_HydratedURLButton)}, + { 794, 805, -1, sizeof(::proto::HydratedTemplateButton)}, + { 809, 817, -1, sizeof(::proto::IdentityKeyPairStructure)}, + { 819, -1, -1, sizeof(::proto::InteractiveAnnotation)}, + { 828, 838, -1, sizeof(::proto::KeepInChat)}, + { 842, 849, -1, sizeof(::proto::KeyId)}, + { 850, 859, -1, sizeof(::proto::LocalizedName)}, + { 862, 871, -1, sizeof(::proto::Location)}, + { 874, 881, -1, sizeof(::proto::MediaData)}, + { 882, 891, -1, sizeof(::proto::MediaRetryNotification)}, + { 894, 902, -1, sizeof(::proto::Message_AppStateFatalExceptionNotification)}, + { 904, 913, -1, sizeof(::proto::Message_AppStateSyncKeyData)}, + { 916, 925, -1, sizeof(::proto::Message_AppStateSyncKeyFingerprint)}, + { 928, 935, -1, sizeof(::proto::Message_AppStateSyncKeyId)}, + { 936, -1, -1, sizeof(::proto::Message_AppStateSyncKeyRequest)}, + { 943, -1, -1, sizeof(::proto::Message_AppStateSyncKeyShare)}, + { 950, 958, -1, sizeof(::proto::Message_AppStateSyncKey)}, + { 960, 979, -1, sizeof(::proto::Message_AudioMessage)}, + { 992, 999, -1, sizeof(::proto::Message_ButtonsMessage_Button_ButtonText)}, + { 1000, 1008, -1, sizeof(::proto::Message_ButtonsMessage_Button_NativeFlowInfo)}, + { 1010, 1020, -1, sizeof(::proto::Message_ButtonsMessage_Button)}, + { 1024, 1041, -1, sizeof(::proto::Message_ButtonsMessage)}, + { 1051, 1062, -1, sizeof(::proto::Message_ButtonsResponseMessage)}, + { 1066, 1076, -1, sizeof(::proto::Message_Call)}, + { 1080, 1087, -1, sizeof(::proto::Message_CancelPaymentRequestMessage)}, + { 1088, 1096, -1, sizeof(::proto::Message_Chat)}, + { 1098, 1107, -1, sizeof(::proto::Message_ContactMessage)}, + { 1110, 1119, -1, sizeof(::proto::Message_ContactsArrayMessage)}, + { 1122, 1129, -1, sizeof(::proto::Message_DeclinePaymentRequestMessage)}, + { 1130, 1139, -1, sizeof(::proto::Message_DeviceSentMessage)}, + { 1142, 1168, -1, sizeof(::proto::Message_DocumentMessage)}, + { 1188, 1217, -1, sizeof(::proto::Message_ExtendedTextMessage)}, + { 1240, 1247, -1, sizeof(::proto::Message_FutureProofMessage)}, + { 1248, 1262, -1, sizeof(::proto::Message_GroupInviteMessage)}, + { 1270, 1278, -1, sizeof(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency)}, + { 1280, 1293, -1, sizeof(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent)}, + { 1300, 1307, -1, sizeof(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch)}, + { 1308, -1, -1, sizeof(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime)}, + { 1317, 1327, -1, sizeof(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter)}, + { 1330, 1345, -1, sizeof(::proto::Message_HighlyStructuredMessage)}, + { 1354, 1369, -1, sizeof(::proto::Message_HistorySyncNotification)}, + { 1378, 1410, -1, sizeof(::proto::Message_ImageMessage)}, + { 1436, 1443, -1, sizeof(::proto::Message_InitialSecurityNotificationSettingSync)}, + { 1444, 1451, -1, sizeof(::proto::Message_InteractiveMessage_Body)}, + { 1452, 1461, -1, sizeof(::proto::Message_InteractiveMessage_CollectionMessage)}, + { 1464, 1471, -1, sizeof(::proto::Message_InteractiveMessage_Footer)}, + { 1472, 1486, -1, sizeof(::proto::Message_InteractiveMessage_Header)}, + { 1493, 1501, -1, sizeof(::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton)}, + { 1503, 1512, -1, sizeof(::proto::Message_InteractiveMessage_NativeFlowMessage)}, + { 1515, 1524, -1, sizeof(::proto::Message_InteractiveMessage_ShopMessage)}, + { 1527, 1541, -1, sizeof(::proto::Message_InteractiveMessage)}, + { 1548, 1555, -1, sizeof(::proto::Message_InteractiveResponseMessage_Body)}, + { 1556, 1565, -1, sizeof(::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage)}, + { 1568, 1578, -1, sizeof(::proto::Message_InteractiveResponseMessage)}, + { 1581, 1597, -1, sizeof(::proto::Message_InvoiceMessage)}, + { 1607, 1616, -1, sizeof(::proto::Message_KeepInChatMessage)}, + { 1619, 1627, -1, sizeof(::proto::Message_ListMessage_ProductListHeaderImage)}, + { 1629, 1638, -1, sizeof(::proto::Message_ListMessage_ProductListInfo)}, + { 1641, 1649, -1, sizeof(::proto::Message_ListMessage_ProductSection)}, + { 1651, 1658, -1, sizeof(::proto::Message_ListMessage_Product)}, + { 1659, 1668, -1, sizeof(::proto::Message_ListMessage_Row)}, + { 1671, 1679, -1, sizeof(::proto::Message_ListMessage_Section)}, + { 1681, 1695, -1, sizeof(::proto::Message_ListMessage)}, + { 1703, 1710, -1, sizeof(::proto::Message_ListResponseMessage_SingleSelectReply)}, + { 1711, 1722, -1, sizeof(::proto::Message_ListResponseMessage)}, + { 1727, 1743, -1, sizeof(::proto::Message_LiveLocationMessage)}, + { 1753, 1771, -1, sizeof(::proto::Message_LocationMessage)}, + { 1783, 1801, -1, sizeof(::proto::Message_OrderMessage)}, + { 1813, 1821, -1, sizeof(::proto::Message_PaymentInviteMessage)}, + { 1823, 1830, -1, sizeof(::proto::Message_PollCreationMessage_Option)}, + { 1831, 1842, -1, sizeof(::proto::Message_PollCreationMessage)}, + { 1847, 1855, -1, sizeof(::proto::Message_PollEncValue)}, + { 1857, -1, -1, sizeof(::proto::Message_PollUpdateMessageMetadata)}, + { 1863, 1873, -1, sizeof(::proto::Message_PollUpdateMessage)}, + { 1877, -1, -1, sizeof(::proto::Message_PollVoteMessage)}, + { 1884, 1893, -1, sizeof(::proto::Message_ProductMessage_CatalogSnapshot)}, + { 1896, 1913, -1, sizeof(::proto::Message_ProductMessage_ProductSnapshot)}, + { 1924, 1936, -1, sizeof(::proto::Message_ProductMessage)}, + { 1942, 1960, -1, sizeof(::proto::Message_ProtocolMessage)}, + { 1972, 1982, -1, sizeof(::proto::Message_ReactionMessage)}, + { 1986, 1994, -1, sizeof(::proto::Message_RequestMediaUploadMessage)}, + { 1996, 2005, -1, sizeof(::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult)}, + { 2008, 2017, -1, sizeof(::proto::Message_RequestMediaUploadResponseMessage)}, + { 2020, 2033, -1, sizeof(::proto::Message_RequestPaymentMessage)}, + { 2040, 2047, -1, sizeof(::proto::Message_RequestPhoneNumberMessage)}, + { 2048, 2057, -1, sizeof(::proto::Message_SendPaymentMessage)}, + { 2060, 2068, -1, sizeof(::proto::Message_SenderKeyDistributionMessage)}, + { 2070, 2091, -1, sizeof(::proto::Message_StickerMessage)}, + { 2106, 2115, -1, sizeof(::proto::Message_StickerSyncRMRMessage)}, + { 2118, 2128, -1, sizeof(::proto::Message_TemplateButtonReplyMessage)}, + { 2132, 2147, -1, sizeof(::proto::Message_TemplateMessage_FourRowTemplate)}, + { 2155, 2171, -1, sizeof(::proto::Message_TemplateMessage_HydratedFourRowTemplate)}, + { 2180, 2191, -1, sizeof(::proto::Message_TemplateMessage)}, + { 2195, 2224, -1, sizeof(::proto::Message_VideoMessage)}, + { 2247, 2299, -1, sizeof(::proto::Message)}, + { 2345, 2355, -1, sizeof(::proto::MessageContextInfo)}, + { 2359, 2369, -1, sizeof(::proto::MessageKey)}, + { 2373, 2382, -1, sizeof(::proto::Money)}, + { 2385, 2392, -1, sizeof(::proto::MsgOpaqueData_PollOption)}, + { 2393, 2420, -1, sizeof(::proto::MsgOpaqueData)}, + { 2441, 2449, -1, sizeof(::proto::MsgRowOpaqueData)}, + { 2451, 2462, -1, sizeof(::proto::NoiseCertificate_Details)}, + { 2467, 2475, -1, sizeof(::proto::NoiseCertificate)}, + { 2477, 2487, -1, sizeof(::proto::NotificationMessageInfo)}, + { 2491, 2500, -1, sizeof(::proto::PastParticipant)}, + { 2503, 2511, -1, sizeof(::proto::PastParticipants)}, + { 2513, 2524, -1, sizeof(::proto::PaymentBackground_MediaData)}, + { 2529, 2545, -1, sizeof(::proto::PaymentBackground)}, + { 2555, 2574, -1, sizeof(::proto::PaymentInfo)}, + { 2587, 2600, -1, sizeof(::proto::PendingKeyExchange)}, + { 2607, 2616, -1, sizeof(::proto::PendingPreKey)}, + { 2619, 2628, -1, sizeof(::proto::PhotoChange)}, + { 2631, 2641, -1, sizeof(::proto::Point)}, + { 2645, 2652, -1, sizeof(::proto::PollAdditionalMetadata)}, + { 2653, 2661, -1, sizeof(::proto::PollEncValue)}, + { 2663, 2672, -1, sizeof(::proto::PollUpdate)}, + { 2675, 2684, -1, sizeof(::proto::PreKeyRecordStructure)}, + { 2687, 2695, -1, sizeof(::proto::Pushname)}, + { 2697, 2708, -1, sizeof(::proto::Reaction)}, + { 2713, 2721, -1, sizeof(::proto::RecentEmojiWeight)}, + { 2723, 2731, -1, sizeof(::proto::RecordStructure)}, + { 2733, 2741, -1, sizeof(::proto::SenderChainKey)}, + { 2743, -1, -1, sizeof(::proto::SenderKeyRecordStructure)}, + { 2750, 2760, -1, sizeof(::proto::SenderKeyStateStructure)}, + { 2764, 2772, -1, sizeof(::proto::SenderMessageKey)}, + { 2774, 2782, -1, sizeof(::proto::SenderSigningKey)}, + { 2784, 2791, -1, sizeof(::proto::ServerErrorReceipt)}, + { 2792, 2811, -1, sizeof(::proto::SessionStructure)}, + { 2824, 2835, -1, sizeof(::proto::SignedPreKeyRecordStructure)}, + { 2840, 2848, -1, sizeof(::proto::StatusPSA)}, + { 2850, 2866, -1, sizeof(::proto::StickerMetadata)}, + { 2876, 2886, -1, sizeof(::proto::SyncActionData)}, + { 2890, 2899, -1, sizeof(::proto::SyncActionValue_AgentAction)}, + { 2902, 2909, -1, sizeof(::proto::SyncActionValue_AndroidUnsupportedActions)}, + { 2910, 2918, -1, sizeof(::proto::SyncActionValue_ArchiveChatAction)}, + { 2920, 2927, -1, sizeof(::proto::SyncActionValue_ClearChatAction)}, + { 2928, 2936, -1, sizeof(::proto::SyncActionValue_ContactAction)}, + { 2938, 2945, -1, sizeof(::proto::SyncActionValue_DeleteChatAction)}, + { 2946, 2954, -1, sizeof(::proto::SyncActionValue_DeleteMessageForMeAction)}, + { 2956, 2963, -1, sizeof(::proto::SyncActionValue_KeyExpiration)}, + { 2964, 2971, -1, sizeof(::proto::SyncActionValue_LabelAssociationAction)}, + { 2972, 2982, -1, sizeof(::proto::SyncActionValue_LabelEditAction)}, + { 2986, 2993, -1, sizeof(::proto::SyncActionValue_LocaleSetting)}, + { 2994, 3002, -1, sizeof(::proto::SyncActionValue_MarkChatAsReadAction)}, + { 3004, 3012, -1, sizeof(::proto::SyncActionValue_MuteAction)}, + { 3014, 3021, -1, sizeof(::proto::SyncActionValue_NuxAction)}, + { 3022, 3029, -1, sizeof(::proto::SyncActionValue_PinAction)}, + { 3030, -1, -1, sizeof(::proto::SyncActionValue_PrimaryFeature)}, + { 3037, 3044, -1, sizeof(::proto::SyncActionValue_PrimaryVersionAction)}, + { 3045, 3052, -1, sizeof(::proto::SyncActionValue_PushNameSetting)}, + { 3053, 3064, -1, sizeof(::proto::SyncActionValue_QuickReplyAction)}, + { 3069, -1, -1, sizeof(::proto::SyncActionValue_RecentEmojiWeightsAction)}, + { 3076, 3083, -1, sizeof(::proto::SyncActionValue_SecurityNotificationSetting)}, + { 3084, 3091, -1, sizeof(::proto::SyncActionValue_StarAction)}, + { 3092, 3108, -1, sizeof(::proto::SyncActionValue_StickerAction)}, + { 3118, 3127, -1, sizeof(::proto::SyncActionValue_SubscriptionAction)}, + { 3130, 3139, -1, sizeof(::proto::SyncActionValue_SyncActionMessageRange)}, + { 3142, 3150, -1, sizeof(::proto::SyncActionValue_SyncActionMessage)}, + { 3152, 3159, -1, sizeof(::proto::SyncActionValue_TimeFormatAction)}, + { 3160, 3167, -1, sizeof(::proto::SyncActionValue_UnarchiveChatsSetting)}, + { 3168, 3175, -1, sizeof(::proto::SyncActionValue_UserStatusMuteAction)}, + { 3176, 3210, -1, sizeof(::proto::SyncActionValue)}, + { 3238, 3245, -1, sizeof(::proto::SyncdIndex)}, + { 3246, 3254, -1, sizeof(::proto::SyncdMutation)}, + { 3256, -1, -1, sizeof(::proto::SyncdMutations)}, + { 3263, 3277, -1, sizeof(::proto::SyncdPatch)}, + { 3285, 3294, -1, sizeof(::proto::SyncdRecord)}, + { 3297, 3307, -1, sizeof(::proto::SyncdSnapshot)}, + { 3311, 3318, -1, sizeof(::proto::SyncdValue)}, + { 3319, 3326, -1, sizeof(::proto::SyncdVersion)}, + { 3327, 3335, -1, sizeof(::proto::TemplateButton_CallButton)}, + { 3337, 3345, -1, sizeof(::proto::TemplateButton_QuickReplyButton)}, + { 3347, 3355, -1, sizeof(::proto::TemplateButton_URLButton)}, + { 3357, 3368, -1, sizeof(::proto::TemplateButton)}, + { 3372, 3384, -1, sizeof(::proto::UserReceipt)}, + { 3390, 3401, -1, sizeof(::proto::VerifiedNameCertificate_Details)}, + { 3406, 3415, -1, sizeof(::proto::VerifiedNameCertificate)}, + { 3418, 3426, -1, sizeof(::proto::WallpaperSettings)}, + { 3428, 3479, -1, sizeof(::proto::WebFeatures)}, + { 3524, 3573, -1, sizeof(::proto::WebMessageInfo)}, + { 3616, 3626, -1, sizeof(::proto::WebNotificationsInfo)}, +}; + +static const ::_pb::Message* const file_default_instances[] = { + &::proto::_ADVDeviceIdentity_default_instance_._instance, + &::proto::_ADVKeyIndexList_default_instance_._instance, + &::proto::_ADVSignedDeviceIdentity_default_instance_._instance, + &::proto::_ADVSignedDeviceIdentityHMAC_default_instance_._instance, + &::proto::_ADVSignedKeyIndexList_default_instance_._instance, + &::proto::_ActionLink_default_instance_._instance, + &::proto::_AutoDownloadSettings_default_instance_._instance, + &::proto::_BizAccountLinkInfo_default_instance_._instance, + &::proto::_BizAccountPayload_default_instance_._instance, + &::proto::_BizIdentityInfo_default_instance_._instance, + &::proto::_CertChain_NoiseCertificate_Details_default_instance_._instance, + &::proto::_CertChain_NoiseCertificate_default_instance_._instance, + &::proto::_CertChain_default_instance_._instance, + &::proto::_Chain_default_instance_._instance, + &::proto::_ChainKey_default_instance_._instance, + &::proto::_ClientPayload_DNSSource_default_instance_._instance, + &::proto::_ClientPayload_DevicePairingRegistrationData_default_instance_._instance, + &::proto::_ClientPayload_UserAgent_AppVersion_default_instance_._instance, + &::proto::_ClientPayload_UserAgent_default_instance_._instance, + &::proto::_ClientPayload_WebInfo_WebdPayload_default_instance_._instance, + &::proto::_ClientPayload_WebInfo_default_instance_._instance, + &::proto::_ClientPayload_default_instance_._instance, + &::proto::_ContextInfo_AdReplyInfo_default_instance_._instance, + &::proto::_ContextInfo_ExternalAdReplyInfo_default_instance_._instance, + &::proto::_ContextInfo_default_instance_._instance, + &::proto::_Conversation_default_instance_._instance, + &::proto::_DeviceListMetadata_default_instance_._instance, + &::proto::_DeviceProps_AppVersion_default_instance_._instance, + &::proto::_DeviceProps_default_instance_._instance, + &::proto::_DisappearingMode_default_instance_._instance, + &::proto::_EphemeralSetting_default_instance_._instance, + &::proto::_ExitCode_default_instance_._instance, + &::proto::_ExternalBlobReference_default_instance_._instance, + &::proto::_GlobalSettings_default_instance_._instance, + &::proto::_GroupParticipant_default_instance_._instance, + &::proto::_HandshakeMessage_ClientFinish_default_instance_._instance, + &::proto::_HandshakeMessage_ClientHello_default_instance_._instance, + &::proto::_HandshakeMessage_ServerHello_default_instance_._instance, + &::proto::_HandshakeMessage_default_instance_._instance, + &::proto::_HistorySync_default_instance_._instance, + &::proto::_HistorySyncMsg_default_instance_._instance, + &::proto::_HydratedTemplateButton_HydratedCallButton_default_instance_._instance, + &::proto::_HydratedTemplateButton_HydratedQuickReplyButton_default_instance_._instance, + &::proto::_HydratedTemplateButton_HydratedURLButton_default_instance_._instance, + &::proto::_HydratedTemplateButton_default_instance_._instance, + &::proto::_IdentityKeyPairStructure_default_instance_._instance, + &::proto::_InteractiveAnnotation_default_instance_._instance, + &::proto::_KeepInChat_default_instance_._instance, + &::proto::_KeyId_default_instance_._instance, + &::proto::_LocalizedName_default_instance_._instance, + &::proto::_Location_default_instance_._instance, + &::proto::_MediaData_default_instance_._instance, + &::proto::_MediaRetryNotification_default_instance_._instance, + &::proto::_Message_AppStateFatalExceptionNotification_default_instance_._instance, + &::proto::_Message_AppStateSyncKeyData_default_instance_._instance, + &::proto::_Message_AppStateSyncKeyFingerprint_default_instance_._instance, + &::proto::_Message_AppStateSyncKeyId_default_instance_._instance, + &::proto::_Message_AppStateSyncKeyRequest_default_instance_._instance, + &::proto::_Message_AppStateSyncKeyShare_default_instance_._instance, + &::proto::_Message_AppStateSyncKey_default_instance_._instance, + &::proto::_Message_AudioMessage_default_instance_._instance, + &::proto::_Message_ButtonsMessage_Button_ButtonText_default_instance_._instance, + &::proto::_Message_ButtonsMessage_Button_NativeFlowInfo_default_instance_._instance, + &::proto::_Message_ButtonsMessage_Button_default_instance_._instance, + &::proto::_Message_ButtonsMessage_default_instance_._instance, + &::proto::_Message_ButtonsResponseMessage_default_instance_._instance, + &::proto::_Message_Call_default_instance_._instance, + &::proto::_Message_CancelPaymentRequestMessage_default_instance_._instance, + &::proto::_Message_Chat_default_instance_._instance, + &::proto::_Message_ContactMessage_default_instance_._instance, + &::proto::_Message_ContactsArrayMessage_default_instance_._instance, + &::proto::_Message_DeclinePaymentRequestMessage_default_instance_._instance, + &::proto::_Message_DeviceSentMessage_default_instance_._instance, + &::proto::_Message_DocumentMessage_default_instance_._instance, + &::proto::_Message_ExtendedTextMessage_default_instance_._instance, + &::proto::_Message_FutureProofMessage_default_instance_._instance, + &::proto::_Message_GroupInviteMessage_default_instance_._instance, + &::proto::_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency_default_instance_._instance, + &::proto::_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_default_instance_._instance, + &::proto::_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch_default_instance_._instance, + &::proto::_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_default_instance_._instance, + &::proto::_Message_HighlyStructuredMessage_HSMLocalizableParameter_default_instance_._instance, + &::proto::_Message_HighlyStructuredMessage_default_instance_._instance, + &::proto::_Message_HistorySyncNotification_default_instance_._instance, + &::proto::_Message_ImageMessage_default_instance_._instance, + &::proto::_Message_InitialSecurityNotificationSettingSync_default_instance_._instance, + &::proto::_Message_InteractiveMessage_Body_default_instance_._instance, + &::proto::_Message_InteractiveMessage_CollectionMessage_default_instance_._instance, + &::proto::_Message_InteractiveMessage_Footer_default_instance_._instance, + &::proto::_Message_InteractiveMessage_Header_default_instance_._instance, + &::proto::_Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton_default_instance_._instance, + &::proto::_Message_InteractiveMessage_NativeFlowMessage_default_instance_._instance, + &::proto::_Message_InteractiveMessage_ShopMessage_default_instance_._instance, + &::proto::_Message_InteractiveMessage_default_instance_._instance, + &::proto::_Message_InteractiveResponseMessage_Body_default_instance_._instance, + &::proto::_Message_InteractiveResponseMessage_NativeFlowResponseMessage_default_instance_._instance, + &::proto::_Message_InteractiveResponseMessage_default_instance_._instance, + &::proto::_Message_InvoiceMessage_default_instance_._instance, + &::proto::_Message_KeepInChatMessage_default_instance_._instance, + &::proto::_Message_ListMessage_ProductListHeaderImage_default_instance_._instance, + &::proto::_Message_ListMessage_ProductListInfo_default_instance_._instance, + &::proto::_Message_ListMessage_ProductSection_default_instance_._instance, + &::proto::_Message_ListMessage_Product_default_instance_._instance, + &::proto::_Message_ListMessage_Row_default_instance_._instance, + &::proto::_Message_ListMessage_Section_default_instance_._instance, + &::proto::_Message_ListMessage_default_instance_._instance, + &::proto::_Message_ListResponseMessage_SingleSelectReply_default_instance_._instance, + &::proto::_Message_ListResponseMessage_default_instance_._instance, + &::proto::_Message_LiveLocationMessage_default_instance_._instance, + &::proto::_Message_LocationMessage_default_instance_._instance, + &::proto::_Message_OrderMessage_default_instance_._instance, + &::proto::_Message_PaymentInviteMessage_default_instance_._instance, + &::proto::_Message_PollCreationMessage_Option_default_instance_._instance, + &::proto::_Message_PollCreationMessage_default_instance_._instance, + &::proto::_Message_PollEncValue_default_instance_._instance, + &::proto::_Message_PollUpdateMessageMetadata_default_instance_._instance, + &::proto::_Message_PollUpdateMessage_default_instance_._instance, + &::proto::_Message_PollVoteMessage_default_instance_._instance, + &::proto::_Message_ProductMessage_CatalogSnapshot_default_instance_._instance, + &::proto::_Message_ProductMessage_ProductSnapshot_default_instance_._instance, + &::proto::_Message_ProductMessage_default_instance_._instance, + &::proto::_Message_ProtocolMessage_default_instance_._instance, + &::proto::_Message_ReactionMessage_default_instance_._instance, + &::proto::_Message_RequestMediaUploadMessage_default_instance_._instance, + &::proto::_Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult_default_instance_._instance, + &::proto::_Message_RequestMediaUploadResponseMessage_default_instance_._instance, + &::proto::_Message_RequestPaymentMessage_default_instance_._instance, + &::proto::_Message_RequestPhoneNumberMessage_default_instance_._instance, + &::proto::_Message_SendPaymentMessage_default_instance_._instance, + &::proto::_Message_SenderKeyDistributionMessage_default_instance_._instance, + &::proto::_Message_StickerMessage_default_instance_._instance, + &::proto::_Message_StickerSyncRMRMessage_default_instance_._instance, + &::proto::_Message_TemplateButtonReplyMessage_default_instance_._instance, + &::proto::_Message_TemplateMessage_FourRowTemplate_default_instance_._instance, + &::proto::_Message_TemplateMessage_HydratedFourRowTemplate_default_instance_._instance, + &::proto::_Message_TemplateMessage_default_instance_._instance, + &::proto::_Message_VideoMessage_default_instance_._instance, + &::proto::_Message_default_instance_._instance, + &::proto::_MessageContextInfo_default_instance_._instance, + &::proto::_MessageKey_default_instance_._instance, + &::proto::_Money_default_instance_._instance, + &::proto::_MsgOpaqueData_PollOption_default_instance_._instance, + &::proto::_MsgOpaqueData_default_instance_._instance, + &::proto::_MsgRowOpaqueData_default_instance_._instance, + &::proto::_NoiseCertificate_Details_default_instance_._instance, + &::proto::_NoiseCertificate_default_instance_._instance, + &::proto::_NotificationMessageInfo_default_instance_._instance, + &::proto::_PastParticipant_default_instance_._instance, + &::proto::_PastParticipants_default_instance_._instance, + &::proto::_PaymentBackground_MediaData_default_instance_._instance, + &::proto::_PaymentBackground_default_instance_._instance, + &::proto::_PaymentInfo_default_instance_._instance, + &::proto::_PendingKeyExchange_default_instance_._instance, + &::proto::_PendingPreKey_default_instance_._instance, + &::proto::_PhotoChange_default_instance_._instance, + &::proto::_Point_default_instance_._instance, + &::proto::_PollAdditionalMetadata_default_instance_._instance, + &::proto::_PollEncValue_default_instance_._instance, + &::proto::_PollUpdate_default_instance_._instance, + &::proto::_PreKeyRecordStructure_default_instance_._instance, + &::proto::_Pushname_default_instance_._instance, + &::proto::_Reaction_default_instance_._instance, + &::proto::_RecentEmojiWeight_default_instance_._instance, + &::proto::_RecordStructure_default_instance_._instance, + &::proto::_SenderChainKey_default_instance_._instance, + &::proto::_SenderKeyRecordStructure_default_instance_._instance, + &::proto::_SenderKeyStateStructure_default_instance_._instance, + &::proto::_SenderMessageKey_default_instance_._instance, + &::proto::_SenderSigningKey_default_instance_._instance, + &::proto::_ServerErrorReceipt_default_instance_._instance, + &::proto::_SessionStructure_default_instance_._instance, + &::proto::_SignedPreKeyRecordStructure_default_instance_._instance, + &::proto::_StatusPSA_default_instance_._instance, + &::proto::_StickerMetadata_default_instance_._instance, + &::proto::_SyncActionData_default_instance_._instance, + &::proto::_SyncActionValue_AgentAction_default_instance_._instance, + &::proto::_SyncActionValue_AndroidUnsupportedActions_default_instance_._instance, + &::proto::_SyncActionValue_ArchiveChatAction_default_instance_._instance, + &::proto::_SyncActionValue_ClearChatAction_default_instance_._instance, + &::proto::_SyncActionValue_ContactAction_default_instance_._instance, + &::proto::_SyncActionValue_DeleteChatAction_default_instance_._instance, + &::proto::_SyncActionValue_DeleteMessageForMeAction_default_instance_._instance, + &::proto::_SyncActionValue_KeyExpiration_default_instance_._instance, + &::proto::_SyncActionValue_LabelAssociationAction_default_instance_._instance, + &::proto::_SyncActionValue_LabelEditAction_default_instance_._instance, + &::proto::_SyncActionValue_LocaleSetting_default_instance_._instance, + &::proto::_SyncActionValue_MarkChatAsReadAction_default_instance_._instance, + &::proto::_SyncActionValue_MuteAction_default_instance_._instance, + &::proto::_SyncActionValue_NuxAction_default_instance_._instance, + &::proto::_SyncActionValue_PinAction_default_instance_._instance, + &::proto::_SyncActionValue_PrimaryFeature_default_instance_._instance, + &::proto::_SyncActionValue_PrimaryVersionAction_default_instance_._instance, + &::proto::_SyncActionValue_PushNameSetting_default_instance_._instance, + &::proto::_SyncActionValue_QuickReplyAction_default_instance_._instance, + &::proto::_SyncActionValue_RecentEmojiWeightsAction_default_instance_._instance, + &::proto::_SyncActionValue_SecurityNotificationSetting_default_instance_._instance, + &::proto::_SyncActionValue_StarAction_default_instance_._instance, + &::proto::_SyncActionValue_StickerAction_default_instance_._instance, + &::proto::_SyncActionValue_SubscriptionAction_default_instance_._instance, + &::proto::_SyncActionValue_SyncActionMessageRange_default_instance_._instance, + &::proto::_SyncActionValue_SyncActionMessage_default_instance_._instance, + &::proto::_SyncActionValue_TimeFormatAction_default_instance_._instance, + &::proto::_SyncActionValue_UnarchiveChatsSetting_default_instance_._instance, + &::proto::_SyncActionValue_UserStatusMuteAction_default_instance_._instance, + &::proto::_SyncActionValue_default_instance_._instance, + &::proto::_SyncdIndex_default_instance_._instance, + &::proto::_SyncdMutation_default_instance_._instance, + &::proto::_SyncdMutations_default_instance_._instance, + &::proto::_SyncdPatch_default_instance_._instance, + &::proto::_SyncdRecord_default_instance_._instance, + &::proto::_SyncdSnapshot_default_instance_._instance, + &::proto::_SyncdValue_default_instance_._instance, + &::proto::_SyncdVersion_default_instance_._instance, + &::proto::_TemplateButton_CallButton_default_instance_._instance, + &::proto::_TemplateButton_QuickReplyButton_default_instance_._instance, + &::proto::_TemplateButton_URLButton_default_instance_._instance, + &::proto::_TemplateButton_default_instance_._instance, + &::proto::_UserReceipt_default_instance_._instance, + &::proto::_VerifiedNameCertificate_Details_default_instance_._instance, + &::proto::_VerifiedNameCertificate_default_instance_._instance, + &::proto::_WallpaperSettings_default_instance_._instance, + &::proto::_WebFeatures_default_instance_._instance, + &::proto::_WebMessageInfo_default_instance_._instance, + &::proto::_WebNotificationsInfo_default_instance_._instance, +}; + +const char descriptor_table_protodef_pmsg_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n\npmsg.proto\022\005proto\"G\n\021ADVDeviceIdentity" + "\022\r\n\005rawId\030\001 \001(\r\022\021\n\ttimestamp\030\002 \001(\004\022\020\n\010ke" + "yIndex\030\003 \001(\r\"c\n\017ADVKeyIndexList\022\r\n\005rawId" + "\030\001 \001(\r\022\021\n\ttimestamp\030\002 \001(\004\022\024\n\014currentInde" + "x\030\003 \001(\r\022\030\n\014validIndexes\030\004 \003(\rB\002\020\001\"z\n\027ADV" + "SignedDeviceIdentity\022\017\n\007details\030\001 \001(\014\022\033\n" + "\023accountSignatureKey\030\002 \001(\014\022\030\n\020accountSig" + "nature\030\003 \001(\014\022\027\n\017deviceSignature\030\004 \001(\014\"<\n" + "\033ADVSignedDeviceIdentityHMAC\022\017\n\007details\030" + "\001 \001(\014\022\014\n\004hmac\030\002 \001(\014\"B\n\025ADVSignedKeyIndex" + "List\022\017\n\007details\030\001 \001(\014\022\030\n\020accountSignatur" + "e\030\002 \001(\014\".\n\nActionLink\022\013\n\003url\030\001 \001(\t\022\023\n\013bu" + "ttonTitle\030\002 \001(\t\"w\n\024AutoDownloadSettings\022" + "\026\n\016downloadImages\030\001 \001(\010\022\025\n\rdownloadAudio" + "\030\002 \001(\010\022\025\n\rdownloadVideo\030\003 \001(\010\022\031\n\021downloa" + "dDocuments\030\004 \001(\010\"\254\002\n\022BizAccountLinkInfo\022" + "\033\n\023whatsappBizAcctFbid\030\001 \001(\004\022\032\n\022whatsapp" + "AcctNumber\030\002 \001(\t\022\021\n\tissueTime\030\003 \001(\004\022>\n\013h" + "ostStorage\030\004 \001(\0162).proto.BizAccountLinkI" + "nfo.HostStorageType\022:\n\013accountType\030\005 \001(\016" + "2%.proto.BizAccountLinkInfo.AccountType\"" + "\035\n\013AccountType\022\016\n\nENTERPRISE\020\000\"/\n\017HostSt" + "orageType\022\016\n\nON_PREMISE\020\000\022\014\n\010FACEBOOK\020\001\"" + "_\n\021BizAccountPayload\0221\n\tvnameCert\030\001 \001(\0132" + "\036.proto.VerifiedNameCertificate\022\027\n\017bizAc" + "ctLinkInfo\030\002 \001(\014\"\332\003\n\017BizIdentityInfo\0229\n\006" + "vlevel\030\001 \001(\0162).proto.BizIdentityInfo.Ver" + "ifiedLevelValue\0221\n\tvnameCert\030\002 \001(\0132\036.pro" + "to.VerifiedNameCertificate\022\016\n\006signed\030\003 \001" + "(\010\022\017\n\007revoked\030\004 \001(\010\022;\n\013hostStorage\030\005 \001(\016" + "2&.proto.BizIdentityInfo.HostStorageType" + "\022=\n\014actualActors\030\006 \001(\0162\'.proto.BizIdenti" + "tyInfo.ActualActorsType\022\025\n\rprivacyModeTs" + "\030\007 \001(\004\022\027\n\017featureControls\030\010 \001(\004\"%\n\020Actua" + "lActorsType\022\010\n\004SELF\020\000\022\007\n\003BSP\020\001\"/\n\017HostSt" + "orageType\022\016\n\nON_PREMISE\020\000\022\014\n\010FACEBOOK\020\001\"" + "4\n\022VerifiedLevelValue\022\013\n\007UNKNOWN\020\000\022\007\n\003LO" + "W\020\001\022\010\n\004HIGH\020\002\"\221\002\n\tCertChain\022/\n\004leaf\030\001 \001(" + "\0132!.proto.CertChain.NoiseCertificate\0227\n\014" + "intermediate\030\002 \001(\0132!.proto.CertChain.Noi" + "seCertificate\032\231\001\n\020NoiseCertificate\022\017\n\007de" + "tails\030\001 \001(\014\022\021\n\tsignature\030\002 \001(\014\032a\n\007Detail" + "s\022\016\n\006serial\030\001 \001(\r\022\024\n\014issuerSerial\030\002 \001(\r\022" + "\013\n\003key\030\003 \001(\014\022\021\n\tnotBefore\030\004 \001(\004\022\020\n\010notAf" + "ter\030\005 \001(\004\"\215\001\n\005Chain\022\030\n\020senderRatchetKey\030" + "\001 \001(\014\022\037\n\027senderRatchetKeyPrivate\030\002 \001(\014\022!" + "\n\010chainKey\030\003 \001(\0132\017.proto.ChainKey\022&\n\013mes" + "sageKeys\030\004 \003(\0132\021.proto.MessageKey\"&\n\010Cha" + "inKey\022\r\n\005index\030\001 \001(\r\022\013\n\003key\030\002 \001(\014\"\326\031\n\rCl" + "ientPayload\022\020\n\010username\030\001 \001(\004\022\017\n\007passive" + "\030\003 \001(\010\0221\n\tuserAgent\030\005 \001(\0132\036.proto.Client" + "Payload.UserAgent\022-\n\007webInfo\030\006 \001(\0132\034.pro" + "to.ClientPayload.WebInfo\022\020\n\010pushName\030\007 \001" + "(\t\022\021\n\tsessionId\030\t \001(\017\022\024\n\014shortConnect\030\n " + "\001(\010\0225\n\013connectType\030\014 \001(\0162 .proto.ClientP" + "ayload.ConnectType\0229\n\rconnectReason\030\r \001(" + "\0162\".proto.ClientPayload.ConnectReason\022\016\n" + "\006shards\030\016 \003(\005\0221\n\tdnsSource\030\017 \001(\0132\036.proto" + ".ClientPayload.DNSSource\022\033\n\023connectAttem" + "ptCount\030\020 \001(\r\022\016\n\006device\030\022 \001(\r\022M\n\021deviceP" + "airingData\030\023 \001(\01322.proto.ClientPayload.D" + "evicePairingRegistrationData\022-\n\007product\030" + "\024 \001(\0162\034.proto.ClientPayload.Product\022\r\n\005f" + "bCat\030\025 \001(\014\022\023\n\013fbUserAgent\030\026 \001(\014\022\n\n\002oc\030\027 " + "\001(\010\022\n\n\002lc\030\030 \001(\005\022=\n\017iosAppExtension\030\036 \001(\016" + "2$.proto.ClientPayload.IOSAppExtension\022\017" + "\n\007fbAppId\030\037 \001(\004\022\022\n\nfbDeviceId\030 \001(\014\022\014\n\004p" + "ull\030! \001(\010\022\024\n\014paddingBytes\030\" \001(\014\032\277\001\n\tDNSS" + "ource\022E\n\tdnsMethod\030\017 \001(\01622.proto.ClientP" + "ayload.DNSSource.DNSResolutionMethod\022\021\n\t" + "appCached\030\020 \001(\010\"X\n\023DNSResolutionMethod\022\n" + "\n\006SYSTEM\020\000\022\n\n\006GOOGLE\020\001\022\r\n\tHARDCODED\020\002\022\014\n" + "\010OVERRIDE\020\003\022\014\n\010FALLBACK\020\004\032\256\001\n\035DevicePair" + "ingRegistrationData\022\016\n\006eRegid\030\001 \001(\014\022\020\n\010e" + "Keytype\030\002 \001(\014\022\016\n\006eIdent\030\003 \001(\014\022\017\n\007eSkeyId" + "\030\004 \001(\014\022\020\n\010eSkeyVal\030\005 \001(\014\022\020\n\010eSkeySig\030\006 \001" + "(\014\022\021\n\tbuildHash\030\007 \001(\014\022\023\n\013deviceProps\030\010 \001" + "(\014\032\370\007\n\tUserAgent\0229\n\010platform\030\001 \001(\0162\'.pro" + "to.ClientPayload.UserAgent.Platform\022=\n\na" + "ppVersion\030\002 \001(\0132).proto.ClientPayload.Us" + "erAgent.AppVersion\022\013\n\003mcc\030\003 \001(\t\022\013\n\003mnc\030\004" + " \001(\t\022\021\n\tosVersion\030\005 \001(\t\022\024\n\014manufacturer\030" + "\006 \001(\t\022\016\n\006device\030\007 \001(\t\022\025\n\rosBuildNumber\030\010" + " \001(\t\022\017\n\007phoneId\030\t \001(\t\022E\n\016releaseChannel\030" + "\n \001(\0162-.proto.ClientPayload.UserAgent.Re" + "leaseChannel\022\035\n\025localeLanguageIso6391\030\013 " + "\001(\t\022#\n\033localeCountryIso31661Alpha2\030\014 \001(\t" + "\022\023\n\013deviceBoard\030\r \001(\t\032g\n\nAppVersion\022\017\n\007p" + "rimary\030\001 \001(\r\022\021\n\tsecondary\030\002 \001(\r\022\020\n\010terti" + "ary\030\003 \001(\r\022\022\n\nquaternary\030\004 \001(\r\022\017\n\007quinary" + "\030\005 \001(\r\"\255\003\n\010Platform\022\013\n\007ANDROID\020\000\022\007\n\003IOS\020" + "\001\022\021\n\rWINDOWS_PHONE\020\002\022\016\n\nBLACKBERRY\020\003\022\017\n\013" + "BLACKBERRYX\020\004\022\007\n\003S40\020\005\022\007\n\003S60\020\006\022\021\n\rPYTHO" + "N_CLIENT\020\007\022\t\n\005TIZEN\020\010\022\016\n\nENTERPRISE\020\t\022\017\n" + "\013SMB_ANDROID\020\n\022\t\n\005KAIOS\020\013\022\013\n\007SMB_IOS\020\014\022\013" + "\n\007WINDOWS\020\r\022\007\n\003WEB\020\016\022\n\n\006PORTAL\020\017\022\021\n\rGREE" + "N_ANDROID\020\020\022\020\n\014GREEN_IPHONE\020\021\022\020\n\014BLUE_AN" + "DROID\020\022\022\017\n\013BLUE_IPHONE\020\023\022\022\n\016FBLITE_ANDRO" + "ID\020\024\022\021\n\rMLITE_ANDROID\020\025\022\022\n\016IGLITE_ANDROI" + "D\020\026\022\010\n\004PAGE\020\027\022\t\n\005MACOS\020\030\022\016\n\nOCULUS_MSG\020\031" + "\022\017\n\013OCULUS_CALL\020\032\022\t\n\005MILAN\020\033\022\010\n\004CAPI\020\034\"=" + "\n\016ReleaseChannel\022\013\n\007RELEASE\020\000\022\010\n\004BETA\020\001\022" + "\t\n\005ALPHA\020\002\022\t\n\005DEBUG\020\003\032\306\004\n\007WebInfo\022\020\n\010ref" + "Token\030\001 \001(\t\022\017\n\007version\030\002 \001(\t\022=\n\013webdPayl" + "oad\030\003 \001(\0132(.proto.ClientPayload.WebInfo." + "WebdPayload\022C\n\016webSubPlatform\030\004 \001(\0162+.pr" + "oto.ClientPayload.WebInfo.WebSubPlatform" + "\032\273\002\n\013WebdPayload\022\034\n\024usesParticipantInKey" + "\030\001 \001(\010\022\037\n\027supportsStarredMessages\030\002 \001(\010\022" + " \n\030supportsDocumentMessages\030\003 \001(\010\022\033\n\023sup" + "portsUrlMessages\030\004 \001(\010\022\032\n\022supportsMediaR" + "etry\030\005 \001(\010\022\030\n\020supportsE2EImage\030\006 \001(\010\022\030\n\020" + "supportsE2EVideo\030\007 \001(\010\022\030\n\020supportsE2EAud" + "io\030\010 \001(\010\022\033\n\023supportsE2EDocument\030\t \001(\010\022\025\n" + "\rdocumentTypes\030\n \001(\t\022\020\n\010features\030\013 \001(\014\"V" + "\n\016WebSubPlatform\022\017\n\013WEB_BROWSER\020\000\022\r\n\tAPP" + "_STORE\020\001\022\r\n\tWIN_STORE\020\002\022\n\n\006DARWIN\020\003\022\t\n\005W" + "INDA\020\004\"y\n\rConnectReason\022\010\n\004PUSH\020\000\022\022\n\016USE" + "R_ACTIVATED\020\001\022\r\n\tSCHEDULED\020\002\022\023\n\017ERROR_RE" + "CONNECT\020\003\022\022\n\016NETWORK_SWITCH\020\004\022\022\n\016PING_RE" + "CONNECT\020\005\"\260\002\n\013ConnectType\022\024\n\020CELLULAR_UN" + "KNOWN\020\000\022\020\n\014WIFI_UNKNOWN\020\001\022\021\n\rCELLULAR_ED" + "GE\020d\022\021\n\rCELLULAR_IDEN\020e\022\021\n\rCELLULAR_UMTS" + "\020f\022\021\n\rCELLULAR_EVDO\020g\022\021\n\rCELLULAR_GPRS\020h" + "\022\022\n\016CELLULAR_HSDPA\020i\022\022\n\016CELLULAR_HSUPA\020j" + "\022\021\n\rCELLULAR_HSPA\020k\022\021\n\rCELLULAR_CDMA\020l\022\022" + "\n\016CELLULAR_1XRTT\020m\022\022\n\016CELLULAR_EHRPD\020n\022\020" + "\n\014CELLULAR_LTE\020o\022\022\n\016CELLULAR_HSPAP\020p\"T\n\017" + "IOSAppExtension\022\023\n\017SHARE_EXTENSION\020\000\022\025\n\021" + "SERVICE_EXTENSION\020\001\022\025\n\021INTENTS_EXTENSION" + "\020\002\"&\n\007Product\022\014\n\010WHATSAPP\020\000\022\r\n\tMESSENGER" + "\020\001\"\231\n\n\013ContextInfo\022\020\n\010stanzaId\030\001 \001(\t\022\023\n\013" + "participant\030\002 \001(\t\022%\n\rquotedMessage\030\003 \001(\013" + "2\016.proto.Message\022\021\n\tremoteJid\030\004 \001(\t\022\024\n\014m" + "entionedJid\030\017 \003(\t\022\030\n\020conversionSource\030\022 " + "\001(\t\022\026\n\016conversionData\030\023 \001(\014\022\036\n\026conversio" + "nDelaySeconds\030\024 \001(\r\022\027\n\017forwardingScore\030\025" + " \001(\r\022\023\n\013isForwarded\030\026 \001(\010\0220\n\010quotedAd\030\027 " + "\001(\0132\036.proto.ContextInfo.AdReplyInfo\022)\n\016p" + "laceholderKey\030\030 \001(\0132\021.proto.MessageKey\022\022" + "\n\nexpiration\030\031 \001(\r\022!\n\031ephemeralSettingTi" + "mestamp\030\032 \001(\003\022\035\n\025ephemeralSharedSecret\030\033" + " \001(\014\022\?\n\017externalAdReply\030\034 \001(\0132&.proto.Co" + "ntextInfo.ExternalAdReplyInfo\022\"\n\032entryPo" + "intConversionSource\030\035 \001(\t\022\037\n\027entryPointC" + "onversionApp\030\036 \001(\t\022(\n entryPointConversi" + "onDelaySeconds\030\037 \001(\r\0221\n\020disappearingMode" + "\030 \001(\0132\027.proto.DisappearingMode\022%\n\nactio" + "nLink\030! \001(\0132\021.proto.ActionLink\022\024\n\014groupS" + "ubject\030\" \001(\t\022\026\n\016parentGroupJid\030# \001(\t\032\267\001\n" + "\013AdReplyInfo\022\026\n\016advertiserName\030\001 \001(\t\022;\n\t" + "mediaType\030\002 \001(\0162(.proto.ContextInfo.AdRe" + "plyInfo.MediaType\022\025\n\rjpegThumbnail\030\020 \001(\014" + "\022\017\n\007caption\030\021 \001(\t\"+\n\tMediaType\022\010\n\004NONE\020\000" + "\022\t\n\005IMAGE\020\001\022\t\n\005VIDEO\020\002\032\355\002\n\023ExternalAdRep" + "lyInfo\022\r\n\005title\030\001 \001(\t\022\014\n\004body\030\002 \001(\t\022C\n\tm" + "ediaType\030\003 \001(\01620.proto.ContextInfo.Exter" + "nalAdReplyInfo.MediaType\022\024\n\014thumbnailUrl" + "\030\004 \001(\t\022\020\n\010mediaUrl\030\005 \001(\t\022\021\n\tthumbnail\030\006 " + "\001(\014\022\022\n\nsourceType\030\007 \001(\t\022\020\n\010sourceId\030\010 \001(" + "\t\022\021\n\tsourceUrl\030\t \001(\t\022\031\n\021containsAutoRepl" + "y\030\n \001(\010\022\035\n\025renderLargerThumbnail\030\013 \001(\010\022\031" + "\n\021showAdAttribution\030\014 \001(\010\"+\n\tMediaType\022\010" + "\n\004NONE\020\000\022\t\n\005IMAGE\020\001\022\t\n\005VIDEO\020\002\"\261\t\n\014Conve" + "rsation\022\n\n\002id\030\001 \002(\t\022\'\n\010messages\030\002 \003(\0132\025." + "proto.HistorySyncMsg\022\016\n\006newJid\030\003 \001(\t\022\016\n\006" + "oldJid\030\004 \001(\t\022\030\n\020lastMsgTimestamp\030\005 \001(\004\022\023" + "\n\013unreadCount\030\006 \001(\r\022\020\n\010readOnly\030\007 \001(\010\022\034\n" + "\024endOfHistoryTransfer\030\010 \001(\010\022\033\n\023ephemeral" + "Expiration\030\t \001(\r\022!\n\031ephemeralSettingTime" + "stamp\030\n \001(\003\022N\n\030endOfHistoryTransferType\030" + "\013 \001(\0162,.proto.Conversation.EndOfHistoryT" + "ransferType\022\035\n\025conversationTimestamp\030\014 \001" + "(\004\022\014\n\004name\030\r \001(\t\022\r\n\005pHash\030\016 \001(\t\022\017\n\007notSp" + "am\030\017 \001(\010\022\020\n\010archived\030\020 \001(\010\0221\n\020disappeari" + "ngMode\030\021 \001(\0132\027.proto.DisappearingMode\022\032\n" + "\022unreadMentionCount\030\022 \001(\r\022\026\n\016markedAsUnr" + "ead\030\023 \001(\010\022,\n\013participant\030\024 \003(\0132\027.proto.G" + "roupParticipant\022\017\n\007tcToken\030\025 \001(\014\022\030\n\020tcTo" + "kenTimestamp\030\026 \001(\004\022!\n\031contactPrimaryIden" + "tityKey\030\027 \001(\014\022\016\n\006pinned\030\030 \001(\r\022\023\n\013muteEnd" + "Time\030\031 \001(\004\022+\n\twallpaper\030\032 \001(\0132\030.proto.Wa" + "llpaperSettings\022/\n\017mediaVisibility\030\033 \001(\016" + "2\026.proto.MediaVisibility\022\036\n\026tcTokenSende" + "rTimestamp\030\034 \001(\004\022\021\n\tsuspended\030\035 \001(\010\022\022\n\nt" + "erminated\030\036 \001(\010\022\021\n\tcreatedAt\030\037 \001(\004\022\021\n\tcr" + "eatedBy\030 \001(\t\022\023\n\013description\030! \001(\t\022\017\n\007su" + "pport\030\" \001(\010\022\025\n\risParentGroup\030# \001(\010\022\031\n\021is" + "DefaultSubgroup\030$ \001(\010\022\025\n\rparentGroupId\030%" + " \001(\t\022\023\n\013displayName\030& \001(\t\022\r\n\005pnJid\030\' \001(\t" + "\022\025\n\rselfPnExposed\030( \001(\010\"\200\001\n\030EndOfHistory" + "TransferType\0220\n,COMPLETE_BUT_MORE_MESSAG" + "ES_REMAIN_ON_PRIMARY\020\000\0222\n.COMPLETE_AND_N" + "O_MORE_MESSAGE_REMAIN_ON_PRIMARY\020\001\"\271\001\n\022D" + "eviceListMetadata\022\025\n\rsenderKeyHash\030\001 \001(\014" + "\022\027\n\017senderTimestamp\030\002 \001(\004\022\034\n\020senderKeyIn" + "dexes\030\003 \003(\rB\002\020\001\022\030\n\020recipientKeyHash\030\010 \001(" + "\014\022\032\n\022recipientTimestamp\030\t \001(\004\022\037\n\023recipie" + "ntKeyIndexes\030\n \003(\rB\002\020\001\"\275\003\n\013DeviceProps\022\n" + "\n\002os\030\001 \001(\t\022.\n\007version\030\002 \001(\0132\035.proto.Devi" + "ceProps.AppVersion\0225\n\014platformType\030\003 \001(\016" + "2\037.proto.DeviceProps.PlatformType\022\027\n\017req" + "uireFullSync\030\004 \001(\010\032g\n\nAppVersion\022\017\n\007prim" + "ary\030\001 \001(\r\022\021\n\tsecondary\030\002 \001(\r\022\020\n\010tertiary" + "\030\003 \001(\r\022\022\n\nquaternary\030\004 \001(\r\022\017\n\007quinary\030\005 " + "\001(\r\"\270\001\n\014PlatformType\022\013\n\007UNKNOWN\020\000\022\n\n\006CHR" + "OME\020\001\022\013\n\007FIREFOX\020\002\022\006\n\002IE\020\003\022\t\n\005OPERA\020\004\022\n\n" + "\006SAFARI\020\005\022\010\n\004EDGE\020\006\022\013\n\007DESKTOP\020\007\022\010\n\004IPAD" + "\020\010\022\022\n\016ANDROID_TABLET\020\t\022\t\n\005OHANA\020\n\022\t\n\005ALO" + "HA\020\013\022\014\n\010CATALINA\020\014\022\n\n\006TCL_TV\020\r\"\227\001\n\020Disap" + "pearingMode\0224\n\tinitiator\030\001 \001(\0162!.proto.D" + "isappearingMode.Initiator\"M\n\tInitiator\022\023" + "\n\017CHANGED_IN_CHAT\020\000\022\023\n\017INITIATED_BY_ME\020\001" + "\022\026\n\022INITIATED_BY_OTHER\020\002\"7\n\020EphemeralSet" + "ting\022\020\n\010duration\030\001 \001(\017\022\021\n\ttimestamp\030\002 \001(" + "\020\"&\n\010ExitCode\022\014\n\004code\030\001 \001(\004\022\014\n\004text\030\002 \001(" + "\t\"\217\001\n\025ExternalBlobReference\022\020\n\010mediaKey\030" + "\001 \001(\014\022\022\n\ndirectPath\030\002 \001(\t\022\016\n\006handle\030\003 \001(" + "\t\022\025\n\rfileSizeBytes\030\004 \001(\004\022\022\n\nfileSha256\030\005" + " \001(\014\022\025\n\rfileEncSha256\030\006 \001(\014\"\362\003\n\016GlobalSe" + "ttings\0225\n\023lightThemeWallpaper\030\001 \001(\0132\030.pr" + "oto.WallpaperSettings\022/\n\017mediaVisibility" + "\030\002 \001(\0162\026.proto.MediaVisibility\0224\n\022darkTh" + "emeWallpaper\030\003 \001(\0132\030.proto.WallpaperSett" + "ings\0225\n\020autoDownloadWiFi\030\004 \001(\0132\033.proto.A" + "utoDownloadSettings\0229\n\024autoDownloadCellu" + "lar\030\005 \001(\0132\033.proto.AutoDownloadSettings\0228" + "\n\023autoDownloadRoaming\030\006 \001(\0132\033.proto.Auto" + "DownloadSettings\022*\n\"showIndividualNotifi" + "cationsPreview\030\007 \001(\010\022%\n\035showGroupNotific" + "ationsPreview\030\010 \001(\010\022 \n\030disappearingModeD" + "uration\030\t \001(\005\022!\n\031disappearingModeTimesta" + "mp\030\n \001(\003\"\177\n\020GroupParticipant\022\017\n\007userJid\030" + "\001 \002(\t\022*\n\004rank\030\002 \001(\0162\034.proto.GroupPartici" + "pant.Rank\".\n\004Rank\022\013\n\007REGULAR\020\000\022\t\n\005ADMIN\020" + "\001\022\016\n\nSUPERADMIN\020\002\"\371\002\n\020HandshakeMessage\0228" + "\n\013clientHello\030\002 \001(\0132#.proto.HandshakeMes" + "sage.ClientHello\0228\n\013serverHello\030\003 \001(\0132#." + "proto.HandshakeMessage.ServerHello\022:\n\014cl" + "ientFinish\030\004 \001(\0132$.proto.HandshakeMessag" + "e.ClientFinish\032/\n\014ClientFinish\022\016\n\006static" + "\030\001 \001(\014\022\017\n\007payload\030\002 \001(\014\032A\n\013ClientHello\022\021" + "\n\tephemeral\030\001 \001(\014\022\016\n\006static\030\002 \001(\014\022\017\n\007pay" + "load\030\003 \001(\014\032A\n\013ServerHello\022\021\n\tephemeral\030\001" + " \001(\014\022\016\n\006static\030\002 \001(\014\022\017\n\007payload\030\003 \001(\014\"\264\004" + "\n\013HistorySync\0224\n\010syncType\030\001 \002(\0162\".proto." + "HistorySync.HistorySyncType\022*\n\rconversat" + "ions\030\002 \003(\0132\023.proto.Conversation\022/\n\020statu" + "sV3Messages\030\003 \003(\0132\025.proto.WebMessageInfo" + "\022\022\n\nchunkOrder\030\005 \001(\r\022\020\n\010progress\030\006 \001(\r\022\"" + "\n\tpushnames\030\007 \003(\0132\017.proto.Pushname\022-\n\016gl" + "obalSettings\030\010 \001(\0132\025.proto.GlobalSetting" + "s\022\032\n\022threadIdUserSecret\030\t \001(\014\022\037\n\027threadD" + "sTimeframeOffset\030\n \001(\r\022.\n\016recentStickers" + "\030\013 \003(\0132\026.proto.StickerMetadata\0221\n\020pastPa" + "rticipants\030\014 \003(\0132\027.proto.PastParticipant" + "s\"y\n\017HistorySyncType\022\025\n\021INITIAL_BOOTSTRA" + "P\020\000\022\025\n\021INITIAL_STATUS_V3\020\001\022\010\n\004FULL\020\002\022\n\n\006" + "RECENT\020\003\022\r\n\tPUSH_NAME\020\004\022\023\n\017UNBLOCKING_DA" + "TA\020\005\"L\n\016HistorySyncMsg\022&\n\007message\030\001 \001(\0132" + "\025.proto.WebMessageInfo\022\022\n\nmsgOrderId\030\002 \001" + "(\004\"\317\003\n\026HydratedTemplateButton\022\r\n\005index\030\004" + " \001(\r\022R\n\020quickReplyButton\030\001 \001(\01326.proto.H" + "ydratedTemplateButton.HydratedQuickReply" + "ButtonH\000\022D\n\turlButton\030\002 \001(\0132/.proto.Hydr" + "atedTemplateButton.HydratedURLButtonH\000\022F" + "\n\ncallButton\030\003 \001(\01320.proto.HydratedTempl" + "ateButton.HydratedCallButtonH\000\032>\n\022Hydrat" + "edCallButton\022\023\n\013displayText\030\001 \001(\t\022\023\n\013pho" + "neNumber\030\002 \001(\t\032;\n\030HydratedQuickReplyButt" + "on\022\023\n\013displayText\030\001 \001(\t\022\n\n\002id\030\002 \001(\t\0325\n\021H" + "ydratedURLButton\022\023\n\013displayText\030\001 \001(\t\022\013\n" + "\003url\030\002 \001(\tB\020\n\016hydratedButton\"A\n\030Identity" + "KeyPairStructure\022\021\n\tpublicKey\030\001 \001(\014\022\022\n\np" + "rivateKey\030\002 \001(\014\"m\n\025InteractiveAnnotation" + "\022%\n\017polygonVertices\030\001 \003(\0132\014.proto.Point\022" + "#\n\010location\030\002 \001(\0132\017.proto.LocationH\000B\010\n\006" + "action\"{\n\nKeepInChat\022!\n\010keepType\030\001 \001(\0162\017" + ".proto.KeepType\022\027\n\017serverTimestamp\030\002 \001(\003" + "\022\036\n\003key\030\003 \001(\0132\021.proto.MessageKey\022\021\n\tdevi" + "ceJid\030\004 \001(\t\"\023\n\005KeyId\022\n\n\002id\030\001 \001(\014\"=\n\rLoca" + "lizedName\022\n\n\002lg\030\001 \001(\t\022\n\n\002lc\030\002 \001(\t\022\024\n\014ver" + "ifiedName\030\003 \001(\t\"K\n\010Location\022\027\n\017degreesLa" + "titude\030\001 \001(\001\022\030\n\020degreesLongitude\030\002 \001(\001\022\014" + "\n\004name\030\003 \001(\t\"\036\n\tMediaData\022\021\n\tlocalPath\030\001" + " \001(\t\"\313\001\n\026MediaRetryNotification\022\020\n\010stanz" + "aId\030\001 \001(\t\022\022\n\ndirectPath\030\002 \001(\t\0228\n\006result\030" + "\003 \001(\0162(.proto.MediaRetryNotification.Res" + "ultType\"Q\n\nResultType\022\021\n\rGENERAL_ERROR\020\000" + "\022\013\n\007SUCCESS\020\001\022\r\n\tNOT_FOUND\020\002\022\024\n\020DECRYPTI" + "ON_ERROR\020\003\"\335\237\001\n\007Message\022\024\n\014conversation\030" + "\001 \001(\t\022Q\n\034senderKeyDistributionMessage\030\002 " + "\001(\0132+.proto.Message.SenderKeyDistributio" + "nMessage\0221\n\014imageMessage\030\003 \001(\0132\033.proto.M" + "essage.ImageMessage\0225\n\016contactMessage\030\004 " + "\001(\0132\035.proto.Message.ContactMessage\0227\n\017lo" + "cationMessage\030\005 \001(\0132\036.proto.Message.Loca" + "tionMessage\022\?\n\023extendedTextMessage\030\006 \001(\013" + "2\".proto.Message.ExtendedTextMessage\0227\n\017" + "documentMessage\030\007 \001(\0132\036.proto.Message.Do" + "cumentMessage\0221\n\014audioMessage\030\010 \001(\0132\033.pr" + "oto.Message.AudioMessage\0221\n\014videoMessage" + "\030\t \001(\0132\033.proto.Message.VideoMessage\022!\n\004c" + "all\030\n \001(\0132\023.proto.Message.Call\022!\n\004chat\030\013" + " \001(\0132\023.proto.Message.Chat\0227\n\017protocolMes" + "sage\030\014 \001(\0132\036.proto.Message.ProtocolMessa" + "ge\022A\n\024contactsArrayMessage\030\r \001(\0132#.proto" + ".Message.ContactsArrayMessage\022G\n\027highlyS" + "tructuredMessage\030\016 \001(\0132&.proto.Message.H" + "ighlyStructuredMessage\022_\n*fastRatchetKey" + "SenderKeyDistributionMessage\030\017 \001(\0132+.pro" + "to.Message.SenderKeyDistributionMessage\022" + "=\n\022sendPaymentMessage\030\020 \001(\0132!.proto.Mess" + "age.SendPaymentMessage\022\?\n\023liveLocationMe" + "ssage\030\022 \001(\0132\".proto.Message.LiveLocation" + "Message\022C\n\025requestPaymentMessage\030\026 \001(\0132$" + ".proto.Message.RequestPaymentMessage\022Q\n\034" + "declinePaymentRequestMessage\030\027 \001(\0132+.pro" + "to.Message.DeclinePaymentRequestMessage\022" + "O\n\033cancelPaymentRequestMessage\030\030 \001(\0132*.p" + "roto.Message.CancelPaymentRequestMessage" + "\0227\n\017templateMessage\030\031 \001(\0132\036.proto.Messag" + "e.TemplateMessage\0225\n\016stickerMessage\030\032 \001(" + "\0132\035.proto.Message.StickerMessage\022=\n\022grou" + "pInviteMessage\030\034 \001(\0132!.proto.Message.Gro" + "upInviteMessage\022M\n\032templateButtonReplyMe" + "ssage\030\035 \001(\0132).proto.Message.TemplateButt" + "onReplyMessage\0225\n\016productMessage\030\036 \001(\0132\035" + ".proto.Message.ProductMessage\022;\n\021deviceS" + "entMessage\030\037 \001(\0132 .proto.Message.DeviceS" + "entMessage\0225\n\022messageContextInfo\030# \001(\0132\031" + ".proto.MessageContextInfo\022/\n\013listMessage" + "\030$ \001(\0132\032.proto.Message.ListMessage\022:\n\017vi" + "ewOnceMessage\030% \001(\0132!.proto.Message.Futu" + "reProofMessage\0221\n\014orderMessage\030& \001(\0132\033.p" + "roto.Message.OrderMessage\022\?\n\023listRespons" + "eMessage\030\' \001(\0132\".proto.Message.ListRespo" + "nseMessage\022;\n\020ephemeralMessage\030( \001(\0132!.p" + "roto.Message.FutureProofMessage\0225\n\016invoi" + "ceMessage\030) \001(\0132\035.proto.Message.InvoiceM" + "essage\0225\n\016buttonsMessage\030* \001(\0132\035.proto.M" + "essage.ButtonsMessage\022E\n\026buttonsResponse" + "Message\030+ \001(\0132%.proto.Message.ButtonsRes" + "ponseMessage\022A\n\024paymentInviteMessage\030, \001" + "(\0132#.proto.Message.PaymentInviteMessage\022" + "=\n\022interactiveMessage\030- \001(\0132!.proto.Mess" + "age.InteractiveMessage\0227\n\017reactionMessag" + "e\030. \001(\0132\036.proto.Message.ReactionMessage\022" + "C\n\025stickerSyncRmrMessage\030/ \001(\0132$.proto.M" + "essage.StickerSyncRMRMessage\022M\n\032interact" + "iveResponseMessage\0300 \001(\0132).proto.Message" + ".InteractiveResponseMessage\022\?\n\023pollCreat" + "ionMessage\0301 \001(\0132\".proto.Message.PollCre" + "ationMessage\022;\n\021pollUpdateMessage\0302 \001(\0132" + " .proto.Message.PollUpdateMessage\022;\n\021kee" + "pInChatMessage\0303 \001(\0132 .proto.Message.Kee" + "pInChatMessage\022E\n\032documentWithCaptionMes" + "sage\0305 \001(\0132!.proto.Message.FutureProofMe" + "ssage\022K\n\031requestPhoneNumberMessage\0306 \001(\013" + "2(.proto.Message.RequestPhoneNumberMessa" + "ge\022<\n\021viewOnceMessageV2\0307 \001(\0132!.proto.Me" + "ssage.FutureProofMessage\032P\n\"AppStateFata" + "lExceptionNotification\022\027\n\017collectionName" + "s\030\001 \003(\t\022\021\n\ttimestamp\030\002 \001(\003\032y\n\023AppStateSy" + "ncKeyData\022\017\n\007keyData\030\001 \001(\014\022>\n\013fingerprin" + "t\030\002 \001(\0132).proto.Message.AppStateSyncKeyF" + "ingerprint\022\021\n\ttimestamp\030\003 \001(\003\032\\\n\032AppStat" + "eSyncKeyFingerprint\022\r\n\005rawId\030\001 \001(\r\022\024\n\014cu" + "rrentIndex\030\002 \001(\r\022\031\n\rdeviceIndexes\030\003 \003(\rB" + "\002\020\001\032\"\n\021AppStateSyncKeyId\022\r\n\005keyId\030\001 \001(\014\032" + "J\n\026AppStateSyncKeyRequest\0220\n\006keyIds\030\001 \003(" + "\0132 .proto.Message.AppStateSyncKeyId\032D\n\024A" + "ppStateSyncKeyShare\022,\n\004keys\030\001 \003(\0132\036.prot" + "o.Message.AppStateSyncKey\032w\n\017AppStateSyn" + "cKey\022/\n\005keyId\030\001 \001(\0132 .proto.Message.AppS" + "tateSyncKeyId\0223\n\007keyData\030\002 \001(\0132\".proto.M" + "essage.AppStateSyncKeyData\032\240\002\n\014AudioMess" + "age\022\013\n\003url\030\001 \001(\t\022\020\n\010mimetype\030\002 \001(\t\022\022\n\nfi" + "leSha256\030\003 \001(\014\022\022\n\nfileLength\030\004 \001(\004\022\017\n\007se" + "conds\030\005 \001(\r\022\013\n\003ptt\030\006 \001(\010\022\020\n\010mediaKey\030\007 \001" + "(\014\022\025\n\rfileEncSha256\030\010 \001(\014\022\022\n\ndirectPath\030" + "\t \001(\t\022\031\n\021mediaKeyTimestamp\030\n \001(\003\022\'\n\013cont" + "extInfo\030\021 \001(\0132\022.proto.ContextInfo\022\030\n\020str" + "eamingSidecar\030\022 \001(\014\022\020\n\010waveform\030\023 \001(\014\032\246\007" + "\n\016ButtonsMessage\022\023\n\013contentText\030\006 \001(\t\022\022\n" + "\nfooterText\030\007 \001(\t\022\'\n\013contextInfo\030\010 \001(\0132\022" + ".proto.ContextInfo\0225\n\007buttons\030\t \003(\0132$.pr" + "oto.Message.ButtonsMessage.Button\022<\n\nhea" + "derType\030\n \001(\0162(.proto.Message.ButtonsMes" + "sage.HeaderType\022\016\n\004text\030\001 \001(\tH\000\0229\n\017docum" + "entMessage\030\002 \001(\0132\036.proto.Message.Documen" + "tMessageH\000\0223\n\014imageMessage\030\003 \001(\0132\033.proto" + ".Message.ImageMessageH\000\0223\n\014videoMessage\030" + "\004 \001(\0132\033.proto.Message.VideoMessageH\000\0229\n\017" + "locationMessage\030\005 \001(\0132\036.proto.Message.Lo" + "cationMessageH\000\032\360\002\n\006Button\022\020\n\010buttonId\030\001" + " \001(\t\022C\n\nbuttonText\030\002 \001(\0132/.proto.Message" + ".ButtonsMessage.Button.ButtonText\0227\n\004typ" + "e\030\003 \001(\0162).proto.Message.ButtonsMessage.B" + "utton.Type\022K\n\016nativeFlowInfo\030\004 \001(\01323.pro" + "to.Message.ButtonsMessage.Button.NativeF" + "lowInfo\032!\n\nButtonText\022\023\n\013displayText\030\001 \001" + "(\t\0322\n\016NativeFlowInfo\022\014\n\004name\030\001 \001(\t\022\022\n\npa" + "ramsJson\030\002 \001(\t\"2\n\004Type\022\013\n\007UNKNOWN\020\000\022\014\n\010R" + "ESPONSE\020\001\022\017\n\013NATIVE_FLOW\020\002\"`\n\nHeaderType" + "\022\013\n\007UNKNOWN\020\000\022\t\n\005EMPTY\020\001\022\010\n\004TEXT\020\002\022\014\n\010DO" + "CUMENT\020\003\022\t\n\005IMAGE\020\004\022\t\n\005VIDEO\020\005\022\014\n\010LOCATI" + "ON\020\006B\010\n\006header\032\347\001\n\026ButtonsResponseMessag" + "e\022\030\n\020selectedButtonId\030\001 \001(\t\022\'\n\013contextIn" + "fo\030\003 \001(\0132\022.proto.ContextInfo\0228\n\004type\030\004 \001" + "(\0162*.proto.Message.ButtonsResponseMessag" + "e.Type\022\035\n\023selectedDisplayText\030\002 \001(\tH\000\"%\n" + "\004Type\022\013\n\007UNKNOWN\020\000\022\020\n\014DISPLAY_TEXT\020\001B\n\n\010" + "response\032i\n\004Call\022\017\n\007callKey\030\001 \001(\014\022\030\n\020con" + "versionSource\030\002 \001(\t\022\026\n\016conversionData\030\003 " + "\001(\014\022\036\n\026conversionDelaySeconds\030\004 \001(\r\032=\n\033C" + "ancelPaymentRequestMessage\022\036\n\003key\030\001 \001(\0132" + "\021.proto.MessageKey\032\'\n\004Chat\022\023\n\013displayNam" + "e\030\001 \001(\t\022\n\n\002id\030\002 \001(\t\032]\n\016ContactMessage\022\023\n" + "\013displayName\030\001 \001(\t\022\r\n\005vcard\030\020 \001(\t\022\'\n\013con" + "textInfo\030\021 \001(\0132\022.proto.ContextInfo\032\205\001\n\024C" + "ontactsArrayMessage\022\023\n\013displayName\030\001 \001(\t" + "\022/\n\010contacts\030\002 \003(\0132\035.proto.Message.Conta" + "ctMessage\022\'\n\013contextInfo\030\021 \001(\0132\022.proto.C" + "ontextInfo\032>\n\034DeclinePaymentRequestMessa" + "ge\022\036\n\003key\030\001 \001(\0132\021.proto.MessageKey\032[\n\021De" + "viceSentMessage\022\026\n\016destinationJid\030\001 \001(\t\022" + "\037\n\007message\030\002 \001(\0132\016.proto.Message\022\r\n\005phas" + "h\030\003 \001(\t\032\316\003\n\017DocumentMessage\022\013\n\003url\030\001 \001(\t" + "\022\020\n\010mimetype\030\002 \001(\t\022\r\n\005title\030\003 \001(\t\022\022\n\nfil" + "eSha256\030\004 \001(\014\022\022\n\nfileLength\030\005 \001(\004\022\021\n\tpag" + "eCount\030\006 \001(\r\022\020\n\010mediaKey\030\007 \001(\014\022\020\n\010fileNa" + "me\030\010 \001(\t\022\025\n\rfileEncSha256\030\t \001(\014\022\022\n\ndirec" + "tPath\030\n \001(\t\022\031\n\021mediaKeyTimestamp\030\013 \001(\003\022\024" + "\n\014contactVcard\030\014 \001(\010\022\033\n\023thumbnailDirectP" + "ath\030\r \001(\t\022\027\n\017thumbnailSha256\030\016 \001(\014\022\032\n\022th" + "umbnailEncSha256\030\017 \001(\014\022\025\n\rjpegThumbnail\030" + "\020 \001(\014\022\'\n\013contextInfo\030\021 \001(\0132\022.proto.Conte" + "xtInfo\022\027\n\017thumbnailHeight\030\022 \001(\r\022\026\n\016thumb" + "nailWidth\030\023 \001(\r\022\017\n\007caption\030\024 \001(\t\032\211\010\n\023Ext" + "endedTextMessage\022\014\n\004text\030\001 \001(\t\022\023\n\013matche" + "dText\030\002 \001(\t\022\024\n\014canonicalUrl\030\004 \001(\t\022\023\n\013des" + "cription\030\005 \001(\t\022\r\n\005title\030\006 \001(\t\022\020\n\010textArg" + "b\030\007 \001(\007\022\026\n\016backgroundArgb\030\010 \001(\007\0229\n\004font\030" + "\t \001(\0162+.proto.Message.ExtendedTextMessag" + "e.FontType\022C\n\013previewType\030\n \001(\0162..proto." + "Message.ExtendedTextMessage.PreviewType\022" + "\025\n\rjpegThumbnail\030\020 \001(\014\022\'\n\013contextInfo\030\021 " + "\001(\0132\022.proto.ContextInfo\022\027\n\017doNotPlayInli" + "ne\030\022 \001(\010\022\033\n\023thumbnailDirectPath\030\023 \001(\t\022\027\n" + "\017thumbnailSha256\030\024 \001(\014\022\032\n\022thumbnailEncSh" + "a256\030\025 \001(\014\022\020\n\010mediaKey\030\026 \001(\014\022\031\n\021mediaKey" + "Timestamp\030\027 \001(\003\022\027\n\017thumbnailHeight\030\030 \001(\r" + "\022\026\n\016thumbnailWidth\030\031 \001(\r\022S\n\023inviteLinkGr" + "oupType\030\032 \001(\01626.proto.Message.ExtendedTe" + "xtMessage.InviteLinkGroupType\022&\n\036inviteL" + "inkParentGroupSubjectV2\030\033 \001(\t\022(\n inviteL" + "inkParentGroupThumbnailV2\030\034 \001(\014\022U\n\025invit" + "eLinkGroupTypeV2\030\035 \001(\01626.proto.Message.E" + "xtendedTextMessage.InviteLinkGroupType\"v" + "\n\010FontType\022\016\n\nSANS_SERIF\020\000\022\t\n\005SERIF\020\001\022\023\n" + "\017NORICAN_REGULAR\020\002\022\021\n\rBRYNDAN_WRITE\020\003\022\025\n" + "\021BEBASNEUE_REGULAR\020\004\022\020\n\014OSWALD_HEAVY\020\005\"H" + "\n\023InviteLinkGroupType\022\013\n\007DEFAULT\020\000\022\n\n\006PA" + "RENT\020\001\022\007\n\003SUB\020\002\022\017\n\013DEFAULT_SUB\020\003\"\"\n\013Prev" + "iewType\022\010\n\004NONE\020\000\022\t\n\005VIDEO\020\001\0325\n\022FuturePr" + "oofMessage\022\037\n\007message\030\001 \001(\0132\016.proto.Mess" + "age\032\236\002\n\022GroupInviteMessage\022\020\n\010groupJid\030\001" + " \001(\t\022\022\n\ninviteCode\030\002 \001(\t\022\030\n\020inviteExpira" + "tion\030\003 \001(\003\022\021\n\tgroupName\030\004 \001(\t\022\025\n\rjpegThu" + "mbnail\030\005 \001(\014\022\017\n\007caption\030\006 \001(\t\022\'\n\013context" + "Info\030\007 \001(\0132\022.proto.ContextInfo\022>\n\tgroupT" + "ype\030\010 \001(\0162+.proto.Message.GroupInviteMes" + "sage.GroupType\"$\n\tGroupType\022\013\n\007DEFAULT\020\000" + "\022\n\n\006PARENT\020\001\032\257\013\n\027HighlyStructuredMessage" + "\022\021\n\tnamespace\030\001 \001(\t\022\023\n\013elementName\030\002 \001(\t" + "\022\016\n\006params\030\003 \003(\t\022\022\n\nfallbackLg\030\004 \001(\t\022\022\n\n" + "fallbackLc\030\005 \001(\t\022Y\n\021localizableParams\030\006 " + "\003(\0132>.proto.Message.HighlyStructuredMess" + "age.HSMLocalizableParameter\022\027\n\017determini" + "sticLg\030\007 \001(\t\022\027\n\017deterministicLc\030\010 \001(\t\0223\n" + "\013hydratedHsm\030\t \001(\0132\036.proto.Message.Templ" + "ateMessage\032\361\010\n\027HSMLocalizableParameter\022\017" + "\n\007default\030\001 \001(\t\022^\n\010currency\030\002 \001(\0132J.prot" + "o.Message.HighlyStructuredMessage.HSMLoc" + "alizableParameter.HSMCurrencyH\000\022^\n\010dateT" + "ime\030\003 \001(\0132J.proto.Message.HighlyStructur" + "edMessage.HSMLocalizableParameter.HSMDat" + "eTimeH\000\0327\n\013HSMCurrency\022\024\n\014currencyCode\030\001" + " \001(\t\022\022\n\namount1000\030\002 \001(\003\032\275\006\n\013HSMDateTime" + "\022t\n\tcomponent\030\001 \001(\0132_.proto.Message.High" + "lyStructuredMessage.HSMLocalizableParame" + "ter.HSMDateTime.HSMDateTimeComponentH\000\022t" + "\n\tunixEpoch\030\002 \001(\0132_.proto.Message.Highly" + "StructuredMessage.HSMLocalizableParamete" + "r.HSMDateTime.HSMDateTimeUnixEpochH\000\032\205\004\n" + "\024HSMDateTimeComponent\022\200\001\n\tdayOfWeek\030\001 \001(" + "\0162m.proto.Message.HighlyStructuredMessag" + "e.HSMLocalizableParameter.HSMDateTime.HS" + "MDateTimeComponent.DayOfWeekType\022\014\n\004year" + "\030\002 \001(\r\022\r\n\005month\030\003 \001(\r\022\022\n\ndayOfMonth\030\004 \001(" + "\r\022\014\n\004hour\030\005 \001(\r\022\016\n\006minute\030\006 \001(\r\022~\n\010calen" + "dar\030\007 \001(\0162l.proto.Message.HighlyStructur" + "edMessage.HSMLocalizableParameter.HSMDat" + "eTime.HSMDateTimeComponent.CalendarType\"" + ".\n\014CalendarType\022\r\n\tGREGORIAN\020\001\022\017\n\013SOLAR_" + "HIJRI\020\002\"k\n\rDayOfWeekType\022\n\n\006MONDAY\020\001\022\013\n\007" + "TUESDAY\020\002\022\r\n\tWEDNESDAY\020\003\022\014\n\010THURSDAY\020\004\022\n" + "\n\006FRIDAY\020\005\022\014\n\010SATURDAY\020\006\022\n\n\006SUNDAY\020\007\032)\n\024" + "HSMDateTimeUnixEpoch\022\021\n\ttimestamp\030\001 \001(\003B" + "\017\n\rdatetimeOneofB\014\n\nparamOneof\032\357\002\n\027Histo" + "rySyncNotification\022\022\n\nfileSha256\030\001 \001(\014\022\022" + "\n\nfileLength\030\002 \001(\004\022\020\n\010mediaKey\030\003 \001(\014\022\025\n\r" + "fileEncSha256\030\004 \001(\014\022\022\n\ndirectPath\030\005 \001(\t\022" + "H\n\010syncType\030\006 \001(\01626.proto.Message.Histor" + "ySyncNotification.HistorySyncType\022\022\n\nchu" + "nkOrder\030\007 \001(\r\022\031\n\021originalMessageId\030\010 \001(\t" + "\022\020\n\010progress\030\t \001(\r\"d\n\017HistorySyncType\022\025\n" + "\021INITIAL_BOOTSTRAP\020\000\022\025\n\021INITIAL_STATUS_V" + "3\020\001\022\010\n\004FULL\020\002\022\n\n\006RECENT\020\003\022\r\n\tPUSH_NAME\020\004" + "\032\212\005\n\014ImageMessage\022\013\n\003url\030\001 \001(\t\022\020\n\010mimety" + "pe\030\002 \001(\t\022\017\n\007caption\030\003 \001(\t\022\022\n\nfileSha256\030" + "\004 \001(\014\022\022\n\nfileLength\030\005 \001(\004\022\016\n\006height\030\006 \001(" + "\r\022\r\n\005width\030\007 \001(\r\022\020\n\010mediaKey\030\010 \001(\014\022\025\n\rfi" + "leEncSha256\030\t \001(\014\022<\n\026interactiveAnnotati" + "ons\030\n \003(\0132\034.proto.InteractiveAnnotation\022" + "\022\n\ndirectPath\030\013 \001(\t\022\031\n\021mediaKeyTimestamp" + "\030\014 \001(\003\022\025\n\rjpegThumbnail\030\020 \001(\014\022\'\n\013context" + "Info\030\021 \001(\0132\022.proto.ContextInfo\022\030\n\020firstS" + "canSidecar\030\022 \001(\014\022\027\n\017firstScanLength\030\023 \001(" + "\r\022\031\n\021experimentGroupId\030\024 \001(\r\022\024\n\014scansSid" + "ecar\030\025 \001(\014\022\023\n\013scanLengths\030\026 \003(\r\022\034\n\024midQu" + "alityFileSha256\030\027 \001(\014\022\037\n\027midQualityFileE" + "ncSha256\030\030 \001(\014\022\020\n\010viewOnce\030\031 \001(\010\022\033\n\023thum" + "bnailDirectPath\030\032 \001(\t\022\027\n\017thumbnailSha256" + "\030\033 \001(\014\022\032\n\022thumbnailEncSha256\030\034 \001(\014\022\021\n\tst" + "aticUrl\030\035 \001(\t\032M\n&InitialSecurityNotifica" + "tionSettingSync\022#\n\033securityNotificationE" + "nabled\030\001 \001(\010\032\207\n\n\022InteractiveMessage\0228\n\006h" + "eader\030\001 \001(\0132(.proto.Message.InteractiveM" + "essage.Header\0224\n\004body\030\002 \001(\0132&.proto.Mess" + "age.InteractiveMessage.Body\0228\n\006footer\030\003 " + "\001(\0132(.proto.Message.InteractiveMessage.F" + "ooter\022\'\n\013contextInfo\030\017 \001(\0132\022.proto.Conte" + "xtInfo\022N\n\025shopStorefrontMessage\030\004 \001(\0132-." + "proto.Message.InteractiveMessage.ShopMes" + "sageH\000\022P\n\021collectionMessage\030\005 \001(\01323.prot" + "o.Message.InteractiveMessage.CollectionM" + "essageH\000\022P\n\021nativeFlowMessage\030\006 \001(\01323.pr" + "oto.Message.InteractiveMessage.NativeFlo" + "wMessageH\000\032\024\n\004Body\022\014\n\004text\030\001 \001(\t\032G\n\021Coll" + "ectionMessage\022\016\n\006bizJid\030\001 \001(\t\022\n\n\002id\030\002 \001(" + "\t\022\026\n\016messageVersion\030\003 \001(\005\032\026\n\006Footer\022\014\n\004t" + "ext\030\001 \001(\t\032\214\002\n\006Header\022\r\n\005title\030\001 \001(\t\022\020\n\010s" + "ubtitle\030\002 \001(\t\022\032\n\022hasMediaAttachment\030\005 \001(" + "\010\0229\n\017documentMessage\030\003 \001(\0132\036.proto.Messa" + "ge.DocumentMessageH\000\0223\n\014imageMessage\030\004 \001" + "(\0132\033.proto.Message.ImageMessageH\000\022\027\n\rjpe" + "gThumbnail\030\006 \001(\014H\000\0223\n\014videoMessage\030\007 \001(\013" + "2\033.proto.Message.VideoMessageH\000B\007\n\005media" + "\032\331\001\n\021NativeFlowMessage\022U\n\007buttons\030\001 \003(\0132" + "D.proto.Message.InteractiveMessage.Nativ" + "eFlowMessage.NativeFlowButton\022\031\n\021message" + "ParamsJson\030\002 \001(\t\022\026\n\016messageVersion\030\003 \001(\005" + "\032:\n\020NativeFlowButton\022\014\n\004name\030\001 \001(\t\022\030\n\020bu" + "ttonParamsJson\030\002 \001(\t\032\261\001\n\013ShopMessage\022\n\n\002" + "id\030\001 \001(\t\022F\n\007surface\030\002 \001(\01625.proto.Messag" + "e.InteractiveMessage.ShopMessage.Surface" + "\022\026\n\016messageVersion\030\003 \001(\005\"6\n\007Surface\022\023\n\017U" + "NKNOWN_SURFACE\020\000\022\006\n\002FB\020\001\022\006\n\002IG\020\002\022\006\n\002WA\020\003" + "B\024\n\022interactiveMessage\032\361\002\n\032InteractiveRe" + "sponseMessage\022<\n\004body\030\001 \001(\0132..proto.Mess" + "age.InteractiveResponseMessage.Body\022\'\n\013c" + "ontextInfo\030\017 \001(\0132\022.proto.ContextInfo\022h\n\031" + "nativeFlowResponseMessage\030\002 \001(\0132C.proto." + "Message.InteractiveResponseMessage.Nativ" + "eFlowResponseMessageH\000\032\024\n\004Body\022\014\n\004text\030\001" + " \001(\t\032N\n\031NativeFlowResponseMessage\022\014\n\004nam" + "e\030\001 \001(\t\022\022\n\nparamsJson\030\002 \001(\t\022\017\n\007version\030\003" + " \001(\005B\034\n\032interactiveResponseMessage\032\364\002\n\016I" + "nvoiceMessage\022\014\n\004note\030\001 \001(\t\022\r\n\005token\030\002 \001" + "(\t\022D\n\016attachmentType\030\003 \001(\0162,.proto.Messa" + "ge.InvoiceMessage.AttachmentType\022\032\n\022atta" + "chmentMimetype\030\004 \001(\t\022\032\n\022attachmentMediaK" + "ey\030\005 \001(\014\022#\n\033attachmentMediaKeyTimestamp\030" + "\006 \001(\003\022\034\n\024attachmentFileSha256\030\007 \001(\014\022\037\n\027a" + "ttachmentFileEncSha256\030\010 \001(\014\022\034\n\024attachme" + "ntDirectPath\030\t \001(\t\022\037\n\027attachmentJpegThum" + "bnail\030\n \001(\014\"$\n\016AttachmentType\022\t\n\005IMAGE\020\000" + "\022\007\n\003PDF\020\001\032k\n\021KeepInChatMessage\022\036\n\003key\030\001 " + "\001(\0132\021.proto.MessageKey\022!\n\010keepType\030\002 \001(\016" + "2\017.proto.KeepType\022\023\n\013timestampMs\030\003 \001(\003\032\347" + "\006\n\013ListMessage\022\r\n\005title\030\001 \001(\t\022\023\n\013descrip" + "tion\030\002 \001(\t\022\022\n\nbuttonText\030\003 \001(\t\0225\n\010listTy" + "pe\030\004 \001(\0162#.proto.Message.ListMessage.Lis" + "tType\0224\n\010sections\030\005 \003(\0132\".proto.Message." + "ListMessage.Section\022C\n\017productListInfo\030\006" + " \001(\0132*.proto.Message.ListMessage.Product" + "ListInfo\022\022\n\nfooterText\030\007 \001(\t\022\'\n\013contextI" + "nfo\030\010 \001(\0132\022.proto.ContextInfo\032B\n\026Product" + "ListHeaderImage\022\021\n\tproductId\030\001 \001(\t\022\025\n\rjp" + "egThumbnail\030\002 \001(\014\032\267\001\n\017ProductListInfo\022B\n" + "\017productSections\030\001 \003(\0132).proto.Message.L" + "istMessage.ProductSection\022F\n\013headerImage" + "\030\002 \001(\01321.proto.Message.ListMessage.Produ" + "ctListHeaderImage\022\030\n\020businessOwnerJid\030\003 " + "\001(\t\032U\n\016ProductSection\022\r\n\005title\030\001 \001(\t\0224\n\010" + "products\030\002 \003(\0132\".proto.Message.ListMessa" + "ge.Product\032\034\n\007Product\022\021\n\tproductId\030\001 \001(\t" + "\0328\n\003Row\022\r\n\005title\030\001 \001(\t\022\023\n\013description\030\002 " + "\001(\t\022\r\n\005rowId\030\003 \001(\t\032F\n\007Section\022\r\n\005title\030\001" + " \001(\t\022,\n\004rows\030\002 \003(\0132\036.proto.Message.ListM" + "essage.Row\"<\n\010ListType\022\013\n\007UNKNOWN\020\000\022\021\n\rS" + "INGLE_SELECT\020\001\022\020\n\014PRODUCT_LIST\020\002\032\312\002\n\023Lis" + "tResponseMessage\022\r\n\005title\030\001 \001(\t\022=\n\010listT" + "ype\030\002 \001(\0162+.proto.Message.ListResponseMe" + "ssage.ListType\022O\n\021singleSelectReply\030\003 \001(" + "\01324.proto.Message.ListResponseMessage.Si" + "ngleSelectReply\022\'\n\013contextInfo\030\004 \001(\0132\022.p" + "roto.ContextInfo\022\023\n\013description\030\005 \001(\t\032*\n" + "\021SingleSelectReply\022\025\n\rselectedRowId\030\001 \001(" + "\t\"*\n\010ListType\022\013\n\007UNKNOWN\020\000\022\021\n\rSINGLE_SEL" + "ECT\020\001\032\236\002\n\023LiveLocationMessage\022\027\n\017degrees" + "Latitude\030\001 \001(\001\022\030\n\020degreesLongitude\030\002 \001(\001" + "\022\030\n\020accuracyInMeters\030\003 \001(\r\022\022\n\nspeedInMps" + "\030\004 \001(\002\022)\n!degreesClockwiseFromMagneticNo" + "rth\030\005 \001(\r\022\017\n\007caption\030\006 \001(\t\022\026\n\016sequenceNu" + "mber\030\007 \001(\003\022\022\n\ntimeOffset\030\010 \001(\r\022\025\n\rjpegTh" + "umbnail\030\020 \001(\014\022\'\n\013contextInfo\030\021 \001(\0132\022.pro" + "to.ContextInfo\032\252\002\n\017LocationMessage\022\027\n\017de" + "greesLatitude\030\001 \001(\001\022\030\n\020degreesLongitude\030" + "\002 \001(\001\022\014\n\004name\030\003 \001(\t\022\017\n\007address\030\004 \001(\t\022\013\n\003" + "url\030\005 \001(\t\022\016\n\006isLive\030\006 \001(\010\022\030\n\020accuracyInM" + "eters\030\007 \001(\r\022\022\n\nspeedInMps\030\010 \001(\002\022)\n!degre" + "esClockwiseFromMagneticNorth\030\t \001(\r\022\017\n\007co" + "mment\030\013 \001(\t\022\025\n\rjpegThumbnail\030\020 \001(\014\022\'\n\013co" + "ntextInfo\030\021 \001(\0132\022.proto.ContextInfo\032\226\003\n\014" + "OrderMessage\022\017\n\007orderId\030\001 \001(\t\022\021\n\tthumbna" + "il\030\002 \001(\014\022\021\n\titemCount\030\003 \001(\005\0227\n\006status\030\004 " + "\001(\0162\'.proto.Message.OrderMessage.OrderSt" + "atus\0229\n\007surface\030\005 \001(\0162(.proto.Message.Or" + "derMessage.OrderSurface\022\017\n\007message\030\006 \001(\t" + "\022\022\n\norderTitle\030\007 \001(\t\022\021\n\tsellerJid\030\010 \001(\t\022" + "\r\n\005token\030\t \001(\t\022\027\n\017totalAmount1000\030\n \001(\003\022" + "\031\n\021totalCurrencyCode\030\013 \001(\t\022\'\n\013contextInf" + "o\030\021 \001(\0132\022.proto.ContextInfo\"\032\n\013OrderStat" + "us\022\013\n\007INQUIRY\020\001\"\033\n\014OrderSurface\022\013\n\007CATAL" + "OG\020\001\032\257\001\n\024PaymentInviteMessage\022D\n\013service" + "Type\030\001 \001(\0162/.proto.Message.PaymentInvite" + "Message.ServiceType\022\027\n\017expiryTimestamp\030\002" + " \001(\003\"8\n\013ServiceType\022\013\n\007UNKNOWN\020\000\022\t\n\005FBPA" + "Y\020\001\022\010\n\004NOVI\020\002\022\007\n\003UPI\020\003\032\326\001\n\023PollCreationM" + "essage\022\016\n\006encKey\030\001 \001(\014\022\014\n\004name\030\002 \001(\t\022:\n\007" + "options\030\003 \003(\0132).proto.Message.PollCreati" + "onMessage.Option\022\036\n\026selectableOptionsCou" + "nt\030\004 \001(\r\022\'\n\013contextInfo\030\005 \001(\0132\022.proto.Co" + "ntextInfo\032\034\n\006Option\022\022\n\noptionName\030\001 \001(\t\032" + "1\n\014PollEncValue\022\022\n\nencPayload\030\001 \001(\014\022\r\n\005e" + "ncIv\030\002 \001(\014\032\033\n\031PollUpdateMessageMetadata\032" + "\310\001\n\021PollUpdateMessage\0221\n\026pollCreationMes" + "sageKey\030\001 \001(\0132\021.proto.MessageKey\022)\n\004vote" + "\030\002 \001(\0132\033.proto.Message.PollEncValue\022:\n\010m" + "etadata\030\003 \001(\0132(.proto.Message.PollUpdate" + "MessageMetadata\022\031\n\021senderTimestampMs\030\004 \001" + "(\003\032*\n\017PollVoteMessage\022\027\n\017selectedOptions" + "\030\001 \003(\014\032\367\004\n\016ProductMessage\022>\n\007product\030\001 \001" + "(\0132-.proto.Message.ProductMessage.Produc" + "tSnapshot\022\030\n\020businessOwnerJid\030\002 \001(\t\022>\n\007c" + "atalog\030\004 \001(\0132-.proto.Message.ProductMess" + "age.CatalogSnapshot\022\014\n\004body\030\005 \001(\t\022\016\n\006foo" + "ter\030\006 \001(\t\022\'\n\013contextInfo\030\021 \001(\0132\022.proto.C" + "ontextInfo\032h\n\017CatalogSnapshot\0221\n\014catalog" + "Image\030\001 \001(\0132\033.proto.Message.ImageMessage" + "\022\r\n\005title\030\002 \001(\t\022\023\n\013description\030\003 \001(\t\032\231\002\n" + "\017ProductSnapshot\0221\n\014productImage\030\001 \001(\0132\033" + ".proto.Message.ImageMessage\022\021\n\tproductId" + "\030\002 \001(\t\022\r\n\005title\030\003 \001(\t\022\023\n\013description\030\004 \001" + "(\t\022\024\n\014currencyCode\030\005 \001(\t\022\027\n\017priceAmount1" + "000\030\006 \001(\003\022\022\n\nretailerId\030\007 \001(\t\022\013\n\003url\030\010 \001" + "(\t\022\031\n\021productImageCount\030\t \001(\r\022\024\n\014firstIm" + "ageId\030\013 \001(\t\022\033\n\023salePriceAmount1000\030\014 \001(\003" + "\032\242\t\n\017ProtocolMessage\022\036\n\003key\030\001 \001(\0132\021.prot" + "o.MessageKey\0221\n\004type\030\002 \001(\0162#.proto.Messa" + "ge.ProtocolMessage.Type\022\033\n\023ephemeralExpi" + "ration\030\004 \001(\r\022!\n\031ephemeralSettingTimestam" + "p\030\005 \001(\003\022G\n\027historySyncNotification\030\006 \001(\013" + "2&.proto.Message.HistorySyncNotification" + "\022A\n\024appStateSyncKeyShare\030\007 \001(\0132#.proto.M" + "essage.AppStateSyncKeyShare\022E\n\026appStateS" + "yncKeyRequest\030\010 \001(\0132%.proto.Message.AppS" + "tateSyncKeyRequest\022e\n&initialSecurityNot" + "ificationSettingSync\030\t \001(\01325.proto.Messa" + "ge.InitialSecurityNotificationSettingSyn" + "c\022]\n\"appStateFatalExceptionNotification\030" + "\n \001(\01321.proto.Message.AppStateFatalExcep" + "tionNotification\0221\n\020disappearingMode\030\013 \001" + "(\0132\027.proto.DisappearingMode\022K\n\031requestMe" + "diaUploadMessage\030\014 \001(\0132(.proto.Message.R" + "equestMediaUploadMessage\022[\n!requestMedia" + "UploadResponseMessage\030\r \001(\01320.proto.Mess" + "age.RequestMediaUploadResponseMessage\"\205\003" + "\n\004Type\022\n\n\006REVOKE\020\000\022\025\n\021EPHEMERAL_SETTING\020" + "\003\022\033\n\027EPHEMERAL_SYNC_RESPONSE\020\004\022\035\n\031HISTOR" + "Y_SYNC_NOTIFICATION\020\005\022\034\n\030APP_STATE_SYNC_" + "KEY_SHARE\020\006\022\036\n\032APP_STATE_SYNC_KEY_REQUES" + "T\020\007\022\037\n\033MSG_FANOUT_BACKFILL_REQUEST\020\010\022.\n*" + "INITIAL_SECURITY_NOTIFICATION_SETTING_SY" + "NC\020\t\022*\n&APP_STATE_FATAL_EXCEPTION_NOTIFI" + "CATION\020\n\022\026\n\022SHARE_PHONE_NUMBER\020\013\022 \n\034REQU" + "EST_MEDIA_UPLOAD_MESSAGE\020\014\022)\n%REQUEST_ME" + "DIA_UPLOAD_RESPONSE_MESSAGE\020\r\032o\n\017Reactio" + "nMessage\022\036\n\003key\030\001 \001(\0132\021.proto.MessageKey" + "\022\014\n\004text\030\002 \001(\t\022\023\n\013groupingKey\030\003 \001(\t\022\031\n\021s" + "enderTimestampMs\030\004 \001(\003\032\\\n\031RequestMediaUp" + "loadMessage\022\022\n\nfileSha256\030\001 \003(\t\022+\n\trmrSo" + "urce\030\002 \001(\0162\030.proto.Message.RmrSource\032\362\002\n" + "!RequestMediaUploadResponseMessage\022+\n\trm" + "rSource\030\001 \001(\0162\030.proto.Message.RmrSource\022" + "\020\n\010stanzaId\030\002 \001(\t\022a\n\016reuploadResult\030\003 \003(" + "\0132I.proto.Message.RequestMediaUploadResp" + "onseMessage.RequestMediaUploadResult\032\252\001\n" + "\030RequestMediaUploadResult\022\022\n\nfileSha256\030" + "\001 \001(\t\022C\n\021mediaUploadResult\030\002 \001(\0162(.proto" + ".MediaRetryNotification.ResultType\0225\n\016st" + "ickerMessage\030\003 \001(\0132\035.proto.Message.Stick" + "erMessage\032\347\001\n\025RequestPaymentMessage\022#\n\013n" + "oteMessage\030\004 \001(\0132\016.proto.Message\022\033\n\023curr" + "encyCodeIso4217\030\001 \001(\t\022\022\n\namount1000\030\002 \001(" + "\004\022\023\n\013requestFrom\030\003 \001(\t\022\027\n\017expiryTimestam" + "p\030\005 \001(\003\022\034\n\006amount\030\006 \001(\0132\014.proto.Money\022,\n" + "\nbackground\030\007 \001(\0132\030.proto.PaymentBackgro" + "und\032D\n\031RequestPhoneNumberMessage\022\'\n\013cont" + "extInfo\030\001 \001(\0132\022.proto.ContextInfo\032\225\001\n\022Se" + "ndPaymentMessage\022#\n\013noteMessage\030\002 \001(\0132\016." + "proto.Message\022,\n\021requestMessageKey\030\003 \001(\013" + "2\021.proto.MessageKey\022,\n\nbackground\030\004 \001(\0132" + "\030.proto.PaymentBackground\032\\\n\034SenderKeyDi" + "stributionMessage\022\017\n\007groupId\030\001 \001(\t\022+\n#ax" + "olotlSenderKeyDistributionMessage\030\002 \001(\014\032" + "\326\002\n\016StickerMessage\022\013\n\003url\030\001 \001(\t\022\022\n\nfileS" + "ha256\030\002 \001(\014\022\025\n\rfileEncSha256\030\003 \001(\014\022\020\n\010me" + "diaKey\030\004 \001(\014\022\020\n\010mimetype\030\005 \001(\t\022\016\n\006height" + "\030\006 \001(\r\022\r\n\005width\030\007 \001(\r\022\022\n\ndirectPath\030\010 \001(" + "\t\022\022\n\nfileLength\030\t \001(\004\022\031\n\021mediaKeyTimesta" + "mp\030\n \001(\003\022\030\n\020firstFrameLength\030\013 \001(\r\022\031\n\021fi" + "rstFrameSidecar\030\014 \001(\014\022\022\n\nisAnimated\030\r \001(" + "\010\022\024\n\014pngThumbnail\030\020 \001(\014\022\'\n\013contextInfo\030\021" + " \001(\0132\022.proto.ContextInfo\032V\n\025StickerSyncR" + "MRMessage\022\020\n\010filehash\030\001 \003(\t\022\021\n\trmrSource" + "\030\002 \001(\t\022\030\n\020requestTimestamp\030\003 \001(\003\032\215\001\n\032Tem" + "plateButtonReplyMessage\022\022\n\nselectedId\030\001 " + "\001(\t\022\033\n\023selectedDisplayText\030\002 \001(\t\022\'\n\013cont" + "extInfo\030\003 \001(\0132\022.proto.ContextInfo\022\025\n\rsel" + "ectedIndex\030\004 \001(\r\032\304\t\n\017TemplateMessage\022\'\n\013" + "contextInfo\030\003 \001(\0132\022.proto.ContextInfo\022P\n" + "\020hydratedTemplate\030\004 \001(\01326.proto.Message." + "TemplateMessage.HydratedFourRowTemplate\022" + "I\n\017fourRowTemplate\030\001 \001(\0132..proto.Message" + ".TemplateMessage.FourRowTemplateH\000\022Y\n\027hy" + "dratedFourRowTemplate\030\002 \001(\01326.proto.Mess" + "age.TemplateMessage.HydratedFourRowTempl" + "ateH\000\032\336\003\n\017FourRowTemplate\0227\n\007content\030\006 \001" + "(\0132&.proto.Message.HighlyStructuredMessa" + "ge\0226\n\006footer\030\007 \001(\0132&.proto.Message.Highl" + "yStructuredMessage\022&\n\007buttons\030\010 \003(\0132\025.pr" + "oto.TemplateButton\0229\n\017documentMessage\030\001 " + "\001(\0132\036.proto.Message.DocumentMessageH\000\022I\n" + "\027highlyStructuredMessage\030\002 \001(\0132&.proto.M" + "essage.HighlyStructuredMessageH\000\0223\n\014imag" + "eMessage\030\003 \001(\0132\033.proto.Message.ImageMess" + "ageH\000\0223\n\014videoMessage\030\004 \001(\0132\033.proto.Mess" + "age.VideoMessageH\000\0229\n\017locationMessage\030\005 " + "\001(\0132\036.proto.Message.LocationMessageH\000B\007\n" + "\005title\032\244\003\n\027HydratedFourRowTemplate\022\033\n\023hy" + "dratedContentText\030\006 \001(\t\022\032\n\022hydratedFoote" + "rText\030\007 \001(\t\0226\n\017hydratedButtons\030\010 \003(\0132\035.p" + "roto.HydratedTemplateButton\022\022\n\ntemplateI" + "d\030\t \001(\t\0229\n\017documentMessage\030\001 \001(\0132\036.proto" + ".Message.DocumentMessageH\000\022\033\n\021hydratedTi" + "tleText\030\002 \001(\tH\000\0223\n\014imageMessage\030\003 \001(\0132\033." + "proto.Message.ImageMessageH\000\0223\n\014videoMes" + "sage\030\004 \001(\0132\033.proto.Message.VideoMessageH" + "\000\0229\n\017locationMessage\030\005 \001(\0132\036.proto.Messa" + "ge.LocationMessageH\000B\007\n\005titleB\010\n\006format\032" + "\202\005\n\014VideoMessage\022\013\n\003url\030\001 \001(\t\022\020\n\010mimetyp" + "e\030\002 \001(\t\022\022\n\nfileSha256\030\003 \001(\014\022\022\n\nfileLengt" + "h\030\004 \001(\004\022\017\n\007seconds\030\005 \001(\r\022\020\n\010mediaKey\030\006 \001" + "(\014\022\017\n\007caption\030\007 \001(\t\022\023\n\013gifPlayback\030\010 \001(\010" + "\022\016\n\006height\030\t \001(\r\022\r\n\005width\030\n \001(\r\022\025\n\rfileE" + "ncSha256\030\013 \001(\014\022<\n\026interactiveAnnotations" + "\030\014 \003(\0132\034.proto.InteractiveAnnotation\022\022\n\n" + "directPath\030\r \001(\t\022\031\n\021mediaKeyTimestamp\030\016 " + "\001(\003\022\025\n\rjpegThumbnail\030\020 \001(\014\022\'\n\013contextInf" + "o\030\021 \001(\0132\022.proto.ContextInfo\022\030\n\020streaming" + "Sidecar\030\022 \001(\014\022\?\n\016gifAttribution\030\023 \001(\0162\'." + "proto.Message.VideoMessage.Attribution\022\020" + "\n\010viewOnce\030\024 \001(\010\022\033\n\023thumbnailDirectPath\030" + "\025 \001(\t\022\027\n\017thumbnailSha256\030\026 \001(\014\022\032\n\022thumbn" + "ailEncSha256\030\027 \001(\014\022\021\n\tstaticUrl\030\030 \001(\t\"-\n" + "\013Attribution\022\010\n\004NONE\020\000\022\t\n\005GIPHY\020\001\022\t\n\005TEN" + "OR\020\002\"5\n\tRmrSource\022\024\n\020FAVORITE_STICKER\020\000\022" + "\022\n\016RECENT_STICKER\020\001\"\233\001\n\022MessageContextIn" + "fo\0225\n\022deviceListMetadata\030\001 \001(\0132\031.proto.D" + "eviceListMetadata\022!\n\031deviceListMetadataV" + "ersion\030\002 \001(\005\022\025\n\rmessageSecret\030\003 \001(\014\022\024\n\014p" + "addingBytes\030\004 \001(\014\"P\n\nMessageKey\022\021\n\tremot" + "eJid\030\001 \001(\t\022\016\n\006fromMe\030\002 \001(\010\022\n\n\002id\030\003 \001(\t\022\023" + "\n\013participant\030\004 \001(\t\"<\n\005Money\022\r\n\005value\030\001 " + "\001(\003\022\016\n\006offset\030\002 \001(\r\022\024\n\014currencyCode\030\003 \001(" + "\t\"\232\004\n\rMsgOpaqueData\022\014\n\004body\030\001 \001(\t\022\017\n\007cap" + "tion\030\003 \001(\t\022\013\n\003lng\030\005 \001(\001\022\016\n\006isLive\030\006 \001(\010\022" + "\013\n\003lat\030\007 \001(\001\022\031\n\021paymentAmount1000\030\010 \001(\005\022" + "\032\n\022paymentNoteMsgBody\030\t \001(\t\022\024\n\014canonical" + "Url\030\n \001(\t\022\023\n\013matchedText\030\013 \001(\t\022\r\n\005title\030" + "\014 \001(\t\022\023\n\013description\030\r \001(\t\022\031\n\021futureproo" + "fBuffer\030\016 \001(\014\022\021\n\tclientUrl\030\017 \001(\t\022\013\n\003loc\030" + "\020 \001(\t\022\020\n\010pollName\030\021 \001(\t\0224\n\013pollOptions\030\022" + " \003(\0132\037.proto.MsgOpaqueData.PollOption\022\"\n" + "\032pollSelectableOptionsCount\030\024 \001(\r\022\025\n\rmes" + "sageSecret\030\025 \001(\014\022\031\n\021senderTimestampMs\030\026 " + "\001(\003\022\033\n\023pollUpdateParentKey\030\027 \001(\t\022(\n\013encP" + "ollVote\030\030 \001(\0132\023.proto.PollEncValue\032\032\n\nPo" + "llOption\022\014\n\004name\030\001 \001(\t\"e\n\020MsgRowOpaqueDa" + "ta\022(\n\ncurrentMsg\030\001 \001(\0132\024.proto.MsgOpaque" + "Data\022\'\n\tquotedMsg\030\002 \001(\0132\024.proto.MsgOpaqu" + "eData\"\220\001\n\020NoiseCertificate\022\017\n\007details\030\001 " + "\001(\014\022\021\n\tsignature\030\002 \001(\014\032X\n\007Details\022\016\n\006ser" + "ial\030\001 \001(\r\022\016\n\006issuer\030\002 \001(\t\022\017\n\007expires\030\003 \001" + "(\004\022\017\n\007subject\030\004 \001(\t\022\013\n\003key\030\005 \001(\014\"\211\001\n\027Not" + "ificationMessageInfo\022\036\n\003key\030\001 \001(\0132\021.prot" + "o.MessageKey\022\037\n\007message\030\002 \001(\0132\016.proto.Me" + "ssage\022\030\n\020messageTimestamp\030\003 \001(\004\022\023\n\013parti" + "cipant\030\004 \001(\t\"\222\001\n\017PastParticipant\022\017\n\007user" + "Jid\030\001 \002(\t\0227\n\013leaveReason\030\002 \002(\0162\".proto.P" + "astParticipant.LeaveReason\022\017\n\007leaveTs\030\003 " + "\002(\004\"$\n\013LeaveReason\022\010\n\004LEFT\020\000\022\013\n\007REMOVED\020" + "\001\"V\n\020PastParticipants\022\020\n\010groupJid\030\001 \002(\t\022" + "0\n\020pastParticipants\030\002 \003(\0132\026.proto.PastPa" + "rticipant\"\243\003\n\021PaymentBackground\022\n\n\002id\030\001 " + "\001(\t\022\022\n\nfileLength\030\002 \001(\004\022\r\n\005width\030\003 \001(\r\022\016" + "\n\006height\030\004 \001(\r\022\020\n\010mimetype\030\005 \001(\t\022\027\n\017plac" + "eholderArgb\030\006 \001(\007\022\020\n\010textArgb\030\007 \001(\007\022\023\n\013s" + "ubtextArgb\030\010 \001(\007\0225\n\tmediaData\030\t \001(\0132\".pr" + "oto.PaymentBackground.MediaData\022+\n\004type\030" + "\n \001(\0162\035.proto.PaymentBackground.Type\032w\n\t" + "MediaData\022\020\n\010mediaKey\030\001 \001(\014\022\031\n\021mediaKeyT" + "imestamp\030\002 \001(\003\022\022\n\nfileSha256\030\003 \001(\014\022\025\n\rfi" + "leEncSha256\030\004 \001(\014\022\022\n\ndirectPath\030\005 \001(\t\" \n" + "\004Type\022\013\n\007UNKNOWN\020\000\022\013\n\007DEFAULT\020\001\"\325\n\n\013Paym" + "entInfo\0227\n\022currencyDeprecated\030\001 \001(\0162\033.pr" + "oto.PaymentInfo.Currency\022\022\n\namount1000\030\002" + " \001(\004\022\023\n\013receiverJid\030\003 \001(\t\022)\n\006status\030\004 \001(" + "\0162\031.proto.PaymentInfo.Status\022\034\n\024transact" + "ionTimestamp\030\005 \001(\004\022,\n\021requestMessageKey\030" + "\006 \001(\0132\021.proto.MessageKey\022\027\n\017expiryTimest" + "amp\030\007 \001(\004\022\025\n\rfutureproofed\030\010 \001(\010\022\020\n\010curr" + "ency\030\t \001(\t\022/\n\ttxnStatus\030\n \001(\0162\034.proto.Pa" + "ymentInfo.TxnStatus\022\031\n\021useNoviFiatFormat" + "\030\013 \001(\010\022#\n\rprimaryAmount\030\014 \001(\0132\014.proto.Mo" + "ney\022$\n\016exchangeAmount\030\r \001(\0132\014.proto.Mone" + "y\")\n\010Currency\022\024\n\020UNKNOWN_CURRENCY\020\000\022\007\n\003I" + "NR\020\001\"\314\001\n\006Status\022\022\n\016UNKNOWN_STATUS\020\000\022\016\n\nP" + "ROCESSING\020\001\022\010\n\004SENT\020\002\022\022\n\016NEED_TO_ACCEPT\020" + "\003\022\014\n\010COMPLETE\020\004\022\026\n\022COULD_NOT_COMPLETE\020\005\022" + "\014\n\010REFUNDED\020\006\022\013\n\007EXPIRED\020\007\022\014\n\010REJECTED\020\010" + "\022\r\n\tCANCELLED\020\t\022\025\n\021WAITING_FOR_PAYER\020\n\022\013" + "\n\007WAITING\020\013\"\231\005\n\tTxnStatus\022\013\n\007UNKNOWN\020\000\022\021" + "\n\rPENDING_SETUP\020\001\022\032\n\026PENDING_RECEIVER_SE" + "TUP\020\002\022\010\n\004INIT\020\003\022\013\n\007SUCCESS\020\004\022\r\n\tCOMPLETE" + "D\020\005\022\n\n\006FAILED\020\006\022\017\n\013FAILED_RISK\020\007\022\025\n\021FAIL" + "ED_PROCESSING\020\010\022\036\n\032FAILED_RECEIVER_PROCE" + "SSING\020\t\022\r\n\tFAILED_DA\020\n\022\023\n\017FAILED_DA_FINA" + "L\020\013\022\020\n\014REFUNDED_TXN\020\014\022\021\n\rREFUND_FAILED\020\r" + "\022\034\n\030REFUND_FAILED_PROCESSING\020\016\022\024\n\020REFUND" + "_FAILED_DA\020\017\022\017\n\013EXPIRED_TXN\020\020\022\021\n\rAUTH_CA" + "NCELED\020\021\022!\n\035AUTH_CANCEL_FAILED_PROCESSIN" + "G\020\022\022\026\n\022AUTH_CANCEL_FAILED\020\023\022\020\n\014COLLECT_I" + "NIT\020\024\022\023\n\017COLLECT_SUCCESS\020\025\022\022\n\016COLLECT_FA" + "ILED\020\026\022\027\n\023COLLECT_FAILED_RISK\020\027\022\024\n\020COLLE" + "CT_REJECTED\020\030\022\023\n\017COLLECT_EXPIRED\020\031\022\024\n\020CO" + "LLECT_CANCELED\020\032\022\026\n\022COLLECT_CANCELLING\020\033" + "\022\r\n\tIN_REVIEW\020\034\022\024\n\020REVERSAL_SUCCESS\020\035\022\024\n" + "\020REVERSAL_PENDING\020\036\022\022\n\016REFUND_PENDING\020\037\"" + "\315\001\n\022PendingKeyExchange\022\020\n\010sequence\030\001 \001(\r" + "\022\024\n\014localBaseKey\030\002 \001(\014\022\033\n\023localBaseKeyPr" + "ivate\030\003 \001(\014\022\027\n\017localRatchetKey\030\004 \001(\014\022\036\n\026" + "localRatchetKeyPrivate\030\005 \001(\014\022\030\n\020localIde" + "ntityKey\030\007 \001(\014\022\037\n\027localIdentityKeyPrivat" + "e\030\010 \001(\014\"J\n\rPendingPreKey\022\020\n\010preKeyId\030\001 \001" + "(\r\022\026\n\016signedPreKeyId\030\003 \001(\005\022\017\n\007baseKey\030\002 " + "\001(\014\"E\n\013PhotoChange\022\020\n\010oldPhoto\030\001 \001(\014\022\020\n\010" + "newPhoto\030\002 \001(\014\022\022\n\nnewPhotoId\030\003 \001(\r\"G\n\005Po" + "int\022\023\n\013xDeprecated\030\001 \001(\005\022\023\n\013yDeprecated\030" + "\002 \001(\005\022\t\n\001x\030\003 \001(\001\022\t\n\001y\030\004 \001(\001\"1\n\026PollAddit" + "ionalMetadata\022\027\n\017pollInvalidated\030\001 \001(\010\"1" + "\n\014PollEncValue\022\022\n\nencPayload\030\001 \001(\014\022\r\n\005en" + "cIv\030\002 \001(\014\"\206\001\n\nPollUpdate\022/\n\024pollUpdateMe" + "ssageKey\030\001 \001(\0132\021.proto.MessageKey\022,\n\004vot" + "e\030\002 \001(\0132\036.proto.Message.PollVoteMessage\022" + "\031\n\021senderTimestampMs\030\003 \001(\003\"J\n\025PreKeyReco" + "rdStructure\022\n\n\002id\030\001 \001(\r\022\021\n\tpublicKey\030\002 \001" + "(\014\022\022\n\nprivateKey\030\003 \001(\014\"(\n\010Pushname\022\n\n\002id" + "\030\001 \001(\t\022\020\n\010pushname\030\002 \001(\t\"x\n\010Reaction\022\036\n\003" + "key\030\001 \001(\0132\021.proto.MessageKey\022\014\n\004text\030\002 \001" + "(\t\022\023\n\013groupingKey\030\003 \001(\t\022\031\n\021senderTimesta" + "mpMs\030\004 \001(\003\022\016\n\006unread\030\005 \001(\010\"2\n\021RecentEmoj" + "iWeight\022\r\n\005emoji\030\001 \001(\t\022\016\n\006weight\030\002 \001(\002\"u" + "\n\017RecordStructure\022/\n\016currentSession\030\001 \001(" + "\0132\027.proto.SessionStructure\0221\n\020previousSe" + "ssions\030\002 \003(\0132\027.proto.SessionStructure\"1\n" + "\016SenderChainKey\022\021\n\titeration\030\001 \001(\r\022\014\n\004se" + "ed\030\002 \001(\014\"S\n\030SenderKeyRecordStructure\0227\n\017" + "senderKeyStates\030\001 \003(\0132\036.proto.SenderKeyS" + "tateStructure\"\304\001\n\027SenderKeyStateStructur" + "e\022\023\n\013senderKeyId\030\001 \001(\r\022-\n\016senderChainKey" + "\030\002 \001(\0132\025.proto.SenderChainKey\0221\n\020senderS" + "igningKey\030\003 \001(\0132\027.proto.SenderSigningKey" + "\0222\n\021senderMessageKeys\030\004 \003(\0132\027.proto.Send" + "erMessageKey\"3\n\020SenderMessageKey\022\021\n\titer" + "ation\030\001 \001(\r\022\014\n\004seed\030\002 \001(\014\"3\n\020SenderSigni" + "ngKey\022\016\n\006public\030\001 \001(\014\022\017\n\007private\030\002 \001(\014\"&" + "\n\022ServerErrorReceipt\022\020\n\010stanzaId\030\001 \001(\t\"\243" + "\003\n\020SessionStructure\022\026\n\016sessionVersion\030\001 " + "\001(\r\022\033\n\023localIdentityPublic\030\002 \001(\014\022\034\n\024remo" + "teIdentityPublic\030\003 \001(\014\022\017\n\007rootKey\030\004 \001(\014\022" + "\027\n\017previousCounter\030\005 \001(\r\022!\n\013senderChain\030" + "\006 \001(\0132\014.proto.Chain\022$\n\016receiverChains\030\007 " + "\003(\0132\014.proto.Chain\0225\n\022pendingKeyExchange\030" + "\010 \001(\0132\031.proto.PendingKeyExchange\022+\n\rpend" + "ingPreKey\030\t \001(\0132\024.proto.PendingPreKey\022\034\n" + "\024remoteRegistrationId\030\n \001(\r\022\033\n\023localRegi" + "strationId\030\013 \001(\r\022\024\n\014needsRefresh\030\014 \001(\010\022\024" + "\n\014aliceBaseKey\030\r \001(\014\"v\n\033SignedPreKeyReco" + "rdStructure\022\n\n\002id\030\001 \001(\r\022\021\n\tpublicKey\030\002 \001" + "(\014\022\022\n\nprivateKey\030\003 \001(\014\022\021\n\tsignature\030\004 \001(" + "\014\022\021\n\ttimestamp\030\005 \001(\006\"D\n\tStatusPSA\022\022\n\ncam" + "paignId\030, \002(\004\022#\n\033campaignExpirationTimes" + "tamp\030- \001(\004\"\304\001\n\017StickerMetadata\022\013\n\003url\030\001 " + "\001(\t\022\022\n\nfileSha256\030\002 \001(\014\022\025\n\rfileEncSha256" + "\030\003 \001(\014\022\020\n\010mediaKey\030\004 \001(\014\022\020\n\010mimetype\030\005 \001" + "(\t\022\016\n\006height\030\006 \001(\r\022\r\n\005width\030\007 \001(\r\022\022\n\ndir" + "ectPath\030\010 \001(\t\022\022\n\nfileLength\030\t \001(\004\022\016\n\006wei" + "ght\030\n \001(\002\"h\n\016SyncActionData\022\r\n\005index\030\001 \001" + "(\014\022%\n\005value\030\002 \001(\0132\026.proto.SyncActionValu" + "e\022\017\n\007padding\030\003 \001(\014\022\017\n\007version\030\004 \001(\005\"\235\036\n\017" + "SyncActionValue\022\021\n\ttimestamp\030\001 \001(\003\0225\n\nst" + "arAction\030\002 \001(\0132!.proto.SyncActionValue.S" + "tarAction\022;\n\rcontactAction\030\003 \001(\0132$.proto" + ".SyncActionValue.ContactAction\0225\n\nmuteAc" + "tion\030\004 \001(\0132!.proto.SyncActionValue.MuteA" + "ction\0223\n\tpinAction\030\005 \001(\0132 .proto.SyncAct" + "ionValue.PinAction\022W\n\033securityNotificati" + "onSetting\030\006 \001(\01322.proto.SyncActionValue." + "SecurityNotificationSetting\022\?\n\017pushNameS" + "etting\030\007 \001(\0132&.proto.SyncActionValue.Pus" + "hNameSetting\022A\n\020quickReplyAction\030\010 \001(\0132\'" + ".proto.SyncActionValue.QuickReplyAction\022" + "Q\n\030recentEmojiWeightsAction\030\013 \001(\0132/.prot" + "o.SyncActionValue.RecentEmojiWeightsActi" + "on\022\?\n\017labelEditAction\030\016 \001(\0132&.proto.Sync" + "ActionValue.LabelEditAction\022M\n\026labelAsso" + "ciationAction\030\017 \001(\0132-.proto.SyncActionVa" + "lue.LabelAssociationAction\022;\n\rlocaleSett" + "ing\030\020 \001(\0132$.proto.SyncActionValue.Locale" + "Setting\022C\n\021archiveChatAction\030\021 \001(\0132(.pro" + "to.SyncActionValue.ArchiveChatAction\022Q\n\030" + "deleteMessageForMeAction\030\022 \001(\0132/.proto.S" + "yncActionValue.DeleteMessageForMeAction\022" + ";\n\rkeyExpiration\030\023 \001(\0132$.proto.SyncActio" + "nValue.KeyExpiration\022I\n\024markChatAsReadAc" + "tion\030\024 \001(\0132+.proto.SyncActionValue.MarkC" + "hatAsReadAction\022\?\n\017clearChatAction\030\025 \001(\013" + "2&.proto.SyncActionValue.ClearChatAction" + "\022A\n\020deleteChatAction\030\026 \001(\0132\'.proto.SyncA" + "ctionValue.DeleteChatAction\022K\n\025unarchive" + "ChatsSetting\030\027 \001(\0132,.proto.SyncActionVal" + "ue.UnarchiveChatsSetting\022=\n\016primaryFeatu" + "re\030\030 \001(\0132%.proto.SyncActionValue.Primary" + "Feature\022S\n\031androidUnsupportedActions\030\032 \001" + "(\01320.proto.SyncActionValue.AndroidUnsupp" + "ortedActions\0227\n\013agentAction\030\033 \001(\0132\".prot" + "o.SyncActionValue.AgentAction\022E\n\022subscri" + "ptionAction\030\034 \001(\0132).proto.SyncActionValu" + "e.SubscriptionAction\022I\n\024userStatusMuteAc" + "tion\030\035 \001(\0132+.proto.SyncActionValue.UserS" + "tatusMuteAction\022A\n\020timeFormatAction\030\036 \001(" + "\0132\'.proto.SyncActionValue.TimeFormatActi" + "on\0223\n\tnuxAction\030\037 \001(\0132 .proto.SyncAction" + "Value.NuxAction\022I\n\024primaryVersionAction\030" + " \001(\0132+.proto.SyncActionValue.PrimaryVer" + "sionAction\022;\n\rstickerAction\030! \001(\0132$.prot" + "o.SyncActionValue.StickerAction\032@\n\013Agent" + "Action\022\014\n\004name\030\001 \001(\t\022\020\n\010deviceID\030\002 \001(\005\022\021" + "\n\tisDeleted\030\003 \001(\010\032,\n\031AndroidUnsupportedA" + "ctions\022\017\n\007allowed\030\001 \001(\010\032j\n\021ArchiveChatAc" + "tion\022\020\n\010archived\030\001 \001(\010\022C\n\014messageRange\030\002" + " \001(\0132-.proto.SyncActionValue.SyncActionM" + "essageRange\032V\n\017ClearChatAction\022C\n\014messag" + "eRange\030\001 \001(\0132-.proto.SyncActionValue.Syn" + "cActionMessageRange\0324\n\rContactAction\022\020\n\010" + "fullName\030\001 \001(\t\022\021\n\tfirstName\030\002 \001(\t\032W\n\020Del" + "eteChatAction\022C\n\014messageRange\030\001 \001(\0132-.pr" + "oto.SyncActionValue.SyncActionMessageRan" + "ge\032I\n\030DeleteMessageForMeAction\022\023\n\013delete" + "Media\030\001 \001(\010\022\030\n\020messageTimestamp\030\002 \001(\003\032(\n" + "\rKeyExpiration\022\027\n\017expiredKeyEpoch\030\001 \001(\005\032" + ")\n\026LabelAssociationAction\022\017\n\007labeled\030\001 \001" + "(\010\032U\n\017LabelEditAction\022\014\n\004name\030\001 \001(\t\022\r\n\005c" + "olor\030\002 \001(\005\022\024\n\014predefinedId\030\003 \001(\005\022\017\n\007dele" + "ted\030\004 \001(\010\032\037\n\rLocaleSetting\022\016\n\006locale\030\001 \001" + "(\t\032i\n\024MarkChatAsReadAction\022\014\n\004read\030\001 \001(\010" + "\022C\n\014messageRange\030\002 \001(\0132-.proto.SyncActio" + "nValue.SyncActionMessageRange\0325\n\nMuteAct" + "ion\022\r\n\005muted\030\001 \001(\010\022\030\n\020muteEndTimestamp\030\002" + " \001(\003\032!\n\tNuxAction\022\024\n\014acknowledged\030\001 \001(\010\032" + "\033\n\tPinAction\022\016\n\006pinned\030\001 \001(\010\032\037\n\016PrimaryF" + "eature\022\r\n\005flags\030\001 \003(\t\032\'\n\024PrimaryVersionA" + "ction\022\017\n\007version\030\001 \001(\t\032\037\n\017PushNameSettin" + "g\022\014\n\004name\030\001 \001(\t\032g\n\020QuickReplyAction\022\020\n\010s" + "hortcut\030\001 \001(\t\022\017\n\007message\030\002 \001(\t\022\020\n\010keywor" + "ds\030\003 \003(\t\022\r\n\005count\030\004 \001(\005\022\017\n\007deleted\030\005 \001(\010" + "\032E\n\030RecentEmojiWeightsAction\022)\n\007weights\030" + "\001 \003(\0132\030.proto.RecentEmojiWeight\0327\n\033Secur" + "ityNotificationSetting\022\030\n\020showNotificati" + "on\030\001 \001(\010\032\035\n\nStarAction\022\017\n\007starred\030\001 \001(\010\032" + "\310\001\n\rStickerAction\022\013\n\003url\030\001 \001(\t\022\025\n\rfileEn" + "cSha256\030\002 \001(\014\022\020\n\010mediaKey\030\003 \001(\014\022\020\n\010mimet" + "ype\030\004 \001(\t\022\016\n\006height\030\005 \001(\r\022\r\n\005width\030\006 \001(\r" + "\022\022\n\ndirectPath\030\007 \001(\t\022\022\n\nfileLength\030\010 \001(\004" + "\022\022\n\nisFavorite\030\t \001(\010\022\024\n\014deviceIdHint\030\n \001" + "(\r\032[\n\022SubscriptionAction\022\025\n\risDeactivate" + "d\030\001 \001(\010\022\026\n\016isAutoRenewing\030\002 \001(\010\022\026\n\016expir" + "ationDate\030\003 \001(\003\032\226\001\n\026SyncActionMessageRan" + "ge\022\034\n\024lastMessageTimestamp\030\001 \001(\003\022\"\n\032last" + "SystemMessageTimestamp\030\002 \001(\003\022:\n\010messages" + "\030\003 \003(\0132(.proto.SyncActionValue.SyncActio" + "nMessage\032F\n\021SyncActionMessage\022\036\n\003key\030\001 \001" + "(\0132\021.proto.MessageKey\022\021\n\ttimestamp\030\002 \001(\003" + "\0329\n\020TimeFormatAction\022%\n\035isTwentyFourHour" + "FormatEnabled\030\001 \001(\010\032/\n\025UnarchiveChatsSet" + "ting\022\026\n\016unarchiveChats\030\001 \001(\010\032%\n\024UserStat" + "usMuteAction\022\r\n\005muted\030\001 \001(\010\"\032\n\nSyncdInde" + "x\022\014\n\004blob\030\001 \001(\014\"\222\001\n\rSyncdMutation\0226\n\tope" + "ration\030\001 \001(\0162#.proto.SyncdMutation.Syncd" + "Operation\022\"\n\006record\030\002 \001(\0132\022.proto.SyncdR" + "ecord\"%\n\016SyncdOperation\022\007\n\003SET\020\000\022\n\n\006REMO" + "VE\020\001\"9\n\016SyncdMutations\022\'\n\tmutations\030\001 \003(" + "\0132\024.proto.SyncdMutation\"\220\002\n\nSyncdPatch\022$" + "\n\007version\030\001 \001(\0132\023.proto.SyncdVersion\022\'\n\t" + "mutations\030\002 \003(\0132\024.proto.SyncdMutation\0227\n" + "\021externalMutations\030\003 \001(\0132\034.proto.Externa" + "lBlobReference\022\023\n\013snapshotMac\030\004 \001(\014\022\020\n\010p" + "atchMac\030\005 \001(\014\022\033\n\005keyId\030\006 \001(\0132\014.proto.Key" + "Id\022!\n\010exitCode\030\007 \001(\0132\017.proto.ExitCode\022\023\n" + "\013deviceIndex\030\010 \001(\r\"n\n\013SyncdRecord\022 \n\005ind" + "ex\030\001 \001(\0132\021.proto.SyncdIndex\022 \n\005value\030\002 \001" + "(\0132\021.proto.SyncdValue\022\033\n\005keyId\030\003 \001(\0132\014.p" + "roto.KeyId\"\204\001\n\rSyncdSnapshot\022$\n\007version\030" + "\001 \001(\0132\023.proto.SyncdVersion\022#\n\007records\030\002 " + "\003(\0132\022.proto.SyncdRecord\022\013\n\003mac\030\003 \001(\014\022\033\n\005" + "keyId\030\004 \001(\0132\014.proto.KeyId\"\032\n\nSyncdValue\022" + "\014\n\004blob\030\001 \001(\014\"\037\n\014SyncdVersion\022\017\n\007version" + "\030\001 \001(\004\"\300\004\n\016TemplateButton\022\r\n\005index\030\004 \001(\r" + "\022B\n\020quickReplyButton\030\001 \001(\0132&.proto.Templ" + "ateButton.QuickReplyButtonH\000\0224\n\turlButto" + "n\030\002 \001(\0132\037.proto.TemplateButton.URLButton" + "H\000\0226\n\ncallButton\030\003 \001(\0132 .proto.TemplateB" + "utton.CallButtonH\000\032\206\001\n\nCallButton\022;\n\013dis" + "playText\030\001 \001(\0132&.proto.Message.HighlyStr" + "ucturedMessage\022;\n\013phoneNumber\030\002 \001(\0132&.pr" + "oto.Message.HighlyStructuredMessage\032[\n\020Q" + "uickReplyButton\022;\n\013displayText\030\001 \001(\0132&.p" + "roto.Message.HighlyStructuredMessage\022\n\n\002" + "id\030\002 \001(\t\032}\n\tURLButton\022;\n\013displayText\030\001 \001" + "(\0132&.proto.Message.HighlyStructuredMessa" + "ge\0223\n\003url\030\002 \001(\0132&.proto.Message.HighlySt" + "ructuredMessageB\010\n\006button\"\236\001\n\013UserReceip" + "t\022\017\n\007userJid\030\001 \002(\t\022\030\n\020receiptTimestamp\030\002" + " \001(\003\022\025\n\rreadTimestamp\030\003 \001(\003\022\027\n\017playedTim" + "estamp\030\004 \001(\003\022\030\n\020pendingDeviceJid\030\005 \003(\t\022\032" + "\n\022deliveredDeviceJid\030\006 \003(\t\"\331\001\n\027VerifiedN" + "ameCertificate\022\017\n\007details\030\001 \001(\014\022\021\n\tsigna" + "ture\030\002 \001(\014\022\027\n\017serverSignature\030\003 \001(\014\032\200\001\n\007" + "Details\022\016\n\006serial\030\001 \001(\004\022\016\n\006issuer\030\002 \001(\t\022" + "\024\n\014verifiedName\030\004 \001(\t\022,\n\016localizedNames\030" + "\010 \003(\0132\024.proto.LocalizedName\022\021\n\tissueTime" + "\030\n \001(\004\"6\n\021WallpaperSettings\022\020\n\010filename\030" + "\001 \001(\t\022\017\n\007opacity\030\002 \001(\r\"\333\022\n\013WebFeatures\022." + "\n\rlabelsDisplay\030\001 \001(\0162\027.proto.WebFeature" + "s.Flag\0227\n\026voipIndividualOutgoing\030\002 \001(\0162\027" + ".proto.WebFeatures.Flag\022)\n\010groupsV3\030\003 \001(" + "\0162\027.proto.WebFeatures.Flag\022/\n\016groupsV3Cr" + "eate\030\004 \001(\0162\027.proto.WebFeatures.Flag\022/\n\016c" + "hangeNumberV2\030\005 \001(\0162\027.proto.WebFeatures." + "Flag\0227\n\026queryStatusV3Thumbnail\030\006 \001(\0162\027.p" + "roto.WebFeatures.Flag\022.\n\rliveLocations\030\007" + " \001(\0162\027.proto.WebFeatures.Flag\022+\n\nqueryVn" + "ame\030\010 \001(\0162\027.proto.WebFeatures.Flag\0227\n\026vo" + "ipIndividualIncoming\030\t \001(\0162\027.proto.WebFe" + "atures.Flag\0222\n\021quickRepliesQuery\030\n \001(\0162\027" + ".proto.WebFeatures.Flag\022)\n\010payments\030\013 \001(" + "\0162\027.proto.WebFeatures.Flag\0221\n\020stickerPac" + "kQuery\030\014 \001(\0162\027.proto.WebFeatures.Flag\0223\n" + "\022liveLocationsFinal\030\r \001(\0162\027.proto.WebFea" + "tures.Flag\022+\n\nlabelsEdit\030\016 \001(\0162\027.proto.W" + "ebFeatures.Flag\022,\n\013mediaUpload\030\017 \001(\0162\027.p" + "roto.WebFeatures.Flag\022<\n\033mediaUploadRich" + "QuickReplies\030\022 \001(\0162\027.proto.WebFeatures.F" + "lag\022(\n\007vnameV2\030\023 \001(\0162\027.proto.WebFeatures" + ".Flag\0221\n\020videoPlaybackUrl\030\024 \001(\0162\027.proto." + "WebFeatures.Flag\022.\n\rstatusRanking\030\025 \001(\0162" + "\027.proto.WebFeatures.Flag\0224\n\023voipIndividu" + "alVideo\030\026 \001(\0162\027.proto.WebFeatures.Flag\0223" + "\n\022thirdPartyStickers\030\027 \001(\0162\027.proto.WebFe" + "atures.Flag\022;\n\032frequentlyForwardedSettin" + "g\030\030 \001(\0162\027.proto.WebFeatures.Flag\0227\n\026grou" + "psV4JoinPermission\030\031 \001(\0162\027.proto.WebFeat" + "ures.Flag\022/\n\016recentStickers\030\032 \001(\0162\027.prot" + "o.WebFeatures.Flag\022(\n\007catalog\030\033 \001(\0162\027.pr" + "oto.WebFeatures.Flag\0220\n\017starredStickers\030" + "\034 \001(\0162\027.proto.WebFeatures.Flag\022.\n\rvoipGr" + "oupCall\030\035 \001(\0162\027.proto.WebFeatures.Flag\0220" + "\n\017templateMessage\030\036 \001(\0162\027.proto.WebFeatu" + "res.Flag\022=\n\034templateMessageInteractivity" + "\030\037 \001(\0162\027.proto.WebFeatures.Flag\0222\n\021ephem" + "eralMessages\030 \001(\0162\027.proto.WebFeatures.F" + "lag\0224\n\023e2ENotificationSync\030! \001(\0162\027.proto" + ".WebFeatures.Flag\0221\n\020recentStickersV2\030\" " + "\001(\0162\027.proto.WebFeatures.Flag\0221\n\020recentSt" + "ickersV3\030$ \001(\0162\027.proto.WebFeatures.Flag\022" + "+\n\nuserNotice\030% \001(\0162\027.proto.WebFeatures." + "Flag\022(\n\007support\030\' \001(\0162\027.proto.WebFeature" + "s.Flag\0220\n\017groupUiiCleanup\030( \001(\0162\027.proto." + "WebFeatures.Flag\022<\n\033groupDogfoodingInter" + "nalOnly\030) \001(\0162\027.proto.WebFeatures.Flag\022-" + "\n\014settingsSync\030* \001(\0162\027.proto.WebFeatures" + ".Flag\022*\n\tarchiveV2\030+ \001(\0162\027.proto.WebFeat" + "ures.Flag\022;\n\032ephemeralAllowGroupMembers\030" + ", \001(\0162\027.proto.WebFeatures.Flag\0225\n\024epheme" + "ral24HDuration\030- \001(\0162\027.proto.WebFeatures" + ".Flag\022/\n\016mdForceUpgrade\030. \001(\0162\027.proto.We" + "bFeatures.Flag\0221\n\020disappearingMode\030/ \001(\016" + "2\027.proto.WebFeatures.Flag\0229\n\030externalMdO" + "ptInAvailable\0300 \001(\0162\027.proto.WebFeatures." + "Flag\0229\n\030noDeleteMessageTimeLimit\0301 \001(\0162\027" + ".proto.WebFeatures.Flag\"K\n\004Flag\022\017\n\013NOT_S" + "TARTED\020\000\022\021\n\rFORCE_UPGRADE\020\001\022\017\n\013DEVELOPME" + "NT\020\002\022\016\n\nPRODUCTION\020\003\"\2424\n\016WebMessageInfo\022" + "\036\n\003key\030\001 \002(\0132\021.proto.MessageKey\022\037\n\007messa" + "ge\030\002 \001(\0132\016.proto.Message\022\030\n\020messageTimes" + "tamp\030\003 \001(\004\022,\n\006status\030\004 \001(\0162\034.proto.WebMe" + "ssageInfo.Status\022\023\n\013participant\030\005 \001(\t\022\033\n" + "\023messageC2STimestamp\030\006 \001(\004\022\016\n\006ignore\030\020 \001" + "(\010\022\017\n\007starred\030\021 \001(\010\022\021\n\tbroadcast\030\022 \001(\010\022\020" + "\n\010pushName\030\023 \001(\t\022\035\n\025mediaCiphertextSha25" + "6\030\024 \001(\014\022\021\n\tmulticast\030\025 \001(\010\022\017\n\007urlText\030\026 " + "\001(\010\022\021\n\turlNumber\030\027 \001(\010\0227\n\017messageStubTyp" + "e\030\030 \001(\0162\036.proto.WebMessageInfo.StubType\022" + "\022\n\nclearMedia\030\031 \001(\010\022\035\n\025messageStubParame" + "ters\030\032 \003(\t\022\020\n\010duration\030\033 \001(\r\022\016\n\006labels\030\034" + " \003(\t\022\'\n\013paymentInfo\030\035 \001(\0132\022.proto.Paymen" + "tInfo\022=\n\021finalLiveLocation\030\036 \001(\0132\".proto" + ".Message.LiveLocationMessage\022-\n\021quotedPa" + "ymentInfo\030\037 \001(\0132\022.proto.PaymentInfo\022\037\n\027e" + "phemeralStartTimestamp\030 \001(\004\022\031\n\021ephemera" + "lDuration\030! \001(\r\022\030\n\020ephemeralOffToOn\030\" \001(" + "\010\022\032\n\022ephemeralOutOfSync\030# \001(\010\022@\n\020bizPriv" + "acyStatus\030$ \001(\0162&.proto.WebMessageInfo.B" + "izPrivacyStatus\022\027\n\017verifiedBizName\030% \001(\t" + "\022#\n\tmediaData\030& \001(\0132\020.proto.MediaData\022\'\n" + "\013photoChange\030\' \001(\0132\022.proto.PhotoChange\022\'" + "\n\013userReceipt\030( \003(\0132\022.proto.UserReceipt\022" + "\"\n\treactions\030) \003(\0132\017.proto.Reaction\022+\n\021q" + "uotedStickerData\030* \001(\0132\020.proto.MediaData" + "\022\027\n\017futureproofData\030+ \001(\014\022#\n\tstatusPsa\030," + " \001(\0132\020.proto.StatusPSA\022&\n\013pollUpdates\030- " + "\003(\0132\021.proto.PollUpdate\022=\n\026pollAdditional" + "Metadata\030. \001(\0132\035.proto.PollAdditionalMet" + "adata\022\017\n\007agentId\030/ \001(\t\022\033\n\023statusAlreadyV" + "iewed\0300 \001(\010\022\025\n\rmessageSecret\0301 \001(\014\022%\n\nke" + "epInChat\0302 \001(\0132\021.proto.KeepInChat\022\'\n\037ori" + "ginalSelfAuthorUserJidString\0303 \001(\t\022\036\n\026re" + "vokeMessageTimestamp\0304 \001(\004\"=\n\020BizPrivacy" + "Status\022\010\n\004E2EE\020\000\022\006\n\002FB\020\002\022\007\n\003BSP\020\001\022\016\n\nBSP" + "_AND_FB\020\003\"X\n\006Status\022\t\n\005ERROR\020\000\022\013\n\007PENDIN" + "G\020\001\022\016\n\nSERVER_ACK\020\002\022\020\n\014DELIVERY_ACK\020\003\022\010\n" + "\004READ\020\004\022\n\n\006PLAYED\020\005\"\213(\n\010StubType\022\013\n\007UNKN" + "OWN\020\000\022\n\n\006REVOKE\020\001\022\016\n\nCIPHERTEXT\020\002\022\017\n\013FUT" + "UREPROOF\020\003\022\033\n\027NON_VERIFIED_TRANSITION\020\004\022" + "\031\n\025UNVERIFIED_TRANSITION\020\005\022\027\n\023VERIFIED_T" + "RANSITION\020\006\022\030\n\024VERIFIED_LOW_UNKNOWN\020\007\022\021\n" + "\rVERIFIED_HIGH\020\010\022\034\n\030VERIFIED_INITIAL_UNK" + "NOWN\020\t\022\030\n\024VERIFIED_INITIAL_LOW\020\n\022\031\n\025VERI" + "FIED_INITIAL_HIGH\020\013\022#\n\037VERIFIED_TRANSITI" + "ON_ANY_TO_NONE\020\014\022#\n\037VERIFIED_TRANSITION_" + "ANY_TO_HIGH\020\r\022#\n\037VERIFIED_TRANSITION_HIG" + "H_TO_LOW\020\016\022\'\n#VERIFIED_TRANSITION_HIGH_T" + "O_UNKNOWN\020\017\022&\n\"VERIFIED_TRANSITION_UNKNO" + "WN_TO_LOW\020\020\022&\n\"VERIFIED_TRANSITION_LOW_T" + "O_UNKNOWN\020\021\022#\n\037VERIFIED_TRANSITION_NONE_" + "TO_LOW\020\022\022\'\n#VERIFIED_TRANSITION_NONE_TO_" + "UNKNOWN\020\023\022\020\n\014GROUP_CREATE\020\024\022\030\n\024GROUP_CHA" + "NGE_SUBJECT\020\025\022\025\n\021GROUP_CHANGE_ICON\020\026\022\034\n\030" + "GROUP_CHANGE_INVITE_LINK\020\027\022\034\n\030GROUP_CHAN" + "GE_DESCRIPTION\020\030\022\031\n\025GROUP_CHANGE_RESTRIC" + "T\020\031\022\031\n\025GROUP_CHANGE_ANNOUNCE\020\032\022\031\n\025GROUP_" + "PARTICIPANT_ADD\020\033\022\034\n\030GROUP_PARTICIPANT_R" + "EMOVE\020\034\022\035\n\031GROUP_PARTICIPANT_PROMOTE\020\035\022\034" + "\n\030GROUP_PARTICIPANT_DEMOTE\020\036\022\034\n\030GROUP_PA" + "RTICIPANT_INVITE\020\037\022\033\n\027GROUP_PARTICIPANT_" + "LEAVE\020 \022#\n\037GROUP_PARTICIPANT_CHANGE_NUMB" + "ER\020!\022\024\n\020BROADCAST_CREATE\020\"\022\021\n\rBROADCAST_" + "ADD\020#\022\024\n\020BROADCAST_REMOVE\020$\022\030\n\024GENERIC_N" + "OTIFICATION\020%\022\030\n\024E2E_IDENTITY_CHANGED\020&\022" + "\021\n\rE2E_ENCRYPTED\020\'\022\025\n\021CALL_MISSED_VOICE\020" + "(\022\025\n\021CALL_MISSED_VIDEO\020)\022\034\n\030INDIVIDUAL_C" + "HANGE_NUMBER\020*\022\020\n\014GROUP_DELETE\020+\022&\n\"GROU" + "P_ANNOUNCE_MODE_MESSAGE_BOUNCE\020,\022\033\n\027CALL" + "_MISSED_GROUP_VOICE\020-\022\033\n\027CALL_MISSED_GRO" + "UP_VIDEO\020.\022\026\n\022PAYMENT_CIPHERTEXT\020/\022\027\n\023PA" + "YMENT_FUTUREPROOF\0200\022,\n(PAYMENT_TRANSACTI" + "ON_STATUS_UPDATE_FAILED\0201\022.\n*PAYMENT_TRA" + "NSACTION_STATUS_UPDATE_REFUNDED\0202\0223\n/PAY" + "MENT_TRANSACTION_STATUS_UPDATE_REFUND_FA" + "ILED\0203\0225\n1PAYMENT_TRANSACTION_STATUS_REC" + "EIVER_PENDING_SETUP\0204\022<\n8PAYMENT_TRANSAC" + "TION_STATUS_RECEIVER_SUCCESS_AFTER_HICCU" + "P\0205\022)\n%PAYMENT_ACTION_ACCOUNT_SETUP_REMI" + "NDER\0206\022(\n$PAYMENT_ACTION_SEND_PAYMENT_RE" + "MINDER\0207\022*\n&PAYMENT_ACTION_SEND_PAYMENT_" + "INVITATION\0208\022#\n\037PAYMENT_ACTION_REQUEST_D" + "ECLINED\0209\022\"\n\036PAYMENT_ACTION_REQUEST_EXPI" + "RED\020:\022$\n PAYMENT_ACTION_REQUEST_CANCELLE" + "D\020;\022)\n%BIZ_VERIFIED_TRANSITION_TOP_TO_BO" + "TTOM\020<\022)\n%BIZ_VERIFIED_TRANSITION_BOTTOM" + "_TO_TOP\020=\022\021\n\rBIZ_INTRO_TOP\020>\022\024\n\020BIZ_INTR" + "O_BOTTOM\020\?\022\023\n\017BIZ_NAME_CHANGE\020@\022\034\n\030BIZ_M" + "OVE_TO_CONSUMER_APP\020A\022\036\n\032BIZ_TWO_TIER_MI" + "GRATION_TOP\020B\022!\n\035BIZ_TWO_TIER_MIGRATION_" + "BOTTOM\020C\022\r\n\tOVERSIZED\020D\022(\n$GROUP_CHANGE_" + "NO_FREQUENTLY_FORWARDED\020E\022\034\n\030GROUP_V4_AD" + "D_INVITE_SENT\020F\022&\n\"GROUP_PARTICIPANT_ADD" + "_REQUEST_JOIN\020G\022\034\n\030CHANGE_EPHEMERAL_SETT" + "ING\020H\022\026\n\022E2E_DEVICE_CHANGED\020I\022\017\n\013VIEWED_" + "ONCE\020J\022\025\n\021E2E_ENCRYPTED_NOW\020K\022\"\n\036BLUE_MS" + "G_BSP_FB_TO_BSP_PREMISE\020L\022\036\n\032BLUE_MSG_BS" + "P_FB_TO_SELF_FB\020M\022#\n\037BLUE_MSG_BSP_FB_TO_" + "SELF_PREMISE\020N\022\036\n\032BLUE_MSG_BSP_FB_UNVERI" + "FIED\020O\0227\n3BLUE_MSG_BSP_FB_UNVERIFIED_TO_" + "SELF_PREMISE_VERIFIED\020P\022\034\n\030BLUE_MSG_BSP_" + "FB_VERIFIED\020Q\0227\n3BLUE_MSG_BSP_FB_VERIFIE" + "D_TO_SELF_PREMISE_UNVERIFIED\020R\022(\n$BLUE_M" + "SG_BSP_PREMISE_TO_SELF_PREMISE\020S\022#\n\037BLUE" + "_MSG_BSP_PREMISE_UNVERIFIED\020T\022<\n8BLUE_MS" + "G_BSP_PREMISE_UNVERIFIED_TO_SELF_PREMISE" + "_VERIFIED\020U\022!\n\035BLUE_MSG_BSP_PREMISE_VERI" + "FIED\020V\022<\n8BLUE_MSG_BSP_PREMISE_VERIFIED_" + "TO_SELF_PREMISE_UNVERIFIED\020W\022*\n&BLUE_MSG" + "_CONSUMER_TO_BSP_FB_UNVERIFIED\020X\022/\n+BLUE" + "_MSG_CONSUMER_TO_BSP_PREMISE_UNVERIFIED\020" + "Y\022+\n\'BLUE_MSG_CONSUMER_TO_SELF_FB_UNVERI" + "FIED\020Z\0220\n,BLUE_MSG_CONSUMER_TO_SELF_PREM" + "ISE_UNVERIFIED\020[\022#\n\037BLUE_MSG_SELF_FB_TO_" + "BSP_PREMISE\020\\\022$\n BLUE_MSG_SELF_FB_TO_SEL" + "F_PREMISE\020]\022\037\n\033BLUE_MSG_SELF_FB_UNVERIFI" + "ED\020^\0228\n4BLUE_MSG_SELF_FB_UNVERIFIED_TO_S" + "ELF_PREMISE_VERIFIED\020_\022\035\n\031BLUE_MSG_SELF_" + "FB_VERIFIED\020`\0228\n4BLUE_MSG_SELF_FB_VERIFI" + "ED_TO_SELF_PREMISE_UNVERIFIED\020a\022(\n$BLUE_" + "MSG_SELF_PREMISE_TO_BSP_PREMISE\020b\022$\n BLU" + "E_MSG_SELF_PREMISE_UNVERIFIED\020c\022\"\n\036BLUE_" + "MSG_SELF_PREMISE_VERIFIED\020d\022\026\n\022BLUE_MSG_" + "TO_BSP_FB\020e\022\030\n\024BLUE_MSG_TO_CONSUMER\020f\022\027\n" + "\023BLUE_MSG_TO_SELF_FB\020g\022*\n&BLUE_MSG_UNVER" + "IFIED_TO_BSP_FB_VERIFIED\020h\022/\n+BLUE_MSG_U" + "NVERIFIED_TO_BSP_PREMISE_VERIFIED\020i\022+\n\'B" + "LUE_MSG_UNVERIFIED_TO_SELF_FB_VERIFIED\020j" + "\022#\n\037BLUE_MSG_UNVERIFIED_TO_VERIFIED\020k\022*\n" + "&BLUE_MSG_VERIFIED_TO_BSP_FB_UNVERIFIED\020" + "l\022/\n+BLUE_MSG_VERIFIED_TO_BSP_PREMISE_UN" + "VERIFIED\020m\022+\n\'BLUE_MSG_VERIFIED_TO_SELF_" + "FB_UNVERIFIED\020n\022#\n\037BLUE_MSG_VERIFIED_TO_" + "UNVERIFIED\020o\0226\n2BLUE_MSG_BSP_FB_UNVERIFI" + "ED_TO_BSP_PREMISE_VERIFIED\020p\0222\n.BLUE_MSG" + "_BSP_FB_UNVERIFIED_TO_SELF_FB_VERIFIED\020q" + "\0226\n2BLUE_MSG_BSP_FB_VERIFIED_TO_BSP_PREM" + "ISE_UNVERIFIED\020r\0222\n.BLUE_MSG_BSP_FB_VERI" + "FIED_TO_SELF_FB_UNVERIFIED\020s\0227\n3BLUE_MSG" + "_SELF_FB_UNVERIFIED_TO_BSP_PREMISE_VERIF" + "IED\020t\0227\n3BLUE_MSG_SELF_FB_VERIFIED_TO_BS" + "P_PREMISE_UNVERIFIED\020u\022\034\n\030E2E_IDENTITY_U" + "NAVAILABLE\020v\022\022\n\016GROUP_CREATING\020w\022\027\n\023GROU" + "P_CREATE_FAILED\020x\022\021\n\rGROUP_BOUNCED\020y\022\021\n\r" + "BLOCK_CONTACT\020z\022!\n\035EPHEMERAL_SETTING_NOT" + "_APPLIED\020{\022\017\n\013SYNC_FAILED\020|\022\013\n\007SYNCING\020}" + "\022\034\n\030BIZ_PRIVACY_MODE_INIT_FB\020~\022\035\n\031BIZ_PR" + "IVACY_MODE_INIT_BSP\020\177\022\033\n\026BIZ_PRIVACY_MOD" + "E_TO_FB\020\200\001\022\034\n\027BIZ_PRIVACY_MODE_TO_BSP\020\201\001" + "\022\026\n\021DISAPPEARING_MODE\020\202\001\022\034\n\027E2E_DEVICE_F" + "ETCH_FAILED\020\203\001\022\021\n\014ADMIN_REVOKE\020\204\001\022$\n\037GRO" + "UP_INVITE_LINK_GROWTH_LOCKED\020\205\001\022 \n\033COMMU" + "NITY_LINK_PARENT_GROUP\020\206\001\022!\n\034COMMUNITY_L" + "INK_SIBLING_GROUP\020\207\001\022\035\n\030COMMUNITY_LINK_S" + "UB_GROUP\020\210\001\022\"\n\035COMMUNITY_UNLINK_PARENT_G" + "ROUP\020\211\001\022#\n\036COMMUNITY_UNLINK_SIBLING_GROU" + "P\020\212\001\022\037\n\032COMMUNITY_UNLINK_SUB_GROUP\020\213\001\022\035\n" + "\030GROUP_PARTICIPANT_ACCEPT\020\214\001\022(\n#GROUP_PA" + "RTICIPANT_LINKED_GROUP_JOIN\020\215\001\022\025\n\020COMMUN" + "ITY_CREATE\020\216\001\022\033\n\026EPHEMERAL_KEEP_IN_CHAT\020" + "\217\001\022+\n&GROUP_MEMBERSHIP_JOIN_APPROVAL_REQ" + "UEST\020\220\001\022(\n#GROUP_MEMBERSHIP_JOIN_APPROVA" + "L_MODE\020\221\001\022\"\n\035INTEGRITY_UNLINK_PARENT_GRO" + "UP\020\222\001\022\"\n\035COMMUNITY_PARTICIPANT_PROMOTE\020\223" + "\001\022!\n\034COMMUNITY_PARTICIPANT_DEMOTE\020\224\001\022#\n\036" + "COMMUNITY_PARENT_GROUP_DELETED\020\225\001\"\211\001\n\024We" + "bNotificationsInfo\022\021\n\ttimestamp\030\002 \001(\004\022\023\n" + "\013unreadChats\030\003 \001(\r\022\032\n\022notifyMessageCount" + "\030\004 \001(\r\022-\n\016notifyMessages\030\005 \003(\0132\025.proto.W" + "ebMessageInfo*@\n\010KeepType\022\013\n\007UNKNOWN\020\000\022\020" + "\n\014KEEP_FOR_ALL\020\001\022\025\n\021UNDO_KEEP_FOR_ALL\020\002*" + "/\n\017MediaVisibility\022\013\n\007DEFAULT\020\000\022\007\n\003OFF\020\001" + "\022\006\n\002ON\020\002" + ; +static ::_pbi::once_flag descriptor_table_pmsg_2eproto_once; +const ::_pbi::DescriptorTable descriptor_table_pmsg_2eproto = { + false, false, 52848, descriptor_table_protodef_pmsg_2eproto, + "pmsg.proto", + &descriptor_table_pmsg_2eproto_once, nullptr, 0, 224, + schemas, file_default_instances, TableStruct_pmsg_2eproto::offsets, + file_level_metadata_pmsg_2eproto, file_level_enum_descriptors_pmsg_2eproto, + file_level_service_descriptors_pmsg_2eproto, +}; +PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_pmsg_2eproto_getter() { + return &descriptor_table_pmsg_2eproto; +} + +// Force running AddDescriptors() at dynamic initialization time. +PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_pmsg_2eproto(&descriptor_table_pmsg_2eproto); +namespace proto { +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizAccountLinkInfo_AccountType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[0]; +} +bool BizAccountLinkInfo_AccountType_IsValid(int value) { + switch (value) { + case 0: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr BizAccountLinkInfo_AccountType BizAccountLinkInfo::ENTERPRISE; +constexpr BizAccountLinkInfo_AccountType BizAccountLinkInfo::AccountType_MIN; +constexpr BizAccountLinkInfo_AccountType BizAccountLinkInfo::AccountType_MAX; +constexpr int BizAccountLinkInfo::AccountType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizAccountLinkInfo_HostStorageType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[1]; +} +bool BizAccountLinkInfo_HostStorageType_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr BizAccountLinkInfo_HostStorageType BizAccountLinkInfo::ON_PREMISE; +constexpr BizAccountLinkInfo_HostStorageType BizAccountLinkInfo::FACEBOOK; +constexpr BizAccountLinkInfo_HostStorageType BizAccountLinkInfo::HostStorageType_MIN; +constexpr BizAccountLinkInfo_HostStorageType BizAccountLinkInfo::HostStorageType_MAX; +constexpr int BizAccountLinkInfo::HostStorageType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizIdentityInfo_ActualActorsType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[2]; +} +bool BizIdentityInfo_ActualActorsType_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr BizIdentityInfo_ActualActorsType BizIdentityInfo::SELF; +constexpr BizIdentityInfo_ActualActorsType BizIdentityInfo::BSP; +constexpr BizIdentityInfo_ActualActorsType BizIdentityInfo::ActualActorsType_MIN; +constexpr BizIdentityInfo_ActualActorsType BizIdentityInfo::ActualActorsType_MAX; +constexpr int BizIdentityInfo::ActualActorsType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizIdentityInfo_HostStorageType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[3]; +} +bool BizIdentityInfo_HostStorageType_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr BizIdentityInfo_HostStorageType BizIdentityInfo::ON_PREMISE; +constexpr BizIdentityInfo_HostStorageType BizIdentityInfo::FACEBOOK; +constexpr BizIdentityInfo_HostStorageType BizIdentityInfo::HostStorageType_MIN; +constexpr BizIdentityInfo_HostStorageType BizIdentityInfo::HostStorageType_MAX; +constexpr int BizIdentityInfo::HostStorageType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizIdentityInfo_VerifiedLevelValue_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[4]; +} +bool BizIdentityInfo_VerifiedLevelValue_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr BizIdentityInfo_VerifiedLevelValue BizIdentityInfo::UNKNOWN; +constexpr BizIdentityInfo_VerifiedLevelValue BizIdentityInfo::LOW; +constexpr BizIdentityInfo_VerifiedLevelValue BizIdentityInfo::HIGH; +constexpr BizIdentityInfo_VerifiedLevelValue BizIdentityInfo::VerifiedLevelValue_MIN; +constexpr BizIdentityInfo_VerifiedLevelValue BizIdentityInfo::VerifiedLevelValue_MAX; +constexpr int BizIdentityInfo::VerifiedLevelValue_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_DNSSource_DNSResolutionMethod_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[5]; +} +bool ClientPayload_DNSSource_DNSResolutionMethod_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource::SYSTEM; +constexpr ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource::GOOGLE; +constexpr ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource::HARDCODED; +constexpr ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource::OVERRIDE; +constexpr ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource::FALLBACK; +constexpr ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource::DNSResolutionMethod_MIN; +constexpr ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource::DNSResolutionMethod_MAX; +constexpr int ClientPayload_DNSSource::DNSResolutionMethod_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_UserAgent_Platform_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[6]; +} +bool ClientPayload_UserAgent_Platform_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + case 10: + case 11: + case 12: + case 13: + case 14: + case 15: + case 16: + case 17: + case 18: + case 19: + case 20: + case 21: + case 22: + case 23: + case 24: + case 25: + case 26: + case 27: + case 28: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::ANDROID; +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::IOS; +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::WINDOWS_PHONE; +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::BLACKBERRY; +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::BLACKBERRYX; +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::S40; +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::S60; +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::PYTHON_CLIENT; +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::TIZEN; +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::ENTERPRISE; +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::SMB_ANDROID; +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::KAIOS; +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::SMB_IOS; +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::WINDOWS; +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::WEB; +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::PORTAL; +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::GREEN_ANDROID; +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::GREEN_IPHONE; +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::BLUE_ANDROID; +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::BLUE_IPHONE; +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::FBLITE_ANDROID; +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::MLITE_ANDROID; +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::IGLITE_ANDROID; +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::PAGE; +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::MACOS; +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::OCULUS_MSG; +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::OCULUS_CALL; +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::MILAN; +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::CAPI; +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::Platform_MIN; +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::Platform_MAX; +constexpr int ClientPayload_UserAgent::Platform_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_UserAgent_ReleaseChannel_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[7]; +} +bool ClientPayload_UserAgent_ReleaseChannel_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent::RELEASE; +constexpr ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent::BETA; +constexpr ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent::ALPHA; +constexpr ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent::DEBUG; +constexpr ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent::ReleaseChannel_MIN; +constexpr ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent::ReleaseChannel_MAX; +constexpr int ClientPayload_UserAgent::ReleaseChannel_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_WebInfo_WebSubPlatform_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[8]; +} +bool ClientPayload_WebInfo_WebSubPlatform_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo::WEB_BROWSER; +constexpr ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo::APP_STORE; +constexpr ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo::WIN_STORE; +constexpr ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo::DARWIN; +constexpr ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo::WINDA; +constexpr ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo::WebSubPlatform_MIN; +constexpr ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo::WebSubPlatform_MAX; +constexpr int ClientPayload_WebInfo::WebSubPlatform_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_ConnectReason_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[9]; +} +bool ClientPayload_ConnectReason_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr ClientPayload_ConnectReason ClientPayload::PUSH; +constexpr ClientPayload_ConnectReason ClientPayload::USER_ACTIVATED; +constexpr ClientPayload_ConnectReason ClientPayload::SCHEDULED; +constexpr ClientPayload_ConnectReason ClientPayload::ERROR_RECONNECT; +constexpr ClientPayload_ConnectReason ClientPayload::NETWORK_SWITCH; +constexpr ClientPayload_ConnectReason ClientPayload::PING_RECONNECT; +constexpr ClientPayload_ConnectReason ClientPayload::ConnectReason_MIN; +constexpr ClientPayload_ConnectReason ClientPayload::ConnectReason_MAX; +constexpr int ClientPayload::ConnectReason_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_ConnectType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[10]; +} +bool ClientPayload_ConnectType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 100: + case 101: + case 102: + case 103: + case 104: + case 105: + case 106: + case 107: + case 108: + case 109: + case 110: + case 111: + case 112: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_UNKNOWN; +constexpr ClientPayload_ConnectType ClientPayload::WIFI_UNKNOWN; +constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_EDGE; +constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_IDEN; +constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_UMTS; +constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_EVDO; +constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_GPRS; +constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_HSDPA; +constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_HSUPA; +constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_HSPA; +constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_CDMA; +constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_1XRTT; +constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_EHRPD; +constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_LTE; +constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_HSPAP; +constexpr ClientPayload_ConnectType ClientPayload::ConnectType_MIN; +constexpr ClientPayload_ConnectType ClientPayload::ConnectType_MAX; +constexpr int ClientPayload::ConnectType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_IOSAppExtension_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[11]; +} +bool ClientPayload_IOSAppExtension_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr ClientPayload_IOSAppExtension ClientPayload::SHARE_EXTENSION; +constexpr ClientPayload_IOSAppExtension ClientPayload::SERVICE_EXTENSION; +constexpr ClientPayload_IOSAppExtension ClientPayload::INTENTS_EXTENSION; +constexpr ClientPayload_IOSAppExtension ClientPayload::IOSAppExtension_MIN; +constexpr ClientPayload_IOSAppExtension ClientPayload::IOSAppExtension_MAX; +constexpr int ClientPayload::IOSAppExtension_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_Product_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[12]; +} +bool ClientPayload_Product_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr ClientPayload_Product ClientPayload::WHATSAPP; +constexpr ClientPayload_Product ClientPayload::MESSENGER; +constexpr ClientPayload_Product ClientPayload::Product_MIN; +constexpr ClientPayload_Product ClientPayload::Product_MAX; +constexpr int ClientPayload::Product_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ContextInfo_AdReplyInfo_MediaType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[13]; +} +bool ContextInfo_AdReplyInfo_MediaType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr ContextInfo_AdReplyInfo_MediaType ContextInfo_AdReplyInfo::NONE; +constexpr ContextInfo_AdReplyInfo_MediaType ContextInfo_AdReplyInfo::IMAGE; +constexpr ContextInfo_AdReplyInfo_MediaType ContextInfo_AdReplyInfo::VIDEO; +constexpr ContextInfo_AdReplyInfo_MediaType ContextInfo_AdReplyInfo::MediaType_MIN; +constexpr ContextInfo_AdReplyInfo_MediaType ContextInfo_AdReplyInfo::MediaType_MAX; +constexpr int ContextInfo_AdReplyInfo::MediaType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ContextInfo_ExternalAdReplyInfo_MediaType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[14]; +} +bool ContextInfo_ExternalAdReplyInfo_MediaType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr ContextInfo_ExternalAdReplyInfo_MediaType ContextInfo_ExternalAdReplyInfo::NONE; +constexpr ContextInfo_ExternalAdReplyInfo_MediaType ContextInfo_ExternalAdReplyInfo::IMAGE; +constexpr ContextInfo_ExternalAdReplyInfo_MediaType ContextInfo_ExternalAdReplyInfo::VIDEO; +constexpr ContextInfo_ExternalAdReplyInfo_MediaType ContextInfo_ExternalAdReplyInfo::MediaType_MIN; +constexpr ContextInfo_ExternalAdReplyInfo_MediaType ContextInfo_ExternalAdReplyInfo::MediaType_MAX; +constexpr int ContextInfo_ExternalAdReplyInfo::MediaType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Conversation_EndOfHistoryTransferType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[15]; +} +bool Conversation_EndOfHistoryTransferType_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr Conversation_EndOfHistoryTransferType Conversation::COMPLETE_BUT_MORE_MESSAGES_REMAIN_ON_PRIMARY; +constexpr Conversation_EndOfHistoryTransferType Conversation::COMPLETE_AND_NO_MORE_MESSAGE_REMAIN_ON_PRIMARY; +constexpr Conversation_EndOfHistoryTransferType Conversation::EndOfHistoryTransferType_MIN; +constexpr Conversation_EndOfHistoryTransferType Conversation::EndOfHistoryTransferType_MAX; +constexpr int Conversation::EndOfHistoryTransferType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceProps_PlatformType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[16]; +} +bool DeviceProps_PlatformType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + case 10: + case 11: + case 12: + case 13: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr DeviceProps_PlatformType DeviceProps::UNKNOWN; +constexpr DeviceProps_PlatformType DeviceProps::CHROME; +constexpr DeviceProps_PlatformType DeviceProps::FIREFOX; +constexpr DeviceProps_PlatformType DeviceProps::IE; +constexpr DeviceProps_PlatformType DeviceProps::OPERA; +constexpr DeviceProps_PlatformType DeviceProps::SAFARI; +constexpr DeviceProps_PlatformType DeviceProps::EDGE; +constexpr DeviceProps_PlatformType DeviceProps::DESKTOP; +constexpr DeviceProps_PlatformType DeviceProps::IPAD; +constexpr DeviceProps_PlatformType DeviceProps::ANDROID_TABLET; +constexpr DeviceProps_PlatformType DeviceProps::OHANA; +constexpr DeviceProps_PlatformType DeviceProps::ALOHA; +constexpr DeviceProps_PlatformType DeviceProps::CATALINA; +constexpr DeviceProps_PlatformType DeviceProps::TCL_TV; +constexpr DeviceProps_PlatformType DeviceProps::PlatformType_MIN; +constexpr DeviceProps_PlatformType DeviceProps::PlatformType_MAX; +constexpr int DeviceProps::PlatformType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DisappearingMode_Initiator_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[17]; +} +bool DisappearingMode_Initiator_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr DisappearingMode_Initiator DisappearingMode::CHANGED_IN_CHAT; +constexpr DisappearingMode_Initiator DisappearingMode::INITIATED_BY_ME; +constexpr DisappearingMode_Initiator DisappearingMode::INITIATED_BY_OTHER; +constexpr DisappearingMode_Initiator DisappearingMode::Initiator_MIN; +constexpr DisappearingMode_Initiator DisappearingMode::Initiator_MAX; +constexpr int DisappearingMode::Initiator_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* GroupParticipant_Rank_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[18]; +} +bool GroupParticipant_Rank_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr GroupParticipant_Rank GroupParticipant::REGULAR; +constexpr GroupParticipant_Rank GroupParticipant::ADMIN; +constexpr GroupParticipant_Rank GroupParticipant::SUPERADMIN; +constexpr GroupParticipant_Rank GroupParticipant::Rank_MIN; +constexpr GroupParticipant_Rank GroupParticipant::Rank_MAX; +constexpr int GroupParticipant::Rank_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HistorySync_HistorySyncType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[19]; +} +bool HistorySync_HistorySyncType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr HistorySync_HistorySyncType HistorySync::INITIAL_BOOTSTRAP; +constexpr HistorySync_HistorySyncType HistorySync::INITIAL_STATUS_V3; +constexpr HistorySync_HistorySyncType HistorySync::FULL; +constexpr HistorySync_HistorySyncType HistorySync::RECENT; +constexpr HistorySync_HistorySyncType HistorySync::PUSH_NAME; +constexpr HistorySync_HistorySyncType HistorySync::UNBLOCKING_DATA; +constexpr HistorySync_HistorySyncType HistorySync::HistorySyncType_MIN; +constexpr HistorySync_HistorySyncType HistorySync::HistorySyncType_MAX; +constexpr int HistorySync::HistorySyncType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MediaRetryNotification_ResultType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[20]; +} +bool MediaRetryNotification_ResultType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr MediaRetryNotification_ResultType MediaRetryNotification::GENERAL_ERROR; +constexpr MediaRetryNotification_ResultType MediaRetryNotification::SUCCESS; +constexpr MediaRetryNotification_ResultType MediaRetryNotification::NOT_FOUND; +constexpr MediaRetryNotification_ResultType MediaRetryNotification::DECRYPTION_ERROR; +constexpr MediaRetryNotification_ResultType MediaRetryNotification::ResultType_MIN; +constexpr MediaRetryNotification_ResultType MediaRetryNotification::ResultType_MAX; +constexpr int MediaRetryNotification::ResultType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ButtonsMessage_Button_Type_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[21]; +} +bool Message_ButtonsMessage_Button_Type_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr Message_ButtonsMessage_Button_Type Message_ButtonsMessage_Button::UNKNOWN; +constexpr Message_ButtonsMessage_Button_Type Message_ButtonsMessage_Button::RESPONSE; +constexpr Message_ButtonsMessage_Button_Type Message_ButtonsMessage_Button::NATIVE_FLOW; +constexpr Message_ButtonsMessage_Button_Type Message_ButtonsMessage_Button::Type_MIN; +constexpr Message_ButtonsMessage_Button_Type Message_ButtonsMessage_Button::Type_MAX; +constexpr int Message_ButtonsMessage_Button::Type_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ButtonsMessage_HeaderType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[22]; +} +bool Message_ButtonsMessage_HeaderType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage::UNKNOWN; +constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage::EMPTY; +constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage::TEXT; +constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage::DOCUMENT; +constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage::IMAGE; +constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage::VIDEO; +constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage::LOCATION; +constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage::HeaderType_MIN; +constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage::HeaderType_MAX; +constexpr int Message_ButtonsMessage::HeaderType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ButtonsResponseMessage_Type_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[23]; +} +bool Message_ButtonsResponseMessage_Type_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr Message_ButtonsResponseMessage_Type Message_ButtonsResponseMessage::UNKNOWN; +constexpr Message_ButtonsResponseMessage_Type Message_ButtonsResponseMessage::DISPLAY_TEXT; +constexpr Message_ButtonsResponseMessage_Type Message_ButtonsResponseMessage::Type_MIN; +constexpr Message_ButtonsResponseMessage_Type Message_ButtonsResponseMessage::Type_MAX; +constexpr int Message_ButtonsResponseMessage::Type_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ExtendedTextMessage_FontType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[24]; +} +bool Message_ExtendedTextMessage_FontType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::SANS_SERIF; +constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::SERIF; +constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::NORICAN_REGULAR; +constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::BRYNDAN_WRITE; +constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::BEBASNEUE_REGULAR; +constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::OSWALD_HEAVY; +constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::FontType_MIN; +constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::FontType_MAX; +constexpr int Message_ExtendedTextMessage::FontType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ExtendedTextMessage_InviteLinkGroupType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[25]; +} +bool Message_ExtendedTextMessage_InviteLinkGroupType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::DEFAULT; +constexpr Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::PARENT; +constexpr Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::SUB; +constexpr Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::DEFAULT_SUB; +constexpr Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::InviteLinkGroupType_MIN; +constexpr Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::InviteLinkGroupType_MAX; +constexpr int Message_ExtendedTextMessage::InviteLinkGroupType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ExtendedTextMessage_PreviewType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[26]; +} +bool Message_ExtendedTextMessage_PreviewType_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr Message_ExtendedTextMessage_PreviewType Message_ExtendedTextMessage::NONE; +constexpr Message_ExtendedTextMessage_PreviewType Message_ExtendedTextMessage::VIDEO; +constexpr Message_ExtendedTextMessage_PreviewType Message_ExtendedTextMessage::PreviewType_MIN; +constexpr Message_ExtendedTextMessage_PreviewType Message_ExtendedTextMessage::PreviewType_MAX; +constexpr int Message_ExtendedTextMessage::PreviewType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_GroupInviteMessage_GroupType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[27]; +} +bool Message_GroupInviteMessage_GroupType_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr Message_GroupInviteMessage_GroupType Message_GroupInviteMessage::DEFAULT; +constexpr Message_GroupInviteMessage_GroupType Message_GroupInviteMessage::PARENT; +constexpr Message_GroupInviteMessage_GroupType Message_GroupInviteMessage::GroupType_MIN; +constexpr Message_GroupInviteMessage_GroupType Message_GroupInviteMessage::GroupType_MAX; +constexpr int Message_GroupInviteMessage::GroupType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[28]; +} +bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_IsValid(int value) { + switch (value) { + case 1: + case 2: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::GREGORIAN; +constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::SOLAR_HIJRI; +constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::CalendarType_MIN; +constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::CalendarType_MAX; +constexpr int Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::CalendarType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[29]; +} +bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_IsValid(int value) { + switch (value) { + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::MONDAY; +constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::TUESDAY; +constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::WEDNESDAY; +constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::THURSDAY; +constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::FRIDAY; +constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::SATURDAY; +constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::SUNDAY; +constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::DayOfWeekType_MIN; +constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::DayOfWeekType_MAX; +constexpr int Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::DayOfWeekType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_HistorySyncNotification_HistorySyncType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[30]; +} +bool Message_HistorySyncNotification_HistorySyncType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification::INITIAL_BOOTSTRAP; +constexpr Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification::INITIAL_STATUS_V3; +constexpr Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification::FULL; +constexpr Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification::RECENT; +constexpr Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification::PUSH_NAME; +constexpr Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification::HistorySyncType_MIN; +constexpr Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification::HistorySyncType_MAX; +constexpr int Message_HistorySyncNotification::HistorySyncType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_InteractiveMessage_ShopMessage_Surface_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[31]; +} +bool Message_InteractiveMessage_ShopMessage_Surface_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage::UNKNOWN_SURFACE; +constexpr Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage::FB; +constexpr Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage::IG; +constexpr Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage::WA; +constexpr Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage::Surface_MIN; +constexpr Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage::Surface_MAX; +constexpr int Message_InteractiveMessage_ShopMessage::Surface_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_InvoiceMessage_AttachmentType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[32]; +} +bool Message_InvoiceMessage_AttachmentType_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr Message_InvoiceMessage_AttachmentType Message_InvoiceMessage::IMAGE; +constexpr Message_InvoiceMessage_AttachmentType Message_InvoiceMessage::PDF; +constexpr Message_InvoiceMessage_AttachmentType Message_InvoiceMessage::AttachmentType_MIN; +constexpr Message_InvoiceMessage_AttachmentType Message_InvoiceMessage::AttachmentType_MAX; +constexpr int Message_InvoiceMessage::AttachmentType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ListMessage_ListType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[33]; +} +bool Message_ListMessage_ListType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr Message_ListMessage_ListType Message_ListMessage::UNKNOWN; +constexpr Message_ListMessage_ListType Message_ListMessage::SINGLE_SELECT; +constexpr Message_ListMessage_ListType Message_ListMessage::PRODUCT_LIST; +constexpr Message_ListMessage_ListType Message_ListMessage::ListType_MIN; +constexpr Message_ListMessage_ListType Message_ListMessage::ListType_MAX; +constexpr int Message_ListMessage::ListType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ListResponseMessage_ListType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[34]; +} +bool Message_ListResponseMessage_ListType_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr Message_ListResponseMessage_ListType Message_ListResponseMessage::UNKNOWN; +constexpr Message_ListResponseMessage_ListType Message_ListResponseMessage::SINGLE_SELECT; +constexpr Message_ListResponseMessage_ListType Message_ListResponseMessage::ListType_MIN; +constexpr Message_ListResponseMessage_ListType Message_ListResponseMessage::ListType_MAX; +constexpr int Message_ListResponseMessage::ListType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_OrderMessage_OrderStatus_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[35]; +} +bool Message_OrderMessage_OrderStatus_IsValid(int value) { + switch (value) { + case 1: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr Message_OrderMessage_OrderStatus Message_OrderMessage::INQUIRY; +constexpr Message_OrderMessage_OrderStatus Message_OrderMessage::OrderStatus_MIN; +constexpr Message_OrderMessage_OrderStatus Message_OrderMessage::OrderStatus_MAX; +constexpr int Message_OrderMessage::OrderStatus_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_OrderMessage_OrderSurface_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[36]; +} +bool Message_OrderMessage_OrderSurface_IsValid(int value) { + switch (value) { + case 1: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr Message_OrderMessage_OrderSurface Message_OrderMessage::CATALOG; +constexpr Message_OrderMessage_OrderSurface Message_OrderMessage::OrderSurface_MIN; +constexpr Message_OrderMessage_OrderSurface Message_OrderMessage::OrderSurface_MAX; +constexpr int Message_OrderMessage::OrderSurface_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_PaymentInviteMessage_ServiceType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[37]; +} +bool Message_PaymentInviteMessage_ServiceType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage::UNKNOWN; +constexpr Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage::FBPAY; +constexpr Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage::NOVI; +constexpr Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage::UPI; +constexpr Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage::ServiceType_MIN; +constexpr Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage::ServiceType_MAX; +constexpr int Message_PaymentInviteMessage::ServiceType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ProtocolMessage_Type_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[38]; +} +bool Message_ProtocolMessage_Type_IsValid(int value) { + switch (value) { + case 0: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + case 10: + case 11: + case 12: + case 13: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::REVOKE; +constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::EPHEMERAL_SETTING; +constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::EPHEMERAL_SYNC_RESPONSE; +constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::HISTORY_SYNC_NOTIFICATION; +constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::APP_STATE_SYNC_KEY_SHARE; +constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::APP_STATE_SYNC_KEY_REQUEST; +constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::MSG_FANOUT_BACKFILL_REQUEST; +constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::INITIAL_SECURITY_NOTIFICATION_SETTING_SYNC; +constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::APP_STATE_FATAL_EXCEPTION_NOTIFICATION; +constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::SHARE_PHONE_NUMBER; +constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::REQUEST_MEDIA_UPLOAD_MESSAGE; +constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::REQUEST_MEDIA_UPLOAD_RESPONSE_MESSAGE; +constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::Type_MIN; +constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::Type_MAX; +constexpr int Message_ProtocolMessage::Type_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_VideoMessage_Attribution_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[39]; +} +bool Message_VideoMessage_Attribution_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr Message_VideoMessage_Attribution Message_VideoMessage::NONE; +constexpr Message_VideoMessage_Attribution Message_VideoMessage::GIPHY; +constexpr Message_VideoMessage_Attribution Message_VideoMessage::TENOR; +constexpr Message_VideoMessage_Attribution Message_VideoMessage::Attribution_MIN; +constexpr Message_VideoMessage_Attribution Message_VideoMessage::Attribution_MAX; +constexpr int Message_VideoMessage::Attribution_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_RmrSource_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[40]; +} +bool Message_RmrSource_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr Message_RmrSource Message::FAVORITE_STICKER; +constexpr Message_RmrSource Message::RECENT_STICKER; +constexpr Message_RmrSource Message::RmrSource_MIN; +constexpr Message_RmrSource Message::RmrSource_MAX; +constexpr int Message::RmrSource_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PastParticipant_LeaveReason_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[41]; +} +bool PastParticipant_LeaveReason_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr PastParticipant_LeaveReason PastParticipant::LEFT; +constexpr PastParticipant_LeaveReason PastParticipant::REMOVED; +constexpr PastParticipant_LeaveReason PastParticipant::LeaveReason_MIN; +constexpr PastParticipant_LeaveReason PastParticipant::LeaveReason_MAX; +constexpr int PastParticipant::LeaveReason_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PaymentBackground_Type_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[42]; +} +bool PaymentBackground_Type_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr PaymentBackground_Type PaymentBackground::UNKNOWN; +constexpr PaymentBackground_Type PaymentBackground::DEFAULT; +constexpr PaymentBackground_Type PaymentBackground::Type_MIN; +constexpr PaymentBackground_Type PaymentBackground::Type_MAX; +constexpr int PaymentBackground::Type_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PaymentInfo_Currency_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[43]; +} +bool PaymentInfo_Currency_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr PaymentInfo_Currency PaymentInfo::UNKNOWN_CURRENCY; +constexpr PaymentInfo_Currency PaymentInfo::INR; +constexpr PaymentInfo_Currency PaymentInfo::Currency_MIN; +constexpr PaymentInfo_Currency PaymentInfo::Currency_MAX; +constexpr int PaymentInfo::Currency_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PaymentInfo_Status_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[44]; +} +bool PaymentInfo_Status_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + case 10: + case 11: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr PaymentInfo_Status PaymentInfo::UNKNOWN_STATUS; +constexpr PaymentInfo_Status PaymentInfo::PROCESSING; +constexpr PaymentInfo_Status PaymentInfo::SENT; +constexpr PaymentInfo_Status PaymentInfo::NEED_TO_ACCEPT; +constexpr PaymentInfo_Status PaymentInfo::COMPLETE; +constexpr PaymentInfo_Status PaymentInfo::COULD_NOT_COMPLETE; +constexpr PaymentInfo_Status PaymentInfo::REFUNDED; +constexpr PaymentInfo_Status PaymentInfo::EXPIRED; +constexpr PaymentInfo_Status PaymentInfo::REJECTED; +constexpr PaymentInfo_Status PaymentInfo::CANCELLED; +constexpr PaymentInfo_Status PaymentInfo::WAITING_FOR_PAYER; +constexpr PaymentInfo_Status PaymentInfo::WAITING; +constexpr PaymentInfo_Status PaymentInfo::Status_MIN; +constexpr PaymentInfo_Status PaymentInfo::Status_MAX; +constexpr int PaymentInfo::Status_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PaymentInfo_TxnStatus_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[45]; +} +bool PaymentInfo_TxnStatus_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + case 10: + case 11: + case 12: + case 13: + case 14: + case 15: + case 16: + case 17: + case 18: + case 19: + case 20: + case 21: + case 22: + case 23: + case 24: + case 25: + case 26: + case 27: + case 28: + case 29: + case 30: + case 31: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr PaymentInfo_TxnStatus PaymentInfo::UNKNOWN; +constexpr PaymentInfo_TxnStatus PaymentInfo::PENDING_SETUP; +constexpr PaymentInfo_TxnStatus PaymentInfo::PENDING_RECEIVER_SETUP; +constexpr PaymentInfo_TxnStatus PaymentInfo::INIT; +constexpr PaymentInfo_TxnStatus PaymentInfo::SUCCESS; +constexpr PaymentInfo_TxnStatus PaymentInfo::COMPLETED; +constexpr PaymentInfo_TxnStatus PaymentInfo::FAILED; +constexpr PaymentInfo_TxnStatus PaymentInfo::FAILED_RISK; +constexpr PaymentInfo_TxnStatus PaymentInfo::FAILED_PROCESSING; +constexpr PaymentInfo_TxnStatus PaymentInfo::FAILED_RECEIVER_PROCESSING; +constexpr PaymentInfo_TxnStatus PaymentInfo::FAILED_DA; +constexpr PaymentInfo_TxnStatus PaymentInfo::FAILED_DA_FINAL; +constexpr PaymentInfo_TxnStatus PaymentInfo::REFUNDED_TXN; +constexpr PaymentInfo_TxnStatus PaymentInfo::REFUND_FAILED; +constexpr PaymentInfo_TxnStatus PaymentInfo::REFUND_FAILED_PROCESSING; +constexpr PaymentInfo_TxnStatus PaymentInfo::REFUND_FAILED_DA; +constexpr PaymentInfo_TxnStatus PaymentInfo::EXPIRED_TXN; +constexpr PaymentInfo_TxnStatus PaymentInfo::AUTH_CANCELED; +constexpr PaymentInfo_TxnStatus PaymentInfo::AUTH_CANCEL_FAILED_PROCESSING; +constexpr PaymentInfo_TxnStatus PaymentInfo::AUTH_CANCEL_FAILED; +constexpr PaymentInfo_TxnStatus PaymentInfo::COLLECT_INIT; +constexpr PaymentInfo_TxnStatus PaymentInfo::COLLECT_SUCCESS; +constexpr PaymentInfo_TxnStatus PaymentInfo::COLLECT_FAILED; +constexpr PaymentInfo_TxnStatus PaymentInfo::COLLECT_FAILED_RISK; +constexpr PaymentInfo_TxnStatus PaymentInfo::COLLECT_REJECTED; +constexpr PaymentInfo_TxnStatus PaymentInfo::COLLECT_EXPIRED; +constexpr PaymentInfo_TxnStatus PaymentInfo::COLLECT_CANCELED; +constexpr PaymentInfo_TxnStatus PaymentInfo::COLLECT_CANCELLING; +constexpr PaymentInfo_TxnStatus PaymentInfo::IN_REVIEW; +constexpr PaymentInfo_TxnStatus PaymentInfo::REVERSAL_SUCCESS; +constexpr PaymentInfo_TxnStatus PaymentInfo::REVERSAL_PENDING; +constexpr PaymentInfo_TxnStatus PaymentInfo::REFUND_PENDING; +constexpr PaymentInfo_TxnStatus PaymentInfo::TxnStatus_MIN; +constexpr PaymentInfo_TxnStatus PaymentInfo::TxnStatus_MAX; +constexpr int PaymentInfo::TxnStatus_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SyncdMutation_SyncdOperation_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[46]; +} +bool SyncdMutation_SyncdOperation_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr SyncdMutation_SyncdOperation SyncdMutation::SET; +constexpr SyncdMutation_SyncdOperation SyncdMutation::REMOVE; +constexpr SyncdMutation_SyncdOperation SyncdMutation::SyncdOperation_MIN; +constexpr SyncdMutation_SyncdOperation SyncdMutation::SyncdOperation_MAX; +constexpr int SyncdMutation::SyncdOperation_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WebFeatures_Flag_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[47]; +} +bool WebFeatures_Flag_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr WebFeatures_Flag WebFeatures::NOT_STARTED; +constexpr WebFeatures_Flag WebFeatures::FORCE_UPGRADE; +constexpr WebFeatures_Flag WebFeatures::DEVELOPMENT; +constexpr WebFeatures_Flag WebFeatures::PRODUCTION; +constexpr WebFeatures_Flag WebFeatures::Flag_MIN; +constexpr WebFeatures_Flag WebFeatures::Flag_MAX; +constexpr int WebFeatures::Flag_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WebMessageInfo_BizPrivacyStatus_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[48]; +} +bool WebMessageInfo_BizPrivacyStatus_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr WebMessageInfo_BizPrivacyStatus WebMessageInfo::E2EE; +constexpr WebMessageInfo_BizPrivacyStatus WebMessageInfo::FB; +constexpr WebMessageInfo_BizPrivacyStatus WebMessageInfo::BSP; +constexpr WebMessageInfo_BizPrivacyStatus WebMessageInfo::BSP_AND_FB; +constexpr WebMessageInfo_BizPrivacyStatus WebMessageInfo::BizPrivacyStatus_MIN; +constexpr WebMessageInfo_BizPrivacyStatus WebMessageInfo::BizPrivacyStatus_MAX; +constexpr int WebMessageInfo::BizPrivacyStatus_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WebMessageInfo_Status_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[49]; +} +bool WebMessageInfo_Status_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr WebMessageInfo_Status WebMessageInfo::ERROR; +constexpr WebMessageInfo_Status WebMessageInfo::PENDING; +constexpr WebMessageInfo_Status WebMessageInfo::SERVER_ACK; +constexpr WebMessageInfo_Status WebMessageInfo::DELIVERY_ACK; +constexpr WebMessageInfo_Status WebMessageInfo::READ; +constexpr WebMessageInfo_Status WebMessageInfo::PLAYED; +constexpr WebMessageInfo_Status WebMessageInfo::Status_MIN; +constexpr WebMessageInfo_Status WebMessageInfo::Status_MAX; +constexpr int WebMessageInfo::Status_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WebMessageInfo_StubType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[50]; +} +bool WebMessageInfo_StubType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + case 10: + case 11: + case 12: + case 13: + case 14: + case 15: + case 16: + case 17: + case 18: + case 19: + case 20: + case 21: + case 22: + case 23: + case 24: + case 25: + case 26: + case 27: + case 28: + case 29: + case 30: + case 31: + case 32: + case 33: + case 34: + case 35: + case 36: + case 37: + case 38: + case 39: + case 40: + case 41: + case 42: + case 43: + case 44: + case 45: + case 46: + case 47: + case 48: + case 49: + case 50: + case 51: + case 52: + case 53: + case 54: + case 55: + case 56: + case 57: + case 58: + case 59: + case 60: + case 61: + case 62: + case 63: + case 64: + case 65: + case 66: + case 67: + case 68: + case 69: + case 70: + case 71: + case 72: + case 73: + case 74: + case 75: + case 76: + case 77: + case 78: + case 79: + case 80: + case 81: + case 82: + case 83: + case 84: + case 85: + case 86: + case 87: + case 88: + case 89: + case 90: + case 91: + case 92: + case 93: + case 94: + case 95: + case 96: + case 97: + case 98: + case 99: + case 100: + case 101: + case 102: + case 103: + case 104: + case 105: + case 106: + case 107: + case 108: + case 109: + case 110: + case 111: + case 112: + case 113: + case 114: + case 115: + case 116: + case 117: + case 118: + case 119: + case 120: + case 121: + case 122: + case 123: + case 124: + case 125: + case 126: + case 127: + case 128: + case 129: + case 130: + case 131: + case 132: + case 133: + case 134: + case 135: + case 136: + case 137: + case 138: + case 139: + case 140: + case 141: + case 142: + case 143: + case 144: + case 145: + case 146: + case 147: + case 148: + case 149: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr WebMessageInfo_StubType WebMessageInfo::UNKNOWN; +constexpr WebMessageInfo_StubType WebMessageInfo::REVOKE; +constexpr WebMessageInfo_StubType WebMessageInfo::CIPHERTEXT; +constexpr WebMessageInfo_StubType WebMessageInfo::FUTUREPROOF; +constexpr WebMessageInfo_StubType WebMessageInfo::NON_VERIFIED_TRANSITION; +constexpr WebMessageInfo_StubType WebMessageInfo::UNVERIFIED_TRANSITION; +constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_TRANSITION; +constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_LOW_UNKNOWN; +constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_HIGH; +constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_INITIAL_UNKNOWN; +constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_INITIAL_LOW; +constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_INITIAL_HIGH; +constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_TRANSITION_ANY_TO_NONE; +constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_TRANSITION_ANY_TO_HIGH; +constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_TRANSITION_HIGH_TO_LOW; +constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_TRANSITION_HIGH_TO_UNKNOWN; +constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_TRANSITION_UNKNOWN_TO_LOW; +constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_TRANSITION_LOW_TO_UNKNOWN; +constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_TRANSITION_NONE_TO_LOW; +constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_TRANSITION_NONE_TO_UNKNOWN; +constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_CREATE; +constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_CHANGE_SUBJECT; +constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_CHANGE_ICON; +constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_CHANGE_INVITE_LINK; +constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_CHANGE_DESCRIPTION; +constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_CHANGE_RESTRICT; +constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_CHANGE_ANNOUNCE; +constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_PARTICIPANT_ADD; +constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_PARTICIPANT_REMOVE; +constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_PARTICIPANT_PROMOTE; +constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_PARTICIPANT_DEMOTE; +constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_PARTICIPANT_INVITE; +constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_PARTICIPANT_LEAVE; +constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_PARTICIPANT_CHANGE_NUMBER; +constexpr WebMessageInfo_StubType WebMessageInfo::BROADCAST_CREATE; +constexpr WebMessageInfo_StubType WebMessageInfo::BROADCAST_ADD; +constexpr WebMessageInfo_StubType WebMessageInfo::BROADCAST_REMOVE; +constexpr WebMessageInfo_StubType WebMessageInfo::GENERIC_NOTIFICATION; +constexpr WebMessageInfo_StubType WebMessageInfo::E2E_IDENTITY_CHANGED; +constexpr WebMessageInfo_StubType WebMessageInfo::E2E_ENCRYPTED; +constexpr WebMessageInfo_StubType WebMessageInfo::CALL_MISSED_VOICE; +constexpr WebMessageInfo_StubType WebMessageInfo::CALL_MISSED_VIDEO; +constexpr WebMessageInfo_StubType WebMessageInfo::INDIVIDUAL_CHANGE_NUMBER; +constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_DELETE; +constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_ANNOUNCE_MODE_MESSAGE_BOUNCE; +constexpr WebMessageInfo_StubType WebMessageInfo::CALL_MISSED_GROUP_VOICE; +constexpr WebMessageInfo_StubType WebMessageInfo::CALL_MISSED_GROUP_VIDEO; +constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_CIPHERTEXT; +constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_FUTUREPROOF; +constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_TRANSACTION_STATUS_UPDATE_FAILED; +constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_TRANSACTION_STATUS_UPDATE_REFUNDED; +constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_TRANSACTION_STATUS_UPDATE_REFUND_FAILED; +constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_TRANSACTION_STATUS_RECEIVER_PENDING_SETUP; +constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_TRANSACTION_STATUS_RECEIVER_SUCCESS_AFTER_HICCUP; +constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_ACTION_ACCOUNT_SETUP_REMINDER; +constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_ACTION_SEND_PAYMENT_REMINDER; +constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_ACTION_SEND_PAYMENT_INVITATION; +constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_ACTION_REQUEST_DECLINED; +constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_ACTION_REQUEST_EXPIRED; +constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_ACTION_REQUEST_CANCELLED; +constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_VERIFIED_TRANSITION_TOP_TO_BOTTOM; +constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_VERIFIED_TRANSITION_BOTTOM_TO_TOP; +constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_INTRO_TOP; +constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_INTRO_BOTTOM; +constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_NAME_CHANGE; +constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_MOVE_TO_CONSUMER_APP; +constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_TWO_TIER_MIGRATION_TOP; +constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_TWO_TIER_MIGRATION_BOTTOM; +constexpr WebMessageInfo_StubType WebMessageInfo::OVERSIZED; +constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_CHANGE_NO_FREQUENTLY_FORWARDED; +constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_V4_ADD_INVITE_SENT; +constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_PARTICIPANT_ADD_REQUEST_JOIN; +constexpr WebMessageInfo_StubType WebMessageInfo::CHANGE_EPHEMERAL_SETTING; +constexpr WebMessageInfo_StubType WebMessageInfo::E2E_DEVICE_CHANGED; +constexpr WebMessageInfo_StubType WebMessageInfo::VIEWED_ONCE; +constexpr WebMessageInfo_StubType WebMessageInfo::E2E_ENCRYPTED_NOW; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_TO_BSP_PREMISE; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_TO_SELF_FB; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_TO_SELF_PREMISE; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_UNVERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_VERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_PREMISE_TO_SELF_PREMISE; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_PREMISE_UNVERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_PREMISE_UNVERIFIED_TO_SELF_PREMISE_VERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_PREMISE_VERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_PREMISE_VERIFIED_TO_SELF_PREMISE_UNVERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_CONSUMER_TO_BSP_FB_UNVERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_CONSUMER_TO_BSP_PREMISE_UNVERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_CONSUMER_TO_SELF_FB_UNVERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_CONSUMER_TO_SELF_PREMISE_UNVERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_FB_TO_BSP_PREMISE; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_FB_TO_SELF_PREMISE; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_FB_UNVERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_FB_VERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_PREMISE_TO_BSP_PREMISE; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_PREMISE_UNVERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_PREMISE_VERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_TO_BSP_FB; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_TO_CONSUMER; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_TO_SELF_FB; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_UNVERIFIED_TO_BSP_FB_VERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_UNVERIFIED_TO_BSP_PREMISE_VERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_UNVERIFIED_TO_SELF_FB_VERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_UNVERIFIED_TO_VERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_VERIFIED_TO_BSP_FB_UNVERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_VERIFIED_TO_BSP_PREMISE_UNVERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_VERIFIED_TO_SELF_FB_UNVERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_VERIFIED_TO_UNVERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_FB_VERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_FB_UNVERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED; +constexpr WebMessageInfo_StubType WebMessageInfo::E2E_IDENTITY_UNAVAILABLE; +constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_CREATING; +constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_CREATE_FAILED; +constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_BOUNCED; +constexpr WebMessageInfo_StubType WebMessageInfo::BLOCK_CONTACT; +constexpr WebMessageInfo_StubType WebMessageInfo::EPHEMERAL_SETTING_NOT_APPLIED; +constexpr WebMessageInfo_StubType WebMessageInfo::SYNC_FAILED; +constexpr WebMessageInfo_StubType WebMessageInfo::SYNCING; +constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_PRIVACY_MODE_INIT_FB; +constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_PRIVACY_MODE_INIT_BSP; +constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_PRIVACY_MODE_TO_FB; +constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_PRIVACY_MODE_TO_BSP; +constexpr WebMessageInfo_StubType WebMessageInfo::DISAPPEARING_MODE; +constexpr WebMessageInfo_StubType WebMessageInfo::E2E_DEVICE_FETCH_FAILED; +constexpr WebMessageInfo_StubType WebMessageInfo::ADMIN_REVOKE; +constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_INVITE_LINK_GROWTH_LOCKED; +constexpr WebMessageInfo_StubType WebMessageInfo::COMMUNITY_LINK_PARENT_GROUP; +constexpr WebMessageInfo_StubType WebMessageInfo::COMMUNITY_LINK_SIBLING_GROUP; +constexpr WebMessageInfo_StubType WebMessageInfo::COMMUNITY_LINK_SUB_GROUP; +constexpr WebMessageInfo_StubType WebMessageInfo::COMMUNITY_UNLINK_PARENT_GROUP; +constexpr WebMessageInfo_StubType WebMessageInfo::COMMUNITY_UNLINK_SIBLING_GROUP; +constexpr WebMessageInfo_StubType WebMessageInfo::COMMUNITY_UNLINK_SUB_GROUP; +constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_PARTICIPANT_ACCEPT; +constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_PARTICIPANT_LINKED_GROUP_JOIN; +constexpr WebMessageInfo_StubType WebMessageInfo::COMMUNITY_CREATE; +constexpr WebMessageInfo_StubType WebMessageInfo::EPHEMERAL_KEEP_IN_CHAT; +constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST; +constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_MEMBERSHIP_JOIN_APPROVAL_MODE; +constexpr WebMessageInfo_StubType WebMessageInfo::INTEGRITY_UNLINK_PARENT_GROUP; +constexpr WebMessageInfo_StubType WebMessageInfo::COMMUNITY_PARTICIPANT_PROMOTE; +constexpr WebMessageInfo_StubType WebMessageInfo::COMMUNITY_PARTICIPANT_DEMOTE; +constexpr WebMessageInfo_StubType WebMessageInfo::COMMUNITY_PARENT_GROUP_DELETED; +constexpr WebMessageInfo_StubType WebMessageInfo::StubType_MIN; +constexpr WebMessageInfo_StubType WebMessageInfo::StubType_MAX; +constexpr int WebMessageInfo::StubType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* KeepType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[51]; +} +bool KeepType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MediaVisibility_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); + return file_level_enum_descriptors_pmsg_2eproto[52]; +} +bool MediaVisibility_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + + +// =================================================================== + +class ADVDeviceIdentity::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_rawid(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_timestamp(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_keyindex(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +ADVDeviceIdentity::ADVDeviceIdentity(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.ADVDeviceIdentity) +} +ADVDeviceIdentity::ADVDeviceIdentity(const ADVDeviceIdentity& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + ADVDeviceIdentity* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.timestamp_){} + , decltype(_impl_.rawid_){} + , decltype(_impl_.keyindex_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&_impl_.timestamp_, &from._impl_.timestamp_, + static_cast(reinterpret_cast(&_impl_.keyindex_) - + reinterpret_cast(&_impl_.timestamp_)) + sizeof(_impl_.keyindex_)); + // @@protoc_insertion_point(copy_constructor:proto.ADVDeviceIdentity) +} + +inline void ADVDeviceIdentity::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.timestamp_){uint64_t{0u}} + , decltype(_impl_.rawid_){0u} + , decltype(_impl_.keyindex_){0u} + }; +} + +ADVDeviceIdentity::~ADVDeviceIdentity() { + // @@protoc_insertion_point(destructor:proto.ADVDeviceIdentity) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ADVDeviceIdentity::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void ADVDeviceIdentity::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ADVDeviceIdentity::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.ADVDeviceIdentity) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + ::memset(&_impl_.timestamp_, 0, static_cast( + reinterpret_cast(&_impl_.keyindex_) - + reinterpret_cast(&_impl_.timestamp_)) + sizeof(_impl_.keyindex_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ADVDeviceIdentity::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint32 rawId = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_rawid(&has_bits); + _impl_.rawid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint64 timestamp = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_timestamp(&has_bits); + _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 keyIndex = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_keyindex(&has_bits); + _impl_.keyindex_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ADVDeviceIdentity::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.ADVDeviceIdentity) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional uint32 rawId = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_rawid(), target); + } + + // optional uint64 timestamp = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_timestamp(), target); + } + + // optional uint32 keyIndex = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_keyindex(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.ADVDeviceIdentity) + return target; +} + +size_t ADVDeviceIdentity::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.ADVDeviceIdentity) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional uint64 timestamp = 2; + if (cached_has_bits & 0x00000001u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_timestamp()); + } + + // optional uint32 rawId = 1; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_rawid()); + } + + // optional uint32 keyIndex = 3; + if (cached_has_bits & 0x00000004u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_keyindex()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ADVDeviceIdentity::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + ADVDeviceIdentity::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ADVDeviceIdentity::GetClassData() const { return &_class_data_; } + + +void ADVDeviceIdentity::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.ADVDeviceIdentity) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_impl_.timestamp_ = from._impl_.timestamp_; + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.rawid_ = from._impl_.rawid_; + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.keyindex_ = from._impl_.keyindex_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ADVDeviceIdentity::CopyFrom(const ADVDeviceIdentity& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.ADVDeviceIdentity) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ADVDeviceIdentity::IsInitialized() const { + return true; +} + +void ADVDeviceIdentity::InternalSwap(ADVDeviceIdentity* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ADVDeviceIdentity, _impl_.keyindex_) + + sizeof(ADVDeviceIdentity::_impl_.keyindex_) + - PROTOBUF_FIELD_OFFSET(ADVDeviceIdentity, _impl_.timestamp_)>( + reinterpret_cast(&_impl_.timestamp_), + reinterpret_cast(&other->_impl_.timestamp_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ADVDeviceIdentity::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[0]); +} + +// =================================================================== + +class ADVKeyIndexList::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_rawid(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_timestamp(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_currentindex(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +ADVKeyIndexList::ADVKeyIndexList(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.ADVKeyIndexList) +} +ADVKeyIndexList::ADVKeyIndexList(const ADVKeyIndexList& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + ADVKeyIndexList* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.validindexes_){from._impl_.validindexes_} + , /*decltype(_impl_._validindexes_cached_byte_size_)*/{0} + , decltype(_impl_.timestamp_){} + , decltype(_impl_.rawid_){} + , decltype(_impl_.currentindex_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&_impl_.timestamp_, &from._impl_.timestamp_, + static_cast(reinterpret_cast(&_impl_.currentindex_) - + reinterpret_cast(&_impl_.timestamp_)) + sizeof(_impl_.currentindex_)); + // @@protoc_insertion_point(copy_constructor:proto.ADVKeyIndexList) +} + +inline void ADVKeyIndexList::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.validindexes_){arena} + , /*decltype(_impl_._validindexes_cached_byte_size_)*/{0} + , decltype(_impl_.timestamp_){uint64_t{0u}} + , decltype(_impl_.rawid_){0u} + , decltype(_impl_.currentindex_){0u} + }; +} + +ADVKeyIndexList::~ADVKeyIndexList() { + // @@protoc_insertion_point(destructor:proto.ADVKeyIndexList) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ADVKeyIndexList::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.validindexes_.~RepeatedField(); +} + +void ADVKeyIndexList::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ADVKeyIndexList::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.ADVKeyIndexList) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.validindexes_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + ::memset(&_impl_.timestamp_, 0, static_cast( + reinterpret_cast(&_impl_.currentindex_) - + reinterpret_cast(&_impl_.timestamp_)) + sizeof(_impl_.currentindex_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ADVKeyIndexList::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint32 rawId = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_rawid(&has_bits); + _impl_.rawid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint64 timestamp = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_timestamp(&has_bits); + _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 currentIndex = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_currentindex(&has_bits); + _impl_.currentindex_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated uint32 validIndexes = 4 [packed = true]; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_validindexes(), ptr, ctx); + CHK_(ptr); + } else if (static_cast(tag) == 32) { + _internal_add_validindexes(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ADVKeyIndexList::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.ADVKeyIndexList) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional uint32 rawId = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_rawid(), target); + } + + // optional uint64 timestamp = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_timestamp(), target); + } + + // optional uint32 currentIndex = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_currentindex(), target); + } + + // repeated uint32 validIndexes = 4 [packed = true]; + { + int byte_size = _impl_._validindexes_cached_byte_size_.load(std::memory_order_relaxed); + if (byte_size > 0) { + target = stream->WriteUInt32Packed( + 4, _internal_validindexes(), byte_size, target); + } + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.ADVKeyIndexList) + return target; +} + +size_t ADVKeyIndexList::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.ADVKeyIndexList) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated uint32 validIndexes = 4 [packed = true]; + { + size_t data_size = ::_pbi::WireFormatLite:: + UInt32Size(this->_impl_.validindexes_); + if (data_size > 0) { + total_size += 1 + + ::_pbi::WireFormatLite::Int32Size(static_cast(data_size)); + } + int cached_size = ::_pbi::ToCachedSize(data_size); + _impl_._validindexes_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional uint64 timestamp = 2; + if (cached_has_bits & 0x00000001u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_timestamp()); + } + + // optional uint32 rawId = 1; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_rawid()); + } + + // optional uint32 currentIndex = 3; + if (cached_has_bits & 0x00000004u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_currentindex()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ADVKeyIndexList::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + ADVKeyIndexList::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ADVKeyIndexList::GetClassData() const { return &_class_data_; } + + +void ADVKeyIndexList::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.ADVKeyIndexList) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.validindexes_.MergeFrom(from._impl_.validindexes_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_impl_.timestamp_ = from._impl_.timestamp_; + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.rawid_ = from._impl_.rawid_; + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.currentindex_ = from._impl_.currentindex_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ADVKeyIndexList::CopyFrom(const ADVKeyIndexList& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.ADVKeyIndexList) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ADVKeyIndexList::IsInitialized() const { + return true; +} + +void ADVKeyIndexList::InternalSwap(ADVKeyIndexList* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.validindexes_.InternalSwap(&other->_impl_.validindexes_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ADVKeyIndexList, _impl_.currentindex_) + + sizeof(ADVKeyIndexList::_impl_.currentindex_) + - PROTOBUF_FIELD_OFFSET(ADVKeyIndexList, _impl_.timestamp_)>( + reinterpret_cast(&_impl_.timestamp_), + reinterpret_cast(&other->_impl_.timestamp_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ADVKeyIndexList::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[1]); +} + +// =================================================================== + +class ADVSignedDeviceIdentity::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_details(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_accountsignaturekey(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_accountsignature(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_devicesignature(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +ADVSignedDeviceIdentity::ADVSignedDeviceIdentity(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.ADVSignedDeviceIdentity) +} +ADVSignedDeviceIdentity::ADVSignedDeviceIdentity(const ADVSignedDeviceIdentity& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + ADVSignedDeviceIdentity* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.details_){} + , decltype(_impl_.accountsignaturekey_){} + , decltype(_impl_.accountsignature_){} + , decltype(_impl_.devicesignature_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.details_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.details_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_details()) { + _this->_impl_.details_.Set(from._internal_details(), + _this->GetArenaForAllocation()); + } + _impl_.accountsignaturekey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.accountsignaturekey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_accountsignaturekey()) { + _this->_impl_.accountsignaturekey_.Set(from._internal_accountsignaturekey(), + _this->GetArenaForAllocation()); + } + _impl_.accountsignature_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.accountsignature_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_accountsignature()) { + _this->_impl_.accountsignature_.Set(from._internal_accountsignature(), + _this->GetArenaForAllocation()); + } + _impl_.devicesignature_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.devicesignature_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_devicesignature()) { + _this->_impl_.devicesignature_.Set(from._internal_devicesignature(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.ADVSignedDeviceIdentity) +} + +inline void ADVSignedDeviceIdentity::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.details_){} + , decltype(_impl_.accountsignaturekey_){} + , decltype(_impl_.accountsignature_){} + , decltype(_impl_.devicesignature_){} + }; + _impl_.details_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.details_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.accountsignaturekey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.accountsignaturekey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.accountsignature_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.accountsignature_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.devicesignature_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.devicesignature_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +ADVSignedDeviceIdentity::~ADVSignedDeviceIdentity() { + // @@protoc_insertion_point(destructor:proto.ADVSignedDeviceIdentity) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ADVSignedDeviceIdentity::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.details_.Destroy(); + _impl_.accountsignaturekey_.Destroy(); + _impl_.accountsignature_.Destroy(); + _impl_.devicesignature_.Destroy(); +} + +void ADVSignedDeviceIdentity::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ADVSignedDeviceIdentity::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.ADVSignedDeviceIdentity) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _impl_.details_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.accountsignaturekey_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.accountsignature_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + _impl_.devicesignature_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ADVSignedDeviceIdentity::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes details = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_details(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes accountSignatureKey = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_accountsignaturekey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes accountSignature = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_accountsignature(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes deviceSignature = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_devicesignature(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ADVSignedDeviceIdentity::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.ADVSignedDeviceIdentity) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes details = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_details(), target); + } + + // optional bytes accountSignatureKey = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_accountsignaturekey(), target); + } + + // optional bytes accountSignature = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->WriteBytesMaybeAliased( + 3, this->_internal_accountsignature(), target); + } + + // optional bytes deviceSignature = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->WriteBytesMaybeAliased( + 4, this->_internal_devicesignature(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.ADVSignedDeviceIdentity) + return target; +} + +size_t ADVSignedDeviceIdentity::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.ADVSignedDeviceIdentity) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional bytes details = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_details()); + } + + // optional bytes accountSignatureKey = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_accountsignaturekey()); + } + + // optional bytes accountSignature = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_accountsignature()); + } + + // optional bytes deviceSignature = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_devicesignature()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ADVSignedDeviceIdentity::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + ADVSignedDeviceIdentity::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ADVSignedDeviceIdentity::GetClassData() const { return &_class_data_; } + + +void ADVSignedDeviceIdentity::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.ADVSignedDeviceIdentity) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_details(from._internal_details()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_accountsignaturekey(from._internal_accountsignaturekey()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_accountsignature(from._internal_accountsignature()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_set_devicesignature(from._internal_devicesignature()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ADVSignedDeviceIdentity::CopyFrom(const ADVSignedDeviceIdentity& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.ADVSignedDeviceIdentity) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ADVSignedDeviceIdentity::IsInitialized() const { + return true; +} + +void ADVSignedDeviceIdentity::InternalSwap(ADVSignedDeviceIdentity* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.details_, lhs_arena, + &other->_impl_.details_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.accountsignaturekey_, lhs_arena, + &other->_impl_.accountsignaturekey_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.accountsignature_, lhs_arena, + &other->_impl_.accountsignature_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.devicesignature_, lhs_arena, + &other->_impl_.devicesignature_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ADVSignedDeviceIdentity::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[2]); +} + +// =================================================================== + +class ADVSignedDeviceIdentityHMAC::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_details(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_hmac(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +ADVSignedDeviceIdentityHMAC::ADVSignedDeviceIdentityHMAC(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.ADVSignedDeviceIdentityHMAC) +} +ADVSignedDeviceIdentityHMAC::ADVSignedDeviceIdentityHMAC(const ADVSignedDeviceIdentityHMAC& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + ADVSignedDeviceIdentityHMAC* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.details_){} + , decltype(_impl_.hmac_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.details_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.details_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_details()) { + _this->_impl_.details_.Set(from._internal_details(), + _this->GetArenaForAllocation()); + } + _impl_.hmac_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.hmac_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_hmac()) { + _this->_impl_.hmac_.Set(from._internal_hmac(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.ADVSignedDeviceIdentityHMAC) +} + +inline void ADVSignedDeviceIdentityHMAC::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.details_){} + , decltype(_impl_.hmac_){} + }; + _impl_.details_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.details_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.hmac_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.hmac_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +ADVSignedDeviceIdentityHMAC::~ADVSignedDeviceIdentityHMAC() { + // @@protoc_insertion_point(destructor:proto.ADVSignedDeviceIdentityHMAC) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ADVSignedDeviceIdentityHMAC::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.details_.Destroy(); + _impl_.hmac_.Destroy(); +} + +void ADVSignedDeviceIdentityHMAC::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ADVSignedDeviceIdentityHMAC::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.ADVSignedDeviceIdentityHMAC) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.details_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.hmac_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ADVSignedDeviceIdentityHMAC::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes details = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_details(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes hmac = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_hmac(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ADVSignedDeviceIdentityHMAC::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.ADVSignedDeviceIdentityHMAC) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes details = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_details(), target); + } + + // optional bytes hmac = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_hmac(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.ADVSignedDeviceIdentityHMAC) + return target; +} + +size_t ADVSignedDeviceIdentityHMAC::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.ADVSignedDeviceIdentityHMAC) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional bytes details = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_details()); + } + + // optional bytes hmac = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_hmac()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ADVSignedDeviceIdentityHMAC::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + ADVSignedDeviceIdentityHMAC::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ADVSignedDeviceIdentityHMAC::GetClassData() const { return &_class_data_; } + + +void ADVSignedDeviceIdentityHMAC::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.ADVSignedDeviceIdentityHMAC) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_details(from._internal_details()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_hmac(from._internal_hmac()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ADVSignedDeviceIdentityHMAC::CopyFrom(const ADVSignedDeviceIdentityHMAC& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.ADVSignedDeviceIdentityHMAC) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ADVSignedDeviceIdentityHMAC::IsInitialized() const { + return true; +} + +void ADVSignedDeviceIdentityHMAC::InternalSwap(ADVSignedDeviceIdentityHMAC* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.details_, lhs_arena, + &other->_impl_.details_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.hmac_, lhs_arena, + &other->_impl_.hmac_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ADVSignedDeviceIdentityHMAC::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[3]); +} + +// =================================================================== + +class ADVSignedKeyIndexList::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_details(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_accountsignature(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +ADVSignedKeyIndexList::ADVSignedKeyIndexList(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.ADVSignedKeyIndexList) +} +ADVSignedKeyIndexList::ADVSignedKeyIndexList(const ADVSignedKeyIndexList& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + ADVSignedKeyIndexList* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.details_){} + , decltype(_impl_.accountsignature_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.details_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.details_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_details()) { + _this->_impl_.details_.Set(from._internal_details(), + _this->GetArenaForAllocation()); + } + _impl_.accountsignature_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.accountsignature_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_accountsignature()) { + _this->_impl_.accountsignature_.Set(from._internal_accountsignature(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.ADVSignedKeyIndexList) +} + +inline void ADVSignedKeyIndexList::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.details_){} + , decltype(_impl_.accountsignature_){} + }; + _impl_.details_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.details_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.accountsignature_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.accountsignature_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +ADVSignedKeyIndexList::~ADVSignedKeyIndexList() { + // @@protoc_insertion_point(destructor:proto.ADVSignedKeyIndexList) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ADVSignedKeyIndexList::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.details_.Destroy(); + _impl_.accountsignature_.Destroy(); +} + +void ADVSignedKeyIndexList::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ADVSignedKeyIndexList::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.ADVSignedKeyIndexList) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.details_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.accountsignature_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ADVSignedKeyIndexList::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes details = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_details(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes accountSignature = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_accountsignature(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ADVSignedKeyIndexList::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.ADVSignedKeyIndexList) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes details = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_details(), target); + } + + // optional bytes accountSignature = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_accountsignature(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.ADVSignedKeyIndexList) + return target; +} + +size_t ADVSignedKeyIndexList::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.ADVSignedKeyIndexList) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional bytes details = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_details()); + } + + // optional bytes accountSignature = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_accountsignature()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ADVSignedKeyIndexList::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + ADVSignedKeyIndexList::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ADVSignedKeyIndexList::GetClassData() const { return &_class_data_; } + + +void ADVSignedKeyIndexList::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.ADVSignedKeyIndexList) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_details(from._internal_details()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_accountsignature(from._internal_accountsignature()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ADVSignedKeyIndexList::CopyFrom(const ADVSignedKeyIndexList& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.ADVSignedKeyIndexList) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ADVSignedKeyIndexList::IsInitialized() const { + return true; +} + +void ADVSignedKeyIndexList::InternalSwap(ADVSignedKeyIndexList* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.details_, lhs_arena, + &other->_impl_.details_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.accountsignature_, lhs_arena, + &other->_impl_.accountsignature_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ADVSignedKeyIndexList::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[4]); +} + +// =================================================================== + +class ActionLink::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_url(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_buttontitle(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +ActionLink::ActionLink(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.ActionLink) +} +ActionLink::ActionLink(const ActionLink& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + ActionLink* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.url_){} + , decltype(_impl_.buttontitle_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.url_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.url_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_url()) { + _this->_impl_.url_.Set(from._internal_url(), + _this->GetArenaForAllocation()); + } + _impl_.buttontitle_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.buttontitle_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_buttontitle()) { + _this->_impl_.buttontitle_.Set(from._internal_buttontitle(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.ActionLink) +} + +inline void ActionLink::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.url_){} + , decltype(_impl_.buttontitle_){} + }; + _impl_.url_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.url_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.buttontitle_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.buttontitle_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +ActionLink::~ActionLink() { + // @@protoc_insertion_point(destructor:proto.ActionLink) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ActionLink::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.url_.Destroy(); + _impl_.buttontitle_.Destroy(); +} + +void ActionLink::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ActionLink::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.ActionLink) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.url_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.buttontitle_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ActionLink::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string url = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_url(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ActionLink.url"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string buttonTitle = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_buttontitle(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ActionLink.buttonTitle"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ActionLink::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.ActionLink) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string url = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_url().data(), static_cast(this->_internal_url().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ActionLink.url"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_url(), target); + } + + // optional string buttonTitle = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_buttontitle().data(), static_cast(this->_internal_buttontitle().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ActionLink.buttonTitle"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_buttontitle(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.ActionLink) + return target; +} + +size_t ActionLink::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.ActionLink) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional string url = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_url()); + } + + // optional string buttonTitle = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_buttontitle()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ActionLink::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + ActionLink::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ActionLink::GetClassData() const { return &_class_data_; } + + +void ActionLink::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.ActionLink) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_url(from._internal_url()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_buttontitle(from._internal_buttontitle()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ActionLink::CopyFrom(const ActionLink& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.ActionLink) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ActionLink::IsInitialized() const { + return true; +} + +void ActionLink::InternalSwap(ActionLink* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.url_, lhs_arena, + &other->_impl_.url_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.buttontitle_, lhs_arena, + &other->_impl_.buttontitle_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ActionLink::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[5]); +} + +// =================================================================== + +class AutoDownloadSettings::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_downloadimages(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_downloadaudio(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_downloadvideo(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_downloaddocuments(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +AutoDownloadSettings::AutoDownloadSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.AutoDownloadSettings) +} +AutoDownloadSettings::AutoDownloadSettings(const AutoDownloadSettings& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + AutoDownloadSettings* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.downloadimages_){} + , decltype(_impl_.downloadaudio_){} + , decltype(_impl_.downloadvideo_){} + , decltype(_impl_.downloaddocuments_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&_impl_.downloadimages_, &from._impl_.downloadimages_, + static_cast(reinterpret_cast(&_impl_.downloaddocuments_) - + reinterpret_cast(&_impl_.downloadimages_)) + sizeof(_impl_.downloaddocuments_)); + // @@protoc_insertion_point(copy_constructor:proto.AutoDownloadSettings) +} + +inline void AutoDownloadSettings::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.downloadimages_){false} + , decltype(_impl_.downloadaudio_){false} + , decltype(_impl_.downloadvideo_){false} + , decltype(_impl_.downloaddocuments_){false} + }; +} + +AutoDownloadSettings::~AutoDownloadSettings() { + // @@protoc_insertion_point(destructor:proto.AutoDownloadSettings) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void AutoDownloadSettings::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void AutoDownloadSettings::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void AutoDownloadSettings::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.AutoDownloadSettings) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.downloadimages_, 0, static_cast( + reinterpret_cast(&_impl_.downloaddocuments_) - + reinterpret_cast(&_impl_.downloadimages_)) + sizeof(_impl_.downloaddocuments_)); + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* AutoDownloadSettings::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bool downloadImages = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_downloadimages(&has_bits); + _impl_.downloadimages_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool downloadAudio = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_downloadaudio(&has_bits); + _impl_.downloadaudio_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool downloadVideo = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_downloadvideo(&has_bits); + _impl_.downloadvideo_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool downloadDocuments = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_downloaddocuments(&has_bits); + _impl_.downloaddocuments_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* AutoDownloadSettings::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.AutoDownloadSettings) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bool downloadImages = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_downloadimages(), target); + } + + // optional bool downloadAudio = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(2, this->_internal_downloadaudio(), target); + } + + // optional bool downloadVideo = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_downloadvideo(), target); + } + + // optional bool downloadDocuments = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(4, this->_internal_downloaddocuments(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.AutoDownloadSettings) + return target; +} + +size_t AutoDownloadSettings::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.AutoDownloadSettings) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional bool downloadImages = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 1; + } + + // optional bool downloadAudio = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 1; + } + + // optional bool downloadVideo = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 1; + } + + // optional bool downloadDocuments = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 1; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData AutoDownloadSettings::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + AutoDownloadSettings::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*AutoDownloadSettings::GetClassData() const { return &_class_data_; } + + +void AutoDownloadSettings::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.AutoDownloadSettings) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _this->_impl_.downloadimages_ = from._impl_.downloadimages_; + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.downloadaudio_ = from._impl_.downloadaudio_; + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.downloadvideo_ = from._impl_.downloadvideo_; + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.downloaddocuments_ = from._impl_.downloaddocuments_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void AutoDownloadSettings::CopyFrom(const AutoDownloadSettings& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.AutoDownloadSettings) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AutoDownloadSettings::IsInitialized() const { + return true; +} + +void AutoDownloadSettings::InternalSwap(AutoDownloadSettings* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(AutoDownloadSettings, _impl_.downloaddocuments_) + + sizeof(AutoDownloadSettings::_impl_.downloaddocuments_) + - PROTOBUF_FIELD_OFFSET(AutoDownloadSettings, _impl_.downloadimages_)>( + reinterpret_cast(&_impl_.downloadimages_), + reinterpret_cast(&other->_impl_.downloadimages_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata AutoDownloadSettings::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[6]); +} + +// =================================================================== + +class BizAccountLinkInfo::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_whatsappbizacctfbid(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_whatsappacctnumber(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_issuetime(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_hoststorage(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_accounttype(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } +}; + +BizAccountLinkInfo::BizAccountLinkInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.BizAccountLinkInfo) +} +BizAccountLinkInfo::BizAccountLinkInfo(const BizAccountLinkInfo& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + BizAccountLinkInfo* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.whatsappacctnumber_){} + , decltype(_impl_.whatsappbizacctfbid_){} + , decltype(_impl_.issuetime_){} + , decltype(_impl_.hoststorage_){} + , decltype(_impl_.accounttype_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.whatsappacctnumber_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.whatsappacctnumber_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_whatsappacctnumber()) { + _this->_impl_.whatsappacctnumber_.Set(from._internal_whatsappacctnumber(), + _this->GetArenaForAllocation()); + } + ::memcpy(&_impl_.whatsappbizacctfbid_, &from._impl_.whatsappbizacctfbid_, + static_cast(reinterpret_cast(&_impl_.accounttype_) - + reinterpret_cast(&_impl_.whatsappbizacctfbid_)) + sizeof(_impl_.accounttype_)); + // @@protoc_insertion_point(copy_constructor:proto.BizAccountLinkInfo) +} + +inline void BizAccountLinkInfo::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.whatsappacctnumber_){} + , decltype(_impl_.whatsappbizacctfbid_){uint64_t{0u}} + , decltype(_impl_.issuetime_){uint64_t{0u}} + , decltype(_impl_.hoststorage_){0} + , decltype(_impl_.accounttype_){0} + }; + _impl_.whatsappacctnumber_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.whatsappacctnumber_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +BizAccountLinkInfo::~BizAccountLinkInfo() { + // @@protoc_insertion_point(destructor:proto.BizAccountLinkInfo) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void BizAccountLinkInfo::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.whatsappacctnumber_.Destroy(); +} + +void BizAccountLinkInfo::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void BizAccountLinkInfo::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.BizAccountLinkInfo) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.whatsappacctnumber_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x0000001eu) { + ::memset(&_impl_.whatsappbizacctfbid_, 0, static_cast( + reinterpret_cast(&_impl_.accounttype_) - + reinterpret_cast(&_impl_.whatsappbizacctfbid_)) + sizeof(_impl_.accounttype_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* BizAccountLinkInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint64 whatsappBizAcctFbid = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_whatsappbizacctfbid(&has_bits); + _impl_.whatsappbizacctfbid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string whatsappAcctNumber = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_whatsappacctnumber(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.BizAccountLinkInfo.whatsappAcctNumber"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional uint64 issueTime = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_issuetime(&has_bits); + _impl_.issuetime_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.BizAccountLinkInfo.HostStorageType hostStorage = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::BizAccountLinkInfo_HostStorageType_IsValid(val))) { + _internal_set_hoststorage(static_cast<::proto::BizAccountLinkInfo_HostStorageType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.BizAccountLinkInfo.AccountType accountType = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::BizAccountLinkInfo_AccountType_IsValid(val))) { + _internal_set_accounttype(static_cast<::proto::BizAccountLinkInfo_AccountType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* BizAccountLinkInfo::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.BizAccountLinkInfo) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional uint64 whatsappBizAcctFbid = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_whatsappbizacctfbid(), target); + } + + // optional string whatsappAcctNumber = 2; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_whatsappacctnumber().data(), static_cast(this->_internal_whatsappacctnumber().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.BizAccountLinkInfo.whatsappAcctNumber"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_whatsappacctnumber(), target); + } + + // optional uint64 issueTime = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_issuetime(), target); + } + + // optional .proto.BizAccountLinkInfo.HostStorageType hostStorage = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 4, this->_internal_hoststorage(), target); + } + + // optional .proto.BizAccountLinkInfo.AccountType accountType = 5; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 5, this->_internal_accounttype(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.BizAccountLinkInfo) + return target; +} + +size_t BizAccountLinkInfo::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.BizAccountLinkInfo) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + // optional string whatsappAcctNumber = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_whatsappacctnumber()); + } + + // optional uint64 whatsappBizAcctFbid = 1; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_whatsappbizacctfbid()); + } + + // optional uint64 issueTime = 3; + if (cached_has_bits & 0x00000004u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_issuetime()); + } + + // optional .proto.BizAccountLinkInfo.HostStorageType hostStorage = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_hoststorage()); + } + + // optional .proto.BizAccountLinkInfo.AccountType accountType = 5; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_accounttype()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData BizAccountLinkInfo::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + BizAccountLinkInfo::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*BizAccountLinkInfo::GetClassData() const { return &_class_data_; } + + +void BizAccountLinkInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.BizAccountLinkInfo) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_whatsappacctnumber(from._internal_whatsappacctnumber()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.whatsappbizacctfbid_ = from._impl_.whatsappbizacctfbid_; + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.issuetime_ = from._impl_.issuetime_; + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.hoststorage_ = from._impl_.hoststorage_; + } + if (cached_has_bits & 0x00000010u) { + _this->_impl_.accounttype_ = from._impl_.accounttype_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void BizAccountLinkInfo::CopyFrom(const BizAccountLinkInfo& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.BizAccountLinkInfo) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BizAccountLinkInfo::IsInitialized() const { + return true; +} + +void BizAccountLinkInfo::InternalSwap(BizAccountLinkInfo* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.whatsappacctnumber_, lhs_arena, + &other->_impl_.whatsappacctnumber_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(BizAccountLinkInfo, _impl_.accounttype_) + + sizeof(BizAccountLinkInfo::_impl_.accounttype_) + - PROTOBUF_FIELD_OFFSET(BizAccountLinkInfo, _impl_.whatsappbizacctfbid_)>( + reinterpret_cast(&_impl_.whatsappbizacctfbid_), + reinterpret_cast(&other->_impl_.whatsappbizacctfbid_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata BizAccountLinkInfo::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[7]); +} + +// =================================================================== + +class BizAccountPayload::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::VerifiedNameCertificate& vnamecert(const BizAccountPayload* msg); + static void set_has_vnamecert(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_bizacctlinkinfo(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +const ::proto::VerifiedNameCertificate& +BizAccountPayload::_Internal::vnamecert(const BizAccountPayload* msg) { + return *msg->_impl_.vnamecert_; +} +BizAccountPayload::BizAccountPayload(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.BizAccountPayload) +} +BizAccountPayload::BizAccountPayload(const BizAccountPayload& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + BizAccountPayload* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.bizacctlinkinfo_){} + , decltype(_impl_.vnamecert_){nullptr}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.bizacctlinkinfo_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.bizacctlinkinfo_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_bizacctlinkinfo()) { + _this->_impl_.bizacctlinkinfo_.Set(from._internal_bizacctlinkinfo(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_vnamecert()) { + _this->_impl_.vnamecert_ = new ::proto::VerifiedNameCertificate(*from._impl_.vnamecert_); + } + // @@protoc_insertion_point(copy_constructor:proto.BizAccountPayload) +} + +inline void BizAccountPayload::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.bizacctlinkinfo_){} + , decltype(_impl_.vnamecert_){nullptr} + }; + _impl_.bizacctlinkinfo_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.bizacctlinkinfo_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +BizAccountPayload::~BizAccountPayload() { + // @@protoc_insertion_point(destructor:proto.BizAccountPayload) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void BizAccountPayload::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.bizacctlinkinfo_.Destroy(); + if (this != internal_default_instance()) delete _impl_.vnamecert_; +} + +void BizAccountPayload::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void BizAccountPayload::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.BizAccountPayload) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.bizacctlinkinfo_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.vnamecert_ != nullptr); + _impl_.vnamecert_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* BizAccountPayload::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.VerifiedNameCertificate vnameCert = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_vnamecert(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes bizAcctLinkInfo = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_bizacctlinkinfo(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* BizAccountPayload::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.BizAccountPayload) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.VerifiedNameCertificate vnameCert = 1; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::vnamecert(this), + _Internal::vnamecert(this).GetCachedSize(), target, stream); + } + + // optional bytes bizAcctLinkInfo = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_bizacctlinkinfo(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.BizAccountPayload) + return target; +} + +size_t BizAccountPayload::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.BizAccountPayload) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional bytes bizAcctLinkInfo = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_bizacctlinkinfo()); + } + + // optional .proto.VerifiedNameCertificate vnameCert = 1; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.vnamecert_); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData BizAccountPayload::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + BizAccountPayload::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*BizAccountPayload::GetClassData() const { return &_class_data_; } + + +void BizAccountPayload::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.BizAccountPayload) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_bizacctlinkinfo(from._internal_bizacctlinkinfo()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_vnamecert()->::proto::VerifiedNameCertificate::MergeFrom( + from._internal_vnamecert()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void BizAccountPayload::CopyFrom(const BizAccountPayload& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.BizAccountPayload) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BizAccountPayload::IsInitialized() const { + return true; +} + +void BizAccountPayload::InternalSwap(BizAccountPayload* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.bizacctlinkinfo_, lhs_arena, + &other->_impl_.bizacctlinkinfo_, rhs_arena + ); + swap(_impl_.vnamecert_, other->_impl_.vnamecert_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata BizAccountPayload::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[8]); +} + +// =================================================================== + +class BizIdentityInfo::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_vlevel(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::proto::VerifiedNameCertificate& vnamecert(const BizIdentityInfo* msg); + static void set_has_vnamecert(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_signed_(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_revoked(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_hoststorage(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_actualactors(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_privacymodets(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_featurecontrols(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } +}; + +const ::proto::VerifiedNameCertificate& +BizIdentityInfo::_Internal::vnamecert(const BizIdentityInfo* msg) { + return *msg->_impl_.vnamecert_; +} +BizIdentityInfo::BizIdentityInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.BizIdentityInfo) +} +BizIdentityInfo::BizIdentityInfo(const BizIdentityInfo& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + BizIdentityInfo* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.vnamecert_){nullptr} + , decltype(_impl_.vlevel_){} + , decltype(_impl_.signed__){} + , decltype(_impl_.revoked_){} + , decltype(_impl_.hoststorage_){} + , decltype(_impl_.actualactors_){} + , decltype(_impl_.privacymodets_){} + , decltype(_impl_.featurecontrols_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_vnamecert()) { + _this->_impl_.vnamecert_ = new ::proto::VerifiedNameCertificate(*from._impl_.vnamecert_); + } + ::memcpy(&_impl_.vlevel_, &from._impl_.vlevel_, + static_cast(reinterpret_cast(&_impl_.featurecontrols_) - + reinterpret_cast(&_impl_.vlevel_)) + sizeof(_impl_.featurecontrols_)); + // @@protoc_insertion_point(copy_constructor:proto.BizIdentityInfo) +} + +inline void BizIdentityInfo::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.vnamecert_){nullptr} + , decltype(_impl_.vlevel_){0} + , decltype(_impl_.signed__){false} + , decltype(_impl_.revoked_){false} + , decltype(_impl_.hoststorage_){0} + , decltype(_impl_.actualactors_){0} + , decltype(_impl_.privacymodets_){uint64_t{0u}} + , decltype(_impl_.featurecontrols_){uint64_t{0u}} + }; +} + +BizIdentityInfo::~BizIdentityInfo() { + // @@protoc_insertion_point(destructor:proto.BizIdentityInfo) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void BizIdentityInfo::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.vnamecert_; +} + +void BizIdentityInfo::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void BizIdentityInfo::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.BizIdentityInfo) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.vnamecert_ != nullptr); + _impl_.vnamecert_->Clear(); + } + if (cached_has_bits & 0x000000feu) { + ::memset(&_impl_.vlevel_, 0, static_cast( + reinterpret_cast(&_impl_.featurecontrols_) - + reinterpret_cast(&_impl_.vlevel_)) + sizeof(_impl_.featurecontrols_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* BizIdentityInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.BizIdentityInfo.VerifiedLevelValue vlevel = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::BizIdentityInfo_VerifiedLevelValue_IsValid(val))) { + _internal_set_vlevel(static_cast<::proto::BizIdentityInfo_VerifiedLevelValue>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.VerifiedNameCertificate vnameCert = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_vnamecert(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool signed = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_signed_(&has_bits); + _impl_.signed__ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool revoked = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_revoked(&has_bits); + _impl_.revoked_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.BizIdentityInfo.HostStorageType hostStorage = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::BizIdentityInfo_HostStorageType_IsValid(val))) { + _internal_set_hoststorage(static_cast<::proto::BizIdentityInfo_HostStorageType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.BizIdentityInfo.ActualActorsType actualActors = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::BizIdentityInfo_ActualActorsType_IsValid(val))) { + _internal_set_actualactors(static_cast<::proto::BizIdentityInfo_ActualActorsType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(6, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional uint64 privacyModeTs = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + _Internal::set_has_privacymodets(&has_bits); + _impl_.privacymodets_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint64 featureControls = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { + _Internal::set_has_featurecontrols(&has_bits); + _impl_.featurecontrols_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* BizIdentityInfo::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.BizIdentityInfo) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.BizIdentityInfo.VerifiedLevelValue vlevel = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this->_internal_vlevel(), target); + } + + // optional .proto.VerifiedNameCertificate vnameCert = 2; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::vnamecert(this), + _Internal::vnamecert(this).GetCachedSize(), target, stream); + } + + // optional bool signed = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_signed_(), target); + } + + // optional bool revoked = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(4, this->_internal_revoked(), target); + } + + // optional .proto.BizIdentityInfo.HostStorageType hostStorage = 5; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 5, this->_internal_hoststorage(), target); + } + + // optional .proto.BizIdentityInfo.ActualActorsType actualActors = 6; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 6, this->_internal_actualactors(), target); + } + + // optional uint64 privacyModeTs = 7; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(7, this->_internal_privacymodets(), target); + } + + // optional uint64 featureControls = 8; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(8, this->_internal_featurecontrols(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.BizIdentityInfo) + return target; +} + +size_t BizIdentityInfo::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.BizIdentityInfo) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional .proto.VerifiedNameCertificate vnameCert = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.vnamecert_); + } + + // optional .proto.BizIdentityInfo.VerifiedLevelValue vlevel = 1; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_vlevel()); + } + + // optional bool signed = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 1; + } + + // optional bool revoked = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 1; + } + + // optional .proto.BizIdentityInfo.HostStorageType hostStorage = 5; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_hoststorage()); + } + + // optional .proto.BizIdentityInfo.ActualActorsType actualActors = 6; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_actualactors()); + } + + // optional uint64 privacyModeTs = 7; + if (cached_has_bits & 0x00000040u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_privacymodets()); + } + + // optional uint64 featureControls = 8; + if (cached_has_bits & 0x00000080u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_featurecontrols()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData BizIdentityInfo::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + BizIdentityInfo::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*BizIdentityInfo::GetClassData() const { return &_class_data_; } + + +void BizIdentityInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.BizIdentityInfo) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_vnamecert()->::proto::VerifiedNameCertificate::MergeFrom( + from._internal_vnamecert()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.vlevel_ = from._impl_.vlevel_; + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.signed__ = from._impl_.signed__; + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.revoked_ = from._impl_.revoked_; + } + if (cached_has_bits & 0x00000010u) { + _this->_impl_.hoststorage_ = from._impl_.hoststorage_; + } + if (cached_has_bits & 0x00000020u) { + _this->_impl_.actualactors_ = from._impl_.actualactors_; + } + if (cached_has_bits & 0x00000040u) { + _this->_impl_.privacymodets_ = from._impl_.privacymodets_; + } + if (cached_has_bits & 0x00000080u) { + _this->_impl_.featurecontrols_ = from._impl_.featurecontrols_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void BizIdentityInfo::CopyFrom(const BizIdentityInfo& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.BizIdentityInfo) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BizIdentityInfo::IsInitialized() const { + return true; +} + +void BizIdentityInfo::InternalSwap(BizIdentityInfo* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(BizIdentityInfo, _impl_.featurecontrols_) + + sizeof(BizIdentityInfo::_impl_.featurecontrols_) + - PROTOBUF_FIELD_OFFSET(BizIdentityInfo, _impl_.vnamecert_)>( + reinterpret_cast(&_impl_.vnamecert_), + reinterpret_cast(&other->_impl_.vnamecert_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata BizIdentityInfo::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[9]); +} + +// =================================================================== + +class CertChain_NoiseCertificate_Details::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_serial(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_issuerserial(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_key(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_notbefore(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_notafter(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } +}; + +CertChain_NoiseCertificate_Details::CertChain_NoiseCertificate_Details(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.CertChain.NoiseCertificate.Details) +} +CertChain_NoiseCertificate_Details::CertChain_NoiseCertificate_Details(const CertChain_NoiseCertificate_Details& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + CertChain_NoiseCertificate_Details* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.key_){} + , decltype(_impl_.serial_){} + , decltype(_impl_.issuerserial_){} + , decltype(_impl_.notbefore_){} + , decltype(_impl_.notafter_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.key_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.key_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_key()) { + _this->_impl_.key_.Set(from._internal_key(), + _this->GetArenaForAllocation()); + } + ::memcpy(&_impl_.serial_, &from._impl_.serial_, + static_cast(reinterpret_cast(&_impl_.notafter_) - + reinterpret_cast(&_impl_.serial_)) + sizeof(_impl_.notafter_)); + // @@protoc_insertion_point(copy_constructor:proto.CertChain.NoiseCertificate.Details) +} + +inline void CertChain_NoiseCertificate_Details::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.key_){} + , decltype(_impl_.serial_){0u} + , decltype(_impl_.issuerserial_){0u} + , decltype(_impl_.notbefore_){uint64_t{0u}} + , decltype(_impl_.notafter_){uint64_t{0u}} + }; + _impl_.key_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.key_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +CertChain_NoiseCertificate_Details::~CertChain_NoiseCertificate_Details() { + // @@protoc_insertion_point(destructor:proto.CertChain.NoiseCertificate.Details) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void CertChain_NoiseCertificate_Details::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.key_.Destroy(); +} + +void CertChain_NoiseCertificate_Details::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void CertChain_NoiseCertificate_Details::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.CertChain.NoiseCertificate.Details) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.key_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x0000001eu) { + ::memset(&_impl_.serial_, 0, static_cast( + reinterpret_cast(&_impl_.notafter_) - + reinterpret_cast(&_impl_.serial_)) + sizeof(_impl_.notafter_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* CertChain_NoiseCertificate_Details::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint32 serial = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_serial(&has_bits); + _impl_.serial_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 issuerSerial = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_issuerserial(&has_bits); + _impl_.issuerserial_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes key = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_key(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint64 notBefore = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_notbefore(&has_bits); + _impl_.notbefore_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint64 notAfter = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_notafter(&has_bits); + _impl_.notafter_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* CertChain_NoiseCertificate_Details::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.CertChain.NoiseCertificate.Details) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional uint32 serial = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_serial(), target); + } + + // optional uint32 issuerSerial = 2; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_issuerserial(), target); + } + + // optional bytes key = 3; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 3, this->_internal_key(), target); + } + + // optional uint64 notBefore = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_notbefore(), target); + } + + // optional uint64 notAfter = 5; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_notafter(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.CertChain.NoiseCertificate.Details) + return target; +} + +size_t CertChain_NoiseCertificate_Details::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.CertChain.NoiseCertificate.Details) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + // optional bytes key = 3; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_key()); + } + + // optional uint32 serial = 1; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_serial()); + } + + // optional uint32 issuerSerial = 2; + if (cached_has_bits & 0x00000004u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_issuerserial()); + } + + // optional uint64 notBefore = 4; + if (cached_has_bits & 0x00000008u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_notbefore()); + } + + // optional uint64 notAfter = 5; + if (cached_has_bits & 0x00000010u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_notafter()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CertChain_NoiseCertificate_Details::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + CertChain_NoiseCertificate_Details::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CertChain_NoiseCertificate_Details::GetClassData() const { return &_class_data_; } + + +void CertChain_NoiseCertificate_Details::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.CertChain.NoiseCertificate.Details) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_key(from._internal_key()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.serial_ = from._impl_.serial_; + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.issuerserial_ = from._impl_.issuerserial_; + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.notbefore_ = from._impl_.notbefore_; + } + if (cached_has_bits & 0x00000010u) { + _this->_impl_.notafter_ = from._impl_.notafter_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void CertChain_NoiseCertificate_Details::CopyFrom(const CertChain_NoiseCertificate_Details& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.CertChain.NoiseCertificate.Details) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CertChain_NoiseCertificate_Details::IsInitialized() const { + return true; +} + +void CertChain_NoiseCertificate_Details::InternalSwap(CertChain_NoiseCertificate_Details* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.key_, lhs_arena, + &other->_impl_.key_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(CertChain_NoiseCertificate_Details, _impl_.notafter_) + + sizeof(CertChain_NoiseCertificate_Details::_impl_.notafter_) + - PROTOBUF_FIELD_OFFSET(CertChain_NoiseCertificate_Details, _impl_.serial_)>( + reinterpret_cast(&_impl_.serial_), + reinterpret_cast(&other->_impl_.serial_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata CertChain_NoiseCertificate_Details::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[10]); +} + +// =================================================================== + +class CertChain_NoiseCertificate::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_details(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_signature(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +CertChain_NoiseCertificate::CertChain_NoiseCertificate(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.CertChain.NoiseCertificate) +} +CertChain_NoiseCertificate::CertChain_NoiseCertificate(const CertChain_NoiseCertificate& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + CertChain_NoiseCertificate* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.details_){} + , decltype(_impl_.signature_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.details_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.details_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_details()) { + _this->_impl_.details_.Set(from._internal_details(), + _this->GetArenaForAllocation()); + } + _impl_.signature_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.signature_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_signature()) { + _this->_impl_.signature_.Set(from._internal_signature(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.CertChain.NoiseCertificate) +} + +inline void CertChain_NoiseCertificate::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.details_){} + , decltype(_impl_.signature_){} + }; + _impl_.details_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.details_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.signature_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.signature_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +CertChain_NoiseCertificate::~CertChain_NoiseCertificate() { + // @@protoc_insertion_point(destructor:proto.CertChain.NoiseCertificate) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void CertChain_NoiseCertificate::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.details_.Destroy(); + _impl_.signature_.Destroy(); +} + +void CertChain_NoiseCertificate::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void CertChain_NoiseCertificate::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.CertChain.NoiseCertificate) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.details_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.signature_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* CertChain_NoiseCertificate::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes details = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_details(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes signature = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_signature(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* CertChain_NoiseCertificate::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.CertChain.NoiseCertificate) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes details = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_details(), target); + } + + // optional bytes signature = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_signature(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.CertChain.NoiseCertificate) + return target; +} + +size_t CertChain_NoiseCertificate::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.CertChain.NoiseCertificate) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional bytes details = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_details()); + } + + // optional bytes signature = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_signature()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CertChain_NoiseCertificate::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + CertChain_NoiseCertificate::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CertChain_NoiseCertificate::GetClassData() const { return &_class_data_; } + + +void CertChain_NoiseCertificate::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.CertChain.NoiseCertificate) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_details(from._internal_details()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_signature(from._internal_signature()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void CertChain_NoiseCertificate::CopyFrom(const CertChain_NoiseCertificate& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.CertChain.NoiseCertificate) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CertChain_NoiseCertificate::IsInitialized() const { + return true; +} + +void CertChain_NoiseCertificate::InternalSwap(CertChain_NoiseCertificate* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.details_, lhs_arena, + &other->_impl_.details_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.signature_, lhs_arena, + &other->_impl_.signature_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata CertChain_NoiseCertificate::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[11]); +} + +// =================================================================== + +class CertChain::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::CertChain_NoiseCertificate& leaf(const CertChain* msg); + static void set_has_leaf(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::proto::CertChain_NoiseCertificate& intermediate(const CertChain* msg); + static void set_has_intermediate(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::proto::CertChain_NoiseCertificate& +CertChain::_Internal::leaf(const CertChain* msg) { + return *msg->_impl_.leaf_; +} +const ::proto::CertChain_NoiseCertificate& +CertChain::_Internal::intermediate(const CertChain* msg) { + return *msg->_impl_.intermediate_; +} +CertChain::CertChain(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.CertChain) +} +CertChain::CertChain(const CertChain& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + CertChain* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.leaf_){nullptr} + , decltype(_impl_.intermediate_){nullptr}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_leaf()) { + _this->_impl_.leaf_ = new ::proto::CertChain_NoiseCertificate(*from._impl_.leaf_); + } + if (from._internal_has_intermediate()) { + _this->_impl_.intermediate_ = new ::proto::CertChain_NoiseCertificate(*from._impl_.intermediate_); + } + // @@protoc_insertion_point(copy_constructor:proto.CertChain) +} + +inline void CertChain::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.leaf_){nullptr} + , decltype(_impl_.intermediate_){nullptr} + }; +} + +CertChain::~CertChain() { + // @@protoc_insertion_point(destructor:proto.CertChain) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void CertChain::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.leaf_; + if (this != internal_default_instance()) delete _impl_.intermediate_; +} + +void CertChain::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void CertChain::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.CertChain) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.leaf_ != nullptr); + _impl_.leaf_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.intermediate_ != nullptr); + _impl_.intermediate_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* CertChain::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.CertChain.NoiseCertificate leaf = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_leaf(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.CertChain.NoiseCertificate intermediate = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_intermediate(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* CertChain::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.CertChain) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.CertChain.NoiseCertificate leaf = 1; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::leaf(this), + _Internal::leaf(this).GetCachedSize(), target, stream); + } + + // optional .proto.CertChain.NoiseCertificate intermediate = 2; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::intermediate(this), + _Internal::intermediate(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.CertChain) + return target; +} + +size_t CertChain::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.CertChain) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional .proto.CertChain.NoiseCertificate leaf = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.leaf_); + } + + // optional .proto.CertChain.NoiseCertificate intermediate = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.intermediate_); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CertChain::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + CertChain::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CertChain::GetClassData() const { return &_class_data_; } + + +void CertChain::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.CertChain) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_leaf()->::proto::CertChain_NoiseCertificate::MergeFrom( + from._internal_leaf()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_intermediate()->::proto::CertChain_NoiseCertificate::MergeFrom( + from._internal_intermediate()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void CertChain::CopyFrom(const CertChain& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.CertChain) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CertChain::IsInitialized() const { + return true; +} + +void CertChain::InternalSwap(CertChain* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(CertChain, _impl_.intermediate_) + + sizeof(CertChain::_impl_.intermediate_) + - PROTOBUF_FIELD_OFFSET(CertChain, _impl_.leaf_)>( + reinterpret_cast(&_impl_.leaf_), + reinterpret_cast(&other->_impl_.leaf_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata CertChain::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[12]); +} + +// =================================================================== + +class Chain::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_senderratchetkey(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_senderratchetkeyprivate(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::proto::ChainKey& chainkey(const Chain* msg); + static void set_has_chainkey(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +const ::proto::ChainKey& +Chain::_Internal::chainkey(const Chain* msg) { + return *msg->_impl_.chainkey_; +} +Chain::Chain(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Chain) +} +Chain::Chain(const Chain& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Chain* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.messagekeys_){from._impl_.messagekeys_} + , decltype(_impl_.senderratchetkey_){} + , decltype(_impl_.senderratchetkeyprivate_){} + , decltype(_impl_.chainkey_){nullptr}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.senderratchetkey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.senderratchetkey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_senderratchetkey()) { + _this->_impl_.senderratchetkey_.Set(from._internal_senderratchetkey(), + _this->GetArenaForAllocation()); + } + _impl_.senderratchetkeyprivate_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.senderratchetkeyprivate_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_senderratchetkeyprivate()) { + _this->_impl_.senderratchetkeyprivate_.Set(from._internal_senderratchetkeyprivate(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_chainkey()) { + _this->_impl_.chainkey_ = new ::proto::ChainKey(*from._impl_.chainkey_); + } + // @@protoc_insertion_point(copy_constructor:proto.Chain) +} + +inline void Chain::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.messagekeys_){arena} + , decltype(_impl_.senderratchetkey_){} + , decltype(_impl_.senderratchetkeyprivate_){} + , decltype(_impl_.chainkey_){nullptr} + }; + _impl_.senderratchetkey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.senderratchetkey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.senderratchetkeyprivate_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.senderratchetkeyprivate_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Chain::~Chain() { + // @@protoc_insertion_point(destructor:proto.Chain) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Chain::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.messagekeys_.~RepeatedPtrField(); + _impl_.senderratchetkey_.Destroy(); + _impl_.senderratchetkeyprivate_.Destroy(); + if (this != internal_default_instance()) delete _impl_.chainkey_; +} + +void Chain::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Chain::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Chain) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.messagekeys_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _impl_.senderratchetkey_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.senderratchetkeyprivate_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.chainkey_ != nullptr); + _impl_.chainkey_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Chain::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes senderRatchetKey = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_senderratchetkey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes senderRatchetKeyPrivate = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_senderratchetkeyprivate(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.ChainKey chainKey = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_chainkey(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .proto.MessageKey messageKeys = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_messagekeys(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Chain::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Chain) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes senderRatchetKey = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_senderratchetkey(), target); + } + + // optional bytes senderRatchetKeyPrivate = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_senderratchetkeyprivate(), target); + } + + // optional .proto.ChainKey chainKey = 3; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::chainkey(this), + _Internal::chainkey(this).GetCachedSize(), target, stream); + } + + // repeated .proto.MessageKey messageKeys = 4; + for (unsigned i = 0, + n = static_cast(this->_internal_messagekeys_size()); i < n; i++) { + const auto& repfield = this->_internal_messagekeys(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Chain) + return target; +} + +size_t Chain::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Chain) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.MessageKey messageKeys = 4; + total_size += 1UL * this->_internal_messagekeys_size(); + for (const auto& msg : this->_impl_.messagekeys_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional bytes senderRatchetKey = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_senderratchetkey()); + } + + // optional bytes senderRatchetKeyPrivate = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_senderratchetkeyprivate()); + } + + // optional .proto.ChainKey chainKey = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.chainkey_); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Chain::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Chain::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Chain::GetClassData() const { return &_class_data_; } + + +void Chain::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Chain) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.messagekeys_.MergeFrom(from._impl_.messagekeys_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_senderratchetkey(from._internal_senderratchetkey()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_senderratchetkeyprivate(from._internal_senderratchetkeyprivate()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_chainkey()->::proto::ChainKey::MergeFrom( + from._internal_chainkey()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Chain::CopyFrom(const Chain& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Chain) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Chain::IsInitialized() const { + return true; +} + +void Chain::InternalSwap(Chain* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.messagekeys_.InternalSwap(&other->_impl_.messagekeys_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.senderratchetkey_, lhs_arena, + &other->_impl_.senderratchetkey_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.senderratchetkeyprivate_, lhs_arena, + &other->_impl_.senderratchetkeyprivate_, rhs_arena + ); + swap(_impl_.chainkey_, other->_impl_.chainkey_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Chain::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[13]); +} + +// =================================================================== + +class ChainKey::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_index(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_key(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +ChainKey::ChainKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.ChainKey) +} +ChainKey::ChainKey(const ChainKey& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + ChainKey* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.key_){} + , decltype(_impl_.index_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.key_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.key_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_key()) { + _this->_impl_.key_.Set(from._internal_key(), + _this->GetArenaForAllocation()); + } + _this->_impl_.index_ = from._impl_.index_; + // @@protoc_insertion_point(copy_constructor:proto.ChainKey) +} + +inline void ChainKey::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.key_){} + , decltype(_impl_.index_){0u} + }; + _impl_.key_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.key_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +ChainKey::~ChainKey() { + // @@protoc_insertion_point(destructor:proto.ChainKey) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ChainKey::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.key_.Destroy(); +} + +void ChainKey::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ChainKey::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.ChainKey) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.key_.ClearNonDefaultToEmpty(); + } + _impl_.index_ = 0u; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ChainKey::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint32 index = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_index(&has_bits); + _impl_.index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes key = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_key(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ChainKey::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.ChainKey) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional uint32 index = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_index(), target); + } + + // optional bytes key = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_key(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.ChainKey) + return target; +} + +size_t ChainKey::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.ChainKey) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional bytes key = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_key()); + } + + // optional uint32 index = 1; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_index()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ChainKey::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + ChainKey::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ChainKey::GetClassData() const { return &_class_data_; } + + +void ChainKey::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.ChainKey) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_key(from._internal_key()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.index_ = from._impl_.index_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ChainKey::CopyFrom(const ChainKey& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.ChainKey) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ChainKey::IsInitialized() const { + return true; +} + +void ChainKey::InternalSwap(ChainKey* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.key_, lhs_arena, + &other->_impl_.key_, rhs_arena + ); + swap(_impl_.index_, other->_impl_.index_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ChainKey::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[14]); +} + +// =================================================================== + +class ClientPayload_DNSSource::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_dnsmethod(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_appcached(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +ClientPayload_DNSSource::ClientPayload_DNSSource(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.ClientPayload.DNSSource) +} +ClientPayload_DNSSource::ClientPayload_DNSSource(const ClientPayload_DNSSource& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + ClientPayload_DNSSource* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.dnsmethod_){} + , decltype(_impl_.appcached_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&_impl_.dnsmethod_, &from._impl_.dnsmethod_, + static_cast(reinterpret_cast(&_impl_.appcached_) - + reinterpret_cast(&_impl_.dnsmethod_)) + sizeof(_impl_.appcached_)); + // @@protoc_insertion_point(copy_constructor:proto.ClientPayload.DNSSource) +} + +inline void ClientPayload_DNSSource::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.dnsmethod_){0} + , decltype(_impl_.appcached_){false} + }; +} + +ClientPayload_DNSSource::~ClientPayload_DNSSource() { + // @@protoc_insertion_point(destructor:proto.ClientPayload.DNSSource) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ClientPayload_DNSSource::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void ClientPayload_DNSSource::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ClientPayload_DNSSource::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.ClientPayload.DNSSource) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + ::memset(&_impl_.dnsmethod_, 0, static_cast( + reinterpret_cast(&_impl_.appcached_) - + reinterpret_cast(&_impl_.dnsmethod_)) + sizeof(_impl_.appcached_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ClientPayload_DNSSource::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.ClientPayload.DNSSource.DNSResolutionMethod dnsMethod = 15; + case 15: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 120)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::ClientPayload_DNSSource_DNSResolutionMethod_IsValid(val))) { + _internal_set_dnsmethod(static_cast<::proto::ClientPayload_DNSSource_DNSResolutionMethod>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(15, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional bool appCached = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 128)) { + _Internal::set_has_appcached(&has_bits); + _impl_.appcached_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ClientPayload_DNSSource::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.ClientPayload.DNSSource) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.ClientPayload.DNSSource.DNSResolutionMethod dnsMethod = 15; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 15, this->_internal_dnsmethod(), target); + } + + // optional bool appCached = 16; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(16, this->_internal_appcached(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.ClientPayload.DNSSource) + return target; +} + +size_t ClientPayload_DNSSource::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.ClientPayload.DNSSource) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional .proto.ClientPayload.DNSSource.DNSResolutionMethod dnsMethod = 15; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_dnsmethod()); + } + + // optional bool appCached = 16; + if (cached_has_bits & 0x00000002u) { + total_size += 2 + 1; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ClientPayload_DNSSource::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + ClientPayload_DNSSource::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ClientPayload_DNSSource::GetClassData() const { return &_class_data_; } + + +void ClientPayload_DNSSource::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.ClientPayload.DNSSource) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_impl_.dnsmethod_ = from._impl_.dnsmethod_; + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.appcached_ = from._impl_.appcached_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ClientPayload_DNSSource::CopyFrom(const ClientPayload_DNSSource& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.ClientPayload.DNSSource) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ClientPayload_DNSSource::IsInitialized() const { + return true; +} + +void ClientPayload_DNSSource::InternalSwap(ClientPayload_DNSSource* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ClientPayload_DNSSource, _impl_.appcached_) + + sizeof(ClientPayload_DNSSource::_impl_.appcached_) + - PROTOBUF_FIELD_OFFSET(ClientPayload_DNSSource, _impl_.dnsmethod_)>( + reinterpret_cast(&_impl_.dnsmethod_), + reinterpret_cast(&other->_impl_.dnsmethod_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ClientPayload_DNSSource::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[15]); +} + +// =================================================================== + +class ClientPayload_DevicePairingRegistrationData::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_eregid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_ekeytype(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_eident(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_eskeyid(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_eskeyval(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_eskeysig(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_buildhash(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_deviceprops(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } +}; + +ClientPayload_DevicePairingRegistrationData::ClientPayload_DevicePairingRegistrationData(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.ClientPayload.DevicePairingRegistrationData) +} +ClientPayload_DevicePairingRegistrationData::ClientPayload_DevicePairingRegistrationData(const ClientPayload_DevicePairingRegistrationData& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + ClientPayload_DevicePairingRegistrationData* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.eregid_){} + , decltype(_impl_.ekeytype_){} + , decltype(_impl_.eident_){} + , decltype(_impl_.eskeyid_){} + , decltype(_impl_.eskeyval_){} + , decltype(_impl_.eskeysig_){} + , decltype(_impl_.buildhash_){} + , decltype(_impl_.deviceprops_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.eregid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.eregid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_eregid()) { + _this->_impl_.eregid_.Set(from._internal_eregid(), + _this->GetArenaForAllocation()); + } + _impl_.ekeytype_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.ekeytype_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_ekeytype()) { + _this->_impl_.ekeytype_.Set(from._internal_ekeytype(), + _this->GetArenaForAllocation()); + } + _impl_.eident_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.eident_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_eident()) { + _this->_impl_.eident_.Set(from._internal_eident(), + _this->GetArenaForAllocation()); + } + _impl_.eskeyid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.eskeyid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_eskeyid()) { + _this->_impl_.eskeyid_.Set(from._internal_eskeyid(), + _this->GetArenaForAllocation()); + } + _impl_.eskeyval_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.eskeyval_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_eskeyval()) { + _this->_impl_.eskeyval_.Set(from._internal_eskeyval(), + _this->GetArenaForAllocation()); + } + _impl_.eskeysig_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.eskeysig_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_eskeysig()) { + _this->_impl_.eskeysig_.Set(from._internal_eskeysig(), + _this->GetArenaForAllocation()); + } + _impl_.buildhash_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.buildhash_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_buildhash()) { + _this->_impl_.buildhash_.Set(from._internal_buildhash(), + _this->GetArenaForAllocation()); + } + _impl_.deviceprops_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.deviceprops_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_deviceprops()) { + _this->_impl_.deviceprops_.Set(from._internal_deviceprops(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.ClientPayload.DevicePairingRegistrationData) +} + +inline void ClientPayload_DevicePairingRegistrationData::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.eregid_){} + , decltype(_impl_.ekeytype_){} + , decltype(_impl_.eident_){} + , decltype(_impl_.eskeyid_){} + , decltype(_impl_.eskeyval_){} + , decltype(_impl_.eskeysig_){} + , decltype(_impl_.buildhash_){} + , decltype(_impl_.deviceprops_){} + }; + _impl_.eregid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.eregid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.ekeytype_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.ekeytype_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.eident_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.eident_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.eskeyid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.eskeyid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.eskeyval_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.eskeyval_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.eskeysig_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.eskeysig_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.buildhash_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.buildhash_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.deviceprops_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.deviceprops_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +ClientPayload_DevicePairingRegistrationData::~ClientPayload_DevicePairingRegistrationData() { + // @@protoc_insertion_point(destructor:proto.ClientPayload.DevicePairingRegistrationData) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ClientPayload_DevicePairingRegistrationData::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.eregid_.Destroy(); + _impl_.ekeytype_.Destroy(); + _impl_.eident_.Destroy(); + _impl_.eskeyid_.Destroy(); + _impl_.eskeyval_.Destroy(); + _impl_.eskeysig_.Destroy(); + _impl_.buildhash_.Destroy(); + _impl_.deviceprops_.Destroy(); +} + +void ClientPayload_DevicePairingRegistrationData::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ClientPayload_DevicePairingRegistrationData::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.ClientPayload.DevicePairingRegistrationData) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _impl_.eregid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.ekeytype_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.eident_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + _impl_.eskeyid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + _impl_.eskeyval_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000020u) { + _impl_.eskeysig_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000040u) { + _impl_.buildhash_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000080u) { + _impl_.deviceprops_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ClientPayload_DevicePairingRegistrationData::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes eRegid = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_eregid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes eKeytype = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_ekeytype(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes eIdent = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_eident(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes eSkeyId = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_eskeyid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes eSkeyVal = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + auto str = _internal_mutable_eskeyval(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes eSkeySig = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + auto str = _internal_mutable_eskeysig(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes buildHash = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + auto str = _internal_mutable_buildhash(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes deviceProps = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + auto str = _internal_mutable_deviceprops(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ClientPayload_DevicePairingRegistrationData::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.ClientPayload.DevicePairingRegistrationData) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes eRegid = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_eregid(), target); + } + + // optional bytes eKeytype = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_ekeytype(), target); + } + + // optional bytes eIdent = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->WriteBytesMaybeAliased( + 3, this->_internal_eident(), target); + } + + // optional bytes eSkeyId = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->WriteBytesMaybeAliased( + 4, this->_internal_eskeyid(), target); + } + + // optional bytes eSkeyVal = 5; + if (cached_has_bits & 0x00000010u) { + target = stream->WriteBytesMaybeAliased( + 5, this->_internal_eskeyval(), target); + } + + // optional bytes eSkeySig = 6; + if (cached_has_bits & 0x00000020u) { + target = stream->WriteBytesMaybeAliased( + 6, this->_internal_eskeysig(), target); + } + + // optional bytes buildHash = 7; + if (cached_has_bits & 0x00000040u) { + target = stream->WriteBytesMaybeAliased( + 7, this->_internal_buildhash(), target); + } + + // optional bytes deviceProps = 8; + if (cached_has_bits & 0x00000080u) { + target = stream->WriteBytesMaybeAliased( + 8, this->_internal_deviceprops(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.ClientPayload.DevicePairingRegistrationData) + return target; +} + +size_t ClientPayload_DevicePairingRegistrationData::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.ClientPayload.DevicePairingRegistrationData) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional bytes eRegid = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_eregid()); + } + + // optional bytes eKeytype = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_ekeytype()); + } + + // optional bytes eIdent = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_eident()); + } + + // optional bytes eSkeyId = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_eskeyid()); + } + + // optional bytes eSkeyVal = 5; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_eskeyval()); + } + + // optional bytes eSkeySig = 6; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_eskeysig()); + } + + // optional bytes buildHash = 7; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_buildhash()); + } + + // optional bytes deviceProps = 8; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_deviceprops()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ClientPayload_DevicePairingRegistrationData::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + ClientPayload_DevicePairingRegistrationData::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ClientPayload_DevicePairingRegistrationData::GetClassData() const { return &_class_data_; } + + +void ClientPayload_DevicePairingRegistrationData::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.ClientPayload.DevicePairingRegistrationData) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_eregid(from._internal_eregid()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_ekeytype(from._internal_ekeytype()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_eident(from._internal_eident()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_set_eskeyid(from._internal_eskeyid()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_set_eskeyval(from._internal_eskeyval()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_set_eskeysig(from._internal_eskeysig()); + } + if (cached_has_bits & 0x00000040u) { + _this->_internal_set_buildhash(from._internal_buildhash()); + } + if (cached_has_bits & 0x00000080u) { + _this->_internal_set_deviceprops(from._internal_deviceprops()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ClientPayload_DevicePairingRegistrationData::CopyFrom(const ClientPayload_DevicePairingRegistrationData& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.ClientPayload.DevicePairingRegistrationData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ClientPayload_DevicePairingRegistrationData::IsInitialized() const { + return true; +} + +void ClientPayload_DevicePairingRegistrationData::InternalSwap(ClientPayload_DevicePairingRegistrationData* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.eregid_, lhs_arena, + &other->_impl_.eregid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.ekeytype_, lhs_arena, + &other->_impl_.ekeytype_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.eident_, lhs_arena, + &other->_impl_.eident_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.eskeyid_, lhs_arena, + &other->_impl_.eskeyid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.eskeyval_, lhs_arena, + &other->_impl_.eskeyval_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.eskeysig_, lhs_arena, + &other->_impl_.eskeysig_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.buildhash_, lhs_arena, + &other->_impl_.buildhash_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.deviceprops_, lhs_arena, + &other->_impl_.deviceprops_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ClientPayload_DevicePairingRegistrationData::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[16]); +} + +// =================================================================== + +class ClientPayload_UserAgent_AppVersion::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_primary(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_secondary(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_tertiary(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_quaternary(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_quinary(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } +}; + +ClientPayload_UserAgent_AppVersion::ClientPayload_UserAgent_AppVersion(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.ClientPayload.UserAgent.AppVersion) +} +ClientPayload_UserAgent_AppVersion::ClientPayload_UserAgent_AppVersion(const ClientPayload_UserAgent_AppVersion& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + ClientPayload_UserAgent_AppVersion* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.primary_){} + , decltype(_impl_.secondary_){} + , decltype(_impl_.tertiary_){} + , decltype(_impl_.quaternary_){} + , decltype(_impl_.quinary_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&_impl_.primary_, &from._impl_.primary_, + static_cast(reinterpret_cast(&_impl_.quinary_) - + reinterpret_cast(&_impl_.primary_)) + sizeof(_impl_.quinary_)); + // @@protoc_insertion_point(copy_constructor:proto.ClientPayload.UserAgent.AppVersion) +} + +inline void ClientPayload_UserAgent_AppVersion::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.primary_){0u} + , decltype(_impl_.secondary_){0u} + , decltype(_impl_.tertiary_){0u} + , decltype(_impl_.quaternary_){0u} + , decltype(_impl_.quinary_){0u} + }; +} + +ClientPayload_UserAgent_AppVersion::~ClientPayload_UserAgent_AppVersion() { + // @@protoc_insertion_point(destructor:proto.ClientPayload.UserAgent.AppVersion) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ClientPayload_UserAgent_AppVersion::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void ClientPayload_UserAgent_AppVersion::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ClientPayload_UserAgent_AppVersion::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.ClientPayload.UserAgent.AppVersion) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + ::memset(&_impl_.primary_, 0, static_cast( + reinterpret_cast(&_impl_.quinary_) - + reinterpret_cast(&_impl_.primary_)) + sizeof(_impl_.quinary_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ClientPayload_UserAgent_AppVersion::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint32 primary = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_primary(&has_bits); + _impl_.primary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 secondary = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_secondary(&has_bits); + _impl_.secondary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 tertiary = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_tertiary(&has_bits); + _impl_.tertiary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 quaternary = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_quaternary(&has_bits); + _impl_.quaternary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 quinary = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_quinary(&has_bits); + _impl_.quinary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ClientPayload_UserAgent_AppVersion::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.ClientPayload.UserAgent.AppVersion) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional uint32 primary = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_primary(), target); + } + + // optional uint32 secondary = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_secondary(), target); + } + + // optional uint32 tertiary = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_tertiary(), target); + } + + // optional uint32 quaternary = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_quaternary(), target); + } + + // optional uint32 quinary = 5; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_quinary(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.ClientPayload.UserAgent.AppVersion) + return target; +} + +size_t ClientPayload_UserAgent_AppVersion::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.ClientPayload.UserAgent.AppVersion) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + // optional uint32 primary = 1; + if (cached_has_bits & 0x00000001u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_primary()); + } + + // optional uint32 secondary = 2; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_secondary()); + } + + // optional uint32 tertiary = 3; + if (cached_has_bits & 0x00000004u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_tertiary()); + } + + // optional uint32 quaternary = 4; + if (cached_has_bits & 0x00000008u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_quaternary()); + } + + // optional uint32 quinary = 5; + if (cached_has_bits & 0x00000010u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_quinary()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ClientPayload_UserAgent_AppVersion::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + ClientPayload_UserAgent_AppVersion::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ClientPayload_UserAgent_AppVersion::GetClassData() const { return &_class_data_; } + + +void ClientPayload_UserAgent_AppVersion::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.ClientPayload.UserAgent.AppVersion) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _this->_impl_.primary_ = from._impl_.primary_; + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.secondary_ = from._impl_.secondary_; + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.tertiary_ = from._impl_.tertiary_; + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.quaternary_ = from._impl_.quaternary_; + } + if (cached_has_bits & 0x00000010u) { + _this->_impl_.quinary_ = from._impl_.quinary_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ClientPayload_UserAgent_AppVersion::CopyFrom(const ClientPayload_UserAgent_AppVersion& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.ClientPayload.UserAgent.AppVersion) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ClientPayload_UserAgent_AppVersion::IsInitialized() const { + return true; +} + +void ClientPayload_UserAgent_AppVersion::InternalSwap(ClientPayload_UserAgent_AppVersion* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ClientPayload_UserAgent_AppVersion, _impl_.quinary_) + + sizeof(ClientPayload_UserAgent_AppVersion::_impl_.quinary_) + - PROTOBUF_FIELD_OFFSET(ClientPayload_UserAgent_AppVersion, _impl_.primary_)>( + reinterpret_cast(&_impl_.primary_), + reinterpret_cast(&other->_impl_.primary_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ClientPayload_UserAgent_AppVersion::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[17]); +} + +// =================================================================== + +class ClientPayload_UserAgent::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_platform(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static const ::proto::ClientPayload_UserAgent_AppVersion& appversion(const ClientPayload_UserAgent* msg); + static void set_has_appversion(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static void set_has_mcc(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_mnc(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_osversion(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_manufacturer(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_device(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_osbuildnumber(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_phoneid(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_releasechannel(HasBits* has_bits) { + (*has_bits)[0] |= 4096u; + } + static void set_has_localelanguageiso6391(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_localecountryiso31661alpha2(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_deviceboard(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } +}; + +const ::proto::ClientPayload_UserAgent_AppVersion& +ClientPayload_UserAgent::_Internal::appversion(const ClientPayload_UserAgent* msg) { + return *msg->_impl_.appversion_; +} +ClientPayload_UserAgent::ClientPayload_UserAgent(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.ClientPayload.UserAgent) +} +ClientPayload_UserAgent::ClientPayload_UserAgent(const ClientPayload_UserAgent& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + ClientPayload_UserAgent* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.mcc_){} + , decltype(_impl_.mnc_){} + , decltype(_impl_.osversion_){} + , decltype(_impl_.manufacturer_){} + , decltype(_impl_.device_){} + , decltype(_impl_.osbuildnumber_){} + , decltype(_impl_.phoneid_){} + , decltype(_impl_.localelanguageiso6391_){} + , decltype(_impl_.localecountryiso31661alpha2_){} + , decltype(_impl_.deviceboard_){} + , decltype(_impl_.appversion_){nullptr} + , decltype(_impl_.platform_){} + , decltype(_impl_.releasechannel_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.mcc_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mcc_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_mcc()) { + _this->_impl_.mcc_.Set(from._internal_mcc(), + _this->GetArenaForAllocation()); + } + _impl_.mnc_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mnc_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_mnc()) { + _this->_impl_.mnc_.Set(from._internal_mnc(), + _this->GetArenaForAllocation()); + } + _impl_.osversion_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.osversion_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_osversion()) { + _this->_impl_.osversion_.Set(from._internal_osversion(), + _this->GetArenaForAllocation()); + } + _impl_.manufacturer_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.manufacturer_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_manufacturer()) { + _this->_impl_.manufacturer_.Set(from._internal_manufacturer(), + _this->GetArenaForAllocation()); + } + _impl_.device_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.device_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_device()) { + _this->_impl_.device_.Set(from._internal_device(), + _this->GetArenaForAllocation()); + } + _impl_.osbuildnumber_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.osbuildnumber_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_osbuildnumber()) { + _this->_impl_.osbuildnumber_.Set(from._internal_osbuildnumber(), + _this->GetArenaForAllocation()); + } + _impl_.phoneid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.phoneid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_phoneid()) { + _this->_impl_.phoneid_.Set(from._internal_phoneid(), + _this->GetArenaForAllocation()); + } + _impl_.localelanguageiso6391_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.localelanguageiso6391_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_localelanguageiso6391()) { + _this->_impl_.localelanguageiso6391_.Set(from._internal_localelanguageiso6391(), + _this->GetArenaForAllocation()); + } + _impl_.localecountryiso31661alpha2_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.localecountryiso31661alpha2_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_localecountryiso31661alpha2()) { + _this->_impl_.localecountryiso31661alpha2_.Set(from._internal_localecountryiso31661alpha2(), + _this->GetArenaForAllocation()); + } + _impl_.deviceboard_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.deviceboard_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_deviceboard()) { + _this->_impl_.deviceboard_.Set(from._internal_deviceboard(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_appversion()) { + _this->_impl_.appversion_ = new ::proto::ClientPayload_UserAgent_AppVersion(*from._impl_.appversion_); + } + ::memcpy(&_impl_.platform_, &from._impl_.platform_, + static_cast(reinterpret_cast(&_impl_.releasechannel_) - + reinterpret_cast(&_impl_.platform_)) + sizeof(_impl_.releasechannel_)); + // @@protoc_insertion_point(copy_constructor:proto.ClientPayload.UserAgent) +} + +inline void ClientPayload_UserAgent::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.mcc_){} + , decltype(_impl_.mnc_){} + , decltype(_impl_.osversion_){} + , decltype(_impl_.manufacturer_){} + , decltype(_impl_.device_){} + , decltype(_impl_.osbuildnumber_){} + , decltype(_impl_.phoneid_){} + , decltype(_impl_.localelanguageiso6391_){} + , decltype(_impl_.localecountryiso31661alpha2_){} + , decltype(_impl_.deviceboard_){} + , decltype(_impl_.appversion_){nullptr} + , decltype(_impl_.platform_){0} + , decltype(_impl_.releasechannel_){0} + }; + _impl_.mcc_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mcc_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mnc_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mnc_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.osversion_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.osversion_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.manufacturer_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.manufacturer_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.device_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.device_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.osbuildnumber_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.osbuildnumber_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.phoneid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.phoneid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.localelanguageiso6391_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.localelanguageiso6391_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.localecountryiso31661alpha2_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.localecountryiso31661alpha2_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.deviceboard_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.deviceboard_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +ClientPayload_UserAgent::~ClientPayload_UserAgent() { + // @@protoc_insertion_point(destructor:proto.ClientPayload.UserAgent) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ClientPayload_UserAgent::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.mcc_.Destroy(); + _impl_.mnc_.Destroy(); + _impl_.osversion_.Destroy(); + _impl_.manufacturer_.Destroy(); + _impl_.device_.Destroy(); + _impl_.osbuildnumber_.Destroy(); + _impl_.phoneid_.Destroy(); + _impl_.localelanguageiso6391_.Destroy(); + _impl_.localecountryiso31661alpha2_.Destroy(); + _impl_.deviceboard_.Destroy(); + if (this != internal_default_instance()) delete _impl_.appversion_; +} + +void ClientPayload_UserAgent::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ClientPayload_UserAgent::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.ClientPayload.UserAgent) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _impl_.mcc_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.mnc_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.osversion_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + _impl_.manufacturer_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + _impl_.device_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000020u) { + _impl_.osbuildnumber_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000040u) { + _impl_.phoneid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000080u) { + _impl_.localelanguageiso6391_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x00000700u) { + if (cached_has_bits & 0x00000100u) { + _impl_.localecountryiso31661alpha2_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000200u) { + _impl_.deviceboard_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000400u) { + GOOGLE_DCHECK(_impl_.appversion_ != nullptr); + _impl_.appversion_->Clear(); + } + } + if (cached_has_bits & 0x00001800u) { + ::memset(&_impl_.platform_, 0, static_cast( + reinterpret_cast(&_impl_.releasechannel_) - + reinterpret_cast(&_impl_.platform_)) + sizeof(_impl_.releasechannel_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ClientPayload_UserAgent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.ClientPayload.UserAgent.Platform platform = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::ClientPayload_UserAgent_Platform_IsValid(val))) { + _internal_set_platform(static_cast<::proto::ClientPayload_UserAgent_Platform>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.ClientPayload.UserAgent.AppVersion appVersion = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_appversion(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string mcc = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_mcc(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ClientPayload.UserAgent.mcc"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string mnc = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_mnc(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ClientPayload.UserAgent.mnc"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string osVersion = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + auto str = _internal_mutable_osversion(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ClientPayload.UserAgent.osVersion"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string manufacturer = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + auto str = _internal_mutable_manufacturer(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ClientPayload.UserAgent.manufacturer"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string device = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + auto str = _internal_mutable_device(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ClientPayload.UserAgent.device"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string osBuildNumber = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + auto str = _internal_mutable_osbuildnumber(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ClientPayload.UserAgent.osBuildNumber"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string phoneId = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + auto str = _internal_mutable_phoneid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ClientPayload.UserAgent.phoneId"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.ClientPayload.UserAgent.ReleaseChannel releaseChannel = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::ClientPayload_UserAgent_ReleaseChannel_IsValid(val))) { + _internal_set_releasechannel(static_cast<::proto::ClientPayload_UserAgent_ReleaseChannel>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(10, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional string localeLanguageIso6391 = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { + auto str = _internal_mutable_localelanguageiso6391(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ClientPayload.UserAgent.localeLanguageIso6391"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string localeCountryIso31661Alpha2 = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { + auto str = _internal_mutable_localecountryiso31661alpha2(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ClientPayload.UserAgent.localeCountryIso31661Alpha2"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string deviceBoard = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { + auto str = _internal_mutable_deviceboard(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ClientPayload.UserAgent.deviceBoard"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ClientPayload_UserAgent::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.ClientPayload.UserAgent) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.ClientPayload.UserAgent.Platform platform = 1; + if (cached_has_bits & 0x00000800u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this->_internal_platform(), target); + } + + // optional .proto.ClientPayload.UserAgent.AppVersion appVersion = 2; + if (cached_has_bits & 0x00000400u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::appversion(this), + _Internal::appversion(this).GetCachedSize(), target, stream); + } + + // optional string mcc = 3; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_mcc().data(), static_cast(this->_internal_mcc().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ClientPayload.UserAgent.mcc"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_mcc(), target); + } + + // optional string mnc = 4; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_mnc().data(), static_cast(this->_internal_mnc().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ClientPayload.UserAgent.mnc"); + target = stream->WriteStringMaybeAliased( + 4, this->_internal_mnc(), target); + } + + // optional string osVersion = 5; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_osversion().data(), static_cast(this->_internal_osversion().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ClientPayload.UserAgent.osVersion"); + target = stream->WriteStringMaybeAliased( + 5, this->_internal_osversion(), target); + } + + // optional string manufacturer = 6; + if (cached_has_bits & 0x00000008u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_manufacturer().data(), static_cast(this->_internal_manufacturer().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ClientPayload.UserAgent.manufacturer"); + target = stream->WriteStringMaybeAliased( + 6, this->_internal_manufacturer(), target); + } + + // optional string device = 7; + if (cached_has_bits & 0x00000010u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_device().data(), static_cast(this->_internal_device().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ClientPayload.UserAgent.device"); + target = stream->WriteStringMaybeAliased( + 7, this->_internal_device(), target); + } + + // optional string osBuildNumber = 8; + if (cached_has_bits & 0x00000020u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_osbuildnumber().data(), static_cast(this->_internal_osbuildnumber().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ClientPayload.UserAgent.osBuildNumber"); + target = stream->WriteStringMaybeAliased( + 8, this->_internal_osbuildnumber(), target); + } + + // optional string phoneId = 9; + if (cached_has_bits & 0x00000040u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_phoneid().data(), static_cast(this->_internal_phoneid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ClientPayload.UserAgent.phoneId"); + target = stream->WriteStringMaybeAliased( + 9, this->_internal_phoneid(), target); + } + + // optional .proto.ClientPayload.UserAgent.ReleaseChannel releaseChannel = 10; + if (cached_has_bits & 0x00001000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 10, this->_internal_releasechannel(), target); + } + + // optional string localeLanguageIso6391 = 11; + if (cached_has_bits & 0x00000080u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_localelanguageiso6391().data(), static_cast(this->_internal_localelanguageiso6391().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ClientPayload.UserAgent.localeLanguageIso6391"); + target = stream->WriteStringMaybeAliased( + 11, this->_internal_localelanguageiso6391(), target); + } + + // optional string localeCountryIso31661Alpha2 = 12; + if (cached_has_bits & 0x00000100u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_localecountryiso31661alpha2().data(), static_cast(this->_internal_localecountryiso31661alpha2().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ClientPayload.UserAgent.localeCountryIso31661Alpha2"); + target = stream->WriteStringMaybeAliased( + 12, this->_internal_localecountryiso31661alpha2(), target); + } + + // optional string deviceBoard = 13; + if (cached_has_bits & 0x00000200u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_deviceboard().data(), static_cast(this->_internal_deviceboard().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ClientPayload.UserAgent.deviceBoard"); + target = stream->WriteStringMaybeAliased( + 13, this->_internal_deviceboard(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.ClientPayload.UserAgent) + return target; +} + +size_t ClientPayload_UserAgent::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.ClientPayload.UserAgent) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string mcc = 3; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_mcc()); + } + + // optional string mnc = 4; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_mnc()); + } + + // optional string osVersion = 5; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_osversion()); + } + + // optional string manufacturer = 6; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_manufacturer()); + } + + // optional string device = 7; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_device()); + } + + // optional string osBuildNumber = 8; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_osbuildnumber()); + } + + // optional string phoneId = 9; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_phoneid()); + } + + // optional string localeLanguageIso6391 = 11; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_localelanguageiso6391()); + } + + } + if (cached_has_bits & 0x00001f00u) { + // optional string localeCountryIso31661Alpha2 = 12; + if (cached_has_bits & 0x00000100u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_localecountryiso31661alpha2()); + } + + // optional string deviceBoard = 13; + if (cached_has_bits & 0x00000200u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_deviceboard()); + } + + // optional .proto.ClientPayload.UserAgent.AppVersion appVersion = 2; + if (cached_has_bits & 0x00000400u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.appversion_); + } + + // optional .proto.ClientPayload.UserAgent.Platform platform = 1; + if (cached_has_bits & 0x00000800u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_platform()); + } + + // optional .proto.ClientPayload.UserAgent.ReleaseChannel releaseChannel = 10; + if (cached_has_bits & 0x00001000u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_releasechannel()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ClientPayload_UserAgent::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + ClientPayload_UserAgent::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ClientPayload_UserAgent::GetClassData() const { return &_class_data_; } + + +void ClientPayload_UserAgent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.ClientPayload.UserAgent) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_mcc(from._internal_mcc()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_mnc(from._internal_mnc()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_osversion(from._internal_osversion()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_set_manufacturer(from._internal_manufacturer()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_set_device(from._internal_device()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_set_osbuildnumber(from._internal_osbuildnumber()); + } + if (cached_has_bits & 0x00000040u) { + _this->_internal_set_phoneid(from._internal_phoneid()); + } + if (cached_has_bits & 0x00000080u) { + _this->_internal_set_localelanguageiso6391(from._internal_localelanguageiso6391()); + } + } + if (cached_has_bits & 0x00001f00u) { + if (cached_has_bits & 0x00000100u) { + _this->_internal_set_localecountryiso31661alpha2(from._internal_localecountryiso31661alpha2()); + } + if (cached_has_bits & 0x00000200u) { + _this->_internal_set_deviceboard(from._internal_deviceboard()); + } + if (cached_has_bits & 0x00000400u) { + _this->_internal_mutable_appversion()->::proto::ClientPayload_UserAgent_AppVersion::MergeFrom( + from._internal_appversion()); + } + if (cached_has_bits & 0x00000800u) { + _this->_impl_.platform_ = from._impl_.platform_; + } + if (cached_has_bits & 0x00001000u) { + _this->_impl_.releasechannel_ = from._impl_.releasechannel_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ClientPayload_UserAgent::CopyFrom(const ClientPayload_UserAgent& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.ClientPayload.UserAgent) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ClientPayload_UserAgent::IsInitialized() const { + return true; +} + +void ClientPayload_UserAgent::InternalSwap(ClientPayload_UserAgent* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.mcc_, lhs_arena, + &other->_impl_.mcc_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.mnc_, lhs_arena, + &other->_impl_.mnc_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.osversion_, lhs_arena, + &other->_impl_.osversion_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.manufacturer_, lhs_arena, + &other->_impl_.manufacturer_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.device_, lhs_arena, + &other->_impl_.device_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.osbuildnumber_, lhs_arena, + &other->_impl_.osbuildnumber_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.phoneid_, lhs_arena, + &other->_impl_.phoneid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.localelanguageiso6391_, lhs_arena, + &other->_impl_.localelanguageiso6391_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.localecountryiso31661alpha2_, lhs_arena, + &other->_impl_.localecountryiso31661alpha2_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.deviceboard_, lhs_arena, + &other->_impl_.deviceboard_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ClientPayload_UserAgent, _impl_.releasechannel_) + + sizeof(ClientPayload_UserAgent::_impl_.releasechannel_) + - PROTOBUF_FIELD_OFFSET(ClientPayload_UserAgent, _impl_.appversion_)>( + reinterpret_cast(&_impl_.appversion_), + reinterpret_cast(&other->_impl_.appversion_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ClientPayload_UserAgent::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[18]); +} + +// =================================================================== + +class ClientPayload_WebInfo_WebdPayload::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_usesparticipantinkey(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_supportsstarredmessages(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_supportsdocumentmessages(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_supportsurlmessages(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_supportsmediaretry(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_supportse2eimage(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_supportse2evideo(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_supportse2eaudio(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_supportse2edocument(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static void set_has_documenttypes(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_features(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +ClientPayload_WebInfo_WebdPayload::ClientPayload_WebInfo_WebdPayload(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.ClientPayload.WebInfo.WebdPayload) +} +ClientPayload_WebInfo_WebdPayload::ClientPayload_WebInfo_WebdPayload(const ClientPayload_WebInfo_WebdPayload& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + ClientPayload_WebInfo_WebdPayload* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.documenttypes_){} + , decltype(_impl_.features_){} + , decltype(_impl_.usesparticipantinkey_){} + , decltype(_impl_.supportsstarredmessages_){} + , decltype(_impl_.supportsdocumentmessages_){} + , decltype(_impl_.supportsurlmessages_){} + , decltype(_impl_.supportsmediaretry_){} + , decltype(_impl_.supportse2eimage_){} + , decltype(_impl_.supportse2evideo_){} + , decltype(_impl_.supportse2eaudio_){} + , decltype(_impl_.supportse2edocument_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.documenttypes_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.documenttypes_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_documenttypes()) { + _this->_impl_.documenttypes_.Set(from._internal_documenttypes(), + _this->GetArenaForAllocation()); + } + _impl_.features_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.features_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_features()) { + _this->_impl_.features_.Set(from._internal_features(), + _this->GetArenaForAllocation()); + } + ::memcpy(&_impl_.usesparticipantinkey_, &from._impl_.usesparticipantinkey_, + static_cast(reinterpret_cast(&_impl_.supportse2edocument_) - + reinterpret_cast(&_impl_.usesparticipantinkey_)) + sizeof(_impl_.supportse2edocument_)); + // @@protoc_insertion_point(copy_constructor:proto.ClientPayload.WebInfo.WebdPayload) +} + +inline void ClientPayload_WebInfo_WebdPayload::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.documenttypes_){} + , decltype(_impl_.features_){} + , decltype(_impl_.usesparticipantinkey_){false} + , decltype(_impl_.supportsstarredmessages_){false} + , decltype(_impl_.supportsdocumentmessages_){false} + , decltype(_impl_.supportsurlmessages_){false} + , decltype(_impl_.supportsmediaretry_){false} + , decltype(_impl_.supportse2eimage_){false} + , decltype(_impl_.supportse2evideo_){false} + , decltype(_impl_.supportse2eaudio_){false} + , decltype(_impl_.supportse2edocument_){false} + }; + _impl_.documenttypes_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.documenttypes_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.features_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.features_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +ClientPayload_WebInfo_WebdPayload::~ClientPayload_WebInfo_WebdPayload() { + // @@protoc_insertion_point(destructor:proto.ClientPayload.WebInfo.WebdPayload) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ClientPayload_WebInfo_WebdPayload::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.documenttypes_.Destroy(); + _impl_.features_.Destroy(); +} + +void ClientPayload_WebInfo_WebdPayload::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ClientPayload_WebInfo_WebdPayload::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.ClientPayload.WebInfo.WebdPayload) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.documenttypes_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.features_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x000000fcu) { + ::memset(&_impl_.usesparticipantinkey_, 0, static_cast( + reinterpret_cast(&_impl_.supportse2eimage_) - + reinterpret_cast(&_impl_.usesparticipantinkey_)) + sizeof(_impl_.supportse2eimage_)); + } + if (cached_has_bits & 0x00000700u) { + ::memset(&_impl_.supportse2evideo_, 0, static_cast( + reinterpret_cast(&_impl_.supportse2edocument_) - + reinterpret_cast(&_impl_.supportse2evideo_)) + sizeof(_impl_.supportse2edocument_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ClientPayload_WebInfo_WebdPayload::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bool usesParticipantInKey = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_usesparticipantinkey(&has_bits); + _impl_.usesparticipantinkey_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool supportsStarredMessages = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_supportsstarredmessages(&has_bits); + _impl_.supportsstarredmessages_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool supportsDocumentMessages = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_supportsdocumentmessages(&has_bits); + _impl_.supportsdocumentmessages_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool supportsUrlMessages = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_supportsurlmessages(&has_bits); + _impl_.supportsurlmessages_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool supportsMediaRetry = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_supportsmediaretry(&has_bits); + _impl_.supportsmediaretry_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool supportsE2EImage = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + _Internal::set_has_supportse2eimage(&has_bits); + _impl_.supportse2eimage_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool supportsE2EVideo = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + _Internal::set_has_supportse2evideo(&has_bits); + _impl_.supportse2evideo_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool supportsE2EAudio = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { + _Internal::set_has_supportse2eaudio(&has_bits); + _impl_.supportse2eaudio_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool supportsE2EDocument = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { + _Internal::set_has_supportse2edocument(&has_bits); + _impl_.supportse2edocument_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string documentTypes = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { + auto str = _internal_mutable_documenttypes(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ClientPayload.WebInfo.WebdPayload.documentTypes"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bytes features = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { + auto str = _internal_mutable_features(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ClientPayload_WebInfo_WebdPayload::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.ClientPayload.WebInfo.WebdPayload) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bool usesParticipantInKey = 1; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_usesparticipantinkey(), target); + } + + // optional bool supportsStarredMessages = 2; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(2, this->_internal_supportsstarredmessages(), target); + } + + // optional bool supportsDocumentMessages = 3; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_supportsdocumentmessages(), target); + } + + // optional bool supportsUrlMessages = 4; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(4, this->_internal_supportsurlmessages(), target); + } + + // optional bool supportsMediaRetry = 5; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(5, this->_internal_supportsmediaretry(), target); + } + + // optional bool supportsE2EImage = 6; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(6, this->_internal_supportse2eimage(), target); + } + + // optional bool supportsE2EVideo = 7; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(7, this->_internal_supportse2evideo(), target); + } + + // optional bool supportsE2EAudio = 8; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(8, this->_internal_supportse2eaudio(), target); + } + + // optional bool supportsE2EDocument = 9; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(9, this->_internal_supportse2edocument(), target); + } + + // optional string documentTypes = 10; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_documenttypes().data(), static_cast(this->_internal_documenttypes().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ClientPayload.WebInfo.WebdPayload.documentTypes"); + target = stream->WriteStringMaybeAliased( + 10, this->_internal_documenttypes(), target); + } + + // optional bytes features = 11; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 11, this->_internal_features(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.ClientPayload.WebInfo.WebdPayload) + return target; +} + +size_t ClientPayload_WebInfo_WebdPayload::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.ClientPayload.WebInfo.WebdPayload) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string documentTypes = 10; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_documenttypes()); + } + + // optional bytes features = 11; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_features()); + } + + // optional bool usesParticipantInKey = 1; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 1; + } + + // optional bool supportsStarredMessages = 2; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 1; + } + + // optional bool supportsDocumentMessages = 3; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + 1; + } + + // optional bool supportsUrlMessages = 4; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + 1; + } + + // optional bool supportsMediaRetry = 5; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + 1; + } + + // optional bool supportsE2EImage = 6; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + 1; + } + + } + if (cached_has_bits & 0x00000700u) { + // optional bool supportsE2EVideo = 7; + if (cached_has_bits & 0x00000100u) { + total_size += 1 + 1; + } + + // optional bool supportsE2EAudio = 8; + if (cached_has_bits & 0x00000200u) { + total_size += 1 + 1; + } + + // optional bool supportsE2EDocument = 9; + if (cached_has_bits & 0x00000400u) { + total_size += 1 + 1; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ClientPayload_WebInfo_WebdPayload::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + ClientPayload_WebInfo_WebdPayload::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ClientPayload_WebInfo_WebdPayload::GetClassData() const { return &_class_data_; } + + +void ClientPayload_WebInfo_WebdPayload::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.ClientPayload.WebInfo.WebdPayload) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_documenttypes(from._internal_documenttypes()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_features(from._internal_features()); + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.usesparticipantinkey_ = from._impl_.usesparticipantinkey_; + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.supportsstarredmessages_ = from._impl_.supportsstarredmessages_; + } + if (cached_has_bits & 0x00000010u) { + _this->_impl_.supportsdocumentmessages_ = from._impl_.supportsdocumentmessages_; + } + if (cached_has_bits & 0x00000020u) { + _this->_impl_.supportsurlmessages_ = from._impl_.supportsurlmessages_; + } + if (cached_has_bits & 0x00000040u) { + _this->_impl_.supportsmediaretry_ = from._impl_.supportsmediaretry_; + } + if (cached_has_bits & 0x00000080u) { + _this->_impl_.supportse2eimage_ = from._impl_.supportse2eimage_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00000700u) { + if (cached_has_bits & 0x00000100u) { + _this->_impl_.supportse2evideo_ = from._impl_.supportse2evideo_; + } + if (cached_has_bits & 0x00000200u) { + _this->_impl_.supportse2eaudio_ = from._impl_.supportse2eaudio_; + } + if (cached_has_bits & 0x00000400u) { + _this->_impl_.supportse2edocument_ = from._impl_.supportse2edocument_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ClientPayload_WebInfo_WebdPayload::CopyFrom(const ClientPayload_WebInfo_WebdPayload& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.ClientPayload.WebInfo.WebdPayload) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ClientPayload_WebInfo_WebdPayload::IsInitialized() const { + return true; +} + +void ClientPayload_WebInfo_WebdPayload::InternalSwap(ClientPayload_WebInfo_WebdPayload* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.documenttypes_, lhs_arena, + &other->_impl_.documenttypes_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.features_, lhs_arena, + &other->_impl_.features_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ClientPayload_WebInfo_WebdPayload, _impl_.supportse2edocument_) + + sizeof(ClientPayload_WebInfo_WebdPayload::_impl_.supportse2edocument_) + - PROTOBUF_FIELD_OFFSET(ClientPayload_WebInfo_WebdPayload, _impl_.usesparticipantinkey_)>( + reinterpret_cast(&_impl_.usesparticipantinkey_), + reinterpret_cast(&other->_impl_.usesparticipantinkey_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ClientPayload_WebInfo_WebdPayload::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[19]); +} + +// =================================================================== + +class ClientPayload_WebInfo::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_reftoken(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_version(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::proto::ClientPayload_WebInfo_WebdPayload& webdpayload(const ClientPayload_WebInfo* msg); + static void set_has_webdpayload(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_websubplatform(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +const ::proto::ClientPayload_WebInfo_WebdPayload& +ClientPayload_WebInfo::_Internal::webdpayload(const ClientPayload_WebInfo* msg) { + return *msg->_impl_.webdpayload_; +} +ClientPayload_WebInfo::ClientPayload_WebInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.ClientPayload.WebInfo) +} +ClientPayload_WebInfo::ClientPayload_WebInfo(const ClientPayload_WebInfo& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + ClientPayload_WebInfo* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.reftoken_){} + , decltype(_impl_.version_){} + , decltype(_impl_.webdpayload_){nullptr} + , decltype(_impl_.websubplatform_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.reftoken_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.reftoken_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_reftoken()) { + _this->_impl_.reftoken_.Set(from._internal_reftoken(), + _this->GetArenaForAllocation()); + } + _impl_.version_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.version_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_version()) { + _this->_impl_.version_.Set(from._internal_version(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_webdpayload()) { + _this->_impl_.webdpayload_ = new ::proto::ClientPayload_WebInfo_WebdPayload(*from._impl_.webdpayload_); + } + _this->_impl_.websubplatform_ = from._impl_.websubplatform_; + // @@protoc_insertion_point(copy_constructor:proto.ClientPayload.WebInfo) +} + +inline void ClientPayload_WebInfo::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.reftoken_){} + , decltype(_impl_.version_){} + , decltype(_impl_.webdpayload_){nullptr} + , decltype(_impl_.websubplatform_){0} + }; + _impl_.reftoken_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.reftoken_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.version_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.version_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +ClientPayload_WebInfo::~ClientPayload_WebInfo() { + // @@protoc_insertion_point(destructor:proto.ClientPayload.WebInfo) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ClientPayload_WebInfo::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.reftoken_.Destroy(); + _impl_.version_.Destroy(); + if (this != internal_default_instance()) delete _impl_.webdpayload_; +} + +void ClientPayload_WebInfo::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ClientPayload_WebInfo::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.ClientPayload.WebInfo) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _impl_.reftoken_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.version_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.webdpayload_ != nullptr); + _impl_.webdpayload_->Clear(); + } + } + _impl_.websubplatform_ = 0; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ClientPayload_WebInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string refToken = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_reftoken(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ClientPayload.WebInfo.refToken"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string version = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_version(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ClientPayload.WebInfo.version"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.ClientPayload.WebInfo.WebdPayload webdPayload = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_webdpayload(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.ClientPayload.WebInfo.WebSubPlatform webSubPlatform = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::ClientPayload_WebInfo_WebSubPlatform_IsValid(val))) { + _internal_set_websubplatform(static_cast<::proto::ClientPayload_WebInfo_WebSubPlatform>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ClientPayload_WebInfo::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.ClientPayload.WebInfo) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string refToken = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_reftoken().data(), static_cast(this->_internal_reftoken().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ClientPayload.WebInfo.refToken"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_reftoken(), target); + } + + // optional string version = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_version().data(), static_cast(this->_internal_version().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ClientPayload.WebInfo.version"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_version(), target); + } + + // optional .proto.ClientPayload.WebInfo.WebdPayload webdPayload = 3; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::webdpayload(this), + _Internal::webdpayload(this).GetCachedSize(), target, stream); + } + + // optional .proto.ClientPayload.WebInfo.WebSubPlatform webSubPlatform = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 4, this->_internal_websubplatform(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.ClientPayload.WebInfo) + return target; +} + +size_t ClientPayload_WebInfo::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.ClientPayload.WebInfo) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional string refToken = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_reftoken()); + } + + // optional string version = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_version()); + } + + // optional .proto.ClientPayload.WebInfo.WebdPayload webdPayload = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.webdpayload_); + } + + // optional .proto.ClientPayload.WebInfo.WebSubPlatform webSubPlatform = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_websubplatform()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ClientPayload_WebInfo::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + ClientPayload_WebInfo::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ClientPayload_WebInfo::GetClassData() const { return &_class_data_; } + + +void ClientPayload_WebInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.ClientPayload.WebInfo) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_reftoken(from._internal_reftoken()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_version(from._internal_version()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_webdpayload()->::proto::ClientPayload_WebInfo_WebdPayload::MergeFrom( + from._internal_webdpayload()); + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.websubplatform_ = from._impl_.websubplatform_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ClientPayload_WebInfo::CopyFrom(const ClientPayload_WebInfo& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.ClientPayload.WebInfo) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ClientPayload_WebInfo::IsInitialized() const { + return true; +} + +void ClientPayload_WebInfo::InternalSwap(ClientPayload_WebInfo* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.reftoken_, lhs_arena, + &other->_impl_.reftoken_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.version_, lhs_arena, + &other->_impl_.version_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ClientPayload_WebInfo, _impl_.websubplatform_) + + sizeof(ClientPayload_WebInfo::_impl_.websubplatform_) + - PROTOBUF_FIELD_OFFSET(ClientPayload_WebInfo, _impl_.webdpayload_)>( + reinterpret_cast(&_impl_.webdpayload_), + reinterpret_cast(&other->_impl_.webdpayload_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ClientPayload_WebInfo::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[20]); +} + +// =================================================================== + +class ClientPayload::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_username(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_passive(HasBits* has_bits) { + (*has_bits)[0] |= 16384u; + } + static const ::proto::ClientPayload_UserAgent& useragent(const ClientPayload* msg); + static void set_has_useragent(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static const ::proto::ClientPayload_WebInfo& webinfo(const ClientPayload* msg); + static void set_has_webinfo(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_pushname(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_sessionid(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static void set_has_shortconnect(HasBits* has_bits) { + (*has_bits)[0] |= 32768u; + } + static void set_has_connecttype(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static void set_has_connectreason(HasBits* has_bits) { + (*has_bits)[0] |= 4096u; + } + static const ::proto::ClientPayload_DNSSource& dnssource(const ClientPayload* msg); + static void set_has_dnssource(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_connectattemptcount(HasBits* has_bits) { + (*has_bits)[0] |= 8192u; + } + static void set_has_device(HasBits* has_bits) { + (*has_bits)[0] |= 262144u; + } + static const ::proto::ClientPayload_DevicePairingRegistrationData& devicepairingdata(const ClientPayload* msg); + static void set_has_devicepairingdata(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_product(HasBits* has_bits) { + (*has_bits)[0] |= 524288u; + } + static void set_has_fbcat(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_fbuseragent(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_oc(HasBits* has_bits) { + (*has_bits)[0] |= 65536u; + } + static void set_has_lc(HasBits* has_bits) { + (*has_bits)[0] |= 1048576u; + } + static void set_has_iosappextension(HasBits* has_bits) { + (*has_bits)[0] |= 4194304u; + } + static void set_has_fbappid(HasBits* has_bits) { + (*has_bits)[0] |= 2097152u; + } + static void set_has_fbdeviceid(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_pull(HasBits* has_bits) { + (*has_bits)[0] |= 131072u; + } + static void set_has_paddingbytes(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } +}; + +const ::proto::ClientPayload_UserAgent& +ClientPayload::_Internal::useragent(const ClientPayload* msg) { + return *msg->_impl_.useragent_; +} +const ::proto::ClientPayload_WebInfo& +ClientPayload::_Internal::webinfo(const ClientPayload* msg) { + return *msg->_impl_.webinfo_; +} +const ::proto::ClientPayload_DNSSource& +ClientPayload::_Internal::dnssource(const ClientPayload* msg) { + return *msg->_impl_.dnssource_; +} +const ::proto::ClientPayload_DevicePairingRegistrationData& +ClientPayload::_Internal::devicepairingdata(const ClientPayload* msg) { + return *msg->_impl_.devicepairingdata_; +} +ClientPayload::ClientPayload(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.ClientPayload) +} +ClientPayload::ClientPayload(const ClientPayload& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + ClientPayload* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.shards_){from._impl_.shards_} + , decltype(_impl_.pushname_){} + , decltype(_impl_.fbcat_){} + , decltype(_impl_.fbuseragent_){} + , decltype(_impl_.fbdeviceid_){} + , decltype(_impl_.paddingbytes_){} + , decltype(_impl_.useragent_){nullptr} + , decltype(_impl_.webinfo_){nullptr} + , decltype(_impl_.dnssource_){nullptr} + , decltype(_impl_.devicepairingdata_){nullptr} + , decltype(_impl_.username_){} + , decltype(_impl_.sessionid_){} + , decltype(_impl_.connecttype_){} + , decltype(_impl_.connectreason_){} + , decltype(_impl_.connectattemptcount_){} + , decltype(_impl_.passive_){} + , decltype(_impl_.shortconnect_){} + , decltype(_impl_.oc_){} + , decltype(_impl_.pull_){} + , decltype(_impl_.device_){} + , decltype(_impl_.product_){} + , decltype(_impl_.lc_){} + , decltype(_impl_.fbappid_){} + , decltype(_impl_.iosappextension_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.pushname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.pushname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_pushname()) { + _this->_impl_.pushname_.Set(from._internal_pushname(), + _this->GetArenaForAllocation()); + } + _impl_.fbcat_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fbcat_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_fbcat()) { + _this->_impl_.fbcat_.Set(from._internal_fbcat(), + _this->GetArenaForAllocation()); + } + _impl_.fbuseragent_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fbuseragent_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_fbuseragent()) { + _this->_impl_.fbuseragent_.Set(from._internal_fbuseragent(), + _this->GetArenaForAllocation()); + } + _impl_.fbdeviceid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fbdeviceid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_fbdeviceid()) { + _this->_impl_.fbdeviceid_.Set(from._internal_fbdeviceid(), + _this->GetArenaForAllocation()); + } + _impl_.paddingbytes_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.paddingbytes_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_paddingbytes()) { + _this->_impl_.paddingbytes_.Set(from._internal_paddingbytes(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_useragent()) { + _this->_impl_.useragent_ = new ::proto::ClientPayload_UserAgent(*from._impl_.useragent_); + } + if (from._internal_has_webinfo()) { + _this->_impl_.webinfo_ = new ::proto::ClientPayload_WebInfo(*from._impl_.webinfo_); + } + if (from._internal_has_dnssource()) { + _this->_impl_.dnssource_ = new ::proto::ClientPayload_DNSSource(*from._impl_.dnssource_); + } + if (from._internal_has_devicepairingdata()) { + _this->_impl_.devicepairingdata_ = new ::proto::ClientPayload_DevicePairingRegistrationData(*from._impl_.devicepairingdata_); + } + ::memcpy(&_impl_.username_, &from._impl_.username_, + static_cast(reinterpret_cast(&_impl_.iosappextension_) - + reinterpret_cast(&_impl_.username_)) + sizeof(_impl_.iosappextension_)); + // @@protoc_insertion_point(copy_constructor:proto.ClientPayload) +} + +inline void ClientPayload::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.shards_){arena} + , decltype(_impl_.pushname_){} + , decltype(_impl_.fbcat_){} + , decltype(_impl_.fbuseragent_){} + , decltype(_impl_.fbdeviceid_){} + , decltype(_impl_.paddingbytes_){} + , decltype(_impl_.useragent_){nullptr} + , decltype(_impl_.webinfo_){nullptr} + , decltype(_impl_.dnssource_){nullptr} + , decltype(_impl_.devicepairingdata_){nullptr} + , decltype(_impl_.username_){uint64_t{0u}} + , decltype(_impl_.sessionid_){0} + , decltype(_impl_.connecttype_){0} + , decltype(_impl_.connectreason_){0} + , decltype(_impl_.connectattemptcount_){0u} + , decltype(_impl_.passive_){false} + , decltype(_impl_.shortconnect_){false} + , decltype(_impl_.oc_){false} + , decltype(_impl_.pull_){false} + , decltype(_impl_.device_){0u} + , decltype(_impl_.product_){0} + , decltype(_impl_.lc_){0} + , decltype(_impl_.fbappid_){uint64_t{0u}} + , decltype(_impl_.iosappextension_){0} + }; + _impl_.pushname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.pushname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fbcat_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fbcat_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fbuseragent_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fbuseragent_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fbdeviceid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fbdeviceid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.paddingbytes_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.paddingbytes_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +ClientPayload::~ClientPayload() { + // @@protoc_insertion_point(destructor:proto.ClientPayload) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ClientPayload::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.shards_.~RepeatedField(); + _impl_.pushname_.Destroy(); + _impl_.fbcat_.Destroy(); + _impl_.fbuseragent_.Destroy(); + _impl_.fbdeviceid_.Destroy(); + _impl_.paddingbytes_.Destroy(); + if (this != internal_default_instance()) delete _impl_.useragent_; + if (this != internal_default_instance()) delete _impl_.webinfo_; + if (this != internal_default_instance()) delete _impl_.dnssource_; + if (this != internal_default_instance()) delete _impl_.devicepairingdata_; +} + +void ClientPayload::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ClientPayload::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.ClientPayload) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.shards_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _impl_.pushname_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.fbcat_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.fbuseragent_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + _impl_.fbdeviceid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + _impl_.paddingbytes_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000020u) { + GOOGLE_DCHECK(_impl_.useragent_ != nullptr); + _impl_.useragent_->Clear(); + } + if (cached_has_bits & 0x00000040u) { + GOOGLE_DCHECK(_impl_.webinfo_ != nullptr); + _impl_.webinfo_->Clear(); + } + if (cached_has_bits & 0x00000080u) { + GOOGLE_DCHECK(_impl_.dnssource_ != nullptr); + _impl_.dnssource_->Clear(); + } + } + if (cached_has_bits & 0x00000100u) { + GOOGLE_DCHECK(_impl_.devicepairingdata_ != nullptr); + _impl_.devicepairingdata_->Clear(); + } + if (cached_has_bits & 0x0000fe00u) { + ::memset(&_impl_.username_, 0, static_cast( + reinterpret_cast(&_impl_.shortconnect_) - + reinterpret_cast(&_impl_.username_)) + sizeof(_impl_.shortconnect_)); + } + if (cached_has_bits & 0x007f0000u) { + ::memset(&_impl_.oc_, 0, static_cast( + reinterpret_cast(&_impl_.iosappextension_) - + reinterpret_cast(&_impl_.oc_)) + sizeof(_impl_.iosappextension_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ClientPayload::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint64 username = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_username(&has_bits); + _impl_.username_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool passive = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_passive(&has_bits); + _impl_.passive_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.ClientPayload.UserAgent userAgent = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_useragent(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.ClientPayload.WebInfo webInfo = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_webinfo(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string pushName = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + auto str = _internal_mutable_pushname(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ClientPayload.pushName"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional sfixed32 sessionId = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 77)) { + _Internal::set_has_sessionid(&has_bits); + _impl_.sessionid_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(int32_t); + } else + goto handle_unusual; + continue; + // optional bool shortConnect = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { + _Internal::set_has_shortconnect(&has_bits); + _impl_.shortconnect_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.ClientPayload.ConnectType connectType = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::ClientPayload_ConnectType_IsValid(val))) { + _internal_set_connecttype(static_cast<::proto::ClientPayload_ConnectType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(12, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.ClientPayload.ConnectReason connectReason = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 104)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::ClientPayload_ConnectReason_IsValid(val))) { + _internal_set_connectreason(static_cast<::proto::ClientPayload_ConnectReason>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(13, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // repeated int32 shards = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 112)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_shards(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<112>(ptr)); + } else if (static_cast(tag) == 114) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_shards(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.ClientPayload.DNSSource dnsSource = 15; + case 15: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { + ptr = ctx->ParseMessage(_internal_mutable_dnssource(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 connectAttemptCount = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 128)) { + _Internal::set_has_connectattemptcount(&has_bits); + _impl_.connectattemptcount_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 device = 18; + case 18: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 144)) { + _Internal::set_has_device(&has_bits); + _impl_.device_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.ClientPayload.DevicePairingRegistrationData devicePairingData = 19; + case 19: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) { + ptr = ctx->ParseMessage(_internal_mutable_devicepairingdata(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.ClientPayload.Product product = 20; + case 20: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 160)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::ClientPayload_Product_IsValid(val))) { + _internal_set_product(static_cast<::proto::ClientPayload_Product>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(20, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional bytes fbCat = 21; + case 21: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { + auto str = _internal_mutable_fbcat(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes fbUserAgent = 22; + case 22: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 178)) { + auto str = _internal_mutable_fbuseragent(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool oc = 23; + case 23: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 184)) { + _Internal::set_has_oc(&has_bits); + _impl_.oc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 lc = 24; + case 24: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 192)) { + _Internal::set_has_lc(&has_bits); + _impl_.lc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.ClientPayload.IOSAppExtension iosAppExtension = 30; + case 30: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 240)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::ClientPayload_IOSAppExtension_IsValid(val))) { + _internal_set_iosappextension(static_cast<::proto::ClientPayload_IOSAppExtension>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(30, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional uint64 fbAppId = 31; + case 31: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 248)) { + _Internal::set_has_fbappid(&has_bits); + _impl_.fbappid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes fbDeviceId = 32; + case 32: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 2)) { + auto str = _internal_mutable_fbdeviceid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool pull = 33; + case 33: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_pull(&has_bits); + _impl_.pull_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes paddingBytes = 34; + case 34: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_paddingbytes(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ClientPayload::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.ClientPayload) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional uint64 username = 1; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_username(), target); + } + + // optional bool passive = 3; + if (cached_has_bits & 0x00004000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_passive(), target); + } + + // optional .proto.ClientPayload.UserAgent userAgent = 5; + if (cached_has_bits & 0x00000020u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(5, _Internal::useragent(this), + _Internal::useragent(this).GetCachedSize(), target, stream); + } + + // optional .proto.ClientPayload.WebInfo webInfo = 6; + if (cached_has_bits & 0x00000040u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(6, _Internal::webinfo(this), + _Internal::webinfo(this).GetCachedSize(), target, stream); + } + + // optional string pushName = 7; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_pushname().data(), static_cast(this->_internal_pushname().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ClientPayload.pushName"); + target = stream->WriteStringMaybeAliased( + 7, this->_internal_pushname(), target); + } + + // optional sfixed32 sessionId = 9; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSFixed32ToArray(9, this->_internal_sessionid(), target); + } + + // optional bool shortConnect = 10; + if (cached_has_bits & 0x00008000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(10, this->_internal_shortconnect(), target); + } + + // optional .proto.ClientPayload.ConnectType connectType = 12; + if (cached_has_bits & 0x00000800u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 12, this->_internal_connecttype(), target); + } + + // optional .proto.ClientPayload.ConnectReason connectReason = 13; + if (cached_has_bits & 0x00001000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 13, this->_internal_connectreason(), target); + } + + // repeated int32 shards = 14; + for (int i = 0, n = this->_internal_shards_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(14, this->_internal_shards(i), target); + } + + // optional .proto.ClientPayload.DNSSource dnsSource = 15; + if (cached_has_bits & 0x00000080u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(15, _Internal::dnssource(this), + _Internal::dnssource(this).GetCachedSize(), target, stream); + } + + // optional uint32 connectAttemptCount = 16; + if (cached_has_bits & 0x00002000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(16, this->_internal_connectattemptcount(), target); + } + + // optional uint32 device = 18; + if (cached_has_bits & 0x00040000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(18, this->_internal_device(), target); + } + + // optional .proto.ClientPayload.DevicePairingRegistrationData devicePairingData = 19; + if (cached_has_bits & 0x00000100u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(19, _Internal::devicepairingdata(this), + _Internal::devicepairingdata(this).GetCachedSize(), target, stream); + } + + // optional .proto.ClientPayload.Product product = 20; + if (cached_has_bits & 0x00080000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 20, this->_internal_product(), target); + } + + // optional bytes fbCat = 21; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 21, this->_internal_fbcat(), target); + } + + // optional bytes fbUserAgent = 22; + if (cached_has_bits & 0x00000004u) { + target = stream->WriteBytesMaybeAliased( + 22, this->_internal_fbuseragent(), target); + } + + // optional bool oc = 23; + if (cached_has_bits & 0x00010000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(23, this->_internal_oc(), target); + } + + // optional int32 lc = 24; + if (cached_has_bits & 0x00100000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(24, this->_internal_lc(), target); + } + + // optional .proto.ClientPayload.IOSAppExtension iosAppExtension = 30; + if (cached_has_bits & 0x00400000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 30, this->_internal_iosappextension(), target); + } + + // optional uint64 fbAppId = 31; + if (cached_has_bits & 0x00200000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(31, this->_internal_fbappid(), target); + } + + // optional bytes fbDeviceId = 32; + if (cached_has_bits & 0x00000008u) { + target = stream->WriteBytesMaybeAliased( + 32, this->_internal_fbdeviceid(), target); + } + + // optional bool pull = 33; + if (cached_has_bits & 0x00020000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(33, this->_internal_pull(), target); + } + + // optional bytes paddingBytes = 34; + if (cached_has_bits & 0x00000010u) { + target = stream->WriteBytesMaybeAliased( + 34, this->_internal_paddingbytes(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.ClientPayload) + return target; +} + +size_t ClientPayload::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.ClientPayload) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated int32 shards = 14; + { + size_t data_size = ::_pbi::WireFormatLite:: + Int32Size(this->_impl_.shards_); + total_size += 1 * + ::_pbi::FromIntSize(this->_internal_shards_size()); + total_size += data_size; + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string pushName = 7; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_pushname()); + } + + // optional bytes fbCat = 21; + if (cached_has_bits & 0x00000002u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_fbcat()); + } + + // optional bytes fbUserAgent = 22; + if (cached_has_bits & 0x00000004u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_fbuseragent()); + } + + // optional bytes fbDeviceId = 32; + if (cached_has_bits & 0x00000008u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_fbdeviceid()); + } + + // optional bytes paddingBytes = 34; + if (cached_has_bits & 0x00000010u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_paddingbytes()); + } + + // optional .proto.ClientPayload.UserAgent userAgent = 5; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.useragent_); + } + + // optional .proto.ClientPayload.WebInfo webInfo = 6; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.webinfo_); + } + + // optional .proto.ClientPayload.DNSSource dnsSource = 15; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.dnssource_); + } + + } + if (cached_has_bits & 0x0000ff00u) { + // optional .proto.ClientPayload.DevicePairingRegistrationData devicePairingData = 19; + if (cached_has_bits & 0x00000100u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.devicepairingdata_); + } + + // optional uint64 username = 1; + if (cached_has_bits & 0x00000200u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_username()); + } + + // optional sfixed32 sessionId = 9; + if (cached_has_bits & 0x00000400u) { + total_size += 1 + 4; + } + + // optional .proto.ClientPayload.ConnectType connectType = 12; + if (cached_has_bits & 0x00000800u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_connecttype()); + } + + // optional .proto.ClientPayload.ConnectReason connectReason = 13; + if (cached_has_bits & 0x00001000u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_connectreason()); + } + + // optional uint32 connectAttemptCount = 16; + if (cached_has_bits & 0x00002000u) { + total_size += 2 + + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_connectattemptcount()); + } + + // optional bool passive = 3; + if (cached_has_bits & 0x00004000u) { + total_size += 1 + 1; + } + + // optional bool shortConnect = 10; + if (cached_has_bits & 0x00008000u) { + total_size += 1 + 1; + } + + } + if (cached_has_bits & 0x007f0000u) { + // optional bool oc = 23; + if (cached_has_bits & 0x00010000u) { + total_size += 2 + 1; + } + + // optional bool pull = 33; + if (cached_has_bits & 0x00020000u) { + total_size += 2 + 1; + } + + // optional uint32 device = 18; + if (cached_has_bits & 0x00040000u) { + total_size += 2 + + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_device()); + } + + // optional .proto.ClientPayload.Product product = 20; + if (cached_has_bits & 0x00080000u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_product()); + } + + // optional int32 lc = 24; + if (cached_has_bits & 0x00100000u) { + total_size += 2 + + ::_pbi::WireFormatLite::Int32Size( + this->_internal_lc()); + } + + // optional uint64 fbAppId = 31; + if (cached_has_bits & 0x00200000u) { + total_size += 2 + + ::_pbi::WireFormatLite::UInt64Size( + this->_internal_fbappid()); + } + + // optional .proto.ClientPayload.IOSAppExtension iosAppExtension = 30; + if (cached_has_bits & 0x00400000u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_iosappextension()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ClientPayload::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + ClientPayload::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ClientPayload::GetClassData() const { return &_class_data_; } + + +void ClientPayload::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.ClientPayload) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.shards_.MergeFrom(from._impl_.shards_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_pushname(from._internal_pushname()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_fbcat(from._internal_fbcat()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_fbuseragent(from._internal_fbuseragent()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_set_fbdeviceid(from._internal_fbdeviceid()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_set_paddingbytes(from._internal_paddingbytes()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_mutable_useragent()->::proto::ClientPayload_UserAgent::MergeFrom( + from._internal_useragent()); + } + if (cached_has_bits & 0x00000040u) { + _this->_internal_mutable_webinfo()->::proto::ClientPayload_WebInfo::MergeFrom( + from._internal_webinfo()); + } + if (cached_has_bits & 0x00000080u) { + _this->_internal_mutable_dnssource()->::proto::ClientPayload_DNSSource::MergeFrom( + from._internal_dnssource()); + } + } + if (cached_has_bits & 0x0000ff00u) { + if (cached_has_bits & 0x00000100u) { + _this->_internal_mutable_devicepairingdata()->::proto::ClientPayload_DevicePairingRegistrationData::MergeFrom( + from._internal_devicepairingdata()); + } + if (cached_has_bits & 0x00000200u) { + _this->_impl_.username_ = from._impl_.username_; + } + if (cached_has_bits & 0x00000400u) { + _this->_impl_.sessionid_ = from._impl_.sessionid_; + } + if (cached_has_bits & 0x00000800u) { + _this->_impl_.connecttype_ = from._impl_.connecttype_; + } + if (cached_has_bits & 0x00001000u) { + _this->_impl_.connectreason_ = from._impl_.connectreason_; + } + if (cached_has_bits & 0x00002000u) { + _this->_impl_.connectattemptcount_ = from._impl_.connectattemptcount_; + } + if (cached_has_bits & 0x00004000u) { + _this->_impl_.passive_ = from._impl_.passive_; + } + if (cached_has_bits & 0x00008000u) { + _this->_impl_.shortconnect_ = from._impl_.shortconnect_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x007f0000u) { + if (cached_has_bits & 0x00010000u) { + _this->_impl_.oc_ = from._impl_.oc_; + } + if (cached_has_bits & 0x00020000u) { + _this->_impl_.pull_ = from._impl_.pull_; + } + if (cached_has_bits & 0x00040000u) { + _this->_impl_.device_ = from._impl_.device_; + } + if (cached_has_bits & 0x00080000u) { + _this->_impl_.product_ = from._impl_.product_; + } + if (cached_has_bits & 0x00100000u) { + _this->_impl_.lc_ = from._impl_.lc_; + } + if (cached_has_bits & 0x00200000u) { + _this->_impl_.fbappid_ = from._impl_.fbappid_; + } + if (cached_has_bits & 0x00400000u) { + _this->_impl_.iosappextension_ = from._impl_.iosappextension_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ClientPayload::CopyFrom(const ClientPayload& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.ClientPayload) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ClientPayload::IsInitialized() const { + return true; +} + +void ClientPayload::InternalSwap(ClientPayload* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.shards_.InternalSwap(&other->_impl_.shards_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.pushname_, lhs_arena, + &other->_impl_.pushname_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.fbcat_, lhs_arena, + &other->_impl_.fbcat_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.fbuseragent_, lhs_arena, + &other->_impl_.fbuseragent_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.fbdeviceid_, lhs_arena, + &other->_impl_.fbdeviceid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.paddingbytes_, lhs_arena, + &other->_impl_.paddingbytes_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ClientPayload, _impl_.iosappextension_) + + sizeof(ClientPayload::_impl_.iosappextension_) + - PROTOBUF_FIELD_OFFSET(ClientPayload, _impl_.useragent_)>( + reinterpret_cast(&_impl_.useragent_), + reinterpret_cast(&other->_impl_.useragent_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ClientPayload::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[21]); +} + +// =================================================================== + +class ContextInfo_AdReplyInfo::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_advertisername(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_mediatype(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_jpegthumbnail(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_caption(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +ContextInfo_AdReplyInfo::ContextInfo_AdReplyInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.ContextInfo.AdReplyInfo) +} +ContextInfo_AdReplyInfo::ContextInfo_AdReplyInfo(const ContextInfo_AdReplyInfo& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + ContextInfo_AdReplyInfo* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.advertisername_){} + , decltype(_impl_.jpegthumbnail_){} + , decltype(_impl_.caption_){} + , decltype(_impl_.mediatype_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.advertisername_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.advertisername_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_advertisername()) { + _this->_impl_.advertisername_.Set(from._internal_advertisername(), + _this->GetArenaForAllocation()); + } + _impl_.jpegthumbnail_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_jpegthumbnail()) { + _this->_impl_.jpegthumbnail_.Set(from._internal_jpegthumbnail(), + _this->GetArenaForAllocation()); + } + _impl_.caption_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.caption_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_caption()) { + _this->_impl_.caption_.Set(from._internal_caption(), + _this->GetArenaForAllocation()); + } + _this->_impl_.mediatype_ = from._impl_.mediatype_; + // @@protoc_insertion_point(copy_constructor:proto.ContextInfo.AdReplyInfo) +} + +inline void ContextInfo_AdReplyInfo::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.advertisername_){} + , decltype(_impl_.jpegthumbnail_){} + , decltype(_impl_.caption_){} + , decltype(_impl_.mediatype_){0} + }; + _impl_.advertisername_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.advertisername_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.jpegthumbnail_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.caption_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.caption_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +ContextInfo_AdReplyInfo::~ContextInfo_AdReplyInfo() { + // @@protoc_insertion_point(destructor:proto.ContextInfo.AdReplyInfo) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ContextInfo_AdReplyInfo::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.advertisername_.Destroy(); + _impl_.jpegthumbnail_.Destroy(); + _impl_.caption_.Destroy(); +} + +void ContextInfo_AdReplyInfo::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ContextInfo_AdReplyInfo::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.ContextInfo.AdReplyInfo) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _impl_.advertisername_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.jpegthumbnail_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.caption_.ClearNonDefaultToEmpty(); + } + } + _impl_.mediatype_ = 0; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ContextInfo_AdReplyInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string advertiserName = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_advertisername(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ContextInfo.AdReplyInfo.advertiserName"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.ContextInfo.AdReplyInfo.MediaType mediaType = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::ContextInfo_AdReplyInfo_MediaType_IsValid(val))) { + _internal_set_mediatype(static_cast<::proto::ContextInfo_AdReplyInfo_MediaType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional bytes jpegThumbnail = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { + auto str = _internal_mutable_jpegthumbnail(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string caption = 17; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { + auto str = _internal_mutable_caption(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ContextInfo.AdReplyInfo.caption"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ContextInfo_AdReplyInfo::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.ContextInfo.AdReplyInfo) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string advertiserName = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_advertisername().data(), static_cast(this->_internal_advertisername().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ContextInfo.AdReplyInfo.advertiserName"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_advertisername(), target); + } + + // optional .proto.ContextInfo.AdReplyInfo.MediaType mediaType = 2; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this->_internal_mediatype(), target); + } + + // optional bytes jpegThumbnail = 16; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 16, this->_internal_jpegthumbnail(), target); + } + + // optional string caption = 17; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_caption().data(), static_cast(this->_internal_caption().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ContextInfo.AdReplyInfo.caption"); + target = stream->WriteStringMaybeAliased( + 17, this->_internal_caption(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.ContextInfo.AdReplyInfo) + return target; +} + +size_t ContextInfo_AdReplyInfo::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.ContextInfo.AdReplyInfo) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional string advertiserName = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_advertisername()); + } + + // optional bytes jpegThumbnail = 16; + if (cached_has_bits & 0x00000002u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_jpegthumbnail()); + } + + // optional string caption = 17; + if (cached_has_bits & 0x00000004u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_caption()); + } + + // optional .proto.ContextInfo.AdReplyInfo.MediaType mediaType = 2; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_mediatype()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ContextInfo_AdReplyInfo::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + ContextInfo_AdReplyInfo::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ContextInfo_AdReplyInfo::GetClassData() const { return &_class_data_; } + + +void ContextInfo_AdReplyInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.ContextInfo.AdReplyInfo) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_advertisername(from._internal_advertisername()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_caption(from._internal_caption()); + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.mediatype_ = from._impl_.mediatype_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ContextInfo_AdReplyInfo::CopyFrom(const ContextInfo_AdReplyInfo& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.ContextInfo.AdReplyInfo) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ContextInfo_AdReplyInfo::IsInitialized() const { + return true; +} + +void ContextInfo_AdReplyInfo::InternalSwap(ContextInfo_AdReplyInfo* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.advertisername_, lhs_arena, + &other->_impl_.advertisername_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.jpegthumbnail_, lhs_arena, + &other->_impl_.jpegthumbnail_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.caption_, lhs_arena, + &other->_impl_.caption_, rhs_arena + ); + swap(_impl_.mediatype_, other->_impl_.mediatype_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ContextInfo_AdReplyInfo::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[22]); +} + +// =================================================================== + +class ContextInfo_ExternalAdReplyInfo::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_title(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_body(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_mediatype(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_thumbnailurl(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_mediaurl(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_thumbnail(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_sourcetype(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_sourceid(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_sourceurl(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_containsautoreply(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_renderlargerthumbnail(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static void set_has_showadattribution(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } +}; + +ContextInfo_ExternalAdReplyInfo::ContextInfo_ExternalAdReplyInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.ContextInfo.ExternalAdReplyInfo) +} +ContextInfo_ExternalAdReplyInfo::ContextInfo_ExternalAdReplyInfo(const ContextInfo_ExternalAdReplyInfo& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + ContextInfo_ExternalAdReplyInfo* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.title_){} + , decltype(_impl_.body_){} + , decltype(_impl_.thumbnailurl_){} + , decltype(_impl_.mediaurl_){} + , decltype(_impl_.thumbnail_){} + , decltype(_impl_.sourcetype_){} + , decltype(_impl_.sourceid_){} + , decltype(_impl_.sourceurl_){} + , decltype(_impl_.mediatype_){} + , decltype(_impl_.containsautoreply_){} + , decltype(_impl_.renderlargerthumbnail_){} + , decltype(_impl_.showadattribution_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.title_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.title_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_title()) { + _this->_impl_.title_.Set(from._internal_title(), + _this->GetArenaForAllocation()); + } + _impl_.body_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.body_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_body()) { + _this->_impl_.body_.Set(from._internal_body(), + _this->GetArenaForAllocation()); + } + _impl_.thumbnailurl_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnailurl_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_thumbnailurl()) { + _this->_impl_.thumbnailurl_.Set(from._internal_thumbnailurl(), + _this->GetArenaForAllocation()); + } + _impl_.mediaurl_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediaurl_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_mediaurl()) { + _this->_impl_.mediaurl_.Set(from._internal_mediaurl(), + _this->GetArenaForAllocation()); + } + _impl_.thumbnail_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnail_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_thumbnail()) { + _this->_impl_.thumbnail_.Set(from._internal_thumbnail(), + _this->GetArenaForAllocation()); + } + _impl_.sourcetype_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.sourcetype_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_sourcetype()) { + _this->_impl_.sourcetype_.Set(from._internal_sourcetype(), + _this->GetArenaForAllocation()); + } + _impl_.sourceid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.sourceid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_sourceid()) { + _this->_impl_.sourceid_.Set(from._internal_sourceid(), + _this->GetArenaForAllocation()); + } + _impl_.sourceurl_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.sourceurl_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_sourceurl()) { + _this->_impl_.sourceurl_.Set(from._internal_sourceurl(), + _this->GetArenaForAllocation()); + } + ::memcpy(&_impl_.mediatype_, &from._impl_.mediatype_, + static_cast(reinterpret_cast(&_impl_.showadattribution_) - + reinterpret_cast(&_impl_.mediatype_)) + sizeof(_impl_.showadattribution_)); + // @@protoc_insertion_point(copy_constructor:proto.ContextInfo.ExternalAdReplyInfo) +} + +inline void ContextInfo_ExternalAdReplyInfo::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.title_){} + , decltype(_impl_.body_){} + , decltype(_impl_.thumbnailurl_){} + , decltype(_impl_.mediaurl_){} + , decltype(_impl_.thumbnail_){} + , decltype(_impl_.sourcetype_){} + , decltype(_impl_.sourceid_){} + , decltype(_impl_.sourceurl_){} + , decltype(_impl_.mediatype_){0} + , decltype(_impl_.containsautoreply_){false} + , decltype(_impl_.renderlargerthumbnail_){false} + , decltype(_impl_.showadattribution_){false} + }; + _impl_.title_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.title_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.body_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.body_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnailurl_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnailurl_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediaurl_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediaurl_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnail_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnail_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.sourcetype_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.sourcetype_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.sourceid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.sourceid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.sourceurl_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.sourceurl_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +ContextInfo_ExternalAdReplyInfo::~ContextInfo_ExternalAdReplyInfo() { + // @@protoc_insertion_point(destructor:proto.ContextInfo.ExternalAdReplyInfo) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ContextInfo_ExternalAdReplyInfo::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.title_.Destroy(); + _impl_.body_.Destroy(); + _impl_.thumbnailurl_.Destroy(); + _impl_.mediaurl_.Destroy(); + _impl_.thumbnail_.Destroy(); + _impl_.sourcetype_.Destroy(); + _impl_.sourceid_.Destroy(); + _impl_.sourceurl_.Destroy(); +} + +void ContextInfo_ExternalAdReplyInfo::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ContextInfo_ExternalAdReplyInfo::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.ContextInfo.ExternalAdReplyInfo) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _impl_.title_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.body_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.thumbnailurl_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + _impl_.mediaurl_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + _impl_.thumbnail_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000020u) { + _impl_.sourcetype_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000040u) { + _impl_.sourceid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000080u) { + _impl_.sourceurl_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x00000f00u) { + ::memset(&_impl_.mediatype_, 0, static_cast( + reinterpret_cast(&_impl_.showadattribution_) - + reinterpret_cast(&_impl_.mediatype_)) + sizeof(_impl_.showadattribution_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ContextInfo_ExternalAdReplyInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string title = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_title(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ContextInfo.ExternalAdReplyInfo.title"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string body = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_body(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ContextInfo.ExternalAdReplyInfo.body"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.ContextInfo.ExternalAdReplyInfo.MediaType mediaType = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::ContextInfo_ExternalAdReplyInfo_MediaType_IsValid(val))) { + _internal_set_mediatype(static_cast<::proto::ContextInfo_ExternalAdReplyInfo_MediaType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional string thumbnailUrl = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_thumbnailurl(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ContextInfo.ExternalAdReplyInfo.thumbnailUrl"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string mediaUrl = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + auto str = _internal_mutable_mediaurl(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ContextInfo.ExternalAdReplyInfo.mediaUrl"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bytes thumbnail = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + auto str = _internal_mutable_thumbnail(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string sourceType = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + auto str = _internal_mutable_sourcetype(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ContextInfo.ExternalAdReplyInfo.sourceType"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string sourceId = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + auto str = _internal_mutable_sourceid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ContextInfo.ExternalAdReplyInfo.sourceId"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string sourceUrl = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + auto str = _internal_mutable_sourceurl(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ContextInfo.ExternalAdReplyInfo.sourceUrl"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bool containsAutoReply = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { + _Internal::set_has_containsautoreply(&has_bits); + _impl_.containsautoreply_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool renderLargerThumbnail = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { + _Internal::set_has_renderlargerthumbnail(&has_bits); + _impl_.renderlargerthumbnail_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool showAdAttribution = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { + _Internal::set_has_showadattribution(&has_bits); + _impl_.showadattribution_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ContextInfo_ExternalAdReplyInfo::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.ContextInfo.ExternalAdReplyInfo) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string title = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_title().data(), static_cast(this->_internal_title().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ContextInfo.ExternalAdReplyInfo.title"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_title(), target); + } + + // optional string body = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_body().data(), static_cast(this->_internal_body().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ContextInfo.ExternalAdReplyInfo.body"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_body(), target); + } + + // optional .proto.ContextInfo.ExternalAdReplyInfo.MediaType mediaType = 3; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 3, this->_internal_mediatype(), target); + } + + // optional string thumbnailUrl = 4; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_thumbnailurl().data(), static_cast(this->_internal_thumbnailurl().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ContextInfo.ExternalAdReplyInfo.thumbnailUrl"); + target = stream->WriteStringMaybeAliased( + 4, this->_internal_thumbnailurl(), target); + } + + // optional string mediaUrl = 5; + if (cached_has_bits & 0x00000008u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_mediaurl().data(), static_cast(this->_internal_mediaurl().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ContextInfo.ExternalAdReplyInfo.mediaUrl"); + target = stream->WriteStringMaybeAliased( + 5, this->_internal_mediaurl(), target); + } + + // optional bytes thumbnail = 6; + if (cached_has_bits & 0x00000010u) { + target = stream->WriteBytesMaybeAliased( + 6, this->_internal_thumbnail(), target); + } + + // optional string sourceType = 7; + if (cached_has_bits & 0x00000020u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_sourcetype().data(), static_cast(this->_internal_sourcetype().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ContextInfo.ExternalAdReplyInfo.sourceType"); + target = stream->WriteStringMaybeAliased( + 7, this->_internal_sourcetype(), target); + } + + // optional string sourceId = 8; + if (cached_has_bits & 0x00000040u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_sourceid().data(), static_cast(this->_internal_sourceid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ContextInfo.ExternalAdReplyInfo.sourceId"); + target = stream->WriteStringMaybeAliased( + 8, this->_internal_sourceid(), target); + } + + // optional string sourceUrl = 9; + if (cached_has_bits & 0x00000080u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_sourceurl().data(), static_cast(this->_internal_sourceurl().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ContextInfo.ExternalAdReplyInfo.sourceUrl"); + target = stream->WriteStringMaybeAliased( + 9, this->_internal_sourceurl(), target); + } + + // optional bool containsAutoReply = 10; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(10, this->_internal_containsautoreply(), target); + } + + // optional bool renderLargerThumbnail = 11; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(11, this->_internal_renderlargerthumbnail(), target); + } + + // optional bool showAdAttribution = 12; + if (cached_has_bits & 0x00000800u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(12, this->_internal_showadattribution(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.ContextInfo.ExternalAdReplyInfo) + return target; +} + +size_t ContextInfo_ExternalAdReplyInfo::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.ContextInfo.ExternalAdReplyInfo) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string title = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_title()); + } + + // optional string body = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_body()); + } + + // optional string thumbnailUrl = 4; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_thumbnailurl()); + } + + // optional string mediaUrl = 5; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_mediaurl()); + } + + // optional bytes thumbnail = 6; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_thumbnail()); + } + + // optional string sourceType = 7; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_sourcetype()); + } + + // optional string sourceId = 8; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_sourceid()); + } + + // optional string sourceUrl = 9; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_sourceurl()); + } + + } + if (cached_has_bits & 0x00000f00u) { + // optional .proto.ContextInfo.ExternalAdReplyInfo.MediaType mediaType = 3; + if (cached_has_bits & 0x00000100u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_mediatype()); + } + + // optional bool containsAutoReply = 10; + if (cached_has_bits & 0x00000200u) { + total_size += 1 + 1; + } + + // optional bool renderLargerThumbnail = 11; + if (cached_has_bits & 0x00000400u) { + total_size += 1 + 1; + } + + // optional bool showAdAttribution = 12; + if (cached_has_bits & 0x00000800u) { + total_size += 1 + 1; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ContextInfo_ExternalAdReplyInfo::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + ContextInfo_ExternalAdReplyInfo::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ContextInfo_ExternalAdReplyInfo::GetClassData() const { return &_class_data_; } + + +void ContextInfo_ExternalAdReplyInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.ContextInfo.ExternalAdReplyInfo) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_title(from._internal_title()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_body(from._internal_body()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_thumbnailurl(from._internal_thumbnailurl()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_set_mediaurl(from._internal_mediaurl()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_set_thumbnail(from._internal_thumbnail()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_set_sourcetype(from._internal_sourcetype()); + } + if (cached_has_bits & 0x00000040u) { + _this->_internal_set_sourceid(from._internal_sourceid()); + } + if (cached_has_bits & 0x00000080u) { + _this->_internal_set_sourceurl(from._internal_sourceurl()); + } + } + if (cached_has_bits & 0x00000f00u) { + if (cached_has_bits & 0x00000100u) { + _this->_impl_.mediatype_ = from._impl_.mediatype_; + } + if (cached_has_bits & 0x00000200u) { + _this->_impl_.containsautoreply_ = from._impl_.containsautoreply_; + } + if (cached_has_bits & 0x00000400u) { + _this->_impl_.renderlargerthumbnail_ = from._impl_.renderlargerthumbnail_; + } + if (cached_has_bits & 0x00000800u) { + _this->_impl_.showadattribution_ = from._impl_.showadattribution_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ContextInfo_ExternalAdReplyInfo::CopyFrom(const ContextInfo_ExternalAdReplyInfo& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.ContextInfo.ExternalAdReplyInfo) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ContextInfo_ExternalAdReplyInfo::IsInitialized() const { + return true; +} + +void ContextInfo_ExternalAdReplyInfo::InternalSwap(ContextInfo_ExternalAdReplyInfo* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.title_, lhs_arena, + &other->_impl_.title_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.body_, lhs_arena, + &other->_impl_.body_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.thumbnailurl_, lhs_arena, + &other->_impl_.thumbnailurl_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.mediaurl_, lhs_arena, + &other->_impl_.mediaurl_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.thumbnail_, lhs_arena, + &other->_impl_.thumbnail_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.sourcetype_, lhs_arena, + &other->_impl_.sourcetype_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.sourceid_, lhs_arena, + &other->_impl_.sourceid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.sourceurl_, lhs_arena, + &other->_impl_.sourceurl_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ContextInfo_ExternalAdReplyInfo, _impl_.showadattribution_) + + sizeof(ContextInfo_ExternalAdReplyInfo::_impl_.showadattribution_) + - PROTOBUF_FIELD_OFFSET(ContextInfo_ExternalAdReplyInfo, _impl_.mediatype_)>( + reinterpret_cast(&_impl_.mediatype_), + reinterpret_cast(&other->_impl_.mediatype_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ContextInfo_ExternalAdReplyInfo::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[23]); +} + +// =================================================================== + +class ContextInfo::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_stanzaid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_participant(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::proto::Message& quotedmessage(const ContextInfo* msg); + static void set_has_quotedmessage(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static void set_has_remotejid(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_conversionsource(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_conversiondata(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_conversiondelayseconds(HasBits* has_bits) { + (*has_bits)[0] |= 65536u; + } + static void set_has_forwardingscore(HasBits* has_bits) { + (*has_bits)[0] |= 131072u; + } + static void set_has_isforwarded(HasBits* has_bits) { + (*has_bits)[0] |= 262144u; + } + static const ::proto::ContextInfo_AdReplyInfo& quotedad(const ContextInfo* msg); + static void set_has_quotedad(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static const ::proto::MessageKey& placeholderkey(const ContextInfo* msg); + static void set_has_placeholderkey(HasBits* has_bits) { + (*has_bits)[0] |= 4096u; + } + static void set_has_expiration(HasBits* has_bits) { + (*has_bits)[0] |= 524288u; + } + static void set_has_ephemeralsettingtimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 1048576u; + } + static void set_has_ephemeralsharedsecret(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static const ::proto::ContextInfo_ExternalAdReplyInfo& externaladreply(const ContextInfo* msg); + static void set_has_externaladreply(HasBits* has_bits) { + (*has_bits)[0] |= 8192u; + } + static void set_has_entrypointconversionsource(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_entrypointconversionapp(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_entrypointconversiondelayseconds(HasBits* has_bits) { + (*has_bits)[0] |= 2097152u; + } + static const ::proto::DisappearingMode& disappearingmode(const ContextInfo* msg); + static void set_has_disappearingmode(HasBits* has_bits) { + (*has_bits)[0] |= 16384u; + } + static const ::proto::ActionLink& actionlink(const ContextInfo* msg); + static void set_has_actionlink(HasBits* has_bits) { + (*has_bits)[0] |= 32768u; + } + static void set_has_groupsubject(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_parentgroupjid(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } +}; + +const ::proto::Message& +ContextInfo::_Internal::quotedmessage(const ContextInfo* msg) { + return *msg->_impl_.quotedmessage_; +} +const ::proto::ContextInfo_AdReplyInfo& +ContextInfo::_Internal::quotedad(const ContextInfo* msg) { + return *msg->_impl_.quotedad_; +} +const ::proto::MessageKey& +ContextInfo::_Internal::placeholderkey(const ContextInfo* msg) { + return *msg->_impl_.placeholderkey_; +} +const ::proto::ContextInfo_ExternalAdReplyInfo& +ContextInfo::_Internal::externaladreply(const ContextInfo* msg) { + return *msg->_impl_.externaladreply_; +} +const ::proto::DisappearingMode& +ContextInfo::_Internal::disappearingmode(const ContextInfo* msg) { + return *msg->_impl_.disappearingmode_; +} +const ::proto::ActionLink& +ContextInfo::_Internal::actionlink(const ContextInfo* msg) { + return *msg->_impl_.actionlink_; +} +ContextInfo::ContextInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.ContextInfo) +} +ContextInfo::ContextInfo(const ContextInfo& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + ContextInfo* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.mentionedjid_){from._impl_.mentionedjid_} + , decltype(_impl_.stanzaid_){} + , decltype(_impl_.participant_){} + , decltype(_impl_.remotejid_){} + , decltype(_impl_.conversionsource_){} + , decltype(_impl_.conversiondata_){} + , decltype(_impl_.ephemeralsharedsecret_){} + , decltype(_impl_.entrypointconversionsource_){} + , decltype(_impl_.entrypointconversionapp_){} + , decltype(_impl_.groupsubject_){} + , decltype(_impl_.parentgroupjid_){} + , decltype(_impl_.quotedmessage_){nullptr} + , decltype(_impl_.quotedad_){nullptr} + , decltype(_impl_.placeholderkey_){nullptr} + , decltype(_impl_.externaladreply_){nullptr} + , decltype(_impl_.disappearingmode_){nullptr} + , decltype(_impl_.actionlink_){nullptr} + , decltype(_impl_.conversiondelayseconds_){} + , decltype(_impl_.forwardingscore_){} + , decltype(_impl_.isforwarded_){} + , decltype(_impl_.expiration_){} + , decltype(_impl_.ephemeralsettingtimestamp_){} + , decltype(_impl_.entrypointconversiondelayseconds_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.stanzaid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.stanzaid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_stanzaid()) { + _this->_impl_.stanzaid_.Set(from._internal_stanzaid(), + _this->GetArenaForAllocation()); + } + _impl_.participant_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.participant_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_participant()) { + _this->_impl_.participant_.Set(from._internal_participant(), + _this->GetArenaForAllocation()); + } + _impl_.remotejid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.remotejid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_remotejid()) { + _this->_impl_.remotejid_.Set(from._internal_remotejid(), + _this->GetArenaForAllocation()); + } + _impl_.conversionsource_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.conversionsource_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_conversionsource()) { + _this->_impl_.conversionsource_.Set(from._internal_conversionsource(), + _this->GetArenaForAllocation()); + } + _impl_.conversiondata_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.conversiondata_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_conversiondata()) { + _this->_impl_.conversiondata_.Set(from._internal_conversiondata(), + _this->GetArenaForAllocation()); + } + _impl_.ephemeralsharedsecret_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.ephemeralsharedsecret_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_ephemeralsharedsecret()) { + _this->_impl_.ephemeralsharedsecret_.Set(from._internal_ephemeralsharedsecret(), + _this->GetArenaForAllocation()); + } + _impl_.entrypointconversionsource_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.entrypointconversionsource_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_entrypointconversionsource()) { + _this->_impl_.entrypointconversionsource_.Set(from._internal_entrypointconversionsource(), + _this->GetArenaForAllocation()); + } + _impl_.entrypointconversionapp_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.entrypointconversionapp_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_entrypointconversionapp()) { + _this->_impl_.entrypointconversionapp_.Set(from._internal_entrypointconversionapp(), + _this->GetArenaForAllocation()); + } + _impl_.groupsubject_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.groupsubject_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_groupsubject()) { + _this->_impl_.groupsubject_.Set(from._internal_groupsubject(), + _this->GetArenaForAllocation()); + } + _impl_.parentgroupjid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.parentgroupjid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_parentgroupjid()) { + _this->_impl_.parentgroupjid_.Set(from._internal_parentgroupjid(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_quotedmessage()) { + _this->_impl_.quotedmessage_ = new ::proto::Message(*from._impl_.quotedmessage_); + } + if (from._internal_has_quotedad()) { + _this->_impl_.quotedad_ = new ::proto::ContextInfo_AdReplyInfo(*from._impl_.quotedad_); + } + if (from._internal_has_placeholderkey()) { + _this->_impl_.placeholderkey_ = new ::proto::MessageKey(*from._impl_.placeholderkey_); + } + if (from._internal_has_externaladreply()) { + _this->_impl_.externaladreply_ = new ::proto::ContextInfo_ExternalAdReplyInfo(*from._impl_.externaladreply_); + } + if (from._internal_has_disappearingmode()) { + _this->_impl_.disappearingmode_ = new ::proto::DisappearingMode(*from._impl_.disappearingmode_); + } + if (from._internal_has_actionlink()) { + _this->_impl_.actionlink_ = new ::proto::ActionLink(*from._impl_.actionlink_); + } + ::memcpy(&_impl_.conversiondelayseconds_, &from._impl_.conversiondelayseconds_, + static_cast(reinterpret_cast(&_impl_.entrypointconversiondelayseconds_) - + reinterpret_cast(&_impl_.conversiondelayseconds_)) + sizeof(_impl_.entrypointconversiondelayseconds_)); + // @@protoc_insertion_point(copy_constructor:proto.ContextInfo) +} + +inline void ContextInfo::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.mentionedjid_){arena} + , decltype(_impl_.stanzaid_){} + , decltype(_impl_.participant_){} + , decltype(_impl_.remotejid_){} + , decltype(_impl_.conversionsource_){} + , decltype(_impl_.conversiondata_){} + , decltype(_impl_.ephemeralsharedsecret_){} + , decltype(_impl_.entrypointconversionsource_){} + , decltype(_impl_.entrypointconversionapp_){} + , decltype(_impl_.groupsubject_){} + , decltype(_impl_.parentgroupjid_){} + , decltype(_impl_.quotedmessage_){nullptr} + , decltype(_impl_.quotedad_){nullptr} + , decltype(_impl_.placeholderkey_){nullptr} + , decltype(_impl_.externaladreply_){nullptr} + , decltype(_impl_.disappearingmode_){nullptr} + , decltype(_impl_.actionlink_){nullptr} + , decltype(_impl_.conversiondelayseconds_){0u} + , decltype(_impl_.forwardingscore_){0u} + , decltype(_impl_.isforwarded_){false} + , decltype(_impl_.expiration_){0u} + , decltype(_impl_.ephemeralsettingtimestamp_){int64_t{0}} + , decltype(_impl_.entrypointconversiondelayseconds_){0u} + }; + _impl_.stanzaid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.stanzaid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.participant_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.participant_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.remotejid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.remotejid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.conversionsource_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.conversionsource_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.conversiondata_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.conversiondata_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.ephemeralsharedsecret_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.ephemeralsharedsecret_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.entrypointconversionsource_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.entrypointconversionsource_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.entrypointconversionapp_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.entrypointconversionapp_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.groupsubject_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.groupsubject_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.parentgroupjid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.parentgroupjid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +ContextInfo::~ContextInfo() { + // @@protoc_insertion_point(destructor:proto.ContextInfo) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ContextInfo::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.mentionedjid_.~RepeatedPtrField(); + _impl_.stanzaid_.Destroy(); + _impl_.participant_.Destroy(); + _impl_.remotejid_.Destroy(); + _impl_.conversionsource_.Destroy(); + _impl_.conversiondata_.Destroy(); + _impl_.ephemeralsharedsecret_.Destroy(); + _impl_.entrypointconversionsource_.Destroy(); + _impl_.entrypointconversionapp_.Destroy(); + _impl_.groupsubject_.Destroy(); + _impl_.parentgroupjid_.Destroy(); + if (this != internal_default_instance()) delete _impl_.quotedmessage_; + if (this != internal_default_instance()) delete _impl_.quotedad_; + if (this != internal_default_instance()) delete _impl_.placeholderkey_; + if (this != internal_default_instance()) delete _impl_.externaladreply_; + if (this != internal_default_instance()) delete _impl_.disappearingmode_; + if (this != internal_default_instance()) delete _impl_.actionlink_; +} + +void ContextInfo::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ContextInfo::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.ContextInfo) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.mentionedjid_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _impl_.stanzaid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.participant_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.remotejid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + _impl_.conversionsource_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + _impl_.conversiondata_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000020u) { + _impl_.ephemeralsharedsecret_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000040u) { + _impl_.entrypointconversionsource_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000080u) { + _impl_.entrypointconversionapp_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x0000ff00u) { + if (cached_has_bits & 0x00000100u) { + _impl_.groupsubject_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000200u) { + _impl_.parentgroupjid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000400u) { + GOOGLE_DCHECK(_impl_.quotedmessage_ != nullptr); + _impl_.quotedmessage_->Clear(); + } + if (cached_has_bits & 0x00000800u) { + GOOGLE_DCHECK(_impl_.quotedad_ != nullptr); + _impl_.quotedad_->Clear(); + } + if (cached_has_bits & 0x00001000u) { + GOOGLE_DCHECK(_impl_.placeholderkey_ != nullptr); + _impl_.placeholderkey_->Clear(); + } + if (cached_has_bits & 0x00002000u) { + GOOGLE_DCHECK(_impl_.externaladreply_ != nullptr); + _impl_.externaladreply_->Clear(); + } + if (cached_has_bits & 0x00004000u) { + GOOGLE_DCHECK(_impl_.disappearingmode_ != nullptr); + _impl_.disappearingmode_->Clear(); + } + if (cached_has_bits & 0x00008000u) { + GOOGLE_DCHECK(_impl_.actionlink_ != nullptr); + _impl_.actionlink_->Clear(); + } + } + if (cached_has_bits & 0x003f0000u) { + ::memset(&_impl_.conversiondelayseconds_, 0, static_cast( + reinterpret_cast(&_impl_.entrypointconversiondelayseconds_) - + reinterpret_cast(&_impl_.conversiondelayseconds_)) + sizeof(_impl_.entrypointconversiondelayseconds_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ContextInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string stanzaId = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_stanzaid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ContextInfo.stanzaId"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string participant = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_participant(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ContextInfo.participant"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.Message quotedMessage = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_quotedmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string remoteJid = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_remotejid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ContextInfo.remoteJid"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // repeated string mentionedJid = 15; + case 15: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_mentionedjid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ContextInfo.mentionedJid"); + #endif // !NDEBUG + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<122>(ptr)); + } else + goto handle_unusual; + continue; + // optional string conversionSource = 18; + case 18: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { + auto str = _internal_mutable_conversionsource(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ContextInfo.conversionSource"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bytes conversionData = 19; + case 19: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) { + auto str = _internal_mutable_conversiondata(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 conversionDelaySeconds = 20; + case 20: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 160)) { + _Internal::set_has_conversiondelayseconds(&has_bits); + _impl_.conversiondelayseconds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 forwardingScore = 21; + case 21: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 168)) { + _Internal::set_has_forwardingscore(&has_bits); + _impl_.forwardingscore_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool isForwarded = 22; + case 22: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 176)) { + _Internal::set_has_isforwarded(&has_bits); + _impl_.isforwarded_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.ContextInfo.AdReplyInfo quotedAd = 23; + case 23: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { + ptr = ctx->ParseMessage(_internal_mutable_quotedad(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.MessageKey placeholderKey = 24; + case 24: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 194)) { + ptr = ctx->ParseMessage(_internal_mutable_placeholderkey(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 expiration = 25; + case 25: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 200)) { + _Internal::set_has_expiration(&has_bits); + _impl_.expiration_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 ephemeralSettingTimestamp = 26; + case 26: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 208)) { + _Internal::set_has_ephemeralsettingtimestamp(&has_bits); + _impl_.ephemeralsettingtimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes ephemeralSharedSecret = 27; + case 27: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 218)) { + auto str = _internal_mutable_ephemeralsharedsecret(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.ContextInfo.ExternalAdReplyInfo externalAdReply = 28; + case 28: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 226)) { + ptr = ctx->ParseMessage(_internal_mutable_externaladreply(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string entryPointConversionSource = 29; + case 29: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 234)) { + auto str = _internal_mutable_entrypointconversionsource(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ContextInfo.entryPointConversionSource"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string entryPointConversionApp = 30; + case 30: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 242)) { + auto str = _internal_mutable_entrypointconversionapp(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ContextInfo.entryPointConversionApp"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional uint32 entryPointConversionDelaySeconds = 31; + case 31: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 248)) { + _Internal::set_has_entrypointconversiondelayseconds(&has_bits); + _impl_.entrypointconversiondelayseconds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.DisappearingMode disappearingMode = 32; + case 32: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 2)) { + ptr = ctx->ParseMessage(_internal_mutable_disappearingmode(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.ActionLink actionLink = 33; + case 33: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_actionlink(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string groupSubject = 34; + case 34: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_groupsubject(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ContextInfo.groupSubject"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string parentGroupJid = 35; + case 35: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_parentgroupjid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ContextInfo.parentGroupJid"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ContextInfo::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.ContextInfo) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string stanzaId = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_stanzaid().data(), static_cast(this->_internal_stanzaid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ContextInfo.stanzaId"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_stanzaid(), target); + } + + // optional string participant = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_participant().data(), static_cast(this->_internal_participant().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ContextInfo.participant"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_participant(), target); + } + + // optional .proto.Message quotedMessage = 3; + if (cached_has_bits & 0x00000400u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::quotedmessage(this), + _Internal::quotedmessage(this).GetCachedSize(), target, stream); + } + + // optional string remoteJid = 4; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_remotejid().data(), static_cast(this->_internal_remotejid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ContextInfo.remoteJid"); + target = stream->WriteStringMaybeAliased( + 4, this->_internal_remotejid(), target); + } + + // repeated string mentionedJid = 15; + for (int i = 0, n = this->_internal_mentionedjid_size(); i < n; i++) { + const auto& s = this->_internal_mentionedjid(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ContextInfo.mentionedJid"); + target = stream->WriteString(15, s, target); + } + + // optional string conversionSource = 18; + if (cached_has_bits & 0x00000008u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_conversionsource().data(), static_cast(this->_internal_conversionsource().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ContextInfo.conversionSource"); + target = stream->WriteStringMaybeAliased( + 18, this->_internal_conversionsource(), target); + } + + // optional bytes conversionData = 19; + if (cached_has_bits & 0x00000010u) { + target = stream->WriteBytesMaybeAliased( + 19, this->_internal_conversiondata(), target); + } + + // optional uint32 conversionDelaySeconds = 20; + if (cached_has_bits & 0x00010000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(20, this->_internal_conversiondelayseconds(), target); + } + + // optional uint32 forwardingScore = 21; + if (cached_has_bits & 0x00020000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(21, this->_internal_forwardingscore(), target); + } + + // optional bool isForwarded = 22; + if (cached_has_bits & 0x00040000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(22, this->_internal_isforwarded(), target); + } + + // optional .proto.ContextInfo.AdReplyInfo quotedAd = 23; + if (cached_has_bits & 0x00000800u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(23, _Internal::quotedad(this), + _Internal::quotedad(this).GetCachedSize(), target, stream); + } + + // optional .proto.MessageKey placeholderKey = 24; + if (cached_has_bits & 0x00001000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(24, _Internal::placeholderkey(this), + _Internal::placeholderkey(this).GetCachedSize(), target, stream); + } + + // optional uint32 expiration = 25; + if (cached_has_bits & 0x00080000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(25, this->_internal_expiration(), target); + } + + // optional int64 ephemeralSettingTimestamp = 26; + if (cached_has_bits & 0x00100000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(26, this->_internal_ephemeralsettingtimestamp(), target); + } + + // optional bytes ephemeralSharedSecret = 27; + if (cached_has_bits & 0x00000020u) { + target = stream->WriteBytesMaybeAliased( + 27, this->_internal_ephemeralsharedsecret(), target); + } + + // optional .proto.ContextInfo.ExternalAdReplyInfo externalAdReply = 28; + if (cached_has_bits & 0x00002000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(28, _Internal::externaladreply(this), + _Internal::externaladreply(this).GetCachedSize(), target, stream); + } + + // optional string entryPointConversionSource = 29; + if (cached_has_bits & 0x00000040u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_entrypointconversionsource().data(), static_cast(this->_internal_entrypointconversionsource().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ContextInfo.entryPointConversionSource"); + target = stream->WriteStringMaybeAliased( + 29, this->_internal_entrypointconversionsource(), target); + } + + // optional string entryPointConversionApp = 30; + if (cached_has_bits & 0x00000080u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_entrypointconversionapp().data(), static_cast(this->_internal_entrypointconversionapp().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ContextInfo.entryPointConversionApp"); + target = stream->WriteStringMaybeAliased( + 30, this->_internal_entrypointconversionapp(), target); + } + + // optional uint32 entryPointConversionDelaySeconds = 31; + if (cached_has_bits & 0x00200000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(31, this->_internal_entrypointconversiondelayseconds(), target); + } + + // optional .proto.DisappearingMode disappearingMode = 32; + if (cached_has_bits & 0x00004000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(32, _Internal::disappearingmode(this), + _Internal::disappearingmode(this).GetCachedSize(), target, stream); + } + + // optional .proto.ActionLink actionLink = 33; + if (cached_has_bits & 0x00008000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(33, _Internal::actionlink(this), + _Internal::actionlink(this).GetCachedSize(), target, stream); + } + + // optional string groupSubject = 34; + if (cached_has_bits & 0x00000100u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_groupsubject().data(), static_cast(this->_internal_groupsubject().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ContextInfo.groupSubject"); + target = stream->WriteStringMaybeAliased( + 34, this->_internal_groupsubject(), target); + } + + // optional string parentGroupJid = 35; + if (cached_has_bits & 0x00000200u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_parentgroupjid().data(), static_cast(this->_internal_parentgroupjid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ContextInfo.parentGroupJid"); + target = stream->WriteStringMaybeAliased( + 35, this->_internal_parentgroupjid(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.ContextInfo) + return target; +} + +size_t ContextInfo::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.ContextInfo) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string mentionedJid = 15; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.mentionedjid_.size()); + for (int i = 0, n = _impl_.mentionedjid_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + _impl_.mentionedjid_.Get(i)); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string stanzaId = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_stanzaid()); + } + + // optional string participant = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_participant()); + } + + // optional string remoteJid = 4; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_remotejid()); + } + + // optional string conversionSource = 18; + if (cached_has_bits & 0x00000008u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_conversionsource()); + } + + // optional bytes conversionData = 19; + if (cached_has_bits & 0x00000010u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_conversiondata()); + } + + // optional bytes ephemeralSharedSecret = 27; + if (cached_has_bits & 0x00000020u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_ephemeralsharedsecret()); + } + + // optional string entryPointConversionSource = 29; + if (cached_has_bits & 0x00000040u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_entrypointconversionsource()); + } + + // optional string entryPointConversionApp = 30; + if (cached_has_bits & 0x00000080u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_entrypointconversionapp()); + } + + } + if (cached_has_bits & 0x0000ff00u) { + // optional string groupSubject = 34; + if (cached_has_bits & 0x00000100u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_groupsubject()); + } + + // optional string parentGroupJid = 35; + if (cached_has_bits & 0x00000200u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_parentgroupjid()); + } + + // optional .proto.Message quotedMessage = 3; + if (cached_has_bits & 0x00000400u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.quotedmessage_); + } + + // optional .proto.ContextInfo.AdReplyInfo quotedAd = 23; + if (cached_has_bits & 0x00000800u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.quotedad_); + } + + // optional .proto.MessageKey placeholderKey = 24; + if (cached_has_bits & 0x00001000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.placeholderkey_); + } + + // optional .proto.ContextInfo.ExternalAdReplyInfo externalAdReply = 28; + if (cached_has_bits & 0x00002000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.externaladreply_); + } + + // optional .proto.DisappearingMode disappearingMode = 32; + if (cached_has_bits & 0x00004000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.disappearingmode_); + } + + // optional .proto.ActionLink actionLink = 33; + if (cached_has_bits & 0x00008000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.actionlink_); + } + + } + if (cached_has_bits & 0x003f0000u) { + // optional uint32 conversionDelaySeconds = 20; + if (cached_has_bits & 0x00010000u) { + total_size += 2 + + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_conversiondelayseconds()); + } + + // optional uint32 forwardingScore = 21; + if (cached_has_bits & 0x00020000u) { + total_size += 2 + + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_forwardingscore()); + } + + // optional bool isForwarded = 22; + if (cached_has_bits & 0x00040000u) { + total_size += 2 + 1; + } + + // optional uint32 expiration = 25; + if (cached_has_bits & 0x00080000u) { + total_size += 2 + + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_expiration()); + } + + // optional int64 ephemeralSettingTimestamp = 26; + if (cached_has_bits & 0x00100000u) { + total_size += 2 + + ::_pbi::WireFormatLite::Int64Size( + this->_internal_ephemeralsettingtimestamp()); + } + + // optional uint32 entryPointConversionDelaySeconds = 31; + if (cached_has_bits & 0x00200000u) { + total_size += 2 + + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_entrypointconversiondelayseconds()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ContextInfo::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + ContextInfo::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ContextInfo::GetClassData() const { return &_class_data_; } + + +void ContextInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.ContextInfo) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.mentionedjid_.MergeFrom(from._impl_.mentionedjid_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_stanzaid(from._internal_stanzaid()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_participant(from._internal_participant()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_remotejid(from._internal_remotejid()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_set_conversionsource(from._internal_conversionsource()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_set_conversiondata(from._internal_conversiondata()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_set_ephemeralsharedsecret(from._internal_ephemeralsharedsecret()); + } + if (cached_has_bits & 0x00000040u) { + _this->_internal_set_entrypointconversionsource(from._internal_entrypointconversionsource()); + } + if (cached_has_bits & 0x00000080u) { + _this->_internal_set_entrypointconversionapp(from._internal_entrypointconversionapp()); + } + } + if (cached_has_bits & 0x0000ff00u) { + if (cached_has_bits & 0x00000100u) { + _this->_internal_set_groupsubject(from._internal_groupsubject()); + } + if (cached_has_bits & 0x00000200u) { + _this->_internal_set_parentgroupjid(from._internal_parentgroupjid()); + } + if (cached_has_bits & 0x00000400u) { + _this->_internal_mutable_quotedmessage()->::proto::Message::MergeFrom( + from._internal_quotedmessage()); + } + if (cached_has_bits & 0x00000800u) { + _this->_internal_mutable_quotedad()->::proto::ContextInfo_AdReplyInfo::MergeFrom( + from._internal_quotedad()); + } + if (cached_has_bits & 0x00001000u) { + _this->_internal_mutable_placeholderkey()->::proto::MessageKey::MergeFrom( + from._internal_placeholderkey()); + } + if (cached_has_bits & 0x00002000u) { + _this->_internal_mutable_externaladreply()->::proto::ContextInfo_ExternalAdReplyInfo::MergeFrom( + from._internal_externaladreply()); + } + if (cached_has_bits & 0x00004000u) { + _this->_internal_mutable_disappearingmode()->::proto::DisappearingMode::MergeFrom( + from._internal_disappearingmode()); + } + if (cached_has_bits & 0x00008000u) { + _this->_internal_mutable_actionlink()->::proto::ActionLink::MergeFrom( + from._internal_actionlink()); + } + } + if (cached_has_bits & 0x003f0000u) { + if (cached_has_bits & 0x00010000u) { + _this->_impl_.conversiondelayseconds_ = from._impl_.conversiondelayseconds_; + } + if (cached_has_bits & 0x00020000u) { + _this->_impl_.forwardingscore_ = from._impl_.forwardingscore_; + } + if (cached_has_bits & 0x00040000u) { + _this->_impl_.isforwarded_ = from._impl_.isforwarded_; + } + if (cached_has_bits & 0x00080000u) { + _this->_impl_.expiration_ = from._impl_.expiration_; + } + if (cached_has_bits & 0x00100000u) { + _this->_impl_.ephemeralsettingtimestamp_ = from._impl_.ephemeralsettingtimestamp_; + } + if (cached_has_bits & 0x00200000u) { + _this->_impl_.entrypointconversiondelayseconds_ = from._impl_.entrypointconversiondelayseconds_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ContextInfo::CopyFrom(const ContextInfo& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.ContextInfo) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ContextInfo::IsInitialized() const { + return true; +} + +void ContextInfo::InternalSwap(ContextInfo* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.mentionedjid_.InternalSwap(&other->_impl_.mentionedjid_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.stanzaid_, lhs_arena, + &other->_impl_.stanzaid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.participant_, lhs_arena, + &other->_impl_.participant_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.remotejid_, lhs_arena, + &other->_impl_.remotejid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.conversionsource_, lhs_arena, + &other->_impl_.conversionsource_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.conversiondata_, lhs_arena, + &other->_impl_.conversiondata_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.ephemeralsharedsecret_, lhs_arena, + &other->_impl_.ephemeralsharedsecret_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.entrypointconversionsource_, lhs_arena, + &other->_impl_.entrypointconversionsource_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.entrypointconversionapp_, lhs_arena, + &other->_impl_.entrypointconversionapp_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.groupsubject_, lhs_arena, + &other->_impl_.groupsubject_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.parentgroupjid_, lhs_arena, + &other->_impl_.parentgroupjid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ContextInfo, _impl_.entrypointconversiondelayseconds_) + + sizeof(ContextInfo::_impl_.entrypointconversiondelayseconds_) + - PROTOBUF_FIELD_OFFSET(ContextInfo, _impl_.quotedmessage_)>( + reinterpret_cast(&_impl_.quotedmessage_), + reinterpret_cast(&other->_impl_.quotedmessage_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ContextInfo::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[24]); +} + +// =================================================================== + +class Conversation::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_id(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_newjid(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_oldjid(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_lastmsgtimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 16384u; + } + static void set_has_unreadcount(HasBits* has_bits) { + (*has_bits)[0] |= 32768u; + } + static void set_has_readonly(HasBits* has_bits) { + (*has_bits)[0] |= 524288u; + } + static void set_has_endofhistorytransfer(HasBits* has_bits) { + (*has_bits)[0] |= 1048576u; + } + static void set_has_ephemeralexpiration(HasBits* has_bits) { + (*has_bits)[0] |= 65536u; + } + static void set_has_ephemeralsettingtimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 131072u; + } + static void set_has_endofhistorytransfertype(HasBits* has_bits) { + (*has_bits)[0] |= 262144u; + } + static void set_has_conversationtimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 8388608u; + } + static void set_has_name(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_phash(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_notspam(HasBits* has_bits) { + (*has_bits)[0] |= 2097152u; + } + static void set_has_archived(HasBits* has_bits) { + (*has_bits)[0] |= 4194304u; + } + static const ::proto::DisappearingMode& disappearingmode(const Conversation* msg); + static void set_has_disappearingmode(HasBits* has_bits) { + (*has_bits)[0] |= 4096u; + } + static void set_has_unreadmentioncount(HasBits* has_bits) { + (*has_bits)[0] |= 16777216u; + } + static void set_has_markedasunread(HasBits* has_bits) { + (*has_bits)[0] |= 536870912u; + } + static void set_has_tctoken(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_tctokentimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 67108864u; + } + static void set_has_contactprimaryidentitykey(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_pinned(HasBits* has_bits) { + (*has_bits)[0] |= 33554432u; + } + static void set_has_muteendtime(HasBits* has_bits) { + (*has_bits)[0] |= 134217728u; + } + static const ::proto::WallpaperSettings& wallpaper(const Conversation* msg); + static void set_has_wallpaper(HasBits* has_bits) { + (*has_bits)[0] |= 8192u; + } + static void set_has_mediavisibility(HasBits* has_bits) { + (*has_bits)[0] |= 268435456u; + } + static void set_has_tctokensendertimestamp(HasBits* has_bits) { + (*has_bits)[1] |= 2u; + } + static void set_has_suspended(HasBits* has_bits) { + (*has_bits)[0] |= 1073741824u; + } + static void set_has_terminated(HasBits* has_bits) { + (*has_bits)[0] |= 2147483648u; + } + static void set_has_createdat(HasBits* has_bits) { + (*has_bits)[1] |= 4u; + } + static void set_has_createdby(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_description(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_support(HasBits* has_bits) { + (*has_bits)[1] |= 1u; + } + static void set_has_isparentgroup(HasBits* has_bits) { + (*has_bits)[1] |= 8u; + } + static void set_has_isdefaultsubgroup(HasBits* has_bits) { + (*has_bits)[1] |= 16u; + } + static void set_has_parentgroupid(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_displayname(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static void set_has_pnjid(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static void set_has_selfpnexposed(HasBits* has_bits) { + (*has_bits)[1] |= 32u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0; + } +}; + +const ::proto::DisappearingMode& +Conversation::_Internal::disappearingmode(const Conversation* msg) { + return *msg->_impl_.disappearingmode_; +} +const ::proto::WallpaperSettings& +Conversation::_Internal::wallpaper(const Conversation* msg) { + return *msg->_impl_.wallpaper_; +} +Conversation::Conversation(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Conversation) +} +Conversation::Conversation(const Conversation& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Conversation* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.messages_){from._impl_.messages_} + , decltype(_impl_.participant_){from._impl_.participant_} + , decltype(_impl_.id_){} + , decltype(_impl_.newjid_){} + , decltype(_impl_.oldjid_){} + , decltype(_impl_.name_){} + , decltype(_impl_.phash_){} + , decltype(_impl_.tctoken_){} + , decltype(_impl_.contactprimaryidentitykey_){} + , decltype(_impl_.createdby_){} + , decltype(_impl_.description_){} + , decltype(_impl_.parentgroupid_){} + , decltype(_impl_.displayname_){} + , decltype(_impl_.pnjid_){} + , decltype(_impl_.disappearingmode_){nullptr} + , decltype(_impl_.wallpaper_){nullptr} + , decltype(_impl_.lastmsgtimestamp_){} + , decltype(_impl_.unreadcount_){} + , decltype(_impl_.ephemeralexpiration_){} + , decltype(_impl_.ephemeralsettingtimestamp_){} + , decltype(_impl_.endofhistorytransfertype_){} + , decltype(_impl_.readonly_){} + , decltype(_impl_.endofhistorytransfer_){} + , decltype(_impl_.notspam_){} + , decltype(_impl_.archived_){} + , decltype(_impl_.conversationtimestamp_){} + , decltype(_impl_.unreadmentioncount_){} + , decltype(_impl_.pinned_){} + , decltype(_impl_.tctokentimestamp_){} + , decltype(_impl_.muteendtime_){} + , decltype(_impl_.mediavisibility_){} + , decltype(_impl_.markedasunread_){} + , decltype(_impl_.suspended_){} + , decltype(_impl_.terminated_){} + , decltype(_impl_.support_){} + , decltype(_impl_.tctokensendertimestamp_){} + , decltype(_impl_.createdat_){} + , decltype(_impl_.isparentgroup_){} + , decltype(_impl_.isdefaultsubgroup_){} + , decltype(_impl_.selfpnexposed_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.id_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.id_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_id()) { + _this->_impl_.id_.Set(from._internal_id(), + _this->GetArenaForAllocation()); + } + _impl_.newjid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.newjid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_newjid()) { + _this->_impl_.newjid_.Set(from._internal_newjid(), + _this->GetArenaForAllocation()); + } + _impl_.oldjid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.oldjid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_oldjid()) { + _this->_impl_.oldjid_.Set(from._internal_oldjid(), + _this->GetArenaForAllocation()); + } + _impl_.name_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.name_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_name()) { + _this->_impl_.name_.Set(from._internal_name(), + _this->GetArenaForAllocation()); + } + _impl_.phash_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.phash_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_phash()) { + _this->_impl_.phash_.Set(from._internal_phash(), + _this->GetArenaForAllocation()); + } + _impl_.tctoken_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.tctoken_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_tctoken()) { + _this->_impl_.tctoken_.Set(from._internal_tctoken(), + _this->GetArenaForAllocation()); + } + _impl_.contactprimaryidentitykey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.contactprimaryidentitykey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_contactprimaryidentitykey()) { + _this->_impl_.contactprimaryidentitykey_.Set(from._internal_contactprimaryidentitykey(), + _this->GetArenaForAllocation()); + } + _impl_.createdby_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.createdby_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_createdby()) { + _this->_impl_.createdby_.Set(from._internal_createdby(), + _this->GetArenaForAllocation()); + } + _impl_.description_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.description_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_description()) { + _this->_impl_.description_.Set(from._internal_description(), + _this->GetArenaForAllocation()); + } + _impl_.parentgroupid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.parentgroupid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_parentgroupid()) { + _this->_impl_.parentgroupid_.Set(from._internal_parentgroupid(), + _this->GetArenaForAllocation()); + } + _impl_.displayname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.displayname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_displayname()) { + _this->_impl_.displayname_.Set(from._internal_displayname(), + _this->GetArenaForAllocation()); + } + _impl_.pnjid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.pnjid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_pnjid()) { + _this->_impl_.pnjid_.Set(from._internal_pnjid(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_disappearingmode()) { + _this->_impl_.disappearingmode_ = new ::proto::DisappearingMode(*from._impl_.disappearingmode_); + } + if (from._internal_has_wallpaper()) { + _this->_impl_.wallpaper_ = new ::proto::WallpaperSettings(*from._impl_.wallpaper_); + } + ::memcpy(&_impl_.lastmsgtimestamp_, &from._impl_.lastmsgtimestamp_, + static_cast(reinterpret_cast(&_impl_.selfpnexposed_) - + reinterpret_cast(&_impl_.lastmsgtimestamp_)) + sizeof(_impl_.selfpnexposed_)); + // @@protoc_insertion_point(copy_constructor:proto.Conversation) +} + +inline void Conversation::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.messages_){arena} + , decltype(_impl_.participant_){arena} + , decltype(_impl_.id_){} + , decltype(_impl_.newjid_){} + , decltype(_impl_.oldjid_){} + , decltype(_impl_.name_){} + , decltype(_impl_.phash_){} + , decltype(_impl_.tctoken_){} + , decltype(_impl_.contactprimaryidentitykey_){} + , decltype(_impl_.createdby_){} + , decltype(_impl_.description_){} + , decltype(_impl_.parentgroupid_){} + , decltype(_impl_.displayname_){} + , decltype(_impl_.pnjid_){} + , decltype(_impl_.disappearingmode_){nullptr} + , decltype(_impl_.wallpaper_){nullptr} + , decltype(_impl_.lastmsgtimestamp_){uint64_t{0u}} + , decltype(_impl_.unreadcount_){0u} + , decltype(_impl_.ephemeralexpiration_){0u} + , decltype(_impl_.ephemeralsettingtimestamp_){int64_t{0}} + , decltype(_impl_.endofhistorytransfertype_){0} + , decltype(_impl_.readonly_){false} + , decltype(_impl_.endofhistorytransfer_){false} + , decltype(_impl_.notspam_){false} + , decltype(_impl_.archived_){false} + , decltype(_impl_.conversationtimestamp_){uint64_t{0u}} + , decltype(_impl_.unreadmentioncount_){0u} + , decltype(_impl_.pinned_){0u} + , decltype(_impl_.tctokentimestamp_){uint64_t{0u}} + , decltype(_impl_.muteendtime_){uint64_t{0u}} + , decltype(_impl_.mediavisibility_){0} + , decltype(_impl_.markedasunread_){false} + , decltype(_impl_.suspended_){false} + , decltype(_impl_.terminated_){false} + , decltype(_impl_.support_){false} + , decltype(_impl_.tctokensendertimestamp_){uint64_t{0u}} + , decltype(_impl_.createdat_){uint64_t{0u}} + , decltype(_impl_.isparentgroup_){false} + , decltype(_impl_.isdefaultsubgroup_){false} + , decltype(_impl_.selfpnexposed_){false} + }; + _impl_.id_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.id_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.newjid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.newjid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.oldjid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.oldjid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.name_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.name_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.phash_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.phash_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.tctoken_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.tctoken_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.contactprimaryidentitykey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.contactprimaryidentitykey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.createdby_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.createdby_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.description_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.description_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.parentgroupid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.parentgroupid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.displayname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.displayname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.pnjid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.pnjid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Conversation::~Conversation() { + // @@protoc_insertion_point(destructor:proto.Conversation) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Conversation::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.messages_.~RepeatedPtrField(); + _impl_.participant_.~RepeatedPtrField(); + _impl_.id_.Destroy(); + _impl_.newjid_.Destroy(); + _impl_.oldjid_.Destroy(); + _impl_.name_.Destroy(); + _impl_.phash_.Destroy(); + _impl_.tctoken_.Destroy(); + _impl_.contactprimaryidentitykey_.Destroy(); + _impl_.createdby_.Destroy(); + _impl_.description_.Destroy(); + _impl_.parentgroupid_.Destroy(); + _impl_.displayname_.Destroy(); + _impl_.pnjid_.Destroy(); + if (this != internal_default_instance()) delete _impl_.disappearingmode_; + if (this != internal_default_instance()) delete _impl_.wallpaper_; +} + +void Conversation::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Conversation::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Conversation) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.messages_.Clear(); + _impl_.participant_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _impl_.id_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.newjid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.oldjid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + _impl_.name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + _impl_.phash_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000020u) { + _impl_.tctoken_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000040u) { + _impl_.contactprimaryidentitykey_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000080u) { + _impl_.createdby_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x00003f00u) { + if (cached_has_bits & 0x00000100u) { + _impl_.description_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000200u) { + _impl_.parentgroupid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000400u) { + _impl_.displayname_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000800u) { + _impl_.pnjid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00001000u) { + GOOGLE_DCHECK(_impl_.disappearingmode_ != nullptr); + _impl_.disappearingmode_->Clear(); + } + if (cached_has_bits & 0x00002000u) { + GOOGLE_DCHECK(_impl_.wallpaper_ != nullptr); + _impl_.wallpaper_->Clear(); + } + } + if (cached_has_bits & 0x0000c000u) { + ::memset(&_impl_.lastmsgtimestamp_, 0, static_cast( + reinterpret_cast(&_impl_.unreadcount_) - + reinterpret_cast(&_impl_.lastmsgtimestamp_)) + sizeof(_impl_.unreadcount_)); + } + if (cached_has_bits & 0x00ff0000u) { + ::memset(&_impl_.ephemeralexpiration_, 0, static_cast( + reinterpret_cast(&_impl_.conversationtimestamp_) - + reinterpret_cast(&_impl_.ephemeralexpiration_)) + sizeof(_impl_.conversationtimestamp_)); + } + if (cached_has_bits & 0xff000000u) { + ::memset(&_impl_.unreadmentioncount_, 0, static_cast( + reinterpret_cast(&_impl_.terminated_) - + reinterpret_cast(&_impl_.unreadmentioncount_)) + sizeof(_impl_.terminated_)); + } + cached_has_bits = _impl_._has_bits_[1]; + if (cached_has_bits & 0x0000003fu) { + ::memset(&_impl_.support_, 0, static_cast( + reinterpret_cast(&_impl_.selfpnexposed_) - + reinterpret_cast(&_impl_.support_)) + sizeof(_impl_.selfpnexposed_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Conversation::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // required string id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_id(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Conversation.id"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // repeated .proto.HistorySyncMsg messages = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_messages(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else + goto handle_unusual; + continue; + // optional string newJid = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_newjid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Conversation.newJid"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string oldJid = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_oldjid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Conversation.oldJid"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional uint64 lastMsgTimestamp = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_lastmsgtimestamp(&_impl_._has_bits_); + _impl_.lastmsgtimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 unreadCount = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + _Internal::set_has_unreadcount(&_impl_._has_bits_); + _impl_.unreadcount_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool readOnly = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + _Internal::set_has_readonly(&_impl_._has_bits_); + _impl_.readonly_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool endOfHistoryTransfer = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { + _Internal::set_has_endofhistorytransfer(&_impl_._has_bits_); + _impl_.endofhistorytransfer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 ephemeralExpiration = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { + _Internal::set_has_ephemeralexpiration(&_impl_._has_bits_); + _impl_.ephemeralexpiration_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 ephemeralSettingTimestamp = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { + _Internal::set_has_ephemeralsettingtimestamp(&_impl_._has_bits_); + _impl_.ephemeralsettingtimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Conversation.EndOfHistoryTransferType endOfHistoryTransferType = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::Conversation_EndOfHistoryTransferType_IsValid(val))) { + _internal_set_endofhistorytransfertype(static_cast<::proto::Conversation_EndOfHistoryTransferType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(11, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional uint64 conversationTimestamp = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { + _Internal::set_has_conversationtimestamp(&_impl_._has_bits_); + _impl_.conversationtimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string name = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { + auto str = _internal_mutable_name(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Conversation.name"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string pHash = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) { + auto str = _internal_mutable_phash(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Conversation.pHash"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bool notSpam = 15; + case 15: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 120)) { + _Internal::set_has_notspam(&_impl_._has_bits_); + _impl_.notspam_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool archived = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 128)) { + _Internal::set_has_archived(&_impl_._has_bits_); + _impl_.archived_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.DisappearingMode disappearingMode = 17; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { + ptr = ctx->ParseMessage(_internal_mutable_disappearingmode(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 unreadMentionCount = 18; + case 18: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 144)) { + _Internal::set_has_unreadmentioncount(&_impl_._has_bits_); + _impl_.unreadmentioncount_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool markedAsUnread = 19; + case 19: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 152)) { + _Internal::set_has_markedasunread(&_impl_._has_bits_); + _impl_.markedasunread_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .proto.GroupParticipant participant = 20; + case 20: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 162)) { + ptr -= 2; + do { + ptr += 2; + ptr = ctx->ParseMessage(_internal_add_participant(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<162>(ptr)); + } else + goto handle_unusual; + continue; + // optional bytes tcToken = 21; + case 21: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { + auto str = _internal_mutable_tctoken(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint64 tcTokenTimestamp = 22; + case 22: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 176)) { + _Internal::set_has_tctokentimestamp(&_impl_._has_bits_); + _impl_.tctokentimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes contactPrimaryIdentityKey = 23; + case 23: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { + auto str = _internal_mutable_contactprimaryidentitykey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 pinned = 24; + case 24: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 192)) { + _Internal::set_has_pinned(&_impl_._has_bits_); + _impl_.pinned_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint64 muteEndTime = 25; + case 25: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 200)) { + _Internal::set_has_muteendtime(&_impl_._has_bits_); + _impl_.muteendtime_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.WallpaperSettings wallpaper = 26; + case 26: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 210)) { + ptr = ctx->ParseMessage(_internal_mutable_wallpaper(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.MediaVisibility mediaVisibility = 27; + case 27: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 216)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::MediaVisibility_IsValid(val))) { + _internal_set_mediavisibility(static_cast<::proto::MediaVisibility>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(27, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional uint64 tcTokenSenderTimestamp = 28; + case 28: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 224)) { + _Internal::set_has_tctokensendertimestamp(&_impl_._has_bits_); + _impl_.tctokensendertimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool suspended = 29; + case 29: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 232)) { + _Internal::set_has_suspended(&_impl_._has_bits_); + _impl_.suspended_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool terminated = 30; + case 30: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 240)) { + _Internal::set_has_terminated(&_impl_._has_bits_); + _impl_.terminated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint64 createdAt = 31; + case 31: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 248)) { + _Internal::set_has_createdat(&_impl_._has_bits_); + _impl_.createdat_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string createdBy = 32; + case 32: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 2)) { + auto str = _internal_mutable_createdby(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Conversation.createdBy"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string description = 33; + case 33: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_description(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Conversation.description"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bool support = 34; + case 34: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_support(&_impl_._has_bits_); + _impl_.support_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool isParentGroup = 35; + case 35: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_isparentgroup(&_impl_._has_bits_); + _impl_.isparentgroup_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool isDefaultSubgroup = 36; + case 36: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_isdefaultsubgroup(&_impl_._has_bits_); + _impl_.isdefaultsubgroup_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string parentGroupId = 37; + case 37: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + auto str = _internal_mutable_parentgroupid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Conversation.parentGroupId"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string displayName = 38; + case 38: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + auto str = _internal_mutable_displayname(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Conversation.displayName"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string pnJid = 39; + case 39: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + auto str = _internal_mutable_pnjid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Conversation.pnJid"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bool selfPnExposed = 40; + case 40: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { + _Internal::set_has_selfpnexposed(&_impl_._has_bits_); + _impl_.selfpnexposed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Conversation::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Conversation) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // required string id = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_id().data(), static_cast(this->_internal_id().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Conversation.id"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_id(), target); + } + + // repeated .proto.HistorySyncMsg messages = 2; + for (unsigned i = 0, + n = static_cast(this->_internal_messages_size()); i < n; i++) { + const auto& repfield = this->_internal_messages(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream); + } + + // optional string newJid = 3; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_newjid().data(), static_cast(this->_internal_newjid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Conversation.newJid"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_newjid(), target); + } + + // optional string oldJid = 4; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_oldjid().data(), static_cast(this->_internal_oldjid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Conversation.oldJid"); + target = stream->WriteStringMaybeAliased( + 4, this->_internal_oldjid(), target); + } + + // optional uint64 lastMsgTimestamp = 5; + if (cached_has_bits & 0x00004000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_lastmsgtimestamp(), target); + } + + // optional uint32 unreadCount = 6; + if (cached_has_bits & 0x00008000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_unreadcount(), target); + } + + // optional bool readOnly = 7; + if (cached_has_bits & 0x00080000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(7, this->_internal_readonly(), target); + } + + // optional bool endOfHistoryTransfer = 8; + if (cached_has_bits & 0x00100000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(8, this->_internal_endofhistorytransfer(), target); + } + + // optional uint32 ephemeralExpiration = 9; + if (cached_has_bits & 0x00010000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(9, this->_internal_ephemeralexpiration(), target); + } + + // optional int64 ephemeralSettingTimestamp = 10; + if (cached_has_bits & 0x00020000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(10, this->_internal_ephemeralsettingtimestamp(), target); + } + + // optional .proto.Conversation.EndOfHistoryTransferType endOfHistoryTransferType = 11; + if (cached_has_bits & 0x00040000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 11, this->_internal_endofhistorytransfertype(), target); + } + + // optional uint64 conversationTimestamp = 12; + if (cached_has_bits & 0x00800000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(12, this->_internal_conversationtimestamp(), target); + } + + // optional string name = 13; + if (cached_has_bits & 0x00000008u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Conversation.name"); + target = stream->WriteStringMaybeAliased( + 13, this->_internal_name(), target); + } + + // optional string pHash = 14; + if (cached_has_bits & 0x00000010u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_phash().data(), static_cast(this->_internal_phash().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Conversation.pHash"); + target = stream->WriteStringMaybeAliased( + 14, this->_internal_phash(), target); + } + + // optional bool notSpam = 15; + if (cached_has_bits & 0x00200000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(15, this->_internal_notspam(), target); + } + + // optional bool archived = 16; + if (cached_has_bits & 0x00400000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(16, this->_internal_archived(), target); + } + + // optional .proto.DisappearingMode disappearingMode = 17; + if (cached_has_bits & 0x00001000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(17, _Internal::disappearingmode(this), + _Internal::disappearingmode(this).GetCachedSize(), target, stream); + } + + // optional uint32 unreadMentionCount = 18; + if (cached_has_bits & 0x01000000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(18, this->_internal_unreadmentioncount(), target); + } + + // optional bool markedAsUnread = 19; + if (cached_has_bits & 0x20000000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(19, this->_internal_markedasunread(), target); + } + + // repeated .proto.GroupParticipant participant = 20; + for (unsigned i = 0, + n = static_cast(this->_internal_participant_size()); i < n; i++) { + const auto& repfield = this->_internal_participant(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(20, repfield, repfield.GetCachedSize(), target, stream); + } + + // optional bytes tcToken = 21; + if (cached_has_bits & 0x00000020u) { + target = stream->WriteBytesMaybeAliased( + 21, this->_internal_tctoken(), target); + } + + // optional uint64 tcTokenTimestamp = 22; + if (cached_has_bits & 0x04000000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(22, this->_internal_tctokentimestamp(), target); + } + + // optional bytes contactPrimaryIdentityKey = 23; + if (cached_has_bits & 0x00000040u) { + target = stream->WriteBytesMaybeAliased( + 23, this->_internal_contactprimaryidentitykey(), target); + } + + // optional uint32 pinned = 24; + if (cached_has_bits & 0x02000000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(24, this->_internal_pinned(), target); + } + + // optional uint64 muteEndTime = 25; + if (cached_has_bits & 0x08000000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(25, this->_internal_muteendtime(), target); + } + + // optional .proto.WallpaperSettings wallpaper = 26; + if (cached_has_bits & 0x00002000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(26, _Internal::wallpaper(this), + _Internal::wallpaper(this).GetCachedSize(), target, stream); + } + + // optional .proto.MediaVisibility mediaVisibility = 27; + if (cached_has_bits & 0x10000000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 27, this->_internal_mediavisibility(), target); + } + + cached_has_bits = _impl_._has_bits_[1]; + // optional uint64 tcTokenSenderTimestamp = 28; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(28, this->_internal_tctokensendertimestamp(), target); + } + + cached_has_bits = _impl_._has_bits_[0]; + // optional bool suspended = 29; + if (cached_has_bits & 0x40000000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(29, this->_internal_suspended(), target); + } + + // optional bool terminated = 30; + if (cached_has_bits & 0x80000000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(30, this->_internal_terminated(), target); + } + + cached_has_bits = _impl_._has_bits_[1]; + // optional uint64 createdAt = 31; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(31, this->_internal_createdat(), target); + } + + cached_has_bits = _impl_._has_bits_[0]; + // optional string createdBy = 32; + if (cached_has_bits & 0x00000080u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_createdby().data(), static_cast(this->_internal_createdby().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Conversation.createdBy"); + target = stream->WriteStringMaybeAliased( + 32, this->_internal_createdby(), target); + } + + // optional string description = 33; + if (cached_has_bits & 0x00000100u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_description().data(), static_cast(this->_internal_description().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Conversation.description"); + target = stream->WriteStringMaybeAliased( + 33, this->_internal_description(), target); + } + + cached_has_bits = _impl_._has_bits_[1]; + // optional bool support = 34; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(34, this->_internal_support(), target); + } + + // optional bool isParentGroup = 35; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(35, this->_internal_isparentgroup(), target); + } + + // optional bool isDefaultSubgroup = 36; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(36, this->_internal_isdefaultsubgroup(), target); + } + + cached_has_bits = _impl_._has_bits_[0]; + // optional string parentGroupId = 37; + if (cached_has_bits & 0x00000200u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_parentgroupid().data(), static_cast(this->_internal_parentgroupid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Conversation.parentGroupId"); + target = stream->WriteStringMaybeAliased( + 37, this->_internal_parentgroupid(), target); + } + + // optional string displayName = 38; + if (cached_has_bits & 0x00000400u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_displayname().data(), static_cast(this->_internal_displayname().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Conversation.displayName"); + target = stream->WriteStringMaybeAliased( + 38, this->_internal_displayname(), target); + } + + // optional string pnJid = 39; + if (cached_has_bits & 0x00000800u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_pnjid().data(), static_cast(this->_internal_pnjid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Conversation.pnJid"); + target = stream->WriteStringMaybeAliased( + 39, this->_internal_pnjid(), target); + } + + cached_has_bits = _impl_._has_bits_[1]; + // optional bool selfPnExposed = 40; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(40, this->_internal_selfpnexposed(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Conversation) + return target; +} + +size_t Conversation::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Conversation) + size_t total_size = 0; + + // required string id = 1; + if (_internal_has_id()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_id()); + } + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.HistorySyncMsg messages = 2; + total_size += 1UL * this->_internal_messages_size(); + for (const auto& msg : this->_impl_.messages_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .proto.GroupParticipant participant = 20; + total_size += 2UL * this->_internal_participant_size(); + for (const auto& msg : this->_impl_.participant_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000feu) { + // optional string newJid = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_newjid()); + } + + // optional string oldJid = 4; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_oldjid()); + } + + // optional string name = 13; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // optional string pHash = 14; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_phash()); + } + + // optional bytes tcToken = 21; + if (cached_has_bits & 0x00000020u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_tctoken()); + } + + // optional bytes contactPrimaryIdentityKey = 23; + if (cached_has_bits & 0x00000040u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_contactprimaryidentitykey()); + } + + // optional string createdBy = 32; + if (cached_has_bits & 0x00000080u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_createdby()); + } + + } + if (cached_has_bits & 0x0000ff00u) { + // optional string description = 33; + if (cached_has_bits & 0x00000100u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_description()); + } + + // optional string parentGroupId = 37; + if (cached_has_bits & 0x00000200u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_parentgroupid()); + } + + // optional string displayName = 38; + if (cached_has_bits & 0x00000400u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_displayname()); + } + + // optional string pnJid = 39; + if (cached_has_bits & 0x00000800u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_pnjid()); + } + + // optional .proto.DisappearingMode disappearingMode = 17; + if (cached_has_bits & 0x00001000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.disappearingmode_); + } + + // optional .proto.WallpaperSettings wallpaper = 26; + if (cached_has_bits & 0x00002000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.wallpaper_); + } + + // optional uint64 lastMsgTimestamp = 5; + if (cached_has_bits & 0x00004000u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_lastmsgtimestamp()); + } + + // optional uint32 unreadCount = 6; + if (cached_has_bits & 0x00008000u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_unreadcount()); + } + + } + if (cached_has_bits & 0x00ff0000u) { + // optional uint32 ephemeralExpiration = 9; + if (cached_has_bits & 0x00010000u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_ephemeralexpiration()); + } + + // optional int64 ephemeralSettingTimestamp = 10; + if (cached_has_bits & 0x00020000u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_ephemeralsettingtimestamp()); + } + + // optional .proto.Conversation.EndOfHistoryTransferType endOfHistoryTransferType = 11; + if (cached_has_bits & 0x00040000u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_endofhistorytransfertype()); + } + + // optional bool readOnly = 7; + if (cached_has_bits & 0x00080000u) { + total_size += 1 + 1; + } + + // optional bool endOfHistoryTransfer = 8; + if (cached_has_bits & 0x00100000u) { + total_size += 1 + 1; + } + + // optional bool notSpam = 15; + if (cached_has_bits & 0x00200000u) { + total_size += 1 + 1; + } + + // optional bool archived = 16; + if (cached_has_bits & 0x00400000u) { + total_size += 2 + 1; + } + + // optional uint64 conversationTimestamp = 12; + if (cached_has_bits & 0x00800000u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_conversationtimestamp()); + } + + } + if (cached_has_bits & 0xff000000u) { + // optional uint32 unreadMentionCount = 18; + if (cached_has_bits & 0x01000000u) { + total_size += 2 + + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_unreadmentioncount()); + } + + // optional uint32 pinned = 24; + if (cached_has_bits & 0x02000000u) { + total_size += 2 + + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_pinned()); + } + + // optional uint64 tcTokenTimestamp = 22; + if (cached_has_bits & 0x04000000u) { + total_size += 2 + + ::_pbi::WireFormatLite::UInt64Size( + this->_internal_tctokentimestamp()); + } + + // optional uint64 muteEndTime = 25; + if (cached_has_bits & 0x08000000u) { + total_size += 2 + + ::_pbi::WireFormatLite::UInt64Size( + this->_internal_muteendtime()); + } + + // optional .proto.MediaVisibility mediaVisibility = 27; + if (cached_has_bits & 0x10000000u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_mediavisibility()); + } + + // optional bool markedAsUnread = 19; + if (cached_has_bits & 0x20000000u) { + total_size += 2 + 1; + } + + // optional bool suspended = 29; + if (cached_has_bits & 0x40000000u) { + total_size += 2 + 1; + } + + // optional bool terminated = 30; + if (cached_has_bits & 0x80000000u) { + total_size += 2 + 1; + } + + } + cached_has_bits = _impl_._has_bits_[1]; + if (cached_has_bits & 0x0000003fu) { + // optional bool support = 34; + if (cached_has_bits & 0x00000001u) { + total_size += 2 + 1; + } + + // optional uint64 tcTokenSenderTimestamp = 28; + if (cached_has_bits & 0x00000002u) { + total_size += 2 + + ::_pbi::WireFormatLite::UInt64Size( + this->_internal_tctokensendertimestamp()); + } + + // optional uint64 createdAt = 31; + if (cached_has_bits & 0x00000004u) { + total_size += 2 + + ::_pbi::WireFormatLite::UInt64Size( + this->_internal_createdat()); + } + + // optional bool isParentGroup = 35; + if (cached_has_bits & 0x00000008u) { + total_size += 2 + 1; + } + + // optional bool isDefaultSubgroup = 36; + if (cached_has_bits & 0x00000010u) { + total_size += 2 + 1; + } + + // optional bool selfPnExposed = 40; + if (cached_has_bits & 0x00000020u) { + total_size += 2 + 1; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Conversation::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Conversation::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Conversation::GetClassData() const { return &_class_data_; } + + +void Conversation::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Conversation) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.messages_.MergeFrom(from._impl_.messages_); + _this->_impl_.participant_.MergeFrom(from._impl_.participant_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_id(from._internal_id()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_newjid(from._internal_newjid()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_oldjid(from._internal_oldjid()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_set_name(from._internal_name()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_set_phash(from._internal_phash()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_set_tctoken(from._internal_tctoken()); + } + if (cached_has_bits & 0x00000040u) { + _this->_internal_set_contactprimaryidentitykey(from._internal_contactprimaryidentitykey()); + } + if (cached_has_bits & 0x00000080u) { + _this->_internal_set_createdby(from._internal_createdby()); + } + } + if (cached_has_bits & 0x0000ff00u) { + if (cached_has_bits & 0x00000100u) { + _this->_internal_set_description(from._internal_description()); + } + if (cached_has_bits & 0x00000200u) { + _this->_internal_set_parentgroupid(from._internal_parentgroupid()); + } + if (cached_has_bits & 0x00000400u) { + _this->_internal_set_displayname(from._internal_displayname()); + } + if (cached_has_bits & 0x00000800u) { + _this->_internal_set_pnjid(from._internal_pnjid()); + } + if (cached_has_bits & 0x00001000u) { + _this->_internal_mutable_disappearingmode()->::proto::DisappearingMode::MergeFrom( + from._internal_disappearingmode()); + } + if (cached_has_bits & 0x00002000u) { + _this->_internal_mutable_wallpaper()->::proto::WallpaperSettings::MergeFrom( + from._internal_wallpaper()); + } + if (cached_has_bits & 0x00004000u) { + _this->_impl_.lastmsgtimestamp_ = from._impl_.lastmsgtimestamp_; + } + if (cached_has_bits & 0x00008000u) { + _this->_impl_.unreadcount_ = from._impl_.unreadcount_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00ff0000u) { + if (cached_has_bits & 0x00010000u) { + _this->_impl_.ephemeralexpiration_ = from._impl_.ephemeralexpiration_; + } + if (cached_has_bits & 0x00020000u) { + _this->_impl_.ephemeralsettingtimestamp_ = from._impl_.ephemeralsettingtimestamp_; + } + if (cached_has_bits & 0x00040000u) { + _this->_impl_.endofhistorytransfertype_ = from._impl_.endofhistorytransfertype_; + } + if (cached_has_bits & 0x00080000u) { + _this->_impl_.readonly_ = from._impl_.readonly_; + } + if (cached_has_bits & 0x00100000u) { + _this->_impl_.endofhistorytransfer_ = from._impl_.endofhistorytransfer_; + } + if (cached_has_bits & 0x00200000u) { + _this->_impl_.notspam_ = from._impl_.notspam_; + } + if (cached_has_bits & 0x00400000u) { + _this->_impl_.archived_ = from._impl_.archived_; + } + if (cached_has_bits & 0x00800000u) { + _this->_impl_.conversationtimestamp_ = from._impl_.conversationtimestamp_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0xff000000u) { + if (cached_has_bits & 0x01000000u) { + _this->_impl_.unreadmentioncount_ = from._impl_.unreadmentioncount_; + } + if (cached_has_bits & 0x02000000u) { + _this->_impl_.pinned_ = from._impl_.pinned_; + } + if (cached_has_bits & 0x04000000u) { + _this->_impl_.tctokentimestamp_ = from._impl_.tctokentimestamp_; + } + if (cached_has_bits & 0x08000000u) { + _this->_impl_.muteendtime_ = from._impl_.muteendtime_; + } + if (cached_has_bits & 0x10000000u) { + _this->_impl_.mediavisibility_ = from._impl_.mediavisibility_; + } + if (cached_has_bits & 0x20000000u) { + _this->_impl_.markedasunread_ = from._impl_.markedasunread_; + } + if (cached_has_bits & 0x40000000u) { + _this->_impl_.suspended_ = from._impl_.suspended_; + } + if (cached_has_bits & 0x80000000u) { + _this->_impl_.terminated_ = from._impl_.terminated_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + cached_has_bits = from._impl_._has_bits_[1]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + _this->_impl_.support_ = from._impl_.support_; + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.tctokensendertimestamp_ = from._impl_.tctokensendertimestamp_; + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.createdat_ = from._impl_.createdat_; + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.isparentgroup_ = from._impl_.isparentgroup_; + } + if (cached_has_bits & 0x00000010u) { + _this->_impl_.isdefaultsubgroup_ = from._impl_.isdefaultsubgroup_; + } + if (cached_has_bits & 0x00000020u) { + _this->_impl_.selfpnexposed_ = from._impl_.selfpnexposed_; + } + _this->_impl_._has_bits_[1] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Conversation::CopyFrom(const Conversation& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Conversation) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Conversation::IsInitialized() const { + if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false; + if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.messages_)) + return false; + if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.participant_)) + return false; + return true; +} + +void Conversation::InternalSwap(Conversation* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_._has_bits_[1], other->_impl_._has_bits_[1]); + _impl_.messages_.InternalSwap(&other->_impl_.messages_); + _impl_.participant_.InternalSwap(&other->_impl_.participant_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.id_, lhs_arena, + &other->_impl_.id_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.newjid_, lhs_arena, + &other->_impl_.newjid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.oldjid_, lhs_arena, + &other->_impl_.oldjid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.name_, lhs_arena, + &other->_impl_.name_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.phash_, lhs_arena, + &other->_impl_.phash_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.tctoken_, lhs_arena, + &other->_impl_.tctoken_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.contactprimaryidentitykey_, lhs_arena, + &other->_impl_.contactprimaryidentitykey_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.createdby_, lhs_arena, + &other->_impl_.createdby_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.description_, lhs_arena, + &other->_impl_.description_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.parentgroupid_, lhs_arena, + &other->_impl_.parentgroupid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.displayname_, lhs_arena, + &other->_impl_.displayname_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.pnjid_, lhs_arena, + &other->_impl_.pnjid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Conversation, _impl_.selfpnexposed_) + + sizeof(Conversation::_impl_.selfpnexposed_) + - PROTOBUF_FIELD_OFFSET(Conversation, _impl_.disappearingmode_)>( + reinterpret_cast(&_impl_.disappearingmode_), + reinterpret_cast(&other->_impl_.disappearingmode_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Conversation::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[25]); +} + +// =================================================================== + +class DeviceListMetadata::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_senderkeyhash(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_sendertimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_recipientkeyhash(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_recipienttimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +DeviceListMetadata::DeviceListMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.DeviceListMetadata) +} +DeviceListMetadata::DeviceListMetadata(const DeviceListMetadata& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + DeviceListMetadata* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.senderkeyindexes_){from._impl_.senderkeyindexes_} + , /*decltype(_impl_._senderkeyindexes_cached_byte_size_)*/{0} + , decltype(_impl_.recipientkeyindexes_){from._impl_.recipientkeyindexes_} + , /*decltype(_impl_._recipientkeyindexes_cached_byte_size_)*/{0} + , decltype(_impl_.senderkeyhash_){} + , decltype(_impl_.recipientkeyhash_){} + , decltype(_impl_.sendertimestamp_){} + , decltype(_impl_.recipienttimestamp_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.senderkeyhash_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.senderkeyhash_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_senderkeyhash()) { + _this->_impl_.senderkeyhash_.Set(from._internal_senderkeyhash(), + _this->GetArenaForAllocation()); + } + _impl_.recipientkeyhash_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.recipientkeyhash_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_recipientkeyhash()) { + _this->_impl_.recipientkeyhash_.Set(from._internal_recipientkeyhash(), + _this->GetArenaForAllocation()); + } + ::memcpy(&_impl_.sendertimestamp_, &from._impl_.sendertimestamp_, + static_cast(reinterpret_cast(&_impl_.recipienttimestamp_) - + reinterpret_cast(&_impl_.sendertimestamp_)) + sizeof(_impl_.recipienttimestamp_)); + // @@protoc_insertion_point(copy_constructor:proto.DeviceListMetadata) +} + +inline void DeviceListMetadata::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.senderkeyindexes_){arena} + , /*decltype(_impl_._senderkeyindexes_cached_byte_size_)*/{0} + , decltype(_impl_.recipientkeyindexes_){arena} + , /*decltype(_impl_._recipientkeyindexes_cached_byte_size_)*/{0} + , decltype(_impl_.senderkeyhash_){} + , decltype(_impl_.recipientkeyhash_){} + , decltype(_impl_.sendertimestamp_){uint64_t{0u}} + , decltype(_impl_.recipienttimestamp_){uint64_t{0u}} + }; + _impl_.senderkeyhash_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.senderkeyhash_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.recipientkeyhash_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.recipientkeyhash_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +DeviceListMetadata::~DeviceListMetadata() { + // @@protoc_insertion_point(destructor:proto.DeviceListMetadata) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void DeviceListMetadata::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.senderkeyindexes_.~RepeatedField(); + _impl_.recipientkeyindexes_.~RepeatedField(); + _impl_.senderkeyhash_.Destroy(); + _impl_.recipientkeyhash_.Destroy(); +} + +void DeviceListMetadata::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void DeviceListMetadata::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.DeviceListMetadata) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.senderkeyindexes_.Clear(); + _impl_.recipientkeyindexes_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.senderkeyhash_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.recipientkeyhash_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x0000000cu) { + ::memset(&_impl_.sendertimestamp_, 0, static_cast( + reinterpret_cast(&_impl_.recipienttimestamp_) - + reinterpret_cast(&_impl_.sendertimestamp_)) + sizeof(_impl_.recipienttimestamp_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* DeviceListMetadata::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes senderKeyHash = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_senderkeyhash(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint64 senderTimestamp = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_sendertimestamp(&has_bits); + _impl_.sendertimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated uint32 senderKeyIndexes = 3 [packed = true]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_senderkeyindexes(), ptr, ctx); + CHK_(ptr); + } else if (static_cast(tag) == 24) { + _internal_add_senderkeyindexes(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes recipientKeyHash = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + auto str = _internal_mutable_recipientkeyhash(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint64 recipientTimestamp = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { + _Internal::set_has_recipienttimestamp(&has_bits); + _impl_.recipienttimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated uint32 recipientKeyIndexes = 10 [packed = true]; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_recipientkeyindexes(), ptr, ctx); + CHK_(ptr); + } else if (static_cast(tag) == 80) { + _internal_add_recipientkeyindexes(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* DeviceListMetadata::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.DeviceListMetadata) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes senderKeyHash = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_senderkeyhash(), target); + } + + // optional uint64 senderTimestamp = 2; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_sendertimestamp(), target); + } + + // repeated uint32 senderKeyIndexes = 3 [packed = true]; + { + int byte_size = _impl_._senderkeyindexes_cached_byte_size_.load(std::memory_order_relaxed); + if (byte_size > 0) { + target = stream->WriteUInt32Packed( + 3, _internal_senderkeyindexes(), byte_size, target); + } + } + + // optional bytes recipientKeyHash = 8; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 8, this->_internal_recipientkeyhash(), target); + } + + // optional uint64 recipientTimestamp = 9; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(9, this->_internal_recipienttimestamp(), target); + } + + // repeated uint32 recipientKeyIndexes = 10 [packed = true]; + { + int byte_size = _impl_._recipientkeyindexes_cached_byte_size_.load(std::memory_order_relaxed); + if (byte_size > 0) { + target = stream->WriteUInt32Packed( + 10, _internal_recipientkeyindexes(), byte_size, target); + } + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.DeviceListMetadata) + return target; +} + +size_t DeviceListMetadata::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.DeviceListMetadata) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated uint32 senderKeyIndexes = 3 [packed = true]; + { + size_t data_size = ::_pbi::WireFormatLite:: + UInt32Size(this->_impl_.senderkeyindexes_); + if (data_size > 0) { + total_size += 1 + + ::_pbi::WireFormatLite::Int32Size(static_cast(data_size)); + } + int cached_size = ::_pbi::ToCachedSize(data_size); + _impl_._senderkeyindexes_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated uint32 recipientKeyIndexes = 10 [packed = true]; + { + size_t data_size = ::_pbi::WireFormatLite:: + UInt32Size(this->_impl_.recipientkeyindexes_); + if (data_size > 0) { + total_size += 1 + + ::_pbi::WireFormatLite::Int32Size(static_cast(data_size)); + } + int cached_size = ::_pbi::ToCachedSize(data_size); + _impl_._recipientkeyindexes_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional bytes senderKeyHash = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_senderkeyhash()); + } + + // optional bytes recipientKeyHash = 8; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_recipientkeyhash()); + } + + // optional uint64 senderTimestamp = 2; + if (cached_has_bits & 0x00000004u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_sendertimestamp()); + } + + // optional uint64 recipientTimestamp = 9; + if (cached_has_bits & 0x00000008u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_recipienttimestamp()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DeviceListMetadata::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + DeviceListMetadata::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DeviceListMetadata::GetClassData() const { return &_class_data_; } + + +void DeviceListMetadata::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.DeviceListMetadata) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.senderkeyindexes_.MergeFrom(from._impl_.senderkeyindexes_); + _this->_impl_.recipientkeyindexes_.MergeFrom(from._impl_.recipientkeyindexes_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_senderkeyhash(from._internal_senderkeyhash()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_recipientkeyhash(from._internal_recipientkeyhash()); + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.sendertimestamp_ = from._impl_.sendertimestamp_; + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.recipienttimestamp_ = from._impl_.recipienttimestamp_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void DeviceListMetadata::CopyFrom(const DeviceListMetadata& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.DeviceListMetadata) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DeviceListMetadata::IsInitialized() const { + return true; +} + +void DeviceListMetadata::InternalSwap(DeviceListMetadata* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.senderkeyindexes_.InternalSwap(&other->_impl_.senderkeyindexes_); + _impl_.recipientkeyindexes_.InternalSwap(&other->_impl_.recipientkeyindexes_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.senderkeyhash_, lhs_arena, + &other->_impl_.senderkeyhash_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.recipientkeyhash_, lhs_arena, + &other->_impl_.recipientkeyhash_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(DeviceListMetadata, _impl_.recipienttimestamp_) + + sizeof(DeviceListMetadata::_impl_.recipienttimestamp_) + - PROTOBUF_FIELD_OFFSET(DeviceListMetadata, _impl_.sendertimestamp_)>( + reinterpret_cast(&_impl_.sendertimestamp_), + reinterpret_cast(&other->_impl_.sendertimestamp_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata DeviceListMetadata::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[26]); +} + +// =================================================================== + +class DeviceProps_AppVersion::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_primary(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_secondary(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_tertiary(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_quaternary(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_quinary(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } +}; + +DeviceProps_AppVersion::DeviceProps_AppVersion(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.DeviceProps.AppVersion) +} +DeviceProps_AppVersion::DeviceProps_AppVersion(const DeviceProps_AppVersion& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + DeviceProps_AppVersion* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.primary_){} + , decltype(_impl_.secondary_){} + , decltype(_impl_.tertiary_){} + , decltype(_impl_.quaternary_){} + , decltype(_impl_.quinary_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&_impl_.primary_, &from._impl_.primary_, + static_cast(reinterpret_cast(&_impl_.quinary_) - + reinterpret_cast(&_impl_.primary_)) + sizeof(_impl_.quinary_)); + // @@protoc_insertion_point(copy_constructor:proto.DeviceProps.AppVersion) +} + +inline void DeviceProps_AppVersion::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.primary_){0u} + , decltype(_impl_.secondary_){0u} + , decltype(_impl_.tertiary_){0u} + , decltype(_impl_.quaternary_){0u} + , decltype(_impl_.quinary_){0u} + }; +} + +DeviceProps_AppVersion::~DeviceProps_AppVersion() { + // @@protoc_insertion_point(destructor:proto.DeviceProps.AppVersion) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void DeviceProps_AppVersion::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void DeviceProps_AppVersion::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void DeviceProps_AppVersion::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.DeviceProps.AppVersion) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + ::memset(&_impl_.primary_, 0, static_cast( + reinterpret_cast(&_impl_.quinary_) - + reinterpret_cast(&_impl_.primary_)) + sizeof(_impl_.quinary_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* DeviceProps_AppVersion::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint32 primary = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_primary(&has_bits); + _impl_.primary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 secondary = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_secondary(&has_bits); + _impl_.secondary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 tertiary = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_tertiary(&has_bits); + _impl_.tertiary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 quaternary = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_quaternary(&has_bits); + _impl_.quaternary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 quinary = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_quinary(&has_bits); + _impl_.quinary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* DeviceProps_AppVersion::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.DeviceProps.AppVersion) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional uint32 primary = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_primary(), target); + } + + // optional uint32 secondary = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_secondary(), target); + } + + // optional uint32 tertiary = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_tertiary(), target); + } + + // optional uint32 quaternary = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_quaternary(), target); + } + + // optional uint32 quinary = 5; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_quinary(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.DeviceProps.AppVersion) + return target; +} + +size_t DeviceProps_AppVersion::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.DeviceProps.AppVersion) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + // optional uint32 primary = 1; + if (cached_has_bits & 0x00000001u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_primary()); + } + + // optional uint32 secondary = 2; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_secondary()); + } + + // optional uint32 tertiary = 3; + if (cached_has_bits & 0x00000004u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_tertiary()); + } + + // optional uint32 quaternary = 4; + if (cached_has_bits & 0x00000008u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_quaternary()); + } + + // optional uint32 quinary = 5; + if (cached_has_bits & 0x00000010u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_quinary()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DeviceProps_AppVersion::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + DeviceProps_AppVersion::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DeviceProps_AppVersion::GetClassData() const { return &_class_data_; } + + +void DeviceProps_AppVersion::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.DeviceProps.AppVersion) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _this->_impl_.primary_ = from._impl_.primary_; + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.secondary_ = from._impl_.secondary_; + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.tertiary_ = from._impl_.tertiary_; + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.quaternary_ = from._impl_.quaternary_; + } + if (cached_has_bits & 0x00000010u) { + _this->_impl_.quinary_ = from._impl_.quinary_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void DeviceProps_AppVersion::CopyFrom(const DeviceProps_AppVersion& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.DeviceProps.AppVersion) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DeviceProps_AppVersion::IsInitialized() const { + return true; +} + +void DeviceProps_AppVersion::InternalSwap(DeviceProps_AppVersion* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(DeviceProps_AppVersion, _impl_.quinary_) + + sizeof(DeviceProps_AppVersion::_impl_.quinary_) + - PROTOBUF_FIELD_OFFSET(DeviceProps_AppVersion, _impl_.primary_)>( + reinterpret_cast(&_impl_.primary_), + reinterpret_cast(&other->_impl_.primary_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata DeviceProps_AppVersion::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[27]); +} + +// =================================================================== + +class DeviceProps::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_os(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::proto::DeviceProps_AppVersion& version(const DeviceProps* msg); + static void set_has_version(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_platformtype(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_requirefullsync(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +const ::proto::DeviceProps_AppVersion& +DeviceProps::_Internal::version(const DeviceProps* msg) { + return *msg->_impl_.version_; +} +DeviceProps::DeviceProps(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.DeviceProps) +} +DeviceProps::DeviceProps(const DeviceProps& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + DeviceProps* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.os_){} + , decltype(_impl_.version_){nullptr} + , decltype(_impl_.platformtype_){} + , decltype(_impl_.requirefullsync_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.os_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.os_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_os()) { + _this->_impl_.os_.Set(from._internal_os(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_version()) { + _this->_impl_.version_ = new ::proto::DeviceProps_AppVersion(*from._impl_.version_); + } + ::memcpy(&_impl_.platformtype_, &from._impl_.platformtype_, + static_cast(reinterpret_cast(&_impl_.requirefullsync_) - + reinterpret_cast(&_impl_.platformtype_)) + sizeof(_impl_.requirefullsync_)); + // @@protoc_insertion_point(copy_constructor:proto.DeviceProps) +} + +inline void DeviceProps::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.os_){} + , decltype(_impl_.version_){nullptr} + , decltype(_impl_.platformtype_){0} + , decltype(_impl_.requirefullsync_){false} + }; + _impl_.os_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.os_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +DeviceProps::~DeviceProps() { + // @@protoc_insertion_point(destructor:proto.DeviceProps) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void DeviceProps::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.os_.Destroy(); + if (this != internal_default_instance()) delete _impl_.version_; +} + +void DeviceProps::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void DeviceProps::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.DeviceProps) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.os_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.version_ != nullptr); + _impl_.version_->Clear(); + } + } + if (cached_has_bits & 0x0000000cu) { + ::memset(&_impl_.platformtype_, 0, static_cast( + reinterpret_cast(&_impl_.requirefullsync_) - + reinterpret_cast(&_impl_.platformtype_)) + sizeof(_impl_.requirefullsync_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* DeviceProps::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string os = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_os(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.DeviceProps.os"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.DeviceProps.AppVersion version = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_version(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.DeviceProps.PlatformType platformType = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::DeviceProps_PlatformType_IsValid(val))) { + _internal_set_platformtype(static_cast<::proto::DeviceProps_PlatformType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional bool requireFullSync = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_requirefullsync(&has_bits); + _impl_.requirefullsync_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* DeviceProps::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.DeviceProps) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string os = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_os().data(), static_cast(this->_internal_os().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.DeviceProps.os"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_os(), target); + } + + // optional .proto.DeviceProps.AppVersion version = 2; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::version(this), + _Internal::version(this).GetCachedSize(), target, stream); + } + + // optional .proto.DeviceProps.PlatformType platformType = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 3, this->_internal_platformtype(), target); + } + + // optional bool requireFullSync = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(4, this->_internal_requirefullsync(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.DeviceProps) + return target; +} + +size_t DeviceProps::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.DeviceProps) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional string os = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_os()); + } + + // optional .proto.DeviceProps.AppVersion version = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.version_); + } + + // optional .proto.DeviceProps.PlatformType platformType = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_platformtype()); + } + + // optional bool requireFullSync = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 1; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DeviceProps::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + DeviceProps::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DeviceProps::GetClassData() const { return &_class_data_; } + + +void DeviceProps::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.DeviceProps) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_os(from._internal_os()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_version()->::proto::DeviceProps_AppVersion::MergeFrom( + from._internal_version()); + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.platformtype_ = from._impl_.platformtype_; + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.requirefullsync_ = from._impl_.requirefullsync_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void DeviceProps::CopyFrom(const DeviceProps& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.DeviceProps) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DeviceProps::IsInitialized() const { + return true; +} + +void DeviceProps::InternalSwap(DeviceProps* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.os_, lhs_arena, + &other->_impl_.os_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(DeviceProps, _impl_.requirefullsync_) + + sizeof(DeviceProps::_impl_.requirefullsync_) + - PROTOBUF_FIELD_OFFSET(DeviceProps, _impl_.version_)>( + reinterpret_cast(&_impl_.version_), + reinterpret_cast(&other->_impl_.version_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata DeviceProps::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[28]); +} + +// =================================================================== + +class DisappearingMode::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_initiator(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +DisappearingMode::DisappearingMode(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.DisappearingMode) +} +DisappearingMode::DisappearingMode(const DisappearingMode& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + DisappearingMode* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.initiator_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _this->_impl_.initiator_ = from._impl_.initiator_; + // @@protoc_insertion_point(copy_constructor:proto.DisappearingMode) +} + +inline void DisappearingMode::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.initiator_){0} + }; +} + +DisappearingMode::~DisappearingMode() { + // @@protoc_insertion_point(destructor:proto.DisappearingMode) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void DisappearingMode::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void DisappearingMode::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void DisappearingMode::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.DisappearingMode) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.initiator_ = 0; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* DisappearingMode::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.DisappearingMode.Initiator initiator = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::DisappearingMode_Initiator_IsValid(val))) { + _internal_set_initiator(static_cast<::proto::DisappearingMode_Initiator>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* DisappearingMode::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.DisappearingMode) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.DisappearingMode.Initiator initiator = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this->_internal_initiator(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.DisappearingMode) + return target; +} + +size_t DisappearingMode::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.DisappearingMode) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional .proto.DisappearingMode.Initiator initiator = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_initiator()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DisappearingMode::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + DisappearingMode::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DisappearingMode::GetClassData() const { return &_class_data_; } + + +void DisappearingMode::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.DisappearingMode) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_initiator()) { + _this->_internal_set_initiator(from._internal_initiator()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void DisappearingMode::CopyFrom(const DisappearingMode& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.DisappearingMode) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DisappearingMode::IsInitialized() const { + return true; +} + +void DisappearingMode::InternalSwap(DisappearingMode* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_.initiator_, other->_impl_.initiator_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata DisappearingMode::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[29]); +} + +// =================================================================== + +class EphemeralSetting::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_duration(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_timestamp(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +EphemeralSetting::EphemeralSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.EphemeralSetting) +} +EphemeralSetting::EphemeralSetting(const EphemeralSetting& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + EphemeralSetting* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.timestamp_){} + , decltype(_impl_.duration_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&_impl_.timestamp_, &from._impl_.timestamp_, + static_cast(reinterpret_cast(&_impl_.duration_) - + reinterpret_cast(&_impl_.timestamp_)) + sizeof(_impl_.duration_)); + // @@protoc_insertion_point(copy_constructor:proto.EphemeralSetting) +} + +inline void EphemeralSetting::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.timestamp_){int64_t{0}} + , decltype(_impl_.duration_){0} + }; +} + +EphemeralSetting::~EphemeralSetting() { + // @@protoc_insertion_point(destructor:proto.EphemeralSetting) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void EphemeralSetting::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void EphemeralSetting::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void EphemeralSetting::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.EphemeralSetting) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + ::memset(&_impl_.timestamp_, 0, static_cast( + reinterpret_cast(&_impl_.duration_) - + reinterpret_cast(&_impl_.timestamp_)) + sizeof(_impl_.duration_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* EphemeralSetting::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional sfixed32 duration = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 13)) { + _Internal::set_has_duration(&has_bits); + _impl_.duration_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(int32_t); + } else + goto handle_unusual; + continue; + // optional sfixed64 timestamp = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 17)) { + _Internal::set_has_timestamp(&has_bits); + _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(int64_t); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* EphemeralSetting::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.EphemeralSetting) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional sfixed32 duration = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSFixed32ToArray(1, this->_internal_duration(), target); + } + + // optional sfixed64 timestamp = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSFixed64ToArray(2, this->_internal_timestamp(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.EphemeralSetting) + return target; +} + +size_t EphemeralSetting::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.EphemeralSetting) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional sfixed64 timestamp = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 8; + } + + // optional sfixed32 duration = 1; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 4; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData EphemeralSetting::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + EphemeralSetting::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*EphemeralSetting::GetClassData() const { return &_class_data_; } + + +void EphemeralSetting::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.EphemeralSetting) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_impl_.timestamp_ = from._impl_.timestamp_; + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.duration_ = from._impl_.duration_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void EphemeralSetting::CopyFrom(const EphemeralSetting& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.EphemeralSetting) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool EphemeralSetting::IsInitialized() const { + return true; +} + +void EphemeralSetting::InternalSwap(EphemeralSetting* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(EphemeralSetting, _impl_.duration_) + + sizeof(EphemeralSetting::_impl_.duration_) + - PROTOBUF_FIELD_OFFSET(EphemeralSetting, _impl_.timestamp_)>( + reinterpret_cast(&_impl_.timestamp_), + reinterpret_cast(&other->_impl_.timestamp_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata EphemeralSetting::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[30]); +} + +// =================================================================== + +class ExitCode::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_code(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_text(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +ExitCode::ExitCode(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.ExitCode) +} +ExitCode::ExitCode(const ExitCode& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + ExitCode* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.text_){} + , decltype(_impl_.code_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.text_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.text_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_text()) { + _this->_impl_.text_.Set(from._internal_text(), + _this->GetArenaForAllocation()); + } + _this->_impl_.code_ = from._impl_.code_; + // @@protoc_insertion_point(copy_constructor:proto.ExitCode) +} + +inline void ExitCode::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.text_){} + , decltype(_impl_.code_){uint64_t{0u}} + }; + _impl_.text_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.text_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +ExitCode::~ExitCode() { + // @@protoc_insertion_point(destructor:proto.ExitCode) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ExitCode::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.text_.Destroy(); +} + +void ExitCode::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ExitCode::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.ExitCode) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.text_.ClearNonDefaultToEmpty(); + } + _impl_.code_ = uint64_t{0u}; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ExitCode::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint64 code = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_code(&has_bits); + _impl_.code_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string text = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_text(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ExitCode.text"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ExitCode::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.ExitCode) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional uint64 code = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_code(), target); + } + + // optional string text = 2; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_text().data(), static_cast(this->_internal_text().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ExitCode.text"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_text(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.ExitCode) + return target; +} + +size_t ExitCode::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.ExitCode) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional string text = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_text()); + } + + // optional uint64 code = 1; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_code()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ExitCode::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + ExitCode::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ExitCode::GetClassData() const { return &_class_data_; } + + +void ExitCode::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.ExitCode) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_text(from._internal_text()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.code_ = from._impl_.code_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ExitCode::CopyFrom(const ExitCode& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.ExitCode) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ExitCode::IsInitialized() const { + return true; +} + +void ExitCode::InternalSwap(ExitCode* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.text_, lhs_arena, + &other->_impl_.text_, rhs_arena + ); + swap(_impl_.code_, other->_impl_.code_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ExitCode::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[31]); +} + +// =================================================================== + +class ExternalBlobReference::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_mediakey(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_directpath(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_handle(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_filesizebytes(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_filesha256(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_fileencsha256(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } +}; + +ExternalBlobReference::ExternalBlobReference(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.ExternalBlobReference) +} +ExternalBlobReference::ExternalBlobReference(const ExternalBlobReference& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + ExternalBlobReference* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.mediakey_){} + , decltype(_impl_.directpath_){} + , decltype(_impl_.handle_){} + , decltype(_impl_.filesha256_){} + , decltype(_impl_.fileencsha256_){} + , decltype(_impl_.filesizebytes_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.mediakey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediakey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_mediakey()) { + _this->_impl_.mediakey_.Set(from._internal_mediakey(), + _this->GetArenaForAllocation()); + } + _impl_.directpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_directpath()) { + _this->_impl_.directpath_.Set(from._internal_directpath(), + _this->GetArenaForAllocation()); + } + _impl_.handle_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.handle_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_handle()) { + _this->_impl_.handle_.Set(from._internal_handle(), + _this->GetArenaForAllocation()); + } + _impl_.filesha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filesha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_filesha256()) { + _this->_impl_.filesha256_.Set(from._internal_filesha256(), + _this->GetArenaForAllocation()); + } + _impl_.fileencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_fileencsha256()) { + _this->_impl_.fileencsha256_.Set(from._internal_fileencsha256(), + _this->GetArenaForAllocation()); + } + _this->_impl_.filesizebytes_ = from._impl_.filesizebytes_; + // @@protoc_insertion_point(copy_constructor:proto.ExternalBlobReference) +} + +inline void ExternalBlobReference::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.mediakey_){} + , decltype(_impl_.directpath_){} + , decltype(_impl_.handle_){} + , decltype(_impl_.filesha256_){} + , decltype(_impl_.fileencsha256_){} + , decltype(_impl_.filesizebytes_){uint64_t{0u}} + }; + _impl_.mediakey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediakey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.handle_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.handle_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filesha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filesha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fileencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +ExternalBlobReference::~ExternalBlobReference() { + // @@protoc_insertion_point(destructor:proto.ExternalBlobReference) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ExternalBlobReference::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.mediakey_.Destroy(); + _impl_.directpath_.Destroy(); + _impl_.handle_.Destroy(); + _impl_.filesha256_.Destroy(); + _impl_.fileencsha256_.Destroy(); +} + +void ExternalBlobReference::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ExternalBlobReference::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.ExternalBlobReference) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _impl_.mediakey_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.directpath_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.handle_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + _impl_.filesha256_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + _impl_.fileencsha256_.ClearNonDefaultToEmpty(); + } + } + _impl_.filesizebytes_ = uint64_t{0u}; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ExternalBlobReference::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes mediaKey = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_mediakey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string directPath = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_directpath(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ExternalBlobReference.directPath"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string handle = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_handle(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ExternalBlobReference.handle"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional uint64 fileSizeBytes = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_filesizebytes(&has_bits); + _impl_.filesizebytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes fileSha256 = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + auto str = _internal_mutable_filesha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes fileEncSha256 = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + auto str = _internal_mutable_fileencsha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ExternalBlobReference::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.ExternalBlobReference) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes mediaKey = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_mediakey(), target); + } + + // optional string directPath = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_directpath().data(), static_cast(this->_internal_directpath().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ExternalBlobReference.directPath"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_directpath(), target); + } + + // optional string handle = 3; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_handle().data(), static_cast(this->_internal_handle().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ExternalBlobReference.handle"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_handle(), target); + } + + // optional uint64 fileSizeBytes = 4; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_filesizebytes(), target); + } + + // optional bytes fileSha256 = 5; + if (cached_has_bits & 0x00000008u) { + target = stream->WriteBytesMaybeAliased( + 5, this->_internal_filesha256(), target); + } + + // optional bytes fileEncSha256 = 6; + if (cached_has_bits & 0x00000010u) { + target = stream->WriteBytesMaybeAliased( + 6, this->_internal_fileencsha256(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.ExternalBlobReference) + return target; +} + +size_t ExternalBlobReference::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.ExternalBlobReference) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + // optional bytes mediaKey = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_mediakey()); + } + + // optional string directPath = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_directpath()); + } + + // optional string handle = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_handle()); + } + + // optional bytes fileSha256 = 5; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_filesha256()); + } + + // optional bytes fileEncSha256 = 6; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_fileencsha256()); + } + + // optional uint64 fileSizeBytes = 4; + if (cached_has_bits & 0x00000020u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_filesizebytes()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ExternalBlobReference::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + ExternalBlobReference::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ExternalBlobReference::GetClassData() const { return &_class_data_; } + + +void ExternalBlobReference::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.ExternalBlobReference) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_mediakey(from._internal_mediakey()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_directpath(from._internal_directpath()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_handle(from._internal_handle()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_set_filesha256(from._internal_filesha256()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_set_fileencsha256(from._internal_fileencsha256()); + } + if (cached_has_bits & 0x00000020u) { + _this->_impl_.filesizebytes_ = from._impl_.filesizebytes_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ExternalBlobReference::CopyFrom(const ExternalBlobReference& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.ExternalBlobReference) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ExternalBlobReference::IsInitialized() const { + return true; +} + +void ExternalBlobReference::InternalSwap(ExternalBlobReference* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.mediakey_, lhs_arena, + &other->_impl_.mediakey_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.directpath_, lhs_arena, + &other->_impl_.directpath_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.handle_, lhs_arena, + &other->_impl_.handle_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.filesha256_, lhs_arena, + &other->_impl_.filesha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.fileencsha256_, lhs_arena, + &other->_impl_.fileencsha256_, rhs_arena + ); + swap(_impl_.filesizebytes_, other->_impl_.filesizebytes_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ExternalBlobReference::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[32]); +} + +// =================================================================== + +class GlobalSettings::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::WallpaperSettings& lightthemewallpaper(const GlobalSettings* msg); + static void set_has_lightthemewallpaper(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_mediavisibility(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static const ::proto::WallpaperSettings& darkthemewallpaper(const GlobalSettings* msg); + static void set_has_darkthemewallpaper(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::proto::AutoDownloadSettings& autodownloadwifi(const GlobalSettings* msg); + static void set_has_autodownloadwifi(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static const ::proto::AutoDownloadSettings& autodownloadcellular(const GlobalSettings* msg); + static void set_has_autodownloadcellular(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static const ::proto::AutoDownloadSettings& autodownloadroaming(const GlobalSettings* msg); + static void set_has_autodownloadroaming(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_showindividualnotificationspreview(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_showgroupnotificationspreview(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_disappearingmodeduration(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_disappearingmodetimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } +}; + +const ::proto::WallpaperSettings& +GlobalSettings::_Internal::lightthemewallpaper(const GlobalSettings* msg) { + return *msg->_impl_.lightthemewallpaper_; +} +const ::proto::WallpaperSettings& +GlobalSettings::_Internal::darkthemewallpaper(const GlobalSettings* msg) { + return *msg->_impl_.darkthemewallpaper_; +} +const ::proto::AutoDownloadSettings& +GlobalSettings::_Internal::autodownloadwifi(const GlobalSettings* msg) { + return *msg->_impl_.autodownloadwifi_; +} +const ::proto::AutoDownloadSettings& +GlobalSettings::_Internal::autodownloadcellular(const GlobalSettings* msg) { + return *msg->_impl_.autodownloadcellular_; +} +const ::proto::AutoDownloadSettings& +GlobalSettings::_Internal::autodownloadroaming(const GlobalSettings* msg) { + return *msg->_impl_.autodownloadroaming_; +} +GlobalSettings::GlobalSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.GlobalSettings) +} +GlobalSettings::GlobalSettings(const GlobalSettings& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + GlobalSettings* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.lightthemewallpaper_){nullptr} + , decltype(_impl_.darkthemewallpaper_){nullptr} + , decltype(_impl_.autodownloadwifi_){nullptr} + , decltype(_impl_.autodownloadcellular_){nullptr} + , decltype(_impl_.autodownloadroaming_){nullptr} + , decltype(_impl_.mediavisibility_){} + , decltype(_impl_.showindividualnotificationspreview_){} + , decltype(_impl_.showgroupnotificationspreview_){} + , decltype(_impl_.disappearingmodetimestamp_){} + , decltype(_impl_.disappearingmodeduration_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_lightthemewallpaper()) { + _this->_impl_.lightthemewallpaper_ = new ::proto::WallpaperSettings(*from._impl_.lightthemewallpaper_); + } + if (from._internal_has_darkthemewallpaper()) { + _this->_impl_.darkthemewallpaper_ = new ::proto::WallpaperSettings(*from._impl_.darkthemewallpaper_); + } + if (from._internal_has_autodownloadwifi()) { + _this->_impl_.autodownloadwifi_ = new ::proto::AutoDownloadSettings(*from._impl_.autodownloadwifi_); + } + if (from._internal_has_autodownloadcellular()) { + _this->_impl_.autodownloadcellular_ = new ::proto::AutoDownloadSettings(*from._impl_.autodownloadcellular_); + } + if (from._internal_has_autodownloadroaming()) { + _this->_impl_.autodownloadroaming_ = new ::proto::AutoDownloadSettings(*from._impl_.autodownloadroaming_); + } + ::memcpy(&_impl_.mediavisibility_, &from._impl_.mediavisibility_, + static_cast(reinterpret_cast(&_impl_.disappearingmodeduration_) - + reinterpret_cast(&_impl_.mediavisibility_)) + sizeof(_impl_.disappearingmodeduration_)); + // @@protoc_insertion_point(copy_constructor:proto.GlobalSettings) +} + +inline void GlobalSettings::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.lightthemewallpaper_){nullptr} + , decltype(_impl_.darkthemewallpaper_){nullptr} + , decltype(_impl_.autodownloadwifi_){nullptr} + , decltype(_impl_.autodownloadcellular_){nullptr} + , decltype(_impl_.autodownloadroaming_){nullptr} + , decltype(_impl_.mediavisibility_){0} + , decltype(_impl_.showindividualnotificationspreview_){false} + , decltype(_impl_.showgroupnotificationspreview_){false} + , decltype(_impl_.disappearingmodetimestamp_){int64_t{0}} + , decltype(_impl_.disappearingmodeduration_){0} + }; +} + +GlobalSettings::~GlobalSettings() { + // @@protoc_insertion_point(destructor:proto.GlobalSettings) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void GlobalSettings::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.lightthemewallpaper_; + if (this != internal_default_instance()) delete _impl_.darkthemewallpaper_; + if (this != internal_default_instance()) delete _impl_.autodownloadwifi_; + if (this != internal_default_instance()) delete _impl_.autodownloadcellular_; + if (this != internal_default_instance()) delete _impl_.autodownloadroaming_; +} + +void GlobalSettings::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void GlobalSettings::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.GlobalSettings) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.lightthemewallpaper_ != nullptr); + _impl_.lightthemewallpaper_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.darkthemewallpaper_ != nullptr); + _impl_.darkthemewallpaper_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.autodownloadwifi_ != nullptr); + _impl_.autodownloadwifi_->Clear(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(_impl_.autodownloadcellular_ != nullptr); + _impl_.autodownloadcellular_->Clear(); + } + if (cached_has_bits & 0x00000010u) { + GOOGLE_DCHECK(_impl_.autodownloadroaming_ != nullptr); + _impl_.autodownloadroaming_->Clear(); + } + } + if (cached_has_bits & 0x000000e0u) { + ::memset(&_impl_.mediavisibility_, 0, static_cast( + reinterpret_cast(&_impl_.showgroupnotificationspreview_) - + reinterpret_cast(&_impl_.mediavisibility_)) + sizeof(_impl_.showgroupnotificationspreview_)); + } + if (cached_has_bits & 0x00000300u) { + ::memset(&_impl_.disappearingmodetimestamp_, 0, static_cast( + reinterpret_cast(&_impl_.disappearingmodeduration_) - + reinterpret_cast(&_impl_.disappearingmodetimestamp_)) + sizeof(_impl_.disappearingmodeduration_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* GlobalSettings::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.WallpaperSettings lightThemeWallpaper = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_lightthemewallpaper(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.MediaVisibility mediaVisibility = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::MediaVisibility_IsValid(val))) { + _internal_set_mediavisibility(static_cast<::proto::MediaVisibility>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WallpaperSettings darkThemeWallpaper = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_darkthemewallpaper(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.AutoDownloadSettings autoDownloadWiFi = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_autodownloadwifi(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.AutoDownloadSettings autoDownloadCellular = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_autodownloadcellular(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.AutoDownloadSettings autoDownloadRoaming = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_autodownloadroaming(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool showIndividualNotificationsPreview = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + _Internal::set_has_showindividualnotificationspreview(&has_bits); + _impl_.showindividualnotificationspreview_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool showGroupNotificationsPreview = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { + _Internal::set_has_showgroupnotificationspreview(&has_bits); + _impl_.showgroupnotificationspreview_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 disappearingModeDuration = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { + _Internal::set_has_disappearingmodeduration(&has_bits); + _impl_.disappearingmodeduration_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 disappearingModeTimestamp = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { + _Internal::set_has_disappearingmodetimestamp(&has_bits); + _impl_.disappearingmodetimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* GlobalSettings::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.GlobalSettings) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.WallpaperSettings lightThemeWallpaper = 1; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::lightthemewallpaper(this), + _Internal::lightthemewallpaper(this).GetCachedSize(), target, stream); + } + + // optional .proto.MediaVisibility mediaVisibility = 2; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this->_internal_mediavisibility(), target); + } + + // optional .proto.WallpaperSettings darkThemeWallpaper = 3; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::darkthemewallpaper(this), + _Internal::darkthemewallpaper(this).GetCachedSize(), target, stream); + } + + // optional .proto.AutoDownloadSettings autoDownloadWiFi = 4; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, _Internal::autodownloadwifi(this), + _Internal::autodownloadwifi(this).GetCachedSize(), target, stream); + } + + // optional .proto.AutoDownloadSettings autoDownloadCellular = 5; + if (cached_has_bits & 0x00000008u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(5, _Internal::autodownloadcellular(this), + _Internal::autodownloadcellular(this).GetCachedSize(), target, stream); + } + + // optional .proto.AutoDownloadSettings autoDownloadRoaming = 6; + if (cached_has_bits & 0x00000010u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(6, _Internal::autodownloadroaming(this), + _Internal::autodownloadroaming(this).GetCachedSize(), target, stream); + } + + // optional bool showIndividualNotificationsPreview = 7; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(7, this->_internal_showindividualnotificationspreview(), target); + } + + // optional bool showGroupNotificationsPreview = 8; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(8, this->_internal_showgroupnotificationspreview(), target); + } + + // optional int32 disappearingModeDuration = 9; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(9, this->_internal_disappearingmodeduration(), target); + } + + // optional int64 disappearingModeTimestamp = 10; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(10, this->_internal_disappearingmodetimestamp(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.GlobalSettings) + return target; +} + +size_t GlobalSettings::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.GlobalSettings) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional .proto.WallpaperSettings lightThemeWallpaper = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.lightthemewallpaper_); + } + + // optional .proto.WallpaperSettings darkThemeWallpaper = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.darkthemewallpaper_); + } + + // optional .proto.AutoDownloadSettings autoDownloadWiFi = 4; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.autodownloadwifi_); + } + + // optional .proto.AutoDownloadSettings autoDownloadCellular = 5; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.autodownloadcellular_); + } + + // optional .proto.AutoDownloadSettings autoDownloadRoaming = 6; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.autodownloadroaming_); + } + + // optional .proto.MediaVisibility mediaVisibility = 2; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_mediavisibility()); + } + + // optional bool showIndividualNotificationsPreview = 7; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + 1; + } + + // optional bool showGroupNotificationsPreview = 8; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + 1; + } + + } + if (cached_has_bits & 0x00000300u) { + // optional int64 disappearingModeTimestamp = 10; + if (cached_has_bits & 0x00000100u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_disappearingmodetimestamp()); + } + + // optional int32 disappearingModeDuration = 9; + if (cached_has_bits & 0x00000200u) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_disappearingmodeduration()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData GlobalSettings::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + GlobalSettings::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GlobalSettings::GetClassData() const { return &_class_data_; } + + +void GlobalSettings::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.GlobalSettings) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_lightthemewallpaper()->::proto::WallpaperSettings::MergeFrom( + from._internal_lightthemewallpaper()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_darkthemewallpaper()->::proto::WallpaperSettings::MergeFrom( + from._internal_darkthemewallpaper()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_autodownloadwifi()->::proto::AutoDownloadSettings::MergeFrom( + from._internal_autodownloadwifi()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_mutable_autodownloadcellular()->::proto::AutoDownloadSettings::MergeFrom( + from._internal_autodownloadcellular()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_mutable_autodownloadroaming()->::proto::AutoDownloadSettings::MergeFrom( + from._internal_autodownloadroaming()); + } + if (cached_has_bits & 0x00000020u) { + _this->_impl_.mediavisibility_ = from._impl_.mediavisibility_; + } + if (cached_has_bits & 0x00000040u) { + _this->_impl_.showindividualnotificationspreview_ = from._impl_.showindividualnotificationspreview_; + } + if (cached_has_bits & 0x00000080u) { + _this->_impl_.showgroupnotificationspreview_ = from._impl_.showgroupnotificationspreview_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00000300u) { + if (cached_has_bits & 0x00000100u) { + _this->_impl_.disappearingmodetimestamp_ = from._impl_.disappearingmodetimestamp_; + } + if (cached_has_bits & 0x00000200u) { + _this->_impl_.disappearingmodeduration_ = from._impl_.disappearingmodeduration_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void GlobalSettings::CopyFrom(const GlobalSettings& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.GlobalSettings) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GlobalSettings::IsInitialized() const { + return true; +} + +void GlobalSettings::InternalSwap(GlobalSettings* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(GlobalSettings, _impl_.disappearingmodeduration_) + + sizeof(GlobalSettings::_impl_.disappearingmodeduration_) + - PROTOBUF_FIELD_OFFSET(GlobalSettings, _impl_.lightthemewallpaper_)>( + reinterpret_cast(&_impl_.lightthemewallpaper_), + reinterpret_cast(&other->_impl_.lightthemewallpaper_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata GlobalSettings::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[33]); +} + +// =================================================================== + +class GroupParticipant::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_userjid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_rank(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0; + } +}; + +GroupParticipant::GroupParticipant(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.GroupParticipant) +} +GroupParticipant::GroupParticipant(const GroupParticipant& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + GroupParticipant* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.userjid_){} + , decltype(_impl_.rank_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.userjid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.userjid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_userjid()) { + _this->_impl_.userjid_.Set(from._internal_userjid(), + _this->GetArenaForAllocation()); + } + _this->_impl_.rank_ = from._impl_.rank_; + // @@protoc_insertion_point(copy_constructor:proto.GroupParticipant) +} + +inline void GroupParticipant::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.userjid_){} + , decltype(_impl_.rank_){0} + }; + _impl_.userjid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.userjid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +GroupParticipant::~GroupParticipant() { + // @@protoc_insertion_point(destructor:proto.GroupParticipant) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void GroupParticipant::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.userjid_.Destroy(); +} + +void GroupParticipant::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void GroupParticipant::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.GroupParticipant) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.userjid_.ClearNonDefaultToEmpty(); + } + _impl_.rank_ = 0; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* GroupParticipant::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // required string userJid = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_userjid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.GroupParticipant.userJid"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.GroupParticipant.Rank rank = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::GroupParticipant_Rank_IsValid(val))) { + _internal_set_rank(static_cast<::proto::GroupParticipant_Rank>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* GroupParticipant::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.GroupParticipant) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // required string userJid = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_userjid().data(), static_cast(this->_internal_userjid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.GroupParticipant.userJid"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_userjid(), target); + } + + // optional .proto.GroupParticipant.Rank rank = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this->_internal_rank(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.GroupParticipant) + return target; +} + +size_t GroupParticipant::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.GroupParticipant) + size_t total_size = 0; + + // required string userJid = 1; + if (_internal_has_userjid()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_userjid()); + } + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional .proto.GroupParticipant.Rank rank = 2; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_rank()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData GroupParticipant::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + GroupParticipant::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GroupParticipant::GetClassData() const { return &_class_data_; } + + +void GroupParticipant::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.GroupParticipant) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_userjid(from._internal_userjid()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.rank_ = from._impl_.rank_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void GroupParticipant::CopyFrom(const GroupParticipant& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.GroupParticipant) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GroupParticipant::IsInitialized() const { + if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false; + return true; +} + +void GroupParticipant::InternalSwap(GroupParticipant* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.userjid_, lhs_arena, + &other->_impl_.userjid_, rhs_arena + ); + swap(_impl_.rank_, other->_impl_.rank_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata GroupParticipant::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[34]); +} + +// =================================================================== + +class HandshakeMessage_ClientFinish::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_static_(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_payload(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +HandshakeMessage_ClientFinish::HandshakeMessage_ClientFinish(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.HandshakeMessage.ClientFinish) +} +HandshakeMessage_ClientFinish::HandshakeMessage_ClientFinish(const HandshakeMessage_ClientFinish& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + HandshakeMessage_ClientFinish* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.static__){} + , decltype(_impl_.payload_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.static__.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.static__.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_static_()) { + _this->_impl_.static__.Set(from._internal_static_(), + _this->GetArenaForAllocation()); + } + _impl_.payload_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.payload_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_payload()) { + _this->_impl_.payload_.Set(from._internal_payload(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.HandshakeMessage.ClientFinish) +} + +inline void HandshakeMessage_ClientFinish::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.static__){} + , decltype(_impl_.payload_){} + }; + _impl_.static__.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.static__.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.payload_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.payload_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +HandshakeMessage_ClientFinish::~HandshakeMessage_ClientFinish() { + // @@protoc_insertion_point(destructor:proto.HandshakeMessage.ClientFinish) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void HandshakeMessage_ClientFinish::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.static__.Destroy(); + _impl_.payload_.Destroy(); +} + +void HandshakeMessage_ClientFinish::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void HandshakeMessage_ClientFinish::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.HandshakeMessage.ClientFinish) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.static__.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.payload_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* HandshakeMessage_ClientFinish::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes static = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_static_(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes payload = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_payload(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* HandshakeMessage_ClientFinish::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.HandshakeMessage.ClientFinish) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes static = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_static_(), target); + } + + // optional bytes payload = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_payload(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.HandshakeMessage.ClientFinish) + return target; +} + +size_t HandshakeMessage_ClientFinish::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.HandshakeMessage.ClientFinish) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional bytes static = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_static_()); + } + + // optional bytes payload = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_payload()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HandshakeMessage_ClientFinish::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + HandshakeMessage_ClientFinish::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HandshakeMessage_ClientFinish::GetClassData() const { return &_class_data_; } + + +void HandshakeMessage_ClientFinish::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.HandshakeMessage.ClientFinish) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_static_(from._internal_static_()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_payload(from._internal_payload()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void HandshakeMessage_ClientFinish::CopyFrom(const HandshakeMessage_ClientFinish& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.HandshakeMessage.ClientFinish) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HandshakeMessage_ClientFinish::IsInitialized() const { + return true; +} + +void HandshakeMessage_ClientFinish::InternalSwap(HandshakeMessage_ClientFinish* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.static__, lhs_arena, + &other->_impl_.static__, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.payload_, lhs_arena, + &other->_impl_.payload_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HandshakeMessage_ClientFinish::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[35]); +} + +// =================================================================== + +class HandshakeMessage_ClientHello::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_ephemeral(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_static_(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_payload(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +HandshakeMessage_ClientHello::HandshakeMessage_ClientHello(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.HandshakeMessage.ClientHello) +} +HandshakeMessage_ClientHello::HandshakeMessage_ClientHello(const HandshakeMessage_ClientHello& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + HandshakeMessage_ClientHello* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.ephemeral_){} + , decltype(_impl_.static__){} + , decltype(_impl_.payload_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.ephemeral_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.ephemeral_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_ephemeral()) { + _this->_impl_.ephemeral_.Set(from._internal_ephemeral(), + _this->GetArenaForAllocation()); + } + _impl_.static__.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.static__.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_static_()) { + _this->_impl_.static__.Set(from._internal_static_(), + _this->GetArenaForAllocation()); + } + _impl_.payload_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.payload_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_payload()) { + _this->_impl_.payload_.Set(from._internal_payload(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.HandshakeMessage.ClientHello) +} + +inline void HandshakeMessage_ClientHello::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.ephemeral_){} + , decltype(_impl_.static__){} + , decltype(_impl_.payload_){} + }; + _impl_.ephemeral_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.ephemeral_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.static__.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.static__.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.payload_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.payload_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +HandshakeMessage_ClientHello::~HandshakeMessage_ClientHello() { + // @@protoc_insertion_point(destructor:proto.HandshakeMessage.ClientHello) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void HandshakeMessage_ClientHello::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.ephemeral_.Destroy(); + _impl_.static__.Destroy(); + _impl_.payload_.Destroy(); +} + +void HandshakeMessage_ClientHello::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void HandshakeMessage_ClientHello::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.HandshakeMessage.ClientHello) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _impl_.ephemeral_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.static__.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.payload_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* HandshakeMessage_ClientHello::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes ephemeral = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_ephemeral(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes static = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_static_(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes payload = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_payload(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* HandshakeMessage_ClientHello::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.HandshakeMessage.ClientHello) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes ephemeral = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_ephemeral(), target); + } + + // optional bytes static = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_static_(), target); + } + + // optional bytes payload = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->WriteBytesMaybeAliased( + 3, this->_internal_payload(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.HandshakeMessage.ClientHello) + return target; +} + +size_t HandshakeMessage_ClientHello::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.HandshakeMessage.ClientHello) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional bytes ephemeral = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_ephemeral()); + } + + // optional bytes static = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_static_()); + } + + // optional bytes payload = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_payload()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HandshakeMessage_ClientHello::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + HandshakeMessage_ClientHello::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HandshakeMessage_ClientHello::GetClassData() const { return &_class_data_; } + + +void HandshakeMessage_ClientHello::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.HandshakeMessage.ClientHello) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_ephemeral(from._internal_ephemeral()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_static_(from._internal_static_()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_payload(from._internal_payload()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void HandshakeMessage_ClientHello::CopyFrom(const HandshakeMessage_ClientHello& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.HandshakeMessage.ClientHello) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HandshakeMessage_ClientHello::IsInitialized() const { + return true; +} + +void HandshakeMessage_ClientHello::InternalSwap(HandshakeMessage_ClientHello* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.ephemeral_, lhs_arena, + &other->_impl_.ephemeral_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.static__, lhs_arena, + &other->_impl_.static__, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.payload_, lhs_arena, + &other->_impl_.payload_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HandshakeMessage_ClientHello::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[36]); +} + +// =================================================================== + +class HandshakeMessage_ServerHello::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_ephemeral(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_static_(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_payload(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +HandshakeMessage_ServerHello::HandshakeMessage_ServerHello(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.HandshakeMessage.ServerHello) +} +HandshakeMessage_ServerHello::HandshakeMessage_ServerHello(const HandshakeMessage_ServerHello& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + HandshakeMessage_ServerHello* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.ephemeral_){} + , decltype(_impl_.static__){} + , decltype(_impl_.payload_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.ephemeral_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.ephemeral_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_ephemeral()) { + _this->_impl_.ephemeral_.Set(from._internal_ephemeral(), + _this->GetArenaForAllocation()); + } + _impl_.static__.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.static__.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_static_()) { + _this->_impl_.static__.Set(from._internal_static_(), + _this->GetArenaForAllocation()); + } + _impl_.payload_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.payload_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_payload()) { + _this->_impl_.payload_.Set(from._internal_payload(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.HandshakeMessage.ServerHello) +} + +inline void HandshakeMessage_ServerHello::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.ephemeral_){} + , decltype(_impl_.static__){} + , decltype(_impl_.payload_){} + }; + _impl_.ephemeral_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.ephemeral_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.static__.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.static__.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.payload_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.payload_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +HandshakeMessage_ServerHello::~HandshakeMessage_ServerHello() { + // @@protoc_insertion_point(destructor:proto.HandshakeMessage.ServerHello) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void HandshakeMessage_ServerHello::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.ephemeral_.Destroy(); + _impl_.static__.Destroy(); + _impl_.payload_.Destroy(); +} + +void HandshakeMessage_ServerHello::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void HandshakeMessage_ServerHello::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.HandshakeMessage.ServerHello) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _impl_.ephemeral_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.static__.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.payload_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* HandshakeMessage_ServerHello::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes ephemeral = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_ephemeral(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes static = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_static_(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes payload = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_payload(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* HandshakeMessage_ServerHello::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.HandshakeMessage.ServerHello) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes ephemeral = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_ephemeral(), target); + } + + // optional bytes static = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_static_(), target); + } + + // optional bytes payload = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->WriteBytesMaybeAliased( + 3, this->_internal_payload(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.HandshakeMessage.ServerHello) + return target; +} + +size_t HandshakeMessage_ServerHello::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.HandshakeMessage.ServerHello) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional bytes ephemeral = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_ephemeral()); + } + + // optional bytes static = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_static_()); + } + + // optional bytes payload = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_payload()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HandshakeMessage_ServerHello::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + HandshakeMessage_ServerHello::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HandshakeMessage_ServerHello::GetClassData() const { return &_class_data_; } + + +void HandshakeMessage_ServerHello::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.HandshakeMessage.ServerHello) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_ephemeral(from._internal_ephemeral()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_static_(from._internal_static_()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_payload(from._internal_payload()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void HandshakeMessage_ServerHello::CopyFrom(const HandshakeMessage_ServerHello& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.HandshakeMessage.ServerHello) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HandshakeMessage_ServerHello::IsInitialized() const { + return true; +} + +void HandshakeMessage_ServerHello::InternalSwap(HandshakeMessage_ServerHello* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.ephemeral_, lhs_arena, + &other->_impl_.ephemeral_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.static__, lhs_arena, + &other->_impl_.static__, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.payload_, lhs_arena, + &other->_impl_.payload_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HandshakeMessage_ServerHello::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[37]); +} + +// =================================================================== + +class HandshakeMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::HandshakeMessage_ClientHello& clienthello(const HandshakeMessage* msg); + static void set_has_clienthello(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::proto::HandshakeMessage_ServerHello& serverhello(const HandshakeMessage* msg); + static void set_has_serverhello(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::proto::HandshakeMessage_ClientFinish& clientfinish(const HandshakeMessage* msg); + static void set_has_clientfinish(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +const ::proto::HandshakeMessage_ClientHello& +HandshakeMessage::_Internal::clienthello(const HandshakeMessage* msg) { + return *msg->_impl_.clienthello_; +} +const ::proto::HandshakeMessage_ServerHello& +HandshakeMessage::_Internal::serverhello(const HandshakeMessage* msg) { + return *msg->_impl_.serverhello_; +} +const ::proto::HandshakeMessage_ClientFinish& +HandshakeMessage::_Internal::clientfinish(const HandshakeMessage* msg) { + return *msg->_impl_.clientfinish_; +} +HandshakeMessage::HandshakeMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.HandshakeMessage) +} +HandshakeMessage::HandshakeMessage(const HandshakeMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + HandshakeMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.clienthello_){nullptr} + , decltype(_impl_.serverhello_){nullptr} + , decltype(_impl_.clientfinish_){nullptr}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_clienthello()) { + _this->_impl_.clienthello_ = new ::proto::HandshakeMessage_ClientHello(*from._impl_.clienthello_); + } + if (from._internal_has_serverhello()) { + _this->_impl_.serverhello_ = new ::proto::HandshakeMessage_ServerHello(*from._impl_.serverhello_); + } + if (from._internal_has_clientfinish()) { + _this->_impl_.clientfinish_ = new ::proto::HandshakeMessage_ClientFinish(*from._impl_.clientfinish_); + } + // @@protoc_insertion_point(copy_constructor:proto.HandshakeMessage) +} + +inline void HandshakeMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.clienthello_){nullptr} + , decltype(_impl_.serverhello_){nullptr} + , decltype(_impl_.clientfinish_){nullptr} + }; +} + +HandshakeMessage::~HandshakeMessage() { + // @@protoc_insertion_point(destructor:proto.HandshakeMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void HandshakeMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.clienthello_; + if (this != internal_default_instance()) delete _impl_.serverhello_; + if (this != internal_default_instance()) delete _impl_.clientfinish_; +} + +void HandshakeMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void HandshakeMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.HandshakeMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.clienthello_ != nullptr); + _impl_.clienthello_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.serverhello_ != nullptr); + _impl_.serverhello_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.clientfinish_ != nullptr); + _impl_.clientfinish_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* HandshakeMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.HandshakeMessage.ClientHello clientHello = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_clienthello(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.HandshakeMessage.ServerHello serverHello = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_serverhello(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.HandshakeMessage.ClientFinish clientFinish = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_clientfinish(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* HandshakeMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.HandshakeMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.HandshakeMessage.ClientHello clientHello = 2; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::clienthello(this), + _Internal::clienthello(this).GetCachedSize(), target, stream); + } + + // optional .proto.HandshakeMessage.ServerHello serverHello = 3; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::serverhello(this), + _Internal::serverhello(this).GetCachedSize(), target, stream); + } + + // optional .proto.HandshakeMessage.ClientFinish clientFinish = 4; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, _Internal::clientfinish(this), + _Internal::clientfinish(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.HandshakeMessage) + return target; +} + +size_t HandshakeMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.HandshakeMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional .proto.HandshakeMessage.ClientHello clientHello = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.clienthello_); + } + + // optional .proto.HandshakeMessage.ServerHello serverHello = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.serverhello_); + } + + // optional .proto.HandshakeMessage.ClientFinish clientFinish = 4; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.clientfinish_); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HandshakeMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + HandshakeMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HandshakeMessage::GetClassData() const { return &_class_data_; } + + +void HandshakeMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.HandshakeMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_clienthello()->::proto::HandshakeMessage_ClientHello::MergeFrom( + from._internal_clienthello()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_serverhello()->::proto::HandshakeMessage_ServerHello::MergeFrom( + from._internal_serverhello()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_clientfinish()->::proto::HandshakeMessage_ClientFinish::MergeFrom( + from._internal_clientfinish()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void HandshakeMessage::CopyFrom(const HandshakeMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.HandshakeMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HandshakeMessage::IsInitialized() const { + return true; +} + +void HandshakeMessage::InternalSwap(HandshakeMessage* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(HandshakeMessage, _impl_.clientfinish_) + + sizeof(HandshakeMessage::_impl_.clientfinish_) + - PROTOBUF_FIELD_OFFSET(HandshakeMessage, _impl_.clienthello_)>( + reinterpret_cast(&_impl_.clienthello_), + reinterpret_cast(&other->_impl_.clienthello_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HandshakeMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[38]); +} + +// =================================================================== + +class HistorySync::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_synctype(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_chunkorder(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_progress(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static const ::proto::GlobalSettings& globalsettings(const HistorySync* msg); + static void set_has_globalsettings(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_threadidusersecret(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_threaddstimeframeoffset(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000004) ^ 0x00000004) != 0; + } +}; + +const ::proto::GlobalSettings& +HistorySync::_Internal::globalsettings(const HistorySync* msg) { + return *msg->_impl_.globalsettings_; +} +HistorySync::HistorySync(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.HistorySync) +} +HistorySync::HistorySync(const HistorySync& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + HistorySync* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.conversations_){from._impl_.conversations_} + , decltype(_impl_.statusv3messages_){from._impl_.statusv3messages_} + , decltype(_impl_.pushnames_){from._impl_.pushnames_} + , decltype(_impl_.recentstickers_){from._impl_.recentstickers_} + , decltype(_impl_.pastparticipants_){from._impl_.pastparticipants_} + , decltype(_impl_.threadidusersecret_){} + , decltype(_impl_.globalsettings_){nullptr} + , decltype(_impl_.synctype_){} + , decltype(_impl_.chunkorder_){} + , decltype(_impl_.progress_){} + , decltype(_impl_.threaddstimeframeoffset_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.threadidusersecret_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.threadidusersecret_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_threadidusersecret()) { + _this->_impl_.threadidusersecret_.Set(from._internal_threadidusersecret(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_globalsettings()) { + _this->_impl_.globalsettings_ = new ::proto::GlobalSettings(*from._impl_.globalsettings_); + } + ::memcpy(&_impl_.synctype_, &from._impl_.synctype_, + static_cast(reinterpret_cast(&_impl_.threaddstimeframeoffset_) - + reinterpret_cast(&_impl_.synctype_)) + sizeof(_impl_.threaddstimeframeoffset_)); + // @@protoc_insertion_point(copy_constructor:proto.HistorySync) +} + +inline void HistorySync::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.conversations_){arena} + , decltype(_impl_.statusv3messages_){arena} + , decltype(_impl_.pushnames_){arena} + , decltype(_impl_.recentstickers_){arena} + , decltype(_impl_.pastparticipants_){arena} + , decltype(_impl_.threadidusersecret_){} + , decltype(_impl_.globalsettings_){nullptr} + , decltype(_impl_.synctype_){0} + , decltype(_impl_.chunkorder_){0u} + , decltype(_impl_.progress_){0u} + , decltype(_impl_.threaddstimeframeoffset_){0u} + }; + _impl_.threadidusersecret_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.threadidusersecret_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +HistorySync::~HistorySync() { + // @@protoc_insertion_point(destructor:proto.HistorySync) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void HistorySync::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.conversations_.~RepeatedPtrField(); + _impl_.statusv3messages_.~RepeatedPtrField(); + _impl_.pushnames_.~RepeatedPtrField(); + _impl_.recentstickers_.~RepeatedPtrField(); + _impl_.pastparticipants_.~RepeatedPtrField(); + _impl_.threadidusersecret_.Destroy(); + if (this != internal_default_instance()) delete _impl_.globalsettings_; +} + +void HistorySync::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void HistorySync::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.HistorySync) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.conversations_.Clear(); + _impl_.statusv3messages_.Clear(); + _impl_.pushnames_.Clear(); + _impl_.recentstickers_.Clear(); + _impl_.pastparticipants_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.threadidusersecret_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.globalsettings_ != nullptr); + _impl_.globalsettings_->Clear(); + } + } + if (cached_has_bits & 0x0000003cu) { + ::memset(&_impl_.synctype_, 0, static_cast( + reinterpret_cast(&_impl_.threaddstimeframeoffset_) - + reinterpret_cast(&_impl_.synctype_)) + sizeof(_impl_.threaddstimeframeoffset_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* HistorySync::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // required .proto.HistorySync.HistorySyncType syncType = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::HistorySync_HistorySyncType_IsValid(val))) { + _internal_set_synctype(static_cast<::proto::HistorySync_HistorySyncType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // repeated .proto.Conversation conversations = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_conversations(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else + goto handle_unusual; + continue; + // repeated .proto.WebMessageInfo statusV3Messages = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_statusv3messages(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else + goto handle_unusual; + continue; + // optional uint32 chunkOrder = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_chunkorder(&has_bits); + _impl_.chunkorder_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 progress = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + _Internal::set_has_progress(&has_bits); + _impl_.progress_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .proto.Pushname pushnames = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_pushnames(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<58>(ptr)); + } else + goto handle_unusual; + continue; + // optional .proto.GlobalSettings globalSettings = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + ptr = ctx->ParseMessage(_internal_mutable_globalsettings(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes threadIdUserSecret = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + auto str = _internal_mutable_threadidusersecret(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 threadDsTimeframeOffset = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { + _Internal::set_has_threaddstimeframeoffset(&has_bits); + _impl_.threaddstimeframeoffset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .proto.StickerMetadata recentStickers = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_recentstickers(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<90>(ptr)); + } else + goto handle_unusual; + continue; + // repeated .proto.PastParticipants pastParticipants = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_pastparticipants(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<98>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* HistorySync::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.HistorySync) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // required .proto.HistorySync.HistorySyncType syncType = 1; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this->_internal_synctype(), target); + } + + // repeated .proto.Conversation conversations = 2; + for (unsigned i = 0, + n = static_cast(this->_internal_conversations_size()); i < n; i++) { + const auto& repfield = this->_internal_conversations(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream); + } + + // repeated .proto.WebMessageInfo statusV3Messages = 3; + for (unsigned i = 0, + n = static_cast(this->_internal_statusv3messages_size()); i < n; i++) { + const auto& repfield = this->_internal_statusv3messages(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream); + } + + // optional uint32 chunkOrder = 5; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_chunkorder(), target); + } + + // optional uint32 progress = 6; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_progress(), target); + } + + // repeated .proto.Pushname pushnames = 7; + for (unsigned i = 0, + n = static_cast(this->_internal_pushnames_size()); i < n; i++) { + const auto& repfield = this->_internal_pushnames(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(7, repfield, repfield.GetCachedSize(), target, stream); + } + + // optional .proto.GlobalSettings globalSettings = 8; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(8, _Internal::globalsettings(this), + _Internal::globalsettings(this).GetCachedSize(), target, stream); + } + + // optional bytes threadIdUserSecret = 9; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 9, this->_internal_threadidusersecret(), target); + } + + // optional uint32 threadDsTimeframeOffset = 10; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(10, this->_internal_threaddstimeframeoffset(), target); + } + + // repeated .proto.StickerMetadata recentStickers = 11; + for (unsigned i = 0, + n = static_cast(this->_internal_recentstickers_size()); i < n; i++) { + const auto& repfield = this->_internal_recentstickers(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(11, repfield, repfield.GetCachedSize(), target, stream); + } + + // repeated .proto.PastParticipants pastParticipants = 12; + for (unsigned i = 0, + n = static_cast(this->_internal_pastparticipants_size()); i < n; i++) { + const auto& repfield = this->_internal_pastparticipants(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(12, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.HistorySync) + return target; +} + +size_t HistorySync::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.HistorySync) + size_t total_size = 0; + + // required .proto.HistorySync.HistorySyncType syncType = 1; + if (_internal_has_synctype()) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_synctype()); + } + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.Conversation conversations = 2; + total_size += 1UL * this->_internal_conversations_size(); + for (const auto& msg : this->_impl_.conversations_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .proto.WebMessageInfo statusV3Messages = 3; + total_size += 1UL * this->_internal_statusv3messages_size(); + for (const auto& msg : this->_impl_.statusv3messages_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .proto.Pushname pushnames = 7; + total_size += 1UL * this->_internal_pushnames_size(); + for (const auto& msg : this->_impl_.pushnames_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .proto.StickerMetadata recentStickers = 11; + total_size += 1UL * this->_internal_recentstickers_size(); + for (const auto& msg : this->_impl_.recentstickers_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .proto.PastParticipants pastParticipants = 12; + total_size += 1UL * this->_internal_pastparticipants_size(); + for (const auto& msg : this->_impl_.pastparticipants_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional bytes threadIdUserSecret = 9; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_threadidusersecret()); + } + + // optional .proto.GlobalSettings globalSettings = 8; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.globalsettings_); + } + + } + if (cached_has_bits & 0x00000038u) { + // optional uint32 chunkOrder = 5; + if (cached_has_bits & 0x00000008u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_chunkorder()); + } + + // optional uint32 progress = 6; + if (cached_has_bits & 0x00000010u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_progress()); + } + + // optional uint32 threadDsTimeframeOffset = 10; + if (cached_has_bits & 0x00000020u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_threaddstimeframeoffset()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HistorySync::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + HistorySync::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HistorySync::GetClassData() const { return &_class_data_; } + + +void HistorySync::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.HistorySync) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.conversations_.MergeFrom(from._impl_.conversations_); + _this->_impl_.statusv3messages_.MergeFrom(from._impl_.statusv3messages_); + _this->_impl_.pushnames_.MergeFrom(from._impl_.pushnames_); + _this->_impl_.recentstickers_.MergeFrom(from._impl_.recentstickers_); + _this->_impl_.pastparticipants_.MergeFrom(from._impl_.pastparticipants_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_threadidusersecret(from._internal_threadidusersecret()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_globalsettings()->::proto::GlobalSettings::MergeFrom( + from._internal_globalsettings()); + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.synctype_ = from._impl_.synctype_; + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.chunkorder_ = from._impl_.chunkorder_; + } + if (cached_has_bits & 0x00000010u) { + _this->_impl_.progress_ = from._impl_.progress_; + } + if (cached_has_bits & 0x00000020u) { + _this->_impl_.threaddstimeframeoffset_ = from._impl_.threaddstimeframeoffset_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void HistorySync::CopyFrom(const HistorySync& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.HistorySync) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HistorySync::IsInitialized() const { + if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false; + if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.conversations_)) + return false; + if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.statusv3messages_)) + return false; + if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.pastparticipants_)) + return false; + return true; +} + +void HistorySync::InternalSwap(HistorySync* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.conversations_.InternalSwap(&other->_impl_.conversations_); + _impl_.statusv3messages_.InternalSwap(&other->_impl_.statusv3messages_); + _impl_.pushnames_.InternalSwap(&other->_impl_.pushnames_); + _impl_.recentstickers_.InternalSwap(&other->_impl_.recentstickers_); + _impl_.pastparticipants_.InternalSwap(&other->_impl_.pastparticipants_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.threadidusersecret_, lhs_arena, + &other->_impl_.threadidusersecret_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(HistorySync, _impl_.threaddstimeframeoffset_) + + sizeof(HistorySync::_impl_.threaddstimeframeoffset_) + - PROTOBUF_FIELD_OFFSET(HistorySync, _impl_.globalsettings_)>( + reinterpret_cast(&_impl_.globalsettings_), + reinterpret_cast(&other->_impl_.globalsettings_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HistorySync::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[39]); +} + +// =================================================================== + +class HistorySyncMsg::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::WebMessageInfo& message(const HistorySyncMsg* msg); + static void set_has_message(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_msgorderid(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::proto::WebMessageInfo& +HistorySyncMsg::_Internal::message(const HistorySyncMsg* msg) { + return *msg->_impl_.message_; +} +HistorySyncMsg::HistorySyncMsg(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.HistorySyncMsg) +} +HistorySyncMsg::HistorySyncMsg(const HistorySyncMsg& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + HistorySyncMsg* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.message_){nullptr} + , decltype(_impl_.msgorderid_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_message()) { + _this->_impl_.message_ = new ::proto::WebMessageInfo(*from._impl_.message_); + } + _this->_impl_.msgorderid_ = from._impl_.msgorderid_; + // @@protoc_insertion_point(copy_constructor:proto.HistorySyncMsg) +} + +inline void HistorySyncMsg::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.message_){nullptr} + , decltype(_impl_.msgorderid_){uint64_t{0u}} + }; +} + +HistorySyncMsg::~HistorySyncMsg() { + // @@protoc_insertion_point(destructor:proto.HistorySyncMsg) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void HistorySyncMsg::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.message_; +} + +void HistorySyncMsg::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void HistorySyncMsg::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.HistorySyncMsg) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.message_ != nullptr); + _impl_.message_->Clear(); + } + _impl_.msgorderid_ = uint64_t{0u}; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* HistorySyncMsg::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.WebMessageInfo message = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_message(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint64 msgOrderId = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_msgorderid(&has_bits); + _impl_.msgorderid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* HistorySyncMsg::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.HistorySyncMsg) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.WebMessageInfo message = 1; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::message(this), + _Internal::message(this).GetCachedSize(), target, stream); + } + + // optional uint64 msgOrderId = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_msgorderid(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.HistorySyncMsg) + return target; +} + +size_t HistorySyncMsg::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.HistorySyncMsg) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional .proto.WebMessageInfo message = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.message_); + } + + // optional uint64 msgOrderId = 2; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_msgorderid()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HistorySyncMsg::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + HistorySyncMsg::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HistorySyncMsg::GetClassData() const { return &_class_data_; } + + +void HistorySyncMsg::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.HistorySyncMsg) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_message()->::proto::WebMessageInfo::MergeFrom( + from._internal_message()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.msgorderid_ = from._impl_.msgorderid_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void HistorySyncMsg::CopyFrom(const HistorySyncMsg& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.HistorySyncMsg) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HistorySyncMsg::IsInitialized() const { + if (_internal_has_message()) { + if (!_impl_.message_->IsInitialized()) return false; + } + return true; +} + +void HistorySyncMsg::InternalSwap(HistorySyncMsg* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(HistorySyncMsg, _impl_.msgorderid_) + + sizeof(HistorySyncMsg::_impl_.msgorderid_) + - PROTOBUF_FIELD_OFFSET(HistorySyncMsg, _impl_.message_)>( + reinterpret_cast(&_impl_.message_), + reinterpret_cast(&other->_impl_.message_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HistorySyncMsg::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[40]); +} + +// =================================================================== + +class HydratedTemplateButton_HydratedCallButton::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_displaytext(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_phonenumber(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +HydratedTemplateButton_HydratedCallButton::HydratedTemplateButton_HydratedCallButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.HydratedTemplateButton.HydratedCallButton) +} +HydratedTemplateButton_HydratedCallButton::HydratedTemplateButton_HydratedCallButton(const HydratedTemplateButton_HydratedCallButton& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + HydratedTemplateButton_HydratedCallButton* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.displaytext_){} + , decltype(_impl_.phonenumber_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.displaytext_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.displaytext_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_displaytext()) { + _this->_impl_.displaytext_.Set(from._internal_displaytext(), + _this->GetArenaForAllocation()); + } + _impl_.phonenumber_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.phonenumber_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_phonenumber()) { + _this->_impl_.phonenumber_.Set(from._internal_phonenumber(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.HydratedTemplateButton.HydratedCallButton) +} + +inline void HydratedTemplateButton_HydratedCallButton::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.displaytext_){} + , decltype(_impl_.phonenumber_){} + }; + _impl_.displaytext_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.displaytext_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.phonenumber_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.phonenumber_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +HydratedTemplateButton_HydratedCallButton::~HydratedTemplateButton_HydratedCallButton() { + // @@protoc_insertion_point(destructor:proto.HydratedTemplateButton.HydratedCallButton) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void HydratedTemplateButton_HydratedCallButton::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.displaytext_.Destroy(); + _impl_.phonenumber_.Destroy(); +} + +void HydratedTemplateButton_HydratedCallButton::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void HydratedTemplateButton_HydratedCallButton::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.HydratedTemplateButton.HydratedCallButton) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.displaytext_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.phonenumber_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* HydratedTemplateButton_HydratedCallButton::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string displayText = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_displaytext(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.HydratedTemplateButton.HydratedCallButton.displayText"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string phoneNumber = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_phonenumber(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.HydratedTemplateButton.HydratedCallButton.phoneNumber"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* HydratedTemplateButton_HydratedCallButton::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.HydratedTemplateButton.HydratedCallButton) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string displayText = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_displaytext().data(), static_cast(this->_internal_displaytext().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.HydratedTemplateButton.HydratedCallButton.displayText"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_displaytext(), target); + } + + // optional string phoneNumber = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_phonenumber().data(), static_cast(this->_internal_phonenumber().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.HydratedTemplateButton.HydratedCallButton.phoneNumber"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_phonenumber(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.HydratedTemplateButton.HydratedCallButton) + return target; +} + +size_t HydratedTemplateButton_HydratedCallButton::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.HydratedTemplateButton.HydratedCallButton) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional string displayText = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_displaytext()); + } + + // optional string phoneNumber = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_phonenumber()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HydratedTemplateButton_HydratedCallButton::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + HydratedTemplateButton_HydratedCallButton::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HydratedTemplateButton_HydratedCallButton::GetClassData() const { return &_class_data_; } + + +void HydratedTemplateButton_HydratedCallButton::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.HydratedTemplateButton.HydratedCallButton) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_displaytext(from._internal_displaytext()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_phonenumber(from._internal_phonenumber()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void HydratedTemplateButton_HydratedCallButton::CopyFrom(const HydratedTemplateButton_HydratedCallButton& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.HydratedTemplateButton.HydratedCallButton) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HydratedTemplateButton_HydratedCallButton::IsInitialized() const { + return true; +} + +void HydratedTemplateButton_HydratedCallButton::InternalSwap(HydratedTemplateButton_HydratedCallButton* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.displaytext_, lhs_arena, + &other->_impl_.displaytext_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.phonenumber_, lhs_arena, + &other->_impl_.phonenumber_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HydratedTemplateButton_HydratedCallButton::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[41]); +} + +// =================================================================== + +class HydratedTemplateButton_HydratedQuickReplyButton::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_displaytext(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_id(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +HydratedTemplateButton_HydratedQuickReplyButton::HydratedTemplateButton_HydratedQuickReplyButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.HydratedTemplateButton.HydratedQuickReplyButton) +} +HydratedTemplateButton_HydratedQuickReplyButton::HydratedTemplateButton_HydratedQuickReplyButton(const HydratedTemplateButton_HydratedQuickReplyButton& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + HydratedTemplateButton_HydratedQuickReplyButton* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.displaytext_){} + , decltype(_impl_.id_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.displaytext_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.displaytext_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_displaytext()) { + _this->_impl_.displaytext_.Set(from._internal_displaytext(), + _this->GetArenaForAllocation()); + } + _impl_.id_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.id_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_id()) { + _this->_impl_.id_.Set(from._internal_id(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.HydratedTemplateButton.HydratedQuickReplyButton) +} + +inline void HydratedTemplateButton_HydratedQuickReplyButton::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.displaytext_){} + , decltype(_impl_.id_){} + }; + _impl_.displaytext_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.displaytext_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.id_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.id_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +HydratedTemplateButton_HydratedQuickReplyButton::~HydratedTemplateButton_HydratedQuickReplyButton() { + // @@protoc_insertion_point(destructor:proto.HydratedTemplateButton.HydratedQuickReplyButton) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void HydratedTemplateButton_HydratedQuickReplyButton::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.displaytext_.Destroy(); + _impl_.id_.Destroy(); +} + +void HydratedTemplateButton_HydratedQuickReplyButton::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void HydratedTemplateButton_HydratedQuickReplyButton::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.HydratedTemplateButton.HydratedQuickReplyButton) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.displaytext_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.id_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* HydratedTemplateButton_HydratedQuickReplyButton::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string displayText = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_displaytext(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.HydratedTemplateButton.HydratedQuickReplyButton.displayText"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string id = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_id(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.HydratedTemplateButton.HydratedQuickReplyButton.id"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* HydratedTemplateButton_HydratedQuickReplyButton::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.HydratedTemplateButton.HydratedQuickReplyButton) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string displayText = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_displaytext().data(), static_cast(this->_internal_displaytext().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.HydratedTemplateButton.HydratedQuickReplyButton.displayText"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_displaytext(), target); + } + + // optional string id = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_id().data(), static_cast(this->_internal_id().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.HydratedTemplateButton.HydratedQuickReplyButton.id"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.HydratedTemplateButton.HydratedQuickReplyButton) + return target; +} + +size_t HydratedTemplateButton_HydratedQuickReplyButton::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.HydratedTemplateButton.HydratedQuickReplyButton) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional string displayText = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_displaytext()); + } + + // optional string id = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_id()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HydratedTemplateButton_HydratedQuickReplyButton::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + HydratedTemplateButton_HydratedQuickReplyButton::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HydratedTemplateButton_HydratedQuickReplyButton::GetClassData() const { return &_class_data_; } + + +void HydratedTemplateButton_HydratedQuickReplyButton::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.HydratedTemplateButton.HydratedQuickReplyButton) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_displaytext(from._internal_displaytext()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_id(from._internal_id()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void HydratedTemplateButton_HydratedQuickReplyButton::CopyFrom(const HydratedTemplateButton_HydratedQuickReplyButton& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.HydratedTemplateButton.HydratedQuickReplyButton) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HydratedTemplateButton_HydratedQuickReplyButton::IsInitialized() const { + return true; +} + +void HydratedTemplateButton_HydratedQuickReplyButton::InternalSwap(HydratedTemplateButton_HydratedQuickReplyButton* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.displaytext_, lhs_arena, + &other->_impl_.displaytext_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.id_, lhs_arena, + &other->_impl_.id_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HydratedTemplateButton_HydratedQuickReplyButton::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[42]); +} + +// =================================================================== + +class HydratedTemplateButton_HydratedURLButton::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_displaytext(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_url(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +HydratedTemplateButton_HydratedURLButton::HydratedTemplateButton_HydratedURLButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.HydratedTemplateButton.HydratedURLButton) +} +HydratedTemplateButton_HydratedURLButton::HydratedTemplateButton_HydratedURLButton(const HydratedTemplateButton_HydratedURLButton& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + HydratedTemplateButton_HydratedURLButton* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.displaytext_){} + , decltype(_impl_.url_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.displaytext_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.displaytext_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_displaytext()) { + _this->_impl_.displaytext_.Set(from._internal_displaytext(), + _this->GetArenaForAllocation()); + } + _impl_.url_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.url_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_url()) { + _this->_impl_.url_.Set(from._internal_url(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.HydratedTemplateButton.HydratedURLButton) +} + +inline void HydratedTemplateButton_HydratedURLButton::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.displaytext_){} + , decltype(_impl_.url_){} + }; + _impl_.displaytext_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.displaytext_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.url_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.url_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +HydratedTemplateButton_HydratedURLButton::~HydratedTemplateButton_HydratedURLButton() { + // @@protoc_insertion_point(destructor:proto.HydratedTemplateButton.HydratedURLButton) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void HydratedTemplateButton_HydratedURLButton::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.displaytext_.Destroy(); + _impl_.url_.Destroy(); +} + +void HydratedTemplateButton_HydratedURLButton::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void HydratedTemplateButton_HydratedURLButton::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.HydratedTemplateButton.HydratedURLButton) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.displaytext_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.url_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* HydratedTemplateButton_HydratedURLButton::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string displayText = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_displaytext(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.HydratedTemplateButton.HydratedURLButton.displayText"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string url = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_url(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.HydratedTemplateButton.HydratedURLButton.url"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* HydratedTemplateButton_HydratedURLButton::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.HydratedTemplateButton.HydratedURLButton) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string displayText = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_displaytext().data(), static_cast(this->_internal_displaytext().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.HydratedTemplateButton.HydratedURLButton.displayText"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_displaytext(), target); + } + + // optional string url = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_url().data(), static_cast(this->_internal_url().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.HydratedTemplateButton.HydratedURLButton.url"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_url(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.HydratedTemplateButton.HydratedURLButton) + return target; +} + +size_t HydratedTemplateButton_HydratedURLButton::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.HydratedTemplateButton.HydratedURLButton) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional string displayText = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_displaytext()); + } + + // optional string url = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_url()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HydratedTemplateButton_HydratedURLButton::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + HydratedTemplateButton_HydratedURLButton::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HydratedTemplateButton_HydratedURLButton::GetClassData() const { return &_class_data_; } + + +void HydratedTemplateButton_HydratedURLButton::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.HydratedTemplateButton.HydratedURLButton) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_displaytext(from._internal_displaytext()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_url(from._internal_url()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void HydratedTemplateButton_HydratedURLButton::CopyFrom(const HydratedTemplateButton_HydratedURLButton& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.HydratedTemplateButton.HydratedURLButton) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HydratedTemplateButton_HydratedURLButton::IsInitialized() const { + return true; +} + +void HydratedTemplateButton_HydratedURLButton::InternalSwap(HydratedTemplateButton_HydratedURLButton* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.displaytext_, lhs_arena, + &other->_impl_.displaytext_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.url_, lhs_arena, + &other->_impl_.url_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HydratedTemplateButton_HydratedURLButton::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[43]); +} + +// =================================================================== + +class HydratedTemplateButton::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_index(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::proto::HydratedTemplateButton_HydratedQuickReplyButton& quickreplybutton(const HydratedTemplateButton* msg); + static const ::proto::HydratedTemplateButton_HydratedURLButton& urlbutton(const HydratedTemplateButton* msg); + static const ::proto::HydratedTemplateButton_HydratedCallButton& callbutton(const HydratedTemplateButton* msg); +}; + +const ::proto::HydratedTemplateButton_HydratedQuickReplyButton& +HydratedTemplateButton::_Internal::quickreplybutton(const HydratedTemplateButton* msg) { + return *msg->_impl_.hydratedButton_.quickreplybutton_; +} +const ::proto::HydratedTemplateButton_HydratedURLButton& +HydratedTemplateButton::_Internal::urlbutton(const HydratedTemplateButton* msg) { + return *msg->_impl_.hydratedButton_.urlbutton_; +} +const ::proto::HydratedTemplateButton_HydratedCallButton& +HydratedTemplateButton::_Internal::callbutton(const HydratedTemplateButton* msg) { + return *msg->_impl_.hydratedButton_.callbutton_; +} +void HydratedTemplateButton::set_allocated_quickreplybutton(::proto::HydratedTemplateButton_HydratedQuickReplyButton* quickreplybutton) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_hydratedButton(); + if (quickreplybutton) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quickreplybutton); + if (message_arena != submessage_arena) { + quickreplybutton = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, quickreplybutton, submessage_arena); + } + set_has_quickreplybutton(); + _impl_.hydratedButton_.quickreplybutton_ = quickreplybutton; + } + // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.quickReplyButton) +} +void HydratedTemplateButton::set_allocated_urlbutton(::proto::HydratedTemplateButton_HydratedURLButton* urlbutton) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_hydratedButton(); + if (urlbutton) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(urlbutton); + if (message_arena != submessage_arena) { + urlbutton = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, urlbutton, submessage_arena); + } + set_has_urlbutton(); + _impl_.hydratedButton_.urlbutton_ = urlbutton; + } + // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.urlButton) +} +void HydratedTemplateButton::set_allocated_callbutton(::proto::HydratedTemplateButton_HydratedCallButton* callbutton) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_hydratedButton(); + if (callbutton) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(callbutton); + if (message_arena != submessage_arena) { + callbutton = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, callbutton, submessage_arena); + } + set_has_callbutton(); + _impl_.hydratedButton_.callbutton_ = callbutton; + } + // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.callButton) +} +HydratedTemplateButton::HydratedTemplateButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.HydratedTemplateButton) +} +HydratedTemplateButton::HydratedTemplateButton(const HydratedTemplateButton& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + HydratedTemplateButton* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.index_){} + , decltype(_impl_.hydratedButton_){} + , /*decltype(_impl_._oneof_case_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _this->_impl_.index_ = from._impl_.index_; + clear_has_hydratedButton(); + switch (from.hydratedButton_case()) { + case kQuickReplyButton: { + _this->_internal_mutable_quickreplybutton()->::proto::HydratedTemplateButton_HydratedQuickReplyButton::MergeFrom( + from._internal_quickreplybutton()); + break; + } + case kUrlButton: { + _this->_internal_mutable_urlbutton()->::proto::HydratedTemplateButton_HydratedURLButton::MergeFrom( + from._internal_urlbutton()); + break; + } + case kCallButton: { + _this->_internal_mutable_callbutton()->::proto::HydratedTemplateButton_HydratedCallButton::MergeFrom( + from._internal_callbutton()); + break; + } + case HYDRATEDBUTTON_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:proto.HydratedTemplateButton) +} + +inline void HydratedTemplateButton::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.index_){0u} + , decltype(_impl_.hydratedButton_){} + , /*decltype(_impl_._oneof_case_)*/{} + }; + clear_has_hydratedButton(); +} + +HydratedTemplateButton::~HydratedTemplateButton() { + // @@protoc_insertion_point(destructor:proto.HydratedTemplateButton) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void HydratedTemplateButton::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (has_hydratedButton()) { + clear_hydratedButton(); + } +} + +void HydratedTemplateButton::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void HydratedTemplateButton::clear_hydratedButton() { +// @@protoc_insertion_point(one_of_clear_start:proto.HydratedTemplateButton) + switch (hydratedButton_case()) { + case kQuickReplyButton: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.hydratedButton_.quickreplybutton_; + } + break; + } + case kUrlButton: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.hydratedButton_.urlbutton_; + } + break; + } + case kCallButton: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.hydratedButton_.callbutton_; + } + break; + } + case HYDRATEDBUTTON_NOT_SET: { + break; + } + } + _impl_._oneof_case_[0] = HYDRATEDBUTTON_NOT_SET; +} + + +void HydratedTemplateButton::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.HydratedTemplateButton) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.index_ = 0u; + clear_hydratedButton(); + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* HydratedTemplateButton::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .proto.HydratedTemplateButton.HydratedQuickReplyButton quickReplyButton = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_quickreplybutton(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .proto.HydratedTemplateButton.HydratedURLButton urlButton = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_urlbutton(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .proto.HydratedTemplateButton.HydratedCallButton callButton = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_callbutton(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 index = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_index(&has_bits); + _impl_.index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* HydratedTemplateButton::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.HydratedTemplateButton) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + switch (hydratedButton_case()) { + case kQuickReplyButton: { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::quickreplybutton(this), + _Internal::quickreplybutton(this).GetCachedSize(), target, stream); + break; + } + case kUrlButton: { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::urlbutton(this), + _Internal::urlbutton(this).GetCachedSize(), target, stream); + break; + } + case kCallButton: { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::callbutton(this), + _Internal::callbutton(this).GetCachedSize(), target, stream); + break; + } + default: ; + } + cached_has_bits = _impl_._has_bits_[0]; + // optional uint32 index = 4; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_index(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.HydratedTemplateButton) + return target; +} + +size_t HydratedTemplateButton::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.HydratedTemplateButton) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional uint32 index = 4; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_index()); + } + + switch (hydratedButton_case()) { + // .proto.HydratedTemplateButton.HydratedQuickReplyButton quickReplyButton = 1; + case kQuickReplyButton: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.hydratedButton_.quickreplybutton_); + break; + } + // .proto.HydratedTemplateButton.HydratedURLButton urlButton = 2; + case kUrlButton: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.hydratedButton_.urlbutton_); + break; + } + // .proto.HydratedTemplateButton.HydratedCallButton callButton = 3; + case kCallButton: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.hydratedButton_.callbutton_); + break; + } + case HYDRATEDBUTTON_NOT_SET: { + break; + } + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HydratedTemplateButton::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + HydratedTemplateButton::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HydratedTemplateButton::GetClassData() const { return &_class_data_; } + + +void HydratedTemplateButton::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.HydratedTemplateButton) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_index()) { + _this->_internal_set_index(from._internal_index()); + } + switch (from.hydratedButton_case()) { + case kQuickReplyButton: { + _this->_internal_mutable_quickreplybutton()->::proto::HydratedTemplateButton_HydratedQuickReplyButton::MergeFrom( + from._internal_quickreplybutton()); + break; + } + case kUrlButton: { + _this->_internal_mutable_urlbutton()->::proto::HydratedTemplateButton_HydratedURLButton::MergeFrom( + from._internal_urlbutton()); + break; + } + case kCallButton: { + _this->_internal_mutable_callbutton()->::proto::HydratedTemplateButton_HydratedCallButton::MergeFrom( + from._internal_callbutton()); + break; + } + case HYDRATEDBUTTON_NOT_SET: { + break; + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void HydratedTemplateButton::CopyFrom(const HydratedTemplateButton& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.HydratedTemplateButton) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HydratedTemplateButton::IsInitialized() const { + return true; +} + +void HydratedTemplateButton::InternalSwap(HydratedTemplateButton* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_.index_, other->_impl_.index_); + swap(_impl_.hydratedButton_, other->_impl_.hydratedButton_); + swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HydratedTemplateButton::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[44]); +} + +// =================================================================== + +class IdentityKeyPairStructure::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_publickey(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_privatekey(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +IdentityKeyPairStructure::IdentityKeyPairStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.IdentityKeyPairStructure) +} +IdentityKeyPairStructure::IdentityKeyPairStructure(const IdentityKeyPairStructure& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + IdentityKeyPairStructure* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.publickey_){} + , decltype(_impl_.privatekey_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.publickey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.publickey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_publickey()) { + _this->_impl_.publickey_.Set(from._internal_publickey(), + _this->GetArenaForAllocation()); + } + _impl_.privatekey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.privatekey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_privatekey()) { + _this->_impl_.privatekey_.Set(from._internal_privatekey(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.IdentityKeyPairStructure) +} + +inline void IdentityKeyPairStructure::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.publickey_){} + , decltype(_impl_.privatekey_){} + }; + _impl_.publickey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.publickey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.privatekey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.privatekey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +IdentityKeyPairStructure::~IdentityKeyPairStructure() { + // @@protoc_insertion_point(destructor:proto.IdentityKeyPairStructure) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void IdentityKeyPairStructure::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.publickey_.Destroy(); + _impl_.privatekey_.Destroy(); +} + +void IdentityKeyPairStructure::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void IdentityKeyPairStructure::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.IdentityKeyPairStructure) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.publickey_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.privatekey_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* IdentityKeyPairStructure::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes publicKey = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_publickey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes privateKey = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_privatekey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* IdentityKeyPairStructure::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.IdentityKeyPairStructure) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes publicKey = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_publickey(), target); + } + + // optional bytes privateKey = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_privatekey(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.IdentityKeyPairStructure) + return target; +} + +size_t IdentityKeyPairStructure::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.IdentityKeyPairStructure) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional bytes publicKey = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_publickey()); + } + + // optional bytes privateKey = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_privatekey()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData IdentityKeyPairStructure::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + IdentityKeyPairStructure::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*IdentityKeyPairStructure::GetClassData() const { return &_class_data_; } + + +void IdentityKeyPairStructure::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.IdentityKeyPairStructure) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_publickey(from._internal_publickey()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_privatekey(from._internal_privatekey()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void IdentityKeyPairStructure::CopyFrom(const IdentityKeyPairStructure& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.IdentityKeyPairStructure) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool IdentityKeyPairStructure::IsInitialized() const { + return true; +} + +void IdentityKeyPairStructure::InternalSwap(IdentityKeyPairStructure* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.publickey_, lhs_arena, + &other->_impl_.publickey_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.privatekey_, lhs_arena, + &other->_impl_.privatekey_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata IdentityKeyPairStructure::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[45]); +} + +// =================================================================== + +class InteractiveAnnotation::_Internal { + public: + static const ::proto::Location& location(const InteractiveAnnotation* msg); +}; + +const ::proto::Location& +InteractiveAnnotation::_Internal::location(const InteractiveAnnotation* msg) { + return *msg->_impl_.action_.location_; +} +void InteractiveAnnotation::set_allocated_location(::proto::Location* location) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_action(); + if (location) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(location); + if (message_arena != submessage_arena) { + location = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, location, submessage_arena); + } + set_has_location(); + _impl_.action_.location_ = location; + } + // @@protoc_insertion_point(field_set_allocated:proto.InteractiveAnnotation.location) +} +InteractiveAnnotation::InteractiveAnnotation(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.InteractiveAnnotation) +} +InteractiveAnnotation::InteractiveAnnotation(const InteractiveAnnotation& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + InteractiveAnnotation* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.polygonvertices_){from._impl_.polygonvertices_} + , decltype(_impl_.action_){} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_._oneof_case_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + clear_has_action(); + switch (from.action_case()) { + case kLocation: { + _this->_internal_mutable_location()->::proto::Location::MergeFrom( + from._internal_location()); + break; + } + case ACTION_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:proto.InteractiveAnnotation) +} + +inline void InteractiveAnnotation::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_.polygonvertices_){arena} + , decltype(_impl_.action_){} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_._oneof_case_)*/{} + }; + clear_has_action(); +} + +InteractiveAnnotation::~InteractiveAnnotation() { + // @@protoc_insertion_point(destructor:proto.InteractiveAnnotation) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void InteractiveAnnotation::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.polygonvertices_.~RepeatedPtrField(); + if (has_action()) { + clear_action(); + } +} + +void InteractiveAnnotation::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void InteractiveAnnotation::clear_action() { +// @@protoc_insertion_point(one_of_clear_start:proto.InteractiveAnnotation) + switch (action_case()) { + case kLocation: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.action_.location_; + } + break; + } + case ACTION_NOT_SET: { + break; + } + } + _impl_._oneof_case_[0] = ACTION_NOT_SET; +} + + +void InteractiveAnnotation::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.InteractiveAnnotation) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.polygonvertices_.Clear(); + clear_action(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* InteractiveAnnotation::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .proto.Point polygonVertices = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_polygonvertices(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else + goto handle_unusual; + continue; + // .proto.Location location = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_location(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* InteractiveAnnotation::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.InteractiveAnnotation) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .proto.Point polygonVertices = 1; + for (unsigned i = 0, + n = static_cast(this->_internal_polygonvertices_size()); i < n; i++) { + const auto& repfield = this->_internal_polygonvertices(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream); + } + + // .proto.Location location = 2; + if (_internal_has_location()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::location(this), + _Internal::location(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.InteractiveAnnotation) + return target; +} + +size_t InteractiveAnnotation::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.InteractiveAnnotation) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.Point polygonVertices = 1; + total_size += 1UL * this->_internal_polygonvertices_size(); + for (const auto& msg : this->_impl_.polygonvertices_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + switch (action_case()) { + // .proto.Location location = 2; + case kLocation: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.action_.location_); + break; + } + case ACTION_NOT_SET: { + break; + } + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData InteractiveAnnotation::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + InteractiveAnnotation::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*InteractiveAnnotation::GetClassData() const { return &_class_data_; } + + +void InteractiveAnnotation::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.InteractiveAnnotation) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.polygonvertices_.MergeFrom(from._impl_.polygonvertices_); + switch (from.action_case()) { + case kLocation: { + _this->_internal_mutable_location()->::proto::Location::MergeFrom( + from._internal_location()); + break; + } + case ACTION_NOT_SET: { + break; + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void InteractiveAnnotation::CopyFrom(const InteractiveAnnotation& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.InteractiveAnnotation) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool InteractiveAnnotation::IsInitialized() const { + return true; +} + +void InteractiveAnnotation::InternalSwap(InteractiveAnnotation* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.polygonvertices_.InternalSwap(&other->_impl_.polygonvertices_); + swap(_impl_.action_, other->_impl_.action_); + swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata InteractiveAnnotation::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[46]); +} + +// =================================================================== + +class KeepInChat::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_keeptype(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_servertimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static const ::proto::MessageKey& key(const KeepInChat* msg); + static void set_has_key(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_devicejid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +const ::proto::MessageKey& +KeepInChat::_Internal::key(const KeepInChat* msg) { + return *msg->_impl_.key_; +} +KeepInChat::KeepInChat(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.KeepInChat) +} +KeepInChat::KeepInChat(const KeepInChat& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + KeepInChat* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.devicejid_){} + , decltype(_impl_.key_){nullptr} + , decltype(_impl_.servertimestamp_){} + , decltype(_impl_.keeptype_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.devicejid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.devicejid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_devicejid()) { + _this->_impl_.devicejid_.Set(from._internal_devicejid(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_key()) { + _this->_impl_.key_ = new ::proto::MessageKey(*from._impl_.key_); + } + ::memcpy(&_impl_.servertimestamp_, &from._impl_.servertimestamp_, + static_cast(reinterpret_cast(&_impl_.keeptype_) - + reinterpret_cast(&_impl_.servertimestamp_)) + sizeof(_impl_.keeptype_)); + // @@protoc_insertion_point(copy_constructor:proto.KeepInChat) +} + +inline void KeepInChat::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.devicejid_){} + , decltype(_impl_.key_){nullptr} + , decltype(_impl_.servertimestamp_){int64_t{0}} + , decltype(_impl_.keeptype_){0} + }; + _impl_.devicejid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.devicejid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +KeepInChat::~KeepInChat() { + // @@protoc_insertion_point(destructor:proto.KeepInChat) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void KeepInChat::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.devicejid_.Destroy(); + if (this != internal_default_instance()) delete _impl_.key_; +} + +void KeepInChat::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void KeepInChat::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.KeepInChat) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.devicejid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.key_ != nullptr); + _impl_.key_->Clear(); + } + } + if (cached_has_bits & 0x0000000cu) { + ::memset(&_impl_.servertimestamp_, 0, static_cast( + reinterpret_cast(&_impl_.keeptype_) - + reinterpret_cast(&_impl_.servertimestamp_)) + sizeof(_impl_.keeptype_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* KeepInChat::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.KeepType keepType = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::KeepType_IsValid(val))) { + _internal_set_keeptype(static_cast<::proto::KeepType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional int64 serverTimestamp = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_servertimestamp(&has_bits); + _impl_.servertimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.MessageKey key = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string deviceJid = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_devicejid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.KeepInChat.deviceJid"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* KeepInChat::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.KeepInChat) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.KeepType keepType = 1; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this->_internal_keeptype(), target); + } + + // optional int64 serverTimestamp = 2; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_servertimestamp(), target); + } + + // optional .proto.MessageKey key = 3; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::key(this), + _Internal::key(this).GetCachedSize(), target, stream); + } + + // optional string deviceJid = 4; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_devicejid().data(), static_cast(this->_internal_devicejid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.KeepInChat.deviceJid"); + target = stream->WriteStringMaybeAliased( + 4, this->_internal_devicejid(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.KeepInChat) + return target; +} + +size_t KeepInChat::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.KeepInChat) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional string deviceJid = 4; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_devicejid()); + } + + // optional .proto.MessageKey key = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.key_); + } + + // optional int64 serverTimestamp = 2; + if (cached_has_bits & 0x00000004u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_servertimestamp()); + } + + // optional .proto.KeepType keepType = 1; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_keeptype()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData KeepInChat::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + KeepInChat::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*KeepInChat::GetClassData() const { return &_class_data_; } + + +void KeepInChat::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.KeepInChat) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_devicejid(from._internal_devicejid()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_key()->::proto::MessageKey::MergeFrom( + from._internal_key()); + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.servertimestamp_ = from._impl_.servertimestamp_; + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.keeptype_ = from._impl_.keeptype_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void KeepInChat::CopyFrom(const KeepInChat& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.KeepInChat) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool KeepInChat::IsInitialized() const { + return true; +} + +void KeepInChat::InternalSwap(KeepInChat* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.devicejid_, lhs_arena, + &other->_impl_.devicejid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(KeepInChat, _impl_.keeptype_) + + sizeof(KeepInChat::_impl_.keeptype_) + - PROTOBUF_FIELD_OFFSET(KeepInChat, _impl_.key_)>( + reinterpret_cast(&_impl_.key_), + reinterpret_cast(&other->_impl_.key_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata KeepInChat::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[47]); +} + +// =================================================================== + +class KeyId::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_id(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +KeyId::KeyId(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.KeyId) +} +KeyId::KeyId(const KeyId& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + KeyId* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.id_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.id_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.id_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_id()) { + _this->_impl_.id_.Set(from._internal_id(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.KeyId) +} + +inline void KeyId::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.id_){} + }; + _impl_.id_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.id_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +KeyId::~KeyId() { + // @@protoc_insertion_point(destructor:proto.KeyId) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void KeyId::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.id_.Destroy(); +} + +void KeyId::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void KeyId::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.KeyId) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.id_.ClearNonDefaultToEmpty(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* KeyId::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_id(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* KeyId::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.KeyId) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes id = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.KeyId) + return target; +} + +size_t KeyId::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.KeyId) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional bytes id = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_id()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData KeyId::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + KeyId::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*KeyId::GetClassData() const { return &_class_data_; } + + +void KeyId::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.KeyId) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_id()) { + _this->_internal_set_id(from._internal_id()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void KeyId::CopyFrom(const KeyId& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.KeyId) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool KeyId::IsInitialized() const { + return true; +} + +void KeyId::InternalSwap(KeyId* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.id_, lhs_arena, + &other->_impl_.id_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata KeyId::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[48]); +} + +// =================================================================== + +class LocalizedName::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_lg(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_lc(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_verifiedname(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +LocalizedName::LocalizedName(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.LocalizedName) +} +LocalizedName::LocalizedName(const LocalizedName& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + LocalizedName* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.lg_){} + , decltype(_impl_.lc_){} + , decltype(_impl_.verifiedname_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.lg_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.lg_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_lg()) { + _this->_impl_.lg_.Set(from._internal_lg(), + _this->GetArenaForAllocation()); + } + _impl_.lc_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.lc_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_lc()) { + _this->_impl_.lc_.Set(from._internal_lc(), + _this->GetArenaForAllocation()); + } + _impl_.verifiedname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.verifiedname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_verifiedname()) { + _this->_impl_.verifiedname_.Set(from._internal_verifiedname(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.LocalizedName) +} + +inline void LocalizedName::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.lg_){} + , decltype(_impl_.lc_){} + , decltype(_impl_.verifiedname_){} + }; + _impl_.lg_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.lg_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.lc_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.lc_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.verifiedname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.verifiedname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +LocalizedName::~LocalizedName() { + // @@protoc_insertion_point(destructor:proto.LocalizedName) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void LocalizedName::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.lg_.Destroy(); + _impl_.lc_.Destroy(); + _impl_.verifiedname_.Destroy(); +} + +void LocalizedName::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void LocalizedName::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.LocalizedName) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _impl_.lg_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.lc_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.verifiedname_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* LocalizedName::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string lg = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_lg(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.LocalizedName.lg"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string lc = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_lc(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.LocalizedName.lc"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string verifiedName = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_verifiedname(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.LocalizedName.verifiedName"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* LocalizedName::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.LocalizedName) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string lg = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_lg().data(), static_cast(this->_internal_lg().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.LocalizedName.lg"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_lg(), target); + } + + // optional string lc = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_lc().data(), static_cast(this->_internal_lc().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.LocalizedName.lc"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_lc(), target); + } + + // optional string verifiedName = 3; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_verifiedname().data(), static_cast(this->_internal_verifiedname().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.LocalizedName.verifiedName"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_verifiedname(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.LocalizedName) + return target; +} + +size_t LocalizedName::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.LocalizedName) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional string lg = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_lg()); + } + + // optional string lc = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_lc()); + } + + // optional string verifiedName = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_verifiedname()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData LocalizedName::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + LocalizedName::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*LocalizedName::GetClassData() const { return &_class_data_; } + + +void LocalizedName::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.LocalizedName) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_lg(from._internal_lg()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_lc(from._internal_lc()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_verifiedname(from._internal_verifiedname()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void LocalizedName::CopyFrom(const LocalizedName& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.LocalizedName) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool LocalizedName::IsInitialized() const { + return true; +} + +void LocalizedName::InternalSwap(LocalizedName* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.lg_, lhs_arena, + &other->_impl_.lg_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.lc_, lhs_arena, + &other->_impl_.lc_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.verifiedname_, lhs_arena, + &other->_impl_.verifiedname_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata LocalizedName::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[49]); +} + +// =================================================================== + +class Location::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_degreeslatitude(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_degreeslongitude(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_name(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +Location::Location(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Location) +} +Location::Location(const Location& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Location* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.name_){} + , decltype(_impl_.degreeslatitude_){} + , decltype(_impl_.degreeslongitude_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.name_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.name_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_name()) { + _this->_impl_.name_.Set(from._internal_name(), + _this->GetArenaForAllocation()); + } + ::memcpy(&_impl_.degreeslatitude_, &from._impl_.degreeslatitude_, + static_cast(reinterpret_cast(&_impl_.degreeslongitude_) - + reinterpret_cast(&_impl_.degreeslatitude_)) + sizeof(_impl_.degreeslongitude_)); + // @@protoc_insertion_point(copy_constructor:proto.Location) +} + +inline void Location::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.name_){} + , decltype(_impl_.degreeslatitude_){0} + , decltype(_impl_.degreeslongitude_){0} + }; + _impl_.name_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.name_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Location::~Location() { + // @@protoc_insertion_point(destructor:proto.Location) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Location::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.name_.Destroy(); +} + +void Location::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Location::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Location) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000006u) { + ::memset(&_impl_.degreeslatitude_, 0, static_cast( + reinterpret_cast(&_impl_.degreeslongitude_) - + reinterpret_cast(&_impl_.degreeslatitude_)) + sizeof(_impl_.degreeslongitude_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Location::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional double degreesLatitude = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 9)) { + _Internal::set_has_degreeslatitude(&has_bits); + _impl_.degreeslatitude_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(double); + } else + goto handle_unusual; + continue; + // optional double degreesLongitude = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 17)) { + _Internal::set_has_degreeslongitude(&has_bits); + _impl_.degreeslongitude_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(double); + } else + goto handle_unusual; + continue; + // optional string name = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_name(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Location.name"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Location::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Location) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional double degreesLatitude = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray(1, this->_internal_degreeslatitude(), target); + } + + // optional double degreesLongitude = 2; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray(2, this->_internal_degreeslongitude(), target); + } + + // optional string name = 3; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Location.name"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_name(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Location) + return target; +} + +size_t Location::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Location) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional string name = 3; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // optional double degreesLatitude = 1; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 8; + } + + // optional double degreesLongitude = 2; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 8; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Location::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Location::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Location::GetClassData() const { return &_class_data_; } + + +void Location::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Location) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_name(from._internal_name()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.degreeslatitude_ = from._impl_.degreeslatitude_; + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.degreeslongitude_ = from._impl_.degreeslongitude_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Location::CopyFrom(const Location& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Location) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Location::IsInitialized() const { + return true; +} + +void Location::InternalSwap(Location* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.name_, lhs_arena, + &other->_impl_.name_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Location, _impl_.degreeslongitude_) + + sizeof(Location::_impl_.degreeslongitude_) + - PROTOBUF_FIELD_OFFSET(Location, _impl_.degreeslatitude_)>( + reinterpret_cast(&_impl_.degreeslatitude_), + reinterpret_cast(&other->_impl_.degreeslatitude_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Location::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[50]); +} + +// =================================================================== + +class MediaData::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_localpath(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +MediaData::MediaData(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.MediaData) +} +MediaData::MediaData(const MediaData& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + MediaData* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.localpath_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.localpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.localpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_localpath()) { + _this->_impl_.localpath_.Set(from._internal_localpath(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.MediaData) +} + +inline void MediaData::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.localpath_){} + }; + _impl_.localpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.localpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +MediaData::~MediaData() { + // @@protoc_insertion_point(destructor:proto.MediaData) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void MediaData::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.localpath_.Destroy(); +} + +void MediaData::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void MediaData::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.MediaData) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.localpath_.ClearNonDefaultToEmpty(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* MediaData::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string localPath = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_localpath(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.MediaData.localPath"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* MediaData::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.MediaData) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string localPath = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_localpath().data(), static_cast(this->_internal_localpath().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.MediaData.localPath"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_localpath(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.MediaData) + return target; +} + +size_t MediaData::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.MediaData) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional string localPath = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_localpath()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MediaData::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + MediaData::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MediaData::GetClassData() const { return &_class_data_; } + + +void MediaData::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.MediaData) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_localpath()) { + _this->_internal_set_localpath(from._internal_localpath()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void MediaData::CopyFrom(const MediaData& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.MediaData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MediaData::IsInitialized() const { + return true; +} + +void MediaData::InternalSwap(MediaData* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.localpath_, lhs_arena, + &other->_impl_.localpath_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata MediaData::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[51]); +} + +// =================================================================== + +class MediaRetryNotification::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_stanzaid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_directpath(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_result(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +MediaRetryNotification::MediaRetryNotification(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.MediaRetryNotification) +} +MediaRetryNotification::MediaRetryNotification(const MediaRetryNotification& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + MediaRetryNotification* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.stanzaid_){} + , decltype(_impl_.directpath_){} + , decltype(_impl_.result_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.stanzaid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.stanzaid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_stanzaid()) { + _this->_impl_.stanzaid_.Set(from._internal_stanzaid(), + _this->GetArenaForAllocation()); + } + _impl_.directpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_directpath()) { + _this->_impl_.directpath_.Set(from._internal_directpath(), + _this->GetArenaForAllocation()); + } + _this->_impl_.result_ = from._impl_.result_; + // @@protoc_insertion_point(copy_constructor:proto.MediaRetryNotification) +} + +inline void MediaRetryNotification::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.stanzaid_){} + , decltype(_impl_.directpath_){} + , decltype(_impl_.result_){0} + }; + _impl_.stanzaid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.stanzaid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +MediaRetryNotification::~MediaRetryNotification() { + // @@protoc_insertion_point(destructor:proto.MediaRetryNotification) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void MediaRetryNotification::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.stanzaid_.Destroy(); + _impl_.directpath_.Destroy(); +} + +void MediaRetryNotification::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void MediaRetryNotification::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.MediaRetryNotification) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.stanzaid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.directpath_.ClearNonDefaultToEmpty(); + } + } + _impl_.result_ = 0; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* MediaRetryNotification::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string stanzaId = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_stanzaid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.MediaRetryNotification.stanzaId"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string directPath = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_directpath(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.MediaRetryNotification.directPath"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.MediaRetryNotification.ResultType result = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::MediaRetryNotification_ResultType_IsValid(val))) { + _internal_set_result(static_cast<::proto::MediaRetryNotification_ResultType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* MediaRetryNotification::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.MediaRetryNotification) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string stanzaId = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_stanzaid().data(), static_cast(this->_internal_stanzaid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.MediaRetryNotification.stanzaId"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_stanzaid(), target); + } + + // optional string directPath = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_directpath().data(), static_cast(this->_internal_directpath().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.MediaRetryNotification.directPath"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_directpath(), target); + } + + // optional .proto.MediaRetryNotification.ResultType result = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 3, this->_internal_result(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.MediaRetryNotification) + return target; +} + +size_t MediaRetryNotification::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.MediaRetryNotification) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional string stanzaId = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_stanzaid()); + } + + // optional string directPath = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_directpath()); + } + + // optional .proto.MediaRetryNotification.ResultType result = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_result()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MediaRetryNotification::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + MediaRetryNotification::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MediaRetryNotification::GetClassData() const { return &_class_data_; } + + +void MediaRetryNotification::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.MediaRetryNotification) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_stanzaid(from._internal_stanzaid()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_directpath(from._internal_directpath()); + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.result_ = from._impl_.result_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void MediaRetryNotification::CopyFrom(const MediaRetryNotification& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.MediaRetryNotification) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MediaRetryNotification::IsInitialized() const { + return true; +} + +void MediaRetryNotification::InternalSwap(MediaRetryNotification* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.stanzaid_, lhs_arena, + &other->_impl_.stanzaid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.directpath_, lhs_arena, + &other->_impl_.directpath_, rhs_arena + ); + swap(_impl_.result_, other->_impl_.result_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata MediaRetryNotification::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[52]); +} + +// =================================================================== + +class Message_AppStateFatalExceptionNotification::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_timestamp(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +Message_AppStateFatalExceptionNotification::Message_AppStateFatalExceptionNotification(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.AppStateFatalExceptionNotification) +} +Message_AppStateFatalExceptionNotification::Message_AppStateFatalExceptionNotification(const Message_AppStateFatalExceptionNotification& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_AppStateFatalExceptionNotification* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.collectionnames_){from._impl_.collectionnames_} + , decltype(_impl_.timestamp_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _this->_impl_.timestamp_ = from._impl_.timestamp_; + // @@protoc_insertion_point(copy_constructor:proto.Message.AppStateFatalExceptionNotification) +} + +inline void Message_AppStateFatalExceptionNotification::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.collectionnames_){arena} + , decltype(_impl_.timestamp_){int64_t{0}} + }; +} + +Message_AppStateFatalExceptionNotification::~Message_AppStateFatalExceptionNotification() { + // @@protoc_insertion_point(destructor:proto.Message.AppStateFatalExceptionNotification) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_AppStateFatalExceptionNotification::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.collectionnames_.~RepeatedPtrField(); +} + +void Message_AppStateFatalExceptionNotification::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_AppStateFatalExceptionNotification::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.AppStateFatalExceptionNotification) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.collectionnames_.Clear(); + _impl_.timestamp_ = int64_t{0}; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_AppStateFatalExceptionNotification::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated string collectionNames = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_collectionnames(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.AppStateFatalExceptionNotification.collectionNames"); + #endif // !NDEBUG + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else + goto handle_unusual; + continue; + // optional int64 timestamp = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_timestamp(&has_bits); + _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_AppStateFatalExceptionNotification::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.AppStateFatalExceptionNotification) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated string collectionNames = 1; + for (int i = 0, n = this->_internal_collectionnames_size(); i < n; i++) { + const auto& s = this->_internal_collectionnames(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.AppStateFatalExceptionNotification.collectionNames"); + target = stream->WriteString(1, s, target); + } + + cached_has_bits = _impl_._has_bits_[0]; + // optional int64 timestamp = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_timestamp(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.AppStateFatalExceptionNotification) + return target; +} + +size_t Message_AppStateFatalExceptionNotification::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.AppStateFatalExceptionNotification) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string collectionNames = 1; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.collectionnames_.size()); + for (int i = 0, n = _impl_.collectionnames_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + _impl_.collectionnames_.Get(i)); + } + + // optional int64 timestamp = 2; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_timestamp()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_AppStateFatalExceptionNotification::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_AppStateFatalExceptionNotification::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_AppStateFatalExceptionNotification::GetClassData() const { return &_class_data_; } + + +void Message_AppStateFatalExceptionNotification::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.AppStateFatalExceptionNotification) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.collectionnames_.MergeFrom(from._impl_.collectionnames_); + if (from._internal_has_timestamp()) { + _this->_internal_set_timestamp(from._internal_timestamp()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_AppStateFatalExceptionNotification::CopyFrom(const Message_AppStateFatalExceptionNotification& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.AppStateFatalExceptionNotification) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_AppStateFatalExceptionNotification::IsInitialized() const { + return true; +} + +void Message_AppStateFatalExceptionNotification::InternalSwap(Message_AppStateFatalExceptionNotification* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.collectionnames_.InternalSwap(&other->_impl_.collectionnames_); + swap(_impl_.timestamp_, other->_impl_.timestamp_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_AppStateFatalExceptionNotification::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[53]); +} + +// =================================================================== + +class Message_AppStateSyncKeyData::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_keydata(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::proto::Message_AppStateSyncKeyFingerprint& fingerprint(const Message_AppStateSyncKeyData* msg); + static void set_has_fingerprint(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_timestamp(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +const ::proto::Message_AppStateSyncKeyFingerprint& +Message_AppStateSyncKeyData::_Internal::fingerprint(const Message_AppStateSyncKeyData* msg) { + return *msg->_impl_.fingerprint_; +} +Message_AppStateSyncKeyData::Message_AppStateSyncKeyData(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.AppStateSyncKeyData) +} +Message_AppStateSyncKeyData::Message_AppStateSyncKeyData(const Message_AppStateSyncKeyData& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_AppStateSyncKeyData* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.keydata_){} + , decltype(_impl_.fingerprint_){nullptr} + , decltype(_impl_.timestamp_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.keydata_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.keydata_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_keydata()) { + _this->_impl_.keydata_.Set(from._internal_keydata(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_fingerprint()) { + _this->_impl_.fingerprint_ = new ::proto::Message_AppStateSyncKeyFingerprint(*from._impl_.fingerprint_); + } + _this->_impl_.timestamp_ = from._impl_.timestamp_; + // @@protoc_insertion_point(copy_constructor:proto.Message.AppStateSyncKeyData) +} + +inline void Message_AppStateSyncKeyData::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.keydata_){} + , decltype(_impl_.fingerprint_){nullptr} + , decltype(_impl_.timestamp_){int64_t{0}} + }; + _impl_.keydata_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.keydata_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_AppStateSyncKeyData::~Message_AppStateSyncKeyData() { + // @@protoc_insertion_point(destructor:proto.Message.AppStateSyncKeyData) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_AppStateSyncKeyData::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.keydata_.Destroy(); + if (this != internal_default_instance()) delete _impl_.fingerprint_; +} + +void Message_AppStateSyncKeyData::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_AppStateSyncKeyData::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.AppStateSyncKeyData) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.keydata_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.fingerprint_ != nullptr); + _impl_.fingerprint_->Clear(); + } + } + _impl_.timestamp_ = int64_t{0}; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_AppStateSyncKeyData::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes keyData = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_keydata(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.AppStateSyncKeyFingerprint fingerprint = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_fingerprint(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 timestamp = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_timestamp(&has_bits); + _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_AppStateSyncKeyData::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.AppStateSyncKeyData) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes keyData = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_keydata(), target); + } + + // optional .proto.Message.AppStateSyncKeyFingerprint fingerprint = 2; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::fingerprint(this), + _Internal::fingerprint(this).GetCachedSize(), target, stream); + } + + // optional int64 timestamp = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_timestamp(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.AppStateSyncKeyData) + return target; +} + +size_t Message_AppStateSyncKeyData::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.AppStateSyncKeyData) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional bytes keyData = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_keydata()); + } + + // optional .proto.Message.AppStateSyncKeyFingerprint fingerprint = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.fingerprint_); + } + + // optional int64 timestamp = 3; + if (cached_has_bits & 0x00000004u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_timestamp()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_AppStateSyncKeyData::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_AppStateSyncKeyData::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_AppStateSyncKeyData::GetClassData() const { return &_class_data_; } + + +void Message_AppStateSyncKeyData::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.AppStateSyncKeyData) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_keydata(from._internal_keydata()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_fingerprint()->::proto::Message_AppStateSyncKeyFingerprint::MergeFrom( + from._internal_fingerprint()); + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.timestamp_ = from._impl_.timestamp_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_AppStateSyncKeyData::CopyFrom(const Message_AppStateSyncKeyData& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.AppStateSyncKeyData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_AppStateSyncKeyData::IsInitialized() const { + return true; +} + +void Message_AppStateSyncKeyData::InternalSwap(Message_AppStateSyncKeyData* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.keydata_, lhs_arena, + &other->_impl_.keydata_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_AppStateSyncKeyData, _impl_.timestamp_) + + sizeof(Message_AppStateSyncKeyData::_impl_.timestamp_) + - PROTOBUF_FIELD_OFFSET(Message_AppStateSyncKeyData, _impl_.fingerprint_)>( + reinterpret_cast(&_impl_.fingerprint_), + reinterpret_cast(&other->_impl_.fingerprint_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_AppStateSyncKeyData::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[54]); +} + +// =================================================================== + +class Message_AppStateSyncKeyFingerprint::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_rawid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_currentindex(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +Message_AppStateSyncKeyFingerprint::Message_AppStateSyncKeyFingerprint(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.AppStateSyncKeyFingerprint) +} +Message_AppStateSyncKeyFingerprint::Message_AppStateSyncKeyFingerprint(const Message_AppStateSyncKeyFingerprint& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_AppStateSyncKeyFingerprint* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.deviceindexes_){from._impl_.deviceindexes_} + , /*decltype(_impl_._deviceindexes_cached_byte_size_)*/{0} + , decltype(_impl_.rawid_){} + , decltype(_impl_.currentindex_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&_impl_.rawid_, &from._impl_.rawid_, + static_cast(reinterpret_cast(&_impl_.currentindex_) - + reinterpret_cast(&_impl_.rawid_)) + sizeof(_impl_.currentindex_)); + // @@protoc_insertion_point(copy_constructor:proto.Message.AppStateSyncKeyFingerprint) +} + +inline void Message_AppStateSyncKeyFingerprint::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.deviceindexes_){arena} + , /*decltype(_impl_._deviceindexes_cached_byte_size_)*/{0} + , decltype(_impl_.rawid_){0u} + , decltype(_impl_.currentindex_){0u} + }; +} + +Message_AppStateSyncKeyFingerprint::~Message_AppStateSyncKeyFingerprint() { + // @@protoc_insertion_point(destructor:proto.Message.AppStateSyncKeyFingerprint) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_AppStateSyncKeyFingerprint::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.deviceindexes_.~RepeatedField(); +} + +void Message_AppStateSyncKeyFingerprint::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_AppStateSyncKeyFingerprint::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.AppStateSyncKeyFingerprint) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.deviceindexes_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + ::memset(&_impl_.rawid_, 0, static_cast( + reinterpret_cast(&_impl_.currentindex_) - + reinterpret_cast(&_impl_.rawid_)) + sizeof(_impl_.currentindex_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_AppStateSyncKeyFingerprint::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint32 rawId = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_rawid(&has_bits); + _impl_.rawid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 currentIndex = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_currentindex(&has_bits); + _impl_.currentindex_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated uint32 deviceIndexes = 3 [packed = true]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_deviceindexes(), ptr, ctx); + CHK_(ptr); + } else if (static_cast(tag) == 24) { + _internal_add_deviceindexes(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_AppStateSyncKeyFingerprint::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.AppStateSyncKeyFingerprint) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional uint32 rawId = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_rawid(), target); + } + + // optional uint32 currentIndex = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_currentindex(), target); + } + + // repeated uint32 deviceIndexes = 3 [packed = true]; + { + int byte_size = _impl_._deviceindexes_cached_byte_size_.load(std::memory_order_relaxed); + if (byte_size > 0) { + target = stream->WriteUInt32Packed( + 3, _internal_deviceindexes(), byte_size, target); + } + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.AppStateSyncKeyFingerprint) + return target; +} + +size_t Message_AppStateSyncKeyFingerprint::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.AppStateSyncKeyFingerprint) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated uint32 deviceIndexes = 3 [packed = true]; + { + size_t data_size = ::_pbi::WireFormatLite:: + UInt32Size(this->_impl_.deviceindexes_); + if (data_size > 0) { + total_size += 1 + + ::_pbi::WireFormatLite::Int32Size(static_cast(data_size)); + } + int cached_size = ::_pbi::ToCachedSize(data_size); + _impl_._deviceindexes_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional uint32 rawId = 1; + if (cached_has_bits & 0x00000001u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_rawid()); + } + + // optional uint32 currentIndex = 2; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_currentindex()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_AppStateSyncKeyFingerprint::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_AppStateSyncKeyFingerprint::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_AppStateSyncKeyFingerprint::GetClassData() const { return &_class_data_; } + + +void Message_AppStateSyncKeyFingerprint::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.AppStateSyncKeyFingerprint) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.deviceindexes_.MergeFrom(from._impl_.deviceindexes_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_impl_.rawid_ = from._impl_.rawid_; + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.currentindex_ = from._impl_.currentindex_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_AppStateSyncKeyFingerprint::CopyFrom(const Message_AppStateSyncKeyFingerprint& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.AppStateSyncKeyFingerprint) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_AppStateSyncKeyFingerprint::IsInitialized() const { + return true; +} + +void Message_AppStateSyncKeyFingerprint::InternalSwap(Message_AppStateSyncKeyFingerprint* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.deviceindexes_.InternalSwap(&other->_impl_.deviceindexes_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_AppStateSyncKeyFingerprint, _impl_.currentindex_) + + sizeof(Message_AppStateSyncKeyFingerprint::_impl_.currentindex_) + - PROTOBUF_FIELD_OFFSET(Message_AppStateSyncKeyFingerprint, _impl_.rawid_)>( + reinterpret_cast(&_impl_.rawid_), + reinterpret_cast(&other->_impl_.rawid_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_AppStateSyncKeyFingerprint::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[55]); +} + +// =================================================================== + +class Message_AppStateSyncKeyId::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_keyid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +Message_AppStateSyncKeyId::Message_AppStateSyncKeyId(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.AppStateSyncKeyId) +} +Message_AppStateSyncKeyId::Message_AppStateSyncKeyId(const Message_AppStateSyncKeyId& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_AppStateSyncKeyId* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.keyid_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.keyid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.keyid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_keyid()) { + _this->_impl_.keyid_.Set(from._internal_keyid(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.Message.AppStateSyncKeyId) +} + +inline void Message_AppStateSyncKeyId::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.keyid_){} + }; + _impl_.keyid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.keyid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_AppStateSyncKeyId::~Message_AppStateSyncKeyId() { + // @@protoc_insertion_point(destructor:proto.Message.AppStateSyncKeyId) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_AppStateSyncKeyId::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.keyid_.Destroy(); +} + +void Message_AppStateSyncKeyId::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_AppStateSyncKeyId::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.AppStateSyncKeyId) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.keyid_.ClearNonDefaultToEmpty(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_AppStateSyncKeyId::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes keyId = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_keyid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_AppStateSyncKeyId::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.AppStateSyncKeyId) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes keyId = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_keyid(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.AppStateSyncKeyId) + return target; +} + +size_t Message_AppStateSyncKeyId::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.AppStateSyncKeyId) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional bytes keyId = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_keyid()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_AppStateSyncKeyId::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_AppStateSyncKeyId::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_AppStateSyncKeyId::GetClassData() const { return &_class_data_; } + + +void Message_AppStateSyncKeyId::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.AppStateSyncKeyId) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_keyid()) { + _this->_internal_set_keyid(from._internal_keyid()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_AppStateSyncKeyId::CopyFrom(const Message_AppStateSyncKeyId& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.AppStateSyncKeyId) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_AppStateSyncKeyId::IsInitialized() const { + return true; +} + +void Message_AppStateSyncKeyId::InternalSwap(Message_AppStateSyncKeyId* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.keyid_, lhs_arena, + &other->_impl_.keyid_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_AppStateSyncKeyId::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[56]); +} + +// =================================================================== + +class Message_AppStateSyncKeyRequest::_Internal { + public: +}; + +Message_AppStateSyncKeyRequest::Message_AppStateSyncKeyRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.AppStateSyncKeyRequest) +} +Message_AppStateSyncKeyRequest::Message_AppStateSyncKeyRequest(const Message_AppStateSyncKeyRequest& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_AppStateSyncKeyRequest* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.keyids_){from._impl_.keyids_} + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:proto.Message.AppStateSyncKeyRequest) +} + +inline void Message_AppStateSyncKeyRequest::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_.keyids_){arena} + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +Message_AppStateSyncKeyRequest::~Message_AppStateSyncKeyRequest() { + // @@protoc_insertion_point(destructor:proto.Message.AppStateSyncKeyRequest) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_AppStateSyncKeyRequest::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.keyids_.~RepeatedPtrField(); +} + +void Message_AppStateSyncKeyRequest::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_AppStateSyncKeyRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.AppStateSyncKeyRequest) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.keyids_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_AppStateSyncKeyRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .proto.Message.AppStateSyncKeyId keyIds = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_keyids(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_AppStateSyncKeyRequest::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.AppStateSyncKeyRequest) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .proto.Message.AppStateSyncKeyId keyIds = 1; + for (unsigned i = 0, + n = static_cast(this->_internal_keyids_size()); i < n; i++) { + const auto& repfield = this->_internal_keyids(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.AppStateSyncKeyRequest) + return target; +} + +size_t Message_AppStateSyncKeyRequest::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.AppStateSyncKeyRequest) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.Message.AppStateSyncKeyId keyIds = 1; + total_size += 1UL * this->_internal_keyids_size(); + for (const auto& msg : this->_impl_.keyids_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_AppStateSyncKeyRequest::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_AppStateSyncKeyRequest::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_AppStateSyncKeyRequest::GetClassData() const { return &_class_data_; } + + +void Message_AppStateSyncKeyRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.AppStateSyncKeyRequest) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.keyids_.MergeFrom(from._impl_.keyids_); + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_AppStateSyncKeyRequest::CopyFrom(const Message_AppStateSyncKeyRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.AppStateSyncKeyRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_AppStateSyncKeyRequest::IsInitialized() const { + return true; +} + +void Message_AppStateSyncKeyRequest::InternalSwap(Message_AppStateSyncKeyRequest* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.keyids_.InternalSwap(&other->_impl_.keyids_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_AppStateSyncKeyRequest::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[57]); +} + +// =================================================================== + +class Message_AppStateSyncKeyShare::_Internal { + public: +}; + +Message_AppStateSyncKeyShare::Message_AppStateSyncKeyShare(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.AppStateSyncKeyShare) +} +Message_AppStateSyncKeyShare::Message_AppStateSyncKeyShare(const Message_AppStateSyncKeyShare& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_AppStateSyncKeyShare* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.keys_){from._impl_.keys_} + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:proto.Message.AppStateSyncKeyShare) +} + +inline void Message_AppStateSyncKeyShare::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_.keys_){arena} + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +Message_AppStateSyncKeyShare::~Message_AppStateSyncKeyShare() { + // @@protoc_insertion_point(destructor:proto.Message.AppStateSyncKeyShare) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_AppStateSyncKeyShare::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.keys_.~RepeatedPtrField(); +} + +void Message_AppStateSyncKeyShare::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_AppStateSyncKeyShare::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.AppStateSyncKeyShare) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.keys_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_AppStateSyncKeyShare::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .proto.Message.AppStateSyncKey keys = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_keys(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_AppStateSyncKeyShare::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.AppStateSyncKeyShare) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .proto.Message.AppStateSyncKey keys = 1; + for (unsigned i = 0, + n = static_cast(this->_internal_keys_size()); i < n; i++) { + const auto& repfield = this->_internal_keys(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.AppStateSyncKeyShare) + return target; +} + +size_t Message_AppStateSyncKeyShare::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.AppStateSyncKeyShare) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.Message.AppStateSyncKey keys = 1; + total_size += 1UL * this->_internal_keys_size(); + for (const auto& msg : this->_impl_.keys_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_AppStateSyncKeyShare::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_AppStateSyncKeyShare::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_AppStateSyncKeyShare::GetClassData() const { return &_class_data_; } + + +void Message_AppStateSyncKeyShare::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.AppStateSyncKeyShare) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.keys_.MergeFrom(from._impl_.keys_); + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_AppStateSyncKeyShare::CopyFrom(const Message_AppStateSyncKeyShare& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.AppStateSyncKeyShare) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_AppStateSyncKeyShare::IsInitialized() const { + return true; +} + +void Message_AppStateSyncKeyShare::InternalSwap(Message_AppStateSyncKeyShare* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.keys_.InternalSwap(&other->_impl_.keys_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_AppStateSyncKeyShare::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[58]); +} + +// =================================================================== + +class Message_AppStateSyncKey::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::Message_AppStateSyncKeyId& keyid(const Message_AppStateSyncKey* msg); + static void set_has_keyid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::proto::Message_AppStateSyncKeyData& keydata(const Message_AppStateSyncKey* msg); + static void set_has_keydata(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::proto::Message_AppStateSyncKeyId& +Message_AppStateSyncKey::_Internal::keyid(const Message_AppStateSyncKey* msg) { + return *msg->_impl_.keyid_; +} +const ::proto::Message_AppStateSyncKeyData& +Message_AppStateSyncKey::_Internal::keydata(const Message_AppStateSyncKey* msg) { + return *msg->_impl_.keydata_; +} +Message_AppStateSyncKey::Message_AppStateSyncKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.AppStateSyncKey) +} +Message_AppStateSyncKey::Message_AppStateSyncKey(const Message_AppStateSyncKey& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_AppStateSyncKey* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.keyid_){nullptr} + , decltype(_impl_.keydata_){nullptr}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_keyid()) { + _this->_impl_.keyid_ = new ::proto::Message_AppStateSyncKeyId(*from._impl_.keyid_); + } + if (from._internal_has_keydata()) { + _this->_impl_.keydata_ = new ::proto::Message_AppStateSyncKeyData(*from._impl_.keydata_); + } + // @@protoc_insertion_point(copy_constructor:proto.Message.AppStateSyncKey) +} + +inline void Message_AppStateSyncKey::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.keyid_){nullptr} + , decltype(_impl_.keydata_){nullptr} + }; +} + +Message_AppStateSyncKey::~Message_AppStateSyncKey() { + // @@protoc_insertion_point(destructor:proto.Message.AppStateSyncKey) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_AppStateSyncKey::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.keyid_; + if (this != internal_default_instance()) delete _impl_.keydata_; +} + +void Message_AppStateSyncKey::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_AppStateSyncKey::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.AppStateSyncKey) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.keyid_ != nullptr); + _impl_.keyid_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.keydata_ != nullptr); + _impl_.keydata_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_AppStateSyncKey::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.Message.AppStateSyncKeyId keyId = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_keyid(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.AppStateSyncKeyData keyData = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_keydata(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_AppStateSyncKey::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.AppStateSyncKey) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.Message.AppStateSyncKeyId keyId = 1; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::keyid(this), + _Internal::keyid(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.AppStateSyncKeyData keyData = 2; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::keydata(this), + _Internal::keydata(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.AppStateSyncKey) + return target; +} + +size_t Message_AppStateSyncKey::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.AppStateSyncKey) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional .proto.Message.AppStateSyncKeyId keyId = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.keyid_); + } + + // optional .proto.Message.AppStateSyncKeyData keyData = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.keydata_); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_AppStateSyncKey::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_AppStateSyncKey::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_AppStateSyncKey::GetClassData() const { return &_class_data_; } + + +void Message_AppStateSyncKey::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.AppStateSyncKey) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_keyid()->::proto::Message_AppStateSyncKeyId::MergeFrom( + from._internal_keyid()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_keydata()->::proto::Message_AppStateSyncKeyData::MergeFrom( + from._internal_keydata()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_AppStateSyncKey::CopyFrom(const Message_AppStateSyncKey& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.AppStateSyncKey) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_AppStateSyncKey::IsInitialized() const { + return true; +} + +void Message_AppStateSyncKey::InternalSwap(Message_AppStateSyncKey* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_AppStateSyncKey, _impl_.keydata_) + + sizeof(Message_AppStateSyncKey::_impl_.keydata_) + - PROTOBUF_FIELD_OFFSET(Message_AppStateSyncKey, _impl_.keyid_)>( + reinterpret_cast(&_impl_.keyid_), + reinterpret_cast(&other->_impl_.keyid_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_AppStateSyncKey::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[59]); +} + +// =================================================================== + +class Message_AudioMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_url(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_mimetype(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_filesha256(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_filelength(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_seconds(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static void set_has_ptt(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static void set_has_mediakey(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_fileencsha256(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_directpath(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_mediakeytimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 4096u; + } + static const ::proto::ContextInfo& contextinfo(const Message_AudioMessage* msg); + static void set_has_contextinfo(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_streamingsidecar(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_waveform(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } +}; + +const ::proto::ContextInfo& +Message_AudioMessage::_Internal::contextinfo(const Message_AudioMessage* msg) { + return *msg->_impl_.contextinfo_; +} +Message_AudioMessage::Message_AudioMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.AudioMessage) +} +Message_AudioMessage::Message_AudioMessage(const Message_AudioMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_AudioMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.url_){} + , decltype(_impl_.mimetype_){} + , decltype(_impl_.filesha256_){} + , decltype(_impl_.mediakey_){} + , decltype(_impl_.fileencsha256_){} + , decltype(_impl_.directpath_){} + , decltype(_impl_.streamingsidecar_){} + , decltype(_impl_.waveform_){} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.filelength_){} + , decltype(_impl_.seconds_){} + , decltype(_impl_.ptt_){} + , decltype(_impl_.mediakeytimestamp_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.url_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.url_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_url()) { + _this->_impl_.url_.Set(from._internal_url(), + _this->GetArenaForAllocation()); + } + _impl_.mimetype_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mimetype_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_mimetype()) { + _this->_impl_.mimetype_.Set(from._internal_mimetype(), + _this->GetArenaForAllocation()); + } + _impl_.filesha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filesha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_filesha256()) { + _this->_impl_.filesha256_.Set(from._internal_filesha256(), + _this->GetArenaForAllocation()); + } + _impl_.mediakey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediakey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_mediakey()) { + _this->_impl_.mediakey_.Set(from._internal_mediakey(), + _this->GetArenaForAllocation()); + } + _impl_.fileencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_fileencsha256()) { + _this->_impl_.fileencsha256_.Set(from._internal_fileencsha256(), + _this->GetArenaForAllocation()); + } + _impl_.directpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_directpath()) { + _this->_impl_.directpath_.Set(from._internal_directpath(), + _this->GetArenaForAllocation()); + } + _impl_.streamingsidecar_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.streamingsidecar_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_streamingsidecar()) { + _this->_impl_.streamingsidecar_.Set(from._internal_streamingsidecar(), + _this->GetArenaForAllocation()); + } + _impl_.waveform_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.waveform_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_waveform()) { + _this->_impl_.waveform_.Set(from._internal_waveform(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_contextinfo()) { + _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); + } + ::memcpy(&_impl_.filelength_, &from._impl_.filelength_, + static_cast(reinterpret_cast(&_impl_.mediakeytimestamp_) - + reinterpret_cast(&_impl_.filelength_)) + sizeof(_impl_.mediakeytimestamp_)); + // @@protoc_insertion_point(copy_constructor:proto.Message.AudioMessage) +} + +inline void Message_AudioMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.url_){} + , decltype(_impl_.mimetype_){} + , decltype(_impl_.filesha256_){} + , decltype(_impl_.mediakey_){} + , decltype(_impl_.fileencsha256_){} + , decltype(_impl_.directpath_){} + , decltype(_impl_.streamingsidecar_){} + , decltype(_impl_.waveform_){} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.filelength_){uint64_t{0u}} + , decltype(_impl_.seconds_){0u} + , decltype(_impl_.ptt_){false} + , decltype(_impl_.mediakeytimestamp_){int64_t{0}} + }; + _impl_.url_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.url_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mimetype_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mimetype_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filesha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filesha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediakey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediakey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fileencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.streamingsidecar_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.streamingsidecar_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.waveform_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.waveform_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_AudioMessage::~Message_AudioMessage() { + // @@protoc_insertion_point(destructor:proto.Message.AudioMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_AudioMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.url_.Destroy(); + _impl_.mimetype_.Destroy(); + _impl_.filesha256_.Destroy(); + _impl_.mediakey_.Destroy(); + _impl_.fileencsha256_.Destroy(); + _impl_.directpath_.Destroy(); + _impl_.streamingsidecar_.Destroy(); + _impl_.waveform_.Destroy(); + if (this != internal_default_instance()) delete _impl_.contextinfo_; +} + +void Message_AudioMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_AudioMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.AudioMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _impl_.url_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.mimetype_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.filesha256_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + _impl_.mediakey_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + _impl_.fileencsha256_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000020u) { + _impl_.directpath_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000040u) { + _impl_.streamingsidecar_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000080u) { + _impl_.waveform_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x00000100u) { + GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); + _impl_.contextinfo_->Clear(); + } + if (cached_has_bits & 0x00001e00u) { + ::memset(&_impl_.filelength_, 0, static_cast( + reinterpret_cast(&_impl_.mediakeytimestamp_) - + reinterpret_cast(&_impl_.filelength_)) + sizeof(_impl_.mediakeytimestamp_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_AudioMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string url = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_url(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.AudioMessage.url"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string mimetype = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_mimetype(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.AudioMessage.mimetype"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bytes fileSha256 = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_filesha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint64 fileLength = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_filelength(&has_bits); + _impl_.filelength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 seconds = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_seconds(&has_bits); + _impl_.seconds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool ptt = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + _Internal::set_has_ptt(&has_bits); + _impl_.ptt_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes mediaKey = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + auto str = _internal_mutable_mediakey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes fileEncSha256 = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + auto str = _internal_mutable_fileencsha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string directPath = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + auto str = _internal_mutable_directpath(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.AudioMessage.directPath"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional int64 mediaKeyTimestamp = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { + _Internal::set_has_mediakeytimestamp(&has_bits); + _impl_.mediakeytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.ContextInfo contextInfo = 17; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { + ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes streamingSidecar = 18; + case 18: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { + auto str = _internal_mutable_streamingsidecar(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes waveform = 19; + case 19: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) { + auto str = _internal_mutable_waveform(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_AudioMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.AudioMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string url = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_url().data(), static_cast(this->_internal_url().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.AudioMessage.url"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_url(), target); + } + + // optional string mimetype = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_mimetype().data(), static_cast(this->_internal_mimetype().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.AudioMessage.mimetype"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_mimetype(), target); + } + + // optional bytes fileSha256 = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->WriteBytesMaybeAliased( + 3, this->_internal_filesha256(), target); + } + + // optional uint64 fileLength = 4; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_filelength(), target); + } + + // optional uint32 seconds = 5; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_seconds(), target); + } + + // optional bool ptt = 6; + if (cached_has_bits & 0x00000800u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(6, this->_internal_ptt(), target); + } + + // optional bytes mediaKey = 7; + if (cached_has_bits & 0x00000008u) { + target = stream->WriteBytesMaybeAliased( + 7, this->_internal_mediakey(), target); + } + + // optional bytes fileEncSha256 = 8; + if (cached_has_bits & 0x00000010u) { + target = stream->WriteBytesMaybeAliased( + 8, this->_internal_fileencsha256(), target); + } + + // optional string directPath = 9; + if (cached_has_bits & 0x00000020u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_directpath().data(), static_cast(this->_internal_directpath().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.AudioMessage.directPath"); + target = stream->WriteStringMaybeAliased( + 9, this->_internal_directpath(), target); + } + + // optional int64 mediaKeyTimestamp = 10; + if (cached_has_bits & 0x00001000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(10, this->_internal_mediakeytimestamp(), target); + } + + // optional .proto.ContextInfo contextInfo = 17; + if (cached_has_bits & 0x00000100u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(17, _Internal::contextinfo(this), + _Internal::contextinfo(this).GetCachedSize(), target, stream); + } + + // optional bytes streamingSidecar = 18; + if (cached_has_bits & 0x00000040u) { + target = stream->WriteBytesMaybeAliased( + 18, this->_internal_streamingsidecar(), target); + } + + // optional bytes waveform = 19; + if (cached_has_bits & 0x00000080u) { + target = stream->WriteBytesMaybeAliased( + 19, this->_internal_waveform(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.AudioMessage) + return target; +} + +size_t Message_AudioMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.AudioMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string url = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_url()); + } + + // optional string mimetype = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_mimetype()); + } + + // optional bytes fileSha256 = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_filesha256()); + } + + // optional bytes mediaKey = 7; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_mediakey()); + } + + // optional bytes fileEncSha256 = 8; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_fileencsha256()); + } + + // optional string directPath = 9; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_directpath()); + } + + // optional bytes streamingSidecar = 18; + if (cached_has_bits & 0x00000040u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_streamingsidecar()); + } + + // optional bytes waveform = 19; + if (cached_has_bits & 0x00000080u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_waveform()); + } + + } + if (cached_has_bits & 0x00001f00u) { + // optional .proto.ContextInfo contextInfo = 17; + if (cached_has_bits & 0x00000100u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.contextinfo_); + } + + // optional uint64 fileLength = 4; + if (cached_has_bits & 0x00000200u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_filelength()); + } + + // optional uint32 seconds = 5; + if (cached_has_bits & 0x00000400u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_seconds()); + } + + // optional bool ptt = 6; + if (cached_has_bits & 0x00000800u) { + total_size += 1 + 1; + } + + // optional int64 mediaKeyTimestamp = 10; + if (cached_has_bits & 0x00001000u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_mediakeytimestamp()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_AudioMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_AudioMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_AudioMessage::GetClassData() const { return &_class_data_; } + + +void Message_AudioMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.AudioMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_url(from._internal_url()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_mimetype(from._internal_mimetype()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_filesha256(from._internal_filesha256()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_set_mediakey(from._internal_mediakey()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_set_fileencsha256(from._internal_fileencsha256()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_set_directpath(from._internal_directpath()); + } + if (cached_has_bits & 0x00000040u) { + _this->_internal_set_streamingsidecar(from._internal_streamingsidecar()); + } + if (cached_has_bits & 0x00000080u) { + _this->_internal_set_waveform(from._internal_waveform()); + } + } + if (cached_has_bits & 0x00001f00u) { + if (cached_has_bits & 0x00000100u) { + _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( + from._internal_contextinfo()); + } + if (cached_has_bits & 0x00000200u) { + _this->_impl_.filelength_ = from._impl_.filelength_; + } + if (cached_has_bits & 0x00000400u) { + _this->_impl_.seconds_ = from._impl_.seconds_; + } + if (cached_has_bits & 0x00000800u) { + _this->_impl_.ptt_ = from._impl_.ptt_; + } + if (cached_has_bits & 0x00001000u) { + _this->_impl_.mediakeytimestamp_ = from._impl_.mediakeytimestamp_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_AudioMessage::CopyFrom(const Message_AudioMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.AudioMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_AudioMessage::IsInitialized() const { + return true; +} + +void Message_AudioMessage::InternalSwap(Message_AudioMessage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.url_, lhs_arena, + &other->_impl_.url_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.mimetype_, lhs_arena, + &other->_impl_.mimetype_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.filesha256_, lhs_arena, + &other->_impl_.filesha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.mediakey_, lhs_arena, + &other->_impl_.mediakey_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.fileencsha256_, lhs_arena, + &other->_impl_.fileencsha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.directpath_, lhs_arena, + &other->_impl_.directpath_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.streamingsidecar_, lhs_arena, + &other->_impl_.streamingsidecar_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.waveform_, lhs_arena, + &other->_impl_.waveform_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_AudioMessage, _impl_.mediakeytimestamp_) + + sizeof(Message_AudioMessage::_impl_.mediakeytimestamp_) + - PROTOBUF_FIELD_OFFSET(Message_AudioMessage, _impl_.contextinfo_)>( + reinterpret_cast(&_impl_.contextinfo_), + reinterpret_cast(&other->_impl_.contextinfo_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_AudioMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[60]); +} + +// =================================================================== + +class Message_ButtonsMessage_Button_ButtonText::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_displaytext(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +Message_ButtonsMessage_Button_ButtonText::Message_ButtonsMessage_Button_ButtonText(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.ButtonsMessage.Button.ButtonText) +} +Message_ButtonsMessage_Button_ButtonText::Message_ButtonsMessage_Button_ButtonText(const Message_ButtonsMessage_Button_ButtonText& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_ButtonsMessage_Button_ButtonText* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.displaytext_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.displaytext_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.displaytext_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_displaytext()) { + _this->_impl_.displaytext_.Set(from._internal_displaytext(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.Message.ButtonsMessage.Button.ButtonText) +} + +inline void Message_ButtonsMessage_Button_ButtonText::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.displaytext_){} + }; + _impl_.displaytext_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.displaytext_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_ButtonsMessage_Button_ButtonText::~Message_ButtonsMessage_Button_ButtonText() { + // @@protoc_insertion_point(destructor:proto.Message.ButtonsMessage.Button.ButtonText) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_ButtonsMessage_Button_ButtonText::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.displaytext_.Destroy(); +} + +void Message_ButtonsMessage_Button_ButtonText::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_ButtonsMessage_Button_ButtonText::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.ButtonsMessage.Button.ButtonText) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.displaytext_.ClearNonDefaultToEmpty(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_ButtonsMessage_Button_ButtonText::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string displayText = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_displaytext(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ButtonsMessage.Button.ButtonText.displayText"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_ButtonsMessage_Button_ButtonText::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ButtonsMessage.Button.ButtonText) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string displayText = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_displaytext().data(), static_cast(this->_internal_displaytext().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ButtonsMessage.Button.ButtonText.displayText"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_displaytext(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ButtonsMessage.Button.ButtonText) + return target; +} + +size_t Message_ButtonsMessage_Button_ButtonText::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.ButtonsMessage.Button.ButtonText) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional string displayText = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_displaytext()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ButtonsMessage_Button_ButtonText::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_ButtonsMessage_Button_ButtonText::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ButtonsMessage_Button_ButtonText::GetClassData() const { return &_class_data_; } + + +void Message_ButtonsMessage_Button_ButtonText::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ButtonsMessage.Button.ButtonText) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_displaytext()) { + _this->_internal_set_displaytext(from._internal_displaytext()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_ButtonsMessage_Button_ButtonText::CopyFrom(const Message_ButtonsMessage_Button_ButtonText& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ButtonsMessage.Button.ButtonText) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_ButtonsMessage_Button_ButtonText::IsInitialized() const { + return true; +} + +void Message_ButtonsMessage_Button_ButtonText::InternalSwap(Message_ButtonsMessage_Button_ButtonText* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.displaytext_, lhs_arena, + &other->_impl_.displaytext_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_ButtonsMessage_Button_ButtonText::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[61]); +} + +// =================================================================== + +class Message_ButtonsMessage_Button_NativeFlowInfo::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_name(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_paramsjson(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +Message_ButtonsMessage_Button_NativeFlowInfo::Message_ButtonsMessage_Button_NativeFlowInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.ButtonsMessage.Button.NativeFlowInfo) +} +Message_ButtonsMessage_Button_NativeFlowInfo::Message_ButtonsMessage_Button_NativeFlowInfo(const Message_ButtonsMessage_Button_NativeFlowInfo& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_ButtonsMessage_Button_NativeFlowInfo* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.name_){} + , decltype(_impl_.paramsjson_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.name_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.name_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_name()) { + _this->_impl_.name_.Set(from._internal_name(), + _this->GetArenaForAllocation()); + } + _impl_.paramsjson_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.paramsjson_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_paramsjson()) { + _this->_impl_.paramsjson_.Set(from._internal_paramsjson(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.Message.ButtonsMessage.Button.NativeFlowInfo) +} + +inline void Message_ButtonsMessage_Button_NativeFlowInfo::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.name_){} + , decltype(_impl_.paramsjson_){} + }; + _impl_.name_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.name_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.paramsjson_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.paramsjson_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_ButtonsMessage_Button_NativeFlowInfo::~Message_ButtonsMessage_Button_NativeFlowInfo() { + // @@protoc_insertion_point(destructor:proto.Message.ButtonsMessage.Button.NativeFlowInfo) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_ButtonsMessage_Button_NativeFlowInfo::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.name_.Destroy(); + _impl_.paramsjson_.Destroy(); +} + +void Message_ButtonsMessage_Button_NativeFlowInfo::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_ButtonsMessage_Button_NativeFlowInfo::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.ButtonsMessage.Button.NativeFlowInfo) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.paramsjson_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_ButtonsMessage_Button_NativeFlowInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_name(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ButtonsMessage.Button.NativeFlowInfo.name"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string paramsJson = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_paramsjson(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ButtonsMessage.Button.NativeFlowInfo.paramsJson"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_ButtonsMessage_Button_NativeFlowInfo::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ButtonsMessage.Button.NativeFlowInfo) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string name = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ButtonsMessage.Button.NativeFlowInfo.name"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_name(), target); + } + + // optional string paramsJson = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_paramsjson().data(), static_cast(this->_internal_paramsjson().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ButtonsMessage.Button.NativeFlowInfo.paramsJson"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_paramsjson(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ButtonsMessage.Button.NativeFlowInfo) + return target; +} + +size_t Message_ButtonsMessage_Button_NativeFlowInfo::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.ButtonsMessage.Button.NativeFlowInfo) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional string name = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // optional string paramsJson = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_paramsjson()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ButtonsMessage_Button_NativeFlowInfo::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_ButtonsMessage_Button_NativeFlowInfo::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ButtonsMessage_Button_NativeFlowInfo::GetClassData() const { return &_class_data_; } + + +void Message_ButtonsMessage_Button_NativeFlowInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ButtonsMessage.Button.NativeFlowInfo) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_name(from._internal_name()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_paramsjson(from._internal_paramsjson()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_ButtonsMessage_Button_NativeFlowInfo::CopyFrom(const Message_ButtonsMessage_Button_NativeFlowInfo& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ButtonsMessage.Button.NativeFlowInfo) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_ButtonsMessage_Button_NativeFlowInfo::IsInitialized() const { + return true; +} + +void Message_ButtonsMessage_Button_NativeFlowInfo::InternalSwap(Message_ButtonsMessage_Button_NativeFlowInfo* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.name_, lhs_arena, + &other->_impl_.name_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.paramsjson_, lhs_arena, + &other->_impl_.paramsjson_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_ButtonsMessage_Button_NativeFlowInfo::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[62]); +} + +// =================================================================== + +class Message_ButtonsMessage_Button::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_buttonid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::proto::Message_ButtonsMessage_Button_ButtonText& buttontext(const Message_ButtonsMessage_Button* msg); + static void set_has_buttontext(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_type(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static const ::proto::Message_ButtonsMessage_Button_NativeFlowInfo& nativeflowinfo(const Message_ButtonsMessage_Button* msg); + static void set_has_nativeflowinfo(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +const ::proto::Message_ButtonsMessage_Button_ButtonText& +Message_ButtonsMessage_Button::_Internal::buttontext(const Message_ButtonsMessage_Button* msg) { + return *msg->_impl_.buttontext_; +} +const ::proto::Message_ButtonsMessage_Button_NativeFlowInfo& +Message_ButtonsMessage_Button::_Internal::nativeflowinfo(const Message_ButtonsMessage_Button* msg) { + return *msg->_impl_.nativeflowinfo_; +} +Message_ButtonsMessage_Button::Message_ButtonsMessage_Button(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.ButtonsMessage.Button) +} +Message_ButtonsMessage_Button::Message_ButtonsMessage_Button(const Message_ButtonsMessage_Button& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_ButtonsMessage_Button* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.buttonid_){} + , decltype(_impl_.buttontext_){nullptr} + , decltype(_impl_.nativeflowinfo_){nullptr} + , decltype(_impl_.type_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.buttonid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.buttonid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_buttonid()) { + _this->_impl_.buttonid_.Set(from._internal_buttonid(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_buttontext()) { + _this->_impl_.buttontext_ = new ::proto::Message_ButtonsMessage_Button_ButtonText(*from._impl_.buttontext_); + } + if (from._internal_has_nativeflowinfo()) { + _this->_impl_.nativeflowinfo_ = new ::proto::Message_ButtonsMessage_Button_NativeFlowInfo(*from._impl_.nativeflowinfo_); + } + _this->_impl_.type_ = from._impl_.type_; + // @@protoc_insertion_point(copy_constructor:proto.Message.ButtonsMessage.Button) +} + +inline void Message_ButtonsMessage_Button::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.buttonid_){} + , decltype(_impl_.buttontext_){nullptr} + , decltype(_impl_.nativeflowinfo_){nullptr} + , decltype(_impl_.type_){0} + }; + _impl_.buttonid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.buttonid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_ButtonsMessage_Button::~Message_ButtonsMessage_Button() { + // @@protoc_insertion_point(destructor:proto.Message.ButtonsMessage.Button) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_ButtonsMessage_Button::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.buttonid_.Destroy(); + if (this != internal_default_instance()) delete _impl_.buttontext_; + if (this != internal_default_instance()) delete _impl_.nativeflowinfo_; +} + +void Message_ButtonsMessage_Button::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_ButtonsMessage_Button::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.ButtonsMessage.Button) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _impl_.buttonid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.buttontext_ != nullptr); + _impl_.buttontext_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.nativeflowinfo_ != nullptr); + _impl_.nativeflowinfo_->Clear(); + } + } + _impl_.type_ = 0; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_ButtonsMessage_Button::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string buttonId = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_buttonid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ButtonsMessage.Button.buttonId"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.Message.ButtonsMessage.Button.ButtonText buttonText = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_buttontext(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.ButtonsMessage.Button.Type type = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::Message_ButtonsMessage_Button_Type_IsValid(val))) { + _internal_set_type(static_cast<::proto::Message_ButtonsMessage_Button_Type>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.Message.ButtonsMessage.Button.NativeFlowInfo nativeFlowInfo = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_nativeflowinfo(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_ButtonsMessage_Button::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ButtonsMessage.Button) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string buttonId = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_buttonid().data(), static_cast(this->_internal_buttonid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ButtonsMessage.Button.buttonId"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_buttonid(), target); + } + + // optional .proto.Message.ButtonsMessage.Button.ButtonText buttonText = 2; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::buttontext(this), + _Internal::buttontext(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.ButtonsMessage.Button.Type type = 3; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 3, this->_internal_type(), target); + } + + // optional .proto.Message.ButtonsMessage.Button.NativeFlowInfo nativeFlowInfo = 4; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, _Internal::nativeflowinfo(this), + _Internal::nativeflowinfo(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ButtonsMessage.Button) + return target; +} + +size_t Message_ButtonsMessage_Button::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.ButtonsMessage.Button) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional string buttonId = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_buttonid()); + } + + // optional .proto.Message.ButtonsMessage.Button.ButtonText buttonText = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.buttontext_); + } + + // optional .proto.Message.ButtonsMessage.Button.NativeFlowInfo nativeFlowInfo = 4; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.nativeflowinfo_); + } + + // optional .proto.Message.ButtonsMessage.Button.Type type = 3; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_type()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ButtonsMessage_Button::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_ButtonsMessage_Button::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ButtonsMessage_Button::GetClassData() const { return &_class_data_; } + + +void Message_ButtonsMessage_Button::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ButtonsMessage.Button) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_buttonid(from._internal_buttonid()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_buttontext()->::proto::Message_ButtonsMessage_Button_ButtonText::MergeFrom( + from._internal_buttontext()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_nativeflowinfo()->::proto::Message_ButtonsMessage_Button_NativeFlowInfo::MergeFrom( + from._internal_nativeflowinfo()); + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.type_ = from._impl_.type_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_ButtonsMessage_Button::CopyFrom(const Message_ButtonsMessage_Button& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ButtonsMessage.Button) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_ButtonsMessage_Button::IsInitialized() const { + return true; +} + +void Message_ButtonsMessage_Button::InternalSwap(Message_ButtonsMessage_Button* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.buttonid_, lhs_arena, + &other->_impl_.buttonid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_ButtonsMessage_Button, _impl_.type_) + + sizeof(Message_ButtonsMessage_Button::_impl_.type_) + - PROTOBUF_FIELD_OFFSET(Message_ButtonsMessage_Button, _impl_.buttontext_)>( + reinterpret_cast(&_impl_.buttontext_), + reinterpret_cast(&other->_impl_.buttontext_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_ButtonsMessage_Button::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[63]); +} + +// =================================================================== + +class Message_ButtonsMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_contenttext(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_footertext(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::proto::ContextInfo& contextinfo(const Message_ButtonsMessage* msg); + static void set_has_contextinfo(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_headertype(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static const ::proto::Message_DocumentMessage& documentmessage(const Message_ButtonsMessage* msg); + static const ::proto::Message_ImageMessage& imagemessage(const Message_ButtonsMessage* msg); + static const ::proto::Message_VideoMessage& videomessage(const Message_ButtonsMessage* msg); + static const ::proto::Message_LocationMessage& locationmessage(const Message_ButtonsMessage* msg); +}; + +const ::proto::ContextInfo& +Message_ButtonsMessage::_Internal::contextinfo(const Message_ButtonsMessage* msg) { + return *msg->_impl_.contextinfo_; +} +const ::proto::Message_DocumentMessage& +Message_ButtonsMessage::_Internal::documentmessage(const Message_ButtonsMessage* msg) { + return *msg->_impl_.header_.documentmessage_; +} +const ::proto::Message_ImageMessage& +Message_ButtonsMessage::_Internal::imagemessage(const Message_ButtonsMessage* msg) { + return *msg->_impl_.header_.imagemessage_; +} +const ::proto::Message_VideoMessage& +Message_ButtonsMessage::_Internal::videomessage(const Message_ButtonsMessage* msg) { + return *msg->_impl_.header_.videomessage_; +} +const ::proto::Message_LocationMessage& +Message_ButtonsMessage::_Internal::locationmessage(const Message_ButtonsMessage* msg) { + return *msg->_impl_.header_.locationmessage_; +} +void Message_ButtonsMessage::set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_header(); + if (documentmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(documentmessage); + if (message_arena != submessage_arena) { + documentmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, documentmessage, submessage_arena); + } + set_has_documentmessage(); + _impl_.header_.documentmessage_ = documentmessage; + } + // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.documentMessage) +} +void Message_ButtonsMessage::set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_header(); + if (imagemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(imagemessage); + if (message_arena != submessage_arena) { + imagemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, imagemessage, submessage_arena); + } + set_has_imagemessage(); + _impl_.header_.imagemessage_ = imagemessage; + } + // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.imageMessage) +} +void Message_ButtonsMessage::set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_header(); + if (videomessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(videomessage); + if (message_arena != submessage_arena) { + videomessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, videomessage, submessage_arena); + } + set_has_videomessage(); + _impl_.header_.videomessage_ = videomessage; + } + // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.videoMessage) +} +void Message_ButtonsMessage::set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_header(); + if (locationmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(locationmessage); + if (message_arena != submessage_arena) { + locationmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, locationmessage, submessage_arena); + } + set_has_locationmessage(); + _impl_.header_.locationmessage_ = locationmessage; + } + // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.locationMessage) +} +Message_ButtonsMessage::Message_ButtonsMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.ButtonsMessage) +} +Message_ButtonsMessage::Message_ButtonsMessage(const Message_ButtonsMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_ButtonsMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.buttons_){from._impl_.buttons_} + , decltype(_impl_.contenttext_){} + , decltype(_impl_.footertext_){} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.headertype_){} + , decltype(_impl_.header_){} + , /*decltype(_impl_._oneof_case_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.contenttext_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.contenttext_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_contenttext()) { + _this->_impl_.contenttext_.Set(from._internal_contenttext(), + _this->GetArenaForAllocation()); + } + _impl_.footertext_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.footertext_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_footertext()) { + _this->_impl_.footertext_.Set(from._internal_footertext(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_contextinfo()) { + _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); + } + _this->_impl_.headertype_ = from._impl_.headertype_; + clear_has_header(); + switch (from.header_case()) { + case kText: { + _this->_internal_set_text(from._internal_text()); + break; + } + case kDocumentMessage: { + _this->_internal_mutable_documentmessage()->::proto::Message_DocumentMessage::MergeFrom( + from._internal_documentmessage()); + break; + } + case kImageMessage: { + _this->_internal_mutable_imagemessage()->::proto::Message_ImageMessage::MergeFrom( + from._internal_imagemessage()); + break; + } + case kVideoMessage: { + _this->_internal_mutable_videomessage()->::proto::Message_VideoMessage::MergeFrom( + from._internal_videomessage()); + break; + } + case kLocationMessage: { + _this->_internal_mutable_locationmessage()->::proto::Message_LocationMessage::MergeFrom( + from._internal_locationmessage()); + break; + } + case HEADER_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:proto.Message.ButtonsMessage) +} + +inline void Message_ButtonsMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.buttons_){arena} + , decltype(_impl_.contenttext_){} + , decltype(_impl_.footertext_){} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.headertype_){0} + , decltype(_impl_.header_){} + , /*decltype(_impl_._oneof_case_)*/{} + }; + _impl_.contenttext_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.contenttext_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.footertext_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.footertext_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + clear_has_header(); +} + +Message_ButtonsMessage::~Message_ButtonsMessage() { + // @@protoc_insertion_point(destructor:proto.Message.ButtonsMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_ButtonsMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.buttons_.~RepeatedPtrField(); + _impl_.contenttext_.Destroy(); + _impl_.footertext_.Destroy(); + if (this != internal_default_instance()) delete _impl_.contextinfo_; + if (has_header()) { + clear_header(); + } +} + +void Message_ButtonsMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_ButtonsMessage::clear_header() { +// @@protoc_insertion_point(one_of_clear_start:proto.Message.ButtonsMessage) + switch (header_case()) { + case kText: { + _impl_.header_.text_.Destroy(); + break; + } + case kDocumentMessage: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.header_.documentmessage_; + } + break; + } + case kImageMessage: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.header_.imagemessage_; + } + break; + } + case kVideoMessage: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.header_.videomessage_; + } + break; + } + case kLocationMessage: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.header_.locationmessage_; + } + break; + } + case HEADER_NOT_SET: { + break; + } + } + _impl_._oneof_case_[0] = HEADER_NOT_SET; +} + + +void Message_ButtonsMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.ButtonsMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.buttons_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _impl_.contenttext_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.footertext_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); + _impl_.contextinfo_->Clear(); + } + } + _impl_.headertype_ = 0; + clear_header(); + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_ButtonsMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // string text = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_text(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ButtonsMessage.text"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // .proto.Message.DocumentMessage documentMessage = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_documentmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .proto.Message.ImageMessage imageMessage = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_imagemessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .proto.Message.VideoMessage videoMessage = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_videomessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .proto.Message.LocationMessage locationMessage = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_locationmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string contentText = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + auto str = _internal_mutable_contenttext(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ButtonsMessage.contentText"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string footerText = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + auto str = _internal_mutable_footertext(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ButtonsMessage.footerText"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.ContextInfo contextInfo = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .proto.Message.ButtonsMessage.Button buttons = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_buttons(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<74>(ptr)); + } else + goto handle_unusual; + continue; + // optional .proto.Message.ButtonsMessage.HeaderType headerType = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::Message_ButtonsMessage_HeaderType_IsValid(val))) { + _internal_set_headertype(static_cast<::proto::Message_ButtonsMessage_HeaderType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(10, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_ButtonsMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ButtonsMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + switch (header_case()) { + case kText: { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_text().data(), static_cast(this->_internal_text().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ButtonsMessage.text"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_text(), target); + break; + } + case kDocumentMessage: { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::documentmessage(this), + _Internal::documentmessage(this).GetCachedSize(), target, stream); + break; + } + case kImageMessage: { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::imagemessage(this), + _Internal::imagemessage(this).GetCachedSize(), target, stream); + break; + } + case kVideoMessage: { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, _Internal::videomessage(this), + _Internal::videomessage(this).GetCachedSize(), target, stream); + break; + } + case kLocationMessage: { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(5, _Internal::locationmessage(this), + _Internal::locationmessage(this).GetCachedSize(), target, stream); + break; + } + default: ; + } + cached_has_bits = _impl_._has_bits_[0]; + // optional string contentText = 6; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_contenttext().data(), static_cast(this->_internal_contenttext().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ButtonsMessage.contentText"); + target = stream->WriteStringMaybeAliased( + 6, this->_internal_contenttext(), target); + } + + // optional string footerText = 7; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_footertext().data(), static_cast(this->_internal_footertext().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ButtonsMessage.footerText"); + target = stream->WriteStringMaybeAliased( + 7, this->_internal_footertext(), target); + } + + // optional .proto.ContextInfo contextInfo = 8; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(8, _Internal::contextinfo(this), + _Internal::contextinfo(this).GetCachedSize(), target, stream); + } + + // repeated .proto.Message.ButtonsMessage.Button buttons = 9; + for (unsigned i = 0, + n = static_cast(this->_internal_buttons_size()); i < n; i++) { + const auto& repfield = this->_internal_buttons(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(9, repfield, repfield.GetCachedSize(), target, stream); + } + + // optional .proto.Message.ButtonsMessage.HeaderType headerType = 10; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 10, this->_internal_headertype(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ButtonsMessage) + return target; +} + +size_t Message_ButtonsMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.ButtonsMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.Message.ButtonsMessage.Button buttons = 9; + total_size += 1UL * this->_internal_buttons_size(); + for (const auto& msg : this->_impl_.buttons_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional string contentText = 6; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_contenttext()); + } + + // optional string footerText = 7; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_footertext()); + } + + // optional .proto.ContextInfo contextInfo = 8; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.contextinfo_); + } + + // optional .proto.Message.ButtonsMessage.HeaderType headerType = 10; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_headertype()); + } + + } + switch (header_case()) { + // string text = 1; + case kText: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_text()); + break; + } + // .proto.Message.DocumentMessage documentMessage = 2; + case kDocumentMessage: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.header_.documentmessage_); + break; + } + // .proto.Message.ImageMessage imageMessage = 3; + case kImageMessage: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.header_.imagemessage_); + break; + } + // .proto.Message.VideoMessage videoMessage = 4; + case kVideoMessage: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.header_.videomessage_); + break; + } + // .proto.Message.LocationMessage locationMessage = 5; + case kLocationMessage: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.header_.locationmessage_); + break; + } + case HEADER_NOT_SET: { + break; + } + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ButtonsMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_ButtonsMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ButtonsMessage::GetClassData() const { return &_class_data_; } + + +void Message_ButtonsMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ButtonsMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.buttons_.MergeFrom(from._impl_.buttons_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_contenttext(from._internal_contenttext()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_footertext(from._internal_footertext()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( + from._internal_contextinfo()); + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.headertype_ = from._impl_.headertype_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + switch (from.header_case()) { + case kText: { + _this->_internal_set_text(from._internal_text()); + break; + } + case kDocumentMessage: { + _this->_internal_mutable_documentmessage()->::proto::Message_DocumentMessage::MergeFrom( + from._internal_documentmessage()); + break; + } + case kImageMessage: { + _this->_internal_mutable_imagemessage()->::proto::Message_ImageMessage::MergeFrom( + from._internal_imagemessage()); + break; + } + case kVideoMessage: { + _this->_internal_mutable_videomessage()->::proto::Message_VideoMessage::MergeFrom( + from._internal_videomessage()); + break; + } + case kLocationMessage: { + _this->_internal_mutable_locationmessage()->::proto::Message_LocationMessage::MergeFrom( + from._internal_locationmessage()); + break; + } + case HEADER_NOT_SET: { + break; + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_ButtonsMessage::CopyFrom(const Message_ButtonsMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ButtonsMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_ButtonsMessage::IsInitialized() const { + return true; +} + +void Message_ButtonsMessage::InternalSwap(Message_ButtonsMessage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.buttons_.InternalSwap(&other->_impl_.buttons_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.contenttext_, lhs_arena, + &other->_impl_.contenttext_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.footertext_, lhs_arena, + &other->_impl_.footertext_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_ButtonsMessage, _impl_.headertype_) + + sizeof(Message_ButtonsMessage::_impl_.headertype_) + - PROTOBUF_FIELD_OFFSET(Message_ButtonsMessage, _impl_.contextinfo_)>( + reinterpret_cast(&_impl_.contextinfo_), + reinterpret_cast(&other->_impl_.contextinfo_)); + swap(_impl_.header_, other->_impl_.header_); + swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_ButtonsMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[64]); +} + +// =================================================================== + +class Message_ButtonsResponseMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_selectedbuttonid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::proto::ContextInfo& contextinfo(const Message_ButtonsResponseMessage* msg); + static void set_has_contextinfo(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_type(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +const ::proto::ContextInfo& +Message_ButtonsResponseMessage::_Internal::contextinfo(const Message_ButtonsResponseMessage* msg) { + return *msg->_impl_.contextinfo_; +} +Message_ButtonsResponseMessage::Message_ButtonsResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.ButtonsResponseMessage) +} +Message_ButtonsResponseMessage::Message_ButtonsResponseMessage(const Message_ButtonsResponseMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_ButtonsResponseMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.selectedbuttonid_){} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.type_){} + , decltype(_impl_.response_){} + , /*decltype(_impl_._oneof_case_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.selectedbuttonid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.selectedbuttonid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_selectedbuttonid()) { + _this->_impl_.selectedbuttonid_.Set(from._internal_selectedbuttonid(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_contextinfo()) { + _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); + } + _this->_impl_.type_ = from._impl_.type_; + clear_has_response(); + switch (from.response_case()) { + case kSelectedDisplayText: { + _this->_internal_set_selecteddisplaytext(from._internal_selecteddisplaytext()); + break; + } + case RESPONSE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:proto.Message.ButtonsResponseMessage) +} + +inline void Message_ButtonsResponseMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.selectedbuttonid_){} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.type_){0} + , decltype(_impl_.response_){} + , /*decltype(_impl_._oneof_case_)*/{} + }; + _impl_.selectedbuttonid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.selectedbuttonid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + clear_has_response(); +} + +Message_ButtonsResponseMessage::~Message_ButtonsResponseMessage() { + // @@protoc_insertion_point(destructor:proto.Message.ButtonsResponseMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_ButtonsResponseMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.selectedbuttonid_.Destroy(); + if (this != internal_default_instance()) delete _impl_.contextinfo_; + if (has_response()) { + clear_response(); + } +} + +void Message_ButtonsResponseMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_ButtonsResponseMessage::clear_response() { +// @@protoc_insertion_point(one_of_clear_start:proto.Message.ButtonsResponseMessage) + switch (response_case()) { + case kSelectedDisplayText: { + _impl_.response_.selecteddisplaytext_.Destroy(); + break; + } + case RESPONSE_NOT_SET: { + break; + } + } + _impl_._oneof_case_[0] = RESPONSE_NOT_SET; +} + + +void Message_ButtonsResponseMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.ButtonsResponseMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.selectedbuttonid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); + _impl_.contextinfo_->Clear(); + } + } + _impl_.type_ = 0; + clear_response(); + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_ButtonsResponseMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string selectedButtonId = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_selectedbuttonid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ButtonsResponseMessage.selectedButtonId"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // string selectedDisplayText = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_selecteddisplaytext(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ButtonsResponseMessage.selectedDisplayText"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.ContextInfo contextInfo = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.ButtonsResponseMessage.Type type = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::Message_ButtonsResponseMessage_Type_IsValid(val))) { + _internal_set_type(static_cast<::proto::Message_ButtonsResponseMessage_Type>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_ButtonsResponseMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ButtonsResponseMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string selectedButtonId = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_selectedbuttonid().data(), static_cast(this->_internal_selectedbuttonid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ButtonsResponseMessage.selectedButtonId"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_selectedbuttonid(), target); + } + + // string selectedDisplayText = 2; + if (_internal_has_selecteddisplaytext()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_selecteddisplaytext().data(), static_cast(this->_internal_selecteddisplaytext().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ButtonsResponseMessage.selectedDisplayText"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_selecteddisplaytext(), target); + } + + // optional .proto.ContextInfo contextInfo = 3; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::contextinfo(this), + _Internal::contextinfo(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.ButtonsResponseMessage.Type type = 4; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 4, this->_internal_type(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ButtonsResponseMessage) + return target; +} + +size_t Message_ButtonsResponseMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.ButtonsResponseMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional string selectedButtonId = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_selectedbuttonid()); + } + + // optional .proto.ContextInfo contextInfo = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.contextinfo_); + } + + // optional .proto.Message.ButtonsResponseMessage.Type type = 4; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_type()); + } + + } + switch (response_case()) { + // string selectedDisplayText = 2; + case kSelectedDisplayText: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_selecteddisplaytext()); + break; + } + case RESPONSE_NOT_SET: { + break; + } + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ButtonsResponseMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_ButtonsResponseMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ButtonsResponseMessage::GetClassData() const { return &_class_data_; } + + +void Message_ButtonsResponseMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ButtonsResponseMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_selectedbuttonid(from._internal_selectedbuttonid()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( + from._internal_contextinfo()); + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.type_ = from._impl_.type_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + switch (from.response_case()) { + case kSelectedDisplayText: { + _this->_internal_set_selecteddisplaytext(from._internal_selecteddisplaytext()); + break; + } + case RESPONSE_NOT_SET: { + break; + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_ButtonsResponseMessage::CopyFrom(const Message_ButtonsResponseMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ButtonsResponseMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_ButtonsResponseMessage::IsInitialized() const { + return true; +} + +void Message_ButtonsResponseMessage::InternalSwap(Message_ButtonsResponseMessage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.selectedbuttonid_, lhs_arena, + &other->_impl_.selectedbuttonid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_ButtonsResponseMessage, _impl_.type_) + + sizeof(Message_ButtonsResponseMessage::_impl_.type_) + - PROTOBUF_FIELD_OFFSET(Message_ButtonsResponseMessage, _impl_.contextinfo_)>( + reinterpret_cast(&_impl_.contextinfo_), + reinterpret_cast(&other->_impl_.contextinfo_)); + swap(_impl_.response_, other->_impl_.response_); + swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_ButtonsResponseMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[65]); +} + +// =================================================================== + +class Message_Call::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_callkey(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_conversionsource(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_conversiondata(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_conversiondelayseconds(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +Message_Call::Message_Call(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.Call) +} +Message_Call::Message_Call(const Message_Call& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_Call* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.callkey_){} + , decltype(_impl_.conversionsource_){} + , decltype(_impl_.conversiondata_){} + , decltype(_impl_.conversiondelayseconds_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.callkey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.callkey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_callkey()) { + _this->_impl_.callkey_.Set(from._internal_callkey(), + _this->GetArenaForAllocation()); + } + _impl_.conversionsource_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.conversionsource_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_conversionsource()) { + _this->_impl_.conversionsource_.Set(from._internal_conversionsource(), + _this->GetArenaForAllocation()); + } + _impl_.conversiondata_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.conversiondata_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_conversiondata()) { + _this->_impl_.conversiondata_.Set(from._internal_conversiondata(), + _this->GetArenaForAllocation()); + } + _this->_impl_.conversiondelayseconds_ = from._impl_.conversiondelayseconds_; + // @@protoc_insertion_point(copy_constructor:proto.Message.Call) +} + +inline void Message_Call::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.callkey_){} + , decltype(_impl_.conversionsource_){} + , decltype(_impl_.conversiondata_){} + , decltype(_impl_.conversiondelayseconds_){0u} + }; + _impl_.callkey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.callkey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.conversionsource_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.conversionsource_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.conversiondata_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.conversiondata_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_Call::~Message_Call() { + // @@protoc_insertion_point(destructor:proto.Message.Call) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_Call::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.callkey_.Destroy(); + _impl_.conversionsource_.Destroy(); + _impl_.conversiondata_.Destroy(); +} + +void Message_Call::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_Call::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.Call) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _impl_.callkey_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.conversionsource_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.conversiondata_.ClearNonDefaultToEmpty(); + } + } + _impl_.conversiondelayseconds_ = 0u; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_Call::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes callKey = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_callkey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string conversionSource = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_conversionsource(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.Call.conversionSource"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bytes conversionData = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_conversiondata(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 conversionDelaySeconds = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_conversiondelayseconds(&has_bits); + _impl_.conversiondelayseconds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_Call::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.Call) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes callKey = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_callkey(), target); + } + + // optional string conversionSource = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_conversionsource().data(), static_cast(this->_internal_conversionsource().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.Call.conversionSource"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_conversionsource(), target); + } + + // optional bytes conversionData = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->WriteBytesMaybeAliased( + 3, this->_internal_conversiondata(), target); + } + + // optional uint32 conversionDelaySeconds = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_conversiondelayseconds(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.Call) + return target; +} + +size_t Message_Call::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.Call) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional bytes callKey = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_callkey()); + } + + // optional string conversionSource = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_conversionsource()); + } + + // optional bytes conversionData = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_conversiondata()); + } + + // optional uint32 conversionDelaySeconds = 4; + if (cached_has_bits & 0x00000008u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_conversiondelayseconds()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_Call::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_Call::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_Call::GetClassData() const { return &_class_data_; } + + +void Message_Call::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.Call) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_callkey(from._internal_callkey()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_conversionsource(from._internal_conversionsource()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_conversiondata(from._internal_conversiondata()); + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.conversiondelayseconds_ = from._impl_.conversiondelayseconds_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_Call::CopyFrom(const Message_Call& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.Call) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_Call::IsInitialized() const { + return true; +} + +void Message_Call::InternalSwap(Message_Call* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.callkey_, lhs_arena, + &other->_impl_.callkey_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.conversionsource_, lhs_arena, + &other->_impl_.conversionsource_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.conversiondata_, lhs_arena, + &other->_impl_.conversiondata_, rhs_arena + ); + swap(_impl_.conversiondelayseconds_, other->_impl_.conversiondelayseconds_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_Call::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[66]); +} + +// =================================================================== + +class Message_CancelPaymentRequestMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::MessageKey& key(const Message_CancelPaymentRequestMessage* msg); + static void set_has_key(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +const ::proto::MessageKey& +Message_CancelPaymentRequestMessage::_Internal::key(const Message_CancelPaymentRequestMessage* msg) { + return *msg->_impl_.key_; +} +Message_CancelPaymentRequestMessage::Message_CancelPaymentRequestMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.CancelPaymentRequestMessage) +} +Message_CancelPaymentRequestMessage::Message_CancelPaymentRequestMessage(const Message_CancelPaymentRequestMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_CancelPaymentRequestMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.key_){nullptr}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_key()) { + _this->_impl_.key_ = new ::proto::MessageKey(*from._impl_.key_); + } + // @@protoc_insertion_point(copy_constructor:proto.Message.CancelPaymentRequestMessage) +} + +inline void Message_CancelPaymentRequestMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.key_){nullptr} + }; +} + +Message_CancelPaymentRequestMessage::~Message_CancelPaymentRequestMessage() { + // @@protoc_insertion_point(destructor:proto.Message.CancelPaymentRequestMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_CancelPaymentRequestMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.key_; +} + +void Message_CancelPaymentRequestMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_CancelPaymentRequestMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.CancelPaymentRequestMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.key_ != nullptr); + _impl_.key_->Clear(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_CancelPaymentRequestMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.MessageKey key = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_CancelPaymentRequestMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.CancelPaymentRequestMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.MessageKey key = 1; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::key(this), + _Internal::key(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.CancelPaymentRequestMessage) + return target; +} + +size_t Message_CancelPaymentRequestMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.CancelPaymentRequestMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional .proto.MessageKey key = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.key_); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_CancelPaymentRequestMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_CancelPaymentRequestMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_CancelPaymentRequestMessage::GetClassData() const { return &_class_data_; } + + +void Message_CancelPaymentRequestMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.CancelPaymentRequestMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_key()) { + _this->_internal_mutable_key()->::proto::MessageKey::MergeFrom( + from._internal_key()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_CancelPaymentRequestMessage::CopyFrom(const Message_CancelPaymentRequestMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.CancelPaymentRequestMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_CancelPaymentRequestMessage::IsInitialized() const { + return true; +} + +void Message_CancelPaymentRequestMessage::InternalSwap(Message_CancelPaymentRequestMessage* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_.key_, other->_impl_.key_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_CancelPaymentRequestMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[67]); +} + +// =================================================================== + +class Message_Chat::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_displayname(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_id(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +Message_Chat::Message_Chat(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.Chat) +} +Message_Chat::Message_Chat(const Message_Chat& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_Chat* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.displayname_){} + , decltype(_impl_.id_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.displayname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.displayname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_displayname()) { + _this->_impl_.displayname_.Set(from._internal_displayname(), + _this->GetArenaForAllocation()); + } + _impl_.id_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.id_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_id()) { + _this->_impl_.id_.Set(from._internal_id(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.Message.Chat) +} + +inline void Message_Chat::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.displayname_){} + , decltype(_impl_.id_){} + }; + _impl_.displayname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.displayname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.id_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.id_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_Chat::~Message_Chat() { + // @@protoc_insertion_point(destructor:proto.Message.Chat) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_Chat::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.displayname_.Destroy(); + _impl_.id_.Destroy(); +} + +void Message_Chat::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_Chat::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.Chat) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.displayname_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.id_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_Chat::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string displayName = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_displayname(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.Chat.displayName"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string id = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_id(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.Chat.id"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_Chat::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.Chat) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string displayName = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_displayname().data(), static_cast(this->_internal_displayname().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.Chat.displayName"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_displayname(), target); + } + + // optional string id = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_id().data(), static_cast(this->_internal_id().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.Chat.id"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.Chat) + return target; +} + +size_t Message_Chat::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.Chat) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional string displayName = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_displayname()); + } + + // optional string id = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_id()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_Chat::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_Chat::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_Chat::GetClassData() const { return &_class_data_; } + + +void Message_Chat::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.Chat) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_displayname(from._internal_displayname()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_id(from._internal_id()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_Chat::CopyFrom(const Message_Chat& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.Chat) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_Chat::IsInitialized() const { + return true; +} + +void Message_Chat::InternalSwap(Message_Chat* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.displayname_, lhs_arena, + &other->_impl_.displayname_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.id_, lhs_arena, + &other->_impl_.id_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_Chat::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[68]); +} + +// =================================================================== + +class Message_ContactMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_displayname(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_vcard(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::proto::ContextInfo& contextinfo(const Message_ContactMessage* msg); + static void set_has_contextinfo(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +const ::proto::ContextInfo& +Message_ContactMessage::_Internal::contextinfo(const Message_ContactMessage* msg) { + return *msg->_impl_.contextinfo_; +} +Message_ContactMessage::Message_ContactMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.ContactMessage) +} +Message_ContactMessage::Message_ContactMessage(const Message_ContactMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_ContactMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.displayname_){} + , decltype(_impl_.vcard_){} + , decltype(_impl_.contextinfo_){nullptr}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.displayname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.displayname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_displayname()) { + _this->_impl_.displayname_.Set(from._internal_displayname(), + _this->GetArenaForAllocation()); + } + _impl_.vcard_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.vcard_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_vcard()) { + _this->_impl_.vcard_.Set(from._internal_vcard(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_contextinfo()) { + _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); + } + // @@protoc_insertion_point(copy_constructor:proto.Message.ContactMessage) +} + +inline void Message_ContactMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.displayname_){} + , decltype(_impl_.vcard_){} + , decltype(_impl_.contextinfo_){nullptr} + }; + _impl_.displayname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.displayname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.vcard_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.vcard_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_ContactMessage::~Message_ContactMessage() { + // @@protoc_insertion_point(destructor:proto.Message.ContactMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_ContactMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.displayname_.Destroy(); + _impl_.vcard_.Destroy(); + if (this != internal_default_instance()) delete _impl_.contextinfo_; +} + +void Message_ContactMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_ContactMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.ContactMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _impl_.displayname_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.vcard_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); + _impl_.contextinfo_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_ContactMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string displayName = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_displayname(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ContactMessage.displayName"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string vcard = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { + auto str = _internal_mutable_vcard(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ContactMessage.vcard"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.ContextInfo contextInfo = 17; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { + ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_ContactMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ContactMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string displayName = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_displayname().data(), static_cast(this->_internal_displayname().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ContactMessage.displayName"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_displayname(), target); + } + + // optional string vcard = 16; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_vcard().data(), static_cast(this->_internal_vcard().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ContactMessage.vcard"); + target = stream->WriteStringMaybeAliased( + 16, this->_internal_vcard(), target); + } + + // optional .proto.ContextInfo contextInfo = 17; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(17, _Internal::contextinfo(this), + _Internal::contextinfo(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ContactMessage) + return target; +} + +size_t Message_ContactMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.ContactMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional string displayName = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_displayname()); + } + + // optional string vcard = 16; + if (cached_has_bits & 0x00000002u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_vcard()); + } + + // optional .proto.ContextInfo contextInfo = 17; + if (cached_has_bits & 0x00000004u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.contextinfo_); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ContactMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_ContactMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ContactMessage::GetClassData() const { return &_class_data_; } + + +void Message_ContactMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ContactMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_displayname(from._internal_displayname()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_vcard(from._internal_vcard()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( + from._internal_contextinfo()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_ContactMessage::CopyFrom(const Message_ContactMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ContactMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_ContactMessage::IsInitialized() const { + return true; +} + +void Message_ContactMessage::InternalSwap(Message_ContactMessage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.displayname_, lhs_arena, + &other->_impl_.displayname_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.vcard_, lhs_arena, + &other->_impl_.vcard_, rhs_arena + ); + swap(_impl_.contextinfo_, other->_impl_.contextinfo_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_ContactMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[69]); +} + +// =================================================================== + +class Message_ContactsArrayMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_displayname(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::proto::ContextInfo& contextinfo(const Message_ContactsArrayMessage* msg); + static void set_has_contextinfo(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::proto::ContextInfo& +Message_ContactsArrayMessage::_Internal::contextinfo(const Message_ContactsArrayMessage* msg) { + return *msg->_impl_.contextinfo_; +} +Message_ContactsArrayMessage::Message_ContactsArrayMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.ContactsArrayMessage) +} +Message_ContactsArrayMessage::Message_ContactsArrayMessage(const Message_ContactsArrayMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_ContactsArrayMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.contacts_){from._impl_.contacts_} + , decltype(_impl_.displayname_){} + , decltype(_impl_.contextinfo_){nullptr}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.displayname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.displayname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_displayname()) { + _this->_impl_.displayname_.Set(from._internal_displayname(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_contextinfo()) { + _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); + } + // @@protoc_insertion_point(copy_constructor:proto.Message.ContactsArrayMessage) +} + +inline void Message_ContactsArrayMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.contacts_){arena} + , decltype(_impl_.displayname_){} + , decltype(_impl_.contextinfo_){nullptr} + }; + _impl_.displayname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.displayname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_ContactsArrayMessage::~Message_ContactsArrayMessage() { + // @@protoc_insertion_point(destructor:proto.Message.ContactsArrayMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_ContactsArrayMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.contacts_.~RepeatedPtrField(); + _impl_.displayname_.Destroy(); + if (this != internal_default_instance()) delete _impl_.contextinfo_; +} + +void Message_ContactsArrayMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_ContactsArrayMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.ContactsArrayMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.contacts_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.displayname_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); + _impl_.contextinfo_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_ContactsArrayMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string displayName = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_displayname(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ContactsArrayMessage.displayName"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // repeated .proto.Message.ContactMessage contacts = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_contacts(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else + goto handle_unusual; + continue; + // optional .proto.ContextInfo contextInfo = 17; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { + ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_ContactsArrayMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ContactsArrayMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string displayName = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_displayname().data(), static_cast(this->_internal_displayname().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ContactsArrayMessage.displayName"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_displayname(), target); + } + + // repeated .proto.Message.ContactMessage contacts = 2; + for (unsigned i = 0, + n = static_cast(this->_internal_contacts_size()); i < n; i++) { + const auto& repfield = this->_internal_contacts(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream); + } + + // optional .proto.ContextInfo contextInfo = 17; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(17, _Internal::contextinfo(this), + _Internal::contextinfo(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ContactsArrayMessage) + return target; +} + +size_t Message_ContactsArrayMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.ContactsArrayMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.Message.ContactMessage contacts = 2; + total_size += 1UL * this->_internal_contacts_size(); + for (const auto& msg : this->_impl_.contacts_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional string displayName = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_displayname()); + } + + // optional .proto.ContextInfo contextInfo = 17; + if (cached_has_bits & 0x00000002u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.contextinfo_); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ContactsArrayMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_ContactsArrayMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ContactsArrayMessage::GetClassData() const { return &_class_data_; } + + +void Message_ContactsArrayMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ContactsArrayMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.contacts_.MergeFrom(from._impl_.contacts_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_displayname(from._internal_displayname()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( + from._internal_contextinfo()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_ContactsArrayMessage::CopyFrom(const Message_ContactsArrayMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ContactsArrayMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_ContactsArrayMessage::IsInitialized() const { + return true; +} + +void Message_ContactsArrayMessage::InternalSwap(Message_ContactsArrayMessage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.contacts_.InternalSwap(&other->_impl_.contacts_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.displayname_, lhs_arena, + &other->_impl_.displayname_, rhs_arena + ); + swap(_impl_.contextinfo_, other->_impl_.contextinfo_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_ContactsArrayMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[70]); +} + +// =================================================================== + +class Message_DeclinePaymentRequestMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::MessageKey& key(const Message_DeclinePaymentRequestMessage* msg); + static void set_has_key(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +const ::proto::MessageKey& +Message_DeclinePaymentRequestMessage::_Internal::key(const Message_DeclinePaymentRequestMessage* msg) { + return *msg->_impl_.key_; +} +Message_DeclinePaymentRequestMessage::Message_DeclinePaymentRequestMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.DeclinePaymentRequestMessage) +} +Message_DeclinePaymentRequestMessage::Message_DeclinePaymentRequestMessage(const Message_DeclinePaymentRequestMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_DeclinePaymentRequestMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.key_){nullptr}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_key()) { + _this->_impl_.key_ = new ::proto::MessageKey(*from._impl_.key_); + } + // @@protoc_insertion_point(copy_constructor:proto.Message.DeclinePaymentRequestMessage) +} + +inline void Message_DeclinePaymentRequestMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.key_){nullptr} + }; +} + +Message_DeclinePaymentRequestMessage::~Message_DeclinePaymentRequestMessage() { + // @@protoc_insertion_point(destructor:proto.Message.DeclinePaymentRequestMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_DeclinePaymentRequestMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.key_; +} + +void Message_DeclinePaymentRequestMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_DeclinePaymentRequestMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.DeclinePaymentRequestMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.key_ != nullptr); + _impl_.key_->Clear(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_DeclinePaymentRequestMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.MessageKey key = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_DeclinePaymentRequestMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.DeclinePaymentRequestMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.MessageKey key = 1; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::key(this), + _Internal::key(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.DeclinePaymentRequestMessage) + return target; +} + +size_t Message_DeclinePaymentRequestMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.DeclinePaymentRequestMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional .proto.MessageKey key = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.key_); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_DeclinePaymentRequestMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_DeclinePaymentRequestMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_DeclinePaymentRequestMessage::GetClassData() const { return &_class_data_; } + + +void Message_DeclinePaymentRequestMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.DeclinePaymentRequestMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_key()) { + _this->_internal_mutable_key()->::proto::MessageKey::MergeFrom( + from._internal_key()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_DeclinePaymentRequestMessage::CopyFrom(const Message_DeclinePaymentRequestMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.DeclinePaymentRequestMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_DeclinePaymentRequestMessage::IsInitialized() const { + return true; +} + +void Message_DeclinePaymentRequestMessage::InternalSwap(Message_DeclinePaymentRequestMessage* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_.key_, other->_impl_.key_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_DeclinePaymentRequestMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[71]); +} + +// =================================================================== + +class Message_DeviceSentMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_destinationjid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::proto::Message& message(const Message_DeviceSentMessage* msg); + static void set_has_message(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_phash(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::proto::Message& +Message_DeviceSentMessage::_Internal::message(const Message_DeviceSentMessage* msg) { + return *msg->_impl_.message_; +} +Message_DeviceSentMessage::Message_DeviceSentMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.DeviceSentMessage) +} +Message_DeviceSentMessage::Message_DeviceSentMessage(const Message_DeviceSentMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_DeviceSentMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.destinationjid_){} + , decltype(_impl_.phash_){} + , decltype(_impl_.message_){nullptr}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.destinationjid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.destinationjid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_destinationjid()) { + _this->_impl_.destinationjid_.Set(from._internal_destinationjid(), + _this->GetArenaForAllocation()); + } + _impl_.phash_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.phash_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_phash()) { + _this->_impl_.phash_.Set(from._internal_phash(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_message()) { + _this->_impl_.message_ = new ::proto::Message(*from._impl_.message_); + } + // @@protoc_insertion_point(copy_constructor:proto.Message.DeviceSentMessage) +} + +inline void Message_DeviceSentMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.destinationjid_){} + , decltype(_impl_.phash_){} + , decltype(_impl_.message_){nullptr} + }; + _impl_.destinationjid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.destinationjid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.phash_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.phash_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_DeviceSentMessage::~Message_DeviceSentMessage() { + // @@protoc_insertion_point(destructor:proto.Message.DeviceSentMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_DeviceSentMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.destinationjid_.Destroy(); + _impl_.phash_.Destroy(); + if (this != internal_default_instance()) delete _impl_.message_; +} + +void Message_DeviceSentMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_DeviceSentMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.DeviceSentMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _impl_.destinationjid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.phash_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.message_ != nullptr); + _impl_.message_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_DeviceSentMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string destinationJid = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_destinationjid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.DeviceSentMessage.destinationJid"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.Message message = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_message(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string phash = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_phash(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.DeviceSentMessage.phash"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_DeviceSentMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.DeviceSentMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string destinationJid = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_destinationjid().data(), static_cast(this->_internal_destinationjid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.DeviceSentMessage.destinationJid"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_destinationjid(), target); + } + + // optional .proto.Message message = 2; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::message(this), + _Internal::message(this).GetCachedSize(), target, stream); + } + + // optional string phash = 3; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_phash().data(), static_cast(this->_internal_phash().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.DeviceSentMessage.phash"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_phash(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.DeviceSentMessage) + return target; +} + +size_t Message_DeviceSentMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.DeviceSentMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional string destinationJid = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_destinationjid()); + } + + // optional string phash = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_phash()); + } + + // optional .proto.Message message = 2; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.message_); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_DeviceSentMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_DeviceSentMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_DeviceSentMessage::GetClassData() const { return &_class_data_; } + + +void Message_DeviceSentMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.DeviceSentMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_destinationjid(from._internal_destinationjid()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_phash(from._internal_phash()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_message()->::proto::Message::MergeFrom( + from._internal_message()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_DeviceSentMessage::CopyFrom(const Message_DeviceSentMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.DeviceSentMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_DeviceSentMessage::IsInitialized() const { + return true; +} + +void Message_DeviceSentMessage::InternalSwap(Message_DeviceSentMessage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.destinationjid_, lhs_arena, + &other->_impl_.destinationjid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.phash_, lhs_arena, + &other->_impl_.phash_, rhs_arena + ); + swap(_impl_.message_, other->_impl_.message_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_DeviceSentMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[72]); +} + +// =================================================================== + +class Message_DocumentMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_url(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_mimetype(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_title(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_filesha256(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_filelength(HasBits* has_bits) { + (*has_bits)[0] |= 16384u; + } + static void set_has_pagecount(HasBits* has_bits) { + (*has_bits)[0] |= 32768u; + } + static void set_has_mediakey(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_filename(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_fileencsha256(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_directpath(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_mediakeytimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 131072u; + } + static void set_has_contactvcard(HasBits* has_bits) { + (*has_bits)[0] |= 65536u; + } + static void set_has_thumbnaildirectpath(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_thumbnailsha256(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_thumbnailencsha256(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static void set_has_jpegthumbnail(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static const ::proto::ContextInfo& contextinfo(const Message_DocumentMessage* msg); + static void set_has_contextinfo(HasBits* has_bits) { + (*has_bits)[0] |= 8192u; + } + static void set_has_thumbnailheight(HasBits* has_bits) { + (*has_bits)[0] |= 262144u; + } + static void set_has_thumbnailwidth(HasBits* has_bits) { + (*has_bits)[0] |= 524288u; + } + static void set_has_caption(HasBits* has_bits) { + (*has_bits)[0] |= 4096u; + } +}; + +const ::proto::ContextInfo& +Message_DocumentMessage::_Internal::contextinfo(const Message_DocumentMessage* msg) { + return *msg->_impl_.contextinfo_; +} +Message_DocumentMessage::Message_DocumentMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.DocumentMessage) +} +Message_DocumentMessage::Message_DocumentMessage(const Message_DocumentMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_DocumentMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.url_){} + , decltype(_impl_.mimetype_){} + , decltype(_impl_.title_){} + , decltype(_impl_.filesha256_){} + , decltype(_impl_.mediakey_){} + , decltype(_impl_.filename_){} + , decltype(_impl_.fileencsha256_){} + , decltype(_impl_.directpath_){} + , decltype(_impl_.thumbnaildirectpath_){} + , decltype(_impl_.thumbnailsha256_){} + , decltype(_impl_.thumbnailencsha256_){} + , decltype(_impl_.jpegthumbnail_){} + , decltype(_impl_.caption_){} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.filelength_){} + , decltype(_impl_.pagecount_){} + , decltype(_impl_.contactvcard_){} + , decltype(_impl_.mediakeytimestamp_){} + , decltype(_impl_.thumbnailheight_){} + , decltype(_impl_.thumbnailwidth_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.url_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.url_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_url()) { + _this->_impl_.url_.Set(from._internal_url(), + _this->GetArenaForAllocation()); + } + _impl_.mimetype_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mimetype_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_mimetype()) { + _this->_impl_.mimetype_.Set(from._internal_mimetype(), + _this->GetArenaForAllocation()); + } + _impl_.title_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.title_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_title()) { + _this->_impl_.title_.Set(from._internal_title(), + _this->GetArenaForAllocation()); + } + _impl_.filesha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filesha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_filesha256()) { + _this->_impl_.filesha256_.Set(from._internal_filesha256(), + _this->GetArenaForAllocation()); + } + _impl_.mediakey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediakey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_mediakey()) { + _this->_impl_.mediakey_.Set(from._internal_mediakey(), + _this->GetArenaForAllocation()); + } + _impl_.filename_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filename_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_filename()) { + _this->_impl_.filename_.Set(from._internal_filename(), + _this->GetArenaForAllocation()); + } + _impl_.fileencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_fileencsha256()) { + _this->_impl_.fileencsha256_.Set(from._internal_fileencsha256(), + _this->GetArenaForAllocation()); + } + _impl_.directpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_directpath()) { + _this->_impl_.directpath_.Set(from._internal_directpath(), + _this->GetArenaForAllocation()); + } + _impl_.thumbnaildirectpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_thumbnaildirectpath()) { + _this->_impl_.thumbnaildirectpath_.Set(from._internal_thumbnaildirectpath(), + _this->GetArenaForAllocation()); + } + _impl_.thumbnailsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_thumbnailsha256()) { + _this->_impl_.thumbnailsha256_.Set(from._internal_thumbnailsha256(), + _this->GetArenaForAllocation()); + } + _impl_.thumbnailencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_thumbnailencsha256()) { + _this->_impl_.thumbnailencsha256_.Set(from._internal_thumbnailencsha256(), + _this->GetArenaForAllocation()); + } + _impl_.jpegthumbnail_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_jpegthumbnail()) { + _this->_impl_.jpegthumbnail_.Set(from._internal_jpegthumbnail(), + _this->GetArenaForAllocation()); + } + _impl_.caption_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.caption_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_caption()) { + _this->_impl_.caption_.Set(from._internal_caption(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_contextinfo()) { + _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); + } + ::memcpy(&_impl_.filelength_, &from._impl_.filelength_, + static_cast(reinterpret_cast(&_impl_.thumbnailwidth_) - + reinterpret_cast(&_impl_.filelength_)) + sizeof(_impl_.thumbnailwidth_)); + // @@protoc_insertion_point(copy_constructor:proto.Message.DocumentMessage) +} + +inline void Message_DocumentMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.url_){} + , decltype(_impl_.mimetype_){} + , decltype(_impl_.title_){} + , decltype(_impl_.filesha256_){} + , decltype(_impl_.mediakey_){} + , decltype(_impl_.filename_){} + , decltype(_impl_.fileencsha256_){} + , decltype(_impl_.directpath_){} + , decltype(_impl_.thumbnaildirectpath_){} + , decltype(_impl_.thumbnailsha256_){} + , decltype(_impl_.thumbnailencsha256_){} + , decltype(_impl_.jpegthumbnail_){} + , decltype(_impl_.caption_){} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.filelength_){uint64_t{0u}} + , decltype(_impl_.pagecount_){0u} + , decltype(_impl_.contactvcard_){false} + , decltype(_impl_.mediakeytimestamp_){int64_t{0}} + , decltype(_impl_.thumbnailheight_){0u} + , decltype(_impl_.thumbnailwidth_){0u} + }; + _impl_.url_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.url_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mimetype_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mimetype_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.title_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.title_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filesha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filesha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediakey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediakey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filename_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filename_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fileencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnaildirectpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnailsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnailencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.jpegthumbnail_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.caption_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.caption_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_DocumentMessage::~Message_DocumentMessage() { + // @@protoc_insertion_point(destructor:proto.Message.DocumentMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_DocumentMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.url_.Destroy(); + _impl_.mimetype_.Destroy(); + _impl_.title_.Destroy(); + _impl_.filesha256_.Destroy(); + _impl_.mediakey_.Destroy(); + _impl_.filename_.Destroy(); + _impl_.fileencsha256_.Destroy(); + _impl_.directpath_.Destroy(); + _impl_.thumbnaildirectpath_.Destroy(); + _impl_.thumbnailsha256_.Destroy(); + _impl_.thumbnailencsha256_.Destroy(); + _impl_.jpegthumbnail_.Destroy(); + _impl_.caption_.Destroy(); + if (this != internal_default_instance()) delete _impl_.contextinfo_; +} + +void Message_DocumentMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_DocumentMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.DocumentMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _impl_.url_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.mimetype_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.title_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + _impl_.filesha256_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + _impl_.mediakey_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000020u) { + _impl_.filename_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000040u) { + _impl_.fileencsha256_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000080u) { + _impl_.directpath_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x00003f00u) { + if (cached_has_bits & 0x00000100u) { + _impl_.thumbnaildirectpath_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000200u) { + _impl_.thumbnailsha256_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000400u) { + _impl_.thumbnailencsha256_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000800u) { + _impl_.jpegthumbnail_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00001000u) { + _impl_.caption_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00002000u) { + GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); + _impl_.contextinfo_->Clear(); + } + } + if (cached_has_bits & 0x0000c000u) { + ::memset(&_impl_.filelength_, 0, static_cast( + reinterpret_cast(&_impl_.pagecount_) - + reinterpret_cast(&_impl_.filelength_)) + sizeof(_impl_.pagecount_)); + } + if (cached_has_bits & 0x000f0000u) { + ::memset(&_impl_.contactvcard_, 0, static_cast( + reinterpret_cast(&_impl_.thumbnailwidth_) - + reinterpret_cast(&_impl_.contactvcard_)) + sizeof(_impl_.thumbnailwidth_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_DocumentMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string url = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_url(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.DocumentMessage.url"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string mimetype = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_mimetype(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.DocumentMessage.mimetype"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string title = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_title(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.DocumentMessage.title"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bytes fileSha256 = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_filesha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint64 fileLength = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_filelength(&has_bits); + _impl_.filelength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 pageCount = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + _Internal::set_has_pagecount(&has_bits); + _impl_.pagecount_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes mediaKey = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + auto str = _internal_mutable_mediakey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string fileName = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + auto str = _internal_mutable_filename(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.DocumentMessage.fileName"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bytes fileEncSha256 = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + auto str = _internal_mutable_fileencsha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string directPath = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { + auto str = _internal_mutable_directpath(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.DocumentMessage.directPath"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional int64 mediaKeyTimestamp = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { + _Internal::set_has_mediakeytimestamp(&has_bits); + _impl_.mediakeytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool contactVcard = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { + _Internal::set_has_contactvcard(&has_bits); + _impl_.contactvcard_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string thumbnailDirectPath = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { + auto str = _internal_mutable_thumbnaildirectpath(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.DocumentMessage.thumbnailDirectPath"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bytes thumbnailSha256 = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) { + auto str = _internal_mutable_thumbnailsha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes thumbnailEncSha256 = 15; + case 15: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { + auto str = _internal_mutable_thumbnailencsha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes jpegThumbnail = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { + auto str = _internal_mutable_jpegthumbnail(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.ContextInfo contextInfo = 17; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { + ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 thumbnailHeight = 18; + case 18: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 144)) { + _Internal::set_has_thumbnailheight(&has_bits); + _impl_.thumbnailheight_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 thumbnailWidth = 19; + case 19: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 152)) { + _Internal::set_has_thumbnailwidth(&has_bits); + _impl_.thumbnailwidth_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string caption = 20; + case 20: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 162)) { + auto str = _internal_mutable_caption(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.DocumentMessage.caption"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_DocumentMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.DocumentMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string url = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_url().data(), static_cast(this->_internal_url().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.DocumentMessage.url"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_url(), target); + } + + // optional string mimetype = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_mimetype().data(), static_cast(this->_internal_mimetype().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.DocumentMessage.mimetype"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_mimetype(), target); + } + + // optional string title = 3; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_title().data(), static_cast(this->_internal_title().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.DocumentMessage.title"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_title(), target); + } + + // optional bytes fileSha256 = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->WriteBytesMaybeAliased( + 4, this->_internal_filesha256(), target); + } + + // optional uint64 fileLength = 5; + if (cached_has_bits & 0x00004000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_filelength(), target); + } + + // optional uint32 pageCount = 6; + if (cached_has_bits & 0x00008000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_pagecount(), target); + } + + // optional bytes mediaKey = 7; + if (cached_has_bits & 0x00000010u) { + target = stream->WriteBytesMaybeAliased( + 7, this->_internal_mediakey(), target); + } + + // optional string fileName = 8; + if (cached_has_bits & 0x00000020u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_filename().data(), static_cast(this->_internal_filename().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.DocumentMessage.fileName"); + target = stream->WriteStringMaybeAliased( + 8, this->_internal_filename(), target); + } + + // optional bytes fileEncSha256 = 9; + if (cached_has_bits & 0x00000040u) { + target = stream->WriteBytesMaybeAliased( + 9, this->_internal_fileencsha256(), target); + } + + // optional string directPath = 10; + if (cached_has_bits & 0x00000080u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_directpath().data(), static_cast(this->_internal_directpath().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.DocumentMessage.directPath"); + target = stream->WriteStringMaybeAliased( + 10, this->_internal_directpath(), target); + } + + // optional int64 mediaKeyTimestamp = 11; + if (cached_has_bits & 0x00020000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(11, this->_internal_mediakeytimestamp(), target); + } + + // optional bool contactVcard = 12; + if (cached_has_bits & 0x00010000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(12, this->_internal_contactvcard(), target); + } + + // optional string thumbnailDirectPath = 13; + if (cached_has_bits & 0x00000100u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_thumbnaildirectpath().data(), static_cast(this->_internal_thumbnaildirectpath().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.DocumentMessage.thumbnailDirectPath"); + target = stream->WriteStringMaybeAliased( + 13, this->_internal_thumbnaildirectpath(), target); + } + + // optional bytes thumbnailSha256 = 14; + if (cached_has_bits & 0x00000200u) { + target = stream->WriteBytesMaybeAliased( + 14, this->_internal_thumbnailsha256(), target); + } + + // optional bytes thumbnailEncSha256 = 15; + if (cached_has_bits & 0x00000400u) { + target = stream->WriteBytesMaybeAliased( + 15, this->_internal_thumbnailencsha256(), target); + } + + // optional bytes jpegThumbnail = 16; + if (cached_has_bits & 0x00000800u) { + target = stream->WriteBytesMaybeAliased( + 16, this->_internal_jpegthumbnail(), target); + } + + // optional .proto.ContextInfo contextInfo = 17; + if (cached_has_bits & 0x00002000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(17, _Internal::contextinfo(this), + _Internal::contextinfo(this).GetCachedSize(), target, stream); + } + + // optional uint32 thumbnailHeight = 18; + if (cached_has_bits & 0x00040000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(18, this->_internal_thumbnailheight(), target); + } + + // optional uint32 thumbnailWidth = 19; + if (cached_has_bits & 0x00080000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(19, this->_internal_thumbnailwidth(), target); + } + + // optional string caption = 20; + if (cached_has_bits & 0x00001000u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_caption().data(), static_cast(this->_internal_caption().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.DocumentMessage.caption"); + target = stream->WriteStringMaybeAliased( + 20, this->_internal_caption(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.DocumentMessage) + return target; +} + +size_t Message_DocumentMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.DocumentMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string url = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_url()); + } + + // optional string mimetype = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_mimetype()); + } + + // optional string title = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_title()); + } + + // optional bytes fileSha256 = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_filesha256()); + } + + // optional bytes mediaKey = 7; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_mediakey()); + } + + // optional string fileName = 8; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_filename()); + } + + // optional bytes fileEncSha256 = 9; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_fileencsha256()); + } + + // optional string directPath = 10; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_directpath()); + } + + } + if (cached_has_bits & 0x0000ff00u) { + // optional string thumbnailDirectPath = 13; + if (cached_has_bits & 0x00000100u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_thumbnaildirectpath()); + } + + // optional bytes thumbnailSha256 = 14; + if (cached_has_bits & 0x00000200u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_thumbnailsha256()); + } + + // optional bytes thumbnailEncSha256 = 15; + if (cached_has_bits & 0x00000400u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_thumbnailencsha256()); + } + + // optional bytes jpegThumbnail = 16; + if (cached_has_bits & 0x00000800u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_jpegthumbnail()); + } + + // optional string caption = 20; + if (cached_has_bits & 0x00001000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_caption()); + } + + // optional .proto.ContextInfo contextInfo = 17; + if (cached_has_bits & 0x00002000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.contextinfo_); + } + + // optional uint64 fileLength = 5; + if (cached_has_bits & 0x00004000u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_filelength()); + } + + // optional uint32 pageCount = 6; + if (cached_has_bits & 0x00008000u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_pagecount()); + } + + } + if (cached_has_bits & 0x000f0000u) { + // optional bool contactVcard = 12; + if (cached_has_bits & 0x00010000u) { + total_size += 1 + 1; + } + + // optional int64 mediaKeyTimestamp = 11; + if (cached_has_bits & 0x00020000u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_mediakeytimestamp()); + } + + // optional uint32 thumbnailHeight = 18; + if (cached_has_bits & 0x00040000u) { + total_size += 2 + + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_thumbnailheight()); + } + + // optional uint32 thumbnailWidth = 19; + if (cached_has_bits & 0x00080000u) { + total_size += 2 + + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_thumbnailwidth()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_DocumentMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_DocumentMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_DocumentMessage::GetClassData() const { return &_class_data_; } + + +void Message_DocumentMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.DocumentMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_url(from._internal_url()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_mimetype(from._internal_mimetype()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_title(from._internal_title()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_set_filesha256(from._internal_filesha256()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_set_mediakey(from._internal_mediakey()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_set_filename(from._internal_filename()); + } + if (cached_has_bits & 0x00000040u) { + _this->_internal_set_fileencsha256(from._internal_fileencsha256()); + } + if (cached_has_bits & 0x00000080u) { + _this->_internal_set_directpath(from._internal_directpath()); + } + } + if (cached_has_bits & 0x0000ff00u) { + if (cached_has_bits & 0x00000100u) { + _this->_internal_set_thumbnaildirectpath(from._internal_thumbnaildirectpath()); + } + if (cached_has_bits & 0x00000200u) { + _this->_internal_set_thumbnailsha256(from._internal_thumbnailsha256()); + } + if (cached_has_bits & 0x00000400u) { + _this->_internal_set_thumbnailencsha256(from._internal_thumbnailencsha256()); + } + if (cached_has_bits & 0x00000800u) { + _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail()); + } + if (cached_has_bits & 0x00001000u) { + _this->_internal_set_caption(from._internal_caption()); + } + if (cached_has_bits & 0x00002000u) { + _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( + from._internal_contextinfo()); + } + if (cached_has_bits & 0x00004000u) { + _this->_impl_.filelength_ = from._impl_.filelength_; + } + if (cached_has_bits & 0x00008000u) { + _this->_impl_.pagecount_ = from._impl_.pagecount_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x000f0000u) { + if (cached_has_bits & 0x00010000u) { + _this->_impl_.contactvcard_ = from._impl_.contactvcard_; + } + if (cached_has_bits & 0x00020000u) { + _this->_impl_.mediakeytimestamp_ = from._impl_.mediakeytimestamp_; + } + if (cached_has_bits & 0x00040000u) { + _this->_impl_.thumbnailheight_ = from._impl_.thumbnailheight_; + } + if (cached_has_bits & 0x00080000u) { + _this->_impl_.thumbnailwidth_ = from._impl_.thumbnailwidth_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_DocumentMessage::CopyFrom(const Message_DocumentMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.DocumentMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_DocumentMessage::IsInitialized() const { + return true; +} + +void Message_DocumentMessage::InternalSwap(Message_DocumentMessage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.url_, lhs_arena, + &other->_impl_.url_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.mimetype_, lhs_arena, + &other->_impl_.mimetype_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.title_, lhs_arena, + &other->_impl_.title_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.filesha256_, lhs_arena, + &other->_impl_.filesha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.mediakey_, lhs_arena, + &other->_impl_.mediakey_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.filename_, lhs_arena, + &other->_impl_.filename_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.fileencsha256_, lhs_arena, + &other->_impl_.fileencsha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.directpath_, lhs_arena, + &other->_impl_.directpath_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.thumbnaildirectpath_, lhs_arena, + &other->_impl_.thumbnaildirectpath_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.thumbnailsha256_, lhs_arena, + &other->_impl_.thumbnailsha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.thumbnailencsha256_, lhs_arena, + &other->_impl_.thumbnailencsha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.jpegthumbnail_, lhs_arena, + &other->_impl_.jpegthumbnail_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.caption_, lhs_arena, + &other->_impl_.caption_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_DocumentMessage, _impl_.thumbnailwidth_) + + sizeof(Message_DocumentMessage::_impl_.thumbnailwidth_) + - PROTOBUF_FIELD_OFFSET(Message_DocumentMessage, _impl_.contextinfo_)>( + reinterpret_cast(&_impl_.contextinfo_), + reinterpret_cast(&other->_impl_.contextinfo_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_DocumentMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[73]); +} + +// =================================================================== + +class Message_ExtendedTextMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_text(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_matchedtext(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_canonicalurl(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_description(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_title(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_textargb(HasBits* has_bits) { + (*has_bits)[0] |= 8192u; + } + static void set_has_backgroundargb(HasBits* has_bits) { + (*has_bits)[0] |= 16384u; + } + static void set_has_font(HasBits* has_bits) { + (*has_bits)[0] |= 32768u; + } + static void set_has_previewtype(HasBits* has_bits) { + (*has_bits)[0] |= 65536u; + } + static void set_has_jpegthumbnail(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static const ::proto::ContextInfo& contextinfo(const Message_ExtendedTextMessage* msg); + static void set_has_contextinfo(HasBits* has_bits) { + (*has_bits)[0] |= 4096u; + } + static void set_has_donotplayinline(HasBits* has_bits) { + (*has_bits)[0] |= 131072u; + } + static void set_has_thumbnaildirectpath(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_thumbnailsha256(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_thumbnailencsha256(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_mediakey(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_mediakeytimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 524288u; + } + static void set_has_thumbnailheight(HasBits* has_bits) { + (*has_bits)[0] |= 262144u; + } + static void set_has_thumbnailwidth(HasBits* has_bits) { + (*has_bits)[0] |= 1048576u; + } + static void set_has_invitelinkgrouptype(HasBits* has_bits) { + (*has_bits)[0] |= 2097152u; + } + static void set_has_invitelinkparentgroupsubjectv2(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static void set_has_invitelinkparentgroupthumbnailv2(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static void set_has_invitelinkgrouptypev2(HasBits* has_bits) { + (*has_bits)[0] |= 4194304u; + } +}; + +const ::proto::ContextInfo& +Message_ExtendedTextMessage::_Internal::contextinfo(const Message_ExtendedTextMessage* msg) { + return *msg->_impl_.contextinfo_; +} +Message_ExtendedTextMessage::Message_ExtendedTextMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.ExtendedTextMessage) +} +Message_ExtendedTextMessage::Message_ExtendedTextMessage(const Message_ExtendedTextMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_ExtendedTextMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.text_){} + , decltype(_impl_.matchedtext_){} + , decltype(_impl_.canonicalurl_){} + , decltype(_impl_.description_){} + , decltype(_impl_.title_){} + , decltype(_impl_.jpegthumbnail_){} + , decltype(_impl_.thumbnaildirectpath_){} + , decltype(_impl_.thumbnailsha256_){} + , decltype(_impl_.thumbnailencsha256_){} + , decltype(_impl_.mediakey_){} + , decltype(_impl_.invitelinkparentgroupsubjectv2_){} + , decltype(_impl_.invitelinkparentgroupthumbnailv2_){} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.textargb_){} + , decltype(_impl_.backgroundargb_){} + , decltype(_impl_.font_){} + , decltype(_impl_.previewtype_){} + , decltype(_impl_.donotplayinline_){} + , decltype(_impl_.thumbnailheight_){} + , decltype(_impl_.mediakeytimestamp_){} + , decltype(_impl_.thumbnailwidth_){} + , decltype(_impl_.invitelinkgrouptype_){} + , decltype(_impl_.invitelinkgrouptypev2_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.text_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.text_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_text()) { + _this->_impl_.text_.Set(from._internal_text(), + _this->GetArenaForAllocation()); + } + _impl_.matchedtext_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.matchedtext_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_matchedtext()) { + _this->_impl_.matchedtext_.Set(from._internal_matchedtext(), + _this->GetArenaForAllocation()); + } + _impl_.canonicalurl_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.canonicalurl_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_canonicalurl()) { + _this->_impl_.canonicalurl_.Set(from._internal_canonicalurl(), + _this->GetArenaForAllocation()); + } + _impl_.description_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.description_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_description()) { + _this->_impl_.description_.Set(from._internal_description(), + _this->GetArenaForAllocation()); + } + _impl_.title_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.title_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_title()) { + _this->_impl_.title_.Set(from._internal_title(), + _this->GetArenaForAllocation()); + } + _impl_.jpegthumbnail_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_jpegthumbnail()) { + _this->_impl_.jpegthumbnail_.Set(from._internal_jpegthumbnail(), + _this->GetArenaForAllocation()); + } + _impl_.thumbnaildirectpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_thumbnaildirectpath()) { + _this->_impl_.thumbnaildirectpath_.Set(from._internal_thumbnaildirectpath(), + _this->GetArenaForAllocation()); + } + _impl_.thumbnailsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_thumbnailsha256()) { + _this->_impl_.thumbnailsha256_.Set(from._internal_thumbnailsha256(), + _this->GetArenaForAllocation()); + } + _impl_.thumbnailencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_thumbnailencsha256()) { + _this->_impl_.thumbnailencsha256_.Set(from._internal_thumbnailencsha256(), + _this->GetArenaForAllocation()); + } + _impl_.mediakey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediakey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_mediakey()) { + _this->_impl_.mediakey_.Set(from._internal_mediakey(), + _this->GetArenaForAllocation()); + } + _impl_.invitelinkparentgroupsubjectv2_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.invitelinkparentgroupsubjectv2_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_invitelinkparentgroupsubjectv2()) { + _this->_impl_.invitelinkparentgroupsubjectv2_.Set(from._internal_invitelinkparentgroupsubjectv2(), + _this->GetArenaForAllocation()); + } + _impl_.invitelinkparentgroupthumbnailv2_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.invitelinkparentgroupthumbnailv2_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_invitelinkparentgroupthumbnailv2()) { + _this->_impl_.invitelinkparentgroupthumbnailv2_.Set(from._internal_invitelinkparentgroupthumbnailv2(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_contextinfo()) { + _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); + } + ::memcpy(&_impl_.textargb_, &from._impl_.textargb_, + static_cast(reinterpret_cast(&_impl_.invitelinkgrouptypev2_) - + reinterpret_cast(&_impl_.textargb_)) + sizeof(_impl_.invitelinkgrouptypev2_)); + // @@protoc_insertion_point(copy_constructor:proto.Message.ExtendedTextMessage) +} + +inline void Message_ExtendedTextMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.text_){} + , decltype(_impl_.matchedtext_){} + , decltype(_impl_.canonicalurl_){} + , decltype(_impl_.description_){} + , decltype(_impl_.title_){} + , decltype(_impl_.jpegthumbnail_){} + , decltype(_impl_.thumbnaildirectpath_){} + , decltype(_impl_.thumbnailsha256_){} + , decltype(_impl_.thumbnailencsha256_){} + , decltype(_impl_.mediakey_){} + , decltype(_impl_.invitelinkparentgroupsubjectv2_){} + , decltype(_impl_.invitelinkparentgroupthumbnailv2_){} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.textargb_){0u} + , decltype(_impl_.backgroundargb_){0u} + , decltype(_impl_.font_){0} + , decltype(_impl_.previewtype_){0} + , decltype(_impl_.donotplayinline_){false} + , decltype(_impl_.thumbnailheight_){0u} + , decltype(_impl_.mediakeytimestamp_){int64_t{0}} + , decltype(_impl_.thumbnailwidth_){0u} + , decltype(_impl_.invitelinkgrouptype_){0} + , decltype(_impl_.invitelinkgrouptypev2_){0} + }; + _impl_.text_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.text_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.matchedtext_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.matchedtext_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.canonicalurl_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.canonicalurl_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.description_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.description_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.title_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.title_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.jpegthumbnail_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnaildirectpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnailsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnailencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediakey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediakey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.invitelinkparentgroupsubjectv2_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.invitelinkparentgroupsubjectv2_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.invitelinkparentgroupthumbnailv2_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.invitelinkparentgroupthumbnailv2_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_ExtendedTextMessage::~Message_ExtendedTextMessage() { + // @@protoc_insertion_point(destructor:proto.Message.ExtendedTextMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_ExtendedTextMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.text_.Destroy(); + _impl_.matchedtext_.Destroy(); + _impl_.canonicalurl_.Destroy(); + _impl_.description_.Destroy(); + _impl_.title_.Destroy(); + _impl_.jpegthumbnail_.Destroy(); + _impl_.thumbnaildirectpath_.Destroy(); + _impl_.thumbnailsha256_.Destroy(); + _impl_.thumbnailencsha256_.Destroy(); + _impl_.mediakey_.Destroy(); + _impl_.invitelinkparentgroupsubjectv2_.Destroy(); + _impl_.invitelinkparentgroupthumbnailv2_.Destroy(); + if (this != internal_default_instance()) delete _impl_.contextinfo_; +} + +void Message_ExtendedTextMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_ExtendedTextMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.ExtendedTextMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _impl_.text_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.matchedtext_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.canonicalurl_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + _impl_.description_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + _impl_.title_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000020u) { + _impl_.jpegthumbnail_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000040u) { + _impl_.thumbnaildirectpath_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000080u) { + _impl_.thumbnailsha256_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x00001f00u) { + if (cached_has_bits & 0x00000100u) { + _impl_.thumbnailencsha256_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000200u) { + _impl_.mediakey_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000400u) { + _impl_.invitelinkparentgroupsubjectv2_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000800u) { + _impl_.invitelinkparentgroupthumbnailv2_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00001000u) { + GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); + _impl_.contextinfo_->Clear(); + } + } + if (cached_has_bits & 0x0000e000u) { + ::memset(&_impl_.textargb_, 0, static_cast( + reinterpret_cast(&_impl_.font_) - + reinterpret_cast(&_impl_.textargb_)) + sizeof(_impl_.font_)); + } + if (cached_has_bits & 0x007f0000u) { + ::memset(&_impl_.previewtype_, 0, static_cast( + reinterpret_cast(&_impl_.invitelinkgrouptypev2_) - + reinterpret_cast(&_impl_.previewtype_)) + sizeof(_impl_.invitelinkgrouptypev2_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_ExtendedTextMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string text = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_text(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ExtendedTextMessage.text"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string matchedText = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_matchedtext(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ExtendedTextMessage.matchedText"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string canonicalUrl = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_canonicalurl(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ExtendedTextMessage.canonicalUrl"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string description = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + auto str = _internal_mutable_description(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ExtendedTextMessage.description"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string title = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + auto str = _internal_mutable_title(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ExtendedTextMessage.title"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional fixed32 textArgb = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 61)) { + _Internal::set_has_textargb(&has_bits); + _impl_.textargb_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(uint32_t); + } else + goto handle_unusual; + continue; + // optional fixed32 backgroundArgb = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 69)) { + _Internal::set_has_backgroundargb(&has_bits); + _impl_.backgroundargb_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(uint32_t); + } else + goto handle_unusual; + continue; + // optional .proto.Message.ExtendedTextMessage.FontType font = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::Message_ExtendedTextMessage_FontType_IsValid(val))) { + _internal_set_font(static_cast<::proto::Message_ExtendedTextMessage_FontType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(9, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.Message.ExtendedTextMessage.PreviewType previewType = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::Message_ExtendedTextMessage_PreviewType_IsValid(val))) { + _internal_set_previewtype(static_cast<::proto::Message_ExtendedTextMessage_PreviewType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(10, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional bytes jpegThumbnail = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { + auto str = _internal_mutable_jpegthumbnail(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.ContextInfo contextInfo = 17; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { + ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool doNotPlayInline = 18; + case 18: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 144)) { + _Internal::set_has_donotplayinline(&has_bits); + _impl_.donotplayinline_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string thumbnailDirectPath = 19; + case 19: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) { + auto str = _internal_mutable_thumbnaildirectpath(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ExtendedTextMessage.thumbnailDirectPath"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bytes thumbnailSha256 = 20; + case 20: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 162)) { + auto str = _internal_mutable_thumbnailsha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes thumbnailEncSha256 = 21; + case 21: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { + auto str = _internal_mutable_thumbnailencsha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes mediaKey = 22; + case 22: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 178)) { + auto str = _internal_mutable_mediakey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 mediaKeyTimestamp = 23; + case 23: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 184)) { + _Internal::set_has_mediakeytimestamp(&has_bits); + _impl_.mediakeytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 thumbnailHeight = 24; + case 24: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 192)) { + _Internal::set_has_thumbnailheight(&has_bits); + _impl_.thumbnailheight_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 thumbnailWidth = 25; + case 25: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 200)) { + _Internal::set_has_thumbnailwidth(&has_bits); + _impl_.thumbnailwidth_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupType = 26; + case 26: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 208)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::Message_ExtendedTextMessage_InviteLinkGroupType_IsValid(val))) { + _internal_set_invitelinkgrouptype(static_cast<::proto::Message_ExtendedTextMessage_InviteLinkGroupType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(26, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional string inviteLinkParentGroupSubjectV2 = 27; + case 27: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 218)) { + auto str = _internal_mutable_invitelinkparentgroupsubjectv2(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ExtendedTextMessage.inviteLinkParentGroupSubjectV2"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bytes inviteLinkParentGroupThumbnailV2 = 28; + case 28: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 226)) { + auto str = _internal_mutable_invitelinkparentgroupthumbnailv2(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupTypeV2 = 29; + case 29: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 232)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::Message_ExtendedTextMessage_InviteLinkGroupType_IsValid(val))) { + _internal_set_invitelinkgrouptypev2(static_cast<::proto::Message_ExtendedTextMessage_InviteLinkGroupType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(29, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_ExtendedTextMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ExtendedTextMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string text = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_text().data(), static_cast(this->_internal_text().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ExtendedTextMessage.text"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_text(), target); + } + + // optional string matchedText = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_matchedtext().data(), static_cast(this->_internal_matchedtext().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ExtendedTextMessage.matchedText"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_matchedtext(), target); + } + + // optional string canonicalUrl = 4; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_canonicalurl().data(), static_cast(this->_internal_canonicalurl().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ExtendedTextMessage.canonicalUrl"); + target = stream->WriteStringMaybeAliased( + 4, this->_internal_canonicalurl(), target); + } + + // optional string description = 5; + if (cached_has_bits & 0x00000008u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_description().data(), static_cast(this->_internal_description().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ExtendedTextMessage.description"); + target = stream->WriteStringMaybeAliased( + 5, this->_internal_description(), target); + } + + // optional string title = 6; + if (cached_has_bits & 0x00000010u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_title().data(), static_cast(this->_internal_title().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ExtendedTextMessage.title"); + target = stream->WriteStringMaybeAliased( + 6, this->_internal_title(), target); + } + + // optional fixed32 textArgb = 7; + if (cached_has_bits & 0x00002000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFixed32ToArray(7, this->_internal_textargb(), target); + } + + // optional fixed32 backgroundArgb = 8; + if (cached_has_bits & 0x00004000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFixed32ToArray(8, this->_internal_backgroundargb(), target); + } + + // optional .proto.Message.ExtendedTextMessage.FontType font = 9; + if (cached_has_bits & 0x00008000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 9, this->_internal_font(), target); + } + + // optional .proto.Message.ExtendedTextMessage.PreviewType previewType = 10; + if (cached_has_bits & 0x00010000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 10, this->_internal_previewtype(), target); + } + + // optional bytes jpegThumbnail = 16; + if (cached_has_bits & 0x00000020u) { + target = stream->WriteBytesMaybeAliased( + 16, this->_internal_jpegthumbnail(), target); + } + + // optional .proto.ContextInfo contextInfo = 17; + if (cached_has_bits & 0x00001000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(17, _Internal::contextinfo(this), + _Internal::contextinfo(this).GetCachedSize(), target, stream); + } + + // optional bool doNotPlayInline = 18; + if (cached_has_bits & 0x00020000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(18, this->_internal_donotplayinline(), target); + } + + // optional string thumbnailDirectPath = 19; + if (cached_has_bits & 0x00000040u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_thumbnaildirectpath().data(), static_cast(this->_internal_thumbnaildirectpath().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ExtendedTextMessage.thumbnailDirectPath"); + target = stream->WriteStringMaybeAliased( + 19, this->_internal_thumbnaildirectpath(), target); + } + + // optional bytes thumbnailSha256 = 20; + if (cached_has_bits & 0x00000080u) { + target = stream->WriteBytesMaybeAliased( + 20, this->_internal_thumbnailsha256(), target); + } + + // optional bytes thumbnailEncSha256 = 21; + if (cached_has_bits & 0x00000100u) { + target = stream->WriteBytesMaybeAliased( + 21, this->_internal_thumbnailencsha256(), target); + } + + // optional bytes mediaKey = 22; + if (cached_has_bits & 0x00000200u) { + target = stream->WriteBytesMaybeAliased( + 22, this->_internal_mediakey(), target); + } + + // optional int64 mediaKeyTimestamp = 23; + if (cached_has_bits & 0x00080000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(23, this->_internal_mediakeytimestamp(), target); + } + + // optional uint32 thumbnailHeight = 24; + if (cached_has_bits & 0x00040000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(24, this->_internal_thumbnailheight(), target); + } + + // optional uint32 thumbnailWidth = 25; + if (cached_has_bits & 0x00100000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(25, this->_internal_thumbnailwidth(), target); + } + + // optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupType = 26; + if (cached_has_bits & 0x00200000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 26, this->_internal_invitelinkgrouptype(), target); + } + + // optional string inviteLinkParentGroupSubjectV2 = 27; + if (cached_has_bits & 0x00000400u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_invitelinkparentgroupsubjectv2().data(), static_cast(this->_internal_invitelinkparentgroupsubjectv2().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ExtendedTextMessage.inviteLinkParentGroupSubjectV2"); + target = stream->WriteStringMaybeAliased( + 27, this->_internal_invitelinkparentgroupsubjectv2(), target); + } + + // optional bytes inviteLinkParentGroupThumbnailV2 = 28; + if (cached_has_bits & 0x00000800u) { + target = stream->WriteBytesMaybeAliased( + 28, this->_internal_invitelinkparentgroupthumbnailv2(), target); + } + + // optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupTypeV2 = 29; + if (cached_has_bits & 0x00400000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 29, this->_internal_invitelinkgrouptypev2(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ExtendedTextMessage) + return target; +} + +size_t Message_ExtendedTextMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.ExtendedTextMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string text = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_text()); + } + + // optional string matchedText = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_matchedtext()); + } + + // optional string canonicalUrl = 4; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_canonicalurl()); + } + + // optional string description = 5; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_description()); + } + + // optional string title = 6; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_title()); + } + + // optional bytes jpegThumbnail = 16; + if (cached_has_bits & 0x00000020u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_jpegthumbnail()); + } + + // optional string thumbnailDirectPath = 19; + if (cached_has_bits & 0x00000040u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_thumbnaildirectpath()); + } + + // optional bytes thumbnailSha256 = 20; + if (cached_has_bits & 0x00000080u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_thumbnailsha256()); + } + + } + if (cached_has_bits & 0x0000ff00u) { + // optional bytes thumbnailEncSha256 = 21; + if (cached_has_bits & 0x00000100u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_thumbnailencsha256()); + } + + // optional bytes mediaKey = 22; + if (cached_has_bits & 0x00000200u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_mediakey()); + } + + // optional string inviteLinkParentGroupSubjectV2 = 27; + if (cached_has_bits & 0x00000400u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_invitelinkparentgroupsubjectv2()); + } + + // optional bytes inviteLinkParentGroupThumbnailV2 = 28; + if (cached_has_bits & 0x00000800u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_invitelinkparentgroupthumbnailv2()); + } + + // optional .proto.ContextInfo contextInfo = 17; + if (cached_has_bits & 0x00001000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.contextinfo_); + } + + // optional fixed32 textArgb = 7; + if (cached_has_bits & 0x00002000u) { + total_size += 1 + 4; + } + + // optional fixed32 backgroundArgb = 8; + if (cached_has_bits & 0x00004000u) { + total_size += 1 + 4; + } + + // optional .proto.Message.ExtendedTextMessage.FontType font = 9; + if (cached_has_bits & 0x00008000u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_font()); + } + + } + if (cached_has_bits & 0x007f0000u) { + // optional .proto.Message.ExtendedTextMessage.PreviewType previewType = 10; + if (cached_has_bits & 0x00010000u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_previewtype()); + } + + // optional bool doNotPlayInline = 18; + if (cached_has_bits & 0x00020000u) { + total_size += 2 + 1; + } + + // optional uint32 thumbnailHeight = 24; + if (cached_has_bits & 0x00040000u) { + total_size += 2 + + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_thumbnailheight()); + } + + // optional int64 mediaKeyTimestamp = 23; + if (cached_has_bits & 0x00080000u) { + total_size += 2 + + ::_pbi::WireFormatLite::Int64Size( + this->_internal_mediakeytimestamp()); + } + + // optional uint32 thumbnailWidth = 25; + if (cached_has_bits & 0x00100000u) { + total_size += 2 + + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_thumbnailwidth()); + } + + // optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupType = 26; + if (cached_has_bits & 0x00200000u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_invitelinkgrouptype()); + } + + // optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupTypeV2 = 29; + if (cached_has_bits & 0x00400000u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_invitelinkgrouptypev2()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ExtendedTextMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_ExtendedTextMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ExtendedTextMessage::GetClassData() const { return &_class_data_; } + + +void Message_ExtendedTextMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ExtendedTextMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_text(from._internal_text()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_matchedtext(from._internal_matchedtext()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_canonicalurl(from._internal_canonicalurl()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_set_description(from._internal_description()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_set_title(from._internal_title()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail()); + } + if (cached_has_bits & 0x00000040u) { + _this->_internal_set_thumbnaildirectpath(from._internal_thumbnaildirectpath()); + } + if (cached_has_bits & 0x00000080u) { + _this->_internal_set_thumbnailsha256(from._internal_thumbnailsha256()); + } + } + if (cached_has_bits & 0x0000ff00u) { + if (cached_has_bits & 0x00000100u) { + _this->_internal_set_thumbnailencsha256(from._internal_thumbnailencsha256()); + } + if (cached_has_bits & 0x00000200u) { + _this->_internal_set_mediakey(from._internal_mediakey()); + } + if (cached_has_bits & 0x00000400u) { + _this->_internal_set_invitelinkparentgroupsubjectv2(from._internal_invitelinkparentgroupsubjectv2()); + } + if (cached_has_bits & 0x00000800u) { + _this->_internal_set_invitelinkparentgroupthumbnailv2(from._internal_invitelinkparentgroupthumbnailv2()); + } + if (cached_has_bits & 0x00001000u) { + _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( + from._internal_contextinfo()); + } + if (cached_has_bits & 0x00002000u) { + _this->_impl_.textargb_ = from._impl_.textargb_; + } + if (cached_has_bits & 0x00004000u) { + _this->_impl_.backgroundargb_ = from._impl_.backgroundargb_; + } + if (cached_has_bits & 0x00008000u) { + _this->_impl_.font_ = from._impl_.font_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x007f0000u) { + if (cached_has_bits & 0x00010000u) { + _this->_impl_.previewtype_ = from._impl_.previewtype_; + } + if (cached_has_bits & 0x00020000u) { + _this->_impl_.donotplayinline_ = from._impl_.donotplayinline_; + } + if (cached_has_bits & 0x00040000u) { + _this->_impl_.thumbnailheight_ = from._impl_.thumbnailheight_; + } + if (cached_has_bits & 0x00080000u) { + _this->_impl_.mediakeytimestamp_ = from._impl_.mediakeytimestamp_; + } + if (cached_has_bits & 0x00100000u) { + _this->_impl_.thumbnailwidth_ = from._impl_.thumbnailwidth_; + } + if (cached_has_bits & 0x00200000u) { + _this->_impl_.invitelinkgrouptype_ = from._impl_.invitelinkgrouptype_; + } + if (cached_has_bits & 0x00400000u) { + _this->_impl_.invitelinkgrouptypev2_ = from._impl_.invitelinkgrouptypev2_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_ExtendedTextMessage::CopyFrom(const Message_ExtendedTextMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ExtendedTextMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_ExtendedTextMessage::IsInitialized() const { + return true; +} + +void Message_ExtendedTextMessage::InternalSwap(Message_ExtendedTextMessage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.text_, lhs_arena, + &other->_impl_.text_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.matchedtext_, lhs_arena, + &other->_impl_.matchedtext_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.canonicalurl_, lhs_arena, + &other->_impl_.canonicalurl_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.description_, lhs_arena, + &other->_impl_.description_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.title_, lhs_arena, + &other->_impl_.title_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.jpegthumbnail_, lhs_arena, + &other->_impl_.jpegthumbnail_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.thumbnaildirectpath_, lhs_arena, + &other->_impl_.thumbnaildirectpath_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.thumbnailsha256_, lhs_arena, + &other->_impl_.thumbnailsha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.thumbnailencsha256_, lhs_arena, + &other->_impl_.thumbnailencsha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.mediakey_, lhs_arena, + &other->_impl_.mediakey_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.invitelinkparentgroupsubjectv2_, lhs_arena, + &other->_impl_.invitelinkparentgroupsubjectv2_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.invitelinkparentgroupthumbnailv2_, lhs_arena, + &other->_impl_.invitelinkparentgroupthumbnailv2_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_ExtendedTextMessage, _impl_.invitelinkgrouptypev2_) + + sizeof(Message_ExtendedTextMessage::_impl_.invitelinkgrouptypev2_) + - PROTOBUF_FIELD_OFFSET(Message_ExtendedTextMessage, _impl_.contextinfo_)>( + reinterpret_cast(&_impl_.contextinfo_), + reinterpret_cast(&other->_impl_.contextinfo_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_ExtendedTextMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[74]); +} + +// =================================================================== + +class Message_FutureProofMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::Message& message(const Message_FutureProofMessage* msg); + static void set_has_message(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +const ::proto::Message& +Message_FutureProofMessage::_Internal::message(const Message_FutureProofMessage* msg) { + return *msg->_impl_.message_; +} +Message_FutureProofMessage::Message_FutureProofMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.FutureProofMessage) +} +Message_FutureProofMessage::Message_FutureProofMessage(const Message_FutureProofMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_FutureProofMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.message_){nullptr}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_message()) { + _this->_impl_.message_ = new ::proto::Message(*from._impl_.message_); + } + // @@protoc_insertion_point(copy_constructor:proto.Message.FutureProofMessage) +} + +inline void Message_FutureProofMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.message_){nullptr} + }; +} + +Message_FutureProofMessage::~Message_FutureProofMessage() { + // @@protoc_insertion_point(destructor:proto.Message.FutureProofMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_FutureProofMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.message_; +} + +void Message_FutureProofMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_FutureProofMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.FutureProofMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.message_ != nullptr); + _impl_.message_->Clear(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_FutureProofMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.Message message = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_message(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_FutureProofMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.FutureProofMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.Message message = 1; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::message(this), + _Internal::message(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.FutureProofMessage) + return target; +} + +size_t Message_FutureProofMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.FutureProofMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional .proto.Message message = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.message_); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_FutureProofMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_FutureProofMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_FutureProofMessage::GetClassData() const { return &_class_data_; } + + +void Message_FutureProofMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.FutureProofMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_message()) { + _this->_internal_mutable_message()->::proto::Message::MergeFrom( + from._internal_message()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_FutureProofMessage::CopyFrom(const Message_FutureProofMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.FutureProofMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_FutureProofMessage::IsInitialized() const { + return true; +} + +void Message_FutureProofMessage::InternalSwap(Message_FutureProofMessage* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_.message_, other->_impl_.message_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_FutureProofMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[75]); +} + +// =================================================================== + +class Message_GroupInviteMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_groupjid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_invitecode(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_inviteexpiration(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_groupname(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_jpegthumbnail(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_caption(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static const ::proto::ContextInfo& contextinfo(const Message_GroupInviteMessage* msg); + static void set_has_contextinfo(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_grouptype(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } +}; + +const ::proto::ContextInfo& +Message_GroupInviteMessage::_Internal::contextinfo(const Message_GroupInviteMessage* msg) { + return *msg->_impl_.contextinfo_; +} +Message_GroupInviteMessage::Message_GroupInviteMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.GroupInviteMessage) +} +Message_GroupInviteMessage::Message_GroupInviteMessage(const Message_GroupInviteMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_GroupInviteMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.groupjid_){} + , decltype(_impl_.invitecode_){} + , decltype(_impl_.groupname_){} + , decltype(_impl_.jpegthumbnail_){} + , decltype(_impl_.caption_){} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.inviteexpiration_){} + , decltype(_impl_.grouptype_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.groupjid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.groupjid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_groupjid()) { + _this->_impl_.groupjid_.Set(from._internal_groupjid(), + _this->GetArenaForAllocation()); + } + _impl_.invitecode_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.invitecode_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_invitecode()) { + _this->_impl_.invitecode_.Set(from._internal_invitecode(), + _this->GetArenaForAllocation()); + } + _impl_.groupname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.groupname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_groupname()) { + _this->_impl_.groupname_.Set(from._internal_groupname(), + _this->GetArenaForAllocation()); + } + _impl_.jpegthumbnail_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_jpegthumbnail()) { + _this->_impl_.jpegthumbnail_.Set(from._internal_jpegthumbnail(), + _this->GetArenaForAllocation()); + } + _impl_.caption_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.caption_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_caption()) { + _this->_impl_.caption_.Set(from._internal_caption(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_contextinfo()) { + _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); + } + ::memcpy(&_impl_.inviteexpiration_, &from._impl_.inviteexpiration_, + static_cast(reinterpret_cast(&_impl_.grouptype_) - + reinterpret_cast(&_impl_.inviteexpiration_)) + sizeof(_impl_.grouptype_)); + // @@protoc_insertion_point(copy_constructor:proto.Message.GroupInviteMessage) +} + +inline void Message_GroupInviteMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.groupjid_){} + , decltype(_impl_.invitecode_){} + , decltype(_impl_.groupname_){} + , decltype(_impl_.jpegthumbnail_){} + , decltype(_impl_.caption_){} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.inviteexpiration_){int64_t{0}} + , decltype(_impl_.grouptype_){0} + }; + _impl_.groupjid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.groupjid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.invitecode_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.invitecode_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.groupname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.groupname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.jpegthumbnail_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.caption_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.caption_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_GroupInviteMessage::~Message_GroupInviteMessage() { + // @@protoc_insertion_point(destructor:proto.Message.GroupInviteMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_GroupInviteMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.groupjid_.Destroy(); + _impl_.invitecode_.Destroy(); + _impl_.groupname_.Destroy(); + _impl_.jpegthumbnail_.Destroy(); + _impl_.caption_.Destroy(); + if (this != internal_default_instance()) delete _impl_.contextinfo_; +} + +void Message_GroupInviteMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_GroupInviteMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.GroupInviteMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + _impl_.groupjid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.invitecode_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.groupname_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + _impl_.jpegthumbnail_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + _impl_.caption_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000020u) { + GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); + _impl_.contextinfo_->Clear(); + } + } + if (cached_has_bits & 0x000000c0u) { + ::memset(&_impl_.inviteexpiration_, 0, static_cast( + reinterpret_cast(&_impl_.grouptype_) - + reinterpret_cast(&_impl_.inviteexpiration_)) + sizeof(_impl_.grouptype_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_GroupInviteMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string groupJid = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_groupjid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.GroupInviteMessage.groupJid"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string inviteCode = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_invitecode(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.GroupInviteMessage.inviteCode"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional int64 inviteExpiration = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_inviteexpiration(&has_bits); + _impl_.inviteexpiration_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string groupName = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_groupname(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.GroupInviteMessage.groupName"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bytes jpegThumbnail = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + auto str = _internal_mutable_jpegthumbnail(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string caption = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + auto str = _internal_mutable_caption(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.GroupInviteMessage.caption"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.ContextInfo contextInfo = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.GroupInviteMessage.GroupType groupType = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::Message_GroupInviteMessage_GroupType_IsValid(val))) { + _internal_set_grouptype(static_cast<::proto::Message_GroupInviteMessage_GroupType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(8, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_GroupInviteMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.GroupInviteMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string groupJid = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_groupjid().data(), static_cast(this->_internal_groupjid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.GroupInviteMessage.groupJid"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_groupjid(), target); + } + + // optional string inviteCode = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_invitecode().data(), static_cast(this->_internal_invitecode().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.GroupInviteMessage.inviteCode"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_invitecode(), target); + } + + // optional int64 inviteExpiration = 3; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_inviteexpiration(), target); + } + + // optional string groupName = 4; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_groupname().data(), static_cast(this->_internal_groupname().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.GroupInviteMessage.groupName"); + target = stream->WriteStringMaybeAliased( + 4, this->_internal_groupname(), target); + } + + // optional bytes jpegThumbnail = 5; + if (cached_has_bits & 0x00000008u) { + target = stream->WriteBytesMaybeAliased( + 5, this->_internal_jpegthumbnail(), target); + } + + // optional string caption = 6; + if (cached_has_bits & 0x00000010u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_caption().data(), static_cast(this->_internal_caption().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.GroupInviteMessage.caption"); + target = stream->WriteStringMaybeAliased( + 6, this->_internal_caption(), target); + } + + // optional .proto.ContextInfo contextInfo = 7; + if (cached_has_bits & 0x00000020u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(7, _Internal::contextinfo(this), + _Internal::contextinfo(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.GroupInviteMessage.GroupType groupType = 8; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 8, this->_internal_grouptype(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.GroupInviteMessage) + return target; +} + +size_t Message_GroupInviteMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.GroupInviteMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string groupJid = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_groupjid()); + } + + // optional string inviteCode = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_invitecode()); + } + + // optional string groupName = 4; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_groupname()); + } + + // optional bytes jpegThumbnail = 5; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_jpegthumbnail()); + } + + // optional string caption = 6; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_caption()); + } + + // optional .proto.ContextInfo contextInfo = 7; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.contextinfo_); + } + + // optional int64 inviteExpiration = 3; + if (cached_has_bits & 0x00000040u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_inviteexpiration()); + } + + // optional .proto.Message.GroupInviteMessage.GroupType groupType = 8; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_grouptype()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_GroupInviteMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_GroupInviteMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_GroupInviteMessage::GetClassData() const { return &_class_data_; } + + +void Message_GroupInviteMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.GroupInviteMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_groupjid(from._internal_groupjid()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_invitecode(from._internal_invitecode()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_groupname(from._internal_groupname()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_set_caption(from._internal_caption()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( + from._internal_contextinfo()); + } + if (cached_has_bits & 0x00000040u) { + _this->_impl_.inviteexpiration_ = from._impl_.inviteexpiration_; + } + if (cached_has_bits & 0x00000080u) { + _this->_impl_.grouptype_ = from._impl_.grouptype_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_GroupInviteMessage::CopyFrom(const Message_GroupInviteMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.GroupInviteMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_GroupInviteMessage::IsInitialized() const { + return true; +} + +void Message_GroupInviteMessage::InternalSwap(Message_GroupInviteMessage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.groupjid_, lhs_arena, + &other->_impl_.groupjid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.invitecode_, lhs_arena, + &other->_impl_.invitecode_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.groupname_, lhs_arena, + &other->_impl_.groupname_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.jpegthumbnail_, lhs_arena, + &other->_impl_.jpegthumbnail_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.caption_, lhs_arena, + &other->_impl_.caption_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_GroupInviteMessage, _impl_.grouptype_) + + sizeof(Message_GroupInviteMessage::_impl_.grouptype_) + - PROTOBUF_FIELD_OFFSET(Message_GroupInviteMessage, _impl_.contextinfo_)>( + reinterpret_cast(&_impl_.contextinfo_), + reinterpret_cast(&other->_impl_.contextinfo_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_GroupInviteMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[76]); +} + +// =================================================================== + +class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_currencycode(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_amount1000(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency) +} +Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.currencycode_){} + , decltype(_impl_.amount1000_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.currencycode_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.currencycode_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_currencycode()) { + _this->_impl_.currencycode_.Set(from._internal_currencycode(), + _this->GetArenaForAllocation()); + } + _this->_impl_.amount1000_ = from._impl_.amount1000_; + // @@protoc_insertion_point(copy_constructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency) +} + +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.currencycode_){} + , decltype(_impl_.amount1000_){int64_t{0}} + }; + _impl_.currencycode_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.currencycode_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency() { + // @@protoc_insertion_point(destructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.currencycode_.Destroy(); +} + +void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.currencycode_.ClearNonDefaultToEmpty(); + } + _impl_.amount1000_ = int64_t{0}; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string currencyCode = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_currencycode(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.currencyCode"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional int64 amount1000 = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_amount1000(&has_bits); + _impl_.amount1000_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string currencyCode = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_currencycode().data(), static_cast(this->_internal_currencycode().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.currencyCode"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_currencycode(), target); + } + + // optional int64 amount1000 = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_amount1000(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency) + return target; +} + +size_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional string currencyCode = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_currencycode()); + } + + // optional int64 amount1000 = 2; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_amount1000()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::GetClassData() const { return &_class_data_; } + + +void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_currencycode(from._internal_currencycode()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.amount1000_ = from._impl_.amount1000_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::IsInitialized() const { + return true; +} + +void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.currencycode_, lhs_arena, + &other->_impl_.currencycode_, rhs_arena + ); + swap(_impl_.amount1000_, other->_impl_.amount1000_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[77]); +} + +// =================================================================== + +class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_dayofweek(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_year(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_month(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_dayofmonth(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_hour(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_minute(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_calendar(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } +}; + +Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent) +} +Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.year_){} + , decltype(_impl_.month_){} + , decltype(_impl_.dayofmonth_){} + , decltype(_impl_.hour_){} + , decltype(_impl_.minute_){} + , decltype(_impl_.dayofweek_){} + , decltype(_impl_.calendar_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&_impl_.year_, &from._impl_.year_, + static_cast(reinterpret_cast(&_impl_.calendar_) - + reinterpret_cast(&_impl_.year_)) + sizeof(_impl_.calendar_)); + // @@protoc_insertion_point(copy_constructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent) +} + +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.year_){0u} + , decltype(_impl_.month_){0u} + , decltype(_impl_.dayofmonth_){0u} + , decltype(_impl_.hour_){0u} + , decltype(_impl_.minute_){0u} + , decltype(_impl_.dayofweek_){1} + , decltype(_impl_.calendar_){1} + }; +} + +Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent() { + // @@protoc_insertion_point(destructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + ::memset(&_impl_.year_, 0, static_cast( + reinterpret_cast(&_impl_.minute_) - + reinterpret_cast(&_impl_.year_)) + sizeof(_impl_.minute_)); + _impl_.dayofweek_ = 1; + _impl_.calendar_ = 1; + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.DayOfWeekType dayOfWeek = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_IsValid(val))) { + _internal_set_dayofweek(static_cast<::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional uint32 year = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_year(&has_bits); + _impl_.year_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 month = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_month(&has_bits); + _impl_.month_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 dayOfMonth = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_dayofmonth(&has_bits); + _impl_.dayofmonth_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 hour = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_hour(&has_bits); + _impl_.hour_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 minute = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + _Internal::set_has_minute(&has_bits); + _impl_.minute_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.CalendarType calendar = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_IsValid(val))) { + _internal_set_calendar(static_cast<::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(7, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.DayOfWeekType dayOfWeek = 1; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this->_internal_dayofweek(), target); + } + + // optional uint32 year = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_year(), target); + } + + // optional uint32 month = 3; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_month(), target); + } + + // optional uint32 dayOfMonth = 4; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_dayofmonth(), target); + } + + // optional uint32 hour = 5; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_hour(), target); + } + + // optional uint32 minute = 6; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_minute(), target); + } + + // optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.CalendarType calendar = 7; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 7, this->_internal_calendar(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent) + return target; +} + +size_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + // optional uint32 year = 2; + if (cached_has_bits & 0x00000001u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_year()); + } + + // optional uint32 month = 3; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_month()); + } + + // optional uint32 dayOfMonth = 4; + if (cached_has_bits & 0x00000004u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_dayofmonth()); + } + + // optional uint32 hour = 5; + if (cached_has_bits & 0x00000008u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_hour()); + } + + // optional uint32 minute = 6; + if (cached_has_bits & 0x00000010u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_minute()); + } + + // optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.DayOfWeekType dayOfWeek = 1; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_dayofweek()); + } + + // optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.CalendarType calendar = 7; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_calendar()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::GetClassData() const { return &_class_data_; } + + +void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + if (cached_has_bits & 0x00000001u) { + _this->_impl_.year_ = from._impl_.year_; + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.month_ = from._impl_.month_; + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.dayofmonth_ = from._impl_.dayofmonth_; + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.hour_ = from._impl_.hour_; + } + if (cached_has_bits & 0x00000010u) { + _this->_impl_.minute_ = from._impl_.minute_; + } + if (cached_has_bits & 0x00000020u) { + _this->_impl_.dayofweek_ = from._impl_.dayofweek_; + } + if (cached_has_bits & 0x00000040u) { + _this->_impl_.calendar_ = from._impl_.calendar_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::IsInitialized() const { + return true; +} + +void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _impl_.minute_) + + sizeof(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_impl_.minute_) + - PROTOBUF_FIELD_OFFSET(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _impl_.year_)>( + reinterpret_cast(&_impl_.year_), + reinterpret_cast(&other->_impl_.year_)); + swap(_impl_.dayofweek_, other->_impl_.dayofweek_); + swap(_impl_.calendar_, other->_impl_.calendar_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[78]); +} + +// =================================================================== + +class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_timestamp(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch) +} +Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.timestamp_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _this->_impl_.timestamp_ = from._impl_.timestamp_; + // @@protoc_insertion_point(copy_constructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch) +} + +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.timestamp_){int64_t{0}} + }; +} + +Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch() { + // @@protoc_insertion_point(destructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.timestamp_ = int64_t{0}; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional int64 timestamp = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_timestamp(&has_bits); + _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional int64 timestamp = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_timestamp(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch) + return target; +} + +size_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional int64 timestamp = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_timestamp()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::GetClassData() const { return &_class_data_; } + + +void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_timestamp()) { + _this->_internal_set_timestamp(from._internal_timestamp()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::IsInitialized() const { + return true; +} + +void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_.timestamp_, other->_impl_.timestamp_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[79]); +} + +// =================================================================== + +class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_Internal { + public: + static const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& component(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* msg); + static const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& unixepoch(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* msg); +}; + +const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& +Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_Internal::component(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* msg) { + return *msg->_impl_.datetimeOneof_.component_; +} +const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& +Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_Internal::unixepoch(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* msg) { + return *msg->_impl_.datetimeOneof_.unixepoch_; +} +void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::set_allocated_component(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* component) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_datetimeOneof(); + if (component) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(component); + if (message_arena != submessage_arena) { + component = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, component, submessage_arena); + } + set_has_component(); + _impl_.datetimeOneof_.component_ = component; + } + // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.component) +} +void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::set_allocated_unixepoch(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* unixepoch) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_datetimeOneof(); + if (unixepoch) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(unixepoch); + if (message_arena != submessage_arena) { + unixepoch = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, unixepoch, submessage_arena); + } + set_has_unixepoch(); + _impl_.datetimeOneof_.unixepoch_ = unixepoch; + } + // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.unixEpoch) +} +Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime) +} +Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.datetimeOneof_){} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_._oneof_case_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + clear_has_datetimeOneof(); + switch (from.datetimeOneof_case()) { + case kComponent: { + _this->_internal_mutable_component()->::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::MergeFrom( + from._internal_component()); + break; + } + case kUnixEpoch: { + _this->_internal_mutable_unixepoch()->::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::MergeFrom( + from._internal_unixepoch()); + break; + } + case DATETIMEONEOF_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime) +} + +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_.datetimeOneof_){} + , /*decltype(_impl_._cached_size_)*/{} + , /*decltype(_impl_._oneof_case_)*/{} + }; + clear_has_datetimeOneof(); +} + +Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime() { + // @@protoc_insertion_point(destructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (has_datetimeOneof()) { + clear_datetimeOneof(); + } +} + +void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::clear_datetimeOneof() { +// @@protoc_insertion_point(one_of_clear_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime) + switch (datetimeOneof_case()) { + case kComponent: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.datetimeOneof_.component_; + } + break; + } + case kUnixEpoch: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.datetimeOneof_.unixepoch_; + } + break; + } + case DATETIMEONEOF_NOT_SET: { + break; + } + } + _impl_._oneof_case_[0] = DATETIMEONEOF_NOT_SET; +} + + +void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_datetimeOneof(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent component = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_component(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch unixEpoch = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_unixepoch(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + switch (datetimeOneof_case()) { + case kComponent: { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::component(this), + _Internal::component(this).GetCachedSize(), target, stream); + break; + } + case kUnixEpoch: { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::unixepoch(this), + _Internal::unixepoch(this).GetCachedSize(), target, stream); + break; + } + default: ; + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime) + return target; +} + +size_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + switch (datetimeOneof_case()) { + // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent component = 1; + case kComponent: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.datetimeOneof_.component_); + break; + } + // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch unixEpoch = 2; + case kUnixEpoch: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.datetimeOneof_.unixepoch_); + break; + } + case DATETIMEONEOF_NOT_SET: { + break; + } + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::GetClassData() const { return &_class_data_; } + + +void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.datetimeOneof_case()) { + case kComponent: { + _this->_internal_mutable_component()->::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::MergeFrom( + from._internal_component()); + break; + } + case kUnixEpoch: { + _this->_internal_mutable_unixepoch()->::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::MergeFrom( + from._internal_unixepoch()); + break; + } + case DATETIMEONEOF_NOT_SET: { + break; + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::IsInitialized() const { + return true; +} + +void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.datetimeOneof_, other->_impl_.datetimeOneof_); + swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[80]); +} + +// =================================================================== + +class Message_HighlyStructuredMessage_HSMLocalizableParameter::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_default_(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& currency(const Message_HighlyStructuredMessage_HSMLocalizableParameter* msg); + static const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& datetime(const Message_HighlyStructuredMessage_HSMLocalizableParameter* msg); +}; + +const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& +Message_HighlyStructuredMessage_HSMLocalizableParameter::_Internal::currency(const Message_HighlyStructuredMessage_HSMLocalizableParameter* msg) { + return *msg->_impl_.paramOneof_.currency_; +} +const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& +Message_HighlyStructuredMessage_HSMLocalizableParameter::_Internal::datetime(const Message_HighlyStructuredMessage_HSMLocalizableParameter* msg) { + return *msg->_impl_.paramOneof_.datetime_; +} +void Message_HighlyStructuredMessage_HSMLocalizableParameter::set_allocated_currency(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* currency) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_paramOneof(); + if (currency) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(currency); + if (message_arena != submessage_arena) { + currency = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, currency, submessage_arena); + } + set_has_currency(); + _impl_.paramOneof_.currency_ = currency; + } + // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.currency) +} +void Message_HighlyStructuredMessage_HSMLocalizableParameter::set_allocated_datetime(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* datetime) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_paramOneof(); + if (datetime) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(datetime); + if (message_arena != submessage_arena) { + datetime = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, datetime, submessage_arena); + } + set_has_datetime(); + _impl_.paramOneof_.datetime_ = datetime; + } + // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.dateTime) +} +Message_HighlyStructuredMessage_HSMLocalizableParameter::Message_HighlyStructuredMessage_HSMLocalizableParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter) +} +Message_HighlyStructuredMessage_HSMLocalizableParameter::Message_HighlyStructuredMessage_HSMLocalizableParameter(const Message_HighlyStructuredMessage_HSMLocalizableParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_HighlyStructuredMessage_HSMLocalizableParameter* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.default__){} + , decltype(_impl_.paramOneof_){} + , /*decltype(_impl_._oneof_case_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.default__.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.default__.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_default_()) { + _this->_impl_.default__.Set(from._internal_default_(), + _this->GetArenaForAllocation()); + } + clear_has_paramOneof(); + switch (from.paramOneof_case()) { + case kCurrency: { + _this->_internal_mutable_currency()->::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::MergeFrom( + from._internal_currency()); + break; + } + case kDateTime: { + _this->_internal_mutable_datetime()->::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::MergeFrom( + from._internal_datetime()); + break; + } + case PARAMONEOF_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter) +} + +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.default__){} + , decltype(_impl_.paramOneof_){} + , /*decltype(_impl_._oneof_case_)*/{} + }; + _impl_.default__.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.default__.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + clear_has_paramOneof(); +} + +Message_HighlyStructuredMessage_HSMLocalizableParameter::~Message_HighlyStructuredMessage_HSMLocalizableParameter() { + // @@protoc_insertion_point(destructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.default__.Destroy(); + if (has_paramOneof()) { + clear_paramOneof(); + } +} + +void Message_HighlyStructuredMessage_HSMLocalizableParameter::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_HighlyStructuredMessage_HSMLocalizableParameter::clear_paramOneof() { +// @@protoc_insertion_point(one_of_clear_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter) + switch (paramOneof_case()) { + case kCurrency: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.paramOneof_.currency_; + } + break; + } + case kDateTime: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.paramOneof_.datetime_; + } + break; + } + case PARAMONEOF_NOT_SET: { + break; + } + } + _impl_._oneof_case_[0] = PARAMONEOF_NOT_SET; +} + + +void Message_HighlyStructuredMessage_HSMLocalizableParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.default__.ClearNonDefaultToEmpty(); + } + clear_paramOneof(); + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_HighlyStructuredMessage_HSMLocalizableParameter::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string default = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_default_(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.default"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency currency = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_currency(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime dateTime = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_datetime(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_HighlyStructuredMessage_HSMLocalizableParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string default = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_default_().data(), static_cast(this->_internal_default_().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.default"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_default_(), target); + } + + switch (paramOneof_case()) { + case kCurrency: { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::currency(this), + _Internal::currency(this).GetCachedSize(), target, stream); + break; + } + case kDateTime: { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::datetime(this), + _Internal::datetime(this).GetCachedSize(), target, stream); + break; + } + default: ; + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter) + return target; +} + +size_t Message_HighlyStructuredMessage_HSMLocalizableParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional string default = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_default_()); + } + + switch (paramOneof_case()) { + // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency currency = 2; + case kCurrency: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.paramOneof_.currency_); + break; + } + // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime dateTime = 3; + case kDateTime: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.paramOneof_.datetime_); + break; + } + case PARAMONEOF_NOT_SET: { + break; + } + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_HighlyStructuredMessage_HSMLocalizableParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_HighlyStructuredMessage_HSMLocalizableParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_HighlyStructuredMessage_HSMLocalizableParameter::GetClassData() const { return &_class_data_; } + + +void Message_HighlyStructuredMessage_HSMLocalizableParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_default_()) { + _this->_internal_set_default_(from._internal_default_()); + } + switch (from.paramOneof_case()) { + case kCurrency: { + _this->_internal_mutable_currency()->::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::MergeFrom( + from._internal_currency()); + break; + } + case kDateTime: { + _this->_internal_mutable_datetime()->::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::MergeFrom( + from._internal_datetime()); + break; + } + case PARAMONEOF_NOT_SET: { + break; + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_HighlyStructuredMessage_HSMLocalizableParameter::CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_HighlyStructuredMessage_HSMLocalizableParameter::IsInitialized() const { + return true; +} + +void Message_HighlyStructuredMessage_HSMLocalizableParameter::InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.default__, lhs_arena, + &other->_impl_.default__, rhs_arena + ); + swap(_impl_.paramOneof_, other->_impl_.paramOneof_); + swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_HighlyStructuredMessage_HSMLocalizableParameter::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[81]); +} + +// =================================================================== + +class Message_HighlyStructuredMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_namespace_(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_elementname(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_fallbacklg(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_fallbacklc(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_deterministiclg(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_deterministiclc(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static const ::proto::Message_TemplateMessage& hydratedhsm(const Message_HighlyStructuredMessage* msg); + static void set_has_hydratedhsm(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } +}; + +const ::proto::Message_TemplateMessage& +Message_HighlyStructuredMessage::_Internal::hydratedhsm(const Message_HighlyStructuredMessage* msg) { + return *msg->_impl_.hydratedhsm_; +} +Message_HighlyStructuredMessage::Message_HighlyStructuredMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.HighlyStructuredMessage) +} +Message_HighlyStructuredMessage::Message_HighlyStructuredMessage(const Message_HighlyStructuredMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_HighlyStructuredMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.params_){from._impl_.params_} + , decltype(_impl_.localizableparams_){from._impl_.localizableparams_} + , decltype(_impl_.namespace__){} + , decltype(_impl_.elementname_){} + , decltype(_impl_.fallbacklg_){} + , decltype(_impl_.fallbacklc_){} + , decltype(_impl_.deterministiclg_){} + , decltype(_impl_.deterministiclc_){} + , decltype(_impl_.hydratedhsm_){nullptr}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.namespace__.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.namespace__.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_namespace_()) { + _this->_impl_.namespace__.Set(from._internal_namespace_(), + _this->GetArenaForAllocation()); + } + _impl_.elementname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.elementname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_elementname()) { + _this->_impl_.elementname_.Set(from._internal_elementname(), + _this->GetArenaForAllocation()); + } + _impl_.fallbacklg_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fallbacklg_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_fallbacklg()) { + _this->_impl_.fallbacklg_.Set(from._internal_fallbacklg(), + _this->GetArenaForAllocation()); + } + _impl_.fallbacklc_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fallbacklc_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_fallbacklc()) { + _this->_impl_.fallbacklc_.Set(from._internal_fallbacklc(), + _this->GetArenaForAllocation()); + } + _impl_.deterministiclg_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.deterministiclg_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_deterministiclg()) { + _this->_impl_.deterministiclg_.Set(from._internal_deterministiclg(), + _this->GetArenaForAllocation()); + } + _impl_.deterministiclc_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.deterministiclc_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_deterministiclc()) { + _this->_impl_.deterministiclc_.Set(from._internal_deterministiclc(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_hydratedhsm()) { + _this->_impl_.hydratedhsm_ = new ::proto::Message_TemplateMessage(*from._impl_.hydratedhsm_); + } + // @@protoc_insertion_point(copy_constructor:proto.Message.HighlyStructuredMessage) +} + +inline void Message_HighlyStructuredMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.params_){arena} + , decltype(_impl_.localizableparams_){arena} + , decltype(_impl_.namespace__){} + , decltype(_impl_.elementname_){} + , decltype(_impl_.fallbacklg_){} + , decltype(_impl_.fallbacklc_){} + , decltype(_impl_.deterministiclg_){} + , decltype(_impl_.deterministiclc_){} + , decltype(_impl_.hydratedhsm_){nullptr} + }; + _impl_.namespace__.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.namespace__.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.elementname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.elementname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fallbacklg_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fallbacklg_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fallbacklc_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fallbacklc_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.deterministiclg_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.deterministiclg_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.deterministiclc_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.deterministiclc_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_HighlyStructuredMessage::~Message_HighlyStructuredMessage() { + // @@protoc_insertion_point(destructor:proto.Message.HighlyStructuredMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_HighlyStructuredMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.params_.~RepeatedPtrField(); + _impl_.localizableparams_.~RepeatedPtrField(); + _impl_.namespace__.Destroy(); + _impl_.elementname_.Destroy(); + _impl_.fallbacklg_.Destroy(); + _impl_.fallbacklc_.Destroy(); + _impl_.deterministiclg_.Destroy(); + _impl_.deterministiclc_.Destroy(); + if (this != internal_default_instance()) delete _impl_.hydratedhsm_; +} + +void Message_HighlyStructuredMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_HighlyStructuredMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.HighlyStructuredMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.params_.Clear(); + _impl_.localizableparams_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + if (cached_has_bits & 0x00000001u) { + _impl_.namespace__.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.elementname_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.fallbacklg_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + _impl_.fallbacklc_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + _impl_.deterministiclg_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000020u) { + _impl_.deterministiclc_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000040u) { + GOOGLE_DCHECK(_impl_.hydratedhsm_ != nullptr); + _impl_.hydratedhsm_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_HighlyStructuredMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string namespace = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_namespace_(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.HighlyStructuredMessage.namespace"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string elementName = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_elementname(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.HighlyStructuredMessage.elementName"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // repeated string params = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_params(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.HighlyStructuredMessage.params"); + #endif // !NDEBUG + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else + goto handle_unusual; + continue; + // optional string fallbackLg = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_fallbacklg(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.HighlyStructuredMessage.fallbackLg"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string fallbackLc = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + auto str = _internal_mutable_fallbacklc(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.HighlyStructuredMessage.fallbackLc"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // repeated .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter localizableParams = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_localizableparams(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr)); + } else + goto handle_unusual; + continue; + // optional string deterministicLg = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + auto str = _internal_mutable_deterministiclg(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.HighlyStructuredMessage.deterministicLg"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string deterministicLc = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + auto str = _internal_mutable_deterministiclc(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.HighlyStructuredMessage.deterministicLc"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.Message.TemplateMessage hydratedHsm = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + ptr = ctx->ParseMessage(_internal_mutable_hydratedhsm(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_HighlyStructuredMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.HighlyStructuredMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string namespace = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_namespace_().data(), static_cast(this->_internal_namespace_().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.HighlyStructuredMessage.namespace"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_namespace_(), target); + } + + // optional string elementName = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_elementname().data(), static_cast(this->_internal_elementname().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.HighlyStructuredMessage.elementName"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_elementname(), target); + } + + // repeated string params = 3; + for (int i = 0, n = this->_internal_params_size(); i < n; i++) { + const auto& s = this->_internal_params(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.HighlyStructuredMessage.params"); + target = stream->WriteString(3, s, target); + } + + // optional string fallbackLg = 4; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_fallbacklg().data(), static_cast(this->_internal_fallbacklg().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.HighlyStructuredMessage.fallbackLg"); + target = stream->WriteStringMaybeAliased( + 4, this->_internal_fallbacklg(), target); + } + + // optional string fallbackLc = 5; + if (cached_has_bits & 0x00000008u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_fallbacklc().data(), static_cast(this->_internal_fallbacklc().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.HighlyStructuredMessage.fallbackLc"); + target = stream->WriteStringMaybeAliased( + 5, this->_internal_fallbacklc(), target); + } + + // repeated .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter localizableParams = 6; + for (unsigned i = 0, + n = static_cast(this->_internal_localizableparams_size()); i < n; i++) { + const auto& repfield = this->_internal_localizableparams(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(6, repfield, repfield.GetCachedSize(), target, stream); + } + + // optional string deterministicLg = 7; + if (cached_has_bits & 0x00000010u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_deterministiclg().data(), static_cast(this->_internal_deterministiclg().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.HighlyStructuredMessage.deterministicLg"); + target = stream->WriteStringMaybeAliased( + 7, this->_internal_deterministiclg(), target); + } + + // optional string deterministicLc = 8; + if (cached_has_bits & 0x00000020u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_deterministiclc().data(), static_cast(this->_internal_deterministiclc().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.HighlyStructuredMessage.deterministicLc"); + target = stream->WriteStringMaybeAliased( + 8, this->_internal_deterministiclc(), target); + } + + // optional .proto.Message.TemplateMessage hydratedHsm = 9; + if (cached_has_bits & 0x00000040u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(9, _Internal::hydratedhsm(this), + _Internal::hydratedhsm(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.HighlyStructuredMessage) + return target; +} + +size_t Message_HighlyStructuredMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.HighlyStructuredMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string params = 3; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.params_.size()); + for (int i = 0, n = _impl_.params_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + _impl_.params_.Get(i)); + } + + // repeated .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter localizableParams = 6; + total_size += 1UL * this->_internal_localizableparams_size(); + for (const auto& msg : this->_impl_.localizableparams_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + // optional string namespace = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_namespace_()); + } + + // optional string elementName = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_elementname()); + } + + // optional string fallbackLg = 4; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_fallbacklg()); + } + + // optional string fallbackLc = 5; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_fallbacklc()); + } + + // optional string deterministicLg = 7; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_deterministiclg()); + } + + // optional string deterministicLc = 8; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_deterministiclc()); + } + + // optional .proto.Message.TemplateMessage hydratedHsm = 9; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.hydratedhsm_); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_HighlyStructuredMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_HighlyStructuredMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_HighlyStructuredMessage::GetClassData() const { return &_class_data_; } + + +void Message_HighlyStructuredMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.HighlyStructuredMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.params_.MergeFrom(from._impl_.params_); + _this->_impl_.localizableparams_.MergeFrom(from._impl_.localizableparams_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_namespace_(from._internal_namespace_()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_elementname(from._internal_elementname()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_fallbacklg(from._internal_fallbacklg()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_set_fallbacklc(from._internal_fallbacklc()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_set_deterministiclg(from._internal_deterministiclg()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_set_deterministiclc(from._internal_deterministiclc()); + } + if (cached_has_bits & 0x00000040u) { + _this->_internal_mutable_hydratedhsm()->::proto::Message_TemplateMessage::MergeFrom( + from._internal_hydratedhsm()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_HighlyStructuredMessage::CopyFrom(const Message_HighlyStructuredMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.HighlyStructuredMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_HighlyStructuredMessage::IsInitialized() const { + return true; +} + +void Message_HighlyStructuredMessage::InternalSwap(Message_HighlyStructuredMessage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.params_.InternalSwap(&other->_impl_.params_); + _impl_.localizableparams_.InternalSwap(&other->_impl_.localizableparams_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.namespace__, lhs_arena, + &other->_impl_.namespace__, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.elementname_, lhs_arena, + &other->_impl_.elementname_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.fallbacklg_, lhs_arena, + &other->_impl_.fallbacklg_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.fallbacklc_, lhs_arena, + &other->_impl_.fallbacklc_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.deterministiclg_, lhs_arena, + &other->_impl_.deterministiclg_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.deterministiclc_, lhs_arena, + &other->_impl_.deterministiclc_, rhs_arena + ); + swap(_impl_.hydratedhsm_, other->_impl_.hydratedhsm_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_HighlyStructuredMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[82]); +} + +// =================================================================== + +class Message_HistorySyncNotification::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_filesha256(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_filelength(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_mediakey(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_fileencsha256(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_directpath(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_synctype(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_chunkorder(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_originalmessageid(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_progress(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } +}; + +Message_HistorySyncNotification::Message_HistorySyncNotification(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.HistorySyncNotification) +} +Message_HistorySyncNotification::Message_HistorySyncNotification(const Message_HistorySyncNotification& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_HistorySyncNotification* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.filesha256_){} + , decltype(_impl_.mediakey_){} + , decltype(_impl_.fileencsha256_){} + , decltype(_impl_.directpath_){} + , decltype(_impl_.originalmessageid_){} + , decltype(_impl_.filelength_){} + , decltype(_impl_.synctype_){} + , decltype(_impl_.chunkorder_){} + , decltype(_impl_.progress_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.filesha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filesha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_filesha256()) { + _this->_impl_.filesha256_.Set(from._internal_filesha256(), + _this->GetArenaForAllocation()); + } + _impl_.mediakey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediakey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_mediakey()) { + _this->_impl_.mediakey_.Set(from._internal_mediakey(), + _this->GetArenaForAllocation()); + } + _impl_.fileencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_fileencsha256()) { + _this->_impl_.fileencsha256_.Set(from._internal_fileencsha256(), + _this->GetArenaForAllocation()); + } + _impl_.directpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_directpath()) { + _this->_impl_.directpath_.Set(from._internal_directpath(), + _this->GetArenaForAllocation()); + } + _impl_.originalmessageid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.originalmessageid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_originalmessageid()) { + _this->_impl_.originalmessageid_.Set(from._internal_originalmessageid(), + _this->GetArenaForAllocation()); + } + ::memcpy(&_impl_.filelength_, &from._impl_.filelength_, + static_cast(reinterpret_cast(&_impl_.progress_) - + reinterpret_cast(&_impl_.filelength_)) + sizeof(_impl_.progress_)); + // @@protoc_insertion_point(copy_constructor:proto.Message.HistorySyncNotification) +} + +inline void Message_HistorySyncNotification::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.filesha256_){} + , decltype(_impl_.mediakey_){} + , decltype(_impl_.fileencsha256_){} + , decltype(_impl_.directpath_){} + , decltype(_impl_.originalmessageid_){} + , decltype(_impl_.filelength_){uint64_t{0u}} + , decltype(_impl_.synctype_){0} + , decltype(_impl_.chunkorder_){0u} + , decltype(_impl_.progress_){0u} + }; + _impl_.filesha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filesha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediakey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediakey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fileencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.originalmessageid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.originalmessageid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_HistorySyncNotification::~Message_HistorySyncNotification() { + // @@protoc_insertion_point(destructor:proto.Message.HistorySyncNotification) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_HistorySyncNotification::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.filesha256_.Destroy(); + _impl_.mediakey_.Destroy(); + _impl_.fileencsha256_.Destroy(); + _impl_.directpath_.Destroy(); + _impl_.originalmessageid_.Destroy(); +} + +void Message_HistorySyncNotification::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_HistorySyncNotification::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.HistorySyncNotification) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _impl_.filesha256_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.mediakey_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.fileencsha256_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + _impl_.directpath_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + _impl_.originalmessageid_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x000000e0u) { + ::memset(&_impl_.filelength_, 0, static_cast( + reinterpret_cast(&_impl_.chunkorder_) - + reinterpret_cast(&_impl_.filelength_)) + sizeof(_impl_.chunkorder_)); + } + _impl_.progress_ = 0u; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_HistorySyncNotification::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes fileSha256 = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_filesha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint64 fileLength = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_filelength(&has_bits); + _impl_.filelength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes mediaKey = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_mediakey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes fileEncSha256 = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_fileencsha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string directPath = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + auto str = _internal_mutable_directpath(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.HistorySyncNotification.directPath"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.Message.HistorySyncNotification.HistorySyncType syncType = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::Message_HistorySyncNotification_HistorySyncType_IsValid(val))) { + _internal_set_synctype(static_cast<::proto::Message_HistorySyncNotification_HistorySyncType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(6, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional uint32 chunkOrder = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + _Internal::set_has_chunkorder(&has_bits); + _impl_.chunkorder_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string originalMessageId = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + auto str = _internal_mutable_originalmessageid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.HistorySyncNotification.originalMessageId"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional uint32 progress = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { + _Internal::set_has_progress(&has_bits); + _impl_.progress_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_HistorySyncNotification::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.HistorySyncNotification) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes fileSha256 = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_filesha256(), target); + } + + // optional uint64 fileLength = 2; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_filelength(), target); + } + + // optional bytes mediaKey = 3; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 3, this->_internal_mediakey(), target); + } + + // optional bytes fileEncSha256 = 4; + if (cached_has_bits & 0x00000004u) { + target = stream->WriteBytesMaybeAliased( + 4, this->_internal_fileencsha256(), target); + } + + // optional string directPath = 5; + if (cached_has_bits & 0x00000008u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_directpath().data(), static_cast(this->_internal_directpath().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.HistorySyncNotification.directPath"); + target = stream->WriteStringMaybeAliased( + 5, this->_internal_directpath(), target); + } + + // optional .proto.Message.HistorySyncNotification.HistorySyncType syncType = 6; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 6, this->_internal_synctype(), target); + } + + // optional uint32 chunkOrder = 7; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(7, this->_internal_chunkorder(), target); + } + + // optional string originalMessageId = 8; + if (cached_has_bits & 0x00000010u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_originalmessageid().data(), static_cast(this->_internal_originalmessageid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.HistorySyncNotification.originalMessageId"); + target = stream->WriteStringMaybeAliased( + 8, this->_internal_originalmessageid(), target); + } + + // optional uint32 progress = 9; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(9, this->_internal_progress(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.HistorySyncNotification) + return target; +} + +size_t Message_HistorySyncNotification::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.HistorySyncNotification) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional bytes fileSha256 = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_filesha256()); + } + + // optional bytes mediaKey = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_mediakey()); + } + + // optional bytes fileEncSha256 = 4; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_fileencsha256()); + } + + // optional string directPath = 5; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_directpath()); + } + + // optional string originalMessageId = 8; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_originalmessageid()); + } + + // optional uint64 fileLength = 2; + if (cached_has_bits & 0x00000020u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_filelength()); + } + + // optional .proto.Message.HistorySyncNotification.HistorySyncType syncType = 6; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_synctype()); + } + + // optional uint32 chunkOrder = 7; + if (cached_has_bits & 0x00000080u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_chunkorder()); + } + + } + // optional uint32 progress = 9; + if (cached_has_bits & 0x00000100u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_progress()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_HistorySyncNotification::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_HistorySyncNotification::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_HistorySyncNotification::GetClassData() const { return &_class_data_; } + + +void Message_HistorySyncNotification::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.HistorySyncNotification) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_filesha256(from._internal_filesha256()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_mediakey(from._internal_mediakey()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_fileencsha256(from._internal_fileencsha256()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_set_directpath(from._internal_directpath()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_set_originalmessageid(from._internal_originalmessageid()); + } + if (cached_has_bits & 0x00000020u) { + _this->_impl_.filelength_ = from._impl_.filelength_; + } + if (cached_has_bits & 0x00000040u) { + _this->_impl_.synctype_ = from._impl_.synctype_; + } + if (cached_has_bits & 0x00000080u) { + _this->_impl_.chunkorder_ = from._impl_.chunkorder_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00000100u) { + _this->_internal_set_progress(from._internal_progress()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_HistorySyncNotification::CopyFrom(const Message_HistorySyncNotification& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.HistorySyncNotification) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_HistorySyncNotification::IsInitialized() const { + return true; +} + +void Message_HistorySyncNotification::InternalSwap(Message_HistorySyncNotification* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.filesha256_, lhs_arena, + &other->_impl_.filesha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.mediakey_, lhs_arena, + &other->_impl_.mediakey_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.fileencsha256_, lhs_arena, + &other->_impl_.fileencsha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.directpath_, lhs_arena, + &other->_impl_.directpath_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.originalmessageid_, lhs_arena, + &other->_impl_.originalmessageid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_HistorySyncNotification, _impl_.progress_) + + sizeof(Message_HistorySyncNotification::_impl_.progress_) + - PROTOBUF_FIELD_OFFSET(Message_HistorySyncNotification, _impl_.filelength_)>( + reinterpret_cast(&_impl_.filelength_), + reinterpret_cast(&other->_impl_.filelength_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_HistorySyncNotification::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[83]); +} + +// =================================================================== + +class Message_ImageMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_url(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_mimetype(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_caption(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_filesha256(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_filelength(HasBits* has_bits) { + (*has_bits)[0] |= 131072u; + } + static void set_has_height(HasBits* has_bits) { + (*has_bits)[0] |= 262144u; + } + static void set_has_width(HasBits* has_bits) { + (*has_bits)[0] |= 524288u; + } + static void set_has_mediakey(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_fileencsha256(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_directpath(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_mediakeytimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 1048576u; + } + static void set_has_jpegthumbnail(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static const ::proto::ContextInfo& contextinfo(const Message_ImageMessage* msg); + static void set_has_contextinfo(HasBits* has_bits) { + (*has_bits)[0] |= 65536u; + } + static void set_has_firstscansidecar(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_firstscanlength(HasBits* has_bits) { + (*has_bits)[0] |= 2097152u; + } + static void set_has_experimentgroupid(HasBits* has_bits) { + (*has_bits)[0] |= 4194304u; + } + static void set_has_scanssidecar(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_midqualityfilesha256(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static void set_has_midqualityfileencsha256(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static void set_has_viewonce(HasBits* has_bits) { + (*has_bits)[0] |= 8388608u; + } + static void set_has_thumbnaildirectpath(HasBits* has_bits) { + (*has_bits)[0] |= 4096u; + } + static void set_has_thumbnailsha256(HasBits* has_bits) { + (*has_bits)[0] |= 8192u; + } + static void set_has_thumbnailencsha256(HasBits* has_bits) { + (*has_bits)[0] |= 16384u; + } + static void set_has_staticurl(HasBits* has_bits) { + (*has_bits)[0] |= 32768u; + } +}; + +const ::proto::ContextInfo& +Message_ImageMessage::_Internal::contextinfo(const Message_ImageMessage* msg) { + return *msg->_impl_.contextinfo_; +} +Message_ImageMessage::Message_ImageMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.ImageMessage) +} +Message_ImageMessage::Message_ImageMessage(const Message_ImageMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_ImageMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.interactiveannotations_){from._impl_.interactiveannotations_} + , decltype(_impl_.scanlengths_){from._impl_.scanlengths_} + , decltype(_impl_.url_){} + , decltype(_impl_.mimetype_){} + , decltype(_impl_.caption_){} + , decltype(_impl_.filesha256_){} + , decltype(_impl_.mediakey_){} + , decltype(_impl_.fileencsha256_){} + , decltype(_impl_.directpath_){} + , decltype(_impl_.jpegthumbnail_){} + , decltype(_impl_.firstscansidecar_){} + , decltype(_impl_.scanssidecar_){} + , decltype(_impl_.midqualityfilesha256_){} + , decltype(_impl_.midqualityfileencsha256_){} + , decltype(_impl_.thumbnaildirectpath_){} + , decltype(_impl_.thumbnailsha256_){} + , decltype(_impl_.thumbnailencsha256_){} + , decltype(_impl_.staticurl_){} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.filelength_){} + , decltype(_impl_.height_){} + , decltype(_impl_.width_){} + , decltype(_impl_.mediakeytimestamp_){} + , decltype(_impl_.firstscanlength_){} + , decltype(_impl_.experimentgroupid_){} + , decltype(_impl_.viewonce_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.url_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.url_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_url()) { + _this->_impl_.url_.Set(from._internal_url(), + _this->GetArenaForAllocation()); + } + _impl_.mimetype_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mimetype_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_mimetype()) { + _this->_impl_.mimetype_.Set(from._internal_mimetype(), + _this->GetArenaForAllocation()); + } + _impl_.caption_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.caption_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_caption()) { + _this->_impl_.caption_.Set(from._internal_caption(), + _this->GetArenaForAllocation()); + } + _impl_.filesha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filesha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_filesha256()) { + _this->_impl_.filesha256_.Set(from._internal_filesha256(), + _this->GetArenaForAllocation()); + } + _impl_.mediakey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediakey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_mediakey()) { + _this->_impl_.mediakey_.Set(from._internal_mediakey(), + _this->GetArenaForAllocation()); + } + _impl_.fileencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_fileencsha256()) { + _this->_impl_.fileencsha256_.Set(from._internal_fileencsha256(), + _this->GetArenaForAllocation()); + } + _impl_.directpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_directpath()) { + _this->_impl_.directpath_.Set(from._internal_directpath(), + _this->GetArenaForAllocation()); + } + _impl_.jpegthumbnail_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_jpegthumbnail()) { + _this->_impl_.jpegthumbnail_.Set(from._internal_jpegthumbnail(), + _this->GetArenaForAllocation()); + } + _impl_.firstscansidecar_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.firstscansidecar_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_firstscansidecar()) { + _this->_impl_.firstscansidecar_.Set(from._internal_firstscansidecar(), + _this->GetArenaForAllocation()); + } + _impl_.scanssidecar_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.scanssidecar_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_scanssidecar()) { + _this->_impl_.scanssidecar_.Set(from._internal_scanssidecar(), + _this->GetArenaForAllocation()); + } + _impl_.midqualityfilesha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.midqualityfilesha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_midqualityfilesha256()) { + _this->_impl_.midqualityfilesha256_.Set(from._internal_midqualityfilesha256(), + _this->GetArenaForAllocation()); + } + _impl_.midqualityfileencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.midqualityfileencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_midqualityfileencsha256()) { + _this->_impl_.midqualityfileencsha256_.Set(from._internal_midqualityfileencsha256(), + _this->GetArenaForAllocation()); + } + _impl_.thumbnaildirectpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_thumbnaildirectpath()) { + _this->_impl_.thumbnaildirectpath_.Set(from._internal_thumbnaildirectpath(), + _this->GetArenaForAllocation()); + } + _impl_.thumbnailsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_thumbnailsha256()) { + _this->_impl_.thumbnailsha256_.Set(from._internal_thumbnailsha256(), + _this->GetArenaForAllocation()); + } + _impl_.thumbnailencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_thumbnailencsha256()) { + _this->_impl_.thumbnailencsha256_.Set(from._internal_thumbnailencsha256(), + _this->GetArenaForAllocation()); + } + _impl_.staticurl_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.staticurl_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_staticurl()) { + _this->_impl_.staticurl_.Set(from._internal_staticurl(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_contextinfo()) { + _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); + } + ::memcpy(&_impl_.filelength_, &from._impl_.filelength_, + static_cast(reinterpret_cast(&_impl_.viewonce_) - + reinterpret_cast(&_impl_.filelength_)) + sizeof(_impl_.viewonce_)); + // @@protoc_insertion_point(copy_constructor:proto.Message.ImageMessage) +} + +inline void Message_ImageMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.interactiveannotations_){arena} + , decltype(_impl_.scanlengths_){arena} + , decltype(_impl_.url_){} + , decltype(_impl_.mimetype_){} + , decltype(_impl_.caption_){} + , decltype(_impl_.filesha256_){} + , decltype(_impl_.mediakey_){} + , decltype(_impl_.fileencsha256_){} + , decltype(_impl_.directpath_){} + , decltype(_impl_.jpegthumbnail_){} + , decltype(_impl_.firstscansidecar_){} + , decltype(_impl_.scanssidecar_){} + , decltype(_impl_.midqualityfilesha256_){} + , decltype(_impl_.midqualityfileencsha256_){} + , decltype(_impl_.thumbnaildirectpath_){} + , decltype(_impl_.thumbnailsha256_){} + , decltype(_impl_.thumbnailencsha256_){} + , decltype(_impl_.staticurl_){} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.filelength_){uint64_t{0u}} + , decltype(_impl_.height_){0u} + , decltype(_impl_.width_){0u} + , decltype(_impl_.mediakeytimestamp_){int64_t{0}} + , decltype(_impl_.firstscanlength_){0u} + , decltype(_impl_.experimentgroupid_){0u} + , decltype(_impl_.viewonce_){false} + }; + _impl_.url_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.url_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mimetype_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mimetype_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.caption_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.caption_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filesha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filesha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediakey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediakey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fileencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.jpegthumbnail_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.firstscansidecar_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.firstscansidecar_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.scanssidecar_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.scanssidecar_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.midqualityfilesha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.midqualityfilesha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.midqualityfileencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.midqualityfileencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnaildirectpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnailsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnailencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.staticurl_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.staticurl_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_ImageMessage::~Message_ImageMessage() { + // @@protoc_insertion_point(destructor:proto.Message.ImageMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_ImageMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.interactiveannotations_.~RepeatedPtrField(); + _impl_.scanlengths_.~RepeatedField(); + _impl_.url_.Destroy(); + _impl_.mimetype_.Destroy(); + _impl_.caption_.Destroy(); + _impl_.filesha256_.Destroy(); + _impl_.mediakey_.Destroy(); + _impl_.fileencsha256_.Destroy(); + _impl_.directpath_.Destroy(); + _impl_.jpegthumbnail_.Destroy(); + _impl_.firstscansidecar_.Destroy(); + _impl_.scanssidecar_.Destroy(); + _impl_.midqualityfilesha256_.Destroy(); + _impl_.midqualityfileencsha256_.Destroy(); + _impl_.thumbnaildirectpath_.Destroy(); + _impl_.thumbnailsha256_.Destroy(); + _impl_.thumbnailencsha256_.Destroy(); + _impl_.staticurl_.Destroy(); + if (this != internal_default_instance()) delete _impl_.contextinfo_; +} + +void Message_ImageMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_ImageMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.ImageMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.interactiveannotations_.Clear(); + _impl_.scanlengths_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _impl_.url_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.mimetype_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.caption_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + _impl_.filesha256_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + _impl_.mediakey_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000020u) { + _impl_.fileencsha256_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000040u) { + _impl_.directpath_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000080u) { + _impl_.jpegthumbnail_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x0000ff00u) { + if (cached_has_bits & 0x00000100u) { + _impl_.firstscansidecar_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000200u) { + _impl_.scanssidecar_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000400u) { + _impl_.midqualityfilesha256_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000800u) { + _impl_.midqualityfileencsha256_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00001000u) { + _impl_.thumbnaildirectpath_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00002000u) { + _impl_.thumbnailsha256_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00004000u) { + _impl_.thumbnailencsha256_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00008000u) { + _impl_.staticurl_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x00010000u) { + GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); + _impl_.contextinfo_->Clear(); + } + if (cached_has_bits & 0x00fe0000u) { + ::memset(&_impl_.filelength_, 0, static_cast( + reinterpret_cast(&_impl_.viewonce_) - + reinterpret_cast(&_impl_.filelength_)) + sizeof(_impl_.viewonce_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_ImageMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string url = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_url(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ImageMessage.url"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string mimetype = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_mimetype(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ImageMessage.mimetype"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string caption = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_caption(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ImageMessage.caption"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bytes fileSha256 = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_filesha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint64 fileLength = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_filelength(&has_bits); + _impl_.filelength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 height = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + _Internal::set_has_height(&has_bits); + _impl_.height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 width = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + _Internal::set_has_width(&has_bits); + _impl_.width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes mediaKey = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + auto str = _internal_mutable_mediakey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes fileEncSha256 = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + auto str = _internal_mutable_fileencsha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .proto.InteractiveAnnotation interactiveAnnotations = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_interactiveannotations(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<82>(ptr)); + } else + goto handle_unusual; + continue; + // optional string directPath = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { + auto str = _internal_mutable_directpath(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ImageMessage.directPath"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional int64 mediaKeyTimestamp = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { + _Internal::set_has_mediakeytimestamp(&has_bits); + _impl_.mediakeytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes jpegThumbnail = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { + auto str = _internal_mutable_jpegthumbnail(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.ContextInfo contextInfo = 17; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { + ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes firstScanSidecar = 18; + case 18: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { + auto str = _internal_mutable_firstscansidecar(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 firstScanLength = 19; + case 19: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 152)) { + _Internal::set_has_firstscanlength(&has_bits); + _impl_.firstscanlength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 experimentGroupId = 20; + case 20: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 160)) { + _Internal::set_has_experimentgroupid(&has_bits); + _impl_.experimentgroupid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes scansSidecar = 21; + case 21: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { + auto str = _internal_mutable_scanssidecar(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated uint32 scanLengths = 22; + case 22: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 176)) { + ptr -= 2; + do { + ptr += 2; + _internal_add_scanlengths(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<176>(ptr)); + } else if (static_cast(tag) == 178) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_scanlengths(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes midQualityFileSha256 = 23; + case 23: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { + auto str = _internal_mutable_midqualityfilesha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes midQualityFileEncSha256 = 24; + case 24: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 194)) { + auto str = _internal_mutable_midqualityfileencsha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool viewOnce = 25; + case 25: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 200)) { + _Internal::set_has_viewonce(&has_bits); + _impl_.viewonce_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string thumbnailDirectPath = 26; + case 26: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 210)) { + auto str = _internal_mutable_thumbnaildirectpath(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ImageMessage.thumbnailDirectPath"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bytes thumbnailSha256 = 27; + case 27: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 218)) { + auto str = _internal_mutable_thumbnailsha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes thumbnailEncSha256 = 28; + case 28: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 226)) { + auto str = _internal_mutable_thumbnailencsha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string staticUrl = 29; + case 29: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 234)) { + auto str = _internal_mutable_staticurl(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ImageMessage.staticUrl"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_ImageMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ImageMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string url = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_url().data(), static_cast(this->_internal_url().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ImageMessage.url"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_url(), target); + } + + // optional string mimetype = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_mimetype().data(), static_cast(this->_internal_mimetype().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ImageMessage.mimetype"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_mimetype(), target); + } + + // optional string caption = 3; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_caption().data(), static_cast(this->_internal_caption().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ImageMessage.caption"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_caption(), target); + } + + // optional bytes fileSha256 = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->WriteBytesMaybeAliased( + 4, this->_internal_filesha256(), target); + } + + // optional uint64 fileLength = 5; + if (cached_has_bits & 0x00020000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_filelength(), target); + } + + // optional uint32 height = 6; + if (cached_has_bits & 0x00040000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_height(), target); + } + + // optional uint32 width = 7; + if (cached_has_bits & 0x00080000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(7, this->_internal_width(), target); + } + + // optional bytes mediaKey = 8; + if (cached_has_bits & 0x00000010u) { + target = stream->WriteBytesMaybeAliased( + 8, this->_internal_mediakey(), target); + } + + // optional bytes fileEncSha256 = 9; + if (cached_has_bits & 0x00000020u) { + target = stream->WriteBytesMaybeAliased( + 9, this->_internal_fileencsha256(), target); + } + + // repeated .proto.InteractiveAnnotation interactiveAnnotations = 10; + for (unsigned i = 0, + n = static_cast(this->_internal_interactiveannotations_size()); i < n; i++) { + const auto& repfield = this->_internal_interactiveannotations(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(10, repfield, repfield.GetCachedSize(), target, stream); + } + + // optional string directPath = 11; + if (cached_has_bits & 0x00000040u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_directpath().data(), static_cast(this->_internal_directpath().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ImageMessage.directPath"); + target = stream->WriteStringMaybeAliased( + 11, this->_internal_directpath(), target); + } + + // optional int64 mediaKeyTimestamp = 12; + if (cached_has_bits & 0x00100000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(12, this->_internal_mediakeytimestamp(), target); + } + + // optional bytes jpegThumbnail = 16; + if (cached_has_bits & 0x00000080u) { + target = stream->WriteBytesMaybeAliased( + 16, this->_internal_jpegthumbnail(), target); + } + + // optional .proto.ContextInfo contextInfo = 17; + if (cached_has_bits & 0x00010000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(17, _Internal::contextinfo(this), + _Internal::contextinfo(this).GetCachedSize(), target, stream); + } + + // optional bytes firstScanSidecar = 18; + if (cached_has_bits & 0x00000100u) { + target = stream->WriteBytesMaybeAliased( + 18, this->_internal_firstscansidecar(), target); + } + + // optional uint32 firstScanLength = 19; + if (cached_has_bits & 0x00200000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(19, this->_internal_firstscanlength(), target); + } + + // optional uint32 experimentGroupId = 20; + if (cached_has_bits & 0x00400000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(20, this->_internal_experimentgroupid(), target); + } + + // optional bytes scansSidecar = 21; + if (cached_has_bits & 0x00000200u) { + target = stream->WriteBytesMaybeAliased( + 21, this->_internal_scanssidecar(), target); + } + + // repeated uint32 scanLengths = 22; + for (int i = 0, n = this->_internal_scanlengths_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(22, this->_internal_scanlengths(i), target); + } + + // optional bytes midQualityFileSha256 = 23; + if (cached_has_bits & 0x00000400u) { + target = stream->WriteBytesMaybeAliased( + 23, this->_internal_midqualityfilesha256(), target); + } + + // optional bytes midQualityFileEncSha256 = 24; + if (cached_has_bits & 0x00000800u) { + target = stream->WriteBytesMaybeAliased( + 24, this->_internal_midqualityfileencsha256(), target); + } + + // optional bool viewOnce = 25; + if (cached_has_bits & 0x00800000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(25, this->_internal_viewonce(), target); + } + + // optional string thumbnailDirectPath = 26; + if (cached_has_bits & 0x00001000u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_thumbnaildirectpath().data(), static_cast(this->_internal_thumbnaildirectpath().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ImageMessage.thumbnailDirectPath"); + target = stream->WriteStringMaybeAliased( + 26, this->_internal_thumbnaildirectpath(), target); + } + + // optional bytes thumbnailSha256 = 27; + if (cached_has_bits & 0x00002000u) { + target = stream->WriteBytesMaybeAliased( + 27, this->_internal_thumbnailsha256(), target); + } + + // optional bytes thumbnailEncSha256 = 28; + if (cached_has_bits & 0x00004000u) { + target = stream->WriteBytesMaybeAliased( + 28, this->_internal_thumbnailencsha256(), target); + } + + // optional string staticUrl = 29; + if (cached_has_bits & 0x00008000u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_staticurl().data(), static_cast(this->_internal_staticurl().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ImageMessage.staticUrl"); + target = stream->WriteStringMaybeAliased( + 29, this->_internal_staticurl(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ImageMessage) + return target; +} + +size_t Message_ImageMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.ImageMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.InteractiveAnnotation interactiveAnnotations = 10; + total_size += 1UL * this->_internal_interactiveannotations_size(); + for (const auto& msg : this->_impl_.interactiveannotations_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated uint32 scanLengths = 22; + { + size_t data_size = ::_pbi::WireFormatLite:: + UInt32Size(this->_impl_.scanlengths_); + total_size += 2 * + ::_pbi::FromIntSize(this->_internal_scanlengths_size()); + total_size += data_size; + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string url = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_url()); + } + + // optional string mimetype = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_mimetype()); + } + + // optional string caption = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_caption()); + } + + // optional bytes fileSha256 = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_filesha256()); + } + + // optional bytes mediaKey = 8; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_mediakey()); + } + + // optional bytes fileEncSha256 = 9; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_fileencsha256()); + } + + // optional string directPath = 11; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_directpath()); + } + + // optional bytes jpegThumbnail = 16; + if (cached_has_bits & 0x00000080u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_jpegthumbnail()); + } + + } + if (cached_has_bits & 0x0000ff00u) { + // optional bytes firstScanSidecar = 18; + if (cached_has_bits & 0x00000100u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_firstscansidecar()); + } + + // optional bytes scansSidecar = 21; + if (cached_has_bits & 0x00000200u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_scanssidecar()); + } + + // optional bytes midQualityFileSha256 = 23; + if (cached_has_bits & 0x00000400u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_midqualityfilesha256()); + } + + // optional bytes midQualityFileEncSha256 = 24; + if (cached_has_bits & 0x00000800u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_midqualityfileencsha256()); + } + + // optional string thumbnailDirectPath = 26; + if (cached_has_bits & 0x00001000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_thumbnaildirectpath()); + } + + // optional bytes thumbnailSha256 = 27; + if (cached_has_bits & 0x00002000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_thumbnailsha256()); + } + + // optional bytes thumbnailEncSha256 = 28; + if (cached_has_bits & 0x00004000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_thumbnailencsha256()); + } + + // optional string staticUrl = 29; + if (cached_has_bits & 0x00008000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_staticurl()); + } + + } + if (cached_has_bits & 0x00ff0000u) { + // optional .proto.ContextInfo contextInfo = 17; + if (cached_has_bits & 0x00010000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.contextinfo_); + } + + // optional uint64 fileLength = 5; + if (cached_has_bits & 0x00020000u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_filelength()); + } + + // optional uint32 height = 6; + if (cached_has_bits & 0x00040000u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_height()); + } + + // optional uint32 width = 7; + if (cached_has_bits & 0x00080000u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_width()); + } + + // optional int64 mediaKeyTimestamp = 12; + if (cached_has_bits & 0x00100000u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_mediakeytimestamp()); + } + + // optional uint32 firstScanLength = 19; + if (cached_has_bits & 0x00200000u) { + total_size += 2 + + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_firstscanlength()); + } + + // optional uint32 experimentGroupId = 20; + if (cached_has_bits & 0x00400000u) { + total_size += 2 + + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_experimentgroupid()); + } + + // optional bool viewOnce = 25; + if (cached_has_bits & 0x00800000u) { + total_size += 2 + 1; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ImageMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_ImageMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ImageMessage::GetClassData() const { return &_class_data_; } + + +void Message_ImageMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ImageMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.interactiveannotations_.MergeFrom(from._impl_.interactiveannotations_); + _this->_impl_.scanlengths_.MergeFrom(from._impl_.scanlengths_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_url(from._internal_url()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_mimetype(from._internal_mimetype()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_caption(from._internal_caption()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_set_filesha256(from._internal_filesha256()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_set_mediakey(from._internal_mediakey()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_set_fileencsha256(from._internal_fileencsha256()); + } + if (cached_has_bits & 0x00000040u) { + _this->_internal_set_directpath(from._internal_directpath()); + } + if (cached_has_bits & 0x00000080u) { + _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail()); + } + } + if (cached_has_bits & 0x0000ff00u) { + if (cached_has_bits & 0x00000100u) { + _this->_internal_set_firstscansidecar(from._internal_firstscansidecar()); + } + if (cached_has_bits & 0x00000200u) { + _this->_internal_set_scanssidecar(from._internal_scanssidecar()); + } + if (cached_has_bits & 0x00000400u) { + _this->_internal_set_midqualityfilesha256(from._internal_midqualityfilesha256()); + } + if (cached_has_bits & 0x00000800u) { + _this->_internal_set_midqualityfileencsha256(from._internal_midqualityfileencsha256()); + } + if (cached_has_bits & 0x00001000u) { + _this->_internal_set_thumbnaildirectpath(from._internal_thumbnaildirectpath()); + } + if (cached_has_bits & 0x00002000u) { + _this->_internal_set_thumbnailsha256(from._internal_thumbnailsha256()); + } + if (cached_has_bits & 0x00004000u) { + _this->_internal_set_thumbnailencsha256(from._internal_thumbnailencsha256()); + } + if (cached_has_bits & 0x00008000u) { + _this->_internal_set_staticurl(from._internal_staticurl()); + } + } + if (cached_has_bits & 0x00ff0000u) { + if (cached_has_bits & 0x00010000u) { + _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( + from._internal_contextinfo()); + } + if (cached_has_bits & 0x00020000u) { + _this->_impl_.filelength_ = from._impl_.filelength_; + } + if (cached_has_bits & 0x00040000u) { + _this->_impl_.height_ = from._impl_.height_; + } + if (cached_has_bits & 0x00080000u) { + _this->_impl_.width_ = from._impl_.width_; + } + if (cached_has_bits & 0x00100000u) { + _this->_impl_.mediakeytimestamp_ = from._impl_.mediakeytimestamp_; + } + if (cached_has_bits & 0x00200000u) { + _this->_impl_.firstscanlength_ = from._impl_.firstscanlength_; + } + if (cached_has_bits & 0x00400000u) { + _this->_impl_.experimentgroupid_ = from._impl_.experimentgroupid_; + } + if (cached_has_bits & 0x00800000u) { + _this->_impl_.viewonce_ = from._impl_.viewonce_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_ImageMessage::CopyFrom(const Message_ImageMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ImageMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_ImageMessage::IsInitialized() const { + return true; +} + +void Message_ImageMessage::InternalSwap(Message_ImageMessage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.interactiveannotations_.InternalSwap(&other->_impl_.interactiveannotations_); + _impl_.scanlengths_.InternalSwap(&other->_impl_.scanlengths_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.url_, lhs_arena, + &other->_impl_.url_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.mimetype_, lhs_arena, + &other->_impl_.mimetype_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.caption_, lhs_arena, + &other->_impl_.caption_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.filesha256_, lhs_arena, + &other->_impl_.filesha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.mediakey_, lhs_arena, + &other->_impl_.mediakey_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.fileencsha256_, lhs_arena, + &other->_impl_.fileencsha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.directpath_, lhs_arena, + &other->_impl_.directpath_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.jpegthumbnail_, lhs_arena, + &other->_impl_.jpegthumbnail_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.firstscansidecar_, lhs_arena, + &other->_impl_.firstscansidecar_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.scanssidecar_, lhs_arena, + &other->_impl_.scanssidecar_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.midqualityfilesha256_, lhs_arena, + &other->_impl_.midqualityfilesha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.midqualityfileencsha256_, lhs_arena, + &other->_impl_.midqualityfileencsha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.thumbnaildirectpath_, lhs_arena, + &other->_impl_.thumbnaildirectpath_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.thumbnailsha256_, lhs_arena, + &other->_impl_.thumbnailsha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.thumbnailencsha256_, lhs_arena, + &other->_impl_.thumbnailencsha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.staticurl_, lhs_arena, + &other->_impl_.staticurl_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_ImageMessage, _impl_.viewonce_) + + sizeof(Message_ImageMessage::_impl_.viewonce_) + - PROTOBUF_FIELD_OFFSET(Message_ImageMessage, _impl_.contextinfo_)>( + reinterpret_cast(&_impl_.contextinfo_), + reinterpret_cast(&other->_impl_.contextinfo_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_ImageMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[84]); +} + +// =================================================================== + +class Message_InitialSecurityNotificationSettingSync::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_securitynotificationenabled(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +Message_InitialSecurityNotificationSettingSync::Message_InitialSecurityNotificationSettingSync(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.InitialSecurityNotificationSettingSync) +} +Message_InitialSecurityNotificationSettingSync::Message_InitialSecurityNotificationSettingSync(const Message_InitialSecurityNotificationSettingSync& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_InitialSecurityNotificationSettingSync* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.securitynotificationenabled_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _this->_impl_.securitynotificationenabled_ = from._impl_.securitynotificationenabled_; + // @@protoc_insertion_point(copy_constructor:proto.Message.InitialSecurityNotificationSettingSync) +} + +inline void Message_InitialSecurityNotificationSettingSync::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.securitynotificationenabled_){false} + }; +} + +Message_InitialSecurityNotificationSettingSync::~Message_InitialSecurityNotificationSettingSync() { + // @@protoc_insertion_point(destructor:proto.Message.InitialSecurityNotificationSettingSync) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_InitialSecurityNotificationSettingSync::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void Message_InitialSecurityNotificationSettingSync::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_InitialSecurityNotificationSettingSync::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.InitialSecurityNotificationSettingSync) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.securitynotificationenabled_ = false; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_InitialSecurityNotificationSettingSync::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bool securityNotificationEnabled = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_securitynotificationenabled(&has_bits); + _impl_.securitynotificationenabled_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_InitialSecurityNotificationSettingSync::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InitialSecurityNotificationSettingSync) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bool securityNotificationEnabled = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_securitynotificationenabled(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.InitialSecurityNotificationSettingSync) + return target; +} + +size_t Message_InitialSecurityNotificationSettingSync::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.InitialSecurityNotificationSettingSync) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional bool securityNotificationEnabled = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 1; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InitialSecurityNotificationSettingSync::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_InitialSecurityNotificationSettingSync::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InitialSecurityNotificationSettingSync::GetClassData() const { return &_class_data_; } + + +void Message_InitialSecurityNotificationSettingSync::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InitialSecurityNotificationSettingSync) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_securitynotificationenabled()) { + _this->_internal_set_securitynotificationenabled(from._internal_securitynotificationenabled()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_InitialSecurityNotificationSettingSync::CopyFrom(const Message_InitialSecurityNotificationSettingSync& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InitialSecurityNotificationSettingSync) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_InitialSecurityNotificationSettingSync::IsInitialized() const { + return true; +} + +void Message_InitialSecurityNotificationSettingSync::InternalSwap(Message_InitialSecurityNotificationSettingSync* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_.securitynotificationenabled_, other->_impl_.securitynotificationenabled_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_InitialSecurityNotificationSettingSync::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[85]); +} + +// =================================================================== + +class Message_InteractiveMessage_Body::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_text(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +Message_InteractiveMessage_Body::Message_InteractiveMessage_Body(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveMessage.Body) +} +Message_InteractiveMessage_Body::Message_InteractiveMessage_Body(const Message_InteractiveMessage_Body& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_InteractiveMessage_Body* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.text_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.text_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.text_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_text()) { + _this->_impl_.text_.Set(from._internal_text(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveMessage.Body) +} + +inline void Message_InteractiveMessage_Body::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.text_){} + }; + _impl_.text_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.text_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_InteractiveMessage_Body::~Message_InteractiveMessage_Body() { + // @@protoc_insertion_point(destructor:proto.Message.InteractiveMessage.Body) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_InteractiveMessage_Body::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.text_.Destroy(); +} + +void Message_InteractiveMessage_Body::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_InteractiveMessage_Body::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveMessage.Body) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.text_.ClearNonDefaultToEmpty(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_InteractiveMessage_Body::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string text = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_text(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveMessage.Body.text"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_InteractiveMessage_Body::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveMessage.Body) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string text = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_text().data(), static_cast(this->_internal_text().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.InteractiveMessage.Body.text"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_text(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.InteractiveMessage.Body) + return target; +} + +size_t Message_InteractiveMessage_Body::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveMessage.Body) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional string text = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_text()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveMessage_Body::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_InteractiveMessage_Body::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveMessage_Body::GetClassData() const { return &_class_data_; } + + +void Message_InteractiveMessage_Body::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveMessage.Body) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_text()) { + _this->_internal_set_text(from._internal_text()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_InteractiveMessage_Body::CopyFrom(const Message_InteractiveMessage_Body& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveMessage.Body) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_InteractiveMessage_Body::IsInitialized() const { + return true; +} + +void Message_InteractiveMessage_Body::InternalSwap(Message_InteractiveMessage_Body* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.text_, lhs_arena, + &other->_impl_.text_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveMessage_Body::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[86]); +} + +// =================================================================== + +class Message_InteractiveMessage_CollectionMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_bizjid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_id(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_messageversion(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +Message_InteractiveMessage_CollectionMessage::Message_InteractiveMessage_CollectionMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveMessage.CollectionMessage) +} +Message_InteractiveMessage_CollectionMessage::Message_InteractiveMessage_CollectionMessage(const Message_InteractiveMessage_CollectionMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_InteractiveMessage_CollectionMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.bizjid_){} + , decltype(_impl_.id_){} + , decltype(_impl_.messageversion_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.bizjid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.bizjid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_bizjid()) { + _this->_impl_.bizjid_.Set(from._internal_bizjid(), + _this->GetArenaForAllocation()); + } + _impl_.id_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.id_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_id()) { + _this->_impl_.id_.Set(from._internal_id(), + _this->GetArenaForAllocation()); + } + _this->_impl_.messageversion_ = from._impl_.messageversion_; + // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveMessage.CollectionMessage) +} + +inline void Message_InteractiveMessage_CollectionMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.bizjid_){} + , decltype(_impl_.id_){} + , decltype(_impl_.messageversion_){0} + }; + _impl_.bizjid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.bizjid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.id_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.id_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_InteractiveMessage_CollectionMessage::~Message_InteractiveMessage_CollectionMessage() { + // @@protoc_insertion_point(destructor:proto.Message.InteractiveMessage.CollectionMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_InteractiveMessage_CollectionMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.bizjid_.Destroy(); + _impl_.id_.Destroy(); +} + +void Message_InteractiveMessage_CollectionMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_InteractiveMessage_CollectionMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveMessage.CollectionMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.bizjid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.id_.ClearNonDefaultToEmpty(); + } + } + _impl_.messageversion_ = 0; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_InteractiveMessage_CollectionMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string bizJid = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_bizjid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveMessage.CollectionMessage.bizJid"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string id = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_id(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveMessage.CollectionMessage.id"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional int32 messageVersion = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_messageversion(&has_bits); + _impl_.messageversion_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_InteractiveMessage_CollectionMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveMessage.CollectionMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string bizJid = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_bizjid().data(), static_cast(this->_internal_bizjid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.InteractiveMessage.CollectionMessage.bizJid"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_bizjid(), target); + } + + // optional string id = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_id().data(), static_cast(this->_internal_id().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.InteractiveMessage.CollectionMessage.id"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_id(), target); + } + + // optional int32 messageVersion = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_messageversion(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.InteractiveMessage.CollectionMessage) + return target; +} + +size_t Message_InteractiveMessage_CollectionMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveMessage.CollectionMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional string bizJid = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_bizjid()); + } + + // optional string id = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_id()); + } + + // optional int32 messageVersion = 3; + if (cached_has_bits & 0x00000004u) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_messageversion()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveMessage_CollectionMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_InteractiveMessage_CollectionMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveMessage_CollectionMessage::GetClassData() const { return &_class_data_; } + + +void Message_InteractiveMessage_CollectionMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveMessage.CollectionMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_bizjid(from._internal_bizjid()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_id(from._internal_id()); + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.messageversion_ = from._impl_.messageversion_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_InteractiveMessage_CollectionMessage::CopyFrom(const Message_InteractiveMessage_CollectionMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveMessage.CollectionMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_InteractiveMessage_CollectionMessage::IsInitialized() const { + return true; +} + +void Message_InteractiveMessage_CollectionMessage::InternalSwap(Message_InteractiveMessage_CollectionMessage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.bizjid_, lhs_arena, + &other->_impl_.bizjid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.id_, lhs_arena, + &other->_impl_.id_, rhs_arena + ); + swap(_impl_.messageversion_, other->_impl_.messageversion_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveMessage_CollectionMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[87]); +} + +// =================================================================== + +class Message_InteractiveMessage_Footer::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_text(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +Message_InteractiveMessage_Footer::Message_InteractiveMessage_Footer(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveMessage.Footer) +} +Message_InteractiveMessage_Footer::Message_InteractiveMessage_Footer(const Message_InteractiveMessage_Footer& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_InteractiveMessage_Footer* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.text_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.text_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.text_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_text()) { + _this->_impl_.text_.Set(from._internal_text(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveMessage.Footer) +} + +inline void Message_InteractiveMessage_Footer::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.text_){} + }; + _impl_.text_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.text_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_InteractiveMessage_Footer::~Message_InteractiveMessage_Footer() { + // @@protoc_insertion_point(destructor:proto.Message.InteractiveMessage.Footer) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_InteractiveMessage_Footer::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.text_.Destroy(); +} + +void Message_InteractiveMessage_Footer::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_InteractiveMessage_Footer::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveMessage.Footer) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.text_.ClearNonDefaultToEmpty(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_InteractiveMessage_Footer::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string text = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_text(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveMessage.Footer.text"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_InteractiveMessage_Footer::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveMessage.Footer) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string text = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_text().data(), static_cast(this->_internal_text().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.InteractiveMessage.Footer.text"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_text(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.InteractiveMessage.Footer) + return target; +} + +size_t Message_InteractiveMessage_Footer::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveMessage.Footer) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional string text = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_text()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveMessage_Footer::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_InteractiveMessage_Footer::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveMessage_Footer::GetClassData() const { return &_class_data_; } + + +void Message_InteractiveMessage_Footer::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveMessage.Footer) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_text()) { + _this->_internal_set_text(from._internal_text()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_InteractiveMessage_Footer::CopyFrom(const Message_InteractiveMessage_Footer& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveMessage.Footer) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_InteractiveMessage_Footer::IsInitialized() const { + return true; +} + +void Message_InteractiveMessage_Footer::InternalSwap(Message_InteractiveMessage_Footer* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.text_, lhs_arena, + &other->_impl_.text_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveMessage_Footer::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[88]); +} + +// =================================================================== + +class Message_InteractiveMessage_Header::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_title(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_subtitle(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_hasmediaattachment(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static const ::proto::Message_DocumentMessage& documentmessage(const Message_InteractiveMessage_Header* msg); + static const ::proto::Message_ImageMessage& imagemessage(const Message_InteractiveMessage_Header* msg); + static const ::proto::Message_VideoMessage& videomessage(const Message_InteractiveMessage_Header* msg); +}; + +const ::proto::Message_DocumentMessage& +Message_InteractiveMessage_Header::_Internal::documentmessage(const Message_InteractiveMessage_Header* msg) { + return *msg->_impl_.media_.documentmessage_; +} +const ::proto::Message_ImageMessage& +Message_InteractiveMessage_Header::_Internal::imagemessage(const Message_InteractiveMessage_Header* msg) { + return *msg->_impl_.media_.imagemessage_; +} +const ::proto::Message_VideoMessage& +Message_InteractiveMessage_Header::_Internal::videomessage(const Message_InteractiveMessage_Header* msg) { + return *msg->_impl_.media_.videomessage_; +} +void Message_InteractiveMessage_Header::set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_media(); + if (documentmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(documentmessage); + if (message_arena != submessage_arena) { + documentmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, documentmessage, submessage_arena); + } + set_has_documentmessage(); + _impl_.media_.documentmessage_ = documentmessage; + } + // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.Header.documentMessage) +} +void Message_InteractiveMessage_Header::set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_media(); + if (imagemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(imagemessage); + if (message_arena != submessage_arena) { + imagemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, imagemessage, submessage_arena); + } + set_has_imagemessage(); + _impl_.media_.imagemessage_ = imagemessage; + } + // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.Header.imageMessage) +} +void Message_InteractiveMessage_Header::set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_media(); + if (videomessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(videomessage); + if (message_arena != submessage_arena) { + videomessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, videomessage, submessage_arena); + } + set_has_videomessage(); + _impl_.media_.videomessage_ = videomessage; + } + // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.Header.videoMessage) +} +Message_InteractiveMessage_Header::Message_InteractiveMessage_Header(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveMessage.Header) +} +Message_InteractiveMessage_Header::Message_InteractiveMessage_Header(const Message_InteractiveMessage_Header& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_InteractiveMessage_Header* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.title_){} + , decltype(_impl_.subtitle_){} + , decltype(_impl_.hasmediaattachment_){} + , decltype(_impl_.media_){} + , /*decltype(_impl_._oneof_case_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.title_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.title_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_title()) { + _this->_impl_.title_.Set(from._internal_title(), + _this->GetArenaForAllocation()); + } + _impl_.subtitle_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.subtitle_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_subtitle()) { + _this->_impl_.subtitle_.Set(from._internal_subtitle(), + _this->GetArenaForAllocation()); + } + _this->_impl_.hasmediaattachment_ = from._impl_.hasmediaattachment_; + clear_has_media(); + switch (from.media_case()) { + case kDocumentMessage: { + _this->_internal_mutable_documentmessage()->::proto::Message_DocumentMessage::MergeFrom( + from._internal_documentmessage()); + break; + } + case kImageMessage: { + _this->_internal_mutable_imagemessage()->::proto::Message_ImageMessage::MergeFrom( + from._internal_imagemessage()); + break; + } + case kJpegThumbnail: { + _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail()); + break; + } + case kVideoMessage: { + _this->_internal_mutable_videomessage()->::proto::Message_VideoMessage::MergeFrom( + from._internal_videomessage()); + break; + } + case MEDIA_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveMessage.Header) +} + +inline void Message_InteractiveMessage_Header::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.title_){} + , decltype(_impl_.subtitle_){} + , decltype(_impl_.hasmediaattachment_){false} + , decltype(_impl_.media_){} + , /*decltype(_impl_._oneof_case_)*/{} + }; + _impl_.title_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.title_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.subtitle_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.subtitle_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + clear_has_media(); +} + +Message_InteractiveMessage_Header::~Message_InteractiveMessage_Header() { + // @@protoc_insertion_point(destructor:proto.Message.InteractiveMessage.Header) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_InteractiveMessage_Header::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.title_.Destroy(); + _impl_.subtitle_.Destroy(); + if (has_media()) { + clear_media(); + } +} + +void Message_InteractiveMessage_Header::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_InteractiveMessage_Header::clear_media() { +// @@protoc_insertion_point(one_of_clear_start:proto.Message.InteractiveMessage.Header) + switch (media_case()) { + case kDocumentMessage: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.media_.documentmessage_; + } + break; + } + case kImageMessage: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.media_.imagemessage_; + } + break; + } + case kJpegThumbnail: { + _impl_.media_.jpegthumbnail_.Destroy(); + break; + } + case kVideoMessage: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.media_.videomessage_; + } + break; + } + case MEDIA_NOT_SET: { + break; + } + } + _impl_._oneof_case_[0] = MEDIA_NOT_SET; +} + + +void Message_InteractiveMessage_Header::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveMessage.Header) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.title_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.subtitle_.ClearNonDefaultToEmpty(); + } + } + _impl_.hasmediaattachment_ = false; + clear_media(); + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_InteractiveMessage_Header::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string title = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_title(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveMessage.Header.title"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string subtitle = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_subtitle(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveMessage.Header.subtitle"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // .proto.Message.DocumentMessage documentMessage = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_documentmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .proto.Message.ImageMessage imageMessage = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_imagemessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool hasMediaAttachment = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_hasmediaattachment(&has_bits); + _impl_.hasmediaattachment_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // bytes jpegThumbnail = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + auto str = _internal_mutable_jpegthumbnail(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .proto.Message.VideoMessage videoMessage = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_videomessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_InteractiveMessage_Header::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveMessage.Header) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string title = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_title().data(), static_cast(this->_internal_title().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.InteractiveMessage.Header.title"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_title(), target); + } + + // optional string subtitle = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_subtitle().data(), static_cast(this->_internal_subtitle().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.InteractiveMessage.Header.subtitle"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_subtitle(), target); + } + + switch (media_case()) { + case kDocumentMessage: { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::documentmessage(this), + _Internal::documentmessage(this).GetCachedSize(), target, stream); + break; + } + case kImageMessage: { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, _Internal::imagemessage(this), + _Internal::imagemessage(this).GetCachedSize(), target, stream); + break; + } + default: ; + } + // optional bool hasMediaAttachment = 5; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(5, this->_internal_hasmediaattachment(), target); + } + + switch (media_case()) { + case kJpegThumbnail: { + target = stream->WriteBytesMaybeAliased( + 6, this->_internal_jpegthumbnail(), target); + break; + } + case kVideoMessage: { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(7, _Internal::videomessage(this), + _Internal::videomessage(this).GetCachedSize(), target, stream); + break; + } + default: ; + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.InteractiveMessage.Header) + return target; +} + +size_t Message_InteractiveMessage_Header::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveMessage.Header) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional string title = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_title()); + } + + // optional string subtitle = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_subtitle()); + } + + // optional bool hasMediaAttachment = 5; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 1; + } + + } + switch (media_case()) { + // .proto.Message.DocumentMessage documentMessage = 3; + case kDocumentMessage: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.media_.documentmessage_); + break; + } + // .proto.Message.ImageMessage imageMessage = 4; + case kImageMessage: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.media_.imagemessage_); + break; + } + // bytes jpegThumbnail = 6; + case kJpegThumbnail: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_jpegthumbnail()); + break; + } + // .proto.Message.VideoMessage videoMessage = 7; + case kVideoMessage: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.media_.videomessage_); + break; + } + case MEDIA_NOT_SET: { + break; + } + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveMessage_Header::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_InteractiveMessage_Header::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveMessage_Header::GetClassData() const { return &_class_data_; } + + +void Message_InteractiveMessage_Header::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveMessage.Header) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_title(from._internal_title()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_subtitle(from._internal_subtitle()); + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.hasmediaattachment_ = from._impl_.hasmediaattachment_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + switch (from.media_case()) { + case kDocumentMessage: { + _this->_internal_mutable_documentmessage()->::proto::Message_DocumentMessage::MergeFrom( + from._internal_documentmessage()); + break; + } + case kImageMessage: { + _this->_internal_mutable_imagemessage()->::proto::Message_ImageMessage::MergeFrom( + from._internal_imagemessage()); + break; + } + case kJpegThumbnail: { + _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail()); + break; + } + case kVideoMessage: { + _this->_internal_mutable_videomessage()->::proto::Message_VideoMessage::MergeFrom( + from._internal_videomessage()); + break; + } + case MEDIA_NOT_SET: { + break; + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_InteractiveMessage_Header::CopyFrom(const Message_InteractiveMessage_Header& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveMessage.Header) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_InteractiveMessage_Header::IsInitialized() const { + return true; +} + +void Message_InteractiveMessage_Header::InternalSwap(Message_InteractiveMessage_Header* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.title_, lhs_arena, + &other->_impl_.title_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.subtitle_, lhs_arena, + &other->_impl_.subtitle_, rhs_arena + ); + swap(_impl_.hasmediaattachment_, other->_impl_.hasmediaattachment_); + swap(_impl_.media_, other->_impl_.media_); + swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveMessage_Header::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[89]); +} + +// =================================================================== + +class Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_name(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_buttonparamsjson(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton) +} +Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton(const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.name_){} + , decltype(_impl_.buttonparamsjson_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.name_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.name_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_name()) { + _this->_impl_.name_.Set(from._internal_name(), + _this->GetArenaForAllocation()); + } + _impl_.buttonparamsjson_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.buttonparamsjson_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_buttonparamsjson()) { + _this->_impl_.buttonparamsjson_.Set(from._internal_buttonparamsjson(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton) +} + +inline void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.name_){} + , decltype(_impl_.buttonparamsjson_){} + }; + _impl_.name_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.name_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.buttonparamsjson_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.buttonparamsjson_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::~Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton() { + // @@protoc_insertion_point(destructor:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.name_.Destroy(); + _impl_.buttonparamsjson_.Destroy(); +} + +void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.buttonparamsjson_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_name(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.name"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string buttonParamsJson = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_buttonparamsjson(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.buttonParamsJson"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string name = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.name"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_name(), target); + } + + // optional string buttonParamsJson = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_buttonparamsjson().data(), static_cast(this->_internal_buttonparamsjson().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.buttonParamsJson"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_buttonparamsjson(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton) + return target; +} + +size_t Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional string name = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // optional string buttonParamsJson = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_buttonparamsjson()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::GetClassData() const { return &_class_data_; } + + +void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_name(from._internal_name()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_buttonparamsjson(from._internal_buttonparamsjson()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::CopyFrom(const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::IsInitialized() const { + return true; +} + +void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::InternalSwap(Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.name_, lhs_arena, + &other->_impl_.name_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.buttonparamsjson_, lhs_arena, + &other->_impl_.buttonparamsjson_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[90]); +} + +// =================================================================== + +class Message_InteractiveMessage_NativeFlowMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_messageparamsjson(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_messageversion(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +Message_InteractiveMessage_NativeFlowMessage::Message_InteractiveMessage_NativeFlowMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveMessage.NativeFlowMessage) +} +Message_InteractiveMessage_NativeFlowMessage::Message_InteractiveMessage_NativeFlowMessage(const Message_InteractiveMessage_NativeFlowMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_InteractiveMessage_NativeFlowMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.buttons_){from._impl_.buttons_} + , decltype(_impl_.messageparamsjson_){} + , decltype(_impl_.messageversion_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.messageparamsjson_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.messageparamsjson_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_messageparamsjson()) { + _this->_impl_.messageparamsjson_.Set(from._internal_messageparamsjson(), + _this->GetArenaForAllocation()); + } + _this->_impl_.messageversion_ = from._impl_.messageversion_; + // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveMessage.NativeFlowMessage) +} + +inline void Message_InteractiveMessage_NativeFlowMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.buttons_){arena} + , decltype(_impl_.messageparamsjson_){} + , decltype(_impl_.messageversion_){0} + }; + _impl_.messageparamsjson_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.messageparamsjson_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_InteractiveMessage_NativeFlowMessage::~Message_InteractiveMessage_NativeFlowMessage() { + // @@protoc_insertion_point(destructor:proto.Message.InteractiveMessage.NativeFlowMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_InteractiveMessage_NativeFlowMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.buttons_.~RepeatedPtrField(); + _impl_.messageparamsjson_.Destroy(); +} + +void Message_InteractiveMessage_NativeFlowMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_InteractiveMessage_NativeFlowMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveMessage.NativeFlowMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.buttons_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.messageparamsjson_.ClearNonDefaultToEmpty(); + } + _impl_.messageversion_ = 0; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_InteractiveMessage_NativeFlowMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton buttons = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_buttons(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else + goto handle_unusual; + continue; + // optional string messageParamsJson = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_messageparamsjson(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveMessage.NativeFlowMessage.messageParamsJson"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional int32 messageVersion = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_messageversion(&has_bits); + _impl_.messageversion_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_InteractiveMessage_NativeFlowMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveMessage.NativeFlowMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton buttons = 1; + for (unsigned i = 0, + n = static_cast(this->_internal_buttons_size()); i < n; i++) { + const auto& repfield = this->_internal_buttons(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream); + } + + cached_has_bits = _impl_._has_bits_[0]; + // optional string messageParamsJson = 2; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_messageparamsjson().data(), static_cast(this->_internal_messageparamsjson().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.InteractiveMessage.NativeFlowMessage.messageParamsJson"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_messageparamsjson(), target); + } + + // optional int32 messageVersion = 3; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_messageversion(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.InteractiveMessage.NativeFlowMessage) + return target; +} + +size_t Message_InteractiveMessage_NativeFlowMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveMessage.NativeFlowMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton buttons = 1; + total_size += 1UL * this->_internal_buttons_size(); + for (const auto& msg : this->_impl_.buttons_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional string messageParamsJson = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_messageparamsjson()); + } + + // optional int32 messageVersion = 3; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_messageversion()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveMessage_NativeFlowMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_InteractiveMessage_NativeFlowMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveMessage_NativeFlowMessage::GetClassData() const { return &_class_data_; } + + +void Message_InteractiveMessage_NativeFlowMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveMessage.NativeFlowMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.buttons_.MergeFrom(from._impl_.buttons_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_messageparamsjson(from._internal_messageparamsjson()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.messageversion_ = from._impl_.messageversion_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_InteractiveMessage_NativeFlowMessage::CopyFrom(const Message_InteractiveMessage_NativeFlowMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveMessage.NativeFlowMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_InteractiveMessage_NativeFlowMessage::IsInitialized() const { + return true; +} + +void Message_InteractiveMessage_NativeFlowMessage::InternalSwap(Message_InteractiveMessage_NativeFlowMessage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.buttons_.InternalSwap(&other->_impl_.buttons_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.messageparamsjson_, lhs_arena, + &other->_impl_.messageparamsjson_, rhs_arena + ); + swap(_impl_.messageversion_, other->_impl_.messageversion_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveMessage_NativeFlowMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[91]); +} + +// =================================================================== + +class Message_InteractiveMessage_ShopMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_id(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_surface(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_messageversion(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +Message_InteractiveMessage_ShopMessage::Message_InteractiveMessage_ShopMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveMessage.ShopMessage) +} +Message_InteractiveMessage_ShopMessage::Message_InteractiveMessage_ShopMessage(const Message_InteractiveMessage_ShopMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_InteractiveMessage_ShopMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.id_){} + , decltype(_impl_.surface_){} + , decltype(_impl_.messageversion_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.id_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.id_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_id()) { + _this->_impl_.id_.Set(from._internal_id(), + _this->GetArenaForAllocation()); + } + ::memcpy(&_impl_.surface_, &from._impl_.surface_, + static_cast(reinterpret_cast(&_impl_.messageversion_) - + reinterpret_cast(&_impl_.surface_)) + sizeof(_impl_.messageversion_)); + // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveMessage.ShopMessage) +} + +inline void Message_InteractiveMessage_ShopMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.id_){} + , decltype(_impl_.surface_){0} + , decltype(_impl_.messageversion_){0} + }; + _impl_.id_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.id_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_InteractiveMessage_ShopMessage::~Message_InteractiveMessage_ShopMessage() { + // @@protoc_insertion_point(destructor:proto.Message.InteractiveMessage.ShopMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_InteractiveMessage_ShopMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.id_.Destroy(); +} + +void Message_InteractiveMessage_ShopMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_InteractiveMessage_ShopMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveMessage.ShopMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.id_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000006u) { + ::memset(&_impl_.surface_, 0, static_cast( + reinterpret_cast(&_impl_.messageversion_) - + reinterpret_cast(&_impl_.surface_)) + sizeof(_impl_.messageversion_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_InteractiveMessage_ShopMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_id(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveMessage.ShopMessage.id"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.Message.InteractiveMessage.ShopMessage.Surface surface = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::Message_InteractiveMessage_ShopMessage_Surface_IsValid(val))) { + _internal_set_surface(static_cast<::proto::Message_InteractiveMessage_ShopMessage_Surface>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional int32 messageVersion = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_messageversion(&has_bits); + _impl_.messageversion_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_InteractiveMessage_ShopMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveMessage.ShopMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string id = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_id().data(), static_cast(this->_internal_id().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.InteractiveMessage.ShopMessage.id"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_id(), target); + } + + // optional .proto.Message.InteractiveMessage.ShopMessage.Surface surface = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this->_internal_surface(), target); + } + + // optional int32 messageVersion = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_messageversion(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.InteractiveMessage.ShopMessage) + return target; +} + +size_t Message_InteractiveMessage_ShopMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveMessage.ShopMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional string id = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_id()); + } + + // optional .proto.Message.InteractiveMessage.ShopMessage.Surface surface = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_surface()); + } + + // optional int32 messageVersion = 3; + if (cached_has_bits & 0x00000004u) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_messageversion()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveMessage_ShopMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_InteractiveMessage_ShopMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveMessage_ShopMessage::GetClassData() const { return &_class_data_; } + + +void Message_InteractiveMessage_ShopMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveMessage.ShopMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_id(from._internal_id()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.surface_ = from._impl_.surface_; + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.messageversion_ = from._impl_.messageversion_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_InteractiveMessage_ShopMessage::CopyFrom(const Message_InteractiveMessage_ShopMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveMessage.ShopMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_InteractiveMessage_ShopMessage::IsInitialized() const { + return true; +} + +void Message_InteractiveMessage_ShopMessage::InternalSwap(Message_InteractiveMessage_ShopMessage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.id_, lhs_arena, + &other->_impl_.id_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_InteractiveMessage_ShopMessage, _impl_.messageversion_) + + sizeof(Message_InteractiveMessage_ShopMessage::_impl_.messageversion_) + - PROTOBUF_FIELD_OFFSET(Message_InteractiveMessage_ShopMessage, _impl_.surface_)>( + reinterpret_cast(&_impl_.surface_), + reinterpret_cast(&other->_impl_.surface_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveMessage_ShopMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[92]); +} + +// =================================================================== + +class Message_InteractiveMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::Message_InteractiveMessage_Header& header(const Message_InteractiveMessage* msg); + static void set_has_header(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::proto::Message_InteractiveMessage_Body& body(const Message_InteractiveMessage* msg); + static void set_has_body(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::proto::Message_InteractiveMessage_Footer& footer(const Message_InteractiveMessage* msg); + static void set_has_footer(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static const ::proto::ContextInfo& contextinfo(const Message_InteractiveMessage* msg); + static void set_has_contextinfo(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static const ::proto::Message_InteractiveMessage_ShopMessage& shopstorefrontmessage(const Message_InteractiveMessage* msg); + static const ::proto::Message_InteractiveMessage_CollectionMessage& collectionmessage(const Message_InteractiveMessage* msg); + static const ::proto::Message_InteractiveMessage_NativeFlowMessage& nativeflowmessage(const Message_InteractiveMessage* msg); +}; + +const ::proto::Message_InteractiveMessage_Header& +Message_InteractiveMessage::_Internal::header(const Message_InteractiveMessage* msg) { + return *msg->_impl_.header_; +} +const ::proto::Message_InteractiveMessage_Body& +Message_InteractiveMessage::_Internal::body(const Message_InteractiveMessage* msg) { + return *msg->_impl_.body_; +} +const ::proto::Message_InteractiveMessage_Footer& +Message_InteractiveMessage::_Internal::footer(const Message_InteractiveMessage* msg) { + return *msg->_impl_.footer_; +} +const ::proto::ContextInfo& +Message_InteractiveMessage::_Internal::contextinfo(const Message_InteractiveMessage* msg) { + return *msg->_impl_.contextinfo_; +} +const ::proto::Message_InteractiveMessage_ShopMessage& +Message_InteractiveMessage::_Internal::shopstorefrontmessage(const Message_InteractiveMessage* msg) { + return *msg->_impl_.interactiveMessage_.shopstorefrontmessage_; +} +const ::proto::Message_InteractiveMessage_CollectionMessage& +Message_InteractiveMessage::_Internal::collectionmessage(const Message_InteractiveMessage* msg) { + return *msg->_impl_.interactiveMessage_.collectionmessage_; +} +const ::proto::Message_InteractiveMessage_NativeFlowMessage& +Message_InteractiveMessage::_Internal::nativeflowmessage(const Message_InteractiveMessage* msg) { + return *msg->_impl_.interactiveMessage_.nativeflowmessage_; +} +void Message_InteractiveMessage::set_allocated_shopstorefrontmessage(::proto::Message_InteractiveMessage_ShopMessage* shopstorefrontmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_interactiveMessage(); + if (shopstorefrontmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(shopstorefrontmessage); + if (message_arena != submessage_arena) { + shopstorefrontmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, shopstorefrontmessage, submessage_arena); + } + set_has_shopstorefrontmessage(); + _impl_.interactiveMessage_.shopstorefrontmessage_ = shopstorefrontmessage; + } + // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.shopStorefrontMessage) +} +void Message_InteractiveMessage::set_allocated_collectionmessage(::proto::Message_InteractiveMessage_CollectionMessage* collectionmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_interactiveMessage(); + if (collectionmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(collectionmessage); + if (message_arena != submessage_arena) { + collectionmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, collectionmessage, submessage_arena); + } + set_has_collectionmessage(); + _impl_.interactiveMessage_.collectionmessage_ = collectionmessage; + } + // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.collectionMessage) +} +void Message_InteractiveMessage::set_allocated_nativeflowmessage(::proto::Message_InteractiveMessage_NativeFlowMessage* nativeflowmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_interactiveMessage(); + if (nativeflowmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(nativeflowmessage); + if (message_arena != submessage_arena) { + nativeflowmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, nativeflowmessage, submessage_arena); + } + set_has_nativeflowmessage(); + _impl_.interactiveMessage_.nativeflowmessage_ = nativeflowmessage; + } + // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.nativeFlowMessage) +} +Message_InteractiveMessage::Message_InteractiveMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveMessage) +} +Message_InteractiveMessage::Message_InteractiveMessage(const Message_InteractiveMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_InteractiveMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.header_){nullptr} + , decltype(_impl_.body_){nullptr} + , decltype(_impl_.footer_){nullptr} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.interactiveMessage_){} + , /*decltype(_impl_._oneof_case_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_header()) { + _this->_impl_.header_ = new ::proto::Message_InteractiveMessage_Header(*from._impl_.header_); + } + if (from._internal_has_body()) { + _this->_impl_.body_ = new ::proto::Message_InteractiveMessage_Body(*from._impl_.body_); + } + if (from._internal_has_footer()) { + _this->_impl_.footer_ = new ::proto::Message_InteractiveMessage_Footer(*from._impl_.footer_); + } + if (from._internal_has_contextinfo()) { + _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); + } + clear_has_interactiveMessage(); + switch (from.interactiveMessage_case()) { + case kShopStorefrontMessage: { + _this->_internal_mutable_shopstorefrontmessage()->::proto::Message_InteractiveMessage_ShopMessage::MergeFrom( + from._internal_shopstorefrontmessage()); + break; + } + case kCollectionMessage: { + _this->_internal_mutable_collectionmessage()->::proto::Message_InteractiveMessage_CollectionMessage::MergeFrom( + from._internal_collectionmessage()); + break; + } + case kNativeFlowMessage: { + _this->_internal_mutable_nativeflowmessage()->::proto::Message_InteractiveMessage_NativeFlowMessage::MergeFrom( + from._internal_nativeflowmessage()); + break; + } + case INTERACTIVEMESSAGE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveMessage) +} + +inline void Message_InteractiveMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.header_){nullptr} + , decltype(_impl_.body_){nullptr} + , decltype(_impl_.footer_){nullptr} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.interactiveMessage_){} + , /*decltype(_impl_._oneof_case_)*/{} + }; + clear_has_interactiveMessage(); +} + +Message_InteractiveMessage::~Message_InteractiveMessage() { + // @@protoc_insertion_point(destructor:proto.Message.InteractiveMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_InteractiveMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.header_; + if (this != internal_default_instance()) delete _impl_.body_; + if (this != internal_default_instance()) delete _impl_.footer_; + if (this != internal_default_instance()) delete _impl_.contextinfo_; + if (has_interactiveMessage()) { + clear_interactiveMessage(); + } +} + +void Message_InteractiveMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_InteractiveMessage::clear_interactiveMessage() { +// @@protoc_insertion_point(one_of_clear_start:proto.Message.InteractiveMessage) + switch (interactiveMessage_case()) { + case kShopStorefrontMessage: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.interactiveMessage_.shopstorefrontmessage_; + } + break; + } + case kCollectionMessage: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.interactiveMessage_.collectionmessage_; + } + break; + } + case kNativeFlowMessage: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.interactiveMessage_.nativeflowmessage_; + } + break; + } + case INTERACTIVEMESSAGE_NOT_SET: { + break; + } + } + _impl_._oneof_case_[0] = INTERACTIVEMESSAGE_NOT_SET; +} + + +void Message_InteractiveMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.header_ != nullptr); + _impl_.header_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.body_ != nullptr); + _impl_.body_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.footer_ != nullptr); + _impl_.footer_->Clear(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); + _impl_.contextinfo_->Clear(); + } + } + clear_interactiveMessage(); + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_InteractiveMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.Message.InteractiveMessage.Header header = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_header(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.InteractiveMessage.Body body = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_body(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.InteractiveMessage.Footer footer = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_footer(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .proto.Message.InteractiveMessage.ShopMessage shopStorefrontMessage = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_shopstorefrontmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .proto.Message.InteractiveMessage.CollectionMessage collectionMessage = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_collectionmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .proto.Message.InteractiveMessage.NativeFlowMessage nativeFlowMessage = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_nativeflowmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.ContextInfo contextInfo = 15; + case 15: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { + ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_InteractiveMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.Message.InteractiveMessage.Header header = 1; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::header(this), + _Internal::header(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.InteractiveMessage.Body body = 2; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::body(this), + _Internal::body(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.InteractiveMessage.Footer footer = 3; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::footer(this), + _Internal::footer(this).GetCachedSize(), target, stream); + } + + switch (interactiveMessage_case()) { + case kShopStorefrontMessage: { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, _Internal::shopstorefrontmessage(this), + _Internal::shopstorefrontmessage(this).GetCachedSize(), target, stream); + break; + } + case kCollectionMessage: { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(5, _Internal::collectionmessage(this), + _Internal::collectionmessage(this).GetCachedSize(), target, stream); + break; + } + case kNativeFlowMessage: { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(6, _Internal::nativeflowmessage(this), + _Internal::nativeflowmessage(this).GetCachedSize(), target, stream); + break; + } + default: ; + } + // optional .proto.ContextInfo contextInfo = 15; + if (cached_has_bits & 0x00000008u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(15, _Internal::contextinfo(this), + _Internal::contextinfo(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.InteractiveMessage) + return target; +} + +size_t Message_InteractiveMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional .proto.Message.InteractiveMessage.Header header = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.header_); + } + + // optional .proto.Message.InteractiveMessage.Body body = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.body_); + } + + // optional .proto.Message.InteractiveMessage.Footer footer = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.footer_); + } + + // optional .proto.ContextInfo contextInfo = 15; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.contextinfo_); + } + + } + switch (interactiveMessage_case()) { + // .proto.Message.InteractiveMessage.ShopMessage shopStorefrontMessage = 4; + case kShopStorefrontMessage: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.interactiveMessage_.shopstorefrontmessage_); + break; + } + // .proto.Message.InteractiveMessage.CollectionMessage collectionMessage = 5; + case kCollectionMessage: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.interactiveMessage_.collectionmessage_); + break; + } + // .proto.Message.InteractiveMessage.NativeFlowMessage nativeFlowMessage = 6; + case kNativeFlowMessage: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.interactiveMessage_.nativeflowmessage_); + break; + } + case INTERACTIVEMESSAGE_NOT_SET: { + break; + } + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_InteractiveMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveMessage::GetClassData() const { return &_class_data_; } + + +void Message_InteractiveMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_header()->::proto::Message_InteractiveMessage_Header::MergeFrom( + from._internal_header()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_body()->::proto::Message_InteractiveMessage_Body::MergeFrom( + from._internal_body()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_footer()->::proto::Message_InteractiveMessage_Footer::MergeFrom( + from._internal_footer()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( + from._internal_contextinfo()); + } + } + switch (from.interactiveMessage_case()) { + case kShopStorefrontMessage: { + _this->_internal_mutable_shopstorefrontmessage()->::proto::Message_InteractiveMessage_ShopMessage::MergeFrom( + from._internal_shopstorefrontmessage()); + break; + } + case kCollectionMessage: { + _this->_internal_mutable_collectionmessage()->::proto::Message_InteractiveMessage_CollectionMessage::MergeFrom( + from._internal_collectionmessage()); + break; + } + case kNativeFlowMessage: { + _this->_internal_mutable_nativeflowmessage()->::proto::Message_InteractiveMessage_NativeFlowMessage::MergeFrom( + from._internal_nativeflowmessage()); + break; + } + case INTERACTIVEMESSAGE_NOT_SET: { + break; + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_InteractiveMessage::CopyFrom(const Message_InteractiveMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_InteractiveMessage::IsInitialized() const { + return true; +} + +void Message_InteractiveMessage::InternalSwap(Message_InteractiveMessage* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_InteractiveMessage, _impl_.contextinfo_) + + sizeof(Message_InteractiveMessage::_impl_.contextinfo_) + - PROTOBUF_FIELD_OFFSET(Message_InteractiveMessage, _impl_.header_)>( + reinterpret_cast(&_impl_.header_), + reinterpret_cast(&other->_impl_.header_)); + swap(_impl_.interactiveMessage_, other->_impl_.interactiveMessage_); + swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[93]); +} + +// =================================================================== + +class Message_InteractiveResponseMessage_Body::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_text(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +Message_InteractiveResponseMessage_Body::Message_InteractiveResponseMessage_Body(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveResponseMessage.Body) +} +Message_InteractiveResponseMessage_Body::Message_InteractiveResponseMessage_Body(const Message_InteractiveResponseMessage_Body& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_InteractiveResponseMessage_Body* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.text_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.text_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.text_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_text()) { + _this->_impl_.text_.Set(from._internal_text(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveResponseMessage.Body) +} + +inline void Message_InteractiveResponseMessage_Body::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.text_){} + }; + _impl_.text_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.text_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_InteractiveResponseMessage_Body::~Message_InteractiveResponseMessage_Body() { + // @@protoc_insertion_point(destructor:proto.Message.InteractiveResponseMessage.Body) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_InteractiveResponseMessage_Body::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.text_.Destroy(); +} + +void Message_InteractiveResponseMessage_Body::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_InteractiveResponseMessage_Body::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveResponseMessage.Body) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.text_.ClearNonDefaultToEmpty(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_InteractiveResponseMessage_Body::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string text = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_text(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveResponseMessage.Body.text"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_InteractiveResponseMessage_Body::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveResponseMessage.Body) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string text = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_text().data(), static_cast(this->_internal_text().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.InteractiveResponseMessage.Body.text"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_text(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.InteractiveResponseMessage.Body) + return target; +} + +size_t Message_InteractiveResponseMessage_Body::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveResponseMessage.Body) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional string text = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_text()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveResponseMessage_Body::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_InteractiveResponseMessage_Body::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveResponseMessage_Body::GetClassData() const { return &_class_data_; } + + +void Message_InteractiveResponseMessage_Body::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveResponseMessage.Body) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_text()) { + _this->_internal_set_text(from._internal_text()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_InteractiveResponseMessage_Body::CopyFrom(const Message_InteractiveResponseMessage_Body& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveResponseMessage.Body) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_InteractiveResponseMessage_Body::IsInitialized() const { + return true; +} + +void Message_InteractiveResponseMessage_Body::InternalSwap(Message_InteractiveResponseMessage_Body* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.text_, lhs_arena, + &other->_impl_.text_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveResponseMessage_Body::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[94]); +} + +// =================================================================== + +class Message_InteractiveResponseMessage_NativeFlowResponseMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_name(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_paramsjson(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_version(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +Message_InteractiveResponseMessage_NativeFlowResponseMessage::Message_InteractiveResponseMessage_NativeFlowResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage) +} +Message_InteractiveResponseMessage_NativeFlowResponseMessage::Message_InteractiveResponseMessage_NativeFlowResponseMessage(const Message_InteractiveResponseMessage_NativeFlowResponseMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_InteractiveResponseMessage_NativeFlowResponseMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.name_){} + , decltype(_impl_.paramsjson_){} + , decltype(_impl_.version_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.name_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.name_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_name()) { + _this->_impl_.name_.Set(from._internal_name(), + _this->GetArenaForAllocation()); + } + _impl_.paramsjson_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.paramsjson_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_paramsjson()) { + _this->_impl_.paramsjson_.Set(from._internal_paramsjson(), + _this->GetArenaForAllocation()); + } + _this->_impl_.version_ = from._impl_.version_; + // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage) +} + +inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.name_){} + , decltype(_impl_.paramsjson_){} + , decltype(_impl_.version_){0} + }; + _impl_.name_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.name_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.paramsjson_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.paramsjson_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_InteractiveResponseMessage_NativeFlowResponseMessage::~Message_InteractiveResponseMessage_NativeFlowResponseMessage() { + // @@protoc_insertion_point(destructor:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.name_.Destroy(); + _impl_.paramsjson_.Destroy(); +} + +void Message_InteractiveResponseMessage_NativeFlowResponseMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_InteractiveResponseMessage_NativeFlowResponseMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.paramsjson_.ClearNonDefaultToEmpty(); + } + } + _impl_.version_ = 0; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_InteractiveResponseMessage_NativeFlowResponseMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_name(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.name"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string paramsJson = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_paramsjson(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.paramsJson"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional int32 version = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_version(&has_bits); + _impl_.version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_InteractiveResponseMessage_NativeFlowResponseMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string name = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.name"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_name(), target); + } + + // optional string paramsJson = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_paramsjson().data(), static_cast(this->_internal_paramsjson().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.paramsJson"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_paramsjson(), target); + } + + // optional int32 version = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_version(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage) + return target; +} + +size_t Message_InteractiveResponseMessage_NativeFlowResponseMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional string name = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // optional string paramsJson = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_paramsjson()); + } + + // optional int32 version = 3; + if (cached_has_bits & 0x00000004u) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_version()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveResponseMessage_NativeFlowResponseMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_InteractiveResponseMessage_NativeFlowResponseMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveResponseMessage_NativeFlowResponseMessage::GetClassData() const { return &_class_data_; } + + +void Message_InteractiveResponseMessage_NativeFlowResponseMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_name(from._internal_name()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_paramsjson(from._internal_paramsjson()); + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.version_ = from._impl_.version_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_InteractiveResponseMessage_NativeFlowResponseMessage::CopyFrom(const Message_InteractiveResponseMessage_NativeFlowResponseMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_InteractiveResponseMessage_NativeFlowResponseMessage::IsInitialized() const { + return true; +} + +void Message_InteractiveResponseMessage_NativeFlowResponseMessage::InternalSwap(Message_InteractiveResponseMessage_NativeFlowResponseMessage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.name_, lhs_arena, + &other->_impl_.name_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.paramsjson_, lhs_arena, + &other->_impl_.paramsjson_, rhs_arena + ); + swap(_impl_.version_, other->_impl_.version_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveResponseMessage_NativeFlowResponseMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[95]); +} + +// =================================================================== + +class Message_InteractiveResponseMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::Message_InteractiveResponseMessage_Body& body(const Message_InteractiveResponseMessage* msg); + static void set_has_body(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::proto::ContextInfo& contextinfo(const Message_InteractiveResponseMessage* msg); + static void set_has_contextinfo(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage& nativeflowresponsemessage(const Message_InteractiveResponseMessage* msg); +}; + +const ::proto::Message_InteractiveResponseMessage_Body& +Message_InteractiveResponseMessage::_Internal::body(const Message_InteractiveResponseMessage* msg) { + return *msg->_impl_.body_; +} +const ::proto::ContextInfo& +Message_InteractiveResponseMessage::_Internal::contextinfo(const Message_InteractiveResponseMessage* msg) { + return *msg->_impl_.contextinfo_; +} +const ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage& +Message_InteractiveResponseMessage::_Internal::nativeflowresponsemessage(const Message_InteractiveResponseMessage* msg) { + return *msg->_impl_.interactiveResponseMessage_.nativeflowresponsemessage_; +} +void Message_InteractiveResponseMessage::set_allocated_nativeflowresponsemessage(::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* nativeflowresponsemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_interactiveResponseMessage(); + if (nativeflowresponsemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(nativeflowresponsemessage); + if (message_arena != submessage_arena) { + nativeflowresponsemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, nativeflowresponsemessage, submessage_arena); + } + set_has_nativeflowresponsemessage(); + _impl_.interactiveResponseMessage_.nativeflowresponsemessage_ = nativeflowresponsemessage; + } + // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveResponseMessage.nativeFlowResponseMessage) +} +Message_InteractiveResponseMessage::Message_InteractiveResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveResponseMessage) +} +Message_InteractiveResponseMessage::Message_InteractiveResponseMessage(const Message_InteractiveResponseMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_InteractiveResponseMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.body_){nullptr} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.interactiveResponseMessage_){} + , /*decltype(_impl_._oneof_case_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_body()) { + _this->_impl_.body_ = new ::proto::Message_InteractiveResponseMessage_Body(*from._impl_.body_); + } + if (from._internal_has_contextinfo()) { + _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); + } + clear_has_interactiveResponseMessage(); + switch (from.interactiveResponseMessage_case()) { + case kNativeFlowResponseMessage: { + _this->_internal_mutable_nativeflowresponsemessage()->::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage::MergeFrom( + from._internal_nativeflowresponsemessage()); + break; + } + case INTERACTIVERESPONSEMESSAGE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveResponseMessage) +} + +inline void Message_InteractiveResponseMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.body_){nullptr} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.interactiveResponseMessage_){} + , /*decltype(_impl_._oneof_case_)*/{} + }; + clear_has_interactiveResponseMessage(); +} + +Message_InteractiveResponseMessage::~Message_InteractiveResponseMessage() { + // @@protoc_insertion_point(destructor:proto.Message.InteractiveResponseMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_InteractiveResponseMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.body_; + if (this != internal_default_instance()) delete _impl_.contextinfo_; + if (has_interactiveResponseMessage()) { + clear_interactiveResponseMessage(); + } +} + +void Message_InteractiveResponseMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_InteractiveResponseMessage::clear_interactiveResponseMessage() { +// @@protoc_insertion_point(one_of_clear_start:proto.Message.InteractiveResponseMessage) + switch (interactiveResponseMessage_case()) { + case kNativeFlowResponseMessage: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.interactiveResponseMessage_.nativeflowresponsemessage_; + } + break; + } + case INTERACTIVERESPONSEMESSAGE_NOT_SET: { + break; + } + } + _impl_._oneof_case_[0] = INTERACTIVERESPONSEMESSAGE_NOT_SET; +} + + +void Message_InteractiveResponseMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveResponseMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.body_ != nullptr); + _impl_.body_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); + _impl_.contextinfo_->Clear(); + } + } + clear_interactiveResponseMessage(); + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_InteractiveResponseMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.Message.InteractiveResponseMessage.Body body = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_body(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage nativeFlowResponseMessage = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_nativeflowresponsemessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.ContextInfo contextInfo = 15; + case 15: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { + ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_InteractiveResponseMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveResponseMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.Message.InteractiveResponseMessage.Body body = 1; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::body(this), + _Internal::body(this).GetCachedSize(), target, stream); + } + + // .proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage nativeFlowResponseMessage = 2; + if (_internal_has_nativeflowresponsemessage()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::nativeflowresponsemessage(this), + _Internal::nativeflowresponsemessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.ContextInfo contextInfo = 15; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(15, _Internal::contextinfo(this), + _Internal::contextinfo(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.InteractiveResponseMessage) + return target; +} + +size_t Message_InteractiveResponseMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveResponseMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional .proto.Message.InteractiveResponseMessage.Body body = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.body_); + } + + // optional .proto.ContextInfo contextInfo = 15; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.contextinfo_); + } + + } + switch (interactiveResponseMessage_case()) { + // .proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage nativeFlowResponseMessage = 2; + case kNativeFlowResponseMessage: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.interactiveResponseMessage_.nativeflowresponsemessage_); + break; + } + case INTERACTIVERESPONSEMESSAGE_NOT_SET: { + break; + } + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveResponseMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_InteractiveResponseMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveResponseMessage::GetClassData() const { return &_class_data_; } + + +void Message_InteractiveResponseMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveResponseMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_body()->::proto::Message_InteractiveResponseMessage_Body::MergeFrom( + from._internal_body()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( + from._internal_contextinfo()); + } + } + switch (from.interactiveResponseMessage_case()) { + case kNativeFlowResponseMessage: { + _this->_internal_mutable_nativeflowresponsemessage()->::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage::MergeFrom( + from._internal_nativeflowresponsemessage()); + break; + } + case INTERACTIVERESPONSEMESSAGE_NOT_SET: { + break; + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_InteractiveResponseMessage::CopyFrom(const Message_InteractiveResponseMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveResponseMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_InteractiveResponseMessage::IsInitialized() const { + return true; +} + +void Message_InteractiveResponseMessage::InternalSwap(Message_InteractiveResponseMessage* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_InteractiveResponseMessage, _impl_.contextinfo_) + + sizeof(Message_InteractiveResponseMessage::_impl_.contextinfo_) + - PROTOBUF_FIELD_OFFSET(Message_InteractiveResponseMessage, _impl_.body_)>( + reinterpret_cast(&_impl_.body_), + reinterpret_cast(&other->_impl_.body_)); + swap(_impl_.interactiveResponseMessage_, other->_impl_.interactiveResponseMessage_); + swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveResponseMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[96]); +} + +// =================================================================== + +class Message_InvoiceMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_note(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_token(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_attachmenttype(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_attachmentmimetype(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_attachmentmediakey(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_attachmentmediakeytimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_attachmentfilesha256(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_attachmentfileencsha256(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_attachmentdirectpath(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_attachmentjpegthumbnail(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } +}; + +Message_InvoiceMessage::Message_InvoiceMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.InvoiceMessage) +} +Message_InvoiceMessage::Message_InvoiceMessage(const Message_InvoiceMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_InvoiceMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.note_){} + , decltype(_impl_.token_){} + , decltype(_impl_.attachmentmimetype_){} + , decltype(_impl_.attachmentmediakey_){} + , decltype(_impl_.attachmentfilesha256_){} + , decltype(_impl_.attachmentfileencsha256_){} + , decltype(_impl_.attachmentdirectpath_){} + , decltype(_impl_.attachmentjpegthumbnail_){} + , decltype(_impl_.attachmentmediakeytimestamp_){} + , decltype(_impl_.attachmenttype_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.note_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.note_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_note()) { + _this->_impl_.note_.Set(from._internal_note(), + _this->GetArenaForAllocation()); + } + _impl_.token_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.token_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_token()) { + _this->_impl_.token_.Set(from._internal_token(), + _this->GetArenaForAllocation()); + } + _impl_.attachmentmimetype_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.attachmentmimetype_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_attachmentmimetype()) { + _this->_impl_.attachmentmimetype_.Set(from._internal_attachmentmimetype(), + _this->GetArenaForAllocation()); + } + _impl_.attachmentmediakey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.attachmentmediakey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_attachmentmediakey()) { + _this->_impl_.attachmentmediakey_.Set(from._internal_attachmentmediakey(), + _this->GetArenaForAllocation()); + } + _impl_.attachmentfilesha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.attachmentfilesha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_attachmentfilesha256()) { + _this->_impl_.attachmentfilesha256_.Set(from._internal_attachmentfilesha256(), + _this->GetArenaForAllocation()); + } + _impl_.attachmentfileencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.attachmentfileencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_attachmentfileencsha256()) { + _this->_impl_.attachmentfileencsha256_.Set(from._internal_attachmentfileencsha256(), + _this->GetArenaForAllocation()); + } + _impl_.attachmentdirectpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.attachmentdirectpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_attachmentdirectpath()) { + _this->_impl_.attachmentdirectpath_.Set(from._internal_attachmentdirectpath(), + _this->GetArenaForAllocation()); + } + _impl_.attachmentjpegthumbnail_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.attachmentjpegthumbnail_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_attachmentjpegthumbnail()) { + _this->_impl_.attachmentjpegthumbnail_.Set(from._internal_attachmentjpegthumbnail(), + _this->GetArenaForAllocation()); + } + ::memcpy(&_impl_.attachmentmediakeytimestamp_, &from._impl_.attachmentmediakeytimestamp_, + static_cast(reinterpret_cast(&_impl_.attachmenttype_) - + reinterpret_cast(&_impl_.attachmentmediakeytimestamp_)) + sizeof(_impl_.attachmenttype_)); + // @@protoc_insertion_point(copy_constructor:proto.Message.InvoiceMessage) +} + +inline void Message_InvoiceMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.note_){} + , decltype(_impl_.token_){} + , decltype(_impl_.attachmentmimetype_){} + , decltype(_impl_.attachmentmediakey_){} + , decltype(_impl_.attachmentfilesha256_){} + , decltype(_impl_.attachmentfileencsha256_){} + , decltype(_impl_.attachmentdirectpath_){} + , decltype(_impl_.attachmentjpegthumbnail_){} + , decltype(_impl_.attachmentmediakeytimestamp_){int64_t{0}} + , decltype(_impl_.attachmenttype_){0} + }; + _impl_.note_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.note_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.token_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.token_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.attachmentmimetype_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.attachmentmimetype_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.attachmentmediakey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.attachmentmediakey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.attachmentfilesha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.attachmentfilesha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.attachmentfileencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.attachmentfileencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.attachmentdirectpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.attachmentdirectpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.attachmentjpegthumbnail_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.attachmentjpegthumbnail_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_InvoiceMessage::~Message_InvoiceMessage() { + // @@protoc_insertion_point(destructor:proto.Message.InvoiceMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_InvoiceMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.note_.Destroy(); + _impl_.token_.Destroy(); + _impl_.attachmentmimetype_.Destroy(); + _impl_.attachmentmediakey_.Destroy(); + _impl_.attachmentfilesha256_.Destroy(); + _impl_.attachmentfileencsha256_.Destroy(); + _impl_.attachmentdirectpath_.Destroy(); + _impl_.attachmentjpegthumbnail_.Destroy(); +} + +void Message_InvoiceMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_InvoiceMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.InvoiceMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _impl_.note_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.token_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.attachmentmimetype_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + _impl_.attachmentmediakey_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + _impl_.attachmentfilesha256_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000020u) { + _impl_.attachmentfileencsha256_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000040u) { + _impl_.attachmentdirectpath_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000080u) { + _impl_.attachmentjpegthumbnail_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x00000300u) { + ::memset(&_impl_.attachmentmediakeytimestamp_, 0, static_cast( + reinterpret_cast(&_impl_.attachmenttype_) - + reinterpret_cast(&_impl_.attachmentmediakeytimestamp_)) + sizeof(_impl_.attachmenttype_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_InvoiceMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string note = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_note(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.InvoiceMessage.note"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string token = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_token(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.InvoiceMessage.token"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.Message.InvoiceMessage.AttachmentType attachmentType = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::Message_InvoiceMessage_AttachmentType_IsValid(val))) { + _internal_set_attachmenttype(static_cast<::proto::Message_InvoiceMessage_AttachmentType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional string attachmentMimetype = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_attachmentmimetype(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.InvoiceMessage.attachmentMimetype"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bytes attachmentMediaKey = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + auto str = _internal_mutable_attachmentmediakey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 attachmentMediaKeyTimestamp = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + _Internal::set_has_attachmentmediakeytimestamp(&has_bits); + _impl_.attachmentmediakeytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes attachmentFileSha256 = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + auto str = _internal_mutable_attachmentfilesha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes attachmentFileEncSha256 = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + auto str = _internal_mutable_attachmentfileencsha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string attachmentDirectPath = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + auto str = _internal_mutable_attachmentdirectpath(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.InvoiceMessage.attachmentDirectPath"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bytes attachmentJpegThumbnail = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { + auto str = _internal_mutable_attachmentjpegthumbnail(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_InvoiceMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InvoiceMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string note = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_note().data(), static_cast(this->_internal_note().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.InvoiceMessage.note"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_note(), target); + } + + // optional string token = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_token().data(), static_cast(this->_internal_token().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.InvoiceMessage.token"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_token(), target); + } + + // optional .proto.Message.InvoiceMessage.AttachmentType attachmentType = 3; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 3, this->_internal_attachmenttype(), target); + } + + // optional string attachmentMimetype = 4; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_attachmentmimetype().data(), static_cast(this->_internal_attachmentmimetype().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.InvoiceMessage.attachmentMimetype"); + target = stream->WriteStringMaybeAliased( + 4, this->_internal_attachmentmimetype(), target); + } + + // optional bytes attachmentMediaKey = 5; + if (cached_has_bits & 0x00000008u) { + target = stream->WriteBytesMaybeAliased( + 5, this->_internal_attachmentmediakey(), target); + } + + // optional int64 attachmentMediaKeyTimestamp = 6; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(6, this->_internal_attachmentmediakeytimestamp(), target); + } + + // optional bytes attachmentFileSha256 = 7; + if (cached_has_bits & 0x00000010u) { + target = stream->WriteBytesMaybeAliased( + 7, this->_internal_attachmentfilesha256(), target); + } + + // optional bytes attachmentFileEncSha256 = 8; + if (cached_has_bits & 0x00000020u) { + target = stream->WriteBytesMaybeAliased( + 8, this->_internal_attachmentfileencsha256(), target); + } + + // optional string attachmentDirectPath = 9; + if (cached_has_bits & 0x00000040u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_attachmentdirectpath().data(), static_cast(this->_internal_attachmentdirectpath().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.InvoiceMessage.attachmentDirectPath"); + target = stream->WriteStringMaybeAliased( + 9, this->_internal_attachmentdirectpath(), target); + } + + // optional bytes attachmentJpegThumbnail = 10; + if (cached_has_bits & 0x00000080u) { + target = stream->WriteBytesMaybeAliased( + 10, this->_internal_attachmentjpegthumbnail(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.InvoiceMessage) + return target; +} + +size_t Message_InvoiceMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.InvoiceMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string note = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_note()); + } + + // optional string token = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_token()); + } + + // optional string attachmentMimetype = 4; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_attachmentmimetype()); + } + + // optional bytes attachmentMediaKey = 5; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_attachmentmediakey()); + } + + // optional bytes attachmentFileSha256 = 7; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_attachmentfilesha256()); + } + + // optional bytes attachmentFileEncSha256 = 8; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_attachmentfileencsha256()); + } + + // optional string attachmentDirectPath = 9; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_attachmentdirectpath()); + } + + // optional bytes attachmentJpegThumbnail = 10; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_attachmentjpegthumbnail()); + } + + } + if (cached_has_bits & 0x00000300u) { + // optional int64 attachmentMediaKeyTimestamp = 6; + if (cached_has_bits & 0x00000100u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_attachmentmediakeytimestamp()); + } + + // optional .proto.Message.InvoiceMessage.AttachmentType attachmentType = 3; + if (cached_has_bits & 0x00000200u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_attachmenttype()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InvoiceMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_InvoiceMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InvoiceMessage::GetClassData() const { return &_class_data_; } + + +void Message_InvoiceMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InvoiceMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_note(from._internal_note()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_token(from._internal_token()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_attachmentmimetype(from._internal_attachmentmimetype()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_set_attachmentmediakey(from._internal_attachmentmediakey()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_set_attachmentfilesha256(from._internal_attachmentfilesha256()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_set_attachmentfileencsha256(from._internal_attachmentfileencsha256()); + } + if (cached_has_bits & 0x00000040u) { + _this->_internal_set_attachmentdirectpath(from._internal_attachmentdirectpath()); + } + if (cached_has_bits & 0x00000080u) { + _this->_internal_set_attachmentjpegthumbnail(from._internal_attachmentjpegthumbnail()); + } + } + if (cached_has_bits & 0x00000300u) { + if (cached_has_bits & 0x00000100u) { + _this->_impl_.attachmentmediakeytimestamp_ = from._impl_.attachmentmediakeytimestamp_; + } + if (cached_has_bits & 0x00000200u) { + _this->_impl_.attachmenttype_ = from._impl_.attachmenttype_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_InvoiceMessage::CopyFrom(const Message_InvoiceMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InvoiceMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_InvoiceMessage::IsInitialized() const { + return true; +} + +void Message_InvoiceMessage::InternalSwap(Message_InvoiceMessage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.note_, lhs_arena, + &other->_impl_.note_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.token_, lhs_arena, + &other->_impl_.token_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.attachmentmimetype_, lhs_arena, + &other->_impl_.attachmentmimetype_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.attachmentmediakey_, lhs_arena, + &other->_impl_.attachmentmediakey_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.attachmentfilesha256_, lhs_arena, + &other->_impl_.attachmentfilesha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.attachmentfileencsha256_, lhs_arena, + &other->_impl_.attachmentfileencsha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.attachmentdirectpath_, lhs_arena, + &other->_impl_.attachmentdirectpath_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.attachmentjpegthumbnail_, lhs_arena, + &other->_impl_.attachmentjpegthumbnail_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_InvoiceMessage, _impl_.attachmenttype_) + + sizeof(Message_InvoiceMessage::_impl_.attachmenttype_) + - PROTOBUF_FIELD_OFFSET(Message_InvoiceMessage, _impl_.attachmentmediakeytimestamp_)>( + reinterpret_cast(&_impl_.attachmentmediakeytimestamp_), + reinterpret_cast(&other->_impl_.attachmentmediakeytimestamp_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_InvoiceMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[97]); +} + +// =================================================================== + +class Message_KeepInChatMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::MessageKey& key(const Message_KeepInChatMessage* msg); + static void set_has_key(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_keeptype(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_timestampms(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::proto::MessageKey& +Message_KeepInChatMessage::_Internal::key(const Message_KeepInChatMessage* msg) { + return *msg->_impl_.key_; +} +Message_KeepInChatMessage::Message_KeepInChatMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.KeepInChatMessage) +} +Message_KeepInChatMessage::Message_KeepInChatMessage(const Message_KeepInChatMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_KeepInChatMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.key_){nullptr} + , decltype(_impl_.timestampms_){} + , decltype(_impl_.keeptype_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_key()) { + _this->_impl_.key_ = new ::proto::MessageKey(*from._impl_.key_); + } + ::memcpy(&_impl_.timestampms_, &from._impl_.timestampms_, + static_cast(reinterpret_cast(&_impl_.keeptype_) - + reinterpret_cast(&_impl_.timestampms_)) + sizeof(_impl_.keeptype_)); + // @@protoc_insertion_point(copy_constructor:proto.Message.KeepInChatMessage) +} + +inline void Message_KeepInChatMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.key_){nullptr} + , decltype(_impl_.timestampms_){int64_t{0}} + , decltype(_impl_.keeptype_){0} + }; +} + +Message_KeepInChatMessage::~Message_KeepInChatMessage() { + // @@protoc_insertion_point(destructor:proto.Message.KeepInChatMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_KeepInChatMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.key_; +} + +void Message_KeepInChatMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_KeepInChatMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.KeepInChatMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.key_ != nullptr); + _impl_.key_->Clear(); + } + if (cached_has_bits & 0x00000006u) { + ::memset(&_impl_.timestampms_, 0, static_cast( + reinterpret_cast(&_impl_.keeptype_) - + reinterpret_cast(&_impl_.timestampms_)) + sizeof(_impl_.keeptype_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_KeepInChatMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.MessageKey key = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.KeepType keepType = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::KeepType_IsValid(val))) { + _internal_set_keeptype(static_cast<::proto::KeepType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional int64 timestampMs = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_timestampms(&has_bits); + _impl_.timestampms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_KeepInChatMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.KeepInChatMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.MessageKey key = 1; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::key(this), + _Internal::key(this).GetCachedSize(), target, stream); + } + + // optional .proto.KeepType keepType = 2; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this->_internal_keeptype(), target); + } + + // optional int64 timestampMs = 3; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_timestampms(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.KeepInChatMessage) + return target; +} + +size_t Message_KeepInChatMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.KeepInChatMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional .proto.MessageKey key = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.key_); + } + + // optional int64 timestampMs = 3; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_timestampms()); + } + + // optional .proto.KeepType keepType = 2; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_keeptype()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_KeepInChatMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_KeepInChatMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_KeepInChatMessage::GetClassData() const { return &_class_data_; } + + +void Message_KeepInChatMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.KeepInChatMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_key()->::proto::MessageKey::MergeFrom( + from._internal_key()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.timestampms_ = from._impl_.timestampms_; + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.keeptype_ = from._impl_.keeptype_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_KeepInChatMessage::CopyFrom(const Message_KeepInChatMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.KeepInChatMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_KeepInChatMessage::IsInitialized() const { + return true; +} + +void Message_KeepInChatMessage::InternalSwap(Message_KeepInChatMessage* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_KeepInChatMessage, _impl_.keeptype_) + + sizeof(Message_KeepInChatMessage::_impl_.keeptype_) + - PROTOBUF_FIELD_OFFSET(Message_KeepInChatMessage, _impl_.key_)>( + reinterpret_cast(&_impl_.key_), + reinterpret_cast(&other->_impl_.key_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_KeepInChatMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[98]); +} + +// =================================================================== + +class Message_ListMessage_ProductListHeaderImage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_productid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_jpegthumbnail(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +Message_ListMessage_ProductListHeaderImage::Message_ListMessage_ProductListHeaderImage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.ListMessage.ProductListHeaderImage) +} +Message_ListMessage_ProductListHeaderImage::Message_ListMessage_ProductListHeaderImage(const Message_ListMessage_ProductListHeaderImage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_ListMessage_ProductListHeaderImage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.productid_){} + , decltype(_impl_.jpegthumbnail_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.productid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.productid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_productid()) { + _this->_impl_.productid_.Set(from._internal_productid(), + _this->GetArenaForAllocation()); + } + _impl_.jpegthumbnail_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_jpegthumbnail()) { + _this->_impl_.jpegthumbnail_.Set(from._internal_jpegthumbnail(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.Message.ListMessage.ProductListHeaderImage) +} + +inline void Message_ListMessage_ProductListHeaderImage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.productid_){} + , decltype(_impl_.jpegthumbnail_){} + }; + _impl_.productid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.productid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.jpegthumbnail_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_ListMessage_ProductListHeaderImage::~Message_ListMessage_ProductListHeaderImage() { + // @@protoc_insertion_point(destructor:proto.Message.ListMessage.ProductListHeaderImage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_ListMessage_ProductListHeaderImage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.productid_.Destroy(); + _impl_.jpegthumbnail_.Destroy(); +} + +void Message_ListMessage_ProductListHeaderImage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_ListMessage_ProductListHeaderImage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.ListMessage.ProductListHeaderImage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.productid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.jpegthumbnail_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_ListMessage_ProductListHeaderImage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string productId = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_productid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.ProductListHeaderImage.productId"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bytes jpegThumbnail = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_jpegthumbnail(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_ListMessage_ProductListHeaderImage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ListMessage.ProductListHeaderImage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string productId = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_productid().data(), static_cast(this->_internal_productid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ListMessage.ProductListHeaderImage.productId"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_productid(), target); + } + + // optional bytes jpegThumbnail = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_jpegthumbnail(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ListMessage.ProductListHeaderImage) + return target; +} + +size_t Message_ListMessage_ProductListHeaderImage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.ListMessage.ProductListHeaderImage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional string productId = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_productid()); + } + + // optional bytes jpegThumbnail = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_jpegthumbnail()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ListMessage_ProductListHeaderImage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_ListMessage_ProductListHeaderImage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ListMessage_ProductListHeaderImage::GetClassData() const { return &_class_data_; } + + +void Message_ListMessage_ProductListHeaderImage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ListMessage.ProductListHeaderImage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_productid(from._internal_productid()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_ListMessage_ProductListHeaderImage::CopyFrom(const Message_ListMessage_ProductListHeaderImage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ListMessage.ProductListHeaderImage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_ListMessage_ProductListHeaderImage::IsInitialized() const { + return true; +} + +void Message_ListMessage_ProductListHeaderImage::InternalSwap(Message_ListMessage_ProductListHeaderImage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.productid_, lhs_arena, + &other->_impl_.productid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.jpegthumbnail_, lhs_arena, + &other->_impl_.jpegthumbnail_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_ListMessage_ProductListHeaderImage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[99]); +} + +// =================================================================== + +class Message_ListMessage_ProductListInfo::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::Message_ListMessage_ProductListHeaderImage& headerimage(const Message_ListMessage_ProductListInfo* msg); + static void set_has_headerimage(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_businessownerjid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +const ::proto::Message_ListMessage_ProductListHeaderImage& +Message_ListMessage_ProductListInfo::_Internal::headerimage(const Message_ListMessage_ProductListInfo* msg) { + return *msg->_impl_.headerimage_; +} +Message_ListMessage_ProductListInfo::Message_ListMessage_ProductListInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.ListMessage.ProductListInfo) +} +Message_ListMessage_ProductListInfo::Message_ListMessage_ProductListInfo(const Message_ListMessage_ProductListInfo& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_ListMessage_ProductListInfo* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.productsections_){from._impl_.productsections_} + , decltype(_impl_.businessownerjid_){} + , decltype(_impl_.headerimage_){nullptr}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.businessownerjid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.businessownerjid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_businessownerjid()) { + _this->_impl_.businessownerjid_.Set(from._internal_businessownerjid(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_headerimage()) { + _this->_impl_.headerimage_ = new ::proto::Message_ListMessage_ProductListHeaderImage(*from._impl_.headerimage_); + } + // @@protoc_insertion_point(copy_constructor:proto.Message.ListMessage.ProductListInfo) +} + +inline void Message_ListMessage_ProductListInfo::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.productsections_){arena} + , decltype(_impl_.businessownerjid_){} + , decltype(_impl_.headerimage_){nullptr} + }; + _impl_.businessownerjid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.businessownerjid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_ListMessage_ProductListInfo::~Message_ListMessage_ProductListInfo() { + // @@protoc_insertion_point(destructor:proto.Message.ListMessage.ProductListInfo) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_ListMessage_ProductListInfo::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.productsections_.~RepeatedPtrField(); + _impl_.businessownerjid_.Destroy(); + if (this != internal_default_instance()) delete _impl_.headerimage_; +} + +void Message_ListMessage_ProductListInfo::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_ListMessage_ProductListInfo::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.ListMessage.ProductListInfo) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.productsections_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.businessownerjid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.headerimage_ != nullptr); + _impl_.headerimage_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_ListMessage_ProductListInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .proto.Message.ListMessage.ProductSection productSections = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_productsections(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else + goto handle_unusual; + continue; + // optional .proto.Message.ListMessage.ProductListHeaderImage headerImage = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_headerimage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string businessOwnerJid = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_businessownerjid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.ProductListInfo.businessOwnerJid"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_ListMessage_ProductListInfo::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ListMessage.ProductListInfo) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .proto.Message.ListMessage.ProductSection productSections = 1; + for (unsigned i = 0, + n = static_cast(this->_internal_productsections_size()); i < n; i++) { + const auto& repfield = this->_internal_productsections(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream); + } + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.Message.ListMessage.ProductListHeaderImage headerImage = 2; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::headerimage(this), + _Internal::headerimage(this).GetCachedSize(), target, stream); + } + + // optional string businessOwnerJid = 3; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_businessownerjid().data(), static_cast(this->_internal_businessownerjid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ListMessage.ProductListInfo.businessOwnerJid"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_businessownerjid(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ListMessage.ProductListInfo) + return target; +} + +size_t Message_ListMessage_ProductListInfo::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.ListMessage.ProductListInfo) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.Message.ListMessage.ProductSection productSections = 1; + total_size += 1UL * this->_internal_productsections_size(); + for (const auto& msg : this->_impl_.productsections_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional string businessOwnerJid = 3; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_businessownerjid()); + } + + // optional .proto.Message.ListMessage.ProductListHeaderImage headerImage = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.headerimage_); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ListMessage_ProductListInfo::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_ListMessage_ProductListInfo::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ListMessage_ProductListInfo::GetClassData() const { return &_class_data_; } + + +void Message_ListMessage_ProductListInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ListMessage.ProductListInfo) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.productsections_.MergeFrom(from._impl_.productsections_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_businessownerjid(from._internal_businessownerjid()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_headerimage()->::proto::Message_ListMessage_ProductListHeaderImage::MergeFrom( + from._internal_headerimage()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_ListMessage_ProductListInfo::CopyFrom(const Message_ListMessage_ProductListInfo& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ListMessage.ProductListInfo) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_ListMessage_ProductListInfo::IsInitialized() const { + return true; +} + +void Message_ListMessage_ProductListInfo::InternalSwap(Message_ListMessage_ProductListInfo* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.productsections_.InternalSwap(&other->_impl_.productsections_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.businessownerjid_, lhs_arena, + &other->_impl_.businessownerjid_, rhs_arena + ); + swap(_impl_.headerimage_, other->_impl_.headerimage_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_ListMessage_ProductListInfo::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[100]); +} + +// =================================================================== + +class Message_ListMessage_ProductSection::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_title(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +Message_ListMessage_ProductSection::Message_ListMessage_ProductSection(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.ListMessage.ProductSection) +} +Message_ListMessage_ProductSection::Message_ListMessage_ProductSection(const Message_ListMessage_ProductSection& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_ListMessage_ProductSection* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.products_){from._impl_.products_} + , decltype(_impl_.title_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.title_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.title_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_title()) { + _this->_impl_.title_.Set(from._internal_title(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.Message.ListMessage.ProductSection) +} + +inline void Message_ListMessage_ProductSection::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.products_){arena} + , decltype(_impl_.title_){} + }; + _impl_.title_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.title_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_ListMessage_ProductSection::~Message_ListMessage_ProductSection() { + // @@protoc_insertion_point(destructor:proto.Message.ListMessage.ProductSection) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_ListMessage_ProductSection::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.products_.~RepeatedPtrField(); + _impl_.title_.Destroy(); +} + +void Message_ListMessage_ProductSection::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_ListMessage_ProductSection::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.ListMessage.ProductSection) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.products_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.title_.ClearNonDefaultToEmpty(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_ListMessage_ProductSection::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string title = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_title(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.ProductSection.title"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // repeated .proto.Message.ListMessage.Product products = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_products(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_ListMessage_ProductSection::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ListMessage.ProductSection) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string title = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_title().data(), static_cast(this->_internal_title().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ListMessage.ProductSection.title"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_title(), target); + } + + // repeated .proto.Message.ListMessage.Product products = 2; + for (unsigned i = 0, + n = static_cast(this->_internal_products_size()); i < n; i++) { + const auto& repfield = this->_internal_products(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ListMessage.ProductSection) + return target; +} + +size_t Message_ListMessage_ProductSection::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.ListMessage.ProductSection) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.Message.ListMessage.Product products = 2; + total_size += 1UL * this->_internal_products_size(); + for (const auto& msg : this->_impl_.products_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // optional string title = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_title()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ListMessage_ProductSection::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_ListMessage_ProductSection::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ListMessage_ProductSection::GetClassData() const { return &_class_data_; } + + +void Message_ListMessage_ProductSection::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ListMessage.ProductSection) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.products_.MergeFrom(from._impl_.products_); + if (from._internal_has_title()) { + _this->_internal_set_title(from._internal_title()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_ListMessage_ProductSection::CopyFrom(const Message_ListMessage_ProductSection& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ListMessage.ProductSection) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_ListMessage_ProductSection::IsInitialized() const { + return true; +} + +void Message_ListMessage_ProductSection::InternalSwap(Message_ListMessage_ProductSection* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.products_.InternalSwap(&other->_impl_.products_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.title_, lhs_arena, + &other->_impl_.title_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_ListMessage_ProductSection::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[101]); +} + +// =================================================================== + +class Message_ListMessage_Product::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_productid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +Message_ListMessage_Product::Message_ListMessage_Product(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.ListMessage.Product) +} +Message_ListMessage_Product::Message_ListMessage_Product(const Message_ListMessage_Product& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_ListMessage_Product* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.productid_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.productid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.productid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_productid()) { + _this->_impl_.productid_.Set(from._internal_productid(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.Message.ListMessage.Product) +} + +inline void Message_ListMessage_Product::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.productid_){} + }; + _impl_.productid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.productid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_ListMessage_Product::~Message_ListMessage_Product() { + // @@protoc_insertion_point(destructor:proto.Message.ListMessage.Product) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_ListMessage_Product::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.productid_.Destroy(); +} + +void Message_ListMessage_Product::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_ListMessage_Product::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.ListMessage.Product) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.productid_.ClearNonDefaultToEmpty(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_ListMessage_Product::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string productId = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_productid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.Product.productId"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_ListMessage_Product::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ListMessage.Product) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string productId = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_productid().data(), static_cast(this->_internal_productid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ListMessage.Product.productId"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_productid(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ListMessage.Product) + return target; +} + +size_t Message_ListMessage_Product::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.ListMessage.Product) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional string productId = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_productid()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ListMessage_Product::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_ListMessage_Product::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ListMessage_Product::GetClassData() const { return &_class_data_; } + + +void Message_ListMessage_Product::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ListMessage.Product) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_productid()) { + _this->_internal_set_productid(from._internal_productid()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_ListMessage_Product::CopyFrom(const Message_ListMessage_Product& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ListMessage.Product) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_ListMessage_Product::IsInitialized() const { + return true; +} + +void Message_ListMessage_Product::InternalSwap(Message_ListMessage_Product* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.productid_, lhs_arena, + &other->_impl_.productid_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_ListMessage_Product::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[102]); +} + +// =================================================================== + +class Message_ListMessage_Row::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_title(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_description(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_rowid(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +Message_ListMessage_Row::Message_ListMessage_Row(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.ListMessage.Row) +} +Message_ListMessage_Row::Message_ListMessage_Row(const Message_ListMessage_Row& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_ListMessage_Row* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.title_){} + , decltype(_impl_.description_){} + , decltype(_impl_.rowid_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.title_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.title_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_title()) { + _this->_impl_.title_.Set(from._internal_title(), + _this->GetArenaForAllocation()); + } + _impl_.description_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.description_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_description()) { + _this->_impl_.description_.Set(from._internal_description(), + _this->GetArenaForAllocation()); + } + _impl_.rowid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.rowid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_rowid()) { + _this->_impl_.rowid_.Set(from._internal_rowid(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.Message.ListMessage.Row) +} + +inline void Message_ListMessage_Row::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.title_){} + , decltype(_impl_.description_){} + , decltype(_impl_.rowid_){} + }; + _impl_.title_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.title_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.description_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.description_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.rowid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.rowid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_ListMessage_Row::~Message_ListMessage_Row() { + // @@protoc_insertion_point(destructor:proto.Message.ListMessage.Row) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_ListMessage_Row::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.title_.Destroy(); + _impl_.description_.Destroy(); + _impl_.rowid_.Destroy(); +} + +void Message_ListMessage_Row::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_ListMessage_Row::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.ListMessage.Row) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _impl_.title_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.description_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.rowid_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_ListMessage_Row::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string title = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_title(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.Row.title"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string description = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_description(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.Row.description"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string rowId = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_rowid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.Row.rowId"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_ListMessage_Row::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ListMessage.Row) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string title = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_title().data(), static_cast(this->_internal_title().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ListMessage.Row.title"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_title(), target); + } + + // optional string description = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_description().data(), static_cast(this->_internal_description().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ListMessage.Row.description"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_description(), target); + } + + // optional string rowId = 3; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_rowid().data(), static_cast(this->_internal_rowid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ListMessage.Row.rowId"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_rowid(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ListMessage.Row) + return target; +} + +size_t Message_ListMessage_Row::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.ListMessage.Row) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional string title = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_title()); + } + + // optional string description = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_description()); + } + + // optional string rowId = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_rowid()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ListMessage_Row::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_ListMessage_Row::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ListMessage_Row::GetClassData() const { return &_class_data_; } + + +void Message_ListMessage_Row::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ListMessage.Row) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_title(from._internal_title()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_description(from._internal_description()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_rowid(from._internal_rowid()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_ListMessage_Row::CopyFrom(const Message_ListMessage_Row& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ListMessage.Row) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_ListMessage_Row::IsInitialized() const { + return true; +} + +void Message_ListMessage_Row::InternalSwap(Message_ListMessage_Row* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.title_, lhs_arena, + &other->_impl_.title_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.description_, lhs_arena, + &other->_impl_.description_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.rowid_, lhs_arena, + &other->_impl_.rowid_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_ListMessage_Row::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[103]); +} + +// =================================================================== + +class Message_ListMessage_Section::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_title(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +Message_ListMessage_Section::Message_ListMessage_Section(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.ListMessage.Section) +} +Message_ListMessage_Section::Message_ListMessage_Section(const Message_ListMessage_Section& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_ListMessage_Section* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.rows_){from._impl_.rows_} + , decltype(_impl_.title_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.title_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.title_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_title()) { + _this->_impl_.title_.Set(from._internal_title(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.Message.ListMessage.Section) +} + +inline void Message_ListMessage_Section::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.rows_){arena} + , decltype(_impl_.title_){} + }; + _impl_.title_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.title_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_ListMessage_Section::~Message_ListMessage_Section() { + // @@protoc_insertion_point(destructor:proto.Message.ListMessage.Section) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_ListMessage_Section::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.rows_.~RepeatedPtrField(); + _impl_.title_.Destroy(); +} + +void Message_ListMessage_Section::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_ListMessage_Section::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.ListMessage.Section) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.rows_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.title_.ClearNonDefaultToEmpty(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_ListMessage_Section::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string title = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_title(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.Section.title"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // repeated .proto.Message.ListMessage.Row rows = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_rows(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_ListMessage_Section::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ListMessage.Section) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string title = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_title().data(), static_cast(this->_internal_title().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ListMessage.Section.title"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_title(), target); + } + + // repeated .proto.Message.ListMessage.Row rows = 2; + for (unsigned i = 0, + n = static_cast(this->_internal_rows_size()); i < n; i++) { + const auto& repfield = this->_internal_rows(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ListMessage.Section) + return target; +} + +size_t Message_ListMessage_Section::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.ListMessage.Section) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.Message.ListMessage.Row rows = 2; + total_size += 1UL * this->_internal_rows_size(); + for (const auto& msg : this->_impl_.rows_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // optional string title = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_title()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ListMessage_Section::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_ListMessage_Section::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ListMessage_Section::GetClassData() const { return &_class_data_; } + + +void Message_ListMessage_Section::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ListMessage.Section) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.rows_.MergeFrom(from._impl_.rows_); + if (from._internal_has_title()) { + _this->_internal_set_title(from._internal_title()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_ListMessage_Section::CopyFrom(const Message_ListMessage_Section& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ListMessage.Section) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_ListMessage_Section::IsInitialized() const { + return true; +} + +void Message_ListMessage_Section::InternalSwap(Message_ListMessage_Section* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.rows_.InternalSwap(&other->_impl_.rows_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.title_, lhs_arena, + &other->_impl_.title_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_ListMessage_Section::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[104]); +} + +// =================================================================== + +class Message_ListMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_title(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_description(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_buttontext(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_listtype(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static const ::proto::Message_ListMessage_ProductListInfo& productlistinfo(const Message_ListMessage* msg); + static void set_has_productlistinfo(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_footertext(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static const ::proto::ContextInfo& contextinfo(const Message_ListMessage* msg); + static void set_has_contextinfo(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } +}; + +const ::proto::Message_ListMessage_ProductListInfo& +Message_ListMessage::_Internal::productlistinfo(const Message_ListMessage* msg) { + return *msg->_impl_.productlistinfo_; +} +const ::proto::ContextInfo& +Message_ListMessage::_Internal::contextinfo(const Message_ListMessage* msg) { + return *msg->_impl_.contextinfo_; +} +Message_ListMessage::Message_ListMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.ListMessage) +} +Message_ListMessage::Message_ListMessage(const Message_ListMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_ListMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.sections_){from._impl_.sections_} + , decltype(_impl_.title_){} + , decltype(_impl_.description_){} + , decltype(_impl_.buttontext_){} + , decltype(_impl_.footertext_){} + , decltype(_impl_.productlistinfo_){nullptr} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.listtype_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.title_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.title_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_title()) { + _this->_impl_.title_.Set(from._internal_title(), + _this->GetArenaForAllocation()); + } + _impl_.description_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.description_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_description()) { + _this->_impl_.description_.Set(from._internal_description(), + _this->GetArenaForAllocation()); + } + _impl_.buttontext_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.buttontext_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_buttontext()) { + _this->_impl_.buttontext_.Set(from._internal_buttontext(), + _this->GetArenaForAllocation()); + } + _impl_.footertext_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.footertext_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_footertext()) { + _this->_impl_.footertext_.Set(from._internal_footertext(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_productlistinfo()) { + _this->_impl_.productlistinfo_ = new ::proto::Message_ListMessage_ProductListInfo(*from._impl_.productlistinfo_); + } + if (from._internal_has_contextinfo()) { + _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); + } + _this->_impl_.listtype_ = from._impl_.listtype_; + // @@protoc_insertion_point(copy_constructor:proto.Message.ListMessage) +} + +inline void Message_ListMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.sections_){arena} + , decltype(_impl_.title_){} + , decltype(_impl_.description_){} + , decltype(_impl_.buttontext_){} + , decltype(_impl_.footertext_){} + , decltype(_impl_.productlistinfo_){nullptr} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.listtype_){0} + }; + _impl_.title_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.title_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.description_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.description_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.buttontext_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.buttontext_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.footertext_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.footertext_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_ListMessage::~Message_ListMessage() { + // @@protoc_insertion_point(destructor:proto.Message.ListMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_ListMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.sections_.~RepeatedPtrField(); + _impl_.title_.Destroy(); + _impl_.description_.Destroy(); + _impl_.buttontext_.Destroy(); + _impl_.footertext_.Destroy(); + if (this != internal_default_instance()) delete _impl_.productlistinfo_; + if (this != internal_default_instance()) delete _impl_.contextinfo_; +} + +void Message_ListMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_ListMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.ListMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.sections_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + _impl_.title_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.description_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.buttontext_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + _impl_.footertext_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + GOOGLE_DCHECK(_impl_.productlistinfo_ != nullptr); + _impl_.productlistinfo_->Clear(); + } + if (cached_has_bits & 0x00000020u) { + GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); + _impl_.contextinfo_->Clear(); + } + } + _impl_.listtype_ = 0; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_ListMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string title = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_title(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.title"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string description = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_description(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.description"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string buttonText = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_buttontext(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.buttonText"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.Message.ListMessage.ListType listType = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::Message_ListMessage_ListType_IsValid(val))) { + _internal_set_listtype(static_cast<::proto::Message_ListMessage_ListType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // repeated .proto.Message.ListMessage.Section sections = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_sections(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr)); + } else + goto handle_unusual; + continue; + // optional .proto.Message.ListMessage.ProductListInfo productListInfo = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_productlistinfo(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string footerText = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + auto str = _internal_mutable_footertext(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.footerText"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.ContextInfo contextInfo = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_ListMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ListMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string title = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_title().data(), static_cast(this->_internal_title().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ListMessage.title"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_title(), target); + } + + // optional string description = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_description().data(), static_cast(this->_internal_description().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ListMessage.description"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_description(), target); + } + + // optional string buttonText = 3; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_buttontext().data(), static_cast(this->_internal_buttontext().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ListMessage.buttonText"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_buttontext(), target); + } + + // optional .proto.Message.ListMessage.ListType listType = 4; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 4, this->_internal_listtype(), target); + } + + // repeated .proto.Message.ListMessage.Section sections = 5; + for (unsigned i = 0, + n = static_cast(this->_internal_sections_size()); i < n; i++) { + const auto& repfield = this->_internal_sections(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(5, repfield, repfield.GetCachedSize(), target, stream); + } + + // optional .proto.Message.ListMessage.ProductListInfo productListInfo = 6; + if (cached_has_bits & 0x00000010u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(6, _Internal::productlistinfo(this), + _Internal::productlistinfo(this).GetCachedSize(), target, stream); + } + + // optional string footerText = 7; + if (cached_has_bits & 0x00000008u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_footertext().data(), static_cast(this->_internal_footertext().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ListMessage.footerText"); + target = stream->WriteStringMaybeAliased( + 7, this->_internal_footertext(), target); + } + + // optional .proto.ContextInfo contextInfo = 8; + if (cached_has_bits & 0x00000020u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(8, _Internal::contextinfo(this), + _Internal::contextinfo(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ListMessage) + return target; +} + +size_t Message_ListMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.ListMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.Message.ListMessage.Section sections = 5; + total_size += 1UL * this->_internal_sections_size(); + for (const auto& msg : this->_impl_.sections_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + // optional string title = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_title()); + } + + // optional string description = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_description()); + } + + // optional string buttonText = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_buttontext()); + } + + // optional string footerText = 7; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_footertext()); + } + + // optional .proto.Message.ListMessage.ProductListInfo productListInfo = 6; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.productlistinfo_); + } + + // optional .proto.ContextInfo contextInfo = 8; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.contextinfo_); + } + + // optional .proto.Message.ListMessage.ListType listType = 4; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_listtype()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ListMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_ListMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ListMessage::GetClassData() const { return &_class_data_; } + + +void Message_ListMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ListMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.sections_.MergeFrom(from._impl_.sections_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_title(from._internal_title()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_description(from._internal_description()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_buttontext(from._internal_buttontext()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_set_footertext(from._internal_footertext()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_mutable_productlistinfo()->::proto::Message_ListMessage_ProductListInfo::MergeFrom( + from._internal_productlistinfo()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( + from._internal_contextinfo()); + } + if (cached_has_bits & 0x00000040u) { + _this->_impl_.listtype_ = from._impl_.listtype_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_ListMessage::CopyFrom(const Message_ListMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ListMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_ListMessage::IsInitialized() const { + return true; +} + +void Message_ListMessage::InternalSwap(Message_ListMessage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.sections_.InternalSwap(&other->_impl_.sections_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.title_, lhs_arena, + &other->_impl_.title_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.description_, lhs_arena, + &other->_impl_.description_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.buttontext_, lhs_arena, + &other->_impl_.buttontext_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.footertext_, lhs_arena, + &other->_impl_.footertext_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_ListMessage, _impl_.listtype_) + + sizeof(Message_ListMessage::_impl_.listtype_) + - PROTOBUF_FIELD_OFFSET(Message_ListMessage, _impl_.productlistinfo_)>( + reinterpret_cast(&_impl_.productlistinfo_), + reinterpret_cast(&other->_impl_.productlistinfo_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_ListMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[105]); +} + +// =================================================================== + +class Message_ListResponseMessage_SingleSelectReply::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_selectedrowid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +Message_ListResponseMessage_SingleSelectReply::Message_ListResponseMessage_SingleSelectReply(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.ListResponseMessage.SingleSelectReply) +} +Message_ListResponseMessage_SingleSelectReply::Message_ListResponseMessage_SingleSelectReply(const Message_ListResponseMessage_SingleSelectReply& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_ListResponseMessage_SingleSelectReply* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.selectedrowid_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.selectedrowid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.selectedrowid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_selectedrowid()) { + _this->_impl_.selectedrowid_.Set(from._internal_selectedrowid(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.Message.ListResponseMessage.SingleSelectReply) +} + +inline void Message_ListResponseMessage_SingleSelectReply::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.selectedrowid_){} + }; + _impl_.selectedrowid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.selectedrowid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_ListResponseMessage_SingleSelectReply::~Message_ListResponseMessage_SingleSelectReply() { + // @@protoc_insertion_point(destructor:proto.Message.ListResponseMessage.SingleSelectReply) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_ListResponseMessage_SingleSelectReply::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.selectedrowid_.Destroy(); +} + +void Message_ListResponseMessage_SingleSelectReply::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_ListResponseMessage_SingleSelectReply::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.ListResponseMessage.SingleSelectReply) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.selectedrowid_.ClearNonDefaultToEmpty(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_ListResponseMessage_SingleSelectReply::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string selectedRowId = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_selectedrowid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ListResponseMessage.SingleSelectReply.selectedRowId"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_ListResponseMessage_SingleSelectReply::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ListResponseMessage.SingleSelectReply) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string selectedRowId = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_selectedrowid().data(), static_cast(this->_internal_selectedrowid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ListResponseMessage.SingleSelectReply.selectedRowId"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_selectedrowid(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ListResponseMessage.SingleSelectReply) + return target; +} + +size_t Message_ListResponseMessage_SingleSelectReply::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.ListResponseMessage.SingleSelectReply) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional string selectedRowId = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_selectedrowid()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ListResponseMessage_SingleSelectReply::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_ListResponseMessage_SingleSelectReply::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ListResponseMessage_SingleSelectReply::GetClassData() const { return &_class_data_; } + + +void Message_ListResponseMessage_SingleSelectReply::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ListResponseMessage.SingleSelectReply) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_selectedrowid()) { + _this->_internal_set_selectedrowid(from._internal_selectedrowid()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_ListResponseMessage_SingleSelectReply::CopyFrom(const Message_ListResponseMessage_SingleSelectReply& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ListResponseMessage.SingleSelectReply) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_ListResponseMessage_SingleSelectReply::IsInitialized() const { + return true; +} + +void Message_ListResponseMessage_SingleSelectReply::InternalSwap(Message_ListResponseMessage_SingleSelectReply* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.selectedrowid_, lhs_arena, + &other->_impl_.selectedrowid_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_ListResponseMessage_SingleSelectReply::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[106]); +} + +// =================================================================== + +class Message_ListResponseMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_title(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_listtype(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static const ::proto::Message_ListResponseMessage_SingleSelectReply& singleselectreply(const Message_ListResponseMessage* msg); + static void set_has_singleselectreply(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static const ::proto::ContextInfo& contextinfo(const Message_ListResponseMessage* msg); + static void set_has_contextinfo(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_description(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::proto::Message_ListResponseMessage_SingleSelectReply& +Message_ListResponseMessage::_Internal::singleselectreply(const Message_ListResponseMessage* msg) { + return *msg->_impl_.singleselectreply_; +} +const ::proto::ContextInfo& +Message_ListResponseMessage::_Internal::contextinfo(const Message_ListResponseMessage* msg) { + return *msg->_impl_.contextinfo_; +} +Message_ListResponseMessage::Message_ListResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.ListResponseMessage) +} +Message_ListResponseMessage::Message_ListResponseMessage(const Message_ListResponseMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_ListResponseMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.title_){} + , decltype(_impl_.description_){} + , decltype(_impl_.singleselectreply_){nullptr} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.listtype_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.title_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.title_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_title()) { + _this->_impl_.title_.Set(from._internal_title(), + _this->GetArenaForAllocation()); + } + _impl_.description_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.description_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_description()) { + _this->_impl_.description_.Set(from._internal_description(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_singleselectreply()) { + _this->_impl_.singleselectreply_ = new ::proto::Message_ListResponseMessage_SingleSelectReply(*from._impl_.singleselectreply_); + } + if (from._internal_has_contextinfo()) { + _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); + } + _this->_impl_.listtype_ = from._impl_.listtype_; + // @@protoc_insertion_point(copy_constructor:proto.Message.ListResponseMessage) +} + +inline void Message_ListResponseMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.title_){} + , decltype(_impl_.description_){} + , decltype(_impl_.singleselectreply_){nullptr} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.listtype_){0} + }; + _impl_.title_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.title_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.description_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.description_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_ListResponseMessage::~Message_ListResponseMessage() { + // @@protoc_insertion_point(destructor:proto.Message.ListResponseMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_ListResponseMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.title_.Destroy(); + _impl_.description_.Destroy(); + if (this != internal_default_instance()) delete _impl_.singleselectreply_; + if (this != internal_default_instance()) delete _impl_.contextinfo_; +} + +void Message_ListResponseMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_ListResponseMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.ListResponseMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _impl_.title_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.description_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.singleselectreply_ != nullptr); + _impl_.singleselectreply_->Clear(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); + _impl_.contextinfo_->Clear(); + } + } + _impl_.listtype_ = 0; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_ListResponseMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string title = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_title(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ListResponseMessage.title"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.Message.ListResponseMessage.ListType listType = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::Message_ListResponseMessage_ListType_IsValid(val))) { + _internal_set_listtype(static_cast<::proto::Message_ListResponseMessage_ListType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.Message.ListResponseMessage.SingleSelectReply singleSelectReply = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_singleselectreply(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.ContextInfo contextInfo = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string description = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + auto str = _internal_mutable_description(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ListResponseMessage.description"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_ListResponseMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ListResponseMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string title = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_title().data(), static_cast(this->_internal_title().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ListResponseMessage.title"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_title(), target); + } + + // optional .proto.Message.ListResponseMessage.ListType listType = 2; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this->_internal_listtype(), target); + } + + // optional .proto.Message.ListResponseMessage.SingleSelectReply singleSelectReply = 3; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::singleselectreply(this), + _Internal::singleselectreply(this).GetCachedSize(), target, stream); + } + + // optional .proto.ContextInfo contextInfo = 4; + if (cached_has_bits & 0x00000008u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, _Internal::contextinfo(this), + _Internal::contextinfo(this).GetCachedSize(), target, stream); + } + + // optional string description = 5; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_description().data(), static_cast(this->_internal_description().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ListResponseMessage.description"); + target = stream->WriteStringMaybeAliased( + 5, this->_internal_description(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ListResponseMessage) + return target; +} + +size_t Message_ListResponseMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.ListResponseMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + // optional string title = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_title()); + } + + // optional string description = 5; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_description()); + } + + // optional .proto.Message.ListResponseMessage.SingleSelectReply singleSelectReply = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.singleselectreply_); + } + + // optional .proto.ContextInfo contextInfo = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.contextinfo_); + } + + // optional .proto.Message.ListResponseMessage.ListType listType = 2; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_listtype()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ListResponseMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_ListResponseMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ListResponseMessage::GetClassData() const { return &_class_data_; } + + +void Message_ListResponseMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ListResponseMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_title(from._internal_title()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_description(from._internal_description()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_singleselectreply()->::proto::Message_ListResponseMessage_SingleSelectReply::MergeFrom( + from._internal_singleselectreply()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( + from._internal_contextinfo()); + } + if (cached_has_bits & 0x00000010u) { + _this->_impl_.listtype_ = from._impl_.listtype_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_ListResponseMessage::CopyFrom(const Message_ListResponseMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ListResponseMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_ListResponseMessage::IsInitialized() const { + return true; +} + +void Message_ListResponseMessage::InternalSwap(Message_ListResponseMessage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.title_, lhs_arena, + &other->_impl_.title_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.description_, lhs_arena, + &other->_impl_.description_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_ListResponseMessage, _impl_.listtype_) + + sizeof(Message_ListResponseMessage::_impl_.listtype_) + - PROTOBUF_FIELD_OFFSET(Message_ListResponseMessage, _impl_.singleselectreply_)>( + reinterpret_cast(&_impl_.singleselectreply_), + reinterpret_cast(&other->_impl_.singleselectreply_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_ListResponseMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[107]); +} + +// =================================================================== + +class Message_LiveLocationMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_degreeslatitude(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_degreeslongitude(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_accuracyinmeters(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_speedinmps(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_degreesclockwisefrommagneticnorth(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_caption(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_sequencenumber(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_timeoffset(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_jpegthumbnail(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::proto::ContextInfo& contextinfo(const Message_LiveLocationMessage* msg); + static void set_has_contextinfo(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +const ::proto::ContextInfo& +Message_LiveLocationMessage::_Internal::contextinfo(const Message_LiveLocationMessage* msg) { + return *msg->_impl_.contextinfo_; +} +Message_LiveLocationMessage::Message_LiveLocationMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.LiveLocationMessage) +} +Message_LiveLocationMessage::Message_LiveLocationMessage(const Message_LiveLocationMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_LiveLocationMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.caption_){} + , decltype(_impl_.jpegthumbnail_){} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.degreeslatitude_){} + , decltype(_impl_.degreeslongitude_){} + , decltype(_impl_.accuracyinmeters_){} + , decltype(_impl_.speedinmps_){} + , decltype(_impl_.degreesclockwisefrommagneticnorth_){} + , decltype(_impl_.timeoffset_){} + , decltype(_impl_.sequencenumber_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.caption_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.caption_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_caption()) { + _this->_impl_.caption_.Set(from._internal_caption(), + _this->GetArenaForAllocation()); + } + _impl_.jpegthumbnail_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_jpegthumbnail()) { + _this->_impl_.jpegthumbnail_.Set(from._internal_jpegthumbnail(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_contextinfo()) { + _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); + } + ::memcpy(&_impl_.degreeslatitude_, &from._impl_.degreeslatitude_, + static_cast(reinterpret_cast(&_impl_.sequencenumber_) - + reinterpret_cast(&_impl_.degreeslatitude_)) + sizeof(_impl_.sequencenumber_)); + // @@protoc_insertion_point(copy_constructor:proto.Message.LiveLocationMessage) +} + +inline void Message_LiveLocationMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.caption_){} + , decltype(_impl_.jpegthumbnail_){} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.degreeslatitude_){0} + , decltype(_impl_.degreeslongitude_){0} + , decltype(_impl_.accuracyinmeters_){0u} + , decltype(_impl_.speedinmps_){0} + , decltype(_impl_.degreesclockwisefrommagneticnorth_){0u} + , decltype(_impl_.timeoffset_){0u} + , decltype(_impl_.sequencenumber_){int64_t{0}} + }; + _impl_.caption_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.caption_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.jpegthumbnail_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_LiveLocationMessage::~Message_LiveLocationMessage() { + // @@protoc_insertion_point(destructor:proto.Message.LiveLocationMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_LiveLocationMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.caption_.Destroy(); + _impl_.jpegthumbnail_.Destroy(); + if (this != internal_default_instance()) delete _impl_.contextinfo_; +} + +void Message_LiveLocationMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_LiveLocationMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.LiveLocationMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _impl_.caption_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.jpegthumbnail_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); + _impl_.contextinfo_->Clear(); + } + } + if (cached_has_bits & 0x000000f8u) { + ::memset(&_impl_.degreeslatitude_, 0, static_cast( + reinterpret_cast(&_impl_.degreesclockwisefrommagneticnorth_) - + reinterpret_cast(&_impl_.degreeslatitude_)) + sizeof(_impl_.degreesclockwisefrommagneticnorth_)); + } + if (cached_has_bits & 0x00000300u) { + ::memset(&_impl_.timeoffset_, 0, static_cast( + reinterpret_cast(&_impl_.sequencenumber_) - + reinterpret_cast(&_impl_.timeoffset_)) + sizeof(_impl_.sequencenumber_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_LiveLocationMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional double degreesLatitude = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 9)) { + _Internal::set_has_degreeslatitude(&has_bits); + _impl_.degreeslatitude_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(double); + } else + goto handle_unusual; + continue; + // optional double degreesLongitude = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 17)) { + _Internal::set_has_degreeslongitude(&has_bits); + _impl_.degreeslongitude_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(double); + } else + goto handle_unusual; + continue; + // optional uint32 accuracyInMeters = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_accuracyinmeters(&has_bits); + _impl_.accuracyinmeters_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional float speedInMps = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 37)) { + _Internal::set_has_speedinmps(&has_bits); + _impl_.speedinmps_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional uint32 degreesClockwiseFromMagneticNorth = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_degreesclockwisefrommagneticnorth(&has_bits); + _impl_.degreesclockwisefrommagneticnorth_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string caption = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + auto str = _internal_mutable_caption(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.LiveLocationMessage.caption"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional int64 sequenceNumber = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + _Internal::set_has_sequencenumber(&has_bits); + _impl_.sequencenumber_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 timeOffset = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { + _Internal::set_has_timeoffset(&has_bits); + _impl_.timeoffset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes jpegThumbnail = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { + auto str = _internal_mutable_jpegthumbnail(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.ContextInfo contextInfo = 17; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { + ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_LiveLocationMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.LiveLocationMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional double degreesLatitude = 1; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray(1, this->_internal_degreeslatitude(), target); + } + + // optional double degreesLongitude = 2; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray(2, this->_internal_degreeslongitude(), target); + } + + // optional uint32 accuracyInMeters = 3; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_accuracyinmeters(), target); + } + + // optional float speedInMps = 4; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFloatToArray(4, this->_internal_speedinmps(), target); + } + + // optional uint32 degreesClockwiseFromMagneticNorth = 5; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_degreesclockwisefrommagneticnorth(), target); + } + + // optional string caption = 6; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_caption().data(), static_cast(this->_internal_caption().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.LiveLocationMessage.caption"); + target = stream->WriteStringMaybeAliased( + 6, this->_internal_caption(), target); + } + + // optional int64 sequenceNumber = 7; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(7, this->_internal_sequencenumber(), target); + } + + // optional uint32 timeOffset = 8; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(8, this->_internal_timeoffset(), target); + } + + // optional bytes jpegThumbnail = 16; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 16, this->_internal_jpegthumbnail(), target); + } + + // optional .proto.ContextInfo contextInfo = 17; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(17, _Internal::contextinfo(this), + _Internal::contextinfo(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.LiveLocationMessage) + return target; +} + +size_t Message_LiveLocationMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.LiveLocationMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string caption = 6; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_caption()); + } + + // optional bytes jpegThumbnail = 16; + if (cached_has_bits & 0x00000002u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_jpegthumbnail()); + } + + // optional .proto.ContextInfo contextInfo = 17; + if (cached_has_bits & 0x00000004u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.contextinfo_); + } + + // optional double degreesLatitude = 1; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 8; + } + + // optional double degreesLongitude = 2; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + 8; + } + + // optional uint32 accuracyInMeters = 3; + if (cached_has_bits & 0x00000020u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_accuracyinmeters()); + } + + // optional float speedInMps = 4; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + 4; + } + + // optional uint32 degreesClockwiseFromMagneticNorth = 5; + if (cached_has_bits & 0x00000080u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_degreesclockwisefrommagneticnorth()); + } + + } + if (cached_has_bits & 0x00000300u) { + // optional uint32 timeOffset = 8; + if (cached_has_bits & 0x00000100u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_timeoffset()); + } + + // optional int64 sequenceNumber = 7; + if (cached_has_bits & 0x00000200u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_sequencenumber()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_LiveLocationMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_LiveLocationMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_LiveLocationMessage::GetClassData() const { return &_class_data_; } + + +void Message_LiveLocationMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.LiveLocationMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_caption(from._internal_caption()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( + from._internal_contextinfo()); + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.degreeslatitude_ = from._impl_.degreeslatitude_; + } + if (cached_has_bits & 0x00000010u) { + _this->_impl_.degreeslongitude_ = from._impl_.degreeslongitude_; + } + if (cached_has_bits & 0x00000020u) { + _this->_impl_.accuracyinmeters_ = from._impl_.accuracyinmeters_; + } + if (cached_has_bits & 0x00000040u) { + _this->_impl_.speedinmps_ = from._impl_.speedinmps_; + } + if (cached_has_bits & 0x00000080u) { + _this->_impl_.degreesclockwisefrommagneticnorth_ = from._impl_.degreesclockwisefrommagneticnorth_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00000300u) { + if (cached_has_bits & 0x00000100u) { + _this->_impl_.timeoffset_ = from._impl_.timeoffset_; + } + if (cached_has_bits & 0x00000200u) { + _this->_impl_.sequencenumber_ = from._impl_.sequencenumber_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_LiveLocationMessage::CopyFrom(const Message_LiveLocationMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.LiveLocationMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_LiveLocationMessage::IsInitialized() const { + return true; +} + +void Message_LiveLocationMessage::InternalSwap(Message_LiveLocationMessage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.caption_, lhs_arena, + &other->_impl_.caption_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.jpegthumbnail_, lhs_arena, + &other->_impl_.jpegthumbnail_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_LiveLocationMessage, _impl_.sequencenumber_) + + sizeof(Message_LiveLocationMessage::_impl_.sequencenumber_) + - PROTOBUF_FIELD_OFFSET(Message_LiveLocationMessage, _impl_.contextinfo_)>( + reinterpret_cast(&_impl_.contextinfo_), + reinterpret_cast(&other->_impl_.contextinfo_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_LiveLocationMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[108]); +} + +// =================================================================== + +class Message_LocationMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_degreeslatitude(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_degreeslongitude(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_name(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_address(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_url(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_islive(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_accuracyinmeters(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_speedinmps(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static void set_has_degreesclockwisefrommagneticnorth(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static void set_has_comment(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_jpegthumbnail(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static const ::proto::ContextInfo& contextinfo(const Message_LocationMessage* msg); + static void set_has_contextinfo(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } +}; + +const ::proto::ContextInfo& +Message_LocationMessage::_Internal::contextinfo(const Message_LocationMessage* msg) { + return *msg->_impl_.contextinfo_; +} +Message_LocationMessage::Message_LocationMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.LocationMessage) +} +Message_LocationMessage::Message_LocationMessage(const Message_LocationMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_LocationMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.name_){} + , decltype(_impl_.address_){} + , decltype(_impl_.url_){} + , decltype(_impl_.comment_){} + , decltype(_impl_.jpegthumbnail_){} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.degreeslatitude_){} + , decltype(_impl_.degreeslongitude_){} + , decltype(_impl_.islive_){} + , decltype(_impl_.accuracyinmeters_){} + , decltype(_impl_.speedinmps_){} + , decltype(_impl_.degreesclockwisefrommagneticnorth_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.name_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.name_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_name()) { + _this->_impl_.name_.Set(from._internal_name(), + _this->GetArenaForAllocation()); + } + _impl_.address_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.address_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_address()) { + _this->_impl_.address_.Set(from._internal_address(), + _this->GetArenaForAllocation()); + } + _impl_.url_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.url_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_url()) { + _this->_impl_.url_.Set(from._internal_url(), + _this->GetArenaForAllocation()); + } + _impl_.comment_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.comment_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_comment()) { + _this->_impl_.comment_.Set(from._internal_comment(), + _this->GetArenaForAllocation()); + } + _impl_.jpegthumbnail_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_jpegthumbnail()) { + _this->_impl_.jpegthumbnail_.Set(from._internal_jpegthumbnail(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_contextinfo()) { + _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); + } + ::memcpy(&_impl_.degreeslatitude_, &from._impl_.degreeslatitude_, + static_cast(reinterpret_cast(&_impl_.degreesclockwisefrommagneticnorth_) - + reinterpret_cast(&_impl_.degreeslatitude_)) + sizeof(_impl_.degreesclockwisefrommagneticnorth_)); + // @@protoc_insertion_point(copy_constructor:proto.Message.LocationMessage) +} + +inline void Message_LocationMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.name_){} + , decltype(_impl_.address_){} + , decltype(_impl_.url_){} + , decltype(_impl_.comment_){} + , decltype(_impl_.jpegthumbnail_){} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.degreeslatitude_){0} + , decltype(_impl_.degreeslongitude_){0} + , decltype(_impl_.islive_){false} + , decltype(_impl_.accuracyinmeters_){0u} + , decltype(_impl_.speedinmps_){0} + , decltype(_impl_.degreesclockwisefrommagneticnorth_){0u} + }; + _impl_.name_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.name_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.address_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.address_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.url_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.url_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.comment_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.comment_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.jpegthumbnail_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_LocationMessage::~Message_LocationMessage() { + // @@protoc_insertion_point(destructor:proto.Message.LocationMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_LocationMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.name_.Destroy(); + _impl_.address_.Destroy(); + _impl_.url_.Destroy(); + _impl_.comment_.Destroy(); + _impl_.jpegthumbnail_.Destroy(); + if (this != internal_default_instance()) delete _impl_.contextinfo_; +} + +void Message_LocationMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_LocationMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.LocationMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + _impl_.name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.address_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.url_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + _impl_.comment_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + _impl_.jpegthumbnail_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000020u) { + GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); + _impl_.contextinfo_->Clear(); + } + } + if (cached_has_bits & 0x000000c0u) { + ::memset(&_impl_.degreeslatitude_, 0, static_cast( + reinterpret_cast(&_impl_.degreeslongitude_) - + reinterpret_cast(&_impl_.degreeslatitude_)) + sizeof(_impl_.degreeslongitude_)); + } + if (cached_has_bits & 0x00000f00u) { + ::memset(&_impl_.islive_, 0, static_cast( + reinterpret_cast(&_impl_.degreesclockwisefrommagneticnorth_) - + reinterpret_cast(&_impl_.islive_)) + sizeof(_impl_.degreesclockwisefrommagneticnorth_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_LocationMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional double degreesLatitude = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 9)) { + _Internal::set_has_degreeslatitude(&has_bits); + _impl_.degreeslatitude_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(double); + } else + goto handle_unusual; + continue; + // optional double degreesLongitude = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 17)) { + _Internal::set_has_degreeslongitude(&has_bits); + _impl_.degreeslongitude_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(double); + } else + goto handle_unusual; + continue; + // optional string name = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_name(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.LocationMessage.name"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string address = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_address(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.LocationMessage.address"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string url = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + auto str = _internal_mutable_url(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.LocationMessage.url"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bool isLive = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + _Internal::set_has_islive(&has_bits); + _impl_.islive_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 accuracyInMeters = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + _Internal::set_has_accuracyinmeters(&has_bits); + _impl_.accuracyinmeters_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional float speedInMps = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 69)) { + _Internal::set_has_speedinmps(&has_bits); + _impl_.speedinmps_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional uint32 degreesClockwiseFromMagneticNorth = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { + _Internal::set_has_degreesclockwisefrommagneticnorth(&has_bits); + _impl_.degreesclockwisefrommagneticnorth_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string comment = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { + auto str = _internal_mutable_comment(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.LocationMessage.comment"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bytes jpegThumbnail = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { + auto str = _internal_mutable_jpegthumbnail(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.ContextInfo contextInfo = 17; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { + ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_LocationMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.LocationMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional double degreesLatitude = 1; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray(1, this->_internal_degreeslatitude(), target); + } + + // optional double degreesLongitude = 2; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray(2, this->_internal_degreeslongitude(), target); + } + + // optional string name = 3; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.LocationMessage.name"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_name(), target); + } + + // optional string address = 4; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_address().data(), static_cast(this->_internal_address().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.LocationMessage.address"); + target = stream->WriteStringMaybeAliased( + 4, this->_internal_address(), target); + } + + // optional string url = 5; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_url().data(), static_cast(this->_internal_url().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.LocationMessage.url"); + target = stream->WriteStringMaybeAliased( + 5, this->_internal_url(), target); + } + + // optional bool isLive = 6; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(6, this->_internal_islive(), target); + } + + // optional uint32 accuracyInMeters = 7; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(7, this->_internal_accuracyinmeters(), target); + } + + // optional float speedInMps = 8; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFloatToArray(8, this->_internal_speedinmps(), target); + } + + // optional uint32 degreesClockwiseFromMagneticNorth = 9; + if (cached_has_bits & 0x00000800u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(9, this->_internal_degreesclockwisefrommagneticnorth(), target); + } + + // optional string comment = 11; + if (cached_has_bits & 0x00000008u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_comment().data(), static_cast(this->_internal_comment().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.LocationMessage.comment"); + target = stream->WriteStringMaybeAliased( + 11, this->_internal_comment(), target); + } + + // optional bytes jpegThumbnail = 16; + if (cached_has_bits & 0x00000010u) { + target = stream->WriteBytesMaybeAliased( + 16, this->_internal_jpegthumbnail(), target); + } + + // optional .proto.ContextInfo contextInfo = 17; + if (cached_has_bits & 0x00000020u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(17, _Internal::contextinfo(this), + _Internal::contextinfo(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.LocationMessage) + return target; +} + +size_t Message_LocationMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.LocationMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string name = 3; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // optional string address = 4; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_address()); + } + + // optional string url = 5; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_url()); + } + + // optional string comment = 11; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_comment()); + } + + // optional bytes jpegThumbnail = 16; + if (cached_has_bits & 0x00000010u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_jpegthumbnail()); + } + + // optional .proto.ContextInfo contextInfo = 17; + if (cached_has_bits & 0x00000020u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.contextinfo_); + } + + // optional double degreesLatitude = 1; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + 8; + } + + // optional double degreesLongitude = 2; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + 8; + } + + } + if (cached_has_bits & 0x00000f00u) { + // optional bool isLive = 6; + if (cached_has_bits & 0x00000100u) { + total_size += 1 + 1; + } + + // optional uint32 accuracyInMeters = 7; + if (cached_has_bits & 0x00000200u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_accuracyinmeters()); + } + + // optional float speedInMps = 8; + if (cached_has_bits & 0x00000400u) { + total_size += 1 + 4; + } + + // optional uint32 degreesClockwiseFromMagneticNorth = 9; + if (cached_has_bits & 0x00000800u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_degreesclockwisefrommagneticnorth()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_LocationMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_LocationMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_LocationMessage::GetClassData() const { return &_class_data_; } + + +void Message_LocationMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.LocationMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_name(from._internal_name()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_address(from._internal_address()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_url(from._internal_url()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_set_comment(from._internal_comment()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( + from._internal_contextinfo()); + } + if (cached_has_bits & 0x00000040u) { + _this->_impl_.degreeslatitude_ = from._impl_.degreeslatitude_; + } + if (cached_has_bits & 0x00000080u) { + _this->_impl_.degreeslongitude_ = from._impl_.degreeslongitude_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00000f00u) { + if (cached_has_bits & 0x00000100u) { + _this->_impl_.islive_ = from._impl_.islive_; + } + if (cached_has_bits & 0x00000200u) { + _this->_impl_.accuracyinmeters_ = from._impl_.accuracyinmeters_; + } + if (cached_has_bits & 0x00000400u) { + _this->_impl_.speedinmps_ = from._impl_.speedinmps_; + } + if (cached_has_bits & 0x00000800u) { + _this->_impl_.degreesclockwisefrommagneticnorth_ = from._impl_.degreesclockwisefrommagneticnorth_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_LocationMessage::CopyFrom(const Message_LocationMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.LocationMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_LocationMessage::IsInitialized() const { + return true; +} + +void Message_LocationMessage::InternalSwap(Message_LocationMessage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.name_, lhs_arena, + &other->_impl_.name_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.address_, lhs_arena, + &other->_impl_.address_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.url_, lhs_arena, + &other->_impl_.url_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.comment_, lhs_arena, + &other->_impl_.comment_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.jpegthumbnail_, lhs_arena, + &other->_impl_.jpegthumbnail_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_LocationMessage, _impl_.degreesclockwisefrommagneticnorth_) + + sizeof(Message_LocationMessage::_impl_.degreesclockwisefrommagneticnorth_) + - PROTOBUF_FIELD_OFFSET(Message_LocationMessage, _impl_.contextinfo_)>( + reinterpret_cast(&_impl_.contextinfo_), + reinterpret_cast(&other->_impl_.contextinfo_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_LocationMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[109]); +} + +// =================================================================== + +class Message_OrderMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_orderid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_thumbnail(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_itemcount(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_status(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static void set_has_surface(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static void set_has_message(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_ordertitle(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_sellerjid(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_token(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_totalamount1000(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_totalcurrencycode(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static const ::proto::ContextInfo& contextinfo(const Message_OrderMessage* msg); + static void set_has_contextinfo(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } +}; + +const ::proto::ContextInfo& +Message_OrderMessage::_Internal::contextinfo(const Message_OrderMessage* msg) { + return *msg->_impl_.contextinfo_; +} +Message_OrderMessage::Message_OrderMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.OrderMessage) +} +Message_OrderMessage::Message_OrderMessage(const Message_OrderMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_OrderMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.orderid_){} + , decltype(_impl_.thumbnail_){} + , decltype(_impl_.message_){} + , decltype(_impl_.ordertitle_){} + , decltype(_impl_.sellerjid_){} + , decltype(_impl_.token_){} + , decltype(_impl_.totalcurrencycode_){} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.totalamount1000_){} + , decltype(_impl_.itemcount_){} + , decltype(_impl_.status_){} + , decltype(_impl_.surface_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.orderid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.orderid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_orderid()) { + _this->_impl_.orderid_.Set(from._internal_orderid(), + _this->GetArenaForAllocation()); + } + _impl_.thumbnail_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnail_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_thumbnail()) { + _this->_impl_.thumbnail_.Set(from._internal_thumbnail(), + _this->GetArenaForAllocation()); + } + _impl_.message_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.message_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_message()) { + _this->_impl_.message_.Set(from._internal_message(), + _this->GetArenaForAllocation()); + } + _impl_.ordertitle_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.ordertitle_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_ordertitle()) { + _this->_impl_.ordertitle_.Set(from._internal_ordertitle(), + _this->GetArenaForAllocation()); + } + _impl_.sellerjid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.sellerjid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_sellerjid()) { + _this->_impl_.sellerjid_.Set(from._internal_sellerjid(), + _this->GetArenaForAllocation()); + } + _impl_.token_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.token_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_token()) { + _this->_impl_.token_.Set(from._internal_token(), + _this->GetArenaForAllocation()); + } + _impl_.totalcurrencycode_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.totalcurrencycode_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_totalcurrencycode()) { + _this->_impl_.totalcurrencycode_.Set(from._internal_totalcurrencycode(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_contextinfo()) { + _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); + } + ::memcpy(&_impl_.totalamount1000_, &from._impl_.totalamount1000_, + static_cast(reinterpret_cast(&_impl_.surface_) - + reinterpret_cast(&_impl_.totalamount1000_)) + sizeof(_impl_.surface_)); + // @@protoc_insertion_point(copy_constructor:proto.Message.OrderMessage) +} + +inline void Message_OrderMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.orderid_){} + , decltype(_impl_.thumbnail_){} + , decltype(_impl_.message_){} + , decltype(_impl_.ordertitle_){} + , decltype(_impl_.sellerjid_){} + , decltype(_impl_.token_){} + , decltype(_impl_.totalcurrencycode_){} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.totalamount1000_){int64_t{0}} + , decltype(_impl_.itemcount_){0} + , decltype(_impl_.status_){1} + , decltype(_impl_.surface_){1} + }; + _impl_.orderid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.orderid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnail_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnail_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.message_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.message_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.ordertitle_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.ordertitle_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.sellerjid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.sellerjid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.token_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.token_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.totalcurrencycode_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.totalcurrencycode_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_OrderMessage::~Message_OrderMessage() { + // @@protoc_insertion_point(destructor:proto.Message.OrderMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_OrderMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.orderid_.Destroy(); + _impl_.thumbnail_.Destroy(); + _impl_.message_.Destroy(); + _impl_.ordertitle_.Destroy(); + _impl_.sellerjid_.Destroy(); + _impl_.token_.Destroy(); + _impl_.totalcurrencycode_.Destroy(); + if (this != internal_default_instance()) delete _impl_.contextinfo_; +} + +void Message_OrderMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_OrderMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.OrderMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _impl_.orderid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.thumbnail_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.message_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + _impl_.ordertitle_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + _impl_.sellerjid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000020u) { + _impl_.token_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000040u) { + _impl_.totalcurrencycode_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000080u) { + GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); + _impl_.contextinfo_->Clear(); + } + } + if (cached_has_bits & 0x00000f00u) { + ::memset(&_impl_.totalamount1000_, 0, static_cast( + reinterpret_cast(&_impl_.itemcount_) - + reinterpret_cast(&_impl_.totalamount1000_)) + sizeof(_impl_.itemcount_)); + _impl_.status_ = 1; + _impl_.surface_ = 1; + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_OrderMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string orderId = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_orderid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.OrderMessage.orderId"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bytes thumbnail = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_thumbnail(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 itemCount = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_itemcount(&has_bits); + _impl_.itemcount_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.OrderMessage.OrderStatus status = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::Message_OrderMessage_OrderStatus_IsValid(val))) { + _internal_set_status(static_cast<::proto::Message_OrderMessage_OrderStatus>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.Message.OrderMessage.OrderSurface surface = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::Message_OrderMessage_OrderSurface_IsValid(val))) { + _internal_set_surface(static_cast<::proto::Message_OrderMessage_OrderSurface>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional string message = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + auto str = _internal_mutable_message(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.OrderMessage.message"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string orderTitle = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + auto str = _internal_mutable_ordertitle(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.OrderMessage.orderTitle"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string sellerJid = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + auto str = _internal_mutable_sellerjid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.OrderMessage.sellerJid"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string token = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + auto str = _internal_mutable_token(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.OrderMessage.token"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional int64 totalAmount1000 = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { + _Internal::set_has_totalamount1000(&has_bits); + _impl_.totalamount1000_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string totalCurrencyCode = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { + auto str = _internal_mutable_totalcurrencycode(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.OrderMessage.totalCurrencyCode"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.ContextInfo contextInfo = 17; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { + ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_OrderMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.OrderMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string orderId = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_orderid().data(), static_cast(this->_internal_orderid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.OrderMessage.orderId"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_orderid(), target); + } + + // optional bytes thumbnail = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_thumbnail(), target); + } + + // optional int32 itemCount = 3; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_itemcount(), target); + } + + // optional .proto.Message.OrderMessage.OrderStatus status = 4; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 4, this->_internal_status(), target); + } + + // optional .proto.Message.OrderMessage.OrderSurface surface = 5; + if (cached_has_bits & 0x00000800u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 5, this->_internal_surface(), target); + } + + // optional string message = 6; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_message().data(), static_cast(this->_internal_message().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.OrderMessage.message"); + target = stream->WriteStringMaybeAliased( + 6, this->_internal_message(), target); + } + + // optional string orderTitle = 7; + if (cached_has_bits & 0x00000008u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_ordertitle().data(), static_cast(this->_internal_ordertitle().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.OrderMessage.orderTitle"); + target = stream->WriteStringMaybeAliased( + 7, this->_internal_ordertitle(), target); + } + + // optional string sellerJid = 8; + if (cached_has_bits & 0x00000010u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_sellerjid().data(), static_cast(this->_internal_sellerjid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.OrderMessage.sellerJid"); + target = stream->WriteStringMaybeAliased( + 8, this->_internal_sellerjid(), target); + } + + // optional string token = 9; + if (cached_has_bits & 0x00000020u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_token().data(), static_cast(this->_internal_token().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.OrderMessage.token"); + target = stream->WriteStringMaybeAliased( + 9, this->_internal_token(), target); + } + + // optional int64 totalAmount1000 = 10; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(10, this->_internal_totalamount1000(), target); + } + + // optional string totalCurrencyCode = 11; + if (cached_has_bits & 0x00000040u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_totalcurrencycode().data(), static_cast(this->_internal_totalcurrencycode().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.OrderMessage.totalCurrencyCode"); + target = stream->WriteStringMaybeAliased( + 11, this->_internal_totalcurrencycode(), target); + } + + // optional .proto.ContextInfo contextInfo = 17; + if (cached_has_bits & 0x00000080u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(17, _Internal::contextinfo(this), + _Internal::contextinfo(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.OrderMessage) + return target; +} + +size_t Message_OrderMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.OrderMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string orderId = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_orderid()); + } + + // optional bytes thumbnail = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_thumbnail()); + } + + // optional string message = 6; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_message()); + } + + // optional string orderTitle = 7; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_ordertitle()); + } + + // optional string sellerJid = 8; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_sellerjid()); + } + + // optional string token = 9; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_token()); + } + + // optional string totalCurrencyCode = 11; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_totalcurrencycode()); + } + + // optional .proto.ContextInfo contextInfo = 17; + if (cached_has_bits & 0x00000080u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.contextinfo_); + } + + } + if (cached_has_bits & 0x00000f00u) { + // optional int64 totalAmount1000 = 10; + if (cached_has_bits & 0x00000100u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_totalamount1000()); + } + + // optional int32 itemCount = 3; + if (cached_has_bits & 0x00000200u) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_itemcount()); + } + + // optional .proto.Message.OrderMessage.OrderStatus status = 4; + if (cached_has_bits & 0x00000400u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_status()); + } + + // optional .proto.Message.OrderMessage.OrderSurface surface = 5; + if (cached_has_bits & 0x00000800u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_surface()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_OrderMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_OrderMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_OrderMessage::GetClassData() const { return &_class_data_; } + + +void Message_OrderMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.OrderMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_orderid(from._internal_orderid()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_thumbnail(from._internal_thumbnail()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_message(from._internal_message()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_set_ordertitle(from._internal_ordertitle()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_set_sellerjid(from._internal_sellerjid()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_set_token(from._internal_token()); + } + if (cached_has_bits & 0x00000040u) { + _this->_internal_set_totalcurrencycode(from._internal_totalcurrencycode()); + } + if (cached_has_bits & 0x00000080u) { + _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( + from._internal_contextinfo()); + } + } + if (cached_has_bits & 0x00000f00u) { + if (cached_has_bits & 0x00000100u) { + _this->_impl_.totalamount1000_ = from._impl_.totalamount1000_; + } + if (cached_has_bits & 0x00000200u) { + _this->_impl_.itemcount_ = from._impl_.itemcount_; + } + if (cached_has_bits & 0x00000400u) { + _this->_impl_.status_ = from._impl_.status_; + } + if (cached_has_bits & 0x00000800u) { + _this->_impl_.surface_ = from._impl_.surface_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_OrderMessage::CopyFrom(const Message_OrderMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.OrderMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_OrderMessage::IsInitialized() const { + return true; +} + +void Message_OrderMessage::InternalSwap(Message_OrderMessage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.orderid_, lhs_arena, + &other->_impl_.orderid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.thumbnail_, lhs_arena, + &other->_impl_.thumbnail_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.message_, lhs_arena, + &other->_impl_.message_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.ordertitle_, lhs_arena, + &other->_impl_.ordertitle_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.sellerjid_, lhs_arena, + &other->_impl_.sellerjid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.token_, lhs_arena, + &other->_impl_.token_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.totalcurrencycode_, lhs_arena, + &other->_impl_.totalcurrencycode_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_OrderMessage, _impl_.itemcount_) + + sizeof(Message_OrderMessage::_impl_.itemcount_) + - PROTOBUF_FIELD_OFFSET(Message_OrderMessage, _impl_.contextinfo_)>( + reinterpret_cast(&_impl_.contextinfo_), + reinterpret_cast(&other->_impl_.contextinfo_)); + swap(_impl_.status_, other->_impl_.status_); + swap(_impl_.surface_, other->_impl_.surface_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_OrderMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[110]); +} + +// =================================================================== + +class Message_PaymentInviteMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_servicetype(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_expirytimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +Message_PaymentInviteMessage::Message_PaymentInviteMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.PaymentInviteMessage) +} +Message_PaymentInviteMessage::Message_PaymentInviteMessage(const Message_PaymentInviteMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_PaymentInviteMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.expirytimestamp_){} + , decltype(_impl_.servicetype_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&_impl_.expirytimestamp_, &from._impl_.expirytimestamp_, + static_cast(reinterpret_cast(&_impl_.servicetype_) - + reinterpret_cast(&_impl_.expirytimestamp_)) + sizeof(_impl_.servicetype_)); + // @@protoc_insertion_point(copy_constructor:proto.Message.PaymentInviteMessage) +} + +inline void Message_PaymentInviteMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.expirytimestamp_){int64_t{0}} + , decltype(_impl_.servicetype_){0} + }; +} + +Message_PaymentInviteMessage::~Message_PaymentInviteMessage() { + // @@protoc_insertion_point(destructor:proto.Message.PaymentInviteMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_PaymentInviteMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void Message_PaymentInviteMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_PaymentInviteMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.PaymentInviteMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + ::memset(&_impl_.expirytimestamp_, 0, static_cast( + reinterpret_cast(&_impl_.servicetype_) - + reinterpret_cast(&_impl_.expirytimestamp_)) + sizeof(_impl_.servicetype_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_PaymentInviteMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.Message.PaymentInviteMessage.ServiceType serviceType = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::Message_PaymentInviteMessage_ServiceType_IsValid(val))) { + _internal_set_servicetype(static_cast<::proto::Message_PaymentInviteMessage_ServiceType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional int64 expiryTimestamp = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_expirytimestamp(&has_bits); + _impl_.expirytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_PaymentInviteMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.PaymentInviteMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.Message.PaymentInviteMessage.ServiceType serviceType = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this->_internal_servicetype(), target); + } + + // optional int64 expiryTimestamp = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_expirytimestamp(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.PaymentInviteMessage) + return target; +} + +size_t Message_PaymentInviteMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.PaymentInviteMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional int64 expiryTimestamp = 2; + if (cached_has_bits & 0x00000001u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_expirytimestamp()); + } + + // optional .proto.Message.PaymentInviteMessage.ServiceType serviceType = 1; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_servicetype()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_PaymentInviteMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_PaymentInviteMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_PaymentInviteMessage::GetClassData() const { return &_class_data_; } + + +void Message_PaymentInviteMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.PaymentInviteMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_impl_.expirytimestamp_ = from._impl_.expirytimestamp_; + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.servicetype_ = from._impl_.servicetype_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_PaymentInviteMessage::CopyFrom(const Message_PaymentInviteMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.PaymentInviteMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_PaymentInviteMessage::IsInitialized() const { + return true; +} + +void Message_PaymentInviteMessage::InternalSwap(Message_PaymentInviteMessage* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_PaymentInviteMessage, _impl_.servicetype_) + + sizeof(Message_PaymentInviteMessage::_impl_.servicetype_) + - PROTOBUF_FIELD_OFFSET(Message_PaymentInviteMessage, _impl_.expirytimestamp_)>( + reinterpret_cast(&_impl_.expirytimestamp_), + reinterpret_cast(&other->_impl_.expirytimestamp_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_PaymentInviteMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[111]); +} + +// =================================================================== + +class Message_PollCreationMessage_Option::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_optionname(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +Message_PollCreationMessage_Option::Message_PollCreationMessage_Option(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.PollCreationMessage.Option) +} +Message_PollCreationMessage_Option::Message_PollCreationMessage_Option(const Message_PollCreationMessage_Option& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_PollCreationMessage_Option* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.optionname_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.optionname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.optionname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_optionname()) { + _this->_impl_.optionname_.Set(from._internal_optionname(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.Message.PollCreationMessage.Option) +} + +inline void Message_PollCreationMessage_Option::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.optionname_){} + }; + _impl_.optionname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.optionname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_PollCreationMessage_Option::~Message_PollCreationMessage_Option() { + // @@protoc_insertion_point(destructor:proto.Message.PollCreationMessage.Option) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_PollCreationMessage_Option::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.optionname_.Destroy(); +} + +void Message_PollCreationMessage_Option::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_PollCreationMessage_Option::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.PollCreationMessage.Option) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.optionname_.ClearNonDefaultToEmpty(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_PollCreationMessage_Option::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string optionName = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_optionname(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.PollCreationMessage.Option.optionName"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_PollCreationMessage_Option::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.PollCreationMessage.Option) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string optionName = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_optionname().data(), static_cast(this->_internal_optionname().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.PollCreationMessage.Option.optionName"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_optionname(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.PollCreationMessage.Option) + return target; +} + +size_t Message_PollCreationMessage_Option::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.PollCreationMessage.Option) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional string optionName = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_optionname()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_PollCreationMessage_Option::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_PollCreationMessage_Option::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_PollCreationMessage_Option::GetClassData() const { return &_class_data_; } + + +void Message_PollCreationMessage_Option::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.PollCreationMessage.Option) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_optionname()) { + _this->_internal_set_optionname(from._internal_optionname()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_PollCreationMessage_Option::CopyFrom(const Message_PollCreationMessage_Option& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.PollCreationMessage.Option) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_PollCreationMessage_Option::IsInitialized() const { + return true; +} + +void Message_PollCreationMessage_Option::InternalSwap(Message_PollCreationMessage_Option* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.optionname_, lhs_arena, + &other->_impl_.optionname_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_PollCreationMessage_Option::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[112]); +} + +// =================================================================== + +class Message_PollCreationMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_enckey(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_name(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_selectableoptionscount(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static const ::proto::ContextInfo& contextinfo(const Message_PollCreationMessage* msg); + static void set_has_contextinfo(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +const ::proto::ContextInfo& +Message_PollCreationMessage::_Internal::contextinfo(const Message_PollCreationMessage* msg) { + return *msg->_impl_.contextinfo_; +} +Message_PollCreationMessage::Message_PollCreationMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.PollCreationMessage) +} +Message_PollCreationMessage::Message_PollCreationMessage(const Message_PollCreationMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_PollCreationMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.options_){from._impl_.options_} + , decltype(_impl_.enckey_){} + , decltype(_impl_.name_){} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.selectableoptionscount_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.enckey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.enckey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_enckey()) { + _this->_impl_.enckey_.Set(from._internal_enckey(), + _this->GetArenaForAllocation()); + } + _impl_.name_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.name_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_name()) { + _this->_impl_.name_.Set(from._internal_name(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_contextinfo()) { + _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); + } + _this->_impl_.selectableoptionscount_ = from._impl_.selectableoptionscount_; + // @@protoc_insertion_point(copy_constructor:proto.Message.PollCreationMessage) +} + +inline void Message_PollCreationMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.options_){arena} + , decltype(_impl_.enckey_){} + , decltype(_impl_.name_){} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.selectableoptionscount_){0u} + }; + _impl_.enckey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.enckey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.name_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.name_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_PollCreationMessage::~Message_PollCreationMessage() { + // @@protoc_insertion_point(destructor:proto.Message.PollCreationMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_PollCreationMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.options_.~RepeatedPtrField(); + _impl_.enckey_.Destroy(); + _impl_.name_.Destroy(); + if (this != internal_default_instance()) delete _impl_.contextinfo_; +} + +void Message_PollCreationMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_PollCreationMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.PollCreationMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.options_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _impl_.enckey_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); + _impl_.contextinfo_->Clear(); + } + } + _impl_.selectableoptionscount_ = 0u; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_PollCreationMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes encKey = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_enckey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string name = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_name(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.PollCreationMessage.name"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // repeated .proto.Message.PollCreationMessage.Option options = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_options(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else + goto handle_unusual; + continue; + // optional uint32 selectableOptionsCount = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_selectableoptionscount(&has_bits); + _impl_.selectableoptionscount_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.ContextInfo contextInfo = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_PollCreationMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.PollCreationMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes encKey = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_enckey(), target); + } + + // optional string name = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.PollCreationMessage.name"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_name(), target); + } + + // repeated .proto.Message.PollCreationMessage.Option options = 3; + for (unsigned i = 0, + n = static_cast(this->_internal_options_size()); i < n; i++) { + const auto& repfield = this->_internal_options(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream); + } + + // optional uint32 selectableOptionsCount = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_selectableoptionscount(), target); + } + + // optional .proto.ContextInfo contextInfo = 5; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(5, _Internal::contextinfo(this), + _Internal::contextinfo(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.PollCreationMessage) + return target; +} + +size_t Message_PollCreationMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.PollCreationMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.Message.PollCreationMessage.Option options = 3; + total_size += 1UL * this->_internal_options_size(); + for (const auto& msg : this->_impl_.options_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional bytes encKey = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_enckey()); + } + + // optional string name = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // optional .proto.ContextInfo contextInfo = 5; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.contextinfo_); + } + + // optional uint32 selectableOptionsCount = 4; + if (cached_has_bits & 0x00000008u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_selectableoptionscount()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_PollCreationMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_PollCreationMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_PollCreationMessage::GetClassData() const { return &_class_data_; } + + +void Message_PollCreationMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.PollCreationMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.options_.MergeFrom(from._impl_.options_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_enckey(from._internal_enckey()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_name(from._internal_name()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( + from._internal_contextinfo()); + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.selectableoptionscount_ = from._impl_.selectableoptionscount_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_PollCreationMessage::CopyFrom(const Message_PollCreationMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.PollCreationMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_PollCreationMessage::IsInitialized() const { + return true; +} + +void Message_PollCreationMessage::InternalSwap(Message_PollCreationMessage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.options_.InternalSwap(&other->_impl_.options_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.enckey_, lhs_arena, + &other->_impl_.enckey_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.name_, lhs_arena, + &other->_impl_.name_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_PollCreationMessage, _impl_.selectableoptionscount_) + + sizeof(Message_PollCreationMessage::_impl_.selectableoptionscount_) + - PROTOBUF_FIELD_OFFSET(Message_PollCreationMessage, _impl_.contextinfo_)>( + reinterpret_cast(&_impl_.contextinfo_), + reinterpret_cast(&other->_impl_.contextinfo_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_PollCreationMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[113]); +} + +// =================================================================== + +class Message_PollEncValue::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_encpayload(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_enciv(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +Message_PollEncValue::Message_PollEncValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.PollEncValue) +} +Message_PollEncValue::Message_PollEncValue(const Message_PollEncValue& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_PollEncValue* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.encpayload_){} + , decltype(_impl_.enciv_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.encpayload_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.encpayload_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_encpayload()) { + _this->_impl_.encpayload_.Set(from._internal_encpayload(), + _this->GetArenaForAllocation()); + } + _impl_.enciv_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.enciv_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_enciv()) { + _this->_impl_.enciv_.Set(from._internal_enciv(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.Message.PollEncValue) +} + +inline void Message_PollEncValue::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.encpayload_){} + , decltype(_impl_.enciv_){} + }; + _impl_.encpayload_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.encpayload_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.enciv_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.enciv_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_PollEncValue::~Message_PollEncValue() { + // @@protoc_insertion_point(destructor:proto.Message.PollEncValue) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_PollEncValue::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.encpayload_.Destroy(); + _impl_.enciv_.Destroy(); +} + +void Message_PollEncValue::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_PollEncValue::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.PollEncValue) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.encpayload_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.enciv_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_PollEncValue::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes encPayload = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_encpayload(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes encIv = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_enciv(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_PollEncValue::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.PollEncValue) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes encPayload = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_encpayload(), target); + } + + // optional bytes encIv = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_enciv(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.PollEncValue) + return target; +} + +size_t Message_PollEncValue::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.PollEncValue) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional bytes encPayload = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_encpayload()); + } + + // optional bytes encIv = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_enciv()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_PollEncValue::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_PollEncValue::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_PollEncValue::GetClassData() const { return &_class_data_; } + + +void Message_PollEncValue::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.PollEncValue) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_encpayload(from._internal_encpayload()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_enciv(from._internal_enciv()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_PollEncValue::CopyFrom(const Message_PollEncValue& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.PollEncValue) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_PollEncValue::IsInitialized() const { + return true; +} + +void Message_PollEncValue::InternalSwap(Message_PollEncValue* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.encpayload_, lhs_arena, + &other->_impl_.encpayload_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.enciv_, lhs_arena, + &other->_impl_.enciv_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_PollEncValue::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[114]); +} + +// =================================================================== + +class Message_PollUpdateMessageMetadata::_Internal { + public: +}; + +Message_PollUpdateMessageMetadata::Message_PollUpdateMessageMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) { + // @@protoc_insertion_point(arena_constructor:proto.Message.PollUpdateMessageMetadata) +} +Message_PollUpdateMessageMetadata::Message_PollUpdateMessageMetadata(const Message_PollUpdateMessageMetadata& from) + : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() { + Message_PollUpdateMessageMetadata* const _this = this; (void)_this; + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:proto.Message.PollUpdateMessageMetadata) +} + + + + + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_PollUpdateMessageMetadata::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl, + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl, +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_PollUpdateMessageMetadata::GetClassData() const { return &_class_data_; } + + + + + + + +::PROTOBUF_NAMESPACE_ID::Metadata Message_PollUpdateMessageMetadata::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[115]); +} + +// =================================================================== + +class Message_PollUpdateMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::MessageKey& pollcreationmessagekey(const Message_PollUpdateMessage* msg); + static void set_has_pollcreationmessagekey(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::proto::Message_PollEncValue& vote(const Message_PollUpdateMessage* msg); + static void set_has_vote(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::proto::Message_PollUpdateMessageMetadata& metadata(const Message_PollUpdateMessage* msg); + static void set_has_metadata(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_sendertimestampms(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +const ::proto::MessageKey& +Message_PollUpdateMessage::_Internal::pollcreationmessagekey(const Message_PollUpdateMessage* msg) { + return *msg->_impl_.pollcreationmessagekey_; +} +const ::proto::Message_PollEncValue& +Message_PollUpdateMessage::_Internal::vote(const Message_PollUpdateMessage* msg) { + return *msg->_impl_.vote_; +} +const ::proto::Message_PollUpdateMessageMetadata& +Message_PollUpdateMessage::_Internal::metadata(const Message_PollUpdateMessage* msg) { + return *msg->_impl_.metadata_; +} +Message_PollUpdateMessage::Message_PollUpdateMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.PollUpdateMessage) +} +Message_PollUpdateMessage::Message_PollUpdateMessage(const Message_PollUpdateMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_PollUpdateMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.pollcreationmessagekey_){nullptr} + , decltype(_impl_.vote_){nullptr} + , decltype(_impl_.metadata_){nullptr} + , decltype(_impl_.sendertimestampms_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_pollcreationmessagekey()) { + _this->_impl_.pollcreationmessagekey_ = new ::proto::MessageKey(*from._impl_.pollcreationmessagekey_); + } + if (from._internal_has_vote()) { + _this->_impl_.vote_ = new ::proto::Message_PollEncValue(*from._impl_.vote_); + } + if (from._internal_has_metadata()) { + _this->_impl_.metadata_ = new ::proto::Message_PollUpdateMessageMetadata(*from._impl_.metadata_); + } + _this->_impl_.sendertimestampms_ = from._impl_.sendertimestampms_; + // @@protoc_insertion_point(copy_constructor:proto.Message.PollUpdateMessage) +} + +inline void Message_PollUpdateMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.pollcreationmessagekey_){nullptr} + , decltype(_impl_.vote_){nullptr} + , decltype(_impl_.metadata_){nullptr} + , decltype(_impl_.sendertimestampms_){int64_t{0}} + }; +} + +Message_PollUpdateMessage::~Message_PollUpdateMessage() { + // @@protoc_insertion_point(destructor:proto.Message.PollUpdateMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_PollUpdateMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.pollcreationmessagekey_; + if (this != internal_default_instance()) delete _impl_.vote_; + if (this != internal_default_instance()) delete _impl_.metadata_; +} + +void Message_PollUpdateMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_PollUpdateMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.PollUpdateMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.pollcreationmessagekey_ != nullptr); + _impl_.pollcreationmessagekey_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.vote_ != nullptr); + _impl_.vote_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.metadata_ != nullptr); + _impl_.metadata_->Clear(); + } + } + _impl_.sendertimestampms_ = int64_t{0}; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_PollUpdateMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.MessageKey pollCreationMessageKey = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_pollcreationmessagekey(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.PollEncValue vote = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_vote(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.PollUpdateMessageMetadata metadata = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_metadata(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 senderTimestampMs = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_sendertimestampms(&has_bits); + _impl_.sendertimestampms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_PollUpdateMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.PollUpdateMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.MessageKey pollCreationMessageKey = 1; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::pollcreationmessagekey(this), + _Internal::pollcreationmessagekey(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.PollEncValue vote = 2; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::vote(this), + _Internal::vote(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.PollUpdateMessageMetadata metadata = 3; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::metadata(this), + _Internal::metadata(this).GetCachedSize(), target, stream); + } + + // optional int64 senderTimestampMs = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_sendertimestampms(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.PollUpdateMessage) + return target; +} + +size_t Message_PollUpdateMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.PollUpdateMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional .proto.MessageKey pollCreationMessageKey = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.pollcreationmessagekey_); + } + + // optional .proto.Message.PollEncValue vote = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.vote_); + } + + // optional .proto.Message.PollUpdateMessageMetadata metadata = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.metadata_); + } + + // optional int64 senderTimestampMs = 4; + if (cached_has_bits & 0x00000008u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_sendertimestampms()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_PollUpdateMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_PollUpdateMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_PollUpdateMessage::GetClassData() const { return &_class_data_; } + + +void Message_PollUpdateMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.PollUpdateMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_pollcreationmessagekey()->::proto::MessageKey::MergeFrom( + from._internal_pollcreationmessagekey()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_vote()->::proto::Message_PollEncValue::MergeFrom( + from._internal_vote()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_metadata()->::proto::Message_PollUpdateMessageMetadata::MergeFrom( + from._internal_metadata()); + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.sendertimestampms_ = from._impl_.sendertimestampms_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_PollUpdateMessage::CopyFrom(const Message_PollUpdateMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.PollUpdateMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_PollUpdateMessage::IsInitialized() const { + return true; +} + +void Message_PollUpdateMessage::InternalSwap(Message_PollUpdateMessage* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_PollUpdateMessage, _impl_.sendertimestampms_) + + sizeof(Message_PollUpdateMessage::_impl_.sendertimestampms_) + - PROTOBUF_FIELD_OFFSET(Message_PollUpdateMessage, _impl_.pollcreationmessagekey_)>( + reinterpret_cast(&_impl_.pollcreationmessagekey_), + reinterpret_cast(&other->_impl_.pollcreationmessagekey_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_PollUpdateMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[116]); +} + +// =================================================================== + +class Message_PollVoteMessage::_Internal { + public: +}; + +Message_PollVoteMessage::Message_PollVoteMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.PollVoteMessage) +} +Message_PollVoteMessage::Message_PollVoteMessage(const Message_PollVoteMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_PollVoteMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.selectedoptions_){from._impl_.selectedoptions_} + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:proto.Message.PollVoteMessage) +} + +inline void Message_PollVoteMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_.selectedoptions_){arena} + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +Message_PollVoteMessage::~Message_PollVoteMessage() { + // @@protoc_insertion_point(destructor:proto.Message.PollVoteMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_PollVoteMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.selectedoptions_.~RepeatedPtrField(); +} + +void Message_PollVoteMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_PollVoteMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.PollVoteMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.selectedoptions_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_PollVoteMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated bytes selectedOptions = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_selectedoptions(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_PollVoteMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.PollVoteMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated bytes selectedOptions = 1; + for (int i = 0, n = this->_internal_selectedoptions_size(); i < n; i++) { + const auto& s = this->_internal_selectedoptions(i); + target = stream->WriteBytes(1, s, target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.PollVoteMessage) + return target; +} + +size_t Message_PollVoteMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.PollVoteMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated bytes selectedOptions = 1; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.selectedoptions_.size()); + for (int i = 0, n = _impl_.selectedoptions_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + _impl_.selectedoptions_.Get(i)); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_PollVoteMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_PollVoteMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_PollVoteMessage::GetClassData() const { return &_class_data_; } + + +void Message_PollVoteMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.PollVoteMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.selectedoptions_.MergeFrom(from._impl_.selectedoptions_); + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_PollVoteMessage::CopyFrom(const Message_PollVoteMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.PollVoteMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_PollVoteMessage::IsInitialized() const { + return true; +} + +void Message_PollVoteMessage::InternalSwap(Message_PollVoteMessage* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.selectedoptions_.InternalSwap(&other->_impl_.selectedoptions_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_PollVoteMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[117]); +} + +// =================================================================== + +class Message_ProductMessage_CatalogSnapshot::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::Message_ImageMessage& catalogimage(const Message_ProductMessage_CatalogSnapshot* msg); + static void set_has_catalogimage(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_title(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_description(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::proto::Message_ImageMessage& +Message_ProductMessage_CatalogSnapshot::_Internal::catalogimage(const Message_ProductMessage_CatalogSnapshot* msg) { + return *msg->_impl_.catalogimage_; +} +Message_ProductMessage_CatalogSnapshot::Message_ProductMessage_CatalogSnapshot(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.ProductMessage.CatalogSnapshot) +} +Message_ProductMessage_CatalogSnapshot::Message_ProductMessage_CatalogSnapshot(const Message_ProductMessage_CatalogSnapshot& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_ProductMessage_CatalogSnapshot* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.title_){} + , decltype(_impl_.description_){} + , decltype(_impl_.catalogimage_){nullptr}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.title_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.title_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_title()) { + _this->_impl_.title_.Set(from._internal_title(), + _this->GetArenaForAllocation()); + } + _impl_.description_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.description_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_description()) { + _this->_impl_.description_.Set(from._internal_description(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_catalogimage()) { + _this->_impl_.catalogimage_ = new ::proto::Message_ImageMessage(*from._impl_.catalogimage_); + } + // @@protoc_insertion_point(copy_constructor:proto.Message.ProductMessage.CatalogSnapshot) +} + +inline void Message_ProductMessage_CatalogSnapshot::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.title_){} + , decltype(_impl_.description_){} + , decltype(_impl_.catalogimage_){nullptr} + }; + _impl_.title_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.title_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.description_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.description_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_ProductMessage_CatalogSnapshot::~Message_ProductMessage_CatalogSnapshot() { + // @@protoc_insertion_point(destructor:proto.Message.ProductMessage.CatalogSnapshot) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_ProductMessage_CatalogSnapshot::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.title_.Destroy(); + _impl_.description_.Destroy(); + if (this != internal_default_instance()) delete _impl_.catalogimage_; +} + +void Message_ProductMessage_CatalogSnapshot::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_ProductMessage_CatalogSnapshot::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.ProductMessage.CatalogSnapshot) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _impl_.title_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.description_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.catalogimage_ != nullptr); + _impl_.catalogimage_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_ProductMessage_CatalogSnapshot::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.Message.ImageMessage catalogImage = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_catalogimage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string title = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_title(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.CatalogSnapshot.title"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string description = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_description(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.CatalogSnapshot.description"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_ProductMessage_CatalogSnapshot::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ProductMessage.CatalogSnapshot) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.Message.ImageMessage catalogImage = 1; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::catalogimage(this), + _Internal::catalogimage(this).GetCachedSize(), target, stream); + } + + // optional string title = 2; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_title().data(), static_cast(this->_internal_title().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ProductMessage.CatalogSnapshot.title"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_title(), target); + } + + // optional string description = 3; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_description().data(), static_cast(this->_internal_description().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ProductMessage.CatalogSnapshot.description"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_description(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ProductMessage.CatalogSnapshot) + return target; +} + +size_t Message_ProductMessage_CatalogSnapshot::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.ProductMessage.CatalogSnapshot) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional string title = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_title()); + } + + // optional string description = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_description()); + } + + // optional .proto.Message.ImageMessage catalogImage = 1; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.catalogimage_); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ProductMessage_CatalogSnapshot::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_ProductMessage_CatalogSnapshot::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ProductMessage_CatalogSnapshot::GetClassData() const { return &_class_data_; } + + +void Message_ProductMessage_CatalogSnapshot::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ProductMessage.CatalogSnapshot) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_title(from._internal_title()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_description(from._internal_description()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_catalogimage()->::proto::Message_ImageMessage::MergeFrom( + from._internal_catalogimage()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_ProductMessage_CatalogSnapshot::CopyFrom(const Message_ProductMessage_CatalogSnapshot& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ProductMessage.CatalogSnapshot) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_ProductMessage_CatalogSnapshot::IsInitialized() const { + return true; +} + +void Message_ProductMessage_CatalogSnapshot::InternalSwap(Message_ProductMessage_CatalogSnapshot* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.title_, lhs_arena, + &other->_impl_.title_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.description_, lhs_arena, + &other->_impl_.description_, rhs_arena + ); + swap(_impl_.catalogimage_, other->_impl_.catalogimage_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_ProductMessage_CatalogSnapshot::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[118]); +} + +// =================================================================== + +class Message_ProductMessage_ProductSnapshot::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::Message_ImageMessage& productimage(const Message_ProductMessage_ProductSnapshot* msg); + static void set_has_productimage(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_productid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_title(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_description(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_currencycode(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_priceamount1000(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_retailerid(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_url(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_productimagecount(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static void set_has_firstimageid(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_salepriceamount1000(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } +}; + +const ::proto::Message_ImageMessage& +Message_ProductMessage_ProductSnapshot::_Internal::productimage(const Message_ProductMessage_ProductSnapshot* msg) { + return *msg->_impl_.productimage_; +} +Message_ProductMessage_ProductSnapshot::Message_ProductMessage_ProductSnapshot(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.ProductMessage.ProductSnapshot) +} +Message_ProductMessage_ProductSnapshot::Message_ProductMessage_ProductSnapshot(const Message_ProductMessage_ProductSnapshot& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_ProductMessage_ProductSnapshot* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.productid_){} + , decltype(_impl_.title_){} + , decltype(_impl_.description_){} + , decltype(_impl_.currencycode_){} + , decltype(_impl_.retailerid_){} + , decltype(_impl_.url_){} + , decltype(_impl_.firstimageid_){} + , decltype(_impl_.productimage_){nullptr} + , decltype(_impl_.priceamount1000_){} + , decltype(_impl_.salepriceamount1000_){} + , decltype(_impl_.productimagecount_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.productid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.productid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_productid()) { + _this->_impl_.productid_.Set(from._internal_productid(), + _this->GetArenaForAllocation()); + } + _impl_.title_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.title_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_title()) { + _this->_impl_.title_.Set(from._internal_title(), + _this->GetArenaForAllocation()); + } + _impl_.description_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.description_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_description()) { + _this->_impl_.description_.Set(from._internal_description(), + _this->GetArenaForAllocation()); + } + _impl_.currencycode_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.currencycode_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_currencycode()) { + _this->_impl_.currencycode_.Set(from._internal_currencycode(), + _this->GetArenaForAllocation()); + } + _impl_.retailerid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.retailerid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_retailerid()) { + _this->_impl_.retailerid_.Set(from._internal_retailerid(), + _this->GetArenaForAllocation()); + } + _impl_.url_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.url_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_url()) { + _this->_impl_.url_.Set(from._internal_url(), + _this->GetArenaForAllocation()); + } + _impl_.firstimageid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.firstimageid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_firstimageid()) { + _this->_impl_.firstimageid_.Set(from._internal_firstimageid(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_productimage()) { + _this->_impl_.productimage_ = new ::proto::Message_ImageMessage(*from._impl_.productimage_); + } + ::memcpy(&_impl_.priceamount1000_, &from._impl_.priceamount1000_, + static_cast(reinterpret_cast(&_impl_.productimagecount_) - + reinterpret_cast(&_impl_.priceamount1000_)) + sizeof(_impl_.productimagecount_)); + // @@protoc_insertion_point(copy_constructor:proto.Message.ProductMessage.ProductSnapshot) +} + +inline void Message_ProductMessage_ProductSnapshot::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.productid_){} + , decltype(_impl_.title_){} + , decltype(_impl_.description_){} + , decltype(_impl_.currencycode_){} + , decltype(_impl_.retailerid_){} + , decltype(_impl_.url_){} + , decltype(_impl_.firstimageid_){} + , decltype(_impl_.productimage_){nullptr} + , decltype(_impl_.priceamount1000_){int64_t{0}} + , decltype(_impl_.salepriceamount1000_){int64_t{0}} + , decltype(_impl_.productimagecount_){0u} + }; + _impl_.productid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.productid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.title_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.title_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.description_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.description_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.currencycode_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.currencycode_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.retailerid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.retailerid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.url_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.url_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.firstimageid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.firstimageid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_ProductMessage_ProductSnapshot::~Message_ProductMessage_ProductSnapshot() { + // @@protoc_insertion_point(destructor:proto.Message.ProductMessage.ProductSnapshot) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_ProductMessage_ProductSnapshot::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.productid_.Destroy(); + _impl_.title_.Destroy(); + _impl_.description_.Destroy(); + _impl_.currencycode_.Destroy(); + _impl_.retailerid_.Destroy(); + _impl_.url_.Destroy(); + _impl_.firstimageid_.Destroy(); + if (this != internal_default_instance()) delete _impl_.productimage_; +} + +void Message_ProductMessage_ProductSnapshot::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_ProductMessage_ProductSnapshot::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.ProductMessage.ProductSnapshot) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _impl_.productid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.title_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.description_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + _impl_.currencycode_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + _impl_.retailerid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000020u) { + _impl_.url_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000040u) { + _impl_.firstimageid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000080u) { + GOOGLE_DCHECK(_impl_.productimage_ != nullptr); + _impl_.productimage_->Clear(); + } + } + if (cached_has_bits & 0x00000700u) { + ::memset(&_impl_.priceamount1000_, 0, static_cast( + reinterpret_cast(&_impl_.productimagecount_) - + reinterpret_cast(&_impl_.priceamount1000_)) + sizeof(_impl_.productimagecount_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_ProductMessage_ProductSnapshot::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.Message.ImageMessage productImage = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_productimage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string productId = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_productid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.ProductSnapshot.productId"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string title = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_title(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.ProductSnapshot.title"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string description = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_description(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.ProductSnapshot.description"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string currencyCode = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + auto str = _internal_mutable_currencycode(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.ProductSnapshot.currencyCode"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional int64 priceAmount1000 = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + _Internal::set_has_priceamount1000(&has_bits); + _impl_.priceamount1000_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string retailerId = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + auto str = _internal_mutable_retailerid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.ProductSnapshot.retailerId"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string url = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + auto str = _internal_mutable_url(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.ProductSnapshot.url"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional uint32 productImageCount = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { + _Internal::set_has_productimagecount(&has_bits); + _impl_.productimagecount_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string firstImageId = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { + auto str = _internal_mutable_firstimageid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.ProductSnapshot.firstImageId"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional int64 salePriceAmount1000 = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { + _Internal::set_has_salepriceamount1000(&has_bits); + _impl_.salepriceamount1000_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_ProductMessage_ProductSnapshot::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ProductMessage.ProductSnapshot) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.Message.ImageMessage productImage = 1; + if (cached_has_bits & 0x00000080u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::productimage(this), + _Internal::productimage(this).GetCachedSize(), target, stream); + } + + // optional string productId = 2; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_productid().data(), static_cast(this->_internal_productid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ProductMessage.ProductSnapshot.productId"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_productid(), target); + } + + // optional string title = 3; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_title().data(), static_cast(this->_internal_title().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ProductMessage.ProductSnapshot.title"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_title(), target); + } + + // optional string description = 4; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_description().data(), static_cast(this->_internal_description().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ProductMessage.ProductSnapshot.description"); + target = stream->WriteStringMaybeAliased( + 4, this->_internal_description(), target); + } + + // optional string currencyCode = 5; + if (cached_has_bits & 0x00000008u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_currencycode().data(), static_cast(this->_internal_currencycode().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ProductMessage.ProductSnapshot.currencyCode"); + target = stream->WriteStringMaybeAliased( + 5, this->_internal_currencycode(), target); + } + + // optional int64 priceAmount1000 = 6; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(6, this->_internal_priceamount1000(), target); + } + + // optional string retailerId = 7; + if (cached_has_bits & 0x00000010u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_retailerid().data(), static_cast(this->_internal_retailerid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ProductMessage.ProductSnapshot.retailerId"); + target = stream->WriteStringMaybeAliased( + 7, this->_internal_retailerid(), target); + } + + // optional string url = 8; + if (cached_has_bits & 0x00000020u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_url().data(), static_cast(this->_internal_url().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ProductMessage.ProductSnapshot.url"); + target = stream->WriteStringMaybeAliased( + 8, this->_internal_url(), target); + } + + // optional uint32 productImageCount = 9; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(9, this->_internal_productimagecount(), target); + } + + // optional string firstImageId = 11; + if (cached_has_bits & 0x00000040u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_firstimageid().data(), static_cast(this->_internal_firstimageid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ProductMessage.ProductSnapshot.firstImageId"); + target = stream->WriteStringMaybeAliased( + 11, this->_internal_firstimageid(), target); + } + + // optional int64 salePriceAmount1000 = 12; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(12, this->_internal_salepriceamount1000(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ProductMessage.ProductSnapshot) + return target; +} + +size_t Message_ProductMessage_ProductSnapshot::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.ProductMessage.ProductSnapshot) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string productId = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_productid()); + } + + // optional string title = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_title()); + } + + // optional string description = 4; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_description()); + } + + // optional string currencyCode = 5; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_currencycode()); + } + + // optional string retailerId = 7; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_retailerid()); + } + + // optional string url = 8; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_url()); + } + + // optional string firstImageId = 11; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_firstimageid()); + } + + // optional .proto.Message.ImageMessage productImage = 1; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.productimage_); + } + + } + if (cached_has_bits & 0x00000700u) { + // optional int64 priceAmount1000 = 6; + if (cached_has_bits & 0x00000100u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_priceamount1000()); + } + + // optional int64 salePriceAmount1000 = 12; + if (cached_has_bits & 0x00000200u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_salepriceamount1000()); + } + + // optional uint32 productImageCount = 9; + if (cached_has_bits & 0x00000400u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_productimagecount()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ProductMessage_ProductSnapshot::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_ProductMessage_ProductSnapshot::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ProductMessage_ProductSnapshot::GetClassData() const { return &_class_data_; } + + +void Message_ProductMessage_ProductSnapshot::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ProductMessage.ProductSnapshot) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_productid(from._internal_productid()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_title(from._internal_title()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_description(from._internal_description()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_set_currencycode(from._internal_currencycode()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_set_retailerid(from._internal_retailerid()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_set_url(from._internal_url()); + } + if (cached_has_bits & 0x00000040u) { + _this->_internal_set_firstimageid(from._internal_firstimageid()); + } + if (cached_has_bits & 0x00000080u) { + _this->_internal_mutable_productimage()->::proto::Message_ImageMessage::MergeFrom( + from._internal_productimage()); + } + } + if (cached_has_bits & 0x00000700u) { + if (cached_has_bits & 0x00000100u) { + _this->_impl_.priceamount1000_ = from._impl_.priceamount1000_; + } + if (cached_has_bits & 0x00000200u) { + _this->_impl_.salepriceamount1000_ = from._impl_.salepriceamount1000_; + } + if (cached_has_bits & 0x00000400u) { + _this->_impl_.productimagecount_ = from._impl_.productimagecount_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_ProductMessage_ProductSnapshot::CopyFrom(const Message_ProductMessage_ProductSnapshot& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ProductMessage.ProductSnapshot) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_ProductMessage_ProductSnapshot::IsInitialized() const { + return true; +} + +void Message_ProductMessage_ProductSnapshot::InternalSwap(Message_ProductMessage_ProductSnapshot* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.productid_, lhs_arena, + &other->_impl_.productid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.title_, lhs_arena, + &other->_impl_.title_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.description_, lhs_arena, + &other->_impl_.description_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.currencycode_, lhs_arena, + &other->_impl_.currencycode_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.retailerid_, lhs_arena, + &other->_impl_.retailerid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.url_, lhs_arena, + &other->_impl_.url_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.firstimageid_, lhs_arena, + &other->_impl_.firstimageid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_ProductMessage_ProductSnapshot, _impl_.productimagecount_) + + sizeof(Message_ProductMessage_ProductSnapshot::_impl_.productimagecount_) + - PROTOBUF_FIELD_OFFSET(Message_ProductMessage_ProductSnapshot, _impl_.productimage_)>( + reinterpret_cast(&_impl_.productimage_), + reinterpret_cast(&other->_impl_.productimage_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_ProductMessage_ProductSnapshot::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[119]); +} + +// =================================================================== + +class Message_ProductMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::Message_ProductMessage_ProductSnapshot& product(const Message_ProductMessage* msg); + static void set_has_product(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_businessownerjid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::proto::Message_ProductMessage_CatalogSnapshot& catalog(const Message_ProductMessage* msg); + static void set_has_catalog(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_body(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_footer(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static const ::proto::ContextInfo& contextinfo(const Message_ProductMessage* msg); + static void set_has_contextinfo(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } +}; + +const ::proto::Message_ProductMessage_ProductSnapshot& +Message_ProductMessage::_Internal::product(const Message_ProductMessage* msg) { + return *msg->_impl_.product_; +} +const ::proto::Message_ProductMessage_CatalogSnapshot& +Message_ProductMessage::_Internal::catalog(const Message_ProductMessage* msg) { + return *msg->_impl_.catalog_; +} +const ::proto::ContextInfo& +Message_ProductMessage::_Internal::contextinfo(const Message_ProductMessage* msg) { + return *msg->_impl_.contextinfo_; +} +Message_ProductMessage::Message_ProductMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.ProductMessage) +} +Message_ProductMessage::Message_ProductMessage(const Message_ProductMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_ProductMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.businessownerjid_){} + , decltype(_impl_.body_){} + , decltype(_impl_.footer_){} + , decltype(_impl_.product_){nullptr} + , decltype(_impl_.catalog_){nullptr} + , decltype(_impl_.contextinfo_){nullptr}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.businessownerjid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.businessownerjid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_businessownerjid()) { + _this->_impl_.businessownerjid_.Set(from._internal_businessownerjid(), + _this->GetArenaForAllocation()); + } + _impl_.body_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.body_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_body()) { + _this->_impl_.body_.Set(from._internal_body(), + _this->GetArenaForAllocation()); + } + _impl_.footer_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.footer_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_footer()) { + _this->_impl_.footer_.Set(from._internal_footer(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_product()) { + _this->_impl_.product_ = new ::proto::Message_ProductMessage_ProductSnapshot(*from._impl_.product_); + } + if (from._internal_has_catalog()) { + _this->_impl_.catalog_ = new ::proto::Message_ProductMessage_CatalogSnapshot(*from._impl_.catalog_); + } + if (from._internal_has_contextinfo()) { + _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); + } + // @@protoc_insertion_point(copy_constructor:proto.Message.ProductMessage) +} + +inline void Message_ProductMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.businessownerjid_){} + , decltype(_impl_.body_){} + , decltype(_impl_.footer_){} + , decltype(_impl_.product_){nullptr} + , decltype(_impl_.catalog_){nullptr} + , decltype(_impl_.contextinfo_){nullptr} + }; + _impl_.businessownerjid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.businessownerjid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.body_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.body_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.footer_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.footer_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_ProductMessage::~Message_ProductMessage() { + // @@protoc_insertion_point(destructor:proto.Message.ProductMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_ProductMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.businessownerjid_.Destroy(); + _impl_.body_.Destroy(); + _impl_.footer_.Destroy(); + if (this != internal_default_instance()) delete _impl_.product_; + if (this != internal_default_instance()) delete _impl_.catalog_; + if (this != internal_default_instance()) delete _impl_.contextinfo_; +} + +void Message_ProductMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_ProductMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.ProductMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + _impl_.businessownerjid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.body_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.footer_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(_impl_.product_ != nullptr); + _impl_.product_->Clear(); + } + if (cached_has_bits & 0x00000010u) { + GOOGLE_DCHECK(_impl_.catalog_ != nullptr); + _impl_.catalog_->Clear(); + } + if (cached_has_bits & 0x00000020u) { + GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); + _impl_.contextinfo_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_ProductMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.Message.ProductMessage.ProductSnapshot product = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_product(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string businessOwnerJid = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_businessownerjid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.businessOwnerJid"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.Message.ProductMessage.CatalogSnapshot catalog = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_catalog(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string body = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + auto str = _internal_mutable_body(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.body"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string footer = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + auto str = _internal_mutable_footer(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.footer"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.ContextInfo contextInfo = 17; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { + ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_ProductMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ProductMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.Message.ProductMessage.ProductSnapshot product = 1; + if (cached_has_bits & 0x00000008u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::product(this), + _Internal::product(this).GetCachedSize(), target, stream); + } + + // optional string businessOwnerJid = 2; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_businessownerjid().data(), static_cast(this->_internal_businessownerjid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ProductMessage.businessOwnerJid"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_businessownerjid(), target); + } + + // optional .proto.Message.ProductMessage.CatalogSnapshot catalog = 4; + if (cached_has_bits & 0x00000010u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, _Internal::catalog(this), + _Internal::catalog(this).GetCachedSize(), target, stream); + } + + // optional string body = 5; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_body().data(), static_cast(this->_internal_body().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ProductMessage.body"); + target = stream->WriteStringMaybeAliased( + 5, this->_internal_body(), target); + } + + // optional string footer = 6; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_footer().data(), static_cast(this->_internal_footer().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ProductMessage.footer"); + target = stream->WriteStringMaybeAliased( + 6, this->_internal_footer(), target); + } + + // optional .proto.ContextInfo contextInfo = 17; + if (cached_has_bits & 0x00000020u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(17, _Internal::contextinfo(this), + _Internal::contextinfo(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ProductMessage) + return target; +} + +size_t Message_ProductMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.ProductMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + // optional string businessOwnerJid = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_businessownerjid()); + } + + // optional string body = 5; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_body()); + } + + // optional string footer = 6; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_footer()); + } + + // optional .proto.Message.ProductMessage.ProductSnapshot product = 1; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.product_); + } + + // optional .proto.Message.ProductMessage.CatalogSnapshot catalog = 4; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.catalog_); + } + + // optional .proto.ContextInfo contextInfo = 17; + if (cached_has_bits & 0x00000020u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.contextinfo_); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ProductMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_ProductMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ProductMessage::GetClassData() const { return &_class_data_; } + + +void Message_ProductMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ProductMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_businessownerjid(from._internal_businessownerjid()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_body(from._internal_body()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_footer(from._internal_footer()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_mutable_product()->::proto::Message_ProductMessage_ProductSnapshot::MergeFrom( + from._internal_product()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_mutable_catalog()->::proto::Message_ProductMessage_CatalogSnapshot::MergeFrom( + from._internal_catalog()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( + from._internal_contextinfo()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_ProductMessage::CopyFrom(const Message_ProductMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ProductMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_ProductMessage::IsInitialized() const { + return true; +} + +void Message_ProductMessage::InternalSwap(Message_ProductMessage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.businessownerjid_, lhs_arena, + &other->_impl_.businessownerjid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.body_, lhs_arena, + &other->_impl_.body_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.footer_, lhs_arena, + &other->_impl_.footer_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_ProductMessage, _impl_.contextinfo_) + + sizeof(Message_ProductMessage::_impl_.contextinfo_) + - PROTOBUF_FIELD_OFFSET(Message_ProductMessage, _impl_.product_)>( + reinterpret_cast(&_impl_.product_), + reinterpret_cast(&other->_impl_.product_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_ProductMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[120]); +} + +// =================================================================== + +class Message_ProtocolMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::MessageKey& key(const Message_ProtocolMessage* msg); + static void set_has_key(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_type(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_ephemeralexpiration(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static void set_has_ephemeralsettingtimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static const ::proto::Message_HistorySyncNotification& historysyncnotification(const Message_ProtocolMessage* msg); + static void set_has_historysyncnotification(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::proto::Message_AppStateSyncKeyShare& appstatesynckeyshare(const Message_ProtocolMessage* msg); + static void set_has_appstatesynckeyshare(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static const ::proto::Message_AppStateSyncKeyRequest& appstatesynckeyrequest(const Message_ProtocolMessage* msg); + static void set_has_appstatesynckeyrequest(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static const ::proto::Message_InitialSecurityNotificationSettingSync& initialsecuritynotificationsettingsync(const Message_ProtocolMessage* msg); + static void set_has_initialsecuritynotificationsettingsync(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static const ::proto::Message_AppStateFatalExceptionNotification& appstatefatalexceptionnotification(const Message_ProtocolMessage* msg); + static void set_has_appstatefatalexceptionnotification(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static const ::proto::DisappearingMode& disappearingmode(const Message_ProtocolMessage* msg); + static void set_has_disappearingmode(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static const ::proto::Message_RequestMediaUploadMessage& requestmediauploadmessage(const Message_ProtocolMessage* msg); + static void set_has_requestmediauploadmessage(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static const ::proto::Message_RequestMediaUploadResponseMessage& requestmediauploadresponsemessage(const Message_ProtocolMessage* msg); + static void set_has_requestmediauploadresponsemessage(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } +}; + +const ::proto::MessageKey& +Message_ProtocolMessage::_Internal::key(const Message_ProtocolMessage* msg) { + return *msg->_impl_.key_; +} +const ::proto::Message_HistorySyncNotification& +Message_ProtocolMessage::_Internal::historysyncnotification(const Message_ProtocolMessage* msg) { + return *msg->_impl_.historysyncnotification_; +} +const ::proto::Message_AppStateSyncKeyShare& +Message_ProtocolMessage::_Internal::appstatesynckeyshare(const Message_ProtocolMessage* msg) { + return *msg->_impl_.appstatesynckeyshare_; +} +const ::proto::Message_AppStateSyncKeyRequest& +Message_ProtocolMessage::_Internal::appstatesynckeyrequest(const Message_ProtocolMessage* msg) { + return *msg->_impl_.appstatesynckeyrequest_; +} +const ::proto::Message_InitialSecurityNotificationSettingSync& +Message_ProtocolMessage::_Internal::initialsecuritynotificationsettingsync(const Message_ProtocolMessage* msg) { + return *msg->_impl_.initialsecuritynotificationsettingsync_; +} +const ::proto::Message_AppStateFatalExceptionNotification& +Message_ProtocolMessage::_Internal::appstatefatalexceptionnotification(const Message_ProtocolMessage* msg) { + return *msg->_impl_.appstatefatalexceptionnotification_; +} +const ::proto::DisappearingMode& +Message_ProtocolMessage::_Internal::disappearingmode(const Message_ProtocolMessage* msg) { + return *msg->_impl_.disappearingmode_; +} +const ::proto::Message_RequestMediaUploadMessage& +Message_ProtocolMessage::_Internal::requestmediauploadmessage(const Message_ProtocolMessage* msg) { + return *msg->_impl_.requestmediauploadmessage_; +} +const ::proto::Message_RequestMediaUploadResponseMessage& +Message_ProtocolMessage::_Internal::requestmediauploadresponsemessage(const Message_ProtocolMessage* msg) { + return *msg->_impl_.requestmediauploadresponsemessage_; +} +Message_ProtocolMessage::Message_ProtocolMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.ProtocolMessage) +} +Message_ProtocolMessage::Message_ProtocolMessage(const Message_ProtocolMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_ProtocolMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.key_){nullptr} + , decltype(_impl_.historysyncnotification_){nullptr} + , decltype(_impl_.appstatesynckeyshare_){nullptr} + , decltype(_impl_.appstatesynckeyrequest_){nullptr} + , decltype(_impl_.initialsecuritynotificationsettingsync_){nullptr} + , decltype(_impl_.appstatefatalexceptionnotification_){nullptr} + , decltype(_impl_.disappearingmode_){nullptr} + , decltype(_impl_.requestmediauploadmessage_){nullptr} + , decltype(_impl_.requestmediauploadresponsemessage_){nullptr} + , decltype(_impl_.type_){} + , decltype(_impl_.ephemeralexpiration_){} + , decltype(_impl_.ephemeralsettingtimestamp_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_key()) { + _this->_impl_.key_ = new ::proto::MessageKey(*from._impl_.key_); + } + if (from._internal_has_historysyncnotification()) { + _this->_impl_.historysyncnotification_ = new ::proto::Message_HistorySyncNotification(*from._impl_.historysyncnotification_); + } + if (from._internal_has_appstatesynckeyshare()) { + _this->_impl_.appstatesynckeyshare_ = new ::proto::Message_AppStateSyncKeyShare(*from._impl_.appstatesynckeyshare_); + } + if (from._internal_has_appstatesynckeyrequest()) { + _this->_impl_.appstatesynckeyrequest_ = new ::proto::Message_AppStateSyncKeyRequest(*from._impl_.appstatesynckeyrequest_); + } + if (from._internal_has_initialsecuritynotificationsettingsync()) { + _this->_impl_.initialsecuritynotificationsettingsync_ = new ::proto::Message_InitialSecurityNotificationSettingSync(*from._impl_.initialsecuritynotificationsettingsync_); + } + if (from._internal_has_appstatefatalexceptionnotification()) { + _this->_impl_.appstatefatalexceptionnotification_ = new ::proto::Message_AppStateFatalExceptionNotification(*from._impl_.appstatefatalexceptionnotification_); + } + if (from._internal_has_disappearingmode()) { + _this->_impl_.disappearingmode_ = new ::proto::DisappearingMode(*from._impl_.disappearingmode_); + } + if (from._internal_has_requestmediauploadmessage()) { + _this->_impl_.requestmediauploadmessage_ = new ::proto::Message_RequestMediaUploadMessage(*from._impl_.requestmediauploadmessage_); + } + if (from._internal_has_requestmediauploadresponsemessage()) { + _this->_impl_.requestmediauploadresponsemessage_ = new ::proto::Message_RequestMediaUploadResponseMessage(*from._impl_.requestmediauploadresponsemessage_); + } + ::memcpy(&_impl_.type_, &from._impl_.type_, + static_cast(reinterpret_cast(&_impl_.ephemeralsettingtimestamp_) - + reinterpret_cast(&_impl_.type_)) + sizeof(_impl_.ephemeralsettingtimestamp_)); + // @@protoc_insertion_point(copy_constructor:proto.Message.ProtocolMessage) +} + +inline void Message_ProtocolMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.key_){nullptr} + , decltype(_impl_.historysyncnotification_){nullptr} + , decltype(_impl_.appstatesynckeyshare_){nullptr} + , decltype(_impl_.appstatesynckeyrequest_){nullptr} + , decltype(_impl_.initialsecuritynotificationsettingsync_){nullptr} + , decltype(_impl_.appstatefatalexceptionnotification_){nullptr} + , decltype(_impl_.disappearingmode_){nullptr} + , decltype(_impl_.requestmediauploadmessage_){nullptr} + , decltype(_impl_.requestmediauploadresponsemessage_){nullptr} + , decltype(_impl_.type_){0} + , decltype(_impl_.ephemeralexpiration_){0u} + , decltype(_impl_.ephemeralsettingtimestamp_){int64_t{0}} + }; +} + +Message_ProtocolMessage::~Message_ProtocolMessage() { + // @@protoc_insertion_point(destructor:proto.Message.ProtocolMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_ProtocolMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.key_; + if (this != internal_default_instance()) delete _impl_.historysyncnotification_; + if (this != internal_default_instance()) delete _impl_.appstatesynckeyshare_; + if (this != internal_default_instance()) delete _impl_.appstatesynckeyrequest_; + if (this != internal_default_instance()) delete _impl_.initialsecuritynotificationsettingsync_; + if (this != internal_default_instance()) delete _impl_.appstatefatalexceptionnotification_; + if (this != internal_default_instance()) delete _impl_.disappearingmode_; + if (this != internal_default_instance()) delete _impl_.requestmediauploadmessage_; + if (this != internal_default_instance()) delete _impl_.requestmediauploadresponsemessage_; +} + +void Message_ProtocolMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_ProtocolMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.ProtocolMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.key_ != nullptr); + _impl_.key_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.historysyncnotification_ != nullptr); + _impl_.historysyncnotification_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.appstatesynckeyshare_ != nullptr); + _impl_.appstatesynckeyshare_->Clear(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(_impl_.appstatesynckeyrequest_ != nullptr); + _impl_.appstatesynckeyrequest_->Clear(); + } + if (cached_has_bits & 0x00000010u) { + GOOGLE_DCHECK(_impl_.initialsecuritynotificationsettingsync_ != nullptr); + _impl_.initialsecuritynotificationsettingsync_->Clear(); + } + if (cached_has_bits & 0x00000020u) { + GOOGLE_DCHECK(_impl_.appstatefatalexceptionnotification_ != nullptr); + _impl_.appstatefatalexceptionnotification_->Clear(); + } + if (cached_has_bits & 0x00000040u) { + GOOGLE_DCHECK(_impl_.disappearingmode_ != nullptr); + _impl_.disappearingmode_->Clear(); + } + if (cached_has_bits & 0x00000080u) { + GOOGLE_DCHECK(_impl_.requestmediauploadmessage_ != nullptr); + _impl_.requestmediauploadmessage_->Clear(); + } + } + if (cached_has_bits & 0x00000100u) { + GOOGLE_DCHECK(_impl_.requestmediauploadresponsemessage_ != nullptr); + _impl_.requestmediauploadresponsemessage_->Clear(); + } + if (cached_has_bits & 0x00000e00u) { + ::memset(&_impl_.type_, 0, static_cast( + reinterpret_cast(&_impl_.ephemeralsettingtimestamp_) - + reinterpret_cast(&_impl_.type_)) + sizeof(_impl_.ephemeralsettingtimestamp_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_ProtocolMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.MessageKey key = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.ProtocolMessage.Type type = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::Message_ProtocolMessage_Type_IsValid(val))) { + _internal_set_type(static_cast<::proto::Message_ProtocolMessage_Type>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional uint32 ephemeralExpiration = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_ephemeralexpiration(&has_bits); + _impl_.ephemeralexpiration_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 ephemeralSettingTimestamp = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_ephemeralsettingtimestamp(&has_bits); + _impl_.ephemeralsettingtimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.HistorySyncNotification historySyncNotification = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_historysyncnotification(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.AppStateSyncKeyShare appStateSyncKeyShare = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_appstatesynckeyshare(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.AppStateSyncKeyRequest appStateSyncKeyRequest = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + ptr = ctx->ParseMessage(_internal_mutable_appstatesynckeyrequest(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.InitialSecurityNotificationSettingSync initialSecurityNotificationSettingSync = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + ptr = ctx->ParseMessage(_internal_mutable_initialsecuritynotificationsettingsync(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.AppStateFatalExceptionNotification appStateFatalExceptionNotification = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_appstatefatalexceptionnotification(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.DisappearingMode disappearingMode = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { + ptr = ctx->ParseMessage(_internal_mutable_disappearingmode(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.RequestMediaUploadMessage requestMediaUploadMessage = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { + ptr = ctx->ParseMessage(_internal_mutable_requestmediauploadmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.RequestMediaUploadResponseMessage requestMediaUploadResponseMessage = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { + ptr = ctx->ParseMessage(_internal_mutable_requestmediauploadresponsemessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_ProtocolMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ProtocolMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.MessageKey key = 1; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::key(this), + _Internal::key(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.ProtocolMessage.Type type = 2; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this->_internal_type(), target); + } + + // optional uint32 ephemeralExpiration = 4; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_ephemeralexpiration(), target); + } + + // optional int64 ephemeralSettingTimestamp = 5; + if (cached_has_bits & 0x00000800u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(5, this->_internal_ephemeralsettingtimestamp(), target); + } + + // optional .proto.Message.HistorySyncNotification historySyncNotification = 6; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(6, _Internal::historysyncnotification(this), + _Internal::historysyncnotification(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.AppStateSyncKeyShare appStateSyncKeyShare = 7; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(7, _Internal::appstatesynckeyshare(this), + _Internal::appstatesynckeyshare(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.AppStateSyncKeyRequest appStateSyncKeyRequest = 8; + if (cached_has_bits & 0x00000008u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(8, _Internal::appstatesynckeyrequest(this), + _Internal::appstatesynckeyrequest(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.InitialSecurityNotificationSettingSync initialSecurityNotificationSettingSync = 9; + if (cached_has_bits & 0x00000010u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(9, _Internal::initialsecuritynotificationsettingsync(this), + _Internal::initialsecuritynotificationsettingsync(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.AppStateFatalExceptionNotification appStateFatalExceptionNotification = 10; + if (cached_has_bits & 0x00000020u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(10, _Internal::appstatefatalexceptionnotification(this), + _Internal::appstatefatalexceptionnotification(this).GetCachedSize(), target, stream); + } + + // optional .proto.DisappearingMode disappearingMode = 11; + if (cached_has_bits & 0x00000040u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(11, _Internal::disappearingmode(this), + _Internal::disappearingmode(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.RequestMediaUploadMessage requestMediaUploadMessage = 12; + if (cached_has_bits & 0x00000080u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(12, _Internal::requestmediauploadmessage(this), + _Internal::requestmediauploadmessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.RequestMediaUploadResponseMessage requestMediaUploadResponseMessage = 13; + if (cached_has_bits & 0x00000100u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(13, _Internal::requestmediauploadresponsemessage(this), + _Internal::requestmediauploadresponsemessage(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ProtocolMessage) + return target; +} + +size_t Message_ProtocolMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.ProtocolMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional .proto.MessageKey key = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.key_); + } + + // optional .proto.Message.HistorySyncNotification historySyncNotification = 6; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.historysyncnotification_); + } + + // optional .proto.Message.AppStateSyncKeyShare appStateSyncKeyShare = 7; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.appstatesynckeyshare_); + } + + // optional .proto.Message.AppStateSyncKeyRequest appStateSyncKeyRequest = 8; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.appstatesynckeyrequest_); + } + + // optional .proto.Message.InitialSecurityNotificationSettingSync initialSecurityNotificationSettingSync = 9; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.initialsecuritynotificationsettingsync_); + } + + // optional .proto.Message.AppStateFatalExceptionNotification appStateFatalExceptionNotification = 10; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.appstatefatalexceptionnotification_); + } + + // optional .proto.DisappearingMode disappearingMode = 11; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.disappearingmode_); + } + + // optional .proto.Message.RequestMediaUploadMessage requestMediaUploadMessage = 12; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.requestmediauploadmessage_); + } + + } + if (cached_has_bits & 0x00000f00u) { + // optional .proto.Message.RequestMediaUploadResponseMessage requestMediaUploadResponseMessage = 13; + if (cached_has_bits & 0x00000100u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.requestmediauploadresponsemessage_); + } + + // optional .proto.Message.ProtocolMessage.Type type = 2; + if (cached_has_bits & 0x00000200u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_type()); + } + + // optional uint32 ephemeralExpiration = 4; + if (cached_has_bits & 0x00000400u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_ephemeralexpiration()); + } + + // optional int64 ephemeralSettingTimestamp = 5; + if (cached_has_bits & 0x00000800u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_ephemeralsettingtimestamp()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ProtocolMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_ProtocolMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ProtocolMessage::GetClassData() const { return &_class_data_; } + + +void Message_ProtocolMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ProtocolMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_key()->::proto::MessageKey::MergeFrom( + from._internal_key()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_historysyncnotification()->::proto::Message_HistorySyncNotification::MergeFrom( + from._internal_historysyncnotification()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_appstatesynckeyshare()->::proto::Message_AppStateSyncKeyShare::MergeFrom( + from._internal_appstatesynckeyshare()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_mutable_appstatesynckeyrequest()->::proto::Message_AppStateSyncKeyRequest::MergeFrom( + from._internal_appstatesynckeyrequest()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_mutable_initialsecuritynotificationsettingsync()->::proto::Message_InitialSecurityNotificationSettingSync::MergeFrom( + from._internal_initialsecuritynotificationsettingsync()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_mutable_appstatefatalexceptionnotification()->::proto::Message_AppStateFatalExceptionNotification::MergeFrom( + from._internal_appstatefatalexceptionnotification()); + } + if (cached_has_bits & 0x00000040u) { + _this->_internal_mutable_disappearingmode()->::proto::DisappearingMode::MergeFrom( + from._internal_disappearingmode()); + } + if (cached_has_bits & 0x00000080u) { + _this->_internal_mutable_requestmediauploadmessage()->::proto::Message_RequestMediaUploadMessage::MergeFrom( + from._internal_requestmediauploadmessage()); + } + } + if (cached_has_bits & 0x00000f00u) { + if (cached_has_bits & 0x00000100u) { + _this->_internal_mutable_requestmediauploadresponsemessage()->::proto::Message_RequestMediaUploadResponseMessage::MergeFrom( + from._internal_requestmediauploadresponsemessage()); + } + if (cached_has_bits & 0x00000200u) { + _this->_impl_.type_ = from._impl_.type_; + } + if (cached_has_bits & 0x00000400u) { + _this->_impl_.ephemeralexpiration_ = from._impl_.ephemeralexpiration_; + } + if (cached_has_bits & 0x00000800u) { + _this->_impl_.ephemeralsettingtimestamp_ = from._impl_.ephemeralsettingtimestamp_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_ProtocolMessage::CopyFrom(const Message_ProtocolMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ProtocolMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_ProtocolMessage::IsInitialized() const { + return true; +} + +void Message_ProtocolMessage::InternalSwap(Message_ProtocolMessage* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_ProtocolMessage, _impl_.ephemeralsettingtimestamp_) + + sizeof(Message_ProtocolMessage::_impl_.ephemeralsettingtimestamp_) + - PROTOBUF_FIELD_OFFSET(Message_ProtocolMessage, _impl_.key_)>( + reinterpret_cast(&_impl_.key_), + reinterpret_cast(&other->_impl_.key_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_ProtocolMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[121]); +} + +// =================================================================== + +class Message_ReactionMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::MessageKey& key(const Message_ReactionMessage* msg); + static void set_has_key(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_text(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_groupingkey(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_sendertimestampms(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +const ::proto::MessageKey& +Message_ReactionMessage::_Internal::key(const Message_ReactionMessage* msg) { + return *msg->_impl_.key_; +} +Message_ReactionMessage::Message_ReactionMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.ReactionMessage) +} +Message_ReactionMessage::Message_ReactionMessage(const Message_ReactionMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_ReactionMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.text_){} + , decltype(_impl_.groupingkey_){} + , decltype(_impl_.key_){nullptr} + , decltype(_impl_.sendertimestampms_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.text_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.text_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_text()) { + _this->_impl_.text_.Set(from._internal_text(), + _this->GetArenaForAllocation()); + } + _impl_.groupingkey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.groupingkey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_groupingkey()) { + _this->_impl_.groupingkey_.Set(from._internal_groupingkey(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_key()) { + _this->_impl_.key_ = new ::proto::MessageKey(*from._impl_.key_); + } + _this->_impl_.sendertimestampms_ = from._impl_.sendertimestampms_; + // @@protoc_insertion_point(copy_constructor:proto.Message.ReactionMessage) +} + +inline void Message_ReactionMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.text_){} + , decltype(_impl_.groupingkey_){} + , decltype(_impl_.key_){nullptr} + , decltype(_impl_.sendertimestampms_){int64_t{0}} + }; + _impl_.text_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.text_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.groupingkey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.groupingkey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_ReactionMessage::~Message_ReactionMessage() { + // @@protoc_insertion_point(destructor:proto.Message.ReactionMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_ReactionMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.text_.Destroy(); + _impl_.groupingkey_.Destroy(); + if (this != internal_default_instance()) delete _impl_.key_; +} + +void Message_ReactionMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_ReactionMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.ReactionMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _impl_.text_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.groupingkey_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.key_ != nullptr); + _impl_.key_->Clear(); + } + } + _impl_.sendertimestampms_ = int64_t{0}; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_ReactionMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.MessageKey key = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string text = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_text(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ReactionMessage.text"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string groupingKey = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_groupingkey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.ReactionMessage.groupingKey"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional int64 senderTimestampMs = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_sendertimestampms(&has_bits); + _impl_.sendertimestampms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_ReactionMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ReactionMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.MessageKey key = 1; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::key(this), + _Internal::key(this).GetCachedSize(), target, stream); + } + + // optional string text = 2; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_text().data(), static_cast(this->_internal_text().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ReactionMessage.text"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_text(), target); + } + + // optional string groupingKey = 3; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_groupingkey().data(), static_cast(this->_internal_groupingkey().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.ReactionMessage.groupingKey"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_groupingkey(), target); + } + + // optional int64 senderTimestampMs = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_sendertimestampms(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ReactionMessage) + return target; +} + +size_t Message_ReactionMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.ReactionMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional string text = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_text()); + } + + // optional string groupingKey = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_groupingkey()); + } + + // optional .proto.MessageKey key = 1; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.key_); + } + + // optional int64 senderTimestampMs = 4; + if (cached_has_bits & 0x00000008u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_sendertimestampms()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ReactionMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_ReactionMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ReactionMessage::GetClassData() const { return &_class_data_; } + + +void Message_ReactionMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ReactionMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_text(from._internal_text()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_groupingkey(from._internal_groupingkey()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_key()->::proto::MessageKey::MergeFrom( + from._internal_key()); + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.sendertimestampms_ = from._impl_.sendertimestampms_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_ReactionMessage::CopyFrom(const Message_ReactionMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ReactionMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_ReactionMessage::IsInitialized() const { + return true; +} + +void Message_ReactionMessage::InternalSwap(Message_ReactionMessage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.text_, lhs_arena, + &other->_impl_.text_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.groupingkey_, lhs_arena, + &other->_impl_.groupingkey_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_ReactionMessage, _impl_.sendertimestampms_) + + sizeof(Message_ReactionMessage::_impl_.sendertimestampms_) + - PROTOBUF_FIELD_OFFSET(Message_ReactionMessage, _impl_.key_)>( + reinterpret_cast(&_impl_.key_), + reinterpret_cast(&other->_impl_.key_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_ReactionMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[122]); +} + +// =================================================================== + +class Message_RequestMediaUploadMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_rmrsource(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +Message_RequestMediaUploadMessage::Message_RequestMediaUploadMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.RequestMediaUploadMessage) +} +Message_RequestMediaUploadMessage::Message_RequestMediaUploadMessage(const Message_RequestMediaUploadMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_RequestMediaUploadMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.filesha256_){from._impl_.filesha256_} + , decltype(_impl_.rmrsource_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _this->_impl_.rmrsource_ = from._impl_.rmrsource_; + // @@protoc_insertion_point(copy_constructor:proto.Message.RequestMediaUploadMessage) +} + +inline void Message_RequestMediaUploadMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.filesha256_){arena} + , decltype(_impl_.rmrsource_){0} + }; +} + +Message_RequestMediaUploadMessage::~Message_RequestMediaUploadMessage() { + // @@protoc_insertion_point(destructor:proto.Message.RequestMediaUploadMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_RequestMediaUploadMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.filesha256_.~RepeatedPtrField(); +} + +void Message_RequestMediaUploadMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_RequestMediaUploadMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.RequestMediaUploadMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.filesha256_.Clear(); + _impl_.rmrsource_ = 0; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_RequestMediaUploadMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated string fileSha256 = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_filesha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.RequestMediaUploadMessage.fileSha256"); + #endif // !NDEBUG + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else + goto handle_unusual; + continue; + // optional .proto.Message.RmrSource rmrSource = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::Message_RmrSource_IsValid(val))) { + _internal_set_rmrsource(static_cast<::proto::Message_RmrSource>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_RequestMediaUploadMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.RequestMediaUploadMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated string fileSha256 = 1; + for (int i = 0, n = this->_internal_filesha256_size(); i < n; i++) { + const auto& s = this->_internal_filesha256(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.RequestMediaUploadMessage.fileSha256"); + target = stream->WriteString(1, s, target); + } + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.Message.RmrSource rmrSource = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this->_internal_rmrsource(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.RequestMediaUploadMessage) + return target; +} + +size_t Message_RequestMediaUploadMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.RequestMediaUploadMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string fileSha256 = 1; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.filesha256_.size()); + for (int i = 0, n = _impl_.filesha256_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + _impl_.filesha256_.Get(i)); + } + + // optional .proto.Message.RmrSource rmrSource = 2; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_rmrsource()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_RequestMediaUploadMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_RequestMediaUploadMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_RequestMediaUploadMessage::GetClassData() const { return &_class_data_; } + + +void Message_RequestMediaUploadMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.RequestMediaUploadMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.filesha256_.MergeFrom(from._impl_.filesha256_); + if (from._internal_has_rmrsource()) { + _this->_internal_set_rmrsource(from._internal_rmrsource()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_RequestMediaUploadMessage::CopyFrom(const Message_RequestMediaUploadMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.RequestMediaUploadMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_RequestMediaUploadMessage::IsInitialized() const { + return true; +} + +void Message_RequestMediaUploadMessage::InternalSwap(Message_RequestMediaUploadMessage* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.filesha256_.InternalSwap(&other->_impl_.filesha256_); + swap(_impl_.rmrsource_, other->_impl_.rmrsource_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_RequestMediaUploadMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[123]); +} + +// =================================================================== + +class Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_filesha256(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_mediauploadresult(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static const ::proto::Message_StickerMessage& stickermessage(const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* msg); + static void set_has_stickermessage(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::proto::Message_StickerMessage& +Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_Internal::stickermessage(const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* msg) { + return *msg->_impl_.stickermessage_; +} +Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult) +} +Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult(const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.filesha256_){} + , decltype(_impl_.stickermessage_){nullptr} + , decltype(_impl_.mediauploadresult_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.filesha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filesha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_filesha256()) { + _this->_impl_.filesha256_.Set(from._internal_filesha256(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_stickermessage()) { + _this->_impl_.stickermessage_ = new ::proto::Message_StickerMessage(*from._impl_.stickermessage_); + } + _this->_impl_.mediauploadresult_ = from._impl_.mediauploadresult_; + // @@protoc_insertion_point(copy_constructor:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult) +} + +inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.filesha256_){} + , decltype(_impl_.stickermessage_){nullptr} + , decltype(_impl_.mediauploadresult_){0} + }; + _impl_.filesha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filesha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::~Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult() { + // @@protoc_insertion_point(destructor:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.filesha256_.Destroy(); + if (this != internal_default_instance()) delete _impl_.stickermessage_; +} + +void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.filesha256_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.stickermessage_ != nullptr); + _impl_.stickermessage_->Clear(); + } + } + _impl_.mediauploadresult_ = 0; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string fileSha256 = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_filesha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.fileSha256"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.MediaRetryNotification.ResultType mediaUploadResult = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::MediaRetryNotification_ResultType_IsValid(val))) { + _internal_set_mediauploadresult(static_cast<::proto::MediaRetryNotification_ResultType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.Message.StickerMessage stickerMessage = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_stickermessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string fileSha256 = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_filesha256().data(), static_cast(this->_internal_filesha256().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.fileSha256"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_filesha256(), target); + } + + // optional .proto.MediaRetryNotification.ResultType mediaUploadResult = 2; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this->_internal_mediauploadresult(), target); + } + + // optional .proto.Message.StickerMessage stickerMessage = 3; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::stickermessage(this), + _Internal::stickermessage(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult) + return target; +} + +size_t Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional string fileSha256 = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_filesha256()); + } + + // optional .proto.Message.StickerMessage stickerMessage = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.stickermessage_); + } + + // optional .proto.MediaRetryNotification.ResultType mediaUploadResult = 2; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_mediauploadresult()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::GetClassData() const { return &_class_data_; } + + +void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_filesha256(from._internal_filesha256()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_stickermessage()->::proto::Message_StickerMessage::MergeFrom( + from._internal_stickermessage()); + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.mediauploadresult_ = from._impl_.mediauploadresult_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::CopyFrom(const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::IsInitialized() const { + return true; +} + +void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::InternalSwap(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.filesha256_, lhs_arena, + &other->_impl_.filesha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult, _impl_.mediauploadresult_) + + sizeof(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_impl_.mediauploadresult_) + - PROTOBUF_FIELD_OFFSET(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult, _impl_.stickermessage_)>( + reinterpret_cast(&_impl_.stickermessage_), + reinterpret_cast(&other->_impl_.stickermessage_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[124]); +} + +// =================================================================== + +class Message_RequestMediaUploadResponseMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_rmrsource(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_stanzaid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +Message_RequestMediaUploadResponseMessage::Message_RequestMediaUploadResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.RequestMediaUploadResponseMessage) +} +Message_RequestMediaUploadResponseMessage::Message_RequestMediaUploadResponseMessage(const Message_RequestMediaUploadResponseMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_RequestMediaUploadResponseMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.reuploadresult_){from._impl_.reuploadresult_} + , decltype(_impl_.stanzaid_){} + , decltype(_impl_.rmrsource_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.stanzaid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.stanzaid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_stanzaid()) { + _this->_impl_.stanzaid_.Set(from._internal_stanzaid(), + _this->GetArenaForAllocation()); + } + _this->_impl_.rmrsource_ = from._impl_.rmrsource_; + // @@protoc_insertion_point(copy_constructor:proto.Message.RequestMediaUploadResponseMessage) +} + +inline void Message_RequestMediaUploadResponseMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.reuploadresult_){arena} + , decltype(_impl_.stanzaid_){} + , decltype(_impl_.rmrsource_){0} + }; + _impl_.stanzaid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.stanzaid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_RequestMediaUploadResponseMessage::~Message_RequestMediaUploadResponseMessage() { + // @@protoc_insertion_point(destructor:proto.Message.RequestMediaUploadResponseMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_RequestMediaUploadResponseMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.reuploadresult_.~RepeatedPtrField(); + _impl_.stanzaid_.Destroy(); +} + +void Message_RequestMediaUploadResponseMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_RequestMediaUploadResponseMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.RequestMediaUploadResponseMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.reuploadresult_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.stanzaid_.ClearNonDefaultToEmpty(); + } + _impl_.rmrsource_ = 0; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_RequestMediaUploadResponseMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.Message.RmrSource rmrSource = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::Message_RmrSource_IsValid(val))) { + _internal_set_rmrsource(static_cast<::proto::Message_RmrSource>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional string stanzaId = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_stanzaid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.RequestMediaUploadResponseMessage.stanzaId"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // repeated .proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult reuploadResult = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_reuploadresult(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_RequestMediaUploadResponseMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.RequestMediaUploadResponseMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.Message.RmrSource rmrSource = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this->_internal_rmrsource(), target); + } + + // optional string stanzaId = 2; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_stanzaid().data(), static_cast(this->_internal_stanzaid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.RequestMediaUploadResponseMessage.stanzaId"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_stanzaid(), target); + } + + // repeated .proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult reuploadResult = 3; + for (unsigned i = 0, + n = static_cast(this->_internal_reuploadresult_size()); i < n; i++) { + const auto& repfield = this->_internal_reuploadresult(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.RequestMediaUploadResponseMessage) + return target; +} + +size_t Message_RequestMediaUploadResponseMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.RequestMediaUploadResponseMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult reuploadResult = 3; + total_size += 1UL * this->_internal_reuploadresult_size(); + for (const auto& msg : this->_impl_.reuploadresult_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional string stanzaId = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_stanzaid()); + } + + // optional .proto.Message.RmrSource rmrSource = 1; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_rmrsource()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_RequestMediaUploadResponseMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_RequestMediaUploadResponseMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_RequestMediaUploadResponseMessage::GetClassData() const { return &_class_data_; } + + +void Message_RequestMediaUploadResponseMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.RequestMediaUploadResponseMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.reuploadresult_.MergeFrom(from._impl_.reuploadresult_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_stanzaid(from._internal_stanzaid()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.rmrsource_ = from._impl_.rmrsource_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_RequestMediaUploadResponseMessage::CopyFrom(const Message_RequestMediaUploadResponseMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.RequestMediaUploadResponseMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_RequestMediaUploadResponseMessage::IsInitialized() const { + return true; +} + +void Message_RequestMediaUploadResponseMessage::InternalSwap(Message_RequestMediaUploadResponseMessage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.reuploadresult_.InternalSwap(&other->_impl_.reuploadresult_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.stanzaid_, lhs_arena, + &other->_impl_.stanzaid_, rhs_arena + ); + swap(_impl_.rmrsource_, other->_impl_.rmrsource_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_RequestMediaUploadResponseMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[125]); +} + +// =================================================================== + +class Message_RequestPaymentMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::Message& notemessage(const Message_RequestPaymentMessage* msg); + static void set_has_notemessage(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_currencycodeiso4217(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_amount1000(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_requestfrom(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_expirytimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static const ::proto::Money& amount(const Message_RequestPaymentMessage* msg); + static void set_has_amount(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static const ::proto::PaymentBackground& background(const Message_RequestPaymentMessage* msg); + static void set_has_background(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } +}; + +const ::proto::Message& +Message_RequestPaymentMessage::_Internal::notemessage(const Message_RequestPaymentMessage* msg) { + return *msg->_impl_.notemessage_; +} +const ::proto::Money& +Message_RequestPaymentMessage::_Internal::amount(const Message_RequestPaymentMessage* msg) { + return *msg->_impl_.amount_; +} +const ::proto::PaymentBackground& +Message_RequestPaymentMessage::_Internal::background(const Message_RequestPaymentMessage* msg) { + return *msg->_impl_.background_; +} +Message_RequestPaymentMessage::Message_RequestPaymentMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.RequestPaymentMessage) +} +Message_RequestPaymentMessage::Message_RequestPaymentMessage(const Message_RequestPaymentMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_RequestPaymentMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.currencycodeiso4217_){} + , decltype(_impl_.requestfrom_){} + , decltype(_impl_.notemessage_){nullptr} + , decltype(_impl_.amount_){nullptr} + , decltype(_impl_.background_){nullptr} + , decltype(_impl_.amount1000_){} + , decltype(_impl_.expirytimestamp_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.currencycodeiso4217_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.currencycodeiso4217_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_currencycodeiso4217()) { + _this->_impl_.currencycodeiso4217_.Set(from._internal_currencycodeiso4217(), + _this->GetArenaForAllocation()); + } + _impl_.requestfrom_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.requestfrom_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_requestfrom()) { + _this->_impl_.requestfrom_.Set(from._internal_requestfrom(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_notemessage()) { + _this->_impl_.notemessage_ = new ::proto::Message(*from._impl_.notemessage_); + } + if (from._internal_has_amount()) { + _this->_impl_.amount_ = new ::proto::Money(*from._impl_.amount_); + } + if (from._internal_has_background()) { + _this->_impl_.background_ = new ::proto::PaymentBackground(*from._impl_.background_); + } + ::memcpy(&_impl_.amount1000_, &from._impl_.amount1000_, + static_cast(reinterpret_cast(&_impl_.expirytimestamp_) - + reinterpret_cast(&_impl_.amount1000_)) + sizeof(_impl_.expirytimestamp_)); + // @@protoc_insertion_point(copy_constructor:proto.Message.RequestPaymentMessage) +} + +inline void Message_RequestPaymentMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.currencycodeiso4217_){} + , decltype(_impl_.requestfrom_){} + , decltype(_impl_.notemessage_){nullptr} + , decltype(_impl_.amount_){nullptr} + , decltype(_impl_.background_){nullptr} + , decltype(_impl_.amount1000_){uint64_t{0u}} + , decltype(_impl_.expirytimestamp_){int64_t{0}} + }; + _impl_.currencycodeiso4217_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.currencycodeiso4217_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.requestfrom_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.requestfrom_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_RequestPaymentMessage::~Message_RequestPaymentMessage() { + // @@protoc_insertion_point(destructor:proto.Message.RequestPaymentMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_RequestPaymentMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.currencycodeiso4217_.Destroy(); + _impl_.requestfrom_.Destroy(); + if (this != internal_default_instance()) delete _impl_.notemessage_; + if (this != internal_default_instance()) delete _impl_.amount_; + if (this != internal_default_instance()) delete _impl_.background_; +} + +void Message_RequestPaymentMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_RequestPaymentMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.RequestPaymentMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _impl_.currencycodeiso4217_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.requestfrom_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.notemessage_ != nullptr); + _impl_.notemessage_->Clear(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(_impl_.amount_ != nullptr); + _impl_.amount_->Clear(); + } + if (cached_has_bits & 0x00000010u) { + GOOGLE_DCHECK(_impl_.background_ != nullptr); + _impl_.background_->Clear(); + } + } + if (cached_has_bits & 0x00000060u) { + ::memset(&_impl_.amount1000_, 0, static_cast( + reinterpret_cast(&_impl_.expirytimestamp_) - + reinterpret_cast(&_impl_.amount1000_)) + sizeof(_impl_.expirytimestamp_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_RequestPaymentMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string currencyCodeIso4217 = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_currencycodeiso4217(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.RequestPaymentMessage.currencyCodeIso4217"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional uint64 amount1000 = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_amount1000(&has_bits); + _impl_.amount1000_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string requestFrom = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_requestfrom(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.RequestPaymentMessage.requestFrom"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.Message noteMessage = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_notemessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 expiryTimestamp = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_expirytimestamp(&has_bits); + _impl_.expirytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Money amount = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_amount(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.PaymentBackground background = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_background(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_RequestPaymentMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.RequestPaymentMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string currencyCodeIso4217 = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_currencycodeiso4217().data(), static_cast(this->_internal_currencycodeiso4217().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.RequestPaymentMessage.currencyCodeIso4217"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_currencycodeiso4217(), target); + } + + // optional uint64 amount1000 = 2; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_amount1000(), target); + } + + // optional string requestFrom = 3; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_requestfrom().data(), static_cast(this->_internal_requestfrom().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.RequestPaymentMessage.requestFrom"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_requestfrom(), target); + } + + // optional .proto.Message noteMessage = 4; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, _Internal::notemessage(this), + _Internal::notemessage(this).GetCachedSize(), target, stream); + } + + // optional int64 expiryTimestamp = 5; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(5, this->_internal_expirytimestamp(), target); + } + + // optional .proto.Money amount = 6; + if (cached_has_bits & 0x00000008u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(6, _Internal::amount(this), + _Internal::amount(this).GetCachedSize(), target, stream); + } + + // optional .proto.PaymentBackground background = 7; + if (cached_has_bits & 0x00000010u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(7, _Internal::background(this), + _Internal::background(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.RequestPaymentMessage) + return target; +} + +size_t Message_RequestPaymentMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.RequestPaymentMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + // optional string currencyCodeIso4217 = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_currencycodeiso4217()); + } + + // optional string requestFrom = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_requestfrom()); + } + + // optional .proto.Message noteMessage = 4; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.notemessage_); + } + + // optional .proto.Money amount = 6; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.amount_); + } + + // optional .proto.PaymentBackground background = 7; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.background_); + } + + // optional uint64 amount1000 = 2; + if (cached_has_bits & 0x00000020u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_amount1000()); + } + + // optional int64 expiryTimestamp = 5; + if (cached_has_bits & 0x00000040u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_expirytimestamp()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_RequestPaymentMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_RequestPaymentMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_RequestPaymentMessage::GetClassData() const { return &_class_data_; } + + +void Message_RequestPaymentMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.RequestPaymentMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_currencycodeiso4217(from._internal_currencycodeiso4217()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_requestfrom(from._internal_requestfrom()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_notemessage()->::proto::Message::MergeFrom( + from._internal_notemessage()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_mutable_amount()->::proto::Money::MergeFrom( + from._internal_amount()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_mutable_background()->::proto::PaymentBackground::MergeFrom( + from._internal_background()); + } + if (cached_has_bits & 0x00000020u) { + _this->_impl_.amount1000_ = from._impl_.amount1000_; + } + if (cached_has_bits & 0x00000040u) { + _this->_impl_.expirytimestamp_ = from._impl_.expirytimestamp_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_RequestPaymentMessage::CopyFrom(const Message_RequestPaymentMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.RequestPaymentMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_RequestPaymentMessage::IsInitialized() const { + return true; +} + +void Message_RequestPaymentMessage::InternalSwap(Message_RequestPaymentMessage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.currencycodeiso4217_, lhs_arena, + &other->_impl_.currencycodeiso4217_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.requestfrom_, lhs_arena, + &other->_impl_.requestfrom_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_RequestPaymentMessage, _impl_.expirytimestamp_) + + sizeof(Message_RequestPaymentMessage::_impl_.expirytimestamp_) + - PROTOBUF_FIELD_OFFSET(Message_RequestPaymentMessage, _impl_.notemessage_)>( + reinterpret_cast(&_impl_.notemessage_), + reinterpret_cast(&other->_impl_.notemessage_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_RequestPaymentMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[126]); +} + +// =================================================================== + +class Message_RequestPhoneNumberMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::ContextInfo& contextinfo(const Message_RequestPhoneNumberMessage* msg); + static void set_has_contextinfo(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +const ::proto::ContextInfo& +Message_RequestPhoneNumberMessage::_Internal::contextinfo(const Message_RequestPhoneNumberMessage* msg) { + return *msg->_impl_.contextinfo_; +} +Message_RequestPhoneNumberMessage::Message_RequestPhoneNumberMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.RequestPhoneNumberMessage) +} +Message_RequestPhoneNumberMessage::Message_RequestPhoneNumberMessage(const Message_RequestPhoneNumberMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_RequestPhoneNumberMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.contextinfo_){nullptr}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_contextinfo()) { + _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); + } + // @@protoc_insertion_point(copy_constructor:proto.Message.RequestPhoneNumberMessage) +} + +inline void Message_RequestPhoneNumberMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.contextinfo_){nullptr} + }; +} + +Message_RequestPhoneNumberMessage::~Message_RequestPhoneNumberMessage() { + // @@protoc_insertion_point(destructor:proto.Message.RequestPhoneNumberMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_RequestPhoneNumberMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.contextinfo_; +} + +void Message_RequestPhoneNumberMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_RequestPhoneNumberMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.RequestPhoneNumberMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); + _impl_.contextinfo_->Clear(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_RequestPhoneNumberMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.ContextInfo contextInfo = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_RequestPhoneNumberMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.RequestPhoneNumberMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.ContextInfo contextInfo = 1; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::contextinfo(this), + _Internal::contextinfo(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.RequestPhoneNumberMessage) + return target; +} + +size_t Message_RequestPhoneNumberMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.RequestPhoneNumberMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional .proto.ContextInfo contextInfo = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.contextinfo_); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_RequestPhoneNumberMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_RequestPhoneNumberMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_RequestPhoneNumberMessage::GetClassData() const { return &_class_data_; } + + +void Message_RequestPhoneNumberMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.RequestPhoneNumberMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_contextinfo()) { + _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( + from._internal_contextinfo()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_RequestPhoneNumberMessage::CopyFrom(const Message_RequestPhoneNumberMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.RequestPhoneNumberMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_RequestPhoneNumberMessage::IsInitialized() const { + return true; +} + +void Message_RequestPhoneNumberMessage::InternalSwap(Message_RequestPhoneNumberMessage* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_.contextinfo_, other->_impl_.contextinfo_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_RequestPhoneNumberMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[127]); +} + +// =================================================================== + +class Message_SendPaymentMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::Message& notemessage(const Message_SendPaymentMessage* msg); + static void set_has_notemessage(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::proto::MessageKey& requestmessagekey(const Message_SendPaymentMessage* msg); + static void set_has_requestmessagekey(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::proto::PaymentBackground& background(const Message_SendPaymentMessage* msg); + static void set_has_background(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +const ::proto::Message& +Message_SendPaymentMessage::_Internal::notemessage(const Message_SendPaymentMessage* msg) { + return *msg->_impl_.notemessage_; +} +const ::proto::MessageKey& +Message_SendPaymentMessage::_Internal::requestmessagekey(const Message_SendPaymentMessage* msg) { + return *msg->_impl_.requestmessagekey_; +} +const ::proto::PaymentBackground& +Message_SendPaymentMessage::_Internal::background(const Message_SendPaymentMessage* msg) { + return *msg->_impl_.background_; +} +Message_SendPaymentMessage::Message_SendPaymentMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.SendPaymentMessage) +} +Message_SendPaymentMessage::Message_SendPaymentMessage(const Message_SendPaymentMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_SendPaymentMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.notemessage_){nullptr} + , decltype(_impl_.requestmessagekey_){nullptr} + , decltype(_impl_.background_){nullptr}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_notemessage()) { + _this->_impl_.notemessage_ = new ::proto::Message(*from._impl_.notemessage_); + } + if (from._internal_has_requestmessagekey()) { + _this->_impl_.requestmessagekey_ = new ::proto::MessageKey(*from._impl_.requestmessagekey_); + } + if (from._internal_has_background()) { + _this->_impl_.background_ = new ::proto::PaymentBackground(*from._impl_.background_); + } + // @@protoc_insertion_point(copy_constructor:proto.Message.SendPaymentMessage) +} + +inline void Message_SendPaymentMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.notemessage_){nullptr} + , decltype(_impl_.requestmessagekey_){nullptr} + , decltype(_impl_.background_){nullptr} + }; +} + +Message_SendPaymentMessage::~Message_SendPaymentMessage() { + // @@protoc_insertion_point(destructor:proto.Message.SendPaymentMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_SendPaymentMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.notemessage_; + if (this != internal_default_instance()) delete _impl_.requestmessagekey_; + if (this != internal_default_instance()) delete _impl_.background_; +} + +void Message_SendPaymentMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_SendPaymentMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.SendPaymentMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.notemessage_ != nullptr); + _impl_.notemessage_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.requestmessagekey_ != nullptr); + _impl_.requestmessagekey_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.background_ != nullptr); + _impl_.background_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_SendPaymentMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.Message noteMessage = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_notemessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.MessageKey requestMessageKey = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_requestmessagekey(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.PaymentBackground background = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_background(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_SendPaymentMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.SendPaymentMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.Message noteMessage = 2; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::notemessage(this), + _Internal::notemessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.MessageKey requestMessageKey = 3; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::requestmessagekey(this), + _Internal::requestmessagekey(this).GetCachedSize(), target, stream); + } + + // optional .proto.PaymentBackground background = 4; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, _Internal::background(this), + _Internal::background(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.SendPaymentMessage) + return target; +} + +size_t Message_SendPaymentMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.SendPaymentMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional .proto.Message noteMessage = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.notemessage_); + } + + // optional .proto.MessageKey requestMessageKey = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.requestmessagekey_); + } + + // optional .proto.PaymentBackground background = 4; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.background_); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_SendPaymentMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_SendPaymentMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_SendPaymentMessage::GetClassData() const { return &_class_data_; } + + +void Message_SendPaymentMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.SendPaymentMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_notemessage()->::proto::Message::MergeFrom( + from._internal_notemessage()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_requestmessagekey()->::proto::MessageKey::MergeFrom( + from._internal_requestmessagekey()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_background()->::proto::PaymentBackground::MergeFrom( + from._internal_background()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_SendPaymentMessage::CopyFrom(const Message_SendPaymentMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.SendPaymentMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_SendPaymentMessage::IsInitialized() const { + return true; +} + +void Message_SendPaymentMessage::InternalSwap(Message_SendPaymentMessage* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_SendPaymentMessage, _impl_.background_) + + sizeof(Message_SendPaymentMessage::_impl_.background_) + - PROTOBUF_FIELD_OFFSET(Message_SendPaymentMessage, _impl_.notemessage_)>( + reinterpret_cast(&_impl_.notemessage_), + reinterpret_cast(&other->_impl_.notemessage_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_SendPaymentMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[128]); +} + +// =================================================================== + +class Message_SenderKeyDistributionMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_groupid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_axolotlsenderkeydistributionmessage(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +Message_SenderKeyDistributionMessage::Message_SenderKeyDistributionMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.SenderKeyDistributionMessage) +} +Message_SenderKeyDistributionMessage::Message_SenderKeyDistributionMessage(const Message_SenderKeyDistributionMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_SenderKeyDistributionMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.groupid_){} + , decltype(_impl_.axolotlsenderkeydistributionmessage_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.groupid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.groupid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_groupid()) { + _this->_impl_.groupid_.Set(from._internal_groupid(), + _this->GetArenaForAllocation()); + } + _impl_.axolotlsenderkeydistributionmessage_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.axolotlsenderkeydistributionmessage_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_axolotlsenderkeydistributionmessage()) { + _this->_impl_.axolotlsenderkeydistributionmessage_.Set(from._internal_axolotlsenderkeydistributionmessage(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.Message.SenderKeyDistributionMessage) +} + +inline void Message_SenderKeyDistributionMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.groupid_){} + , decltype(_impl_.axolotlsenderkeydistributionmessage_){} + }; + _impl_.groupid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.groupid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.axolotlsenderkeydistributionmessage_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.axolotlsenderkeydistributionmessage_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_SenderKeyDistributionMessage::~Message_SenderKeyDistributionMessage() { + // @@protoc_insertion_point(destructor:proto.Message.SenderKeyDistributionMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_SenderKeyDistributionMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.groupid_.Destroy(); + _impl_.axolotlsenderkeydistributionmessage_.Destroy(); +} + +void Message_SenderKeyDistributionMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_SenderKeyDistributionMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.SenderKeyDistributionMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.groupid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.axolotlsenderkeydistributionmessage_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_SenderKeyDistributionMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string groupId = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_groupid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.SenderKeyDistributionMessage.groupId"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bytes axolotlSenderKeyDistributionMessage = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_axolotlsenderkeydistributionmessage(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_SenderKeyDistributionMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.SenderKeyDistributionMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string groupId = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_groupid().data(), static_cast(this->_internal_groupid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.SenderKeyDistributionMessage.groupId"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_groupid(), target); + } + + // optional bytes axolotlSenderKeyDistributionMessage = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_axolotlsenderkeydistributionmessage(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.SenderKeyDistributionMessage) + return target; +} + +size_t Message_SenderKeyDistributionMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.SenderKeyDistributionMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional string groupId = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_groupid()); + } + + // optional bytes axolotlSenderKeyDistributionMessage = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_axolotlsenderkeydistributionmessage()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_SenderKeyDistributionMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_SenderKeyDistributionMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_SenderKeyDistributionMessage::GetClassData() const { return &_class_data_; } + + +void Message_SenderKeyDistributionMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.SenderKeyDistributionMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_groupid(from._internal_groupid()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_axolotlsenderkeydistributionmessage(from._internal_axolotlsenderkeydistributionmessage()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_SenderKeyDistributionMessage::CopyFrom(const Message_SenderKeyDistributionMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.SenderKeyDistributionMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_SenderKeyDistributionMessage::IsInitialized() const { + return true; +} + +void Message_SenderKeyDistributionMessage::InternalSwap(Message_SenderKeyDistributionMessage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.groupid_, lhs_arena, + &other->_impl_.groupid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.axolotlsenderkeydistributionmessage_, lhs_arena, + &other->_impl_.axolotlsenderkeydistributionmessage_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_SenderKeyDistributionMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[129]); +} + +// =================================================================== + +class Message_StickerMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_url(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_filesha256(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_fileencsha256(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_mediakey(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_mimetype(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_height(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_width(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static void set_has_directpath(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_filelength(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static void set_has_mediakeytimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 4096u; + } + static void set_has_firstframelength(HasBits* has_bits) { + (*has_bits)[0] |= 8192u; + } + static void set_has_firstframesidecar(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_isanimated(HasBits* has_bits) { + (*has_bits)[0] |= 16384u; + } + static void set_has_pngthumbnail(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static const ::proto::ContextInfo& contextinfo(const Message_StickerMessage* msg); + static void set_has_contextinfo(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } +}; + +const ::proto::ContextInfo& +Message_StickerMessage::_Internal::contextinfo(const Message_StickerMessage* msg) { + return *msg->_impl_.contextinfo_; +} +Message_StickerMessage::Message_StickerMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.StickerMessage) +} +Message_StickerMessage::Message_StickerMessage(const Message_StickerMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_StickerMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.url_){} + , decltype(_impl_.filesha256_){} + , decltype(_impl_.fileencsha256_){} + , decltype(_impl_.mediakey_){} + , decltype(_impl_.mimetype_){} + , decltype(_impl_.directpath_){} + , decltype(_impl_.firstframesidecar_){} + , decltype(_impl_.pngthumbnail_){} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.height_){} + , decltype(_impl_.width_){} + , decltype(_impl_.filelength_){} + , decltype(_impl_.mediakeytimestamp_){} + , decltype(_impl_.firstframelength_){} + , decltype(_impl_.isanimated_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.url_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.url_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_url()) { + _this->_impl_.url_.Set(from._internal_url(), + _this->GetArenaForAllocation()); + } + _impl_.filesha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filesha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_filesha256()) { + _this->_impl_.filesha256_.Set(from._internal_filesha256(), + _this->GetArenaForAllocation()); + } + _impl_.fileencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_fileencsha256()) { + _this->_impl_.fileencsha256_.Set(from._internal_fileencsha256(), + _this->GetArenaForAllocation()); + } + _impl_.mediakey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediakey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_mediakey()) { + _this->_impl_.mediakey_.Set(from._internal_mediakey(), + _this->GetArenaForAllocation()); + } + _impl_.mimetype_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mimetype_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_mimetype()) { + _this->_impl_.mimetype_.Set(from._internal_mimetype(), + _this->GetArenaForAllocation()); + } + _impl_.directpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_directpath()) { + _this->_impl_.directpath_.Set(from._internal_directpath(), + _this->GetArenaForAllocation()); + } + _impl_.firstframesidecar_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.firstframesidecar_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_firstframesidecar()) { + _this->_impl_.firstframesidecar_.Set(from._internal_firstframesidecar(), + _this->GetArenaForAllocation()); + } + _impl_.pngthumbnail_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.pngthumbnail_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_pngthumbnail()) { + _this->_impl_.pngthumbnail_.Set(from._internal_pngthumbnail(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_contextinfo()) { + _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); + } + ::memcpy(&_impl_.height_, &from._impl_.height_, + static_cast(reinterpret_cast(&_impl_.isanimated_) - + reinterpret_cast(&_impl_.height_)) + sizeof(_impl_.isanimated_)); + // @@protoc_insertion_point(copy_constructor:proto.Message.StickerMessage) +} + +inline void Message_StickerMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.url_){} + , decltype(_impl_.filesha256_){} + , decltype(_impl_.fileencsha256_){} + , decltype(_impl_.mediakey_){} + , decltype(_impl_.mimetype_){} + , decltype(_impl_.directpath_){} + , decltype(_impl_.firstframesidecar_){} + , decltype(_impl_.pngthumbnail_){} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.height_){0u} + , decltype(_impl_.width_){0u} + , decltype(_impl_.filelength_){uint64_t{0u}} + , decltype(_impl_.mediakeytimestamp_){int64_t{0}} + , decltype(_impl_.firstframelength_){0u} + , decltype(_impl_.isanimated_){false} + }; + _impl_.url_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.url_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filesha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filesha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fileencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediakey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediakey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mimetype_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mimetype_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.firstframesidecar_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.firstframesidecar_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.pngthumbnail_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.pngthumbnail_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_StickerMessage::~Message_StickerMessage() { + // @@protoc_insertion_point(destructor:proto.Message.StickerMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_StickerMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.url_.Destroy(); + _impl_.filesha256_.Destroy(); + _impl_.fileencsha256_.Destroy(); + _impl_.mediakey_.Destroy(); + _impl_.mimetype_.Destroy(); + _impl_.directpath_.Destroy(); + _impl_.firstframesidecar_.Destroy(); + _impl_.pngthumbnail_.Destroy(); + if (this != internal_default_instance()) delete _impl_.contextinfo_; +} + +void Message_StickerMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_StickerMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.StickerMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _impl_.url_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.filesha256_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.fileencsha256_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + _impl_.mediakey_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + _impl_.mimetype_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000020u) { + _impl_.directpath_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000040u) { + _impl_.firstframesidecar_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000080u) { + _impl_.pngthumbnail_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x00000100u) { + GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); + _impl_.contextinfo_->Clear(); + } + if (cached_has_bits & 0x00007e00u) { + ::memset(&_impl_.height_, 0, static_cast( + reinterpret_cast(&_impl_.isanimated_) - + reinterpret_cast(&_impl_.height_)) + sizeof(_impl_.isanimated_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_StickerMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string url = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_url(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.StickerMessage.url"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bytes fileSha256 = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_filesha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes fileEncSha256 = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_fileencsha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes mediaKey = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_mediakey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string mimetype = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + auto str = _internal_mutable_mimetype(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.StickerMessage.mimetype"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional uint32 height = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + _Internal::set_has_height(&has_bits); + _impl_.height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 width = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + _Internal::set_has_width(&has_bits); + _impl_.width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string directPath = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + auto str = _internal_mutable_directpath(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.StickerMessage.directPath"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional uint64 fileLength = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { + _Internal::set_has_filelength(&has_bits); + _impl_.filelength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 mediaKeyTimestamp = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { + _Internal::set_has_mediakeytimestamp(&has_bits); + _impl_.mediakeytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 firstFrameLength = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { + _Internal::set_has_firstframelength(&has_bits); + _impl_.firstframelength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes firstFrameSidecar = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { + auto str = _internal_mutable_firstframesidecar(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool isAnimated = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 104)) { + _Internal::set_has_isanimated(&has_bits); + _impl_.isanimated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes pngThumbnail = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { + auto str = _internal_mutable_pngthumbnail(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.ContextInfo contextInfo = 17; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { + ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_StickerMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.StickerMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string url = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_url().data(), static_cast(this->_internal_url().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.StickerMessage.url"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_url(), target); + } + + // optional bytes fileSha256 = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_filesha256(), target); + } + + // optional bytes fileEncSha256 = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->WriteBytesMaybeAliased( + 3, this->_internal_fileencsha256(), target); + } + + // optional bytes mediaKey = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->WriteBytesMaybeAliased( + 4, this->_internal_mediakey(), target); + } + + // optional string mimetype = 5; + if (cached_has_bits & 0x00000010u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_mimetype().data(), static_cast(this->_internal_mimetype().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.StickerMessage.mimetype"); + target = stream->WriteStringMaybeAliased( + 5, this->_internal_mimetype(), target); + } + + // optional uint32 height = 6; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_height(), target); + } + + // optional uint32 width = 7; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(7, this->_internal_width(), target); + } + + // optional string directPath = 8; + if (cached_has_bits & 0x00000020u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_directpath().data(), static_cast(this->_internal_directpath().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.StickerMessage.directPath"); + target = stream->WriteStringMaybeAliased( + 8, this->_internal_directpath(), target); + } + + // optional uint64 fileLength = 9; + if (cached_has_bits & 0x00000800u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(9, this->_internal_filelength(), target); + } + + // optional int64 mediaKeyTimestamp = 10; + if (cached_has_bits & 0x00001000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(10, this->_internal_mediakeytimestamp(), target); + } + + // optional uint32 firstFrameLength = 11; + if (cached_has_bits & 0x00002000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(11, this->_internal_firstframelength(), target); + } + + // optional bytes firstFrameSidecar = 12; + if (cached_has_bits & 0x00000040u) { + target = stream->WriteBytesMaybeAliased( + 12, this->_internal_firstframesidecar(), target); + } + + // optional bool isAnimated = 13; + if (cached_has_bits & 0x00004000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(13, this->_internal_isanimated(), target); + } + + // optional bytes pngThumbnail = 16; + if (cached_has_bits & 0x00000080u) { + target = stream->WriteBytesMaybeAliased( + 16, this->_internal_pngthumbnail(), target); + } + + // optional .proto.ContextInfo contextInfo = 17; + if (cached_has_bits & 0x00000100u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(17, _Internal::contextinfo(this), + _Internal::contextinfo(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.StickerMessage) + return target; +} + +size_t Message_StickerMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.StickerMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string url = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_url()); + } + + // optional bytes fileSha256 = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_filesha256()); + } + + // optional bytes fileEncSha256 = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_fileencsha256()); + } + + // optional bytes mediaKey = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_mediakey()); + } + + // optional string mimetype = 5; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_mimetype()); + } + + // optional string directPath = 8; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_directpath()); + } + + // optional bytes firstFrameSidecar = 12; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_firstframesidecar()); + } + + // optional bytes pngThumbnail = 16; + if (cached_has_bits & 0x00000080u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_pngthumbnail()); + } + + } + if (cached_has_bits & 0x00007f00u) { + // optional .proto.ContextInfo contextInfo = 17; + if (cached_has_bits & 0x00000100u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.contextinfo_); + } + + // optional uint32 height = 6; + if (cached_has_bits & 0x00000200u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_height()); + } + + // optional uint32 width = 7; + if (cached_has_bits & 0x00000400u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_width()); + } + + // optional uint64 fileLength = 9; + if (cached_has_bits & 0x00000800u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_filelength()); + } + + // optional int64 mediaKeyTimestamp = 10; + if (cached_has_bits & 0x00001000u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_mediakeytimestamp()); + } + + // optional uint32 firstFrameLength = 11; + if (cached_has_bits & 0x00002000u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_firstframelength()); + } + + // optional bool isAnimated = 13; + if (cached_has_bits & 0x00004000u) { + total_size += 1 + 1; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_StickerMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_StickerMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_StickerMessage::GetClassData() const { return &_class_data_; } + + +void Message_StickerMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.StickerMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_url(from._internal_url()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_filesha256(from._internal_filesha256()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_fileencsha256(from._internal_fileencsha256()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_set_mediakey(from._internal_mediakey()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_set_mimetype(from._internal_mimetype()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_set_directpath(from._internal_directpath()); + } + if (cached_has_bits & 0x00000040u) { + _this->_internal_set_firstframesidecar(from._internal_firstframesidecar()); + } + if (cached_has_bits & 0x00000080u) { + _this->_internal_set_pngthumbnail(from._internal_pngthumbnail()); + } + } + if (cached_has_bits & 0x00007f00u) { + if (cached_has_bits & 0x00000100u) { + _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( + from._internal_contextinfo()); + } + if (cached_has_bits & 0x00000200u) { + _this->_impl_.height_ = from._impl_.height_; + } + if (cached_has_bits & 0x00000400u) { + _this->_impl_.width_ = from._impl_.width_; + } + if (cached_has_bits & 0x00000800u) { + _this->_impl_.filelength_ = from._impl_.filelength_; + } + if (cached_has_bits & 0x00001000u) { + _this->_impl_.mediakeytimestamp_ = from._impl_.mediakeytimestamp_; + } + if (cached_has_bits & 0x00002000u) { + _this->_impl_.firstframelength_ = from._impl_.firstframelength_; + } + if (cached_has_bits & 0x00004000u) { + _this->_impl_.isanimated_ = from._impl_.isanimated_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_StickerMessage::CopyFrom(const Message_StickerMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.StickerMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_StickerMessage::IsInitialized() const { + return true; +} + +void Message_StickerMessage::InternalSwap(Message_StickerMessage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.url_, lhs_arena, + &other->_impl_.url_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.filesha256_, lhs_arena, + &other->_impl_.filesha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.fileencsha256_, lhs_arena, + &other->_impl_.fileencsha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.mediakey_, lhs_arena, + &other->_impl_.mediakey_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.mimetype_, lhs_arena, + &other->_impl_.mimetype_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.directpath_, lhs_arena, + &other->_impl_.directpath_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.firstframesidecar_, lhs_arena, + &other->_impl_.firstframesidecar_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.pngthumbnail_, lhs_arena, + &other->_impl_.pngthumbnail_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_StickerMessage, _impl_.isanimated_) + + sizeof(Message_StickerMessage::_impl_.isanimated_) + - PROTOBUF_FIELD_OFFSET(Message_StickerMessage, _impl_.contextinfo_)>( + reinterpret_cast(&_impl_.contextinfo_), + reinterpret_cast(&other->_impl_.contextinfo_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_StickerMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[130]); +} + +// =================================================================== + +class Message_StickerSyncRMRMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_rmrsource(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_requesttimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +Message_StickerSyncRMRMessage::Message_StickerSyncRMRMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.StickerSyncRMRMessage) +} +Message_StickerSyncRMRMessage::Message_StickerSyncRMRMessage(const Message_StickerSyncRMRMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_StickerSyncRMRMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.filehash_){from._impl_.filehash_} + , decltype(_impl_.rmrsource_){} + , decltype(_impl_.requesttimestamp_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.rmrsource_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.rmrsource_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_rmrsource()) { + _this->_impl_.rmrsource_.Set(from._internal_rmrsource(), + _this->GetArenaForAllocation()); + } + _this->_impl_.requesttimestamp_ = from._impl_.requesttimestamp_; + // @@protoc_insertion_point(copy_constructor:proto.Message.StickerSyncRMRMessage) +} + +inline void Message_StickerSyncRMRMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.filehash_){arena} + , decltype(_impl_.rmrsource_){} + , decltype(_impl_.requesttimestamp_){int64_t{0}} + }; + _impl_.rmrsource_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.rmrsource_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_StickerSyncRMRMessage::~Message_StickerSyncRMRMessage() { + // @@protoc_insertion_point(destructor:proto.Message.StickerSyncRMRMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_StickerSyncRMRMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.filehash_.~RepeatedPtrField(); + _impl_.rmrsource_.Destroy(); +} + +void Message_StickerSyncRMRMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_StickerSyncRMRMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.StickerSyncRMRMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.filehash_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.rmrsource_.ClearNonDefaultToEmpty(); + } + _impl_.requesttimestamp_ = int64_t{0}; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_StickerSyncRMRMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated string filehash = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_filehash(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.StickerSyncRMRMessage.filehash"); + #endif // !NDEBUG + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else + goto handle_unusual; + continue; + // optional string rmrSource = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_rmrsource(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.StickerSyncRMRMessage.rmrSource"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional int64 requestTimestamp = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_requesttimestamp(&has_bits); + _impl_.requesttimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_StickerSyncRMRMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.StickerSyncRMRMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated string filehash = 1; + for (int i = 0, n = this->_internal_filehash_size(); i < n; i++) { + const auto& s = this->_internal_filehash(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.StickerSyncRMRMessage.filehash"); + target = stream->WriteString(1, s, target); + } + + cached_has_bits = _impl_._has_bits_[0]; + // optional string rmrSource = 2; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_rmrsource().data(), static_cast(this->_internal_rmrsource().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.StickerSyncRMRMessage.rmrSource"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_rmrsource(), target); + } + + // optional int64 requestTimestamp = 3; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_requesttimestamp(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.StickerSyncRMRMessage) + return target; +} + +size_t Message_StickerSyncRMRMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.StickerSyncRMRMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string filehash = 1; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.filehash_.size()); + for (int i = 0, n = _impl_.filehash_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + _impl_.filehash_.Get(i)); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional string rmrSource = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_rmrsource()); + } + + // optional int64 requestTimestamp = 3; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_requesttimestamp()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_StickerSyncRMRMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_StickerSyncRMRMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_StickerSyncRMRMessage::GetClassData() const { return &_class_data_; } + + +void Message_StickerSyncRMRMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.StickerSyncRMRMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.filehash_.MergeFrom(from._impl_.filehash_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_rmrsource(from._internal_rmrsource()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.requesttimestamp_ = from._impl_.requesttimestamp_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_StickerSyncRMRMessage::CopyFrom(const Message_StickerSyncRMRMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.StickerSyncRMRMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_StickerSyncRMRMessage::IsInitialized() const { + return true; +} + +void Message_StickerSyncRMRMessage::InternalSwap(Message_StickerSyncRMRMessage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.filehash_.InternalSwap(&other->_impl_.filehash_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.rmrsource_, lhs_arena, + &other->_impl_.rmrsource_, rhs_arena + ); + swap(_impl_.requesttimestamp_, other->_impl_.requesttimestamp_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_StickerSyncRMRMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[131]); +} + +// =================================================================== + +class Message_TemplateButtonReplyMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_selectedid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_selecteddisplaytext(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::proto::ContextInfo& contextinfo(const Message_TemplateButtonReplyMessage* msg); + static void set_has_contextinfo(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_selectedindex(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +const ::proto::ContextInfo& +Message_TemplateButtonReplyMessage::_Internal::contextinfo(const Message_TemplateButtonReplyMessage* msg) { + return *msg->_impl_.contextinfo_; +} +Message_TemplateButtonReplyMessage::Message_TemplateButtonReplyMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.TemplateButtonReplyMessage) +} +Message_TemplateButtonReplyMessage::Message_TemplateButtonReplyMessage(const Message_TemplateButtonReplyMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_TemplateButtonReplyMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.selectedid_){} + , decltype(_impl_.selecteddisplaytext_){} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.selectedindex_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.selectedid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.selectedid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_selectedid()) { + _this->_impl_.selectedid_.Set(from._internal_selectedid(), + _this->GetArenaForAllocation()); + } + _impl_.selecteddisplaytext_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.selecteddisplaytext_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_selecteddisplaytext()) { + _this->_impl_.selecteddisplaytext_.Set(from._internal_selecteddisplaytext(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_contextinfo()) { + _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); + } + _this->_impl_.selectedindex_ = from._impl_.selectedindex_; + // @@protoc_insertion_point(copy_constructor:proto.Message.TemplateButtonReplyMessage) +} + +inline void Message_TemplateButtonReplyMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.selectedid_){} + , decltype(_impl_.selecteddisplaytext_){} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.selectedindex_){0u} + }; + _impl_.selectedid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.selectedid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.selecteddisplaytext_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.selecteddisplaytext_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_TemplateButtonReplyMessage::~Message_TemplateButtonReplyMessage() { + // @@protoc_insertion_point(destructor:proto.Message.TemplateButtonReplyMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_TemplateButtonReplyMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.selectedid_.Destroy(); + _impl_.selecteddisplaytext_.Destroy(); + if (this != internal_default_instance()) delete _impl_.contextinfo_; +} + +void Message_TemplateButtonReplyMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_TemplateButtonReplyMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.TemplateButtonReplyMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _impl_.selectedid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.selecteddisplaytext_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); + _impl_.contextinfo_->Clear(); + } + } + _impl_.selectedindex_ = 0u; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_TemplateButtonReplyMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string selectedId = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_selectedid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.TemplateButtonReplyMessage.selectedId"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string selectedDisplayText = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_selecteddisplaytext(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.TemplateButtonReplyMessage.selectedDisplayText"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.ContextInfo contextInfo = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 selectedIndex = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_selectedindex(&has_bits); + _impl_.selectedindex_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_TemplateButtonReplyMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.TemplateButtonReplyMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string selectedId = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_selectedid().data(), static_cast(this->_internal_selectedid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.TemplateButtonReplyMessage.selectedId"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_selectedid(), target); + } + + // optional string selectedDisplayText = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_selecteddisplaytext().data(), static_cast(this->_internal_selecteddisplaytext().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.TemplateButtonReplyMessage.selectedDisplayText"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_selecteddisplaytext(), target); + } + + // optional .proto.ContextInfo contextInfo = 3; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::contextinfo(this), + _Internal::contextinfo(this).GetCachedSize(), target, stream); + } + + // optional uint32 selectedIndex = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_selectedindex(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.TemplateButtonReplyMessage) + return target; +} + +size_t Message_TemplateButtonReplyMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.TemplateButtonReplyMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional string selectedId = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_selectedid()); + } + + // optional string selectedDisplayText = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_selecteddisplaytext()); + } + + // optional .proto.ContextInfo contextInfo = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.contextinfo_); + } + + // optional uint32 selectedIndex = 4; + if (cached_has_bits & 0x00000008u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_selectedindex()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_TemplateButtonReplyMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_TemplateButtonReplyMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_TemplateButtonReplyMessage::GetClassData() const { return &_class_data_; } + + +void Message_TemplateButtonReplyMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.TemplateButtonReplyMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_selectedid(from._internal_selectedid()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_selecteddisplaytext(from._internal_selecteddisplaytext()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( + from._internal_contextinfo()); + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.selectedindex_ = from._impl_.selectedindex_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_TemplateButtonReplyMessage::CopyFrom(const Message_TemplateButtonReplyMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.TemplateButtonReplyMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_TemplateButtonReplyMessage::IsInitialized() const { + return true; +} + +void Message_TemplateButtonReplyMessage::InternalSwap(Message_TemplateButtonReplyMessage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.selectedid_, lhs_arena, + &other->_impl_.selectedid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.selecteddisplaytext_, lhs_arena, + &other->_impl_.selecteddisplaytext_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_TemplateButtonReplyMessage, _impl_.selectedindex_) + + sizeof(Message_TemplateButtonReplyMessage::_impl_.selectedindex_) + - PROTOBUF_FIELD_OFFSET(Message_TemplateButtonReplyMessage, _impl_.contextinfo_)>( + reinterpret_cast(&_impl_.contextinfo_), + reinterpret_cast(&other->_impl_.contextinfo_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_TemplateButtonReplyMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[132]); +} + +// =================================================================== + +class Message_TemplateMessage_FourRowTemplate::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::Message_HighlyStructuredMessage& content(const Message_TemplateMessage_FourRowTemplate* msg); + static void set_has_content(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::proto::Message_HighlyStructuredMessage& footer(const Message_TemplateMessage_FourRowTemplate* msg); + static void set_has_footer(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::proto::Message_DocumentMessage& documentmessage(const Message_TemplateMessage_FourRowTemplate* msg); + static const ::proto::Message_HighlyStructuredMessage& highlystructuredmessage(const Message_TemplateMessage_FourRowTemplate* msg); + static const ::proto::Message_ImageMessage& imagemessage(const Message_TemplateMessage_FourRowTemplate* msg); + static const ::proto::Message_VideoMessage& videomessage(const Message_TemplateMessage_FourRowTemplate* msg); + static const ::proto::Message_LocationMessage& locationmessage(const Message_TemplateMessage_FourRowTemplate* msg); +}; + +const ::proto::Message_HighlyStructuredMessage& +Message_TemplateMessage_FourRowTemplate::_Internal::content(const Message_TemplateMessage_FourRowTemplate* msg) { + return *msg->_impl_.content_; +} +const ::proto::Message_HighlyStructuredMessage& +Message_TemplateMessage_FourRowTemplate::_Internal::footer(const Message_TemplateMessage_FourRowTemplate* msg) { + return *msg->_impl_.footer_; +} +const ::proto::Message_DocumentMessage& +Message_TemplateMessage_FourRowTemplate::_Internal::documentmessage(const Message_TemplateMessage_FourRowTemplate* msg) { + return *msg->_impl_.title_.documentmessage_; +} +const ::proto::Message_HighlyStructuredMessage& +Message_TemplateMessage_FourRowTemplate::_Internal::highlystructuredmessage(const Message_TemplateMessage_FourRowTemplate* msg) { + return *msg->_impl_.title_.highlystructuredmessage_; +} +const ::proto::Message_ImageMessage& +Message_TemplateMessage_FourRowTemplate::_Internal::imagemessage(const Message_TemplateMessage_FourRowTemplate* msg) { + return *msg->_impl_.title_.imagemessage_; +} +const ::proto::Message_VideoMessage& +Message_TemplateMessage_FourRowTemplate::_Internal::videomessage(const Message_TemplateMessage_FourRowTemplate* msg) { + return *msg->_impl_.title_.videomessage_; +} +const ::proto::Message_LocationMessage& +Message_TemplateMessage_FourRowTemplate::_Internal::locationmessage(const Message_TemplateMessage_FourRowTemplate* msg) { + return *msg->_impl_.title_.locationmessage_; +} +void Message_TemplateMessage_FourRowTemplate::set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_title(); + if (documentmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(documentmessage); + if (message_arena != submessage_arena) { + documentmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, documentmessage, submessage_arena); + } + set_has_documentmessage(); + _impl_.title_.documentmessage_ = documentmessage; + } + // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.documentMessage) +} +void Message_TemplateMessage_FourRowTemplate::set_allocated_highlystructuredmessage(::proto::Message_HighlyStructuredMessage* highlystructuredmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_title(); + if (highlystructuredmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(highlystructuredmessage); + if (message_arena != submessage_arena) { + highlystructuredmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, highlystructuredmessage, submessage_arena); + } + set_has_highlystructuredmessage(); + _impl_.title_.highlystructuredmessage_ = highlystructuredmessage; + } + // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.highlyStructuredMessage) +} +void Message_TemplateMessage_FourRowTemplate::set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_title(); + if (imagemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(imagemessage); + if (message_arena != submessage_arena) { + imagemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, imagemessage, submessage_arena); + } + set_has_imagemessage(); + _impl_.title_.imagemessage_ = imagemessage; + } + // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.imageMessage) +} +void Message_TemplateMessage_FourRowTemplate::set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_title(); + if (videomessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(videomessage); + if (message_arena != submessage_arena) { + videomessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, videomessage, submessage_arena); + } + set_has_videomessage(); + _impl_.title_.videomessage_ = videomessage; + } + // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.videoMessage) +} +void Message_TemplateMessage_FourRowTemplate::set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_title(); + if (locationmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(locationmessage); + if (message_arena != submessage_arena) { + locationmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, locationmessage, submessage_arena); + } + set_has_locationmessage(); + _impl_.title_.locationmessage_ = locationmessage; + } + // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.locationMessage) +} +Message_TemplateMessage_FourRowTemplate::Message_TemplateMessage_FourRowTemplate(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.TemplateMessage.FourRowTemplate) +} +Message_TemplateMessage_FourRowTemplate::Message_TemplateMessage_FourRowTemplate(const Message_TemplateMessage_FourRowTemplate& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_TemplateMessage_FourRowTemplate* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.buttons_){from._impl_.buttons_} + , decltype(_impl_.content_){nullptr} + , decltype(_impl_.footer_){nullptr} + , decltype(_impl_.title_){} + , /*decltype(_impl_._oneof_case_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_content()) { + _this->_impl_.content_ = new ::proto::Message_HighlyStructuredMessage(*from._impl_.content_); + } + if (from._internal_has_footer()) { + _this->_impl_.footer_ = new ::proto::Message_HighlyStructuredMessage(*from._impl_.footer_); + } + clear_has_title(); + switch (from.title_case()) { + case kDocumentMessage: { + _this->_internal_mutable_documentmessage()->::proto::Message_DocumentMessage::MergeFrom( + from._internal_documentmessage()); + break; + } + case kHighlyStructuredMessage: { + _this->_internal_mutable_highlystructuredmessage()->::proto::Message_HighlyStructuredMessage::MergeFrom( + from._internal_highlystructuredmessage()); + break; + } + case kImageMessage: { + _this->_internal_mutable_imagemessage()->::proto::Message_ImageMessage::MergeFrom( + from._internal_imagemessage()); + break; + } + case kVideoMessage: { + _this->_internal_mutable_videomessage()->::proto::Message_VideoMessage::MergeFrom( + from._internal_videomessage()); + break; + } + case kLocationMessage: { + _this->_internal_mutable_locationmessage()->::proto::Message_LocationMessage::MergeFrom( + from._internal_locationmessage()); + break; + } + case TITLE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:proto.Message.TemplateMessage.FourRowTemplate) +} + +inline void Message_TemplateMessage_FourRowTemplate::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.buttons_){arena} + , decltype(_impl_.content_){nullptr} + , decltype(_impl_.footer_){nullptr} + , decltype(_impl_.title_){} + , /*decltype(_impl_._oneof_case_)*/{} + }; + clear_has_title(); +} + +Message_TemplateMessage_FourRowTemplate::~Message_TemplateMessage_FourRowTemplate() { + // @@protoc_insertion_point(destructor:proto.Message.TemplateMessage.FourRowTemplate) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_TemplateMessage_FourRowTemplate::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.buttons_.~RepeatedPtrField(); + if (this != internal_default_instance()) delete _impl_.content_; + if (this != internal_default_instance()) delete _impl_.footer_; + if (has_title()) { + clear_title(); + } +} + +void Message_TemplateMessage_FourRowTemplate::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_TemplateMessage_FourRowTemplate::clear_title() { +// @@protoc_insertion_point(one_of_clear_start:proto.Message.TemplateMessage.FourRowTemplate) + switch (title_case()) { + case kDocumentMessage: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.title_.documentmessage_; + } + break; + } + case kHighlyStructuredMessage: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.title_.highlystructuredmessage_; + } + break; + } + case kImageMessage: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.title_.imagemessage_; + } + break; + } + case kVideoMessage: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.title_.videomessage_; + } + break; + } + case kLocationMessage: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.title_.locationmessage_; + } + break; + } + case TITLE_NOT_SET: { + break; + } + } + _impl_._oneof_case_[0] = TITLE_NOT_SET; +} + + +void Message_TemplateMessage_FourRowTemplate::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.TemplateMessage.FourRowTemplate) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.buttons_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.content_ != nullptr); + _impl_.content_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.footer_ != nullptr); + _impl_.footer_->Clear(); + } + } + clear_title(); + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_TemplateMessage_FourRowTemplate::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .proto.Message.DocumentMessage documentMessage = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_documentmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .proto.Message.HighlyStructuredMessage highlyStructuredMessage = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_highlystructuredmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .proto.Message.ImageMessage imageMessage = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_imagemessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .proto.Message.VideoMessage videoMessage = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_videomessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .proto.Message.LocationMessage locationMessage = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_locationmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.HighlyStructuredMessage content = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_content(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.HighlyStructuredMessage footer = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_footer(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .proto.TemplateButton buttons = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_buttons(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_TemplateMessage_FourRowTemplate::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.TemplateMessage.FourRowTemplate) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + switch (title_case()) { + case kDocumentMessage: { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::documentmessage(this), + _Internal::documentmessage(this).GetCachedSize(), target, stream); + break; + } + case kHighlyStructuredMessage: { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::highlystructuredmessage(this), + _Internal::highlystructuredmessage(this).GetCachedSize(), target, stream); + break; + } + case kImageMessage: { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::imagemessage(this), + _Internal::imagemessage(this).GetCachedSize(), target, stream); + break; + } + case kVideoMessage: { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, _Internal::videomessage(this), + _Internal::videomessage(this).GetCachedSize(), target, stream); + break; + } + case kLocationMessage: { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(5, _Internal::locationmessage(this), + _Internal::locationmessage(this).GetCachedSize(), target, stream); + break; + } + default: ; + } + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.Message.HighlyStructuredMessage content = 6; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(6, _Internal::content(this), + _Internal::content(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.HighlyStructuredMessage footer = 7; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(7, _Internal::footer(this), + _Internal::footer(this).GetCachedSize(), target, stream); + } + + // repeated .proto.TemplateButton buttons = 8; + for (unsigned i = 0, + n = static_cast(this->_internal_buttons_size()); i < n; i++) { + const auto& repfield = this->_internal_buttons(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(8, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.TemplateMessage.FourRowTemplate) + return target; +} + +size_t Message_TemplateMessage_FourRowTemplate::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.TemplateMessage.FourRowTemplate) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.TemplateButton buttons = 8; + total_size += 1UL * this->_internal_buttons_size(); + for (const auto& msg : this->_impl_.buttons_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional .proto.Message.HighlyStructuredMessage content = 6; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.content_); + } + + // optional .proto.Message.HighlyStructuredMessage footer = 7; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.footer_); + } + + } + switch (title_case()) { + // .proto.Message.DocumentMessage documentMessage = 1; + case kDocumentMessage: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.title_.documentmessage_); + break; + } + // .proto.Message.HighlyStructuredMessage highlyStructuredMessage = 2; + case kHighlyStructuredMessage: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.title_.highlystructuredmessage_); + break; + } + // .proto.Message.ImageMessage imageMessage = 3; + case kImageMessage: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.title_.imagemessage_); + break; + } + // .proto.Message.VideoMessage videoMessage = 4; + case kVideoMessage: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.title_.videomessage_); + break; + } + // .proto.Message.LocationMessage locationMessage = 5; + case kLocationMessage: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.title_.locationmessage_); + break; + } + case TITLE_NOT_SET: { + break; + } + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_TemplateMessage_FourRowTemplate::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_TemplateMessage_FourRowTemplate::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_TemplateMessage_FourRowTemplate::GetClassData() const { return &_class_data_; } + + +void Message_TemplateMessage_FourRowTemplate::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.TemplateMessage.FourRowTemplate) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.buttons_.MergeFrom(from._impl_.buttons_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_content()->::proto::Message_HighlyStructuredMessage::MergeFrom( + from._internal_content()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_footer()->::proto::Message_HighlyStructuredMessage::MergeFrom( + from._internal_footer()); + } + } + switch (from.title_case()) { + case kDocumentMessage: { + _this->_internal_mutable_documentmessage()->::proto::Message_DocumentMessage::MergeFrom( + from._internal_documentmessage()); + break; + } + case kHighlyStructuredMessage: { + _this->_internal_mutable_highlystructuredmessage()->::proto::Message_HighlyStructuredMessage::MergeFrom( + from._internal_highlystructuredmessage()); + break; + } + case kImageMessage: { + _this->_internal_mutable_imagemessage()->::proto::Message_ImageMessage::MergeFrom( + from._internal_imagemessage()); + break; + } + case kVideoMessage: { + _this->_internal_mutable_videomessage()->::proto::Message_VideoMessage::MergeFrom( + from._internal_videomessage()); + break; + } + case kLocationMessage: { + _this->_internal_mutable_locationmessage()->::proto::Message_LocationMessage::MergeFrom( + from._internal_locationmessage()); + break; + } + case TITLE_NOT_SET: { + break; + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_TemplateMessage_FourRowTemplate::CopyFrom(const Message_TemplateMessage_FourRowTemplate& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.TemplateMessage.FourRowTemplate) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_TemplateMessage_FourRowTemplate::IsInitialized() const { + return true; +} + +void Message_TemplateMessage_FourRowTemplate::InternalSwap(Message_TemplateMessage_FourRowTemplate* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.buttons_.InternalSwap(&other->_impl_.buttons_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_TemplateMessage_FourRowTemplate, _impl_.footer_) + + sizeof(Message_TemplateMessage_FourRowTemplate::_impl_.footer_) + - PROTOBUF_FIELD_OFFSET(Message_TemplateMessage_FourRowTemplate, _impl_.content_)>( + reinterpret_cast(&_impl_.content_), + reinterpret_cast(&other->_impl_.content_)); + swap(_impl_.title_, other->_impl_.title_); + swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_TemplateMessage_FourRowTemplate::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[133]); +} + +// =================================================================== + +class Message_TemplateMessage_HydratedFourRowTemplate::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_hydratedcontenttext(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_hydratedfootertext(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_templateid(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static const ::proto::Message_DocumentMessage& documentmessage(const Message_TemplateMessage_HydratedFourRowTemplate* msg); + static const ::proto::Message_ImageMessage& imagemessage(const Message_TemplateMessage_HydratedFourRowTemplate* msg); + static const ::proto::Message_VideoMessage& videomessage(const Message_TemplateMessage_HydratedFourRowTemplate* msg); + static const ::proto::Message_LocationMessage& locationmessage(const Message_TemplateMessage_HydratedFourRowTemplate* msg); +}; + +const ::proto::Message_DocumentMessage& +Message_TemplateMessage_HydratedFourRowTemplate::_Internal::documentmessage(const Message_TemplateMessage_HydratedFourRowTemplate* msg) { + return *msg->_impl_.title_.documentmessage_; +} +const ::proto::Message_ImageMessage& +Message_TemplateMessage_HydratedFourRowTemplate::_Internal::imagemessage(const Message_TemplateMessage_HydratedFourRowTemplate* msg) { + return *msg->_impl_.title_.imagemessage_; +} +const ::proto::Message_VideoMessage& +Message_TemplateMessage_HydratedFourRowTemplate::_Internal::videomessage(const Message_TemplateMessage_HydratedFourRowTemplate* msg) { + return *msg->_impl_.title_.videomessage_; +} +const ::proto::Message_LocationMessage& +Message_TemplateMessage_HydratedFourRowTemplate::_Internal::locationmessage(const Message_TemplateMessage_HydratedFourRowTemplate* msg) { + return *msg->_impl_.title_.locationmessage_; +} +void Message_TemplateMessage_HydratedFourRowTemplate::set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_title(); + if (documentmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(documentmessage); + if (message_arena != submessage_arena) { + documentmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, documentmessage, submessage_arena); + } + set_has_documentmessage(); + _impl_.title_.documentmessage_ = documentmessage; + } + // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.documentMessage) +} +void Message_TemplateMessage_HydratedFourRowTemplate::set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_title(); + if (imagemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(imagemessage); + if (message_arena != submessage_arena) { + imagemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, imagemessage, submessage_arena); + } + set_has_imagemessage(); + _impl_.title_.imagemessage_ = imagemessage; + } + // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.imageMessage) +} +void Message_TemplateMessage_HydratedFourRowTemplate::set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_title(); + if (videomessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(videomessage); + if (message_arena != submessage_arena) { + videomessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, videomessage, submessage_arena); + } + set_has_videomessage(); + _impl_.title_.videomessage_ = videomessage; + } + // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.videoMessage) +} +void Message_TemplateMessage_HydratedFourRowTemplate::set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_title(); + if (locationmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(locationmessage); + if (message_arena != submessage_arena) { + locationmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, locationmessage, submessage_arena); + } + set_has_locationmessage(); + _impl_.title_.locationmessage_ = locationmessage; + } + // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.locationMessage) +} +Message_TemplateMessage_HydratedFourRowTemplate::Message_TemplateMessage_HydratedFourRowTemplate(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.TemplateMessage.HydratedFourRowTemplate) +} +Message_TemplateMessage_HydratedFourRowTemplate::Message_TemplateMessage_HydratedFourRowTemplate(const Message_TemplateMessage_HydratedFourRowTemplate& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_TemplateMessage_HydratedFourRowTemplate* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.hydratedbuttons_){from._impl_.hydratedbuttons_} + , decltype(_impl_.hydratedcontenttext_){} + , decltype(_impl_.hydratedfootertext_){} + , decltype(_impl_.templateid_){} + , decltype(_impl_.title_){} + , /*decltype(_impl_._oneof_case_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.hydratedcontenttext_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.hydratedcontenttext_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_hydratedcontenttext()) { + _this->_impl_.hydratedcontenttext_.Set(from._internal_hydratedcontenttext(), + _this->GetArenaForAllocation()); + } + _impl_.hydratedfootertext_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.hydratedfootertext_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_hydratedfootertext()) { + _this->_impl_.hydratedfootertext_.Set(from._internal_hydratedfootertext(), + _this->GetArenaForAllocation()); + } + _impl_.templateid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.templateid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_templateid()) { + _this->_impl_.templateid_.Set(from._internal_templateid(), + _this->GetArenaForAllocation()); + } + clear_has_title(); + switch (from.title_case()) { + case kDocumentMessage: { + _this->_internal_mutable_documentmessage()->::proto::Message_DocumentMessage::MergeFrom( + from._internal_documentmessage()); + break; + } + case kHydratedTitleText: { + _this->_internal_set_hydratedtitletext(from._internal_hydratedtitletext()); + break; + } + case kImageMessage: { + _this->_internal_mutable_imagemessage()->::proto::Message_ImageMessage::MergeFrom( + from._internal_imagemessage()); + break; + } + case kVideoMessage: { + _this->_internal_mutable_videomessage()->::proto::Message_VideoMessage::MergeFrom( + from._internal_videomessage()); + break; + } + case kLocationMessage: { + _this->_internal_mutable_locationmessage()->::proto::Message_LocationMessage::MergeFrom( + from._internal_locationmessage()); + break; + } + case TITLE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:proto.Message.TemplateMessage.HydratedFourRowTemplate) +} + +inline void Message_TemplateMessage_HydratedFourRowTemplate::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.hydratedbuttons_){arena} + , decltype(_impl_.hydratedcontenttext_){} + , decltype(_impl_.hydratedfootertext_){} + , decltype(_impl_.templateid_){} + , decltype(_impl_.title_){} + , /*decltype(_impl_._oneof_case_)*/{} + }; + _impl_.hydratedcontenttext_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.hydratedcontenttext_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.hydratedfootertext_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.hydratedfootertext_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.templateid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.templateid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + clear_has_title(); +} + +Message_TemplateMessage_HydratedFourRowTemplate::~Message_TemplateMessage_HydratedFourRowTemplate() { + // @@protoc_insertion_point(destructor:proto.Message.TemplateMessage.HydratedFourRowTemplate) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_TemplateMessage_HydratedFourRowTemplate::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.hydratedbuttons_.~RepeatedPtrField(); + _impl_.hydratedcontenttext_.Destroy(); + _impl_.hydratedfootertext_.Destroy(); + _impl_.templateid_.Destroy(); + if (has_title()) { + clear_title(); + } +} + +void Message_TemplateMessage_HydratedFourRowTemplate::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_TemplateMessage_HydratedFourRowTemplate::clear_title() { +// @@protoc_insertion_point(one_of_clear_start:proto.Message.TemplateMessage.HydratedFourRowTemplate) + switch (title_case()) { + case kDocumentMessage: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.title_.documentmessage_; + } + break; + } + case kHydratedTitleText: { + _impl_.title_.hydratedtitletext_.Destroy(); + break; + } + case kImageMessage: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.title_.imagemessage_; + } + break; + } + case kVideoMessage: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.title_.videomessage_; + } + break; + } + case kLocationMessage: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.title_.locationmessage_; + } + break; + } + case TITLE_NOT_SET: { + break; + } + } + _impl_._oneof_case_[0] = TITLE_NOT_SET; +} + + +void Message_TemplateMessage_HydratedFourRowTemplate::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.TemplateMessage.HydratedFourRowTemplate) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.hydratedbuttons_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _impl_.hydratedcontenttext_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.hydratedfootertext_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.templateid_.ClearNonDefaultToEmpty(); + } + } + clear_title(); + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_TemplateMessage_HydratedFourRowTemplate::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .proto.Message.DocumentMessage documentMessage = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_documentmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // string hydratedTitleText = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_hydratedtitletext(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedTitleText"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // .proto.Message.ImageMessage imageMessage = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_imagemessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .proto.Message.VideoMessage videoMessage = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_videomessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .proto.Message.LocationMessage locationMessage = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_locationmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string hydratedContentText = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + auto str = _internal_mutable_hydratedcontenttext(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedContentText"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string hydratedFooterText = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + auto str = _internal_mutable_hydratedfootertext(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedFooterText"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // repeated .proto.HydratedTemplateButton hydratedButtons = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_hydratedbuttons(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(ptr)); + } else + goto handle_unusual; + continue; + // optional string templateId = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + auto str = _internal_mutable_templateid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.TemplateMessage.HydratedFourRowTemplate.templateId"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_TemplateMessage_HydratedFourRowTemplate::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.TemplateMessage.HydratedFourRowTemplate) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + switch (title_case()) { + case kDocumentMessage: { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::documentmessage(this), + _Internal::documentmessage(this).GetCachedSize(), target, stream); + break; + } + case kHydratedTitleText: { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_hydratedtitletext().data(), static_cast(this->_internal_hydratedtitletext().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedTitleText"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_hydratedtitletext(), target); + break; + } + case kImageMessage: { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::imagemessage(this), + _Internal::imagemessage(this).GetCachedSize(), target, stream); + break; + } + case kVideoMessage: { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, _Internal::videomessage(this), + _Internal::videomessage(this).GetCachedSize(), target, stream); + break; + } + case kLocationMessage: { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(5, _Internal::locationmessage(this), + _Internal::locationmessage(this).GetCachedSize(), target, stream); + break; + } + default: ; + } + cached_has_bits = _impl_._has_bits_[0]; + // optional string hydratedContentText = 6; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_hydratedcontenttext().data(), static_cast(this->_internal_hydratedcontenttext().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedContentText"); + target = stream->WriteStringMaybeAliased( + 6, this->_internal_hydratedcontenttext(), target); + } + + // optional string hydratedFooterText = 7; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_hydratedfootertext().data(), static_cast(this->_internal_hydratedfootertext().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedFooterText"); + target = stream->WriteStringMaybeAliased( + 7, this->_internal_hydratedfootertext(), target); + } + + // repeated .proto.HydratedTemplateButton hydratedButtons = 8; + for (unsigned i = 0, + n = static_cast(this->_internal_hydratedbuttons_size()); i < n; i++) { + const auto& repfield = this->_internal_hydratedbuttons(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(8, repfield, repfield.GetCachedSize(), target, stream); + } + + // optional string templateId = 9; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_templateid().data(), static_cast(this->_internal_templateid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.TemplateMessage.HydratedFourRowTemplate.templateId"); + target = stream->WriteStringMaybeAliased( + 9, this->_internal_templateid(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.TemplateMessage.HydratedFourRowTemplate) + return target; +} + +size_t Message_TemplateMessage_HydratedFourRowTemplate::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.TemplateMessage.HydratedFourRowTemplate) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.HydratedTemplateButton hydratedButtons = 8; + total_size += 1UL * this->_internal_hydratedbuttons_size(); + for (const auto& msg : this->_impl_.hydratedbuttons_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional string hydratedContentText = 6; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_hydratedcontenttext()); + } + + // optional string hydratedFooterText = 7; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_hydratedfootertext()); + } + + // optional string templateId = 9; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_templateid()); + } + + } + switch (title_case()) { + // .proto.Message.DocumentMessage documentMessage = 1; + case kDocumentMessage: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.title_.documentmessage_); + break; + } + // string hydratedTitleText = 2; + case kHydratedTitleText: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_hydratedtitletext()); + break; + } + // .proto.Message.ImageMessage imageMessage = 3; + case kImageMessage: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.title_.imagemessage_); + break; + } + // .proto.Message.VideoMessage videoMessage = 4; + case kVideoMessage: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.title_.videomessage_); + break; + } + // .proto.Message.LocationMessage locationMessage = 5; + case kLocationMessage: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.title_.locationmessage_); + break; + } + case TITLE_NOT_SET: { + break; + } + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_TemplateMessage_HydratedFourRowTemplate::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_TemplateMessage_HydratedFourRowTemplate::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_TemplateMessage_HydratedFourRowTemplate::GetClassData() const { return &_class_data_; } + + +void Message_TemplateMessage_HydratedFourRowTemplate::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.TemplateMessage.HydratedFourRowTemplate) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.hydratedbuttons_.MergeFrom(from._impl_.hydratedbuttons_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_hydratedcontenttext(from._internal_hydratedcontenttext()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_hydratedfootertext(from._internal_hydratedfootertext()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_templateid(from._internal_templateid()); + } + } + switch (from.title_case()) { + case kDocumentMessage: { + _this->_internal_mutable_documentmessage()->::proto::Message_DocumentMessage::MergeFrom( + from._internal_documentmessage()); + break; + } + case kHydratedTitleText: { + _this->_internal_set_hydratedtitletext(from._internal_hydratedtitletext()); + break; + } + case kImageMessage: { + _this->_internal_mutable_imagemessage()->::proto::Message_ImageMessage::MergeFrom( + from._internal_imagemessage()); + break; + } + case kVideoMessage: { + _this->_internal_mutable_videomessage()->::proto::Message_VideoMessage::MergeFrom( + from._internal_videomessage()); + break; + } + case kLocationMessage: { + _this->_internal_mutable_locationmessage()->::proto::Message_LocationMessage::MergeFrom( + from._internal_locationmessage()); + break; + } + case TITLE_NOT_SET: { + break; + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_TemplateMessage_HydratedFourRowTemplate::CopyFrom(const Message_TemplateMessage_HydratedFourRowTemplate& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.TemplateMessage.HydratedFourRowTemplate) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_TemplateMessage_HydratedFourRowTemplate::IsInitialized() const { + return true; +} + +void Message_TemplateMessage_HydratedFourRowTemplate::InternalSwap(Message_TemplateMessage_HydratedFourRowTemplate* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.hydratedbuttons_.InternalSwap(&other->_impl_.hydratedbuttons_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.hydratedcontenttext_, lhs_arena, + &other->_impl_.hydratedcontenttext_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.hydratedfootertext_, lhs_arena, + &other->_impl_.hydratedfootertext_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.templateid_, lhs_arena, + &other->_impl_.templateid_, rhs_arena + ); + swap(_impl_.title_, other->_impl_.title_); + swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_TemplateMessage_HydratedFourRowTemplate::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[134]); +} + +// =================================================================== + +class Message_TemplateMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::ContextInfo& contextinfo(const Message_TemplateMessage* msg); + static void set_has_contextinfo(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& hydratedtemplate(const Message_TemplateMessage* msg); + static void set_has_hydratedtemplate(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::proto::Message_TemplateMessage_FourRowTemplate& fourrowtemplate(const Message_TemplateMessage* msg); + static const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& hydratedfourrowtemplate(const Message_TemplateMessage* msg); +}; + +const ::proto::ContextInfo& +Message_TemplateMessage::_Internal::contextinfo(const Message_TemplateMessage* msg) { + return *msg->_impl_.contextinfo_; +} +const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& +Message_TemplateMessage::_Internal::hydratedtemplate(const Message_TemplateMessage* msg) { + return *msg->_impl_.hydratedtemplate_; +} +const ::proto::Message_TemplateMessage_FourRowTemplate& +Message_TemplateMessage::_Internal::fourrowtemplate(const Message_TemplateMessage* msg) { + return *msg->_impl_.format_.fourrowtemplate_; +} +const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& +Message_TemplateMessage::_Internal::hydratedfourrowtemplate(const Message_TemplateMessage* msg) { + return *msg->_impl_.format_.hydratedfourrowtemplate_; +} +void Message_TemplateMessage::set_allocated_fourrowtemplate(::proto::Message_TemplateMessage_FourRowTemplate* fourrowtemplate) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_format(); + if (fourrowtemplate) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(fourrowtemplate); + if (message_arena != submessage_arena) { + fourrowtemplate = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, fourrowtemplate, submessage_arena); + } + set_has_fourrowtemplate(); + _impl_.format_.fourrowtemplate_ = fourrowtemplate; + } + // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.fourRowTemplate) +} +void Message_TemplateMessage::set_allocated_hydratedfourrowtemplate(::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedfourrowtemplate) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_format(); + if (hydratedfourrowtemplate) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(hydratedfourrowtemplate); + if (message_arena != submessage_arena) { + hydratedfourrowtemplate = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, hydratedfourrowtemplate, submessage_arena); + } + set_has_hydratedfourrowtemplate(); + _impl_.format_.hydratedfourrowtemplate_ = hydratedfourrowtemplate; + } + // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.hydratedFourRowTemplate) +} +Message_TemplateMessage::Message_TemplateMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.TemplateMessage) +} +Message_TemplateMessage::Message_TemplateMessage(const Message_TemplateMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_TemplateMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.hydratedtemplate_){nullptr} + , decltype(_impl_.format_){} + , /*decltype(_impl_._oneof_case_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_contextinfo()) { + _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); + } + if (from._internal_has_hydratedtemplate()) { + _this->_impl_.hydratedtemplate_ = new ::proto::Message_TemplateMessage_HydratedFourRowTemplate(*from._impl_.hydratedtemplate_); + } + clear_has_format(); + switch (from.format_case()) { + case kFourRowTemplate: { + _this->_internal_mutable_fourrowtemplate()->::proto::Message_TemplateMessage_FourRowTemplate::MergeFrom( + from._internal_fourrowtemplate()); + break; + } + case kHydratedFourRowTemplate: { + _this->_internal_mutable_hydratedfourrowtemplate()->::proto::Message_TemplateMessage_HydratedFourRowTemplate::MergeFrom( + from._internal_hydratedfourrowtemplate()); + break; + } + case FORMAT_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:proto.Message.TemplateMessage) +} + +inline void Message_TemplateMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.hydratedtemplate_){nullptr} + , decltype(_impl_.format_){} + , /*decltype(_impl_._oneof_case_)*/{} + }; + clear_has_format(); +} + +Message_TemplateMessage::~Message_TemplateMessage() { + // @@protoc_insertion_point(destructor:proto.Message.TemplateMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_TemplateMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.contextinfo_; + if (this != internal_default_instance()) delete _impl_.hydratedtemplate_; + if (has_format()) { + clear_format(); + } +} + +void Message_TemplateMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_TemplateMessage::clear_format() { +// @@protoc_insertion_point(one_of_clear_start:proto.Message.TemplateMessage) + switch (format_case()) { + case kFourRowTemplate: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.format_.fourrowtemplate_; + } + break; + } + case kHydratedFourRowTemplate: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.format_.hydratedfourrowtemplate_; + } + break; + } + case FORMAT_NOT_SET: { + break; + } + } + _impl_._oneof_case_[0] = FORMAT_NOT_SET; +} + + +void Message_TemplateMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.TemplateMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); + _impl_.contextinfo_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.hydratedtemplate_ != nullptr); + _impl_.hydratedtemplate_->Clear(); + } + } + clear_format(); + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_TemplateMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .proto.Message.TemplateMessage.FourRowTemplate fourRowTemplate = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_fourrowtemplate(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .proto.Message.TemplateMessage.HydratedFourRowTemplate hydratedFourRowTemplate = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_hydratedfourrowtemplate(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.ContextInfo contextInfo = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.TemplateMessage.HydratedFourRowTemplate hydratedTemplate = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_hydratedtemplate(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_TemplateMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.TemplateMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + switch (format_case()) { + case kFourRowTemplate: { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::fourrowtemplate(this), + _Internal::fourrowtemplate(this).GetCachedSize(), target, stream); + break; + } + case kHydratedFourRowTemplate: { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::hydratedfourrowtemplate(this), + _Internal::hydratedfourrowtemplate(this).GetCachedSize(), target, stream); + break; + } + default: ; + } + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.ContextInfo contextInfo = 3; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::contextinfo(this), + _Internal::contextinfo(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.TemplateMessage.HydratedFourRowTemplate hydratedTemplate = 4; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, _Internal::hydratedtemplate(this), + _Internal::hydratedtemplate(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.TemplateMessage) + return target; +} + +size_t Message_TemplateMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.TemplateMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional .proto.ContextInfo contextInfo = 3; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.contextinfo_); + } + + // optional .proto.Message.TemplateMessage.HydratedFourRowTemplate hydratedTemplate = 4; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.hydratedtemplate_); + } + + } + switch (format_case()) { + // .proto.Message.TemplateMessage.FourRowTemplate fourRowTemplate = 1; + case kFourRowTemplate: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.format_.fourrowtemplate_); + break; + } + // .proto.Message.TemplateMessage.HydratedFourRowTemplate hydratedFourRowTemplate = 2; + case kHydratedFourRowTemplate: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.format_.hydratedfourrowtemplate_); + break; + } + case FORMAT_NOT_SET: { + break; + } + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_TemplateMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_TemplateMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_TemplateMessage::GetClassData() const { return &_class_data_; } + + +void Message_TemplateMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.TemplateMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( + from._internal_contextinfo()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_hydratedtemplate()->::proto::Message_TemplateMessage_HydratedFourRowTemplate::MergeFrom( + from._internal_hydratedtemplate()); + } + } + switch (from.format_case()) { + case kFourRowTemplate: { + _this->_internal_mutable_fourrowtemplate()->::proto::Message_TemplateMessage_FourRowTemplate::MergeFrom( + from._internal_fourrowtemplate()); + break; + } + case kHydratedFourRowTemplate: { + _this->_internal_mutable_hydratedfourrowtemplate()->::proto::Message_TemplateMessage_HydratedFourRowTemplate::MergeFrom( + from._internal_hydratedfourrowtemplate()); + break; + } + case FORMAT_NOT_SET: { + break; + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_TemplateMessage::CopyFrom(const Message_TemplateMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.TemplateMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_TemplateMessage::IsInitialized() const { + return true; +} + +void Message_TemplateMessage::InternalSwap(Message_TemplateMessage* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_TemplateMessage, _impl_.hydratedtemplate_) + + sizeof(Message_TemplateMessage::_impl_.hydratedtemplate_) + - PROTOBUF_FIELD_OFFSET(Message_TemplateMessage, _impl_.contextinfo_)>( + reinterpret_cast(&_impl_.contextinfo_), + reinterpret_cast(&other->_impl_.contextinfo_)); + swap(_impl_.format_, other->_impl_.format_); + swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_TemplateMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[135]); +} + +// =================================================================== + +class Message_VideoMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_url(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_mimetype(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_filesha256(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_filelength(HasBits* has_bits) { + (*has_bits)[0] |= 16384u; + } + static void set_has_seconds(HasBits* has_bits) { + (*has_bits)[0] |= 32768u; + } + static void set_has_mediakey(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_caption(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_gifplayback(HasBits* has_bits) { + (*has_bits)[0] |= 262144u; + } + static void set_has_height(HasBits* has_bits) { + (*has_bits)[0] |= 65536u; + } + static void set_has_width(HasBits* has_bits) { + (*has_bits)[0] |= 131072u; + } + static void set_has_fileencsha256(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_directpath(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_mediakeytimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 1048576u; + } + static void set_has_jpegthumbnail(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static const ::proto::ContextInfo& contextinfo(const Message_VideoMessage* msg); + static void set_has_contextinfo(HasBits* has_bits) { + (*has_bits)[0] |= 8192u; + } + static void set_has_streamingsidecar(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_gifattribution(HasBits* has_bits) { + (*has_bits)[0] |= 2097152u; + } + static void set_has_viewonce(HasBits* has_bits) { + (*has_bits)[0] |= 524288u; + } + static void set_has_thumbnaildirectpath(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_thumbnailsha256(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static void set_has_thumbnailencsha256(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static void set_has_staticurl(HasBits* has_bits) { + (*has_bits)[0] |= 4096u; + } +}; + +const ::proto::ContextInfo& +Message_VideoMessage::_Internal::contextinfo(const Message_VideoMessage* msg) { + return *msg->_impl_.contextinfo_; +} +Message_VideoMessage::Message_VideoMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message.VideoMessage) +} +Message_VideoMessage::Message_VideoMessage(const Message_VideoMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message_VideoMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.interactiveannotations_){from._impl_.interactiveannotations_} + , decltype(_impl_.url_){} + , decltype(_impl_.mimetype_){} + , decltype(_impl_.filesha256_){} + , decltype(_impl_.mediakey_){} + , decltype(_impl_.caption_){} + , decltype(_impl_.fileencsha256_){} + , decltype(_impl_.directpath_){} + , decltype(_impl_.jpegthumbnail_){} + , decltype(_impl_.streamingsidecar_){} + , decltype(_impl_.thumbnaildirectpath_){} + , decltype(_impl_.thumbnailsha256_){} + , decltype(_impl_.thumbnailencsha256_){} + , decltype(_impl_.staticurl_){} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.filelength_){} + , decltype(_impl_.seconds_){} + , decltype(_impl_.height_){} + , decltype(_impl_.width_){} + , decltype(_impl_.gifplayback_){} + , decltype(_impl_.viewonce_){} + , decltype(_impl_.mediakeytimestamp_){} + , decltype(_impl_.gifattribution_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.url_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.url_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_url()) { + _this->_impl_.url_.Set(from._internal_url(), + _this->GetArenaForAllocation()); + } + _impl_.mimetype_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mimetype_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_mimetype()) { + _this->_impl_.mimetype_.Set(from._internal_mimetype(), + _this->GetArenaForAllocation()); + } + _impl_.filesha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filesha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_filesha256()) { + _this->_impl_.filesha256_.Set(from._internal_filesha256(), + _this->GetArenaForAllocation()); + } + _impl_.mediakey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediakey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_mediakey()) { + _this->_impl_.mediakey_.Set(from._internal_mediakey(), + _this->GetArenaForAllocation()); + } + _impl_.caption_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.caption_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_caption()) { + _this->_impl_.caption_.Set(from._internal_caption(), + _this->GetArenaForAllocation()); + } + _impl_.fileencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_fileencsha256()) { + _this->_impl_.fileencsha256_.Set(from._internal_fileencsha256(), + _this->GetArenaForAllocation()); + } + _impl_.directpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_directpath()) { + _this->_impl_.directpath_.Set(from._internal_directpath(), + _this->GetArenaForAllocation()); + } + _impl_.jpegthumbnail_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_jpegthumbnail()) { + _this->_impl_.jpegthumbnail_.Set(from._internal_jpegthumbnail(), + _this->GetArenaForAllocation()); + } + _impl_.streamingsidecar_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.streamingsidecar_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_streamingsidecar()) { + _this->_impl_.streamingsidecar_.Set(from._internal_streamingsidecar(), + _this->GetArenaForAllocation()); + } + _impl_.thumbnaildirectpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_thumbnaildirectpath()) { + _this->_impl_.thumbnaildirectpath_.Set(from._internal_thumbnaildirectpath(), + _this->GetArenaForAllocation()); + } + _impl_.thumbnailsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_thumbnailsha256()) { + _this->_impl_.thumbnailsha256_.Set(from._internal_thumbnailsha256(), + _this->GetArenaForAllocation()); + } + _impl_.thumbnailencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_thumbnailencsha256()) { + _this->_impl_.thumbnailencsha256_.Set(from._internal_thumbnailencsha256(), + _this->GetArenaForAllocation()); + } + _impl_.staticurl_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.staticurl_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_staticurl()) { + _this->_impl_.staticurl_.Set(from._internal_staticurl(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_contextinfo()) { + _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); + } + ::memcpy(&_impl_.filelength_, &from._impl_.filelength_, + static_cast(reinterpret_cast(&_impl_.gifattribution_) - + reinterpret_cast(&_impl_.filelength_)) + sizeof(_impl_.gifattribution_)); + // @@protoc_insertion_point(copy_constructor:proto.Message.VideoMessage) +} + +inline void Message_VideoMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.interactiveannotations_){arena} + , decltype(_impl_.url_){} + , decltype(_impl_.mimetype_){} + , decltype(_impl_.filesha256_){} + , decltype(_impl_.mediakey_){} + , decltype(_impl_.caption_){} + , decltype(_impl_.fileencsha256_){} + , decltype(_impl_.directpath_){} + , decltype(_impl_.jpegthumbnail_){} + , decltype(_impl_.streamingsidecar_){} + , decltype(_impl_.thumbnaildirectpath_){} + , decltype(_impl_.thumbnailsha256_){} + , decltype(_impl_.thumbnailencsha256_){} + , decltype(_impl_.staticurl_){} + , decltype(_impl_.contextinfo_){nullptr} + , decltype(_impl_.filelength_){uint64_t{0u}} + , decltype(_impl_.seconds_){0u} + , decltype(_impl_.height_){0u} + , decltype(_impl_.width_){0u} + , decltype(_impl_.gifplayback_){false} + , decltype(_impl_.viewonce_){false} + , decltype(_impl_.mediakeytimestamp_){int64_t{0}} + , decltype(_impl_.gifattribution_){0} + }; + _impl_.url_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.url_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mimetype_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mimetype_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filesha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filesha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediakey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediakey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.caption_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.caption_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fileencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.jpegthumbnail_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.streamingsidecar_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.streamingsidecar_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnaildirectpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnailsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnailencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.staticurl_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.staticurl_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message_VideoMessage::~Message_VideoMessage() { + // @@protoc_insertion_point(destructor:proto.Message.VideoMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message_VideoMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.interactiveannotations_.~RepeatedPtrField(); + _impl_.url_.Destroy(); + _impl_.mimetype_.Destroy(); + _impl_.filesha256_.Destroy(); + _impl_.mediakey_.Destroy(); + _impl_.caption_.Destroy(); + _impl_.fileencsha256_.Destroy(); + _impl_.directpath_.Destroy(); + _impl_.jpegthumbnail_.Destroy(); + _impl_.streamingsidecar_.Destroy(); + _impl_.thumbnaildirectpath_.Destroy(); + _impl_.thumbnailsha256_.Destroy(); + _impl_.thumbnailencsha256_.Destroy(); + _impl_.staticurl_.Destroy(); + if (this != internal_default_instance()) delete _impl_.contextinfo_; +} + +void Message_VideoMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message_VideoMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message.VideoMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.interactiveannotations_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _impl_.url_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.mimetype_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.filesha256_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + _impl_.mediakey_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + _impl_.caption_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000020u) { + _impl_.fileencsha256_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000040u) { + _impl_.directpath_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000080u) { + _impl_.jpegthumbnail_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x00003f00u) { + if (cached_has_bits & 0x00000100u) { + _impl_.streamingsidecar_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000200u) { + _impl_.thumbnaildirectpath_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000400u) { + _impl_.thumbnailsha256_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000800u) { + _impl_.thumbnailencsha256_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00001000u) { + _impl_.staticurl_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00002000u) { + GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); + _impl_.contextinfo_->Clear(); + } + } + if (cached_has_bits & 0x0000c000u) { + ::memset(&_impl_.filelength_, 0, static_cast( + reinterpret_cast(&_impl_.seconds_) - + reinterpret_cast(&_impl_.filelength_)) + sizeof(_impl_.seconds_)); + } + if (cached_has_bits & 0x003f0000u) { + ::memset(&_impl_.height_, 0, static_cast( + reinterpret_cast(&_impl_.gifattribution_) - + reinterpret_cast(&_impl_.height_)) + sizeof(_impl_.gifattribution_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message_VideoMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string url = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_url(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.VideoMessage.url"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string mimetype = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_mimetype(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.VideoMessage.mimetype"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bytes fileSha256 = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_filesha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint64 fileLength = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_filelength(&has_bits); + _impl_.filelength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 seconds = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_seconds(&has_bits); + _impl_.seconds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes mediaKey = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + auto str = _internal_mutable_mediakey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string caption = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + auto str = _internal_mutable_caption(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.VideoMessage.caption"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bool gifPlayback = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { + _Internal::set_has_gifplayback(&has_bits); + _impl_.gifplayback_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 height = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { + _Internal::set_has_height(&has_bits); + _impl_.height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 width = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { + _Internal::set_has_width(&has_bits); + _impl_.width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes fileEncSha256 = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { + auto str = _internal_mutable_fileencsha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .proto.InteractiveAnnotation interactiveAnnotations = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_interactiveannotations(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<98>(ptr)); + } else + goto handle_unusual; + continue; + // optional string directPath = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { + auto str = _internal_mutable_directpath(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.VideoMessage.directPath"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional int64 mediaKeyTimestamp = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 112)) { + _Internal::set_has_mediakeytimestamp(&has_bits); + _impl_.mediakeytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes jpegThumbnail = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { + auto str = _internal_mutable_jpegthumbnail(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.ContextInfo contextInfo = 17; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { + ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes streamingSidecar = 18; + case 18: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { + auto str = _internal_mutable_streamingsidecar(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.VideoMessage.Attribution gifAttribution = 19; + case 19: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 152)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::Message_VideoMessage_Attribution_IsValid(val))) { + _internal_set_gifattribution(static_cast<::proto::Message_VideoMessage_Attribution>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(19, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional bool viewOnce = 20; + case 20: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 160)) { + _Internal::set_has_viewonce(&has_bits); + _impl_.viewonce_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string thumbnailDirectPath = 21; + case 21: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { + auto str = _internal_mutable_thumbnaildirectpath(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.VideoMessage.thumbnailDirectPath"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bytes thumbnailSha256 = 22; + case 22: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 178)) { + auto str = _internal_mutable_thumbnailsha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes thumbnailEncSha256 = 23; + case 23: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { + auto str = _internal_mutable_thumbnailencsha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string staticUrl = 24; + case 24: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 194)) { + auto str = _internal_mutable_staticurl(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.VideoMessage.staticUrl"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message_VideoMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message.VideoMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string url = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_url().data(), static_cast(this->_internal_url().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.VideoMessage.url"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_url(), target); + } + + // optional string mimetype = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_mimetype().data(), static_cast(this->_internal_mimetype().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.VideoMessage.mimetype"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_mimetype(), target); + } + + // optional bytes fileSha256 = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->WriteBytesMaybeAliased( + 3, this->_internal_filesha256(), target); + } + + // optional uint64 fileLength = 4; + if (cached_has_bits & 0x00004000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_filelength(), target); + } + + // optional uint32 seconds = 5; + if (cached_has_bits & 0x00008000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_seconds(), target); + } + + // optional bytes mediaKey = 6; + if (cached_has_bits & 0x00000008u) { + target = stream->WriteBytesMaybeAliased( + 6, this->_internal_mediakey(), target); + } + + // optional string caption = 7; + if (cached_has_bits & 0x00000010u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_caption().data(), static_cast(this->_internal_caption().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.VideoMessage.caption"); + target = stream->WriteStringMaybeAliased( + 7, this->_internal_caption(), target); + } + + // optional bool gifPlayback = 8; + if (cached_has_bits & 0x00040000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(8, this->_internal_gifplayback(), target); + } + + // optional uint32 height = 9; + if (cached_has_bits & 0x00010000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(9, this->_internal_height(), target); + } + + // optional uint32 width = 10; + if (cached_has_bits & 0x00020000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(10, this->_internal_width(), target); + } + + // optional bytes fileEncSha256 = 11; + if (cached_has_bits & 0x00000020u) { + target = stream->WriteBytesMaybeAliased( + 11, this->_internal_fileencsha256(), target); + } + + // repeated .proto.InteractiveAnnotation interactiveAnnotations = 12; + for (unsigned i = 0, + n = static_cast(this->_internal_interactiveannotations_size()); i < n; i++) { + const auto& repfield = this->_internal_interactiveannotations(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(12, repfield, repfield.GetCachedSize(), target, stream); + } + + // optional string directPath = 13; + if (cached_has_bits & 0x00000040u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_directpath().data(), static_cast(this->_internal_directpath().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.VideoMessage.directPath"); + target = stream->WriteStringMaybeAliased( + 13, this->_internal_directpath(), target); + } + + // optional int64 mediaKeyTimestamp = 14; + if (cached_has_bits & 0x00100000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(14, this->_internal_mediakeytimestamp(), target); + } + + // optional bytes jpegThumbnail = 16; + if (cached_has_bits & 0x00000080u) { + target = stream->WriteBytesMaybeAliased( + 16, this->_internal_jpegthumbnail(), target); + } + + // optional .proto.ContextInfo contextInfo = 17; + if (cached_has_bits & 0x00002000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(17, _Internal::contextinfo(this), + _Internal::contextinfo(this).GetCachedSize(), target, stream); + } + + // optional bytes streamingSidecar = 18; + if (cached_has_bits & 0x00000100u) { + target = stream->WriteBytesMaybeAliased( + 18, this->_internal_streamingsidecar(), target); + } + + // optional .proto.Message.VideoMessage.Attribution gifAttribution = 19; + if (cached_has_bits & 0x00200000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 19, this->_internal_gifattribution(), target); + } + + // optional bool viewOnce = 20; + if (cached_has_bits & 0x00080000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(20, this->_internal_viewonce(), target); + } + + // optional string thumbnailDirectPath = 21; + if (cached_has_bits & 0x00000200u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_thumbnaildirectpath().data(), static_cast(this->_internal_thumbnaildirectpath().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.VideoMessage.thumbnailDirectPath"); + target = stream->WriteStringMaybeAliased( + 21, this->_internal_thumbnaildirectpath(), target); + } + + // optional bytes thumbnailSha256 = 22; + if (cached_has_bits & 0x00000400u) { + target = stream->WriteBytesMaybeAliased( + 22, this->_internal_thumbnailsha256(), target); + } + + // optional bytes thumbnailEncSha256 = 23; + if (cached_has_bits & 0x00000800u) { + target = stream->WriteBytesMaybeAliased( + 23, this->_internal_thumbnailencsha256(), target); + } + + // optional string staticUrl = 24; + if (cached_has_bits & 0x00001000u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_staticurl().data(), static_cast(this->_internal_staticurl().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.VideoMessage.staticUrl"); + target = stream->WriteStringMaybeAliased( + 24, this->_internal_staticurl(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message.VideoMessage) + return target; +} + +size_t Message_VideoMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message.VideoMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.InteractiveAnnotation interactiveAnnotations = 12; + total_size += 1UL * this->_internal_interactiveannotations_size(); + for (const auto& msg : this->_impl_.interactiveannotations_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string url = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_url()); + } + + // optional string mimetype = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_mimetype()); + } + + // optional bytes fileSha256 = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_filesha256()); + } + + // optional bytes mediaKey = 6; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_mediakey()); + } + + // optional string caption = 7; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_caption()); + } + + // optional bytes fileEncSha256 = 11; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_fileencsha256()); + } + + // optional string directPath = 13; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_directpath()); + } + + // optional bytes jpegThumbnail = 16; + if (cached_has_bits & 0x00000080u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_jpegthumbnail()); + } + + } + if (cached_has_bits & 0x0000ff00u) { + // optional bytes streamingSidecar = 18; + if (cached_has_bits & 0x00000100u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_streamingsidecar()); + } + + // optional string thumbnailDirectPath = 21; + if (cached_has_bits & 0x00000200u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_thumbnaildirectpath()); + } + + // optional bytes thumbnailSha256 = 22; + if (cached_has_bits & 0x00000400u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_thumbnailsha256()); + } + + // optional bytes thumbnailEncSha256 = 23; + if (cached_has_bits & 0x00000800u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_thumbnailencsha256()); + } + + // optional string staticUrl = 24; + if (cached_has_bits & 0x00001000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_staticurl()); + } + + // optional .proto.ContextInfo contextInfo = 17; + if (cached_has_bits & 0x00002000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.contextinfo_); + } + + // optional uint64 fileLength = 4; + if (cached_has_bits & 0x00004000u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_filelength()); + } + + // optional uint32 seconds = 5; + if (cached_has_bits & 0x00008000u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_seconds()); + } + + } + if (cached_has_bits & 0x003f0000u) { + // optional uint32 height = 9; + if (cached_has_bits & 0x00010000u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_height()); + } + + // optional uint32 width = 10; + if (cached_has_bits & 0x00020000u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_width()); + } + + // optional bool gifPlayback = 8; + if (cached_has_bits & 0x00040000u) { + total_size += 1 + 1; + } + + // optional bool viewOnce = 20; + if (cached_has_bits & 0x00080000u) { + total_size += 2 + 1; + } + + // optional int64 mediaKeyTimestamp = 14; + if (cached_has_bits & 0x00100000u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_mediakeytimestamp()); + } + + // optional .proto.Message.VideoMessage.Attribution gifAttribution = 19; + if (cached_has_bits & 0x00200000u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_gifattribution()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_VideoMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message_VideoMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_VideoMessage::GetClassData() const { return &_class_data_; } + + +void Message_VideoMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.VideoMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.interactiveannotations_.MergeFrom(from._impl_.interactiveannotations_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_url(from._internal_url()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_mimetype(from._internal_mimetype()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_filesha256(from._internal_filesha256()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_set_mediakey(from._internal_mediakey()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_set_caption(from._internal_caption()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_set_fileencsha256(from._internal_fileencsha256()); + } + if (cached_has_bits & 0x00000040u) { + _this->_internal_set_directpath(from._internal_directpath()); + } + if (cached_has_bits & 0x00000080u) { + _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail()); + } + } + if (cached_has_bits & 0x0000ff00u) { + if (cached_has_bits & 0x00000100u) { + _this->_internal_set_streamingsidecar(from._internal_streamingsidecar()); + } + if (cached_has_bits & 0x00000200u) { + _this->_internal_set_thumbnaildirectpath(from._internal_thumbnaildirectpath()); + } + if (cached_has_bits & 0x00000400u) { + _this->_internal_set_thumbnailsha256(from._internal_thumbnailsha256()); + } + if (cached_has_bits & 0x00000800u) { + _this->_internal_set_thumbnailencsha256(from._internal_thumbnailencsha256()); + } + if (cached_has_bits & 0x00001000u) { + _this->_internal_set_staticurl(from._internal_staticurl()); + } + if (cached_has_bits & 0x00002000u) { + _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( + from._internal_contextinfo()); + } + if (cached_has_bits & 0x00004000u) { + _this->_impl_.filelength_ = from._impl_.filelength_; + } + if (cached_has_bits & 0x00008000u) { + _this->_impl_.seconds_ = from._impl_.seconds_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x003f0000u) { + if (cached_has_bits & 0x00010000u) { + _this->_impl_.height_ = from._impl_.height_; + } + if (cached_has_bits & 0x00020000u) { + _this->_impl_.width_ = from._impl_.width_; + } + if (cached_has_bits & 0x00040000u) { + _this->_impl_.gifplayback_ = from._impl_.gifplayback_; + } + if (cached_has_bits & 0x00080000u) { + _this->_impl_.viewonce_ = from._impl_.viewonce_; + } + if (cached_has_bits & 0x00100000u) { + _this->_impl_.mediakeytimestamp_ = from._impl_.mediakeytimestamp_; + } + if (cached_has_bits & 0x00200000u) { + _this->_impl_.gifattribution_ = from._impl_.gifattribution_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message_VideoMessage::CopyFrom(const Message_VideoMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.VideoMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message_VideoMessage::IsInitialized() const { + return true; +} + +void Message_VideoMessage::InternalSwap(Message_VideoMessage* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.interactiveannotations_.InternalSwap(&other->_impl_.interactiveannotations_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.url_, lhs_arena, + &other->_impl_.url_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.mimetype_, lhs_arena, + &other->_impl_.mimetype_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.filesha256_, lhs_arena, + &other->_impl_.filesha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.mediakey_, lhs_arena, + &other->_impl_.mediakey_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.caption_, lhs_arena, + &other->_impl_.caption_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.fileencsha256_, lhs_arena, + &other->_impl_.fileencsha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.directpath_, lhs_arena, + &other->_impl_.directpath_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.jpegthumbnail_, lhs_arena, + &other->_impl_.jpegthumbnail_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.streamingsidecar_, lhs_arena, + &other->_impl_.streamingsidecar_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.thumbnaildirectpath_, lhs_arena, + &other->_impl_.thumbnaildirectpath_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.thumbnailsha256_, lhs_arena, + &other->_impl_.thumbnailsha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.thumbnailencsha256_, lhs_arena, + &other->_impl_.thumbnailencsha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.staticurl_, lhs_arena, + &other->_impl_.staticurl_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message_VideoMessage, _impl_.gifattribution_) + + sizeof(Message_VideoMessage::_impl_.gifattribution_) + - PROTOBUF_FIELD_OFFSET(Message_VideoMessage, _impl_.contextinfo_)>( + reinterpret_cast(&_impl_.contextinfo_), + reinterpret_cast(&other->_impl_.contextinfo_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message_VideoMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[136]); +} + +// =================================================================== + +class Message::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_conversation(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::proto::Message_SenderKeyDistributionMessage& senderkeydistributionmessage(const Message* msg); + static void set_has_senderkeydistributionmessage(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::proto::Message_ImageMessage& imagemessage(const Message* msg); + static void set_has_imagemessage(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static const ::proto::Message_ContactMessage& contactmessage(const Message* msg); + static void set_has_contactmessage(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static const ::proto::Message_LocationMessage& locationmessage(const Message* msg); + static void set_has_locationmessage(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static const ::proto::Message_ExtendedTextMessage& extendedtextmessage(const Message* msg); + static void set_has_extendedtextmessage(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static const ::proto::Message_DocumentMessage& documentmessage(const Message* msg); + static void set_has_documentmessage(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static const ::proto::Message_AudioMessage& audiomessage(const Message* msg); + static void set_has_audiomessage(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static const ::proto::Message_VideoMessage& videomessage(const Message* msg); + static void set_has_videomessage(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static const ::proto::Message_Call& call(const Message* msg); + static void set_has_call(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static const ::proto::Message_Chat& chat(const Message* msg); + static void set_has_chat(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static const ::proto::Message_ProtocolMessage& protocolmessage(const Message* msg); + static void set_has_protocolmessage(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static const ::proto::Message_ContactsArrayMessage& contactsarraymessage(const Message* msg); + static void set_has_contactsarraymessage(HasBits* has_bits) { + (*has_bits)[0] |= 4096u; + } + static const ::proto::Message_HighlyStructuredMessage& highlystructuredmessage(const Message* msg); + static void set_has_highlystructuredmessage(HasBits* has_bits) { + (*has_bits)[0] |= 8192u; + } + static const ::proto::Message_SenderKeyDistributionMessage& fastratchetkeysenderkeydistributionmessage(const Message* msg); + static void set_has_fastratchetkeysenderkeydistributionmessage(HasBits* has_bits) { + (*has_bits)[0] |= 16384u; + } + static const ::proto::Message_SendPaymentMessage& sendpaymentmessage(const Message* msg); + static void set_has_sendpaymentmessage(HasBits* has_bits) { + (*has_bits)[0] |= 32768u; + } + static const ::proto::Message_LiveLocationMessage& livelocationmessage(const Message* msg); + static void set_has_livelocationmessage(HasBits* has_bits) { + (*has_bits)[0] |= 65536u; + } + static const ::proto::Message_RequestPaymentMessage& requestpaymentmessage(const Message* msg); + static void set_has_requestpaymentmessage(HasBits* has_bits) { + (*has_bits)[0] |= 131072u; + } + static const ::proto::Message_DeclinePaymentRequestMessage& declinepaymentrequestmessage(const Message* msg); + static void set_has_declinepaymentrequestmessage(HasBits* has_bits) { + (*has_bits)[0] |= 262144u; + } + static const ::proto::Message_CancelPaymentRequestMessage& cancelpaymentrequestmessage(const Message* msg); + static void set_has_cancelpaymentrequestmessage(HasBits* has_bits) { + (*has_bits)[0] |= 524288u; + } + static const ::proto::Message_TemplateMessage& templatemessage(const Message* msg); + static void set_has_templatemessage(HasBits* has_bits) { + (*has_bits)[0] |= 1048576u; + } + static const ::proto::Message_StickerMessage& stickermessage(const Message* msg); + static void set_has_stickermessage(HasBits* has_bits) { + (*has_bits)[0] |= 2097152u; + } + static const ::proto::Message_GroupInviteMessage& groupinvitemessage(const Message* msg); + static void set_has_groupinvitemessage(HasBits* has_bits) { + (*has_bits)[0] |= 4194304u; + } + static const ::proto::Message_TemplateButtonReplyMessage& templatebuttonreplymessage(const Message* msg); + static void set_has_templatebuttonreplymessage(HasBits* has_bits) { + (*has_bits)[0] |= 8388608u; + } + static const ::proto::Message_ProductMessage& productmessage(const Message* msg); + static void set_has_productmessage(HasBits* has_bits) { + (*has_bits)[0] |= 16777216u; + } + static const ::proto::Message_DeviceSentMessage& devicesentmessage(const Message* msg); + static void set_has_devicesentmessage(HasBits* has_bits) { + (*has_bits)[0] |= 33554432u; + } + static const ::proto::MessageContextInfo& messagecontextinfo(const Message* msg); + static void set_has_messagecontextinfo(HasBits* has_bits) { + (*has_bits)[0] |= 67108864u; + } + static const ::proto::Message_ListMessage& listmessage(const Message* msg); + static void set_has_listmessage(HasBits* has_bits) { + (*has_bits)[0] |= 134217728u; + } + static const ::proto::Message_FutureProofMessage& viewoncemessage(const Message* msg); + static void set_has_viewoncemessage(HasBits* has_bits) { + (*has_bits)[0] |= 268435456u; + } + static const ::proto::Message_OrderMessage& ordermessage(const Message* msg); + static void set_has_ordermessage(HasBits* has_bits) { + (*has_bits)[0] |= 536870912u; + } + static const ::proto::Message_ListResponseMessage& listresponsemessage(const Message* msg); + static void set_has_listresponsemessage(HasBits* has_bits) { + (*has_bits)[0] |= 1073741824u; + } + static const ::proto::Message_FutureProofMessage& ephemeralmessage(const Message* msg); + static void set_has_ephemeralmessage(HasBits* has_bits) { + (*has_bits)[0] |= 2147483648u; + } + static const ::proto::Message_InvoiceMessage& invoicemessage(const Message* msg); + static void set_has_invoicemessage(HasBits* has_bits) { + (*has_bits)[1] |= 1u; + } + static const ::proto::Message_ButtonsMessage& buttonsmessage(const Message* msg); + static void set_has_buttonsmessage(HasBits* has_bits) { + (*has_bits)[1] |= 2u; + } + static const ::proto::Message_ButtonsResponseMessage& buttonsresponsemessage(const Message* msg); + static void set_has_buttonsresponsemessage(HasBits* has_bits) { + (*has_bits)[1] |= 4u; + } + static const ::proto::Message_PaymentInviteMessage& paymentinvitemessage(const Message* msg); + static void set_has_paymentinvitemessage(HasBits* has_bits) { + (*has_bits)[1] |= 8u; + } + static const ::proto::Message_InteractiveMessage& interactivemessage(const Message* msg); + static void set_has_interactivemessage(HasBits* has_bits) { + (*has_bits)[1] |= 16u; + } + static const ::proto::Message_ReactionMessage& reactionmessage(const Message* msg); + static void set_has_reactionmessage(HasBits* has_bits) { + (*has_bits)[1] |= 32u; + } + static const ::proto::Message_StickerSyncRMRMessage& stickersyncrmrmessage(const Message* msg); + static void set_has_stickersyncrmrmessage(HasBits* has_bits) { + (*has_bits)[1] |= 64u; + } + static const ::proto::Message_InteractiveResponseMessage& interactiveresponsemessage(const Message* msg); + static void set_has_interactiveresponsemessage(HasBits* has_bits) { + (*has_bits)[1] |= 128u; + } + static const ::proto::Message_PollCreationMessage& pollcreationmessage(const Message* msg); + static void set_has_pollcreationmessage(HasBits* has_bits) { + (*has_bits)[1] |= 256u; + } + static const ::proto::Message_PollUpdateMessage& pollupdatemessage(const Message* msg); + static void set_has_pollupdatemessage(HasBits* has_bits) { + (*has_bits)[1] |= 512u; + } + static const ::proto::Message_KeepInChatMessage& keepinchatmessage(const Message* msg); + static void set_has_keepinchatmessage(HasBits* has_bits) { + (*has_bits)[1] |= 1024u; + } + static const ::proto::Message_FutureProofMessage& documentwithcaptionmessage(const Message* msg); + static void set_has_documentwithcaptionmessage(HasBits* has_bits) { + (*has_bits)[1] |= 2048u; + } + static const ::proto::Message_RequestPhoneNumberMessage& requestphonenumbermessage(const Message* msg); + static void set_has_requestphonenumbermessage(HasBits* has_bits) { + (*has_bits)[1] |= 4096u; + } + static const ::proto::Message_FutureProofMessage& viewoncemessagev2(const Message* msg); + static void set_has_viewoncemessagev2(HasBits* has_bits) { + (*has_bits)[1] |= 8192u; + } +}; + +const ::proto::Message_SenderKeyDistributionMessage& +Message::_Internal::senderkeydistributionmessage(const Message* msg) { + return *msg->_impl_.senderkeydistributionmessage_; +} +const ::proto::Message_ImageMessage& +Message::_Internal::imagemessage(const Message* msg) { + return *msg->_impl_.imagemessage_; +} +const ::proto::Message_ContactMessage& +Message::_Internal::contactmessage(const Message* msg) { + return *msg->_impl_.contactmessage_; +} +const ::proto::Message_LocationMessage& +Message::_Internal::locationmessage(const Message* msg) { + return *msg->_impl_.locationmessage_; +} +const ::proto::Message_ExtendedTextMessage& +Message::_Internal::extendedtextmessage(const Message* msg) { + return *msg->_impl_.extendedtextmessage_; +} +const ::proto::Message_DocumentMessage& +Message::_Internal::documentmessage(const Message* msg) { + return *msg->_impl_.documentmessage_; +} +const ::proto::Message_AudioMessage& +Message::_Internal::audiomessage(const Message* msg) { + return *msg->_impl_.audiomessage_; +} +const ::proto::Message_VideoMessage& +Message::_Internal::videomessage(const Message* msg) { + return *msg->_impl_.videomessage_; +} +const ::proto::Message_Call& +Message::_Internal::call(const Message* msg) { + return *msg->_impl_.call_; +} +const ::proto::Message_Chat& +Message::_Internal::chat(const Message* msg) { + return *msg->_impl_.chat_; +} +const ::proto::Message_ProtocolMessage& +Message::_Internal::protocolmessage(const Message* msg) { + return *msg->_impl_.protocolmessage_; +} +const ::proto::Message_ContactsArrayMessage& +Message::_Internal::contactsarraymessage(const Message* msg) { + return *msg->_impl_.contactsarraymessage_; +} +const ::proto::Message_HighlyStructuredMessage& +Message::_Internal::highlystructuredmessage(const Message* msg) { + return *msg->_impl_.highlystructuredmessage_; +} +const ::proto::Message_SenderKeyDistributionMessage& +Message::_Internal::fastratchetkeysenderkeydistributionmessage(const Message* msg) { + return *msg->_impl_.fastratchetkeysenderkeydistributionmessage_; +} +const ::proto::Message_SendPaymentMessage& +Message::_Internal::sendpaymentmessage(const Message* msg) { + return *msg->_impl_.sendpaymentmessage_; +} +const ::proto::Message_LiveLocationMessage& +Message::_Internal::livelocationmessage(const Message* msg) { + return *msg->_impl_.livelocationmessage_; +} +const ::proto::Message_RequestPaymentMessage& +Message::_Internal::requestpaymentmessage(const Message* msg) { + return *msg->_impl_.requestpaymentmessage_; +} +const ::proto::Message_DeclinePaymentRequestMessage& +Message::_Internal::declinepaymentrequestmessage(const Message* msg) { + return *msg->_impl_.declinepaymentrequestmessage_; +} +const ::proto::Message_CancelPaymentRequestMessage& +Message::_Internal::cancelpaymentrequestmessage(const Message* msg) { + return *msg->_impl_.cancelpaymentrequestmessage_; +} +const ::proto::Message_TemplateMessage& +Message::_Internal::templatemessage(const Message* msg) { + return *msg->_impl_.templatemessage_; +} +const ::proto::Message_StickerMessage& +Message::_Internal::stickermessage(const Message* msg) { + return *msg->_impl_.stickermessage_; +} +const ::proto::Message_GroupInviteMessage& +Message::_Internal::groupinvitemessage(const Message* msg) { + return *msg->_impl_.groupinvitemessage_; +} +const ::proto::Message_TemplateButtonReplyMessage& +Message::_Internal::templatebuttonreplymessage(const Message* msg) { + return *msg->_impl_.templatebuttonreplymessage_; +} +const ::proto::Message_ProductMessage& +Message::_Internal::productmessage(const Message* msg) { + return *msg->_impl_.productmessage_; +} +const ::proto::Message_DeviceSentMessage& +Message::_Internal::devicesentmessage(const Message* msg) { + return *msg->_impl_.devicesentmessage_; +} +const ::proto::MessageContextInfo& +Message::_Internal::messagecontextinfo(const Message* msg) { + return *msg->_impl_.messagecontextinfo_; +} +const ::proto::Message_ListMessage& +Message::_Internal::listmessage(const Message* msg) { + return *msg->_impl_.listmessage_; +} +const ::proto::Message_FutureProofMessage& +Message::_Internal::viewoncemessage(const Message* msg) { + return *msg->_impl_.viewoncemessage_; +} +const ::proto::Message_OrderMessage& +Message::_Internal::ordermessage(const Message* msg) { + return *msg->_impl_.ordermessage_; +} +const ::proto::Message_ListResponseMessage& +Message::_Internal::listresponsemessage(const Message* msg) { + return *msg->_impl_.listresponsemessage_; +} +const ::proto::Message_FutureProofMessage& +Message::_Internal::ephemeralmessage(const Message* msg) { + return *msg->_impl_.ephemeralmessage_; +} +const ::proto::Message_InvoiceMessage& +Message::_Internal::invoicemessage(const Message* msg) { + return *msg->_impl_.invoicemessage_; +} +const ::proto::Message_ButtonsMessage& +Message::_Internal::buttonsmessage(const Message* msg) { + return *msg->_impl_.buttonsmessage_; +} +const ::proto::Message_ButtonsResponseMessage& +Message::_Internal::buttonsresponsemessage(const Message* msg) { + return *msg->_impl_.buttonsresponsemessage_; +} +const ::proto::Message_PaymentInviteMessage& +Message::_Internal::paymentinvitemessage(const Message* msg) { + return *msg->_impl_.paymentinvitemessage_; +} +const ::proto::Message_InteractiveMessage& +Message::_Internal::interactivemessage(const Message* msg) { + return *msg->_impl_.interactivemessage_; +} +const ::proto::Message_ReactionMessage& +Message::_Internal::reactionmessage(const Message* msg) { + return *msg->_impl_.reactionmessage_; +} +const ::proto::Message_StickerSyncRMRMessage& +Message::_Internal::stickersyncrmrmessage(const Message* msg) { + return *msg->_impl_.stickersyncrmrmessage_; +} +const ::proto::Message_InteractiveResponseMessage& +Message::_Internal::interactiveresponsemessage(const Message* msg) { + return *msg->_impl_.interactiveresponsemessage_; +} +const ::proto::Message_PollCreationMessage& +Message::_Internal::pollcreationmessage(const Message* msg) { + return *msg->_impl_.pollcreationmessage_; +} +const ::proto::Message_PollUpdateMessage& +Message::_Internal::pollupdatemessage(const Message* msg) { + return *msg->_impl_.pollupdatemessage_; +} +const ::proto::Message_KeepInChatMessage& +Message::_Internal::keepinchatmessage(const Message* msg) { + return *msg->_impl_.keepinchatmessage_; +} +const ::proto::Message_FutureProofMessage& +Message::_Internal::documentwithcaptionmessage(const Message* msg) { + return *msg->_impl_.documentwithcaptionmessage_; +} +const ::proto::Message_RequestPhoneNumberMessage& +Message::_Internal::requestphonenumbermessage(const Message* msg) { + return *msg->_impl_.requestphonenumbermessage_; +} +const ::proto::Message_FutureProofMessage& +Message::_Internal::viewoncemessagev2(const Message* msg) { + return *msg->_impl_.viewoncemessagev2_; +} +Message::Message(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Message) +} +Message::Message(const Message& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Message* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.conversation_){} + , decltype(_impl_.senderkeydistributionmessage_){nullptr} + , decltype(_impl_.imagemessage_){nullptr} + , decltype(_impl_.contactmessage_){nullptr} + , decltype(_impl_.locationmessage_){nullptr} + , decltype(_impl_.extendedtextmessage_){nullptr} + , decltype(_impl_.documentmessage_){nullptr} + , decltype(_impl_.audiomessage_){nullptr} + , decltype(_impl_.videomessage_){nullptr} + , decltype(_impl_.call_){nullptr} + , decltype(_impl_.chat_){nullptr} + , decltype(_impl_.protocolmessage_){nullptr} + , decltype(_impl_.contactsarraymessage_){nullptr} + , decltype(_impl_.highlystructuredmessage_){nullptr} + , decltype(_impl_.fastratchetkeysenderkeydistributionmessage_){nullptr} + , decltype(_impl_.sendpaymentmessage_){nullptr} + , decltype(_impl_.livelocationmessage_){nullptr} + , decltype(_impl_.requestpaymentmessage_){nullptr} + , decltype(_impl_.declinepaymentrequestmessage_){nullptr} + , decltype(_impl_.cancelpaymentrequestmessage_){nullptr} + , decltype(_impl_.templatemessage_){nullptr} + , decltype(_impl_.stickermessage_){nullptr} + , decltype(_impl_.groupinvitemessage_){nullptr} + , decltype(_impl_.templatebuttonreplymessage_){nullptr} + , decltype(_impl_.productmessage_){nullptr} + , decltype(_impl_.devicesentmessage_){nullptr} + , decltype(_impl_.messagecontextinfo_){nullptr} + , decltype(_impl_.listmessage_){nullptr} + , decltype(_impl_.viewoncemessage_){nullptr} + , decltype(_impl_.ordermessage_){nullptr} + , decltype(_impl_.listresponsemessage_){nullptr} + , decltype(_impl_.ephemeralmessage_){nullptr} + , decltype(_impl_.invoicemessage_){nullptr} + , decltype(_impl_.buttonsmessage_){nullptr} + , decltype(_impl_.buttonsresponsemessage_){nullptr} + , decltype(_impl_.paymentinvitemessage_){nullptr} + , decltype(_impl_.interactivemessage_){nullptr} + , decltype(_impl_.reactionmessage_){nullptr} + , decltype(_impl_.stickersyncrmrmessage_){nullptr} + , decltype(_impl_.interactiveresponsemessage_){nullptr} + , decltype(_impl_.pollcreationmessage_){nullptr} + , decltype(_impl_.pollupdatemessage_){nullptr} + , decltype(_impl_.keepinchatmessage_){nullptr} + , decltype(_impl_.documentwithcaptionmessage_){nullptr} + , decltype(_impl_.requestphonenumbermessage_){nullptr} + , decltype(_impl_.viewoncemessagev2_){nullptr}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.conversation_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.conversation_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_conversation()) { + _this->_impl_.conversation_.Set(from._internal_conversation(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_senderkeydistributionmessage()) { + _this->_impl_.senderkeydistributionmessage_ = new ::proto::Message_SenderKeyDistributionMessage(*from._impl_.senderkeydistributionmessage_); + } + if (from._internal_has_imagemessage()) { + _this->_impl_.imagemessage_ = new ::proto::Message_ImageMessage(*from._impl_.imagemessage_); + } + if (from._internal_has_contactmessage()) { + _this->_impl_.contactmessage_ = new ::proto::Message_ContactMessage(*from._impl_.contactmessage_); + } + if (from._internal_has_locationmessage()) { + _this->_impl_.locationmessage_ = new ::proto::Message_LocationMessage(*from._impl_.locationmessage_); + } + if (from._internal_has_extendedtextmessage()) { + _this->_impl_.extendedtextmessage_ = new ::proto::Message_ExtendedTextMessage(*from._impl_.extendedtextmessage_); + } + if (from._internal_has_documentmessage()) { + _this->_impl_.documentmessage_ = new ::proto::Message_DocumentMessage(*from._impl_.documentmessage_); + } + if (from._internal_has_audiomessage()) { + _this->_impl_.audiomessage_ = new ::proto::Message_AudioMessage(*from._impl_.audiomessage_); + } + if (from._internal_has_videomessage()) { + _this->_impl_.videomessage_ = new ::proto::Message_VideoMessage(*from._impl_.videomessage_); + } + if (from._internal_has_call()) { + _this->_impl_.call_ = new ::proto::Message_Call(*from._impl_.call_); + } + if (from._internal_has_chat()) { + _this->_impl_.chat_ = new ::proto::Message_Chat(*from._impl_.chat_); + } + if (from._internal_has_protocolmessage()) { + _this->_impl_.protocolmessage_ = new ::proto::Message_ProtocolMessage(*from._impl_.protocolmessage_); + } + if (from._internal_has_contactsarraymessage()) { + _this->_impl_.contactsarraymessage_ = new ::proto::Message_ContactsArrayMessage(*from._impl_.contactsarraymessage_); + } + if (from._internal_has_highlystructuredmessage()) { + _this->_impl_.highlystructuredmessage_ = new ::proto::Message_HighlyStructuredMessage(*from._impl_.highlystructuredmessage_); + } + if (from._internal_has_fastratchetkeysenderkeydistributionmessage()) { + _this->_impl_.fastratchetkeysenderkeydistributionmessage_ = new ::proto::Message_SenderKeyDistributionMessage(*from._impl_.fastratchetkeysenderkeydistributionmessage_); + } + if (from._internal_has_sendpaymentmessage()) { + _this->_impl_.sendpaymentmessage_ = new ::proto::Message_SendPaymentMessage(*from._impl_.sendpaymentmessage_); + } + if (from._internal_has_livelocationmessage()) { + _this->_impl_.livelocationmessage_ = new ::proto::Message_LiveLocationMessage(*from._impl_.livelocationmessage_); + } + if (from._internal_has_requestpaymentmessage()) { + _this->_impl_.requestpaymentmessage_ = new ::proto::Message_RequestPaymentMessage(*from._impl_.requestpaymentmessage_); + } + if (from._internal_has_declinepaymentrequestmessage()) { + _this->_impl_.declinepaymentrequestmessage_ = new ::proto::Message_DeclinePaymentRequestMessage(*from._impl_.declinepaymentrequestmessage_); + } + if (from._internal_has_cancelpaymentrequestmessage()) { + _this->_impl_.cancelpaymentrequestmessage_ = new ::proto::Message_CancelPaymentRequestMessage(*from._impl_.cancelpaymentrequestmessage_); + } + if (from._internal_has_templatemessage()) { + _this->_impl_.templatemessage_ = new ::proto::Message_TemplateMessage(*from._impl_.templatemessage_); + } + if (from._internal_has_stickermessage()) { + _this->_impl_.stickermessage_ = new ::proto::Message_StickerMessage(*from._impl_.stickermessage_); + } + if (from._internal_has_groupinvitemessage()) { + _this->_impl_.groupinvitemessage_ = new ::proto::Message_GroupInviteMessage(*from._impl_.groupinvitemessage_); + } + if (from._internal_has_templatebuttonreplymessage()) { + _this->_impl_.templatebuttonreplymessage_ = new ::proto::Message_TemplateButtonReplyMessage(*from._impl_.templatebuttonreplymessage_); + } + if (from._internal_has_productmessage()) { + _this->_impl_.productmessage_ = new ::proto::Message_ProductMessage(*from._impl_.productmessage_); + } + if (from._internal_has_devicesentmessage()) { + _this->_impl_.devicesentmessage_ = new ::proto::Message_DeviceSentMessage(*from._impl_.devicesentmessage_); + } + if (from._internal_has_messagecontextinfo()) { + _this->_impl_.messagecontextinfo_ = new ::proto::MessageContextInfo(*from._impl_.messagecontextinfo_); + } + if (from._internal_has_listmessage()) { + _this->_impl_.listmessage_ = new ::proto::Message_ListMessage(*from._impl_.listmessage_); + } + if (from._internal_has_viewoncemessage()) { + _this->_impl_.viewoncemessage_ = new ::proto::Message_FutureProofMessage(*from._impl_.viewoncemessage_); + } + if (from._internal_has_ordermessage()) { + _this->_impl_.ordermessage_ = new ::proto::Message_OrderMessage(*from._impl_.ordermessage_); + } + if (from._internal_has_listresponsemessage()) { + _this->_impl_.listresponsemessage_ = new ::proto::Message_ListResponseMessage(*from._impl_.listresponsemessage_); + } + if (from._internal_has_ephemeralmessage()) { + _this->_impl_.ephemeralmessage_ = new ::proto::Message_FutureProofMessage(*from._impl_.ephemeralmessage_); + } + if (from._internal_has_invoicemessage()) { + _this->_impl_.invoicemessage_ = new ::proto::Message_InvoiceMessage(*from._impl_.invoicemessage_); + } + if (from._internal_has_buttonsmessage()) { + _this->_impl_.buttonsmessage_ = new ::proto::Message_ButtonsMessage(*from._impl_.buttonsmessage_); + } + if (from._internal_has_buttonsresponsemessage()) { + _this->_impl_.buttonsresponsemessage_ = new ::proto::Message_ButtonsResponseMessage(*from._impl_.buttonsresponsemessage_); + } + if (from._internal_has_paymentinvitemessage()) { + _this->_impl_.paymentinvitemessage_ = new ::proto::Message_PaymentInviteMessage(*from._impl_.paymentinvitemessage_); + } + if (from._internal_has_interactivemessage()) { + _this->_impl_.interactivemessage_ = new ::proto::Message_InteractiveMessage(*from._impl_.interactivemessage_); + } + if (from._internal_has_reactionmessage()) { + _this->_impl_.reactionmessage_ = new ::proto::Message_ReactionMessage(*from._impl_.reactionmessage_); + } + if (from._internal_has_stickersyncrmrmessage()) { + _this->_impl_.stickersyncrmrmessage_ = new ::proto::Message_StickerSyncRMRMessage(*from._impl_.stickersyncrmrmessage_); + } + if (from._internal_has_interactiveresponsemessage()) { + _this->_impl_.interactiveresponsemessage_ = new ::proto::Message_InteractiveResponseMessage(*from._impl_.interactiveresponsemessage_); + } + if (from._internal_has_pollcreationmessage()) { + _this->_impl_.pollcreationmessage_ = new ::proto::Message_PollCreationMessage(*from._impl_.pollcreationmessage_); + } + if (from._internal_has_pollupdatemessage()) { + _this->_impl_.pollupdatemessage_ = new ::proto::Message_PollUpdateMessage(*from._impl_.pollupdatemessage_); + } + if (from._internal_has_keepinchatmessage()) { + _this->_impl_.keepinchatmessage_ = new ::proto::Message_KeepInChatMessage(*from._impl_.keepinchatmessage_); + } + if (from._internal_has_documentwithcaptionmessage()) { + _this->_impl_.documentwithcaptionmessage_ = new ::proto::Message_FutureProofMessage(*from._impl_.documentwithcaptionmessage_); + } + if (from._internal_has_requestphonenumbermessage()) { + _this->_impl_.requestphonenumbermessage_ = new ::proto::Message_RequestPhoneNumberMessage(*from._impl_.requestphonenumbermessage_); + } + if (from._internal_has_viewoncemessagev2()) { + _this->_impl_.viewoncemessagev2_ = new ::proto::Message_FutureProofMessage(*from._impl_.viewoncemessagev2_); + } + // @@protoc_insertion_point(copy_constructor:proto.Message) +} + +inline void Message::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.conversation_){} + , decltype(_impl_.senderkeydistributionmessage_){nullptr} + , decltype(_impl_.imagemessage_){nullptr} + , decltype(_impl_.contactmessage_){nullptr} + , decltype(_impl_.locationmessage_){nullptr} + , decltype(_impl_.extendedtextmessage_){nullptr} + , decltype(_impl_.documentmessage_){nullptr} + , decltype(_impl_.audiomessage_){nullptr} + , decltype(_impl_.videomessage_){nullptr} + , decltype(_impl_.call_){nullptr} + , decltype(_impl_.chat_){nullptr} + , decltype(_impl_.protocolmessage_){nullptr} + , decltype(_impl_.contactsarraymessage_){nullptr} + , decltype(_impl_.highlystructuredmessage_){nullptr} + , decltype(_impl_.fastratchetkeysenderkeydistributionmessage_){nullptr} + , decltype(_impl_.sendpaymentmessage_){nullptr} + , decltype(_impl_.livelocationmessage_){nullptr} + , decltype(_impl_.requestpaymentmessage_){nullptr} + , decltype(_impl_.declinepaymentrequestmessage_){nullptr} + , decltype(_impl_.cancelpaymentrequestmessage_){nullptr} + , decltype(_impl_.templatemessage_){nullptr} + , decltype(_impl_.stickermessage_){nullptr} + , decltype(_impl_.groupinvitemessage_){nullptr} + , decltype(_impl_.templatebuttonreplymessage_){nullptr} + , decltype(_impl_.productmessage_){nullptr} + , decltype(_impl_.devicesentmessage_){nullptr} + , decltype(_impl_.messagecontextinfo_){nullptr} + , decltype(_impl_.listmessage_){nullptr} + , decltype(_impl_.viewoncemessage_){nullptr} + , decltype(_impl_.ordermessage_){nullptr} + , decltype(_impl_.listresponsemessage_){nullptr} + , decltype(_impl_.ephemeralmessage_){nullptr} + , decltype(_impl_.invoicemessage_){nullptr} + , decltype(_impl_.buttonsmessage_){nullptr} + , decltype(_impl_.buttonsresponsemessage_){nullptr} + , decltype(_impl_.paymentinvitemessage_){nullptr} + , decltype(_impl_.interactivemessage_){nullptr} + , decltype(_impl_.reactionmessage_){nullptr} + , decltype(_impl_.stickersyncrmrmessage_){nullptr} + , decltype(_impl_.interactiveresponsemessage_){nullptr} + , decltype(_impl_.pollcreationmessage_){nullptr} + , decltype(_impl_.pollupdatemessage_){nullptr} + , decltype(_impl_.keepinchatmessage_){nullptr} + , decltype(_impl_.documentwithcaptionmessage_){nullptr} + , decltype(_impl_.requestphonenumbermessage_){nullptr} + , decltype(_impl_.viewoncemessagev2_){nullptr} + }; + _impl_.conversation_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.conversation_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Message::~Message() { + // @@protoc_insertion_point(destructor:proto.Message) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Message::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.conversation_.Destroy(); + if (this != internal_default_instance()) delete _impl_.senderkeydistributionmessage_; + if (this != internal_default_instance()) delete _impl_.imagemessage_; + if (this != internal_default_instance()) delete _impl_.contactmessage_; + if (this != internal_default_instance()) delete _impl_.locationmessage_; + if (this != internal_default_instance()) delete _impl_.extendedtextmessage_; + if (this != internal_default_instance()) delete _impl_.documentmessage_; + if (this != internal_default_instance()) delete _impl_.audiomessage_; + if (this != internal_default_instance()) delete _impl_.videomessage_; + if (this != internal_default_instance()) delete _impl_.call_; + if (this != internal_default_instance()) delete _impl_.chat_; + if (this != internal_default_instance()) delete _impl_.protocolmessage_; + if (this != internal_default_instance()) delete _impl_.contactsarraymessage_; + if (this != internal_default_instance()) delete _impl_.highlystructuredmessage_; + if (this != internal_default_instance()) delete _impl_.fastratchetkeysenderkeydistributionmessage_; + if (this != internal_default_instance()) delete _impl_.sendpaymentmessage_; + if (this != internal_default_instance()) delete _impl_.livelocationmessage_; + if (this != internal_default_instance()) delete _impl_.requestpaymentmessage_; + if (this != internal_default_instance()) delete _impl_.declinepaymentrequestmessage_; + if (this != internal_default_instance()) delete _impl_.cancelpaymentrequestmessage_; + if (this != internal_default_instance()) delete _impl_.templatemessage_; + if (this != internal_default_instance()) delete _impl_.stickermessage_; + if (this != internal_default_instance()) delete _impl_.groupinvitemessage_; + if (this != internal_default_instance()) delete _impl_.templatebuttonreplymessage_; + if (this != internal_default_instance()) delete _impl_.productmessage_; + if (this != internal_default_instance()) delete _impl_.devicesentmessage_; + if (this != internal_default_instance()) delete _impl_.messagecontextinfo_; + if (this != internal_default_instance()) delete _impl_.listmessage_; + if (this != internal_default_instance()) delete _impl_.viewoncemessage_; + if (this != internal_default_instance()) delete _impl_.ordermessage_; + if (this != internal_default_instance()) delete _impl_.listresponsemessage_; + if (this != internal_default_instance()) delete _impl_.ephemeralmessage_; + if (this != internal_default_instance()) delete _impl_.invoicemessage_; + if (this != internal_default_instance()) delete _impl_.buttonsmessage_; + if (this != internal_default_instance()) delete _impl_.buttonsresponsemessage_; + if (this != internal_default_instance()) delete _impl_.paymentinvitemessage_; + if (this != internal_default_instance()) delete _impl_.interactivemessage_; + if (this != internal_default_instance()) delete _impl_.reactionmessage_; + if (this != internal_default_instance()) delete _impl_.stickersyncrmrmessage_; + if (this != internal_default_instance()) delete _impl_.interactiveresponsemessage_; + if (this != internal_default_instance()) delete _impl_.pollcreationmessage_; + if (this != internal_default_instance()) delete _impl_.pollupdatemessage_; + if (this != internal_default_instance()) delete _impl_.keepinchatmessage_; + if (this != internal_default_instance()) delete _impl_.documentwithcaptionmessage_; + if (this != internal_default_instance()) delete _impl_.requestphonenumbermessage_; + if (this != internal_default_instance()) delete _impl_.viewoncemessagev2_; +} + +void Message::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Message::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Message) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _impl_.conversation_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.senderkeydistributionmessage_ != nullptr); + _impl_.senderkeydistributionmessage_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.imagemessage_ != nullptr); + _impl_.imagemessage_->Clear(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(_impl_.contactmessage_ != nullptr); + _impl_.contactmessage_->Clear(); + } + if (cached_has_bits & 0x00000010u) { + GOOGLE_DCHECK(_impl_.locationmessage_ != nullptr); + _impl_.locationmessage_->Clear(); + } + if (cached_has_bits & 0x00000020u) { + GOOGLE_DCHECK(_impl_.extendedtextmessage_ != nullptr); + _impl_.extendedtextmessage_->Clear(); + } + if (cached_has_bits & 0x00000040u) { + GOOGLE_DCHECK(_impl_.documentmessage_ != nullptr); + _impl_.documentmessage_->Clear(); + } + if (cached_has_bits & 0x00000080u) { + GOOGLE_DCHECK(_impl_.audiomessage_ != nullptr); + _impl_.audiomessage_->Clear(); + } + } + if (cached_has_bits & 0x0000ff00u) { + if (cached_has_bits & 0x00000100u) { + GOOGLE_DCHECK(_impl_.videomessage_ != nullptr); + _impl_.videomessage_->Clear(); + } + if (cached_has_bits & 0x00000200u) { + GOOGLE_DCHECK(_impl_.call_ != nullptr); + _impl_.call_->Clear(); + } + if (cached_has_bits & 0x00000400u) { + GOOGLE_DCHECK(_impl_.chat_ != nullptr); + _impl_.chat_->Clear(); + } + if (cached_has_bits & 0x00000800u) { + GOOGLE_DCHECK(_impl_.protocolmessage_ != nullptr); + _impl_.protocolmessage_->Clear(); + } + if (cached_has_bits & 0x00001000u) { + GOOGLE_DCHECK(_impl_.contactsarraymessage_ != nullptr); + _impl_.contactsarraymessage_->Clear(); + } + if (cached_has_bits & 0x00002000u) { + GOOGLE_DCHECK(_impl_.highlystructuredmessage_ != nullptr); + _impl_.highlystructuredmessage_->Clear(); + } + if (cached_has_bits & 0x00004000u) { + GOOGLE_DCHECK(_impl_.fastratchetkeysenderkeydistributionmessage_ != nullptr); + _impl_.fastratchetkeysenderkeydistributionmessage_->Clear(); + } + if (cached_has_bits & 0x00008000u) { + GOOGLE_DCHECK(_impl_.sendpaymentmessage_ != nullptr); + _impl_.sendpaymentmessage_->Clear(); + } + } + if (cached_has_bits & 0x00ff0000u) { + if (cached_has_bits & 0x00010000u) { + GOOGLE_DCHECK(_impl_.livelocationmessage_ != nullptr); + _impl_.livelocationmessage_->Clear(); + } + if (cached_has_bits & 0x00020000u) { + GOOGLE_DCHECK(_impl_.requestpaymentmessage_ != nullptr); + _impl_.requestpaymentmessage_->Clear(); + } + if (cached_has_bits & 0x00040000u) { + GOOGLE_DCHECK(_impl_.declinepaymentrequestmessage_ != nullptr); + _impl_.declinepaymentrequestmessage_->Clear(); + } + if (cached_has_bits & 0x00080000u) { + GOOGLE_DCHECK(_impl_.cancelpaymentrequestmessage_ != nullptr); + _impl_.cancelpaymentrequestmessage_->Clear(); + } + if (cached_has_bits & 0x00100000u) { + GOOGLE_DCHECK(_impl_.templatemessage_ != nullptr); + _impl_.templatemessage_->Clear(); + } + if (cached_has_bits & 0x00200000u) { + GOOGLE_DCHECK(_impl_.stickermessage_ != nullptr); + _impl_.stickermessage_->Clear(); + } + if (cached_has_bits & 0x00400000u) { + GOOGLE_DCHECK(_impl_.groupinvitemessage_ != nullptr); + _impl_.groupinvitemessage_->Clear(); + } + if (cached_has_bits & 0x00800000u) { + GOOGLE_DCHECK(_impl_.templatebuttonreplymessage_ != nullptr); + _impl_.templatebuttonreplymessage_->Clear(); + } + } + if (cached_has_bits & 0xff000000u) { + if (cached_has_bits & 0x01000000u) { + GOOGLE_DCHECK(_impl_.productmessage_ != nullptr); + _impl_.productmessage_->Clear(); + } + if (cached_has_bits & 0x02000000u) { + GOOGLE_DCHECK(_impl_.devicesentmessage_ != nullptr); + _impl_.devicesentmessage_->Clear(); + } + if (cached_has_bits & 0x04000000u) { + GOOGLE_DCHECK(_impl_.messagecontextinfo_ != nullptr); + _impl_.messagecontextinfo_->Clear(); + } + if (cached_has_bits & 0x08000000u) { + GOOGLE_DCHECK(_impl_.listmessage_ != nullptr); + _impl_.listmessage_->Clear(); + } + if (cached_has_bits & 0x10000000u) { + GOOGLE_DCHECK(_impl_.viewoncemessage_ != nullptr); + _impl_.viewoncemessage_->Clear(); + } + if (cached_has_bits & 0x20000000u) { + GOOGLE_DCHECK(_impl_.ordermessage_ != nullptr); + _impl_.ordermessage_->Clear(); + } + if (cached_has_bits & 0x40000000u) { + GOOGLE_DCHECK(_impl_.listresponsemessage_ != nullptr); + _impl_.listresponsemessage_->Clear(); + } + if (cached_has_bits & 0x80000000u) { + GOOGLE_DCHECK(_impl_.ephemeralmessage_ != nullptr); + _impl_.ephemeralmessage_->Clear(); + } + } + cached_has_bits = _impl_._has_bits_[1]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.invoicemessage_ != nullptr); + _impl_.invoicemessage_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.buttonsmessage_ != nullptr); + _impl_.buttonsmessage_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.buttonsresponsemessage_ != nullptr); + _impl_.buttonsresponsemessage_->Clear(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(_impl_.paymentinvitemessage_ != nullptr); + _impl_.paymentinvitemessage_->Clear(); + } + if (cached_has_bits & 0x00000010u) { + GOOGLE_DCHECK(_impl_.interactivemessage_ != nullptr); + _impl_.interactivemessage_->Clear(); + } + if (cached_has_bits & 0x00000020u) { + GOOGLE_DCHECK(_impl_.reactionmessage_ != nullptr); + _impl_.reactionmessage_->Clear(); + } + if (cached_has_bits & 0x00000040u) { + GOOGLE_DCHECK(_impl_.stickersyncrmrmessage_ != nullptr); + _impl_.stickersyncrmrmessage_->Clear(); + } + if (cached_has_bits & 0x00000080u) { + GOOGLE_DCHECK(_impl_.interactiveresponsemessage_ != nullptr); + _impl_.interactiveresponsemessage_->Clear(); + } + } + if (cached_has_bits & 0x00003f00u) { + if (cached_has_bits & 0x00000100u) { + GOOGLE_DCHECK(_impl_.pollcreationmessage_ != nullptr); + _impl_.pollcreationmessage_->Clear(); + } + if (cached_has_bits & 0x00000200u) { + GOOGLE_DCHECK(_impl_.pollupdatemessage_ != nullptr); + _impl_.pollupdatemessage_->Clear(); + } + if (cached_has_bits & 0x00000400u) { + GOOGLE_DCHECK(_impl_.keepinchatmessage_ != nullptr); + _impl_.keepinchatmessage_->Clear(); + } + if (cached_has_bits & 0x00000800u) { + GOOGLE_DCHECK(_impl_.documentwithcaptionmessage_ != nullptr); + _impl_.documentwithcaptionmessage_->Clear(); + } + if (cached_has_bits & 0x00001000u) { + GOOGLE_DCHECK(_impl_.requestphonenumbermessage_ != nullptr); + _impl_.requestphonenumbermessage_->Clear(); + } + if (cached_has_bits & 0x00002000u) { + GOOGLE_DCHECK(_impl_.viewoncemessagev2_ != nullptr); + _impl_.viewoncemessagev2_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Message::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string conversation = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_conversation(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Message.conversation"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.Message.SenderKeyDistributionMessage senderKeyDistributionMessage = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_senderkeydistributionmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.ImageMessage imageMessage = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_imagemessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.ContactMessage contactMessage = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_contactmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.LocationMessage locationMessage = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_locationmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.ExtendedTextMessage extendedTextMessage = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_extendedtextmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.DocumentMessage documentMessage = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_documentmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.AudioMessage audioMessage = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + ptr = ctx->ParseMessage(_internal_mutable_audiomessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.VideoMessage videoMessage = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + ptr = ctx->ParseMessage(_internal_mutable_videomessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.Call call = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_call(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.Chat chat = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { + ptr = ctx->ParseMessage(_internal_mutable_chat(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.ProtocolMessage protocolMessage = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { + ptr = ctx->ParseMessage(_internal_mutable_protocolmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.ContactsArrayMessage contactsArrayMessage = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { + ptr = ctx->ParseMessage(_internal_mutable_contactsarraymessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.HighlyStructuredMessage highlyStructuredMessage = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) { + ptr = ctx->ParseMessage(_internal_mutable_highlystructuredmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.SenderKeyDistributionMessage fastRatchetKeySenderKeyDistributionMessage = 15; + case 15: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { + ptr = ctx->ParseMessage(_internal_mutable_fastratchetkeysenderkeydistributionmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.SendPaymentMessage sendPaymentMessage = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { + ptr = ctx->ParseMessage(_internal_mutable_sendpaymentmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.LiveLocationMessage liveLocationMessage = 18; + case 18: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { + ptr = ctx->ParseMessage(_internal_mutable_livelocationmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.RequestPaymentMessage requestPaymentMessage = 22; + case 22: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 178)) { + ptr = ctx->ParseMessage(_internal_mutable_requestpaymentmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.DeclinePaymentRequestMessage declinePaymentRequestMessage = 23; + case 23: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { + ptr = ctx->ParseMessage(_internal_mutable_declinepaymentrequestmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.CancelPaymentRequestMessage cancelPaymentRequestMessage = 24; + case 24: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 194)) { + ptr = ctx->ParseMessage(_internal_mutable_cancelpaymentrequestmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.TemplateMessage templateMessage = 25; + case 25: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 202)) { + ptr = ctx->ParseMessage(_internal_mutable_templatemessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.StickerMessage stickerMessage = 26; + case 26: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 210)) { + ptr = ctx->ParseMessage(_internal_mutable_stickermessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.GroupInviteMessage groupInviteMessage = 28; + case 28: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 226)) { + ptr = ctx->ParseMessage(_internal_mutable_groupinvitemessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.TemplateButtonReplyMessage templateButtonReplyMessage = 29; + case 29: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 234)) { + ptr = ctx->ParseMessage(_internal_mutable_templatebuttonreplymessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.ProductMessage productMessage = 30; + case 30: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 242)) { + ptr = ctx->ParseMessage(_internal_mutable_productmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.DeviceSentMessage deviceSentMessage = 31; + case 31: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 250)) { + ptr = ctx->ParseMessage(_internal_mutable_devicesentmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.MessageContextInfo messageContextInfo = 35; + case 35: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_messagecontextinfo(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.ListMessage listMessage = 36; + case 36: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_listmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.FutureProofMessage viewOnceMessage = 37; + case 37: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_viewoncemessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.OrderMessage orderMessage = 38; + case 38: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_ordermessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.ListResponseMessage listResponseMessage = 39; + case 39: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_listresponsemessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.FutureProofMessage ephemeralMessage = 40; + case 40: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + ptr = ctx->ParseMessage(_internal_mutable_ephemeralmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.InvoiceMessage invoiceMessage = 41; + case 41: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + ptr = ctx->ParseMessage(_internal_mutable_invoicemessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.ButtonsMessage buttonsMessage = 42; + case 42: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_buttonsmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.ButtonsResponseMessage buttonsResponseMessage = 43; + case 43: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { + ptr = ctx->ParseMessage(_internal_mutable_buttonsresponsemessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.PaymentInviteMessage paymentInviteMessage = 44; + case 44: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { + ptr = ctx->ParseMessage(_internal_mutable_paymentinvitemessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.InteractiveMessage interactiveMessage = 45; + case 45: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { + ptr = ctx->ParseMessage(_internal_mutable_interactivemessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.ReactionMessage reactionMessage = 46; + case 46: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) { + ptr = ctx->ParseMessage(_internal_mutable_reactionmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.StickerSyncRMRMessage stickerSyncRmrMessage = 47; + case 47: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { + ptr = ctx->ParseMessage(_internal_mutable_stickersyncrmrmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.InteractiveResponseMessage interactiveResponseMessage = 48; + case 48: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { + ptr = ctx->ParseMessage(_internal_mutable_interactiveresponsemessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.PollCreationMessage pollCreationMessage = 49; + case 49: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { + ptr = ctx->ParseMessage(_internal_mutable_pollcreationmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.PollUpdateMessage pollUpdateMessage = 50; + case 50: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { + ptr = ctx->ParseMessage(_internal_mutable_pollupdatemessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.KeepInChatMessage keepInChatMessage = 51; + case 51: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) { + ptr = ctx->ParseMessage(_internal_mutable_keepinchatmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.FutureProofMessage documentWithCaptionMessage = 53; + case 53: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { + ptr = ctx->ParseMessage(_internal_mutable_documentwithcaptionmessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.RequestPhoneNumberMessage requestPhoneNumberMessage = 54; + case 54: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 178)) { + ptr = ctx->ParseMessage(_internal_mutable_requestphonenumbermessage(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.FutureProofMessage viewOnceMessageV2 = 55; + case 55: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { + ptr = ctx->ParseMessage(_internal_mutable_viewoncemessagev2(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Message::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Message) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string conversation = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_conversation().data(), static_cast(this->_internal_conversation().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Message.conversation"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_conversation(), target); + } + + // optional .proto.Message.SenderKeyDistributionMessage senderKeyDistributionMessage = 2; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::senderkeydistributionmessage(this), + _Internal::senderkeydistributionmessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.ImageMessage imageMessage = 3; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::imagemessage(this), + _Internal::imagemessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.ContactMessage contactMessage = 4; + if (cached_has_bits & 0x00000008u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, _Internal::contactmessage(this), + _Internal::contactmessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.LocationMessage locationMessage = 5; + if (cached_has_bits & 0x00000010u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(5, _Internal::locationmessage(this), + _Internal::locationmessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.ExtendedTextMessage extendedTextMessage = 6; + if (cached_has_bits & 0x00000020u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(6, _Internal::extendedtextmessage(this), + _Internal::extendedtextmessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.DocumentMessage documentMessage = 7; + if (cached_has_bits & 0x00000040u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(7, _Internal::documentmessage(this), + _Internal::documentmessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.AudioMessage audioMessage = 8; + if (cached_has_bits & 0x00000080u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(8, _Internal::audiomessage(this), + _Internal::audiomessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.VideoMessage videoMessage = 9; + if (cached_has_bits & 0x00000100u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(9, _Internal::videomessage(this), + _Internal::videomessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.Call call = 10; + if (cached_has_bits & 0x00000200u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(10, _Internal::call(this), + _Internal::call(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.Chat chat = 11; + if (cached_has_bits & 0x00000400u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(11, _Internal::chat(this), + _Internal::chat(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.ProtocolMessage protocolMessage = 12; + if (cached_has_bits & 0x00000800u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(12, _Internal::protocolmessage(this), + _Internal::protocolmessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.ContactsArrayMessage contactsArrayMessage = 13; + if (cached_has_bits & 0x00001000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(13, _Internal::contactsarraymessage(this), + _Internal::contactsarraymessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.HighlyStructuredMessage highlyStructuredMessage = 14; + if (cached_has_bits & 0x00002000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(14, _Internal::highlystructuredmessage(this), + _Internal::highlystructuredmessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.SenderKeyDistributionMessage fastRatchetKeySenderKeyDistributionMessage = 15; + if (cached_has_bits & 0x00004000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(15, _Internal::fastratchetkeysenderkeydistributionmessage(this), + _Internal::fastratchetkeysenderkeydistributionmessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.SendPaymentMessage sendPaymentMessage = 16; + if (cached_has_bits & 0x00008000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(16, _Internal::sendpaymentmessage(this), + _Internal::sendpaymentmessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.LiveLocationMessage liveLocationMessage = 18; + if (cached_has_bits & 0x00010000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(18, _Internal::livelocationmessage(this), + _Internal::livelocationmessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.RequestPaymentMessage requestPaymentMessage = 22; + if (cached_has_bits & 0x00020000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(22, _Internal::requestpaymentmessage(this), + _Internal::requestpaymentmessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.DeclinePaymentRequestMessage declinePaymentRequestMessage = 23; + if (cached_has_bits & 0x00040000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(23, _Internal::declinepaymentrequestmessage(this), + _Internal::declinepaymentrequestmessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.CancelPaymentRequestMessage cancelPaymentRequestMessage = 24; + if (cached_has_bits & 0x00080000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(24, _Internal::cancelpaymentrequestmessage(this), + _Internal::cancelpaymentrequestmessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.TemplateMessage templateMessage = 25; + if (cached_has_bits & 0x00100000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(25, _Internal::templatemessage(this), + _Internal::templatemessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.StickerMessage stickerMessage = 26; + if (cached_has_bits & 0x00200000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(26, _Internal::stickermessage(this), + _Internal::stickermessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.GroupInviteMessage groupInviteMessage = 28; + if (cached_has_bits & 0x00400000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(28, _Internal::groupinvitemessage(this), + _Internal::groupinvitemessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.TemplateButtonReplyMessage templateButtonReplyMessage = 29; + if (cached_has_bits & 0x00800000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(29, _Internal::templatebuttonreplymessage(this), + _Internal::templatebuttonreplymessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.ProductMessage productMessage = 30; + if (cached_has_bits & 0x01000000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(30, _Internal::productmessage(this), + _Internal::productmessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.DeviceSentMessage deviceSentMessage = 31; + if (cached_has_bits & 0x02000000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(31, _Internal::devicesentmessage(this), + _Internal::devicesentmessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.MessageContextInfo messageContextInfo = 35; + if (cached_has_bits & 0x04000000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(35, _Internal::messagecontextinfo(this), + _Internal::messagecontextinfo(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.ListMessage listMessage = 36; + if (cached_has_bits & 0x08000000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(36, _Internal::listmessage(this), + _Internal::listmessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.FutureProofMessage viewOnceMessage = 37; + if (cached_has_bits & 0x10000000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(37, _Internal::viewoncemessage(this), + _Internal::viewoncemessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.OrderMessage orderMessage = 38; + if (cached_has_bits & 0x20000000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(38, _Internal::ordermessage(this), + _Internal::ordermessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.ListResponseMessage listResponseMessage = 39; + if (cached_has_bits & 0x40000000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(39, _Internal::listresponsemessage(this), + _Internal::listresponsemessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.FutureProofMessage ephemeralMessage = 40; + if (cached_has_bits & 0x80000000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(40, _Internal::ephemeralmessage(this), + _Internal::ephemeralmessage(this).GetCachedSize(), target, stream); + } + + cached_has_bits = _impl_._has_bits_[1]; + // optional .proto.Message.InvoiceMessage invoiceMessage = 41; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(41, _Internal::invoicemessage(this), + _Internal::invoicemessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.ButtonsMessage buttonsMessage = 42; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(42, _Internal::buttonsmessage(this), + _Internal::buttonsmessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.ButtonsResponseMessage buttonsResponseMessage = 43; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(43, _Internal::buttonsresponsemessage(this), + _Internal::buttonsresponsemessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.PaymentInviteMessage paymentInviteMessage = 44; + if (cached_has_bits & 0x00000008u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(44, _Internal::paymentinvitemessage(this), + _Internal::paymentinvitemessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.InteractiveMessage interactiveMessage = 45; + if (cached_has_bits & 0x00000010u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(45, _Internal::interactivemessage(this), + _Internal::interactivemessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.ReactionMessage reactionMessage = 46; + if (cached_has_bits & 0x00000020u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(46, _Internal::reactionmessage(this), + _Internal::reactionmessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.StickerSyncRMRMessage stickerSyncRmrMessage = 47; + if (cached_has_bits & 0x00000040u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(47, _Internal::stickersyncrmrmessage(this), + _Internal::stickersyncrmrmessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.InteractiveResponseMessage interactiveResponseMessage = 48; + if (cached_has_bits & 0x00000080u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(48, _Internal::interactiveresponsemessage(this), + _Internal::interactiveresponsemessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.PollCreationMessage pollCreationMessage = 49; + if (cached_has_bits & 0x00000100u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(49, _Internal::pollcreationmessage(this), + _Internal::pollcreationmessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.PollUpdateMessage pollUpdateMessage = 50; + if (cached_has_bits & 0x00000200u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(50, _Internal::pollupdatemessage(this), + _Internal::pollupdatemessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.KeepInChatMessage keepInChatMessage = 51; + if (cached_has_bits & 0x00000400u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(51, _Internal::keepinchatmessage(this), + _Internal::keepinchatmessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.FutureProofMessage documentWithCaptionMessage = 53; + if (cached_has_bits & 0x00000800u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(53, _Internal::documentwithcaptionmessage(this), + _Internal::documentwithcaptionmessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.RequestPhoneNumberMessage requestPhoneNumberMessage = 54; + if (cached_has_bits & 0x00001000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(54, _Internal::requestphonenumbermessage(this), + _Internal::requestphonenumbermessage(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.FutureProofMessage viewOnceMessageV2 = 55; + if (cached_has_bits & 0x00002000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(55, _Internal::viewoncemessagev2(this), + _Internal::viewoncemessagev2(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Message) + return target; +} + +size_t Message::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Message) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string conversation = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_conversation()); + } + + // optional .proto.Message.SenderKeyDistributionMessage senderKeyDistributionMessage = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.senderkeydistributionmessage_); + } + + // optional .proto.Message.ImageMessage imageMessage = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.imagemessage_); + } + + // optional .proto.Message.ContactMessage contactMessage = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.contactmessage_); + } + + // optional .proto.Message.LocationMessage locationMessage = 5; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.locationmessage_); + } + + // optional .proto.Message.ExtendedTextMessage extendedTextMessage = 6; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.extendedtextmessage_); + } + + // optional .proto.Message.DocumentMessage documentMessage = 7; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.documentmessage_); + } + + // optional .proto.Message.AudioMessage audioMessage = 8; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.audiomessage_); + } + + } + if (cached_has_bits & 0x0000ff00u) { + // optional .proto.Message.VideoMessage videoMessage = 9; + if (cached_has_bits & 0x00000100u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.videomessage_); + } + + // optional .proto.Message.Call call = 10; + if (cached_has_bits & 0x00000200u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.call_); + } + + // optional .proto.Message.Chat chat = 11; + if (cached_has_bits & 0x00000400u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.chat_); + } + + // optional .proto.Message.ProtocolMessage protocolMessage = 12; + if (cached_has_bits & 0x00000800u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.protocolmessage_); + } + + // optional .proto.Message.ContactsArrayMessage contactsArrayMessage = 13; + if (cached_has_bits & 0x00001000u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.contactsarraymessage_); + } + + // optional .proto.Message.HighlyStructuredMessage highlyStructuredMessage = 14; + if (cached_has_bits & 0x00002000u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.highlystructuredmessage_); + } + + // optional .proto.Message.SenderKeyDistributionMessage fastRatchetKeySenderKeyDistributionMessage = 15; + if (cached_has_bits & 0x00004000u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.fastratchetkeysenderkeydistributionmessage_); + } + + // optional .proto.Message.SendPaymentMessage sendPaymentMessage = 16; + if (cached_has_bits & 0x00008000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.sendpaymentmessage_); + } + + } + if (cached_has_bits & 0x00ff0000u) { + // optional .proto.Message.LiveLocationMessage liveLocationMessage = 18; + if (cached_has_bits & 0x00010000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.livelocationmessage_); + } + + // optional .proto.Message.RequestPaymentMessage requestPaymentMessage = 22; + if (cached_has_bits & 0x00020000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.requestpaymentmessage_); + } + + // optional .proto.Message.DeclinePaymentRequestMessage declinePaymentRequestMessage = 23; + if (cached_has_bits & 0x00040000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.declinepaymentrequestmessage_); + } + + // optional .proto.Message.CancelPaymentRequestMessage cancelPaymentRequestMessage = 24; + if (cached_has_bits & 0x00080000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.cancelpaymentrequestmessage_); + } + + // optional .proto.Message.TemplateMessage templateMessage = 25; + if (cached_has_bits & 0x00100000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.templatemessage_); + } + + // optional .proto.Message.StickerMessage stickerMessage = 26; + if (cached_has_bits & 0x00200000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.stickermessage_); + } + + // optional .proto.Message.GroupInviteMessage groupInviteMessage = 28; + if (cached_has_bits & 0x00400000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.groupinvitemessage_); + } + + // optional .proto.Message.TemplateButtonReplyMessage templateButtonReplyMessage = 29; + if (cached_has_bits & 0x00800000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.templatebuttonreplymessage_); + } + + } + if (cached_has_bits & 0xff000000u) { + // optional .proto.Message.ProductMessage productMessage = 30; + if (cached_has_bits & 0x01000000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.productmessage_); + } + + // optional .proto.Message.DeviceSentMessage deviceSentMessage = 31; + if (cached_has_bits & 0x02000000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.devicesentmessage_); + } + + // optional .proto.MessageContextInfo messageContextInfo = 35; + if (cached_has_bits & 0x04000000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.messagecontextinfo_); + } + + // optional .proto.Message.ListMessage listMessage = 36; + if (cached_has_bits & 0x08000000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.listmessage_); + } + + // optional .proto.Message.FutureProofMessage viewOnceMessage = 37; + if (cached_has_bits & 0x10000000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.viewoncemessage_); + } + + // optional .proto.Message.OrderMessage orderMessage = 38; + if (cached_has_bits & 0x20000000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.ordermessage_); + } + + // optional .proto.Message.ListResponseMessage listResponseMessage = 39; + if (cached_has_bits & 0x40000000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.listresponsemessage_); + } + + // optional .proto.Message.FutureProofMessage ephemeralMessage = 40; + if (cached_has_bits & 0x80000000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.ephemeralmessage_); + } + + } + cached_has_bits = _impl_._has_bits_[1]; + if (cached_has_bits & 0x000000ffu) { + // optional .proto.Message.InvoiceMessage invoiceMessage = 41; + if (cached_has_bits & 0x00000001u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.invoicemessage_); + } + + // optional .proto.Message.ButtonsMessage buttonsMessage = 42; + if (cached_has_bits & 0x00000002u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.buttonsmessage_); + } + + // optional .proto.Message.ButtonsResponseMessage buttonsResponseMessage = 43; + if (cached_has_bits & 0x00000004u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.buttonsresponsemessage_); + } + + // optional .proto.Message.PaymentInviteMessage paymentInviteMessage = 44; + if (cached_has_bits & 0x00000008u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.paymentinvitemessage_); + } + + // optional .proto.Message.InteractiveMessage interactiveMessage = 45; + if (cached_has_bits & 0x00000010u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.interactivemessage_); + } + + // optional .proto.Message.ReactionMessage reactionMessage = 46; + if (cached_has_bits & 0x00000020u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.reactionmessage_); + } + + // optional .proto.Message.StickerSyncRMRMessage stickerSyncRmrMessage = 47; + if (cached_has_bits & 0x00000040u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.stickersyncrmrmessage_); + } + + // optional .proto.Message.InteractiveResponseMessage interactiveResponseMessage = 48; + if (cached_has_bits & 0x00000080u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.interactiveresponsemessage_); + } + + } + if (cached_has_bits & 0x00003f00u) { + // optional .proto.Message.PollCreationMessage pollCreationMessage = 49; + if (cached_has_bits & 0x00000100u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.pollcreationmessage_); + } + + // optional .proto.Message.PollUpdateMessage pollUpdateMessage = 50; + if (cached_has_bits & 0x00000200u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.pollupdatemessage_); + } + + // optional .proto.Message.KeepInChatMessage keepInChatMessage = 51; + if (cached_has_bits & 0x00000400u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.keepinchatmessage_); + } + + // optional .proto.Message.FutureProofMessage documentWithCaptionMessage = 53; + if (cached_has_bits & 0x00000800u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.documentwithcaptionmessage_); + } + + // optional .proto.Message.RequestPhoneNumberMessage requestPhoneNumberMessage = 54; + if (cached_has_bits & 0x00001000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.requestphonenumbermessage_); + } + + // optional .proto.Message.FutureProofMessage viewOnceMessageV2 = 55; + if (cached_has_bits & 0x00002000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.viewoncemessagev2_); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Message::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message::GetClassData() const { return &_class_data_; } + + +void Message::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_conversation(from._internal_conversation()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_senderkeydistributionmessage()->::proto::Message_SenderKeyDistributionMessage::MergeFrom( + from._internal_senderkeydistributionmessage()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_imagemessage()->::proto::Message_ImageMessage::MergeFrom( + from._internal_imagemessage()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_mutable_contactmessage()->::proto::Message_ContactMessage::MergeFrom( + from._internal_contactmessage()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_mutable_locationmessage()->::proto::Message_LocationMessage::MergeFrom( + from._internal_locationmessage()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_mutable_extendedtextmessage()->::proto::Message_ExtendedTextMessage::MergeFrom( + from._internal_extendedtextmessage()); + } + if (cached_has_bits & 0x00000040u) { + _this->_internal_mutable_documentmessage()->::proto::Message_DocumentMessage::MergeFrom( + from._internal_documentmessage()); + } + if (cached_has_bits & 0x00000080u) { + _this->_internal_mutable_audiomessage()->::proto::Message_AudioMessage::MergeFrom( + from._internal_audiomessage()); + } + } + if (cached_has_bits & 0x0000ff00u) { + if (cached_has_bits & 0x00000100u) { + _this->_internal_mutable_videomessage()->::proto::Message_VideoMessage::MergeFrom( + from._internal_videomessage()); + } + if (cached_has_bits & 0x00000200u) { + _this->_internal_mutable_call()->::proto::Message_Call::MergeFrom( + from._internal_call()); + } + if (cached_has_bits & 0x00000400u) { + _this->_internal_mutable_chat()->::proto::Message_Chat::MergeFrom( + from._internal_chat()); + } + if (cached_has_bits & 0x00000800u) { + _this->_internal_mutable_protocolmessage()->::proto::Message_ProtocolMessage::MergeFrom( + from._internal_protocolmessage()); + } + if (cached_has_bits & 0x00001000u) { + _this->_internal_mutable_contactsarraymessage()->::proto::Message_ContactsArrayMessage::MergeFrom( + from._internal_contactsarraymessage()); + } + if (cached_has_bits & 0x00002000u) { + _this->_internal_mutable_highlystructuredmessage()->::proto::Message_HighlyStructuredMessage::MergeFrom( + from._internal_highlystructuredmessage()); + } + if (cached_has_bits & 0x00004000u) { + _this->_internal_mutable_fastratchetkeysenderkeydistributionmessage()->::proto::Message_SenderKeyDistributionMessage::MergeFrom( + from._internal_fastratchetkeysenderkeydistributionmessage()); + } + if (cached_has_bits & 0x00008000u) { + _this->_internal_mutable_sendpaymentmessage()->::proto::Message_SendPaymentMessage::MergeFrom( + from._internal_sendpaymentmessage()); + } + } + if (cached_has_bits & 0x00ff0000u) { + if (cached_has_bits & 0x00010000u) { + _this->_internal_mutable_livelocationmessage()->::proto::Message_LiveLocationMessage::MergeFrom( + from._internal_livelocationmessage()); + } + if (cached_has_bits & 0x00020000u) { + _this->_internal_mutable_requestpaymentmessage()->::proto::Message_RequestPaymentMessage::MergeFrom( + from._internal_requestpaymentmessage()); + } + if (cached_has_bits & 0x00040000u) { + _this->_internal_mutable_declinepaymentrequestmessage()->::proto::Message_DeclinePaymentRequestMessage::MergeFrom( + from._internal_declinepaymentrequestmessage()); + } + if (cached_has_bits & 0x00080000u) { + _this->_internal_mutable_cancelpaymentrequestmessage()->::proto::Message_CancelPaymentRequestMessage::MergeFrom( + from._internal_cancelpaymentrequestmessage()); + } + if (cached_has_bits & 0x00100000u) { + _this->_internal_mutable_templatemessage()->::proto::Message_TemplateMessage::MergeFrom( + from._internal_templatemessage()); + } + if (cached_has_bits & 0x00200000u) { + _this->_internal_mutable_stickermessage()->::proto::Message_StickerMessage::MergeFrom( + from._internal_stickermessage()); + } + if (cached_has_bits & 0x00400000u) { + _this->_internal_mutable_groupinvitemessage()->::proto::Message_GroupInviteMessage::MergeFrom( + from._internal_groupinvitemessage()); + } + if (cached_has_bits & 0x00800000u) { + _this->_internal_mutable_templatebuttonreplymessage()->::proto::Message_TemplateButtonReplyMessage::MergeFrom( + from._internal_templatebuttonreplymessage()); + } + } + if (cached_has_bits & 0xff000000u) { + if (cached_has_bits & 0x01000000u) { + _this->_internal_mutable_productmessage()->::proto::Message_ProductMessage::MergeFrom( + from._internal_productmessage()); + } + if (cached_has_bits & 0x02000000u) { + _this->_internal_mutable_devicesentmessage()->::proto::Message_DeviceSentMessage::MergeFrom( + from._internal_devicesentmessage()); + } + if (cached_has_bits & 0x04000000u) { + _this->_internal_mutable_messagecontextinfo()->::proto::MessageContextInfo::MergeFrom( + from._internal_messagecontextinfo()); + } + if (cached_has_bits & 0x08000000u) { + _this->_internal_mutable_listmessage()->::proto::Message_ListMessage::MergeFrom( + from._internal_listmessage()); + } + if (cached_has_bits & 0x10000000u) { + _this->_internal_mutable_viewoncemessage()->::proto::Message_FutureProofMessage::MergeFrom( + from._internal_viewoncemessage()); + } + if (cached_has_bits & 0x20000000u) { + _this->_internal_mutable_ordermessage()->::proto::Message_OrderMessage::MergeFrom( + from._internal_ordermessage()); + } + if (cached_has_bits & 0x40000000u) { + _this->_internal_mutable_listresponsemessage()->::proto::Message_ListResponseMessage::MergeFrom( + from._internal_listresponsemessage()); + } + if (cached_has_bits & 0x80000000u) { + _this->_internal_mutable_ephemeralmessage()->::proto::Message_FutureProofMessage::MergeFrom( + from._internal_ephemeralmessage()); + } + } + cached_has_bits = from._impl_._has_bits_[1]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_invoicemessage()->::proto::Message_InvoiceMessage::MergeFrom( + from._internal_invoicemessage()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_buttonsmessage()->::proto::Message_ButtonsMessage::MergeFrom( + from._internal_buttonsmessage()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_buttonsresponsemessage()->::proto::Message_ButtonsResponseMessage::MergeFrom( + from._internal_buttonsresponsemessage()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_mutable_paymentinvitemessage()->::proto::Message_PaymentInviteMessage::MergeFrom( + from._internal_paymentinvitemessage()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_mutable_interactivemessage()->::proto::Message_InteractiveMessage::MergeFrom( + from._internal_interactivemessage()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_mutable_reactionmessage()->::proto::Message_ReactionMessage::MergeFrom( + from._internal_reactionmessage()); + } + if (cached_has_bits & 0x00000040u) { + _this->_internal_mutable_stickersyncrmrmessage()->::proto::Message_StickerSyncRMRMessage::MergeFrom( + from._internal_stickersyncrmrmessage()); + } + if (cached_has_bits & 0x00000080u) { + _this->_internal_mutable_interactiveresponsemessage()->::proto::Message_InteractiveResponseMessage::MergeFrom( + from._internal_interactiveresponsemessage()); + } + } + if (cached_has_bits & 0x00003f00u) { + if (cached_has_bits & 0x00000100u) { + _this->_internal_mutable_pollcreationmessage()->::proto::Message_PollCreationMessage::MergeFrom( + from._internal_pollcreationmessage()); + } + if (cached_has_bits & 0x00000200u) { + _this->_internal_mutable_pollupdatemessage()->::proto::Message_PollUpdateMessage::MergeFrom( + from._internal_pollupdatemessage()); + } + if (cached_has_bits & 0x00000400u) { + _this->_internal_mutable_keepinchatmessage()->::proto::Message_KeepInChatMessage::MergeFrom( + from._internal_keepinchatmessage()); + } + if (cached_has_bits & 0x00000800u) { + _this->_internal_mutable_documentwithcaptionmessage()->::proto::Message_FutureProofMessage::MergeFrom( + from._internal_documentwithcaptionmessage()); + } + if (cached_has_bits & 0x00001000u) { + _this->_internal_mutable_requestphonenumbermessage()->::proto::Message_RequestPhoneNumberMessage::MergeFrom( + from._internal_requestphonenumbermessage()); + } + if (cached_has_bits & 0x00002000u) { + _this->_internal_mutable_viewoncemessagev2()->::proto::Message_FutureProofMessage::MergeFrom( + from._internal_viewoncemessagev2()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Message::CopyFrom(const Message& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Message::IsInitialized() const { + return true; +} + +void Message::InternalSwap(Message* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_._has_bits_[1], other->_impl_._has_bits_[1]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.conversation_, lhs_arena, + &other->_impl_.conversation_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Message, _impl_.viewoncemessagev2_) + + sizeof(Message::_impl_.viewoncemessagev2_) + - PROTOBUF_FIELD_OFFSET(Message, _impl_.senderkeydistributionmessage_)>( + reinterpret_cast(&_impl_.senderkeydistributionmessage_), + reinterpret_cast(&other->_impl_.senderkeydistributionmessage_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Message::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[137]); +} + +// =================================================================== + +class MessageContextInfo::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::DeviceListMetadata& devicelistmetadata(const MessageContextInfo* msg); + static void set_has_devicelistmetadata(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_devicelistmetadataversion(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_messagesecret(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_paddingbytes(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::proto::DeviceListMetadata& +MessageContextInfo::_Internal::devicelistmetadata(const MessageContextInfo* msg) { + return *msg->_impl_.devicelistmetadata_; +} +MessageContextInfo::MessageContextInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.MessageContextInfo) +} +MessageContextInfo::MessageContextInfo(const MessageContextInfo& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + MessageContextInfo* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.messagesecret_){} + , decltype(_impl_.paddingbytes_){} + , decltype(_impl_.devicelistmetadata_){nullptr} + , decltype(_impl_.devicelistmetadataversion_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.messagesecret_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.messagesecret_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_messagesecret()) { + _this->_impl_.messagesecret_.Set(from._internal_messagesecret(), + _this->GetArenaForAllocation()); + } + _impl_.paddingbytes_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.paddingbytes_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_paddingbytes()) { + _this->_impl_.paddingbytes_.Set(from._internal_paddingbytes(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_devicelistmetadata()) { + _this->_impl_.devicelistmetadata_ = new ::proto::DeviceListMetadata(*from._impl_.devicelistmetadata_); + } + _this->_impl_.devicelistmetadataversion_ = from._impl_.devicelistmetadataversion_; + // @@protoc_insertion_point(copy_constructor:proto.MessageContextInfo) +} + +inline void MessageContextInfo::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.messagesecret_){} + , decltype(_impl_.paddingbytes_){} + , decltype(_impl_.devicelistmetadata_){nullptr} + , decltype(_impl_.devicelistmetadataversion_){0} + }; + _impl_.messagesecret_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.messagesecret_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.paddingbytes_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.paddingbytes_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +MessageContextInfo::~MessageContextInfo() { + // @@protoc_insertion_point(destructor:proto.MessageContextInfo) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void MessageContextInfo::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.messagesecret_.Destroy(); + _impl_.paddingbytes_.Destroy(); + if (this != internal_default_instance()) delete _impl_.devicelistmetadata_; +} + +void MessageContextInfo::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void MessageContextInfo::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.MessageContextInfo) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _impl_.messagesecret_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.paddingbytes_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.devicelistmetadata_ != nullptr); + _impl_.devicelistmetadata_->Clear(); + } + } + _impl_.devicelistmetadataversion_ = 0; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* MessageContextInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.DeviceListMetadata deviceListMetadata = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_devicelistmetadata(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 deviceListMetadataVersion = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_devicelistmetadataversion(&has_bits); + _impl_.devicelistmetadataversion_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes messageSecret = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_messagesecret(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes paddingBytes = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_paddingbytes(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* MessageContextInfo::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.MessageContextInfo) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.DeviceListMetadata deviceListMetadata = 1; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::devicelistmetadata(this), + _Internal::devicelistmetadata(this).GetCachedSize(), target, stream); + } + + // optional int32 deviceListMetadataVersion = 2; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_devicelistmetadataversion(), target); + } + + // optional bytes messageSecret = 3; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 3, this->_internal_messagesecret(), target); + } + + // optional bytes paddingBytes = 4; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 4, this->_internal_paddingbytes(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.MessageContextInfo) + return target; +} + +size_t MessageContextInfo::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.MessageContextInfo) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional bytes messageSecret = 3; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_messagesecret()); + } + + // optional bytes paddingBytes = 4; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_paddingbytes()); + } + + // optional .proto.DeviceListMetadata deviceListMetadata = 1; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.devicelistmetadata_); + } + + // optional int32 deviceListMetadataVersion = 2; + if (cached_has_bits & 0x00000008u) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_devicelistmetadataversion()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MessageContextInfo::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + MessageContextInfo::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MessageContextInfo::GetClassData() const { return &_class_data_; } + + +void MessageContextInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.MessageContextInfo) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_messagesecret(from._internal_messagesecret()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_paddingbytes(from._internal_paddingbytes()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_devicelistmetadata()->::proto::DeviceListMetadata::MergeFrom( + from._internal_devicelistmetadata()); + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.devicelistmetadataversion_ = from._impl_.devicelistmetadataversion_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void MessageContextInfo::CopyFrom(const MessageContextInfo& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.MessageContextInfo) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MessageContextInfo::IsInitialized() const { + return true; +} + +void MessageContextInfo::InternalSwap(MessageContextInfo* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.messagesecret_, lhs_arena, + &other->_impl_.messagesecret_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.paddingbytes_, lhs_arena, + &other->_impl_.paddingbytes_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(MessageContextInfo, _impl_.devicelistmetadataversion_) + + sizeof(MessageContextInfo::_impl_.devicelistmetadataversion_) + - PROTOBUF_FIELD_OFFSET(MessageContextInfo, _impl_.devicelistmetadata_)>( + reinterpret_cast(&_impl_.devicelistmetadata_), + reinterpret_cast(&other->_impl_.devicelistmetadata_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata MessageContextInfo::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[138]); +} + +// =================================================================== + +class MessageKey::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_remotejid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_fromme(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_id(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_participant(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +MessageKey::MessageKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.MessageKey) +} +MessageKey::MessageKey(const MessageKey& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + MessageKey* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.remotejid_){} + , decltype(_impl_.id_){} + , decltype(_impl_.participant_){} + , decltype(_impl_.fromme_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.remotejid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.remotejid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_remotejid()) { + _this->_impl_.remotejid_.Set(from._internal_remotejid(), + _this->GetArenaForAllocation()); + } + _impl_.id_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.id_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_id()) { + _this->_impl_.id_.Set(from._internal_id(), + _this->GetArenaForAllocation()); + } + _impl_.participant_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.participant_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_participant()) { + _this->_impl_.participant_.Set(from._internal_participant(), + _this->GetArenaForAllocation()); + } + _this->_impl_.fromme_ = from._impl_.fromme_; + // @@protoc_insertion_point(copy_constructor:proto.MessageKey) +} + +inline void MessageKey::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.remotejid_){} + , decltype(_impl_.id_){} + , decltype(_impl_.participant_){} + , decltype(_impl_.fromme_){false} + }; + _impl_.remotejid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.remotejid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.id_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.id_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.participant_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.participant_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +MessageKey::~MessageKey() { + // @@protoc_insertion_point(destructor:proto.MessageKey) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void MessageKey::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.remotejid_.Destroy(); + _impl_.id_.Destroy(); + _impl_.participant_.Destroy(); +} + +void MessageKey::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void MessageKey::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.MessageKey) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _impl_.remotejid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.id_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.participant_.ClearNonDefaultToEmpty(); + } + } + _impl_.fromme_ = false; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* MessageKey::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string remoteJid = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_remotejid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.MessageKey.remoteJid"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bool fromMe = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_fromme(&has_bits); + _impl_.fromme_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string id = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_id(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.MessageKey.id"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string participant = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_participant(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.MessageKey.participant"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* MessageKey::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.MessageKey) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string remoteJid = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_remotejid().data(), static_cast(this->_internal_remotejid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.MessageKey.remoteJid"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_remotejid(), target); + } + + // optional bool fromMe = 2; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(2, this->_internal_fromme(), target); + } + + // optional string id = 3; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_id().data(), static_cast(this->_internal_id().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.MessageKey.id"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_id(), target); + } + + // optional string participant = 4; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_participant().data(), static_cast(this->_internal_participant().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.MessageKey.participant"); + target = stream->WriteStringMaybeAliased( + 4, this->_internal_participant(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.MessageKey) + return target; +} + +size_t MessageKey::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.MessageKey) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional string remoteJid = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_remotejid()); + } + + // optional string id = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_id()); + } + + // optional string participant = 4; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_participant()); + } + + // optional bool fromMe = 2; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 1; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MessageKey::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + MessageKey::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MessageKey::GetClassData() const { return &_class_data_; } + + +void MessageKey::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.MessageKey) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_remotejid(from._internal_remotejid()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_id(from._internal_id()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_participant(from._internal_participant()); + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.fromme_ = from._impl_.fromme_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void MessageKey::CopyFrom(const MessageKey& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.MessageKey) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MessageKey::IsInitialized() const { + return true; +} + +void MessageKey::InternalSwap(MessageKey* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.remotejid_, lhs_arena, + &other->_impl_.remotejid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.id_, lhs_arena, + &other->_impl_.id_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.participant_, lhs_arena, + &other->_impl_.participant_, rhs_arena + ); + swap(_impl_.fromme_, other->_impl_.fromme_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata MessageKey::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[139]); +} + +// =================================================================== + +class Money::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_value(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_offset(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_currencycode(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +Money::Money(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Money) +} +Money::Money(const Money& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Money* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.currencycode_){} + , decltype(_impl_.value_){} + , decltype(_impl_.offset_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.currencycode_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.currencycode_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_currencycode()) { + _this->_impl_.currencycode_.Set(from._internal_currencycode(), + _this->GetArenaForAllocation()); + } + ::memcpy(&_impl_.value_, &from._impl_.value_, + static_cast(reinterpret_cast(&_impl_.offset_) - + reinterpret_cast(&_impl_.value_)) + sizeof(_impl_.offset_)); + // @@protoc_insertion_point(copy_constructor:proto.Money) +} + +inline void Money::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.currencycode_){} + , decltype(_impl_.value_){int64_t{0}} + , decltype(_impl_.offset_){0u} + }; + _impl_.currencycode_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.currencycode_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Money::~Money() { + // @@protoc_insertion_point(destructor:proto.Money) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Money::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.currencycode_.Destroy(); +} + +void Money::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Money::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Money) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.currencycode_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000006u) { + ::memset(&_impl_.value_, 0, static_cast( + reinterpret_cast(&_impl_.offset_) - + reinterpret_cast(&_impl_.value_)) + sizeof(_impl_.offset_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Money::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional int64 value = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_value(&has_bits); + _impl_.value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 offset = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_offset(&has_bits); + _impl_.offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string currencyCode = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_currencycode(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Money.currencyCode"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Money::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Money) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional int64 value = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_value(), target); + } + + // optional uint32 offset = 2; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_offset(), target); + } + + // optional string currencyCode = 3; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_currencycode().data(), static_cast(this->_internal_currencycode().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Money.currencyCode"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_currencycode(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Money) + return target; +} + +size_t Money::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Money) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional string currencyCode = 3; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_currencycode()); + } + + // optional int64 value = 1; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_value()); + } + + // optional uint32 offset = 2; + if (cached_has_bits & 0x00000004u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_offset()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Money::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Money::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Money::GetClassData() const { return &_class_data_; } + + +void Money::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Money) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_currencycode(from._internal_currencycode()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.value_ = from._impl_.value_; + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.offset_ = from._impl_.offset_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Money::CopyFrom(const Money& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Money) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Money::IsInitialized() const { + return true; +} + +void Money::InternalSwap(Money* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.currencycode_, lhs_arena, + &other->_impl_.currencycode_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Money, _impl_.offset_) + + sizeof(Money::_impl_.offset_) + - PROTOBUF_FIELD_OFFSET(Money, _impl_.value_)>( + reinterpret_cast(&_impl_.value_), + reinterpret_cast(&other->_impl_.value_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Money::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[140]); +} + +// =================================================================== + +class MsgOpaqueData_PollOption::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_name(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +MsgOpaqueData_PollOption::MsgOpaqueData_PollOption(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.MsgOpaqueData.PollOption) +} +MsgOpaqueData_PollOption::MsgOpaqueData_PollOption(const MsgOpaqueData_PollOption& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + MsgOpaqueData_PollOption* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.name_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.name_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.name_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_name()) { + _this->_impl_.name_.Set(from._internal_name(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.MsgOpaqueData.PollOption) +} + +inline void MsgOpaqueData_PollOption::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.name_){} + }; + _impl_.name_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.name_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +MsgOpaqueData_PollOption::~MsgOpaqueData_PollOption() { + // @@protoc_insertion_point(destructor:proto.MsgOpaqueData.PollOption) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void MsgOpaqueData_PollOption::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.name_.Destroy(); +} + +void MsgOpaqueData_PollOption::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void MsgOpaqueData_PollOption::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.MsgOpaqueData.PollOption) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.name_.ClearNonDefaultToEmpty(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* MsgOpaqueData_PollOption::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_name(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.PollOption.name"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* MsgOpaqueData_PollOption::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.MsgOpaqueData.PollOption) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string name = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.MsgOpaqueData.PollOption.name"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_name(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.MsgOpaqueData.PollOption) + return target; +} + +size_t MsgOpaqueData_PollOption::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.MsgOpaqueData.PollOption) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional string name = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MsgOpaqueData_PollOption::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + MsgOpaqueData_PollOption::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MsgOpaqueData_PollOption::GetClassData() const { return &_class_data_; } + + +void MsgOpaqueData_PollOption::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.MsgOpaqueData.PollOption) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_name()) { + _this->_internal_set_name(from._internal_name()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void MsgOpaqueData_PollOption::CopyFrom(const MsgOpaqueData_PollOption& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.MsgOpaqueData.PollOption) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MsgOpaqueData_PollOption::IsInitialized() const { + return true; +} + +void MsgOpaqueData_PollOption::InternalSwap(MsgOpaqueData_PollOption* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.name_, lhs_arena, + &other->_impl_.name_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata MsgOpaqueData_PollOption::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[141]); +} + +// =================================================================== + +class MsgOpaqueData::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_body(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_caption(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_lng(HasBits* has_bits) { + (*has_bits)[0] |= 16384u; + } + static void set_has_islive(HasBits* has_bits) { + (*has_bits)[0] |= 65536u; + } + static void set_has_lat(HasBits* has_bits) { + (*has_bits)[0] |= 32768u; + } + static void set_has_paymentamount1000(HasBits* has_bits) { + (*has_bits)[0] |= 131072u; + } + static void set_has_paymentnotemsgbody(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_canonicalurl(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_matchedtext(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_title(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_description(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_futureproofbuffer(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_clienturl(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_loc(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_pollname(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static void set_has_pollselectableoptionscount(HasBits* has_bits) { + (*has_bits)[0] |= 524288u; + } + static void set_has_messagesecret(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static void set_has_sendertimestampms(HasBits* has_bits) { + (*has_bits)[0] |= 262144u; + } + static void set_has_pollupdateparentkey(HasBits* has_bits) { + (*has_bits)[0] |= 4096u; + } + static const ::proto::PollEncValue& encpollvote(const MsgOpaqueData* msg); + static void set_has_encpollvote(HasBits* has_bits) { + (*has_bits)[0] |= 8192u; + } +}; + +const ::proto::PollEncValue& +MsgOpaqueData::_Internal::encpollvote(const MsgOpaqueData* msg) { + return *msg->_impl_.encpollvote_; +} +MsgOpaqueData::MsgOpaqueData(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.MsgOpaqueData) +} +MsgOpaqueData::MsgOpaqueData(const MsgOpaqueData& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + MsgOpaqueData* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.polloptions_){from._impl_.polloptions_} + , decltype(_impl_.body_){} + , decltype(_impl_.caption_){} + , decltype(_impl_.paymentnotemsgbody_){} + , decltype(_impl_.canonicalurl_){} + , decltype(_impl_.matchedtext_){} + , decltype(_impl_.title_){} + , decltype(_impl_.description_){} + , decltype(_impl_.futureproofbuffer_){} + , decltype(_impl_.clienturl_){} + , decltype(_impl_.loc_){} + , decltype(_impl_.pollname_){} + , decltype(_impl_.messagesecret_){} + , decltype(_impl_.pollupdateparentkey_){} + , decltype(_impl_.encpollvote_){nullptr} + , decltype(_impl_.lng_){} + , decltype(_impl_.lat_){} + , decltype(_impl_.islive_){} + , decltype(_impl_.paymentamount1000_){} + , decltype(_impl_.sendertimestampms_){} + , decltype(_impl_.pollselectableoptionscount_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.body_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.body_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_body()) { + _this->_impl_.body_.Set(from._internal_body(), + _this->GetArenaForAllocation()); + } + _impl_.caption_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.caption_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_caption()) { + _this->_impl_.caption_.Set(from._internal_caption(), + _this->GetArenaForAllocation()); + } + _impl_.paymentnotemsgbody_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.paymentnotemsgbody_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_paymentnotemsgbody()) { + _this->_impl_.paymentnotemsgbody_.Set(from._internal_paymentnotemsgbody(), + _this->GetArenaForAllocation()); + } + _impl_.canonicalurl_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.canonicalurl_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_canonicalurl()) { + _this->_impl_.canonicalurl_.Set(from._internal_canonicalurl(), + _this->GetArenaForAllocation()); + } + _impl_.matchedtext_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.matchedtext_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_matchedtext()) { + _this->_impl_.matchedtext_.Set(from._internal_matchedtext(), + _this->GetArenaForAllocation()); + } + _impl_.title_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.title_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_title()) { + _this->_impl_.title_.Set(from._internal_title(), + _this->GetArenaForAllocation()); + } + _impl_.description_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.description_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_description()) { + _this->_impl_.description_.Set(from._internal_description(), + _this->GetArenaForAllocation()); + } + _impl_.futureproofbuffer_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.futureproofbuffer_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_futureproofbuffer()) { + _this->_impl_.futureproofbuffer_.Set(from._internal_futureproofbuffer(), + _this->GetArenaForAllocation()); + } + _impl_.clienturl_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.clienturl_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_clienturl()) { + _this->_impl_.clienturl_.Set(from._internal_clienturl(), + _this->GetArenaForAllocation()); + } + _impl_.loc_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.loc_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_loc()) { + _this->_impl_.loc_.Set(from._internal_loc(), + _this->GetArenaForAllocation()); + } + _impl_.pollname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.pollname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_pollname()) { + _this->_impl_.pollname_.Set(from._internal_pollname(), + _this->GetArenaForAllocation()); + } + _impl_.messagesecret_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.messagesecret_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_messagesecret()) { + _this->_impl_.messagesecret_.Set(from._internal_messagesecret(), + _this->GetArenaForAllocation()); + } + _impl_.pollupdateparentkey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.pollupdateparentkey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_pollupdateparentkey()) { + _this->_impl_.pollupdateparentkey_.Set(from._internal_pollupdateparentkey(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_encpollvote()) { + _this->_impl_.encpollvote_ = new ::proto::PollEncValue(*from._impl_.encpollvote_); + } + ::memcpy(&_impl_.lng_, &from._impl_.lng_, + static_cast(reinterpret_cast(&_impl_.pollselectableoptionscount_) - + reinterpret_cast(&_impl_.lng_)) + sizeof(_impl_.pollselectableoptionscount_)); + // @@protoc_insertion_point(copy_constructor:proto.MsgOpaqueData) +} + +inline void MsgOpaqueData::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.polloptions_){arena} + , decltype(_impl_.body_){} + , decltype(_impl_.caption_){} + , decltype(_impl_.paymentnotemsgbody_){} + , decltype(_impl_.canonicalurl_){} + , decltype(_impl_.matchedtext_){} + , decltype(_impl_.title_){} + , decltype(_impl_.description_){} + , decltype(_impl_.futureproofbuffer_){} + , decltype(_impl_.clienturl_){} + , decltype(_impl_.loc_){} + , decltype(_impl_.pollname_){} + , decltype(_impl_.messagesecret_){} + , decltype(_impl_.pollupdateparentkey_){} + , decltype(_impl_.encpollvote_){nullptr} + , decltype(_impl_.lng_){0} + , decltype(_impl_.lat_){0} + , decltype(_impl_.islive_){false} + , decltype(_impl_.paymentamount1000_){0} + , decltype(_impl_.sendertimestampms_){int64_t{0}} + , decltype(_impl_.pollselectableoptionscount_){0u} + }; + _impl_.body_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.body_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.caption_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.caption_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.paymentnotemsgbody_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.paymentnotemsgbody_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.canonicalurl_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.canonicalurl_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.matchedtext_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.matchedtext_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.title_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.title_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.description_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.description_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.futureproofbuffer_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.futureproofbuffer_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.clienturl_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.clienturl_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.loc_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.loc_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.pollname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.pollname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.messagesecret_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.messagesecret_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.pollupdateparentkey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.pollupdateparentkey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +MsgOpaqueData::~MsgOpaqueData() { + // @@protoc_insertion_point(destructor:proto.MsgOpaqueData) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void MsgOpaqueData::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.polloptions_.~RepeatedPtrField(); + _impl_.body_.Destroy(); + _impl_.caption_.Destroy(); + _impl_.paymentnotemsgbody_.Destroy(); + _impl_.canonicalurl_.Destroy(); + _impl_.matchedtext_.Destroy(); + _impl_.title_.Destroy(); + _impl_.description_.Destroy(); + _impl_.futureproofbuffer_.Destroy(); + _impl_.clienturl_.Destroy(); + _impl_.loc_.Destroy(); + _impl_.pollname_.Destroy(); + _impl_.messagesecret_.Destroy(); + _impl_.pollupdateparentkey_.Destroy(); + if (this != internal_default_instance()) delete _impl_.encpollvote_; +} + +void MsgOpaqueData::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void MsgOpaqueData::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.MsgOpaqueData) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.polloptions_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _impl_.body_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.caption_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.paymentnotemsgbody_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + _impl_.canonicalurl_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + _impl_.matchedtext_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000020u) { + _impl_.title_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000040u) { + _impl_.description_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000080u) { + _impl_.futureproofbuffer_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x00003f00u) { + if (cached_has_bits & 0x00000100u) { + _impl_.clienturl_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000200u) { + _impl_.loc_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000400u) { + _impl_.pollname_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000800u) { + _impl_.messagesecret_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00001000u) { + _impl_.pollupdateparentkey_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00002000u) { + GOOGLE_DCHECK(_impl_.encpollvote_ != nullptr); + _impl_.encpollvote_->Clear(); + } + } + if (cached_has_bits & 0x0000c000u) { + ::memset(&_impl_.lng_, 0, static_cast( + reinterpret_cast(&_impl_.lat_) - + reinterpret_cast(&_impl_.lng_)) + sizeof(_impl_.lat_)); + } + if (cached_has_bits & 0x000f0000u) { + ::memset(&_impl_.islive_, 0, static_cast( + reinterpret_cast(&_impl_.pollselectableoptionscount_) - + reinterpret_cast(&_impl_.islive_)) + sizeof(_impl_.pollselectableoptionscount_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* MsgOpaqueData::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string body = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_body(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.body"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string caption = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_caption(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.caption"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional double lng = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 41)) { + _Internal::set_has_lng(&has_bits); + _impl_.lng_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(double); + } else + goto handle_unusual; + continue; + // optional bool isLive = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + _Internal::set_has_islive(&has_bits); + _impl_.islive_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional double lat = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 57)) { + _Internal::set_has_lat(&has_bits); + _impl_.lat_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(double); + } else + goto handle_unusual; + continue; + // optional int32 paymentAmount1000 = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { + _Internal::set_has_paymentamount1000(&has_bits); + _impl_.paymentamount1000_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string paymentNoteMsgBody = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + auto str = _internal_mutable_paymentnotemsgbody(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.paymentNoteMsgBody"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string canonicalUrl = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { + auto str = _internal_mutable_canonicalurl(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.canonicalUrl"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string matchedText = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { + auto str = _internal_mutable_matchedtext(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.matchedText"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string title = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { + auto str = _internal_mutable_title(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.title"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string description = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { + auto str = _internal_mutable_description(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.description"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bytes futureproofBuffer = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) { + auto str = _internal_mutable_futureproofbuffer(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string clientUrl = 15; + case 15: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { + auto str = _internal_mutable_clienturl(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.clientUrl"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string loc = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { + auto str = _internal_mutable_loc(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.loc"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string pollName = 17; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { + auto str = _internal_mutable_pollname(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.pollName"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // repeated .proto.MsgOpaqueData.PollOption pollOptions = 18; + case 18: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { + ptr -= 2; + do { + ptr += 2; + ptr = ctx->ParseMessage(_internal_add_polloptions(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<146>(ptr)); + } else + goto handle_unusual; + continue; + // optional uint32 pollSelectableOptionsCount = 20; + case 20: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 160)) { + _Internal::set_has_pollselectableoptionscount(&has_bits); + _impl_.pollselectableoptionscount_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes messageSecret = 21; + case 21: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { + auto str = _internal_mutable_messagesecret(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 senderTimestampMs = 22; + case 22: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 176)) { + _Internal::set_has_sendertimestampms(&has_bits); + _impl_.sendertimestampms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string pollUpdateParentKey = 23; + case 23: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { + auto str = _internal_mutable_pollupdateparentkey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.pollUpdateParentKey"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.PollEncValue encPollVote = 24; + case 24: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 194)) { + ptr = ctx->ParseMessage(_internal_mutable_encpollvote(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* MsgOpaqueData::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.MsgOpaqueData) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string body = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_body().data(), static_cast(this->_internal_body().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.MsgOpaqueData.body"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_body(), target); + } + + // optional string caption = 3; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_caption().data(), static_cast(this->_internal_caption().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.MsgOpaqueData.caption"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_caption(), target); + } + + // optional double lng = 5; + if (cached_has_bits & 0x00004000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray(5, this->_internal_lng(), target); + } + + // optional bool isLive = 6; + if (cached_has_bits & 0x00010000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(6, this->_internal_islive(), target); + } + + // optional double lat = 7; + if (cached_has_bits & 0x00008000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray(7, this->_internal_lat(), target); + } + + // optional int32 paymentAmount1000 = 8; + if (cached_has_bits & 0x00020000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(8, this->_internal_paymentamount1000(), target); + } + + // optional string paymentNoteMsgBody = 9; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_paymentnotemsgbody().data(), static_cast(this->_internal_paymentnotemsgbody().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.MsgOpaqueData.paymentNoteMsgBody"); + target = stream->WriteStringMaybeAliased( + 9, this->_internal_paymentnotemsgbody(), target); + } + + // optional string canonicalUrl = 10; + if (cached_has_bits & 0x00000008u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_canonicalurl().data(), static_cast(this->_internal_canonicalurl().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.MsgOpaqueData.canonicalUrl"); + target = stream->WriteStringMaybeAliased( + 10, this->_internal_canonicalurl(), target); + } + + // optional string matchedText = 11; + if (cached_has_bits & 0x00000010u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_matchedtext().data(), static_cast(this->_internal_matchedtext().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.MsgOpaqueData.matchedText"); + target = stream->WriteStringMaybeAliased( + 11, this->_internal_matchedtext(), target); + } + + // optional string title = 12; + if (cached_has_bits & 0x00000020u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_title().data(), static_cast(this->_internal_title().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.MsgOpaqueData.title"); + target = stream->WriteStringMaybeAliased( + 12, this->_internal_title(), target); + } + + // optional string description = 13; + if (cached_has_bits & 0x00000040u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_description().data(), static_cast(this->_internal_description().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.MsgOpaqueData.description"); + target = stream->WriteStringMaybeAliased( + 13, this->_internal_description(), target); + } + + // optional bytes futureproofBuffer = 14; + if (cached_has_bits & 0x00000080u) { + target = stream->WriteBytesMaybeAliased( + 14, this->_internal_futureproofbuffer(), target); + } + + // optional string clientUrl = 15; + if (cached_has_bits & 0x00000100u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_clienturl().data(), static_cast(this->_internal_clienturl().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.MsgOpaqueData.clientUrl"); + target = stream->WriteStringMaybeAliased( + 15, this->_internal_clienturl(), target); + } + + // optional string loc = 16; + if (cached_has_bits & 0x00000200u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_loc().data(), static_cast(this->_internal_loc().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.MsgOpaqueData.loc"); + target = stream->WriteStringMaybeAliased( + 16, this->_internal_loc(), target); + } + + // optional string pollName = 17; + if (cached_has_bits & 0x00000400u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_pollname().data(), static_cast(this->_internal_pollname().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.MsgOpaqueData.pollName"); + target = stream->WriteStringMaybeAliased( + 17, this->_internal_pollname(), target); + } + + // repeated .proto.MsgOpaqueData.PollOption pollOptions = 18; + for (unsigned i = 0, + n = static_cast(this->_internal_polloptions_size()); i < n; i++) { + const auto& repfield = this->_internal_polloptions(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(18, repfield, repfield.GetCachedSize(), target, stream); + } + + // optional uint32 pollSelectableOptionsCount = 20; + if (cached_has_bits & 0x00080000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(20, this->_internal_pollselectableoptionscount(), target); + } + + // optional bytes messageSecret = 21; + if (cached_has_bits & 0x00000800u) { + target = stream->WriteBytesMaybeAliased( + 21, this->_internal_messagesecret(), target); + } + + // optional int64 senderTimestampMs = 22; + if (cached_has_bits & 0x00040000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(22, this->_internal_sendertimestampms(), target); + } + + // optional string pollUpdateParentKey = 23; + if (cached_has_bits & 0x00001000u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_pollupdateparentkey().data(), static_cast(this->_internal_pollupdateparentkey().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.MsgOpaqueData.pollUpdateParentKey"); + target = stream->WriteStringMaybeAliased( + 23, this->_internal_pollupdateparentkey(), target); + } + + // optional .proto.PollEncValue encPollVote = 24; + if (cached_has_bits & 0x00002000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(24, _Internal::encpollvote(this), + _Internal::encpollvote(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.MsgOpaqueData) + return target; +} + +size_t MsgOpaqueData::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.MsgOpaqueData) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.MsgOpaqueData.PollOption pollOptions = 18; + total_size += 2UL * this->_internal_polloptions_size(); + for (const auto& msg : this->_impl_.polloptions_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string body = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_body()); + } + + // optional string caption = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_caption()); + } + + // optional string paymentNoteMsgBody = 9; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_paymentnotemsgbody()); + } + + // optional string canonicalUrl = 10; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_canonicalurl()); + } + + // optional string matchedText = 11; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_matchedtext()); + } + + // optional string title = 12; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_title()); + } + + // optional string description = 13; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_description()); + } + + // optional bytes futureproofBuffer = 14; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_futureproofbuffer()); + } + + } + if (cached_has_bits & 0x0000ff00u) { + // optional string clientUrl = 15; + if (cached_has_bits & 0x00000100u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_clienturl()); + } + + // optional string loc = 16; + if (cached_has_bits & 0x00000200u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_loc()); + } + + // optional string pollName = 17; + if (cached_has_bits & 0x00000400u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_pollname()); + } + + // optional bytes messageSecret = 21; + if (cached_has_bits & 0x00000800u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_messagesecret()); + } + + // optional string pollUpdateParentKey = 23; + if (cached_has_bits & 0x00001000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_pollupdateparentkey()); + } + + // optional .proto.PollEncValue encPollVote = 24; + if (cached_has_bits & 0x00002000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.encpollvote_); + } + + // optional double lng = 5; + if (cached_has_bits & 0x00004000u) { + total_size += 1 + 8; + } + + // optional double lat = 7; + if (cached_has_bits & 0x00008000u) { + total_size += 1 + 8; + } + + } + if (cached_has_bits & 0x000f0000u) { + // optional bool isLive = 6; + if (cached_has_bits & 0x00010000u) { + total_size += 1 + 1; + } + + // optional int32 paymentAmount1000 = 8; + if (cached_has_bits & 0x00020000u) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_paymentamount1000()); + } + + // optional int64 senderTimestampMs = 22; + if (cached_has_bits & 0x00040000u) { + total_size += 2 + + ::_pbi::WireFormatLite::Int64Size( + this->_internal_sendertimestampms()); + } + + // optional uint32 pollSelectableOptionsCount = 20; + if (cached_has_bits & 0x00080000u) { + total_size += 2 + + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_pollselectableoptionscount()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MsgOpaqueData::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + MsgOpaqueData::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MsgOpaqueData::GetClassData() const { return &_class_data_; } + + +void MsgOpaqueData::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.MsgOpaqueData) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.polloptions_.MergeFrom(from._impl_.polloptions_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_body(from._internal_body()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_caption(from._internal_caption()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_paymentnotemsgbody(from._internal_paymentnotemsgbody()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_set_canonicalurl(from._internal_canonicalurl()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_set_matchedtext(from._internal_matchedtext()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_set_title(from._internal_title()); + } + if (cached_has_bits & 0x00000040u) { + _this->_internal_set_description(from._internal_description()); + } + if (cached_has_bits & 0x00000080u) { + _this->_internal_set_futureproofbuffer(from._internal_futureproofbuffer()); + } + } + if (cached_has_bits & 0x0000ff00u) { + if (cached_has_bits & 0x00000100u) { + _this->_internal_set_clienturl(from._internal_clienturl()); + } + if (cached_has_bits & 0x00000200u) { + _this->_internal_set_loc(from._internal_loc()); + } + if (cached_has_bits & 0x00000400u) { + _this->_internal_set_pollname(from._internal_pollname()); + } + if (cached_has_bits & 0x00000800u) { + _this->_internal_set_messagesecret(from._internal_messagesecret()); + } + if (cached_has_bits & 0x00001000u) { + _this->_internal_set_pollupdateparentkey(from._internal_pollupdateparentkey()); + } + if (cached_has_bits & 0x00002000u) { + _this->_internal_mutable_encpollvote()->::proto::PollEncValue::MergeFrom( + from._internal_encpollvote()); + } + if (cached_has_bits & 0x00004000u) { + _this->_impl_.lng_ = from._impl_.lng_; + } + if (cached_has_bits & 0x00008000u) { + _this->_impl_.lat_ = from._impl_.lat_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x000f0000u) { + if (cached_has_bits & 0x00010000u) { + _this->_impl_.islive_ = from._impl_.islive_; + } + if (cached_has_bits & 0x00020000u) { + _this->_impl_.paymentamount1000_ = from._impl_.paymentamount1000_; + } + if (cached_has_bits & 0x00040000u) { + _this->_impl_.sendertimestampms_ = from._impl_.sendertimestampms_; + } + if (cached_has_bits & 0x00080000u) { + _this->_impl_.pollselectableoptionscount_ = from._impl_.pollselectableoptionscount_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void MsgOpaqueData::CopyFrom(const MsgOpaqueData& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.MsgOpaqueData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MsgOpaqueData::IsInitialized() const { + return true; +} + +void MsgOpaqueData::InternalSwap(MsgOpaqueData* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.polloptions_.InternalSwap(&other->_impl_.polloptions_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.body_, lhs_arena, + &other->_impl_.body_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.caption_, lhs_arena, + &other->_impl_.caption_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.paymentnotemsgbody_, lhs_arena, + &other->_impl_.paymentnotemsgbody_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.canonicalurl_, lhs_arena, + &other->_impl_.canonicalurl_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.matchedtext_, lhs_arena, + &other->_impl_.matchedtext_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.title_, lhs_arena, + &other->_impl_.title_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.description_, lhs_arena, + &other->_impl_.description_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.futureproofbuffer_, lhs_arena, + &other->_impl_.futureproofbuffer_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.clienturl_, lhs_arena, + &other->_impl_.clienturl_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.loc_, lhs_arena, + &other->_impl_.loc_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.pollname_, lhs_arena, + &other->_impl_.pollname_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.messagesecret_, lhs_arena, + &other->_impl_.messagesecret_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.pollupdateparentkey_, lhs_arena, + &other->_impl_.pollupdateparentkey_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(MsgOpaqueData, _impl_.pollselectableoptionscount_) + + sizeof(MsgOpaqueData::_impl_.pollselectableoptionscount_) + - PROTOBUF_FIELD_OFFSET(MsgOpaqueData, _impl_.encpollvote_)>( + reinterpret_cast(&_impl_.encpollvote_), + reinterpret_cast(&other->_impl_.encpollvote_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata MsgOpaqueData::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[142]); +} + +// =================================================================== + +class MsgRowOpaqueData::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::MsgOpaqueData& currentmsg(const MsgRowOpaqueData* msg); + static void set_has_currentmsg(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::proto::MsgOpaqueData& quotedmsg(const MsgRowOpaqueData* msg); + static void set_has_quotedmsg(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::proto::MsgOpaqueData& +MsgRowOpaqueData::_Internal::currentmsg(const MsgRowOpaqueData* msg) { + return *msg->_impl_.currentmsg_; +} +const ::proto::MsgOpaqueData& +MsgRowOpaqueData::_Internal::quotedmsg(const MsgRowOpaqueData* msg) { + return *msg->_impl_.quotedmsg_; +} +MsgRowOpaqueData::MsgRowOpaqueData(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.MsgRowOpaqueData) +} +MsgRowOpaqueData::MsgRowOpaqueData(const MsgRowOpaqueData& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + MsgRowOpaqueData* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.currentmsg_){nullptr} + , decltype(_impl_.quotedmsg_){nullptr}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_currentmsg()) { + _this->_impl_.currentmsg_ = new ::proto::MsgOpaqueData(*from._impl_.currentmsg_); + } + if (from._internal_has_quotedmsg()) { + _this->_impl_.quotedmsg_ = new ::proto::MsgOpaqueData(*from._impl_.quotedmsg_); + } + // @@protoc_insertion_point(copy_constructor:proto.MsgRowOpaqueData) +} + +inline void MsgRowOpaqueData::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.currentmsg_){nullptr} + , decltype(_impl_.quotedmsg_){nullptr} + }; +} + +MsgRowOpaqueData::~MsgRowOpaqueData() { + // @@protoc_insertion_point(destructor:proto.MsgRowOpaqueData) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void MsgRowOpaqueData::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.currentmsg_; + if (this != internal_default_instance()) delete _impl_.quotedmsg_; +} + +void MsgRowOpaqueData::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void MsgRowOpaqueData::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.MsgRowOpaqueData) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.currentmsg_ != nullptr); + _impl_.currentmsg_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.quotedmsg_ != nullptr); + _impl_.quotedmsg_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* MsgRowOpaqueData::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.MsgOpaqueData currentMsg = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_currentmsg(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.MsgOpaqueData quotedMsg = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_quotedmsg(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* MsgRowOpaqueData::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.MsgRowOpaqueData) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.MsgOpaqueData currentMsg = 1; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::currentmsg(this), + _Internal::currentmsg(this).GetCachedSize(), target, stream); + } + + // optional .proto.MsgOpaqueData quotedMsg = 2; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::quotedmsg(this), + _Internal::quotedmsg(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.MsgRowOpaqueData) + return target; +} + +size_t MsgRowOpaqueData::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.MsgRowOpaqueData) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional .proto.MsgOpaqueData currentMsg = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.currentmsg_); + } + + // optional .proto.MsgOpaqueData quotedMsg = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.quotedmsg_); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MsgRowOpaqueData::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + MsgRowOpaqueData::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MsgRowOpaqueData::GetClassData() const { return &_class_data_; } + + +void MsgRowOpaqueData::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.MsgRowOpaqueData) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_currentmsg()->::proto::MsgOpaqueData::MergeFrom( + from._internal_currentmsg()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_quotedmsg()->::proto::MsgOpaqueData::MergeFrom( + from._internal_quotedmsg()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void MsgRowOpaqueData::CopyFrom(const MsgRowOpaqueData& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.MsgRowOpaqueData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MsgRowOpaqueData::IsInitialized() const { + return true; +} + +void MsgRowOpaqueData::InternalSwap(MsgRowOpaqueData* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(MsgRowOpaqueData, _impl_.quotedmsg_) + + sizeof(MsgRowOpaqueData::_impl_.quotedmsg_) + - PROTOBUF_FIELD_OFFSET(MsgRowOpaqueData, _impl_.currentmsg_)>( + reinterpret_cast(&_impl_.currentmsg_), + reinterpret_cast(&other->_impl_.currentmsg_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata MsgRowOpaqueData::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[143]); +} + +// =================================================================== + +class NoiseCertificate_Details::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_serial(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_issuer(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_expires(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_subject(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_key(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +NoiseCertificate_Details::NoiseCertificate_Details(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.NoiseCertificate.Details) +} +NoiseCertificate_Details::NoiseCertificate_Details(const NoiseCertificate_Details& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + NoiseCertificate_Details* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.issuer_){} + , decltype(_impl_.subject_){} + , decltype(_impl_.key_){} + , decltype(_impl_.expires_){} + , decltype(_impl_.serial_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.issuer_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.issuer_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_issuer()) { + _this->_impl_.issuer_.Set(from._internal_issuer(), + _this->GetArenaForAllocation()); + } + _impl_.subject_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.subject_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_subject()) { + _this->_impl_.subject_.Set(from._internal_subject(), + _this->GetArenaForAllocation()); + } + _impl_.key_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.key_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_key()) { + _this->_impl_.key_.Set(from._internal_key(), + _this->GetArenaForAllocation()); + } + ::memcpy(&_impl_.expires_, &from._impl_.expires_, + static_cast(reinterpret_cast(&_impl_.serial_) - + reinterpret_cast(&_impl_.expires_)) + sizeof(_impl_.serial_)); + // @@protoc_insertion_point(copy_constructor:proto.NoiseCertificate.Details) +} + +inline void NoiseCertificate_Details::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.issuer_){} + , decltype(_impl_.subject_){} + , decltype(_impl_.key_){} + , decltype(_impl_.expires_){uint64_t{0u}} + , decltype(_impl_.serial_){0u} + }; + _impl_.issuer_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.issuer_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.subject_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.subject_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.key_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.key_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +NoiseCertificate_Details::~NoiseCertificate_Details() { + // @@protoc_insertion_point(destructor:proto.NoiseCertificate.Details) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void NoiseCertificate_Details::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.issuer_.Destroy(); + _impl_.subject_.Destroy(); + _impl_.key_.Destroy(); +} + +void NoiseCertificate_Details::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void NoiseCertificate_Details::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.NoiseCertificate.Details) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _impl_.issuer_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.subject_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.key_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x00000018u) { + ::memset(&_impl_.expires_, 0, static_cast( + reinterpret_cast(&_impl_.serial_) - + reinterpret_cast(&_impl_.expires_)) + sizeof(_impl_.serial_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* NoiseCertificate_Details::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint32 serial = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_serial(&has_bits); + _impl_.serial_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string issuer = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_issuer(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.NoiseCertificate.Details.issuer"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional uint64 expires = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_expires(&has_bits); + _impl_.expires_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string subject = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_subject(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.NoiseCertificate.Details.subject"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bytes key = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + auto str = _internal_mutable_key(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* NoiseCertificate_Details::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.NoiseCertificate.Details) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional uint32 serial = 1; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_serial(), target); + } + + // optional string issuer = 2; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_issuer().data(), static_cast(this->_internal_issuer().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.NoiseCertificate.Details.issuer"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_issuer(), target); + } + + // optional uint64 expires = 3; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_expires(), target); + } + + // optional string subject = 4; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_subject().data(), static_cast(this->_internal_subject().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.NoiseCertificate.Details.subject"); + target = stream->WriteStringMaybeAliased( + 4, this->_internal_subject(), target); + } + + // optional bytes key = 5; + if (cached_has_bits & 0x00000004u) { + target = stream->WriteBytesMaybeAliased( + 5, this->_internal_key(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.NoiseCertificate.Details) + return target; +} + +size_t NoiseCertificate_Details::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.NoiseCertificate.Details) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + // optional string issuer = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_issuer()); + } + + // optional string subject = 4; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_subject()); + } + + // optional bytes key = 5; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_key()); + } + + // optional uint64 expires = 3; + if (cached_has_bits & 0x00000008u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_expires()); + } + + // optional uint32 serial = 1; + if (cached_has_bits & 0x00000010u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_serial()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NoiseCertificate_Details::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + NoiseCertificate_Details::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NoiseCertificate_Details::GetClassData() const { return &_class_data_; } + + +void NoiseCertificate_Details::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.NoiseCertificate.Details) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_issuer(from._internal_issuer()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_subject(from._internal_subject()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_key(from._internal_key()); + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.expires_ = from._impl_.expires_; + } + if (cached_has_bits & 0x00000010u) { + _this->_impl_.serial_ = from._impl_.serial_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void NoiseCertificate_Details::CopyFrom(const NoiseCertificate_Details& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.NoiseCertificate.Details) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool NoiseCertificate_Details::IsInitialized() const { + return true; +} + +void NoiseCertificate_Details::InternalSwap(NoiseCertificate_Details* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.issuer_, lhs_arena, + &other->_impl_.issuer_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.subject_, lhs_arena, + &other->_impl_.subject_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.key_, lhs_arena, + &other->_impl_.key_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(NoiseCertificate_Details, _impl_.serial_) + + sizeof(NoiseCertificate_Details::_impl_.serial_) + - PROTOBUF_FIELD_OFFSET(NoiseCertificate_Details, _impl_.expires_)>( + reinterpret_cast(&_impl_.expires_), + reinterpret_cast(&other->_impl_.expires_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata NoiseCertificate_Details::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[144]); +} + +// =================================================================== + +class NoiseCertificate::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_details(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_signature(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +NoiseCertificate::NoiseCertificate(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.NoiseCertificate) +} +NoiseCertificate::NoiseCertificate(const NoiseCertificate& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + NoiseCertificate* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.details_){} + , decltype(_impl_.signature_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.details_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.details_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_details()) { + _this->_impl_.details_.Set(from._internal_details(), + _this->GetArenaForAllocation()); + } + _impl_.signature_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.signature_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_signature()) { + _this->_impl_.signature_.Set(from._internal_signature(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.NoiseCertificate) +} + +inline void NoiseCertificate::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.details_){} + , decltype(_impl_.signature_){} + }; + _impl_.details_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.details_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.signature_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.signature_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +NoiseCertificate::~NoiseCertificate() { + // @@protoc_insertion_point(destructor:proto.NoiseCertificate) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void NoiseCertificate::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.details_.Destroy(); + _impl_.signature_.Destroy(); +} + +void NoiseCertificate::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void NoiseCertificate::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.NoiseCertificate) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.details_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.signature_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* NoiseCertificate::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes details = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_details(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes signature = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_signature(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* NoiseCertificate::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.NoiseCertificate) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes details = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_details(), target); + } + + // optional bytes signature = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_signature(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.NoiseCertificate) + return target; +} + +size_t NoiseCertificate::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.NoiseCertificate) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional bytes details = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_details()); + } + + // optional bytes signature = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_signature()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NoiseCertificate::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + NoiseCertificate::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NoiseCertificate::GetClassData() const { return &_class_data_; } + + +void NoiseCertificate::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.NoiseCertificate) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_details(from._internal_details()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_signature(from._internal_signature()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void NoiseCertificate::CopyFrom(const NoiseCertificate& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.NoiseCertificate) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool NoiseCertificate::IsInitialized() const { + return true; +} + +void NoiseCertificate::InternalSwap(NoiseCertificate* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.details_, lhs_arena, + &other->_impl_.details_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.signature_, lhs_arena, + &other->_impl_.signature_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata NoiseCertificate::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[145]); +} + +// =================================================================== + +class NotificationMessageInfo::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::MessageKey& key(const NotificationMessageInfo* msg); + static void set_has_key(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::proto::Message& message(const NotificationMessageInfo* msg); + static void set_has_message(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_messagetimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_participant(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +const ::proto::MessageKey& +NotificationMessageInfo::_Internal::key(const NotificationMessageInfo* msg) { + return *msg->_impl_.key_; +} +const ::proto::Message& +NotificationMessageInfo::_Internal::message(const NotificationMessageInfo* msg) { + return *msg->_impl_.message_; +} +NotificationMessageInfo::NotificationMessageInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.NotificationMessageInfo) +} +NotificationMessageInfo::NotificationMessageInfo(const NotificationMessageInfo& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + NotificationMessageInfo* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.participant_){} + , decltype(_impl_.key_){nullptr} + , decltype(_impl_.message_){nullptr} + , decltype(_impl_.messagetimestamp_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.participant_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.participant_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_participant()) { + _this->_impl_.participant_.Set(from._internal_participant(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_key()) { + _this->_impl_.key_ = new ::proto::MessageKey(*from._impl_.key_); + } + if (from._internal_has_message()) { + _this->_impl_.message_ = new ::proto::Message(*from._impl_.message_); + } + _this->_impl_.messagetimestamp_ = from._impl_.messagetimestamp_; + // @@protoc_insertion_point(copy_constructor:proto.NotificationMessageInfo) +} + +inline void NotificationMessageInfo::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.participant_){} + , decltype(_impl_.key_){nullptr} + , decltype(_impl_.message_){nullptr} + , decltype(_impl_.messagetimestamp_){uint64_t{0u}} + }; + _impl_.participant_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.participant_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +NotificationMessageInfo::~NotificationMessageInfo() { + // @@protoc_insertion_point(destructor:proto.NotificationMessageInfo) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void NotificationMessageInfo::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.participant_.Destroy(); + if (this != internal_default_instance()) delete _impl_.key_; + if (this != internal_default_instance()) delete _impl_.message_; +} + +void NotificationMessageInfo::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void NotificationMessageInfo::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.NotificationMessageInfo) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _impl_.participant_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.key_ != nullptr); + _impl_.key_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.message_ != nullptr); + _impl_.message_->Clear(); + } + } + _impl_.messagetimestamp_ = uint64_t{0u}; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* NotificationMessageInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.MessageKey key = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message message = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_message(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint64 messageTimestamp = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_messagetimestamp(&has_bits); + _impl_.messagetimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string participant = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_participant(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.NotificationMessageInfo.participant"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* NotificationMessageInfo::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.NotificationMessageInfo) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.MessageKey key = 1; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::key(this), + _Internal::key(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message message = 2; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::message(this), + _Internal::message(this).GetCachedSize(), target, stream); + } + + // optional uint64 messageTimestamp = 3; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_messagetimestamp(), target); + } + + // optional string participant = 4; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_participant().data(), static_cast(this->_internal_participant().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.NotificationMessageInfo.participant"); + target = stream->WriteStringMaybeAliased( + 4, this->_internal_participant(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.NotificationMessageInfo) + return target; +} + +size_t NotificationMessageInfo::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.NotificationMessageInfo) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional string participant = 4; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_participant()); + } + + // optional .proto.MessageKey key = 1; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.key_); + } + + // optional .proto.Message message = 2; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.message_); + } + + // optional uint64 messageTimestamp = 3; + if (cached_has_bits & 0x00000008u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_messagetimestamp()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NotificationMessageInfo::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + NotificationMessageInfo::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NotificationMessageInfo::GetClassData() const { return &_class_data_; } + + +void NotificationMessageInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.NotificationMessageInfo) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_participant(from._internal_participant()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_key()->::proto::MessageKey::MergeFrom( + from._internal_key()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_message()->::proto::Message::MergeFrom( + from._internal_message()); + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.messagetimestamp_ = from._impl_.messagetimestamp_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void NotificationMessageInfo::CopyFrom(const NotificationMessageInfo& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.NotificationMessageInfo) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool NotificationMessageInfo::IsInitialized() const { + return true; +} + +void NotificationMessageInfo::InternalSwap(NotificationMessageInfo* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.participant_, lhs_arena, + &other->_impl_.participant_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(NotificationMessageInfo, _impl_.messagetimestamp_) + + sizeof(NotificationMessageInfo::_impl_.messagetimestamp_) + - PROTOBUF_FIELD_OFFSET(NotificationMessageInfo, _impl_.key_)>( + reinterpret_cast(&_impl_.key_), + reinterpret_cast(&other->_impl_.key_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata NotificationMessageInfo::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[146]); +} + +// =================================================================== + +class PastParticipant::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_userjid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_leavereason(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_leavets(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000007) ^ 0x00000007) != 0; + } +}; + +PastParticipant::PastParticipant(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.PastParticipant) +} +PastParticipant::PastParticipant(const PastParticipant& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + PastParticipant* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.userjid_){} + , decltype(_impl_.leavets_){} + , decltype(_impl_.leavereason_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.userjid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.userjid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_userjid()) { + _this->_impl_.userjid_.Set(from._internal_userjid(), + _this->GetArenaForAllocation()); + } + ::memcpy(&_impl_.leavets_, &from._impl_.leavets_, + static_cast(reinterpret_cast(&_impl_.leavereason_) - + reinterpret_cast(&_impl_.leavets_)) + sizeof(_impl_.leavereason_)); + // @@protoc_insertion_point(copy_constructor:proto.PastParticipant) +} + +inline void PastParticipant::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.userjid_){} + , decltype(_impl_.leavets_){uint64_t{0u}} + , decltype(_impl_.leavereason_){0} + }; + _impl_.userjid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.userjid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +PastParticipant::~PastParticipant() { + // @@protoc_insertion_point(destructor:proto.PastParticipant) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void PastParticipant::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.userjid_.Destroy(); +} + +void PastParticipant::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void PastParticipant::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.PastParticipant) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.userjid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000006u) { + ::memset(&_impl_.leavets_, 0, static_cast( + reinterpret_cast(&_impl_.leavereason_) - + reinterpret_cast(&_impl_.leavets_)) + sizeof(_impl_.leavereason_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* PastParticipant::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // required string userJid = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_userjid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.PastParticipant.userJid"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // required .proto.PastParticipant.LeaveReason leaveReason = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::PastParticipant_LeaveReason_IsValid(val))) { + _internal_set_leavereason(static_cast<::proto::PastParticipant_LeaveReason>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // required uint64 leaveTs = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_leavets(&has_bits); + _impl_.leavets_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* PastParticipant::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.PastParticipant) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // required string userJid = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_userjid().data(), static_cast(this->_internal_userjid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.PastParticipant.userJid"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_userjid(), target); + } + + // required .proto.PastParticipant.LeaveReason leaveReason = 2; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this->_internal_leavereason(), target); + } + + // required uint64 leaveTs = 3; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_leavets(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.PastParticipant) + return target; +} + +size_t PastParticipant::RequiredFieldsByteSizeFallback() const { +// @@protoc_insertion_point(required_fields_byte_size_fallback_start:proto.PastParticipant) + size_t total_size = 0; + + if (_internal_has_userjid()) { + // required string userJid = 1; + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_userjid()); + } + + if (_internal_has_leavets()) { + // required uint64 leaveTs = 3; + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_leavets()); + } + + if (_internal_has_leavereason()) { + // required .proto.PastParticipant.LeaveReason leaveReason = 2; + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_leavereason()); + } + + return total_size; +} +size_t PastParticipant::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.PastParticipant) + size_t total_size = 0; + + if (((_impl_._has_bits_[0] & 0x00000007) ^ 0x00000007) == 0) { // All required fields are present. + // required string userJid = 1; + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_userjid()); + + // required uint64 leaveTs = 3; + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_leavets()); + + // required .proto.PastParticipant.LeaveReason leaveReason = 2; + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_leavereason()); + + } else { + total_size += RequiredFieldsByteSizeFallback(); + } + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PastParticipant::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + PastParticipant::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PastParticipant::GetClassData() const { return &_class_data_; } + + +void PastParticipant::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.PastParticipant) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_userjid(from._internal_userjid()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.leavets_ = from._impl_.leavets_; + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.leavereason_ = from._impl_.leavereason_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void PastParticipant::CopyFrom(const PastParticipant& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.PastParticipant) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PastParticipant::IsInitialized() const { + if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false; + return true; +} + +void PastParticipant::InternalSwap(PastParticipant* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.userjid_, lhs_arena, + &other->_impl_.userjid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(PastParticipant, _impl_.leavereason_) + + sizeof(PastParticipant::_impl_.leavereason_) + - PROTOBUF_FIELD_OFFSET(PastParticipant, _impl_.leavets_)>( + reinterpret_cast(&_impl_.leavets_), + reinterpret_cast(&other->_impl_.leavets_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PastParticipant::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[147]); +} + +// =================================================================== + +class PastParticipants::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_groupjid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0; + } +}; + +PastParticipants::PastParticipants(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.PastParticipants) +} +PastParticipants::PastParticipants(const PastParticipants& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + PastParticipants* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.pastparticipants_){from._impl_.pastparticipants_} + , decltype(_impl_.groupjid_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.groupjid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.groupjid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_groupjid()) { + _this->_impl_.groupjid_.Set(from._internal_groupjid(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.PastParticipants) +} + +inline void PastParticipants::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.pastparticipants_){arena} + , decltype(_impl_.groupjid_){} + }; + _impl_.groupjid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.groupjid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +PastParticipants::~PastParticipants() { + // @@protoc_insertion_point(destructor:proto.PastParticipants) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void PastParticipants::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.pastparticipants_.~RepeatedPtrField(); + _impl_.groupjid_.Destroy(); +} + +void PastParticipants::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void PastParticipants::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.PastParticipants) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.pastparticipants_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.groupjid_.ClearNonDefaultToEmpty(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* PastParticipants::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // required string groupJid = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_groupjid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.PastParticipants.groupJid"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // repeated .proto.PastParticipant pastParticipants = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_pastparticipants(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* PastParticipants::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.PastParticipants) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // required string groupJid = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_groupjid().data(), static_cast(this->_internal_groupjid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.PastParticipants.groupJid"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_groupjid(), target); + } + + // repeated .proto.PastParticipant pastParticipants = 2; + for (unsigned i = 0, + n = static_cast(this->_internal_pastparticipants_size()); i < n; i++) { + const auto& repfield = this->_internal_pastparticipants(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.PastParticipants) + return target; +} + +size_t PastParticipants::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.PastParticipants) + size_t total_size = 0; + + // required string groupJid = 1; + if (_internal_has_groupjid()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_groupjid()); + } + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.PastParticipant pastParticipants = 2; + total_size += 1UL * this->_internal_pastparticipants_size(); + for (const auto& msg : this->_impl_.pastparticipants_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PastParticipants::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + PastParticipants::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PastParticipants::GetClassData() const { return &_class_data_; } + + +void PastParticipants::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.PastParticipants) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.pastparticipants_.MergeFrom(from._impl_.pastparticipants_); + if (from._internal_has_groupjid()) { + _this->_internal_set_groupjid(from._internal_groupjid()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void PastParticipants::CopyFrom(const PastParticipants& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.PastParticipants) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PastParticipants::IsInitialized() const { + if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false; + if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.pastparticipants_)) + return false; + return true; +} + +void PastParticipants::InternalSwap(PastParticipants* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.pastparticipants_.InternalSwap(&other->_impl_.pastparticipants_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.groupjid_, lhs_arena, + &other->_impl_.groupjid_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PastParticipants::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[148]); +} + +// =================================================================== + +class PaymentBackground_MediaData::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_mediakey(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_mediakeytimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_filesha256(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_fileencsha256(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_directpath(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +PaymentBackground_MediaData::PaymentBackground_MediaData(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.PaymentBackground.MediaData) +} +PaymentBackground_MediaData::PaymentBackground_MediaData(const PaymentBackground_MediaData& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + PaymentBackground_MediaData* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.mediakey_){} + , decltype(_impl_.filesha256_){} + , decltype(_impl_.fileencsha256_){} + , decltype(_impl_.directpath_){} + , decltype(_impl_.mediakeytimestamp_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.mediakey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediakey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_mediakey()) { + _this->_impl_.mediakey_.Set(from._internal_mediakey(), + _this->GetArenaForAllocation()); + } + _impl_.filesha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filesha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_filesha256()) { + _this->_impl_.filesha256_.Set(from._internal_filesha256(), + _this->GetArenaForAllocation()); + } + _impl_.fileencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_fileencsha256()) { + _this->_impl_.fileencsha256_.Set(from._internal_fileencsha256(), + _this->GetArenaForAllocation()); + } + _impl_.directpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_directpath()) { + _this->_impl_.directpath_.Set(from._internal_directpath(), + _this->GetArenaForAllocation()); + } + _this->_impl_.mediakeytimestamp_ = from._impl_.mediakeytimestamp_; + // @@protoc_insertion_point(copy_constructor:proto.PaymentBackground.MediaData) +} + +inline void PaymentBackground_MediaData::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.mediakey_){} + , decltype(_impl_.filesha256_){} + , decltype(_impl_.fileencsha256_){} + , decltype(_impl_.directpath_){} + , decltype(_impl_.mediakeytimestamp_){int64_t{0}} + }; + _impl_.mediakey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediakey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filesha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filesha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fileencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +PaymentBackground_MediaData::~PaymentBackground_MediaData() { + // @@protoc_insertion_point(destructor:proto.PaymentBackground.MediaData) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void PaymentBackground_MediaData::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.mediakey_.Destroy(); + _impl_.filesha256_.Destroy(); + _impl_.fileencsha256_.Destroy(); + _impl_.directpath_.Destroy(); +} + +void PaymentBackground_MediaData::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void PaymentBackground_MediaData::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.PaymentBackground.MediaData) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _impl_.mediakey_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.filesha256_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.fileencsha256_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + _impl_.directpath_.ClearNonDefaultToEmpty(); + } + } + _impl_.mediakeytimestamp_ = int64_t{0}; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* PaymentBackground_MediaData::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes mediaKey = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_mediakey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 mediaKeyTimestamp = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_mediakeytimestamp(&has_bits); + _impl_.mediakeytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes fileSha256 = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_filesha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes fileEncSha256 = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_fileencsha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string directPath = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + auto str = _internal_mutable_directpath(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.PaymentBackground.MediaData.directPath"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* PaymentBackground_MediaData::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.PaymentBackground.MediaData) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes mediaKey = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_mediakey(), target); + } + + // optional int64 mediaKeyTimestamp = 2; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_mediakeytimestamp(), target); + } + + // optional bytes fileSha256 = 3; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 3, this->_internal_filesha256(), target); + } + + // optional bytes fileEncSha256 = 4; + if (cached_has_bits & 0x00000004u) { + target = stream->WriteBytesMaybeAliased( + 4, this->_internal_fileencsha256(), target); + } + + // optional string directPath = 5; + if (cached_has_bits & 0x00000008u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_directpath().data(), static_cast(this->_internal_directpath().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.PaymentBackground.MediaData.directPath"); + target = stream->WriteStringMaybeAliased( + 5, this->_internal_directpath(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.PaymentBackground.MediaData) + return target; +} + +size_t PaymentBackground_MediaData::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.PaymentBackground.MediaData) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + // optional bytes mediaKey = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_mediakey()); + } + + // optional bytes fileSha256 = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_filesha256()); + } + + // optional bytes fileEncSha256 = 4; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_fileencsha256()); + } + + // optional string directPath = 5; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_directpath()); + } + + // optional int64 mediaKeyTimestamp = 2; + if (cached_has_bits & 0x00000010u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_mediakeytimestamp()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PaymentBackground_MediaData::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + PaymentBackground_MediaData::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PaymentBackground_MediaData::GetClassData() const { return &_class_data_; } + + +void PaymentBackground_MediaData::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.PaymentBackground.MediaData) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_mediakey(from._internal_mediakey()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_filesha256(from._internal_filesha256()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_fileencsha256(from._internal_fileencsha256()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_set_directpath(from._internal_directpath()); + } + if (cached_has_bits & 0x00000010u) { + _this->_impl_.mediakeytimestamp_ = from._impl_.mediakeytimestamp_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void PaymentBackground_MediaData::CopyFrom(const PaymentBackground_MediaData& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.PaymentBackground.MediaData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PaymentBackground_MediaData::IsInitialized() const { + return true; +} + +void PaymentBackground_MediaData::InternalSwap(PaymentBackground_MediaData* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.mediakey_, lhs_arena, + &other->_impl_.mediakey_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.filesha256_, lhs_arena, + &other->_impl_.filesha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.fileencsha256_, lhs_arena, + &other->_impl_.fileencsha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.directpath_, lhs_arena, + &other->_impl_.directpath_, rhs_arena + ); + swap(_impl_.mediakeytimestamp_, other->_impl_.mediakeytimestamp_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PaymentBackground_MediaData::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[149]); +} + +// =================================================================== + +class PaymentBackground::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_id(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_filelength(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_width(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_height(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_mimetype(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_placeholderargb(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_textargb(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_subtextargb(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static const ::proto::PaymentBackground_MediaData& mediadata(const PaymentBackground* msg); + static void set_has_mediadata(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_type(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } +}; + +const ::proto::PaymentBackground_MediaData& +PaymentBackground::_Internal::mediadata(const PaymentBackground* msg) { + return *msg->_impl_.mediadata_; +} +PaymentBackground::PaymentBackground(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.PaymentBackground) +} +PaymentBackground::PaymentBackground(const PaymentBackground& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + PaymentBackground* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.id_){} + , decltype(_impl_.mimetype_){} + , decltype(_impl_.mediadata_){nullptr} + , decltype(_impl_.filelength_){} + , decltype(_impl_.width_){} + , decltype(_impl_.height_){} + , decltype(_impl_.placeholderargb_){} + , decltype(_impl_.textargb_){} + , decltype(_impl_.subtextargb_){} + , decltype(_impl_.type_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.id_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.id_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_id()) { + _this->_impl_.id_.Set(from._internal_id(), + _this->GetArenaForAllocation()); + } + _impl_.mimetype_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mimetype_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_mimetype()) { + _this->_impl_.mimetype_.Set(from._internal_mimetype(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_mediadata()) { + _this->_impl_.mediadata_ = new ::proto::PaymentBackground_MediaData(*from._impl_.mediadata_); + } + ::memcpy(&_impl_.filelength_, &from._impl_.filelength_, + static_cast(reinterpret_cast(&_impl_.type_) - + reinterpret_cast(&_impl_.filelength_)) + sizeof(_impl_.type_)); + // @@protoc_insertion_point(copy_constructor:proto.PaymentBackground) +} + +inline void PaymentBackground::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.id_){} + , decltype(_impl_.mimetype_){} + , decltype(_impl_.mediadata_){nullptr} + , decltype(_impl_.filelength_){uint64_t{0u}} + , decltype(_impl_.width_){0u} + , decltype(_impl_.height_){0u} + , decltype(_impl_.placeholderargb_){0u} + , decltype(_impl_.textargb_){0u} + , decltype(_impl_.subtextargb_){0u} + , decltype(_impl_.type_){0} + }; + _impl_.id_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.id_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mimetype_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mimetype_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +PaymentBackground::~PaymentBackground() { + // @@protoc_insertion_point(destructor:proto.PaymentBackground) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void PaymentBackground::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.id_.Destroy(); + _impl_.mimetype_.Destroy(); + if (this != internal_default_instance()) delete _impl_.mediadata_; +} + +void PaymentBackground::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void PaymentBackground::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.PaymentBackground) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _impl_.id_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.mimetype_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.mediadata_ != nullptr); + _impl_.mediadata_->Clear(); + } + } + if (cached_has_bits & 0x000000f8u) { + ::memset(&_impl_.filelength_, 0, static_cast( + reinterpret_cast(&_impl_.textargb_) - + reinterpret_cast(&_impl_.filelength_)) + sizeof(_impl_.textargb_)); + } + if (cached_has_bits & 0x00000300u) { + ::memset(&_impl_.subtextargb_, 0, static_cast( + reinterpret_cast(&_impl_.type_) - + reinterpret_cast(&_impl_.subtextargb_)) + sizeof(_impl_.type_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* PaymentBackground::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_id(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.PaymentBackground.id"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional uint64 fileLength = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_filelength(&has_bits); + _impl_.filelength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 width = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_width(&has_bits); + _impl_.width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 height = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_height(&has_bits); + _impl_.height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string mimetype = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + auto str = _internal_mutable_mimetype(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.PaymentBackground.mimetype"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional fixed32 placeholderArgb = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 53)) { + _Internal::set_has_placeholderargb(&has_bits); + _impl_.placeholderargb_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(uint32_t); + } else + goto handle_unusual; + continue; + // optional fixed32 textArgb = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 61)) { + _Internal::set_has_textargb(&has_bits); + _impl_.textargb_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(uint32_t); + } else + goto handle_unusual; + continue; + // optional fixed32 subtextArgb = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 69)) { + _Internal::set_has_subtextargb(&has_bits); + _impl_.subtextargb_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(uint32_t); + } else + goto handle_unusual; + continue; + // optional .proto.PaymentBackground.MediaData mediaData = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + ptr = ctx->ParseMessage(_internal_mutable_mediadata(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.PaymentBackground.Type type = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::PaymentBackground_Type_IsValid(val))) { + _internal_set_type(static_cast<::proto::PaymentBackground_Type>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(10, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* PaymentBackground::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.PaymentBackground) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string id = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_id().data(), static_cast(this->_internal_id().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.PaymentBackground.id"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_id(), target); + } + + // optional uint64 fileLength = 2; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_filelength(), target); + } + + // optional uint32 width = 3; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_width(), target); + } + + // optional uint32 height = 4; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_height(), target); + } + + // optional string mimetype = 5; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_mimetype().data(), static_cast(this->_internal_mimetype().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.PaymentBackground.mimetype"); + target = stream->WriteStringMaybeAliased( + 5, this->_internal_mimetype(), target); + } + + // optional fixed32 placeholderArgb = 6; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFixed32ToArray(6, this->_internal_placeholderargb(), target); + } + + // optional fixed32 textArgb = 7; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFixed32ToArray(7, this->_internal_textargb(), target); + } + + // optional fixed32 subtextArgb = 8; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFixed32ToArray(8, this->_internal_subtextargb(), target); + } + + // optional .proto.PaymentBackground.MediaData mediaData = 9; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(9, _Internal::mediadata(this), + _Internal::mediadata(this).GetCachedSize(), target, stream); + } + + // optional .proto.PaymentBackground.Type type = 10; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 10, this->_internal_type(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.PaymentBackground) + return target; +} + +size_t PaymentBackground::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.PaymentBackground) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string id = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_id()); + } + + // optional string mimetype = 5; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_mimetype()); + } + + // optional .proto.PaymentBackground.MediaData mediaData = 9; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.mediadata_); + } + + // optional uint64 fileLength = 2; + if (cached_has_bits & 0x00000008u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_filelength()); + } + + // optional uint32 width = 3; + if (cached_has_bits & 0x00000010u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_width()); + } + + // optional uint32 height = 4; + if (cached_has_bits & 0x00000020u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_height()); + } + + // optional fixed32 placeholderArgb = 6; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + 4; + } + + // optional fixed32 textArgb = 7; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + 4; + } + + } + if (cached_has_bits & 0x00000300u) { + // optional fixed32 subtextArgb = 8; + if (cached_has_bits & 0x00000100u) { + total_size += 1 + 4; + } + + // optional .proto.PaymentBackground.Type type = 10; + if (cached_has_bits & 0x00000200u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_type()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PaymentBackground::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + PaymentBackground::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PaymentBackground::GetClassData() const { return &_class_data_; } + + +void PaymentBackground::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.PaymentBackground) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_id(from._internal_id()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_mimetype(from._internal_mimetype()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_mediadata()->::proto::PaymentBackground_MediaData::MergeFrom( + from._internal_mediadata()); + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.filelength_ = from._impl_.filelength_; + } + if (cached_has_bits & 0x00000010u) { + _this->_impl_.width_ = from._impl_.width_; + } + if (cached_has_bits & 0x00000020u) { + _this->_impl_.height_ = from._impl_.height_; + } + if (cached_has_bits & 0x00000040u) { + _this->_impl_.placeholderargb_ = from._impl_.placeholderargb_; + } + if (cached_has_bits & 0x00000080u) { + _this->_impl_.textargb_ = from._impl_.textargb_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00000300u) { + if (cached_has_bits & 0x00000100u) { + _this->_impl_.subtextargb_ = from._impl_.subtextargb_; + } + if (cached_has_bits & 0x00000200u) { + _this->_impl_.type_ = from._impl_.type_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void PaymentBackground::CopyFrom(const PaymentBackground& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.PaymentBackground) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PaymentBackground::IsInitialized() const { + return true; +} + +void PaymentBackground::InternalSwap(PaymentBackground* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.id_, lhs_arena, + &other->_impl_.id_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.mimetype_, lhs_arena, + &other->_impl_.mimetype_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(PaymentBackground, _impl_.type_) + + sizeof(PaymentBackground::_impl_.type_) + - PROTOBUF_FIELD_OFFSET(PaymentBackground, _impl_.mediadata_)>( + reinterpret_cast(&_impl_.mediadata_), + reinterpret_cast(&other->_impl_.mediadata_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PaymentBackground::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[150]); +} + +// =================================================================== + +class PaymentInfo::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_currencydeprecated(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_amount1000(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_receiverjid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_status(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_transactiontimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static const ::proto::MessageKey& requestmessagekey(const PaymentInfo* msg); + static void set_has_requestmessagekey(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_expirytimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_futureproofed(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static void set_has_currency(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_txnstatus(HasBits* has_bits) { + (*has_bits)[0] |= 4096u; + } + static void set_has_usenovifiatformat(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static const ::proto::Money& primaryamount(const PaymentInfo* msg); + static void set_has_primaryamount(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static const ::proto::Money& exchangeamount(const PaymentInfo* msg); + static void set_has_exchangeamount(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } +}; + +const ::proto::MessageKey& +PaymentInfo::_Internal::requestmessagekey(const PaymentInfo* msg) { + return *msg->_impl_.requestmessagekey_; +} +const ::proto::Money& +PaymentInfo::_Internal::primaryamount(const PaymentInfo* msg) { + return *msg->_impl_.primaryamount_; +} +const ::proto::Money& +PaymentInfo::_Internal::exchangeamount(const PaymentInfo* msg) { + return *msg->_impl_.exchangeamount_; +} +PaymentInfo::PaymentInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.PaymentInfo) +} +PaymentInfo::PaymentInfo(const PaymentInfo& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + PaymentInfo* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.receiverjid_){} + , decltype(_impl_.currency_){} + , decltype(_impl_.requestmessagekey_){nullptr} + , decltype(_impl_.primaryamount_){nullptr} + , decltype(_impl_.exchangeamount_){nullptr} + , decltype(_impl_.amount1000_){} + , decltype(_impl_.currencydeprecated_){} + , decltype(_impl_.status_){} + , decltype(_impl_.transactiontimestamp_){} + , decltype(_impl_.expirytimestamp_){} + , decltype(_impl_.futureproofed_){} + , decltype(_impl_.usenovifiatformat_){} + , decltype(_impl_.txnstatus_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.receiverjid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.receiverjid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_receiverjid()) { + _this->_impl_.receiverjid_.Set(from._internal_receiverjid(), + _this->GetArenaForAllocation()); + } + _impl_.currency_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.currency_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_currency()) { + _this->_impl_.currency_.Set(from._internal_currency(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_requestmessagekey()) { + _this->_impl_.requestmessagekey_ = new ::proto::MessageKey(*from._impl_.requestmessagekey_); + } + if (from._internal_has_primaryamount()) { + _this->_impl_.primaryamount_ = new ::proto::Money(*from._impl_.primaryamount_); + } + if (from._internal_has_exchangeamount()) { + _this->_impl_.exchangeamount_ = new ::proto::Money(*from._impl_.exchangeamount_); + } + ::memcpy(&_impl_.amount1000_, &from._impl_.amount1000_, + static_cast(reinterpret_cast(&_impl_.txnstatus_) - + reinterpret_cast(&_impl_.amount1000_)) + sizeof(_impl_.txnstatus_)); + // @@protoc_insertion_point(copy_constructor:proto.PaymentInfo) +} + +inline void PaymentInfo::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.receiverjid_){} + , decltype(_impl_.currency_){} + , decltype(_impl_.requestmessagekey_){nullptr} + , decltype(_impl_.primaryamount_){nullptr} + , decltype(_impl_.exchangeamount_){nullptr} + , decltype(_impl_.amount1000_){uint64_t{0u}} + , decltype(_impl_.currencydeprecated_){0} + , decltype(_impl_.status_){0} + , decltype(_impl_.transactiontimestamp_){uint64_t{0u}} + , decltype(_impl_.expirytimestamp_){uint64_t{0u}} + , decltype(_impl_.futureproofed_){false} + , decltype(_impl_.usenovifiatformat_){false} + , decltype(_impl_.txnstatus_){0} + }; + _impl_.receiverjid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.receiverjid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.currency_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.currency_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +PaymentInfo::~PaymentInfo() { + // @@protoc_insertion_point(destructor:proto.PaymentInfo) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void PaymentInfo::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.receiverjid_.Destroy(); + _impl_.currency_.Destroy(); + if (this != internal_default_instance()) delete _impl_.requestmessagekey_; + if (this != internal_default_instance()) delete _impl_.primaryamount_; + if (this != internal_default_instance()) delete _impl_.exchangeamount_; +} + +void PaymentInfo::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void PaymentInfo::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.PaymentInfo) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _impl_.receiverjid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.currency_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.requestmessagekey_ != nullptr); + _impl_.requestmessagekey_->Clear(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(_impl_.primaryamount_ != nullptr); + _impl_.primaryamount_->Clear(); + } + if (cached_has_bits & 0x00000010u) { + GOOGLE_DCHECK(_impl_.exchangeamount_ != nullptr); + _impl_.exchangeamount_->Clear(); + } + } + if (cached_has_bits & 0x000000e0u) { + ::memset(&_impl_.amount1000_, 0, static_cast( + reinterpret_cast(&_impl_.status_) - + reinterpret_cast(&_impl_.amount1000_)) + sizeof(_impl_.status_)); + } + if (cached_has_bits & 0x00001f00u) { + ::memset(&_impl_.transactiontimestamp_, 0, static_cast( + reinterpret_cast(&_impl_.txnstatus_) - + reinterpret_cast(&_impl_.transactiontimestamp_)) + sizeof(_impl_.txnstatus_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* PaymentInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.PaymentInfo.Currency currencyDeprecated = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::PaymentInfo_Currency_IsValid(val))) { + _internal_set_currencydeprecated(static_cast<::proto::PaymentInfo_Currency>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional uint64 amount1000 = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_amount1000(&has_bits); + _impl_.amount1000_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string receiverJid = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_receiverjid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.PaymentInfo.receiverJid"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.PaymentInfo.Status status = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::PaymentInfo_Status_IsValid(val))) { + _internal_set_status(static_cast<::proto::PaymentInfo_Status>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional uint64 transactionTimestamp = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_transactiontimestamp(&has_bits); + _impl_.transactiontimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.MessageKey requestMessageKey = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_requestmessagekey(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint64 expiryTimestamp = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + _Internal::set_has_expirytimestamp(&has_bits); + _impl_.expirytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool futureproofed = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { + _Internal::set_has_futureproofed(&has_bits); + _impl_.futureproofed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string currency = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + auto str = _internal_mutable_currency(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.PaymentInfo.currency"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.PaymentInfo.TxnStatus txnStatus = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::PaymentInfo_TxnStatus_IsValid(val))) { + _internal_set_txnstatus(static_cast<::proto::PaymentInfo_TxnStatus>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(10, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional bool useNoviFiatFormat = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { + _Internal::set_has_usenovifiatformat(&has_bits); + _impl_.usenovifiatformat_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Money primaryAmount = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { + ptr = ctx->ParseMessage(_internal_mutable_primaryamount(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Money exchangeAmount = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { + ptr = ctx->ParseMessage(_internal_mutable_exchangeamount(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* PaymentInfo::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.PaymentInfo) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.PaymentInfo.Currency currencyDeprecated = 1; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this->_internal_currencydeprecated(), target); + } + + // optional uint64 amount1000 = 2; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_amount1000(), target); + } + + // optional string receiverJid = 3; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_receiverjid().data(), static_cast(this->_internal_receiverjid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.PaymentInfo.receiverJid"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_receiverjid(), target); + } + + // optional .proto.PaymentInfo.Status status = 4; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 4, this->_internal_status(), target); + } + + // optional uint64 transactionTimestamp = 5; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_transactiontimestamp(), target); + } + + // optional .proto.MessageKey requestMessageKey = 6; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(6, _Internal::requestmessagekey(this), + _Internal::requestmessagekey(this).GetCachedSize(), target, stream); + } + + // optional uint64 expiryTimestamp = 7; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(7, this->_internal_expirytimestamp(), target); + } + + // optional bool futureproofed = 8; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(8, this->_internal_futureproofed(), target); + } + + // optional string currency = 9; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_currency().data(), static_cast(this->_internal_currency().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.PaymentInfo.currency"); + target = stream->WriteStringMaybeAliased( + 9, this->_internal_currency(), target); + } + + // optional .proto.PaymentInfo.TxnStatus txnStatus = 10; + if (cached_has_bits & 0x00001000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 10, this->_internal_txnstatus(), target); + } + + // optional bool useNoviFiatFormat = 11; + if (cached_has_bits & 0x00000800u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(11, this->_internal_usenovifiatformat(), target); + } + + // optional .proto.Money primaryAmount = 12; + if (cached_has_bits & 0x00000008u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(12, _Internal::primaryamount(this), + _Internal::primaryamount(this).GetCachedSize(), target, stream); + } + + // optional .proto.Money exchangeAmount = 13; + if (cached_has_bits & 0x00000010u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(13, _Internal::exchangeamount(this), + _Internal::exchangeamount(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.PaymentInfo) + return target; +} + +size_t PaymentInfo::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.PaymentInfo) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string receiverJid = 3; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_receiverjid()); + } + + // optional string currency = 9; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_currency()); + } + + // optional .proto.MessageKey requestMessageKey = 6; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.requestmessagekey_); + } + + // optional .proto.Money primaryAmount = 12; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.primaryamount_); + } + + // optional .proto.Money exchangeAmount = 13; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.exchangeamount_); + } + + // optional uint64 amount1000 = 2; + if (cached_has_bits & 0x00000020u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_amount1000()); + } + + // optional .proto.PaymentInfo.Currency currencyDeprecated = 1; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_currencydeprecated()); + } + + // optional .proto.PaymentInfo.Status status = 4; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_status()); + } + + } + if (cached_has_bits & 0x00001f00u) { + // optional uint64 transactionTimestamp = 5; + if (cached_has_bits & 0x00000100u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_transactiontimestamp()); + } + + // optional uint64 expiryTimestamp = 7; + if (cached_has_bits & 0x00000200u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_expirytimestamp()); + } + + // optional bool futureproofed = 8; + if (cached_has_bits & 0x00000400u) { + total_size += 1 + 1; + } + + // optional bool useNoviFiatFormat = 11; + if (cached_has_bits & 0x00000800u) { + total_size += 1 + 1; + } + + // optional .proto.PaymentInfo.TxnStatus txnStatus = 10; + if (cached_has_bits & 0x00001000u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_txnstatus()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PaymentInfo::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + PaymentInfo::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PaymentInfo::GetClassData() const { return &_class_data_; } + + +void PaymentInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.PaymentInfo) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_receiverjid(from._internal_receiverjid()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_currency(from._internal_currency()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_requestmessagekey()->::proto::MessageKey::MergeFrom( + from._internal_requestmessagekey()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_mutable_primaryamount()->::proto::Money::MergeFrom( + from._internal_primaryamount()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_mutable_exchangeamount()->::proto::Money::MergeFrom( + from._internal_exchangeamount()); + } + if (cached_has_bits & 0x00000020u) { + _this->_impl_.amount1000_ = from._impl_.amount1000_; + } + if (cached_has_bits & 0x00000040u) { + _this->_impl_.currencydeprecated_ = from._impl_.currencydeprecated_; + } + if (cached_has_bits & 0x00000080u) { + _this->_impl_.status_ = from._impl_.status_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00001f00u) { + if (cached_has_bits & 0x00000100u) { + _this->_impl_.transactiontimestamp_ = from._impl_.transactiontimestamp_; + } + if (cached_has_bits & 0x00000200u) { + _this->_impl_.expirytimestamp_ = from._impl_.expirytimestamp_; + } + if (cached_has_bits & 0x00000400u) { + _this->_impl_.futureproofed_ = from._impl_.futureproofed_; + } + if (cached_has_bits & 0x00000800u) { + _this->_impl_.usenovifiatformat_ = from._impl_.usenovifiatformat_; + } + if (cached_has_bits & 0x00001000u) { + _this->_impl_.txnstatus_ = from._impl_.txnstatus_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void PaymentInfo::CopyFrom(const PaymentInfo& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.PaymentInfo) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PaymentInfo::IsInitialized() const { + return true; +} + +void PaymentInfo::InternalSwap(PaymentInfo* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.receiverjid_, lhs_arena, + &other->_impl_.receiverjid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.currency_, lhs_arena, + &other->_impl_.currency_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(PaymentInfo, _impl_.txnstatus_) + + sizeof(PaymentInfo::_impl_.txnstatus_) + - PROTOBUF_FIELD_OFFSET(PaymentInfo, _impl_.requestmessagekey_)>( + reinterpret_cast(&_impl_.requestmessagekey_), + reinterpret_cast(&other->_impl_.requestmessagekey_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PaymentInfo::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[151]); +} + +// =================================================================== + +class PendingKeyExchange::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_sequence(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_localbasekey(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_localbasekeyprivate(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_localratchetkey(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_localratchetkeyprivate(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_localidentitykey(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_localidentitykeyprivate(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } +}; + +PendingKeyExchange::PendingKeyExchange(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.PendingKeyExchange) +} +PendingKeyExchange::PendingKeyExchange(const PendingKeyExchange& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + PendingKeyExchange* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.localbasekey_){} + , decltype(_impl_.localbasekeyprivate_){} + , decltype(_impl_.localratchetkey_){} + , decltype(_impl_.localratchetkeyprivate_){} + , decltype(_impl_.localidentitykey_){} + , decltype(_impl_.localidentitykeyprivate_){} + , decltype(_impl_.sequence_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.localbasekey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.localbasekey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_localbasekey()) { + _this->_impl_.localbasekey_.Set(from._internal_localbasekey(), + _this->GetArenaForAllocation()); + } + _impl_.localbasekeyprivate_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.localbasekeyprivate_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_localbasekeyprivate()) { + _this->_impl_.localbasekeyprivate_.Set(from._internal_localbasekeyprivate(), + _this->GetArenaForAllocation()); + } + _impl_.localratchetkey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.localratchetkey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_localratchetkey()) { + _this->_impl_.localratchetkey_.Set(from._internal_localratchetkey(), + _this->GetArenaForAllocation()); + } + _impl_.localratchetkeyprivate_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.localratchetkeyprivate_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_localratchetkeyprivate()) { + _this->_impl_.localratchetkeyprivate_.Set(from._internal_localratchetkeyprivate(), + _this->GetArenaForAllocation()); + } + _impl_.localidentitykey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.localidentitykey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_localidentitykey()) { + _this->_impl_.localidentitykey_.Set(from._internal_localidentitykey(), + _this->GetArenaForAllocation()); + } + _impl_.localidentitykeyprivate_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.localidentitykeyprivate_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_localidentitykeyprivate()) { + _this->_impl_.localidentitykeyprivate_.Set(from._internal_localidentitykeyprivate(), + _this->GetArenaForAllocation()); + } + _this->_impl_.sequence_ = from._impl_.sequence_; + // @@protoc_insertion_point(copy_constructor:proto.PendingKeyExchange) +} + +inline void PendingKeyExchange::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.localbasekey_){} + , decltype(_impl_.localbasekeyprivate_){} + , decltype(_impl_.localratchetkey_){} + , decltype(_impl_.localratchetkeyprivate_){} + , decltype(_impl_.localidentitykey_){} + , decltype(_impl_.localidentitykeyprivate_){} + , decltype(_impl_.sequence_){0u} + }; + _impl_.localbasekey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.localbasekey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.localbasekeyprivate_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.localbasekeyprivate_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.localratchetkey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.localratchetkey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.localratchetkeyprivate_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.localratchetkeyprivate_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.localidentitykey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.localidentitykey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.localidentitykeyprivate_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.localidentitykeyprivate_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +PendingKeyExchange::~PendingKeyExchange() { + // @@protoc_insertion_point(destructor:proto.PendingKeyExchange) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void PendingKeyExchange::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.localbasekey_.Destroy(); + _impl_.localbasekeyprivate_.Destroy(); + _impl_.localratchetkey_.Destroy(); + _impl_.localratchetkeyprivate_.Destroy(); + _impl_.localidentitykey_.Destroy(); + _impl_.localidentitykeyprivate_.Destroy(); +} + +void PendingKeyExchange::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void PendingKeyExchange::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.PendingKeyExchange) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + _impl_.localbasekey_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.localbasekeyprivate_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.localratchetkey_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + _impl_.localratchetkeyprivate_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + _impl_.localidentitykey_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000020u) { + _impl_.localidentitykeyprivate_.ClearNonDefaultToEmpty(); + } + } + _impl_.sequence_ = 0u; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* PendingKeyExchange::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint32 sequence = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_sequence(&has_bits); + _impl_.sequence_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes localBaseKey = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_localbasekey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes localBaseKeyPrivate = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_localbasekeyprivate(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes localRatchetKey = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_localratchetkey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes localRatchetKeyPrivate = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + auto str = _internal_mutable_localratchetkeyprivate(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes localIdentityKey = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + auto str = _internal_mutable_localidentitykey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes localIdentityKeyPrivate = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + auto str = _internal_mutable_localidentitykeyprivate(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* PendingKeyExchange::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.PendingKeyExchange) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional uint32 sequence = 1; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_sequence(), target); + } + + // optional bytes localBaseKey = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_localbasekey(), target); + } + + // optional bytes localBaseKeyPrivate = 3; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 3, this->_internal_localbasekeyprivate(), target); + } + + // optional bytes localRatchetKey = 4; + if (cached_has_bits & 0x00000004u) { + target = stream->WriteBytesMaybeAliased( + 4, this->_internal_localratchetkey(), target); + } + + // optional bytes localRatchetKeyPrivate = 5; + if (cached_has_bits & 0x00000008u) { + target = stream->WriteBytesMaybeAliased( + 5, this->_internal_localratchetkeyprivate(), target); + } + + // optional bytes localIdentityKey = 7; + if (cached_has_bits & 0x00000010u) { + target = stream->WriteBytesMaybeAliased( + 7, this->_internal_localidentitykey(), target); + } + + // optional bytes localIdentityKeyPrivate = 8; + if (cached_has_bits & 0x00000020u) { + target = stream->WriteBytesMaybeAliased( + 8, this->_internal_localidentitykeyprivate(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.PendingKeyExchange) + return target; +} + +size_t PendingKeyExchange::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.PendingKeyExchange) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + // optional bytes localBaseKey = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_localbasekey()); + } + + // optional bytes localBaseKeyPrivate = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_localbasekeyprivate()); + } + + // optional bytes localRatchetKey = 4; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_localratchetkey()); + } + + // optional bytes localRatchetKeyPrivate = 5; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_localratchetkeyprivate()); + } + + // optional bytes localIdentityKey = 7; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_localidentitykey()); + } + + // optional bytes localIdentityKeyPrivate = 8; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_localidentitykeyprivate()); + } + + // optional uint32 sequence = 1; + if (cached_has_bits & 0x00000040u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_sequence()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PendingKeyExchange::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + PendingKeyExchange::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PendingKeyExchange::GetClassData() const { return &_class_data_; } + + +void PendingKeyExchange::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.PendingKeyExchange) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_localbasekey(from._internal_localbasekey()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_localbasekeyprivate(from._internal_localbasekeyprivate()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_localratchetkey(from._internal_localratchetkey()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_set_localratchetkeyprivate(from._internal_localratchetkeyprivate()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_set_localidentitykey(from._internal_localidentitykey()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_set_localidentitykeyprivate(from._internal_localidentitykeyprivate()); + } + if (cached_has_bits & 0x00000040u) { + _this->_impl_.sequence_ = from._impl_.sequence_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void PendingKeyExchange::CopyFrom(const PendingKeyExchange& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.PendingKeyExchange) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PendingKeyExchange::IsInitialized() const { + return true; +} + +void PendingKeyExchange::InternalSwap(PendingKeyExchange* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.localbasekey_, lhs_arena, + &other->_impl_.localbasekey_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.localbasekeyprivate_, lhs_arena, + &other->_impl_.localbasekeyprivate_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.localratchetkey_, lhs_arena, + &other->_impl_.localratchetkey_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.localratchetkeyprivate_, lhs_arena, + &other->_impl_.localratchetkeyprivate_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.localidentitykey_, lhs_arena, + &other->_impl_.localidentitykey_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.localidentitykeyprivate_, lhs_arena, + &other->_impl_.localidentitykeyprivate_, rhs_arena + ); + swap(_impl_.sequence_, other->_impl_.sequence_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PendingKeyExchange::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[152]); +} + +// =================================================================== + +class PendingPreKey::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_prekeyid(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_signedprekeyid(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_basekey(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +PendingPreKey::PendingPreKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.PendingPreKey) +} +PendingPreKey::PendingPreKey(const PendingPreKey& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + PendingPreKey* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.basekey_){} + , decltype(_impl_.prekeyid_){} + , decltype(_impl_.signedprekeyid_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.basekey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.basekey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_basekey()) { + _this->_impl_.basekey_.Set(from._internal_basekey(), + _this->GetArenaForAllocation()); + } + ::memcpy(&_impl_.prekeyid_, &from._impl_.prekeyid_, + static_cast(reinterpret_cast(&_impl_.signedprekeyid_) - + reinterpret_cast(&_impl_.prekeyid_)) + sizeof(_impl_.signedprekeyid_)); + // @@protoc_insertion_point(copy_constructor:proto.PendingPreKey) +} + +inline void PendingPreKey::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.basekey_){} + , decltype(_impl_.prekeyid_){0u} + , decltype(_impl_.signedprekeyid_){0} + }; + _impl_.basekey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.basekey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +PendingPreKey::~PendingPreKey() { + // @@protoc_insertion_point(destructor:proto.PendingPreKey) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void PendingPreKey::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.basekey_.Destroy(); +} + +void PendingPreKey::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void PendingPreKey::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.PendingPreKey) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.basekey_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000006u) { + ::memset(&_impl_.prekeyid_, 0, static_cast( + reinterpret_cast(&_impl_.signedprekeyid_) - + reinterpret_cast(&_impl_.prekeyid_)) + sizeof(_impl_.signedprekeyid_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* PendingPreKey::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint32 preKeyId = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_prekeyid(&has_bits); + _impl_.prekeyid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes baseKey = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_basekey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 signedPreKeyId = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_signedprekeyid(&has_bits); + _impl_.signedprekeyid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* PendingPreKey::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.PendingPreKey) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional uint32 preKeyId = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_prekeyid(), target); + } + + // optional bytes baseKey = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_basekey(), target); + } + + // optional int32 signedPreKeyId = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_signedprekeyid(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.PendingPreKey) + return target; +} + +size_t PendingPreKey::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.PendingPreKey) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional bytes baseKey = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_basekey()); + } + + // optional uint32 preKeyId = 1; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_prekeyid()); + } + + // optional int32 signedPreKeyId = 3; + if (cached_has_bits & 0x00000004u) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_signedprekeyid()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PendingPreKey::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + PendingPreKey::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PendingPreKey::GetClassData() const { return &_class_data_; } + + +void PendingPreKey::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.PendingPreKey) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_basekey(from._internal_basekey()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.prekeyid_ = from._impl_.prekeyid_; + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.signedprekeyid_ = from._impl_.signedprekeyid_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void PendingPreKey::CopyFrom(const PendingPreKey& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.PendingPreKey) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PendingPreKey::IsInitialized() const { + return true; +} + +void PendingPreKey::InternalSwap(PendingPreKey* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.basekey_, lhs_arena, + &other->_impl_.basekey_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(PendingPreKey, _impl_.signedprekeyid_) + + sizeof(PendingPreKey::_impl_.signedprekeyid_) + - PROTOBUF_FIELD_OFFSET(PendingPreKey, _impl_.prekeyid_)>( + reinterpret_cast(&_impl_.prekeyid_), + reinterpret_cast(&other->_impl_.prekeyid_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PendingPreKey::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[153]); +} + +// =================================================================== + +class PhotoChange::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_oldphoto(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_newphoto(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_newphotoid(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +PhotoChange::PhotoChange(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.PhotoChange) +} +PhotoChange::PhotoChange(const PhotoChange& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + PhotoChange* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.oldphoto_){} + , decltype(_impl_.newphoto_){} + , decltype(_impl_.newphotoid_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.oldphoto_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.oldphoto_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_oldphoto()) { + _this->_impl_.oldphoto_.Set(from._internal_oldphoto(), + _this->GetArenaForAllocation()); + } + _impl_.newphoto_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.newphoto_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_newphoto()) { + _this->_impl_.newphoto_.Set(from._internal_newphoto(), + _this->GetArenaForAllocation()); + } + _this->_impl_.newphotoid_ = from._impl_.newphotoid_; + // @@protoc_insertion_point(copy_constructor:proto.PhotoChange) +} + +inline void PhotoChange::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.oldphoto_){} + , decltype(_impl_.newphoto_){} + , decltype(_impl_.newphotoid_){0u} + }; + _impl_.oldphoto_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.oldphoto_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.newphoto_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.newphoto_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +PhotoChange::~PhotoChange() { + // @@protoc_insertion_point(destructor:proto.PhotoChange) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void PhotoChange::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.oldphoto_.Destroy(); + _impl_.newphoto_.Destroy(); +} + +void PhotoChange::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void PhotoChange::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.PhotoChange) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.oldphoto_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.newphoto_.ClearNonDefaultToEmpty(); + } + } + _impl_.newphotoid_ = 0u; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* PhotoChange::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes oldPhoto = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_oldphoto(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes newPhoto = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_newphoto(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 newPhotoId = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_newphotoid(&has_bits); + _impl_.newphotoid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* PhotoChange::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.PhotoChange) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes oldPhoto = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_oldphoto(), target); + } + + // optional bytes newPhoto = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_newphoto(), target); + } + + // optional uint32 newPhotoId = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_newphotoid(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.PhotoChange) + return target; +} + +size_t PhotoChange::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.PhotoChange) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional bytes oldPhoto = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_oldphoto()); + } + + // optional bytes newPhoto = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_newphoto()); + } + + // optional uint32 newPhotoId = 3; + if (cached_has_bits & 0x00000004u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_newphotoid()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PhotoChange::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + PhotoChange::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PhotoChange::GetClassData() const { return &_class_data_; } + + +void PhotoChange::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.PhotoChange) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_oldphoto(from._internal_oldphoto()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_newphoto(from._internal_newphoto()); + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.newphotoid_ = from._impl_.newphotoid_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void PhotoChange::CopyFrom(const PhotoChange& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.PhotoChange) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PhotoChange::IsInitialized() const { + return true; +} + +void PhotoChange::InternalSwap(PhotoChange* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.oldphoto_, lhs_arena, + &other->_impl_.oldphoto_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.newphoto_, lhs_arena, + &other->_impl_.newphoto_, rhs_arena + ); + swap(_impl_.newphotoid_, other->_impl_.newphotoid_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PhotoChange::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[154]); +} + +// =================================================================== + +class Point::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_xdeprecated(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_ydeprecated(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_x(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_y(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +Point::Point(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Point) +} +Point::Point(const Point& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Point* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.xdeprecated_){} + , decltype(_impl_.ydeprecated_){} + , decltype(_impl_.x_){} + , decltype(_impl_.y_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&_impl_.xdeprecated_, &from._impl_.xdeprecated_, + static_cast(reinterpret_cast(&_impl_.y_) - + reinterpret_cast(&_impl_.xdeprecated_)) + sizeof(_impl_.y_)); + // @@protoc_insertion_point(copy_constructor:proto.Point) +} + +inline void Point::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.xdeprecated_){0} + , decltype(_impl_.ydeprecated_){0} + , decltype(_impl_.x_){0} + , decltype(_impl_.y_){0} + }; +} + +Point::~Point() { + // @@protoc_insertion_point(destructor:proto.Point) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Point::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void Point::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Point::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Point) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + ::memset(&_impl_.xdeprecated_, 0, static_cast( + reinterpret_cast(&_impl_.y_) - + reinterpret_cast(&_impl_.xdeprecated_)) + sizeof(_impl_.y_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Point::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional int32 xDeprecated = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_xdeprecated(&has_bits); + _impl_.xdeprecated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 yDeprecated = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_ydeprecated(&has_bits); + _impl_.ydeprecated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional double x = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 25)) { + _Internal::set_has_x(&has_bits); + _impl_.x_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(double); + } else + goto handle_unusual; + continue; + // optional double y = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 33)) { + _Internal::set_has_y(&has_bits); + _impl_.y_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(double); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Point::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Point) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional int32 xDeprecated = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_xdeprecated(), target); + } + + // optional int32 yDeprecated = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_ydeprecated(), target); + } + + // optional double x = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray(3, this->_internal_x(), target); + } + + // optional double y = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray(4, this->_internal_y(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Point) + return target; +} + +size_t Point::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Point) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional int32 xDeprecated = 1; + if (cached_has_bits & 0x00000001u) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_xdeprecated()); + } + + // optional int32 yDeprecated = 2; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_ydeprecated()); + } + + // optional double x = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 8; + } + + // optional double y = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 8; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Point::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Point::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Point::GetClassData() const { return &_class_data_; } + + +void Point::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Point) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _this->_impl_.xdeprecated_ = from._impl_.xdeprecated_; + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.ydeprecated_ = from._impl_.ydeprecated_; + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.x_ = from._impl_.x_; + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.y_ = from._impl_.y_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Point::CopyFrom(const Point& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Point) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Point::IsInitialized() const { + return true; +} + +void Point::InternalSwap(Point* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Point, _impl_.y_) + + sizeof(Point::_impl_.y_) + - PROTOBUF_FIELD_OFFSET(Point, _impl_.xdeprecated_)>( + reinterpret_cast(&_impl_.xdeprecated_), + reinterpret_cast(&other->_impl_.xdeprecated_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Point::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[155]); +} + +// =================================================================== + +class PollAdditionalMetadata::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_pollinvalidated(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +PollAdditionalMetadata::PollAdditionalMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.PollAdditionalMetadata) +} +PollAdditionalMetadata::PollAdditionalMetadata(const PollAdditionalMetadata& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + PollAdditionalMetadata* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.pollinvalidated_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _this->_impl_.pollinvalidated_ = from._impl_.pollinvalidated_; + // @@protoc_insertion_point(copy_constructor:proto.PollAdditionalMetadata) +} + +inline void PollAdditionalMetadata::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.pollinvalidated_){false} + }; +} + +PollAdditionalMetadata::~PollAdditionalMetadata() { + // @@protoc_insertion_point(destructor:proto.PollAdditionalMetadata) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void PollAdditionalMetadata::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void PollAdditionalMetadata::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void PollAdditionalMetadata::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.PollAdditionalMetadata) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.pollinvalidated_ = false; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* PollAdditionalMetadata::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bool pollInvalidated = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_pollinvalidated(&has_bits); + _impl_.pollinvalidated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* PollAdditionalMetadata::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.PollAdditionalMetadata) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bool pollInvalidated = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_pollinvalidated(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.PollAdditionalMetadata) + return target; +} + +size_t PollAdditionalMetadata::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.PollAdditionalMetadata) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional bool pollInvalidated = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 1; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PollAdditionalMetadata::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + PollAdditionalMetadata::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PollAdditionalMetadata::GetClassData() const { return &_class_data_; } + + +void PollAdditionalMetadata::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.PollAdditionalMetadata) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_pollinvalidated()) { + _this->_internal_set_pollinvalidated(from._internal_pollinvalidated()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void PollAdditionalMetadata::CopyFrom(const PollAdditionalMetadata& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.PollAdditionalMetadata) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PollAdditionalMetadata::IsInitialized() const { + return true; +} + +void PollAdditionalMetadata::InternalSwap(PollAdditionalMetadata* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_.pollinvalidated_, other->_impl_.pollinvalidated_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PollAdditionalMetadata::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[156]); +} + +// =================================================================== + +class PollEncValue::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_encpayload(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_enciv(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +PollEncValue::PollEncValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.PollEncValue) +} +PollEncValue::PollEncValue(const PollEncValue& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + PollEncValue* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.encpayload_){} + , decltype(_impl_.enciv_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.encpayload_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.encpayload_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_encpayload()) { + _this->_impl_.encpayload_.Set(from._internal_encpayload(), + _this->GetArenaForAllocation()); + } + _impl_.enciv_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.enciv_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_enciv()) { + _this->_impl_.enciv_.Set(from._internal_enciv(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.PollEncValue) +} + +inline void PollEncValue::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.encpayload_){} + , decltype(_impl_.enciv_){} + }; + _impl_.encpayload_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.encpayload_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.enciv_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.enciv_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +PollEncValue::~PollEncValue() { + // @@protoc_insertion_point(destructor:proto.PollEncValue) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void PollEncValue::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.encpayload_.Destroy(); + _impl_.enciv_.Destroy(); +} + +void PollEncValue::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void PollEncValue::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.PollEncValue) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.encpayload_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.enciv_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* PollEncValue::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes encPayload = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_encpayload(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes encIv = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_enciv(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* PollEncValue::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.PollEncValue) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes encPayload = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_encpayload(), target); + } + + // optional bytes encIv = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_enciv(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.PollEncValue) + return target; +} + +size_t PollEncValue::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.PollEncValue) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional bytes encPayload = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_encpayload()); + } + + // optional bytes encIv = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_enciv()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PollEncValue::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + PollEncValue::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PollEncValue::GetClassData() const { return &_class_data_; } + + +void PollEncValue::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.PollEncValue) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_encpayload(from._internal_encpayload()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_enciv(from._internal_enciv()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void PollEncValue::CopyFrom(const PollEncValue& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.PollEncValue) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PollEncValue::IsInitialized() const { + return true; +} + +void PollEncValue::InternalSwap(PollEncValue* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.encpayload_, lhs_arena, + &other->_impl_.encpayload_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.enciv_, lhs_arena, + &other->_impl_.enciv_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PollEncValue::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[157]); +} + +// =================================================================== + +class PollUpdate::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::MessageKey& pollupdatemessagekey(const PollUpdate* msg); + static void set_has_pollupdatemessagekey(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::proto::Message_PollVoteMessage& vote(const PollUpdate* msg); + static void set_has_vote(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_sendertimestampms(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +const ::proto::MessageKey& +PollUpdate::_Internal::pollupdatemessagekey(const PollUpdate* msg) { + return *msg->_impl_.pollupdatemessagekey_; +} +const ::proto::Message_PollVoteMessage& +PollUpdate::_Internal::vote(const PollUpdate* msg) { + return *msg->_impl_.vote_; +} +PollUpdate::PollUpdate(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.PollUpdate) +} +PollUpdate::PollUpdate(const PollUpdate& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + PollUpdate* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.pollupdatemessagekey_){nullptr} + , decltype(_impl_.vote_){nullptr} + , decltype(_impl_.sendertimestampms_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_pollupdatemessagekey()) { + _this->_impl_.pollupdatemessagekey_ = new ::proto::MessageKey(*from._impl_.pollupdatemessagekey_); + } + if (from._internal_has_vote()) { + _this->_impl_.vote_ = new ::proto::Message_PollVoteMessage(*from._impl_.vote_); + } + _this->_impl_.sendertimestampms_ = from._impl_.sendertimestampms_; + // @@protoc_insertion_point(copy_constructor:proto.PollUpdate) +} + +inline void PollUpdate::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.pollupdatemessagekey_){nullptr} + , decltype(_impl_.vote_){nullptr} + , decltype(_impl_.sendertimestampms_){int64_t{0}} + }; +} + +PollUpdate::~PollUpdate() { + // @@protoc_insertion_point(destructor:proto.PollUpdate) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void PollUpdate::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.pollupdatemessagekey_; + if (this != internal_default_instance()) delete _impl_.vote_; +} + +void PollUpdate::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void PollUpdate::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.PollUpdate) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.pollupdatemessagekey_ != nullptr); + _impl_.pollupdatemessagekey_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.vote_ != nullptr); + _impl_.vote_->Clear(); + } + } + _impl_.sendertimestampms_ = int64_t{0}; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* PollUpdate::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.MessageKey pollUpdateMessageKey = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_pollupdatemessagekey(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.PollVoteMessage vote = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_vote(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 senderTimestampMs = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_sendertimestampms(&has_bits); + _impl_.sendertimestampms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* PollUpdate::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.PollUpdate) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.MessageKey pollUpdateMessageKey = 1; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::pollupdatemessagekey(this), + _Internal::pollupdatemessagekey(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.PollVoteMessage vote = 2; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::vote(this), + _Internal::vote(this).GetCachedSize(), target, stream); + } + + // optional int64 senderTimestampMs = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_sendertimestampms(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.PollUpdate) + return target; +} + +size_t PollUpdate::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.PollUpdate) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional .proto.MessageKey pollUpdateMessageKey = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.pollupdatemessagekey_); + } + + // optional .proto.Message.PollVoteMessage vote = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.vote_); + } + + // optional int64 senderTimestampMs = 3; + if (cached_has_bits & 0x00000004u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_sendertimestampms()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PollUpdate::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + PollUpdate::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PollUpdate::GetClassData() const { return &_class_data_; } + + +void PollUpdate::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.PollUpdate) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_pollupdatemessagekey()->::proto::MessageKey::MergeFrom( + from._internal_pollupdatemessagekey()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_vote()->::proto::Message_PollVoteMessage::MergeFrom( + from._internal_vote()); + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.sendertimestampms_ = from._impl_.sendertimestampms_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void PollUpdate::CopyFrom(const PollUpdate& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.PollUpdate) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PollUpdate::IsInitialized() const { + return true; +} + +void PollUpdate::InternalSwap(PollUpdate* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(PollUpdate, _impl_.sendertimestampms_) + + sizeof(PollUpdate::_impl_.sendertimestampms_) + - PROTOBUF_FIELD_OFFSET(PollUpdate, _impl_.pollupdatemessagekey_)>( + reinterpret_cast(&_impl_.pollupdatemessagekey_), + reinterpret_cast(&other->_impl_.pollupdatemessagekey_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PollUpdate::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[158]); +} + +// =================================================================== + +class PreKeyRecordStructure::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_id(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_publickey(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_privatekey(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +PreKeyRecordStructure::PreKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.PreKeyRecordStructure) +} +PreKeyRecordStructure::PreKeyRecordStructure(const PreKeyRecordStructure& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + PreKeyRecordStructure* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.publickey_){} + , decltype(_impl_.privatekey_){} + , decltype(_impl_.id_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.publickey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.publickey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_publickey()) { + _this->_impl_.publickey_.Set(from._internal_publickey(), + _this->GetArenaForAllocation()); + } + _impl_.privatekey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.privatekey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_privatekey()) { + _this->_impl_.privatekey_.Set(from._internal_privatekey(), + _this->GetArenaForAllocation()); + } + _this->_impl_.id_ = from._impl_.id_; + // @@protoc_insertion_point(copy_constructor:proto.PreKeyRecordStructure) +} + +inline void PreKeyRecordStructure::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.publickey_){} + , decltype(_impl_.privatekey_){} + , decltype(_impl_.id_){0u} + }; + _impl_.publickey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.publickey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.privatekey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.privatekey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +PreKeyRecordStructure::~PreKeyRecordStructure() { + // @@protoc_insertion_point(destructor:proto.PreKeyRecordStructure) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void PreKeyRecordStructure::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.publickey_.Destroy(); + _impl_.privatekey_.Destroy(); +} + +void PreKeyRecordStructure::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void PreKeyRecordStructure::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.PreKeyRecordStructure) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.publickey_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.privatekey_.ClearNonDefaultToEmpty(); + } + } + _impl_.id_ = 0u; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* PreKeyRecordStructure::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint32 id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_id(&has_bits); + _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes publicKey = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_publickey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes privateKey = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_privatekey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* PreKeyRecordStructure::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.PreKeyRecordStructure) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional uint32 id = 1; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_id(), target); + } + + // optional bytes publicKey = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_publickey(), target); + } + + // optional bytes privateKey = 3; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 3, this->_internal_privatekey(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.PreKeyRecordStructure) + return target; +} + +size_t PreKeyRecordStructure::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.PreKeyRecordStructure) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional bytes publicKey = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_publickey()); + } + + // optional bytes privateKey = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_privatekey()); + } + + // optional uint32 id = 1; + if (cached_has_bits & 0x00000004u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_id()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PreKeyRecordStructure::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + PreKeyRecordStructure::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PreKeyRecordStructure::GetClassData() const { return &_class_data_; } + + +void PreKeyRecordStructure::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.PreKeyRecordStructure) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_publickey(from._internal_publickey()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_privatekey(from._internal_privatekey()); + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.id_ = from._impl_.id_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void PreKeyRecordStructure::CopyFrom(const PreKeyRecordStructure& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.PreKeyRecordStructure) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PreKeyRecordStructure::IsInitialized() const { + return true; +} + +void PreKeyRecordStructure::InternalSwap(PreKeyRecordStructure* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.publickey_, lhs_arena, + &other->_impl_.publickey_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.privatekey_, lhs_arena, + &other->_impl_.privatekey_, rhs_arena + ); + swap(_impl_.id_, other->_impl_.id_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PreKeyRecordStructure::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[159]); +} + +// =================================================================== + +class Pushname::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_id(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_pushname(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +Pushname::Pushname(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Pushname) +} +Pushname::Pushname(const Pushname& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Pushname* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.id_){} + , decltype(_impl_.pushname_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.id_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.id_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_id()) { + _this->_impl_.id_.Set(from._internal_id(), + _this->GetArenaForAllocation()); + } + _impl_.pushname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.pushname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_pushname()) { + _this->_impl_.pushname_.Set(from._internal_pushname(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.Pushname) +} + +inline void Pushname::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.id_){} + , decltype(_impl_.pushname_){} + }; + _impl_.id_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.id_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.pushname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.pushname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Pushname::~Pushname() { + // @@protoc_insertion_point(destructor:proto.Pushname) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Pushname::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.id_.Destroy(); + _impl_.pushname_.Destroy(); +} + +void Pushname::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Pushname::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Pushname) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.id_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.pushname_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Pushname::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_id(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Pushname.id"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string pushname = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_pushname(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Pushname.pushname"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Pushname::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Pushname) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string id = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_id().data(), static_cast(this->_internal_id().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Pushname.id"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_id(), target); + } + + // optional string pushname = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_pushname().data(), static_cast(this->_internal_pushname().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Pushname.pushname"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_pushname(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Pushname) + return target; +} + +size_t Pushname::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Pushname) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional string id = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_id()); + } + + // optional string pushname = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_pushname()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Pushname::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Pushname::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Pushname::GetClassData() const { return &_class_data_; } + + +void Pushname::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Pushname) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_id(from._internal_id()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_pushname(from._internal_pushname()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Pushname::CopyFrom(const Pushname& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Pushname) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Pushname::IsInitialized() const { + return true; +} + +void Pushname::InternalSwap(Pushname* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.id_, lhs_arena, + &other->_impl_.id_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.pushname_, lhs_arena, + &other->_impl_.pushname_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Pushname::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[160]); +} + +// =================================================================== + +class Reaction::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::MessageKey& key(const Reaction* msg); + static void set_has_key(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_text(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_groupingkey(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_sendertimestampms(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_unread(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } +}; + +const ::proto::MessageKey& +Reaction::_Internal::key(const Reaction* msg) { + return *msg->_impl_.key_; +} +Reaction::Reaction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.Reaction) +} +Reaction::Reaction(const Reaction& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + Reaction* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.text_){} + , decltype(_impl_.groupingkey_){} + , decltype(_impl_.key_){nullptr} + , decltype(_impl_.sendertimestampms_){} + , decltype(_impl_.unread_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.text_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.text_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_text()) { + _this->_impl_.text_.Set(from._internal_text(), + _this->GetArenaForAllocation()); + } + _impl_.groupingkey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.groupingkey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_groupingkey()) { + _this->_impl_.groupingkey_.Set(from._internal_groupingkey(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_key()) { + _this->_impl_.key_ = new ::proto::MessageKey(*from._impl_.key_); + } + ::memcpy(&_impl_.sendertimestampms_, &from._impl_.sendertimestampms_, + static_cast(reinterpret_cast(&_impl_.unread_) - + reinterpret_cast(&_impl_.sendertimestampms_)) + sizeof(_impl_.unread_)); + // @@protoc_insertion_point(copy_constructor:proto.Reaction) +} + +inline void Reaction::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.text_){} + , decltype(_impl_.groupingkey_){} + , decltype(_impl_.key_){nullptr} + , decltype(_impl_.sendertimestampms_){int64_t{0}} + , decltype(_impl_.unread_){false} + }; + _impl_.text_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.text_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.groupingkey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.groupingkey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +Reaction::~Reaction() { + // @@protoc_insertion_point(destructor:proto.Reaction) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void Reaction::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.text_.Destroy(); + _impl_.groupingkey_.Destroy(); + if (this != internal_default_instance()) delete _impl_.key_; +} + +void Reaction::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void Reaction::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.Reaction) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _impl_.text_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.groupingkey_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.key_ != nullptr); + _impl_.key_->Clear(); + } + } + if (cached_has_bits & 0x00000018u) { + ::memset(&_impl_.sendertimestampms_, 0, static_cast( + reinterpret_cast(&_impl_.unread_) - + reinterpret_cast(&_impl_.sendertimestampms_)) + sizeof(_impl_.unread_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Reaction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.MessageKey key = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string text = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_text(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Reaction.text"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string groupingKey = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_groupingkey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.Reaction.groupingKey"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional int64 senderTimestampMs = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_sendertimestampms(&has_bits); + _impl_.sendertimestampms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool unread = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_unread(&has_bits); + _impl_.unread_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* Reaction::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.Reaction) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.MessageKey key = 1; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::key(this), + _Internal::key(this).GetCachedSize(), target, stream); + } + + // optional string text = 2; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_text().data(), static_cast(this->_internal_text().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Reaction.text"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_text(), target); + } + + // optional string groupingKey = 3; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_groupingkey().data(), static_cast(this->_internal_groupingkey().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.Reaction.groupingKey"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_groupingkey(), target); + } + + // optional int64 senderTimestampMs = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_sendertimestampms(), target); + } + + // optional bool unread = 5; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(5, this->_internal_unread(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.Reaction) + return target; +} + +size_t Reaction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.Reaction) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + // optional string text = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_text()); + } + + // optional string groupingKey = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_groupingkey()); + } + + // optional .proto.MessageKey key = 1; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.key_); + } + + // optional int64 senderTimestampMs = 4; + if (cached_has_bits & 0x00000008u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_sendertimestampms()); + } + + // optional bool unread = 5; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + 1; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Reaction::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + Reaction::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Reaction::GetClassData() const { return &_class_data_; } + + +void Reaction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.Reaction) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_text(from._internal_text()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_groupingkey(from._internal_groupingkey()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_key()->::proto::MessageKey::MergeFrom( + from._internal_key()); + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.sendertimestampms_ = from._impl_.sendertimestampms_; + } + if (cached_has_bits & 0x00000010u) { + _this->_impl_.unread_ = from._impl_.unread_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void Reaction::CopyFrom(const Reaction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.Reaction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Reaction::IsInitialized() const { + return true; +} + +void Reaction::InternalSwap(Reaction* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.text_, lhs_arena, + &other->_impl_.text_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.groupingkey_, lhs_arena, + &other->_impl_.groupingkey_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Reaction, _impl_.unread_) + + sizeof(Reaction::_impl_.unread_) + - PROTOBUF_FIELD_OFFSET(Reaction, _impl_.key_)>( + reinterpret_cast(&_impl_.key_), + reinterpret_cast(&other->_impl_.key_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Reaction::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[161]); +} + +// =================================================================== + +class RecentEmojiWeight::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_emoji(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_weight(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +RecentEmojiWeight::RecentEmojiWeight(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.RecentEmojiWeight) +} +RecentEmojiWeight::RecentEmojiWeight(const RecentEmojiWeight& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + RecentEmojiWeight* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.emoji_){} + , decltype(_impl_.weight_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.emoji_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.emoji_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_emoji()) { + _this->_impl_.emoji_.Set(from._internal_emoji(), + _this->GetArenaForAllocation()); + } + _this->_impl_.weight_ = from._impl_.weight_; + // @@protoc_insertion_point(copy_constructor:proto.RecentEmojiWeight) +} + +inline void RecentEmojiWeight::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.emoji_){} + , decltype(_impl_.weight_){0} + }; + _impl_.emoji_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.emoji_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +RecentEmojiWeight::~RecentEmojiWeight() { + // @@protoc_insertion_point(destructor:proto.RecentEmojiWeight) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void RecentEmojiWeight::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.emoji_.Destroy(); +} + +void RecentEmojiWeight::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void RecentEmojiWeight::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.RecentEmojiWeight) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.emoji_.ClearNonDefaultToEmpty(); + } + _impl_.weight_ = 0; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* RecentEmojiWeight::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string emoji = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_emoji(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.RecentEmojiWeight.emoji"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional float weight = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 21)) { + _Internal::set_has_weight(&has_bits); + _impl_.weight_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* RecentEmojiWeight::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.RecentEmojiWeight) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string emoji = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_emoji().data(), static_cast(this->_internal_emoji().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.RecentEmojiWeight.emoji"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_emoji(), target); + } + + // optional float weight = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFloatToArray(2, this->_internal_weight(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.RecentEmojiWeight) + return target; +} + +size_t RecentEmojiWeight::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.RecentEmojiWeight) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional string emoji = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_emoji()); + } + + // optional float weight = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 4; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RecentEmojiWeight::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + RecentEmojiWeight::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RecentEmojiWeight::GetClassData() const { return &_class_data_; } + + +void RecentEmojiWeight::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.RecentEmojiWeight) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_emoji(from._internal_emoji()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.weight_ = from._impl_.weight_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void RecentEmojiWeight::CopyFrom(const RecentEmojiWeight& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.RecentEmojiWeight) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RecentEmojiWeight::IsInitialized() const { + return true; +} + +void RecentEmojiWeight::InternalSwap(RecentEmojiWeight* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.emoji_, lhs_arena, + &other->_impl_.emoji_, rhs_arena + ); + swap(_impl_.weight_, other->_impl_.weight_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata RecentEmojiWeight::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[162]); +} + +// =================================================================== + +class RecordStructure::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::SessionStructure& currentsession(const RecordStructure* msg); + static void set_has_currentsession(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +const ::proto::SessionStructure& +RecordStructure::_Internal::currentsession(const RecordStructure* msg) { + return *msg->_impl_.currentsession_; +} +RecordStructure::RecordStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.RecordStructure) +} +RecordStructure::RecordStructure(const RecordStructure& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + RecordStructure* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.previoussessions_){from._impl_.previoussessions_} + , decltype(_impl_.currentsession_){nullptr}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_currentsession()) { + _this->_impl_.currentsession_ = new ::proto::SessionStructure(*from._impl_.currentsession_); + } + // @@protoc_insertion_point(copy_constructor:proto.RecordStructure) +} + +inline void RecordStructure::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.previoussessions_){arena} + , decltype(_impl_.currentsession_){nullptr} + }; +} + +RecordStructure::~RecordStructure() { + // @@protoc_insertion_point(destructor:proto.RecordStructure) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void RecordStructure::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.previoussessions_.~RepeatedPtrField(); + if (this != internal_default_instance()) delete _impl_.currentsession_; +} + +void RecordStructure::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void RecordStructure::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.RecordStructure) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.previoussessions_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.currentsession_ != nullptr); + _impl_.currentsession_->Clear(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* RecordStructure::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.SessionStructure currentSession = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_currentsession(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .proto.SessionStructure previousSessions = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_previoussessions(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* RecordStructure::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.RecordStructure) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.SessionStructure currentSession = 1; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::currentsession(this), + _Internal::currentsession(this).GetCachedSize(), target, stream); + } + + // repeated .proto.SessionStructure previousSessions = 2; + for (unsigned i = 0, + n = static_cast(this->_internal_previoussessions_size()); i < n; i++) { + const auto& repfield = this->_internal_previoussessions(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.RecordStructure) + return target; +} + +size_t RecordStructure::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.RecordStructure) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.SessionStructure previousSessions = 2; + total_size += 1UL * this->_internal_previoussessions_size(); + for (const auto& msg : this->_impl_.previoussessions_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // optional .proto.SessionStructure currentSession = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.currentsession_); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RecordStructure::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + RecordStructure::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RecordStructure::GetClassData() const { return &_class_data_; } + + +void RecordStructure::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.RecordStructure) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.previoussessions_.MergeFrom(from._impl_.previoussessions_); + if (from._internal_has_currentsession()) { + _this->_internal_mutable_currentsession()->::proto::SessionStructure::MergeFrom( + from._internal_currentsession()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void RecordStructure::CopyFrom(const RecordStructure& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.RecordStructure) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RecordStructure::IsInitialized() const { + return true; +} + +void RecordStructure::InternalSwap(RecordStructure* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.previoussessions_.InternalSwap(&other->_impl_.previoussessions_); + swap(_impl_.currentsession_, other->_impl_.currentsession_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata RecordStructure::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[163]); +} + +// =================================================================== + +class SenderChainKey::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_iteration(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_seed(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +SenderChainKey::SenderChainKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SenderChainKey) +} +SenderChainKey::SenderChainKey(const SenderChainKey& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SenderChainKey* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.seed_){} + , decltype(_impl_.iteration_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.seed_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.seed_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_seed()) { + _this->_impl_.seed_.Set(from._internal_seed(), + _this->GetArenaForAllocation()); + } + _this->_impl_.iteration_ = from._impl_.iteration_; + // @@protoc_insertion_point(copy_constructor:proto.SenderChainKey) +} + +inline void SenderChainKey::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.seed_){} + , decltype(_impl_.iteration_){0u} + }; + _impl_.seed_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.seed_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +SenderChainKey::~SenderChainKey() { + // @@protoc_insertion_point(destructor:proto.SenderChainKey) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SenderChainKey::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.seed_.Destroy(); +} + +void SenderChainKey::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SenderChainKey::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SenderChainKey) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.seed_.ClearNonDefaultToEmpty(); + } + _impl_.iteration_ = 0u; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SenderChainKey::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint32 iteration = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_iteration(&has_bits); + _impl_.iteration_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes seed = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_seed(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SenderChainKey::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SenderChainKey) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional uint32 iteration = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_iteration(), target); + } + + // optional bytes seed = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_seed(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SenderChainKey) + return target; +} + +size_t SenderChainKey::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SenderChainKey) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional bytes seed = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_seed()); + } + + // optional uint32 iteration = 1; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_iteration()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SenderChainKey::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SenderChainKey::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SenderChainKey::GetClassData() const { return &_class_data_; } + + +void SenderChainKey::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SenderChainKey) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_seed(from._internal_seed()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.iteration_ = from._impl_.iteration_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SenderChainKey::CopyFrom(const SenderChainKey& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SenderChainKey) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SenderChainKey::IsInitialized() const { + return true; +} + +void SenderChainKey::InternalSwap(SenderChainKey* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.seed_, lhs_arena, + &other->_impl_.seed_, rhs_arena + ); + swap(_impl_.iteration_, other->_impl_.iteration_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SenderChainKey::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[164]); +} + +// =================================================================== + +class SenderKeyRecordStructure::_Internal { + public: +}; + +SenderKeyRecordStructure::SenderKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SenderKeyRecordStructure) +} +SenderKeyRecordStructure::SenderKeyRecordStructure(const SenderKeyRecordStructure& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SenderKeyRecordStructure* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.senderkeystates_){from._impl_.senderkeystates_} + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:proto.SenderKeyRecordStructure) +} + +inline void SenderKeyRecordStructure::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_.senderkeystates_){arena} + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +SenderKeyRecordStructure::~SenderKeyRecordStructure() { + // @@protoc_insertion_point(destructor:proto.SenderKeyRecordStructure) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SenderKeyRecordStructure::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.senderkeystates_.~RepeatedPtrField(); +} + +void SenderKeyRecordStructure::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SenderKeyRecordStructure::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SenderKeyRecordStructure) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.senderkeystates_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SenderKeyRecordStructure::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .proto.SenderKeyStateStructure senderKeyStates = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_senderkeystates(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SenderKeyRecordStructure::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SenderKeyRecordStructure) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .proto.SenderKeyStateStructure senderKeyStates = 1; + for (unsigned i = 0, + n = static_cast(this->_internal_senderkeystates_size()); i < n; i++) { + const auto& repfield = this->_internal_senderkeystates(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SenderKeyRecordStructure) + return target; +} + +size_t SenderKeyRecordStructure::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SenderKeyRecordStructure) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.SenderKeyStateStructure senderKeyStates = 1; + total_size += 1UL * this->_internal_senderkeystates_size(); + for (const auto& msg : this->_impl_.senderkeystates_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SenderKeyRecordStructure::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SenderKeyRecordStructure::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SenderKeyRecordStructure::GetClassData() const { return &_class_data_; } + + +void SenderKeyRecordStructure::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SenderKeyRecordStructure) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.senderkeystates_.MergeFrom(from._impl_.senderkeystates_); + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SenderKeyRecordStructure::CopyFrom(const SenderKeyRecordStructure& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SenderKeyRecordStructure) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SenderKeyRecordStructure::IsInitialized() const { + return true; +} + +void SenderKeyRecordStructure::InternalSwap(SenderKeyRecordStructure* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.senderkeystates_.InternalSwap(&other->_impl_.senderkeystates_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SenderKeyRecordStructure::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[165]); +} + +// =================================================================== + +class SenderKeyStateStructure::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_senderkeyid(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static const ::proto::SenderChainKey& senderchainkey(const SenderKeyStateStructure* msg); + static void set_has_senderchainkey(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::proto::SenderSigningKey& sendersigningkey(const SenderKeyStateStructure* msg); + static void set_has_sendersigningkey(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::proto::SenderChainKey& +SenderKeyStateStructure::_Internal::senderchainkey(const SenderKeyStateStructure* msg) { + return *msg->_impl_.senderchainkey_; +} +const ::proto::SenderSigningKey& +SenderKeyStateStructure::_Internal::sendersigningkey(const SenderKeyStateStructure* msg) { + return *msg->_impl_.sendersigningkey_; +} +SenderKeyStateStructure::SenderKeyStateStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SenderKeyStateStructure) +} +SenderKeyStateStructure::SenderKeyStateStructure(const SenderKeyStateStructure& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SenderKeyStateStructure* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.sendermessagekeys_){from._impl_.sendermessagekeys_} + , decltype(_impl_.senderchainkey_){nullptr} + , decltype(_impl_.sendersigningkey_){nullptr} + , decltype(_impl_.senderkeyid_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_senderchainkey()) { + _this->_impl_.senderchainkey_ = new ::proto::SenderChainKey(*from._impl_.senderchainkey_); + } + if (from._internal_has_sendersigningkey()) { + _this->_impl_.sendersigningkey_ = new ::proto::SenderSigningKey(*from._impl_.sendersigningkey_); + } + _this->_impl_.senderkeyid_ = from._impl_.senderkeyid_; + // @@protoc_insertion_point(copy_constructor:proto.SenderKeyStateStructure) +} + +inline void SenderKeyStateStructure::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.sendermessagekeys_){arena} + , decltype(_impl_.senderchainkey_){nullptr} + , decltype(_impl_.sendersigningkey_){nullptr} + , decltype(_impl_.senderkeyid_){0u} + }; +} + +SenderKeyStateStructure::~SenderKeyStateStructure() { + // @@protoc_insertion_point(destructor:proto.SenderKeyStateStructure) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SenderKeyStateStructure::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.sendermessagekeys_.~RepeatedPtrField(); + if (this != internal_default_instance()) delete _impl_.senderchainkey_; + if (this != internal_default_instance()) delete _impl_.sendersigningkey_; +} + +void SenderKeyStateStructure::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SenderKeyStateStructure::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SenderKeyStateStructure) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.sendermessagekeys_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.senderchainkey_ != nullptr); + _impl_.senderchainkey_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.sendersigningkey_ != nullptr); + _impl_.sendersigningkey_->Clear(); + } + } + _impl_.senderkeyid_ = 0u; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SenderKeyStateStructure::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint32 senderKeyId = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_senderkeyid(&has_bits); + _impl_.senderkeyid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SenderChainKey senderChainKey = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_senderchainkey(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SenderSigningKey senderSigningKey = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_sendersigningkey(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .proto.SenderMessageKey senderMessageKeys = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_sendermessagekeys(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SenderKeyStateStructure::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SenderKeyStateStructure) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional uint32 senderKeyId = 1; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_senderkeyid(), target); + } + + // optional .proto.SenderChainKey senderChainKey = 2; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::senderchainkey(this), + _Internal::senderchainkey(this).GetCachedSize(), target, stream); + } + + // optional .proto.SenderSigningKey senderSigningKey = 3; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::sendersigningkey(this), + _Internal::sendersigningkey(this).GetCachedSize(), target, stream); + } + + // repeated .proto.SenderMessageKey senderMessageKeys = 4; + for (unsigned i = 0, + n = static_cast(this->_internal_sendermessagekeys_size()); i < n; i++) { + const auto& repfield = this->_internal_sendermessagekeys(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SenderKeyStateStructure) + return target; +} + +size_t SenderKeyStateStructure::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SenderKeyStateStructure) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.SenderMessageKey senderMessageKeys = 4; + total_size += 1UL * this->_internal_sendermessagekeys_size(); + for (const auto& msg : this->_impl_.sendermessagekeys_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional .proto.SenderChainKey senderChainKey = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.senderchainkey_); + } + + // optional .proto.SenderSigningKey senderSigningKey = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.sendersigningkey_); + } + + // optional uint32 senderKeyId = 1; + if (cached_has_bits & 0x00000004u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_senderkeyid()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SenderKeyStateStructure::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SenderKeyStateStructure::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SenderKeyStateStructure::GetClassData() const { return &_class_data_; } + + +void SenderKeyStateStructure::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SenderKeyStateStructure) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.sendermessagekeys_.MergeFrom(from._impl_.sendermessagekeys_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_senderchainkey()->::proto::SenderChainKey::MergeFrom( + from._internal_senderchainkey()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_sendersigningkey()->::proto::SenderSigningKey::MergeFrom( + from._internal_sendersigningkey()); + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.senderkeyid_ = from._impl_.senderkeyid_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SenderKeyStateStructure::CopyFrom(const SenderKeyStateStructure& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SenderKeyStateStructure) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SenderKeyStateStructure::IsInitialized() const { + return true; +} + +void SenderKeyStateStructure::InternalSwap(SenderKeyStateStructure* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.sendermessagekeys_.InternalSwap(&other->_impl_.sendermessagekeys_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SenderKeyStateStructure, _impl_.senderkeyid_) + + sizeof(SenderKeyStateStructure::_impl_.senderkeyid_) + - PROTOBUF_FIELD_OFFSET(SenderKeyStateStructure, _impl_.senderchainkey_)>( + reinterpret_cast(&_impl_.senderchainkey_), + reinterpret_cast(&other->_impl_.senderchainkey_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SenderKeyStateStructure::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[166]); +} + +// =================================================================== + +class SenderMessageKey::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_iteration(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_seed(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +SenderMessageKey::SenderMessageKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SenderMessageKey) +} +SenderMessageKey::SenderMessageKey(const SenderMessageKey& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SenderMessageKey* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.seed_){} + , decltype(_impl_.iteration_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.seed_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.seed_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_seed()) { + _this->_impl_.seed_.Set(from._internal_seed(), + _this->GetArenaForAllocation()); + } + _this->_impl_.iteration_ = from._impl_.iteration_; + // @@protoc_insertion_point(copy_constructor:proto.SenderMessageKey) +} + +inline void SenderMessageKey::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.seed_){} + , decltype(_impl_.iteration_){0u} + }; + _impl_.seed_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.seed_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +SenderMessageKey::~SenderMessageKey() { + // @@protoc_insertion_point(destructor:proto.SenderMessageKey) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SenderMessageKey::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.seed_.Destroy(); +} + +void SenderMessageKey::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SenderMessageKey::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SenderMessageKey) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.seed_.ClearNonDefaultToEmpty(); + } + _impl_.iteration_ = 0u; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SenderMessageKey::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint32 iteration = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_iteration(&has_bits); + _impl_.iteration_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes seed = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_seed(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SenderMessageKey::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SenderMessageKey) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional uint32 iteration = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_iteration(), target); + } + + // optional bytes seed = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_seed(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SenderMessageKey) + return target; +} + +size_t SenderMessageKey::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SenderMessageKey) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional bytes seed = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_seed()); + } + + // optional uint32 iteration = 1; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_iteration()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SenderMessageKey::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SenderMessageKey::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SenderMessageKey::GetClassData() const { return &_class_data_; } + + +void SenderMessageKey::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SenderMessageKey) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_seed(from._internal_seed()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.iteration_ = from._impl_.iteration_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SenderMessageKey::CopyFrom(const SenderMessageKey& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SenderMessageKey) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SenderMessageKey::IsInitialized() const { + return true; +} + +void SenderMessageKey::InternalSwap(SenderMessageKey* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.seed_, lhs_arena, + &other->_impl_.seed_, rhs_arena + ); + swap(_impl_.iteration_, other->_impl_.iteration_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SenderMessageKey::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[167]); +} + +// =================================================================== + +class SenderSigningKey::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_public_(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_private_(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +SenderSigningKey::SenderSigningKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SenderSigningKey) +} +SenderSigningKey::SenderSigningKey(const SenderSigningKey& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SenderSigningKey* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.public__){} + , decltype(_impl_.private__){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.public__.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.public__.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_public_()) { + _this->_impl_.public__.Set(from._internal_public_(), + _this->GetArenaForAllocation()); + } + _impl_.private__.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.private__.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_private_()) { + _this->_impl_.private__.Set(from._internal_private_(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.SenderSigningKey) +} + +inline void SenderSigningKey::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.public__){} + , decltype(_impl_.private__){} + }; + _impl_.public__.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.public__.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.private__.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.private__.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +SenderSigningKey::~SenderSigningKey() { + // @@protoc_insertion_point(destructor:proto.SenderSigningKey) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SenderSigningKey::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.public__.Destroy(); + _impl_.private__.Destroy(); +} + +void SenderSigningKey::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SenderSigningKey::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SenderSigningKey) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.public__.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.private__.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SenderSigningKey::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes public = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_public_(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes private = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_private_(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SenderSigningKey::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SenderSigningKey) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes public = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_public_(), target); + } + + // optional bytes private = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_private_(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SenderSigningKey) + return target; +} + +size_t SenderSigningKey::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SenderSigningKey) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional bytes public = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_public_()); + } + + // optional bytes private = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_private_()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SenderSigningKey::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SenderSigningKey::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SenderSigningKey::GetClassData() const { return &_class_data_; } + + +void SenderSigningKey::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SenderSigningKey) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_public_(from._internal_public_()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_private_(from._internal_private_()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SenderSigningKey::CopyFrom(const SenderSigningKey& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SenderSigningKey) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SenderSigningKey::IsInitialized() const { + return true; +} + +void SenderSigningKey::InternalSwap(SenderSigningKey* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.public__, lhs_arena, + &other->_impl_.public__, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.private__, lhs_arena, + &other->_impl_.private__, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SenderSigningKey::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[168]); +} + +// =================================================================== + +class ServerErrorReceipt::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_stanzaid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +ServerErrorReceipt::ServerErrorReceipt(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.ServerErrorReceipt) +} +ServerErrorReceipt::ServerErrorReceipt(const ServerErrorReceipt& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + ServerErrorReceipt* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.stanzaid_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.stanzaid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.stanzaid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_stanzaid()) { + _this->_impl_.stanzaid_.Set(from._internal_stanzaid(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.ServerErrorReceipt) +} + +inline void ServerErrorReceipt::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.stanzaid_){} + }; + _impl_.stanzaid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.stanzaid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +ServerErrorReceipt::~ServerErrorReceipt() { + // @@protoc_insertion_point(destructor:proto.ServerErrorReceipt) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ServerErrorReceipt::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.stanzaid_.Destroy(); +} + +void ServerErrorReceipt::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void ServerErrorReceipt::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.ServerErrorReceipt) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.stanzaid_.ClearNonDefaultToEmpty(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ServerErrorReceipt::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string stanzaId = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_stanzaid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.ServerErrorReceipt.stanzaId"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ServerErrorReceipt::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.ServerErrorReceipt) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string stanzaId = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_stanzaid().data(), static_cast(this->_internal_stanzaid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.ServerErrorReceipt.stanzaId"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_stanzaid(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.ServerErrorReceipt) + return target; +} + +size_t ServerErrorReceipt::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.ServerErrorReceipt) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional string stanzaId = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_stanzaid()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ServerErrorReceipt::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + ServerErrorReceipt::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ServerErrorReceipt::GetClassData() const { return &_class_data_; } + + +void ServerErrorReceipt::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.ServerErrorReceipt) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_stanzaid()) { + _this->_internal_set_stanzaid(from._internal_stanzaid()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void ServerErrorReceipt::CopyFrom(const ServerErrorReceipt& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.ServerErrorReceipt) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ServerErrorReceipt::IsInitialized() const { + return true; +} + +void ServerErrorReceipt::InternalSwap(ServerErrorReceipt* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.stanzaid_, lhs_arena, + &other->_impl_.stanzaid_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ServerErrorReceipt::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[169]); +} + +// =================================================================== + +class SessionStructure::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_sessionversion(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_localidentitypublic(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_remoteidentitypublic(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_rootkey(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_previouscounter(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static const ::proto::Chain& senderchain(const SessionStructure* msg); + static void set_has_senderchain(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static const ::proto::PendingKeyExchange& pendingkeyexchange(const SessionStructure* msg); + static void set_has_pendingkeyexchange(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static const ::proto::PendingPreKey& pendingprekey(const SessionStructure* msg); + static void set_has_pendingprekey(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_remoteregistrationid(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_localregistrationid(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static void set_has_needsrefresh(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static void set_has_alicebasekey(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +const ::proto::Chain& +SessionStructure::_Internal::senderchain(const SessionStructure* msg) { + return *msg->_impl_.senderchain_; +} +const ::proto::PendingKeyExchange& +SessionStructure::_Internal::pendingkeyexchange(const SessionStructure* msg) { + return *msg->_impl_.pendingkeyexchange_; +} +const ::proto::PendingPreKey& +SessionStructure::_Internal::pendingprekey(const SessionStructure* msg) { + return *msg->_impl_.pendingprekey_; +} +SessionStructure::SessionStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SessionStructure) +} +SessionStructure::SessionStructure(const SessionStructure& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SessionStructure* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.receiverchains_){from._impl_.receiverchains_} + , decltype(_impl_.localidentitypublic_){} + , decltype(_impl_.remoteidentitypublic_){} + , decltype(_impl_.rootkey_){} + , decltype(_impl_.alicebasekey_){} + , decltype(_impl_.senderchain_){nullptr} + , decltype(_impl_.pendingkeyexchange_){nullptr} + , decltype(_impl_.pendingprekey_){nullptr} + , decltype(_impl_.sessionversion_){} + , decltype(_impl_.previouscounter_){} + , decltype(_impl_.remoteregistrationid_){} + , decltype(_impl_.localregistrationid_){} + , decltype(_impl_.needsrefresh_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.localidentitypublic_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.localidentitypublic_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_localidentitypublic()) { + _this->_impl_.localidentitypublic_.Set(from._internal_localidentitypublic(), + _this->GetArenaForAllocation()); + } + _impl_.remoteidentitypublic_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.remoteidentitypublic_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_remoteidentitypublic()) { + _this->_impl_.remoteidentitypublic_.Set(from._internal_remoteidentitypublic(), + _this->GetArenaForAllocation()); + } + _impl_.rootkey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.rootkey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_rootkey()) { + _this->_impl_.rootkey_.Set(from._internal_rootkey(), + _this->GetArenaForAllocation()); + } + _impl_.alicebasekey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.alicebasekey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_alicebasekey()) { + _this->_impl_.alicebasekey_.Set(from._internal_alicebasekey(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_senderchain()) { + _this->_impl_.senderchain_ = new ::proto::Chain(*from._impl_.senderchain_); + } + if (from._internal_has_pendingkeyexchange()) { + _this->_impl_.pendingkeyexchange_ = new ::proto::PendingKeyExchange(*from._impl_.pendingkeyexchange_); + } + if (from._internal_has_pendingprekey()) { + _this->_impl_.pendingprekey_ = new ::proto::PendingPreKey(*from._impl_.pendingprekey_); + } + ::memcpy(&_impl_.sessionversion_, &from._impl_.sessionversion_, + static_cast(reinterpret_cast(&_impl_.needsrefresh_) - + reinterpret_cast(&_impl_.sessionversion_)) + sizeof(_impl_.needsrefresh_)); + // @@protoc_insertion_point(copy_constructor:proto.SessionStructure) +} + +inline void SessionStructure::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.receiverchains_){arena} + , decltype(_impl_.localidentitypublic_){} + , decltype(_impl_.remoteidentitypublic_){} + , decltype(_impl_.rootkey_){} + , decltype(_impl_.alicebasekey_){} + , decltype(_impl_.senderchain_){nullptr} + , decltype(_impl_.pendingkeyexchange_){nullptr} + , decltype(_impl_.pendingprekey_){nullptr} + , decltype(_impl_.sessionversion_){0u} + , decltype(_impl_.previouscounter_){0u} + , decltype(_impl_.remoteregistrationid_){0u} + , decltype(_impl_.localregistrationid_){0u} + , decltype(_impl_.needsrefresh_){false} + }; + _impl_.localidentitypublic_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.localidentitypublic_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.remoteidentitypublic_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.remoteidentitypublic_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.rootkey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.rootkey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.alicebasekey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.alicebasekey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +SessionStructure::~SessionStructure() { + // @@protoc_insertion_point(destructor:proto.SessionStructure) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SessionStructure::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.receiverchains_.~RepeatedPtrField(); + _impl_.localidentitypublic_.Destroy(); + _impl_.remoteidentitypublic_.Destroy(); + _impl_.rootkey_.Destroy(); + _impl_.alicebasekey_.Destroy(); + if (this != internal_default_instance()) delete _impl_.senderchain_; + if (this != internal_default_instance()) delete _impl_.pendingkeyexchange_; + if (this != internal_default_instance()) delete _impl_.pendingprekey_; +} + +void SessionStructure::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SessionStructure::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SessionStructure) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.receiverchains_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + if (cached_has_bits & 0x00000001u) { + _impl_.localidentitypublic_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.remoteidentitypublic_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.rootkey_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + _impl_.alicebasekey_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + GOOGLE_DCHECK(_impl_.senderchain_ != nullptr); + _impl_.senderchain_->Clear(); + } + if (cached_has_bits & 0x00000020u) { + GOOGLE_DCHECK(_impl_.pendingkeyexchange_ != nullptr); + _impl_.pendingkeyexchange_->Clear(); + } + if (cached_has_bits & 0x00000040u) { + GOOGLE_DCHECK(_impl_.pendingprekey_ != nullptr); + _impl_.pendingprekey_->Clear(); + } + } + _impl_.sessionversion_ = 0u; + if (cached_has_bits & 0x00000f00u) { + ::memset(&_impl_.previouscounter_, 0, static_cast( + reinterpret_cast(&_impl_.needsrefresh_) - + reinterpret_cast(&_impl_.previouscounter_)) + sizeof(_impl_.needsrefresh_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SessionStructure::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint32 sessionVersion = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_sessionversion(&has_bits); + _impl_.sessionversion_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes localIdentityPublic = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_localidentitypublic(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes remoteIdentityPublic = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_remoteidentitypublic(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes rootKey = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_rootkey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 previousCounter = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_previouscounter(&has_bits); + _impl_.previouscounter_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Chain senderChain = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_senderchain(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .proto.Chain receiverChains = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_receiverchains(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<58>(ptr)); + } else + goto handle_unusual; + continue; + // optional .proto.PendingKeyExchange pendingKeyExchange = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + ptr = ctx->ParseMessage(_internal_mutable_pendingkeyexchange(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.PendingPreKey pendingPreKey = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + ptr = ctx->ParseMessage(_internal_mutable_pendingprekey(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 remoteRegistrationId = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { + _Internal::set_has_remoteregistrationid(&has_bits); + _impl_.remoteregistrationid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 localRegistrationId = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { + _Internal::set_has_localregistrationid(&has_bits); + _impl_.localregistrationid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool needsRefresh = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { + _Internal::set_has_needsrefresh(&has_bits); + _impl_.needsrefresh_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes aliceBaseKey = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { + auto str = _internal_mutable_alicebasekey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SessionStructure::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SessionStructure) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional uint32 sessionVersion = 1; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_sessionversion(), target); + } + + // optional bytes localIdentityPublic = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_localidentitypublic(), target); + } + + // optional bytes remoteIdentityPublic = 3; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 3, this->_internal_remoteidentitypublic(), target); + } + + // optional bytes rootKey = 4; + if (cached_has_bits & 0x00000004u) { + target = stream->WriteBytesMaybeAliased( + 4, this->_internal_rootkey(), target); + } + + // optional uint32 previousCounter = 5; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_previouscounter(), target); + } + + // optional .proto.Chain senderChain = 6; + if (cached_has_bits & 0x00000010u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(6, _Internal::senderchain(this), + _Internal::senderchain(this).GetCachedSize(), target, stream); + } + + // repeated .proto.Chain receiverChains = 7; + for (unsigned i = 0, + n = static_cast(this->_internal_receiverchains_size()); i < n; i++) { + const auto& repfield = this->_internal_receiverchains(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(7, repfield, repfield.GetCachedSize(), target, stream); + } + + // optional .proto.PendingKeyExchange pendingKeyExchange = 8; + if (cached_has_bits & 0x00000020u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(8, _Internal::pendingkeyexchange(this), + _Internal::pendingkeyexchange(this).GetCachedSize(), target, stream); + } + + // optional .proto.PendingPreKey pendingPreKey = 9; + if (cached_has_bits & 0x00000040u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(9, _Internal::pendingprekey(this), + _Internal::pendingprekey(this).GetCachedSize(), target, stream); + } + + // optional uint32 remoteRegistrationId = 10; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(10, this->_internal_remoteregistrationid(), target); + } + + // optional uint32 localRegistrationId = 11; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(11, this->_internal_localregistrationid(), target); + } + + // optional bool needsRefresh = 12; + if (cached_has_bits & 0x00000800u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(12, this->_internal_needsrefresh(), target); + } + + // optional bytes aliceBaseKey = 13; + if (cached_has_bits & 0x00000008u) { + target = stream->WriteBytesMaybeAliased( + 13, this->_internal_alicebasekey(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SessionStructure) + return target; +} + +size_t SessionStructure::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SessionStructure) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.Chain receiverChains = 7; + total_size += 1UL * this->_internal_receiverchains_size(); + for (const auto& msg : this->_impl_.receiverchains_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional bytes localIdentityPublic = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_localidentitypublic()); + } + + // optional bytes remoteIdentityPublic = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_remoteidentitypublic()); + } + + // optional bytes rootKey = 4; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_rootkey()); + } + + // optional bytes aliceBaseKey = 13; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_alicebasekey()); + } + + // optional .proto.Chain senderChain = 6; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.senderchain_); + } + + // optional .proto.PendingKeyExchange pendingKeyExchange = 8; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.pendingkeyexchange_); + } + + // optional .proto.PendingPreKey pendingPreKey = 9; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.pendingprekey_); + } + + // optional uint32 sessionVersion = 1; + if (cached_has_bits & 0x00000080u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_sessionversion()); + } + + } + if (cached_has_bits & 0x00000f00u) { + // optional uint32 previousCounter = 5; + if (cached_has_bits & 0x00000100u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_previouscounter()); + } + + // optional uint32 remoteRegistrationId = 10; + if (cached_has_bits & 0x00000200u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_remoteregistrationid()); + } + + // optional uint32 localRegistrationId = 11; + if (cached_has_bits & 0x00000400u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_localregistrationid()); + } + + // optional bool needsRefresh = 12; + if (cached_has_bits & 0x00000800u) { + total_size += 1 + 1; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SessionStructure::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SessionStructure::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SessionStructure::GetClassData() const { return &_class_data_; } + + +void SessionStructure::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SessionStructure) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.receiverchains_.MergeFrom(from._impl_.receiverchains_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_localidentitypublic(from._internal_localidentitypublic()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_remoteidentitypublic(from._internal_remoteidentitypublic()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_rootkey(from._internal_rootkey()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_set_alicebasekey(from._internal_alicebasekey()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_mutable_senderchain()->::proto::Chain::MergeFrom( + from._internal_senderchain()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_mutable_pendingkeyexchange()->::proto::PendingKeyExchange::MergeFrom( + from._internal_pendingkeyexchange()); + } + if (cached_has_bits & 0x00000040u) { + _this->_internal_mutable_pendingprekey()->::proto::PendingPreKey::MergeFrom( + from._internal_pendingprekey()); + } + if (cached_has_bits & 0x00000080u) { + _this->_impl_.sessionversion_ = from._impl_.sessionversion_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00000f00u) { + if (cached_has_bits & 0x00000100u) { + _this->_impl_.previouscounter_ = from._impl_.previouscounter_; + } + if (cached_has_bits & 0x00000200u) { + _this->_impl_.remoteregistrationid_ = from._impl_.remoteregistrationid_; + } + if (cached_has_bits & 0x00000400u) { + _this->_impl_.localregistrationid_ = from._impl_.localregistrationid_; + } + if (cached_has_bits & 0x00000800u) { + _this->_impl_.needsrefresh_ = from._impl_.needsrefresh_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SessionStructure::CopyFrom(const SessionStructure& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SessionStructure) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SessionStructure::IsInitialized() const { + return true; +} + +void SessionStructure::InternalSwap(SessionStructure* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.receiverchains_.InternalSwap(&other->_impl_.receiverchains_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.localidentitypublic_, lhs_arena, + &other->_impl_.localidentitypublic_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.remoteidentitypublic_, lhs_arena, + &other->_impl_.remoteidentitypublic_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.rootkey_, lhs_arena, + &other->_impl_.rootkey_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.alicebasekey_, lhs_arena, + &other->_impl_.alicebasekey_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SessionStructure, _impl_.needsrefresh_) + + sizeof(SessionStructure::_impl_.needsrefresh_) + - PROTOBUF_FIELD_OFFSET(SessionStructure, _impl_.senderchain_)>( + reinterpret_cast(&_impl_.senderchain_), + reinterpret_cast(&other->_impl_.senderchain_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SessionStructure::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[170]); +} + +// =================================================================== + +class SignedPreKeyRecordStructure::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_id(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_publickey(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_privatekey(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_signature(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_timestamp(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +SignedPreKeyRecordStructure::SignedPreKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SignedPreKeyRecordStructure) +} +SignedPreKeyRecordStructure::SignedPreKeyRecordStructure(const SignedPreKeyRecordStructure& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SignedPreKeyRecordStructure* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.publickey_){} + , decltype(_impl_.privatekey_){} + , decltype(_impl_.signature_){} + , decltype(_impl_.timestamp_){} + , decltype(_impl_.id_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.publickey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.publickey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_publickey()) { + _this->_impl_.publickey_.Set(from._internal_publickey(), + _this->GetArenaForAllocation()); + } + _impl_.privatekey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.privatekey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_privatekey()) { + _this->_impl_.privatekey_.Set(from._internal_privatekey(), + _this->GetArenaForAllocation()); + } + _impl_.signature_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.signature_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_signature()) { + _this->_impl_.signature_.Set(from._internal_signature(), + _this->GetArenaForAllocation()); + } + ::memcpy(&_impl_.timestamp_, &from._impl_.timestamp_, + static_cast(reinterpret_cast(&_impl_.id_) - + reinterpret_cast(&_impl_.timestamp_)) + sizeof(_impl_.id_)); + // @@protoc_insertion_point(copy_constructor:proto.SignedPreKeyRecordStructure) +} + +inline void SignedPreKeyRecordStructure::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.publickey_){} + , decltype(_impl_.privatekey_){} + , decltype(_impl_.signature_){} + , decltype(_impl_.timestamp_){uint64_t{0u}} + , decltype(_impl_.id_){0u} + }; + _impl_.publickey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.publickey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.privatekey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.privatekey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.signature_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.signature_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +SignedPreKeyRecordStructure::~SignedPreKeyRecordStructure() { + // @@protoc_insertion_point(destructor:proto.SignedPreKeyRecordStructure) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SignedPreKeyRecordStructure::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.publickey_.Destroy(); + _impl_.privatekey_.Destroy(); + _impl_.signature_.Destroy(); +} + +void SignedPreKeyRecordStructure::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SignedPreKeyRecordStructure::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SignedPreKeyRecordStructure) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _impl_.publickey_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.privatekey_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.signature_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x00000018u) { + ::memset(&_impl_.timestamp_, 0, static_cast( + reinterpret_cast(&_impl_.id_) - + reinterpret_cast(&_impl_.timestamp_)) + sizeof(_impl_.id_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SignedPreKeyRecordStructure::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint32 id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_id(&has_bits); + _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes publicKey = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_publickey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes privateKey = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_privatekey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes signature = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_signature(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional fixed64 timestamp = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 41)) { + _Internal::set_has_timestamp(&has_bits); + _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(uint64_t); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SignedPreKeyRecordStructure::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SignedPreKeyRecordStructure) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional uint32 id = 1; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_id(), target); + } + + // optional bytes publicKey = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_publickey(), target); + } + + // optional bytes privateKey = 3; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 3, this->_internal_privatekey(), target); + } + + // optional bytes signature = 4; + if (cached_has_bits & 0x00000004u) { + target = stream->WriteBytesMaybeAliased( + 4, this->_internal_signature(), target); + } + + // optional fixed64 timestamp = 5; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFixed64ToArray(5, this->_internal_timestamp(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SignedPreKeyRecordStructure) + return target; +} + +size_t SignedPreKeyRecordStructure::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SignedPreKeyRecordStructure) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + // optional bytes publicKey = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_publickey()); + } + + // optional bytes privateKey = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_privatekey()); + } + + // optional bytes signature = 4; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_signature()); + } + + // optional fixed64 timestamp = 5; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 8; + } + + // optional uint32 id = 1; + if (cached_has_bits & 0x00000010u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_id()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SignedPreKeyRecordStructure::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SignedPreKeyRecordStructure::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SignedPreKeyRecordStructure::GetClassData() const { return &_class_data_; } + + +void SignedPreKeyRecordStructure::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SignedPreKeyRecordStructure) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_publickey(from._internal_publickey()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_privatekey(from._internal_privatekey()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_signature(from._internal_signature()); + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.timestamp_ = from._impl_.timestamp_; + } + if (cached_has_bits & 0x00000010u) { + _this->_impl_.id_ = from._impl_.id_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SignedPreKeyRecordStructure::CopyFrom(const SignedPreKeyRecordStructure& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SignedPreKeyRecordStructure) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SignedPreKeyRecordStructure::IsInitialized() const { + return true; +} + +void SignedPreKeyRecordStructure::InternalSwap(SignedPreKeyRecordStructure* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.publickey_, lhs_arena, + &other->_impl_.publickey_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.privatekey_, lhs_arena, + &other->_impl_.privatekey_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.signature_, lhs_arena, + &other->_impl_.signature_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SignedPreKeyRecordStructure, _impl_.id_) + + sizeof(SignedPreKeyRecordStructure::_impl_.id_) + - PROTOBUF_FIELD_OFFSET(SignedPreKeyRecordStructure, _impl_.timestamp_)>( + reinterpret_cast(&_impl_.timestamp_), + reinterpret_cast(&other->_impl_.timestamp_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SignedPreKeyRecordStructure::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[171]); +} + +// =================================================================== + +class StatusPSA::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_campaignid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_campaignexpirationtimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0; + } +}; + +StatusPSA::StatusPSA(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.StatusPSA) +} +StatusPSA::StatusPSA(const StatusPSA& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + StatusPSA* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.campaignid_){} + , decltype(_impl_.campaignexpirationtimestamp_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&_impl_.campaignid_, &from._impl_.campaignid_, + static_cast(reinterpret_cast(&_impl_.campaignexpirationtimestamp_) - + reinterpret_cast(&_impl_.campaignid_)) + sizeof(_impl_.campaignexpirationtimestamp_)); + // @@protoc_insertion_point(copy_constructor:proto.StatusPSA) +} + +inline void StatusPSA::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.campaignid_){uint64_t{0u}} + , decltype(_impl_.campaignexpirationtimestamp_){uint64_t{0u}} + }; +} + +StatusPSA::~StatusPSA() { + // @@protoc_insertion_point(destructor:proto.StatusPSA) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void StatusPSA::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void StatusPSA::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void StatusPSA::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.StatusPSA) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + ::memset(&_impl_.campaignid_, 0, static_cast( + reinterpret_cast(&_impl_.campaignexpirationtimestamp_) - + reinterpret_cast(&_impl_.campaignid_)) + sizeof(_impl_.campaignexpirationtimestamp_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* StatusPSA::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // required uint64 campaignId = 44; + case 44: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { + _Internal::set_has_campaignid(&has_bits); + _impl_.campaignid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint64 campaignExpirationTimestamp = 45; + case 45: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 104)) { + _Internal::set_has_campaignexpirationtimestamp(&has_bits); + _impl_.campaignexpirationtimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* StatusPSA::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.StatusPSA) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // required uint64 campaignId = 44; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(44, this->_internal_campaignid(), target); + } + + // optional uint64 campaignExpirationTimestamp = 45; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(45, this->_internal_campaignexpirationtimestamp(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.StatusPSA) + return target; +} + +size_t StatusPSA::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.StatusPSA) + size_t total_size = 0; + + // required uint64 campaignId = 44; + if (_internal_has_campaignid()) { + total_size += 2 + + ::_pbi::WireFormatLite::UInt64Size( + this->_internal_campaignid()); + } + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional uint64 campaignExpirationTimestamp = 45; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000002u) { + total_size += 2 + + ::_pbi::WireFormatLite::UInt64Size( + this->_internal_campaignexpirationtimestamp()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData StatusPSA::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + StatusPSA::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*StatusPSA::GetClassData() const { return &_class_data_; } + + +void StatusPSA::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.StatusPSA) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_impl_.campaignid_ = from._impl_.campaignid_; + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.campaignexpirationtimestamp_ = from._impl_.campaignexpirationtimestamp_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void StatusPSA::CopyFrom(const StatusPSA& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.StatusPSA) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool StatusPSA::IsInitialized() const { + if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false; + return true; +} + +void StatusPSA::InternalSwap(StatusPSA* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(StatusPSA, _impl_.campaignexpirationtimestamp_) + + sizeof(StatusPSA::_impl_.campaignexpirationtimestamp_) + - PROTOBUF_FIELD_OFFSET(StatusPSA, _impl_.campaignid_)>( + reinterpret_cast(&_impl_.campaignid_), + reinterpret_cast(&other->_impl_.campaignid_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata StatusPSA::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[172]); +} + +// =================================================================== + +class StickerMetadata::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_url(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_filesha256(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_fileencsha256(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_mediakey(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_mimetype(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_height(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_width(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_directpath(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_filelength(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_weight(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } +}; + +StickerMetadata::StickerMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.StickerMetadata) +} +StickerMetadata::StickerMetadata(const StickerMetadata& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + StickerMetadata* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.url_){} + , decltype(_impl_.filesha256_){} + , decltype(_impl_.fileencsha256_){} + , decltype(_impl_.mediakey_){} + , decltype(_impl_.mimetype_){} + , decltype(_impl_.directpath_){} + , decltype(_impl_.height_){} + , decltype(_impl_.width_){} + , decltype(_impl_.filelength_){} + , decltype(_impl_.weight_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.url_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.url_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_url()) { + _this->_impl_.url_.Set(from._internal_url(), + _this->GetArenaForAllocation()); + } + _impl_.filesha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filesha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_filesha256()) { + _this->_impl_.filesha256_.Set(from._internal_filesha256(), + _this->GetArenaForAllocation()); + } + _impl_.fileencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_fileencsha256()) { + _this->_impl_.fileencsha256_.Set(from._internal_fileencsha256(), + _this->GetArenaForAllocation()); + } + _impl_.mediakey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediakey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_mediakey()) { + _this->_impl_.mediakey_.Set(from._internal_mediakey(), + _this->GetArenaForAllocation()); + } + _impl_.mimetype_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mimetype_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_mimetype()) { + _this->_impl_.mimetype_.Set(from._internal_mimetype(), + _this->GetArenaForAllocation()); + } + _impl_.directpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_directpath()) { + _this->_impl_.directpath_.Set(from._internal_directpath(), + _this->GetArenaForAllocation()); + } + ::memcpy(&_impl_.height_, &from._impl_.height_, + static_cast(reinterpret_cast(&_impl_.weight_) - + reinterpret_cast(&_impl_.height_)) + sizeof(_impl_.weight_)); + // @@protoc_insertion_point(copy_constructor:proto.StickerMetadata) +} + +inline void StickerMetadata::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.url_){} + , decltype(_impl_.filesha256_){} + , decltype(_impl_.fileencsha256_){} + , decltype(_impl_.mediakey_){} + , decltype(_impl_.mimetype_){} + , decltype(_impl_.directpath_){} + , decltype(_impl_.height_){0u} + , decltype(_impl_.width_){0u} + , decltype(_impl_.filelength_){uint64_t{0u}} + , decltype(_impl_.weight_){0} + }; + _impl_.url_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.url_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filesha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filesha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fileencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediakey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediakey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mimetype_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mimetype_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +StickerMetadata::~StickerMetadata() { + // @@protoc_insertion_point(destructor:proto.StickerMetadata) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void StickerMetadata::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.url_.Destroy(); + _impl_.filesha256_.Destroy(); + _impl_.fileencsha256_.Destroy(); + _impl_.mediakey_.Destroy(); + _impl_.mimetype_.Destroy(); + _impl_.directpath_.Destroy(); +} + +void StickerMetadata::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void StickerMetadata::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.StickerMetadata) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + _impl_.url_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.filesha256_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.fileencsha256_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + _impl_.mediakey_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + _impl_.mimetype_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000020u) { + _impl_.directpath_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x000000c0u) { + ::memset(&_impl_.height_, 0, static_cast( + reinterpret_cast(&_impl_.width_) - + reinterpret_cast(&_impl_.height_)) + sizeof(_impl_.width_)); + } + if (cached_has_bits & 0x00000300u) { + ::memset(&_impl_.filelength_, 0, static_cast( + reinterpret_cast(&_impl_.weight_) - + reinterpret_cast(&_impl_.filelength_)) + sizeof(_impl_.weight_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* StickerMetadata::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string url = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_url(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.StickerMetadata.url"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bytes fileSha256 = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_filesha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes fileEncSha256 = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_fileencsha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes mediaKey = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_mediakey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string mimetype = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + auto str = _internal_mutable_mimetype(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.StickerMetadata.mimetype"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional uint32 height = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + _Internal::set_has_height(&has_bits); + _impl_.height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 width = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + _Internal::set_has_width(&has_bits); + _impl_.width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string directPath = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + auto str = _internal_mutable_directpath(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.StickerMetadata.directPath"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional uint64 fileLength = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { + _Internal::set_has_filelength(&has_bits); + _impl_.filelength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional float weight = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 85)) { + _Internal::set_has_weight(&has_bits); + _impl_.weight_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* StickerMetadata::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.StickerMetadata) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string url = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_url().data(), static_cast(this->_internal_url().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.StickerMetadata.url"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_url(), target); + } + + // optional bytes fileSha256 = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_filesha256(), target); + } + + // optional bytes fileEncSha256 = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->WriteBytesMaybeAliased( + 3, this->_internal_fileencsha256(), target); + } + + // optional bytes mediaKey = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->WriteBytesMaybeAliased( + 4, this->_internal_mediakey(), target); + } + + // optional string mimetype = 5; + if (cached_has_bits & 0x00000010u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_mimetype().data(), static_cast(this->_internal_mimetype().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.StickerMetadata.mimetype"); + target = stream->WriteStringMaybeAliased( + 5, this->_internal_mimetype(), target); + } + + // optional uint32 height = 6; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_height(), target); + } + + // optional uint32 width = 7; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(7, this->_internal_width(), target); + } + + // optional string directPath = 8; + if (cached_has_bits & 0x00000020u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_directpath().data(), static_cast(this->_internal_directpath().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.StickerMetadata.directPath"); + target = stream->WriteStringMaybeAliased( + 8, this->_internal_directpath(), target); + } + + // optional uint64 fileLength = 9; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(9, this->_internal_filelength(), target); + } + + // optional float weight = 10; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFloatToArray(10, this->_internal_weight(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.StickerMetadata) + return target; +} + +size_t StickerMetadata::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.StickerMetadata) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string url = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_url()); + } + + // optional bytes fileSha256 = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_filesha256()); + } + + // optional bytes fileEncSha256 = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_fileencsha256()); + } + + // optional bytes mediaKey = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_mediakey()); + } + + // optional string mimetype = 5; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_mimetype()); + } + + // optional string directPath = 8; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_directpath()); + } + + // optional uint32 height = 6; + if (cached_has_bits & 0x00000040u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_height()); + } + + // optional uint32 width = 7; + if (cached_has_bits & 0x00000080u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_width()); + } + + } + if (cached_has_bits & 0x00000300u) { + // optional uint64 fileLength = 9; + if (cached_has_bits & 0x00000100u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_filelength()); + } + + // optional float weight = 10; + if (cached_has_bits & 0x00000200u) { + total_size += 1 + 4; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData StickerMetadata::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + StickerMetadata::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*StickerMetadata::GetClassData() const { return &_class_data_; } + + +void StickerMetadata::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.StickerMetadata) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_url(from._internal_url()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_filesha256(from._internal_filesha256()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_fileencsha256(from._internal_fileencsha256()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_set_mediakey(from._internal_mediakey()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_set_mimetype(from._internal_mimetype()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_set_directpath(from._internal_directpath()); + } + if (cached_has_bits & 0x00000040u) { + _this->_impl_.height_ = from._impl_.height_; + } + if (cached_has_bits & 0x00000080u) { + _this->_impl_.width_ = from._impl_.width_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00000300u) { + if (cached_has_bits & 0x00000100u) { + _this->_impl_.filelength_ = from._impl_.filelength_; + } + if (cached_has_bits & 0x00000200u) { + _this->_impl_.weight_ = from._impl_.weight_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void StickerMetadata::CopyFrom(const StickerMetadata& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.StickerMetadata) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool StickerMetadata::IsInitialized() const { + return true; +} + +void StickerMetadata::InternalSwap(StickerMetadata* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.url_, lhs_arena, + &other->_impl_.url_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.filesha256_, lhs_arena, + &other->_impl_.filesha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.fileencsha256_, lhs_arena, + &other->_impl_.fileencsha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.mediakey_, lhs_arena, + &other->_impl_.mediakey_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.mimetype_, lhs_arena, + &other->_impl_.mimetype_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.directpath_, lhs_arena, + &other->_impl_.directpath_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(StickerMetadata, _impl_.weight_) + + sizeof(StickerMetadata::_impl_.weight_) + - PROTOBUF_FIELD_OFFSET(StickerMetadata, _impl_.height_)>( + reinterpret_cast(&_impl_.height_), + reinterpret_cast(&other->_impl_.height_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata StickerMetadata::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[173]); +} + +// =================================================================== + +class SyncActionData::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_index(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::proto::SyncActionValue& value(const SyncActionData* msg); + static void set_has_value(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_padding(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_version(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +const ::proto::SyncActionValue& +SyncActionData::_Internal::value(const SyncActionData* msg) { + return *msg->_impl_.value_; +} +SyncActionData::SyncActionData(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncActionData) +} +SyncActionData::SyncActionData(const SyncActionData& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncActionData* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.index_){} + , decltype(_impl_.padding_){} + , decltype(_impl_.value_){nullptr} + , decltype(_impl_.version_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.index_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.index_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_index()) { + _this->_impl_.index_.Set(from._internal_index(), + _this->GetArenaForAllocation()); + } + _impl_.padding_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.padding_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_padding()) { + _this->_impl_.padding_.Set(from._internal_padding(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_value()) { + _this->_impl_.value_ = new ::proto::SyncActionValue(*from._impl_.value_); + } + _this->_impl_.version_ = from._impl_.version_; + // @@protoc_insertion_point(copy_constructor:proto.SyncActionData) +} + +inline void SyncActionData::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.index_){} + , decltype(_impl_.padding_){} + , decltype(_impl_.value_){nullptr} + , decltype(_impl_.version_){0} + }; + _impl_.index_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.index_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.padding_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.padding_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +SyncActionData::~SyncActionData() { + // @@protoc_insertion_point(destructor:proto.SyncActionData) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncActionData::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.index_.Destroy(); + _impl_.padding_.Destroy(); + if (this != internal_default_instance()) delete _impl_.value_; +} + +void SyncActionData::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncActionData::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncActionData) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _impl_.index_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.padding_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.value_ != nullptr); + _impl_.value_->Clear(); + } + } + _impl_.version_ = 0; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncActionData::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes index = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_index(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SyncActionValue value = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_value(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes padding = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_padding(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 version = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_version(&has_bits); + _impl_.version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncActionData::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionData) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes index = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_index(), target); + } + + // optional .proto.SyncActionValue value = 2; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::value(this), + _Internal::value(this).GetCachedSize(), target, stream); + } + + // optional bytes padding = 3; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 3, this->_internal_padding(), target); + } + + // optional int32 version = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_version(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionData) + return target; +} + +size_t SyncActionData::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionData) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional bytes index = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_index()); + } + + // optional bytes padding = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_padding()); + } + + // optional .proto.SyncActionValue value = 2; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.value_); + } + + // optional int32 version = 4; + if (cached_has_bits & 0x00000008u) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_version()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionData::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncActionData::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionData::GetClassData() const { return &_class_data_; } + + +void SyncActionData::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionData) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_index(from._internal_index()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_padding(from._internal_padding()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_value()->::proto::SyncActionValue::MergeFrom( + from._internal_value()); + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.version_ = from._impl_.version_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncActionData::CopyFrom(const SyncActionData& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncActionData::IsInitialized() const { + return true; +} + +void SyncActionData::InternalSwap(SyncActionData* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.index_, lhs_arena, + &other->_impl_.index_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.padding_, lhs_arena, + &other->_impl_.padding_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SyncActionData, _impl_.version_) + + sizeof(SyncActionData::_impl_.version_) + - PROTOBUF_FIELD_OFFSET(SyncActionData, _impl_.value_)>( + reinterpret_cast(&_impl_.value_), + reinterpret_cast(&other->_impl_.value_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncActionData::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[174]); +} + +// =================================================================== + +class SyncActionValue_AgentAction::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_name(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_deviceid(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_isdeleted(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +SyncActionValue_AgentAction::SyncActionValue_AgentAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.AgentAction) +} +SyncActionValue_AgentAction::SyncActionValue_AgentAction(const SyncActionValue_AgentAction& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncActionValue_AgentAction* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.name_){} + , decltype(_impl_.deviceid_){} + , decltype(_impl_.isdeleted_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.name_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.name_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_name()) { + _this->_impl_.name_.Set(from._internal_name(), + _this->GetArenaForAllocation()); + } + ::memcpy(&_impl_.deviceid_, &from._impl_.deviceid_, + static_cast(reinterpret_cast(&_impl_.isdeleted_) - + reinterpret_cast(&_impl_.deviceid_)) + sizeof(_impl_.isdeleted_)); + // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.AgentAction) +} + +inline void SyncActionValue_AgentAction::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.name_){} + , decltype(_impl_.deviceid_){0} + , decltype(_impl_.isdeleted_){false} + }; + _impl_.name_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.name_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +SyncActionValue_AgentAction::~SyncActionValue_AgentAction() { + // @@protoc_insertion_point(destructor:proto.SyncActionValue.AgentAction) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncActionValue_AgentAction::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.name_.Destroy(); +} + +void SyncActionValue_AgentAction::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncActionValue_AgentAction::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.AgentAction) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000006u) { + ::memset(&_impl_.deviceid_, 0, static_cast( + reinterpret_cast(&_impl_.isdeleted_) - + reinterpret_cast(&_impl_.deviceid_)) + sizeof(_impl_.isdeleted_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncActionValue_AgentAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_name(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.AgentAction.name"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional int32 deviceID = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_deviceid(&has_bits); + _impl_.deviceid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool isDeleted = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_isdeleted(&has_bits); + _impl_.isdeleted_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncActionValue_AgentAction::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.AgentAction) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string name = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.SyncActionValue.AgentAction.name"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_name(), target); + } + + // optional int32 deviceID = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_deviceid(), target); + } + + // optional bool isDeleted = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_isdeleted(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.AgentAction) + return target; +} + +size_t SyncActionValue_AgentAction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.AgentAction) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional string name = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // optional int32 deviceID = 2; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_deviceid()); + } + + // optional bool isDeleted = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 1; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_AgentAction::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncActionValue_AgentAction::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_AgentAction::GetClassData() const { return &_class_data_; } + + +void SyncActionValue_AgentAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.AgentAction) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_name(from._internal_name()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.deviceid_ = from._impl_.deviceid_; + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.isdeleted_ = from._impl_.isdeleted_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncActionValue_AgentAction::CopyFrom(const SyncActionValue_AgentAction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.AgentAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncActionValue_AgentAction::IsInitialized() const { + return true; +} + +void SyncActionValue_AgentAction::InternalSwap(SyncActionValue_AgentAction* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.name_, lhs_arena, + &other->_impl_.name_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SyncActionValue_AgentAction, _impl_.isdeleted_) + + sizeof(SyncActionValue_AgentAction::_impl_.isdeleted_) + - PROTOBUF_FIELD_OFFSET(SyncActionValue_AgentAction, _impl_.deviceid_)>( + reinterpret_cast(&_impl_.deviceid_), + reinterpret_cast(&other->_impl_.deviceid_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_AgentAction::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[175]); +} + +// =================================================================== + +class SyncActionValue_AndroidUnsupportedActions::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_allowed(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +SyncActionValue_AndroidUnsupportedActions::SyncActionValue_AndroidUnsupportedActions(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.AndroidUnsupportedActions) +} +SyncActionValue_AndroidUnsupportedActions::SyncActionValue_AndroidUnsupportedActions(const SyncActionValue_AndroidUnsupportedActions& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncActionValue_AndroidUnsupportedActions* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.allowed_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _this->_impl_.allowed_ = from._impl_.allowed_; + // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.AndroidUnsupportedActions) +} + +inline void SyncActionValue_AndroidUnsupportedActions::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.allowed_){false} + }; +} + +SyncActionValue_AndroidUnsupportedActions::~SyncActionValue_AndroidUnsupportedActions() { + // @@protoc_insertion_point(destructor:proto.SyncActionValue.AndroidUnsupportedActions) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncActionValue_AndroidUnsupportedActions::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void SyncActionValue_AndroidUnsupportedActions::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncActionValue_AndroidUnsupportedActions::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.AndroidUnsupportedActions) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.allowed_ = false; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncActionValue_AndroidUnsupportedActions::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bool allowed = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_allowed(&has_bits); + _impl_.allowed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncActionValue_AndroidUnsupportedActions::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.AndroidUnsupportedActions) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bool allowed = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_allowed(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.AndroidUnsupportedActions) + return target; +} + +size_t SyncActionValue_AndroidUnsupportedActions::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.AndroidUnsupportedActions) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional bool allowed = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 1; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_AndroidUnsupportedActions::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncActionValue_AndroidUnsupportedActions::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_AndroidUnsupportedActions::GetClassData() const { return &_class_data_; } + + +void SyncActionValue_AndroidUnsupportedActions::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.AndroidUnsupportedActions) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_allowed()) { + _this->_internal_set_allowed(from._internal_allowed()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncActionValue_AndroidUnsupportedActions::CopyFrom(const SyncActionValue_AndroidUnsupportedActions& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.AndroidUnsupportedActions) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncActionValue_AndroidUnsupportedActions::IsInitialized() const { + return true; +} + +void SyncActionValue_AndroidUnsupportedActions::InternalSwap(SyncActionValue_AndroidUnsupportedActions* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_.allowed_, other->_impl_.allowed_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_AndroidUnsupportedActions::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[176]); +} + +// =================================================================== + +class SyncActionValue_ArchiveChatAction::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_archived(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::proto::SyncActionValue_SyncActionMessageRange& messagerange(const SyncActionValue_ArchiveChatAction* msg); + static void set_has_messagerange(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +const ::proto::SyncActionValue_SyncActionMessageRange& +SyncActionValue_ArchiveChatAction::_Internal::messagerange(const SyncActionValue_ArchiveChatAction* msg) { + return *msg->_impl_.messagerange_; +} +SyncActionValue_ArchiveChatAction::SyncActionValue_ArchiveChatAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.ArchiveChatAction) +} +SyncActionValue_ArchiveChatAction::SyncActionValue_ArchiveChatAction(const SyncActionValue_ArchiveChatAction& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncActionValue_ArchiveChatAction* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.messagerange_){nullptr} + , decltype(_impl_.archived_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_messagerange()) { + _this->_impl_.messagerange_ = new ::proto::SyncActionValue_SyncActionMessageRange(*from._impl_.messagerange_); + } + _this->_impl_.archived_ = from._impl_.archived_; + // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.ArchiveChatAction) +} + +inline void SyncActionValue_ArchiveChatAction::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.messagerange_){nullptr} + , decltype(_impl_.archived_){false} + }; +} + +SyncActionValue_ArchiveChatAction::~SyncActionValue_ArchiveChatAction() { + // @@protoc_insertion_point(destructor:proto.SyncActionValue.ArchiveChatAction) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncActionValue_ArchiveChatAction::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.messagerange_; +} + +void SyncActionValue_ArchiveChatAction::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncActionValue_ArchiveChatAction::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.ArchiveChatAction) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.messagerange_ != nullptr); + _impl_.messagerange_->Clear(); + } + _impl_.archived_ = false; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncActionValue_ArchiveChatAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bool archived = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_archived(&has_bits); + _impl_.archived_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_messagerange(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncActionValue_ArchiveChatAction::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.ArchiveChatAction) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bool archived = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_archived(), target); + } + + // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::messagerange(this), + _Internal::messagerange(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.ArchiveChatAction) + return target; +} + +size_t SyncActionValue_ArchiveChatAction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.ArchiveChatAction) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.messagerange_); + } + + // optional bool archived = 1; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 1; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_ArchiveChatAction::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncActionValue_ArchiveChatAction::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_ArchiveChatAction::GetClassData() const { return &_class_data_; } + + +void SyncActionValue_ArchiveChatAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.ArchiveChatAction) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_messagerange()->::proto::SyncActionValue_SyncActionMessageRange::MergeFrom( + from._internal_messagerange()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.archived_ = from._impl_.archived_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncActionValue_ArchiveChatAction::CopyFrom(const SyncActionValue_ArchiveChatAction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.ArchiveChatAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncActionValue_ArchiveChatAction::IsInitialized() const { + return true; +} + +void SyncActionValue_ArchiveChatAction::InternalSwap(SyncActionValue_ArchiveChatAction* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SyncActionValue_ArchiveChatAction, _impl_.archived_) + + sizeof(SyncActionValue_ArchiveChatAction::_impl_.archived_) + - PROTOBUF_FIELD_OFFSET(SyncActionValue_ArchiveChatAction, _impl_.messagerange_)>( + reinterpret_cast(&_impl_.messagerange_), + reinterpret_cast(&other->_impl_.messagerange_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_ArchiveChatAction::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[177]); +} + +// =================================================================== + +class SyncActionValue_ClearChatAction::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::SyncActionValue_SyncActionMessageRange& messagerange(const SyncActionValue_ClearChatAction* msg); + static void set_has_messagerange(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +const ::proto::SyncActionValue_SyncActionMessageRange& +SyncActionValue_ClearChatAction::_Internal::messagerange(const SyncActionValue_ClearChatAction* msg) { + return *msg->_impl_.messagerange_; +} +SyncActionValue_ClearChatAction::SyncActionValue_ClearChatAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.ClearChatAction) +} +SyncActionValue_ClearChatAction::SyncActionValue_ClearChatAction(const SyncActionValue_ClearChatAction& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncActionValue_ClearChatAction* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.messagerange_){nullptr}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_messagerange()) { + _this->_impl_.messagerange_ = new ::proto::SyncActionValue_SyncActionMessageRange(*from._impl_.messagerange_); + } + // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.ClearChatAction) +} + +inline void SyncActionValue_ClearChatAction::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.messagerange_){nullptr} + }; +} + +SyncActionValue_ClearChatAction::~SyncActionValue_ClearChatAction() { + // @@protoc_insertion_point(destructor:proto.SyncActionValue.ClearChatAction) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncActionValue_ClearChatAction::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.messagerange_; +} + +void SyncActionValue_ClearChatAction::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncActionValue_ClearChatAction::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.ClearChatAction) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.messagerange_ != nullptr); + _impl_.messagerange_->Clear(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncActionValue_ClearChatAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_messagerange(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncActionValue_ClearChatAction::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.ClearChatAction) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::messagerange(this), + _Internal::messagerange(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.ClearChatAction) + return target; +} + +size_t SyncActionValue_ClearChatAction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.ClearChatAction) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.messagerange_); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_ClearChatAction::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncActionValue_ClearChatAction::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_ClearChatAction::GetClassData() const { return &_class_data_; } + + +void SyncActionValue_ClearChatAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.ClearChatAction) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_messagerange()) { + _this->_internal_mutable_messagerange()->::proto::SyncActionValue_SyncActionMessageRange::MergeFrom( + from._internal_messagerange()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncActionValue_ClearChatAction::CopyFrom(const SyncActionValue_ClearChatAction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.ClearChatAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncActionValue_ClearChatAction::IsInitialized() const { + return true; +} + +void SyncActionValue_ClearChatAction::InternalSwap(SyncActionValue_ClearChatAction* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_.messagerange_, other->_impl_.messagerange_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_ClearChatAction::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[178]); +} + +// =================================================================== + +class SyncActionValue_ContactAction::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_fullname(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_firstname(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +SyncActionValue_ContactAction::SyncActionValue_ContactAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.ContactAction) +} +SyncActionValue_ContactAction::SyncActionValue_ContactAction(const SyncActionValue_ContactAction& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncActionValue_ContactAction* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.fullname_){} + , decltype(_impl_.firstname_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.fullname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fullname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_fullname()) { + _this->_impl_.fullname_.Set(from._internal_fullname(), + _this->GetArenaForAllocation()); + } + _impl_.firstname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.firstname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_firstname()) { + _this->_impl_.firstname_.Set(from._internal_firstname(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.ContactAction) +} + +inline void SyncActionValue_ContactAction::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.fullname_){} + , decltype(_impl_.firstname_){} + }; + _impl_.fullname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fullname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.firstname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.firstname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +SyncActionValue_ContactAction::~SyncActionValue_ContactAction() { + // @@protoc_insertion_point(destructor:proto.SyncActionValue.ContactAction) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncActionValue_ContactAction::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.fullname_.Destroy(); + _impl_.firstname_.Destroy(); +} + +void SyncActionValue_ContactAction::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncActionValue_ContactAction::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.ContactAction) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.fullname_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.firstname_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncActionValue_ContactAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string fullName = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_fullname(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.ContactAction.fullName"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string firstName = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_firstname(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.ContactAction.firstName"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncActionValue_ContactAction::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.ContactAction) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string fullName = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_fullname().data(), static_cast(this->_internal_fullname().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.SyncActionValue.ContactAction.fullName"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_fullname(), target); + } + + // optional string firstName = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_firstname().data(), static_cast(this->_internal_firstname().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.SyncActionValue.ContactAction.firstName"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_firstname(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.ContactAction) + return target; +} + +size_t SyncActionValue_ContactAction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.ContactAction) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional string fullName = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_fullname()); + } + + // optional string firstName = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_firstname()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_ContactAction::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncActionValue_ContactAction::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_ContactAction::GetClassData() const { return &_class_data_; } + + +void SyncActionValue_ContactAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.ContactAction) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_fullname(from._internal_fullname()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_firstname(from._internal_firstname()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncActionValue_ContactAction::CopyFrom(const SyncActionValue_ContactAction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.ContactAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncActionValue_ContactAction::IsInitialized() const { + return true; +} + +void SyncActionValue_ContactAction::InternalSwap(SyncActionValue_ContactAction* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.fullname_, lhs_arena, + &other->_impl_.fullname_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.firstname_, lhs_arena, + &other->_impl_.firstname_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_ContactAction::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[179]); +} + +// =================================================================== + +class SyncActionValue_DeleteChatAction::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::SyncActionValue_SyncActionMessageRange& messagerange(const SyncActionValue_DeleteChatAction* msg); + static void set_has_messagerange(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +const ::proto::SyncActionValue_SyncActionMessageRange& +SyncActionValue_DeleteChatAction::_Internal::messagerange(const SyncActionValue_DeleteChatAction* msg) { + return *msg->_impl_.messagerange_; +} +SyncActionValue_DeleteChatAction::SyncActionValue_DeleteChatAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.DeleteChatAction) +} +SyncActionValue_DeleteChatAction::SyncActionValue_DeleteChatAction(const SyncActionValue_DeleteChatAction& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncActionValue_DeleteChatAction* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.messagerange_){nullptr}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_messagerange()) { + _this->_impl_.messagerange_ = new ::proto::SyncActionValue_SyncActionMessageRange(*from._impl_.messagerange_); + } + // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.DeleteChatAction) +} + +inline void SyncActionValue_DeleteChatAction::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.messagerange_){nullptr} + }; +} + +SyncActionValue_DeleteChatAction::~SyncActionValue_DeleteChatAction() { + // @@protoc_insertion_point(destructor:proto.SyncActionValue.DeleteChatAction) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncActionValue_DeleteChatAction::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.messagerange_; +} + +void SyncActionValue_DeleteChatAction::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncActionValue_DeleteChatAction::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.DeleteChatAction) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.messagerange_ != nullptr); + _impl_.messagerange_->Clear(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncActionValue_DeleteChatAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_messagerange(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncActionValue_DeleteChatAction::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.DeleteChatAction) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::messagerange(this), + _Internal::messagerange(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.DeleteChatAction) + return target; +} + +size_t SyncActionValue_DeleteChatAction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.DeleteChatAction) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.messagerange_); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_DeleteChatAction::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncActionValue_DeleteChatAction::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_DeleteChatAction::GetClassData() const { return &_class_data_; } + + +void SyncActionValue_DeleteChatAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.DeleteChatAction) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_messagerange()) { + _this->_internal_mutable_messagerange()->::proto::SyncActionValue_SyncActionMessageRange::MergeFrom( + from._internal_messagerange()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncActionValue_DeleteChatAction::CopyFrom(const SyncActionValue_DeleteChatAction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.DeleteChatAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncActionValue_DeleteChatAction::IsInitialized() const { + return true; +} + +void SyncActionValue_DeleteChatAction::InternalSwap(SyncActionValue_DeleteChatAction* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_.messagerange_, other->_impl_.messagerange_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_DeleteChatAction::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[180]); +} + +// =================================================================== + +class SyncActionValue_DeleteMessageForMeAction::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_deletemedia(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_messagetimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +SyncActionValue_DeleteMessageForMeAction::SyncActionValue_DeleteMessageForMeAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.DeleteMessageForMeAction) +} +SyncActionValue_DeleteMessageForMeAction::SyncActionValue_DeleteMessageForMeAction(const SyncActionValue_DeleteMessageForMeAction& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncActionValue_DeleteMessageForMeAction* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.messagetimestamp_){} + , decltype(_impl_.deletemedia_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&_impl_.messagetimestamp_, &from._impl_.messagetimestamp_, + static_cast(reinterpret_cast(&_impl_.deletemedia_) - + reinterpret_cast(&_impl_.messagetimestamp_)) + sizeof(_impl_.deletemedia_)); + // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.DeleteMessageForMeAction) +} + +inline void SyncActionValue_DeleteMessageForMeAction::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.messagetimestamp_){int64_t{0}} + , decltype(_impl_.deletemedia_){false} + }; +} + +SyncActionValue_DeleteMessageForMeAction::~SyncActionValue_DeleteMessageForMeAction() { + // @@protoc_insertion_point(destructor:proto.SyncActionValue.DeleteMessageForMeAction) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncActionValue_DeleteMessageForMeAction::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void SyncActionValue_DeleteMessageForMeAction::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncActionValue_DeleteMessageForMeAction::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.DeleteMessageForMeAction) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + ::memset(&_impl_.messagetimestamp_, 0, static_cast( + reinterpret_cast(&_impl_.deletemedia_) - + reinterpret_cast(&_impl_.messagetimestamp_)) + sizeof(_impl_.deletemedia_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncActionValue_DeleteMessageForMeAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bool deleteMedia = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_deletemedia(&has_bits); + _impl_.deletemedia_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 messageTimestamp = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_messagetimestamp(&has_bits); + _impl_.messagetimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncActionValue_DeleteMessageForMeAction::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.DeleteMessageForMeAction) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bool deleteMedia = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_deletemedia(), target); + } + + // optional int64 messageTimestamp = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_messagetimestamp(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.DeleteMessageForMeAction) + return target; +} + +size_t SyncActionValue_DeleteMessageForMeAction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.DeleteMessageForMeAction) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional int64 messageTimestamp = 2; + if (cached_has_bits & 0x00000001u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_messagetimestamp()); + } + + // optional bool deleteMedia = 1; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 1; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_DeleteMessageForMeAction::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncActionValue_DeleteMessageForMeAction::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_DeleteMessageForMeAction::GetClassData() const { return &_class_data_; } + + +void SyncActionValue_DeleteMessageForMeAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.DeleteMessageForMeAction) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_impl_.messagetimestamp_ = from._impl_.messagetimestamp_; + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.deletemedia_ = from._impl_.deletemedia_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncActionValue_DeleteMessageForMeAction::CopyFrom(const SyncActionValue_DeleteMessageForMeAction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.DeleteMessageForMeAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncActionValue_DeleteMessageForMeAction::IsInitialized() const { + return true; +} + +void SyncActionValue_DeleteMessageForMeAction::InternalSwap(SyncActionValue_DeleteMessageForMeAction* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SyncActionValue_DeleteMessageForMeAction, _impl_.deletemedia_) + + sizeof(SyncActionValue_DeleteMessageForMeAction::_impl_.deletemedia_) + - PROTOBUF_FIELD_OFFSET(SyncActionValue_DeleteMessageForMeAction, _impl_.messagetimestamp_)>( + reinterpret_cast(&_impl_.messagetimestamp_), + reinterpret_cast(&other->_impl_.messagetimestamp_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_DeleteMessageForMeAction::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[181]); +} + +// =================================================================== + +class SyncActionValue_KeyExpiration::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_expiredkeyepoch(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +SyncActionValue_KeyExpiration::SyncActionValue_KeyExpiration(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.KeyExpiration) +} +SyncActionValue_KeyExpiration::SyncActionValue_KeyExpiration(const SyncActionValue_KeyExpiration& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncActionValue_KeyExpiration* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.expiredkeyepoch_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _this->_impl_.expiredkeyepoch_ = from._impl_.expiredkeyepoch_; + // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.KeyExpiration) +} + +inline void SyncActionValue_KeyExpiration::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.expiredkeyepoch_){0} + }; +} + +SyncActionValue_KeyExpiration::~SyncActionValue_KeyExpiration() { + // @@protoc_insertion_point(destructor:proto.SyncActionValue.KeyExpiration) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncActionValue_KeyExpiration::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void SyncActionValue_KeyExpiration::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncActionValue_KeyExpiration::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.KeyExpiration) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.expiredkeyepoch_ = 0; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncActionValue_KeyExpiration::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional int32 expiredKeyEpoch = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_expiredkeyepoch(&has_bits); + _impl_.expiredkeyepoch_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncActionValue_KeyExpiration::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.KeyExpiration) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional int32 expiredKeyEpoch = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_expiredkeyepoch(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.KeyExpiration) + return target; +} + +size_t SyncActionValue_KeyExpiration::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.KeyExpiration) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional int32 expiredKeyEpoch = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_expiredkeyepoch()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_KeyExpiration::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncActionValue_KeyExpiration::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_KeyExpiration::GetClassData() const { return &_class_data_; } + + +void SyncActionValue_KeyExpiration::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.KeyExpiration) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_expiredkeyepoch()) { + _this->_internal_set_expiredkeyepoch(from._internal_expiredkeyepoch()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncActionValue_KeyExpiration::CopyFrom(const SyncActionValue_KeyExpiration& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.KeyExpiration) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncActionValue_KeyExpiration::IsInitialized() const { + return true; +} + +void SyncActionValue_KeyExpiration::InternalSwap(SyncActionValue_KeyExpiration* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_.expiredkeyepoch_, other->_impl_.expiredkeyepoch_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_KeyExpiration::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[182]); +} + +// =================================================================== + +class SyncActionValue_LabelAssociationAction::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_labeled(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +SyncActionValue_LabelAssociationAction::SyncActionValue_LabelAssociationAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.LabelAssociationAction) +} +SyncActionValue_LabelAssociationAction::SyncActionValue_LabelAssociationAction(const SyncActionValue_LabelAssociationAction& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncActionValue_LabelAssociationAction* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.labeled_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _this->_impl_.labeled_ = from._impl_.labeled_; + // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.LabelAssociationAction) +} + +inline void SyncActionValue_LabelAssociationAction::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.labeled_){false} + }; +} + +SyncActionValue_LabelAssociationAction::~SyncActionValue_LabelAssociationAction() { + // @@protoc_insertion_point(destructor:proto.SyncActionValue.LabelAssociationAction) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncActionValue_LabelAssociationAction::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void SyncActionValue_LabelAssociationAction::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncActionValue_LabelAssociationAction::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.LabelAssociationAction) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.labeled_ = false; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncActionValue_LabelAssociationAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bool labeled = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_labeled(&has_bits); + _impl_.labeled_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncActionValue_LabelAssociationAction::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.LabelAssociationAction) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bool labeled = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_labeled(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.LabelAssociationAction) + return target; +} + +size_t SyncActionValue_LabelAssociationAction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.LabelAssociationAction) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional bool labeled = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 1; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_LabelAssociationAction::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncActionValue_LabelAssociationAction::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_LabelAssociationAction::GetClassData() const { return &_class_data_; } + + +void SyncActionValue_LabelAssociationAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.LabelAssociationAction) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_labeled()) { + _this->_internal_set_labeled(from._internal_labeled()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncActionValue_LabelAssociationAction::CopyFrom(const SyncActionValue_LabelAssociationAction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.LabelAssociationAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncActionValue_LabelAssociationAction::IsInitialized() const { + return true; +} + +void SyncActionValue_LabelAssociationAction::InternalSwap(SyncActionValue_LabelAssociationAction* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_.labeled_, other->_impl_.labeled_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_LabelAssociationAction::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[183]); +} + +// =================================================================== + +class SyncActionValue_LabelEditAction::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_name(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_color(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_predefinedid(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_deleted(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +SyncActionValue_LabelEditAction::SyncActionValue_LabelEditAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.LabelEditAction) +} +SyncActionValue_LabelEditAction::SyncActionValue_LabelEditAction(const SyncActionValue_LabelEditAction& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncActionValue_LabelEditAction* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.name_){} + , decltype(_impl_.color_){} + , decltype(_impl_.predefinedid_){} + , decltype(_impl_.deleted_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.name_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.name_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_name()) { + _this->_impl_.name_.Set(from._internal_name(), + _this->GetArenaForAllocation()); + } + ::memcpy(&_impl_.color_, &from._impl_.color_, + static_cast(reinterpret_cast(&_impl_.deleted_) - + reinterpret_cast(&_impl_.color_)) + sizeof(_impl_.deleted_)); + // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.LabelEditAction) +} + +inline void SyncActionValue_LabelEditAction::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.name_){} + , decltype(_impl_.color_){0} + , decltype(_impl_.predefinedid_){0} + , decltype(_impl_.deleted_){false} + }; + _impl_.name_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.name_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +SyncActionValue_LabelEditAction::~SyncActionValue_LabelEditAction() { + // @@protoc_insertion_point(destructor:proto.SyncActionValue.LabelEditAction) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncActionValue_LabelEditAction::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.name_.Destroy(); +} + +void SyncActionValue_LabelEditAction::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncActionValue_LabelEditAction::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.LabelEditAction) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x0000000eu) { + ::memset(&_impl_.color_, 0, static_cast( + reinterpret_cast(&_impl_.deleted_) - + reinterpret_cast(&_impl_.color_)) + sizeof(_impl_.deleted_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncActionValue_LabelEditAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_name(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.LabelEditAction.name"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional int32 color = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_color(&has_bits); + _impl_.color_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 predefinedId = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_predefinedid(&has_bits); + _impl_.predefinedid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool deleted = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_deleted(&has_bits); + _impl_.deleted_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncActionValue_LabelEditAction::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.LabelEditAction) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string name = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.SyncActionValue.LabelEditAction.name"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_name(), target); + } + + // optional int32 color = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_color(), target); + } + + // optional int32 predefinedId = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_predefinedid(), target); + } + + // optional bool deleted = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(4, this->_internal_deleted(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.LabelEditAction) + return target; +} + +size_t SyncActionValue_LabelEditAction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.LabelEditAction) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional string name = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // optional int32 color = 2; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_color()); + } + + // optional int32 predefinedId = 3; + if (cached_has_bits & 0x00000004u) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_predefinedid()); + } + + // optional bool deleted = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 1; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_LabelEditAction::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncActionValue_LabelEditAction::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_LabelEditAction::GetClassData() const { return &_class_data_; } + + +void SyncActionValue_LabelEditAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.LabelEditAction) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_name(from._internal_name()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.color_ = from._impl_.color_; + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.predefinedid_ = from._impl_.predefinedid_; + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.deleted_ = from._impl_.deleted_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncActionValue_LabelEditAction::CopyFrom(const SyncActionValue_LabelEditAction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.LabelEditAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncActionValue_LabelEditAction::IsInitialized() const { + return true; +} + +void SyncActionValue_LabelEditAction::InternalSwap(SyncActionValue_LabelEditAction* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.name_, lhs_arena, + &other->_impl_.name_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SyncActionValue_LabelEditAction, _impl_.deleted_) + + sizeof(SyncActionValue_LabelEditAction::_impl_.deleted_) + - PROTOBUF_FIELD_OFFSET(SyncActionValue_LabelEditAction, _impl_.color_)>( + reinterpret_cast(&_impl_.color_), + reinterpret_cast(&other->_impl_.color_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_LabelEditAction::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[184]); +} + +// =================================================================== + +class SyncActionValue_LocaleSetting::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_locale(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +SyncActionValue_LocaleSetting::SyncActionValue_LocaleSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.LocaleSetting) +} +SyncActionValue_LocaleSetting::SyncActionValue_LocaleSetting(const SyncActionValue_LocaleSetting& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncActionValue_LocaleSetting* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.locale_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.locale_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.locale_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_locale()) { + _this->_impl_.locale_.Set(from._internal_locale(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.LocaleSetting) +} + +inline void SyncActionValue_LocaleSetting::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.locale_){} + }; + _impl_.locale_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.locale_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +SyncActionValue_LocaleSetting::~SyncActionValue_LocaleSetting() { + // @@protoc_insertion_point(destructor:proto.SyncActionValue.LocaleSetting) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncActionValue_LocaleSetting::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.locale_.Destroy(); +} + +void SyncActionValue_LocaleSetting::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncActionValue_LocaleSetting::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.LocaleSetting) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.locale_.ClearNonDefaultToEmpty(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncActionValue_LocaleSetting::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string locale = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_locale(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.LocaleSetting.locale"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncActionValue_LocaleSetting::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.LocaleSetting) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string locale = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_locale().data(), static_cast(this->_internal_locale().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.SyncActionValue.LocaleSetting.locale"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_locale(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.LocaleSetting) + return target; +} + +size_t SyncActionValue_LocaleSetting::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.LocaleSetting) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional string locale = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_locale()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_LocaleSetting::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncActionValue_LocaleSetting::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_LocaleSetting::GetClassData() const { return &_class_data_; } + + +void SyncActionValue_LocaleSetting::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.LocaleSetting) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_locale()) { + _this->_internal_set_locale(from._internal_locale()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncActionValue_LocaleSetting::CopyFrom(const SyncActionValue_LocaleSetting& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.LocaleSetting) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncActionValue_LocaleSetting::IsInitialized() const { + return true; +} + +void SyncActionValue_LocaleSetting::InternalSwap(SyncActionValue_LocaleSetting* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.locale_, lhs_arena, + &other->_impl_.locale_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_LocaleSetting::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[185]); +} + +// =================================================================== + +class SyncActionValue_MarkChatAsReadAction::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_read(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::proto::SyncActionValue_SyncActionMessageRange& messagerange(const SyncActionValue_MarkChatAsReadAction* msg); + static void set_has_messagerange(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +const ::proto::SyncActionValue_SyncActionMessageRange& +SyncActionValue_MarkChatAsReadAction::_Internal::messagerange(const SyncActionValue_MarkChatAsReadAction* msg) { + return *msg->_impl_.messagerange_; +} +SyncActionValue_MarkChatAsReadAction::SyncActionValue_MarkChatAsReadAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.MarkChatAsReadAction) +} +SyncActionValue_MarkChatAsReadAction::SyncActionValue_MarkChatAsReadAction(const SyncActionValue_MarkChatAsReadAction& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncActionValue_MarkChatAsReadAction* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.messagerange_){nullptr} + , decltype(_impl_.read_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_messagerange()) { + _this->_impl_.messagerange_ = new ::proto::SyncActionValue_SyncActionMessageRange(*from._impl_.messagerange_); + } + _this->_impl_.read_ = from._impl_.read_; + // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.MarkChatAsReadAction) +} + +inline void SyncActionValue_MarkChatAsReadAction::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.messagerange_){nullptr} + , decltype(_impl_.read_){false} + }; +} + +SyncActionValue_MarkChatAsReadAction::~SyncActionValue_MarkChatAsReadAction() { + // @@protoc_insertion_point(destructor:proto.SyncActionValue.MarkChatAsReadAction) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncActionValue_MarkChatAsReadAction::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.messagerange_; +} + +void SyncActionValue_MarkChatAsReadAction::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncActionValue_MarkChatAsReadAction::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.MarkChatAsReadAction) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.messagerange_ != nullptr); + _impl_.messagerange_->Clear(); + } + _impl_.read_ = false; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncActionValue_MarkChatAsReadAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bool read = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_read(&has_bits); + _impl_.read_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_messagerange(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncActionValue_MarkChatAsReadAction::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.MarkChatAsReadAction) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bool read = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_read(), target); + } + + // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::messagerange(this), + _Internal::messagerange(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.MarkChatAsReadAction) + return target; +} + +size_t SyncActionValue_MarkChatAsReadAction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.MarkChatAsReadAction) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.messagerange_); + } + + // optional bool read = 1; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 1; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_MarkChatAsReadAction::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncActionValue_MarkChatAsReadAction::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_MarkChatAsReadAction::GetClassData() const { return &_class_data_; } + + +void SyncActionValue_MarkChatAsReadAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.MarkChatAsReadAction) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_messagerange()->::proto::SyncActionValue_SyncActionMessageRange::MergeFrom( + from._internal_messagerange()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.read_ = from._impl_.read_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncActionValue_MarkChatAsReadAction::CopyFrom(const SyncActionValue_MarkChatAsReadAction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.MarkChatAsReadAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncActionValue_MarkChatAsReadAction::IsInitialized() const { + return true; +} + +void SyncActionValue_MarkChatAsReadAction::InternalSwap(SyncActionValue_MarkChatAsReadAction* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SyncActionValue_MarkChatAsReadAction, _impl_.read_) + + sizeof(SyncActionValue_MarkChatAsReadAction::_impl_.read_) + - PROTOBUF_FIELD_OFFSET(SyncActionValue_MarkChatAsReadAction, _impl_.messagerange_)>( + reinterpret_cast(&_impl_.messagerange_), + reinterpret_cast(&other->_impl_.messagerange_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_MarkChatAsReadAction::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[186]); +} + +// =================================================================== + +class SyncActionValue_MuteAction::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_muted(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_muteendtimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +SyncActionValue_MuteAction::SyncActionValue_MuteAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.MuteAction) +} +SyncActionValue_MuteAction::SyncActionValue_MuteAction(const SyncActionValue_MuteAction& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncActionValue_MuteAction* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.muteendtimestamp_){} + , decltype(_impl_.muted_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&_impl_.muteendtimestamp_, &from._impl_.muteendtimestamp_, + static_cast(reinterpret_cast(&_impl_.muted_) - + reinterpret_cast(&_impl_.muteendtimestamp_)) + sizeof(_impl_.muted_)); + // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.MuteAction) +} + +inline void SyncActionValue_MuteAction::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.muteendtimestamp_){int64_t{0}} + , decltype(_impl_.muted_){false} + }; +} + +SyncActionValue_MuteAction::~SyncActionValue_MuteAction() { + // @@protoc_insertion_point(destructor:proto.SyncActionValue.MuteAction) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncActionValue_MuteAction::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void SyncActionValue_MuteAction::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncActionValue_MuteAction::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.MuteAction) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + ::memset(&_impl_.muteendtimestamp_, 0, static_cast( + reinterpret_cast(&_impl_.muted_) - + reinterpret_cast(&_impl_.muteendtimestamp_)) + sizeof(_impl_.muted_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncActionValue_MuteAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bool muted = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_muted(&has_bits); + _impl_.muted_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 muteEndTimestamp = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_muteendtimestamp(&has_bits); + _impl_.muteendtimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncActionValue_MuteAction::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.MuteAction) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bool muted = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_muted(), target); + } + + // optional int64 muteEndTimestamp = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_muteendtimestamp(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.MuteAction) + return target; +} + +size_t SyncActionValue_MuteAction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.MuteAction) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional int64 muteEndTimestamp = 2; + if (cached_has_bits & 0x00000001u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_muteendtimestamp()); + } + + // optional bool muted = 1; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 1; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_MuteAction::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncActionValue_MuteAction::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_MuteAction::GetClassData() const { return &_class_data_; } + + +void SyncActionValue_MuteAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.MuteAction) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_impl_.muteendtimestamp_ = from._impl_.muteendtimestamp_; + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.muted_ = from._impl_.muted_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncActionValue_MuteAction::CopyFrom(const SyncActionValue_MuteAction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.MuteAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncActionValue_MuteAction::IsInitialized() const { + return true; +} + +void SyncActionValue_MuteAction::InternalSwap(SyncActionValue_MuteAction* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SyncActionValue_MuteAction, _impl_.muted_) + + sizeof(SyncActionValue_MuteAction::_impl_.muted_) + - PROTOBUF_FIELD_OFFSET(SyncActionValue_MuteAction, _impl_.muteendtimestamp_)>( + reinterpret_cast(&_impl_.muteendtimestamp_), + reinterpret_cast(&other->_impl_.muteendtimestamp_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_MuteAction::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[187]); +} + +// =================================================================== + +class SyncActionValue_NuxAction::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_acknowledged(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +SyncActionValue_NuxAction::SyncActionValue_NuxAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.NuxAction) +} +SyncActionValue_NuxAction::SyncActionValue_NuxAction(const SyncActionValue_NuxAction& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncActionValue_NuxAction* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.acknowledged_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _this->_impl_.acknowledged_ = from._impl_.acknowledged_; + // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.NuxAction) +} + +inline void SyncActionValue_NuxAction::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.acknowledged_){false} + }; +} + +SyncActionValue_NuxAction::~SyncActionValue_NuxAction() { + // @@protoc_insertion_point(destructor:proto.SyncActionValue.NuxAction) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncActionValue_NuxAction::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void SyncActionValue_NuxAction::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncActionValue_NuxAction::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.NuxAction) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.acknowledged_ = false; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncActionValue_NuxAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bool acknowledged = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_acknowledged(&has_bits); + _impl_.acknowledged_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncActionValue_NuxAction::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.NuxAction) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bool acknowledged = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_acknowledged(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.NuxAction) + return target; +} + +size_t SyncActionValue_NuxAction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.NuxAction) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional bool acknowledged = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 1; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_NuxAction::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncActionValue_NuxAction::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_NuxAction::GetClassData() const { return &_class_data_; } + + +void SyncActionValue_NuxAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.NuxAction) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_acknowledged()) { + _this->_internal_set_acknowledged(from._internal_acknowledged()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncActionValue_NuxAction::CopyFrom(const SyncActionValue_NuxAction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.NuxAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncActionValue_NuxAction::IsInitialized() const { + return true; +} + +void SyncActionValue_NuxAction::InternalSwap(SyncActionValue_NuxAction* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_.acknowledged_, other->_impl_.acknowledged_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_NuxAction::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[188]); +} + +// =================================================================== + +class SyncActionValue_PinAction::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_pinned(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +SyncActionValue_PinAction::SyncActionValue_PinAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.PinAction) +} +SyncActionValue_PinAction::SyncActionValue_PinAction(const SyncActionValue_PinAction& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncActionValue_PinAction* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.pinned_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _this->_impl_.pinned_ = from._impl_.pinned_; + // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.PinAction) +} + +inline void SyncActionValue_PinAction::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.pinned_){false} + }; +} + +SyncActionValue_PinAction::~SyncActionValue_PinAction() { + // @@protoc_insertion_point(destructor:proto.SyncActionValue.PinAction) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncActionValue_PinAction::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void SyncActionValue_PinAction::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncActionValue_PinAction::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.PinAction) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.pinned_ = false; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncActionValue_PinAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bool pinned = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_pinned(&has_bits); + _impl_.pinned_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncActionValue_PinAction::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.PinAction) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bool pinned = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_pinned(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.PinAction) + return target; +} + +size_t SyncActionValue_PinAction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.PinAction) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional bool pinned = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 1; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_PinAction::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncActionValue_PinAction::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_PinAction::GetClassData() const { return &_class_data_; } + + +void SyncActionValue_PinAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.PinAction) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_pinned()) { + _this->_internal_set_pinned(from._internal_pinned()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncActionValue_PinAction::CopyFrom(const SyncActionValue_PinAction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.PinAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncActionValue_PinAction::IsInitialized() const { + return true; +} + +void SyncActionValue_PinAction::InternalSwap(SyncActionValue_PinAction* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_.pinned_, other->_impl_.pinned_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_PinAction::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[189]); +} + +// =================================================================== + +class SyncActionValue_PrimaryFeature::_Internal { + public: +}; + +SyncActionValue_PrimaryFeature::SyncActionValue_PrimaryFeature(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.PrimaryFeature) +} +SyncActionValue_PrimaryFeature::SyncActionValue_PrimaryFeature(const SyncActionValue_PrimaryFeature& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncActionValue_PrimaryFeature* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.flags_){from._impl_.flags_} + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.PrimaryFeature) +} + +inline void SyncActionValue_PrimaryFeature::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_.flags_){arena} + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +SyncActionValue_PrimaryFeature::~SyncActionValue_PrimaryFeature() { + // @@protoc_insertion_point(destructor:proto.SyncActionValue.PrimaryFeature) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncActionValue_PrimaryFeature::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.flags_.~RepeatedPtrField(); +} + +void SyncActionValue_PrimaryFeature::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncActionValue_PrimaryFeature::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.PrimaryFeature) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.flags_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncActionValue_PrimaryFeature::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated string flags = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_flags(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.PrimaryFeature.flags"); + #endif // !NDEBUG + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncActionValue_PrimaryFeature::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.PrimaryFeature) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated string flags = 1; + for (int i = 0, n = this->_internal_flags_size(); i < n; i++) { + const auto& s = this->_internal_flags(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.SyncActionValue.PrimaryFeature.flags"); + target = stream->WriteString(1, s, target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.PrimaryFeature) + return target; +} + +size_t SyncActionValue_PrimaryFeature::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.PrimaryFeature) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string flags = 1; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.flags_.size()); + for (int i = 0, n = _impl_.flags_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + _impl_.flags_.Get(i)); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_PrimaryFeature::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncActionValue_PrimaryFeature::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_PrimaryFeature::GetClassData() const { return &_class_data_; } + + +void SyncActionValue_PrimaryFeature::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.PrimaryFeature) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.flags_.MergeFrom(from._impl_.flags_); + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncActionValue_PrimaryFeature::CopyFrom(const SyncActionValue_PrimaryFeature& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.PrimaryFeature) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncActionValue_PrimaryFeature::IsInitialized() const { + return true; +} + +void SyncActionValue_PrimaryFeature::InternalSwap(SyncActionValue_PrimaryFeature* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.flags_.InternalSwap(&other->_impl_.flags_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_PrimaryFeature::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[190]); +} + +// =================================================================== + +class SyncActionValue_PrimaryVersionAction::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_version(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +SyncActionValue_PrimaryVersionAction::SyncActionValue_PrimaryVersionAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.PrimaryVersionAction) +} +SyncActionValue_PrimaryVersionAction::SyncActionValue_PrimaryVersionAction(const SyncActionValue_PrimaryVersionAction& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncActionValue_PrimaryVersionAction* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.version_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.version_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.version_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_version()) { + _this->_impl_.version_.Set(from._internal_version(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.PrimaryVersionAction) +} + +inline void SyncActionValue_PrimaryVersionAction::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.version_){} + }; + _impl_.version_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.version_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +SyncActionValue_PrimaryVersionAction::~SyncActionValue_PrimaryVersionAction() { + // @@protoc_insertion_point(destructor:proto.SyncActionValue.PrimaryVersionAction) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncActionValue_PrimaryVersionAction::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.version_.Destroy(); +} + +void SyncActionValue_PrimaryVersionAction::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncActionValue_PrimaryVersionAction::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.PrimaryVersionAction) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.version_.ClearNonDefaultToEmpty(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncActionValue_PrimaryVersionAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string version = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_version(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.PrimaryVersionAction.version"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncActionValue_PrimaryVersionAction::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.PrimaryVersionAction) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string version = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_version().data(), static_cast(this->_internal_version().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.SyncActionValue.PrimaryVersionAction.version"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_version(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.PrimaryVersionAction) + return target; +} + +size_t SyncActionValue_PrimaryVersionAction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.PrimaryVersionAction) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional string version = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_version()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_PrimaryVersionAction::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncActionValue_PrimaryVersionAction::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_PrimaryVersionAction::GetClassData() const { return &_class_data_; } + + +void SyncActionValue_PrimaryVersionAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.PrimaryVersionAction) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_version()) { + _this->_internal_set_version(from._internal_version()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncActionValue_PrimaryVersionAction::CopyFrom(const SyncActionValue_PrimaryVersionAction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.PrimaryVersionAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncActionValue_PrimaryVersionAction::IsInitialized() const { + return true; +} + +void SyncActionValue_PrimaryVersionAction::InternalSwap(SyncActionValue_PrimaryVersionAction* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.version_, lhs_arena, + &other->_impl_.version_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_PrimaryVersionAction::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[191]); +} + +// =================================================================== + +class SyncActionValue_PushNameSetting::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_name(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +SyncActionValue_PushNameSetting::SyncActionValue_PushNameSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.PushNameSetting) +} +SyncActionValue_PushNameSetting::SyncActionValue_PushNameSetting(const SyncActionValue_PushNameSetting& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncActionValue_PushNameSetting* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.name_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.name_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.name_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_name()) { + _this->_impl_.name_.Set(from._internal_name(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.PushNameSetting) +} + +inline void SyncActionValue_PushNameSetting::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.name_){} + }; + _impl_.name_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.name_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +SyncActionValue_PushNameSetting::~SyncActionValue_PushNameSetting() { + // @@protoc_insertion_point(destructor:proto.SyncActionValue.PushNameSetting) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncActionValue_PushNameSetting::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.name_.Destroy(); +} + +void SyncActionValue_PushNameSetting::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncActionValue_PushNameSetting::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.PushNameSetting) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.name_.ClearNonDefaultToEmpty(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncActionValue_PushNameSetting::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_name(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.PushNameSetting.name"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncActionValue_PushNameSetting::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.PushNameSetting) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string name = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.SyncActionValue.PushNameSetting.name"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_name(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.PushNameSetting) + return target; +} + +size_t SyncActionValue_PushNameSetting::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.PushNameSetting) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional string name = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_PushNameSetting::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncActionValue_PushNameSetting::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_PushNameSetting::GetClassData() const { return &_class_data_; } + + +void SyncActionValue_PushNameSetting::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.PushNameSetting) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_name()) { + _this->_internal_set_name(from._internal_name()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncActionValue_PushNameSetting::CopyFrom(const SyncActionValue_PushNameSetting& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.PushNameSetting) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncActionValue_PushNameSetting::IsInitialized() const { + return true; +} + +void SyncActionValue_PushNameSetting::InternalSwap(SyncActionValue_PushNameSetting* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.name_, lhs_arena, + &other->_impl_.name_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_PushNameSetting::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[192]); +} + +// =================================================================== + +class SyncActionValue_QuickReplyAction::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_shortcut(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_message(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_count(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_deleted(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +SyncActionValue_QuickReplyAction::SyncActionValue_QuickReplyAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.QuickReplyAction) +} +SyncActionValue_QuickReplyAction::SyncActionValue_QuickReplyAction(const SyncActionValue_QuickReplyAction& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncActionValue_QuickReplyAction* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.keywords_){from._impl_.keywords_} + , decltype(_impl_.shortcut_){} + , decltype(_impl_.message_){} + , decltype(_impl_.count_){} + , decltype(_impl_.deleted_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.shortcut_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.shortcut_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_shortcut()) { + _this->_impl_.shortcut_.Set(from._internal_shortcut(), + _this->GetArenaForAllocation()); + } + _impl_.message_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.message_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_message()) { + _this->_impl_.message_.Set(from._internal_message(), + _this->GetArenaForAllocation()); + } + ::memcpy(&_impl_.count_, &from._impl_.count_, + static_cast(reinterpret_cast(&_impl_.deleted_) - + reinterpret_cast(&_impl_.count_)) + sizeof(_impl_.deleted_)); + // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.QuickReplyAction) +} + +inline void SyncActionValue_QuickReplyAction::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.keywords_){arena} + , decltype(_impl_.shortcut_){} + , decltype(_impl_.message_){} + , decltype(_impl_.count_){0} + , decltype(_impl_.deleted_){false} + }; + _impl_.shortcut_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.shortcut_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.message_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.message_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +SyncActionValue_QuickReplyAction::~SyncActionValue_QuickReplyAction() { + // @@protoc_insertion_point(destructor:proto.SyncActionValue.QuickReplyAction) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncActionValue_QuickReplyAction::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.keywords_.~RepeatedPtrField(); + _impl_.shortcut_.Destroy(); + _impl_.message_.Destroy(); +} + +void SyncActionValue_QuickReplyAction::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncActionValue_QuickReplyAction::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.QuickReplyAction) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.keywords_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.shortcut_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.message_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x0000000cu) { + ::memset(&_impl_.count_, 0, static_cast( + reinterpret_cast(&_impl_.deleted_) - + reinterpret_cast(&_impl_.count_)) + sizeof(_impl_.deleted_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncActionValue_QuickReplyAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string shortcut = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_shortcut(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.QuickReplyAction.shortcut"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string message = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_message(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.QuickReplyAction.message"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // repeated string keywords = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_keywords(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.QuickReplyAction.keywords"); + #endif // !NDEBUG + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else + goto handle_unusual; + continue; + // optional int32 count = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_count(&has_bits); + _impl_.count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool deleted = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_deleted(&has_bits); + _impl_.deleted_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncActionValue_QuickReplyAction::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.QuickReplyAction) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string shortcut = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_shortcut().data(), static_cast(this->_internal_shortcut().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.SyncActionValue.QuickReplyAction.shortcut"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_shortcut(), target); + } + + // optional string message = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_message().data(), static_cast(this->_internal_message().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.SyncActionValue.QuickReplyAction.message"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_message(), target); + } + + // repeated string keywords = 3; + for (int i = 0, n = this->_internal_keywords_size(); i < n; i++) { + const auto& s = this->_internal_keywords(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.SyncActionValue.QuickReplyAction.keywords"); + target = stream->WriteString(3, s, target); + } + + // optional int32 count = 4; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_count(), target); + } + + // optional bool deleted = 5; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(5, this->_internal_deleted(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.QuickReplyAction) + return target; +} + +size_t SyncActionValue_QuickReplyAction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.QuickReplyAction) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string keywords = 3; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.keywords_.size()); + for (int i = 0, n = _impl_.keywords_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + _impl_.keywords_.Get(i)); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional string shortcut = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_shortcut()); + } + + // optional string message = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_message()); + } + + // optional int32 count = 4; + if (cached_has_bits & 0x00000004u) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_count()); + } + + // optional bool deleted = 5; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 1; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_QuickReplyAction::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncActionValue_QuickReplyAction::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_QuickReplyAction::GetClassData() const { return &_class_data_; } + + +void SyncActionValue_QuickReplyAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.QuickReplyAction) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.keywords_.MergeFrom(from._impl_.keywords_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_shortcut(from._internal_shortcut()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_message(from._internal_message()); + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.count_ = from._impl_.count_; + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.deleted_ = from._impl_.deleted_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncActionValue_QuickReplyAction::CopyFrom(const SyncActionValue_QuickReplyAction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.QuickReplyAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncActionValue_QuickReplyAction::IsInitialized() const { + return true; +} + +void SyncActionValue_QuickReplyAction::InternalSwap(SyncActionValue_QuickReplyAction* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.keywords_.InternalSwap(&other->_impl_.keywords_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.shortcut_, lhs_arena, + &other->_impl_.shortcut_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.message_, lhs_arena, + &other->_impl_.message_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SyncActionValue_QuickReplyAction, _impl_.deleted_) + + sizeof(SyncActionValue_QuickReplyAction::_impl_.deleted_) + - PROTOBUF_FIELD_OFFSET(SyncActionValue_QuickReplyAction, _impl_.count_)>( + reinterpret_cast(&_impl_.count_), + reinterpret_cast(&other->_impl_.count_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_QuickReplyAction::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[193]); +} + +// =================================================================== + +class SyncActionValue_RecentEmojiWeightsAction::_Internal { + public: +}; + +SyncActionValue_RecentEmojiWeightsAction::SyncActionValue_RecentEmojiWeightsAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.RecentEmojiWeightsAction) +} +SyncActionValue_RecentEmojiWeightsAction::SyncActionValue_RecentEmojiWeightsAction(const SyncActionValue_RecentEmojiWeightsAction& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncActionValue_RecentEmojiWeightsAction* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.weights_){from._impl_.weights_} + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.RecentEmojiWeightsAction) +} + +inline void SyncActionValue_RecentEmojiWeightsAction::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_.weights_){arena} + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +SyncActionValue_RecentEmojiWeightsAction::~SyncActionValue_RecentEmojiWeightsAction() { + // @@protoc_insertion_point(destructor:proto.SyncActionValue.RecentEmojiWeightsAction) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncActionValue_RecentEmojiWeightsAction::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.weights_.~RepeatedPtrField(); +} + +void SyncActionValue_RecentEmojiWeightsAction::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncActionValue_RecentEmojiWeightsAction::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.RecentEmojiWeightsAction) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.weights_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncActionValue_RecentEmojiWeightsAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .proto.RecentEmojiWeight weights = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_weights(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncActionValue_RecentEmojiWeightsAction::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.RecentEmojiWeightsAction) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .proto.RecentEmojiWeight weights = 1; + for (unsigned i = 0, + n = static_cast(this->_internal_weights_size()); i < n; i++) { + const auto& repfield = this->_internal_weights(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.RecentEmojiWeightsAction) + return target; +} + +size_t SyncActionValue_RecentEmojiWeightsAction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.RecentEmojiWeightsAction) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.RecentEmojiWeight weights = 1; + total_size += 1UL * this->_internal_weights_size(); + for (const auto& msg : this->_impl_.weights_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_RecentEmojiWeightsAction::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncActionValue_RecentEmojiWeightsAction::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_RecentEmojiWeightsAction::GetClassData() const { return &_class_data_; } + + +void SyncActionValue_RecentEmojiWeightsAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.RecentEmojiWeightsAction) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.weights_.MergeFrom(from._impl_.weights_); + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncActionValue_RecentEmojiWeightsAction::CopyFrom(const SyncActionValue_RecentEmojiWeightsAction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.RecentEmojiWeightsAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncActionValue_RecentEmojiWeightsAction::IsInitialized() const { + return true; +} + +void SyncActionValue_RecentEmojiWeightsAction::InternalSwap(SyncActionValue_RecentEmojiWeightsAction* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.weights_.InternalSwap(&other->_impl_.weights_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_RecentEmojiWeightsAction::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[194]); +} + +// =================================================================== + +class SyncActionValue_SecurityNotificationSetting::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_shownotification(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +SyncActionValue_SecurityNotificationSetting::SyncActionValue_SecurityNotificationSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.SecurityNotificationSetting) +} +SyncActionValue_SecurityNotificationSetting::SyncActionValue_SecurityNotificationSetting(const SyncActionValue_SecurityNotificationSetting& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncActionValue_SecurityNotificationSetting* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.shownotification_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _this->_impl_.shownotification_ = from._impl_.shownotification_; + // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.SecurityNotificationSetting) +} + +inline void SyncActionValue_SecurityNotificationSetting::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.shownotification_){false} + }; +} + +SyncActionValue_SecurityNotificationSetting::~SyncActionValue_SecurityNotificationSetting() { + // @@protoc_insertion_point(destructor:proto.SyncActionValue.SecurityNotificationSetting) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncActionValue_SecurityNotificationSetting::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void SyncActionValue_SecurityNotificationSetting::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncActionValue_SecurityNotificationSetting::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.SecurityNotificationSetting) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.shownotification_ = false; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncActionValue_SecurityNotificationSetting::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bool showNotification = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_shownotification(&has_bits); + _impl_.shownotification_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncActionValue_SecurityNotificationSetting::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.SecurityNotificationSetting) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bool showNotification = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_shownotification(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.SecurityNotificationSetting) + return target; +} + +size_t SyncActionValue_SecurityNotificationSetting::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.SecurityNotificationSetting) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional bool showNotification = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 1; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_SecurityNotificationSetting::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncActionValue_SecurityNotificationSetting::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_SecurityNotificationSetting::GetClassData() const { return &_class_data_; } + + +void SyncActionValue_SecurityNotificationSetting::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.SecurityNotificationSetting) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_shownotification()) { + _this->_internal_set_shownotification(from._internal_shownotification()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncActionValue_SecurityNotificationSetting::CopyFrom(const SyncActionValue_SecurityNotificationSetting& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.SecurityNotificationSetting) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncActionValue_SecurityNotificationSetting::IsInitialized() const { + return true; +} + +void SyncActionValue_SecurityNotificationSetting::InternalSwap(SyncActionValue_SecurityNotificationSetting* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_.shownotification_, other->_impl_.shownotification_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_SecurityNotificationSetting::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[195]); +} + +// =================================================================== + +class SyncActionValue_StarAction::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_starred(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +SyncActionValue_StarAction::SyncActionValue_StarAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.StarAction) +} +SyncActionValue_StarAction::SyncActionValue_StarAction(const SyncActionValue_StarAction& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncActionValue_StarAction* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.starred_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _this->_impl_.starred_ = from._impl_.starred_; + // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.StarAction) +} + +inline void SyncActionValue_StarAction::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.starred_){false} + }; +} + +SyncActionValue_StarAction::~SyncActionValue_StarAction() { + // @@protoc_insertion_point(destructor:proto.SyncActionValue.StarAction) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncActionValue_StarAction::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void SyncActionValue_StarAction::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncActionValue_StarAction::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.StarAction) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.starred_ = false; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncActionValue_StarAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bool starred = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_starred(&has_bits); + _impl_.starred_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncActionValue_StarAction::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.StarAction) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bool starred = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_starred(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.StarAction) + return target; +} + +size_t SyncActionValue_StarAction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.StarAction) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional bool starred = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 1; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_StarAction::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncActionValue_StarAction::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_StarAction::GetClassData() const { return &_class_data_; } + + +void SyncActionValue_StarAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.StarAction) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_starred()) { + _this->_internal_set_starred(from._internal_starred()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncActionValue_StarAction::CopyFrom(const SyncActionValue_StarAction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.StarAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncActionValue_StarAction::IsInitialized() const { + return true; +} + +void SyncActionValue_StarAction::InternalSwap(SyncActionValue_StarAction* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_.starred_, other->_impl_.starred_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_StarAction::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[196]); +} + +// =================================================================== + +class SyncActionValue_StickerAction::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_url(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_fileencsha256(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_mediakey(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_mimetype(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_height(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_width(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_directpath(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_filelength(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_isfavorite(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_deviceidhint(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } +}; + +SyncActionValue_StickerAction::SyncActionValue_StickerAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.StickerAction) +} +SyncActionValue_StickerAction::SyncActionValue_StickerAction(const SyncActionValue_StickerAction& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncActionValue_StickerAction* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.url_){} + , decltype(_impl_.fileencsha256_){} + , decltype(_impl_.mediakey_){} + , decltype(_impl_.mimetype_){} + , decltype(_impl_.directpath_){} + , decltype(_impl_.height_){} + , decltype(_impl_.width_){} + , decltype(_impl_.filelength_){} + , decltype(_impl_.isfavorite_){} + , decltype(_impl_.deviceidhint_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.url_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.url_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_url()) { + _this->_impl_.url_.Set(from._internal_url(), + _this->GetArenaForAllocation()); + } + _impl_.fileencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_fileencsha256()) { + _this->_impl_.fileencsha256_.Set(from._internal_fileencsha256(), + _this->GetArenaForAllocation()); + } + _impl_.mediakey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediakey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_mediakey()) { + _this->_impl_.mediakey_.Set(from._internal_mediakey(), + _this->GetArenaForAllocation()); + } + _impl_.mimetype_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mimetype_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_mimetype()) { + _this->_impl_.mimetype_.Set(from._internal_mimetype(), + _this->GetArenaForAllocation()); + } + _impl_.directpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_directpath()) { + _this->_impl_.directpath_.Set(from._internal_directpath(), + _this->GetArenaForAllocation()); + } + ::memcpy(&_impl_.height_, &from._impl_.height_, + static_cast(reinterpret_cast(&_impl_.deviceidhint_) - + reinterpret_cast(&_impl_.height_)) + sizeof(_impl_.deviceidhint_)); + // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.StickerAction) +} + +inline void SyncActionValue_StickerAction::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.url_){} + , decltype(_impl_.fileencsha256_){} + , decltype(_impl_.mediakey_){} + , decltype(_impl_.mimetype_){} + , decltype(_impl_.directpath_){} + , decltype(_impl_.height_){0u} + , decltype(_impl_.width_){0u} + , decltype(_impl_.filelength_){uint64_t{0u}} + , decltype(_impl_.isfavorite_){false} + , decltype(_impl_.deviceidhint_){0u} + }; + _impl_.url_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.url_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fileencsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediakey_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediakey_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mimetype_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mimetype_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.directpath_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +SyncActionValue_StickerAction::~SyncActionValue_StickerAction() { + // @@protoc_insertion_point(destructor:proto.SyncActionValue.StickerAction) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncActionValue_StickerAction::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.url_.Destroy(); + _impl_.fileencsha256_.Destroy(); + _impl_.mediakey_.Destroy(); + _impl_.mimetype_.Destroy(); + _impl_.directpath_.Destroy(); +} + +void SyncActionValue_StickerAction::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncActionValue_StickerAction::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.StickerAction) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _impl_.url_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.fileencsha256_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.mediakey_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + _impl_.mimetype_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + _impl_.directpath_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x000000e0u) { + ::memset(&_impl_.height_, 0, static_cast( + reinterpret_cast(&_impl_.filelength_) - + reinterpret_cast(&_impl_.height_)) + sizeof(_impl_.filelength_)); + } + if (cached_has_bits & 0x00000300u) { + ::memset(&_impl_.isfavorite_, 0, static_cast( + reinterpret_cast(&_impl_.deviceidhint_) - + reinterpret_cast(&_impl_.isfavorite_)) + sizeof(_impl_.deviceidhint_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncActionValue_StickerAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string url = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_url(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.StickerAction.url"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bytes fileEncSha256 = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_fileencsha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes mediaKey = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_mediakey(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string mimetype = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_mimetype(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.StickerAction.mimetype"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional uint32 height = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_height(&has_bits); + _impl_.height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 width = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + _Internal::set_has_width(&has_bits); + _impl_.width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string directPath = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + auto str = _internal_mutable_directpath(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.StickerAction.directPath"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional uint64 fileLength = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { + _Internal::set_has_filelength(&has_bits); + _impl_.filelength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool isFavorite = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { + _Internal::set_has_isfavorite(&has_bits); + _impl_.isfavorite_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 deviceIdHint = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { + _Internal::set_has_deviceidhint(&has_bits); + _impl_.deviceidhint_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncActionValue_StickerAction::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.StickerAction) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string url = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_url().data(), static_cast(this->_internal_url().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.SyncActionValue.StickerAction.url"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_url(), target); + } + + // optional bytes fileEncSha256 = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_fileencsha256(), target); + } + + // optional bytes mediaKey = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->WriteBytesMaybeAliased( + 3, this->_internal_mediakey(), target); + } + + // optional string mimetype = 4; + if (cached_has_bits & 0x00000008u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_mimetype().data(), static_cast(this->_internal_mimetype().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.SyncActionValue.StickerAction.mimetype"); + target = stream->WriteStringMaybeAliased( + 4, this->_internal_mimetype(), target); + } + + // optional uint32 height = 5; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_height(), target); + } + + // optional uint32 width = 6; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_width(), target); + } + + // optional string directPath = 7; + if (cached_has_bits & 0x00000010u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_directpath().data(), static_cast(this->_internal_directpath().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.SyncActionValue.StickerAction.directPath"); + target = stream->WriteStringMaybeAliased( + 7, this->_internal_directpath(), target); + } + + // optional uint64 fileLength = 8; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(8, this->_internal_filelength(), target); + } + + // optional bool isFavorite = 9; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(9, this->_internal_isfavorite(), target); + } + + // optional uint32 deviceIdHint = 10; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(10, this->_internal_deviceidhint(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.StickerAction) + return target; +} + +size_t SyncActionValue_StickerAction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.StickerAction) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string url = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_url()); + } + + // optional bytes fileEncSha256 = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_fileencsha256()); + } + + // optional bytes mediaKey = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_mediakey()); + } + + // optional string mimetype = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_mimetype()); + } + + // optional string directPath = 7; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_directpath()); + } + + // optional uint32 height = 5; + if (cached_has_bits & 0x00000020u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_height()); + } + + // optional uint32 width = 6; + if (cached_has_bits & 0x00000040u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_width()); + } + + // optional uint64 fileLength = 8; + if (cached_has_bits & 0x00000080u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_filelength()); + } + + } + if (cached_has_bits & 0x00000300u) { + // optional bool isFavorite = 9; + if (cached_has_bits & 0x00000100u) { + total_size += 1 + 1; + } + + // optional uint32 deviceIdHint = 10; + if (cached_has_bits & 0x00000200u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_deviceidhint()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_StickerAction::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncActionValue_StickerAction::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_StickerAction::GetClassData() const { return &_class_data_; } + + +void SyncActionValue_StickerAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.StickerAction) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_url(from._internal_url()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_fileencsha256(from._internal_fileencsha256()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_mediakey(from._internal_mediakey()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_set_mimetype(from._internal_mimetype()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_set_directpath(from._internal_directpath()); + } + if (cached_has_bits & 0x00000020u) { + _this->_impl_.height_ = from._impl_.height_; + } + if (cached_has_bits & 0x00000040u) { + _this->_impl_.width_ = from._impl_.width_; + } + if (cached_has_bits & 0x00000080u) { + _this->_impl_.filelength_ = from._impl_.filelength_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00000300u) { + if (cached_has_bits & 0x00000100u) { + _this->_impl_.isfavorite_ = from._impl_.isfavorite_; + } + if (cached_has_bits & 0x00000200u) { + _this->_impl_.deviceidhint_ = from._impl_.deviceidhint_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncActionValue_StickerAction::CopyFrom(const SyncActionValue_StickerAction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.StickerAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncActionValue_StickerAction::IsInitialized() const { + return true; +} + +void SyncActionValue_StickerAction::InternalSwap(SyncActionValue_StickerAction* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.url_, lhs_arena, + &other->_impl_.url_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.fileencsha256_, lhs_arena, + &other->_impl_.fileencsha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.mediakey_, lhs_arena, + &other->_impl_.mediakey_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.mimetype_, lhs_arena, + &other->_impl_.mimetype_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.directpath_, lhs_arena, + &other->_impl_.directpath_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SyncActionValue_StickerAction, _impl_.deviceidhint_) + + sizeof(SyncActionValue_StickerAction::_impl_.deviceidhint_) + - PROTOBUF_FIELD_OFFSET(SyncActionValue_StickerAction, _impl_.height_)>( + reinterpret_cast(&_impl_.height_), + reinterpret_cast(&other->_impl_.height_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_StickerAction::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[197]); +} + +// =================================================================== + +class SyncActionValue_SubscriptionAction::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_isdeactivated(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_isautorenewing(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_expirationdate(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +SyncActionValue_SubscriptionAction::SyncActionValue_SubscriptionAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.SubscriptionAction) +} +SyncActionValue_SubscriptionAction::SyncActionValue_SubscriptionAction(const SyncActionValue_SubscriptionAction& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncActionValue_SubscriptionAction* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.expirationdate_){} + , decltype(_impl_.isdeactivated_){} + , decltype(_impl_.isautorenewing_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&_impl_.expirationdate_, &from._impl_.expirationdate_, + static_cast(reinterpret_cast(&_impl_.isautorenewing_) - + reinterpret_cast(&_impl_.expirationdate_)) + sizeof(_impl_.isautorenewing_)); + // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.SubscriptionAction) +} + +inline void SyncActionValue_SubscriptionAction::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.expirationdate_){int64_t{0}} + , decltype(_impl_.isdeactivated_){false} + , decltype(_impl_.isautorenewing_){false} + }; +} + +SyncActionValue_SubscriptionAction::~SyncActionValue_SubscriptionAction() { + // @@protoc_insertion_point(destructor:proto.SyncActionValue.SubscriptionAction) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncActionValue_SubscriptionAction::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void SyncActionValue_SubscriptionAction::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncActionValue_SubscriptionAction::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.SubscriptionAction) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + ::memset(&_impl_.expirationdate_, 0, static_cast( + reinterpret_cast(&_impl_.isautorenewing_) - + reinterpret_cast(&_impl_.expirationdate_)) + sizeof(_impl_.isautorenewing_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncActionValue_SubscriptionAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bool isDeactivated = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_isdeactivated(&has_bits); + _impl_.isdeactivated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool isAutoRenewing = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_isautorenewing(&has_bits); + _impl_.isautorenewing_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 expirationDate = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_expirationdate(&has_bits); + _impl_.expirationdate_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncActionValue_SubscriptionAction::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.SubscriptionAction) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bool isDeactivated = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_isdeactivated(), target); + } + + // optional bool isAutoRenewing = 2; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(2, this->_internal_isautorenewing(), target); + } + + // optional int64 expirationDate = 3; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_expirationdate(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.SubscriptionAction) + return target; +} + +size_t SyncActionValue_SubscriptionAction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.SubscriptionAction) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional int64 expirationDate = 3; + if (cached_has_bits & 0x00000001u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_expirationdate()); + } + + // optional bool isDeactivated = 1; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 1; + } + + // optional bool isAutoRenewing = 2; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 1; + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_SubscriptionAction::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncActionValue_SubscriptionAction::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_SubscriptionAction::GetClassData() const { return &_class_data_; } + + +void SyncActionValue_SubscriptionAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.SubscriptionAction) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_impl_.expirationdate_ = from._impl_.expirationdate_; + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.isdeactivated_ = from._impl_.isdeactivated_; + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.isautorenewing_ = from._impl_.isautorenewing_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncActionValue_SubscriptionAction::CopyFrom(const SyncActionValue_SubscriptionAction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.SubscriptionAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncActionValue_SubscriptionAction::IsInitialized() const { + return true; +} + +void SyncActionValue_SubscriptionAction::InternalSwap(SyncActionValue_SubscriptionAction* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SyncActionValue_SubscriptionAction, _impl_.isautorenewing_) + + sizeof(SyncActionValue_SubscriptionAction::_impl_.isautorenewing_) + - PROTOBUF_FIELD_OFFSET(SyncActionValue_SubscriptionAction, _impl_.expirationdate_)>( + reinterpret_cast(&_impl_.expirationdate_), + reinterpret_cast(&other->_impl_.expirationdate_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_SubscriptionAction::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[198]); +} + +// =================================================================== + +class SyncActionValue_SyncActionMessageRange::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_lastmessagetimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_lastsystemmessagetimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +SyncActionValue_SyncActionMessageRange::SyncActionValue_SyncActionMessageRange(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.SyncActionMessageRange) +} +SyncActionValue_SyncActionMessageRange::SyncActionValue_SyncActionMessageRange(const SyncActionValue_SyncActionMessageRange& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncActionValue_SyncActionMessageRange* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.messages_){from._impl_.messages_} + , decltype(_impl_.lastmessagetimestamp_){} + , decltype(_impl_.lastsystemmessagetimestamp_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&_impl_.lastmessagetimestamp_, &from._impl_.lastmessagetimestamp_, + static_cast(reinterpret_cast(&_impl_.lastsystemmessagetimestamp_) - + reinterpret_cast(&_impl_.lastmessagetimestamp_)) + sizeof(_impl_.lastsystemmessagetimestamp_)); + // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.SyncActionMessageRange) +} + +inline void SyncActionValue_SyncActionMessageRange::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.messages_){arena} + , decltype(_impl_.lastmessagetimestamp_){int64_t{0}} + , decltype(_impl_.lastsystemmessagetimestamp_){int64_t{0}} + }; +} + +SyncActionValue_SyncActionMessageRange::~SyncActionValue_SyncActionMessageRange() { + // @@protoc_insertion_point(destructor:proto.SyncActionValue.SyncActionMessageRange) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncActionValue_SyncActionMessageRange::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.messages_.~RepeatedPtrField(); +} + +void SyncActionValue_SyncActionMessageRange::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncActionValue_SyncActionMessageRange::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.SyncActionMessageRange) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.messages_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + ::memset(&_impl_.lastmessagetimestamp_, 0, static_cast( + reinterpret_cast(&_impl_.lastsystemmessagetimestamp_) - + reinterpret_cast(&_impl_.lastmessagetimestamp_)) + sizeof(_impl_.lastsystemmessagetimestamp_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncActionValue_SyncActionMessageRange::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional int64 lastMessageTimestamp = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_lastmessagetimestamp(&has_bits); + _impl_.lastmessagetimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 lastSystemMessageTimestamp = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_lastsystemmessagetimestamp(&has_bits); + _impl_.lastsystemmessagetimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .proto.SyncActionValue.SyncActionMessage messages = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_messages(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncActionValue_SyncActionMessageRange::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.SyncActionMessageRange) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional int64 lastMessageTimestamp = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_lastmessagetimestamp(), target); + } + + // optional int64 lastSystemMessageTimestamp = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_lastsystemmessagetimestamp(), target); + } + + // repeated .proto.SyncActionValue.SyncActionMessage messages = 3; + for (unsigned i = 0, + n = static_cast(this->_internal_messages_size()); i < n; i++) { + const auto& repfield = this->_internal_messages(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.SyncActionMessageRange) + return target; +} + +size_t SyncActionValue_SyncActionMessageRange::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.SyncActionMessageRange) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.SyncActionValue.SyncActionMessage messages = 3; + total_size += 1UL * this->_internal_messages_size(); + for (const auto& msg : this->_impl_.messages_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional int64 lastMessageTimestamp = 1; + if (cached_has_bits & 0x00000001u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_lastmessagetimestamp()); + } + + // optional int64 lastSystemMessageTimestamp = 2; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_lastsystemmessagetimestamp()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_SyncActionMessageRange::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncActionValue_SyncActionMessageRange::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_SyncActionMessageRange::GetClassData() const { return &_class_data_; } + + +void SyncActionValue_SyncActionMessageRange::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.SyncActionMessageRange) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.messages_.MergeFrom(from._impl_.messages_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_impl_.lastmessagetimestamp_ = from._impl_.lastmessagetimestamp_; + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.lastsystemmessagetimestamp_ = from._impl_.lastsystemmessagetimestamp_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncActionValue_SyncActionMessageRange::CopyFrom(const SyncActionValue_SyncActionMessageRange& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.SyncActionMessageRange) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncActionValue_SyncActionMessageRange::IsInitialized() const { + return true; +} + +void SyncActionValue_SyncActionMessageRange::InternalSwap(SyncActionValue_SyncActionMessageRange* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.messages_.InternalSwap(&other->_impl_.messages_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SyncActionValue_SyncActionMessageRange, _impl_.lastsystemmessagetimestamp_) + + sizeof(SyncActionValue_SyncActionMessageRange::_impl_.lastsystemmessagetimestamp_) + - PROTOBUF_FIELD_OFFSET(SyncActionValue_SyncActionMessageRange, _impl_.lastmessagetimestamp_)>( + reinterpret_cast(&_impl_.lastmessagetimestamp_), + reinterpret_cast(&other->_impl_.lastmessagetimestamp_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_SyncActionMessageRange::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[199]); +} + +// =================================================================== + +class SyncActionValue_SyncActionMessage::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::MessageKey& key(const SyncActionValue_SyncActionMessage* msg); + static void set_has_key(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_timestamp(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::proto::MessageKey& +SyncActionValue_SyncActionMessage::_Internal::key(const SyncActionValue_SyncActionMessage* msg) { + return *msg->_impl_.key_; +} +SyncActionValue_SyncActionMessage::SyncActionValue_SyncActionMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.SyncActionMessage) +} +SyncActionValue_SyncActionMessage::SyncActionValue_SyncActionMessage(const SyncActionValue_SyncActionMessage& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncActionValue_SyncActionMessage* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.key_){nullptr} + , decltype(_impl_.timestamp_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_key()) { + _this->_impl_.key_ = new ::proto::MessageKey(*from._impl_.key_); + } + _this->_impl_.timestamp_ = from._impl_.timestamp_; + // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.SyncActionMessage) +} + +inline void SyncActionValue_SyncActionMessage::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.key_){nullptr} + , decltype(_impl_.timestamp_){int64_t{0}} + }; +} + +SyncActionValue_SyncActionMessage::~SyncActionValue_SyncActionMessage() { + // @@protoc_insertion_point(destructor:proto.SyncActionValue.SyncActionMessage) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncActionValue_SyncActionMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.key_; +} + +void SyncActionValue_SyncActionMessage::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncActionValue_SyncActionMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.SyncActionMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.key_ != nullptr); + _impl_.key_->Clear(); + } + _impl_.timestamp_ = int64_t{0}; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncActionValue_SyncActionMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.MessageKey key = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 timestamp = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_timestamp(&has_bits); + _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncActionValue_SyncActionMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.SyncActionMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.MessageKey key = 1; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::key(this), + _Internal::key(this).GetCachedSize(), target, stream); + } + + // optional int64 timestamp = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_timestamp(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.SyncActionMessage) + return target; +} + +size_t SyncActionValue_SyncActionMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.SyncActionMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional .proto.MessageKey key = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.key_); + } + + // optional int64 timestamp = 2; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_timestamp()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_SyncActionMessage::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncActionValue_SyncActionMessage::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_SyncActionMessage::GetClassData() const { return &_class_data_; } + + +void SyncActionValue_SyncActionMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.SyncActionMessage) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_key()->::proto::MessageKey::MergeFrom( + from._internal_key()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.timestamp_ = from._impl_.timestamp_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncActionValue_SyncActionMessage::CopyFrom(const SyncActionValue_SyncActionMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.SyncActionMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncActionValue_SyncActionMessage::IsInitialized() const { + return true; +} + +void SyncActionValue_SyncActionMessage::InternalSwap(SyncActionValue_SyncActionMessage* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SyncActionValue_SyncActionMessage, _impl_.timestamp_) + + sizeof(SyncActionValue_SyncActionMessage::_impl_.timestamp_) + - PROTOBUF_FIELD_OFFSET(SyncActionValue_SyncActionMessage, _impl_.key_)>( + reinterpret_cast(&_impl_.key_), + reinterpret_cast(&other->_impl_.key_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_SyncActionMessage::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[200]); +} + +// =================================================================== + +class SyncActionValue_TimeFormatAction::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_istwentyfourhourformatenabled(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +SyncActionValue_TimeFormatAction::SyncActionValue_TimeFormatAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.TimeFormatAction) +} +SyncActionValue_TimeFormatAction::SyncActionValue_TimeFormatAction(const SyncActionValue_TimeFormatAction& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncActionValue_TimeFormatAction* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.istwentyfourhourformatenabled_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _this->_impl_.istwentyfourhourformatenabled_ = from._impl_.istwentyfourhourformatenabled_; + // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.TimeFormatAction) +} + +inline void SyncActionValue_TimeFormatAction::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.istwentyfourhourformatenabled_){false} + }; +} + +SyncActionValue_TimeFormatAction::~SyncActionValue_TimeFormatAction() { + // @@protoc_insertion_point(destructor:proto.SyncActionValue.TimeFormatAction) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncActionValue_TimeFormatAction::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void SyncActionValue_TimeFormatAction::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncActionValue_TimeFormatAction::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.TimeFormatAction) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.istwentyfourhourformatenabled_ = false; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncActionValue_TimeFormatAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bool isTwentyFourHourFormatEnabled = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_istwentyfourhourformatenabled(&has_bits); + _impl_.istwentyfourhourformatenabled_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncActionValue_TimeFormatAction::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.TimeFormatAction) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bool isTwentyFourHourFormatEnabled = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_istwentyfourhourformatenabled(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.TimeFormatAction) + return target; +} + +size_t SyncActionValue_TimeFormatAction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.TimeFormatAction) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional bool isTwentyFourHourFormatEnabled = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 1; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_TimeFormatAction::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncActionValue_TimeFormatAction::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_TimeFormatAction::GetClassData() const { return &_class_data_; } + + +void SyncActionValue_TimeFormatAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.TimeFormatAction) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_istwentyfourhourformatenabled()) { + _this->_internal_set_istwentyfourhourformatenabled(from._internal_istwentyfourhourformatenabled()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncActionValue_TimeFormatAction::CopyFrom(const SyncActionValue_TimeFormatAction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.TimeFormatAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncActionValue_TimeFormatAction::IsInitialized() const { + return true; +} + +void SyncActionValue_TimeFormatAction::InternalSwap(SyncActionValue_TimeFormatAction* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_.istwentyfourhourformatenabled_, other->_impl_.istwentyfourhourformatenabled_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_TimeFormatAction::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[201]); +} + +// =================================================================== + +class SyncActionValue_UnarchiveChatsSetting::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_unarchivechats(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +SyncActionValue_UnarchiveChatsSetting::SyncActionValue_UnarchiveChatsSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.UnarchiveChatsSetting) +} +SyncActionValue_UnarchiveChatsSetting::SyncActionValue_UnarchiveChatsSetting(const SyncActionValue_UnarchiveChatsSetting& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncActionValue_UnarchiveChatsSetting* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.unarchivechats_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _this->_impl_.unarchivechats_ = from._impl_.unarchivechats_; + // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.UnarchiveChatsSetting) +} + +inline void SyncActionValue_UnarchiveChatsSetting::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.unarchivechats_){false} + }; +} + +SyncActionValue_UnarchiveChatsSetting::~SyncActionValue_UnarchiveChatsSetting() { + // @@protoc_insertion_point(destructor:proto.SyncActionValue.UnarchiveChatsSetting) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncActionValue_UnarchiveChatsSetting::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void SyncActionValue_UnarchiveChatsSetting::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncActionValue_UnarchiveChatsSetting::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.UnarchiveChatsSetting) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.unarchivechats_ = false; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncActionValue_UnarchiveChatsSetting::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bool unarchiveChats = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_unarchivechats(&has_bits); + _impl_.unarchivechats_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncActionValue_UnarchiveChatsSetting::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.UnarchiveChatsSetting) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bool unarchiveChats = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_unarchivechats(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.UnarchiveChatsSetting) + return target; +} + +size_t SyncActionValue_UnarchiveChatsSetting::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.UnarchiveChatsSetting) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional bool unarchiveChats = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 1; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_UnarchiveChatsSetting::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncActionValue_UnarchiveChatsSetting::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_UnarchiveChatsSetting::GetClassData() const { return &_class_data_; } + + +void SyncActionValue_UnarchiveChatsSetting::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.UnarchiveChatsSetting) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_unarchivechats()) { + _this->_internal_set_unarchivechats(from._internal_unarchivechats()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncActionValue_UnarchiveChatsSetting::CopyFrom(const SyncActionValue_UnarchiveChatsSetting& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.UnarchiveChatsSetting) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncActionValue_UnarchiveChatsSetting::IsInitialized() const { + return true; +} + +void SyncActionValue_UnarchiveChatsSetting::InternalSwap(SyncActionValue_UnarchiveChatsSetting* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_.unarchivechats_, other->_impl_.unarchivechats_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_UnarchiveChatsSetting::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[202]); +} + +// =================================================================== + +class SyncActionValue_UserStatusMuteAction::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_muted(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +SyncActionValue_UserStatusMuteAction::SyncActionValue_UserStatusMuteAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.UserStatusMuteAction) +} +SyncActionValue_UserStatusMuteAction::SyncActionValue_UserStatusMuteAction(const SyncActionValue_UserStatusMuteAction& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncActionValue_UserStatusMuteAction* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.muted_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _this->_impl_.muted_ = from._impl_.muted_; + // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.UserStatusMuteAction) +} + +inline void SyncActionValue_UserStatusMuteAction::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.muted_){false} + }; +} + +SyncActionValue_UserStatusMuteAction::~SyncActionValue_UserStatusMuteAction() { + // @@protoc_insertion_point(destructor:proto.SyncActionValue.UserStatusMuteAction) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncActionValue_UserStatusMuteAction::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void SyncActionValue_UserStatusMuteAction::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncActionValue_UserStatusMuteAction::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.UserStatusMuteAction) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.muted_ = false; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncActionValue_UserStatusMuteAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bool muted = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_muted(&has_bits); + _impl_.muted_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncActionValue_UserStatusMuteAction::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.UserStatusMuteAction) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bool muted = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_muted(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.UserStatusMuteAction) + return target; +} + +size_t SyncActionValue_UserStatusMuteAction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.UserStatusMuteAction) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional bool muted = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 1; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_UserStatusMuteAction::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncActionValue_UserStatusMuteAction::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_UserStatusMuteAction::GetClassData() const { return &_class_data_; } + + +void SyncActionValue_UserStatusMuteAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.UserStatusMuteAction) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_muted()) { + _this->_internal_set_muted(from._internal_muted()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncActionValue_UserStatusMuteAction::CopyFrom(const SyncActionValue_UserStatusMuteAction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.UserStatusMuteAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncActionValue_UserStatusMuteAction::IsInitialized() const { + return true; +} + +void SyncActionValue_UserStatusMuteAction::InternalSwap(SyncActionValue_UserStatusMuteAction* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_.muted_, other->_impl_.muted_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_UserStatusMuteAction::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[203]); +} + +// =================================================================== + +class SyncActionValue::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_timestamp(HasBits* has_bits) { + (*has_bits)[0] |= 134217728u; + } + static const ::proto::SyncActionValue_StarAction& staraction(const SyncActionValue* msg); + static void set_has_staraction(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::proto::SyncActionValue_ContactAction& contactaction(const SyncActionValue* msg); + static void set_has_contactaction(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::proto::SyncActionValue_MuteAction& muteaction(const SyncActionValue* msg); + static void set_has_muteaction(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static const ::proto::SyncActionValue_PinAction& pinaction(const SyncActionValue* msg); + static void set_has_pinaction(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static const ::proto::SyncActionValue_SecurityNotificationSetting& securitynotificationsetting(const SyncActionValue* msg); + static void set_has_securitynotificationsetting(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static const ::proto::SyncActionValue_PushNameSetting& pushnamesetting(const SyncActionValue* msg); + static void set_has_pushnamesetting(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static const ::proto::SyncActionValue_QuickReplyAction& quickreplyaction(const SyncActionValue* msg); + static void set_has_quickreplyaction(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static const ::proto::SyncActionValue_RecentEmojiWeightsAction& recentemojiweightsaction(const SyncActionValue* msg); + static void set_has_recentemojiweightsaction(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static const ::proto::SyncActionValue_LabelEditAction& labeleditaction(const SyncActionValue* msg); + static void set_has_labeleditaction(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static const ::proto::SyncActionValue_LabelAssociationAction& labelassociationaction(const SyncActionValue* msg); + static void set_has_labelassociationaction(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static const ::proto::SyncActionValue_LocaleSetting& localesetting(const SyncActionValue* msg); + static void set_has_localesetting(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static const ::proto::SyncActionValue_ArchiveChatAction& archivechataction(const SyncActionValue* msg); + static void set_has_archivechataction(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static const ::proto::SyncActionValue_DeleteMessageForMeAction& deletemessageformeaction(const SyncActionValue* msg); + static void set_has_deletemessageformeaction(HasBits* has_bits) { + (*has_bits)[0] |= 4096u; + } + static const ::proto::SyncActionValue_KeyExpiration& keyexpiration(const SyncActionValue* msg); + static void set_has_keyexpiration(HasBits* has_bits) { + (*has_bits)[0] |= 8192u; + } + static const ::proto::SyncActionValue_MarkChatAsReadAction& markchatasreadaction(const SyncActionValue* msg); + static void set_has_markchatasreadaction(HasBits* has_bits) { + (*has_bits)[0] |= 16384u; + } + static const ::proto::SyncActionValue_ClearChatAction& clearchataction(const SyncActionValue* msg); + static void set_has_clearchataction(HasBits* has_bits) { + (*has_bits)[0] |= 32768u; + } + static const ::proto::SyncActionValue_DeleteChatAction& deletechataction(const SyncActionValue* msg); + static void set_has_deletechataction(HasBits* has_bits) { + (*has_bits)[0] |= 65536u; + } + static const ::proto::SyncActionValue_UnarchiveChatsSetting& unarchivechatssetting(const SyncActionValue* msg); + static void set_has_unarchivechatssetting(HasBits* has_bits) { + (*has_bits)[0] |= 131072u; + } + static const ::proto::SyncActionValue_PrimaryFeature& primaryfeature(const SyncActionValue* msg); + static void set_has_primaryfeature(HasBits* has_bits) { + (*has_bits)[0] |= 262144u; + } + static const ::proto::SyncActionValue_AndroidUnsupportedActions& androidunsupportedactions(const SyncActionValue* msg); + static void set_has_androidunsupportedactions(HasBits* has_bits) { + (*has_bits)[0] |= 524288u; + } + static const ::proto::SyncActionValue_AgentAction& agentaction(const SyncActionValue* msg); + static void set_has_agentaction(HasBits* has_bits) { + (*has_bits)[0] |= 1048576u; + } + static const ::proto::SyncActionValue_SubscriptionAction& subscriptionaction(const SyncActionValue* msg); + static void set_has_subscriptionaction(HasBits* has_bits) { + (*has_bits)[0] |= 2097152u; + } + static const ::proto::SyncActionValue_UserStatusMuteAction& userstatusmuteaction(const SyncActionValue* msg); + static void set_has_userstatusmuteaction(HasBits* has_bits) { + (*has_bits)[0] |= 4194304u; + } + static const ::proto::SyncActionValue_TimeFormatAction& timeformataction(const SyncActionValue* msg); + static void set_has_timeformataction(HasBits* has_bits) { + (*has_bits)[0] |= 8388608u; + } + static const ::proto::SyncActionValue_NuxAction& nuxaction(const SyncActionValue* msg); + static void set_has_nuxaction(HasBits* has_bits) { + (*has_bits)[0] |= 16777216u; + } + static const ::proto::SyncActionValue_PrimaryVersionAction& primaryversionaction(const SyncActionValue* msg); + static void set_has_primaryversionaction(HasBits* has_bits) { + (*has_bits)[0] |= 33554432u; + } + static const ::proto::SyncActionValue_StickerAction& stickeraction(const SyncActionValue* msg); + static void set_has_stickeraction(HasBits* has_bits) { + (*has_bits)[0] |= 67108864u; + } +}; + +const ::proto::SyncActionValue_StarAction& +SyncActionValue::_Internal::staraction(const SyncActionValue* msg) { + return *msg->_impl_.staraction_; +} +const ::proto::SyncActionValue_ContactAction& +SyncActionValue::_Internal::contactaction(const SyncActionValue* msg) { + return *msg->_impl_.contactaction_; +} +const ::proto::SyncActionValue_MuteAction& +SyncActionValue::_Internal::muteaction(const SyncActionValue* msg) { + return *msg->_impl_.muteaction_; +} +const ::proto::SyncActionValue_PinAction& +SyncActionValue::_Internal::pinaction(const SyncActionValue* msg) { + return *msg->_impl_.pinaction_; +} +const ::proto::SyncActionValue_SecurityNotificationSetting& +SyncActionValue::_Internal::securitynotificationsetting(const SyncActionValue* msg) { + return *msg->_impl_.securitynotificationsetting_; +} +const ::proto::SyncActionValue_PushNameSetting& +SyncActionValue::_Internal::pushnamesetting(const SyncActionValue* msg) { + return *msg->_impl_.pushnamesetting_; +} +const ::proto::SyncActionValue_QuickReplyAction& +SyncActionValue::_Internal::quickreplyaction(const SyncActionValue* msg) { + return *msg->_impl_.quickreplyaction_; +} +const ::proto::SyncActionValue_RecentEmojiWeightsAction& +SyncActionValue::_Internal::recentemojiweightsaction(const SyncActionValue* msg) { + return *msg->_impl_.recentemojiweightsaction_; +} +const ::proto::SyncActionValue_LabelEditAction& +SyncActionValue::_Internal::labeleditaction(const SyncActionValue* msg) { + return *msg->_impl_.labeleditaction_; +} +const ::proto::SyncActionValue_LabelAssociationAction& +SyncActionValue::_Internal::labelassociationaction(const SyncActionValue* msg) { + return *msg->_impl_.labelassociationaction_; +} +const ::proto::SyncActionValue_LocaleSetting& +SyncActionValue::_Internal::localesetting(const SyncActionValue* msg) { + return *msg->_impl_.localesetting_; +} +const ::proto::SyncActionValue_ArchiveChatAction& +SyncActionValue::_Internal::archivechataction(const SyncActionValue* msg) { + return *msg->_impl_.archivechataction_; +} +const ::proto::SyncActionValue_DeleteMessageForMeAction& +SyncActionValue::_Internal::deletemessageformeaction(const SyncActionValue* msg) { + return *msg->_impl_.deletemessageformeaction_; +} +const ::proto::SyncActionValue_KeyExpiration& +SyncActionValue::_Internal::keyexpiration(const SyncActionValue* msg) { + return *msg->_impl_.keyexpiration_; +} +const ::proto::SyncActionValue_MarkChatAsReadAction& +SyncActionValue::_Internal::markchatasreadaction(const SyncActionValue* msg) { + return *msg->_impl_.markchatasreadaction_; +} +const ::proto::SyncActionValue_ClearChatAction& +SyncActionValue::_Internal::clearchataction(const SyncActionValue* msg) { + return *msg->_impl_.clearchataction_; +} +const ::proto::SyncActionValue_DeleteChatAction& +SyncActionValue::_Internal::deletechataction(const SyncActionValue* msg) { + return *msg->_impl_.deletechataction_; +} +const ::proto::SyncActionValue_UnarchiveChatsSetting& +SyncActionValue::_Internal::unarchivechatssetting(const SyncActionValue* msg) { + return *msg->_impl_.unarchivechatssetting_; +} +const ::proto::SyncActionValue_PrimaryFeature& +SyncActionValue::_Internal::primaryfeature(const SyncActionValue* msg) { + return *msg->_impl_.primaryfeature_; +} +const ::proto::SyncActionValue_AndroidUnsupportedActions& +SyncActionValue::_Internal::androidunsupportedactions(const SyncActionValue* msg) { + return *msg->_impl_.androidunsupportedactions_; +} +const ::proto::SyncActionValue_AgentAction& +SyncActionValue::_Internal::agentaction(const SyncActionValue* msg) { + return *msg->_impl_.agentaction_; +} +const ::proto::SyncActionValue_SubscriptionAction& +SyncActionValue::_Internal::subscriptionaction(const SyncActionValue* msg) { + return *msg->_impl_.subscriptionaction_; +} +const ::proto::SyncActionValue_UserStatusMuteAction& +SyncActionValue::_Internal::userstatusmuteaction(const SyncActionValue* msg) { + return *msg->_impl_.userstatusmuteaction_; +} +const ::proto::SyncActionValue_TimeFormatAction& +SyncActionValue::_Internal::timeformataction(const SyncActionValue* msg) { + return *msg->_impl_.timeformataction_; +} +const ::proto::SyncActionValue_NuxAction& +SyncActionValue::_Internal::nuxaction(const SyncActionValue* msg) { + return *msg->_impl_.nuxaction_; +} +const ::proto::SyncActionValue_PrimaryVersionAction& +SyncActionValue::_Internal::primaryversionaction(const SyncActionValue* msg) { + return *msg->_impl_.primaryversionaction_; +} +const ::proto::SyncActionValue_StickerAction& +SyncActionValue::_Internal::stickeraction(const SyncActionValue* msg) { + return *msg->_impl_.stickeraction_; +} +SyncActionValue::SyncActionValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue) +} +SyncActionValue::SyncActionValue(const SyncActionValue& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncActionValue* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.staraction_){nullptr} + , decltype(_impl_.contactaction_){nullptr} + , decltype(_impl_.muteaction_){nullptr} + , decltype(_impl_.pinaction_){nullptr} + , decltype(_impl_.securitynotificationsetting_){nullptr} + , decltype(_impl_.pushnamesetting_){nullptr} + , decltype(_impl_.quickreplyaction_){nullptr} + , decltype(_impl_.recentemojiweightsaction_){nullptr} + , decltype(_impl_.labeleditaction_){nullptr} + , decltype(_impl_.labelassociationaction_){nullptr} + , decltype(_impl_.localesetting_){nullptr} + , decltype(_impl_.archivechataction_){nullptr} + , decltype(_impl_.deletemessageformeaction_){nullptr} + , decltype(_impl_.keyexpiration_){nullptr} + , decltype(_impl_.markchatasreadaction_){nullptr} + , decltype(_impl_.clearchataction_){nullptr} + , decltype(_impl_.deletechataction_){nullptr} + , decltype(_impl_.unarchivechatssetting_){nullptr} + , decltype(_impl_.primaryfeature_){nullptr} + , decltype(_impl_.androidunsupportedactions_){nullptr} + , decltype(_impl_.agentaction_){nullptr} + , decltype(_impl_.subscriptionaction_){nullptr} + , decltype(_impl_.userstatusmuteaction_){nullptr} + , decltype(_impl_.timeformataction_){nullptr} + , decltype(_impl_.nuxaction_){nullptr} + , decltype(_impl_.primaryversionaction_){nullptr} + , decltype(_impl_.stickeraction_){nullptr} + , decltype(_impl_.timestamp_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_staraction()) { + _this->_impl_.staraction_ = new ::proto::SyncActionValue_StarAction(*from._impl_.staraction_); + } + if (from._internal_has_contactaction()) { + _this->_impl_.contactaction_ = new ::proto::SyncActionValue_ContactAction(*from._impl_.contactaction_); + } + if (from._internal_has_muteaction()) { + _this->_impl_.muteaction_ = new ::proto::SyncActionValue_MuteAction(*from._impl_.muteaction_); + } + if (from._internal_has_pinaction()) { + _this->_impl_.pinaction_ = new ::proto::SyncActionValue_PinAction(*from._impl_.pinaction_); + } + if (from._internal_has_securitynotificationsetting()) { + _this->_impl_.securitynotificationsetting_ = new ::proto::SyncActionValue_SecurityNotificationSetting(*from._impl_.securitynotificationsetting_); + } + if (from._internal_has_pushnamesetting()) { + _this->_impl_.pushnamesetting_ = new ::proto::SyncActionValue_PushNameSetting(*from._impl_.pushnamesetting_); + } + if (from._internal_has_quickreplyaction()) { + _this->_impl_.quickreplyaction_ = new ::proto::SyncActionValue_QuickReplyAction(*from._impl_.quickreplyaction_); + } + if (from._internal_has_recentemojiweightsaction()) { + _this->_impl_.recentemojiweightsaction_ = new ::proto::SyncActionValue_RecentEmojiWeightsAction(*from._impl_.recentemojiweightsaction_); + } + if (from._internal_has_labeleditaction()) { + _this->_impl_.labeleditaction_ = new ::proto::SyncActionValue_LabelEditAction(*from._impl_.labeleditaction_); + } + if (from._internal_has_labelassociationaction()) { + _this->_impl_.labelassociationaction_ = new ::proto::SyncActionValue_LabelAssociationAction(*from._impl_.labelassociationaction_); + } + if (from._internal_has_localesetting()) { + _this->_impl_.localesetting_ = new ::proto::SyncActionValue_LocaleSetting(*from._impl_.localesetting_); + } + if (from._internal_has_archivechataction()) { + _this->_impl_.archivechataction_ = new ::proto::SyncActionValue_ArchiveChatAction(*from._impl_.archivechataction_); + } + if (from._internal_has_deletemessageformeaction()) { + _this->_impl_.deletemessageformeaction_ = new ::proto::SyncActionValue_DeleteMessageForMeAction(*from._impl_.deletemessageformeaction_); + } + if (from._internal_has_keyexpiration()) { + _this->_impl_.keyexpiration_ = new ::proto::SyncActionValue_KeyExpiration(*from._impl_.keyexpiration_); + } + if (from._internal_has_markchatasreadaction()) { + _this->_impl_.markchatasreadaction_ = new ::proto::SyncActionValue_MarkChatAsReadAction(*from._impl_.markchatasreadaction_); + } + if (from._internal_has_clearchataction()) { + _this->_impl_.clearchataction_ = new ::proto::SyncActionValue_ClearChatAction(*from._impl_.clearchataction_); + } + if (from._internal_has_deletechataction()) { + _this->_impl_.deletechataction_ = new ::proto::SyncActionValue_DeleteChatAction(*from._impl_.deletechataction_); + } + if (from._internal_has_unarchivechatssetting()) { + _this->_impl_.unarchivechatssetting_ = new ::proto::SyncActionValue_UnarchiveChatsSetting(*from._impl_.unarchivechatssetting_); + } + if (from._internal_has_primaryfeature()) { + _this->_impl_.primaryfeature_ = new ::proto::SyncActionValue_PrimaryFeature(*from._impl_.primaryfeature_); + } + if (from._internal_has_androidunsupportedactions()) { + _this->_impl_.androidunsupportedactions_ = new ::proto::SyncActionValue_AndroidUnsupportedActions(*from._impl_.androidunsupportedactions_); + } + if (from._internal_has_agentaction()) { + _this->_impl_.agentaction_ = new ::proto::SyncActionValue_AgentAction(*from._impl_.agentaction_); + } + if (from._internal_has_subscriptionaction()) { + _this->_impl_.subscriptionaction_ = new ::proto::SyncActionValue_SubscriptionAction(*from._impl_.subscriptionaction_); + } + if (from._internal_has_userstatusmuteaction()) { + _this->_impl_.userstatusmuteaction_ = new ::proto::SyncActionValue_UserStatusMuteAction(*from._impl_.userstatusmuteaction_); + } + if (from._internal_has_timeformataction()) { + _this->_impl_.timeformataction_ = new ::proto::SyncActionValue_TimeFormatAction(*from._impl_.timeformataction_); + } + if (from._internal_has_nuxaction()) { + _this->_impl_.nuxaction_ = new ::proto::SyncActionValue_NuxAction(*from._impl_.nuxaction_); + } + if (from._internal_has_primaryversionaction()) { + _this->_impl_.primaryversionaction_ = new ::proto::SyncActionValue_PrimaryVersionAction(*from._impl_.primaryversionaction_); + } + if (from._internal_has_stickeraction()) { + _this->_impl_.stickeraction_ = new ::proto::SyncActionValue_StickerAction(*from._impl_.stickeraction_); + } + _this->_impl_.timestamp_ = from._impl_.timestamp_; + // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue) +} + +inline void SyncActionValue::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.staraction_){nullptr} + , decltype(_impl_.contactaction_){nullptr} + , decltype(_impl_.muteaction_){nullptr} + , decltype(_impl_.pinaction_){nullptr} + , decltype(_impl_.securitynotificationsetting_){nullptr} + , decltype(_impl_.pushnamesetting_){nullptr} + , decltype(_impl_.quickreplyaction_){nullptr} + , decltype(_impl_.recentemojiweightsaction_){nullptr} + , decltype(_impl_.labeleditaction_){nullptr} + , decltype(_impl_.labelassociationaction_){nullptr} + , decltype(_impl_.localesetting_){nullptr} + , decltype(_impl_.archivechataction_){nullptr} + , decltype(_impl_.deletemessageformeaction_){nullptr} + , decltype(_impl_.keyexpiration_){nullptr} + , decltype(_impl_.markchatasreadaction_){nullptr} + , decltype(_impl_.clearchataction_){nullptr} + , decltype(_impl_.deletechataction_){nullptr} + , decltype(_impl_.unarchivechatssetting_){nullptr} + , decltype(_impl_.primaryfeature_){nullptr} + , decltype(_impl_.androidunsupportedactions_){nullptr} + , decltype(_impl_.agentaction_){nullptr} + , decltype(_impl_.subscriptionaction_){nullptr} + , decltype(_impl_.userstatusmuteaction_){nullptr} + , decltype(_impl_.timeformataction_){nullptr} + , decltype(_impl_.nuxaction_){nullptr} + , decltype(_impl_.primaryversionaction_){nullptr} + , decltype(_impl_.stickeraction_){nullptr} + , decltype(_impl_.timestamp_){int64_t{0}} + }; +} + +SyncActionValue::~SyncActionValue() { + // @@protoc_insertion_point(destructor:proto.SyncActionValue) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncActionValue::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.staraction_; + if (this != internal_default_instance()) delete _impl_.contactaction_; + if (this != internal_default_instance()) delete _impl_.muteaction_; + if (this != internal_default_instance()) delete _impl_.pinaction_; + if (this != internal_default_instance()) delete _impl_.securitynotificationsetting_; + if (this != internal_default_instance()) delete _impl_.pushnamesetting_; + if (this != internal_default_instance()) delete _impl_.quickreplyaction_; + if (this != internal_default_instance()) delete _impl_.recentemojiweightsaction_; + if (this != internal_default_instance()) delete _impl_.labeleditaction_; + if (this != internal_default_instance()) delete _impl_.labelassociationaction_; + if (this != internal_default_instance()) delete _impl_.localesetting_; + if (this != internal_default_instance()) delete _impl_.archivechataction_; + if (this != internal_default_instance()) delete _impl_.deletemessageformeaction_; + if (this != internal_default_instance()) delete _impl_.keyexpiration_; + if (this != internal_default_instance()) delete _impl_.markchatasreadaction_; + if (this != internal_default_instance()) delete _impl_.clearchataction_; + if (this != internal_default_instance()) delete _impl_.deletechataction_; + if (this != internal_default_instance()) delete _impl_.unarchivechatssetting_; + if (this != internal_default_instance()) delete _impl_.primaryfeature_; + if (this != internal_default_instance()) delete _impl_.androidunsupportedactions_; + if (this != internal_default_instance()) delete _impl_.agentaction_; + if (this != internal_default_instance()) delete _impl_.subscriptionaction_; + if (this != internal_default_instance()) delete _impl_.userstatusmuteaction_; + if (this != internal_default_instance()) delete _impl_.timeformataction_; + if (this != internal_default_instance()) delete _impl_.nuxaction_; + if (this != internal_default_instance()) delete _impl_.primaryversionaction_; + if (this != internal_default_instance()) delete _impl_.stickeraction_; +} + +void SyncActionValue::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncActionValue::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.staraction_ != nullptr); + _impl_.staraction_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.contactaction_ != nullptr); + _impl_.contactaction_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.muteaction_ != nullptr); + _impl_.muteaction_->Clear(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(_impl_.pinaction_ != nullptr); + _impl_.pinaction_->Clear(); + } + if (cached_has_bits & 0x00000010u) { + GOOGLE_DCHECK(_impl_.securitynotificationsetting_ != nullptr); + _impl_.securitynotificationsetting_->Clear(); + } + if (cached_has_bits & 0x00000020u) { + GOOGLE_DCHECK(_impl_.pushnamesetting_ != nullptr); + _impl_.pushnamesetting_->Clear(); + } + if (cached_has_bits & 0x00000040u) { + GOOGLE_DCHECK(_impl_.quickreplyaction_ != nullptr); + _impl_.quickreplyaction_->Clear(); + } + if (cached_has_bits & 0x00000080u) { + GOOGLE_DCHECK(_impl_.recentemojiweightsaction_ != nullptr); + _impl_.recentemojiweightsaction_->Clear(); + } + } + if (cached_has_bits & 0x0000ff00u) { + if (cached_has_bits & 0x00000100u) { + GOOGLE_DCHECK(_impl_.labeleditaction_ != nullptr); + _impl_.labeleditaction_->Clear(); + } + if (cached_has_bits & 0x00000200u) { + GOOGLE_DCHECK(_impl_.labelassociationaction_ != nullptr); + _impl_.labelassociationaction_->Clear(); + } + if (cached_has_bits & 0x00000400u) { + GOOGLE_DCHECK(_impl_.localesetting_ != nullptr); + _impl_.localesetting_->Clear(); + } + if (cached_has_bits & 0x00000800u) { + GOOGLE_DCHECK(_impl_.archivechataction_ != nullptr); + _impl_.archivechataction_->Clear(); + } + if (cached_has_bits & 0x00001000u) { + GOOGLE_DCHECK(_impl_.deletemessageformeaction_ != nullptr); + _impl_.deletemessageformeaction_->Clear(); + } + if (cached_has_bits & 0x00002000u) { + GOOGLE_DCHECK(_impl_.keyexpiration_ != nullptr); + _impl_.keyexpiration_->Clear(); + } + if (cached_has_bits & 0x00004000u) { + GOOGLE_DCHECK(_impl_.markchatasreadaction_ != nullptr); + _impl_.markchatasreadaction_->Clear(); + } + if (cached_has_bits & 0x00008000u) { + GOOGLE_DCHECK(_impl_.clearchataction_ != nullptr); + _impl_.clearchataction_->Clear(); + } + } + if (cached_has_bits & 0x00ff0000u) { + if (cached_has_bits & 0x00010000u) { + GOOGLE_DCHECK(_impl_.deletechataction_ != nullptr); + _impl_.deletechataction_->Clear(); + } + if (cached_has_bits & 0x00020000u) { + GOOGLE_DCHECK(_impl_.unarchivechatssetting_ != nullptr); + _impl_.unarchivechatssetting_->Clear(); + } + if (cached_has_bits & 0x00040000u) { + GOOGLE_DCHECK(_impl_.primaryfeature_ != nullptr); + _impl_.primaryfeature_->Clear(); + } + if (cached_has_bits & 0x00080000u) { + GOOGLE_DCHECK(_impl_.androidunsupportedactions_ != nullptr); + _impl_.androidunsupportedactions_->Clear(); + } + if (cached_has_bits & 0x00100000u) { + GOOGLE_DCHECK(_impl_.agentaction_ != nullptr); + _impl_.agentaction_->Clear(); + } + if (cached_has_bits & 0x00200000u) { + GOOGLE_DCHECK(_impl_.subscriptionaction_ != nullptr); + _impl_.subscriptionaction_->Clear(); + } + if (cached_has_bits & 0x00400000u) { + GOOGLE_DCHECK(_impl_.userstatusmuteaction_ != nullptr); + _impl_.userstatusmuteaction_->Clear(); + } + if (cached_has_bits & 0x00800000u) { + GOOGLE_DCHECK(_impl_.timeformataction_ != nullptr); + _impl_.timeformataction_->Clear(); + } + } + if (cached_has_bits & 0x07000000u) { + if (cached_has_bits & 0x01000000u) { + GOOGLE_DCHECK(_impl_.nuxaction_ != nullptr); + _impl_.nuxaction_->Clear(); + } + if (cached_has_bits & 0x02000000u) { + GOOGLE_DCHECK(_impl_.primaryversionaction_ != nullptr); + _impl_.primaryversionaction_->Clear(); + } + if (cached_has_bits & 0x04000000u) { + GOOGLE_DCHECK(_impl_.stickeraction_ != nullptr); + _impl_.stickeraction_->Clear(); + } + } + _impl_.timestamp_ = int64_t{0}; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncActionValue::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional int64 timestamp = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_timestamp(&has_bits); + _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SyncActionValue.StarAction starAction = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_staraction(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SyncActionValue.ContactAction contactAction = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_contactaction(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SyncActionValue.MuteAction muteAction = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_muteaction(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SyncActionValue.PinAction pinAction = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_pinaction(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SyncActionValue.SecurityNotificationSetting securityNotificationSetting = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_securitynotificationsetting(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SyncActionValue.PushNameSetting pushNameSetting = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_pushnamesetting(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SyncActionValue.QuickReplyAction quickReplyAction = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + ptr = ctx->ParseMessage(_internal_mutable_quickreplyaction(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SyncActionValue.RecentEmojiWeightsAction recentEmojiWeightsAction = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { + ptr = ctx->ParseMessage(_internal_mutable_recentemojiweightsaction(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SyncActionValue.LabelEditAction labelEditAction = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) { + ptr = ctx->ParseMessage(_internal_mutable_labeleditaction(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SyncActionValue.LabelAssociationAction labelAssociationAction = 15; + case 15: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { + ptr = ctx->ParseMessage(_internal_mutable_labelassociationaction(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SyncActionValue.LocaleSetting localeSetting = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { + ptr = ctx->ParseMessage(_internal_mutable_localesetting(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SyncActionValue.ArchiveChatAction archiveChatAction = 17; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { + ptr = ctx->ParseMessage(_internal_mutable_archivechataction(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SyncActionValue.DeleteMessageForMeAction deleteMessageForMeAction = 18; + case 18: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { + ptr = ctx->ParseMessage(_internal_mutable_deletemessageformeaction(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SyncActionValue.KeyExpiration keyExpiration = 19; + case 19: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) { + ptr = ctx->ParseMessage(_internal_mutable_keyexpiration(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SyncActionValue.MarkChatAsReadAction markChatAsReadAction = 20; + case 20: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 162)) { + ptr = ctx->ParseMessage(_internal_mutable_markchatasreadaction(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SyncActionValue.ClearChatAction clearChatAction = 21; + case 21: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { + ptr = ctx->ParseMessage(_internal_mutable_clearchataction(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SyncActionValue.DeleteChatAction deleteChatAction = 22; + case 22: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 178)) { + ptr = ctx->ParseMessage(_internal_mutable_deletechataction(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SyncActionValue.UnarchiveChatsSetting unarchiveChatsSetting = 23; + case 23: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { + ptr = ctx->ParseMessage(_internal_mutable_unarchivechatssetting(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SyncActionValue.PrimaryFeature primaryFeature = 24; + case 24: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 194)) { + ptr = ctx->ParseMessage(_internal_mutable_primaryfeature(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SyncActionValue.AndroidUnsupportedActions androidUnsupportedActions = 26; + case 26: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 210)) { + ptr = ctx->ParseMessage(_internal_mutable_androidunsupportedactions(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SyncActionValue.AgentAction agentAction = 27; + case 27: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 218)) { + ptr = ctx->ParseMessage(_internal_mutable_agentaction(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SyncActionValue.SubscriptionAction subscriptionAction = 28; + case 28: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 226)) { + ptr = ctx->ParseMessage(_internal_mutable_subscriptionaction(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SyncActionValue.UserStatusMuteAction userStatusMuteAction = 29; + case 29: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 234)) { + ptr = ctx->ParseMessage(_internal_mutable_userstatusmuteaction(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SyncActionValue.TimeFormatAction timeFormatAction = 30; + case 30: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 242)) { + ptr = ctx->ParseMessage(_internal_mutable_timeformataction(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SyncActionValue.NuxAction nuxAction = 31; + case 31: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 250)) { + ptr = ctx->ParseMessage(_internal_mutable_nuxaction(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SyncActionValue.PrimaryVersionAction primaryVersionAction = 32; + case 32: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 2)) { + ptr = ctx->ParseMessage(_internal_mutable_primaryversionaction(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SyncActionValue.StickerAction stickerAction = 33; + case 33: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_stickeraction(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncActionValue::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional int64 timestamp = 1; + if (cached_has_bits & 0x08000000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_timestamp(), target); + } + + // optional .proto.SyncActionValue.StarAction starAction = 2; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::staraction(this), + _Internal::staraction(this).GetCachedSize(), target, stream); + } + + // optional .proto.SyncActionValue.ContactAction contactAction = 3; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::contactaction(this), + _Internal::contactaction(this).GetCachedSize(), target, stream); + } + + // optional .proto.SyncActionValue.MuteAction muteAction = 4; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, _Internal::muteaction(this), + _Internal::muteaction(this).GetCachedSize(), target, stream); + } + + // optional .proto.SyncActionValue.PinAction pinAction = 5; + if (cached_has_bits & 0x00000008u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(5, _Internal::pinaction(this), + _Internal::pinaction(this).GetCachedSize(), target, stream); + } + + // optional .proto.SyncActionValue.SecurityNotificationSetting securityNotificationSetting = 6; + if (cached_has_bits & 0x00000010u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(6, _Internal::securitynotificationsetting(this), + _Internal::securitynotificationsetting(this).GetCachedSize(), target, stream); + } + + // optional .proto.SyncActionValue.PushNameSetting pushNameSetting = 7; + if (cached_has_bits & 0x00000020u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(7, _Internal::pushnamesetting(this), + _Internal::pushnamesetting(this).GetCachedSize(), target, stream); + } + + // optional .proto.SyncActionValue.QuickReplyAction quickReplyAction = 8; + if (cached_has_bits & 0x00000040u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(8, _Internal::quickreplyaction(this), + _Internal::quickreplyaction(this).GetCachedSize(), target, stream); + } + + // optional .proto.SyncActionValue.RecentEmojiWeightsAction recentEmojiWeightsAction = 11; + if (cached_has_bits & 0x00000080u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(11, _Internal::recentemojiweightsaction(this), + _Internal::recentemojiweightsaction(this).GetCachedSize(), target, stream); + } + + // optional .proto.SyncActionValue.LabelEditAction labelEditAction = 14; + if (cached_has_bits & 0x00000100u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(14, _Internal::labeleditaction(this), + _Internal::labeleditaction(this).GetCachedSize(), target, stream); + } + + // optional .proto.SyncActionValue.LabelAssociationAction labelAssociationAction = 15; + if (cached_has_bits & 0x00000200u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(15, _Internal::labelassociationaction(this), + _Internal::labelassociationaction(this).GetCachedSize(), target, stream); + } + + // optional .proto.SyncActionValue.LocaleSetting localeSetting = 16; + if (cached_has_bits & 0x00000400u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(16, _Internal::localesetting(this), + _Internal::localesetting(this).GetCachedSize(), target, stream); + } + + // optional .proto.SyncActionValue.ArchiveChatAction archiveChatAction = 17; + if (cached_has_bits & 0x00000800u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(17, _Internal::archivechataction(this), + _Internal::archivechataction(this).GetCachedSize(), target, stream); + } + + // optional .proto.SyncActionValue.DeleteMessageForMeAction deleteMessageForMeAction = 18; + if (cached_has_bits & 0x00001000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(18, _Internal::deletemessageformeaction(this), + _Internal::deletemessageformeaction(this).GetCachedSize(), target, stream); + } + + // optional .proto.SyncActionValue.KeyExpiration keyExpiration = 19; + if (cached_has_bits & 0x00002000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(19, _Internal::keyexpiration(this), + _Internal::keyexpiration(this).GetCachedSize(), target, stream); + } + + // optional .proto.SyncActionValue.MarkChatAsReadAction markChatAsReadAction = 20; + if (cached_has_bits & 0x00004000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(20, _Internal::markchatasreadaction(this), + _Internal::markchatasreadaction(this).GetCachedSize(), target, stream); + } + + // optional .proto.SyncActionValue.ClearChatAction clearChatAction = 21; + if (cached_has_bits & 0x00008000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(21, _Internal::clearchataction(this), + _Internal::clearchataction(this).GetCachedSize(), target, stream); + } + + // optional .proto.SyncActionValue.DeleteChatAction deleteChatAction = 22; + if (cached_has_bits & 0x00010000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(22, _Internal::deletechataction(this), + _Internal::deletechataction(this).GetCachedSize(), target, stream); + } + + // optional .proto.SyncActionValue.UnarchiveChatsSetting unarchiveChatsSetting = 23; + if (cached_has_bits & 0x00020000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(23, _Internal::unarchivechatssetting(this), + _Internal::unarchivechatssetting(this).GetCachedSize(), target, stream); + } + + // optional .proto.SyncActionValue.PrimaryFeature primaryFeature = 24; + if (cached_has_bits & 0x00040000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(24, _Internal::primaryfeature(this), + _Internal::primaryfeature(this).GetCachedSize(), target, stream); + } + + // optional .proto.SyncActionValue.AndroidUnsupportedActions androidUnsupportedActions = 26; + if (cached_has_bits & 0x00080000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(26, _Internal::androidunsupportedactions(this), + _Internal::androidunsupportedactions(this).GetCachedSize(), target, stream); + } + + // optional .proto.SyncActionValue.AgentAction agentAction = 27; + if (cached_has_bits & 0x00100000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(27, _Internal::agentaction(this), + _Internal::agentaction(this).GetCachedSize(), target, stream); + } + + // optional .proto.SyncActionValue.SubscriptionAction subscriptionAction = 28; + if (cached_has_bits & 0x00200000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(28, _Internal::subscriptionaction(this), + _Internal::subscriptionaction(this).GetCachedSize(), target, stream); + } + + // optional .proto.SyncActionValue.UserStatusMuteAction userStatusMuteAction = 29; + if (cached_has_bits & 0x00400000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(29, _Internal::userstatusmuteaction(this), + _Internal::userstatusmuteaction(this).GetCachedSize(), target, stream); + } + + // optional .proto.SyncActionValue.TimeFormatAction timeFormatAction = 30; + if (cached_has_bits & 0x00800000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(30, _Internal::timeformataction(this), + _Internal::timeformataction(this).GetCachedSize(), target, stream); + } + + // optional .proto.SyncActionValue.NuxAction nuxAction = 31; + if (cached_has_bits & 0x01000000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(31, _Internal::nuxaction(this), + _Internal::nuxaction(this).GetCachedSize(), target, stream); + } + + // optional .proto.SyncActionValue.PrimaryVersionAction primaryVersionAction = 32; + if (cached_has_bits & 0x02000000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(32, _Internal::primaryversionaction(this), + _Internal::primaryversionaction(this).GetCachedSize(), target, stream); + } + + // optional .proto.SyncActionValue.StickerAction stickerAction = 33; + if (cached_has_bits & 0x04000000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(33, _Internal::stickeraction(this), + _Internal::stickeraction(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue) + return target; +} + +size_t SyncActionValue::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional .proto.SyncActionValue.StarAction starAction = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.staraction_); + } + + // optional .proto.SyncActionValue.ContactAction contactAction = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.contactaction_); + } + + // optional .proto.SyncActionValue.MuteAction muteAction = 4; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.muteaction_); + } + + // optional .proto.SyncActionValue.PinAction pinAction = 5; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.pinaction_); + } + + // optional .proto.SyncActionValue.SecurityNotificationSetting securityNotificationSetting = 6; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.securitynotificationsetting_); + } + + // optional .proto.SyncActionValue.PushNameSetting pushNameSetting = 7; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.pushnamesetting_); + } + + // optional .proto.SyncActionValue.QuickReplyAction quickReplyAction = 8; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.quickreplyaction_); + } + + // optional .proto.SyncActionValue.RecentEmojiWeightsAction recentEmojiWeightsAction = 11; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.recentemojiweightsaction_); + } + + } + if (cached_has_bits & 0x0000ff00u) { + // optional .proto.SyncActionValue.LabelEditAction labelEditAction = 14; + if (cached_has_bits & 0x00000100u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.labeleditaction_); + } + + // optional .proto.SyncActionValue.LabelAssociationAction labelAssociationAction = 15; + if (cached_has_bits & 0x00000200u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.labelassociationaction_); + } + + // optional .proto.SyncActionValue.LocaleSetting localeSetting = 16; + if (cached_has_bits & 0x00000400u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.localesetting_); + } + + // optional .proto.SyncActionValue.ArchiveChatAction archiveChatAction = 17; + if (cached_has_bits & 0x00000800u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.archivechataction_); + } + + // optional .proto.SyncActionValue.DeleteMessageForMeAction deleteMessageForMeAction = 18; + if (cached_has_bits & 0x00001000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.deletemessageformeaction_); + } + + // optional .proto.SyncActionValue.KeyExpiration keyExpiration = 19; + if (cached_has_bits & 0x00002000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.keyexpiration_); + } + + // optional .proto.SyncActionValue.MarkChatAsReadAction markChatAsReadAction = 20; + if (cached_has_bits & 0x00004000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.markchatasreadaction_); + } + + // optional .proto.SyncActionValue.ClearChatAction clearChatAction = 21; + if (cached_has_bits & 0x00008000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.clearchataction_); + } + + } + if (cached_has_bits & 0x00ff0000u) { + // optional .proto.SyncActionValue.DeleteChatAction deleteChatAction = 22; + if (cached_has_bits & 0x00010000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.deletechataction_); + } + + // optional .proto.SyncActionValue.UnarchiveChatsSetting unarchiveChatsSetting = 23; + if (cached_has_bits & 0x00020000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.unarchivechatssetting_); + } + + // optional .proto.SyncActionValue.PrimaryFeature primaryFeature = 24; + if (cached_has_bits & 0x00040000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.primaryfeature_); + } + + // optional .proto.SyncActionValue.AndroidUnsupportedActions androidUnsupportedActions = 26; + if (cached_has_bits & 0x00080000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.androidunsupportedactions_); + } + + // optional .proto.SyncActionValue.AgentAction agentAction = 27; + if (cached_has_bits & 0x00100000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.agentaction_); + } + + // optional .proto.SyncActionValue.SubscriptionAction subscriptionAction = 28; + if (cached_has_bits & 0x00200000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.subscriptionaction_); + } + + // optional .proto.SyncActionValue.UserStatusMuteAction userStatusMuteAction = 29; + if (cached_has_bits & 0x00400000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.userstatusmuteaction_); + } + + // optional .proto.SyncActionValue.TimeFormatAction timeFormatAction = 30; + if (cached_has_bits & 0x00800000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.timeformataction_); + } + + } + if (cached_has_bits & 0x0f000000u) { + // optional .proto.SyncActionValue.NuxAction nuxAction = 31; + if (cached_has_bits & 0x01000000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.nuxaction_); + } + + // optional .proto.SyncActionValue.PrimaryVersionAction primaryVersionAction = 32; + if (cached_has_bits & 0x02000000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.primaryversionaction_); + } + + // optional .proto.SyncActionValue.StickerAction stickerAction = 33; + if (cached_has_bits & 0x04000000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.stickeraction_); + } + + // optional int64 timestamp = 1; + if (cached_has_bits & 0x08000000u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_timestamp()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncActionValue::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue::GetClassData() const { return &_class_data_; } + + +void SyncActionValue::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_staraction()->::proto::SyncActionValue_StarAction::MergeFrom( + from._internal_staraction()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_contactaction()->::proto::SyncActionValue_ContactAction::MergeFrom( + from._internal_contactaction()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_muteaction()->::proto::SyncActionValue_MuteAction::MergeFrom( + from._internal_muteaction()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_mutable_pinaction()->::proto::SyncActionValue_PinAction::MergeFrom( + from._internal_pinaction()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_mutable_securitynotificationsetting()->::proto::SyncActionValue_SecurityNotificationSetting::MergeFrom( + from._internal_securitynotificationsetting()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_mutable_pushnamesetting()->::proto::SyncActionValue_PushNameSetting::MergeFrom( + from._internal_pushnamesetting()); + } + if (cached_has_bits & 0x00000040u) { + _this->_internal_mutable_quickreplyaction()->::proto::SyncActionValue_QuickReplyAction::MergeFrom( + from._internal_quickreplyaction()); + } + if (cached_has_bits & 0x00000080u) { + _this->_internal_mutable_recentemojiweightsaction()->::proto::SyncActionValue_RecentEmojiWeightsAction::MergeFrom( + from._internal_recentemojiweightsaction()); + } + } + if (cached_has_bits & 0x0000ff00u) { + if (cached_has_bits & 0x00000100u) { + _this->_internal_mutable_labeleditaction()->::proto::SyncActionValue_LabelEditAction::MergeFrom( + from._internal_labeleditaction()); + } + if (cached_has_bits & 0x00000200u) { + _this->_internal_mutable_labelassociationaction()->::proto::SyncActionValue_LabelAssociationAction::MergeFrom( + from._internal_labelassociationaction()); + } + if (cached_has_bits & 0x00000400u) { + _this->_internal_mutable_localesetting()->::proto::SyncActionValue_LocaleSetting::MergeFrom( + from._internal_localesetting()); + } + if (cached_has_bits & 0x00000800u) { + _this->_internal_mutable_archivechataction()->::proto::SyncActionValue_ArchiveChatAction::MergeFrom( + from._internal_archivechataction()); + } + if (cached_has_bits & 0x00001000u) { + _this->_internal_mutable_deletemessageformeaction()->::proto::SyncActionValue_DeleteMessageForMeAction::MergeFrom( + from._internal_deletemessageformeaction()); + } + if (cached_has_bits & 0x00002000u) { + _this->_internal_mutable_keyexpiration()->::proto::SyncActionValue_KeyExpiration::MergeFrom( + from._internal_keyexpiration()); + } + if (cached_has_bits & 0x00004000u) { + _this->_internal_mutable_markchatasreadaction()->::proto::SyncActionValue_MarkChatAsReadAction::MergeFrom( + from._internal_markchatasreadaction()); + } + if (cached_has_bits & 0x00008000u) { + _this->_internal_mutable_clearchataction()->::proto::SyncActionValue_ClearChatAction::MergeFrom( + from._internal_clearchataction()); + } + } + if (cached_has_bits & 0x00ff0000u) { + if (cached_has_bits & 0x00010000u) { + _this->_internal_mutable_deletechataction()->::proto::SyncActionValue_DeleteChatAction::MergeFrom( + from._internal_deletechataction()); + } + if (cached_has_bits & 0x00020000u) { + _this->_internal_mutable_unarchivechatssetting()->::proto::SyncActionValue_UnarchiveChatsSetting::MergeFrom( + from._internal_unarchivechatssetting()); + } + if (cached_has_bits & 0x00040000u) { + _this->_internal_mutable_primaryfeature()->::proto::SyncActionValue_PrimaryFeature::MergeFrom( + from._internal_primaryfeature()); + } + if (cached_has_bits & 0x00080000u) { + _this->_internal_mutable_androidunsupportedactions()->::proto::SyncActionValue_AndroidUnsupportedActions::MergeFrom( + from._internal_androidunsupportedactions()); + } + if (cached_has_bits & 0x00100000u) { + _this->_internal_mutable_agentaction()->::proto::SyncActionValue_AgentAction::MergeFrom( + from._internal_agentaction()); + } + if (cached_has_bits & 0x00200000u) { + _this->_internal_mutable_subscriptionaction()->::proto::SyncActionValue_SubscriptionAction::MergeFrom( + from._internal_subscriptionaction()); + } + if (cached_has_bits & 0x00400000u) { + _this->_internal_mutable_userstatusmuteaction()->::proto::SyncActionValue_UserStatusMuteAction::MergeFrom( + from._internal_userstatusmuteaction()); + } + if (cached_has_bits & 0x00800000u) { + _this->_internal_mutable_timeformataction()->::proto::SyncActionValue_TimeFormatAction::MergeFrom( + from._internal_timeformataction()); + } + } + if (cached_has_bits & 0x0f000000u) { + if (cached_has_bits & 0x01000000u) { + _this->_internal_mutable_nuxaction()->::proto::SyncActionValue_NuxAction::MergeFrom( + from._internal_nuxaction()); + } + if (cached_has_bits & 0x02000000u) { + _this->_internal_mutable_primaryversionaction()->::proto::SyncActionValue_PrimaryVersionAction::MergeFrom( + from._internal_primaryversionaction()); + } + if (cached_has_bits & 0x04000000u) { + _this->_internal_mutable_stickeraction()->::proto::SyncActionValue_StickerAction::MergeFrom( + from._internal_stickeraction()); + } + if (cached_has_bits & 0x08000000u) { + _this->_impl_.timestamp_ = from._impl_.timestamp_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncActionValue::CopyFrom(const SyncActionValue& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncActionValue::IsInitialized() const { + return true; +} + +void SyncActionValue::InternalSwap(SyncActionValue* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SyncActionValue, _impl_.timestamp_) + + sizeof(SyncActionValue::_impl_.timestamp_) + - PROTOBUF_FIELD_OFFSET(SyncActionValue, _impl_.staraction_)>( + reinterpret_cast(&_impl_.staraction_), + reinterpret_cast(&other->_impl_.staraction_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[204]); +} + +// =================================================================== + +class SyncdIndex::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_blob(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +SyncdIndex::SyncdIndex(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncdIndex) +} +SyncdIndex::SyncdIndex(const SyncdIndex& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncdIndex* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.blob_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.blob_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.blob_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_blob()) { + _this->_impl_.blob_.Set(from._internal_blob(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.SyncdIndex) +} + +inline void SyncdIndex::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.blob_){} + }; + _impl_.blob_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.blob_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +SyncdIndex::~SyncdIndex() { + // @@protoc_insertion_point(destructor:proto.SyncdIndex) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncdIndex::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.blob_.Destroy(); +} + +void SyncdIndex::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncdIndex::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncdIndex) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.blob_.ClearNonDefaultToEmpty(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncdIndex::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes blob = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_blob(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncdIndex::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncdIndex) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes blob = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_blob(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncdIndex) + return target; +} + +size_t SyncdIndex::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncdIndex) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional bytes blob = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_blob()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncdIndex::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncdIndex::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncdIndex::GetClassData() const { return &_class_data_; } + + +void SyncdIndex::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncdIndex) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_blob()) { + _this->_internal_set_blob(from._internal_blob()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncdIndex::CopyFrom(const SyncdIndex& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncdIndex) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncdIndex::IsInitialized() const { + return true; +} + +void SyncdIndex::InternalSwap(SyncdIndex* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.blob_, lhs_arena, + &other->_impl_.blob_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncdIndex::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[205]); +} + +// =================================================================== + +class SyncdMutation::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_operation(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::proto::SyncdRecord& record(const SyncdMutation* msg); + static void set_has_record(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +const ::proto::SyncdRecord& +SyncdMutation::_Internal::record(const SyncdMutation* msg) { + return *msg->_impl_.record_; +} +SyncdMutation::SyncdMutation(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncdMutation) +} +SyncdMutation::SyncdMutation(const SyncdMutation& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncdMutation* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.record_){nullptr} + , decltype(_impl_.operation_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_record()) { + _this->_impl_.record_ = new ::proto::SyncdRecord(*from._impl_.record_); + } + _this->_impl_.operation_ = from._impl_.operation_; + // @@protoc_insertion_point(copy_constructor:proto.SyncdMutation) +} + +inline void SyncdMutation::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.record_){nullptr} + , decltype(_impl_.operation_){0} + }; +} + +SyncdMutation::~SyncdMutation() { + // @@protoc_insertion_point(destructor:proto.SyncdMutation) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncdMutation::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.record_; +} + +void SyncdMutation::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncdMutation::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncdMutation) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.record_ != nullptr); + _impl_.record_->Clear(); + } + _impl_.operation_ = 0; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncdMutation::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.SyncdMutation.SyncdOperation operation = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::SyncdMutation_SyncdOperation_IsValid(val))) { + _internal_set_operation(static_cast<::proto::SyncdMutation_SyncdOperation>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.SyncdRecord record = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_record(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncdMutation::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncdMutation) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.SyncdMutation.SyncdOperation operation = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this->_internal_operation(), target); + } + + // optional .proto.SyncdRecord record = 2; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::record(this), + _Internal::record(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncdMutation) + return target; +} + +size_t SyncdMutation::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncdMutation) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional .proto.SyncdRecord record = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.record_); + } + + // optional .proto.SyncdMutation.SyncdOperation operation = 1; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_operation()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncdMutation::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncdMutation::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncdMutation::GetClassData() const { return &_class_data_; } + + +void SyncdMutation::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncdMutation) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_record()->::proto::SyncdRecord::MergeFrom( + from._internal_record()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.operation_ = from._impl_.operation_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncdMutation::CopyFrom(const SyncdMutation& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncdMutation) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncdMutation::IsInitialized() const { + return true; +} + +void SyncdMutation::InternalSwap(SyncdMutation* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SyncdMutation, _impl_.operation_) + + sizeof(SyncdMutation::_impl_.operation_) + - PROTOBUF_FIELD_OFFSET(SyncdMutation, _impl_.record_)>( + reinterpret_cast(&_impl_.record_), + reinterpret_cast(&other->_impl_.record_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncdMutation::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[206]); +} + +// =================================================================== + +class SyncdMutations::_Internal { + public: +}; + +SyncdMutations::SyncdMutations(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncdMutations) +} +SyncdMutations::SyncdMutations(const SyncdMutations& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncdMutations* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.mutations_){from._impl_.mutations_} + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:proto.SyncdMutations) +} + +inline void SyncdMutations::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_.mutations_){arena} + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +SyncdMutations::~SyncdMutations() { + // @@protoc_insertion_point(destructor:proto.SyncdMutations) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncdMutations::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.mutations_.~RepeatedPtrField(); +} + +void SyncdMutations::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncdMutations::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncdMutations) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.mutations_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncdMutations::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .proto.SyncdMutation mutations = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_mutations(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncdMutations::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncdMutations) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .proto.SyncdMutation mutations = 1; + for (unsigned i = 0, + n = static_cast(this->_internal_mutations_size()); i < n; i++) { + const auto& repfield = this->_internal_mutations(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncdMutations) + return target; +} + +size_t SyncdMutations::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncdMutations) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.SyncdMutation mutations = 1; + total_size += 1UL * this->_internal_mutations_size(); + for (const auto& msg : this->_impl_.mutations_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncdMutations::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncdMutations::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncdMutations::GetClassData() const { return &_class_data_; } + + +void SyncdMutations::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncdMutations) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.mutations_.MergeFrom(from._impl_.mutations_); + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncdMutations::CopyFrom(const SyncdMutations& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncdMutations) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncdMutations::IsInitialized() const { + return true; +} + +void SyncdMutations::InternalSwap(SyncdMutations* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.mutations_.InternalSwap(&other->_impl_.mutations_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncdMutations::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[207]); +} + +// =================================================================== + +class SyncdPatch::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::SyncdVersion& version(const SyncdPatch* msg); + static void set_has_version(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static const ::proto::ExternalBlobReference& externalmutations(const SyncdPatch* msg); + static void set_has_externalmutations(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_snapshotmac(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_patchmac(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::proto::KeyId& keyid(const SyncdPatch* msg); + static void set_has_keyid(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static const ::proto::ExitCode& exitcode(const SyncdPatch* msg); + static void set_has_exitcode(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_deviceindex(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } +}; + +const ::proto::SyncdVersion& +SyncdPatch::_Internal::version(const SyncdPatch* msg) { + return *msg->_impl_.version_; +} +const ::proto::ExternalBlobReference& +SyncdPatch::_Internal::externalmutations(const SyncdPatch* msg) { + return *msg->_impl_.externalmutations_; +} +const ::proto::KeyId& +SyncdPatch::_Internal::keyid(const SyncdPatch* msg) { + return *msg->_impl_.keyid_; +} +const ::proto::ExitCode& +SyncdPatch::_Internal::exitcode(const SyncdPatch* msg) { + return *msg->_impl_.exitcode_; +} +SyncdPatch::SyncdPatch(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncdPatch) +} +SyncdPatch::SyncdPatch(const SyncdPatch& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncdPatch* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.mutations_){from._impl_.mutations_} + , decltype(_impl_.snapshotmac_){} + , decltype(_impl_.patchmac_){} + , decltype(_impl_.version_){nullptr} + , decltype(_impl_.externalmutations_){nullptr} + , decltype(_impl_.keyid_){nullptr} + , decltype(_impl_.exitcode_){nullptr} + , decltype(_impl_.deviceindex_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.snapshotmac_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.snapshotmac_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_snapshotmac()) { + _this->_impl_.snapshotmac_.Set(from._internal_snapshotmac(), + _this->GetArenaForAllocation()); + } + _impl_.patchmac_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.patchmac_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_patchmac()) { + _this->_impl_.patchmac_.Set(from._internal_patchmac(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_version()) { + _this->_impl_.version_ = new ::proto::SyncdVersion(*from._impl_.version_); + } + if (from._internal_has_externalmutations()) { + _this->_impl_.externalmutations_ = new ::proto::ExternalBlobReference(*from._impl_.externalmutations_); + } + if (from._internal_has_keyid()) { + _this->_impl_.keyid_ = new ::proto::KeyId(*from._impl_.keyid_); + } + if (from._internal_has_exitcode()) { + _this->_impl_.exitcode_ = new ::proto::ExitCode(*from._impl_.exitcode_); + } + _this->_impl_.deviceindex_ = from._impl_.deviceindex_; + // @@protoc_insertion_point(copy_constructor:proto.SyncdPatch) +} + +inline void SyncdPatch::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.mutations_){arena} + , decltype(_impl_.snapshotmac_){} + , decltype(_impl_.patchmac_){} + , decltype(_impl_.version_){nullptr} + , decltype(_impl_.externalmutations_){nullptr} + , decltype(_impl_.keyid_){nullptr} + , decltype(_impl_.exitcode_){nullptr} + , decltype(_impl_.deviceindex_){0u} + }; + _impl_.snapshotmac_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.snapshotmac_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.patchmac_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.patchmac_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +SyncdPatch::~SyncdPatch() { + // @@protoc_insertion_point(destructor:proto.SyncdPatch) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncdPatch::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.mutations_.~RepeatedPtrField(); + _impl_.snapshotmac_.Destroy(); + _impl_.patchmac_.Destroy(); + if (this != internal_default_instance()) delete _impl_.version_; + if (this != internal_default_instance()) delete _impl_.externalmutations_; + if (this != internal_default_instance()) delete _impl_.keyid_; + if (this != internal_default_instance()) delete _impl_.exitcode_; +} + +void SyncdPatch::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncdPatch::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncdPatch) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.mutations_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + _impl_.snapshotmac_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.patchmac_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.version_ != nullptr); + _impl_.version_->Clear(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(_impl_.externalmutations_ != nullptr); + _impl_.externalmutations_->Clear(); + } + if (cached_has_bits & 0x00000010u) { + GOOGLE_DCHECK(_impl_.keyid_ != nullptr); + _impl_.keyid_->Clear(); + } + if (cached_has_bits & 0x00000020u) { + GOOGLE_DCHECK(_impl_.exitcode_ != nullptr); + _impl_.exitcode_->Clear(); + } + } + _impl_.deviceindex_ = 0u; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncdPatch::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.SyncdVersion version = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_version(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .proto.SyncdMutation mutations = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_mutations(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else + goto handle_unusual; + continue; + // optional .proto.ExternalBlobReference externalMutations = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_externalmutations(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes snapshotMac = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_snapshotmac(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes patchMac = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + auto str = _internal_mutable_patchmac(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.KeyId keyId = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_keyid(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.ExitCode exitCode = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_exitcode(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 deviceIndex = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { + _Internal::set_has_deviceindex(&has_bits); + _impl_.deviceindex_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncdPatch::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncdPatch) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.SyncdVersion version = 1; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::version(this), + _Internal::version(this).GetCachedSize(), target, stream); + } + + // repeated .proto.SyncdMutation mutations = 2; + for (unsigned i = 0, + n = static_cast(this->_internal_mutations_size()); i < n; i++) { + const auto& repfield = this->_internal_mutations(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream); + } + + // optional .proto.ExternalBlobReference externalMutations = 3; + if (cached_has_bits & 0x00000008u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::externalmutations(this), + _Internal::externalmutations(this).GetCachedSize(), target, stream); + } + + // optional bytes snapshotMac = 4; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 4, this->_internal_snapshotmac(), target); + } + + // optional bytes patchMac = 5; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 5, this->_internal_patchmac(), target); + } + + // optional .proto.KeyId keyId = 6; + if (cached_has_bits & 0x00000010u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(6, _Internal::keyid(this), + _Internal::keyid(this).GetCachedSize(), target, stream); + } + + // optional .proto.ExitCode exitCode = 7; + if (cached_has_bits & 0x00000020u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(7, _Internal::exitcode(this), + _Internal::exitcode(this).GetCachedSize(), target, stream); + } + + // optional uint32 deviceIndex = 8; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(8, this->_internal_deviceindex(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncdPatch) + return target; +} + +size_t SyncdPatch::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncdPatch) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.SyncdMutation mutations = 2; + total_size += 1UL * this->_internal_mutations_size(); + for (const auto& msg : this->_impl_.mutations_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + // optional bytes snapshotMac = 4; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_snapshotmac()); + } + + // optional bytes patchMac = 5; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_patchmac()); + } + + // optional .proto.SyncdVersion version = 1; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.version_); + } + + // optional .proto.ExternalBlobReference externalMutations = 3; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.externalmutations_); + } + + // optional .proto.KeyId keyId = 6; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.keyid_); + } + + // optional .proto.ExitCode exitCode = 7; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.exitcode_); + } + + // optional uint32 deviceIndex = 8; + if (cached_has_bits & 0x00000040u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_deviceindex()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncdPatch::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncdPatch::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncdPatch::GetClassData() const { return &_class_data_; } + + +void SyncdPatch::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncdPatch) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.mutations_.MergeFrom(from._impl_.mutations_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_snapshotmac(from._internal_snapshotmac()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_patchmac(from._internal_patchmac()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_version()->::proto::SyncdVersion::MergeFrom( + from._internal_version()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_mutable_externalmutations()->::proto::ExternalBlobReference::MergeFrom( + from._internal_externalmutations()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_mutable_keyid()->::proto::KeyId::MergeFrom( + from._internal_keyid()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_mutable_exitcode()->::proto::ExitCode::MergeFrom( + from._internal_exitcode()); + } + if (cached_has_bits & 0x00000040u) { + _this->_impl_.deviceindex_ = from._impl_.deviceindex_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncdPatch::CopyFrom(const SyncdPatch& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncdPatch) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncdPatch::IsInitialized() const { + return true; +} + +void SyncdPatch::InternalSwap(SyncdPatch* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.mutations_.InternalSwap(&other->_impl_.mutations_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.snapshotmac_, lhs_arena, + &other->_impl_.snapshotmac_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.patchmac_, lhs_arena, + &other->_impl_.patchmac_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SyncdPatch, _impl_.deviceindex_) + + sizeof(SyncdPatch::_impl_.deviceindex_) + - PROTOBUF_FIELD_OFFSET(SyncdPatch, _impl_.version_)>( + reinterpret_cast(&_impl_.version_), + reinterpret_cast(&other->_impl_.version_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncdPatch::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[208]); +} + +// =================================================================== + +class SyncdRecord::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::SyncdIndex& index(const SyncdRecord* msg); + static void set_has_index(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::proto::SyncdValue& value(const SyncdRecord* msg); + static void set_has_value(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::proto::KeyId& keyid(const SyncdRecord* msg); + static void set_has_keyid(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +const ::proto::SyncdIndex& +SyncdRecord::_Internal::index(const SyncdRecord* msg) { + return *msg->_impl_.index_; +} +const ::proto::SyncdValue& +SyncdRecord::_Internal::value(const SyncdRecord* msg) { + return *msg->_impl_.value_; +} +const ::proto::KeyId& +SyncdRecord::_Internal::keyid(const SyncdRecord* msg) { + return *msg->_impl_.keyid_; +} +SyncdRecord::SyncdRecord(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncdRecord) +} +SyncdRecord::SyncdRecord(const SyncdRecord& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncdRecord* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.index_){nullptr} + , decltype(_impl_.value_){nullptr} + , decltype(_impl_.keyid_){nullptr}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_index()) { + _this->_impl_.index_ = new ::proto::SyncdIndex(*from._impl_.index_); + } + if (from._internal_has_value()) { + _this->_impl_.value_ = new ::proto::SyncdValue(*from._impl_.value_); + } + if (from._internal_has_keyid()) { + _this->_impl_.keyid_ = new ::proto::KeyId(*from._impl_.keyid_); + } + // @@protoc_insertion_point(copy_constructor:proto.SyncdRecord) +} + +inline void SyncdRecord::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.index_){nullptr} + , decltype(_impl_.value_){nullptr} + , decltype(_impl_.keyid_){nullptr} + }; +} + +SyncdRecord::~SyncdRecord() { + // @@protoc_insertion_point(destructor:proto.SyncdRecord) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncdRecord::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.index_; + if (this != internal_default_instance()) delete _impl_.value_; + if (this != internal_default_instance()) delete _impl_.keyid_; +} + +void SyncdRecord::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncdRecord::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncdRecord) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.index_ != nullptr); + _impl_.index_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.value_ != nullptr); + _impl_.value_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.keyid_ != nullptr); + _impl_.keyid_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncdRecord::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.SyncdIndex index = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_index(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.SyncdValue value = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_value(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.KeyId keyId = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_keyid(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncdRecord::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncdRecord) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.SyncdIndex index = 1; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::index(this), + _Internal::index(this).GetCachedSize(), target, stream); + } + + // optional .proto.SyncdValue value = 2; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::value(this), + _Internal::value(this).GetCachedSize(), target, stream); + } + + // optional .proto.KeyId keyId = 3; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::keyid(this), + _Internal::keyid(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncdRecord) + return target; +} + +size_t SyncdRecord::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncdRecord) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional .proto.SyncdIndex index = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.index_); + } + + // optional .proto.SyncdValue value = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.value_); + } + + // optional .proto.KeyId keyId = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.keyid_); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncdRecord::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncdRecord::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncdRecord::GetClassData() const { return &_class_data_; } + + +void SyncdRecord::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncdRecord) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_index()->::proto::SyncdIndex::MergeFrom( + from._internal_index()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_value()->::proto::SyncdValue::MergeFrom( + from._internal_value()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_keyid()->::proto::KeyId::MergeFrom( + from._internal_keyid()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncdRecord::CopyFrom(const SyncdRecord& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncdRecord) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncdRecord::IsInitialized() const { + return true; +} + +void SyncdRecord::InternalSwap(SyncdRecord* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SyncdRecord, _impl_.keyid_) + + sizeof(SyncdRecord::_impl_.keyid_) + - PROTOBUF_FIELD_OFFSET(SyncdRecord, _impl_.index_)>( + reinterpret_cast(&_impl_.index_), + reinterpret_cast(&other->_impl_.index_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncdRecord::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[209]); +} + +// =================================================================== + +class SyncdSnapshot::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::SyncdVersion& version(const SyncdSnapshot* msg); + static void set_has_version(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_mac(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::proto::KeyId& keyid(const SyncdSnapshot* msg); + static void set_has_keyid(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +const ::proto::SyncdVersion& +SyncdSnapshot::_Internal::version(const SyncdSnapshot* msg) { + return *msg->_impl_.version_; +} +const ::proto::KeyId& +SyncdSnapshot::_Internal::keyid(const SyncdSnapshot* msg) { + return *msg->_impl_.keyid_; +} +SyncdSnapshot::SyncdSnapshot(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncdSnapshot) +} +SyncdSnapshot::SyncdSnapshot(const SyncdSnapshot& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncdSnapshot* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.records_){from._impl_.records_} + , decltype(_impl_.mac_){} + , decltype(_impl_.version_){nullptr} + , decltype(_impl_.keyid_){nullptr}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.mac_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mac_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_mac()) { + _this->_impl_.mac_.Set(from._internal_mac(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_version()) { + _this->_impl_.version_ = new ::proto::SyncdVersion(*from._impl_.version_); + } + if (from._internal_has_keyid()) { + _this->_impl_.keyid_ = new ::proto::KeyId(*from._impl_.keyid_); + } + // @@protoc_insertion_point(copy_constructor:proto.SyncdSnapshot) +} + +inline void SyncdSnapshot::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.records_){arena} + , decltype(_impl_.mac_){} + , decltype(_impl_.version_){nullptr} + , decltype(_impl_.keyid_){nullptr} + }; + _impl_.mac_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mac_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +SyncdSnapshot::~SyncdSnapshot() { + // @@protoc_insertion_point(destructor:proto.SyncdSnapshot) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncdSnapshot::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.records_.~RepeatedPtrField(); + _impl_.mac_.Destroy(); + if (this != internal_default_instance()) delete _impl_.version_; + if (this != internal_default_instance()) delete _impl_.keyid_; +} + +void SyncdSnapshot::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncdSnapshot::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncdSnapshot) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.records_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _impl_.mac_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.version_ != nullptr); + _impl_.version_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(_impl_.keyid_ != nullptr); + _impl_.keyid_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncdSnapshot::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.SyncdVersion version = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_version(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .proto.SyncdRecord records = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_records(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else + goto handle_unusual; + continue; + // optional bytes mac = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_mac(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.KeyId keyId = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_keyid(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncdSnapshot::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncdSnapshot) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.SyncdVersion version = 1; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::version(this), + _Internal::version(this).GetCachedSize(), target, stream); + } + + // repeated .proto.SyncdRecord records = 2; + for (unsigned i = 0, + n = static_cast(this->_internal_records_size()); i < n; i++) { + const auto& repfield = this->_internal_records(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream); + } + + // optional bytes mac = 3; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 3, this->_internal_mac(), target); + } + + // optional .proto.KeyId keyId = 4; + if (cached_has_bits & 0x00000004u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, _Internal::keyid(this), + _Internal::keyid(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncdSnapshot) + return target; +} + +size_t SyncdSnapshot::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncdSnapshot) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.SyncdRecord records = 2; + total_size += 1UL * this->_internal_records_size(); + for (const auto& msg : this->_impl_.records_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional bytes mac = 3; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_mac()); + } + + // optional .proto.SyncdVersion version = 1; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.version_); + } + + // optional .proto.KeyId keyId = 4; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.keyid_); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncdSnapshot::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncdSnapshot::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncdSnapshot::GetClassData() const { return &_class_data_; } + + +void SyncdSnapshot::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncdSnapshot) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.records_.MergeFrom(from._impl_.records_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_mac(from._internal_mac()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_version()->::proto::SyncdVersion::MergeFrom( + from._internal_version()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_mutable_keyid()->::proto::KeyId::MergeFrom( + from._internal_keyid()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncdSnapshot::CopyFrom(const SyncdSnapshot& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncdSnapshot) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncdSnapshot::IsInitialized() const { + return true; +} + +void SyncdSnapshot::InternalSwap(SyncdSnapshot* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.records_.InternalSwap(&other->_impl_.records_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.mac_, lhs_arena, + &other->_impl_.mac_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SyncdSnapshot, _impl_.keyid_) + + sizeof(SyncdSnapshot::_impl_.keyid_) + - PROTOBUF_FIELD_OFFSET(SyncdSnapshot, _impl_.version_)>( + reinterpret_cast(&_impl_.version_), + reinterpret_cast(&other->_impl_.version_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncdSnapshot::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[210]); +} + +// =================================================================== + +class SyncdValue::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_blob(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +SyncdValue::SyncdValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncdValue) +} +SyncdValue::SyncdValue(const SyncdValue& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncdValue* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.blob_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.blob_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.blob_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_blob()) { + _this->_impl_.blob_.Set(from._internal_blob(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.SyncdValue) +} + +inline void SyncdValue::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.blob_){} + }; + _impl_.blob_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.blob_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +SyncdValue::~SyncdValue() { + // @@protoc_insertion_point(destructor:proto.SyncdValue) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncdValue::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.blob_.Destroy(); +} + +void SyncdValue::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncdValue::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncdValue) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.blob_.ClearNonDefaultToEmpty(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncdValue::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes blob = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_blob(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncdValue::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncdValue) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes blob = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_blob(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncdValue) + return target; +} + +size_t SyncdValue::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncdValue) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional bytes blob = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_blob()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncdValue::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncdValue::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncdValue::GetClassData() const { return &_class_data_; } + + +void SyncdValue::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncdValue) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_blob()) { + _this->_internal_set_blob(from._internal_blob()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncdValue::CopyFrom(const SyncdValue& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncdValue) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncdValue::IsInitialized() const { + return true; +} + +void SyncdValue::InternalSwap(SyncdValue* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.blob_, lhs_arena, + &other->_impl_.blob_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncdValue::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[211]); +} + +// =================================================================== + +class SyncdVersion::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_version(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +SyncdVersion::SyncdVersion(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.SyncdVersion) +} +SyncdVersion::SyncdVersion(const SyncdVersion& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + SyncdVersion* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.version_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _this->_impl_.version_ = from._impl_.version_; + // @@protoc_insertion_point(copy_constructor:proto.SyncdVersion) +} + +inline void SyncdVersion::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.version_){uint64_t{0u}} + }; +} + +SyncdVersion::~SyncdVersion() { + // @@protoc_insertion_point(destructor:proto.SyncdVersion) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SyncdVersion::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void SyncdVersion::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SyncdVersion::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.SyncdVersion) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.version_ = uint64_t{0u}; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SyncdVersion::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint64 version = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_version(&has_bits); + _impl_.version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* SyncdVersion::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.SyncdVersion) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional uint64 version = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_version(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.SyncdVersion) + return target; +} + +size_t SyncdVersion::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.SyncdVersion) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional uint64 version = 1; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_version()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncdVersion::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SyncdVersion::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncdVersion::GetClassData() const { return &_class_data_; } + + +void SyncdVersion::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncdVersion) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_version()) { + _this->_internal_set_version(from._internal_version()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SyncdVersion::CopyFrom(const SyncdVersion& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncdVersion) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SyncdVersion::IsInitialized() const { + return true; +} + +void SyncdVersion::InternalSwap(SyncdVersion* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_.version_, other->_impl_.version_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SyncdVersion::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[212]); +} + +// =================================================================== + +class TemplateButton_CallButton::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::Message_HighlyStructuredMessage& displaytext(const TemplateButton_CallButton* msg); + static void set_has_displaytext(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::proto::Message_HighlyStructuredMessage& phonenumber(const TemplateButton_CallButton* msg); + static void set_has_phonenumber(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::proto::Message_HighlyStructuredMessage& +TemplateButton_CallButton::_Internal::displaytext(const TemplateButton_CallButton* msg) { + return *msg->_impl_.displaytext_; +} +const ::proto::Message_HighlyStructuredMessage& +TemplateButton_CallButton::_Internal::phonenumber(const TemplateButton_CallButton* msg) { + return *msg->_impl_.phonenumber_; +} +TemplateButton_CallButton::TemplateButton_CallButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.TemplateButton.CallButton) +} +TemplateButton_CallButton::TemplateButton_CallButton(const TemplateButton_CallButton& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + TemplateButton_CallButton* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.displaytext_){nullptr} + , decltype(_impl_.phonenumber_){nullptr}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_displaytext()) { + _this->_impl_.displaytext_ = new ::proto::Message_HighlyStructuredMessage(*from._impl_.displaytext_); + } + if (from._internal_has_phonenumber()) { + _this->_impl_.phonenumber_ = new ::proto::Message_HighlyStructuredMessage(*from._impl_.phonenumber_); + } + // @@protoc_insertion_point(copy_constructor:proto.TemplateButton.CallButton) +} + +inline void TemplateButton_CallButton::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.displaytext_){nullptr} + , decltype(_impl_.phonenumber_){nullptr} + }; +} + +TemplateButton_CallButton::~TemplateButton_CallButton() { + // @@protoc_insertion_point(destructor:proto.TemplateButton.CallButton) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void TemplateButton_CallButton::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.displaytext_; + if (this != internal_default_instance()) delete _impl_.phonenumber_; +} + +void TemplateButton_CallButton::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void TemplateButton_CallButton::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.TemplateButton.CallButton) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.displaytext_ != nullptr); + _impl_.displaytext_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.phonenumber_ != nullptr); + _impl_.phonenumber_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* TemplateButton_CallButton::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.Message.HighlyStructuredMessage displayText = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_displaytext(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.HighlyStructuredMessage phoneNumber = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_phonenumber(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* TemplateButton_CallButton::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.TemplateButton.CallButton) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.Message.HighlyStructuredMessage displayText = 1; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::displaytext(this), + _Internal::displaytext(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.HighlyStructuredMessage phoneNumber = 2; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::phonenumber(this), + _Internal::phonenumber(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.TemplateButton.CallButton) + return target; +} + +size_t TemplateButton_CallButton::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.TemplateButton.CallButton) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional .proto.Message.HighlyStructuredMessage displayText = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.displaytext_); + } + + // optional .proto.Message.HighlyStructuredMessage phoneNumber = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.phonenumber_); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TemplateButton_CallButton::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + TemplateButton_CallButton::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TemplateButton_CallButton::GetClassData() const { return &_class_data_; } + + +void TemplateButton_CallButton::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.TemplateButton.CallButton) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_displaytext()->::proto::Message_HighlyStructuredMessage::MergeFrom( + from._internal_displaytext()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_phonenumber()->::proto::Message_HighlyStructuredMessage::MergeFrom( + from._internal_phonenumber()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void TemplateButton_CallButton::CopyFrom(const TemplateButton_CallButton& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.TemplateButton.CallButton) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool TemplateButton_CallButton::IsInitialized() const { + return true; +} + +void TemplateButton_CallButton::InternalSwap(TemplateButton_CallButton* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(TemplateButton_CallButton, _impl_.phonenumber_) + + sizeof(TemplateButton_CallButton::_impl_.phonenumber_) + - PROTOBUF_FIELD_OFFSET(TemplateButton_CallButton, _impl_.displaytext_)>( + reinterpret_cast(&_impl_.displaytext_), + reinterpret_cast(&other->_impl_.displaytext_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata TemplateButton_CallButton::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[213]); +} + +// =================================================================== + +class TemplateButton_QuickReplyButton::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::Message_HighlyStructuredMessage& displaytext(const TemplateButton_QuickReplyButton* msg); + static void set_has_displaytext(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_id(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +const ::proto::Message_HighlyStructuredMessage& +TemplateButton_QuickReplyButton::_Internal::displaytext(const TemplateButton_QuickReplyButton* msg) { + return *msg->_impl_.displaytext_; +} +TemplateButton_QuickReplyButton::TemplateButton_QuickReplyButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.TemplateButton.QuickReplyButton) +} +TemplateButton_QuickReplyButton::TemplateButton_QuickReplyButton(const TemplateButton_QuickReplyButton& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + TemplateButton_QuickReplyButton* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.id_){} + , decltype(_impl_.displaytext_){nullptr}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.id_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.id_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_id()) { + _this->_impl_.id_.Set(from._internal_id(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_displaytext()) { + _this->_impl_.displaytext_ = new ::proto::Message_HighlyStructuredMessage(*from._impl_.displaytext_); + } + // @@protoc_insertion_point(copy_constructor:proto.TemplateButton.QuickReplyButton) +} + +inline void TemplateButton_QuickReplyButton::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.id_){} + , decltype(_impl_.displaytext_){nullptr} + }; + _impl_.id_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.id_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +TemplateButton_QuickReplyButton::~TemplateButton_QuickReplyButton() { + // @@protoc_insertion_point(destructor:proto.TemplateButton.QuickReplyButton) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void TemplateButton_QuickReplyButton::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.id_.Destroy(); + if (this != internal_default_instance()) delete _impl_.displaytext_; +} + +void TemplateButton_QuickReplyButton::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void TemplateButton_QuickReplyButton::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.TemplateButton.QuickReplyButton) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.id_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.displaytext_ != nullptr); + _impl_.displaytext_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* TemplateButton_QuickReplyButton::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.Message.HighlyStructuredMessage displayText = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_displaytext(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string id = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_id(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.TemplateButton.QuickReplyButton.id"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* TemplateButton_QuickReplyButton::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.TemplateButton.QuickReplyButton) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.Message.HighlyStructuredMessage displayText = 1; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::displaytext(this), + _Internal::displaytext(this).GetCachedSize(), target, stream); + } + + // optional string id = 2; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_id().data(), static_cast(this->_internal_id().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.TemplateButton.QuickReplyButton.id"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.TemplateButton.QuickReplyButton) + return target; +} + +size_t TemplateButton_QuickReplyButton::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.TemplateButton.QuickReplyButton) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional string id = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_id()); + } + + // optional .proto.Message.HighlyStructuredMessage displayText = 1; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.displaytext_); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TemplateButton_QuickReplyButton::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + TemplateButton_QuickReplyButton::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TemplateButton_QuickReplyButton::GetClassData() const { return &_class_data_; } + + +void TemplateButton_QuickReplyButton::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.TemplateButton.QuickReplyButton) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_id(from._internal_id()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_displaytext()->::proto::Message_HighlyStructuredMessage::MergeFrom( + from._internal_displaytext()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void TemplateButton_QuickReplyButton::CopyFrom(const TemplateButton_QuickReplyButton& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.TemplateButton.QuickReplyButton) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool TemplateButton_QuickReplyButton::IsInitialized() const { + return true; +} + +void TemplateButton_QuickReplyButton::InternalSwap(TemplateButton_QuickReplyButton* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.id_, lhs_arena, + &other->_impl_.id_, rhs_arena + ); + swap(_impl_.displaytext_, other->_impl_.displaytext_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata TemplateButton_QuickReplyButton::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[214]); +} + +// =================================================================== + +class TemplateButton_URLButton::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::Message_HighlyStructuredMessage& displaytext(const TemplateButton_URLButton* msg); + static void set_has_displaytext(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::proto::Message_HighlyStructuredMessage& url(const TemplateButton_URLButton* msg); + static void set_has_url(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::proto::Message_HighlyStructuredMessage& +TemplateButton_URLButton::_Internal::displaytext(const TemplateButton_URLButton* msg) { + return *msg->_impl_.displaytext_; +} +const ::proto::Message_HighlyStructuredMessage& +TemplateButton_URLButton::_Internal::url(const TemplateButton_URLButton* msg) { + return *msg->_impl_.url_; +} +TemplateButton_URLButton::TemplateButton_URLButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.TemplateButton.URLButton) +} +TemplateButton_URLButton::TemplateButton_URLButton(const TemplateButton_URLButton& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + TemplateButton_URLButton* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.displaytext_){nullptr} + , decltype(_impl_.url_){nullptr}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_displaytext()) { + _this->_impl_.displaytext_ = new ::proto::Message_HighlyStructuredMessage(*from._impl_.displaytext_); + } + if (from._internal_has_url()) { + _this->_impl_.url_ = new ::proto::Message_HighlyStructuredMessage(*from._impl_.url_); + } + // @@protoc_insertion_point(copy_constructor:proto.TemplateButton.URLButton) +} + +inline void TemplateButton_URLButton::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.displaytext_){nullptr} + , decltype(_impl_.url_){nullptr} + }; +} + +TemplateButton_URLButton::~TemplateButton_URLButton() { + // @@protoc_insertion_point(destructor:proto.TemplateButton.URLButton) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void TemplateButton_URLButton::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.displaytext_; + if (this != internal_default_instance()) delete _impl_.url_; +} + +void TemplateButton_URLButton::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void TemplateButton_URLButton::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.TemplateButton.URLButton) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(_impl_.displaytext_ != nullptr); + _impl_.displaytext_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(_impl_.url_ != nullptr); + _impl_.url_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* TemplateButton_URLButton::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.Message.HighlyStructuredMessage displayText = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_displaytext(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.HighlyStructuredMessage url = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_url(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* TemplateButton_URLButton::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.TemplateButton.URLButton) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.Message.HighlyStructuredMessage displayText = 1; + if (cached_has_bits & 0x00000001u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::displaytext(this), + _Internal::displaytext(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.HighlyStructuredMessage url = 2; + if (cached_has_bits & 0x00000002u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::url(this), + _Internal::url(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.TemplateButton.URLButton) + return target; +} + +size_t TemplateButton_URLButton::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.TemplateButton.URLButton) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional .proto.Message.HighlyStructuredMessage displayText = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.displaytext_); + } + + // optional .proto.Message.HighlyStructuredMessage url = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.url_); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TemplateButton_URLButton::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + TemplateButton_URLButton::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TemplateButton_URLButton::GetClassData() const { return &_class_data_; } + + +void TemplateButton_URLButton::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.TemplateButton.URLButton) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_mutable_displaytext()->::proto::Message_HighlyStructuredMessage::MergeFrom( + from._internal_displaytext()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_mutable_url()->::proto::Message_HighlyStructuredMessage::MergeFrom( + from._internal_url()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void TemplateButton_URLButton::CopyFrom(const TemplateButton_URLButton& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.TemplateButton.URLButton) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool TemplateButton_URLButton::IsInitialized() const { + return true; +} + +void TemplateButton_URLButton::InternalSwap(TemplateButton_URLButton* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(TemplateButton_URLButton, _impl_.url_) + + sizeof(TemplateButton_URLButton::_impl_.url_) + - PROTOBUF_FIELD_OFFSET(TemplateButton_URLButton, _impl_.displaytext_)>( + reinterpret_cast(&_impl_.displaytext_), + reinterpret_cast(&other->_impl_.displaytext_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata TemplateButton_URLButton::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[215]); +} + +// =================================================================== + +class TemplateButton::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_index(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::proto::TemplateButton_QuickReplyButton& quickreplybutton(const TemplateButton* msg); + static const ::proto::TemplateButton_URLButton& urlbutton(const TemplateButton* msg); + static const ::proto::TemplateButton_CallButton& callbutton(const TemplateButton* msg); +}; + +const ::proto::TemplateButton_QuickReplyButton& +TemplateButton::_Internal::quickreplybutton(const TemplateButton* msg) { + return *msg->_impl_.button_.quickreplybutton_; +} +const ::proto::TemplateButton_URLButton& +TemplateButton::_Internal::urlbutton(const TemplateButton* msg) { + return *msg->_impl_.button_.urlbutton_; +} +const ::proto::TemplateButton_CallButton& +TemplateButton::_Internal::callbutton(const TemplateButton* msg) { + return *msg->_impl_.button_.callbutton_; +} +void TemplateButton::set_allocated_quickreplybutton(::proto::TemplateButton_QuickReplyButton* quickreplybutton) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_button(); + if (quickreplybutton) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quickreplybutton); + if (message_arena != submessage_arena) { + quickreplybutton = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, quickreplybutton, submessage_arena); + } + set_has_quickreplybutton(); + _impl_.button_.quickreplybutton_ = quickreplybutton; + } + // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.quickReplyButton) +} +void TemplateButton::set_allocated_urlbutton(::proto::TemplateButton_URLButton* urlbutton) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_button(); + if (urlbutton) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(urlbutton); + if (message_arena != submessage_arena) { + urlbutton = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, urlbutton, submessage_arena); + } + set_has_urlbutton(); + _impl_.button_.urlbutton_ = urlbutton; + } + // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.urlButton) +} +void TemplateButton::set_allocated_callbutton(::proto::TemplateButton_CallButton* callbutton) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_button(); + if (callbutton) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(callbutton); + if (message_arena != submessage_arena) { + callbutton = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, callbutton, submessage_arena); + } + set_has_callbutton(); + _impl_.button_.callbutton_ = callbutton; + } + // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.callButton) +} +TemplateButton::TemplateButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.TemplateButton) +} +TemplateButton::TemplateButton(const TemplateButton& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + TemplateButton* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.index_){} + , decltype(_impl_.button_){} + , /*decltype(_impl_._oneof_case_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _this->_impl_.index_ = from._impl_.index_; + clear_has_button(); + switch (from.button_case()) { + case kQuickReplyButton: { + _this->_internal_mutable_quickreplybutton()->::proto::TemplateButton_QuickReplyButton::MergeFrom( + from._internal_quickreplybutton()); + break; + } + case kUrlButton: { + _this->_internal_mutable_urlbutton()->::proto::TemplateButton_URLButton::MergeFrom( + from._internal_urlbutton()); + break; + } + case kCallButton: { + _this->_internal_mutable_callbutton()->::proto::TemplateButton_CallButton::MergeFrom( + from._internal_callbutton()); + break; + } + case BUTTON_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:proto.TemplateButton) +} + +inline void TemplateButton::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.index_){0u} + , decltype(_impl_.button_){} + , /*decltype(_impl_._oneof_case_)*/{} + }; + clear_has_button(); +} + +TemplateButton::~TemplateButton() { + // @@protoc_insertion_point(destructor:proto.TemplateButton) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void TemplateButton::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (has_button()) { + clear_button(); + } +} + +void TemplateButton::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void TemplateButton::clear_button() { +// @@protoc_insertion_point(one_of_clear_start:proto.TemplateButton) + switch (button_case()) { + case kQuickReplyButton: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.button_.quickreplybutton_; + } + break; + } + case kUrlButton: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.button_.urlbutton_; + } + break; + } + case kCallButton: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.button_.callbutton_; + } + break; + } + case BUTTON_NOT_SET: { + break; + } + } + _impl_._oneof_case_[0] = BUTTON_NOT_SET; +} + + +void TemplateButton::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.TemplateButton) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.index_ = 0u; + clear_button(); + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* TemplateButton::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .proto.TemplateButton.QuickReplyButton quickReplyButton = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_quickreplybutton(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .proto.TemplateButton.URLButton urlButton = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_urlbutton(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .proto.TemplateButton.CallButton callButton = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_callbutton(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 index = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_index(&has_bits); + _impl_.index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* TemplateButton::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.TemplateButton) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + switch (button_case()) { + case kQuickReplyButton: { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::quickreplybutton(this), + _Internal::quickreplybutton(this).GetCachedSize(), target, stream); + break; + } + case kUrlButton: { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::urlbutton(this), + _Internal::urlbutton(this).GetCachedSize(), target, stream); + break; + } + case kCallButton: { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::callbutton(this), + _Internal::callbutton(this).GetCachedSize(), target, stream); + break; + } + default: ; + } + cached_has_bits = _impl_._has_bits_[0]; + // optional uint32 index = 4; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_index(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.TemplateButton) + return target; +} + +size_t TemplateButton::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.TemplateButton) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional uint32 index = 4; + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_index()); + } + + switch (button_case()) { + // .proto.TemplateButton.QuickReplyButton quickReplyButton = 1; + case kQuickReplyButton: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.button_.quickreplybutton_); + break; + } + // .proto.TemplateButton.URLButton urlButton = 2; + case kUrlButton: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.button_.urlbutton_); + break; + } + // .proto.TemplateButton.CallButton callButton = 3; + case kCallButton: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.button_.callbutton_); + break; + } + case BUTTON_NOT_SET: { + break; + } + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TemplateButton::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + TemplateButton::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TemplateButton::GetClassData() const { return &_class_data_; } + + +void TemplateButton::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.TemplateButton) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_index()) { + _this->_internal_set_index(from._internal_index()); + } + switch (from.button_case()) { + case kQuickReplyButton: { + _this->_internal_mutable_quickreplybutton()->::proto::TemplateButton_QuickReplyButton::MergeFrom( + from._internal_quickreplybutton()); + break; + } + case kUrlButton: { + _this->_internal_mutable_urlbutton()->::proto::TemplateButton_URLButton::MergeFrom( + from._internal_urlbutton()); + break; + } + case kCallButton: { + _this->_internal_mutable_callbutton()->::proto::TemplateButton_CallButton::MergeFrom( + from._internal_callbutton()); + break; + } + case BUTTON_NOT_SET: { + break; + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void TemplateButton::CopyFrom(const TemplateButton& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.TemplateButton) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool TemplateButton::IsInitialized() const { + return true; +} + +void TemplateButton::InternalSwap(TemplateButton* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_.index_, other->_impl_.index_); + swap(_impl_.button_, other->_impl_.button_); + swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata TemplateButton::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[216]); +} + +// =================================================================== + +class UserReceipt::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_userjid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_receipttimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_readtimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_playedtimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0; + } +}; + +UserReceipt::UserReceipt(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.UserReceipt) +} +UserReceipt::UserReceipt(const UserReceipt& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + UserReceipt* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.pendingdevicejid_){from._impl_.pendingdevicejid_} + , decltype(_impl_.delivereddevicejid_){from._impl_.delivereddevicejid_} + , decltype(_impl_.userjid_){} + , decltype(_impl_.receipttimestamp_){} + , decltype(_impl_.readtimestamp_){} + , decltype(_impl_.playedtimestamp_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.userjid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.userjid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_userjid()) { + _this->_impl_.userjid_.Set(from._internal_userjid(), + _this->GetArenaForAllocation()); + } + ::memcpy(&_impl_.receipttimestamp_, &from._impl_.receipttimestamp_, + static_cast(reinterpret_cast(&_impl_.playedtimestamp_) - + reinterpret_cast(&_impl_.receipttimestamp_)) + sizeof(_impl_.playedtimestamp_)); + // @@protoc_insertion_point(copy_constructor:proto.UserReceipt) +} + +inline void UserReceipt::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.pendingdevicejid_){arena} + , decltype(_impl_.delivereddevicejid_){arena} + , decltype(_impl_.userjid_){} + , decltype(_impl_.receipttimestamp_){int64_t{0}} + , decltype(_impl_.readtimestamp_){int64_t{0}} + , decltype(_impl_.playedtimestamp_){int64_t{0}} + }; + _impl_.userjid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.userjid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +UserReceipt::~UserReceipt() { + // @@protoc_insertion_point(destructor:proto.UserReceipt) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void UserReceipt::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.pendingdevicejid_.~RepeatedPtrField(); + _impl_.delivereddevicejid_.~RepeatedPtrField(); + _impl_.userjid_.Destroy(); +} + +void UserReceipt::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void UserReceipt::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.UserReceipt) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.pendingdevicejid_.Clear(); + _impl_.delivereddevicejid_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.userjid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x0000000eu) { + ::memset(&_impl_.receipttimestamp_, 0, static_cast( + reinterpret_cast(&_impl_.playedtimestamp_) - + reinterpret_cast(&_impl_.receipttimestamp_)) + sizeof(_impl_.playedtimestamp_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* UserReceipt::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // required string userJid = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_userjid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.UserReceipt.userJid"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional int64 receiptTimestamp = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_receipttimestamp(&has_bits); + _impl_.receipttimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 readTimestamp = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_readtimestamp(&has_bits); + _impl_.readtimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 playedTimestamp = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_playedtimestamp(&has_bits); + _impl_.playedtimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated string pendingDeviceJid = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_pendingdevicejid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.UserReceipt.pendingDeviceJid"); + #endif // !NDEBUG + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr)); + } else + goto handle_unusual; + continue; + // repeated string deliveredDeviceJid = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_delivereddevicejid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.UserReceipt.deliveredDeviceJid"); + #endif // !NDEBUG + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* UserReceipt::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.UserReceipt) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // required string userJid = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_userjid().data(), static_cast(this->_internal_userjid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.UserReceipt.userJid"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_userjid(), target); + } + + // optional int64 receiptTimestamp = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_receipttimestamp(), target); + } + + // optional int64 readTimestamp = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_readtimestamp(), target); + } + + // optional int64 playedTimestamp = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_playedtimestamp(), target); + } + + // repeated string pendingDeviceJid = 5; + for (int i = 0, n = this->_internal_pendingdevicejid_size(); i < n; i++) { + const auto& s = this->_internal_pendingdevicejid(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.UserReceipt.pendingDeviceJid"); + target = stream->WriteString(5, s, target); + } + + // repeated string deliveredDeviceJid = 6; + for (int i = 0, n = this->_internal_delivereddevicejid_size(); i < n; i++) { + const auto& s = this->_internal_delivereddevicejid(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.UserReceipt.deliveredDeviceJid"); + target = stream->WriteString(6, s, target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.UserReceipt) + return target; +} + +size_t UserReceipt::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.UserReceipt) + size_t total_size = 0; + + // required string userJid = 1; + if (_internal_has_userjid()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_userjid()); + } + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string pendingDeviceJid = 5; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.pendingdevicejid_.size()); + for (int i = 0, n = _impl_.pendingdevicejid_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + _impl_.pendingdevicejid_.Get(i)); + } + + // repeated string deliveredDeviceJid = 6; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.delivereddevicejid_.size()); + for (int i = 0, n = _impl_.delivereddevicejid_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + _impl_.delivereddevicejid_.Get(i)); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000eu) { + // optional int64 receiptTimestamp = 2; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_receipttimestamp()); + } + + // optional int64 readTimestamp = 3; + if (cached_has_bits & 0x00000004u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_readtimestamp()); + } + + // optional int64 playedTimestamp = 4; + if (cached_has_bits & 0x00000008u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_playedtimestamp()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData UserReceipt::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + UserReceipt::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*UserReceipt::GetClassData() const { return &_class_data_; } + + +void UserReceipt::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.UserReceipt) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.pendingdevicejid_.MergeFrom(from._impl_.pendingdevicejid_); + _this->_impl_.delivereddevicejid_.MergeFrom(from._impl_.delivereddevicejid_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_userjid(from._internal_userjid()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.receipttimestamp_ = from._impl_.receipttimestamp_; + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.readtimestamp_ = from._impl_.readtimestamp_; + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.playedtimestamp_ = from._impl_.playedtimestamp_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void UserReceipt::CopyFrom(const UserReceipt& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.UserReceipt) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool UserReceipt::IsInitialized() const { + if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false; + return true; +} + +void UserReceipt::InternalSwap(UserReceipt* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.pendingdevicejid_.InternalSwap(&other->_impl_.pendingdevicejid_); + _impl_.delivereddevicejid_.InternalSwap(&other->_impl_.delivereddevicejid_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.userjid_, lhs_arena, + &other->_impl_.userjid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(UserReceipt, _impl_.playedtimestamp_) + + sizeof(UserReceipt::_impl_.playedtimestamp_) + - PROTOBUF_FIELD_OFFSET(UserReceipt, _impl_.receipttimestamp_)>( + reinterpret_cast(&_impl_.receipttimestamp_), + reinterpret_cast(&other->_impl_.receipttimestamp_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata UserReceipt::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[217]); +} + +// =================================================================== + +class VerifiedNameCertificate_Details::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_serial(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_issuer(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_verifiedname(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_issuetime(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +VerifiedNameCertificate_Details::VerifiedNameCertificate_Details(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.VerifiedNameCertificate.Details) +} +VerifiedNameCertificate_Details::VerifiedNameCertificate_Details(const VerifiedNameCertificate_Details& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + VerifiedNameCertificate_Details* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.localizednames_){from._impl_.localizednames_} + , decltype(_impl_.issuer_){} + , decltype(_impl_.verifiedname_){} + , decltype(_impl_.serial_){} + , decltype(_impl_.issuetime_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.issuer_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.issuer_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_issuer()) { + _this->_impl_.issuer_.Set(from._internal_issuer(), + _this->GetArenaForAllocation()); + } + _impl_.verifiedname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.verifiedname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_verifiedname()) { + _this->_impl_.verifiedname_.Set(from._internal_verifiedname(), + _this->GetArenaForAllocation()); + } + ::memcpy(&_impl_.serial_, &from._impl_.serial_, + static_cast(reinterpret_cast(&_impl_.issuetime_) - + reinterpret_cast(&_impl_.serial_)) + sizeof(_impl_.issuetime_)); + // @@protoc_insertion_point(copy_constructor:proto.VerifiedNameCertificate.Details) +} + +inline void VerifiedNameCertificate_Details::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.localizednames_){arena} + , decltype(_impl_.issuer_){} + , decltype(_impl_.verifiedname_){} + , decltype(_impl_.serial_){uint64_t{0u}} + , decltype(_impl_.issuetime_){uint64_t{0u}} + }; + _impl_.issuer_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.issuer_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.verifiedname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.verifiedname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +VerifiedNameCertificate_Details::~VerifiedNameCertificate_Details() { + // @@protoc_insertion_point(destructor:proto.VerifiedNameCertificate.Details) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void VerifiedNameCertificate_Details::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.localizednames_.~RepeatedPtrField(); + _impl_.issuer_.Destroy(); + _impl_.verifiedname_.Destroy(); +} + +void VerifiedNameCertificate_Details::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void VerifiedNameCertificate_Details::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.VerifiedNameCertificate.Details) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.localizednames_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _impl_.issuer_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.verifiedname_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x0000000cu) { + ::memset(&_impl_.serial_, 0, static_cast( + reinterpret_cast(&_impl_.issuetime_) - + reinterpret_cast(&_impl_.serial_)) + sizeof(_impl_.issuetime_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* VerifiedNameCertificate_Details::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint64 serial = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_serial(&has_bits); + _impl_.serial_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string issuer = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_issuer(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.VerifiedNameCertificate.Details.issuer"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional string verifiedName = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_verifiedname(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.VerifiedNameCertificate.Details.verifiedName"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // repeated .proto.LocalizedName localizedNames = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_localizednames(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(ptr)); + } else + goto handle_unusual; + continue; + // optional uint64 issueTime = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { + _Internal::set_has_issuetime(&has_bits); + _impl_.issuetime_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* VerifiedNameCertificate_Details::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.VerifiedNameCertificate.Details) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional uint64 serial = 1; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_serial(), target); + } + + // optional string issuer = 2; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_issuer().data(), static_cast(this->_internal_issuer().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.VerifiedNameCertificate.Details.issuer"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_issuer(), target); + } + + // optional string verifiedName = 4; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_verifiedname().data(), static_cast(this->_internal_verifiedname().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.VerifiedNameCertificate.Details.verifiedName"); + target = stream->WriteStringMaybeAliased( + 4, this->_internal_verifiedname(), target); + } + + // repeated .proto.LocalizedName localizedNames = 8; + for (unsigned i = 0, + n = static_cast(this->_internal_localizednames_size()); i < n; i++) { + const auto& repfield = this->_internal_localizednames(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(8, repfield, repfield.GetCachedSize(), target, stream); + } + + // optional uint64 issueTime = 10; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(10, this->_internal_issuetime(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.VerifiedNameCertificate.Details) + return target; +} + +size_t VerifiedNameCertificate_Details::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.VerifiedNameCertificate.Details) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.LocalizedName localizedNames = 8; + total_size += 1UL * this->_internal_localizednames_size(); + for (const auto& msg : this->_impl_.localizednames_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional string issuer = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_issuer()); + } + + // optional string verifiedName = 4; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_verifiedname()); + } + + // optional uint64 serial = 1; + if (cached_has_bits & 0x00000004u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_serial()); + } + + // optional uint64 issueTime = 10; + if (cached_has_bits & 0x00000008u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_issuetime()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData VerifiedNameCertificate_Details::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + VerifiedNameCertificate_Details::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*VerifiedNameCertificate_Details::GetClassData() const { return &_class_data_; } + + +void VerifiedNameCertificate_Details::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.VerifiedNameCertificate.Details) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.localizednames_.MergeFrom(from._impl_.localizednames_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_issuer(from._internal_issuer()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_verifiedname(from._internal_verifiedname()); + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.serial_ = from._impl_.serial_; + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.issuetime_ = from._impl_.issuetime_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void VerifiedNameCertificate_Details::CopyFrom(const VerifiedNameCertificate_Details& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.VerifiedNameCertificate.Details) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool VerifiedNameCertificate_Details::IsInitialized() const { + return true; +} + +void VerifiedNameCertificate_Details::InternalSwap(VerifiedNameCertificate_Details* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.localizednames_.InternalSwap(&other->_impl_.localizednames_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.issuer_, lhs_arena, + &other->_impl_.issuer_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.verifiedname_, lhs_arena, + &other->_impl_.verifiedname_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(VerifiedNameCertificate_Details, _impl_.issuetime_) + + sizeof(VerifiedNameCertificate_Details::_impl_.issuetime_) + - PROTOBUF_FIELD_OFFSET(VerifiedNameCertificate_Details, _impl_.serial_)>( + reinterpret_cast(&_impl_.serial_), + reinterpret_cast(&other->_impl_.serial_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata VerifiedNameCertificate_Details::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[218]); +} + +// =================================================================== + +class VerifiedNameCertificate::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_details(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_signature(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_serversignature(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +VerifiedNameCertificate::VerifiedNameCertificate(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.VerifiedNameCertificate) +} +VerifiedNameCertificate::VerifiedNameCertificate(const VerifiedNameCertificate& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + VerifiedNameCertificate* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.details_){} + , decltype(_impl_.signature_){} + , decltype(_impl_.serversignature_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.details_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.details_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_details()) { + _this->_impl_.details_.Set(from._internal_details(), + _this->GetArenaForAllocation()); + } + _impl_.signature_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.signature_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_signature()) { + _this->_impl_.signature_.Set(from._internal_signature(), + _this->GetArenaForAllocation()); + } + _impl_.serversignature_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.serversignature_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_serversignature()) { + _this->_impl_.serversignature_.Set(from._internal_serversignature(), + _this->GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:proto.VerifiedNameCertificate) +} + +inline void VerifiedNameCertificate::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.details_){} + , decltype(_impl_.signature_){} + , decltype(_impl_.serversignature_){} + }; + _impl_.details_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.details_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.signature_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.signature_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.serversignature_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.serversignature_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +VerifiedNameCertificate::~VerifiedNameCertificate() { + // @@protoc_insertion_point(destructor:proto.VerifiedNameCertificate) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void VerifiedNameCertificate::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.details_.Destroy(); + _impl_.signature_.Destroy(); + _impl_.serversignature_.Destroy(); +} + +void VerifiedNameCertificate::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void VerifiedNameCertificate::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.VerifiedNameCertificate) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _impl_.details_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.signature_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.serversignature_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* VerifiedNameCertificate::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes details = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_details(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes signature = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_signature(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes serverSignature = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_serversignature(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* VerifiedNameCertificate::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.VerifiedNameCertificate) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes details = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_details(), target); + } + + // optional bytes signature = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_signature(), target); + } + + // optional bytes serverSignature = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->WriteBytesMaybeAliased( + 3, this->_internal_serversignature(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.VerifiedNameCertificate) + return target; +} + +size_t VerifiedNameCertificate::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.VerifiedNameCertificate) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional bytes details = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_details()); + } + + // optional bytes signature = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_signature()); + } + + // optional bytes serverSignature = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_serversignature()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData VerifiedNameCertificate::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + VerifiedNameCertificate::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*VerifiedNameCertificate::GetClassData() const { return &_class_data_; } + + +void VerifiedNameCertificate::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.VerifiedNameCertificate) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_details(from._internal_details()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_signature(from._internal_signature()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_serversignature(from._internal_serversignature()); + } + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void VerifiedNameCertificate::CopyFrom(const VerifiedNameCertificate& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.VerifiedNameCertificate) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool VerifiedNameCertificate::IsInitialized() const { + return true; +} + +void VerifiedNameCertificate::InternalSwap(VerifiedNameCertificate* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.details_, lhs_arena, + &other->_impl_.details_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.signature_, lhs_arena, + &other->_impl_.signature_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.serversignature_, lhs_arena, + &other->_impl_.serversignature_, rhs_arena + ); +} + +::PROTOBUF_NAMESPACE_ID::Metadata VerifiedNameCertificate::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[219]); +} + +// =================================================================== + +class WallpaperSettings::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_filename(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_opacity(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +WallpaperSettings::WallpaperSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.WallpaperSettings) +} +WallpaperSettings::WallpaperSettings(const WallpaperSettings& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + WallpaperSettings* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.filename_){} + , decltype(_impl_.opacity_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.filename_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filename_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_filename()) { + _this->_impl_.filename_.Set(from._internal_filename(), + _this->GetArenaForAllocation()); + } + _this->_impl_.opacity_ = from._impl_.opacity_; + // @@protoc_insertion_point(copy_constructor:proto.WallpaperSettings) +} + +inline void WallpaperSettings::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.filename_){} + , decltype(_impl_.opacity_){0u} + }; + _impl_.filename_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.filename_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +WallpaperSettings::~WallpaperSettings() { + // @@protoc_insertion_point(destructor:proto.WallpaperSettings) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void WallpaperSettings::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.filename_.Destroy(); +} + +void WallpaperSettings::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void WallpaperSettings::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.WallpaperSettings) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + _impl_.filename_.ClearNonDefaultToEmpty(); + } + _impl_.opacity_ = 0u; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* WallpaperSettings::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string filename = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_filename(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.WallpaperSettings.filename"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional uint32 opacity = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_opacity(&has_bits); + _impl_.opacity_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* WallpaperSettings::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.WallpaperSettings) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional string filename = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_filename().data(), static_cast(this->_internal_filename().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.WallpaperSettings.filename"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_filename(), target); + } + + // optional uint32 opacity = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_opacity(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.WallpaperSettings) + return target; +} + +size_t WallpaperSettings::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.WallpaperSettings) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional string filename = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_filename()); + } + + // optional uint32 opacity = 2; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_opacity()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData WallpaperSettings::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + WallpaperSettings::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*WallpaperSettings::GetClassData() const { return &_class_data_; } + + +void WallpaperSettings::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.WallpaperSettings) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_filename(from._internal_filename()); + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.opacity_ = from._impl_.opacity_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void WallpaperSettings::CopyFrom(const WallpaperSettings& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.WallpaperSettings) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool WallpaperSettings::IsInitialized() const { + return true; +} + +void WallpaperSettings::InternalSwap(WallpaperSettings* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.filename_, lhs_arena, + &other->_impl_.filename_, rhs_arena + ); + swap(_impl_.opacity_, other->_impl_.opacity_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata WallpaperSettings::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[220]); +} + +// =================================================================== + +class WebFeatures::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_labelsdisplay(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_voipindividualoutgoing(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_groupsv3(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_groupsv3create(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_changenumberv2(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_querystatusv3thumbnail(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_livelocations(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_queryvname(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_voipindividualincoming(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_quickrepliesquery(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_payments(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static void set_has_stickerpackquery(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static void set_has_livelocationsfinal(HasBits* has_bits) { + (*has_bits)[0] |= 4096u; + } + static void set_has_labelsedit(HasBits* has_bits) { + (*has_bits)[0] |= 8192u; + } + static void set_has_mediaupload(HasBits* has_bits) { + (*has_bits)[0] |= 16384u; + } + static void set_has_mediauploadrichquickreplies(HasBits* has_bits) { + (*has_bits)[0] |= 32768u; + } + static void set_has_vnamev2(HasBits* has_bits) { + (*has_bits)[0] |= 65536u; + } + static void set_has_videoplaybackurl(HasBits* has_bits) { + (*has_bits)[0] |= 131072u; + } + static void set_has_statusranking(HasBits* has_bits) { + (*has_bits)[0] |= 262144u; + } + static void set_has_voipindividualvideo(HasBits* has_bits) { + (*has_bits)[0] |= 524288u; + } + static void set_has_thirdpartystickers(HasBits* has_bits) { + (*has_bits)[0] |= 1048576u; + } + static void set_has_frequentlyforwardedsetting(HasBits* has_bits) { + (*has_bits)[0] |= 2097152u; + } + static void set_has_groupsv4joinpermission(HasBits* has_bits) { + (*has_bits)[0] |= 4194304u; + } + static void set_has_recentstickers(HasBits* has_bits) { + (*has_bits)[0] |= 8388608u; + } + static void set_has_catalog(HasBits* has_bits) { + (*has_bits)[0] |= 16777216u; + } + static void set_has_starredstickers(HasBits* has_bits) { + (*has_bits)[0] |= 33554432u; + } + static void set_has_voipgroupcall(HasBits* has_bits) { + (*has_bits)[0] |= 67108864u; + } + static void set_has_templatemessage(HasBits* has_bits) { + (*has_bits)[0] |= 134217728u; + } + static void set_has_templatemessageinteractivity(HasBits* has_bits) { + (*has_bits)[0] |= 268435456u; + } + static void set_has_ephemeralmessages(HasBits* has_bits) { + (*has_bits)[0] |= 536870912u; + } + static void set_has_e2enotificationsync(HasBits* has_bits) { + (*has_bits)[0] |= 1073741824u; + } + static void set_has_recentstickersv2(HasBits* has_bits) { + (*has_bits)[0] |= 2147483648u; + } + static void set_has_recentstickersv3(HasBits* has_bits) { + (*has_bits)[1] |= 1u; + } + static void set_has_usernotice(HasBits* has_bits) { + (*has_bits)[1] |= 2u; + } + static void set_has_support(HasBits* has_bits) { + (*has_bits)[1] |= 4u; + } + static void set_has_groupuiicleanup(HasBits* has_bits) { + (*has_bits)[1] |= 8u; + } + static void set_has_groupdogfoodinginternalonly(HasBits* has_bits) { + (*has_bits)[1] |= 16u; + } + static void set_has_settingssync(HasBits* has_bits) { + (*has_bits)[1] |= 32u; + } + static void set_has_archivev2(HasBits* has_bits) { + (*has_bits)[1] |= 64u; + } + static void set_has_ephemeralallowgroupmembers(HasBits* has_bits) { + (*has_bits)[1] |= 128u; + } + static void set_has_ephemeral24hduration(HasBits* has_bits) { + (*has_bits)[1] |= 256u; + } + static void set_has_mdforceupgrade(HasBits* has_bits) { + (*has_bits)[1] |= 512u; + } + static void set_has_disappearingmode(HasBits* has_bits) { + (*has_bits)[1] |= 1024u; + } + static void set_has_externalmdoptinavailable(HasBits* has_bits) { + (*has_bits)[1] |= 2048u; + } + static void set_has_nodeletemessagetimelimit(HasBits* has_bits) { + (*has_bits)[1] |= 4096u; + } +}; + +WebFeatures::WebFeatures(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.WebFeatures) +} +WebFeatures::WebFeatures(const WebFeatures& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + WebFeatures* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.labelsdisplay_){} + , decltype(_impl_.voipindividualoutgoing_){} + , decltype(_impl_.groupsv3_){} + , decltype(_impl_.groupsv3create_){} + , decltype(_impl_.changenumberv2_){} + , decltype(_impl_.querystatusv3thumbnail_){} + , decltype(_impl_.livelocations_){} + , decltype(_impl_.queryvname_){} + , decltype(_impl_.voipindividualincoming_){} + , decltype(_impl_.quickrepliesquery_){} + , decltype(_impl_.payments_){} + , decltype(_impl_.stickerpackquery_){} + , decltype(_impl_.livelocationsfinal_){} + , decltype(_impl_.labelsedit_){} + , decltype(_impl_.mediaupload_){} + , decltype(_impl_.mediauploadrichquickreplies_){} + , decltype(_impl_.vnamev2_){} + , decltype(_impl_.videoplaybackurl_){} + , decltype(_impl_.statusranking_){} + , decltype(_impl_.voipindividualvideo_){} + , decltype(_impl_.thirdpartystickers_){} + , decltype(_impl_.frequentlyforwardedsetting_){} + , decltype(_impl_.groupsv4joinpermission_){} + , decltype(_impl_.recentstickers_){} + , decltype(_impl_.catalog_){} + , decltype(_impl_.starredstickers_){} + , decltype(_impl_.voipgroupcall_){} + , decltype(_impl_.templatemessage_){} + , decltype(_impl_.templatemessageinteractivity_){} + , decltype(_impl_.ephemeralmessages_){} + , decltype(_impl_.e2enotificationsync_){} + , decltype(_impl_.recentstickersv2_){} + , decltype(_impl_.recentstickersv3_){} + , decltype(_impl_.usernotice_){} + , decltype(_impl_.support_){} + , decltype(_impl_.groupuiicleanup_){} + , decltype(_impl_.groupdogfoodinginternalonly_){} + , decltype(_impl_.settingssync_){} + , decltype(_impl_.archivev2_){} + , decltype(_impl_.ephemeralallowgroupmembers_){} + , decltype(_impl_.ephemeral24hduration_){} + , decltype(_impl_.mdforceupgrade_){} + , decltype(_impl_.disappearingmode_){} + , decltype(_impl_.externalmdoptinavailable_){} + , decltype(_impl_.nodeletemessagetimelimit_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&_impl_.labelsdisplay_, &from._impl_.labelsdisplay_, + static_cast(reinterpret_cast(&_impl_.nodeletemessagetimelimit_) - + reinterpret_cast(&_impl_.labelsdisplay_)) + sizeof(_impl_.nodeletemessagetimelimit_)); + // @@protoc_insertion_point(copy_constructor:proto.WebFeatures) +} + +inline void WebFeatures::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.labelsdisplay_){0} + , decltype(_impl_.voipindividualoutgoing_){0} + , decltype(_impl_.groupsv3_){0} + , decltype(_impl_.groupsv3create_){0} + , decltype(_impl_.changenumberv2_){0} + , decltype(_impl_.querystatusv3thumbnail_){0} + , decltype(_impl_.livelocations_){0} + , decltype(_impl_.queryvname_){0} + , decltype(_impl_.voipindividualincoming_){0} + , decltype(_impl_.quickrepliesquery_){0} + , decltype(_impl_.payments_){0} + , decltype(_impl_.stickerpackquery_){0} + , decltype(_impl_.livelocationsfinal_){0} + , decltype(_impl_.labelsedit_){0} + , decltype(_impl_.mediaupload_){0} + , decltype(_impl_.mediauploadrichquickreplies_){0} + , decltype(_impl_.vnamev2_){0} + , decltype(_impl_.videoplaybackurl_){0} + , decltype(_impl_.statusranking_){0} + , decltype(_impl_.voipindividualvideo_){0} + , decltype(_impl_.thirdpartystickers_){0} + , decltype(_impl_.frequentlyforwardedsetting_){0} + , decltype(_impl_.groupsv4joinpermission_){0} + , decltype(_impl_.recentstickers_){0} + , decltype(_impl_.catalog_){0} + , decltype(_impl_.starredstickers_){0} + , decltype(_impl_.voipgroupcall_){0} + , decltype(_impl_.templatemessage_){0} + , decltype(_impl_.templatemessageinteractivity_){0} + , decltype(_impl_.ephemeralmessages_){0} + , decltype(_impl_.e2enotificationsync_){0} + , decltype(_impl_.recentstickersv2_){0} + , decltype(_impl_.recentstickersv3_){0} + , decltype(_impl_.usernotice_){0} + , decltype(_impl_.support_){0} + , decltype(_impl_.groupuiicleanup_){0} + , decltype(_impl_.groupdogfoodinginternalonly_){0} + , decltype(_impl_.settingssync_){0} + , decltype(_impl_.archivev2_){0} + , decltype(_impl_.ephemeralallowgroupmembers_){0} + , decltype(_impl_.ephemeral24hduration_){0} + , decltype(_impl_.mdforceupgrade_){0} + , decltype(_impl_.disappearingmode_){0} + , decltype(_impl_.externalmdoptinavailable_){0} + , decltype(_impl_.nodeletemessagetimelimit_){0} + }; +} + +WebFeatures::~WebFeatures() { + // @@protoc_insertion_point(destructor:proto.WebFeatures) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void WebFeatures::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void WebFeatures::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void WebFeatures::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.WebFeatures) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + ::memset(&_impl_.labelsdisplay_, 0, static_cast( + reinterpret_cast(&_impl_.queryvname_) - + reinterpret_cast(&_impl_.labelsdisplay_)) + sizeof(_impl_.queryvname_)); + } + if (cached_has_bits & 0x0000ff00u) { + ::memset(&_impl_.voipindividualincoming_, 0, static_cast( + reinterpret_cast(&_impl_.mediauploadrichquickreplies_) - + reinterpret_cast(&_impl_.voipindividualincoming_)) + sizeof(_impl_.mediauploadrichquickreplies_)); + } + if (cached_has_bits & 0x00ff0000u) { + ::memset(&_impl_.vnamev2_, 0, static_cast( + reinterpret_cast(&_impl_.recentstickers_) - + reinterpret_cast(&_impl_.vnamev2_)) + sizeof(_impl_.recentstickers_)); + } + if (cached_has_bits & 0xff000000u) { + ::memset(&_impl_.catalog_, 0, static_cast( + reinterpret_cast(&_impl_.recentstickersv2_) - + reinterpret_cast(&_impl_.catalog_)) + sizeof(_impl_.recentstickersv2_)); + } + cached_has_bits = _impl_._has_bits_[1]; + if (cached_has_bits & 0x000000ffu) { + ::memset(&_impl_.recentstickersv3_, 0, static_cast( + reinterpret_cast(&_impl_.ephemeralallowgroupmembers_) - + reinterpret_cast(&_impl_.recentstickersv3_)) + sizeof(_impl_.ephemeralallowgroupmembers_)); + } + if (cached_has_bits & 0x00001f00u) { + ::memset(&_impl_.ephemeral24hduration_, 0, static_cast( + reinterpret_cast(&_impl_.nodeletemessagetimelimit_) - + reinterpret_cast(&_impl_.ephemeral24hduration_)) + sizeof(_impl_.nodeletemessagetimelimit_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* WebFeatures::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .proto.WebFeatures.Flag labelsDisplay = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_labelsdisplay(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag voipIndividualOutgoing = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_voipindividualoutgoing(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag groupsV3 = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_groupsv3(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag groupsV3Create = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_groupsv3create(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag changeNumberV2 = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_changenumberv2(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag queryStatusV3Thumbnail = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_querystatusv3thumbnail(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(6, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag liveLocations = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_livelocations(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(7, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag queryVname = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_queryvname(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(8, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag voipIndividualIncoming = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_voipindividualincoming(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(9, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag quickRepliesQuery = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_quickrepliesquery(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(10, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag payments = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_payments(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(11, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag stickerPackQuery = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_stickerpackquery(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(12, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag liveLocationsFinal = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 104)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_livelocationsfinal(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(13, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag labelsEdit = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 112)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_labelsedit(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(14, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag mediaUpload = 15; + case 15: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 120)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_mediaupload(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(15, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag mediaUploadRichQuickReplies = 18; + case 18: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 144)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_mediauploadrichquickreplies(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(18, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag vnameV2 = 19; + case 19: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 152)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_vnamev2(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(19, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag videoPlaybackUrl = 20; + case 20: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 160)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_videoplaybackurl(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(20, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag statusRanking = 21; + case 21: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 168)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_statusranking(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(21, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag voipIndividualVideo = 22; + case 22: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 176)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_voipindividualvideo(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(22, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag thirdPartyStickers = 23; + case 23: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 184)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_thirdpartystickers(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(23, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag frequentlyForwardedSetting = 24; + case 24: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 192)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_frequentlyforwardedsetting(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(24, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag groupsV4JoinPermission = 25; + case 25: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 200)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_groupsv4joinpermission(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(25, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag recentStickers = 26; + case 26: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 208)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_recentstickers(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(26, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag catalog = 27; + case 27: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 216)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_catalog(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(27, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag starredStickers = 28; + case 28: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 224)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_starredstickers(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(28, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag voipGroupCall = 29; + case 29: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 232)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_voipgroupcall(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(29, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag templateMessage = 30; + case 30: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 240)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_templatemessage(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(30, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag templateMessageInteractivity = 31; + case 31: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 248)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_templatemessageinteractivity(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(31, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag ephemeralMessages = 32; + case 32: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 0)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_ephemeralmessages(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(32, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag e2ENotificationSync = 33; + case 33: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_e2enotificationsync(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(33, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag recentStickersV2 = 34; + case 34: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_recentstickersv2(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(34, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag recentStickersV3 = 36; + case 36: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_recentstickersv3(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(36, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag userNotice = 37; + case 37: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_usernotice(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(37, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag support = 39; + case 39: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_support(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(39, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag groupUiiCleanup = 40; + case 40: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_groupuiicleanup(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(40, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag groupDogfoodingInternalOnly = 41; + case 41: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_groupdogfoodinginternalonly(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(41, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag settingsSync = 42; + case 42: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_settingssync(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(42, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag archiveV2 = 43; + case 43: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_archivev2(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(43, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag ephemeralAllowGroupMembers = 44; + case 44: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_ephemeralallowgroupmembers(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(44, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag ephemeral24HDuration = 45; + case 45: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 104)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_ephemeral24hduration(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(45, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag mdForceUpgrade = 46; + case 46: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 112)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_mdforceupgrade(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(46, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag disappearingMode = 47; + case 47: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 120)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_disappearingmode(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(47, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag externalMdOptInAvailable = 48; + case 48: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 128)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_externalmdoptinavailable(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(48, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .proto.WebFeatures.Flag noDeleteMessageTimeLimit = 49; + case 49: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 136)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { + _internal_set_nodeletemessagetimelimit(static_cast<::proto::WebFeatures_Flag>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(49, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* WebFeatures::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.WebFeatures) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional .proto.WebFeatures.Flag labelsDisplay = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this->_internal_labelsdisplay(), target); + } + + // optional .proto.WebFeatures.Flag voipIndividualOutgoing = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this->_internal_voipindividualoutgoing(), target); + } + + // optional .proto.WebFeatures.Flag groupsV3 = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 3, this->_internal_groupsv3(), target); + } + + // optional .proto.WebFeatures.Flag groupsV3Create = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 4, this->_internal_groupsv3create(), target); + } + + // optional .proto.WebFeatures.Flag changeNumberV2 = 5; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 5, this->_internal_changenumberv2(), target); + } + + // optional .proto.WebFeatures.Flag queryStatusV3Thumbnail = 6; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 6, this->_internal_querystatusv3thumbnail(), target); + } + + // optional .proto.WebFeatures.Flag liveLocations = 7; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 7, this->_internal_livelocations(), target); + } + + // optional .proto.WebFeatures.Flag queryVname = 8; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 8, this->_internal_queryvname(), target); + } + + // optional .proto.WebFeatures.Flag voipIndividualIncoming = 9; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 9, this->_internal_voipindividualincoming(), target); + } + + // optional .proto.WebFeatures.Flag quickRepliesQuery = 10; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 10, this->_internal_quickrepliesquery(), target); + } + + // optional .proto.WebFeatures.Flag payments = 11; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 11, this->_internal_payments(), target); + } + + // optional .proto.WebFeatures.Flag stickerPackQuery = 12; + if (cached_has_bits & 0x00000800u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 12, this->_internal_stickerpackquery(), target); + } + + // optional .proto.WebFeatures.Flag liveLocationsFinal = 13; + if (cached_has_bits & 0x00001000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 13, this->_internal_livelocationsfinal(), target); + } + + // optional .proto.WebFeatures.Flag labelsEdit = 14; + if (cached_has_bits & 0x00002000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 14, this->_internal_labelsedit(), target); + } + + // optional .proto.WebFeatures.Flag mediaUpload = 15; + if (cached_has_bits & 0x00004000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 15, this->_internal_mediaupload(), target); + } + + // optional .proto.WebFeatures.Flag mediaUploadRichQuickReplies = 18; + if (cached_has_bits & 0x00008000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 18, this->_internal_mediauploadrichquickreplies(), target); + } + + // optional .proto.WebFeatures.Flag vnameV2 = 19; + if (cached_has_bits & 0x00010000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 19, this->_internal_vnamev2(), target); + } + + // optional .proto.WebFeatures.Flag videoPlaybackUrl = 20; + if (cached_has_bits & 0x00020000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 20, this->_internal_videoplaybackurl(), target); + } + + // optional .proto.WebFeatures.Flag statusRanking = 21; + if (cached_has_bits & 0x00040000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 21, this->_internal_statusranking(), target); + } + + // optional .proto.WebFeatures.Flag voipIndividualVideo = 22; + if (cached_has_bits & 0x00080000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 22, this->_internal_voipindividualvideo(), target); + } + + // optional .proto.WebFeatures.Flag thirdPartyStickers = 23; + if (cached_has_bits & 0x00100000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 23, this->_internal_thirdpartystickers(), target); + } + + // optional .proto.WebFeatures.Flag frequentlyForwardedSetting = 24; + if (cached_has_bits & 0x00200000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 24, this->_internal_frequentlyforwardedsetting(), target); + } + + // optional .proto.WebFeatures.Flag groupsV4JoinPermission = 25; + if (cached_has_bits & 0x00400000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 25, this->_internal_groupsv4joinpermission(), target); + } + + // optional .proto.WebFeatures.Flag recentStickers = 26; + if (cached_has_bits & 0x00800000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 26, this->_internal_recentstickers(), target); + } + + // optional .proto.WebFeatures.Flag catalog = 27; + if (cached_has_bits & 0x01000000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 27, this->_internal_catalog(), target); + } + + // optional .proto.WebFeatures.Flag starredStickers = 28; + if (cached_has_bits & 0x02000000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 28, this->_internal_starredstickers(), target); + } + + // optional .proto.WebFeatures.Flag voipGroupCall = 29; + if (cached_has_bits & 0x04000000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 29, this->_internal_voipgroupcall(), target); + } + + // optional .proto.WebFeatures.Flag templateMessage = 30; + if (cached_has_bits & 0x08000000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 30, this->_internal_templatemessage(), target); + } + + // optional .proto.WebFeatures.Flag templateMessageInteractivity = 31; + if (cached_has_bits & 0x10000000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 31, this->_internal_templatemessageinteractivity(), target); + } + + // optional .proto.WebFeatures.Flag ephemeralMessages = 32; + if (cached_has_bits & 0x20000000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 32, this->_internal_ephemeralmessages(), target); + } + + // optional .proto.WebFeatures.Flag e2ENotificationSync = 33; + if (cached_has_bits & 0x40000000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 33, this->_internal_e2enotificationsync(), target); + } + + // optional .proto.WebFeatures.Flag recentStickersV2 = 34; + if (cached_has_bits & 0x80000000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 34, this->_internal_recentstickersv2(), target); + } + + cached_has_bits = _impl_._has_bits_[1]; + // optional .proto.WebFeatures.Flag recentStickersV3 = 36; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 36, this->_internal_recentstickersv3(), target); + } + + // optional .proto.WebFeatures.Flag userNotice = 37; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 37, this->_internal_usernotice(), target); + } + + // optional .proto.WebFeatures.Flag support = 39; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 39, this->_internal_support(), target); + } + + // optional .proto.WebFeatures.Flag groupUiiCleanup = 40; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 40, this->_internal_groupuiicleanup(), target); + } + + // optional .proto.WebFeatures.Flag groupDogfoodingInternalOnly = 41; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 41, this->_internal_groupdogfoodinginternalonly(), target); + } + + // optional .proto.WebFeatures.Flag settingsSync = 42; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 42, this->_internal_settingssync(), target); + } + + // optional .proto.WebFeatures.Flag archiveV2 = 43; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 43, this->_internal_archivev2(), target); + } + + // optional .proto.WebFeatures.Flag ephemeralAllowGroupMembers = 44; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 44, this->_internal_ephemeralallowgroupmembers(), target); + } + + // optional .proto.WebFeatures.Flag ephemeral24HDuration = 45; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 45, this->_internal_ephemeral24hduration(), target); + } + + // optional .proto.WebFeatures.Flag mdForceUpgrade = 46; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 46, this->_internal_mdforceupgrade(), target); + } + + // optional .proto.WebFeatures.Flag disappearingMode = 47; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 47, this->_internal_disappearingmode(), target); + } + + // optional .proto.WebFeatures.Flag externalMdOptInAvailable = 48; + if (cached_has_bits & 0x00000800u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 48, this->_internal_externalmdoptinavailable(), target); + } + + // optional .proto.WebFeatures.Flag noDeleteMessageTimeLimit = 49; + if (cached_has_bits & 0x00001000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 49, this->_internal_nodeletemessagetimelimit(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.WebFeatures) + return target; +} + +size_t WebFeatures::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.WebFeatures) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional .proto.WebFeatures.Flag labelsDisplay = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_labelsdisplay()); + } + + // optional .proto.WebFeatures.Flag voipIndividualOutgoing = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_voipindividualoutgoing()); + } + + // optional .proto.WebFeatures.Flag groupsV3 = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_groupsv3()); + } + + // optional .proto.WebFeatures.Flag groupsV3Create = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_groupsv3create()); + } + + // optional .proto.WebFeatures.Flag changeNumberV2 = 5; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_changenumberv2()); + } + + // optional .proto.WebFeatures.Flag queryStatusV3Thumbnail = 6; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_querystatusv3thumbnail()); + } + + // optional .proto.WebFeatures.Flag liveLocations = 7; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_livelocations()); + } + + // optional .proto.WebFeatures.Flag queryVname = 8; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_queryvname()); + } + + } + if (cached_has_bits & 0x0000ff00u) { + // optional .proto.WebFeatures.Flag voipIndividualIncoming = 9; + if (cached_has_bits & 0x00000100u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_voipindividualincoming()); + } + + // optional .proto.WebFeatures.Flag quickRepliesQuery = 10; + if (cached_has_bits & 0x00000200u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_quickrepliesquery()); + } + + // optional .proto.WebFeatures.Flag payments = 11; + if (cached_has_bits & 0x00000400u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_payments()); + } + + // optional .proto.WebFeatures.Flag stickerPackQuery = 12; + if (cached_has_bits & 0x00000800u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_stickerpackquery()); + } + + // optional .proto.WebFeatures.Flag liveLocationsFinal = 13; + if (cached_has_bits & 0x00001000u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_livelocationsfinal()); + } + + // optional .proto.WebFeatures.Flag labelsEdit = 14; + if (cached_has_bits & 0x00002000u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_labelsedit()); + } + + // optional .proto.WebFeatures.Flag mediaUpload = 15; + if (cached_has_bits & 0x00004000u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_mediaupload()); + } + + // optional .proto.WebFeatures.Flag mediaUploadRichQuickReplies = 18; + if (cached_has_bits & 0x00008000u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_mediauploadrichquickreplies()); + } + + } + if (cached_has_bits & 0x00ff0000u) { + // optional .proto.WebFeatures.Flag vnameV2 = 19; + if (cached_has_bits & 0x00010000u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_vnamev2()); + } + + // optional .proto.WebFeatures.Flag videoPlaybackUrl = 20; + if (cached_has_bits & 0x00020000u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_videoplaybackurl()); + } + + // optional .proto.WebFeatures.Flag statusRanking = 21; + if (cached_has_bits & 0x00040000u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_statusranking()); + } + + // optional .proto.WebFeatures.Flag voipIndividualVideo = 22; + if (cached_has_bits & 0x00080000u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_voipindividualvideo()); + } + + // optional .proto.WebFeatures.Flag thirdPartyStickers = 23; + if (cached_has_bits & 0x00100000u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_thirdpartystickers()); + } + + // optional .proto.WebFeatures.Flag frequentlyForwardedSetting = 24; + if (cached_has_bits & 0x00200000u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_frequentlyforwardedsetting()); + } + + // optional .proto.WebFeatures.Flag groupsV4JoinPermission = 25; + if (cached_has_bits & 0x00400000u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_groupsv4joinpermission()); + } + + // optional .proto.WebFeatures.Flag recentStickers = 26; + if (cached_has_bits & 0x00800000u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_recentstickers()); + } + + } + if (cached_has_bits & 0xff000000u) { + // optional .proto.WebFeatures.Flag catalog = 27; + if (cached_has_bits & 0x01000000u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_catalog()); + } + + // optional .proto.WebFeatures.Flag starredStickers = 28; + if (cached_has_bits & 0x02000000u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_starredstickers()); + } + + // optional .proto.WebFeatures.Flag voipGroupCall = 29; + if (cached_has_bits & 0x04000000u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_voipgroupcall()); + } + + // optional .proto.WebFeatures.Flag templateMessage = 30; + if (cached_has_bits & 0x08000000u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_templatemessage()); + } + + // optional .proto.WebFeatures.Flag templateMessageInteractivity = 31; + if (cached_has_bits & 0x10000000u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_templatemessageinteractivity()); + } + + // optional .proto.WebFeatures.Flag ephemeralMessages = 32; + if (cached_has_bits & 0x20000000u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_ephemeralmessages()); + } + + // optional .proto.WebFeatures.Flag e2ENotificationSync = 33; + if (cached_has_bits & 0x40000000u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_e2enotificationsync()); + } + + // optional .proto.WebFeatures.Flag recentStickersV2 = 34; + if (cached_has_bits & 0x80000000u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_recentstickersv2()); + } + + } + cached_has_bits = _impl_._has_bits_[1]; + if (cached_has_bits & 0x000000ffu) { + // optional .proto.WebFeatures.Flag recentStickersV3 = 36; + if (cached_has_bits & 0x00000001u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_recentstickersv3()); + } + + // optional .proto.WebFeatures.Flag userNotice = 37; + if (cached_has_bits & 0x00000002u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_usernotice()); + } + + // optional .proto.WebFeatures.Flag support = 39; + if (cached_has_bits & 0x00000004u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_support()); + } + + // optional .proto.WebFeatures.Flag groupUiiCleanup = 40; + if (cached_has_bits & 0x00000008u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_groupuiicleanup()); + } + + // optional .proto.WebFeatures.Flag groupDogfoodingInternalOnly = 41; + if (cached_has_bits & 0x00000010u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_groupdogfoodinginternalonly()); + } + + // optional .proto.WebFeatures.Flag settingsSync = 42; + if (cached_has_bits & 0x00000020u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_settingssync()); + } + + // optional .proto.WebFeatures.Flag archiveV2 = 43; + if (cached_has_bits & 0x00000040u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_archivev2()); + } + + // optional .proto.WebFeatures.Flag ephemeralAllowGroupMembers = 44; + if (cached_has_bits & 0x00000080u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_ephemeralallowgroupmembers()); + } + + } + if (cached_has_bits & 0x00001f00u) { + // optional .proto.WebFeatures.Flag ephemeral24HDuration = 45; + if (cached_has_bits & 0x00000100u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_ephemeral24hduration()); + } + + // optional .proto.WebFeatures.Flag mdForceUpgrade = 46; + if (cached_has_bits & 0x00000200u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_mdforceupgrade()); + } + + // optional .proto.WebFeatures.Flag disappearingMode = 47; + if (cached_has_bits & 0x00000400u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_disappearingmode()); + } + + // optional .proto.WebFeatures.Flag externalMdOptInAvailable = 48; + if (cached_has_bits & 0x00000800u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_externalmdoptinavailable()); + } + + // optional .proto.WebFeatures.Flag noDeleteMessageTimeLimit = 49; + if (cached_has_bits & 0x00001000u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_nodeletemessagetimelimit()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData WebFeatures::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + WebFeatures::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*WebFeatures::GetClassData() const { return &_class_data_; } + + +void WebFeatures::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.WebFeatures) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_impl_.labelsdisplay_ = from._impl_.labelsdisplay_; + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.voipindividualoutgoing_ = from._impl_.voipindividualoutgoing_; + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.groupsv3_ = from._impl_.groupsv3_; + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.groupsv3create_ = from._impl_.groupsv3create_; + } + if (cached_has_bits & 0x00000010u) { + _this->_impl_.changenumberv2_ = from._impl_.changenumberv2_; + } + if (cached_has_bits & 0x00000020u) { + _this->_impl_.querystatusv3thumbnail_ = from._impl_.querystatusv3thumbnail_; + } + if (cached_has_bits & 0x00000040u) { + _this->_impl_.livelocations_ = from._impl_.livelocations_; + } + if (cached_has_bits & 0x00000080u) { + _this->_impl_.queryvname_ = from._impl_.queryvname_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x0000ff00u) { + if (cached_has_bits & 0x00000100u) { + _this->_impl_.voipindividualincoming_ = from._impl_.voipindividualincoming_; + } + if (cached_has_bits & 0x00000200u) { + _this->_impl_.quickrepliesquery_ = from._impl_.quickrepliesquery_; + } + if (cached_has_bits & 0x00000400u) { + _this->_impl_.payments_ = from._impl_.payments_; + } + if (cached_has_bits & 0x00000800u) { + _this->_impl_.stickerpackquery_ = from._impl_.stickerpackquery_; + } + if (cached_has_bits & 0x00001000u) { + _this->_impl_.livelocationsfinal_ = from._impl_.livelocationsfinal_; + } + if (cached_has_bits & 0x00002000u) { + _this->_impl_.labelsedit_ = from._impl_.labelsedit_; + } + if (cached_has_bits & 0x00004000u) { + _this->_impl_.mediaupload_ = from._impl_.mediaupload_; + } + if (cached_has_bits & 0x00008000u) { + _this->_impl_.mediauploadrichquickreplies_ = from._impl_.mediauploadrichquickreplies_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00ff0000u) { + if (cached_has_bits & 0x00010000u) { + _this->_impl_.vnamev2_ = from._impl_.vnamev2_; + } + if (cached_has_bits & 0x00020000u) { + _this->_impl_.videoplaybackurl_ = from._impl_.videoplaybackurl_; + } + if (cached_has_bits & 0x00040000u) { + _this->_impl_.statusranking_ = from._impl_.statusranking_; + } + if (cached_has_bits & 0x00080000u) { + _this->_impl_.voipindividualvideo_ = from._impl_.voipindividualvideo_; + } + if (cached_has_bits & 0x00100000u) { + _this->_impl_.thirdpartystickers_ = from._impl_.thirdpartystickers_; + } + if (cached_has_bits & 0x00200000u) { + _this->_impl_.frequentlyforwardedsetting_ = from._impl_.frequentlyforwardedsetting_; + } + if (cached_has_bits & 0x00400000u) { + _this->_impl_.groupsv4joinpermission_ = from._impl_.groupsv4joinpermission_; + } + if (cached_has_bits & 0x00800000u) { + _this->_impl_.recentstickers_ = from._impl_.recentstickers_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0xff000000u) { + if (cached_has_bits & 0x01000000u) { + _this->_impl_.catalog_ = from._impl_.catalog_; + } + if (cached_has_bits & 0x02000000u) { + _this->_impl_.starredstickers_ = from._impl_.starredstickers_; + } + if (cached_has_bits & 0x04000000u) { + _this->_impl_.voipgroupcall_ = from._impl_.voipgroupcall_; + } + if (cached_has_bits & 0x08000000u) { + _this->_impl_.templatemessage_ = from._impl_.templatemessage_; + } + if (cached_has_bits & 0x10000000u) { + _this->_impl_.templatemessageinteractivity_ = from._impl_.templatemessageinteractivity_; + } + if (cached_has_bits & 0x20000000u) { + _this->_impl_.ephemeralmessages_ = from._impl_.ephemeralmessages_; + } + if (cached_has_bits & 0x40000000u) { + _this->_impl_.e2enotificationsync_ = from._impl_.e2enotificationsync_; + } + if (cached_has_bits & 0x80000000u) { + _this->_impl_.recentstickersv2_ = from._impl_.recentstickersv2_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + cached_has_bits = from._impl_._has_bits_[1]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_impl_.recentstickersv3_ = from._impl_.recentstickersv3_; + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.usernotice_ = from._impl_.usernotice_; + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.support_ = from._impl_.support_; + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.groupuiicleanup_ = from._impl_.groupuiicleanup_; + } + if (cached_has_bits & 0x00000010u) { + _this->_impl_.groupdogfoodinginternalonly_ = from._impl_.groupdogfoodinginternalonly_; + } + if (cached_has_bits & 0x00000020u) { + _this->_impl_.settingssync_ = from._impl_.settingssync_; + } + if (cached_has_bits & 0x00000040u) { + _this->_impl_.archivev2_ = from._impl_.archivev2_; + } + if (cached_has_bits & 0x00000080u) { + _this->_impl_.ephemeralallowgroupmembers_ = from._impl_.ephemeralallowgroupmembers_; + } + _this->_impl_._has_bits_[1] |= cached_has_bits; + } + if (cached_has_bits & 0x00001f00u) { + if (cached_has_bits & 0x00000100u) { + _this->_impl_.ephemeral24hduration_ = from._impl_.ephemeral24hduration_; + } + if (cached_has_bits & 0x00000200u) { + _this->_impl_.mdforceupgrade_ = from._impl_.mdforceupgrade_; + } + if (cached_has_bits & 0x00000400u) { + _this->_impl_.disappearingmode_ = from._impl_.disappearingmode_; + } + if (cached_has_bits & 0x00000800u) { + _this->_impl_.externalmdoptinavailable_ = from._impl_.externalmdoptinavailable_; + } + if (cached_has_bits & 0x00001000u) { + _this->_impl_.nodeletemessagetimelimit_ = from._impl_.nodeletemessagetimelimit_; + } + _this->_impl_._has_bits_[1] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void WebFeatures::CopyFrom(const WebFeatures& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.WebFeatures) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool WebFeatures::IsInitialized() const { + return true; +} + +void WebFeatures::InternalSwap(WebFeatures* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_._has_bits_[1], other->_impl_._has_bits_[1]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(WebFeatures, _impl_.nodeletemessagetimelimit_) + + sizeof(WebFeatures::_impl_.nodeletemessagetimelimit_) + - PROTOBUF_FIELD_OFFSET(WebFeatures, _impl_.labelsdisplay_)>( + reinterpret_cast(&_impl_.labelsdisplay_), + reinterpret_cast(&other->_impl_.labelsdisplay_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata WebFeatures::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[221]); +} + +// =================================================================== + +class WebMessageInfo::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static const ::proto::MessageKey& key(const WebMessageInfo* msg); + static void set_has_key(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static const ::proto::Message& message(const WebMessageInfo* msg); + static void set_has_message(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_messagetimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 524288u; + } + static void set_has_status(HasBits* has_bits) { + (*has_bits)[0] |= 2097152u; + } + static void set_has_participant(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_messagec2stimestamp(HasBits* has_bits) { + (*has_bits)[0] |= 1048576u; + } + static void set_has_ignore(HasBits* has_bits) { + (*has_bits)[0] |= 4194304u; + } + static void set_has_starred(HasBits* has_bits) { + (*has_bits)[0] |= 8388608u; + } + static void set_has_broadcast(HasBits* has_bits) { + (*has_bits)[0] |= 16777216u; + } + static void set_has_pushname(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_mediaciphertextsha256(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_multicast(HasBits* has_bits) { + (*has_bits)[0] |= 33554432u; + } + static void set_has_urltext(HasBits* has_bits) { + (*has_bits)[0] |= 134217728u; + } + static void set_has_urlnumber(HasBits* has_bits) { + (*has_bits)[0] |= 268435456u; + } + static void set_has_messagestubtype(HasBits* has_bits) { + (*has_bits)[0] |= 67108864u; + } + static void set_has_clearmedia(HasBits* has_bits) { + (*has_bits)[0] |= 536870912u; + } + static void set_has_duration(HasBits* has_bits) { + (*has_bits)[0] |= 2147483648u; + } + static const ::proto::PaymentInfo& paymentinfo(const WebMessageInfo* msg); + static void set_has_paymentinfo(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static const ::proto::Message_LiveLocationMessage& finallivelocation(const WebMessageInfo* msg); + static void set_has_finallivelocation(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static const ::proto::PaymentInfo& quotedpaymentinfo(const WebMessageInfo* msg); + static void set_has_quotedpaymentinfo(HasBits* has_bits) { + (*has_bits)[0] |= 4096u; + } + static void set_has_ephemeralstarttimestamp(HasBits* has_bits) { + (*has_bits)[1] |= 2u; + } + static void set_has_ephemeralduration(HasBits* has_bits) { + (*has_bits)[1] |= 1u; + } + static void set_has_ephemeralofftoon(HasBits* has_bits) { + (*has_bits)[0] |= 1073741824u; + } + static void set_has_ephemeraloutofsync(HasBits* has_bits) { + (*has_bits)[1] |= 8u; + } + static void set_has_bizprivacystatus(HasBits* has_bits) { + (*has_bits)[1] |= 4u; + } + static void set_has_verifiedbizname(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static const ::proto::MediaData& mediadata(const WebMessageInfo* msg); + static void set_has_mediadata(HasBits* has_bits) { + (*has_bits)[0] |= 8192u; + } + static const ::proto::PhotoChange& photochange(const WebMessageInfo* msg); + static void set_has_photochange(HasBits* has_bits) { + (*has_bits)[0] |= 16384u; + } + static const ::proto::MediaData& quotedstickerdata(const WebMessageInfo* msg); + static void set_has_quotedstickerdata(HasBits* has_bits) { + (*has_bits)[0] |= 32768u; + } + static void set_has_futureproofdata(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static const ::proto::StatusPSA& statuspsa(const WebMessageInfo* msg); + static void set_has_statuspsa(HasBits* has_bits) { + (*has_bits)[0] |= 65536u; + } + static const ::proto::PollAdditionalMetadata& polladditionalmetadata(const WebMessageInfo* msg); + static void set_has_polladditionalmetadata(HasBits* has_bits) { + (*has_bits)[0] |= 131072u; + } + static void set_has_agentid(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_statusalreadyviewed(HasBits* has_bits) { + (*has_bits)[1] |= 16u; + } + static void set_has_messagesecret(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static const ::proto::KeepInChat& keepinchat(const WebMessageInfo* msg); + static void set_has_keepinchat(HasBits* has_bits) { + (*has_bits)[0] |= 262144u; + } + static void set_has_originalselfauthoruserjidstring(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_revokemessagetimestamp(HasBits* has_bits) { + (*has_bits)[1] |= 32u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000100) ^ 0x00000100) != 0; + } +}; + +const ::proto::MessageKey& +WebMessageInfo::_Internal::key(const WebMessageInfo* msg) { + return *msg->_impl_.key_; +} +const ::proto::Message& +WebMessageInfo::_Internal::message(const WebMessageInfo* msg) { + return *msg->_impl_.message_; +} +const ::proto::PaymentInfo& +WebMessageInfo::_Internal::paymentinfo(const WebMessageInfo* msg) { + return *msg->_impl_.paymentinfo_; +} +const ::proto::Message_LiveLocationMessage& +WebMessageInfo::_Internal::finallivelocation(const WebMessageInfo* msg) { + return *msg->_impl_.finallivelocation_; +} +const ::proto::PaymentInfo& +WebMessageInfo::_Internal::quotedpaymentinfo(const WebMessageInfo* msg) { + return *msg->_impl_.quotedpaymentinfo_; +} +const ::proto::MediaData& +WebMessageInfo::_Internal::mediadata(const WebMessageInfo* msg) { + return *msg->_impl_.mediadata_; +} +const ::proto::PhotoChange& +WebMessageInfo::_Internal::photochange(const WebMessageInfo* msg) { + return *msg->_impl_.photochange_; +} +const ::proto::MediaData& +WebMessageInfo::_Internal::quotedstickerdata(const WebMessageInfo* msg) { + return *msg->_impl_.quotedstickerdata_; +} +const ::proto::StatusPSA& +WebMessageInfo::_Internal::statuspsa(const WebMessageInfo* msg) { + return *msg->_impl_.statuspsa_; +} +const ::proto::PollAdditionalMetadata& +WebMessageInfo::_Internal::polladditionalmetadata(const WebMessageInfo* msg) { + return *msg->_impl_.polladditionalmetadata_; +} +const ::proto::KeepInChat& +WebMessageInfo::_Internal::keepinchat(const WebMessageInfo* msg) { + return *msg->_impl_.keepinchat_; +} +WebMessageInfo::WebMessageInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.WebMessageInfo) +} +WebMessageInfo::WebMessageInfo(const WebMessageInfo& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + WebMessageInfo* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.messagestubparameters_){from._impl_.messagestubparameters_} + , decltype(_impl_.labels_){from._impl_.labels_} + , decltype(_impl_.userreceipt_){from._impl_.userreceipt_} + , decltype(_impl_.reactions_){from._impl_.reactions_} + , decltype(_impl_.pollupdates_){from._impl_.pollupdates_} + , decltype(_impl_.participant_){} + , decltype(_impl_.pushname_){} + , decltype(_impl_.mediaciphertextsha256_){} + , decltype(_impl_.verifiedbizname_){} + , decltype(_impl_.futureproofdata_){} + , decltype(_impl_.agentid_){} + , decltype(_impl_.messagesecret_){} + , decltype(_impl_.originalselfauthoruserjidstring_){} + , decltype(_impl_.key_){nullptr} + , decltype(_impl_.message_){nullptr} + , decltype(_impl_.paymentinfo_){nullptr} + , decltype(_impl_.finallivelocation_){nullptr} + , decltype(_impl_.quotedpaymentinfo_){nullptr} + , decltype(_impl_.mediadata_){nullptr} + , decltype(_impl_.photochange_){nullptr} + , decltype(_impl_.quotedstickerdata_){nullptr} + , decltype(_impl_.statuspsa_){nullptr} + , decltype(_impl_.polladditionalmetadata_){nullptr} + , decltype(_impl_.keepinchat_){nullptr} + , decltype(_impl_.messagetimestamp_){} + , decltype(_impl_.messagec2stimestamp_){} + , decltype(_impl_.status_){} + , decltype(_impl_.ignore_){} + , decltype(_impl_.starred_){} + , decltype(_impl_.broadcast_){} + , decltype(_impl_.multicast_){} + , decltype(_impl_.messagestubtype_){} + , decltype(_impl_.urltext_){} + , decltype(_impl_.urlnumber_){} + , decltype(_impl_.clearmedia_){} + , decltype(_impl_.ephemeralofftoon_){} + , decltype(_impl_.duration_){} + , decltype(_impl_.ephemeralduration_){} + , decltype(_impl_.ephemeralstarttimestamp_){} + , decltype(_impl_.bizprivacystatus_){} + , decltype(_impl_.ephemeraloutofsync_){} + , decltype(_impl_.statusalreadyviewed_){} + , decltype(_impl_.revokemessagetimestamp_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + _impl_.participant_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.participant_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_participant()) { + _this->_impl_.participant_.Set(from._internal_participant(), + _this->GetArenaForAllocation()); + } + _impl_.pushname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.pushname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_pushname()) { + _this->_impl_.pushname_.Set(from._internal_pushname(), + _this->GetArenaForAllocation()); + } + _impl_.mediaciphertextsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediaciphertextsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_mediaciphertextsha256()) { + _this->_impl_.mediaciphertextsha256_.Set(from._internal_mediaciphertextsha256(), + _this->GetArenaForAllocation()); + } + _impl_.verifiedbizname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.verifiedbizname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_verifiedbizname()) { + _this->_impl_.verifiedbizname_.Set(from._internal_verifiedbizname(), + _this->GetArenaForAllocation()); + } + _impl_.futureproofdata_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.futureproofdata_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_futureproofdata()) { + _this->_impl_.futureproofdata_.Set(from._internal_futureproofdata(), + _this->GetArenaForAllocation()); + } + _impl_.agentid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.agentid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_agentid()) { + _this->_impl_.agentid_.Set(from._internal_agentid(), + _this->GetArenaForAllocation()); + } + _impl_.messagesecret_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.messagesecret_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_messagesecret()) { + _this->_impl_.messagesecret_.Set(from._internal_messagesecret(), + _this->GetArenaForAllocation()); + } + _impl_.originalselfauthoruserjidstring_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.originalselfauthoruserjidstring_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_originalselfauthoruserjidstring()) { + _this->_impl_.originalselfauthoruserjidstring_.Set(from._internal_originalselfauthoruserjidstring(), + _this->GetArenaForAllocation()); + } + if (from._internal_has_key()) { + _this->_impl_.key_ = new ::proto::MessageKey(*from._impl_.key_); + } + if (from._internal_has_message()) { + _this->_impl_.message_ = new ::proto::Message(*from._impl_.message_); + } + if (from._internal_has_paymentinfo()) { + _this->_impl_.paymentinfo_ = new ::proto::PaymentInfo(*from._impl_.paymentinfo_); + } + if (from._internal_has_finallivelocation()) { + _this->_impl_.finallivelocation_ = new ::proto::Message_LiveLocationMessage(*from._impl_.finallivelocation_); + } + if (from._internal_has_quotedpaymentinfo()) { + _this->_impl_.quotedpaymentinfo_ = new ::proto::PaymentInfo(*from._impl_.quotedpaymentinfo_); + } + if (from._internal_has_mediadata()) { + _this->_impl_.mediadata_ = new ::proto::MediaData(*from._impl_.mediadata_); + } + if (from._internal_has_photochange()) { + _this->_impl_.photochange_ = new ::proto::PhotoChange(*from._impl_.photochange_); + } + if (from._internal_has_quotedstickerdata()) { + _this->_impl_.quotedstickerdata_ = new ::proto::MediaData(*from._impl_.quotedstickerdata_); + } + if (from._internal_has_statuspsa()) { + _this->_impl_.statuspsa_ = new ::proto::StatusPSA(*from._impl_.statuspsa_); + } + if (from._internal_has_polladditionalmetadata()) { + _this->_impl_.polladditionalmetadata_ = new ::proto::PollAdditionalMetadata(*from._impl_.polladditionalmetadata_); + } + if (from._internal_has_keepinchat()) { + _this->_impl_.keepinchat_ = new ::proto::KeepInChat(*from._impl_.keepinchat_); + } + ::memcpy(&_impl_.messagetimestamp_, &from._impl_.messagetimestamp_, + static_cast(reinterpret_cast(&_impl_.revokemessagetimestamp_) - + reinterpret_cast(&_impl_.messagetimestamp_)) + sizeof(_impl_.revokemessagetimestamp_)); + // @@protoc_insertion_point(copy_constructor:proto.WebMessageInfo) +} + +inline void WebMessageInfo::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.messagestubparameters_){arena} + , decltype(_impl_.labels_){arena} + , decltype(_impl_.userreceipt_){arena} + , decltype(_impl_.reactions_){arena} + , decltype(_impl_.pollupdates_){arena} + , decltype(_impl_.participant_){} + , decltype(_impl_.pushname_){} + , decltype(_impl_.mediaciphertextsha256_){} + , decltype(_impl_.verifiedbizname_){} + , decltype(_impl_.futureproofdata_){} + , decltype(_impl_.agentid_){} + , decltype(_impl_.messagesecret_){} + , decltype(_impl_.originalselfauthoruserjidstring_){} + , decltype(_impl_.key_){nullptr} + , decltype(_impl_.message_){nullptr} + , decltype(_impl_.paymentinfo_){nullptr} + , decltype(_impl_.finallivelocation_){nullptr} + , decltype(_impl_.quotedpaymentinfo_){nullptr} + , decltype(_impl_.mediadata_){nullptr} + , decltype(_impl_.photochange_){nullptr} + , decltype(_impl_.quotedstickerdata_){nullptr} + , decltype(_impl_.statuspsa_){nullptr} + , decltype(_impl_.polladditionalmetadata_){nullptr} + , decltype(_impl_.keepinchat_){nullptr} + , decltype(_impl_.messagetimestamp_){uint64_t{0u}} + , decltype(_impl_.messagec2stimestamp_){uint64_t{0u}} + , decltype(_impl_.status_){0} + , decltype(_impl_.ignore_){false} + , decltype(_impl_.starred_){false} + , decltype(_impl_.broadcast_){false} + , decltype(_impl_.multicast_){false} + , decltype(_impl_.messagestubtype_){0} + , decltype(_impl_.urltext_){false} + , decltype(_impl_.urlnumber_){false} + , decltype(_impl_.clearmedia_){false} + , decltype(_impl_.ephemeralofftoon_){false} + , decltype(_impl_.duration_){0u} + , decltype(_impl_.ephemeralduration_){0u} + , decltype(_impl_.ephemeralstarttimestamp_){uint64_t{0u}} + , decltype(_impl_.bizprivacystatus_){0} + , decltype(_impl_.ephemeraloutofsync_){false} + , decltype(_impl_.statusalreadyviewed_){false} + , decltype(_impl_.revokemessagetimestamp_){uint64_t{0u}} + }; + _impl_.participant_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.participant_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.pushname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.pushname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediaciphertextsha256_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.mediaciphertextsha256_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.verifiedbizname_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.verifiedbizname_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.futureproofdata_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.futureproofdata_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.agentid_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.agentid_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.messagesecret_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.messagesecret_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.originalselfauthoruserjidstring_.InitDefault(); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + _impl_.originalselfauthoruserjidstring_.Set("", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +WebMessageInfo::~WebMessageInfo() { + // @@protoc_insertion_point(destructor:proto.WebMessageInfo) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void WebMessageInfo::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.messagestubparameters_.~RepeatedPtrField(); + _impl_.labels_.~RepeatedPtrField(); + _impl_.userreceipt_.~RepeatedPtrField(); + _impl_.reactions_.~RepeatedPtrField(); + _impl_.pollupdates_.~RepeatedPtrField(); + _impl_.participant_.Destroy(); + _impl_.pushname_.Destroy(); + _impl_.mediaciphertextsha256_.Destroy(); + _impl_.verifiedbizname_.Destroy(); + _impl_.futureproofdata_.Destroy(); + _impl_.agentid_.Destroy(); + _impl_.messagesecret_.Destroy(); + _impl_.originalselfauthoruserjidstring_.Destroy(); + if (this != internal_default_instance()) delete _impl_.key_; + if (this != internal_default_instance()) delete _impl_.message_; + if (this != internal_default_instance()) delete _impl_.paymentinfo_; + if (this != internal_default_instance()) delete _impl_.finallivelocation_; + if (this != internal_default_instance()) delete _impl_.quotedpaymentinfo_; + if (this != internal_default_instance()) delete _impl_.mediadata_; + if (this != internal_default_instance()) delete _impl_.photochange_; + if (this != internal_default_instance()) delete _impl_.quotedstickerdata_; + if (this != internal_default_instance()) delete _impl_.statuspsa_; + if (this != internal_default_instance()) delete _impl_.polladditionalmetadata_; + if (this != internal_default_instance()) delete _impl_.keepinchat_; +} + +void WebMessageInfo::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void WebMessageInfo::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.WebMessageInfo) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.messagestubparameters_.Clear(); + _impl_.labels_.Clear(); + _impl_.userreceipt_.Clear(); + _impl_.reactions_.Clear(); + _impl_.pollupdates_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _impl_.participant_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + _impl_.pushname_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + _impl_.mediaciphertextsha256_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + _impl_.verifiedbizname_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + _impl_.futureproofdata_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000020u) { + _impl_.agentid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000040u) { + _impl_.messagesecret_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000080u) { + _impl_.originalselfauthoruserjidstring_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x0000ff00u) { + if (cached_has_bits & 0x00000100u) { + GOOGLE_DCHECK(_impl_.key_ != nullptr); + _impl_.key_->Clear(); + } + if (cached_has_bits & 0x00000200u) { + GOOGLE_DCHECK(_impl_.message_ != nullptr); + _impl_.message_->Clear(); + } + if (cached_has_bits & 0x00000400u) { + GOOGLE_DCHECK(_impl_.paymentinfo_ != nullptr); + _impl_.paymentinfo_->Clear(); + } + if (cached_has_bits & 0x00000800u) { + GOOGLE_DCHECK(_impl_.finallivelocation_ != nullptr); + _impl_.finallivelocation_->Clear(); + } + if (cached_has_bits & 0x00001000u) { + GOOGLE_DCHECK(_impl_.quotedpaymentinfo_ != nullptr); + _impl_.quotedpaymentinfo_->Clear(); + } + if (cached_has_bits & 0x00002000u) { + GOOGLE_DCHECK(_impl_.mediadata_ != nullptr); + _impl_.mediadata_->Clear(); + } + if (cached_has_bits & 0x00004000u) { + GOOGLE_DCHECK(_impl_.photochange_ != nullptr); + _impl_.photochange_->Clear(); + } + if (cached_has_bits & 0x00008000u) { + GOOGLE_DCHECK(_impl_.quotedstickerdata_ != nullptr); + _impl_.quotedstickerdata_->Clear(); + } + } + if (cached_has_bits & 0x00070000u) { + if (cached_has_bits & 0x00010000u) { + GOOGLE_DCHECK(_impl_.statuspsa_ != nullptr); + _impl_.statuspsa_->Clear(); + } + if (cached_has_bits & 0x00020000u) { + GOOGLE_DCHECK(_impl_.polladditionalmetadata_ != nullptr); + _impl_.polladditionalmetadata_->Clear(); + } + if (cached_has_bits & 0x00040000u) { + GOOGLE_DCHECK(_impl_.keepinchat_ != nullptr); + _impl_.keepinchat_->Clear(); + } + } + if (cached_has_bits & 0x00f80000u) { + ::memset(&_impl_.messagetimestamp_, 0, static_cast( + reinterpret_cast(&_impl_.starred_) - + reinterpret_cast(&_impl_.messagetimestamp_)) + sizeof(_impl_.starred_)); + } + if (cached_has_bits & 0xff000000u) { + ::memset(&_impl_.broadcast_, 0, static_cast( + reinterpret_cast(&_impl_.duration_) - + reinterpret_cast(&_impl_.broadcast_)) + sizeof(_impl_.duration_)); + } + cached_has_bits = _impl_._has_bits_[1]; + if (cached_has_bits & 0x0000003fu) { + ::memset(&_impl_.ephemeralduration_, 0, static_cast( + reinterpret_cast(&_impl_.revokemessagetimestamp_) - + reinterpret_cast(&_impl_.ephemeralduration_)) + sizeof(_impl_.revokemessagetimestamp_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* WebMessageInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // required .proto.MessageKey key = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message message = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_message(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint64 messageTimestamp = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_messagetimestamp(&_impl_._has_bits_); + _impl_.messagetimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.WebMessageInfo.Status status = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebMessageInfo_Status_IsValid(val))) { + _internal_set_status(static_cast<::proto::WebMessageInfo_Status>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional string participant = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + auto str = _internal_mutable_participant(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.WebMessageInfo.participant"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional uint64 messageC2STimestamp = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + _Internal::set_has_messagec2stimestamp(&_impl_._has_bits_); + _impl_.messagec2stimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool ignore = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 128)) { + _Internal::set_has_ignore(&_impl_._has_bits_); + _impl_.ignore_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool starred = 17; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 136)) { + _Internal::set_has_starred(&_impl_._has_bits_); + _impl_.starred_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool broadcast = 18; + case 18: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 144)) { + _Internal::set_has_broadcast(&_impl_._has_bits_); + _impl_.broadcast_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string pushName = 19; + case 19: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) { + auto str = _internal_mutable_pushname(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.WebMessageInfo.pushName"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bytes mediaCiphertextSha256 = 20; + case 20: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 162)) { + auto str = _internal_mutable_mediaciphertextsha256(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool multicast = 21; + case 21: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 168)) { + _Internal::set_has_multicast(&_impl_._has_bits_); + _impl_.multicast_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool urlText = 22; + case 22: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 176)) { + _Internal::set_has_urltext(&_impl_._has_bits_); + _impl_.urltext_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool urlNumber = 23; + case 23: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 184)) { + _Internal::set_has_urlnumber(&_impl_._has_bits_); + _impl_.urlnumber_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.WebMessageInfo.StubType messageStubType = 24; + case 24: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 192)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebMessageInfo_StubType_IsValid(val))) { + _internal_set_messagestubtype(static_cast<::proto::WebMessageInfo_StubType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(24, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional bool clearMedia = 25; + case 25: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 200)) { + _Internal::set_has_clearmedia(&_impl_._has_bits_); + _impl_.clearmedia_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated string messageStubParameters = 26; + case 26: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 210)) { + ptr -= 2; + do { + ptr += 2; + auto str = _internal_add_messagestubparameters(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.WebMessageInfo.messageStubParameters"); + #endif // !NDEBUG + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<210>(ptr)); + } else + goto handle_unusual; + continue; + // optional uint32 duration = 27; + case 27: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 216)) { + _Internal::set_has_duration(&_impl_._has_bits_); + _impl_.duration_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated string labels = 28; + case 28: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 226)) { + ptr -= 2; + do { + ptr += 2; + auto str = _internal_add_labels(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.WebMessageInfo.labels"); + #endif // !NDEBUG + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<226>(ptr)); + } else + goto handle_unusual; + continue; + // optional .proto.PaymentInfo paymentInfo = 29; + case 29: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 234)) { + ptr = ctx->ParseMessage(_internal_mutable_paymentinfo(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.Message.LiveLocationMessage finalLiveLocation = 30; + case 30: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 242)) { + ptr = ctx->ParseMessage(_internal_mutable_finallivelocation(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.PaymentInfo quotedPaymentInfo = 31; + case 31: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 250)) { + ptr = ctx->ParseMessage(_internal_mutable_quotedpaymentinfo(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint64 ephemeralStartTimestamp = 32; + case 32: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 0)) { + _Internal::set_has_ephemeralstarttimestamp(&_impl_._has_bits_); + _impl_.ephemeralstarttimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 ephemeralDuration = 33; + case 33: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_ephemeralduration(&_impl_._has_bits_); + _impl_.ephemeralduration_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool ephemeralOffToOn = 34; + case 34: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_ephemeralofftoon(&_impl_._has_bits_); + _impl_.ephemeralofftoon_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool ephemeralOutOfSync = 35; + case 35: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_ephemeraloutofsync(&_impl_._has_bits_); + _impl_.ephemeraloutofsync_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.WebMessageInfo.BizPrivacyStatus bizPrivacyStatus = 36; + case 36: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::proto::WebMessageInfo_BizPrivacyStatus_IsValid(val))) { + _internal_set_bizprivacystatus(static_cast<::proto::WebMessageInfo_BizPrivacyStatus>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(36, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional string verifiedBizName = 37; + case 37: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + auto str = _internal_mutable_verifiedbizname(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.WebMessageInfo.verifiedBizName"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional .proto.MediaData mediaData = 38; + case 38: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_mediadata(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.PhotoChange photoChange = 39; + case 39: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_photochange(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .proto.UserReceipt userReceipt = 40; + case 40: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + ptr -= 2; + do { + ptr += 2; + ptr = ctx->ParseMessage(_internal_add_userreceipt(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<322>(ptr)); + } else + goto handle_unusual; + continue; + // repeated .proto.Reaction reactions = 41; + case 41: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + ptr -= 2; + do { + ptr += 2; + ptr = ctx->ParseMessage(_internal_add_reactions(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<330>(ptr)); + } else + goto handle_unusual; + continue; + // optional .proto.MediaData quotedStickerData = 42; + case 42: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_quotedstickerdata(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes futureproofData = 43; + case 43: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { + auto str = _internal_mutable_futureproofdata(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.StatusPSA statusPsa = 44; + case 44: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { + ptr = ctx->ParseMessage(_internal_mutable_statuspsa(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .proto.PollUpdate pollUpdates = 45; + case 45: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { + ptr -= 2; + do { + ptr += 2; + ptr = ctx->ParseMessage(_internal_add_pollupdates(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<362>(ptr)); + } else + goto handle_unusual; + continue; + // optional .proto.PollAdditionalMetadata pollAdditionalMetadata = 46; + case 46: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) { + ptr = ctx->ParseMessage(_internal_mutable_polladditionalmetadata(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string agentId = 47; + case 47: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { + auto str = _internal_mutable_agentid(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.WebMessageInfo.agentId"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional bool statusAlreadyViewed = 48; + case 48: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 128)) { + _Internal::set_has_statusalreadyviewed(&_impl_._has_bits_); + _impl_.statusalreadyviewed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes messageSecret = 49; + case 49: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { + auto str = _internal_mutable_messagesecret(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .proto.KeepInChat keepInChat = 50; + case 50: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { + ptr = ctx->ParseMessage(_internal_mutable_keepinchat(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string originalSelfAuthorUserJidString = 51; + case 51: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) { + auto str = _internal_mutable_originalselfauthoruserjidstring(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + #ifndef NDEBUG + ::_pbi::VerifyUTF8(str, "proto.WebMessageInfo.originalSelfAuthorUserJidString"); + #endif // !NDEBUG + } else + goto handle_unusual; + continue; + // optional uint64 revokeMessageTimestamp = 52; + case 52: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 160)) { + _Internal::set_has_revokemessagetimestamp(&_impl_._has_bits_); + _impl_.revokemessagetimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* WebMessageInfo::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.WebMessageInfo) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // required .proto.MessageKey key = 1; + if (cached_has_bits & 0x00000100u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::key(this), + _Internal::key(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message message = 2; + if (cached_has_bits & 0x00000200u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::message(this), + _Internal::message(this).GetCachedSize(), target, stream); + } + + // optional uint64 messageTimestamp = 3; + if (cached_has_bits & 0x00080000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_messagetimestamp(), target); + } + + // optional .proto.WebMessageInfo.Status status = 4; + if (cached_has_bits & 0x00200000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 4, this->_internal_status(), target); + } + + // optional string participant = 5; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_participant().data(), static_cast(this->_internal_participant().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.WebMessageInfo.participant"); + target = stream->WriteStringMaybeAliased( + 5, this->_internal_participant(), target); + } + + // optional uint64 messageC2STimestamp = 6; + if (cached_has_bits & 0x00100000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(6, this->_internal_messagec2stimestamp(), target); + } + + // optional bool ignore = 16; + if (cached_has_bits & 0x00400000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(16, this->_internal_ignore(), target); + } + + // optional bool starred = 17; + if (cached_has_bits & 0x00800000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(17, this->_internal_starred(), target); + } + + // optional bool broadcast = 18; + if (cached_has_bits & 0x01000000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(18, this->_internal_broadcast(), target); + } + + // optional string pushName = 19; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_pushname().data(), static_cast(this->_internal_pushname().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.WebMessageInfo.pushName"); + target = stream->WriteStringMaybeAliased( + 19, this->_internal_pushname(), target); + } + + // optional bytes mediaCiphertextSha256 = 20; + if (cached_has_bits & 0x00000004u) { + target = stream->WriteBytesMaybeAliased( + 20, this->_internal_mediaciphertextsha256(), target); + } + + // optional bool multicast = 21; + if (cached_has_bits & 0x02000000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(21, this->_internal_multicast(), target); + } + + // optional bool urlText = 22; + if (cached_has_bits & 0x08000000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(22, this->_internal_urltext(), target); + } + + // optional bool urlNumber = 23; + if (cached_has_bits & 0x10000000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(23, this->_internal_urlnumber(), target); + } + + // optional .proto.WebMessageInfo.StubType messageStubType = 24; + if (cached_has_bits & 0x04000000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 24, this->_internal_messagestubtype(), target); + } + + // optional bool clearMedia = 25; + if (cached_has_bits & 0x20000000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(25, this->_internal_clearmedia(), target); + } + + // repeated string messageStubParameters = 26; + for (int i = 0, n = this->_internal_messagestubparameters_size(); i < n; i++) { + const auto& s = this->_internal_messagestubparameters(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.WebMessageInfo.messageStubParameters"); + target = stream->WriteString(26, s, target); + } + + // optional uint32 duration = 27; + if (cached_has_bits & 0x80000000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(27, this->_internal_duration(), target); + } + + // repeated string labels = 28; + for (int i = 0, n = this->_internal_labels_size(); i < n; i++) { + const auto& s = this->_internal_labels(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.WebMessageInfo.labels"); + target = stream->WriteString(28, s, target); + } + + // optional .proto.PaymentInfo paymentInfo = 29; + if (cached_has_bits & 0x00000400u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(29, _Internal::paymentinfo(this), + _Internal::paymentinfo(this).GetCachedSize(), target, stream); + } + + // optional .proto.Message.LiveLocationMessage finalLiveLocation = 30; + if (cached_has_bits & 0x00000800u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(30, _Internal::finallivelocation(this), + _Internal::finallivelocation(this).GetCachedSize(), target, stream); + } + + // optional .proto.PaymentInfo quotedPaymentInfo = 31; + if (cached_has_bits & 0x00001000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(31, _Internal::quotedpaymentinfo(this), + _Internal::quotedpaymentinfo(this).GetCachedSize(), target, stream); + } + + cached_has_bits = _impl_._has_bits_[1]; + // optional uint64 ephemeralStartTimestamp = 32; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(32, this->_internal_ephemeralstarttimestamp(), target); + } + + // optional uint32 ephemeralDuration = 33; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(33, this->_internal_ephemeralduration(), target); + } + + cached_has_bits = _impl_._has_bits_[0]; + // optional bool ephemeralOffToOn = 34; + if (cached_has_bits & 0x40000000u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(34, this->_internal_ephemeralofftoon(), target); + } + + cached_has_bits = _impl_._has_bits_[1]; + // optional bool ephemeralOutOfSync = 35; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(35, this->_internal_ephemeraloutofsync(), target); + } + + // optional .proto.WebMessageInfo.BizPrivacyStatus bizPrivacyStatus = 36; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 36, this->_internal_bizprivacystatus(), target); + } + + cached_has_bits = _impl_._has_bits_[0]; + // optional string verifiedBizName = 37; + if (cached_has_bits & 0x00000008u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_verifiedbizname().data(), static_cast(this->_internal_verifiedbizname().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.WebMessageInfo.verifiedBizName"); + target = stream->WriteStringMaybeAliased( + 37, this->_internal_verifiedbizname(), target); + } + + // optional .proto.MediaData mediaData = 38; + if (cached_has_bits & 0x00002000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(38, _Internal::mediadata(this), + _Internal::mediadata(this).GetCachedSize(), target, stream); + } + + // optional .proto.PhotoChange photoChange = 39; + if (cached_has_bits & 0x00004000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(39, _Internal::photochange(this), + _Internal::photochange(this).GetCachedSize(), target, stream); + } + + // repeated .proto.UserReceipt userReceipt = 40; + for (unsigned i = 0, + n = static_cast(this->_internal_userreceipt_size()); i < n; i++) { + const auto& repfield = this->_internal_userreceipt(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(40, repfield, repfield.GetCachedSize(), target, stream); + } + + // repeated .proto.Reaction reactions = 41; + for (unsigned i = 0, + n = static_cast(this->_internal_reactions_size()); i < n; i++) { + const auto& repfield = this->_internal_reactions(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(41, repfield, repfield.GetCachedSize(), target, stream); + } + + // optional .proto.MediaData quotedStickerData = 42; + if (cached_has_bits & 0x00008000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(42, _Internal::quotedstickerdata(this), + _Internal::quotedstickerdata(this).GetCachedSize(), target, stream); + } + + // optional bytes futureproofData = 43; + if (cached_has_bits & 0x00000010u) { + target = stream->WriteBytesMaybeAliased( + 43, this->_internal_futureproofdata(), target); + } + + // optional .proto.StatusPSA statusPsa = 44; + if (cached_has_bits & 0x00010000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(44, _Internal::statuspsa(this), + _Internal::statuspsa(this).GetCachedSize(), target, stream); + } + + // repeated .proto.PollUpdate pollUpdates = 45; + for (unsigned i = 0, + n = static_cast(this->_internal_pollupdates_size()); i < n; i++) { + const auto& repfield = this->_internal_pollupdates(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(45, repfield, repfield.GetCachedSize(), target, stream); + } + + // optional .proto.PollAdditionalMetadata pollAdditionalMetadata = 46; + if (cached_has_bits & 0x00020000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(46, _Internal::polladditionalmetadata(this), + _Internal::polladditionalmetadata(this).GetCachedSize(), target, stream); + } + + // optional string agentId = 47; + if (cached_has_bits & 0x00000020u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_agentid().data(), static_cast(this->_internal_agentid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.WebMessageInfo.agentId"); + target = stream->WriteStringMaybeAliased( + 47, this->_internal_agentid(), target); + } + + cached_has_bits = _impl_._has_bits_[1]; + // optional bool statusAlreadyViewed = 48; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray(48, this->_internal_statusalreadyviewed(), target); + } + + cached_has_bits = _impl_._has_bits_[0]; + // optional bytes messageSecret = 49; + if (cached_has_bits & 0x00000040u) { + target = stream->WriteBytesMaybeAliased( + 49, this->_internal_messagesecret(), target); + } + + // optional .proto.KeepInChat keepInChat = 50; + if (cached_has_bits & 0x00040000u) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(50, _Internal::keepinchat(this), + _Internal::keepinchat(this).GetCachedSize(), target, stream); + } + + // optional string originalSelfAuthorUserJidString = 51; + if (cached_has_bits & 0x00000080u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_originalselfauthoruserjidstring().data(), static_cast(this->_internal_originalselfauthoruserjidstring().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "proto.WebMessageInfo.originalSelfAuthorUserJidString"); + target = stream->WriteStringMaybeAliased( + 51, this->_internal_originalselfauthoruserjidstring(), target); + } + + cached_has_bits = _impl_._has_bits_[1]; + // optional uint64 revokeMessageTimestamp = 52; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(52, this->_internal_revokemessagetimestamp(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.WebMessageInfo) + return target; +} + +size_t WebMessageInfo::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.WebMessageInfo) + size_t total_size = 0; + + // required .proto.MessageKey key = 1; + if (_internal_has_key()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.key_); + } + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string messageStubParameters = 26; + total_size += 2 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.messagestubparameters_.size()); + for (int i = 0, n = _impl_.messagestubparameters_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + _impl_.messagestubparameters_.Get(i)); + } + + // repeated string labels = 28; + total_size += 2 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.labels_.size()); + for (int i = 0, n = _impl_.labels_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + _impl_.labels_.Get(i)); + } + + // repeated .proto.UserReceipt userReceipt = 40; + total_size += 2UL * this->_internal_userreceipt_size(); + for (const auto& msg : this->_impl_.userreceipt_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .proto.Reaction reactions = 41; + total_size += 2UL * this->_internal_reactions_size(); + for (const auto& msg : this->_impl_.reactions_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .proto.PollUpdate pollUpdates = 45; + total_size += 2UL * this->_internal_pollupdates_size(); + for (const auto& msg : this->_impl_.pollupdates_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string participant = 5; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_participant()); + } + + // optional string pushName = 19; + if (cached_has_bits & 0x00000002u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_pushname()); + } + + // optional bytes mediaCiphertextSha256 = 20; + if (cached_has_bits & 0x00000004u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_mediaciphertextsha256()); + } + + // optional string verifiedBizName = 37; + if (cached_has_bits & 0x00000008u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_verifiedbizname()); + } + + // optional bytes futureproofData = 43; + if (cached_has_bits & 0x00000010u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_futureproofdata()); + } + + // optional string agentId = 47; + if (cached_has_bits & 0x00000020u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_agentid()); + } + + // optional bytes messageSecret = 49; + if (cached_has_bits & 0x00000040u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_messagesecret()); + } + + // optional string originalSelfAuthorUserJidString = 51; + if (cached_has_bits & 0x00000080u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_originalselfauthoruserjidstring()); + } + + } + if (cached_has_bits & 0x0000fe00u) { + // optional .proto.Message message = 2; + if (cached_has_bits & 0x00000200u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.message_); + } + + // optional .proto.PaymentInfo paymentInfo = 29; + if (cached_has_bits & 0x00000400u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.paymentinfo_); + } + + // optional .proto.Message.LiveLocationMessage finalLiveLocation = 30; + if (cached_has_bits & 0x00000800u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.finallivelocation_); + } + + // optional .proto.PaymentInfo quotedPaymentInfo = 31; + if (cached_has_bits & 0x00001000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.quotedpaymentinfo_); + } + + // optional .proto.MediaData mediaData = 38; + if (cached_has_bits & 0x00002000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.mediadata_); + } + + // optional .proto.PhotoChange photoChange = 39; + if (cached_has_bits & 0x00004000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.photochange_); + } + + // optional .proto.MediaData quotedStickerData = 42; + if (cached_has_bits & 0x00008000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.quotedstickerdata_); + } + + } + if (cached_has_bits & 0x00ff0000u) { + // optional .proto.StatusPSA statusPsa = 44; + if (cached_has_bits & 0x00010000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.statuspsa_); + } + + // optional .proto.PollAdditionalMetadata pollAdditionalMetadata = 46; + if (cached_has_bits & 0x00020000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.polladditionalmetadata_); + } + + // optional .proto.KeepInChat keepInChat = 50; + if (cached_has_bits & 0x00040000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.keepinchat_); + } + + // optional uint64 messageTimestamp = 3; + if (cached_has_bits & 0x00080000u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_messagetimestamp()); + } + + // optional uint64 messageC2STimestamp = 6; + if (cached_has_bits & 0x00100000u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_messagec2stimestamp()); + } + + // optional .proto.WebMessageInfo.Status status = 4; + if (cached_has_bits & 0x00200000u) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_status()); + } + + // optional bool ignore = 16; + if (cached_has_bits & 0x00400000u) { + total_size += 2 + 1; + } + + // optional bool starred = 17; + if (cached_has_bits & 0x00800000u) { + total_size += 2 + 1; + } + + } + if (cached_has_bits & 0xff000000u) { + // optional bool broadcast = 18; + if (cached_has_bits & 0x01000000u) { + total_size += 2 + 1; + } + + // optional bool multicast = 21; + if (cached_has_bits & 0x02000000u) { + total_size += 2 + 1; + } + + // optional .proto.WebMessageInfo.StubType messageStubType = 24; + if (cached_has_bits & 0x04000000u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_messagestubtype()); + } + + // optional bool urlText = 22; + if (cached_has_bits & 0x08000000u) { + total_size += 2 + 1; + } + + // optional bool urlNumber = 23; + if (cached_has_bits & 0x10000000u) { + total_size += 2 + 1; + } + + // optional bool clearMedia = 25; + if (cached_has_bits & 0x20000000u) { + total_size += 2 + 1; + } + + // optional bool ephemeralOffToOn = 34; + if (cached_has_bits & 0x40000000u) { + total_size += 2 + 1; + } + + // optional uint32 duration = 27; + if (cached_has_bits & 0x80000000u) { + total_size += 2 + + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_duration()); + } + + } + cached_has_bits = _impl_._has_bits_[1]; + if (cached_has_bits & 0x0000003fu) { + // optional uint32 ephemeralDuration = 33; + if (cached_has_bits & 0x00000001u) { + total_size += 2 + + ::_pbi::WireFormatLite::UInt32Size( + this->_internal_ephemeralduration()); + } + + // optional uint64 ephemeralStartTimestamp = 32; + if (cached_has_bits & 0x00000002u) { + total_size += 2 + + ::_pbi::WireFormatLite::UInt64Size( + this->_internal_ephemeralstarttimestamp()); + } + + // optional .proto.WebMessageInfo.BizPrivacyStatus bizPrivacyStatus = 36; + if (cached_has_bits & 0x00000004u) { + total_size += 2 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_bizprivacystatus()); + } + + // optional bool ephemeralOutOfSync = 35; + if (cached_has_bits & 0x00000008u) { + total_size += 2 + 1; + } + + // optional bool statusAlreadyViewed = 48; + if (cached_has_bits & 0x00000010u) { + total_size += 2 + 1; + } + + // optional uint64 revokeMessageTimestamp = 52; + if (cached_has_bits & 0x00000020u) { + total_size += 2 + + ::_pbi::WireFormatLite::UInt64Size( + this->_internal_revokemessagetimestamp()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData WebMessageInfo::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + WebMessageInfo::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*WebMessageInfo::GetClassData() const { return &_class_data_; } + + +void WebMessageInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.WebMessageInfo) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.messagestubparameters_.MergeFrom(from._impl_.messagestubparameters_); + _this->_impl_.labels_.MergeFrom(from._impl_.labels_); + _this->_impl_.userreceipt_.MergeFrom(from._impl_.userreceipt_); + _this->_impl_.reactions_.MergeFrom(from._impl_.reactions_); + _this->_impl_.pollupdates_.MergeFrom(from._impl_.pollupdates_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _this->_internal_set_participant(from._internal_participant()); + } + if (cached_has_bits & 0x00000002u) { + _this->_internal_set_pushname(from._internal_pushname()); + } + if (cached_has_bits & 0x00000004u) { + _this->_internal_set_mediaciphertextsha256(from._internal_mediaciphertextsha256()); + } + if (cached_has_bits & 0x00000008u) { + _this->_internal_set_verifiedbizname(from._internal_verifiedbizname()); + } + if (cached_has_bits & 0x00000010u) { + _this->_internal_set_futureproofdata(from._internal_futureproofdata()); + } + if (cached_has_bits & 0x00000020u) { + _this->_internal_set_agentid(from._internal_agentid()); + } + if (cached_has_bits & 0x00000040u) { + _this->_internal_set_messagesecret(from._internal_messagesecret()); + } + if (cached_has_bits & 0x00000080u) { + _this->_internal_set_originalselfauthoruserjidstring(from._internal_originalselfauthoruserjidstring()); + } + } + if (cached_has_bits & 0x0000ff00u) { + if (cached_has_bits & 0x00000100u) { + _this->_internal_mutable_key()->::proto::MessageKey::MergeFrom( + from._internal_key()); + } + if (cached_has_bits & 0x00000200u) { + _this->_internal_mutable_message()->::proto::Message::MergeFrom( + from._internal_message()); + } + if (cached_has_bits & 0x00000400u) { + _this->_internal_mutable_paymentinfo()->::proto::PaymentInfo::MergeFrom( + from._internal_paymentinfo()); + } + if (cached_has_bits & 0x00000800u) { + _this->_internal_mutable_finallivelocation()->::proto::Message_LiveLocationMessage::MergeFrom( + from._internal_finallivelocation()); + } + if (cached_has_bits & 0x00001000u) { + _this->_internal_mutable_quotedpaymentinfo()->::proto::PaymentInfo::MergeFrom( + from._internal_quotedpaymentinfo()); + } + if (cached_has_bits & 0x00002000u) { + _this->_internal_mutable_mediadata()->::proto::MediaData::MergeFrom( + from._internal_mediadata()); + } + if (cached_has_bits & 0x00004000u) { + _this->_internal_mutable_photochange()->::proto::PhotoChange::MergeFrom( + from._internal_photochange()); + } + if (cached_has_bits & 0x00008000u) { + _this->_internal_mutable_quotedstickerdata()->::proto::MediaData::MergeFrom( + from._internal_quotedstickerdata()); + } + } + if (cached_has_bits & 0x00ff0000u) { + if (cached_has_bits & 0x00010000u) { + _this->_internal_mutable_statuspsa()->::proto::StatusPSA::MergeFrom( + from._internal_statuspsa()); + } + if (cached_has_bits & 0x00020000u) { + _this->_internal_mutable_polladditionalmetadata()->::proto::PollAdditionalMetadata::MergeFrom( + from._internal_polladditionalmetadata()); + } + if (cached_has_bits & 0x00040000u) { + _this->_internal_mutable_keepinchat()->::proto::KeepInChat::MergeFrom( + from._internal_keepinchat()); + } + if (cached_has_bits & 0x00080000u) { + _this->_impl_.messagetimestamp_ = from._impl_.messagetimestamp_; + } + if (cached_has_bits & 0x00100000u) { + _this->_impl_.messagec2stimestamp_ = from._impl_.messagec2stimestamp_; + } + if (cached_has_bits & 0x00200000u) { + _this->_impl_.status_ = from._impl_.status_; + } + if (cached_has_bits & 0x00400000u) { + _this->_impl_.ignore_ = from._impl_.ignore_; + } + if (cached_has_bits & 0x00800000u) { + _this->_impl_.starred_ = from._impl_.starred_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0xff000000u) { + if (cached_has_bits & 0x01000000u) { + _this->_impl_.broadcast_ = from._impl_.broadcast_; + } + if (cached_has_bits & 0x02000000u) { + _this->_impl_.multicast_ = from._impl_.multicast_; + } + if (cached_has_bits & 0x04000000u) { + _this->_impl_.messagestubtype_ = from._impl_.messagestubtype_; + } + if (cached_has_bits & 0x08000000u) { + _this->_impl_.urltext_ = from._impl_.urltext_; + } + if (cached_has_bits & 0x10000000u) { + _this->_impl_.urlnumber_ = from._impl_.urlnumber_; + } + if (cached_has_bits & 0x20000000u) { + _this->_impl_.clearmedia_ = from._impl_.clearmedia_; + } + if (cached_has_bits & 0x40000000u) { + _this->_impl_.ephemeralofftoon_ = from._impl_.ephemeralofftoon_; + } + if (cached_has_bits & 0x80000000u) { + _this->_impl_.duration_ = from._impl_.duration_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + cached_has_bits = from._impl_._has_bits_[1]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + _this->_impl_.ephemeralduration_ = from._impl_.ephemeralduration_; + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.ephemeralstarttimestamp_ = from._impl_.ephemeralstarttimestamp_; + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.bizprivacystatus_ = from._impl_.bizprivacystatus_; + } + if (cached_has_bits & 0x00000008u) { + _this->_impl_.ephemeraloutofsync_ = from._impl_.ephemeraloutofsync_; + } + if (cached_has_bits & 0x00000010u) { + _this->_impl_.statusalreadyviewed_ = from._impl_.statusalreadyviewed_; + } + if (cached_has_bits & 0x00000020u) { + _this->_impl_.revokemessagetimestamp_ = from._impl_.revokemessagetimestamp_; + } + _this->_impl_._has_bits_[1] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void WebMessageInfo::CopyFrom(const WebMessageInfo& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.WebMessageInfo) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool WebMessageInfo::IsInitialized() const { + if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false; + if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.userreceipt_)) + return false; + if (_internal_has_statuspsa()) { + if (!_impl_.statuspsa_->IsInitialized()) return false; + } + return true; +} + +void WebMessageInfo::InternalSwap(WebMessageInfo* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + swap(_impl_._has_bits_[1], other->_impl_._has_bits_[1]); + _impl_.messagestubparameters_.InternalSwap(&other->_impl_.messagestubparameters_); + _impl_.labels_.InternalSwap(&other->_impl_.labels_); + _impl_.userreceipt_.InternalSwap(&other->_impl_.userreceipt_); + _impl_.reactions_.InternalSwap(&other->_impl_.reactions_); + _impl_.pollupdates_.InternalSwap(&other->_impl_.pollupdates_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.participant_, lhs_arena, + &other->_impl_.participant_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.pushname_, lhs_arena, + &other->_impl_.pushname_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.mediaciphertextsha256_, lhs_arena, + &other->_impl_.mediaciphertextsha256_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.verifiedbizname_, lhs_arena, + &other->_impl_.verifiedbizname_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.futureproofdata_, lhs_arena, + &other->_impl_.futureproofdata_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.agentid_, lhs_arena, + &other->_impl_.agentid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.messagesecret_, lhs_arena, + &other->_impl_.messagesecret_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &_impl_.originalselfauthoruserjidstring_, lhs_arena, + &other->_impl_.originalselfauthoruserjidstring_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(WebMessageInfo, _impl_.revokemessagetimestamp_) + + sizeof(WebMessageInfo::_impl_.revokemessagetimestamp_) + - PROTOBUF_FIELD_OFFSET(WebMessageInfo, _impl_.key_)>( + reinterpret_cast(&_impl_.key_), + reinterpret_cast(&other->_impl_.key_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata WebMessageInfo::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[222]); +} + +// =================================================================== + +class WebNotificationsInfo::_Internal { + public: + using HasBits = decltype(std::declval()._impl_._has_bits_); + static void set_has_timestamp(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_unreadchats(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_notifymessagecount(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +WebNotificationsInfo::WebNotificationsInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:proto.WebNotificationsInfo) +} +WebNotificationsInfo::WebNotificationsInfo(const WebNotificationsInfo& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + WebNotificationsInfo* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){from._impl_._has_bits_} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.notifymessages_){from._impl_.notifymessages_} + , decltype(_impl_.timestamp_){} + , decltype(_impl_.unreadchats_){} + , decltype(_impl_.notifymessagecount_){}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&_impl_.timestamp_, &from._impl_.timestamp_, + static_cast(reinterpret_cast(&_impl_.notifymessagecount_) - + reinterpret_cast(&_impl_.timestamp_)) + sizeof(_impl_.notifymessagecount_)); + // @@protoc_insertion_point(copy_constructor:proto.WebNotificationsInfo) +} + +inline void WebNotificationsInfo::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_._has_bits_){} + , /*decltype(_impl_._cached_size_)*/{} + , decltype(_impl_.notifymessages_){arena} + , decltype(_impl_.timestamp_){uint64_t{0u}} + , decltype(_impl_.unreadchats_){0u} + , decltype(_impl_.notifymessagecount_){0u} + }; +} + +WebNotificationsInfo::~WebNotificationsInfo() { + // @@protoc_insertion_point(destructor:proto.WebNotificationsInfo) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void WebNotificationsInfo::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + _impl_.notifymessages_.~RepeatedPtrField(); +} + +void WebNotificationsInfo::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void WebNotificationsInfo::Clear() { +// @@protoc_insertion_point(message_clear_start:proto.WebNotificationsInfo) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.notifymessages_.Clear(); + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + ::memset(&_impl_.timestamp_, 0, static_cast( + reinterpret_cast(&_impl_.notifymessagecount_) - + reinterpret_cast(&_impl_.timestamp_)) + sizeof(_impl_.notifymessagecount_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* WebNotificationsInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional uint64 timestamp = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_timestamp(&has_bits); + _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 unreadChats = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_unreadchats(&has_bits); + _impl_.unreadchats_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional uint32 notifyMessageCount = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_notifymessagecount(&has_bits); + _impl_.notifymessagecount_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .proto.WebMessageInfo notifyMessages = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_notifymessages(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _impl_._has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* WebNotificationsInfo::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:proto.WebNotificationsInfo) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + // optional uint64 timestamp = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_timestamp(), target); + } + + // optional uint32 unreadChats = 3; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_unreadchats(), target); + } + + // optional uint32 notifyMessageCount = 4; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_notifymessagecount(), target); + } + + // repeated .proto.WebMessageInfo notifyMessages = 5; + for (unsigned i = 0, + n = static_cast(this->_internal_notifymessages_size()); i < n; i++) { + const auto& repfield = this->_internal_notifymessages(i); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(5, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:proto.WebNotificationsInfo) + return target; +} + +size_t WebNotificationsInfo::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:proto.WebNotificationsInfo) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .proto.WebMessageInfo notifyMessages = 5; + total_size += 1UL * this->_internal_notifymessages_size(); + for (const auto& msg : this->_impl_.notifymessages_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional uint64 timestamp = 2; + if (cached_has_bits & 0x00000001u) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_timestamp()); + } + + // optional uint32 unreadChats = 3; + if (cached_has_bits & 0x00000002u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_unreadchats()); + } + + // optional uint32 notifyMessageCount = 4; + if (cached_has_bits & 0x00000004u) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_notifymessagecount()); + } + + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData WebNotificationsInfo::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + WebNotificationsInfo::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*WebNotificationsInfo::GetClassData() const { return &_class_data_; } + + +void WebNotificationsInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:proto.WebNotificationsInfo) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_impl_.notifymessages_.MergeFrom(from._impl_.notifymessages_); + cached_has_bits = from._impl_._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _this->_impl_.timestamp_ = from._impl_.timestamp_; + } + if (cached_has_bits & 0x00000002u) { + _this->_impl_.unreadchats_ = from._impl_.unreadchats_; + } + if (cached_has_bits & 0x00000004u) { + _this->_impl_.notifymessagecount_ = from._impl_.notifymessagecount_; + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void WebNotificationsInfo::CopyFrom(const WebNotificationsInfo& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:proto.WebNotificationsInfo) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool WebNotificationsInfo::IsInitialized() const { + if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.notifymessages_)) + return false; + return true; +} + +void WebNotificationsInfo::InternalSwap(WebNotificationsInfo* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + _impl_.notifymessages_.InternalSwap(&other->_impl_.notifymessages_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(WebNotificationsInfo, _impl_.notifymessagecount_) + + sizeof(WebNotificationsInfo::_impl_.notifymessagecount_) + - PROTOBUF_FIELD_OFFSET(WebNotificationsInfo, _impl_.timestamp_)>( + reinterpret_cast(&_impl_.timestamp_), + reinterpret_cast(&other->_impl_.timestamp_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata WebNotificationsInfo::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, + file_level_metadata_pmsg_2eproto[223]); +} + +// @@protoc_insertion_point(namespace_scope) +} // namespace proto +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::proto::ADVDeviceIdentity* +Arena::CreateMaybeMessage< ::proto::ADVDeviceIdentity >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::ADVDeviceIdentity >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::ADVKeyIndexList* +Arena::CreateMaybeMessage< ::proto::ADVKeyIndexList >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::ADVKeyIndexList >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::ADVSignedDeviceIdentity* +Arena::CreateMaybeMessage< ::proto::ADVSignedDeviceIdentity >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::ADVSignedDeviceIdentity >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::ADVSignedDeviceIdentityHMAC* +Arena::CreateMaybeMessage< ::proto::ADVSignedDeviceIdentityHMAC >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::ADVSignedDeviceIdentityHMAC >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::ADVSignedKeyIndexList* +Arena::CreateMaybeMessage< ::proto::ADVSignedKeyIndexList >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::ADVSignedKeyIndexList >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::ActionLink* +Arena::CreateMaybeMessage< ::proto::ActionLink >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::ActionLink >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::AutoDownloadSettings* +Arena::CreateMaybeMessage< ::proto::AutoDownloadSettings >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::AutoDownloadSettings >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::BizAccountLinkInfo* +Arena::CreateMaybeMessage< ::proto::BizAccountLinkInfo >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::BizAccountLinkInfo >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::BizAccountPayload* +Arena::CreateMaybeMessage< ::proto::BizAccountPayload >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::BizAccountPayload >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::BizIdentityInfo* +Arena::CreateMaybeMessage< ::proto::BizIdentityInfo >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::BizIdentityInfo >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::CertChain_NoiseCertificate_Details* +Arena::CreateMaybeMessage< ::proto::CertChain_NoiseCertificate_Details >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::CertChain_NoiseCertificate_Details >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::CertChain_NoiseCertificate* +Arena::CreateMaybeMessage< ::proto::CertChain_NoiseCertificate >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::CertChain_NoiseCertificate >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::CertChain* +Arena::CreateMaybeMessage< ::proto::CertChain >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::CertChain >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Chain* +Arena::CreateMaybeMessage< ::proto::Chain >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Chain >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::ChainKey* +Arena::CreateMaybeMessage< ::proto::ChainKey >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::ChainKey >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::ClientPayload_DNSSource* +Arena::CreateMaybeMessage< ::proto::ClientPayload_DNSSource >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::ClientPayload_DNSSource >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::ClientPayload_DevicePairingRegistrationData* +Arena::CreateMaybeMessage< ::proto::ClientPayload_DevicePairingRegistrationData >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::ClientPayload_DevicePairingRegistrationData >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::ClientPayload_UserAgent_AppVersion* +Arena::CreateMaybeMessage< ::proto::ClientPayload_UserAgent_AppVersion >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::ClientPayload_UserAgent_AppVersion >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::ClientPayload_UserAgent* +Arena::CreateMaybeMessage< ::proto::ClientPayload_UserAgent >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::ClientPayload_UserAgent >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::ClientPayload_WebInfo_WebdPayload* +Arena::CreateMaybeMessage< ::proto::ClientPayload_WebInfo_WebdPayload >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::ClientPayload_WebInfo_WebdPayload >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::ClientPayload_WebInfo* +Arena::CreateMaybeMessage< ::proto::ClientPayload_WebInfo >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::ClientPayload_WebInfo >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::ClientPayload* +Arena::CreateMaybeMessage< ::proto::ClientPayload >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::ClientPayload >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::ContextInfo_AdReplyInfo* +Arena::CreateMaybeMessage< ::proto::ContextInfo_AdReplyInfo >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::ContextInfo_AdReplyInfo >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::ContextInfo_ExternalAdReplyInfo* +Arena::CreateMaybeMessage< ::proto::ContextInfo_ExternalAdReplyInfo >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::ContextInfo_ExternalAdReplyInfo >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::ContextInfo* +Arena::CreateMaybeMessage< ::proto::ContextInfo >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::ContextInfo >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Conversation* +Arena::CreateMaybeMessage< ::proto::Conversation >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Conversation >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::DeviceListMetadata* +Arena::CreateMaybeMessage< ::proto::DeviceListMetadata >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::DeviceListMetadata >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::DeviceProps_AppVersion* +Arena::CreateMaybeMessage< ::proto::DeviceProps_AppVersion >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::DeviceProps_AppVersion >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::DeviceProps* +Arena::CreateMaybeMessage< ::proto::DeviceProps >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::DeviceProps >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::DisappearingMode* +Arena::CreateMaybeMessage< ::proto::DisappearingMode >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::DisappearingMode >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::EphemeralSetting* +Arena::CreateMaybeMessage< ::proto::EphemeralSetting >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::EphemeralSetting >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::ExitCode* +Arena::CreateMaybeMessage< ::proto::ExitCode >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::ExitCode >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::ExternalBlobReference* +Arena::CreateMaybeMessage< ::proto::ExternalBlobReference >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::ExternalBlobReference >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::GlobalSettings* +Arena::CreateMaybeMessage< ::proto::GlobalSettings >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::GlobalSettings >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::GroupParticipant* +Arena::CreateMaybeMessage< ::proto::GroupParticipant >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::GroupParticipant >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::HandshakeMessage_ClientFinish* +Arena::CreateMaybeMessage< ::proto::HandshakeMessage_ClientFinish >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::HandshakeMessage_ClientFinish >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::HandshakeMessage_ClientHello* +Arena::CreateMaybeMessage< ::proto::HandshakeMessage_ClientHello >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::HandshakeMessage_ClientHello >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::HandshakeMessage_ServerHello* +Arena::CreateMaybeMessage< ::proto::HandshakeMessage_ServerHello >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::HandshakeMessage_ServerHello >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::HandshakeMessage* +Arena::CreateMaybeMessage< ::proto::HandshakeMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::HandshakeMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::HistorySync* +Arena::CreateMaybeMessage< ::proto::HistorySync >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::HistorySync >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::HistorySyncMsg* +Arena::CreateMaybeMessage< ::proto::HistorySyncMsg >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::HistorySyncMsg >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::HydratedTemplateButton_HydratedCallButton* +Arena::CreateMaybeMessage< ::proto::HydratedTemplateButton_HydratedCallButton >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::HydratedTemplateButton_HydratedCallButton >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::HydratedTemplateButton_HydratedQuickReplyButton* +Arena::CreateMaybeMessage< ::proto::HydratedTemplateButton_HydratedQuickReplyButton >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::HydratedTemplateButton_HydratedQuickReplyButton >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::HydratedTemplateButton_HydratedURLButton* +Arena::CreateMaybeMessage< ::proto::HydratedTemplateButton_HydratedURLButton >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::HydratedTemplateButton_HydratedURLButton >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::HydratedTemplateButton* +Arena::CreateMaybeMessage< ::proto::HydratedTemplateButton >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::HydratedTemplateButton >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::IdentityKeyPairStructure* +Arena::CreateMaybeMessage< ::proto::IdentityKeyPairStructure >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::IdentityKeyPairStructure >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::InteractiveAnnotation* +Arena::CreateMaybeMessage< ::proto::InteractiveAnnotation >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::InteractiveAnnotation >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::KeepInChat* +Arena::CreateMaybeMessage< ::proto::KeepInChat >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::KeepInChat >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::KeyId* +Arena::CreateMaybeMessage< ::proto::KeyId >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::KeyId >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::LocalizedName* +Arena::CreateMaybeMessage< ::proto::LocalizedName >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::LocalizedName >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Location* +Arena::CreateMaybeMessage< ::proto::Location >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Location >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::MediaData* +Arena::CreateMaybeMessage< ::proto::MediaData >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::MediaData >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::MediaRetryNotification* +Arena::CreateMaybeMessage< ::proto::MediaRetryNotification >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::MediaRetryNotification >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_AppStateFatalExceptionNotification* +Arena::CreateMaybeMessage< ::proto::Message_AppStateFatalExceptionNotification >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_AppStateFatalExceptionNotification >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_AppStateSyncKeyData* +Arena::CreateMaybeMessage< ::proto::Message_AppStateSyncKeyData >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_AppStateSyncKeyData >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_AppStateSyncKeyFingerprint* +Arena::CreateMaybeMessage< ::proto::Message_AppStateSyncKeyFingerprint >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_AppStateSyncKeyFingerprint >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_AppStateSyncKeyId* +Arena::CreateMaybeMessage< ::proto::Message_AppStateSyncKeyId >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_AppStateSyncKeyId >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_AppStateSyncKeyRequest* +Arena::CreateMaybeMessage< ::proto::Message_AppStateSyncKeyRequest >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_AppStateSyncKeyRequest >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_AppStateSyncKeyShare* +Arena::CreateMaybeMessage< ::proto::Message_AppStateSyncKeyShare >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_AppStateSyncKeyShare >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_AppStateSyncKey* +Arena::CreateMaybeMessage< ::proto::Message_AppStateSyncKey >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_AppStateSyncKey >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_AudioMessage* +Arena::CreateMaybeMessage< ::proto::Message_AudioMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_AudioMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_ButtonsMessage_Button_ButtonText* +Arena::CreateMaybeMessage< ::proto::Message_ButtonsMessage_Button_ButtonText >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_ButtonsMessage_Button_ButtonText >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* +Arena::CreateMaybeMessage< ::proto::Message_ButtonsMessage_Button_NativeFlowInfo >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_ButtonsMessage_Button_NativeFlowInfo >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_ButtonsMessage_Button* +Arena::CreateMaybeMessage< ::proto::Message_ButtonsMessage_Button >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_ButtonsMessage_Button >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_ButtonsMessage* +Arena::CreateMaybeMessage< ::proto::Message_ButtonsMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_ButtonsMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_ButtonsResponseMessage* +Arena::CreateMaybeMessage< ::proto::Message_ButtonsResponseMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_ButtonsResponseMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_Call* +Arena::CreateMaybeMessage< ::proto::Message_Call >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_Call >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_CancelPaymentRequestMessage* +Arena::CreateMaybeMessage< ::proto::Message_CancelPaymentRequestMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_CancelPaymentRequestMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_Chat* +Arena::CreateMaybeMessage< ::proto::Message_Chat >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_Chat >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_ContactMessage* +Arena::CreateMaybeMessage< ::proto::Message_ContactMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_ContactMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_ContactsArrayMessage* +Arena::CreateMaybeMessage< ::proto::Message_ContactsArrayMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_ContactsArrayMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_DeclinePaymentRequestMessage* +Arena::CreateMaybeMessage< ::proto::Message_DeclinePaymentRequestMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_DeclinePaymentRequestMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_DeviceSentMessage* +Arena::CreateMaybeMessage< ::proto::Message_DeviceSentMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_DeviceSentMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_DocumentMessage* +Arena::CreateMaybeMessage< ::proto::Message_DocumentMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_DocumentMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_ExtendedTextMessage* +Arena::CreateMaybeMessage< ::proto::Message_ExtendedTextMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_ExtendedTextMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_FutureProofMessage* +Arena::CreateMaybeMessage< ::proto::Message_FutureProofMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_FutureProofMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_GroupInviteMessage* +Arena::CreateMaybeMessage< ::proto::Message_GroupInviteMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_GroupInviteMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* +Arena::CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* +Arena::CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* +Arena::CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* +Arena::CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* +Arena::CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_HighlyStructuredMessage* +Arena::CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_HighlyStructuredMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_HistorySyncNotification* +Arena::CreateMaybeMessage< ::proto::Message_HistorySyncNotification >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_HistorySyncNotification >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_ImageMessage* +Arena::CreateMaybeMessage< ::proto::Message_ImageMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_ImageMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_InitialSecurityNotificationSettingSync* +Arena::CreateMaybeMessage< ::proto::Message_InitialSecurityNotificationSettingSync >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_InitialSecurityNotificationSettingSync >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveMessage_Body* +Arena::CreateMaybeMessage< ::proto::Message_InteractiveMessage_Body >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_InteractiveMessage_Body >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveMessage_CollectionMessage* +Arena::CreateMaybeMessage< ::proto::Message_InteractiveMessage_CollectionMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_InteractiveMessage_CollectionMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveMessage_Footer* +Arena::CreateMaybeMessage< ::proto::Message_InteractiveMessage_Footer >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_InteractiveMessage_Footer >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveMessage_Header* +Arena::CreateMaybeMessage< ::proto::Message_InteractiveMessage_Header >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_InteractiveMessage_Header >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* +Arena::CreateMaybeMessage< ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveMessage_NativeFlowMessage* +Arena::CreateMaybeMessage< ::proto::Message_InteractiveMessage_NativeFlowMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_InteractiveMessage_NativeFlowMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveMessage_ShopMessage* +Arena::CreateMaybeMessage< ::proto::Message_InteractiveMessage_ShopMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_InteractiveMessage_ShopMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveMessage* +Arena::CreateMaybeMessage< ::proto::Message_InteractiveMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_InteractiveMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveResponseMessage_Body* +Arena::CreateMaybeMessage< ::proto::Message_InteractiveResponseMessage_Body >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_InteractiveResponseMessage_Body >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* +Arena::CreateMaybeMessage< ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveResponseMessage* +Arena::CreateMaybeMessage< ::proto::Message_InteractiveResponseMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_InteractiveResponseMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_InvoiceMessage* +Arena::CreateMaybeMessage< ::proto::Message_InvoiceMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_InvoiceMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_KeepInChatMessage* +Arena::CreateMaybeMessage< ::proto::Message_KeepInChatMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_KeepInChatMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_ListMessage_ProductListHeaderImage* +Arena::CreateMaybeMessage< ::proto::Message_ListMessage_ProductListHeaderImage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_ListMessage_ProductListHeaderImage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_ListMessage_ProductListInfo* +Arena::CreateMaybeMessage< ::proto::Message_ListMessage_ProductListInfo >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_ListMessage_ProductListInfo >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_ListMessage_ProductSection* +Arena::CreateMaybeMessage< ::proto::Message_ListMessage_ProductSection >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_ListMessage_ProductSection >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_ListMessage_Product* +Arena::CreateMaybeMessage< ::proto::Message_ListMessage_Product >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_ListMessage_Product >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_ListMessage_Row* +Arena::CreateMaybeMessage< ::proto::Message_ListMessage_Row >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_ListMessage_Row >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_ListMessage_Section* +Arena::CreateMaybeMessage< ::proto::Message_ListMessage_Section >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_ListMessage_Section >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_ListMessage* +Arena::CreateMaybeMessage< ::proto::Message_ListMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_ListMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_ListResponseMessage_SingleSelectReply* +Arena::CreateMaybeMessage< ::proto::Message_ListResponseMessage_SingleSelectReply >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_ListResponseMessage_SingleSelectReply >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_ListResponseMessage* +Arena::CreateMaybeMessage< ::proto::Message_ListResponseMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_ListResponseMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_LiveLocationMessage* +Arena::CreateMaybeMessage< ::proto::Message_LiveLocationMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_LiveLocationMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_LocationMessage* +Arena::CreateMaybeMessage< ::proto::Message_LocationMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_LocationMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_OrderMessage* +Arena::CreateMaybeMessage< ::proto::Message_OrderMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_OrderMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_PaymentInviteMessage* +Arena::CreateMaybeMessage< ::proto::Message_PaymentInviteMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_PaymentInviteMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_PollCreationMessage_Option* +Arena::CreateMaybeMessage< ::proto::Message_PollCreationMessage_Option >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_PollCreationMessage_Option >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_PollCreationMessage* +Arena::CreateMaybeMessage< ::proto::Message_PollCreationMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_PollCreationMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_PollEncValue* +Arena::CreateMaybeMessage< ::proto::Message_PollEncValue >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_PollEncValue >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_PollUpdateMessageMetadata* +Arena::CreateMaybeMessage< ::proto::Message_PollUpdateMessageMetadata >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_PollUpdateMessageMetadata >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_PollUpdateMessage* +Arena::CreateMaybeMessage< ::proto::Message_PollUpdateMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_PollUpdateMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_PollVoteMessage* +Arena::CreateMaybeMessage< ::proto::Message_PollVoteMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_PollVoteMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_ProductMessage_CatalogSnapshot* +Arena::CreateMaybeMessage< ::proto::Message_ProductMessage_CatalogSnapshot >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_ProductMessage_CatalogSnapshot >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_ProductMessage_ProductSnapshot* +Arena::CreateMaybeMessage< ::proto::Message_ProductMessage_ProductSnapshot >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_ProductMessage_ProductSnapshot >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_ProductMessage* +Arena::CreateMaybeMessage< ::proto::Message_ProductMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_ProductMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_ProtocolMessage* +Arena::CreateMaybeMessage< ::proto::Message_ProtocolMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_ProtocolMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_ReactionMessage* +Arena::CreateMaybeMessage< ::proto::Message_ReactionMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_ReactionMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_RequestMediaUploadMessage* +Arena::CreateMaybeMessage< ::proto::Message_RequestMediaUploadMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_RequestMediaUploadMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* +Arena::CreateMaybeMessage< ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_RequestMediaUploadResponseMessage* +Arena::CreateMaybeMessage< ::proto::Message_RequestMediaUploadResponseMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_RequestMediaUploadResponseMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_RequestPaymentMessage* +Arena::CreateMaybeMessage< ::proto::Message_RequestPaymentMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_RequestPaymentMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_RequestPhoneNumberMessage* +Arena::CreateMaybeMessage< ::proto::Message_RequestPhoneNumberMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_RequestPhoneNumberMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_SendPaymentMessage* +Arena::CreateMaybeMessage< ::proto::Message_SendPaymentMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_SendPaymentMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_SenderKeyDistributionMessage* +Arena::CreateMaybeMessage< ::proto::Message_SenderKeyDistributionMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_SenderKeyDistributionMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_StickerMessage* +Arena::CreateMaybeMessage< ::proto::Message_StickerMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_StickerMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_StickerSyncRMRMessage* +Arena::CreateMaybeMessage< ::proto::Message_StickerSyncRMRMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_StickerSyncRMRMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_TemplateButtonReplyMessage* +Arena::CreateMaybeMessage< ::proto::Message_TemplateButtonReplyMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_TemplateButtonReplyMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_TemplateMessage_FourRowTemplate* +Arena::CreateMaybeMessage< ::proto::Message_TemplateMessage_FourRowTemplate >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_TemplateMessage_FourRowTemplate >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_TemplateMessage_HydratedFourRowTemplate* +Arena::CreateMaybeMessage< ::proto::Message_TemplateMessage_HydratedFourRowTemplate >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_TemplateMessage_HydratedFourRowTemplate >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_TemplateMessage* +Arena::CreateMaybeMessage< ::proto::Message_TemplateMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_TemplateMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message_VideoMessage* +Arena::CreateMaybeMessage< ::proto::Message_VideoMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message_VideoMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Message* +Arena::CreateMaybeMessage< ::proto::Message >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Message >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::MessageContextInfo* +Arena::CreateMaybeMessage< ::proto::MessageContextInfo >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::MessageContextInfo >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::MessageKey* +Arena::CreateMaybeMessage< ::proto::MessageKey >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::MessageKey >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Money* +Arena::CreateMaybeMessage< ::proto::Money >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Money >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::MsgOpaqueData_PollOption* +Arena::CreateMaybeMessage< ::proto::MsgOpaqueData_PollOption >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::MsgOpaqueData_PollOption >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::MsgOpaqueData* +Arena::CreateMaybeMessage< ::proto::MsgOpaqueData >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::MsgOpaqueData >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::MsgRowOpaqueData* +Arena::CreateMaybeMessage< ::proto::MsgRowOpaqueData >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::MsgRowOpaqueData >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::NoiseCertificate_Details* +Arena::CreateMaybeMessage< ::proto::NoiseCertificate_Details >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::NoiseCertificate_Details >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::NoiseCertificate* +Arena::CreateMaybeMessage< ::proto::NoiseCertificate >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::NoiseCertificate >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::NotificationMessageInfo* +Arena::CreateMaybeMessage< ::proto::NotificationMessageInfo >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::NotificationMessageInfo >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::PastParticipant* +Arena::CreateMaybeMessage< ::proto::PastParticipant >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::PastParticipant >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::PastParticipants* +Arena::CreateMaybeMessage< ::proto::PastParticipants >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::PastParticipants >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::PaymentBackground_MediaData* +Arena::CreateMaybeMessage< ::proto::PaymentBackground_MediaData >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::PaymentBackground_MediaData >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::PaymentBackground* +Arena::CreateMaybeMessage< ::proto::PaymentBackground >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::PaymentBackground >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::PaymentInfo* +Arena::CreateMaybeMessage< ::proto::PaymentInfo >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::PaymentInfo >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::PendingKeyExchange* +Arena::CreateMaybeMessage< ::proto::PendingKeyExchange >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::PendingKeyExchange >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::PendingPreKey* +Arena::CreateMaybeMessage< ::proto::PendingPreKey >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::PendingPreKey >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::PhotoChange* +Arena::CreateMaybeMessage< ::proto::PhotoChange >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::PhotoChange >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Point* +Arena::CreateMaybeMessage< ::proto::Point >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Point >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::PollAdditionalMetadata* +Arena::CreateMaybeMessage< ::proto::PollAdditionalMetadata >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::PollAdditionalMetadata >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::PollEncValue* +Arena::CreateMaybeMessage< ::proto::PollEncValue >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::PollEncValue >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::PollUpdate* +Arena::CreateMaybeMessage< ::proto::PollUpdate >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::PollUpdate >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::PreKeyRecordStructure* +Arena::CreateMaybeMessage< ::proto::PreKeyRecordStructure >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::PreKeyRecordStructure >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Pushname* +Arena::CreateMaybeMessage< ::proto::Pushname >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Pushname >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::Reaction* +Arena::CreateMaybeMessage< ::proto::Reaction >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::Reaction >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::RecentEmojiWeight* +Arena::CreateMaybeMessage< ::proto::RecentEmojiWeight >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::RecentEmojiWeight >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::RecordStructure* +Arena::CreateMaybeMessage< ::proto::RecordStructure >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::RecordStructure >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SenderChainKey* +Arena::CreateMaybeMessage< ::proto::SenderChainKey >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SenderChainKey >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SenderKeyRecordStructure* +Arena::CreateMaybeMessage< ::proto::SenderKeyRecordStructure >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SenderKeyRecordStructure >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SenderKeyStateStructure* +Arena::CreateMaybeMessage< ::proto::SenderKeyStateStructure >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SenderKeyStateStructure >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SenderMessageKey* +Arena::CreateMaybeMessage< ::proto::SenderMessageKey >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SenderMessageKey >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SenderSigningKey* +Arena::CreateMaybeMessage< ::proto::SenderSigningKey >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SenderSigningKey >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::ServerErrorReceipt* +Arena::CreateMaybeMessage< ::proto::ServerErrorReceipt >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::ServerErrorReceipt >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SessionStructure* +Arena::CreateMaybeMessage< ::proto::SessionStructure >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SessionStructure >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SignedPreKeyRecordStructure* +Arena::CreateMaybeMessage< ::proto::SignedPreKeyRecordStructure >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SignedPreKeyRecordStructure >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::StatusPSA* +Arena::CreateMaybeMessage< ::proto::StatusPSA >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::StatusPSA >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::StickerMetadata* +Arena::CreateMaybeMessage< ::proto::StickerMetadata >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::StickerMetadata >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncActionData* +Arena::CreateMaybeMessage< ::proto::SyncActionData >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncActionData >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_AgentAction* +Arena::CreateMaybeMessage< ::proto::SyncActionValue_AgentAction >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncActionValue_AgentAction >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_AndroidUnsupportedActions* +Arena::CreateMaybeMessage< ::proto::SyncActionValue_AndroidUnsupportedActions >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncActionValue_AndroidUnsupportedActions >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_ArchiveChatAction* +Arena::CreateMaybeMessage< ::proto::SyncActionValue_ArchiveChatAction >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncActionValue_ArchiveChatAction >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_ClearChatAction* +Arena::CreateMaybeMessage< ::proto::SyncActionValue_ClearChatAction >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncActionValue_ClearChatAction >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_ContactAction* +Arena::CreateMaybeMessage< ::proto::SyncActionValue_ContactAction >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncActionValue_ContactAction >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_DeleteChatAction* +Arena::CreateMaybeMessage< ::proto::SyncActionValue_DeleteChatAction >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncActionValue_DeleteChatAction >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_DeleteMessageForMeAction* +Arena::CreateMaybeMessage< ::proto::SyncActionValue_DeleteMessageForMeAction >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncActionValue_DeleteMessageForMeAction >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_KeyExpiration* +Arena::CreateMaybeMessage< ::proto::SyncActionValue_KeyExpiration >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncActionValue_KeyExpiration >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_LabelAssociationAction* +Arena::CreateMaybeMessage< ::proto::SyncActionValue_LabelAssociationAction >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncActionValue_LabelAssociationAction >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_LabelEditAction* +Arena::CreateMaybeMessage< ::proto::SyncActionValue_LabelEditAction >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncActionValue_LabelEditAction >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_LocaleSetting* +Arena::CreateMaybeMessage< ::proto::SyncActionValue_LocaleSetting >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncActionValue_LocaleSetting >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_MarkChatAsReadAction* +Arena::CreateMaybeMessage< ::proto::SyncActionValue_MarkChatAsReadAction >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncActionValue_MarkChatAsReadAction >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_MuteAction* +Arena::CreateMaybeMessage< ::proto::SyncActionValue_MuteAction >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncActionValue_MuteAction >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_NuxAction* +Arena::CreateMaybeMessage< ::proto::SyncActionValue_NuxAction >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncActionValue_NuxAction >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_PinAction* +Arena::CreateMaybeMessage< ::proto::SyncActionValue_PinAction >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncActionValue_PinAction >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_PrimaryFeature* +Arena::CreateMaybeMessage< ::proto::SyncActionValue_PrimaryFeature >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncActionValue_PrimaryFeature >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_PrimaryVersionAction* +Arena::CreateMaybeMessage< ::proto::SyncActionValue_PrimaryVersionAction >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncActionValue_PrimaryVersionAction >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_PushNameSetting* +Arena::CreateMaybeMessage< ::proto::SyncActionValue_PushNameSetting >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncActionValue_PushNameSetting >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_QuickReplyAction* +Arena::CreateMaybeMessage< ::proto::SyncActionValue_QuickReplyAction >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncActionValue_QuickReplyAction >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_RecentEmojiWeightsAction* +Arena::CreateMaybeMessage< ::proto::SyncActionValue_RecentEmojiWeightsAction >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncActionValue_RecentEmojiWeightsAction >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_SecurityNotificationSetting* +Arena::CreateMaybeMessage< ::proto::SyncActionValue_SecurityNotificationSetting >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncActionValue_SecurityNotificationSetting >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_StarAction* +Arena::CreateMaybeMessage< ::proto::SyncActionValue_StarAction >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncActionValue_StarAction >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_StickerAction* +Arena::CreateMaybeMessage< ::proto::SyncActionValue_StickerAction >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncActionValue_StickerAction >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_SubscriptionAction* +Arena::CreateMaybeMessage< ::proto::SyncActionValue_SubscriptionAction >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncActionValue_SubscriptionAction >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_SyncActionMessageRange* +Arena::CreateMaybeMessage< ::proto::SyncActionValue_SyncActionMessageRange >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncActionValue_SyncActionMessageRange >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_SyncActionMessage* +Arena::CreateMaybeMessage< ::proto::SyncActionValue_SyncActionMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncActionValue_SyncActionMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_TimeFormatAction* +Arena::CreateMaybeMessage< ::proto::SyncActionValue_TimeFormatAction >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncActionValue_TimeFormatAction >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_UnarchiveChatsSetting* +Arena::CreateMaybeMessage< ::proto::SyncActionValue_UnarchiveChatsSetting >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncActionValue_UnarchiveChatsSetting >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_UserStatusMuteAction* +Arena::CreateMaybeMessage< ::proto::SyncActionValue_UserStatusMuteAction >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncActionValue_UserStatusMuteAction >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncActionValue* +Arena::CreateMaybeMessage< ::proto::SyncActionValue >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncActionValue >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncdIndex* +Arena::CreateMaybeMessage< ::proto::SyncdIndex >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncdIndex >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncdMutation* +Arena::CreateMaybeMessage< ::proto::SyncdMutation >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncdMutation >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncdMutations* +Arena::CreateMaybeMessage< ::proto::SyncdMutations >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncdMutations >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncdPatch* +Arena::CreateMaybeMessage< ::proto::SyncdPatch >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncdPatch >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncdRecord* +Arena::CreateMaybeMessage< ::proto::SyncdRecord >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncdRecord >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncdSnapshot* +Arena::CreateMaybeMessage< ::proto::SyncdSnapshot >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncdSnapshot >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncdValue* +Arena::CreateMaybeMessage< ::proto::SyncdValue >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncdValue >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::SyncdVersion* +Arena::CreateMaybeMessage< ::proto::SyncdVersion >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::SyncdVersion >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::TemplateButton_CallButton* +Arena::CreateMaybeMessage< ::proto::TemplateButton_CallButton >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::TemplateButton_CallButton >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::TemplateButton_QuickReplyButton* +Arena::CreateMaybeMessage< ::proto::TemplateButton_QuickReplyButton >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::TemplateButton_QuickReplyButton >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::TemplateButton_URLButton* +Arena::CreateMaybeMessage< ::proto::TemplateButton_URLButton >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::TemplateButton_URLButton >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::TemplateButton* +Arena::CreateMaybeMessage< ::proto::TemplateButton >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::TemplateButton >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::UserReceipt* +Arena::CreateMaybeMessage< ::proto::UserReceipt >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::UserReceipt >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::VerifiedNameCertificate_Details* +Arena::CreateMaybeMessage< ::proto::VerifiedNameCertificate_Details >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::VerifiedNameCertificate_Details >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::VerifiedNameCertificate* +Arena::CreateMaybeMessage< ::proto::VerifiedNameCertificate >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::VerifiedNameCertificate >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::WallpaperSettings* +Arena::CreateMaybeMessage< ::proto::WallpaperSettings >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::WallpaperSettings >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::WebFeatures* +Arena::CreateMaybeMessage< ::proto::WebFeatures >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::WebFeatures >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::WebMessageInfo* +Arena::CreateMaybeMessage< ::proto::WebMessageInfo >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::WebMessageInfo >(arena); +} +template<> PROTOBUF_NOINLINE ::proto::WebNotificationsInfo* +Arena::CreateMaybeMessage< ::proto::WebNotificationsInfo >(Arena* arena) { + return Arena::CreateMessageInternal< ::proto::WebNotificationsInfo >(arena); +} +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) +#include diff --git a/protocols/WhatsApp/src/pmsg.pb.h b/protocols/WhatsApp/src/pmsg.pb.h new file mode 100644 index 0000000000..5402ec1abf --- /dev/null +++ b/protocols/WhatsApp/src/pmsg.pb.h @@ -0,0 +1,125385 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: pmsg.proto + +#ifndef GOOGLE_PROTOBUF_INCLUDED_pmsg_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_pmsg_2eproto + +#include +#include + +#include +#if PROTOBUF_VERSION < 3021000 +#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 3021004 < PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +#include +// @@protoc_insertion_point(includes) +#include +#define PROTOBUF_INTERNAL_EXPORT_pmsg_2eproto +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_pmsg_2eproto { + static const uint32_t offsets[]; +}; +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_pmsg_2eproto; +namespace proto { +class ADVDeviceIdentity; +struct ADVDeviceIdentityDefaultTypeInternal; +extern ADVDeviceIdentityDefaultTypeInternal _ADVDeviceIdentity_default_instance_; +class ADVKeyIndexList; +struct ADVKeyIndexListDefaultTypeInternal; +extern ADVKeyIndexListDefaultTypeInternal _ADVKeyIndexList_default_instance_; +class ADVSignedDeviceIdentity; +struct ADVSignedDeviceIdentityDefaultTypeInternal; +extern ADVSignedDeviceIdentityDefaultTypeInternal _ADVSignedDeviceIdentity_default_instance_; +class ADVSignedDeviceIdentityHMAC; +struct ADVSignedDeviceIdentityHMACDefaultTypeInternal; +extern ADVSignedDeviceIdentityHMACDefaultTypeInternal _ADVSignedDeviceIdentityHMAC_default_instance_; +class ADVSignedKeyIndexList; +struct ADVSignedKeyIndexListDefaultTypeInternal; +extern ADVSignedKeyIndexListDefaultTypeInternal _ADVSignedKeyIndexList_default_instance_; +class ActionLink; +struct ActionLinkDefaultTypeInternal; +extern ActionLinkDefaultTypeInternal _ActionLink_default_instance_; +class AutoDownloadSettings; +struct AutoDownloadSettingsDefaultTypeInternal; +extern AutoDownloadSettingsDefaultTypeInternal _AutoDownloadSettings_default_instance_; +class BizAccountLinkInfo; +struct BizAccountLinkInfoDefaultTypeInternal; +extern BizAccountLinkInfoDefaultTypeInternal _BizAccountLinkInfo_default_instance_; +class BizAccountPayload; +struct BizAccountPayloadDefaultTypeInternal; +extern BizAccountPayloadDefaultTypeInternal _BizAccountPayload_default_instance_; +class BizIdentityInfo; +struct BizIdentityInfoDefaultTypeInternal; +extern BizIdentityInfoDefaultTypeInternal _BizIdentityInfo_default_instance_; +class CertChain; +struct CertChainDefaultTypeInternal; +extern CertChainDefaultTypeInternal _CertChain_default_instance_; +class CertChain_NoiseCertificate; +struct CertChain_NoiseCertificateDefaultTypeInternal; +extern CertChain_NoiseCertificateDefaultTypeInternal _CertChain_NoiseCertificate_default_instance_; +class CertChain_NoiseCertificate_Details; +struct CertChain_NoiseCertificate_DetailsDefaultTypeInternal; +extern CertChain_NoiseCertificate_DetailsDefaultTypeInternal _CertChain_NoiseCertificate_Details_default_instance_; +class Chain; +struct ChainDefaultTypeInternal; +extern ChainDefaultTypeInternal _Chain_default_instance_; +class ChainKey; +struct ChainKeyDefaultTypeInternal; +extern ChainKeyDefaultTypeInternal _ChainKey_default_instance_; +class ClientPayload; +struct ClientPayloadDefaultTypeInternal; +extern ClientPayloadDefaultTypeInternal _ClientPayload_default_instance_; +class ClientPayload_DNSSource; +struct ClientPayload_DNSSourceDefaultTypeInternal; +extern ClientPayload_DNSSourceDefaultTypeInternal _ClientPayload_DNSSource_default_instance_; +class ClientPayload_DevicePairingRegistrationData; +struct ClientPayload_DevicePairingRegistrationDataDefaultTypeInternal; +extern ClientPayload_DevicePairingRegistrationDataDefaultTypeInternal _ClientPayload_DevicePairingRegistrationData_default_instance_; +class ClientPayload_UserAgent; +struct ClientPayload_UserAgentDefaultTypeInternal; +extern ClientPayload_UserAgentDefaultTypeInternal _ClientPayload_UserAgent_default_instance_; +class ClientPayload_UserAgent_AppVersion; +struct ClientPayload_UserAgent_AppVersionDefaultTypeInternal; +extern ClientPayload_UserAgent_AppVersionDefaultTypeInternal _ClientPayload_UserAgent_AppVersion_default_instance_; +class ClientPayload_WebInfo; +struct ClientPayload_WebInfoDefaultTypeInternal; +extern ClientPayload_WebInfoDefaultTypeInternal _ClientPayload_WebInfo_default_instance_; +class ClientPayload_WebInfo_WebdPayload; +struct ClientPayload_WebInfo_WebdPayloadDefaultTypeInternal; +extern ClientPayload_WebInfo_WebdPayloadDefaultTypeInternal _ClientPayload_WebInfo_WebdPayload_default_instance_; +class ContextInfo; +struct ContextInfoDefaultTypeInternal; +extern ContextInfoDefaultTypeInternal _ContextInfo_default_instance_; +class ContextInfo_AdReplyInfo; +struct ContextInfo_AdReplyInfoDefaultTypeInternal; +extern ContextInfo_AdReplyInfoDefaultTypeInternal _ContextInfo_AdReplyInfo_default_instance_; +class ContextInfo_ExternalAdReplyInfo; +struct ContextInfo_ExternalAdReplyInfoDefaultTypeInternal; +extern ContextInfo_ExternalAdReplyInfoDefaultTypeInternal _ContextInfo_ExternalAdReplyInfo_default_instance_; +class Conversation; +struct ConversationDefaultTypeInternal; +extern ConversationDefaultTypeInternal _Conversation_default_instance_; +class DeviceListMetadata; +struct DeviceListMetadataDefaultTypeInternal; +extern DeviceListMetadataDefaultTypeInternal _DeviceListMetadata_default_instance_; +class DeviceProps; +struct DevicePropsDefaultTypeInternal; +extern DevicePropsDefaultTypeInternal _DeviceProps_default_instance_; +class DeviceProps_AppVersion; +struct DeviceProps_AppVersionDefaultTypeInternal; +extern DeviceProps_AppVersionDefaultTypeInternal _DeviceProps_AppVersion_default_instance_; +class DisappearingMode; +struct DisappearingModeDefaultTypeInternal; +extern DisappearingModeDefaultTypeInternal _DisappearingMode_default_instance_; +class EphemeralSetting; +struct EphemeralSettingDefaultTypeInternal; +extern EphemeralSettingDefaultTypeInternal _EphemeralSetting_default_instance_; +class ExitCode; +struct ExitCodeDefaultTypeInternal; +extern ExitCodeDefaultTypeInternal _ExitCode_default_instance_; +class ExternalBlobReference; +struct ExternalBlobReferenceDefaultTypeInternal; +extern ExternalBlobReferenceDefaultTypeInternal _ExternalBlobReference_default_instance_; +class GlobalSettings; +struct GlobalSettingsDefaultTypeInternal; +extern GlobalSettingsDefaultTypeInternal _GlobalSettings_default_instance_; +class GroupParticipant; +struct GroupParticipantDefaultTypeInternal; +extern GroupParticipantDefaultTypeInternal _GroupParticipant_default_instance_; +class HandshakeMessage; +struct HandshakeMessageDefaultTypeInternal; +extern HandshakeMessageDefaultTypeInternal _HandshakeMessage_default_instance_; +class HandshakeMessage_ClientFinish; +struct HandshakeMessage_ClientFinishDefaultTypeInternal; +extern HandshakeMessage_ClientFinishDefaultTypeInternal _HandshakeMessage_ClientFinish_default_instance_; +class HandshakeMessage_ClientHello; +struct HandshakeMessage_ClientHelloDefaultTypeInternal; +extern HandshakeMessage_ClientHelloDefaultTypeInternal _HandshakeMessage_ClientHello_default_instance_; +class HandshakeMessage_ServerHello; +struct HandshakeMessage_ServerHelloDefaultTypeInternal; +extern HandshakeMessage_ServerHelloDefaultTypeInternal _HandshakeMessage_ServerHello_default_instance_; +class HistorySync; +struct HistorySyncDefaultTypeInternal; +extern HistorySyncDefaultTypeInternal _HistorySync_default_instance_; +class HistorySyncMsg; +struct HistorySyncMsgDefaultTypeInternal; +extern HistorySyncMsgDefaultTypeInternal _HistorySyncMsg_default_instance_; +class HydratedTemplateButton; +struct HydratedTemplateButtonDefaultTypeInternal; +extern HydratedTemplateButtonDefaultTypeInternal _HydratedTemplateButton_default_instance_; +class HydratedTemplateButton_HydratedCallButton; +struct HydratedTemplateButton_HydratedCallButtonDefaultTypeInternal; +extern HydratedTemplateButton_HydratedCallButtonDefaultTypeInternal _HydratedTemplateButton_HydratedCallButton_default_instance_; +class HydratedTemplateButton_HydratedQuickReplyButton; +struct HydratedTemplateButton_HydratedQuickReplyButtonDefaultTypeInternal; +extern HydratedTemplateButton_HydratedQuickReplyButtonDefaultTypeInternal _HydratedTemplateButton_HydratedQuickReplyButton_default_instance_; +class HydratedTemplateButton_HydratedURLButton; +struct HydratedTemplateButton_HydratedURLButtonDefaultTypeInternal; +extern HydratedTemplateButton_HydratedURLButtonDefaultTypeInternal _HydratedTemplateButton_HydratedURLButton_default_instance_; +class IdentityKeyPairStructure; +struct IdentityKeyPairStructureDefaultTypeInternal; +extern IdentityKeyPairStructureDefaultTypeInternal _IdentityKeyPairStructure_default_instance_; +class InteractiveAnnotation; +struct InteractiveAnnotationDefaultTypeInternal; +extern InteractiveAnnotationDefaultTypeInternal _InteractiveAnnotation_default_instance_; +class KeepInChat; +struct KeepInChatDefaultTypeInternal; +extern KeepInChatDefaultTypeInternal _KeepInChat_default_instance_; +class KeyId; +struct KeyIdDefaultTypeInternal; +extern KeyIdDefaultTypeInternal _KeyId_default_instance_; +class LocalizedName; +struct LocalizedNameDefaultTypeInternal; +extern LocalizedNameDefaultTypeInternal _LocalizedName_default_instance_; +class Location; +struct LocationDefaultTypeInternal; +extern LocationDefaultTypeInternal _Location_default_instance_; +class MediaData; +struct MediaDataDefaultTypeInternal; +extern MediaDataDefaultTypeInternal _MediaData_default_instance_; +class MediaRetryNotification; +struct MediaRetryNotificationDefaultTypeInternal; +extern MediaRetryNotificationDefaultTypeInternal _MediaRetryNotification_default_instance_; +class Message; +struct MessageDefaultTypeInternal; +extern MessageDefaultTypeInternal _Message_default_instance_; +class MessageContextInfo; +struct MessageContextInfoDefaultTypeInternal; +extern MessageContextInfoDefaultTypeInternal _MessageContextInfo_default_instance_; +class MessageKey; +struct MessageKeyDefaultTypeInternal; +extern MessageKeyDefaultTypeInternal _MessageKey_default_instance_; +class Message_AppStateFatalExceptionNotification; +struct Message_AppStateFatalExceptionNotificationDefaultTypeInternal; +extern Message_AppStateFatalExceptionNotificationDefaultTypeInternal _Message_AppStateFatalExceptionNotification_default_instance_; +class Message_AppStateSyncKey; +struct Message_AppStateSyncKeyDefaultTypeInternal; +extern Message_AppStateSyncKeyDefaultTypeInternal _Message_AppStateSyncKey_default_instance_; +class Message_AppStateSyncKeyData; +struct Message_AppStateSyncKeyDataDefaultTypeInternal; +extern Message_AppStateSyncKeyDataDefaultTypeInternal _Message_AppStateSyncKeyData_default_instance_; +class Message_AppStateSyncKeyFingerprint; +struct Message_AppStateSyncKeyFingerprintDefaultTypeInternal; +extern Message_AppStateSyncKeyFingerprintDefaultTypeInternal _Message_AppStateSyncKeyFingerprint_default_instance_; +class Message_AppStateSyncKeyId; +struct Message_AppStateSyncKeyIdDefaultTypeInternal; +extern Message_AppStateSyncKeyIdDefaultTypeInternal _Message_AppStateSyncKeyId_default_instance_; +class Message_AppStateSyncKeyRequest; +struct Message_AppStateSyncKeyRequestDefaultTypeInternal; +extern Message_AppStateSyncKeyRequestDefaultTypeInternal _Message_AppStateSyncKeyRequest_default_instance_; +class Message_AppStateSyncKeyShare; +struct Message_AppStateSyncKeyShareDefaultTypeInternal; +extern Message_AppStateSyncKeyShareDefaultTypeInternal _Message_AppStateSyncKeyShare_default_instance_; +class Message_AudioMessage; +struct Message_AudioMessageDefaultTypeInternal; +extern Message_AudioMessageDefaultTypeInternal _Message_AudioMessage_default_instance_; +class Message_ButtonsMessage; +struct Message_ButtonsMessageDefaultTypeInternal; +extern Message_ButtonsMessageDefaultTypeInternal _Message_ButtonsMessage_default_instance_; +class Message_ButtonsMessage_Button; +struct Message_ButtonsMessage_ButtonDefaultTypeInternal; +extern Message_ButtonsMessage_ButtonDefaultTypeInternal _Message_ButtonsMessage_Button_default_instance_; +class Message_ButtonsMessage_Button_ButtonText; +struct Message_ButtonsMessage_Button_ButtonTextDefaultTypeInternal; +extern Message_ButtonsMessage_Button_ButtonTextDefaultTypeInternal _Message_ButtonsMessage_Button_ButtonText_default_instance_; +class Message_ButtonsMessage_Button_NativeFlowInfo; +struct Message_ButtonsMessage_Button_NativeFlowInfoDefaultTypeInternal; +extern Message_ButtonsMessage_Button_NativeFlowInfoDefaultTypeInternal _Message_ButtonsMessage_Button_NativeFlowInfo_default_instance_; +class Message_ButtonsResponseMessage; +struct Message_ButtonsResponseMessageDefaultTypeInternal; +extern Message_ButtonsResponseMessageDefaultTypeInternal _Message_ButtonsResponseMessage_default_instance_; +class Message_Call; +struct Message_CallDefaultTypeInternal; +extern Message_CallDefaultTypeInternal _Message_Call_default_instance_; +class Message_CancelPaymentRequestMessage; +struct Message_CancelPaymentRequestMessageDefaultTypeInternal; +extern Message_CancelPaymentRequestMessageDefaultTypeInternal _Message_CancelPaymentRequestMessage_default_instance_; +class Message_Chat; +struct Message_ChatDefaultTypeInternal; +extern Message_ChatDefaultTypeInternal _Message_Chat_default_instance_; +class Message_ContactMessage; +struct Message_ContactMessageDefaultTypeInternal; +extern Message_ContactMessageDefaultTypeInternal _Message_ContactMessage_default_instance_; +class Message_ContactsArrayMessage; +struct Message_ContactsArrayMessageDefaultTypeInternal; +extern Message_ContactsArrayMessageDefaultTypeInternal _Message_ContactsArrayMessage_default_instance_; +class Message_DeclinePaymentRequestMessage; +struct Message_DeclinePaymentRequestMessageDefaultTypeInternal; +extern Message_DeclinePaymentRequestMessageDefaultTypeInternal _Message_DeclinePaymentRequestMessage_default_instance_; +class Message_DeviceSentMessage; +struct Message_DeviceSentMessageDefaultTypeInternal; +extern Message_DeviceSentMessageDefaultTypeInternal _Message_DeviceSentMessage_default_instance_; +class Message_DocumentMessage; +struct Message_DocumentMessageDefaultTypeInternal; +extern Message_DocumentMessageDefaultTypeInternal _Message_DocumentMessage_default_instance_; +class Message_ExtendedTextMessage; +struct Message_ExtendedTextMessageDefaultTypeInternal; +extern Message_ExtendedTextMessageDefaultTypeInternal _Message_ExtendedTextMessage_default_instance_; +class Message_FutureProofMessage; +struct Message_FutureProofMessageDefaultTypeInternal; +extern Message_FutureProofMessageDefaultTypeInternal _Message_FutureProofMessage_default_instance_; +class Message_GroupInviteMessage; +struct Message_GroupInviteMessageDefaultTypeInternal; +extern Message_GroupInviteMessageDefaultTypeInternal _Message_GroupInviteMessage_default_instance_; +class Message_HighlyStructuredMessage; +struct Message_HighlyStructuredMessageDefaultTypeInternal; +extern Message_HighlyStructuredMessageDefaultTypeInternal _Message_HighlyStructuredMessage_default_instance_; +class Message_HighlyStructuredMessage_HSMLocalizableParameter; +struct Message_HighlyStructuredMessage_HSMLocalizableParameterDefaultTypeInternal; +extern Message_HighlyStructuredMessage_HSMLocalizableParameterDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_default_instance_; +class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency; +struct Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrencyDefaultTypeInternal; +extern Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrencyDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency_default_instance_; +class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime; +struct Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTimeDefaultTypeInternal; +extern Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTimeDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_default_instance_; +class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent; +struct Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponentDefaultTypeInternal; +extern Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponentDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_default_instance_; +class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch; +struct Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpochDefaultTypeInternal; +extern Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpochDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch_default_instance_; +class Message_HistorySyncNotification; +struct Message_HistorySyncNotificationDefaultTypeInternal; +extern Message_HistorySyncNotificationDefaultTypeInternal _Message_HistorySyncNotification_default_instance_; +class Message_ImageMessage; +struct Message_ImageMessageDefaultTypeInternal; +extern Message_ImageMessageDefaultTypeInternal _Message_ImageMessage_default_instance_; +class Message_InitialSecurityNotificationSettingSync; +struct Message_InitialSecurityNotificationSettingSyncDefaultTypeInternal; +extern Message_InitialSecurityNotificationSettingSyncDefaultTypeInternal _Message_InitialSecurityNotificationSettingSync_default_instance_; +class Message_InteractiveMessage; +struct Message_InteractiveMessageDefaultTypeInternal; +extern Message_InteractiveMessageDefaultTypeInternal _Message_InteractiveMessage_default_instance_; +class Message_InteractiveMessage_Body; +struct Message_InteractiveMessage_BodyDefaultTypeInternal; +extern Message_InteractiveMessage_BodyDefaultTypeInternal _Message_InteractiveMessage_Body_default_instance_; +class Message_InteractiveMessage_CollectionMessage; +struct Message_InteractiveMessage_CollectionMessageDefaultTypeInternal; +extern Message_InteractiveMessage_CollectionMessageDefaultTypeInternal _Message_InteractiveMessage_CollectionMessage_default_instance_; +class Message_InteractiveMessage_Footer; +struct Message_InteractiveMessage_FooterDefaultTypeInternal; +extern Message_InteractiveMessage_FooterDefaultTypeInternal _Message_InteractiveMessage_Footer_default_instance_; +class Message_InteractiveMessage_Header; +struct Message_InteractiveMessage_HeaderDefaultTypeInternal; +extern Message_InteractiveMessage_HeaderDefaultTypeInternal _Message_InteractiveMessage_Header_default_instance_; +class Message_InteractiveMessage_NativeFlowMessage; +struct Message_InteractiveMessage_NativeFlowMessageDefaultTypeInternal; +extern Message_InteractiveMessage_NativeFlowMessageDefaultTypeInternal _Message_InteractiveMessage_NativeFlowMessage_default_instance_; +class Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton; +struct Message_InteractiveMessage_NativeFlowMessage_NativeFlowButtonDefaultTypeInternal; +extern Message_InteractiveMessage_NativeFlowMessage_NativeFlowButtonDefaultTypeInternal _Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton_default_instance_; +class Message_InteractiveMessage_ShopMessage; +struct Message_InteractiveMessage_ShopMessageDefaultTypeInternal; +extern Message_InteractiveMessage_ShopMessageDefaultTypeInternal _Message_InteractiveMessage_ShopMessage_default_instance_; +class Message_InteractiveResponseMessage; +struct Message_InteractiveResponseMessageDefaultTypeInternal; +extern Message_InteractiveResponseMessageDefaultTypeInternal _Message_InteractiveResponseMessage_default_instance_; +class Message_InteractiveResponseMessage_Body; +struct Message_InteractiveResponseMessage_BodyDefaultTypeInternal; +extern Message_InteractiveResponseMessage_BodyDefaultTypeInternal _Message_InteractiveResponseMessage_Body_default_instance_; +class Message_InteractiveResponseMessage_NativeFlowResponseMessage; +struct Message_InteractiveResponseMessage_NativeFlowResponseMessageDefaultTypeInternal; +extern Message_InteractiveResponseMessage_NativeFlowResponseMessageDefaultTypeInternal _Message_InteractiveResponseMessage_NativeFlowResponseMessage_default_instance_; +class Message_InvoiceMessage; +struct Message_InvoiceMessageDefaultTypeInternal; +extern Message_InvoiceMessageDefaultTypeInternal _Message_InvoiceMessage_default_instance_; +class Message_KeepInChatMessage; +struct Message_KeepInChatMessageDefaultTypeInternal; +extern Message_KeepInChatMessageDefaultTypeInternal _Message_KeepInChatMessage_default_instance_; +class Message_ListMessage; +struct Message_ListMessageDefaultTypeInternal; +extern Message_ListMessageDefaultTypeInternal _Message_ListMessage_default_instance_; +class Message_ListMessage_Product; +struct Message_ListMessage_ProductDefaultTypeInternal; +extern Message_ListMessage_ProductDefaultTypeInternal _Message_ListMessage_Product_default_instance_; +class Message_ListMessage_ProductListHeaderImage; +struct Message_ListMessage_ProductListHeaderImageDefaultTypeInternal; +extern Message_ListMessage_ProductListHeaderImageDefaultTypeInternal _Message_ListMessage_ProductListHeaderImage_default_instance_; +class Message_ListMessage_ProductListInfo; +struct Message_ListMessage_ProductListInfoDefaultTypeInternal; +extern Message_ListMessage_ProductListInfoDefaultTypeInternal _Message_ListMessage_ProductListInfo_default_instance_; +class Message_ListMessage_ProductSection; +struct Message_ListMessage_ProductSectionDefaultTypeInternal; +extern Message_ListMessage_ProductSectionDefaultTypeInternal _Message_ListMessage_ProductSection_default_instance_; +class Message_ListMessage_Row; +struct Message_ListMessage_RowDefaultTypeInternal; +extern Message_ListMessage_RowDefaultTypeInternal _Message_ListMessage_Row_default_instance_; +class Message_ListMessage_Section; +struct Message_ListMessage_SectionDefaultTypeInternal; +extern Message_ListMessage_SectionDefaultTypeInternal _Message_ListMessage_Section_default_instance_; +class Message_ListResponseMessage; +struct Message_ListResponseMessageDefaultTypeInternal; +extern Message_ListResponseMessageDefaultTypeInternal _Message_ListResponseMessage_default_instance_; +class Message_ListResponseMessage_SingleSelectReply; +struct Message_ListResponseMessage_SingleSelectReplyDefaultTypeInternal; +extern Message_ListResponseMessage_SingleSelectReplyDefaultTypeInternal _Message_ListResponseMessage_SingleSelectReply_default_instance_; +class Message_LiveLocationMessage; +struct Message_LiveLocationMessageDefaultTypeInternal; +extern Message_LiveLocationMessageDefaultTypeInternal _Message_LiveLocationMessage_default_instance_; +class Message_LocationMessage; +struct Message_LocationMessageDefaultTypeInternal; +extern Message_LocationMessageDefaultTypeInternal _Message_LocationMessage_default_instance_; +class Message_OrderMessage; +struct Message_OrderMessageDefaultTypeInternal; +extern Message_OrderMessageDefaultTypeInternal _Message_OrderMessage_default_instance_; +class Message_PaymentInviteMessage; +struct Message_PaymentInviteMessageDefaultTypeInternal; +extern Message_PaymentInviteMessageDefaultTypeInternal _Message_PaymentInviteMessage_default_instance_; +class Message_PollCreationMessage; +struct Message_PollCreationMessageDefaultTypeInternal; +extern Message_PollCreationMessageDefaultTypeInternal _Message_PollCreationMessage_default_instance_; +class Message_PollCreationMessage_Option; +struct Message_PollCreationMessage_OptionDefaultTypeInternal; +extern Message_PollCreationMessage_OptionDefaultTypeInternal _Message_PollCreationMessage_Option_default_instance_; +class Message_PollEncValue; +struct Message_PollEncValueDefaultTypeInternal; +extern Message_PollEncValueDefaultTypeInternal _Message_PollEncValue_default_instance_; +class Message_PollUpdateMessage; +struct Message_PollUpdateMessageDefaultTypeInternal; +extern Message_PollUpdateMessageDefaultTypeInternal _Message_PollUpdateMessage_default_instance_; +class Message_PollUpdateMessageMetadata; +struct Message_PollUpdateMessageMetadataDefaultTypeInternal; +extern Message_PollUpdateMessageMetadataDefaultTypeInternal _Message_PollUpdateMessageMetadata_default_instance_; +class Message_PollVoteMessage; +struct Message_PollVoteMessageDefaultTypeInternal; +extern Message_PollVoteMessageDefaultTypeInternal _Message_PollVoteMessage_default_instance_; +class Message_ProductMessage; +struct Message_ProductMessageDefaultTypeInternal; +extern Message_ProductMessageDefaultTypeInternal _Message_ProductMessage_default_instance_; +class Message_ProductMessage_CatalogSnapshot; +struct Message_ProductMessage_CatalogSnapshotDefaultTypeInternal; +extern Message_ProductMessage_CatalogSnapshotDefaultTypeInternal _Message_ProductMessage_CatalogSnapshot_default_instance_; +class Message_ProductMessage_ProductSnapshot; +struct Message_ProductMessage_ProductSnapshotDefaultTypeInternal; +extern Message_ProductMessage_ProductSnapshotDefaultTypeInternal _Message_ProductMessage_ProductSnapshot_default_instance_; +class Message_ProtocolMessage; +struct Message_ProtocolMessageDefaultTypeInternal; +extern Message_ProtocolMessageDefaultTypeInternal _Message_ProtocolMessage_default_instance_; +class Message_ReactionMessage; +struct Message_ReactionMessageDefaultTypeInternal; +extern Message_ReactionMessageDefaultTypeInternal _Message_ReactionMessage_default_instance_; +class Message_RequestMediaUploadMessage; +struct Message_RequestMediaUploadMessageDefaultTypeInternal; +extern Message_RequestMediaUploadMessageDefaultTypeInternal _Message_RequestMediaUploadMessage_default_instance_; +class Message_RequestMediaUploadResponseMessage; +struct Message_RequestMediaUploadResponseMessageDefaultTypeInternal; +extern Message_RequestMediaUploadResponseMessageDefaultTypeInternal _Message_RequestMediaUploadResponseMessage_default_instance_; +class Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult; +struct Message_RequestMediaUploadResponseMessage_RequestMediaUploadResultDefaultTypeInternal; +extern Message_RequestMediaUploadResponseMessage_RequestMediaUploadResultDefaultTypeInternal _Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult_default_instance_; +class Message_RequestPaymentMessage; +struct Message_RequestPaymentMessageDefaultTypeInternal; +extern Message_RequestPaymentMessageDefaultTypeInternal _Message_RequestPaymentMessage_default_instance_; +class Message_RequestPhoneNumberMessage; +struct Message_RequestPhoneNumberMessageDefaultTypeInternal; +extern Message_RequestPhoneNumberMessageDefaultTypeInternal _Message_RequestPhoneNumberMessage_default_instance_; +class Message_SendPaymentMessage; +struct Message_SendPaymentMessageDefaultTypeInternal; +extern Message_SendPaymentMessageDefaultTypeInternal _Message_SendPaymentMessage_default_instance_; +class Message_SenderKeyDistributionMessage; +struct Message_SenderKeyDistributionMessageDefaultTypeInternal; +extern Message_SenderKeyDistributionMessageDefaultTypeInternal _Message_SenderKeyDistributionMessage_default_instance_; +class Message_StickerMessage; +struct Message_StickerMessageDefaultTypeInternal; +extern Message_StickerMessageDefaultTypeInternal _Message_StickerMessage_default_instance_; +class Message_StickerSyncRMRMessage; +struct Message_StickerSyncRMRMessageDefaultTypeInternal; +extern Message_StickerSyncRMRMessageDefaultTypeInternal _Message_StickerSyncRMRMessage_default_instance_; +class Message_TemplateButtonReplyMessage; +struct Message_TemplateButtonReplyMessageDefaultTypeInternal; +extern Message_TemplateButtonReplyMessageDefaultTypeInternal _Message_TemplateButtonReplyMessage_default_instance_; +class Message_TemplateMessage; +struct Message_TemplateMessageDefaultTypeInternal; +extern Message_TemplateMessageDefaultTypeInternal _Message_TemplateMessage_default_instance_; +class Message_TemplateMessage_FourRowTemplate; +struct Message_TemplateMessage_FourRowTemplateDefaultTypeInternal; +extern Message_TemplateMessage_FourRowTemplateDefaultTypeInternal _Message_TemplateMessage_FourRowTemplate_default_instance_; +class Message_TemplateMessage_HydratedFourRowTemplate; +struct Message_TemplateMessage_HydratedFourRowTemplateDefaultTypeInternal; +extern Message_TemplateMessage_HydratedFourRowTemplateDefaultTypeInternal _Message_TemplateMessage_HydratedFourRowTemplate_default_instance_; +class Message_VideoMessage; +struct Message_VideoMessageDefaultTypeInternal; +extern Message_VideoMessageDefaultTypeInternal _Message_VideoMessage_default_instance_; +class Money; +struct MoneyDefaultTypeInternal; +extern MoneyDefaultTypeInternal _Money_default_instance_; +class MsgOpaqueData; +struct MsgOpaqueDataDefaultTypeInternal; +extern MsgOpaqueDataDefaultTypeInternal _MsgOpaqueData_default_instance_; +class MsgOpaqueData_PollOption; +struct MsgOpaqueData_PollOptionDefaultTypeInternal; +extern MsgOpaqueData_PollOptionDefaultTypeInternal _MsgOpaqueData_PollOption_default_instance_; +class MsgRowOpaqueData; +struct MsgRowOpaqueDataDefaultTypeInternal; +extern MsgRowOpaqueDataDefaultTypeInternal _MsgRowOpaqueData_default_instance_; +class NoiseCertificate; +struct NoiseCertificateDefaultTypeInternal; +extern NoiseCertificateDefaultTypeInternal _NoiseCertificate_default_instance_; +class NoiseCertificate_Details; +struct NoiseCertificate_DetailsDefaultTypeInternal; +extern NoiseCertificate_DetailsDefaultTypeInternal _NoiseCertificate_Details_default_instance_; +class NotificationMessageInfo; +struct NotificationMessageInfoDefaultTypeInternal; +extern NotificationMessageInfoDefaultTypeInternal _NotificationMessageInfo_default_instance_; +class PastParticipant; +struct PastParticipantDefaultTypeInternal; +extern PastParticipantDefaultTypeInternal _PastParticipant_default_instance_; +class PastParticipants; +struct PastParticipantsDefaultTypeInternal; +extern PastParticipantsDefaultTypeInternal _PastParticipants_default_instance_; +class PaymentBackground; +struct PaymentBackgroundDefaultTypeInternal; +extern PaymentBackgroundDefaultTypeInternal _PaymentBackground_default_instance_; +class PaymentBackground_MediaData; +struct PaymentBackground_MediaDataDefaultTypeInternal; +extern PaymentBackground_MediaDataDefaultTypeInternal _PaymentBackground_MediaData_default_instance_; +class PaymentInfo; +struct PaymentInfoDefaultTypeInternal; +extern PaymentInfoDefaultTypeInternal _PaymentInfo_default_instance_; +class PendingKeyExchange; +struct PendingKeyExchangeDefaultTypeInternal; +extern PendingKeyExchangeDefaultTypeInternal _PendingKeyExchange_default_instance_; +class PendingPreKey; +struct PendingPreKeyDefaultTypeInternal; +extern PendingPreKeyDefaultTypeInternal _PendingPreKey_default_instance_; +class PhotoChange; +struct PhotoChangeDefaultTypeInternal; +extern PhotoChangeDefaultTypeInternal _PhotoChange_default_instance_; +class Point; +struct PointDefaultTypeInternal; +extern PointDefaultTypeInternal _Point_default_instance_; +class PollAdditionalMetadata; +struct PollAdditionalMetadataDefaultTypeInternal; +extern PollAdditionalMetadataDefaultTypeInternal _PollAdditionalMetadata_default_instance_; +class PollEncValue; +struct PollEncValueDefaultTypeInternal; +extern PollEncValueDefaultTypeInternal _PollEncValue_default_instance_; +class PollUpdate; +struct PollUpdateDefaultTypeInternal; +extern PollUpdateDefaultTypeInternal _PollUpdate_default_instance_; +class PreKeyRecordStructure; +struct PreKeyRecordStructureDefaultTypeInternal; +extern PreKeyRecordStructureDefaultTypeInternal _PreKeyRecordStructure_default_instance_; +class Pushname; +struct PushnameDefaultTypeInternal; +extern PushnameDefaultTypeInternal _Pushname_default_instance_; +class Reaction; +struct ReactionDefaultTypeInternal; +extern ReactionDefaultTypeInternal _Reaction_default_instance_; +class RecentEmojiWeight; +struct RecentEmojiWeightDefaultTypeInternal; +extern RecentEmojiWeightDefaultTypeInternal _RecentEmojiWeight_default_instance_; +class RecordStructure; +struct RecordStructureDefaultTypeInternal; +extern RecordStructureDefaultTypeInternal _RecordStructure_default_instance_; +class SenderChainKey; +struct SenderChainKeyDefaultTypeInternal; +extern SenderChainKeyDefaultTypeInternal _SenderChainKey_default_instance_; +class SenderKeyRecordStructure; +struct SenderKeyRecordStructureDefaultTypeInternal; +extern SenderKeyRecordStructureDefaultTypeInternal _SenderKeyRecordStructure_default_instance_; +class SenderKeyStateStructure; +struct SenderKeyStateStructureDefaultTypeInternal; +extern SenderKeyStateStructureDefaultTypeInternal _SenderKeyStateStructure_default_instance_; +class SenderMessageKey; +struct SenderMessageKeyDefaultTypeInternal; +extern SenderMessageKeyDefaultTypeInternal _SenderMessageKey_default_instance_; +class SenderSigningKey; +struct SenderSigningKeyDefaultTypeInternal; +extern SenderSigningKeyDefaultTypeInternal _SenderSigningKey_default_instance_; +class ServerErrorReceipt; +struct ServerErrorReceiptDefaultTypeInternal; +extern ServerErrorReceiptDefaultTypeInternal _ServerErrorReceipt_default_instance_; +class SessionStructure; +struct SessionStructureDefaultTypeInternal; +extern SessionStructureDefaultTypeInternal _SessionStructure_default_instance_; +class SignedPreKeyRecordStructure; +struct SignedPreKeyRecordStructureDefaultTypeInternal; +extern SignedPreKeyRecordStructureDefaultTypeInternal _SignedPreKeyRecordStructure_default_instance_; +class StatusPSA; +struct StatusPSADefaultTypeInternal; +extern StatusPSADefaultTypeInternal _StatusPSA_default_instance_; +class StickerMetadata; +struct StickerMetadataDefaultTypeInternal; +extern StickerMetadataDefaultTypeInternal _StickerMetadata_default_instance_; +class SyncActionData; +struct SyncActionDataDefaultTypeInternal; +extern SyncActionDataDefaultTypeInternal _SyncActionData_default_instance_; +class SyncActionValue; +struct SyncActionValueDefaultTypeInternal; +extern SyncActionValueDefaultTypeInternal _SyncActionValue_default_instance_; +class SyncActionValue_AgentAction; +struct SyncActionValue_AgentActionDefaultTypeInternal; +extern SyncActionValue_AgentActionDefaultTypeInternal _SyncActionValue_AgentAction_default_instance_; +class SyncActionValue_AndroidUnsupportedActions; +struct SyncActionValue_AndroidUnsupportedActionsDefaultTypeInternal; +extern SyncActionValue_AndroidUnsupportedActionsDefaultTypeInternal _SyncActionValue_AndroidUnsupportedActions_default_instance_; +class SyncActionValue_ArchiveChatAction; +struct SyncActionValue_ArchiveChatActionDefaultTypeInternal; +extern SyncActionValue_ArchiveChatActionDefaultTypeInternal _SyncActionValue_ArchiveChatAction_default_instance_; +class SyncActionValue_ClearChatAction; +struct SyncActionValue_ClearChatActionDefaultTypeInternal; +extern SyncActionValue_ClearChatActionDefaultTypeInternal _SyncActionValue_ClearChatAction_default_instance_; +class SyncActionValue_ContactAction; +struct SyncActionValue_ContactActionDefaultTypeInternal; +extern SyncActionValue_ContactActionDefaultTypeInternal _SyncActionValue_ContactAction_default_instance_; +class SyncActionValue_DeleteChatAction; +struct SyncActionValue_DeleteChatActionDefaultTypeInternal; +extern SyncActionValue_DeleteChatActionDefaultTypeInternal _SyncActionValue_DeleteChatAction_default_instance_; +class SyncActionValue_DeleteMessageForMeAction; +struct SyncActionValue_DeleteMessageForMeActionDefaultTypeInternal; +extern SyncActionValue_DeleteMessageForMeActionDefaultTypeInternal _SyncActionValue_DeleteMessageForMeAction_default_instance_; +class SyncActionValue_KeyExpiration; +struct SyncActionValue_KeyExpirationDefaultTypeInternal; +extern SyncActionValue_KeyExpirationDefaultTypeInternal _SyncActionValue_KeyExpiration_default_instance_; +class SyncActionValue_LabelAssociationAction; +struct SyncActionValue_LabelAssociationActionDefaultTypeInternal; +extern SyncActionValue_LabelAssociationActionDefaultTypeInternal _SyncActionValue_LabelAssociationAction_default_instance_; +class SyncActionValue_LabelEditAction; +struct SyncActionValue_LabelEditActionDefaultTypeInternal; +extern SyncActionValue_LabelEditActionDefaultTypeInternal _SyncActionValue_LabelEditAction_default_instance_; +class SyncActionValue_LocaleSetting; +struct SyncActionValue_LocaleSettingDefaultTypeInternal; +extern SyncActionValue_LocaleSettingDefaultTypeInternal _SyncActionValue_LocaleSetting_default_instance_; +class SyncActionValue_MarkChatAsReadAction; +struct SyncActionValue_MarkChatAsReadActionDefaultTypeInternal; +extern SyncActionValue_MarkChatAsReadActionDefaultTypeInternal _SyncActionValue_MarkChatAsReadAction_default_instance_; +class SyncActionValue_MuteAction; +struct SyncActionValue_MuteActionDefaultTypeInternal; +extern SyncActionValue_MuteActionDefaultTypeInternal _SyncActionValue_MuteAction_default_instance_; +class SyncActionValue_NuxAction; +struct SyncActionValue_NuxActionDefaultTypeInternal; +extern SyncActionValue_NuxActionDefaultTypeInternal _SyncActionValue_NuxAction_default_instance_; +class SyncActionValue_PinAction; +struct SyncActionValue_PinActionDefaultTypeInternal; +extern SyncActionValue_PinActionDefaultTypeInternal _SyncActionValue_PinAction_default_instance_; +class SyncActionValue_PrimaryFeature; +struct SyncActionValue_PrimaryFeatureDefaultTypeInternal; +extern SyncActionValue_PrimaryFeatureDefaultTypeInternal _SyncActionValue_PrimaryFeature_default_instance_; +class SyncActionValue_PrimaryVersionAction; +struct SyncActionValue_PrimaryVersionActionDefaultTypeInternal; +extern SyncActionValue_PrimaryVersionActionDefaultTypeInternal _SyncActionValue_PrimaryVersionAction_default_instance_; +class SyncActionValue_PushNameSetting; +struct SyncActionValue_PushNameSettingDefaultTypeInternal; +extern SyncActionValue_PushNameSettingDefaultTypeInternal _SyncActionValue_PushNameSetting_default_instance_; +class SyncActionValue_QuickReplyAction; +struct SyncActionValue_QuickReplyActionDefaultTypeInternal; +extern SyncActionValue_QuickReplyActionDefaultTypeInternal _SyncActionValue_QuickReplyAction_default_instance_; +class SyncActionValue_RecentEmojiWeightsAction; +struct SyncActionValue_RecentEmojiWeightsActionDefaultTypeInternal; +extern SyncActionValue_RecentEmojiWeightsActionDefaultTypeInternal _SyncActionValue_RecentEmojiWeightsAction_default_instance_; +class SyncActionValue_SecurityNotificationSetting; +struct SyncActionValue_SecurityNotificationSettingDefaultTypeInternal; +extern SyncActionValue_SecurityNotificationSettingDefaultTypeInternal _SyncActionValue_SecurityNotificationSetting_default_instance_; +class SyncActionValue_StarAction; +struct SyncActionValue_StarActionDefaultTypeInternal; +extern SyncActionValue_StarActionDefaultTypeInternal _SyncActionValue_StarAction_default_instance_; +class SyncActionValue_StickerAction; +struct SyncActionValue_StickerActionDefaultTypeInternal; +extern SyncActionValue_StickerActionDefaultTypeInternal _SyncActionValue_StickerAction_default_instance_; +class SyncActionValue_SubscriptionAction; +struct SyncActionValue_SubscriptionActionDefaultTypeInternal; +extern SyncActionValue_SubscriptionActionDefaultTypeInternal _SyncActionValue_SubscriptionAction_default_instance_; +class SyncActionValue_SyncActionMessage; +struct SyncActionValue_SyncActionMessageDefaultTypeInternal; +extern SyncActionValue_SyncActionMessageDefaultTypeInternal _SyncActionValue_SyncActionMessage_default_instance_; +class SyncActionValue_SyncActionMessageRange; +struct SyncActionValue_SyncActionMessageRangeDefaultTypeInternal; +extern SyncActionValue_SyncActionMessageRangeDefaultTypeInternal _SyncActionValue_SyncActionMessageRange_default_instance_; +class SyncActionValue_TimeFormatAction; +struct SyncActionValue_TimeFormatActionDefaultTypeInternal; +extern SyncActionValue_TimeFormatActionDefaultTypeInternal _SyncActionValue_TimeFormatAction_default_instance_; +class SyncActionValue_UnarchiveChatsSetting; +struct SyncActionValue_UnarchiveChatsSettingDefaultTypeInternal; +extern SyncActionValue_UnarchiveChatsSettingDefaultTypeInternal _SyncActionValue_UnarchiveChatsSetting_default_instance_; +class SyncActionValue_UserStatusMuteAction; +struct SyncActionValue_UserStatusMuteActionDefaultTypeInternal; +extern SyncActionValue_UserStatusMuteActionDefaultTypeInternal _SyncActionValue_UserStatusMuteAction_default_instance_; +class SyncdIndex; +struct SyncdIndexDefaultTypeInternal; +extern SyncdIndexDefaultTypeInternal _SyncdIndex_default_instance_; +class SyncdMutation; +struct SyncdMutationDefaultTypeInternal; +extern SyncdMutationDefaultTypeInternal _SyncdMutation_default_instance_; +class SyncdMutations; +struct SyncdMutationsDefaultTypeInternal; +extern SyncdMutationsDefaultTypeInternal _SyncdMutations_default_instance_; +class SyncdPatch; +struct SyncdPatchDefaultTypeInternal; +extern SyncdPatchDefaultTypeInternal _SyncdPatch_default_instance_; +class SyncdRecord; +struct SyncdRecordDefaultTypeInternal; +extern SyncdRecordDefaultTypeInternal _SyncdRecord_default_instance_; +class SyncdSnapshot; +struct SyncdSnapshotDefaultTypeInternal; +extern SyncdSnapshotDefaultTypeInternal _SyncdSnapshot_default_instance_; +class SyncdValue; +struct SyncdValueDefaultTypeInternal; +extern SyncdValueDefaultTypeInternal _SyncdValue_default_instance_; +class SyncdVersion; +struct SyncdVersionDefaultTypeInternal; +extern SyncdVersionDefaultTypeInternal _SyncdVersion_default_instance_; +class TemplateButton; +struct TemplateButtonDefaultTypeInternal; +extern TemplateButtonDefaultTypeInternal _TemplateButton_default_instance_; +class TemplateButton_CallButton; +struct TemplateButton_CallButtonDefaultTypeInternal; +extern TemplateButton_CallButtonDefaultTypeInternal _TemplateButton_CallButton_default_instance_; +class TemplateButton_QuickReplyButton; +struct TemplateButton_QuickReplyButtonDefaultTypeInternal; +extern TemplateButton_QuickReplyButtonDefaultTypeInternal _TemplateButton_QuickReplyButton_default_instance_; +class TemplateButton_URLButton; +struct TemplateButton_URLButtonDefaultTypeInternal; +extern TemplateButton_URLButtonDefaultTypeInternal _TemplateButton_URLButton_default_instance_; +class UserReceipt; +struct UserReceiptDefaultTypeInternal; +extern UserReceiptDefaultTypeInternal _UserReceipt_default_instance_; +class VerifiedNameCertificate; +struct VerifiedNameCertificateDefaultTypeInternal; +extern VerifiedNameCertificateDefaultTypeInternal _VerifiedNameCertificate_default_instance_; +class VerifiedNameCertificate_Details; +struct VerifiedNameCertificate_DetailsDefaultTypeInternal; +extern VerifiedNameCertificate_DetailsDefaultTypeInternal _VerifiedNameCertificate_Details_default_instance_; +class WallpaperSettings; +struct WallpaperSettingsDefaultTypeInternal; +extern WallpaperSettingsDefaultTypeInternal _WallpaperSettings_default_instance_; +class WebFeatures; +struct WebFeaturesDefaultTypeInternal; +extern WebFeaturesDefaultTypeInternal _WebFeatures_default_instance_; +class WebMessageInfo; +struct WebMessageInfoDefaultTypeInternal; +extern WebMessageInfoDefaultTypeInternal _WebMessageInfo_default_instance_; +class WebNotificationsInfo; +struct WebNotificationsInfoDefaultTypeInternal; +extern WebNotificationsInfoDefaultTypeInternal _WebNotificationsInfo_default_instance_; +} // namespace proto +PROTOBUF_NAMESPACE_OPEN +template<> ::proto::ADVDeviceIdentity* Arena::CreateMaybeMessage<::proto::ADVDeviceIdentity>(Arena*); +template<> ::proto::ADVKeyIndexList* Arena::CreateMaybeMessage<::proto::ADVKeyIndexList>(Arena*); +template<> ::proto::ADVSignedDeviceIdentity* Arena::CreateMaybeMessage<::proto::ADVSignedDeviceIdentity>(Arena*); +template<> ::proto::ADVSignedDeviceIdentityHMAC* Arena::CreateMaybeMessage<::proto::ADVSignedDeviceIdentityHMAC>(Arena*); +template<> ::proto::ADVSignedKeyIndexList* Arena::CreateMaybeMessage<::proto::ADVSignedKeyIndexList>(Arena*); +template<> ::proto::ActionLink* Arena::CreateMaybeMessage<::proto::ActionLink>(Arena*); +template<> ::proto::AutoDownloadSettings* Arena::CreateMaybeMessage<::proto::AutoDownloadSettings>(Arena*); +template<> ::proto::BizAccountLinkInfo* Arena::CreateMaybeMessage<::proto::BizAccountLinkInfo>(Arena*); +template<> ::proto::BizAccountPayload* Arena::CreateMaybeMessage<::proto::BizAccountPayload>(Arena*); +template<> ::proto::BizIdentityInfo* Arena::CreateMaybeMessage<::proto::BizIdentityInfo>(Arena*); +template<> ::proto::CertChain* Arena::CreateMaybeMessage<::proto::CertChain>(Arena*); +template<> ::proto::CertChain_NoiseCertificate* Arena::CreateMaybeMessage<::proto::CertChain_NoiseCertificate>(Arena*); +template<> ::proto::CertChain_NoiseCertificate_Details* Arena::CreateMaybeMessage<::proto::CertChain_NoiseCertificate_Details>(Arena*); +template<> ::proto::Chain* Arena::CreateMaybeMessage<::proto::Chain>(Arena*); +template<> ::proto::ChainKey* Arena::CreateMaybeMessage<::proto::ChainKey>(Arena*); +template<> ::proto::ClientPayload* Arena::CreateMaybeMessage<::proto::ClientPayload>(Arena*); +template<> ::proto::ClientPayload_DNSSource* Arena::CreateMaybeMessage<::proto::ClientPayload_DNSSource>(Arena*); +template<> ::proto::ClientPayload_DevicePairingRegistrationData* Arena::CreateMaybeMessage<::proto::ClientPayload_DevicePairingRegistrationData>(Arena*); +template<> ::proto::ClientPayload_UserAgent* Arena::CreateMaybeMessage<::proto::ClientPayload_UserAgent>(Arena*); +template<> ::proto::ClientPayload_UserAgent_AppVersion* Arena::CreateMaybeMessage<::proto::ClientPayload_UserAgent_AppVersion>(Arena*); +template<> ::proto::ClientPayload_WebInfo* Arena::CreateMaybeMessage<::proto::ClientPayload_WebInfo>(Arena*); +template<> ::proto::ClientPayload_WebInfo_WebdPayload* Arena::CreateMaybeMessage<::proto::ClientPayload_WebInfo_WebdPayload>(Arena*); +template<> ::proto::ContextInfo* Arena::CreateMaybeMessage<::proto::ContextInfo>(Arena*); +template<> ::proto::ContextInfo_AdReplyInfo* Arena::CreateMaybeMessage<::proto::ContextInfo_AdReplyInfo>(Arena*); +template<> ::proto::ContextInfo_ExternalAdReplyInfo* Arena::CreateMaybeMessage<::proto::ContextInfo_ExternalAdReplyInfo>(Arena*); +template<> ::proto::Conversation* Arena::CreateMaybeMessage<::proto::Conversation>(Arena*); +template<> ::proto::DeviceListMetadata* Arena::CreateMaybeMessage<::proto::DeviceListMetadata>(Arena*); +template<> ::proto::DeviceProps* Arena::CreateMaybeMessage<::proto::DeviceProps>(Arena*); +template<> ::proto::DeviceProps_AppVersion* Arena::CreateMaybeMessage<::proto::DeviceProps_AppVersion>(Arena*); +template<> ::proto::DisappearingMode* Arena::CreateMaybeMessage<::proto::DisappearingMode>(Arena*); +template<> ::proto::EphemeralSetting* Arena::CreateMaybeMessage<::proto::EphemeralSetting>(Arena*); +template<> ::proto::ExitCode* Arena::CreateMaybeMessage<::proto::ExitCode>(Arena*); +template<> ::proto::ExternalBlobReference* Arena::CreateMaybeMessage<::proto::ExternalBlobReference>(Arena*); +template<> ::proto::GlobalSettings* Arena::CreateMaybeMessage<::proto::GlobalSettings>(Arena*); +template<> ::proto::GroupParticipant* Arena::CreateMaybeMessage<::proto::GroupParticipant>(Arena*); +template<> ::proto::HandshakeMessage* Arena::CreateMaybeMessage<::proto::HandshakeMessage>(Arena*); +template<> ::proto::HandshakeMessage_ClientFinish* Arena::CreateMaybeMessage<::proto::HandshakeMessage_ClientFinish>(Arena*); +template<> ::proto::HandshakeMessage_ClientHello* Arena::CreateMaybeMessage<::proto::HandshakeMessage_ClientHello>(Arena*); +template<> ::proto::HandshakeMessage_ServerHello* Arena::CreateMaybeMessage<::proto::HandshakeMessage_ServerHello>(Arena*); +template<> ::proto::HistorySync* Arena::CreateMaybeMessage<::proto::HistorySync>(Arena*); +template<> ::proto::HistorySyncMsg* Arena::CreateMaybeMessage<::proto::HistorySyncMsg>(Arena*); +template<> ::proto::HydratedTemplateButton* Arena::CreateMaybeMessage<::proto::HydratedTemplateButton>(Arena*); +template<> ::proto::HydratedTemplateButton_HydratedCallButton* Arena::CreateMaybeMessage<::proto::HydratedTemplateButton_HydratedCallButton>(Arena*); +template<> ::proto::HydratedTemplateButton_HydratedQuickReplyButton* Arena::CreateMaybeMessage<::proto::HydratedTemplateButton_HydratedQuickReplyButton>(Arena*); +template<> ::proto::HydratedTemplateButton_HydratedURLButton* Arena::CreateMaybeMessage<::proto::HydratedTemplateButton_HydratedURLButton>(Arena*); +template<> ::proto::IdentityKeyPairStructure* Arena::CreateMaybeMessage<::proto::IdentityKeyPairStructure>(Arena*); +template<> ::proto::InteractiveAnnotation* Arena::CreateMaybeMessage<::proto::InteractiveAnnotation>(Arena*); +template<> ::proto::KeepInChat* Arena::CreateMaybeMessage<::proto::KeepInChat>(Arena*); +template<> ::proto::KeyId* Arena::CreateMaybeMessage<::proto::KeyId>(Arena*); +template<> ::proto::LocalizedName* Arena::CreateMaybeMessage<::proto::LocalizedName>(Arena*); +template<> ::proto::Location* Arena::CreateMaybeMessage<::proto::Location>(Arena*); +template<> ::proto::MediaData* Arena::CreateMaybeMessage<::proto::MediaData>(Arena*); +template<> ::proto::MediaRetryNotification* Arena::CreateMaybeMessage<::proto::MediaRetryNotification>(Arena*); +template<> ::proto::Message* Arena::CreateMaybeMessage<::proto::Message>(Arena*); +template<> ::proto::MessageContextInfo* Arena::CreateMaybeMessage<::proto::MessageContextInfo>(Arena*); +template<> ::proto::MessageKey* Arena::CreateMaybeMessage<::proto::MessageKey>(Arena*); +template<> ::proto::Message_AppStateFatalExceptionNotification* Arena::CreateMaybeMessage<::proto::Message_AppStateFatalExceptionNotification>(Arena*); +template<> ::proto::Message_AppStateSyncKey* Arena::CreateMaybeMessage<::proto::Message_AppStateSyncKey>(Arena*); +template<> ::proto::Message_AppStateSyncKeyData* Arena::CreateMaybeMessage<::proto::Message_AppStateSyncKeyData>(Arena*); +template<> ::proto::Message_AppStateSyncKeyFingerprint* Arena::CreateMaybeMessage<::proto::Message_AppStateSyncKeyFingerprint>(Arena*); +template<> ::proto::Message_AppStateSyncKeyId* Arena::CreateMaybeMessage<::proto::Message_AppStateSyncKeyId>(Arena*); +template<> ::proto::Message_AppStateSyncKeyRequest* Arena::CreateMaybeMessage<::proto::Message_AppStateSyncKeyRequest>(Arena*); +template<> ::proto::Message_AppStateSyncKeyShare* Arena::CreateMaybeMessage<::proto::Message_AppStateSyncKeyShare>(Arena*); +template<> ::proto::Message_AudioMessage* Arena::CreateMaybeMessage<::proto::Message_AudioMessage>(Arena*); +template<> ::proto::Message_ButtonsMessage* Arena::CreateMaybeMessage<::proto::Message_ButtonsMessage>(Arena*); +template<> ::proto::Message_ButtonsMessage_Button* Arena::CreateMaybeMessage<::proto::Message_ButtonsMessage_Button>(Arena*); +template<> ::proto::Message_ButtonsMessage_Button_ButtonText* Arena::CreateMaybeMessage<::proto::Message_ButtonsMessage_Button_ButtonText>(Arena*); +template<> ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* Arena::CreateMaybeMessage<::proto::Message_ButtonsMessage_Button_NativeFlowInfo>(Arena*); +template<> ::proto::Message_ButtonsResponseMessage* Arena::CreateMaybeMessage<::proto::Message_ButtonsResponseMessage>(Arena*); +template<> ::proto::Message_Call* Arena::CreateMaybeMessage<::proto::Message_Call>(Arena*); +template<> ::proto::Message_CancelPaymentRequestMessage* Arena::CreateMaybeMessage<::proto::Message_CancelPaymentRequestMessage>(Arena*); +template<> ::proto::Message_Chat* Arena::CreateMaybeMessage<::proto::Message_Chat>(Arena*); +template<> ::proto::Message_ContactMessage* Arena::CreateMaybeMessage<::proto::Message_ContactMessage>(Arena*); +template<> ::proto::Message_ContactsArrayMessage* Arena::CreateMaybeMessage<::proto::Message_ContactsArrayMessage>(Arena*); +template<> ::proto::Message_DeclinePaymentRequestMessage* Arena::CreateMaybeMessage<::proto::Message_DeclinePaymentRequestMessage>(Arena*); +template<> ::proto::Message_DeviceSentMessage* Arena::CreateMaybeMessage<::proto::Message_DeviceSentMessage>(Arena*); +template<> ::proto::Message_DocumentMessage* Arena::CreateMaybeMessage<::proto::Message_DocumentMessage>(Arena*); +template<> ::proto::Message_ExtendedTextMessage* Arena::CreateMaybeMessage<::proto::Message_ExtendedTextMessage>(Arena*); +template<> ::proto::Message_FutureProofMessage* Arena::CreateMaybeMessage<::proto::Message_FutureProofMessage>(Arena*); +template<> ::proto::Message_GroupInviteMessage* Arena::CreateMaybeMessage<::proto::Message_GroupInviteMessage>(Arena*); +template<> ::proto::Message_HighlyStructuredMessage* Arena::CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(Arena*); +template<> ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* Arena::CreateMaybeMessage<::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter>(Arena*); +template<> ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* Arena::CreateMaybeMessage<::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency>(Arena*); +template<> ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* Arena::CreateMaybeMessage<::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime>(Arena*); +template<> ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* Arena::CreateMaybeMessage<::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent>(Arena*); +template<> ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* Arena::CreateMaybeMessage<::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch>(Arena*); +template<> ::proto::Message_HistorySyncNotification* Arena::CreateMaybeMessage<::proto::Message_HistorySyncNotification>(Arena*); +template<> ::proto::Message_ImageMessage* Arena::CreateMaybeMessage<::proto::Message_ImageMessage>(Arena*); +template<> ::proto::Message_InitialSecurityNotificationSettingSync* Arena::CreateMaybeMessage<::proto::Message_InitialSecurityNotificationSettingSync>(Arena*); +template<> ::proto::Message_InteractiveMessage* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage>(Arena*); +template<> ::proto::Message_InteractiveMessage_Body* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage_Body>(Arena*); +template<> ::proto::Message_InteractiveMessage_CollectionMessage* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage_CollectionMessage>(Arena*); +template<> ::proto::Message_InteractiveMessage_Footer* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage_Footer>(Arena*); +template<> ::proto::Message_InteractiveMessage_Header* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage_Header>(Arena*); +template<> ::proto::Message_InteractiveMessage_NativeFlowMessage* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage_NativeFlowMessage>(Arena*); +template<> ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton>(Arena*); +template<> ::proto::Message_InteractiveMessage_ShopMessage* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage_ShopMessage>(Arena*); +template<> ::proto::Message_InteractiveResponseMessage* Arena::CreateMaybeMessage<::proto::Message_InteractiveResponseMessage>(Arena*); +template<> ::proto::Message_InteractiveResponseMessage_Body* Arena::CreateMaybeMessage<::proto::Message_InteractiveResponseMessage_Body>(Arena*); +template<> ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* Arena::CreateMaybeMessage<::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage>(Arena*); +template<> ::proto::Message_InvoiceMessage* Arena::CreateMaybeMessage<::proto::Message_InvoiceMessage>(Arena*); +template<> ::proto::Message_KeepInChatMessage* Arena::CreateMaybeMessage<::proto::Message_KeepInChatMessage>(Arena*); +template<> ::proto::Message_ListMessage* Arena::CreateMaybeMessage<::proto::Message_ListMessage>(Arena*); +template<> ::proto::Message_ListMessage_Product* Arena::CreateMaybeMessage<::proto::Message_ListMessage_Product>(Arena*); +template<> ::proto::Message_ListMessage_ProductListHeaderImage* Arena::CreateMaybeMessage<::proto::Message_ListMessage_ProductListHeaderImage>(Arena*); +template<> ::proto::Message_ListMessage_ProductListInfo* Arena::CreateMaybeMessage<::proto::Message_ListMessage_ProductListInfo>(Arena*); +template<> ::proto::Message_ListMessage_ProductSection* Arena::CreateMaybeMessage<::proto::Message_ListMessage_ProductSection>(Arena*); +template<> ::proto::Message_ListMessage_Row* Arena::CreateMaybeMessage<::proto::Message_ListMessage_Row>(Arena*); +template<> ::proto::Message_ListMessage_Section* Arena::CreateMaybeMessage<::proto::Message_ListMessage_Section>(Arena*); +template<> ::proto::Message_ListResponseMessage* Arena::CreateMaybeMessage<::proto::Message_ListResponseMessage>(Arena*); +template<> ::proto::Message_ListResponseMessage_SingleSelectReply* Arena::CreateMaybeMessage<::proto::Message_ListResponseMessage_SingleSelectReply>(Arena*); +template<> ::proto::Message_LiveLocationMessage* Arena::CreateMaybeMessage<::proto::Message_LiveLocationMessage>(Arena*); +template<> ::proto::Message_LocationMessage* Arena::CreateMaybeMessage<::proto::Message_LocationMessage>(Arena*); +template<> ::proto::Message_OrderMessage* Arena::CreateMaybeMessage<::proto::Message_OrderMessage>(Arena*); +template<> ::proto::Message_PaymentInviteMessage* Arena::CreateMaybeMessage<::proto::Message_PaymentInviteMessage>(Arena*); +template<> ::proto::Message_PollCreationMessage* Arena::CreateMaybeMessage<::proto::Message_PollCreationMessage>(Arena*); +template<> ::proto::Message_PollCreationMessage_Option* Arena::CreateMaybeMessage<::proto::Message_PollCreationMessage_Option>(Arena*); +template<> ::proto::Message_PollEncValue* Arena::CreateMaybeMessage<::proto::Message_PollEncValue>(Arena*); +template<> ::proto::Message_PollUpdateMessage* Arena::CreateMaybeMessage<::proto::Message_PollUpdateMessage>(Arena*); +template<> ::proto::Message_PollUpdateMessageMetadata* Arena::CreateMaybeMessage<::proto::Message_PollUpdateMessageMetadata>(Arena*); +template<> ::proto::Message_PollVoteMessage* Arena::CreateMaybeMessage<::proto::Message_PollVoteMessage>(Arena*); +template<> ::proto::Message_ProductMessage* Arena::CreateMaybeMessage<::proto::Message_ProductMessage>(Arena*); +template<> ::proto::Message_ProductMessage_CatalogSnapshot* Arena::CreateMaybeMessage<::proto::Message_ProductMessage_CatalogSnapshot>(Arena*); +template<> ::proto::Message_ProductMessage_ProductSnapshot* Arena::CreateMaybeMessage<::proto::Message_ProductMessage_ProductSnapshot>(Arena*); +template<> ::proto::Message_ProtocolMessage* Arena::CreateMaybeMessage<::proto::Message_ProtocolMessage>(Arena*); +template<> ::proto::Message_ReactionMessage* Arena::CreateMaybeMessage<::proto::Message_ReactionMessage>(Arena*); +template<> ::proto::Message_RequestMediaUploadMessage* Arena::CreateMaybeMessage<::proto::Message_RequestMediaUploadMessage>(Arena*); +template<> ::proto::Message_RequestMediaUploadResponseMessage* Arena::CreateMaybeMessage<::proto::Message_RequestMediaUploadResponseMessage>(Arena*); +template<> ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* Arena::CreateMaybeMessage<::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult>(Arena*); +template<> ::proto::Message_RequestPaymentMessage* Arena::CreateMaybeMessage<::proto::Message_RequestPaymentMessage>(Arena*); +template<> ::proto::Message_RequestPhoneNumberMessage* Arena::CreateMaybeMessage<::proto::Message_RequestPhoneNumberMessage>(Arena*); +template<> ::proto::Message_SendPaymentMessage* Arena::CreateMaybeMessage<::proto::Message_SendPaymentMessage>(Arena*); +template<> ::proto::Message_SenderKeyDistributionMessage* Arena::CreateMaybeMessage<::proto::Message_SenderKeyDistributionMessage>(Arena*); +template<> ::proto::Message_StickerMessage* Arena::CreateMaybeMessage<::proto::Message_StickerMessage>(Arena*); +template<> ::proto::Message_StickerSyncRMRMessage* Arena::CreateMaybeMessage<::proto::Message_StickerSyncRMRMessage>(Arena*); +template<> ::proto::Message_TemplateButtonReplyMessage* Arena::CreateMaybeMessage<::proto::Message_TemplateButtonReplyMessage>(Arena*); +template<> ::proto::Message_TemplateMessage* Arena::CreateMaybeMessage<::proto::Message_TemplateMessage>(Arena*); +template<> ::proto::Message_TemplateMessage_FourRowTemplate* Arena::CreateMaybeMessage<::proto::Message_TemplateMessage_FourRowTemplate>(Arena*); +template<> ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Arena::CreateMaybeMessage<::proto::Message_TemplateMessage_HydratedFourRowTemplate>(Arena*); +template<> ::proto::Message_VideoMessage* Arena::CreateMaybeMessage<::proto::Message_VideoMessage>(Arena*); +template<> ::proto::Money* Arena::CreateMaybeMessage<::proto::Money>(Arena*); +template<> ::proto::MsgOpaqueData* Arena::CreateMaybeMessage<::proto::MsgOpaqueData>(Arena*); +template<> ::proto::MsgOpaqueData_PollOption* Arena::CreateMaybeMessage<::proto::MsgOpaqueData_PollOption>(Arena*); +template<> ::proto::MsgRowOpaqueData* Arena::CreateMaybeMessage<::proto::MsgRowOpaqueData>(Arena*); +template<> ::proto::NoiseCertificate* Arena::CreateMaybeMessage<::proto::NoiseCertificate>(Arena*); +template<> ::proto::NoiseCertificate_Details* Arena::CreateMaybeMessage<::proto::NoiseCertificate_Details>(Arena*); +template<> ::proto::NotificationMessageInfo* Arena::CreateMaybeMessage<::proto::NotificationMessageInfo>(Arena*); +template<> ::proto::PastParticipant* Arena::CreateMaybeMessage<::proto::PastParticipant>(Arena*); +template<> ::proto::PastParticipants* Arena::CreateMaybeMessage<::proto::PastParticipants>(Arena*); +template<> ::proto::PaymentBackground* Arena::CreateMaybeMessage<::proto::PaymentBackground>(Arena*); +template<> ::proto::PaymentBackground_MediaData* Arena::CreateMaybeMessage<::proto::PaymentBackground_MediaData>(Arena*); +template<> ::proto::PaymentInfo* Arena::CreateMaybeMessage<::proto::PaymentInfo>(Arena*); +template<> ::proto::PendingKeyExchange* Arena::CreateMaybeMessage<::proto::PendingKeyExchange>(Arena*); +template<> ::proto::PendingPreKey* Arena::CreateMaybeMessage<::proto::PendingPreKey>(Arena*); +template<> ::proto::PhotoChange* Arena::CreateMaybeMessage<::proto::PhotoChange>(Arena*); +template<> ::proto::Point* Arena::CreateMaybeMessage<::proto::Point>(Arena*); +template<> ::proto::PollAdditionalMetadata* Arena::CreateMaybeMessage<::proto::PollAdditionalMetadata>(Arena*); +template<> ::proto::PollEncValue* Arena::CreateMaybeMessage<::proto::PollEncValue>(Arena*); +template<> ::proto::PollUpdate* Arena::CreateMaybeMessage<::proto::PollUpdate>(Arena*); +template<> ::proto::PreKeyRecordStructure* Arena::CreateMaybeMessage<::proto::PreKeyRecordStructure>(Arena*); +template<> ::proto::Pushname* Arena::CreateMaybeMessage<::proto::Pushname>(Arena*); +template<> ::proto::Reaction* Arena::CreateMaybeMessage<::proto::Reaction>(Arena*); +template<> ::proto::RecentEmojiWeight* Arena::CreateMaybeMessage<::proto::RecentEmojiWeight>(Arena*); +template<> ::proto::RecordStructure* Arena::CreateMaybeMessage<::proto::RecordStructure>(Arena*); +template<> ::proto::SenderChainKey* Arena::CreateMaybeMessage<::proto::SenderChainKey>(Arena*); +template<> ::proto::SenderKeyRecordStructure* Arena::CreateMaybeMessage<::proto::SenderKeyRecordStructure>(Arena*); +template<> ::proto::SenderKeyStateStructure* Arena::CreateMaybeMessage<::proto::SenderKeyStateStructure>(Arena*); +template<> ::proto::SenderMessageKey* Arena::CreateMaybeMessage<::proto::SenderMessageKey>(Arena*); +template<> ::proto::SenderSigningKey* Arena::CreateMaybeMessage<::proto::SenderSigningKey>(Arena*); +template<> ::proto::ServerErrorReceipt* Arena::CreateMaybeMessage<::proto::ServerErrorReceipt>(Arena*); +template<> ::proto::SessionStructure* Arena::CreateMaybeMessage<::proto::SessionStructure>(Arena*); +template<> ::proto::SignedPreKeyRecordStructure* Arena::CreateMaybeMessage<::proto::SignedPreKeyRecordStructure>(Arena*); +template<> ::proto::StatusPSA* Arena::CreateMaybeMessage<::proto::StatusPSA>(Arena*); +template<> ::proto::StickerMetadata* Arena::CreateMaybeMessage<::proto::StickerMetadata>(Arena*); +template<> ::proto::SyncActionData* Arena::CreateMaybeMessage<::proto::SyncActionData>(Arena*); +template<> ::proto::SyncActionValue* Arena::CreateMaybeMessage<::proto::SyncActionValue>(Arena*); +template<> ::proto::SyncActionValue_AgentAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_AgentAction>(Arena*); +template<> ::proto::SyncActionValue_AndroidUnsupportedActions* Arena::CreateMaybeMessage<::proto::SyncActionValue_AndroidUnsupportedActions>(Arena*); +template<> ::proto::SyncActionValue_ArchiveChatAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_ArchiveChatAction>(Arena*); +template<> ::proto::SyncActionValue_ClearChatAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_ClearChatAction>(Arena*); +template<> ::proto::SyncActionValue_ContactAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_ContactAction>(Arena*); +template<> ::proto::SyncActionValue_DeleteChatAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_DeleteChatAction>(Arena*); +template<> ::proto::SyncActionValue_DeleteMessageForMeAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_DeleteMessageForMeAction>(Arena*); +template<> ::proto::SyncActionValue_KeyExpiration* Arena::CreateMaybeMessage<::proto::SyncActionValue_KeyExpiration>(Arena*); +template<> ::proto::SyncActionValue_LabelAssociationAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_LabelAssociationAction>(Arena*); +template<> ::proto::SyncActionValue_LabelEditAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_LabelEditAction>(Arena*); +template<> ::proto::SyncActionValue_LocaleSetting* Arena::CreateMaybeMessage<::proto::SyncActionValue_LocaleSetting>(Arena*); +template<> ::proto::SyncActionValue_MarkChatAsReadAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_MarkChatAsReadAction>(Arena*); +template<> ::proto::SyncActionValue_MuteAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_MuteAction>(Arena*); +template<> ::proto::SyncActionValue_NuxAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_NuxAction>(Arena*); +template<> ::proto::SyncActionValue_PinAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_PinAction>(Arena*); +template<> ::proto::SyncActionValue_PrimaryFeature* Arena::CreateMaybeMessage<::proto::SyncActionValue_PrimaryFeature>(Arena*); +template<> ::proto::SyncActionValue_PrimaryVersionAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_PrimaryVersionAction>(Arena*); +template<> ::proto::SyncActionValue_PushNameSetting* Arena::CreateMaybeMessage<::proto::SyncActionValue_PushNameSetting>(Arena*); +template<> ::proto::SyncActionValue_QuickReplyAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_QuickReplyAction>(Arena*); +template<> ::proto::SyncActionValue_RecentEmojiWeightsAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_RecentEmojiWeightsAction>(Arena*); +template<> ::proto::SyncActionValue_SecurityNotificationSetting* Arena::CreateMaybeMessage<::proto::SyncActionValue_SecurityNotificationSetting>(Arena*); +template<> ::proto::SyncActionValue_StarAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_StarAction>(Arena*); +template<> ::proto::SyncActionValue_StickerAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_StickerAction>(Arena*); +template<> ::proto::SyncActionValue_SubscriptionAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_SubscriptionAction>(Arena*); +template<> ::proto::SyncActionValue_SyncActionMessage* Arena::CreateMaybeMessage<::proto::SyncActionValue_SyncActionMessage>(Arena*); +template<> ::proto::SyncActionValue_SyncActionMessageRange* Arena::CreateMaybeMessage<::proto::SyncActionValue_SyncActionMessageRange>(Arena*); +template<> ::proto::SyncActionValue_TimeFormatAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_TimeFormatAction>(Arena*); +template<> ::proto::SyncActionValue_UnarchiveChatsSetting* Arena::CreateMaybeMessage<::proto::SyncActionValue_UnarchiveChatsSetting>(Arena*); +template<> ::proto::SyncActionValue_UserStatusMuteAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_UserStatusMuteAction>(Arena*); +template<> ::proto::SyncdIndex* Arena::CreateMaybeMessage<::proto::SyncdIndex>(Arena*); +template<> ::proto::SyncdMutation* Arena::CreateMaybeMessage<::proto::SyncdMutation>(Arena*); +template<> ::proto::SyncdMutations* Arena::CreateMaybeMessage<::proto::SyncdMutations>(Arena*); +template<> ::proto::SyncdPatch* Arena::CreateMaybeMessage<::proto::SyncdPatch>(Arena*); +template<> ::proto::SyncdRecord* Arena::CreateMaybeMessage<::proto::SyncdRecord>(Arena*); +template<> ::proto::SyncdSnapshot* Arena::CreateMaybeMessage<::proto::SyncdSnapshot>(Arena*); +template<> ::proto::SyncdValue* Arena::CreateMaybeMessage<::proto::SyncdValue>(Arena*); +template<> ::proto::SyncdVersion* Arena::CreateMaybeMessage<::proto::SyncdVersion>(Arena*); +template<> ::proto::TemplateButton* Arena::CreateMaybeMessage<::proto::TemplateButton>(Arena*); +template<> ::proto::TemplateButton_CallButton* Arena::CreateMaybeMessage<::proto::TemplateButton_CallButton>(Arena*); +template<> ::proto::TemplateButton_QuickReplyButton* Arena::CreateMaybeMessage<::proto::TemplateButton_QuickReplyButton>(Arena*); +template<> ::proto::TemplateButton_URLButton* Arena::CreateMaybeMessage<::proto::TemplateButton_URLButton>(Arena*); +template<> ::proto::UserReceipt* Arena::CreateMaybeMessage<::proto::UserReceipt>(Arena*); +template<> ::proto::VerifiedNameCertificate* Arena::CreateMaybeMessage<::proto::VerifiedNameCertificate>(Arena*); +template<> ::proto::VerifiedNameCertificate_Details* Arena::CreateMaybeMessage<::proto::VerifiedNameCertificate_Details>(Arena*); +template<> ::proto::WallpaperSettings* Arena::CreateMaybeMessage<::proto::WallpaperSettings>(Arena*); +template<> ::proto::WebFeatures* Arena::CreateMaybeMessage<::proto::WebFeatures>(Arena*); +template<> ::proto::WebMessageInfo* Arena::CreateMaybeMessage<::proto::WebMessageInfo>(Arena*); +template<> ::proto::WebNotificationsInfo* Arena::CreateMaybeMessage<::proto::WebNotificationsInfo>(Arena*); +PROTOBUF_NAMESPACE_CLOSE +namespace proto { + +enum BizAccountLinkInfo_AccountType : int { + BizAccountLinkInfo_AccountType_ENTERPRISE = 0 +}; +bool BizAccountLinkInfo_AccountType_IsValid(int value); +constexpr BizAccountLinkInfo_AccountType BizAccountLinkInfo_AccountType_AccountType_MIN = BizAccountLinkInfo_AccountType_ENTERPRISE; +constexpr BizAccountLinkInfo_AccountType BizAccountLinkInfo_AccountType_AccountType_MAX = BizAccountLinkInfo_AccountType_ENTERPRISE; +constexpr int BizAccountLinkInfo_AccountType_AccountType_ARRAYSIZE = BizAccountLinkInfo_AccountType_AccountType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizAccountLinkInfo_AccountType_descriptor(); +template +inline const std::string& BizAccountLinkInfo_AccountType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function BizAccountLinkInfo_AccountType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + BizAccountLinkInfo_AccountType_descriptor(), enum_t_value); +} +inline bool BizAccountLinkInfo_AccountType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BizAccountLinkInfo_AccountType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + BizAccountLinkInfo_AccountType_descriptor(), name, value); +} +enum BizAccountLinkInfo_HostStorageType : int { + BizAccountLinkInfo_HostStorageType_ON_PREMISE = 0, + BizAccountLinkInfo_HostStorageType_FACEBOOK = 1 +}; +bool BizAccountLinkInfo_HostStorageType_IsValid(int value); +constexpr BizAccountLinkInfo_HostStorageType BizAccountLinkInfo_HostStorageType_HostStorageType_MIN = BizAccountLinkInfo_HostStorageType_ON_PREMISE; +constexpr BizAccountLinkInfo_HostStorageType BizAccountLinkInfo_HostStorageType_HostStorageType_MAX = BizAccountLinkInfo_HostStorageType_FACEBOOK; +constexpr int BizAccountLinkInfo_HostStorageType_HostStorageType_ARRAYSIZE = BizAccountLinkInfo_HostStorageType_HostStorageType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizAccountLinkInfo_HostStorageType_descriptor(); +template +inline const std::string& BizAccountLinkInfo_HostStorageType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function BizAccountLinkInfo_HostStorageType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + BizAccountLinkInfo_HostStorageType_descriptor(), enum_t_value); +} +inline bool BizAccountLinkInfo_HostStorageType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BizAccountLinkInfo_HostStorageType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + BizAccountLinkInfo_HostStorageType_descriptor(), name, value); +} +enum BizIdentityInfo_ActualActorsType : int { + BizIdentityInfo_ActualActorsType_SELF = 0, + BizIdentityInfo_ActualActorsType_BSP = 1 +}; +bool BizIdentityInfo_ActualActorsType_IsValid(int value); +constexpr BizIdentityInfo_ActualActorsType BizIdentityInfo_ActualActorsType_ActualActorsType_MIN = BizIdentityInfo_ActualActorsType_SELF; +constexpr BizIdentityInfo_ActualActorsType BizIdentityInfo_ActualActorsType_ActualActorsType_MAX = BizIdentityInfo_ActualActorsType_BSP; +constexpr int BizIdentityInfo_ActualActorsType_ActualActorsType_ARRAYSIZE = BizIdentityInfo_ActualActorsType_ActualActorsType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizIdentityInfo_ActualActorsType_descriptor(); +template +inline const std::string& BizIdentityInfo_ActualActorsType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function BizIdentityInfo_ActualActorsType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + BizIdentityInfo_ActualActorsType_descriptor(), enum_t_value); +} +inline bool BizIdentityInfo_ActualActorsType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BizIdentityInfo_ActualActorsType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + BizIdentityInfo_ActualActorsType_descriptor(), name, value); +} +enum BizIdentityInfo_HostStorageType : int { + BizIdentityInfo_HostStorageType_ON_PREMISE = 0, + BizIdentityInfo_HostStorageType_FACEBOOK = 1 +}; +bool BizIdentityInfo_HostStorageType_IsValid(int value); +constexpr BizIdentityInfo_HostStorageType BizIdentityInfo_HostStorageType_HostStorageType_MIN = BizIdentityInfo_HostStorageType_ON_PREMISE; +constexpr BizIdentityInfo_HostStorageType BizIdentityInfo_HostStorageType_HostStorageType_MAX = BizIdentityInfo_HostStorageType_FACEBOOK; +constexpr int BizIdentityInfo_HostStorageType_HostStorageType_ARRAYSIZE = BizIdentityInfo_HostStorageType_HostStorageType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizIdentityInfo_HostStorageType_descriptor(); +template +inline const std::string& BizIdentityInfo_HostStorageType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function BizIdentityInfo_HostStorageType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + BizIdentityInfo_HostStorageType_descriptor(), enum_t_value); +} +inline bool BizIdentityInfo_HostStorageType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BizIdentityInfo_HostStorageType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + BizIdentityInfo_HostStorageType_descriptor(), name, value); +} +enum BizIdentityInfo_VerifiedLevelValue : int { + BizIdentityInfo_VerifiedLevelValue_UNKNOWN = 0, + BizIdentityInfo_VerifiedLevelValue_LOW = 1, + BizIdentityInfo_VerifiedLevelValue_HIGH = 2 +}; +bool BizIdentityInfo_VerifiedLevelValue_IsValid(int value); +constexpr BizIdentityInfo_VerifiedLevelValue BizIdentityInfo_VerifiedLevelValue_VerifiedLevelValue_MIN = BizIdentityInfo_VerifiedLevelValue_UNKNOWN; +constexpr BizIdentityInfo_VerifiedLevelValue BizIdentityInfo_VerifiedLevelValue_VerifiedLevelValue_MAX = BizIdentityInfo_VerifiedLevelValue_HIGH; +constexpr int BizIdentityInfo_VerifiedLevelValue_VerifiedLevelValue_ARRAYSIZE = BizIdentityInfo_VerifiedLevelValue_VerifiedLevelValue_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizIdentityInfo_VerifiedLevelValue_descriptor(); +template +inline const std::string& BizIdentityInfo_VerifiedLevelValue_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function BizIdentityInfo_VerifiedLevelValue_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + BizIdentityInfo_VerifiedLevelValue_descriptor(), enum_t_value); +} +inline bool BizIdentityInfo_VerifiedLevelValue_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BizIdentityInfo_VerifiedLevelValue* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + BizIdentityInfo_VerifiedLevelValue_descriptor(), name, value); +} +enum ClientPayload_DNSSource_DNSResolutionMethod : int { + ClientPayload_DNSSource_DNSResolutionMethod_SYSTEM = 0, + ClientPayload_DNSSource_DNSResolutionMethod_GOOGLE = 1, + ClientPayload_DNSSource_DNSResolutionMethod_HARDCODED = 2, + ClientPayload_DNSSource_DNSResolutionMethod_OVERRIDE = 3, + ClientPayload_DNSSource_DNSResolutionMethod_FALLBACK = 4 +}; +bool ClientPayload_DNSSource_DNSResolutionMethod_IsValid(int value); +constexpr ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource_DNSResolutionMethod_DNSResolutionMethod_MIN = ClientPayload_DNSSource_DNSResolutionMethod_SYSTEM; +constexpr ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource_DNSResolutionMethod_DNSResolutionMethod_MAX = ClientPayload_DNSSource_DNSResolutionMethod_FALLBACK; +constexpr int ClientPayload_DNSSource_DNSResolutionMethod_DNSResolutionMethod_ARRAYSIZE = ClientPayload_DNSSource_DNSResolutionMethod_DNSResolutionMethod_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_DNSSource_DNSResolutionMethod_descriptor(); +template +inline const std::string& ClientPayload_DNSSource_DNSResolutionMethod_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ClientPayload_DNSSource_DNSResolutionMethod_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + ClientPayload_DNSSource_DNSResolutionMethod_descriptor(), enum_t_value); +} +inline bool ClientPayload_DNSSource_DNSResolutionMethod_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_DNSSource_DNSResolutionMethod* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + ClientPayload_DNSSource_DNSResolutionMethod_descriptor(), name, value); +} +enum ClientPayload_UserAgent_Platform : int { + ClientPayload_UserAgent_Platform_ANDROID = 0, + ClientPayload_UserAgent_Platform_IOS = 1, + ClientPayload_UserAgent_Platform_WINDOWS_PHONE = 2, + ClientPayload_UserAgent_Platform_BLACKBERRY = 3, + ClientPayload_UserAgent_Platform_BLACKBERRYX = 4, + ClientPayload_UserAgent_Platform_S40 = 5, + ClientPayload_UserAgent_Platform_S60 = 6, + ClientPayload_UserAgent_Platform_PYTHON_CLIENT = 7, + ClientPayload_UserAgent_Platform_TIZEN = 8, + ClientPayload_UserAgent_Platform_ENTERPRISE = 9, + ClientPayload_UserAgent_Platform_SMB_ANDROID = 10, + ClientPayload_UserAgent_Platform_KAIOS = 11, + ClientPayload_UserAgent_Platform_SMB_IOS = 12, + ClientPayload_UserAgent_Platform_WINDOWS = 13, + ClientPayload_UserAgent_Platform_WEB = 14, + ClientPayload_UserAgent_Platform_PORTAL = 15, + ClientPayload_UserAgent_Platform_GREEN_ANDROID = 16, + ClientPayload_UserAgent_Platform_GREEN_IPHONE = 17, + ClientPayload_UserAgent_Platform_BLUE_ANDROID = 18, + ClientPayload_UserAgent_Platform_BLUE_IPHONE = 19, + ClientPayload_UserAgent_Platform_FBLITE_ANDROID = 20, + ClientPayload_UserAgent_Platform_MLITE_ANDROID = 21, + ClientPayload_UserAgent_Platform_IGLITE_ANDROID = 22, + ClientPayload_UserAgent_Platform_PAGE = 23, + ClientPayload_UserAgent_Platform_MACOS = 24, + ClientPayload_UserAgent_Platform_OCULUS_MSG = 25, + ClientPayload_UserAgent_Platform_OCULUS_CALL = 26, + ClientPayload_UserAgent_Platform_MILAN = 27, + ClientPayload_UserAgent_Platform_CAPI = 28 +}; +bool ClientPayload_UserAgent_Platform_IsValid(int value); +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent_Platform_Platform_MIN = ClientPayload_UserAgent_Platform_ANDROID; +constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent_Platform_Platform_MAX = ClientPayload_UserAgent_Platform_CAPI; +constexpr int ClientPayload_UserAgent_Platform_Platform_ARRAYSIZE = ClientPayload_UserAgent_Platform_Platform_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_UserAgent_Platform_descriptor(); +template +inline const std::string& ClientPayload_UserAgent_Platform_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ClientPayload_UserAgent_Platform_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + ClientPayload_UserAgent_Platform_descriptor(), enum_t_value); +} +inline bool ClientPayload_UserAgent_Platform_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_UserAgent_Platform* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + ClientPayload_UserAgent_Platform_descriptor(), name, value); +} +enum ClientPayload_UserAgent_ReleaseChannel : int { + ClientPayload_UserAgent_ReleaseChannel_RELEASE = 0, + ClientPayload_UserAgent_ReleaseChannel_BETA = 1, + ClientPayload_UserAgent_ReleaseChannel_ALPHA = 2, + ClientPayload_UserAgent_ReleaseChannel_DEBUG = 3 +}; +bool ClientPayload_UserAgent_ReleaseChannel_IsValid(int value); +constexpr ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent_ReleaseChannel_ReleaseChannel_MIN = ClientPayload_UserAgent_ReleaseChannel_RELEASE; +constexpr ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent_ReleaseChannel_ReleaseChannel_MAX = ClientPayload_UserAgent_ReleaseChannel_DEBUG; +constexpr int ClientPayload_UserAgent_ReleaseChannel_ReleaseChannel_ARRAYSIZE = ClientPayload_UserAgent_ReleaseChannel_ReleaseChannel_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_UserAgent_ReleaseChannel_descriptor(); +template +inline const std::string& ClientPayload_UserAgent_ReleaseChannel_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ClientPayload_UserAgent_ReleaseChannel_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + ClientPayload_UserAgent_ReleaseChannel_descriptor(), enum_t_value); +} +inline bool ClientPayload_UserAgent_ReleaseChannel_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_UserAgent_ReleaseChannel* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + ClientPayload_UserAgent_ReleaseChannel_descriptor(), name, value); +} +enum ClientPayload_WebInfo_WebSubPlatform : int { + ClientPayload_WebInfo_WebSubPlatform_WEB_BROWSER = 0, + ClientPayload_WebInfo_WebSubPlatform_APP_STORE = 1, + ClientPayload_WebInfo_WebSubPlatform_WIN_STORE = 2, + ClientPayload_WebInfo_WebSubPlatform_DARWIN = 3, + ClientPayload_WebInfo_WebSubPlatform_WINDA = 4 +}; +bool ClientPayload_WebInfo_WebSubPlatform_IsValid(int value); +constexpr ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo_WebSubPlatform_WebSubPlatform_MIN = ClientPayload_WebInfo_WebSubPlatform_WEB_BROWSER; +constexpr ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo_WebSubPlatform_WebSubPlatform_MAX = ClientPayload_WebInfo_WebSubPlatform_WINDA; +constexpr int ClientPayload_WebInfo_WebSubPlatform_WebSubPlatform_ARRAYSIZE = ClientPayload_WebInfo_WebSubPlatform_WebSubPlatform_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_WebInfo_WebSubPlatform_descriptor(); +template +inline const std::string& ClientPayload_WebInfo_WebSubPlatform_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ClientPayload_WebInfo_WebSubPlatform_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + ClientPayload_WebInfo_WebSubPlatform_descriptor(), enum_t_value); +} +inline bool ClientPayload_WebInfo_WebSubPlatform_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_WebInfo_WebSubPlatform* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + ClientPayload_WebInfo_WebSubPlatform_descriptor(), name, value); +} +enum ClientPayload_ConnectReason : int { + ClientPayload_ConnectReason_PUSH = 0, + ClientPayload_ConnectReason_USER_ACTIVATED = 1, + ClientPayload_ConnectReason_SCHEDULED = 2, + ClientPayload_ConnectReason_ERROR_RECONNECT = 3, + ClientPayload_ConnectReason_NETWORK_SWITCH = 4, + ClientPayload_ConnectReason_PING_RECONNECT = 5 +}; +bool ClientPayload_ConnectReason_IsValid(int value); +constexpr ClientPayload_ConnectReason ClientPayload_ConnectReason_ConnectReason_MIN = ClientPayload_ConnectReason_PUSH; +constexpr ClientPayload_ConnectReason ClientPayload_ConnectReason_ConnectReason_MAX = ClientPayload_ConnectReason_PING_RECONNECT; +constexpr int ClientPayload_ConnectReason_ConnectReason_ARRAYSIZE = ClientPayload_ConnectReason_ConnectReason_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_ConnectReason_descriptor(); +template +inline const std::string& ClientPayload_ConnectReason_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ClientPayload_ConnectReason_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + ClientPayload_ConnectReason_descriptor(), enum_t_value); +} +inline bool ClientPayload_ConnectReason_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_ConnectReason* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + ClientPayload_ConnectReason_descriptor(), name, value); +} +enum ClientPayload_ConnectType : int { + ClientPayload_ConnectType_CELLULAR_UNKNOWN = 0, + ClientPayload_ConnectType_WIFI_UNKNOWN = 1, + ClientPayload_ConnectType_CELLULAR_EDGE = 100, + ClientPayload_ConnectType_CELLULAR_IDEN = 101, + ClientPayload_ConnectType_CELLULAR_UMTS = 102, + ClientPayload_ConnectType_CELLULAR_EVDO = 103, + ClientPayload_ConnectType_CELLULAR_GPRS = 104, + ClientPayload_ConnectType_CELLULAR_HSDPA = 105, + ClientPayload_ConnectType_CELLULAR_HSUPA = 106, + ClientPayload_ConnectType_CELLULAR_HSPA = 107, + ClientPayload_ConnectType_CELLULAR_CDMA = 108, + ClientPayload_ConnectType_CELLULAR_1XRTT = 109, + ClientPayload_ConnectType_CELLULAR_EHRPD = 110, + ClientPayload_ConnectType_CELLULAR_LTE = 111, + ClientPayload_ConnectType_CELLULAR_HSPAP = 112 +}; +bool ClientPayload_ConnectType_IsValid(int value); +constexpr ClientPayload_ConnectType ClientPayload_ConnectType_ConnectType_MIN = ClientPayload_ConnectType_CELLULAR_UNKNOWN; +constexpr ClientPayload_ConnectType ClientPayload_ConnectType_ConnectType_MAX = ClientPayload_ConnectType_CELLULAR_HSPAP; +constexpr int ClientPayload_ConnectType_ConnectType_ARRAYSIZE = ClientPayload_ConnectType_ConnectType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_ConnectType_descriptor(); +template +inline const std::string& ClientPayload_ConnectType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ClientPayload_ConnectType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + ClientPayload_ConnectType_descriptor(), enum_t_value); +} +inline bool ClientPayload_ConnectType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_ConnectType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + ClientPayload_ConnectType_descriptor(), name, value); +} +enum ClientPayload_IOSAppExtension : int { + ClientPayload_IOSAppExtension_SHARE_EXTENSION = 0, + ClientPayload_IOSAppExtension_SERVICE_EXTENSION = 1, + ClientPayload_IOSAppExtension_INTENTS_EXTENSION = 2 +}; +bool ClientPayload_IOSAppExtension_IsValid(int value); +constexpr ClientPayload_IOSAppExtension ClientPayload_IOSAppExtension_IOSAppExtension_MIN = ClientPayload_IOSAppExtension_SHARE_EXTENSION; +constexpr ClientPayload_IOSAppExtension ClientPayload_IOSAppExtension_IOSAppExtension_MAX = ClientPayload_IOSAppExtension_INTENTS_EXTENSION; +constexpr int ClientPayload_IOSAppExtension_IOSAppExtension_ARRAYSIZE = ClientPayload_IOSAppExtension_IOSAppExtension_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_IOSAppExtension_descriptor(); +template +inline const std::string& ClientPayload_IOSAppExtension_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ClientPayload_IOSAppExtension_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + ClientPayload_IOSAppExtension_descriptor(), enum_t_value); +} +inline bool ClientPayload_IOSAppExtension_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_IOSAppExtension* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + ClientPayload_IOSAppExtension_descriptor(), name, value); +} +enum ClientPayload_Product : int { + ClientPayload_Product_WHATSAPP = 0, + ClientPayload_Product_MESSENGER = 1 +}; +bool ClientPayload_Product_IsValid(int value); +constexpr ClientPayload_Product ClientPayload_Product_Product_MIN = ClientPayload_Product_WHATSAPP; +constexpr ClientPayload_Product ClientPayload_Product_Product_MAX = ClientPayload_Product_MESSENGER; +constexpr int ClientPayload_Product_Product_ARRAYSIZE = ClientPayload_Product_Product_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_Product_descriptor(); +template +inline const std::string& ClientPayload_Product_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ClientPayload_Product_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + ClientPayload_Product_descriptor(), enum_t_value); +} +inline bool ClientPayload_Product_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_Product* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + ClientPayload_Product_descriptor(), name, value); +} +enum ContextInfo_AdReplyInfo_MediaType : int { + ContextInfo_AdReplyInfo_MediaType_NONE = 0, + ContextInfo_AdReplyInfo_MediaType_IMAGE = 1, + ContextInfo_AdReplyInfo_MediaType_VIDEO = 2 +}; +bool ContextInfo_AdReplyInfo_MediaType_IsValid(int value); +constexpr ContextInfo_AdReplyInfo_MediaType ContextInfo_AdReplyInfo_MediaType_MediaType_MIN = ContextInfo_AdReplyInfo_MediaType_NONE; +constexpr ContextInfo_AdReplyInfo_MediaType ContextInfo_AdReplyInfo_MediaType_MediaType_MAX = ContextInfo_AdReplyInfo_MediaType_VIDEO; +constexpr int ContextInfo_AdReplyInfo_MediaType_MediaType_ARRAYSIZE = ContextInfo_AdReplyInfo_MediaType_MediaType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ContextInfo_AdReplyInfo_MediaType_descriptor(); +template +inline const std::string& ContextInfo_AdReplyInfo_MediaType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ContextInfo_AdReplyInfo_MediaType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + ContextInfo_AdReplyInfo_MediaType_descriptor(), enum_t_value); +} +inline bool ContextInfo_AdReplyInfo_MediaType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ContextInfo_AdReplyInfo_MediaType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + ContextInfo_AdReplyInfo_MediaType_descriptor(), name, value); +} +enum ContextInfo_ExternalAdReplyInfo_MediaType : int { + ContextInfo_ExternalAdReplyInfo_MediaType_NONE = 0, + ContextInfo_ExternalAdReplyInfo_MediaType_IMAGE = 1, + ContextInfo_ExternalAdReplyInfo_MediaType_VIDEO = 2 +}; +bool ContextInfo_ExternalAdReplyInfo_MediaType_IsValid(int value); +constexpr ContextInfo_ExternalAdReplyInfo_MediaType ContextInfo_ExternalAdReplyInfo_MediaType_MediaType_MIN = ContextInfo_ExternalAdReplyInfo_MediaType_NONE; +constexpr ContextInfo_ExternalAdReplyInfo_MediaType ContextInfo_ExternalAdReplyInfo_MediaType_MediaType_MAX = ContextInfo_ExternalAdReplyInfo_MediaType_VIDEO; +constexpr int ContextInfo_ExternalAdReplyInfo_MediaType_MediaType_ARRAYSIZE = ContextInfo_ExternalAdReplyInfo_MediaType_MediaType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ContextInfo_ExternalAdReplyInfo_MediaType_descriptor(); +template +inline const std::string& ContextInfo_ExternalAdReplyInfo_MediaType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ContextInfo_ExternalAdReplyInfo_MediaType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + ContextInfo_ExternalAdReplyInfo_MediaType_descriptor(), enum_t_value); +} +inline bool ContextInfo_ExternalAdReplyInfo_MediaType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ContextInfo_ExternalAdReplyInfo_MediaType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + ContextInfo_ExternalAdReplyInfo_MediaType_descriptor(), name, value); +} +enum Conversation_EndOfHistoryTransferType : int { + Conversation_EndOfHistoryTransferType_COMPLETE_BUT_MORE_MESSAGES_REMAIN_ON_PRIMARY = 0, + Conversation_EndOfHistoryTransferType_COMPLETE_AND_NO_MORE_MESSAGE_REMAIN_ON_PRIMARY = 1 +}; +bool Conversation_EndOfHistoryTransferType_IsValid(int value); +constexpr Conversation_EndOfHistoryTransferType Conversation_EndOfHistoryTransferType_EndOfHistoryTransferType_MIN = Conversation_EndOfHistoryTransferType_COMPLETE_BUT_MORE_MESSAGES_REMAIN_ON_PRIMARY; +constexpr Conversation_EndOfHistoryTransferType Conversation_EndOfHistoryTransferType_EndOfHistoryTransferType_MAX = Conversation_EndOfHistoryTransferType_COMPLETE_AND_NO_MORE_MESSAGE_REMAIN_ON_PRIMARY; +constexpr int Conversation_EndOfHistoryTransferType_EndOfHistoryTransferType_ARRAYSIZE = Conversation_EndOfHistoryTransferType_EndOfHistoryTransferType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Conversation_EndOfHistoryTransferType_descriptor(); +template +inline const std::string& Conversation_EndOfHistoryTransferType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Conversation_EndOfHistoryTransferType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Conversation_EndOfHistoryTransferType_descriptor(), enum_t_value); +} +inline bool Conversation_EndOfHistoryTransferType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Conversation_EndOfHistoryTransferType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Conversation_EndOfHistoryTransferType_descriptor(), name, value); +} +enum DeviceProps_PlatformType : int { + DeviceProps_PlatformType_UNKNOWN = 0, + DeviceProps_PlatformType_CHROME = 1, + DeviceProps_PlatformType_FIREFOX = 2, + DeviceProps_PlatformType_IE = 3, + DeviceProps_PlatformType_OPERA = 4, + DeviceProps_PlatformType_SAFARI = 5, + DeviceProps_PlatformType_EDGE = 6, + DeviceProps_PlatformType_DESKTOP = 7, + DeviceProps_PlatformType_IPAD = 8, + DeviceProps_PlatformType_ANDROID_TABLET = 9, + DeviceProps_PlatformType_OHANA = 10, + DeviceProps_PlatformType_ALOHA = 11, + DeviceProps_PlatformType_CATALINA = 12, + DeviceProps_PlatformType_TCL_TV = 13 +}; +bool DeviceProps_PlatformType_IsValid(int value); +constexpr DeviceProps_PlatformType DeviceProps_PlatformType_PlatformType_MIN = DeviceProps_PlatformType_UNKNOWN; +constexpr DeviceProps_PlatformType DeviceProps_PlatformType_PlatformType_MAX = DeviceProps_PlatformType_TCL_TV; +constexpr int DeviceProps_PlatformType_PlatformType_ARRAYSIZE = DeviceProps_PlatformType_PlatformType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceProps_PlatformType_descriptor(); +template +inline const std::string& DeviceProps_PlatformType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function DeviceProps_PlatformType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + DeviceProps_PlatformType_descriptor(), enum_t_value); +} +inline bool DeviceProps_PlatformType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceProps_PlatformType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + DeviceProps_PlatformType_descriptor(), name, value); +} +enum DisappearingMode_Initiator : int { + DisappearingMode_Initiator_CHANGED_IN_CHAT = 0, + DisappearingMode_Initiator_INITIATED_BY_ME = 1, + DisappearingMode_Initiator_INITIATED_BY_OTHER = 2 +}; +bool DisappearingMode_Initiator_IsValid(int value); +constexpr DisappearingMode_Initiator DisappearingMode_Initiator_Initiator_MIN = DisappearingMode_Initiator_CHANGED_IN_CHAT; +constexpr DisappearingMode_Initiator DisappearingMode_Initiator_Initiator_MAX = DisappearingMode_Initiator_INITIATED_BY_OTHER; +constexpr int DisappearingMode_Initiator_Initiator_ARRAYSIZE = DisappearingMode_Initiator_Initiator_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DisappearingMode_Initiator_descriptor(); +template +inline const std::string& DisappearingMode_Initiator_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function DisappearingMode_Initiator_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + DisappearingMode_Initiator_descriptor(), enum_t_value); +} +inline bool DisappearingMode_Initiator_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DisappearingMode_Initiator* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + DisappearingMode_Initiator_descriptor(), name, value); +} +enum GroupParticipant_Rank : int { + GroupParticipant_Rank_REGULAR = 0, + GroupParticipant_Rank_ADMIN = 1, + GroupParticipant_Rank_SUPERADMIN = 2 +}; +bool GroupParticipant_Rank_IsValid(int value); +constexpr GroupParticipant_Rank GroupParticipant_Rank_Rank_MIN = GroupParticipant_Rank_REGULAR; +constexpr GroupParticipant_Rank GroupParticipant_Rank_Rank_MAX = GroupParticipant_Rank_SUPERADMIN; +constexpr int GroupParticipant_Rank_Rank_ARRAYSIZE = GroupParticipant_Rank_Rank_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* GroupParticipant_Rank_descriptor(); +template +inline const std::string& GroupParticipant_Rank_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function GroupParticipant_Rank_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + GroupParticipant_Rank_descriptor(), enum_t_value); +} +inline bool GroupParticipant_Rank_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, GroupParticipant_Rank* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + GroupParticipant_Rank_descriptor(), name, value); +} +enum HistorySync_HistorySyncType : int { + HistorySync_HistorySyncType_INITIAL_BOOTSTRAP = 0, + HistorySync_HistorySyncType_INITIAL_STATUS_V3 = 1, + HistorySync_HistorySyncType_FULL = 2, + HistorySync_HistorySyncType_RECENT = 3, + HistorySync_HistorySyncType_PUSH_NAME = 4, + HistorySync_HistorySyncType_UNBLOCKING_DATA = 5 +}; +bool HistorySync_HistorySyncType_IsValid(int value); +constexpr HistorySync_HistorySyncType HistorySync_HistorySyncType_HistorySyncType_MIN = HistorySync_HistorySyncType_INITIAL_BOOTSTRAP; +constexpr HistorySync_HistorySyncType HistorySync_HistorySyncType_HistorySyncType_MAX = HistorySync_HistorySyncType_UNBLOCKING_DATA; +constexpr int HistorySync_HistorySyncType_HistorySyncType_ARRAYSIZE = HistorySync_HistorySyncType_HistorySyncType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HistorySync_HistorySyncType_descriptor(); +template +inline const std::string& HistorySync_HistorySyncType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function HistorySync_HistorySyncType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + HistorySync_HistorySyncType_descriptor(), enum_t_value); +} +inline bool HistorySync_HistorySyncType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, HistorySync_HistorySyncType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + HistorySync_HistorySyncType_descriptor(), name, value); +} +enum MediaRetryNotification_ResultType : int { + MediaRetryNotification_ResultType_GENERAL_ERROR = 0, + MediaRetryNotification_ResultType_SUCCESS = 1, + MediaRetryNotification_ResultType_NOT_FOUND = 2, + MediaRetryNotification_ResultType_DECRYPTION_ERROR = 3 +}; +bool MediaRetryNotification_ResultType_IsValid(int value); +constexpr MediaRetryNotification_ResultType MediaRetryNotification_ResultType_ResultType_MIN = MediaRetryNotification_ResultType_GENERAL_ERROR; +constexpr MediaRetryNotification_ResultType MediaRetryNotification_ResultType_ResultType_MAX = MediaRetryNotification_ResultType_DECRYPTION_ERROR; +constexpr int MediaRetryNotification_ResultType_ResultType_ARRAYSIZE = MediaRetryNotification_ResultType_ResultType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MediaRetryNotification_ResultType_descriptor(); +template +inline const std::string& MediaRetryNotification_ResultType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function MediaRetryNotification_ResultType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + MediaRetryNotification_ResultType_descriptor(), enum_t_value); +} +inline bool MediaRetryNotification_ResultType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MediaRetryNotification_ResultType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + MediaRetryNotification_ResultType_descriptor(), name, value); +} +enum Message_ButtonsMessage_Button_Type : int { + Message_ButtonsMessage_Button_Type_UNKNOWN = 0, + Message_ButtonsMessage_Button_Type_RESPONSE = 1, + Message_ButtonsMessage_Button_Type_NATIVE_FLOW = 2 +}; +bool Message_ButtonsMessage_Button_Type_IsValid(int value); +constexpr Message_ButtonsMessage_Button_Type Message_ButtonsMessage_Button_Type_Type_MIN = Message_ButtonsMessage_Button_Type_UNKNOWN; +constexpr Message_ButtonsMessage_Button_Type Message_ButtonsMessage_Button_Type_Type_MAX = Message_ButtonsMessage_Button_Type_NATIVE_FLOW; +constexpr int Message_ButtonsMessage_Button_Type_Type_ARRAYSIZE = Message_ButtonsMessage_Button_Type_Type_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ButtonsMessage_Button_Type_descriptor(); +template +inline const std::string& Message_ButtonsMessage_Button_Type_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Message_ButtonsMessage_Button_Type_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Message_ButtonsMessage_Button_Type_descriptor(), enum_t_value); +} +inline bool Message_ButtonsMessage_Button_Type_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ButtonsMessage_Button_Type* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Message_ButtonsMessage_Button_Type_descriptor(), name, value); +} +enum Message_ButtonsMessage_HeaderType : int { + Message_ButtonsMessage_HeaderType_UNKNOWN = 0, + Message_ButtonsMessage_HeaderType_EMPTY = 1, + Message_ButtonsMessage_HeaderType_TEXT = 2, + Message_ButtonsMessage_HeaderType_DOCUMENT = 3, + Message_ButtonsMessage_HeaderType_IMAGE = 4, + Message_ButtonsMessage_HeaderType_VIDEO = 5, + Message_ButtonsMessage_HeaderType_LOCATION = 6 +}; +bool Message_ButtonsMessage_HeaderType_IsValid(int value); +constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage_HeaderType_HeaderType_MIN = Message_ButtonsMessage_HeaderType_UNKNOWN; +constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage_HeaderType_HeaderType_MAX = Message_ButtonsMessage_HeaderType_LOCATION; +constexpr int Message_ButtonsMessage_HeaderType_HeaderType_ARRAYSIZE = Message_ButtonsMessage_HeaderType_HeaderType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ButtonsMessage_HeaderType_descriptor(); +template +inline const std::string& Message_ButtonsMessage_HeaderType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Message_ButtonsMessage_HeaderType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Message_ButtonsMessage_HeaderType_descriptor(), enum_t_value); +} +inline bool Message_ButtonsMessage_HeaderType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ButtonsMessage_HeaderType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Message_ButtonsMessage_HeaderType_descriptor(), name, value); +} +enum Message_ButtonsResponseMessage_Type : int { + Message_ButtonsResponseMessage_Type_UNKNOWN = 0, + Message_ButtonsResponseMessage_Type_DISPLAY_TEXT = 1 +}; +bool Message_ButtonsResponseMessage_Type_IsValid(int value); +constexpr Message_ButtonsResponseMessage_Type Message_ButtonsResponseMessage_Type_Type_MIN = Message_ButtonsResponseMessage_Type_UNKNOWN; +constexpr Message_ButtonsResponseMessage_Type Message_ButtonsResponseMessage_Type_Type_MAX = Message_ButtonsResponseMessage_Type_DISPLAY_TEXT; +constexpr int Message_ButtonsResponseMessage_Type_Type_ARRAYSIZE = Message_ButtonsResponseMessage_Type_Type_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ButtonsResponseMessage_Type_descriptor(); +template +inline const std::string& Message_ButtonsResponseMessage_Type_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Message_ButtonsResponseMessage_Type_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Message_ButtonsResponseMessage_Type_descriptor(), enum_t_value); +} +inline bool Message_ButtonsResponseMessage_Type_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ButtonsResponseMessage_Type* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Message_ButtonsResponseMessage_Type_descriptor(), name, value); +} +enum Message_ExtendedTextMessage_FontType : int { + Message_ExtendedTextMessage_FontType_SANS_SERIF = 0, + Message_ExtendedTextMessage_FontType_SERIF = 1, + Message_ExtendedTextMessage_FontType_NORICAN_REGULAR = 2, + Message_ExtendedTextMessage_FontType_BRYNDAN_WRITE = 3, + Message_ExtendedTextMessage_FontType_BEBASNEUE_REGULAR = 4, + Message_ExtendedTextMessage_FontType_OSWALD_HEAVY = 5 +}; +bool Message_ExtendedTextMessage_FontType_IsValid(int value); +constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage_FontType_FontType_MIN = Message_ExtendedTextMessage_FontType_SANS_SERIF; +constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage_FontType_FontType_MAX = Message_ExtendedTextMessage_FontType_OSWALD_HEAVY; +constexpr int Message_ExtendedTextMessage_FontType_FontType_ARRAYSIZE = Message_ExtendedTextMessage_FontType_FontType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ExtendedTextMessage_FontType_descriptor(); +template +inline const std::string& Message_ExtendedTextMessage_FontType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Message_ExtendedTextMessage_FontType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Message_ExtendedTextMessage_FontType_descriptor(), enum_t_value); +} +inline bool Message_ExtendedTextMessage_FontType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ExtendedTextMessage_FontType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Message_ExtendedTextMessage_FontType_descriptor(), name, value); +} +enum Message_ExtendedTextMessage_InviteLinkGroupType : int { + Message_ExtendedTextMessage_InviteLinkGroupType_DEFAULT = 0, + Message_ExtendedTextMessage_InviteLinkGroupType_PARENT = 1, + Message_ExtendedTextMessage_InviteLinkGroupType_SUB = 2, + Message_ExtendedTextMessage_InviteLinkGroupType_DEFAULT_SUB = 3 +}; +bool Message_ExtendedTextMessage_InviteLinkGroupType_IsValid(int value); +constexpr Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage_InviteLinkGroupType_InviteLinkGroupType_MIN = Message_ExtendedTextMessage_InviteLinkGroupType_DEFAULT; +constexpr Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage_InviteLinkGroupType_InviteLinkGroupType_MAX = Message_ExtendedTextMessage_InviteLinkGroupType_DEFAULT_SUB; +constexpr int Message_ExtendedTextMessage_InviteLinkGroupType_InviteLinkGroupType_ARRAYSIZE = Message_ExtendedTextMessage_InviteLinkGroupType_InviteLinkGroupType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ExtendedTextMessage_InviteLinkGroupType_descriptor(); +template +inline const std::string& Message_ExtendedTextMessage_InviteLinkGroupType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Message_ExtendedTextMessage_InviteLinkGroupType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Message_ExtendedTextMessage_InviteLinkGroupType_descriptor(), enum_t_value); +} +inline bool Message_ExtendedTextMessage_InviteLinkGroupType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ExtendedTextMessage_InviteLinkGroupType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Message_ExtendedTextMessage_InviteLinkGroupType_descriptor(), name, value); +} +enum Message_ExtendedTextMessage_PreviewType : int { + Message_ExtendedTextMessage_PreviewType_NONE = 0, + Message_ExtendedTextMessage_PreviewType_VIDEO = 1 +}; +bool Message_ExtendedTextMessage_PreviewType_IsValid(int value); +constexpr Message_ExtendedTextMessage_PreviewType Message_ExtendedTextMessage_PreviewType_PreviewType_MIN = Message_ExtendedTextMessage_PreviewType_NONE; +constexpr Message_ExtendedTextMessage_PreviewType Message_ExtendedTextMessage_PreviewType_PreviewType_MAX = Message_ExtendedTextMessage_PreviewType_VIDEO; +constexpr int Message_ExtendedTextMessage_PreviewType_PreviewType_ARRAYSIZE = Message_ExtendedTextMessage_PreviewType_PreviewType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ExtendedTextMessage_PreviewType_descriptor(); +template +inline const std::string& Message_ExtendedTextMessage_PreviewType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Message_ExtendedTextMessage_PreviewType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Message_ExtendedTextMessage_PreviewType_descriptor(), enum_t_value); +} +inline bool Message_ExtendedTextMessage_PreviewType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ExtendedTextMessage_PreviewType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Message_ExtendedTextMessage_PreviewType_descriptor(), name, value); +} +enum Message_GroupInviteMessage_GroupType : int { + Message_GroupInviteMessage_GroupType_DEFAULT = 0, + Message_GroupInviteMessage_GroupType_PARENT = 1 +}; +bool Message_GroupInviteMessage_GroupType_IsValid(int value); +constexpr Message_GroupInviteMessage_GroupType Message_GroupInviteMessage_GroupType_GroupType_MIN = Message_GroupInviteMessage_GroupType_DEFAULT; +constexpr Message_GroupInviteMessage_GroupType Message_GroupInviteMessage_GroupType_GroupType_MAX = Message_GroupInviteMessage_GroupType_PARENT; +constexpr int Message_GroupInviteMessage_GroupType_GroupType_ARRAYSIZE = Message_GroupInviteMessage_GroupType_GroupType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_GroupInviteMessage_GroupType_descriptor(); +template +inline const std::string& Message_GroupInviteMessage_GroupType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Message_GroupInviteMessage_GroupType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Message_GroupInviteMessage_GroupType_descriptor(), enum_t_value); +} +inline bool Message_GroupInviteMessage_GroupType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_GroupInviteMessage_GroupType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Message_GroupInviteMessage_GroupType_descriptor(), name, value); +} +enum Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType : int { + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_GREGORIAN = 1, + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_SOLAR_HIJRI = 2 +}; +bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_IsValid(int value); +constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_CalendarType_MIN = Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_GREGORIAN; +constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_CalendarType_MAX = Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_SOLAR_HIJRI; +constexpr int Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_CalendarType_ARRAYSIZE = Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_CalendarType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_descriptor(); +template +inline const std::string& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_descriptor(), enum_t_value); +} +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_descriptor(), name, value); +} +enum Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType : int { + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_MONDAY = 1, + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_TUESDAY = 2, + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_WEDNESDAY = 3, + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_THURSDAY = 4, + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_FRIDAY = 5, + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_SATURDAY = 6, + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_SUNDAY = 7 +}; +bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_IsValid(int value); +constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_DayOfWeekType_MIN = Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_MONDAY; +constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_DayOfWeekType_MAX = Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_SUNDAY; +constexpr int Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_DayOfWeekType_ARRAYSIZE = Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_DayOfWeekType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_descriptor(); +template +inline const std::string& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_descriptor(), enum_t_value); +} +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_descriptor(), name, value); +} +enum Message_HistorySyncNotification_HistorySyncType : int { + Message_HistorySyncNotification_HistorySyncType_INITIAL_BOOTSTRAP = 0, + Message_HistorySyncNotification_HistorySyncType_INITIAL_STATUS_V3 = 1, + Message_HistorySyncNotification_HistorySyncType_FULL = 2, + Message_HistorySyncNotification_HistorySyncType_RECENT = 3, + Message_HistorySyncNotification_HistorySyncType_PUSH_NAME = 4 +}; +bool Message_HistorySyncNotification_HistorySyncType_IsValid(int value); +constexpr Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification_HistorySyncType_HistorySyncType_MIN = Message_HistorySyncNotification_HistorySyncType_INITIAL_BOOTSTRAP; +constexpr Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification_HistorySyncType_HistorySyncType_MAX = Message_HistorySyncNotification_HistorySyncType_PUSH_NAME; +constexpr int Message_HistorySyncNotification_HistorySyncType_HistorySyncType_ARRAYSIZE = Message_HistorySyncNotification_HistorySyncType_HistorySyncType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_HistorySyncNotification_HistorySyncType_descriptor(); +template +inline const std::string& Message_HistorySyncNotification_HistorySyncType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Message_HistorySyncNotification_HistorySyncType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Message_HistorySyncNotification_HistorySyncType_descriptor(), enum_t_value); +} +inline bool Message_HistorySyncNotification_HistorySyncType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_HistorySyncNotification_HistorySyncType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Message_HistorySyncNotification_HistorySyncType_descriptor(), name, value); +} +enum Message_InteractiveMessage_ShopMessage_Surface : int { + Message_InteractiveMessage_ShopMessage_Surface_UNKNOWN_SURFACE = 0, + Message_InteractiveMessage_ShopMessage_Surface_FB = 1, + Message_InteractiveMessage_ShopMessage_Surface_IG = 2, + Message_InteractiveMessage_ShopMessage_Surface_WA = 3 +}; +bool Message_InteractiveMessage_ShopMessage_Surface_IsValid(int value); +constexpr Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage_Surface_Surface_MIN = Message_InteractiveMessage_ShopMessage_Surface_UNKNOWN_SURFACE; +constexpr Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage_Surface_Surface_MAX = Message_InteractiveMessage_ShopMessage_Surface_WA; +constexpr int Message_InteractiveMessage_ShopMessage_Surface_Surface_ARRAYSIZE = Message_InteractiveMessage_ShopMessage_Surface_Surface_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_InteractiveMessage_ShopMessage_Surface_descriptor(); +template +inline const std::string& Message_InteractiveMessage_ShopMessage_Surface_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Message_InteractiveMessage_ShopMessage_Surface_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Message_InteractiveMessage_ShopMessage_Surface_descriptor(), enum_t_value); +} +inline bool Message_InteractiveMessage_ShopMessage_Surface_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_InteractiveMessage_ShopMessage_Surface* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Message_InteractiveMessage_ShopMessage_Surface_descriptor(), name, value); +} +enum Message_InvoiceMessage_AttachmentType : int { + Message_InvoiceMessage_AttachmentType_IMAGE = 0, + Message_InvoiceMessage_AttachmentType_PDF = 1 +}; +bool Message_InvoiceMessage_AttachmentType_IsValid(int value); +constexpr Message_InvoiceMessage_AttachmentType Message_InvoiceMessage_AttachmentType_AttachmentType_MIN = Message_InvoiceMessage_AttachmentType_IMAGE; +constexpr Message_InvoiceMessage_AttachmentType Message_InvoiceMessage_AttachmentType_AttachmentType_MAX = Message_InvoiceMessage_AttachmentType_PDF; +constexpr int Message_InvoiceMessage_AttachmentType_AttachmentType_ARRAYSIZE = Message_InvoiceMessage_AttachmentType_AttachmentType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_InvoiceMessage_AttachmentType_descriptor(); +template +inline const std::string& Message_InvoiceMessage_AttachmentType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Message_InvoiceMessage_AttachmentType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Message_InvoiceMessage_AttachmentType_descriptor(), enum_t_value); +} +inline bool Message_InvoiceMessage_AttachmentType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_InvoiceMessage_AttachmentType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Message_InvoiceMessage_AttachmentType_descriptor(), name, value); +} +enum Message_ListMessage_ListType : int { + Message_ListMessage_ListType_UNKNOWN = 0, + Message_ListMessage_ListType_SINGLE_SELECT = 1, + Message_ListMessage_ListType_PRODUCT_LIST = 2 +}; +bool Message_ListMessage_ListType_IsValid(int value); +constexpr Message_ListMessage_ListType Message_ListMessage_ListType_ListType_MIN = Message_ListMessage_ListType_UNKNOWN; +constexpr Message_ListMessage_ListType Message_ListMessage_ListType_ListType_MAX = Message_ListMessage_ListType_PRODUCT_LIST; +constexpr int Message_ListMessage_ListType_ListType_ARRAYSIZE = Message_ListMessage_ListType_ListType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ListMessage_ListType_descriptor(); +template +inline const std::string& Message_ListMessage_ListType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Message_ListMessage_ListType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Message_ListMessage_ListType_descriptor(), enum_t_value); +} +inline bool Message_ListMessage_ListType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ListMessage_ListType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Message_ListMessage_ListType_descriptor(), name, value); +} +enum Message_ListResponseMessage_ListType : int { + Message_ListResponseMessage_ListType_UNKNOWN = 0, + Message_ListResponseMessage_ListType_SINGLE_SELECT = 1 +}; +bool Message_ListResponseMessage_ListType_IsValid(int value); +constexpr Message_ListResponseMessage_ListType Message_ListResponseMessage_ListType_ListType_MIN = Message_ListResponseMessage_ListType_UNKNOWN; +constexpr Message_ListResponseMessage_ListType Message_ListResponseMessage_ListType_ListType_MAX = Message_ListResponseMessage_ListType_SINGLE_SELECT; +constexpr int Message_ListResponseMessage_ListType_ListType_ARRAYSIZE = Message_ListResponseMessage_ListType_ListType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ListResponseMessage_ListType_descriptor(); +template +inline const std::string& Message_ListResponseMessage_ListType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Message_ListResponseMessage_ListType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Message_ListResponseMessage_ListType_descriptor(), enum_t_value); +} +inline bool Message_ListResponseMessage_ListType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ListResponseMessage_ListType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Message_ListResponseMessage_ListType_descriptor(), name, value); +} +enum Message_OrderMessage_OrderStatus : int { + Message_OrderMessage_OrderStatus_INQUIRY = 1 +}; +bool Message_OrderMessage_OrderStatus_IsValid(int value); +constexpr Message_OrderMessage_OrderStatus Message_OrderMessage_OrderStatus_OrderStatus_MIN = Message_OrderMessage_OrderStatus_INQUIRY; +constexpr Message_OrderMessage_OrderStatus Message_OrderMessage_OrderStatus_OrderStatus_MAX = Message_OrderMessage_OrderStatus_INQUIRY; +constexpr int Message_OrderMessage_OrderStatus_OrderStatus_ARRAYSIZE = Message_OrderMessage_OrderStatus_OrderStatus_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_OrderMessage_OrderStatus_descriptor(); +template +inline const std::string& Message_OrderMessage_OrderStatus_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Message_OrderMessage_OrderStatus_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Message_OrderMessage_OrderStatus_descriptor(), enum_t_value); +} +inline bool Message_OrderMessage_OrderStatus_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_OrderMessage_OrderStatus* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Message_OrderMessage_OrderStatus_descriptor(), name, value); +} +enum Message_OrderMessage_OrderSurface : int { + Message_OrderMessage_OrderSurface_CATALOG = 1 +}; +bool Message_OrderMessage_OrderSurface_IsValid(int value); +constexpr Message_OrderMessage_OrderSurface Message_OrderMessage_OrderSurface_OrderSurface_MIN = Message_OrderMessage_OrderSurface_CATALOG; +constexpr Message_OrderMessage_OrderSurface Message_OrderMessage_OrderSurface_OrderSurface_MAX = Message_OrderMessage_OrderSurface_CATALOG; +constexpr int Message_OrderMessage_OrderSurface_OrderSurface_ARRAYSIZE = Message_OrderMessage_OrderSurface_OrderSurface_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_OrderMessage_OrderSurface_descriptor(); +template +inline const std::string& Message_OrderMessage_OrderSurface_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Message_OrderMessage_OrderSurface_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Message_OrderMessage_OrderSurface_descriptor(), enum_t_value); +} +inline bool Message_OrderMessage_OrderSurface_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_OrderMessage_OrderSurface* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Message_OrderMessage_OrderSurface_descriptor(), name, value); +} +enum Message_PaymentInviteMessage_ServiceType : int { + Message_PaymentInviteMessage_ServiceType_UNKNOWN = 0, + Message_PaymentInviteMessage_ServiceType_FBPAY = 1, + Message_PaymentInviteMessage_ServiceType_NOVI = 2, + Message_PaymentInviteMessage_ServiceType_UPI = 3 +}; +bool Message_PaymentInviteMessage_ServiceType_IsValid(int value); +constexpr Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage_ServiceType_ServiceType_MIN = Message_PaymentInviteMessage_ServiceType_UNKNOWN; +constexpr Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage_ServiceType_ServiceType_MAX = Message_PaymentInviteMessage_ServiceType_UPI; +constexpr int Message_PaymentInviteMessage_ServiceType_ServiceType_ARRAYSIZE = Message_PaymentInviteMessage_ServiceType_ServiceType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_PaymentInviteMessage_ServiceType_descriptor(); +template +inline const std::string& Message_PaymentInviteMessage_ServiceType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Message_PaymentInviteMessage_ServiceType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Message_PaymentInviteMessage_ServiceType_descriptor(), enum_t_value); +} +inline bool Message_PaymentInviteMessage_ServiceType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_PaymentInviteMessage_ServiceType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Message_PaymentInviteMessage_ServiceType_descriptor(), name, value); +} +enum Message_ProtocolMessage_Type : int { + Message_ProtocolMessage_Type_REVOKE = 0, + Message_ProtocolMessage_Type_EPHEMERAL_SETTING = 3, + Message_ProtocolMessage_Type_EPHEMERAL_SYNC_RESPONSE = 4, + Message_ProtocolMessage_Type_HISTORY_SYNC_NOTIFICATION = 5, + Message_ProtocolMessage_Type_APP_STATE_SYNC_KEY_SHARE = 6, + Message_ProtocolMessage_Type_APP_STATE_SYNC_KEY_REQUEST = 7, + Message_ProtocolMessage_Type_MSG_FANOUT_BACKFILL_REQUEST = 8, + Message_ProtocolMessage_Type_INITIAL_SECURITY_NOTIFICATION_SETTING_SYNC = 9, + Message_ProtocolMessage_Type_APP_STATE_FATAL_EXCEPTION_NOTIFICATION = 10, + Message_ProtocolMessage_Type_SHARE_PHONE_NUMBER = 11, + Message_ProtocolMessage_Type_REQUEST_MEDIA_UPLOAD_MESSAGE = 12, + Message_ProtocolMessage_Type_REQUEST_MEDIA_UPLOAD_RESPONSE_MESSAGE = 13 +}; +bool Message_ProtocolMessage_Type_IsValid(int value); +constexpr Message_ProtocolMessage_Type Message_ProtocolMessage_Type_Type_MIN = Message_ProtocolMessage_Type_REVOKE; +constexpr Message_ProtocolMessage_Type Message_ProtocolMessage_Type_Type_MAX = Message_ProtocolMessage_Type_REQUEST_MEDIA_UPLOAD_RESPONSE_MESSAGE; +constexpr int Message_ProtocolMessage_Type_Type_ARRAYSIZE = Message_ProtocolMessage_Type_Type_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ProtocolMessage_Type_descriptor(); +template +inline const std::string& Message_ProtocolMessage_Type_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Message_ProtocolMessage_Type_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Message_ProtocolMessage_Type_descriptor(), enum_t_value); +} +inline bool Message_ProtocolMessage_Type_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ProtocolMessage_Type* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Message_ProtocolMessage_Type_descriptor(), name, value); +} +enum Message_VideoMessage_Attribution : int { + Message_VideoMessage_Attribution_NONE = 0, + Message_VideoMessage_Attribution_GIPHY = 1, + Message_VideoMessage_Attribution_TENOR = 2 +}; +bool Message_VideoMessage_Attribution_IsValid(int value); +constexpr Message_VideoMessage_Attribution Message_VideoMessage_Attribution_Attribution_MIN = Message_VideoMessage_Attribution_NONE; +constexpr Message_VideoMessage_Attribution Message_VideoMessage_Attribution_Attribution_MAX = Message_VideoMessage_Attribution_TENOR; +constexpr int Message_VideoMessage_Attribution_Attribution_ARRAYSIZE = Message_VideoMessage_Attribution_Attribution_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_VideoMessage_Attribution_descriptor(); +template +inline const std::string& Message_VideoMessage_Attribution_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Message_VideoMessage_Attribution_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Message_VideoMessage_Attribution_descriptor(), enum_t_value); +} +inline bool Message_VideoMessage_Attribution_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_VideoMessage_Attribution* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Message_VideoMessage_Attribution_descriptor(), name, value); +} +enum Message_RmrSource : int { + Message_RmrSource_FAVORITE_STICKER = 0, + Message_RmrSource_RECENT_STICKER = 1 +}; +bool Message_RmrSource_IsValid(int value); +constexpr Message_RmrSource Message_RmrSource_RmrSource_MIN = Message_RmrSource_FAVORITE_STICKER; +constexpr Message_RmrSource Message_RmrSource_RmrSource_MAX = Message_RmrSource_RECENT_STICKER; +constexpr int Message_RmrSource_RmrSource_ARRAYSIZE = Message_RmrSource_RmrSource_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_RmrSource_descriptor(); +template +inline const std::string& Message_RmrSource_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Message_RmrSource_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Message_RmrSource_descriptor(), enum_t_value); +} +inline bool Message_RmrSource_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_RmrSource* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Message_RmrSource_descriptor(), name, value); +} +enum PastParticipant_LeaveReason : int { + PastParticipant_LeaveReason_LEFT = 0, + PastParticipant_LeaveReason_REMOVED = 1 +}; +bool PastParticipant_LeaveReason_IsValid(int value); +constexpr PastParticipant_LeaveReason PastParticipant_LeaveReason_LeaveReason_MIN = PastParticipant_LeaveReason_LEFT; +constexpr PastParticipant_LeaveReason PastParticipant_LeaveReason_LeaveReason_MAX = PastParticipant_LeaveReason_REMOVED; +constexpr int PastParticipant_LeaveReason_LeaveReason_ARRAYSIZE = PastParticipant_LeaveReason_LeaveReason_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PastParticipant_LeaveReason_descriptor(); +template +inline const std::string& PastParticipant_LeaveReason_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function PastParticipant_LeaveReason_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + PastParticipant_LeaveReason_descriptor(), enum_t_value); +} +inline bool PastParticipant_LeaveReason_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PastParticipant_LeaveReason* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + PastParticipant_LeaveReason_descriptor(), name, value); +} +enum PaymentBackground_Type : int { + PaymentBackground_Type_UNKNOWN = 0, + PaymentBackground_Type_DEFAULT = 1 +}; +bool PaymentBackground_Type_IsValid(int value); +constexpr PaymentBackground_Type PaymentBackground_Type_Type_MIN = PaymentBackground_Type_UNKNOWN; +constexpr PaymentBackground_Type PaymentBackground_Type_Type_MAX = PaymentBackground_Type_DEFAULT; +constexpr int PaymentBackground_Type_Type_ARRAYSIZE = PaymentBackground_Type_Type_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PaymentBackground_Type_descriptor(); +template +inline const std::string& PaymentBackground_Type_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function PaymentBackground_Type_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + PaymentBackground_Type_descriptor(), enum_t_value); +} +inline bool PaymentBackground_Type_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PaymentBackground_Type* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + PaymentBackground_Type_descriptor(), name, value); +} +enum PaymentInfo_Currency : int { + PaymentInfo_Currency_UNKNOWN_CURRENCY = 0, + PaymentInfo_Currency_INR = 1 +}; +bool PaymentInfo_Currency_IsValid(int value); +constexpr PaymentInfo_Currency PaymentInfo_Currency_Currency_MIN = PaymentInfo_Currency_UNKNOWN_CURRENCY; +constexpr PaymentInfo_Currency PaymentInfo_Currency_Currency_MAX = PaymentInfo_Currency_INR; +constexpr int PaymentInfo_Currency_Currency_ARRAYSIZE = PaymentInfo_Currency_Currency_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PaymentInfo_Currency_descriptor(); +template +inline const std::string& PaymentInfo_Currency_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function PaymentInfo_Currency_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + PaymentInfo_Currency_descriptor(), enum_t_value); +} +inline bool PaymentInfo_Currency_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PaymentInfo_Currency* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + PaymentInfo_Currency_descriptor(), name, value); +} +enum PaymentInfo_Status : int { + PaymentInfo_Status_UNKNOWN_STATUS = 0, + PaymentInfo_Status_PROCESSING = 1, + PaymentInfo_Status_SENT = 2, + PaymentInfo_Status_NEED_TO_ACCEPT = 3, + PaymentInfo_Status_COMPLETE = 4, + PaymentInfo_Status_COULD_NOT_COMPLETE = 5, + PaymentInfo_Status_REFUNDED = 6, + PaymentInfo_Status_EXPIRED = 7, + PaymentInfo_Status_REJECTED = 8, + PaymentInfo_Status_CANCELLED = 9, + PaymentInfo_Status_WAITING_FOR_PAYER = 10, + PaymentInfo_Status_WAITING = 11 +}; +bool PaymentInfo_Status_IsValid(int value); +constexpr PaymentInfo_Status PaymentInfo_Status_Status_MIN = PaymentInfo_Status_UNKNOWN_STATUS; +constexpr PaymentInfo_Status PaymentInfo_Status_Status_MAX = PaymentInfo_Status_WAITING; +constexpr int PaymentInfo_Status_Status_ARRAYSIZE = PaymentInfo_Status_Status_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PaymentInfo_Status_descriptor(); +template +inline const std::string& PaymentInfo_Status_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function PaymentInfo_Status_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + PaymentInfo_Status_descriptor(), enum_t_value); +} +inline bool PaymentInfo_Status_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PaymentInfo_Status* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + PaymentInfo_Status_descriptor(), name, value); +} +enum PaymentInfo_TxnStatus : int { + PaymentInfo_TxnStatus_UNKNOWN = 0, + PaymentInfo_TxnStatus_PENDING_SETUP = 1, + PaymentInfo_TxnStatus_PENDING_RECEIVER_SETUP = 2, + PaymentInfo_TxnStatus_INIT = 3, + PaymentInfo_TxnStatus_SUCCESS = 4, + PaymentInfo_TxnStatus_COMPLETED = 5, + PaymentInfo_TxnStatus_FAILED = 6, + PaymentInfo_TxnStatus_FAILED_RISK = 7, + PaymentInfo_TxnStatus_FAILED_PROCESSING = 8, + PaymentInfo_TxnStatus_FAILED_RECEIVER_PROCESSING = 9, + PaymentInfo_TxnStatus_FAILED_DA = 10, + PaymentInfo_TxnStatus_FAILED_DA_FINAL = 11, + PaymentInfo_TxnStatus_REFUNDED_TXN = 12, + PaymentInfo_TxnStatus_REFUND_FAILED = 13, + PaymentInfo_TxnStatus_REFUND_FAILED_PROCESSING = 14, + PaymentInfo_TxnStatus_REFUND_FAILED_DA = 15, + PaymentInfo_TxnStatus_EXPIRED_TXN = 16, + PaymentInfo_TxnStatus_AUTH_CANCELED = 17, + PaymentInfo_TxnStatus_AUTH_CANCEL_FAILED_PROCESSING = 18, + PaymentInfo_TxnStatus_AUTH_CANCEL_FAILED = 19, + PaymentInfo_TxnStatus_COLLECT_INIT = 20, + PaymentInfo_TxnStatus_COLLECT_SUCCESS = 21, + PaymentInfo_TxnStatus_COLLECT_FAILED = 22, + PaymentInfo_TxnStatus_COLLECT_FAILED_RISK = 23, + PaymentInfo_TxnStatus_COLLECT_REJECTED = 24, + PaymentInfo_TxnStatus_COLLECT_EXPIRED = 25, + PaymentInfo_TxnStatus_COLLECT_CANCELED = 26, + PaymentInfo_TxnStatus_COLLECT_CANCELLING = 27, + PaymentInfo_TxnStatus_IN_REVIEW = 28, + PaymentInfo_TxnStatus_REVERSAL_SUCCESS = 29, + PaymentInfo_TxnStatus_REVERSAL_PENDING = 30, + PaymentInfo_TxnStatus_REFUND_PENDING = 31 +}; +bool PaymentInfo_TxnStatus_IsValid(int value); +constexpr PaymentInfo_TxnStatus PaymentInfo_TxnStatus_TxnStatus_MIN = PaymentInfo_TxnStatus_UNKNOWN; +constexpr PaymentInfo_TxnStatus PaymentInfo_TxnStatus_TxnStatus_MAX = PaymentInfo_TxnStatus_REFUND_PENDING; +constexpr int PaymentInfo_TxnStatus_TxnStatus_ARRAYSIZE = PaymentInfo_TxnStatus_TxnStatus_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PaymentInfo_TxnStatus_descriptor(); +template +inline const std::string& PaymentInfo_TxnStatus_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function PaymentInfo_TxnStatus_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + PaymentInfo_TxnStatus_descriptor(), enum_t_value); +} +inline bool PaymentInfo_TxnStatus_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PaymentInfo_TxnStatus* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + PaymentInfo_TxnStatus_descriptor(), name, value); +} +enum SyncdMutation_SyncdOperation : int { + SyncdMutation_SyncdOperation_SET = 0, + SyncdMutation_SyncdOperation_REMOVE = 1 +}; +bool SyncdMutation_SyncdOperation_IsValid(int value); +constexpr SyncdMutation_SyncdOperation SyncdMutation_SyncdOperation_SyncdOperation_MIN = SyncdMutation_SyncdOperation_SET; +constexpr SyncdMutation_SyncdOperation SyncdMutation_SyncdOperation_SyncdOperation_MAX = SyncdMutation_SyncdOperation_REMOVE; +constexpr int SyncdMutation_SyncdOperation_SyncdOperation_ARRAYSIZE = SyncdMutation_SyncdOperation_SyncdOperation_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SyncdMutation_SyncdOperation_descriptor(); +template +inline const std::string& SyncdMutation_SyncdOperation_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function SyncdMutation_SyncdOperation_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + SyncdMutation_SyncdOperation_descriptor(), enum_t_value); +} +inline bool SyncdMutation_SyncdOperation_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SyncdMutation_SyncdOperation* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + SyncdMutation_SyncdOperation_descriptor(), name, value); +} +enum WebFeatures_Flag : int { + WebFeatures_Flag_NOT_STARTED = 0, + WebFeatures_Flag_FORCE_UPGRADE = 1, + WebFeatures_Flag_DEVELOPMENT = 2, + WebFeatures_Flag_PRODUCTION = 3 +}; +bool WebFeatures_Flag_IsValid(int value); +constexpr WebFeatures_Flag WebFeatures_Flag_Flag_MIN = WebFeatures_Flag_NOT_STARTED; +constexpr WebFeatures_Flag WebFeatures_Flag_Flag_MAX = WebFeatures_Flag_PRODUCTION; +constexpr int WebFeatures_Flag_Flag_ARRAYSIZE = WebFeatures_Flag_Flag_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WebFeatures_Flag_descriptor(); +template +inline const std::string& WebFeatures_Flag_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function WebFeatures_Flag_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + WebFeatures_Flag_descriptor(), enum_t_value); +} +inline bool WebFeatures_Flag_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WebFeatures_Flag* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + WebFeatures_Flag_descriptor(), name, value); +} +enum WebMessageInfo_BizPrivacyStatus : int { + WebMessageInfo_BizPrivacyStatus_E2EE = 0, + WebMessageInfo_BizPrivacyStatus_FB = 2, + WebMessageInfo_BizPrivacyStatus_BSP = 1, + WebMessageInfo_BizPrivacyStatus_BSP_AND_FB = 3 +}; +bool WebMessageInfo_BizPrivacyStatus_IsValid(int value); +constexpr WebMessageInfo_BizPrivacyStatus WebMessageInfo_BizPrivacyStatus_BizPrivacyStatus_MIN = WebMessageInfo_BizPrivacyStatus_E2EE; +constexpr WebMessageInfo_BizPrivacyStatus WebMessageInfo_BizPrivacyStatus_BizPrivacyStatus_MAX = WebMessageInfo_BizPrivacyStatus_BSP_AND_FB; +constexpr int WebMessageInfo_BizPrivacyStatus_BizPrivacyStatus_ARRAYSIZE = WebMessageInfo_BizPrivacyStatus_BizPrivacyStatus_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WebMessageInfo_BizPrivacyStatus_descriptor(); +template +inline const std::string& WebMessageInfo_BizPrivacyStatus_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function WebMessageInfo_BizPrivacyStatus_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + WebMessageInfo_BizPrivacyStatus_descriptor(), enum_t_value); +} +inline bool WebMessageInfo_BizPrivacyStatus_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WebMessageInfo_BizPrivacyStatus* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + WebMessageInfo_BizPrivacyStatus_descriptor(), name, value); +} +enum WebMessageInfo_Status : int { + WebMessageInfo_Status_ERROR = 0, + WebMessageInfo_Status_PENDING = 1, + WebMessageInfo_Status_SERVER_ACK = 2, + WebMessageInfo_Status_DELIVERY_ACK = 3, + WebMessageInfo_Status_READ = 4, + WebMessageInfo_Status_PLAYED = 5 +}; +bool WebMessageInfo_Status_IsValid(int value); +constexpr WebMessageInfo_Status WebMessageInfo_Status_Status_MIN = WebMessageInfo_Status_ERROR; +constexpr WebMessageInfo_Status WebMessageInfo_Status_Status_MAX = WebMessageInfo_Status_PLAYED; +constexpr int WebMessageInfo_Status_Status_ARRAYSIZE = WebMessageInfo_Status_Status_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WebMessageInfo_Status_descriptor(); +template +inline const std::string& WebMessageInfo_Status_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function WebMessageInfo_Status_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + WebMessageInfo_Status_descriptor(), enum_t_value); +} +inline bool WebMessageInfo_Status_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WebMessageInfo_Status* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + WebMessageInfo_Status_descriptor(), name, value); +} +enum WebMessageInfo_StubType : int { + WebMessageInfo_StubType_UNKNOWN = 0, + WebMessageInfo_StubType_REVOKE = 1, + WebMessageInfo_StubType_CIPHERTEXT = 2, + WebMessageInfo_StubType_FUTUREPROOF = 3, + WebMessageInfo_StubType_NON_VERIFIED_TRANSITION = 4, + WebMessageInfo_StubType_UNVERIFIED_TRANSITION = 5, + WebMessageInfo_StubType_VERIFIED_TRANSITION = 6, + WebMessageInfo_StubType_VERIFIED_LOW_UNKNOWN = 7, + WebMessageInfo_StubType_VERIFIED_HIGH = 8, + WebMessageInfo_StubType_VERIFIED_INITIAL_UNKNOWN = 9, + WebMessageInfo_StubType_VERIFIED_INITIAL_LOW = 10, + WebMessageInfo_StubType_VERIFIED_INITIAL_HIGH = 11, + WebMessageInfo_StubType_VERIFIED_TRANSITION_ANY_TO_NONE = 12, + WebMessageInfo_StubType_VERIFIED_TRANSITION_ANY_TO_HIGH = 13, + WebMessageInfo_StubType_VERIFIED_TRANSITION_HIGH_TO_LOW = 14, + WebMessageInfo_StubType_VERIFIED_TRANSITION_HIGH_TO_UNKNOWN = 15, + WebMessageInfo_StubType_VERIFIED_TRANSITION_UNKNOWN_TO_LOW = 16, + WebMessageInfo_StubType_VERIFIED_TRANSITION_LOW_TO_UNKNOWN = 17, + WebMessageInfo_StubType_VERIFIED_TRANSITION_NONE_TO_LOW = 18, + WebMessageInfo_StubType_VERIFIED_TRANSITION_NONE_TO_UNKNOWN = 19, + WebMessageInfo_StubType_GROUP_CREATE = 20, + WebMessageInfo_StubType_GROUP_CHANGE_SUBJECT = 21, + WebMessageInfo_StubType_GROUP_CHANGE_ICON = 22, + WebMessageInfo_StubType_GROUP_CHANGE_INVITE_LINK = 23, + WebMessageInfo_StubType_GROUP_CHANGE_DESCRIPTION = 24, + WebMessageInfo_StubType_GROUP_CHANGE_RESTRICT = 25, + WebMessageInfo_StubType_GROUP_CHANGE_ANNOUNCE = 26, + WebMessageInfo_StubType_GROUP_PARTICIPANT_ADD = 27, + WebMessageInfo_StubType_GROUP_PARTICIPANT_REMOVE = 28, + WebMessageInfo_StubType_GROUP_PARTICIPANT_PROMOTE = 29, + WebMessageInfo_StubType_GROUP_PARTICIPANT_DEMOTE = 30, + WebMessageInfo_StubType_GROUP_PARTICIPANT_INVITE = 31, + WebMessageInfo_StubType_GROUP_PARTICIPANT_LEAVE = 32, + WebMessageInfo_StubType_GROUP_PARTICIPANT_CHANGE_NUMBER = 33, + WebMessageInfo_StubType_BROADCAST_CREATE = 34, + WebMessageInfo_StubType_BROADCAST_ADD = 35, + WebMessageInfo_StubType_BROADCAST_REMOVE = 36, + WebMessageInfo_StubType_GENERIC_NOTIFICATION = 37, + WebMessageInfo_StubType_E2E_IDENTITY_CHANGED = 38, + WebMessageInfo_StubType_E2E_ENCRYPTED = 39, + WebMessageInfo_StubType_CALL_MISSED_VOICE = 40, + WebMessageInfo_StubType_CALL_MISSED_VIDEO = 41, + WebMessageInfo_StubType_INDIVIDUAL_CHANGE_NUMBER = 42, + WebMessageInfo_StubType_GROUP_DELETE = 43, + WebMessageInfo_StubType_GROUP_ANNOUNCE_MODE_MESSAGE_BOUNCE = 44, + WebMessageInfo_StubType_CALL_MISSED_GROUP_VOICE = 45, + WebMessageInfo_StubType_CALL_MISSED_GROUP_VIDEO = 46, + WebMessageInfo_StubType_PAYMENT_CIPHERTEXT = 47, + WebMessageInfo_StubType_PAYMENT_FUTUREPROOF = 48, + WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_UPDATE_FAILED = 49, + WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_UPDATE_REFUNDED = 50, + WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_UPDATE_REFUND_FAILED = 51, + WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_RECEIVER_PENDING_SETUP = 52, + WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_RECEIVER_SUCCESS_AFTER_HICCUP = 53, + WebMessageInfo_StubType_PAYMENT_ACTION_ACCOUNT_SETUP_REMINDER = 54, + WebMessageInfo_StubType_PAYMENT_ACTION_SEND_PAYMENT_REMINDER = 55, + WebMessageInfo_StubType_PAYMENT_ACTION_SEND_PAYMENT_INVITATION = 56, + WebMessageInfo_StubType_PAYMENT_ACTION_REQUEST_DECLINED = 57, + WebMessageInfo_StubType_PAYMENT_ACTION_REQUEST_EXPIRED = 58, + WebMessageInfo_StubType_PAYMENT_ACTION_REQUEST_CANCELLED = 59, + WebMessageInfo_StubType_BIZ_VERIFIED_TRANSITION_TOP_TO_BOTTOM = 60, + WebMessageInfo_StubType_BIZ_VERIFIED_TRANSITION_BOTTOM_TO_TOP = 61, + WebMessageInfo_StubType_BIZ_INTRO_TOP = 62, + WebMessageInfo_StubType_BIZ_INTRO_BOTTOM = 63, + WebMessageInfo_StubType_BIZ_NAME_CHANGE = 64, + WebMessageInfo_StubType_BIZ_MOVE_TO_CONSUMER_APP = 65, + WebMessageInfo_StubType_BIZ_TWO_TIER_MIGRATION_TOP = 66, + WebMessageInfo_StubType_BIZ_TWO_TIER_MIGRATION_BOTTOM = 67, + WebMessageInfo_StubType_OVERSIZED = 68, + WebMessageInfo_StubType_GROUP_CHANGE_NO_FREQUENTLY_FORWARDED = 69, + WebMessageInfo_StubType_GROUP_V4_ADD_INVITE_SENT = 70, + WebMessageInfo_StubType_GROUP_PARTICIPANT_ADD_REQUEST_JOIN = 71, + WebMessageInfo_StubType_CHANGE_EPHEMERAL_SETTING = 72, + WebMessageInfo_StubType_E2E_DEVICE_CHANGED = 73, + WebMessageInfo_StubType_VIEWED_ONCE = 74, + WebMessageInfo_StubType_E2E_ENCRYPTED_NOW = 75, + WebMessageInfo_StubType_BLUE_MSG_BSP_FB_TO_BSP_PREMISE = 76, + WebMessageInfo_StubType_BLUE_MSG_BSP_FB_TO_SELF_FB = 77, + WebMessageInfo_StubType_BLUE_MSG_BSP_FB_TO_SELF_PREMISE = 78, + WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED = 79, + WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED = 80, + WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED = 81, + WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED = 82, + WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_TO_SELF_PREMISE = 83, + WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_UNVERIFIED = 84, + WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_UNVERIFIED_TO_SELF_PREMISE_VERIFIED = 85, + WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_VERIFIED = 86, + WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_VERIFIED_TO_SELF_PREMISE_UNVERIFIED = 87, + WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_BSP_FB_UNVERIFIED = 88, + WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_BSP_PREMISE_UNVERIFIED = 89, + WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_SELF_FB_UNVERIFIED = 90, + WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_SELF_PREMISE_UNVERIFIED = 91, + WebMessageInfo_StubType_BLUE_MSG_SELF_FB_TO_BSP_PREMISE = 92, + WebMessageInfo_StubType_BLUE_MSG_SELF_FB_TO_SELF_PREMISE = 93, + WebMessageInfo_StubType_BLUE_MSG_SELF_FB_UNVERIFIED = 94, + WebMessageInfo_StubType_BLUE_MSG_SELF_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED = 95, + WebMessageInfo_StubType_BLUE_MSG_SELF_FB_VERIFIED = 96, + WebMessageInfo_StubType_BLUE_MSG_SELF_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED = 97, + WebMessageInfo_StubType_BLUE_MSG_SELF_PREMISE_TO_BSP_PREMISE = 98, + WebMessageInfo_StubType_BLUE_MSG_SELF_PREMISE_UNVERIFIED = 99, + WebMessageInfo_StubType_BLUE_MSG_SELF_PREMISE_VERIFIED = 100, + WebMessageInfo_StubType_BLUE_MSG_TO_BSP_FB = 101, + WebMessageInfo_StubType_BLUE_MSG_TO_CONSUMER = 102, + WebMessageInfo_StubType_BLUE_MSG_TO_SELF_FB = 103, + WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_BSP_FB_VERIFIED = 104, + WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_BSP_PREMISE_VERIFIED = 105, + WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_SELF_FB_VERIFIED = 106, + WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_VERIFIED = 107, + WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_BSP_FB_UNVERIFIED = 108, + WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_BSP_PREMISE_UNVERIFIED = 109, + WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_SELF_FB_UNVERIFIED = 110, + WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_UNVERIFIED = 111, + WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED = 112, + WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_FB_VERIFIED = 113, + WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED = 114, + WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_FB_UNVERIFIED = 115, + WebMessageInfo_StubType_BLUE_MSG_SELF_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED = 116, + WebMessageInfo_StubType_BLUE_MSG_SELF_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED = 117, + WebMessageInfo_StubType_E2E_IDENTITY_UNAVAILABLE = 118, + WebMessageInfo_StubType_GROUP_CREATING = 119, + WebMessageInfo_StubType_GROUP_CREATE_FAILED = 120, + WebMessageInfo_StubType_GROUP_BOUNCED = 121, + WebMessageInfo_StubType_BLOCK_CONTACT = 122, + WebMessageInfo_StubType_EPHEMERAL_SETTING_NOT_APPLIED = 123, + WebMessageInfo_StubType_SYNC_FAILED = 124, + WebMessageInfo_StubType_SYNCING = 125, + WebMessageInfo_StubType_BIZ_PRIVACY_MODE_INIT_FB = 126, + WebMessageInfo_StubType_BIZ_PRIVACY_MODE_INIT_BSP = 127, + WebMessageInfo_StubType_BIZ_PRIVACY_MODE_TO_FB = 128, + WebMessageInfo_StubType_BIZ_PRIVACY_MODE_TO_BSP = 129, + WebMessageInfo_StubType_DISAPPEARING_MODE = 130, + WebMessageInfo_StubType_E2E_DEVICE_FETCH_FAILED = 131, + WebMessageInfo_StubType_ADMIN_REVOKE = 132, + WebMessageInfo_StubType_GROUP_INVITE_LINK_GROWTH_LOCKED = 133, + WebMessageInfo_StubType_COMMUNITY_LINK_PARENT_GROUP = 134, + WebMessageInfo_StubType_COMMUNITY_LINK_SIBLING_GROUP = 135, + WebMessageInfo_StubType_COMMUNITY_LINK_SUB_GROUP = 136, + WebMessageInfo_StubType_COMMUNITY_UNLINK_PARENT_GROUP = 137, + WebMessageInfo_StubType_COMMUNITY_UNLINK_SIBLING_GROUP = 138, + WebMessageInfo_StubType_COMMUNITY_UNLINK_SUB_GROUP = 139, + WebMessageInfo_StubType_GROUP_PARTICIPANT_ACCEPT = 140, + WebMessageInfo_StubType_GROUP_PARTICIPANT_LINKED_GROUP_JOIN = 141, + WebMessageInfo_StubType_COMMUNITY_CREATE = 142, + WebMessageInfo_StubType_EPHEMERAL_KEEP_IN_CHAT = 143, + WebMessageInfo_StubType_GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST = 144, + WebMessageInfo_StubType_GROUP_MEMBERSHIP_JOIN_APPROVAL_MODE = 145, + WebMessageInfo_StubType_INTEGRITY_UNLINK_PARENT_GROUP = 146, + WebMessageInfo_StubType_COMMUNITY_PARTICIPANT_PROMOTE = 147, + WebMessageInfo_StubType_COMMUNITY_PARTICIPANT_DEMOTE = 148, + WebMessageInfo_StubType_COMMUNITY_PARENT_GROUP_DELETED = 149 +}; +bool WebMessageInfo_StubType_IsValid(int value); +constexpr WebMessageInfo_StubType WebMessageInfo_StubType_StubType_MIN = WebMessageInfo_StubType_UNKNOWN; +constexpr WebMessageInfo_StubType WebMessageInfo_StubType_StubType_MAX = WebMessageInfo_StubType_COMMUNITY_PARENT_GROUP_DELETED; +constexpr int WebMessageInfo_StubType_StubType_ARRAYSIZE = WebMessageInfo_StubType_StubType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WebMessageInfo_StubType_descriptor(); +template +inline const std::string& WebMessageInfo_StubType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function WebMessageInfo_StubType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + WebMessageInfo_StubType_descriptor(), enum_t_value); +} +inline bool WebMessageInfo_StubType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WebMessageInfo_StubType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + WebMessageInfo_StubType_descriptor(), name, value); +} +enum KeepType : int { + UNKNOWN = 0, + KEEP_FOR_ALL = 1, + UNDO_KEEP_FOR_ALL = 2 +}; +bool KeepType_IsValid(int value); +constexpr KeepType KeepType_MIN = UNKNOWN; +constexpr KeepType KeepType_MAX = UNDO_KEEP_FOR_ALL; +constexpr int KeepType_ARRAYSIZE = KeepType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* KeepType_descriptor(); +template +inline const std::string& KeepType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function KeepType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + KeepType_descriptor(), enum_t_value); +} +inline bool KeepType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, KeepType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + KeepType_descriptor(), name, value); +} +enum MediaVisibility : int { + DEFAULT = 0, + OFF = 1, + ON = 2 +}; +bool MediaVisibility_IsValid(int value); +constexpr MediaVisibility MediaVisibility_MIN = DEFAULT; +constexpr MediaVisibility MediaVisibility_MAX = ON; +constexpr int MediaVisibility_ARRAYSIZE = MediaVisibility_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MediaVisibility_descriptor(); +template +inline const std::string& MediaVisibility_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function MediaVisibility_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + MediaVisibility_descriptor(), enum_t_value); +} +inline bool MediaVisibility_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MediaVisibility* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + MediaVisibility_descriptor(), name, value); +} +// =================================================================== + +class ADVDeviceIdentity final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ADVDeviceIdentity) */ { + public: + inline ADVDeviceIdentity() : ADVDeviceIdentity(nullptr) {} + ~ADVDeviceIdentity() override; + explicit PROTOBUF_CONSTEXPR ADVDeviceIdentity(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ADVDeviceIdentity(const ADVDeviceIdentity& from); + ADVDeviceIdentity(ADVDeviceIdentity&& from) noexcept + : ADVDeviceIdentity() { + *this = ::std::move(from); + } + + inline ADVDeviceIdentity& operator=(const ADVDeviceIdentity& from) { + CopyFrom(from); + return *this; + } + inline ADVDeviceIdentity& operator=(ADVDeviceIdentity&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ADVDeviceIdentity& default_instance() { + return *internal_default_instance(); + } + static inline const ADVDeviceIdentity* internal_default_instance() { + return reinterpret_cast( + &_ADVDeviceIdentity_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(ADVDeviceIdentity& a, ADVDeviceIdentity& b) { + a.Swap(&b); + } + inline void Swap(ADVDeviceIdentity* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ADVDeviceIdentity* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ADVDeviceIdentity* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ADVDeviceIdentity& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const ADVDeviceIdentity& from) { + ADVDeviceIdentity::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ADVDeviceIdentity* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.ADVDeviceIdentity"; + } + protected: + explicit ADVDeviceIdentity(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kTimestampFieldNumber = 2, + kRawIdFieldNumber = 1, + kKeyIndexFieldNumber = 3, + }; + // optional uint64 timestamp = 2; + bool has_timestamp() const; + private: + bool _internal_has_timestamp() const; + public: + void clear_timestamp(); + uint64_t timestamp() const; + void set_timestamp(uint64_t value); + private: + uint64_t _internal_timestamp() const; + void _internal_set_timestamp(uint64_t value); + public: + + // optional uint32 rawId = 1; + bool has_rawid() const; + private: + bool _internal_has_rawid() const; + public: + void clear_rawid(); + uint32_t rawid() const; + void set_rawid(uint32_t value); + private: + uint32_t _internal_rawid() const; + void _internal_set_rawid(uint32_t value); + public: + + // optional uint32 keyIndex = 3; + bool has_keyindex() const; + private: + bool _internal_has_keyindex() const; + public: + void clear_keyindex(); + uint32_t keyindex() const; + void set_keyindex(uint32_t value); + private: + uint32_t _internal_keyindex() const; + void _internal_set_keyindex(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.ADVDeviceIdentity) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + uint64_t timestamp_; + uint32_t rawid_; + uint32_t keyindex_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class ADVKeyIndexList final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ADVKeyIndexList) */ { + public: + inline ADVKeyIndexList() : ADVKeyIndexList(nullptr) {} + ~ADVKeyIndexList() override; + explicit PROTOBUF_CONSTEXPR ADVKeyIndexList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ADVKeyIndexList(const ADVKeyIndexList& from); + ADVKeyIndexList(ADVKeyIndexList&& from) noexcept + : ADVKeyIndexList() { + *this = ::std::move(from); + } + + inline ADVKeyIndexList& operator=(const ADVKeyIndexList& from) { + CopyFrom(from); + return *this; + } + inline ADVKeyIndexList& operator=(ADVKeyIndexList&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ADVKeyIndexList& default_instance() { + return *internal_default_instance(); + } + static inline const ADVKeyIndexList* internal_default_instance() { + return reinterpret_cast( + &_ADVKeyIndexList_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + friend void swap(ADVKeyIndexList& a, ADVKeyIndexList& b) { + a.Swap(&b); + } + inline void Swap(ADVKeyIndexList* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ADVKeyIndexList* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ADVKeyIndexList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ADVKeyIndexList& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const ADVKeyIndexList& from) { + ADVKeyIndexList::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ADVKeyIndexList* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.ADVKeyIndexList"; + } + protected: + explicit ADVKeyIndexList(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kValidIndexesFieldNumber = 4, + kTimestampFieldNumber = 2, + kRawIdFieldNumber = 1, + kCurrentIndexFieldNumber = 3, + }; + // repeated uint32 validIndexes = 4 [packed = true]; + int validindexes_size() const; + private: + int _internal_validindexes_size() const; + public: + void clear_validindexes(); + private: + uint32_t _internal_validindexes(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + _internal_validindexes() const; + void _internal_add_validindexes(uint32_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + _internal_mutable_validindexes(); + public: + uint32_t validindexes(int index) const; + void set_validindexes(int index, uint32_t value); + void add_validindexes(uint32_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + validindexes() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + mutable_validindexes(); + + // optional uint64 timestamp = 2; + bool has_timestamp() const; + private: + bool _internal_has_timestamp() const; + public: + void clear_timestamp(); + uint64_t timestamp() const; + void set_timestamp(uint64_t value); + private: + uint64_t _internal_timestamp() const; + void _internal_set_timestamp(uint64_t value); + public: + + // optional uint32 rawId = 1; + bool has_rawid() const; + private: + bool _internal_has_rawid() const; + public: + void clear_rawid(); + uint32_t rawid() const; + void set_rawid(uint32_t value); + private: + uint32_t _internal_rawid() const; + void _internal_set_rawid(uint32_t value); + public: + + // optional uint32 currentIndex = 3; + bool has_currentindex() const; + private: + bool _internal_has_currentindex() const; + public: + void clear_currentindex(); + uint32_t currentindex() const; + void set_currentindex(uint32_t value); + private: + uint32_t _internal_currentindex() const; + void _internal_set_currentindex(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.ADVKeyIndexList) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > validindexes_; + mutable std::atomic _validindexes_cached_byte_size_; + uint64_t timestamp_; + uint32_t rawid_; + uint32_t currentindex_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class ADVSignedDeviceIdentity final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ADVSignedDeviceIdentity) */ { + public: + inline ADVSignedDeviceIdentity() : ADVSignedDeviceIdentity(nullptr) {} + ~ADVSignedDeviceIdentity() override; + explicit PROTOBUF_CONSTEXPR ADVSignedDeviceIdentity(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ADVSignedDeviceIdentity(const ADVSignedDeviceIdentity& from); + ADVSignedDeviceIdentity(ADVSignedDeviceIdentity&& from) noexcept + : ADVSignedDeviceIdentity() { + *this = ::std::move(from); + } + + inline ADVSignedDeviceIdentity& operator=(const ADVSignedDeviceIdentity& from) { + CopyFrom(from); + return *this; + } + inline ADVSignedDeviceIdentity& operator=(ADVSignedDeviceIdentity&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ADVSignedDeviceIdentity& default_instance() { + return *internal_default_instance(); + } + static inline const ADVSignedDeviceIdentity* internal_default_instance() { + return reinterpret_cast( + &_ADVSignedDeviceIdentity_default_instance_); + } + static constexpr int kIndexInFileMessages = + 2; + + friend void swap(ADVSignedDeviceIdentity& a, ADVSignedDeviceIdentity& b) { + a.Swap(&b); + } + inline void Swap(ADVSignedDeviceIdentity* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ADVSignedDeviceIdentity* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ADVSignedDeviceIdentity* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ADVSignedDeviceIdentity& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const ADVSignedDeviceIdentity& from) { + ADVSignedDeviceIdentity::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ADVSignedDeviceIdentity* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.ADVSignedDeviceIdentity"; + } + protected: + explicit ADVSignedDeviceIdentity(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDetailsFieldNumber = 1, + kAccountSignatureKeyFieldNumber = 2, + kAccountSignatureFieldNumber = 3, + kDeviceSignatureFieldNumber = 4, + }; + // optional bytes details = 1; + bool has_details() const; + private: + bool _internal_has_details() const; + public: + void clear_details(); + const std::string& details() const; + template + void set_details(ArgT0&& arg0, ArgT... args); + std::string* mutable_details(); + PROTOBUF_NODISCARD std::string* release_details(); + void set_allocated_details(std::string* details); + private: + const std::string& _internal_details() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_details(const std::string& value); + std::string* _internal_mutable_details(); + public: + + // optional bytes accountSignatureKey = 2; + bool has_accountsignaturekey() const; + private: + bool _internal_has_accountsignaturekey() const; + public: + void clear_accountsignaturekey(); + const std::string& accountsignaturekey() const; + template + void set_accountsignaturekey(ArgT0&& arg0, ArgT... args); + std::string* mutable_accountsignaturekey(); + PROTOBUF_NODISCARD std::string* release_accountsignaturekey(); + void set_allocated_accountsignaturekey(std::string* accountsignaturekey); + private: + const std::string& _internal_accountsignaturekey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_accountsignaturekey(const std::string& value); + std::string* _internal_mutable_accountsignaturekey(); + public: + + // optional bytes accountSignature = 3; + bool has_accountsignature() const; + private: + bool _internal_has_accountsignature() const; + public: + void clear_accountsignature(); + const std::string& accountsignature() const; + template + void set_accountsignature(ArgT0&& arg0, ArgT... args); + std::string* mutable_accountsignature(); + PROTOBUF_NODISCARD std::string* release_accountsignature(); + void set_allocated_accountsignature(std::string* accountsignature); + private: + const std::string& _internal_accountsignature() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_accountsignature(const std::string& value); + std::string* _internal_mutable_accountsignature(); + public: + + // optional bytes deviceSignature = 4; + bool has_devicesignature() const; + private: + bool _internal_has_devicesignature() const; + public: + void clear_devicesignature(); + const std::string& devicesignature() const; + template + void set_devicesignature(ArgT0&& arg0, ArgT... args); + std::string* mutable_devicesignature(); + PROTOBUF_NODISCARD std::string* release_devicesignature(); + void set_allocated_devicesignature(std::string* devicesignature); + private: + const std::string& _internal_devicesignature() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_devicesignature(const std::string& value); + std::string* _internal_mutable_devicesignature(); + public: + + // @@protoc_insertion_point(class_scope:proto.ADVSignedDeviceIdentity) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr details_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr accountsignaturekey_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr accountsignature_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr devicesignature_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class ADVSignedDeviceIdentityHMAC final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ADVSignedDeviceIdentityHMAC) */ { + public: + inline ADVSignedDeviceIdentityHMAC() : ADVSignedDeviceIdentityHMAC(nullptr) {} + ~ADVSignedDeviceIdentityHMAC() override; + explicit PROTOBUF_CONSTEXPR ADVSignedDeviceIdentityHMAC(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ADVSignedDeviceIdentityHMAC(const ADVSignedDeviceIdentityHMAC& from); + ADVSignedDeviceIdentityHMAC(ADVSignedDeviceIdentityHMAC&& from) noexcept + : ADVSignedDeviceIdentityHMAC() { + *this = ::std::move(from); + } + + inline ADVSignedDeviceIdentityHMAC& operator=(const ADVSignedDeviceIdentityHMAC& from) { + CopyFrom(from); + return *this; + } + inline ADVSignedDeviceIdentityHMAC& operator=(ADVSignedDeviceIdentityHMAC&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ADVSignedDeviceIdentityHMAC& default_instance() { + return *internal_default_instance(); + } + static inline const ADVSignedDeviceIdentityHMAC* internal_default_instance() { + return reinterpret_cast( + &_ADVSignedDeviceIdentityHMAC_default_instance_); + } + static constexpr int kIndexInFileMessages = + 3; + + friend void swap(ADVSignedDeviceIdentityHMAC& a, ADVSignedDeviceIdentityHMAC& b) { + a.Swap(&b); + } + inline void Swap(ADVSignedDeviceIdentityHMAC* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ADVSignedDeviceIdentityHMAC* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ADVSignedDeviceIdentityHMAC* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ADVSignedDeviceIdentityHMAC& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const ADVSignedDeviceIdentityHMAC& from) { + ADVSignedDeviceIdentityHMAC::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ADVSignedDeviceIdentityHMAC* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.ADVSignedDeviceIdentityHMAC"; + } + protected: + explicit ADVSignedDeviceIdentityHMAC(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDetailsFieldNumber = 1, + kHmacFieldNumber = 2, + }; + // optional bytes details = 1; + bool has_details() const; + private: + bool _internal_has_details() const; + public: + void clear_details(); + const std::string& details() const; + template + void set_details(ArgT0&& arg0, ArgT... args); + std::string* mutable_details(); + PROTOBUF_NODISCARD std::string* release_details(); + void set_allocated_details(std::string* details); + private: + const std::string& _internal_details() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_details(const std::string& value); + std::string* _internal_mutable_details(); + public: + + // optional bytes hmac = 2; + bool has_hmac() const; + private: + bool _internal_has_hmac() const; + public: + void clear_hmac(); + const std::string& hmac() const; + template + void set_hmac(ArgT0&& arg0, ArgT... args); + std::string* mutable_hmac(); + PROTOBUF_NODISCARD std::string* release_hmac(); + void set_allocated_hmac(std::string* hmac); + private: + const std::string& _internal_hmac() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_hmac(const std::string& value); + std::string* _internal_mutable_hmac(); + public: + + // @@protoc_insertion_point(class_scope:proto.ADVSignedDeviceIdentityHMAC) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr details_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hmac_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class ADVSignedKeyIndexList final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ADVSignedKeyIndexList) */ { + public: + inline ADVSignedKeyIndexList() : ADVSignedKeyIndexList(nullptr) {} + ~ADVSignedKeyIndexList() override; + explicit PROTOBUF_CONSTEXPR ADVSignedKeyIndexList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ADVSignedKeyIndexList(const ADVSignedKeyIndexList& from); + ADVSignedKeyIndexList(ADVSignedKeyIndexList&& from) noexcept + : ADVSignedKeyIndexList() { + *this = ::std::move(from); + } + + inline ADVSignedKeyIndexList& operator=(const ADVSignedKeyIndexList& from) { + CopyFrom(from); + return *this; + } + inline ADVSignedKeyIndexList& operator=(ADVSignedKeyIndexList&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ADVSignedKeyIndexList& default_instance() { + return *internal_default_instance(); + } + static inline const ADVSignedKeyIndexList* internal_default_instance() { + return reinterpret_cast( + &_ADVSignedKeyIndexList_default_instance_); + } + static constexpr int kIndexInFileMessages = + 4; + + friend void swap(ADVSignedKeyIndexList& a, ADVSignedKeyIndexList& b) { + a.Swap(&b); + } + inline void Swap(ADVSignedKeyIndexList* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ADVSignedKeyIndexList* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ADVSignedKeyIndexList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ADVSignedKeyIndexList& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const ADVSignedKeyIndexList& from) { + ADVSignedKeyIndexList::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ADVSignedKeyIndexList* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.ADVSignedKeyIndexList"; + } + protected: + explicit ADVSignedKeyIndexList(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDetailsFieldNumber = 1, + kAccountSignatureFieldNumber = 2, + }; + // optional bytes details = 1; + bool has_details() const; + private: + bool _internal_has_details() const; + public: + void clear_details(); + const std::string& details() const; + template + void set_details(ArgT0&& arg0, ArgT... args); + std::string* mutable_details(); + PROTOBUF_NODISCARD std::string* release_details(); + void set_allocated_details(std::string* details); + private: + const std::string& _internal_details() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_details(const std::string& value); + std::string* _internal_mutable_details(); + public: + + // optional bytes accountSignature = 2; + bool has_accountsignature() const; + private: + bool _internal_has_accountsignature() const; + public: + void clear_accountsignature(); + const std::string& accountsignature() const; + template + void set_accountsignature(ArgT0&& arg0, ArgT... args); + std::string* mutable_accountsignature(); + PROTOBUF_NODISCARD std::string* release_accountsignature(); + void set_allocated_accountsignature(std::string* accountsignature); + private: + const std::string& _internal_accountsignature() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_accountsignature(const std::string& value); + std::string* _internal_mutable_accountsignature(); + public: + + // @@protoc_insertion_point(class_scope:proto.ADVSignedKeyIndexList) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr details_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr accountsignature_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class ActionLink final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ActionLink) */ { + public: + inline ActionLink() : ActionLink(nullptr) {} + ~ActionLink() override; + explicit PROTOBUF_CONSTEXPR ActionLink(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ActionLink(const ActionLink& from); + ActionLink(ActionLink&& from) noexcept + : ActionLink() { + *this = ::std::move(from); + } + + inline ActionLink& operator=(const ActionLink& from) { + CopyFrom(from); + return *this; + } + inline ActionLink& operator=(ActionLink&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ActionLink& default_instance() { + return *internal_default_instance(); + } + static inline const ActionLink* internal_default_instance() { + return reinterpret_cast( + &_ActionLink_default_instance_); + } + static constexpr int kIndexInFileMessages = + 5; + + friend void swap(ActionLink& a, ActionLink& b) { + a.Swap(&b); + } + inline void Swap(ActionLink* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ActionLink* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ActionLink* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ActionLink& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const ActionLink& from) { + ActionLink::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ActionLink* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.ActionLink"; + } + protected: + explicit ActionLink(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kUrlFieldNumber = 1, + kButtonTitleFieldNumber = 2, + }; + // optional string url = 1; + bool has_url() const; + private: + bool _internal_has_url() const; + public: + void clear_url(); + const std::string& url() const; + template + void set_url(ArgT0&& arg0, ArgT... args); + std::string* mutable_url(); + PROTOBUF_NODISCARD std::string* release_url(); + void set_allocated_url(std::string* url); + private: + const std::string& _internal_url() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value); + std::string* _internal_mutable_url(); + public: + + // optional string buttonTitle = 2; + bool has_buttontitle() const; + private: + bool _internal_has_buttontitle() const; + public: + void clear_buttontitle(); + const std::string& buttontitle() const; + template + void set_buttontitle(ArgT0&& arg0, ArgT... args); + std::string* mutable_buttontitle(); + PROTOBUF_NODISCARD std::string* release_buttontitle(); + void set_allocated_buttontitle(std::string* buttontitle); + private: + const std::string& _internal_buttontitle() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_buttontitle(const std::string& value); + std::string* _internal_mutable_buttontitle(); + public: + + // @@protoc_insertion_point(class_scope:proto.ActionLink) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr buttontitle_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class AutoDownloadSettings final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.AutoDownloadSettings) */ { + public: + inline AutoDownloadSettings() : AutoDownloadSettings(nullptr) {} + ~AutoDownloadSettings() override; + explicit PROTOBUF_CONSTEXPR AutoDownloadSettings(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + AutoDownloadSettings(const AutoDownloadSettings& from); + AutoDownloadSettings(AutoDownloadSettings&& from) noexcept + : AutoDownloadSettings() { + *this = ::std::move(from); + } + + inline AutoDownloadSettings& operator=(const AutoDownloadSettings& from) { + CopyFrom(from); + return *this; + } + inline AutoDownloadSettings& operator=(AutoDownloadSettings&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const AutoDownloadSettings& default_instance() { + return *internal_default_instance(); + } + static inline const AutoDownloadSettings* internal_default_instance() { + return reinterpret_cast( + &_AutoDownloadSettings_default_instance_); + } + static constexpr int kIndexInFileMessages = + 6; + + friend void swap(AutoDownloadSettings& a, AutoDownloadSettings& b) { + a.Swap(&b); + } + inline void Swap(AutoDownloadSettings* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(AutoDownloadSettings* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + AutoDownloadSettings* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const AutoDownloadSettings& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const AutoDownloadSettings& from) { + AutoDownloadSettings::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(AutoDownloadSettings* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.AutoDownloadSettings"; + } + protected: + explicit AutoDownloadSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDownloadImagesFieldNumber = 1, + kDownloadAudioFieldNumber = 2, + kDownloadVideoFieldNumber = 3, + kDownloadDocumentsFieldNumber = 4, + }; + // optional bool downloadImages = 1; + bool has_downloadimages() const; + private: + bool _internal_has_downloadimages() const; + public: + void clear_downloadimages(); + bool downloadimages() const; + void set_downloadimages(bool value); + private: + bool _internal_downloadimages() const; + void _internal_set_downloadimages(bool value); + public: + + // optional bool downloadAudio = 2; + bool has_downloadaudio() const; + private: + bool _internal_has_downloadaudio() const; + public: + void clear_downloadaudio(); + bool downloadaudio() const; + void set_downloadaudio(bool value); + private: + bool _internal_downloadaudio() const; + void _internal_set_downloadaudio(bool value); + public: + + // optional bool downloadVideo = 3; + bool has_downloadvideo() const; + private: + bool _internal_has_downloadvideo() const; + public: + void clear_downloadvideo(); + bool downloadvideo() const; + void set_downloadvideo(bool value); + private: + bool _internal_downloadvideo() const; + void _internal_set_downloadvideo(bool value); + public: + + // optional bool downloadDocuments = 4; + bool has_downloaddocuments() const; + private: + bool _internal_has_downloaddocuments() const; + public: + void clear_downloaddocuments(); + bool downloaddocuments() const; + void set_downloaddocuments(bool value); + private: + bool _internal_downloaddocuments() const; + void _internal_set_downloaddocuments(bool value); + public: + + // @@protoc_insertion_point(class_scope:proto.AutoDownloadSettings) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + bool downloadimages_; + bool downloadaudio_; + bool downloadvideo_; + bool downloaddocuments_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class BizAccountLinkInfo final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.BizAccountLinkInfo) */ { + public: + inline BizAccountLinkInfo() : BizAccountLinkInfo(nullptr) {} + ~BizAccountLinkInfo() override; + explicit PROTOBUF_CONSTEXPR BizAccountLinkInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + BizAccountLinkInfo(const BizAccountLinkInfo& from); + BizAccountLinkInfo(BizAccountLinkInfo&& from) noexcept + : BizAccountLinkInfo() { + *this = ::std::move(from); + } + + inline BizAccountLinkInfo& operator=(const BizAccountLinkInfo& from) { + CopyFrom(from); + return *this; + } + inline BizAccountLinkInfo& operator=(BizAccountLinkInfo&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const BizAccountLinkInfo& default_instance() { + return *internal_default_instance(); + } + static inline const BizAccountLinkInfo* internal_default_instance() { + return reinterpret_cast( + &_BizAccountLinkInfo_default_instance_); + } + static constexpr int kIndexInFileMessages = + 7; + + friend void swap(BizAccountLinkInfo& a, BizAccountLinkInfo& b) { + a.Swap(&b); + } + inline void Swap(BizAccountLinkInfo* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(BizAccountLinkInfo* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + BizAccountLinkInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const BizAccountLinkInfo& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const BizAccountLinkInfo& from) { + BizAccountLinkInfo::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(BizAccountLinkInfo* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.BizAccountLinkInfo"; + } + protected: + explicit BizAccountLinkInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef BizAccountLinkInfo_AccountType AccountType; + static constexpr AccountType ENTERPRISE = + BizAccountLinkInfo_AccountType_ENTERPRISE; + static inline bool AccountType_IsValid(int value) { + return BizAccountLinkInfo_AccountType_IsValid(value); + } + static constexpr AccountType AccountType_MIN = + BizAccountLinkInfo_AccountType_AccountType_MIN; + static constexpr AccountType AccountType_MAX = + BizAccountLinkInfo_AccountType_AccountType_MAX; + static constexpr int AccountType_ARRAYSIZE = + BizAccountLinkInfo_AccountType_AccountType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + AccountType_descriptor() { + return BizAccountLinkInfo_AccountType_descriptor(); + } + template + static inline const std::string& AccountType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function AccountType_Name."); + return BizAccountLinkInfo_AccountType_Name(enum_t_value); + } + static inline bool AccountType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + AccountType* value) { + return BizAccountLinkInfo_AccountType_Parse(name, value); + } + + typedef BizAccountLinkInfo_HostStorageType HostStorageType; + static constexpr HostStorageType ON_PREMISE = + BizAccountLinkInfo_HostStorageType_ON_PREMISE; + static constexpr HostStorageType FACEBOOK = + BizAccountLinkInfo_HostStorageType_FACEBOOK; + static inline bool HostStorageType_IsValid(int value) { + return BizAccountLinkInfo_HostStorageType_IsValid(value); + } + static constexpr HostStorageType HostStorageType_MIN = + BizAccountLinkInfo_HostStorageType_HostStorageType_MIN; + static constexpr HostStorageType HostStorageType_MAX = + BizAccountLinkInfo_HostStorageType_HostStorageType_MAX; + static constexpr int HostStorageType_ARRAYSIZE = + BizAccountLinkInfo_HostStorageType_HostStorageType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + HostStorageType_descriptor() { + return BizAccountLinkInfo_HostStorageType_descriptor(); + } + template + static inline const std::string& HostStorageType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function HostStorageType_Name."); + return BizAccountLinkInfo_HostStorageType_Name(enum_t_value); + } + static inline bool HostStorageType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + HostStorageType* value) { + return BizAccountLinkInfo_HostStorageType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kWhatsappAcctNumberFieldNumber = 2, + kWhatsappBizAcctFbidFieldNumber = 1, + kIssueTimeFieldNumber = 3, + kHostStorageFieldNumber = 4, + kAccountTypeFieldNumber = 5, + }; + // optional string whatsappAcctNumber = 2; + bool has_whatsappacctnumber() const; + private: + bool _internal_has_whatsappacctnumber() const; + public: + void clear_whatsappacctnumber(); + const std::string& whatsappacctnumber() const; + template + void set_whatsappacctnumber(ArgT0&& arg0, ArgT... args); + std::string* mutable_whatsappacctnumber(); + PROTOBUF_NODISCARD std::string* release_whatsappacctnumber(); + void set_allocated_whatsappacctnumber(std::string* whatsappacctnumber); + private: + const std::string& _internal_whatsappacctnumber() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_whatsappacctnumber(const std::string& value); + std::string* _internal_mutable_whatsappacctnumber(); + public: + + // optional uint64 whatsappBizAcctFbid = 1; + bool has_whatsappbizacctfbid() const; + private: + bool _internal_has_whatsappbizacctfbid() const; + public: + void clear_whatsappbizacctfbid(); + uint64_t whatsappbizacctfbid() const; + void set_whatsappbizacctfbid(uint64_t value); + private: + uint64_t _internal_whatsappbizacctfbid() const; + void _internal_set_whatsappbizacctfbid(uint64_t value); + public: + + // optional uint64 issueTime = 3; + bool has_issuetime() const; + private: + bool _internal_has_issuetime() const; + public: + void clear_issuetime(); + uint64_t issuetime() const; + void set_issuetime(uint64_t value); + private: + uint64_t _internal_issuetime() const; + void _internal_set_issuetime(uint64_t value); + public: + + // optional .proto.BizAccountLinkInfo.HostStorageType hostStorage = 4; + bool has_hoststorage() const; + private: + bool _internal_has_hoststorage() const; + public: + void clear_hoststorage(); + ::proto::BizAccountLinkInfo_HostStorageType hoststorage() const; + void set_hoststorage(::proto::BizAccountLinkInfo_HostStorageType value); + private: + ::proto::BizAccountLinkInfo_HostStorageType _internal_hoststorage() const; + void _internal_set_hoststorage(::proto::BizAccountLinkInfo_HostStorageType value); + public: + + // optional .proto.BizAccountLinkInfo.AccountType accountType = 5; + bool has_accounttype() const; + private: + bool _internal_has_accounttype() const; + public: + void clear_accounttype(); + ::proto::BizAccountLinkInfo_AccountType accounttype() const; + void set_accounttype(::proto::BizAccountLinkInfo_AccountType value); + private: + ::proto::BizAccountLinkInfo_AccountType _internal_accounttype() const; + void _internal_set_accounttype(::proto::BizAccountLinkInfo_AccountType value); + public: + + // @@protoc_insertion_point(class_scope:proto.BizAccountLinkInfo) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr whatsappacctnumber_; + uint64_t whatsappbizacctfbid_; + uint64_t issuetime_; + int hoststorage_; + int accounttype_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class BizAccountPayload final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.BizAccountPayload) */ { + public: + inline BizAccountPayload() : BizAccountPayload(nullptr) {} + ~BizAccountPayload() override; + explicit PROTOBUF_CONSTEXPR BizAccountPayload(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + BizAccountPayload(const BizAccountPayload& from); + BizAccountPayload(BizAccountPayload&& from) noexcept + : BizAccountPayload() { + *this = ::std::move(from); + } + + inline BizAccountPayload& operator=(const BizAccountPayload& from) { + CopyFrom(from); + return *this; + } + inline BizAccountPayload& operator=(BizAccountPayload&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const BizAccountPayload& default_instance() { + return *internal_default_instance(); + } + static inline const BizAccountPayload* internal_default_instance() { + return reinterpret_cast( + &_BizAccountPayload_default_instance_); + } + static constexpr int kIndexInFileMessages = + 8; + + friend void swap(BizAccountPayload& a, BizAccountPayload& b) { + a.Swap(&b); + } + inline void Swap(BizAccountPayload* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(BizAccountPayload* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + BizAccountPayload* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const BizAccountPayload& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const BizAccountPayload& from) { + BizAccountPayload::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(BizAccountPayload* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.BizAccountPayload"; + } + protected: + explicit BizAccountPayload(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kBizAcctLinkInfoFieldNumber = 2, + kVnameCertFieldNumber = 1, + }; + // optional bytes bizAcctLinkInfo = 2; + bool has_bizacctlinkinfo() const; + private: + bool _internal_has_bizacctlinkinfo() const; + public: + void clear_bizacctlinkinfo(); + const std::string& bizacctlinkinfo() const; + template + void set_bizacctlinkinfo(ArgT0&& arg0, ArgT... args); + std::string* mutable_bizacctlinkinfo(); + PROTOBUF_NODISCARD std::string* release_bizacctlinkinfo(); + void set_allocated_bizacctlinkinfo(std::string* bizacctlinkinfo); + private: + const std::string& _internal_bizacctlinkinfo() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_bizacctlinkinfo(const std::string& value); + std::string* _internal_mutable_bizacctlinkinfo(); + public: + + // optional .proto.VerifiedNameCertificate vnameCert = 1; + bool has_vnamecert() const; + private: + bool _internal_has_vnamecert() const; + public: + void clear_vnamecert(); + const ::proto::VerifiedNameCertificate& vnamecert() const; + PROTOBUF_NODISCARD ::proto::VerifiedNameCertificate* release_vnamecert(); + ::proto::VerifiedNameCertificate* mutable_vnamecert(); + void set_allocated_vnamecert(::proto::VerifiedNameCertificate* vnamecert); + private: + const ::proto::VerifiedNameCertificate& _internal_vnamecert() const; + ::proto::VerifiedNameCertificate* _internal_mutable_vnamecert(); + public: + void unsafe_arena_set_allocated_vnamecert( + ::proto::VerifiedNameCertificate* vnamecert); + ::proto::VerifiedNameCertificate* unsafe_arena_release_vnamecert(); + + // @@protoc_insertion_point(class_scope:proto.BizAccountPayload) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bizacctlinkinfo_; + ::proto::VerifiedNameCertificate* vnamecert_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class BizIdentityInfo final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.BizIdentityInfo) */ { + public: + inline BizIdentityInfo() : BizIdentityInfo(nullptr) {} + ~BizIdentityInfo() override; + explicit PROTOBUF_CONSTEXPR BizIdentityInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + BizIdentityInfo(const BizIdentityInfo& from); + BizIdentityInfo(BizIdentityInfo&& from) noexcept + : BizIdentityInfo() { + *this = ::std::move(from); + } + + inline BizIdentityInfo& operator=(const BizIdentityInfo& from) { + CopyFrom(from); + return *this; + } + inline BizIdentityInfo& operator=(BizIdentityInfo&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const BizIdentityInfo& default_instance() { + return *internal_default_instance(); + } + static inline const BizIdentityInfo* internal_default_instance() { + return reinterpret_cast( + &_BizIdentityInfo_default_instance_); + } + static constexpr int kIndexInFileMessages = + 9; + + friend void swap(BizIdentityInfo& a, BizIdentityInfo& b) { + a.Swap(&b); + } + inline void Swap(BizIdentityInfo* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(BizIdentityInfo* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + BizIdentityInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const BizIdentityInfo& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const BizIdentityInfo& from) { + BizIdentityInfo::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(BizIdentityInfo* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.BizIdentityInfo"; + } + protected: + explicit BizIdentityInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef BizIdentityInfo_ActualActorsType ActualActorsType; + static constexpr ActualActorsType SELF = + BizIdentityInfo_ActualActorsType_SELF; + static constexpr ActualActorsType BSP = + BizIdentityInfo_ActualActorsType_BSP; + static inline bool ActualActorsType_IsValid(int value) { + return BizIdentityInfo_ActualActorsType_IsValid(value); + } + static constexpr ActualActorsType ActualActorsType_MIN = + BizIdentityInfo_ActualActorsType_ActualActorsType_MIN; + static constexpr ActualActorsType ActualActorsType_MAX = + BizIdentityInfo_ActualActorsType_ActualActorsType_MAX; + static constexpr int ActualActorsType_ARRAYSIZE = + BizIdentityInfo_ActualActorsType_ActualActorsType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + ActualActorsType_descriptor() { + return BizIdentityInfo_ActualActorsType_descriptor(); + } + template + static inline const std::string& ActualActorsType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ActualActorsType_Name."); + return BizIdentityInfo_ActualActorsType_Name(enum_t_value); + } + static inline bool ActualActorsType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + ActualActorsType* value) { + return BizIdentityInfo_ActualActorsType_Parse(name, value); + } + + typedef BizIdentityInfo_HostStorageType HostStorageType; + static constexpr HostStorageType ON_PREMISE = + BizIdentityInfo_HostStorageType_ON_PREMISE; + static constexpr HostStorageType FACEBOOK = + BizIdentityInfo_HostStorageType_FACEBOOK; + static inline bool HostStorageType_IsValid(int value) { + return BizIdentityInfo_HostStorageType_IsValid(value); + } + static constexpr HostStorageType HostStorageType_MIN = + BizIdentityInfo_HostStorageType_HostStorageType_MIN; + static constexpr HostStorageType HostStorageType_MAX = + BizIdentityInfo_HostStorageType_HostStorageType_MAX; + static constexpr int HostStorageType_ARRAYSIZE = + BizIdentityInfo_HostStorageType_HostStorageType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + HostStorageType_descriptor() { + return BizIdentityInfo_HostStorageType_descriptor(); + } + template + static inline const std::string& HostStorageType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function HostStorageType_Name."); + return BizIdentityInfo_HostStorageType_Name(enum_t_value); + } + static inline bool HostStorageType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + HostStorageType* value) { + return BizIdentityInfo_HostStorageType_Parse(name, value); + } + + typedef BizIdentityInfo_VerifiedLevelValue VerifiedLevelValue; + static constexpr VerifiedLevelValue UNKNOWN = + BizIdentityInfo_VerifiedLevelValue_UNKNOWN; + static constexpr VerifiedLevelValue LOW = + BizIdentityInfo_VerifiedLevelValue_LOW; + static constexpr VerifiedLevelValue HIGH = + BizIdentityInfo_VerifiedLevelValue_HIGH; + static inline bool VerifiedLevelValue_IsValid(int value) { + return BizIdentityInfo_VerifiedLevelValue_IsValid(value); + } + static constexpr VerifiedLevelValue VerifiedLevelValue_MIN = + BizIdentityInfo_VerifiedLevelValue_VerifiedLevelValue_MIN; + static constexpr VerifiedLevelValue VerifiedLevelValue_MAX = + BizIdentityInfo_VerifiedLevelValue_VerifiedLevelValue_MAX; + static constexpr int VerifiedLevelValue_ARRAYSIZE = + BizIdentityInfo_VerifiedLevelValue_VerifiedLevelValue_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + VerifiedLevelValue_descriptor() { + return BizIdentityInfo_VerifiedLevelValue_descriptor(); + } + template + static inline const std::string& VerifiedLevelValue_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function VerifiedLevelValue_Name."); + return BizIdentityInfo_VerifiedLevelValue_Name(enum_t_value); + } + static inline bool VerifiedLevelValue_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + VerifiedLevelValue* value) { + return BizIdentityInfo_VerifiedLevelValue_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kVnameCertFieldNumber = 2, + kVlevelFieldNumber = 1, + kSignedFieldNumber = 3, + kRevokedFieldNumber = 4, + kHostStorageFieldNumber = 5, + kActualActorsFieldNumber = 6, + kPrivacyModeTsFieldNumber = 7, + kFeatureControlsFieldNumber = 8, + }; + // optional .proto.VerifiedNameCertificate vnameCert = 2; + bool has_vnamecert() const; + private: + bool _internal_has_vnamecert() const; + public: + void clear_vnamecert(); + const ::proto::VerifiedNameCertificate& vnamecert() const; + PROTOBUF_NODISCARD ::proto::VerifiedNameCertificate* release_vnamecert(); + ::proto::VerifiedNameCertificate* mutable_vnamecert(); + void set_allocated_vnamecert(::proto::VerifiedNameCertificate* vnamecert); + private: + const ::proto::VerifiedNameCertificate& _internal_vnamecert() const; + ::proto::VerifiedNameCertificate* _internal_mutable_vnamecert(); + public: + void unsafe_arena_set_allocated_vnamecert( + ::proto::VerifiedNameCertificate* vnamecert); + ::proto::VerifiedNameCertificate* unsafe_arena_release_vnamecert(); + + // optional .proto.BizIdentityInfo.VerifiedLevelValue vlevel = 1; + bool has_vlevel() const; + private: + bool _internal_has_vlevel() const; + public: + void clear_vlevel(); + ::proto::BizIdentityInfo_VerifiedLevelValue vlevel() const; + void set_vlevel(::proto::BizIdentityInfo_VerifiedLevelValue value); + private: + ::proto::BizIdentityInfo_VerifiedLevelValue _internal_vlevel() const; + void _internal_set_vlevel(::proto::BizIdentityInfo_VerifiedLevelValue value); + public: + + // optional bool signed = 3; + bool has_signed_() const; + private: + bool _internal_has_signed_() const; + public: + void clear_signed_(); + bool signed_() const; + void set_signed_(bool value); + private: + bool _internal_signed_() const; + void _internal_set_signed_(bool value); + public: + + // optional bool revoked = 4; + bool has_revoked() const; + private: + bool _internal_has_revoked() const; + public: + void clear_revoked(); + bool revoked() const; + void set_revoked(bool value); + private: + bool _internal_revoked() const; + void _internal_set_revoked(bool value); + public: + + // optional .proto.BizIdentityInfo.HostStorageType hostStorage = 5; + bool has_hoststorage() const; + private: + bool _internal_has_hoststorage() const; + public: + void clear_hoststorage(); + ::proto::BizIdentityInfo_HostStorageType hoststorage() const; + void set_hoststorage(::proto::BizIdentityInfo_HostStorageType value); + private: + ::proto::BizIdentityInfo_HostStorageType _internal_hoststorage() const; + void _internal_set_hoststorage(::proto::BizIdentityInfo_HostStorageType value); + public: + + // optional .proto.BizIdentityInfo.ActualActorsType actualActors = 6; + bool has_actualactors() const; + private: + bool _internal_has_actualactors() const; + public: + void clear_actualactors(); + ::proto::BizIdentityInfo_ActualActorsType actualactors() const; + void set_actualactors(::proto::BizIdentityInfo_ActualActorsType value); + private: + ::proto::BizIdentityInfo_ActualActorsType _internal_actualactors() const; + void _internal_set_actualactors(::proto::BizIdentityInfo_ActualActorsType value); + public: + + // optional uint64 privacyModeTs = 7; + bool has_privacymodets() const; + private: + bool _internal_has_privacymodets() const; + public: + void clear_privacymodets(); + uint64_t privacymodets() const; + void set_privacymodets(uint64_t value); + private: + uint64_t _internal_privacymodets() const; + void _internal_set_privacymodets(uint64_t value); + public: + + // optional uint64 featureControls = 8; + bool has_featurecontrols() const; + private: + bool _internal_has_featurecontrols() const; + public: + void clear_featurecontrols(); + uint64_t featurecontrols() const; + void set_featurecontrols(uint64_t value); + private: + uint64_t _internal_featurecontrols() const; + void _internal_set_featurecontrols(uint64_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.BizIdentityInfo) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::proto::VerifiedNameCertificate* vnamecert_; + int vlevel_; + bool signed__; + bool revoked_; + int hoststorage_; + int actualactors_; + uint64_t privacymodets_; + uint64_t featurecontrols_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class CertChain_NoiseCertificate_Details final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.CertChain.NoiseCertificate.Details) */ { + public: + inline CertChain_NoiseCertificate_Details() : CertChain_NoiseCertificate_Details(nullptr) {} + ~CertChain_NoiseCertificate_Details() override; + explicit PROTOBUF_CONSTEXPR CertChain_NoiseCertificate_Details(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + CertChain_NoiseCertificate_Details(const CertChain_NoiseCertificate_Details& from); + CertChain_NoiseCertificate_Details(CertChain_NoiseCertificate_Details&& from) noexcept + : CertChain_NoiseCertificate_Details() { + *this = ::std::move(from); + } + + inline CertChain_NoiseCertificate_Details& operator=(const CertChain_NoiseCertificate_Details& from) { + CopyFrom(from); + return *this; + } + inline CertChain_NoiseCertificate_Details& operator=(CertChain_NoiseCertificate_Details&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const CertChain_NoiseCertificate_Details& default_instance() { + return *internal_default_instance(); + } + static inline const CertChain_NoiseCertificate_Details* internal_default_instance() { + return reinterpret_cast( + &_CertChain_NoiseCertificate_Details_default_instance_); + } + static constexpr int kIndexInFileMessages = + 10; + + friend void swap(CertChain_NoiseCertificate_Details& a, CertChain_NoiseCertificate_Details& b) { + a.Swap(&b); + } + inline void Swap(CertChain_NoiseCertificate_Details* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(CertChain_NoiseCertificate_Details* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + CertChain_NoiseCertificate_Details* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const CertChain_NoiseCertificate_Details& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const CertChain_NoiseCertificate_Details& from) { + CertChain_NoiseCertificate_Details::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(CertChain_NoiseCertificate_Details* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.CertChain.NoiseCertificate.Details"; + } + protected: + explicit CertChain_NoiseCertificate_Details(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kKeyFieldNumber = 3, + kSerialFieldNumber = 1, + kIssuerSerialFieldNumber = 2, + kNotBeforeFieldNumber = 4, + kNotAfterFieldNumber = 5, + }; + // optional bytes key = 3; + bool has_key() const; + private: + bool _internal_has_key() const; + public: + void clear_key(); + const std::string& key() const; + template + void set_key(ArgT0&& arg0, ArgT... args); + std::string* mutable_key(); + PROTOBUF_NODISCARD std::string* release_key(); + void set_allocated_key(std::string* key); + private: + const std::string& _internal_key() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value); + std::string* _internal_mutable_key(); + public: + + // optional uint32 serial = 1; + bool has_serial() const; + private: + bool _internal_has_serial() const; + public: + void clear_serial(); + uint32_t serial() const; + void set_serial(uint32_t value); + private: + uint32_t _internal_serial() const; + void _internal_set_serial(uint32_t value); + public: + + // optional uint32 issuerSerial = 2; + bool has_issuerserial() const; + private: + bool _internal_has_issuerserial() const; + public: + void clear_issuerserial(); + uint32_t issuerserial() const; + void set_issuerserial(uint32_t value); + private: + uint32_t _internal_issuerserial() const; + void _internal_set_issuerserial(uint32_t value); + public: + + // optional uint64 notBefore = 4; + bool has_notbefore() const; + private: + bool _internal_has_notbefore() const; + public: + void clear_notbefore(); + uint64_t notbefore() const; + void set_notbefore(uint64_t value); + private: + uint64_t _internal_notbefore() const; + void _internal_set_notbefore(uint64_t value); + public: + + // optional uint64 notAfter = 5; + bool has_notafter() const; + private: + bool _internal_has_notafter() const; + public: + void clear_notafter(); + uint64_t notafter() const; + void set_notafter(uint64_t value); + private: + uint64_t _internal_notafter() const; + void _internal_set_notafter(uint64_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.CertChain.NoiseCertificate.Details) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_; + uint32_t serial_; + uint32_t issuerserial_; + uint64_t notbefore_; + uint64_t notafter_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class CertChain_NoiseCertificate final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.CertChain.NoiseCertificate) */ { + public: + inline CertChain_NoiseCertificate() : CertChain_NoiseCertificate(nullptr) {} + ~CertChain_NoiseCertificate() override; + explicit PROTOBUF_CONSTEXPR CertChain_NoiseCertificate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + CertChain_NoiseCertificate(const CertChain_NoiseCertificate& from); + CertChain_NoiseCertificate(CertChain_NoiseCertificate&& from) noexcept + : CertChain_NoiseCertificate() { + *this = ::std::move(from); + } + + inline CertChain_NoiseCertificate& operator=(const CertChain_NoiseCertificate& from) { + CopyFrom(from); + return *this; + } + inline CertChain_NoiseCertificate& operator=(CertChain_NoiseCertificate&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const CertChain_NoiseCertificate& default_instance() { + return *internal_default_instance(); + } + static inline const CertChain_NoiseCertificate* internal_default_instance() { + return reinterpret_cast( + &_CertChain_NoiseCertificate_default_instance_); + } + static constexpr int kIndexInFileMessages = + 11; + + friend void swap(CertChain_NoiseCertificate& a, CertChain_NoiseCertificate& b) { + a.Swap(&b); + } + inline void Swap(CertChain_NoiseCertificate* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(CertChain_NoiseCertificate* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + CertChain_NoiseCertificate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const CertChain_NoiseCertificate& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const CertChain_NoiseCertificate& from) { + CertChain_NoiseCertificate::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(CertChain_NoiseCertificate* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.CertChain.NoiseCertificate"; + } + protected: + explicit CertChain_NoiseCertificate(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef CertChain_NoiseCertificate_Details Details; + + // accessors ------------------------------------------------------- + + enum : int { + kDetailsFieldNumber = 1, + kSignatureFieldNumber = 2, + }; + // optional bytes details = 1; + bool has_details() const; + private: + bool _internal_has_details() const; + public: + void clear_details(); + const std::string& details() const; + template + void set_details(ArgT0&& arg0, ArgT... args); + std::string* mutable_details(); + PROTOBUF_NODISCARD std::string* release_details(); + void set_allocated_details(std::string* details); + private: + const std::string& _internal_details() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_details(const std::string& value); + std::string* _internal_mutable_details(); + public: + + // optional bytes signature = 2; + bool has_signature() const; + private: + bool _internal_has_signature() const; + public: + void clear_signature(); + const std::string& signature() const; + template + void set_signature(ArgT0&& arg0, ArgT... args); + std::string* mutable_signature(); + PROTOBUF_NODISCARD std::string* release_signature(); + void set_allocated_signature(std::string* signature); + private: + const std::string& _internal_signature() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value); + std::string* _internal_mutable_signature(); + public: + + // @@protoc_insertion_point(class_scope:proto.CertChain.NoiseCertificate) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr details_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class CertChain final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.CertChain) */ { + public: + inline CertChain() : CertChain(nullptr) {} + ~CertChain() override; + explicit PROTOBUF_CONSTEXPR CertChain(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + CertChain(const CertChain& from); + CertChain(CertChain&& from) noexcept + : CertChain() { + *this = ::std::move(from); + } + + inline CertChain& operator=(const CertChain& from) { + CopyFrom(from); + return *this; + } + inline CertChain& operator=(CertChain&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const CertChain& default_instance() { + return *internal_default_instance(); + } + static inline const CertChain* internal_default_instance() { + return reinterpret_cast( + &_CertChain_default_instance_); + } + static constexpr int kIndexInFileMessages = + 12; + + friend void swap(CertChain& a, CertChain& b) { + a.Swap(&b); + } + inline void Swap(CertChain* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(CertChain* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + CertChain* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const CertChain& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const CertChain& from) { + CertChain::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(CertChain* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.CertChain"; + } + protected: + explicit CertChain(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef CertChain_NoiseCertificate NoiseCertificate; + + // accessors ------------------------------------------------------- + + enum : int { + kLeafFieldNumber = 1, + kIntermediateFieldNumber = 2, + }; + // optional .proto.CertChain.NoiseCertificate leaf = 1; + bool has_leaf() const; + private: + bool _internal_has_leaf() const; + public: + void clear_leaf(); + const ::proto::CertChain_NoiseCertificate& leaf() const; + PROTOBUF_NODISCARD ::proto::CertChain_NoiseCertificate* release_leaf(); + ::proto::CertChain_NoiseCertificate* mutable_leaf(); + void set_allocated_leaf(::proto::CertChain_NoiseCertificate* leaf); + private: + const ::proto::CertChain_NoiseCertificate& _internal_leaf() const; + ::proto::CertChain_NoiseCertificate* _internal_mutable_leaf(); + public: + void unsafe_arena_set_allocated_leaf( + ::proto::CertChain_NoiseCertificate* leaf); + ::proto::CertChain_NoiseCertificate* unsafe_arena_release_leaf(); + + // optional .proto.CertChain.NoiseCertificate intermediate = 2; + bool has_intermediate() const; + private: + bool _internal_has_intermediate() const; + public: + void clear_intermediate(); + const ::proto::CertChain_NoiseCertificate& intermediate() const; + PROTOBUF_NODISCARD ::proto::CertChain_NoiseCertificate* release_intermediate(); + ::proto::CertChain_NoiseCertificate* mutable_intermediate(); + void set_allocated_intermediate(::proto::CertChain_NoiseCertificate* intermediate); + private: + const ::proto::CertChain_NoiseCertificate& _internal_intermediate() const; + ::proto::CertChain_NoiseCertificate* _internal_mutable_intermediate(); + public: + void unsafe_arena_set_allocated_intermediate( + ::proto::CertChain_NoiseCertificate* intermediate); + ::proto::CertChain_NoiseCertificate* unsafe_arena_release_intermediate(); + + // @@protoc_insertion_point(class_scope:proto.CertChain) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::proto::CertChain_NoiseCertificate* leaf_; + ::proto::CertChain_NoiseCertificate* intermediate_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Chain final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Chain) */ { + public: + inline Chain() : Chain(nullptr) {} + ~Chain() override; + explicit PROTOBUF_CONSTEXPR Chain(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Chain(const Chain& from); + Chain(Chain&& from) noexcept + : Chain() { + *this = ::std::move(from); + } + + inline Chain& operator=(const Chain& from) { + CopyFrom(from); + return *this; + } + inline Chain& operator=(Chain&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Chain& default_instance() { + return *internal_default_instance(); + } + static inline const Chain* internal_default_instance() { + return reinterpret_cast( + &_Chain_default_instance_); + } + static constexpr int kIndexInFileMessages = + 13; + + friend void swap(Chain& a, Chain& b) { + a.Swap(&b); + } + inline void Swap(Chain* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Chain* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Chain* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Chain& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Chain& from) { + Chain::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Chain* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Chain"; + } + protected: + explicit Chain(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMessageKeysFieldNumber = 4, + kSenderRatchetKeyFieldNumber = 1, + kSenderRatchetKeyPrivateFieldNumber = 2, + kChainKeyFieldNumber = 3, + }; + // repeated .proto.MessageKey messageKeys = 4; + int messagekeys_size() const; + private: + int _internal_messagekeys_size() const; + public: + void clear_messagekeys(); + ::proto::MessageKey* mutable_messagekeys(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MessageKey >* + mutable_messagekeys(); + private: + const ::proto::MessageKey& _internal_messagekeys(int index) const; + ::proto::MessageKey* _internal_add_messagekeys(); + public: + const ::proto::MessageKey& messagekeys(int index) const; + ::proto::MessageKey* add_messagekeys(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MessageKey >& + messagekeys() const; + + // optional bytes senderRatchetKey = 1; + bool has_senderratchetkey() const; + private: + bool _internal_has_senderratchetkey() const; + public: + void clear_senderratchetkey(); + const std::string& senderratchetkey() const; + template + void set_senderratchetkey(ArgT0&& arg0, ArgT... args); + std::string* mutable_senderratchetkey(); + PROTOBUF_NODISCARD std::string* release_senderratchetkey(); + void set_allocated_senderratchetkey(std::string* senderratchetkey); + private: + const std::string& _internal_senderratchetkey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_senderratchetkey(const std::string& value); + std::string* _internal_mutable_senderratchetkey(); + public: + + // optional bytes senderRatchetKeyPrivate = 2; + bool has_senderratchetkeyprivate() const; + private: + bool _internal_has_senderratchetkeyprivate() const; + public: + void clear_senderratchetkeyprivate(); + const std::string& senderratchetkeyprivate() const; + template + void set_senderratchetkeyprivate(ArgT0&& arg0, ArgT... args); + std::string* mutable_senderratchetkeyprivate(); + PROTOBUF_NODISCARD std::string* release_senderratchetkeyprivate(); + void set_allocated_senderratchetkeyprivate(std::string* senderratchetkeyprivate); + private: + const std::string& _internal_senderratchetkeyprivate() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_senderratchetkeyprivate(const std::string& value); + std::string* _internal_mutable_senderratchetkeyprivate(); + public: + + // optional .proto.ChainKey chainKey = 3; + bool has_chainkey() const; + private: + bool _internal_has_chainkey() const; + public: + void clear_chainkey(); + const ::proto::ChainKey& chainkey() const; + PROTOBUF_NODISCARD ::proto::ChainKey* release_chainkey(); + ::proto::ChainKey* mutable_chainkey(); + void set_allocated_chainkey(::proto::ChainKey* chainkey); + private: + const ::proto::ChainKey& _internal_chainkey() const; + ::proto::ChainKey* _internal_mutable_chainkey(); + public: + void unsafe_arena_set_allocated_chainkey( + ::proto::ChainKey* chainkey); + ::proto::ChainKey* unsafe_arena_release_chainkey(); + + // @@protoc_insertion_point(class_scope:proto.Chain) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MessageKey > messagekeys_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr senderratchetkey_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr senderratchetkeyprivate_; + ::proto::ChainKey* chainkey_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class ChainKey final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ChainKey) */ { + public: + inline ChainKey() : ChainKey(nullptr) {} + ~ChainKey() override; + explicit PROTOBUF_CONSTEXPR ChainKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ChainKey(const ChainKey& from); + ChainKey(ChainKey&& from) noexcept + : ChainKey() { + *this = ::std::move(from); + } + + inline ChainKey& operator=(const ChainKey& from) { + CopyFrom(from); + return *this; + } + inline ChainKey& operator=(ChainKey&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ChainKey& default_instance() { + return *internal_default_instance(); + } + static inline const ChainKey* internal_default_instance() { + return reinterpret_cast( + &_ChainKey_default_instance_); + } + static constexpr int kIndexInFileMessages = + 14; + + friend void swap(ChainKey& a, ChainKey& b) { + a.Swap(&b); + } + inline void Swap(ChainKey* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ChainKey* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ChainKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ChainKey& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const ChainKey& from) { + ChainKey::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ChainKey* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.ChainKey"; + } + protected: + explicit ChainKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kKeyFieldNumber = 2, + kIndexFieldNumber = 1, + }; + // optional bytes key = 2; + bool has_key() const; + private: + bool _internal_has_key() const; + public: + void clear_key(); + const std::string& key() const; + template + void set_key(ArgT0&& arg0, ArgT... args); + std::string* mutable_key(); + PROTOBUF_NODISCARD std::string* release_key(); + void set_allocated_key(std::string* key); + private: + const std::string& _internal_key() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value); + std::string* _internal_mutable_key(); + public: + + // optional uint32 index = 1; + bool has_index() const; + private: + bool _internal_has_index() const; + public: + void clear_index(); + uint32_t index() const; + void set_index(uint32_t value); + private: + uint32_t _internal_index() const; + void _internal_set_index(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.ChainKey) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_; + uint32_t index_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientPayload_DNSSource final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ClientPayload.DNSSource) */ { + public: + inline ClientPayload_DNSSource() : ClientPayload_DNSSource(nullptr) {} + ~ClientPayload_DNSSource() override; + explicit PROTOBUF_CONSTEXPR ClientPayload_DNSSource(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ClientPayload_DNSSource(const ClientPayload_DNSSource& from); + ClientPayload_DNSSource(ClientPayload_DNSSource&& from) noexcept + : ClientPayload_DNSSource() { + *this = ::std::move(from); + } + + inline ClientPayload_DNSSource& operator=(const ClientPayload_DNSSource& from) { + CopyFrom(from); + return *this; + } + inline ClientPayload_DNSSource& operator=(ClientPayload_DNSSource&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ClientPayload_DNSSource& default_instance() { + return *internal_default_instance(); + } + static inline const ClientPayload_DNSSource* internal_default_instance() { + return reinterpret_cast( + &_ClientPayload_DNSSource_default_instance_); + } + static constexpr int kIndexInFileMessages = + 15; + + friend void swap(ClientPayload_DNSSource& a, ClientPayload_DNSSource& b) { + a.Swap(&b); + } + inline void Swap(ClientPayload_DNSSource* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ClientPayload_DNSSource* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ClientPayload_DNSSource* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ClientPayload_DNSSource& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const ClientPayload_DNSSource& from) { + ClientPayload_DNSSource::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ClientPayload_DNSSource* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.ClientPayload.DNSSource"; + } + protected: + explicit ClientPayload_DNSSource(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef ClientPayload_DNSSource_DNSResolutionMethod DNSResolutionMethod; + static constexpr DNSResolutionMethod SYSTEM = + ClientPayload_DNSSource_DNSResolutionMethod_SYSTEM; + static constexpr DNSResolutionMethod GOOGLE = + ClientPayload_DNSSource_DNSResolutionMethod_GOOGLE; + static constexpr DNSResolutionMethod HARDCODED = + ClientPayload_DNSSource_DNSResolutionMethod_HARDCODED; + static constexpr DNSResolutionMethod OVERRIDE = + ClientPayload_DNSSource_DNSResolutionMethod_OVERRIDE; + static constexpr DNSResolutionMethod FALLBACK = + ClientPayload_DNSSource_DNSResolutionMethod_FALLBACK; + static inline bool DNSResolutionMethod_IsValid(int value) { + return ClientPayload_DNSSource_DNSResolutionMethod_IsValid(value); + } + static constexpr DNSResolutionMethod DNSResolutionMethod_MIN = + ClientPayload_DNSSource_DNSResolutionMethod_DNSResolutionMethod_MIN; + static constexpr DNSResolutionMethod DNSResolutionMethod_MAX = + ClientPayload_DNSSource_DNSResolutionMethod_DNSResolutionMethod_MAX; + static constexpr int DNSResolutionMethod_ARRAYSIZE = + ClientPayload_DNSSource_DNSResolutionMethod_DNSResolutionMethod_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + DNSResolutionMethod_descriptor() { + return ClientPayload_DNSSource_DNSResolutionMethod_descriptor(); + } + template + static inline const std::string& DNSResolutionMethod_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function DNSResolutionMethod_Name."); + return ClientPayload_DNSSource_DNSResolutionMethod_Name(enum_t_value); + } + static inline bool DNSResolutionMethod_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + DNSResolutionMethod* value) { + return ClientPayload_DNSSource_DNSResolutionMethod_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kDnsMethodFieldNumber = 15, + kAppCachedFieldNumber = 16, + }; + // optional .proto.ClientPayload.DNSSource.DNSResolutionMethod dnsMethod = 15; + bool has_dnsmethod() const; + private: + bool _internal_has_dnsmethod() const; + public: + void clear_dnsmethod(); + ::proto::ClientPayload_DNSSource_DNSResolutionMethod dnsmethod() const; + void set_dnsmethod(::proto::ClientPayload_DNSSource_DNSResolutionMethod value); + private: + ::proto::ClientPayload_DNSSource_DNSResolutionMethod _internal_dnsmethod() const; + void _internal_set_dnsmethod(::proto::ClientPayload_DNSSource_DNSResolutionMethod value); + public: + + // optional bool appCached = 16; + bool has_appcached() const; + private: + bool _internal_has_appcached() const; + public: + void clear_appcached(); + bool appcached() const; + void set_appcached(bool value); + private: + bool _internal_appcached() const; + void _internal_set_appcached(bool value); + public: + + // @@protoc_insertion_point(class_scope:proto.ClientPayload.DNSSource) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + int dnsmethod_; + bool appcached_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientPayload_DevicePairingRegistrationData final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ClientPayload.DevicePairingRegistrationData) */ { + public: + inline ClientPayload_DevicePairingRegistrationData() : ClientPayload_DevicePairingRegistrationData(nullptr) {} + ~ClientPayload_DevicePairingRegistrationData() override; + explicit PROTOBUF_CONSTEXPR ClientPayload_DevicePairingRegistrationData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ClientPayload_DevicePairingRegistrationData(const ClientPayload_DevicePairingRegistrationData& from); + ClientPayload_DevicePairingRegistrationData(ClientPayload_DevicePairingRegistrationData&& from) noexcept + : ClientPayload_DevicePairingRegistrationData() { + *this = ::std::move(from); + } + + inline ClientPayload_DevicePairingRegistrationData& operator=(const ClientPayload_DevicePairingRegistrationData& from) { + CopyFrom(from); + return *this; + } + inline ClientPayload_DevicePairingRegistrationData& operator=(ClientPayload_DevicePairingRegistrationData&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ClientPayload_DevicePairingRegistrationData& default_instance() { + return *internal_default_instance(); + } + static inline const ClientPayload_DevicePairingRegistrationData* internal_default_instance() { + return reinterpret_cast( + &_ClientPayload_DevicePairingRegistrationData_default_instance_); + } + static constexpr int kIndexInFileMessages = + 16; + + friend void swap(ClientPayload_DevicePairingRegistrationData& a, ClientPayload_DevicePairingRegistrationData& b) { + a.Swap(&b); + } + inline void Swap(ClientPayload_DevicePairingRegistrationData* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ClientPayload_DevicePairingRegistrationData* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ClientPayload_DevicePairingRegistrationData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ClientPayload_DevicePairingRegistrationData& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const ClientPayload_DevicePairingRegistrationData& from) { + ClientPayload_DevicePairingRegistrationData::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ClientPayload_DevicePairingRegistrationData* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.ClientPayload.DevicePairingRegistrationData"; + } + protected: + explicit ClientPayload_DevicePairingRegistrationData(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kERegidFieldNumber = 1, + kEKeytypeFieldNumber = 2, + kEIdentFieldNumber = 3, + kESkeyIdFieldNumber = 4, + kESkeyValFieldNumber = 5, + kESkeySigFieldNumber = 6, + kBuildHashFieldNumber = 7, + kDevicePropsFieldNumber = 8, + }; + // optional bytes eRegid = 1; + bool has_eregid() const; + private: + bool _internal_has_eregid() const; + public: + void clear_eregid(); + const std::string& eregid() const; + template + void set_eregid(ArgT0&& arg0, ArgT... args); + std::string* mutable_eregid(); + PROTOBUF_NODISCARD std::string* release_eregid(); + void set_allocated_eregid(std::string* eregid); + private: + const std::string& _internal_eregid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_eregid(const std::string& value); + std::string* _internal_mutable_eregid(); + public: + + // optional bytes eKeytype = 2; + bool has_ekeytype() const; + private: + bool _internal_has_ekeytype() const; + public: + void clear_ekeytype(); + const std::string& ekeytype() const; + template + void set_ekeytype(ArgT0&& arg0, ArgT... args); + std::string* mutable_ekeytype(); + PROTOBUF_NODISCARD std::string* release_ekeytype(); + void set_allocated_ekeytype(std::string* ekeytype); + private: + const std::string& _internal_ekeytype() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_ekeytype(const std::string& value); + std::string* _internal_mutable_ekeytype(); + public: + + // optional bytes eIdent = 3; + bool has_eident() const; + private: + bool _internal_has_eident() const; + public: + void clear_eident(); + const std::string& eident() const; + template + void set_eident(ArgT0&& arg0, ArgT... args); + std::string* mutable_eident(); + PROTOBUF_NODISCARD std::string* release_eident(); + void set_allocated_eident(std::string* eident); + private: + const std::string& _internal_eident() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_eident(const std::string& value); + std::string* _internal_mutable_eident(); + public: + + // optional bytes eSkeyId = 4; + bool has_eskeyid() const; + private: + bool _internal_has_eskeyid() const; + public: + void clear_eskeyid(); + const std::string& eskeyid() const; + template + void set_eskeyid(ArgT0&& arg0, ArgT... args); + std::string* mutable_eskeyid(); + PROTOBUF_NODISCARD std::string* release_eskeyid(); + void set_allocated_eskeyid(std::string* eskeyid); + private: + const std::string& _internal_eskeyid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_eskeyid(const std::string& value); + std::string* _internal_mutable_eskeyid(); + public: + + // optional bytes eSkeyVal = 5; + bool has_eskeyval() const; + private: + bool _internal_has_eskeyval() const; + public: + void clear_eskeyval(); + const std::string& eskeyval() const; + template + void set_eskeyval(ArgT0&& arg0, ArgT... args); + std::string* mutable_eskeyval(); + PROTOBUF_NODISCARD std::string* release_eskeyval(); + void set_allocated_eskeyval(std::string* eskeyval); + private: + const std::string& _internal_eskeyval() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_eskeyval(const std::string& value); + std::string* _internal_mutable_eskeyval(); + public: + + // optional bytes eSkeySig = 6; + bool has_eskeysig() const; + private: + bool _internal_has_eskeysig() const; + public: + void clear_eskeysig(); + const std::string& eskeysig() const; + template + void set_eskeysig(ArgT0&& arg0, ArgT... args); + std::string* mutable_eskeysig(); + PROTOBUF_NODISCARD std::string* release_eskeysig(); + void set_allocated_eskeysig(std::string* eskeysig); + private: + const std::string& _internal_eskeysig() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_eskeysig(const std::string& value); + std::string* _internal_mutable_eskeysig(); + public: + + // optional bytes buildHash = 7; + bool has_buildhash() const; + private: + bool _internal_has_buildhash() const; + public: + void clear_buildhash(); + const std::string& buildhash() const; + template + void set_buildhash(ArgT0&& arg0, ArgT... args); + std::string* mutable_buildhash(); + PROTOBUF_NODISCARD std::string* release_buildhash(); + void set_allocated_buildhash(std::string* buildhash); + private: + const std::string& _internal_buildhash() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_buildhash(const std::string& value); + std::string* _internal_mutable_buildhash(); + public: + + // optional bytes deviceProps = 8; + bool has_deviceprops() const; + private: + bool _internal_has_deviceprops() const; + public: + void clear_deviceprops(); + const std::string& deviceprops() const; + template + void set_deviceprops(ArgT0&& arg0, ArgT... args); + std::string* mutable_deviceprops(); + PROTOBUF_NODISCARD std::string* release_deviceprops(); + void set_allocated_deviceprops(std::string* deviceprops); + private: + const std::string& _internal_deviceprops() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_deviceprops(const std::string& value); + std::string* _internal_mutable_deviceprops(); + public: + + // @@protoc_insertion_point(class_scope:proto.ClientPayload.DevicePairingRegistrationData) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr eregid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ekeytype_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr eident_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr eskeyid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr eskeyval_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr eskeysig_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr buildhash_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr deviceprops_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientPayload_UserAgent_AppVersion final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ClientPayload.UserAgent.AppVersion) */ { + public: + inline ClientPayload_UserAgent_AppVersion() : ClientPayload_UserAgent_AppVersion(nullptr) {} + ~ClientPayload_UserAgent_AppVersion() override; + explicit PROTOBUF_CONSTEXPR ClientPayload_UserAgent_AppVersion(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ClientPayload_UserAgent_AppVersion(const ClientPayload_UserAgent_AppVersion& from); + ClientPayload_UserAgent_AppVersion(ClientPayload_UserAgent_AppVersion&& from) noexcept + : ClientPayload_UserAgent_AppVersion() { + *this = ::std::move(from); + } + + inline ClientPayload_UserAgent_AppVersion& operator=(const ClientPayload_UserAgent_AppVersion& from) { + CopyFrom(from); + return *this; + } + inline ClientPayload_UserAgent_AppVersion& operator=(ClientPayload_UserAgent_AppVersion&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ClientPayload_UserAgent_AppVersion& default_instance() { + return *internal_default_instance(); + } + static inline const ClientPayload_UserAgent_AppVersion* internal_default_instance() { + return reinterpret_cast( + &_ClientPayload_UserAgent_AppVersion_default_instance_); + } + static constexpr int kIndexInFileMessages = + 17; + + friend void swap(ClientPayload_UserAgent_AppVersion& a, ClientPayload_UserAgent_AppVersion& b) { + a.Swap(&b); + } + inline void Swap(ClientPayload_UserAgent_AppVersion* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ClientPayload_UserAgent_AppVersion* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ClientPayload_UserAgent_AppVersion* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ClientPayload_UserAgent_AppVersion& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const ClientPayload_UserAgent_AppVersion& from) { + ClientPayload_UserAgent_AppVersion::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ClientPayload_UserAgent_AppVersion* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.ClientPayload.UserAgent.AppVersion"; + } + protected: + explicit ClientPayload_UserAgent_AppVersion(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kPrimaryFieldNumber = 1, + kSecondaryFieldNumber = 2, + kTertiaryFieldNumber = 3, + kQuaternaryFieldNumber = 4, + kQuinaryFieldNumber = 5, + }; + // optional uint32 primary = 1; + bool has_primary() const; + private: + bool _internal_has_primary() const; + public: + void clear_primary(); + uint32_t primary() const; + void set_primary(uint32_t value); + private: + uint32_t _internal_primary() const; + void _internal_set_primary(uint32_t value); + public: + + // optional uint32 secondary = 2; + bool has_secondary() const; + private: + bool _internal_has_secondary() const; + public: + void clear_secondary(); + uint32_t secondary() const; + void set_secondary(uint32_t value); + private: + uint32_t _internal_secondary() const; + void _internal_set_secondary(uint32_t value); + public: + + // optional uint32 tertiary = 3; + bool has_tertiary() const; + private: + bool _internal_has_tertiary() const; + public: + void clear_tertiary(); + uint32_t tertiary() const; + void set_tertiary(uint32_t value); + private: + uint32_t _internal_tertiary() const; + void _internal_set_tertiary(uint32_t value); + public: + + // optional uint32 quaternary = 4; + bool has_quaternary() const; + private: + bool _internal_has_quaternary() const; + public: + void clear_quaternary(); + uint32_t quaternary() const; + void set_quaternary(uint32_t value); + private: + uint32_t _internal_quaternary() const; + void _internal_set_quaternary(uint32_t value); + public: + + // optional uint32 quinary = 5; + bool has_quinary() const; + private: + bool _internal_has_quinary() const; + public: + void clear_quinary(); + uint32_t quinary() const; + void set_quinary(uint32_t value); + private: + uint32_t _internal_quinary() const; + void _internal_set_quinary(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.ClientPayload.UserAgent.AppVersion) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + uint32_t primary_; + uint32_t secondary_; + uint32_t tertiary_; + uint32_t quaternary_; + uint32_t quinary_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientPayload_UserAgent final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ClientPayload.UserAgent) */ { + public: + inline ClientPayload_UserAgent() : ClientPayload_UserAgent(nullptr) {} + ~ClientPayload_UserAgent() override; + explicit PROTOBUF_CONSTEXPR ClientPayload_UserAgent(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ClientPayload_UserAgent(const ClientPayload_UserAgent& from); + ClientPayload_UserAgent(ClientPayload_UserAgent&& from) noexcept + : ClientPayload_UserAgent() { + *this = ::std::move(from); + } + + inline ClientPayload_UserAgent& operator=(const ClientPayload_UserAgent& from) { + CopyFrom(from); + return *this; + } + inline ClientPayload_UserAgent& operator=(ClientPayload_UserAgent&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ClientPayload_UserAgent& default_instance() { + return *internal_default_instance(); + } + static inline const ClientPayload_UserAgent* internal_default_instance() { + return reinterpret_cast( + &_ClientPayload_UserAgent_default_instance_); + } + static constexpr int kIndexInFileMessages = + 18; + + friend void swap(ClientPayload_UserAgent& a, ClientPayload_UserAgent& b) { + a.Swap(&b); + } + inline void Swap(ClientPayload_UserAgent* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ClientPayload_UserAgent* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ClientPayload_UserAgent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ClientPayload_UserAgent& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const ClientPayload_UserAgent& from) { + ClientPayload_UserAgent::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ClientPayload_UserAgent* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.ClientPayload.UserAgent"; + } + protected: + explicit ClientPayload_UserAgent(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef ClientPayload_UserAgent_AppVersion AppVersion; + + typedef ClientPayload_UserAgent_Platform Platform; + static constexpr Platform ANDROID = + ClientPayload_UserAgent_Platform_ANDROID; + static constexpr Platform IOS = + ClientPayload_UserAgent_Platform_IOS; + static constexpr Platform WINDOWS_PHONE = + ClientPayload_UserAgent_Platform_WINDOWS_PHONE; + static constexpr Platform BLACKBERRY = + ClientPayload_UserAgent_Platform_BLACKBERRY; + static constexpr Platform BLACKBERRYX = + ClientPayload_UserAgent_Platform_BLACKBERRYX; + static constexpr Platform S40 = + ClientPayload_UserAgent_Platform_S40; + static constexpr Platform S60 = + ClientPayload_UserAgent_Platform_S60; + static constexpr Platform PYTHON_CLIENT = + ClientPayload_UserAgent_Platform_PYTHON_CLIENT; + static constexpr Platform TIZEN = + ClientPayload_UserAgent_Platform_TIZEN; + static constexpr Platform ENTERPRISE = + ClientPayload_UserAgent_Platform_ENTERPRISE; + static constexpr Platform SMB_ANDROID = + ClientPayload_UserAgent_Platform_SMB_ANDROID; + static constexpr Platform KAIOS = + ClientPayload_UserAgent_Platform_KAIOS; + static constexpr Platform SMB_IOS = + ClientPayload_UserAgent_Platform_SMB_IOS; + static constexpr Platform WINDA = + ClientPayload_UserAgent_Platform_WINDOWS; + static constexpr Platform WEB = + ClientPayload_UserAgent_Platform_WEB; + static constexpr Platform PORTAL = + ClientPayload_UserAgent_Platform_PORTAL; + static constexpr Platform GREEN_ANDROID = + ClientPayload_UserAgent_Platform_GREEN_ANDROID; + static constexpr Platform GREEN_IPHONE = + ClientPayload_UserAgent_Platform_GREEN_IPHONE; + static constexpr Platform BLUE_ANDROID = + ClientPayload_UserAgent_Platform_BLUE_ANDROID; + static constexpr Platform BLUE_IPHONE = + ClientPayload_UserAgent_Platform_BLUE_IPHONE; + static constexpr Platform FBLITE_ANDROID = + ClientPayload_UserAgent_Platform_FBLITE_ANDROID; + static constexpr Platform MLITE_ANDROID = + ClientPayload_UserAgent_Platform_MLITE_ANDROID; + static constexpr Platform IGLITE_ANDROID = + ClientPayload_UserAgent_Platform_IGLITE_ANDROID; + static constexpr Platform PAGE = + ClientPayload_UserAgent_Platform_PAGE; + static constexpr Platform MACOS = + ClientPayload_UserAgent_Platform_MACOS; + static constexpr Platform OCULUS_MSG = + ClientPayload_UserAgent_Platform_OCULUS_MSG; + static constexpr Platform OCULUS_CALL = + ClientPayload_UserAgent_Platform_OCULUS_CALL; + static constexpr Platform MILAN = + ClientPayload_UserAgent_Platform_MILAN; + static constexpr Platform CAPI = + ClientPayload_UserAgent_Platform_CAPI; + static inline bool Platform_IsValid(int value) { + return ClientPayload_UserAgent_Platform_IsValid(value); + } + static constexpr Platform Platform_MIN = + ClientPayload_UserAgent_Platform_Platform_MIN; + static constexpr Platform Platform_MAX = + ClientPayload_UserAgent_Platform_Platform_MAX; + static constexpr int Platform_ARRAYSIZE = + ClientPayload_UserAgent_Platform_Platform_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + Platform_descriptor() { + return ClientPayload_UserAgent_Platform_descriptor(); + } + template + static inline const std::string& Platform_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Platform_Name."); + return ClientPayload_UserAgent_Platform_Name(enum_t_value); + } + static inline bool Platform_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Platform* value) { + return ClientPayload_UserAgent_Platform_Parse(name, value); + } + + typedef ClientPayload_UserAgent_ReleaseChannel ReleaseChannel; + static constexpr ReleaseChannel RELEASE = + ClientPayload_UserAgent_ReleaseChannel_RELEASE; + static constexpr ReleaseChannel BETA = + ClientPayload_UserAgent_ReleaseChannel_BETA; + static constexpr ReleaseChannel ALPHA = + ClientPayload_UserAgent_ReleaseChannel_ALPHA; + static constexpr ReleaseChannel DEBUG = + ClientPayload_UserAgent_ReleaseChannel_DEBUG; + static inline bool ReleaseChannel_IsValid(int value) { + return ClientPayload_UserAgent_ReleaseChannel_IsValid(value); + } + static constexpr ReleaseChannel ReleaseChannel_MIN = + ClientPayload_UserAgent_ReleaseChannel_ReleaseChannel_MIN; + static constexpr ReleaseChannel ReleaseChannel_MAX = + ClientPayload_UserAgent_ReleaseChannel_ReleaseChannel_MAX; + static constexpr int ReleaseChannel_ARRAYSIZE = + ClientPayload_UserAgent_ReleaseChannel_ReleaseChannel_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + ReleaseChannel_descriptor() { + return ClientPayload_UserAgent_ReleaseChannel_descriptor(); + } + template + static inline const std::string& ReleaseChannel_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ReleaseChannel_Name."); + return ClientPayload_UserAgent_ReleaseChannel_Name(enum_t_value); + } + static inline bool ReleaseChannel_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + ReleaseChannel* value) { + return ClientPayload_UserAgent_ReleaseChannel_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kMccFieldNumber = 3, + kMncFieldNumber = 4, + kOsVersionFieldNumber = 5, + kManufacturerFieldNumber = 6, + kDeviceFieldNumber = 7, + kOsBuildNumberFieldNumber = 8, + kPhoneIdFieldNumber = 9, + kLocaleLanguageIso6391FieldNumber = 11, + kLocaleCountryIso31661Alpha2FieldNumber = 12, + kDeviceBoardFieldNumber = 13, + kAppVersionFieldNumber = 2, + kPlatformFieldNumber = 1, + kReleaseChannelFieldNumber = 10, + }; + // optional string mcc = 3; + bool has_mcc() const; + private: + bool _internal_has_mcc() const; + public: + void clear_mcc(); + const std::string& mcc() const; + template + void set_mcc(ArgT0&& arg0, ArgT... args); + std::string* mutable_mcc(); + PROTOBUF_NODISCARD std::string* release_mcc(); + void set_allocated_mcc(std::string* mcc); + private: + const std::string& _internal_mcc() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mcc(const std::string& value); + std::string* _internal_mutable_mcc(); + public: + + // optional string mnc = 4; + bool has_mnc() const; + private: + bool _internal_has_mnc() const; + public: + void clear_mnc(); + const std::string& mnc() const; + template + void set_mnc(ArgT0&& arg0, ArgT... args); + std::string* mutable_mnc(); + PROTOBUF_NODISCARD std::string* release_mnc(); + void set_allocated_mnc(std::string* mnc); + private: + const std::string& _internal_mnc() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mnc(const std::string& value); + std::string* _internal_mutable_mnc(); + public: + + // optional string osVersion = 5; + bool has_osversion() const; + private: + bool _internal_has_osversion() const; + public: + void clear_osversion(); + const std::string& osversion() const; + template + void set_osversion(ArgT0&& arg0, ArgT... args); + std::string* mutable_osversion(); + PROTOBUF_NODISCARD std::string* release_osversion(); + void set_allocated_osversion(std::string* osversion); + private: + const std::string& _internal_osversion() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_osversion(const std::string& value); + std::string* _internal_mutable_osversion(); + public: + + // optional string manufacturer = 6; + bool has_manufacturer() const; + private: + bool _internal_has_manufacturer() const; + public: + void clear_manufacturer(); + const std::string& manufacturer() const; + template + void set_manufacturer(ArgT0&& arg0, ArgT... args); + std::string* mutable_manufacturer(); + PROTOBUF_NODISCARD std::string* release_manufacturer(); + void set_allocated_manufacturer(std::string* manufacturer); + private: + const std::string& _internal_manufacturer() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_manufacturer(const std::string& value); + std::string* _internal_mutable_manufacturer(); + public: + + // optional string device = 7; + bool has_device() const; + private: + bool _internal_has_device() const; + public: + void clear_device(); + const std::string& device() const; + template + void set_device(ArgT0&& arg0, ArgT... args); + std::string* mutable_device(); + PROTOBUF_NODISCARD std::string* release_device(); + void set_allocated_device(std::string* device); + private: + const std::string& _internal_device() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_device(const std::string& value); + std::string* _internal_mutable_device(); + public: + + // optional string osBuildNumber = 8; + bool has_osbuildnumber() const; + private: + bool _internal_has_osbuildnumber() const; + public: + void clear_osbuildnumber(); + const std::string& osbuildnumber() const; + template + void set_osbuildnumber(ArgT0&& arg0, ArgT... args); + std::string* mutable_osbuildnumber(); + PROTOBUF_NODISCARD std::string* release_osbuildnumber(); + void set_allocated_osbuildnumber(std::string* osbuildnumber); + private: + const std::string& _internal_osbuildnumber() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_osbuildnumber(const std::string& value); + std::string* _internal_mutable_osbuildnumber(); + public: + + // optional string phoneId = 9; + bool has_phoneid() const; + private: + bool _internal_has_phoneid() const; + public: + void clear_phoneid(); + const std::string& phoneid() const; + template + void set_phoneid(ArgT0&& arg0, ArgT... args); + std::string* mutable_phoneid(); + PROTOBUF_NODISCARD std::string* release_phoneid(); + void set_allocated_phoneid(std::string* phoneid); + private: + const std::string& _internal_phoneid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_phoneid(const std::string& value); + std::string* _internal_mutable_phoneid(); + public: + + // optional string localeLanguageIso6391 = 11; + bool has_localelanguageiso6391() const; + private: + bool _internal_has_localelanguageiso6391() const; + public: + void clear_localelanguageiso6391(); + const std::string& localelanguageiso6391() const; + template + void set_localelanguageiso6391(ArgT0&& arg0, ArgT... args); + std::string* mutable_localelanguageiso6391(); + PROTOBUF_NODISCARD std::string* release_localelanguageiso6391(); + void set_allocated_localelanguageiso6391(std::string* localelanguageiso6391); + private: + const std::string& _internal_localelanguageiso6391() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_localelanguageiso6391(const std::string& value); + std::string* _internal_mutable_localelanguageiso6391(); + public: + + // optional string localeCountryIso31661Alpha2 = 12; + bool has_localecountryiso31661alpha2() const; + private: + bool _internal_has_localecountryiso31661alpha2() const; + public: + void clear_localecountryiso31661alpha2(); + const std::string& localecountryiso31661alpha2() const; + template + void set_localecountryiso31661alpha2(ArgT0&& arg0, ArgT... args); + std::string* mutable_localecountryiso31661alpha2(); + PROTOBUF_NODISCARD std::string* release_localecountryiso31661alpha2(); + void set_allocated_localecountryiso31661alpha2(std::string* localecountryiso31661alpha2); + private: + const std::string& _internal_localecountryiso31661alpha2() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_localecountryiso31661alpha2(const std::string& value); + std::string* _internal_mutable_localecountryiso31661alpha2(); + public: + + // optional string deviceBoard = 13; + bool has_deviceboard() const; + private: + bool _internal_has_deviceboard() const; + public: + void clear_deviceboard(); + const std::string& deviceboard() const; + template + void set_deviceboard(ArgT0&& arg0, ArgT... args); + std::string* mutable_deviceboard(); + PROTOBUF_NODISCARD std::string* release_deviceboard(); + void set_allocated_deviceboard(std::string* deviceboard); + private: + const std::string& _internal_deviceboard() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_deviceboard(const std::string& value); + std::string* _internal_mutable_deviceboard(); + public: + + // optional .proto.ClientPayload.UserAgent.AppVersion appVersion = 2; + bool has_appversion() const; + private: + bool _internal_has_appversion() const; + public: + void clear_appversion(); + const ::proto::ClientPayload_UserAgent_AppVersion& appversion() const; + PROTOBUF_NODISCARD ::proto::ClientPayload_UserAgent_AppVersion* release_appversion(); + ::proto::ClientPayload_UserAgent_AppVersion* mutable_appversion(); + void set_allocated_appversion(::proto::ClientPayload_UserAgent_AppVersion* appversion); + private: + const ::proto::ClientPayload_UserAgent_AppVersion& _internal_appversion() const; + ::proto::ClientPayload_UserAgent_AppVersion* _internal_mutable_appversion(); + public: + void unsafe_arena_set_allocated_appversion( + ::proto::ClientPayload_UserAgent_AppVersion* appversion); + ::proto::ClientPayload_UserAgent_AppVersion* unsafe_arena_release_appversion(); + + // optional .proto.ClientPayload.UserAgent.Platform platform = 1; + bool has_platform() const; + private: + bool _internal_has_platform() const; + public: + void clear_platform(); + ::proto::ClientPayload_UserAgent_Platform platform() const; + void set_platform(::proto::ClientPayload_UserAgent_Platform value); + private: + ::proto::ClientPayload_UserAgent_Platform _internal_platform() const; + void _internal_set_platform(::proto::ClientPayload_UserAgent_Platform value); + public: + + // optional .proto.ClientPayload.UserAgent.ReleaseChannel releaseChannel = 10; + bool has_releasechannel() const; + private: + bool _internal_has_releasechannel() const; + public: + void clear_releasechannel(); + ::proto::ClientPayload_UserAgent_ReleaseChannel releasechannel() const; + void set_releasechannel(::proto::ClientPayload_UserAgent_ReleaseChannel value); + private: + ::proto::ClientPayload_UserAgent_ReleaseChannel _internal_releasechannel() const; + void _internal_set_releasechannel(::proto::ClientPayload_UserAgent_ReleaseChannel value); + public: + + // @@protoc_insertion_point(class_scope:proto.ClientPayload.UserAgent) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mcc_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mnc_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr osversion_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr manufacturer_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr osbuildnumber_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr phoneid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localelanguageiso6391_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localecountryiso31661alpha2_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr deviceboard_; + ::proto::ClientPayload_UserAgent_AppVersion* appversion_; + int platform_; + int releasechannel_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientPayload_WebInfo_WebdPayload final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ClientPayload.WebInfo.WebdPayload) */ { + public: + inline ClientPayload_WebInfo_WebdPayload() : ClientPayload_WebInfo_WebdPayload(nullptr) {} + ~ClientPayload_WebInfo_WebdPayload() override; + explicit PROTOBUF_CONSTEXPR ClientPayload_WebInfo_WebdPayload(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ClientPayload_WebInfo_WebdPayload(const ClientPayload_WebInfo_WebdPayload& from); + ClientPayload_WebInfo_WebdPayload(ClientPayload_WebInfo_WebdPayload&& from) noexcept + : ClientPayload_WebInfo_WebdPayload() { + *this = ::std::move(from); + } + + inline ClientPayload_WebInfo_WebdPayload& operator=(const ClientPayload_WebInfo_WebdPayload& from) { + CopyFrom(from); + return *this; + } + inline ClientPayload_WebInfo_WebdPayload& operator=(ClientPayload_WebInfo_WebdPayload&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ClientPayload_WebInfo_WebdPayload& default_instance() { + return *internal_default_instance(); + } + static inline const ClientPayload_WebInfo_WebdPayload* internal_default_instance() { + return reinterpret_cast( + &_ClientPayload_WebInfo_WebdPayload_default_instance_); + } + static constexpr int kIndexInFileMessages = + 19; + + friend void swap(ClientPayload_WebInfo_WebdPayload& a, ClientPayload_WebInfo_WebdPayload& b) { + a.Swap(&b); + } + inline void Swap(ClientPayload_WebInfo_WebdPayload* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ClientPayload_WebInfo_WebdPayload* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ClientPayload_WebInfo_WebdPayload* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ClientPayload_WebInfo_WebdPayload& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const ClientPayload_WebInfo_WebdPayload& from) { + ClientPayload_WebInfo_WebdPayload::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ClientPayload_WebInfo_WebdPayload* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.ClientPayload.WebInfo.WebdPayload"; + } + protected: + explicit ClientPayload_WebInfo_WebdPayload(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDocumentTypesFieldNumber = 10, + kFeaturesFieldNumber = 11, + kUsesParticipantInKeyFieldNumber = 1, + kSupportsStarredMessagesFieldNumber = 2, + kSupportsDocumentMessagesFieldNumber = 3, + kSupportsUrlMessagesFieldNumber = 4, + kSupportsMediaRetryFieldNumber = 5, + kSupportsE2EImageFieldNumber = 6, + kSupportsE2EVideoFieldNumber = 7, + kSupportsE2EAudioFieldNumber = 8, + kSupportsE2EDocumentFieldNumber = 9, + }; + // optional string documentTypes = 10; + bool has_documenttypes() const; + private: + bool _internal_has_documenttypes() const; + public: + void clear_documenttypes(); + const std::string& documenttypes() const; + template + void set_documenttypes(ArgT0&& arg0, ArgT... args); + std::string* mutable_documenttypes(); + PROTOBUF_NODISCARD std::string* release_documenttypes(); + void set_allocated_documenttypes(std::string* documenttypes); + private: + const std::string& _internal_documenttypes() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_documenttypes(const std::string& value); + std::string* _internal_mutable_documenttypes(); + public: + + // optional bytes features = 11; + bool has_features() const; + private: + bool _internal_has_features() const; + public: + void clear_features(); + const std::string& features() const; + template + void set_features(ArgT0&& arg0, ArgT... args); + std::string* mutable_features(); + PROTOBUF_NODISCARD std::string* release_features(); + void set_allocated_features(std::string* features); + private: + const std::string& _internal_features() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_features(const std::string& value); + std::string* _internal_mutable_features(); + public: + + // optional bool usesParticipantInKey = 1; + bool has_usesparticipantinkey() const; + private: + bool _internal_has_usesparticipantinkey() const; + public: + void clear_usesparticipantinkey(); + bool usesparticipantinkey() const; + void set_usesparticipantinkey(bool value); + private: + bool _internal_usesparticipantinkey() const; + void _internal_set_usesparticipantinkey(bool value); + public: + + // optional bool supportsStarredMessages = 2; + bool has_supportsstarredmessages() const; + private: + bool _internal_has_supportsstarredmessages() const; + public: + void clear_supportsstarredmessages(); + bool supportsstarredmessages() const; + void set_supportsstarredmessages(bool value); + private: + bool _internal_supportsstarredmessages() const; + void _internal_set_supportsstarredmessages(bool value); + public: + + // optional bool supportsDocumentMessages = 3; + bool has_supportsdocumentmessages() const; + private: + bool _internal_has_supportsdocumentmessages() const; + public: + void clear_supportsdocumentmessages(); + bool supportsdocumentmessages() const; + void set_supportsdocumentmessages(bool value); + private: + bool _internal_supportsdocumentmessages() const; + void _internal_set_supportsdocumentmessages(bool value); + public: + + // optional bool supportsUrlMessages = 4; + bool has_supportsurlmessages() const; + private: + bool _internal_has_supportsurlmessages() const; + public: + void clear_supportsurlmessages(); + bool supportsurlmessages() const; + void set_supportsurlmessages(bool value); + private: + bool _internal_supportsurlmessages() const; + void _internal_set_supportsurlmessages(bool value); + public: + + // optional bool supportsMediaRetry = 5; + bool has_supportsmediaretry() const; + private: + bool _internal_has_supportsmediaretry() const; + public: + void clear_supportsmediaretry(); + bool supportsmediaretry() const; + void set_supportsmediaretry(bool value); + private: + bool _internal_supportsmediaretry() const; + void _internal_set_supportsmediaretry(bool value); + public: + + // optional bool supportsE2EImage = 6; + bool has_supportse2eimage() const; + private: + bool _internal_has_supportse2eimage() const; + public: + void clear_supportse2eimage(); + bool supportse2eimage() const; + void set_supportse2eimage(bool value); + private: + bool _internal_supportse2eimage() const; + void _internal_set_supportse2eimage(bool value); + public: + + // optional bool supportsE2EVideo = 7; + bool has_supportse2evideo() const; + private: + bool _internal_has_supportse2evideo() const; + public: + void clear_supportse2evideo(); + bool supportse2evideo() const; + void set_supportse2evideo(bool value); + private: + bool _internal_supportse2evideo() const; + void _internal_set_supportse2evideo(bool value); + public: + + // optional bool supportsE2EAudio = 8; + bool has_supportse2eaudio() const; + private: + bool _internal_has_supportse2eaudio() const; + public: + void clear_supportse2eaudio(); + bool supportse2eaudio() const; + void set_supportse2eaudio(bool value); + private: + bool _internal_supportse2eaudio() const; + void _internal_set_supportse2eaudio(bool value); + public: + + // optional bool supportsE2EDocument = 9; + bool has_supportse2edocument() const; + private: + bool _internal_has_supportse2edocument() const; + public: + void clear_supportse2edocument(); + bool supportse2edocument() const; + void set_supportse2edocument(bool value); + private: + bool _internal_supportse2edocument() const; + void _internal_set_supportse2edocument(bool value); + public: + + // @@protoc_insertion_point(class_scope:proto.ClientPayload.WebInfo.WebdPayload) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr documenttypes_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr features_; + bool usesparticipantinkey_; + bool supportsstarredmessages_; + bool supportsdocumentmessages_; + bool supportsurlmessages_; + bool supportsmediaretry_; + bool supportse2eimage_; + bool supportse2evideo_; + bool supportse2eaudio_; + bool supportse2edocument_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientPayload_WebInfo final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ClientPayload.WebInfo) */ { + public: + inline ClientPayload_WebInfo() : ClientPayload_WebInfo(nullptr) {} + ~ClientPayload_WebInfo() override; + explicit PROTOBUF_CONSTEXPR ClientPayload_WebInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ClientPayload_WebInfo(const ClientPayload_WebInfo& from); + ClientPayload_WebInfo(ClientPayload_WebInfo&& from) noexcept + : ClientPayload_WebInfo() { + *this = ::std::move(from); + } + + inline ClientPayload_WebInfo& operator=(const ClientPayload_WebInfo& from) { + CopyFrom(from); + return *this; + } + inline ClientPayload_WebInfo& operator=(ClientPayload_WebInfo&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ClientPayload_WebInfo& default_instance() { + return *internal_default_instance(); + } + static inline const ClientPayload_WebInfo* internal_default_instance() { + return reinterpret_cast( + &_ClientPayload_WebInfo_default_instance_); + } + static constexpr int kIndexInFileMessages = + 20; + + friend void swap(ClientPayload_WebInfo& a, ClientPayload_WebInfo& b) { + a.Swap(&b); + } + inline void Swap(ClientPayload_WebInfo* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ClientPayload_WebInfo* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ClientPayload_WebInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ClientPayload_WebInfo& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const ClientPayload_WebInfo& from) { + ClientPayload_WebInfo::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ClientPayload_WebInfo* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.ClientPayload.WebInfo"; + } + protected: + explicit ClientPayload_WebInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef ClientPayload_WebInfo_WebdPayload WebdPayload; + + typedef ClientPayload_WebInfo_WebSubPlatform WebSubPlatform; + static constexpr WebSubPlatform WEB_BROWSER = + ClientPayload_WebInfo_WebSubPlatform_WEB_BROWSER; + static constexpr WebSubPlatform APP_STORE = + ClientPayload_WebInfo_WebSubPlatform_APP_STORE; + static constexpr WebSubPlatform WIN_STORE = + ClientPayload_WebInfo_WebSubPlatform_WIN_STORE; + static constexpr WebSubPlatform DARWIN = + ClientPayload_WebInfo_WebSubPlatform_DARWIN; + static constexpr WebSubPlatform WINDA = + ClientPayload_WebInfo_WebSubPlatform_WINDA; + static inline bool WebSubPlatform_IsValid(int value) { + return ClientPayload_WebInfo_WebSubPlatform_IsValid(value); + } + static constexpr WebSubPlatform WebSubPlatform_MIN = + ClientPayload_WebInfo_WebSubPlatform_WebSubPlatform_MIN; + static constexpr WebSubPlatform WebSubPlatform_MAX = + ClientPayload_WebInfo_WebSubPlatform_WebSubPlatform_MAX; + static constexpr int WebSubPlatform_ARRAYSIZE = + ClientPayload_WebInfo_WebSubPlatform_WebSubPlatform_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + WebSubPlatform_descriptor() { + return ClientPayload_WebInfo_WebSubPlatform_descriptor(); + } + template + static inline const std::string& WebSubPlatform_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function WebSubPlatform_Name."); + return ClientPayload_WebInfo_WebSubPlatform_Name(enum_t_value); + } + static inline bool WebSubPlatform_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + WebSubPlatform* value) { + return ClientPayload_WebInfo_WebSubPlatform_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kRefTokenFieldNumber = 1, + kVersionFieldNumber = 2, + kWebdPayloadFieldNumber = 3, + kWebSubPlatformFieldNumber = 4, + }; + // optional string refToken = 1; + bool has_reftoken() const; + private: + bool _internal_has_reftoken() const; + public: + void clear_reftoken(); + const std::string& reftoken() const; + template + void set_reftoken(ArgT0&& arg0, ArgT... args); + std::string* mutable_reftoken(); + PROTOBUF_NODISCARD std::string* release_reftoken(); + void set_allocated_reftoken(std::string* reftoken); + private: + const std::string& _internal_reftoken() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_reftoken(const std::string& value); + std::string* _internal_mutable_reftoken(); + public: + + // optional string version = 2; + bool has_version() const; + private: + bool _internal_has_version() const; + public: + void clear_version(); + const std::string& version() const; + template + void set_version(ArgT0&& arg0, ArgT... args); + std::string* mutable_version(); + PROTOBUF_NODISCARD std::string* release_version(); + void set_allocated_version(std::string* version); + private: + const std::string& _internal_version() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(const std::string& value); + std::string* _internal_mutable_version(); + public: + + // optional .proto.ClientPayload.WebInfo.WebdPayload webdPayload = 3; + bool has_webdpayload() const; + private: + bool _internal_has_webdpayload() const; + public: + void clear_webdpayload(); + const ::proto::ClientPayload_WebInfo_WebdPayload& webdpayload() const; + PROTOBUF_NODISCARD ::proto::ClientPayload_WebInfo_WebdPayload* release_webdpayload(); + ::proto::ClientPayload_WebInfo_WebdPayload* mutable_webdpayload(); + void set_allocated_webdpayload(::proto::ClientPayload_WebInfo_WebdPayload* webdpayload); + private: + const ::proto::ClientPayload_WebInfo_WebdPayload& _internal_webdpayload() const; + ::proto::ClientPayload_WebInfo_WebdPayload* _internal_mutable_webdpayload(); + public: + void unsafe_arena_set_allocated_webdpayload( + ::proto::ClientPayload_WebInfo_WebdPayload* webdpayload); + ::proto::ClientPayload_WebInfo_WebdPayload* unsafe_arena_release_webdpayload(); + + // optional .proto.ClientPayload.WebInfo.WebSubPlatform webSubPlatform = 4; + bool has_websubplatform() const; + private: + bool _internal_has_websubplatform() const; + public: + void clear_websubplatform(); + ::proto::ClientPayload_WebInfo_WebSubPlatform websubplatform() const; + void set_websubplatform(::proto::ClientPayload_WebInfo_WebSubPlatform value); + private: + ::proto::ClientPayload_WebInfo_WebSubPlatform _internal_websubplatform() const; + void _internal_set_websubplatform(::proto::ClientPayload_WebInfo_WebSubPlatform value); + public: + + // @@protoc_insertion_point(class_scope:proto.ClientPayload.WebInfo) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr reftoken_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_; + ::proto::ClientPayload_WebInfo_WebdPayload* webdpayload_; + int websubplatform_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientPayload final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ClientPayload) */ { + public: + inline ClientPayload() : ClientPayload(nullptr) {} + ~ClientPayload() override; + explicit PROTOBUF_CONSTEXPR ClientPayload(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ClientPayload(const ClientPayload& from); + ClientPayload(ClientPayload&& from) noexcept + : ClientPayload() { + *this = ::std::move(from); + } + + inline ClientPayload& operator=(const ClientPayload& from) { + CopyFrom(from); + return *this; + } + inline ClientPayload& operator=(ClientPayload&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ClientPayload& default_instance() { + return *internal_default_instance(); + } + static inline const ClientPayload* internal_default_instance() { + return reinterpret_cast( + &_ClientPayload_default_instance_); + } + static constexpr int kIndexInFileMessages = + 21; + + friend void swap(ClientPayload& a, ClientPayload& b) { + a.Swap(&b); + } + inline void Swap(ClientPayload* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ClientPayload* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ClientPayload* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ClientPayload& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const ClientPayload& from) { + ClientPayload::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ClientPayload* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.ClientPayload"; + } + protected: + explicit ClientPayload(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef ClientPayload_DNSSource DNSSource; + typedef ClientPayload_DevicePairingRegistrationData DevicePairingRegistrationData; + typedef ClientPayload_UserAgent UserAgent; + typedef ClientPayload_WebInfo WebInfo; + + typedef ClientPayload_ConnectReason ConnectReason; + static constexpr ConnectReason PUSH = + ClientPayload_ConnectReason_PUSH; + static constexpr ConnectReason USER_ACTIVATED = + ClientPayload_ConnectReason_USER_ACTIVATED; + static constexpr ConnectReason SCHEDULED = + ClientPayload_ConnectReason_SCHEDULED; + static constexpr ConnectReason ERROR_RECONNECT = + ClientPayload_ConnectReason_ERROR_RECONNECT; + static constexpr ConnectReason NETWORK_SWITCH = + ClientPayload_ConnectReason_NETWORK_SWITCH; + static constexpr ConnectReason PING_RECONNECT = + ClientPayload_ConnectReason_PING_RECONNECT; + static inline bool ConnectReason_IsValid(int value) { + return ClientPayload_ConnectReason_IsValid(value); + } + static constexpr ConnectReason ConnectReason_MIN = + ClientPayload_ConnectReason_ConnectReason_MIN; + static constexpr ConnectReason ConnectReason_MAX = + ClientPayload_ConnectReason_ConnectReason_MAX; + static constexpr int ConnectReason_ARRAYSIZE = + ClientPayload_ConnectReason_ConnectReason_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + ConnectReason_descriptor() { + return ClientPayload_ConnectReason_descriptor(); + } + template + static inline const std::string& ConnectReason_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ConnectReason_Name."); + return ClientPayload_ConnectReason_Name(enum_t_value); + } + static inline bool ConnectReason_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + ConnectReason* value) { + return ClientPayload_ConnectReason_Parse(name, value); + } + + typedef ClientPayload_ConnectType ConnectType; + static constexpr ConnectType CELLULAR_UNKNOWN = + ClientPayload_ConnectType_CELLULAR_UNKNOWN; + static constexpr ConnectType WIFI_UNKNOWN = + ClientPayload_ConnectType_WIFI_UNKNOWN; + static constexpr ConnectType CELLULAR_EDGE = + ClientPayload_ConnectType_CELLULAR_EDGE; + static constexpr ConnectType CELLULAR_IDEN = + ClientPayload_ConnectType_CELLULAR_IDEN; + static constexpr ConnectType CELLULAR_UMTS = + ClientPayload_ConnectType_CELLULAR_UMTS; + static constexpr ConnectType CELLULAR_EVDO = + ClientPayload_ConnectType_CELLULAR_EVDO; + static constexpr ConnectType CELLULAR_GPRS = + ClientPayload_ConnectType_CELLULAR_GPRS; + static constexpr ConnectType CELLULAR_HSDPA = + ClientPayload_ConnectType_CELLULAR_HSDPA; + static constexpr ConnectType CELLULAR_HSUPA = + ClientPayload_ConnectType_CELLULAR_HSUPA; + static constexpr ConnectType CELLULAR_HSPA = + ClientPayload_ConnectType_CELLULAR_HSPA; + static constexpr ConnectType CELLULAR_CDMA = + ClientPayload_ConnectType_CELLULAR_CDMA; + static constexpr ConnectType CELLULAR_1XRTT = + ClientPayload_ConnectType_CELLULAR_1XRTT; + static constexpr ConnectType CELLULAR_EHRPD = + ClientPayload_ConnectType_CELLULAR_EHRPD; + static constexpr ConnectType CELLULAR_LTE = + ClientPayload_ConnectType_CELLULAR_LTE; + static constexpr ConnectType CELLULAR_HSPAP = + ClientPayload_ConnectType_CELLULAR_HSPAP; + static inline bool ConnectType_IsValid(int value) { + return ClientPayload_ConnectType_IsValid(value); + } + static constexpr ConnectType ConnectType_MIN = + ClientPayload_ConnectType_ConnectType_MIN; + static constexpr ConnectType ConnectType_MAX = + ClientPayload_ConnectType_ConnectType_MAX; + static constexpr int ConnectType_ARRAYSIZE = + ClientPayload_ConnectType_ConnectType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + ConnectType_descriptor() { + return ClientPayload_ConnectType_descriptor(); + } + template + static inline const std::string& ConnectType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ConnectType_Name."); + return ClientPayload_ConnectType_Name(enum_t_value); + } + static inline bool ConnectType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + ConnectType* value) { + return ClientPayload_ConnectType_Parse(name, value); + } + + typedef ClientPayload_IOSAppExtension IOSAppExtension; + static constexpr IOSAppExtension SHARE_EXTENSION = + ClientPayload_IOSAppExtension_SHARE_EXTENSION; + static constexpr IOSAppExtension SERVICE_EXTENSION = + ClientPayload_IOSAppExtension_SERVICE_EXTENSION; + static constexpr IOSAppExtension INTENTS_EXTENSION = + ClientPayload_IOSAppExtension_INTENTS_EXTENSION; + static inline bool IOSAppExtension_IsValid(int value) { + return ClientPayload_IOSAppExtension_IsValid(value); + } + static constexpr IOSAppExtension IOSAppExtension_MIN = + ClientPayload_IOSAppExtension_IOSAppExtension_MIN; + static constexpr IOSAppExtension IOSAppExtension_MAX = + ClientPayload_IOSAppExtension_IOSAppExtension_MAX; + static constexpr int IOSAppExtension_ARRAYSIZE = + ClientPayload_IOSAppExtension_IOSAppExtension_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + IOSAppExtension_descriptor() { + return ClientPayload_IOSAppExtension_descriptor(); + } + template + static inline const std::string& IOSAppExtension_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function IOSAppExtension_Name."); + return ClientPayload_IOSAppExtension_Name(enum_t_value); + } + static inline bool IOSAppExtension_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + IOSAppExtension* value) { + return ClientPayload_IOSAppExtension_Parse(name, value); + } + + typedef ClientPayload_Product Product; + static constexpr Product WHATSAPP = + ClientPayload_Product_WHATSAPP; + static constexpr Product MESSENGER = + ClientPayload_Product_MESSENGER; + static inline bool Product_IsValid(int value) { + return ClientPayload_Product_IsValid(value); + } + static constexpr Product Product_MIN = + ClientPayload_Product_Product_MIN; + static constexpr Product Product_MAX = + ClientPayload_Product_Product_MAX; + static constexpr int Product_ARRAYSIZE = + ClientPayload_Product_Product_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + Product_descriptor() { + return ClientPayload_Product_descriptor(); + } + template + static inline const std::string& Product_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Product_Name."); + return ClientPayload_Product_Name(enum_t_value); + } + static inline bool Product_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Product* value) { + return ClientPayload_Product_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kShardsFieldNumber = 14, + kPushNameFieldNumber = 7, + kFbCatFieldNumber = 21, + kFbUserAgentFieldNumber = 22, + kFbDeviceIdFieldNumber = 32, + kPaddingBytesFieldNumber = 34, + kUserAgentFieldNumber = 5, + kWebInfoFieldNumber = 6, + kDnsSourceFieldNumber = 15, + kDevicePairingDataFieldNumber = 19, + kUsernameFieldNumber = 1, + kSessionIdFieldNumber = 9, + kConnectTypeFieldNumber = 12, + kConnectReasonFieldNumber = 13, + kConnectAttemptCountFieldNumber = 16, + kPassiveFieldNumber = 3, + kShortConnectFieldNumber = 10, + kOcFieldNumber = 23, + kPullFieldNumber = 33, + kDeviceFieldNumber = 18, + kProductFieldNumber = 20, + kLcFieldNumber = 24, + kFbAppIdFieldNumber = 31, + kIosAppExtensionFieldNumber = 30, + }; + // repeated int32 shards = 14; + int shards_size() const; + private: + int _internal_shards_size() const; + public: + void clear_shards(); + private: + int32_t _internal_shards(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& + _internal_shards() const; + void _internal_add_shards(int32_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* + _internal_mutable_shards(); + public: + int32_t shards(int index) const; + void set_shards(int index, int32_t value); + void add_shards(int32_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& + shards() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* + mutable_shards(); + + // optional string pushName = 7; + bool has_pushname() const; + private: + bool _internal_has_pushname() const; + public: + void clear_pushname(); + const std::string& pushname() const; + template + void set_pushname(ArgT0&& arg0, ArgT... args); + std::string* mutable_pushname(); + PROTOBUF_NODISCARD std::string* release_pushname(); + void set_allocated_pushname(std::string* pushname); + private: + const std::string& _internal_pushname() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_pushname(const std::string& value); + std::string* _internal_mutable_pushname(); + public: + + // optional bytes fbCat = 21; + bool has_fbcat() const; + private: + bool _internal_has_fbcat() const; + public: + void clear_fbcat(); + const std::string& fbcat() const; + template + void set_fbcat(ArgT0&& arg0, ArgT... args); + std::string* mutable_fbcat(); + PROTOBUF_NODISCARD std::string* release_fbcat(); + void set_allocated_fbcat(std::string* fbcat); + private: + const std::string& _internal_fbcat() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_fbcat(const std::string& value); + std::string* _internal_mutable_fbcat(); + public: + + // optional bytes fbUserAgent = 22; + bool has_fbuseragent() const; + private: + bool _internal_has_fbuseragent() const; + public: + void clear_fbuseragent(); + const std::string& fbuseragent() const; + template + void set_fbuseragent(ArgT0&& arg0, ArgT... args); + std::string* mutable_fbuseragent(); + PROTOBUF_NODISCARD std::string* release_fbuseragent(); + void set_allocated_fbuseragent(std::string* fbuseragent); + private: + const std::string& _internal_fbuseragent() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_fbuseragent(const std::string& value); + std::string* _internal_mutable_fbuseragent(); + public: + + // optional bytes fbDeviceId = 32; + bool has_fbdeviceid() const; + private: + bool _internal_has_fbdeviceid() const; + public: + void clear_fbdeviceid(); + const std::string& fbdeviceid() const; + template + void set_fbdeviceid(ArgT0&& arg0, ArgT... args); + std::string* mutable_fbdeviceid(); + PROTOBUF_NODISCARD std::string* release_fbdeviceid(); + void set_allocated_fbdeviceid(std::string* fbdeviceid); + private: + const std::string& _internal_fbdeviceid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_fbdeviceid(const std::string& value); + std::string* _internal_mutable_fbdeviceid(); + public: + + // optional bytes paddingBytes = 34; + bool has_paddingbytes() const; + private: + bool _internal_has_paddingbytes() const; + public: + void clear_paddingbytes(); + const std::string& paddingbytes() const; + template + void set_paddingbytes(ArgT0&& arg0, ArgT... args); + std::string* mutable_paddingbytes(); + PROTOBUF_NODISCARD std::string* release_paddingbytes(); + void set_allocated_paddingbytes(std::string* paddingbytes); + private: + const std::string& _internal_paddingbytes() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_paddingbytes(const std::string& value); + std::string* _internal_mutable_paddingbytes(); + public: + + // optional .proto.ClientPayload.UserAgent userAgent = 5; + bool has_useragent() const; + private: + bool _internal_has_useragent() const; + public: + void clear_useragent(); + const ::proto::ClientPayload_UserAgent& useragent() const; + PROTOBUF_NODISCARD ::proto::ClientPayload_UserAgent* release_useragent(); + ::proto::ClientPayload_UserAgent* mutable_useragent(); + void set_allocated_useragent(::proto::ClientPayload_UserAgent* useragent); + private: + const ::proto::ClientPayload_UserAgent& _internal_useragent() const; + ::proto::ClientPayload_UserAgent* _internal_mutable_useragent(); + public: + void unsafe_arena_set_allocated_useragent( + ::proto::ClientPayload_UserAgent* useragent); + ::proto::ClientPayload_UserAgent* unsafe_arena_release_useragent(); + + // optional .proto.ClientPayload.WebInfo webInfo = 6; + bool has_webinfo() const; + private: + bool _internal_has_webinfo() const; + public: + void clear_webinfo(); + const ::proto::ClientPayload_WebInfo& webinfo() const; + PROTOBUF_NODISCARD ::proto::ClientPayload_WebInfo* release_webinfo(); + ::proto::ClientPayload_WebInfo* mutable_webinfo(); + void set_allocated_webinfo(::proto::ClientPayload_WebInfo* webinfo); + private: + const ::proto::ClientPayload_WebInfo& _internal_webinfo() const; + ::proto::ClientPayload_WebInfo* _internal_mutable_webinfo(); + public: + void unsafe_arena_set_allocated_webinfo( + ::proto::ClientPayload_WebInfo* webinfo); + ::proto::ClientPayload_WebInfo* unsafe_arena_release_webinfo(); + + // optional .proto.ClientPayload.DNSSource dnsSource = 15; + bool has_dnssource() const; + private: + bool _internal_has_dnssource() const; + public: + void clear_dnssource(); + const ::proto::ClientPayload_DNSSource& dnssource() const; + PROTOBUF_NODISCARD ::proto::ClientPayload_DNSSource* release_dnssource(); + ::proto::ClientPayload_DNSSource* mutable_dnssource(); + void set_allocated_dnssource(::proto::ClientPayload_DNSSource* dnssource); + private: + const ::proto::ClientPayload_DNSSource& _internal_dnssource() const; + ::proto::ClientPayload_DNSSource* _internal_mutable_dnssource(); + public: + void unsafe_arena_set_allocated_dnssource( + ::proto::ClientPayload_DNSSource* dnssource); + ::proto::ClientPayload_DNSSource* unsafe_arena_release_dnssource(); + + // optional .proto.ClientPayload.DevicePairingRegistrationData devicePairingData = 19; + bool has_devicepairingdata() const; + private: + bool _internal_has_devicepairingdata() const; + public: + void clear_devicepairingdata(); + const ::proto::ClientPayload_DevicePairingRegistrationData& devicepairingdata() const; + PROTOBUF_NODISCARD ::proto::ClientPayload_DevicePairingRegistrationData* release_devicepairingdata(); + ::proto::ClientPayload_DevicePairingRegistrationData* mutable_devicepairingdata(); + void set_allocated_devicepairingdata(::proto::ClientPayload_DevicePairingRegistrationData* devicepairingdata); + private: + const ::proto::ClientPayload_DevicePairingRegistrationData& _internal_devicepairingdata() const; + ::proto::ClientPayload_DevicePairingRegistrationData* _internal_mutable_devicepairingdata(); + public: + void unsafe_arena_set_allocated_devicepairingdata( + ::proto::ClientPayload_DevicePairingRegistrationData* devicepairingdata); + ::proto::ClientPayload_DevicePairingRegistrationData* unsafe_arena_release_devicepairingdata(); + + // optional uint64 username = 1; + bool has_username() const; + private: + bool _internal_has_username() const; + public: + void clear_username(); + uint64_t username() const; + void set_username(uint64_t value); + private: + uint64_t _internal_username() const; + void _internal_set_username(uint64_t value); + public: + + // optional sfixed32 sessionId = 9; + bool has_sessionid() const; + private: + bool _internal_has_sessionid() const; + public: + void clear_sessionid(); + int32_t sessionid() const; + void set_sessionid(int32_t value); + private: + int32_t _internal_sessionid() const; + void _internal_set_sessionid(int32_t value); + public: + + // optional .proto.ClientPayload.ConnectType connectType = 12; + bool has_connecttype() const; + private: + bool _internal_has_connecttype() const; + public: + void clear_connecttype(); + ::proto::ClientPayload_ConnectType connecttype() const; + void set_connecttype(::proto::ClientPayload_ConnectType value); + private: + ::proto::ClientPayload_ConnectType _internal_connecttype() const; + void _internal_set_connecttype(::proto::ClientPayload_ConnectType value); + public: + + // optional .proto.ClientPayload.ConnectReason connectReason = 13; + bool has_connectreason() const; + private: + bool _internal_has_connectreason() const; + public: + void clear_connectreason(); + ::proto::ClientPayload_ConnectReason connectreason() const; + void set_connectreason(::proto::ClientPayload_ConnectReason value); + private: + ::proto::ClientPayload_ConnectReason _internal_connectreason() const; + void _internal_set_connectreason(::proto::ClientPayload_ConnectReason value); + public: + + // optional uint32 connectAttemptCount = 16; + bool has_connectattemptcount() const; + private: + bool _internal_has_connectattemptcount() const; + public: + void clear_connectattemptcount(); + uint32_t connectattemptcount() const; + void set_connectattemptcount(uint32_t value); + private: + uint32_t _internal_connectattemptcount() const; + void _internal_set_connectattemptcount(uint32_t value); + public: + + // optional bool passive = 3; + bool has_passive() const; + private: + bool _internal_has_passive() const; + public: + void clear_passive(); + bool passive() const; + void set_passive(bool value); + private: + bool _internal_passive() const; + void _internal_set_passive(bool value); + public: + + // optional bool shortConnect = 10; + bool has_shortconnect() const; + private: + bool _internal_has_shortconnect() const; + public: + void clear_shortconnect(); + bool shortconnect() const; + void set_shortconnect(bool value); + private: + bool _internal_shortconnect() const; + void _internal_set_shortconnect(bool value); + public: + + // optional bool oc = 23; + bool has_oc() const; + private: + bool _internal_has_oc() const; + public: + void clear_oc(); + bool oc() const; + void set_oc(bool value); + private: + bool _internal_oc() const; + void _internal_set_oc(bool value); + public: + + // optional bool pull = 33; + bool has_pull() const; + private: + bool _internal_has_pull() const; + public: + void clear_pull(); + bool pull() const; + void set_pull(bool value); + private: + bool _internal_pull() const; + void _internal_set_pull(bool value); + public: + + // optional uint32 device = 18; + bool has_device() const; + private: + bool _internal_has_device() const; + public: + void clear_device(); + uint32_t device() const; + void set_device(uint32_t value); + private: + uint32_t _internal_device() const; + void _internal_set_device(uint32_t value); + public: + + // optional .proto.ClientPayload.Product product = 20; + bool has_product() const; + private: + bool _internal_has_product() const; + public: + void clear_product(); + ::proto::ClientPayload_Product product() const; + void set_product(::proto::ClientPayload_Product value); + private: + ::proto::ClientPayload_Product _internal_product() const; + void _internal_set_product(::proto::ClientPayload_Product value); + public: + + // optional int32 lc = 24; + bool has_lc() const; + private: + bool _internal_has_lc() const; + public: + void clear_lc(); + int32_t lc() const; + void set_lc(int32_t value); + private: + int32_t _internal_lc() const; + void _internal_set_lc(int32_t value); + public: + + // optional uint64 fbAppId = 31; + bool has_fbappid() const; + private: + bool _internal_has_fbappid() const; + public: + void clear_fbappid(); + uint64_t fbappid() const; + void set_fbappid(uint64_t value); + private: + uint64_t _internal_fbappid() const; + void _internal_set_fbappid(uint64_t value); + public: + + // optional .proto.ClientPayload.IOSAppExtension iosAppExtension = 30; + bool has_iosappextension() const; + private: + bool _internal_has_iosappextension() const; + public: + void clear_iosappextension(); + ::proto::ClientPayload_IOSAppExtension iosappextension() const; + void set_iosappextension(::proto::ClientPayload_IOSAppExtension value); + private: + ::proto::ClientPayload_IOSAppExtension _internal_iosappextension() const; + void _internal_set_iosappextension(::proto::ClientPayload_IOSAppExtension value); + public: + + // @@protoc_insertion_point(class_scope:proto.ClientPayload) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > shards_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pushname_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fbcat_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fbuseragent_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fbdeviceid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr paddingbytes_; + ::proto::ClientPayload_UserAgent* useragent_; + ::proto::ClientPayload_WebInfo* webinfo_; + ::proto::ClientPayload_DNSSource* dnssource_; + ::proto::ClientPayload_DevicePairingRegistrationData* devicepairingdata_; + uint64_t username_; + int32_t sessionid_; + int connecttype_; + int connectreason_; + uint32_t connectattemptcount_; + bool passive_; + bool shortconnect_; + bool oc_; + bool pull_; + uint32_t device_; + int product_; + int32_t lc_; + uint64_t fbappid_; + int iosappextension_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class ContextInfo_AdReplyInfo final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ContextInfo.AdReplyInfo) */ { + public: + inline ContextInfo_AdReplyInfo() : ContextInfo_AdReplyInfo(nullptr) {} + ~ContextInfo_AdReplyInfo() override; + explicit PROTOBUF_CONSTEXPR ContextInfo_AdReplyInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ContextInfo_AdReplyInfo(const ContextInfo_AdReplyInfo& from); + ContextInfo_AdReplyInfo(ContextInfo_AdReplyInfo&& from) noexcept + : ContextInfo_AdReplyInfo() { + *this = ::std::move(from); + } + + inline ContextInfo_AdReplyInfo& operator=(const ContextInfo_AdReplyInfo& from) { + CopyFrom(from); + return *this; + } + inline ContextInfo_AdReplyInfo& operator=(ContextInfo_AdReplyInfo&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ContextInfo_AdReplyInfo& default_instance() { + return *internal_default_instance(); + } + static inline const ContextInfo_AdReplyInfo* internal_default_instance() { + return reinterpret_cast( + &_ContextInfo_AdReplyInfo_default_instance_); + } + static constexpr int kIndexInFileMessages = + 22; + + friend void swap(ContextInfo_AdReplyInfo& a, ContextInfo_AdReplyInfo& b) { + a.Swap(&b); + } + inline void Swap(ContextInfo_AdReplyInfo* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ContextInfo_AdReplyInfo* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ContextInfo_AdReplyInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ContextInfo_AdReplyInfo& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const ContextInfo_AdReplyInfo& from) { + ContextInfo_AdReplyInfo::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ContextInfo_AdReplyInfo* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.ContextInfo.AdReplyInfo"; + } + protected: + explicit ContextInfo_AdReplyInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef ContextInfo_AdReplyInfo_MediaType MediaType; + static constexpr MediaType NONE = + ContextInfo_AdReplyInfo_MediaType_NONE; + static constexpr MediaType IMAGE = + ContextInfo_AdReplyInfo_MediaType_IMAGE; + static constexpr MediaType VIDEO = + ContextInfo_AdReplyInfo_MediaType_VIDEO; + static inline bool MediaType_IsValid(int value) { + return ContextInfo_AdReplyInfo_MediaType_IsValid(value); + } + static constexpr MediaType MediaType_MIN = + ContextInfo_AdReplyInfo_MediaType_MediaType_MIN; + static constexpr MediaType MediaType_MAX = + ContextInfo_AdReplyInfo_MediaType_MediaType_MAX; + static constexpr int MediaType_ARRAYSIZE = + ContextInfo_AdReplyInfo_MediaType_MediaType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + MediaType_descriptor() { + return ContextInfo_AdReplyInfo_MediaType_descriptor(); + } + template + static inline const std::string& MediaType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function MediaType_Name."); + return ContextInfo_AdReplyInfo_MediaType_Name(enum_t_value); + } + static inline bool MediaType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + MediaType* value) { + return ContextInfo_AdReplyInfo_MediaType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kAdvertiserNameFieldNumber = 1, + kJpegThumbnailFieldNumber = 16, + kCaptionFieldNumber = 17, + kMediaTypeFieldNumber = 2, + }; + // optional string advertiserName = 1; + bool has_advertisername() const; + private: + bool _internal_has_advertisername() const; + public: + void clear_advertisername(); + const std::string& advertisername() const; + template + void set_advertisername(ArgT0&& arg0, ArgT... args); + std::string* mutable_advertisername(); + PROTOBUF_NODISCARD std::string* release_advertisername(); + void set_allocated_advertisername(std::string* advertisername); + private: + const std::string& _internal_advertisername() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_advertisername(const std::string& value); + std::string* _internal_mutable_advertisername(); + public: + + // optional bytes jpegThumbnail = 16; + bool has_jpegthumbnail() const; + private: + bool _internal_has_jpegthumbnail() const; + public: + void clear_jpegthumbnail(); + const std::string& jpegthumbnail() const; + template + void set_jpegthumbnail(ArgT0&& arg0, ArgT... args); + std::string* mutable_jpegthumbnail(); + PROTOBUF_NODISCARD std::string* release_jpegthumbnail(); + void set_allocated_jpegthumbnail(std::string* jpegthumbnail); + private: + const std::string& _internal_jpegthumbnail() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value); + std::string* _internal_mutable_jpegthumbnail(); + public: + + // optional string caption = 17; + bool has_caption() const; + private: + bool _internal_has_caption() const; + public: + void clear_caption(); + const std::string& caption() const; + template + void set_caption(ArgT0&& arg0, ArgT... args); + std::string* mutable_caption(); + PROTOBUF_NODISCARD std::string* release_caption(); + void set_allocated_caption(std::string* caption); + private: + const std::string& _internal_caption() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_caption(const std::string& value); + std::string* _internal_mutable_caption(); + public: + + // optional .proto.ContextInfo.AdReplyInfo.MediaType mediaType = 2; + bool has_mediatype() const; + private: + bool _internal_has_mediatype() const; + public: + void clear_mediatype(); + ::proto::ContextInfo_AdReplyInfo_MediaType mediatype() const; + void set_mediatype(::proto::ContextInfo_AdReplyInfo_MediaType value); + private: + ::proto::ContextInfo_AdReplyInfo_MediaType _internal_mediatype() const; + void _internal_set_mediatype(::proto::ContextInfo_AdReplyInfo_MediaType value); + public: + + // @@protoc_insertion_point(class_scope:proto.ContextInfo.AdReplyInfo) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr advertisername_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr caption_; + int mediatype_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class ContextInfo_ExternalAdReplyInfo final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ContextInfo.ExternalAdReplyInfo) */ { + public: + inline ContextInfo_ExternalAdReplyInfo() : ContextInfo_ExternalAdReplyInfo(nullptr) {} + ~ContextInfo_ExternalAdReplyInfo() override; + explicit PROTOBUF_CONSTEXPR ContextInfo_ExternalAdReplyInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ContextInfo_ExternalAdReplyInfo(const ContextInfo_ExternalAdReplyInfo& from); + ContextInfo_ExternalAdReplyInfo(ContextInfo_ExternalAdReplyInfo&& from) noexcept + : ContextInfo_ExternalAdReplyInfo() { + *this = ::std::move(from); + } + + inline ContextInfo_ExternalAdReplyInfo& operator=(const ContextInfo_ExternalAdReplyInfo& from) { + CopyFrom(from); + return *this; + } + inline ContextInfo_ExternalAdReplyInfo& operator=(ContextInfo_ExternalAdReplyInfo&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ContextInfo_ExternalAdReplyInfo& default_instance() { + return *internal_default_instance(); + } + static inline const ContextInfo_ExternalAdReplyInfo* internal_default_instance() { + return reinterpret_cast( + &_ContextInfo_ExternalAdReplyInfo_default_instance_); + } + static constexpr int kIndexInFileMessages = + 23; + + friend void swap(ContextInfo_ExternalAdReplyInfo& a, ContextInfo_ExternalAdReplyInfo& b) { + a.Swap(&b); + } + inline void Swap(ContextInfo_ExternalAdReplyInfo* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ContextInfo_ExternalAdReplyInfo* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ContextInfo_ExternalAdReplyInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ContextInfo_ExternalAdReplyInfo& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const ContextInfo_ExternalAdReplyInfo& from) { + ContextInfo_ExternalAdReplyInfo::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ContextInfo_ExternalAdReplyInfo* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.ContextInfo.ExternalAdReplyInfo"; + } + protected: + explicit ContextInfo_ExternalAdReplyInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef ContextInfo_ExternalAdReplyInfo_MediaType MediaType; + static constexpr MediaType NONE = + ContextInfo_ExternalAdReplyInfo_MediaType_NONE; + static constexpr MediaType IMAGE = + ContextInfo_ExternalAdReplyInfo_MediaType_IMAGE; + static constexpr MediaType VIDEO = + ContextInfo_ExternalAdReplyInfo_MediaType_VIDEO; + static inline bool MediaType_IsValid(int value) { + return ContextInfo_ExternalAdReplyInfo_MediaType_IsValid(value); + } + static constexpr MediaType MediaType_MIN = + ContextInfo_ExternalAdReplyInfo_MediaType_MediaType_MIN; + static constexpr MediaType MediaType_MAX = + ContextInfo_ExternalAdReplyInfo_MediaType_MediaType_MAX; + static constexpr int MediaType_ARRAYSIZE = + ContextInfo_ExternalAdReplyInfo_MediaType_MediaType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + MediaType_descriptor() { + return ContextInfo_ExternalAdReplyInfo_MediaType_descriptor(); + } + template + static inline const std::string& MediaType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function MediaType_Name."); + return ContextInfo_ExternalAdReplyInfo_MediaType_Name(enum_t_value); + } + static inline bool MediaType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + MediaType* value) { + return ContextInfo_ExternalAdReplyInfo_MediaType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kTitleFieldNumber = 1, + kBodyFieldNumber = 2, + kThumbnailUrlFieldNumber = 4, + kMediaUrlFieldNumber = 5, + kThumbnailFieldNumber = 6, + kSourceTypeFieldNumber = 7, + kSourceIdFieldNumber = 8, + kSourceUrlFieldNumber = 9, + kMediaTypeFieldNumber = 3, + kContainsAutoReplyFieldNumber = 10, + kRenderLargerThumbnailFieldNumber = 11, + kShowAdAttributionFieldNumber = 12, + }; + // optional string title = 1; + bool has_title() const; + private: + bool _internal_has_title() const; + public: + void clear_title(); + const std::string& title() const; + template + void set_title(ArgT0&& arg0, ArgT... args); + std::string* mutable_title(); + PROTOBUF_NODISCARD std::string* release_title(); + void set_allocated_title(std::string* title); + private: + const std::string& _internal_title() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value); + std::string* _internal_mutable_title(); + public: + + // optional string body = 2; + bool has_body() const; + private: + bool _internal_has_body() const; + public: + void clear_body(); + const std::string& body() const; + template + void set_body(ArgT0&& arg0, ArgT... args); + std::string* mutable_body(); + PROTOBUF_NODISCARD std::string* release_body(); + void set_allocated_body(std::string* body); + private: + const std::string& _internal_body() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_body(const std::string& value); + std::string* _internal_mutable_body(); + public: + + // optional string thumbnailUrl = 4; + bool has_thumbnailurl() const; + private: + bool _internal_has_thumbnailurl() const; + public: + void clear_thumbnailurl(); + const std::string& thumbnailurl() const; + template + void set_thumbnailurl(ArgT0&& arg0, ArgT... args); + std::string* mutable_thumbnailurl(); + PROTOBUF_NODISCARD std::string* release_thumbnailurl(); + void set_allocated_thumbnailurl(std::string* thumbnailurl); + private: + const std::string& _internal_thumbnailurl() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailurl(const std::string& value); + std::string* _internal_mutable_thumbnailurl(); + public: + + // optional string mediaUrl = 5; + bool has_mediaurl() const; + private: + bool _internal_has_mediaurl() const; + public: + void clear_mediaurl(); + const std::string& mediaurl() const; + template + void set_mediaurl(ArgT0&& arg0, ArgT... args); + std::string* mutable_mediaurl(); + PROTOBUF_NODISCARD std::string* release_mediaurl(); + void set_allocated_mediaurl(std::string* mediaurl); + private: + const std::string& _internal_mediaurl() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediaurl(const std::string& value); + std::string* _internal_mutable_mediaurl(); + public: + + // optional bytes thumbnail = 6; + bool has_thumbnail() const; + private: + bool _internal_has_thumbnail() const; + public: + void clear_thumbnail(); + const std::string& thumbnail() const; + template + void set_thumbnail(ArgT0&& arg0, ArgT... args); + std::string* mutable_thumbnail(); + PROTOBUF_NODISCARD std::string* release_thumbnail(); + void set_allocated_thumbnail(std::string* thumbnail); + private: + const std::string& _internal_thumbnail() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnail(const std::string& value); + std::string* _internal_mutable_thumbnail(); + public: + + // optional string sourceType = 7; + bool has_sourcetype() const; + private: + bool _internal_has_sourcetype() const; + public: + void clear_sourcetype(); + const std::string& sourcetype() const; + template + void set_sourcetype(ArgT0&& arg0, ArgT... args); + std::string* mutable_sourcetype(); + PROTOBUF_NODISCARD std::string* release_sourcetype(); + void set_allocated_sourcetype(std::string* sourcetype); + private: + const std::string& _internal_sourcetype() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_sourcetype(const std::string& value); + std::string* _internal_mutable_sourcetype(); + public: + + // optional string sourceId = 8; + bool has_sourceid() const; + private: + bool _internal_has_sourceid() const; + public: + void clear_sourceid(); + const std::string& sourceid() const; + template + void set_sourceid(ArgT0&& arg0, ArgT... args); + std::string* mutable_sourceid(); + PROTOBUF_NODISCARD std::string* release_sourceid(); + void set_allocated_sourceid(std::string* sourceid); + private: + const std::string& _internal_sourceid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_sourceid(const std::string& value); + std::string* _internal_mutable_sourceid(); + public: + + // optional string sourceUrl = 9; + bool has_sourceurl() const; + private: + bool _internal_has_sourceurl() const; + public: + void clear_sourceurl(); + const std::string& sourceurl() const; + template + void set_sourceurl(ArgT0&& arg0, ArgT... args); + std::string* mutable_sourceurl(); + PROTOBUF_NODISCARD std::string* release_sourceurl(); + void set_allocated_sourceurl(std::string* sourceurl); + private: + const std::string& _internal_sourceurl() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_sourceurl(const std::string& value); + std::string* _internal_mutable_sourceurl(); + public: + + // optional .proto.ContextInfo.ExternalAdReplyInfo.MediaType mediaType = 3; + bool has_mediatype() const; + private: + bool _internal_has_mediatype() const; + public: + void clear_mediatype(); + ::proto::ContextInfo_ExternalAdReplyInfo_MediaType mediatype() const; + void set_mediatype(::proto::ContextInfo_ExternalAdReplyInfo_MediaType value); + private: + ::proto::ContextInfo_ExternalAdReplyInfo_MediaType _internal_mediatype() const; + void _internal_set_mediatype(::proto::ContextInfo_ExternalAdReplyInfo_MediaType value); + public: + + // optional bool containsAutoReply = 10; + bool has_containsautoreply() const; + private: + bool _internal_has_containsautoreply() const; + public: + void clear_containsautoreply(); + bool containsautoreply() const; + void set_containsautoreply(bool value); + private: + bool _internal_containsautoreply() const; + void _internal_set_containsautoreply(bool value); + public: + + // optional bool renderLargerThumbnail = 11; + bool has_renderlargerthumbnail() const; + private: + bool _internal_has_renderlargerthumbnail() const; + public: + void clear_renderlargerthumbnail(); + bool renderlargerthumbnail() const; + void set_renderlargerthumbnail(bool value); + private: + bool _internal_renderlargerthumbnail() const; + void _internal_set_renderlargerthumbnail(bool value); + public: + + // optional bool showAdAttribution = 12; + bool has_showadattribution() const; + private: + bool _internal_has_showadattribution() const; + public: + void clear_showadattribution(); + bool showadattribution() const; + void set_showadattribution(bool value); + private: + bool _internal_showadattribution() const; + void _internal_set_showadattribution(bool value); + public: + + // @@protoc_insertion_point(class_scope:proto.ContextInfo.ExternalAdReplyInfo) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr body_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailurl_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediaurl_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnail_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sourcetype_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sourceid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sourceurl_; + int mediatype_; + bool containsautoreply_; + bool renderlargerthumbnail_; + bool showadattribution_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class ContextInfo final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ContextInfo) */ { + public: + inline ContextInfo() : ContextInfo(nullptr) {} + ~ContextInfo() override; + explicit PROTOBUF_CONSTEXPR ContextInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ContextInfo(const ContextInfo& from); + ContextInfo(ContextInfo&& from) noexcept + : ContextInfo() { + *this = ::std::move(from); + } + + inline ContextInfo& operator=(const ContextInfo& from) { + CopyFrom(from); + return *this; + } + inline ContextInfo& operator=(ContextInfo&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ContextInfo& default_instance() { + return *internal_default_instance(); + } + static inline const ContextInfo* internal_default_instance() { + return reinterpret_cast( + &_ContextInfo_default_instance_); + } + static constexpr int kIndexInFileMessages = + 24; + + friend void swap(ContextInfo& a, ContextInfo& b) { + a.Swap(&b); + } + inline void Swap(ContextInfo* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ContextInfo* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ContextInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ContextInfo& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const ContextInfo& from) { + ContextInfo::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ContextInfo* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.ContextInfo"; + } + protected: + explicit ContextInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef ContextInfo_AdReplyInfo AdReplyInfo; + typedef ContextInfo_ExternalAdReplyInfo ExternalAdReplyInfo; + + // accessors ------------------------------------------------------- + + enum : int { + kMentionedJidFieldNumber = 15, + kStanzaIdFieldNumber = 1, + kParticipantFieldNumber = 2, + kRemoteJidFieldNumber = 4, + kConversionSourceFieldNumber = 18, + kConversionDataFieldNumber = 19, + kEphemeralSharedSecretFieldNumber = 27, + kEntryPointConversionSourceFieldNumber = 29, + kEntryPointConversionAppFieldNumber = 30, + kGroupSubjectFieldNumber = 34, + kParentGroupJidFieldNumber = 35, + kQuotedMessageFieldNumber = 3, + kQuotedAdFieldNumber = 23, + kPlaceholderKeyFieldNumber = 24, + kExternalAdReplyFieldNumber = 28, + kDisappearingModeFieldNumber = 32, + kActionLinkFieldNumber = 33, + kConversionDelaySecondsFieldNumber = 20, + kForwardingScoreFieldNumber = 21, + kIsForwardedFieldNumber = 22, + kExpirationFieldNumber = 25, + kEphemeralSettingTimestampFieldNumber = 26, + kEntryPointConversionDelaySecondsFieldNumber = 31, + }; + // repeated string mentionedJid = 15; + int mentionedjid_size() const; + private: + int _internal_mentionedjid_size() const; + public: + void clear_mentionedjid(); + const std::string& mentionedjid(int index) const; + std::string* mutable_mentionedjid(int index); + void set_mentionedjid(int index, const std::string& value); + void set_mentionedjid(int index, std::string&& value); + void set_mentionedjid(int index, const char* value); + void set_mentionedjid(int index, const char* value, size_t size); + std::string* add_mentionedjid(); + void add_mentionedjid(const std::string& value); + void add_mentionedjid(std::string&& value); + void add_mentionedjid(const char* value); + void add_mentionedjid(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& mentionedjid() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_mentionedjid(); + private: + const std::string& _internal_mentionedjid(int index) const; + std::string* _internal_add_mentionedjid(); + public: + + // optional string stanzaId = 1; + bool has_stanzaid() const; + private: + bool _internal_has_stanzaid() const; + public: + void clear_stanzaid(); + const std::string& stanzaid() const; + template + void set_stanzaid(ArgT0&& arg0, ArgT... args); + std::string* mutable_stanzaid(); + PROTOBUF_NODISCARD std::string* release_stanzaid(); + void set_allocated_stanzaid(std::string* stanzaid); + private: + const std::string& _internal_stanzaid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_stanzaid(const std::string& value); + std::string* _internal_mutable_stanzaid(); + public: + + // optional string participant = 2; + bool has_participant() const; + private: + bool _internal_has_participant() const; + public: + void clear_participant(); + const std::string& participant() const; + template + void set_participant(ArgT0&& arg0, ArgT... args); + std::string* mutable_participant(); + PROTOBUF_NODISCARD std::string* release_participant(); + void set_allocated_participant(std::string* participant); + private: + const std::string& _internal_participant() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_participant(const std::string& value); + std::string* _internal_mutable_participant(); + public: + + // optional string remoteJid = 4; + bool has_remotejid() const; + private: + bool _internal_has_remotejid() const; + public: + void clear_remotejid(); + const std::string& remotejid() const; + template + void set_remotejid(ArgT0&& arg0, ArgT... args); + std::string* mutable_remotejid(); + PROTOBUF_NODISCARD std::string* release_remotejid(); + void set_allocated_remotejid(std::string* remotejid); + private: + const std::string& _internal_remotejid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_remotejid(const std::string& value); + std::string* _internal_mutable_remotejid(); + public: + + // optional string conversionSource = 18; + bool has_conversionsource() const; + private: + bool _internal_has_conversionsource() const; + public: + void clear_conversionsource(); + const std::string& conversionsource() const; + template + void set_conversionsource(ArgT0&& arg0, ArgT... args); + std::string* mutable_conversionsource(); + PROTOBUF_NODISCARD std::string* release_conversionsource(); + void set_allocated_conversionsource(std::string* conversionsource); + private: + const std::string& _internal_conversionsource() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_conversionsource(const std::string& value); + std::string* _internal_mutable_conversionsource(); + public: + + // optional bytes conversionData = 19; + bool has_conversiondata() const; + private: + bool _internal_has_conversiondata() const; + public: + void clear_conversiondata(); + const std::string& conversiondata() const; + template + void set_conversiondata(ArgT0&& arg0, ArgT... args); + std::string* mutable_conversiondata(); + PROTOBUF_NODISCARD std::string* release_conversiondata(); + void set_allocated_conversiondata(std::string* conversiondata); + private: + const std::string& _internal_conversiondata() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_conversiondata(const std::string& value); + std::string* _internal_mutable_conversiondata(); + public: + + // optional bytes ephemeralSharedSecret = 27; + bool has_ephemeralsharedsecret() const; + private: + bool _internal_has_ephemeralsharedsecret() const; + public: + void clear_ephemeralsharedsecret(); + const std::string& ephemeralsharedsecret() const; + template + void set_ephemeralsharedsecret(ArgT0&& arg0, ArgT... args); + std::string* mutable_ephemeralsharedsecret(); + PROTOBUF_NODISCARD std::string* release_ephemeralsharedsecret(); + void set_allocated_ephemeralsharedsecret(std::string* ephemeralsharedsecret); + private: + const std::string& _internal_ephemeralsharedsecret() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_ephemeralsharedsecret(const std::string& value); + std::string* _internal_mutable_ephemeralsharedsecret(); + public: + + // optional string entryPointConversionSource = 29; + bool has_entrypointconversionsource() const; + private: + bool _internal_has_entrypointconversionsource() const; + public: + void clear_entrypointconversionsource(); + const std::string& entrypointconversionsource() const; + template + void set_entrypointconversionsource(ArgT0&& arg0, ArgT... args); + std::string* mutable_entrypointconversionsource(); + PROTOBUF_NODISCARD std::string* release_entrypointconversionsource(); + void set_allocated_entrypointconversionsource(std::string* entrypointconversionsource); + private: + const std::string& _internal_entrypointconversionsource() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_entrypointconversionsource(const std::string& value); + std::string* _internal_mutable_entrypointconversionsource(); + public: + + // optional string entryPointConversionApp = 30; + bool has_entrypointconversionapp() const; + private: + bool _internal_has_entrypointconversionapp() const; + public: + void clear_entrypointconversionapp(); + const std::string& entrypointconversionapp() const; + template + void set_entrypointconversionapp(ArgT0&& arg0, ArgT... args); + std::string* mutable_entrypointconversionapp(); + PROTOBUF_NODISCARD std::string* release_entrypointconversionapp(); + void set_allocated_entrypointconversionapp(std::string* entrypointconversionapp); + private: + const std::string& _internal_entrypointconversionapp() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_entrypointconversionapp(const std::string& value); + std::string* _internal_mutable_entrypointconversionapp(); + public: + + // optional string groupSubject = 34; + bool has_groupsubject() const; + private: + bool _internal_has_groupsubject() const; + public: + void clear_groupsubject(); + const std::string& groupsubject() const; + template + void set_groupsubject(ArgT0&& arg0, ArgT... args); + std::string* mutable_groupsubject(); + PROTOBUF_NODISCARD std::string* release_groupsubject(); + void set_allocated_groupsubject(std::string* groupsubject); + private: + const std::string& _internal_groupsubject() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_groupsubject(const std::string& value); + std::string* _internal_mutable_groupsubject(); + public: + + // optional string parentGroupJid = 35; + bool has_parentgroupjid() const; + private: + bool _internal_has_parentgroupjid() const; + public: + void clear_parentgroupjid(); + const std::string& parentgroupjid() const; + template + void set_parentgroupjid(ArgT0&& arg0, ArgT... args); + std::string* mutable_parentgroupjid(); + PROTOBUF_NODISCARD std::string* release_parentgroupjid(); + void set_allocated_parentgroupjid(std::string* parentgroupjid); + private: + const std::string& _internal_parentgroupjid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_parentgroupjid(const std::string& value); + std::string* _internal_mutable_parentgroupjid(); + public: + + // optional .proto.Message quotedMessage = 3; + bool has_quotedmessage() const; + private: + bool _internal_has_quotedmessage() const; + public: + void clear_quotedmessage(); + const ::proto::Message& quotedmessage() const; + PROTOBUF_NODISCARD ::proto::Message* release_quotedmessage(); + ::proto::Message* mutable_quotedmessage(); + void set_allocated_quotedmessage(::proto::Message* quotedmessage); + private: + const ::proto::Message& _internal_quotedmessage() const; + ::proto::Message* _internal_mutable_quotedmessage(); + public: + void unsafe_arena_set_allocated_quotedmessage( + ::proto::Message* quotedmessage); + ::proto::Message* unsafe_arena_release_quotedmessage(); + + // optional .proto.ContextInfo.AdReplyInfo quotedAd = 23; + bool has_quotedad() const; + private: + bool _internal_has_quotedad() const; + public: + void clear_quotedad(); + const ::proto::ContextInfo_AdReplyInfo& quotedad() const; + PROTOBUF_NODISCARD ::proto::ContextInfo_AdReplyInfo* release_quotedad(); + ::proto::ContextInfo_AdReplyInfo* mutable_quotedad(); + void set_allocated_quotedad(::proto::ContextInfo_AdReplyInfo* quotedad); + private: + const ::proto::ContextInfo_AdReplyInfo& _internal_quotedad() const; + ::proto::ContextInfo_AdReplyInfo* _internal_mutable_quotedad(); + public: + void unsafe_arena_set_allocated_quotedad( + ::proto::ContextInfo_AdReplyInfo* quotedad); + ::proto::ContextInfo_AdReplyInfo* unsafe_arena_release_quotedad(); + + // optional .proto.MessageKey placeholderKey = 24; + bool has_placeholderkey() const; + private: + bool _internal_has_placeholderkey() const; + public: + void clear_placeholderkey(); + const ::proto::MessageKey& placeholderkey() const; + PROTOBUF_NODISCARD ::proto::MessageKey* release_placeholderkey(); + ::proto::MessageKey* mutable_placeholderkey(); + void set_allocated_placeholderkey(::proto::MessageKey* placeholderkey); + private: + const ::proto::MessageKey& _internal_placeholderkey() const; + ::proto::MessageKey* _internal_mutable_placeholderkey(); + public: + void unsafe_arena_set_allocated_placeholderkey( + ::proto::MessageKey* placeholderkey); + ::proto::MessageKey* unsafe_arena_release_placeholderkey(); + + // optional .proto.ContextInfo.ExternalAdReplyInfo externalAdReply = 28; + bool has_externaladreply() const; + private: + bool _internal_has_externaladreply() const; + public: + void clear_externaladreply(); + const ::proto::ContextInfo_ExternalAdReplyInfo& externaladreply() const; + PROTOBUF_NODISCARD ::proto::ContextInfo_ExternalAdReplyInfo* release_externaladreply(); + ::proto::ContextInfo_ExternalAdReplyInfo* mutable_externaladreply(); + void set_allocated_externaladreply(::proto::ContextInfo_ExternalAdReplyInfo* externaladreply); + private: + const ::proto::ContextInfo_ExternalAdReplyInfo& _internal_externaladreply() const; + ::proto::ContextInfo_ExternalAdReplyInfo* _internal_mutable_externaladreply(); + public: + void unsafe_arena_set_allocated_externaladreply( + ::proto::ContextInfo_ExternalAdReplyInfo* externaladreply); + ::proto::ContextInfo_ExternalAdReplyInfo* unsafe_arena_release_externaladreply(); + + // optional .proto.DisappearingMode disappearingMode = 32; + bool has_disappearingmode() const; + private: + bool _internal_has_disappearingmode() const; + public: + void clear_disappearingmode(); + const ::proto::DisappearingMode& disappearingmode() const; + PROTOBUF_NODISCARD ::proto::DisappearingMode* release_disappearingmode(); + ::proto::DisappearingMode* mutable_disappearingmode(); + void set_allocated_disappearingmode(::proto::DisappearingMode* disappearingmode); + private: + const ::proto::DisappearingMode& _internal_disappearingmode() const; + ::proto::DisappearingMode* _internal_mutable_disappearingmode(); + public: + void unsafe_arena_set_allocated_disappearingmode( + ::proto::DisappearingMode* disappearingmode); + ::proto::DisappearingMode* unsafe_arena_release_disappearingmode(); + + // optional .proto.ActionLink actionLink = 33; + bool has_actionlink() const; + private: + bool _internal_has_actionlink() const; + public: + void clear_actionlink(); + const ::proto::ActionLink& actionlink() const; + PROTOBUF_NODISCARD ::proto::ActionLink* release_actionlink(); + ::proto::ActionLink* mutable_actionlink(); + void set_allocated_actionlink(::proto::ActionLink* actionlink); + private: + const ::proto::ActionLink& _internal_actionlink() const; + ::proto::ActionLink* _internal_mutable_actionlink(); + public: + void unsafe_arena_set_allocated_actionlink( + ::proto::ActionLink* actionlink); + ::proto::ActionLink* unsafe_arena_release_actionlink(); + + // optional uint32 conversionDelaySeconds = 20; + bool has_conversiondelayseconds() const; + private: + bool _internal_has_conversiondelayseconds() const; + public: + void clear_conversiondelayseconds(); + uint32_t conversiondelayseconds() const; + void set_conversiondelayseconds(uint32_t value); + private: + uint32_t _internal_conversiondelayseconds() const; + void _internal_set_conversiondelayseconds(uint32_t value); + public: + + // optional uint32 forwardingScore = 21; + bool has_forwardingscore() const; + private: + bool _internal_has_forwardingscore() const; + public: + void clear_forwardingscore(); + uint32_t forwardingscore() const; + void set_forwardingscore(uint32_t value); + private: + uint32_t _internal_forwardingscore() const; + void _internal_set_forwardingscore(uint32_t value); + public: + + // optional bool isForwarded = 22; + bool has_isforwarded() const; + private: + bool _internal_has_isforwarded() const; + public: + void clear_isforwarded(); + bool isforwarded() const; + void set_isforwarded(bool value); + private: + bool _internal_isforwarded() const; + void _internal_set_isforwarded(bool value); + public: + + // optional uint32 expiration = 25; + bool has_expiration() const; + private: + bool _internal_has_expiration() const; + public: + void clear_expiration(); + uint32_t expiration() const; + void set_expiration(uint32_t value); + private: + uint32_t _internal_expiration() const; + void _internal_set_expiration(uint32_t value); + public: + + // optional int64 ephemeralSettingTimestamp = 26; + bool has_ephemeralsettingtimestamp() const; + private: + bool _internal_has_ephemeralsettingtimestamp() const; + public: + void clear_ephemeralsettingtimestamp(); + int64_t ephemeralsettingtimestamp() const; + void set_ephemeralsettingtimestamp(int64_t value); + private: + int64_t _internal_ephemeralsettingtimestamp() const; + void _internal_set_ephemeralsettingtimestamp(int64_t value); + public: + + // optional uint32 entryPointConversionDelaySeconds = 31; + bool has_entrypointconversiondelayseconds() const; + private: + bool _internal_has_entrypointconversiondelayseconds() const; + public: + void clear_entrypointconversiondelayseconds(); + uint32_t entrypointconversiondelayseconds() const; + void set_entrypointconversiondelayseconds(uint32_t value); + private: + uint32_t _internal_entrypointconversiondelayseconds() const; + void _internal_set_entrypointconversiondelayseconds(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.ContextInfo) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField mentionedjid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr stanzaid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr participant_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr remotejid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conversionsource_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conversiondata_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ephemeralsharedsecret_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr entrypointconversionsource_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr entrypointconversionapp_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr groupsubject_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr parentgroupjid_; + ::proto::Message* quotedmessage_; + ::proto::ContextInfo_AdReplyInfo* quotedad_; + ::proto::MessageKey* placeholderkey_; + ::proto::ContextInfo_ExternalAdReplyInfo* externaladreply_; + ::proto::DisappearingMode* disappearingmode_; + ::proto::ActionLink* actionlink_; + uint32_t conversiondelayseconds_; + uint32_t forwardingscore_; + bool isforwarded_; + uint32_t expiration_; + int64_t ephemeralsettingtimestamp_; + uint32_t entrypointconversiondelayseconds_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Conversation final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Conversation) */ { + public: + inline Conversation() : Conversation(nullptr) {} + ~Conversation() override; + explicit PROTOBUF_CONSTEXPR Conversation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Conversation(const Conversation& from); + Conversation(Conversation&& from) noexcept + : Conversation() { + *this = ::std::move(from); + } + + inline Conversation& operator=(const Conversation& from) { + CopyFrom(from); + return *this; + } + inline Conversation& operator=(Conversation&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Conversation& default_instance() { + return *internal_default_instance(); + } + static inline const Conversation* internal_default_instance() { + return reinterpret_cast( + &_Conversation_default_instance_); + } + static constexpr int kIndexInFileMessages = + 25; + + friend void swap(Conversation& a, Conversation& b) { + a.Swap(&b); + } + inline void Swap(Conversation* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Conversation* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Conversation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Conversation& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Conversation& from) { + Conversation::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Conversation* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Conversation"; + } + protected: + explicit Conversation(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Conversation_EndOfHistoryTransferType EndOfHistoryTransferType; + static constexpr EndOfHistoryTransferType COMPLETE_BUT_MORE_MESSAGES_REMAIN_ON_PRIMARY = + Conversation_EndOfHistoryTransferType_COMPLETE_BUT_MORE_MESSAGES_REMAIN_ON_PRIMARY; + static constexpr EndOfHistoryTransferType COMPLETE_AND_NO_MORE_MESSAGE_REMAIN_ON_PRIMARY = + Conversation_EndOfHistoryTransferType_COMPLETE_AND_NO_MORE_MESSAGE_REMAIN_ON_PRIMARY; + static inline bool EndOfHistoryTransferType_IsValid(int value) { + return Conversation_EndOfHistoryTransferType_IsValid(value); + } + static constexpr EndOfHistoryTransferType EndOfHistoryTransferType_MIN = + Conversation_EndOfHistoryTransferType_EndOfHistoryTransferType_MIN; + static constexpr EndOfHistoryTransferType EndOfHistoryTransferType_MAX = + Conversation_EndOfHistoryTransferType_EndOfHistoryTransferType_MAX; + static constexpr int EndOfHistoryTransferType_ARRAYSIZE = + Conversation_EndOfHistoryTransferType_EndOfHistoryTransferType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + EndOfHistoryTransferType_descriptor() { + return Conversation_EndOfHistoryTransferType_descriptor(); + } + template + static inline const std::string& EndOfHistoryTransferType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function EndOfHistoryTransferType_Name."); + return Conversation_EndOfHistoryTransferType_Name(enum_t_value); + } + static inline bool EndOfHistoryTransferType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + EndOfHistoryTransferType* value) { + return Conversation_EndOfHistoryTransferType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kMessagesFieldNumber = 2, + kParticipantFieldNumber = 20, + kIdFieldNumber = 1, + kNewJidFieldNumber = 3, + kOldJidFieldNumber = 4, + kNameFieldNumber = 13, + kPHashFieldNumber = 14, + kTcTokenFieldNumber = 21, + kContactPrimaryIdentityKeyFieldNumber = 23, + kCreatedByFieldNumber = 32, + kDescriptionFieldNumber = 33, + kParentGroupIdFieldNumber = 37, + kDisplayNameFieldNumber = 38, + kPnJidFieldNumber = 39, + kDisappearingModeFieldNumber = 17, + kWallpaperFieldNumber = 26, + kLastMsgTimestampFieldNumber = 5, + kUnreadCountFieldNumber = 6, + kEphemeralExpirationFieldNumber = 9, + kEphemeralSettingTimestampFieldNumber = 10, + kEndOfHistoryTransferTypeFieldNumber = 11, + kReadOnlyFieldNumber = 7, + kEndOfHistoryTransferFieldNumber = 8, + kNotSpamFieldNumber = 15, + kArchivedFieldNumber = 16, + kConversationTimestampFieldNumber = 12, + kUnreadMentionCountFieldNumber = 18, + kPinnedFieldNumber = 24, + kTcTokenTimestampFieldNumber = 22, + kMuteEndTimeFieldNumber = 25, + kMediaVisibilityFieldNumber = 27, + kMarkedAsUnreadFieldNumber = 19, + kSuspendedFieldNumber = 29, + kTerminatedFieldNumber = 30, + kSupportFieldNumber = 34, + kTcTokenSenderTimestampFieldNumber = 28, + kCreatedAtFieldNumber = 31, + kIsParentGroupFieldNumber = 35, + kIsDefaultSubgroupFieldNumber = 36, + kSelfPnExposedFieldNumber = 40, + }; + // repeated .proto.HistorySyncMsg messages = 2; + int messages_size() const; + private: + int _internal_messages_size() const; + public: + void clear_messages(); + ::proto::HistorySyncMsg* mutable_messages(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HistorySyncMsg >* + mutable_messages(); + private: + const ::proto::HistorySyncMsg& _internal_messages(int index) const; + ::proto::HistorySyncMsg* _internal_add_messages(); + public: + const ::proto::HistorySyncMsg& messages(int index) const; + ::proto::HistorySyncMsg* add_messages(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HistorySyncMsg >& + messages() const; + + // repeated .proto.GroupParticipant participant = 20; + int participant_size() const; + private: + int _internal_participant_size() const; + public: + void clear_participant(); + ::proto::GroupParticipant* mutable_participant(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::GroupParticipant >* + mutable_participant(); + private: + const ::proto::GroupParticipant& _internal_participant(int index) const; + ::proto::GroupParticipant* _internal_add_participant(); + public: + const ::proto::GroupParticipant& participant(int index) const; + ::proto::GroupParticipant* add_participant(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::GroupParticipant >& + participant() const; + + // required string id = 1; + bool has_id() const; + private: + bool _internal_has_id() const; + public: + void clear_id(); + const std::string& id() const; + template + void set_id(ArgT0&& arg0, ArgT... args); + std::string* mutable_id(); + PROTOBUF_NODISCARD std::string* release_id(); + void set_allocated_id(std::string* id); + private: + const std::string& _internal_id() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value); + std::string* _internal_mutable_id(); + public: + + // optional string newJid = 3; + bool has_newjid() const; + private: + bool _internal_has_newjid() const; + public: + void clear_newjid(); + const std::string& newjid() const; + template + void set_newjid(ArgT0&& arg0, ArgT... args); + std::string* mutable_newjid(); + PROTOBUF_NODISCARD std::string* release_newjid(); + void set_allocated_newjid(std::string* newjid); + private: + const std::string& _internal_newjid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_newjid(const std::string& value); + std::string* _internal_mutable_newjid(); + public: + + // optional string oldJid = 4; + bool has_oldjid() const; + private: + bool _internal_has_oldjid() const; + public: + void clear_oldjid(); + const std::string& oldjid() const; + template + void set_oldjid(ArgT0&& arg0, ArgT... args); + std::string* mutable_oldjid(); + PROTOBUF_NODISCARD std::string* release_oldjid(); + void set_allocated_oldjid(std::string* oldjid); + private: + const std::string& _internal_oldjid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_oldjid(const std::string& value); + std::string* _internal_mutable_oldjid(); + public: + + // optional string name = 13; + bool has_name() const; + private: + bool _internal_has_name() const; + public: + void clear_name(); + const std::string& name() const; + template + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + PROTOBUF_NODISCARD std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // optional string pHash = 14; + bool has_phash() const; + private: + bool _internal_has_phash() const; + public: + void clear_phash(); + const std::string& phash() const; + template + void set_phash(ArgT0&& arg0, ArgT... args); + std::string* mutable_phash(); + PROTOBUF_NODISCARD std::string* release_phash(); + void set_allocated_phash(std::string* phash); + private: + const std::string& _internal_phash() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_phash(const std::string& value); + std::string* _internal_mutable_phash(); + public: + + // optional bytes tcToken = 21; + bool has_tctoken() const; + private: + bool _internal_has_tctoken() const; + public: + void clear_tctoken(); + const std::string& tctoken() const; + template + void set_tctoken(ArgT0&& arg0, ArgT... args); + std::string* mutable_tctoken(); + PROTOBUF_NODISCARD std::string* release_tctoken(); + void set_allocated_tctoken(std::string* tctoken); + private: + const std::string& _internal_tctoken() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_tctoken(const std::string& value); + std::string* _internal_mutable_tctoken(); + public: + + // optional bytes contactPrimaryIdentityKey = 23; + bool has_contactprimaryidentitykey() const; + private: + bool _internal_has_contactprimaryidentitykey() const; + public: + void clear_contactprimaryidentitykey(); + const std::string& contactprimaryidentitykey() const; + template + void set_contactprimaryidentitykey(ArgT0&& arg0, ArgT... args); + std::string* mutable_contactprimaryidentitykey(); + PROTOBUF_NODISCARD std::string* release_contactprimaryidentitykey(); + void set_allocated_contactprimaryidentitykey(std::string* contactprimaryidentitykey); + private: + const std::string& _internal_contactprimaryidentitykey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_contactprimaryidentitykey(const std::string& value); + std::string* _internal_mutable_contactprimaryidentitykey(); + public: + + // optional string createdBy = 32; + bool has_createdby() const; + private: + bool _internal_has_createdby() const; + public: + void clear_createdby(); + const std::string& createdby() const; + template + void set_createdby(ArgT0&& arg0, ArgT... args); + std::string* mutable_createdby(); + PROTOBUF_NODISCARD std::string* release_createdby(); + void set_allocated_createdby(std::string* createdby); + private: + const std::string& _internal_createdby() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_createdby(const std::string& value); + std::string* _internal_mutable_createdby(); + public: + + // optional string description = 33; + bool has_description() const; + private: + bool _internal_has_description() const; + public: + void clear_description(); + const std::string& description() const; + template + void set_description(ArgT0&& arg0, ArgT... args); + std::string* mutable_description(); + PROTOBUF_NODISCARD std::string* release_description(); + void set_allocated_description(std::string* description); + private: + const std::string& _internal_description() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value); + std::string* _internal_mutable_description(); + public: + + // optional string parentGroupId = 37; + bool has_parentgroupid() const; + private: + bool _internal_has_parentgroupid() const; + public: + void clear_parentgroupid(); + const std::string& parentgroupid() const; + template + void set_parentgroupid(ArgT0&& arg0, ArgT... args); + std::string* mutable_parentgroupid(); + PROTOBUF_NODISCARD std::string* release_parentgroupid(); + void set_allocated_parentgroupid(std::string* parentgroupid); + private: + const std::string& _internal_parentgroupid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_parentgroupid(const std::string& value); + std::string* _internal_mutable_parentgroupid(); + public: + + // optional string displayName = 38; + bool has_displayname() const; + private: + bool _internal_has_displayname() const; + public: + void clear_displayname(); + const std::string& displayname() const; + template + void set_displayname(ArgT0&& arg0, ArgT... args); + std::string* mutable_displayname(); + PROTOBUF_NODISCARD std::string* release_displayname(); + void set_allocated_displayname(std::string* displayname); + private: + const std::string& _internal_displayname() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_displayname(const std::string& value); + std::string* _internal_mutable_displayname(); + public: + + // optional string pnJid = 39; + bool has_pnjid() const; + private: + bool _internal_has_pnjid() const; + public: + void clear_pnjid(); + const std::string& pnjid() const; + template + void set_pnjid(ArgT0&& arg0, ArgT... args); + std::string* mutable_pnjid(); + PROTOBUF_NODISCARD std::string* release_pnjid(); + void set_allocated_pnjid(std::string* pnjid); + private: + const std::string& _internal_pnjid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_pnjid(const std::string& value); + std::string* _internal_mutable_pnjid(); + public: + + // optional .proto.DisappearingMode disappearingMode = 17; + bool has_disappearingmode() const; + private: + bool _internal_has_disappearingmode() const; + public: + void clear_disappearingmode(); + const ::proto::DisappearingMode& disappearingmode() const; + PROTOBUF_NODISCARD ::proto::DisappearingMode* release_disappearingmode(); + ::proto::DisappearingMode* mutable_disappearingmode(); + void set_allocated_disappearingmode(::proto::DisappearingMode* disappearingmode); + private: + const ::proto::DisappearingMode& _internal_disappearingmode() const; + ::proto::DisappearingMode* _internal_mutable_disappearingmode(); + public: + void unsafe_arena_set_allocated_disappearingmode( + ::proto::DisappearingMode* disappearingmode); + ::proto::DisappearingMode* unsafe_arena_release_disappearingmode(); + + // optional .proto.WallpaperSettings wallpaper = 26; + bool has_wallpaper() const; + private: + bool _internal_has_wallpaper() const; + public: + void clear_wallpaper(); + const ::proto::WallpaperSettings& wallpaper() const; + PROTOBUF_NODISCARD ::proto::WallpaperSettings* release_wallpaper(); + ::proto::WallpaperSettings* mutable_wallpaper(); + void set_allocated_wallpaper(::proto::WallpaperSettings* wallpaper); + private: + const ::proto::WallpaperSettings& _internal_wallpaper() const; + ::proto::WallpaperSettings* _internal_mutable_wallpaper(); + public: + void unsafe_arena_set_allocated_wallpaper( + ::proto::WallpaperSettings* wallpaper); + ::proto::WallpaperSettings* unsafe_arena_release_wallpaper(); + + // optional uint64 lastMsgTimestamp = 5; + bool has_lastmsgtimestamp() const; + private: + bool _internal_has_lastmsgtimestamp() const; + public: + void clear_lastmsgtimestamp(); + uint64_t lastmsgtimestamp() const; + void set_lastmsgtimestamp(uint64_t value); + private: + uint64_t _internal_lastmsgtimestamp() const; + void _internal_set_lastmsgtimestamp(uint64_t value); + public: + + // optional uint32 unreadCount = 6; + bool has_unreadcount() const; + private: + bool _internal_has_unreadcount() const; + public: + void clear_unreadcount(); + uint32_t unreadcount() const; + void set_unreadcount(uint32_t value); + private: + uint32_t _internal_unreadcount() const; + void _internal_set_unreadcount(uint32_t value); + public: + + // optional uint32 ephemeralExpiration = 9; + bool has_ephemeralexpiration() const; + private: + bool _internal_has_ephemeralexpiration() const; + public: + void clear_ephemeralexpiration(); + uint32_t ephemeralexpiration() const; + void set_ephemeralexpiration(uint32_t value); + private: + uint32_t _internal_ephemeralexpiration() const; + void _internal_set_ephemeralexpiration(uint32_t value); + public: + + // optional int64 ephemeralSettingTimestamp = 10; + bool has_ephemeralsettingtimestamp() const; + private: + bool _internal_has_ephemeralsettingtimestamp() const; + public: + void clear_ephemeralsettingtimestamp(); + int64_t ephemeralsettingtimestamp() const; + void set_ephemeralsettingtimestamp(int64_t value); + private: + int64_t _internal_ephemeralsettingtimestamp() const; + void _internal_set_ephemeralsettingtimestamp(int64_t value); + public: + + // optional .proto.Conversation.EndOfHistoryTransferType endOfHistoryTransferType = 11; + bool has_endofhistorytransfertype() const; + private: + bool _internal_has_endofhistorytransfertype() const; + public: + void clear_endofhistorytransfertype(); + ::proto::Conversation_EndOfHistoryTransferType endofhistorytransfertype() const; + void set_endofhistorytransfertype(::proto::Conversation_EndOfHistoryTransferType value); + private: + ::proto::Conversation_EndOfHistoryTransferType _internal_endofhistorytransfertype() const; + void _internal_set_endofhistorytransfertype(::proto::Conversation_EndOfHistoryTransferType value); + public: + + // optional bool readOnly = 7; + bool has_readonly() const; + private: + bool _internal_has_readonly() const; + public: + void clear_readonly(); + bool readonly() const; + void set_readonly(bool value); + private: + bool _internal_readonly() const; + void _internal_set_readonly(bool value); + public: + + // optional bool endOfHistoryTransfer = 8; + bool has_endofhistorytransfer() const; + private: + bool _internal_has_endofhistorytransfer() const; + public: + void clear_endofhistorytransfer(); + bool endofhistorytransfer() const; + void set_endofhistorytransfer(bool value); + private: + bool _internal_endofhistorytransfer() const; + void _internal_set_endofhistorytransfer(bool value); + public: + + // optional bool notSpam = 15; + bool has_notspam() const; + private: + bool _internal_has_notspam() const; + public: + void clear_notspam(); + bool notspam() const; + void set_notspam(bool value); + private: + bool _internal_notspam() const; + void _internal_set_notspam(bool value); + public: + + // optional bool archived = 16; + bool has_archived() const; + private: + bool _internal_has_archived() const; + public: + void clear_archived(); + bool archived() const; + void set_archived(bool value); + private: + bool _internal_archived() const; + void _internal_set_archived(bool value); + public: + + // optional uint64 conversationTimestamp = 12; + bool has_conversationtimestamp() const; + private: + bool _internal_has_conversationtimestamp() const; + public: + void clear_conversationtimestamp(); + uint64_t conversationtimestamp() const; + void set_conversationtimestamp(uint64_t value); + private: + uint64_t _internal_conversationtimestamp() const; + void _internal_set_conversationtimestamp(uint64_t value); + public: + + // optional uint32 unreadMentionCount = 18; + bool has_unreadmentioncount() const; + private: + bool _internal_has_unreadmentioncount() const; + public: + void clear_unreadmentioncount(); + uint32_t unreadmentioncount() const; + void set_unreadmentioncount(uint32_t value); + private: + uint32_t _internal_unreadmentioncount() const; + void _internal_set_unreadmentioncount(uint32_t value); + public: + + // optional uint32 pinned = 24; + bool has_pinned() const; + private: + bool _internal_has_pinned() const; + public: + void clear_pinned(); + uint32_t pinned() const; + void set_pinned(uint32_t value); + private: + uint32_t _internal_pinned() const; + void _internal_set_pinned(uint32_t value); + public: + + // optional uint64 tcTokenTimestamp = 22; + bool has_tctokentimestamp() const; + private: + bool _internal_has_tctokentimestamp() const; + public: + void clear_tctokentimestamp(); + uint64_t tctokentimestamp() const; + void set_tctokentimestamp(uint64_t value); + private: + uint64_t _internal_tctokentimestamp() const; + void _internal_set_tctokentimestamp(uint64_t value); + public: + + // optional uint64 muteEndTime = 25; + bool has_muteendtime() const; + private: + bool _internal_has_muteendtime() const; + public: + void clear_muteendtime(); + uint64_t muteendtime() const; + void set_muteendtime(uint64_t value); + private: + uint64_t _internal_muteendtime() const; + void _internal_set_muteendtime(uint64_t value); + public: + + // optional .proto.MediaVisibility mediaVisibility = 27; + bool has_mediavisibility() const; + private: + bool _internal_has_mediavisibility() const; + public: + void clear_mediavisibility(); + ::proto::MediaVisibility mediavisibility() const; + void set_mediavisibility(::proto::MediaVisibility value); + private: + ::proto::MediaVisibility _internal_mediavisibility() const; + void _internal_set_mediavisibility(::proto::MediaVisibility value); + public: + + // optional bool markedAsUnread = 19; + bool has_markedasunread() const; + private: + bool _internal_has_markedasunread() const; + public: + void clear_markedasunread(); + bool markedasunread() const; + void set_markedasunread(bool value); + private: + bool _internal_markedasunread() const; + void _internal_set_markedasunread(bool value); + public: + + // optional bool suspended = 29; + bool has_suspended() const; + private: + bool _internal_has_suspended() const; + public: + void clear_suspended(); + bool suspended() const; + void set_suspended(bool value); + private: + bool _internal_suspended() const; + void _internal_set_suspended(bool value); + public: + + // optional bool terminated = 30; + bool has_terminated() const; + private: + bool _internal_has_terminated() const; + public: + void clear_terminated(); + bool terminated() const; + void set_terminated(bool value); + private: + bool _internal_terminated() const; + void _internal_set_terminated(bool value); + public: + + // optional bool support = 34; + bool has_support() const; + private: + bool _internal_has_support() const; + public: + void clear_support(); + bool support() const; + void set_support(bool value); + private: + bool _internal_support() const; + void _internal_set_support(bool value); + public: + + // optional uint64 tcTokenSenderTimestamp = 28; + bool has_tctokensendertimestamp() const; + private: + bool _internal_has_tctokensendertimestamp() const; + public: + void clear_tctokensendertimestamp(); + uint64_t tctokensendertimestamp() const; + void set_tctokensendertimestamp(uint64_t value); + private: + uint64_t _internal_tctokensendertimestamp() const; + void _internal_set_tctokensendertimestamp(uint64_t value); + public: + + // optional uint64 createdAt = 31; + bool has_createdat() const; + private: + bool _internal_has_createdat() const; + public: + void clear_createdat(); + uint64_t createdat() const; + void set_createdat(uint64_t value); + private: + uint64_t _internal_createdat() const; + void _internal_set_createdat(uint64_t value); + public: + + // optional bool isParentGroup = 35; + bool has_isparentgroup() const; + private: + bool _internal_has_isparentgroup() const; + public: + void clear_isparentgroup(); + bool isparentgroup() const; + void set_isparentgroup(bool value); + private: + bool _internal_isparentgroup() const; + void _internal_set_isparentgroup(bool value); + public: + + // optional bool isDefaultSubgroup = 36; + bool has_isdefaultsubgroup() const; + private: + bool _internal_has_isdefaultsubgroup() const; + public: + void clear_isdefaultsubgroup(); + bool isdefaultsubgroup() const; + void set_isdefaultsubgroup(bool value); + private: + bool _internal_isdefaultsubgroup() const; + void _internal_set_isdefaultsubgroup(bool value); + public: + + // optional bool selfPnExposed = 40; + bool has_selfpnexposed() const; + private: + bool _internal_has_selfpnexposed() const; + public: + void clear_selfpnexposed(); + bool selfpnexposed() const; + void set_selfpnexposed(bool value); + private: + bool _internal_selfpnexposed() const; + void _internal_set_selfpnexposed(bool value); + public: + + // @@protoc_insertion_point(class_scope:proto.Conversation) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<2> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HistorySyncMsg > messages_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::GroupParticipant > participant_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr newjid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr oldjid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr phash_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tctoken_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr contactprimaryidentitykey_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr createdby_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr parentgroupid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr displayname_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pnjid_; + ::proto::DisappearingMode* disappearingmode_; + ::proto::WallpaperSettings* wallpaper_; + uint64_t lastmsgtimestamp_; + uint32_t unreadcount_; + uint32_t ephemeralexpiration_; + int64_t ephemeralsettingtimestamp_; + int endofhistorytransfertype_; + bool readonly_; + bool endofhistorytransfer_; + bool notspam_; + bool archived_; + uint64_t conversationtimestamp_; + uint32_t unreadmentioncount_; + uint32_t pinned_; + uint64_t tctokentimestamp_; + uint64_t muteendtime_; + int mediavisibility_; + bool markedasunread_; + bool suspended_; + bool terminated_; + bool support_; + uint64_t tctokensendertimestamp_; + uint64_t createdat_; + bool isparentgroup_; + bool isdefaultsubgroup_; + bool selfpnexposed_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class DeviceListMetadata final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.DeviceListMetadata) */ { + public: + inline DeviceListMetadata() : DeviceListMetadata(nullptr) {} + ~DeviceListMetadata() override; + explicit PROTOBUF_CONSTEXPR DeviceListMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + DeviceListMetadata(const DeviceListMetadata& from); + DeviceListMetadata(DeviceListMetadata&& from) noexcept + : DeviceListMetadata() { + *this = ::std::move(from); + } + + inline DeviceListMetadata& operator=(const DeviceListMetadata& from) { + CopyFrom(from); + return *this; + } + inline DeviceListMetadata& operator=(DeviceListMetadata&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const DeviceListMetadata& default_instance() { + return *internal_default_instance(); + } + static inline const DeviceListMetadata* internal_default_instance() { + return reinterpret_cast( + &_DeviceListMetadata_default_instance_); + } + static constexpr int kIndexInFileMessages = + 26; + + friend void swap(DeviceListMetadata& a, DeviceListMetadata& b) { + a.Swap(&b); + } + inline void Swap(DeviceListMetadata* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(DeviceListMetadata* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + DeviceListMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const DeviceListMetadata& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const DeviceListMetadata& from) { + DeviceListMetadata::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(DeviceListMetadata* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.DeviceListMetadata"; + } + protected: + explicit DeviceListMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSenderKeyIndexesFieldNumber = 3, + kRecipientKeyIndexesFieldNumber = 10, + kSenderKeyHashFieldNumber = 1, + kRecipientKeyHashFieldNumber = 8, + kSenderTimestampFieldNumber = 2, + kRecipientTimestampFieldNumber = 9, + }; + // repeated uint32 senderKeyIndexes = 3 [packed = true]; + int senderkeyindexes_size() const; + private: + int _internal_senderkeyindexes_size() const; + public: + void clear_senderkeyindexes(); + private: + uint32_t _internal_senderkeyindexes(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + _internal_senderkeyindexes() const; + void _internal_add_senderkeyindexes(uint32_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + _internal_mutable_senderkeyindexes(); + public: + uint32_t senderkeyindexes(int index) const; + void set_senderkeyindexes(int index, uint32_t value); + void add_senderkeyindexes(uint32_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + senderkeyindexes() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + mutable_senderkeyindexes(); + + // repeated uint32 recipientKeyIndexes = 10 [packed = true]; + int recipientkeyindexes_size() const; + private: + int _internal_recipientkeyindexes_size() const; + public: + void clear_recipientkeyindexes(); + private: + uint32_t _internal_recipientkeyindexes(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + _internal_recipientkeyindexes() const; + void _internal_add_recipientkeyindexes(uint32_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + _internal_mutable_recipientkeyindexes(); + public: + uint32_t recipientkeyindexes(int index) const; + void set_recipientkeyindexes(int index, uint32_t value); + void add_recipientkeyindexes(uint32_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + recipientkeyindexes() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + mutable_recipientkeyindexes(); + + // optional bytes senderKeyHash = 1; + bool has_senderkeyhash() const; + private: + bool _internal_has_senderkeyhash() const; + public: + void clear_senderkeyhash(); + const std::string& senderkeyhash() const; + template + void set_senderkeyhash(ArgT0&& arg0, ArgT... args); + std::string* mutable_senderkeyhash(); + PROTOBUF_NODISCARD std::string* release_senderkeyhash(); + void set_allocated_senderkeyhash(std::string* senderkeyhash); + private: + const std::string& _internal_senderkeyhash() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_senderkeyhash(const std::string& value); + std::string* _internal_mutable_senderkeyhash(); + public: + + // optional bytes recipientKeyHash = 8; + bool has_recipientkeyhash() const; + private: + bool _internal_has_recipientkeyhash() const; + public: + void clear_recipientkeyhash(); + const std::string& recipientkeyhash() const; + template + void set_recipientkeyhash(ArgT0&& arg0, ArgT... args); + std::string* mutable_recipientkeyhash(); + PROTOBUF_NODISCARD std::string* release_recipientkeyhash(); + void set_allocated_recipientkeyhash(std::string* recipientkeyhash); + private: + const std::string& _internal_recipientkeyhash() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_recipientkeyhash(const std::string& value); + std::string* _internal_mutable_recipientkeyhash(); + public: + + // optional uint64 senderTimestamp = 2; + bool has_sendertimestamp() const; + private: + bool _internal_has_sendertimestamp() const; + public: + void clear_sendertimestamp(); + uint64_t sendertimestamp() const; + void set_sendertimestamp(uint64_t value); + private: + uint64_t _internal_sendertimestamp() const; + void _internal_set_sendertimestamp(uint64_t value); + public: + + // optional uint64 recipientTimestamp = 9; + bool has_recipienttimestamp() const; + private: + bool _internal_has_recipienttimestamp() const; + public: + void clear_recipienttimestamp(); + uint64_t recipienttimestamp() const; + void set_recipienttimestamp(uint64_t value); + private: + uint64_t _internal_recipienttimestamp() const; + void _internal_set_recipienttimestamp(uint64_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.DeviceListMetadata) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > senderkeyindexes_; + mutable std::atomic _senderkeyindexes_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > recipientkeyindexes_; + mutable std::atomic _recipientkeyindexes_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr senderkeyhash_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr recipientkeyhash_; + uint64_t sendertimestamp_; + uint64_t recipienttimestamp_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class DeviceProps_AppVersion final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.DeviceProps.AppVersion) */ { + public: + inline DeviceProps_AppVersion() : DeviceProps_AppVersion(nullptr) {} + ~DeviceProps_AppVersion() override; + explicit PROTOBUF_CONSTEXPR DeviceProps_AppVersion(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + DeviceProps_AppVersion(const DeviceProps_AppVersion& from); + DeviceProps_AppVersion(DeviceProps_AppVersion&& from) noexcept + : DeviceProps_AppVersion() { + *this = ::std::move(from); + } + + inline DeviceProps_AppVersion& operator=(const DeviceProps_AppVersion& from) { + CopyFrom(from); + return *this; + } + inline DeviceProps_AppVersion& operator=(DeviceProps_AppVersion&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const DeviceProps_AppVersion& default_instance() { + return *internal_default_instance(); + } + static inline const DeviceProps_AppVersion* internal_default_instance() { + return reinterpret_cast( + &_DeviceProps_AppVersion_default_instance_); + } + static constexpr int kIndexInFileMessages = + 27; + + friend void swap(DeviceProps_AppVersion& a, DeviceProps_AppVersion& b) { + a.Swap(&b); + } + inline void Swap(DeviceProps_AppVersion* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(DeviceProps_AppVersion* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + DeviceProps_AppVersion* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const DeviceProps_AppVersion& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const DeviceProps_AppVersion& from) { + DeviceProps_AppVersion::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(DeviceProps_AppVersion* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.DeviceProps.AppVersion"; + } + protected: + explicit DeviceProps_AppVersion(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kPrimaryFieldNumber = 1, + kSecondaryFieldNumber = 2, + kTertiaryFieldNumber = 3, + kQuaternaryFieldNumber = 4, + kQuinaryFieldNumber = 5, + }; + // optional uint32 primary = 1; + bool has_primary() const; + private: + bool _internal_has_primary() const; + public: + void clear_primary(); + uint32_t primary() const; + void set_primary(uint32_t value); + private: + uint32_t _internal_primary() const; + void _internal_set_primary(uint32_t value); + public: + + // optional uint32 secondary = 2; + bool has_secondary() const; + private: + bool _internal_has_secondary() const; + public: + void clear_secondary(); + uint32_t secondary() const; + void set_secondary(uint32_t value); + private: + uint32_t _internal_secondary() const; + void _internal_set_secondary(uint32_t value); + public: + + // optional uint32 tertiary = 3; + bool has_tertiary() const; + private: + bool _internal_has_tertiary() const; + public: + void clear_tertiary(); + uint32_t tertiary() const; + void set_tertiary(uint32_t value); + private: + uint32_t _internal_tertiary() const; + void _internal_set_tertiary(uint32_t value); + public: + + // optional uint32 quaternary = 4; + bool has_quaternary() const; + private: + bool _internal_has_quaternary() const; + public: + void clear_quaternary(); + uint32_t quaternary() const; + void set_quaternary(uint32_t value); + private: + uint32_t _internal_quaternary() const; + void _internal_set_quaternary(uint32_t value); + public: + + // optional uint32 quinary = 5; + bool has_quinary() const; + private: + bool _internal_has_quinary() const; + public: + void clear_quinary(); + uint32_t quinary() const; + void set_quinary(uint32_t value); + private: + uint32_t _internal_quinary() const; + void _internal_set_quinary(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.DeviceProps.AppVersion) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + uint32_t primary_; + uint32_t secondary_; + uint32_t tertiary_; + uint32_t quaternary_; + uint32_t quinary_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class DeviceProps final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.DeviceProps) */ { + public: + inline DeviceProps() : DeviceProps(nullptr) {} + ~DeviceProps() override; + explicit PROTOBUF_CONSTEXPR DeviceProps(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + DeviceProps(const DeviceProps& from); + DeviceProps(DeviceProps&& from) noexcept + : DeviceProps() { + *this = ::std::move(from); + } + + inline DeviceProps& operator=(const DeviceProps& from) { + CopyFrom(from); + return *this; + } + inline DeviceProps& operator=(DeviceProps&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const DeviceProps& default_instance() { + return *internal_default_instance(); + } + static inline const DeviceProps* internal_default_instance() { + return reinterpret_cast( + &_DeviceProps_default_instance_); + } + static constexpr int kIndexInFileMessages = + 28; + + friend void swap(DeviceProps& a, DeviceProps& b) { + a.Swap(&b); + } + inline void Swap(DeviceProps* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(DeviceProps* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + DeviceProps* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const DeviceProps& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const DeviceProps& from) { + DeviceProps::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(DeviceProps* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.DeviceProps"; + } + protected: + explicit DeviceProps(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef DeviceProps_AppVersion AppVersion; + + typedef DeviceProps_PlatformType PlatformType; + static constexpr PlatformType UNKNOWN = + DeviceProps_PlatformType_UNKNOWN; + static constexpr PlatformType CHROME = + DeviceProps_PlatformType_CHROME; + static constexpr PlatformType FIREFOX = + DeviceProps_PlatformType_FIREFOX; + static constexpr PlatformType IE = + DeviceProps_PlatformType_IE; + static constexpr PlatformType OPERA = + DeviceProps_PlatformType_OPERA; + static constexpr PlatformType SAFARI = + DeviceProps_PlatformType_SAFARI; + static constexpr PlatformType EDGE = + DeviceProps_PlatformType_EDGE; + static constexpr PlatformType DESKTOP = + DeviceProps_PlatformType_DESKTOP; + static constexpr PlatformType IPAD = + DeviceProps_PlatformType_IPAD; + static constexpr PlatformType ANDROID_TABLET = + DeviceProps_PlatformType_ANDROID_TABLET; + static constexpr PlatformType OHANA = + DeviceProps_PlatformType_OHANA; + static constexpr PlatformType ALOHA = + DeviceProps_PlatformType_ALOHA; + static constexpr PlatformType CATALINA = + DeviceProps_PlatformType_CATALINA; + static constexpr PlatformType TCL_TV = + DeviceProps_PlatformType_TCL_TV; + static inline bool PlatformType_IsValid(int value) { + return DeviceProps_PlatformType_IsValid(value); + } + static constexpr PlatformType PlatformType_MIN = + DeviceProps_PlatformType_PlatformType_MIN; + static constexpr PlatformType PlatformType_MAX = + DeviceProps_PlatformType_PlatformType_MAX; + static constexpr int PlatformType_ARRAYSIZE = + DeviceProps_PlatformType_PlatformType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + PlatformType_descriptor() { + return DeviceProps_PlatformType_descriptor(); + } + template + static inline const std::string& PlatformType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function PlatformType_Name."); + return DeviceProps_PlatformType_Name(enum_t_value); + } + static inline bool PlatformType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + PlatformType* value) { + return DeviceProps_PlatformType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kOsFieldNumber = 1, + kVersionFieldNumber = 2, + kPlatformTypeFieldNumber = 3, + kRequireFullSyncFieldNumber = 4, + }; + // optional string os = 1; + bool has_os() const; + private: + bool _internal_has_os() const; + public: + void clear_os(); + const std::string& os() const; + template + void set_os(ArgT0&& arg0, ArgT... args); + std::string* mutable_os(); + PROTOBUF_NODISCARD std::string* release_os(); + void set_allocated_os(std::string* os); + private: + const std::string& _internal_os() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_os(const std::string& value); + std::string* _internal_mutable_os(); + public: + + // optional .proto.DeviceProps.AppVersion version = 2; + bool has_version() const; + private: + bool _internal_has_version() const; + public: + void clear_version(); + const ::proto::DeviceProps_AppVersion& version() const; + PROTOBUF_NODISCARD ::proto::DeviceProps_AppVersion* release_version(); + ::proto::DeviceProps_AppVersion* mutable_version(); + void set_allocated_version(::proto::DeviceProps_AppVersion* version); + private: + const ::proto::DeviceProps_AppVersion& _internal_version() const; + ::proto::DeviceProps_AppVersion* _internal_mutable_version(); + public: + void unsafe_arena_set_allocated_version( + ::proto::DeviceProps_AppVersion* version); + ::proto::DeviceProps_AppVersion* unsafe_arena_release_version(); + + // optional .proto.DeviceProps.PlatformType platformType = 3; + bool has_platformtype() const; + private: + bool _internal_has_platformtype() const; + public: + void clear_platformtype(); + ::proto::DeviceProps_PlatformType platformtype() const; + void set_platformtype(::proto::DeviceProps_PlatformType value); + private: + ::proto::DeviceProps_PlatformType _internal_platformtype() const; + void _internal_set_platformtype(::proto::DeviceProps_PlatformType value); + public: + + // optional bool requireFullSync = 4; + bool has_requirefullsync() const; + private: + bool _internal_has_requirefullsync() const; + public: + void clear_requirefullsync(); + bool requirefullsync() const; + void set_requirefullsync(bool value); + private: + bool _internal_requirefullsync() const; + void _internal_set_requirefullsync(bool value); + public: + + // @@protoc_insertion_point(class_scope:proto.DeviceProps) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr os_; + ::proto::DeviceProps_AppVersion* version_; + int platformtype_; + bool requirefullsync_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class DisappearingMode final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.DisappearingMode) */ { + public: + inline DisappearingMode() : DisappearingMode(nullptr) {} + ~DisappearingMode() override; + explicit PROTOBUF_CONSTEXPR DisappearingMode(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + DisappearingMode(const DisappearingMode& from); + DisappearingMode(DisappearingMode&& from) noexcept + : DisappearingMode() { + *this = ::std::move(from); + } + + inline DisappearingMode& operator=(const DisappearingMode& from) { + CopyFrom(from); + return *this; + } + inline DisappearingMode& operator=(DisappearingMode&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const DisappearingMode& default_instance() { + return *internal_default_instance(); + } + static inline const DisappearingMode* internal_default_instance() { + return reinterpret_cast( + &_DisappearingMode_default_instance_); + } + static constexpr int kIndexInFileMessages = + 29; + + friend void swap(DisappearingMode& a, DisappearingMode& b) { + a.Swap(&b); + } + inline void Swap(DisappearingMode* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(DisappearingMode* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + DisappearingMode* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const DisappearingMode& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const DisappearingMode& from) { + DisappearingMode::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(DisappearingMode* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.DisappearingMode"; + } + protected: + explicit DisappearingMode(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef DisappearingMode_Initiator Initiator; + static constexpr Initiator CHANGED_IN_CHAT = + DisappearingMode_Initiator_CHANGED_IN_CHAT; + static constexpr Initiator INITIATED_BY_ME = + DisappearingMode_Initiator_INITIATED_BY_ME; + static constexpr Initiator INITIATED_BY_OTHER = + DisappearingMode_Initiator_INITIATED_BY_OTHER; + static inline bool Initiator_IsValid(int value) { + return DisappearingMode_Initiator_IsValid(value); + } + static constexpr Initiator Initiator_MIN = + DisappearingMode_Initiator_Initiator_MIN; + static constexpr Initiator Initiator_MAX = + DisappearingMode_Initiator_Initiator_MAX; + static constexpr int Initiator_ARRAYSIZE = + DisappearingMode_Initiator_Initiator_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + Initiator_descriptor() { + return DisappearingMode_Initiator_descriptor(); + } + template + static inline const std::string& Initiator_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Initiator_Name."); + return DisappearingMode_Initiator_Name(enum_t_value); + } + static inline bool Initiator_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Initiator* value) { + return DisappearingMode_Initiator_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kInitiatorFieldNumber = 1, + }; + // optional .proto.DisappearingMode.Initiator initiator = 1; + bool has_initiator() const; + private: + bool _internal_has_initiator() const; + public: + void clear_initiator(); + ::proto::DisappearingMode_Initiator initiator() const; + void set_initiator(::proto::DisappearingMode_Initiator value); + private: + ::proto::DisappearingMode_Initiator _internal_initiator() const; + void _internal_set_initiator(::proto::DisappearingMode_Initiator value); + public: + + // @@protoc_insertion_point(class_scope:proto.DisappearingMode) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + int initiator_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class EphemeralSetting final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.EphemeralSetting) */ { + public: + inline EphemeralSetting() : EphemeralSetting(nullptr) {} + ~EphemeralSetting() override; + explicit PROTOBUF_CONSTEXPR EphemeralSetting(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + EphemeralSetting(const EphemeralSetting& from); + EphemeralSetting(EphemeralSetting&& from) noexcept + : EphemeralSetting() { + *this = ::std::move(from); + } + + inline EphemeralSetting& operator=(const EphemeralSetting& from) { + CopyFrom(from); + return *this; + } + inline EphemeralSetting& operator=(EphemeralSetting&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const EphemeralSetting& default_instance() { + return *internal_default_instance(); + } + static inline const EphemeralSetting* internal_default_instance() { + return reinterpret_cast( + &_EphemeralSetting_default_instance_); + } + static constexpr int kIndexInFileMessages = + 30; + + friend void swap(EphemeralSetting& a, EphemeralSetting& b) { + a.Swap(&b); + } + inline void Swap(EphemeralSetting* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(EphemeralSetting* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + EphemeralSetting* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const EphemeralSetting& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const EphemeralSetting& from) { + EphemeralSetting::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(EphemeralSetting* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.EphemeralSetting"; + } + protected: + explicit EphemeralSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kTimestampFieldNumber = 2, + kDurationFieldNumber = 1, + }; + // optional sfixed64 timestamp = 2; + bool has_timestamp() const; + private: + bool _internal_has_timestamp() const; + public: + void clear_timestamp(); + int64_t timestamp() const; + void set_timestamp(int64_t value); + private: + int64_t _internal_timestamp() const; + void _internal_set_timestamp(int64_t value); + public: + + // optional sfixed32 duration = 1; + bool has_duration() const; + private: + bool _internal_has_duration() const; + public: + void clear_duration(); + int32_t duration() const; + void set_duration(int32_t value); + private: + int32_t _internal_duration() const; + void _internal_set_duration(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.EphemeralSetting) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + int64_t timestamp_; + int32_t duration_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class ExitCode final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ExitCode) */ { + public: + inline ExitCode() : ExitCode(nullptr) {} + ~ExitCode() override; + explicit PROTOBUF_CONSTEXPR ExitCode(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ExitCode(const ExitCode& from); + ExitCode(ExitCode&& from) noexcept + : ExitCode() { + *this = ::std::move(from); + } + + inline ExitCode& operator=(const ExitCode& from) { + CopyFrom(from); + return *this; + } + inline ExitCode& operator=(ExitCode&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ExitCode& default_instance() { + return *internal_default_instance(); + } + static inline const ExitCode* internal_default_instance() { + return reinterpret_cast( + &_ExitCode_default_instance_); + } + static constexpr int kIndexInFileMessages = + 31; + + friend void swap(ExitCode& a, ExitCode& b) { + a.Swap(&b); + } + inline void Swap(ExitCode* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ExitCode* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ExitCode* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ExitCode& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const ExitCode& from) { + ExitCode::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ExitCode* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.ExitCode"; + } + protected: + explicit ExitCode(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kTextFieldNumber = 2, + kCodeFieldNumber = 1, + }; + // optional string text = 2; + bool has_text() const; + private: + bool _internal_has_text() const; + public: + void clear_text(); + const std::string& text() const; + template + void set_text(ArgT0&& arg0, ArgT... args); + std::string* mutable_text(); + PROTOBUF_NODISCARD std::string* release_text(); + void set_allocated_text(std::string* text); + private: + const std::string& _internal_text() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value); + std::string* _internal_mutable_text(); + public: + + // optional uint64 code = 1; + bool has_code() const; + private: + bool _internal_has_code() const; + public: + void clear_code(); + uint64_t code() const; + void set_code(uint64_t value); + private: + uint64_t _internal_code() const; + void _internal_set_code(uint64_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.ExitCode) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_; + uint64_t code_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class ExternalBlobReference final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ExternalBlobReference) */ { + public: + inline ExternalBlobReference() : ExternalBlobReference(nullptr) {} + ~ExternalBlobReference() override; + explicit PROTOBUF_CONSTEXPR ExternalBlobReference(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ExternalBlobReference(const ExternalBlobReference& from); + ExternalBlobReference(ExternalBlobReference&& from) noexcept + : ExternalBlobReference() { + *this = ::std::move(from); + } + + inline ExternalBlobReference& operator=(const ExternalBlobReference& from) { + CopyFrom(from); + return *this; + } + inline ExternalBlobReference& operator=(ExternalBlobReference&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ExternalBlobReference& default_instance() { + return *internal_default_instance(); + } + static inline const ExternalBlobReference* internal_default_instance() { + return reinterpret_cast( + &_ExternalBlobReference_default_instance_); + } + static constexpr int kIndexInFileMessages = + 32; + + friend void swap(ExternalBlobReference& a, ExternalBlobReference& b) { + a.Swap(&b); + } + inline void Swap(ExternalBlobReference* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ExternalBlobReference* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ExternalBlobReference* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ExternalBlobReference& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const ExternalBlobReference& from) { + ExternalBlobReference::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ExternalBlobReference* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.ExternalBlobReference"; + } + protected: + explicit ExternalBlobReference(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMediaKeyFieldNumber = 1, + kDirectPathFieldNumber = 2, + kHandleFieldNumber = 3, + kFileSha256FieldNumber = 5, + kFileEncSha256FieldNumber = 6, + kFileSizeBytesFieldNumber = 4, + }; + // optional bytes mediaKey = 1; + bool has_mediakey() const; + private: + bool _internal_has_mediakey() const; + public: + void clear_mediakey(); + const std::string& mediakey() const; + template + void set_mediakey(ArgT0&& arg0, ArgT... args); + std::string* mutable_mediakey(); + PROTOBUF_NODISCARD std::string* release_mediakey(); + void set_allocated_mediakey(std::string* mediakey); + private: + const std::string& _internal_mediakey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value); + std::string* _internal_mutable_mediakey(); + public: + + // optional string directPath = 2; + bool has_directpath() const; + private: + bool _internal_has_directpath() const; + public: + void clear_directpath(); + const std::string& directpath() const; + template + void set_directpath(ArgT0&& arg0, ArgT... args); + std::string* mutable_directpath(); + PROTOBUF_NODISCARD std::string* release_directpath(); + void set_allocated_directpath(std::string* directpath); + private: + const std::string& _internal_directpath() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value); + std::string* _internal_mutable_directpath(); + public: + + // optional string handle = 3; + bool has_handle() const; + private: + bool _internal_has_handle() const; + public: + void clear_handle(); + const std::string& handle() const; + template + void set_handle(ArgT0&& arg0, ArgT... args); + std::string* mutable_handle(); + PROTOBUF_NODISCARD std::string* release_handle(); + void set_allocated_handle(std::string* handle); + private: + const std::string& _internal_handle() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_handle(const std::string& value); + std::string* _internal_mutable_handle(); + public: + + // optional bytes fileSha256 = 5; + bool has_filesha256() const; + private: + bool _internal_has_filesha256() const; + public: + void clear_filesha256(); + const std::string& filesha256() const; + template + void set_filesha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_filesha256(); + PROTOBUF_NODISCARD std::string* release_filesha256(); + void set_allocated_filesha256(std::string* filesha256); + private: + const std::string& _internal_filesha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value); + std::string* _internal_mutable_filesha256(); + public: + + // optional bytes fileEncSha256 = 6; + bool has_fileencsha256() const; + private: + bool _internal_has_fileencsha256() const; + public: + void clear_fileencsha256(); + const std::string& fileencsha256() const; + template + void set_fileencsha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_fileencsha256(); + PROTOBUF_NODISCARD std::string* release_fileencsha256(); + void set_allocated_fileencsha256(std::string* fileencsha256); + private: + const std::string& _internal_fileencsha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value); + std::string* _internal_mutable_fileencsha256(); + public: + + // optional uint64 fileSizeBytes = 4; + bool has_filesizebytes() const; + private: + bool _internal_has_filesizebytes() const; + public: + void clear_filesizebytes(); + uint64_t filesizebytes() const; + void set_filesizebytes(uint64_t value); + private: + uint64_t _internal_filesizebytes() const; + void _internal_set_filesizebytes(uint64_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.ExternalBlobReference) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr handle_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_; + uint64_t filesizebytes_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class GlobalSettings final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.GlobalSettings) */ { + public: + inline GlobalSettings() : GlobalSettings(nullptr) {} + ~GlobalSettings() override; + explicit PROTOBUF_CONSTEXPR GlobalSettings(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + GlobalSettings(const GlobalSettings& from); + GlobalSettings(GlobalSettings&& from) noexcept + : GlobalSettings() { + *this = ::std::move(from); + } + + inline GlobalSettings& operator=(const GlobalSettings& from) { + CopyFrom(from); + return *this; + } + inline GlobalSettings& operator=(GlobalSettings&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const GlobalSettings& default_instance() { + return *internal_default_instance(); + } + static inline const GlobalSettings* internal_default_instance() { + return reinterpret_cast( + &_GlobalSettings_default_instance_); + } + static constexpr int kIndexInFileMessages = + 33; + + friend void swap(GlobalSettings& a, GlobalSettings& b) { + a.Swap(&b); + } + inline void Swap(GlobalSettings* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(GlobalSettings* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + GlobalSettings* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const GlobalSettings& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const GlobalSettings& from) { + GlobalSettings::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(GlobalSettings* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.GlobalSettings"; + } + protected: + explicit GlobalSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kLightThemeWallpaperFieldNumber = 1, + kDarkThemeWallpaperFieldNumber = 3, + kAutoDownloadWiFiFieldNumber = 4, + kAutoDownloadCellularFieldNumber = 5, + kAutoDownloadRoamingFieldNumber = 6, + kMediaVisibilityFieldNumber = 2, + kShowIndividualNotificationsPreviewFieldNumber = 7, + kShowGroupNotificationsPreviewFieldNumber = 8, + kDisappearingModeTimestampFieldNumber = 10, + kDisappearingModeDurationFieldNumber = 9, + }; + // optional .proto.WallpaperSettings lightThemeWallpaper = 1; + bool has_lightthemewallpaper() const; + private: + bool _internal_has_lightthemewallpaper() const; + public: + void clear_lightthemewallpaper(); + const ::proto::WallpaperSettings& lightthemewallpaper() const; + PROTOBUF_NODISCARD ::proto::WallpaperSettings* release_lightthemewallpaper(); + ::proto::WallpaperSettings* mutable_lightthemewallpaper(); + void set_allocated_lightthemewallpaper(::proto::WallpaperSettings* lightthemewallpaper); + private: + const ::proto::WallpaperSettings& _internal_lightthemewallpaper() const; + ::proto::WallpaperSettings* _internal_mutable_lightthemewallpaper(); + public: + void unsafe_arena_set_allocated_lightthemewallpaper( + ::proto::WallpaperSettings* lightthemewallpaper); + ::proto::WallpaperSettings* unsafe_arena_release_lightthemewallpaper(); + + // optional .proto.WallpaperSettings darkThemeWallpaper = 3; + bool has_darkthemewallpaper() const; + private: + bool _internal_has_darkthemewallpaper() const; + public: + void clear_darkthemewallpaper(); + const ::proto::WallpaperSettings& darkthemewallpaper() const; + PROTOBUF_NODISCARD ::proto::WallpaperSettings* release_darkthemewallpaper(); + ::proto::WallpaperSettings* mutable_darkthemewallpaper(); + void set_allocated_darkthemewallpaper(::proto::WallpaperSettings* darkthemewallpaper); + private: + const ::proto::WallpaperSettings& _internal_darkthemewallpaper() const; + ::proto::WallpaperSettings* _internal_mutable_darkthemewallpaper(); + public: + void unsafe_arena_set_allocated_darkthemewallpaper( + ::proto::WallpaperSettings* darkthemewallpaper); + ::proto::WallpaperSettings* unsafe_arena_release_darkthemewallpaper(); + + // optional .proto.AutoDownloadSettings autoDownloadWiFi = 4; + bool has_autodownloadwifi() const; + private: + bool _internal_has_autodownloadwifi() const; + public: + void clear_autodownloadwifi(); + const ::proto::AutoDownloadSettings& autodownloadwifi() const; + PROTOBUF_NODISCARD ::proto::AutoDownloadSettings* release_autodownloadwifi(); + ::proto::AutoDownloadSettings* mutable_autodownloadwifi(); + void set_allocated_autodownloadwifi(::proto::AutoDownloadSettings* autodownloadwifi); + private: + const ::proto::AutoDownloadSettings& _internal_autodownloadwifi() const; + ::proto::AutoDownloadSettings* _internal_mutable_autodownloadwifi(); + public: + void unsafe_arena_set_allocated_autodownloadwifi( + ::proto::AutoDownloadSettings* autodownloadwifi); + ::proto::AutoDownloadSettings* unsafe_arena_release_autodownloadwifi(); + + // optional .proto.AutoDownloadSettings autoDownloadCellular = 5; + bool has_autodownloadcellular() const; + private: + bool _internal_has_autodownloadcellular() const; + public: + void clear_autodownloadcellular(); + const ::proto::AutoDownloadSettings& autodownloadcellular() const; + PROTOBUF_NODISCARD ::proto::AutoDownloadSettings* release_autodownloadcellular(); + ::proto::AutoDownloadSettings* mutable_autodownloadcellular(); + void set_allocated_autodownloadcellular(::proto::AutoDownloadSettings* autodownloadcellular); + private: + const ::proto::AutoDownloadSettings& _internal_autodownloadcellular() const; + ::proto::AutoDownloadSettings* _internal_mutable_autodownloadcellular(); + public: + void unsafe_arena_set_allocated_autodownloadcellular( + ::proto::AutoDownloadSettings* autodownloadcellular); + ::proto::AutoDownloadSettings* unsafe_arena_release_autodownloadcellular(); + + // optional .proto.AutoDownloadSettings autoDownloadRoaming = 6; + bool has_autodownloadroaming() const; + private: + bool _internal_has_autodownloadroaming() const; + public: + void clear_autodownloadroaming(); + const ::proto::AutoDownloadSettings& autodownloadroaming() const; + PROTOBUF_NODISCARD ::proto::AutoDownloadSettings* release_autodownloadroaming(); + ::proto::AutoDownloadSettings* mutable_autodownloadroaming(); + void set_allocated_autodownloadroaming(::proto::AutoDownloadSettings* autodownloadroaming); + private: + const ::proto::AutoDownloadSettings& _internal_autodownloadroaming() const; + ::proto::AutoDownloadSettings* _internal_mutable_autodownloadroaming(); + public: + void unsafe_arena_set_allocated_autodownloadroaming( + ::proto::AutoDownloadSettings* autodownloadroaming); + ::proto::AutoDownloadSettings* unsafe_arena_release_autodownloadroaming(); + + // optional .proto.MediaVisibility mediaVisibility = 2; + bool has_mediavisibility() const; + private: + bool _internal_has_mediavisibility() const; + public: + void clear_mediavisibility(); + ::proto::MediaVisibility mediavisibility() const; + void set_mediavisibility(::proto::MediaVisibility value); + private: + ::proto::MediaVisibility _internal_mediavisibility() const; + void _internal_set_mediavisibility(::proto::MediaVisibility value); + public: + + // optional bool showIndividualNotificationsPreview = 7; + bool has_showindividualnotificationspreview() const; + private: + bool _internal_has_showindividualnotificationspreview() const; + public: + void clear_showindividualnotificationspreview(); + bool showindividualnotificationspreview() const; + void set_showindividualnotificationspreview(bool value); + private: + bool _internal_showindividualnotificationspreview() const; + void _internal_set_showindividualnotificationspreview(bool value); + public: + + // optional bool showGroupNotificationsPreview = 8; + bool has_showgroupnotificationspreview() const; + private: + bool _internal_has_showgroupnotificationspreview() const; + public: + void clear_showgroupnotificationspreview(); + bool showgroupnotificationspreview() const; + void set_showgroupnotificationspreview(bool value); + private: + bool _internal_showgroupnotificationspreview() const; + void _internal_set_showgroupnotificationspreview(bool value); + public: + + // optional int64 disappearingModeTimestamp = 10; + bool has_disappearingmodetimestamp() const; + private: + bool _internal_has_disappearingmodetimestamp() const; + public: + void clear_disappearingmodetimestamp(); + int64_t disappearingmodetimestamp() const; + void set_disappearingmodetimestamp(int64_t value); + private: + int64_t _internal_disappearingmodetimestamp() const; + void _internal_set_disappearingmodetimestamp(int64_t value); + public: + + // optional int32 disappearingModeDuration = 9; + bool has_disappearingmodeduration() const; + private: + bool _internal_has_disappearingmodeduration() const; + public: + void clear_disappearingmodeduration(); + int32_t disappearingmodeduration() const; + void set_disappearingmodeduration(int32_t value); + private: + int32_t _internal_disappearingmodeduration() const; + void _internal_set_disappearingmodeduration(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.GlobalSettings) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::proto::WallpaperSettings* lightthemewallpaper_; + ::proto::WallpaperSettings* darkthemewallpaper_; + ::proto::AutoDownloadSettings* autodownloadwifi_; + ::proto::AutoDownloadSettings* autodownloadcellular_; + ::proto::AutoDownloadSettings* autodownloadroaming_; + int mediavisibility_; + bool showindividualnotificationspreview_; + bool showgroupnotificationspreview_; + int64_t disappearingmodetimestamp_; + int32_t disappearingmodeduration_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class GroupParticipant final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.GroupParticipant) */ { + public: + inline GroupParticipant() : GroupParticipant(nullptr) {} + ~GroupParticipant() override; + explicit PROTOBUF_CONSTEXPR GroupParticipant(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + GroupParticipant(const GroupParticipant& from); + GroupParticipant(GroupParticipant&& from) noexcept + : GroupParticipant() { + *this = ::std::move(from); + } + + inline GroupParticipant& operator=(const GroupParticipant& from) { + CopyFrom(from); + return *this; + } + inline GroupParticipant& operator=(GroupParticipant&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const GroupParticipant& default_instance() { + return *internal_default_instance(); + } + static inline const GroupParticipant* internal_default_instance() { + return reinterpret_cast( + &_GroupParticipant_default_instance_); + } + static constexpr int kIndexInFileMessages = + 34; + + friend void swap(GroupParticipant& a, GroupParticipant& b) { + a.Swap(&b); + } + inline void Swap(GroupParticipant* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(GroupParticipant* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + GroupParticipant* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const GroupParticipant& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const GroupParticipant& from) { + GroupParticipant::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(GroupParticipant* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.GroupParticipant"; + } + protected: + explicit GroupParticipant(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef GroupParticipant_Rank Rank; + static constexpr Rank REGULAR = + GroupParticipant_Rank_REGULAR; + static constexpr Rank ADMIN = + GroupParticipant_Rank_ADMIN; + static constexpr Rank SUPERADMIN = + GroupParticipant_Rank_SUPERADMIN; + static inline bool Rank_IsValid(int value) { + return GroupParticipant_Rank_IsValid(value); + } + static constexpr Rank Rank_MIN = + GroupParticipant_Rank_Rank_MIN; + static constexpr Rank Rank_MAX = + GroupParticipant_Rank_Rank_MAX; + static constexpr int Rank_ARRAYSIZE = + GroupParticipant_Rank_Rank_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + Rank_descriptor() { + return GroupParticipant_Rank_descriptor(); + } + template + static inline const std::string& Rank_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Rank_Name."); + return GroupParticipant_Rank_Name(enum_t_value); + } + static inline bool Rank_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Rank* value) { + return GroupParticipant_Rank_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kUserJidFieldNumber = 1, + kRankFieldNumber = 2, + }; + // required string userJid = 1; + bool has_userjid() const; + private: + bool _internal_has_userjid() const; + public: + void clear_userjid(); + const std::string& userjid() const; + template + void set_userjid(ArgT0&& arg0, ArgT... args); + std::string* mutable_userjid(); + PROTOBUF_NODISCARD std::string* release_userjid(); + void set_allocated_userjid(std::string* userjid); + private: + const std::string& _internal_userjid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_userjid(const std::string& value); + std::string* _internal_mutable_userjid(); + public: + + // optional .proto.GroupParticipant.Rank rank = 2; + bool has_rank() const; + private: + bool _internal_has_rank() const; + public: + void clear_rank(); + ::proto::GroupParticipant_Rank rank() const; + void set_rank(::proto::GroupParticipant_Rank value); + private: + ::proto::GroupParticipant_Rank _internal_rank() const; + void _internal_set_rank(::proto::GroupParticipant_Rank value); + public: + + // @@protoc_insertion_point(class_scope:proto.GroupParticipant) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userjid_; + int rank_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class HandshakeMessage_ClientFinish final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HandshakeMessage.ClientFinish) */ { + public: + inline HandshakeMessage_ClientFinish() : HandshakeMessage_ClientFinish(nullptr) {} + ~HandshakeMessage_ClientFinish() override; + explicit PROTOBUF_CONSTEXPR HandshakeMessage_ClientFinish(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + HandshakeMessage_ClientFinish(const HandshakeMessage_ClientFinish& from); + HandshakeMessage_ClientFinish(HandshakeMessage_ClientFinish&& from) noexcept + : HandshakeMessage_ClientFinish() { + *this = ::std::move(from); + } + + inline HandshakeMessage_ClientFinish& operator=(const HandshakeMessage_ClientFinish& from) { + CopyFrom(from); + return *this; + } + inline HandshakeMessage_ClientFinish& operator=(HandshakeMessage_ClientFinish&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const HandshakeMessage_ClientFinish& default_instance() { + return *internal_default_instance(); + } + static inline const HandshakeMessage_ClientFinish* internal_default_instance() { + return reinterpret_cast( + &_HandshakeMessage_ClientFinish_default_instance_); + } + static constexpr int kIndexInFileMessages = + 35; + + friend void swap(HandshakeMessage_ClientFinish& a, HandshakeMessage_ClientFinish& b) { + a.Swap(&b); + } + inline void Swap(HandshakeMessage_ClientFinish* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(HandshakeMessage_ClientFinish* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + HandshakeMessage_ClientFinish* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const HandshakeMessage_ClientFinish& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const HandshakeMessage_ClientFinish& from) { + HandshakeMessage_ClientFinish::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(HandshakeMessage_ClientFinish* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.HandshakeMessage.ClientFinish"; + } + protected: + explicit HandshakeMessage_ClientFinish(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kStaticFieldNumber = 1, + kPayloadFieldNumber = 2, + }; + // optional bytes static = 1; + bool has_static_() const; + private: + bool _internal_has_static_() const; + public: + void clear_static_(); + const std::string& static_() const; + template + void set_static_(ArgT0&& arg0, ArgT... args); + std::string* mutable_static_(); + PROTOBUF_NODISCARD std::string* release_static_(); + void set_allocated_static_(std::string* static_); + private: + const std::string& _internal_static_() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_static_(const std::string& value); + std::string* _internal_mutable_static_(); + public: + + // optional bytes payload = 2; + bool has_payload() const; + private: + bool _internal_has_payload() const; + public: + void clear_payload(); + const std::string& payload() const; + template + void set_payload(ArgT0&& arg0, ArgT... args); + std::string* mutable_payload(); + PROTOBUF_NODISCARD std::string* release_payload(); + void set_allocated_payload(std::string* payload); + private: + const std::string& _internal_payload() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_payload(const std::string& value); + std::string* _internal_mutable_payload(); + public: + + // @@protoc_insertion_point(class_scope:proto.HandshakeMessage.ClientFinish) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr static__; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class HandshakeMessage_ClientHello final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HandshakeMessage.ClientHello) */ { + public: + inline HandshakeMessage_ClientHello() : HandshakeMessage_ClientHello(nullptr) {} + ~HandshakeMessage_ClientHello() override; + explicit PROTOBUF_CONSTEXPR HandshakeMessage_ClientHello(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + HandshakeMessage_ClientHello(const HandshakeMessage_ClientHello& from); + HandshakeMessage_ClientHello(HandshakeMessage_ClientHello&& from) noexcept + : HandshakeMessage_ClientHello() { + *this = ::std::move(from); + } + + inline HandshakeMessage_ClientHello& operator=(const HandshakeMessage_ClientHello& from) { + CopyFrom(from); + return *this; + } + inline HandshakeMessage_ClientHello& operator=(HandshakeMessage_ClientHello&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const HandshakeMessage_ClientHello& default_instance() { + return *internal_default_instance(); + } + static inline const HandshakeMessage_ClientHello* internal_default_instance() { + return reinterpret_cast( + &_HandshakeMessage_ClientHello_default_instance_); + } + static constexpr int kIndexInFileMessages = + 36; + + friend void swap(HandshakeMessage_ClientHello& a, HandshakeMessage_ClientHello& b) { + a.Swap(&b); + } + inline void Swap(HandshakeMessage_ClientHello* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(HandshakeMessage_ClientHello* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + HandshakeMessage_ClientHello* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const HandshakeMessage_ClientHello& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const HandshakeMessage_ClientHello& from) { + HandshakeMessage_ClientHello::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(HandshakeMessage_ClientHello* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.HandshakeMessage.ClientHello"; + } + protected: + explicit HandshakeMessage_ClientHello(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kEphemeralFieldNumber = 1, + kStaticFieldNumber = 2, + kPayloadFieldNumber = 3, + }; + // optional bytes ephemeral = 1; + bool has_ephemeral() const; + private: + bool _internal_has_ephemeral() const; + public: + void clear_ephemeral(); + const std::string& ephemeral() const; + template + void set_ephemeral(ArgT0&& arg0, ArgT... args); + std::string* mutable_ephemeral(); + PROTOBUF_NODISCARD std::string* release_ephemeral(); + void set_allocated_ephemeral(std::string* ephemeral); + private: + const std::string& _internal_ephemeral() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_ephemeral(const std::string& value); + std::string* _internal_mutable_ephemeral(); + public: + + // optional bytes static = 2; + bool has_static_() const; + private: + bool _internal_has_static_() const; + public: + void clear_static_(); + const std::string& static_() const; + template + void set_static_(ArgT0&& arg0, ArgT... args); + std::string* mutable_static_(); + PROTOBUF_NODISCARD std::string* release_static_(); + void set_allocated_static_(std::string* static_); + private: + const std::string& _internal_static_() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_static_(const std::string& value); + std::string* _internal_mutable_static_(); + public: + + // optional bytes payload = 3; + bool has_payload() const; + private: + bool _internal_has_payload() const; + public: + void clear_payload(); + const std::string& payload() const; + template + void set_payload(ArgT0&& arg0, ArgT... args); + std::string* mutable_payload(); + PROTOBUF_NODISCARD std::string* release_payload(); + void set_allocated_payload(std::string* payload); + private: + const std::string& _internal_payload() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_payload(const std::string& value); + std::string* _internal_mutable_payload(); + public: + + // @@protoc_insertion_point(class_scope:proto.HandshakeMessage.ClientHello) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ephemeral_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr static__; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class HandshakeMessage_ServerHello final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HandshakeMessage.ServerHello) */ { + public: + inline HandshakeMessage_ServerHello() : HandshakeMessage_ServerHello(nullptr) {} + ~HandshakeMessage_ServerHello() override; + explicit PROTOBUF_CONSTEXPR HandshakeMessage_ServerHello(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + HandshakeMessage_ServerHello(const HandshakeMessage_ServerHello& from); + HandshakeMessage_ServerHello(HandshakeMessage_ServerHello&& from) noexcept + : HandshakeMessage_ServerHello() { + *this = ::std::move(from); + } + + inline HandshakeMessage_ServerHello& operator=(const HandshakeMessage_ServerHello& from) { + CopyFrom(from); + return *this; + } + inline HandshakeMessage_ServerHello& operator=(HandshakeMessage_ServerHello&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const HandshakeMessage_ServerHello& default_instance() { + return *internal_default_instance(); + } + static inline const HandshakeMessage_ServerHello* internal_default_instance() { + return reinterpret_cast( + &_HandshakeMessage_ServerHello_default_instance_); + } + static constexpr int kIndexInFileMessages = + 37; + + friend void swap(HandshakeMessage_ServerHello& a, HandshakeMessage_ServerHello& b) { + a.Swap(&b); + } + inline void Swap(HandshakeMessage_ServerHello* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(HandshakeMessage_ServerHello* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + HandshakeMessage_ServerHello* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const HandshakeMessage_ServerHello& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const HandshakeMessage_ServerHello& from) { + HandshakeMessage_ServerHello::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(HandshakeMessage_ServerHello* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.HandshakeMessage.ServerHello"; + } + protected: + explicit HandshakeMessage_ServerHello(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kEphemeralFieldNumber = 1, + kStaticFieldNumber = 2, + kPayloadFieldNumber = 3, + }; + // optional bytes ephemeral = 1; + bool has_ephemeral() const; + private: + bool _internal_has_ephemeral() const; + public: + void clear_ephemeral(); + const std::string& ephemeral() const; + template + void set_ephemeral(ArgT0&& arg0, ArgT... args); + std::string* mutable_ephemeral(); + PROTOBUF_NODISCARD std::string* release_ephemeral(); + void set_allocated_ephemeral(std::string* ephemeral); + private: + const std::string& _internal_ephemeral() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_ephemeral(const std::string& value); + std::string* _internal_mutable_ephemeral(); + public: + + // optional bytes static = 2; + bool has_static_() const; + private: + bool _internal_has_static_() const; + public: + void clear_static_(); + const std::string& static_() const; + template + void set_static_(ArgT0&& arg0, ArgT... args); + std::string* mutable_static_(); + PROTOBUF_NODISCARD std::string* release_static_(); + void set_allocated_static_(std::string* static_); + private: + const std::string& _internal_static_() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_static_(const std::string& value); + std::string* _internal_mutable_static_(); + public: + + // optional bytes payload = 3; + bool has_payload() const; + private: + bool _internal_has_payload() const; + public: + void clear_payload(); + const std::string& payload() const; + template + void set_payload(ArgT0&& arg0, ArgT... args); + std::string* mutable_payload(); + PROTOBUF_NODISCARD std::string* release_payload(); + void set_allocated_payload(std::string* payload); + private: + const std::string& _internal_payload() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_payload(const std::string& value); + std::string* _internal_mutable_payload(); + public: + + // @@protoc_insertion_point(class_scope:proto.HandshakeMessage.ServerHello) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ephemeral_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr static__; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class HandshakeMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HandshakeMessage) */ { + public: + inline HandshakeMessage() : HandshakeMessage(nullptr) {} + ~HandshakeMessage() override; + explicit PROTOBUF_CONSTEXPR HandshakeMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + HandshakeMessage(const HandshakeMessage& from); + HandshakeMessage(HandshakeMessage&& from) noexcept + : HandshakeMessage() { + *this = ::std::move(from); + } + + inline HandshakeMessage& operator=(const HandshakeMessage& from) { + CopyFrom(from); + return *this; + } + inline HandshakeMessage& operator=(HandshakeMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const HandshakeMessage& default_instance() { + return *internal_default_instance(); + } + static inline const HandshakeMessage* internal_default_instance() { + return reinterpret_cast( + &_HandshakeMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 38; + + friend void swap(HandshakeMessage& a, HandshakeMessage& b) { + a.Swap(&b); + } + inline void Swap(HandshakeMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(HandshakeMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + HandshakeMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const HandshakeMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const HandshakeMessage& from) { + HandshakeMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(HandshakeMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.HandshakeMessage"; + } + protected: + explicit HandshakeMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef HandshakeMessage_ClientFinish ClientFinish; + typedef HandshakeMessage_ClientHello ClientHello; + typedef HandshakeMessage_ServerHello ServerHello; + + // accessors ------------------------------------------------------- + + enum : int { + kClientHelloFieldNumber = 2, + kServerHelloFieldNumber = 3, + kClientFinishFieldNumber = 4, + }; + // optional .proto.HandshakeMessage.ClientHello clientHello = 2; + bool has_clienthello() const; + private: + bool _internal_has_clienthello() const; + public: + void clear_clienthello(); + const ::proto::HandshakeMessage_ClientHello& clienthello() const; + PROTOBUF_NODISCARD ::proto::HandshakeMessage_ClientHello* release_clienthello(); + ::proto::HandshakeMessage_ClientHello* mutable_clienthello(); + void set_allocated_clienthello(::proto::HandshakeMessage_ClientHello* clienthello); + private: + const ::proto::HandshakeMessage_ClientHello& _internal_clienthello() const; + ::proto::HandshakeMessage_ClientHello* _internal_mutable_clienthello(); + public: + void unsafe_arena_set_allocated_clienthello( + ::proto::HandshakeMessage_ClientHello* clienthello); + ::proto::HandshakeMessage_ClientHello* unsafe_arena_release_clienthello(); + + // optional .proto.HandshakeMessage.ServerHello serverHello = 3; + bool has_serverhello() const; + private: + bool _internal_has_serverhello() const; + public: + void clear_serverhello(); + const ::proto::HandshakeMessage_ServerHello& serverhello() const; + PROTOBUF_NODISCARD ::proto::HandshakeMessage_ServerHello* release_serverhello(); + ::proto::HandshakeMessage_ServerHello* mutable_serverhello(); + void set_allocated_serverhello(::proto::HandshakeMessage_ServerHello* serverhello); + private: + const ::proto::HandshakeMessage_ServerHello& _internal_serverhello() const; + ::proto::HandshakeMessage_ServerHello* _internal_mutable_serverhello(); + public: + void unsafe_arena_set_allocated_serverhello( + ::proto::HandshakeMessage_ServerHello* serverhello); + ::proto::HandshakeMessage_ServerHello* unsafe_arena_release_serverhello(); + + // optional .proto.HandshakeMessage.ClientFinish clientFinish = 4; + bool has_clientfinish() const; + private: + bool _internal_has_clientfinish() const; + public: + void clear_clientfinish(); + const ::proto::HandshakeMessage_ClientFinish& clientfinish() const; + PROTOBUF_NODISCARD ::proto::HandshakeMessage_ClientFinish* release_clientfinish(); + ::proto::HandshakeMessage_ClientFinish* mutable_clientfinish(); + void set_allocated_clientfinish(::proto::HandshakeMessage_ClientFinish* clientfinish); + private: + const ::proto::HandshakeMessage_ClientFinish& _internal_clientfinish() const; + ::proto::HandshakeMessage_ClientFinish* _internal_mutable_clientfinish(); + public: + void unsafe_arena_set_allocated_clientfinish( + ::proto::HandshakeMessage_ClientFinish* clientfinish); + ::proto::HandshakeMessage_ClientFinish* unsafe_arena_release_clientfinish(); + + // @@protoc_insertion_point(class_scope:proto.HandshakeMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::proto::HandshakeMessage_ClientHello* clienthello_; + ::proto::HandshakeMessage_ServerHello* serverhello_; + ::proto::HandshakeMessage_ClientFinish* clientfinish_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class HistorySync final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HistorySync) */ { + public: + inline HistorySync() : HistorySync(nullptr) {} + ~HistorySync() override; + explicit PROTOBUF_CONSTEXPR HistorySync(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + HistorySync(const HistorySync& from); + HistorySync(HistorySync&& from) noexcept + : HistorySync() { + *this = ::std::move(from); + } + + inline HistorySync& operator=(const HistorySync& from) { + CopyFrom(from); + return *this; + } + inline HistorySync& operator=(HistorySync&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const HistorySync& default_instance() { + return *internal_default_instance(); + } + static inline const HistorySync* internal_default_instance() { + return reinterpret_cast( + &_HistorySync_default_instance_); + } + static constexpr int kIndexInFileMessages = + 39; + + friend void swap(HistorySync& a, HistorySync& b) { + a.Swap(&b); + } + inline void Swap(HistorySync* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(HistorySync* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + HistorySync* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const HistorySync& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const HistorySync& from) { + HistorySync::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(HistorySync* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.HistorySync"; + } + protected: + explicit HistorySync(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef HistorySync_HistorySyncType HistorySyncType; + static constexpr HistorySyncType INITIAL_BOOTSTRAP = + HistorySync_HistorySyncType_INITIAL_BOOTSTRAP; + static constexpr HistorySyncType INITIAL_STATUS_V3 = + HistorySync_HistorySyncType_INITIAL_STATUS_V3; + static constexpr HistorySyncType FULL = + HistorySync_HistorySyncType_FULL; + static constexpr HistorySyncType RECENT = + HistorySync_HistorySyncType_RECENT; + static constexpr HistorySyncType PUSH_NAME = + HistorySync_HistorySyncType_PUSH_NAME; + static constexpr HistorySyncType UNBLOCKING_DATA = + HistorySync_HistorySyncType_UNBLOCKING_DATA; + static inline bool HistorySyncType_IsValid(int value) { + return HistorySync_HistorySyncType_IsValid(value); + } + static constexpr HistorySyncType HistorySyncType_MIN = + HistorySync_HistorySyncType_HistorySyncType_MIN; + static constexpr HistorySyncType HistorySyncType_MAX = + HistorySync_HistorySyncType_HistorySyncType_MAX; + static constexpr int HistorySyncType_ARRAYSIZE = + HistorySync_HistorySyncType_HistorySyncType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + HistorySyncType_descriptor() { + return HistorySync_HistorySyncType_descriptor(); + } + template + static inline const std::string& HistorySyncType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function HistorySyncType_Name."); + return HistorySync_HistorySyncType_Name(enum_t_value); + } + static inline bool HistorySyncType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + HistorySyncType* value) { + return HistorySync_HistorySyncType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kConversationsFieldNumber = 2, + kStatusV3MessagesFieldNumber = 3, + kPushnamesFieldNumber = 7, + kRecentStickersFieldNumber = 11, + kPastParticipantsFieldNumber = 12, + kThreadIdUserSecretFieldNumber = 9, + kGlobalSettingsFieldNumber = 8, + kSyncTypeFieldNumber = 1, + kChunkOrderFieldNumber = 5, + kProgressFieldNumber = 6, + kThreadDsTimeframeOffsetFieldNumber = 10, + }; + // repeated .proto.Conversation conversations = 2; + int conversations_size() const; + private: + int _internal_conversations_size() const; + public: + void clear_conversations(); + ::proto::Conversation* mutable_conversations(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Conversation >* + mutable_conversations(); + private: + const ::proto::Conversation& _internal_conversations(int index) const; + ::proto::Conversation* _internal_add_conversations(); + public: + const ::proto::Conversation& conversations(int index) const; + ::proto::Conversation* add_conversations(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Conversation >& + conversations() const; + + // repeated .proto.WebMessageInfo statusV3Messages = 3; + int statusv3messages_size() const; + private: + int _internal_statusv3messages_size() const; + public: + void clear_statusv3messages(); + ::proto::WebMessageInfo* mutable_statusv3messages(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >* + mutable_statusv3messages(); + private: + const ::proto::WebMessageInfo& _internal_statusv3messages(int index) const; + ::proto::WebMessageInfo* _internal_add_statusv3messages(); + public: + const ::proto::WebMessageInfo& statusv3messages(int index) const; + ::proto::WebMessageInfo* add_statusv3messages(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >& + statusv3messages() const; + + // repeated .proto.Pushname pushnames = 7; + int pushnames_size() const; + private: + int _internal_pushnames_size() const; + public: + void clear_pushnames(); + ::proto::Pushname* mutable_pushnames(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Pushname >* + mutable_pushnames(); + private: + const ::proto::Pushname& _internal_pushnames(int index) const; + ::proto::Pushname* _internal_add_pushnames(); + public: + const ::proto::Pushname& pushnames(int index) const; + ::proto::Pushname* add_pushnames(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Pushname >& + pushnames() const; + + // repeated .proto.StickerMetadata recentStickers = 11; + int recentstickers_size() const; + private: + int _internal_recentstickers_size() const; + public: + void clear_recentstickers(); + ::proto::StickerMetadata* mutable_recentstickers(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::StickerMetadata >* + mutable_recentstickers(); + private: + const ::proto::StickerMetadata& _internal_recentstickers(int index) const; + ::proto::StickerMetadata* _internal_add_recentstickers(); + public: + const ::proto::StickerMetadata& recentstickers(int index) const; + ::proto::StickerMetadata* add_recentstickers(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::StickerMetadata >& + recentstickers() const; + + // repeated .proto.PastParticipants pastParticipants = 12; + int pastparticipants_size() const; + private: + int _internal_pastparticipants_size() const; + public: + void clear_pastparticipants(); + ::proto::PastParticipants* mutable_pastparticipants(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipants >* + mutable_pastparticipants(); + private: + const ::proto::PastParticipants& _internal_pastparticipants(int index) const; + ::proto::PastParticipants* _internal_add_pastparticipants(); + public: + const ::proto::PastParticipants& pastparticipants(int index) const; + ::proto::PastParticipants* add_pastparticipants(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipants >& + pastparticipants() const; + + // optional bytes threadIdUserSecret = 9; + bool has_threadidusersecret() const; + private: + bool _internal_has_threadidusersecret() const; + public: + void clear_threadidusersecret(); + const std::string& threadidusersecret() const; + template + void set_threadidusersecret(ArgT0&& arg0, ArgT... args); + std::string* mutable_threadidusersecret(); + PROTOBUF_NODISCARD std::string* release_threadidusersecret(); + void set_allocated_threadidusersecret(std::string* threadidusersecret); + private: + const std::string& _internal_threadidusersecret() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_threadidusersecret(const std::string& value); + std::string* _internal_mutable_threadidusersecret(); + public: + + // optional .proto.GlobalSettings globalSettings = 8; + bool has_globalsettings() const; + private: + bool _internal_has_globalsettings() const; + public: + void clear_globalsettings(); + const ::proto::GlobalSettings& globalsettings() const; + PROTOBUF_NODISCARD ::proto::GlobalSettings* release_globalsettings(); + ::proto::GlobalSettings* mutable_globalsettings(); + void set_allocated_globalsettings(::proto::GlobalSettings* globalsettings); + private: + const ::proto::GlobalSettings& _internal_globalsettings() const; + ::proto::GlobalSettings* _internal_mutable_globalsettings(); + public: + void unsafe_arena_set_allocated_globalsettings( + ::proto::GlobalSettings* globalsettings); + ::proto::GlobalSettings* unsafe_arena_release_globalsettings(); + + // required .proto.HistorySync.HistorySyncType syncType = 1; + bool has_synctype() const; + private: + bool _internal_has_synctype() const; + public: + void clear_synctype(); + ::proto::HistorySync_HistorySyncType synctype() const; + void set_synctype(::proto::HistorySync_HistorySyncType value); + private: + ::proto::HistorySync_HistorySyncType _internal_synctype() const; + void _internal_set_synctype(::proto::HistorySync_HistorySyncType value); + public: + + // optional uint32 chunkOrder = 5; + bool has_chunkorder() const; + private: + bool _internal_has_chunkorder() const; + public: + void clear_chunkorder(); + uint32_t chunkorder() const; + void set_chunkorder(uint32_t value); + private: + uint32_t _internal_chunkorder() const; + void _internal_set_chunkorder(uint32_t value); + public: + + // optional uint32 progress = 6; + bool has_progress() const; + private: + bool _internal_has_progress() const; + public: + void clear_progress(); + uint32_t progress() const; + void set_progress(uint32_t value); + private: + uint32_t _internal_progress() const; + void _internal_set_progress(uint32_t value); + public: + + // optional uint32 threadDsTimeframeOffset = 10; + bool has_threaddstimeframeoffset() const; + private: + bool _internal_has_threaddstimeframeoffset() const; + public: + void clear_threaddstimeframeoffset(); + uint32_t threaddstimeframeoffset() const; + void set_threaddstimeframeoffset(uint32_t value); + private: + uint32_t _internal_threaddstimeframeoffset() const; + void _internal_set_threaddstimeframeoffset(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.HistorySync) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Conversation > conversations_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo > statusv3messages_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Pushname > pushnames_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::StickerMetadata > recentstickers_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipants > pastparticipants_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr threadidusersecret_; + ::proto::GlobalSettings* globalsettings_; + int synctype_; + uint32_t chunkorder_; + uint32_t progress_; + uint32_t threaddstimeframeoffset_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class HistorySyncMsg final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HistorySyncMsg) */ { + public: + inline HistorySyncMsg() : HistorySyncMsg(nullptr) {} + ~HistorySyncMsg() override; + explicit PROTOBUF_CONSTEXPR HistorySyncMsg(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + HistorySyncMsg(const HistorySyncMsg& from); + HistorySyncMsg(HistorySyncMsg&& from) noexcept + : HistorySyncMsg() { + *this = ::std::move(from); + } + + inline HistorySyncMsg& operator=(const HistorySyncMsg& from) { + CopyFrom(from); + return *this; + } + inline HistorySyncMsg& operator=(HistorySyncMsg&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const HistorySyncMsg& default_instance() { + return *internal_default_instance(); + } + static inline const HistorySyncMsg* internal_default_instance() { + return reinterpret_cast( + &_HistorySyncMsg_default_instance_); + } + static constexpr int kIndexInFileMessages = + 40; + + friend void swap(HistorySyncMsg& a, HistorySyncMsg& b) { + a.Swap(&b); + } + inline void Swap(HistorySyncMsg* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(HistorySyncMsg* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + HistorySyncMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const HistorySyncMsg& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const HistorySyncMsg& from) { + HistorySyncMsg::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(HistorySyncMsg* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.HistorySyncMsg"; + } + protected: + explicit HistorySyncMsg(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMessageFieldNumber = 1, + kMsgOrderIdFieldNumber = 2, + }; + // optional .proto.WebMessageInfo message = 1; + bool has_message() const; + private: + bool _internal_has_message() const; + public: + void clear_message(); + const ::proto::WebMessageInfo& message() const; + PROTOBUF_NODISCARD ::proto::WebMessageInfo* release_message(); + ::proto::WebMessageInfo* mutable_message(); + void set_allocated_message(::proto::WebMessageInfo* message); + private: + const ::proto::WebMessageInfo& _internal_message() const; + ::proto::WebMessageInfo* _internal_mutable_message(); + public: + void unsafe_arena_set_allocated_message( + ::proto::WebMessageInfo* message); + ::proto::WebMessageInfo* unsafe_arena_release_message(); + + // optional uint64 msgOrderId = 2; + bool has_msgorderid() const; + private: + bool _internal_has_msgorderid() const; + public: + void clear_msgorderid(); + uint64_t msgorderid() const; + void set_msgorderid(uint64_t value); + private: + uint64_t _internal_msgorderid() const; + void _internal_set_msgorderid(uint64_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.HistorySyncMsg) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::proto::WebMessageInfo* message_; + uint64_t msgorderid_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class HydratedTemplateButton_HydratedCallButton final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HydratedTemplateButton.HydratedCallButton) */ { + public: + inline HydratedTemplateButton_HydratedCallButton() : HydratedTemplateButton_HydratedCallButton(nullptr) {} + ~HydratedTemplateButton_HydratedCallButton() override; + explicit PROTOBUF_CONSTEXPR HydratedTemplateButton_HydratedCallButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + HydratedTemplateButton_HydratedCallButton(const HydratedTemplateButton_HydratedCallButton& from); + HydratedTemplateButton_HydratedCallButton(HydratedTemplateButton_HydratedCallButton&& from) noexcept + : HydratedTemplateButton_HydratedCallButton() { + *this = ::std::move(from); + } + + inline HydratedTemplateButton_HydratedCallButton& operator=(const HydratedTemplateButton_HydratedCallButton& from) { + CopyFrom(from); + return *this; + } + inline HydratedTemplateButton_HydratedCallButton& operator=(HydratedTemplateButton_HydratedCallButton&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const HydratedTemplateButton_HydratedCallButton& default_instance() { + return *internal_default_instance(); + } + static inline const HydratedTemplateButton_HydratedCallButton* internal_default_instance() { + return reinterpret_cast( + &_HydratedTemplateButton_HydratedCallButton_default_instance_); + } + static constexpr int kIndexInFileMessages = + 41; + + friend void swap(HydratedTemplateButton_HydratedCallButton& a, HydratedTemplateButton_HydratedCallButton& b) { + a.Swap(&b); + } + inline void Swap(HydratedTemplateButton_HydratedCallButton* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(HydratedTemplateButton_HydratedCallButton* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + HydratedTemplateButton_HydratedCallButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const HydratedTemplateButton_HydratedCallButton& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const HydratedTemplateButton_HydratedCallButton& from) { + HydratedTemplateButton_HydratedCallButton::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(HydratedTemplateButton_HydratedCallButton* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.HydratedTemplateButton.HydratedCallButton"; + } + protected: + explicit HydratedTemplateButton_HydratedCallButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDisplayTextFieldNumber = 1, + kPhoneNumberFieldNumber = 2, + }; + // optional string displayText = 1; + bool has_displaytext() const; + private: + bool _internal_has_displaytext() const; + public: + void clear_displaytext(); + const std::string& displaytext() const; + template + void set_displaytext(ArgT0&& arg0, ArgT... args); + std::string* mutable_displaytext(); + PROTOBUF_NODISCARD std::string* release_displaytext(); + void set_allocated_displaytext(std::string* displaytext); + private: + const std::string& _internal_displaytext() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_displaytext(const std::string& value); + std::string* _internal_mutable_displaytext(); + public: + + // optional string phoneNumber = 2; + bool has_phonenumber() const; + private: + bool _internal_has_phonenumber() const; + public: + void clear_phonenumber(); + const std::string& phonenumber() const; + template + void set_phonenumber(ArgT0&& arg0, ArgT... args); + std::string* mutable_phonenumber(); + PROTOBUF_NODISCARD std::string* release_phonenumber(); + void set_allocated_phonenumber(std::string* phonenumber); + private: + const std::string& _internal_phonenumber() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_phonenumber(const std::string& value); + std::string* _internal_mutable_phonenumber(); + public: + + // @@protoc_insertion_point(class_scope:proto.HydratedTemplateButton.HydratedCallButton) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr displaytext_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr phonenumber_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class HydratedTemplateButton_HydratedQuickReplyButton final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HydratedTemplateButton.HydratedQuickReplyButton) */ { + public: + inline HydratedTemplateButton_HydratedQuickReplyButton() : HydratedTemplateButton_HydratedQuickReplyButton(nullptr) {} + ~HydratedTemplateButton_HydratedQuickReplyButton() override; + explicit PROTOBUF_CONSTEXPR HydratedTemplateButton_HydratedQuickReplyButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + HydratedTemplateButton_HydratedQuickReplyButton(const HydratedTemplateButton_HydratedQuickReplyButton& from); + HydratedTemplateButton_HydratedQuickReplyButton(HydratedTemplateButton_HydratedQuickReplyButton&& from) noexcept + : HydratedTemplateButton_HydratedQuickReplyButton() { + *this = ::std::move(from); + } + + inline HydratedTemplateButton_HydratedQuickReplyButton& operator=(const HydratedTemplateButton_HydratedQuickReplyButton& from) { + CopyFrom(from); + return *this; + } + inline HydratedTemplateButton_HydratedQuickReplyButton& operator=(HydratedTemplateButton_HydratedQuickReplyButton&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const HydratedTemplateButton_HydratedQuickReplyButton& default_instance() { + return *internal_default_instance(); + } + static inline const HydratedTemplateButton_HydratedQuickReplyButton* internal_default_instance() { + return reinterpret_cast( + &_HydratedTemplateButton_HydratedQuickReplyButton_default_instance_); + } + static constexpr int kIndexInFileMessages = + 42; + + friend void swap(HydratedTemplateButton_HydratedQuickReplyButton& a, HydratedTemplateButton_HydratedQuickReplyButton& b) { + a.Swap(&b); + } + inline void Swap(HydratedTemplateButton_HydratedQuickReplyButton* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(HydratedTemplateButton_HydratedQuickReplyButton* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + HydratedTemplateButton_HydratedQuickReplyButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const HydratedTemplateButton_HydratedQuickReplyButton& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const HydratedTemplateButton_HydratedQuickReplyButton& from) { + HydratedTemplateButton_HydratedQuickReplyButton::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(HydratedTemplateButton_HydratedQuickReplyButton* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.HydratedTemplateButton.HydratedQuickReplyButton"; + } + protected: + explicit HydratedTemplateButton_HydratedQuickReplyButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDisplayTextFieldNumber = 1, + kIdFieldNumber = 2, + }; + // optional string displayText = 1; + bool has_displaytext() const; + private: + bool _internal_has_displaytext() const; + public: + void clear_displaytext(); + const std::string& displaytext() const; + template + void set_displaytext(ArgT0&& arg0, ArgT... args); + std::string* mutable_displaytext(); + PROTOBUF_NODISCARD std::string* release_displaytext(); + void set_allocated_displaytext(std::string* displaytext); + private: + const std::string& _internal_displaytext() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_displaytext(const std::string& value); + std::string* _internal_mutable_displaytext(); + public: + + // optional string id = 2; + bool has_id() const; + private: + bool _internal_has_id() const; + public: + void clear_id(); + const std::string& id() const; + template + void set_id(ArgT0&& arg0, ArgT... args); + std::string* mutable_id(); + PROTOBUF_NODISCARD std::string* release_id(); + void set_allocated_id(std::string* id); + private: + const std::string& _internal_id() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value); + std::string* _internal_mutable_id(); + public: + + // @@protoc_insertion_point(class_scope:proto.HydratedTemplateButton.HydratedQuickReplyButton) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr displaytext_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class HydratedTemplateButton_HydratedURLButton final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HydratedTemplateButton.HydratedURLButton) */ { + public: + inline HydratedTemplateButton_HydratedURLButton() : HydratedTemplateButton_HydratedURLButton(nullptr) {} + ~HydratedTemplateButton_HydratedURLButton() override; + explicit PROTOBUF_CONSTEXPR HydratedTemplateButton_HydratedURLButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + HydratedTemplateButton_HydratedURLButton(const HydratedTemplateButton_HydratedURLButton& from); + HydratedTemplateButton_HydratedURLButton(HydratedTemplateButton_HydratedURLButton&& from) noexcept + : HydratedTemplateButton_HydratedURLButton() { + *this = ::std::move(from); + } + + inline HydratedTemplateButton_HydratedURLButton& operator=(const HydratedTemplateButton_HydratedURLButton& from) { + CopyFrom(from); + return *this; + } + inline HydratedTemplateButton_HydratedURLButton& operator=(HydratedTemplateButton_HydratedURLButton&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const HydratedTemplateButton_HydratedURLButton& default_instance() { + return *internal_default_instance(); + } + static inline const HydratedTemplateButton_HydratedURLButton* internal_default_instance() { + return reinterpret_cast( + &_HydratedTemplateButton_HydratedURLButton_default_instance_); + } + static constexpr int kIndexInFileMessages = + 43; + + friend void swap(HydratedTemplateButton_HydratedURLButton& a, HydratedTemplateButton_HydratedURLButton& b) { + a.Swap(&b); + } + inline void Swap(HydratedTemplateButton_HydratedURLButton* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(HydratedTemplateButton_HydratedURLButton* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + HydratedTemplateButton_HydratedURLButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const HydratedTemplateButton_HydratedURLButton& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const HydratedTemplateButton_HydratedURLButton& from) { + HydratedTemplateButton_HydratedURLButton::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(HydratedTemplateButton_HydratedURLButton* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.HydratedTemplateButton.HydratedURLButton"; + } + protected: + explicit HydratedTemplateButton_HydratedURLButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDisplayTextFieldNumber = 1, + kUrlFieldNumber = 2, + }; + // optional string displayText = 1; + bool has_displaytext() const; + private: + bool _internal_has_displaytext() const; + public: + void clear_displaytext(); + const std::string& displaytext() const; + template + void set_displaytext(ArgT0&& arg0, ArgT... args); + std::string* mutable_displaytext(); + PROTOBUF_NODISCARD std::string* release_displaytext(); + void set_allocated_displaytext(std::string* displaytext); + private: + const std::string& _internal_displaytext() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_displaytext(const std::string& value); + std::string* _internal_mutable_displaytext(); + public: + + // optional string url = 2; + bool has_url() const; + private: + bool _internal_has_url() const; + public: + void clear_url(); + const std::string& url() const; + template + void set_url(ArgT0&& arg0, ArgT... args); + std::string* mutable_url(); + PROTOBUF_NODISCARD std::string* release_url(); + void set_allocated_url(std::string* url); + private: + const std::string& _internal_url() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value); + std::string* _internal_mutable_url(); + public: + + // @@protoc_insertion_point(class_scope:proto.HydratedTemplateButton.HydratedURLButton) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr displaytext_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class HydratedTemplateButton final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HydratedTemplateButton) */ { + public: + inline HydratedTemplateButton() : HydratedTemplateButton(nullptr) {} + ~HydratedTemplateButton() override; + explicit PROTOBUF_CONSTEXPR HydratedTemplateButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + HydratedTemplateButton(const HydratedTemplateButton& from); + HydratedTemplateButton(HydratedTemplateButton&& from) noexcept + : HydratedTemplateButton() { + *this = ::std::move(from); + } + + inline HydratedTemplateButton& operator=(const HydratedTemplateButton& from) { + CopyFrom(from); + return *this; + } + inline HydratedTemplateButton& operator=(HydratedTemplateButton&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const HydratedTemplateButton& default_instance() { + return *internal_default_instance(); + } + enum HydratedButtonCase { + kQuickReplyButton = 1, + kUrlButton = 2, + kCallButton = 3, + HYDRATEDBUTTON_NOT_SET = 0, + }; + + static inline const HydratedTemplateButton* internal_default_instance() { + return reinterpret_cast( + &_HydratedTemplateButton_default_instance_); + } + static constexpr int kIndexInFileMessages = + 44; + + friend void swap(HydratedTemplateButton& a, HydratedTemplateButton& b) { + a.Swap(&b); + } + inline void Swap(HydratedTemplateButton* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(HydratedTemplateButton* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + HydratedTemplateButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const HydratedTemplateButton& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const HydratedTemplateButton& from) { + HydratedTemplateButton::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(HydratedTemplateButton* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.HydratedTemplateButton"; + } + protected: + explicit HydratedTemplateButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef HydratedTemplateButton_HydratedCallButton HydratedCallButton; + typedef HydratedTemplateButton_HydratedQuickReplyButton HydratedQuickReplyButton; + typedef HydratedTemplateButton_HydratedURLButton HydratedURLButton; + + // accessors ------------------------------------------------------- + + enum : int { + kIndexFieldNumber = 4, + kQuickReplyButtonFieldNumber = 1, + kUrlButtonFieldNumber = 2, + kCallButtonFieldNumber = 3, + }; + // optional uint32 index = 4; + bool has_index() const; + private: + bool _internal_has_index() const; + public: + void clear_index(); + uint32_t index() const; + void set_index(uint32_t value); + private: + uint32_t _internal_index() const; + void _internal_set_index(uint32_t value); + public: + + // .proto.HydratedTemplateButton.HydratedQuickReplyButton quickReplyButton = 1; + bool has_quickreplybutton() const; + private: + bool _internal_has_quickreplybutton() const; + public: + void clear_quickreplybutton(); + const ::proto::HydratedTemplateButton_HydratedQuickReplyButton& quickreplybutton() const; + PROTOBUF_NODISCARD ::proto::HydratedTemplateButton_HydratedQuickReplyButton* release_quickreplybutton(); + ::proto::HydratedTemplateButton_HydratedQuickReplyButton* mutable_quickreplybutton(); + void set_allocated_quickreplybutton(::proto::HydratedTemplateButton_HydratedQuickReplyButton* quickreplybutton); + private: + const ::proto::HydratedTemplateButton_HydratedQuickReplyButton& _internal_quickreplybutton() const; + ::proto::HydratedTemplateButton_HydratedQuickReplyButton* _internal_mutable_quickreplybutton(); + public: + void unsafe_arena_set_allocated_quickreplybutton( + ::proto::HydratedTemplateButton_HydratedQuickReplyButton* quickreplybutton); + ::proto::HydratedTemplateButton_HydratedQuickReplyButton* unsafe_arena_release_quickreplybutton(); + + // .proto.HydratedTemplateButton.HydratedURLButton urlButton = 2; + bool has_urlbutton() const; + private: + bool _internal_has_urlbutton() const; + public: + void clear_urlbutton(); + const ::proto::HydratedTemplateButton_HydratedURLButton& urlbutton() const; + PROTOBUF_NODISCARD ::proto::HydratedTemplateButton_HydratedURLButton* release_urlbutton(); + ::proto::HydratedTemplateButton_HydratedURLButton* mutable_urlbutton(); + void set_allocated_urlbutton(::proto::HydratedTemplateButton_HydratedURLButton* urlbutton); + private: + const ::proto::HydratedTemplateButton_HydratedURLButton& _internal_urlbutton() const; + ::proto::HydratedTemplateButton_HydratedURLButton* _internal_mutable_urlbutton(); + public: + void unsafe_arena_set_allocated_urlbutton( + ::proto::HydratedTemplateButton_HydratedURLButton* urlbutton); + ::proto::HydratedTemplateButton_HydratedURLButton* unsafe_arena_release_urlbutton(); + + // .proto.HydratedTemplateButton.HydratedCallButton callButton = 3; + bool has_callbutton() const; + private: + bool _internal_has_callbutton() const; + public: + void clear_callbutton(); + const ::proto::HydratedTemplateButton_HydratedCallButton& callbutton() const; + PROTOBUF_NODISCARD ::proto::HydratedTemplateButton_HydratedCallButton* release_callbutton(); + ::proto::HydratedTemplateButton_HydratedCallButton* mutable_callbutton(); + void set_allocated_callbutton(::proto::HydratedTemplateButton_HydratedCallButton* callbutton); + private: + const ::proto::HydratedTemplateButton_HydratedCallButton& _internal_callbutton() const; + ::proto::HydratedTemplateButton_HydratedCallButton* _internal_mutable_callbutton(); + public: + void unsafe_arena_set_allocated_callbutton( + ::proto::HydratedTemplateButton_HydratedCallButton* callbutton); + ::proto::HydratedTemplateButton_HydratedCallButton* unsafe_arena_release_callbutton(); + + void clear_hydratedButton(); + HydratedButtonCase hydratedButton_case() const; + // @@protoc_insertion_point(class_scope:proto.HydratedTemplateButton) + private: + class _Internal; + void set_has_quickreplybutton(); + void set_has_urlbutton(); + void set_has_callbutton(); + + inline bool has_hydratedButton() const; + inline void clear_has_hydratedButton(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + uint32_t index_; + union HydratedButtonUnion { + constexpr HydratedButtonUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::proto::HydratedTemplateButton_HydratedQuickReplyButton* quickreplybutton_; + ::proto::HydratedTemplateButton_HydratedURLButton* urlbutton_; + ::proto::HydratedTemplateButton_HydratedCallButton* callbutton_; + } hydratedButton_; + uint32_t _oneof_case_[1]; + + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class IdentityKeyPairStructure final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.IdentityKeyPairStructure) */ { + public: + inline IdentityKeyPairStructure() : IdentityKeyPairStructure(nullptr) {} + ~IdentityKeyPairStructure() override; + explicit PROTOBUF_CONSTEXPR IdentityKeyPairStructure(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + IdentityKeyPairStructure(const IdentityKeyPairStructure& from); + IdentityKeyPairStructure(IdentityKeyPairStructure&& from) noexcept + : IdentityKeyPairStructure() { + *this = ::std::move(from); + } + + inline IdentityKeyPairStructure& operator=(const IdentityKeyPairStructure& from) { + CopyFrom(from); + return *this; + } + inline IdentityKeyPairStructure& operator=(IdentityKeyPairStructure&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const IdentityKeyPairStructure& default_instance() { + return *internal_default_instance(); + } + static inline const IdentityKeyPairStructure* internal_default_instance() { + return reinterpret_cast( + &_IdentityKeyPairStructure_default_instance_); + } + static constexpr int kIndexInFileMessages = + 45; + + friend void swap(IdentityKeyPairStructure& a, IdentityKeyPairStructure& b) { + a.Swap(&b); + } + inline void Swap(IdentityKeyPairStructure* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(IdentityKeyPairStructure* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + IdentityKeyPairStructure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const IdentityKeyPairStructure& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const IdentityKeyPairStructure& from) { + IdentityKeyPairStructure::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(IdentityKeyPairStructure* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.IdentityKeyPairStructure"; + } + protected: + explicit IdentityKeyPairStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kPublicKeyFieldNumber = 1, + kPrivateKeyFieldNumber = 2, + }; + // optional bytes publicKey = 1; + bool has_publickey() const; + private: + bool _internal_has_publickey() const; + public: + void clear_publickey(); + const std::string& publickey() const; + template + void set_publickey(ArgT0&& arg0, ArgT... args); + std::string* mutable_publickey(); + PROTOBUF_NODISCARD std::string* release_publickey(); + void set_allocated_publickey(std::string* publickey); + private: + const std::string& _internal_publickey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_publickey(const std::string& value); + std::string* _internal_mutable_publickey(); + public: + + // optional bytes privateKey = 2; + bool has_privatekey() const; + private: + bool _internal_has_privatekey() const; + public: + void clear_privatekey(); + const std::string& privatekey() const; + template + void set_privatekey(ArgT0&& arg0, ArgT... args); + std::string* mutable_privatekey(); + PROTOBUF_NODISCARD std::string* release_privatekey(); + void set_allocated_privatekey(std::string* privatekey); + private: + const std::string& _internal_privatekey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_privatekey(const std::string& value); + std::string* _internal_mutable_privatekey(); + public: + + // @@protoc_insertion_point(class_scope:proto.IdentityKeyPairStructure) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr publickey_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr privatekey_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class InteractiveAnnotation final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.InteractiveAnnotation) */ { + public: + inline InteractiveAnnotation() : InteractiveAnnotation(nullptr) {} + ~InteractiveAnnotation() override; + explicit PROTOBUF_CONSTEXPR InteractiveAnnotation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + InteractiveAnnotation(const InteractiveAnnotation& from); + InteractiveAnnotation(InteractiveAnnotation&& from) noexcept + : InteractiveAnnotation() { + *this = ::std::move(from); + } + + inline InteractiveAnnotation& operator=(const InteractiveAnnotation& from) { + CopyFrom(from); + return *this; + } + inline InteractiveAnnotation& operator=(InteractiveAnnotation&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const InteractiveAnnotation& default_instance() { + return *internal_default_instance(); + } + enum ActionCase { + kLocation = 2, + ACTION_NOT_SET = 0, + }; + + static inline const InteractiveAnnotation* internal_default_instance() { + return reinterpret_cast( + &_InteractiveAnnotation_default_instance_); + } + static constexpr int kIndexInFileMessages = + 46; + + friend void swap(InteractiveAnnotation& a, InteractiveAnnotation& b) { + a.Swap(&b); + } + inline void Swap(InteractiveAnnotation* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(InteractiveAnnotation* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + InteractiveAnnotation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const InteractiveAnnotation& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const InteractiveAnnotation& from) { + InteractiveAnnotation::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(InteractiveAnnotation* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.InteractiveAnnotation"; + } + protected: + explicit InteractiveAnnotation(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kPolygonVerticesFieldNumber = 1, + kLocationFieldNumber = 2, + }; + // repeated .proto.Point polygonVertices = 1; + int polygonvertices_size() const; + private: + int _internal_polygonvertices_size() const; + public: + void clear_polygonvertices(); + ::proto::Point* mutable_polygonvertices(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Point >* + mutable_polygonvertices(); + private: + const ::proto::Point& _internal_polygonvertices(int index) const; + ::proto::Point* _internal_add_polygonvertices(); + public: + const ::proto::Point& polygonvertices(int index) const; + ::proto::Point* add_polygonvertices(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Point >& + polygonvertices() const; + + // .proto.Location location = 2; + bool has_location() const; + private: + bool _internal_has_location() const; + public: + void clear_location(); + const ::proto::Location& location() const; + PROTOBUF_NODISCARD ::proto::Location* release_location(); + ::proto::Location* mutable_location(); + void set_allocated_location(::proto::Location* location); + private: + const ::proto::Location& _internal_location() const; + ::proto::Location* _internal_mutable_location(); + public: + void unsafe_arena_set_allocated_location( + ::proto::Location* location); + ::proto::Location* unsafe_arena_release_location(); + + void clear_action(); + ActionCase action_case() const; + // @@protoc_insertion_point(class_scope:proto.InteractiveAnnotation) + private: + class _Internal; + void set_has_location(); + + inline bool has_action() const; + inline void clear_has_action(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Point > polygonvertices_; + union ActionUnion { + constexpr ActionUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::proto::Location* location_; + } action_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + uint32_t _oneof_case_[1]; + + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class KeepInChat final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.KeepInChat) */ { + public: + inline KeepInChat() : KeepInChat(nullptr) {} + ~KeepInChat() override; + explicit PROTOBUF_CONSTEXPR KeepInChat(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + KeepInChat(const KeepInChat& from); + KeepInChat(KeepInChat&& from) noexcept + : KeepInChat() { + *this = ::std::move(from); + } + + inline KeepInChat& operator=(const KeepInChat& from) { + CopyFrom(from); + return *this; + } + inline KeepInChat& operator=(KeepInChat&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const KeepInChat& default_instance() { + return *internal_default_instance(); + } + static inline const KeepInChat* internal_default_instance() { + return reinterpret_cast( + &_KeepInChat_default_instance_); + } + static constexpr int kIndexInFileMessages = + 47; + + friend void swap(KeepInChat& a, KeepInChat& b) { + a.Swap(&b); + } + inline void Swap(KeepInChat* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(KeepInChat* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + KeepInChat* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const KeepInChat& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const KeepInChat& from) { + KeepInChat::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(KeepInChat* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.KeepInChat"; + } + protected: + explicit KeepInChat(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDeviceJidFieldNumber = 4, + kKeyFieldNumber = 3, + kServerTimestampFieldNumber = 2, + kKeepTypeFieldNumber = 1, + }; + // optional string deviceJid = 4; + bool has_devicejid() const; + private: + bool _internal_has_devicejid() const; + public: + void clear_devicejid(); + const std::string& devicejid() const; + template + void set_devicejid(ArgT0&& arg0, ArgT... args); + std::string* mutable_devicejid(); + PROTOBUF_NODISCARD std::string* release_devicejid(); + void set_allocated_devicejid(std::string* devicejid); + private: + const std::string& _internal_devicejid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_devicejid(const std::string& value); + std::string* _internal_mutable_devicejid(); + public: + + // optional .proto.MessageKey key = 3; + bool has_key() const; + private: + bool _internal_has_key() const; + public: + void clear_key(); + const ::proto::MessageKey& key() const; + PROTOBUF_NODISCARD ::proto::MessageKey* release_key(); + ::proto::MessageKey* mutable_key(); + void set_allocated_key(::proto::MessageKey* key); + private: + const ::proto::MessageKey& _internal_key() const; + ::proto::MessageKey* _internal_mutable_key(); + public: + void unsafe_arena_set_allocated_key( + ::proto::MessageKey* key); + ::proto::MessageKey* unsafe_arena_release_key(); + + // optional int64 serverTimestamp = 2; + bool has_servertimestamp() const; + private: + bool _internal_has_servertimestamp() const; + public: + void clear_servertimestamp(); + int64_t servertimestamp() const; + void set_servertimestamp(int64_t value); + private: + int64_t _internal_servertimestamp() const; + void _internal_set_servertimestamp(int64_t value); + public: + + // optional .proto.KeepType keepType = 1; + bool has_keeptype() const; + private: + bool _internal_has_keeptype() const; + public: + void clear_keeptype(); + ::proto::KeepType keeptype() const; + void set_keeptype(::proto::KeepType value); + private: + ::proto::KeepType _internal_keeptype() const; + void _internal_set_keeptype(::proto::KeepType value); + public: + + // @@protoc_insertion_point(class_scope:proto.KeepInChat) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr devicejid_; + ::proto::MessageKey* key_; + int64_t servertimestamp_; + int keeptype_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class KeyId final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.KeyId) */ { + public: + inline KeyId() : KeyId(nullptr) {} + ~KeyId() override; + explicit PROTOBUF_CONSTEXPR KeyId(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + KeyId(const KeyId& from); + KeyId(KeyId&& from) noexcept + : KeyId() { + *this = ::std::move(from); + } + + inline KeyId& operator=(const KeyId& from) { + CopyFrom(from); + return *this; + } + inline KeyId& operator=(KeyId&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const KeyId& default_instance() { + return *internal_default_instance(); + } + static inline const KeyId* internal_default_instance() { + return reinterpret_cast( + &_KeyId_default_instance_); + } + static constexpr int kIndexInFileMessages = + 48; + + friend void swap(KeyId& a, KeyId& b) { + a.Swap(&b); + } + inline void Swap(KeyId* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(KeyId* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + KeyId* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const KeyId& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const KeyId& from) { + KeyId::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(KeyId* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.KeyId"; + } + protected: + explicit KeyId(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kIdFieldNumber = 1, + }; + // optional bytes id = 1; + bool has_id() const; + private: + bool _internal_has_id() const; + public: + void clear_id(); + const std::string& id() const; + template + void set_id(ArgT0&& arg0, ArgT... args); + std::string* mutable_id(); + PROTOBUF_NODISCARD std::string* release_id(); + void set_allocated_id(std::string* id); + private: + const std::string& _internal_id() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value); + std::string* _internal_mutable_id(); + public: + + // @@protoc_insertion_point(class_scope:proto.KeyId) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class LocalizedName final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.LocalizedName) */ { + public: + inline LocalizedName() : LocalizedName(nullptr) {} + ~LocalizedName() override; + explicit PROTOBUF_CONSTEXPR LocalizedName(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + LocalizedName(const LocalizedName& from); + LocalizedName(LocalizedName&& from) noexcept + : LocalizedName() { + *this = ::std::move(from); + } + + inline LocalizedName& operator=(const LocalizedName& from) { + CopyFrom(from); + return *this; + } + inline LocalizedName& operator=(LocalizedName&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const LocalizedName& default_instance() { + return *internal_default_instance(); + } + static inline const LocalizedName* internal_default_instance() { + return reinterpret_cast( + &_LocalizedName_default_instance_); + } + static constexpr int kIndexInFileMessages = + 49; + + friend void swap(LocalizedName& a, LocalizedName& b) { + a.Swap(&b); + } + inline void Swap(LocalizedName* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(LocalizedName* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + LocalizedName* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const LocalizedName& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const LocalizedName& from) { + LocalizedName::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(LocalizedName* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.LocalizedName"; + } + protected: + explicit LocalizedName(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kLgFieldNumber = 1, + kLcFieldNumber = 2, + kVerifiedNameFieldNumber = 3, + }; + // optional string lg = 1; + bool has_lg() const; + private: + bool _internal_has_lg() const; + public: + void clear_lg(); + const std::string& lg() const; + template + void set_lg(ArgT0&& arg0, ArgT... args); + std::string* mutable_lg(); + PROTOBUF_NODISCARD std::string* release_lg(); + void set_allocated_lg(std::string* lg); + private: + const std::string& _internal_lg() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_lg(const std::string& value); + std::string* _internal_mutable_lg(); + public: + + // optional string lc = 2; + bool has_lc() const; + private: + bool _internal_has_lc() const; + public: + void clear_lc(); + const std::string& lc() const; + template + void set_lc(ArgT0&& arg0, ArgT... args); + std::string* mutable_lc(); + PROTOBUF_NODISCARD std::string* release_lc(); + void set_allocated_lc(std::string* lc); + private: + const std::string& _internal_lc() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_lc(const std::string& value); + std::string* _internal_mutable_lc(); + public: + + // optional string verifiedName = 3; + bool has_verifiedname() const; + private: + bool _internal_has_verifiedname() const; + public: + void clear_verifiedname(); + const std::string& verifiedname() const; + template + void set_verifiedname(ArgT0&& arg0, ArgT... args); + std::string* mutable_verifiedname(); + PROTOBUF_NODISCARD std::string* release_verifiedname(); + void set_allocated_verifiedname(std::string* verifiedname); + private: + const std::string& _internal_verifiedname() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_verifiedname(const std::string& value); + std::string* _internal_mutable_verifiedname(); + public: + + // @@protoc_insertion_point(class_scope:proto.LocalizedName) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr lg_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr lc_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr verifiedname_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Location final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Location) */ { + public: + inline Location() : Location(nullptr) {} + ~Location() override; + explicit PROTOBUF_CONSTEXPR Location(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Location(const Location& from); + Location(Location&& from) noexcept + : Location() { + *this = ::std::move(from); + } + + inline Location& operator=(const Location& from) { + CopyFrom(from); + return *this; + } + inline Location& operator=(Location&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Location& default_instance() { + return *internal_default_instance(); + } + static inline const Location* internal_default_instance() { + return reinterpret_cast( + &_Location_default_instance_); + } + static constexpr int kIndexInFileMessages = + 50; + + friend void swap(Location& a, Location& b) { + a.Swap(&b); + } + inline void Swap(Location* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Location* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Location* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Location& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Location& from) { + Location::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Location* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Location"; + } + protected: + explicit Location(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNameFieldNumber = 3, + kDegreesLatitudeFieldNumber = 1, + kDegreesLongitudeFieldNumber = 2, + }; + // optional string name = 3; + bool has_name() const; + private: + bool _internal_has_name() const; + public: + void clear_name(); + const std::string& name() const; + template + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + PROTOBUF_NODISCARD std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // optional double degreesLatitude = 1; + bool has_degreeslatitude() const; + private: + bool _internal_has_degreeslatitude() const; + public: + void clear_degreeslatitude(); + double degreeslatitude() const; + void set_degreeslatitude(double value); + private: + double _internal_degreeslatitude() const; + void _internal_set_degreeslatitude(double value); + public: + + // optional double degreesLongitude = 2; + bool has_degreeslongitude() const; + private: + bool _internal_has_degreeslongitude() const; + public: + void clear_degreeslongitude(); + double degreeslongitude() const; + void set_degreeslongitude(double value); + private: + double _internal_degreeslongitude() const; + void _internal_set_degreeslongitude(double value); + public: + + // @@protoc_insertion_point(class_scope:proto.Location) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + double degreeslatitude_; + double degreeslongitude_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class MediaData final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.MediaData) */ { + public: + inline MediaData() : MediaData(nullptr) {} + ~MediaData() override; + explicit PROTOBUF_CONSTEXPR MediaData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + MediaData(const MediaData& from); + MediaData(MediaData&& from) noexcept + : MediaData() { + *this = ::std::move(from); + } + + inline MediaData& operator=(const MediaData& from) { + CopyFrom(from); + return *this; + } + inline MediaData& operator=(MediaData&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const MediaData& default_instance() { + return *internal_default_instance(); + } + static inline const MediaData* internal_default_instance() { + return reinterpret_cast( + &_MediaData_default_instance_); + } + static constexpr int kIndexInFileMessages = + 51; + + friend void swap(MediaData& a, MediaData& b) { + a.Swap(&b); + } + inline void Swap(MediaData* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(MediaData* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + MediaData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const MediaData& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const MediaData& from) { + MediaData::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(MediaData* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.MediaData"; + } + protected: + explicit MediaData(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kLocalPathFieldNumber = 1, + }; + // optional string localPath = 1; + bool has_localpath() const; + private: + bool _internal_has_localpath() const; + public: + void clear_localpath(); + const std::string& localpath() const; + template + void set_localpath(ArgT0&& arg0, ArgT... args); + std::string* mutable_localpath(); + PROTOBUF_NODISCARD std::string* release_localpath(); + void set_allocated_localpath(std::string* localpath); + private: + const std::string& _internal_localpath() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_localpath(const std::string& value); + std::string* _internal_mutable_localpath(); + public: + + // @@protoc_insertion_point(class_scope:proto.MediaData) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localpath_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class MediaRetryNotification final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.MediaRetryNotification) */ { + public: + inline MediaRetryNotification() : MediaRetryNotification(nullptr) {} + ~MediaRetryNotification() override; + explicit PROTOBUF_CONSTEXPR MediaRetryNotification(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + MediaRetryNotification(const MediaRetryNotification& from); + MediaRetryNotification(MediaRetryNotification&& from) noexcept + : MediaRetryNotification() { + *this = ::std::move(from); + } + + inline MediaRetryNotification& operator=(const MediaRetryNotification& from) { + CopyFrom(from); + return *this; + } + inline MediaRetryNotification& operator=(MediaRetryNotification&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const MediaRetryNotification& default_instance() { + return *internal_default_instance(); + } + static inline const MediaRetryNotification* internal_default_instance() { + return reinterpret_cast( + &_MediaRetryNotification_default_instance_); + } + static constexpr int kIndexInFileMessages = + 52; + + friend void swap(MediaRetryNotification& a, MediaRetryNotification& b) { + a.Swap(&b); + } + inline void Swap(MediaRetryNotification* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(MediaRetryNotification* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + MediaRetryNotification* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const MediaRetryNotification& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const MediaRetryNotification& from) { + MediaRetryNotification::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(MediaRetryNotification* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.MediaRetryNotification"; + } + protected: + explicit MediaRetryNotification(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef MediaRetryNotification_ResultType ResultType; + static constexpr ResultType GENERAL_ERROR = + MediaRetryNotification_ResultType_GENERAL_ERROR; + static constexpr ResultType SUCCESS = + MediaRetryNotification_ResultType_SUCCESS; + static constexpr ResultType NOT_FOUND = + MediaRetryNotification_ResultType_NOT_FOUND; + static constexpr ResultType DECRYPTION_ERROR = + MediaRetryNotification_ResultType_DECRYPTION_ERROR; + static inline bool ResultType_IsValid(int value) { + return MediaRetryNotification_ResultType_IsValid(value); + } + static constexpr ResultType ResultType_MIN = + MediaRetryNotification_ResultType_ResultType_MIN; + static constexpr ResultType ResultType_MAX = + MediaRetryNotification_ResultType_ResultType_MAX; + static constexpr int ResultType_ARRAYSIZE = + MediaRetryNotification_ResultType_ResultType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + ResultType_descriptor() { + return MediaRetryNotification_ResultType_descriptor(); + } + template + static inline const std::string& ResultType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ResultType_Name."); + return MediaRetryNotification_ResultType_Name(enum_t_value); + } + static inline bool ResultType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + ResultType* value) { + return MediaRetryNotification_ResultType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kStanzaIdFieldNumber = 1, + kDirectPathFieldNumber = 2, + kResultFieldNumber = 3, + }; + // optional string stanzaId = 1; + bool has_stanzaid() const; + private: + bool _internal_has_stanzaid() const; + public: + void clear_stanzaid(); + const std::string& stanzaid() const; + template + void set_stanzaid(ArgT0&& arg0, ArgT... args); + std::string* mutable_stanzaid(); + PROTOBUF_NODISCARD std::string* release_stanzaid(); + void set_allocated_stanzaid(std::string* stanzaid); + private: + const std::string& _internal_stanzaid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_stanzaid(const std::string& value); + std::string* _internal_mutable_stanzaid(); + public: + + // optional string directPath = 2; + bool has_directpath() const; + private: + bool _internal_has_directpath() const; + public: + void clear_directpath(); + const std::string& directpath() const; + template + void set_directpath(ArgT0&& arg0, ArgT... args); + std::string* mutable_directpath(); + PROTOBUF_NODISCARD std::string* release_directpath(); + void set_allocated_directpath(std::string* directpath); + private: + const std::string& _internal_directpath() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value); + std::string* _internal_mutable_directpath(); + public: + + // optional .proto.MediaRetryNotification.ResultType result = 3; + bool has_result() const; + private: + bool _internal_has_result() const; + public: + void clear_result(); + ::proto::MediaRetryNotification_ResultType result() const; + void set_result(::proto::MediaRetryNotification_ResultType value); + private: + ::proto::MediaRetryNotification_ResultType _internal_result() const; + void _internal_set_result(::proto::MediaRetryNotification_ResultType value); + public: + + // @@protoc_insertion_point(class_scope:proto.MediaRetryNotification) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr stanzaid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_; + int result_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_AppStateFatalExceptionNotification final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AppStateFatalExceptionNotification) */ { + public: + inline Message_AppStateFatalExceptionNotification() : Message_AppStateFatalExceptionNotification(nullptr) {} + ~Message_AppStateFatalExceptionNotification() override; + explicit PROTOBUF_CONSTEXPR Message_AppStateFatalExceptionNotification(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_AppStateFatalExceptionNotification(const Message_AppStateFatalExceptionNotification& from); + Message_AppStateFatalExceptionNotification(Message_AppStateFatalExceptionNotification&& from) noexcept + : Message_AppStateFatalExceptionNotification() { + *this = ::std::move(from); + } + + inline Message_AppStateFatalExceptionNotification& operator=(const Message_AppStateFatalExceptionNotification& from) { + CopyFrom(from); + return *this; + } + inline Message_AppStateFatalExceptionNotification& operator=(Message_AppStateFatalExceptionNotification&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_AppStateFatalExceptionNotification& default_instance() { + return *internal_default_instance(); + } + static inline const Message_AppStateFatalExceptionNotification* internal_default_instance() { + return reinterpret_cast( + &_Message_AppStateFatalExceptionNotification_default_instance_); + } + static constexpr int kIndexInFileMessages = + 53; + + friend void swap(Message_AppStateFatalExceptionNotification& a, Message_AppStateFatalExceptionNotification& b) { + a.Swap(&b); + } + inline void Swap(Message_AppStateFatalExceptionNotification* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_AppStateFatalExceptionNotification* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_AppStateFatalExceptionNotification* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_AppStateFatalExceptionNotification& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_AppStateFatalExceptionNotification& from) { + Message_AppStateFatalExceptionNotification::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_AppStateFatalExceptionNotification* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.AppStateFatalExceptionNotification"; + } + protected: + explicit Message_AppStateFatalExceptionNotification(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kCollectionNamesFieldNumber = 1, + kTimestampFieldNumber = 2, + }; + // repeated string collectionNames = 1; + int collectionnames_size() const; + private: + int _internal_collectionnames_size() const; + public: + void clear_collectionnames(); + const std::string& collectionnames(int index) const; + std::string* mutable_collectionnames(int index); + void set_collectionnames(int index, const std::string& value); + void set_collectionnames(int index, std::string&& value); + void set_collectionnames(int index, const char* value); + void set_collectionnames(int index, const char* value, size_t size); + std::string* add_collectionnames(); + void add_collectionnames(const std::string& value); + void add_collectionnames(std::string&& value); + void add_collectionnames(const char* value); + void add_collectionnames(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& collectionnames() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_collectionnames(); + private: + const std::string& _internal_collectionnames(int index) const; + std::string* _internal_add_collectionnames(); + public: + + // optional int64 timestamp = 2; + bool has_timestamp() const; + private: + bool _internal_has_timestamp() const; + public: + void clear_timestamp(); + int64_t timestamp() const; + void set_timestamp(int64_t value); + private: + int64_t _internal_timestamp() const; + void _internal_set_timestamp(int64_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.AppStateFatalExceptionNotification) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField collectionnames_; + int64_t timestamp_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_AppStateSyncKeyData final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AppStateSyncKeyData) */ { + public: + inline Message_AppStateSyncKeyData() : Message_AppStateSyncKeyData(nullptr) {} + ~Message_AppStateSyncKeyData() override; + explicit PROTOBUF_CONSTEXPR Message_AppStateSyncKeyData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_AppStateSyncKeyData(const Message_AppStateSyncKeyData& from); + Message_AppStateSyncKeyData(Message_AppStateSyncKeyData&& from) noexcept + : Message_AppStateSyncKeyData() { + *this = ::std::move(from); + } + + inline Message_AppStateSyncKeyData& operator=(const Message_AppStateSyncKeyData& from) { + CopyFrom(from); + return *this; + } + inline Message_AppStateSyncKeyData& operator=(Message_AppStateSyncKeyData&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_AppStateSyncKeyData& default_instance() { + return *internal_default_instance(); + } + static inline const Message_AppStateSyncKeyData* internal_default_instance() { + return reinterpret_cast( + &_Message_AppStateSyncKeyData_default_instance_); + } + static constexpr int kIndexInFileMessages = + 54; + + friend void swap(Message_AppStateSyncKeyData& a, Message_AppStateSyncKeyData& b) { + a.Swap(&b); + } + inline void Swap(Message_AppStateSyncKeyData* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_AppStateSyncKeyData* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_AppStateSyncKeyData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_AppStateSyncKeyData& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_AppStateSyncKeyData& from) { + Message_AppStateSyncKeyData::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_AppStateSyncKeyData* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.AppStateSyncKeyData"; + } + protected: + explicit Message_AppStateSyncKeyData(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kKeyDataFieldNumber = 1, + kFingerprintFieldNumber = 2, + kTimestampFieldNumber = 3, + }; + // optional bytes keyData = 1; + bool has_keydata() const; + private: + bool _internal_has_keydata() const; + public: + void clear_keydata(); + const std::string& keydata() const; + template + void set_keydata(ArgT0&& arg0, ArgT... args); + std::string* mutable_keydata(); + PROTOBUF_NODISCARD std::string* release_keydata(); + void set_allocated_keydata(std::string* keydata); + private: + const std::string& _internal_keydata() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_keydata(const std::string& value); + std::string* _internal_mutable_keydata(); + public: + + // optional .proto.Message.AppStateSyncKeyFingerprint fingerprint = 2; + bool has_fingerprint() const; + private: + bool _internal_has_fingerprint() const; + public: + void clear_fingerprint(); + const ::proto::Message_AppStateSyncKeyFingerprint& fingerprint() const; + PROTOBUF_NODISCARD ::proto::Message_AppStateSyncKeyFingerprint* release_fingerprint(); + ::proto::Message_AppStateSyncKeyFingerprint* mutable_fingerprint(); + void set_allocated_fingerprint(::proto::Message_AppStateSyncKeyFingerprint* fingerprint); + private: + const ::proto::Message_AppStateSyncKeyFingerprint& _internal_fingerprint() const; + ::proto::Message_AppStateSyncKeyFingerprint* _internal_mutable_fingerprint(); + public: + void unsafe_arena_set_allocated_fingerprint( + ::proto::Message_AppStateSyncKeyFingerprint* fingerprint); + ::proto::Message_AppStateSyncKeyFingerprint* unsafe_arena_release_fingerprint(); + + // optional int64 timestamp = 3; + bool has_timestamp() const; + private: + bool _internal_has_timestamp() const; + public: + void clear_timestamp(); + int64_t timestamp() const; + void set_timestamp(int64_t value); + private: + int64_t _internal_timestamp() const; + void _internal_set_timestamp(int64_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.AppStateSyncKeyData) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr keydata_; + ::proto::Message_AppStateSyncKeyFingerprint* fingerprint_; + int64_t timestamp_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_AppStateSyncKeyFingerprint final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AppStateSyncKeyFingerprint) */ { + public: + inline Message_AppStateSyncKeyFingerprint() : Message_AppStateSyncKeyFingerprint(nullptr) {} + ~Message_AppStateSyncKeyFingerprint() override; + explicit PROTOBUF_CONSTEXPR Message_AppStateSyncKeyFingerprint(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_AppStateSyncKeyFingerprint(const Message_AppStateSyncKeyFingerprint& from); + Message_AppStateSyncKeyFingerprint(Message_AppStateSyncKeyFingerprint&& from) noexcept + : Message_AppStateSyncKeyFingerprint() { + *this = ::std::move(from); + } + + inline Message_AppStateSyncKeyFingerprint& operator=(const Message_AppStateSyncKeyFingerprint& from) { + CopyFrom(from); + return *this; + } + inline Message_AppStateSyncKeyFingerprint& operator=(Message_AppStateSyncKeyFingerprint&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_AppStateSyncKeyFingerprint& default_instance() { + return *internal_default_instance(); + } + static inline const Message_AppStateSyncKeyFingerprint* internal_default_instance() { + return reinterpret_cast( + &_Message_AppStateSyncKeyFingerprint_default_instance_); + } + static constexpr int kIndexInFileMessages = + 55; + + friend void swap(Message_AppStateSyncKeyFingerprint& a, Message_AppStateSyncKeyFingerprint& b) { + a.Swap(&b); + } + inline void Swap(Message_AppStateSyncKeyFingerprint* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_AppStateSyncKeyFingerprint* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_AppStateSyncKeyFingerprint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_AppStateSyncKeyFingerprint& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_AppStateSyncKeyFingerprint& from) { + Message_AppStateSyncKeyFingerprint::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_AppStateSyncKeyFingerprint* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.AppStateSyncKeyFingerprint"; + } + protected: + explicit Message_AppStateSyncKeyFingerprint(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDeviceIndexesFieldNumber = 3, + kRawIdFieldNumber = 1, + kCurrentIndexFieldNumber = 2, + }; + // repeated uint32 deviceIndexes = 3 [packed = true]; + int deviceindexes_size() const; + private: + int _internal_deviceindexes_size() const; + public: + void clear_deviceindexes(); + private: + uint32_t _internal_deviceindexes(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + _internal_deviceindexes() const; + void _internal_add_deviceindexes(uint32_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + _internal_mutable_deviceindexes(); + public: + uint32_t deviceindexes(int index) const; + void set_deviceindexes(int index, uint32_t value); + void add_deviceindexes(uint32_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + deviceindexes() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + mutable_deviceindexes(); + + // optional uint32 rawId = 1; + bool has_rawid() const; + private: + bool _internal_has_rawid() const; + public: + void clear_rawid(); + uint32_t rawid() const; + void set_rawid(uint32_t value); + private: + uint32_t _internal_rawid() const; + void _internal_set_rawid(uint32_t value); + public: + + // optional uint32 currentIndex = 2; + bool has_currentindex() const; + private: + bool _internal_has_currentindex() const; + public: + void clear_currentindex(); + uint32_t currentindex() const; + void set_currentindex(uint32_t value); + private: + uint32_t _internal_currentindex() const; + void _internal_set_currentindex(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.AppStateSyncKeyFingerprint) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > deviceindexes_; + mutable std::atomic _deviceindexes_cached_byte_size_; + uint32_t rawid_; + uint32_t currentindex_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_AppStateSyncKeyId final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AppStateSyncKeyId) */ { + public: + inline Message_AppStateSyncKeyId() : Message_AppStateSyncKeyId(nullptr) {} + ~Message_AppStateSyncKeyId() override; + explicit PROTOBUF_CONSTEXPR Message_AppStateSyncKeyId(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_AppStateSyncKeyId(const Message_AppStateSyncKeyId& from); + Message_AppStateSyncKeyId(Message_AppStateSyncKeyId&& from) noexcept + : Message_AppStateSyncKeyId() { + *this = ::std::move(from); + } + + inline Message_AppStateSyncKeyId& operator=(const Message_AppStateSyncKeyId& from) { + CopyFrom(from); + return *this; + } + inline Message_AppStateSyncKeyId& operator=(Message_AppStateSyncKeyId&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_AppStateSyncKeyId& default_instance() { + return *internal_default_instance(); + } + static inline const Message_AppStateSyncKeyId* internal_default_instance() { + return reinterpret_cast( + &_Message_AppStateSyncKeyId_default_instance_); + } + static constexpr int kIndexInFileMessages = + 56; + + friend void swap(Message_AppStateSyncKeyId& a, Message_AppStateSyncKeyId& b) { + a.Swap(&b); + } + inline void Swap(Message_AppStateSyncKeyId* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_AppStateSyncKeyId* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_AppStateSyncKeyId* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_AppStateSyncKeyId& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_AppStateSyncKeyId& from) { + Message_AppStateSyncKeyId::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_AppStateSyncKeyId* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.AppStateSyncKeyId"; + } + protected: + explicit Message_AppStateSyncKeyId(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kKeyIdFieldNumber = 1, + }; + // optional bytes keyId = 1; + bool has_keyid() const; + private: + bool _internal_has_keyid() const; + public: + void clear_keyid(); + const std::string& keyid() const; + template + void set_keyid(ArgT0&& arg0, ArgT... args); + std::string* mutable_keyid(); + PROTOBUF_NODISCARD std::string* release_keyid(); + void set_allocated_keyid(std::string* keyid); + private: + const std::string& _internal_keyid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_keyid(const std::string& value); + std::string* _internal_mutable_keyid(); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.AppStateSyncKeyId) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr keyid_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_AppStateSyncKeyRequest final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AppStateSyncKeyRequest) */ { + public: + inline Message_AppStateSyncKeyRequest() : Message_AppStateSyncKeyRequest(nullptr) {} + ~Message_AppStateSyncKeyRequest() override; + explicit PROTOBUF_CONSTEXPR Message_AppStateSyncKeyRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_AppStateSyncKeyRequest(const Message_AppStateSyncKeyRequest& from); + Message_AppStateSyncKeyRequest(Message_AppStateSyncKeyRequest&& from) noexcept + : Message_AppStateSyncKeyRequest() { + *this = ::std::move(from); + } + + inline Message_AppStateSyncKeyRequest& operator=(const Message_AppStateSyncKeyRequest& from) { + CopyFrom(from); + return *this; + } + inline Message_AppStateSyncKeyRequest& operator=(Message_AppStateSyncKeyRequest&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_AppStateSyncKeyRequest& default_instance() { + return *internal_default_instance(); + } + static inline const Message_AppStateSyncKeyRequest* internal_default_instance() { + return reinterpret_cast( + &_Message_AppStateSyncKeyRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = + 57; + + friend void swap(Message_AppStateSyncKeyRequest& a, Message_AppStateSyncKeyRequest& b) { + a.Swap(&b); + } + inline void Swap(Message_AppStateSyncKeyRequest* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_AppStateSyncKeyRequest* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_AppStateSyncKeyRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_AppStateSyncKeyRequest& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_AppStateSyncKeyRequest& from) { + Message_AppStateSyncKeyRequest::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_AppStateSyncKeyRequest* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.AppStateSyncKeyRequest"; + } + protected: + explicit Message_AppStateSyncKeyRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kKeyIdsFieldNumber = 1, + }; + // repeated .proto.Message.AppStateSyncKeyId keyIds = 1; + int keyids_size() const; + private: + int _internal_keyids_size() const; + public: + void clear_keyids(); + ::proto::Message_AppStateSyncKeyId* mutable_keyids(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKeyId >* + mutable_keyids(); + private: + const ::proto::Message_AppStateSyncKeyId& _internal_keyids(int index) const; + ::proto::Message_AppStateSyncKeyId* _internal_add_keyids(); + public: + const ::proto::Message_AppStateSyncKeyId& keyids(int index) const; + ::proto::Message_AppStateSyncKeyId* add_keyids(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKeyId >& + keyids() const; + + // @@protoc_insertion_point(class_scope:proto.Message.AppStateSyncKeyRequest) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKeyId > keyids_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_AppStateSyncKeyShare final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AppStateSyncKeyShare) */ { + public: + inline Message_AppStateSyncKeyShare() : Message_AppStateSyncKeyShare(nullptr) {} + ~Message_AppStateSyncKeyShare() override; + explicit PROTOBUF_CONSTEXPR Message_AppStateSyncKeyShare(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_AppStateSyncKeyShare(const Message_AppStateSyncKeyShare& from); + Message_AppStateSyncKeyShare(Message_AppStateSyncKeyShare&& from) noexcept + : Message_AppStateSyncKeyShare() { + *this = ::std::move(from); + } + + inline Message_AppStateSyncKeyShare& operator=(const Message_AppStateSyncKeyShare& from) { + CopyFrom(from); + return *this; + } + inline Message_AppStateSyncKeyShare& operator=(Message_AppStateSyncKeyShare&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_AppStateSyncKeyShare& default_instance() { + return *internal_default_instance(); + } + static inline const Message_AppStateSyncKeyShare* internal_default_instance() { + return reinterpret_cast( + &_Message_AppStateSyncKeyShare_default_instance_); + } + static constexpr int kIndexInFileMessages = + 58; + + friend void swap(Message_AppStateSyncKeyShare& a, Message_AppStateSyncKeyShare& b) { + a.Swap(&b); + } + inline void Swap(Message_AppStateSyncKeyShare* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_AppStateSyncKeyShare* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_AppStateSyncKeyShare* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_AppStateSyncKeyShare& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_AppStateSyncKeyShare& from) { + Message_AppStateSyncKeyShare::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_AppStateSyncKeyShare* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.AppStateSyncKeyShare"; + } + protected: + explicit Message_AppStateSyncKeyShare(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kKeysFieldNumber = 1, + }; + // repeated .proto.Message.AppStateSyncKey keys = 1; + int keys_size() const; + private: + int _internal_keys_size() const; + public: + void clear_keys(); + ::proto::Message_AppStateSyncKey* mutable_keys(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKey >* + mutable_keys(); + private: + const ::proto::Message_AppStateSyncKey& _internal_keys(int index) const; + ::proto::Message_AppStateSyncKey* _internal_add_keys(); + public: + const ::proto::Message_AppStateSyncKey& keys(int index) const; + ::proto::Message_AppStateSyncKey* add_keys(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKey >& + keys() const; + + // @@protoc_insertion_point(class_scope:proto.Message.AppStateSyncKeyShare) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKey > keys_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_AppStateSyncKey final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AppStateSyncKey) */ { + public: + inline Message_AppStateSyncKey() : Message_AppStateSyncKey(nullptr) {} + ~Message_AppStateSyncKey() override; + explicit PROTOBUF_CONSTEXPR Message_AppStateSyncKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_AppStateSyncKey(const Message_AppStateSyncKey& from); + Message_AppStateSyncKey(Message_AppStateSyncKey&& from) noexcept + : Message_AppStateSyncKey() { + *this = ::std::move(from); + } + + inline Message_AppStateSyncKey& operator=(const Message_AppStateSyncKey& from) { + CopyFrom(from); + return *this; + } + inline Message_AppStateSyncKey& operator=(Message_AppStateSyncKey&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_AppStateSyncKey& default_instance() { + return *internal_default_instance(); + } + static inline const Message_AppStateSyncKey* internal_default_instance() { + return reinterpret_cast( + &_Message_AppStateSyncKey_default_instance_); + } + static constexpr int kIndexInFileMessages = + 59; + + friend void swap(Message_AppStateSyncKey& a, Message_AppStateSyncKey& b) { + a.Swap(&b); + } + inline void Swap(Message_AppStateSyncKey* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_AppStateSyncKey* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_AppStateSyncKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_AppStateSyncKey& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_AppStateSyncKey& from) { + Message_AppStateSyncKey::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_AppStateSyncKey* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.AppStateSyncKey"; + } + protected: + explicit Message_AppStateSyncKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kKeyIdFieldNumber = 1, + kKeyDataFieldNumber = 2, + }; + // optional .proto.Message.AppStateSyncKeyId keyId = 1; + bool has_keyid() const; + private: + bool _internal_has_keyid() const; + public: + void clear_keyid(); + const ::proto::Message_AppStateSyncKeyId& keyid() const; + PROTOBUF_NODISCARD ::proto::Message_AppStateSyncKeyId* release_keyid(); + ::proto::Message_AppStateSyncKeyId* mutable_keyid(); + void set_allocated_keyid(::proto::Message_AppStateSyncKeyId* keyid); + private: + const ::proto::Message_AppStateSyncKeyId& _internal_keyid() const; + ::proto::Message_AppStateSyncKeyId* _internal_mutable_keyid(); + public: + void unsafe_arena_set_allocated_keyid( + ::proto::Message_AppStateSyncKeyId* keyid); + ::proto::Message_AppStateSyncKeyId* unsafe_arena_release_keyid(); + + // optional .proto.Message.AppStateSyncKeyData keyData = 2; + bool has_keydata() const; + private: + bool _internal_has_keydata() const; + public: + void clear_keydata(); + const ::proto::Message_AppStateSyncKeyData& keydata() const; + PROTOBUF_NODISCARD ::proto::Message_AppStateSyncKeyData* release_keydata(); + ::proto::Message_AppStateSyncKeyData* mutable_keydata(); + void set_allocated_keydata(::proto::Message_AppStateSyncKeyData* keydata); + private: + const ::proto::Message_AppStateSyncKeyData& _internal_keydata() const; + ::proto::Message_AppStateSyncKeyData* _internal_mutable_keydata(); + public: + void unsafe_arena_set_allocated_keydata( + ::proto::Message_AppStateSyncKeyData* keydata); + ::proto::Message_AppStateSyncKeyData* unsafe_arena_release_keydata(); + + // @@protoc_insertion_point(class_scope:proto.Message.AppStateSyncKey) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::proto::Message_AppStateSyncKeyId* keyid_; + ::proto::Message_AppStateSyncKeyData* keydata_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_AudioMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AudioMessage) */ { + public: + inline Message_AudioMessage() : Message_AudioMessage(nullptr) {} + ~Message_AudioMessage() override; + explicit PROTOBUF_CONSTEXPR Message_AudioMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_AudioMessage(const Message_AudioMessage& from); + Message_AudioMessage(Message_AudioMessage&& from) noexcept + : Message_AudioMessage() { + *this = ::std::move(from); + } + + inline Message_AudioMessage& operator=(const Message_AudioMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_AudioMessage& operator=(Message_AudioMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_AudioMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_AudioMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_AudioMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 60; + + friend void swap(Message_AudioMessage& a, Message_AudioMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_AudioMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_AudioMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_AudioMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_AudioMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_AudioMessage& from) { + Message_AudioMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_AudioMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.AudioMessage"; + } + protected: + explicit Message_AudioMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kUrlFieldNumber = 1, + kMimetypeFieldNumber = 2, + kFileSha256FieldNumber = 3, + kMediaKeyFieldNumber = 7, + kFileEncSha256FieldNumber = 8, + kDirectPathFieldNumber = 9, + kStreamingSidecarFieldNumber = 18, + kWaveformFieldNumber = 19, + kContextInfoFieldNumber = 17, + kFileLengthFieldNumber = 4, + kSecondsFieldNumber = 5, + kPttFieldNumber = 6, + kMediaKeyTimestampFieldNumber = 10, + }; + // optional string url = 1; + bool has_url() const; + private: + bool _internal_has_url() const; + public: + void clear_url(); + const std::string& url() const; + template + void set_url(ArgT0&& arg0, ArgT... args); + std::string* mutable_url(); + PROTOBUF_NODISCARD std::string* release_url(); + void set_allocated_url(std::string* url); + private: + const std::string& _internal_url() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value); + std::string* _internal_mutable_url(); + public: + + // optional string mimetype = 2; + bool has_mimetype() const; + private: + bool _internal_has_mimetype() const; + public: + void clear_mimetype(); + const std::string& mimetype() const; + template + void set_mimetype(ArgT0&& arg0, ArgT... args); + std::string* mutable_mimetype(); + PROTOBUF_NODISCARD std::string* release_mimetype(); + void set_allocated_mimetype(std::string* mimetype); + private: + const std::string& _internal_mimetype() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value); + std::string* _internal_mutable_mimetype(); + public: + + // optional bytes fileSha256 = 3; + bool has_filesha256() const; + private: + bool _internal_has_filesha256() const; + public: + void clear_filesha256(); + const std::string& filesha256() const; + template + void set_filesha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_filesha256(); + PROTOBUF_NODISCARD std::string* release_filesha256(); + void set_allocated_filesha256(std::string* filesha256); + private: + const std::string& _internal_filesha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value); + std::string* _internal_mutable_filesha256(); + public: + + // optional bytes mediaKey = 7; + bool has_mediakey() const; + private: + bool _internal_has_mediakey() const; + public: + void clear_mediakey(); + const std::string& mediakey() const; + template + void set_mediakey(ArgT0&& arg0, ArgT... args); + std::string* mutable_mediakey(); + PROTOBUF_NODISCARD std::string* release_mediakey(); + void set_allocated_mediakey(std::string* mediakey); + private: + const std::string& _internal_mediakey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value); + std::string* _internal_mutable_mediakey(); + public: + + // optional bytes fileEncSha256 = 8; + bool has_fileencsha256() const; + private: + bool _internal_has_fileencsha256() const; + public: + void clear_fileencsha256(); + const std::string& fileencsha256() const; + template + void set_fileencsha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_fileencsha256(); + PROTOBUF_NODISCARD std::string* release_fileencsha256(); + void set_allocated_fileencsha256(std::string* fileencsha256); + private: + const std::string& _internal_fileencsha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value); + std::string* _internal_mutable_fileencsha256(); + public: + + // optional string directPath = 9; + bool has_directpath() const; + private: + bool _internal_has_directpath() const; + public: + void clear_directpath(); + const std::string& directpath() const; + template + void set_directpath(ArgT0&& arg0, ArgT... args); + std::string* mutable_directpath(); + PROTOBUF_NODISCARD std::string* release_directpath(); + void set_allocated_directpath(std::string* directpath); + private: + const std::string& _internal_directpath() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value); + std::string* _internal_mutable_directpath(); + public: + + // optional bytes streamingSidecar = 18; + bool has_streamingsidecar() const; + private: + bool _internal_has_streamingsidecar() const; + public: + void clear_streamingsidecar(); + const std::string& streamingsidecar() const; + template + void set_streamingsidecar(ArgT0&& arg0, ArgT... args); + std::string* mutable_streamingsidecar(); + PROTOBUF_NODISCARD std::string* release_streamingsidecar(); + void set_allocated_streamingsidecar(std::string* streamingsidecar); + private: + const std::string& _internal_streamingsidecar() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_streamingsidecar(const std::string& value); + std::string* _internal_mutable_streamingsidecar(); + public: + + // optional bytes waveform = 19; + bool has_waveform() const; + private: + bool _internal_has_waveform() const; + public: + void clear_waveform(); + const std::string& waveform() const; + template + void set_waveform(ArgT0&& arg0, ArgT... args); + std::string* mutable_waveform(); + PROTOBUF_NODISCARD std::string* release_waveform(); + void set_allocated_waveform(std::string* waveform); + private: + const std::string& _internal_waveform() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_waveform(const std::string& value); + std::string* _internal_mutable_waveform(); + public: + + // optional .proto.ContextInfo contextInfo = 17; + bool has_contextinfo() const; + private: + bool _internal_has_contextinfo() const; + public: + void clear_contextinfo(); + const ::proto::ContextInfo& contextinfo() const; + PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); + ::proto::ContextInfo* mutable_contextinfo(); + void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); + private: + const ::proto::ContextInfo& _internal_contextinfo() const; + ::proto::ContextInfo* _internal_mutable_contextinfo(); + public: + void unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo); + ::proto::ContextInfo* unsafe_arena_release_contextinfo(); + + // optional uint64 fileLength = 4; + bool has_filelength() const; + private: + bool _internal_has_filelength() const; + public: + void clear_filelength(); + uint64_t filelength() const; + void set_filelength(uint64_t value); + private: + uint64_t _internal_filelength() const; + void _internal_set_filelength(uint64_t value); + public: + + // optional uint32 seconds = 5; + bool has_seconds() const; + private: + bool _internal_has_seconds() const; + public: + void clear_seconds(); + uint32_t seconds() const; + void set_seconds(uint32_t value); + private: + uint32_t _internal_seconds() const; + void _internal_set_seconds(uint32_t value); + public: + + // optional bool ptt = 6; + bool has_ptt() const; + private: + bool _internal_has_ptt() const; + public: + void clear_ptt(); + bool ptt() const; + void set_ptt(bool value); + private: + bool _internal_ptt() const; + void _internal_set_ptt(bool value); + public: + + // optional int64 mediaKeyTimestamp = 10; + bool has_mediakeytimestamp() const; + private: + bool _internal_has_mediakeytimestamp() const; + public: + void clear_mediakeytimestamp(); + int64_t mediakeytimestamp() const; + void set_mediakeytimestamp(int64_t value); + private: + int64_t _internal_mediakeytimestamp() const; + void _internal_set_mediakeytimestamp(int64_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.AudioMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mimetype_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr streamingsidecar_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr waveform_; + ::proto::ContextInfo* contextinfo_; + uint64_t filelength_; + uint32_t seconds_; + bool ptt_; + int64_t mediakeytimestamp_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_ButtonsMessage_Button_ButtonText final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ButtonsMessage.Button.ButtonText) */ { + public: + inline Message_ButtonsMessage_Button_ButtonText() : Message_ButtonsMessage_Button_ButtonText(nullptr) {} + ~Message_ButtonsMessage_Button_ButtonText() override; + explicit PROTOBUF_CONSTEXPR Message_ButtonsMessage_Button_ButtonText(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_ButtonsMessage_Button_ButtonText(const Message_ButtonsMessage_Button_ButtonText& from); + Message_ButtonsMessage_Button_ButtonText(Message_ButtonsMessage_Button_ButtonText&& from) noexcept + : Message_ButtonsMessage_Button_ButtonText() { + *this = ::std::move(from); + } + + inline Message_ButtonsMessage_Button_ButtonText& operator=(const Message_ButtonsMessage_Button_ButtonText& from) { + CopyFrom(from); + return *this; + } + inline Message_ButtonsMessage_Button_ButtonText& operator=(Message_ButtonsMessage_Button_ButtonText&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_ButtonsMessage_Button_ButtonText& default_instance() { + return *internal_default_instance(); + } + static inline const Message_ButtonsMessage_Button_ButtonText* internal_default_instance() { + return reinterpret_cast( + &_Message_ButtonsMessage_Button_ButtonText_default_instance_); + } + static constexpr int kIndexInFileMessages = + 61; + + friend void swap(Message_ButtonsMessage_Button_ButtonText& a, Message_ButtonsMessage_Button_ButtonText& b) { + a.Swap(&b); + } + inline void Swap(Message_ButtonsMessage_Button_ButtonText* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_ButtonsMessage_Button_ButtonText* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_ButtonsMessage_Button_ButtonText* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_ButtonsMessage_Button_ButtonText& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_ButtonsMessage_Button_ButtonText& from) { + Message_ButtonsMessage_Button_ButtonText::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_ButtonsMessage_Button_ButtonText* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.ButtonsMessage.Button.ButtonText"; + } + protected: + explicit Message_ButtonsMessage_Button_ButtonText(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDisplayTextFieldNumber = 1, + }; + // optional string displayText = 1; + bool has_displaytext() const; + private: + bool _internal_has_displaytext() const; + public: + void clear_displaytext(); + const std::string& displaytext() const; + template + void set_displaytext(ArgT0&& arg0, ArgT... args); + std::string* mutable_displaytext(); + PROTOBUF_NODISCARD std::string* release_displaytext(); + void set_allocated_displaytext(std::string* displaytext); + private: + const std::string& _internal_displaytext() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_displaytext(const std::string& value); + std::string* _internal_mutable_displaytext(); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.ButtonsMessage.Button.ButtonText) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr displaytext_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_ButtonsMessage_Button_NativeFlowInfo final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ButtonsMessage.Button.NativeFlowInfo) */ { + public: + inline Message_ButtonsMessage_Button_NativeFlowInfo() : Message_ButtonsMessage_Button_NativeFlowInfo(nullptr) {} + ~Message_ButtonsMessage_Button_NativeFlowInfo() override; + explicit PROTOBUF_CONSTEXPR Message_ButtonsMessage_Button_NativeFlowInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_ButtonsMessage_Button_NativeFlowInfo(const Message_ButtonsMessage_Button_NativeFlowInfo& from); + Message_ButtonsMessage_Button_NativeFlowInfo(Message_ButtonsMessage_Button_NativeFlowInfo&& from) noexcept + : Message_ButtonsMessage_Button_NativeFlowInfo() { + *this = ::std::move(from); + } + + inline Message_ButtonsMessage_Button_NativeFlowInfo& operator=(const Message_ButtonsMessage_Button_NativeFlowInfo& from) { + CopyFrom(from); + return *this; + } + inline Message_ButtonsMessage_Button_NativeFlowInfo& operator=(Message_ButtonsMessage_Button_NativeFlowInfo&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_ButtonsMessage_Button_NativeFlowInfo& default_instance() { + return *internal_default_instance(); + } + static inline const Message_ButtonsMessage_Button_NativeFlowInfo* internal_default_instance() { + return reinterpret_cast( + &_Message_ButtonsMessage_Button_NativeFlowInfo_default_instance_); + } + static constexpr int kIndexInFileMessages = + 62; + + friend void swap(Message_ButtonsMessage_Button_NativeFlowInfo& a, Message_ButtonsMessage_Button_NativeFlowInfo& b) { + a.Swap(&b); + } + inline void Swap(Message_ButtonsMessage_Button_NativeFlowInfo* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_ButtonsMessage_Button_NativeFlowInfo* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_ButtonsMessage_Button_NativeFlowInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_ButtonsMessage_Button_NativeFlowInfo& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_ButtonsMessage_Button_NativeFlowInfo& from) { + Message_ButtonsMessage_Button_NativeFlowInfo::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_ButtonsMessage_Button_NativeFlowInfo* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.ButtonsMessage.Button.NativeFlowInfo"; + } + protected: + explicit Message_ButtonsMessage_Button_NativeFlowInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNameFieldNumber = 1, + kParamsJsonFieldNumber = 2, + }; + // optional string name = 1; + bool has_name() const; + private: + bool _internal_has_name() const; + public: + void clear_name(); + const std::string& name() const; + template + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + PROTOBUF_NODISCARD std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // optional string paramsJson = 2; + bool has_paramsjson() const; + private: + bool _internal_has_paramsjson() const; + public: + void clear_paramsjson(); + const std::string& paramsjson() const; + template + void set_paramsjson(ArgT0&& arg0, ArgT... args); + std::string* mutable_paramsjson(); + PROTOBUF_NODISCARD std::string* release_paramsjson(); + void set_allocated_paramsjson(std::string* paramsjson); + private: + const std::string& _internal_paramsjson() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_paramsjson(const std::string& value); + std::string* _internal_mutable_paramsjson(); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.ButtonsMessage.Button.NativeFlowInfo) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr paramsjson_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_ButtonsMessage_Button final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ButtonsMessage.Button) */ { + public: + inline Message_ButtonsMessage_Button() : Message_ButtonsMessage_Button(nullptr) {} + ~Message_ButtonsMessage_Button() override; + explicit PROTOBUF_CONSTEXPR Message_ButtonsMessage_Button(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_ButtonsMessage_Button(const Message_ButtonsMessage_Button& from); + Message_ButtonsMessage_Button(Message_ButtonsMessage_Button&& from) noexcept + : Message_ButtonsMessage_Button() { + *this = ::std::move(from); + } + + inline Message_ButtonsMessage_Button& operator=(const Message_ButtonsMessage_Button& from) { + CopyFrom(from); + return *this; + } + inline Message_ButtonsMessage_Button& operator=(Message_ButtonsMessage_Button&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_ButtonsMessage_Button& default_instance() { + return *internal_default_instance(); + } + static inline const Message_ButtonsMessage_Button* internal_default_instance() { + return reinterpret_cast( + &_Message_ButtonsMessage_Button_default_instance_); + } + static constexpr int kIndexInFileMessages = + 63; + + friend void swap(Message_ButtonsMessage_Button& a, Message_ButtonsMessage_Button& b) { + a.Swap(&b); + } + inline void Swap(Message_ButtonsMessage_Button* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_ButtonsMessage_Button* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_ButtonsMessage_Button* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_ButtonsMessage_Button& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_ButtonsMessage_Button& from) { + Message_ButtonsMessage_Button::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_ButtonsMessage_Button* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.ButtonsMessage.Button"; + } + protected: + explicit Message_ButtonsMessage_Button(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Message_ButtonsMessage_Button_ButtonText ButtonText; + typedef Message_ButtonsMessage_Button_NativeFlowInfo NativeFlowInfo; + + typedef Message_ButtonsMessage_Button_Type Type; + static constexpr Type UNKNOWN = + Message_ButtonsMessage_Button_Type_UNKNOWN; + static constexpr Type RESPONSE = + Message_ButtonsMessage_Button_Type_RESPONSE; + static constexpr Type NATIVE_FLOW = + Message_ButtonsMessage_Button_Type_NATIVE_FLOW; + static inline bool Type_IsValid(int value) { + return Message_ButtonsMessage_Button_Type_IsValid(value); + } + static constexpr Type Type_MIN = + Message_ButtonsMessage_Button_Type_Type_MIN; + static constexpr Type Type_MAX = + Message_ButtonsMessage_Button_Type_Type_MAX; + static constexpr int Type_ARRAYSIZE = + Message_ButtonsMessage_Button_Type_Type_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + Type_descriptor() { + return Message_ButtonsMessage_Button_Type_descriptor(); + } + template + static inline const std::string& Type_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Type_Name."); + return Message_ButtonsMessage_Button_Type_Name(enum_t_value); + } + static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Type* value) { + return Message_ButtonsMessage_Button_Type_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kButtonIdFieldNumber = 1, + kButtonTextFieldNumber = 2, + kNativeFlowInfoFieldNumber = 4, + kTypeFieldNumber = 3, + }; + // optional string buttonId = 1; + bool has_buttonid() const; + private: + bool _internal_has_buttonid() const; + public: + void clear_buttonid(); + const std::string& buttonid() const; + template + void set_buttonid(ArgT0&& arg0, ArgT... args); + std::string* mutable_buttonid(); + PROTOBUF_NODISCARD std::string* release_buttonid(); + void set_allocated_buttonid(std::string* buttonid); + private: + const std::string& _internal_buttonid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_buttonid(const std::string& value); + std::string* _internal_mutable_buttonid(); + public: + + // optional .proto.Message.ButtonsMessage.Button.ButtonText buttonText = 2; + bool has_buttontext() const; + private: + bool _internal_has_buttontext() const; + public: + void clear_buttontext(); + const ::proto::Message_ButtonsMessage_Button_ButtonText& buttontext() const; + PROTOBUF_NODISCARD ::proto::Message_ButtonsMessage_Button_ButtonText* release_buttontext(); + ::proto::Message_ButtonsMessage_Button_ButtonText* mutable_buttontext(); + void set_allocated_buttontext(::proto::Message_ButtonsMessage_Button_ButtonText* buttontext); + private: + const ::proto::Message_ButtonsMessage_Button_ButtonText& _internal_buttontext() const; + ::proto::Message_ButtonsMessage_Button_ButtonText* _internal_mutable_buttontext(); + public: + void unsafe_arena_set_allocated_buttontext( + ::proto::Message_ButtonsMessage_Button_ButtonText* buttontext); + ::proto::Message_ButtonsMessage_Button_ButtonText* unsafe_arena_release_buttontext(); + + // optional .proto.Message.ButtonsMessage.Button.NativeFlowInfo nativeFlowInfo = 4; + bool has_nativeflowinfo() const; + private: + bool _internal_has_nativeflowinfo() const; + public: + void clear_nativeflowinfo(); + const ::proto::Message_ButtonsMessage_Button_NativeFlowInfo& nativeflowinfo() const; + PROTOBUF_NODISCARD ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* release_nativeflowinfo(); + ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* mutable_nativeflowinfo(); + void set_allocated_nativeflowinfo(::proto::Message_ButtonsMessage_Button_NativeFlowInfo* nativeflowinfo); + private: + const ::proto::Message_ButtonsMessage_Button_NativeFlowInfo& _internal_nativeflowinfo() const; + ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* _internal_mutable_nativeflowinfo(); + public: + void unsafe_arena_set_allocated_nativeflowinfo( + ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* nativeflowinfo); + ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* unsafe_arena_release_nativeflowinfo(); + + // optional .proto.Message.ButtonsMessage.Button.Type type = 3; + bool has_type() const; + private: + bool _internal_has_type() const; + public: + void clear_type(); + ::proto::Message_ButtonsMessage_Button_Type type() const; + void set_type(::proto::Message_ButtonsMessage_Button_Type value); + private: + ::proto::Message_ButtonsMessage_Button_Type _internal_type() const; + void _internal_set_type(::proto::Message_ButtonsMessage_Button_Type value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.ButtonsMessage.Button) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr buttonid_; + ::proto::Message_ButtonsMessage_Button_ButtonText* buttontext_; + ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* nativeflowinfo_; + int type_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_ButtonsMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ButtonsMessage) */ { + public: + inline Message_ButtonsMessage() : Message_ButtonsMessage(nullptr) {} + ~Message_ButtonsMessage() override; + explicit PROTOBUF_CONSTEXPR Message_ButtonsMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_ButtonsMessage(const Message_ButtonsMessage& from); + Message_ButtonsMessage(Message_ButtonsMessage&& from) noexcept + : Message_ButtonsMessage() { + *this = ::std::move(from); + } + + inline Message_ButtonsMessage& operator=(const Message_ButtonsMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_ButtonsMessage& operator=(Message_ButtonsMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_ButtonsMessage& default_instance() { + return *internal_default_instance(); + } + enum HeaderCase { + kText = 1, + kDocumentMessage = 2, + kImageMessage = 3, + kVideoMessage = 4, + kLocationMessage = 5, + HEADER_NOT_SET = 0, + }; + + static inline const Message_ButtonsMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_ButtonsMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 64; + + friend void swap(Message_ButtonsMessage& a, Message_ButtonsMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_ButtonsMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_ButtonsMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_ButtonsMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_ButtonsMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_ButtonsMessage& from) { + Message_ButtonsMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_ButtonsMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.ButtonsMessage"; + } + protected: + explicit Message_ButtonsMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Message_ButtonsMessage_Button Button; + + typedef Message_ButtonsMessage_HeaderType HeaderType; + static constexpr HeaderType UNKNOWN = + Message_ButtonsMessage_HeaderType_UNKNOWN; + static constexpr HeaderType EMPTY = + Message_ButtonsMessage_HeaderType_EMPTY; + static constexpr HeaderType TEXT = + Message_ButtonsMessage_HeaderType_TEXT; + static constexpr HeaderType DOCUMENT = + Message_ButtonsMessage_HeaderType_DOCUMENT; + static constexpr HeaderType IMAGE = + Message_ButtonsMessage_HeaderType_IMAGE; + static constexpr HeaderType VIDEO = + Message_ButtonsMessage_HeaderType_VIDEO; + static constexpr HeaderType LOCATION = + Message_ButtonsMessage_HeaderType_LOCATION; + static inline bool HeaderType_IsValid(int value) { + return Message_ButtonsMessage_HeaderType_IsValid(value); + } + static constexpr HeaderType HeaderType_MIN = + Message_ButtonsMessage_HeaderType_HeaderType_MIN; + static constexpr HeaderType HeaderType_MAX = + Message_ButtonsMessage_HeaderType_HeaderType_MAX; + static constexpr int HeaderType_ARRAYSIZE = + Message_ButtonsMessage_HeaderType_HeaderType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + HeaderType_descriptor() { + return Message_ButtonsMessage_HeaderType_descriptor(); + } + template + static inline const std::string& HeaderType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function HeaderType_Name."); + return Message_ButtonsMessage_HeaderType_Name(enum_t_value); + } + static inline bool HeaderType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + HeaderType* value) { + return Message_ButtonsMessage_HeaderType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kButtonsFieldNumber = 9, + kContentTextFieldNumber = 6, + kFooterTextFieldNumber = 7, + kContextInfoFieldNumber = 8, + kHeaderTypeFieldNumber = 10, + kTextFieldNumber = 1, + kDocumentMessageFieldNumber = 2, + kImageMessageFieldNumber = 3, + kVideoMessageFieldNumber = 4, + kLocationMessageFieldNumber = 5, + }; + // repeated .proto.Message.ButtonsMessage.Button buttons = 9; + int buttons_size() const; + private: + int _internal_buttons_size() const; + public: + void clear_buttons(); + ::proto::Message_ButtonsMessage_Button* mutable_buttons(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ButtonsMessage_Button >* + mutable_buttons(); + private: + const ::proto::Message_ButtonsMessage_Button& _internal_buttons(int index) const; + ::proto::Message_ButtonsMessage_Button* _internal_add_buttons(); + public: + const ::proto::Message_ButtonsMessage_Button& buttons(int index) const; + ::proto::Message_ButtonsMessage_Button* add_buttons(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ButtonsMessage_Button >& + buttons() const; + + // optional string contentText = 6; + bool has_contenttext() const; + private: + bool _internal_has_contenttext() const; + public: + void clear_contenttext(); + const std::string& contenttext() const; + template + void set_contenttext(ArgT0&& arg0, ArgT... args); + std::string* mutable_contenttext(); + PROTOBUF_NODISCARD std::string* release_contenttext(); + void set_allocated_contenttext(std::string* contenttext); + private: + const std::string& _internal_contenttext() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_contenttext(const std::string& value); + std::string* _internal_mutable_contenttext(); + public: + + // optional string footerText = 7; + bool has_footertext() const; + private: + bool _internal_has_footertext() const; + public: + void clear_footertext(); + const std::string& footertext() const; + template + void set_footertext(ArgT0&& arg0, ArgT... args); + std::string* mutable_footertext(); + PROTOBUF_NODISCARD std::string* release_footertext(); + void set_allocated_footertext(std::string* footertext); + private: + const std::string& _internal_footertext() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_footertext(const std::string& value); + std::string* _internal_mutable_footertext(); + public: + + // optional .proto.ContextInfo contextInfo = 8; + bool has_contextinfo() const; + private: + bool _internal_has_contextinfo() const; + public: + void clear_contextinfo(); + const ::proto::ContextInfo& contextinfo() const; + PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); + ::proto::ContextInfo* mutable_contextinfo(); + void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); + private: + const ::proto::ContextInfo& _internal_contextinfo() const; + ::proto::ContextInfo* _internal_mutable_contextinfo(); + public: + void unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo); + ::proto::ContextInfo* unsafe_arena_release_contextinfo(); + + // optional .proto.Message.ButtonsMessage.HeaderType headerType = 10; + bool has_headertype() const; + private: + bool _internal_has_headertype() const; + public: + void clear_headertype(); + ::proto::Message_ButtonsMessage_HeaderType headertype() const; + void set_headertype(::proto::Message_ButtonsMessage_HeaderType value); + private: + ::proto::Message_ButtonsMessage_HeaderType _internal_headertype() const; + void _internal_set_headertype(::proto::Message_ButtonsMessage_HeaderType value); + public: + + // string text = 1; + bool has_text() const; + private: + bool _internal_has_text() const; + public: + void clear_text(); + const std::string& text() const; + template + void set_text(ArgT0&& arg0, ArgT... args); + std::string* mutable_text(); + PROTOBUF_NODISCARD std::string* release_text(); + void set_allocated_text(std::string* text); + private: + const std::string& _internal_text() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value); + std::string* _internal_mutable_text(); + public: + + // .proto.Message.DocumentMessage documentMessage = 2; + bool has_documentmessage() const; + private: + bool _internal_has_documentmessage() const; + public: + void clear_documentmessage(); + const ::proto::Message_DocumentMessage& documentmessage() const; + PROTOBUF_NODISCARD ::proto::Message_DocumentMessage* release_documentmessage(); + ::proto::Message_DocumentMessage* mutable_documentmessage(); + void set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage); + private: + const ::proto::Message_DocumentMessage& _internal_documentmessage() const; + ::proto::Message_DocumentMessage* _internal_mutable_documentmessage(); + public: + void unsafe_arena_set_allocated_documentmessage( + ::proto::Message_DocumentMessage* documentmessage); + ::proto::Message_DocumentMessage* unsafe_arena_release_documentmessage(); + + // .proto.Message.ImageMessage imageMessage = 3; + bool has_imagemessage() const; + private: + bool _internal_has_imagemessage() const; + public: + void clear_imagemessage(); + const ::proto::Message_ImageMessage& imagemessage() const; + PROTOBUF_NODISCARD ::proto::Message_ImageMessage* release_imagemessage(); + ::proto::Message_ImageMessage* mutable_imagemessage(); + void set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage); + private: + const ::proto::Message_ImageMessage& _internal_imagemessage() const; + ::proto::Message_ImageMessage* _internal_mutable_imagemessage(); + public: + void unsafe_arena_set_allocated_imagemessage( + ::proto::Message_ImageMessage* imagemessage); + ::proto::Message_ImageMessage* unsafe_arena_release_imagemessage(); + + // .proto.Message.VideoMessage videoMessage = 4; + bool has_videomessage() const; + private: + bool _internal_has_videomessage() const; + public: + void clear_videomessage(); + const ::proto::Message_VideoMessage& videomessage() const; + PROTOBUF_NODISCARD ::proto::Message_VideoMessage* release_videomessage(); + ::proto::Message_VideoMessage* mutable_videomessage(); + void set_allocated_videomessage(::proto::Message_VideoMessage* videomessage); + private: + const ::proto::Message_VideoMessage& _internal_videomessage() const; + ::proto::Message_VideoMessage* _internal_mutable_videomessage(); + public: + void unsafe_arena_set_allocated_videomessage( + ::proto::Message_VideoMessage* videomessage); + ::proto::Message_VideoMessage* unsafe_arena_release_videomessage(); + + // .proto.Message.LocationMessage locationMessage = 5; + bool has_locationmessage() const; + private: + bool _internal_has_locationmessage() const; + public: + void clear_locationmessage(); + const ::proto::Message_LocationMessage& locationmessage() const; + PROTOBUF_NODISCARD ::proto::Message_LocationMessage* release_locationmessage(); + ::proto::Message_LocationMessage* mutable_locationmessage(); + void set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage); + private: + const ::proto::Message_LocationMessage& _internal_locationmessage() const; + ::proto::Message_LocationMessage* _internal_mutable_locationmessage(); + public: + void unsafe_arena_set_allocated_locationmessage( + ::proto::Message_LocationMessage* locationmessage); + ::proto::Message_LocationMessage* unsafe_arena_release_locationmessage(); + + void clear_header(); + HeaderCase header_case() const; + // @@protoc_insertion_point(class_scope:proto.Message.ButtonsMessage) + private: + class _Internal; + void set_has_text(); + void set_has_documentmessage(); + void set_has_imagemessage(); + void set_has_videomessage(); + void set_has_locationmessage(); + + inline bool has_header() const; + inline void clear_has_header(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ButtonsMessage_Button > buttons_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr contenttext_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr footertext_; + ::proto::ContextInfo* contextinfo_; + int headertype_; + union HeaderUnion { + constexpr HeaderUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_; + ::proto::Message_DocumentMessage* documentmessage_; + ::proto::Message_ImageMessage* imagemessage_; + ::proto::Message_VideoMessage* videomessage_; + ::proto::Message_LocationMessage* locationmessage_; + } header_; + uint32_t _oneof_case_[1]; + + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_ButtonsResponseMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ButtonsResponseMessage) */ { + public: + inline Message_ButtonsResponseMessage() : Message_ButtonsResponseMessage(nullptr) {} + ~Message_ButtonsResponseMessage() override; + explicit PROTOBUF_CONSTEXPR Message_ButtonsResponseMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_ButtonsResponseMessage(const Message_ButtonsResponseMessage& from); + Message_ButtonsResponseMessage(Message_ButtonsResponseMessage&& from) noexcept + : Message_ButtonsResponseMessage() { + *this = ::std::move(from); + } + + inline Message_ButtonsResponseMessage& operator=(const Message_ButtonsResponseMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_ButtonsResponseMessage& operator=(Message_ButtonsResponseMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_ButtonsResponseMessage& default_instance() { + return *internal_default_instance(); + } + enum ResponseCase { + kSelectedDisplayText = 2, + RESPONSE_NOT_SET = 0, + }; + + static inline const Message_ButtonsResponseMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_ButtonsResponseMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 65; + + friend void swap(Message_ButtonsResponseMessage& a, Message_ButtonsResponseMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_ButtonsResponseMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_ButtonsResponseMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_ButtonsResponseMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_ButtonsResponseMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_ButtonsResponseMessage& from) { + Message_ButtonsResponseMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_ButtonsResponseMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.ButtonsResponseMessage"; + } + protected: + explicit Message_ButtonsResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Message_ButtonsResponseMessage_Type Type; + static constexpr Type UNKNOWN = + Message_ButtonsResponseMessage_Type_UNKNOWN; + static constexpr Type DISPLAY_TEXT = + Message_ButtonsResponseMessage_Type_DISPLAY_TEXT; + static inline bool Type_IsValid(int value) { + return Message_ButtonsResponseMessage_Type_IsValid(value); + } + static constexpr Type Type_MIN = + Message_ButtonsResponseMessage_Type_Type_MIN; + static constexpr Type Type_MAX = + Message_ButtonsResponseMessage_Type_Type_MAX; + static constexpr int Type_ARRAYSIZE = + Message_ButtonsResponseMessage_Type_Type_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + Type_descriptor() { + return Message_ButtonsResponseMessage_Type_descriptor(); + } + template + static inline const std::string& Type_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Type_Name."); + return Message_ButtonsResponseMessage_Type_Name(enum_t_value); + } + static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Type* value) { + return Message_ButtonsResponseMessage_Type_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kSelectedButtonIdFieldNumber = 1, + kContextInfoFieldNumber = 3, + kTypeFieldNumber = 4, + kSelectedDisplayTextFieldNumber = 2, + }; + // optional string selectedButtonId = 1; + bool has_selectedbuttonid() const; + private: + bool _internal_has_selectedbuttonid() const; + public: + void clear_selectedbuttonid(); + const std::string& selectedbuttonid() const; + template + void set_selectedbuttonid(ArgT0&& arg0, ArgT... args); + std::string* mutable_selectedbuttonid(); + PROTOBUF_NODISCARD std::string* release_selectedbuttonid(); + void set_allocated_selectedbuttonid(std::string* selectedbuttonid); + private: + const std::string& _internal_selectedbuttonid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_selectedbuttonid(const std::string& value); + std::string* _internal_mutable_selectedbuttonid(); + public: + + // optional .proto.ContextInfo contextInfo = 3; + bool has_contextinfo() const; + private: + bool _internal_has_contextinfo() const; + public: + void clear_contextinfo(); + const ::proto::ContextInfo& contextinfo() const; + PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); + ::proto::ContextInfo* mutable_contextinfo(); + void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); + private: + const ::proto::ContextInfo& _internal_contextinfo() const; + ::proto::ContextInfo* _internal_mutable_contextinfo(); + public: + void unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo); + ::proto::ContextInfo* unsafe_arena_release_contextinfo(); + + // optional .proto.Message.ButtonsResponseMessage.Type type = 4; + bool has_type() const; + private: + bool _internal_has_type() const; + public: + void clear_type(); + ::proto::Message_ButtonsResponseMessage_Type type() const; + void set_type(::proto::Message_ButtonsResponseMessage_Type value); + private: + ::proto::Message_ButtonsResponseMessage_Type _internal_type() const; + void _internal_set_type(::proto::Message_ButtonsResponseMessage_Type value); + public: + + // string selectedDisplayText = 2; + bool has_selecteddisplaytext() const; + private: + bool _internal_has_selecteddisplaytext() const; + public: + void clear_selecteddisplaytext(); + const std::string& selecteddisplaytext() const; + template + void set_selecteddisplaytext(ArgT0&& arg0, ArgT... args); + std::string* mutable_selecteddisplaytext(); + PROTOBUF_NODISCARD std::string* release_selecteddisplaytext(); + void set_allocated_selecteddisplaytext(std::string* selecteddisplaytext); + private: + const std::string& _internal_selecteddisplaytext() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_selecteddisplaytext(const std::string& value); + std::string* _internal_mutable_selecteddisplaytext(); + public: + + void clear_response(); + ResponseCase response_case() const; + // @@protoc_insertion_point(class_scope:proto.Message.ButtonsResponseMessage) + private: + class _Internal; + void set_has_selecteddisplaytext(); + + inline bool has_response() const; + inline void clear_has_response(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr selectedbuttonid_; + ::proto::ContextInfo* contextinfo_; + int type_; + union ResponseUnion { + constexpr ResponseUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr selecteddisplaytext_; + } response_; + uint32_t _oneof_case_[1]; + + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_Call final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.Call) */ { + public: + inline Message_Call() : Message_Call(nullptr) {} + ~Message_Call() override; + explicit PROTOBUF_CONSTEXPR Message_Call(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_Call(const Message_Call& from); + Message_Call(Message_Call&& from) noexcept + : Message_Call() { + *this = ::std::move(from); + } + + inline Message_Call& operator=(const Message_Call& from) { + CopyFrom(from); + return *this; + } + inline Message_Call& operator=(Message_Call&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_Call& default_instance() { + return *internal_default_instance(); + } + static inline const Message_Call* internal_default_instance() { + return reinterpret_cast( + &_Message_Call_default_instance_); + } + static constexpr int kIndexInFileMessages = + 66; + + friend void swap(Message_Call& a, Message_Call& b) { + a.Swap(&b); + } + inline void Swap(Message_Call* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_Call* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_Call* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_Call& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_Call& from) { + Message_Call::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_Call* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.Call"; + } + protected: + explicit Message_Call(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kCallKeyFieldNumber = 1, + kConversionSourceFieldNumber = 2, + kConversionDataFieldNumber = 3, + kConversionDelaySecondsFieldNumber = 4, + }; + // optional bytes callKey = 1; + bool has_callkey() const; + private: + bool _internal_has_callkey() const; + public: + void clear_callkey(); + const std::string& callkey() const; + template + void set_callkey(ArgT0&& arg0, ArgT... args); + std::string* mutable_callkey(); + PROTOBUF_NODISCARD std::string* release_callkey(); + void set_allocated_callkey(std::string* callkey); + private: + const std::string& _internal_callkey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_callkey(const std::string& value); + std::string* _internal_mutable_callkey(); + public: + + // optional string conversionSource = 2; + bool has_conversionsource() const; + private: + bool _internal_has_conversionsource() const; + public: + void clear_conversionsource(); + const std::string& conversionsource() const; + template + void set_conversionsource(ArgT0&& arg0, ArgT... args); + std::string* mutable_conversionsource(); + PROTOBUF_NODISCARD std::string* release_conversionsource(); + void set_allocated_conversionsource(std::string* conversionsource); + private: + const std::string& _internal_conversionsource() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_conversionsource(const std::string& value); + std::string* _internal_mutable_conversionsource(); + public: + + // optional bytes conversionData = 3; + bool has_conversiondata() const; + private: + bool _internal_has_conversiondata() const; + public: + void clear_conversiondata(); + const std::string& conversiondata() const; + template + void set_conversiondata(ArgT0&& arg0, ArgT... args); + std::string* mutable_conversiondata(); + PROTOBUF_NODISCARD std::string* release_conversiondata(); + void set_allocated_conversiondata(std::string* conversiondata); + private: + const std::string& _internal_conversiondata() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_conversiondata(const std::string& value); + std::string* _internal_mutable_conversiondata(); + public: + + // optional uint32 conversionDelaySeconds = 4; + bool has_conversiondelayseconds() const; + private: + bool _internal_has_conversiondelayseconds() const; + public: + void clear_conversiondelayseconds(); + uint32_t conversiondelayseconds() const; + void set_conversiondelayseconds(uint32_t value); + private: + uint32_t _internal_conversiondelayseconds() const; + void _internal_set_conversiondelayseconds(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.Call) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr callkey_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conversionsource_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conversiondata_; + uint32_t conversiondelayseconds_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_CancelPaymentRequestMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.CancelPaymentRequestMessage) */ { + public: + inline Message_CancelPaymentRequestMessage() : Message_CancelPaymentRequestMessage(nullptr) {} + ~Message_CancelPaymentRequestMessage() override; + explicit PROTOBUF_CONSTEXPR Message_CancelPaymentRequestMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_CancelPaymentRequestMessage(const Message_CancelPaymentRequestMessage& from); + Message_CancelPaymentRequestMessage(Message_CancelPaymentRequestMessage&& from) noexcept + : Message_CancelPaymentRequestMessage() { + *this = ::std::move(from); + } + + inline Message_CancelPaymentRequestMessage& operator=(const Message_CancelPaymentRequestMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_CancelPaymentRequestMessage& operator=(Message_CancelPaymentRequestMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_CancelPaymentRequestMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_CancelPaymentRequestMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_CancelPaymentRequestMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 67; + + friend void swap(Message_CancelPaymentRequestMessage& a, Message_CancelPaymentRequestMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_CancelPaymentRequestMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_CancelPaymentRequestMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_CancelPaymentRequestMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_CancelPaymentRequestMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_CancelPaymentRequestMessage& from) { + Message_CancelPaymentRequestMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_CancelPaymentRequestMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.CancelPaymentRequestMessage"; + } + protected: + explicit Message_CancelPaymentRequestMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kKeyFieldNumber = 1, + }; + // optional .proto.MessageKey key = 1; + bool has_key() const; + private: + bool _internal_has_key() const; + public: + void clear_key(); + const ::proto::MessageKey& key() const; + PROTOBUF_NODISCARD ::proto::MessageKey* release_key(); + ::proto::MessageKey* mutable_key(); + void set_allocated_key(::proto::MessageKey* key); + private: + const ::proto::MessageKey& _internal_key() const; + ::proto::MessageKey* _internal_mutable_key(); + public: + void unsafe_arena_set_allocated_key( + ::proto::MessageKey* key); + ::proto::MessageKey* unsafe_arena_release_key(); + + // @@protoc_insertion_point(class_scope:proto.Message.CancelPaymentRequestMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::proto::MessageKey* key_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_Chat final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.Chat) */ { + public: + inline Message_Chat() : Message_Chat(nullptr) {} + ~Message_Chat() override; + explicit PROTOBUF_CONSTEXPR Message_Chat(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_Chat(const Message_Chat& from); + Message_Chat(Message_Chat&& from) noexcept + : Message_Chat() { + *this = ::std::move(from); + } + + inline Message_Chat& operator=(const Message_Chat& from) { + CopyFrom(from); + return *this; + } + inline Message_Chat& operator=(Message_Chat&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_Chat& default_instance() { + return *internal_default_instance(); + } + static inline const Message_Chat* internal_default_instance() { + return reinterpret_cast( + &_Message_Chat_default_instance_); + } + static constexpr int kIndexInFileMessages = + 68; + + friend void swap(Message_Chat& a, Message_Chat& b) { + a.Swap(&b); + } + inline void Swap(Message_Chat* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_Chat* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_Chat* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_Chat& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_Chat& from) { + Message_Chat::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_Chat* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.Chat"; + } + protected: + explicit Message_Chat(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDisplayNameFieldNumber = 1, + kIdFieldNumber = 2, + }; + // optional string displayName = 1; + bool has_displayname() const; + private: + bool _internal_has_displayname() const; + public: + void clear_displayname(); + const std::string& displayname() const; + template + void set_displayname(ArgT0&& arg0, ArgT... args); + std::string* mutable_displayname(); + PROTOBUF_NODISCARD std::string* release_displayname(); + void set_allocated_displayname(std::string* displayname); + private: + const std::string& _internal_displayname() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_displayname(const std::string& value); + std::string* _internal_mutable_displayname(); + public: + + // optional string id = 2; + bool has_id() const; + private: + bool _internal_has_id() const; + public: + void clear_id(); + const std::string& id() const; + template + void set_id(ArgT0&& arg0, ArgT... args); + std::string* mutable_id(); + PROTOBUF_NODISCARD std::string* release_id(); + void set_allocated_id(std::string* id); + private: + const std::string& _internal_id() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value); + std::string* _internal_mutable_id(); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.Chat) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr displayname_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_ContactMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ContactMessage) */ { + public: + inline Message_ContactMessage() : Message_ContactMessage(nullptr) {} + ~Message_ContactMessage() override; + explicit PROTOBUF_CONSTEXPR Message_ContactMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_ContactMessage(const Message_ContactMessage& from); + Message_ContactMessage(Message_ContactMessage&& from) noexcept + : Message_ContactMessage() { + *this = ::std::move(from); + } + + inline Message_ContactMessage& operator=(const Message_ContactMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_ContactMessage& operator=(Message_ContactMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_ContactMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_ContactMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_ContactMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 69; + + friend void swap(Message_ContactMessage& a, Message_ContactMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_ContactMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_ContactMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_ContactMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_ContactMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_ContactMessage& from) { + Message_ContactMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_ContactMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.ContactMessage"; + } + protected: + explicit Message_ContactMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDisplayNameFieldNumber = 1, + kVcardFieldNumber = 16, + kContextInfoFieldNumber = 17, + }; + // optional string displayName = 1; + bool has_displayname() const; + private: + bool _internal_has_displayname() const; + public: + void clear_displayname(); + const std::string& displayname() const; + template + void set_displayname(ArgT0&& arg0, ArgT... args); + std::string* mutable_displayname(); + PROTOBUF_NODISCARD std::string* release_displayname(); + void set_allocated_displayname(std::string* displayname); + private: + const std::string& _internal_displayname() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_displayname(const std::string& value); + std::string* _internal_mutable_displayname(); + public: + + // optional string vcard = 16; + bool has_vcard() const; + private: + bool _internal_has_vcard() const; + public: + void clear_vcard(); + const std::string& vcard() const; + template + void set_vcard(ArgT0&& arg0, ArgT... args); + std::string* mutable_vcard(); + PROTOBUF_NODISCARD std::string* release_vcard(); + void set_allocated_vcard(std::string* vcard); + private: + const std::string& _internal_vcard() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_vcard(const std::string& value); + std::string* _internal_mutable_vcard(); + public: + + // optional .proto.ContextInfo contextInfo = 17; + bool has_contextinfo() const; + private: + bool _internal_has_contextinfo() const; + public: + void clear_contextinfo(); + const ::proto::ContextInfo& contextinfo() const; + PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); + ::proto::ContextInfo* mutable_contextinfo(); + void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); + private: + const ::proto::ContextInfo& _internal_contextinfo() const; + ::proto::ContextInfo* _internal_mutable_contextinfo(); + public: + void unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo); + ::proto::ContextInfo* unsafe_arena_release_contextinfo(); + + // @@protoc_insertion_point(class_scope:proto.Message.ContactMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr displayname_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr vcard_; + ::proto::ContextInfo* contextinfo_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_ContactsArrayMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ContactsArrayMessage) */ { + public: + inline Message_ContactsArrayMessage() : Message_ContactsArrayMessage(nullptr) {} + ~Message_ContactsArrayMessage() override; + explicit PROTOBUF_CONSTEXPR Message_ContactsArrayMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_ContactsArrayMessage(const Message_ContactsArrayMessage& from); + Message_ContactsArrayMessage(Message_ContactsArrayMessage&& from) noexcept + : Message_ContactsArrayMessage() { + *this = ::std::move(from); + } + + inline Message_ContactsArrayMessage& operator=(const Message_ContactsArrayMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_ContactsArrayMessage& operator=(Message_ContactsArrayMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_ContactsArrayMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_ContactsArrayMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_ContactsArrayMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 70; + + friend void swap(Message_ContactsArrayMessage& a, Message_ContactsArrayMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_ContactsArrayMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_ContactsArrayMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_ContactsArrayMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_ContactsArrayMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_ContactsArrayMessage& from) { + Message_ContactsArrayMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_ContactsArrayMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.ContactsArrayMessage"; + } + protected: + explicit Message_ContactsArrayMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kContactsFieldNumber = 2, + kDisplayNameFieldNumber = 1, + kContextInfoFieldNumber = 17, + }; + // repeated .proto.Message.ContactMessage contacts = 2; + int contacts_size() const; + private: + int _internal_contacts_size() const; + public: + void clear_contacts(); + ::proto::Message_ContactMessage* mutable_contacts(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ContactMessage >* + mutable_contacts(); + private: + const ::proto::Message_ContactMessage& _internal_contacts(int index) const; + ::proto::Message_ContactMessage* _internal_add_contacts(); + public: + const ::proto::Message_ContactMessage& contacts(int index) const; + ::proto::Message_ContactMessage* add_contacts(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ContactMessage >& + contacts() const; + + // optional string displayName = 1; + bool has_displayname() const; + private: + bool _internal_has_displayname() const; + public: + void clear_displayname(); + const std::string& displayname() const; + template + void set_displayname(ArgT0&& arg0, ArgT... args); + std::string* mutable_displayname(); + PROTOBUF_NODISCARD std::string* release_displayname(); + void set_allocated_displayname(std::string* displayname); + private: + const std::string& _internal_displayname() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_displayname(const std::string& value); + std::string* _internal_mutable_displayname(); + public: + + // optional .proto.ContextInfo contextInfo = 17; + bool has_contextinfo() const; + private: + bool _internal_has_contextinfo() const; + public: + void clear_contextinfo(); + const ::proto::ContextInfo& contextinfo() const; + PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); + ::proto::ContextInfo* mutable_contextinfo(); + void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); + private: + const ::proto::ContextInfo& _internal_contextinfo() const; + ::proto::ContextInfo* _internal_mutable_contextinfo(); + public: + void unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo); + ::proto::ContextInfo* unsafe_arena_release_contextinfo(); + + // @@protoc_insertion_point(class_scope:proto.Message.ContactsArrayMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ContactMessage > contacts_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr displayname_; + ::proto::ContextInfo* contextinfo_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_DeclinePaymentRequestMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.DeclinePaymentRequestMessage) */ { + public: + inline Message_DeclinePaymentRequestMessage() : Message_DeclinePaymentRequestMessage(nullptr) {} + ~Message_DeclinePaymentRequestMessage() override; + explicit PROTOBUF_CONSTEXPR Message_DeclinePaymentRequestMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_DeclinePaymentRequestMessage(const Message_DeclinePaymentRequestMessage& from); + Message_DeclinePaymentRequestMessage(Message_DeclinePaymentRequestMessage&& from) noexcept + : Message_DeclinePaymentRequestMessage() { + *this = ::std::move(from); + } + + inline Message_DeclinePaymentRequestMessage& operator=(const Message_DeclinePaymentRequestMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_DeclinePaymentRequestMessage& operator=(Message_DeclinePaymentRequestMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_DeclinePaymentRequestMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_DeclinePaymentRequestMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_DeclinePaymentRequestMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 71; + + friend void swap(Message_DeclinePaymentRequestMessage& a, Message_DeclinePaymentRequestMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_DeclinePaymentRequestMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_DeclinePaymentRequestMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_DeclinePaymentRequestMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_DeclinePaymentRequestMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_DeclinePaymentRequestMessage& from) { + Message_DeclinePaymentRequestMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_DeclinePaymentRequestMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.DeclinePaymentRequestMessage"; + } + protected: + explicit Message_DeclinePaymentRequestMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kKeyFieldNumber = 1, + }; + // optional .proto.MessageKey key = 1; + bool has_key() const; + private: + bool _internal_has_key() const; + public: + void clear_key(); + const ::proto::MessageKey& key() const; + PROTOBUF_NODISCARD ::proto::MessageKey* release_key(); + ::proto::MessageKey* mutable_key(); + void set_allocated_key(::proto::MessageKey* key); + private: + const ::proto::MessageKey& _internal_key() const; + ::proto::MessageKey* _internal_mutable_key(); + public: + void unsafe_arena_set_allocated_key( + ::proto::MessageKey* key); + ::proto::MessageKey* unsafe_arena_release_key(); + + // @@protoc_insertion_point(class_scope:proto.Message.DeclinePaymentRequestMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::proto::MessageKey* key_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_DeviceSentMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.DeviceSentMessage) */ { + public: + inline Message_DeviceSentMessage() : Message_DeviceSentMessage(nullptr) {} + ~Message_DeviceSentMessage() override; + explicit PROTOBUF_CONSTEXPR Message_DeviceSentMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_DeviceSentMessage(const Message_DeviceSentMessage& from); + Message_DeviceSentMessage(Message_DeviceSentMessage&& from) noexcept + : Message_DeviceSentMessage() { + *this = ::std::move(from); + } + + inline Message_DeviceSentMessage& operator=(const Message_DeviceSentMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_DeviceSentMessage& operator=(Message_DeviceSentMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_DeviceSentMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_DeviceSentMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_DeviceSentMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 72; + + friend void swap(Message_DeviceSentMessage& a, Message_DeviceSentMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_DeviceSentMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_DeviceSentMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_DeviceSentMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_DeviceSentMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_DeviceSentMessage& from) { + Message_DeviceSentMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_DeviceSentMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.DeviceSentMessage"; + } + protected: + explicit Message_DeviceSentMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDestinationJidFieldNumber = 1, + kPhashFieldNumber = 3, + kMessageFieldNumber = 2, + }; + // optional string destinationJid = 1; + bool has_destinationjid() const; + private: + bool _internal_has_destinationjid() const; + public: + void clear_destinationjid(); + const std::string& destinationjid() const; + template + void set_destinationjid(ArgT0&& arg0, ArgT... args); + std::string* mutable_destinationjid(); + PROTOBUF_NODISCARD std::string* release_destinationjid(); + void set_allocated_destinationjid(std::string* destinationjid); + private: + const std::string& _internal_destinationjid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_destinationjid(const std::string& value); + std::string* _internal_mutable_destinationjid(); + public: + + // optional string phash = 3; + bool has_phash() const; + private: + bool _internal_has_phash() const; + public: + void clear_phash(); + const std::string& phash() const; + template + void set_phash(ArgT0&& arg0, ArgT... args); + std::string* mutable_phash(); + PROTOBUF_NODISCARD std::string* release_phash(); + void set_allocated_phash(std::string* phash); + private: + const std::string& _internal_phash() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_phash(const std::string& value); + std::string* _internal_mutable_phash(); + public: + + // optional .proto.Message message = 2; + bool has_message() const; + private: + bool _internal_has_message() const; + public: + void clear_message(); + const ::proto::Message& message() const; + PROTOBUF_NODISCARD ::proto::Message* release_message(); + ::proto::Message* mutable_message(); + void set_allocated_message(::proto::Message* message); + private: + const ::proto::Message& _internal_message() const; + ::proto::Message* _internal_mutable_message(); + public: + void unsafe_arena_set_allocated_message( + ::proto::Message* message); + ::proto::Message* unsafe_arena_release_message(); + + // @@protoc_insertion_point(class_scope:proto.Message.DeviceSentMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr destinationjid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr phash_; + ::proto::Message* message_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_DocumentMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.DocumentMessage) */ { + public: + inline Message_DocumentMessage() : Message_DocumentMessage(nullptr) {} + ~Message_DocumentMessage() override; + explicit PROTOBUF_CONSTEXPR Message_DocumentMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_DocumentMessage(const Message_DocumentMessage& from); + Message_DocumentMessage(Message_DocumentMessage&& from) noexcept + : Message_DocumentMessage() { + *this = ::std::move(from); + } + + inline Message_DocumentMessage& operator=(const Message_DocumentMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_DocumentMessage& operator=(Message_DocumentMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_DocumentMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_DocumentMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_DocumentMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 73; + + friend void swap(Message_DocumentMessage& a, Message_DocumentMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_DocumentMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_DocumentMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_DocumentMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_DocumentMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_DocumentMessage& from) { + Message_DocumentMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_DocumentMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.DocumentMessage"; + } + protected: + explicit Message_DocumentMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kUrlFieldNumber = 1, + kMimetypeFieldNumber = 2, + kTitleFieldNumber = 3, + kFileSha256FieldNumber = 4, + kMediaKeyFieldNumber = 7, + kFileNameFieldNumber = 8, + kFileEncSha256FieldNumber = 9, + kDirectPathFieldNumber = 10, + kThumbnailDirectPathFieldNumber = 13, + kThumbnailSha256FieldNumber = 14, + kThumbnailEncSha256FieldNumber = 15, + kJpegThumbnailFieldNumber = 16, + kCaptionFieldNumber = 20, + kContextInfoFieldNumber = 17, + kFileLengthFieldNumber = 5, + kPageCountFieldNumber = 6, + kContactVcardFieldNumber = 12, + kMediaKeyTimestampFieldNumber = 11, + kThumbnailHeightFieldNumber = 18, + kThumbnailWidthFieldNumber = 19, + }; + // optional string url = 1; + bool has_url() const; + private: + bool _internal_has_url() const; + public: + void clear_url(); + const std::string& url() const; + template + void set_url(ArgT0&& arg0, ArgT... args); + std::string* mutable_url(); + PROTOBUF_NODISCARD std::string* release_url(); + void set_allocated_url(std::string* url); + private: + const std::string& _internal_url() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value); + std::string* _internal_mutable_url(); + public: + + // optional string mimetype = 2; + bool has_mimetype() const; + private: + bool _internal_has_mimetype() const; + public: + void clear_mimetype(); + const std::string& mimetype() const; + template + void set_mimetype(ArgT0&& arg0, ArgT... args); + std::string* mutable_mimetype(); + PROTOBUF_NODISCARD std::string* release_mimetype(); + void set_allocated_mimetype(std::string* mimetype); + private: + const std::string& _internal_mimetype() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value); + std::string* _internal_mutable_mimetype(); + public: + + // optional string title = 3; + bool has_title() const; + private: + bool _internal_has_title() const; + public: + void clear_title(); + const std::string& title() const; + template + void set_title(ArgT0&& arg0, ArgT... args); + std::string* mutable_title(); + PROTOBUF_NODISCARD std::string* release_title(); + void set_allocated_title(std::string* title); + private: + const std::string& _internal_title() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value); + std::string* _internal_mutable_title(); + public: + + // optional bytes fileSha256 = 4; + bool has_filesha256() const; + private: + bool _internal_has_filesha256() const; + public: + void clear_filesha256(); + const std::string& filesha256() const; + template + void set_filesha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_filesha256(); + PROTOBUF_NODISCARD std::string* release_filesha256(); + void set_allocated_filesha256(std::string* filesha256); + private: + const std::string& _internal_filesha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value); + std::string* _internal_mutable_filesha256(); + public: + + // optional bytes mediaKey = 7; + bool has_mediakey() const; + private: + bool _internal_has_mediakey() const; + public: + void clear_mediakey(); + const std::string& mediakey() const; + template + void set_mediakey(ArgT0&& arg0, ArgT... args); + std::string* mutable_mediakey(); + PROTOBUF_NODISCARD std::string* release_mediakey(); + void set_allocated_mediakey(std::string* mediakey); + private: + const std::string& _internal_mediakey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value); + std::string* _internal_mutable_mediakey(); + public: + + // optional string fileName = 8; + bool has_filename() const; + private: + bool _internal_has_filename() const; + public: + void clear_filename(); + const std::string& filename() const; + template + void set_filename(ArgT0&& arg0, ArgT... args); + std::string* mutable_filename(); + PROTOBUF_NODISCARD std::string* release_filename(); + void set_allocated_filename(std::string* filename); + private: + const std::string& _internal_filename() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_filename(const std::string& value); + std::string* _internal_mutable_filename(); + public: + + // optional bytes fileEncSha256 = 9; + bool has_fileencsha256() const; + private: + bool _internal_has_fileencsha256() const; + public: + void clear_fileencsha256(); + const std::string& fileencsha256() const; + template + void set_fileencsha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_fileencsha256(); + PROTOBUF_NODISCARD std::string* release_fileencsha256(); + void set_allocated_fileencsha256(std::string* fileencsha256); + private: + const std::string& _internal_fileencsha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value); + std::string* _internal_mutable_fileencsha256(); + public: + + // optional string directPath = 10; + bool has_directpath() const; + private: + bool _internal_has_directpath() const; + public: + void clear_directpath(); + const std::string& directpath() const; + template + void set_directpath(ArgT0&& arg0, ArgT... args); + std::string* mutable_directpath(); + PROTOBUF_NODISCARD std::string* release_directpath(); + void set_allocated_directpath(std::string* directpath); + private: + const std::string& _internal_directpath() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value); + std::string* _internal_mutable_directpath(); + public: + + // optional string thumbnailDirectPath = 13; + bool has_thumbnaildirectpath() const; + private: + bool _internal_has_thumbnaildirectpath() const; + public: + void clear_thumbnaildirectpath(); + const std::string& thumbnaildirectpath() const; + template + void set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args); + std::string* mutable_thumbnaildirectpath(); + PROTOBUF_NODISCARD std::string* release_thumbnaildirectpath(); + void set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath); + private: + const std::string& _internal_thumbnaildirectpath() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnaildirectpath(const std::string& value); + std::string* _internal_mutable_thumbnaildirectpath(); + public: + + // optional bytes thumbnailSha256 = 14; + bool has_thumbnailsha256() const; + private: + bool _internal_has_thumbnailsha256() const; + public: + void clear_thumbnailsha256(); + const std::string& thumbnailsha256() const; + template + void set_thumbnailsha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_thumbnailsha256(); + PROTOBUF_NODISCARD std::string* release_thumbnailsha256(); + void set_allocated_thumbnailsha256(std::string* thumbnailsha256); + private: + const std::string& _internal_thumbnailsha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailsha256(const std::string& value); + std::string* _internal_mutable_thumbnailsha256(); + public: + + // optional bytes thumbnailEncSha256 = 15; + bool has_thumbnailencsha256() const; + private: + bool _internal_has_thumbnailencsha256() const; + public: + void clear_thumbnailencsha256(); + const std::string& thumbnailencsha256() const; + template + void set_thumbnailencsha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_thumbnailencsha256(); + PROTOBUF_NODISCARD std::string* release_thumbnailencsha256(); + void set_allocated_thumbnailencsha256(std::string* thumbnailencsha256); + private: + const std::string& _internal_thumbnailencsha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailencsha256(const std::string& value); + std::string* _internal_mutable_thumbnailencsha256(); + public: + + // optional bytes jpegThumbnail = 16; + bool has_jpegthumbnail() const; + private: + bool _internal_has_jpegthumbnail() const; + public: + void clear_jpegthumbnail(); + const std::string& jpegthumbnail() const; + template + void set_jpegthumbnail(ArgT0&& arg0, ArgT... args); + std::string* mutable_jpegthumbnail(); + PROTOBUF_NODISCARD std::string* release_jpegthumbnail(); + void set_allocated_jpegthumbnail(std::string* jpegthumbnail); + private: + const std::string& _internal_jpegthumbnail() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value); + std::string* _internal_mutable_jpegthumbnail(); + public: + + // optional string caption = 20; + bool has_caption() const; + private: + bool _internal_has_caption() const; + public: + void clear_caption(); + const std::string& caption() const; + template + void set_caption(ArgT0&& arg0, ArgT... args); + std::string* mutable_caption(); + PROTOBUF_NODISCARD std::string* release_caption(); + void set_allocated_caption(std::string* caption); + private: + const std::string& _internal_caption() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_caption(const std::string& value); + std::string* _internal_mutable_caption(); + public: + + // optional .proto.ContextInfo contextInfo = 17; + bool has_contextinfo() const; + private: + bool _internal_has_contextinfo() const; + public: + void clear_contextinfo(); + const ::proto::ContextInfo& contextinfo() const; + PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); + ::proto::ContextInfo* mutable_contextinfo(); + void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); + private: + const ::proto::ContextInfo& _internal_contextinfo() const; + ::proto::ContextInfo* _internal_mutable_contextinfo(); + public: + void unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo); + ::proto::ContextInfo* unsafe_arena_release_contextinfo(); + + // optional uint64 fileLength = 5; + bool has_filelength() const; + private: + bool _internal_has_filelength() const; + public: + void clear_filelength(); + uint64_t filelength() const; + void set_filelength(uint64_t value); + private: + uint64_t _internal_filelength() const; + void _internal_set_filelength(uint64_t value); + public: + + // optional uint32 pageCount = 6; + bool has_pagecount() const; + private: + bool _internal_has_pagecount() const; + public: + void clear_pagecount(); + uint32_t pagecount() const; + void set_pagecount(uint32_t value); + private: + uint32_t _internal_pagecount() const; + void _internal_set_pagecount(uint32_t value); + public: + + // optional bool contactVcard = 12; + bool has_contactvcard() const; + private: + bool _internal_has_contactvcard() const; + public: + void clear_contactvcard(); + bool contactvcard() const; + void set_contactvcard(bool value); + private: + bool _internal_contactvcard() const; + void _internal_set_contactvcard(bool value); + public: + + // optional int64 mediaKeyTimestamp = 11; + bool has_mediakeytimestamp() const; + private: + bool _internal_has_mediakeytimestamp() const; + public: + void clear_mediakeytimestamp(); + int64_t mediakeytimestamp() const; + void set_mediakeytimestamp(int64_t value); + private: + int64_t _internal_mediakeytimestamp() const; + void _internal_set_mediakeytimestamp(int64_t value); + public: + + // optional uint32 thumbnailHeight = 18; + bool has_thumbnailheight() const; + private: + bool _internal_has_thumbnailheight() const; + public: + void clear_thumbnailheight(); + uint32_t thumbnailheight() const; + void set_thumbnailheight(uint32_t value); + private: + uint32_t _internal_thumbnailheight() const; + void _internal_set_thumbnailheight(uint32_t value); + public: + + // optional uint32 thumbnailWidth = 19; + bool has_thumbnailwidth() const; + private: + bool _internal_has_thumbnailwidth() const; + public: + void clear_thumbnailwidth(); + uint32_t thumbnailwidth() const; + void set_thumbnailwidth(uint32_t value); + private: + uint32_t _internal_thumbnailwidth() const; + void _internal_set_thumbnailwidth(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.DocumentMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mimetype_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filename_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnaildirectpath_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailsha256_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailencsha256_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr caption_; + ::proto::ContextInfo* contextinfo_; + uint64_t filelength_; + uint32_t pagecount_; + bool contactvcard_; + int64_t mediakeytimestamp_; + uint32_t thumbnailheight_; + uint32_t thumbnailwidth_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_ExtendedTextMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ExtendedTextMessage) */ { + public: + inline Message_ExtendedTextMessage() : Message_ExtendedTextMessage(nullptr) {} + ~Message_ExtendedTextMessage() override; + explicit PROTOBUF_CONSTEXPR Message_ExtendedTextMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_ExtendedTextMessage(const Message_ExtendedTextMessage& from); + Message_ExtendedTextMessage(Message_ExtendedTextMessage&& from) noexcept + : Message_ExtendedTextMessage() { + *this = ::std::move(from); + } + + inline Message_ExtendedTextMessage& operator=(const Message_ExtendedTextMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_ExtendedTextMessage& operator=(Message_ExtendedTextMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_ExtendedTextMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_ExtendedTextMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_ExtendedTextMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 74; + + friend void swap(Message_ExtendedTextMessage& a, Message_ExtendedTextMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_ExtendedTextMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_ExtendedTextMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_ExtendedTextMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_ExtendedTextMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_ExtendedTextMessage& from) { + Message_ExtendedTextMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_ExtendedTextMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.ExtendedTextMessage"; + } + protected: + explicit Message_ExtendedTextMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Message_ExtendedTextMessage_FontType FontType; + static constexpr FontType SANS_SERIF = + Message_ExtendedTextMessage_FontType_SANS_SERIF; + static constexpr FontType SERIF = + Message_ExtendedTextMessage_FontType_SERIF; + static constexpr FontType NORICAN_REGULAR = + Message_ExtendedTextMessage_FontType_NORICAN_REGULAR; + static constexpr FontType BRYNDAN_WRITE = + Message_ExtendedTextMessage_FontType_BRYNDAN_WRITE; + static constexpr FontType BEBASNEUE_REGULAR = + Message_ExtendedTextMessage_FontType_BEBASNEUE_REGULAR; + static constexpr FontType OSWALD_HEAVY = + Message_ExtendedTextMessage_FontType_OSWALD_HEAVY; + static inline bool FontType_IsValid(int value) { + return Message_ExtendedTextMessage_FontType_IsValid(value); + } + static constexpr FontType FontType_MIN = + Message_ExtendedTextMessage_FontType_FontType_MIN; + static constexpr FontType FontType_MAX = + Message_ExtendedTextMessage_FontType_FontType_MAX; + static constexpr int FontType_ARRAYSIZE = + Message_ExtendedTextMessage_FontType_FontType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + FontType_descriptor() { + return Message_ExtendedTextMessage_FontType_descriptor(); + } + template + static inline const std::string& FontType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function FontType_Name."); + return Message_ExtendedTextMessage_FontType_Name(enum_t_value); + } + static inline bool FontType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + FontType* value) { + return Message_ExtendedTextMessage_FontType_Parse(name, value); + } + + typedef Message_ExtendedTextMessage_InviteLinkGroupType InviteLinkGroupType; + static constexpr InviteLinkGroupType DEFAULT = + Message_ExtendedTextMessage_InviteLinkGroupType_DEFAULT; + static constexpr InviteLinkGroupType PARENT = + Message_ExtendedTextMessage_InviteLinkGroupType_PARENT; + static constexpr InviteLinkGroupType SUB = + Message_ExtendedTextMessage_InviteLinkGroupType_SUB; + static constexpr InviteLinkGroupType DEFAULT_SUB = + Message_ExtendedTextMessage_InviteLinkGroupType_DEFAULT_SUB; + static inline bool InviteLinkGroupType_IsValid(int value) { + return Message_ExtendedTextMessage_InviteLinkGroupType_IsValid(value); + } + static constexpr InviteLinkGroupType InviteLinkGroupType_MIN = + Message_ExtendedTextMessage_InviteLinkGroupType_InviteLinkGroupType_MIN; + static constexpr InviteLinkGroupType InviteLinkGroupType_MAX = + Message_ExtendedTextMessage_InviteLinkGroupType_InviteLinkGroupType_MAX; + static constexpr int InviteLinkGroupType_ARRAYSIZE = + Message_ExtendedTextMessage_InviteLinkGroupType_InviteLinkGroupType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + InviteLinkGroupType_descriptor() { + return Message_ExtendedTextMessage_InviteLinkGroupType_descriptor(); + } + template + static inline const std::string& InviteLinkGroupType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function InviteLinkGroupType_Name."); + return Message_ExtendedTextMessage_InviteLinkGroupType_Name(enum_t_value); + } + static inline bool InviteLinkGroupType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + InviteLinkGroupType* value) { + return Message_ExtendedTextMessage_InviteLinkGroupType_Parse(name, value); + } + + typedef Message_ExtendedTextMessage_PreviewType PreviewType; + static constexpr PreviewType NONE = + Message_ExtendedTextMessage_PreviewType_NONE; + static constexpr PreviewType VIDEO = + Message_ExtendedTextMessage_PreviewType_VIDEO; + static inline bool PreviewType_IsValid(int value) { + return Message_ExtendedTextMessage_PreviewType_IsValid(value); + } + static constexpr PreviewType PreviewType_MIN = + Message_ExtendedTextMessage_PreviewType_PreviewType_MIN; + static constexpr PreviewType PreviewType_MAX = + Message_ExtendedTextMessage_PreviewType_PreviewType_MAX; + static constexpr int PreviewType_ARRAYSIZE = + Message_ExtendedTextMessage_PreviewType_PreviewType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + PreviewType_descriptor() { + return Message_ExtendedTextMessage_PreviewType_descriptor(); + } + template + static inline const std::string& PreviewType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function PreviewType_Name."); + return Message_ExtendedTextMessage_PreviewType_Name(enum_t_value); + } + static inline bool PreviewType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + PreviewType* value) { + return Message_ExtendedTextMessage_PreviewType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kTextFieldNumber = 1, + kMatchedTextFieldNumber = 2, + kCanonicalUrlFieldNumber = 4, + kDescriptionFieldNumber = 5, + kTitleFieldNumber = 6, + kJpegThumbnailFieldNumber = 16, + kThumbnailDirectPathFieldNumber = 19, + kThumbnailSha256FieldNumber = 20, + kThumbnailEncSha256FieldNumber = 21, + kMediaKeyFieldNumber = 22, + kInviteLinkParentGroupSubjectV2FieldNumber = 27, + kInviteLinkParentGroupThumbnailV2FieldNumber = 28, + kContextInfoFieldNumber = 17, + kTextArgbFieldNumber = 7, + kBackgroundArgbFieldNumber = 8, + kFontFieldNumber = 9, + kPreviewTypeFieldNumber = 10, + kDoNotPlayInlineFieldNumber = 18, + kThumbnailHeightFieldNumber = 24, + kMediaKeyTimestampFieldNumber = 23, + kThumbnailWidthFieldNumber = 25, + kInviteLinkGroupTypeFieldNumber = 26, + kInviteLinkGroupTypeV2FieldNumber = 29, + }; + // optional string text = 1; + bool has_text() const; + private: + bool _internal_has_text() const; + public: + void clear_text(); + const std::string& text() const; + template + void set_text(ArgT0&& arg0, ArgT... args); + std::string* mutable_text(); + PROTOBUF_NODISCARD std::string* release_text(); + void set_allocated_text(std::string* text); + private: + const std::string& _internal_text() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value); + std::string* _internal_mutable_text(); + public: + + // optional string matchedText = 2; + bool has_matchedtext() const; + private: + bool _internal_has_matchedtext() const; + public: + void clear_matchedtext(); + const std::string& matchedtext() const; + template + void set_matchedtext(ArgT0&& arg0, ArgT... args); + std::string* mutable_matchedtext(); + PROTOBUF_NODISCARD std::string* release_matchedtext(); + void set_allocated_matchedtext(std::string* matchedtext); + private: + const std::string& _internal_matchedtext() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_matchedtext(const std::string& value); + std::string* _internal_mutable_matchedtext(); + public: + + // optional string canonicalUrl = 4; + bool has_canonicalurl() const; + private: + bool _internal_has_canonicalurl() const; + public: + void clear_canonicalurl(); + const std::string& canonicalurl() const; + template + void set_canonicalurl(ArgT0&& arg0, ArgT... args); + std::string* mutable_canonicalurl(); + PROTOBUF_NODISCARD std::string* release_canonicalurl(); + void set_allocated_canonicalurl(std::string* canonicalurl); + private: + const std::string& _internal_canonicalurl() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_canonicalurl(const std::string& value); + std::string* _internal_mutable_canonicalurl(); + public: + + // optional string description = 5; + bool has_description() const; + private: + bool _internal_has_description() const; + public: + void clear_description(); + const std::string& description() const; + template + void set_description(ArgT0&& arg0, ArgT... args); + std::string* mutable_description(); + PROTOBUF_NODISCARD std::string* release_description(); + void set_allocated_description(std::string* description); + private: + const std::string& _internal_description() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value); + std::string* _internal_mutable_description(); + public: + + // optional string title = 6; + bool has_title() const; + private: + bool _internal_has_title() const; + public: + void clear_title(); + const std::string& title() const; + template + void set_title(ArgT0&& arg0, ArgT... args); + std::string* mutable_title(); + PROTOBUF_NODISCARD std::string* release_title(); + void set_allocated_title(std::string* title); + private: + const std::string& _internal_title() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value); + std::string* _internal_mutable_title(); + public: + + // optional bytes jpegThumbnail = 16; + bool has_jpegthumbnail() const; + private: + bool _internal_has_jpegthumbnail() const; + public: + void clear_jpegthumbnail(); + const std::string& jpegthumbnail() const; + template + void set_jpegthumbnail(ArgT0&& arg0, ArgT... args); + std::string* mutable_jpegthumbnail(); + PROTOBUF_NODISCARD std::string* release_jpegthumbnail(); + void set_allocated_jpegthumbnail(std::string* jpegthumbnail); + private: + const std::string& _internal_jpegthumbnail() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value); + std::string* _internal_mutable_jpegthumbnail(); + public: + + // optional string thumbnailDirectPath = 19; + bool has_thumbnaildirectpath() const; + private: + bool _internal_has_thumbnaildirectpath() const; + public: + void clear_thumbnaildirectpath(); + const std::string& thumbnaildirectpath() const; + template + void set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args); + std::string* mutable_thumbnaildirectpath(); + PROTOBUF_NODISCARD std::string* release_thumbnaildirectpath(); + void set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath); + private: + const std::string& _internal_thumbnaildirectpath() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnaildirectpath(const std::string& value); + std::string* _internal_mutable_thumbnaildirectpath(); + public: + + // optional bytes thumbnailSha256 = 20; + bool has_thumbnailsha256() const; + private: + bool _internal_has_thumbnailsha256() const; + public: + void clear_thumbnailsha256(); + const std::string& thumbnailsha256() const; + template + void set_thumbnailsha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_thumbnailsha256(); + PROTOBUF_NODISCARD std::string* release_thumbnailsha256(); + void set_allocated_thumbnailsha256(std::string* thumbnailsha256); + private: + const std::string& _internal_thumbnailsha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailsha256(const std::string& value); + std::string* _internal_mutable_thumbnailsha256(); + public: + + // optional bytes thumbnailEncSha256 = 21; + bool has_thumbnailencsha256() const; + private: + bool _internal_has_thumbnailencsha256() const; + public: + void clear_thumbnailencsha256(); + const std::string& thumbnailencsha256() const; + template + void set_thumbnailencsha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_thumbnailencsha256(); + PROTOBUF_NODISCARD std::string* release_thumbnailencsha256(); + void set_allocated_thumbnailencsha256(std::string* thumbnailencsha256); + private: + const std::string& _internal_thumbnailencsha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailencsha256(const std::string& value); + std::string* _internal_mutable_thumbnailencsha256(); + public: + + // optional bytes mediaKey = 22; + bool has_mediakey() const; + private: + bool _internal_has_mediakey() const; + public: + void clear_mediakey(); + const std::string& mediakey() const; + template + void set_mediakey(ArgT0&& arg0, ArgT... args); + std::string* mutable_mediakey(); + PROTOBUF_NODISCARD std::string* release_mediakey(); + void set_allocated_mediakey(std::string* mediakey); + private: + const std::string& _internal_mediakey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value); + std::string* _internal_mutable_mediakey(); + public: + + // optional string inviteLinkParentGroupSubjectV2 = 27; + bool has_invitelinkparentgroupsubjectv2() const; + private: + bool _internal_has_invitelinkparentgroupsubjectv2() const; + public: + void clear_invitelinkparentgroupsubjectv2(); + const std::string& invitelinkparentgroupsubjectv2() const; + template + void set_invitelinkparentgroupsubjectv2(ArgT0&& arg0, ArgT... args); + std::string* mutable_invitelinkparentgroupsubjectv2(); + PROTOBUF_NODISCARD std::string* release_invitelinkparentgroupsubjectv2(); + void set_allocated_invitelinkparentgroupsubjectv2(std::string* invitelinkparentgroupsubjectv2); + private: + const std::string& _internal_invitelinkparentgroupsubjectv2() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_invitelinkparentgroupsubjectv2(const std::string& value); + std::string* _internal_mutable_invitelinkparentgroupsubjectv2(); + public: + + // optional bytes inviteLinkParentGroupThumbnailV2 = 28; + bool has_invitelinkparentgroupthumbnailv2() const; + private: + bool _internal_has_invitelinkparentgroupthumbnailv2() const; + public: + void clear_invitelinkparentgroupthumbnailv2(); + const std::string& invitelinkparentgroupthumbnailv2() const; + template + void set_invitelinkparentgroupthumbnailv2(ArgT0&& arg0, ArgT... args); + std::string* mutable_invitelinkparentgroupthumbnailv2(); + PROTOBUF_NODISCARD std::string* release_invitelinkparentgroupthumbnailv2(); + void set_allocated_invitelinkparentgroupthumbnailv2(std::string* invitelinkparentgroupthumbnailv2); + private: + const std::string& _internal_invitelinkparentgroupthumbnailv2() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_invitelinkparentgroupthumbnailv2(const std::string& value); + std::string* _internal_mutable_invitelinkparentgroupthumbnailv2(); + public: + + // optional .proto.ContextInfo contextInfo = 17; + bool has_contextinfo() const; + private: + bool _internal_has_contextinfo() const; + public: + void clear_contextinfo(); + const ::proto::ContextInfo& contextinfo() const; + PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); + ::proto::ContextInfo* mutable_contextinfo(); + void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); + private: + const ::proto::ContextInfo& _internal_contextinfo() const; + ::proto::ContextInfo* _internal_mutable_contextinfo(); + public: + void unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo); + ::proto::ContextInfo* unsafe_arena_release_contextinfo(); + + // optional fixed32 textArgb = 7; + bool has_textargb() const; + private: + bool _internal_has_textargb() const; + public: + void clear_textargb(); + uint32_t textargb() const; + void set_textargb(uint32_t value); + private: + uint32_t _internal_textargb() const; + void _internal_set_textargb(uint32_t value); + public: + + // optional fixed32 backgroundArgb = 8; + bool has_backgroundargb() const; + private: + bool _internal_has_backgroundargb() const; + public: + void clear_backgroundargb(); + uint32_t backgroundargb() const; + void set_backgroundargb(uint32_t value); + private: + uint32_t _internal_backgroundargb() const; + void _internal_set_backgroundargb(uint32_t value); + public: + + // optional .proto.Message.ExtendedTextMessage.FontType font = 9; + bool has_font() const; + private: + bool _internal_has_font() const; + public: + void clear_font(); + ::proto::Message_ExtendedTextMessage_FontType font() const; + void set_font(::proto::Message_ExtendedTextMessage_FontType value); + private: + ::proto::Message_ExtendedTextMessage_FontType _internal_font() const; + void _internal_set_font(::proto::Message_ExtendedTextMessage_FontType value); + public: + + // optional .proto.Message.ExtendedTextMessage.PreviewType previewType = 10; + bool has_previewtype() const; + private: + bool _internal_has_previewtype() const; + public: + void clear_previewtype(); + ::proto::Message_ExtendedTextMessage_PreviewType previewtype() const; + void set_previewtype(::proto::Message_ExtendedTextMessage_PreviewType value); + private: + ::proto::Message_ExtendedTextMessage_PreviewType _internal_previewtype() const; + void _internal_set_previewtype(::proto::Message_ExtendedTextMessage_PreviewType value); + public: + + // optional bool doNotPlayInline = 18; + bool has_donotplayinline() const; + private: + bool _internal_has_donotplayinline() const; + public: + void clear_donotplayinline(); + bool donotplayinline() const; + void set_donotplayinline(bool value); + private: + bool _internal_donotplayinline() const; + void _internal_set_donotplayinline(bool value); + public: + + // optional uint32 thumbnailHeight = 24; + bool has_thumbnailheight() const; + private: + bool _internal_has_thumbnailheight() const; + public: + void clear_thumbnailheight(); + uint32_t thumbnailheight() const; + void set_thumbnailheight(uint32_t value); + private: + uint32_t _internal_thumbnailheight() const; + void _internal_set_thumbnailheight(uint32_t value); + public: + + // optional int64 mediaKeyTimestamp = 23; + bool has_mediakeytimestamp() const; + private: + bool _internal_has_mediakeytimestamp() const; + public: + void clear_mediakeytimestamp(); + int64_t mediakeytimestamp() const; + void set_mediakeytimestamp(int64_t value); + private: + int64_t _internal_mediakeytimestamp() const; + void _internal_set_mediakeytimestamp(int64_t value); + public: + + // optional uint32 thumbnailWidth = 25; + bool has_thumbnailwidth() const; + private: + bool _internal_has_thumbnailwidth() const; + public: + void clear_thumbnailwidth(); + uint32_t thumbnailwidth() const; + void set_thumbnailwidth(uint32_t value); + private: + uint32_t _internal_thumbnailwidth() const; + void _internal_set_thumbnailwidth(uint32_t value); + public: + + // optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupType = 26; + bool has_invitelinkgrouptype() const; + private: + bool _internal_has_invitelinkgrouptype() const; + public: + void clear_invitelinkgrouptype(); + ::proto::Message_ExtendedTextMessage_InviteLinkGroupType invitelinkgrouptype() const; + void set_invitelinkgrouptype(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value); + private: + ::proto::Message_ExtendedTextMessage_InviteLinkGroupType _internal_invitelinkgrouptype() const; + void _internal_set_invitelinkgrouptype(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value); + public: + + // optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupTypeV2 = 29; + bool has_invitelinkgrouptypev2() const; + private: + bool _internal_has_invitelinkgrouptypev2() const; + public: + void clear_invitelinkgrouptypev2(); + ::proto::Message_ExtendedTextMessage_InviteLinkGroupType invitelinkgrouptypev2() const; + void set_invitelinkgrouptypev2(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value); + private: + ::proto::Message_ExtendedTextMessage_InviteLinkGroupType _internal_invitelinkgrouptypev2() const; + void _internal_set_invitelinkgrouptypev2(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.ExtendedTextMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr matchedtext_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr canonicalurl_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnaildirectpath_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailsha256_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailencsha256_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr invitelinkparentgroupsubjectv2_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr invitelinkparentgroupthumbnailv2_; + ::proto::ContextInfo* contextinfo_; + uint32_t textargb_; + uint32_t backgroundargb_; + int font_; + int previewtype_; + bool donotplayinline_; + uint32_t thumbnailheight_; + int64_t mediakeytimestamp_; + uint32_t thumbnailwidth_; + int invitelinkgrouptype_; + int invitelinkgrouptypev2_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_FutureProofMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.FutureProofMessage) */ { + public: + inline Message_FutureProofMessage() : Message_FutureProofMessage(nullptr) {} + ~Message_FutureProofMessage() override; + explicit PROTOBUF_CONSTEXPR Message_FutureProofMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_FutureProofMessage(const Message_FutureProofMessage& from); + Message_FutureProofMessage(Message_FutureProofMessage&& from) noexcept + : Message_FutureProofMessage() { + *this = ::std::move(from); + } + + inline Message_FutureProofMessage& operator=(const Message_FutureProofMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_FutureProofMessage& operator=(Message_FutureProofMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_FutureProofMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_FutureProofMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_FutureProofMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 75; + + friend void swap(Message_FutureProofMessage& a, Message_FutureProofMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_FutureProofMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_FutureProofMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_FutureProofMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_FutureProofMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_FutureProofMessage& from) { + Message_FutureProofMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_FutureProofMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.FutureProofMessage"; + } + protected: + explicit Message_FutureProofMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMessageFieldNumber = 1, + }; + // optional .proto.Message message = 1; + bool has_message() const; + private: + bool _internal_has_message() const; + public: + void clear_message(); + const ::proto::Message& message() const; + PROTOBUF_NODISCARD ::proto::Message* release_message(); + ::proto::Message* mutable_message(); + void set_allocated_message(::proto::Message* message); + private: + const ::proto::Message& _internal_message() const; + ::proto::Message* _internal_mutable_message(); + public: + void unsafe_arena_set_allocated_message( + ::proto::Message* message); + ::proto::Message* unsafe_arena_release_message(); + + // @@protoc_insertion_point(class_scope:proto.Message.FutureProofMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::proto::Message* message_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_GroupInviteMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.GroupInviteMessage) */ { + public: + inline Message_GroupInviteMessage() : Message_GroupInviteMessage(nullptr) {} + ~Message_GroupInviteMessage() override; + explicit PROTOBUF_CONSTEXPR Message_GroupInviteMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_GroupInviteMessage(const Message_GroupInviteMessage& from); + Message_GroupInviteMessage(Message_GroupInviteMessage&& from) noexcept + : Message_GroupInviteMessage() { + *this = ::std::move(from); + } + + inline Message_GroupInviteMessage& operator=(const Message_GroupInviteMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_GroupInviteMessage& operator=(Message_GroupInviteMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_GroupInviteMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_GroupInviteMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_GroupInviteMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 76; + + friend void swap(Message_GroupInviteMessage& a, Message_GroupInviteMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_GroupInviteMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_GroupInviteMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_GroupInviteMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_GroupInviteMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_GroupInviteMessage& from) { + Message_GroupInviteMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_GroupInviteMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.GroupInviteMessage"; + } + protected: + explicit Message_GroupInviteMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Message_GroupInviteMessage_GroupType GroupType; + static constexpr GroupType DEFAULT = + Message_GroupInviteMessage_GroupType_DEFAULT; + static constexpr GroupType PARENT = + Message_GroupInviteMessage_GroupType_PARENT; + static inline bool GroupType_IsValid(int value) { + return Message_GroupInviteMessage_GroupType_IsValid(value); + } + static constexpr GroupType GroupType_MIN = + Message_GroupInviteMessage_GroupType_GroupType_MIN; + static constexpr GroupType GroupType_MAX = + Message_GroupInviteMessage_GroupType_GroupType_MAX; + static constexpr int GroupType_ARRAYSIZE = + Message_GroupInviteMessage_GroupType_GroupType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + GroupType_descriptor() { + return Message_GroupInviteMessage_GroupType_descriptor(); + } + template + static inline const std::string& GroupType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function GroupType_Name."); + return Message_GroupInviteMessage_GroupType_Name(enum_t_value); + } + static inline bool GroupType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + GroupType* value) { + return Message_GroupInviteMessage_GroupType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kGroupJidFieldNumber = 1, + kInviteCodeFieldNumber = 2, + kGroupNameFieldNumber = 4, + kJpegThumbnailFieldNumber = 5, + kCaptionFieldNumber = 6, + kContextInfoFieldNumber = 7, + kInviteExpirationFieldNumber = 3, + kGroupTypeFieldNumber = 8, + }; + // optional string groupJid = 1; + bool has_groupjid() const; + private: + bool _internal_has_groupjid() const; + public: + void clear_groupjid(); + const std::string& groupjid() const; + template + void set_groupjid(ArgT0&& arg0, ArgT... args); + std::string* mutable_groupjid(); + PROTOBUF_NODISCARD std::string* release_groupjid(); + void set_allocated_groupjid(std::string* groupjid); + private: + const std::string& _internal_groupjid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_groupjid(const std::string& value); + std::string* _internal_mutable_groupjid(); + public: + + // optional string inviteCode = 2; + bool has_invitecode() const; + private: + bool _internal_has_invitecode() const; + public: + void clear_invitecode(); + const std::string& invitecode() const; + template + void set_invitecode(ArgT0&& arg0, ArgT... args); + std::string* mutable_invitecode(); + PROTOBUF_NODISCARD std::string* release_invitecode(); + void set_allocated_invitecode(std::string* invitecode); + private: + const std::string& _internal_invitecode() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_invitecode(const std::string& value); + std::string* _internal_mutable_invitecode(); + public: + + // optional string groupName = 4; + bool has_groupname() const; + private: + bool _internal_has_groupname() const; + public: + void clear_groupname(); + const std::string& groupname() const; + template + void set_groupname(ArgT0&& arg0, ArgT... args); + std::string* mutable_groupname(); + PROTOBUF_NODISCARD std::string* release_groupname(); + void set_allocated_groupname(std::string* groupname); + private: + const std::string& _internal_groupname() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_groupname(const std::string& value); + std::string* _internal_mutable_groupname(); + public: + + // optional bytes jpegThumbnail = 5; + bool has_jpegthumbnail() const; + private: + bool _internal_has_jpegthumbnail() const; + public: + void clear_jpegthumbnail(); + const std::string& jpegthumbnail() const; + template + void set_jpegthumbnail(ArgT0&& arg0, ArgT... args); + std::string* mutable_jpegthumbnail(); + PROTOBUF_NODISCARD std::string* release_jpegthumbnail(); + void set_allocated_jpegthumbnail(std::string* jpegthumbnail); + private: + const std::string& _internal_jpegthumbnail() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value); + std::string* _internal_mutable_jpegthumbnail(); + public: + + // optional string caption = 6; + bool has_caption() const; + private: + bool _internal_has_caption() const; + public: + void clear_caption(); + const std::string& caption() const; + template + void set_caption(ArgT0&& arg0, ArgT... args); + std::string* mutable_caption(); + PROTOBUF_NODISCARD std::string* release_caption(); + void set_allocated_caption(std::string* caption); + private: + const std::string& _internal_caption() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_caption(const std::string& value); + std::string* _internal_mutable_caption(); + public: + + // optional .proto.ContextInfo contextInfo = 7; + bool has_contextinfo() const; + private: + bool _internal_has_contextinfo() const; + public: + void clear_contextinfo(); + const ::proto::ContextInfo& contextinfo() const; + PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); + ::proto::ContextInfo* mutable_contextinfo(); + void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); + private: + const ::proto::ContextInfo& _internal_contextinfo() const; + ::proto::ContextInfo* _internal_mutable_contextinfo(); + public: + void unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo); + ::proto::ContextInfo* unsafe_arena_release_contextinfo(); + + // optional int64 inviteExpiration = 3; + bool has_inviteexpiration() const; + private: + bool _internal_has_inviteexpiration() const; + public: + void clear_inviteexpiration(); + int64_t inviteexpiration() const; + void set_inviteexpiration(int64_t value); + private: + int64_t _internal_inviteexpiration() const; + void _internal_set_inviteexpiration(int64_t value); + public: + + // optional .proto.Message.GroupInviteMessage.GroupType groupType = 8; + bool has_grouptype() const; + private: + bool _internal_has_grouptype() const; + public: + void clear_grouptype(); + ::proto::Message_GroupInviteMessage_GroupType grouptype() const; + void set_grouptype(::proto::Message_GroupInviteMessage_GroupType value); + private: + ::proto::Message_GroupInviteMessage_GroupType _internal_grouptype() const; + void _internal_set_grouptype(::proto::Message_GroupInviteMessage_GroupType value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.GroupInviteMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr groupjid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr invitecode_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr groupname_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr caption_; + ::proto::ContextInfo* contextinfo_; + int64_t inviteexpiration_; + int grouptype_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency) */ { + public: + inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency() : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency(nullptr) {} + ~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency() override; + explicit PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& from); + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency&& from) noexcept + : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency() { + *this = ::std::move(from); + } + + inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& operator=(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& from) { + CopyFrom(from); + return *this; + } + inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& operator=(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& default_instance() { + return *internal_default_instance(); + } + static inline const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* internal_default_instance() { + return reinterpret_cast( + &_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency_default_instance_); + } + static constexpr int kIndexInFileMessages = + 77; + + friend void swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& a, Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& b) { + a.Swap(&b); + } + inline void Swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& from) { + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency"; + } + protected: + explicit Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kCurrencyCodeFieldNumber = 1, + kAmount1000FieldNumber = 2, + }; + // optional string currencyCode = 1; + bool has_currencycode() const; + private: + bool _internal_has_currencycode() const; + public: + void clear_currencycode(); + const std::string& currencycode() const; + template + void set_currencycode(ArgT0&& arg0, ArgT... args); + std::string* mutable_currencycode(); + PROTOBUF_NODISCARD std::string* release_currencycode(); + void set_allocated_currencycode(std::string* currencycode); + private: + const std::string& _internal_currencycode() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_currencycode(const std::string& value); + std::string* _internal_mutable_currencycode(); + public: + + // optional int64 amount1000 = 2; + bool has_amount1000() const; + private: + bool _internal_has_amount1000() const; + public: + void clear_amount1000(); + int64_t amount1000() const; + void set_amount1000(int64_t value); + private: + int64_t _internal_amount1000() const; + void _internal_set_amount1000(int64_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr currencycode_; + int64_t amount1000_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent) */ { + public: + inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent() : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent(nullptr) {} + ~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent() override; + explicit PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& from); + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent&& from) noexcept + : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent() { + *this = ::std::move(from); + } + + inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& operator=(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& from) { + CopyFrom(from); + return *this; + } + inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& operator=(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& default_instance() { + return *internal_default_instance(); + } + static inline const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* internal_default_instance() { + return reinterpret_cast( + &_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_default_instance_); + } + static constexpr int kIndexInFileMessages = + 78; + + friend void swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& a, Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& b) { + a.Swap(&b); + } + inline void Swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& from) { + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent"; + } + protected: + explicit Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType CalendarType; + static constexpr CalendarType GREGORIAN = + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_GREGORIAN; + static constexpr CalendarType SOLAR_HIJRI = + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_SOLAR_HIJRI; + static inline bool CalendarType_IsValid(int value) { + return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_IsValid(value); + } + static constexpr CalendarType CalendarType_MIN = + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_CalendarType_MIN; + static constexpr CalendarType CalendarType_MAX = + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_CalendarType_MAX; + static constexpr int CalendarType_ARRAYSIZE = + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_CalendarType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + CalendarType_descriptor() { + return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_descriptor(); + } + template + static inline const std::string& CalendarType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function CalendarType_Name."); + return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_Name(enum_t_value); + } + static inline bool CalendarType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + CalendarType* value) { + return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_Parse(name, value); + } + + typedef Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType DayOfWeekType; + static constexpr DayOfWeekType MONDAY = + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_MONDAY; + static constexpr DayOfWeekType TUESDAY = + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_TUESDAY; + static constexpr DayOfWeekType WEDNESDAY = + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_WEDNESDAY; + static constexpr DayOfWeekType THURSDAY = + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_THURSDAY; + static constexpr DayOfWeekType FRIDAY = + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_FRIDAY; + static constexpr DayOfWeekType SATURDAY = + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_SATURDAY; + static constexpr DayOfWeekType SUNDAY = + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_SUNDAY; + static inline bool DayOfWeekType_IsValid(int value) { + return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_IsValid(value); + } + static constexpr DayOfWeekType DayOfWeekType_MIN = + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_DayOfWeekType_MIN; + static constexpr DayOfWeekType DayOfWeekType_MAX = + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_DayOfWeekType_MAX; + static constexpr int DayOfWeekType_ARRAYSIZE = + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_DayOfWeekType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + DayOfWeekType_descriptor() { + return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_descriptor(); + } + template + static inline const std::string& DayOfWeekType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function DayOfWeekType_Name."); + return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_Name(enum_t_value); + } + static inline bool DayOfWeekType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + DayOfWeekType* value) { + return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kYearFieldNumber = 2, + kMonthFieldNumber = 3, + kDayOfMonthFieldNumber = 4, + kHourFieldNumber = 5, + kMinuteFieldNumber = 6, + kDayOfWeekFieldNumber = 1, + kCalendarFieldNumber = 7, + }; + // optional uint32 year = 2; + bool has_year() const; + private: + bool _internal_has_year() const; + public: + void clear_year(); + uint32_t year() const; + void set_year(uint32_t value); + private: + uint32_t _internal_year() const; + void _internal_set_year(uint32_t value); + public: + + // optional uint32 month = 3; + bool has_month() const; + private: + bool _internal_has_month() const; + public: + void clear_month(); + uint32_t month() const; + void set_month(uint32_t value); + private: + uint32_t _internal_month() const; + void _internal_set_month(uint32_t value); + public: + + // optional uint32 dayOfMonth = 4; + bool has_dayofmonth() const; + private: + bool _internal_has_dayofmonth() const; + public: + void clear_dayofmonth(); + uint32_t dayofmonth() const; + void set_dayofmonth(uint32_t value); + private: + uint32_t _internal_dayofmonth() const; + void _internal_set_dayofmonth(uint32_t value); + public: + + // optional uint32 hour = 5; + bool has_hour() const; + private: + bool _internal_has_hour() const; + public: + void clear_hour(); + uint32_t hour() const; + void set_hour(uint32_t value); + private: + uint32_t _internal_hour() const; + void _internal_set_hour(uint32_t value); + public: + + // optional uint32 minute = 6; + bool has_minute() const; + private: + bool _internal_has_minute() const; + public: + void clear_minute(); + uint32_t minute() const; + void set_minute(uint32_t value); + private: + uint32_t _internal_minute() const; + void _internal_set_minute(uint32_t value); + public: + + // optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.DayOfWeekType dayOfWeek = 1; + bool has_dayofweek() const; + private: + bool _internal_has_dayofweek() const; + public: + void clear_dayofweek(); + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType dayofweek() const; + void set_dayofweek(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType value); + private: + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType _internal_dayofweek() const; + void _internal_set_dayofweek(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType value); + public: + + // optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.CalendarType calendar = 7; + bool has_calendar() const; + private: + bool _internal_has_calendar() const; + public: + void clear_calendar(); + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType calendar() const; + void set_calendar(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType value); + private: + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType _internal_calendar() const; + void _internal_set_calendar(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + uint32_t year_; + uint32_t month_; + uint32_t dayofmonth_; + uint32_t hour_; + uint32_t minute_; + int dayofweek_; + int calendar_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch) */ { + public: + inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch() : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch(nullptr) {} + ~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch() override; + explicit PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& from); + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch&& from) noexcept + : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch() { + *this = ::std::move(from); + } + + inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& operator=(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& from) { + CopyFrom(from); + return *this; + } + inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& operator=(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& default_instance() { + return *internal_default_instance(); + } + static inline const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* internal_default_instance() { + return reinterpret_cast( + &_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch_default_instance_); + } + static constexpr int kIndexInFileMessages = + 79; + + friend void swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& a, Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& b) { + a.Swap(&b); + } + inline void Swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& from) { + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch"; + } + protected: + explicit Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kTimestampFieldNumber = 1, + }; + // optional int64 timestamp = 1; + bool has_timestamp() const; + private: + bool _internal_has_timestamp() const; + public: + void clear_timestamp(); + int64_t timestamp() const; + void set_timestamp(int64_t value); + private: + int64_t _internal_timestamp() const; + void _internal_set_timestamp(int64_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + int64_t timestamp_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime) */ { + public: + inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime() : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime(nullptr) {} + ~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime() override; + explicit PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& from); + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime&& from) noexcept + : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime() { + *this = ::std::move(from); + } + + inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& operator=(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& from) { + CopyFrom(from); + return *this; + } + inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& operator=(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& default_instance() { + return *internal_default_instance(); + } + enum DatetimeOneofCase { + kComponent = 1, + kUnixEpoch = 2, + DATETIMEONEOF_NOT_SET = 0, + }; + + static inline const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* internal_default_instance() { + return reinterpret_cast( + &_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_default_instance_); + } + static constexpr int kIndexInFileMessages = + 80; + + friend void swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& a, Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& b) { + a.Swap(&b); + } + inline void Swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& from) { + Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime"; + } + protected: + explicit Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent HSMDateTimeComponent; + typedef Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch HSMDateTimeUnixEpoch; + + // accessors ------------------------------------------------------- + + enum : int { + kComponentFieldNumber = 1, + kUnixEpochFieldNumber = 2, + }; + // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent component = 1; + bool has_component() const; + private: + bool _internal_has_component() const; + public: + void clear_component(); + const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& component() const; + PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* release_component(); + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* mutable_component(); + void set_allocated_component(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* component); + private: + const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& _internal_component() const; + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* _internal_mutable_component(); + public: + void unsafe_arena_set_allocated_component( + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* component); + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* unsafe_arena_release_component(); + + // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch unixEpoch = 2; + bool has_unixepoch() const; + private: + bool _internal_has_unixepoch() const; + public: + void clear_unixepoch(); + const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& unixepoch() const; + PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* release_unixepoch(); + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* mutable_unixepoch(); + void set_allocated_unixepoch(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* unixepoch); + private: + const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& _internal_unixepoch() const; + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* _internal_mutable_unixepoch(); + public: + void unsafe_arena_set_allocated_unixepoch( + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* unixepoch); + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* unsafe_arena_release_unixepoch(); + + void clear_datetimeOneof(); + DatetimeOneofCase datetimeOneof_case() const; + // @@protoc_insertion_point(class_scope:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime) + private: + class _Internal; + void set_has_component(); + void set_has_unixepoch(); + + inline bool has_datetimeOneof() const; + inline void clear_has_datetimeOneof(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + union DatetimeOneofUnion { + constexpr DatetimeOneofUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* component_; + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* unixepoch_; + } datetimeOneof_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + uint32_t _oneof_case_[1]; + + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_HighlyStructuredMessage_HSMLocalizableParameter final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter) */ { + public: + inline Message_HighlyStructuredMessage_HSMLocalizableParameter() : Message_HighlyStructuredMessage_HSMLocalizableParameter(nullptr) {} + ~Message_HighlyStructuredMessage_HSMLocalizableParameter() override; + explicit PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_HighlyStructuredMessage_HSMLocalizableParameter(const Message_HighlyStructuredMessage_HSMLocalizableParameter& from); + Message_HighlyStructuredMessage_HSMLocalizableParameter(Message_HighlyStructuredMessage_HSMLocalizableParameter&& from) noexcept + : Message_HighlyStructuredMessage_HSMLocalizableParameter() { + *this = ::std::move(from); + } + + inline Message_HighlyStructuredMessage_HSMLocalizableParameter& operator=(const Message_HighlyStructuredMessage_HSMLocalizableParameter& from) { + CopyFrom(from); + return *this; + } + inline Message_HighlyStructuredMessage_HSMLocalizableParameter& operator=(Message_HighlyStructuredMessage_HSMLocalizableParameter&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_HighlyStructuredMessage_HSMLocalizableParameter& default_instance() { + return *internal_default_instance(); + } + enum ParamOneofCase { + kCurrency = 2, + kDateTime = 3, + PARAMONEOF_NOT_SET = 0, + }; + + static inline const Message_HighlyStructuredMessage_HSMLocalizableParameter* internal_default_instance() { + return reinterpret_cast( + &_Message_HighlyStructuredMessage_HSMLocalizableParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 81; + + friend void swap(Message_HighlyStructuredMessage_HSMLocalizableParameter& a, Message_HighlyStructuredMessage_HSMLocalizableParameter& b) { + a.Swap(&b); + } + inline void Swap(Message_HighlyStructuredMessage_HSMLocalizableParameter* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_HighlyStructuredMessage_HSMLocalizableParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_HighlyStructuredMessage_HSMLocalizableParameter& from) { + Message_HighlyStructuredMessage_HSMLocalizableParameter::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter"; + } + protected: + explicit Message_HighlyStructuredMessage_HSMLocalizableParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency HSMCurrency; + typedef Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime HSMDateTime; + + // accessors ------------------------------------------------------- + + enum : int { + kDefaultFieldNumber = 1, + kCurrencyFieldNumber = 2, + kDateTimeFieldNumber = 3, + }; + // optional string default = 1; + bool has_default_() const; + private: + bool _internal_has_default_() const; + public: + void clear_default_(); + const std::string& default_() const; + template + void set_default_(ArgT0&& arg0, ArgT... args); + std::string* mutable_default_(); + PROTOBUF_NODISCARD std::string* release_default_(); + void set_allocated_default_(std::string* default_); + private: + const std::string& _internal_default_() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_default_(const std::string& value); + std::string* _internal_mutable_default_(); + public: + + // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency currency = 2; + bool has_currency() const; + private: + bool _internal_has_currency() const; + public: + void clear_currency(); + const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& currency() const; + PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* release_currency(); + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* mutable_currency(); + void set_allocated_currency(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* currency); + private: + const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& _internal_currency() const; + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* _internal_mutable_currency(); + public: + void unsafe_arena_set_allocated_currency( + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* currency); + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* unsafe_arena_release_currency(); + + // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime dateTime = 3; + bool has_datetime() const; + private: + bool _internal_has_datetime() const; + public: + void clear_datetime(); + const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& datetime() const; + PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* release_datetime(); + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* mutable_datetime(); + void set_allocated_datetime(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* datetime); + private: + const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& _internal_datetime() const; + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* _internal_mutable_datetime(); + public: + void unsafe_arena_set_allocated_datetime( + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* datetime); + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* unsafe_arena_release_datetime(); + + void clear_paramOneof(); + ParamOneofCase paramOneof_case() const; + // @@protoc_insertion_point(class_scope:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter) + private: + class _Internal; + void set_has_currency(); + void set_has_datetime(); + + inline bool has_paramOneof() const; + inline void clear_has_paramOneof(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr default__; + union ParamOneofUnion { + constexpr ParamOneofUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* currency_; + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* datetime_; + } paramOneof_; + uint32_t _oneof_case_[1]; + + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_HighlyStructuredMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.HighlyStructuredMessage) */ { + public: + inline Message_HighlyStructuredMessage() : Message_HighlyStructuredMessage(nullptr) {} + ~Message_HighlyStructuredMessage() override; + explicit PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_HighlyStructuredMessage(const Message_HighlyStructuredMessage& from); + Message_HighlyStructuredMessage(Message_HighlyStructuredMessage&& from) noexcept + : Message_HighlyStructuredMessage() { + *this = ::std::move(from); + } + + inline Message_HighlyStructuredMessage& operator=(const Message_HighlyStructuredMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_HighlyStructuredMessage& operator=(Message_HighlyStructuredMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_HighlyStructuredMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_HighlyStructuredMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_HighlyStructuredMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 82; + + friend void swap(Message_HighlyStructuredMessage& a, Message_HighlyStructuredMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_HighlyStructuredMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_HighlyStructuredMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_HighlyStructuredMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_HighlyStructuredMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_HighlyStructuredMessage& from) { + Message_HighlyStructuredMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_HighlyStructuredMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.HighlyStructuredMessage"; + } + protected: + explicit Message_HighlyStructuredMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Message_HighlyStructuredMessage_HSMLocalizableParameter HSMLocalizableParameter; + + // accessors ------------------------------------------------------- + + enum : int { + kParamsFieldNumber = 3, + kLocalizableParamsFieldNumber = 6, + kNamespaceFieldNumber = 1, + kElementNameFieldNumber = 2, + kFallbackLgFieldNumber = 4, + kFallbackLcFieldNumber = 5, + kDeterministicLgFieldNumber = 7, + kDeterministicLcFieldNumber = 8, + kHydratedHsmFieldNumber = 9, + }; + // repeated string params = 3; + int params_size() const; + private: + int _internal_params_size() const; + public: + void clear_params(); + const std::string& params(int index) const; + std::string* mutable_params(int index); + void set_params(int index, const std::string& value); + void set_params(int index, std::string&& value); + void set_params(int index, const char* value); + void set_params(int index, const char* value, size_t size); + std::string* add_params(); + void add_params(const std::string& value); + void add_params(std::string&& value); + void add_params(const char* value); + void add_params(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& params() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_params(); + private: + const std::string& _internal_params(int index) const; + std::string* _internal_add_params(); + public: + + // repeated .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter localizableParams = 6; + int localizableparams_size() const; + private: + int _internal_localizableparams_size() const; + public: + void clear_localizableparams(); + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* mutable_localizableparams(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter >* + mutable_localizableparams(); + private: + const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter& _internal_localizableparams(int index) const; + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* _internal_add_localizableparams(); + public: + const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter& localizableparams(int index) const; + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* add_localizableparams(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter >& + localizableparams() const; + + // optional string namespace = 1; + bool has_namespace_() const; + private: + bool _internal_has_namespace_() const; + public: + void clear_namespace_(); + const std::string& namespace_() const; + template + void set_namespace_(ArgT0&& arg0, ArgT... args); + std::string* mutable_namespace_(); + PROTOBUF_NODISCARD std::string* release_namespace_(); + void set_allocated_namespace_(std::string* namespace_); + private: + const std::string& _internal_namespace_() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_namespace_(const std::string& value); + std::string* _internal_mutable_namespace_(); + public: + + // optional string elementName = 2; + bool has_elementname() const; + private: + bool _internal_has_elementname() const; + public: + void clear_elementname(); + const std::string& elementname() const; + template + void set_elementname(ArgT0&& arg0, ArgT... args); + std::string* mutable_elementname(); + PROTOBUF_NODISCARD std::string* release_elementname(); + void set_allocated_elementname(std::string* elementname); + private: + const std::string& _internal_elementname() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_elementname(const std::string& value); + std::string* _internal_mutable_elementname(); + public: + + // optional string fallbackLg = 4; + bool has_fallbacklg() const; + private: + bool _internal_has_fallbacklg() const; + public: + void clear_fallbacklg(); + const std::string& fallbacklg() const; + template + void set_fallbacklg(ArgT0&& arg0, ArgT... args); + std::string* mutable_fallbacklg(); + PROTOBUF_NODISCARD std::string* release_fallbacklg(); + void set_allocated_fallbacklg(std::string* fallbacklg); + private: + const std::string& _internal_fallbacklg() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_fallbacklg(const std::string& value); + std::string* _internal_mutable_fallbacklg(); + public: + + // optional string fallbackLc = 5; + bool has_fallbacklc() const; + private: + bool _internal_has_fallbacklc() const; + public: + void clear_fallbacklc(); + const std::string& fallbacklc() const; + template + void set_fallbacklc(ArgT0&& arg0, ArgT... args); + std::string* mutable_fallbacklc(); + PROTOBUF_NODISCARD std::string* release_fallbacklc(); + void set_allocated_fallbacklc(std::string* fallbacklc); + private: + const std::string& _internal_fallbacklc() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_fallbacklc(const std::string& value); + std::string* _internal_mutable_fallbacklc(); + public: + + // optional string deterministicLg = 7; + bool has_deterministiclg() const; + private: + bool _internal_has_deterministiclg() const; + public: + void clear_deterministiclg(); + const std::string& deterministiclg() const; + template + void set_deterministiclg(ArgT0&& arg0, ArgT... args); + std::string* mutable_deterministiclg(); + PROTOBUF_NODISCARD std::string* release_deterministiclg(); + void set_allocated_deterministiclg(std::string* deterministiclg); + private: + const std::string& _internal_deterministiclg() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_deterministiclg(const std::string& value); + std::string* _internal_mutable_deterministiclg(); + public: + + // optional string deterministicLc = 8; + bool has_deterministiclc() const; + private: + bool _internal_has_deterministiclc() const; + public: + void clear_deterministiclc(); + const std::string& deterministiclc() const; + template + void set_deterministiclc(ArgT0&& arg0, ArgT... args); + std::string* mutable_deterministiclc(); + PROTOBUF_NODISCARD std::string* release_deterministiclc(); + void set_allocated_deterministiclc(std::string* deterministiclc); + private: + const std::string& _internal_deterministiclc() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_deterministiclc(const std::string& value); + std::string* _internal_mutable_deterministiclc(); + public: + + // optional .proto.Message.TemplateMessage hydratedHsm = 9; + bool has_hydratedhsm() const; + private: + bool _internal_has_hydratedhsm() const; + public: + void clear_hydratedhsm(); + const ::proto::Message_TemplateMessage& hydratedhsm() const; + PROTOBUF_NODISCARD ::proto::Message_TemplateMessage* release_hydratedhsm(); + ::proto::Message_TemplateMessage* mutable_hydratedhsm(); + void set_allocated_hydratedhsm(::proto::Message_TemplateMessage* hydratedhsm); + private: + const ::proto::Message_TemplateMessage& _internal_hydratedhsm() const; + ::proto::Message_TemplateMessage* _internal_mutable_hydratedhsm(); + public: + void unsafe_arena_set_allocated_hydratedhsm( + ::proto::Message_TemplateMessage* hydratedhsm); + ::proto::Message_TemplateMessage* unsafe_arena_release_hydratedhsm(); + + // @@protoc_insertion_point(class_scope:proto.Message.HighlyStructuredMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField params_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter > localizableparams_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr namespace__; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr elementname_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fallbacklg_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fallbacklc_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr deterministiclg_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr deterministiclc_; + ::proto::Message_TemplateMessage* hydratedhsm_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_HistorySyncNotification final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.HistorySyncNotification) */ { + public: + inline Message_HistorySyncNotification() : Message_HistorySyncNotification(nullptr) {} + ~Message_HistorySyncNotification() override; + explicit PROTOBUF_CONSTEXPR Message_HistorySyncNotification(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_HistorySyncNotification(const Message_HistorySyncNotification& from); + Message_HistorySyncNotification(Message_HistorySyncNotification&& from) noexcept + : Message_HistorySyncNotification() { + *this = ::std::move(from); + } + + inline Message_HistorySyncNotification& operator=(const Message_HistorySyncNotification& from) { + CopyFrom(from); + return *this; + } + inline Message_HistorySyncNotification& operator=(Message_HistorySyncNotification&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_HistorySyncNotification& default_instance() { + return *internal_default_instance(); + } + static inline const Message_HistorySyncNotification* internal_default_instance() { + return reinterpret_cast( + &_Message_HistorySyncNotification_default_instance_); + } + static constexpr int kIndexInFileMessages = + 83; + + friend void swap(Message_HistorySyncNotification& a, Message_HistorySyncNotification& b) { + a.Swap(&b); + } + inline void Swap(Message_HistorySyncNotification* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_HistorySyncNotification* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_HistorySyncNotification* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_HistorySyncNotification& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_HistorySyncNotification& from) { + Message_HistorySyncNotification::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_HistorySyncNotification* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.HistorySyncNotification"; + } + protected: + explicit Message_HistorySyncNotification(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Message_HistorySyncNotification_HistorySyncType HistorySyncType; + static constexpr HistorySyncType INITIAL_BOOTSTRAP = + Message_HistorySyncNotification_HistorySyncType_INITIAL_BOOTSTRAP; + static constexpr HistorySyncType INITIAL_STATUS_V3 = + Message_HistorySyncNotification_HistorySyncType_INITIAL_STATUS_V3; + static constexpr HistorySyncType FULL = + Message_HistorySyncNotification_HistorySyncType_FULL; + static constexpr HistorySyncType RECENT = + Message_HistorySyncNotification_HistorySyncType_RECENT; + static constexpr HistorySyncType PUSH_NAME = + Message_HistorySyncNotification_HistorySyncType_PUSH_NAME; + static inline bool HistorySyncType_IsValid(int value) { + return Message_HistorySyncNotification_HistorySyncType_IsValid(value); + } + static constexpr HistorySyncType HistorySyncType_MIN = + Message_HistorySyncNotification_HistorySyncType_HistorySyncType_MIN; + static constexpr HistorySyncType HistorySyncType_MAX = + Message_HistorySyncNotification_HistorySyncType_HistorySyncType_MAX; + static constexpr int HistorySyncType_ARRAYSIZE = + Message_HistorySyncNotification_HistorySyncType_HistorySyncType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + HistorySyncType_descriptor() { + return Message_HistorySyncNotification_HistorySyncType_descriptor(); + } + template + static inline const std::string& HistorySyncType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function HistorySyncType_Name."); + return Message_HistorySyncNotification_HistorySyncType_Name(enum_t_value); + } + static inline bool HistorySyncType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + HistorySyncType* value) { + return Message_HistorySyncNotification_HistorySyncType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kFileSha256FieldNumber = 1, + kMediaKeyFieldNumber = 3, + kFileEncSha256FieldNumber = 4, + kDirectPathFieldNumber = 5, + kOriginalMessageIdFieldNumber = 8, + kFileLengthFieldNumber = 2, + kSyncTypeFieldNumber = 6, + kChunkOrderFieldNumber = 7, + kProgressFieldNumber = 9, + }; + // optional bytes fileSha256 = 1; + bool has_filesha256() const; + private: + bool _internal_has_filesha256() const; + public: + void clear_filesha256(); + const std::string& filesha256() const; + template + void set_filesha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_filesha256(); + PROTOBUF_NODISCARD std::string* release_filesha256(); + void set_allocated_filesha256(std::string* filesha256); + private: + const std::string& _internal_filesha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value); + std::string* _internal_mutable_filesha256(); + public: + + // optional bytes mediaKey = 3; + bool has_mediakey() const; + private: + bool _internal_has_mediakey() const; + public: + void clear_mediakey(); + const std::string& mediakey() const; + template + void set_mediakey(ArgT0&& arg0, ArgT... args); + std::string* mutable_mediakey(); + PROTOBUF_NODISCARD std::string* release_mediakey(); + void set_allocated_mediakey(std::string* mediakey); + private: + const std::string& _internal_mediakey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value); + std::string* _internal_mutable_mediakey(); + public: + + // optional bytes fileEncSha256 = 4; + bool has_fileencsha256() const; + private: + bool _internal_has_fileencsha256() const; + public: + void clear_fileencsha256(); + const std::string& fileencsha256() const; + template + void set_fileencsha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_fileencsha256(); + PROTOBUF_NODISCARD std::string* release_fileencsha256(); + void set_allocated_fileencsha256(std::string* fileencsha256); + private: + const std::string& _internal_fileencsha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value); + std::string* _internal_mutable_fileencsha256(); + public: + + // optional string directPath = 5; + bool has_directpath() const; + private: + bool _internal_has_directpath() const; + public: + void clear_directpath(); + const std::string& directpath() const; + template + void set_directpath(ArgT0&& arg0, ArgT... args); + std::string* mutable_directpath(); + PROTOBUF_NODISCARD std::string* release_directpath(); + void set_allocated_directpath(std::string* directpath); + private: + const std::string& _internal_directpath() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value); + std::string* _internal_mutable_directpath(); + public: + + // optional string originalMessageId = 8; + bool has_originalmessageid() const; + private: + bool _internal_has_originalmessageid() const; + public: + void clear_originalmessageid(); + const std::string& originalmessageid() const; + template + void set_originalmessageid(ArgT0&& arg0, ArgT... args); + std::string* mutable_originalmessageid(); + PROTOBUF_NODISCARD std::string* release_originalmessageid(); + void set_allocated_originalmessageid(std::string* originalmessageid); + private: + const std::string& _internal_originalmessageid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_originalmessageid(const std::string& value); + std::string* _internal_mutable_originalmessageid(); + public: + + // optional uint64 fileLength = 2; + bool has_filelength() const; + private: + bool _internal_has_filelength() const; + public: + void clear_filelength(); + uint64_t filelength() const; + void set_filelength(uint64_t value); + private: + uint64_t _internal_filelength() const; + void _internal_set_filelength(uint64_t value); + public: + + // optional .proto.Message.HistorySyncNotification.HistorySyncType syncType = 6; + bool has_synctype() const; + private: + bool _internal_has_synctype() const; + public: + void clear_synctype(); + ::proto::Message_HistorySyncNotification_HistorySyncType synctype() const; + void set_synctype(::proto::Message_HistorySyncNotification_HistorySyncType value); + private: + ::proto::Message_HistorySyncNotification_HistorySyncType _internal_synctype() const; + void _internal_set_synctype(::proto::Message_HistorySyncNotification_HistorySyncType value); + public: + + // optional uint32 chunkOrder = 7; + bool has_chunkorder() const; + private: + bool _internal_has_chunkorder() const; + public: + void clear_chunkorder(); + uint32_t chunkorder() const; + void set_chunkorder(uint32_t value); + private: + uint32_t _internal_chunkorder() const; + void _internal_set_chunkorder(uint32_t value); + public: + + // optional uint32 progress = 9; + bool has_progress() const; + private: + bool _internal_has_progress() const; + public: + void clear_progress(); + uint32_t progress() const; + void set_progress(uint32_t value); + private: + uint32_t _internal_progress() const; + void _internal_set_progress(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.HistorySyncNotification) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr originalmessageid_; + uint64_t filelength_; + int synctype_; + uint32_t chunkorder_; + uint32_t progress_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_ImageMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ImageMessage) */ { + public: + inline Message_ImageMessage() : Message_ImageMessage(nullptr) {} + ~Message_ImageMessage() override; + explicit PROTOBUF_CONSTEXPR Message_ImageMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_ImageMessage(const Message_ImageMessage& from); + Message_ImageMessage(Message_ImageMessage&& from) noexcept + : Message_ImageMessage() { + *this = ::std::move(from); + } + + inline Message_ImageMessage& operator=(const Message_ImageMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_ImageMessage& operator=(Message_ImageMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_ImageMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_ImageMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_ImageMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 84; + + friend void swap(Message_ImageMessage& a, Message_ImageMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_ImageMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_ImageMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_ImageMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_ImageMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_ImageMessage& from) { + Message_ImageMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_ImageMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.ImageMessage"; + } + protected: + explicit Message_ImageMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kInteractiveAnnotationsFieldNumber = 10, + kScanLengthsFieldNumber = 22, + kUrlFieldNumber = 1, + kMimetypeFieldNumber = 2, + kCaptionFieldNumber = 3, + kFileSha256FieldNumber = 4, + kMediaKeyFieldNumber = 8, + kFileEncSha256FieldNumber = 9, + kDirectPathFieldNumber = 11, + kJpegThumbnailFieldNumber = 16, + kFirstScanSidecarFieldNumber = 18, + kScansSidecarFieldNumber = 21, + kMidQualityFileSha256FieldNumber = 23, + kMidQualityFileEncSha256FieldNumber = 24, + kThumbnailDirectPathFieldNumber = 26, + kThumbnailSha256FieldNumber = 27, + kThumbnailEncSha256FieldNumber = 28, + kStaticUrlFieldNumber = 29, + kContextInfoFieldNumber = 17, + kFileLengthFieldNumber = 5, + kHeightFieldNumber = 6, + kWidthFieldNumber = 7, + kMediaKeyTimestampFieldNumber = 12, + kFirstScanLengthFieldNumber = 19, + kExperimentGroupIdFieldNumber = 20, + kViewOnceFieldNumber = 25, + }; + // repeated .proto.InteractiveAnnotation interactiveAnnotations = 10; + int interactiveannotations_size() const; + private: + int _internal_interactiveannotations_size() const; + public: + void clear_interactiveannotations(); + ::proto::InteractiveAnnotation* mutable_interactiveannotations(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >* + mutable_interactiveannotations(); + private: + const ::proto::InteractiveAnnotation& _internal_interactiveannotations(int index) const; + ::proto::InteractiveAnnotation* _internal_add_interactiveannotations(); + public: + const ::proto::InteractiveAnnotation& interactiveannotations(int index) const; + ::proto::InteractiveAnnotation* add_interactiveannotations(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >& + interactiveannotations() const; + + // repeated uint32 scanLengths = 22; + int scanlengths_size() const; + private: + int _internal_scanlengths_size() const; + public: + void clear_scanlengths(); + private: + uint32_t _internal_scanlengths(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + _internal_scanlengths() const; + void _internal_add_scanlengths(uint32_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + _internal_mutable_scanlengths(); + public: + uint32_t scanlengths(int index) const; + void set_scanlengths(int index, uint32_t value); + void add_scanlengths(uint32_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& + scanlengths() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* + mutable_scanlengths(); + + // optional string url = 1; + bool has_url() const; + private: + bool _internal_has_url() const; + public: + void clear_url(); + const std::string& url() const; + template + void set_url(ArgT0&& arg0, ArgT... args); + std::string* mutable_url(); + PROTOBUF_NODISCARD std::string* release_url(); + void set_allocated_url(std::string* url); + private: + const std::string& _internal_url() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value); + std::string* _internal_mutable_url(); + public: + + // optional string mimetype = 2; + bool has_mimetype() const; + private: + bool _internal_has_mimetype() const; + public: + void clear_mimetype(); + const std::string& mimetype() const; + template + void set_mimetype(ArgT0&& arg0, ArgT... args); + std::string* mutable_mimetype(); + PROTOBUF_NODISCARD std::string* release_mimetype(); + void set_allocated_mimetype(std::string* mimetype); + private: + const std::string& _internal_mimetype() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value); + std::string* _internal_mutable_mimetype(); + public: + + // optional string caption = 3; + bool has_caption() const; + private: + bool _internal_has_caption() const; + public: + void clear_caption(); + const std::string& caption() const; + template + void set_caption(ArgT0&& arg0, ArgT... args); + std::string* mutable_caption(); + PROTOBUF_NODISCARD std::string* release_caption(); + void set_allocated_caption(std::string* caption); + private: + const std::string& _internal_caption() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_caption(const std::string& value); + std::string* _internal_mutable_caption(); + public: + + // optional bytes fileSha256 = 4; + bool has_filesha256() const; + private: + bool _internal_has_filesha256() const; + public: + void clear_filesha256(); + const std::string& filesha256() const; + template + void set_filesha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_filesha256(); + PROTOBUF_NODISCARD std::string* release_filesha256(); + void set_allocated_filesha256(std::string* filesha256); + private: + const std::string& _internal_filesha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value); + std::string* _internal_mutable_filesha256(); + public: + + // optional bytes mediaKey = 8; + bool has_mediakey() const; + private: + bool _internal_has_mediakey() const; + public: + void clear_mediakey(); + const std::string& mediakey() const; + template + void set_mediakey(ArgT0&& arg0, ArgT... args); + std::string* mutable_mediakey(); + PROTOBUF_NODISCARD std::string* release_mediakey(); + void set_allocated_mediakey(std::string* mediakey); + private: + const std::string& _internal_mediakey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value); + std::string* _internal_mutable_mediakey(); + public: + + // optional bytes fileEncSha256 = 9; + bool has_fileencsha256() const; + private: + bool _internal_has_fileencsha256() const; + public: + void clear_fileencsha256(); + const std::string& fileencsha256() const; + template + void set_fileencsha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_fileencsha256(); + PROTOBUF_NODISCARD std::string* release_fileencsha256(); + void set_allocated_fileencsha256(std::string* fileencsha256); + private: + const std::string& _internal_fileencsha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value); + std::string* _internal_mutable_fileencsha256(); + public: + + // optional string directPath = 11; + bool has_directpath() const; + private: + bool _internal_has_directpath() const; + public: + void clear_directpath(); + const std::string& directpath() const; + template + void set_directpath(ArgT0&& arg0, ArgT... args); + std::string* mutable_directpath(); + PROTOBUF_NODISCARD std::string* release_directpath(); + void set_allocated_directpath(std::string* directpath); + private: + const std::string& _internal_directpath() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value); + std::string* _internal_mutable_directpath(); + public: + + // optional bytes jpegThumbnail = 16; + bool has_jpegthumbnail() const; + private: + bool _internal_has_jpegthumbnail() const; + public: + void clear_jpegthumbnail(); + const std::string& jpegthumbnail() const; + template + void set_jpegthumbnail(ArgT0&& arg0, ArgT... args); + std::string* mutable_jpegthumbnail(); + PROTOBUF_NODISCARD std::string* release_jpegthumbnail(); + void set_allocated_jpegthumbnail(std::string* jpegthumbnail); + private: + const std::string& _internal_jpegthumbnail() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value); + std::string* _internal_mutable_jpegthumbnail(); + public: + + // optional bytes firstScanSidecar = 18; + bool has_firstscansidecar() const; + private: + bool _internal_has_firstscansidecar() const; + public: + void clear_firstscansidecar(); + const std::string& firstscansidecar() const; + template + void set_firstscansidecar(ArgT0&& arg0, ArgT... args); + std::string* mutable_firstscansidecar(); + PROTOBUF_NODISCARD std::string* release_firstscansidecar(); + void set_allocated_firstscansidecar(std::string* firstscansidecar); + private: + const std::string& _internal_firstscansidecar() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_firstscansidecar(const std::string& value); + std::string* _internal_mutable_firstscansidecar(); + public: + + // optional bytes scansSidecar = 21; + bool has_scanssidecar() const; + private: + bool _internal_has_scanssidecar() const; + public: + void clear_scanssidecar(); + const std::string& scanssidecar() const; + template + void set_scanssidecar(ArgT0&& arg0, ArgT... args); + std::string* mutable_scanssidecar(); + PROTOBUF_NODISCARD std::string* release_scanssidecar(); + void set_allocated_scanssidecar(std::string* scanssidecar); + private: + const std::string& _internal_scanssidecar() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_scanssidecar(const std::string& value); + std::string* _internal_mutable_scanssidecar(); + public: + + // optional bytes midQualityFileSha256 = 23; + bool has_midqualityfilesha256() const; + private: + bool _internal_has_midqualityfilesha256() const; + public: + void clear_midqualityfilesha256(); + const std::string& midqualityfilesha256() const; + template + void set_midqualityfilesha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_midqualityfilesha256(); + PROTOBUF_NODISCARD std::string* release_midqualityfilesha256(); + void set_allocated_midqualityfilesha256(std::string* midqualityfilesha256); + private: + const std::string& _internal_midqualityfilesha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_midqualityfilesha256(const std::string& value); + std::string* _internal_mutable_midqualityfilesha256(); + public: + + // optional bytes midQualityFileEncSha256 = 24; + bool has_midqualityfileencsha256() const; + private: + bool _internal_has_midqualityfileencsha256() const; + public: + void clear_midqualityfileencsha256(); + const std::string& midqualityfileencsha256() const; + template + void set_midqualityfileencsha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_midqualityfileencsha256(); + PROTOBUF_NODISCARD std::string* release_midqualityfileencsha256(); + void set_allocated_midqualityfileencsha256(std::string* midqualityfileencsha256); + private: + const std::string& _internal_midqualityfileencsha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_midqualityfileencsha256(const std::string& value); + std::string* _internal_mutable_midqualityfileencsha256(); + public: + + // optional string thumbnailDirectPath = 26; + bool has_thumbnaildirectpath() const; + private: + bool _internal_has_thumbnaildirectpath() const; + public: + void clear_thumbnaildirectpath(); + const std::string& thumbnaildirectpath() const; + template + void set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args); + std::string* mutable_thumbnaildirectpath(); + PROTOBUF_NODISCARD std::string* release_thumbnaildirectpath(); + void set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath); + private: + const std::string& _internal_thumbnaildirectpath() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnaildirectpath(const std::string& value); + std::string* _internal_mutable_thumbnaildirectpath(); + public: + + // optional bytes thumbnailSha256 = 27; + bool has_thumbnailsha256() const; + private: + bool _internal_has_thumbnailsha256() const; + public: + void clear_thumbnailsha256(); + const std::string& thumbnailsha256() const; + template + void set_thumbnailsha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_thumbnailsha256(); + PROTOBUF_NODISCARD std::string* release_thumbnailsha256(); + void set_allocated_thumbnailsha256(std::string* thumbnailsha256); + private: + const std::string& _internal_thumbnailsha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailsha256(const std::string& value); + std::string* _internal_mutable_thumbnailsha256(); + public: + + // optional bytes thumbnailEncSha256 = 28; + bool has_thumbnailencsha256() const; + private: + bool _internal_has_thumbnailencsha256() const; + public: + void clear_thumbnailencsha256(); + const std::string& thumbnailencsha256() const; + template + void set_thumbnailencsha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_thumbnailencsha256(); + PROTOBUF_NODISCARD std::string* release_thumbnailencsha256(); + void set_allocated_thumbnailencsha256(std::string* thumbnailencsha256); + private: + const std::string& _internal_thumbnailencsha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailencsha256(const std::string& value); + std::string* _internal_mutable_thumbnailencsha256(); + public: + + // optional string staticUrl = 29; + bool has_staticurl() const; + private: + bool _internal_has_staticurl() const; + public: + void clear_staticurl(); + const std::string& staticurl() const; + template + void set_staticurl(ArgT0&& arg0, ArgT... args); + std::string* mutable_staticurl(); + PROTOBUF_NODISCARD std::string* release_staticurl(); + void set_allocated_staticurl(std::string* staticurl); + private: + const std::string& _internal_staticurl() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_staticurl(const std::string& value); + std::string* _internal_mutable_staticurl(); + public: + + // optional .proto.ContextInfo contextInfo = 17; + bool has_contextinfo() const; + private: + bool _internal_has_contextinfo() const; + public: + void clear_contextinfo(); + const ::proto::ContextInfo& contextinfo() const; + PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); + ::proto::ContextInfo* mutable_contextinfo(); + void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); + private: + const ::proto::ContextInfo& _internal_contextinfo() const; + ::proto::ContextInfo* _internal_mutable_contextinfo(); + public: + void unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo); + ::proto::ContextInfo* unsafe_arena_release_contextinfo(); + + // optional uint64 fileLength = 5; + bool has_filelength() const; + private: + bool _internal_has_filelength() const; + public: + void clear_filelength(); + uint64_t filelength() const; + void set_filelength(uint64_t value); + private: + uint64_t _internal_filelength() const; + void _internal_set_filelength(uint64_t value); + public: + + // optional uint32 height = 6; + bool has_height() const; + private: + bool _internal_has_height() const; + public: + void clear_height(); + uint32_t height() const; + void set_height(uint32_t value); + private: + uint32_t _internal_height() const; + void _internal_set_height(uint32_t value); + public: + + // optional uint32 width = 7; + bool has_width() const; + private: + bool _internal_has_width() const; + public: + void clear_width(); + uint32_t width() const; + void set_width(uint32_t value); + private: + uint32_t _internal_width() const; + void _internal_set_width(uint32_t value); + public: + + // optional int64 mediaKeyTimestamp = 12; + bool has_mediakeytimestamp() const; + private: + bool _internal_has_mediakeytimestamp() const; + public: + void clear_mediakeytimestamp(); + int64_t mediakeytimestamp() const; + void set_mediakeytimestamp(int64_t value); + private: + int64_t _internal_mediakeytimestamp() const; + void _internal_set_mediakeytimestamp(int64_t value); + public: + + // optional uint32 firstScanLength = 19; + bool has_firstscanlength() const; + private: + bool _internal_has_firstscanlength() const; + public: + void clear_firstscanlength(); + uint32_t firstscanlength() const; + void set_firstscanlength(uint32_t value); + private: + uint32_t _internal_firstscanlength() const; + void _internal_set_firstscanlength(uint32_t value); + public: + + // optional uint32 experimentGroupId = 20; + bool has_experimentgroupid() const; + private: + bool _internal_has_experimentgroupid() const; + public: + void clear_experimentgroupid(); + uint32_t experimentgroupid() const; + void set_experimentgroupid(uint32_t value); + private: + uint32_t _internal_experimentgroupid() const; + void _internal_set_experimentgroupid(uint32_t value); + public: + + // optional bool viewOnce = 25; + bool has_viewonce() const; + private: + bool _internal_has_viewonce() const; + public: + void clear_viewonce(); + bool viewonce() const; + void set_viewonce(bool value); + private: + bool _internal_viewonce() const; + void _internal_set_viewonce(bool value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.ImageMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation > interactiveannotations_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > scanlengths_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mimetype_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr caption_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr firstscansidecar_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr scanssidecar_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr midqualityfilesha256_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr midqualityfileencsha256_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnaildirectpath_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailsha256_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailencsha256_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr staticurl_; + ::proto::ContextInfo* contextinfo_; + uint64_t filelength_; + uint32_t height_; + uint32_t width_; + int64_t mediakeytimestamp_; + uint32_t firstscanlength_; + uint32_t experimentgroupid_; + bool viewonce_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_InitialSecurityNotificationSettingSync final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InitialSecurityNotificationSettingSync) */ { + public: + inline Message_InitialSecurityNotificationSettingSync() : Message_InitialSecurityNotificationSettingSync(nullptr) {} + ~Message_InitialSecurityNotificationSettingSync() override; + explicit PROTOBUF_CONSTEXPR Message_InitialSecurityNotificationSettingSync(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_InitialSecurityNotificationSettingSync(const Message_InitialSecurityNotificationSettingSync& from); + Message_InitialSecurityNotificationSettingSync(Message_InitialSecurityNotificationSettingSync&& from) noexcept + : Message_InitialSecurityNotificationSettingSync() { + *this = ::std::move(from); + } + + inline Message_InitialSecurityNotificationSettingSync& operator=(const Message_InitialSecurityNotificationSettingSync& from) { + CopyFrom(from); + return *this; + } + inline Message_InitialSecurityNotificationSettingSync& operator=(Message_InitialSecurityNotificationSettingSync&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_InitialSecurityNotificationSettingSync& default_instance() { + return *internal_default_instance(); + } + static inline const Message_InitialSecurityNotificationSettingSync* internal_default_instance() { + return reinterpret_cast( + &_Message_InitialSecurityNotificationSettingSync_default_instance_); + } + static constexpr int kIndexInFileMessages = + 85; + + friend void swap(Message_InitialSecurityNotificationSettingSync& a, Message_InitialSecurityNotificationSettingSync& b) { + a.Swap(&b); + } + inline void Swap(Message_InitialSecurityNotificationSettingSync* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_InitialSecurityNotificationSettingSync* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_InitialSecurityNotificationSettingSync* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_InitialSecurityNotificationSettingSync& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_InitialSecurityNotificationSettingSync& from) { + Message_InitialSecurityNotificationSettingSync::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_InitialSecurityNotificationSettingSync* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.InitialSecurityNotificationSettingSync"; + } + protected: + explicit Message_InitialSecurityNotificationSettingSync(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSecurityNotificationEnabledFieldNumber = 1, + }; + // optional bool securityNotificationEnabled = 1; + bool has_securitynotificationenabled() const; + private: + bool _internal_has_securitynotificationenabled() const; + public: + void clear_securitynotificationenabled(); + bool securitynotificationenabled() const; + void set_securitynotificationenabled(bool value); + private: + bool _internal_securitynotificationenabled() const; + void _internal_set_securitynotificationenabled(bool value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.InitialSecurityNotificationSettingSync) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + bool securitynotificationenabled_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_InteractiveMessage_Body final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage.Body) */ { + public: + inline Message_InteractiveMessage_Body() : Message_InteractiveMessage_Body(nullptr) {} + ~Message_InteractiveMessage_Body() override; + explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage_Body(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_InteractiveMessage_Body(const Message_InteractiveMessage_Body& from); + Message_InteractiveMessage_Body(Message_InteractiveMessage_Body&& from) noexcept + : Message_InteractiveMessage_Body() { + *this = ::std::move(from); + } + + inline Message_InteractiveMessage_Body& operator=(const Message_InteractiveMessage_Body& from) { + CopyFrom(from); + return *this; + } + inline Message_InteractiveMessage_Body& operator=(Message_InteractiveMessage_Body&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_InteractiveMessage_Body& default_instance() { + return *internal_default_instance(); + } + static inline const Message_InteractiveMessage_Body* internal_default_instance() { + return reinterpret_cast( + &_Message_InteractiveMessage_Body_default_instance_); + } + static constexpr int kIndexInFileMessages = + 86; + + friend void swap(Message_InteractiveMessage_Body& a, Message_InteractiveMessage_Body& b) { + a.Swap(&b); + } + inline void Swap(Message_InteractiveMessage_Body* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_InteractiveMessage_Body* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_InteractiveMessage_Body* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_InteractiveMessage_Body& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_InteractiveMessage_Body& from) { + Message_InteractiveMessage_Body::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_InteractiveMessage_Body* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.InteractiveMessage.Body"; + } + protected: + explicit Message_InteractiveMessage_Body(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kTextFieldNumber = 1, + }; + // optional string text = 1; + bool has_text() const; + private: + bool _internal_has_text() const; + public: + void clear_text(); + const std::string& text() const; + template + void set_text(ArgT0&& arg0, ArgT... args); + std::string* mutable_text(); + PROTOBUF_NODISCARD std::string* release_text(); + void set_allocated_text(std::string* text); + private: + const std::string& _internal_text() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value); + std::string* _internal_mutable_text(); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage.Body) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_InteractiveMessage_CollectionMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage.CollectionMessage) */ { + public: + inline Message_InteractiveMessage_CollectionMessage() : Message_InteractiveMessage_CollectionMessage(nullptr) {} + ~Message_InteractiveMessage_CollectionMessage() override; + explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage_CollectionMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_InteractiveMessage_CollectionMessage(const Message_InteractiveMessage_CollectionMessage& from); + Message_InteractiveMessage_CollectionMessage(Message_InteractiveMessage_CollectionMessage&& from) noexcept + : Message_InteractiveMessage_CollectionMessage() { + *this = ::std::move(from); + } + + inline Message_InteractiveMessage_CollectionMessage& operator=(const Message_InteractiveMessage_CollectionMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_InteractiveMessage_CollectionMessage& operator=(Message_InteractiveMessage_CollectionMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_InteractiveMessage_CollectionMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_InteractiveMessage_CollectionMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_InteractiveMessage_CollectionMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 87; + + friend void swap(Message_InteractiveMessage_CollectionMessage& a, Message_InteractiveMessage_CollectionMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_InteractiveMessage_CollectionMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_InteractiveMessage_CollectionMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_InteractiveMessage_CollectionMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_InteractiveMessage_CollectionMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_InteractiveMessage_CollectionMessage& from) { + Message_InteractiveMessage_CollectionMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_InteractiveMessage_CollectionMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.InteractiveMessage.CollectionMessage"; + } + protected: + explicit Message_InteractiveMessage_CollectionMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kBizJidFieldNumber = 1, + kIdFieldNumber = 2, + kMessageVersionFieldNumber = 3, + }; + // optional string bizJid = 1; + bool has_bizjid() const; + private: + bool _internal_has_bizjid() const; + public: + void clear_bizjid(); + const std::string& bizjid() const; + template + void set_bizjid(ArgT0&& arg0, ArgT... args); + std::string* mutable_bizjid(); + PROTOBUF_NODISCARD std::string* release_bizjid(); + void set_allocated_bizjid(std::string* bizjid); + private: + const std::string& _internal_bizjid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_bizjid(const std::string& value); + std::string* _internal_mutable_bizjid(); + public: + + // optional string id = 2; + bool has_id() const; + private: + bool _internal_has_id() const; + public: + void clear_id(); + const std::string& id() const; + template + void set_id(ArgT0&& arg0, ArgT... args); + std::string* mutable_id(); + PROTOBUF_NODISCARD std::string* release_id(); + void set_allocated_id(std::string* id); + private: + const std::string& _internal_id() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value); + std::string* _internal_mutable_id(); + public: + + // optional int32 messageVersion = 3; + bool has_messageversion() const; + private: + bool _internal_has_messageversion() const; + public: + void clear_messageversion(); + int32_t messageversion() const; + void set_messageversion(int32_t value); + private: + int32_t _internal_messageversion() const; + void _internal_set_messageversion(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage.CollectionMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bizjid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_; + int32_t messageversion_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_InteractiveMessage_Footer final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage.Footer) */ { + public: + inline Message_InteractiveMessage_Footer() : Message_InteractiveMessage_Footer(nullptr) {} + ~Message_InteractiveMessage_Footer() override; + explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage_Footer(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_InteractiveMessage_Footer(const Message_InteractiveMessage_Footer& from); + Message_InteractiveMessage_Footer(Message_InteractiveMessage_Footer&& from) noexcept + : Message_InteractiveMessage_Footer() { + *this = ::std::move(from); + } + + inline Message_InteractiveMessage_Footer& operator=(const Message_InteractiveMessage_Footer& from) { + CopyFrom(from); + return *this; + } + inline Message_InteractiveMessage_Footer& operator=(Message_InteractiveMessage_Footer&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_InteractiveMessage_Footer& default_instance() { + return *internal_default_instance(); + } + static inline const Message_InteractiveMessage_Footer* internal_default_instance() { + return reinterpret_cast( + &_Message_InteractiveMessage_Footer_default_instance_); + } + static constexpr int kIndexInFileMessages = + 88; + + friend void swap(Message_InteractiveMessage_Footer& a, Message_InteractiveMessage_Footer& b) { + a.Swap(&b); + } + inline void Swap(Message_InteractiveMessage_Footer* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_InteractiveMessage_Footer* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_InteractiveMessage_Footer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_InteractiveMessage_Footer& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_InteractiveMessage_Footer& from) { + Message_InteractiveMessage_Footer::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_InteractiveMessage_Footer* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.InteractiveMessage.Footer"; + } + protected: + explicit Message_InteractiveMessage_Footer(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kTextFieldNumber = 1, + }; + // optional string text = 1; + bool has_text() const; + private: + bool _internal_has_text() const; + public: + void clear_text(); + const std::string& text() const; + template + void set_text(ArgT0&& arg0, ArgT... args); + std::string* mutable_text(); + PROTOBUF_NODISCARD std::string* release_text(); + void set_allocated_text(std::string* text); + private: + const std::string& _internal_text() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value); + std::string* _internal_mutable_text(); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage.Footer) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_InteractiveMessage_Header final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage.Header) */ { + public: + inline Message_InteractiveMessage_Header() : Message_InteractiveMessage_Header(nullptr) {} + ~Message_InteractiveMessage_Header() override; + explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage_Header(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_InteractiveMessage_Header(const Message_InteractiveMessage_Header& from); + Message_InteractiveMessage_Header(Message_InteractiveMessage_Header&& from) noexcept + : Message_InteractiveMessage_Header() { + *this = ::std::move(from); + } + + inline Message_InteractiveMessage_Header& operator=(const Message_InteractiveMessage_Header& from) { + CopyFrom(from); + return *this; + } + inline Message_InteractiveMessage_Header& operator=(Message_InteractiveMessage_Header&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_InteractiveMessage_Header& default_instance() { + return *internal_default_instance(); + } + enum MediaCase { + kDocumentMessage = 3, + kImageMessage = 4, + kJpegThumbnail = 6, + kVideoMessage = 7, + MEDIA_NOT_SET = 0, + }; + + static inline const Message_InteractiveMessage_Header* internal_default_instance() { + return reinterpret_cast( + &_Message_InteractiveMessage_Header_default_instance_); + } + static constexpr int kIndexInFileMessages = + 89; + + friend void swap(Message_InteractiveMessage_Header& a, Message_InteractiveMessage_Header& b) { + a.Swap(&b); + } + inline void Swap(Message_InteractiveMessage_Header* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_InteractiveMessage_Header* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_InteractiveMessage_Header* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_InteractiveMessage_Header& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_InteractiveMessage_Header& from) { + Message_InteractiveMessage_Header::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_InteractiveMessage_Header* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.InteractiveMessage.Header"; + } + protected: + explicit Message_InteractiveMessage_Header(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kTitleFieldNumber = 1, + kSubtitleFieldNumber = 2, + kHasMediaAttachmentFieldNumber = 5, + kDocumentMessageFieldNumber = 3, + kImageMessageFieldNumber = 4, + kJpegThumbnailFieldNumber = 6, + kVideoMessageFieldNumber = 7, + }; + // optional string title = 1; + bool has_title() const; + private: + bool _internal_has_title() const; + public: + void clear_title(); + const std::string& title() const; + template + void set_title(ArgT0&& arg0, ArgT... args); + std::string* mutable_title(); + PROTOBUF_NODISCARD std::string* release_title(); + void set_allocated_title(std::string* title); + private: + const std::string& _internal_title() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value); + std::string* _internal_mutable_title(); + public: + + // optional string subtitle = 2; + bool has_subtitle() const; + private: + bool _internal_has_subtitle() const; + public: + void clear_subtitle(); + const std::string& subtitle() const; + template + void set_subtitle(ArgT0&& arg0, ArgT... args); + std::string* mutable_subtitle(); + PROTOBUF_NODISCARD std::string* release_subtitle(); + void set_allocated_subtitle(std::string* subtitle); + private: + const std::string& _internal_subtitle() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_subtitle(const std::string& value); + std::string* _internal_mutable_subtitle(); + public: + + // optional bool hasMediaAttachment = 5; + bool has_hasmediaattachment() const; + private: + bool _internal_has_hasmediaattachment() const; + public: + void clear_hasmediaattachment(); + bool hasmediaattachment() const; + void set_hasmediaattachment(bool value); + private: + bool _internal_hasmediaattachment() const; + void _internal_set_hasmediaattachment(bool value); + public: + + // .proto.Message.DocumentMessage documentMessage = 3; + bool has_documentmessage() const; + private: + bool _internal_has_documentmessage() const; + public: + void clear_documentmessage(); + const ::proto::Message_DocumentMessage& documentmessage() const; + PROTOBUF_NODISCARD ::proto::Message_DocumentMessage* release_documentmessage(); + ::proto::Message_DocumentMessage* mutable_documentmessage(); + void set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage); + private: + const ::proto::Message_DocumentMessage& _internal_documentmessage() const; + ::proto::Message_DocumentMessage* _internal_mutable_documentmessage(); + public: + void unsafe_arena_set_allocated_documentmessage( + ::proto::Message_DocumentMessage* documentmessage); + ::proto::Message_DocumentMessage* unsafe_arena_release_documentmessage(); + + // .proto.Message.ImageMessage imageMessage = 4; + bool has_imagemessage() const; + private: + bool _internal_has_imagemessage() const; + public: + void clear_imagemessage(); + const ::proto::Message_ImageMessage& imagemessage() const; + PROTOBUF_NODISCARD ::proto::Message_ImageMessage* release_imagemessage(); + ::proto::Message_ImageMessage* mutable_imagemessage(); + void set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage); + private: + const ::proto::Message_ImageMessage& _internal_imagemessage() const; + ::proto::Message_ImageMessage* _internal_mutable_imagemessage(); + public: + void unsafe_arena_set_allocated_imagemessage( + ::proto::Message_ImageMessage* imagemessage); + ::proto::Message_ImageMessage* unsafe_arena_release_imagemessage(); + + // bytes jpegThumbnail = 6; + bool has_jpegthumbnail() const; + private: + bool _internal_has_jpegthumbnail() const; + public: + void clear_jpegthumbnail(); + const std::string& jpegthumbnail() const; + template + void set_jpegthumbnail(ArgT0&& arg0, ArgT... args); + std::string* mutable_jpegthumbnail(); + PROTOBUF_NODISCARD std::string* release_jpegthumbnail(); + void set_allocated_jpegthumbnail(std::string* jpegthumbnail); + private: + const std::string& _internal_jpegthumbnail() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value); + std::string* _internal_mutable_jpegthumbnail(); + public: + + // .proto.Message.VideoMessage videoMessage = 7; + bool has_videomessage() const; + private: + bool _internal_has_videomessage() const; + public: + void clear_videomessage(); + const ::proto::Message_VideoMessage& videomessage() const; + PROTOBUF_NODISCARD ::proto::Message_VideoMessage* release_videomessage(); + ::proto::Message_VideoMessage* mutable_videomessage(); + void set_allocated_videomessage(::proto::Message_VideoMessage* videomessage); + private: + const ::proto::Message_VideoMessage& _internal_videomessage() const; + ::proto::Message_VideoMessage* _internal_mutable_videomessage(); + public: + void unsafe_arena_set_allocated_videomessage( + ::proto::Message_VideoMessage* videomessage); + ::proto::Message_VideoMessage* unsafe_arena_release_videomessage(); + + void clear_media(); + MediaCase media_case() const; + // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage.Header) + private: + class _Internal; + void set_has_documentmessage(); + void set_has_imagemessage(); + void set_has_jpegthumbnail(); + void set_has_videomessage(); + + inline bool has_media() const; + inline void clear_has_media(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr subtitle_; + bool hasmediaattachment_; + union MediaUnion { + constexpr MediaUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::proto::Message_DocumentMessage* documentmessage_; + ::proto::Message_ImageMessage* imagemessage_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_; + ::proto::Message_VideoMessage* videomessage_; + } media_; + uint32_t _oneof_case_[1]; + + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton) */ { + public: + inline Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton() : Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton(nullptr) {} + ~Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton() override; + explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton(const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& from); + Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton(Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton&& from) noexcept + : Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton() { + *this = ::std::move(from); + } + + inline Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& operator=(const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& from) { + CopyFrom(from); + return *this; + } + inline Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& operator=(Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& default_instance() { + return *internal_default_instance(); + } + static inline const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* internal_default_instance() { + return reinterpret_cast( + &_Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton_default_instance_); + } + static constexpr int kIndexInFileMessages = + 90; + + friend void swap(Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& a, Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& b) { + a.Swap(&b); + } + inline void Swap(Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& from) { + Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton"; + } + protected: + explicit Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNameFieldNumber = 1, + kButtonParamsJsonFieldNumber = 2, + }; + // optional string name = 1; + bool has_name() const; + private: + bool _internal_has_name() const; + public: + void clear_name(); + const std::string& name() const; + template + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + PROTOBUF_NODISCARD std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // optional string buttonParamsJson = 2; + bool has_buttonparamsjson() const; + private: + bool _internal_has_buttonparamsjson() const; + public: + void clear_buttonparamsjson(); + const std::string& buttonparamsjson() const; + template + void set_buttonparamsjson(ArgT0&& arg0, ArgT... args); + std::string* mutable_buttonparamsjson(); + PROTOBUF_NODISCARD std::string* release_buttonparamsjson(); + void set_allocated_buttonparamsjson(std::string* buttonparamsjson); + private: + const std::string& _internal_buttonparamsjson() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_buttonparamsjson(const std::string& value); + std::string* _internal_mutable_buttonparamsjson(); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr buttonparamsjson_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_InteractiveMessage_NativeFlowMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage.NativeFlowMessage) */ { + public: + inline Message_InteractiveMessage_NativeFlowMessage() : Message_InteractiveMessage_NativeFlowMessage(nullptr) {} + ~Message_InteractiveMessage_NativeFlowMessage() override; + explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage_NativeFlowMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_InteractiveMessage_NativeFlowMessage(const Message_InteractiveMessage_NativeFlowMessage& from); + Message_InteractiveMessage_NativeFlowMessage(Message_InteractiveMessage_NativeFlowMessage&& from) noexcept + : Message_InteractiveMessage_NativeFlowMessage() { + *this = ::std::move(from); + } + + inline Message_InteractiveMessage_NativeFlowMessage& operator=(const Message_InteractiveMessage_NativeFlowMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_InteractiveMessage_NativeFlowMessage& operator=(Message_InteractiveMessage_NativeFlowMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_InteractiveMessage_NativeFlowMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_InteractiveMessage_NativeFlowMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_InteractiveMessage_NativeFlowMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 91; + + friend void swap(Message_InteractiveMessage_NativeFlowMessage& a, Message_InteractiveMessage_NativeFlowMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_InteractiveMessage_NativeFlowMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_InteractiveMessage_NativeFlowMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_InteractiveMessage_NativeFlowMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_InteractiveMessage_NativeFlowMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_InteractiveMessage_NativeFlowMessage& from) { + Message_InteractiveMessage_NativeFlowMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_InteractiveMessage_NativeFlowMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.InteractiveMessage.NativeFlowMessage"; + } + protected: + explicit Message_InteractiveMessage_NativeFlowMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton NativeFlowButton; + + // accessors ------------------------------------------------------- + + enum : int { + kButtonsFieldNumber = 1, + kMessageParamsJsonFieldNumber = 2, + kMessageVersionFieldNumber = 3, + }; + // repeated .proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton buttons = 1; + int buttons_size() const; + private: + int _internal_buttons_size() const; + public: + void clear_buttons(); + ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* mutable_buttons(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton >* + mutable_buttons(); + private: + const ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& _internal_buttons(int index) const; + ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* _internal_add_buttons(); + public: + const ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& buttons(int index) const; + ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* add_buttons(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton >& + buttons() const; + + // optional string messageParamsJson = 2; + bool has_messageparamsjson() const; + private: + bool _internal_has_messageparamsjson() const; + public: + void clear_messageparamsjson(); + const std::string& messageparamsjson() const; + template + void set_messageparamsjson(ArgT0&& arg0, ArgT... args); + std::string* mutable_messageparamsjson(); + PROTOBUF_NODISCARD std::string* release_messageparamsjson(); + void set_allocated_messageparamsjson(std::string* messageparamsjson); + private: + const std::string& _internal_messageparamsjson() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_messageparamsjson(const std::string& value); + std::string* _internal_mutable_messageparamsjson(); + public: + + // optional int32 messageVersion = 3; + bool has_messageversion() const; + private: + bool _internal_has_messageversion() const; + public: + void clear_messageversion(); + int32_t messageversion() const; + void set_messageversion(int32_t value); + private: + int32_t _internal_messageversion() const; + void _internal_set_messageversion(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage.NativeFlowMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton > buttons_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr messageparamsjson_; + int32_t messageversion_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_InteractiveMessage_ShopMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage.ShopMessage) */ { + public: + inline Message_InteractiveMessage_ShopMessage() : Message_InteractiveMessage_ShopMessage(nullptr) {} + ~Message_InteractiveMessage_ShopMessage() override; + explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage_ShopMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_InteractiveMessage_ShopMessage(const Message_InteractiveMessage_ShopMessage& from); + Message_InteractiveMessage_ShopMessage(Message_InteractiveMessage_ShopMessage&& from) noexcept + : Message_InteractiveMessage_ShopMessage() { + *this = ::std::move(from); + } + + inline Message_InteractiveMessage_ShopMessage& operator=(const Message_InteractiveMessage_ShopMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_InteractiveMessage_ShopMessage& operator=(Message_InteractiveMessage_ShopMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_InteractiveMessage_ShopMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_InteractiveMessage_ShopMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_InteractiveMessage_ShopMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 92; + + friend void swap(Message_InteractiveMessage_ShopMessage& a, Message_InteractiveMessage_ShopMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_InteractiveMessage_ShopMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_InteractiveMessage_ShopMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_InteractiveMessage_ShopMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_InteractiveMessage_ShopMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_InteractiveMessage_ShopMessage& from) { + Message_InteractiveMessage_ShopMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_InteractiveMessage_ShopMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.InteractiveMessage.ShopMessage"; + } + protected: + explicit Message_InteractiveMessage_ShopMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Message_InteractiveMessage_ShopMessage_Surface Surface; + static constexpr Surface UNKNOWN_SURFACE = + Message_InteractiveMessage_ShopMessage_Surface_UNKNOWN_SURFACE; + static constexpr Surface FB = + Message_InteractiveMessage_ShopMessage_Surface_FB; + static constexpr Surface IG = + Message_InteractiveMessage_ShopMessage_Surface_IG; + static constexpr Surface WA = + Message_InteractiveMessage_ShopMessage_Surface_WA; + static inline bool Surface_IsValid(int value) { + return Message_InteractiveMessage_ShopMessage_Surface_IsValid(value); + } + static constexpr Surface Surface_MIN = + Message_InteractiveMessage_ShopMessage_Surface_Surface_MIN; + static constexpr Surface Surface_MAX = + Message_InteractiveMessage_ShopMessage_Surface_Surface_MAX; + static constexpr int Surface_ARRAYSIZE = + Message_InteractiveMessage_ShopMessage_Surface_Surface_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + Surface_descriptor() { + return Message_InteractiveMessage_ShopMessage_Surface_descriptor(); + } + template + static inline const std::string& Surface_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Surface_Name."); + return Message_InteractiveMessage_ShopMessage_Surface_Name(enum_t_value); + } + static inline bool Surface_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Surface* value) { + return Message_InteractiveMessage_ShopMessage_Surface_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kIdFieldNumber = 1, + kSurfaceFieldNumber = 2, + kMessageVersionFieldNumber = 3, + }; + // optional string id = 1; + bool has_id() const; + private: + bool _internal_has_id() const; + public: + void clear_id(); + const std::string& id() const; + template + void set_id(ArgT0&& arg0, ArgT... args); + std::string* mutable_id(); + PROTOBUF_NODISCARD std::string* release_id(); + void set_allocated_id(std::string* id); + private: + const std::string& _internal_id() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value); + std::string* _internal_mutable_id(); + public: + + // optional .proto.Message.InteractiveMessage.ShopMessage.Surface surface = 2; + bool has_surface() const; + private: + bool _internal_has_surface() const; + public: + void clear_surface(); + ::proto::Message_InteractiveMessage_ShopMessage_Surface surface() const; + void set_surface(::proto::Message_InteractiveMessage_ShopMessage_Surface value); + private: + ::proto::Message_InteractiveMessage_ShopMessage_Surface _internal_surface() const; + void _internal_set_surface(::proto::Message_InteractiveMessage_ShopMessage_Surface value); + public: + + // optional int32 messageVersion = 3; + bool has_messageversion() const; + private: + bool _internal_has_messageversion() const; + public: + void clear_messageversion(); + int32_t messageversion() const; + void set_messageversion(int32_t value); + private: + int32_t _internal_messageversion() const; + void _internal_set_messageversion(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage.ShopMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_; + int surface_; + int32_t messageversion_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_InteractiveMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage) */ { + public: + inline Message_InteractiveMessage() : Message_InteractiveMessage(nullptr) {} + ~Message_InteractiveMessage() override; + explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_InteractiveMessage(const Message_InteractiveMessage& from); + Message_InteractiveMessage(Message_InteractiveMessage&& from) noexcept + : Message_InteractiveMessage() { + *this = ::std::move(from); + } + + inline Message_InteractiveMessage& operator=(const Message_InteractiveMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_InteractiveMessage& operator=(Message_InteractiveMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_InteractiveMessage& default_instance() { + return *internal_default_instance(); + } + enum InteractiveMessageCase { + kShopStorefrontMessage = 4, + kCollectionMessage = 5, + kNativeFlowMessage = 6, + INTERACTIVEMESSAGE_NOT_SET = 0, + }; + + static inline const Message_InteractiveMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_InteractiveMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 93; + + friend void swap(Message_InteractiveMessage& a, Message_InteractiveMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_InteractiveMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_InteractiveMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_InteractiveMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_InteractiveMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_InteractiveMessage& from) { + Message_InteractiveMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_InteractiveMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.InteractiveMessage"; + } + protected: + explicit Message_InteractiveMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Message_InteractiveMessage_Body Body; + typedef Message_InteractiveMessage_CollectionMessage CollectionMessage; + typedef Message_InteractiveMessage_Footer Footer; + typedef Message_InteractiveMessage_Header Header; + typedef Message_InteractiveMessage_NativeFlowMessage NativeFlowMessage; + typedef Message_InteractiveMessage_ShopMessage ShopMessage; + + // accessors ------------------------------------------------------- + + enum : int { + kHeaderFieldNumber = 1, + kBodyFieldNumber = 2, + kFooterFieldNumber = 3, + kContextInfoFieldNumber = 15, + kShopStorefrontMessageFieldNumber = 4, + kCollectionMessageFieldNumber = 5, + kNativeFlowMessageFieldNumber = 6, + }; + // optional .proto.Message.InteractiveMessage.Header header = 1; + bool has_header() const; + private: + bool _internal_has_header() const; + public: + void clear_header(); + const ::proto::Message_InteractiveMessage_Header& header() const; + PROTOBUF_NODISCARD ::proto::Message_InteractiveMessage_Header* release_header(); + ::proto::Message_InteractiveMessage_Header* mutable_header(); + void set_allocated_header(::proto::Message_InteractiveMessage_Header* header); + private: + const ::proto::Message_InteractiveMessage_Header& _internal_header() const; + ::proto::Message_InteractiveMessage_Header* _internal_mutable_header(); + public: + void unsafe_arena_set_allocated_header( + ::proto::Message_InteractiveMessage_Header* header); + ::proto::Message_InteractiveMessage_Header* unsafe_arena_release_header(); + + // optional .proto.Message.InteractiveMessage.Body body = 2; + bool has_body() const; + private: + bool _internal_has_body() const; + public: + void clear_body(); + const ::proto::Message_InteractiveMessage_Body& body() const; + PROTOBUF_NODISCARD ::proto::Message_InteractiveMessage_Body* release_body(); + ::proto::Message_InteractiveMessage_Body* mutable_body(); + void set_allocated_body(::proto::Message_InteractiveMessage_Body* body); + private: + const ::proto::Message_InteractiveMessage_Body& _internal_body() const; + ::proto::Message_InteractiveMessage_Body* _internal_mutable_body(); + public: + void unsafe_arena_set_allocated_body( + ::proto::Message_InteractiveMessage_Body* body); + ::proto::Message_InteractiveMessage_Body* unsafe_arena_release_body(); + + // optional .proto.Message.InteractiveMessage.Footer footer = 3; + bool has_footer() const; + private: + bool _internal_has_footer() const; + public: + void clear_footer(); + const ::proto::Message_InteractiveMessage_Footer& footer() const; + PROTOBUF_NODISCARD ::proto::Message_InteractiveMessage_Footer* release_footer(); + ::proto::Message_InteractiveMessage_Footer* mutable_footer(); + void set_allocated_footer(::proto::Message_InteractiveMessage_Footer* footer); + private: + const ::proto::Message_InteractiveMessage_Footer& _internal_footer() const; + ::proto::Message_InteractiveMessage_Footer* _internal_mutable_footer(); + public: + void unsafe_arena_set_allocated_footer( + ::proto::Message_InteractiveMessage_Footer* footer); + ::proto::Message_InteractiveMessage_Footer* unsafe_arena_release_footer(); + + // optional .proto.ContextInfo contextInfo = 15; + bool has_contextinfo() const; + private: + bool _internal_has_contextinfo() const; + public: + void clear_contextinfo(); + const ::proto::ContextInfo& contextinfo() const; + PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); + ::proto::ContextInfo* mutable_contextinfo(); + void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); + private: + const ::proto::ContextInfo& _internal_contextinfo() const; + ::proto::ContextInfo* _internal_mutable_contextinfo(); + public: + void unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo); + ::proto::ContextInfo* unsafe_arena_release_contextinfo(); + + // .proto.Message.InteractiveMessage.ShopMessage shopStorefrontMessage = 4; + bool has_shopstorefrontmessage() const; + private: + bool _internal_has_shopstorefrontmessage() const; + public: + void clear_shopstorefrontmessage(); + const ::proto::Message_InteractiveMessage_ShopMessage& shopstorefrontmessage() const; + PROTOBUF_NODISCARD ::proto::Message_InteractiveMessage_ShopMessage* release_shopstorefrontmessage(); + ::proto::Message_InteractiveMessage_ShopMessage* mutable_shopstorefrontmessage(); + void set_allocated_shopstorefrontmessage(::proto::Message_InteractiveMessage_ShopMessage* shopstorefrontmessage); + private: + const ::proto::Message_InteractiveMessage_ShopMessage& _internal_shopstorefrontmessage() const; + ::proto::Message_InteractiveMessage_ShopMessage* _internal_mutable_shopstorefrontmessage(); + public: + void unsafe_arena_set_allocated_shopstorefrontmessage( + ::proto::Message_InteractiveMessage_ShopMessage* shopstorefrontmessage); + ::proto::Message_InteractiveMessage_ShopMessage* unsafe_arena_release_shopstorefrontmessage(); + + // .proto.Message.InteractiveMessage.CollectionMessage collectionMessage = 5; + bool has_collectionmessage() const; + private: + bool _internal_has_collectionmessage() const; + public: + void clear_collectionmessage(); + const ::proto::Message_InteractiveMessage_CollectionMessage& collectionmessage() const; + PROTOBUF_NODISCARD ::proto::Message_InteractiveMessage_CollectionMessage* release_collectionmessage(); + ::proto::Message_InteractiveMessage_CollectionMessage* mutable_collectionmessage(); + void set_allocated_collectionmessage(::proto::Message_InteractiveMessage_CollectionMessage* collectionmessage); + private: + const ::proto::Message_InteractiveMessage_CollectionMessage& _internal_collectionmessage() const; + ::proto::Message_InteractiveMessage_CollectionMessage* _internal_mutable_collectionmessage(); + public: + void unsafe_arena_set_allocated_collectionmessage( + ::proto::Message_InteractiveMessage_CollectionMessage* collectionmessage); + ::proto::Message_InteractiveMessage_CollectionMessage* unsafe_arena_release_collectionmessage(); + + // .proto.Message.InteractiveMessage.NativeFlowMessage nativeFlowMessage = 6; + bool has_nativeflowmessage() const; + private: + bool _internal_has_nativeflowmessage() const; + public: + void clear_nativeflowmessage(); + const ::proto::Message_InteractiveMessage_NativeFlowMessage& nativeflowmessage() const; + PROTOBUF_NODISCARD ::proto::Message_InteractiveMessage_NativeFlowMessage* release_nativeflowmessage(); + ::proto::Message_InteractiveMessage_NativeFlowMessage* mutable_nativeflowmessage(); + void set_allocated_nativeflowmessage(::proto::Message_InteractiveMessage_NativeFlowMessage* nativeflowmessage); + private: + const ::proto::Message_InteractiveMessage_NativeFlowMessage& _internal_nativeflowmessage() const; + ::proto::Message_InteractiveMessage_NativeFlowMessage* _internal_mutable_nativeflowmessage(); + public: + void unsafe_arena_set_allocated_nativeflowmessage( + ::proto::Message_InteractiveMessage_NativeFlowMessage* nativeflowmessage); + ::proto::Message_InteractiveMessage_NativeFlowMessage* unsafe_arena_release_nativeflowmessage(); + + void clear_interactiveMessage(); + InteractiveMessageCase interactiveMessage_case() const; + // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage) + private: + class _Internal; + void set_has_shopstorefrontmessage(); + void set_has_collectionmessage(); + void set_has_nativeflowmessage(); + + inline bool has_interactiveMessage() const; + inline void clear_has_interactiveMessage(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::proto::Message_InteractiveMessage_Header* header_; + ::proto::Message_InteractiveMessage_Body* body_; + ::proto::Message_InteractiveMessage_Footer* footer_; + ::proto::ContextInfo* contextinfo_; + union InteractiveMessageUnion { + constexpr InteractiveMessageUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::proto::Message_InteractiveMessage_ShopMessage* shopstorefrontmessage_; + ::proto::Message_InteractiveMessage_CollectionMessage* collectionmessage_; + ::proto::Message_InteractiveMessage_NativeFlowMessage* nativeflowmessage_; + } interactiveMessage_; + uint32_t _oneof_case_[1]; + + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_InteractiveResponseMessage_Body final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveResponseMessage.Body) */ { + public: + inline Message_InteractiveResponseMessage_Body() : Message_InteractiveResponseMessage_Body(nullptr) {} + ~Message_InteractiveResponseMessage_Body() override; + explicit PROTOBUF_CONSTEXPR Message_InteractiveResponseMessage_Body(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_InteractiveResponseMessage_Body(const Message_InteractiveResponseMessage_Body& from); + Message_InteractiveResponseMessage_Body(Message_InteractiveResponseMessage_Body&& from) noexcept + : Message_InteractiveResponseMessage_Body() { + *this = ::std::move(from); + } + + inline Message_InteractiveResponseMessage_Body& operator=(const Message_InteractiveResponseMessage_Body& from) { + CopyFrom(from); + return *this; + } + inline Message_InteractiveResponseMessage_Body& operator=(Message_InteractiveResponseMessage_Body&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_InteractiveResponseMessage_Body& default_instance() { + return *internal_default_instance(); + } + static inline const Message_InteractiveResponseMessage_Body* internal_default_instance() { + return reinterpret_cast( + &_Message_InteractiveResponseMessage_Body_default_instance_); + } + static constexpr int kIndexInFileMessages = + 94; + + friend void swap(Message_InteractiveResponseMessage_Body& a, Message_InteractiveResponseMessage_Body& b) { + a.Swap(&b); + } + inline void Swap(Message_InteractiveResponseMessage_Body* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_InteractiveResponseMessage_Body* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_InteractiveResponseMessage_Body* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_InteractiveResponseMessage_Body& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_InteractiveResponseMessage_Body& from) { + Message_InteractiveResponseMessage_Body::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_InteractiveResponseMessage_Body* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.InteractiveResponseMessage.Body"; + } + protected: + explicit Message_InteractiveResponseMessage_Body(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kTextFieldNumber = 1, + }; + // optional string text = 1; + bool has_text() const; + private: + bool _internal_has_text() const; + public: + void clear_text(); + const std::string& text() const; + template + void set_text(ArgT0&& arg0, ArgT... args); + std::string* mutable_text(); + PROTOBUF_NODISCARD std::string* release_text(); + void set_allocated_text(std::string* text); + private: + const std::string& _internal_text() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value); + std::string* _internal_mutable_text(); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.InteractiveResponseMessage.Body) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_InteractiveResponseMessage_NativeFlowResponseMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage) */ { + public: + inline Message_InteractiveResponseMessage_NativeFlowResponseMessage() : Message_InteractiveResponseMessage_NativeFlowResponseMessage(nullptr) {} + ~Message_InteractiveResponseMessage_NativeFlowResponseMessage() override; + explicit PROTOBUF_CONSTEXPR Message_InteractiveResponseMessage_NativeFlowResponseMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_InteractiveResponseMessage_NativeFlowResponseMessage(const Message_InteractiveResponseMessage_NativeFlowResponseMessage& from); + Message_InteractiveResponseMessage_NativeFlowResponseMessage(Message_InteractiveResponseMessage_NativeFlowResponseMessage&& from) noexcept + : Message_InteractiveResponseMessage_NativeFlowResponseMessage() { + *this = ::std::move(from); + } + + inline Message_InteractiveResponseMessage_NativeFlowResponseMessage& operator=(const Message_InteractiveResponseMessage_NativeFlowResponseMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_InteractiveResponseMessage_NativeFlowResponseMessage& operator=(Message_InteractiveResponseMessage_NativeFlowResponseMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_InteractiveResponseMessage_NativeFlowResponseMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_InteractiveResponseMessage_NativeFlowResponseMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_InteractiveResponseMessage_NativeFlowResponseMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 95; + + friend void swap(Message_InteractiveResponseMessage_NativeFlowResponseMessage& a, Message_InteractiveResponseMessage_NativeFlowResponseMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_InteractiveResponseMessage_NativeFlowResponseMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_InteractiveResponseMessage_NativeFlowResponseMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_InteractiveResponseMessage_NativeFlowResponseMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_InteractiveResponseMessage_NativeFlowResponseMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_InteractiveResponseMessage_NativeFlowResponseMessage& from) { + Message_InteractiveResponseMessage_NativeFlowResponseMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_InteractiveResponseMessage_NativeFlowResponseMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage"; + } + protected: + explicit Message_InteractiveResponseMessage_NativeFlowResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNameFieldNumber = 1, + kParamsJsonFieldNumber = 2, + kVersionFieldNumber = 3, + }; + // optional string name = 1; + bool has_name() const; + private: + bool _internal_has_name() const; + public: + void clear_name(); + const std::string& name() const; + template + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + PROTOBUF_NODISCARD std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // optional string paramsJson = 2; + bool has_paramsjson() const; + private: + bool _internal_has_paramsjson() const; + public: + void clear_paramsjson(); + const std::string& paramsjson() const; + template + void set_paramsjson(ArgT0&& arg0, ArgT... args); + std::string* mutable_paramsjson(); + PROTOBUF_NODISCARD std::string* release_paramsjson(); + void set_allocated_paramsjson(std::string* paramsjson); + private: + const std::string& _internal_paramsjson() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_paramsjson(const std::string& value); + std::string* _internal_mutable_paramsjson(); + public: + + // optional int32 version = 3; + bool has_version() const; + private: + bool _internal_has_version() const; + public: + void clear_version(); + int32_t version() const; + void set_version(int32_t value); + private: + int32_t _internal_version() const; + void _internal_set_version(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr paramsjson_; + int32_t version_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_InteractiveResponseMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveResponseMessage) */ { + public: + inline Message_InteractiveResponseMessage() : Message_InteractiveResponseMessage(nullptr) {} + ~Message_InteractiveResponseMessage() override; + explicit PROTOBUF_CONSTEXPR Message_InteractiveResponseMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_InteractiveResponseMessage(const Message_InteractiveResponseMessage& from); + Message_InteractiveResponseMessage(Message_InteractiveResponseMessage&& from) noexcept + : Message_InteractiveResponseMessage() { + *this = ::std::move(from); + } + + inline Message_InteractiveResponseMessage& operator=(const Message_InteractiveResponseMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_InteractiveResponseMessage& operator=(Message_InteractiveResponseMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_InteractiveResponseMessage& default_instance() { + return *internal_default_instance(); + } + enum InteractiveResponseMessageCase { + kNativeFlowResponseMessage = 2, + INTERACTIVERESPONSEMESSAGE_NOT_SET = 0, + }; + + static inline const Message_InteractiveResponseMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_InteractiveResponseMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 96; + + friend void swap(Message_InteractiveResponseMessage& a, Message_InteractiveResponseMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_InteractiveResponseMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_InteractiveResponseMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_InteractiveResponseMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_InteractiveResponseMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_InteractiveResponseMessage& from) { + Message_InteractiveResponseMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_InteractiveResponseMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.InteractiveResponseMessage"; + } + protected: + explicit Message_InteractiveResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Message_InteractiveResponseMessage_Body Body; + typedef Message_InteractiveResponseMessage_NativeFlowResponseMessage NativeFlowResponseMessage; + + // accessors ------------------------------------------------------- + + enum : int { + kBodyFieldNumber = 1, + kContextInfoFieldNumber = 15, + kNativeFlowResponseMessageFieldNumber = 2, + }; + // optional .proto.Message.InteractiveResponseMessage.Body body = 1; + bool has_body() const; + private: + bool _internal_has_body() const; + public: + void clear_body(); + const ::proto::Message_InteractiveResponseMessage_Body& body() const; + PROTOBUF_NODISCARD ::proto::Message_InteractiveResponseMessage_Body* release_body(); + ::proto::Message_InteractiveResponseMessage_Body* mutable_body(); + void set_allocated_body(::proto::Message_InteractiveResponseMessage_Body* body); + private: + const ::proto::Message_InteractiveResponseMessage_Body& _internal_body() const; + ::proto::Message_InteractiveResponseMessage_Body* _internal_mutable_body(); + public: + void unsafe_arena_set_allocated_body( + ::proto::Message_InteractiveResponseMessage_Body* body); + ::proto::Message_InteractiveResponseMessage_Body* unsafe_arena_release_body(); + + // optional .proto.ContextInfo contextInfo = 15; + bool has_contextinfo() const; + private: + bool _internal_has_contextinfo() const; + public: + void clear_contextinfo(); + const ::proto::ContextInfo& contextinfo() const; + PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); + ::proto::ContextInfo* mutable_contextinfo(); + void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); + private: + const ::proto::ContextInfo& _internal_contextinfo() const; + ::proto::ContextInfo* _internal_mutable_contextinfo(); + public: + void unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo); + ::proto::ContextInfo* unsafe_arena_release_contextinfo(); + + // .proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage nativeFlowResponseMessage = 2; + bool has_nativeflowresponsemessage() const; + private: + bool _internal_has_nativeflowresponsemessage() const; + public: + void clear_nativeflowresponsemessage(); + const ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage& nativeflowresponsemessage() const; + PROTOBUF_NODISCARD ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* release_nativeflowresponsemessage(); + ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* mutable_nativeflowresponsemessage(); + void set_allocated_nativeflowresponsemessage(::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* nativeflowresponsemessage); + private: + const ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage& _internal_nativeflowresponsemessage() const; + ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* _internal_mutable_nativeflowresponsemessage(); + public: + void unsafe_arena_set_allocated_nativeflowresponsemessage( + ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* nativeflowresponsemessage); + ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* unsafe_arena_release_nativeflowresponsemessage(); + + void clear_interactiveResponseMessage(); + InteractiveResponseMessageCase interactiveResponseMessage_case() const; + // @@protoc_insertion_point(class_scope:proto.Message.InteractiveResponseMessage) + private: + class _Internal; + void set_has_nativeflowresponsemessage(); + + inline bool has_interactiveResponseMessage() const; + inline void clear_has_interactiveResponseMessage(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::proto::Message_InteractiveResponseMessage_Body* body_; + ::proto::ContextInfo* contextinfo_; + union InteractiveResponseMessageUnion { + constexpr InteractiveResponseMessageUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* nativeflowresponsemessage_; + } interactiveResponseMessage_; + uint32_t _oneof_case_[1]; + + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_InvoiceMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InvoiceMessage) */ { + public: + inline Message_InvoiceMessage() : Message_InvoiceMessage(nullptr) {} + ~Message_InvoiceMessage() override; + explicit PROTOBUF_CONSTEXPR Message_InvoiceMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_InvoiceMessage(const Message_InvoiceMessage& from); + Message_InvoiceMessage(Message_InvoiceMessage&& from) noexcept + : Message_InvoiceMessage() { + *this = ::std::move(from); + } + + inline Message_InvoiceMessage& operator=(const Message_InvoiceMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_InvoiceMessage& operator=(Message_InvoiceMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_InvoiceMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_InvoiceMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_InvoiceMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 97; + + friend void swap(Message_InvoiceMessage& a, Message_InvoiceMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_InvoiceMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_InvoiceMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_InvoiceMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_InvoiceMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_InvoiceMessage& from) { + Message_InvoiceMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_InvoiceMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.InvoiceMessage"; + } + protected: + explicit Message_InvoiceMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Message_InvoiceMessage_AttachmentType AttachmentType; + static constexpr AttachmentType IMAGE = + Message_InvoiceMessage_AttachmentType_IMAGE; + static constexpr AttachmentType PDF = + Message_InvoiceMessage_AttachmentType_PDF; + static inline bool AttachmentType_IsValid(int value) { + return Message_InvoiceMessage_AttachmentType_IsValid(value); + } + static constexpr AttachmentType AttachmentType_MIN = + Message_InvoiceMessage_AttachmentType_AttachmentType_MIN; + static constexpr AttachmentType AttachmentType_MAX = + Message_InvoiceMessage_AttachmentType_AttachmentType_MAX; + static constexpr int AttachmentType_ARRAYSIZE = + Message_InvoiceMessage_AttachmentType_AttachmentType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + AttachmentType_descriptor() { + return Message_InvoiceMessage_AttachmentType_descriptor(); + } + template + static inline const std::string& AttachmentType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function AttachmentType_Name."); + return Message_InvoiceMessage_AttachmentType_Name(enum_t_value); + } + static inline bool AttachmentType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + AttachmentType* value) { + return Message_InvoiceMessage_AttachmentType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kNoteFieldNumber = 1, + kTokenFieldNumber = 2, + kAttachmentMimetypeFieldNumber = 4, + kAttachmentMediaKeyFieldNumber = 5, + kAttachmentFileSha256FieldNumber = 7, + kAttachmentFileEncSha256FieldNumber = 8, + kAttachmentDirectPathFieldNumber = 9, + kAttachmentJpegThumbnailFieldNumber = 10, + kAttachmentMediaKeyTimestampFieldNumber = 6, + kAttachmentTypeFieldNumber = 3, + }; + // optional string note = 1; + bool has_note() const; + private: + bool _internal_has_note() const; + public: + void clear_note(); + const std::string& note() const; + template + void set_note(ArgT0&& arg0, ArgT... args); + std::string* mutable_note(); + PROTOBUF_NODISCARD std::string* release_note(); + void set_allocated_note(std::string* note); + private: + const std::string& _internal_note() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_note(const std::string& value); + std::string* _internal_mutable_note(); + public: + + // optional string token = 2; + bool has_token() const; + private: + bool _internal_has_token() const; + public: + void clear_token(); + const std::string& token() const; + template + void set_token(ArgT0&& arg0, ArgT... args); + std::string* mutable_token(); + PROTOBUF_NODISCARD std::string* release_token(); + void set_allocated_token(std::string* token); + private: + const std::string& _internal_token() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_token(const std::string& value); + std::string* _internal_mutable_token(); + public: + + // optional string attachmentMimetype = 4; + bool has_attachmentmimetype() const; + private: + bool _internal_has_attachmentmimetype() const; + public: + void clear_attachmentmimetype(); + const std::string& attachmentmimetype() const; + template + void set_attachmentmimetype(ArgT0&& arg0, ArgT... args); + std::string* mutable_attachmentmimetype(); + PROTOBUF_NODISCARD std::string* release_attachmentmimetype(); + void set_allocated_attachmentmimetype(std::string* attachmentmimetype); + private: + const std::string& _internal_attachmentmimetype() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_attachmentmimetype(const std::string& value); + std::string* _internal_mutable_attachmentmimetype(); + public: + + // optional bytes attachmentMediaKey = 5; + bool has_attachmentmediakey() const; + private: + bool _internal_has_attachmentmediakey() const; + public: + void clear_attachmentmediakey(); + const std::string& attachmentmediakey() const; + template + void set_attachmentmediakey(ArgT0&& arg0, ArgT... args); + std::string* mutable_attachmentmediakey(); + PROTOBUF_NODISCARD std::string* release_attachmentmediakey(); + void set_allocated_attachmentmediakey(std::string* attachmentmediakey); + private: + const std::string& _internal_attachmentmediakey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_attachmentmediakey(const std::string& value); + std::string* _internal_mutable_attachmentmediakey(); + public: + + // optional bytes attachmentFileSha256 = 7; + bool has_attachmentfilesha256() const; + private: + bool _internal_has_attachmentfilesha256() const; + public: + void clear_attachmentfilesha256(); + const std::string& attachmentfilesha256() const; + template + void set_attachmentfilesha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_attachmentfilesha256(); + PROTOBUF_NODISCARD std::string* release_attachmentfilesha256(); + void set_allocated_attachmentfilesha256(std::string* attachmentfilesha256); + private: + const std::string& _internal_attachmentfilesha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_attachmentfilesha256(const std::string& value); + std::string* _internal_mutable_attachmentfilesha256(); + public: + + // optional bytes attachmentFileEncSha256 = 8; + bool has_attachmentfileencsha256() const; + private: + bool _internal_has_attachmentfileencsha256() const; + public: + void clear_attachmentfileencsha256(); + const std::string& attachmentfileencsha256() const; + template + void set_attachmentfileencsha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_attachmentfileencsha256(); + PROTOBUF_NODISCARD std::string* release_attachmentfileencsha256(); + void set_allocated_attachmentfileencsha256(std::string* attachmentfileencsha256); + private: + const std::string& _internal_attachmentfileencsha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_attachmentfileencsha256(const std::string& value); + std::string* _internal_mutable_attachmentfileencsha256(); + public: + + // optional string attachmentDirectPath = 9; + bool has_attachmentdirectpath() const; + private: + bool _internal_has_attachmentdirectpath() const; + public: + void clear_attachmentdirectpath(); + const std::string& attachmentdirectpath() const; + template + void set_attachmentdirectpath(ArgT0&& arg0, ArgT... args); + std::string* mutable_attachmentdirectpath(); + PROTOBUF_NODISCARD std::string* release_attachmentdirectpath(); + void set_allocated_attachmentdirectpath(std::string* attachmentdirectpath); + private: + const std::string& _internal_attachmentdirectpath() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_attachmentdirectpath(const std::string& value); + std::string* _internal_mutable_attachmentdirectpath(); + public: + + // optional bytes attachmentJpegThumbnail = 10; + bool has_attachmentjpegthumbnail() const; + private: + bool _internal_has_attachmentjpegthumbnail() const; + public: + void clear_attachmentjpegthumbnail(); + const std::string& attachmentjpegthumbnail() const; + template + void set_attachmentjpegthumbnail(ArgT0&& arg0, ArgT... args); + std::string* mutable_attachmentjpegthumbnail(); + PROTOBUF_NODISCARD std::string* release_attachmentjpegthumbnail(); + void set_allocated_attachmentjpegthumbnail(std::string* attachmentjpegthumbnail); + private: + const std::string& _internal_attachmentjpegthumbnail() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_attachmentjpegthumbnail(const std::string& value); + std::string* _internal_mutable_attachmentjpegthumbnail(); + public: + + // optional int64 attachmentMediaKeyTimestamp = 6; + bool has_attachmentmediakeytimestamp() const; + private: + bool _internal_has_attachmentmediakeytimestamp() const; + public: + void clear_attachmentmediakeytimestamp(); + int64_t attachmentmediakeytimestamp() const; + void set_attachmentmediakeytimestamp(int64_t value); + private: + int64_t _internal_attachmentmediakeytimestamp() const; + void _internal_set_attachmentmediakeytimestamp(int64_t value); + public: + + // optional .proto.Message.InvoiceMessage.AttachmentType attachmentType = 3; + bool has_attachmenttype() const; + private: + bool _internal_has_attachmenttype() const; + public: + void clear_attachmenttype(); + ::proto::Message_InvoiceMessage_AttachmentType attachmenttype() const; + void set_attachmenttype(::proto::Message_InvoiceMessage_AttachmentType value); + private: + ::proto::Message_InvoiceMessage_AttachmentType _internal_attachmenttype() const; + void _internal_set_attachmenttype(::proto::Message_InvoiceMessage_AttachmentType value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.InvoiceMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr note_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr token_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr attachmentmimetype_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr attachmentmediakey_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr attachmentfilesha256_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr attachmentfileencsha256_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr attachmentdirectpath_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr attachmentjpegthumbnail_; + int64_t attachmentmediakeytimestamp_; + int attachmenttype_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_KeepInChatMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.KeepInChatMessage) */ { + public: + inline Message_KeepInChatMessage() : Message_KeepInChatMessage(nullptr) {} + ~Message_KeepInChatMessage() override; + explicit PROTOBUF_CONSTEXPR Message_KeepInChatMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_KeepInChatMessage(const Message_KeepInChatMessage& from); + Message_KeepInChatMessage(Message_KeepInChatMessage&& from) noexcept + : Message_KeepInChatMessage() { + *this = ::std::move(from); + } + + inline Message_KeepInChatMessage& operator=(const Message_KeepInChatMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_KeepInChatMessage& operator=(Message_KeepInChatMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_KeepInChatMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_KeepInChatMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_KeepInChatMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 98; + + friend void swap(Message_KeepInChatMessage& a, Message_KeepInChatMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_KeepInChatMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_KeepInChatMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_KeepInChatMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_KeepInChatMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_KeepInChatMessage& from) { + Message_KeepInChatMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_KeepInChatMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.KeepInChatMessage"; + } + protected: + explicit Message_KeepInChatMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kKeyFieldNumber = 1, + kTimestampMsFieldNumber = 3, + kKeepTypeFieldNumber = 2, + }; + // optional .proto.MessageKey key = 1; + bool has_key() const; + private: + bool _internal_has_key() const; + public: + void clear_key(); + const ::proto::MessageKey& key() const; + PROTOBUF_NODISCARD ::proto::MessageKey* release_key(); + ::proto::MessageKey* mutable_key(); + void set_allocated_key(::proto::MessageKey* key); + private: + const ::proto::MessageKey& _internal_key() const; + ::proto::MessageKey* _internal_mutable_key(); + public: + void unsafe_arena_set_allocated_key( + ::proto::MessageKey* key); + ::proto::MessageKey* unsafe_arena_release_key(); + + // optional int64 timestampMs = 3; + bool has_timestampms() const; + private: + bool _internal_has_timestampms() const; + public: + void clear_timestampms(); + int64_t timestampms() const; + void set_timestampms(int64_t value); + private: + int64_t _internal_timestampms() const; + void _internal_set_timestampms(int64_t value); + public: + + // optional .proto.KeepType keepType = 2; + bool has_keeptype() const; + private: + bool _internal_has_keeptype() const; + public: + void clear_keeptype(); + ::proto::KeepType keeptype() const; + void set_keeptype(::proto::KeepType value); + private: + ::proto::KeepType _internal_keeptype() const; + void _internal_set_keeptype(::proto::KeepType value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.KeepInChatMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::proto::MessageKey* key_; + int64_t timestampms_; + int keeptype_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_ListMessage_ProductListHeaderImage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListMessage.ProductListHeaderImage) */ { + public: + inline Message_ListMessage_ProductListHeaderImage() : Message_ListMessage_ProductListHeaderImage(nullptr) {} + ~Message_ListMessage_ProductListHeaderImage() override; + explicit PROTOBUF_CONSTEXPR Message_ListMessage_ProductListHeaderImage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_ListMessage_ProductListHeaderImage(const Message_ListMessage_ProductListHeaderImage& from); + Message_ListMessage_ProductListHeaderImage(Message_ListMessage_ProductListHeaderImage&& from) noexcept + : Message_ListMessage_ProductListHeaderImage() { + *this = ::std::move(from); + } + + inline Message_ListMessage_ProductListHeaderImage& operator=(const Message_ListMessage_ProductListHeaderImage& from) { + CopyFrom(from); + return *this; + } + inline Message_ListMessage_ProductListHeaderImage& operator=(Message_ListMessage_ProductListHeaderImage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_ListMessage_ProductListHeaderImage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_ListMessage_ProductListHeaderImage* internal_default_instance() { + return reinterpret_cast( + &_Message_ListMessage_ProductListHeaderImage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 99; + + friend void swap(Message_ListMessage_ProductListHeaderImage& a, Message_ListMessage_ProductListHeaderImage& b) { + a.Swap(&b); + } + inline void Swap(Message_ListMessage_ProductListHeaderImage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_ListMessage_ProductListHeaderImage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_ListMessage_ProductListHeaderImage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_ListMessage_ProductListHeaderImage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_ListMessage_ProductListHeaderImage& from) { + Message_ListMessage_ProductListHeaderImage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_ListMessage_ProductListHeaderImage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.ListMessage.ProductListHeaderImage"; + } + protected: + explicit Message_ListMessage_ProductListHeaderImage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kProductIdFieldNumber = 1, + kJpegThumbnailFieldNumber = 2, + }; + // optional string productId = 1; + bool has_productid() const; + private: + bool _internal_has_productid() const; + public: + void clear_productid(); + const std::string& productid() const; + template + void set_productid(ArgT0&& arg0, ArgT... args); + std::string* mutable_productid(); + PROTOBUF_NODISCARD std::string* release_productid(); + void set_allocated_productid(std::string* productid); + private: + const std::string& _internal_productid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_productid(const std::string& value); + std::string* _internal_mutable_productid(); + public: + + // optional bytes jpegThumbnail = 2; + bool has_jpegthumbnail() const; + private: + bool _internal_has_jpegthumbnail() const; + public: + void clear_jpegthumbnail(); + const std::string& jpegthumbnail() const; + template + void set_jpegthumbnail(ArgT0&& arg0, ArgT... args); + std::string* mutable_jpegthumbnail(); + PROTOBUF_NODISCARD std::string* release_jpegthumbnail(); + void set_allocated_jpegthumbnail(std::string* jpegthumbnail); + private: + const std::string& _internal_jpegthumbnail() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value); + std::string* _internal_mutable_jpegthumbnail(); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.ListMessage.ProductListHeaderImage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr productid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_ListMessage_ProductListInfo final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListMessage.ProductListInfo) */ { + public: + inline Message_ListMessage_ProductListInfo() : Message_ListMessage_ProductListInfo(nullptr) {} + ~Message_ListMessage_ProductListInfo() override; + explicit PROTOBUF_CONSTEXPR Message_ListMessage_ProductListInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_ListMessage_ProductListInfo(const Message_ListMessage_ProductListInfo& from); + Message_ListMessage_ProductListInfo(Message_ListMessage_ProductListInfo&& from) noexcept + : Message_ListMessage_ProductListInfo() { + *this = ::std::move(from); + } + + inline Message_ListMessage_ProductListInfo& operator=(const Message_ListMessage_ProductListInfo& from) { + CopyFrom(from); + return *this; + } + inline Message_ListMessage_ProductListInfo& operator=(Message_ListMessage_ProductListInfo&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_ListMessage_ProductListInfo& default_instance() { + return *internal_default_instance(); + } + static inline const Message_ListMessage_ProductListInfo* internal_default_instance() { + return reinterpret_cast( + &_Message_ListMessage_ProductListInfo_default_instance_); + } + static constexpr int kIndexInFileMessages = + 100; + + friend void swap(Message_ListMessage_ProductListInfo& a, Message_ListMessage_ProductListInfo& b) { + a.Swap(&b); + } + inline void Swap(Message_ListMessage_ProductListInfo* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_ListMessage_ProductListInfo* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_ListMessage_ProductListInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_ListMessage_ProductListInfo& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_ListMessage_ProductListInfo& from) { + Message_ListMessage_ProductListInfo::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_ListMessage_ProductListInfo* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.ListMessage.ProductListInfo"; + } + protected: + explicit Message_ListMessage_ProductListInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kProductSectionsFieldNumber = 1, + kBusinessOwnerJidFieldNumber = 3, + kHeaderImageFieldNumber = 2, + }; + // repeated .proto.Message.ListMessage.ProductSection productSections = 1; + int productsections_size() const; + private: + int _internal_productsections_size() const; + public: + void clear_productsections(); + ::proto::Message_ListMessage_ProductSection* mutable_productsections(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_ProductSection >* + mutable_productsections(); + private: + const ::proto::Message_ListMessage_ProductSection& _internal_productsections(int index) const; + ::proto::Message_ListMessage_ProductSection* _internal_add_productsections(); + public: + const ::proto::Message_ListMessage_ProductSection& productsections(int index) const; + ::proto::Message_ListMessage_ProductSection* add_productsections(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_ProductSection >& + productsections() const; + + // optional string businessOwnerJid = 3; + bool has_businessownerjid() const; + private: + bool _internal_has_businessownerjid() const; + public: + void clear_businessownerjid(); + const std::string& businessownerjid() const; + template + void set_businessownerjid(ArgT0&& arg0, ArgT... args); + std::string* mutable_businessownerjid(); + PROTOBUF_NODISCARD std::string* release_businessownerjid(); + void set_allocated_businessownerjid(std::string* businessownerjid); + private: + const std::string& _internal_businessownerjid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_businessownerjid(const std::string& value); + std::string* _internal_mutable_businessownerjid(); + public: + + // optional .proto.Message.ListMessage.ProductListHeaderImage headerImage = 2; + bool has_headerimage() const; + private: + bool _internal_has_headerimage() const; + public: + void clear_headerimage(); + const ::proto::Message_ListMessage_ProductListHeaderImage& headerimage() const; + PROTOBUF_NODISCARD ::proto::Message_ListMessage_ProductListHeaderImage* release_headerimage(); + ::proto::Message_ListMessage_ProductListHeaderImage* mutable_headerimage(); + void set_allocated_headerimage(::proto::Message_ListMessage_ProductListHeaderImage* headerimage); + private: + const ::proto::Message_ListMessage_ProductListHeaderImage& _internal_headerimage() const; + ::proto::Message_ListMessage_ProductListHeaderImage* _internal_mutable_headerimage(); + public: + void unsafe_arena_set_allocated_headerimage( + ::proto::Message_ListMessage_ProductListHeaderImage* headerimage); + ::proto::Message_ListMessage_ProductListHeaderImage* unsafe_arena_release_headerimage(); + + // @@protoc_insertion_point(class_scope:proto.Message.ListMessage.ProductListInfo) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_ProductSection > productsections_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr businessownerjid_; + ::proto::Message_ListMessage_ProductListHeaderImage* headerimage_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_ListMessage_ProductSection final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListMessage.ProductSection) */ { + public: + inline Message_ListMessage_ProductSection() : Message_ListMessage_ProductSection(nullptr) {} + ~Message_ListMessage_ProductSection() override; + explicit PROTOBUF_CONSTEXPR Message_ListMessage_ProductSection(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_ListMessage_ProductSection(const Message_ListMessage_ProductSection& from); + Message_ListMessage_ProductSection(Message_ListMessage_ProductSection&& from) noexcept + : Message_ListMessage_ProductSection() { + *this = ::std::move(from); + } + + inline Message_ListMessage_ProductSection& operator=(const Message_ListMessage_ProductSection& from) { + CopyFrom(from); + return *this; + } + inline Message_ListMessage_ProductSection& operator=(Message_ListMessage_ProductSection&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_ListMessage_ProductSection& default_instance() { + return *internal_default_instance(); + } + static inline const Message_ListMessage_ProductSection* internal_default_instance() { + return reinterpret_cast( + &_Message_ListMessage_ProductSection_default_instance_); + } + static constexpr int kIndexInFileMessages = + 101; + + friend void swap(Message_ListMessage_ProductSection& a, Message_ListMessage_ProductSection& b) { + a.Swap(&b); + } + inline void Swap(Message_ListMessage_ProductSection* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_ListMessage_ProductSection* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_ListMessage_ProductSection* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_ListMessage_ProductSection& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_ListMessage_ProductSection& from) { + Message_ListMessage_ProductSection::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_ListMessage_ProductSection* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.ListMessage.ProductSection"; + } + protected: + explicit Message_ListMessage_ProductSection(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kProductsFieldNumber = 2, + kTitleFieldNumber = 1, + }; + // repeated .proto.Message.ListMessage.Product products = 2; + int products_size() const; + private: + int _internal_products_size() const; + public: + void clear_products(); + ::proto::Message_ListMessage_Product* mutable_products(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Product >* + mutable_products(); + private: + const ::proto::Message_ListMessage_Product& _internal_products(int index) const; + ::proto::Message_ListMessage_Product* _internal_add_products(); + public: + const ::proto::Message_ListMessage_Product& products(int index) const; + ::proto::Message_ListMessage_Product* add_products(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Product >& + products() const; + + // optional string title = 1; + bool has_title() const; + private: + bool _internal_has_title() const; + public: + void clear_title(); + const std::string& title() const; + template + void set_title(ArgT0&& arg0, ArgT... args); + std::string* mutable_title(); + PROTOBUF_NODISCARD std::string* release_title(); + void set_allocated_title(std::string* title); + private: + const std::string& _internal_title() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value); + std::string* _internal_mutable_title(); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.ListMessage.ProductSection) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Product > products_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_ListMessage_Product final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListMessage.Product) */ { + public: + inline Message_ListMessage_Product() : Message_ListMessage_Product(nullptr) {} + ~Message_ListMessage_Product() override; + explicit PROTOBUF_CONSTEXPR Message_ListMessage_Product(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_ListMessage_Product(const Message_ListMessage_Product& from); + Message_ListMessage_Product(Message_ListMessage_Product&& from) noexcept + : Message_ListMessage_Product() { + *this = ::std::move(from); + } + + inline Message_ListMessage_Product& operator=(const Message_ListMessage_Product& from) { + CopyFrom(from); + return *this; + } + inline Message_ListMessage_Product& operator=(Message_ListMessage_Product&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_ListMessage_Product& default_instance() { + return *internal_default_instance(); + } + static inline const Message_ListMessage_Product* internal_default_instance() { + return reinterpret_cast( + &_Message_ListMessage_Product_default_instance_); + } + static constexpr int kIndexInFileMessages = + 102; + + friend void swap(Message_ListMessage_Product& a, Message_ListMessage_Product& b) { + a.Swap(&b); + } + inline void Swap(Message_ListMessage_Product* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_ListMessage_Product* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_ListMessage_Product* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_ListMessage_Product& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_ListMessage_Product& from) { + Message_ListMessage_Product::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_ListMessage_Product* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.ListMessage.Product"; + } + protected: + explicit Message_ListMessage_Product(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kProductIdFieldNumber = 1, + }; + // optional string productId = 1; + bool has_productid() const; + private: + bool _internal_has_productid() const; + public: + void clear_productid(); + const std::string& productid() const; + template + void set_productid(ArgT0&& arg0, ArgT... args); + std::string* mutable_productid(); + PROTOBUF_NODISCARD std::string* release_productid(); + void set_allocated_productid(std::string* productid); + private: + const std::string& _internal_productid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_productid(const std::string& value); + std::string* _internal_mutable_productid(); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.ListMessage.Product) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr productid_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_ListMessage_Row final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListMessage.Row) */ { + public: + inline Message_ListMessage_Row() : Message_ListMessage_Row(nullptr) {} + ~Message_ListMessage_Row() override; + explicit PROTOBUF_CONSTEXPR Message_ListMessage_Row(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_ListMessage_Row(const Message_ListMessage_Row& from); + Message_ListMessage_Row(Message_ListMessage_Row&& from) noexcept + : Message_ListMessage_Row() { + *this = ::std::move(from); + } + + inline Message_ListMessage_Row& operator=(const Message_ListMessage_Row& from) { + CopyFrom(from); + return *this; + } + inline Message_ListMessage_Row& operator=(Message_ListMessage_Row&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_ListMessage_Row& default_instance() { + return *internal_default_instance(); + } + static inline const Message_ListMessage_Row* internal_default_instance() { + return reinterpret_cast( + &_Message_ListMessage_Row_default_instance_); + } + static constexpr int kIndexInFileMessages = + 103; + + friend void swap(Message_ListMessage_Row& a, Message_ListMessage_Row& b) { + a.Swap(&b); + } + inline void Swap(Message_ListMessage_Row* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_ListMessage_Row* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_ListMessage_Row* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_ListMessage_Row& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_ListMessage_Row& from) { + Message_ListMessage_Row::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_ListMessage_Row* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.ListMessage.Row"; + } + protected: + explicit Message_ListMessage_Row(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kTitleFieldNumber = 1, + kDescriptionFieldNumber = 2, + kRowIdFieldNumber = 3, + }; + // optional string title = 1; + bool has_title() const; + private: + bool _internal_has_title() const; + public: + void clear_title(); + const std::string& title() const; + template + void set_title(ArgT0&& arg0, ArgT... args); + std::string* mutable_title(); + PROTOBUF_NODISCARD std::string* release_title(); + void set_allocated_title(std::string* title); + private: + const std::string& _internal_title() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value); + std::string* _internal_mutable_title(); + public: + + // optional string description = 2; + bool has_description() const; + private: + bool _internal_has_description() const; + public: + void clear_description(); + const std::string& description() const; + template + void set_description(ArgT0&& arg0, ArgT... args); + std::string* mutable_description(); + PROTOBUF_NODISCARD std::string* release_description(); + void set_allocated_description(std::string* description); + private: + const std::string& _internal_description() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value); + std::string* _internal_mutable_description(); + public: + + // optional string rowId = 3; + bool has_rowid() const; + private: + bool _internal_has_rowid() const; + public: + void clear_rowid(); + const std::string& rowid() const; + template + void set_rowid(ArgT0&& arg0, ArgT... args); + std::string* mutable_rowid(); + PROTOBUF_NODISCARD std::string* release_rowid(); + void set_allocated_rowid(std::string* rowid); + private: + const std::string& _internal_rowid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_rowid(const std::string& value); + std::string* _internal_mutable_rowid(); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.ListMessage.Row) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rowid_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_ListMessage_Section final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListMessage.Section) */ { + public: + inline Message_ListMessage_Section() : Message_ListMessage_Section(nullptr) {} + ~Message_ListMessage_Section() override; + explicit PROTOBUF_CONSTEXPR Message_ListMessage_Section(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_ListMessage_Section(const Message_ListMessage_Section& from); + Message_ListMessage_Section(Message_ListMessage_Section&& from) noexcept + : Message_ListMessage_Section() { + *this = ::std::move(from); + } + + inline Message_ListMessage_Section& operator=(const Message_ListMessage_Section& from) { + CopyFrom(from); + return *this; + } + inline Message_ListMessage_Section& operator=(Message_ListMessage_Section&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_ListMessage_Section& default_instance() { + return *internal_default_instance(); + } + static inline const Message_ListMessage_Section* internal_default_instance() { + return reinterpret_cast( + &_Message_ListMessage_Section_default_instance_); + } + static constexpr int kIndexInFileMessages = + 104; + + friend void swap(Message_ListMessage_Section& a, Message_ListMessage_Section& b) { + a.Swap(&b); + } + inline void Swap(Message_ListMessage_Section* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_ListMessage_Section* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_ListMessage_Section* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_ListMessage_Section& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_ListMessage_Section& from) { + Message_ListMessage_Section::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_ListMessage_Section* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.ListMessage.Section"; + } + protected: + explicit Message_ListMessage_Section(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kRowsFieldNumber = 2, + kTitleFieldNumber = 1, + }; + // repeated .proto.Message.ListMessage.Row rows = 2; + int rows_size() const; + private: + int _internal_rows_size() const; + public: + void clear_rows(); + ::proto::Message_ListMessage_Row* mutable_rows(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Row >* + mutable_rows(); + private: + const ::proto::Message_ListMessage_Row& _internal_rows(int index) const; + ::proto::Message_ListMessage_Row* _internal_add_rows(); + public: + const ::proto::Message_ListMessage_Row& rows(int index) const; + ::proto::Message_ListMessage_Row* add_rows(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Row >& + rows() const; + + // optional string title = 1; + bool has_title() const; + private: + bool _internal_has_title() const; + public: + void clear_title(); + const std::string& title() const; + template + void set_title(ArgT0&& arg0, ArgT... args); + std::string* mutable_title(); + PROTOBUF_NODISCARD std::string* release_title(); + void set_allocated_title(std::string* title); + private: + const std::string& _internal_title() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value); + std::string* _internal_mutable_title(); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.ListMessage.Section) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Row > rows_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_ListMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListMessage) */ { + public: + inline Message_ListMessage() : Message_ListMessage(nullptr) {} + ~Message_ListMessage() override; + explicit PROTOBUF_CONSTEXPR Message_ListMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_ListMessage(const Message_ListMessage& from); + Message_ListMessage(Message_ListMessage&& from) noexcept + : Message_ListMessage() { + *this = ::std::move(from); + } + + inline Message_ListMessage& operator=(const Message_ListMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_ListMessage& operator=(Message_ListMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_ListMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_ListMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_ListMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 105; + + friend void swap(Message_ListMessage& a, Message_ListMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_ListMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_ListMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_ListMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_ListMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_ListMessage& from) { + Message_ListMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_ListMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.ListMessage"; + } + protected: + explicit Message_ListMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Message_ListMessage_ProductListHeaderImage ProductListHeaderImage; + typedef Message_ListMessage_ProductListInfo ProductListInfo; + typedef Message_ListMessage_ProductSection ProductSection; + typedef Message_ListMessage_Product Product; + typedef Message_ListMessage_Row Row; + typedef Message_ListMessage_Section Section; + + typedef Message_ListMessage_ListType ListType; + static constexpr ListType UNKNOWN = + Message_ListMessage_ListType_UNKNOWN; + static constexpr ListType SINGLE_SELECT = + Message_ListMessage_ListType_SINGLE_SELECT; + static constexpr ListType PRODUCT_LIST = + Message_ListMessage_ListType_PRODUCT_LIST; + static inline bool ListType_IsValid(int value) { + return Message_ListMessage_ListType_IsValid(value); + } + static constexpr ListType ListType_MIN = + Message_ListMessage_ListType_ListType_MIN; + static constexpr ListType ListType_MAX = + Message_ListMessage_ListType_ListType_MAX; + static constexpr int ListType_ARRAYSIZE = + Message_ListMessage_ListType_ListType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + ListType_descriptor() { + return Message_ListMessage_ListType_descriptor(); + } + template + static inline const std::string& ListType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ListType_Name."); + return Message_ListMessage_ListType_Name(enum_t_value); + } + static inline bool ListType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + ListType* value) { + return Message_ListMessage_ListType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kSectionsFieldNumber = 5, + kTitleFieldNumber = 1, + kDescriptionFieldNumber = 2, + kButtonTextFieldNumber = 3, + kFooterTextFieldNumber = 7, + kProductListInfoFieldNumber = 6, + kContextInfoFieldNumber = 8, + kListTypeFieldNumber = 4, + }; + // repeated .proto.Message.ListMessage.Section sections = 5; + int sections_size() const; + private: + int _internal_sections_size() const; + public: + void clear_sections(); + ::proto::Message_ListMessage_Section* mutable_sections(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Section >* + mutable_sections(); + private: + const ::proto::Message_ListMessage_Section& _internal_sections(int index) const; + ::proto::Message_ListMessage_Section* _internal_add_sections(); + public: + const ::proto::Message_ListMessage_Section& sections(int index) const; + ::proto::Message_ListMessage_Section* add_sections(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Section >& + sections() const; + + // optional string title = 1; + bool has_title() const; + private: + bool _internal_has_title() const; + public: + void clear_title(); + const std::string& title() const; + template + void set_title(ArgT0&& arg0, ArgT... args); + std::string* mutable_title(); + PROTOBUF_NODISCARD std::string* release_title(); + void set_allocated_title(std::string* title); + private: + const std::string& _internal_title() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value); + std::string* _internal_mutable_title(); + public: + + // optional string description = 2; + bool has_description() const; + private: + bool _internal_has_description() const; + public: + void clear_description(); + const std::string& description() const; + template + void set_description(ArgT0&& arg0, ArgT... args); + std::string* mutable_description(); + PROTOBUF_NODISCARD std::string* release_description(); + void set_allocated_description(std::string* description); + private: + const std::string& _internal_description() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value); + std::string* _internal_mutable_description(); + public: + + // optional string buttonText = 3; + bool has_buttontext() const; + private: + bool _internal_has_buttontext() const; + public: + void clear_buttontext(); + const std::string& buttontext() const; + template + void set_buttontext(ArgT0&& arg0, ArgT... args); + std::string* mutable_buttontext(); + PROTOBUF_NODISCARD std::string* release_buttontext(); + void set_allocated_buttontext(std::string* buttontext); + private: + const std::string& _internal_buttontext() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_buttontext(const std::string& value); + std::string* _internal_mutable_buttontext(); + public: + + // optional string footerText = 7; + bool has_footertext() const; + private: + bool _internal_has_footertext() const; + public: + void clear_footertext(); + const std::string& footertext() const; + template + void set_footertext(ArgT0&& arg0, ArgT... args); + std::string* mutable_footertext(); + PROTOBUF_NODISCARD std::string* release_footertext(); + void set_allocated_footertext(std::string* footertext); + private: + const std::string& _internal_footertext() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_footertext(const std::string& value); + std::string* _internal_mutable_footertext(); + public: + + // optional .proto.Message.ListMessage.ProductListInfo productListInfo = 6; + bool has_productlistinfo() const; + private: + bool _internal_has_productlistinfo() const; + public: + void clear_productlistinfo(); + const ::proto::Message_ListMessage_ProductListInfo& productlistinfo() const; + PROTOBUF_NODISCARD ::proto::Message_ListMessage_ProductListInfo* release_productlistinfo(); + ::proto::Message_ListMessage_ProductListInfo* mutable_productlistinfo(); + void set_allocated_productlistinfo(::proto::Message_ListMessage_ProductListInfo* productlistinfo); + private: + const ::proto::Message_ListMessage_ProductListInfo& _internal_productlistinfo() const; + ::proto::Message_ListMessage_ProductListInfo* _internal_mutable_productlistinfo(); + public: + void unsafe_arena_set_allocated_productlistinfo( + ::proto::Message_ListMessage_ProductListInfo* productlistinfo); + ::proto::Message_ListMessage_ProductListInfo* unsafe_arena_release_productlistinfo(); + + // optional .proto.ContextInfo contextInfo = 8; + bool has_contextinfo() const; + private: + bool _internal_has_contextinfo() const; + public: + void clear_contextinfo(); + const ::proto::ContextInfo& contextinfo() const; + PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); + ::proto::ContextInfo* mutable_contextinfo(); + void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); + private: + const ::proto::ContextInfo& _internal_contextinfo() const; + ::proto::ContextInfo* _internal_mutable_contextinfo(); + public: + void unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo); + ::proto::ContextInfo* unsafe_arena_release_contextinfo(); + + // optional .proto.Message.ListMessage.ListType listType = 4; + bool has_listtype() const; + private: + bool _internal_has_listtype() const; + public: + void clear_listtype(); + ::proto::Message_ListMessage_ListType listtype() const; + void set_listtype(::proto::Message_ListMessage_ListType value); + private: + ::proto::Message_ListMessage_ListType _internal_listtype() const; + void _internal_set_listtype(::proto::Message_ListMessage_ListType value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.ListMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Section > sections_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr buttontext_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr footertext_; + ::proto::Message_ListMessage_ProductListInfo* productlistinfo_; + ::proto::ContextInfo* contextinfo_; + int listtype_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_ListResponseMessage_SingleSelectReply final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListResponseMessage.SingleSelectReply) */ { + public: + inline Message_ListResponseMessage_SingleSelectReply() : Message_ListResponseMessage_SingleSelectReply(nullptr) {} + ~Message_ListResponseMessage_SingleSelectReply() override; + explicit PROTOBUF_CONSTEXPR Message_ListResponseMessage_SingleSelectReply(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_ListResponseMessage_SingleSelectReply(const Message_ListResponseMessage_SingleSelectReply& from); + Message_ListResponseMessage_SingleSelectReply(Message_ListResponseMessage_SingleSelectReply&& from) noexcept + : Message_ListResponseMessage_SingleSelectReply() { + *this = ::std::move(from); + } + + inline Message_ListResponseMessage_SingleSelectReply& operator=(const Message_ListResponseMessage_SingleSelectReply& from) { + CopyFrom(from); + return *this; + } + inline Message_ListResponseMessage_SingleSelectReply& operator=(Message_ListResponseMessage_SingleSelectReply&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_ListResponseMessage_SingleSelectReply& default_instance() { + return *internal_default_instance(); + } + static inline const Message_ListResponseMessage_SingleSelectReply* internal_default_instance() { + return reinterpret_cast( + &_Message_ListResponseMessage_SingleSelectReply_default_instance_); + } + static constexpr int kIndexInFileMessages = + 106; + + friend void swap(Message_ListResponseMessage_SingleSelectReply& a, Message_ListResponseMessage_SingleSelectReply& b) { + a.Swap(&b); + } + inline void Swap(Message_ListResponseMessage_SingleSelectReply* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_ListResponseMessage_SingleSelectReply* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_ListResponseMessage_SingleSelectReply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_ListResponseMessage_SingleSelectReply& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_ListResponseMessage_SingleSelectReply& from) { + Message_ListResponseMessage_SingleSelectReply::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_ListResponseMessage_SingleSelectReply* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.ListResponseMessage.SingleSelectReply"; + } + protected: + explicit Message_ListResponseMessage_SingleSelectReply(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSelectedRowIdFieldNumber = 1, + }; + // optional string selectedRowId = 1; + bool has_selectedrowid() const; + private: + bool _internal_has_selectedrowid() const; + public: + void clear_selectedrowid(); + const std::string& selectedrowid() const; + template + void set_selectedrowid(ArgT0&& arg0, ArgT... args); + std::string* mutable_selectedrowid(); + PROTOBUF_NODISCARD std::string* release_selectedrowid(); + void set_allocated_selectedrowid(std::string* selectedrowid); + private: + const std::string& _internal_selectedrowid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_selectedrowid(const std::string& value); + std::string* _internal_mutable_selectedrowid(); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.ListResponseMessage.SingleSelectReply) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr selectedrowid_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_ListResponseMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListResponseMessage) */ { + public: + inline Message_ListResponseMessage() : Message_ListResponseMessage(nullptr) {} + ~Message_ListResponseMessage() override; + explicit PROTOBUF_CONSTEXPR Message_ListResponseMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_ListResponseMessage(const Message_ListResponseMessage& from); + Message_ListResponseMessage(Message_ListResponseMessage&& from) noexcept + : Message_ListResponseMessage() { + *this = ::std::move(from); + } + + inline Message_ListResponseMessage& operator=(const Message_ListResponseMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_ListResponseMessage& operator=(Message_ListResponseMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_ListResponseMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_ListResponseMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_ListResponseMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 107; + + friend void swap(Message_ListResponseMessage& a, Message_ListResponseMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_ListResponseMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_ListResponseMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_ListResponseMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_ListResponseMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_ListResponseMessage& from) { + Message_ListResponseMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_ListResponseMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.ListResponseMessage"; + } + protected: + explicit Message_ListResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Message_ListResponseMessage_SingleSelectReply SingleSelectReply; + + typedef Message_ListResponseMessage_ListType ListType; + static constexpr ListType UNKNOWN = + Message_ListResponseMessage_ListType_UNKNOWN; + static constexpr ListType SINGLE_SELECT = + Message_ListResponseMessage_ListType_SINGLE_SELECT; + static inline bool ListType_IsValid(int value) { + return Message_ListResponseMessage_ListType_IsValid(value); + } + static constexpr ListType ListType_MIN = + Message_ListResponseMessage_ListType_ListType_MIN; + static constexpr ListType ListType_MAX = + Message_ListResponseMessage_ListType_ListType_MAX; + static constexpr int ListType_ARRAYSIZE = + Message_ListResponseMessage_ListType_ListType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + ListType_descriptor() { + return Message_ListResponseMessage_ListType_descriptor(); + } + template + static inline const std::string& ListType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ListType_Name."); + return Message_ListResponseMessage_ListType_Name(enum_t_value); + } + static inline bool ListType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + ListType* value) { + return Message_ListResponseMessage_ListType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kTitleFieldNumber = 1, + kDescriptionFieldNumber = 5, + kSingleSelectReplyFieldNumber = 3, + kContextInfoFieldNumber = 4, + kListTypeFieldNumber = 2, + }; + // optional string title = 1; + bool has_title() const; + private: + bool _internal_has_title() const; + public: + void clear_title(); + const std::string& title() const; + template + void set_title(ArgT0&& arg0, ArgT... args); + std::string* mutable_title(); + PROTOBUF_NODISCARD std::string* release_title(); + void set_allocated_title(std::string* title); + private: + const std::string& _internal_title() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value); + std::string* _internal_mutable_title(); + public: + + // optional string description = 5; + bool has_description() const; + private: + bool _internal_has_description() const; + public: + void clear_description(); + const std::string& description() const; + template + void set_description(ArgT0&& arg0, ArgT... args); + std::string* mutable_description(); + PROTOBUF_NODISCARD std::string* release_description(); + void set_allocated_description(std::string* description); + private: + const std::string& _internal_description() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value); + std::string* _internal_mutable_description(); + public: + + // optional .proto.Message.ListResponseMessage.SingleSelectReply singleSelectReply = 3; + bool has_singleselectreply() const; + private: + bool _internal_has_singleselectreply() const; + public: + void clear_singleselectreply(); + const ::proto::Message_ListResponseMessage_SingleSelectReply& singleselectreply() const; + PROTOBUF_NODISCARD ::proto::Message_ListResponseMessage_SingleSelectReply* release_singleselectreply(); + ::proto::Message_ListResponseMessage_SingleSelectReply* mutable_singleselectreply(); + void set_allocated_singleselectreply(::proto::Message_ListResponseMessage_SingleSelectReply* singleselectreply); + private: + const ::proto::Message_ListResponseMessage_SingleSelectReply& _internal_singleselectreply() const; + ::proto::Message_ListResponseMessage_SingleSelectReply* _internal_mutable_singleselectreply(); + public: + void unsafe_arena_set_allocated_singleselectreply( + ::proto::Message_ListResponseMessage_SingleSelectReply* singleselectreply); + ::proto::Message_ListResponseMessage_SingleSelectReply* unsafe_arena_release_singleselectreply(); + + // optional .proto.ContextInfo contextInfo = 4; + bool has_contextinfo() const; + private: + bool _internal_has_contextinfo() const; + public: + void clear_contextinfo(); + const ::proto::ContextInfo& contextinfo() const; + PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); + ::proto::ContextInfo* mutable_contextinfo(); + void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); + private: + const ::proto::ContextInfo& _internal_contextinfo() const; + ::proto::ContextInfo* _internal_mutable_contextinfo(); + public: + void unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo); + ::proto::ContextInfo* unsafe_arena_release_contextinfo(); + + // optional .proto.Message.ListResponseMessage.ListType listType = 2; + bool has_listtype() const; + private: + bool _internal_has_listtype() const; + public: + void clear_listtype(); + ::proto::Message_ListResponseMessage_ListType listtype() const; + void set_listtype(::proto::Message_ListResponseMessage_ListType value); + private: + ::proto::Message_ListResponseMessage_ListType _internal_listtype() const; + void _internal_set_listtype(::proto::Message_ListResponseMessage_ListType value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.ListResponseMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_; + ::proto::Message_ListResponseMessage_SingleSelectReply* singleselectreply_; + ::proto::ContextInfo* contextinfo_; + int listtype_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_LiveLocationMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.LiveLocationMessage) */ { + public: + inline Message_LiveLocationMessage() : Message_LiveLocationMessage(nullptr) {} + ~Message_LiveLocationMessage() override; + explicit PROTOBUF_CONSTEXPR Message_LiveLocationMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_LiveLocationMessage(const Message_LiveLocationMessage& from); + Message_LiveLocationMessage(Message_LiveLocationMessage&& from) noexcept + : Message_LiveLocationMessage() { + *this = ::std::move(from); + } + + inline Message_LiveLocationMessage& operator=(const Message_LiveLocationMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_LiveLocationMessage& operator=(Message_LiveLocationMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_LiveLocationMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_LiveLocationMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_LiveLocationMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 108; + + friend void swap(Message_LiveLocationMessage& a, Message_LiveLocationMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_LiveLocationMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_LiveLocationMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_LiveLocationMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_LiveLocationMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_LiveLocationMessage& from) { + Message_LiveLocationMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_LiveLocationMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.LiveLocationMessage"; + } + protected: + explicit Message_LiveLocationMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kCaptionFieldNumber = 6, + kJpegThumbnailFieldNumber = 16, + kContextInfoFieldNumber = 17, + kDegreesLatitudeFieldNumber = 1, + kDegreesLongitudeFieldNumber = 2, + kAccuracyInMetersFieldNumber = 3, + kSpeedInMpsFieldNumber = 4, + kDegreesClockwiseFromMagneticNorthFieldNumber = 5, + kTimeOffsetFieldNumber = 8, + kSequenceNumberFieldNumber = 7, + }; + // optional string caption = 6; + bool has_caption() const; + private: + bool _internal_has_caption() const; + public: + void clear_caption(); + const std::string& caption() const; + template + void set_caption(ArgT0&& arg0, ArgT... args); + std::string* mutable_caption(); + PROTOBUF_NODISCARD std::string* release_caption(); + void set_allocated_caption(std::string* caption); + private: + const std::string& _internal_caption() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_caption(const std::string& value); + std::string* _internal_mutable_caption(); + public: + + // optional bytes jpegThumbnail = 16; + bool has_jpegthumbnail() const; + private: + bool _internal_has_jpegthumbnail() const; + public: + void clear_jpegthumbnail(); + const std::string& jpegthumbnail() const; + template + void set_jpegthumbnail(ArgT0&& arg0, ArgT... args); + std::string* mutable_jpegthumbnail(); + PROTOBUF_NODISCARD std::string* release_jpegthumbnail(); + void set_allocated_jpegthumbnail(std::string* jpegthumbnail); + private: + const std::string& _internal_jpegthumbnail() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value); + std::string* _internal_mutable_jpegthumbnail(); + public: + + // optional .proto.ContextInfo contextInfo = 17; + bool has_contextinfo() const; + private: + bool _internal_has_contextinfo() const; + public: + void clear_contextinfo(); + const ::proto::ContextInfo& contextinfo() const; + PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); + ::proto::ContextInfo* mutable_contextinfo(); + void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); + private: + const ::proto::ContextInfo& _internal_contextinfo() const; + ::proto::ContextInfo* _internal_mutable_contextinfo(); + public: + void unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo); + ::proto::ContextInfo* unsafe_arena_release_contextinfo(); + + // optional double degreesLatitude = 1; + bool has_degreeslatitude() const; + private: + bool _internal_has_degreeslatitude() const; + public: + void clear_degreeslatitude(); + double degreeslatitude() const; + void set_degreeslatitude(double value); + private: + double _internal_degreeslatitude() const; + void _internal_set_degreeslatitude(double value); + public: + + // optional double degreesLongitude = 2; + bool has_degreeslongitude() const; + private: + bool _internal_has_degreeslongitude() const; + public: + void clear_degreeslongitude(); + double degreeslongitude() const; + void set_degreeslongitude(double value); + private: + double _internal_degreeslongitude() const; + void _internal_set_degreeslongitude(double value); + public: + + // optional uint32 accuracyInMeters = 3; + bool has_accuracyinmeters() const; + private: + bool _internal_has_accuracyinmeters() const; + public: + void clear_accuracyinmeters(); + uint32_t accuracyinmeters() const; + void set_accuracyinmeters(uint32_t value); + private: + uint32_t _internal_accuracyinmeters() const; + void _internal_set_accuracyinmeters(uint32_t value); + public: + + // optional float speedInMps = 4; + bool has_speedinmps() const; + private: + bool _internal_has_speedinmps() const; + public: + void clear_speedinmps(); + float speedinmps() const; + void set_speedinmps(float value); + private: + float _internal_speedinmps() const; + void _internal_set_speedinmps(float value); + public: + + // optional uint32 degreesClockwiseFromMagneticNorth = 5; + bool has_degreesclockwisefrommagneticnorth() const; + private: + bool _internal_has_degreesclockwisefrommagneticnorth() const; + public: + void clear_degreesclockwisefrommagneticnorth(); + uint32_t degreesclockwisefrommagneticnorth() const; + void set_degreesclockwisefrommagneticnorth(uint32_t value); + private: + uint32_t _internal_degreesclockwisefrommagneticnorth() const; + void _internal_set_degreesclockwisefrommagneticnorth(uint32_t value); + public: + + // optional uint32 timeOffset = 8; + bool has_timeoffset() const; + private: + bool _internal_has_timeoffset() const; + public: + void clear_timeoffset(); + uint32_t timeoffset() const; + void set_timeoffset(uint32_t value); + private: + uint32_t _internal_timeoffset() const; + void _internal_set_timeoffset(uint32_t value); + public: + + // optional int64 sequenceNumber = 7; + bool has_sequencenumber() const; + private: + bool _internal_has_sequencenumber() const; + public: + void clear_sequencenumber(); + int64_t sequencenumber() const; + void set_sequencenumber(int64_t value); + private: + int64_t _internal_sequencenumber() const; + void _internal_set_sequencenumber(int64_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.LiveLocationMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr caption_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_; + ::proto::ContextInfo* contextinfo_; + double degreeslatitude_; + double degreeslongitude_; + uint32_t accuracyinmeters_; + float speedinmps_; + uint32_t degreesclockwisefrommagneticnorth_; + uint32_t timeoffset_; + int64_t sequencenumber_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_LocationMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.LocationMessage) */ { + public: + inline Message_LocationMessage() : Message_LocationMessage(nullptr) {} + ~Message_LocationMessage() override; + explicit PROTOBUF_CONSTEXPR Message_LocationMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_LocationMessage(const Message_LocationMessage& from); + Message_LocationMessage(Message_LocationMessage&& from) noexcept + : Message_LocationMessage() { + *this = ::std::move(from); + } + + inline Message_LocationMessage& operator=(const Message_LocationMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_LocationMessage& operator=(Message_LocationMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_LocationMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_LocationMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_LocationMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 109; + + friend void swap(Message_LocationMessage& a, Message_LocationMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_LocationMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_LocationMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_LocationMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_LocationMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_LocationMessage& from) { + Message_LocationMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_LocationMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.LocationMessage"; + } + protected: + explicit Message_LocationMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNameFieldNumber = 3, + kAddressFieldNumber = 4, + kUrlFieldNumber = 5, + kCommentFieldNumber = 11, + kJpegThumbnailFieldNumber = 16, + kContextInfoFieldNumber = 17, + kDegreesLatitudeFieldNumber = 1, + kDegreesLongitudeFieldNumber = 2, + kIsLiveFieldNumber = 6, + kAccuracyInMetersFieldNumber = 7, + kSpeedInMpsFieldNumber = 8, + kDegreesClockwiseFromMagneticNorthFieldNumber = 9, + }; + // optional string name = 3; + bool has_name() const; + private: + bool _internal_has_name() const; + public: + void clear_name(); + const std::string& name() const; + template + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + PROTOBUF_NODISCARD std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // optional string address = 4; + bool has_address() const; + private: + bool _internal_has_address() const; + public: + void clear_address(); + const std::string& address() const; + template + void set_address(ArgT0&& arg0, ArgT... args); + std::string* mutable_address(); + PROTOBUF_NODISCARD std::string* release_address(); + void set_allocated_address(std::string* address); + private: + const std::string& _internal_address() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_address(const std::string& value); + std::string* _internal_mutable_address(); + public: + + // optional string url = 5; + bool has_url() const; + private: + bool _internal_has_url() const; + public: + void clear_url(); + const std::string& url() const; + template + void set_url(ArgT0&& arg0, ArgT... args); + std::string* mutable_url(); + PROTOBUF_NODISCARD std::string* release_url(); + void set_allocated_url(std::string* url); + private: + const std::string& _internal_url() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value); + std::string* _internal_mutable_url(); + public: + + // optional string comment = 11; + bool has_comment() const; + private: + bool _internal_has_comment() const; + public: + void clear_comment(); + const std::string& comment() const; + template + void set_comment(ArgT0&& arg0, ArgT... args); + std::string* mutable_comment(); + PROTOBUF_NODISCARD std::string* release_comment(); + void set_allocated_comment(std::string* comment); + private: + const std::string& _internal_comment() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_comment(const std::string& value); + std::string* _internal_mutable_comment(); + public: + + // optional bytes jpegThumbnail = 16; + bool has_jpegthumbnail() const; + private: + bool _internal_has_jpegthumbnail() const; + public: + void clear_jpegthumbnail(); + const std::string& jpegthumbnail() const; + template + void set_jpegthumbnail(ArgT0&& arg0, ArgT... args); + std::string* mutable_jpegthumbnail(); + PROTOBUF_NODISCARD std::string* release_jpegthumbnail(); + void set_allocated_jpegthumbnail(std::string* jpegthumbnail); + private: + const std::string& _internal_jpegthumbnail() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value); + std::string* _internal_mutable_jpegthumbnail(); + public: + + // optional .proto.ContextInfo contextInfo = 17; + bool has_contextinfo() const; + private: + bool _internal_has_contextinfo() const; + public: + void clear_contextinfo(); + const ::proto::ContextInfo& contextinfo() const; + PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); + ::proto::ContextInfo* mutable_contextinfo(); + void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); + private: + const ::proto::ContextInfo& _internal_contextinfo() const; + ::proto::ContextInfo* _internal_mutable_contextinfo(); + public: + void unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo); + ::proto::ContextInfo* unsafe_arena_release_contextinfo(); + + // optional double degreesLatitude = 1; + bool has_degreeslatitude() const; + private: + bool _internal_has_degreeslatitude() const; + public: + void clear_degreeslatitude(); + double degreeslatitude() const; + void set_degreeslatitude(double value); + private: + double _internal_degreeslatitude() const; + void _internal_set_degreeslatitude(double value); + public: + + // optional double degreesLongitude = 2; + bool has_degreeslongitude() const; + private: + bool _internal_has_degreeslongitude() const; + public: + void clear_degreeslongitude(); + double degreeslongitude() const; + void set_degreeslongitude(double value); + private: + double _internal_degreeslongitude() const; + void _internal_set_degreeslongitude(double value); + public: + + // optional bool isLive = 6; + bool has_islive() const; + private: + bool _internal_has_islive() const; + public: + void clear_islive(); + bool islive() const; + void set_islive(bool value); + private: + bool _internal_islive() const; + void _internal_set_islive(bool value); + public: + + // optional uint32 accuracyInMeters = 7; + bool has_accuracyinmeters() const; + private: + bool _internal_has_accuracyinmeters() const; + public: + void clear_accuracyinmeters(); + uint32_t accuracyinmeters() const; + void set_accuracyinmeters(uint32_t value); + private: + uint32_t _internal_accuracyinmeters() const; + void _internal_set_accuracyinmeters(uint32_t value); + public: + + // optional float speedInMps = 8; + bool has_speedinmps() const; + private: + bool _internal_has_speedinmps() const; + public: + void clear_speedinmps(); + float speedinmps() const; + void set_speedinmps(float value); + private: + float _internal_speedinmps() const; + void _internal_set_speedinmps(float value); + public: + + // optional uint32 degreesClockwiseFromMagneticNorth = 9; + bool has_degreesclockwisefrommagneticnorth() const; + private: + bool _internal_has_degreesclockwisefrommagneticnorth() const; + public: + void clear_degreesclockwisefrommagneticnorth(); + uint32_t degreesclockwisefrommagneticnorth() const; + void set_degreesclockwisefrommagneticnorth(uint32_t value); + private: + uint32_t _internal_degreesclockwisefrommagneticnorth() const; + void _internal_set_degreesclockwisefrommagneticnorth(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.LocationMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr address_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr comment_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_; + ::proto::ContextInfo* contextinfo_; + double degreeslatitude_; + double degreeslongitude_; + bool islive_; + uint32_t accuracyinmeters_; + float speedinmps_; + uint32_t degreesclockwisefrommagneticnorth_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_OrderMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.OrderMessage) */ { + public: + inline Message_OrderMessage() : Message_OrderMessage(nullptr) {} + ~Message_OrderMessage() override; + explicit PROTOBUF_CONSTEXPR Message_OrderMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_OrderMessage(const Message_OrderMessage& from); + Message_OrderMessage(Message_OrderMessage&& from) noexcept + : Message_OrderMessage() { + *this = ::std::move(from); + } + + inline Message_OrderMessage& operator=(const Message_OrderMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_OrderMessage& operator=(Message_OrderMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_OrderMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_OrderMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_OrderMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 110; + + friend void swap(Message_OrderMessage& a, Message_OrderMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_OrderMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_OrderMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_OrderMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_OrderMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_OrderMessage& from) { + Message_OrderMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_OrderMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.OrderMessage"; + } + protected: + explicit Message_OrderMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Message_OrderMessage_OrderStatus OrderStatus; + static constexpr OrderStatus INQUIRY = + Message_OrderMessage_OrderStatus_INQUIRY; + static inline bool OrderStatus_IsValid(int value) { + return Message_OrderMessage_OrderStatus_IsValid(value); + } + static constexpr OrderStatus OrderStatus_MIN = + Message_OrderMessage_OrderStatus_OrderStatus_MIN; + static constexpr OrderStatus OrderStatus_MAX = + Message_OrderMessage_OrderStatus_OrderStatus_MAX; + static constexpr int OrderStatus_ARRAYSIZE = + Message_OrderMessage_OrderStatus_OrderStatus_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + OrderStatus_descriptor() { + return Message_OrderMessage_OrderStatus_descriptor(); + } + template + static inline const std::string& OrderStatus_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function OrderStatus_Name."); + return Message_OrderMessage_OrderStatus_Name(enum_t_value); + } + static inline bool OrderStatus_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + OrderStatus* value) { + return Message_OrderMessage_OrderStatus_Parse(name, value); + } + + typedef Message_OrderMessage_OrderSurface OrderSurface; + static constexpr OrderSurface CATALOG = + Message_OrderMessage_OrderSurface_CATALOG; + static inline bool OrderSurface_IsValid(int value) { + return Message_OrderMessage_OrderSurface_IsValid(value); + } + static constexpr OrderSurface OrderSurface_MIN = + Message_OrderMessage_OrderSurface_OrderSurface_MIN; + static constexpr OrderSurface OrderSurface_MAX = + Message_OrderMessage_OrderSurface_OrderSurface_MAX; + static constexpr int OrderSurface_ARRAYSIZE = + Message_OrderMessage_OrderSurface_OrderSurface_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + OrderSurface_descriptor() { + return Message_OrderMessage_OrderSurface_descriptor(); + } + template + static inline const std::string& OrderSurface_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function OrderSurface_Name."); + return Message_OrderMessage_OrderSurface_Name(enum_t_value); + } + static inline bool OrderSurface_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + OrderSurface* value) { + return Message_OrderMessage_OrderSurface_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kOrderIdFieldNumber = 1, + kThumbnailFieldNumber = 2, + kMessageFieldNumber = 6, + kOrderTitleFieldNumber = 7, + kSellerJidFieldNumber = 8, + kTokenFieldNumber = 9, + kTotalCurrencyCodeFieldNumber = 11, + kContextInfoFieldNumber = 17, + kTotalAmount1000FieldNumber = 10, + kItemCountFieldNumber = 3, + kStatusFieldNumber = 4, + kSurfaceFieldNumber = 5, + }; + // optional string orderId = 1; + bool has_orderid() const; + private: + bool _internal_has_orderid() const; + public: + void clear_orderid(); + const std::string& orderid() const; + template + void set_orderid(ArgT0&& arg0, ArgT... args); + std::string* mutable_orderid(); + PROTOBUF_NODISCARD std::string* release_orderid(); + void set_allocated_orderid(std::string* orderid); + private: + const std::string& _internal_orderid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_orderid(const std::string& value); + std::string* _internal_mutable_orderid(); + public: + + // optional bytes thumbnail = 2; + bool has_thumbnail() const; + private: + bool _internal_has_thumbnail() const; + public: + void clear_thumbnail(); + const std::string& thumbnail() const; + template + void set_thumbnail(ArgT0&& arg0, ArgT... args); + std::string* mutable_thumbnail(); + PROTOBUF_NODISCARD std::string* release_thumbnail(); + void set_allocated_thumbnail(std::string* thumbnail); + private: + const std::string& _internal_thumbnail() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnail(const std::string& value); + std::string* _internal_mutable_thumbnail(); + public: + + // optional string message = 6; + bool has_message() const; + private: + bool _internal_has_message() const; + public: + void clear_message(); + const std::string& message() const; + template + void set_message(ArgT0&& arg0, ArgT... args); + std::string* mutable_message(); + PROTOBUF_NODISCARD std::string* release_message(); + void set_allocated_message(std::string* message); + private: + const std::string& _internal_message() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_message(const std::string& value); + std::string* _internal_mutable_message(); + public: + + // optional string orderTitle = 7; + bool has_ordertitle() const; + private: + bool _internal_has_ordertitle() const; + public: + void clear_ordertitle(); + const std::string& ordertitle() const; + template + void set_ordertitle(ArgT0&& arg0, ArgT... args); + std::string* mutable_ordertitle(); + PROTOBUF_NODISCARD std::string* release_ordertitle(); + void set_allocated_ordertitle(std::string* ordertitle); + private: + const std::string& _internal_ordertitle() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_ordertitle(const std::string& value); + std::string* _internal_mutable_ordertitle(); + public: + + // optional string sellerJid = 8; + bool has_sellerjid() const; + private: + bool _internal_has_sellerjid() const; + public: + void clear_sellerjid(); + const std::string& sellerjid() const; + template + void set_sellerjid(ArgT0&& arg0, ArgT... args); + std::string* mutable_sellerjid(); + PROTOBUF_NODISCARD std::string* release_sellerjid(); + void set_allocated_sellerjid(std::string* sellerjid); + private: + const std::string& _internal_sellerjid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_sellerjid(const std::string& value); + std::string* _internal_mutable_sellerjid(); + public: + + // optional string token = 9; + bool has_token() const; + private: + bool _internal_has_token() const; + public: + void clear_token(); + const std::string& token() const; + template + void set_token(ArgT0&& arg0, ArgT... args); + std::string* mutable_token(); + PROTOBUF_NODISCARD std::string* release_token(); + void set_allocated_token(std::string* token); + private: + const std::string& _internal_token() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_token(const std::string& value); + std::string* _internal_mutable_token(); + public: + + // optional string totalCurrencyCode = 11; + bool has_totalcurrencycode() const; + private: + bool _internal_has_totalcurrencycode() const; + public: + void clear_totalcurrencycode(); + const std::string& totalcurrencycode() const; + template + void set_totalcurrencycode(ArgT0&& arg0, ArgT... args); + std::string* mutable_totalcurrencycode(); + PROTOBUF_NODISCARD std::string* release_totalcurrencycode(); + void set_allocated_totalcurrencycode(std::string* totalcurrencycode); + private: + const std::string& _internal_totalcurrencycode() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_totalcurrencycode(const std::string& value); + std::string* _internal_mutable_totalcurrencycode(); + public: + + // optional .proto.ContextInfo contextInfo = 17; + bool has_contextinfo() const; + private: + bool _internal_has_contextinfo() const; + public: + void clear_contextinfo(); + const ::proto::ContextInfo& contextinfo() const; + PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); + ::proto::ContextInfo* mutable_contextinfo(); + void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); + private: + const ::proto::ContextInfo& _internal_contextinfo() const; + ::proto::ContextInfo* _internal_mutable_contextinfo(); + public: + void unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo); + ::proto::ContextInfo* unsafe_arena_release_contextinfo(); + + // optional int64 totalAmount1000 = 10; + bool has_totalamount1000() const; + private: + bool _internal_has_totalamount1000() const; + public: + void clear_totalamount1000(); + int64_t totalamount1000() const; + void set_totalamount1000(int64_t value); + private: + int64_t _internal_totalamount1000() const; + void _internal_set_totalamount1000(int64_t value); + public: + + // optional int32 itemCount = 3; + bool has_itemcount() const; + private: + bool _internal_has_itemcount() const; + public: + void clear_itemcount(); + int32_t itemcount() const; + void set_itemcount(int32_t value); + private: + int32_t _internal_itemcount() const; + void _internal_set_itemcount(int32_t value); + public: + + // optional .proto.Message.OrderMessage.OrderStatus status = 4; + bool has_status() const; + private: + bool _internal_has_status() const; + public: + void clear_status(); + ::proto::Message_OrderMessage_OrderStatus status() const; + void set_status(::proto::Message_OrderMessage_OrderStatus value); + private: + ::proto::Message_OrderMessage_OrderStatus _internal_status() const; + void _internal_set_status(::proto::Message_OrderMessage_OrderStatus value); + public: + + // optional .proto.Message.OrderMessage.OrderSurface surface = 5; + bool has_surface() const; + private: + bool _internal_has_surface() const; + public: + void clear_surface(); + ::proto::Message_OrderMessage_OrderSurface surface() const; + void set_surface(::proto::Message_OrderMessage_OrderSurface value); + private: + ::proto::Message_OrderMessage_OrderSurface _internal_surface() const; + void _internal_set_surface(::proto::Message_OrderMessage_OrderSurface value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.OrderMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr orderid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnail_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ordertitle_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sellerjid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr token_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr totalcurrencycode_; + ::proto::ContextInfo* contextinfo_; + int64_t totalamount1000_; + int32_t itemcount_; + int status_; + int surface_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_PaymentInviteMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.PaymentInviteMessage) */ { + public: + inline Message_PaymentInviteMessage() : Message_PaymentInviteMessage(nullptr) {} + ~Message_PaymentInviteMessage() override; + explicit PROTOBUF_CONSTEXPR Message_PaymentInviteMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_PaymentInviteMessage(const Message_PaymentInviteMessage& from); + Message_PaymentInviteMessage(Message_PaymentInviteMessage&& from) noexcept + : Message_PaymentInviteMessage() { + *this = ::std::move(from); + } + + inline Message_PaymentInviteMessage& operator=(const Message_PaymentInviteMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_PaymentInviteMessage& operator=(Message_PaymentInviteMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_PaymentInviteMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_PaymentInviteMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_PaymentInviteMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 111; + + friend void swap(Message_PaymentInviteMessage& a, Message_PaymentInviteMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_PaymentInviteMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_PaymentInviteMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_PaymentInviteMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_PaymentInviteMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_PaymentInviteMessage& from) { + Message_PaymentInviteMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_PaymentInviteMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.PaymentInviteMessage"; + } + protected: + explicit Message_PaymentInviteMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Message_PaymentInviteMessage_ServiceType ServiceType; + static constexpr ServiceType UNKNOWN = + Message_PaymentInviteMessage_ServiceType_UNKNOWN; + static constexpr ServiceType FBPAY = + Message_PaymentInviteMessage_ServiceType_FBPAY; + static constexpr ServiceType NOVI = + Message_PaymentInviteMessage_ServiceType_NOVI; + static constexpr ServiceType UPI = + Message_PaymentInviteMessage_ServiceType_UPI; + static inline bool ServiceType_IsValid(int value) { + return Message_PaymentInviteMessage_ServiceType_IsValid(value); + } + static constexpr ServiceType ServiceType_MIN = + Message_PaymentInviteMessage_ServiceType_ServiceType_MIN; + static constexpr ServiceType ServiceType_MAX = + Message_PaymentInviteMessage_ServiceType_ServiceType_MAX; + static constexpr int ServiceType_ARRAYSIZE = + Message_PaymentInviteMessage_ServiceType_ServiceType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + ServiceType_descriptor() { + return Message_PaymentInviteMessage_ServiceType_descriptor(); + } + template + static inline const std::string& ServiceType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ServiceType_Name."); + return Message_PaymentInviteMessage_ServiceType_Name(enum_t_value); + } + static inline bool ServiceType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + ServiceType* value) { + return Message_PaymentInviteMessage_ServiceType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kExpiryTimestampFieldNumber = 2, + kServiceTypeFieldNumber = 1, + }; + // optional int64 expiryTimestamp = 2; + bool has_expirytimestamp() const; + private: + bool _internal_has_expirytimestamp() const; + public: + void clear_expirytimestamp(); + int64_t expirytimestamp() const; + void set_expirytimestamp(int64_t value); + private: + int64_t _internal_expirytimestamp() const; + void _internal_set_expirytimestamp(int64_t value); + public: + + // optional .proto.Message.PaymentInviteMessage.ServiceType serviceType = 1; + bool has_servicetype() const; + private: + bool _internal_has_servicetype() const; + public: + void clear_servicetype(); + ::proto::Message_PaymentInviteMessage_ServiceType servicetype() const; + void set_servicetype(::proto::Message_PaymentInviteMessage_ServiceType value); + private: + ::proto::Message_PaymentInviteMessage_ServiceType _internal_servicetype() const; + void _internal_set_servicetype(::proto::Message_PaymentInviteMessage_ServiceType value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.PaymentInviteMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + int64_t expirytimestamp_; + int servicetype_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_PollCreationMessage_Option final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.PollCreationMessage.Option) */ { + public: + inline Message_PollCreationMessage_Option() : Message_PollCreationMessage_Option(nullptr) {} + ~Message_PollCreationMessage_Option() override; + explicit PROTOBUF_CONSTEXPR Message_PollCreationMessage_Option(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_PollCreationMessage_Option(const Message_PollCreationMessage_Option& from); + Message_PollCreationMessage_Option(Message_PollCreationMessage_Option&& from) noexcept + : Message_PollCreationMessage_Option() { + *this = ::std::move(from); + } + + inline Message_PollCreationMessage_Option& operator=(const Message_PollCreationMessage_Option& from) { + CopyFrom(from); + return *this; + } + inline Message_PollCreationMessage_Option& operator=(Message_PollCreationMessage_Option&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_PollCreationMessage_Option& default_instance() { + return *internal_default_instance(); + } + static inline const Message_PollCreationMessage_Option* internal_default_instance() { + return reinterpret_cast( + &_Message_PollCreationMessage_Option_default_instance_); + } + static constexpr int kIndexInFileMessages = + 112; + + friend void swap(Message_PollCreationMessage_Option& a, Message_PollCreationMessage_Option& b) { + a.Swap(&b); + } + inline void Swap(Message_PollCreationMessage_Option* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_PollCreationMessage_Option* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_PollCreationMessage_Option* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_PollCreationMessage_Option& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_PollCreationMessage_Option& from) { + Message_PollCreationMessage_Option::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_PollCreationMessage_Option* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.PollCreationMessage.Option"; + } + protected: + explicit Message_PollCreationMessage_Option(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kOptionNameFieldNumber = 1, + }; + // optional string optionName = 1; + bool has_optionname() const; + private: + bool _internal_has_optionname() const; + public: + void clear_optionname(); + const std::string& optionname() const; + template + void set_optionname(ArgT0&& arg0, ArgT... args); + std::string* mutable_optionname(); + PROTOBUF_NODISCARD std::string* release_optionname(); + void set_allocated_optionname(std::string* optionname); + private: + const std::string& _internal_optionname() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_optionname(const std::string& value); + std::string* _internal_mutable_optionname(); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.PollCreationMessage.Option) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr optionname_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_PollCreationMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.PollCreationMessage) */ { + public: + inline Message_PollCreationMessage() : Message_PollCreationMessage(nullptr) {} + ~Message_PollCreationMessage() override; + explicit PROTOBUF_CONSTEXPR Message_PollCreationMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_PollCreationMessage(const Message_PollCreationMessage& from); + Message_PollCreationMessage(Message_PollCreationMessage&& from) noexcept + : Message_PollCreationMessage() { + *this = ::std::move(from); + } + + inline Message_PollCreationMessage& operator=(const Message_PollCreationMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_PollCreationMessage& operator=(Message_PollCreationMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_PollCreationMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_PollCreationMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_PollCreationMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 113; + + friend void swap(Message_PollCreationMessage& a, Message_PollCreationMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_PollCreationMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_PollCreationMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_PollCreationMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_PollCreationMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_PollCreationMessage& from) { + Message_PollCreationMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_PollCreationMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.PollCreationMessage"; + } + protected: + explicit Message_PollCreationMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Message_PollCreationMessage_Option Option; + + // accessors ------------------------------------------------------- + + enum : int { + kOptionsFieldNumber = 3, + kEncKeyFieldNumber = 1, + kNameFieldNumber = 2, + kContextInfoFieldNumber = 5, + kSelectableOptionsCountFieldNumber = 4, + }; + // repeated .proto.Message.PollCreationMessage.Option options = 3; + int options_size() const; + private: + int _internal_options_size() const; + public: + void clear_options(); + ::proto::Message_PollCreationMessage_Option* mutable_options(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_PollCreationMessage_Option >* + mutable_options(); + private: + const ::proto::Message_PollCreationMessage_Option& _internal_options(int index) const; + ::proto::Message_PollCreationMessage_Option* _internal_add_options(); + public: + const ::proto::Message_PollCreationMessage_Option& options(int index) const; + ::proto::Message_PollCreationMessage_Option* add_options(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_PollCreationMessage_Option >& + options() const; + + // optional bytes encKey = 1; + bool has_enckey() const; + private: + bool _internal_has_enckey() const; + public: + void clear_enckey(); + const std::string& enckey() const; + template + void set_enckey(ArgT0&& arg0, ArgT... args); + std::string* mutable_enckey(); + PROTOBUF_NODISCARD std::string* release_enckey(); + void set_allocated_enckey(std::string* enckey); + private: + const std::string& _internal_enckey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_enckey(const std::string& value); + std::string* _internal_mutable_enckey(); + public: + + // optional string name = 2; + bool has_name() const; + private: + bool _internal_has_name() const; + public: + void clear_name(); + const std::string& name() const; + template + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + PROTOBUF_NODISCARD std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // optional .proto.ContextInfo contextInfo = 5; + bool has_contextinfo() const; + private: + bool _internal_has_contextinfo() const; + public: + void clear_contextinfo(); + const ::proto::ContextInfo& contextinfo() const; + PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); + ::proto::ContextInfo* mutable_contextinfo(); + void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); + private: + const ::proto::ContextInfo& _internal_contextinfo() const; + ::proto::ContextInfo* _internal_mutable_contextinfo(); + public: + void unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo); + ::proto::ContextInfo* unsafe_arena_release_contextinfo(); + + // optional uint32 selectableOptionsCount = 4; + bool has_selectableoptionscount() const; + private: + bool _internal_has_selectableoptionscount() const; + public: + void clear_selectableoptionscount(); + uint32_t selectableoptionscount() const; + void set_selectableoptionscount(uint32_t value); + private: + uint32_t _internal_selectableoptionscount() const; + void _internal_set_selectableoptionscount(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.PollCreationMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_PollCreationMessage_Option > options_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr enckey_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::proto::ContextInfo* contextinfo_; + uint32_t selectableoptionscount_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_PollEncValue final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.PollEncValue) */ { + public: + inline Message_PollEncValue() : Message_PollEncValue(nullptr) {} + ~Message_PollEncValue() override; + explicit PROTOBUF_CONSTEXPR Message_PollEncValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_PollEncValue(const Message_PollEncValue& from); + Message_PollEncValue(Message_PollEncValue&& from) noexcept + : Message_PollEncValue() { + *this = ::std::move(from); + } + + inline Message_PollEncValue& operator=(const Message_PollEncValue& from) { + CopyFrom(from); + return *this; + } + inline Message_PollEncValue& operator=(Message_PollEncValue&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_PollEncValue& default_instance() { + return *internal_default_instance(); + } + static inline const Message_PollEncValue* internal_default_instance() { + return reinterpret_cast( + &_Message_PollEncValue_default_instance_); + } + static constexpr int kIndexInFileMessages = + 114; + + friend void swap(Message_PollEncValue& a, Message_PollEncValue& b) { + a.Swap(&b); + } + inline void Swap(Message_PollEncValue* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_PollEncValue* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_PollEncValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_PollEncValue& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_PollEncValue& from) { + Message_PollEncValue::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_PollEncValue* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.PollEncValue"; + } + protected: + explicit Message_PollEncValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kEncPayloadFieldNumber = 1, + kEncIvFieldNumber = 2, + }; + // optional bytes encPayload = 1; + bool has_encpayload() const; + private: + bool _internal_has_encpayload() const; + public: + void clear_encpayload(); + const std::string& encpayload() const; + template + void set_encpayload(ArgT0&& arg0, ArgT... args); + std::string* mutable_encpayload(); + PROTOBUF_NODISCARD std::string* release_encpayload(); + void set_allocated_encpayload(std::string* encpayload); + private: + const std::string& _internal_encpayload() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_encpayload(const std::string& value); + std::string* _internal_mutable_encpayload(); + public: + + // optional bytes encIv = 2; + bool has_enciv() const; + private: + bool _internal_has_enciv() const; + public: + void clear_enciv(); + const std::string& enciv() const; + template + void set_enciv(ArgT0&& arg0, ArgT... args); + std::string* mutable_enciv(); + PROTOBUF_NODISCARD std::string* release_enciv(); + void set_allocated_enciv(std::string* enciv); + private: + const std::string& _internal_enciv() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_enciv(const std::string& value); + std::string* _internal_mutable_enciv(); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.PollEncValue) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encpayload_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr enciv_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_PollUpdateMessageMetadata final : + public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:proto.Message.PollUpdateMessageMetadata) */ { + public: + inline Message_PollUpdateMessageMetadata() : Message_PollUpdateMessageMetadata(nullptr) {} + explicit PROTOBUF_CONSTEXPR Message_PollUpdateMessageMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_PollUpdateMessageMetadata(const Message_PollUpdateMessageMetadata& from); + Message_PollUpdateMessageMetadata(Message_PollUpdateMessageMetadata&& from) noexcept + : Message_PollUpdateMessageMetadata() { + *this = ::std::move(from); + } + + inline Message_PollUpdateMessageMetadata& operator=(const Message_PollUpdateMessageMetadata& from) { + CopyFrom(from); + return *this; + } + inline Message_PollUpdateMessageMetadata& operator=(Message_PollUpdateMessageMetadata&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_PollUpdateMessageMetadata& default_instance() { + return *internal_default_instance(); + } + static inline const Message_PollUpdateMessageMetadata* internal_default_instance() { + return reinterpret_cast( + &_Message_PollUpdateMessageMetadata_default_instance_); + } + static constexpr int kIndexInFileMessages = + 115; + + friend void swap(Message_PollUpdateMessageMetadata& a, Message_PollUpdateMessageMetadata& b) { + a.Swap(&b); + } + inline void Swap(Message_PollUpdateMessageMetadata* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_PollUpdateMessageMetadata* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_PollUpdateMessageMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const Message_PollUpdateMessageMetadata& from) { + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from); + } + using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const Message_PollUpdateMessageMetadata& from) { + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from); + } + public: + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.PollUpdateMessageMetadata"; + } + protected: + explicit Message_PollUpdateMessageMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // @@protoc_insertion_point(class_scope:proto.Message.PollUpdateMessageMetadata) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_PollUpdateMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.PollUpdateMessage) */ { + public: + inline Message_PollUpdateMessage() : Message_PollUpdateMessage(nullptr) {} + ~Message_PollUpdateMessage() override; + explicit PROTOBUF_CONSTEXPR Message_PollUpdateMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_PollUpdateMessage(const Message_PollUpdateMessage& from); + Message_PollUpdateMessage(Message_PollUpdateMessage&& from) noexcept + : Message_PollUpdateMessage() { + *this = ::std::move(from); + } + + inline Message_PollUpdateMessage& operator=(const Message_PollUpdateMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_PollUpdateMessage& operator=(Message_PollUpdateMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_PollUpdateMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_PollUpdateMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_PollUpdateMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 116; + + friend void swap(Message_PollUpdateMessage& a, Message_PollUpdateMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_PollUpdateMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_PollUpdateMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_PollUpdateMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_PollUpdateMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_PollUpdateMessage& from) { + Message_PollUpdateMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_PollUpdateMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.PollUpdateMessage"; + } + protected: + explicit Message_PollUpdateMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kPollCreationMessageKeyFieldNumber = 1, + kVoteFieldNumber = 2, + kMetadataFieldNumber = 3, + kSenderTimestampMsFieldNumber = 4, + }; + // optional .proto.MessageKey pollCreationMessageKey = 1; + bool has_pollcreationmessagekey() const; + private: + bool _internal_has_pollcreationmessagekey() const; + public: + void clear_pollcreationmessagekey(); + const ::proto::MessageKey& pollcreationmessagekey() const; + PROTOBUF_NODISCARD ::proto::MessageKey* release_pollcreationmessagekey(); + ::proto::MessageKey* mutable_pollcreationmessagekey(); + void set_allocated_pollcreationmessagekey(::proto::MessageKey* pollcreationmessagekey); + private: + const ::proto::MessageKey& _internal_pollcreationmessagekey() const; + ::proto::MessageKey* _internal_mutable_pollcreationmessagekey(); + public: + void unsafe_arena_set_allocated_pollcreationmessagekey( + ::proto::MessageKey* pollcreationmessagekey); + ::proto::MessageKey* unsafe_arena_release_pollcreationmessagekey(); + + // optional .proto.Message.PollEncValue vote = 2; + bool has_vote() const; + private: + bool _internal_has_vote() const; + public: + void clear_vote(); + const ::proto::Message_PollEncValue& vote() const; + PROTOBUF_NODISCARD ::proto::Message_PollEncValue* release_vote(); + ::proto::Message_PollEncValue* mutable_vote(); + void set_allocated_vote(::proto::Message_PollEncValue* vote); + private: + const ::proto::Message_PollEncValue& _internal_vote() const; + ::proto::Message_PollEncValue* _internal_mutable_vote(); + public: + void unsafe_arena_set_allocated_vote( + ::proto::Message_PollEncValue* vote); + ::proto::Message_PollEncValue* unsafe_arena_release_vote(); + + // optional .proto.Message.PollUpdateMessageMetadata metadata = 3; + bool has_metadata() const; + private: + bool _internal_has_metadata() const; + public: + void clear_metadata(); + const ::proto::Message_PollUpdateMessageMetadata& metadata() const; + PROTOBUF_NODISCARD ::proto::Message_PollUpdateMessageMetadata* release_metadata(); + ::proto::Message_PollUpdateMessageMetadata* mutable_metadata(); + void set_allocated_metadata(::proto::Message_PollUpdateMessageMetadata* metadata); + private: + const ::proto::Message_PollUpdateMessageMetadata& _internal_metadata() const; + ::proto::Message_PollUpdateMessageMetadata* _internal_mutable_metadata(); + public: + void unsafe_arena_set_allocated_metadata( + ::proto::Message_PollUpdateMessageMetadata* metadata); + ::proto::Message_PollUpdateMessageMetadata* unsafe_arena_release_metadata(); + + // optional int64 senderTimestampMs = 4; + bool has_sendertimestampms() const; + private: + bool _internal_has_sendertimestampms() const; + public: + void clear_sendertimestampms(); + int64_t sendertimestampms() const; + void set_sendertimestampms(int64_t value); + private: + int64_t _internal_sendertimestampms() const; + void _internal_set_sendertimestampms(int64_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.PollUpdateMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::proto::MessageKey* pollcreationmessagekey_; + ::proto::Message_PollEncValue* vote_; + ::proto::Message_PollUpdateMessageMetadata* metadata_; + int64_t sendertimestampms_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_PollVoteMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.PollVoteMessage) */ { + public: + inline Message_PollVoteMessage() : Message_PollVoteMessage(nullptr) {} + ~Message_PollVoteMessage() override; + explicit PROTOBUF_CONSTEXPR Message_PollVoteMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_PollVoteMessage(const Message_PollVoteMessage& from); + Message_PollVoteMessage(Message_PollVoteMessage&& from) noexcept + : Message_PollVoteMessage() { + *this = ::std::move(from); + } + + inline Message_PollVoteMessage& operator=(const Message_PollVoteMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_PollVoteMessage& operator=(Message_PollVoteMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_PollVoteMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_PollVoteMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_PollVoteMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 117; + + friend void swap(Message_PollVoteMessage& a, Message_PollVoteMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_PollVoteMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_PollVoteMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_PollVoteMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_PollVoteMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_PollVoteMessage& from) { + Message_PollVoteMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_PollVoteMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.PollVoteMessage"; + } + protected: + explicit Message_PollVoteMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSelectedOptionsFieldNumber = 1, + }; + // repeated bytes selectedOptions = 1; + int selectedoptions_size() const; + private: + int _internal_selectedoptions_size() const; + public: + void clear_selectedoptions(); + const std::string& selectedoptions(int index) const; + std::string* mutable_selectedoptions(int index); + void set_selectedoptions(int index, const std::string& value); + void set_selectedoptions(int index, std::string&& value); + void set_selectedoptions(int index, const char* value); + void set_selectedoptions(int index, const void* value, size_t size); + std::string* add_selectedoptions(); + void add_selectedoptions(const std::string& value); + void add_selectedoptions(std::string&& value); + void add_selectedoptions(const char* value); + void add_selectedoptions(const void* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& selectedoptions() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_selectedoptions(); + private: + const std::string& _internal_selectedoptions(int index) const; + std::string* _internal_add_selectedoptions(); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.PollVoteMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField selectedoptions_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_ProductMessage_CatalogSnapshot final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ProductMessage.CatalogSnapshot) */ { + public: + inline Message_ProductMessage_CatalogSnapshot() : Message_ProductMessage_CatalogSnapshot(nullptr) {} + ~Message_ProductMessage_CatalogSnapshot() override; + explicit PROTOBUF_CONSTEXPR Message_ProductMessage_CatalogSnapshot(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_ProductMessage_CatalogSnapshot(const Message_ProductMessage_CatalogSnapshot& from); + Message_ProductMessage_CatalogSnapshot(Message_ProductMessage_CatalogSnapshot&& from) noexcept + : Message_ProductMessage_CatalogSnapshot() { + *this = ::std::move(from); + } + + inline Message_ProductMessage_CatalogSnapshot& operator=(const Message_ProductMessage_CatalogSnapshot& from) { + CopyFrom(from); + return *this; + } + inline Message_ProductMessage_CatalogSnapshot& operator=(Message_ProductMessage_CatalogSnapshot&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_ProductMessage_CatalogSnapshot& default_instance() { + return *internal_default_instance(); + } + static inline const Message_ProductMessage_CatalogSnapshot* internal_default_instance() { + return reinterpret_cast( + &_Message_ProductMessage_CatalogSnapshot_default_instance_); + } + static constexpr int kIndexInFileMessages = + 118; + + friend void swap(Message_ProductMessage_CatalogSnapshot& a, Message_ProductMessage_CatalogSnapshot& b) { + a.Swap(&b); + } + inline void Swap(Message_ProductMessage_CatalogSnapshot* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_ProductMessage_CatalogSnapshot* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_ProductMessage_CatalogSnapshot* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_ProductMessage_CatalogSnapshot& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_ProductMessage_CatalogSnapshot& from) { + Message_ProductMessage_CatalogSnapshot::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_ProductMessage_CatalogSnapshot* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.ProductMessage.CatalogSnapshot"; + } + protected: + explicit Message_ProductMessage_CatalogSnapshot(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kTitleFieldNumber = 2, + kDescriptionFieldNumber = 3, + kCatalogImageFieldNumber = 1, + }; + // optional string title = 2; + bool has_title() const; + private: + bool _internal_has_title() const; + public: + void clear_title(); + const std::string& title() const; + template + void set_title(ArgT0&& arg0, ArgT... args); + std::string* mutable_title(); + PROTOBUF_NODISCARD std::string* release_title(); + void set_allocated_title(std::string* title); + private: + const std::string& _internal_title() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value); + std::string* _internal_mutable_title(); + public: + + // optional string description = 3; + bool has_description() const; + private: + bool _internal_has_description() const; + public: + void clear_description(); + const std::string& description() const; + template + void set_description(ArgT0&& arg0, ArgT... args); + std::string* mutable_description(); + PROTOBUF_NODISCARD std::string* release_description(); + void set_allocated_description(std::string* description); + private: + const std::string& _internal_description() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value); + std::string* _internal_mutable_description(); + public: + + // optional .proto.Message.ImageMessage catalogImage = 1; + bool has_catalogimage() const; + private: + bool _internal_has_catalogimage() const; + public: + void clear_catalogimage(); + const ::proto::Message_ImageMessage& catalogimage() const; + PROTOBUF_NODISCARD ::proto::Message_ImageMessage* release_catalogimage(); + ::proto::Message_ImageMessage* mutable_catalogimage(); + void set_allocated_catalogimage(::proto::Message_ImageMessage* catalogimage); + private: + const ::proto::Message_ImageMessage& _internal_catalogimage() const; + ::proto::Message_ImageMessage* _internal_mutable_catalogimage(); + public: + void unsafe_arena_set_allocated_catalogimage( + ::proto::Message_ImageMessage* catalogimage); + ::proto::Message_ImageMessage* unsafe_arena_release_catalogimage(); + + // @@protoc_insertion_point(class_scope:proto.Message.ProductMessage.CatalogSnapshot) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_; + ::proto::Message_ImageMessage* catalogimage_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_ProductMessage_ProductSnapshot final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ProductMessage.ProductSnapshot) */ { + public: + inline Message_ProductMessage_ProductSnapshot() : Message_ProductMessage_ProductSnapshot(nullptr) {} + ~Message_ProductMessage_ProductSnapshot() override; + explicit PROTOBUF_CONSTEXPR Message_ProductMessage_ProductSnapshot(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_ProductMessage_ProductSnapshot(const Message_ProductMessage_ProductSnapshot& from); + Message_ProductMessage_ProductSnapshot(Message_ProductMessage_ProductSnapshot&& from) noexcept + : Message_ProductMessage_ProductSnapshot() { + *this = ::std::move(from); + } + + inline Message_ProductMessage_ProductSnapshot& operator=(const Message_ProductMessage_ProductSnapshot& from) { + CopyFrom(from); + return *this; + } + inline Message_ProductMessage_ProductSnapshot& operator=(Message_ProductMessage_ProductSnapshot&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_ProductMessage_ProductSnapshot& default_instance() { + return *internal_default_instance(); + } + static inline const Message_ProductMessage_ProductSnapshot* internal_default_instance() { + return reinterpret_cast( + &_Message_ProductMessage_ProductSnapshot_default_instance_); + } + static constexpr int kIndexInFileMessages = + 119; + + friend void swap(Message_ProductMessage_ProductSnapshot& a, Message_ProductMessage_ProductSnapshot& b) { + a.Swap(&b); + } + inline void Swap(Message_ProductMessage_ProductSnapshot* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_ProductMessage_ProductSnapshot* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_ProductMessage_ProductSnapshot* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_ProductMessage_ProductSnapshot& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_ProductMessage_ProductSnapshot& from) { + Message_ProductMessage_ProductSnapshot::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_ProductMessage_ProductSnapshot* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.ProductMessage.ProductSnapshot"; + } + protected: + explicit Message_ProductMessage_ProductSnapshot(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kProductIdFieldNumber = 2, + kTitleFieldNumber = 3, + kDescriptionFieldNumber = 4, + kCurrencyCodeFieldNumber = 5, + kRetailerIdFieldNumber = 7, + kUrlFieldNumber = 8, + kFirstImageIdFieldNumber = 11, + kProductImageFieldNumber = 1, + kPriceAmount1000FieldNumber = 6, + kSalePriceAmount1000FieldNumber = 12, + kProductImageCountFieldNumber = 9, + }; + // optional string productId = 2; + bool has_productid() const; + private: + bool _internal_has_productid() const; + public: + void clear_productid(); + const std::string& productid() const; + template + void set_productid(ArgT0&& arg0, ArgT... args); + std::string* mutable_productid(); + PROTOBUF_NODISCARD std::string* release_productid(); + void set_allocated_productid(std::string* productid); + private: + const std::string& _internal_productid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_productid(const std::string& value); + std::string* _internal_mutable_productid(); + public: + + // optional string title = 3; + bool has_title() const; + private: + bool _internal_has_title() const; + public: + void clear_title(); + const std::string& title() const; + template + void set_title(ArgT0&& arg0, ArgT... args); + std::string* mutable_title(); + PROTOBUF_NODISCARD std::string* release_title(); + void set_allocated_title(std::string* title); + private: + const std::string& _internal_title() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value); + std::string* _internal_mutable_title(); + public: + + // optional string description = 4; + bool has_description() const; + private: + bool _internal_has_description() const; + public: + void clear_description(); + const std::string& description() const; + template + void set_description(ArgT0&& arg0, ArgT... args); + std::string* mutable_description(); + PROTOBUF_NODISCARD std::string* release_description(); + void set_allocated_description(std::string* description); + private: + const std::string& _internal_description() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value); + std::string* _internal_mutable_description(); + public: + + // optional string currencyCode = 5; + bool has_currencycode() const; + private: + bool _internal_has_currencycode() const; + public: + void clear_currencycode(); + const std::string& currencycode() const; + template + void set_currencycode(ArgT0&& arg0, ArgT... args); + std::string* mutable_currencycode(); + PROTOBUF_NODISCARD std::string* release_currencycode(); + void set_allocated_currencycode(std::string* currencycode); + private: + const std::string& _internal_currencycode() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_currencycode(const std::string& value); + std::string* _internal_mutable_currencycode(); + public: + + // optional string retailerId = 7; + bool has_retailerid() const; + private: + bool _internal_has_retailerid() const; + public: + void clear_retailerid(); + const std::string& retailerid() const; + template + void set_retailerid(ArgT0&& arg0, ArgT... args); + std::string* mutable_retailerid(); + PROTOBUF_NODISCARD std::string* release_retailerid(); + void set_allocated_retailerid(std::string* retailerid); + private: + const std::string& _internal_retailerid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_retailerid(const std::string& value); + std::string* _internal_mutable_retailerid(); + public: + + // optional string url = 8; + bool has_url() const; + private: + bool _internal_has_url() const; + public: + void clear_url(); + const std::string& url() const; + template + void set_url(ArgT0&& arg0, ArgT... args); + std::string* mutable_url(); + PROTOBUF_NODISCARD std::string* release_url(); + void set_allocated_url(std::string* url); + private: + const std::string& _internal_url() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value); + std::string* _internal_mutable_url(); + public: + + // optional string firstImageId = 11; + bool has_firstimageid() const; + private: + bool _internal_has_firstimageid() const; + public: + void clear_firstimageid(); + const std::string& firstimageid() const; + template + void set_firstimageid(ArgT0&& arg0, ArgT... args); + std::string* mutable_firstimageid(); + PROTOBUF_NODISCARD std::string* release_firstimageid(); + void set_allocated_firstimageid(std::string* firstimageid); + private: + const std::string& _internal_firstimageid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_firstimageid(const std::string& value); + std::string* _internal_mutable_firstimageid(); + public: + + // optional .proto.Message.ImageMessage productImage = 1; + bool has_productimage() const; + private: + bool _internal_has_productimage() const; + public: + void clear_productimage(); + const ::proto::Message_ImageMessage& productimage() const; + PROTOBUF_NODISCARD ::proto::Message_ImageMessage* release_productimage(); + ::proto::Message_ImageMessage* mutable_productimage(); + void set_allocated_productimage(::proto::Message_ImageMessage* productimage); + private: + const ::proto::Message_ImageMessage& _internal_productimage() const; + ::proto::Message_ImageMessage* _internal_mutable_productimage(); + public: + void unsafe_arena_set_allocated_productimage( + ::proto::Message_ImageMessage* productimage); + ::proto::Message_ImageMessage* unsafe_arena_release_productimage(); + + // optional int64 priceAmount1000 = 6; + bool has_priceamount1000() const; + private: + bool _internal_has_priceamount1000() const; + public: + void clear_priceamount1000(); + int64_t priceamount1000() const; + void set_priceamount1000(int64_t value); + private: + int64_t _internal_priceamount1000() const; + void _internal_set_priceamount1000(int64_t value); + public: + + // optional int64 salePriceAmount1000 = 12; + bool has_salepriceamount1000() const; + private: + bool _internal_has_salepriceamount1000() const; + public: + void clear_salepriceamount1000(); + int64_t salepriceamount1000() const; + void set_salepriceamount1000(int64_t value); + private: + int64_t _internal_salepriceamount1000() const; + void _internal_set_salepriceamount1000(int64_t value); + public: + + // optional uint32 productImageCount = 9; + bool has_productimagecount() const; + private: + bool _internal_has_productimagecount() const; + public: + void clear_productimagecount(); + uint32_t productimagecount() const; + void set_productimagecount(uint32_t value); + private: + uint32_t _internal_productimagecount() const; + void _internal_set_productimagecount(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.ProductMessage.ProductSnapshot) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr productid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr currencycode_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr retailerid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr firstimageid_; + ::proto::Message_ImageMessage* productimage_; + int64_t priceamount1000_; + int64_t salepriceamount1000_; + uint32_t productimagecount_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_ProductMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ProductMessage) */ { + public: + inline Message_ProductMessage() : Message_ProductMessage(nullptr) {} + ~Message_ProductMessage() override; + explicit PROTOBUF_CONSTEXPR Message_ProductMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_ProductMessage(const Message_ProductMessage& from); + Message_ProductMessage(Message_ProductMessage&& from) noexcept + : Message_ProductMessage() { + *this = ::std::move(from); + } + + inline Message_ProductMessage& operator=(const Message_ProductMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_ProductMessage& operator=(Message_ProductMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_ProductMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_ProductMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_ProductMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 120; + + friend void swap(Message_ProductMessage& a, Message_ProductMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_ProductMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_ProductMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_ProductMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_ProductMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_ProductMessage& from) { + Message_ProductMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_ProductMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.ProductMessage"; + } + protected: + explicit Message_ProductMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Message_ProductMessage_CatalogSnapshot CatalogSnapshot; + typedef Message_ProductMessage_ProductSnapshot ProductSnapshot; + + // accessors ------------------------------------------------------- + + enum : int { + kBusinessOwnerJidFieldNumber = 2, + kBodyFieldNumber = 5, + kFooterFieldNumber = 6, + kProductFieldNumber = 1, + kCatalogFieldNumber = 4, + kContextInfoFieldNumber = 17, + }; + // optional string businessOwnerJid = 2; + bool has_businessownerjid() const; + private: + bool _internal_has_businessownerjid() const; + public: + void clear_businessownerjid(); + const std::string& businessownerjid() const; + template + void set_businessownerjid(ArgT0&& arg0, ArgT... args); + std::string* mutable_businessownerjid(); + PROTOBUF_NODISCARD std::string* release_businessownerjid(); + void set_allocated_businessownerjid(std::string* businessownerjid); + private: + const std::string& _internal_businessownerjid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_businessownerjid(const std::string& value); + std::string* _internal_mutable_businessownerjid(); + public: + + // optional string body = 5; + bool has_body() const; + private: + bool _internal_has_body() const; + public: + void clear_body(); + const std::string& body() const; + template + void set_body(ArgT0&& arg0, ArgT... args); + std::string* mutable_body(); + PROTOBUF_NODISCARD std::string* release_body(); + void set_allocated_body(std::string* body); + private: + const std::string& _internal_body() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_body(const std::string& value); + std::string* _internal_mutable_body(); + public: + + // optional string footer = 6; + bool has_footer() const; + private: + bool _internal_has_footer() const; + public: + void clear_footer(); + const std::string& footer() const; + template + void set_footer(ArgT0&& arg0, ArgT... args); + std::string* mutable_footer(); + PROTOBUF_NODISCARD std::string* release_footer(); + void set_allocated_footer(std::string* footer); + private: + const std::string& _internal_footer() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_footer(const std::string& value); + std::string* _internal_mutable_footer(); + public: + + // optional .proto.Message.ProductMessage.ProductSnapshot product = 1; + bool has_product() const; + private: + bool _internal_has_product() const; + public: + void clear_product(); + const ::proto::Message_ProductMessage_ProductSnapshot& product() const; + PROTOBUF_NODISCARD ::proto::Message_ProductMessage_ProductSnapshot* release_product(); + ::proto::Message_ProductMessage_ProductSnapshot* mutable_product(); + void set_allocated_product(::proto::Message_ProductMessage_ProductSnapshot* product); + private: + const ::proto::Message_ProductMessage_ProductSnapshot& _internal_product() const; + ::proto::Message_ProductMessage_ProductSnapshot* _internal_mutable_product(); + public: + void unsafe_arena_set_allocated_product( + ::proto::Message_ProductMessage_ProductSnapshot* product); + ::proto::Message_ProductMessage_ProductSnapshot* unsafe_arena_release_product(); + + // optional .proto.Message.ProductMessage.CatalogSnapshot catalog = 4; + bool has_catalog() const; + private: + bool _internal_has_catalog() const; + public: + void clear_catalog(); + const ::proto::Message_ProductMessage_CatalogSnapshot& catalog() const; + PROTOBUF_NODISCARD ::proto::Message_ProductMessage_CatalogSnapshot* release_catalog(); + ::proto::Message_ProductMessage_CatalogSnapshot* mutable_catalog(); + void set_allocated_catalog(::proto::Message_ProductMessage_CatalogSnapshot* catalog); + private: + const ::proto::Message_ProductMessage_CatalogSnapshot& _internal_catalog() const; + ::proto::Message_ProductMessage_CatalogSnapshot* _internal_mutable_catalog(); + public: + void unsafe_arena_set_allocated_catalog( + ::proto::Message_ProductMessage_CatalogSnapshot* catalog); + ::proto::Message_ProductMessage_CatalogSnapshot* unsafe_arena_release_catalog(); + + // optional .proto.ContextInfo contextInfo = 17; + bool has_contextinfo() const; + private: + bool _internal_has_contextinfo() const; + public: + void clear_contextinfo(); + const ::proto::ContextInfo& contextinfo() const; + PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); + ::proto::ContextInfo* mutable_contextinfo(); + void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); + private: + const ::proto::ContextInfo& _internal_contextinfo() const; + ::proto::ContextInfo* _internal_mutable_contextinfo(); + public: + void unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo); + ::proto::ContextInfo* unsafe_arena_release_contextinfo(); + + // @@protoc_insertion_point(class_scope:proto.Message.ProductMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr businessownerjid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr body_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr footer_; + ::proto::Message_ProductMessage_ProductSnapshot* product_; + ::proto::Message_ProductMessage_CatalogSnapshot* catalog_; + ::proto::ContextInfo* contextinfo_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_ProtocolMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ProtocolMessage) */ { + public: + inline Message_ProtocolMessage() : Message_ProtocolMessage(nullptr) {} + ~Message_ProtocolMessage() override; + explicit PROTOBUF_CONSTEXPR Message_ProtocolMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_ProtocolMessage(const Message_ProtocolMessage& from); + Message_ProtocolMessage(Message_ProtocolMessage&& from) noexcept + : Message_ProtocolMessage() { + *this = ::std::move(from); + } + + inline Message_ProtocolMessage& operator=(const Message_ProtocolMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_ProtocolMessage& operator=(Message_ProtocolMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_ProtocolMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_ProtocolMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_ProtocolMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 121; + + friend void swap(Message_ProtocolMessage& a, Message_ProtocolMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_ProtocolMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_ProtocolMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_ProtocolMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_ProtocolMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_ProtocolMessage& from) { + Message_ProtocolMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_ProtocolMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.ProtocolMessage"; + } + protected: + explicit Message_ProtocolMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Message_ProtocolMessage_Type Type; + static constexpr Type REVOKE = + Message_ProtocolMessage_Type_REVOKE; + static constexpr Type EPHEMERAL_SETTING = + Message_ProtocolMessage_Type_EPHEMERAL_SETTING; + static constexpr Type EPHEMERAL_SYNC_RESPONSE = + Message_ProtocolMessage_Type_EPHEMERAL_SYNC_RESPONSE; + static constexpr Type HISTORY_SYNC_NOTIFICATION = + Message_ProtocolMessage_Type_HISTORY_SYNC_NOTIFICATION; + static constexpr Type APP_STATE_SYNC_KEY_SHARE = + Message_ProtocolMessage_Type_APP_STATE_SYNC_KEY_SHARE; + static constexpr Type APP_STATE_SYNC_KEY_REQUEST = + Message_ProtocolMessage_Type_APP_STATE_SYNC_KEY_REQUEST; + static constexpr Type MSG_FANOUT_BACKFILL_REQUEST = + Message_ProtocolMessage_Type_MSG_FANOUT_BACKFILL_REQUEST; + static constexpr Type INITIAL_SECURITY_NOTIFICATION_SETTING_SYNC = + Message_ProtocolMessage_Type_INITIAL_SECURITY_NOTIFICATION_SETTING_SYNC; + static constexpr Type APP_STATE_FATAL_EXCEPTION_NOTIFICATION = + Message_ProtocolMessage_Type_APP_STATE_FATAL_EXCEPTION_NOTIFICATION; + static constexpr Type SHARE_PHONE_NUMBER = + Message_ProtocolMessage_Type_SHARE_PHONE_NUMBER; + static constexpr Type REQUEST_MEDIA_UPLOAD_MESSAGE = + Message_ProtocolMessage_Type_REQUEST_MEDIA_UPLOAD_MESSAGE; + static constexpr Type REQUEST_MEDIA_UPLOAD_RESPONSE_MESSAGE = + Message_ProtocolMessage_Type_REQUEST_MEDIA_UPLOAD_RESPONSE_MESSAGE; + static inline bool Type_IsValid(int value) { + return Message_ProtocolMessage_Type_IsValid(value); + } + static constexpr Type Type_MIN = + Message_ProtocolMessage_Type_Type_MIN; + static constexpr Type Type_MAX = + Message_ProtocolMessage_Type_Type_MAX; + static constexpr int Type_ARRAYSIZE = + Message_ProtocolMessage_Type_Type_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + Type_descriptor() { + return Message_ProtocolMessage_Type_descriptor(); + } + template + static inline const std::string& Type_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Type_Name."); + return Message_ProtocolMessage_Type_Name(enum_t_value); + } + static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Type* value) { + return Message_ProtocolMessage_Type_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kKeyFieldNumber = 1, + kHistorySyncNotificationFieldNumber = 6, + kAppStateSyncKeyShareFieldNumber = 7, + kAppStateSyncKeyRequestFieldNumber = 8, + kInitialSecurityNotificationSettingSyncFieldNumber = 9, + kAppStateFatalExceptionNotificationFieldNumber = 10, + kDisappearingModeFieldNumber = 11, + kRequestMediaUploadMessageFieldNumber = 12, + kRequestMediaUploadResponseMessageFieldNumber = 13, + kTypeFieldNumber = 2, + kEphemeralExpirationFieldNumber = 4, + kEphemeralSettingTimestampFieldNumber = 5, + }; + // optional .proto.MessageKey key = 1; + bool has_key() const; + private: + bool _internal_has_key() const; + public: + void clear_key(); + const ::proto::MessageKey& key() const; + PROTOBUF_NODISCARD ::proto::MessageKey* release_key(); + ::proto::MessageKey* mutable_key(); + void set_allocated_key(::proto::MessageKey* key); + private: + const ::proto::MessageKey& _internal_key() const; + ::proto::MessageKey* _internal_mutable_key(); + public: + void unsafe_arena_set_allocated_key( + ::proto::MessageKey* key); + ::proto::MessageKey* unsafe_arena_release_key(); + + // optional .proto.Message.HistorySyncNotification historySyncNotification = 6; + bool has_historysyncnotification() const; + private: + bool _internal_has_historysyncnotification() const; + public: + void clear_historysyncnotification(); + const ::proto::Message_HistorySyncNotification& historysyncnotification() const; + PROTOBUF_NODISCARD ::proto::Message_HistorySyncNotification* release_historysyncnotification(); + ::proto::Message_HistorySyncNotification* mutable_historysyncnotification(); + void set_allocated_historysyncnotification(::proto::Message_HistorySyncNotification* historysyncnotification); + private: + const ::proto::Message_HistorySyncNotification& _internal_historysyncnotification() const; + ::proto::Message_HistorySyncNotification* _internal_mutable_historysyncnotification(); + public: + void unsafe_arena_set_allocated_historysyncnotification( + ::proto::Message_HistorySyncNotification* historysyncnotification); + ::proto::Message_HistorySyncNotification* unsafe_arena_release_historysyncnotification(); + + // optional .proto.Message.AppStateSyncKeyShare appStateSyncKeyShare = 7; + bool has_appstatesynckeyshare() const; + private: + bool _internal_has_appstatesynckeyshare() const; + public: + void clear_appstatesynckeyshare(); + const ::proto::Message_AppStateSyncKeyShare& appstatesynckeyshare() const; + PROTOBUF_NODISCARD ::proto::Message_AppStateSyncKeyShare* release_appstatesynckeyshare(); + ::proto::Message_AppStateSyncKeyShare* mutable_appstatesynckeyshare(); + void set_allocated_appstatesynckeyshare(::proto::Message_AppStateSyncKeyShare* appstatesynckeyshare); + private: + const ::proto::Message_AppStateSyncKeyShare& _internal_appstatesynckeyshare() const; + ::proto::Message_AppStateSyncKeyShare* _internal_mutable_appstatesynckeyshare(); + public: + void unsafe_arena_set_allocated_appstatesynckeyshare( + ::proto::Message_AppStateSyncKeyShare* appstatesynckeyshare); + ::proto::Message_AppStateSyncKeyShare* unsafe_arena_release_appstatesynckeyshare(); + + // optional .proto.Message.AppStateSyncKeyRequest appStateSyncKeyRequest = 8; + bool has_appstatesynckeyrequest() const; + private: + bool _internal_has_appstatesynckeyrequest() const; + public: + void clear_appstatesynckeyrequest(); + const ::proto::Message_AppStateSyncKeyRequest& appstatesynckeyrequest() const; + PROTOBUF_NODISCARD ::proto::Message_AppStateSyncKeyRequest* release_appstatesynckeyrequest(); + ::proto::Message_AppStateSyncKeyRequest* mutable_appstatesynckeyrequest(); + void set_allocated_appstatesynckeyrequest(::proto::Message_AppStateSyncKeyRequest* appstatesynckeyrequest); + private: + const ::proto::Message_AppStateSyncKeyRequest& _internal_appstatesynckeyrequest() const; + ::proto::Message_AppStateSyncKeyRequest* _internal_mutable_appstatesynckeyrequest(); + public: + void unsafe_arena_set_allocated_appstatesynckeyrequest( + ::proto::Message_AppStateSyncKeyRequest* appstatesynckeyrequest); + ::proto::Message_AppStateSyncKeyRequest* unsafe_arena_release_appstatesynckeyrequest(); + + // optional .proto.Message.InitialSecurityNotificationSettingSync initialSecurityNotificationSettingSync = 9; + bool has_initialsecuritynotificationsettingsync() const; + private: + bool _internal_has_initialsecuritynotificationsettingsync() const; + public: + void clear_initialsecuritynotificationsettingsync(); + const ::proto::Message_InitialSecurityNotificationSettingSync& initialsecuritynotificationsettingsync() const; + PROTOBUF_NODISCARD ::proto::Message_InitialSecurityNotificationSettingSync* release_initialsecuritynotificationsettingsync(); + ::proto::Message_InitialSecurityNotificationSettingSync* mutable_initialsecuritynotificationsettingsync(); + void set_allocated_initialsecuritynotificationsettingsync(::proto::Message_InitialSecurityNotificationSettingSync* initialsecuritynotificationsettingsync); + private: + const ::proto::Message_InitialSecurityNotificationSettingSync& _internal_initialsecuritynotificationsettingsync() const; + ::proto::Message_InitialSecurityNotificationSettingSync* _internal_mutable_initialsecuritynotificationsettingsync(); + public: + void unsafe_arena_set_allocated_initialsecuritynotificationsettingsync( + ::proto::Message_InitialSecurityNotificationSettingSync* initialsecuritynotificationsettingsync); + ::proto::Message_InitialSecurityNotificationSettingSync* unsafe_arena_release_initialsecuritynotificationsettingsync(); + + // optional .proto.Message.AppStateFatalExceptionNotification appStateFatalExceptionNotification = 10; + bool has_appstatefatalexceptionnotification() const; + private: + bool _internal_has_appstatefatalexceptionnotification() const; + public: + void clear_appstatefatalexceptionnotification(); + const ::proto::Message_AppStateFatalExceptionNotification& appstatefatalexceptionnotification() const; + PROTOBUF_NODISCARD ::proto::Message_AppStateFatalExceptionNotification* release_appstatefatalexceptionnotification(); + ::proto::Message_AppStateFatalExceptionNotification* mutable_appstatefatalexceptionnotification(); + void set_allocated_appstatefatalexceptionnotification(::proto::Message_AppStateFatalExceptionNotification* appstatefatalexceptionnotification); + private: + const ::proto::Message_AppStateFatalExceptionNotification& _internal_appstatefatalexceptionnotification() const; + ::proto::Message_AppStateFatalExceptionNotification* _internal_mutable_appstatefatalexceptionnotification(); + public: + void unsafe_arena_set_allocated_appstatefatalexceptionnotification( + ::proto::Message_AppStateFatalExceptionNotification* appstatefatalexceptionnotification); + ::proto::Message_AppStateFatalExceptionNotification* unsafe_arena_release_appstatefatalexceptionnotification(); + + // optional .proto.DisappearingMode disappearingMode = 11; + bool has_disappearingmode() const; + private: + bool _internal_has_disappearingmode() const; + public: + void clear_disappearingmode(); + const ::proto::DisappearingMode& disappearingmode() const; + PROTOBUF_NODISCARD ::proto::DisappearingMode* release_disappearingmode(); + ::proto::DisappearingMode* mutable_disappearingmode(); + void set_allocated_disappearingmode(::proto::DisappearingMode* disappearingmode); + private: + const ::proto::DisappearingMode& _internal_disappearingmode() const; + ::proto::DisappearingMode* _internal_mutable_disappearingmode(); + public: + void unsafe_arena_set_allocated_disappearingmode( + ::proto::DisappearingMode* disappearingmode); + ::proto::DisappearingMode* unsafe_arena_release_disappearingmode(); + + // optional .proto.Message.RequestMediaUploadMessage requestMediaUploadMessage = 12; + bool has_requestmediauploadmessage() const; + private: + bool _internal_has_requestmediauploadmessage() const; + public: + void clear_requestmediauploadmessage(); + const ::proto::Message_RequestMediaUploadMessage& requestmediauploadmessage() const; + PROTOBUF_NODISCARD ::proto::Message_RequestMediaUploadMessage* release_requestmediauploadmessage(); + ::proto::Message_RequestMediaUploadMessage* mutable_requestmediauploadmessage(); + void set_allocated_requestmediauploadmessage(::proto::Message_RequestMediaUploadMessage* requestmediauploadmessage); + private: + const ::proto::Message_RequestMediaUploadMessage& _internal_requestmediauploadmessage() const; + ::proto::Message_RequestMediaUploadMessage* _internal_mutable_requestmediauploadmessage(); + public: + void unsafe_arena_set_allocated_requestmediauploadmessage( + ::proto::Message_RequestMediaUploadMessage* requestmediauploadmessage); + ::proto::Message_RequestMediaUploadMessage* unsafe_arena_release_requestmediauploadmessage(); + + // optional .proto.Message.RequestMediaUploadResponseMessage requestMediaUploadResponseMessage = 13; + bool has_requestmediauploadresponsemessage() const; + private: + bool _internal_has_requestmediauploadresponsemessage() const; + public: + void clear_requestmediauploadresponsemessage(); + const ::proto::Message_RequestMediaUploadResponseMessage& requestmediauploadresponsemessage() const; + PROTOBUF_NODISCARD ::proto::Message_RequestMediaUploadResponseMessage* release_requestmediauploadresponsemessage(); + ::proto::Message_RequestMediaUploadResponseMessage* mutable_requestmediauploadresponsemessage(); + void set_allocated_requestmediauploadresponsemessage(::proto::Message_RequestMediaUploadResponseMessage* requestmediauploadresponsemessage); + private: + const ::proto::Message_RequestMediaUploadResponseMessage& _internal_requestmediauploadresponsemessage() const; + ::proto::Message_RequestMediaUploadResponseMessage* _internal_mutable_requestmediauploadresponsemessage(); + public: + void unsafe_arena_set_allocated_requestmediauploadresponsemessage( + ::proto::Message_RequestMediaUploadResponseMessage* requestmediauploadresponsemessage); + ::proto::Message_RequestMediaUploadResponseMessage* unsafe_arena_release_requestmediauploadresponsemessage(); + + // optional .proto.Message.ProtocolMessage.Type type = 2; + bool has_type() const; + private: + bool _internal_has_type() const; + public: + void clear_type(); + ::proto::Message_ProtocolMessage_Type type() const; + void set_type(::proto::Message_ProtocolMessage_Type value); + private: + ::proto::Message_ProtocolMessage_Type _internal_type() const; + void _internal_set_type(::proto::Message_ProtocolMessage_Type value); + public: + + // optional uint32 ephemeralExpiration = 4; + bool has_ephemeralexpiration() const; + private: + bool _internal_has_ephemeralexpiration() const; + public: + void clear_ephemeralexpiration(); + uint32_t ephemeralexpiration() const; + void set_ephemeralexpiration(uint32_t value); + private: + uint32_t _internal_ephemeralexpiration() const; + void _internal_set_ephemeralexpiration(uint32_t value); + public: + + // optional int64 ephemeralSettingTimestamp = 5; + bool has_ephemeralsettingtimestamp() const; + private: + bool _internal_has_ephemeralsettingtimestamp() const; + public: + void clear_ephemeralsettingtimestamp(); + int64_t ephemeralsettingtimestamp() const; + void set_ephemeralsettingtimestamp(int64_t value); + private: + int64_t _internal_ephemeralsettingtimestamp() const; + void _internal_set_ephemeralsettingtimestamp(int64_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.ProtocolMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::proto::MessageKey* key_; + ::proto::Message_HistorySyncNotification* historysyncnotification_; + ::proto::Message_AppStateSyncKeyShare* appstatesynckeyshare_; + ::proto::Message_AppStateSyncKeyRequest* appstatesynckeyrequest_; + ::proto::Message_InitialSecurityNotificationSettingSync* initialsecuritynotificationsettingsync_; + ::proto::Message_AppStateFatalExceptionNotification* appstatefatalexceptionnotification_; + ::proto::DisappearingMode* disappearingmode_; + ::proto::Message_RequestMediaUploadMessage* requestmediauploadmessage_; + ::proto::Message_RequestMediaUploadResponseMessage* requestmediauploadresponsemessage_; + int type_; + uint32_t ephemeralexpiration_; + int64_t ephemeralsettingtimestamp_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_ReactionMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ReactionMessage) */ { + public: + inline Message_ReactionMessage() : Message_ReactionMessage(nullptr) {} + ~Message_ReactionMessage() override; + explicit PROTOBUF_CONSTEXPR Message_ReactionMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_ReactionMessage(const Message_ReactionMessage& from); + Message_ReactionMessage(Message_ReactionMessage&& from) noexcept + : Message_ReactionMessage() { + *this = ::std::move(from); + } + + inline Message_ReactionMessage& operator=(const Message_ReactionMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_ReactionMessage& operator=(Message_ReactionMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_ReactionMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_ReactionMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_ReactionMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 122; + + friend void swap(Message_ReactionMessage& a, Message_ReactionMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_ReactionMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_ReactionMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_ReactionMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_ReactionMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_ReactionMessage& from) { + Message_ReactionMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_ReactionMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.ReactionMessage"; + } + protected: + explicit Message_ReactionMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kTextFieldNumber = 2, + kGroupingKeyFieldNumber = 3, + kKeyFieldNumber = 1, + kSenderTimestampMsFieldNumber = 4, + }; + // optional string text = 2; + bool has_text() const; + private: + bool _internal_has_text() const; + public: + void clear_text(); + const std::string& text() const; + template + void set_text(ArgT0&& arg0, ArgT... args); + std::string* mutable_text(); + PROTOBUF_NODISCARD std::string* release_text(); + void set_allocated_text(std::string* text); + private: + const std::string& _internal_text() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value); + std::string* _internal_mutable_text(); + public: + + // optional string groupingKey = 3; + bool has_groupingkey() const; + private: + bool _internal_has_groupingkey() const; + public: + void clear_groupingkey(); + const std::string& groupingkey() const; + template + void set_groupingkey(ArgT0&& arg0, ArgT... args); + std::string* mutable_groupingkey(); + PROTOBUF_NODISCARD std::string* release_groupingkey(); + void set_allocated_groupingkey(std::string* groupingkey); + private: + const std::string& _internal_groupingkey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_groupingkey(const std::string& value); + std::string* _internal_mutable_groupingkey(); + public: + + // optional .proto.MessageKey key = 1; + bool has_key() const; + private: + bool _internal_has_key() const; + public: + void clear_key(); + const ::proto::MessageKey& key() const; + PROTOBUF_NODISCARD ::proto::MessageKey* release_key(); + ::proto::MessageKey* mutable_key(); + void set_allocated_key(::proto::MessageKey* key); + private: + const ::proto::MessageKey& _internal_key() const; + ::proto::MessageKey* _internal_mutable_key(); + public: + void unsafe_arena_set_allocated_key( + ::proto::MessageKey* key); + ::proto::MessageKey* unsafe_arena_release_key(); + + // optional int64 senderTimestampMs = 4; + bool has_sendertimestampms() const; + private: + bool _internal_has_sendertimestampms() const; + public: + void clear_sendertimestampms(); + int64_t sendertimestampms() const; + void set_sendertimestampms(int64_t value); + private: + int64_t _internal_sendertimestampms() const; + void _internal_set_sendertimestampms(int64_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.ReactionMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr groupingkey_; + ::proto::MessageKey* key_; + int64_t sendertimestampms_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_RequestMediaUploadMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.RequestMediaUploadMessage) */ { + public: + inline Message_RequestMediaUploadMessage() : Message_RequestMediaUploadMessage(nullptr) {} + ~Message_RequestMediaUploadMessage() override; + explicit PROTOBUF_CONSTEXPR Message_RequestMediaUploadMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_RequestMediaUploadMessage(const Message_RequestMediaUploadMessage& from); + Message_RequestMediaUploadMessage(Message_RequestMediaUploadMessage&& from) noexcept + : Message_RequestMediaUploadMessage() { + *this = ::std::move(from); + } + + inline Message_RequestMediaUploadMessage& operator=(const Message_RequestMediaUploadMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_RequestMediaUploadMessage& operator=(Message_RequestMediaUploadMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_RequestMediaUploadMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_RequestMediaUploadMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_RequestMediaUploadMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 123; + + friend void swap(Message_RequestMediaUploadMessage& a, Message_RequestMediaUploadMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_RequestMediaUploadMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_RequestMediaUploadMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_RequestMediaUploadMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_RequestMediaUploadMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_RequestMediaUploadMessage& from) { + Message_RequestMediaUploadMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_RequestMediaUploadMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.RequestMediaUploadMessage"; + } + protected: + explicit Message_RequestMediaUploadMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kFileSha256FieldNumber = 1, + kRmrSourceFieldNumber = 2, + }; + // repeated string fileSha256 = 1; + int filesha256_size() const; + private: + int _internal_filesha256_size() const; + public: + void clear_filesha256(); + const std::string& filesha256(int index) const; + std::string* mutable_filesha256(int index); + void set_filesha256(int index, const std::string& value); + void set_filesha256(int index, std::string&& value); + void set_filesha256(int index, const char* value); + void set_filesha256(int index, const char* value, size_t size); + std::string* add_filesha256(); + void add_filesha256(const std::string& value); + void add_filesha256(std::string&& value); + void add_filesha256(const char* value); + void add_filesha256(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& filesha256() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_filesha256(); + private: + const std::string& _internal_filesha256(int index) const; + std::string* _internal_add_filesha256(); + public: + + // optional .proto.Message.RmrSource rmrSource = 2; + bool has_rmrsource() const; + private: + bool _internal_has_rmrsource() const; + public: + void clear_rmrsource(); + ::proto::Message_RmrSource rmrsource() const; + void set_rmrsource(::proto::Message_RmrSource value); + private: + ::proto::Message_RmrSource _internal_rmrsource() const; + void _internal_set_rmrsource(::proto::Message_RmrSource value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.RequestMediaUploadMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField filesha256_; + int rmrsource_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult) */ { + public: + inline Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult() : Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult(nullptr) {} + ~Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult() override; + explicit PROTOBUF_CONSTEXPR Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult(const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& from); + Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult&& from) noexcept + : Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult() { + *this = ::std::move(from); + } + + inline Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& operator=(const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& from) { + CopyFrom(from); + return *this; + } + inline Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& operator=(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& default_instance() { + return *internal_default_instance(); + } + static inline const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* internal_default_instance() { + return reinterpret_cast( + &_Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult_default_instance_); + } + static constexpr int kIndexInFileMessages = + 124; + + friend void swap(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& a, Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& b) { + a.Swap(&b); + } + inline void Swap(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& from) { + Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult"; + } + protected: + explicit Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kFileSha256FieldNumber = 1, + kStickerMessageFieldNumber = 3, + kMediaUploadResultFieldNumber = 2, + }; + // optional string fileSha256 = 1; + bool has_filesha256() const; + private: + bool _internal_has_filesha256() const; + public: + void clear_filesha256(); + const std::string& filesha256() const; + template + void set_filesha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_filesha256(); + PROTOBUF_NODISCARD std::string* release_filesha256(); + void set_allocated_filesha256(std::string* filesha256); + private: + const std::string& _internal_filesha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value); + std::string* _internal_mutable_filesha256(); + public: + + // optional .proto.Message.StickerMessage stickerMessage = 3; + bool has_stickermessage() const; + private: + bool _internal_has_stickermessage() const; + public: + void clear_stickermessage(); + const ::proto::Message_StickerMessage& stickermessage() const; + PROTOBUF_NODISCARD ::proto::Message_StickerMessage* release_stickermessage(); + ::proto::Message_StickerMessage* mutable_stickermessage(); + void set_allocated_stickermessage(::proto::Message_StickerMessage* stickermessage); + private: + const ::proto::Message_StickerMessage& _internal_stickermessage() const; + ::proto::Message_StickerMessage* _internal_mutable_stickermessage(); + public: + void unsafe_arena_set_allocated_stickermessage( + ::proto::Message_StickerMessage* stickermessage); + ::proto::Message_StickerMessage* unsafe_arena_release_stickermessage(); + + // optional .proto.MediaRetryNotification.ResultType mediaUploadResult = 2; + bool has_mediauploadresult() const; + private: + bool _internal_has_mediauploadresult() const; + public: + void clear_mediauploadresult(); + ::proto::MediaRetryNotification_ResultType mediauploadresult() const; + void set_mediauploadresult(::proto::MediaRetryNotification_ResultType value); + private: + ::proto::MediaRetryNotification_ResultType _internal_mediauploadresult() const; + void _internal_set_mediauploadresult(::proto::MediaRetryNotification_ResultType value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_; + ::proto::Message_StickerMessage* stickermessage_; + int mediauploadresult_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_RequestMediaUploadResponseMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.RequestMediaUploadResponseMessage) */ { + public: + inline Message_RequestMediaUploadResponseMessage() : Message_RequestMediaUploadResponseMessage(nullptr) {} + ~Message_RequestMediaUploadResponseMessage() override; + explicit PROTOBUF_CONSTEXPR Message_RequestMediaUploadResponseMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_RequestMediaUploadResponseMessage(const Message_RequestMediaUploadResponseMessage& from); + Message_RequestMediaUploadResponseMessage(Message_RequestMediaUploadResponseMessage&& from) noexcept + : Message_RequestMediaUploadResponseMessage() { + *this = ::std::move(from); + } + + inline Message_RequestMediaUploadResponseMessage& operator=(const Message_RequestMediaUploadResponseMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_RequestMediaUploadResponseMessage& operator=(Message_RequestMediaUploadResponseMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_RequestMediaUploadResponseMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_RequestMediaUploadResponseMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_RequestMediaUploadResponseMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 125; + + friend void swap(Message_RequestMediaUploadResponseMessage& a, Message_RequestMediaUploadResponseMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_RequestMediaUploadResponseMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_RequestMediaUploadResponseMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_RequestMediaUploadResponseMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_RequestMediaUploadResponseMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_RequestMediaUploadResponseMessage& from) { + Message_RequestMediaUploadResponseMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_RequestMediaUploadResponseMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.RequestMediaUploadResponseMessage"; + } + protected: + explicit Message_RequestMediaUploadResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult RequestMediaUploadResult; + + // accessors ------------------------------------------------------- + + enum : int { + kReuploadResultFieldNumber = 3, + kStanzaIdFieldNumber = 2, + kRmrSourceFieldNumber = 1, + }; + // repeated .proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult reuploadResult = 3; + int reuploadresult_size() const; + private: + int _internal_reuploadresult_size() const; + public: + void clear_reuploadresult(); + ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* mutable_reuploadresult(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult >* + mutable_reuploadresult(); + private: + const ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& _internal_reuploadresult(int index) const; + ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* _internal_add_reuploadresult(); + public: + const ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& reuploadresult(int index) const; + ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* add_reuploadresult(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult >& + reuploadresult() const; + + // optional string stanzaId = 2; + bool has_stanzaid() const; + private: + bool _internal_has_stanzaid() const; + public: + void clear_stanzaid(); + const std::string& stanzaid() const; + template + void set_stanzaid(ArgT0&& arg0, ArgT... args); + std::string* mutable_stanzaid(); + PROTOBUF_NODISCARD std::string* release_stanzaid(); + void set_allocated_stanzaid(std::string* stanzaid); + private: + const std::string& _internal_stanzaid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_stanzaid(const std::string& value); + std::string* _internal_mutable_stanzaid(); + public: + + // optional .proto.Message.RmrSource rmrSource = 1; + bool has_rmrsource() const; + private: + bool _internal_has_rmrsource() const; + public: + void clear_rmrsource(); + ::proto::Message_RmrSource rmrsource() const; + void set_rmrsource(::proto::Message_RmrSource value); + private: + ::proto::Message_RmrSource _internal_rmrsource() const; + void _internal_set_rmrsource(::proto::Message_RmrSource value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.RequestMediaUploadResponseMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult > reuploadresult_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr stanzaid_; + int rmrsource_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_RequestPaymentMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.RequestPaymentMessage) */ { + public: + inline Message_RequestPaymentMessage() : Message_RequestPaymentMessage(nullptr) {} + ~Message_RequestPaymentMessage() override; + explicit PROTOBUF_CONSTEXPR Message_RequestPaymentMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_RequestPaymentMessage(const Message_RequestPaymentMessage& from); + Message_RequestPaymentMessage(Message_RequestPaymentMessage&& from) noexcept + : Message_RequestPaymentMessage() { + *this = ::std::move(from); + } + + inline Message_RequestPaymentMessage& operator=(const Message_RequestPaymentMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_RequestPaymentMessage& operator=(Message_RequestPaymentMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_RequestPaymentMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_RequestPaymentMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_RequestPaymentMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 126; + + friend void swap(Message_RequestPaymentMessage& a, Message_RequestPaymentMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_RequestPaymentMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_RequestPaymentMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_RequestPaymentMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_RequestPaymentMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_RequestPaymentMessage& from) { + Message_RequestPaymentMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_RequestPaymentMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.RequestPaymentMessage"; + } + protected: + explicit Message_RequestPaymentMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kCurrencyCodeIso4217FieldNumber = 1, + kRequestFromFieldNumber = 3, + kNoteMessageFieldNumber = 4, + kAmountFieldNumber = 6, + kBackgroundFieldNumber = 7, + kAmount1000FieldNumber = 2, + kExpiryTimestampFieldNumber = 5, + }; + // optional string currencyCodeIso4217 = 1; + bool has_currencycodeiso4217() const; + private: + bool _internal_has_currencycodeiso4217() const; + public: + void clear_currencycodeiso4217(); + const std::string& currencycodeiso4217() const; + template + void set_currencycodeiso4217(ArgT0&& arg0, ArgT... args); + std::string* mutable_currencycodeiso4217(); + PROTOBUF_NODISCARD std::string* release_currencycodeiso4217(); + void set_allocated_currencycodeiso4217(std::string* currencycodeiso4217); + private: + const std::string& _internal_currencycodeiso4217() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_currencycodeiso4217(const std::string& value); + std::string* _internal_mutable_currencycodeiso4217(); + public: + + // optional string requestFrom = 3; + bool has_requestfrom() const; + private: + bool _internal_has_requestfrom() const; + public: + void clear_requestfrom(); + const std::string& requestfrom() const; + template + void set_requestfrom(ArgT0&& arg0, ArgT... args); + std::string* mutable_requestfrom(); + PROTOBUF_NODISCARD std::string* release_requestfrom(); + void set_allocated_requestfrom(std::string* requestfrom); + private: + const std::string& _internal_requestfrom() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestfrom(const std::string& value); + std::string* _internal_mutable_requestfrom(); + public: + + // optional .proto.Message noteMessage = 4; + bool has_notemessage() const; + private: + bool _internal_has_notemessage() const; + public: + void clear_notemessage(); + const ::proto::Message& notemessage() const; + PROTOBUF_NODISCARD ::proto::Message* release_notemessage(); + ::proto::Message* mutable_notemessage(); + void set_allocated_notemessage(::proto::Message* notemessage); + private: + const ::proto::Message& _internal_notemessage() const; + ::proto::Message* _internal_mutable_notemessage(); + public: + void unsafe_arena_set_allocated_notemessage( + ::proto::Message* notemessage); + ::proto::Message* unsafe_arena_release_notemessage(); + + // optional .proto.Money amount = 6; + bool has_amount() const; + private: + bool _internal_has_amount() const; + public: + void clear_amount(); + const ::proto::Money& amount() const; + PROTOBUF_NODISCARD ::proto::Money* release_amount(); + ::proto::Money* mutable_amount(); + void set_allocated_amount(::proto::Money* amount); + private: + const ::proto::Money& _internal_amount() const; + ::proto::Money* _internal_mutable_amount(); + public: + void unsafe_arena_set_allocated_amount( + ::proto::Money* amount); + ::proto::Money* unsafe_arena_release_amount(); + + // optional .proto.PaymentBackground background = 7; + bool has_background() const; + private: + bool _internal_has_background() const; + public: + void clear_background(); + const ::proto::PaymentBackground& background() const; + PROTOBUF_NODISCARD ::proto::PaymentBackground* release_background(); + ::proto::PaymentBackground* mutable_background(); + void set_allocated_background(::proto::PaymentBackground* background); + private: + const ::proto::PaymentBackground& _internal_background() const; + ::proto::PaymentBackground* _internal_mutable_background(); + public: + void unsafe_arena_set_allocated_background( + ::proto::PaymentBackground* background); + ::proto::PaymentBackground* unsafe_arena_release_background(); + + // optional uint64 amount1000 = 2; + bool has_amount1000() const; + private: + bool _internal_has_amount1000() const; + public: + void clear_amount1000(); + uint64_t amount1000() const; + void set_amount1000(uint64_t value); + private: + uint64_t _internal_amount1000() const; + void _internal_set_amount1000(uint64_t value); + public: + + // optional int64 expiryTimestamp = 5; + bool has_expirytimestamp() const; + private: + bool _internal_has_expirytimestamp() const; + public: + void clear_expirytimestamp(); + int64_t expirytimestamp() const; + void set_expirytimestamp(int64_t value); + private: + int64_t _internal_expirytimestamp() const; + void _internal_set_expirytimestamp(int64_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.RequestPaymentMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr currencycodeiso4217_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr requestfrom_; + ::proto::Message* notemessage_; + ::proto::Money* amount_; + ::proto::PaymentBackground* background_; + uint64_t amount1000_; + int64_t expirytimestamp_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_RequestPhoneNumberMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.RequestPhoneNumberMessage) */ { + public: + inline Message_RequestPhoneNumberMessage() : Message_RequestPhoneNumberMessage(nullptr) {} + ~Message_RequestPhoneNumberMessage() override; + explicit PROTOBUF_CONSTEXPR Message_RequestPhoneNumberMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_RequestPhoneNumberMessage(const Message_RequestPhoneNumberMessage& from); + Message_RequestPhoneNumberMessage(Message_RequestPhoneNumberMessage&& from) noexcept + : Message_RequestPhoneNumberMessage() { + *this = ::std::move(from); + } + + inline Message_RequestPhoneNumberMessage& operator=(const Message_RequestPhoneNumberMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_RequestPhoneNumberMessage& operator=(Message_RequestPhoneNumberMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_RequestPhoneNumberMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_RequestPhoneNumberMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_RequestPhoneNumberMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 127; + + friend void swap(Message_RequestPhoneNumberMessage& a, Message_RequestPhoneNumberMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_RequestPhoneNumberMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_RequestPhoneNumberMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_RequestPhoneNumberMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_RequestPhoneNumberMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_RequestPhoneNumberMessage& from) { + Message_RequestPhoneNumberMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_RequestPhoneNumberMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.RequestPhoneNumberMessage"; + } + protected: + explicit Message_RequestPhoneNumberMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kContextInfoFieldNumber = 1, + }; + // optional .proto.ContextInfo contextInfo = 1; + bool has_contextinfo() const; + private: + bool _internal_has_contextinfo() const; + public: + void clear_contextinfo(); + const ::proto::ContextInfo& contextinfo() const; + PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); + ::proto::ContextInfo* mutable_contextinfo(); + void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); + private: + const ::proto::ContextInfo& _internal_contextinfo() const; + ::proto::ContextInfo* _internal_mutable_contextinfo(); + public: + void unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo); + ::proto::ContextInfo* unsafe_arena_release_contextinfo(); + + // @@protoc_insertion_point(class_scope:proto.Message.RequestPhoneNumberMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::proto::ContextInfo* contextinfo_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_SendPaymentMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.SendPaymentMessage) */ { + public: + inline Message_SendPaymentMessage() : Message_SendPaymentMessage(nullptr) {} + ~Message_SendPaymentMessage() override; + explicit PROTOBUF_CONSTEXPR Message_SendPaymentMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_SendPaymentMessage(const Message_SendPaymentMessage& from); + Message_SendPaymentMessage(Message_SendPaymentMessage&& from) noexcept + : Message_SendPaymentMessage() { + *this = ::std::move(from); + } + + inline Message_SendPaymentMessage& operator=(const Message_SendPaymentMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_SendPaymentMessage& operator=(Message_SendPaymentMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_SendPaymentMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_SendPaymentMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_SendPaymentMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 128; + + friend void swap(Message_SendPaymentMessage& a, Message_SendPaymentMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_SendPaymentMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_SendPaymentMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_SendPaymentMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_SendPaymentMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_SendPaymentMessage& from) { + Message_SendPaymentMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_SendPaymentMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.SendPaymentMessage"; + } + protected: + explicit Message_SendPaymentMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNoteMessageFieldNumber = 2, + kRequestMessageKeyFieldNumber = 3, + kBackgroundFieldNumber = 4, + }; + // optional .proto.Message noteMessage = 2; + bool has_notemessage() const; + private: + bool _internal_has_notemessage() const; + public: + void clear_notemessage(); + const ::proto::Message& notemessage() const; + PROTOBUF_NODISCARD ::proto::Message* release_notemessage(); + ::proto::Message* mutable_notemessage(); + void set_allocated_notemessage(::proto::Message* notemessage); + private: + const ::proto::Message& _internal_notemessage() const; + ::proto::Message* _internal_mutable_notemessage(); + public: + void unsafe_arena_set_allocated_notemessage( + ::proto::Message* notemessage); + ::proto::Message* unsafe_arena_release_notemessage(); + + // optional .proto.MessageKey requestMessageKey = 3; + bool has_requestmessagekey() const; + private: + bool _internal_has_requestmessagekey() const; + public: + void clear_requestmessagekey(); + const ::proto::MessageKey& requestmessagekey() const; + PROTOBUF_NODISCARD ::proto::MessageKey* release_requestmessagekey(); + ::proto::MessageKey* mutable_requestmessagekey(); + void set_allocated_requestmessagekey(::proto::MessageKey* requestmessagekey); + private: + const ::proto::MessageKey& _internal_requestmessagekey() const; + ::proto::MessageKey* _internal_mutable_requestmessagekey(); + public: + void unsafe_arena_set_allocated_requestmessagekey( + ::proto::MessageKey* requestmessagekey); + ::proto::MessageKey* unsafe_arena_release_requestmessagekey(); + + // optional .proto.PaymentBackground background = 4; + bool has_background() const; + private: + bool _internal_has_background() const; + public: + void clear_background(); + const ::proto::PaymentBackground& background() const; + PROTOBUF_NODISCARD ::proto::PaymentBackground* release_background(); + ::proto::PaymentBackground* mutable_background(); + void set_allocated_background(::proto::PaymentBackground* background); + private: + const ::proto::PaymentBackground& _internal_background() const; + ::proto::PaymentBackground* _internal_mutable_background(); + public: + void unsafe_arena_set_allocated_background( + ::proto::PaymentBackground* background); + ::proto::PaymentBackground* unsafe_arena_release_background(); + + // @@protoc_insertion_point(class_scope:proto.Message.SendPaymentMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::proto::Message* notemessage_; + ::proto::MessageKey* requestmessagekey_; + ::proto::PaymentBackground* background_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_SenderKeyDistributionMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.SenderKeyDistributionMessage) */ { + public: + inline Message_SenderKeyDistributionMessage() : Message_SenderKeyDistributionMessage(nullptr) {} + ~Message_SenderKeyDistributionMessage() override; + explicit PROTOBUF_CONSTEXPR Message_SenderKeyDistributionMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_SenderKeyDistributionMessage(const Message_SenderKeyDistributionMessage& from); + Message_SenderKeyDistributionMessage(Message_SenderKeyDistributionMessage&& from) noexcept + : Message_SenderKeyDistributionMessage() { + *this = ::std::move(from); + } + + inline Message_SenderKeyDistributionMessage& operator=(const Message_SenderKeyDistributionMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_SenderKeyDistributionMessage& operator=(Message_SenderKeyDistributionMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_SenderKeyDistributionMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_SenderKeyDistributionMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_SenderKeyDistributionMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 129; + + friend void swap(Message_SenderKeyDistributionMessage& a, Message_SenderKeyDistributionMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_SenderKeyDistributionMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_SenderKeyDistributionMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_SenderKeyDistributionMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_SenderKeyDistributionMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_SenderKeyDistributionMessage& from) { + Message_SenderKeyDistributionMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_SenderKeyDistributionMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.SenderKeyDistributionMessage"; + } + protected: + explicit Message_SenderKeyDistributionMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kGroupIdFieldNumber = 1, + kAxolotlSenderKeyDistributionMessageFieldNumber = 2, + }; + // optional string groupId = 1; + bool has_groupid() const; + private: + bool _internal_has_groupid() const; + public: + void clear_groupid(); + const std::string& groupid() const; + template + void set_groupid(ArgT0&& arg0, ArgT... args); + std::string* mutable_groupid(); + PROTOBUF_NODISCARD std::string* release_groupid(); + void set_allocated_groupid(std::string* groupid); + private: + const std::string& _internal_groupid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_groupid(const std::string& value); + std::string* _internal_mutable_groupid(); + public: + + // optional bytes axolotlSenderKeyDistributionMessage = 2; + bool has_axolotlsenderkeydistributionmessage() const; + private: + bool _internal_has_axolotlsenderkeydistributionmessage() const; + public: + void clear_axolotlsenderkeydistributionmessage(); + const std::string& axolotlsenderkeydistributionmessage() const; + template + void set_axolotlsenderkeydistributionmessage(ArgT0&& arg0, ArgT... args); + std::string* mutable_axolotlsenderkeydistributionmessage(); + PROTOBUF_NODISCARD std::string* release_axolotlsenderkeydistributionmessage(); + void set_allocated_axolotlsenderkeydistributionmessage(std::string* axolotlsenderkeydistributionmessage); + private: + const std::string& _internal_axolotlsenderkeydistributionmessage() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_axolotlsenderkeydistributionmessage(const std::string& value); + std::string* _internal_mutable_axolotlsenderkeydistributionmessage(); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.SenderKeyDistributionMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr groupid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr axolotlsenderkeydistributionmessage_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_StickerMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.StickerMessage) */ { + public: + inline Message_StickerMessage() : Message_StickerMessage(nullptr) {} + ~Message_StickerMessage() override; + explicit PROTOBUF_CONSTEXPR Message_StickerMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_StickerMessage(const Message_StickerMessage& from); + Message_StickerMessage(Message_StickerMessage&& from) noexcept + : Message_StickerMessage() { + *this = ::std::move(from); + } + + inline Message_StickerMessage& operator=(const Message_StickerMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_StickerMessage& operator=(Message_StickerMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_StickerMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_StickerMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_StickerMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 130; + + friend void swap(Message_StickerMessage& a, Message_StickerMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_StickerMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_StickerMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_StickerMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_StickerMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_StickerMessage& from) { + Message_StickerMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_StickerMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.StickerMessage"; + } + protected: + explicit Message_StickerMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kUrlFieldNumber = 1, + kFileSha256FieldNumber = 2, + kFileEncSha256FieldNumber = 3, + kMediaKeyFieldNumber = 4, + kMimetypeFieldNumber = 5, + kDirectPathFieldNumber = 8, + kFirstFrameSidecarFieldNumber = 12, + kPngThumbnailFieldNumber = 16, + kContextInfoFieldNumber = 17, + kHeightFieldNumber = 6, + kWidthFieldNumber = 7, + kFileLengthFieldNumber = 9, + kMediaKeyTimestampFieldNumber = 10, + kFirstFrameLengthFieldNumber = 11, + kIsAnimatedFieldNumber = 13, + }; + // optional string url = 1; + bool has_url() const; + private: + bool _internal_has_url() const; + public: + void clear_url(); + const std::string& url() const; + template + void set_url(ArgT0&& arg0, ArgT... args); + std::string* mutable_url(); + PROTOBUF_NODISCARD std::string* release_url(); + void set_allocated_url(std::string* url); + private: + const std::string& _internal_url() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value); + std::string* _internal_mutable_url(); + public: + + // optional bytes fileSha256 = 2; + bool has_filesha256() const; + private: + bool _internal_has_filesha256() const; + public: + void clear_filesha256(); + const std::string& filesha256() const; + template + void set_filesha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_filesha256(); + PROTOBUF_NODISCARD std::string* release_filesha256(); + void set_allocated_filesha256(std::string* filesha256); + private: + const std::string& _internal_filesha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value); + std::string* _internal_mutable_filesha256(); + public: + + // optional bytes fileEncSha256 = 3; + bool has_fileencsha256() const; + private: + bool _internal_has_fileencsha256() const; + public: + void clear_fileencsha256(); + const std::string& fileencsha256() const; + template + void set_fileencsha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_fileencsha256(); + PROTOBUF_NODISCARD std::string* release_fileencsha256(); + void set_allocated_fileencsha256(std::string* fileencsha256); + private: + const std::string& _internal_fileencsha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value); + std::string* _internal_mutable_fileencsha256(); + public: + + // optional bytes mediaKey = 4; + bool has_mediakey() const; + private: + bool _internal_has_mediakey() const; + public: + void clear_mediakey(); + const std::string& mediakey() const; + template + void set_mediakey(ArgT0&& arg0, ArgT... args); + std::string* mutable_mediakey(); + PROTOBUF_NODISCARD std::string* release_mediakey(); + void set_allocated_mediakey(std::string* mediakey); + private: + const std::string& _internal_mediakey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value); + std::string* _internal_mutable_mediakey(); + public: + + // optional string mimetype = 5; + bool has_mimetype() const; + private: + bool _internal_has_mimetype() const; + public: + void clear_mimetype(); + const std::string& mimetype() const; + template + void set_mimetype(ArgT0&& arg0, ArgT... args); + std::string* mutable_mimetype(); + PROTOBUF_NODISCARD std::string* release_mimetype(); + void set_allocated_mimetype(std::string* mimetype); + private: + const std::string& _internal_mimetype() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value); + std::string* _internal_mutable_mimetype(); + public: + + // optional string directPath = 8; + bool has_directpath() const; + private: + bool _internal_has_directpath() const; + public: + void clear_directpath(); + const std::string& directpath() const; + template + void set_directpath(ArgT0&& arg0, ArgT... args); + std::string* mutable_directpath(); + PROTOBUF_NODISCARD std::string* release_directpath(); + void set_allocated_directpath(std::string* directpath); + private: + const std::string& _internal_directpath() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value); + std::string* _internal_mutable_directpath(); + public: + + // optional bytes firstFrameSidecar = 12; + bool has_firstframesidecar() const; + private: + bool _internal_has_firstframesidecar() const; + public: + void clear_firstframesidecar(); + const std::string& firstframesidecar() const; + template + void set_firstframesidecar(ArgT0&& arg0, ArgT... args); + std::string* mutable_firstframesidecar(); + PROTOBUF_NODISCARD std::string* release_firstframesidecar(); + void set_allocated_firstframesidecar(std::string* firstframesidecar); + private: + const std::string& _internal_firstframesidecar() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_firstframesidecar(const std::string& value); + std::string* _internal_mutable_firstframesidecar(); + public: + + // optional bytes pngThumbnail = 16; + bool has_pngthumbnail() const; + private: + bool _internal_has_pngthumbnail() const; + public: + void clear_pngthumbnail(); + const std::string& pngthumbnail() const; + template + void set_pngthumbnail(ArgT0&& arg0, ArgT... args); + std::string* mutable_pngthumbnail(); + PROTOBUF_NODISCARD std::string* release_pngthumbnail(); + void set_allocated_pngthumbnail(std::string* pngthumbnail); + private: + const std::string& _internal_pngthumbnail() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_pngthumbnail(const std::string& value); + std::string* _internal_mutable_pngthumbnail(); + public: + + // optional .proto.ContextInfo contextInfo = 17; + bool has_contextinfo() const; + private: + bool _internal_has_contextinfo() const; + public: + void clear_contextinfo(); + const ::proto::ContextInfo& contextinfo() const; + PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); + ::proto::ContextInfo* mutable_contextinfo(); + void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); + private: + const ::proto::ContextInfo& _internal_contextinfo() const; + ::proto::ContextInfo* _internal_mutable_contextinfo(); + public: + void unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo); + ::proto::ContextInfo* unsafe_arena_release_contextinfo(); + + // optional uint32 height = 6; + bool has_height() const; + private: + bool _internal_has_height() const; + public: + void clear_height(); + uint32_t height() const; + void set_height(uint32_t value); + private: + uint32_t _internal_height() const; + void _internal_set_height(uint32_t value); + public: + + // optional uint32 width = 7; + bool has_width() const; + private: + bool _internal_has_width() const; + public: + void clear_width(); + uint32_t width() const; + void set_width(uint32_t value); + private: + uint32_t _internal_width() const; + void _internal_set_width(uint32_t value); + public: + + // optional uint64 fileLength = 9; + bool has_filelength() const; + private: + bool _internal_has_filelength() const; + public: + void clear_filelength(); + uint64_t filelength() const; + void set_filelength(uint64_t value); + private: + uint64_t _internal_filelength() const; + void _internal_set_filelength(uint64_t value); + public: + + // optional int64 mediaKeyTimestamp = 10; + bool has_mediakeytimestamp() const; + private: + bool _internal_has_mediakeytimestamp() const; + public: + void clear_mediakeytimestamp(); + int64_t mediakeytimestamp() const; + void set_mediakeytimestamp(int64_t value); + private: + int64_t _internal_mediakeytimestamp() const; + void _internal_set_mediakeytimestamp(int64_t value); + public: + + // optional uint32 firstFrameLength = 11; + bool has_firstframelength() const; + private: + bool _internal_has_firstframelength() const; + public: + void clear_firstframelength(); + uint32_t firstframelength() const; + void set_firstframelength(uint32_t value); + private: + uint32_t _internal_firstframelength() const; + void _internal_set_firstframelength(uint32_t value); + public: + + // optional bool isAnimated = 13; + bool has_isanimated() const; + private: + bool _internal_has_isanimated() const; + public: + void clear_isanimated(); + bool isanimated() const; + void set_isanimated(bool value); + private: + bool _internal_isanimated() const; + void _internal_set_isanimated(bool value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.StickerMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mimetype_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr firstframesidecar_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pngthumbnail_; + ::proto::ContextInfo* contextinfo_; + uint32_t height_; + uint32_t width_; + uint64_t filelength_; + int64_t mediakeytimestamp_; + uint32_t firstframelength_; + bool isanimated_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_StickerSyncRMRMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.StickerSyncRMRMessage) */ { + public: + inline Message_StickerSyncRMRMessage() : Message_StickerSyncRMRMessage(nullptr) {} + ~Message_StickerSyncRMRMessage() override; + explicit PROTOBUF_CONSTEXPR Message_StickerSyncRMRMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_StickerSyncRMRMessage(const Message_StickerSyncRMRMessage& from); + Message_StickerSyncRMRMessage(Message_StickerSyncRMRMessage&& from) noexcept + : Message_StickerSyncRMRMessage() { + *this = ::std::move(from); + } + + inline Message_StickerSyncRMRMessage& operator=(const Message_StickerSyncRMRMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_StickerSyncRMRMessage& operator=(Message_StickerSyncRMRMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_StickerSyncRMRMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_StickerSyncRMRMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_StickerSyncRMRMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 131; + + friend void swap(Message_StickerSyncRMRMessage& a, Message_StickerSyncRMRMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_StickerSyncRMRMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_StickerSyncRMRMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_StickerSyncRMRMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_StickerSyncRMRMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_StickerSyncRMRMessage& from) { + Message_StickerSyncRMRMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_StickerSyncRMRMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.StickerSyncRMRMessage"; + } + protected: + explicit Message_StickerSyncRMRMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kFilehashFieldNumber = 1, + kRmrSourceFieldNumber = 2, + kRequestTimestampFieldNumber = 3, + }; + // repeated string filehash = 1; + int filehash_size() const; + private: + int _internal_filehash_size() const; + public: + void clear_filehash(); + const std::string& filehash(int index) const; + std::string* mutable_filehash(int index); + void set_filehash(int index, const std::string& value); + void set_filehash(int index, std::string&& value); + void set_filehash(int index, const char* value); + void set_filehash(int index, const char* value, size_t size); + std::string* add_filehash(); + void add_filehash(const std::string& value); + void add_filehash(std::string&& value); + void add_filehash(const char* value); + void add_filehash(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& filehash() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_filehash(); + private: + const std::string& _internal_filehash(int index) const; + std::string* _internal_add_filehash(); + public: + + // optional string rmrSource = 2; + bool has_rmrsource() const; + private: + bool _internal_has_rmrsource() const; + public: + void clear_rmrsource(); + const std::string& rmrsource() const; + template + void set_rmrsource(ArgT0&& arg0, ArgT... args); + std::string* mutable_rmrsource(); + PROTOBUF_NODISCARD std::string* release_rmrsource(); + void set_allocated_rmrsource(std::string* rmrsource); + private: + const std::string& _internal_rmrsource() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_rmrsource(const std::string& value); + std::string* _internal_mutable_rmrsource(); + public: + + // optional int64 requestTimestamp = 3; + bool has_requesttimestamp() const; + private: + bool _internal_has_requesttimestamp() const; + public: + void clear_requesttimestamp(); + int64_t requesttimestamp() const; + void set_requesttimestamp(int64_t value); + private: + int64_t _internal_requesttimestamp() const; + void _internal_set_requesttimestamp(int64_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.StickerSyncRMRMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField filehash_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rmrsource_; + int64_t requesttimestamp_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_TemplateButtonReplyMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.TemplateButtonReplyMessage) */ { + public: + inline Message_TemplateButtonReplyMessage() : Message_TemplateButtonReplyMessage(nullptr) {} + ~Message_TemplateButtonReplyMessage() override; + explicit PROTOBUF_CONSTEXPR Message_TemplateButtonReplyMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_TemplateButtonReplyMessage(const Message_TemplateButtonReplyMessage& from); + Message_TemplateButtonReplyMessage(Message_TemplateButtonReplyMessage&& from) noexcept + : Message_TemplateButtonReplyMessage() { + *this = ::std::move(from); + } + + inline Message_TemplateButtonReplyMessage& operator=(const Message_TemplateButtonReplyMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_TemplateButtonReplyMessage& operator=(Message_TemplateButtonReplyMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_TemplateButtonReplyMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_TemplateButtonReplyMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_TemplateButtonReplyMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 132; + + friend void swap(Message_TemplateButtonReplyMessage& a, Message_TemplateButtonReplyMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_TemplateButtonReplyMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_TemplateButtonReplyMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_TemplateButtonReplyMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_TemplateButtonReplyMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_TemplateButtonReplyMessage& from) { + Message_TemplateButtonReplyMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_TemplateButtonReplyMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.TemplateButtonReplyMessage"; + } + protected: + explicit Message_TemplateButtonReplyMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSelectedIdFieldNumber = 1, + kSelectedDisplayTextFieldNumber = 2, + kContextInfoFieldNumber = 3, + kSelectedIndexFieldNumber = 4, + }; + // optional string selectedId = 1; + bool has_selectedid() const; + private: + bool _internal_has_selectedid() const; + public: + void clear_selectedid(); + const std::string& selectedid() const; + template + void set_selectedid(ArgT0&& arg0, ArgT... args); + std::string* mutable_selectedid(); + PROTOBUF_NODISCARD std::string* release_selectedid(); + void set_allocated_selectedid(std::string* selectedid); + private: + const std::string& _internal_selectedid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_selectedid(const std::string& value); + std::string* _internal_mutable_selectedid(); + public: + + // optional string selectedDisplayText = 2; + bool has_selecteddisplaytext() const; + private: + bool _internal_has_selecteddisplaytext() const; + public: + void clear_selecteddisplaytext(); + const std::string& selecteddisplaytext() const; + template + void set_selecteddisplaytext(ArgT0&& arg0, ArgT... args); + std::string* mutable_selecteddisplaytext(); + PROTOBUF_NODISCARD std::string* release_selecteddisplaytext(); + void set_allocated_selecteddisplaytext(std::string* selecteddisplaytext); + private: + const std::string& _internal_selecteddisplaytext() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_selecteddisplaytext(const std::string& value); + std::string* _internal_mutable_selecteddisplaytext(); + public: + + // optional .proto.ContextInfo contextInfo = 3; + bool has_contextinfo() const; + private: + bool _internal_has_contextinfo() const; + public: + void clear_contextinfo(); + const ::proto::ContextInfo& contextinfo() const; + PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); + ::proto::ContextInfo* mutable_contextinfo(); + void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); + private: + const ::proto::ContextInfo& _internal_contextinfo() const; + ::proto::ContextInfo* _internal_mutable_contextinfo(); + public: + void unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo); + ::proto::ContextInfo* unsafe_arena_release_contextinfo(); + + // optional uint32 selectedIndex = 4; + bool has_selectedindex() const; + private: + bool _internal_has_selectedindex() const; + public: + void clear_selectedindex(); + uint32_t selectedindex() const; + void set_selectedindex(uint32_t value); + private: + uint32_t _internal_selectedindex() const; + void _internal_set_selectedindex(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.TemplateButtonReplyMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr selectedid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr selecteddisplaytext_; + ::proto::ContextInfo* contextinfo_; + uint32_t selectedindex_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_TemplateMessage_FourRowTemplate final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.TemplateMessage.FourRowTemplate) */ { + public: + inline Message_TemplateMessage_FourRowTemplate() : Message_TemplateMessage_FourRowTemplate(nullptr) {} + ~Message_TemplateMessage_FourRowTemplate() override; + explicit PROTOBUF_CONSTEXPR Message_TemplateMessage_FourRowTemplate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_TemplateMessage_FourRowTemplate(const Message_TemplateMessage_FourRowTemplate& from); + Message_TemplateMessage_FourRowTemplate(Message_TemplateMessage_FourRowTemplate&& from) noexcept + : Message_TemplateMessage_FourRowTemplate() { + *this = ::std::move(from); + } + + inline Message_TemplateMessage_FourRowTemplate& operator=(const Message_TemplateMessage_FourRowTemplate& from) { + CopyFrom(from); + return *this; + } + inline Message_TemplateMessage_FourRowTemplate& operator=(Message_TemplateMessage_FourRowTemplate&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_TemplateMessage_FourRowTemplate& default_instance() { + return *internal_default_instance(); + } + enum TitleCase { + kDocumentMessage = 1, + kHighlyStructuredMessage = 2, + kImageMessage = 3, + kVideoMessage = 4, + kLocationMessage = 5, + TITLE_NOT_SET = 0, + }; + + static inline const Message_TemplateMessage_FourRowTemplate* internal_default_instance() { + return reinterpret_cast( + &_Message_TemplateMessage_FourRowTemplate_default_instance_); + } + static constexpr int kIndexInFileMessages = + 133; + + friend void swap(Message_TemplateMessage_FourRowTemplate& a, Message_TemplateMessage_FourRowTemplate& b) { + a.Swap(&b); + } + inline void Swap(Message_TemplateMessage_FourRowTemplate* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_TemplateMessage_FourRowTemplate* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_TemplateMessage_FourRowTemplate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_TemplateMessage_FourRowTemplate& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_TemplateMessage_FourRowTemplate& from) { + Message_TemplateMessage_FourRowTemplate::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_TemplateMessage_FourRowTemplate* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.TemplateMessage.FourRowTemplate"; + } + protected: + explicit Message_TemplateMessage_FourRowTemplate(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kButtonsFieldNumber = 8, + kContentFieldNumber = 6, + kFooterFieldNumber = 7, + kDocumentMessageFieldNumber = 1, + kHighlyStructuredMessageFieldNumber = 2, + kImageMessageFieldNumber = 3, + kVideoMessageFieldNumber = 4, + kLocationMessageFieldNumber = 5, + }; + // repeated .proto.TemplateButton buttons = 8; + int buttons_size() const; + private: + int _internal_buttons_size() const; + public: + void clear_buttons(); + ::proto::TemplateButton* mutable_buttons(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::TemplateButton >* + mutable_buttons(); + private: + const ::proto::TemplateButton& _internal_buttons(int index) const; + ::proto::TemplateButton* _internal_add_buttons(); + public: + const ::proto::TemplateButton& buttons(int index) const; + ::proto::TemplateButton* add_buttons(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::TemplateButton >& + buttons() const; + + // optional .proto.Message.HighlyStructuredMessage content = 6; + bool has_content() const; + private: + bool _internal_has_content() const; + public: + void clear_content(); + const ::proto::Message_HighlyStructuredMessage& content() const; + PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_content(); + ::proto::Message_HighlyStructuredMessage* mutable_content(); + void set_allocated_content(::proto::Message_HighlyStructuredMessage* content); + private: + const ::proto::Message_HighlyStructuredMessage& _internal_content() const; + ::proto::Message_HighlyStructuredMessage* _internal_mutable_content(); + public: + void unsafe_arena_set_allocated_content( + ::proto::Message_HighlyStructuredMessage* content); + ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_content(); + + // optional .proto.Message.HighlyStructuredMessage footer = 7; + bool has_footer() const; + private: + bool _internal_has_footer() const; + public: + void clear_footer(); + const ::proto::Message_HighlyStructuredMessage& footer() const; + PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_footer(); + ::proto::Message_HighlyStructuredMessage* mutable_footer(); + void set_allocated_footer(::proto::Message_HighlyStructuredMessage* footer); + private: + const ::proto::Message_HighlyStructuredMessage& _internal_footer() const; + ::proto::Message_HighlyStructuredMessage* _internal_mutable_footer(); + public: + void unsafe_arena_set_allocated_footer( + ::proto::Message_HighlyStructuredMessage* footer); + ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_footer(); + + // .proto.Message.DocumentMessage documentMessage = 1; + bool has_documentmessage() const; + private: + bool _internal_has_documentmessage() const; + public: + void clear_documentmessage(); + const ::proto::Message_DocumentMessage& documentmessage() const; + PROTOBUF_NODISCARD ::proto::Message_DocumentMessage* release_documentmessage(); + ::proto::Message_DocumentMessage* mutable_documentmessage(); + void set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage); + private: + const ::proto::Message_DocumentMessage& _internal_documentmessage() const; + ::proto::Message_DocumentMessage* _internal_mutable_documentmessage(); + public: + void unsafe_arena_set_allocated_documentmessage( + ::proto::Message_DocumentMessage* documentmessage); + ::proto::Message_DocumentMessage* unsafe_arena_release_documentmessage(); + + // .proto.Message.HighlyStructuredMessage highlyStructuredMessage = 2; + bool has_highlystructuredmessage() const; + private: + bool _internal_has_highlystructuredmessage() const; + public: + void clear_highlystructuredmessage(); + const ::proto::Message_HighlyStructuredMessage& highlystructuredmessage() const; + PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_highlystructuredmessage(); + ::proto::Message_HighlyStructuredMessage* mutable_highlystructuredmessage(); + void set_allocated_highlystructuredmessage(::proto::Message_HighlyStructuredMessage* highlystructuredmessage); + private: + const ::proto::Message_HighlyStructuredMessage& _internal_highlystructuredmessage() const; + ::proto::Message_HighlyStructuredMessage* _internal_mutable_highlystructuredmessage(); + public: + void unsafe_arena_set_allocated_highlystructuredmessage( + ::proto::Message_HighlyStructuredMessage* highlystructuredmessage); + ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_highlystructuredmessage(); + + // .proto.Message.ImageMessage imageMessage = 3; + bool has_imagemessage() const; + private: + bool _internal_has_imagemessage() const; + public: + void clear_imagemessage(); + const ::proto::Message_ImageMessage& imagemessage() const; + PROTOBUF_NODISCARD ::proto::Message_ImageMessage* release_imagemessage(); + ::proto::Message_ImageMessage* mutable_imagemessage(); + void set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage); + private: + const ::proto::Message_ImageMessage& _internal_imagemessage() const; + ::proto::Message_ImageMessage* _internal_mutable_imagemessage(); + public: + void unsafe_arena_set_allocated_imagemessage( + ::proto::Message_ImageMessage* imagemessage); + ::proto::Message_ImageMessage* unsafe_arena_release_imagemessage(); + + // .proto.Message.VideoMessage videoMessage = 4; + bool has_videomessage() const; + private: + bool _internal_has_videomessage() const; + public: + void clear_videomessage(); + const ::proto::Message_VideoMessage& videomessage() const; + PROTOBUF_NODISCARD ::proto::Message_VideoMessage* release_videomessage(); + ::proto::Message_VideoMessage* mutable_videomessage(); + void set_allocated_videomessage(::proto::Message_VideoMessage* videomessage); + private: + const ::proto::Message_VideoMessage& _internal_videomessage() const; + ::proto::Message_VideoMessage* _internal_mutable_videomessage(); + public: + void unsafe_arena_set_allocated_videomessage( + ::proto::Message_VideoMessage* videomessage); + ::proto::Message_VideoMessage* unsafe_arena_release_videomessage(); + + // .proto.Message.LocationMessage locationMessage = 5; + bool has_locationmessage() const; + private: + bool _internal_has_locationmessage() const; + public: + void clear_locationmessage(); + const ::proto::Message_LocationMessage& locationmessage() const; + PROTOBUF_NODISCARD ::proto::Message_LocationMessage* release_locationmessage(); + ::proto::Message_LocationMessage* mutable_locationmessage(); + void set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage); + private: + const ::proto::Message_LocationMessage& _internal_locationmessage() const; + ::proto::Message_LocationMessage* _internal_mutable_locationmessage(); + public: + void unsafe_arena_set_allocated_locationmessage( + ::proto::Message_LocationMessage* locationmessage); + ::proto::Message_LocationMessage* unsafe_arena_release_locationmessage(); + + void clear_title(); + TitleCase title_case() const; + // @@protoc_insertion_point(class_scope:proto.Message.TemplateMessage.FourRowTemplate) + private: + class _Internal; + void set_has_documentmessage(); + void set_has_highlystructuredmessage(); + void set_has_imagemessage(); + void set_has_videomessage(); + void set_has_locationmessage(); + + inline bool has_title() const; + inline void clear_has_title(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::TemplateButton > buttons_; + ::proto::Message_HighlyStructuredMessage* content_; + ::proto::Message_HighlyStructuredMessage* footer_; + union TitleUnion { + constexpr TitleUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::proto::Message_DocumentMessage* documentmessage_; + ::proto::Message_HighlyStructuredMessage* highlystructuredmessage_; + ::proto::Message_ImageMessage* imagemessage_; + ::proto::Message_VideoMessage* videomessage_; + ::proto::Message_LocationMessage* locationmessage_; + } title_; + uint32_t _oneof_case_[1]; + + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_TemplateMessage_HydratedFourRowTemplate final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.TemplateMessage.HydratedFourRowTemplate) */ { + public: + inline Message_TemplateMessage_HydratedFourRowTemplate() : Message_TemplateMessage_HydratedFourRowTemplate(nullptr) {} + ~Message_TemplateMessage_HydratedFourRowTemplate() override; + explicit PROTOBUF_CONSTEXPR Message_TemplateMessage_HydratedFourRowTemplate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_TemplateMessage_HydratedFourRowTemplate(const Message_TemplateMessage_HydratedFourRowTemplate& from); + Message_TemplateMessage_HydratedFourRowTemplate(Message_TemplateMessage_HydratedFourRowTemplate&& from) noexcept + : Message_TemplateMessage_HydratedFourRowTemplate() { + *this = ::std::move(from); + } + + inline Message_TemplateMessage_HydratedFourRowTemplate& operator=(const Message_TemplateMessage_HydratedFourRowTemplate& from) { + CopyFrom(from); + return *this; + } + inline Message_TemplateMessage_HydratedFourRowTemplate& operator=(Message_TemplateMessage_HydratedFourRowTemplate&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_TemplateMessage_HydratedFourRowTemplate& default_instance() { + return *internal_default_instance(); + } + enum TitleCase { + kDocumentMessage = 1, + kHydratedTitleText = 2, + kImageMessage = 3, + kVideoMessage = 4, + kLocationMessage = 5, + TITLE_NOT_SET = 0, + }; + + static inline const Message_TemplateMessage_HydratedFourRowTemplate* internal_default_instance() { + return reinterpret_cast( + &_Message_TemplateMessage_HydratedFourRowTemplate_default_instance_); + } + static constexpr int kIndexInFileMessages = + 134; + + friend void swap(Message_TemplateMessage_HydratedFourRowTemplate& a, Message_TemplateMessage_HydratedFourRowTemplate& b) { + a.Swap(&b); + } + inline void Swap(Message_TemplateMessage_HydratedFourRowTemplate* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_TemplateMessage_HydratedFourRowTemplate* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_TemplateMessage_HydratedFourRowTemplate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_TemplateMessage_HydratedFourRowTemplate& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_TemplateMessage_HydratedFourRowTemplate& from) { + Message_TemplateMessage_HydratedFourRowTemplate::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_TemplateMessage_HydratedFourRowTemplate* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.TemplateMessage.HydratedFourRowTemplate"; + } + protected: + explicit Message_TemplateMessage_HydratedFourRowTemplate(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kHydratedButtonsFieldNumber = 8, + kHydratedContentTextFieldNumber = 6, + kHydratedFooterTextFieldNumber = 7, + kTemplateIdFieldNumber = 9, + kDocumentMessageFieldNumber = 1, + kHydratedTitleTextFieldNumber = 2, + kImageMessageFieldNumber = 3, + kVideoMessageFieldNumber = 4, + kLocationMessageFieldNumber = 5, + }; + // repeated .proto.HydratedTemplateButton hydratedButtons = 8; + int hydratedbuttons_size() const; + private: + int _internal_hydratedbuttons_size() const; + public: + void clear_hydratedbuttons(); + ::proto::HydratedTemplateButton* mutable_hydratedbuttons(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HydratedTemplateButton >* + mutable_hydratedbuttons(); + private: + const ::proto::HydratedTemplateButton& _internal_hydratedbuttons(int index) const; + ::proto::HydratedTemplateButton* _internal_add_hydratedbuttons(); + public: + const ::proto::HydratedTemplateButton& hydratedbuttons(int index) const; + ::proto::HydratedTemplateButton* add_hydratedbuttons(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HydratedTemplateButton >& + hydratedbuttons() const; + + // optional string hydratedContentText = 6; + bool has_hydratedcontenttext() const; + private: + bool _internal_has_hydratedcontenttext() const; + public: + void clear_hydratedcontenttext(); + const std::string& hydratedcontenttext() const; + template + void set_hydratedcontenttext(ArgT0&& arg0, ArgT... args); + std::string* mutable_hydratedcontenttext(); + PROTOBUF_NODISCARD std::string* release_hydratedcontenttext(); + void set_allocated_hydratedcontenttext(std::string* hydratedcontenttext); + private: + const std::string& _internal_hydratedcontenttext() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_hydratedcontenttext(const std::string& value); + std::string* _internal_mutable_hydratedcontenttext(); + public: + + // optional string hydratedFooterText = 7; + bool has_hydratedfootertext() const; + private: + bool _internal_has_hydratedfootertext() const; + public: + void clear_hydratedfootertext(); + const std::string& hydratedfootertext() const; + template + void set_hydratedfootertext(ArgT0&& arg0, ArgT... args); + std::string* mutable_hydratedfootertext(); + PROTOBUF_NODISCARD std::string* release_hydratedfootertext(); + void set_allocated_hydratedfootertext(std::string* hydratedfootertext); + private: + const std::string& _internal_hydratedfootertext() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_hydratedfootertext(const std::string& value); + std::string* _internal_mutable_hydratedfootertext(); + public: + + // optional string templateId = 9; + bool has_templateid() const; + private: + bool _internal_has_templateid() const; + public: + void clear_templateid(); + const std::string& templateid() const; + template + void set_templateid(ArgT0&& arg0, ArgT... args); + std::string* mutable_templateid(); + PROTOBUF_NODISCARD std::string* release_templateid(); + void set_allocated_templateid(std::string* templateid); + private: + const std::string& _internal_templateid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_templateid(const std::string& value); + std::string* _internal_mutable_templateid(); + public: + + // .proto.Message.DocumentMessage documentMessage = 1; + bool has_documentmessage() const; + private: + bool _internal_has_documentmessage() const; + public: + void clear_documentmessage(); + const ::proto::Message_DocumentMessage& documentmessage() const; + PROTOBUF_NODISCARD ::proto::Message_DocumentMessage* release_documentmessage(); + ::proto::Message_DocumentMessage* mutable_documentmessage(); + void set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage); + private: + const ::proto::Message_DocumentMessage& _internal_documentmessage() const; + ::proto::Message_DocumentMessage* _internal_mutable_documentmessage(); + public: + void unsafe_arena_set_allocated_documentmessage( + ::proto::Message_DocumentMessage* documentmessage); + ::proto::Message_DocumentMessage* unsafe_arena_release_documentmessage(); + + // string hydratedTitleText = 2; + bool has_hydratedtitletext() const; + private: + bool _internal_has_hydratedtitletext() const; + public: + void clear_hydratedtitletext(); + const std::string& hydratedtitletext() const; + template + void set_hydratedtitletext(ArgT0&& arg0, ArgT... args); + std::string* mutable_hydratedtitletext(); + PROTOBUF_NODISCARD std::string* release_hydratedtitletext(); + void set_allocated_hydratedtitletext(std::string* hydratedtitletext); + private: + const std::string& _internal_hydratedtitletext() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_hydratedtitletext(const std::string& value); + std::string* _internal_mutable_hydratedtitletext(); + public: + + // .proto.Message.ImageMessage imageMessage = 3; + bool has_imagemessage() const; + private: + bool _internal_has_imagemessage() const; + public: + void clear_imagemessage(); + const ::proto::Message_ImageMessage& imagemessage() const; + PROTOBUF_NODISCARD ::proto::Message_ImageMessage* release_imagemessage(); + ::proto::Message_ImageMessage* mutable_imagemessage(); + void set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage); + private: + const ::proto::Message_ImageMessage& _internal_imagemessage() const; + ::proto::Message_ImageMessage* _internal_mutable_imagemessage(); + public: + void unsafe_arena_set_allocated_imagemessage( + ::proto::Message_ImageMessage* imagemessage); + ::proto::Message_ImageMessage* unsafe_arena_release_imagemessage(); + + // .proto.Message.VideoMessage videoMessage = 4; + bool has_videomessage() const; + private: + bool _internal_has_videomessage() const; + public: + void clear_videomessage(); + const ::proto::Message_VideoMessage& videomessage() const; + PROTOBUF_NODISCARD ::proto::Message_VideoMessage* release_videomessage(); + ::proto::Message_VideoMessage* mutable_videomessage(); + void set_allocated_videomessage(::proto::Message_VideoMessage* videomessage); + private: + const ::proto::Message_VideoMessage& _internal_videomessage() const; + ::proto::Message_VideoMessage* _internal_mutable_videomessage(); + public: + void unsafe_arena_set_allocated_videomessage( + ::proto::Message_VideoMessage* videomessage); + ::proto::Message_VideoMessage* unsafe_arena_release_videomessage(); + + // .proto.Message.LocationMessage locationMessage = 5; + bool has_locationmessage() const; + private: + bool _internal_has_locationmessage() const; + public: + void clear_locationmessage(); + const ::proto::Message_LocationMessage& locationmessage() const; + PROTOBUF_NODISCARD ::proto::Message_LocationMessage* release_locationmessage(); + ::proto::Message_LocationMessage* mutable_locationmessage(); + void set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage); + private: + const ::proto::Message_LocationMessage& _internal_locationmessage() const; + ::proto::Message_LocationMessage* _internal_mutable_locationmessage(); + public: + void unsafe_arena_set_allocated_locationmessage( + ::proto::Message_LocationMessage* locationmessage); + ::proto::Message_LocationMessage* unsafe_arena_release_locationmessage(); + + void clear_title(); + TitleCase title_case() const; + // @@protoc_insertion_point(class_scope:proto.Message.TemplateMessage.HydratedFourRowTemplate) + private: + class _Internal; + void set_has_documentmessage(); + void set_has_hydratedtitletext(); + void set_has_imagemessage(); + void set_has_videomessage(); + void set_has_locationmessage(); + + inline bool has_title() const; + inline void clear_has_title(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HydratedTemplateButton > hydratedbuttons_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hydratedcontenttext_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hydratedfootertext_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr templateid_; + union TitleUnion { + constexpr TitleUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::proto::Message_DocumentMessage* documentmessage_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hydratedtitletext_; + ::proto::Message_ImageMessage* imagemessage_; + ::proto::Message_VideoMessage* videomessage_; + ::proto::Message_LocationMessage* locationmessage_; + } title_; + uint32_t _oneof_case_[1]; + + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_TemplateMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.TemplateMessage) */ { + public: + inline Message_TemplateMessage() : Message_TemplateMessage(nullptr) {} + ~Message_TemplateMessage() override; + explicit PROTOBUF_CONSTEXPR Message_TemplateMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_TemplateMessage(const Message_TemplateMessage& from); + Message_TemplateMessage(Message_TemplateMessage&& from) noexcept + : Message_TemplateMessage() { + *this = ::std::move(from); + } + + inline Message_TemplateMessage& operator=(const Message_TemplateMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_TemplateMessage& operator=(Message_TemplateMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_TemplateMessage& default_instance() { + return *internal_default_instance(); + } + enum FormatCase { + kFourRowTemplate = 1, + kHydratedFourRowTemplate = 2, + FORMAT_NOT_SET = 0, + }; + + static inline const Message_TemplateMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_TemplateMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 135; + + friend void swap(Message_TemplateMessage& a, Message_TemplateMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_TemplateMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_TemplateMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_TemplateMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_TemplateMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_TemplateMessage& from) { + Message_TemplateMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_TemplateMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.TemplateMessage"; + } + protected: + explicit Message_TemplateMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Message_TemplateMessage_FourRowTemplate FourRowTemplate; + typedef Message_TemplateMessage_HydratedFourRowTemplate HydratedFourRowTemplate; + + // accessors ------------------------------------------------------- + + enum : int { + kContextInfoFieldNumber = 3, + kHydratedTemplateFieldNumber = 4, + kFourRowTemplateFieldNumber = 1, + kHydratedFourRowTemplateFieldNumber = 2, + }; + // optional .proto.ContextInfo contextInfo = 3; + bool has_contextinfo() const; + private: + bool _internal_has_contextinfo() const; + public: + void clear_contextinfo(); + const ::proto::ContextInfo& contextinfo() const; + PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); + ::proto::ContextInfo* mutable_contextinfo(); + void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); + private: + const ::proto::ContextInfo& _internal_contextinfo() const; + ::proto::ContextInfo* _internal_mutable_contextinfo(); + public: + void unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo); + ::proto::ContextInfo* unsafe_arena_release_contextinfo(); + + // optional .proto.Message.TemplateMessage.HydratedFourRowTemplate hydratedTemplate = 4; + bool has_hydratedtemplate() const; + private: + bool _internal_has_hydratedtemplate() const; + public: + void clear_hydratedtemplate(); + const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& hydratedtemplate() const; + PROTOBUF_NODISCARD ::proto::Message_TemplateMessage_HydratedFourRowTemplate* release_hydratedtemplate(); + ::proto::Message_TemplateMessage_HydratedFourRowTemplate* mutable_hydratedtemplate(); + void set_allocated_hydratedtemplate(::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedtemplate); + private: + const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& _internal_hydratedtemplate() const; + ::proto::Message_TemplateMessage_HydratedFourRowTemplate* _internal_mutable_hydratedtemplate(); + public: + void unsafe_arena_set_allocated_hydratedtemplate( + ::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedtemplate); + ::proto::Message_TemplateMessage_HydratedFourRowTemplate* unsafe_arena_release_hydratedtemplate(); + + // .proto.Message.TemplateMessage.FourRowTemplate fourRowTemplate = 1; + bool has_fourrowtemplate() const; + private: + bool _internal_has_fourrowtemplate() const; + public: + void clear_fourrowtemplate(); + const ::proto::Message_TemplateMessage_FourRowTemplate& fourrowtemplate() const; + PROTOBUF_NODISCARD ::proto::Message_TemplateMessage_FourRowTemplate* release_fourrowtemplate(); + ::proto::Message_TemplateMessage_FourRowTemplate* mutable_fourrowtemplate(); + void set_allocated_fourrowtemplate(::proto::Message_TemplateMessage_FourRowTemplate* fourrowtemplate); + private: + const ::proto::Message_TemplateMessage_FourRowTemplate& _internal_fourrowtemplate() const; + ::proto::Message_TemplateMessage_FourRowTemplate* _internal_mutable_fourrowtemplate(); + public: + void unsafe_arena_set_allocated_fourrowtemplate( + ::proto::Message_TemplateMessage_FourRowTemplate* fourrowtemplate); + ::proto::Message_TemplateMessage_FourRowTemplate* unsafe_arena_release_fourrowtemplate(); + + // .proto.Message.TemplateMessage.HydratedFourRowTemplate hydratedFourRowTemplate = 2; + bool has_hydratedfourrowtemplate() const; + private: + bool _internal_has_hydratedfourrowtemplate() const; + public: + void clear_hydratedfourrowtemplate(); + const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& hydratedfourrowtemplate() const; + PROTOBUF_NODISCARD ::proto::Message_TemplateMessage_HydratedFourRowTemplate* release_hydratedfourrowtemplate(); + ::proto::Message_TemplateMessage_HydratedFourRowTemplate* mutable_hydratedfourrowtemplate(); + void set_allocated_hydratedfourrowtemplate(::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedfourrowtemplate); + private: + const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& _internal_hydratedfourrowtemplate() const; + ::proto::Message_TemplateMessage_HydratedFourRowTemplate* _internal_mutable_hydratedfourrowtemplate(); + public: + void unsafe_arena_set_allocated_hydratedfourrowtemplate( + ::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedfourrowtemplate); + ::proto::Message_TemplateMessage_HydratedFourRowTemplate* unsafe_arena_release_hydratedfourrowtemplate(); + + void clear_format(); + FormatCase format_case() const; + // @@protoc_insertion_point(class_scope:proto.Message.TemplateMessage) + private: + class _Internal; + void set_has_fourrowtemplate(); + void set_has_hydratedfourrowtemplate(); + + inline bool has_format() const; + inline void clear_has_format(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::proto::ContextInfo* contextinfo_; + ::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedtemplate_; + union FormatUnion { + constexpr FormatUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::proto::Message_TemplateMessage_FourRowTemplate* fourrowtemplate_; + ::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedfourrowtemplate_; + } format_; + uint32_t _oneof_case_[1]; + + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message_VideoMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.VideoMessage) */ { + public: + inline Message_VideoMessage() : Message_VideoMessage(nullptr) {} + ~Message_VideoMessage() override; + explicit PROTOBUF_CONSTEXPR Message_VideoMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message_VideoMessage(const Message_VideoMessage& from); + Message_VideoMessage(Message_VideoMessage&& from) noexcept + : Message_VideoMessage() { + *this = ::std::move(from); + } + + inline Message_VideoMessage& operator=(const Message_VideoMessage& from) { + CopyFrom(from); + return *this; + } + inline Message_VideoMessage& operator=(Message_VideoMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message_VideoMessage& default_instance() { + return *internal_default_instance(); + } + static inline const Message_VideoMessage* internal_default_instance() { + return reinterpret_cast( + &_Message_VideoMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 136; + + friend void swap(Message_VideoMessage& a, Message_VideoMessage& b) { + a.Swap(&b); + } + inline void Swap(Message_VideoMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message_VideoMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message_VideoMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message_VideoMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message_VideoMessage& from) { + Message_VideoMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message_VideoMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message.VideoMessage"; + } + protected: + explicit Message_VideoMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Message_VideoMessage_Attribution Attribution; + static constexpr Attribution NONE = + Message_VideoMessage_Attribution_NONE; + static constexpr Attribution GIPHY = + Message_VideoMessage_Attribution_GIPHY; + static constexpr Attribution TENOR = + Message_VideoMessage_Attribution_TENOR; + static inline bool Attribution_IsValid(int value) { + return Message_VideoMessage_Attribution_IsValid(value); + } + static constexpr Attribution Attribution_MIN = + Message_VideoMessage_Attribution_Attribution_MIN; + static constexpr Attribution Attribution_MAX = + Message_VideoMessage_Attribution_Attribution_MAX; + static constexpr int Attribution_ARRAYSIZE = + Message_VideoMessage_Attribution_Attribution_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + Attribution_descriptor() { + return Message_VideoMessage_Attribution_descriptor(); + } + template + static inline const std::string& Attribution_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Attribution_Name."); + return Message_VideoMessage_Attribution_Name(enum_t_value); + } + static inline bool Attribution_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Attribution* value) { + return Message_VideoMessage_Attribution_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kInteractiveAnnotationsFieldNumber = 12, + kUrlFieldNumber = 1, + kMimetypeFieldNumber = 2, + kFileSha256FieldNumber = 3, + kMediaKeyFieldNumber = 6, + kCaptionFieldNumber = 7, + kFileEncSha256FieldNumber = 11, + kDirectPathFieldNumber = 13, + kJpegThumbnailFieldNumber = 16, + kStreamingSidecarFieldNumber = 18, + kThumbnailDirectPathFieldNumber = 21, + kThumbnailSha256FieldNumber = 22, + kThumbnailEncSha256FieldNumber = 23, + kStaticUrlFieldNumber = 24, + kContextInfoFieldNumber = 17, + kFileLengthFieldNumber = 4, + kSecondsFieldNumber = 5, + kHeightFieldNumber = 9, + kWidthFieldNumber = 10, + kGifPlaybackFieldNumber = 8, + kViewOnceFieldNumber = 20, + kMediaKeyTimestampFieldNumber = 14, + kGifAttributionFieldNumber = 19, + }; + // repeated .proto.InteractiveAnnotation interactiveAnnotations = 12; + int interactiveannotations_size() const; + private: + int _internal_interactiveannotations_size() const; + public: + void clear_interactiveannotations(); + ::proto::InteractiveAnnotation* mutable_interactiveannotations(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >* + mutable_interactiveannotations(); + private: + const ::proto::InteractiveAnnotation& _internal_interactiveannotations(int index) const; + ::proto::InteractiveAnnotation* _internal_add_interactiveannotations(); + public: + const ::proto::InteractiveAnnotation& interactiveannotations(int index) const; + ::proto::InteractiveAnnotation* add_interactiveannotations(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >& + interactiveannotations() const; + + // optional string url = 1; + bool has_url() const; + private: + bool _internal_has_url() const; + public: + void clear_url(); + const std::string& url() const; + template + void set_url(ArgT0&& arg0, ArgT... args); + std::string* mutable_url(); + PROTOBUF_NODISCARD std::string* release_url(); + void set_allocated_url(std::string* url); + private: + const std::string& _internal_url() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value); + std::string* _internal_mutable_url(); + public: + + // optional string mimetype = 2; + bool has_mimetype() const; + private: + bool _internal_has_mimetype() const; + public: + void clear_mimetype(); + const std::string& mimetype() const; + template + void set_mimetype(ArgT0&& arg0, ArgT... args); + std::string* mutable_mimetype(); + PROTOBUF_NODISCARD std::string* release_mimetype(); + void set_allocated_mimetype(std::string* mimetype); + private: + const std::string& _internal_mimetype() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value); + std::string* _internal_mutable_mimetype(); + public: + + // optional bytes fileSha256 = 3; + bool has_filesha256() const; + private: + bool _internal_has_filesha256() const; + public: + void clear_filesha256(); + const std::string& filesha256() const; + template + void set_filesha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_filesha256(); + PROTOBUF_NODISCARD std::string* release_filesha256(); + void set_allocated_filesha256(std::string* filesha256); + private: + const std::string& _internal_filesha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value); + std::string* _internal_mutable_filesha256(); + public: + + // optional bytes mediaKey = 6; + bool has_mediakey() const; + private: + bool _internal_has_mediakey() const; + public: + void clear_mediakey(); + const std::string& mediakey() const; + template + void set_mediakey(ArgT0&& arg0, ArgT... args); + std::string* mutable_mediakey(); + PROTOBUF_NODISCARD std::string* release_mediakey(); + void set_allocated_mediakey(std::string* mediakey); + private: + const std::string& _internal_mediakey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value); + std::string* _internal_mutable_mediakey(); + public: + + // optional string caption = 7; + bool has_caption() const; + private: + bool _internal_has_caption() const; + public: + void clear_caption(); + const std::string& caption() const; + template + void set_caption(ArgT0&& arg0, ArgT... args); + std::string* mutable_caption(); + PROTOBUF_NODISCARD std::string* release_caption(); + void set_allocated_caption(std::string* caption); + private: + const std::string& _internal_caption() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_caption(const std::string& value); + std::string* _internal_mutable_caption(); + public: + + // optional bytes fileEncSha256 = 11; + bool has_fileencsha256() const; + private: + bool _internal_has_fileencsha256() const; + public: + void clear_fileencsha256(); + const std::string& fileencsha256() const; + template + void set_fileencsha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_fileencsha256(); + PROTOBUF_NODISCARD std::string* release_fileencsha256(); + void set_allocated_fileencsha256(std::string* fileencsha256); + private: + const std::string& _internal_fileencsha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value); + std::string* _internal_mutable_fileencsha256(); + public: + + // optional string directPath = 13; + bool has_directpath() const; + private: + bool _internal_has_directpath() const; + public: + void clear_directpath(); + const std::string& directpath() const; + template + void set_directpath(ArgT0&& arg0, ArgT... args); + std::string* mutable_directpath(); + PROTOBUF_NODISCARD std::string* release_directpath(); + void set_allocated_directpath(std::string* directpath); + private: + const std::string& _internal_directpath() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value); + std::string* _internal_mutable_directpath(); + public: + + // optional bytes jpegThumbnail = 16; + bool has_jpegthumbnail() const; + private: + bool _internal_has_jpegthumbnail() const; + public: + void clear_jpegthumbnail(); + const std::string& jpegthumbnail() const; + template + void set_jpegthumbnail(ArgT0&& arg0, ArgT... args); + std::string* mutable_jpegthumbnail(); + PROTOBUF_NODISCARD std::string* release_jpegthumbnail(); + void set_allocated_jpegthumbnail(std::string* jpegthumbnail); + private: + const std::string& _internal_jpegthumbnail() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value); + std::string* _internal_mutable_jpegthumbnail(); + public: + + // optional bytes streamingSidecar = 18; + bool has_streamingsidecar() const; + private: + bool _internal_has_streamingsidecar() const; + public: + void clear_streamingsidecar(); + const std::string& streamingsidecar() const; + template + void set_streamingsidecar(ArgT0&& arg0, ArgT... args); + std::string* mutable_streamingsidecar(); + PROTOBUF_NODISCARD std::string* release_streamingsidecar(); + void set_allocated_streamingsidecar(std::string* streamingsidecar); + private: + const std::string& _internal_streamingsidecar() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_streamingsidecar(const std::string& value); + std::string* _internal_mutable_streamingsidecar(); + public: + + // optional string thumbnailDirectPath = 21; + bool has_thumbnaildirectpath() const; + private: + bool _internal_has_thumbnaildirectpath() const; + public: + void clear_thumbnaildirectpath(); + const std::string& thumbnaildirectpath() const; + template + void set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args); + std::string* mutable_thumbnaildirectpath(); + PROTOBUF_NODISCARD std::string* release_thumbnaildirectpath(); + void set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath); + private: + const std::string& _internal_thumbnaildirectpath() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnaildirectpath(const std::string& value); + std::string* _internal_mutable_thumbnaildirectpath(); + public: + + // optional bytes thumbnailSha256 = 22; + bool has_thumbnailsha256() const; + private: + bool _internal_has_thumbnailsha256() const; + public: + void clear_thumbnailsha256(); + const std::string& thumbnailsha256() const; + template + void set_thumbnailsha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_thumbnailsha256(); + PROTOBUF_NODISCARD std::string* release_thumbnailsha256(); + void set_allocated_thumbnailsha256(std::string* thumbnailsha256); + private: + const std::string& _internal_thumbnailsha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailsha256(const std::string& value); + std::string* _internal_mutable_thumbnailsha256(); + public: + + // optional bytes thumbnailEncSha256 = 23; + bool has_thumbnailencsha256() const; + private: + bool _internal_has_thumbnailencsha256() const; + public: + void clear_thumbnailencsha256(); + const std::string& thumbnailencsha256() const; + template + void set_thumbnailencsha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_thumbnailencsha256(); + PROTOBUF_NODISCARD std::string* release_thumbnailencsha256(); + void set_allocated_thumbnailencsha256(std::string* thumbnailencsha256); + private: + const std::string& _internal_thumbnailencsha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailencsha256(const std::string& value); + std::string* _internal_mutable_thumbnailencsha256(); + public: + + // optional string staticUrl = 24; + bool has_staticurl() const; + private: + bool _internal_has_staticurl() const; + public: + void clear_staticurl(); + const std::string& staticurl() const; + template + void set_staticurl(ArgT0&& arg0, ArgT... args); + std::string* mutable_staticurl(); + PROTOBUF_NODISCARD std::string* release_staticurl(); + void set_allocated_staticurl(std::string* staticurl); + private: + const std::string& _internal_staticurl() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_staticurl(const std::string& value); + std::string* _internal_mutable_staticurl(); + public: + + // optional .proto.ContextInfo contextInfo = 17; + bool has_contextinfo() const; + private: + bool _internal_has_contextinfo() const; + public: + void clear_contextinfo(); + const ::proto::ContextInfo& contextinfo() const; + PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); + ::proto::ContextInfo* mutable_contextinfo(); + void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); + private: + const ::proto::ContextInfo& _internal_contextinfo() const; + ::proto::ContextInfo* _internal_mutable_contextinfo(); + public: + void unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo); + ::proto::ContextInfo* unsafe_arena_release_contextinfo(); + + // optional uint64 fileLength = 4; + bool has_filelength() const; + private: + bool _internal_has_filelength() const; + public: + void clear_filelength(); + uint64_t filelength() const; + void set_filelength(uint64_t value); + private: + uint64_t _internal_filelength() const; + void _internal_set_filelength(uint64_t value); + public: + + // optional uint32 seconds = 5; + bool has_seconds() const; + private: + bool _internal_has_seconds() const; + public: + void clear_seconds(); + uint32_t seconds() const; + void set_seconds(uint32_t value); + private: + uint32_t _internal_seconds() const; + void _internal_set_seconds(uint32_t value); + public: + + // optional uint32 height = 9; + bool has_height() const; + private: + bool _internal_has_height() const; + public: + void clear_height(); + uint32_t height() const; + void set_height(uint32_t value); + private: + uint32_t _internal_height() const; + void _internal_set_height(uint32_t value); + public: + + // optional uint32 width = 10; + bool has_width() const; + private: + bool _internal_has_width() const; + public: + void clear_width(); + uint32_t width() const; + void set_width(uint32_t value); + private: + uint32_t _internal_width() const; + void _internal_set_width(uint32_t value); + public: + + // optional bool gifPlayback = 8; + bool has_gifplayback() const; + private: + bool _internal_has_gifplayback() const; + public: + void clear_gifplayback(); + bool gifplayback() const; + void set_gifplayback(bool value); + private: + bool _internal_gifplayback() const; + void _internal_set_gifplayback(bool value); + public: + + // optional bool viewOnce = 20; + bool has_viewonce() const; + private: + bool _internal_has_viewonce() const; + public: + void clear_viewonce(); + bool viewonce() const; + void set_viewonce(bool value); + private: + bool _internal_viewonce() const; + void _internal_set_viewonce(bool value); + public: + + // optional int64 mediaKeyTimestamp = 14; + bool has_mediakeytimestamp() const; + private: + bool _internal_has_mediakeytimestamp() const; + public: + void clear_mediakeytimestamp(); + int64_t mediakeytimestamp() const; + void set_mediakeytimestamp(int64_t value); + private: + int64_t _internal_mediakeytimestamp() const; + void _internal_set_mediakeytimestamp(int64_t value); + public: + + // optional .proto.Message.VideoMessage.Attribution gifAttribution = 19; + bool has_gifattribution() const; + private: + bool _internal_has_gifattribution() const; + public: + void clear_gifattribution(); + ::proto::Message_VideoMessage_Attribution gifattribution() const; + void set_gifattribution(::proto::Message_VideoMessage_Attribution value); + private: + ::proto::Message_VideoMessage_Attribution _internal_gifattribution() const; + void _internal_set_gifattribution(::proto::Message_VideoMessage_Attribution value); + public: + + // @@protoc_insertion_point(class_scope:proto.Message.VideoMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation > interactiveannotations_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mimetype_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr caption_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr streamingsidecar_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnaildirectpath_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailsha256_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailencsha256_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr staticurl_; + ::proto::ContextInfo* contextinfo_; + uint64_t filelength_; + uint32_t seconds_; + uint32_t height_; + uint32_t width_; + bool gifplayback_; + bool viewonce_; + int64_t mediakeytimestamp_; + int gifattribution_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Message final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message) */ { + public: + inline Message() : Message(nullptr) {} + ~Message() override; + explicit PROTOBUF_CONSTEXPR Message(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Message(const Message& from); + Message(Message&& from) noexcept + : Message() { + *this = ::std::move(from); + } + + inline Message& operator=(const Message& from) { + CopyFrom(from); + return *this; + } + inline Message& operator=(Message&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Message& default_instance() { + return *internal_default_instance(); + } + static inline const Message* internal_default_instance() { + return reinterpret_cast( + &_Message_default_instance_); + } + static constexpr int kIndexInFileMessages = + 137; + + friend void swap(Message& a, Message& b) { + a.Swap(&b); + } + inline void Swap(Message* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Message& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Message& from) { + Message::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Message* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Message"; + } + protected: + explicit Message(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Message_AppStateFatalExceptionNotification AppStateFatalExceptionNotification; + typedef Message_AppStateSyncKeyData AppStateSyncKeyData; + typedef Message_AppStateSyncKeyFingerprint AppStateSyncKeyFingerprint; + typedef Message_AppStateSyncKeyId AppStateSyncKeyId; + typedef Message_AppStateSyncKeyRequest AppStateSyncKeyRequest; + typedef Message_AppStateSyncKeyShare AppStateSyncKeyShare; + typedef Message_AppStateSyncKey AppStateSyncKey; + typedef Message_AudioMessage AudioMessage; + typedef Message_ButtonsMessage ButtonsMessage; + typedef Message_ButtonsResponseMessage ButtonsResponseMessage; + typedef Message_Call Call; + typedef Message_CancelPaymentRequestMessage CancelPaymentRequestMessage; + typedef Message_Chat Chat; + typedef Message_ContactMessage ContactMessage; + typedef Message_ContactsArrayMessage ContactsArrayMessage; + typedef Message_DeclinePaymentRequestMessage DeclinePaymentRequestMessage; + typedef Message_DeviceSentMessage DeviceSentMessage; + typedef Message_DocumentMessage DocumentMessage; + typedef Message_ExtendedTextMessage ExtendedTextMessage; + typedef Message_FutureProofMessage FutureProofMessage; + typedef Message_GroupInviteMessage GroupInviteMessage; + typedef Message_HighlyStructuredMessage HighlyStructuredMessage; + typedef Message_HistorySyncNotification HistorySyncNotification; + typedef Message_ImageMessage ImageMessage; + typedef Message_InitialSecurityNotificationSettingSync InitialSecurityNotificationSettingSync; + typedef Message_InteractiveMessage InteractiveMessage; + typedef Message_InteractiveResponseMessage InteractiveResponseMessage; + typedef Message_InvoiceMessage InvoiceMessage; + typedef Message_KeepInChatMessage KeepInChatMessage; + typedef Message_ListMessage ListMessage; + typedef Message_ListResponseMessage ListResponseMessage; + typedef Message_LiveLocationMessage LiveLocationMessage; + typedef Message_LocationMessage LocationMessage; + typedef Message_OrderMessage OrderMessage; + typedef Message_PaymentInviteMessage PaymentInviteMessage; + typedef Message_PollCreationMessage PollCreationMessage; + typedef Message_PollEncValue PollEncValue; + typedef Message_PollUpdateMessageMetadata PollUpdateMessageMetadata; + typedef Message_PollUpdateMessage PollUpdateMessage; + typedef Message_PollVoteMessage PollVoteMessage; + typedef Message_ProductMessage ProductMessage; + typedef Message_ProtocolMessage ProtocolMessage; + typedef Message_ReactionMessage ReactionMessage; + typedef Message_RequestMediaUploadMessage RequestMediaUploadMessage; + typedef Message_RequestMediaUploadResponseMessage RequestMediaUploadResponseMessage; + typedef Message_RequestPaymentMessage RequestPaymentMessage; + typedef Message_RequestPhoneNumberMessage RequestPhoneNumberMessage; + typedef Message_SendPaymentMessage SendPaymentMessage; + typedef Message_SenderKeyDistributionMessage SenderKeyDistributionMessage; + typedef Message_StickerMessage StickerMessage; + typedef Message_StickerSyncRMRMessage StickerSyncRMRMessage; + typedef Message_TemplateButtonReplyMessage TemplateButtonReplyMessage; + typedef Message_TemplateMessage TemplateMessage; + typedef Message_VideoMessage VideoMessage; + + typedef Message_RmrSource RmrSource; + static constexpr RmrSource FAVORITE_STICKER = + Message_RmrSource_FAVORITE_STICKER; + static constexpr RmrSource RECENT_STICKER = + Message_RmrSource_RECENT_STICKER; + static inline bool RmrSource_IsValid(int value) { + return Message_RmrSource_IsValid(value); + } + static constexpr RmrSource RmrSource_MIN = + Message_RmrSource_RmrSource_MIN; + static constexpr RmrSource RmrSource_MAX = + Message_RmrSource_RmrSource_MAX; + static constexpr int RmrSource_ARRAYSIZE = + Message_RmrSource_RmrSource_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + RmrSource_descriptor() { + return Message_RmrSource_descriptor(); + } + template + static inline const std::string& RmrSource_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function RmrSource_Name."); + return Message_RmrSource_Name(enum_t_value); + } + static inline bool RmrSource_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + RmrSource* value) { + return Message_RmrSource_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kConversationFieldNumber = 1, + kSenderKeyDistributionMessageFieldNumber = 2, + kImageMessageFieldNumber = 3, + kContactMessageFieldNumber = 4, + kLocationMessageFieldNumber = 5, + kExtendedTextMessageFieldNumber = 6, + kDocumentMessageFieldNumber = 7, + kAudioMessageFieldNumber = 8, + kVideoMessageFieldNumber = 9, + kCallFieldNumber = 10, + kChatFieldNumber = 11, + kProtocolMessageFieldNumber = 12, + kContactsArrayMessageFieldNumber = 13, + kHighlyStructuredMessageFieldNumber = 14, + kFastRatchetKeySenderKeyDistributionMessageFieldNumber = 15, + kSendPaymentMessageFieldNumber = 16, + kLiveLocationMessageFieldNumber = 18, + kRequestPaymentMessageFieldNumber = 22, + kDeclinePaymentRequestMessageFieldNumber = 23, + kCancelPaymentRequestMessageFieldNumber = 24, + kTemplateMessageFieldNumber = 25, + kStickerMessageFieldNumber = 26, + kGroupInviteMessageFieldNumber = 28, + kTemplateButtonReplyMessageFieldNumber = 29, + kProductMessageFieldNumber = 30, + kDeviceSentMessageFieldNumber = 31, + kMessageContextInfoFieldNumber = 35, + kListMessageFieldNumber = 36, + kViewOnceMessageFieldNumber = 37, + kOrderMessageFieldNumber = 38, + kListResponseMessageFieldNumber = 39, + kEphemeralMessageFieldNumber = 40, + kInvoiceMessageFieldNumber = 41, + kButtonsMessageFieldNumber = 42, + kButtonsResponseMessageFieldNumber = 43, + kPaymentInviteMessageFieldNumber = 44, + kInteractiveMessageFieldNumber = 45, + kReactionMessageFieldNumber = 46, + kStickerSyncRmrMessageFieldNumber = 47, + kInteractiveResponseMessageFieldNumber = 48, + kPollCreationMessageFieldNumber = 49, + kPollUpdateMessageFieldNumber = 50, + kKeepInChatMessageFieldNumber = 51, + kDocumentWithCaptionMessageFieldNumber = 53, + kRequestPhoneNumberMessageFieldNumber = 54, + kViewOnceMessageV2FieldNumber = 55, + }; + // optional string conversation = 1; + bool has_conversation() const; + private: + bool _internal_has_conversation() const; + public: + void clear_conversation(); + const std::string& conversation() const; + template + void set_conversation(ArgT0&& arg0, ArgT... args); + std::string* mutable_conversation(); + PROTOBUF_NODISCARD std::string* release_conversation(); + void set_allocated_conversation(std::string* conversation); + private: + const std::string& _internal_conversation() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_conversation(const std::string& value); + std::string* _internal_mutable_conversation(); + public: + + // optional .proto.Message.SenderKeyDistributionMessage senderKeyDistributionMessage = 2; + bool has_senderkeydistributionmessage() const; + private: + bool _internal_has_senderkeydistributionmessage() const; + public: + void clear_senderkeydistributionmessage(); + const ::proto::Message_SenderKeyDistributionMessage& senderkeydistributionmessage() const; + PROTOBUF_NODISCARD ::proto::Message_SenderKeyDistributionMessage* release_senderkeydistributionmessage(); + ::proto::Message_SenderKeyDistributionMessage* mutable_senderkeydistributionmessage(); + void set_allocated_senderkeydistributionmessage(::proto::Message_SenderKeyDistributionMessage* senderkeydistributionmessage); + private: + const ::proto::Message_SenderKeyDistributionMessage& _internal_senderkeydistributionmessage() const; + ::proto::Message_SenderKeyDistributionMessage* _internal_mutable_senderkeydistributionmessage(); + public: + void unsafe_arena_set_allocated_senderkeydistributionmessage( + ::proto::Message_SenderKeyDistributionMessage* senderkeydistributionmessage); + ::proto::Message_SenderKeyDistributionMessage* unsafe_arena_release_senderkeydistributionmessage(); + + // optional .proto.Message.ImageMessage imageMessage = 3; + bool has_imagemessage() const; + private: + bool _internal_has_imagemessage() const; + public: + void clear_imagemessage(); + const ::proto::Message_ImageMessage& imagemessage() const; + PROTOBUF_NODISCARD ::proto::Message_ImageMessage* release_imagemessage(); + ::proto::Message_ImageMessage* mutable_imagemessage(); + void set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage); + private: + const ::proto::Message_ImageMessage& _internal_imagemessage() const; + ::proto::Message_ImageMessage* _internal_mutable_imagemessage(); + public: + void unsafe_arena_set_allocated_imagemessage( + ::proto::Message_ImageMessage* imagemessage); + ::proto::Message_ImageMessage* unsafe_arena_release_imagemessage(); + + // optional .proto.Message.ContactMessage contactMessage = 4; + bool has_contactmessage() const; + private: + bool _internal_has_contactmessage() const; + public: + void clear_contactmessage(); + const ::proto::Message_ContactMessage& contactmessage() const; + PROTOBUF_NODISCARD ::proto::Message_ContactMessage* release_contactmessage(); + ::proto::Message_ContactMessage* mutable_contactmessage(); + void set_allocated_contactmessage(::proto::Message_ContactMessage* contactmessage); + private: + const ::proto::Message_ContactMessage& _internal_contactmessage() const; + ::proto::Message_ContactMessage* _internal_mutable_contactmessage(); + public: + void unsafe_arena_set_allocated_contactmessage( + ::proto::Message_ContactMessage* contactmessage); + ::proto::Message_ContactMessage* unsafe_arena_release_contactmessage(); + + // optional .proto.Message.LocationMessage locationMessage = 5; + bool has_locationmessage() const; + private: + bool _internal_has_locationmessage() const; + public: + void clear_locationmessage(); + const ::proto::Message_LocationMessage& locationmessage() const; + PROTOBUF_NODISCARD ::proto::Message_LocationMessage* release_locationmessage(); + ::proto::Message_LocationMessage* mutable_locationmessage(); + void set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage); + private: + const ::proto::Message_LocationMessage& _internal_locationmessage() const; + ::proto::Message_LocationMessage* _internal_mutable_locationmessage(); + public: + void unsafe_arena_set_allocated_locationmessage( + ::proto::Message_LocationMessage* locationmessage); + ::proto::Message_LocationMessage* unsafe_arena_release_locationmessage(); + + // optional .proto.Message.ExtendedTextMessage extendedTextMessage = 6; + bool has_extendedtextmessage() const; + private: + bool _internal_has_extendedtextmessage() const; + public: + void clear_extendedtextmessage(); + const ::proto::Message_ExtendedTextMessage& extendedtextmessage() const; + PROTOBUF_NODISCARD ::proto::Message_ExtendedTextMessage* release_extendedtextmessage(); + ::proto::Message_ExtendedTextMessage* mutable_extendedtextmessage(); + void set_allocated_extendedtextmessage(::proto::Message_ExtendedTextMessage* extendedtextmessage); + private: + const ::proto::Message_ExtendedTextMessage& _internal_extendedtextmessage() const; + ::proto::Message_ExtendedTextMessage* _internal_mutable_extendedtextmessage(); + public: + void unsafe_arena_set_allocated_extendedtextmessage( + ::proto::Message_ExtendedTextMessage* extendedtextmessage); + ::proto::Message_ExtendedTextMessage* unsafe_arena_release_extendedtextmessage(); + + // optional .proto.Message.DocumentMessage documentMessage = 7; + bool has_documentmessage() const; + private: + bool _internal_has_documentmessage() const; + public: + void clear_documentmessage(); + const ::proto::Message_DocumentMessage& documentmessage() const; + PROTOBUF_NODISCARD ::proto::Message_DocumentMessage* release_documentmessage(); + ::proto::Message_DocumentMessage* mutable_documentmessage(); + void set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage); + private: + const ::proto::Message_DocumentMessage& _internal_documentmessage() const; + ::proto::Message_DocumentMessage* _internal_mutable_documentmessage(); + public: + void unsafe_arena_set_allocated_documentmessage( + ::proto::Message_DocumentMessage* documentmessage); + ::proto::Message_DocumentMessage* unsafe_arena_release_documentmessage(); + + // optional .proto.Message.AudioMessage audioMessage = 8; + bool has_audiomessage() const; + private: + bool _internal_has_audiomessage() const; + public: + void clear_audiomessage(); + const ::proto::Message_AudioMessage& audiomessage() const; + PROTOBUF_NODISCARD ::proto::Message_AudioMessage* release_audiomessage(); + ::proto::Message_AudioMessage* mutable_audiomessage(); + void set_allocated_audiomessage(::proto::Message_AudioMessage* audiomessage); + private: + const ::proto::Message_AudioMessage& _internal_audiomessage() const; + ::proto::Message_AudioMessage* _internal_mutable_audiomessage(); + public: + void unsafe_arena_set_allocated_audiomessage( + ::proto::Message_AudioMessage* audiomessage); + ::proto::Message_AudioMessage* unsafe_arena_release_audiomessage(); + + // optional .proto.Message.VideoMessage videoMessage = 9; + bool has_videomessage() const; + private: + bool _internal_has_videomessage() const; + public: + void clear_videomessage(); + const ::proto::Message_VideoMessage& videomessage() const; + PROTOBUF_NODISCARD ::proto::Message_VideoMessage* release_videomessage(); + ::proto::Message_VideoMessage* mutable_videomessage(); + void set_allocated_videomessage(::proto::Message_VideoMessage* videomessage); + private: + const ::proto::Message_VideoMessage& _internal_videomessage() const; + ::proto::Message_VideoMessage* _internal_mutable_videomessage(); + public: + void unsafe_arena_set_allocated_videomessage( + ::proto::Message_VideoMessage* videomessage); + ::proto::Message_VideoMessage* unsafe_arena_release_videomessage(); + + // optional .proto.Message.Call call = 10; + bool has_call() const; + private: + bool _internal_has_call() const; + public: + void clear_call(); + const ::proto::Message_Call& call() const; + PROTOBUF_NODISCARD ::proto::Message_Call* release_call(); + ::proto::Message_Call* mutable_call(); + void set_allocated_call(::proto::Message_Call* call); + private: + const ::proto::Message_Call& _internal_call() const; + ::proto::Message_Call* _internal_mutable_call(); + public: + void unsafe_arena_set_allocated_call( + ::proto::Message_Call* call); + ::proto::Message_Call* unsafe_arena_release_call(); + + // optional .proto.Message.Chat chat = 11; + bool has_chat() const; + private: + bool _internal_has_chat() const; + public: + void clear_chat(); + const ::proto::Message_Chat& chat() const; + PROTOBUF_NODISCARD ::proto::Message_Chat* release_chat(); + ::proto::Message_Chat* mutable_chat(); + void set_allocated_chat(::proto::Message_Chat* chat); + private: + const ::proto::Message_Chat& _internal_chat() const; + ::proto::Message_Chat* _internal_mutable_chat(); + public: + void unsafe_arena_set_allocated_chat( + ::proto::Message_Chat* chat); + ::proto::Message_Chat* unsafe_arena_release_chat(); + + // optional .proto.Message.ProtocolMessage protocolMessage = 12; + bool has_protocolmessage() const; + private: + bool _internal_has_protocolmessage() const; + public: + void clear_protocolmessage(); + const ::proto::Message_ProtocolMessage& protocolmessage() const; + PROTOBUF_NODISCARD ::proto::Message_ProtocolMessage* release_protocolmessage(); + ::proto::Message_ProtocolMessage* mutable_protocolmessage(); + void set_allocated_protocolmessage(::proto::Message_ProtocolMessage* protocolmessage); + private: + const ::proto::Message_ProtocolMessage& _internal_protocolmessage() const; + ::proto::Message_ProtocolMessage* _internal_mutable_protocolmessage(); + public: + void unsafe_arena_set_allocated_protocolmessage( + ::proto::Message_ProtocolMessage* protocolmessage); + ::proto::Message_ProtocolMessage* unsafe_arena_release_protocolmessage(); + + // optional .proto.Message.ContactsArrayMessage contactsArrayMessage = 13; + bool has_contactsarraymessage() const; + private: + bool _internal_has_contactsarraymessage() const; + public: + void clear_contactsarraymessage(); + const ::proto::Message_ContactsArrayMessage& contactsarraymessage() const; + PROTOBUF_NODISCARD ::proto::Message_ContactsArrayMessage* release_contactsarraymessage(); + ::proto::Message_ContactsArrayMessage* mutable_contactsarraymessage(); + void set_allocated_contactsarraymessage(::proto::Message_ContactsArrayMessage* contactsarraymessage); + private: + const ::proto::Message_ContactsArrayMessage& _internal_contactsarraymessage() const; + ::proto::Message_ContactsArrayMessage* _internal_mutable_contactsarraymessage(); + public: + void unsafe_arena_set_allocated_contactsarraymessage( + ::proto::Message_ContactsArrayMessage* contactsarraymessage); + ::proto::Message_ContactsArrayMessage* unsafe_arena_release_contactsarraymessage(); + + // optional .proto.Message.HighlyStructuredMessage highlyStructuredMessage = 14; + bool has_highlystructuredmessage() const; + private: + bool _internal_has_highlystructuredmessage() const; + public: + void clear_highlystructuredmessage(); + const ::proto::Message_HighlyStructuredMessage& highlystructuredmessage() const; + PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_highlystructuredmessage(); + ::proto::Message_HighlyStructuredMessage* mutable_highlystructuredmessage(); + void set_allocated_highlystructuredmessage(::proto::Message_HighlyStructuredMessage* highlystructuredmessage); + private: + const ::proto::Message_HighlyStructuredMessage& _internal_highlystructuredmessage() const; + ::proto::Message_HighlyStructuredMessage* _internal_mutable_highlystructuredmessage(); + public: + void unsafe_arena_set_allocated_highlystructuredmessage( + ::proto::Message_HighlyStructuredMessage* highlystructuredmessage); + ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_highlystructuredmessage(); + + // optional .proto.Message.SenderKeyDistributionMessage fastRatchetKeySenderKeyDistributionMessage = 15; + bool has_fastratchetkeysenderkeydistributionmessage() const; + private: + bool _internal_has_fastratchetkeysenderkeydistributionmessage() const; + public: + void clear_fastratchetkeysenderkeydistributionmessage(); + const ::proto::Message_SenderKeyDistributionMessage& fastratchetkeysenderkeydistributionmessage() const; + PROTOBUF_NODISCARD ::proto::Message_SenderKeyDistributionMessage* release_fastratchetkeysenderkeydistributionmessage(); + ::proto::Message_SenderKeyDistributionMessage* mutable_fastratchetkeysenderkeydistributionmessage(); + void set_allocated_fastratchetkeysenderkeydistributionmessage(::proto::Message_SenderKeyDistributionMessage* fastratchetkeysenderkeydistributionmessage); + private: + const ::proto::Message_SenderKeyDistributionMessage& _internal_fastratchetkeysenderkeydistributionmessage() const; + ::proto::Message_SenderKeyDistributionMessage* _internal_mutable_fastratchetkeysenderkeydistributionmessage(); + public: + void unsafe_arena_set_allocated_fastratchetkeysenderkeydistributionmessage( + ::proto::Message_SenderKeyDistributionMessage* fastratchetkeysenderkeydistributionmessage); + ::proto::Message_SenderKeyDistributionMessage* unsafe_arena_release_fastratchetkeysenderkeydistributionmessage(); + + // optional .proto.Message.SendPaymentMessage sendPaymentMessage = 16; + bool has_sendpaymentmessage() const; + private: + bool _internal_has_sendpaymentmessage() const; + public: + void clear_sendpaymentmessage(); + const ::proto::Message_SendPaymentMessage& sendpaymentmessage() const; + PROTOBUF_NODISCARD ::proto::Message_SendPaymentMessage* release_sendpaymentmessage(); + ::proto::Message_SendPaymentMessage* mutable_sendpaymentmessage(); + void set_allocated_sendpaymentmessage(::proto::Message_SendPaymentMessage* sendpaymentmessage); + private: + const ::proto::Message_SendPaymentMessage& _internal_sendpaymentmessage() const; + ::proto::Message_SendPaymentMessage* _internal_mutable_sendpaymentmessage(); + public: + void unsafe_arena_set_allocated_sendpaymentmessage( + ::proto::Message_SendPaymentMessage* sendpaymentmessage); + ::proto::Message_SendPaymentMessage* unsafe_arena_release_sendpaymentmessage(); + + // optional .proto.Message.LiveLocationMessage liveLocationMessage = 18; + bool has_livelocationmessage() const; + private: + bool _internal_has_livelocationmessage() const; + public: + void clear_livelocationmessage(); + const ::proto::Message_LiveLocationMessage& livelocationmessage() const; + PROTOBUF_NODISCARD ::proto::Message_LiveLocationMessage* release_livelocationmessage(); + ::proto::Message_LiveLocationMessage* mutable_livelocationmessage(); + void set_allocated_livelocationmessage(::proto::Message_LiveLocationMessage* livelocationmessage); + private: + const ::proto::Message_LiveLocationMessage& _internal_livelocationmessage() const; + ::proto::Message_LiveLocationMessage* _internal_mutable_livelocationmessage(); + public: + void unsafe_arena_set_allocated_livelocationmessage( + ::proto::Message_LiveLocationMessage* livelocationmessage); + ::proto::Message_LiveLocationMessage* unsafe_arena_release_livelocationmessage(); + + // optional .proto.Message.RequestPaymentMessage requestPaymentMessage = 22; + bool has_requestpaymentmessage() const; + private: + bool _internal_has_requestpaymentmessage() const; + public: + void clear_requestpaymentmessage(); + const ::proto::Message_RequestPaymentMessage& requestpaymentmessage() const; + PROTOBUF_NODISCARD ::proto::Message_RequestPaymentMessage* release_requestpaymentmessage(); + ::proto::Message_RequestPaymentMessage* mutable_requestpaymentmessage(); + void set_allocated_requestpaymentmessage(::proto::Message_RequestPaymentMessage* requestpaymentmessage); + private: + const ::proto::Message_RequestPaymentMessage& _internal_requestpaymentmessage() const; + ::proto::Message_RequestPaymentMessage* _internal_mutable_requestpaymentmessage(); + public: + void unsafe_arena_set_allocated_requestpaymentmessage( + ::proto::Message_RequestPaymentMessage* requestpaymentmessage); + ::proto::Message_RequestPaymentMessage* unsafe_arena_release_requestpaymentmessage(); + + // optional .proto.Message.DeclinePaymentRequestMessage declinePaymentRequestMessage = 23; + bool has_declinepaymentrequestmessage() const; + private: + bool _internal_has_declinepaymentrequestmessage() const; + public: + void clear_declinepaymentrequestmessage(); + const ::proto::Message_DeclinePaymentRequestMessage& declinepaymentrequestmessage() const; + PROTOBUF_NODISCARD ::proto::Message_DeclinePaymentRequestMessage* release_declinepaymentrequestmessage(); + ::proto::Message_DeclinePaymentRequestMessage* mutable_declinepaymentrequestmessage(); + void set_allocated_declinepaymentrequestmessage(::proto::Message_DeclinePaymentRequestMessage* declinepaymentrequestmessage); + private: + const ::proto::Message_DeclinePaymentRequestMessage& _internal_declinepaymentrequestmessage() const; + ::proto::Message_DeclinePaymentRequestMessage* _internal_mutable_declinepaymentrequestmessage(); + public: + void unsafe_arena_set_allocated_declinepaymentrequestmessage( + ::proto::Message_DeclinePaymentRequestMessage* declinepaymentrequestmessage); + ::proto::Message_DeclinePaymentRequestMessage* unsafe_arena_release_declinepaymentrequestmessage(); + + // optional .proto.Message.CancelPaymentRequestMessage cancelPaymentRequestMessage = 24; + bool has_cancelpaymentrequestmessage() const; + private: + bool _internal_has_cancelpaymentrequestmessage() const; + public: + void clear_cancelpaymentrequestmessage(); + const ::proto::Message_CancelPaymentRequestMessage& cancelpaymentrequestmessage() const; + PROTOBUF_NODISCARD ::proto::Message_CancelPaymentRequestMessage* release_cancelpaymentrequestmessage(); + ::proto::Message_CancelPaymentRequestMessage* mutable_cancelpaymentrequestmessage(); + void set_allocated_cancelpaymentrequestmessage(::proto::Message_CancelPaymentRequestMessage* cancelpaymentrequestmessage); + private: + const ::proto::Message_CancelPaymentRequestMessage& _internal_cancelpaymentrequestmessage() const; + ::proto::Message_CancelPaymentRequestMessage* _internal_mutable_cancelpaymentrequestmessage(); + public: + void unsafe_arena_set_allocated_cancelpaymentrequestmessage( + ::proto::Message_CancelPaymentRequestMessage* cancelpaymentrequestmessage); + ::proto::Message_CancelPaymentRequestMessage* unsafe_arena_release_cancelpaymentrequestmessage(); + + // optional .proto.Message.TemplateMessage templateMessage = 25; + bool has_templatemessage() const; + private: + bool _internal_has_templatemessage() const; + public: + void clear_templatemessage(); + const ::proto::Message_TemplateMessage& templatemessage() const; + PROTOBUF_NODISCARD ::proto::Message_TemplateMessage* release_templatemessage(); + ::proto::Message_TemplateMessage* mutable_templatemessage(); + void set_allocated_templatemessage(::proto::Message_TemplateMessage* templatemessage); + private: + const ::proto::Message_TemplateMessage& _internal_templatemessage() const; + ::proto::Message_TemplateMessage* _internal_mutable_templatemessage(); + public: + void unsafe_arena_set_allocated_templatemessage( + ::proto::Message_TemplateMessage* templatemessage); + ::proto::Message_TemplateMessage* unsafe_arena_release_templatemessage(); + + // optional .proto.Message.StickerMessage stickerMessage = 26; + bool has_stickermessage() const; + private: + bool _internal_has_stickermessage() const; + public: + void clear_stickermessage(); + const ::proto::Message_StickerMessage& stickermessage() const; + PROTOBUF_NODISCARD ::proto::Message_StickerMessage* release_stickermessage(); + ::proto::Message_StickerMessage* mutable_stickermessage(); + void set_allocated_stickermessage(::proto::Message_StickerMessage* stickermessage); + private: + const ::proto::Message_StickerMessage& _internal_stickermessage() const; + ::proto::Message_StickerMessage* _internal_mutable_stickermessage(); + public: + void unsafe_arena_set_allocated_stickermessage( + ::proto::Message_StickerMessage* stickermessage); + ::proto::Message_StickerMessage* unsafe_arena_release_stickermessage(); + + // optional .proto.Message.GroupInviteMessage groupInviteMessage = 28; + bool has_groupinvitemessage() const; + private: + bool _internal_has_groupinvitemessage() const; + public: + void clear_groupinvitemessage(); + const ::proto::Message_GroupInviteMessage& groupinvitemessage() const; + PROTOBUF_NODISCARD ::proto::Message_GroupInviteMessage* release_groupinvitemessage(); + ::proto::Message_GroupInviteMessage* mutable_groupinvitemessage(); + void set_allocated_groupinvitemessage(::proto::Message_GroupInviteMessage* groupinvitemessage); + private: + const ::proto::Message_GroupInviteMessage& _internal_groupinvitemessage() const; + ::proto::Message_GroupInviteMessage* _internal_mutable_groupinvitemessage(); + public: + void unsafe_arena_set_allocated_groupinvitemessage( + ::proto::Message_GroupInviteMessage* groupinvitemessage); + ::proto::Message_GroupInviteMessage* unsafe_arena_release_groupinvitemessage(); + + // optional .proto.Message.TemplateButtonReplyMessage templateButtonReplyMessage = 29; + bool has_templatebuttonreplymessage() const; + private: + bool _internal_has_templatebuttonreplymessage() const; + public: + void clear_templatebuttonreplymessage(); + const ::proto::Message_TemplateButtonReplyMessage& templatebuttonreplymessage() const; + PROTOBUF_NODISCARD ::proto::Message_TemplateButtonReplyMessage* release_templatebuttonreplymessage(); + ::proto::Message_TemplateButtonReplyMessage* mutable_templatebuttonreplymessage(); + void set_allocated_templatebuttonreplymessage(::proto::Message_TemplateButtonReplyMessage* templatebuttonreplymessage); + private: + const ::proto::Message_TemplateButtonReplyMessage& _internal_templatebuttonreplymessage() const; + ::proto::Message_TemplateButtonReplyMessage* _internal_mutable_templatebuttonreplymessage(); + public: + void unsafe_arena_set_allocated_templatebuttonreplymessage( + ::proto::Message_TemplateButtonReplyMessage* templatebuttonreplymessage); + ::proto::Message_TemplateButtonReplyMessage* unsafe_arena_release_templatebuttonreplymessage(); + + // optional .proto.Message.ProductMessage productMessage = 30; + bool has_productmessage() const; + private: + bool _internal_has_productmessage() const; + public: + void clear_productmessage(); + const ::proto::Message_ProductMessage& productmessage() const; + PROTOBUF_NODISCARD ::proto::Message_ProductMessage* release_productmessage(); + ::proto::Message_ProductMessage* mutable_productmessage(); + void set_allocated_productmessage(::proto::Message_ProductMessage* productmessage); + private: + const ::proto::Message_ProductMessage& _internal_productmessage() const; + ::proto::Message_ProductMessage* _internal_mutable_productmessage(); + public: + void unsafe_arena_set_allocated_productmessage( + ::proto::Message_ProductMessage* productmessage); + ::proto::Message_ProductMessage* unsafe_arena_release_productmessage(); + + // optional .proto.Message.DeviceSentMessage deviceSentMessage = 31; + bool has_devicesentmessage() const; + private: + bool _internal_has_devicesentmessage() const; + public: + void clear_devicesentmessage(); + const ::proto::Message_DeviceSentMessage& devicesentmessage() const; + PROTOBUF_NODISCARD ::proto::Message_DeviceSentMessage* release_devicesentmessage(); + ::proto::Message_DeviceSentMessage* mutable_devicesentmessage(); + void set_allocated_devicesentmessage(::proto::Message_DeviceSentMessage* devicesentmessage); + private: + const ::proto::Message_DeviceSentMessage& _internal_devicesentmessage() const; + ::proto::Message_DeviceSentMessage* _internal_mutable_devicesentmessage(); + public: + void unsafe_arena_set_allocated_devicesentmessage( + ::proto::Message_DeviceSentMessage* devicesentmessage); + ::proto::Message_DeviceSentMessage* unsafe_arena_release_devicesentmessage(); + + // optional .proto.MessageContextInfo messageContextInfo = 35; + bool has_messagecontextinfo() const; + private: + bool _internal_has_messagecontextinfo() const; + public: + void clear_messagecontextinfo(); + const ::proto::MessageContextInfo& messagecontextinfo() const; + PROTOBUF_NODISCARD ::proto::MessageContextInfo* release_messagecontextinfo(); + ::proto::MessageContextInfo* mutable_messagecontextinfo(); + void set_allocated_messagecontextinfo(::proto::MessageContextInfo* messagecontextinfo); + private: + const ::proto::MessageContextInfo& _internal_messagecontextinfo() const; + ::proto::MessageContextInfo* _internal_mutable_messagecontextinfo(); + public: + void unsafe_arena_set_allocated_messagecontextinfo( + ::proto::MessageContextInfo* messagecontextinfo); + ::proto::MessageContextInfo* unsafe_arena_release_messagecontextinfo(); + + // optional .proto.Message.ListMessage listMessage = 36; + bool has_listmessage() const; + private: + bool _internal_has_listmessage() const; + public: + void clear_listmessage(); + const ::proto::Message_ListMessage& listmessage() const; + PROTOBUF_NODISCARD ::proto::Message_ListMessage* release_listmessage(); + ::proto::Message_ListMessage* mutable_listmessage(); + void set_allocated_listmessage(::proto::Message_ListMessage* listmessage); + private: + const ::proto::Message_ListMessage& _internal_listmessage() const; + ::proto::Message_ListMessage* _internal_mutable_listmessage(); + public: + void unsafe_arena_set_allocated_listmessage( + ::proto::Message_ListMessage* listmessage); + ::proto::Message_ListMessage* unsafe_arena_release_listmessage(); + + // optional .proto.Message.FutureProofMessage viewOnceMessage = 37; + bool has_viewoncemessage() const; + private: + bool _internal_has_viewoncemessage() const; + public: + void clear_viewoncemessage(); + const ::proto::Message_FutureProofMessage& viewoncemessage() const; + PROTOBUF_NODISCARD ::proto::Message_FutureProofMessage* release_viewoncemessage(); + ::proto::Message_FutureProofMessage* mutable_viewoncemessage(); + void set_allocated_viewoncemessage(::proto::Message_FutureProofMessage* viewoncemessage); + private: + const ::proto::Message_FutureProofMessage& _internal_viewoncemessage() const; + ::proto::Message_FutureProofMessage* _internal_mutable_viewoncemessage(); + public: + void unsafe_arena_set_allocated_viewoncemessage( + ::proto::Message_FutureProofMessage* viewoncemessage); + ::proto::Message_FutureProofMessage* unsafe_arena_release_viewoncemessage(); + + // optional .proto.Message.OrderMessage orderMessage = 38; + bool has_ordermessage() const; + private: + bool _internal_has_ordermessage() const; + public: + void clear_ordermessage(); + const ::proto::Message_OrderMessage& ordermessage() const; + PROTOBUF_NODISCARD ::proto::Message_OrderMessage* release_ordermessage(); + ::proto::Message_OrderMessage* mutable_ordermessage(); + void set_allocated_ordermessage(::proto::Message_OrderMessage* ordermessage); + private: + const ::proto::Message_OrderMessage& _internal_ordermessage() const; + ::proto::Message_OrderMessage* _internal_mutable_ordermessage(); + public: + void unsafe_arena_set_allocated_ordermessage( + ::proto::Message_OrderMessage* ordermessage); + ::proto::Message_OrderMessage* unsafe_arena_release_ordermessage(); + + // optional .proto.Message.ListResponseMessage listResponseMessage = 39; + bool has_listresponsemessage() const; + private: + bool _internal_has_listresponsemessage() const; + public: + void clear_listresponsemessage(); + const ::proto::Message_ListResponseMessage& listresponsemessage() const; + PROTOBUF_NODISCARD ::proto::Message_ListResponseMessage* release_listresponsemessage(); + ::proto::Message_ListResponseMessage* mutable_listresponsemessage(); + void set_allocated_listresponsemessage(::proto::Message_ListResponseMessage* listresponsemessage); + private: + const ::proto::Message_ListResponseMessage& _internal_listresponsemessage() const; + ::proto::Message_ListResponseMessage* _internal_mutable_listresponsemessage(); + public: + void unsafe_arena_set_allocated_listresponsemessage( + ::proto::Message_ListResponseMessage* listresponsemessage); + ::proto::Message_ListResponseMessage* unsafe_arena_release_listresponsemessage(); + + // optional .proto.Message.FutureProofMessage ephemeralMessage = 40; + bool has_ephemeralmessage() const; + private: + bool _internal_has_ephemeralmessage() const; + public: + void clear_ephemeralmessage(); + const ::proto::Message_FutureProofMessage& ephemeralmessage() const; + PROTOBUF_NODISCARD ::proto::Message_FutureProofMessage* release_ephemeralmessage(); + ::proto::Message_FutureProofMessage* mutable_ephemeralmessage(); + void set_allocated_ephemeralmessage(::proto::Message_FutureProofMessage* ephemeralmessage); + private: + const ::proto::Message_FutureProofMessage& _internal_ephemeralmessage() const; + ::proto::Message_FutureProofMessage* _internal_mutable_ephemeralmessage(); + public: + void unsafe_arena_set_allocated_ephemeralmessage( + ::proto::Message_FutureProofMessage* ephemeralmessage); + ::proto::Message_FutureProofMessage* unsafe_arena_release_ephemeralmessage(); + + // optional .proto.Message.InvoiceMessage invoiceMessage = 41; + bool has_invoicemessage() const; + private: + bool _internal_has_invoicemessage() const; + public: + void clear_invoicemessage(); + const ::proto::Message_InvoiceMessage& invoicemessage() const; + PROTOBUF_NODISCARD ::proto::Message_InvoiceMessage* release_invoicemessage(); + ::proto::Message_InvoiceMessage* mutable_invoicemessage(); + void set_allocated_invoicemessage(::proto::Message_InvoiceMessage* invoicemessage); + private: + const ::proto::Message_InvoiceMessage& _internal_invoicemessage() const; + ::proto::Message_InvoiceMessage* _internal_mutable_invoicemessage(); + public: + void unsafe_arena_set_allocated_invoicemessage( + ::proto::Message_InvoiceMessage* invoicemessage); + ::proto::Message_InvoiceMessage* unsafe_arena_release_invoicemessage(); + + // optional .proto.Message.ButtonsMessage buttonsMessage = 42; + bool has_buttonsmessage() const; + private: + bool _internal_has_buttonsmessage() const; + public: + void clear_buttonsmessage(); + const ::proto::Message_ButtonsMessage& buttonsmessage() const; + PROTOBUF_NODISCARD ::proto::Message_ButtonsMessage* release_buttonsmessage(); + ::proto::Message_ButtonsMessage* mutable_buttonsmessage(); + void set_allocated_buttonsmessage(::proto::Message_ButtonsMessage* buttonsmessage); + private: + const ::proto::Message_ButtonsMessage& _internal_buttonsmessage() const; + ::proto::Message_ButtonsMessage* _internal_mutable_buttonsmessage(); + public: + void unsafe_arena_set_allocated_buttonsmessage( + ::proto::Message_ButtonsMessage* buttonsmessage); + ::proto::Message_ButtonsMessage* unsafe_arena_release_buttonsmessage(); + + // optional .proto.Message.ButtonsResponseMessage buttonsResponseMessage = 43; + bool has_buttonsresponsemessage() const; + private: + bool _internal_has_buttonsresponsemessage() const; + public: + void clear_buttonsresponsemessage(); + const ::proto::Message_ButtonsResponseMessage& buttonsresponsemessage() const; + PROTOBUF_NODISCARD ::proto::Message_ButtonsResponseMessage* release_buttonsresponsemessage(); + ::proto::Message_ButtonsResponseMessage* mutable_buttonsresponsemessage(); + void set_allocated_buttonsresponsemessage(::proto::Message_ButtonsResponseMessage* buttonsresponsemessage); + private: + const ::proto::Message_ButtonsResponseMessage& _internal_buttonsresponsemessage() const; + ::proto::Message_ButtonsResponseMessage* _internal_mutable_buttonsresponsemessage(); + public: + void unsafe_arena_set_allocated_buttonsresponsemessage( + ::proto::Message_ButtonsResponseMessage* buttonsresponsemessage); + ::proto::Message_ButtonsResponseMessage* unsafe_arena_release_buttonsresponsemessage(); + + // optional .proto.Message.PaymentInviteMessage paymentInviteMessage = 44; + bool has_paymentinvitemessage() const; + private: + bool _internal_has_paymentinvitemessage() const; + public: + void clear_paymentinvitemessage(); + const ::proto::Message_PaymentInviteMessage& paymentinvitemessage() const; + PROTOBUF_NODISCARD ::proto::Message_PaymentInviteMessage* release_paymentinvitemessage(); + ::proto::Message_PaymentInviteMessage* mutable_paymentinvitemessage(); + void set_allocated_paymentinvitemessage(::proto::Message_PaymentInviteMessage* paymentinvitemessage); + private: + const ::proto::Message_PaymentInviteMessage& _internal_paymentinvitemessage() const; + ::proto::Message_PaymentInviteMessage* _internal_mutable_paymentinvitemessage(); + public: + void unsafe_arena_set_allocated_paymentinvitemessage( + ::proto::Message_PaymentInviteMessage* paymentinvitemessage); + ::proto::Message_PaymentInviteMessage* unsafe_arena_release_paymentinvitemessage(); + + // optional .proto.Message.InteractiveMessage interactiveMessage = 45; + bool has_interactivemessage() const; + private: + bool _internal_has_interactivemessage() const; + public: + void clear_interactivemessage(); + const ::proto::Message_InteractiveMessage& interactivemessage() const; + PROTOBUF_NODISCARD ::proto::Message_InteractiveMessage* release_interactivemessage(); + ::proto::Message_InteractiveMessage* mutable_interactivemessage(); + void set_allocated_interactivemessage(::proto::Message_InteractiveMessage* interactivemessage); + private: + const ::proto::Message_InteractiveMessage& _internal_interactivemessage() const; + ::proto::Message_InteractiveMessage* _internal_mutable_interactivemessage(); + public: + void unsafe_arena_set_allocated_interactivemessage( + ::proto::Message_InteractiveMessage* interactivemessage); + ::proto::Message_InteractiveMessage* unsafe_arena_release_interactivemessage(); + + // optional .proto.Message.ReactionMessage reactionMessage = 46; + bool has_reactionmessage() const; + private: + bool _internal_has_reactionmessage() const; + public: + void clear_reactionmessage(); + const ::proto::Message_ReactionMessage& reactionmessage() const; + PROTOBUF_NODISCARD ::proto::Message_ReactionMessage* release_reactionmessage(); + ::proto::Message_ReactionMessage* mutable_reactionmessage(); + void set_allocated_reactionmessage(::proto::Message_ReactionMessage* reactionmessage); + private: + const ::proto::Message_ReactionMessage& _internal_reactionmessage() const; + ::proto::Message_ReactionMessage* _internal_mutable_reactionmessage(); + public: + void unsafe_arena_set_allocated_reactionmessage( + ::proto::Message_ReactionMessage* reactionmessage); + ::proto::Message_ReactionMessage* unsafe_arena_release_reactionmessage(); + + // optional .proto.Message.StickerSyncRMRMessage stickerSyncRmrMessage = 47; + bool has_stickersyncrmrmessage() const; + private: + bool _internal_has_stickersyncrmrmessage() const; + public: + void clear_stickersyncrmrmessage(); + const ::proto::Message_StickerSyncRMRMessage& stickersyncrmrmessage() const; + PROTOBUF_NODISCARD ::proto::Message_StickerSyncRMRMessage* release_stickersyncrmrmessage(); + ::proto::Message_StickerSyncRMRMessage* mutable_stickersyncrmrmessage(); + void set_allocated_stickersyncrmrmessage(::proto::Message_StickerSyncRMRMessage* stickersyncrmrmessage); + private: + const ::proto::Message_StickerSyncRMRMessage& _internal_stickersyncrmrmessage() const; + ::proto::Message_StickerSyncRMRMessage* _internal_mutable_stickersyncrmrmessage(); + public: + void unsafe_arena_set_allocated_stickersyncrmrmessage( + ::proto::Message_StickerSyncRMRMessage* stickersyncrmrmessage); + ::proto::Message_StickerSyncRMRMessage* unsafe_arena_release_stickersyncrmrmessage(); + + // optional .proto.Message.InteractiveResponseMessage interactiveResponseMessage = 48; + bool has_interactiveresponsemessage() const; + private: + bool _internal_has_interactiveresponsemessage() const; + public: + void clear_interactiveresponsemessage(); + const ::proto::Message_InteractiveResponseMessage& interactiveresponsemessage() const; + PROTOBUF_NODISCARD ::proto::Message_InteractiveResponseMessage* release_interactiveresponsemessage(); + ::proto::Message_InteractiveResponseMessage* mutable_interactiveresponsemessage(); + void set_allocated_interactiveresponsemessage(::proto::Message_InteractiveResponseMessage* interactiveresponsemessage); + private: + const ::proto::Message_InteractiveResponseMessage& _internal_interactiveresponsemessage() const; + ::proto::Message_InteractiveResponseMessage* _internal_mutable_interactiveresponsemessage(); + public: + void unsafe_arena_set_allocated_interactiveresponsemessage( + ::proto::Message_InteractiveResponseMessage* interactiveresponsemessage); + ::proto::Message_InteractiveResponseMessage* unsafe_arena_release_interactiveresponsemessage(); + + // optional .proto.Message.PollCreationMessage pollCreationMessage = 49; + bool has_pollcreationmessage() const; + private: + bool _internal_has_pollcreationmessage() const; + public: + void clear_pollcreationmessage(); + const ::proto::Message_PollCreationMessage& pollcreationmessage() const; + PROTOBUF_NODISCARD ::proto::Message_PollCreationMessage* release_pollcreationmessage(); + ::proto::Message_PollCreationMessage* mutable_pollcreationmessage(); + void set_allocated_pollcreationmessage(::proto::Message_PollCreationMessage* pollcreationmessage); + private: + const ::proto::Message_PollCreationMessage& _internal_pollcreationmessage() const; + ::proto::Message_PollCreationMessage* _internal_mutable_pollcreationmessage(); + public: + void unsafe_arena_set_allocated_pollcreationmessage( + ::proto::Message_PollCreationMessage* pollcreationmessage); + ::proto::Message_PollCreationMessage* unsafe_arena_release_pollcreationmessage(); + + // optional .proto.Message.PollUpdateMessage pollUpdateMessage = 50; + bool has_pollupdatemessage() const; + private: + bool _internal_has_pollupdatemessage() const; + public: + void clear_pollupdatemessage(); + const ::proto::Message_PollUpdateMessage& pollupdatemessage() const; + PROTOBUF_NODISCARD ::proto::Message_PollUpdateMessage* release_pollupdatemessage(); + ::proto::Message_PollUpdateMessage* mutable_pollupdatemessage(); + void set_allocated_pollupdatemessage(::proto::Message_PollUpdateMessage* pollupdatemessage); + private: + const ::proto::Message_PollUpdateMessage& _internal_pollupdatemessage() const; + ::proto::Message_PollUpdateMessage* _internal_mutable_pollupdatemessage(); + public: + void unsafe_arena_set_allocated_pollupdatemessage( + ::proto::Message_PollUpdateMessage* pollupdatemessage); + ::proto::Message_PollUpdateMessage* unsafe_arena_release_pollupdatemessage(); + + // optional .proto.Message.KeepInChatMessage keepInChatMessage = 51; + bool has_keepinchatmessage() const; + private: + bool _internal_has_keepinchatmessage() const; + public: + void clear_keepinchatmessage(); + const ::proto::Message_KeepInChatMessage& keepinchatmessage() const; + PROTOBUF_NODISCARD ::proto::Message_KeepInChatMessage* release_keepinchatmessage(); + ::proto::Message_KeepInChatMessage* mutable_keepinchatmessage(); + void set_allocated_keepinchatmessage(::proto::Message_KeepInChatMessage* keepinchatmessage); + private: + const ::proto::Message_KeepInChatMessage& _internal_keepinchatmessage() const; + ::proto::Message_KeepInChatMessage* _internal_mutable_keepinchatmessage(); + public: + void unsafe_arena_set_allocated_keepinchatmessage( + ::proto::Message_KeepInChatMessage* keepinchatmessage); + ::proto::Message_KeepInChatMessage* unsafe_arena_release_keepinchatmessage(); + + // optional .proto.Message.FutureProofMessage documentWithCaptionMessage = 53; + bool has_documentwithcaptionmessage() const; + private: + bool _internal_has_documentwithcaptionmessage() const; + public: + void clear_documentwithcaptionmessage(); + const ::proto::Message_FutureProofMessage& documentwithcaptionmessage() const; + PROTOBUF_NODISCARD ::proto::Message_FutureProofMessage* release_documentwithcaptionmessage(); + ::proto::Message_FutureProofMessage* mutable_documentwithcaptionmessage(); + void set_allocated_documentwithcaptionmessage(::proto::Message_FutureProofMessage* documentwithcaptionmessage); + private: + const ::proto::Message_FutureProofMessage& _internal_documentwithcaptionmessage() const; + ::proto::Message_FutureProofMessage* _internal_mutable_documentwithcaptionmessage(); + public: + void unsafe_arena_set_allocated_documentwithcaptionmessage( + ::proto::Message_FutureProofMessage* documentwithcaptionmessage); + ::proto::Message_FutureProofMessage* unsafe_arena_release_documentwithcaptionmessage(); + + // optional .proto.Message.RequestPhoneNumberMessage requestPhoneNumberMessage = 54; + bool has_requestphonenumbermessage() const; + private: + bool _internal_has_requestphonenumbermessage() const; + public: + void clear_requestphonenumbermessage(); + const ::proto::Message_RequestPhoneNumberMessage& requestphonenumbermessage() const; + PROTOBUF_NODISCARD ::proto::Message_RequestPhoneNumberMessage* release_requestphonenumbermessage(); + ::proto::Message_RequestPhoneNumberMessage* mutable_requestphonenumbermessage(); + void set_allocated_requestphonenumbermessage(::proto::Message_RequestPhoneNumberMessage* requestphonenumbermessage); + private: + const ::proto::Message_RequestPhoneNumberMessage& _internal_requestphonenumbermessage() const; + ::proto::Message_RequestPhoneNumberMessage* _internal_mutable_requestphonenumbermessage(); + public: + void unsafe_arena_set_allocated_requestphonenumbermessage( + ::proto::Message_RequestPhoneNumberMessage* requestphonenumbermessage); + ::proto::Message_RequestPhoneNumberMessage* unsafe_arena_release_requestphonenumbermessage(); + + // optional .proto.Message.FutureProofMessage viewOnceMessageV2 = 55; + bool has_viewoncemessagev2() const; + private: + bool _internal_has_viewoncemessagev2() const; + public: + void clear_viewoncemessagev2(); + const ::proto::Message_FutureProofMessage& viewoncemessagev2() const; + PROTOBUF_NODISCARD ::proto::Message_FutureProofMessage* release_viewoncemessagev2(); + ::proto::Message_FutureProofMessage* mutable_viewoncemessagev2(); + void set_allocated_viewoncemessagev2(::proto::Message_FutureProofMessage* viewoncemessagev2); + private: + const ::proto::Message_FutureProofMessage& _internal_viewoncemessagev2() const; + ::proto::Message_FutureProofMessage* _internal_mutable_viewoncemessagev2(); + public: + void unsafe_arena_set_allocated_viewoncemessagev2( + ::proto::Message_FutureProofMessage* viewoncemessagev2); + ::proto::Message_FutureProofMessage* unsafe_arena_release_viewoncemessagev2(); + + // @@protoc_insertion_point(class_scope:proto.Message) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<2> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conversation_; + ::proto::Message_SenderKeyDistributionMessage* senderkeydistributionmessage_; + ::proto::Message_ImageMessage* imagemessage_; + ::proto::Message_ContactMessage* contactmessage_; + ::proto::Message_LocationMessage* locationmessage_; + ::proto::Message_ExtendedTextMessage* extendedtextmessage_; + ::proto::Message_DocumentMessage* documentmessage_; + ::proto::Message_AudioMessage* audiomessage_; + ::proto::Message_VideoMessage* videomessage_; + ::proto::Message_Call* call_; + ::proto::Message_Chat* chat_; + ::proto::Message_ProtocolMessage* protocolmessage_; + ::proto::Message_ContactsArrayMessage* contactsarraymessage_; + ::proto::Message_HighlyStructuredMessage* highlystructuredmessage_; + ::proto::Message_SenderKeyDistributionMessage* fastratchetkeysenderkeydistributionmessage_; + ::proto::Message_SendPaymentMessage* sendpaymentmessage_; + ::proto::Message_LiveLocationMessage* livelocationmessage_; + ::proto::Message_RequestPaymentMessage* requestpaymentmessage_; + ::proto::Message_DeclinePaymentRequestMessage* declinepaymentrequestmessage_; + ::proto::Message_CancelPaymentRequestMessage* cancelpaymentrequestmessage_; + ::proto::Message_TemplateMessage* templatemessage_; + ::proto::Message_StickerMessage* stickermessage_; + ::proto::Message_GroupInviteMessage* groupinvitemessage_; + ::proto::Message_TemplateButtonReplyMessage* templatebuttonreplymessage_; + ::proto::Message_ProductMessage* productmessage_; + ::proto::Message_DeviceSentMessage* devicesentmessage_; + ::proto::MessageContextInfo* messagecontextinfo_; + ::proto::Message_ListMessage* listmessage_; + ::proto::Message_FutureProofMessage* viewoncemessage_; + ::proto::Message_OrderMessage* ordermessage_; + ::proto::Message_ListResponseMessage* listresponsemessage_; + ::proto::Message_FutureProofMessage* ephemeralmessage_; + ::proto::Message_InvoiceMessage* invoicemessage_; + ::proto::Message_ButtonsMessage* buttonsmessage_; + ::proto::Message_ButtonsResponseMessage* buttonsresponsemessage_; + ::proto::Message_PaymentInviteMessage* paymentinvitemessage_; + ::proto::Message_InteractiveMessage* interactivemessage_; + ::proto::Message_ReactionMessage* reactionmessage_; + ::proto::Message_StickerSyncRMRMessage* stickersyncrmrmessage_; + ::proto::Message_InteractiveResponseMessage* interactiveresponsemessage_; + ::proto::Message_PollCreationMessage* pollcreationmessage_; + ::proto::Message_PollUpdateMessage* pollupdatemessage_; + ::proto::Message_KeepInChatMessage* keepinchatmessage_; + ::proto::Message_FutureProofMessage* documentwithcaptionmessage_; + ::proto::Message_RequestPhoneNumberMessage* requestphonenumbermessage_; + ::proto::Message_FutureProofMessage* viewoncemessagev2_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class MessageContextInfo final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.MessageContextInfo) */ { + public: + inline MessageContextInfo() : MessageContextInfo(nullptr) {} + ~MessageContextInfo() override; + explicit PROTOBUF_CONSTEXPR MessageContextInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + MessageContextInfo(const MessageContextInfo& from); + MessageContextInfo(MessageContextInfo&& from) noexcept + : MessageContextInfo() { + *this = ::std::move(from); + } + + inline MessageContextInfo& operator=(const MessageContextInfo& from) { + CopyFrom(from); + return *this; + } + inline MessageContextInfo& operator=(MessageContextInfo&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const MessageContextInfo& default_instance() { + return *internal_default_instance(); + } + static inline const MessageContextInfo* internal_default_instance() { + return reinterpret_cast( + &_MessageContextInfo_default_instance_); + } + static constexpr int kIndexInFileMessages = + 138; + + friend void swap(MessageContextInfo& a, MessageContextInfo& b) { + a.Swap(&b); + } + inline void Swap(MessageContextInfo* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(MessageContextInfo* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + MessageContextInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const MessageContextInfo& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const MessageContextInfo& from) { + MessageContextInfo::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(MessageContextInfo* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.MessageContextInfo"; + } + protected: + explicit MessageContextInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMessageSecretFieldNumber = 3, + kPaddingBytesFieldNumber = 4, + kDeviceListMetadataFieldNumber = 1, + kDeviceListMetadataVersionFieldNumber = 2, + }; + // optional bytes messageSecret = 3; + bool has_messagesecret() const; + private: + bool _internal_has_messagesecret() const; + public: + void clear_messagesecret(); + const std::string& messagesecret() const; + template + void set_messagesecret(ArgT0&& arg0, ArgT... args); + std::string* mutable_messagesecret(); + PROTOBUF_NODISCARD std::string* release_messagesecret(); + void set_allocated_messagesecret(std::string* messagesecret); + private: + const std::string& _internal_messagesecret() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_messagesecret(const std::string& value); + std::string* _internal_mutable_messagesecret(); + public: + + // optional bytes paddingBytes = 4; + bool has_paddingbytes() const; + private: + bool _internal_has_paddingbytes() const; + public: + void clear_paddingbytes(); + const std::string& paddingbytes() const; + template + void set_paddingbytes(ArgT0&& arg0, ArgT... args); + std::string* mutable_paddingbytes(); + PROTOBUF_NODISCARD std::string* release_paddingbytes(); + void set_allocated_paddingbytes(std::string* paddingbytes); + private: + const std::string& _internal_paddingbytes() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_paddingbytes(const std::string& value); + std::string* _internal_mutable_paddingbytes(); + public: + + // optional .proto.DeviceListMetadata deviceListMetadata = 1; + bool has_devicelistmetadata() const; + private: + bool _internal_has_devicelistmetadata() const; + public: + void clear_devicelistmetadata(); + const ::proto::DeviceListMetadata& devicelistmetadata() const; + PROTOBUF_NODISCARD ::proto::DeviceListMetadata* release_devicelistmetadata(); + ::proto::DeviceListMetadata* mutable_devicelistmetadata(); + void set_allocated_devicelistmetadata(::proto::DeviceListMetadata* devicelistmetadata); + private: + const ::proto::DeviceListMetadata& _internal_devicelistmetadata() const; + ::proto::DeviceListMetadata* _internal_mutable_devicelistmetadata(); + public: + void unsafe_arena_set_allocated_devicelistmetadata( + ::proto::DeviceListMetadata* devicelistmetadata); + ::proto::DeviceListMetadata* unsafe_arena_release_devicelistmetadata(); + + // optional int32 deviceListMetadataVersion = 2; + bool has_devicelistmetadataversion() const; + private: + bool _internal_has_devicelistmetadataversion() const; + public: + void clear_devicelistmetadataversion(); + int32_t devicelistmetadataversion() const; + void set_devicelistmetadataversion(int32_t value); + private: + int32_t _internal_devicelistmetadataversion() const; + void _internal_set_devicelistmetadataversion(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.MessageContextInfo) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr messagesecret_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr paddingbytes_; + ::proto::DeviceListMetadata* devicelistmetadata_; + int32_t devicelistmetadataversion_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class MessageKey final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.MessageKey) */ { + public: + inline MessageKey() : MessageKey(nullptr) {} + ~MessageKey() override; + explicit PROTOBUF_CONSTEXPR MessageKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + MessageKey(const MessageKey& from); + MessageKey(MessageKey&& from) noexcept + : MessageKey() { + *this = ::std::move(from); + } + + inline MessageKey& operator=(const MessageKey& from) { + CopyFrom(from); + return *this; + } + inline MessageKey& operator=(MessageKey&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const MessageKey& default_instance() { + return *internal_default_instance(); + } + static inline const MessageKey* internal_default_instance() { + return reinterpret_cast( + &_MessageKey_default_instance_); + } + static constexpr int kIndexInFileMessages = + 139; + + friend void swap(MessageKey& a, MessageKey& b) { + a.Swap(&b); + } + inline void Swap(MessageKey* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(MessageKey* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + MessageKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const MessageKey& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const MessageKey& from) { + MessageKey::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(MessageKey* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.MessageKey"; + } + protected: + explicit MessageKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kRemoteJidFieldNumber = 1, + kIdFieldNumber = 3, + kParticipantFieldNumber = 4, + kFromMeFieldNumber = 2, + }; + // optional string remoteJid = 1; + bool has_remotejid() const; + private: + bool _internal_has_remotejid() const; + public: + void clear_remotejid(); + const std::string& remotejid() const; + template + void set_remotejid(ArgT0&& arg0, ArgT... args); + std::string* mutable_remotejid(); + PROTOBUF_NODISCARD std::string* release_remotejid(); + void set_allocated_remotejid(std::string* remotejid); + private: + const std::string& _internal_remotejid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_remotejid(const std::string& value); + std::string* _internal_mutable_remotejid(); + public: + + // optional string id = 3; + bool has_id() const; + private: + bool _internal_has_id() const; + public: + void clear_id(); + const std::string& id() const; + template + void set_id(ArgT0&& arg0, ArgT... args); + std::string* mutable_id(); + PROTOBUF_NODISCARD std::string* release_id(); + void set_allocated_id(std::string* id); + private: + const std::string& _internal_id() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value); + std::string* _internal_mutable_id(); + public: + + // optional string participant = 4; + bool has_participant() const; + private: + bool _internal_has_participant() const; + public: + void clear_participant(); + const std::string& participant() const; + template + void set_participant(ArgT0&& arg0, ArgT... args); + std::string* mutable_participant(); + PROTOBUF_NODISCARD std::string* release_participant(); + void set_allocated_participant(std::string* participant); + private: + const std::string& _internal_participant() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_participant(const std::string& value); + std::string* _internal_mutable_participant(); + public: + + // optional bool fromMe = 2; + bool has_fromme() const; + private: + bool _internal_has_fromme() const; + public: + void clear_fromme(); + bool fromme() const; + void set_fromme(bool value); + private: + bool _internal_fromme() const; + void _internal_set_fromme(bool value); + public: + + // @@protoc_insertion_point(class_scope:proto.MessageKey) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr remotejid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr participant_; + bool fromme_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Money final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Money) */ { + public: + inline Money() : Money(nullptr) {} + ~Money() override; + explicit PROTOBUF_CONSTEXPR Money(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Money(const Money& from); + Money(Money&& from) noexcept + : Money() { + *this = ::std::move(from); + } + + inline Money& operator=(const Money& from) { + CopyFrom(from); + return *this; + } + inline Money& operator=(Money&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Money& default_instance() { + return *internal_default_instance(); + } + static inline const Money* internal_default_instance() { + return reinterpret_cast( + &_Money_default_instance_); + } + static constexpr int kIndexInFileMessages = + 140; + + friend void swap(Money& a, Money& b) { + a.Swap(&b); + } + inline void Swap(Money* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Money* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Money* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Money& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Money& from) { + Money::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Money* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Money"; + } + protected: + explicit Money(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kCurrencyCodeFieldNumber = 3, + kValueFieldNumber = 1, + kOffsetFieldNumber = 2, + }; + // optional string currencyCode = 3; + bool has_currencycode() const; + private: + bool _internal_has_currencycode() const; + public: + void clear_currencycode(); + const std::string& currencycode() const; + template + void set_currencycode(ArgT0&& arg0, ArgT... args); + std::string* mutable_currencycode(); + PROTOBUF_NODISCARD std::string* release_currencycode(); + void set_allocated_currencycode(std::string* currencycode); + private: + const std::string& _internal_currencycode() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_currencycode(const std::string& value); + std::string* _internal_mutable_currencycode(); + public: + + // optional int64 value = 1; + bool has_value() const; + private: + bool _internal_has_value() const; + public: + void clear_value(); + int64_t value() const; + void set_value(int64_t value); + private: + int64_t _internal_value() const; + void _internal_set_value(int64_t value); + public: + + // optional uint32 offset = 2; + bool has_offset() const; + private: + bool _internal_has_offset() const; + public: + void clear_offset(); + uint32_t offset() const; + void set_offset(uint32_t value); + private: + uint32_t _internal_offset() const; + void _internal_set_offset(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.Money) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr currencycode_; + int64_t value_; + uint32_t offset_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class MsgOpaqueData_PollOption final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.MsgOpaqueData.PollOption) */ { + public: + inline MsgOpaqueData_PollOption() : MsgOpaqueData_PollOption(nullptr) {} + ~MsgOpaqueData_PollOption() override; + explicit PROTOBUF_CONSTEXPR MsgOpaqueData_PollOption(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + MsgOpaqueData_PollOption(const MsgOpaqueData_PollOption& from); + MsgOpaqueData_PollOption(MsgOpaqueData_PollOption&& from) noexcept + : MsgOpaqueData_PollOption() { + *this = ::std::move(from); + } + + inline MsgOpaqueData_PollOption& operator=(const MsgOpaqueData_PollOption& from) { + CopyFrom(from); + return *this; + } + inline MsgOpaqueData_PollOption& operator=(MsgOpaqueData_PollOption&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const MsgOpaqueData_PollOption& default_instance() { + return *internal_default_instance(); + } + static inline const MsgOpaqueData_PollOption* internal_default_instance() { + return reinterpret_cast( + &_MsgOpaqueData_PollOption_default_instance_); + } + static constexpr int kIndexInFileMessages = + 141; + + friend void swap(MsgOpaqueData_PollOption& a, MsgOpaqueData_PollOption& b) { + a.Swap(&b); + } + inline void Swap(MsgOpaqueData_PollOption* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(MsgOpaqueData_PollOption* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + MsgOpaqueData_PollOption* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const MsgOpaqueData_PollOption& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const MsgOpaqueData_PollOption& from) { + MsgOpaqueData_PollOption::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(MsgOpaqueData_PollOption* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.MsgOpaqueData.PollOption"; + } + protected: + explicit MsgOpaqueData_PollOption(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNameFieldNumber = 1, + }; + // optional string name = 1; + bool has_name() const; + private: + bool _internal_has_name() const; + public: + void clear_name(); + const std::string& name() const; + template + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + PROTOBUF_NODISCARD std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // @@protoc_insertion_point(class_scope:proto.MsgOpaqueData.PollOption) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class MsgOpaqueData final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.MsgOpaqueData) */ { + public: + inline MsgOpaqueData() : MsgOpaqueData(nullptr) {} + ~MsgOpaqueData() override; + explicit PROTOBUF_CONSTEXPR MsgOpaqueData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + MsgOpaqueData(const MsgOpaqueData& from); + MsgOpaqueData(MsgOpaqueData&& from) noexcept + : MsgOpaqueData() { + *this = ::std::move(from); + } + + inline MsgOpaqueData& operator=(const MsgOpaqueData& from) { + CopyFrom(from); + return *this; + } + inline MsgOpaqueData& operator=(MsgOpaqueData&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const MsgOpaqueData& default_instance() { + return *internal_default_instance(); + } + static inline const MsgOpaqueData* internal_default_instance() { + return reinterpret_cast( + &_MsgOpaqueData_default_instance_); + } + static constexpr int kIndexInFileMessages = + 142; + + friend void swap(MsgOpaqueData& a, MsgOpaqueData& b) { + a.Swap(&b); + } + inline void Swap(MsgOpaqueData* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(MsgOpaqueData* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + MsgOpaqueData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const MsgOpaqueData& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const MsgOpaqueData& from) { + MsgOpaqueData::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(MsgOpaqueData* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.MsgOpaqueData"; + } + protected: + explicit MsgOpaqueData(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef MsgOpaqueData_PollOption PollOption; + + // accessors ------------------------------------------------------- + + enum : int { + kPollOptionsFieldNumber = 18, + kBodyFieldNumber = 1, + kCaptionFieldNumber = 3, + kPaymentNoteMsgBodyFieldNumber = 9, + kCanonicalUrlFieldNumber = 10, + kMatchedTextFieldNumber = 11, + kTitleFieldNumber = 12, + kDescriptionFieldNumber = 13, + kFutureproofBufferFieldNumber = 14, + kClientUrlFieldNumber = 15, + kLocFieldNumber = 16, + kPollNameFieldNumber = 17, + kMessageSecretFieldNumber = 21, + kPollUpdateParentKeyFieldNumber = 23, + kEncPollVoteFieldNumber = 24, + kLngFieldNumber = 5, + kLatFieldNumber = 7, + kIsLiveFieldNumber = 6, + kPaymentAmount1000FieldNumber = 8, + kSenderTimestampMsFieldNumber = 22, + kPollSelectableOptionsCountFieldNumber = 20, + }; + // repeated .proto.MsgOpaqueData.PollOption pollOptions = 18; + int polloptions_size() const; + private: + int _internal_polloptions_size() const; + public: + void clear_polloptions(); + ::proto::MsgOpaqueData_PollOption* mutable_polloptions(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MsgOpaqueData_PollOption >* + mutable_polloptions(); + private: + const ::proto::MsgOpaqueData_PollOption& _internal_polloptions(int index) const; + ::proto::MsgOpaqueData_PollOption* _internal_add_polloptions(); + public: + const ::proto::MsgOpaqueData_PollOption& polloptions(int index) const; + ::proto::MsgOpaqueData_PollOption* add_polloptions(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MsgOpaqueData_PollOption >& + polloptions() const; + + // optional string body = 1; + bool has_body() const; + private: + bool _internal_has_body() const; + public: + void clear_body(); + const std::string& body() const; + template + void set_body(ArgT0&& arg0, ArgT... args); + std::string* mutable_body(); + PROTOBUF_NODISCARD std::string* release_body(); + void set_allocated_body(std::string* body); + private: + const std::string& _internal_body() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_body(const std::string& value); + std::string* _internal_mutable_body(); + public: + + // optional string caption = 3; + bool has_caption() const; + private: + bool _internal_has_caption() const; + public: + void clear_caption(); + const std::string& caption() const; + template + void set_caption(ArgT0&& arg0, ArgT... args); + std::string* mutable_caption(); + PROTOBUF_NODISCARD std::string* release_caption(); + void set_allocated_caption(std::string* caption); + private: + const std::string& _internal_caption() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_caption(const std::string& value); + std::string* _internal_mutable_caption(); + public: + + // optional string paymentNoteMsgBody = 9; + bool has_paymentnotemsgbody() const; + private: + bool _internal_has_paymentnotemsgbody() const; + public: + void clear_paymentnotemsgbody(); + const std::string& paymentnotemsgbody() const; + template + void set_paymentnotemsgbody(ArgT0&& arg0, ArgT... args); + std::string* mutable_paymentnotemsgbody(); + PROTOBUF_NODISCARD std::string* release_paymentnotemsgbody(); + void set_allocated_paymentnotemsgbody(std::string* paymentnotemsgbody); + private: + const std::string& _internal_paymentnotemsgbody() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_paymentnotemsgbody(const std::string& value); + std::string* _internal_mutable_paymentnotemsgbody(); + public: + + // optional string canonicalUrl = 10; + bool has_canonicalurl() const; + private: + bool _internal_has_canonicalurl() const; + public: + void clear_canonicalurl(); + const std::string& canonicalurl() const; + template + void set_canonicalurl(ArgT0&& arg0, ArgT... args); + std::string* mutable_canonicalurl(); + PROTOBUF_NODISCARD std::string* release_canonicalurl(); + void set_allocated_canonicalurl(std::string* canonicalurl); + private: + const std::string& _internal_canonicalurl() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_canonicalurl(const std::string& value); + std::string* _internal_mutable_canonicalurl(); + public: + + // optional string matchedText = 11; + bool has_matchedtext() const; + private: + bool _internal_has_matchedtext() const; + public: + void clear_matchedtext(); + const std::string& matchedtext() const; + template + void set_matchedtext(ArgT0&& arg0, ArgT... args); + std::string* mutable_matchedtext(); + PROTOBUF_NODISCARD std::string* release_matchedtext(); + void set_allocated_matchedtext(std::string* matchedtext); + private: + const std::string& _internal_matchedtext() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_matchedtext(const std::string& value); + std::string* _internal_mutable_matchedtext(); + public: + + // optional string title = 12; + bool has_title() const; + private: + bool _internal_has_title() const; + public: + void clear_title(); + const std::string& title() const; + template + void set_title(ArgT0&& arg0, ArgT... args); + std::string* mutable_title(); + PROTOBUF_NODISCARD std::string* release_title(); + void set_allocated_title(std::string* title); + private: + const std::string& _internal_title() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value); + std::string* _internal_mutable_title(); + public: + + // optional string description = 13; + bool has_description() const; + private: + bool _internal_has_description() const; + public: + void clear_description(); + const std::string& description() const; + template + void set_description(ArgT0&& arg0, ArgT... args); + std::string* mutable_description(); + PROTOBUF_NODISCARD std::string* release_description(); + void set_allocated_description(std::string* description); + private: + const std::string& _internal_description() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value); + std::string* _internal_mutable_description(); + public: + + // optional bytes futureproofBuffer = 14; + bool has_futureproofbuffer() const; + private: + bool _internal_has_futureproofbuffer() const; + public: + void clear_futureproofbuffer(); + const std::string& futureproofbuffer() const; + template + void set_futureproofbuffer(ArgT0&& arg0, ArgT... args); + std::string* mutable_futureproofbuffer(); + PROTOBUF_NODISCARD std::string* release_futureproofbuffer(); + void set_allocated_futureproofbuffer(std::string* futureproofbuffer); + private: + const std::string& _internal_futureproofbuffer() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_futureproofbuffer(const std::string& value); + std::string* _internal_mutable_futureproofbuffer(); + public: + + // optional string clientUrl = 15; + bool has_clienturl() const; + private: + bool _internal_has_clienturl() const; + public: + void clear_clienturl(); + const std::string& clienturl() const; + template + void set_clienturl(ArgT0&& arg0, ArgT... args); + std::string* mutable_clienturl(); + PROTOBUF_NODISCARD std::string* release_clienturl(); + void set_allocated_clienturl(std::string* clienturl); + private: + const std::string& _internal_clienturl() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_clienturl(const std::string& value); + std::string* _internal_mutable_clienturl(); + public: + + // optional string loc = 16; + bool has_loc() const; + private: + bool _internal_has_loc() const; + public: + void clear_loc(); + const std::string& loc() const; + template + void set_loc(ArgT0&& arg0, ArgT... args); + std::string* mutable_loc(); + PROTOBUF_NODISCARD std::string* release_loc(); + void set_allocated_loc(std::string* loc); + private: + const std::string& _internal_loc() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_loc(const std::string& value); + std::string* _internal_mutable_loc(); + public: + + // optional string pollName = 17; + bool has_pollname() const; + private: + bool _internal_has_pollname() const; + public: + void clear_pollname(); + const std::string& pollname() const; + template + void set_pollname(ArgT0&& arg0, ArgT... args); + std::string* mutable_pollname(); + PROTOBUF_NODISCARD std::string* release_pollname(); + void set_allocated_pollname(std::string* pollname); + private: + const std::string& _internal_pollname() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_pollname(const std::string& value); + std::string* _internal_mutable_pollname(); + public: + + // optional bytes messageSecret = 21; + bool has_messagesecret() const; + private: + bool _internal_has_messagesecret() const; + public: + void clear_messagesecret(); + const std::string& messagesecret() const; + template + void set_messagesecret(ArgT0&& arg0, ArgT... args); + std::string* mutable_messagesecret(); + PROTOBUF_NODISCARD std::string* release_messagesecret(); + void set_allocated_messagesecret(std::string* messagesecret); + private: + const std::string& _internal_messagesecret() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_messagesecret(const std::string& value); + std::string* _internal_mutable_messagesecret(); + public: + + // optional string pollUpdateParentKey = 23; + bool has_pollupdateparentkey() const; + private: + bool _internal_has_pollupdateparentkey() const; + public: + void clear_pollupdateparentkey(); + const std::string& pollupdateparentkey() const; + template + void set_pollupdateparentkey(ArgT0&& arg0, ArgT... args); + std::string* mutable_pollupdateparentkey(); + PROTOBUF_NODISCARD std::string* release_pollupdateparentkey(); + void set_allocated_pollupdateparentkey(std::string* pollupdateparentkey); + private: + const std::string& _internal_pollupdateparentkey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_pollupdateparentkey(const std::string& value); + std::string* _internal_mutable_pollupdateparentkey(); + public: + + // optional .proto.PollEncValue encPollVote = 24; + bool has_encpollvote() const; + private: + bool _internal_has_encpollvote() const; + public: + void clear_encpollvote(); + const ::proto::PollEncValue& encpollvote() const; + PROTOBUF_NODISCARD ::proto::PollEncValue* release_encpollvote(); + ::proto::PollEncValue* mutable_encpollvote(); + void set_allocated_encpollvote(::proto::PollEncValue* encpollvote); + private: + const ::proto::PollEncValue& _internal_encpollvote() const; + ::proto::PollEncValue* _internal_mutable_encpollvote(); + public: + void unsafe_arena_set_allocated_encpollvote( + ::proto::PollEncValue* encpollvote); + ::proto::PollEncValue* unsafe_arena_release_encpollvote(); + + // optional double lng = 5; + bool has_lng() const; + private: + bool _internal_has_lng() const; + public: + void clear_lng(); + double lng() const; + void set_lng(double value); + private: + double _internal_lng() const; + void _internal_set_lng(double value); + public: + + // optional double lat = 7; + bool has_lat() const; + private: + bool _internal_has_lat() const; + public: + void clear_lat(); + double lat() const; + void set_lat(double value); + private: + double _internal_lat() const; + void _internal_set_lat(double value); + public: + + // optional bool isLive = 6; + bool has_islive() const; + private: + bool _internal_has_islive() const; + public: + void clear_islive(); + bool islive() const; + void set_islive(bool value); + private: + bool _internal_islive() const; + void _internal_set_islive(bool value); + public: + + // optional int32 paymentAmount1000 = 8; + bool has_paymentamount1000() const; + private: + bool _internal_has_paymentamount1000() const; + public: + void clear_paymentamount1000(); + int32_t paymentamount1000() const; + void set_paymentamount1000(int32_t value); + private: + int32_t _internal_paymentamount1000() const; + void _internal_set_paymentamount1000(int32_t value); + public: + + // optional int64 senderTimestampMs = 22; + bool has_sendertimestampms() const; + private: + bool _internal_has_sendertimestampms() const; + public: + void clear_sendertimestampms(); + int64_t sendertimestampms() const; + void set_sendertimestampms(int64_t value); + private: + int64_t _internal_sendertimestampms() const; + void _internal_set_sendertimestampms(int64_t value); + public: + + // optional uint32 pollSelectableOptionsCount = 20; + bool has_pollselectableoptionscount() const; + private: + bool _internal_has_pollselectableoptionscount() const; + public: + void clear_pollselectableoptionscount(); + uint32_t pollselectableoptionscount() const; + void set_pollselectableoptionscount(uint32_t value); + private: + uint32_t _internal_pollselectableoptionscount() const; + void _internal_set_pollselectableoptionscount(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.MsgOpaqueData) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MsgOpaqueData_PollOption > polloptions_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr body_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr caption_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr paymentnotemsgbody_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr canonicalurl_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr matchedtext_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr futureproofbuffer_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr clienturl_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr loc_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pollname_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr messagesecret_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pollupdateparentkey_; + ::proto::PollEncValue* encpollvote_; + double lng_; + double lat_; + bool islive_; + int32_t paymentamount1000_; + int64_t sendertimestampms_; + uint32_t pollselectableoptionscount_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class MsgRowOpaqueData final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.MsgRowOpaqueData) */ { + public: + inline MsgRowOpaqueData() : MsgRowOpaqueData(nullptr) {} + ~MsgRowOpaqueData() override; + explicit PROTOBUF_CONSTEXPR MsgRowOpaqueData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + MsgRowOpaqueData(const MsgRowOpaqueData& from); + MsgRowOpaqueData(MsgRowOpaqueData&& from) noexcept + : MsgRowOpaqueData() { + *this = ::std::move(from); + } + + inline MsgRowOpaqueData& operator=(const MsgRowOpaqueData& from) { + CopyFrom(from); + return *this; + } + inline MsgRowOpaqueData& operator=(MsgRowOpaqueData&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const MsgRowOpaqueData& default_instance() { + return *internal_default_instance(); + } + static inline const MsgRowOpaqueData* internal_default_instance() { + return reinterpret_cast( + &_MsgRowOpaqueData_default_instance_); + } + static constexpr int kIndexInFileMessages = + 143; + + friend void swap(MsgRowOpaqueData& a, MsgRowOpaqueData& b) { + a.Swap(&b); + } + inline void Swap(MsgRowOpaqueData* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(MsgRowOpaqueData* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + MsgRowOpaqueData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const MsgRowOpaqueData& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const MsgRowOpaqueData& from) { + MsgRowOpaqueData::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(MsgRowOpaqueData* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.MsgRowOpaqueData"; + } + protected: + explicit MsgRowOpaqueData(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kCurrentMsgFieldNumber = 1, + kQuotedMsgFieldNumber = 2, + }; + // optional .proto.MsgOpaqueData currentMsg = 1; + bool has_currentmsg() const; + private: + bool _internal_has_currentmsg() const; + public: + void clear_currentmsg(); + const ::proto::MsgOpaqueData& currentmsg() const; + PROTOBUF_NODISCARD ::proto::MsgOpaqueData* release_currentmsg(); + ::proto::MsgOpaqueData* mutable_currentmsg(); + void set_allocated_currentmsg(::proto::MsgOpaqueData* currentmsg); + private: + const ::proto::MsgOpaqueData& _internal_currentmsg() const; + ::proto::MsgOpaqueData* _internal_mutable_currentmsg(); + public: + void unsafe_arena_set_allocated_currentmsg( + ::proto::MsgOpaqueData* currentmsg); + ::proto::MsgOpaqueData* unsafe_arena_release_currentmsg(); + + // optional .proto.MsgOpaqueData quotedMsg = 2; + bool has_quotedmsg() const; + private: + bool _internal_has_quotedmsg() const; + public: + void clear_quotedmsg(); + const ::proto::MsgOpaqueData& quotedmsg() const; + PROTOBUF_NODISCARD ::proto::MsgOpaqueData* release_quotedmsg(); + ::proto::MsgOpaqueData* mutable_quotedmsg(); + void set_allocated_quotedmsg(::proto::MsgOpaqueData* quotedmsg); + private: + const ::proto::MsgOpaqueData& _internal_quotedmsg() const; + ::proto::MsgOpaqueData* _internal_mutable_quotedmsg(); + public: + void unsafe_arena_set_allocated_quotedmsg( + ::proto::MsgOpaqueData* quotedmsg); + ::proto::MsgOpaqueData* unsafe_arena_release_quotedmsg(); + + // @@protoc_insertion_point(class_scope:proto.MsgRowOpaqueData) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::proto::MsgOpaqueData* currentmsg_; + ::proto::MsgOpaqueData* quotedmsg_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class NoiseCertificate_Details final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.NoiseCertificate.Details) */ { + public: + inline NoiseCertificate_Details() : NoiseCertificate_Details(nullptr) {} + ~NoiseCertificate_Details() override; + explicit PROTOBUF_CONSTEXPR NoiseCertificate_Details(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + NoiseCertificate_Details(const NoiseCertificate_Details& from); + NoiseCertificate_Details(NoiseCertificate_Details&& from) noexcept + : NoiseCertificate_Details() { + *this = ::std::move(from); + } + + inline NoiseCertificate_Details& operator=(const NoiseCertificate_Details& from) { + CopyFrom(from); + return *this; + } + inline NoiseCertificate_Details& operator=(NoiseCertificate_Details&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const NoiseCertificate_Details& default_instance() { + return *internal_default_instance(); + } + static inline const NoiseCertificate_Details* internal_default_instance() { + return reinterpret_cast( + &_NoiseCertificate_Details_default_instance_); + } + static constexpr int kIndexInFileMessages = + 144; + + friend void swap(NoiseCertificate_Details& a, NoiseCertificate_Details& b) { + a.Swap(&b); + } + inline void Swap(NoiseCertificate_Details* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(NoiseCertificate_Details* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + NoiseCertificate_Details* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const NoiseCertificate_Details& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const NoiseCertificate_Details& from) { + NoiseCertificate_Details::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(NoiseCertificate_Details* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.NoiseCertificate.Details"; + } + protected: + explicit NoiseCertificate_Details(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kIssuerFieldNumber = 2, + kSubjectFieldNumber = 4, + kKeyFieldNumber = 5, + kExpiresFieldNumber = 3, + kSerialFieldNumber = 1, + }; + // optional string issuer = 2; + bool has_issuer() const; + private: + bool _internal_has_issuer() const; + public: + void clear_issuer(); + const std::string& issuer() const; + template + void set_issuer(ArgT0&& arg0, ArgT... args); + std::string* mutable_issuer(); + PROTOBUF_NODISCARD std::string* release_issuer(); + void set_allocated_issuer(std::string* issuer); + private: + const std::string& _internal_issuer() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_issuer(const std::string& value); + std::string* _internal_mutable_issuer(); + public: + + // optional string subject = 4; + bool has_subject() const; + private: + bool _internal_has_subject() const; + public: + void clear_subject(); + const std::string& subject() const; + template + void set_subject(ArgT0&& arg0, ArgT... args); + std::string* mutable_subject(); + PROTOBUF_NODISCARD std::string* release_subject(); + void set_allocated_subject(std::string* subject); + private: + const std::string& _internal_subject() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_subject(const std::string& value); + std::string* _internal_mutable_subject(); + public: + + // optional bytes key = 5; + bool has_key() const; + private: + bool _internal_has_key() const; + public: + void clear_key(); + const std::string& key() const; + template + void set_key(ArgT0&& arg0, ArgT... args); + std::string* mutable_key(); + PROTOBUF_NODISCARD std::string* release_key(); + void set_allocated_key(std::string* key); + private: + const std::string& _internal_key() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value); + std::string* _internal_mutable_key(); + public: + + // optional uint64 expires = 3; + bool has_expires() const; + private: + bool _internal_has_expires() const; + public: + void clear_expires(); + uint64_t expires() const; + void set_expires(uint64_t value); + private: + uint64_t _internal_expires() const; + void _internal_set_expires(uint64_t value); + public: + + // optional uint32 serial = 1; + bool has_serial() const; + private: + bool _internal_has_serial() const; + public: + void clear_serial(); + uint32_t serial() const; + void set_serial(uint32_t value); + private: + uint32_t _internal_serial() const; + void _internal_set_serial(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.NoiseCertificate.Details) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr issuer_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr subject_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_; + uint64_t expires_; + uint32_t serial_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class NoiseCertificate final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.NoiseCertificate) */ { + public: + inline NoiseCertificate() : NoiseCertificate(nullptr) {} + ~NoiseCertificate() override; + explicit PROTOBUF_CONSTEXPR NoiseCertificate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + NoiseCertificate(const NoiseCertificate& from); + NoiseCertificate(NoiseCertificate&& from) noexcept + : NoiseCertificate() { + *this = ::std::move(from); + } + + inline NoiseCertificate& operator=(const NoiseCertificate& from) { + CopyFrom(from); + return *this; + } + inline NoiseCertificate& operator=(NoiseCertificate&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const NoiseCertificate& default_instance() { + return *internal_default_instance(); + } + static inline const NoiseCertificate* internal_default_instance() { + return reinterpret_cast( + &_NoiseCertificate_default_instance_); + } + static constexpr int kIndexInFileMessages = + 145; + + friend void swap(NoiseCertificate& a, NoiseCertificate& b) { + a.Swap(&b); + } + inline void Swap(NoiseCertificate* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(NoiseCertificate* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + NoiseCertificate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const NoiseCertificate& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const NoiseCertificate& from) { + NoiseCertificate::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(NoiseCertificate* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.NoiseCertificate"; + } + protected: + explicit NoiseCertificate(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef NoiseCertificate_Details Details; + + // accessors ------------------------------------------------------- + + enum : int { + kDetailsFieldNumber = 1, + kSignatureFieldNumber = 2, + }; + // optional bytes details = 1; + bool has_details() const; + private: + bool _internal_has_details() const; + public: + void clear_details(); + const std::string& details() const; + template + void set_details(ArgT0&& arg0, ArgT... args); + std::string* mutable_details(); + PROTOBUF_NODISCARD std::string* release_details(); + void set_allocated_details(std::string* details); + private: + const std::string& _internal_details() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_details(const std::string& value); + std::string* _internal_mutable_details(); + public: + + // optional bytes signature = 2; + bool has_signature() const; + private: + bool _internal_has_signature() const; + public: + void clear_signature(); + const std::string& signature() const; + template + void set_signature(ArgT0&& arg0, ArgT... args); + std::string* mutable_signature(); + PROTOBUF_NODISCARD std::string* release_signature(); + void set_allocated_signature(std::string* signature); + private: + const std::string& _internal_signature() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value); + std::string* _internal_mutable_signature(); + public: + + // @@protoc_insertion_point(class_scope:proto.NoiseCertificate) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr details_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class NotificationMessageInfo final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.NotificationMessageInfo) */ { + public: + inline NotificationMessageInfo() : NotificationMessageInfo(nullptr) {} + ~NotificationMessageInfo() override; + explicit PROTOBUF_CONSTEXPR NotificationMessageInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + NotificationMessageInfo(const NotificationMessageInfo& from); + NotificationMessageInfo(NotificationMessageInfo&& from) noexcept + : NotificationMessageInfo() { + *this = ::std::move(from); + } + + inline NotificationMessageInfo& operator=(const NotificationMessageInfo& from) { + CopyFrom(from); + return *this; + } + inline NotificationMessageInfo& operator=(NotificationMessageInfo&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const NotificationMessageInfo& default_instance() { + return *internal_default_instance(); + } + static inline const NotificationMessageInfo* internal_default_instance() { + return reinterpret_cast( + &_NotificationMessageInfo_default_instance_); + } + static constexpr int kIndexInFileMessages = + 146; + + friend void swap(NotificationMessageInfo& a, NotificationMessageInfo& b) { + a.Swap(&b); + } + inline void Swap(NotificationMessageInfo* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(NotificationMessageInfo* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + NotificationMessageInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const NotificationMessageInfo& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const NotificationMessageInfo& from) { + NotificationMessageInfo::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(NotificationMessageInfo* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.NotificationMessageInfo"; + } + protected: + explicit NotificationMessageInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kParticipantFieldNumber = 4, + kKeyFieldNumber = 1, + kMessageFieldNumber = 2, + kMessageTimestampFieldNumber = 3, + }; + // optional string participant = 4; + bool has_participant() const; + private: + bool _internal_has_participant() const; + public: + void clear_participant(); + const std::string& participant() const; + template + void set_participant(ArgT0&& arg0, ArgT... args); + std::string* mutable_participant(); + PROTOBUF_NODISCARD std::string* release_participant(); + void set_allocated_participant(std::string* participant); + private: + const std::string& _internal_participant() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_participant(const std::string& value); + std::string* _internal_mutable_participant(); + public: + + // optional .proto.MessageKey key = 1; + bool has_key() const; + private: + bool _internal_has_key() const; + public: + void clear_key(); + const ::proto::MessageKey& key() const; + PROTOBUF_NODISCARD ::proto::MessageKey* release_key(); + ::proto::MessageKey* mutable_key(); + void set_allocated_key(::proto::MessageKey* key); + private: + const ::proto::MessageKey& _internal_key() const; + ::proto::MessageKey* _internal_mutable_key(); + public: + void unsafe_arena_set_allocated_key( + ::proto::MessageKey* key); + ::proto::MessageKey* unsafe_arena_release_key(); + + // optional .proto.Message message = 2; + bool has_message() const; + private: + bool _internal_has_message() const; + public: + void clear_message(); + const ::proto::Message& message() const; + PROTOBUF_NODISCARD ::proto::Message* release_message(); + ::proto::Message* mutable_message(); + void set_allocated_message(::proto::Message* message); + private: + const ::proto::Message& _internal_message() const; + ::proto::Message* _internal_mutable_message(); + public: + void unsafe_arena_set_allocated_message( + ::proto::Message* message); + ::proto::Message* unsafe_arena_release_message(); + + // optional uint64 messageTimestamp = 3; + bool has_messagetimestamp() const; + private: + bool _internal_has_messagetimestamp() const; + public: + void clear_messagetimestamp(); + uint64_t messagetimestamp() const; + void set_messagetimestamp(uint64_t value); + private: + uint64_t _internal_messagetimestamp() const; + void _internal_set_messagetimestamp(uint64_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.NotificationMessageInfo) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr participant_; + ::proto::MessageKey* key_; + ::proto::Message* message_; + uint64_t messagetimestamp_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class PastParticipant final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PastParticipant) */ { + public: + inline PastParticipant() : PastParticipant(nullptr) {} + ~PastParticipant() override; + explicit PROTOBUF_CONSTEXPR PastParticipant(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PastParticipant(const PastParticipant& from); + PastParticipant(PastParticipant&& from) noexcept + : PastParticipant() { + *this = ::std::move(from); + } + + inline PastParticipant& operator=(const PastParticipant& from) { + CopyFrom(from); + return *this; + } + inline PastParticipant& operator=(PastParticipant&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const PastParticipant& default_instance() { + return *internal_default_instance(); + } + static inline const PastParticipant* internal_default_instance() { + return reinterpret_cast( + &_PastParticipant_default_instance_); + } + static constexpr int kIndexInFileMessages = + 147; + + friend void swap(PastParticipant& a, PastParticipant& b) { + a.Swap(&b); + } + inline void Swap(PastParticipant* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PastParticipant* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PastParticipant* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const PastParticipant& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const PastParticipant& from) { + PastParticipant::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PastParticipant* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.PastParticipant"; + } + protected: + explicit PastParticipant(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef PastParticipant_LeaveReason LeaveReason; + static constexpr LeaveReason LEFT = + PastParticipant_LeaveReason_LEFT; + static constexpr LeaveReason REMOVED = + PastParticipant_LeaveReason_REMOVED; + static inline bool LeaveReason_IsValid(int value) { + return PastParticipant_LeaveReason_IsValid(value); + } + static constexpr LeaveReason LeaveReason_MIN = + PastParticipant_LeaveReason_LeaveReason_MIN; + static constexpr LeaveReason LeaveReason_MAX = + PastParticipant_LeaveReason_LeaveReason_MAX; + static constexpr int LeaveReason_ARRAYSIZE = + PastParticipant_LeaveReason_LeaveReason_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + LeaveReason_descriptor() { + return PastParticipant_LeaveReason_descriptor(); + } + template + static inline const std::string& LeaveReason_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function LeaveReason_Name."); + return PastParticipant_LeaveReason_Name(enum_t_value); + } + static inline bool LeaveReason_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + LeaveReason* value) { + return PastParticipant_LeaveReason_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kUserJidFieldNumber = 1, + kLeaveTsFieldNumber = 3, + kLeaveReasonFieldNumber = 2, + }; + // required string userJid = 1; + bool has_userjid() const; + private: + bool _internal_has_userjid() const; + public: + void clear_userjid(); + const std::string& userjid() const; + template + void set_userjid(ArgT0&& arg0, ArgT... args); + std::string* mutable_userjid(); + PROTOBUF_NODISCARD std::string* release_userjid(); + void set_allocated_userjid(std::string* userjid); + private: + const std::string& _internal_userjid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_userjid(const std::string& value); + std::string* _internal_mutable_userjid(); + public: + + // required uint64 leaveTs = 3; + bool has_leavets() const; + private: + bool _internal_has_leavets() const; + public: + void clear_leavets(); + uint64_t leavets() const; + void set_leavets(uint64_t value); + private: + uint64_t _internal_leavets() const; + void _internal_set_leavets(uint64_t value); + public: + + // required .proto.PastParticipant.LeaveReason leaveReason = 2; + bool has_leavereason() const; + private: + bool _internal_has_leavereason() const; + public: + void clear_leavereason(); + ::proto::PastParticipant_LeaveReason leavereason() const; + void set_leavereason(::proto::PastParticipant_LeaveReason value); + private: + ::proto::PastParticipant_LeaveReason _internal_leavereason() const; + void _internal_set_leavereason(::proto::PastParticipant_LeaveReason value); + public: + + // @@protoc_insertion_point(class_scope:proto.PastParticipant) + private: + class _Internal; + + // helper for ByteSizeLong() + size_t RequiredFieldsByteSizeFallback() const; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userjid_; + uint64_t leavets_; + int leavereason_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class PastParticipants final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PastParticipants) */ { + public: + inline PastParticipants() : PastParticipants(nullptr) {} + ~PastParticipants() override; + explicit PROTOBUF_CONSTEXPR PastParticipants(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PastParticipants(const PastParticipants& from); + PastParticipants(PastParticipants&& from) noexcept + : PastParticipants() { + *this = ::std::move(from); + } + + inline PastParticipants& operator=(const PastParticipants& from) { + CopyFrom(from); + return *this; + } + inline PastParticipants& operator=(PastParticipants&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const PastParticipants& default_instance() { + return *internal_default_instance(); + } + static inline const PastParticipants* internal_default_instance() { + return reinterpret_cast( + &_PastParticipants_default_instance_); + } + static constexpr int kIndexInFileMessages = + 148; + + friend void swap(PastParticipants& a, PastParticipants& b) { + a.Swap(&b); + } + inline void Swap(PastParticipants* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PastParticipants* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PastParticipants* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const PastParticipants& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const PastParticipants& from) { + PastParticipants::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PastParticipants* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.PastParticipants"; + } + protected: + explicit PastParticipants(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kPastParticipantsFieldNumber = 2, + kGroupJidFieldNumber = 1, + }; + // repeated .proto.PastParticipant pastParticipants = 2; + int pastparticipants_size() const; + private: + int _internal_pastparticipants_size() const; + public: + void clear_pastparticipants(); + ::proto::PastParticipant* mutable_pastparticipants(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipant >* + mutable_pastparticipants(); + private: + const ::proto::PastParticipant& _internal_pastparticipants(int index) const; + ::proto::PastParticipant* _internal_add_pastparticipants(); + public: + const ::proto::PastParticipant& pastparticipants(int index) const; + ::proto::PastParticipant* add_pastparticipants(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipant >& + pastparticipants() const; + + // required string groupJid = 1; + bool has_groupjid() const; + private: + bool _internal_has_groupjid() const; + public: + void clear_groupjid(); + const std::string& groupjid() const; + template + void set_groupjid(ArgT0&& arg0, ArgT... args); + std::string* mutable_groupjid(); + PROTOBUF_NODISCARD std::string* release_groupjid(); + void set_allocated_groupjid(std::string* groupjid); + private: + const std::string& _internal_groupjid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_groupjid(const std::string& value); + std::string* _internal_mutable_groupjid(); + public: + + // @@protoc_insertion_point(class_scope:proto.PastParticipants) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipant > pastparticipants_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr groupjid_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class PaymentBackground_MediaData final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PaymentBackground.MediaData) */ { + public: + inline PaymentBackground_MediaData() : PaymentBackground_MediaData(nullptr) {} + ~PaymentBackground_MediaData() override; + explicit PROTOBUF_CONSTEXPR PaymentBackground_MediaData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PaymentBackground_MediaData(const PaymentBackground_MediaData& from); + PaymentBackground_MediaData(PaymentBackground_MediaData&& from) noexcept + : PaymentBackground_MediaData() { + *this = ::std::move(from); + } + + inline PaymentBackground_MediaData& operator=(const PaymentBackground_MediaData& from) { + CopyFrom(from); + return *this; + } + inline PaymentBackground_MediaData& operator=(PaymentBackground_MediaData&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const PaymentBackground_MediaData& default_instance() { + return *internal_default_instance(); + } + static inline const PaymentBackground_MediaData* internal_default_instance() { + return reinterpret_cast( + &_PaymentBackground_MediaData_default_instance_); + } + static constexpr int kIndexInFileMessages = + 149; + + friend void swap(PaymentBackground_MediaData& a, PaymentBackground_MediaData& b) { + a.Swap(&b); + } + inline void Swap(PaymentBackground_MediaData* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PaymentBackground_MediaData* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PaymentBackground_MediaData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const PaymentBackground_MediaData& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const PaymentBackground_MediaData& from) { + PaymentBackground_MediaData::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PaymentBackground_MediaData* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.PaymentBackground.MediaData"; + } + protected: + explicit PaymentBackground_MediaData(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMediaKeyFieldNumber = 1, + kFileSha256FieldNumber = 3, + kFileEncSha256FieldNumber = 4, + kDirectPathFieldNumber = 5, + kMediaKeyTimestampFieldNumber = 2, + }; + // optional bytes mediaKey = 1; + bool has_mediakey() const; + private: + bool _internal_has_mediakey() const; + public: + void clear_mediakey(); + const std::string& mediakey() const; + template + void set_mediakey(ArgT0&& arg0, ArgT... args); + std::string* mutable_mediakey(); + PROTOBUF_NODISCARD std::string* release_mediakey(); + void set_allocated_mediakey(std::string* mediakey); + private: + const std::string& _internal_mediakey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value); + std::string* _internal_mutable_mediakey(); + public: + + // optional bytes fileSha256 = 3; + bool has_filesha256() const; + private: + bool _internal_has_filesha256() const; + public: + void clear_filesha256(); + const std::string& filesha256() const; + template + void set_filesha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_filesha256(); + PROTOBUF_NODISCARD std::string* release_filesha256(); + void set_allocated_filesha256(std::string* filesha256); + private: + const std::string& _internal_filesha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value); + std::string* _internal_mutable_filesha256(); + public: + + // optional bytes fileEncSha256 = 4; + bool has_fileencsha256() const; + private: + bool _internal_has_fileencsha256() const; + public: + void clear_fileencsha256(); + const std::string& fileencsha256() const; + template + void set_fileencsha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_fileencsha256(); + PROTOBUF_NODISCARD std::string* release_fileencsha256(); + void set_allocated_fileencsha256(std::string* fileencsha256); + private: + const std::string& _internal_fileencsha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value); + std::string* _internal_mutable_fileencsha256(); + public: + + // optional string directPath = 5; + bool has_directpath() const; + private: + bool _internal_has_directpath() const; + public: + void clear_directpath(); + const std::string& directpath() const; + template + void set_directpath(ArgT0&& arg0, ArgT... args); + std::string* mutable_directpath(); + PROTOBUF_NODISCARD std::string* release_directpath(); + void set_allocated_directpath(std::string* directpath); + private: + const std::string& _internal_directpath() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value); + std::string* _internal_mutable_directpath(); + public: + + // optional int64 mediaKeyTimestamp = 2; + bool has_mediakeytimestamp() const; + private: + bool _internal_has_mediakeytimestamp() const; + public: + void clear_mediakeytimestamp(); + int64_t mediakeytimestamp() const; + void set_mediakeytimestamp(int64_t value); + private: + int64_t _internal_mediakeytimestamp() const; + void _internal_set_mediakeytimestamp(int64_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.PaymentBackground.MediaData) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_; + int64_t mediakeytimestamp_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class PaymentBackground final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PaymentBackground) */ { + public: + inline PaymentBackground() : PaymentBackground(nullptr) {} + ~PaymentBackground() override; + explicit PROTOBUF_CONSTEXPR PaymentBackground(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PaymentBackground(const PaymentBackground& from); + PaymentBackground(PaymentBackground&& from) noexcept + : PaymentBackground() { + *this = ::std::move(from); + } + + inline PaymentBackground& operator=(const PaymentBackground& from) { + CopyFrom(from); + return *this; + } + inline PaymentBackground& operator=(PaymentBackground&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const PaymentBackground& default_instance() { + return *internal_default_instance(); + } + static inline const PaymentBackground* internal_default_instance() { + return reinterpret_cast( + &_PaymentBackground_default_instance_); + } + static constexpr int kIndexInFileMessages = + 150; + + friend void swap(PaymentBackground& a, PaymentBackground& b) { + a.Swap(&b); + } + inline void Swap(PaymentBackground* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PaymentBackground* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PaymentBackground* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const PaymentBackground& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const PaymentBackground& from) { + PaymentBackground::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PaymentBackground* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.PaymentBackground"; + } + protected: + explicit PaymentBackground(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef PaymentBackground_MediaData MediaData; + + typedef PaymentBackground_Type Type; + static constexpr Type UNKNOWN = + PaymentBackground_Type_UNKNOWN; + static constexpr Type DEFAULT = + PaymentBackground_Type_DEFAULT; + static inline bool Type_IsValid(int value) { + return PaymentBackground_Type_IsValid(value); + } + static constexpr Type Type_MIN = + PaymentBackground_Type_Type_MIN; + static constexpr Type Type_MAX = + PaymentBackground_Type_Type_MAX; + static constexpr int Type_ARRAYSIZE = + PaymentBackground_Type_Type_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + Type_descriptor() { + return PaymentBackground_Type_descriptor(); + } + template + static inline const std::string& Type_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Type_Name."); + return PaymentBackground_Type_Name(enum_t_value); + } + static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Type* value) { + return PaymentBackground_Type_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kIdFieldNumber = 1, + kMimetypeFieldNumber = 5, + kMediaDataFieldNumber = 9, + kFileLengthFieldNumber = 2, + kWidthFieldNumber = 3, + kHeightFieldNumber = 4, + kPlaceholderArgbFieldNumber = 6, + kTextArgbFieldNumber = 7, + kSubtextArgbFieldNumber = 8, + kTypeFieldNumber = 10, + }; + // optional string id = 1; + bool has_id() const; + private: + bool _internal_has_id() const; + public: + void clear_id(); + const std::string& id() const; + template + void set_id(ArgT0&& arg0, ArgT... args); + std::string* mutable_id(); + PROTOBUF_NODISCARD std::string* release_id(); + void set_allocated_id(std::string* id); + private: + const std::string& _internal_id() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value); + std::string* _internal_mutable_id(); + public: + + // optional string mimetype = 5; + bool has_mimetype() const; + private: + bool _internal_has_mimetype() const; + public: + void clear_mimetype(); + const std::string& mimetype() const; + template + void set_mimetype(ArgT0&& arg0, ArgT... args); + std::string* mutable_mimetype(); + PROTOBUF_NODISCARD std::string* release_mimetype(); + void set_allocated_mimetype(std::string* mimetype); + private: + const std::string& _internal_mimetype() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value); + std::string* _internal_mutable_mimetype(); + public: + + // optional .proto.PaymentBackground.MediaData mediaData = 9; + bool has_mediadata() const; + private: + bool _internal_has_mediadata() const; + public: + void clear_mediadata(); + const ::proto::PaymentBackground_MediaData& mediadata() const; + PROTOBUF_NODISCARD ::proto::PaymentBackground_MediaData* release_mediadata(); + ::proto::PaymentBackground_MediaData* mutable_mediadata(); + void set_allocated_mediadata(::proto::PaymentBackground_MediaData* mediadata); + private: + const ::proto::PaymentBackground_MediaData& _internal_mediadata() const; + ::proto::PaymentBackground_MediaData* _internal_mutable_mediadata(); + public: + void unsafe_arena_set_allocated_mediadata( + ::proto::PaymentBackground_MediaData* mediadata); + ::proto::PaymentBackground_MediaData* unsafe_arena_release_mediadata(); + + // optional uint64 fileLength = 2; + bool has_filelength() const; + private: + bool _internal_has_filelength() const; + public: + void clear_filelength(); + uint64_t filelength() const; + void set_filelength(uint64_t value); + private: + uint64_t _internal_filelength() const; + void _internal_set_filelength(uint64_t value); + public: + + // optional uint32 width = 3; + bool has_width() const; + private: + bool _internal_has_width() const; + public: + void clear_width(); + uint32_t width() const; + void set_width(uint32_t value); + private: + uint32_t _internal_width() const; + void _internal_set_width(uint32_t value); + public: + + // optional uint32 height = 4; + bool has_height() const; + private: + bool _internal_has_height() const; + public: + void clear_height(); + uint32_t height() const; + void set_height(uint32_t value); + private: + uint32_t _internal_height() const; + void _internal_set_height(uint32_t value); + public: + + // optional fixed32 placeholderArgb = 6; + bool has_placeholderargb() const; + private: + bool _internal_has_placeholderargb() const; + public: + void clear_placeholderargb(); + uint32_t placeholderargb() const; + void set_placeholderargb(uint32_t value); + private: + uint32_t _internal_placeholderargb() const; + void _internal_set_placeholderargb(uint32_t value); + public: + + // optional fixed32 textArgb = 7; + bool has_textargb() const; + private: + bool _internal_has_textargb() const; + public: + void clear_textargb(); + uint32_t textargb() const; + void set_textargb(uint32_t value); + private: + uint32_t _internal_textargb() const; + void _internal_set_textargb(uint32_t value); + public: + + // optional fixed32 subtextArgb = 8; + bool has_subtextargb() const; + private: + bool _internal_has_subtextargb() const; + public: + void clear_subtextargb(); + uint32_t subtextargb() const; + void set_subtextargb(uint32_t value); + private: + uint32_t _internal_subtextargb() const; + void _internal_set_subtextargb(uint32_t value); + public: + + // optional .proto.PaymentBackground.Type type = 10; + bool has_type() const; + private: + bool _internal_has_type() const; + public: + void clear_type(); + ::proto::PaymentBackground_Type type() const; + void set_type(::proto::PaymentBackground_Type value); + private: + ::proto::PaymentBackground_Type _internal_type() const; + void _internal_set_type(::proto::PaymentBackground_Type value); + public: + + // @@protoc_insertion_point(class_scope:proto.PaymentBackground) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mimetype_; + ::proto::PaymentBackground_MediaData* mediadata_; + uint64_t filelength_; + uint32_t width_; + uint32_t height_; + uint32_t placeholderargb_; + uint32_t textargb_; + uint32_t subtextargb_; + int type_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class PaymentInfo final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PaymentInfo) */ { + public: + inline PaymentInfo() : PaymentInfo(nullptr) {} + ~PaymentInfo() override; + explicit PROTOBUF_CONSTEXPR PaymentInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PaymentInfo(const PaymentInfo& from); + PaymentInfo(PaymentInfo&& from) noexcept + : PaymentInfo() { + *this = ::std::move(from); + } + + inline PaymentInfo& operator=(const PaymentInfo& from) { + CopyFrom(from); + return *this; + } + inline PaymentInfo& operator=(PaymentInfo&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const PaymentInfo& default_instance() { + return *internal_default_instance(); + } + static inline const PaymentInfo* internal_default_instance() { + return reinterpret_cast( + &_PaymentInfo_default_instance_); + } + static constexpr int kIndexInFileMessages = + 151; + + friend void swap(PaymentInfo& a, PaymentInfo& b) { + a.Swap(&b); + } + inline void Swap(PaymentInfo* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PaymentInfo* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PaymentInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const PaymentInfo& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const PaymentInfo& from) { + PaymentInfo::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PaymentInfo* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.PaymentInfo"; + } + protected: + explicit PaymentInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef PaymentInfo_Currency Currency; + static constexpr Currency UNKNOWN_CURRENCY = + PaymentInfo_Currency_UNKNOWN_CURRENCY; + static constexpr Currency INR = + PaymentInfo_Currency_INR; + static inline bool Currency_IsValid(int value) { + return PaymentInfo_Currency_IsValid(value); + } + static constexpr Currency Currency_MIN = + PaymentInfo_Currency_Currency_MIN; + static constexpr Currency Currency_MAX = + PaymentInfo_Currency_Currency_MAX; + static constexpr int Currency_ARRAYSIZE = + PaymentInfo_Currency_Currency_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + Currency_descriptor() { + return PaymentInfo_Currency_descriptor(); + } + template + static inline const std::string& Currency_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Currency_Name."); + return PaymentInfo_Currency_Name(enum_t_value); + } + static inline bool Currency_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Currency* value) { + return PaymentInfo_Currency_Parse(name, value); + } + + typedef PaymentInfo_Status Status; + static constexpr Status UNKNOWN_STATUS = + PaymentInfo_Status_UNKNOWN_STATUS; + static constexpr Status PROCESSING = + PaymentInfo_Status_PROCESSING; + static constexpr Status SENT = + PaymentInfo_Status_SENT; + static constexpr Status NEED_TO_ACCEPT = + PaymentInfo_Status_NEED_TO_ACCEPT; + static constexpr Status COMPLETE = + PaymentInfo_Status_COMPLETE; + static constexpr Status COULD_NOT_COMPLETE = + PaymentInfo_Status_COULD_NOT_COMPLETE; + static constexpr Status REFUNDED = + PaymentInfo_Status_REFUNDED; + static constexpr Status EXPIRED = + PaymentInfo_Status_EXPIRED; + static constexpr Status REJECTED = + PaymentInfo_Status_REJECTED; + static constexpr Status CANCELLED = + PaymentInfo_Status_CANCELLED; + static constexpr Status WAITING_FOR_PAYER = + PaymentInfo_Status_WAITING_FOR_PAYER; + static constexpr Status WAITING = + PaymentInfo_Status_WAITING; + static inline bool Status_IsValid(int value) { + return PaymentInfo_Status_IsValid(value); + } + static constexpr Status Status_MIN = + PaymentInfo_Status_Status_MIN; + static constexpr Status Status_MAX = + PaymentInfo_Status_Status_MAX; + static constexpr int Status_ARRAYSIZE = + PaymentInfo_Status_Status_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + Status_descriptor() { + return PaymentInfo_Status_descriptor(); + } + template + static inline const std::string& Status_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Status_Name."); + return PaymentInfo_Status_Name(enum_t_value); + } + static inline bool Status_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Status* value) { + return PaymentInfo_Status_Parse(name, value); + } + + typedef PaymentInfo_TxnStatus TxnStatus; + static constexpr TxnStatus UNKNOWN = + PaymentInfo_TxnStatus_UNKNOWN; + static constexpr TxnStatus PENDING_SETUP = + PaymentInfo_TxnStatus_PENDING_SETUP; + static constexpr TxnStatus PENDING_RECEIVER_SETUP = + PaymentInfo_TxnStatus_PENDING_RECEIVER_SETUP; + static constexpr TxnStatus INIT = + PaymentInfo_TxnStatus_INIT; + static constexpr TxnStatus SUCCESS = + PaymentInfo_TxnStatus_SUCCESS; + static constexpr TxnStatus COMPLETED = + PaymentInfo_TxnStatus_COMPLETED; + static constexpr TxnStatus FAILED = + PaymentInfo_TxnStatus_FAILED; + static constexpr TxnStatus FAILED_RISK = + PaymentInfo_TxnStatus_FAILED_RISK; + static constexpr TxnStatus FAILED_PROCESSING = + PaymentInfo_TxnStatus_FAILED_PROCESSING; + static constexpr TxnStatus FAILED_RECEIVER_PROCESSING = + PaymentInfo_TxnStatus_FAILED_RECEIVER_PROCESSING; + static constexpr TxnStatus FAILED_DA = + PaymentInfo_TxnStatus_FAILED_DA; + static constexpr TxnStatus FAILED_DA_FINAL = + PaymentInfo_TxnStatus_FAILED_DA_FINAL; + static constexpr TxnStatus REFUNDED_TXN = + PaymentInfo_TxnStatus_REFUNDED_TXN; + static constexpr TxnStatus REFUND_FAILED = + PaymentInfo_TxnStatus_REFUND_FAILED; + static constexpr TxnStatus REFUND_FAILED_PROCESSING = + PaymentInfo_TxnStatus_REFUND_FAILED_PROCESSING; + static constexpr TxnStatus REFUND_FAILED_DA = + PaymentInfo_TxnStatus_REFUND_FAILED_DA; + static constexpr TxnStatus EXPIRED_TXN = + PaymentInfo_TxnStatus_EXPIRED_TXN; + static constexpr TxnStatus AUTH_CANCELED = + PaymentInfo_TxnStatus_AUTH_CANCELED; + static constexpr TxnStatus AUTH_CANCEL_FAILED_PROCESSING = + PaymentInfo_TxnStatus_AUTH_CANCEL_FAILED_PROCESSING; + static constexpr TxnStatus AUTH_CANCEL_FAILED = + PaymentInfo_TxnStatus_AUTH_CANCEL_FAILED; + static constexpr TxnStatus COLLECT_INIT = + PaymentInfo_TxnStatus_COLLECT_INIT; + static constexpr TxnStatus COLLECT_SUCCESS = + PaymentInfo_TxnStatus_COLLECT_SUCCESS; + static constexpr TxnStatus COLLECT_FAILED = + PaymentInfo_TxnStatus_COLLECT_FAILED; + static constexpr TxnStatus COLLECT_FAILED_RISK = + PaymentInfo_TxnStatus_COLLECT_FAILED_RISK; + static constexpr TxnStatus COLLECT_REJECTED = + PaymentInfo_TxnStatus_COLLECT_REJECTED; + static constexpr TxnStatus COLLECT_EXPIRED = + PaymentInfo_TxnStatus_COLLECT_EXPIRED; + static constexpr TxnStatus COLLECT_CANCELED = + PaymentInfo_TxnStatus_COLLECT_CANCELED; + static constexpr TxnStatus COLLECT_CANCELLING = + PaymentInfo_TxnStatus_COLLECT_CANCELLING; + static constexpr TxnStatus IN_REVIEW = + PaymentInfo_TxnStatus_IN_REVIEW; + static constexpr TxnStatus REVERSAL_SUCCESS = + PaymentInfo_TxnStatus_REVERSAL_SUCCESS; + static constexpr TxnStatus REVERSAL_PENDING = + PaymentInfo_TxnStatus_REVERSAL_PENDING; + static constexpr TxnStatus REFUND_PENDING = + PaymentInfo_TxnStatus_REFUND_PENDING; + static inline bool TxnStatus_IsValid(int value) { + return PaymentInfo_TxnStatus_IsValid(value); + } + static constexpr TxnStatus TxnStatus_MIN = + PaymentInfo_TxnStatus_TxnStatus_MIN; + static constexpr TxnStatus TxnStatus_MAX = + PaymentInfo_TxnStatus_TxnStatus_MAX; + static constexpr int TxnStatus_ARRAYSIZE = + PaymentInfo_TxnStatus_TxnStatus_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + TxnStatus_descriptor() { + return PaymentInfo_TxnStatus_descriptor(); + } + template + static inline const std::string& TxnStatus_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function TxnStatus_Name."); + return PaymentInfo_TxnStatus_Name(enum_t_value); + } + static inline bool TxnStatus_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + TxnStatus* value) { + return PaymentInfo_TxnStatus_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kReceiverJidFieldNumber = 3, + kCurrencyFieldNumber = 9, + kRequestMessageKeyFieldNumber = 6, + kPrimaryAmountFieldNumber = 12, + kExchangeAmountFieldNumber = 13, + kAmount1000FieldNumber = 2, + kCurrencyDeprecatedFieldNumber = 1, + kStatusFieldNumber = 4, + kTransactionTimestampFieldNumber = 5, + kExpiryTimestampFieldNumber = 7, + kFutureproofedFieldNumber = 8, + kUseNoviFiatFormatFieldNumber = 11, + kTxnStatusFieldNumber = 10, + }; + // optional string receiverJid = 3; + bool has_receiverjid() const; + private: + bool _internal_has_receiverjid() const; + public: + void clear_receiverjid(); + const std::string& receiverjid() const; + template + void set_receiverjid(ArgT0&& arg0, ArgT... args); + std::string* mutable_receiverjid(); + PROTOBUF_NODISCARD std::string* release_receiverjid(); + void set_allocated_receiverjid(std::string* receiverjid); + private: + const std::string& _internal_receiverjid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_receiverjid(const std::string& value); + std::string* _internal_mutable_receiverjid(); + public: + + // optional string currency = 9; + bool has_currency() const; + private: + bool _internal_has_currency() const; + public: + void clear_currency(); + const std::string& currency() const; + template + void set_currency(ArgT0&& arg0, ArgT... args); + std::string* mutable_currency(); + PROTOBUF_NODISCARD std::string* release_currency(); + void set_allocated_currency(std::string* currency); + private: + const std::string& _internal_currency() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_currency(const std::string& value); + std::string* _internal_mutable_currency(); + public: + + // optional .proto.MessageKey requestMessageKey = 6; + bool has_requestmessagekey() const; + private: + bool _internal_has_requestmessagekey() const; + public: + void clear_requestmessagekey(); + const ::proto::MessageKey& requestmessagekey() const; + PROTOBUF_NODISCARD ::proto::MessageKey* release_requestmessagekey(); + ::proto::MessageKey* mutable_requestmessagekey(); + void set_allocated_requestmessagekey(::proto::MessageKey* requestmessagekey); + private: + const ::proto::MessageKey& _internal_requestmessagekey() const; + ::proto::MessageKey* _internal_mutable_requestmessagekey(); + public: + void unsafe_arena_set_allocated_requestmessagekey( + ::proto::MessageKey* requestmessagekey); + ::proto::MessageKey* unsafe_arena_release_requestmessagekey(); + + // optional .proto.Money primaryAmount = 12; + bool has_primaryamount() const; + private: + bool _internal_has_primaryamount() const; + public: + void clear_primaryamount(); + const ::proto::Money& primaryamount() const; + PROTOBUF_NODISCARD ::proto::Money* release_primaryamount(); + ::proto::Money* mutable_primaryamount(); + void set_allocated_primaryamount(::proto::Money* primaryamount); + private: + const ::proto::Money& _internal_primaryamount() const; + ::proto::Money* _internal_mutable_primaryamount(); + public: + void unsafe_arena_set_allocated_primaryamount( + ::proto::Money* primaryamount); + ::proto::Money* unsafe_arena_release_primaryamount(); + + // optional .proto.Money exchangeAmount = 13; + bool has_exchangeamount() const; + private: + bool _internal_has_exchangeamount() const; + public: + void clear_exchangeamount(); + const ::proto::Money& exchangeamount() const; + PROTOBUF_NODISCARD ::proto::Money* release_exchangeamount(); + ::proto::Money* mutable_exchangeamount(); + void set_allocated_exchangeamount(::proto::Money* exchangeamount); + private: + const ::proto::Money& _internal_exchangeamount() const; + ::proto::Money* _internal_mutable_exchangeamount(); + public: + void unsafe_arena_set_allocated_exchangeamount( + ::proto::Money* exchangeamount); + ::proto::Money* unsafe_arena_release_exchangeamount(); + + // optional uint64 amount1000 = 2; + bool has_amount1000() const; + private: + bool _internal_has_amount1000() const; + public: + void clear_amount1000(); + uint64_t amount1000() const; + void set_amount1000(uint64_t value); + private: + uint64_t _internal_amount1000() const; + void _internal_set_amount1000(uint64_t value); + public: + + // optional .proto.PaymentInfo.Currency currencyDeprecated = 1; + bool has_currencydeprecated() const; + private: + bool _internal_has_currencydeprecated() const; + public: + void clear_currencydeprecated(); + ::proto::PaymentInfo_Currency currencydeprecated() const; + void set_currencydeprecated(::proto::PaymentInfo_Currency value); + private: + ::proto::PaymentInfo_Currency _internal_currencydeprecated() const; + void _internal_set_currencydeprecated(::proto::PaymentInfo_Currency value); + public: + + // optional .proto.PaymentInfo.Status status = 4; + bool has_status() const; + private: + bool _internal_has_status() const; + public: + void clear_status(); + ::proto::PaymentInfo_Status status() const; + void set_status(::proto::PaymentInfo_Status value); + private: + ::proto::PaymentInfo_Status _internal_status() const; + void _internal_set_status(::proto::PaymentInfo_Status value); + public: + + // optional uint64 transactionTimestamp = 5; + bool has_transactiontimestamp() const; + private: + bool _internal_has_transactiontimestamp() const; + public: + void clear_transactiontimestamp(); + uint64_t transactiontimestamp() const; + void set_transactiontimestamp(uint64_t value); + private: + uint64_t _internal_transactiontimestamp() const; + void _internal_set_transactiontimestamp(uint64_t value); + public: + + // optional uint64 expiryTimestamp = 7; + bool has_expirytimestamp() const; + private: + bool _internal_has_expirytimestamp() const; + public: + void clear_expirytimestamp(); + uint64_t expirytimestamp() const; + void set_expirytimestamp(uint64_t value); + private: + uint64_t _internal_expirytimestamp() const; + void _internal_set_expirytimestamp(uint64_t value); + public: + + // optional bool futureproofed = 8; + bool has_futureproofed() const; + private: + bool _internal_has_futureproofed() const; + public: + void clear_futureproofed(); + bool futureproofed() const; + void set_futureproofed(bool value); + private: + bool _internal_futureproofed() const; + void _internal_set_futureproofed(bool value); + public: + + // optional bool useNoviFiatFormat = 11; + bool has_usenovifiatformat() const; + private: + bool _internal_has_usenovifiatformat() const; + public: + void clear_usenovifiatformat(); + bool usenovifiatformat() const; + void set_usenovifiatformat(bool value); + private: + bool _internal_usenovifiatformat() const; + void _internal_set_usenovifiatformat(bool value); + public: + + // optional .proto.PaymentInfo.TxnStatus txnStatus = 10; + bool has_txnstatus() const; + private: + bool _internal_has_txnstatus() const; + public: + void clear_txnstatus(); + ::proto::PaymentInfo_TxnStatus txnstatus() const; + void set_txnstatus(::proto::PaymentInfo_TxnStatus value); + private: + ::proto::PaymentInfo_TxnStatus _internal_txnstatus() const; + void _internal_set_txnstatus(::proto::PaymentInfo_TxnStatus value); + public: + + // @@protoc_insertion_point(class_scope:proto.PaymentInfo) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr receiverjid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr currency_; + ::proto::MessageKey* requestmessagekey_; + ::proto::Money* primaryamount_; + ::proto::Money* exchangeamount_; + uint64_t amount1000_; + int currencydeprecated_; + int status_; + uint64_t transactiontimestamp_; + uint64_t expirytimestamp_; + bool futureproofed_; + bool usenovifiatformat_; + int txnstatus_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class PendingKeyExchange final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PendingKeyExchange) */ { + public: + inline PendingKeyExchange() : PendingKeyExchange(nullptr) {} + ~PendingKeyExchange() override; + explicit PROTOBUF_CONSTEXPR PendingKeyExchange(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PendingKeyExchange(const PendingKeyExchange& from); + PendingKeyExchange(PendingKeyExchange&& from) noexcept + : PendingKeyExchange() { + *this = ::std::move(from); + } + + inline PendingKeyExchange& operator=(const PendingKeyExchange& from) { + CopyFrom(from); + return *this; + } + inline PendingKeyExchange& operator=(PendingKeyExchange&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const PendingKeyExchange& default_instance() { + return *internal_default_instance(); + } + static inline const PendingKeyExchange* internal_default_instance() { + return reinterpret_cast( + &_PendingKeyExchange_default_instance_); + } + static constexpr int kIndexInFileMessages = + 152; + + friend void swap(PendingKeyExchange& a, PendingKeyExchange& b) { + a.Swap(&b); + } + inline void Swap(PendingKeyExchange* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PendingKeyExchange* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PendingKeyExchange* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const PendingKeyExchange& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const PendingKeyExchange& from) { + PendingKeyExchange::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PendingKeyExchange* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.PendingKeyExchange"; + } + protected: + explicit PendingKeyExchange(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kLocalBaseKeyFieldNumber = 2, + kLocalBaseKeyPrivateFieldNumber = 3, + kLocalRatchetKeyFieldNumber = 4, + kLocalRatchetKeyPrivateFieldNumber = 5, + kLocalIdentityKeyFieldNumber = 7, + kLocalIdentityKeyPrivateFieldNumber = 8, + kSequenceFieldNumber = 1, + }; + // optional bytes localBaseKey = 2; + bool has_localbasekey() const; + private: + bool _internal_has_localbasekey() const; + public: + void clear_localbasekey(); + const std::string& localbasekey() const; + template + void set_localbasekey(ArgT0&& arg0, ArgT... args); + std::string* mutable_localbasekey(); + PROTOBUF_NODISCARD std::string* release_localbasekey(); + void set_allocated_localbasekey(std::string* localbasekey); + private: + const std::string& _internal_localbasekey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_localbasekey(const std::string& value); + std::string* _internal_mutable_localbasekey(); + public: + + // optional bytes localBaseKeyPrivate = 3; + bool has_localbasekeyprivate() const; + private: + bool _internal_has_localbasekeyprivate() const; + public: + void clear_localbasekeyprivate(); + const std::string& localbasekeyprivate() const; + template + void set_localbasekeyprivate(ArgT0&& arg0, ArgT... args); + std::string* mutable_localbasekeyprivate(); + PROTOBUF_NODISCARD std::string* release_localbasekeyprivate(); + void set_allocated_localbasekeyprivate(std::string* localbasekeyprivate); + private: + const std::string& _internal_localbasekeyprivate() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_localbasekeyprivate(const std::string& value); + std::string* _internal_mutable_localbasekeyprivate(); + public: + + // optional bytes localRatchetKey = 4; + bool has_localratchetkey() const; + private: + bool _internal_has_localratchetkey() const; + public: + void clear_localratchetkey(); + const std::string& localratchetkey() const; + template + void set_localratchetkey(ArgT0&& arg0, ArgT... args); + std::string* mutable_localratchetkey(); + PROTOBUF_NODISCARD std::string* release_localratchetkey(); + void set_allocated_localratchetkey(std::string* localratchetkey); + private: + const std::string& _internal_localratchetkey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_localratchetkey(const std::string& value); + std::string* _internal_mutable_localratchetkey(); + public: + + // optional bytes localRatchetKeyPrivate = 5; + bool has_localratchetkeyprivate() const; + private: + bool _internal_has_localratchetkeyprivate() const; + public: + void clear_localratchetkeyprivate(); + const std::string& localratchetkeyprivate() const; + template + void set_localratchetkeyprivate(ArgT0&& arg0, ArgT... args); + std::string* mutable_localratchetkeyprivate(); + PROTOBUF_NODISCARD std::string* release_localratchetkeyprivate(); + void set_allocated_localratchetkeyprivate(std::string* localratchetkeyprivate); + private: + const std::string& _internal_localratchetkeyprivate() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_localratchetkeyprivate(const std::string& value); + std::string* _internal_mutable_localratchetkeyprivate(); + public: + + // optional bytes localIdentityKey = 7; + bool has_localidentitykey() const; + private: + bool _internal_has_localidentitykey() const; + public: + void clear_localidentitykey(); + const std::string& localidentitykey() const; + template + void set_localidentitykey(ArgT0&& arg0, ArgT... args); + std::string* mutable_localidentitykey(); + PROTOBUF_NODISCARD std::string* release_localidentitykey(); + void set_allocated_localidentitykey(std::string* localidentitykey); + private: + const std::string& _internal_localidentitykey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_localidentitykey(const std::string& value); + std::string* _internal_mutable_localidentitykey(); + public: + + // optional bytes localIdentityKeyPrivate = 8; + bool has_localidentitykeyprivate() const; + private: + bool _internal_has_localidentitykeyprivate() const; + public: + void clear_localidentitykeyprivate(); + const std::string& localidentitykeyprivate() const; + template + void set_localidentitykeyprivate(ArgT0&& arg0, ArgT... args); + std::string* mutable_localidentitykeyprivate(); + PROTOBUF_NODISCARD std::string* release_localidentitykeyprivate(); + void set_allocated_localidentitykeyprivate(std::string* localidentitykeyprivate); + private: + const std::string& _internal_localidentitykeyprivate() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_localidentitykeyprivate(const std::string& value); + std::string* _internal_mutable_localidentitykeyprivate(); + public: + + // optional uint32 sequence = 1; + bool has_sequence() const; + private: + bool _internal_has_sequence() const; + public: + void clear_sequence(); + uint32_t sequence() const; + void set_sequence(uint32_t value); + private: + uint32_t _internal_sequence() const; + void _internal_set_sequence(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.PendingKeyExchange) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localbasekey_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localbasekeyprivate_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localratchetkey_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localratchetkeyprivate_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localidentitykey_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localidentitykeyprivate_; + uint32_t sequence_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class PendingPreKey final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PendingPreKey) */ { + public: + inline PendingPreKey() : PendingPreKey(nullptr) {} + ~PendingPreKey() override; + explicit PROTOBUF_CONSTEXPR PendingPreKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PendingPreKey(const PendingPreKey& from); + PendingPreKey(PendingPreKey&& from) noexcept + : PendingPreKey() { + *this = ::std::move(from); + } + + inline PendingPreKey& operator=(const PendingPreKey& from) { + CopyFrom(from); + return *this; + } + inline PendingPreKey& operator=(PendingPreKey&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const PendingPreKey& default_instance() { + return *internal_default_instance(); + } + static inline const PendingPreKey* internal_default_instance() { + return reinterpret_cast( + &_PendingPreKey_default_instance_); + } + static constexpr int kIndexInFileMessages = + 153; + + friend void swap(PendingPreKey& a, PendingPreKey& b) { + a.Swap(&b); + } + inline void Swap(PendingPreKey* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PendingPreKey* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PendingPreKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const PendingPreKey& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const PendingPreKey& from) { + PendingPreKey::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PendingPreKey* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.PendingPreKey"; + } + protected: + explicit PendingPreKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kBaseKeyFieldNumber = 2, + kPreKeyIdFieldNumber = 1, + kSignedPreKeyIdFieldNumber = 3, + }; + // optional bytes baseKey = 2; + bool has_basekey() const; + private: + bool _internal_has_basekey() const; + public: + void clear_basekey(); + const std::string& basekey() const; + template + void set_basekey(ArgT0&& arg0, ArgT... args); + std::string* mutable_basekey(); + PROTOBUF_NODISCARD std::string* release_basekey(); + void set_allocated_basekey(std::string* basekey); + private: + const std::string& _internal_basekey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_basekey(const std::string& value); + std::string* _internal_mutable_basekey(); + public: + + // optional uint32 preKeyId = 1; + bool has_prekeyid() const; + private: + bool _internal_has_prekeyid() const; + public: + void clear_prekeyid(); + uint32_t prekeyid() const; + void set_prekeyid(uint32_t value); + private: + uint32_t _internal_prekeyid() const; + void _internal_set_prekeyid(uint32_t value); + public: + + // optional int32 signedPreKeyId = 3; + bool has_signedprekeyid() const; + private: + bool _internal_has_signedprekeyid() const; + public: + void clear_signedprekeyid(); + int32_t signedprekeyid() const; + void set_signedprekeyid(int32_t value); + private: + int32_t _internal_signedprekeyid() const; + void _internal_set_signedprekeyid(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.PendingPreKey) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr basekey_; + uint32_t prekeyid_; + int32_t signedprekeyid_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class PhotoChange final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PhotoChange) */ { + public: + inline PhotoChange() : PhotoChange(nullptr) {} + ~PhotoChange() override; + explicit PROTOBUF_CONSTEXPR PhotoChange(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PhotoChange(const PhotoChange& from); + PhotoChange(PhotoChange&& from) noexcept + : PhotoChange() { + *this = ::std::move(from); + } + + inline PhotoChange& operator=(const PhotoChange& from) { + CopyFrom(from); + return *this; + } + inline PhotoChange& operator=(PhotoChange&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const PhotoChange& default_instance() { + return *internal_default_instance(); + } + static inline const PhotoChange* internal_default_instance() { + return reinterpret_cast( + &_PhotoChange_default_instance_); + } + static constexpr int kIndexInFileMessages = + 154; + + friend void swap(PhotoChange& a, PhotoChange& b) { + a.Swap(&b); + } + inline void Swap(PhotoChange* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PhotoChange* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PhotoChange* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const PhotoChange& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const PhotoChange& from) { + PhotoChange::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PhotoChange* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.PhotoChange"; + } + protected: + explicit PhotoChange(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kOldPhotoFieldNumber = 1, + kNewPhotoFieldNumber = 2, + kNewPhotoIdFieldNumber = 3, + }; + // optional bytes oldPhoto = 1; + bool has_oldphoto() const; + private: + bool _internal_has_oldphoto() const; + public: + void clear_oldphoto(); + const std::string& oldphoto() const; + template + void set_oldphoto(ArgT0&& arg0, ArgT... args); + std::string* mutable_oldphoto(); + PROTOBUF_NODISCARD std::string* release_oldphoto(); + void set_allocated_oldphoto(std::string* oldphoto); + private: + const std::string& _internal_oldphoto() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_oldphoto(const std::string& value); + std::string* _internal_mutable_oldphoto(); + public: + + // optional bytes newPhoto = 2; + bool has_newphoto() const; + private: + bool _internal_has_newphoto() const; + public: + void clear_newphoto(); + const std::string& newphoto() const; + template + void set_newphoto(ArgT0&& arg0, ArgT... args); + std::string* mutable_newphoto(); + PROTOBUF_NODISCARD std::string* release_newphoto(); + void set_allocated_newphoto(std::string* newphoto); + private: + const std::string& _internal_newphoto() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_newphoto(const std::string& value); + std::string* _internal_mutable_newphoto(); + public: + + // optional uint32 newPhotoId = 3; + bool has_newphotoid() const; + private: + bool _internal_has_newphotoid() const; + public: + void clear_newphotoid(); + uint32_t newphotoid() const; + void set_newphotoid(uint32_t value); + private: + uint32_t _internal_newphotoid() const; + void _internal_set_newphotoid(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.PhotoChange) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr oldphoto_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr newphoto_; + uint32_t newphotoid_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Point final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Point) */ { + public: + inline Point() : Point(nullptr) {} + ~Point() override; + explicit PROTOBUF_CONSTEXPR Point(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Point(const Point& from); + Point(Point&& from) noexcept + : Point() { + *this = ::std::move(from); + } + + inline Point& operator=(const Point& from) { + CopyFrom(from); + return *this; + } + inline Point& operator=(Point&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Point& default_instance() { + return *internal_default_instance(); + } + static inline const Point* internal_default_instance() { + return reinterpret_cast( + &_Point_default_instance_); + } + static constexpr int kIndexInFileMessages = + 155; + + friend void swap(Point& a, Point& b) { + a.Swap(&b); + } + inline void Swap(Point* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Point* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Point* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Point& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Point& from) { + Point::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Point* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Point"; + } + protected: + explicit Point(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kXDeprecatedFieldNumber = 1, + kYDeprecatedFieldNumber = 2, + kXFieldNumber = 3, + kYFieldNumber = 4, + }; + // optional int32 xDeprecated = 1; + bool has_xdeprecated() const; + private: + bool _internal_has_xdeprecated() const; + public: + void clear_xdeprecated(); + int32_t xdeprecated() const; + void set_xdeprecated(int32_t value); + private: + int32_t _internal_xdeprecated() const; + void _internal_set_xdeprecated(int32_t value); + public: + + // optional int32 yDeprecated = 2; + bool has_ydeprecated() const; + private: + bool _internal_has_ydeprecated() const; + public: + void clear_ydeprecated(); + int32_t ydeprecated() const; + void set_ydeprecated(int32_t value); + private: + int32_t _internal_ydeprecated() const; + void _internal_set_ydeprecated(int32_t value); + public: + + // optional double x = 3; + bool has_x() const; + private: + bool _internal_has_x() const; + public: + void clear_x(); + double x() const; + void set_x(double value); + private: + double _internal_x() const; + void _internal_set_x(double value); + public: + + // optional double y = 4; + bool has_y() const; + private: + bool _internal_has_y() const; + public: + void clear_y(); + double y() const; + void set_y(double value); + private: + double _internal_y() const; + void _internal_set_y(double value); + public: + + // @@protoc_insertion_point(class_scope:proto.Point) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + int32_t xdeprecated_; + int32_t ydeprecated_; + double x_; + double y_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class PollAdditionalMetadata final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PollAdditionalMetadata) */ { + public: + inline PollAdditionalMetadata() : PollAdditionalMetadata(nullptr) {} + ~PollAdditionalMetadata() override; + explicit PROTOBUF_CONSTEXPR PollAdditionalMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PollAdditionalMetadata(const PollAdditionalMetadata& from); + PollAdditionalMetadata(PollAdditionalMetadata&& from) noexcept + : PollAdditionalMetadata() { + *this = ::std::move(from); + } + + inline PollAdditionalMetadata& operator=(const PollAdditionalMetadata& from) { + CopyFrom(from); + return *this; + } + inline PollAdditionalMetadata& operator=(PollAdditionalMetadata&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const PollAdditionalMetadata& default_instance() { + return *internal_default_instance(); + } + static inline const PollAdditionalMetadata* internal_default_instance() { + return reinterpret_cast( + &_PollAdditionalMetadata_default_instance_); + } + static constexpr int kIndexInFileMessages = + 156; + + friend void swap(PollAdditionalMetadata& a, PollAdditionalMetadata& b) { + a.Swap(&b); + } + inline void Swap(PollAdditionalMetadata* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PollAdditionalMetadata* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PollAdditionalMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const PollAdditionalMetadata& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const PollAdditionalMetadata& from) { + PollAdditionalMetadata::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PollAdditionalMetadata* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.PollAdditionalMetadata"; + } + protected: + explicit PollAdditionalMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kPollInvalidatedFieldNumber = 1, + }; + // optional bool pollInvalidated = 1; + bool has_pollinvalidated() const; + private: + bool _internal_has_pollinvalidated() const; + public: + void clear_pollinvalidated(); + bool pollinvalidated() const; + void set_pollinvalidated(bool value); + private: + bool _internal_pollinvalidated() const; + void _internal_set_pollinvalidated(bool value); + public: + + // @@protoc_insertion_point(class_scope:proto.PollAdditionalMetadata) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + bool pollinvalidated_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class PollEncValue final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PollEncValue) */ { + public: + inline PollEncValue() : PollEncValue(nullptr) {} + ~PollEncValue() override; + explicit PROTOBUF_CONSTEXPR PollEncValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PollEncValue(const PollEncValue& from); + PollEncValue(PollEncValue&& from) noexcept + : PollEncValue() { + *this = ::std::move(from); + } + + inline PollEncValue& operator=(const PollEncValue& from) { + CopyFrom(from); + return *this; + } + inline PollEncValue& operator=(PollEncValue&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const PollEncValue& default_instance() { + return *internal_default_instance(); + } + static inline const PollEncValue* internal_default_instance() { + return reinterpret_cast( + &_PollEncValue_default_instance_); + } + static constexpr int kIndexInFileMessages = + 157; + + friend void swap(PollEncValue& a, PollEncValue& b) { + a.Swap(&b); + } + inline void Swap(PollEncValue* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PollEncValue* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PollEncValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const PollEncValue& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const PollEncValue& from) { + PollEncValue::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PollEncValue* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.PollEncValue"; + } + protected: + explicit PollEncValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kEncPayloadFieldNumber = 1, + kEncIvFieldNumber = 2, + }; + // optional bytes encPayload = 1; + bool has_encpayload() const; + private: + bool _internal_has_encpayload() const; + public: + void clear_encpayload(); + const std::string& encpayload() const; + template + void set_encpayload(ArgT0&& arg0, ArgT... args); + std::string* mutable_encpayload(); + PROTOBUF_NODISCARD std::string* release_encpayload(); + void set_allocated_encpayload(std::string* encpayload); + private: + const std::string& _internal_encpayload() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_encpayload(const std::string& value); + std::string* _internal_mutable_encpayload(); + public: + + // optional bytes encIv = 2; + bool has_enciv() const; + private: + bool _internal_has_enciv() const; + public: + void clear_enciv(); + const std::string& enciv() const; + template + void set_enciv(ArgT0&& arg0, ArgT... args); + std::string* mutable_enciv(); + PROTOBUF_NODISCARD std::string* release_enciv(); + void set_allocated_enciv(std::string* enciv); + private: + const std::string& _internal_enciv() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_enciv(const std::string& value); + std::string* _internal_mutable_enciv(); + public: + + // @@protoc_insertion_point(class_scope:proto.PollEncValue) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encpayload_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr enciv_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class PollUpdate final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PollUpdate) */ { + public: + inline PollUpdate() : PollUpdate(nullptr) {} + ~PollUpdate() override; + explicit PROTOBUF_CONSTEXPR PollUpdate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PollUpdate(const PollUpdate& from); + PollUpdate(PollUpdate&& from) noexcept + : PollUpdate() { + *this = ::std::move(from); + } + + inline PollUpdate& operator=(const PollUpdate& from) { + CopyFrom(from); + return *this; + } + inline PollUpdate& operator=(PollUpdate&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const PollUpdate& default_instance() { + return *internal_default_instance(); + } + static inline const PollUpdate* internal_default_instance() { + return reinterpret_cast( + &_PollUpdate_default_instance_); + } + static constexpr int kIndexInFileMessages = + 158; + + friend void swap(PollUpdate& a, PollUpdate& b) { + a.Swap(&b); + } + inline void Swap(PollUpdate* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PollUpdate* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PollUpdate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const PollUpdate& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const PollUpdate& from) { + PollUpdate::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PollUpdate* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.PollUpdate"; + } + protected: + explicit PollUpdate(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kPollUpdateMessageKeyFieldNumber = 1, + kVoteFieldNumber = 2, + kSenderTimestampMsFieldNumber = 3, + }; + // optional .proto.MessageKey pollUpdateMessageKey = 1; + bool has_pollupdatemessagekey() const; + private: + bool _internal_has_pollupdatemessagekey() const; + public: + void clear_pollupdatemessagekey(); + const ::proto::MessageKey& pollupdatemessagekey() const; + PROTOBUF_NODISCARD ::proto::MessageKey* release_pollupdatemessagekey(); + ::proto::MessageKey* mutable_pollupdatemessagekey(); + void set_allocated_pollupdatemessagekey(::proto::MessageKey* pollupdatemessagekey); + private: + const ::proto::MessageKey& _internal_pollupdatemessagekey() const; + ::proto::MessageKey* _internal_mutable_pollupdatemessagekey(); + public: + void unsafe_arena_set_allocated_pollupdatemessagekey( + ::proto::MessageKey* pollupdatemessagekey); + ::proto::MessageKey* unsafe_arena_release_pollupdatemessagekey(); + + // optional .proto.Message.PollVoteMessage vote = 2; + bool has_vote() const; + private: + bool _internal_has_vote() const; + public: + void clear_vote(); + const ::proto::Message_PollVoteMessage& vote() const; + PROTOBUF_NODISCARD ::proto::Message_PollVoteMessage* release_vote(); + ::proto::Message_PollVoteMessage* mutable_vote(); + void set_allocated_vote(::proto::Message_PollVoteMessage* vote); + private: + const ::proto::Message_PollVoteMessage& _internal_vote() const; + ::proto::Message_PollVoteMessage* _internal_mutable_vote(); + public: + void unsafe_arena_set_allocated_vote( + ::proto::Message_PollVoteMessage* vote); + ::proto::Message_PollVoteMessage* unsafe_arena_release_vote(); + + // optional int64 senderTimestampMs = 3; + bool has_sendertimestampms() const; + private: + bool _internal_has_sendertimestampms() const; + public: + void clear_sendertimestampms(); + int64_t sendertimestampms() const; + void set_sendertimestampms(int64_t value); + private: + int64_t _internal_sendertimestampms() const; + void _internal_set_sendertimestampms(int64_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.PollUpdate) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::proto::MessageKey* pollupdatemessagekey_; + ::proto::Message_PollVoteMessage* vote_; + int64_t sendertimestampms_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class PreKeyRecordStructure final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PreKeyRecordStructure) */ { + public: + inline PreKeyRecordStructure() : PreKeyRecordStructure(nullptr) {} + ~PreKeyRecordStructure() override; + explicit PROTOBUF_CONSTEXPR PreKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PreKeyRecordStructure(const PreKeyRecordStructure& from); + PreKeyRecordStructure(PreKeyRecordStructure&& from) noexcept + : PreKeyRecordStructure() { + *this = ::std::move(from); + } + + inline PreKeyRecordStructure& operator=(const PreKeyRecordStructure& from) { + CopyFrom(from); + return *this; + } + inline PreKeyRecordStructure& operator=(PreKeyRecordStructure&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const PreKeyRecordStructure& default_instance() { + return *internal_default_instance(); + } + static inline const PreKeyRecordStructure* internal_default_instance() { + return reinterpret_cast( + &_PreKeyRecordStructure_default_instance_); + } + static constexpr int kIndexInFileMessages = + 159; + + friend void swap(PreKeyRecordStructure& a, PreKeyRecordStructure& b) { + a.Swap(&b); + } + inline void Swap(PreKeyRecordStructure* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PreKeyRecordStructure* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PreKeyRecordStructure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const PreKeyRecordStructure& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const PreKeyRecordStructure& from) { + PreKeyRecordStructure::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PreKeyRecordStructure* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.PreKeyRecordStructure"; + } + protected: + explicit PreKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kPublicKeyFieldNumber = 2, + kPrivateKeyFieldNumber = 3, + kIdFieldNumber = 1, + }; + // optional bytes publicKey = 2; + bool has_publickey() const; + private: + bool _internal_has_publickey() const; + public: + void clear_publickey(); + const std::string& publickey() const; + template + void set_publickey(ArgT0&& arg0, ArgT... args); + std::string* mutable_publickey(); + PROTOBUF_NODISCARD std::string* release_publickey(); + void set_allocated_publickey(std::string* publickey); + private: + const std::string& _internal_publickey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_publickey(const std::string& value); + std::string* _internal_mutable_publickey(); + public: + + // optional bytes privateKey = 3; + bool has_privatekey() const; + private: + bool _internal_has_privatekey() const; + public: + void clear_privatekey(); + const std::string& privatekey() const; + template + void set_privatekey(ArgT0&& arg0, ArgT... args); + std::string* mutable_privatekey(); + PROTOBUF_NODISCARD std::string* release_privatekey(); + void set_allocated_privatekey(std::string* privatekey); + private: + const std::string& _internal_privatekey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_privatekey(const std::string& value); + std::string* _internal_mutable_privatekey(); + public: + + // optional uint32 id = 1; + bool has_id() const; + private: + bool _internal_has_id() const; + public: + void clear_id(); + uint32_t id() const; + void set_id(uint32_t value); + private: + uint32_t _internal_id() const; + void _internal_set_id(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.PreKeyRecordStructure) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr publickey_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr privatekey_; + uint32_t id_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Pushname final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Pushname) */ { + public: + inline Pushname() : Pushname(nullptr) {} + ~Pushname() override; + explicit PROTOBUF_CONSTEXPR Pushname(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Pushname(const Pushname& from); + Pushname(Pushname&& from) noexcept + : Pushname() { + *this = ::std::move(from); + } + + inline Pushname& operator=(const Pushname& from) { + CopyFrom(from); + return *this; + } + inline Pushname& operator=(Pushname&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Pushname& default_instance() { + return *internal_default_instance(); + } + static inline const Pushname* internal_default_instance() { + return reinterpret_cast( + &_Pushname_default_instance_); + } + static constexpr int kIndexInFileMessages = + 160; + + friend void swap(Pushname& a, Pushname& b) { + a.Swap(&b); + } + inline void Swap(Pushname* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Pushname* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Pushname* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Pushname& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Pushname& from) { + Pushname::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Pushname* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Pushname"; + } + protected: + explicit Pushname(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kIdFieldNumber = 1, + kPushnameFieldNumber = 2, + }; + // optional string id = 1; + bool has_id() const; + private: + bool _internal_has_id() const; + public: + void clear_id(); + const std::string& id() const; + template + void set_id(ArgT0&& arg0, ArgT... args); + std::string* mutable_id(); + PROTOBUF_NODISCARD std::string* release_id(); + void set_allocated_id(std::string* id); + private: + const std::string& _internal_id() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value); + std::string* _internal_mutable_id(); + public: + + // optional string pushname = 2; + bool has_pushname() const; + private: + bool _internal_has_pushname() const; + public: + void clear_pushname(); + const std::string& pushname() const; + template + void set_pushname(ArgT0&& arg0, ArgT... args); + std::string* mutable_pushname(); + PROTOBUF_NODISCARD std::string* release_pushname(); + void set_allocated_pushname(std::string* pushname); + private: + const std::string& _internal_pushname() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_pushname(const std::string& value); + std::string* _internal_mutable_pushname(); + public: + + // @@protoc_insertion_point(class_scope:proto.Pushname) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pushname_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class Reaction final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Reaction) */ { + public: + inline Reaction() : Reaction(nullptr) {} + ~Reaction() override; + explicit PROTOBUF_CONSTEXPR Reaction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Reaction(const Reaction& from); + Reaction(Reaction&& from) noexcept + : Reaction() { + *this = ::std::move(from); + } + + inline Reaction& operator=(const Reaction& from) { + CopyFrom(from); + return *this; + } + inline Reaction& operator=(Reaction&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Reaction& default_instance() { + return *internal_default_instance(); + } + static inline const Reaction* internal_default_instance() { + return reinterpret_cast( + &_Reaction_default_instance_); + } + static constexpr int kIndexInFileMessages = + 161; + + friend void swap(Reaction& a, Reaction& b) { + a.Swap(&b); + } + inline void Swap(Reaction* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Reaction* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Reaction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const Reaction& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const Reaction& from) { + Reaction::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Reaction* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.Reaction"; + } + protected: + explicit Reaction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kTextFieldNumber = 2, + kGroupingKeyFieldNumber = 3, + kKeyFieldNumber = 1, + kSenderTimestampMsFieldNumber = 4, + kUnreadFieldNumber = 5, + }; + // optional string text = 2; + bool has_text() const; + private: + bool _internal_has_text() const; + public: + void clear_text(); + const std::string& text() const; + template + void set_text(ArgT0&& arg0, ArgT... args); + std::string* mutable_text(); + PROTOBUF_NODISCARD std::string* release_text(); + void set_allocated_text(std::string* text); + private: + const std::string& _internal_text() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value); + std::string* _internal_mutable_text(); + public: + + // optional string groupingKey = 3; + bool has_groupingkey() const; + private: + bool _internal_has_groupingkey() const; + public: + void clear_groupingkey(); + const std::string& groupingkey() const; + template + void set_groupingkey(ArgT0&& arg0, ArgT... args); + std::string* mutable_groupingkey(); + PROTOBUF_NODISCARD std::string* release_groupingkey(); + void set_allocated_groupingkey(std::string* groupingkey); + private: + const std::string& _internal_groupingkey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_groupingkey(const std::string& value); + std::string* _internal_mutable_groupingkey(); + public: + + // optional .proto.MessageKey key = 1; + bool has_key() const; + private: + bool _internal_has_key() const; + public: + void clear_key(); + const ::proto::MessageKey& key() const; + PROTOBUF_NODISCARD ::proto::MessageKey* release_key(); + ::proto::MessageKey* mutable_key(); + void set_allocated_key(::proto::MessageKey* key); + private: + const ::proto::MessageKey& _internal_key() const; + ::proto::MessageKey* _internal_mutable_key(); + public: + void unsafe_arena_set_allocated_key( + ::proto::MessageKey* key); + ::proto::MessageKey* unsafe_arena_release_key(); + + // optional int64 senderTimestampMs = 4; + bool has_sendertimestampms() const; + private: + bool _internal_has_sendertimestampms() const; + public: + void clear_sendertimestampms(); + int64_t sendertimestampms() const; + void set_sendertimestampms(int64_t value); + private: + int64_t _internal_sendertimestampms() const; + void _internal_set_sendertimestampms(int64_t value); + public: + + // optional bool unread = 5; + bool has_unread() const; + private: + bool _internal_has_unread() const; + public: + void clear_unread(); + bool unread() const; + void set_unread(bool value); + private: + bool _internal_unread() const; + void _internal_set_unread(bool value); + public: + + // @@protoc_insertion_point(class_scope:proto.Reaction) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr groupingkey_; + ::proto::MessageKey* key_; + int64_t sendertimestampms_; + bool unread_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class RecentEmojiWeight final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.RecentEmojiWeight) */ { + public: + inline RecentEmojiWeight() : RecentEmojiWeight(nullptr) {} + ~RecentEmojiWeight() override; + explicit PROTOBUF_CONSTEXPR RecentEmojiWeight(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + RecentEmojiWeight(const RecentEmojiWeight& from); + RecentEmojiWeight(RecentEmojiWeight&& from) noexcept + : RecentEmojiWeight() { + *this = ::std::move(from); + } + + inline RecentEmojiWeight& operator=(const RecentEmojiWeight& from) { + CopyFrom(from); + return *this; + } + inline RecentEmojiWeight& operator=(RecentEmojiWeight&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const RecentEmojiWeight& default_instance() { + return *internal_default_instance(); + } + static inline const RecentEmojiWeight* internal_default_instance() { + return reinterpret_cast( + &_RecentEmojiWeight_default_instance_); + } + static constexpr int kIndexInFileMessages = + 162; + + friend void swap(RecentEmojiWeight& a, RecentEmojiWeight& b) { + a.Swap(&b); + } + inline void Swap(RecentEmojiWeight* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RecentEmojiWeight* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RecentEmojiWeight* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const RecentEmojiWeight& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const RecentEmojiWeight& from) { + RecentEmojiWeight::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(RecentEmojiWeight* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.RecentEmojiWeight"; + } + protected: + explicit RecentEmojiWeight(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kEmojiFieldNumber = 1, + kWeightFieldNumber = 2, + }; + // optional string emoji = 1; + bool has_emoji() const; + private: + bool _internal_has_emoji() const; + public: + void clear_emoji(); + const std::string& emoji() const; + template + void set_emoji(ArgT0&& arg0, ArgT... args); + std::string* mutable_emoji(); + PROTOBUF_NODISCARD std::string* release_emoji(); + void set_allocated_emoji(std::string* emoji); + private: + const std::string& _internal_emoji() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_emoji(const std::string& value); + std::string* _internal_mutable_emoji(); + public: + + // optional float weight = 2; + bool has_weight() const; + private: + bool _internal_has_weight() const; + public: + void clear_weight(); + float weight() const; + void set_weight(float value); + private: + float _internal_weight() const; + void _internal_set_weight(float value); + public: + + // @@protoc_insertion_point(class_scope:proto.RecentEmojiWeight) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr emoji_; + float weight_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class RecordStructure final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.RecordStructure) */ { + public: + inline RecordStructure() : RecordStructure(nullptr) {} + ~RecordStructure() override; + explicit PROTOBUF_CONSTEXPR RecordStructure(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + RecordStructure(const RecordStructure& from); + RecordStructure(RecordStructure&& from) noexcept + : RecordStructure() { + *this = ::std::move(from); + } + + inline RecordStructure& operator=(const RecordStructure& from) { + CopyFrom(from); + return *this; + } + inline RecordStructure& operator=(RecordStructure&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const RecordStructure& default_instance() { + return *internal_default_instance(); + } + static inline const RecordStructure* internal_default_instance() { + return reinterpret_cast( + &_RecordStructure_default_instance_); + } + static constexpr int kIndexInFileMessages = + 163; + + friend void swap(RecordStructure& a, RecordStructure& b) { + a.Swap(&b); + } + inline void Swap(RecordStructure* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RecordStructure* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RecordStructure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const RecordStructure& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const RecordStructure& from) { + RecordStructure::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(RecordStructure* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.RecordStructure"; + } + protected: + explicit RecordStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kPreviousSessionsFieldNumber = 2, + kCurrentSessionFieldNumber = 1, + }; + // repeated .proto.SessionStructure previousSessions = 2; + int previoussessions_size() const; + private: + int _internal_previoussessions_size() const; + public: + void clear_previoussessions(); + ::proto::SessionStructure* mutable_previoussessions(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SessionStructure >* + mutable_previoussessions(); + private: + const ::proto::SessionStructure& _internal_previoussessions(int index) const; + ::proto::SessionStructure* _internal_add_previoussessions(); + public: + const ::proto::SessionStructure& previoussessions(int index) const; + ::proto::SessionStructure* add_previoussessions(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SessionStructure >& + previoussessions() const; + + // optional .proto.SessionStructure currentSession = 1; + bool has_currentsession() const; + private: + bool _internal_has_currentsession() const; + public: + void clear_currentsession(); + const ::proto::SessionStructure& currentsession() const; + PROTOBUF_NODISCARD ::proto::SessionStructure* release_currentsession(); + ::proto::SessionStructure* mutable_currentsession(); + void set_allocated_currentsession(::proto::SessionStructure* currentsession); + private: + const ::proto::SessionStructure& _internal_currentsession() const; + ::proto::SessionStructure* _internal_mutable_currentsession(); + public: + void unsafe_arena_set_allocated_currentsession( + ::proto::SessionStructure* currentsession); + ::proto::SessionStructure* unsafe_arena_release_currentsession(); + + // @@protoc_insertion_point(class_scope:proto.RecordStructure) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SessionStructure > previoussessions_; + ::proto::SessionStructure* currentsession_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SenderChainKey final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SenderChainKey) */ { + public: + inline SenderChainKey() : SenderChainKey(nullptr) {} + ~SenderChainKey() override; + explicit PROTOBUF_CONSTEXPR SenderChainKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SenderChainKey(const SenderChainKey& from); + SenderChainKey(SenderChainKey&& from) noexcept + : SenderChainKey() { + *this = ::std::move(from); + } + + inline SenderChainKey& operator=(const SenderChainKey& from) { + CopyFrom(from); + return *this; + } + inline SenderChainKey& operator=(SenderChainKey&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SenderChainKey& default_instance() { + return *internal_default_instance(); + } + static inline const SenderChainKey* internal_default_instance() { + return reinterpret_cast( + &_SenderChainKey_default_instance_); + } + static constexpr int kIndexInFileMessages = + 164; + + friend void swap(SenderChainKey& a, SenderChainKey& b) { + a.Swap(&b); + } + inline void Swap(SenderChainKey* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SenderChainKey* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SenderChainKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SenderChainKey& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SenderChainKey& from) { + SenderChainKey::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SenderChainKey* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SenderChainKey"; + } + protected: + explicit SenderChainKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSeedFieldNumber = 2, + kIterationFieldNumber = 1, + }; + // optional bytes seed = 2; + bool has_seed() const; + private: + bool _internal_has_seed() const; + public: + void clear_seed(); + const std::string& seed() const; + template + void set_seed(ArgT0&& arg0, ArgT... args); + std::string* mutable_seed(); + PROTOBUF_NODISCARD std::string* release_seed(); + void set_allocated_seed(std::string* seed); + private: + const std::string& _internal_seed() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_seed(const std::string& value); + std::string* _internal_mutable_seed(); + public: + + // optional uint32 iteration = 1; + bool has_iteration() const; + private: + bool _internal_has_iteration() const; + public: + void clear_iteration(); + uint32_t iteration() const; + void set_iteration(uint32_t value); + private: + uint32_t _internal_iteration() const; + void _internal_set_iteration(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.SenderChainKey) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr seed_; + uint32_t iteration_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SenderKeyRecordStructure final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SenderKeyRecordStructure) */ { + public: + inline SenderKeyRecordStructure() : SenderKeyRecordStructure(nullptr) {} + ~SenderKeyRecordStructure() override; + explicit PROTOBUF_CONSTEXPR SenderKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SenderKeyRecordStructure(const SenderKeyRecordStructure& from); + SenderKeyRecordStructure(SenderKeyRecordStructure&& from) noexcept + : SenderKeyRecordStructure() { + *this = ::std::move(from); + } + + inline SenderKeyRecordStructure& operator=(const SenderKeyRecordStructure& from) { + CopyFrom(from); + return *this; + } + inline SenderKeyRecordStructure& operator=(SenderKeyRecordStructure&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SenderKeyRecordStructure& default_instance() { + return *internal_default_instance(); + } + static inline const SenderKeyRecordStructure* internal_default_instance() { + return reinterpret_cast( + &_SenderKeyRecordStructure_default_instance_); + } + static constexpr int kIndexInFileMessages = + 165; + + friend void swap(SenderKeyRecordStructure& a, SenderKeyRecordStructure& b) { + a.Swap(&b); + } + inline void Swap(SenderKeyRecordStructure* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SenderKeyRecordStructure* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SenderKeyRecordStructure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SenderKeyRecordStructure& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SenderKeyRecordStructure& from) { + SenderKeyRecordStructure::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SenderKeyRecordStructure* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SenderKeyRecordStructure"; + } + protected: + explicit SenderKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSenderKeyStatesFieldNumber = 1, + }; + // repeated .proto.SenderKeyStateStructure senderKeyStates = 1; + int senderkeystates_size() const; + private: + int _internal_senderkeystates_size() const; + public: + void clear_senderkeystates(); + ::proto::SenderKeyStateStructure* mutable_senderkeystates(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderKeyStateStructure >* + mutable_senderkeystates(); + private: + const ::proto::SenderKeyStateStructure& _internal_senderkeystates(int index) const; + ::proto::SenderKeyStateStructure* _internal_add_senderkeystates(); + public: + const ::proto::SenderKeyStateStructure& senderkeystates(int index) const; + ::proto::SenderKeyStateStructure* add_senderkeystates(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderKeyStateStructure >& + senderkeystates() const; + + // @@protoc_insertion_point(class_scope:proto.SenderKeyRecordStructure) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderKeyStateStructure > senderkeystates_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SenderKeyStateStructure final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SenderKeyStateStructure) */ { + public: + inline SenderKeyStateStructure() : SenderKeyStateStructure(nullptr) {} + ~SenderKeyStateStructure() override; + explicit PROTOBUF_CONSTEXPR SenderKeyStateStructure(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SenderKeyStateStructure(const SenderKeyStateStructure& from); + SenderKeyStateStructure(SenderKeyStateStructure&& from) noexcept + : SenderKeyStateStructure() { + *this = ::std::move(from); + } + + inline SenderKeyStateStructure& operator=(const SenderKeyStateStructure& from) { + CopyFrom(from); + return *this; + } + inline SenderKeyStateStructure& operator=(SenderKeyStateStructure&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SenderKeyStateStructure& default_instance() { + return *internal_default_instance(); + } + static inline const SenderKeyStateStructure* internal_default_instance() { + return reinterpret_cast( + &_SenderKeyStateStructure_default_instance_); + } + static constexpr int kIndexInFileMessages = + 166; + + friend void swap(SenderKeyStateStructure& a, SenderKeyStateStructure& b) { + a.Swap(&b); + } + inline void Swap(SenderKeyStateStructure* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SenderKeyStateStructure* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SenderKeyStateStructure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SenderKeyStateStructure& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SenderKeyStateStructure& from) { + SenderKeyStateStructure::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SenderKeyStateStructure* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SenderKeyStateStructure"; + } + protected: + explicit SenderKeyStateStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSenderMessageKeysFieldNumber = 4, + kSenderChainKeyFieldNumber = 2, + kSenderSigningKeyFieldNumber = 3, + kSenderKeyIdFieldNumber = 1, + }; + // repeated .proto.SenderMessageKey senderMessageKeys = 4; + int sendermessagekeys_size() const; + private: + int _internal_sendermessagekeys_size() const; + public: + void clear_sendermessagekeys(); + ::proto::SenderMessageKey* mutable_sendermessagekeys(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderMessageKey >* + mutable_sendermessagekeys(); + private: + const ::proto::SenderMessageKey& _internal_sendermessagekeys(int index) const; + ::proto::SenderMessageKey* _internal_add_sendermessagekeys(); + public: + const ::proto::SenderMessageKey& sendermessagekeys(int index) const; + ::proto::SenderMessageKey* add_sendermessagekeys(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderMessageKey >& + sendermessagekeys() const; + + // optional .proto.SenderChainKey senderChainKey = 2; + bool has_senderchainkey() const; + private: + bool _internal_has_senderchainkey() const; + public: + void clear_senderchainkey(); + const ::proto::SenderChainKey& senderchainkey() const; + PROTOBUF_NODISCARD ::proto::SenderChainKey* release_senderchainkey(); + ::proto::SenderChainKey* mutable_senderchainkey(); + void set_allocated_senderchainkey(::proto::SenderChainKey* senderchainkey); + private: + const ::proto::SenderChainKey& _internal_senderchainkey() const; + ::proto::SenderChainKey* _internal_mutable_senderchainkey(); + public: + void unsafe_arena_set_allocated_senderchainkey( + ::proto::SenderChainKey* senderchainkey); + ::proto::SenderChainKey* unsafe_arena_release_senderchainkey(); + + // optional .proto.SenderSigningKey senderSigningKey = 3; + bool has_sendersigningkey() const; + private: + bool _internal_has_sendersigningkey() const; + public: + void clear_sendersigningkey(); + const ::proto::SenderSigningKey& sendersigningkey() const; + PROTOBUF_NODISCARD ::proto::SenderSigningKey* release_sendersigningkey(); + ::proto::SenderSigningKey* mutable_sendersigningkey(); + void set_allocated_sendersigningkey(::proto::SenderSigningKey* sendersigningkey); + private: + const ::proto::SenderSigningKey& _internal_sendersigningkey() const; + ::proto::SenderSigningKey* _internal_mutable_sendersigningkey(); + public: + void unsafe_arena_set_allocated_sendersigningkey( + ::proto::SenderSigningKey* sendersigningkey); + ::proto::SenderSigningKey* unsafe_arena_release_sendersigningkey(); + + // optional uint32 senderKeyId = 1; + bool has_senderkeyid() const; + private: + bool _internal_has_senderkeyid() const; + public: + void clear_senderkeyid(); + uint32_t senderkeyid() const; + void set_senderkeyid(uint32_t value); + private: + uint32_t _internal_senderkeyid() const; + void _internal_set_senderkeyid(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.SenderKeyStateStructure) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderMessageKey > sendermessagekeys_; + ::proto::SenderChainKey* senderchainkey_; + ::proto::SenderSigningKey* sendersigningkey_; + uint32_t senderkeyid_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SenderMessageKey final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SenderMessageKey) */ { + public: + inline SenderMessageKey() : SenderMessageKey(nullptr) {} + ~SenderMessageKey() override; + explicit PROTOBUF_CONSTEXPR SenderMessageKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SenderMessageKey(const SenderMessageKey& from); + SenderMessageKey(SenderMessageKey&& from) noexcept + : SenderMessageKey() { + *this = ::std::move(from); + } + + inline SenderMessageKey& operator=(const SenderMessageKey& from) { + CopyFrom(from); + return *this; + } + inline SenderMessageKey& operator=(SenderMessageKey&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SenderMessageKey& default_instance() { + return *internal_default_instance(); + } + static inline const SenderMessageKey* internal_default_instance() { + return reinterpret_cast( + &_SenderMessageKey_default_instance_); + } + static constexpr int kIndexInFileMessages = + 167; + + friend void swap(SenderMessageKey& a, SenderMessageKey& b) { + a.Swap(&b); + } + inline void Swap(SenderMessageKey* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SenderMessageKey* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SenderMessageKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SenderMessageKey& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SenderMessageKey& from) { + SenderMessageKey::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SenderMessageKey* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SenderMessageKey"; + } + protected: + explicit SenderMessageKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSeedFieldNumber = 2, + kIterationFieldNumber = 1, + }; + // optional bytes seed = 2; + bool has_seed() const; + private: + bool _internal_has_seed() const; + public: + void clear_seed(); + const std::string& seed() const; + template + void set_seed(ArgT0&& arg0, ArgT... args); + std::string* mutable_seed(); + PROTOBUF_NODISCARD std::string* release_seed(); + void set_allocated_seed(std::string* seed); + private: + const std::string& _internal_seed() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_seed(const std::string& value); + std::string* _internal_mutable_seed(); + public: + + // optional uint32 iteration = 1; + bool has_iteration() const; + private: + bool _internal_has_iteration() const; + public: + void clear_iteration(); + uint32_t iteration() const; + void set_iteration(uint32_t value); + private: + uint32_t _internal_iteration() const; + void _internal_set_iteration(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.SenderMessageKey) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr seed_; + uint32_t iteration_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SenderSigningKey final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SenderSigningKey) */ { + public: + inline SenderSigningKey() : SenderSigningKey(nullptr) {} + ~SenderSigningKey() override; + explicit PROTOBUF_CONSTEXPR SenderSigningKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SenderSigningKey(const SenderSigningKey& from); + SenderSigningKey(SenderSigningKey&& from) noexcept + : SenderSigningKey() { + *this = ::std::move(from); + } + + inline SenderSigningKey& operator=(const SenderSigningKey& from) { + CopyFrom(from); + return *this; + } + inline SenderSigningKey& operator=(SenderSigningKey&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SenderSigningKey& default_instance() { + return *internal_default_instance(); + } + static inline const SenderSigningKey* internal_default_instance() { + return reinterpret_cast( + &_SenderSigningKey_default_instance_); + } + static constexpr int kIndexInFileMessages = + 168; + + friend void swap(SenderSigningKey& a, SenderSigningKey& b) { + a.Swap(&b); + } + inline void Swap(SenderSigningKey* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SenderSigningKey* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SenderSigningKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SenderSigningKey& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SenderSigningKey& from) { + SenderSigningKey::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SenderSigningKey* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SenderSigningKey"; + } + protected: + explicit SenderSigningKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kPublicFieldNumber = 1, + kPrivateFieldNumber = 2, + }; + // optional bytes public = 1; + bool has_public_() const; + private: + bool _internal_has_public_() const; + public: + void clear_public_(); + const std::string& public_() const; + template + void set_public_(ArgT0&& arg0, ArgT... args); + std::string* mutable_public_(); + PROTOBUF_NODISCARD std::string* release_public_(); + void set_allocated_public_(std::string* public_); + private: + const std::string& _internal_public_() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_public_(const std::string& value); + std::string* _internal_mutable_public_(); + public: + + // optional bytes private = 2; + bool has_private_() const; + private: + bool _internal_has_private_() const; + public: + void clear_private_(); + const std::string& private_() const; + template + void set_private_(ArgT0&& arg0, ArgT... args); + std::string* mutable_private_(); + PROTOBUF_NODISCARD std::string* release_private_(); + void set_allocated_private_(std::string* private_); + private: + const std::string& _internal_private_() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_private_(const std::string& value); + std::string* _internal_mutable_private_(); + public: + + // @@protoc_insertion_point(class_scope:proto.SenderSigningKey) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr public__; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr private__; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class ServerErrorReceipt final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ServerErrorReceipt) */ { + public: + inline ServerErrorReceipt() : ServerErrorReceipt(nullptr) {} + ~ServerErrorReceipt() override; + explicit PROTOBUF_CONSTEXPR ServerErrorReceipt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ServerErrorReceipt(const ServerErrorReceipt& from); + ServerErrorReceipt(ServerErrorReceipt&& from) noexcept + : ServerErrorReceipt() { + *this = ::std::move(from); + } + + inline ServerErrorReceipt& operator=(const ServerErrorReceipt& from) { + CopyFrom(from); + return *this; + } + inline ServerErrorReceipt& operator=(ServerErrorReceipt&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ServerErrorReceipt& default_instance() { + return *internal_default_instance(); + } + static inline const ServerErrorReceipt* internal_default_instance() { + return reinterpret_cast( + &_ServerErrorReceipt_default_instance_); + } + static constexpr int kIndexInFileMessages = + 169; + + friend void swap(ServerErrorReceipt& a, ServerErrorReceipt& b) { + a.Swap(&b); + } + inline void Swap(ServerErrorReceipt* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ServerErrorReceipt* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ServerErrorReceipt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const ServerErrorReceipt& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const ServerErrorReceipt& from) { + ServerErrorReceipt::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ServerErrorReceipt* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.ServerErrorReceipt"; + } + protected: + explicit ServerErrorReceipt(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kStanzaIdFieldNumber = 1, + }; + // optional string stanzaId = 1; + bool has_stanzaid() const; + private: + bool _internal_has_stanzaid() const; + public: + void clear_stanzaid(); + const std::string& stanzaid() const; + template + void set_stanzaid(ArgT0&& arg0, ArgT... args); + std::string* mutable_stanzaid(); + PROTOBUF_NODISCARD std::string* release_stanzaid(); + void set_allocated_stanzaid(std::string* stanzaid); + private: + const std::string& _internal_stanzaid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_stanzaid(const std::string& value); + std::string* _internal_mutable_stanzaid(); + public: + + // @@protoc_insertion_point(class_scope:proto.ServerErrorReceipt) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr stanzaid_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SessionStructure final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SessionStructure) */ { + public: + inline SessionStructure() : SessionStructure(nullptr) {} + ~SessionStructure() override; + explicit PROTOBUF_CONSTEXPR SessionStructure(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SessionStructure(const SessionStructure& from); + SessionStructure(SessionStructure&& from) noexcept + : SessionStructure() { + *this = ::std::move(from); + } + + inline SessionStructure& operator=(const SessionStructure& from) { + CopyFrom(from); + return *this; + } + inline SessionStructure& operator=(SessionStructure&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SessionStructure& default_instance() { + return *internal_default_instance(); + } + static inline const SessionStructure* internal_default_instance() { + return reinterpret_cast( + &_SessionStructure_default_instance_); + } + static constexpr int kIndexInFileMessages = + 170; + + friend void swap(SessionStructure& a, SessionStructure& b) { + a.Swap(&b); + } + inline void Swap(SessionStructure* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SessionStructure* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SessionStructure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SessionStructure& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SessionStructure& from) { + SessionStructure::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SessionStructure* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SessionStructure"; + } + protected: + explicit SessionStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kReceiverChainsFieldNumber = 7, + kLocalIdentityPublicFieldNumber = 2, + kRemoteIdentityPublicFieldNumber = 3, + kRootKeyFieldNumber = 4, + kAliceBaseKeyFieldNumber = 13, + kSenderChainFieldNumber = 6, + kPendingKeyExchangeFieldNumber = 8, + kPendingPreKeyFieldNumber = 9, + kSessionVersionFieldNumber = 1, + kPreviousCounterFieldNumber = 5, + kRemoteRegistrationIdFieldNumber = 10, + kLocalRegistrationIdFieldNumber = 11, + kNeedsRefreshFieldNumber = 12, + }; + // repeated .proto.Chain receiverChains = 7; + int receiverchains_size() const; + private: + int _internal_receiverchains_size() const; + public: + void clear_receiverchains(); + ::proto::Chain* mutable_receiverchains(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Chain >* + mutable_receiverchains(); + private: + const ::proto::Chain& _internal_receiverchains(int index) const; + ::proto::Chain* _internal_add_receiverchains(); + public: + const ::proto::Chain& receiverchains(int index) const; + ::proto::Chain* add_receiverchains(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Chain >& + receiverchains() const; + + // optional bytes localIdentityPublic = 2; + bool has_localidentitypublic() const; + private: + bool _internal_has_localidentitypublic() const; + public: + void clear_localidentitypublic(); + const std::string& localidentitypublic() const; + template + void set_localidentitypublic(ArgT0&& arg0, ArgT... args); + std::string* mutable_localidentitypublic(); + PROTOBUF_NODISCARD std::string* release_localidentitypublic(); + void set_allocated_localidentitypublic(std::string* localidentitypublic); + private: + const std::string& _internal_localidentitypublic() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_localidentitypublic(const std::string& value); + std::string* _internal_mutable_localidentitypublic(); + public: + + // optional bytes remoteIdentityPublic = 3; + bool has_remoteidentitypublic() const; + private: + bool _internal_has_remoteidentitypublic() const; + public: + void clear_remoteidentitypublic(); + const std::string& remoteidentitypublic() const; + template + void set_remoteidentitypublic(ArgT0&& arg0, ArgT... args); + std::string* mutable_remoteidentitypublic(); + PROTOBUF_NODISCARD std::string* release_remoteidentitypublic(); + void set_allocated_remoteidentitypublic(std::string* remoteidentitypublic); + private: + const std::string& _internal_remoteidentitypublic() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_remoteidentitypublic(const std::string& value); + std::string* _internal_mutable_remoteidentitypublic(); + public: + + // optional bytes rootKey = 4; + bool has_rootkey() const; + private: + bool _internal_has_rootkey() const; + public: + void clear_rootkey(); + const std::string& rootkey() const; + template + void set_rootkey(ArgT0&& arg0, ArgT... args); + std::string* mutable_rootkey(); + PROTOBUF_NODISCARD std::string* release_rootkey(); + void set_allocated_rootkey(std::string* rootkey); + private: + const std::string& _internal_rootkey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_rootkey(const std::string& value); + std::string* _internal_mutable_rootkey(); + public: + + // optional bytes aliceBaseKey = 13; + bool has_alicebasekey() const; + private: + bool _internal_has_alicebasekey() const; + public: + void clear_alicebasekey(); + const std::string& alicebasekey() const; + template + void set_alicebasekey(ArgT0&& arg0, ArgT... args); + std::string* mutable_alicebasekey(); + PROTOBUF_NODISCARD std::string* release_alicebasekey(); + void set_allocated_alicebasekey(std::string* alicebasekey); + private: + const std::string& _internal_alicebasekey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_alicebasekey(const std::string& value); + std::string* _internal_mutable_alicebasekey(); + public: + + // optional .proto.Chain senderChain = 6; + bool has_senderchain() const; + private: + bool _internal_has_senderchain() const; + public: + void clear_senderchain(); + const ::proto::Chain& senderchain() const; + PROTOBUF_NODISCARD ::proto::Chain* release_senderchain(); + ::proto::Chain* mutable_senderchain(); + void set_allocated_senderchain(::proto::Chain* senderchain); + private: + const ::proto::Chain& _internal_senderchain() const; + ::proto::Chain* _internal_mutable_senderchain(); + public: + void unsafe_arena_set_allocated_senderchain( + ::proto::Chain* senderchain); + ::proto::Chain* unsafe_arena_release_senderchain(); + + // optional .proto.PendingKeyExchange pendingKeyExchange = 8; + bool has_pendingkeyexchange() const; + private: + bool _internal_has_pendingkeyexchange() const; + public: + void clear_pendingkeyexchange(); + const ::proto::PendingKeyExchange& pendingkeyexchange() const; + PROTOBUF_NODISCARD ::proto::PendingKeyExchange* release_pendingkeyexchange(); + ::proto::PendingKeyExchange* mutable_pendingkeyexchange(); + void set_allocated_pendingkeyexchange(::proto::PendingKeyExchange* pendingkeyexchange); + private: + const ::proto::PendingKeyExchange& _internal_pendingkeyexchange() const; + ::proto::PendingKeyExchange* _internal_mutable_pendingkeyexchange(); + public: + void unsafe_arena_set_allocated_pendingkeyexchange( + ::proto::PendingKeyExchange* pendingkeyexchange); + ::proto::PendingKeyExchange* unsafe_arena_release_pendingkeyexchange(); + + // optional .proto.PendingPreKey pendingPreKey = 9; + bool has_pendingprekey() const; + private: + bool _internal_has_pendingprekey() const; + public: + void clear_pendingprekey(); + const ::proto::PendingPreKey& pendingprekey() const; + PROTOBUF_NODISCARD ::proto::PendingPreKey* release_pendingprekey(); + ::proto::PendingPreKey* mutable_pendingprekey(); + void set_allocated_pendingprekey(::proto::PendingPreKey* pendingprekey); + private: + const ::proto::PendingPreKey& _internal_pendingprekey() const; + ::proto::PendingPreKey* _internal_mutable_pendingprekey(); + public: + void unsafe_arena_set_allocated_pendingprekey( + ::proto::PendingPreKey* pendingprekey); + ::proto::PendingPreKey* unsafe_arena_release_pendingprekey(); + + // optional uint32 sessionVersion = 1; + bool has_sessionversion() const; + private: + bool _internal_has_sessionversion() const; + public: + void clear_sessionversion(); + uint32_t sessionversion() const; + void set_sessionversion(uint32_t value); + private: + uint32_t _internal_sessionversion() const; + void _internal_set_sessionversion(uint32_t value); + public: + + // optional uint32 previousCounter = 5; + bool has_previouscounter() const; + private: + bool _internal_has_previouscounter() const; + public: + void clear_previouscounter(); + uint32_t previouscounter() const; + void set_previouscounter(uint32_t value); + private: + uint32_t _internal_previouscounter() const; + void _internal_set_previouscounter(uint32_t value); + public: + + // optional uint32 remoteRegistrationId = 10; + bool has_remoteregistrationid() const; + private: + bool _internal_has_remoteregistrationid() const; + public: + void clear_remoteregistrationid(); + uint32_t remoteregistrationid() const; + void set_remoteregistrationid(uint32_t value); + private: + uint32_t _internal_remoteregistrationid() const; + void _internal_set_remoteregistrationid(uint32_t value); + public: + + // optional uint32 localRegistrationId = 11; + bool has_localregistrationid() const; + private: + bool _internal_has_localregistrationid() const; + public: + void clear_localregistrationid(); + uint32_t localregistrationid() const; + void set_localregistrationid(uint32_t value); + private: + uint32_t _internal_localregistrationid() const; + void _internal_set_localregistrationid(uint32_t value); + public: + + // optional bool needsRefresh = 12; + bool has_needsrefresh() const; + private: + bool _internal_has_needsrefresh() const; + public: + void clear_needsrefresh(); + bool needsrefresh() const; + void set_needsrefresh(bool value); + private: + bool _internal_needsrefresh() const; + void _internal_set_needsrefresh(bool value); + public: + + // @@protoc_insertion_point(class_scope:proto.SessionStructure) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Chain > receiverchains_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localidentitypublic_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr remoteidentitypublic_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rootkey_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr alicebasekey_; + ::proto::Chain* senderchain_; + ::proto::PendingKeyExchange* pendingkeyexchange_; + ::proto::PendingPreKey* pendingprekey_; + uint32_t sessionversion_; + uint32_t previouscounter_; + uint32_t remoteregistrationid_; + uint32_t localregistrationid_; + bool needsrefresh_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SignedPreKeyRecordStructure final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SignedPreKeyRecordStructure) */ { + public: + inline SignedPreKeyRecordStructure() : SignedPreKeyRecordStructure(nullptr) {} + ~SignedPreKeyRecordStructure() override; + explicit PROTOBUF_CONSTEXPR SignedPreKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SignedPreKeyRecordStructure(const SignedPreKeyRecordStructure& from); + SignedPreKeyRecordStructure(SignedPreKeyRecordStructure&& from) noexcept + : SignedPreKeyRecordStructure() { + *this = ::std::move(from); + } + + inline SignedPreKeyRecordStructure& operator=(const SignedPreKeyRecordStructure& from) { + CopyFrom(from); + return *this; + } + inline SignedPreKeyRecordStructure& operator=(SignedPreKeyRecordStructure&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SignedPreKeyRecordStructure& default_instance() { + return *internal_default_instance(); + } + static inline const SignedPreKeyRecordStructure* internal_default_instance() { + return reinterpret_cast( + &_SignedPreKeyRecordStructure_default_instance_); + } + static constexpr int kIndexInFileMessages = + 171; + + friend void swap(SignedPreKeyRecordStructure& a, SignedPreKeyRecordStructure& b) { + a.Swap(&b); + } + inline void Swap(SignedPreKeyRecordStructure* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SignedPreKeyRecordStructure* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SignedPreKeyRecordStructure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SignedPreKeyRecordStructure& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SignedPreKeyRecordStructure& from) { + SignedPreKeyRecordStructure::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SignedPreKeyRecordStructure* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SignedPreKeyRecordStructure"; + } + protected: + explicit SignedPreKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kPublicKeyFieldNumber = 2, + kPrivateKeyFieldNumber = 3, + kSignatureFieldNumber = 4, + kTimestampFieldNumber = 5, + kIdFieldNumber = 1, + }; + // optional bytes publicKey = 2; + bool has_publickey() const; + private: + bool _internal_has_publickey() const; + public: + void clear_publickey(); + const std::string& publickey() const; + template + void set_publickey(ArgT0&& arg0, ArgT... args); + std::string* mutable_publickey(); + PROTOBUF_NODISCARD std::string* release_publickey(); + void set_allocated_publickey(std::string* publickey); + private: + const std::string& _internal_publickey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_publickey(const std::string& value); + std::string* _internal_mutable_publickey(); + public: + + // optional bytes privateKey = 3; + bool has_privatekey() const; + private: + bool _internal_has_privatekey() const; + public: + void clear_privatekey(); + const std::string& privatekey() const; + template + void set_privatekey(ArgT0&& arg0, ArgT... args); + std::string* mutable_privatekey(); + PROTOBUF_NODISCARD std::string* release_privatekey(); + void set_allocated_privatekey(std::string* privatekey); + private: + const std::string& _internal_privatekey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_privatekey(const std::string& value); + std::string* _internal_mutable_privatekey(); + public: + + // optional bytes signature = 4; + bool has_signature() const; + private: + bool _internal_has_signature() const; + public: + void clear_signature(); + const std::string& signature() const; + template + void set_signature(ArgT0&& arg0, ArgT... args); + std::string* mutable_signature(); + PROTOBUF_NODISCARD std::string* release_signature(); + void set_allocated_signature(std::string* signature); + private: + const std::string& _internal_signature() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value); + std::string* _internal_mutable_signature(); + public: + + // optional fixed64 timestamp = 5; + bool has_timestamp() const; + private: + bool _internal_has_timestamp() const; + public: + void clear_timestamp(); + uint64_t timestamp() const; + void set_timestamp(uint64_t value); + private: + uint64_t _internal_timestamp() const; + void _internal_set_timestamp(uint64_t value); + public: + + // optional uint32 id = 1; + bool has_id() const; + private: + bool _internal_has_id() const; + public: + void clear_id(); + uint32_t id() const; + void set_id(uint32_t value); + private: + uint32_t _internal_id() const; + void _internal_set_id(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.SignedPreKeyRecordStructure) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr publickey_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr privatekey_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_; + uint64_t timestamp_; + uint32_t id_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class StatusPSA final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.StatusPSA) */ { + public: + inline StatusPSA() : StatusPSA(nullptr) {} + ~StatusPSA() override; + explicit PROTOBUF_CONSTEXPR StatusPSA(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + StatusPSA(const StatusPSA& from); + StatusPSA(StatusPSA&& from) noexcept + : StatusPSA() { + *this = ::std::move(from); + } + + inline StatusPSA& operator=(const StatusPSA& from) { + CopyFrom(from); + return *this; + } + inline StatusPSA& operator=(StatusPSA&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const StatusPSA& default_instance() { + return *internal_default_instance(); + } + static inline const StatusPSA* internal_default_instance() { + return reinterpret_cast( + &_StatusPSA_default_instance_); + } + static constexpr int kIndexInFileMessages = + 172; + + friend void swap(StatusPSA& a, StatusPSA& b) { + a.Swap(&b); + } + inline void Swap(StatusPSA* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(StatusPSA* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + StatusPSA* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const StatusPSA& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const StatusPSA& from) { + StatusPSA::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(StatusPSA* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.StatusPSA"; + } + protected: + explicit StatusPSA(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kCampaignIdFieldNumber = 44, + kCampaignExpirationTimestampFieldNumber = 45, + }; + // required uint64 campaignId = 44; + bool has_campaignid() const; + private: + bool _internal_has_campaignid() const; + public: + void clear_campaignid(); + uint64_t campaignid() const; + void set_campaignid(uint64_t value); + private: + uint64_t _internal_campaignid() const; + void _internal_set_campaignid(uint64_t value); + public: + + // optional uint64 campaignExpirationTimestamp = 45; + bool has_campaignexpirationtimestamp() const; + private: + bool _internal_has_campaignexpirationtimestamp() const; + public: + void clear_campaignexpirationtimestamp(); + uint64_t campaignexpirationtimestamp() const; + void set_campaignexpirationtimestamp(uint64_t value); + private: + uint64_t _internal_campaignexpirationtimestamp() const; + void _internal_set_campaignexpirationtimestamp(uint64_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.StatusPSA) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + uint64_t campaignid_; + uint64_t campaignexpirationtimestamp_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class StickerMetadata final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.StickerMetadata) */ { + public: + inline StickerMetadata() : StickerMetadata(nullptr) {} + ~StickerMetadata() override; + explicit PROTOBUF_CONSTEXPR StickerMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + StickerMetadata(const StickerMetadata& from); + StickerMetadata(StickerMetadata&& from) noexcept + : StickerMetadata() { + *this = ::std::move(from); + } + + inline StickerMetadata& operator=(const StickerMetadata& from) { + CopyFrom(from); + return *this; + } + inline StickerMetadata& operator=(StickerMetadata&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const StickerMetadata& default_instance() { + return *internal_default_instance(); + } + static inline const StickerMetadata* internal_default_instance() { + return reinterpret_cast( + &_StickerMetadata_default_instance_); + } + static constexpr int kIndexInFileMessages = + 173; + + friend void swap(StickerMetadata& a, StickerMetadata& b) { + a.Swap(&b); + } + inline void Swap(StickerMetadata* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(StickerMetadata* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + StickerMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const StickerMetadata& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const StickerMetadata& from) { + StickerMetadata::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(StickerMetadata* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.StickerMetadata"; + } + protected: + explicit StickerMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kUrlFieldNumber = 1, + kFileSha256FieldNumber = 2, + kFileEncSha256FieldNumber = 3, + kMediaKeyFieldNumber = 4, + kMimetypeFieldNumber = 5, + kDirectPathFieldNumber = 8, + kHeightFieldNumber = 6, + kWidthFieldNumber = 7, + kFileLengthFieldNumber = 9, + kWeightFieldNumber = 10, + }; + // optional string url = 1; + bool has_url() const; + private: + bool _internal_has_url() const; + public: + void clear_url(); + const std::string& url() const; + template + void set_url(ArgT0&& arg0, ArgT... args); + std::string* mutable_url(); + PROTOBUF_NODISCARD std::string* release_url(); + void set_allocated_url(std::string* url); + private: + const std::string& _internal_url() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value); + std::string* _internal_mutable_url(); + public: + + // optional bytes fileSha256 = 2; + bool has_filesha256() const; + private: + bool _internal_has_filesha256() const; + public: + void clear_filesha256(); + const std::string& filesha256() const; + template + void set_filesha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_filesha256(); + PROTOBUF_NODISCARD std::string* release_filesha256(); + void set_allocated_filesha256(std::string* filesha256); + private: + const std::string& _internal_filesha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value); + std::string* _internal_mutable_filesha256(); + public: + + // optional bytes fileEncSha256 = 3; + bool has_fileencsha256() const; + private: + bool _internal_has_fileencsha256() const; + public: + void clear_fileencsha256(); + const std::string& fileencsha256() const; + template + void set_fileencsha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_fileencsha256(); + PROTOBUF_NODISCARD std::string* release_fileencsha256(); + void set_allocated_fileencsha256(std::string* fileencsha256); + private: + const std::string& _internal_fileencsha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value); + std::string* _internal_mutable_fileencsha256(); + public: + + // optional bytes mediaKey = 4; + bool has_mediakey() const; + private: + bool _internal_has_mediakey() const; + public: + void clear_mediakey(); + const std::string& mediakey() const; + template + void set_mediakey(ArgT0&& arg0, ArgT... args); + std::string* mutable_mediakey(); + PROTOBUF_NODISCARD std::string* release_mediakey(); + void set_allocated_mediakey(std::string* mediakey); + private: + const std::string& _internal_mediakey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value); + std::string* _internal_mutable_mediakey(); + public: + + // optional string mimetype = 5; + bool has_mimetype() const; + private: + bool _internal_has_mimetype() const; + public: + void clear_mimetype(); + const std::string& mimetype() const; + template + void set_mimetype(ArgT0&& arg0, ArgT... args); + std::string* mutable_mimetype(); + PROTOBUF_NODISCARD std::string* release_mimetype(); + void set_allocated_mimetype(std::string* mimetype); + private: + const std::string& _internal_mimetype() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value); + std::string* _internal_mutable_mimetype(); + public: + + // optional string directPath = 8; + bool has_directpath() const; + private: + bool _internal_has_directpath() const; + public: + void clear_directpath(); + const std::string& directpath() const; + template + void set_directpath(ArgT0&& arg0, ArgT... args); + std::string* mutable_directpath(); + PROTOBUF_NODISCARD std::string* release_directpath(); + void set_allocated_directpath(std::string* directpath); + private: + const std::string& _internal_directpath() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value); + std::string* _internal_mutable_directpath(); + public: + + // optional uint32 height = 6; + bool has_height() const; + private: + bool _internal_has_height() const; + public: + void clear_height(); + uint32_t height() const; + void set_height(uint32_t value); + private: + uint32_t _internal_height() const; + void _internal_set_height(uint32_t value); + public: + + // optional uint32 width = 7; + bool has_width() const; + private: + bool _internal_has_width() const; + public: + void clear_width(); + uint32_t width() const; + void set_width(uint32_t value); + private: + uint32_t _internal_width() const; + void _internal_set_width(uint32_t value); + public: + + // optional uint64 fileLength = 9; + bool has_filelength() const; + private: + bool _internal_has_filelength() const; + public: + void clear_filelength(); + uint64_t filelength() const; + void set_filelength(uint64_t value); + private: + uint64_t _internal_filelength() const; + void _internal_set_filelength(uint64_t value); + public: + + // optional float weight = 10; + bool has_weight() const; + private: + bool _internal_has_weight() const; + public: + void clear_weight(); + float weight() const; + void set_weight(float value); + private: + float _internal_weight() const; + void _internal_set_weight(float value); + public: + + // @@protoc_insertion_point(class_scope:proto.StickerMetadata) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mimetype_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_; + uint32_t height_; + uint32_t width_; + uint64_t filelength_; + float weight_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncActionData final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionData) */ { + public: + inline SyncActionData() : SyncActionData(nullptr) {} + ~SyncActionData() override; + explicit PROTOBUF_CONSTEXPR SyncActionData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncActionData(const SyncActionData& from); + SyncActionData(SyncActionData&& from) noexcept + : SyncActionData() { + *this = ::std::move(from); + } + + inline SyncActionData& operator=(const SyncActionData& from) { + CopyFrom(from); + return *this; + } + inline SyncActionData& operator=(SyncActionData&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncActionData& default_instance() { + return *internal_default_instance(); + } + static inline const SyncActionData* internal_default_instance() { + return reinterpret_cast( + &_SyncActionData_default_instance_); + } + static constexpr int kIndexInFileMessages = + 174; + + friend void swap(SyncActionData& a, SyncActionData& b) { + a.Swap(&b); + } + inline void Swap(SyncActionData* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncActionData* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncActionData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncActionData& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncActionData& from) { + SyncActionData::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncActionData* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncActionData"; + } + protected: + explicit SyncActionData(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kIndexFieldNumber = 1, + kPaddingFieldNumber = 3, + kValueFieldNumber = 2, + kVersionFieldNumber = 4, + }; + // optional bytes index = 1; + bool has_index() const; + private: + bool _internal_has_index() const; + public: + void clear_index(); + const std::string& index() const; + template + void set_index(ArgT0&& arg0, ArgT... args); + std::string* mutable_index(); + PROTOBUF_NODISCARD std::string* release_index(); + void set_allocated_index(std::string* index); + private: + const std::string& _internal_index() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_index(const std::string& value); + std::string* _internal_mutable_index(); + public: + + // optional bytes padding = 3; + bool has_padding() const; + private: + bool _internal_has_padding() const; + public: + void clear_padding(); + const std::string& padding() const; + template + void set_padding(ArgT0&& arg0, ArgT... args); + std::string* mutable_padding(); + PROTOBUF_NODISCARD std::string* release_padding(); + void set_allocated_padding(std::string* padding); + private: + const std::string& _internal_padding() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_padding(const std::string& value); + std::string* _internal_mutable_padding(); + public: + + // optional .proto.SyncActionValue value = 2; + bool has_value() const; + private: + bool _internal_has_value() const; + public: + void clear_value(); + const ::proto::SyncActionValue& value() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue* release_value(); + ::proto::SyncActionValue* mutable_value(); + void set_allocated_value(::proto::SyncActionValue* value); + private: + const ::proto::SyncActionValue& _internal_value() const; + ::proto::SyncActionValue* _internal_mutable_value(); + public: + void unsafe_arena_set_allocated_value( + ::proto::SyncActionValue* value); + ::proto::SyncActionValue* unsafe_arena_release_value(); + + // optional int32 version = 4; + bool has_version() const; + private: + bool _internal_has_version() const; + public: + void clear_version(); + int32_t version() const; + void set_version(int32_t value); + private: + int32_t _internal_version() const; + void _internal_set_version(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncActionData) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr index_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr padding_; + ::proto::SyncActionValue* value_; + int32_t version_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncActionValue_AgentAction final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.AgentAction) */ { + public: + inline SyncActionValue_AgentAction() : SyncActionValue_AgentAction(nullptr) {} + ~SyncActionValue_AgentAction() override; + explicit PROTOBUF_CONSTEXPR SyncActionValue_AgentAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncActionValue_AgentAction(const SyncActionValue_AgentAction& from); + SyncActionValue_AgentAction(SyncActionValue_AgentAction&& from) noexcept + : SyncActionValue_AgentAction() { + *this = ::std::move(from); + } + + inline SyncActionValue_AgentAction& operator=(const SyncActionValue_AgentAction& from) { + CopyFrom(from); + return *this; + } + inline SyncActionValue_AgentAction& operator=(SyncActionValue_AgentAction&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncActionValue_AgentAction& default_instance() { + return *internal_default_instance(); + } + static inline const SyncActionValue_AgentAction* internal_default_instance() { + return reinterpret_cast( + &_SyncActionValue_AgentAction_default_instance_); + } + static constexpr int kIndexInFileMessages = + 175; + + friend void swap(SyncActionValue_AgentAction& a, SyncActionValue_AgentAction& b) { + a.Swap(&b); + } + inline void Swap(SyncActionValue_AgentAction* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncActionValue_AgentAction* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncActionValue_AgentAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncActionValue_AgentAction& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncActionValue_AgentAction& from) { + SyncActionValue_AgentAction::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncActionValue_AgentAction* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncActionValue.AgentAction"; + } + protected: + explicit SyncActionValue_AgentAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNameFieldNumber = 1, + kDeviceIDFieldNumber = 2, + kIsDeletedFieldNumber = 3, + }; + // optional string name = 1; + bool has_name() const; + private: + bool _internal_has_name() const; + public: + void clear_name(); + const std::string& name() const; + template + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + PROTOBUF_NODISCARD std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // optional int32 deviceID = 2; + bool has_deviceid() const; + private: + bool _internal_has_deviceid() const; + public: + void clear_deviceid(); + int32_t deviceid() const; + void set_deviceid(int32_t value); + private: + int32_t _internal_deviceid() const; + void _internal_set_deviceid(int32_t value); + public: + + // optional bool isDeleted = 3; + bool has_isdeleted() const; + private: + bool _internal_has_isdeleted() const; + public: + void clear_isdeleted(); + bool isdeleted() const; + void set_isdeleted(bool value); + private: + bool _internal_isdeleted() const; + void _internal_set_isdeleted(bool value); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncActionValue.AgentAction) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + int32_t deviceid_; + bool isdeleted_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncActionValue_AndroidUnsupportedActions final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.AndroidUnsupportedActions) */ { + public: + inline SyncActionValue_AndroidUnsupportedActions() : SyncActionValue_AndroidUnsupportedActions(nullptr) {} + ~SyncActionValue_AndroidUnsupportedActions() override; + explicit PROTOBUF_CONSTEXPR SyncActionValue_AndroidUnsupportedActions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncActionValue_AndroidUnsupportedActions(const SyncActionValue_AndroidUnsupportedActions& from); + SyncActionValue_AndroidUnsupportedActions(SyncActionValue_AndroidUnsupportedActions&& from) noexcept + : SyncActionValue_AndroidUnsupportedActions() { + *this = ::std::move(from); + } + + inline SyncActionValue_AndroidUnsupportedActions& operator=(const SyncActionValue_AndroidUnsupportedActions& from) { + CopyFrom(from); + return *this; + } + inline SyncActionValue_AndroidUnsupportedActions& operator=(SyncActionValue_AndroidUnsupportedActions&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncActionValue_AndroidUnsupportedActions& default_instance() { + return *internal_default_instance(); + } + static inline const SyncActionValue_AndroidUnsupportedActions* internal_default_instance() { + return reinterpret_cast( + &_SyncActionValue_AndroidUnsupportedActions_default_instance_); + } + static constexpr int kIndexInFileMessages = + 176; + + friend void swap(SyncActionValue_AndroidUnsupportedActions& a, SyncActionValue_AndroidUnsupportedActions& b) { + a.Swap(&b); + } + inline void Swap(SyncActionValue_AndroidUnsupportedActions* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncActionValue_AndroidUnsupportedActions* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncActionValue_AndroidUnsupportedActions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncActionValue_AndroidUnsupportedActions& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncActionValue_AndroidUnsupportedActions& from) { + SyncActionValue_AndroidUnsupportedActions::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncActionValue_AndroidUnsupportedActions* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncActionValue.AndroidUnsupportedActions"; + } + protected: + explicit SyncActionValue_AndroidUnsupportedActions(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kAllowedFieldNumber = 1, + }; + // optional bool allowed = 1; + bool has_allowed() const; + private: + bool _internal_has_allowed() const; + public: + void clear_allowed(); + bool allowed() const; + void set_allowed(bool value); + private: + bool _internal_allowed() const; + void _internal_set_allowed(bool value); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncActionValue.AndroidUnsupportedActions) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + bool allowed_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncActionValue_ArchiveChatAction final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.ArchiveChatAction) */ { + public: + inline SyncActionValue_ArchiveChatAction() : SyncActionValue_ArchiveChatAction(nullptr) {} + ~SyncActionValue_ArchiveChatAction() override; + explicit PROTOBUF_CONSTEXPR SyncActionValue_ArchiveChatAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncActionValue_ArchiveChatAction(const SyncActionValue_ArchiveChatAction& from); + SyncActionValue_ArchiveChatAction(SyncActionValue_ArchiveChatAction&& from) noexcept + : SyncActionValue_ArchiveChatAction() { + *this = ::std::move(from); + } + + inline SyncActionValue_ArchiveChatAction& operator=(const SyncActionValue_ArchiveChatAction& from) { + CopyFrom(from); + return *this; + } + inline SyncActionValue_ArchiveChatAction& operator=(SyncActionValue_ArchiveChatAction&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncActionValue_ArchiveChatAction& default_instance() { + return *internal_default_instance(); + } + static inline const SyncActionValue_ArchiveChatAction* internal_default_instance() { + return reinterpret_cast( + &_SyncActionValue_ArchiveChatAction_default_instance_); + } + static constexpr int kIndexInFileMessages = + 177; + + friend void swap(SyncActionValue_ArchiveChatAction& a, SyncActionValue_ArchiveChatAction& b) { + a.Swap(&b); + } + inline void Swap(SyncActionValue_ArchiveChatAction* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncActionValue_ArchiveChatAction* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncActionValue_ArchiveChatAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncActionValue_ArchiveChatAction& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncActionValue_ArchiveChatAction& from) { + SyncActionValue_ArchiveChatAction::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncActionValue_ArchiveChatAction* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncActionValue.ArchiveChatAction"; + } + protected: + explicit SyncActionValue_ArchiveChatAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMessageRangeFieldNumber = 2, + kArchivedFieldNumber = 1, + }; + // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2; + bool has_messagerange() const; + private: + bool _internal_has_messagerange() const; + public: + void clear_messagerange(); + const ::proto::SyncActionValue_SyncActionMessageRange& messagerange() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue_SyncActionMessageRange* release_messagerange(); + ::proto::SyncActionValue_SyncActionMessageRange* mutable_messagerange(); + void set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange); + private: + const ::proto::SyncActionValue_SyncActionMessageRange& _internal_messagerange() const; + ::proto::SyncActionValue_SyncActionMessageRange* _internal_mutable_messagerange(); + public: + void unsafe_arena_set_allocated_messagerange( + ::proto::SyncActionValue_SyncActionMessageRange* messagerange); + ::proto::SyncActionValue_SyncActionMessageRange* unsafe_arena_release_messagerange(); + + // optional bool archived = 1; + bool has_archived() const; + private: + bool _internal_has_archived() const; + public: + void clear_archived(); + bool archived() const; + void set_archived(bool value); + private: + bool _internal_archived() const; + void _internal_set_archived(bool value); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncActionValue.ArchiveChatAction) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::proto::SyncActionValue_SyncActionMessageRange* messagerange_; + bool archived_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncActionValue_ClearChatAction final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.ClearChatAction) */ { + public: + inline SyncActionValue_ClearChatAction() : SyncActionValue_ClearChatAction(nullptr) {} + ~SyncActionValue_ClearChatAction() override; + explicit PROTOBUF_CONSTEXPR SyncActionValue_ClearChatAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncActionValue_ClearChatAction(const SyncActionValue_ClearChatAction& from); + SyncActionValue_ClearChatAction(SyncActionValue_ClearChatAction&& from) noexcept + : SyncActionValue_ClearChatAction() { + *this = ::std::move(from); + } + + inline SyncActionValue_ClearChatAction& operator=(const SyncActionValue_ClearChatAction& from) { + CopyFrom(from); + return *this; + } + inline SyncActionValue_ClearChatAction& operator=(SyncActionValue_ClearChatAction&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncActionValue_ClearChatAction& default_instance() { + return *internal_default_instance(); + } + static inline const SyncActionValue_ClearChatAction* internal_default_instance() { + return reinterpret_cast( + &_SyncActionValue_ClearChatAction_default_instance_); + } + static constexpr int kIndexInFileMessages = + 178; + + friend void swap(SyncActionValue_ClearChatAction& a, SyncActionValue_ClearChatAction& b) { + a.Swap(&b); + } + inline void Swap(SyncActionValue_ClearChatAction* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncActionValue_ClearChatAction* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncActionValue_ClearChatAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncActionValue_ClearChatAction& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncActionValue_ClearChatAction& from) { + SyncActionValue_ClearChatAction::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncActionValue_ClearChatAction* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncActionValue.ClearChatAction"; + } + protected: + explicit SyncActionValue_ClearChatAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMessageRangeFieldNumber = 1, + }; + // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1; + bool has_messagerange() const; + private: + bool _internal_has_messagerange() const; + public: + void clear_messagerange(); + const ::proto::SyncActionValue_SyncActionMessageRange& messagerange() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue_SyncActionMessageRange* release_messagerange(); + ::proto::SyncActionValue_SyncActionMessageRange* mutable_messagerange(); + void set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange); + private: + const ::proto::SyncActionValue_SyncActionMessageRange& _internal_messagerange() const; + ::proto::SyncActionValue_SyncActionMessageRange* _internal_mutable_messagerange(); + public: + void unsafe_arena_set_allocated_messagerange( + ::proto::SyncActionValue_SyncActionMessageRange* messagerange); + ::proto::SyncActionValue_SyncActionMessageRange* unsafe_arena_release_messagerange(); + + // @@protoc_insertion_point(class_scope:proto.SyncActionValue.ClearChatAction) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::proto::SyncActionValue_SyncActionMessageRange* messagerange_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncActionValue_ContactAction final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.ContactAction) */ { + public: + inline SyncActionValue_ContactAction() : SyncActionValue_ContactAction(nullptr) {} + ~SyncActionValue_ContactAction() override; + explicit PROTOBUF_CONSTEXPR SyncActionValue_ContactAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncActionValue_ContactAction(const SyncActionValue_ContactAction& from); + SyncActionValue_ContactAction(SyncActionValue_ContactAction&& from) noexcept + : SyncActionValue_ContactAction() { + *this = ::std::move(from); + } + + inline SyncActionValue_ContactAction& operator=(const SyncActionValue_ContactAction& from) { + CopyFrom(from); + return *this; + } + inline SyncActionValue_ContactAction& operator=(SyncActionValue_ContactAction&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncActionValue_ContactAction& default_instance() { + return *internal_default_instance(); + } + static inline const SyncActionValue_ContactAction* internal_default_instance() { + return reinterpret_cast( + &_SyncActionValue_ContactAction_default_instance_); + } + static constexpr int kIndexInFileMessages = + 179; + + friend void swap(SyncActionValue_ContactAction& a, SyncActionValue_ContactAction& b) { + a.Swap(&b); + } + inline void Swap(SyncActionValue_ContactAction* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncActionValue_ContactAction* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncActionValue_ContactAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncActionValue_ContactAction& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncActionValue_ContactAction& from) { + SyncActionValue_ContactAction::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncActionValue_ContactAction* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncActionValue.ContactAction"; + } + protected: + explicit SyncActionValue_ContactAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kFullNameFieldNumber = 1, + kFirstNameFieldNumber = 2, + }; + // optional string fullName = 1; + bool has_fullname() const; + private: + bool _internal_has_fullname() const; + public: + void clear_fullname(); + const std::string& fullname() const; + template + void set_fullname(ArgT0&& arg0, ArgT... args); + std::string* mutable_fullname(); + PROTOBUF_NODISCARD std::string* release_fullname(); + void set_allocated_fullname(std::string* fullname); + private: + const std::string& _internal_fullname() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_fullname(const std::string& value); + std::string* _internal_mutable_fullname(); + public: + + // optional string firstName = 2; + bool has_firstname() const; + private: + bool _internal_has_firstname() const; + public: + void clear_firstname(); + const std::string& firstname() const; + template + void set_firstname(ArgT0&& arg0, ArgT... args); + std::string* mutable_firstname(); + PROTOBUF_NODISCARD std::string* release_firstname(); + void set_allocated_firstname(std::string* firstname); + private: + const std::string& _internal_firstname() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_firstname(const std::string& value); + std::string* _internal_mutable_firstname(); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncActionValue.ContactAction) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fullname_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr firstname_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncActionValue_DeleteChatAction final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.DeleteChatAction) */ { + public: + inline SyncActionValue_DeleteChatAction() : SyncActionValue_DeleteChatAction(nullptr) {} + ~SyncActionValue_DeleteChatAction() override; + explicit PROTOBUF_CONSTEXPR SyncActionValue_DeleteChatAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncActionValue_DeleteChatAction(const SyncActionValue_DeleteChatAction& from); + SyncActionValue_DeleteChatAction(SyncActionValue_DeleteChatAction&& from) noexcept + : SyncActionValue_DeleteChatAction() { + *this = ::std::move(from); + } + + inline SyncActionValue_DeleteChatAction& operator=(const SyncActionValue_DeleteChatAction& from) { + CopyFrom(from); + return *this; + } + inline SyncActionValue_DeleteChatAction& operator=(SyncActionValue_DeleteChatAction&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncActionValue_DeleteChatAction& default_instance() { + return *internal_default_instance(); + } + static inline const SyncActionValue_DeleteChatAction* internal_default_instance() { + return reinterpret_cast( + &_SyncActionValue_DeleteChatAction_default_instance_); + } + static constexpr int kIndexInFileMessages = + 180; + + friend void swap(SyncActionValue_DeleteChatAction& a, SyncActionValue_DeleteChatAction& b) { + a.Swap(&b); + } + inline void Swap(SyncActionValue_DeleteChatAction* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncActionValue_DeleteChatAction* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncActionValue_DeleteChatAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncActionValue_DeleteChatAction& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncActionValue_DeleteChatAction& from) { + SyncActionValue_DeleteChatAction::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncActionValue_DeleteChatAction* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncActionValue.DeleteChatAction"; + } + protected: + explicit SyncActionValue_DeleteChatAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMessageRangeFieldNumber = 1, + }; + // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1; + bool has_messagerange() const; + private: + bool _internal_has_messagerange() const; + public: + void clear_messagerange(); + const ::proto::SyncActionValue_SyncActionMessageRange& messagerange() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue_SyncActionMessageRange* release_messagerange(); + ::proto::SyncActionValue_SyncActionMessageRange* mutable_messagerange(); + void set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange); + private: + const ::proto::SyncActionValue_SyncActionMessageRange& _internal_messagerange() const; + ::proto::SyncActionValue_SyncActionMessageRange* _internal_mutable_messagerange(); + public: + void unsafe_arena_set_allocated_messagerange( + ::proto::SyncActionValue_SyncActionMessageRange* messagerange); + ::proto::SyncActionValue_SyncActionMessageRange* unsafe_arena_release_messagerange(); + + // @@protoc_insertion_point(class_scope:proto.SyncActionValue.DeleteChatAction) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::proto::SyncActionValue_SyncActionMessageRange* messagerange_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncActionValue_DeleteMessageForMeAction final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.DeleteMessageForMeAction) */ { + public: + inline SyncActionValue_DeleteMessageForMeAction() : SyncActionValue_DeleteMessageForMeAction(nullptr) {} + ~SyncActionValue_DeleteMessageForMeAction() override; + explicit PROTOBUF_CONSTEXPR SyncActionValue_DeleteMessageForMeAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncActionValue_DeleteMessageForMeAction(const SyncActionValue_DeleteMessageForMeAction& from); + SyncActionValue_DeleteMessageForMeAction(SyncActionValue_DeleteMessageForMeAction&& from) noexcept + : SyncActionValue_DeleteMessageForMeAction() { + *this = ::std::move(from); + } + + inline SyncActionValue_DeleteMessageForMeAction& operator=(const SyncActionValue_DeleteMessageForMeAction& from) { + CopyFrom(from); + return *this; + } + inline SyncActionValue_DeleteMessageForMeAction& operator=(SyncActionValue_DeleteMessageForMeAction&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncActionValue_DeleteMessageForMeAction& default_instance() { + return *internal_default_instance(); + } + static inline const SyncActionValue_DeleteMessageForMeAction* internal_default_instance() { + return reinterpret_cast( + &_SyncActionValue_DeleteMessageForMeAction_default_instance_); + } + static constexpr int kIndexInFileMessages = + 181; + + friend void swap(SyncActionValue_DeleteMessageForMeAction& a, SyncActionValue_DeleteMessageForMeAction& b) { + a.Swap(&b); + } + inline void Swap(SyncActionValue_DeleteMessageForMeAction* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncActionValue_DeleteMessageForMeAction* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncActionValue_DeleteMessageForMeAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncActionValue_DeleteMessageForMeAction& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncActionValue_DeleteMessageForMeAction& from) { + SyncActionValue_DeleteMessageForMeAction::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncActionValue_DeleteMessageForMeAction* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncActionValue.DeleteMessageForMeAction"; + } + protected: + explicit SyncActionValue_DeleteMessageForMeAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMessageTimestampFieldNumber = 2, + kDeleteMediaFieldNumber = 1, + }; + // optional int64 messageTimestamp = 2; + bool has_messagetimestamp() const; + private: + bool _internal_has_messagetimestamp() const; + public: + void clear_messagetimestamp(); + int64_t messagetimestamp() const; + void set_messagetimestamp(int64_t value); + private: + int64_t _internal_messagetimestamp() const; + void _internal_set_messagetimestamp(int64_t value); + public: + + // optional bool deleteMedia = 1; + bool has_deletemedia() const; + private: + bool _internal_has_deletemedia() const; + public: + void clear_deletemedia(); + bool deletemedia() const; + void set_deletemedia(bool value); + private: + bool _internal_deletemedia() const; + void _internal_set_deletemedia(bool value); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncActionValue.DeleteMessageForMeAction) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + int64_t messagetimestamp_; + bool deletemedia_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncActionValue_KeyExpiration final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.KeyExpiration) */ { + public: + inline SyncActionValue_KeyExpiration() : SyncActionValue_KeyExpiration(nullptr) {} + ~SyncActionValue_KeyExpiration() override; + explicit PROTOBUF_CONSTEXPR SyncActionValue_KeyExpiration(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncActionValue_KeyExpiration(const SyncActionValue_KeyExpiration& from); + SyncActionValue_KeyExpiration(SyncActionValue_KeyExpiration&& from) noexcept + : SyncActionValue_KeyExpiration() { + *this = ::std::move(from); + } + + inline SyncActionValue_KeyExpiration& operator=(const SyncActionValue_KeyExpiration& from) { + CopyFrom(from); + return *this; + } + inline SyncActionValue_KeyExpiration& operator=(SyncActionValue_KeyExpiration&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncActionValue_KeyExpiration& default_instance() { + return *internal_default_instance(); + } + static inline const SyncActionValue_KeyExpiration* internal_default_instance() { + return reinterpret_cast( + &_SyncActionValue_KeyExpiration_default_instance_); + } + static constexpr int kIndexInFileMessages = + 182; + + friend void swap(SyncActionValue_KeyExpiration& a, SyncActionValue_KeyExpiration& b) { + a.Swap(&b); + } + inline void Swap(SyncActionValue_KeyExpiration* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncActionValue_KeyExpiration* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncActionValue_KeyExpiration* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncActionValue_KeyExpiration& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncActionValue_KeyExpiration& from) { + SyncActionValue_KeyExpiration::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncActionValue_KeyExpiration* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncActionValue.KeyExpiration"; + } + protected: + explicit SyncActionValue_KeyExpiration(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kExpiredKeyEpochFieldNumber = 1, + }; + // optional int32 expiredKeyEpoch = 1; + bool has_expiredkeyepoch() const; + private: + bool _internal_has_expiredkeyepoch() const; + public: + void clear_expiredkeyepoch(); + int32_t expiredkeyepoch() const; + void set_expiredkeyepoch(int32_t value); + private: + int32_t _internal_expiredkeyepoch() const; + void _internal_set_expiredkeyepoch(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncActionValue.KeyExpiration) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + int32_t expiredkeyepoch_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncActionValue_LabelAssociationAction final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.LabelAssociationAction) */ { + public: + inline SyncActionValue_LabelAssociationAction() : SyncActionValue_LabelAssociationAction(nullptr) {} + ~SyncActionValue_LabelAssociationAction() override; + explicit PROTOBUF_CONSTEXPR SyncActionValue_LabelAssociationAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncActionValue_LabelAssociationAction(const SyncActionValue_LabelAssociationAction& from); + SyncActionValue_LabelAssociationAction(SyncActionValue_LabelAssociationAction&& from) noexcept + : SyncActionValue_LabelAssociationAction() { + *this = ::std::move(from); + } + + inline SyncActionValue_LabelAssociationAction& operator=(const SyncActionValue_LabelAssociationAction& from) { + CopyFrom(from); + return *this; + } + inline SyncActionValue_LabelAssociationAction& operator=(SyncActionValue_LabelAssociationAction&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncActionValue_LabelAssociationAction& default_instance() { + return *internal_default_instance(); + } + static inline const SyncActionValue_LabelAssociationAction* internal_default_instance() { + return reinterpret_cast( + &_SyncActionValue_LabelAssociationAction_default_instance_); + } + static constexpr int kIndexInFileMessages = + 183; + + friend void swap(SyncActionValue_LabelAssociationAction& a, SyncActionValue_LabelAssociationAction& b) { + a.Swap(&b); + } + inline void Swap(SyncActionValue_LabelAssociationAction* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncActionValue_LabelAssociationAction* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncActionValue_LabelAssociationAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncActionValue_LabelAssociationAction& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncActionValue_LabelAssociationAction& from) { + SyncActionValue_LabelAssociationAction::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncActionValue_LabelAssociationAction* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncActionValue.LabelAssociationAction"; + } + protected: + explicit SyncActionValue_LabelAssociationAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kLabeledFieldNumber = 1, + }; + // optional bool labeled = 1; + bool has_labeled() const; + private: + bool _internal_has_labeled() const; + public: + void clear_labeled(); + bool labeled() const; + void set_labeled(bool value); + private: + bool _internal_labeled() const; + void _internal_set_labeled(bool value); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncActionValue.LabelAssociationAction) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + bool labeled_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncActionValue_LabelEditAction final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.LabelEditAction) */ { + public: + inline SyncActionValue_LabelEditAction() : SyncActionValue_LabelEditAction(nullptr) {} + ~SyncActionValue_LabelEditAction() override; + explicit PROTOBUF_CONSTEXPR SyncActionValue_LabelEditAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncActionValue_LabelEditAction(const SyncActionValue_LabelEditAction& from); + SyncActionValue_LabelEditAction(SyncActionValue_LabelEditAction&& from) noexcept + : SyncActionValue_LabelEditAction() { + *this = ::std::move(from); + } + + inline SyncActionValue_LabelEditAction& operator=(const SyncActionValue_LabelEditAction& from) { + CopyFrom(from); + return *this; + } + inline SyncActionValue_LabelEditAction& operator=(SyncActionValue_LabelEditAction&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncActionValue_LabelEditAction& default_instance() { + return *internal_default_instance(); + } + static inline const SyncActionValue_LabelEditAction* internal_default_instance() { + return reinterpret_cast( + &_SyncActionValue_LabelEditAction_default_instance_); + } + static constexpr int kIndexInFileMessages = + 184; + + friend void swap(SyncActionValue_LabelEditAction& a, SyncActionValue_LabelEditAction& b) { + a.Swap(&b); + } + inline void Swap(SyncActionValue_LabelEditAction* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncActionValue_LabelEditAction* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncActionValue_LabelEditAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncActionValue_LabelEditAction& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncActionValue_LabelEditAction& from) { + SyncActionValue_LabelEditAction::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncActionValue_LabelEditAction* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncActionValue.LabelEditAction"; + } + protected: + explicit SyncActionValue_LabelEditAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNameFieldNumber = 1, + kColorFieldNumber = 2, + kPredefinedIdFieldNumber = 3, + kDeletedFieldNumber = 4, + }; + // optional string name = 1; + bool has_name() const; + private: + bool _internal_has_name() const; + public: + void clear_name(); + const std::string& name() const; + template + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + PROTOBUF_NODISCARD std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // optional int32 color = 2; + bool has_color() const; + private: + bool _internal_has_color() const; + public: + void clear_color(); + int32_t color() const; + void set_color(int32_t value); + private: + int32_t _internal_color() const; + void _internal_set_color(int32_t value); + public: + + // optional int32 predefinedId = 3; + bool has_predefinedid() const; + private: + bool _internal_has_predefinedid() const; + public: + void clear_predefinedid(); + int32_t predefinedid() const; + void set_predefinedid(int32_t value); + private: + int32_t _internal_predefinedid() const; + void _internal_set_predefinedid(int32_t value); + public: + + // optional bool deleted = 4; + bool has_deleted() const; + private: + bool _internal_has_deleted() const; + public: + void clear_deleted(); + bool deleted() const; + void set_deleted(bool value); + private: + bool _internal_deleted() const; + void _internal_set_deleted(bool value); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncActionValue.LabelEditAction) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + int32_t color_; + int32_t predefinedid_; + bool deleted_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncActionValue_LocaleSetting final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.LocaleSetting) */ { + public: + inline SyncActionValue_LocaleSetting() : SyncActionValue_LocaleSetting(nullptr) {} + ~SyncActionValue_LocaleSetting() override; + explicit PROTOBUF_CONSTEXPR SyncActionValue_LocaleSetting(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncActionValue_LocaleSetting(const SyncActionValue_LocaleSetting& from); + SyncActionValue_LocaleSetting(SyncActionValue_LocaleSetting&& from) noexcept + : SyncActionValue_LocaleSetting() { + *this = ::std::move(from); + } + + inline SyncActionValue_LocaleSetting& operator=(const SyncActionValue_LocaleSetting& from) { + CopyFrom(from); + return *this; + } + inline SyncActionValue_LocaleSetting& operator=(SyncActionValue_LocaleSetting&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncActionValue_LocaleSetting& default_instance() { + return *internal_default_instance(); + } + static inline const SyncActionValue_LocaleSetting* internal_default_instance() { + return reinterpret_cast( + &_SyncActionValue_LocaleSetting_default_instance_); + } + static constexpr int kIndexInFileMessages = + 185; + + friend void swap(SyncActionValue_LocaleSetting& a, SyncActionValue_LocaleSetting& b) { + a.Swap(&b); + } + inline void Swap(SyncActionValue_LocaleSetting* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncActionValue_LocaleSetting* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncActionValue_LocaleSetting* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncActionValue_LocaleSetting& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncActionValue_LocaleSetting& from) { + SyncActionValue_LocaleSetting::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncActionValue_LocaleSetting* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncActionValue.LocaleSetting"; + } + protected: + explicit SyncActionValue_LocaleSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kLocaleFieldNumber = 1, + }; + // optional string locale = 1; + bool has_locale() const; + private: + bool _internal_has_locale() const; + public: + void clear_locale(); + const std::string& locale() const; + template + void set_locale(ArgT0&& arg0, ArgT... args); + std::string* mutable_locale(); + PROTOBUF_NODISCARD std::string* release_locale(); + void set_allocated_locale(std::string* locale); + private: + const std::string& _internal_locale() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_locale(const std::string& value); + std::string* _internal_mutable_locale(); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncActionValue.LocaleSetting) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr locale_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncActionValue_MarkChatAsReadAction final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.MarkChatAsReadAction) */ { + public: + inline SyncActionValue_MarkChatAsReadAction() : SyncActionValue_MarkChatAsReadAction(nullptr) {} + ~SyncActionValue_MarkChatAsReadAction() override; + explicit PROTOBUF_CONSTEXPR SyncActionValue_MarkChatAsReadAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncActionValue_MarkChatAsReadAction(const SyncActionValue_MarkChatAsReadAction& from); + SyncActionValue_MarkChatAsReadAction(SyncActionValue_MarkChatAsReadAction&& from) noexcept + : SyncActionValue_MarkChatAsReadAction() { + *this = ::std::move(from); + } + + inline SyncActionValue_MarkChatAsReadAction& operator=(const SyncActionValue_MarkChatAsReadAction& from) { + CopyFrom(from); + return *this; + } + inline SyncActionValue_MarkChatAsReadAction& operator=(SyncActionValue_MarkChatAsReadAction&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncActionValue_MarkChatAsReadAction& default_instance() { + return *internal_default_instance(); + } + static inline const SyncActionValue_MarkChatAsReadAction* internal_default_instance() { + return reinterpret_cast( + &_SyncActionValue_MarkChatAsReadAction_default_instance_); + } + static constexpr int kIndexInFileMessages = + 186; + + friend void swap(SyncActionValue_MarkChatAsReadAction& a, SyncActionValue_MarkChatAsReadAction& b) { + a.Swap(&b); + } + inline void Swap(SyncActionValue_MarkChatAsReadAction* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncActionValue_MarkChatAsReadAction* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncActionValue_MarkChatAsReadAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncActionValue_MarkChatAsReadAction& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncActionValue_MarkChatAsReadAction& from) { + SyncActionValue_MarkChatAsReadAction::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncActionValue_MarkChatAsReadAction* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncActionValue.MarkChatAsReadAction"; + } + protected: + explicit SyncActionValue_MarkChatAsReadAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMessageRangeFieldNumber = 2, + kReadFieldNumber = 1, + }; + // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2; + bool has_messagerange() const; + private: + bool _internal_has_messagerange() const; + public: + void clear_messagerange(); + const ::proto::SyncActionValue_SyncActionMessageRange& messagerange() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue_SyncActionMessageRange* release_messagerange(); + ::proto::SyncActionValue_SyncActionMessageRange* mutable_messagerange(); + void set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange); + private: + const ::proto::SyncActionValue_SyncActionMessageRange& _internal_messagerange() const; + ::proto::SyncActionValue_SyncActionMessageRange* _internal_mutable_messagerange(); + public: + void unsafe_arena_set_allocated_messagerange( + ::proto::SyncActionValue_SyncActionMessageRange* messagerange); + ::proto::SyncActionValue_SyncActionMessageRange* unsafe_arena_release_messagerange(); + + // optional bool read = 1; + bool has_read() const; + private: + bool _internal_has_read() const; + public: + void clear_read(); + bool read() const; + void set_read(bool value); + private: + bool _internal_read() const; + void _internal_set_read(bool value); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncActionValue.MarkChatAsReadAction) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::proto::SyncActionValue_SyncActionMessageRange* messagerange_; + bool read_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncActionValue_MuteAction final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.MuteAction) */ { + public: + inline SyncActionValue_MuteAction() : SyncActionValue_MuteAction(nullptr) {} + ~SyncActionValue_MuteAction() override; + explicit PROTOBUF_CONSTEXPR SyncActionValue_MuteAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncActionValue_MuteAction(const SyncActionValue_MuteAction& from); + SyncActionValue_MuteAction(SyncActionValue_MuteAction&& from) noexcept + : SyncActionValue_MuteAction() { + *this = ::std::move(from); + } + + inline SyncActionValue_MuteAction& operator=(const SyncActionValue_MuteAction& from) { + CopyFrom(from); + return *this; + } + inline SyncActionValue_MuteAction& operator=(SyncActionValue_MuteAction&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncActionValue_MuteAction& default_instance() { + return *internal_default_instance(); + } + static inline const SyncActionValue_MuteAction* internal_default_instance() { + return reinterpret_cast( + &_SyncActionValue_MuteAction_default_instance_); + } + static constexpr int kIndexInFileMessages = + 187; + + friend void swap(SyncActionValue_MuteAction& a, SyncActionValue_MuteAction& b) { + a.Swap(&b); + } + inline void Swap(SyncActionValue_MuteAction* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncActionValue_MuteAction* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncActionValue_MuteAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncActionValue_MuteAction& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncActionValue_MuteAction& from) { + SyncActionValue_MuteAction::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncActionValue_MuteAction* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncActionValue.MuteAction"; + } + protected: + explicit SyncActionValue_MuteAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMuteEndTimestampFieldNumber = 2, + kMutedFieldNumber = 1, + }; + // optional int64 muteEndTimestamp = 2; + bool has_muteendtimestamp() const; + private: + bool _internal_has_muteendtimestamp() const; + public: + void clear_muteendtimestamp(); + int64_t muteendtimestamp() const; + void set_muteendtimestamp(int64_t value); + private: + int64_t _internal_muteendtimestamp() const; + void _internal_set_muteendtimestamp(int64_t value); + public: + + // optional bool muted = 1; + bool has_muted() const; + private: + bool _internal_has_muted() const; + public: + void clear_muted(); + bool muted() const; + void set_muted(bool value); + private: + bool _internal_muted() const; + void _internal_set_muted(bool value); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncActionValue.MuteAction) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + int64_t muteendtimestamp_; + bool muted_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncActionValue_NuxAction final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.NuxAction) */ { + public: + inline SyncActionValue_NuxAction() : SyncActionValue_NuxAction(nullptr) {} + ~SyncActionValue_NuxAction() override; + explicit PROTOBUF_CONSTEXPR SyncActionValue_NuxAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncActionValue_NuxAction(const SyncActionValue_NuxAction& from); + SyncActionValue_NuxAction(SyncActionValue_NuxAction&& from) noexcept + : SyncActionValue_NuxAction() { + *this = ::std::move(from); + } + + inline SyncActionValue_NuxAction& operator=(const SyncActionValue_NuxAction& from) { + CopyFrom(from); + return *this; + } + inline SyncActionValue_NuxAction& operator=(SyncActionValue_NuxAction&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncActionValue_NuxAction& default_instance() { + return *internal_default_instance(); + } + static inline const SyncActionValue_NuxAction* internal_default_instance() { + return reinterpret_cast( + &_SyncActionValue_NuxAction_default_instance_); + } + static constexpr int kIndexInFileMessages = + 188; + + friend void swap(SyncActionValue_NuxAction& a, SyncActionValue_NuxAction& b) { + a.Swap(&b); + } + inline void Swap(SyncActionValue_NuxAction* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncActionValue_NuxAction* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncActionValue_NuxAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncActionValue_NuxAction& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncActionValue_NuxAction& from) { + SyncActionValue_NuxAction::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncActionValue_NuxAction* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncActionValue.NuxAction"; + } + protected: + explicit SyncActionValue_NuxAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kAcknowledgedFieldNumber = 1, + }; + // optional bool acknowledged = 1; + bool has_acknowledged() const; + private: + bool _internal_has_acknowledged() const; + public: + void clear_acknowledged(); + bool acknowledged() const; + void set_acknowledged(bool value); + private: + bool _internal_acknowledged() const; + void _internal_set_acknowledged(bool value); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncActionValue.NuxAction) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + bool acknowledged_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncActionValue_PinAction final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.PinAction) */ { + public: + inline SyncActionValue_PinAction() : SyncActionValue_PinAction(nullptr) {} + ~SyncActionValue_PinAction() override; + explicit PROTOBUF_CONSTEXPR SyncActionValue_PinAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncActionValue_PinAction(const SyncActionValue_PinAction& from); + SyncActionValue_PinAction(SyncActionValue_PinAction&& from) noexcept + : SyncActionValue_PinAction() { + *this = ::std::move(from); + } + + inline SyncActionValue_PinAction& operator=(const SyncActionValue_PinAction& from) { + CopyFrom(from); + return *this; + } + inline SyncActionValue_PinAction& operator=(SyncActionValue_PinAction&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncActionValue_PinAction& default_instance() { + return *internal_default_instance(); + } + static inline const SyncActionValue_PinAction* internal_default_instance() { + return reinterpret_cast( + &_SyncActionValue_PinAction_default_instance_); + } + static constexpr int kIndexInFileMessages = + 189; + + friend void swap(SyncActionValue_PinAction& a, SyncActionValue_PinAction& b) { + a.Swap(&b); + } + inline void Swap(SyncActionValue_PinAction* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncActionValue_PinAction* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncActionValue_PinAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncActionValue_PinAction& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncActionValue_PinAction& from) { + SyncActionValue_PinAction::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncActionValue_PinAction* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncActionValue.PinAction"; + } + protected: + explicit SyncActionValue_PinAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kPinnedFieldNumber = 1, + }; + // optional bool pinned = 1; + bool has_pinned() const; + private: + bool _internal_has_pinned() const; + public: + void clear_pinned(); + bool pinned() const; + void set_pinned(bool value); + private: + bool _internal_pinned() const; + void _internal_set_pinned(bool value); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncActionValue.PinAction) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + bool pinned_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncActionValue_PrimaryFeature final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.PrimaryFeature) */ { + public: + inline SyncActionValue_PrimaryFeature() : SyncActionValue_PrimaryFeature(nullptr) {} + ~SyncActionValue_PrimaryFeature() override; + explicit PROTOBUF_CONSTEXPR SyncActionValue_PrimaryFeature(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncActionValue_PrimaryFeature(const SyncActionValue_PrimaryFeature& from); + SyncActionValue_PrimaryFeature(SyncActionValue_PrimaryFeature&& from) noexcept + : SyncActionValue_PrimaryFeature() { + *this = ::std::move(from); + } + + inline SyncActionValue_PrimaryFeature& operator=(const SyncActionValue_PrimaryFeature& from) { + CopyFrom(from); + return *this; + } + inline SyncActionValue_PrimaryFeature& operator=(SyncActionValue_PrimaryFeature&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncActionValue_PrimaryFeature& default_instance() { + return *internal_default_instance(); + } + static inline const SyncActionValue_PrimaryFeature* internal_default_instance() { + return reinterpret_cast( + &_SyncActionValue_PrimaryFeature_default_instance_); + } + static constexpr int kIndexInFileMessages = + 190; + + friend void swap(SyncActionValue_PrimaryFeature& a, SyncActionValue_PrimaryFeature& b) { + a.Swap(&b); + } + inline void Swap(SyncActionValue_PrimaryFeature* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncActionValue_PrimaryFeature* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncActionValue_PrimaryFeature* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncActionValue_PrimaryFeature& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncActionValue_PrimaryFeature& from) { + SyncActionValue_PrimaryFeature::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncActionValue_PrimaryFeature* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncActionValue.PrimaryFeature"; + } + protected: + explicit SyncActionValue_PrimaryFeature(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kFlagsFieldNumber = 1, + }; + // repeated string flags = 1; + int flags_size() const; + private: + int _internal_flags_size() const; + public: + void clear_flags(); + const std::string& flags(int index) const; + std::string* mutable_flags(int index); + void set_flags(int index, const std::string& value); + void set_flags(int index, std::string&& value); + void set_flags(int index, const char* value); + void set_flags(int index, const char* value, size_t size); + std::string* add_flags(); + void add_flags(const std::string& value); + void add_flags(std::string&& value); + void add_flags(const char* value); + void add_flags(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& flags() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_flags(); + private: + const std::string& _internal_flags(int index) const; + std::string* _internal_add_flags(); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncActionValue.PrimaryFeature) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField flags_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncActionValue_PrimaryVersionAction final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.PrimaryVersionAction) */ { + public: + inline SyncActionValue_PrimaryVersionAction() : SyncActionValue_PrimaryVersionAction(nullptr) {} + ~SyncActionValue_PrimaryVersionAction() override; + explicit PROTOBUF_CONSTEXPR SyncActionValue_PrimaryVersionAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncActionValue_PrimaryVersionAction(const SyncActionValue_PrimaryVersionAction& from); + SyncActionValue_PrimaryVersionAction(SyncActionValue_PrimaryVersionAction&& from) noexcept + : SyncActionValue_PrimaryVersionAction() { + *this = ::std::move(from); + } + + inline SyncActionValue_PrimaryVersionAction& operator=(const SyncActionValue_PrimaryVersionAction& from) { + CopyFrom(from); + return *this; + } + inline SyncActionValue_PrimaryVersionAction& operator=(SyncActionValue_PrimaryVersionAction&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncActionValue_PrimaryVersionAction& default_instance() { + return *internal_default_instance(); + } + static inline const SyncActionValue_PrimaryVersionAction* internal_default_instance() { + return reinterpret_cast( + &_SyncActionValue_PrimaryVersionAction_default_instance_); + } + static constexpr int kIndexInFileMessages = + 191; + + friend void swap(SyncActionValue_PrimaryVersionAction& a, SyncActionValue_PrimaryVersionAction& b) { + a.Swap(&b); + } + inline void Swap(SyncActionValue_PrimaryVersionAction* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncActionValue_PrimaryVersionAction* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncActionValue_PrimaryVersionAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncActionValue_PrimaryVersionAction& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncActionValue_PrimaryVersionAction& from) { + SyncActionValue_PrimaryVersionAction::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncActionValue_PrimaryVersionAction* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncActionValue.PrimaryVersionAction"; + } + protected: + explicit SyncActionValue_PrimaryVersionAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kVersionFieldNumber = 1, + }; + // optional string version = 1; + bool has_version() const; + private: + bool _internal_has_version() const; + public: + void clear_version(); + const std::string& version() const; + template + void set_version(ArgT0&& arg0, ArgT... args); + std::string* mutable_version(); + PROTOBUF_NODISCARD std::string* release_version(); + void set_allocated_version(std::string* version); + private: + const std::string& _internal_version() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(const std::string& value); + std::string* _internal_mutable_version(); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncActionValue.PrimaryVersionAction) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncActionValue_PushNameSetting final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.PushNameSetting) */ { + public: + inline SyncActionValue_PushNameSetting() : SyncActionValue_PushNameSetting(nullptr) {} + ~SyncActionValue_PushNameSetting() override; + explicit PROTOBUF_CONSTEXPR SyncActionValue_PushNameSetting(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncActionValue_PushNameSetting(const SyncActionValue_PushNameSetting& from); + SyncActionValue_PushNameSetting(SyncActionValue_PushNameSetting&& from) noexcept + : SyncActionValue_PushNameSetting() { + *this = ::std::move(from); + } + + inline SyncActionValue_PushNameSetting& operator=(const SyncActionValue_PushNameSetting& from) { + CopyFrom(from); + return *this; + } + inline SyncActionValue_PushNameSetting& operator=(SyncActionValue_PushNameSetting&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncActionValue_PushNameSetting& default_instance() { + return *internal_default_instance(); + } + static inline const SyncActionValue_PushNameSetting* internal_default_instance() { + return reinterpret_cast( + &_SyncActionValue_PushNameSetting_default_instance_); + } + static constexpr int kIndexInFileMessages = + 192; + + friend void swap(SyncActionValue_PushNameSetting& a, SyncActionValue_PushNameSetting& b) { + a.Swap(&b); + } + inline void Swap(SyncActionValue_PushNameSetting* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncActionValue_PushNameSetting* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncActionValue_PushNameSetting* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncActionValue_PushNameSetting& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncActionValue_PushNameSetting& from) { + SyncActionValue_PushNameSetting::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncActionValue_PushNameSetting* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncActionValue.PushNameSetting"; + } + protected: + explicit SyncActionValue_PushNameSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNameFieldNumber = 1, + }; + // optional string name = 1; + bool has_name() const; + private: + bool _internal_has_name() const; + public: + void clear_name(); + const std::string& name() const; + template + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + PROTOBUF_NODISCARD std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncActionValue.PushNameSetting) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncActionValue_QuickReplyAction final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.QuickReplyAction) */ { + public: + inline SyncActionValue_QuickReplyAction() : SyncActionValue_QuickReplyAction(nullptr) {} + ~SyncActionValue_QuickReplyAction() override; + explicit PROTOBUF_CONSTEXPR SyncActionValue_QuickReplyAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncActionValue_QuickReplyAction(const SyncActionValue_QuickReplyAction& from); + SyncActionValue_QuickReplyAction(SyncActionValue_QuickReplyAction&& from) noexcept + : SyncActionValue_QuickReplyAction() { + *this = ::std::move(from); + } + + inline SyncActionValue_QuickReplyAction& operator=(const SyncActionValue_QuickReplyAction& from) { + CopyFrom(from); + return *this; + } + inline SyncActionValue_QuickReplyAction& operator=(SyncActionValue_QuickReplyAction&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncActionValue_QuickReplyAction& default_instance() { + return *internal_default_instance(); + } + static inline const SyncActionValue_QuickReplyAction* internal_default_instance() { + return reinterpret_cast( + &_SyncActionValue_QuickReplyAction_default_instance_); + } + static constexpr int kIndexInFileMessages = + 193; + + friend void swap(SyncActionValue_QuickReplyAction& a, SyncActionValue_QuickReplyAction& b) { + a.Swap(&b); + } + inline void Swap(SyncActionValue_QuickReplyAction* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncActionValue_QuickReplyAction* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncActionValue_QuickReplyAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncActionValue_QuickReplyAction& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncActionValue_QuickReplyAction& from) { + SyncActionValue_QuickReplyAction::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncActionValue_QuickReplyAction* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncActionValue.QuickReplyAction"; + } + protected: + explicit SyncActionValue_QuickReplyAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kKeywordsFieldNumber = 3, + kShortcutFieldNumber = 1, + kMessageFieldNumber = 2, + kCountFieldNumber = 4, + kDeletedFieldNumber = 5, + }; + // repeated string keywords = 3; + int keywords_size() const; + private: + int _internal_keywords_size() const; + public: + void clear_keywords(); + const std::string& keywords(int index) const; + std::string* mutable_keywords(int index); + void set_keywords(int index, const std::string& value); + void set_keywords(int index, std::string&& value); + void set_keywords(int index, const char* value); + void set_keywords(int index, const char* value, size_t size); + std::string* add_keywords(); + void add_keywords(const std::string& value); + void add_keywords(std::string&& value); + void add_keywords(const char* value); + void add_keywords(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& keywords() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_keywords(); + private: + const std::string& _internal_keywords(int index) const; + std::string* _internal_add_keywords(); + public: + + // optional string shortcut = 1; + bool has_shortcut() const; + private: + bool _internal_has_shortcut() const; + public: + void clear_shortcut(); + const std::string& shortcut() const; + template + void set_shortcut(ArgT0&& arg0, ArgT... args); + std::string* mutable_shortcut(); + PROTOBUF_NODISCARD std::string* release_shortcut(); + void set_allocated_shortcut(std::string* shortcut); + private: + const std::string& _internal_shortcut() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_shortcut(const std::string& value); + std::string* _internal_mutable_shortcut(); + public: + + // optional string message = 2; + bool has_message() const; + private: + bool _internal_has_message() const; + public: + void clear_message(); + const std::string& message() const; + template + void set_message(ArgT0&& arg0, ArgT... args); + std::string* mutable_message(); + PROTOBUF_NODISCARD std::string* release_message(); + void set_allocated_message(std::string* message); + private: + const std::string& _internal_message() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_message(const std::string& value); + std::string* _internal_mutable_message(); + public: + + // optional int32 count = 4; + bool has_count() const; + private: + bool _internal_has_count() const; + public: + void clear_count(); + int32_t count() const; + void set_count(int32_t value); + private: + int32_t _internal_count() const; + void _internal_set_count(int32_t value); + public: + + // optional bool deleted = 5; + bool has_deleted() const; + private: + bool _internal_has_deleted() const; + public: + void clear_deleted(); + bool deleted() const; + void set_deleted(bool value); + private: + bool _internal_deleted() const; + void _internal_set_deleted(bool value); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncActionValue.QuickReplyAction) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField keywords_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr shortcut_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_; + int32_t count_; + bool deleted_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncActionValue_RecentEmojiWeightsAction final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.RecentEmojiWeightsAction) */ { + public: + inline SyncActionValue_RecentEmojiWeightsAction() : SyncActionValue_RecentEmojiWeightsAction(nullptr) {} + ~SyncActionValue_RecentEmojiWeightsAction() override; + explicit PROTOBUF_CONSTEXPR SyncActionValue_RecentEmojiWeightsAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncActionValue_RecentEmojiWeightsAction(const SyncActionValue_RecentEmojiWeightsAction& from); + SyncActionValue_RecentEmojiWeightsAction(SyncActionValue_RecentEmojiWeightsAction&& from) noexcept + : SyncActionValue_RecentEmojiWeightsAction() { + *this = ::std::move(from); + } + + inline SyncActionValue_RecentEmojiWeightsAction& operator=(const SyncActionValue_RecentEmojiWeightsAction& from) { + CopyFrom(from); + return *this; + } + inline SyncActionValue_RecentEmojiWeightsAction& operator=(SyncActionValue_RecentEmojiWeightsAction&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncActionValue_RecentEmojiWeightsAction& default_instance() { + return *internal_default_instance(); + } + static inline const SyncActionValue_RecentEmojiWeightsAction* internal_default_instance() { + return reinterpret_cast( + &_SyncActionValue_RecentEmojiWeightsAction_default_instance_); + } + static constexpr int kIndexInFileMessages = + 194; + + friend void swap(SyncActionValue_RecentEmojiWeightsAction& a, SyncActionValue_RecentEmojiWeightsAction& b) { + a.Swap(&b); + } + inline void Swap(SyncActionValue_RecentEmojiWeightsAction* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncActionValue_RecentEmojiWeightsAction* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncActionValue_RecentEmojiWeightsAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncActionValue_RecentEmojiWeightsAction& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncActionValue_RecentEmojiWeightsAction& from) { + SyncActionValue_RecentEmojiWeightsAction::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncActionValue_RecentEmojiWeightsAction* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncActionValue.RecentEmojiWeightsAction"; + } + protected: + explicit SyncActionValue_RecentEmojiWeightsAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kWeightsFieldNumber = 1, + }; + // repeated .proto.RecentEmojiWeight weights = 1; + int weights_size() const; + private: + int _internal_weights_size() const; + public: + void clear_weights(); + ::proto::RecentEmojiWeight* mutable_weights(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::RecentEmojiWeight >* + mutable_weights(); + private: + const ::proto::RecentEmojiWeight& _internal_weights(int index) const; + ::proto::RecentEmojiWeight* _internal_add_weights(); + public: + const ::proto::RecentEmojiWeight& weights(int index) const; + ::proto::RecentEmojiWeight* add_weights(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::RecentEmojiWeight >& + weights() const; + + // @@protoc_insertion_point(class_scope:proto.SyncActionValue.RecentEmojiWeightsAction) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::RecentEmojiWeight > weights_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncActionValue_SecurityNotificationSetting final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.SecurityNotificationSetting) */ { + public: + inline SyncActionValue_SecurityNotificationSetting() : SyncActionValue_SecurityNotificationSetting(nullptr) {} + ~SyncActionValue_SecurityNotificationSetting() override; + explicit PROTOBUF_CONSTEXPR SyncActionValue_SecurityNotificationSetting(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncActionValue_SecurityNotificationSetting(const SyncActionValue_SecurityNotificationSetting& from); + SyncActionValue_SecurityNotificationSetting(SyncActionValue_SecurityNotificationSetting&& from) noexcept + : SyncActionValue_SecurityNotificationSetting() { + *this = ::std::move(from); + } + + inline SyncActionValue_SecurityNotificationSetting& operator=(const SyncActionValue_SecurityNotificationSetting& from) { + CopyFrom(from); + return *this; + } + inline SyncActionValue_SecurityNotificationSetting& operator=(SyncActionValue_SecurityNotificationSetting&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncActionValue_SecurityNotificationSetting& default_instance() { + return *internal_default_instance(); + } + static inline const SyncActionValue_SecurityNotificationSetting* internal_default_instance() { + return reinterpret_cast( + &_SyncActionValue_SecurityNotificationSetting_default_instance_); + } + static constexpr int kIndexInFileMessages = + 195; + + friend void swap(SyncActionValue_SecurityNotificationSetting& a, SyncActionValue_SecurityNotificationSetting& b) { + a.Swap(&b); + } + inline void Swap(SyncActionValue_SecurityNotificationSetting* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncActionValue_SecurityNotificationSetting* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncActionValue_SecurityNotificationSetting* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncActionValue_SecurityNotificationSetting& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncActionValue_SecurityNotificationSetting& from) { + SyncActionValue_SecurityNotificationSetting::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncActionValue_SecurityNotificationSetting* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncActionValue.SecurityNotificationSetting"; + } + protected: + explicit SyncActionValue_SecurityNotificationSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kShowNotificationFieldNumber = 1, + }; + // optional bool showNotification = 1; + bool has_shownotification() const; + private: + bool _internal_has_shownotification() const; + public: + void clear_shownotification(); + bool shownotification() const; + void set_shownotification(bool value); + private: + bool _internal_shownotification() const; + void _internal_set_shownotification(bool value); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncActionValue.SecurityNotificationSetting) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + bool shownotification_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncActionValue_StarAction final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.StarAction) */ { + public: + inline SyncActionValue_StarAction() : SyncActionValue_StarAction(nullptr) {} + ~SyncActionValue_StarAction() override; + explicit PROTOBUF_CONSTEXPR SyncActionValue_StarAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncActionValue_StarAction(const SyncActionValue_StarAction& from); + SyncActionValue_StarAction(SyncActionValue_StarAction&& from) noexcept + : SyncActionValue_StarAction() { + *this = ::std::move(from); + } + + inline SyncActionValue_StarAction& operator=(const SyncActionValue_StarAction& from) { + CopyFrom(from); + return *this; + } + inline SyncActionValue_StarAction& operator=(SyncActionValue_StarAction&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncActionValue_StarAction& default_instance() { + return *internal_default_instance(); + } + static inline const SyncActionValue_StarAction* internal_default_instance() { + return reinterpret_cast( + &_SyncActionValue_StarAction_default_instance_); + } + static constexpr int kIndexInFileMessages = + 196; + + friend void swap(SyncActionValue_StarAction& a, SyncActionValue_StarAction& b) { + a.Swap(&b); + } + inline void Swap(SyncActionValue_StarAction* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncActionValue_StarAction* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncActionValue_StarAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncActionValue_StarAction& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncActionValue_StarAction& from) { + SyncActionValue_StarAction::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncActionValue_StarAction* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncActionValue.StarAction"; + } + protected: + explicit SyncActionValue_StarAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kStarredFieldNumber = 1, + }; + // optional bool starred = 1; + bool has_starred() const; + private: + bool _internal_has_starred() const; + public: + void clear_starred(); + bool starred() const; + void set_starred(bool value); + private: + bool _internal_starred() const; + void _internal_set_starred(bool value); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncActionValue.StarAction) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + bool starred_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncActionValue_StickerAction final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.StickerAction) */ { + public: + inline SyncActionValue_StickerAction() : SyncActionValue_StickerAction(nullptr) {} + ~SyncActionValue_StickerAction() override; + explicit PROTOBUF_CONSTEXPR SyncActionValue_StickerAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncActionValue_StickerAction(const SyncActionValue_StickerAction& from); + SyncActionValue_StickerAction(SyncActionValue_StickerAction&& from) noexcept + : SyncActionValue_StickerAction() { + *this = ::std::move(from); + } + + inline SyncActionValue_StickerAction& operator=(const SyncActionValue_StickerAction& from) { + CopyFrom(from); + return *this; + } + inline SyncActionValue_StickerAction& operator=(SyncActionValue_StickerAction&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncActionValue_StickerAction& default_instance() { + return *internal_default_instance(); + } + static inline const SyncActionValue_StickerAction* internal_default_instance() { + return reinterpret_cast( + &_SyncActionValue_StickerAction_default_instance_); + } + static constexpr int kIndexInFileMessages = + 197; + + friend void swap(SyncActionValue_StickerAction& a, SyncActionValue_StickerAction& b) { + a.Swap(&b); + } + inline void Swap(SyncActionValue_StickerAction* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncActionValue_StickerAction* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncActionValue_StickerAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncActionValue_StickerAction& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncActionValue_StickerAction& from) { + SyncActionValue_StickerAction::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncActionValue_StickerAction* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncActionValue.StickerAction"; + } + protected: + explicit SyncActionValue_StickerAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kUrlFieldNumber = 1, + kFileEncSha256FieldNumber = 2, + kMediaKeyFieldNumber = 3, + kMimetypeFieldNumber = 4, + kDirectPathFieldNumber = 7, + kHeightFieldNumber = 5, + kWidthFieldNumber = 6, + kFileLengthFieldNumber = 8, + kIsFavoriteFieldNumber = 9, + kDeviceIdHintFieldNumber = 10, + }; + // optional string url = 1; + bool has_url() const; + private: + bool _internal_has_url() const; + public: + void clear_url(); + const std::string& url() const; + template + void set_url(ArgT0&& arg0, ArgT... args); + std::string* mutable_url(); + PROTOBUF_NODISCARD std::string* release_url(); + void set_allocated_url(std::string* url); + private: + const std::string& _internal_url() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value); + std::string* _internal_mutable_url(); + public: + + // optional bytes fileEncSha256 = 2; + bool has_fileencsha256() const; + private: + bool _internal_has_fileencsha256() const; + public: + void clear_fileencsha256(); + const std::string& fileencsha256() const; + template + void set_fileencsha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_fileencsha256(); + PROTOBUF_NODISCARD std::string* release_fileencsha256(); + void set_allocated_fileencsha256(std::string* fileencsha256); + private: + const std::string& _internal_fileencsha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value); + std::string* _internal_mutable_fileencsha256(); + public: + + // optional bytes mediaKey = 3; + bool has_mediakey() const; + private: + bool _internal_has_mediakey() const; + public: + void clear_mediakey(); + const std::string& mediakey() const; + template + void set_mediakey(ArgT0&& arg0, ArgT... args); + std::string* mutable_mediakey(); + PROTOBUF_NODISCARD std::string* release_mediakey(); + void set_allocated_mediakey(std::string* mediakey); + private: + const std::string& _internal_mediakey() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value); + std::string* _internal_mutable_mediakey(); + public: + + // optional string mimetype = 4; + bool has_mimetype() const; + private: + bool _internal_has_mimetype() const; + public: + void clear_mimetype(); + const std::string& mimetype() const; + template + void set_mimetype(ArgT0&& arg0, ArgT... args); + std::string* mutable_mimetype(); + PROTOBUF_NODISCARD std::string* release_mimetype(); + void set_allocated_mimetype(std::string* mimetype); + private: + const std::string& _internal_mimetype() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value); + std::string* _internal_mutable_mimetype(); + public: + + // optional string directPath = 7; + bool has_directpath() const; + private: + bool _internal_has_directpath() const; + public: + void clear_directpath(); + const std::string& directpath() const; + template + void set_directpath(ArgT0&& arg0, ArgT... args); + std::string* mutable_directpath(); + PROTOBUF_NODISCARD std::string* release_directpath(); + void set_allocated_directpath(std::string* directpath); + private: + const std::string& _internal_directpath() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value); + std::string* _internal_mutable_directpath(); + public: + + // optional uint32 height = 5; + bool has_height() const; + private: + bool _internal_has_height() const; + public: + void clear_height(); + uint32_t height() const; + void set_height(uint32_t value); + private: + uint32_t _internal_height() const; + void _internal_set_height(uint32_t value); + public: + + // optional uint32 width = 6; + bool has_width() const; + private: + bool _internal_has_width() const; + public: + void clear_width(); + uint32_t width() const; + void set_width(uint32_t value); + private: + uint32_t _internal_width() const; + void _internal_set_width(uint32_t value); + public: + + // optional uint64 fileLength = 8; + bool has_filelength() const; + private: + bool _internal_has_filelength() const; + public: + void clear_filelength(); + uint64_t filelength() const; + void set_filelength(uint64_t value); + private: + uint64_t _internal_filelength() const; + void _internal_set_filelength(uint64_t value); + public: + + // optional bool isFavorite = 9; + bool has_isfavorite() const; + private: + bool _internal_has_isfavorite() const; + public: + void clear_isfavorite(); + bool isfavorite() const; + void set_isfavorite(bool value); + private: + bool _internal_isfavorite() const; + void _internal_set_isfavorite(bool value); + public: + + // optional uint32 deviceIdHint = 10; + bool has_deviceidhint() const; + private: + bool _internal_has_deviceidhint() const; + public: + void clear_deviceidhint(); + uint32_t deviceidhint() const; + void set_deviceidhint(uint32_t value); + private: + uint32_t _internal_deviceidhint() const; + void _internal_set_deviceidhint(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncActionValue.StickerAction) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mimetype_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_; + uint32_t height_; + uint32_t width_; + uint64_t filelength_; + bool isfavorite_; + uint32_t deviceidhint_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncActionValue_SubscriptionAction final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.SubscriptionAction) */ { + public: + inline SyncActionValue_SubscriptionAction() : SyncActionValue_SubscriptionAction(nullptr) {} + ~SyncActionValue_SubscriptionAction() override; + explicit PROTOBUF_CONSTEXPR SyncActionValue_SubscriptionAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncActionValue_SubscriptionAction(const SyncActionValue_SubscriptionAction& from); + SyncActionValue_SubscriptionAction(SyncActionValue_SubscriptionAction&& from) noexcept + : SyncActionValue_SubscriptionAction() { + *this = ::std::move(from); + } + + inline SyncActionValue_SubscriptionAction& operator=(const SyncActionValue_SubscriptionAction& from) { + CopyFrom(from); + return *this; + } + inline SyncActionValue_SubscriptionAction& operator=(SyncActionValue_SubscriptionAction&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncActionValue_SubscriptionAction& default_instance() { + return *internal_default_instance(); + } + static inline const SyncActionValue_SubscriptionAction* internal_default_instance() { + return reinterpret_cast( + &_SyncActionValue_SubscriptionAction_default_instance_); + } + static constexpr int kIndexInFileMessages = + 198; + + friend void swap(SyncActionValue_SubscriptionAction& a, SyncActionValue_SubscriptionAction& b) { + a.Swap(&b); + } + inline void Swap(SyncActionValue_SubscriptionAction* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncActionValue_SubscriptionAction* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncActionValue_SubscriptionAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncActionValue_SubscriptionAction& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncActionValue_SubscriptionAction& from) { + SyncActionValue_SubscriptionAction::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncActionValue_SubscriptionAction* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncActionValue.SubscriptionAction"; + } + protected: + explicit SyncActionValue_SubscriptionAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kExpirationDateFieldNumber = 3, + kIsDeactivatedFieldNumber = 1, + kIsAutoRenewingFieldNumber = 2, + }; + // optional int64 expirationDate = 3; + bool has_expirationdate() const; + private: + bool _internal_has_expirationdate() const; + public: + void clear_expirationdate(); + int64_t expirationdate() const; + void set_expirationdate(int64_t value); + private: + int64_t _internal_expirationdate() const; + void _internal_set_expirationdate(int64_t value); + public: + + // optional bool isDeactivated = 1; + bool has_isdeactivated() const; + private: + bool _internal_has_isdeactivated() const; + public: + void clear_isdeactivated(); + bool isdeactivated() const; + void set_isdeactivated(bool value); + private: + bool _internal_isdeactivated() const; + void _internal_set_isdeactivated(bool value); + public: + + // optional bool isAutoRenewing = 2; + bool has_isautorenewing() const; + private: + bool _internal_has_isautorenewing() const; + public: + void clear_isautorenewing(); + bool isautorenewing() const; + void set_isautorenewing(bool value); + private: + bool _internal_isautorenewing() const; + void _internal_set_isautorenewing(bool value); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncActionValue.SubscriptionAction) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + int64_t expirationdate_; + bool isdeactivated_; + bool isautorenewing_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncActionValue_SyncActionMessageRange final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.SyncActionMessageRange) */ { + public: + inline SyncActionValue_SyncActionMessageRange() : SyncActionValue_SyncActionMessageRange(nullptr) {} + ~SyncActionValue_SyncActionMessageRange() override; + explicit PROTOBUF_CONSTEXPR SyncActionValue_SyncActionMessageRange(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncActionValue_SyncActionMessageRange(const SyncActionValue_SyncActionMessageRange& from); + SyncActionValue_SyncActionMessageRange(SyncActionValue_SyncActionMessageRange&& from) noexcept + : SyncActionValue_SyncActionMessageRange() { + *this = ::std::move(from); + } + + inline SyncActionValue_SyncActionMessageRange& operator=(const SyncActionValue_SyncActionMessageRange& from) { + CopyFrom(from); + return *this; + } + inline SyncActionValue_SyncActionMessageRange& operator=(SyncActionValue_SyncActionMessageRange&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncActionValue_SyncActionMessageRange& default_instance() { + return *internal_default_instance(); + } + static inline const SyncActionValue_SyncActionMessageRange* internal_default_instance() { + return reinterpret_cast( + &_SyncActionValue_SyncActionMessageRange_default_instance_); + } + static constexpr int kIndexInFileMessages = + 199; + + friend void swap(SyncActionValue_SyncActionMessageRange& a, SyncActionValue_SyncActionMessageRange& b) { + a.Swap(&b); + } + inline void Swap(SyncActionValue_SyncActionMessageRange* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncActionValue_SyncActionMessageRange* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncActionValue_SyncActionMessageRange* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncActionValue_SyncActionMessageRange& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncActionValue_SyncActionMessageRange& from) { + SyncActionValue_SyncActionMessageRange::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncActionValue_SyncActionMessageRange* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncActionValue.SyncActionMessageRange"; + } + protected: + explicit SyncActionValue_SyncActionMessageRange(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMessagesFieldNumber = 3, + kLastMessageTimestampFieldNumber = 1, + kLastSystemMessageTimestampFieldNumber = 2, + }; + // repeated .proto.SyncActionValue.SyncActionMessage messages = 3; + int messages_size() const; + private: + int _internal_messages_size() const; + public: + void clear_messages(); + ::proto::SyncActionValue_SyncActionMessage* mutable_messages(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncActionValue_SyncActionMessage >* + mutable_messages(); + private: + const ::proto::SyncActionValue_SyncActionMessage& _internal_messages(int index) const; + ::proto::SyncActionValue_SyncActionMessage* _internal_add_messages(); + public: + const ::proto::SyncActionValue_SyncActionMessage& messages(int index) const; + ::proto::SyncActionValue_SyncActionMessage* add_messages(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncActionValue_SyncActionMessage >& + messages() const; + + // optional int64 lastMessageTimestamp = 1; + bool has_lastmessagetimestamp() const; + private: + bool _internal_has_lastmessagetimestamp() const; + public: + void clear_lastmessagetimestamp(); + int64_t lastmessagetimestamp() const; + void set_lastmessagetimestamp(int64_t value); + private: + int64_t _internal_lastmessagetimestamp() const; + void _internal_set_lastmessagetimestamp(int64_t value); + public: + + // optional int64 lastSystemMessageTimestamp = 2; + bool has_lastsystemmessagetimestamp() const; + private: + bool _internal_has_lastsystemmessagetimestamp() const; + public: + void clear_lastsystemmessagetimestamp(); + int64_t lastsystemmessagetimestamp() const; + void set_lastsystemmessagetimestamp(int64_t value); + private: + int64_t _internal_lastsystemmessagetimestamp() const; + void _internal_set_lastsystemmessagetimestamp(int64_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncActionValue.SyncActionMessageRange) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncActionValue_SyncActionMessage > messages_; + int64_t lastmessagetimestamp_; + int64_t lastsystemmessagetimestamp_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncActionValue_SyncActionMessage final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.SyncActionMessage) */ { + public: + inline SyncActionValue_SyncActionMessage() : SyncActionValue_SyncActionMessage(nullptr) {} + ~SyncActionValue_SyncActionMessage() override; + explicit PROTOBUF_CONSTEXPR SyncActionValue_SyncActionMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncActionValue_SyncActionMessage(const SyncActionValue_SyncActionMessage& from); + SyncActionValue_SyncActionMessage(SyncActionValue_SyncActionMessage&& from) noexcept + : SyncActionValue_SyncActionMessage() { + *this = ::std::move(from); + } + + inline SyncActionValue_SyncActionMessage& operator=(const SyncActionValue_SyncActionMessage& from) { + CopyFrom(from); + return *this; + } + inline SyncActionValue_SyncActionMessage& operator=(SyncActionValue_SyncActionMessage&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncActionValue_SyncActionMessage& default_instance() { + return *internal_default_instance(); + } + static inline const SyncActionValue_SyncActionMessage* internal_default_instance() { + return reinterpret_cast( + &_SyncActionValue_SyncActionMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 200; + + friend void swap(SyncActionValue_SyncActionMessage& a, SyncActionValue_SyncActionMessage& b) { + a.Swap(&b); + } + inline void Swap(SyncActionValue_SyncActionMessage* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncActionValue_SyncActionMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncActionValue_SyncActionMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncActionValue_SyncActionMessage& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncActionValue_SyncActionMessage& from) { + SyncActionValue_SyncActionMessage::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncActionValue_SyncActionMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncActionValue.SyncActionMessage"; + } + protected: + explicit SyncActionValue_SyncActionMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kKeyFieldNumber = 1, + kTimestampFieldNumber = 2, + }; + // optional .proto.MessageKey key = 1; + bool has_key() const; + private: + bool _internal_has_key() const; + public: + void clear_key(); + const ::proto::MessageKey& key() const; + PROTOBUF_NODISCARD ::proto::MessageKey* release_key(); + ::proto::MessageKey* mutable_key(); + void set_allocated_key(::proto::MessageKey* key); + private: + const ::proto::MessageKey& _internal_key() const; + ::proto::MessageKey* _internal_mutable_key(); + public: + void unsafe_arena_set_allocated_key( + ::proto::MessageKey* key); + ::proto::MessageKey* unsafe_arena_release_key(); + + // optional int64 timestamp = 2; + bool has_timestamp() const; + private: + bool _internal_has_timestamp() const; + public: + void clear_timestamp(); + int64_t timestamp() const; + void set_timestamp(int64_t value); + private: + int64_t _internal_timestamp() const; + void _internal_set_timestamp(int64_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncActionValue.SyncActionMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::proto::MessageKey* key_; + int64_t timestamp_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncActionValue_TimeFormatAction final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.TimeFormatAction) */ { + public: + inline SyncActionValue_TimeFormatAction() : SyncActionValue_TimeFormatAction(nullptr) {} + ~SyncActionValue_TimeFormatAction() override; + explicit PROTOBUF_CONSTEXPR SyncActionValue_TimeFormatAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncActionValue_TimeFormatAction(const SyncActionValue_TimeFormatAction& from); + SyncActionValue_TimeFormatAction(SyncActionValue_TimeFormatAction&& from) noexcept + : SyncActionValue_TimeFormatAction() { + *this = ::std::move(from); + } + + inline SyncActionValue_TimeFormatAction& operator=(const SyncActionValue_TimeFormatAction& from) { + CopyFrom(from); + return *this; + } + inline SyncActionValue_TimeFormatAction& operator=(SyncActionValue_TimeFormatAction&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncActionValue_TimeFormatAction& default_instance() { + return *internal_default_instance(); + } + static inline const SyncActionValue_TimeFormatAction* internal_default_instance() { + return reinterpret_cast( + &_SyncActionValue_TimeFormatAction_default_instance_); + } + static constexpr int kIndexInFileMessages = + 201; + + friend void swap(SyncActionValue_TimeFormatAction& a, SyncActionValue_TimeFormatAction& b) { + a.Swap(&b); + } + inline void Swap(SyncActionValue_TimeFormatAction* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncActionValue_TimeFormatAction* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncActionValue_TimeFormatAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncActionValue_TimeFormatAction& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncActionValue_TimeFormatAction& from) { + SyncActionValue_TimeFormatAction::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncActionValue_TimeFormatAction* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncActionValue.TimeFormatAction"; + } + protected: + explicit SyncActionValue_TimeFormatAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kIsTwentyFourHourFormatEnabledFieldNumber = 1, + }; + // optional bool isTwentyFourHourFormatEnabled = 1; + bool has_istwentyfourhourformatenabled() const; + private: + bool _internal_has_istwentyfourhourformatenabled() const; + public: + void clear_istwentyfourhourformatenabled(); + bool istwentyfourhourformatenabled() const; + void set_istwentyfourhourformatenabled(bool value); + private: + bool _internal_istwentyfourhourformatenabled() const; + void _internal_set_istwentyfourhourformatenabled(bool value); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncActionValue.TimeFormatAction) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + bool istwentyfourhourformatenabled_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncActionValue_UnarchiveChatsSetting final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.UnarchiveChatsSetting) */ { + public: + inline SyncActionValue_UnarchiveChatsSetting() : SyncActionValue_UnarchiveChatsSetting(nullptr) {} + ~SyncActionValue_UnarchiveChatsSetting() override; + explicit PROTOBUF_CONSTEXPR SyncActionValue_UnarchiveChatsSetting(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncActionValue_UnarchiveChatsSetting(const SyncActionValue_UnarchiveChatsSetting& from); + SyncActionValue_UnarchiveChatsSetting(SyncActionValue_UnarchiveChatsSetting&& from) noexcept + : SyncActionValue_UnarchiveChatsSetting() { + *this = ::std::move(from); + } + + inline SyncActionValue_UnarchiveChatsSetting& operator=(const SyncActionValue_UnarchiveChatsSetting& from) { + CopyFrom(from); + return *this; + } + inline SyncActionValue_UnarchiveChatsSetting& operator=(SyncActionValue_UnarchiveChatsSetting&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncActionValue_UnarchiveChatsSetting& default_instance() { + return *internal_default_instance(); + } + static inline const SyncActionValue_UnarchiveChatsSetting* internal_default_instance() { + return reinterpret_cast( + &_SyncActionValue_UnarchiveChatsSetting_default_instance_); + } + static constexpr int kIndexInFileMessages = + 202; + + friend void swap(SyncActionValue_UnarchiveChatsSetting& a, SyncActionValue_UnarchiveChatsSetting& b) { + a.Swap(&b); + } + inline void Swap(SyncActionValue_UnarchiveChatsSetting* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncActionValue_UnarchiveChatsSetting* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncActionValue_UnarchiveChatsSetting* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncActionValue_UnarchiveChatsSetting& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncActionValue_UnarchiveChatsSetting& from) { + SyncActionValue_UnarchiveChatsSetting::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncActionValue_UnarchiveChatsSetting* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncActionValue.UnarchiveChatsSetting"; + } + protected: + explicit SyncActionValue_UnarchiveChatsSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kUnarchiveChatsFieldNumber = 1, + }; + // optional bool unarchiveChats = 1; + bool has_unarchivechats() const; + private: + bool _internal_has_unarchivechats() const; + public: + void clear_unarchivechats(); + bool unarchivechats() const; + void set_unarchivechats(bool value); + private: + bool _internal_unarchivechats() const; + void _internal_set_unarchivechats(bool value); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncActionValue.UnarchiveChatsSetting) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + bool unarchivechats_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncActionValue_UserStatusMuteAction final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.UserStatusMuteAction) */ { + public: + inline SyncActionValue_UserStatusMuteAction() : SyncActionValue_UserStatusMuteAction(nullptr) {} + ~SyncActionValue_UserStatusMuteAction() override; + explicit PROTOBUF_CONSTEXPR SyncActionValue_UserStatusMuteAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncActionValue_UserStatusMuteAction(const SyncActionValue_UserStatusMuteAction& from); + SyncActionValue_UserStatusMuteAction(SyncActionValue_UserStatusMuteAction&& from) noexcept + : SyncActionValue_UserStatusMuteAction() { + *this = ::std::move(from); + } + + inline SyncActionValue_UserStatusMuteAction& operator=(const SyncActionValue_UserStatusMuteAction& from) { + CopyFrom(from); + return *this; + } + inline SyncActionValue_UserStatusMuteAction& operator=(SyncActionValue_UserStatusMuteAction&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncActionValue_UserStatusMuteAction& default_instance() { + return *internal_default_instance(); + } + static inline const SyncActionValue_UserStatusMuteAction* internal_default_instance() { + return reinterpret_cast( + &_SyncActionValue_UserStatusMuteAction_default_instance_); + } + static constexpr int kIndexInFileMessages = + 203; + + friend void swap(SyncActionValue_UserStatusMuteAction& a, SyncActionValue_UserStatusMuteAction& b) { + a.Swap(&b); + } + inline void Swap(SyncActionValue_UserStatusMuteAction* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncActionValue_UserStatusMuteAction* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncActionValue_UserStatusMuteAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncActionValue_UserStatusMuteAction& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncActionValue_UserStatusMuteAction& from) { + SyncActionValue_UserStatusMuteAction::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncActionValue_UserStatusMuteAction* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncActionValue.UserStatusMuteAction"; + } + protected: + explicit SyncActionValue_UserStatusMuteAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMutedFieldNumber = 1, + }; + // optional bool muted = 1; + bool has_muted() const; + private: + bool _internal_has_muted() const; + public: + void clear_muted(); + bool muted() const; + void set_muted(bool value); + private: + bool _internal_muted() const; + void _internal_set_muted(bool value); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncActionValue.UserStatusMuteAction) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + bool muted_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncActionValue final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue) */ { + public: + inline SyncActionValue() : SyncActionValue(nullptr) {} + ~SyncActionValue() override; + explicit PROTOBUF_CONSTEXPR SyncActionValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncActionValue(const SyncActionValue& from); + SyncActionValue(SyncActionValue&& from) noexcept + : SyncActionValue() { + *this = ::std::move(from); + } + + inline SyncActionValue& operator=(const SyncActionValue& from) { + CopyFrom(from); + return *this; + } + inline SyncActionValue& operator=(SyncActionValue&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncActionValue& default_instance() { + return *internal_default_instance(); + } + static inline const SyncActionValue* internal_default_instance() { + return reinterpret_cast( + &_SyncActionValue_default_instance_); + } + static constexpr int kIndexInFileMessages = + 204; + + friend void swap(SyncActionValue& a, SyncActionValue& b) { + a.Swap(&b); + } + inline void Swap(SyncActionValue* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncActionValue* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncActionValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncActionValue& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncActionValue& from) { + SyncActionValue::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncActionValue* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncActionValue"; + } + protected: + explicit SyncActionValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef SyncActionValue_AgentAction AgentAction; + typedef SyncActionValue_AndroidUnsupportedActions AndroidUnsupportedActions; + typedef SyncActionValue_ArchiveChatAction ArchiveChatAction; + typedef SyncActionValue_ClearChatAction ClearChatAction; + typedef SyncActionValue_ContactAction ContactAction; + typedef SyncActionValue_DeleteChatAction DeleteChatAction; + typedef SyncActionValue_DeleteMessageForMeAction DeleteMessageForMeAction; + typedef SyncActionValue_KeyExpiration KeyExpiration; + typedef SyncActionValue_LabelAssociationAction LabelAssociationAction; + typedef SyncActionValue_LabelEditAction LabelEditAction; + typedef SyncActionValue_LocaleSetting LocaleSetting; + typedef SyncActionValue_MarkChatAsReadAction MarkChatAsReadAction; + typedef SyncActionValue_MuteAction MuteAction; + typedef SyncActionValue_NuxAction NuxAction; + typedef SyncActionValue_PinAction PinAction; + typedef SyncActionValue_PrimaryFeature PrimaryFeature; + typedef SyncActionValue_PrimaryVersionAction PrimaryVersionAction; + typedef SyncActionValue_PushNameSetting PushNameSetting; + typedef SyncActionValue_QuickReplyAction QuickReplyAction; + typedef SyncActionValue_RecentEmojiWeightsAction RecentEmojiWeightsAction; + typedef SyncActionValue_SecurityNotificationSetting SecurityNotificationSetting; + typedef SyncActionValue_StarAction StarAction; + typedef SyncActionValue_StickerAction StickerAction; + typedef SyncActionValue_SubscriptionAction SubscriptionAction; + typedef SyncActionValue_SyncActionMessageRange SyncActionMessageRange; + typedef SyncActionValue_SyncActionMessage SyncActionMessage; + typedef SyncActionValue_TimeFormatAction TimeFormatAction; + typedef SyncActionValue_UnarchiveChatsSetting UnarchiveChatsSetting; + typedef SyncActionValue_UserStatusMuteAction UserStatusMuteAction; + + // accessors ------------------------------------------------------- + + enum : int { + kStarActionFieldNumber = 2, + kContactActionFieldNumber = 3, + kMuteActionFieldNumber = 4, + kPinActionFieldNumber = 5, + kSecurityNotificationSettingFieldNumber = 6, + kPushNameSettingFieldNumber = 7, + kQuickReplyActionFieldNumber = 8, + kRecentEmojiWeightsActionFieldNumber = 11, + kLabelEditActionFieldNumber = 14, + kLabelAssociationActionFieldNumber = 15, + kLocaleSettingFieldNumber = 16, + kArchiveChatActionFieldNumber = 17, + kDeleteMessageForMeActionFieldNumber = 18, + kKeyExpirationFieldNumber = 19, + kMarkChatAsReadActionFieldNumber = 20, + kClearChatActionFieldNumber = 21, + kDeleteChatActionFieldNumber = 22, + kUnarchiveChatsSettingFieldNumber = 23, + kPrimaryFeatureFieldNumber = 24, + kAndroidUnsupportedActionsFieldNumber = 26, + kAgentActionFieldNumber = 27, + kSubscriptionActionFieldNumber = 28, + kUserStatusMuteActionFieldNumber = 29, + kTimeFormatActionFieldNumber = 30, + kNuxActionFieldNumber = 31, + kPrimaryVersionActionFieldNumber = 32, + kStickerActionFieldNumber = 33, + kTimestampFieldNumber = 1, + }; + // optional .proto.SyncActionValue.StarAction starAction = 2; + bool has_staraction() const; + private: + bool _internal_has_staraction() const; + public: + void clear_staraction(); + const ::proto::SyncActionValue_StarAction& staraction() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue_StarAction* release_staraction(); + ::proto::SyncActionValue_StarAction* mutable_staraction(); + void set_allocated_staraction(::proto::SyncActionValue_StarAction* staraction); + private: + const ::proto::SyncActionValue_StarAction& _internal_staraction() const; + ::proto::SyncActionValue_StarAction* _internal_mutable_staraction(); + public: + void unsafe_arena_set_allocated_staraction( + ::proto::SyncActionValue_StarAction* staraction); + ::proto::SyncActionValue_StarAction* unsafe_arena_release_staraction(); + + // optional .proto.SyncActionValue.ContactAction contactAction = 3; + bool has_contactaction() const; + private: + bool _internal_has_contactaction() const; + public: + void clear_contactaction(); + const ::proto::SyncActionValue_ContactAction& contactaction() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue_ContactAction* release_contactaction(); + ::proto::SyncActionValue_ContactAction* mutable_contactaction(); + void set_allocated_contactaction(::proto::SyncActionValue_ContactAction* contactaction); + private: + const ::proto::SyncActionValue_ContactAction& _internal_contactaction() const; + ::proto::SyncActionValue_ContactAction* _internal_mutable_contactaction(); + public: + void unsafe_arena_set_allocated_contactaction( + ::proto::SyncActionValue_ContactAction* contactaction); + ::proto::SyncActionValue_ContactAction* unsafe_arena_release_contactaction(); + + // optional .proto.SyncActionValue.MuteAction muteAction = 4; + bool has_muteaction() const; + private: + bool _internal_has_muteaction() const; + public: + void clear_muteaction(); + const ::proto::SyncActionValue_MuteAction& muteaction() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue_MuteAction* release_muteaction(); + ::proto::SyncActionValue_MuteAction* mutable_muteaction(); + void set_allocated_muteaction(::proto::SyncActionValue_MuteAction* muteaction); + private: + const ::proto::SyncActionValue_MuteAction& _internal_muteaction() const; + ::proto::SyncActionValue_MuteAction* _internal_mutable_muteaction(); + public: + void unsafe_arena_set_allocated_muteaction( + ::proto::SyncActionValue_MuteAction* muteaction); + ::proto::SyncActionValue_MuteAction* unsafe_arena_release_muteaction(); + + // optional .proto.SyncActionValue.PinAction pinAction = 5; + bool has_pinaction() const; + private: + bool _internal_has_pinaction() const; + public: + void clear_pinaction(); + const ::proto::SyncActionValue_PinAction& pinaction() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue_PinAction* release_pinaction(); + ::proto::SyncActionValue_PinAction* mutable_pinaction(); + void set_allocated_pinaction(::proto::SyncActionValue_PinAction* pinaction); + private: + const ::proto::SyncActionValue_PinAction& _internal_pinaction() const; + ::proto::SyncActionValue_PinAction* _internal_mutable_pinaction(); + public: + void unsafe_arena_set_allocated_pinaction( + ::proto::SyncActionValue_PinAction* pinaction); + ::proto::SyncActionValue_PinAction* unsafe_arena_release_pinaction(); + + // optional .proto.SyncActionValue.SecurityNotificationSetting securityNotificationSetting = 6; + bool has_securitynotificationsetting() const; + private: + bool _internal_has_securitynotificationsetting() const; + public: + void clear_securitynotificationsetting(); + const ::proto::SyncActionValue_SecurityNotificationSetting& securitynotificationsetting() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue_SecurityNotificationSetting* release_securitynotificationsetting(); + ::proto::SyncActionValue_SecurityNotificationSetting* mutable_securitynotificationsetting(); + void set_allocated_securitynotificationsetting(::proto::SyncActionValue_SecurityNotificationSetting* securitynotificationsetting); + private: + const ::proto::SyncActionValue_SecurityNotificationSetting& _internal_securitynotificationsetting() const; + ::proto::SyncActionValue_SecurityNotificationSetting* _internal_mutable_securitynotificationsetting(); + public: + void unsafe_arena_set_allocated_securitynotificationsetting( + ::proto::SyncActionValue_SecurityNotificationSetting* securitynotificationsetting); + ::proto::SyncActionValue_SecurityNotificationSetting* unsafe_arena_release_securitynotificationsetting(); + + // optional .proto.SyncActionValue.PushNameSetting pushNameSetting = 7; + bool has_pushnamesetting() const; + private: + bool _internal_has_pushnamesetting() const; + public: + void clear_pushnamesetting(); + const ::proto::SyncActionValue_PushNameSetting& pushnamesetting() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue_PushNameSetting* release_pushnamesetting(); + ::proto::SyncActionValue_PushNameSetting* mutable_pushnamesetting(); + void set_allocated_pushnamesetting(::proto::SyncActionValue_PushNameSetting* pushnamesetting); + private: + const ::proto::SyncActionValue_PushNameSetting& _internal_pushnamesetting() const; + ::proto::SyncActionValue_PushNameSetting* _internal_mutable_pushnamesetting(); + public: + void unsafe_arena_set_allocated_pushnamesetting( + ::proto::SyncActionValue_PushNameSetting* pushnamesetting); + ::proto::SyncActionValue_PushNameSetting* unsafe_arena_release_pushnamesetting(); + + // optional .proto.SyncActionValue.QuickReplyAction quickReplyAction = 8; + bool has_quickreplyaction() const; + private: + bool _internal_has_quickreplyaction() const; + public: + void clear_quickreplyaction(); + const ::proto::SyncActionValue_QuickReplyAction& quickreplyaction() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue_QuickReplyAction* release_quickreplyaction(); + ::proto::SyncActionValue_QuickReplyAction* mutable_quickreplyaction(); + void set_allocated_quickreplyaction(::proto::SyncActionValue_QuickReplyAction* quickreplyaction); + private: + const ::proto::SyncActionValue_QuickReplyAction& _internal_quickreplyaction() const; + ::proto::SyncActionValue_QuickReplyAction* _internal_mutable_quickreplyaction(); + public: + void unsafe_arena_set_allocated_quickreplyaction( + ::proto::SyncActionValue_QuickReplyAction* quickreplyaction); + ::proto::SyncActionValue_QuickReplyAction* unsafe_arena_release_quickreplyaction(); + + // optional .proto.SyncActionValue.RecentEmojiWeightsAction recentEmojiWeightsAction = 11; + bool has_recentemojiweightsaction() const; + private: + bool _internal_has_recentemojiweightsaction() const; + public: + void clear_recentemojiweightsaction(); + const ::proto::SyncActionValue_RecentEmojiWeightsAction& recentemojiweightsaction() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue_RecentEmojiWeightsAction* release_recentemojiweightsaction(); + ::proto::SyncActionValue_RecentEmojiWeightsAction* mutable_recentemojiweightsaction(); + void set_allocated_recentemojiweightsaction(::proto::SyncActionValue_RecentEmojiWeightsAction* recentemojiweightsaction); + private: + const ::proto::SyncActionValue_RecentEmojiWeightsAction& _internal_recentemojiweightsaction() const; + ::proto::SyncActionValue_RecentEmojiWeightsAction* _internal_mutable_recentemojiweightsaction(); + public: + void unsafe_arena_set_allocated_recentemojiweightsaction( + ::proto::SyncActionValue_RecentEmojiWeightsAction* recentemojiweightsaction); + ::proto::SyncActionValue_RecentEmojiWeightsAction* unsafe_arena_release_recentemojiweightsaction(); + + // optional .proto.SyncActionValue.LabelEditAction labelEditAction = 14; + bool has_labeleditaction() const; + private: + bool _internal_has_labeleditaction() const; + public: + void clear_labeleditaction(); + const ::proto::SyncActionValue_LabelEditAction& labeleditaction() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue_LabelEditAction* release_labeleditaction(); + ::proto::SyncActionValue_LabelEditAction* mutable_labeleditaction(); + void set_allocated_labeleditaction(::proto::SyncActionValue_LabelEditAction* labeleditaction); + private: + const ::proto::SyncActionValue_LabelEditAction& _internal_labeleditaction() const; + ::proto::SyncActionValue_LabelEditAction* _internal_mutable_labeleditaction(); + public: + void unsafe_arena_set_allocated_labeleditaction( + ::proto::SyncActionValue_LabelEditAction* labeleditaction); + ::proto::SyncActionValue_LabelEditAction* unsafe_arena_release_labeleditaction(); + + // optional .proto.SyncActionValue.LabelAssociationAction labelAssociationAction = 15; + bool has_labelassociationaction() const; + private: + bool _internal_has_labelassociationaction() const; + public: + void clear_labelassociationaction(); + const ::proto::SyncActionValue_LabelAssociationAction& labelassociationaction() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue_LabelAssociationAction* release_labelassociationaction(); + ::proto::SyncActionValue_LabelAssociationAction* mutable_labelassociationaction(); + void set_allocated_labelassociationaction(::proto::SyncActionValue_LabelAssociationAction* labelassociationaction); + private: + const ::proto::SyncActionValue_LabelAssociationAction& _internal_labelassociationaction() const; + ::proto::SyncActionValue_LabelAssociationAction* _internal_mutable_labelassociationaction(); + public: + void unsafe_arena_set_allocated_labelassociationaction( + ::proto::SyncActionValue_LabelAssociationAction* labelassociationaction); + ::proto::SyncActionValue_LabelAssociationAction* unsafe_arena_release_labelassociationaction(); + + // optional .proto.SyncActionValue.LocaleSetting localeSetting = 16; + bool has_localesetting() const; + private: + bool _internal_has_localesetting() const; + public: + void clear_localesetting(); + const ::proto::SyncActionValue_LocaleSetting& localesetting() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue_LocaleSetting* release_localesetting(); + ::proto::SyncActionValue_LocaleSetting* mutable_localesetting(); + void set_allocated_localesetting(::proto::SyncActionValue_LocaleSetting* localesetting); + private: + const ::proto::SyncActionValue_LocaleSetting& _internal_localesetting() const; + ::proto::SyncActionValue_LocaleSetting* _internal_mutable_localesetting(); + public: + void unsafe_arena_set_allocated_localesetting( + ::proto::SyncActionValue_LocaleSetting* localesetting); + ::proto::SyncActionValue_LocaleSetting* unsafe_arena_release_localesetting(); + + // optional .proto.SyncActionValue.ArchiveChatAction archiveChatAction = 17; + bool has_archivechataction() const; + private: + bool _internal_has_archivechataction() const; + public: + void clear_archivechataction(); + const ::proto::SyncActionValue_ArchiveChatAction& archivechataction() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue_ArchiveChatAction* release_archivechataction(); + ::proto::SyncActionValue_ArchiveChatAction* mutable_archivechataction(); + void set_allocated_archivechataction(::proto::SyncActionValue_ArchiveChatAction* archivechataction); + private: + const ::proto::SyncActionValue_ArchiveChatAction& _internal_archivechataction() const; + ::proto::SyncActionValue_ArchiveChatAction* _internal_mutable_archivechataction(); + public: + void unsafe_arena_set_allocated_archivechataction( + ::proto::SyncActionValue_ArchiveChatAction* archivechataction); + ::proto::SyncActionValue_ArchiveChatAction* unsafe_arena_release_archivechataction(); + + // optional .proto.SyncActionValue.DeleteMessageForMeAction deleteMessageForMeAction = 18; + bool has_deletemessageformeaction() const; + private: + bool _internal_has_deletemessageformeaction() const; + public: + void clear_deletemessageformeaction(); + const ::proto::SyncActionValue_DeleteMessageForMeAction& deletemessageformeaction() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue_DeleteMessageForMeAction* release_deletemessageformeaction(); + ::proto::SyncActionValue_DeleteMessageForMeAction* mutable_deletemessageformeaction(); + void set_allocated_deletemessageformeaction(::proto::SyncActionValue_DeleteMessageForMeAction* deletemessageformeaction); + private: + const ::proto::SyncActionValue_DeleteMessageForMeAction& _internal_deletemessageformeaction() const; + ::proto::SyncActionValue_DeleteMessageForMeAction* _internal_mutable_deletemessageformeaction(); + public: + void unsafe_arena_set_allocated_deletemessageformeaction( + ::proto::SyncActionValue_DeleteMessageForMeAction* deletemessageformeaction); + ::proto::SyncActionValue_DeleteMessageForMeAction* unsafe_arena_release_deletemessageformeaction(); + + // optional .proto.SyncActionValue.KeyExpiration keyExpiration = 19; + bool has_keyexpiration() const; + private: + bool _internal_has_keyexpiration() const; + public: + void clear_keyexpiration(); + const ::proto::SyncActionValue_KeyExpiration& keyexpiration() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue_KeyExpiration* release_keyexpiration(); + ::proto::SyncActionValue_KeyExpiration* mutable_keyexpiration(); + void set_allocated_keyexpiration(::proto::SyncActionValue_KeyExpiration* keyexpiration); + private: + const ::proto::SyncActionValue_KeyExpiration& _internal_keyexpiration() const; + ::proto::SyncActionValue_KeyExpiration* _internal_mutable_keyexpiration(); + public: + void unsafe_arena_set_allocated_keyexpiration( + ::proto::SyncActionValue_KeyExpiration* keyexpiration); + ::proto::SyncActionValue_KeyExpiration* unsafe_arena_release_keyexpiration(); + + // optional .proto.SyncActionValue.MarkChatAsReadAction markChatAsReadAction = 20; + bool has_markchatasreadaction() const; + private: + bool _internal_has_markchatasreadaction() const; + public: + void clear_markchatasreadaction(); + const ::proto::SyncActionValue_MarkChatAsReadAction& markchatasreadaction() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue_MarkChatAsReadAction* release_markchatasreadaction(); + ::proto::SyncActionValue_MarkChatAsReadAction* mutable_markchatasreadaction(); + void set_allocated_markchatasreadaction(::proto::SyncActionValue_MarkChatAsReadAction* markchatasreadaction); + private: + const ::proto::SyncActionValue_MarkChatAsReadAction& _internal_markchatasreadaction() const; + ::proto::SyncActionValue_MarkChatAsReadAction* _internal_mutable_markchatasreadaction(); + public: + void unsafe_arena_set_allocated_markchatasreadaction( + ::proto::SyncActionValue_MarkChatAsReadAction* markchatasreadaction); + ::proto::SyncActionValue_MarkChatAsReadAction* unsafe_arena_release_markchatasreadaction(); + + // optional .proto.SyncActionValue.ClearChatAction clearChatAction = 21; + bool has_clearchataction() const; + private: + bool _internal_has_clearchataction() const; + public: + void clear_clearchataction(); + const ::proto::SyncActionValue_ClearChatAction& clearchataction() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue_ClearChatAction* release_clearchataction(); + ::proto::SyncActionValue_ClearChatAction* mutable_clearchataction(); + void set_allocated_clearchataction(::proto::SyncActionValue_ClearChatAction* clearchataction); + private: + const ::proto::SyncActionValue_ClearChatAction& _internal_clearchataction() const; + ::proto::SyncActionValue_ClearChatAction* _internal_mutable_clearchataction(); + public: + void unsafe_arena_set_allocated_clearchataction( + ::proto::SyncActionValue_ClearChatAction* clearchataction); + ::proto::SyncActionValue_ClearChatAction* unsafe_arena_release_clearchataction(); + + // optional .proto.SyncActionValue.DeleteChatAction deleteChatAction = 22; + bool has_deletechataction() const; + private: + bool _internal_has_deletechataction() const; + public: + void clear_deletechataction(); + const ::proto::SyncActionValue_DeleteChatAction& deletechataction() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue_DeleteChatAction* release_deletechataction(); + ::proto::SyncActionValue_DeleteChatAction* mutable_deletechataction(); + void set_allocated_deletechataction(::proto::SyncActionValue_DeleteChatAction* deletechataction); + private: + const ::proto::SyncActionValue_DeleteChatAction& _internal_deletechataction() const; + ::proto::SyncActionValue_DeleteChatAction* _internal_mutable_deletechataction(); + public: + void unsafe_arena_set_allocated_deletechataction( + ::proto::SyncActionValue_DeleteChatAction* deletechataction); + ::proto::SyncActionValue_DeleteChatAction* unsafe_arena_release_deletechataction(); + + // optional .proto.SyncActionValue.UnarchiveChatsSetting unarchiveChatsSetting = 23; + bool has_unarchivechatssetting() const; + private: + bool _internal_has_unarchivechatssetting() const; + public: + void clear_unarchivechatssetting(); + const ::proto::SyncActionValue_UnarchiveChatsSetting& unarchivechatssetting() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue_UnarchiveChatsSetting* release_unarchivechatssetting(); + ::proto::SyncActionValue_UnarchiveChatsSetting* mutable_unarchivechatssetting(); + void set_allocated_unarchivechatssetting(::proto::SyncActionValue_UnarchiveChatsSetting* unarchivechatssetting); + private: + const ::proto::SyncActionValue_UnarchiveChatsSetting& _internal_unarchivechatssetting() const; + ::proto::SyncActionValue_UnarchiveChatsSetting* _internal_mutable_unarchivechatssetting(); + public: + void unsafe_arena_set_allocated_unarchivechatssetting( + ::proto::SyncActionValue_UnarchiveChatsSetting* unarchivechatssetting); + ::proto::SyncActionValue_UnarchiveChatsSetting* unsafe_arena_release_unarchivechatssetting(); + + // optional .proto.SyncActionValue.PrimaryFeature primaryFeature = 24; + bool has_primaryfeature() const; + private: + bool _internal_has_primaryfeature() const; + public: + void clear_primaryfeature(); + const ::proto::SyncActionValue_PrimaryFeature& primaryfeature() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue_PrimaryFeature* release_primaryfeature(); + ::proto::SyncActionValue_PrimaryFeature* mutable_primaryfeature(); + void set_allocated_primaryfeature(::proto::SyncActionValue_PrimaryFeature* primaryfeature); + private: + const ::proto::SyncActionValue_PrimaryFeature& _internal_primaryfeature() const; + ::proto::SyncActionValue_PrimaryFeature* _internal_mutable_primaryfeature(); + public: + void unsafe_arena_set_allocated_primaryfeature( + ::proto::SyncActionValue_PrimaryFeature* primaryfeature); + ::proto::SyncActionValue_PrimaryFeature* unsafe_arena_release_primaryfeature(); + + // optional .proto.SyncActionValue.AndroidUnsupportedActions androidUnsupportedActions = 26; + bool has_androidunsupportedactions() const; + private: + bool _internal_has_androidunsupportedactions() const; + public: + void clear_androidunsupportedactions(); + const ::proto::SyncActionValue_AndroidUnsupportedActions& androidunsupportedactions() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue_AndroidUnsupportedActions* release_androidunsupportedactions(); + ::proto::SyncActionValue_AndroidUnsupportedActions* mutable_androidunsupportedactions(); + void set_allocated_androidunsupportedactions(::proto::SyncActionValue_AndroidUnsupportedActions* androidunsupportedactions); + private: + const ::proto::SyncActionValue_AndroidUnsupportedActions& _internal_androidunsupportedactions() const; + ::proto::SyncActionValue_AndroidUnsupportedActions* _internal_mutable_androidunsupportedactions(); + public: + void unsafe_arena_set_allocated_androidunsupportedactions( + ::proto::SyncActionValue_AndroidUnsupportedActions* androidunsupportedactions); + ::proto::SyncActionValue_AndroidUnsupportedActions* unsafe_arena_release_androidunsupportedactions(); + + // optional .proto.SyncActionValue.AgentAction agentAction = 27; + bool has_agentaction() const; + private: + bool _internal_has_agentaction() const; + public: + void clear_agentaction(); + const ::proto::SyncActionValue_AgentAction& agentaction() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue_AgentAction* release_agentaction(); + ::proto::SyncActionValue_AgentAction* mutable_agentaction(); + void set_allocated_agentaction(::proto::SyncActionValue_AgentAction* agentaction); + private: + const ::proto::SyncActionValue_AgentAction& _internal_agentaction() const; + ::proto::SyncActionValue_AgentAction* _internal_mutable_agentaction(); + public: + void unsafe_arena_set_allocated_agentaction( + ::proto::SyncActionValue_AgentAction* agentaction); + ::proto::SyncActionValue_AgentAction* unsafe_arena_release_agentaction(); + + // optional .proto.SyncActionValue.SubscriptionAction subscriptionAction = 28; + bool has_subscriptionaction() const; + private: + bool _internal_has_subscriptionaction() const; + public: + void clear_subscriptionaction(); + const ::proto::SyncActionValue_SubscriptionAction& subscriptionaction() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue_SubscriptionAction* release_subscriptionaction(); + ::proto::SyncActionValue_SubscriptionAction* mutable_subscriptionaction(); + void set_allocated_subscriptionaction(::proto::SyncActionValue_SubscriptionAction* subscriptionaction); + private: + const ::proto::SyncActionValue_SubscriptionAction& _internal_subscriptionaction() const; + ::proto::SyncActionValue_SubscriptionAction* _internal_mutable_subscriptionaction(); + public: + void unsafe_arena_set_allocated_subscriptionaction( + ::proto::SyncActionValue_SubscriptionAction* subscriptionaction); + ::proto::SyncActionValue_SubscriptionAction* unsafe_arena_release_subscriptionaction(); + + // optional .proto.SyncActionValue.UserStatusMuteAction userStatusMuteAction = 29; + bool has_userstatusmuteaction() const; + private: + bool _internal_has_userstatusmuteaction() const; + public: + void clear_userstatusmuteaction(); + const ::proto::SyncActionValue_UserStatusMuteAction& userstatusmuteaction() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue_UserStatusMuteAction* release_userstatusmuteaction(); + ::proto::SyncActionValue_UserStatusMuteAction* mutable_userstatusmuteaction(); + void set_allocated_userstatusmuteaction(::proto::SyncActionValue_UserStatusMuteAction* userstatusmuteaction); + private: + const ::proto::SyncActionValue_UserStatusMuteAction& _internal_userstatusmuteaction() const; + ::proto::SyncActionValue_UserStatusMuteAction* _internal_mutable_userstatusmuteaction(); + public: + void unsafe_arena_set_allocated_userstatusmuteaction( + ::proto::SyncActionValue_UserStatusMuteAction* userstatusmuteaction); + ::proto::SyncActionValue_UserStatusMuteAction* unsafe_arena_release_userstatusmuteaction(); + + // optional .proto.SyncActionValue.TimeFormatAction timeFormatAction = 30; + bool has_timeformataction() const; + private: + bool _internal_has_timeformataction() const; + public: + void clear_timeformataction(); + const ::proto::SyncActionValue_TimeFormatAction& timeformataction() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue_TimeFormatAction* release_timeformataction(); + ::proto::SyncActionValue_TimeFormatAction* mutable_timeformataction(); + void set_allocated_timeformataction(::proto::SyncActionValue_TimeFormatAction* timeformataction); + private: + const ::proto::SyncActionValue_TimeFormatAction& _internal_timeformataction() const; + ::proto::SyncActionValue_TimeFormatAction* _internal_mutable_timeformataction(); + public: + void unsafe_arena_set_allocated_timeformataction( + ::proto::SyncActionValue_TimeFormatAction* timeformataction); + ::proto::SyncActionValue_TimeFormatAction* unsafe_arena_release_timeformataction(); + + // optional .proto.SyncActionValue.NuxAction nuxAction = 31; + bool has_nuxaction() const; + private: + bool _internal_has_nuxaction() const; + public: + void clear_nuxaction(); + const ::proto::SyncActionValue_NuxAction& nuxaction() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue_NuxAction* release_nuxaction(); + ::proto::SyncActionValue_NuxAction* mutable_nuxaction(); + void set_allocated_nuxaction(::proto::SyncActionValue_NuxAction* nuxaction); + private: + const ::proto::SyncActionValue_NuxAction& _internal_nuxaction() const; + ::proto::SyncActionValue_NuxAction* _internal_mutable_nuxaction(); + public: + void unsafe_arena_set_allocated_nuxaction( + ::proto::SyncActionValue_NuxAction* nuxaction); + ::proto::SyncActionValue_NuxAction* unsafe_arena_release_nuxaction(); + + // optional .proto.SyncActionValue.PrimaryVersionAction primaryVersionAction = 32; + bool has_primaryversionaction() const; + private: + bool _internal_has_primaryversionaction() const; + public: + void clear_primaryversionaction(); + const ::proto::SyncActionValue_PrimaryVersionAction& primaryversionaction() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue_PrimaryVersionAction* release_primaryversionaction(); + ::proto::SyncActionValue_PrimaryVersionAction* mutable_primaryversionaction(); + void set_allocated_primaryversionaction(::proto::SyncActionValue_PrimaryVersionAction* primaryversionaction); + private: + const ::proto::SyncActionValue_PrimaryVersionAction& _internal_primaryversionaction() const; + ::proto::SyncActionValue_PrimaryVersionAction* _internal_mutable_primaryversionaction(); + public: + void unsafe_arena_set_allocated_primaryversionaction( + ::proto::SyncActionValue_PrimaryVersionAction* primaryversionaction); + ::proto::SyncActionValue_PrimaryVersionAction* unsafe_arena_release_primaryversionaction(); + + // optional .proto.SyncActionValue.StickerAction stickerAction = 33; + bool has_stickeraction() const; + private: + bool _internal_has_stickeraction() const; + public: + void clear_stickeraction(); + const ::proto::SyncActionValue_StickerAction& stickeraction() const; + PROTOBUF_NODISCARD ::proto::SyncActionValue_StickerAction* release_stickeraction(); + ::proto::SyncActionValue_StickerAction* mutable_stickeraction(); + void set_allocated_stickeraction(::proto::SyncActionValue_StickerAction* stickeraction); + private: + const ::proto::SyncActionValue_StickerAction& _internal_stickeraction() const; + ::proto::SyncActionValue_StickerAction* _internal_mutable_stickeraction(); + public: + void unsafe_arena_set_allocated_stickeraction( + ::proto::SyncActionValue_StickerAction* stickeraction); + ::proto::SyncActionValue_StickerAction* unsafe_arena_release_stickeraction(); + + // optional int64 timestamp = 1; + bool has_timestamp() const; + private: + bool _internal_has_timestamp() const; + public: + void clear_timestamp(); + int64_t timestamp() const; + void set_timestamp(int64_t value); + private: + int64_t _internal_timestamp() const; + void _internal_set_timestamp(int64_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncActionValue) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::proto::SyncActionValue_StarAction* staraction_; + ::proto::SyncActionValue_ContactAction* contactaction_; + ::proto::SyncActionValue_MuteAction* muteaction_; + ::proto::SyncActionValue_PinAction* pinaction_; + ::proto::SyncActionValue_SecurityNotificationSetting* securitynotificationsetting_; + ::proto::SyncActionValue_PushNameSetting* pushnamesetting_; + ::proto::SyncActionValue_QuickReplyAction* quickreplyaction_; + ::proto::SyncActionValue_RecentEmojiWeightsAction* recentemojiweightsaction_; + ::proto::SyncActionValue_LabelEditAction* labeleditaction_; + ::proto::SyncActionValue_LabelAssociationAction* labelassociationaction_; + ::proto::SyncActionValue_LocaleSetting* localesetting_; + ::proto::SyncActionValue_ArchiveChatAction* archivechataction_; + ::proto::SyncActionValue_DeleteMessageForMeAction* deletemessageformeaction_; + ::proto::SyncActionValue_KeyExpiration* keyexpiration_; + ::proto::SyncActionValue_MarkChatAsReadAction* markchatasreadaction_; + ::proto::SyncActionValue_ClearChatAction* clearchataction_; + ::proto::SyncActionValue_DeleteChatAction* deletechataction_; + ::proto::SyncActionValue_UnarchiveChatsSetting* unarchivechatssetting_; + ::proto::SyncActionValue_PrimaryFeature* primaryfeature_; + ::proto::SyncActionValue_AndroidUnsupportedActions* androidunsupportedactions_; + ::proto::SyncActionValue_AgentAction* agentaction_; + ::proto::SyncActionValue_SubscriptionAction* subscriptionaction_; + ::proto::SyncActionValue_UserStatusMuteAction* userstatusmuteaction_; + ::proto::SyncActionValue_TimeFormatAction* timeformataction_; + ::proto::SyncActionValue_NuxAction* nuxaction_; + ::proto::SyncActionValue_PrimaryVersionAction* primaryversionaction_; + ::proto::SyncActionValue_StickerAction* stickeraction_; + int64_t timestamp_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncdIndex final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdIndex) */ { + public: + inline SyncdIndex() : SyncdIndex(nullptr) {} + ~SyncdIndex() override; + explicit PROTOBUF_CONSTEXPR SyncdIndex(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncdIndex(const SyncdIndex& from); + SyncdIndex(SyncdIndex&& from) noexcept + : SyncdIndex() { + *this = ::std::move(from); + } + + inline SyncdIndex& operator=(const SyncdIndex& from) { + CopyFrom(from); + return *this; + } + inline SyncdIndex& operator=(SyncdIndex&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncdIndex& default_instance() { + return *internal_default_instance(); + } + static inline const SyncdIndex* internal_default_instance() { + return reinterpret_cast( + &_SyncdIndex_default_instance_); + } + static constexpr int kIndexInFileMessages = + 205; + + friend void swap(SyncdIndex& a, SyncdIndex& b) { + a.Swap(&b); + } + inline void Swap(SyncdIndex* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncdIndex* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncdIndex* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncdIndex& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncdIndex& from) { + SyncdIndex::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncdIndex* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncdIndex"; + } + protected: + explicit SyncdIndex(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kBlobFieldNumber = 1, + }; + // optional bytes blob = 1; + bool has_blob() const; + private: + bool _internal_has_blob() const; + public: + void clear_blob(); + const std::string& blob() const; + template + void set_blob(ArgT0&& arg0, ArgT... args); + std::string* mutable_blob(); + PROTOBUF_NODISCARD std::string* release_blob(); + void set_allocated_blob(std::string* blob); + private: + const std::string& _internal_blob() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_blob(const std::string& value); + std::string* _internal_mutable_blob(); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncdIndex) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr blob_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncdMutation final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdMutation) */ { + public: + inline SyncdMutation() : SyncdMutation(nullptr) {} + ~SyncdMutation() override; + explicit PROTOBUF_CONSTEXPR SyncdMutation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncdMutation(const SyncdMutation& from); + SyncdMutation(SyncdMutation&& from) noexcept + : SyncdMutation() { + *this = ::std::move(from); + } + + inline SyncdMutation& operator=(const SyncdMutation& from) { + CopyFrom(from); + return *this; + } + inline SyncdMutation& operator=(SyncdMutation&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncdMutation& default_instance() { + return *internal_default_instance(); + } + static inline const SyncdMutation* internal_default_instance() { + return reinterpret_cast( + &_SyncdMutation_default_instance_); + } + static constexpr int kIndexInFileMessages = + 206; + + friend void swap(SyncdMutation& a, SyncdMutation& b) { + a.Swap(&b); + } + inline void Swap(SyncdMutation* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncdMutation* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncdMutation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncdMutation& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncdMutation& from) { + SyncdMutation::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncdMutation* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncdMutation"; + } + protected: + explicit SyncdMutation(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef SyncdMutation_SyncdOperation SyncdOperation; + static constexpr SyncdOperation SET = + SyncdMutation_SyncdOperation_SET; + static constexpr SyncdOperation REMOVE = + SyncdMutation_SyncdOperation_REMOVE; + static inline bool SyncdOperation_IsValid(int value) { + return SyncdMutation_SyncdOperation_IsValid(value); + } + static constexpr SyncdOperation SyncdOperation_MIN = + SyncdMutation_SyncdOperation_SyncdOperation_MIN; + static constexpr SyncdOperation SyncdOperation_MAX = + SyncdMutation_SyncdOperation_SyncdOperation_MAX; + static constexpr int SyncdOperation_ARRAYSIZE = + SyncdMutation_SyncdOperation_SyncdOperation_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + SyncdOperation_descriptor() { + return SyncdMutation_SyncdOperation_descriptor(); + } + template + static inline const std::string& SyncdOperation_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function SyncdOperation_Name."); + return SyncdMutation_SyncdOperation_Name(enum_t_value); + } + static inline bool SyncdOperation_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + SyncdOperation* value) { + return SyncdMutation_SyncdOperation_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kRecordFieldNumber = 2, + kOperationFieldNumber = 1, + }; + // optional .proto.SyncdRecord record = 2; + bool has_record() const; + private: + bool _internal_has_record() const; + public: + void clear_record(); + const ::proto::SyncdRecord& record() const; + PROTOBUF_NODISCARD ::proto::SyncdRecord* release_record(); + ::proto::SyncdRecord* mutable_record(); + void set_allocated_record(::proto::SyncdRecord* record); + private: + const ::proto::SyncdRecord& _internal_record() const; + ::proto::SyncdRecord* _internal_mutable_record(); + public: + void unsafe_arena_set_allocated_record( + ::proto::SyncdRecord* record); + ::proto::SyncdRecord* unsafe_arena_release_record(); + + // optional .proto.SyncdMutation.SyncdOperation operation = 1; + bool has_operation() const; + private: + bool _internal_has_operation() const; + public: + void clear_operation(); + ::proto::SyncdMutation_SyncdOperation operation() const; + void set_operation(::proto::SyncdMutation_SyncdOperation value); + private: + ::proto::SyncdMutation_SyncdOperation _internal_operation() const; + void _internal_set_operation(::proto::SyncdMutation_SyncdOperation value); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncdMutation) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::proto::SyncdRecord* record_; + int operation_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncdMutations final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdMutations) */ { + public: + inline SyncdMutations() : SyncdMutations(nullptr) {} + ~SyncdMutations() override; + explicit PROTOBUF_CONSTEXPR SyncdMutations(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncdMutations(const SyncdMutations& from); + SyncdMutations(SyncdMutations&& from) noexcept + : SyncdMutations() { + *this = ::std::move(from); + } + + inline SyncdMutations& operator=(const SyncdMutations& from) { + CopyFrom(from); + return *this; + } + inline SyncdMutations& operator=(SyncdMutations&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncdMutations& default_instance() { + return *internal_default_instance(); + } + static inline const SyncdMutations* internal_default_instance() { + return reinterpret_cast( + &_SyncdMutations_default_instance_); + } + static constexpr int kIndexInFileMessages = + 207; + + friend void swap(SyncdMutations& a, SyncdMutations& b) { + a.Swap(&b); + } + inline void Swap(SyncdMutations* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncdMutations* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncdMutations* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncdMutations& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncdMutations& from) { + SyncdMutations::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncdMutations* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncdMutations"; + } + protected: + explicit SyncdMutations(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMutationsFieldNumber = 1, + }; + // repeated .proto.SyncdMutation mutations = 1; + int mutations_size() const; + private: + int _internal_mutations_size() const; + public: + void clear_mutations(); + ::proto::SyncdMutation* mutable_mutations(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >* + mutable_mutations(); + private: + const ::proto::SyncdMutation& _internal_mutations(int index) const; + ::proto::SyncdMutation* _internal_add_mutations(); + public: + const ::proto::SyncdMutation& mutations(int index) const; + ::proto::SyncdMutation* add_mutations(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >& + mutations() const; + + // @@protoc_insertion_point(class_scope:proto.SyncdMutations) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation > mutations_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncdPatch final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdPatch) */ { + public: + inline SyncdPatch() : SyncdPatch(nullptr) {} + ~SyncdPatch() override; + explicit PROTOBUF_CONSTEXPR SyncdPatch(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncdPatch(const SyncdPatch& from); + SyncdPatch(SyncdPatch&& from) noexcept + : SyncdPatch() { + *this = ::std::move(from); + } + + inline SyncdPatch& operator=(const SyncdPatch& from) { + CopyFrom(from); + return *this; + } + inline SyncdPatch& operator=(SyncdPatch&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncdPatch& default_instance() { + return *internal_default_instance(); + } + static inline const SyncdPatch* internal_default_instance() { + return reinterpret_cast( + &_SyncdPatch_default_instance_); + } + static constexpr int kIndexInFileMessages = + 208; + + friend void swap(SyncdPatch& a, SyncdPatch& b) { + a.Swap(&b); + } + inline void Swap(SyncdPatch* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncdPatch* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncdPatch* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncdPatch& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncdPatch& from) { + SyncdPatch::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncdPatch* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncdPatch"; + } + protected: + explicit SyncdPatch(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMutationsFieldNumber = 2, + kSnapshotMacFieldNumber = 4, + kPatchMacFieldNumber = 5, + kVersionFieldNumber = 1, + kExternalMutationsFieldNumber = 3, + kKeyIdFieldNumber = 6, + kExitCodeFieldNumber = 7, + kDeviceIndexFieldNumber = 8, + }; + // repeated .proto.SyncdMutation mutations = 2; + int mutations_size() const; + private: + int _internal_mutations_size() const; + public: + void clear_mutations(); + ::proto::SyncdMutation* mutable_mutations(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >* + mutable_mutations(); + private: + const ::proto::SyncdMutation& _internal_mutations(int index) const; + ::proto::SyncdMutation* _internal_add_mutations(); + public: + const ::proto::SyncdMutation& mutations(int index) const; + ::proto::SyncdMutation* add_mutations(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >& + mutations() const; + + // optional bytes snapshotMac = 4; + bool has_snapshotmac() const; + private: + bool _internal_has_snapshotmac() const; + public: + void clear_snapshotmac(); + const std::string& snapshotmac() const; + template + void set_snapshotmac(ArgT0&& arg0, ArgT... args); + std::string* mutable_snapshotmac(); + PROTOBUF_NODISCARD std::string* release_snapshotmac(); + void set_allocated_snapshotmac(std::string* snapshotmac); + private: + const std::string& _internal_snapshotmac() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_snapshotmac(const std::string& value); + std::string* _internal_mutable_snapshotmac(); + public: + + // optional bytes patchMac = 5; + bool has_patchmac() const; + private: + bool _internal_has_patchmac() const; + public: + void clear_patchmac(); + const std::string& patchmac() const; + template + void set_patchmac(ArgT0&& arg0, ArgT... args); + std::string* mutable_patchmac(); + PROTOBUF_NODISCARD std::string* release_patchmac(); + void set_allocated_patchmac(std::string* patchmac); + private: + const std::string& _internal_patchmac() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_patchmac(const std::string& value); + std::string* _internal_mutable_patchmac(); + public: + + // optional .proto.SyncdVersion version = 1; + bool has_version() const; + private: + bool _internal_has_version() const; + public: + void clear_version(); + const ::proto::SyncdVersion& version() const; + PROTOBUF_NODISCARD ::proto::SyncdVersion* release_version(); + ::proto::SyncdVersion* mutable_version(); + void set_allocated_version(::proto::SyncdVersion* version); + private: + const ::proto::SyncdVersion& _internal_version() const; + ::proto::SyncdVersion* _internal_mutable_version(); + public: + void unsafe_arena_set_allocated_version( + ::proto::SyncdVersion* version); + ::proto::SyncdVersion* unsafe_arena_release_version(); + + // optional .proto.ExternalBlobReference externalMutations = 3; + bool has_externalmutations() const; + private: + bool _internal_has_externalmutations() const; + public: + void clear_externalmutations(); + const ::proto::ExternalBlobReference& externalmutations() const; + PROTOBUF_NODISCARD ::proto::ExternalBlobReference* release_externalmutations(); + ::proto::ExternalBlobReference* mutable_externalmutations(); + void set_allocated_externalmutations(::proto::ExternalBlobReference* externalmutations); + private: + const ::proto::ExternalBlobReference& _internal_externalmutations() const; + ::proto::ExternalBlobReference* _internal_mutable_externalmutations(); + public: + void unsafe_arena_set_allocated_externalmutations( + ::proto::ExternalBlobReference* externalmutations); + ::proto::ExternalBlobReference* unsafe_arena_release_externalmutations(); + + // optional .proto.KeyId keyId = 6; + bool has_keyid() const; + private: + bool _internal_has_keyid() const; + public: + void clear_keyid(); + const ::proto::KeyId& keyid() const; + PROTOBUF_NODISCARD ::proto::KeyId* release_keyid(); + ::proto::KeyId* mutable_keyid(); + void set_allocated_keyid(::proto::KeyId* keyid); + private: + const ::proto::KeyId& _internal_keyid() const; + ::proto::KeyId* _internal_mutable_keyid(); + public: + void unsafe_arena_set_allocated_keyid( + ::proto::KeyId* keyid); + ::proto::KeyId* unsafe_arena_release_keyid(); + + // optional .proto.ExitCode exitCode = 7; + bool has_exitcode() const; + private: + bool _internal_has_exitcode() const; + public: + void clear_exitcode(); + const ::proto::ExitCode& exitcode() const; + PROTOBUF_NODISCARD ::proto::ExitCode* release_exitcode(); + ::proto::ExitCode* mutable_exitcode(); + void set_allocated_exitcode(::proto::ExitCode* exitcode); + private: + const ::proto::ExitCode& _internal_exitcode() const; + ::proto::ExitCode* _internal_mutable_exitcode(); + public: + void unsafe_arena_set_allocated_exitcode( + ::proto::ExitCode* exitcode); + ::proto::ExitCode* unsafe_arena_release_exitcode(); + + // optional uint32 deviceIndex = 8; + bool has_deviceindex() const; + private: + bool _internal_has_deviceindex() const; + public: + void clear_deviceindex(); + uint32_t deviceindex() const; + void set_deviceindex(uint32_t value); + private: + uint32_t _internal_deviceindex() const; + void _internal_set_deviceindex(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncdPatch) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation > mutations_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr snapshotmac_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr patchmac_; + ::proto::SyncdVersion* version_; + ::proto::ExternalBlobReference* externalmutations_; + ::proto::KeyId* keyid_; + ::proto::ExitCode* exitcode_; + uint32_t deviceindex_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncdRecord final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdRecord) */ { + public: + inline SyncdRecord() : SyncdRecord(nullptr) {} + ~SyncdRecord() override; + explicit PROTOBUF_CONSTEXPR SyncdRecord(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncdRecord(const SyncdRecord& from); + SyncdRecord(SyncdRecord&& from) noexcept + : SyncdRecord() { + *this = ::std::move(from); + } + + inline SyncdRecord& operator=(const SyncdRecord& from) { + CopyFrom(from); + return *this; + } + inline SyncdRecord& operator=(SyncdRecord&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncdRecord& default_instance() { + return *internal_default_instance(); + } + static inline const SyncdRecord* internal_default_instance() { + return reinterpret_cast( + &_SyncdRecord_default_instance_); + } + static constexpr int kIndexInFileMessages = + 209; + + friend void swap(SyncdRecord& a, SyncdRecord& b) { + a.Swap(&b); + } + inline void Swap(SyncdRecord* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncdRecord* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncdRecord* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncdRecord& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncdRecord& from) { + SyncdRecord::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncdRecord* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncdRecord"; + } + protected: + explicit SyncdRecord(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kIndexFieldNumber = 1, + kValueFieldNumber = 2, + kKeyIdFieldNumber = 3, + }; + // optional .proto.SyncdIndex index = 1; + bool has_index() const; + private: + bool _internal_has_index() const; + public: + void clear_index(); + const ::proto::SyncdIndex& index() const; + PROTOBUF_NODISCARD ::proto::SyncdIndex* release_index(); + ::proto::SyncdIndex* mutable_index(); + void set_allocated_index(::proto::SyncdIndex* index); + private: + const ::proto::SyncdIndex& _internal_index() const; + ::proto::SyncdIndex* _internal_mutable_index(); + public: + void unsafe_arena_set_allocated_index( + ::proto::SyncdIndex* index); + ::proto::SyncdIndex* unsafe_arena_release_index(); + + // optional .proto.SyncdValue value = 2; + bool has_value() const; + private: + bool _internal_has_value() const; + public: + void clear_value(); + const ::proto::SyncdValue& value() const; + PROTOBUF_NODISCARD ::proto::SyncdValue* release_value(); + ::proto::SyncdValue* mutable_value(); + void set_allocated_value(::proto::SyncdValue* value); + private: + const ::proto::SyncdValue& _internal_value() const; + ::proto::SyncdValue* _internal_mutable_value(); + public: + void unsafe_arena_set_allocated_value( + ::proto::SyncdValue* value); + ::proto::SyncdValue* unsafe_arena_release_value(); + + // optional .proto.KeyId keyId = 3; + bool has_keyid() const; + private: + bool _internal_has_keyid() const; + public: + void clear_keyid(); + const ::proto::KeyId& keyid() const; + PROTOBUF_NODISCARD ::proto::KeyId* release_keyid(); + ::proto::KeyId* mutable_keyid(); + void set_allocated_keyid(::proto::KeyId* keyid); + private: + const ::proto::KeyId& _internal_keyid() const; + ::proto::KeyId* _internal_mutable_keyid(); + public: + void unsafe_arena_set_allocated_keyid( + ::proto::KeyId* keyid); + ::proto::KeyId* unsafe_arena_release_keyid(); + + // @@protoc_insertion_point(class_scope:proto.SyncdRecord) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::proto::SyncdIndex* index_; + ::proto::SyncdValue* value_; + ::proto::KeyId* keyid_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncdSnapshot final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdSnapshot) */ { + public: + inline SyncdSnapshot() : SyncdSnapshot(nullptr) {} + ~SyncdSnapshot() override; + explicit PROTOBUF_CONSTEXPR SyncdSnapshot(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncdSnapshot(const SyncdSnapshot& from); + SyncdSnapshot(SyncdSnapshot&& from) noexcept + : SyncdSnapshot() { + *this = ::std::move(from); + } + + inline SyncdSnapshot& operator=(const SyncdSnapshot& from) { + CopyFrom(from); + return *this; + } + inline SyncdSnapshot& operator=(SyncdSnapshot&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncdSnapshot& default_instance() { + return *internal_default_instance(); + } + static inline const SyncdSnapshot* internal_default_instance() { + return reinterpret_cast( + &_SyncdSnapshot_default_instance_); + } + static constexpr int kIndexInFileMessages = + 210; + + friend void swap(SyncdSnapshot& a, SyncdSnapshot& b) { + a.Swap(&b); + } + inline void Swap(SyncdSnapshot* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncdSnapshot* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncdSnapshot* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncdSnapshot& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncdSnapshot& from) { + SyncdSnapshot::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncdSnapshot* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncdSnapshot"; + } + protected: + explicit SyncdSnapshot(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kRecordsFieldNumber = 2, + kMacFieldNumber = 3, + kVersionFieldNumber = 1, + kKeyIdFieldNumber = 4, + }; + // repeated .proto.SyncdRecord records = 2; + int records_size() const; + private: + int _internal_records_size() const; + public: + void clear_records(); + ::proto::SyncdRecord* mutable_records(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdRecord >* + mutable_records(); + private: + const ::proto::SyncdRecord& _internal_records(int index) const; + ::proto::SyncdRecord* _internal_add_records(); + public: + const ::proto::SyncdRecord& records(int index) const; + ::proto::SyncdRecord* add_records(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdRecord >& + records() const; + + // optional bytes mac = 3; + bool has_mac() const; + private: + bool _internal_has_mac() const; + public: + void clear_mac(); + const std::string& mac() const; + template + void set_mac(ArgT0&& arg0, ArgT... args); + std::string* mutable_mac(); + PROTOBUF_NODISCARD std::string* release_mac(); + void set_allocated_mac(std::string* mac); + private: + const std::string& _internal_mac() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mac(const std::string& value); + std::string* _internal_mutable_mac(); + public: + + // optional .proto.SyncdVersion version = 1; + bool has_version() const; + private: + bool _internal_has_version() const; + public: + void clear_version(); + const ::proto::SyncdVersion& version() const; + PROTOBUF_NODISCARD ::proto::SyncdVersion* release_version(); + ::proto::SyncdVersion* mutable_version(); + void set_allocated_version(::proto::SyncdVersion* version); + private: + const ::proto::SyncdVersion& _internal_version() const; + ::proto::SyncdVersion* _internal_mutable_version(); + public: + void unsafe_arena_set_allocated_version( + ::proto::SyncdVersion* version); + ::proto::SyncdVersion* unsafe_arena_release_version(); + + // optional .proto.KeyId keyId = 4; + bool has_keyid() const; + private: + bool _internal_has_keyid() const; + public: + void clear_keyid(); + const ::proto::KeyId& keyid() const; + PROTOBUF_NODISCARD ::proto::KeyId* release_keyid(); + ::proto::KeyId* mutable_keyid(); + void set_allocated_keyid(::proto::KeyId* keyid); + private: + const ::proto::KeyId& _internal_keyid() const; + ::proto::KeyId* _internal_mutable_keyid(); + public: + void unsafe_arena_set_allocated_keyid( + ::proto::KeyId* keyid); + ::proto::KeyId* unsafe_arena_release_keyid(); + + // @@protoc_insertion_point(class_scope:proto.SyncdSnapshot) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdRecord > records_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mac_; + ::proto::SyncdVersion* version_; + ::proto::KeyId* keyid_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncdValue final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdValue) */ { + public: + inline SyncdValue() : SyncdValue(nullptr) {} + ~SyncdValue() override; + explicit PROTOBUF_CONSTEXPR SyncdValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncdValue(const SyncdValue& from); + SyncdValue(SyncdValue&& from) noexcept + : SyncdValue() { + *this = ::std::move(from); + } + + inline SyncdValue& operator=(const SyncdValue& from) { + CopyFrom(from); + return *this; + } + inline SyncdValue& operator=(SyncdValue&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncdValue& default_instance() { + return *internal_default_instance(); + } + static inline const SyncdValue* internal_default_instance() { + return reinterpret_cast( + &_SyncdValue_default_instance_); + } + static constexpr int kIndexInFileMessages = + 211; + + friend void swap(SyncdValue& a, SyncdValue& b) { + a.Swap(&b); + } + inline void Swap(SyncdValue* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncdValue* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncdValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncdValue& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncdValue& from) { + SyncdValue::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncdValue* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncdValue"; + } + protected: + explicit SyncdValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kBlobFieldNumber = 1, + }; + // optional bytes blob = 1; + bool has_blob() const; + private: + bool _internal_has_blob() const; + public: + void clear_blob(); + const std::string& blob() const; + template + void set_blob(ArgT0&& arg0, ArgT... args); + std::string* mutable_blob(); + PROTOBUF_NODISCARD std::string* release_blob(); + void set_allocated_blob(std::string* blob); + private: + const std::string& _internal_blob() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_blob(const std::string& value); + std::string* _internal_mutable_blob(); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncdValue) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr blob_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class SyncdVersion final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdVersion) */ { + public: + inline SyncdVersion() : SyncdVersion(nullptr) {} + ~SyncdVersion() override; + explicit PROTOBUF_CONSTEXPR SyncdVersion(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SyncdVersion(const SyncdVersion& from); + SyncdVersion(SyncdVersion&& from) noexcept + : SyncdVersion() { + *this = ::std::move(from); + } + + inline SyncdVersion& operator=(const SyncdVersion& from) { + CopyFrom(from); + return *this; + } + inline SyncdVersion& operator=(SyncdVersion&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SyncdVersion& default_instance() { + return *internal_default_instance(); + } + static inline const SyncdVersion* internal_default_instance() { + return reinterpret_cast( + &_SyncdVersion_default_instance_); + } + static constexpr int kIndexInFileMessages = + 212; + + friend void swap(SyncdVersion& a, SyncdVersion& b) { + a.Swap(&b); + } + inline void Swap(SyncdVersion* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SyncdVersion* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SyncdVersion* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SyncdVersion& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SyncdVersion& from) { + SyncdVersion::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SyncdVersion* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.SyncdVersion"; + } + protected: + explicit SyncdVersion(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kVersionFieldNumber = 1, + }; + // optional uint64 version = 1; + bool has_version() const; + private: + bool _internal_has_version() const; + public: + void clear_version(); + uint64_t version() const; + void set_version(uint64_t value); + private: + uint64_t _internal_version() const; + void _internal_set_version(uint64_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.SyncdVersion) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + uint64_t version_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class TemplateButton_CallButton final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.TemplateButton.CallButton) */ { + public: + inline TemplateButton_CallButton() : TemplateButton_CallButton(nullptr) {} + ~TemplateButton_CallButton() override; + explicit PROTOBUF_CONSTEXPR TemplateButton_CallButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + TemplateButton_CallButton(const TemplateButton_CallButton& from); + TemplateButton_CallButton(TemplateButton_CallButton&& from) noexcept + : TemplateButton_CallButton() { + *this = ::std::move(from); + } + + inline TemplateButton_CallButton& operator=(const TemplateButton_CallButton& from) { + CopyFrom(from); + return *this; + } + inline TemplateButton_CallButton& operator=(TemplateButton_CallButton&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const TemplateButton_CallButton& default_instance() { + return *internal_default_instance(); + } + static inline const TemplateButton_CallButton* internal_default_instance() { + return reinterpret_cast( + &_TemplateButton_CallButton_default_instance_); + } + static constexpr int kIndexInFileMessages = + 213; + + friend void swap(TemplateButton_CallButton& a, TemplateButton_CallButton& b) { + a.Swap(&b); + } + inline void Swap(TemplateButton_CallButton* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(TemplateButton_CallButton* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + TemplateButton_CallButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const TemplateButton_CallButton& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const TemplateButton_CallButton& from) { + TemplateButton_CallButton::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(TemplateButton_CallButton* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.TemplateButton.CallButton"; + } + protected: + explicit TemplateButton_CallButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDisplayTextFieldNumber = 1, + kPhoneNumberFieldNumber = 2, + }; + // optional .proto.Message.HighlyStructuredMessage displayText = 1; + bool has_displaytext() const; + private: + bool _internal_has_displaytext() const; + public: + void clear_displaytext(); + const ::proto::Message_HighlyStructuredMessage& displaytext() const; + PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_displaytext(); + ::proto::Message_HighlyStructuredMessage* mutable_displaytext(); + void set_allocated_displaytext(::proto::Message_HighlyStructuredMessage* displaytext); + private: + const ::proto::Message_HighlyStructuredMessage& _internal_displaytext() const; + ::proto::Message_HighlyStructuredMessage* _internal_mutable_displaytext(); + public: + void unsafe_arena_set_allocated_displaytext( + ::proto::Message_HighlyStructuredMessage* displaytext); + ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_displaytext(); + + // optional .proto.Message.HighlyStructuredMessage phoneNumber = 2; + bool has_phonenumber() const; + private: + bool _internal_has_phonenumber() const; + public: + void clear_phonenumber(); + const ::proto::Message_HighlyStructuredMessage& phonenumber() const; + PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_phonenumber(); + ::proto::Message_HighlyStructuredMessage* mutable_phonenumber(); + void set_allocated_phonenumber(::proto::Message_HighlyStructuredMessage* phonenumber); + private: + const ::proto::Message_HighlyStructuredMessage& _internal_phonenumber() const; + ::proto::Message_HighlyStructuredMessage* _internal_mutable_phonenumber(); + public: + void unsafe_arena_set_allocated_phonenumber( + ::proto::Message_HighlyStructuredMessage* phonenumber); + ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_phonenumber(); + + // @@protoc_insertion_point(class_scope:proto.TemplateButton.CallButton) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::proto::Message_HighlyStructuredMessage* displaytext_; + ::proto::Message_HighlyStructuredMessage* phonenumber_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class TemplateButton_QuickReplyButton final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.TemplateButton.QuickReplyButton) */ { + public: + inline TemplateButton_QuickReplyButton() : TemplateButton_QuickReplyButton(nullptr) {} + ~TemplateButton_QuickReplyButton() override; + explicit PROTOBUF_CONSTEXPR TemplateButton_QuickReplyButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + TemplateButton_QuickReplyButton(const TemplateButton_QuickReplyButton& from); + TemplateButton_QuickReplyButton(TemplateButton_QuickReplyButton&& from) noexcept + : TemplateButton_QuickReplyButton() { + *this = ::std::move(from); + } + + inline TemplateButton_QuickReplyButton& operator=(const TemplateButton_QuickReplyButton& from) { + CopyFrom(from); + return *this; + } + inline TemplateButton_QuickReplyButton& operator=(TemplateButton_QuickReplyButton&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const TemplateButton_QuickReplyButton& default_instance() { + return *internal_default_instance(); + } + static inline const TemplateButton_QuickReplyButton* internal_default_instance() { + return reinterpret_cast( + &_TemplateButton_QuickReplyButton_default_instance_); + } + static constexpr int kIndexInFileMessages = + 214; + + friend void swap(TemplateButton_QuickReplyButton& a, TemplateButton_QuickReplyButton& b) { + a.Swap(&b); + } + inline void Swap(TemplateButton_QuickReplyButton* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(TemplateButton_QuickReplyButton* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + TemplateButton_QuickReplyButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const TemplateButton_QuickReplyButton& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const TemplateButton_QuickReplyButton& from) { + TemplateButton_QuickReplyButton::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(TemplateButton_QuickReplyButton* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.TemplateButton.QuickReplyButton"; + } + protected: + explicit TemplateButton_QuickReplyButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kIdFieldNumber = 2, + kDisplayTextFieldNumber = 1, + }; + // optional string id = 2; + bool has_id() const; + private: + bool _internal_has_id() const; + public: + void clear_id(); + const std::string& id() const; + template + void set_id(ArgT0&& arg0, ArgT... args); + std::string* mutable_id(); + PROTOBUF_NODISCARD std::string* release_id(); + void set_allocated_id(std::string* id); + private: + const std::string& _internal_id() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value); + std::string* _internal_mutable_id(); + public: + + // optional .proto.Message.HighlyStructuredMessage displayText = 1; + bool has_displaytext() const; + private: + bool _internal_has_displaytext() const; + public: + void clear_displaytext(); + const ::proto::Message_HighlyStructuredMessage& displaytext() const; + PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_displaytext(); + ::proto::Message_HighlyStructuredMessage* mutable_displaytext(); + void set_allocated_displaytext(::proto::Message_HighlyStructuredMessage* displaytext); + private: + const ::proto::Message_HighlyStructuredMessage& _internal_displaytext() const; + ::proto::Message_HighlyStructuredMessage* _internal_mutable_displaytext(); + public: + void unsafe_arena_set_allocated_displaytext( + ::proto::Message_HighlyStructuredMessage* displaytext); + ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_displaytext(); + + // @@protoc_insertion_point(class_scope:proto.TemplateButton.QuickReplyButton) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_; + ::proto::Message_HighlyStructuredMessage* displaytext_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class TemplateButton_URLButton final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.TemplateButton.URLButton) */ { + public: + inline TemplateButton_URLButton() : TemplateButton_URLButton(nullptr) {} + ~TemplateButton_URLButton() override; + explicit PROTOBUF_CONSTEXPR TemplateButton_URLButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + TemplateButton_URLButton(const TemplateButton_URLButton& from); + TemplateButton_URLButton(TemplateButton_URLButton&& from) noexcept + : TemplateButton_URLButton() { + *this = ::std::move(from); + } + + inline TemplateButton_URLButton& operator=(const TemplateButton_URLButton& from) { + CopyFrom(from); + return *this; + } + inline TemplateButton_URLButton& operator=(TemplateButton_URLButton&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const TemplateButton_URLButton& default_instance() { + return *internal_default_instance(); + } + static inline const TemplateButton_URLButton* internal_default_instance() { + return reinterpret_cast( + &_TemplateButton_URLButton_default_instance_); + } + static constexpr int kIndexInFileMessages = + 215; + + friend void swap(TemplateButton_URLButton& a, TemplateButton_URLButton& b) { + a.Swap(&b); + } + inline void Swap(TemplateButton_URLButton* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(TemplateButton_URLButton* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + TemplateButton_URLButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const TemplateButton_URLButton& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const TemplateButton_URLButton& from) { + TemplateButton_URLButton::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(TemplateButton_URLButton* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.TemplateButton.URLButton"; + } + protected: + explicit TemplateButton_URLButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDisplayTextFieldNumber = 1, + kUrlFieldNumber = 2, + }; + // optional .proto.Message.HighlyStructuredMessage displayText = 1; + bool has_displaytext() const; + private: + bool _internal_has_displaytext() const; + public: + void clear_displaytext(); + const ::proto::Message_HighlyStructuredMessage& displaytext() const; + PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_displaytext(); + ::proto::Message_HighlyStructuredMessage* mutable_displaytext(); + void set_allocated_displaytext(::proto::Message_HighlyStructuredMessage* displaytext); + private: + const ::proto::Message_HighlyStructuredMessage& _internal_displaytext() const; + ::proto::Message_HighlyStructuredMessage* _internal_mutable_displaytext(); + public: + void unsafe_arena_set_allocated_displaytext( + ::proto::Message_HighlyStructuredMessage* displaytext); + ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_displaytext(); + + // optional .proto.Message.HighlyStructuredMessage url = 2; + bool has_url() const; + private: + bool _internal_has_url() const; + public: + void clear_url(); + const ::proto::Message_HighlyStructuredMessage& url() const; + PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_url(); + ::proto::Message_HighlyStructuredMessage* mutable_url(); + void set_allocated_url(::proto::Message_HighlyStructuredMessage* url); + private: + const ::proto::Message_HighlyStructuredMessage& _internal_url() const; + ::proto::Message_HighlyStructuredMessage* _internal_mutable_url(); + public: + void unsafe_arena_set_allocated_url( + ::proto::Message_HighlyStructuredMessage* url); + ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_url(); + + // @@protoc_insertion_point(class_scope:proto.TemplateButton.URLButton) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::proto::Message_HighlyStructuredMessage* displaytext_; + ::proto::Message_HighlyStructuredMessage* url_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class TemplateButton final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.TemplateButton) */ { + public: + inline TemplateButton() : TemplateButton(nullptr) {} + ~TemplateButton() override; + explicit PROTOBUF_CONSTEXPR TemplateButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + TemplateButton(const TemplateButton& from); + TemplateButton(TemplateButton&& from) noexcept + : TemplateButton() { + *this = ::std::move(from); + } + + inline TemplateButton& operator=(const TemplateButton& from) { + CopyFrom(from); + return *this; + } + inline TemplateButton& operator=(TemplateButton&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const TemplateButton& default_instance() { + return *internal_default_instance(); + } + enum ButtonCase { + kQuickReplyButton = 1, + kUrlButton = 2, + kCallButton = 3, + BUTTON_NOT_SET = 0, + }; + + static inline const TemplateButton* internal_default_instance() { + return reinterpret_cast( + &_TemplateButton_default_instance_); + } + static constexpr int kIndexInFileMessages = + 216; + + friend void swap(TemplateButton& a, TemplateButton& b) { + a.Swap(&b); + } + inline void Swap(TemplateButton* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(TemplateButton* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + TemplateButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const TemplateButton& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const TemplateButton& from) { + TemplateButton::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(TemplateButton* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.TemplateButton"; + } + protected: + explicit TemplateButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef TemplateButton_CallButton CallButton; + typedef TemplateButton_QuickReplyButton QuickReplyButton; + typedef TemplateButton_URLButton URLButton; + + // accessors ------------------------------------------------------- + + enum : int { + kIndexFieldNumber = 4, + kQuickReplyButtonFieldNumber = 1, + kUrlButtonFieldNumber = 2, + kCallButtonFieldNumber = 3, + }; + // optional uint32 index = 4; + bool has_index() const; + private: + bool _internal_has_index() const; + public: + void clear_index(); + uint32_t index() const; + void set_index(uint32_t value); + private: + uint32_t _internal_index() const; + void _internal_set_index(uint32_t value); + public: + + // .proto.TemplateButton.QuickReplyButton quickReplyButton = 1; + bool has_quickreplybutton() const; + private: + bool _internal_has_quickreplybutton() const; + public: + void clear_quickreplybutton(); + const ::proto::TemplateButton_QuickReplyButton& quickreplybutton() const; + PROTOBUF_NODISCARD ::proto::TemplateButton_QuickReplyButton* release_quickreplybutton(); + ::proto::TemplateButton_QuickReplyButton* mutable_quickreplybutton(); + void set_allocated_quickreplybutton(::proto::TemplateButton_QuickReplyButton* quickreplybutton); + private: + const ::proto::TemplateButton_QuickReplyButton& _internal_quickreplybutton() const; + ::proto::TemplateButton_QuickReplyButton* _internal_mutable_quickreplybutton(); + public: + void unsafe_arena_set_allocated_quickreplybutton( + ::proto::TemplateButton_QuickReplyButton* quickreplybutton); + ::proto::TemplateButton_QuickReplyButton* unsafe_arena_release_quickreplybutton(); + + // .proto.TemplateButton.URLButton urlButton = 2; + bool has_urlbutton() const; + private: + bool _internal_has_urlbutton() const; + public: + void clear_urlbutton(); + const ::proto::TemplateButton_URLButton& urlbutton() const; + PROTOBUF_NODISCARD ::proto::TemplateButton_URLButton* release_urlbutton(); + ::proto::TemplateButton_URLButton* mutable_urlbutton(); + void set_allocated_urlbutton(::proto::TemplateButton_URLButton* urlbutton); + private: + const ::proto::TemplateButton_URLButton& _internal_urlbutton() const; + ::proto::TemplateButton_URLButton* _internal_mutable_urlbutton(); + public: + void unsafe_arena_set_allocated_urlbutton( + ::proto::TemplateButton_URLButton* urlbutton); + ::proto::TemplateButton_URLButton* unsafe_arena_release_urlbutton(); + + // .proto.TemplateButton.CallButton callButton = 3; + bool has_callbutton() const; + private: + bool _internal_has_callbutton() const; + public: + void clear_callbutton(); + const ::proto::TemplateButton_CallButton& callbutton() const; + PROTOBUF_NODISCARD ::proto::TemplateButton_CallButton* release_callbutton(); + ::proto::TemplateButton_CallButton* mutable_callbutton(); + void set_allocated_callbutton(::proto::TemplateButton_CallButton* callbutton); + private: + const ::proto::TemplateButton_CallButton& _internal_callbutton() const; + ::proto::TemplateButton_CallButton* _internal_mutable_callbutton(); + public: + void unsafe_arena_set_allocated_callbutton( + ::proto::TemplateButton_CallButton* callbutton); + ::proto::TemplateButton_CallButton* unsafe_arena_release_callbutton(); + + void clear_button(); + ButtonCase button_case() const; + // @@protoc_insertion_point(class_scope:proto.TemplateButton) + private: + class _Internal; + void set_has_quickreplybutton(); + void set_has_urlbutton(); + void set_has_callbutton(); + + inline bool has_button() const; + inline void clear_has_button(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + uint32_t index_; + union ButtonUnion { + constexpr ButtonUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::proto::TemplateButton_QuickReplyButton* quickreplybutton_; + ::proto::TemplateButton_URLButton* urlbutton_; + ::proto::TemplateButton_CallButton* callbutton_; + } button_; + uint32_t _oneof_case_[1]; + + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class UserReceipt final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.UserReceipt) */ { + public: + inline UserReceipt() : UserReceipt(nullptr) {} + ~UserReceipt() override; + explicit PROTOBUF_CONSTEXPR UserReceipt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + UserReceipt(const UserReceipt& from); + UserReceipt(UserReceipt&& from) noexcept + : UserReceipt() { + *this = ::std::move(from); + } + + inline UserReceipt& operator=(const UserReceipt& from) { + CopyFrom(from); + return *this; + } + inline UserReceipt& operator=(UserReceipt&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const UserReceipt& default_instance() { + return *internal_default_instance(); + } + static inline const UserReceipt* internal_default_instance() { + return reinterpret_cast( + &_UserReceipt_default_instance_); + } + static constexpr int kIndexInFileMessages = + 217; + + friend void swap(UserReceipt& a, UserReceipt& b) { + a.Swap(&b); + } + inline void Swap(UserReceipt* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(UserReceipt* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + UserReceipt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const UserReceipt& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const UserReceipt& from) { + UserReceipt::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(UserReceipt* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.UserReceipt"; + } + protected: + explicit UserReceipt(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kPendingDeviceJidFieldNumber = 5, + kDeliveredDeviceJidFieldNumber = 6, + kUserJidFieldNumber = 1, + kReceiptTimestampFieldNumber = 2, + kReadTimestampFieldNumber = 3, + kPlayedTimestampFieldNumber = 4, + }; + // repeated string pendingDeviceJid = 5; + int pendingdevicejid_size() const; + private: + int _internal_pendingdevicejid_size() const; + public: + void clear_pendingdevicejid(); + const std::string& pendingdevicejid(int index) const; + std::string* mutable_pendingdevicejid(int index); + void set_pendingdevicejid(int index, const std::string& value); + void set_pendingdevicejid(int index, std::string&& value); + void set_pendingdevicejid(int index, const char* value); + void set_pendingdevicejid(int index, const char* value, size_t size); + std::string* add_pendingdevicejid(); + void add_pendingdevicejid(const std::string& value); + void add_pendingdevicejid(std::string&& value); + void add_pendingdevicejid(const char* value); + void add_pendingdevicejid(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& pendingdevicejid() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_pendingdevicejid(); + private: + const std::string& _internal_pendingdevicejid(int index) const; + std::string* _internal_add_pendingdevicejid(); + public: + + // repeated string deliveredDeviceJid = 6; + int delivereddevicejid_size() const; + private: + int _internal_delivereddevicejid_size() const; + public: + void clear_delivereddevicejid(); + const std::string& delivereddevicejid(int index) const; + std::string* mutable_delivereddevicejid(int index); + void set_delivereddevicejid(int index, const std::string& value); + void set_delivereddevicejid(int index, std::string&& value); + void set_delivereddevicejid(int index, const char* value); + void set_delivereddevicejid(int index, const char* value, size_t size); + std::string* add_delivereddevicejid(); + void add_delivereddevicejid(const std::string& value); + void add_delivereddevicejid(std::string&& value); + void add_delivereddevicejid(const char* value); + void add_delivereddevicejid(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& delivereddevicejid() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_delivereddevicejid(); + private: + const std::string& _internal_delivereddevicejid(int index) const; + std::string* _internal_add_delivereddevicejid(); + public: + + // required string userJid = 1; + bool has_userjid() const; + private: + bool _internal_has_userjid() const; + public: + void clear_userjid(); + const std::string& userjid() const; + template + void set_userjid(ArgT0&& arg0, ArgT... args); + std::string* mutable_userjid(); + PROTOBUF_NODISCARD std::string* release_userjid(); + void set_allocated_userjid(std::string* userjid); + private: + const std::string& _internal_userjid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_userjid(const std::string& value); + std::string* _internal_mutable_userjid(); + public: + + // optional int64 receiptTimestamp = 2; + bool has_receipttimestamp() const; + private: + bool _internal_has_receipttimestamp() const; + public: + void clear_receipttimestamp(); + int64_t receipttimestamp() const; + void set_receipttimestamp(int64_t value); + private: + int64_t _internal_receipttimestamp() const; + void _internal_set_receipttimestamp(int64_t value); + public: + + // optional int64 readTimestamp = 3; + bool has_readtimestamp() const; + private: + bool _internal_has_readtimestamp() const; + public: + void clear_readtimestamp(); + int64_t readtimestamp() const; + void set_readtimestamp(int64_t value); + private: + int64_t _internal_readtimestamp() const; + void _internal_set_readtimestamp(int64_t value); + public: + + // optional int64 playedTimestamp = 4; + bool has_playedtimestamp() const; + private: + bool _internal_has_playedtimestamp() const; + public: + void clear_playedtimestamp(); + int64_t playedtimestamp() const; + void set_playedtimestamp(int64_t value); + private: + int64_t _internal_playedtimestamp() const; + void _internal_set_playedtimestamp(int64_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.UserReceipt) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField pendingdevicejid_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField delivereddevicejid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userjid_; + int64_t receipttimestamp_; + int64_t readtimestamp_; + int64_t playedtimestamp_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class VerifiedNameCertificate_Details final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.VerifiedNameCertificate.Details) */ { + public: + inline VerifiedNameCertificate_Details() : VerifiedNameCertificate_Details(nullptr) {} + ~VerifiedNameCertificate_Details() override; + explicit PROTOBUF_CONSTEXPR VerifiedNameCertificate_Details(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + VerifiedNameCertificate_Details(const VerifiedNameCertificate_Details& from); + VerifiedNameCertificate_Details(VerifiedNameCertificate_Details&& from) noexcept + : VerifiedNameCertificate_Details() { + *this = ::std::move(from); + } + + inline VerifiedNameCertificate_Details& operator=(const VerifiedNameCertificate_Details& from) { + CopyFrom(from); + return *this; + } + inline VerifiedNameCertificate_Details& operator=(VerifiedNameCertificate_Details&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const VerifiedNameCertificate_Details& default_instance() { + return *internal_default_instance(); + } + static inline const VerifiedNameCertificate_Details* internal_default_instance() { + return reinterpret_cast( + &_VerifiedNameCertificate_Details_default_instance_); + } + static constexpr int kIndexInFileMessages = + 218; + + friend void swap(VerifiedNameCertificate_Details& a, VerifiedNameCertificate_Details& b) { + a.Swap(&b); + } + inline void Swap(VerifiedNameCertificate_Details* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(VerifiedNameCertificate_Details* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + VerifiedNameCertificate_Details* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const VerifiedNameCertificate_Details& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const VerifiedNameCertificate_Details& from) { + VerifiedNameCertificate_Details::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(VerifiedNameCertificate_Details* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.VerifiedNameCertificate.Details"; + } + protected: + explicit VerifiedNameCertificate_Details(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kLocalizedNamesFieldNumber = 8, + kIssuerFieldNumber = 2, + kVerifiedNameFieldNumber = 4, + kSerialFieldNumber = 1, + kIssueTimeFieldNumber = 10, + }; + // repeated .proto.LocalizedName localizedNames = 8; + int localizednames_size() const; + private: + int _internal_localizednames_size() const; + public: + void clear_localizednames(); + ::proto::LocalizedName* mutable_localizednames(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::LocalizedName >* + mutable_localizednames(); + private: + const ::proto::LocalizedName& _internal_localizednames(int index) const; + ::proto::LocalizedName* _internal_add_localizednames(); + public: + const ::proto::LocalizedName& localizednames(int index) const; + ::proto::LocalizedName* add_localizednames(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::LocalizedName >& + localizednames() const; + + // optional string issuer = 2; + bool has_issuer() const; + private: + bool _internal_has_issuer() const; + public: + void clear_issuer(); + const std::string& issuer() const; + template + void set_issuer(ArgT0&& arg0, ArgT... args); + std::string* mutable_issuer(); + PROTOBUF_NODISCARD std::string* release_issuer(); + void set_allocated_issuer(std::string* issuer); + private: + const std::string& _internal_issuer() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_issuer(const std::string& value); + std::string* _internal_mutable_issuer(); + public: + + // optional string verifiedName = 4; + bool has_verifiedname() const; + private: + bool _internal_has_verifiedname() const; + public: + void clear_verifiedname(); + const std::string& verifiedname() const; + template + void set_verifiedname(ArgT0&& arg0, ArgT... args); + std::string* mutable_verifiedname(); + PROTOBUF_NODISCARD std::string* release_verifiedname(); + void set_allocated_verifiedname(std::string* verifiedname); + private: + const std::string& _internal_verifiedname() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_verifiedname(const std::string& value); + std::string* _internal_mutable_verifiedname(); + public: + + // optional uint64 serial = 1; + bool has_serial() const; + private: + bool _internal_has_serial() const; + public: + void clear_serial(); + uint64_t serial() const; + void set_serial(uint64_t value); + private: + uint64_t _internal_serial() const; + void _internal_set_serial(uint64_t value); + public: + + // optional uint64 issueTime = 10; + bool has_issuetime() const; + private: + bool _internal_has_issuetime() const; + public: + void clear_issuetime(); + uint64_t issuetime() const; + void set_issuetime(uint64_t value); + private: + uint64_t _internal_issuetime() const; + void _internal_set_issuetime(uint64_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.VerifiedNameCertificate.Details) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::LocalizedName > localizednames_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr issuer_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr verifiedname_; + uint64_t serial_; + uint64_t issuetime_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class VerifiedNameCertificate final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.VerifiedNameCertificate) */ { + public: + inline VerifiedNameCertificate() : VerifiedNameCertificate(nullptr) {} + ~VerifiedNameCertificate() override; + explicit PROTOBUF_CONSTEXPR VerifiedNameCertificate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + VerifiedNameCertificate(const VerifiedNameCertificate& from); + VerifiedNameCertificate(VerifiedNameCertificate&& from) noexcept + : VerifiedNameCertificate() { + *this = ::std::move(from); + } + + inline VerifiedNameCertificate& operator=(const VerifiedNameCertificate& from) { + CopyFrom(from); + return *this; + } + inline VerifiedNameCertificate& operator=(VerifiedNameCertificate&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const VerifiedNameCertificate& default_instance() { + return *internal_default_instance(); + } + static inline const VerifiedNameCertificate* internal_default_instance() { + return reinterpret_cast( + &_VerifiedNameCertificate_default_instance_); + } + static constexpr int kIndexInFileMessages = + 219; + + friend void swap(VerifiedNameCertificate& a, VerifiedNameCertificate& b) { + a.Swap(&b); + } + inline void Swap(VerifiedNameCertificate* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(VerifiedNameCertificate* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + VerifiedNameCertificate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const VerifiedNameCertificate& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const VerifiedNameCertificate& from) { + VerifiedNameCertificate::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(VerifiedNameCertificate* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.VerifiedNameCertificate"; + } + protected: + explicit VerifiedNameCertificate(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef VerifiedNameCertificate_Details Details; + + // accessors ------------------------------------------------------- + + enum : int { + kDetailsFieldNumber = 1, + kSignatureFieldNumber = 2, + kServerSignatureFieldNumber = 3, + }; + // optional bytes details = 1; + bool has_details() const; + private: + bool _internal_has_details() const; + public: + void clear_details(); + const std::string& details() const; + template + void set_details(ArgT0&& arg0, ArgT... args); + std::string* mutable_details(); + PROTOBUF_NODISCARD std::string* release_details(); + void set_allocated_details(std::string* details); + private: + const std::string& _internal_details() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_details(const std::string& value); + std::string* _internal_mutable_details(); + public: + + // optional bytes signature = 2; + bool has_signature() const; + private: + bool _internal_has_signature() const; + public: + void clear_signature(); + const std::string& signature() const; + template + void set_signature(ArgT0&& arg0, ArgT... args); + std::string* mutable_signature(); + PROTOBUF_NODISCARD std::string* release_signature(); + void set_allocated_signature(std::string* signature); + private: + const std::string& _internal_signature() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value); + std::string* _internal_mutable_signature(); + public: + + // optional bytes serverSignature = 3; + bool has_serversignature() const; + private: + bool _internal_has_serversignature() const; + public: + void clear_serversignature(); + const std::string& serversignature() const; + template + void set_serversignature(ArgT0&& arg0, ArgT... args); + std::string* mutable_serversignature(); + PROTOBUF_NODISCARD std::string* release_serversignature(); + void set_allocated_serversignature(std::string* serversignature); + private: + const std::string& _internal_serversignature() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_serversignature(const std::string& value); + std::string* _internal_mutable_serversignature(); + public: + + // @@protoc_insertion_point(class_scope:proto.VerifiedNameCertificate) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr details_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr serversignature_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class WallpaperSettings final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.WallpaperSettings) */ { + public: + inline WallpaperSettings() : WallpaperSettings(nullptr) {} + ~WallpaperSettings() override; + explicit PROTOBUF_CONSTEXPR WallpaperSettings(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + WallpaperSettings(const WallpaperSettings& from); + WallpaperSettings(WallpaperSettings&& from) noexcept + : WallpaperSettings() { + *this = ::std::move(from); + } + + inline WallpaperSettings& operator=(const WallpaperSettings& from) { + CopyFrom(from); + return *this; + } + inline WallpaperSettings& operator=(WallpaperSettings&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const WallpaperSettings& default_instance() { + return *internal_default_instance(); + } + static inline const WallpaperSettings* internal_default_instance() { + return reinterpret_cast( + &_WallpaperSettings_default_instance_); + } + static constexpr int kIndexInFileMessages = + 220; + + friend void swap(WallpaperSettings& a, WallpaperSettings& b) { + a.Swap(&b); + } + inline void Swap(WallpaperSettings* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(WallpaperSettings* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + WallpaperSettings* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const WallpaperSettings& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const WallpaperSettings& from) { + WallpaperSettings::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(WallpaperSettings* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.WallpaperSettings"; + } + protected: + explicit WallpaperSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kFilenameFieldNumber = 1, + kOpacityFieldNumber = 2, + }; + // optional string filename = 1; + bool has_filename() const; + private: + bool _internal_has_filename() const; + public: + void clear_filename(); + const std::string& filename() const; + template + void set_filename(ArgT0&& arg0, ArgT... args); + std::string* mutable_filename(); + PROTOBUF_NODISCARD std::string* release_filename(); + void set_allocated_filename(std::string* filename); + private: + const std::string& _internal_filename() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_filename(const std::string& value); + std::string* _internal_mutable_filename(); + public: + + // optional uint32 opacity = 2; + bool has_opacity() const; + private: + bool _internal_has_opacity() const; + public: + void clear_opacity(); + uint32_t opacity() const; + void set_opacity(uint32_t value); + private: + uint32_t _internal_opacity() const; + void _internal_set_opacity(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.WallpaperSettings) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filename_; + uint32_t opacity_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class WebFeatures final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.WebFeatures) */ { + public: + inline WebFeatures() : WebFeatures(nullptr) {} + ~WebFeatures() override; + explicit PROTOBUF_CONSTEXPR WebFeatures(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + WebFeatures(const WebFeatures& from); + WebFeatures(WebFeatures&& from) noexcept + : WebFeatures() { + *this = ::std::move(from); + } + + inline WebFeatures& operator=(const WebFeatures& from) { + CopyFrom(from); + return *this; + } + inline WebFeatures& operator=(WebFeatures&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const WebFeatures& default_instance() { + return *internal_default_instance(); + } + static inline const WebFeatures* internal_default_instance() { + return reinterpret_cast( + &_WebFeatures_default_instance_); + } + static constexpr int kIndexInFileMessages = + 221; + + friend void swap(WebFeatures& a, WebFeatures& b) { + a.Swap(&b); + } + inline void Swap(WebFeatures* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(WebFeatures* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + WebFeatures* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const WebFeatures& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const WebFeatures& from) { + WebFeatures::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(WebFeatures* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.WebFeatures"; + } + protected: + explicit WebFeatures(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef WebFeatures_Flag Flag; + static constexpr Flag NOT_STARTED = + WebFeatures_Flag_NOT_STARTED; + static constexpr Flag FORCE_UPGRADE = + WebFeatures_Flag_FORCE_UPGRADE; + static constexpr Flag DEVELOPMENT = + WebFeatures_Flag_DEVELOPMENT; + static constexpr Flag PRODUCTION = + WebFeatures_Flag_PRODUCTION; + static inline bool Flag_IsValid(int value) { + return WebFeatures_Flag_IsValid(value); + } + static constexpr Flag Flag_MIN = + WebFeatures_Flag_Flag_MIN; + static constexpr Flag Flag_MAX = + WebFeatures_Flag_Flag_MAX; + static constexpr int Flag_ARRAYSIZE = + WebFeatures_Flag_Flag_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + Flag_descriptor() { + return WebFeatures_Flag_descriptor(); + } + template + static inline const std::string& Flag_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Flag_Name."); + return WebFeatures_Flag_Name(enum_t_value); + } + static inline bool Flag_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Flag* value) { + return WebFeatures_Flag_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kLabelsDisplayFieldNumber = 1, + kVoipIndividualOutgoingFieldNumber = 2, + kGroupsV3FieldNumber = 3, + kGroupsV3CreateFieldNumber = 4, + kChangeNumberV2FieldNumber = 5, + kQueryStatusV3ThumbnailFieldNumber = 6, + kLiveLocationsFieldNumber = 7, + kQueryVnameFieldNumber = 8, + kVoipIndividualIncomingFieldNumber = 9, + kQuickRepliesQueryFieldNumber = 10, + kPaymentsFieldNumber = 11, + kStickerPackQueryFieldNumber = 12, + kLiveLocationsFinalFieldNumber = 13, + kLabelsEditFieldNumber = 14, + kMediaUploadFieldNumber = 15, + kMediaUploadRichQuickRepliesFieldNumber = 18, + kVnameV2FieldNumber = 19, + kVideoPlaybackUrlFieldNumber = 20, + kStatusRankingFieldNumber = 21, + kVoipIndividualVideoFieldNumber = 22, + kThirdPartyStickersFieldNumber = 23, + kFrequentlyForwardedSettingFieldNumber = 24, + kGroupsV4JoinPermissionFieldNumber = 25, + kRecentStickersFieldNumber = 26, + kCatalogFieldNumber = 27, + kStarredStickersFieldNumber = 28, + kVoipGroupCallFieldNumber = 29, + kTemplateMessageFieldNumber = 30, + kTemplateMessageInteractivityFieldNumber = 31, + kEphemeralMessagesFieldNumber = 32, + kE2ENotificationSyncFieldNumber = 33, + kRecentStickersV2FieldNumber = 34, + kRecentStickersV3FieldNumber = 36, + kUserNoticeFieldNumber = 37, + kSupportFieldNumber = 39, + kGroupUiiCleanupFieldNumber = 40, + kGroupDogfoodingInternalOnlyFieldNumber = 41, + kSettingsSyncFieldNumber = 42, + kArchiveV2FieldNumber = 43, + kEphemeralAllowGroupMembersFieldNumber = 44, + kEphemeral24HDurationFieldNumber = 45, + kMdForceUpgradeFieldNumber = 46, + kDisappearingModeFieldNumber = 47, + kExternalMdOptInAvailableFieldNumber = 48, + kNoDeleteMessageTimeLimitFieldNumber = 49, + }; + // optional .proto.WebFeatures.Flag labelsDisplay = 1; + bool has_labelsdisplay() const; + private: + bool _internal_has_labelsdisplay() const; + public: + void clear_labelsdisplay(); + ::proto::WebFeatures_Flag labelsdisplay() const; + void set_labelsdisplay(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_labelsdisplay() const; + void _internal_set_labelsdisplay(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag voipIndividualOutgoing = 2; + bool has_voipindividualoutgoing() const; + private: + bool _internal_has_voipindividualoutgoing() const; + public: + void clear_voipindividualoutgoing(); + ::proto::WebFeatures_Flag voipindividualoutgoing() const; + void set_voipindividualoutgoing(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_voipindividualoutgoing() const; + void _internal_set_voipindividualoutgoing(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag groupsV3 = 3; + bool has_groupsv3() const; + private: + bool _internal_has_groupsv3() const; + public: + void clear_groupsv3(); + ::proto::WebFeatures_Flag groupsv3() const; + void set_groupsv3(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_groupsv3() const; + void _internal_set_groupsv3(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag groupsV3Create = 4; + bool has_groupsv3create() const; + private: + bool _internal_has_groupsv3create() const; + public: + void clear_groupsv3create(); + ::proto::WebFeatures_Flag groupsv3create() const; + void set_groupsv3create(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_groupsv3create() const; + void _internal_set_groupsv3create(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag changeNumberV2 = 5; + bool has_changenumberv2() const; + private: + bool _internal_has_changenumberv2() const; + public: + void clear_changenumberv2(); + ::proto::WebFeatures_Flag changenumberv2() const; + void set_changenumberv2(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_changenumberv2() const; + void _internal_set_changenumberv2(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag queryStatusV3Thumbnail = 6; + bool has_querystatusv3thumbnail() const; + private: + bool _internal_has_querystatusv3thumbnail() const; + public: + void clear_querystatusv3thumbnail(); + ::proto::WebFeatures_Flag querystatusv3thumbnail() const; + void set_querystatusv3thumbnail(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_querystatusv3thumbnail() const; + void _internal_set_querystatusv3thumbnail(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag liveLocations = 7; + bool has_livelocations() const; + private: + bool _internal_has_livelocations() const; + public: + void clear_livelocations(); + ::proto::WebFeatures_Flag livelocations() const; + void set_livelocations(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_livelocations() const; + void _internal_set_livelocations(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag queryVname = 8; + bool has_queryvname() const; + private: + bool _internal_has_queryvname() const; + public: + void clear_queryvname(); + ::proto::WebFeatures_Flag queryvname() const; + void set_queryvname(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_queryvname() const; + void _internal_set_queryvname(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag voipIndividualIncoming = 9; + bool has_voipindividualincoming() const; + private: + bool _internal_has_voipindividualincoming() const; + public: + void clear_voipindividualincoming(); + ::proto::WebFeatures_Flag voipindividualincoming() const; + void set_voipindividualincoming(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_voipindividualincoming() const; + void _internal_set_voipindividualincoming(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag quickRepliesQuery = 10; + bool has_quickrepliesquery() const; + private: + bool _internal_has_quickrepliesquery() const; + public: + void clear_quickrepliesquery(); + ::proto::WebFeatures_Flag quickrepliesquery() const; + void set_quickrepliesquery(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_quickrepliesquery() const; + void _internal_set_quickrepliesquery(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag payments = 11; + bool has_payments() const; + private: + bool _internal_has_payments() const; + public: + void clear_payments(); + ::proto::WebFeatures_Flag payments() const; + void set_payments(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_payments() const; + void _internal_set_payments(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag stickerPackQuery = 12; + bool has_stickerpackquery() const; + private: + bool _internal_has_stickerpackquery() const; + public: + void clear_stickerpackquery(); + ::proto::WebFeatures_Flag stickerpackquery() const; + void set_stickerpackquery(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_stickerpackquery() const; + void _internal_set_stickerpackquery(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag liveLocationsFinal = 13; + bool has_livelocationsfinal() const; + private: + bool _internal_has_livelocationsfinal() const; + public: + void clear_livelocationsfinal(); + ::proto::WebFeatures_Flag livelocationsfinal() const; + void set_livelocationsfinal(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_livelocationsfinal() const; + void _internal_set_livelocationsfinal(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag labelsEdit = 14; + bool has_labelsedit() const; + private: + bool _internal_has_labelsedit() const; + public: + void clear_labelsedit(); + ::proto::WebFeatures_Flag labelsedit() const; + void set_labelsedit(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_labelsedit() const; + void _internal_set_labelsedit(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag mediaUpload = 15; + bool has_mediaupload() const; + private: + bool _internal_has_mediaupload() const; + public: + void clear_mediaupload(); + ::proto::WebFeatures_Flag mediaupload() const; + void set_mediaupload(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_mediaupload() const; + void _internal_set_mediaupload(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag mediaUploadRichQuickReplies = 18; + bool has_mediauploadrichquickreplies() const; + private: + bool _internal_has_mediauploadrichquickreplies() const; + public: + void clear_mediauploadrichquickreplies(); + ::proto::WebFeatures_Flag mediauploadrichquickreplies() const; + void set_mediauploadrichquickreplies(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_mediauploadrichquickreplies() const; + void _internal_set_mediauploadrichquickreplies(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag vnameV2 = 19; + bool has_vnamev2() const; + private: + bool _internal_has_vnamev2() const; + public: + void clear_vnamev2(); + ::proto::WebFeatures_Flag vnamev2() const; + void set_vnamev2(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_vnamev2() const; + void _internal_set_vnamev2(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag videoPlaybackUrl = 20; + bool has_videoplaybackurl() const; + private: + bool _internal_has_videoplaybackurl() const; + public: + void clear_videoplaybackurl(); + ::proto::WebFeatures_Flag videoplaybackurl() const; + void set_videoplaybackurl(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_videoplaybackurl() const; + void _internal_set_videoplaybackurl(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag statusRanking = 21; + bool has_statusranking() const; + private: + bool _internal_has_statusranking() const; + public: + void clear_statusranking(); + ::proto::WebFeatures_Flag statusranking() const; + void set_statusranking(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_statusranking() const; + void _internal_set_statusranking(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag voipIndividualVideo = 22; + bool has_voipindividualvideo() const; + private: + bool _internal_has_voipindividualvideo() const; + public: + void clear_voipindividualvideo(); + ::proto::WebFeatures_Flag voipindividualvideo() const; + void set_voipindividualvideo(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_voipindividualvideo() const; + void _internal_set_voipindividualvideo(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag thirdPartyStickers = 23; + bool has_thirdpartystickers() const; + private: + bool _internal_has_thirdpartystickers() const; + public: + void clear_thirdpartystickers(); + ::proto::WebFeatures_Flag thirdpartystickers() const; + void set_thirdpartystickers(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_thirdpartystickers() const; + void _internal_set_thirdpartystickers(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag frequentlyForwardedSetting = 24; + bool has_frequentlyforwardedsetting() const; + private: + bool _internal_has_frequentlyforwardedsetting() const; + public: + void clear_frequentlyforwardedsetting(); + ::proto::WebFeatures_Flag frequentlyforwardedsetting() const; + void set_frequentlyforwardedsetting(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_frequentlyforwardedsetting() const; + void _internal_set_frequentlyforwardedsetting(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag groupsV4JoinPermission = 25; + bool has_groupsv4joinpermission() const; + private: + bool _internal_has_groupsv4joinpermission() const; + public: + void clear_groupsv4joinpermission(); + ::proto::WebFeatures_Flag groupsv4joinpermission() const; + void set_groupsv4joinpermission(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_groupsv4joinpermission() const; + void _internal_set_groupsv4joinpermission(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag recentStickers = 26; + bool has_recentstickers() const; + private: + bool _internal_has_recentstickers() const; + public: + void clear_recentstickers(); + ::proto::WebFeatures_Flag recentstickers() const; + void set_recentstickers(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_recentstickers() const; + void _internal_set_recentstickers(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag catalog = 27; + bool has_catalog() const; + private: + bool _internal_has_catalog() const; + public: + void clear_catalog(); + ::proto::WebFeatures_Flag catalog() const; + void set_catalog(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_catalog() const; + void _internal_set_catalog(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag starredStickers = 28; + bool has_starredstickers() const; + private: + bool _internal_has_starredstickers() const; + public: + void clear_starredstickers(); + ::proto::WebFeatures_Flag starredstickers() const; + void set_starredstickers(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_starredstickers() const; + void _internal_set_starredstickers(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag voipGroupCall = 29; + bool has_voipgroupcall() const; + private: + bool _internal_has_voipgroupcall() const; + public: + void clear_voipgroupcall(); + ::proto::WebFeatures_Flag voipgroupcall() const; + void set_voipgroupcall(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_voipgroupcall() const; + void _internal_set_voipgroupcall(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag templateMessage = 30; + bool has_templatemessage() const; + private: + bool _internal_has_templatemessage() const; + public: + void clear_templatemessage(); + ::proto::WebFeatures_Flag templatemessage() const; + void set_templatemessage(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_templatemessage() const; + void _internal_set_templatemessage(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag templateMessageInteractivity = 31; + bool has_templatemessageinteractivity() const; + private: + bool _internal_has_templatemessageinteractivity() const; + public: + void clear_templatemessageinteractivity(); + ::proto::WebFeatures_Flag templatemessageinteractivity() const; + void set_templatemessageinteractivity(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_templatemessageinteractivity() const; + void _internal_set_templatemessageinteractivity(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag ephemeralMessages = 32; + bool has_ephemeralmessages() const; + private: + bool _internal_has_ephemeralmessages() const; + public: + void clear_ephemeralmessages(); + ::proto::WebFeatures_Flag ephemeralmessages() const; + void set_ephemeralmessages(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_ephemeralmessages() const; + void _internal_set_ephemeralmessages(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag e2ENotificationSync = 33; + bool has_e2enotificationsync() const; + private: + bool _internal_has_e2enotificationsync() const; + public: + void clear_e2enotificationsync(); + ::proto::WebFeatures_Flag e2enotificationsync() const; + void set_e2enotificationsync(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_e2enotificationsync() const; + void _internal_set_e2enotificationsync(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag recentStickersV2 = 34; + bool has_recentstickersv2() const; + private: + bool _internal_has_recentstickersv2() const; + public: + void clear_recentstickersv2(); + ::proto::WebFeatures_Flag recentstickersv2() const; + void set_recentstickersv2(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_recentstickersv2() const; + void _internal_set_recentstickersv2(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag recentStickersV3 = 36; + bool has_recentstickersv3() const; + private: + bool _internal_has_recentstickersv3() const; + public: + void clear_recentstickersv3(); + ::proto::WebFeatures_Flag recentstickersv3() const; + void set_recentstickersv3(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_recentstickersv3() const; + void _internal_set_recentstickersv3(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag userNotice = 37; + bool has_usernotice() const; + private: + bool _internal_has_usernotice() const; + public: + void clear_usernotice(); + ::proto::WebFeatures_Flag usernotice() const; + void set_usernotice(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_usernotice() const; + void _internal_set_usernotice(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag support = 39; + bool has_support() const; + private: + bool _internal_has_support() const; + public: + void clear_support(); + ::proto::WebFeatures_Flag support() const; + void set_support(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_support() const; + void _internal_set_support(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag groupUiiCleanup = 40; + bool has_groupuiicleanup() const; + private: + bool _internal_has_groupuiicleanup() const; + public: + void clear_groupuiicleanup(); + ::proto::WebFeatures_Flag groupuiicleanup() const; + void set_groupuiicleanup(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_groupuiicleanup() const; + void _internal_set_groupuiicleanup(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag groupDogfoodingInternalOnly = 41; + bool has_groupdogfoodinginternalonly() const; + private: + bool _internal_has_groupdogfoodinginternalonly() const; + public: + void clear_groupdogfoodinginternalonly(); + ::proto::WebFeatures_Flag groupdogfoodinginternalonly() const; + void set_groupdogfoodinginternalonly(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_groupdogfoodinginternalonly() const; + void _internal_set_groupdogfoodinginternalonly(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag settingsSync = 42; + bool has_settingssync() const; + private: + bool _internal_has_settingssync() const; + public: + void clear_settingssync(); + ::proto::WebFeatures_Flag settingssync() const; + void set_settingssync(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_settingssync() const; + void _internal_set_settingssync(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag archiveV2 = 43; + bool has_archivev2() const; + private: + bool _internal_has_archivev2() const; + public: + void clear_archivev2(); + ::proto::WebFeatures_Flag archivev2() const; + void set_archivev2(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_archivev2() const; + void _internal_set_archivev2(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag ephemeralAllowGroupMembers = 44; + bool has_ephemeralallowgroupmembers() const; + private: + bool _internal_has_ephemeralallowgroupmembers() const; + public: + void clear_ephemeralallowgroupmembers(); + ::proto::WebFeatures_Flag ephemeralallowgroupmembers() const; + void set_ephemeralallowgroupmembers(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_ephemeralallowgroupmembers() const; + void _internal_set_ephemeralallowgroupmembers(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag ephemeral24HDuration = 45; + bool has_ephemeral24hduration() const; + private: + bool _internal_has_ephemeral24hduration() const; + public: + void clear_ephemeral24hduration(); + ::proto::WebFeatures_Flag ephemeral24hduration() const; + void set_ephemeral24hduration(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_ephemeral24hduration() const; + void _internal_set_ephemeral24hduration(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag mdForceUpgrade = 46; + bool has_mdforceupgrade() const; + private: + bool _internal_has_mdforceupgrade() const; + public: + void clear_mdforceupgrade(); + ::proto::WebFeatures_Flag mdforceupgrade() const; + void set_mdforceupgrade(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_mdforceupgrade() const; + void _internal_set_mdforceupgrade(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag disappearingMode = 47; + bool has_disappearingmode() const; + private: + bool _internal_has_disappearingmode() const; + public: + void clear_disappearingmode(); + ::proto::WebFeatures_Flag disappearingmode() const; + void set_disappearingmode(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_disappearingmode() const; + void _internal_set_disappearingmode(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag externalMdOptInAvailable = 48; + bool has_externalmdoptinavailable() const; + private: + bool _internal_has_externalmdoptinavailable() const; + public: + void clear_externalmdoptinavailable(); + ::proto::WebFeatures_Flag externalmdoptinavailable() const; + void set_externalmdoptinavailable(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_externalmdoptinavailable() const; + void _internal_set_externalmdoptinavailable(::proto::WebFeatures_Flag value); + public: + + // optional .proto.WebFeatures.Flag noDeleteMessageTimeLimit = 49; + bool has_nodeletemessagetimelimit() const; + private: + bool _internal_has_nodeletemessagetimelimit() const; + public: + void clear_nodeletemessagetimelimit(); + ::proto::WebFeatures_Flag nodeletemessagetimelimit() const; + void set_nodeletemessagetimelimit(::proto::WebFeatures_Flag value); + private: + ::proto::WebFeatures_Flag _internal_nodeletemessagetimelimit() const; + void _internal_set_nodeletemessagetimelimit(::proto::WebFeatures_Flag value); + public: + + // @@protoc_insertion_point(class_scope:proto.WebFeatures) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<2> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + int labelsdisplay_; + int voipindividualoutgoing_; + int groupsv3_; + int groupsv3create_; + int changenumberv2_; + int querystatusv3thumbnail_; + int livelocations_; + int queryvname_; + int voipindividualincoming_; + int quickrepliesquery_; + int payments_; + int stickerpackquery_; + int livelocationsfinal_; + int labelsedit_; + int mediaupload_; + int mediauploadrichquickreplies_; + int vnamev2_; + int videoplaybackurl_; + int statusranking_; + int voipindividualvideo_; + int thirdpartystickers_; + int frequentlyforwardedsetting_; + int groupsv4joinpermission_; + int recentstickers_; + int catalog_; + int starredstickers_; + int voipgroupcall_; + int templatemessage_; + int templatemessageinteractivity_; + int ephemeralmessages_; + int e2enotificationsync_; + int recentstickersv2_; + int recentstickersv3_; + int usernotice_; + int support_; + int groupuiicleanup_; + int groupdogfoodinginternalonly_; + int settingssync_; + int archivev2_; + int ephemeralallowgroupmembers_; + int ephemeral24hduration_; + int mdforceupgrade_; + int disappearingmode_; + int externalmdoptinavailable_; + int nodeletemessagetimelimit_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class WebMessageInfo final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.WebMessageInfo) */ { + public: + inline WebMessageInfo() : WebMessageInfo(nullptr) {} + ~WebMessageInfo() override; + explicit PROTOBUF_CONSTEXPR WebMessageInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + WebMessageInfo(const WebMessageInfo& from); + WebMessageInfo(WebMessageInfo&& from) noexcept + : WebMessageInfo() { + *this = ::std::move(from); + } + + inline WebMessageInfo& operator=(const WebMessageInfo& from) { + CopyFrom(from); + return *this; + } + inline WebMessageInfo& operator=(WebMessageInfo&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const WebMessageInfo& default_instance() { + return *internal_default_instance(); + } + static inline const WebMessageInfo* internal_default_instance() { + return reinterpret_cast( + &_WebMessageInfo_default_instance_); + } + static constexpr int kIndexInFileMessages = + 222; + + friend void swap(WebMessageInfo& a, WebMessageInfo& b) { + a.Swap(&b); + } + inline void Swap(WebMessageInfo* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(WebMessageInfo* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + WebMessageInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const WebMessageInfo& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const WebMessageInfo& from) { + WebMessageInfo::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(WebMessageInfo* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.WebMessageInfo"; + } + protected: + explicit WebMessageInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef WebMessageInfo_BizPrivacyStatus BizPrivacyStatus; + static constexpr BizPrivacyStatus E2EE = + WebMessageInfo_BizPrivacyStatus_E2EE; + static constexpr BizPrivacyStatus FB = + WebMessageInfo_BizPrivacyStatus_FB; + static constexpr BizPrivacyStatus BSP = + WebMessageInfo_BizPrivacyStatus_BSP; + static constexpr BizPrivacyStatus BSP_AND_FB = + WebMessageInfo_BizPrivacyStatus_BSP_AND_FB; + static inline bool BizPrivacyStatus_IsValid(int value) { + return WebMessageInfo_BizPrivacyStatus_IsValid(value); + } + static constexpr BizPrivacyStatus BizPrivacyStatus_MIN = + WebMessageInfo_BizPrivacyStatus_BizPrivacyStatus_MIN; + static constexpr BizPrivacyStatus BizPrivacyStatus_MAX = + WebMessageInfo_BizPrivacyStatus_BizPrivacyStatus_MAX; + static constexpr int BizPrivacyStatus_ARRAYSIZE = + WebMessageInfo_BizPrivacyStatus_BizPrivacyStatus_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + BizPrivacyStatus_descriptor() { + return WebMessageInfo_BizPrivacyStatus_descriptor(); + } + template + static inline const std::string& BizPrivacyStatus_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function BizPrivacyStatus_Name."); + return WebMessageInfo_BizPrivacyStatus_Name(enum_t_value); + } + static inline bool BizPrivacyStatus_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + BizPrivacyStatus* value) { + return WebMessageInfo_BizPrivacyStatus_Parse(name, value); + } + + typedef WebMessageInfo_Status Status; + static constexpr Status ERROR = + WebMessageInfo_Status_ERROR; + static constexpr Status PENDING = + WebMessageInfo_Status_PENDING; + static constexpr Status SERVER_ACK = + WebMessageInfo_Status_SERVER_ACK; + static constexpr Status DELIVERY_ACK = + WebMessageInfo_Status_DELIVERY_ACK; + static constexpr Status READ = + WebMessageInfo_Status_READ; + static constexpr Status PLAYED = + WebMessageInfo_Status_PLAYED; + static inline bool Status_IsValid(int value) { + return WebMessageInfo_Status_IsValid(value); + } + static constexpr Status Status_MIN = + WebMessageInfo_Status_Status_MIN; + static constexpr Status Status_MAX = + WebMessageInfo_Status_Status_MAX; + static constexpr int Status_ARRAYSIZE = + WebMessageInfo_Status_Status_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + Status_descriptor() { + return WebMessageInfo_Status_descriptor(); + } + template + static inline const std::string& Status_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Status_Name."); + return WebMessageInfo_Status_Name(enum_t_value); + } + static inline bool Status_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Status* value) { + return WebMessageInfo_Status_Parse(name, value); + } + + typedef WebMessageInfo_StubType StubType; + static constexpr StubType UNKNOWN = + WebMessageInfo_StubType_UNKNOWN; + static constexpr StubType REVOKE = + WebMessageInfo_StubType_REVOKE; + static constexpr StubType CIPHERTEXT = + WebMessageInfo_StubType_CIPHERTEXT; + static constexpr StubType FUTUREPROOF = + WebMessageInfo_StubType_FUTUREPROOF; + static constexpr StubType NON_VERIFIED_TRANSITION = + WebMessageInfo_StubType_NON_VERIFIED_TRANSITION; + static constexpr StubType UNVERIFIED_TRANSITION = + WebMessageInfo_StubType_UNVERIFIED_TRANSITION; + static constexpr StubType VERIFIED_TRANSITION = + WebMessageInfo_StubType_VERIFIED_TRANSITION; + static constexpr StubType VERIFIED_LOW_UNKNOWN = + WebMessageInfo_StubType_VERIFIED_LOW_UNKNOWN; + static constexpr StubType VERIFIED_HIGH = + WebMessageInfo_StubType_VERIFIED_HIGH; + static constexpr StubType VERIFIED_INITIAL_UNKNOWN = + WebMessageInfo_StubType_VERIFIED_INITIAL_UNKNOWN; + static constexpr StubType VERIFIED_INITIAL_LOW = + WebMessageInfo_StubType_VERIFIED_INITIAL_LOW; + static constexpr StubType VERIFIED_INITIAL_HIGH = + WebMessageInfo_StubType_VERIFIED_INITIAL_HIGH; + static constexpr StubType VERIFIED_TRANSITION_ANY_TO_NONE = + WebMessageInfo_StubType_VERIFIED_TRANSITION_ANY_TO_NONE; + static constexpr StubType VERIFIED_TRANSITION_ANY_TO_HIGH = + WebMessageInfo_StubType_VERIFIED_TRANSITION_ANY_TO_HIGH; + static constexpr StubType VERIFIED_TRANSITION_HIGH_TO_LOW = + WebMessageInfo_StubType_VERIFIED_TRANSITION_HIGH_TO_LOW; + static constexpr StubType VERIFIED_TRANSITION_HIGH_TO_UNKNOWN = + WebMessageInfo_StubType_VERIFIED_TRANSITION_HIGH_TO_UNKNOWN; + static constexpr StubType VERIFIED_TRANSITION_UNKNOWN_TO_LOW = + WebMessageInfo_StubType_VERIFIED_TRANSITION_UNKNOWN_TO_LOW; + static constexpr StubType VERIFIED_TRANSITION_LOW_TO_UNKNOWN = + WebMessageInfo_StubType_VERIFIED_TRANSITION_LOW_TO_UNKNOWN; + static constexpr StubType VERIFIED_TRANSITION_NONE_TO_LOW = + WebMessageInfo_StubType_VERIFIED_TRANSITION_NONE_TO_LOW; + static constexpr StubType VERIFIED_TRANSITION_NONE_TO_UNKNOWN = + WebMessageInfo_StubType_VERIFIED_TRANSITION_NONE_TO_UNKNOWN; + static constexpr StubType GROUP_CREATE = + WebMessageInfo_StubType_GROUP_CREATE; + static constexpr StubType GROUP_CHANGE_SUBJECT = + WebMessageInfo_StubType_GROUP_CHANGE_SUBJECT; + static constexpr StubType GROUP_CHANGE_ICON = + WebMessageInfo_StubType_GROUP_CHANGE_ICON; + static constexpr StubType GROUP_CHANGE_INVITE_LINK = + WebMessageInfo_StubType_GROUP_CHANGE_INVITE_LINK; + static constexpr StubType GROUP_CHANGE_DESCRIPTION = + WebMessageInfo_StubType_GROUP_CHANGE_DESCRIPTION; + static constexpr StubType GROUP_CHANGE_RESTRICT = + WebMessageInfo_StubType_GROUP_CHANGE_RESTRICT; + static constexpr StubType GROUP_CHANGE_ANNOUNCE = + WebMessageInfo_StubType_GROUP_CHANGE_ANNOUNCE; + static constexpr StubType GROUP_PARTICIPANT_ADD = + WebMessageInfo_StubType_GROUP_PARTICIPANT_ADD; + static constexpr StubType GROUP_PARTICIPANT_REMOVE = + WebMessageInfo_StubType_GROUP_PARTICIPANT_REMOVE; + static constexpr StubType GROUP_PARTICIPANT_PROMOTE = + WebMessageInfo_StubType_GROUP_PARTICIPANT_PROMOTE; + static constexpr StubType GROUP_PARTICIPANT_DEMOTE = + WebMessageInfo_StubType_GROUP_PARTICIPANT_DEMOTE; + static constexpr StubType GROUP_PARTICIPANT_INVITE = + WebMessageInfo_StubType_GROUP_PARTICIPANT_INVITE; + static constexpr StubType GROUP_PARTICIPANT_LEAVE = + WebMessageInfo_StubType_GROUP_PARTICIPANT_LEAVE; + static constexpr StubType GROUP_PARTICIPANT_CHANGE_NUMBER = + WebMessageInfo_StubType_GROUP_PARTICIPANT_CHANGE_NUMBER; + static constexpr StubType BROADCAST_CREATE = + WebMessageInfo_StubType_BROADCAST_CREATE; + static constexpr StubType BROADCAST_ADD = + WebMessageInfo_StubType_BROADCAST_ADD; + static constexpr StubType BROADCAST_REMOVE = + WebMessageInfo_StubType_BROADCAST_REMOVE; + static constexpr StubType GENERIC_NOTIFICATION = + WebMessageInfo_StubType_GENERIC_NOTIFICATION; + static constexpr StubType E2E_IDENTITY_CHANGED = + WebMessageInfo_StubType_E2E_IDENTITY_CHANGED; + static constexpr StubType E2E_ENCRYPTED = + WebMessageInfo_StubType_E2E_ENCRYPTED; + static constexpr StubType CALL_MISSED_VOICE = + WebMessageInfo_StubType_CALL_MISSED_VOICE; + static constexpr StubType CALL_MISSED_VIDEO = + WebMessageInfo_StubType_CALL_MISSED_VIDEO; + static constexpr StubType INDIVIDUAL_CHANGE_NUMBER = + WebMessageInfo_StubType_INDIVIDUAL_CHANGE_NUMBER; + static constexpr StubType GROUP_DELETE = + WebMessageInfo_StubType_GROUP_DELETE; + static constexpr StubType GROUP_ANNOUNCE_MODE_MESSAGE_BOUNCE = + WebMessageInfo_StubType_GROUP_ANNOUNCE_MODE_MESSAGE_BOUNCE; + static constexpr StubType CALL_MISSED_GROUP_VOICE = + WebMessageInfo_StubType_CALL_MISSED_GROUP_VOICE; + static constexpr StubType CALL_MISSED_GROUP_VIDEO = + WebMessageInfo_StubType_CALL_MISSED_GROUP_VIDEO; + static constexpr StubType PAYMENT_CIPHERTEXT = + WebMessageInfo_StubType_PAYMENT_CIPHERTEXT; + static constexpr StubType PAYMENT_FUTUREPROOF = + WebMessageInfo_StubType_PAYMENT_FUTUREPROOF; + static constexpr StubType PAYMENT_TRANSACTION_STATUS_UPDATE_FAILED = + WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_UPDATE_FAILED; + static constexpr StubType PAYMENT_TRANSACTION_STATUS_UPDATE_REFUNDED = + WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_UPDATE_REFUNDED; + static constexpr StubType PAYMENT_TRANSACTION_STATUS_UPDATE_REFUND_FAILED = + WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_UPDATE_REFUND_FAILED; + static constexpr StubType PAYMENT_TRANSACTION_STATUS_RECEIVER_PENDING_SETUP = + WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_RECEIVER_PENDING_SETUP; + static constexpr StubType PAYMENT_TRANSACTION_STATUS_RECEIVER_SUCCESS_AFTER_HICCUP = + WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_RECEIVER_SUCCESS_AFTER_HICCUP; + static constexpr StubType PAYMENT_ACTION_ACCOUNT_SETUP_REMINDER = + WebMessageInfo_StubType_PAYMENT_ACTION_ACCOUNT_SETUP_REMINDER; + static constexpr StubType PAYMENT_ACTION_SEND_PAYMENT_REMINDER = + WebMessageInfo_StubType_PAYMENT_ACTION_SEND_PAYMENT_REMINDER; + static constexpr StubType PAYMENT_ACTION_SEND_PAYMENT_INVITATION = + WebMessageInfo_StubType_PAYMENT_ACTION_SEND_PAYMENT_INVITATION; + static constexpr StubType PAYMENT_ACTION_REQUEST_DECLINED = + WebMessageInfo_StubType_PAYMENT_ACTION_REQUEST_DECLINED; + static constexpr StubType PAYMENT_ACTION_REQUEST_EXPIRED = + WebMessageInfo_StubType_PAYMENT_ACTION_REQUEST_EXPIRED; + static constexpr StubType PAYMENT_ACTION_REQUEST_CANCELLED = + WebMessageInfo_StubType_PAYMENT_ACTION_REQUEST_CANCELLED; + static constexpr StubType BIZ_VERIFIED_TRANSITION_TOP_TO_BOTTOM = + WebMessageInfo_StubType_BIZ_VERIFIED_TRANSITION_TOP_TO_BOTTOM; + static constexpr StubType BIZ_VERIFIED_TRANSITION_BOTTOM_TO_TOP = + WebMessageInfo_StubType_BIZ_VERIFIED_TRANSITION_BOTTOM_TO_TOP; + static constexpr StubType BIZ_INTRO_TOP = + WebMessageInfo_StubType_BIZ_INTRO_TOP; + static constexpr StubType BIZ_INTRO_BOTTOM = + WebMessageInfo_StubType_BIZ_INTRO_BOTTOM; + static constexpr StubType BIZ_NAME_CHANGE = + WebMessageInfo_StubType_BIZ_NAME_CHANGE; + static constexpr StubType BIZ_MOVE_TO_CONSUMER_APP = + WebMessageInfo_StubType_BIZ_MOVE_TO_CONSUMER_APP; + static constexpr StubType BIZ_TWO_TIER_MIGRATION_TOP = + WebMessageInfo_StubType_BIZ_TWO_TIER_MIGRATION_TOP; + static constexpr StubType BIZ_TWO_TIER_MIGRATION_BOTTOM = + WebMessageInfo_StubType_BIZ_TWO_TIER_MIGRATION_BOTTOM; + static constexpr StubType OVERSIZED = + WebMessageInfo_StubType_OVERSIZED; + static constexpr StubType GROUP_CHANGE_NO_FREQUENTLY_FORWARDED = + WebMessageInfo_StubType_GROUP_CHANGE_NO_FREQUENTLY_FORWARDED; + static constexpr StubType GROUP_V4_ADD_INVITE_SENT = + WebMessageInfo_StubType_GROUP_V4_ADD_INVITE_SENT; + static constexpr StubType GROUP_PARTICIPANT_ADD_REQUEST_JOIN = + WebMessageInfo_StubType_GROUP_PARTICIPANT_ADD_REQUEST_JOIN; + static constexpr StubType CHANGE_EPHEMERAL_SETTING = + WebMessageInfo_StubType_CHANGE_EPHEMERAL_SETTING; + static constexpr StubType E2E_DEVICE_CHANGED = + WebMessageInfo_StubType_E2E_DEVICE_CHANGED; + static constexpr StubType VIEWED_ONCE = + WebMessageInfo_StubType_VIEWED_ONCE; + static constexpr StubType E2E_ENCRYPTED_NOW = + WebMessageInfo_StubType_E2E_ENCRYPTED_NOW; + static constexpr StubType BLUE_MSG_BSP_FB_TO_BSP_PREMISE = + WebMessageInfo_StubType_BLUE_MSG_BSP_FB_TO_BSP_PREMISE; + static constexpr StubType BLUE_MSG_BSP_FB_TO_SELF_FB = + WebMessageInfo_StubType_BLUE_MSG_BSP_FB_TO_SELF_FB; + static constexpr StubType BLUE_MSG_BSP_FB_TO_SELF_PREMISE = + WebMessageInfo_StubType_BLUE_MSG_BSP_FB_TO_SELF_PREMISE; + static constexpr StubType BLUE_MSG_BSP_FB_UNVERIFIED = + WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED; + static constexpr StubType BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED = + WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED; + static constexpr StubType BLUE_MSG_BSP_FB_VERIFIED = + WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED; + static constexpr StubType BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED = + WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED; + static constexpr StubType BLUE_MSG_BSP_PREMISE_TO_SELF_PREMISE = + WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_TO_SELF_PREMISE; + static constexpr StubType BLUE_MSG_BSP_PREMISE_UNVERIFIED = + WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_UNVERIFIED; + static constexpr StubType BLUE_MSG_BSP_PREMISE_UNVERIFIED_TO_SELF_PREMISE_VERIFIED = + WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_UNVERIFIED_TO_SELF_PREMISE_VERIFIED; + static constexpr StubType BLUE_MSG_BSP_PREMISE_VERIFIED = + WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_VERIFIED; + static constexpr StubType BLUE_MSG_BSP_PREMISE_VERIFIED_TO_SELF_PREMISE_UNVERIFIED = + WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_VERIFIED_TO_SELF_PREMISE_UNVERIFIED; + static constexpr StubType BLUE_MSG_CONSUMER_TO_BSP_FB_UNVERIFIED = + WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_BSP_FB_UNVERIFIED; + static constexpr StubType BLUE_MSG_CONSUMER_TO_BSP_PREMISE_UNVERIFIED = + WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_BSP_PREMISE_UNVERIFIED; + static constexpr StubType BLUE_MSG_CONSUMER_TO_SELF_FB_UNVERIFIED = + WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_SELF_FB_UNVERIFIED; + static constexpr StubType BLUE_MSG_CONSUMER_TO_SELF_PREMISE_UNVERIFIED = + WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_SELF_PREMISE_UNVERIFIED; + static constexpr StubType BLUE_MSG_SELF_FB_TO_BSP_PREMISE = + WebMessageInfo_StubType_BLUE_MSG_SELF_FB_TO_BSP_PREMISE; + static constexpr StubType BLUE_MSG_SELF_FB_TO_SELF_PREMISE = + WebMessageInfo_StubType_BLUE_MSG_SELF_FB_TO_SELF_PREMISE; + static constexpr StubType BLUE_MSG_SELF_FB_UNVERIFIED = + WebMessageInfo_StubType_BLUE_MSG_SELF_FB_UNVERIFIED; + static constexpr StubType BLUE_MSG_SELF_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED = + WebMessageInfo_StubType_BLUE_MSG_SELF_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED; + static constexpr StubType BLUE_MSG_SELF_FB_VERIFIED = + WebMessageInfo_StubType_BLUE_MSG_SELF_FB_VERIFIED; + static constexpr StubType BLUE_MSG_SELF_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED = + WebMessageInfo_StubType_BLUE_MSG_SELF_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED; + static constexpr StubType BLUE_MSG_SELF_PREMISE_TO_BSP_PREMISE = + WebMessageInfo_StubType_BLUE_MSG_SELF_PREMISE_TO_BSP_PREMISE; + static constexpr StubType BLUE_MSG_SELF_PREMISE_UNVERIFIED = + WebMessageInfo_StubType_BLUE_MSG_SELF_PREMISE_UNVERIFIED; + static constexpr StubType BLUE_MSG_SELF_PREMISE_VERIFIED = + WebMessageInfo_StubType_BLUE_MSG_SELF_PREMISE_VERIFIED; + static constexpr StubType BLUE_MSG_TO_BSP_FB = + WebMessageInfo_StubType_BLUE_MSG_TO_BSP_FB; + static constexpr StubType BLUE_MSG_TO_CONSUMER = + WebMessageInfo_StubType_BLUE_MSG_TO_CONSUMER; + static constexpr StubType BLUE_MSG_TO_SELF_FB = + WebMessageInfo_StubType_BLUE_MSG_TO_SELF_FB; + static constexpr StubType BLUE_MSG_UNVERIFIED_TO_BSP_FB_VERIFIED = + WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_BSP_FB_VERIFIED; + static constexpr StubType BLUE_MSG_UNVERIFIED_TO_BSP_PREMISE_VERIFIED = + WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_BSP_PREMISE_VERIFIED; + static constexpr StubType BLUE_MSG_UNVERIFIED_TO_SELF_FB_VERIFIED = + WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_SELF_FB_VERIFIED; + static constexpr StubType BLUE_MSG_UNVERIFIED_TO_VERIFIED = + WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_VERIFIED; + static constexpr StubType BLUE_MSG_VERIFIED_TO_BSP_FB_UNVERIFIED = + WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_BSP_FB_UNVERIFIED; + static constexpr StubType BLUE_MSG_VERIFIED_TO_BSP_PREMISE_UNVERIFIED = + WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_BSP_PREMISE_UNVERIFIED; + static constexpr StubType BLUE_MSG_VERIFIED_TO_SELF_FB_UNVERIFIED = + WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_SELF_FB_UNVERIFIED; + static constexpr StubType BLUE_MSG_VERIFIED_TO_UNVERIFIED = + WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_UNVERIFIED; + static constexpr StubType BLUE_MSG_BSP_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED = + WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED; + static constexpr StubType BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_FB_VERIFIED = + WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_FB_VERIFIED; + static constexpr StubType BLUE_MSG_BSP_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED = + WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED; + static constexpr StubType BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_FB_UNVERIFIED = + WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_FB_UNVERIFIED; + static constexpr StubType BLUE_MSG_SELF_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED = + WebMessageInfo_StubType_BLUE_MSG_SELF_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED; + static constexpr StubType BLUE_MSG_SELF_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED = + WebMessageInfo_StubType_BLUE_MSG_SELF_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED; + static constexpr StubType E2E_IDENTITY_UNAVAILABLE = + WebMessageInfo_StubType_E2E_IDENTITY_UNAVAILABLE; + static constexpr StubType GROUP_CREATING = + WebMessageInfo_StubType_GROUP_CREATING; + static constexpr StubType GROUP_CREATE_FAILED = + WebMessageInfo_StubType_GROUP_CREATE_FAILED; + static constexpr StubType GROUP_BOUNCED = + WebMessageInfo_StubType_GROUP_BOUNCED; + static constexpr StubType BLOCK_CONTACT = + WebMessageInfo_StubType_BLOCK_CONTACT; + static constexpr StubType EPHEMERAL_SETTING_NOT_APPLIED = + WebMessageInfo_StubType_EPHEMERAL_SETTING_NOT_APPLIED; + static constexpr StubType SYNC_FAILED = + WebMessageInfo_StubType_SYNC_FAILED; + static constexpr StubType SYNCING = + WebMessageInfo_StubType_SYNCING; + static constexpr StubType BIZ_PRIVACY_MODE_INIT_FB = + WebMessageInfo_StubType_BIZ_PRIVACY_MODE_INIT_FB; + static constexpr StubType BIZ_PRIVACY_MODE_INIT_BSP = + WebMessageInfo_StubType_BIZ_PRIVACY_MODE_INIT_BSP; + static constexpr StubType BIZ_PRIVACY_MODE_TO_FB = + WebMessageInfo_StubType_BIZ_PRIVACY_MODE_TO_FB; + static constexpr StubType BIZ_PRIVACY_MODE_TO_BSP = + WebMessageInfo_StubType_BIZ_PRIVACY_MODE_TO_BSP; + static constexpr StubType DISAPPEARING_MODE = + WebMessageInfo_StubType_DISAPPEARING_MODE; + static constexpr StubType E2E_DEVICE_FETCH_FAILED = + WebMessageInfo_StubType_E2E_DEVICE_FETCH_FAILED; + static constexpr StubType ADMIN_REVOKE = + WebMessageInfo_StubType_ADMIN_REVOKE; + static constexpr StubType GROUP_INVITE_LINK_GROWTH_LOCKED = + WebMessageInfo_StubType_GROUP_INVITE_LINK_GROWTH_LOCKED; + static constexpr StubType COMMUNITY_LINK_PARENT_GROUP = + WebMessageInfo_StubType_COMMUNITY_LINK_PARENT_GROUP; + static constexpr StubType COMMUNITY_LINK_SIBLING_GROUP = + WebMessageInfo_StubType_COMMUNITY_LINK_SIBLING_GROUP; + static constexpr StubType COMMUNITY_LINK_SUB_GROUP = + WebMessageInfo_StubType_COMMUNITY_LINK_SUB_GROUP; + static constexpr StubType COMMUNITY_UNLINK_PARENT_GROUP = + WebMessageInfo_StubType_COMMUNITY_UNLINK_PARENT_GROUP; + static constexpr StubType COMMUNITY_UNLINK_SIBLING_GROUP = + WebMessageInfo_StubType_COMMUNITY_UNLINK_SIBLING_GROUP; + static constexpr StubType COMMUNITY_UNLINK_SUB_GROUP = + WebMessageInfo_StubType_COMMUNITY_UNLINK_SUB_GROUP; + static constexpr StubType GROUP_PARTICIPANT_ACCEPT = + WebMessageInfo_StubType_GROUP_PARTICIPANT_ACCEPT; + static constexpr StubType GROUP_PARTICIPANT_LINKED_GROUP_JOIN = + WebMessageInfo_StubType_GROUP_PARTICIPANT_LINKED_GROUP_JOIN; + static constexpr StubType COMMUNITY_CREATE = + WebMessageInfo_StubType_COMMUNITY_CREATE; + static constexpr StubType EPHEMERAL_KEEP_IN_CHAT = + WebMessageInfo_StubType_EPHEMERAL_KEEP_IN_CHAT; + static constexpr StubType GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST = + WebMessageInfo_StubType_GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST; + static constexpr StubType GROUP_MEMBERSHIP_JOIN_APPROVAL_MODE = + WebMessageInfo_StubType_GROUP_MEMBERSHIP_JOIN_APPROVAL_MODE; + static constexpr StubType INTEGRITY_UNLINK_PARENT_GROUP = + WebMessageInfo_StubType_INTEGRITY_UNLINK_PARENT_GROUP; + static constexpr StubType COMMUNITY_PARTICIPANT_PROMOTE = + WebMessageInfo_StubType_COMMUNITY_PARTICIPANT_PROMOTE; + static constexpr StubType COMMUNITY_PARTICIPANT_DEMOTE = + WebMessageInfo_StubType_COMMUNITY_PARTICIPANT_DEMOTE; + static constexpr StubType COMMUNITY_PARENT_GROUP_DELETED = + WebMessageInfo_StubType_COMMUNITY_PARENT_GROUP_DELETED; + static inline bool StubType_IsValid(int value) { + return WebMessageInfo_StubType_IsValid(value); + } + static constexpr StubType StubType_MIN = + WebMessageInfo_StubType_StubType_MIN; + static constexpr StubType StubType_MAX = + WebMessageInfo_StubType_StubType_MAX; + static constexpr int StubType_ARRAYSIZE = + WebMessageInfo_StubType_StubType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + StubType_descriptor() { + return WebMessageInfo_StubType_descriptor(); + } + template + static inline const std::string& StubType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function StubType_Name."); + return WebMessageInfo_StubType_Name(enum_t_value); + } + static inline bool StubType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + StubType* value) { + return WebMessageInfo_StubType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kMessageStubParametersFieldNumber = 26, + kLabelsFieldNumber = 28, + kUserReceiptFieldNumber = 40, + kReactionsFieldNumber = 41, + kPollUpdatesFieldNumber = 45, + kParticipantFieldNumber = 5, + kPushNameFieldNumber = 19, + kMediaCiphertextSha256FieldNumber = 20, + kVerifiedBizNameFieldNumber = 37, + kFutureproofDataFieldNumber = 43, + kAgentIdFieldNumber = 47, + kMessageSecretFieldNumber = 49, + kOriginalSelfAuthorUserJidStringFieldNumber = 51, + kKeyFieldNumber = 1, + kMessageFieldNumber = 2, + kPaymentInfoFieldNumber = 29, + kFinalLiveLocationFieldNumber = 30, + kQuotedPaymentInfoFieldNumber = 31, + kMediaDataFieldNumber = 38, + kPhotoChangeFieldNumber = 39, + kQuotedStickerDataFieldNumber = 42, + kStatusPsaFieldNumber = 44, + kPollAdditionalMetadataFieldNumber = 46, + kKeepInChatFieldNumber = 50, + kMessageTimestampFieldNumber = 3, + kMessageC2STimestampFieldNumber = 6, + kStatusFieldNumber = 4, + kIgnoreFieldNumber = 16, + kStarredFieldNumber = 17, + kBroadcastFieldNumber = 18, + kMulticastFieldNumber = 21, + kMessageStubTypeFieldNumber = 24, + kUrlTextFieldNumber = 22, + kUrlNumberFieldNumber = 23, + kClearMediaFieldNumber = 25, + kEphemeralOffToOnFieldNumber = 34, + kDurationFieldNumber = 27, + kEphemeralDurationFieldNumber = 33, + kEphemeralStartTimestampFieldNumber = 32, + kBizPrivacyStatusFieldNumber = 36, + kEphemeralOutOfSyncFieldNumber = 35, + kStatusAlreadyViewedFieldNumber = 48, + kRevokeMessageTimestampFieldNumber = 52, + }; + // repeated string messageStubParameters = 26; + int messagestubparameters_size() const; + private: + int _internal_messagestubparameters_size() const; + public: + void clear_messagestubparameters(); + const std::string& messagestubparameters(int index) const; + std::string* mutable_messagestubparameters(int index); + void set_messagestubparameters(int index, const std::string& value); + void set_messagestubparameters(int index, std::string&& value); + void set_messagestubparameters(int index, const char* value); + void set_messagestubparameters(int index, const char* value, size_t size); + std::string* add_messagestubparameters(); + void add_messagestubparameters(const std::string& value); + void add_messagestubparameters(std::string&& value); + void add_messagestubparameters(const char* value); + void add_messagestubparameters(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& messagestubparameters() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_messagestubparameters(); + private: + const std::string& _internal_messagestubparameters(int index) const; + std::string* _internal_add_messagestubparameters(); + public: + + // repeated string labels = 28; + int labels_size() const; + private: + int _internal_labels_size() const; + public: + void clear_labels(); + const std::string& labels(int index) const; + std::string* mutable_labels(int index); + void set_labels(int index, const std::string& value); + void set_labels(int index, std::string&& value); + void set_labels(int index, const char* value); + void set_labels(int index, const char* value, size_t size); + std::string* add_labels(); + void add_labels(const std::string& value); + void add_labels(std::string&& value); + void add_labels(const char* value); + void add_labels(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& labels() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_labels(); + private: + const std::string& _internal_labels(int index) const; + std::string* _internal_add_labels(); + public: + + // repeated .proto.UserReceipt userReceipt = 40; + int userreceipt_size() const; + private: + int _internal_userreceipt_size() const; + public: + void clear_userreceipt(); + ::proto::UserReceipt* mutable_userreceipt(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::UserReceipt >* + mutable_userreceipt(); + private: + const ::proto::UserReceipt& _internal_userreceipt(int index) const; + ::proto::UserReceipt* _internal_add_userreceipt(); + public: + const ::proto::UserReceipt& userreceipt(int index) const; + ::proto::UserReceipt* add_userreceipt(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::UserReceipt >& + userreceipt() const; + + // repeated .proto.Reaction reactions = 41; + int reactions_size() const; + private: + int _internal_reactions_size() const; + public: + void clear_reactions(); + ::proto::Reaction* mutable_reactions(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Reaction >* + mutable_reactions(); + private: + const ::proto::Reaction& _internal_reactions(int index) const; + ::proto::Reaction* _internal_add_reactions(); + public: + const ::proto::Reaction& reactions(int index) const; + ::proto::Reaction* add_reactions(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Reaction >& + reactions() const; + + // repeated .proto.PollUpdate pollUpdates = 45; + int pollupdates_size() const; + private: + int _internal_pollupdates_size() const; + public: + void clear_pollupdates(); + ::proto::PollUpdate* mutable_pollupdates(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PollUpdate >* + mutable_pollupdates(); + private: + const ::proto::PollUpdate& _internal_pollupdates(int index) const; + ::proto::PollUpdate* _internal_add_pollupdates(); + public: + const ::proto::PollUpdate& pollupdates(int index) const; + ::proto::PollUpdate* add_pollupdates(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PollUpdate >& + pollupdates() const; + + // optional string participant = 5; + bool has_participant() const; + private: + bool _internal_has_participant() const; + public: + void clear_participant(); + const std::string& participant() const; + template + void set_participant(ArgT0&& arg0, ArgT... args); + std::string* mutable_participant(); + PROTOBUF_NODISCARD std::string* release_participant(); + void set_allocated_participant(std::string* participant); + private: + const std::string& _internal_participant() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_participant(const std::string& value); + std::string* _internal_mutable_participant(); + public: + + // optional string pushName = 19; + bool has_pushname() const; + private: + bool _internal_has_pushname() const; + public: + void clear_pushname(); + const std::string& pushname() const; + template + void set_pushname(ArgT0&& arg0, ArgT... args); + std::string* mutable_pushname(); + PROTOBUF_NODISCARD std::string* release_pushname(); + void set_allocated_pushname(std::string* pushname); + private: + const std::string& _internal_pushname() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_pushname(const std::string& value); + std::string* _internal_mutable_pushname(); + public: + + // optional bytes mediaCiphertextSha256 = 20; + bool has_mediaciphertextsha256() const; + private: + bool _internal_has_mediaciphertextsha256() const; + public: + void clear_mediaciphertextsha256(); + const std::string& mediaciphertextsha256() const; + template + void set_mediaciphertextsha256(ArgT0&& arg0, ArgT... args); + std::string* mutable_mediaciphertextsha256(); + PROTOBUF_NODISCARD std::string* release_mediaciphertextsha256(); + void set_allocated_mediaciphertextsha256(std::string* mediaciphertextsha256); + private: + const std::string& _internal_mediaciphertextsha256() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediaciphertextsha256(const std::string& value); + std::string* _internal_mutable_mediaciphertextsha256(); + public: + + // optional string verifiedBizName = 37; + bool has_verifiedbizname() const; + private: + bool _internal_has_verifiedbizname() const; + public: + void clear_verifiedbizname(); + const std::string& verifiedbizname() const; + template + void set_verifiedbizname(ArgT0&& arg0, ArgT... args); + std::string* mutable_verifiedbizname(); + PROTOBUF_NODISCARD std::string* release_verifiedbizname(); + void set_allocated_verifiedbizname(std::string* verifiedbizname); + private: + const std::string& _internal_verifiedbizname() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_verifiedbizname(const std::string& value); + std::string* _internal_mutable_verifiedbizname(); + public: + + // optional bytes futureproofData = 43; + bool has_futureproofdata() const; + private: + bool _internal_has_futureproofdata() const; + public: + void clear_futureproofdata(); + const std::string& futureproofdata() const; + template + void set_futureproofdata(ArgT0&& arg0, ArgT... args); + std::string* mutable_futureproofdata(); + PROTOBUF_NODISCARD std::string* release_futureproofdata(); + void set_allocated_futureproofdata(std::string* futureproofdata); + private: + const std::string& _internal_futureproofdata() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_futureproofdata(const std::string& value); + std::string* _internal_mutable_futureproofdata(); + public: + + // optional string agentId = 47; + bool has_agentid() const; + private: + bool _internal_has_agentid() const; + public: + void clear_agentid(); + const std::string& agentid() const; + template + void set_agentid(ArgT0&& arg0, ArgT... args); + std::string* mutable_agentid(); + PROTOBUF_NODISCARD std::string* release_agentid(); + void set_allocated_agentid(std::string* agentid); + private: + const std::string& _internal_agentid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_agentid(const std::string& value); + std::string* _internal_mutable_agentid(); + public: + + // optional bytes messageSecret = 49; + bool has_messagesecret() const; + private: + bool _internal_has_messagesecret() const; + public: + void clear_messagesecret(); + const std::string& messagesecret() const; + template + void set_messagesecret(ArgT0&& arg0, ArgT... args); + std::string* mutable_messagesecret(); + PROTOBUF_NODISCARD std::string* release_messagesecret(); + void set_allocated_messagesecret(std::string* messagesecret); + private: + const std::string& _internal_messagesecret() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_messagesecret(const std::string& value); + std::string* _internal_mutable_messagesecret(); + public: + + // optional string originalSelfAuthorUserJidString = 51; + bool has_originalselfauthoruserjidstring() const; + private: + bool _internal_has_originalselfauthoruserjidstring() const; + public: + void clear_originalselfauthoruserjidstring(); + const std::string& originalselfauthoruserjidstring() const; + template + void set_originalselfauthoruserjidstring(ArgT0&& arg0, ArgT... args); + std::string* mutable_originalselfauthoruserjidstring(); + PROTOBUF_NODISCARD std::string* release_originalselfauthoruserjidstring(); + void set_allocated_originalselfauthoruserjidstring(std::string* originalselfauthoruserjidstring); + private: + const std::string& _internal_originalselfauthoruserjidstring() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_originalselfauthoruserjidstring(const std::string& value); + std::string* _internal_mutable_originalselfauthoruserjidstring(); + public: + + // required .proto.MessageKey key = 1; + bool has_key() const; + private: + bool _internal_has_key() const; + public: + void clear_key(); + const ::proto::MessageKey& key() const; + PROTOBUF_NODISCARD ::proto::MessageKey* release_key(); + ::proto::MessageKey* mutable_key(); + void set_allocated_key(::proto::MessageKey* key); + private: + const ::proto::MessageKey& _internal_key() const; + ::proto::MessageKey* _internal_mutable_key(); + public: + void unsafe_arena_set_allocated_key( + ::proto::MessageKey* key); + ::proto::MessageKey* unsafe_arena_release_key(); + + // optional .proto.Message message = 2; + bool has_message() const; + private: + bool _internal_has_message() const; + public: + void clear_message(); + const ::proto::Message& message() const; + PROTOBUF_NODISCARD ::proto::Message* release_message(); + ::proto::Message* mutable_message(); + void set_allocated_message(::proto::Message* message); + private: + const ::proto::Message& _internal_message() const; + ::proto::Message* _internal_mutable_message(); + public: + void unsafe_arena_set_allocated_message( + ::proto::Message* message); + ::proto::Message* unsafe_arena_release_message(); + + // optional .proto.PaymentInfo paymentInfo = 29; + bool has_paymentinfo() const; + private: + bool _internal_has_paymentinfo() const; + public: + void clear_paymentinfo(); + const ::proto::PaymentInfo& paymentinfo() const; + PROTOBUF_NODISCARD ::proto::PaymentInfo* release_paymentinfo(); + ::proto::PaymentInfo* mutable_paymentinfo(); + void set_allocated_paymentinfo(::proto::PaymentInfo* paymentinfo); + private: + const ::proto::PaymentInfo& _internal_paymentinfo() const; + ::proto::PaymentInfo* _internal_mutable_paymentinfo(); + public: + void unsafe_arena_set_allocated_paymentinfo( + ::proto::PaymentInfo* paymentinfo); + ::proto::PaymentInfo* unsafe_arena_release_paymentinfo(); + + // optional .proto.Message.LiveLocationMessage finalLiveLocation = 30; + bool has_finallivelocation() const; + private: + bool _internal_has_finallivelocation() const; + public: + void clear_finallivelocation(); + const ::proto::Message_LiveLocationMessage& finallivelocation() const; + PROTOBUF_NODISCARD ::proto::Message_LiveLocationMessage* release_finallivelocation(); + ::proto::Message_LiveLocationMessage* mutable_finallivelocation(); + void set_allocated_finallivelocation(::proto::Message_LiveLocationMessage* finallivelocation); + private: + const ::proto::Message_LiveLocationMessage& _internal_finallivelocation() const; + ::proto::Message_LiveLocationMessage* _internal_mutable_finallivelocation(); + public: + void unsafe_arena_set_allocated_finallivelocation( + ::proto::Message_LiveLocationMessage* finallivelocation); + ::proto::Message_LiveLocationMessage* unsafe_arena_release_finallivelocation(); + + // optional .proto.PaymentInfo quotedPaymentInfo = 31; + bool has_quotedpaymentinfo() const; + private: + bool _internal_has_quotedpaymentinfo() const; + public: + void clear_quotedpaymentinfo(); + const ::proto::PaymentInfo& quotedpaymentinfo() const; + PROTOBUF_NODISCARD ::proto::PaymentInfo* release_quotedpaymentinfo(); + ::proto::PaymentInfo* mutable_quotedpaymentinfo(); + void set_allocated_quotedpaymentinfo(::proto::PaymentInfo* quotedpaymentinfo); + private: + const ::proto::PaymentInfo& _internal_quotedpaymentinfo() const; + ::proto::PaymentInfo* _internal_mutable_quotedpaymentinfo(); + public: + void unsafe_arena_set_allocated_quotedpaymentinfo( + ::proto::PaymentInfo* quotedpaymentinfo); + ::proto::PaymentInfo* unsafe_arena_release_quotedpaymentinfo(); + + // optional .proto.MediaData mediaData = 38; + bool has_mediadata() const; + private: + bool _internal_has_mediadata() const; + public: + void clear_mediadata(); + const ::proto::MediaData& mediadata() const; + PROTOBUF_NODISCARD ::proto::MediaData* release_mediadata(); + ::proto::MediaData* mutable_mediadata(); + void set_allocated_mediadata(::proto::MediaData* mediadata); + private: + const ::proto::MediaData& _internal_mediadata() const; + ::proto::MediaData* _internal_mutable_mediadata(); + public: + void unsafe_arena_set_allocated_mediadata( + ::proto::MediaData* mediadata); + ::proto::MediaData* unsafe_arena_release_mediadata(); + + // optional .proto.PhotoChange photoChange = 39; + bool has_photochange() const; + private: + bool _internal_has_photochange() const; + public: + void clear_photochange(); + const ::proto::PhotoChange& photochange() const; + PROTOBUF_NODISCARD ::proto::PhotoChange* release_photochange(); + ::proto::PhotoChange* mutable_photochange(); + void set_allocated_photochange(::proto::PhotoChange* photochange); + private: + const ::proto::PhotoChange& _internal_photochange() const; + ::proto::PhotoChange* _internal_mutable_photochange(); + public: + void unsafe_arena_set_allocated_photochange( + ::proto::PhotoChange* photochange); + ::proto::PhotoChange* unsafe_arena_release_photochange(); + + // optional .proto.MediaData quotedStickerData = 42; + bool has_quotedstickerdata() const; + private: + bool _internal_has_quotedstickerdata() const; + public: + void clear_quotedstickerdata(); + const ::proto::MediaData& quotedstickerdata() const; + PROTOBUF_NODISCARD ::proto::MediaData* release_quotedstickerdata(); + ::proto::MediaData* mutable_quotedstickerdata(); + void set_allocated_quotedstickerdata(::proto::MediaData* quotedstickerdata); + private: + const ::proto::MediaData& _internal_quotedstickerdata() const; + ::proto::MediaData* _internal_mutable_quotedstickerdata(); + public: + void unsafe_arena_set_allocated_quotedstickerdata( + ::proto::MediaData* quotedstickerdata); + ::proto::MediaData* unsafe_arena_release_quotedstickerdata(); + + // optional .proto.StatusPSA statusPsa = 44; + bool has_statuspsa() const; + private: + bool _internal_has_statuspsa() const; + public: + void clear_statuspsa(); + const ::proto::StatusPSA& statuspsa() const; + PROTOBUF_NODISCARD ::proto::StatusPSA* release_statuspsa(); + ::proto::StatusPSA* mutable_statuspsa(); + void set_allocated_statuspsa(::proto::StatusPSA* statuspsa); + private: + const ::proto::StatusPSA& _internal_statuspsa() const; + ::proto::StatusPSA* _internal_mutable_statuspsa(); + public: + void unsafe_arena_set_allocated_statuspsa( + ::proto::StatusPSA* statuspsa); + ::proto::StatusPSA* unsafe_arena_release_statuspsa(); + + // optional .proto.PollAdditionalMetadata pollAdditionalMetadata = 46; + bool has_polladditionalmetadata() const; + private: + bool _internal_has_polladditionalmetadata() const; + public: + void clear_polladditionalmetadata(); + const ::proto::PollAdditionalMetadata& polladditionalmetadata() const; + PROTOBUF_NODISCARD ::proto::PollAdditionalMetadata* release_polladditionalmetadata(); + ::proto::PollAdditionalMetadata* mutable_polladditionalmetadata(); + void set_allocated_polladditionalmetadata(::proto::PollAdditionalMetadata* polladditionalmetadata); + private: + const ::proto::PollAdditionalMetadata& _internal_polladditionalmetadata() const; + ::proto::PollAdditionalMetadata* _internal_mutable_polladditionalmetadata(); + public: + void unsafe_arena_set_allocated_polladditionalmetadata( + ::proto::PollAdditionalMetadata* polladditionalmetadata); + ::proto::PollAdditionalMetadata* unsafe_arena_release_polladditionalmetadata(); + + // optional .proto.KeepInChat keepInChat = 50; + bool has_keepinchat() const; + private: + bool _internal_has_keepinchat() const; + public: + void clear_keepinchat(); + const ::proto::KeepInChat& keepinchat() const; + PROTOBUF_NODISCARD ::proto::KeepInChat* release_keepinchat(); + ::proto::KeepInChat* mutable_keepinchat(); + void set_allocated_keepinchat(::proto::KeepInChat* keepinchat); + private: + const ::proto::KeepInChat& _internal_keepinchat() const; + ::proto::KeepInChat* _internal_mutable_keepinchat(); + public: + void unsafe_arena_set_allocated_keepinchat( + ::proto::KeepInChat* keepinchat); + ::proto::KeepInChat* unsafe_arena_release_keepinchat(); + + // optional uint64 messageTimestamp = 3; + bool has_messagetimestamp() const; + private: + bool _internal_has_messagetimestamp() const; + public: + void clear_messagetimestamp(); + uint64_t messagetimestamp() const; + void set_messagetimestamp(uint64_t value); + private: + uint64_t _internal_messagetimestamp() const; + void _internal_set_messagetimestamp(uint64_t value); + public: + + // optional uint64 messageC2STimestamp = 6; + bool has_messagec2stimestamp() const; + private: + bool _internal_has_messagec2stimestamp() const; + public: + void clear_messagec2stimestamp(); + uint64_t messagec2stimestamp() const; + void set_messagec2stimestamp(uint64_t value); + private: + uint64_t _internal_messagec2stimestamp() const; + void _internal_set_messagec2stimestamp(uint64_t value); + public: + + // optional .proto.WebMessageInfo.Status status = 4; + bool has_status() const; + private: + bool _internal_has_status() const; + public: + void clear_status(); + ::proto::WebMessageInfo_Status status() const; + void set_status(::proto::WebMessageInfo_Status value); + private: + ::proto::WebMessageInfo_Status _internal_status() const; + void _internal_set_status(::proto::WebMessageInfo_Status value); + public: + + // optional bool ignore = 16; + bool has_ignore() const; + private: + bool _internal_has_ignore() const; + public: + void clear_ignore(); + bool ignore() const; + void set_ignore(bool value); + private: + bool _internal_ignore() const; + void _internal_set_ignore(bool value); + public: + + // optional bool starred = 17; + bool has_starred() const; + private: + bool _internal_has_starred() const; + public: + void clear_starred(); + bool starred() const; + void set_starred(bool value); + private: + bool _internal_starred() const; + void _internal_set_starred(bool value); + public: + + // optional bool broadcast = 18; + bool has_broadcast() const; + private: + bool _internal_has_broadcast() const; + public: + void clear_broadcast(); + bool broadcast() const; + void set_broadcast(bool value); + private: + bool _internal_broadcast() const; + void _internal_set_broadcast(bool value); + public: + + // optional bool multicast = 21; + bool has_multicast() const; + private: + bool _internal_has_multicast() const; + public: + void clear_multicast(); + bool multicast() const; + void set_multicast(bool value); + private: + bool _internal_multicast() const; + void _internal_set_multicast(bool value); + public: + + // optional .proto.WebMessageInfo.StubType messageStubType = 24; + bool has_messagestubtype() const; + private: + bool _internal_has_messagestubtype() const; + public: + void clear_messagestubtype(); + ::proto::WebMessageInfo_StubType messagestubtype() const; + void set_messagestubtype(::proto::WebMessageInfo_StubType value); + private: + ::proto::WebMessageInfo_StubType _internal_messagestubtype() const; + void _internal_set_messagestubtype(::proto::WebMessageInfo_StubType value); + public: + + // optional bool urlText = 22; + bool has_urltext() const; + private: + bool _internal_has_urltext() const; + public: + void clear_urltext(); + bool urltext() const; + void set_urltext(bool value); + private: + bool _internal_urltext() const; + void _internal_set_urltext(bool value); + public: + + // optional bool urlNumber = 23; + bool has_urlnumber() const; + private: + bool _internal_has_urlnumber() const; + public: + void clear_urlnumber(); + bool urlnumber() const; + void set_urlnumber(bool value); + private: + bool _internal_urlnumber() const; + void _internal_set_urlnumber(bool value); + public: + + // optional bool clearMedia = 25; + bool has_clearmedia() const; + private: + bool _internal_has_clearmedia() const; + public: + void clear_clearmedia(); + bool clearmedia() const; + void set_clearmedia(bool value); + private: + bool _internal_clearmedia() const; + void _internal_set_clearmedia(bool value); + public: + + // optional bool ephemeralOffToOn = 34; + bool has_ephemeralofftoon() const; + private: + bool _internal_has_ephemeralofftoon() const; + public: + void clear_ephemeralofftoon(); + bool ephemeralofftoon() const; + void set_ephemeralofftoon(bool value); + private: + bool _internal_ephemeralofftoon() const; + void _internal_set_ephemeralofftoon(bool value); + public: + + // optional uint32 duration = 27; + bool has_duration() const; + private: + bool _internal_has_duration() const; + public: + void clear_duration(); + uint32_t duration() const; + void set_duration(uint32_t value); + private: + uint32_t _internal_duration() const; + void _internal_set_duration(uint32_t value); + public: + + // optional uint32 ephemeralDuration = 33; + bool has_ephemeralduration() const; + private: + bool _internal_has_ephemeralduration() const; + public: + void clear_ephemeralduration(); + uint32_t ephemeralduration() const; + void set_ephemeralduration(uint32_t value); + private: + uint32_t _internal_ephemeralduration() const; + void _internal_set_ephemeralduration(uint32_t value); + public: + + // optional uint64 ephemeralStartTimestamp = 32; + bool has_ephemeralstarttimestamp() const; + private: + bool _internal_has_ephemeralstarttimestamp() const; + public: + void clear_ephemeralstarttimestamp(); + uint64_t ephemeralstarttimestamp() const; + void set_ephemeralstarttimestamp(uint64_t value); + private: + uint64_t _internal_ephemeralstarttimestamp() const; + void _internal_set_ephemeralstarttimestamp(uint64_t value); + public: + + // optional .proto.WebMessageInfo.BizPrivacyStatus bizPrivacyStatus = 36; + bool has_bizprivacystatus() const; + private: + bool _internal_has_bizprivacystatus() const; + public: + void clear_bizprivacystatus(); + ::proto::WebMessageInfo_BizPrivacyStatus bizprivacystatus() const; + void set_bizprivacystatus(::proto::WebMessageInfo_BizPrivacyStatus value); + private: + ::proto::WebMessageInfo_BizPrivacyStatus _internal_bizprivacystatus() const; + void _internal_set_bizprivacystatus(::proto::WebMessageInfo_BizPrivacyStatus value); + public: + + // optional bool ephemeralOutOfSync = 35; + bool has_ephemeraloutofsync() const; + private: + bool _internal_has_ephemeraloutofsync() const; + public: + void clear_ephemeraloutofsync(); + bool ephemeraloutofsync() const; + void set_ephemeraloutofsync(bool value); + private: + bool _internal_ephemeraloutofsync() const; + void _internal_set_ephemeraloutofsync(bool value); + public: + + // optional bool statusAlreadyViewed = 48; + bool has_statusalreadyviewed() const; + private: + bool _internal_has_statusalreadyviewed() const; + public: + void clear_statusalreadyviewed(); + bool statusalreadyviewed() const; + void set_statusalreadyviewed(bool value); + private: + bool _internal_statusalreadyviewed() const; + void _internal_set_statusalreadyviewed(bool value); + public: + + // optional uint64 revokeMessageTimestamp = 52; + bool has_revokemessagetimestamp() const; + private: + bool _internal_has_revokemessagetimestamp() const; + public: + void clear_revokemessagetimestamp(); + uint64_t revokemessagetimestamp() const; + void set_revokemessagetimestamp(uint64_t value); + private: + uint64_t _internal_revokemessagetimestamp() const; + void _internal_set_revokemessagetimestamp(uint64_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.WebMessageInfo) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<2> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField messagestubparameters_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField labels_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::UserReceipt > userreceipt_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Reaction > reactions_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PollUpdate > pollupdates_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr participant_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pushname_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediaciphertextsha256_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr verifiedbizname_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr futureproofdata_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr agentid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr messagesecret_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr originalselfauthoruserjidstring_; + ::proto::MessageKey* key_; + ::proto::Message* message_; + ::proto::PaymentInfo* paymentinfo_; + ::proto::Message_LiveLocationMessage* finallivelocation_; + ::proto::PaymentInfo* quotedpaymentinfo_; + ::proto::MediaData* mediadata_; + ::proto::PhotoChange* photochange_; + ::proto::MediaData* quotedstickerdata_; + ::proto::StatusPSA* statuspsa_; + ::proto::PollAdditionalMetadata* polladditionalmetadata_; + ::proto::KeepInChat* keepinchat_; + uint64_t messagetimestamp_; + uint64_t messagec2stimestamp_; + int status_; + bool ignore_; + bool starred_; + bool broadcast_; + bool multicast_; + int messagestubtype_; + bool urltext_; + bool urlnumber_; + bool clearmedia_; + bool ephemeralofftoon_; + uint32_t duration_; + uint32_t ephemeralduration_; + uint64_t ephemeralstarttimestamp_; + int bizprivacystatus_; + bool ephemeraloutofsync_; + bool statusalreadyviewed_; + uint64_t revokemessagetimestamp_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// ------------------------------------------------------------------- + +class WebNotificationsInfo final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.WebNotificationsInfo) */ { + public: + inline WebNotificationsInfo() : WebNotificationsInfo(nullptr) {} + ~WebNotificationsInfo() override; + explicit PROTOBUF_CONSTEXPR WebNotificationsInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + WebNotificationsInfo(const WebNotificationsInfo& from); + WebNotificationsInfo(WebNotificationsInfo&& from) noexcept + : WebNotificationsInfo() { + *this = ::std::move(from); + } + + inline WebNotificationsInfo& operator=(const WebNotificationsInfo& from) { + CopyFrom(from); + return *this; + } + inline WebNotificationsInfo& operator=(WebNotificationsInfo&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const WebNotificationsInfo& default_instance() { + return *internal_default_instance(); + } + static inline const WebNotificationsInfo* internal_default_instance() { + return reinterpret_cast( + &_WebNotificationsInfo_default_instance_); + } + static constexpr int kIndexInFileMessages = + 223; + + friend void swap(WebNotificationsInfo& a, WebNotificationsInfo& b) { + a.Swap(&b); + } + inline void Swap(WebNotificationsInfo* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(WebNotificationsInfo* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + WebNotificationsInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const WebNotificationsInfo& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const WebNotificationsInfo& from) { + WebNotificationsInfo::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(WebNotificationsInfo* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "proto.WebNotificationsInfo"; + } + protected: + explicit WebNotificationsInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNotifyMessagesFieldNumber = 5, + kTimestampFieldNumber = 2, + kUnreadChatsFieldNumber = 3, + kNotifyMessageCountFieldNumber = 4, + }; + // repeated .proto.WebMessageInfo notifyMessages = 5; + int notifymessages_size() const; + private: + int _internal_notifymessages_size() const; + public: + void clear_notifymessages(); + ::proto::WebMessageInfo* mutable_notifymessages(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >* + mutable_notifymessages(); + private: + const ::proto::WebMessageInfo& _internal_notifymessages(int index) const; + ::proto::WebMessageInfo* _internal_add_notifymessages(); + public: + const ::proto::WebMessageInfo& notifymessages(int index) const; + ::proto::WebMessageInfo* add_notifymessages(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >& + notifymessages() const; + + // optional uint64 timestamp = 2; + bool has_timestamp() const; + private: + bool _internal_has_timestamp() const; + public: + void clear_timestamp(); + uint64_t timestamp() const; + void set_timestamp(uint64_t value); + private: + uint64_t _internal_timestamp() const; + void _internal_set_timestamp(uint64_t value); + public: + + // optional uint32 unreadChats = 3; + bool has_unreadchats() const; + private: + bool _internal_has_unreadchats() const; + public: + void clear_unreadchats(); + uint32_t unreadchats() const; + void set_unreadchats(uint32_t value); + private: + uint32_t _internal_unreadchats() const; + void _internal_set_unreadchats(uint32_t value); + public: + + // optional uint32 notifyMessageCount = 4; + bool has_notifymessagecount() const; + private: + bool _internal_has_notifymessagecount() const; + public: + void clear_notifymessagecount(); + uint32_t notifymessagecount() const; + void set_notifymessagecount(uint32_t value); + private: + uint32_t _internal_notifymessagecount() const; + void _internal_set_notifymessagecount(uint32_t value); + public: + + // @@protoc_insertion_point(class_scope:proto.WebNotificationsInfo) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo > notifymessages_; + uint64_t timestamp_; + uint32_t unreadchats_; + uint32_t notifymessagecount_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_pmsg_2eproto; +}; +// =================================================================== + + +// =================================================================== + +#ifdef __GNUC__ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// ADVDeviceIdentity + +// optional uint32 rawId = 1; +inline bool ADVDeviceIdentity::_internal_has_rawid() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ADVDeviceIdentity::has_rawid() const { + return _internal_has_rawid(); +} +inline void ADVDeviceIdentity::clear_rawid() { + _impl_.rawid_ = 0u; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline uint32_t ADVDeviceIdentity::_internal_rawid() const { + return _impl_.rawid_; +} +inline uint32_t ADVDeviceIdentity::rawid() const { + // @@protoc_insertion_point(field_get:proto.ADVDeviceIdentity.rawId) + return _internal_rawid(); +} +inline void ADVDeviceIdentity::_internal_set_rawid(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.rawid_ = value; +} +inline void ADVDeviceIdentity::set_rawid(uint32_t value) { + _internal_set_rawid(value); + // @@protoc_insertion_point(field_set:proto.ADVDeviceIdentity.rawId) +} + +// optional uint64 timestamp = 2; +inline bool ADVDeviceIdentity::_internal_has_timestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ADVDeviceIdentity::has_timestamp() const { + return _internal_has_timestamp(); +} +inline void ADVDeviceIdentity::clear_timestamp() { + _impl_.timestamp_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline uint64_t ADVDeviceIdentity::_internal_timestamp() const { + return _impl_.timestamp_; +} +inline uint64_t ADVDeviceIdentity::timestamp() const { + // @@protoc_insertion_point(field_get:proto.ADVDeviceIdentity.timestamp) + return _internal_timestamp(); +} +inline void ADVDeviceIdentity::_internal_set_timestamp(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.timestamp_ = value; +} +inline void ADVDeviceIdentity::set_timestamp(uint64_t value) { + _internal_set_timestamp(value); + // @@protoc_insertion_point(field_set:proto.ADVDeviceIdentity.timestamp) +} + +// optional uint32 keyIndex = 3; +inline bool ADVDeviceIdentity::_internal_has_keyindex() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ADVDeviceIdentity::has_keyindex() const { + return _internal_has_keyindex(); +} +inline void ADVDeviceIdentity::clear_keyindex() { + _impl_.keyindex_ = 0u; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline uint32_t ADVDeviceIdentity::_internal_keyindex() const { + return _impl_.keyindex_; +} +inline uint32_t ADVDeviceIdentity::keyindex() const { + // @@protoc_insertion_point(field_get:proto.ADVDeviceIdentity.keyIndex) + return _internal_keyindex(); +} +inline void ADVDeviceIdentity::_internal_set_keyindex(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.keyindex_ = value; +} +inline void ADVDeviceIdentity::set_keyindex(uint32_t value) { + _internal_set_keyindex(value); + // @@protoc_insertion_point(field_set:proto.ADVDeviceIdentity.keyIndex) +} + +// ------------------------------------------------------------------- + +// ADVKeyIndexList + +// optional uint32 rawId = 1; +inline bool ADVKeyIndexList::_internal_has_rawid() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ADVKeyIndexList::has_rawid() const { + return _internal_has_rawid(); +} +inline void ADVKeyIndexList::clear_rawid() { + _impl_.rawid_ = 0u; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline uint32_t ADVKeyIndexList::_internal_rawid() const { + return _impl_.rawid_; +} +inline uint32_t ADVKeyIndexList::rawid() const { + // @@protoc_insertion_point(field_get:proto.ADVKeyIndexList.rawId) + return _internal_rawid(); +} +inline void ADVKeyIndexList::_internal_set_rawid(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.rawid_ = value; +} +inline void ADVKeyIndexList::set_rawid(uint32_t value) { + _internal_set_rawid(value); + // @@protoc_insertion_point(field_set:proto.ADVKeyIndexList.rawId) +} + +// optional uint64 timestamp = 2; +inline bool ADVKeyIndexList::_internal_has_timestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ADVKeyIndexList::has_timestamp() const { + return _internal_has_timestamp(); +} +inline void ADVKeyIndexList::clear_timestamp() { + _impl_.timestamp_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline uint64_t ADVKeyIndexList::_internal_timestamp() const { + return _impl_.timestamp_; +} +inline uint64_t ADVKeyIndexList::timestamp() const { + // @@protoc_insertion_point(field_get:proto.ADVKeyIndexList.timestamp) + return _internal_timestamp(); +} +inline void ADVKeyIndexList::_internal_set_timestamp(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.timestamp_ = value; +} +inline void ADVKeyIndexList::set_timestamp(uint64_t value) { + _internal_set_timestamp(value); + // @@protoc_insertion_point(field_set:proto.ADVKeyIndexList.timestamp) +} + +// optional uint32 currentIndex = 3; +inline bool ADVKeyIndexList::_internal_has_currentindex() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ADVKeyIndexList::has_currentindex() const { + return _internal_has_currentindex(); +} +inline void ADVKeyIndexList::clear_currentindex() { + _impl_.currentindex_ = 0u; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline uint32_t ADVKeyIndexList::_internal_currentindex() const { + return _impl_.currentindex_; +} +inline uint32_t ADVKeyIndexList::currentindex() const { + // @@protoc_insertion_point(field_get:proto.ADVKeyIndexList.currentIndex) + return _internal_currentindex(); +} +inline void ADVKeyIndexList::_internal_set_currentindex(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.currentindex_ = value; +} +inline void ADVKeyIndexList::set_currentindex(uint32_t value) { + _internal_set_currentindex(value); + // @@protoc_insertion_point(field_set:proto.ADVKeyIndexList.currentIndex) +} + +// repeated uint32 validIndexes = 4 [packed = true]; +inline int ADVKeyIndexList::_internal_validindexes_size() const { + return _impl_.validindexes_.size(); +} +inline int ADVKeyIndexList::validindexes_size() const { + return _internal_validindexes_size(); +} +inline void ADVKeyIndexList::clear_validindexes() { + _impl_.validindexes_.Clear(); +} +inline uint32_t ADVKeyIndexList::_internal_validindexes(int index) const { + return _impl_.validindexes_.Get(index); +} +inline uint32_t ADVKeyIndexList::validindexes(int index) const { + // @@protoc_insertion_point(field_get:proto.ADVKeyIndexList.validIndexes) + return _internal_validindexes(index); +} +inline void ADVKeyIndexList::set_validindexes(int index, uint32_t value) { + _impl_.validindexes_.Set(index, value); + // @@protoc_insertion_point(field_set:proto.ADVKeyIndexList.validIndexes) +} +inline void ADVKeyIndexList::_internal_add_validindexes(uint32_t value) { + _impl_.validindexes_.Add(value); +} +inline void ADVKeyIndexList::add_validindexes(uint32_t value) { + _internal_add_validindexes(value); + // @@protoc_insertion_point(field_add:proto.ADVKeyIndexList.validIndexes) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +ADVKeyIndexList::_internal_validindexes() const { + return _impl_.validindexes_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +ADVKeyIndexList::validindexes() const { + // @@protoc_insertion_point(field_list:proto.ADVKeyIndexList.validIndexes) + return _internal_validindexes(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +ADVKeyIndexList::_internal_mutable_validindexes() { + return &_impl_.validindexes_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +ADVKeyIndexList::mutable_validindexes() { + // @@protoc_insertion_point(field_mutable_list:proto.ADVKeyIndexList.validIndexes) + return _internal_mutable_validindexes(); +} + +// ------------------------------------------------------------------- + +// ADVSignedDeviceIdentity + +// optional bytes details = 1; +inline bool ADVSignedDeviceIdentity::_internal_has_details() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ADVSignedDeviceIdentity::has_details() const { + return _internal_has_details(); +} +inline void ADVSignedDeviceIdentity::clear_details() { + _impl_.details_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ADVSignedDeviceIdentity::details() const { + // @@protoc_insertion_point(field_get:proto.ADVSignedDeviceIdentity.details) + return _internal_details(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ADVSignedDeviceIdentity::set_details(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.details_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ADVSignedDeviceIdentity.details) +} +inline std::string* ADVSignedDeviceIdentity::mutable_details() { + std::string* _s = _internal_mutable_details(); + // @@protoc_insertion_point(field_mutable:proto.ADVSignedDeviceIdentity.details) + return _s; +} +inline const std::string& ADVSignedDeviceIdentity::_internal_details() const { + return _impl_.details_.Get(); +} +inline void ADVSignedDeviceIdentity::_internal_set_details(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.details_.Set(value, GetArenaForAllocation()); +} +inline std::string* ADVSignedDeviceIdentity::_internal_mutable_details() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.details_.Mutable(GetArenaForAllocation()); +} +inline std::string* ADVSignedDeviceIdentity::release_details() { + // @@protoc_insertion_point(field_release:proto.ADVSignedDeviceIdentity.details) + if (!_internal_has_details()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.details_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.details_.IsDefault()) { + _impl_.details_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ADVSignedDeviceIdentity::set_allocated_details(std::string* details) { + if (details != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.details_.SetAllocated(details, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.details_.IsDefault()) { + _impl_.details_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedDeviceIdentity.details) +} + +// optional bytes accountSignatureKey = 2; +inline bool ADVSignedDeviceIdentity::_internal_has_accountsignaturekey() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ADVSignedDeviceIdentity::has_accountsignaturekey() const { + return _internal_has_accountsignaturekey(); +} +inline void ADVSignedDeviceIdentity::clear_accountsignaturekey() { + _impl_.accountsignaturekey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& ADVSignedDeviceIdentity::accountsignaturekey() const { + // @@protoc_insertion_point(field_get:proto.ADVSignedDeviceIdentity.accountSignatureKey) + return _internal_accountsignaturekey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ADVSignedDeviceIdentity::set_accountsignaturekey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.accountsignaturekey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ADVSignedDeviceIdentity.accountSignatureKey) +} +inline std::string* ADVSignedDeviceIdentity::mutable_accountsignaturekey() { + std::string* _s = _internal_mutable_accountsignaturekey(); + // @@protoc_insertion_point(field_mutable:proto.ADVSignedDeviceIdentity.accountSignatureKey) + return _s; +} +inline const std::string& ADVSignedDeviceIdentity::_internal_accountsignaturekey() const { + return _impl_.accountsignaturekey_.Get(); +} +inline void ADVSignedDeviceIdentity::_internal_set_accountsignaturekey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.accountsignaturekey_.Set(value, GetArenaForAllocation()); +} +inline std::string* ADVSignedDeviceIdentity::_internal_mutable_accountsignaturekey() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.accountsignaturekey_.Mutable(GetArenaForAllocation()); +} +inline std::string* ADVSignedDeviceIdentity::release_accountsignaturekey() { + // @@protoc_insertion_point(field_release:proto.ADVSignedDeviceIdentity.accountSignatureKey) + if (!_internal_has_accountsignaturekey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.accountsignaturekey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.accountsignaturekey_.IsDefault()) { + _impl_.accountsignaturekey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ADVSignedDeviceIdentity::set_allocated_accountsignaturekey(std::string* accountsignaturekey) { + if (accountsignaturekey != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.accountsignaturekey_.SetAllocated(accountsignaturekey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.accountsignaturekey_.IsDefault()) { + _impl_.accountsignaturekey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedDeviceIdentity.accountSignatureKey) +} + +// optional bytes accountSignature = 3; +inline bool ADVSignedDeviceIdentity::_internal_has_accountsignature() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ADVSignedDeviceIdentity::has_accountsignature() const { + return _internal_has_accountsignature(); +} +inline void ADVSignedDeviceIdentity::clear_accountsignature() { + _impl_.accountsignature_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& ADVSignedDeviceIdentity::accountsignature() const { + // @@protoc_insertion_point(field_get:proto.ADVSignedDeviceIdentity.accountSignature) + return _internal_accountsignature(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ADVSignedDeviceIdentity::set_accountsignature(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.accountsignature_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ADVSignedDeviceIdentity.accountSignature) +} +inline std::string* ADVSignedDeviceIdentity::mutable_accountsignature() { + std::string* _s = _internal_mutable_accountsignature(); + // @@protoc_insertion_point(field_mutable:proto.ADVSignedDeviceIdentity.accountSignature) + return _s; +} +inline const std::string& ADVSignedDeviceIdentity::_internal_accountsignature() const { + return _impl_.accountsignature_.Get(); +} +inline void ADVSignedDeviceIdentity::_internal_set_accountsignature(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.accountsignature_.Set(value, GetArenaForAllocation()); +} +inline std::string* ADVSignedDeviceIdentity::_internal_mutable_accountsignature() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.accountsignature_.Mutable(GetArenaForAllocation()); +} +inline std::string* ADVSignedDeviceIdentity::release_accountsignature() { + // @@protoc_insertion_point(field_release:proto.ADVSignedDeviceIdentity.accountSignature) + if (!_internal_has_accountsignature()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.accountsignature_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.accountsignature_.IsDefault()) { + _impl_.accountsignature_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ADVSignedDeviceIdentity::set_allocated_accountsignature(std::string* accountsignature) { + if (accountsignature != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.accountsignature_.SetAllocated(accountsignature, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.accountsignature_.IsDefault()) { + _impl_.accountsignature_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedDeviceIdentity.accountSignature) +} + +// optional bytes deviceSignature = 4; +inline bool ADVSignedDeviceIdentity::_internal_has_devicesignature() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ADVSignedDeviceIdentity::has_devicesignature() const { + return _internal_has_devicesignature(); +} +inline void ADVSignedDeviceIdentity::clear_devicesignature() { + _impl_.devicesignature_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const std::string& ADVSignedDeviceIdentity::devicesignature() const { + // @@protoc_insertion_point(field_get:proto.ADVSignedDeviceIdentity.deviceSignature) + return _internal_devicesignature(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ADVSignedDeviceIdentity::set_devicesignature(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.devicesignature_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ADVSignedDeviceIdentity.deviceSignature) +} +inline std::string* ADVSignedDeviceIdentity::mutable_devicesignature() { + std::string* _s = _internal_mutable_devicesignature(); + // @@protoc_insertion_point(field_mutable:proto.ADVSignedDeviceIdentity.deviceSignature) + return _s; +} +inline const std::string& ADVSignedDeviceIdentity::_internal_devicesignature() const { + return _impl_.devicesignature_.Get(); +} +inline void ADVSignedDeviceIdentity::_internal_set_devicesignature(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.devicesignature_.Set(value, GetArenaForAllocation()); +} +inline std::string* ADVSignedDeviceIdentity::_internal_mutable_devicesignature() { + _impl_._has_bits_[0] |= 0x00000008u; + return _impl_.devicesignature_.Mutable(GetArenaForAllocation()); +} +inline std::string* ADVSignedDeviceIdentity::release_devicesignature() { + // @@protoc_insertion_point(field_release:proto.ADVSignedDeviceIdentity.deviceSignature) + if (!_internal_has_devicesignature()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000008u; + auto* p = _impl_.devicesignature_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.devicesignature_.IsDefault()) { + _impl_.devicesignature_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ADVSignedDeviceIdentity::set_allocated_devicesignature(std::string* devicesignature) { + if (devicesignature != nullptr) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.devicesignature_.SetAllocated(devicesignature, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.devicesignature_.IsDefault()) { + _impl_.devicesignature_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedDeviceIdentity.deviceSignature) +} + +// ------------------------------------------------------------------- + +// ADVSignedDeviceIdentityHMAC + +// optional bytes details = 1; +inline bool ADVSignedDeviceIdentityHMAC::_internal_has_details() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ADVSignedDeviceIdentityHMAC::has_details() const { + return _internal_has_details(); +} +inline void ADVSignedDeviceIdentityHMAC::clear_details() { + _impl_.details_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ADVSignedDeviceIdentityHMAC::details() const { + // @@protoc_insertion_point(field_get:proto.ADVSignedDeviceIdentityHMAC.details) + return _internal_details(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ADVSignedDeviceIdentityHMAC::set_details(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.details_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ADVSignedDeviceIdentityHMAC.details) +} +inline std::string* ADVSignedDeviceIdentityHMAC::mutable_details() { + std::string* _s = _internal_mutable_details(); + // @@protoc_insertion_point(field_mutable:proto.ADVSignedDeviceIdentityHMAC.details) + return _s; +} +inline const std::string& ADVSignedDeviceIdentityHMAC::_internal_details() const { + return _impl_.details_.Get(); +} +inline void ADVSignedDeviceIdentityHMAC::_internal_set_details(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.details_.Set(value, GetArenaForAllocation()); +} +inline std::string* ADVSignedDeviceIdentityHMAC::_internal_mutable_details() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.details_.Mutable(GetArenaForAllocation()); +} +inline std::string* ADVSignedDeviceIdentityHMAC::release_details() { + // @@protoc_insertion_point(field_release:proto.ADVSignedDeviceIdentityHMAC.details) + if (!_internal_has_details()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.details_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.details_.IsDefault()) { + _impl_.details_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ADVSignedDeviceIdentityHMAC::set_allocated_details(std::string* details) { + if (details != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.details_.SetAllocated(details, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.details_.IsDefault()) { + _impl_.details_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedDeviceIdentityHMAC.details) +} + +// optional bytes hmac = 2; +inline bool ADVSignedDeviceIdentityHMAC::_internal_has_hmac() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ADVSignedDeviceIdentityHMAC::has_hmac() const { + return _internal_has_hmac(); +} +inline void ADVSignedDeviceIdentityHMAC::clear_hmac() { + _impl_.hmac_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& ADVSignedDeviceIdentityHMAC::hmac() const { + // @@protoc_insertion_point(field_get:proto.ADVSignedDeviceIdentityHMAC.hmac) + return _internal_hmac(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ADVSignedDeviceIdentityHMAC::set_hmac(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.hmac_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ADVSignedDeviceIdentityHMAC.hmac) +} +inline std::string* ADVSignedDeviceIdentityHMAC::mutable_hmac() { + std::string* _s = _internal_mutable_hmac(); + // @@protoc_insertion_point(field_mutable:proto.ADVSignedDeviceIdentityHMAC.hmac) + return _s; +} +inline const std::string& ADVSignedDeviceIdentityHMAC::_internal_hmac() const { + return _impl_.hmac_.Get(); +} +inline void ADVSignedDeviceIdentityHMAC::_internal_set_hmac(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.hmac_.Set(value, GetArenaForAllocation()); +} +inline std::string* ADVSignedDeviceIdentityHMAC::_internal_mutable_hmac() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.hmac_.Mutable(GetArenaForAllocation()); +} +inline std::string* ADVSignedDeviceIdentityHMAC::release_hmac() { + // @@protoc_insertion_point(field_release:proto.ADVSignedDeviceIdentityHMAC.hmac) + if (!_internal_has_hmac()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.hmac_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.hmac_.IsDefault()) { + _impl_.hmac_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ADVSignedDeviceIdentityHMAC::set_allocated_hmac(std::string* hmac) { + if (hmac != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.hmac_.SetAllocated(hmac, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.hmac_.IsDefault()) { + _impl_.hmac_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedDeviceIdentityHMAC.hmac) +} + +// ------------------------------------------------------------------- + +// ADVSignedKeyIndexList + +// optional bytes details = 1; +inline bool ADVSignedKeyIndexList::_internal_has_details() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ADVSignedKeyIndexList::has_details() const { + return _internal_has_details(); +} +inline void ADVSignedKeyIndexList::clear_details() { + _impl_.details_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ADVSignedKeyIndexList::details() const { + // @@protoc_insertion_point(field_get:proto.ADVSignedKeyIndexList.details) + return _internal_details(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ADVSignedKeyIndexList::set_details(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.details_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ADVSignedKeyIndexList.details) +} +inline std::string* ADVSignedKeyIndexList::mutable_details() { + std::string* _s = _internal_mutable_details(); + // @@protoc_insertion_point(field_mutable:proto.ADVSignedKeyIndexList.details) + return _s; +} +inline const std::string& ADVSignedKeyIndexList::_internal_details() const { + return _impl_.details_.Get(); +} +inline void ADVSignedKeyIndexList::_internal_set_details(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.details_.Set(value, GetArenaForAllocation()); +} +inline std::string* ADVSignedKeyIndexList::_internal_mutable_details() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.details_.Mutable(GetArenaForAllocation()); +} +inline std::string* ADVSignedKeyIndexList::release_details() { + // @@protoc_insertion_point(field_release:proto.ADVSignedKeyIndexList.details) + if (!_internal_has_details()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.details_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.details_.IsDefault()) { + _impl_.details_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ADVSignedKeyIndexList::set_allocated_details(std::string* details) { + if (details != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.details_.SetAllocated(details, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.details_.IsDefault()) { + _impl_.details_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedKeyIndexList.details) +} + +// optional bytes accountSignature = 2; +inline bool ADVSignedKeyIndexList::_internal_has_accountsignature() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ADVSignedKeyIndexList::has_accountsignature() const { + return _internal_has_accountsignature(); +} +inline void ADVSignedKeyIndexList::clear_accountsignature() { + _impl_.accountsignature_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& ADVSignedKeyIndexList::accountsignature() const { + // @@protoc_insertion_point(field_get:proto.ADVSignedKeyIndexList.accountSignature) + return _internal_accountsignature(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ADVSignedKeyIndexList::set_accountsignature(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.accountsignature_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ADVSignedKeyIndexList.accountSignature) +} +inline std::string* ADVSignedKeyIndexList::mutable_accountsignature() { + std::string* _s = _internal_mutable_accountsignature(); + // @@protoc_insertion_point(field_mutable:proto.ADVSignedKeyIndexList.accountSignature) + return _s; +} +inline const std::string& ADVSignedKeyIndexList::_internal_accountsignature() const { + return _impl_.accountsignature_.Get(); +} +inline void ADVSignedKeyIndexList::_internal_set_accountsignature(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.accountsignature_.Set(value, GetArenaForAllocation()); +} +inline std::string* ADVSignedKeyIndexList::_internal_mutable_accountsignature() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.accountsignature_.Mutable(GetArenaForAllocation()); +} +inline std::string* ADVSignedKeyIndexList::release_accountsignature() { + // @@protoc_insertion_point(field_release:proto.ADVSignedKeyIndexList.accountSignature) + if (!_internal_has_accountsignature()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.accountsignature_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.accountsignature_.IsDefault()) { + _impl_.accountsignature_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ADVSignedKeyIndexList::set_allocated_accountsignature(std::string* accountsignature) { + if (accountsignature != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.accountsignature_.SetAllocated(accountsignature, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.accountsignature_.IsDefault()) { + _impl_.accountsignature_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedKeyIndexList.accountSignature) +} + +// ------------------------------------------------------------------- + +// ActionLink + +// optional string url = 1; +inline bool ActionLink::_internal_has_url() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ActionLink::has_url() const { + return _internal_has_url(); +} +inline void ActionLink::clear_url() { + _impl_.url_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ActionLink::url() const { + // @@protoc_insertion_point(field_get:proto.ActionLink.url) + return _internal_url(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ActionLink::set_url(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.url_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ActionLink.url) +} +inline std::string* ActionLink::mutable_url() { + std::string* _s = _internal_mutable_url(); + // @@protoc_insertion_point(field_mutable:proto.ActionLink.url) + return _s; +} +inline const std::string& ActionLink::_internal_url() const { + return _impl_.url_.Get(); +} +inline void ActionLink::_internal_set_url(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.url_.Set(value, GetArenaForAllocation()); +} +inline std::string* ActionLink::_internal_mutable_url() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.url_.Mutable(GetArenaForAllocation()); +} +inline std::string* ActionLink::release_url() { + // @@protoc_insertion_point(field_release:proto.ActionLink.url) + if (!_internal_has_url()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.url_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.url_.IsDefault()) { + _impl_.url_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ActionLink::set_allocated_url(std::string* url) { + if (url != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.url_.SetAllocated(url, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.url_.IsDefault()) { + _impl_.url_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ActionLink.url) +} + +// optional string buttonTitle = 2; +inline bool ActionLink::_internal_has_buttontitle() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ActionLink::has_buttontitle() const { + return _internal_has_buttontitle(); +} +inline void ActionLink::clear_buttontitle() { + _impl_.buttontitle_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& ActionLink::buttontitle() const { + // @@protoc_insertion_point(field_get:proto.ActionLink.buttonTitle) + return _internal_buttontitle(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ActionLink::set_buttontitle(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.buttontitle_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ActionLink.buttonTitle) +} +inline std::string* ActionLink::mutable_buttontitle() { + std::string* _s = _internal_mutable_buttontitle(); + // @@protoc_insertion_point(field_mutable:proto.ActionLink.buttonTitle) + return _s; +} +inline const std::string& ActionLink::_internal_buttontitle() const { + return _impl_.buttontitle_.Get(); +} +inline void ActionLink::_internal_set_buttontitle(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.buttontitle_.Set(value, GetArenaForAllocation()); +} +inline std::string* ActionLink::_internal_mutable_buttontitle() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.buttontitle_.Mutable(GetArenaForAllocation()); +} +inline std::string* ActionLink::release_buttontitle() { + // @@protoc_insertion_point(field_release:proto.ActionLink.buttonTitle) + if (!_internal_has_buttontitle()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.buttontitle_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.buttontitle_.IsDefault()) { + _impl_.buttontitle_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ActionLink::set_allocated_buttontitle(std::string* buttontitle) { + if (buttontitle != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.buttontitle_.SetAllocated(buttontitle, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.buttontitle_.IsDefault()) { + _impl_.buttontitle_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ActionLink.buttonTitle) +} + +// ------------------------------------------------------------------- + +// AutoDownloadSettings + +// optional bool downloadImages = 1; +inline bool AutoDownloadSettings::_internal_has_downloadimages() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool AutoDownloadSettings::has_downloadimages() const { + return _internal_has_downloadimages(); +} +inline void AutoDownloadSettings::clear_downloadimages() { + _impl_.downloadimages_ = false; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline bool AutoDownloadSettings::_internal_downloadimages() const { + return _impl_.downloadimages_; +} +inline bool AutoDownloadSettings::downloadimages() const { + // @@protoc_insertion_point(field_get:proto.AutoDownloadSettings.downloadImages) + return _internal_downloadimages(); +} +inline void AutoDownloadSettings::_internal_set_downloadimages(bool value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.downloadimages_ = value; +} +inline void AutoDownloadSettings::set_downloadimages(bool value) { + _internal_set_downloadimages(value); + // @@protoc_insertion_point(field_set:proto.AutoDownloadSettings.downloadImages) +} + +// optional bool downloadAudio = 2; +inline bool AutoDownloadSettings::_internal_has_downloadaudio() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool AutoDownloadSettings::has_downloadaudio() const { + return _internal_has_downloadaudio(); +} +inline void AutoDownloadSettings::clear_downloadaudio() { + _impl_.downloadaudio_ = false; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline bool AutoDownloadSettings::_internal_downloadaudio() const { + return _impl_.downloadaudio_; +} +inline bool AutoDownloadSettings::downloadaudio() const { + // @@protoc_insertion_point(field_get:proto.AutoDownloadSettings.downloadAudio) + return _internal_downloadaudio(); +} +inline void AutoDownloadSettings::_internal_set_downloadaudio(bool value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.downloadaudio_ = value; +} +inline void AutoDownloadSettings::set_downloadaudio(bool value) { + _internal_set_downloadaudio(value); + // @@protoc_insertion_point(field_set:proto.AutoDownloadSettings.downloadAudio) +} + +// optional bool downloadVideo = 3; +inline bool AutoDownloadSettings::_internal_has_downloadvideo() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool AutoDownloadSettings::has_downloadvideo() const { + return _internal_has_downloadvideo(); +} +inline void AutoDownloadSettings::clear_downloadvideo() { + _impl_.downloadvideo_ = false; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline bool AutoDownloadSettings::_internal_downloadvideo() const { + return _impl_.downloadvideo_; +} +inline bool AutoDownloadSettings::downloadvideo() const { + // @@protoc_insertion_point(field_get:proto.AutoDownloadSettings.downloadVideo) + return _internal_downloadvideo(); +} +inline void AutoDownloadSettings::_internal_set_downloadvideo(bool value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.downloadvideo_ = value; +} +inline void AutoDownloadSettings::set_downloadvideo(bool value) { + _internal_set_downloadvideo(value); + // @@protoc_insertion_point(field_set:proto.AutoDownloadSettings.downloadVideo) +} + +// optional bool downloadDocuments = 4; +inline bool AutoDownloadSettings::_internal_has_downloaddocuments() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool AutoDownloadSettings::has_downloaddocuments() const { + return _internal_has_downloaddocuments(); +} +inline void AutoDownloadSettings::clear_downloaddocuments() { + _impl_.downloaddocuments_ = false; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline bool AutoDownloadSettings::_internal_downloaddocuments() const { + return _impl_.downloaddocuments_; +} +inline bool AutoDownloadSettings::downloaddocuments() const { + // @@protoc_insertion_point(field_get:proto.AutoDownloadSettings.downloadDocuments) + return _internal_downloaddocuments(); +} +inline void AutoDownloadSettings::_internal_set_downloaddocuments(bool value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.downloaddocuments_ = value; +} +inline void AutoDownloadSettings::set_downloaddocuments(bool value) { + _internal_set_downloaddocuments(value); + // @@protoc_insertion_point(field_set:proto.AutoDownloadSettings.downloadDocuments) +} + +// ------------------------------------------------------------------- + +// BizAccountLinkInfo + +// optional uint64 whatsappBizAcctFbid = 1; +inline bool BizAccountLinkInfo::_internal_has_whatsappbizacctfbid() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool BizAccountLinkInfo::has_whatsappbizacctfbid() const { + return _internal_has_whatsappbizacctfbid(); +} +inline void BizAccountLinkInfo::clear_whatsappbizacctfbid() { + _impl_.whatsappbizacctfbid_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline uint64_t BizAccountLinkInfo::_internal_whatsappbizacctfbid() const { + return _impl_.whatsappbizacctfbid_; +} +inline uint64_t BizAccountLinkInfo::whatsappbizacctfbid() const { + // @@protoc_insertion_point(field_get:proto.BizAccountLinkInfo.whatsappBizAcctFbid) + return _internal_whatsappbizacctfbid(); +} +inline void BizAccountLinkInfo::_internal_set_whatsappbizacctfbid(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.whatsappbizacctfbid_ = value; +} +inline void BizAccountLinkInfo::set_whatsappbizacctfbid(uint64_t value) { + _internal_set_whatsappbizacctfbid(value); + // @@protoc_insertion_point(field_set:proto.BizAccountLinkInfo.whatsappBizAcctFbid) +} + +// optional string whatsappAcctNumber = 2; +inline bool BizAccountLinkInfo::_internal_has_whatsappacctnumber() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool BizAccountLinkInfo::has_whatsappacctnumber() const { + return _internal_has_whatsappacctnumber(); +} +inline void BizAccountLinkInfo::clear_whatsappacctnumber() { + _impl_.whatsappacctnumber_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& BizAccountLinkInfo::whatsappacctnumber() const { + // @@protoc_insertion_point(field_get:proto.BizAccountLinkInfo.whatsappAcctNumber) + return _internal_whatsappacctnumber(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void BizAccountLinkInfo::set_whatsappacctnumber(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.whatsappacctnumber_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.BizAccountLinkInfo.whatsappAcctNumber) +} +inline std::string* BizAccountLinkInfo::mutable_whatsappacctnumber() { + std::string* _s = _internal_mutable_whatsappacctnumber(); + // @@protoc_insertion_point(field_mutable:proto.BizAccountLinkInfo.whatsappAcctNumber) + return _s; +} +inline const std::string& BizAccountLinkInfo::_internal_whatsappacctnumber() const { + return _impl_.whatsappacctnumber_.Get(); +} +inline void BizAccountLinkInfo::_internal_set_whatsappacctnumber(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.whatsappacctnumber_.Set(value, GetArenaForAllocation()); +} +inline std::string* BizAccountLinkInfo::_internal_mutable_whatsappacctnumber() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.whatsappacctnumber_.Mutable(GetArenaForAllocation()); +} +inline std::string* BizAccountLinkInfo::release_whatsappacctnumber() { + // @@protoc_insertion_point(field_release:proto.BizAccountLinkInfo.whatsappAcctNumber) + if (!_internal_has_whatsappacctnumber()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.whatsappacctnumber_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.whatsappacctnumber_.IsDefault()) { + _impl_.whatsappacctnumber_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void BizAccountLinkInfo::set_allocated_whatsappacctnumber(std::string* whatsappacctnumber) { + if (whatsappacctnumber != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.whatsappacctnumber_.SetAllocated(whatsappacctnumber, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.whatsappacctnumber_.IsDefault()) { + _impl_.whatsappacctnumber_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.BizAccountLinkInfo.whatsappAcctNumber) +} + +// optional uint64 issueTime = 3; +inline bool BizAccountLinkInfo::_internal_has_issuetime() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool BizAccountLinkInfo::has_issuetime() const { + return _internal_has_issuetime(); +} +inline void BizAccountLinkInfo::clear_issuetime() { + _impl_.issuetime_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline uint64_t BizAccountLinkInfo::_internal_issuetime() const { + return _impl_.issuetime_; +} +inline uint64_t BizAccountLinkInfo::issuetime() const { + // @@protoc_insertion_point(field_get:proto.BizAccountLinkInfo.issueTime) + return _internal_issuetime(); +} +inline void BizAccountLinkInfo::_internal_set_issuetime(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.issuetime_ = value; +} +inline void BizAccountLinkInfo::set_issuetime(uint64_t value) { + _internal_set_issuetime(value); + // @@protoc_insertion_point(field_set:proto.BizAccountLinkInfo.issueTime) +} + +// optional .proto.BizAccountLinkInfo.HostStorageType hostStorage = 4; +inline bool BizAccountLinkInfo::_internal_has_hoststorage() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool BizAccountLinkInfo::has_hoststorage() const { + return _internal_has_hoststorage(); +} +inline void BizAccountLinkInfo::clear_hoststorage() { + _impl_.hoststorage_ = 0; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline ::proto::BizAccountLinkInfo_HostStorageType BizAccountLinkInfo::_internal_hoststorage() const { + return static_cast< ::proto::BizAccountLinkInfo_HostStorageType >(_impl_.hoststorage_); +} +inline ::proto::BizAccountLinkInfo_HostStorageType BizAccountLinkInfo::hoststorage() const { + // @@protoc_insertion_point(field_get:proto.BizAccountLinkInfo.hostStorage) + return _internal_hoststorage(); +} +inline void BizAccountLinkInfo::_internal_set_hoststorage(::proto::BizAccountLinkInfo_HostStorageType value) { + assert(::proto::BizAccountLinkInfo_HostStorageType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.hoststorage_ = value; +} +inline void BizAccountLinkInfo::set_hoststorage(::proto::BizAccountLinkInfo_HostStorageType value) { + _internal_set_hoststorage(value); + // @@protoc_insertion_point(field_set:proto.BizAccountLinkInfo.hostStorage) +} + +// optional .proto.BizAccountLinkInfo.AccountType accountType = 5; +inline bool BizAccountLinkInfo::_internal_has_accounttype() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool BizAccountLinkInfo::has_accounttype() const { + return _internal_has_accounttype(); +} +inline void BizAccountLinkInfo::clear_accounttype() { + _impl_.accounttype_ = 0; + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline ::proto::BizAccountLinkInfo_AccountType BizAccountLinkInfo::_internal_accounttype() const { + return static_cast< ::proto::BizAccountLinkInfo_AccountType >(_impl_.accounttype_); +} +inline ::proto::BizAccountLinkInfo_AccountType BizAccountLinkInfo::accounttype() const { + // @@protoc_insertion_point(field_get:proto.BizAccountLinkInfo.accountType) + return _internal_accounttype(); +} +inline void BizAccountLinkInfo::_internal_set_accounttype(::proto::BizAccountLinkInfo_AccountType value) { + assert(::proto::BizAccountLinkInfo_AccountType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.accounttype_ = value; +} +inline void BizAccountLinkInfo::set_accounttype(::proto::BizAccountLinkInfo_AccountType value) { + _internal_set_accounttype(value); + // @@protoc_insertion_point(field_set:proto.BizAccountLinkInfo.accountType) +} + +// ------------------------------------------------------------------- + +// BizAccountPayload + +// optional .proto.VerifiedNameCertificate vnameCert = 1; +inline bool BizAccountPayload::_internal_has_vnamecert() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.vnamecert_ != nullptr); + return value; +} +inline bool BizAccountPayload::has_vnamecert() const { + return _internal_has_vnamecert(); +} +inline void BizAccountPayload::clear_vnamecert() { + if (_impl_.vnamecert_ != nullptr) _impl_.vnamecert_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::VerifiedNameCertificate& BizAccountPayload::_internal_vnamecert() const { + const ::proto::VerifiedNameCertificate* p = _impl_.vnamecert_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_VerifiedNameCertificate_default_instance_); +} +inline const ::proto::VerifiedNameCertificate& BizAccountPayload::vnamecert() const { + // @@protoc_insertion_point(field_get:proto.BizAccountPayload.vnameCert) + return _internal_vnamecert(); +} +inline void BizAccountPayload::unsafe_arena_set_allocated_vnamecert( + ::proto::VerifiedNameCertificate* vnamecert) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.vnamecert_); + } + _impl_.vnamecert_ = vnamecert; + if (vnamecert) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.BizAccountPayload.vnameCert) +} +inline ::proto::VerifiedNameCertificate* BizAccountPayload::release_vnamecert() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::VerifiedNameCertificate* temp = _impl_.vnamecert_; + _impl_.vnamecert_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::VerifiedNameCertificate* BizAccountPayload::unsafe_arena_release_vnamecert() { + // @@protoc_insertion_point(field_release:proto.BizAccountPayload.vnameCert) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::VerifiedNameCertificate* temp = _impl_.vnamecert_; + _impl_.vnamecert_ = nullptr; + return temp; +} +inline ::proto::VerifiedNameCertificate* BizAccountPayload::_internal_mutable_vnamecert() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.vnamecert_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::VerifiedNameCertificate>(GetArenaForAllocation()); + _impl_.vnamecert_ = p; + } + return _impl_.vnamecert_; +} +inline ::proto::VerifiedNameCertificate* BizAccountPayload::mutable_vnamecert() { + ::proto::VerifiedNameCertificate* _msg = _internal_mutable_vnamecert(); + // @@protoc_insertion_point(field_mutable:proto.BizAccountPayload.vnameCert) + return _msg; +} +inline void BizAccountPayload::set_allocated_vnamecert(::proto::VerifiedNameCertificate* vnamecert) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.vnamecert_; + } + if (vnamecert) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(vnamecert); + if (message_arena != submessage_arena) { + vnamecert = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, vnamecert, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.vnamecert_ = vnamecert; + // @@protoc_insertion_point(field_set_allocated:proto.BizAccountPayload.vnameCert) +} + +// optional bytes bizAcctLinkInfo = 2; +inline bool BizAccountPayload::_internal_has_bizacctlinkinfo() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool BizAccountPayload::has_bizacctlinkinfo() const { + return _internal_has_bizacctlinkinfo(); +} +inline void BizAccountPayload::clear_bizacctlinkinfo() { + _impl_.bizacctlinkinfo_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& BizAccountPayload::bizacctlinkinfo() const { + // @@protoc_insertion_point(field_get:proto.BizAccountPayload.bizAcctLinkInfo) + return _internal_bizacctlinkinfo(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void BizAccountPayload::set_bizacctlinkinfo(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.bizacctlinkinfo_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.BizAccountPayload.bizAcctLinkInfo) +} +inline std::string* BizAccountPayload::mutable_bizacctlinkinfo() { + std::string* _s = _internal_mutable_bizacctlinkinfo(); + // @@protoc_insertion_point(field_mutable:proto.BizAccountPayload.bizAcctLinkInfo) + return _s; +} +inline const std::string& BizAccountPayload::_internal_bizacctlinkinfo() const { + return _impl_.bizacctlinkinfo_.Get(); +} +inline void BizAccountPayload::_internal_set_bizacctlinkinfo(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.bizacctlinkinfo_.Set(value, GetArenaForAllocation()); +} +inline std::string* BizAccountPayload::_internal_mutable_bizacctlinkinfo() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.bizacctlinkinfo_.Mutable(GetArenaForAllocation()); +} +inline std::string* BizAccountPayload::release_bizacctlinkinfo() { + // @@protoc_insertion_point(field_release:proto.BizAccountPayload.bizAcctLinkInfo) + if (!_internal_has_bizacctlinkinfo()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.bizacctlinkinfo_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.bizacctlinkinfo_.IsDefault()) { + _impl_.bizacctlinkinfo_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void BizAccountPayload::set_allocated_bizacctlinkinfo(std::string* bizacctlinkinfo) { + if (bizacctlinkinfo != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.bizacctlinkinfo_.SetAllocated(bizacctlinkinfo, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.bizacctlinkinfo_.IsDefault()) { + _impl_.bizacctlinkinfo_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.BizAccountPayload.bizAcctLinkInfo) +} + +// ------------------------------------------------------------------- + +// BizIdentityInfo + +// optional .proto.BizIdentityInfo.VerifiedLevelValue vlevel = 1; +inline bool BizIdentityInfo::_internal_has_vlevel() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool BizIdentityInfo::has_vlevel() const { + return _internal_has_vlevel(); +} +inline void BizIdentityInfo::clear_vlevel() { + _impl_.vlevel_ = 0; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline ::proto::BizIdentityInfo_VerifiedLevelValue BizIdentityInfo::_internal_vlevel() const { + return static_cast< ::proto::BizIdentityInfo_VerifiedLevelValue >(_impl_.vlevel_); +} +inline ::proto::BizIdentityInfo_VerifiedLevelValue BizIdentityInfo::vlevel() const { + // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.vlevel) + return _internal_vlevel(); +} +inline void BizIdentityInfo::_internal_set_vlevel(::proto::BizIdentityInfo_VerifiedLevelValue value) { + assert(::proto::BizIdentityInfo_VerifiedLevelValue_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.vlevel_ = value; +} +inline void BizIdentityInfo::set_vlevel(::proto::BizIdentityInfo_VerifiedLevelValue value) { + _internal_set_vlevel(value); + // @@protoc_insertion_point(field_set:proto.BizIdentityInfo.vlevel) +} + +// optional .proto.VerifiedNameCertificate vnameCert = 2; +inline bool BizIdentityInfo::_internal_has_vnamecert() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.vnamecert_ != nullptr); + return value; +} +inline bool BizIdentityInfo::has_vnamecert() const { + return _internal_has_vnamecert(); +} +inline void BizIdentityInfo::clear_vnamecert() { + if (_impl_.vnamecert_ != nullptr) _impl_.vnamecert_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::VerifiedNameCertificate& BizIdentityInfo::_internal_vnamecert() const { + const ::proto::VerifiedNameCertificate* p = _impl_.vnamecert_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_VerifiedNameCertificate_default_instance_); +} +inline const ::proto::VerifiedNameCertificate& BizIdentityInfo::vnamecert() const { + // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.vnameCert) + return _internal_vnamecert(); +} +inline void BizIdentityInfo::unsafe_arena_set_allocated_vnamecert( + ::proto::VerifiedNameCertificate* vnamecert) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.vnamecert_); + } + _impl_.vnamecert_ = vnamecert; + if (vnamecert) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.BizIdentityInfo.vnameCert) +} +inline ::proto::VerifiedNameCertificate* BizIdentityInfo::release_vnamecert() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::VerifiedNameCertificate* temp = _impl_.vnamecert_; + _impl_.vnamecert_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::VerifiedNameCertificate* BizIdentityInfo::unsafe_arena_release_vnamecert() { + // @@protoc_insertion_point(field_release:proto.BizIdentityInfo.vnameCert) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::VerifiedNameCertificate* temp = _impl_.vnamecert_; + _impl_.vnamecert_ = nullptr; + return temp; +} +inline ::proto::VerifiedNameCertificate* BizIdentityInfo::_internal_mutable_vnamecert() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.vnamecert_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::VerifiedNameCertificate>(GetArenaForAllocation()); + _impl_.vnamecert_ = p; + } + return _impl_.vnamecert_; +} +inline ::proto::VerifiedNameCertificate* BizIdentityInfo::mutable_vnamecert() { + ::proto::VerifiedNameCertificate* _msg = _internal_mutable_vnamecert(); + // @@protoc_insertion_point(field_mutable:proto.BizIdentityInfo.vnameCert) + return _msg; +} +inline void BizIdentityInfo::set_allocated_vnamecert(::proto::VerifiedNameCertificate* vnamecert) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.vnamecert_; + } + if (vnamecert) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(vnamecert); + if (message_arena != submessage_arena) { + vnamecert = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, vnamecert, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.vnamecert_ = vnamecert; + // @@protoc_insertion_point(field_set_allocated:proto.BizIdentityInfo.vnameCert) +} + +// optional bool signed = 3; +inline bool BizIdentityInfo::_internal_has_signed_() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool BizIdentityInfo::has_signed_() const { + return _internal_has_signed_(); +} +inline void BizIdentityInfo::clear_signed_() { + _impl_.signed__ = false; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline bool BizIdentityInfo::_internal_signed_() const { + return _impl_.signed__; +} +inline bool BizIdentityInfo::signed_() const { + // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.signed) + return _internal_signed_(); +} +inline void BizIdentityInfo::_internal_set_signed_(bool value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.signed__ = value; +} +inline void BizIdentityInfo::set_signed_(bool value) { + _internal_set_signed_(value); + // @@protoc_insertion_point(field_set:proto.BizIdentityInfo.signed) +} + +// optional bool revoked = 4; +inline bool BizIdentityInfo::_internal_has_revoked() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool BizIdentityInfo::has_revoked() const { + return _internal_has_revoked(); +} +inline void BizIdentityInfo::clear_revoked() { + _impl_.revoked_ = false; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline bool BizIdentityInfo::_internal_revoked() const { + return _impl_.revoked_; +} +inline bool BizIdentityInfo::revoked() const { + // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.revoked) + return _internal_revoked(); +} +inline void BizIdentityInfo::_internal_set_revoked(bool value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.revoked_ = value; +} +inline void BizIdentityInfo::set_revoked(bool value) { + _internal_set_revoked(value); + // @@protoc_insertion_point(field_set:proto.BizIdentityInfo.revoked) +} + +// optional .proto.BizIdentityInfo.HostStorageType hostStorage = 5; +inline bool BizIdentityInfo::_internal_has_hoststorage() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool BizIdentityInfo::has_hoststorage() const { + return _internal_has_hoststorage(); +} +inline void BizIdentityInfo::clear_hoststorage() { + _impl_.hoststorage_ = 0; + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline ::proto::BizIdentityInfo_HostStorageType BizIdentityInfo::_internal_hoststorage() const { + return static_cast< ::proto::BizIdentityInfo_HostStorageType >(_impl_.hoststorage_); +} +inline ::proto::BizIdentityInfo_HostStorageType BizIdentityInfo::hoststorage() const { + // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.hostStorage) + return _internal_hoststorage(); +} +inline void BizIdentityInfo::_internal_set_hoststorage(::proto::BizIdentityInfo_HostStorageType value) { + assert(::proto::BizIdentityInfo_HostStorageType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.hoststorage_ = value; +} +inline void BizIdentityInfo::set_hoststorage(::proto::BizIdentityInfo_HostStorageType value) { + _internal_set_hoststorage(value); + // @@protoc_insertion_point(field_set:proto.BizIdentityInfo.hostStorage) +} + +// optional .proto.BizIdentityInfo.ActualActorsType actualActors = 6; +inline bool BizIdentityInfo::_internal_has_actualactors() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool BizIdentityInfo::has_actualactors() const { + return _internal_has_actualactors(); +} +inline void BizIdentityInfo::clear_actualactors() { + _impl_.actualactors_ = 0; + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline ::proto::BizIdentityInfo_ActualActorsType BizIdentityInfo::_internal_actualactors() const { + return static_cast< ::proto::BizIdentityInfo_ActualActorsType >(_impl_.actualactors_); +} +inline ::proto::BizIdentityInfo_ActualActorsType BizIdentityInfo::actualactors() const { + // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.actualActors) + return _internal_actualactors(); +} +inline void BizIdentityInfo::_internal_set_actualactors(::proto::BizIdentityInfo_ActualActorsType value) { + assert(::proto::BizIdentityInfo_ActualActorsType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.actualactors_ = value; +} +inline void BizIdentityInfo::set_actualactors(::proto::BizIdentityInfo_ActualActorsType value) { + _internal_set_actualactors(value); + // @@protoc_insertion_point(field_set:proto.BizIdentityInfo.actualActors) +} + +// optional uint64 privacyModeTs = 7; +inline bool BizIdentityInfo::_internal_has_privacymodets() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool BizIdentityInfo::has_privacymodets() const { + return _internal_has_privacymodets(); +} +inline void BizIdentityInfo::clear_privacymodets() { + _impl_.privacymodets_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline uint64_t BizIdentityInfo::_internal_privacymodets() const { + return _impl_.privacymodets_; +} +inline uint64_t BizIdentityInfo::privacymodets() const { + // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.privacyModeTs) + return _internal_privacymodets(); +} +inline void BizIdentityInfo::_internal_set_privacymodets(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.privacymodets_ = value; +} +inline void BizIdentityInfo::set_privacymodets(uint64_t value) { + _internal_set_privacymodets(value); + // @@protoc_insertion_point(field_set:proto.BizIdentityInfo.privacyModeTs) +} + +// optional uint64 featureControls = 8; +inline bool BizIdentityInfo::_internal_has_featurecontrols() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool BizIdentityInfo::has_featurecontrols() const { + return _internal_has_featurecontrols(); +} +inline void BizIdentityInfo::clear_featurecontrols() { + _impl_.featurecontrols_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline uint64_t BizIdentityInfo::_internal_featurecontrols() const { + return _impl_.featurecontrols_; +} +inline uint64_t BizIdentityInfo::featurecontrols() const { + // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.featureControls) + return _internal_featurecontrols(); +} +inline void BizIdentityInfo::_internal_set_featurecontrols(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.featurecontrols_ = value; +} +inline void BizIdentityInfo::set_featurecontrols(uint64_t value) { + _internal_set_featurecontrols(value); + // @@protoc_insertion_point(field_set:proto.BizIdentityInfo.featureControls) +} + +// ------------------------------------------------------------------- + +// CertChain_NoiseCertificate_Details + +// optional uint32 serial = 1; +inline bool CertChain_NoiseCertificate_Details::_internal_has_serial() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool CertChain_NoiseCertificate_Details::has_serial() const { + return _internal_has_serial(); +} +inline void CertChain_NoiseCertificate_Details::clear_serial() { + _impl_.serial_ = 0u; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline uint32_t CertChain_NoiseCertificate_Details::_internal_serial() const { + return _impl_.serial_; +} +inline uint32_t CertChain_NoiseCertificate_Details::serial() const { + // @@protoc_insertion_point(field_get:proto.CertChain.NoiseCertificate.Details.serial) + return _internal_serial(); +} +inline void CertChain_NoiseCertificate_Details::_internal_set_serial(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.serial_ = value; +} +inline void CertChain_NoiseCertificate_Details::set_serial(uint32_t value) { + _internal_set_serial(value); + // @@protoc_insertion_point(field_set:proto.CertChain.NoiseCertificate.Details.serial) +} + +// optional uint32 issuerSerial = 2; +inline bool CertChain_NoiseCertificate_Details::_internal_has_issuerserial() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool CertChain_NoiseCertificate_Details::has_issuerserial() const { + return _internal_has_issuerserial(); +} +inline void CertChain_NoiseCertificate_Details::clear_issuerserial() { + _impl_.issuerserial_ = 0u; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline uint32_t CertChain_NoiseCertificate_Details::_internal_issuerserial() const { + return _impl_.issuerserial_; +} +inline uint32_t CertChain_NoiseCertificate_Details::issuerserial() const { + // @@protoc_insertion_point(field_get:proto.CertChain.NoiseCertificate.Details.issuerSerial) + return _internal_issuerserial(); +} +inline void CertChain_NoiseCertificate_Details::_internal_set_issuerserial(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.issuerserial_ = value; +} +inline void CertChain_NoiseCertificate_Details::set_issuerserial(uint32_t value) { + _internal_set_issuerserial(value); + // @@protoc_insertion_point(field_set:proto.CertChain.NoiseCertificate.Details.issuerSerial) +} + +// optional bytes key = 3; +inline bool CertChain_NoiseCertificate_Details::_internal_has_key() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool CertChain_NoiseCertificate_Details::has_key() const { + return _internal_has_key(); +} +inline void CertChain_NoiseCertificate_Details::clear_key() { + _impl_.key_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& CertChain_NoiseCertificate_Details::key() const { + // @@protoc_insertion_point(field_get:proto.CertChain.NoiseCertificate.Details.key) + return _internal_key(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void CertChain_NoiseCertificate_Details::set_key(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.key_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.CertChain.NoiseCertificate.Details.key) +} +inline std::string* CertChain_NoiseCertificate_Details::mutable_key() { + std::string* _s = _internal_mutable_key(); + // @@protoc_insertion_point(field_mutable:proto.CertChain.NoiseCertificate.Details.key) + return _s; +} +inline const std::string& CertChain_NoiseCertificate_Details::_internal_key() const { + return _impl_.key_.Get(); +} +inline void CertChain_NoiseCertificate_Details::_internal_set_key(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.key_.Set(value, GetArenaForAllocation()); +} +inline std::string* CertChain_NoiseCertificate_Details::_internal_mutable_key() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.key_.Mutable(GetArenaForAllocation()); +} +inline std::string* CertChain_NoiseCertificate_Details::release_key() { + // @@protoc_insertion_point(field_release:proto.CertChain.NoiseCertificate.Details.key) + if (!_internal_has_key()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.key_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.key_.IsDefault()) { + _impl_.key_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void CertChain_NoiseCertificate_Details::set_allocated_key(std::string* key) { + if (key != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.key_.SetAllocated(key, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.key_.IsDefault()) { + _impl_.key_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.CertChain.NoiseCertificate.Details.key) +} + +// optional uint64 notBefore = 4; +inline bool CertChain_NoiseCertificate_Details::_internal_has_notbefore() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool CertChain_NoiseCertificate_Details::has_notbefore() const { + return _internal_has_notbefore(); +} +inline void CertChain_NoiseCertificate_Details::clear_notbefore() { + _impl_.notbefore_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline uint64_t CertChain_NoiseCertificate_Details::_internal_notbefore() const { + return _impl_.notbefore_; +} +inline uint64_t CertChain_NoiseCertificate_Details::notbefore() const { + // @@protoc_insertion_point(field_get:proto.CertChain.NoiseCertificate.Details.notBefore) + return _internal_notbefore(); +} +inline void CertChain_NoiseCertificate_Details::_internal_set_notbefore(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.notbefore_ = value; +} +inline void CertChain_NoiseCertificate_Details::set_notbefore(uint64_t value) { + _internal_set_notbefore(value); + // @@protoc_insertion_point(field_set:proto.CertChain.NoiseCertificate.Details.notBefore) +} + +// optional uint64 notAfter = 5; +inline bool CertChain_NoiseCertificate_Details::_internal_has_notafter() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool CertChain_NoiseCertificate_Details::has_notafter() const { + return _internal_has_notafter(); +} +inline void CertChain_NoiseCertificate_Details::clear_notafter() { + _impl_.notafter_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline uint64_t CertChain_NoiseCertificate_Details::_internal_notafter() const { + return _impl_.notafter_; +} +inline uint64_t CertChain_NoiseCertificate_Details::notafter() const { + // @@protoc_insertion_point(field_get:proto.CertChain.NoiseCertificate.Details.notAfter) + return _internal_notafter(); +} +inline void CertChain_NoiseCertificate_Details::_internal_set_notafter(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.notafter_ = value; +} +inline void CertChain_NoiseCertificate_Details::set_notafter(uint64_t value) { + _internal_set_notafter(value); + // @@protoc_insertion_point(field_set:proto.CertChain.NoiseCertificate.Details.notAfter) +} + +// ------------------------------------------------------------------- + +// CertChain_NoiseCertificate + +// optional bytes details = 1; +inline bool CertChain_NoiseCertificate::_internal_has_details() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool CertChain_NoiseCertificate::has_details() const { + return _internal_has_details(); +} +inline void CertChain_NoiseCertificate::clear_details() { + _impl_.details_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& CertChain_NoiseCertificate::details() const { + // @@protoc_insertion_point(field_get:proto.CertChain.NoiseCertificate.details) + return _internal_details(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void CertChain_NoiseCertificate::set_details(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.details_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.CertChain.NoiseCertificate.details) +} +inline std::string* CertChain_NoiseCertificate::mutable_details() { + std::string* _s = _internal_mutable_details(); + // @@protoc_insertion_point(field_mutable:proto.CertChain.NoiseCertificate.details) + return _s; +} +inline const std::string& CertChain_NoiseCertificate::_internal_details() const { + return _impl_.details_.Get(); +} +inline void CertChain_NoiseCertificate::_internal_set_details(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.details_.Set(value, GetArenaForAllocation()); +} +inline std::string* CertChain_NoiseCertificate::_internal_mutable_details() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.details_.Mutable(GetArenaForAllocation()); +} +inline std::string* CertChain_NoiseCertificate::release_details() { + // @@protoc_insertion_point(field_release:proto.CertChain.NoiseCertificate.details) + if (!_internal_has_details()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.details_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.details_.IsDefault()) { + _impl_.details_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void CertChain_NoiseCertificate::set_allocated_details(std::string* details) { + if (details != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.details_.SetAllocated(details, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.details_.IsDefault()) { + _impl_.details_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.CertChain.NoiseCertificate.details) +} + +// optional bytes signature = 2; +inline bool CertChain_NoiseCertificate::_internal_has_signature() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool CertChain_NoiseCertificate::has_signature() const { + return _internal_has_signature(); +} +inline void CertChain_NoiseCertificate::clear_signature() { + _impl_.signature_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& CertChain_NoiseCertificate::signature() const { + // @@protoc_insertion_point(field_get:proto.CertChain.NoiseCertificate.signature) + return _internal_signature(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void CertChain_NoiseCertificate::set_signature(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.signature_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.CertChain.NoiseCertificate.signature) +} +inline std::string* CertChain_NoiseCertificate::mutable_signature() { + std::string* _s = _internal_mutable_signature(); + // @@protoc_insertion_point(field_mutable:proto.CertChain.NoiseCertificate.signature) + return _s; +} +inline const std::string& CertChain_NoiseCertificate::_internal_signature() const { + return _impl_.signature_.Get(); +} +inline void CertChain_NoiseCertificate::_internal_set_signature(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.signature_.Set(value, GetArenaForAllocation()); +} +inline std::string* CertChain_NoiseCertificate::_internal_mutable_signature() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.signature_.Mutable(GetArenaForAllocation()); +} +inline std::string* CertChain_NoiseCertificate::release_signature() { + // @@protoc_insertion_point(field_release:proto.CertChain.NoiseCertificate.signature) + if (!_internal_has_signature()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.signature_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.signature_.IsDefault()) { + _impl_.signature_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void CertChain_NoiseCertificate::set_allocated_signature(std::string* signature) { + if (signature != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.signature_.SetAllocated(signature, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.signature_.IsDefault()) { + _impl_.signature_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.CertChain.NoiseCertificate.signature) +} + +// ------------------------------------------------------------------- + +// CertChain + +// optional .proto.CertChain.NoiseCertificate leaf = 1; +inline bool CertChain::_internal_has_leaf() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.leaf_ != nullptr); + return value; +} +inline bool CertChain::has_leaf() const { + return _internal_has_leaf(); +} +inline void CertChain::clear_leaf() { + if (_impl_.leaf_ != nullptr) _impl_.leaf_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::CertChain_NoiseCertificate& CertChain::_internal_leaf() const { + const ::proto::CertChain_NoiseCertificate* p = _impl_.leaf_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_CertChain_NoiseCertificate_default_instance_); +} +inline const ::proto::CertChain_NoiseCertificate& CertChain::leaf() const { + // @@protoc_insertion_point(field_get:proto.CertChain.leaf) + return _internal_leaf(); +} +inline void CertChain::unsafe_arena_set_allocated_leaf( + ::proto::CertChain_NoiseCertificate* leaf) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.leaf_); + } + _impl_.leaf_ = leaf; + if (leaf) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.CertChain.leaf) +} +inline ::proto::CertChain_NoiseCertificate* CertChain::release_leaf() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::CertChain_NoiseCertificate* temp = _impl_.leaf_; + _impl_.leaf_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::CertChain_NoiseCertificate* CertChain::unsafe_arena_release_leaf() { + // @@protoc_insertion_point(field_release:proto.CertChain.leaf) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::CertChain_NoiseCertificate* temp = _impl_.leaf_; + _impl_.leaf_ = nullptr; + return temp; +} +inline ::proto::CertChain_NoiseCertificate* CertChain::_internal_mutable_leaf() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.leaf_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::CertChain_NoiseCertificate>(GetArenaForAllocation()); + _impl_.leaf_ = p; + } + return _impl_.leaf_; +} +inline ::proto::CertChain_NoiseCertificate* CertChain::mutable_leaf() { + ::proto::CertChain_NoiseCertificate* _msg = _internal_mutable_leaf(); + // @@protoc_insertion_point(field_mutable:proto.CertChain.leaf) + return _msg; +} +inline void CertChain::set_allocated_leaf(::proto::CertChain_NoiseCertificate* leaf) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.leaf_; + } + if (leaf) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(leaf); + if (message_arena != submessage_arena) { + leaf = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, leaf, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.leaf_ = leaf; + // @@protoc_insertion_point(field_set_allocated:proto.CertChain.leaf) +} + +// optional .proto.CertChain.NoiseCertificate intermediate = 2; +inline bool CertChain::_internal_has_intermediate() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.intermediate_ != nullptr); + return value; +} +inline bool CertChain::has_intermediate() const { + return _internal_has_intermediate(); +} +inline void CertChain::clear_intermediate() { + if (_impl_.intermediate_ != nullptr) _impl_.intermediate_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::CertChain_NoiseCertificate& CertChain::_internal_intermediate() const { + const ::proto::CertChain_NoiseCertificate* p = _impl_.intermediate_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_CertChain_NoiseCertificate_default_instance_); +} +inline const ::proto::CertChain_NoiseCertificate& CertChain::intermediate() const { + // @@protoc_insertion_point(field_get:proto.CertChain.intermediate) + return _internal_intermediate(); +} +inline void CertChain::unsafe_arena_set_allocated_intermediate( + ::proto::CertChain_NoiseCertificate* intermediate) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.intermediate_); + } + _impl_.intermediate_ = intermediate; + if (intermediate) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.CertChain.intermediate) +} +inline ::proto::CertChain_NoiseCertificate* CertChain::release_intermediate() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::CertChain_NoiseCertificate* temp = _impl_.intermediate_; + _impl_.intermediate_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::CertChain_NoiseCertificate* CertChain::unsafe_arena_release_intermediate() { + // @@protoc_insertion_point(field_release:proto.CertChain.intermediate) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::CertChain_NoiseCertificate* temp = _impl_.intermediate_; + _impl_.intermediate_ = nullptr; + return temp; +} +inline ::proto::CertChain_NoiseCertificate* CertChain::_internal_mutable_intermediate() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.intermediate_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::CertChain_NoiseCertificate>(GetArenaForAllocation()); + _impl_.intermediate_ = p; + } + return _impl_.intermediate_; +} +inline ::proto::CertChain_NoiseCertificate* CertChain::mutable_intermediate() { + ::proto::CertChain_NoiseCertificate* _msg = _internal_mutable_intermediate(); + // @@protoc_insertion_point(field_mutable:proto.CertChain.intermediate) + return _msg; +} +inline void CertChain::set_allocated_intermediate(::proto::CertChain_NoiseCertificate* intermediate) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.intermediate_; + } + if (intermediate) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(intermediate); + if (message_arena != submessage_arena) { + intermediate = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, intermediate, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.intermediate_ = intermediate; + // @@protoc_insertion_point(field_set_allocated:proto.CertChain.intermediate) +} + +// ------------------------------------------------------------------- + +// Chain + +// optional bytes senderRatchetKey = 1; +inline bool Chain::_internal_has_senderratchetkey() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Chain::has_senderratchetkey() const { + return _internal_has_senderratchetkey(); +} +inline void Chain::clear_senderratchetkey() { + _impl_.senderratchetkey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Chain::senderratchetkey() const { + // @@protoc_insertion_point(field_get:proto.Chain.senderRatchetKey) + return _internal_senderratchetkey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Chain::set_senderratchetkey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.senderratchetkey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Chain.senderRatchetKey) +} +inline std::string* Chain::mutable_senderratchetkey() { + std::string* _s = _internal_mutable_senderratchetkey(); + // @@protoc_insertion_point(field_mutable:proto.Chain.senderRatchetKey) + return _s; +} +inline const std::string& Chain::_internal_senderratchetkey() const { + return _impl_.senderratchetkey_.Get(); +} +inline void Chain::_internal_set_senderratchetkey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.senderratchetkey_.Set(value, GetArenaForAllocation()); +} +inline std::string* Chain::_internal_mutable_senderratchetkey() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.senderratchetkey_.Mutable(GetArenaForAllocation()); +} +inline std::string* Chain::release_senderratchetkey() { + // @@protoc_insertion_point(field_release:proto.Chain.senderRatchetKey) + if (!_internal_has_senderratchetkey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.senderratchetkey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.senderratchetkey_.IsDefault()) { + _impl_.senderratchetkey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Chain::set_allocated_senderratchetkey(std::string* senderratchetkey) { + if (senderratchetkey != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.senderratchetkey_.SetAllocated(senderratchetkey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.senderratchetkey_.IsDefault()) { + _impl_.senderratchetkey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Chain.senderRatchetKey) +} + +// optional bytes senderRatchetKeyPrivate = 2; +inline bool Chain::_internal_has_senderratchetkeyprivate() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Chain::has_senderratchetkeyprivate() const { + return _internal_has_senderratchetkeyprivate(); +} +inline void Chain::clear_senderratchetkeyprivate() { + _impl_.senderratchetkeyprivate_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Chain::senderratchetkeyprivate() const { + // @@protoc_insertion_point(field_get:proto.Chain.senderRatchetKeyPrivate) + return _internal_senderratchetkeyprivate(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Chain::set_senderratchetkeyprivate(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.senderratchetkeyprivate_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Chain.senderRatchetKeyPrivate) +} +inline std::string* Chain::mutable_senderratchetkeyprivate() { + std::string* _s = _internal_mutable_senderratchetkeyprivate(); + // @@protoc_insertion_point(field_mutable:proto.Chain.senderRatchetKeyPrivate) + return _s; +} +inline const std::string& Chain::_internal_senderratchetkeyprivate() const { + return _impl_.senderratchetkeyprivate_.Get(); +} +inline void Chain::_internal_set_senderratchetkeyprivate(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.senderratchetkeyprivate_.Set(value, GetArenaForAllocation()); +} +inline std::string* Chain::_internal_mutable_senderratchetkeyprivate() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.senderratchetkeyprivate_.Mutable(GetArenaForAllocation()); +} +inline std::string* Chain::release_senderratchetkeyprivate() { + // @@protoc_insertion_point(field_release:proto.Chain.senderRatchetKeyPrivate) + if (!_internal_has_senderratchetkeyprivate()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.senderratchetkeyprivate_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.senderratchetkeyprivate_.IsDefault()) { + _impl_.senderratchetkeyprivate_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Chain::set_allocated_senderratchetkeyprivate(std::string* senderratchetkeyprivate) { + if (senderratchetkeyprivate != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.senderratchetkeyprivate_.SetAllocated(senderratchetkeyprivate, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.senderratchetkeyprivate_.IsDefault()) { + _impl_.senderratchetkeyprivate_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Chain.senderRatchetKeyPrivate) +} + +// optional .proto.ChainKey chainKey = 3; +inline bool Chain::_internal_has_chainkey() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.chainkey_ != nullptr); + return value; +} +inline bool Chain::has_chainkey() const { + return _internal_has_chainkey(); +} +inline void Chain::clear_chainkey() { + if (_impl_.chainkey_ != nullptr) _impl_.chainkey_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::proto::ChainKey& Chain::_internal_chainkey() const { + const ::proto::ChainKey* p = _impl_.chainkey_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ChainKey_default_instance_); +} +inline const ::proto::ChainKey& Chain::chainkey() const { + // @@protoc_insertion_point(field_get:proto.Chain.chainKey) + return _internal_chainkey(); +} +inline void Chain::unsafe_arena_set_allocated_chainkey( + ::proto::ChainKey* chainkey) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.chainkey_); + } + _impl_.chainkey_ = chainkey; + if (chainkey) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Chain.chainKey) +} +inline ::proto::ChainKey* Chain::release_chainkey() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::ChainKey* temp = _impl_.chainkey_; + _impl_.chainkey_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ChainKey* Chain::unsafe_arena_release_chainkey() { + // @@protoc_insertion_point(field_release:proto.Chain.chainKey) + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::ChainKey* temp = _impl_.chainkey_; + _impl_.chainkey_ = nullptr; + return temp; +} +inline ::proto::ChainKey* Chain::_internal_mutable_chainkey() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.chainkey_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ChainKey>(GetArenaForAllocation()); + _impl_.chainkey_ = p; + } + return _impl_.chainkey_; +} +inline ::proto::ChainKey* Chain::mutable_chainkey() { + ::proto::ChainKey* _msg = _internal_mutable_chainkey(); + // @@protoc_insertion_point(field_mutable:proto.Chain.chainKey) + return _msg; +} +inline void Chain::set_allocated_chainkey(::proto::ChainKey* chainkey) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.chainkey_; + } + if (chainkey) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(chainkey); + if (message_arena != submessage_arena) { + chainkey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, chainkey, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.chainkey_ = chainkey; + // @@protoc_insertion_point(field_set_allocated:proto.Chain.chainKey) +} + +// repeated .proto.MessageKey messageKeys = 4; +inline int Chain::_internal_messagekeys_size() const { + return _impl_.messagekeys_.size(); +} +inline int Chain::messagekeys_size() const { + return _internal_messagekeys_size(); +} +inline void Chain::clear_messagekeys() { + _impl_.messagekeys_.Clear(); +} +inline ::proto::MessageKey* Chain::mutable_messagekeys(int index) { + // @@protoc_insertion_point(field_mutable:proto.Chain.messageKeys) + return _impl_.messagekeys_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MessageKey >* +Chain::mutable_messagekeys() { + // @@protoc_insertion_point(field_mutable_list:proto.Chain.messageKeys) + return &_impl_.messagekeys_; +} +inline const ::proto::MessageKey& Chain::_internal_messagekeys(int index) const { + return _impl_.messagekeys_.Get(index); +} +inline const ::proto::MessageKey& Chain::messagekeys(int index) const { + // @@protoc_insertion_point(field_get:proto.Chain.messageKeys) + return _internal_messagekeys(index); +} +inline ::proto::MessageKey* Chain::_internal_add_messagekeys() { + return _impl_.messagekeys_.Add(); +} +inline ::proto::MessageKey* Chain::add_messagekeys() { + ::proto::MessageKey* _add = _internal_add_messagekeys(); + // @@protoc_insertion_point(field_add:proto.Chain.messageKeys) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MessageKey >& +Chain::messagekeys() const { + // @@protoc_insertion_point(field_list:proto.Chain.messageKeys) + return _impl_.messagekeys_; +} + +// ------------------------------------------------------------------- + +// ChainKey + +// optional uint32 index = 1; +inline bool ChainKey::_internal_has_index() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ChainKey::has_index() const { + return _internal_has_index(); +} +inline void ChainKey::clear_index() { + _impl_.index_ = 0u; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline uint32_t ChainKey::_internal_index() const { + return _impl_.index_; +} +inline uint32_t ChainKey::index() const { + // @@protoc_insertion_point(field_get:proto.ChainKey.index) + return _internal_index(); +} +inline void ChainKey::_internal_set_index(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.index_ = value; +} +inline void ChainKey::set_index(uint32_t value) { + _internal_set_index(value); + // @@protoc_insertion_point(field_set:proto.ChainKey.index) +} + +// optional bytes key = 2; +inline bool ChainKey::_internal_has_key() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ChainKey::has_key() const { + return _internal_has_key(); +} +inline void ChainKey::clear_key() { + _impl_.key_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ChainKey::key() const { + // @@protoc_insertion_point(field_get:proto.ChainKey.key) + return _internal_key(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ChainKey::set_key(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.key_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ChainKey.key) +} +inline std::string* ChainKey::mutable_key() { + std::string* _s = _internal_mutable_key(); + // @@protoc_insertion_point(field_mutable:proto.ChainKey.key) + return _s; +} +inline const std::string& ChainKey::_internal_key() const { + return _impl_.key_.Get(); +} +inline void ChainKey::_internal_set_key(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.key_.Set(value, GetArenaForAllocation()); +} +inline std::string* ChainKey::_internal_mutable_key() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.key_.Mutable(GetArenaForAllocation()); +} +inline std::string* ChainKey::release_key() { + // @@protoc_insertion_point(field_release:proto.ChainKey.key) + if (!_internal_has_key()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.key_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.key_.IsDefault()) { + _impl_.key_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ChainKey::set_allocated_key(std::string* key) { + if (key != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.key_.SetAllocated(key, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.key_.IsDefault()) { + _impl_.key_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ChainKey.key) +} + +// ------------------------------------------------------------------- + +// ClientPayload_DNSSource + +// optional .proto.ClientPayload.DNSSource.DNSResolutionMethod dnsMethod = 15; +inline bool ClientPayload_DNSSource::_internal_has_dnsmethod() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ClientPayload_DNSSource::has_dnsmethod() const { + return _internal_has_dnsmethod(); +} +inline void ClientPayload_DNSSource::clear_dnsmethod() { + _impl_.dnsmethod_ = 0; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline ::proto::ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource::_internal_dnsmethod() const { + return static_cast< ::proto::ClientPayload_DNSSource_DNSResolutionMethod >(_impl_.dnsmethod_); +} +inline ::proto::ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource::dnsmethod() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.DNSSource.dnsMethod) + return _internal_dnsmethod(); +} +inline void ClientPayload_DNSSource::_internal_set_dnsmethod(::proto::ClientPayload_DNSSource_DNSResolutionMethod value) { + assert(::proto::ClientPayload_DNSSource_DNSResolutionMethod_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.dnsmethod_ = value; +} +inline void ClientPayload_DNSSource::set_dnsmethod(::proto::ClientPayload_DNSSource_DNSResolutionMethod value) { + _internal_set_dnsmethod(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.DNSSource.dnsMethod) +} + +// optional bool appCached = 16; +inline bool ClientPayload_DNSSource::_internal_has_appcached() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ClientPayload_DNSSource::has_appcached() const { + return _internal_has_appcached(); +} +inline void ClientPayload_DNSSource::clear_appcached() { + _impl_.appcached_ = false; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline bool ClientPayload_DNSSource::_internal_appcached() const { + return _impl_.appcached_; +} +inline bool ClientPayload_DNSSource::appcached() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.DNSSource.appCached) + return _internal_appcached(); +} +inline void ClientPayload_DNSSource::_internal_set_appcached(bool value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.appcached_ = value; +} +inline void ClientPayload_DNSSource::set_appcached(bool value) { + _internal_set_appcached(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.DNSSource.appCached) +} + +// ------------------------------------------------------------------- + +// ClientPayload_DevicePairingRegistrationData + +// optional bytes eRegid = 1; +inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_eregid() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ClientPayload_DevicePairingRegistrationData::has_eregid() const { + return _internal_has_eregid(); +} +inline void ClientPayload_DevicePairingRegistrationData::clear_eregid() { + _impl_.eregid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ClientPayload_DevicePairingRegistrationData::eregid() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.eRegid) + return _internal_eregid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ClientPayload_DevicePairingRegistrationData::set_eregid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.eregid_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.eRegid) +} +inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_eregid() { + std::string* _s = _internal_mutable_eregid(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.eRegid) + return _s; +} +inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_eregid() const { + return _impl_.eregid_.Get(); +} +inline void ClientPayload_DevicePairingRegistrationData::_internal_set_eregid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.eregid_.Set(value, GetArenaForAllocation()); +} +inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_eregid() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.eregid_.Mutable(GetArenaForAllocation()); +} +inline std::string* ClientPayload_DevicePairingRegistrationData::release_eregid() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.eRegid) + if (!_internal_has_eregid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.eregid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.eregid_.IsDefault()) { + _impl_.eregid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ClientPayload_DevicePairingRegistrationData::set_allocated_eregid(std::string* eregid) { + if (eregid != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.eregid_.SetAllocated(eregid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.eregid_.IsDefault()) { + _impl_.eregid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.eRegid) +} + +// optional bytes eKeytype = 2; +inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_ekeytype() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ClientPayload_DevicePairingRegistrationData::has_ekeytype() const { + return _internal_has_ekeytype(); +} +inline void ClientPayload_DevicePairingRegistrationData::clear_ekeytype() { + _impl_.ekeytype_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& ClientPayload_DevicePairingRegistrationData::ekeytype() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.eKeytype) + return _internal_ekeytype(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ClientPayload_DevicePairingRegistrationData::set_ekeytype(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.ekeytype_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.eKeytype) +} +inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_ekeytype() { + std::string* _s = _internal_mutable_ekeytype(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.eKeytype) + return _s; +} +inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_ekeytype() const { + return _impl_.ekeytype_.Get(); +} +inline void ClientPayload_DevicePairingRegistrationData::_internal_set_ekeytype(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.ekeytype_.Set(value, GetArenaForAllocation()); +} +inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_ekeytype() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.ekeytype_.Mutable(GetArenaForAllocation()); +} +inline std::string* ClientPayload_DevicePairingRegistrationData::release_ekeytype() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.eKeytype) + if (!_internal_has_ekeytype()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.ekeytype_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.ekeytype_.IsDefault()) { + _impl_.ekeytype_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ClientPayload_DevicePairingRegistrationData::set_allocated_ekeytype(std::string* ekeytype) { + if (ekeytype != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.ekeytype_.SetAllocated(ekeytype, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.ekeytype_.IsDefault()) { + _impl_.ekeytype_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.eKeytype) +} + +// optional bytes eIdent = 3; +inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_eident() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ClientPayload_DevicePairingRegistrationData::has_eident() const { + return _internal_has_eident(); +} +inline void ClientPayload_DevicePairingRegistrationData::clear_eident() { + _impl_.eident_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& ClientPayload_DevicePairingRegistrationData::eident() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.eIdent) + return _internal_eident(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ClientPayload_DevicePairingRegistrationData::set_eident(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.eident_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.eIdent) +} +inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_eident() { + std::string* _s = _internal_mutable_eident(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.eIdent) + return _s; +} +inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_eident() const { + return _impl_.eident_.Get(); +} +inline void ClientPayload_DevicePairingRegistrationData::_internal_set_eident(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.eident_.Set(value, GetArenaForAllocation()); +} +inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_eident() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.eident_.Mutable(GetArenaForAllocation()); +} +inline std::string* ClientPayload_DevicePairingRegistrationData::release_eident() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.eIdent) + if (!_internal_has_eident()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.eident_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.eident_.IsDefault()) { + _impl_.eident_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ClientPayload_DevicePairingRegistrationData::set_allocated_eident(std::string* eident) { + if (eident != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.eident_.SetAllocated(eident, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.eident_.IsDefault()) { + _impl_.eident_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.eIdent) +} + +// optional bytes eSkeyId = 4; +inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_eskeyid() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ClientPayload_DevicePairingRegistrationData::has_eskeyid() const { + return _internal_has_eskeyid(); +} +inline void ClientPayload_DevicePairingRegistrationData::clear_eskeyid() { + _impl_.eskeyid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const std::string& ClientPayload_DevicePairingRegistrationData::eskeyid() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.eSkeyId) + return _internal_eskeyid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ClientPayload_DevicePairingRegistrationData::set_eskeyid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.eskeyid_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.eSkeyId) +} +inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_eskeyid() { + std::string* _s = _internal_mutable_eskeyid(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.eSkeyId) + return _s; +} +inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_eskeyid() const { + return _impl_.eskeyid_.Get(); +} +inline void ClientPayload_DevicePairingRegistrationData::_internal_set_eskeyid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.eskeyid_.Set(value, GetArenaForAllocation()); +} +inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_eskeyid() { + _impl_._has_bits_[0] |= 0x00000008u; + return _impl_.eskeyid_.Mutable(GetArenaForAllocation()); +} +inline std::string* ClientPayload_DevicePairingRegistrationData::release_eskeyid() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.eSkeyId) + if (!_internal_has_eskeyid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000008u; + auto* p = _impl_.eskeyid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.eskeyid_.IsDefault()) { + _impl_.eskeyid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ClientPayload_DevicePairingRegistrationData::set_allocated_eskeyid(std::string* eskeyid) { + if (eskeyid != nullptr) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.eskeyid_.SetAllocated(eskeyid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.eskeyid_.IsDefault()) { + _impl_.eskeyid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.eSkeyId) +} + +// optional bytes eSkeyVal = 5; +inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_eskeyval() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool ClientPayload_DevicePairingRegistrationData::has_eskeyval() const { + return _internal_has_eskeyval(); +} +inline void ClientPayload_DevicePairingRegistrationData::clear_eskeyval() { + _impl_.eskeyval_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const std::string& ClientPayload_DevicePairingRegistrationData::eskeyval() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.eSkeyVal) + return _internal_eskeyval(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ClientPayload_DevicePairingRegistrationData::set_eskeyval(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.eskeyval_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.eSkeyVal) +} +inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_eskeyval() { + std::string* _s = _internal_mutable_eskeyval(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.eSkeyVal) + return _s; +} +inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_eskeyval() const { + return _impl_.eskeyval_.Get(); +} +inline void ClientPayload_DevicePairingRegistrationData::_internal_set_eskeyval(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.eskeyval_.Set(value, GetArenaForAllocation()); +} +inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_eskeyval() { + _impl_._has_bits_[0] |= 0x00000010u; + return _impl_.eskeyval_.Mutable(GetArenaForAllocation()); +} +inline std::string* ClientPayload_DevicePairingRegistrationData::release_eskeyval() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.eSkeyVal) + if (!_internal_has_eskeyval()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000010u; + auto* p = _impl_.eskeyval_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.eskeyval_.IsDefault()) { + _impl_.eskeyval_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ClientPayload_DevicePairingRegistrationData::set_allocated_eskeyval(std::string* eskeyval) { + if (eskeyval != nullptr) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.eskeyval_.SetAllocated(eskeyval, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.eskeyval_.IsDefault()) { + _impl_.eskeyval_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.eSkeyVal) +} + +// optional bytes eSkeySig = 6; +inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_eskeysig() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool ClientPayload_DevicePairingRegistrationData::has_eskeysig() const { + return _internal_has_eskeysig(); +} +inline void ClientPayload_DevicePairingRegistrationData::clear_eskeysig() { + _impl_.eskeysig_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline const std::string& ClientPayload_DevicePairingRegistrationData::eskeysig() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.eSkeySig) + return _internal_eskeysig(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ClientPayload_DevicePairingRegistrationData::set_eskeysig(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.eskeysig_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.eSkeySig) +} +inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_eskeysig() { + std::string* _s = _internal_mutable_eskeysig(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.eSkeySig) + return _s; +} +inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_eskeysig() const { + return _impl_.eskeysig_.Get(); +} +inline void ClientPayload_DevicePairingRegistrationData::_internal_set_eskeysig(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.eskeysig_.Set(value, GetArenaForAllocation()); +} +inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_eskeysig() { + _impl_._has_bits_[0] |= 0x00000020u; + return _impl_.eskeysig_.Mutable(GetArenaForAllocation()); +} +inline std::string* ClientPayload_DevicePairingRegistrationData::release_eskeysig() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.eSkeySig) + if (!_internal_has_eskeysig()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000020u; + auto* p = _impl_.eskeysig_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.eskeysig_.IsDefault()) { + _impl_.eskeysig_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ClientPayload_DevicePairingRegistrationData::set_allocated_eskeysig(std::string* eskeysig) { + if (eskeysig != nullptr) { + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + _impl_.eskeysig_.SetAllocated(eskeysig, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.eskeysig_.IsDefault()) { + _impl_.eskeysig_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.eSkeySig) +} + +// optional bytes buildHash = 7; +inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_buildhash() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool ClientPayload_DevicePairingRegistrationData::has_buildhash() const { + return _internal_has_buildhash(); +} +inline void ClientPayload_DevicePairingRegistrationData::clear_buildhash() { + _impl_.buildhash_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline const std::string& ClientPayload_DevicePairingRegistrationData::buildhash() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.buildHash) + return _internal_buildhash(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ClientPayload_DevicePairingRegistrationData::set_buildhash(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.buildhash_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.buildHash) +} +inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_buildhash() { + std::string* _s = _internal_mutable_buildhash(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.buildHash) + return _s; +} +inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_buildhash() const { + return _impl_.buildhash_.Get(); +} +inline void ClientPayload_DevicePairingRegistrationData::_internal_set_buildhash(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.buildhash_.Set(value, GetArenaForAllocation()); +} +inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_buildhash() { + _impl_._has_bits_[0] |= 0x00000040u; + return _impl_.buildhash_.Mutable(GetArenaForAllocation()); +} +inline std::string* ClientPayload_DevicePairingRegistrationData::release_buildhash() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.buildHash) + if (!_internal_has_buildhash()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000040u; + auto* p = _impl_.buildhash_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.buildhash_.IsDefault()) { + _impl_.buildhash_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ClientPayload_DevicePairingRegistrationData::set_allocated_buildhash(std::string* buildhash) { + if (buildhash != nullptr) { + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + _impl_.buildhash_.SetAllocated(buildhash, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.buildhash_.IsDefault()) { + _impl_.buildhash_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.buildHash) +} + +// optional bytes deviceProps = 8; +inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_deviceprops() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool ClientPayload_DevicePairingRegistrationData::has_deviceprops() const { + return _internal_has_deviceprops(); +} +inline void ClientPayload_DevicePairingRegistrationData::clear_deviceprops() { + _impl_.deviceprops_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline const std::string& ClientPayload_DevicePairingRegistrationData::deviceprops() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.deviceProps) + return _internal_deviceprops(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ClientPayload_DevicePairingRegistrationData::set_deviceprops(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.deviceprops_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.deviceProps) +} +inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_deviceprops() { + std::string* _s = _internal_mutable_deviceprops(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.deviceProps) + return _s; +} +inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_deviceprops() const { + return _impl_.deviceprops_.Get(); +} +inline void ClientPayload_DevicePairingRegistrationData::_internal_set_deviceprops(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.deviceprops_.Set(value, GetArenaForAllocation()); +} +inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_deviceprops() { + _impl_._has_bits_[0] |= 0x00000080u; + return _impl_.deviceprops_.Mutable(GetArenaForAllocation()); +} +inline std::string* ClientPayload_DevicePairingRegistrationData::release_deviceprops() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.deviceProps) + if (!_internal_has_deviceprops()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000080u; + auto* p = _impl_.deviceprops_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.deviceprops_.IsDefault()) { + _impl_.deviceprops_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ClientPayload_DevicePairingRegistrationData::set_allocated_deviceprops(std::string* deviceprops) { + if (deviceprops != nullptr) { + _impl_._has_bits_[0] |= 0x00000080u; + } else { + _impl_._has_bits_[0] &= ~0x00000080u; + } + _impl_.deviceprops_.SetAllocated(deviceprops, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.deviceprops_.IsDefault()) { + _impl_.deviceprops_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.deviceProps) +} + +// ------------------------------------------------------------------- + +// ClientPayload_UserAgent_AppVersion + +// optional uint32 primary = 1; +inline bool ClientPayload_UserAgent_AppVersion::_internal_has_primary() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ClientPayload_UserAgent_AppVersion::has_primary() const { + return _internal_has_primary(); +} +inline void ClientPayload_UserAgent_AppVersion::clear_primary() { + _impl_.primary_ = 0u; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline uint32_t ClientPayload_UserAgent_AppVersion::_internal_primary() const { + return _impl_.primary_; +} +inline uint32_t ClientPayload_UserAgent_AppVersion::primary() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.AppVersion.primary) + return _internal_primary(); +} +inline void ClientPayload_UserAgent_AppVersion::_internal_set_primary(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.primary_ = value; +} +inline void ClientPayload_UserAgent_AppVersion::set_primary(uint32_t value) { + _internal_set_primary(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.AppVersion.primary) +} + +// optional uint32 secondary = 2; +inline bool ClientPayload_UserAgent_AppVersion::_internal_has_secondary() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ClientPayload_UserAgent_AppVersion::has_secondary() const { + return _internal_has_secondary(); +} +inline void ClientPayload_UserAgent_AppVersion::clear_secondary() { + _impl_.secondary_ = 0u; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline uint32_t ClientPayload_UserAgent_AppVersion::_internal_secondary() const { + return _impl_.secondary_; +} +inline uint32_t ClientPayload_UserAgent_AppVersion::secondary() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.AppVersion.secondary) + return _internal_secondary(); +} +inline void ClientPayload_UserAgent_AppVersion::_internal_set_secondary(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.secondary_ = value; +} +inline void ClientPayload_UserAgent_AppVersion::set_secondary(uint32_t value) { + _internal_set_secondary(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.AppVersion.secondary) +} + +// optional uint32 tertiary = 3; +inline bool ClientPayload_UserAgent_AppVersion::_internal_has_tertiary() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ClientPayload_UserAgent_AppVersion::has_tertiary() const { + return _internal_has_tertiary(); +} +inline void ClientPayload_UserAgent_AppVersion::clear_tertiary() { + _impl_.tertiary_ = 0u; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline uint32_t ClientPayload_UserAgent_AppVersion::_internal_tertiary() const { + return _impl_.tertiary_; +} +inline uint32_t ClientPayload_UserAgent_AppVersion::tertiary() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.AppVersion.tertiary) + return _internal_tertiary(); +} +inline void ClientPayload_UserAgent_AppVersion::_internal_set_tertiary(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.tertiary_ = value; +} +inline void ClientPayload_UserAgent_AppVersion::set_tertiary(uint32_t value) { + _internal_set_tertiary(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.AppVersion.tertiary) +} + +// optional uint32 quaternary = 4; +inline bool ClientPayload_UserAgent_AppVersion::_internal_has_quaternary() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ClientPayload_UserAgent_AppVersion::has_quaternary() const { + return _internal_has_quaternary(); +} +inline void ClientPayload_UserAgent_AppVersion::clear_quaternary() { + _impl_.quaternary_ = 0u; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline uint32_t ClientPayload_UserAgent_AppVersion::_internal_quaternary() const { + return _impl_.quaternary_; +} +inline uint32_t ClientPayload_UserAgent_AppVersion::quaternary() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.AppVersion.quaternary) + return _internal_quaternary(); +} +inline void ClientPayload_UserAgent_AppVersion::_internal_set_quaternary(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.quaternary_ = value; +} +inline void ClientPayload_UserAgent_AppVersion::set_quaternary(uint32_t value) { + _internal_set_quaternary(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.AppVersion.quaternary) +} + +// optional uint32 quinary = 5; +inline bool ClientPayload_UserAgent_AppVersion::_internal_has_quinary() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool ClientPayload_UserAgent_AppVersion::has_quinary() const { + return _internal_has_quinary(); +} +inline void ClientPayload_UserAgent_AppVersion::clear_quinary() { + _impl_.quinary_ = 0u; + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline uint32_t ClientPayload_UserAgent_AppVersion::_internal_quinary() const { + return _impl_.quinary_; +} +inline uint32_t ClientPayload_UserAgent_AppVersion::quinary() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.AppVersion.quinary) + return _internal_quinary(); +} +inline void ClientPayload_UserAgent_AppVersion::_internal_set_quinary(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.quinary_ = value; +} +inline void ClientPayload_UserAgent_AppVersion::set_quinary(uint32_t value) { + _internal_set_quinary(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.AppVersion.quinary) +} + +// ------------------------------------------------------------------- + +// ClientPayload_UserAgent + +// optional .proto.ClientPayload.UserAgent.Platform platform = 1; +inline bool ClientPayload_UserAgent::_internal_has_platform() const { + bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; + return value; +} +inline bool ClientPayload_UserAgent::has_platform() const { + return _internal_has_platform(); +} +inline void ClientPayload_UserAgent::clear_platform() { + _impl_.platform_ = 0; + _impl_._has_bits_[0] &= ~0x00000800u; +} +inline ::proto::ClientPayload_UserAgent_Platform ClientPayload_UserAgent::_internal_platform() const { + return static_cast< ::proto::ClientPayload_UserAgent_Platform >(_impl_.platform_); +} +inline ::proto::ClientPayload_UserAgent_Platform ClientPayload_UserAgent::platform() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.platform) + return _internal_platform(); +} +inline void ClientPayload_UserAgent::_internal_set_platform(::proto::ClientPayload_UserAgent_Platform value) { + assert(::proto::ClientPayload_UserAgent_Platform_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000800u; + _impl_.platform_ = value; +} +inline void ClientPayload_UserAgent::set_platform(::proto::ClientPayload_UserAgent_Platform value) { + _internal_set_platform(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.platform) +} + +// optional .proto.ClientPayload.UserAgent.AppVersion appVersion = 2; +inline bool ClientPayload_UserAgent::_internal_has_appversion() const { + bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; + PROTOBUF_ASSUME(!value || _impl_.appversion_ != nullptr); + return value; +} +inline bool ClientPayload_UserAgent::has_appversion() const { + return _internal_has_appversion(); +} +inline void ClientPayload_UserAgent::clear_appversion() { + if (_impl_.appversion_ != nullptr) _impl_.appversion_->Clear(); + _impl_._has_bits_[0] &= ~0x00000400u; +} +inline const ::proto::ClientPayload_UserAgent_AppVersion& ClientPayload_UserAgent::_internal_appversion() const { + const ::proto::ClientPayload_UserAgent_AppVersion* p = _impl_.appversion_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ClientPayload_UserAgent_AppVersion_default_instance_); +} +inline const ::proto::ClientPayload_UserAgent_AppVersion& ClientPayload_UserAgent::appversion() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.appVersion) + return _internal_appversion(); +} +inline void ClientPayload_UserAgent::unsafe_arena_set_allocated_appversion( + ::proto::ClientPayload_UserAgent_AppVersion* appversion) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.appversion_); + } + _impl_.appversion_ = appversion; + if (appversion) { + _impl_._has_bits_[0] |= 0x00000400u; + } else { + _impl_._has_bits_[0] &= ~0x00000400u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ClientPayload.UserAgent.appVersion) +} +inline ::proto::ClientPayload_UserAgent_AppVersion* ClientPayload_UserAgent::release_appversion() { + _impl_._has_bits_[0] &= ~0x00000400u; + ::proto::ClientPayload_UserAgent_AppVersion* temp = _impl_.appversion_; + _impl_.appversion_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ClientPayload_UserAgent_AppVersion* ClientPayload_UserAgent::unsafe_arena_release_appversion() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.appVersion) + _impl_._has_bits_[0] &= ~0x00000400u; + ::proto::ClientPayload_UserAgent_AppVersion* temp = _impl_.appversion_; + _impl_.appversion_ = nullptr; + return temp; +} +inline ::proto::ClientPayload_UserAgent_AppVersion* ClientPayload_UserAgent::_internal_mutable_appversion() { + _impl_._has_bits_[0] |= 0x00000400u; + if (_impl_.appversion_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ClientPayload_UserAgent_AppVersion>(GetArenaForAllocation()); + _impl_.appversion_ = p; + } + return _impl_.appversion_; +} +inline ::proto::ClientPayload_UserAgent_AppVersion* ClientPayload_UserAgent::mutable_appversion() { + ::proto::ClientPayload_UserAgent_AppVersion* _msg = _internal_mutable_appversion(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.appVersion) + return _msg; +} +inline void ClientPayload_UserAgent::set_allocated_appversion(::proto::ClientPayload_UserAgent_AppVersion* appversion) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.appversion_; + } + if (appversion) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(appversion); + if (message_arena != submessage_arena) { + appversion = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, appversion, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000400u; + } else { + _impl_._has_bits_[0] &= ~0x00000400u; + } + _impl_.appversion_ = appversion; + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.appVersion) +} + +// optional string mcc = 3; +inline bool ClientPayload_UserAgent::_internal_has_mcc() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ClientPayload_UserAgent::has_mcc() const { + return _internal_has_mcc(); +} +inline void ClientPayload_UserAgent::clear_mcc() { + _impl_.mcc_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ClientPayload_UserAgent::mcc() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.mcc) + return _internal_mcc(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ClientPayload_UserAgent::set_mcc(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.mcc_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.mcc) +} +inline std::string* ClientPayload_UserAgent::mutable_mcc() { + std::string* _s = _internal_mutable_mcc(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.mcc) + return _s; +} +inline const std::string& ClientPayload_UserAgent::_internal_mcc() const { + return _impl_.mcc_.Get(); +} +inline void ClientPayload_UserAgent::_internal_set_mcc(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.mcc_.Set(value, GetArenaForAllocation()); +} +inline std::string* ClientPayload_UserAgent::_internal_mutable_mcc() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.mcc_.Mutable(GetArenaForAllocation()); +} +inline std::string* ClientPayload_UserAgent::release_mcc() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.mcc) + if (!_internal_has_mcc()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.mcc_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mcc_.IsDefault()) { + _impl_.mcc_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ClientPayload_UserAgent::set_allocated_mcc(std::string* mcc) { + if (mcc != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.mcc_.SetAllocated(mcc, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mcc_.IsDefault()) { + _impl_.mcc_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.mcc) +} + +// optional string mnc = 4; +inline bool ClientPayload_UserAgent::_internal_has_mnc() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ClientPayload_UserAgent::has_mnc() const { + return _internal_has_mnc(); +} +inline void ClientPayload_UserAgent::clear_mnc() { + _impl_.mnc_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& ClientPayload_UserAgent::mnc() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.mnc) + return _internal_mnc(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ClientPayload_UserAgent::set_mnc(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.mnc_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.mnc) +} +inline std::string* ClientPayload_UserAgent::mutable_mnc() { + std::string* _s = _internal_mutable_mnc(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.mnc) + return _s; +} +inline const std::string& ClientPayload_UserAgent::_internal_mnc() const { + return _impl_.mnc_.Get(); +} +inline void ClientPayload_UserAgent::_internal_set_mnc(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.mnc_.Set(value, GetArenaForAllocation()); +} +inline std::string* ClientPayload_UserAgent::_internal_mutable_mnc() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.mnc_.Mutable(GetArenaForAllocation()); +} +inline std::string* ClientPayload_UserAgent::release_mnc() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.mnc) + if (!_internal_has_mnc()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.mnc_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mnc_.IsDefault()) { + _impl_.mnc_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ClientPayload_UserAgent::set_allocated_mnc(std::string* mnc) { + if (mnc != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.mnc_.SetAllocated(mnc, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mnc_.IsDefault()) { + _impl_.mnc_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.mnc) +} + +// optional string osVersion = 5; +inline bool ClientPayload_UserAgent::_internal_has_osversion() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ClientPayload_UserAgent::has_osversion() const { + return _internal_has_osversion(); +} +inline void ClientPayload_UserAgent::clear_osversion() { + _impl_.osversion_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& ClientPayload_UserAgent::osversion() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.osVersion) + return _internal_osversion(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ClientPayload_UserAgent::set_osversion(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.osversion_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.osVersion) +} +inline std::string* ClientPayload_UserAgent::mutable_osversion() { + std::string* _s = _internal_mutable_osversion(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.osVersion) + return _s; +} +inline const std::string& ClientPayload_UserAgent::_internal_osversion() const { + return _impl_.osversion_.Get(); +} +inline void ClientPayload_UserAgent::_internal_set_osversion(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.osversion_.Set(value, GetArenaForAllocation()); +} +inline std::string* ClientPayload_UserAgent::_internal_mutable_osversion() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.osversion_.Mutable(GetArenaForAllocation()); +} +inline std::string* ClientPayload_UserAgent::release_osversion() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.osVersion) + if (!_internal_has_osversion()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.osversion_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.osversion_.IsDefault()) { + _impl_.osversion_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ClientPayload_UserAgent::set_allocated_osversion(std::string* osversion) { + if (osversion != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.osversion_.SetAllocated(osversion, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.osversion_.IsDefault()) { + _impl_.osversion_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.osVersion) +} + +// optional string manufacturer = 6; +inline bool ClientPayload_UserAgent::_internal_has_manufacturer() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ClientPayload_UserAgent::has_manufacturer() const { + return _internal_has_manufacturer(); +} +inline void ClientPayload_UserAgent::clear_manufacturer() { + _impl_.manufacturer_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const std::string& ClientPayload_UserAgent::manufacturer() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.manufacturer) + return _internal_manufacturer(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ClientPayload_UserAgent::set_manufacturer(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.manufacturer_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.manufacturer) +} +inline std::string* ClientPayload_UserAgent::mutable_manufacturer() { + std::string* _s = _internal_mutable_manufacturer(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.manufacturer) + return _s; +} +inline const std::string& ClientPayload_UserAgent::_internal_manufacturer() const { + return _impl_.manufacturer_.Get(); +} +inline void ClientPayload_UserAgent::_internal_set_manufacturer(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.manufacturer_.Set(value, GetArenaForAllocation()); +} +inline std::string* ClientPayload_UserAgent::_internal_mutable_manufacturer() { + _impl_._has_bits_[0] |= 0x00000008u; + return _impl_.manufacturer_.Mutable(GetArenaForAllocation()); +} +inline std::string* ClientPayload_UserAgent::release_manufacturer() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.manufacturer) + if (!_internal_has_manufacturer()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000008u; + auto* p = _impl_.manufacturer_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.manufacturer_.IsDefault()) { + _impl_.manufacturer_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ClientPayload_UserAgent::set_allocated_manufacturer(std::string* manufacturer) { + if (manufacturer != nullptr) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.manufacturer_.SetAllocated(manufacturer, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.manufacturer_.IsDefault()) { + _impl_.manufacturer_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.manufacturer) +} + +// optional string device = 7; +inline bool ClientPayload_UserAgent::_internal_has_device() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool ClientPayload_UserAgent::has_device() const { + return _internal_has_device(); +} +inline void ClientPayload_UserAgent::clear_device() { + _impl_.device_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const std::string& ClientPayload_UserAgent::device() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.device) + return _internal_device(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ClientPayload_UserAgent::set_device(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.device_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.device) +} +inline std::string* ClientPayload_UserAgent::mutable_device() { + std::string* _s = _internal_mutable_device(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.device) + return _s; +} +inline const std::string& ClientPayload_UserAgent::_internal_device() const { + return _impl_.device_.Get(); +} +inline void ClientPayload_UserAgent::_internal_set_device(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.device_.Set(value, GetArenaForAllocation()); +} +inline std::string* ClientPayload_UserAgent::_internal_mutable_device() { + _impl_._has_bits_[0] |= 0x00000010u; + return _impl_.device_.Mutable(GetArenaForAllocation()); +} +inline std::string* ClientPayload_UserAgent::release_device() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.device) + if (!_internal_has_device()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000010u; + auto* p = _impl_.device_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.device_.IsDefault()) { + _impl_.device_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ClientPayload_UserAgent::set_allocated_device(std::string* device) { + if (device != nullptr) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.device_.SetAllocated(device, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.device_.IsDefault()) { + _impl_.device_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.device) +} + +// optional string osBuildNumber = 8; +inline bool ClientPayload_UserAgent::_internal_has_osbuildnumber() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool ClientPayload_UserAgent::has_osbuildnumber() const { + return _internal_has_osbuildnumber(); +} +inline void ClientPayload_UserAgent::clear_osbuildnumber() { + _impl_.osbuildnumber_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline const std::string& ClientPayload_UserAgent::osbuildnumber() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.osBuildNumber) + return _internal_osbuildnumber(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ClientPayload_UserAgent::set_osbuildnumber(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.osbuildnumber_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.osBuildNumber) +} +inline std::string* ClientPayload_UserAgent::mutable_osbuildnumber() { + std::string* _s = _internal_mutable_osbuildnumber(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.osBuildNumber) + return _s; +} +inline const std::string& ClientPayload_UserAgent::_internal_osbuildnumber() const { + return _impl_.osbuildnumber_.Get(); +} +inline void ClientPayload_UserAgent::_internal_set_osbuildnumber(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.osbuildnumber_.Set(value, GetArenaForAllocation()); +} +inline std::string* ClientPayload_UserAgent::_internal_mutable_osbuildnumber() { + _impl_._has_bits_[0] |= 0x00000020u; + return _impl_.osbuildnumber_.Mutable(GetArenaForAllocation()); +} +inline std::string* ClientPayload_UserAgent::release_osbuildnumber() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.osBuildNumber) + if (!_internal_has_osbuildnumber()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000020u; + auto* p = _impl_.osbuildnumber_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.osbuildnumber_.IsDefault()) { + _impl_.osbuildnumber_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ClientPayload_UserAgent::set_allocated_osbuildnumber(std::string* osbuildnumber) { + if (osbuildnumber != nullptr) { + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + _impl_.osbuildnumber_.SetAllocated(osbuildnumber, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.osbuildnumber_.IsDefault()) { + _impl_.osbuildnumber_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.osBuildNumber) +} + +// optional string phoneId = 9; +inline bool ClientPayload_UserAgent::_internal_has_phoneid() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool ClientPayload_UserAgent::has_phoneid() const { + return _internal_has_phoneid(); +} +inline void ClientPayload_UserAgent::clear_phoneid() { + _impl_.phoneid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline const std::string& ClientPayload_UserAgent::phoneid() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.phoneId) + return _internal_phoneid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ClientPayload_UserAgent::set_phoneid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.phoneid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.phoneId) +} +inline std::string* ClientPayload_UserAgent::mutable_phoneid() { + std::string* _s = _internal_mutable_phoneid(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.phoneId) + return _s; +} +inline const std::string& ClientPayload_UserAgent::_internal_phoneid() const { + return _impl_.phoneid_.Get(); +} +inline void ClientPayload_UserAgent::_internal_set_phoneid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.phoneid_.Set(value, GetArenaForAllocation()); +} +inline std::string* ClientPayload_UserAgent::_internal_mutable_phoneid() { + _impl_._has_bits_[0] |= 0x00000040u; + return _impl_.phoneid_.Mutable(GetArenaForAllocation()); +} +inline std::string* ClientPayload_UserAgent::release_phoneid() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.phoneId) + if (!_internal_has_phoneid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000040u; + auto* p = _impl_.phoneid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.phoneid_.IsDefault()) { + _impl_.phoneid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ClientPayload_UserAgent::set_allocated_phoneid(std::string* phoneid) { + if (phoneid != nullptr) { + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + _impl_.phoneid_.SetAllocated(phoneid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.phoneid_.IsDefault()) { + _impl_.phoneid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.phoneId) +} + +// optional .proto.ClientPayload.UserAgent.ReleaseChannel releaseChannel = 10; +inline bool ClientPayload_UserAgent::_internal_has_releasechannel() const { + bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; + return value; +} +inline bool ClientPayload_UserAgent::has_releasechannel() const { + return _internal_has_releasechannel(); +} +inline void ClientPayload_UserAgent::clear_releasechannel() { + _impl_.releasechannel_ = 0; + _impl_._has_bits_[0] &= ~0x00001000u; +} +inline ::proto::ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent::_internal_releasechannel() const { + return static_cast< ::proto::ClientPayload_UserAgent_ReleaseChannel >(_impl_.releasechannel_); +} +inline ::proto::ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent::releasechannel() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.releaseChannel) + return _internal_releasechannel(); +} +inline void ClientPayload_UserAgent::_internal_set_releasechannel(::proto::ClientPayload_UserAgent_ReleaseChannel value) { + assert(::proto::ClientPayload_UserAgent_ReleaseChannel_IsValid(value)); + _impl_._has_bits_[0] |= 0x00001000u; + _impl_.releasechannel_ = value; +} +inline void ClientPayload_UserAgent::set_releasechannel(::proto::ClientPayload_UserAgent_ReleaseChannel value) { + _internal_set_releasechannel(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.releaseChannel) +} + +// optional string localeLanguageIso6391 = 11; +inline bool ClientPayload_UserAgent::_internal_has_localelanguageiso6391() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool ClientPayload_UserAgent::has_localelanguageiso6391() const { + return _internal_has_localelanguageiso6391(); +} +inline void ClientPayload_UserAgent::clear_localelanguageiso6391() { + _impl_.localelanguageiso6391_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline const std::string& ClientPayload_UserAgent::localelanguageiso6391() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.localeLanguageIso6391) + return _internal_localelanguageiso6391(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ClientPayload_UserAgent::set_localelanguageiso6391(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.localelanguageiso6391_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.localeLanguageIso6391) +} +inline std::string* ClientPayload_UserAgent::mutable_localelanguageiso6391() { + std::string* _s = _internal_mutable_localelanguageiso6391(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.localeLanguageIso6391) + return _s; +} +inline const std::string& ClientPayload_UserAgent::_internal_localelanguageiso6391() const { + return _impl_.localelanguageiso6391_.Get(); +} +inline void ClientPayload_UserAgent::_internal_set_localelanguageiso6391(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.localelanguageiso6391_.Set(value, GetArenaForAllocation()); +} +inline std::string* ClientPayload_UserAgent::_internal_mutable_localelanguageiso6391() { + _impl_._has_bits_[0] |= 0x00000080u; + return _impl_.localelanguageiso6391_.Mutable(GetArenaForAllocation()); +} +inline std::string* ClientPayload_UserAgent::release_localelanguageiso6391() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.localeLanguageIso6391) + if (!_internal_has_localelanguageiso6391()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000080u; + auto* p = _impl_.localelanguageiso6391_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.localelanguageiso6391_.IsDefault()) { + _impl_.localelanguageiso6391_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ClientPayload_UserAgent::set_allocated_localelanguageiso6391(std::string* localelanguageiso6391) { + if (localelanguageiso6391 != nullptr) { + _impl_._has_bits_[0] |= 0x00000080u; + } else { + _impl_._has_bits_[0] &= ~0x00000080u; + } + _impl_.localelanguageiso6391_.SetAllocated(localelanguageiso6391, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.localelanguageiso6391_.IsDefault()) { + _impl_.localelanguageiso6391_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.localeLanguageIso6391) +} + +// optional string localeCountryIso31661Alpha2 = 12; +inline bool ClientPayload_UserAgent::_internal_has_localecountryiso31661alpha2() const { + bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool ClientPayload_UserAgent::has_localecountryiso31661alpha2() const { + return _internal_has_localecountryiso31661alpha2(); +} +inline void ClientPayload_UserAgent::clear_localecountryiso31661alpha2() { + _impl_.localecountryiso31661alpha2_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000100u; +} +inline const std::string& ClientPayload_UserAgent::localecountryiso31661alpha2() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.localeCountryIso31661Alpha2) + return _internal_localecountryiso31661alpha2(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ClientPayload_UserAgent::set_localecountryiso31661alpha2(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.localecountryiso31661alpha2_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.localeCountryIso31661Alpha2) +} +inline std::string* ClientPayload_UserAgent::mutable_localecountryiso31661alpha2() { + std::string* _s = _internal_mutable_localecountryiso31661alpha2(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.localeCountryIso31661Alpha2) + return _s; +} +inline const std::string& ClientPayload_UserAgent::_internal_localecountryiso31661alpha2() const { + return _impl_.localecountryiso31661alpha2_.Get(); +} +inline void ClientPayload_UserAgent::_internal_set_localecountryiso31661alpha2(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.localecountryiso31661alpha2_.Set(value, GetArenaForAllocation()); +} +inline std::string* ClientPayload_UserAgent::_internal_mutable_localecountryiso31661alpha2() { + _impl_._has_bits_[0] |= 0x00000100u; + return _impl_.localecountryiso31661alpha2_.Mutable(GetArenaForAllocation()); +} +inline std::string* ClientPayload_UserAgent::release_localecountryiso31661alpha2() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.localeCountryIso31661Alpha2) + if (!_internal_has_localecountryiso31661alpha2()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000100u; + auto* p = _impl_.localecountryiso31661alpha2_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.localecountryiso31661alpha2_.IsDefault()) { + _impl_.localecountryiso31661alpha2_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ClientPayload_UserAgent::set_allocated_localecountryiso31661alpha2(std::string* localecountryiso31661alpha2) { + if (localecountryiso31661alpha2 != nullptr) { + _impl_._has_bits_[0] |= 0x00000100u; + } else { + _impl_._has_bits_[0] &= ~0x00000100u; + } + _impl_.localecountryiso31661alpha2_.SetAllocated(localecountryiso31661alpha2, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.localecountryiso31661alpha2_.IsDefault()) { + _impl_.localecountryiso31661alpha2_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.localeCountryIso31661Alpha2) +} + +// optional string deviceBoard = 13; +inline bool ClientPayload_UserAgent::_internal_has_deviceboard() const { + bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool ClientPayload_UserAgent::has_deviceboard() const { + return _internal_has_deviceboard(); +} +inline void ClientPayload_UserAgent::clear_deviceboard() { + _impl_.deviceboard_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000200u; +} +inline const std::string& ClientPayload_UserAgent::deviceboard() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.deviceBoard) + return _internal_deviceboard(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ClientPayload_UserAgent::set_deviceboard(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.deviceboard_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.deviceBoard) +} +inline std::string* ClientPayload_UserAgent::mutable_deviceboard() { + std::string* _s = _internal_mutable_deviceboard(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.deviceBoard) + return _s; +} +inline const std::string& ClientPayload_UserAgent::_internal_deviceboard() const { + return _impl_.deviceboard_.Get(); +} +inline void ClientPayload_UserAgent::_internal_set_deviceboard(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.deviceboard_.Set(value, GetArenaForAllocation()); +} +inline std::string* ClientPayload_UserAgent::_internal_mutable_deviceboard() { + _impl_._has_bits_[0] |= 0x00000200u; + return _impl_.deviceboard_.Mutable(GetArenaForAllocation()); +} +inline std::string* ClientPayload_UserAgent::release_deviceboard() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.deviceBoard) + if (!_internal_has_deviceboard()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000200u; + auto* p = _impl_.deviceboard_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.deviceboard_.IsDefault()) { + _impl_.deviceboard_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ClientPayload_UserAgent::set_allocated_deviceboard(std::string* deviceboard) { + if (deviceboard != nullptr) { + _impl_._has_bits_[0] |= 0x00000200u; + } else { + _impl_._has_bits_[0] &= ~0x00000200u; + } + _impl_.deviceboard_.SetAllocated(deviceboard, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.deviceboard_.IsDefault()) { + _impl_.deviceboard_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.deviceBoard) +} + +// ------------------------------------------------------------------- + +// ClientPayload_WebInfo_WebdPayload + +// optional bool usesParticipantInKey = 1; +inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_usesparticipantinkey() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ClientPayload_WebInfo_WebdPayload::has_usesparticipantinkey() const { + return _internal_has_usesparticipantinkey(); +} +inline void ClientPayload_WebInfo_WebdPayload::clear_usesparticipantinkey() { + _impl_.usesparticipantinkey_ = false; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline bool ClientPayload_WebInfo_WebdPayload::_internal_usesparticipantinkey() const { + return _impl_.usesparticipantinkey_; +} +inline bool ClientPayload_WebInfo_WebdPayload::usesparticipantinkey() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.usesParticipantInKey) + return _internal_usesparticipantinkey(); +} +inline void ClientPayload_WebInfo_WebdPayload::_internal_set_usesparticipantinkey(bool value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.usesparticipantinkey_ = value; +} +inline void ClientPayload_WebInfo_WebdPayload::set_usesparticipantinkey(bool value) { + _internal_set_usesparticipantinkey(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.usesParticipantInKey) +} + +// optional bool supportsStarredMessages = 2; +inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportsstarredmessages() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ClientPayload_WebInfo_WebdPayload::has_supportsstarredmessages() const { + return _internal_has_supportsstarredmessages(); +} +inline void ClientPayload_WebInfo_WebdPayload::clear_supportsstarredmessages() { + _impl_.supportsstarredmessages_ = false; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportsstarredmessages() const { + return _impl_.supportsstarredmessages_; +} +inline bool ClientPayload_WebInfo_WebdPayload::supportsstarredmessages() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsStarredMessages) + return _internal_supportsstarredmessages(); +} +inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportsstarredmessages(bool value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.supportsstarredmessages_ = value; +} +inline void ClientPayload_WebInfo_WebdPayload::set_supportsstarredmessages(bool value) { + _internal_set_supportsstarredmessages(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsStarredMessages) +} + +// optional bool supportsDocumentMessages = 3; +inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportsdocumentmessages() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool ClientPayload_WebInfo_WebdPayload::has_supportsdocumentmessages() const { + return _internal_has_supportsdocumentmessages(); +} +inline void ClientPayload_WebInfo_WebdPayload::clear_supportsdocumentmessages() { + _impl_.supportsdocumentmessages_ = false; + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportsdocumentmessages() const { + return _impl_.supportsdocumentmessages_; +} +inline bool ClientPayload_WebInfo_WebdPayload::supportsdocumentmessages() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsDocumentMessages) + return _internal_supportsdocumentmessages(); +} +inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportsdocumentmessages(bool value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.supportsdocumentmessages_ = value; +} +inline void ClientPayload_WebInfo_WebdPayload::set_supportsdocumentmessages(bool value) { + _internal_set_supportsdocumentmessages(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsDocumentMessages) +} + +// optional bool supportsUrlMessages = 4; +inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportsurlmessages() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool ClientPayload_WebInfo_WebdPayload::has_supportsurlmessages() const { + return _internal_has_supportsurlmessages(); +} +inline void ClientPayload_WebInfo_WebdPayload::clear_supportsurlmessages() { + _impl_.supportsurlmessages_ = false; + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportsurlmessages() const { + return _impl_.supportsurlmessages_; +} +inline bool ClientPayload_WebInfo_WebdPayload::supportsurlmessages() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsUrlMessages) + return _internal_supportsurlmessages(); +} +inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportsurlmessages(bool value) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.supportsurlmessages_ = value; +} +inline void ClientPayload_WebInfo_WebdPayload::set_supportsurlmessages(bool value) { + _internal_set_supportsurlmessages(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsUrlMessages) +} + +// optional bool supportsMediaRetry = 5; +inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportsmediaretry() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool ClientPayload_WebInfo_WebdPayload::has_supportsmediaretry() const { + return _internal_has_supportsmediaretry(); +} +inline void ClientPayload_WebInfo_WebdPayload::clear_supportsmediaretry() { + _impl_.supportsmediaretry_ = false; + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportsmediaretry() const { + return _impl_.supportsmediaretry_; +} +inline bool ClientPayload_WebInfo_WebdPayload::supportsmediaretry() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsMediaRetry) + return _internal_supportsmediaretry(); +} +inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportsmediaretry(bool value) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.supportsmediaretry_ = value; +} +inline void ClientPayload_WebInfo_WebdPayload::set_supportsmediaretry(bool value) { + _internal_set_supportsmediaretry(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsMediaRetry) +} + +// optional bool supportsE2EImage = 6; +inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportse2eimage() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool ClientPayload_WebInfo_WebdPayload::has_supportse2eimage() const { + return _internal_has_supportse2eimage(); +} +inline void ClientPayload_WebInfo_WebdPayload::clear_supportse2eimage() { + _impl_.supportse2eimage_ = false; + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportse2eimage() const { + return _impl_.supportse2eimage_; +} +inline bool ClientPayload_WebInfo_WebdPayload::supportse2eimage() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EImage) + return _internal_supportse2eimage(); +} +inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportse2eimage(bool value) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.supportse2eimage_ = value; +} +inline void ClientPayload_WebInfo_WebdPayload::set_supportse2eimage(bool value) { + _internal_set_supportse2eimage(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EImage) +} + +// optional bool supportsE2EVideo = 7; +inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportse2evideo() const { + bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool ClientPayload_WebInfo_WebdPayload::has_supportse2evideo() const { + return _internal_has_supportse2evideo(); +} +inline void ClientPayload_WebInfo_WebdPayload::clear_supportse2evideo() { + _impl_.supportse2evideo_ = false; + _impl_._has_bits_[0] &= ~0x00000100u; +} +inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportse2evideo() const { + return _impl_.supportse2evideo_; +} +inline bool ClientPayload_WebInfo_WebdPayload::supportse2evideo() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EVideo) + return _internal_supportse2evideo(); +} +inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportse2evideo(bool value) { + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.supportse2evideo_ = value; +} +inline void ClientPayload_WebInfo_WebdPayload::set_supportse2evideo(bool value) { + _internal_set_supportse2evideo(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EVideo) +} + +// optional bool supportsE2EAudio = 8; +inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportse2eaudio() const { + bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool ClientPayload_WebInfo_WebdPayload::has_supportse2eaudio() const { + return _internal_has_supportse2eaudio(); +} +inline void ClientPayload_WebInfo_WebdPayload::clear_supportse2eaudio() { + _impl_.supportse2eaudio_ = false; + _impl_._has_bits_[0] &= ~0x00000200u; +} +inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportse2eaudio() const { + return _impl_.supportse2eaudio_; +} +inline bool ClientPayload_WebInfo_WebdPayload::supportse2eaudio() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EAudio) + return _internal_supportse2eaudio(); +} +inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportse2eaudio(bool value) { + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.supportse2eaudio_ = value; +} +inline void ClientPayload_WebInfo_WebdPayload::set_supportse2eaudio(bool value) { + _internal_set_supportse2eaudio(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EAudio) +} + +// optional bool supportsE2EDocument = 9; +inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportse2edocument() const { + bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool ClientPayload_WebInfo_WebdPayload::has_supportse2edocument() const { + return _internal_has_supportse2edocument(); +} +inline void ClientPayload_WebInfo_WebdPayload::clear_supportse2edocument() { + _impl_.supportse2edocument_ = false; + _impl_._has_bits_[0] &= ~0x00000400u; +} +inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportse2edocument() const { + return _impl_.supportse2edocument_; +} +inline bool ClientPayload_WebInfo_WebdPayload::supportse2edocument() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EDocument) + return _internal_supportse2edocument(); +} +inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportse2edocument(bool value) { + _impl_._has_bits_[0] |= 0x00000400u; + _impl_.supportse2edocument_ = value; +} +inline void ClientPayload_WebInfo_WebdPayload::set_supportse2edocument(bool value) { + _internal_set_supportse2edocument(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EDocument) +} + +// optional string documentTypes = 10; +inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_documenttypes() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ClientPayload_WebInfo_WebdPayload::has_documenttypes() const { + return _internal_has_documenttypes(); +} +inline void ClientPayload_WebInfo_WebdPayload::clear_documenttypes() { + _impl_.documenttypes_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ClientPayload_WebInfo_WebdPayload::documenttypes() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.documentTypes) + return _internal_documenttypes(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ClientPayload_WebInfo_WebdPayload::set_documenttypes(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.documenttypes_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.documentTypes) +} +inline std::string* ClientPayload_WebInfo_WebdPayload::mutable_documenttypes() { + std::string* _s = _internal_mutable_documenttypes(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.WebInfo.WebdPayload.documentTypes) + return _s; +} +inline const std::string& ClientPayload_WebInfo_WebdPayload::_internal_documenttypes() const { + return _impl_.documenttypes_.Get(); +} +inline void ClientPayload_WebInfo_WebdPayload::_internal_set_documenttypes(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.documenttypes_.Set(value, GetArenaForAllocation()); +} +inline std::string* ClientPayload_WebInfo_WebdPayload::_internal_mutable_documenttypes() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.documenttypes_.Mutable(GetArenaForAllocation()); +} +inline std::string* ClientPayload_WebInfo_WebdPayload::release_documenttypes() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.WebInfo.WebdPayload.documentTypes) + if (!_internal_has_documenttypes()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.documenttypes_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.documenttypes_.IsDefault()) { + _impl_.documenttypes_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ClientPayload_WebInfo_WebdPayload::set_allocated_documenttypes(std::string* documenttypes) { + if (documenttypes != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.documenttypes_.SetAllocated(documenttypes, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.documenttypes_.IsDefault()) { + _impl_.documenttypes_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.WebInfo.WebdPayload.documentTypes) +} + +// optional bytes features = 11; +inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_features() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ClientPayload_WebInfo_WebdPayload::has_features() const { + return _internal_has_features(); +} +inline void ClientPayload_WebInfo_WebdPayload::clear_features() { + _impl_.features_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& ClientPayload_WebInfo_WebdPayload::features() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.features) + return _internal_features(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ClientPayload_WebInfo_WebdPayload::set_features(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.features_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.features) +} +inline std::string* ClientPayload_WebInfo_WebdPayload::mutable_features() { + std::string* _s = _internal_mutable_features(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.WebInfo.WebdPayload.features) + return _s; +} +inline const std::string& ClientPayload_WebInfo_WebdPayload::_internal_features() const { + return _impl_.features_.Get(); +} +inline void ClientPayload_WebInfo_WebdPayload::_internal_set_features(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.features_.Set(value, GetArenaForAllocation()); +} +inline std::string* ClientPayload_WebInfo_WebdPayload::_internal_mutable_features() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.features_.Mutable(GetArenaForAllocation()); +} +inline std::string* ClientPayload_WebInfo_WebdPayload::release_features() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.WebInfo.WebdPayload.features) + if (!_internal_has_features()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.features_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.features_.IsDefault()) { + _impl_.features_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ClientPayload_WebInfo_WebdPayload::set_allocated_features(std::string* features) { + if (features != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.features_.SetAllocated(features, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.features_.IsDefault()) { + _impl_.features_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.WebInfo.WebdPayload.features) +} + +// ------------------------------------------------------------------- + +// ClientPayload_WebInfo + +// optional string refToken = 1; +inline bool ClientPayload_WebInfo::_internal_has_reftoken() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ClientPayload_WebInfo::has_reftoken() const { + return _internal_has_reftoken(); +} +inline void ClientPayload_WebInfo::clear_reftoken() { + _impl_.reftoken_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ClientPayload_WebInfo::reftoken() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.refToken) + return _internal_reftoken(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ClientPayload_WebInfo::set_reftoken(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.reftoken_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.refToken) +} +inline std::string* ClientPayload_WebInfo::mutable_reftoken() { + std::string* _s = _internal_mutable_reftoken(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.WebInfo.refToken) + return _s; +} +inline const std::string& ClientPayload_WebInfo::_internal_reftoken() const { + return _impl_.reftoken_.Get(); +} +inline void ClientPayload_WebInfo::_internal_set_reftoken(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.reftoken_.Set(value, GetArenaForAllocation()); +} +inline std::string* ClientPayload_WebInfo::_internal_mutable_reftoken() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.reftoken_.Mutable(GetArenaForAllocation()); +} +inline std::string* ClientPayload_WebInfo::release_reftoken() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.WebInfo.refToken) + if (!_internal_has_reftoken()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.reftoken_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.reftoken_.IsDefault()) { + _impl_.reftoken_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ClientPayload_WebInfo::set_allocated_reftoken(std::string* reftoken) { + if (reftoken != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.reftoken_.SetAllocated(reftoken, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.reftoken_.IsDefault()) { + _impl_.reftoken_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.WebInfo.refToken) +} + +// optional string version = 2; +inline bool ClientPayload_WebInfo::_internal_has_version() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ClientPayload_WebInfo::has_version() const { + return _internal_has_version(); +} +inline void ClientPayload_WebInfo::clear_version() { + _impl_.version_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& ClientPayload_WebInfo::version() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.version) + return _internal_version(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ClientPayload_WebInfo::set_version(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.version_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.version) +} +inline std::string* ClientPayload_WebInfo::mutable_version() { + std::string* _s = _internal_mutable_version(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.WebInfo.version) + return _s; +} +inline const std::string& ClientPayload_WebInfo::_internal_version() const { + return _impl_.version_.Get(); +} +inline void ClientPayload_WebInfo::_internal_set_version(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.version_.Set(value, GetArenaForAllocation()); +} +inline std::string* ClientPayload_WebInfo::_internal_mutable_version() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.version_.Mutable(GetArenaForAllocation()); +} +inline std::string* ClientPayload_WebInfo::release_version() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.WebInfo.version) + if (!_internal_has_version()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.version_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.version_.IsDefault()) { + _impl_.version_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ClientPayload_WebInfo::set_allocated_version(std::string* version) { + if (version != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.version_.SetAllocated(version, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.version_.IsDefault()) { + _impl_.version_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.WebInfo.version) +} + +// optional .proto.ClientPayload.WebInfo.WebdPayload webdPayload = 3; +inline bool ClientPayload_WebInfo::_internal_has_webdpayload() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.webdpayload_ != nullptr); + return value; +} +inline bool ClientPayload_WebInfo::has_webdpayload() const { + return _internal_has_webdpayload(); +} +inline void ClientPayload_WebInfo::clear_webdpayload() { + if (_impl_.webdpayload_ != nullptr) _impl_.webdpayload_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::proto::ClientPayload_WebInfo_WebdPayload& ClientPayload_WebInfo::_internal_webdpayload() const { + const ::proto::ClientPayload_WebInfo_WebdPayload* p = _impl_.webdpayload_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ClientPayload_WebInfo_WebdPayload_default_instance_); +} +inline const ::proto::ClientPayload_WebInfo_WebdPayload& ClientPayload_WebInfo::webdpayload() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.webdPayload) + return _internal_webdpayload(); +} +inline void ClientPayload_WebInfo::unsafe_arena_set_allocated_webdpayload( + ::proto::ClientPayload_WebInfo_WebdPayload* webdpayload) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.webdpayload_); + } + _impl_.webdpayload_ = webdpayload; + if (webdpayload) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ClientPayload.WebInfo.webdPayload) +} +inline ::proto::ClientPayload_WebInfo_WebdPayload* ClientPayload_WebInfo::release_webdpayload() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::ClientPayload_WebInfo_WebdPayload* temp = _impl_.webdpayload_; + _impl_.webdpayload_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ClientPayload_WebInfo_WebdPayload* ClientPayload_WebInfo::unsafe_arena_release_webdpayload() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.WebInfo.webdPayload) + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::ClientPayload_WebInfo_WebdPayload* temp = _impl_.webdpayload_; + _impl_.webdpayload_ = nullptr; + return temp; +} +inline ::proto::ClientPayload_WebInfo_WebdPayload* ClientPayload_WebInfo::_internal_mutable_webdpayload() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.webdpayload_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ClientPayload_WebInfo_WebdPayload>(GetArenaForAllocation()); + _impl_.webdpayload_ = p; + } + return _impl_.webdpayload_; +} +inline ::proto::ClientPayload_WebInfo_WebdPayload* ClientPayload_WebInfo::mutable_webdpayload() { + ::proto::ClientPayload_WebInfo_WebdPayload* _msg = _internal_mutable_webdpayload(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.WebInfo.webdPayload) + return _msg; +} +inline void ClientPayload_WebInfo::set_allocated_webdpayload(::proto::ClientPayload_WebInfo_WebdPayload* webdpayload) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.webdpayload_; + } + if (webdpayload) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(webdpayload); + if (message_arena != submessage_arena) { + webdpayload = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, webdpayload, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.webdpayload_ = webdpayload; + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.WebInfo.webdPayload) +} + +// optional .proto.ClientPayload.WebInfo.WebSubPlatform webSubPlatform = 4; +inline bool ClientPayload_WebInfo::_internal_has_websubplatform() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ClientPayload_WebInfo::has_websubplatform() const { + return _internal_has_websubplatform(); +} +inline void ClientPayload_WebInfo::clear_websubplatform() { + _impl_.websubplatform_ = 0; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline ::proto::ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo::_internal_websubplatform() const { + return static_cast< ::proto::ClientPayload_WebInfo_WebSubPlatform >(_impl_.websubplatform_); +} +inline ::proto::ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo::websubplatform() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.webSubPlatform) + return _internal_websubplatform(); +} +inline void ClientPayload_WebInfo::_internal_set_websubplatform(::proto::ClientPayload_WebInfo_WebSubPlatform value) { + assert(::proto::ClientPayload_WebInfo_WebSubPlatform_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.websubplatform_ = value; +} +inline void ClientPayload_WebInfo::set_websubplatform(::proto::ClientPayload_WebInfo_WebSubPlatform value) { + _internal_set_websubplatform(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.webSubPlatform) +} + +// ------------------------------------------------------------------- + +// ClientPayload + +// optional uint64 username = 1; +inline bool ClientPayload::_internal_has_username() const { + bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool ClientPayload::has_username() const { + return _internal_has_username(); +} +inline void ClientPayload::clear_username() { + _impl_.username_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000200u; +} +inline uint64_t ClientPayload::_internal_username() const { + return _impl_.username_; +} +inline uint64_t ClientPayload::username() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.username) + return _internal_username(); +} +inline void ClientPayload::_internal_set_username(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.username_ = value; +} +inline void ClientPayload::set_username(uint64_t value) { + _internal_set_username(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.username) +} + +// optional bool passive = 3; +inline bool ClientPayload::_internal_has_passive() const { + bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0; + return value; +} +inline bool ClientPayload::has_passive() const { + return _internal_has_passive(); +} +inline void ClientPayload::clear_passive() { + _impl_.passive_ = false; + _impl_._has_bits_[0] &= ~0x00004000u; +} +inline bool ClientPayload::_internal_passive() const { + return _impl_.passive_; +} +inline bool ClientPayload::passive() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.passive) + return _internal_passive(); +} +inline void ClientPayload::_internal_set_passive(bool value) { + _impl_._has_bits_[0] |= 0x00004000u; + _impl_.passive_ = value; +} +inline void ClientPayload::set_passive(bool value) { + _internal_set_passive(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.passive) +} + +// optional .proto.ClientPayload.UserAgent userAgent = 5; +inline bool ClientPayload::_internal_has_useragent() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + PROTOBUF_ASSUME(!value || _impl_.useragent_ != nullptr); + return value; +} +inline bool ClientPayload::has_useragent() const { + return _internal_has_useragent(); +} +inline void ClientPayload::clear_useragent() { + if (_impl_.useragent_ != nullptr) _impl_.useragent_->Clear(); + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline const ::proto::ClientPayload_UserAgent& ClientPayload::_internal_useragent() const { + const ::proto::ClientPayload_UserAgent* p = _impl_.useragent_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ClientPayload_UserAgent_default_instance_); +} +inline const ::proto::ClientPayload_UserAgent& ClientPayload::useragent() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.userAgent) + return _internal_useragent(); +} +inline void ClientPayload::unsafe_arena_set_allocated_useragent( + ::proto::ClientPayload_UserAgent* useragent) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.useragent_); + } + _impl_.useragent_ = useragent; + if (useragent) { + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ClientPayload.userAgent) +} +inline ::proto::ClientPayload_UserAgent* ClientPayload::release_useragent() { + _impl_._has_bits_[0] &= ~0x00000020u; + ::proto::ClientPayload_UserAgent* temp = _impl_.useragent_; + _impl_.useragent_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ClientPayload_UserAgent* ClientPayload::unsafe_arena_release_useragent() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.userAgent) + _impl_._has_bits_[0] &= ~0x00000020u; + ::proto::ClientPayload_UserAgent* temp = _impl_.useragent_; + _impl_.useragent_ = nullptr; + return temp; +} +inline ::proto::ClientPayload_UserAgent* ClientPayload::_internal_mutable_useragent() { + _impl_._has_bits_[0] |= 0x00000020u; + if (_impl_.useragent_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ClientPayload_UserAgent>(GetArenaForAllocation()); + _impl_.useragent_ = p; + } + return _impl_.useragent_; +} +inline ::proto::ClientPayload_UserAgent* ClientPayload::mutable_useragent() { + ::proto::ClientPayload_UserAgent* _msg = _internal_mutable_useragent(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.userAgent) + return _msg; +} +inline void ClientPayload::set_allocated_useragent(::proto::ClientPayload_UserAgent* useragent) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.useragent_; + } + if (useragent) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(useragent); + if (message_arena != submessage_arena) { + useragent = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, useragent, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + _impl_.useragent_ = useragent; + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.userAgent) +} + +// optional .proto.ClientPayload.WebInfo webInfo = 6; +inline bool ClientPayload::_internal_has_webinfo() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + PROTOBUF_ASSUME(!value || _impl_.webinfo_ != nullptr); + return value; +} +inline bool ClientPayload::has_webinfo() const { + return _internal_has_webinfo(); +} +inline void ClientPayload::clear_webinfo() { + if (_impl_.webinfo_ != nullptr) _impl_.webinfo_->Clear(); + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline const ::proto::ClientPayload_WebInfo& ClientPayload::_internal_webinfo() const { + const ::proto::ClientPayload_WebInfo* p = _impl_.webinfo_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ClientPayload_WebInfo_default_instance_); +} +inline const ::proto::ClientPayload_WebInfo& ClientPayload::webinfo() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.webInfo) + return _internal_webinfo(); +} +inline void ClientPayload::unsafe_arena_set_allocated_webinfo( + ::proto::ClientPayload_WebInfo* webinfo) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.webinfo_); + } + _impl_.webinfo_ = webinfo; + if (webinfo) { + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ClientPayload.webInfo) +} +inline ::proto::ClientPayload_WebInfo* ClientPayload::release_webinfo() { + _impl_._has_bits_[0] &= ~0x00000040u; + ::proto::ClientPayload_WebInfo* temp = _impl_.webinfo_; + _impl_.webinfo_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ClientPayload_WebInfo* ClientPayload::unsafe_arena_release_webinfo() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.webInfo) + _impl_._has_bits_[0] &= ~0x00000040u; + ::proto::ClientPayload_WebInfo* temp = _impl_.webinfo_; + _impl_.webinfo_ = nullptr; + return temp; +} +inline ::proto::ClientPayload_WebInfo* ClientPayload::_internal_mutable_webinfo() { + _impl_._has_bits_[0] |= 0x00000040u; + if (_impl_.webinfo_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ClientPayload_WebInfo>(GetArenaForAllocation()); + _impl_.webinfo_ = p; + } + return _impl_.webinfo_; +} +inline ::proto::ClientPayload_WebInfo* ClientPayload::mutable_webinfo() { + ::proto::ClientPayload_WebInfo* _msg = _internal_mutable_webinfo(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.webInfo) + return _msg; +} +inline void ClientPayload::set_allocated_webinfo(::proto::ClientPayload_WebInfo* webinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.webinfo_; + } + if (webinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(webinfo); + if (message_arena != submessage_arena) { + webinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, webinfo, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + _impl_.webinfo_ = webinfo; + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.webInfo) +} + +// optional string pushName = 7; +inline bool ClientPayload::_internal_has_pushname() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ClientPayload::has_pushname() const { + return _internal_has_pushname(); +} +inline void ClientPayload::clear_pushname() { + _impl_.pushname_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ClientPayload::pushname() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.pushName) + return _internal_pushname(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ClientPayload::set_pushname(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.pushname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ClientPayload.pushName) +} +inline std::string* ClientPayload::mutable_pushname() { + std::string* _s = _internal_mutable_pushname(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.pushName) + return _s; +} +inline const std::string& ClientPayload::_internal_pushname() const { + return _impl_.pushname_.Get(); +} +inline void ClientPayload::_internal_set_pushname(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.pushname_.Set(value, GetArenaForAllocation()); +} +inline std::string* ClientPayload::_internal_mutable_pushname() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.pushname_.Mutable(GetArenaForAllocation()); +} +inline std::string* ClientPayload::release_pushname() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.pushName) + if (!_internal_has_pushname()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.pushname_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.pushname_.IsDefault()) { + _impl_.pushname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ClientPayload::set_allocated_pushname(std::string* pushname) { + if (pushname != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.pushname_.SetAllocated(pushname, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.pushname_.IsDefault()) { + _impl_.pushname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.pushName) +} + +// optional sfixed32 sessionId = 9; +inline bool ClientPayload::_internal_has_sessionid() const { + bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool ClientPayload::has_sessionid() const { + return _internal_has_sessionid(); +} +inline void ClientPayload::clear_sessionid() { + _impl_.sessionid_ = 0; + _impl_._has_bits_[0] &= ~0x00000400u; +} +inline int32_t ClientPayload::_internal_sessionid() const { + return _impl_.sessionid_; +} +inline int32_t ClientPayload::sessionid() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.sessionId) + return _internal_sessionid(); +} +inline void ClientPayload::_internal_set_sessionid(int32_t value) { + _impl_._has_bits_[0] |= 0x00000400u; + _impl_.sessionid_ = value; +} +inline void ClientPayload::set_sessionid(int32_t value) { + _internal_set_sessionid(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.sessionId) +} + +// optional bool shortConnect = 10; +inline bool ClientPayload::_internal_has_shortconnect() const { + bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0; + return value; +} +inline bool ClientPayload::has_shortconnect() const { + return _internal_has_shortconnect(); +} +inline void ClientPayload::clear_shortconnect() { + _impl_.shortconnect_ = false; + _impl_._has_bits_[0] &= ~0x00008000u; +} +inline bool ClientPayload::_internal_shortconnect() const { + return _impl_.shortconnect_; +} +inline bool ClientPayload::shortconnect() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.shortConnect) + return _internal_shortconnect(); +} +inline void ClientPayload::_internal_set_shortconnect(bool value) { + _impl_._has_bits_[0] |= 0x00008000u; + _impl_.shortconnect_ = value; +} +inline void ClientPayload::set_shortconnect(bool value) { + _internal_set_shortconnect(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.shortConnect) +} + +// optional .proto.ClientPayload.ConnectType connectType = 12; +inline bool ClientPayload::_internal_has_connecttype() const { + bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; + return value; +} +inline bool ClientPayload::has_connecttype() const { + return _internal_has_connecttype(); +} +inline void ClientPayload::clear_connecttype() { + _impl_.connecttype_ = 0; + _impl_._has_bits_[0] &= ~0x00000800u; +} +inline ::proto::ClientPayload_ConnectType ClientPayload::_internal_connecttype() const { + return static_cast< ::proto::ClientPayload_ConnectType >(_impl_.connecttype_); +} +inline ::proto::ClientPayload_ConnectType ClientPayload::connecttype() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.connectType) + return _internal_connecttype(); +} +inline void ClientPayload::_internal_set_connecttype(::proto::ClientPayload_ConnectType value) { + assert(::proto::ClientPayload_ConnectType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000800u; + _impl_.connecttype_ = value; +} +inline void ClientPayload::set_connecttype(::proto::ClientPayload_ConnectType value) { + _internal_set_connecttype(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.connectType) +} + +// optional .proto.ClientPayload.ConnectReason connectReason = 13; +inline bool ClientPayload::_internal_has_connectreason() const { + bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; + return value; +} +inline bool ClientPayload::has_connectreason() const { + return _internal_has_connectreason(); +} +inline void ClientPayload::clear_connectreason() { + _impl_.connectreason_ = 0; + _impl_._has_bits_[0] &= ~0x00001000u; +} +inline ::proto::ClientPayload_ConnectReason ClientPayload::_internal_connectreason() const { + return static_cast< ::proto::ClientPayload_ConnectReason >(_impl_.connectreason_); +} +inline ::proto::ClientPayload_ConnectReason ClientPayload::connectreason() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.connectReason) + return _internal_connectreason(); +} +inline void ClientPayload::_internal_set_connectreason(::proto::ClientPayload_ConnectReason value) { + assert(::proto::ClientPayload_ConnectReason_IsValid(value)); + _impl_._has_bits_[0] |= 0x00001000u; + _impl_.connectreason_ = value; +} +inline void ClientPayload::set_connectreason(::proto::ClientPayload_ConnectReason value) { + _internal_set_connectreason(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.connectReason) +} + +// repeated int32 shards = 14; +inline int ClientPayload::_internal_shards_size() const { + return _impl_.shards_.size(); +} +inline int ClientPayload::shards_size() const { + return _internal_shards_size(); +} +inline void ClientPayload::clear_shards() { + _impl_.shards_.Clear(); +} +inline int32_t ClientPayload::_internal_shards(int index) const { + return _impl_.shards_.Get(index); +} +inline int32_t ClientPayload::shards(int index) const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.shards) + return _internal_shards(index); +} +inline void ClientPayload::set_shards(int index, int32_t value) { + _impl_.shards_.Set(index, value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.shards) +} +inline void ClientPayload::_internal_add_shards(int32_t value) { + _impl_.shards_.Add(value); +} +inline void ClientPayload::add_shards(int32_t value) { + _internal_add_shards(value); + // @@protoc_insertion_point(field_add:proto.ClientPayload.shards) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& +ClientPayload::_internal_shards() const { + return _impl_.shards_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& +ClientPayload::shards() const { + // @@protoc_insertion_point(field_list:proto.ClientPayload.shards) + return _internal_shards(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* +ClientPayload::_internal_mutable_shards() { + return &_impl_.shards_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* +ClientPayload::mutable_shards() { + // @@protoc_insertion_point(field_mutable_list:proto.ClientPayload.shards) + return _internal_mutable_shards(); +} + +// optional .proto.ClientPayload.DNSSource dnsSource = 15; +inline bool ClientPayload::_internal_has_dnssource() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + PROTOBUF_ASSUME(!value || _impl_.dnssource_ != nullptr); + return value; +} +inline bool ClientPayload::has_dnssource() const { + return _internal_has_dnssource(); +} +inline void ClientPayload::clear_dnssource() { + if (_impl_.dnssource_ != nullptr) _impl_.dnssource_->Clear(); + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline const ::proto::ClientPayload_DNSSource& ClientPayload::_internal_dnssource() const { + const ::proto::ClientPayload_DNSSource* p = _impl_.dnssource_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ClientPayload_DNSSource_default_instance_); +} +inline const ::proto::ClientPayload_DNSSource& ClientPayload::dnssource() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.dnsSource) + return _internal_dnssource(); +} +inline void ClientPayload::unsafe_arena_set_allocated_dnssource( + ::proto::ClientPayload_DNSSource* dnssource) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.dnssource_); + } + _impl_.dnssource_ = dnssource; + if (dnssource) { + _impl_._has_bits_[0] |= 0x00000080u; + } else { + _impl_._has_bits_[0] &= ~0x00000080u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ClientPayload.dnsSource) +} +inline ::proto::ClientPayload_DNSSource* ClientPayload::release_dnssource() { + _impl_._has_bits_[0] &= ~0x00000080u; + ::proto::ClientPayload_DNSSource* temp = _impl_.dnssource_; + _impl_.dnssource_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ClientPayload_DNSSource* ClientPayload::unsafe_arena_release_dnssource() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.dnsSource) + _impl_._has_bits_[0] &= ~0x00000080u; + ::proto::ClientPayload_DNSSource* temp = _impl_.dnssource_; + _impl_.dnssource_ = nullptr; + return temp; +} +inline ::proto::ClientPayload_DNSSource* ClientPayload::_internal_mutable_dnssource() { + _impl_._has_bits_[0] |= 0x00000080u; + if (_impl_.dnssource_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ClientPayload_DNSSource>(GetArenaForAllocation()); + _impl_.dnssource_ = p; + } + return _impl_.dnssource_; +} +inline ::proto::ClientPayload_DNSSource* ClientPayload::mutable_dnssource() { + ::proto::ClientPayload_DNSSource* _msg = _internal_mutable_dnssource(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.dnsSource) + return _msg; +} +inline void ClientPayload::set_allocated_dnssource(::proto::ClientPayload_DNSSource* dnssource) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.dnssource_; + } + if (dnssource) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(dnssource); + if (message_arena != submessage_arena) { + dnssource = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, dnssource, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000080u; + } else { + _impl_._has_bits_[0] &= ~0x00000080u; + } + _impl_.dnssource_ = dnssource; + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.dnsSource) +} + +// optional uint32 connectAttemptCount = 16; +inline bool ClientPayload::_internal_has_connectattemptcount() const { + bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0; + return value; +} +inline bool ClientPayload::has_connectattemptcount() const { + return _internal_has_connectattemptcount(); +} +inline void ClientPayload::clear_connectattemptcount() { + _impl_.connectattemptcount_ = 0u; + _impl_._has_bits_[0] &= ~0x00002000u; +} +inline uint32_t ClientPayload::_internal_connectattemptcount() const { + return _impl_.connectattemptcount_; +} +inline uint32_t ClientPayload::connectattemptcount() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.connectAttemptCount) + return _internal_connectattemptcount(); +} +inline void ClientPayload::_internal_set_connectattemptcount(uint32_t value) { + _impl_._has_bits_[0] |= 0x00002000u; + _impl_.connectattemptcount_ = value; +} +inline void ClientPayload::set_connectattemptcount(uint32_t value) { + _internal_set_connectattemptcount(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.connectAttemptCount) +} + +// optional uint32 device = 18; +inline bool ClientPayload::_internal_has_device() const { + bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0; + return value; +} +inline bool ClientPayload::has_device() const { + return _internal_has_device(); +} +inline void ClientPayload::clear_device() { + _impl_.device_ = 0u; + _impl_._has_bits_[0] &= ~0x00040000u; +} +inline uint32_t ClientPayload::_internal_device() const { + return _impl_.device_; +} +inline uint32_t ClientPayload::device() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.device) + return _internal_device(); +} +inline void ClientPayload::_internal_set_device(uint32_t value) { + _impl_._has_bits_[0] |= 0x00040000u; + _impl_.device_ = value; +} +inline void ClientPayload::set_device(uint32_t value) { + _internal_set_device(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.device) +} + +// optional .proto.ClientPayload.DevicePairingRegistrationData devicePairingData = 19; +inline bool ClientPayload::_internal_has_devicepairingdata() const { + bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; + PROTOBUF_ASSUME(!value || _impl_.devicepairingdata_ != nullptr); + return value; +} +inline bool ClientPayload::has_devicepairingdata() const { + return _internal_has_devicepairingdata(); +} +inline void ClientPayload::clear_devicepairingdata() { + if (_impl_.devicepairingdata_ != nullptr) _impl_.devicepairingdata_->Clear(); + _impl_._has_bits_[0] &= ~0x00000100u; +} +inline const ::proto::ClientPayload_DevicePairingRegistrationData& ClientPayload::_internal_devicepairingdata() const { + const ::proto::ClientPayload_DevicePairingRegistrationData* p = _impl_.devicepairingdata_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ClientPayload_DevicePairingRegistrationData_default_instance_); +} +inline const ::proto::ClientPayload_DevicePairingRegistrationData& ClientPayload::devicepairingdata() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.devicePairingData) + return _internal_devicepairingdata(); +} +inline void ClientPayload::unsafe_arena_set_allocated_devicepairingdata( + ::proto::ClientPayload_DevicePairingRegistrationData* devicepairingdata) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.devicepairingdata_); + } + _impl_.devicepairingdata_ = devicepairingdata; + if (devicepairingdata) { + _impl_._has_bits_[0] |= 0x00000100u; + } else { + _impl_._has_bits_[0] &= ~0x00000100u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ClientPayload.devicePairingData) +} +inline ::proto::ClientPayload_DevicePairingRegistrationData* ClientPayload::release_devicepairingdata() { + _impl_._has_bits_[0] &= ~0x00000100u; + ::proto::ClientPayload_DevicePairingRegistrationData* temp = _impl_.devicepairingdata_; + _impl_.devicepairingdata_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ClientPayload_DevicePairingRegistrationData* ClientPayload::unsafe_arena_release_devicepairingdata() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.devicePairingData) + _impl_._has_bits_[0] &= ~0x00000100u; + ::proto::ClientPayload_DevicePairingRegistrationData* temp = _impl_.devicepairingdata_; + _impl_.devicepairingdata_ = nullptr; + return temp; +} +inline ::proto::ClientPayload_DevicePairingRegistrationData* ClientPayload::_internal_mutable_devicepairingdata() { + _impl_._has_bits_[0] |= 0x00000100u; + if (_impl_.devicepairingdata_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ClientPayload_DevicePairingRegistrationData>(GetArenaForAllocation()); + _impl_.devicepairingdata_ = p; + } + return _impl_.devicepairingdata_; +} +inline ::proto::ClientPayload_DevicePairingRegistrationData* ClientPayload::mutable_devicepairingdata() { + ::proto::ClientPayload_DevicePairingRegistrationData* _msg = _internal_mutable_devicepairingdata(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.devicePairingData) + return _msg; +} +inline void ClientPayload::set_allocated_devicepairingdata(::proto::ClientPayload_DevicePairingRegistrationData* devicepairingdata) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.devicepairingdata_; + } + if (devicepairingdata) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(devicepairingdata); + if (message_arena != submessage_arena) { + devicepairingdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, devicepairingdata, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000100u; + } else { + _impl_._has_bits_[0] &= ~0x00000100u; + } + _impl_.devicepairingdata_ = devicepairingdata; + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.devicePairingData) +} + +// optional .proto.ClientPayload.Product product = 20; +inline bool ClientPayload::_internal_has_product() const { + bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0; + return value; +} +inline bool ClientPayload::has_product() const { + return _internal_has_product(); +} +inline void ClientPayload::clear_product() { + _impl_.product_ = 0; + _impl_._has_bits_[0] &= ~0x00080000u; +} +inline ::proto::ClientPayload_Product ClientPayload::_internal_product() const { + return static_cast< ::proto::ClientPayload_Product >(_impl_.product_); +} +inline ::proto::ClientPayload_Product ClientPayload::product() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.product) + return _internal_product(); +} +inline void ClientPayload::_internal_set_product(::proto::ClientPayload_Product value) { + assert(::proto::ClientPayload_Product_IsValid(value)); + _impl_._has_bits_[0] |= 0x00080000u; + _impl_.product_ = value; +} +inline void ClientPayload::set_product(::proto::ClientPayload_Product value) { + _internal_set_product(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.product) +} + +// optional bytes fbCat = 21; +inline bool ClientPayload::_internal_has_fbcat() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ClientPayload::has_fbcat() const { + return _internal_has_fbcat(); +} +inline void ClientPayload::clear_fbcat() { + _impl_.fbcat_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& ClientPayload::fbcat() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.fbCat) + return _internal_fbcat(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ClientPayload::set_fbcat(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.fbcat_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ClientPayload.fbCat) +} +inline std::string* ClientPayload::mutable_fbcat() { + std::string* _s = _internal_mutable_fbcat(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.fbCat) + return _s; +} +inline const std::string& ClientPayload::_internal_fbcat() const { + return _impl_.fbcat_.Get(); +} +inline void ClientPayload::_internal_set_fbcat(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.fbcat_.Set(value, GetArenaForAllocation()); +} +inline std::string* ClientPayload::_internal_mutable_fbcat() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.fbcat_.Mutable(GetArenaForAllocation()); +} +inline std::string* ClientPayload::release_fbcat() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.fbCat) + if (!_internal_has_fbcat()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.fbcat_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fbcat_.IsDefault()) { + _impl_.fbcat_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ClientPayload::set_allocated_fbcat(std::string* fbcat) { + if (fbcat != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.fbcat_.SetAllocated(fbcat, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fbcat_.IsDefault()) { + _impl_.fbcat_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.fbCat) +} + +// optional bytes fbUserAgent = 22; +inline bool ClientPayload::_internal_has_fbuseragent() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ClientPayload::has_fbuseragent() const { + return _internal_has_fbuseragent(); +} +inline void ClientPayload::clear_fbuseragent() { + _impl_.fbuseragent_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& ClientPayload::fbuseragent() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.fbUserAgent) + return _internal_fbuseragent(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ClientPayload::set_fbuseragent(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.fbuseragent_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ClientPayload.fbUserAgent) +} +inline std::string* ClientPayload::mutable_fbuseragent() { + std::string* _s = _internal_mutable_fbuseragent(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.fbUserAgent) + return _s; +} +inline const std::string& ClientPayload::_internal_fbuseragent() const { + return _impl_.fbuseragent_.Get(); +} +inline void ClientPayload::_internal_set_fbuseragent(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.fbuseragent_.Set(value, GetArenaForAllocation()); +} +inline std::string* ClientPayload::_internal_mutable_fbuseragent() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.fbuseragent_.Mutable(GetArenaForAllocation()); +} +inline std::string* ClientPayload::release_fbuseragent() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.fbUserAgent) + if (!_internal_has_fbuseragent()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.fbuseragent_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fbuseragent_.IsDefault()) { + _impl_.fbuseragent_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ClientPayload::set_allocated_fbuseragent(std::string* fbuseragent) { + if (fbuseragent != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.fbuseragent_.SetAllocated(fbuseragent, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fbuseragent_.IsDefault()) { + _impl_.fbuseragent_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.fbUserAgent) +} + +// optional bool oc = 23; +inline bool ClientPayload::_internal_has_oc() const { + bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0; + return value; +} +inline bool ClientPayload::has_oc() const { + return _internal_has_oc(); +} +inline void ClientPayload::clear_oc() { + _impl_.oc_ = false; + _impl_._has_bits_[0] &= ~0x00010000u; +} +inline bool ClientPayload::_internal_oc() const { + return _impl_.oc_; +} +inline bool ClientPayload::oc() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.oc) + return _internal_oc(); +} +inline void ClientPayload::_internal_set_oc(bool value) { + _impl_._has_bits_[0] |= 0x00010000u; + _impl_.oc_ = value; +} +inline void ClientPayload::set_oc(bool value) { + _internal_set_oc(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.oc) +} + +// optional int32 lc = 24; +inline bool ClientPayload::_internal_has_lc() const { + bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0; + return value; +} +inline bool ClientPayload::has_lc() const { + return _internal_has_lc(); +} +inline void ClientPayload::clear_lc() { + _impl_.lc_ = 0; + _impl_._has_bits_[0] &= ~0x00100000u; +} +inline int32_t ClientPayload::_internal_lc() const { + return _impl_.lc_; +} +inline int32_t ClientPayload::lc() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.lc) + return _internal_lc(); +} +inline void ClientPayload::_internal_set_lc(int32_t value) { + _impl_._has_bits_[0] |= 0x00100000u; + _impl_.lc_ = value; +} +inline void ClientPayload::set_lc(int32_t value) { + _internal_set_lc(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.lc) +} + +// optional .proto.ClientPayload.IOSAppExtension iosAppExtension = 30; +inline bool ClientPayload::_internal_has_iosappextension() const { + bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0; + return value; +} +inline bool ClientPayload::has_iosappextension() const { + return _internal_has_iosappextension(); +} +inline void ClientPayload::clear_iosappextension() { + _impl_.iosappextension_ = 0; + _impl_._has_bits_[0] &= ~0x00400000u; +} +inline ::proto::ClientPayload_IOSAppExtension ClientPayload::_internal_iosappextension() const { + return static_cast< ::proto::ClientPayload_IOSAppExtension >(_impl_.iosappextension_); +} +inline ::proto::ClientPayload_IOSAppExtension ClientPayload::iosappextension() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.iosAppExtension) + return _internal_iosappextension(); +} +inline void ClientPayload::_internal_set_iosappextension(::proto::ClientPayload_IOSAppExtension value) { + assert(::proto::ClientPayload_IOSAppExtension_IsValid(value)); + _impl_._has_bits_[0] |= 0x00400000u; + _impl_.iosappextension_ = value; +} +inline void ClientPayload::set_iosappextension(::proto::ClientPayload_IOSAppExtension value) { + _internal_set_iosappextension(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.iosAppExtension) +} + +// optional uint64 fbAppId = 31; +inline bool ClientPayload::_internal_has_fbappid() const { + bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0; + return value; +} +inline bool ClientPayload::has_fbappid() const { + return _internal_has_fbappid(); +} +inline void ClientPayload::clear_fbappid() { + _impl_.fbappid_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00200000u; +} +inline uint64_t ClientPayload::_internal_fbappid() const { + return _impl_.fbappid_; +} +inline uint64_t ClientPayload::fbappid() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.fbAppId) + return _internal_fbappid(); +} +inline void ClientPayload::_internal_set_fbappid(uint64_t value) { + _impl_._has_bits_[0] |= 0x00200000u; + _impl_.fbappid_ = value; +} +inline void ClientPayload::set_fbappid(uint64_t value) { + _internal_set_fbappid(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.fbAppId) +} + +// optional bytes fbDeviceId = 32; +inline bool ClientPayload::_internal_has_fbdeviceid() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ClientPayload::has_fbdeviceid() const { + return _internal_has_fbdeviceid(); +} +inline void ClientPayload::clear_fbdeviceid() { + _impl_.fbdeviceid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const std::string& ClientPayload::fbdeviceid() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.fbDeviceId) + return _internal_fbdeviceid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ClientPayload::set_fbdeviceid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.fbdeviceid_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ClientPayload.fbDeviceId) +} +inline std::string* ClientPayload::mutable_fbdeviceid() { + std::string* _s = _internal_mutable_fbdeviceid(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.fbDeviceId) + return _s; +} +inline const std::string& ClientPayload::_internal_fbdeviceid() const { + return _impl_.fbdeviceid_.Get(); +} +inline void ClientPayload::_internal_set_fbdeviceid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.fbdeviceid_.Set(value, GetArenaForAllocation()); +} +inline std::string* ClientPayload::_internal_mutable_fbdeviceid() { + _impl_._has_bits_[0] |= 0x00000008u; + return _impl_.fbdeviceid_.Mutable(GetArenaForAllocation()); +} +inline std::string* ClientPayload::release_fbdeviceid() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.fbDeviceId) + if (!_internal_has_fbdeviceid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000008u; + auto* p = _impl_.fbdeviceid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fbdeviceid_.IsDefault()) { + _impl_.fbdeviceid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ClientPayload::set_allocated_fbdeviceid(std::string* fbdeviceid) { + if (fbdeviceid != nullptr) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.fbdeviceid_.SetAllocated(fbdeviceid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fbdeviceid_.IsDefault()) { + _impl_.fbdeviceid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.fbDeviceId) +} + +// optional bool pull = 33; +inline bool ClientPayload::_internal_has_pull() const { + bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0; + return value; +} +inline bool ClientPayload::has_pull() const { + return _internal_has_pull(); +} +inline void ClientPayload::clear_pull() { + _impl_.pull_ = false; + _impl_._has_bits_[0] &= ~0x00020000u; +} +inline bool ClientPayload::_internal_pull() const { + return _impl_.pull_; +} +inline bool ClientPayload::pull() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.pull) + return _internal_pull(); +} +inline void ClientPayload::_internal_set_pull(bool value) { + _impl_._has_bits_[0] |= 0x00020000u; + _impl_.pull_ = value; +} +inline void ClientPayload::set_pull(bool value) { + _internal_set_pull(value); + // @@protoc_insertion_point(field_set:proto.ClientPayload.pull) +} + +// optional bytes paddingBytes = 34; +inline bool ClientPayload::_internal_has_paddingbytes() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool ClientPayload::has_paddingbytes() const { + return _internal_has_paddingbytes(); +} +inline void ClientPayload::clear_paddingbytes() { + _impl_.paddingbytes_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const std::string& ClientPayload::paddingbytes() const { + // @@protoc_insertion_point(field_get:proto.ClientPayload.paddingBytes) + return _internal_paddingbytes(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ClientPayload::set_paddingbytes(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.paddingbytes_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ClientPayload.paddingBytes) +} +inline std::string* ClientPayload::mutable_paddingbytes() { + std::string* _s = _internal_mutable_paddingbytes(); + // @@protoc_insertion_point(field_mutable:proto.ClientPayload.paddingBytes) + return _s; +} +inline const std::string& ClientPayload::_internal_paddingbytes() const { + return _impl_.paddingbytes_.Get(); +} +inline void ClientPayload::_internal_set_paddingbytes(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.paddingbytes_.Set(value, GetArenaForAllocation()); +} +inline std::string* ClientPayload::_internal_mutable_paddingbytes() { + _impl_._has_bits_[0] |= 0x00000010u; + return _impl_.paddingbytes_.Mutable(GetArenaForAllocation()); +} +inline std::string* ClientPayload::release_paddingbytes() { + // @@protoc_insertion_point(field_release:proto.ClientPayload.paddingBytes) + if (!_internal_has_paddingbytes()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000010u; + auto* p = _impl_.paddingbytes_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.paddingbytes_.IsDefault()) { + _impl_.paddingbytes_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ClientPayload::set_allocated_paddingbytes(std::string* paddingbytes) { + if (paddingbytes != nullptr) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.paddingbytes_.SetAllocated(paddingbytes, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.paddingbytes_.IsDefault()) { + _impl_.paddingbytes_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.paddingBytes) +} + +// ------------------------------------------------------------------- + +// ContextInfo_AdReplyInfo + +// optional string advertiserName = 1; +inline bool ContextInfo_AdReplyInfo::_internal_has_advertisername() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ContextInfo_AdReplyInfo::has_advertisername() const { + return _internal_has_advertisername(); +} +inline void ContextInfo_AdReplyInfo::clear_advertisername() { + _impl_.advertisername_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ContextInfo_AdReplyInfo::advertisername() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.AdReplyInfo.advertiserName) + return _internal_advertisername(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ContextInfo_AdReplyInfo::set_advertisername(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.advertisername_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ContextInfo.AdReplyInfo.advertiserName) +} +inline std::string* ContextInfo_AdReplyInfo::mutable_advertisername() { + std::string* _s = _internal_mutable_advertisername(); + // @@protoc_insertion_point(field_mutable:proto.ContextInfo.AdReplyInfo.advertiserName) + return _s; +} +inline const std::string& ContextInfo_AdReplyInfo::_internal_advertisername() const { + return _impl_.advertisername_.Get(); +} +inline void ContextInfo_AdReplyInfo::_internal_set_advertisername(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.advertisername_.Set(value, GetArenaForAllocation()); +} +inline std::string* ContextInfo_AdReplyInfo::_internal_mutable_advertisername() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.advertisername_.Mutable(GetArenaForAllocation()); +} +inline std::string* ContextInfo_AdReplyInfo::release_advertisername() { + // @@protoc_insertion_point(field_release:proto.ContextInfo.AdReplyInfo.advertiserName) + if (!_internal_has_advertisername()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.advertisername_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.advertisername_.IsDefault()) { + _impl_.advertisername_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ContextInfo_AdReplyInfo::set_allocated_advertisername(std::string* advertisername) { + if (advertisername != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.advertisername_.SetAllocated(advertisername, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.advertisername_.IsDefault()) { + _impl_.advertisername_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.AdReplyInfo.advertiserName) +} + +// optional .proto.ContextInfo.AdReplyInfo.MediaType mediaType = 2; +inline bool ContextInfo_AdReplyInfo::_internal_has_mediatype() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ContextInfo_AdReplyInfo::has_mediatype() const { + return _internal_has_mediatype(); +} +inline void ContextInfo_AdReplyInfo::clear_mediatype() { + _impl_.mediatype_ = 0; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline ::proto::ContextInfo_AdReplyInfo_MediaType ContextInfo_AdReplyInfo::_internal_mediatype() const { + return static_cast< ::proto::ContextInfo_AdReplyInfo_MediaType >(_impl_.mediatype_); +} +inline ::proto::ContextInfo_AdReplyInfo_MediaType ContextInfo_AdReplyInfo::mediatype() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.AdReplyInfo.mediaType) + return _internal_mediatype(); +} +inline void ContextInfo_AdReplyInfo::_internal_set_mediatype(::proto::ContextInfo_AdReplyInfo_MediaType value) { + assert(::proto::ContextInfo_AdReplyInfo_MediaType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.mediatype_ = value; +} +inline void ContextInfo_AdReplyInfo::set_mediatype(::proto::ContextInfo_AdReplyInfo_MediaType value) { + _internal_set_mediatype(value); + // @@protoc_insertion_point(field_set:proto.ContextInfo.AdReplyInfo.mediaType) +} + +// optional bytes jpegThumbnail = 16; +inline bool ContextInfo_AdReplyInfo::_internal_has_jpegthumbnail() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ContextInfo_AdReplyInfo::has_jpegthumbnail() const { + return _internal_has_jpegthumbnail(); +} +inline void ContextInfo_AdReplyInfo::clear_jpegthumbnail() { + _impl_.jpegthumbnail_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& ContextInfo_AdReplyInfo::jpegthumbnail() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.AdReplyInfo.jpegThumbnail) + return _internal_jpegthumbnail(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ContextInfo_AdReplyInfo::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.jpegthumbnail_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ContextInfo.AdReplyInfo.jpegThumbnail) +} +inline std::string* ContextInfo_AdReplyInfo::mutable_jpegthumbnail() { + std::string* _s = _internal_mutable_jpegthumbnail(); + // @@protoc_insertion_point(field_mutable:proto.ContextInfo.AdReplyInfo.jpegThumbnail) + return _s; +} +inline const std::string& ContextInfo_AdReplyInfo::_internal_jpegthumbnail() const { + return _impl_.jpegthumbnail_.Get(); +} +inline void ContextInfo_AdReplyInfo::_internal_set_jpegthumbnail(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation()); +} +inline std::string* ContextInfo_AdReplyInfo::_internal_mutable_jpegthumbnail() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation()); +} +inline std::string* ContextInfo_AdReplyInfo::release_jpegthumbnail() { + // @@protoc_insertion_point(field_release:proto.ContextInfo.AdReplyInfo.jpegThumbnail) + if (!_internal_has_jpegthumbnail()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.jpegthumbnail_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.jpegthumbnail_.IsDefault()) { + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ContextInfo_AdReplyInfo::set_allocated_jpegthumbnail(std::string* jpegthumbnail) { + if (jpegthumbnail != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.jpegthumbnail_.IsDefault()) { + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.AdReplyInfo.jpegThumbnail) +} + +// optional string caption = 17; +inline bool ContextInfo_AdReplyInfo::_internal_has_caption() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ContextInfo_AdReplyInfo::has_caption() const { + return _internal_has_caption(); +} +inline void ContextInfo_AdReplyInfo::clear_caption() { + _impl_.caption_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& ContextInfo_AdReplyInfo::caption() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.AdReplyInfo.caption) + return _internal_caption(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ContextInfo_AdReplyInfo::set_caption(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.caption_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ContextInfo.AdReplyInfo.caption) +} +inline std::string* ContextInfo_AdReplyInfo::mutable_caption() { + std::string* _s = _internal_mutable_caption(); + // @@protoc_insertion_point(field_mutable:proto.ContextInfo.AdReplyInfo.caption) + return _s; +} +inline const std::string& ContextInfo_AdReplyInfo::_internal_caption() const { + return _impl_.caption_.Get(); +} +inline void ContextInfo_AdReplyInfo::_internal_set_caption(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.caption_.Set(value, GetArenaForAllocation()); +} +inline std::string* ContextInfo_AdReplyInfo::_internal_mutable_caption() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.caption_.Mutable(GetArenaForAllocation()); +} +inline std::string* ContextInfo_AdReplyInfo::release_caption() { + // @@protoc_insertion_point(field_release:proto.ContextInfo.AdReplyInfo.caption) + if (!_internal_has_caption()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.caption_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.caption_.IsDefault()) { + _impl_.caption_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ContextInfo_AdReplyInfo::set_allocated_caption(std::string* caption) { + if (caption != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.caption_.SetAllocated(caption, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.caption_.IsDefault()) { + _impl_.caption_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.AdReplyInfo.caption) +} + +// ------------------------------------------------------------------- + +// ContextInfo_ExternalAdReplyInfo + +// optional string title = 1; +inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_title() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ContextInfo_ExternalAdReplyInfo::has_title() const { + return _internal_has_title(); +} +inline void ContextInfo_ExternalAdReplyInfo::clear_title() { + _impl_.title_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ContextInfo_ExternalAdReplyInfo::title() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.title) + return _internal_title(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ContextInfo_ExternalAdReplyInfo::set_title(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.title_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.title) +} +inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_title() { + std::string* _s = _internal_mutable_title(); + // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.title) + return _s; +} +inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_title() const { + return _impl_.title_.Get(); +} +inline void ContextInfo_ExternalAdReplyInfo::_internal_set_title(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.title_.Set(value, GetArenaForAllocation()); +} +inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_title() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.title_.Mutable(GetArenaForAllocation()); +} +inline std::string* ContextInfo_ExternalAdReplyInfo::release_title() { + // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.title) + if (!_internal_has_title()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.title_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.title_.IsDefault()) { + _impl_.title_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ContextInfo_ExternalAdReplyInfo::set_allocated_title(std::string* title) { + if (title != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.title_.SetAllocated(title, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.title_.IsDefault()) { + _impl_.title_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ExternalAdReplyInfo.title) +} + +// optional string body = 2; +inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_body() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ContextInfo_ExternalAdReplyInfo::has_body() const { + return _internal_has_body(); +} +inline void ContextInfo_ExternalAdReplyInfo::clear_body() { + _impl_.body_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& ContextInfo_ExternalAdReplyInfo::body() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.body) + return _internal_body(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ContextInfo_ExternalAdReplyInfo::set_body(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.body_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.body) +} +inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_body() { + std::string* _s = _internal_mutable_body(); + // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.body) + return _s; +} +inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_body() const { + return _impl_.body_.Get(); +} +inline void ContextInfo_ExternalAdReplyInfo::_internal_set_body(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.body_.Set(value, GetArenaForAllocation()); +} +inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_body() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.body_.Mutable(GetArenaForAllocation()); +} +inline std::string* ContextInfo_ExternalAdReplyInfo::release_body() { + // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.body) + if (!_internal_has_body()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.body_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.body_.IsDefault()) { + _impl_.body_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ContextInfo_ExternalAdReplyInfo::set_allocated_body(std::string* body) { + if (body != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.body_.SetAllocated(body, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.body_.IsDefault()) { + _impl_.body_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ExternalAdReplyInfo.body) +} + +// optional .proto.ContextInfo.ExternalAdReplyInfo.MediaType mediaType = 3; +inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_mediatype() const { + bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool ContextInfo_ExternalAdReplyInfo::has_mediatype() const { + return _internal_has_mediatype(); +} +inline void ContextInfo_ExternalAdReplyInfo::clear_mediatype() { + _impl_.mediatype_ = 0; + _impl_._has_bits_[0] &= ~0x00000100u; +} +inline ::proto::ContextInfo_ExternalAdReplyInfo_MediaType ContextInfo_ExternalAdReplyInfo::_internal_mediatype() const { + return static_cast< ::proto::ContextInfo_ExternalAdReplyInfo_MediaType >(_impl_.mediatype_); +} +inline ::proto::ContextInfo_ExternalAdReplyInfo_MediaType ContextInfo_ExternalAdReplyInfo::mediatype() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.mediaType) + return _internal_mediatype(); +} +inline void ContextInfo_ExternalAdReplyInfo::_internal_set_mediatype(::proto::ContextInfo_ExternalAdReplyInfo_MediaType value) { + assert(::proto::ContextInfo_ExternalAdReplyInfo_MediaType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.mediatype_ = value; +} +inline void ContextInfo_ExternalAdReplyInfo::set_mediatype(::proto::ContextInfo_ExternalAdReplyInfo_MediaType value) { + _internal_set_mediatype(value); + // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.mediaType) +} + +// optional string thumbnailUrl = 4; +inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_thumbnailurl() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ContextInfo_ExternalAdReplyInfo::has_thumbnailurl() const { + return _internal_has_thumbnailurl(); +} +inline void ContextInfo_ExternalAdReplyInfo::clear_thumbnailurl() { + _impl_.thumbnailurl_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& ContextInfo_ExternalAdReplyInfo::thumbnailurl() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.thumbnailUrl) + return _internal_thumbnailurl(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ContextInfo_ExternalAdReplyInfo::set_thumbnailurl(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.thumbnailurl_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.thumbnailUrl) +} +inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_thumbnailurl() { + std::string* _s = _internal_mutable_thumbnailurl(); + // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.thumbnailUrl) + return _s; +} +inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_thumbnailurl() const { + return _impl_.thumbnailurl_.Get(); +} +inline void ContextInfo_ExternalAdReplyInfo::_internal_set_thumbnailurl(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.thumbnailurl_.Set(value, GetArenaForAllocation()); +} +inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_thumbnailurl() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.thumbnailurl_.Mutable(GetArenaForAllocation()); +} +inline std::string* ContextInfo_ExternalAdReplyInfo::release_thumbnailurl() { + // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.thumbnailUrl) + if (!_internal_has_thumbnailurl()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.thumbnailurl_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.thumbnailurl_.IsDefault()) { + _impl_.thumbnailurl_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ContextInfo_ExternalAdReplyInfo::set_allocated_thumbnailurl(std::string* thumbnailurl) { + if (thumbnailurl != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.thumbnailurl_.SetAllocated(thumbnailurl, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.thumbnailurl_.IsDefault()) { + _impl_.thumbnailurl_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ExternalAdReplyInfo.thumbnailUrl) +} + +// optional string mediaUrl = 5; +inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_mediaurl() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ContextInfo_ExternalAdReplyInfo::has_mediaurl() const { + return _internal_has_mediaurl(); +} +inline void ContextInfo_ExternalAdReplyInfo::clear_mediaurl() { + _impl_.mediaurl_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const std::string& ContextInfo_ExternalAdReplyInfo::mediaurl() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.mediaUrl) + return _internal_mediaurl(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ContextInfo_ExternalAdReplyInfo::set_mediaurl(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.mediaurl_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.mediaUrl) +} +inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_mediaurl() { + std::string* _s = _internal_mutable_mediaurl(); + // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.mediaUrl) + return _s; +} +inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_mediaurl() const { + return _impl_.mediaurl_.Get(); +} +inline void ContextInfo_ExternalAdReplyInfo::_internal_set_mediaurl(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.mediaurl_.Set(value, GetArenaForAllocation()); +} +inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_mediaurl() { + _impl_._has_bits_[0] |= 0x00000008u; + return _impl_.mediaurl_.Mutable(GetArenaForAllocation()); +} +inline std::string* ContextInfo_ExternalAdReplyInfo::release_mediaurl() { + // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.mediaUrl) + if (!_internal_has_mediaurl()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000008u; + auto* p = _impl_.mediaurl_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mediaurl_.IsDefault()) { + _impl_.mediaurl_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ContextInfo_ExternalAdReplyInfo::set_allocated_mediaurl(std::string* mediaurl) { + if (mediaurl != nullptr) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.mediaurl_.SetAllocated(mediaurl, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mediaurl_.IsDefault()) { + _impl_.mediaurl_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ExternalAdReplyInfo.mediaUrl) +} + +// optional bytes thumbnail = 6; +inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_thumbnail() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool ContextInfo_ExternalAdReplyInfo::has_thumbnail() const { + return _internal_has_thumbnail(); +} +inline void ContextInfo_ExternalAdReplyInfo::clear_thumbnail() { + _impl_.thumbnail_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const std::string& ContextInfo_ExternalAdReplyInfo::thumbnail() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.thumbnail) + return _internal_thumbnail(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ContextInfo_ExternalAdReplyInfo::set_thumbnail(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.thumbnail_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.thumbnail) +} +inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_thumbnail() { + std::string* _s = _internal_mutable_thumbnail(); + // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.thumbnail) + return _s; +} +inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_thumbnail() const { + return _impl_.thumbnail_.Get(); +} +inline void ContextInfo_ExternalAdReplyInfo::_internal_set_thumbnail(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.thumbnail_.Set(value, GetArenaForAllocation()); +} +inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_thumbnail() { + _impl_._has_bits_[0] |= 0x00000010u; + return _impl_.thumbnail_.Mutable(GetArenaForAllocation()); +} +inline std::string* ContextInfo_ExternalAdReplyInfo::release_thumbnail() { + // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.thumbnail) + if (!_internal_has_thumbnail()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000010u; + auto* p = _impl_.thumbnail_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.thumbnail_.IsDefault()) { + _impl_.thumbnail_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ContextInfo_ExternalAdReplyInfo::set_allocated_thumbnail(std::string* thumbnail) { + if (thumbnail != nullptr) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.thumbnail_.SetAllocated(thumbnail, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.thumbnail_.IsDefault()) { + _impl_.thumbnail_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ExternalAdReplyInfo.thumbnail) +} + +// optional string sourceType = 7; +inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_sourcetype() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool ContextInfo_ExternalAdReplyInfo::has_sourcetype() const { + return _internal_has_sourcetype(); +} +inline void ContextInfo_ExternalAdReplyInfo::clear_sourcetype() { + _impl_.sourcetype_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline const std::string& ContextInfo_ExternalAdReplyInfo::sourcetype() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.sourceType) + return _internal_sourcetype(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ContextInfo_ExternalAdReplyInfo::set_sourcetype(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.sourcetype_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.sourceType) +} +inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_sourcetype() { + std::string* _s = _internal_mutable_sourcetype(); + // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.sourceType) + return _s; +} +inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_sourcetype() const { + return _impl_.sourcetype_.Get(); +} +inline void ContextInfo_ExternalAdReplyInfo::_internal_set_sourcetype(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.sourcetype_.Set(value, GetArenaForAllocation()); +} +inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_sourcetype() { + _impl_._has_bits_[0] |= 0x00000020u; + return _impl_.sourcetype_.Mutable(GetArenaForAllocation()); +} +inline std::string* ContextInfo_ExternalAdReplyInfo::release_sourcetype() { + // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.sourceType) + if (!_internal_has_sourcetype()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000020u; + auto* p = _impl_.sourcetype_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.sourcetype_.IsDefault()) { + _impl_.sourcetype_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ContextInfo_ExternalAdReplyInfo::set_allocated_sourcetype(std::string* sourcetype) { + if (sourcetype != nullptr) { + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + _impl_.sourcetype_.SetAllocated(sourcetype, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.sourcetype_.IsDefault()) { + _impl_.sourcetype_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ExternalAdReplyInfo.sourceType) +} + +// optional string sourceId = 8; +inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_sourceid() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool ContextInfo_ExternalAdReplyInfo::has_sourceid() const { + return _internal_has_sourceid(); +} +inline void ContextInfo_ExternalAdReplyInfo::clear_sourceid() { + _impl_.sourceid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline const std::string& ContextInfo_ExternalAdReplyInfo::sourceid() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.sourceId) + return _internal_sourceid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ContextInfo_ExternalAdReplyInfo::set_sourceid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.sourceid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.sourceId) +} +inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_sourceid() { + std::string* _s = _internal_mutable_sourceid(); + // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.sourceId) + return _s; +} +inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_sourceid() const { + return _impl_.sourceid_.Get(); +} +inline void ContextInfo_ExternalAdReplyInfo::_internal_set_sourceid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.sourceid_.Set(value, GetArenaForAllocation()); +} +inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_sourceid() { + _impl_._has_bits_[0] |= 0x00000040u; + return _impl_.sourceid_.Mutable(GetArenaForAllocation()); +} +inline std::string* ContextInfo_ExternalAdReplyInfo::release_sourceid() { + // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.sourceId) + if (!_internal_has_sourceid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000040u; + auto* p = _impl_.sourceid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.sourceid_.IsDefault()) { + _impl_.sourceid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ContextInfo_ExternalAdReplyInfo::set_allocated_sourceid(std::string* sourceid) { + if (sourceid != nullptr) { + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + _impl_.sourceid_.SetAllocated(sourceid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.sourceid_.IsDefault()) { + _impl_.sourceid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ExternalAdReplyInfo.sourceId) +} + +// optional string sourceUrl = 9; +inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_sourceurl() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool ContextInfo_ExternalAdReplyInfo::has_sourceurl() const { + return _internal_has_sourceurl(); +} +inline void ContextInfo_ExternalAdReplyInfo::clear_sourceurl() { + _impl_.sourceurl_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline const std::string& ContextInfo_ExternalAdReplyInfo::sourceurl() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.sourceUrl) + return _internal_sourceurl(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ContextInfo_ExternalAdReplyInfo::set_sourceurl(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.sourceurl_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.sourceUrl) +} +inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_sourceurl() { + std::string* _s = _internal_mutable_sourceurl(); + // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.sourceUrl) + return _s; +} +inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_sourceurl() const { + return _impl_.sourceurl_.Get(); +} +inline void ContextInfo_ExternalAdReplyInfo::_internal_set_sourceurl(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.sourceurl_.Set(value, GetArenaForAllocation()); +} +inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_sourceurl() { + _impl_._has_bits_[0] |= 0x00000080u; + return _impl_.sourceurl_.Mutable(GetArenaForAllocation()); +} +inline std::string* ContextInfo_ExternalAdReplyInfo::release_sourceurl() { + // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.sourceUrl) + if (!_internal_has_sourceurl()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000080u; + auto* p = _impl_.sourceurl_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.sourceurl_.IsDefault()) { + _impl_.sourceurl_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ContextInfo_ExternalAdReplyInfo::set_allocated_sourceurl(std::string* sourceurl) { + if (sourceurl != nullptr) { + _impl_._has_bits_[0] |= 0x00000080u; + } else { + _impl_._has_bits_[0] &= ~0x00000080u; + } + _impl_.sourceurl_.SetAllocated(sourceurl, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.sourceurl_.IsDefault()) { + _impl_.sourceurl_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ExternalAdReplyInfo.sourceUrl) +} + +// optional bool containsAutoReply = 10; +inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_containsautoreply() const { + bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool ContextInfo_ExternalAdReplyInfo::has_containsautoreply() const { + return _internal_has_containsautoreply(); +} +inline void ContextInfo_ExternalAdReplyInfo::clear_containsautoreply() { + _impl_.containsautoreply_ = false; + _impl_._has_bits_[0] &= ~0x00000200u; +} +inline bool ContextInfo_ExternalAdReplyInfo::_internal_containsautoreply() const { + return _impl_.containsautoreply_; +} +inline bool ContextInfo_ExternalAdReplyInfo::containsautoreply() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.containsAutoReply) + return _internal_containsautoreply(); +} +inline void ContextInfo_ExternalAdReplyInfo::_internal_set_containsautoreply(bool value) { + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.containsautoreply_ = value; +} +inline void ContextInfo_ExternalAdReplyInfo::set_containsautoreply(bool value) { + _internal_set_containsautoreply(value); + // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.containsAutoReply) +} + +// optional bool renderLargerThumbnail = 11; +inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_renderlargerthumbnail() const { + bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool ContextInfo_ExternalAdReplyInfo::has_renderlargerthumbnail() const { + return _internal_has_renderlargerthumbnail(); +} +inline void ContextInfo_ExternalAdReplyInfo::clear_renderlargerthumbnail() { + _impl_.renderlargerthumbnail_ = false; + _impl_._has_bits_[0] &= ~0x00000400u; +} +inline bool ContextInfo_ExternalAdReplyInfo::_internal_renderlargerthumbnail() const { + return _impl_.renderlargerthumbnail_; +} +inline bool ContextInfo_ExternalAdReplyInfo::renderlargerthumbnail() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.renderLargerThumbnail) + return _internal_renderlargerthumbnail(); +} +inline void ContextInfo_ExternalAdReplyInfo::_internal_set_renderlargerthumbnail(bool value) { + _impl_._has_bits_[0] |= 0x00000400u; + _impl_.renderlargerthumbnail_ = value; +} +inline void ContextInfo_ExternalAdReplyInfo::set_renderlargerthumbnail(bool value) { + _internal_set_renderlargerthumbnail(value); + // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.renderLargerThumbnail) +} + +// optional bool showAdAttribution = 12; +inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_showadattribution() const { + bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; + return value; +} +inline bool ContextInfo_ExternalAdReplyInfo::has_showadattribution() const { + return _internal_has_showadattribution(); +} +inline void ContextInfo_ExternalAdReplyInfo::clear_showadattribution() { + _impl_.showadattribution_ = false; + _impl_._has_bits_[0] &= ~0x00000800u; +} +inline bool ContextInfo_ExternalAdReplyInfo::_internal_showadattribution() const { + return _impl_.showadattribution_; +} +inline bool ContextInfo_ExternalAdReplyInfo::showadattribution() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.showAdAttribution) + return _internal_showadattribution(); +} +inline void ContextInfo_ExternalAdReplyInfo::_internal_set_showadattribution(bool value) { + _impl_._has_bits_[0] |= 0x00000800u; + _impl_.showadattribution_ = value; +} +inline void ContextInfo_ExternalAdReplyInfo::set_showadattribution(bool value) { + _internal_set_showadattribution(value); + // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.showAdAttribution) +} + +// ------------------------------------------------------------------- + +// ContextInfo + +// optional string stanzaId = 1; +inline bool ContextInfo::_internal_has_stanzaid() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ContextInfo::has_stanzaid() const { + return _internal_has_stanzaid(); +} +inline void ContextInfo::clear_stanzaid() { + _impl_.stanzaid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ContextInfo::stanzaid() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.stanzaId) + return _internal_stanzaid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ContextInfo::set_stanzaid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.stanzaid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ContextInfo.stanzaId) +} +inline std::string* ContextInfo::mutable_stanzaid() { + std::string* _s = _internal_mutable_stanzaid(); + // @@protoc_insertion_point(field_mutable:proto.ContextInfo.stanzaId) + return _s; +} +inline const std::string& ContextInfo::_internal_stanzaid() const { + return _impl_.stanzaid_.Get(); +} +inline void ContextInfo::_internal_set_stanzaid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.stanzaid_.Set(value, GetArenaForAllocation()); +} +inline std::string* ContextInfo::_internal_mutable_stanzaid() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.stanzaid_.Mutable(GetArenaForAllocation()); +} +inline std::string* ContextInfo::release_stanzaid() { + // @@protoc_insertion_point(field_release:proto.ContextInfo.stanzaId) + if (!_internal_has_stanzaid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.stanzaid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.stanzaid_.IsDefault()) { + _impl_.stanzaid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ContextInfo::set_allocated_stanzaid(std::string* stanzaid) { + if (stanzaid != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.stanzaid_.SetAllocated(stanzaid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.stanzaid_.IsDefault()) { + _impl_.stanzaid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.stanzaId) +} + +// optional string participant = 2; +inline bool ContextInfo::_internal_has_participant() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ContextInfo::has_participant() const { + return _internal_has_participant(); +} +inline void ContextInfo::clear_participant() { + _impl_.participant_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& ContextInfo::participant() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.participant) + return _internal_participant(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ContextInfo::set_participant(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.participant_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ContextInfo.participant) +} +inline std::string* ContextInfo::mutable_participant() { + std::string* _s = _internal_mutable_participant(); + // @@protoc_insertion_point(field_mutable:proto.ContextInfo.participant) + return _s; +} +inline const std::string& ContextInfo::_internal_participant() const { + return _impl_.participant_.Get(); +} +inline void ContextInfo::_internal_set_participant(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.participant_.Set(value, GetArenaForAllocation()); +} +inline std::string* ContextInfo::_internal_mutable_participant() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.participant_.Mutable(GetArenaForAllocation()); +} +inline std::string* ContextInfo::release_participant() { + // @@protoc_insertion_point(field_release:proto.ContextInfo.participant) + if (!_internal_has_participant()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.participant_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.participant_.IsDefault()) { + _impl_.participant_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ContextInfo::set_allocated_participant(std::string* participant) { + if (participant != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.participant_.SetAllocated(participant, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.participant_.IsDefault()) { + _impl_.participant_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.participant) +} + +// optional .proto.Message quotedMessage = 3; +inline bool ContextInfo::_internal_has_quotedmessage() const { + bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; + PROTOBUF_ASSUME(!value || _impl_.quotedmessage_ != nullptr); + return value; +} +inline bool ContextInfo::has_quotedmessage() const { + return _internal_has_quotedmessage(); +} +inline void ContextInfo::clear_quotedmessage() { + if (_impl_.quotedmessage_ != nullptr) _impl_.quotedmessage_->Clear(); + _impl_._has_bits_[0] &= ~0x00000400u; +} +inline const ::proto::Message& ContextInfo::_internal_quotedmessage() const { + const ::proto::Message* p = _impl_.quotedmessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_default_instance_); +} +inline const ::proto::Message& ContextInfo::quotedmessage() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.quotedMessage) + return _internal_quotedmessage(); +} +inline void ContextInfo::unsafe_arena_set_allocated_quotedmessage( + ::proto::Message* quotedmessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quotedmessage_); + } + _impl_.quotedmessage_ = quotedmessage; + if (quotedmessage) { + _impl_._has_bits_[0] |= 0x00000400u; + } else { + _impl_._has_bits_[0] &= ~0x00000400u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ContextInfo.quotedMessage) +} +inline ::proto::Message* ContextInfo::release_quotedmessage() { + _impl_._has_bits_[0] &= ~0x00000400u; + ::proto::Message* temp = _impl_.quotedmessage_; + _impl_.quotedmessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message* ContextInfo::unsafe_arena_release_quotedmessage() { + // @@protoc_insertion_point(field_release:proto.ContextInfo.quotedMessage) + _impl_._has_bits_[0] &= ~0x00000400u; + ::proto::Message* temp = _impl_.quotedmessage_; + _impl_.quotedmessage_ = nullptr; + return temp; +} +inline ::proto::Message* ContextInfo::_internal_mutable_quotedmessage() { + _impl_._has_bits_[0] |= 0x00000400u; + if (_impl_.quotedmessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message>(GetArenaForAllocation()); + _impl_.quotedmessage_ = p; + } + return _impl_.quotedmessage_; +} +inline ::proto::Message* ContextInfo::mutable_quotedmessage() { + ::proto::Message* _msg = _internal_mutable_quotedmessage(); + // @@protoc_insertion_point(field_mutable:proto.ContextInfo.quotedMessage) + return _msg; +} +inline void ContextInfo::set_allocated_quotedmessage(::proto::Message* quotedmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.quotedmessage_; + } + if (quotedmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quotedmessage); + if (message_arena != submessage_arena) { + quotedmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, quotedmessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000400u; + } else { + _impl_._has_bits_[0] &= ~0x00000400u; + } + _impl_.quotedmessage_ = quotedmessage; + // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.quotedMessage) +} + +// optional string remoteJid = 4; +inline bool ContextInfo::_internal_has_remotejid() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ContextInfo::has_remotejid() const { + return _internal_has_remotejid(); +} +inline void ContextInfo::clear_remotejid() { + _impl_.remotejid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& ContextInfo::remotejid() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.remoteJid) + return _internal_remotejid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ContextInfo::set_remotejid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.remotejid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ContextInfo.remoteJid) +} +inline std::string* ContextInfo::mutable_remotejid() { + std::string* _s = _internal_mutable_remotejid(); + // @@protoc_insertion_point(field_mutable:proto.ContextInfo.remoteJid) + return _s; +} +inline const std::string& ContextInfo::_internal_remotejid() const { + return _impl_.remotejid_.Get(); +} +inline void ContextInfo::_internal_set_remotejid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.remotejid_.Set(value, GetArenaForAllocation()); +} +inline std::string* ContextInfo::_internal_mutable_remotejid() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.remotejid_.Mutable(GetArenaForAllocation()); +} +inline std::string* ContextInfo::release_remotejid() { + // @@protoc_insertion_point(field_release:proto.ContextInfo.remoteJid) + if (!_internal_has_remotejid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.remotejid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.remotejid_.IsDefault()) { + _impl_.remotejid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ContextInfo::set_allocated_remotejid(std::string* remotejid) { + if (remotejid != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.remotejid_.SetAllocated(remotejid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.remotejid_.IsDefault()) { + _impl_.remotejid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.remoteJid) +} + +// repeated string mentionedJid = 15; +inline int ContextInfo::_internal_mentionedjid_size() const { + return _impl_.mentionedjid_.size(); +} +inline int ContextInfo::mentionedjid_size() const { + return _internal_mentionedjid_size(); +} +inline void ContextInfo::clear_mentionedjid() { + _impl_.mentionedjid_.Clear(); +} +inline std::string* ContextInfo::add_mentionedjid() { + std::string* _s = _internal_add_mentionedjid(); + // @@protoc_insertion_point(field_add_mutable:proto.ContextInfo.mentionedJid) + return _s; +} +inline const std::string& ContextInfo::_internal_mentionedjid(int index) const { + return _impl_.mentionedjid_.Get(index); +} +inline const std::string& ContextInfo::mentionedjid(int index) const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.mentionedJid) + return _internal_mentionedjid(index); +} +inline std::string* ContextInfo::mutable_mentionedjid(int index) { + // @@protoc_insertion_point(field_mutable:proto.ContextInfo.mentionedJid) + return _impl_.mentionedjid_.Mutable(index); +} +inline void ContextInfo::set_mentionedjid(int index, const std::string& value) { + _impl_.mentionedjid_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:proto.ContextInfo.mentionedJid) +} +inline void ContextInfo::set_mentionedjid(int index, std::string&& value) { + _impl_.mentionedjid_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:proto.ContextInfo.mentionedJid) +} +inline void ContextInfo::set_mentionedjid(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + _impl_.mentionedjid_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:proto.ContextInfo.mentionedJid) +} +inline void ContextInfo::set_mentionedjid(int index, const char* value, size_t size) { + _impl_.mentionedjid_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:proto.ContextInfo.mentionedJid) +} +inline std::string* ContextInfo::_internal_add_mentionedjid() { + return _impl_.mentionedjid_.Add(); +} +inline void ContextInfo::add_mentionedjid(const std::string& value) { + _impl_.mentionedjid_.Add()->assign(value); + // @@protoc_insertion_point(field_add:proto.ContextInfo.mentionedJid) +} +inline void ContextInfo::add_mentionedjid(std::string&& value) { + _impl_.mentionedjid_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:proto.ContextInfo.mentionedJid) +} +inline void ContextInfo::add_mentionedjid(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _impl_.mentionedjid_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:proto.ContextInfo.mentionedJid) +} +inline void ContextInfo::add_mentionedjid(const char* value, size_t size) { + _impl_.mentionedjid_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:proto.ContextInfo.mentionedJid) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +ContextInfo::mentionedjid() const { + // @@protoc_insertion_point(field_list:proto.ContextInfo.mentionedJid) + return _impl_.mentionedjid_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +ContextInfo::mutable_mentionedjid() { + // @@protoc_insertion_point(field_mutable_list:proto.ContextInfo.mentionedJid) + return &_impl_.mentionedjid_; +} + +// optional string conversionSource = 18; +inline bool ContextInfo::_internal_has_conversionsource() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ContextInfo::has_conversionsource() const { + return _internal_has_conversionsource(); +} +inline void ContextInfo::clear_conversionsource() { + _impl_.conversionsource_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const std::string& ContextInfo::conversionsource() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.conversionSource) + return _internal_conversionsource(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ContextInfo::set_conversionsource(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.conversionsource_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ContextInfo.conversionSource) +} +inline std::string* ContextInfo::mutable_conversionsource() { + std::string* _s = _internal_mutable_conversionsource(); + // @@protoc_insertion_point(field_mutable:proto.ContextInfo.conversionSource) + return _s; +} +inline const std::string& ContextInfo::_internal_conversionsource() const { + return _impl_.conversionsource_.Get(); +} +inline void ContextInfo::_internal_set_conversionsource(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.conversionsource_.Set(value, GetArenaForAllocation()); +} +inline std::string* ContextInfo::_internal_mutable_conversionsource() { + _impl_._has_bits_[0] |= 0x00000008u; + return _impl_.conversionsource_.Mutable(GetArenaForAllocation()); +} +inline std::string* ContextInfo::release_conversionsource() { + // @@protoc_insertion_point(field_release:proto.ContextInfo.conversionSource) + if (!_internal_has_conversionsource()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000008u; + auto* p = _impl_.conversionsource_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.conversionsource_.IsDefault()) { + _impl_.conversionsource_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ContextInfo::set_allocated_conversionsource(std::string* conversionsource) { + if (conversionsource != nullptr) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.conversionsource_.SetAllocated(conversionsource, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.conversionsource_.IsDefault()) { + _impl_.conversionsource_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.conversionSource) +} + +// optional bytes conversionData = 19; +inline bool ContextInfo::_internal_has_conversiondata() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool ContextInfo::has_conversiondata() const { + return _internal_has_conversiondata(); +} +inline void ContextInfo::clear_conversiondata() { + _impl_.conversiondata_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const std::string& ContextInfo::conversiondata() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.conversionData) + return _internal_conversiondata(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ContextInfo::set_conversiondata(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.conversiondata_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ContextInfo.conversionData) +} +inline std::string* ContextInfo::mutable_conversiondata() { + std::string* _s = _internal_mutable_conversiondata(); + // @@protoc_insertion_point(field_mutable:proto.ContextInfo.conversionData) + return _s; +} +inline const std::string& ContextInfo::_internal_conversiondata() const { + return _impl_.conversiondata_.Get(); +} +inline void ContextInfo::_internal_set_conversiondata(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.conversiondata_.Set(value, GetArenaForAllocation()); +} +inline std::string* ContextInfo::_internal_mutable_conversiondata() { + _impl_._has_bits_[0] |= 0x00000010u; + return _impl_.conversiondata_.Mutable(GetArenaForAllocation()); +} +inline std::string* ContextInfo::release_conversiondata() { + // @@protoc_insertion_point(field_release:proto.ContextInfo.conversionData) + if (!_internal_has_conversiondata()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000010u; + auto* p = _impl_.conversiondata_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.conversiondata_.IsDefault()) { + _impl_.conversiondata_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ContextInfo::set_allocated_conversiondata(std::string* conversiondata) { + if (conversiondata != nullptr) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.conversiondata_.SetAllocated(conversiondata, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.conversiondata_.IsDefault()) { + _impl_.conversiondata_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.conversionData) +} + +// optional uint32 conversionDelaySeconds = 20; +inline bool ContextInfo::_internal_has_conversiondelayseconds() const { + bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0; + return value; +} +inline bool ContextInfo::has_conversiondelayseconds() const { + return _internal_has_conversiondelayseconds(); +} +inline void ContextInfo::clear_conversiondelayseconds() { + _impl_.conversiondelayseconds_ = 0u; + _impl_._has_bits_[0] &= ~0x00010000u; +} +inline uint32_t ContextInfo::_internal_conversiondelayseconds() const { + return _impl_.conversiondelayseconds_; +} +inline uint32_t ContextInfo::conversiondelayseconds() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.conversionDelaySeconds) + return _internal_conversiondelayseconds(); +} +inline void ContextInfo::_internal_set_conversiondelayseconds(uint32_t value) { + _impl_._has_bits_[0] |= 0x00010000u; + _impl_.conversiondelayseconds_ = value; +} +inline void ContextInfo::set_conversiondelayseconds(uint32_t value) { + _internal_set_conversiondelayseconds(value); + // @@protoc_insertion_point(field_set:proto.ContextInfo.conversionDelaySeconds) +} + +// optional uint32 forwardingScore = 21; +inline bool ContextInfo::_internal_has_forwardingscore() const { + bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0; + return value; +} +inline bool ContextInfo::has_forwardingscore() const { + return _internal_has_forwardingscore(); +} +inline void ContextInfo::clear_forwardingscore() { + _impl_.forwardingscore_ = 0u; + _impl_._has_bits_[0] &= ~0x00020000u; +} +inline uint32_t ContextInfo::_internal_forwardingscore() const { + return _impl_.forwardingscore_; +} +inline uint32_t ContextInfo::forwardingscore() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.forwardingScore) + return _internal_forwardingscore(); +} +inline void ContextInfo::_internal_set_forwardingscore(uint32_t value) { + _impl_._has_bits_[0] |= 0x00020000u; + _impl_.forwardingscore_ = value; +} +inline void ContextInfo::set_forwardingscore(uint32_t value) { + _internal_set_forwardingscore(value); + // @@protoc_insertion_point(field_set:proto.ContextInfo.forwardingScore) +} + +// optional bool isForwarded = 22; +inline bool ContextInfo::_internal_has_isforwarded() const { + bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0; + return value; +} +inline bool ContextInfo::has_isforwarded() const { + return _internal_has_isforwarded(); +} +inline void ContextInfo::clear_isforwarded() { + _impl_.isforwarded_ = false; + _impl_._has_bits_[0] &= ~0x00040000u; +} +inline bool ContextInfo::_internal_isforwarded() const { + return _impl_.isforwarded_; +} +inline bool ContextInfo::isforwarded() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.isForwarded) + return _internal_isforwarded(); +} +inline void ContextInfo::_internal_set_isforwarded(bool value) { + _impl_._has_bits_[0] |= 0x00040000u; + _impl_.isforwarded_ = value; +} +inline void ContextInfo::set_isforwarded(bool value) { + _internal_set_isforwarded(value); + // @@protoc_insertion_point(field_set:proto.ContextInfo.isForwarded) +} + +// optional .proto.ContextInfo.AdReplyInfo quotedAd = 23; +inline bool ContextInfo::_internal_has_quotedad() const { + bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; + PROTOBUF_ASSUME(!value || _impl_.quotedad_ != nullptr); + return value; +} +inline bool ContextInfo::has_quotedad() const { + return _internal_has_quotedad(); +} +inline void ContextInfo::clear_quotedad() { + if (_impl_.quotedad_ != nullptr) _impl_.quotedad_->Clear(); + _impl_._has_bits_[0] &= ~0x00000800u; +} +inline const ::proto::ContextInfo_AdReplyInfo& ContextInfo::_internal_quotedad() const { + const ::proto::ContextInfo_AdReplyInfo* p = _impl_.quotedad_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ContextInfo_AdReplyInfo_default_instance_); +} +inline const ::proto::ContextInfo_AdReplyInfo& ContextInfo::quotedad() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.quotedAd) + return _internal_quotedad(); +} +inline void ContextInfo::unsafe_arena_set_allocated_quotedad( + ::proto::ContextInfo_AdReplyInfo* quotedad) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quotedad_); + } + _impl_.quotedad_ = quotedad; + if (quotedad) { + _impl_._has_bits_[0] |= 0x00000800u; + } else { + _impl_._has_bits_[0] &= ~0x00000800u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ContextInfo.quotedAd) +} +inline ::proto::ContextInfo_AdReplyInfo* ContextInfo::release_quotedad() { + _impl_._has_bits_[0] &= ~0x00000800u; + ::proto::ContextInfo_AdReplyInfo* temp = _impl_.quotedad_; + _impl_.quotedad_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ContextInfo_AdReplyInfo* ContextInfo::unsafe_arena_release_quotedad() { + // @@protoc_insertion_point(field_release:proto.ContextInfo.quotedAd) + _impl_._has_bits_[0] &= ~0x00000800u; + ::proto::ContextInfo_AdReplyInfo* temp = _impl_.quotedad_; + _impl_.quotedad_ = nullptr; + return temp; +} +inline ::proto::ContextInfo_AdReplyInfo* ContextInfo::_internal_mutable_quotedad() { + _impl_._has_bits_[0] |= 0x00000800u; + if (_impl_.quotedad_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ContextInfo_AdReplyInfo>(GetArenaForAllocation()); + _impl_.quotedad_ = p; + } + return _impl_.quotedad_; +} +inline ::proto::ContextInfo_AdReplyInfo* ContextInfo::mutable_quotedad() { + ::proto::ContextInfo_AdReplyInfo* _msg = _internal_mutable_quotedad(); + // @@protoc_insertion_point(field_mutable:proto.ContextInfo.quotedAd) + return _msg; +} +inline void ContextInfo::set_allocated_quotedad(::proto::ContextInfo_AdReplyInfo* quotedad) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.quotedad_; + } + if (quotedad) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quotedad); + if (message_arena != submessage_arena) { + quotedad = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, quotedad, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000800u; + } else { + _impl_._has_bits_[0] &= ~0x00000800u; + } + _impl_.quotedad_ = quotedad; + // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.quotedAd) +} + +// optional .proto.MessageKey placeholderKey = 24; +inline bool ContextInfo::_internal_has_placeholderkey() const { + bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.placeholderkey_ != nullptr); + return value; +} +inline bool ContextInfo::has_placeholderkey() const { + return _internal_has_placeholderkey(); +} +inline void ContextInfo::clear_placeholderkey() { + if (_impl_.placeholderkey_ != nullptr) _impl_.placeholderkey_->Clear(); + _impl_._has_bits_[0] &= ~0x00001000u; +} +inline const ::proto::MessageKey& ContextInfo::_internal_placeholderkey() const { + const ::proto::MessageKey* p = _impl_.placeholderkey_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_MessageKey_default_instance_); +} +inline const ::proto::MessageKey& ContextInfo::placeholderkey() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.placeholderKey) + return _internal_placeholderkey(); +} +inline void ContextInfo::unsafe_arena_set_allocated_placeholderkey( + ::proto::MessageKey* placeholderkey) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.placeholderkey_); + } + _impl_.placeholderkey_ = placeholderkey; + if (placeholderkey) { + _impl_._has_bits_[0] |= 0x00001000u; + } else { + _impl_._has_bits_[0] &= ~0x00001000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ContextInfo.placeholderKey) +} +inline ::proto::MessageKey* ContextInfo::release_placeholderkey() { + _impl_._has_bits_[0] &= ~0x00001000u; + ::proto::MessageKey* temp = _impl_.placeholderkey_; + _impl_.placeholderkey_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::MessageKey* ContextInfo::unsafe_arena_release_placeholderkey() { + // @@protoc_insertion_point(field_release:proto.ContextInfo.placeholderKey) + _impl_._has_bits_[0] &= ~0x00001000u; + ::proto::MessageKey* temp = _impl_.placeholderkey_; + _impl_.placeholderkey_ = nullptr; + return temp; +} +inline ::proto::MessageKey* ContextInfo::_internal_mutable_placeholderkey() { + _impl_._has_bits_[0] |= 0x00001000u; + if (_impl_.placeholderkey_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation()); + _impl_.placeholderkey_ = p; + } + return _impl_.placeholderkey_; +} +inline ::proto::MessageKey* ContextInfo::mutable_placeholderkey() { + ::proto::MessageKey* _msg = _internal_mutable_placeholderkey(); + // @@protoc_insertion_point(field_mutable:proto.ContextInfo.placeholderKey) + return _msg; +} +inline void ContextInfo::set_allocated_placeholderkey(::proto::MessageKey* placeholderkey) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.placeholderkey_; + } + if (placeholderkey) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(placeholderkey); + if (message_arena != submessage_arena) { + placeholderkey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, placeholderkey, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00001000u; + } else { + _impl_._has_bits_[0] &= ~0x00001000u; + } + _impl_.placeholderkey_ = placeholderkey; + // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.placeholderKey) +} + +// optional uint32 expiration = 25; +inline bool ContextInfo::_internal_has_expiration() const { + bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0; + return value; +} +inline bool ContextInfo::has_expiration() const { + return _internal_has_expiration(); +} +inline void ContextInfo::clear_expiration() { + _impl_.expiration_ = 0u; + _impl_._has_bits_[0] &= ~0x00080000u; +} +inline uint32_t ContextInfo::_internal_expiration() const { + return _impl_.expiration_; +} +inline uint32_t ContextInfo::expiration() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.expiration) + return _internal_expiration(); +} +inline void ContextInfo::_internal_set_expiration(uint32_t value) { + _impl_._has_bits_[0] |= 0x00080000u; + _impl_.expiration_ = value; +} +inline void ContextInfo::set_expiration(uint32_t value) { + _internal_set_expiration(value); + // @@protoc_insertion_point(field_set:proto.ContextInfo.expiration) +} + +// optional int64 ephemeralSettingTimestamp = 26; +inline bool ContextInfo::_internal_has_ephemeralsettingtimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0; + return value; +} +inline bool ContextInfo::has_ephemeralsettingtimestamp() const { + return _internal_has_ephemeralsettingtimestamp(); +} +inline void ContextInfo::clear_ephemeralsettingtimestamp() { + _impl_.ephemeralsettingtimestamp_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00100000u; +} +inline int64_t ContextInfo::_internal_ephemeralsettingtimestamp() const { + return _impl_.ephemeralsettingtimestamp_; +} +inline int64_t ContextInfo::ephemeralsettingtimestamp() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.ephemeralSettingTimestamp) + return _internal_ephemeralsettingtimestamp(); +} +inline void ContextInfo::_internal_set_ephemeralsettingtimestamp(int64_t value) { + _impl_._has_bits_[0] |= 0x00100000u; + _impl_.ephemeralsettingtimestamp_ = value; +} +inline void ContextInfo::set_ephemeralsettingtimestamp(int64_t value) { + _internal_set_ephemeralsettingtimestamp(value); + // @@protoc_insertion_point(field_set:proto.ContextInfo.ephemeralSettingTimestamp) +} + +// optional bytes ephemeralSharedSecret = 27; +inline bool ContextInfo::_internal_has_ephemeralsharedsecret() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool ContextInfo::has_ephemeralsharedsecret() const { + return _internal_has_ephemeralsharedsecret(); +} +inline void ContextInfo::clear_ephemeralsharedsecret() { + _impl_.ephemeralsharedsecret_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline const std::string& ContextInfo::ephemeralsharedsecret() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.ephemeralSharedSecret) + return _internal_ephemeralsharedsecret(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ContextInfo::set_ephemeralsharedsecret(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.ephemeralsharedsecret_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ContextInfo.ephemeralSharedSecret) +} +inline std::string* ContextInfo::mutable_ephemeralsharedsecret() { + std::string* _s = _internal_mutable_ephemeralsharedsecret(); + // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ephemeralSharedSecret) + return _s; +} +inline const std::string& ContextInfo::_internal_ephemeralsharedsecret() const { + return _impl_.ephemeralsharedsecret_.Get(); +} +inline void ContextInfo::_internal_set_ephemeralsharedsecret(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.ephemeralsharedsecret_.Set(value, GetArenaForAllocation()); +} +inline std::string* ContextInfo::_internal_mutable_ephemeralsharedsecret() { + _impl_._has_bits_[0] |= 0x00000020u; + return _impl_.ephemeralsharedsecret_.Mutable(GetArenaForAllocation()); +} +inline std::string* ContextInfo::release_ephemeralsharedsecret() { + // @@protoc_insertion_point(field_release:proto.ContextInfo.ephemeralSharedSecret) + if (!_internal_has_ephemeralsharedsecret()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000020u; + auto* p = _impl_.ephemeralsharedsecret_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.ephemeralsharedsecret_.IsDefault()) { + _impl_.ephemeralsharedsecret_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ContextInfo::set_allocated_ephemeralsharedsecret(std::string* ephemeralsharedsecret) { + if (ephemeralsharedsecret != nullptr) { + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + _impl_.ephemeralsharedsecret_.SetAllocated(ephemeralsharedsecret, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.ephemeralsharedsecret_.IsDefault()) { + _impl_.ephemeralsharedsecret_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ephemeralSharedSecret) +} + +// optional .proto.ContextInfo.ExternalAdReplyInfo externalAdReply = 28; +inline bool ContextInfo::_internal_has_externaladreply() const { + bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.externaladreply_ != nullptr); + return value; +} +inline bool ContextInfo::has_externaladreply() const { + return _internal_has_externaladreply(); +} +inline void ContextInfo::clear_externaladreply() { + if (_impl_.externaladreply_ != nullptr) _impl_.externaladreply_->Clear(); + _impl_._has_bits_[0] &= ~0x00002000u; +} +inline const ::proto::ContextInfo_ExternalAdReplyInfo& ContextInfo::_internal_externaladreply() const { + const ::proto::ContextInfo_ExternalAdReplyInfo* p = _impl_.externaladreply_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ContextInfo_ExternalAdReplyInfo_default_instance_); +} +inline const ::proto::ContextInfo_ExternalAdReplyInfo& ContextInfo::externaladreply() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.externalAdReply) + return _internal_externaladreply(); +} +inline void ContextInfo::unsafe_arena_set_allocated_externaladreply( + ::proto::ContextInfo_ExternalAdReplyInfo* externaladreply) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.externaladreply_); + } + _impl_.externaladreply_ = externaladreply; + if (externaladreply) { + _impl_._has_bits_[0] |= 0x00002000u; + } else { + _impl_._has_bits_[0] &= ~0x00002000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ContextInfo.externalAdReply) +} +inline ::proto::ContextInfo_ExternalAdReplyInfo* ContextInfo::release_externaladreply() { + _impl_._has_bits_[0] &= ~0x00002000u; + ::proto::ContextInfo_ExternalAdReplyInfo* temp = _impl_.externaladreply_; + _impl_.externaladreply_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ContextInfo_ExternalAdReplyInfo* ContextInfo::unsafe_arena_release_externaladreply() { + // @@protoc_insertion_point(field_release:proto.ContextInfo.externalAdReply) + _impl_._has_bits_[0] &= ~0x00002000u; + ::proto::ContextInfo_ExternalAdReplyInfo* temp = _impl_.externaladreply_; + _impl_.externaladreply_ = nullptr; + return temp; +} +inline ::proto::ContextInfo_ExternalAdReplyInfo* ContextInfo::_internal_mutable_externaladreply() { + _impl_._has_bits_[0] |= 0x00002000u; + if (_impl_.externaladreply_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ContextInfo_ExternalAdReplyInfo>(GetArenaForAllocation()); + _impl_.externaladreply_ = p; + } + return _impl_.externaladreply_; +} +inline ::proto::ContextInfo_ExternalAdReplyInfo* ContextInfo::mutable_externaladreply() { + ::proto::ContextInfo_ExternalAdReplyInfo* _msg = _internal_mutable_externaladreply(); + // @@protoc_insertion_point(field_mutable:proto.ContextInfo.externalAdReply) + return _msg; +} +inline void ContextInfo::set_allocated_externaladreply(::proto::ContextInfo_ExternalAdReplyInfo* externaladreply) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.externaladreply_; + } + if (externaladreply) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(externaladreply); + if (message_arena != submessage_arena) { + externaladreply = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, externaladreply, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00002000u; + } else { + _impl_._has_bits_[0] &= ~0x00002000u; + } + _impl_.externaladreply_ = externaladreply; + // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.externalAdReply) +} + +// optional string entryPointConversionSource = 29; +inline bool ContextInfo::_internal_has_entrypointconversionsource() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool ContextInfo::has_entrypointconversionsource() const { + return _internal_has_entrypointconversionsource(); +} +inline void ContextInfo::clear_entrypointconversionsource() { + _impl_.entrypointconversionsource_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline const std::string& ContextInfo::entrypointconversionsource() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.entryPointConversionSource) + return _internal_entrypointconversionsource(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ContextInfo::set_entrypointconversionsource(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.entrypointconversionsource_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ContextInfo.entryPointConversionSource) +} +inline std::string* ContextInfo::mutable_entrypointconversionsource() { + std::string* _s = _internal_mutable_entrypointconversionsource(); + // @@protoc_insertion_point(field_mutable:proto.ContextInfo.entryPointConversionSource) + return _s; +} +inline const std::string& ContextInfo::_internal_entrypointconversionsource() const { + return _impl_.entrypointconversionsource_.Get(); +} +inline void ContextInfo::_internal_set_entrypointconversionsource(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.entrypointconversionsource_.Set(value, GetArenaForAllocation()); +} +inline std::string* ContextInfo::_internal_mutable_entrypointconversionsource() { + _impl_._has_bits_[0] |= 0x00000040u; + return _impl_.entrypointconversionsource_.Mutable(GetArenaForAllocation()); +} +inline std::string* ContextInfo::release_entrypointconversionsource() { + // @@protoc_insertion_point(field_release:proto.ContextInfo.entryPointConversionSource) + if (!_internal_has_entrypointconversionsource()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000040u; + auto* p = _impl_.entrypointconversionsource_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.entrypointconversionsource_.IsDefault()) { + _impl_.entrypointconversionsource_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ContextInfo::set_allocated_entrypointconversionsource(std::string* entrypointconversionsource) { + if (entrypointconversionsource != nullptr) { + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + _impl_.entrypointconversionsource_.SetAllocated(entrypointconversionsource, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.entrypointconversionsource_.IsDefault()) { + _impl_.entrypointconversionsource_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.entryPointConversionSource) +} + +// optional string entryPointConversionApp = 30; +inline bool ContextInfo::_internal_has_entrypointconversionapp() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool ContextInfo::has_entrypointconversionapp() const { + return _internal_has_entrypointconversionapp(); +} +inline void ContextInfo::clear_entrypointconversionapp() { + _impl_.entrypointconversionapp_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline const std::string& ContextInfo::entrypointconversionapp() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.entryPointConversionApp) + return _internal_entrypointconversionapp(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ContextInfo::set_entrypointconversionapp(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.entrypointconversionapp_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ContextInfo.entryPointConversionApp) +} +inline std::string* ContextInfo::mutable_entrypointconversionapp() { + std::string* _s = _internal_mutable_entrypointconversionapp(); + // @@protoc_insertion_point(field_mutable:proto.ContextInfo.entryPointConversionApp) + return _s; +} +inline const std::string& ContextInfo::_internal_entrypointconversionapp() const { + return _impl_.entrypointconversionapp_.Get(); +} +inline void ContextInfo::_internal_set_entrypointconversionapp(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.entrypointconversionapp_.Set(value, GetArenaForAllocation()); +} +inline std::string* ContextInfo::_internal_mutable_entrypointconversionapp() { + _impl_._has_bits_[0] |= 0x00000080u; + return _impl_.entrypointconversionapp_.Mutable(GetArenaForAllocation()); +} +inline std::string* ContextInfo::release_entrypointconversionapp() { + // @@protoc_insertion_point(field_release:proto.ContextInfo.entryPointConversionApp) + if (!_internal_has_entrypointconversionapp()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000080u; + auto* p = _impl_.entrypointconversionapp_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.entrypointconversionapp_.IsDefault()) { + _impl_.entrypointconversionapp_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ContextInfo::set_allocated_entrypointconversionapp(std::string* entrypointconversionapp) { + if (entrypointconversionapp != nullptr) { + _impl_._has_bits_[0] |= 0x00000080u; + } else { + _impl_._has_bits_[0] &= ~0x00000080u; + } + _impl_.entrypointconversionapp_.SetAllocated(entrypointconversionapp, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.entrypointconversionapp_.IsDefault()) { + _impl_.entrypointconversionapp_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.entryPointConversionApp) +} + +// optional uint32 entryPointConversionDelaySeconds = 31; +inline bool ContextInfo::_internal_has_entrypointconversiondelayseconds() const { + bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0; + return value; +} +inline bool ContextInfo::has_entrypointconversiondelayseconds() const { + return _internal_has_entrypointconversiondelayseconds(); +} +inline void ContextInfo::clear_entrypointconversiondelayseconds() { + _impl_.entrypointconversiondelayseconds_ = 0u; + _impl_._has_bits_[0] &= ~0x00200000u; +} +inline uint32_t ContextInfo::_internal_entrypointconversiondelayseconds() const { + return _impl_.entrypointconversiondelayseconds_; +} +inline uint32_t ContextInfo::entrypointconversiondelayseconds() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.entryPointConversionDelaySeconds) + return _internal_entrypointconversiondelayseconds(); +} +inline void ContextInfo::_internal_set_entrypointconversiondelayseconds(uint32_t value) { + _impl_._has_bits_[0] |= 0x00200000u; + _impl_.entrypointconversiondelayseconds_ = value; +} +inline void ContextInfo::set_entrypointconversiondelayseconds(uint32_t value) { + _internal_set_entrypointconversiondelayseconds(value); + // @@protoc_insertion_point(field_set:proto.ContextInfo.entryPointConversionDelaySeconds) +} + +// optional .proto.DisappearingMode disappearingMode = 32; +inline bool ContextInfo::_internal_has_disappearingmode() const { + bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.disappearingmode_ != nullptr); + return value; +} +inline bool ContextInfo::has_disappearingmode() const { + return _internal_has_disappearingmode(); +} +inline void ContextInfo::clear_disappearingmode() { + if (_impl_.disappearingmode_ != nullptr) _impl_.disappearingmode_->Clear(); + _impl_._has_bits_[0] &= ~0x00004000u; +} +inline const ::proto::DisappearingMode& ContextInfo::_internal_disappearingmode() const { + const ::proto::DisappearingMode* p = _impl_.disappearingmode_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_DisappearingMode_default_instance_); +} +inline const ::proto::DisappearingMode& ContextInfo::disappearingmode() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.disappearingMode) + return _internal_disappearingmode(); +} +inline void ContextInfo::unsafe_arena_set_allocated_disappearingmode( + ::proto::DisappearingMode* disappearingmode) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.disappearingmode_); + } + _impl_.disappearingmode_ = disappearingmode; + if (disappearingmode) { + _impl_._has_bits_[0] |= 0x00004000u; + } else { + _impl_._has_bits_[0] &= ~0x00004000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ContextInfo.disappearingMode) +} +inline ::proto::DisappearingMode* ContextInfo::release_disappearingmode() { + _impl_._has_bits_[0] &= ~0x00004000u; + ::proto::DisappearingMode* temp = _impl_.disappearingmode_; + _impl_.disappearingmode_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::DisappearingMode* ContextInfo::unsafe_arena_release_disappearingmode() { + // @@protoc_insertion_point(field_release:proto.ContextInfo.disappearingMode) + _impl_._has_bits_[0] &= ~0x00004000u; + ::proto::DisappearingMode* temp = _impl_.disappearingmode_; + _impl_.disappearingmode_ = nullptr; + return temp; +} +inline ::proto::DisappearingMode* ContextInfo::_internal_mutable_disappearingmode() { + _impl_._has_bits_[0] |= 0x00004000u; + if (_impl_.disappearingmode_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::DisappearingMode>(GetArenaForAllocation()); + _impl_.disappearingmode_ = p; + } + return _impl_.disappearingmode_; +} +inline ::proto::DisappearingMode* ContextInfo::mutable_disappearingmode() { + ::proto::DisappearingMode* _msg = _internal_mutable_disappearingmode(); + // @@protoc_insertion_point(field_mutable:proto.ContextInfo.disappearingMode) + return _msg; +} +inline void ContextInfo::set_allocated_disappearingmode(::proto::DisappearingMode* disappearingmode) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.disappearingmode_; + } + if (disappearingmode) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(disappearingmode); + if (message_arena != submessage_arena) { + disappearingmode = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, disappearingmode, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00004000u; + } else { + _impl_._has_bits_[0] &= ~0x00004000u; + } + _impl_.disappearingmode_ = disappearingmode; + // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.disappearingMode) +} + +// optional .proto.ActionLink actionLink = 33; +inline bool ContextInfo::_internal_has_actionlink() const { + bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.actionlink_ != nullptr); + return value; +} +inline bool ContextInfo::has_actionlink() const { + return _internal_has_actionlink(); +} +inline void ContextInfo::clear_actionlink() { + if (_impl_.actionlink_ != nullptr) _impl_.actionlink_->Clear(); + _impl_._has_bits_[0] &= ~0x00008000u; +} +inline const ::proto::ActionLink& ContextInfo::_internal_actionlink() const { + const ::proto::ActionLink* p = _impl_.actionlink_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ActionLink_default_instance_); +} +inline const ::proto::ActionLink& ContextInfo::actionlink() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.actionLink) + return _internal_actionlink(); +} +inline void ContextInfo::unsafe_arena_set_allocated_actionlink( + ::proto::ActionLink* actionlink) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.actionlink_); + } + _impl_.actionlink_ = actionlink; + if (actionlink) { + _impl_._has_bits_[0] |= 0x00008000u; + } else { + _impl_._has_bits_[0] &= ~0x00008000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ContextInfo.actionLink) +} +inline ::proto::ActionLink* ContextInfo::release_actionlink() { + _impl_._has_bits_[0] &= ~0x00008000u; + ::proto::ActionLink* temp = _impl_.actionlink_; + _impl_.actionlink_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ActionLink* ContextInfo::unsafe_arena_release_actionlink() { + // @@protoc_insertion_point(field_release:proto.ContextInfo.actionLink) + _impl_._has_bits_[0] &= ~0x00008000u; + ::proto::ActionLink* temp = _impl_.actionlink_; + _impl_.actionlink_ = nullptr; + return temp; +} +inline ::proto::ActionLink* ContextInfo::_internal_mutable_actionlink() { + _impl_._has_bits_[0] |= 0x00008000u; + if (_impl_.actionlink_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ActionLink>(GetArenaForAllocation()); + _impl_.actionlink_ = p; + } + return _impl_.actionlink_; +} +inline ::proto::ActionLink* ContextInfo::mutable_actionlink() { + ::proto::ActionLink* _msg = _internal_mutable_actionlink(); + // @@protoc_insertion_point(field_mutable:proto.ContextInfo.actionLink) + return _msg; +} +inline void ContextInfo::set_allocated_actionlink(::proto::ActionLink* actionlink) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.actionlink_; + } + if (actionlink) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(actionlink); + if (message_arena != submessage_arena) { + actionlink = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, actionlink, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00008000u; + } else { + _impl_._has_bits_[0] &= ~0x00008000u; + } + _impl_.actionlink_ = actionlink; + // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.actionLink) +} + +// optional string groupSubject = 34; +inline bool ContextInfo::_internal_has_groupsubject() const { + bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool ContextInfo::has_groupsubject() const { + return _internal_has_groupsubject(); +} +inline void ContextInfo::clear_groupsubject() { + _impl_.groupsubject_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000100u; +} +inline const std::string& ContextInfo::groupsubject() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.groupSubject) + return _internal_groupsubject(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ContextInfo::set_groupsubject(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.groupsubject_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ContextInfo.groupSubject) +} +inline std::string* ContextInfo::mutable_groupsubject() { + std::string* _s = _internal_mutable_groupsubject(); + // @@protoc_insertion_point(field_mutable:proto.ContextInfo.groupSubject) + return _s; +} +inline const std::string& ContextInfo::_internal_groupsubject() const { + return _impl_.groupsubject_.Get(); +} +inline void ContextInfo::_internal_set_groupsubject(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.groupsubject_.Set(value, GetArenaForAllocation()); +} +inline std::string* ContextInfo::_internal_mutable_groupsubject() { + _impl_._has_bits_[0] |= 0x00000100u; + return _impl_.groupsubject_.Mutable(GetArenaForAllocation()); +} +inline std::string* ContextInfo::release_groupsubject() { + // @@protoc_insertion_point(field_release:proto.ContextInfo.groupSubject) + if (!_internal_has_groupsubject()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000100u; + auto* p = _impl_.groupsubject_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.groupsubject_.IsDefault()) { + _impl_.groupsubject_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ContextInfo::set_allocated_groupsubject(std::string* groupsubject) { + if (groupsubject != nullptr) { + _impl_._has_bits_[0] |= 0x00000100u; + } else { + _impl_._has_bits_[0] &= ~0x00000100u; + } + _impl_.groupsubject_.SetAllocated(groupsubject, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.groupsubject_.IsDefault()) { + _impl_.groupsubject_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.groupSubject) +} + +// optional string parentGroupJid = 35; +inline bool ContextInfo::_internal_has_parentgroupjid() const { + bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool ContextInfo::has_parentgroupjid() const { + return _internal_has_parentgroupjid(); +} +inline void ContextInfo::clear_parentgroupjid() { + _impl_.parentgroupjid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000200u; +} +inline const std::string& ContextInfo::parentgroupjid() const { + // @@protoc_insertion_point(field_get:proto.ContextInfo.parentGroupJid) + return _internal_parentgroupjid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ContextInfo::set_parentgroupjid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.parentgroupjid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ContextInfo.parentGroupJid) +} +inline std::string* ContextInfo::mutable_parentgroupjid() { + std::string* _s = _internal_mutable_parentgroupjid(); + // @@protoc_insertion_point(field_mutable:proto.ContextInfo.parentGroupJid) + return _s; +} +inline const std::string& ContextInfo::_internal_parentgroupjid() const { + return _impl_.parentgroupjid_.Get(); +} +inline void ContextInfo::_internal_set_parentgroupjid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.parentgroupjid_.Set(value, GetArenaForAllocation()); +} +inline std::string* ContextInfo::_internal_mutable_parentgroupjid() { + _impl_._has_bits_[0] |= 0x00000200u; + return _impl_.parentgroupjid_.Mutable(GetArenaForAllocation()); +} +inline std::string* ContextInfo::release_parentgroupjid() { + // @@protoc_insertion_point(field_release:proto.ContextInfo.parentGroupJid) + if (!_internal_has_parentgroupjid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000200u; + auto* p = _impl_.parentgroupjid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.parentgroupjid_.IsDefault()) { + _impl_.parentgroupjid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ContextInfo::set_allocated_parentgroupjid(std::string* parentgroupjid) { + if (parentgroupjid != nullptr) { + _impl_._has_bits_[0] |= 0x00000200u; + } else { + _impl_._has_bits_[0] &= ~0x00000200u; + } + _impl_.parentgroupjid_.SetAllocated(parentgroupjid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.parentgroupjid_.IsDefault()) { + _impl_.parentgroupjid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.parentGroupJid) +} + +// ------------------------------------------------------------------- + +// Conversation + +// required string id = 1; +inline bool Conversation::_internal_has_id() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Conversation::has_id() const { + return _internal_has_id(); +} +inline void Conversation::clear_id() { + _impl_.id_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Conversation::id() const { + // @@protoc_insertion_point(field_get:proto.Conversation.id) + return _internal_id(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Conversation::set_id(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.id_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Conversation.id) +} +inline std::string* Conversation::mutable_id() { + std::string* _s = _internal_mutable_id(); + // @@protoc_insertion_point(field_mutable:proto.Conversation.id) + return _s; +} +inline const std::string& Conversation::_internal_id() const { + return _impl_.id_.Get(); +} +inline void Conversation::_internal_set_id(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.id_.Set(value, GetArenaForAllocation()); +} +inline std::string* Conversation::_internal_mutable_id() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.id_.Mutable(GetArenaForAllocation()); +} +inline std::string* Conversation::release_id() { + // @@protoc_insertion_point(field_release:proto.Conversation.id) + if (!_internal_has_id()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.id_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.id_.IsDefault()) { + _impl_.id_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Conversation::set_allocated_id(std::string* id) { + if (id != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.id_.SetAllocated(id, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.id_.IsDefault()) { + _impl_.id_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Conversation.id) +} + +// repeated .proto.HistorySyncMsg messages = 2; +inline int Conversation::_internal_messages_size() const { + return _impl_.messages_.size(); +} +inline int Conversation::messages_size() const { + return _internal_messages_size(); +} +inline void Conversation::clear_messages() { + _impl_.messages_.Clear(); +} +inline ::proto::HistorySyncMsg* Conversation::mutable_messages(int index) { + // @@protoc_insertion_point(field_mutable:proto.Conversation.messages) + return _impl_.messages_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HistorySyncMsg >* +Conversation::mutable_messages() { + // @@protoc_insertion_point(field_mutable_list:proto.Conversation.messages) + return &_impl_.messages_; +} +inline const ::proto::HistorySyncMsg& Conversation::_internal_messages(int index) const { + return _impl_.messages_.Get(index); +} +inline const ::proto::HistorySyncMsg& Conversation::messages(int index) const { + // @@protoc_insertion_point(field_get:proto.Conversation.messages) + return _internal_messages(index); +} +inline ::proto::HistorySyncMsg* Conversation::_internal_add_messages() { + return _impl_.messages_.Add(); +} +inline ::proto::HistorySyncMsg* Conversation::add_messages() { + ::proto::HistorySyncMsg* _add = _internal_add_messages(); + // @@protoc_insertion_point(field_add:proto.Conversation.messages) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HistorySyncMsg >& +Conversation::messages() const { + // @@protoc_insertion_point(field_list:proto.Conversation.messages) + return _impl_.messages_; +} + +// optional string newJid = 3; +inline bool Conversation::_internal_has_newjid() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Conversation::has_newjid() const { + return _internal_has_newjid(); +} +inline void Conversation::clear_newjid() { + _impl_.newjid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Conversation::newjid() const { + // @@protoc_insertion_point(field_get:proto.Conversation.newJid) + return _internal_newjid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Conversation::set_newjid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.newjid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Conversation.newJid) +} +inline std::string* Conversation::mutable_newjid() { + std::string* _s = _internal_mutable_newjid(); + // @@protoc_insertion_point(field_mutable:proto.Conversation.newJid) + return _s; +} +inline const std::string& Conversation::_internal_newjid() const { + return _impl_.newjid_.Get(); +} +inline void Conversation::_internal_set_newjid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.newjid_.Set(value, GetArenaForAllocation()); +} +inline std::string* Conversation::_internal_mutable_newjid() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.newjid_.Mutable(GetArenaForAllocation()); +} +inline std::string* Conversation::release_newjid() { + // @@protoc_insertion_point(field_release:proto.Conversation.newJid) + if (!_internal_has_newjid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.newjid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.newjid_.IsDefault()) { + _impl_.newjid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Conversation::set_allocated_newjid(std::string* newjid) { + if (newjid != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.newjid_.SetAllocated(newjid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.newjid_.IsDefault()) { + _impl_.newjid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Conversation.newJid) +} + +// optional string oldJid = 4; +inline bool Conversation::_internal_has_oldjid() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Conversation::has_oldjid() const { + return _internal_has_oldjid(); +} +inline void Conversation::clear_oldjid() { + _impl_.oldjid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& Conversation::oldjid() const { + // @@protoc_insertion_point(field_get:proto.Conversation.oldJid) + return _internal_oldjid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Conversation::set_oldjid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.oldjid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Conversation.oldJid) +} +inline std::string* Conversation::mutable_oldjid() { + std::string* _s = _internal_mutable_oldjid(); + // @@protoc_insertion_point(field_mutable:proto.Conversation.oldJid) + return _s; +} +inline const std::string& Conversation::_internal_oldjid() const { + return _impl_.oldjid_.Get(); +} +inline void Conversation::_internal_set_oldjid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.oldjid_.Set(value, GetArenaForAllocation()); +} +inline std::string* Conversation::_internal_mutable_oldjid() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.oldjid_.Mutable(GetArenaForAllocation()); +} +inline std::string* Conversation::release_oldjid() { + // @@protoc_insertion_point(field_release:proto.Conversation.oldJid) + if (!_internal_has_oldjid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.oldjid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.oldjid_.IsDefault()) { + _impl_.oldjid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Conversation::set_allocated_oldjid(std::string* oldjid) { + if (oldjid != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.oldjid_.SetAllocated(oldjid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.oldjid_.IsDefault()) { + _impl_.oldjid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Conversation.oldJid) +} + +// optional uint64 lastMsgTimestamp = 5; +inline bool Conversation::_internal_has_lastmsgtimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0; + return value; +} +inline bool Conversation::has_lastmsgtimestamp() const { + return _internal_has_lastmsgtimestamp(); +} +inline void Conversation::clear_lastmsgtimestamp() { + _impl_.lastmsgtimestamp_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00004000u; +} +inline uint64_t Conversation::_internal_lastmsgtimestamp() const { + return _impl_.lastmsgtimestamp_; +} +inline uint64_t Conversation::lastmsgtimestamp() const { + // @@protoc_insertion_point(field_get:proto.Conversation.lastMsgTimestamp) + return _internal_lastmsgtimestamp(); +} +inline void Conversation::_internal_set_lastmsgtimestamp(uint64_t value) { + _impl_._has_bits_[0] |= 0x00004000u; + _impl_.lastmsgtimestamp_ = value; +} +inline void Conversation::set_lastmsgtimestamp(uint64_t value) { + _internal_set_lastmsgtimestamp(value); + // @@protoc_insertion_point(field_set:proto.Conversation.lastMsgTimestamp) +} + +// optional uint32 unreadCount = 6; +inline bool Conversation::_internal_has_unreadcount() const { + bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0; + return value; +} +inline bool Conversation::has_unreadcount() const { + return _internal_has_unreadcount(); +} +inline void Conversation::clear_unreadcount() { + _impl_.unreadcount_ = 0u; + _impl_._has_bits_[0] &= ~0x00008000u; +} +inline uint32_t Conversation::_internal_unreadcount() const { + return _impl_.unreadcount_; +} +inline uint32_t Conversation::unreadcount() const { + // @@protoc_insertion_point(field_get:proto.Conversation.unreadCount) + return _internal_unreadcount(); +} +inline void Conversation::_internal_set_unreadcount(uint32_t value) { + _impl_._has_bits_[0] |= 0x00008000u; + _impl_.unreadcount_ = value; +} +inline void Conversation::set_unreadcount(uint32_t value) { + _internal_set_unreadcount(value); + // @@protoc_insertion_point(field_set:proto.Conversation.unreadCount) +} + +// optional bool readOnly = 7; +inline bool Conversation::_internal_has_readonly() const { + bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0; + return value; +} +inline bool Conversation::has_readonly() const { + return _internal_has_readonly(); +} +inline void Conversation::clear_readonly() { + _impl_.readonly_ = false; + _impl_._has_bits_[0] &= ~0x00080000u; +} +inline bool Conversation::_internal_readonly() const { + return _impl_.readonly_; +} +inline bool Conversation::readonly() const { + // @@protoc_insertion_point(field_get:proto.Conversation.readOnly) + return _internal_readonly(); +} +inline void Conversation::_internal_set_readonly(bool value) { + _impl_._has_bits_[0] |= 0x00080000u; + _impl_.readonly_ = value; +} +inline void Conversation::set_readonly(bool value) { + _internal_set_readonly(value); + // @@protoc_insertion_point(field_set:proto.Conversation.readOnly) +} + +// optional bool endOfHistoryTransfer = 8; +inline bool Conversation::_internal_has_endofhistorytransfer() const { + bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0; + return value; +} +inline bool Conversation::has_endofhistorytransfer() const { + return _internal_has_endofhistorytransfer(); +} +inline void Conversation::clear_endofhistorytransfer() { + _impl_.endofhistorytransfer_ = false; + _impl_._has_bits_[0] &= ~0x00100000u; +} +inline bool Conversation::_internal_endofhistorytransfer() const { + return _impl_.endofhistorytransfer_; +} +inline bool Conversation::endofhistorytransfer() const { + // @@protoc_insertion_point(field_get:proto.Conversation.endOfHistoryTransfer) + return _internal_endofhistorytransfer(); +} +inline void Conversation::_internal_set_endofhistorytransfer(bool value) { + _impl_._has_bits_[0] |= 0x00100000u; + _impl_.endofhistorytransfer_ = value; +} +inline void Conversation::set_endofhistorytransfer(bool value) { + _internal_set_endofhistorytransfer(value); + // @@protoc_insertion_point(field_set:proto.Conversation.endOfHistoryTransfer) +} + +// optional uint32 ephemeralExpiration = 9; +inline bool Conversation::_internal_has_ephemeralexpiration() const { + bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0; + return value; +} +inline bool Conversation::has_ephemeralexpiration() const { + return _internal_has_ephemeralexpiration(); +} +inline void Conversation::clear_ephemeralexpiration() { + _impl_.ephemeralexpiration_ = 0u; + _impl_._has_bits_[0] &= ~0x00010000u; +} +inline uint32_t Conversation::_internal_ephemeralexpiration() const { + return _impl_.ephemeralexpiration_; +} +inline uint32_t Conversation::ephemeralexpiration() const { + // @@protoc_insertion_point(field_get:proto.Conversation.ephemeralExpiration) + return _internal_ephemeralexpiration(); +} +inline void Conversation::_internal_set_ephemeralexpiration(uint32_t value) { + _impl_._has_bits_[0] |= 0x00010000u; + _impl_.ephemeralexpiration_ = value; +} +inline void Conversation::set_ephemeralexpiration(uint32_t value) { + _internal_set_ephemeralexpiration(value); + // @@protoc_insertion_point(field_set:proto.Conversation.ephemeralExpiration) +} + +// optional int64 ephemeralSettingTimestamp = 10; +inline bool Conversation::_internal_has_ephemeralsettingtimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0; + return value; +} +inline bool Conversation::has_ephemeralsettingtimestamp() const { + return _internal_has_ephemeralsettingtimestamp(); +} +inline void Conversation::clear_ephemeralsettingtimestamp() { + _impl_.ephemeralsettingtimestamp_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00020000u; +} +inline int64_t Conversation::_internal_ephemeralsettingtimestamp() const { + return _impl_.ephemeralsettingtimestamp_; +} +inline int64_t Conversation::ephemeralsettingtimestamp() const { + // @@protoc_insertion_point(field_get:proto.Conversation.ephemeralSettingTimestamp) + return _internal_ephemeralsettingtimestamp(); +} +inline void Conversation::_internal_set_ephemeralsettingtimestamp(int64_t value) { + _impl_._has_bits_[0] |= 0x00020000u; + _impl_.ephemeralsettingtimestamp_ = value; +} +inline void Conversation::set_ephemeralsettingtimestamp(int64_t value) { + _internal_set_ephemeralsettingtimestamp(value); + // @@protoc_insertion_point(field_set:proto.Conversation.ephemeralSettingTimestamp) +} + +// optional .proto.Conversation.EndOfHistoryTransferType endOfHistoryTransferType = 11; +inline bool Conversation::_internal_has_endofhistorytransfertype() const { + bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0; + return value; +} +inline bool Conversation::has_endofhistorytransfertype() const { + return _internal_has_endofhistorytransfertype(); +} +inline void Conversation::clear_endofhistorytransfertype() { + _impl_.endofhistorytransfertype_ = 0; + _impl_._has_bits_[0] &= ~0x00040000u; +} +inline ::proto::Conversation_EndOfHistoryTransferType Conversation::_internal_endofhistorytransfertype() const { + return static_cast< ::proto::Conversation_EndOfHistoryTransferType >(_impl_.endofhistorytransfertype_); +} +inline ::proto::Conversation_EndOfHistoryTransferType Conversation::endofhistorytransfertype() const { + // @@protoc_insertion_point(field_get:proto.Conversation.endOfHistoryTransferType) + return _internal_endofhistorytransfertype(); +} +inline void Conversation::_internal_set_endofhistorytransfertype(::proto::Conversation_EndOfHistoryTransferType value) { + assert(::proto::Conversation_EndOfHistoryTransferType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00040000u; + _impl_.endofhistorytransfertype_ = value; +} +inline void Conversation::set_endofhistorytransfertype(::proto::Conversation_EndOfHistoryTransferType value) { + _internal_set_endofhistorytransfertype(value); + // @@protoc_insertion_point(field_set:proto.Conversation.endOfHistoryTransferType) +} + +// optional uint64 conversationTimestamp = 12; +inline bool Conversation::_internal_has_conversationtimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0; + return value; +} +inline bool Conversation::has_conversationtimestamp() const { + return _internal_has_conversationtimestamp(); +} +inline void Conversation::clear_conversationtimestamp() { + _impl_.conversationtimestamp_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00800000u; +} +inline uint64_t Conversation::_internal_conversationtimestamp() const { + return _impl_.conversationtimestamp_; +} +inline uint64_t Conversation::conversationtimestamp() const { + // @@protoc_insertion_point(field_get:proto.Conversation.conversationTimestamp) + return _internal_conversationtimestamp(); +} +inline void Conversation::_internal_set_conversationtimestamp(uint64_t value) { + _impl_._has_bits_[0] |= 0x00800000u; + _impl_.conversationtimestamp_ = value; +} +inline void Conversation::set_conversationtimestamp(uint64_t value) { + _internal_set_conversationtimestamp(value); + // @@protoc_insertion_point(field_set:proto.Conversation.conversationTimestamp) +} + +// optional string name = 13; +inline bool Conversation::_internal_has_name() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool Conversation::has_name() const { + return _internal_has_name(); +} +inline void Conversation::clear_name() { + _impl_.name_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const std::string& Conversation::name() const { + // @@protoc_insertion_point(field_get:proto.Conversation.name) + return _internal_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Conversation::set_name(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Conversation.name) +} +inline std::string* Conversation::mutable_name() { + std::string* _s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:proto.Conversation.name) + return _s; +} +inline const std::string& Conversation::_internal_name() const { + return _impl_.name_.Get(); +} +inline void Conversation::_internal_set_name(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.name_.Set(value, GetArenaForAllocation()); +} +inline std::string* Conversation::_internal_mutable_name() { + _impl_._has_bits_[0] |= 0x00000008u; + return _impl_.name_.Mutable(GetArenaForAllocation()); +} +inline std::string* Conversation::release_name() { + // @@protoc_insertion_point(field_release:proto.Conversation.name) + if (!_internal_has_name()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000008u; + auto* p = _impl_.name_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.name_.IsDefault()) { + _impl_.name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Conversation::set_allocated_name(std::string* name) { + if (name != nullptr) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.name_.SetAllocated(name, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.name_.IsDefault()) { + _impl_.name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Conversation.name) +} + +// optional string pHash = 14; +inline bool Conversation::_internal_has_phash() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool Conversation::has_phash() const { + return _internal_has_phash(); +} +inline void Conversation::clear_phash() { + _impl_.phash_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const std::string& Conversation::phash() const { + // @@protoc_insertion_point(field_get:proto.Conversation.pHash) + return _internal_phash(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Conversation::set_phash(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.phash_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Conversation.pHash) +} +inline std::string* Conversation::mutable_phash() { + std::string* _s = _internal_mutable_phash(); + // @@protoc_insertion_point(field_mutable:proto.Conversation.pHash) + return _s; +} +inline const std::string& Conversation::_internal_phash() const { + return _impl_.phash_.Get(); +} +inline void Conversation::_internal_set_phash(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.phash_.Set(value, GetArenaForAllocation()); +} +inline std::string* Conversation::_internal_mutable_phash() { + _impl_._has_bits_[0] |= 0x00000010u; + return _impl_.phash_.Mutable(GetArenaForAllocation()); +} +inline std::string* Conversation::release_phash() { + // @@protoc_insertion_point(field_release:proto.Conversation.pHash) + if (!_internal_has_phash()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000010u; + auto* p = _impl_.phash_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.phash_.IsDefault()) { + _impl_.phash_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Conversation::set_allocated_phash(std::string* phash) { + if (phash != nullptr) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.phash_.SetAllocated(phash, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.phash_.IsDefault()) { + _impl_.phash_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Conversation.pHash) +} + +// optional bool notSpam = 15; +inline bool Conversation::_internal_has_notspam() const { + bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0; + return value; +} +inline bool Conversation::has_notspam() const { + return _internal_has_notspam(); +} +inline void Conversation::clear_notspam() { + _impl_.notspam_ = false; + _impl_._has_bits_[0] &= ~0x00200000u; +} +inline bool Conversation::_internal_notspam() const { + return _impl_.notspam_; +} +inline bool Conversation::notspam() const { + // @@protoc_insertion_point(field_get:proto.Conversation.notSpam) + return _internal_notspam(); +} +inline void Conversation::_internal_set_notspam(bool value) { + _impl_._has_bits_[0] |= 0x00200000u; + _impl_.notspam_ = value; +} +inline void Conversation::set_notspam(bool value) { + _internal_set_notspam(value); + // @@protoc_insertion_point(field_set:proto.Conversation.notSpam) +} + +// optional bool archived = 16; +inline bool Conversation::_internal_has_archived() const { + bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0; + return value; +} +inline bool Conversation::has_archived() const { + return _internal_has_archived(); +} +inline void Conversation::clear_archived() { + _impl_.archived_ = false; + _impl_._has_bits_[0] &= ~0x00400000u; +} +inline bool Conversation::_internal_archived() const { + return _impl_.archived_; +} +inline bool Conversation::archived() const { + // @@protoc_insertion_point(field_get:proto.Conversation.archived) + return _internal_archived(); +} +inline void Conversation::_internal_set_archived(bool value) { + _impl_._has_bits_[0] |= 0x00400000u; + _impl_.archived_ = value; +} +inline void Conversation::set_archived(bool value) { + _internal_set_archived(value); + // @@protoc_insertion_point(field_set:proto.Conversation.archived) +} + +// optional .proto.DisappearingMode disappearingMode = 17; +inline bool Conversation::_internal_has_disappearingmode() const { + bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.disappearingmode_ != nullptr); + return value; +} +inline bool Conversation::has_disappearingmode() const { + return _internal_has_disappearingmode(); +} +inline void Conversation::clear_disappearingmode() { + if (_impl_.disappearingmode_ != nullptr) _impl_.disappearingmode_->Clear(); + _impl_._has_bits_[0] &= ~0x00001000u; +} +inline const ::proto::DisappearingMode& Conversation::_internal_disappearingmode() const { + const ::proto::DisappearingMode* p = _impl_.disappearingmode_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_DisappearingMode_default_instance_); +} +inline const ::proto::DisappearingMode& Conversation::disappearingmode() const { + // @@protoc_insertion_point(field_get:proto.Conversation.disappearingMode) + return _internal_disappearingmode(); +} +inline void Conversation::unsafe_arena_set_allocated_disappearingmode( + ::proto::DisappearingMode* disappearingmode) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.disappearingmode_); + } + _impl_.disappearingmode_ = disappearingmode; + if (disappearingmode) { + _impl_._has_bits_[0] |= 0x00001000u; + } else { + _impl_._has_bits_[0] &= ~0x00001000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Conversation.disappearingMode) +} +inline ::proto::DisappearingMode* Conversation::release_disappearingmode() { + _impl_._has_bits_[0] &= ~0x00001000u; + ::proto::DisappearingMode* temp = _impl_.disappearingmode_; + _impl_.disappearingmode_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::DisappearingMode* Conversation::unsafe_arena_release_disappearingmode() { + // @@protoc_insertion_point(field_release:proto.Conversation.disappearingMode) + _impl_._has_bits_[0] &= ~0x00001000u; + ::proto::DisappearingMode* temp = _impl_.disappearingmode_; + _impl_.disappearingmode_ = nullptr; + return temp; +} +inline ::proto::DisappearingMode* Conversation::_internal_mutable_disappearingmode() { + _impl_._has_bits_[0] |= 0x00001000u; + if (_impl_.disappearingmode_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::DisappearingMode>(GetArenaForAllocation()); + _impl_.disappearingmode_ = p; + } + return _impl_.disappearingmode_; +} +inline ::proto::DisappearingMode* Conversation::mutable_disappearingmode() { + ::proto::DisappearingMode* _msg = _internal_mutable_disappearingmode(); + // @@protoc_insertion_point(field_mutable:proto.Conversation.disappearingMode) + return _msg; +} +inline void Conversation::set_allocated_disappearingmode(::proto::DisappearingMode* disappearingmode) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.disappearingmode_; + } + if (disappearingmode) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(disappearingmode); + if (message_arena != submessage_arena) { + disappearingmode = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, disappearingmode, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00001000u; + } else { + _impl_._has_bits_[0] &= ~0x00001000u; + } + _impl_.disappearingmode_ = disappearingmode; + // @@protoc_insertion_point(field_set_allocated:proto.Conversation.disappearingMode) +} + +// optional uint32 unreadMentionCount = 18; +inline bool Conversation::_internal_has_unreadmentioncount() const { + bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0; + return value; +} +inline bool Conversation::has_unreadmentioncount() const { + return _internal_has_unreadmentioncount(); +} +inline void Conversation::clear_unreadmentioncount() { + _impl_.unreadmentioncount_ = 0u; + _impl_._has_bits_[0] &= ~0x01000000u; +} +inline uint32_t Conversation::_internal_unreadmentioncount() const { + return _impl_.unreadmentioncount_; +} +inline uint32_t Conversation::unreadmentioncount() const { + // @@protoc_insertion_point(field_get:proto.Conversation.unreadMentionCount) + return _internal_unreadmentioncount(); +} +inline void Conversation::_internal_set_unreadmentioncount(uint32_t value) { + _impl_._has_bits_[0] |= 0x01000000u; + _impl_.unreadmentioncount_ = value; +} +inline void Conversation::set_unreadmentioncount(uint32_t value) { + _internal_set_unreadmentioncount(value); + // @@protoc_insertion_point(field_set:proto.Conversation.unreadMentionCount) +} + +// optional bool markedAsUnread = 19; +inline bool Conversation::_internal_has_markedasunread() const { + bool value = (_impl_._has_bits_[0] & 0x20000000u) != 0; + return value; +} +inline bool Conversation::has_markedasunread() const { + return _internal_has_markedasunread(); +} +inline void Conversation::clear_markedasunread() { + _impl_.markedasunread_ = false; + _impl_._has_bits_[0] &= ~0x20000000u; +} +inline bool Conversation::_internal_markedasunread() const { + return _impl_.markedasunread_; +} +inline bool Conversation::markedasunread() const { + // @@protoc_insertion_point(field_get:proto.Conversation.markedAsUnread) + return _internal_markedasunread(); +} +inline void Conversation::_internal_set_markedasunread(bool value) { + _impl_._has_bits_[0] |= 0x20000000u; + _impl_.markedasunread_ = value; +} +inline void Conversation::set_markedasunread(bool value) { + _internal_set_markedasunread(value); + // @@protoc_insertion_point(field_set:proto.Conversation.markedAsUnread) +} + +// repeated .proto.GroupParticipant participant = 20; +inline int Conversation::_internal_participant_size() const { + return _impl_.participant_.size(); +} +inline int Conversation::participant_size() const { + return _internal_participant_size(); +} +inline void Conversation::clear_participant() { + _impl_.participant_.Clear(); +} +inline ::proto::GroupParticipant* Conversation::mutable_participant(int index) { + // @@protoc_insertion_point(field_mutable:proto.Conversation.participant) + return _impl_.participant_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::GroupParticipant >* +Conversation::mutable_participant() { + // @@protoc_insertion_point(field_mutable_list:proto.Conversation.participant) + return &_impl_.participant_; +} +inline const ::proto::GroupParticipant& Conversation::_internal_participant(int index) const { + return _impl_.participant_.Get(index); +} +inline const ::proto::GroupParticipant& Conversation::participant(int index) const { + // @@protoc_insertion_point(field_get:proto.Conversation.participant) + return _internal_participant(index); +} +inline ::proto::GroupParticipant* Conversation::_internal_add_participant() { + return _impl_.participant_.Add(); +} +inline ::proto::GroupParticipant* Conversation::add_participant() { + ::proto::GroupParticipant* _add = _internal_add_participant(); + // @@protoc_insertion_point(field_add:proto.Conversation.participant) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::GroupParticipant >& +Conversation::participant() const { + // @@protoc_insertion_point(field_list:proto.Conversation.participant) + return _impl_.participant_; +} + +// optional bytes tcToken = 21; +inline bool Conversation::_internal_has_tctoken() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool Conversation::has_tctoken() const { + return _internal_has_tctoken(); +} +inline void Conversation::clear_tctoken() { + _impl_.tctoken_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline const std::string& Conversation::tctoken() const { + // @@protoc_insertion_point(field_get:proto.Conversation.tcToken) + return _internal_tctoken(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Conversation::set_tctoken(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.tctoken_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Conversation.tcToken) +} +inline std::string* Conversation::mutable_tctoken() { + std::string* _s = _internal_mutable_tctoken(); + // @@protoc_insertion_point(field_mutable:proto.Conversation.tcToken) + return _s; +} +inline const std::string& Conversation::_internal_tctoken() const { + return _impl_.tctoken_.Get(); +} +inline void Conversation::_internal_set_tctoken(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.tctoken_.Set(value, GetArenaForAllocation()); +} +inline std::string* Conversation::_internal_mutable_tctoken() { + _impl_._has_bits_[0] |= 0x00000020u; + return _impl_.tctoken_.Mutable(GetArenaForAllocation()); +} +inline std::string* Conversation::release_tctoken() { + // @@protoc_insertion_point(field_release:proto.Conversation.tcToken) + if (!_internal_has_tctoken()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000020u; + auto* p = _impl_.tctoken_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.tctoken_.IsDefault()) { + _impl_.tctoken_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Conversation::set_allocated_tctoken(std::string* tctoken) { + if (tctoken != nullptr) { + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + _impl_.tctoken_.SetAllocated(tctoken, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.tctoken_.IsDefault()) { + _impl_.tctoken_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Conversation.tcToken) +} + +// optional uint64 tcTokenTimestamp = 22; +inline bool Conversation::_internal_has_tctokentimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0; + return value; +} +inline bool Conversation::has_tctokentimestamp() const { + return _internal_has_tctokentimestamp(); +} +inline void Conversation::clear_tctokentimestamp() { + _impl_.tctokentimestamp_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x04000000u; +} +inline uint64_t Conversation::_internal_tctokentimestamp() const { + return _impl_.tctokentimestamp_; +} +inline uint64_t Conversation::tctokentimestamp() const { + // @@protoc_insertion_point(field_get:proto.Conversation.tcTokenTimestamp) + return _internal_tctokentimestamp(); +} +inline void Conversation::_internal_set_tctokentimestamp(uint64_t value) { + _impl_._has_bits_[0] |= 0x04000000u; + _impl_.tctokentimestamp_ = value; +} +inline void Conversation::set_tctokentimestamp(uint64_t value) { + _internal_set_tctokentimestamp(value); + // @@protoc_insertion_point(field_set:proto.Conversation.tcTokenTimestamp) +} + +// optional bytes contactPrimaryIdentityKey = 23; +inline bool Conversation::_internal_has_contactprimaryidentitykey() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool Conversation::has_contactprimaryidentitykey() const { + return _internal_has_contactprimaryidentitykey(); +} +inline void Conversation::clear_contactprimaryidentitykey() { + _impl_.contactprimaryidentitykey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline const std::string& Conversation::contactprimaryidentitykey() const { + // @@protoc_insertion_point(field_get:proto.Conversation.contactPrimaryIdentityKey) + return _internal_contactprimaryidentitykey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Conversation::set_contactprimaryidentitykey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.contactprimaryidentitykey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Conversation.contactPrimaryIdentityKey) +} +inline std::string* Conversation::mutable_contactprimaryidentitykey() { + std::string* _s = _internal_mutable_contactprimaryidentitykey(); + // @@protoc_insertion_point(field_mutable:proto.Conversation.contactPrimaryIdentityKey) + return _s; +} +inline const std::string& Conversation::_internal_contactprimaryidentitykey() const { + return _impl_.contactprimaryidentitykey_.Get(); +} +inline void Conversation::_internal_set_contactprimaryidentitykey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.contactprimaryidentitykey_.Set(value, GetArenaForAllocation()); +} +inline std::string* Conversation::_internal_mutable_contactprimaryidentitykey() { + _impl_._has_bits_[0] |= 0x00000040u; + return _impl_.contactprimaryidentitykey_.Mutable(GetArenaForAllocation()); +} +inline std::string* Conversation::release_contactprimaryidentitykey() { + // @@protoc_insertion_point(field_release:proto.Conversation.contactPrimaryIdentityKey) + if (!_internal_has_contactprimaryidentitykey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000040u; + auto* p = _impl_.contactprimaryidentitykey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.contactprimaryidentitykey_.IsDefault()) { + _impl_.contactprimaryidentitykey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Conversation::set_allocated_contactprimaryidentitykey(std::string* contactprimaryidentitykey) { + if (contactprimaryidentitykey != nullptr) { + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + _impl_.contactprimaryidentitykey_.SetAllocated(contactprimaryidentitykey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.contactprimaryidentitykey_.IsDefault()) { + _impl_.contactprimaryidentitykey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Conversation.contactPrimaryIdentityKey) +} + +// optional uint32 pinned = 24; +inline bool Conversation::_internal_has_pinned() const { + bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0; + return value; +} +inline bool Conversation::has_pinned() const { + return _internal_has_pinned(); +} +inline void Conversation::clear_pinned() { + _impl_.pinned_ = 0u; + _impl_._has_bits_[0] &= ~0x02000000u; +} +inline uint32_t Conversation::_internal_pinned() const { + return _impl_.pinned_; +} +inline uint32_t Conversation::pinned() const { + // @@protoc_insertion_point(field_get:proto.Conversation.pinned) + return _internal_pinned(); +} +inline void Conversation::_internal_set_pinned(uint32_t value) { + _impl_._has_bits_[0] |= 0x02000000u; + _impl_.pinned_ = value; +} +inline void Conversation::set_pinned(uint32_t value) { + _internal_set_pinned(value); + // @@protoc_insertion_point(field_set:proto.Conversation.pinned) +} + +// optional uint64 muteEndTime = 25; +inline bool Conversation::_internal_has_muteendtime() const { + bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0; + return value; +} +inline bool Conversation::has_muteendtime() const { + return _internal_has_muteendtime(); +} +inline void Conversation::clear_muteendtime() { + _impl_.muteendtime_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x08000000u; +} +inline uint64_t Conversation::_internal_muteendtime() const { + return _impl_.muteendtime_; +} +inline uint64_t Conversation::muteendtime() const { + // @@protoc_insertion_point(field_get:proto.Conversation.muteEndTime) + return _internal_muteendtime(); +} +inline void Conversation::_internal_set_muteendtime(uint64_t value) { + _impl_._has_bits_[0] |= 0x08000000u; + _impl_.muteendtime_ = value; +} +inline void Conversation::set_muteendtime(uint64_t value) { + _internal_set_muteendtime(value); + // @@protoc_insertion_point(field_set:proto.Conversation.muteEndTime) +} + +// optional .proto.WallpaperSettings wallpaper = 26; +inline bool Conversation::_internal_has_wallpaper() const { + bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.wallpaper_ != nullptr); + return value; +} +inline bool Conversation::has_wallpaper() const { + return _internal_has_wallpaper(); +} +inline void Conversation::clear_wallpaper() { + if (_impl_.wallpaper_ != nullptr) _impl_.wallpaper_->Clear(); + _impl_._has_bits_[0] &= ~0x00002000u; +} +inline const ::proto::WallpaperSettings& Conversation::_internal_wallpaper() const { + const ::proto::WallpaperSettings* p = _impl_.wallpaper_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_WallpaperSettings_default_instance_); +} +inline const ::proto::WallpaperSettings& Conversation::wallpaper() const { + // @@protoc_insertion_point(field_get:proto.Conversation.wallpaper) + return _internal_wallpaper(); +} +inline void Conversation::unsafe_arena_set_allocated_wallpaper( + ::proto::WallpaperSettings* wallpaper) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.wallpaper_); + } + _impl_.wallpaper_ = wallpaper; + if (wallpaper) { + _impl_._has_bits_[0] |= 0x00002000u; + } else { + _impl_._has_bits_[0] &= ~0x00002000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Conversation.wallpaper) +} +inline ::proto::WallpaperSettings* Conversation::release_wallpaper() { + _impl_._has_bits_[0] &= ~0x00002000u; + ::proto::WallpaperSettings* temp = _impl_.wallpaper_; + _impl_.wallpaper_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::WallpaperSettings* Conversation::unsafe_arena_release_wallpaper() { + // @@protoc_insertion_point(field_release:proto.Conversation.wallpaper) + _impl_._has_bits_[0] &= ~0x00002000u; + ::proto::WallpaperSettings* temp = _impl_.wallpaper_; + _impl_.wallpaper_ = nullptr; + return temp; +} +inline ::proto::WallpaperSettings* Conversation::_internal_mutable_wallpaper() { + _impl_._has_bits_[0] |= 0x00002000u; + if (_impl_.wallpaper_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::WallpaperSettings>(GetArenaForAllocation()); + _impl_.wallpaper_ = p; + } + return _impl_.wallpaper_; +} +inline ::proto::WallpaperSettings* Conversation::mutable_wallpaper() { + ::proto::WallpaperSettings* _msg = _internal_mutable_wallpaper(); + // @@protoc_insertion_point(field_mutable:proto.Conversation.wallpaper) + return _msg; +} +inline void Conversation::set_allocated_wallpaper(::proto::WallpaperSettings* wallpaper) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.wallpaper_; + } + if (wallpaper) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(wallpaper); + if (message_arena != submessage_arena) { + wallpaper = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, wallpaper, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00002000u; + } else { + _impl_._has_bits_[0] &= ~0x00002000u; + } + _impl_.wallpaper_ = wallpaper; + // @@protoc_insertion_point(field_set_allocated:proto.Conversation.wallpaper) +} + +// optional .proto.MediaVisibility mediaVisibility = 27; +inline bool Conversation::_internal_has_mediavisibility() const { + bool value = (_impl_._has_bits_[0] & 0x10000000u) != 0; + return value; +} +inline bool Conversation::has_mediavisibility() const { + return _internal_has_mediavisibility(); +} +inline void Conversation::clear_mediavisibility() { + _impl_.mediavisibility_ = 0; + _impl_._has_bits_[0] &= ~0x10000000u; +} +inline ::proto::MediaVisibility Conversation::_internal_mediavisibility() const { + return static_cast< ::proto::MediaVisibility >(_impl_.mediavisibility_); +} +inline ::proto::MediaVisibility Conversation::mediavisibility() const { + // @@protoc_insertion_point(field_get:proto.Conversation.mediaVisibility) + return _internal_mediavisibility(); +} +inline void Conversation::_internal_set_mediavisibility(::proto::MediaVisibility value) { + assert(::proto::MediaVisibility_IsValid(value)); + _impl_._has_bits_[0] |= 0x10000000u; + _impl_.mediavisibility_ = value; +} +inline void Conversation::set_mediavisibility(::proto::MediaVisibility value) { + _internal_set_mediavisibility(value); + // @@protoc_insertion_point(field_set:proto.Conversation.mediaVisibility) +} + +// optional uint64 tcTokenSenderTimestamp = 28; +inline bool Conversation::_internal_has_tctokensendertimestamp() const { + bool value = (_impl_._has_bits_[1] & 0x00000002u) != 0; + return value; +} +inline bool Conversation::has_tctokensendertimestamp() const { + return _internal_has_tctokensendertimestamp(); +} +inline void Conversation::clear_tctokensendertimestamp() { + _impl_.tctokensendertimestamp_ = uint64_t{0u}; + _impl_._has_bits_[1] &= ~0x00000002u; +} +inline uint64_t Conversation::_internal_tctokensendertimestamp() const { + return _impl_.tctokensendertimestamp_; +} +inline uint64_t Conversation::tctokensendertimestamp() const { + // @@protoc_insertion_point(field_get:proto.Conversation.tcTokenSenderTimestamp) + return _internal_tctokensendertimestamp(); +} +inline void Conversation::_internal_set_tctokensendertimestamp(uint64_t value) { + _impl_._has_bits_[1] |= 0x00000002u; + _impl_.tctokensendertimestamp_ = value; +} +inline void Conversation::set_tctokensendertimestamp(uint64_t value) { + _internal_set_tctokensendertimestamp(value); + // @@protoc_insertion_point(field_set:proto.Conversation.tcTokenSenderTimestamp) +} + +// optional bool suspended = 29; +inline bool Conversation::_internal_has_suspended() const { + bool value = (_impl_._has_bits_[0] & 0x40000000u) != 0; + return value; +} +inline bool Conversation::has_suspended() const { + return _internal_has_suspended(); +} +inline void Conversation::clear_suspended() { + _impl_.suspended_ = false; + _impl_._has_bits_[0] &= ~0x40000000u; +} +inline bool Conversation::_internal_suspended() const { + return _impl_.suspended_; +} +inline bool Conversation::suspended() const { + // @@protoc_insertion_point(field_get:proto.Conversation.suspended) + return _internal_suspended(); +} +inline void Conversation::_internal_set_suspended(bool value) { + _impl_._has_bits_[0] |= 0x40000000u; + _impl_.suspended_ = value; +} +inline void Conversation::set_suspended(bool value) { + _internal_set_suspended(value); + // @@protoc_insertion_point(field_set:proto.Conversation.suspended) +} + +// optional bool terminated = 30; +inline bool Conversation::_internal_has_terminated() const { + bool value = (_impl_._has_bits_[0] & 0x80000000u) != 0; + return value; +} +inline bool Conversation::has_terminated() const { + return _internal_has_terminated(); +} +inline void Conversation::clear_terminated() { + _impl_.terminated_ = false; + _impl_._has_bits_[0] &= ~0x80000000u; +} +inline bool Conversation::_internal_terminated() const { + return _impl_.terminated_; +} +inline bool Conversation::terminated() const { + // @@protoc_insertion_point(field_get:proto.Conversation.terminated) + return _internal_terminated(); +} +inline void Conversation::_internal_set_terminated(bool value) { + _impl_._has_bits_[0] |= 0x80000000u; + _impl_.terminated_ = value; +} +inline void Conversation::set_terminated(bool value) { + _internal_set_terminated(value); + // @@protoc_insertion_point(field_set:proto.Conversation.terminated) +} + +// optional uint64 createdAt = 31; +inline bool Conversation::_internal_has_createdat() const { + bool value = (_impl_._has_bits_[1] & 0x00000004u) != 0; + return value; +} +inline bool Conversation::has_createdat() const { + return _internal_has_createdat(); +} +inline void Conversation::clear_createdat() { + _impl_.createdat_ = uint64_t{0u}; + _impl_._has_bits_[1] &= ~0x00000004u; +} +inline uint64_t Conversation::_internal_createdat() const { + return _impl_.createdat_; +} +inline uint64_t Conversation::createdat() const { + // @@protoc_insertion_point(field_get:proto.Conversation.createdAt) + return _internal_createdat(); +} +inline void Conversation::_internal_set_createdat(uint64_t value) { + _impl_._has_bits_[1] |= 0x00000004u; + _impl_.createdat_ = value; +} +inline void Conversation::set_createdat(uint64_t value) { + _internal_set_createdat(value); + // @@protoc_insertion_point(field_set:proto.Conversation.createdAt) +} + +// optional string createdBy = 32; +inline bool Conversation::_internal_has_createdby() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool Conversation::has_createdby() const { + return _internal_has_createdby(); +} +inline void Conversation::clear_createdby() { + _impl_.createdby_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline const std::string& Conversation::createdby() const { + // @@protoc_insertion_point(field_get:proto.Conversation.createdBy) + return _internal_createdby(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Conversation::set_createdby(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.createdby_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Conversation.createdBy) +} +inline std::string* Conversation::mutable_createdby() { + std::string* _s = _internal_mutable_createdby(); + // @@protoc_insertion_point(field_mutable:proto.Conversation.createdBy) + return _s; +} +inline const std::string& Conversation::_internal_createdby() const { + return _impl_.createdby_.Get(); +} +inline void Conversation::_internal_set_createdby(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.createdby_.Set(value, GetArenaForAllocation()); +} +inline std::string* Conversation::_internal_mutable_createdby() { + _impl_._has_bits_[0] |= 0x00000080u; + return _impl_.createdby_.Mutable(GetArenaForAllocation()); +} +inline std::string* Conversation::release_createdby() { + // @@protoc_insertion_point(field_release:proto.Conversation.createdBy) + if (!_internal_has_createdby()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000080u; + auto* p = _impl_.createdby_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.createdby_.IsDefault()) { + _impl_.createdby_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Conversation::set_allocated_createdby(std::string* createdby) { + if (createdby != nullptr) { + _impl_._has_bits_[0] |= 0x00000080u; + } else { + _impl_._has_bits_[0] &= ~0x00000080u; + } + _impl_.createdby_.SetAllocated(createdby, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.createdby_.IsDefault()) { + _impl_.createdby_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Conversation.createdBy) +} + +// optional string description = 33; +inline bool Conversation::_internal_has_description() const { + bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool Conversation::has_description() const { + return _internal_has_description(); +} +inline void Conversation::clear_description() { + _impl_.description_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000100u; +} +inline const std::string& Conversation::description() const { + // @@protoc_insertion_point(field_get:proto.Conversation.description) + return _internal_description(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Conversation::set_description(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.description_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Conversation.description) +} +inline std::string* Conversation::mutable_description() { + std::string* _s = _internal_mutable_description(); + // @@protoc_insertion_point(field_mutable:proto.Conversation.description) + return _s; +} +inline const std::string& Conversation::_internal_description() const { + return _impl_.description_.Get(); +} +inline void Conversation::_internal_set_description(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.description_.Set(value, GetArenaForAllocation()); +} +inline std::string* Conversation::_internal_mutable_description() { + _impl_._has_bits_[0] |= 0x00000100u; + return _impl_.description_.Mutable(GetArenaForAllocation()); +} +inline std::string* Conversation::release_description() { + // @@protoc_insertion_point(field_release:proto.Conversation.description) + if (!_internal_has_description()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000100u; + auto* p = _impl_.description_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.description_.IsDefault()) { + _impl_.description_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Conversation::set_allocated_description(std::string* description) { + if (description != nullptr) { + _impl_._has_bits_[0] |= 0x00000100u; + } else { + _impl_._has_bits_[0] &= ~0x00000100u; + } + _impl_.description_.SetAllocated(description, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.description_.IsDefault()) { + _impl_.description_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Conversation.description) +} + +// optional bool support = 34; +inline bool Conversation::_internal_has_support() const { + bool value = (_impl_._has_bits_[1] & 0x00000001u) != 0; + return value; +} +inline bool Conversation::has_support() const { + return _internal_has_support(); +} +inline void Conversation::clear_support() { + _impl_.support_ = false; + _impl_._has_bits_[1] &= ~0x00000001u; +} +inline bool Conversation::_internal_support() const { + return _impl_.support_; +} +inline bool Conversation::support() const { + // @@protoc_insertion_point(field_get:proto.Conversation.support) + return _internal_support(); +} +inline void Conversation::_internal_set_support(bool value) { + _impl_._has_bits_[1] |= 0x00000001u; + _impl_.support_ = value; +} +inline void Conversation::set_support(bool value) { + _internal_set_support(value); + // @@protoc_insertion_point(field_set:proto.Conversation.support) +} + +// optional bool isParentGroup = 35; +inline bool Conversation::_internal_has_isparentgroup() const { + bool value = (_impl_._has_bits_[1] & 0x00000008u) != 0; + return value; +} +inline bool Conversation::has_isparentgroup() const { + return _internal_has_isparentgroup(); +} +inline void Conversation::clear_isparentgroup() { + _impl_.isparentgroup_ = false; + _impl_._has_bits_[1] &= ~0x00000008u; +} +inline bool Conversation::_internal_isparentgroup() const { + return _impl_.isparentgroup_; +} +inline bool Conversation::isparentgroup() const { + // @@protoc_insertion_point(field_get:proto.Conversation.isParentGroup) + return _internal_isparentgroup(); +} +inline void Conversation::_internal_set_isparentgroup(bool value) { + _impl_._has_bits_[1] |= 0x00000008u; + _impl_.isparentgroup_ = value; +} +inline void Conversation::set_isparentgroup(bool value) { + _internal_set_isparentgroup(value); + // @@protoc_insertion_point(field_set:proto.Conversation.isParentGroup) +} + +// optional bool isDefaultSubgroup = 36; +inline bool Conversation::_internal_has_isdefaultsubgroup() const { + bool value = (_impl_._has_bits_[1] & 0x00000010u) != 0; + return value; +} +inline bool Conversation::has_isdefaultsubgroup() const { + return _internal_has_isdefaultsubgroup(); +} +inline void Conversation::clear_isdefaultsubgroup() { + _impl_.isdefaultsubgroup_ = false; + _impl_._has_bits_[1] &= ~0x00000010u; +} +inline bool Conversation::_internal_isdefaultsubgroup() const { + return _impl_.isdefaultsubgroup_; +} +inline bool Conversation::isdefaultsubgroup() const { + // @@protoc_insertion_point(field_get:proto.Conversation.isDefaultSubgroup) + return _internal_isdefaultsubgroup(); +} +inline void Conversation::_internal_set_isdefaultsubgroup(bool value) { + _impl_._has_bits_[1] |= 0x00000010u; + _impl_.isdefaultsubgroup_ = value; +} +inline void Conversation::set_isdefaultsubgroup(bool value) { + _internal_set_isdefaultsubgroup(value); + // @@protoc_insertion_point(field_set:proto.Conversation.isDefaultSubgroup) +} + +// optional string parentGroupId = 37; +inline bool Conversation::_internal_has_parentgroupid() const { + bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool Conversation::has_parentgroupid() const { + return _internal_has_parentgroupid(); +} +inline void Conversation::clear_parentgroupid() { + _impl_.parentgroupid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000200u; +} +inline const std::string& Conversation::parentgroupid() const { + // @@protoc_insertion_point(field_get:proto.Conversation.parentGroupId) + return _internal_parentgroupid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Conversation::set_parentgroupid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.parentgroupid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Conversation.parentGroupId) +} +inline std::string* Conversation::mutable_parentgroupid() { + std::string* _s = _internal_mutable_parentgroupid(); + // @@protoc_insertion_point(field_mutable:proto.Conversation.parentGroupId) + return _s; +} +inline const std::string& Conversation::_internal_parentgroupid() const { + return _impl_.parentgroupid_.Get(); +} +inline void Conversation::_internal_set_parentgroupid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.parentgroupid_.Set(value, GetArenaForAllocation()); +} +inline std::string* Conversation::_internal_mutable_parentgroupid() { + _impl_._has_bits_[0] |= 0x00000200u; + return _impl_.parentgroupid_.Mutable(GetArenaForAllocation()); +} +inline std::string* Conversation::release_parentgroupid() { + // @@protoc_insertion_point(field_release:proto.Conversation.parentGroupId) + if (!_internal_has_parentgroupid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000200u; + auto* p = _impl_.parentgroupid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.parentgroupid_.IsDefault()) { + _impl_.parentgroupid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Conversation::set_allocated_parentgroupid(std::string* parentgroupid) { + if (parentgroupid != nullptr) { + _impl_._has_bits_[0] |= 0x00000200u; + } else { + _impl_._has_bits_[0] &= ~0x00000200u; + } + _impl_.parentgroupid_.SetAllocated(parentgroupid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.parentgroupid_.IsDefault()) { + _impl_.parentgroupid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Conversation.parentGroupId) +} + +// optional string displayName = 38; +inline bool Conversation::_internal_has_displayname() const { + bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool Conversation::has_displayname() const { + return _internal_has_displayname(); +} +inline void Conversation::clear_displayname() { + _impl_.displayname_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000400u; +} +inline const std::string& Conversation::displayname() const { + // @@protoc_insertion_point(field_get:proto.Conversation.displayName) + return _internal_displayname(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Conversation::set_displayname(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000400u; + _impl_.displayname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Conversation.displayName) +} +inline std::string* Conversation::mutable_displayname() { + std::string* _s = _internal_mutable_displayname(); + // @@protoc_insertion_point(field_mutable:proto.Conversation.displayName) + return _s; +} +inline const std::string& Conversation::_internal_displayname() const { + return _impl_.displayname_.Get(); +} +inline void Conversation::_internal_set_displayname(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000400u; + _impl_.displayname_.Set(value, GetArenaForAllocation()); +} +inline std::string* Conversation::_internal_mutable_displayname() { + _impl_._has_bits_[0] |= 0x00000400u; + return _impl_.displayname_.Mutable(GetArenaForAllocation()); +} +inline std::string* Conversation::release_displayname() { + // @@protoc_insertion_point(field_release:proto.Conversation.displayName) + if (!_internal_has_displayname()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000400u; + auto* p = _impl_.displayname_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.displayname_.IsDefault()) { + _impl_.displayname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Conversation::set_allocated_displayname(std::string* displayname) { + if (displayname != nullptr) { + _impl_._has_bits_[0] |= 0x00000400u; + } else { + _impl_._has_bits_[0] &= ~0x00000400u; + } + _impl_.displayname_.SetAllocated(displayname, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.displayname_.IsDefault()) { + _impl_.displayname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Conversation.displayName) +} + +// optional string pnJid = 39; +inline bool Conversation::_internal_has_pnjid() const { + bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; + return value; +} +inline bool Conversation::has_pnjid() const { + return _internal_has_pnjid(); +} +inline void Conversation::clear_pnjid() { + _impl_.pnjid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000800u; +} +inline const std::string& Conversation::pnjid() const { + // @@protoc_insertion_point(field_get:proto.Conversation.pnJid) + return _internal_pnjid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Conversation::set_pnjid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000800u; + _impl_.pnjid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Conversation.pnJid) +} +inline std::string* Conversation::mutable_pnjid() { + std::string* _s = _internal_mutable_pnjid(); + // @@protoc_insertion_point(field_mutable:proto.Conversation.pnJid) + return _s; +} +inline const std::string& Conversation::_internal_pnjid() const { + return _impl_.pnjid_.Get(); +} +inline void Conversation::_internal_set_pnjid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000800u; + _impl_.pnjid_.Set(value, GetArenaForAllocation()); +} +inline std::string* Conversation::_internal_mutable_pnjid() { + _impl_._has_bits_[0] |= 0x00000800u; + return _impl_.pnjid_.Mutable(GetArenaForAllocation()); +} +inline std::string* Conversation::release_pnjid() { + // @@protoc_insertion_point(field_release:proto.Conversation.pnJid) + if (!_internal_has_pnjid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000800u; + auto* p = _impl_.pnjid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.pnjid_.IsDefault()) { + _impl_.pnjid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Conversation::set_allocated_pnjid(std::string* pnjid) { + if (pnjid != nullptr) { + _impl_._has_bits_[0] |= 0x00000800u; + } else { + _impl_._has_bits_[0] &= ~0x00000800u; + } + _impl_.pnjid_.SetAllocated(pnjid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.pnjid_.IsDefault()) { + _impl_.pnjid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Conversation.pnJid) +} + +// optional bool selfPnExposed = 40; +inline bool Conversation::_internal_has_selfpnexposed() const { + bool value = (_impl_._has_bits_[1] & 0x00000020u) != 0; + return value; +} +inline bool Conversation::has_selfpnexposed() const { + return _internal_has_selfpnexposed(); +} +inline void Conversation::clear_selfpnexposed() { + _impl_.selfpnexposed_ = false; + _impl_._has_bits_[1] &= ~0x00000020u; +} +inline bool Conversation::_internal_selfpnexposed() const { + return _impl_.selfpnexposed_; +} +inline bool Conversation::selfpnexposed() const { + // @@protoc_insertion_point(field_get:proto.Conversation.selfPnExposed) + return _internal_selfpnexposed(); +} +inline void Conversation::_internal_set_selfpnexposed(bool value) { + _impl_._has_bits_[1] |= 0x00000020u; + _impl_.selfpnexposed_ = value; +} +inline void Conversation::set_selfpnexposed(bool value) { + _internal_set_selfpnexposed(value); + // @@protoc_insertion_point(field_set:proto.Conversation.selfPnExposed) +} + +// ------------------------------------------------------------------- + +// DeviceListMetadata + +// optional bytes senderKeyHash = 1; +inline bool DeviceListMetadata::_internal_has_senderkeyhash() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool DeviceListMetadata::has_senderkeyhash() const { + return _internal_has_senderkeyhash(); +} +inline void DeviceListMetadata::clear_senderkeyhash() { + _impl_.senderkeyhash_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& DeviceListMetadata::senderkeyhash() const { + // @@protoc_insertion_point(field_get:proto.DeviceListMetadata.senderKeyHash) + return _internal_senderkeyhash(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void DeviceListMetadata::set_senderkeyhash(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.senderkeyhash_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.DeviceListMetadata.senderKeyHash) +} +inline std::string* DeviceListMetadata::mutable_senderkeyhash() { + std::string* _s = _internal_mutable_senderkeyhash(); + // @@protoc_insertion_point(field_mutable:proto.DeviceListMetadata.senderKeyHash) + return _s; +} +inline const std::string& DeviceListMetadata::_internal_senderkeyhash() const { + return _impl_.senderkeyhash_.Get(); +} +inline void DeviceListMetadata::_internal_set_senderkeyhash(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.senderkeyhash_.Set(value, GetArenaForAllocation()); +} +inline std::string* DeviceListMetadata::_internal_mutable_senderkeyhash() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.senderkeyhash_.Mutable(GetArenaForAllocation()); +} +inline std::string* DeviceListMetadata::release_senderkeyhash() { + // @@protoc_insertion_point(field_release:proto.DeviceListMetadata.senderKeyHash) + if (!_internal_has_senderkeyhash()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.senderkeyhash_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.senderkeyhash_.IsDefault()) { + _impl_.senderkeyhash_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void DeviceListMetadata::set_allocated_senderkeyhash(std::string* senderkeyhash) { + if (senderkeyhash != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.senderkeyhash_.SetAllocated(senderkeyhash, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.senderkeyhash_.IsDefault()) { + _impl_.senderkeyhash_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.DeviceListMetadata.senderKeyHash) +} + +// optional uint64 senderTimestamp = 2; +inline bool DeviceListMetadata::_internal_has_sendertimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool DeviceListMetadata::has_sendertimestamp() const { + return _internal_has_sendertimestamp(); +} +inline void DeviceListMetadata::clear_sendertimestamp() { + _impl_.sendertimestamp_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline uint64_t DeviceListMetadata::_internal_sendertimestamp() const { + return _impl_.sendertimestamp_; +} +inline uint64_t DeviceListMetadata::sendertimestamp() const { + // @@protoc_insertion_point(field_get:proto.DeviceListMetadata.senderTimestamp) + return _internal_sendertimestamp(); +} +inline void DeviceListMetadata::_internal_set_sendertimestamp(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.sendertimestamp_ = value; +} +inline void DeviceListMetadata::set_sendertimestamp(uint64_t value) { + _internal_set_sendertimestamp(value); + // @@protoc_insertion_point(field_set:proto.DeviceListMetadata.senderTimestamp) +} + +// repeated uint32 senderKeyIndexes = 3 [packed = true]; +inline int DeviceListMetadata::_internal_senderkeyindexes_size() const { + return _impl_.senderkeyindexes_.size(); +} +inline int DeviceListMetadata::senderkeyindexes_size() const { + return _internal_senderkeyindexes_size(); +} +inline void DeviceListMetadata::clear_senderkeyindexes() { + _impl_.senderkeyindexes_.Clear(); +} +inline uint32_t DeviceListMetadata::_internal_senderkeyindexes(int index) const { + return _impl_.senderkeyindexes_.Get(index); +} +inline uint32_t DeviceListMetadata::senderkeyindexes(int index) const { + // @@protoc_insertion_point(field_get:proto.DeviceListMetadata.senderKeyIndexes) + return _internal_senderkeyindexes(index); +} +inline void DeviceListMetadata::set_senderkeyindexes(int index, uint32_t value) { + _impl_.senderkeyindexes_.Set(index, value); + // @@protoc_insertion_point(field_set:proto.DeviceListMetadata.senderKeyIndexes) +} +inline void DeviceListMetadata::_internal_add_senderkeyindexes(uint32_t value) { + _impl_.senderkeyindexes_.Add(value); +} +inline void DeviceListMetadata::add_senderkeyindexes(uint32_t value) { + _internal_add_senderkeyindexes(value); + // @@protoc_insertion_point(field_add:proto.DeviceListMetadata.senderKeyIndexes) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +DeviceListMetadata::_internal_senderkeyindexes() const { + return _impl_.senderkeyindexes_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +DeviceListMetadata::senderkeyindexes() const { + // @@protoc_insertion_point(field_list:proto.DeviceListMetadata.senderKeyIndexes) + return _internal_senderkeyindexes(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +DeviceListMetadata::_internal_mutable_senderkeyindexes() { + return &_impl_.senderkeyindexes_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +DeviceListMetadata::mutable_senderkeyindexes() { + // @@protoc_insertion_point(field_mutable_list:proto.DeviceListMetadata.senderKeyIndexes) + return _internal_mutable_senderkeyindexes(); +} + +// optional bytes recipientKeyHash = 8; +inline bool DeviceListMetadata::_internal_has_recipientkeyhash() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool DeviceListMetadata::has_recipientkeyhash() const { + return _internal_has_recipientkeyhash(); +} +inline void DeviceListMetadata::clear_recipientkeyhash() { + _impl_.recipientkeyhash_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& DeviceListMetadata::recipientkeyhash() const { + // @@protoc_insertion_point(field_get:proto.DeviceListMetadata.recipientKeyHash) + return _internal_recipientkeyhash(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void DeviceListMetadata::set_recipientkeyhash(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.recipientkeyhash_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.DeviceListMetadata.recipientKeyHash) +} +inline std::string* DeviceListMetadata::mutable_recipientkeyhash() { + std::string* _s = _internal_mutable_recipientkeyhash(); + // @@protoc_insertion_point(field_mutable:proto.DeviceListMetadata.recipientKeyHash) + return _s; +} +inline const std::string& DeviceListMetadata::_internal_recipientkeyhash() const { + return _impl_.recipientkeyhash_.Get(); +} +inline void DeviceListMetadata::_internal_set_recipientkeyhash(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.recipientkeyhash_.Set(value, GetArenaForAllocation()); +} +inline std::string* DeviceListMetadata::_internal_mutable_recipientkeyhash() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.recipientkeyhash_.Mutable(GetArenaForAllocation()); +} +inline std::string* DeviceListMetadata::release_recipientkeyhash() { + // @@protoc_insertion_point(field_release:proto.DeviceListMetadata.recipientKeyHash) + if (!_internal_has_recipientkeyhash()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.recipientkeyhash_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.recipientkeyhash_.IsDefault()) { + _impl_.recipientkeyhash_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void DeviceListMetadata::set_allocated_recipientkeyhash(std::string* recipientkeyhash) { + if (recipientkeyhash != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.recipientkeyhash_.SetAllocated(recipientkeyhash, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.recipientkeyhash_.IsDefault()) { + _impl_.recipientkeyhash_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.DeviceListMetadata.recipientKeyHash) +} + +// optional uint64 recipientTimestamp = 9; +inline bool DeviceListMetadata::_internal_has_recipienttimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool DeviceListMetadata::has_recipienttimestamp() const { + return _internal_has_recipienttimestamp(); +} +inline void DeviceListMetadata::clear_recipienttimestamp() { + _impl_.recipienttimestamp_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline uint64_t DeviceListMetadata::_internal_recipienttimestamp() const { + return _impl_.recipienttimestamp_; +} +inline uint64_t DeviceListMetadata::recipienttimestamp() const { + // @@protoc_insertion_point(field_get:proto.DeviceListMetadata.recipientTimestamp) + return _internal_recipienttimestamp(); +} +inline void DeviceListMetadata::_internal_set_recipienttimestamp(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.recipienttimestamp_ = value; +} +inline void DeviceListMetadata::set_recipienttimestamp(uint64_t value) { + _internal_set_recipienttimestamp(value); + // @@protoc_insertion_point(field_set:proto.DeviceListMetadata.recipientTimestamp) +} + +// repeated uint32 recipientKeyIndexes = 10 [packed = true]; +inline int DeviceListMetadata::_internal_recipientkeyindexes_size() const { + return _impl_.recipientkeyindexes_.size(); +} +inline int DeviceListMetadata::recipientkeyindexes_size() const { + return _internal_recipientkeyindexes_size(); +} +inline void DeviceListMetadata::clear_recipientkeyindexes() { + _impl_.recipientkeyindexes_.Clear(); +} +inline uint32_t DeviceListMetadata::_internal_recipientkeyindexes(int index) const { + return _impl_.recipientkeyindexes_.Get(index); +} +inline uint32_t DeviceListMetadata::recipientkeyindexes(int index) const { + // @@protoc_insertion_point(field_get:proto.DeviceListMetadata.recipientKeyIndexes) + return _internal_recipientkeyindexes(index); +} +inline void DeviceListMetadata::set_recipientkeyindexes(int index, uint32_t value) { + _impl_.recipientkeyindexes_.Set(index, value); + // @@protoc_insertion_point(field_set:proto.DeviceListMetadata.recipientKeyIndexes) +} +inline void DeviceListMetadata::_internal_add_recipientkeyindexes(uint32_t value) { + _impl_.recipientkeyindexes_.Add(value); +} +inline void DeviceListMetadata::add_recipientkeyindexes(uint32_t value) { + _internal_add_recipientkeyindexes(value); + // @@protoc_insertion_point(field_add:proto.DeviceListMetadata.recipientKeyIndexes) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +DeviceListMetadata::_internal_recipientkeyindexes() const { + return _impl_.recipientkeyindexes_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +DeviceListMetadata::recipientkeyindexes() const { + // @@protoc_insertion_point(field_list:proto.DeviceListMetadata.recipientKeyIndexes) + return _internal_recipientkeyindexes(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +DeviceListMetadata::_internal_mutable_recipientkeyindexes() { + return &_impl_.recipientkeyindexes_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +DeviceListMetadata::mutable_recipientkeyindexes() { + // @@protoc_insertion_point(field_mutable_list:proto.DeviceListMetadata.recipientKeyIndexes) + return _internal_mutable_recipientkeyindexes(); +} + +// ------------------------------------------------------------------- + +// DeviceProps_AppVersion + +// optional uint32 primary = 1; +inline bool DeviceProps_AppVersion::_internal_has_primary() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool DeviceProps_AppVersion::has_primary() const { + return _internal_has_primary(); +} +inline void DeviceProps_AppVersion::clear_primary() { + _impl_.primary_ = 0u; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline uint32_t DeviceProps_AppVersion::_internal_primary() const { + return _impl_.primary_; +} +inline uint32_t DeviceProps_AppVersion::primary() const { + // @@protoc_insertion_point(field_get:proto.DeviceProps.AppVersion.primary) + return _internal_primary(); +} +inline void DeviceProps_AppVersion::_internal_set_primary(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.primary_ = value; +} +inline void DeviceProps_AppVersion::set_primary(uint32_t value) { + _internal_set_primary(value); + // @@protoc_insertion_point(field_set:proto.DeviceProps.AppVersion.primary) +} + +// optional uint32 secondary = 2; +inline bool DeviceProps_AppVersion::_internal_has_secondary() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool DeviceProps_AppVersion::has_secondary() const { + return _internal_has_secondary(); +} +inline void DeviceProps_AppVersion::clear_secondary() { + _impl_.secondary_ = 0u; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline uint32_t DeviceProps_AppVersion::_internal_secondary() const { + return _impl_.secondary_; +} +inline uint32_t DeviceProps_AppVersion::secondary() const { + // @@protoc_insertion_point(field_get:proto.DeviceProps.AppVersion.secondary) + return _internal_secondary(); +} +inline void DeviceProps_AppVersion::_internal_set_secondary(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.secondary_ = value; +} +inline void DeviceProps_AppVersion::set_secondary(uint32_t value) { + _internal_set_secondary(value); + // @@protoc_insertion_point(field_set:proto.DeviceProps.AppVersion.secondary) +} + +// optional uint32 tertiary = 3; +inline bool DeviceProps_AppVersion::_internal_has_tertiary() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool DeviceProps_AppVersion::has_tertiary() const { + return _internal_has_tertiary(); +} +inline void DeviceProps_AppVersion::clear_tertiary() { + _impl_.tertiary_ = 0u; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline uint32_t DeviceProps_AppVersion::_internal_tertiary() const { + return _impl_.tertiary_; +} +inline uint32_t DeviceProps_AppVersion::tertiary() const { + // @@protoc_insertion_point(field_get:proto.DeviceProps.AppVersion.tertiary) + return _internal_tertiary(); +} +inline void DeviceProps_AppVersion::_internal_set_tertiary(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.tertiary_ = value; +} +inline void DeviceProps_AppVersion::set_tertiary(uint32_t value) { + _internal_set_tertiary(value); + // @@protoc_insertion_point(field_set:proto.DeviceProps.AppVersion.tertiary) +} + +// optional uint32 quaternary = 4; +inline bool DeviceProps_AppVersion::_internal_has_quaternary() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool DeviceProps_AppVersion::has_quaternary() const { + return _internal_has_quaternary(); +} +inline void DeviceProps_AppVersion::clear_quaternary() { + _impl_.quaternary_ = 0u; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline uint32_t DeviceProps_AppVersion::_internal_quaternary() const { + return _impl_.quaternary_; +} +inline uint32_t DeviceProps_AppVersion::quaternary() const { + // @@protoc_insertion_point(field_get:proto.DeviceProps.AppVersion.quaternary) + return _internal_quaternary(); +} +inline void DeviceProps_AppVersion::_internal_set_quaternary(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.quaternary_ = value; +} +inline void DeviceProps_AppVersion::set_quaternary(uint32_t value) { + _internal_set_quaternary(value); + // @@protoc_insertion_point(field_set:proto.DeviceProps.AppVersion.quaternary) +} + +// optional uint32 quinary = 5; +inline bool DeviceProps_AppVersion::_internal_has_quinary() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool DeviceProps_AppVersion::has_quinary() const { + return _internal_has_quinary(); +} +inline void DeviceProps_AppVersion::clear_quinary() { + _impl_.quinary_ = 0u; + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline uint32_t DeviceProps_AppVersion::_internal_quinary() const { + return _impl_.quinary_; +} +inline uint32_t DeviceProps_AppVersion::quinary() const { + // @@protoc_insertion_point(field_get:proto.DeviceProps.AppVersion.quinary) + return _internal_quinary(); +} +inline void DeviceProps_AppVersion::_internal_set_quinary(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.quinary_ = value; +} +inline void DeviceProps_AppVersion::set_quinary(uint32_t value) { + _internal_set_quinary(value); + // @@protoc_insertion_point(field_set:proto.DeviceProps.AppVersion.quinary) +} + +// ------------------------------------------------------------------- + +// DeviceProps + +// optional string os = 1; +inline bool DeviceProps::_internal_has_os() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool DeviceProps::has_os() const { + return _internal_has_os(); +} +inline void DeviceProps::clear_os() { + _impl_.os_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& DeviceProps::os() const { + // @@protoc_insertion_point(field_get:proto.DeviceProps.os) + return _internal_os(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void DeviceProps::set_os(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.os_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.DeviceProps.os) +} +inline std::string* DeviceProps::mutable_os() { + std::string* _s = _internal_mutable_os(); + // @@protoc_insertion_point(field_mutable:proto.DeviceProps.os) + return _s; +} +inline const std::string& DeviceProps::_internal_os() const { + return _impl_.os_.Get(); +} +inline void DeviceProps::_internal_set_os(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.os_.Set(value, GetArenaForAllocation()); +} +inline std::string* DeviceProps::_internal_mutable_os() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.os_.Mutable(GetArenaForAllocation()); +} +inline std::string* DeviceProps::release_os() { + // @@protoc_insertion_point(field_release:proto.DeviceProps.os) + if (!_internal_has_os()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.os_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.os_.IsDefault()) { + _impl_.os_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void DeviceProps::set_allocated_os(std::string* os) { + if (os != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.os_.SetAllocated(os, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.os_.IsDefault()) { + _impl_.os_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.DeviceProps.os) +} + +// optional .proto.DeviceProps.AppVersion version = 2; +inline bool DeviceProps::_internal_has_version() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.version_ != nullptr); + return value; +} +inline bool DeviceProps::has_version() const { + return _internal_has_version(); +} +inline void DeviceProps::clear_version() { + if (_impl_.version_ != nullptr) _impl_.version_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::DeviceProps_AppVersion& DeviceProps::_internal_version() const { + const ::proto::DeviceProps_AppVersion* p = _impl_.version_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_DeviceProps_AppVersion_default_instance_); +} +inline const ::proto::DeviceProps_AppVersion& DeviceProps::version() const { + // @@protoc_insertion_point(field_get:proto.DeviceProps.version) + return _internal_version(); +} +inline void DeviceProps::unsafe_arena_set_allocated_version( + ::proto::DeviceProps_AppVersion* version) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.version_); + } + _impl_.version_ = version; + if (version) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.DeviceProps.version) +} +inline ::proto::DeviceProps_AppVersion* DeviceProps::release_version() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::DeviceProps_AppVersion* temp = _impl_.version_; + _impl_.version_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::DeviceProps_AppVersion* DeviceProps::unsafe_arena_release_version() { + // @@protoc_insertion_point(field_release:proto.DeviceProps.version) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::DeviceProps_AppVersion* temp = _impl_.version_; + _impl_.version_ = nullptr; + return temp; +} +inline ::proto::DeviceProps_AppVersion* DeviceProps::_internal_mutable_version() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.version_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::DeviceProps_AppVersion>(GetArenaForAllocation()); + _impl_.version_ = p; + } + return _impl_.version_; +} +inline ::proto::DeviceProps_AppVersion* DeviceProps::mutable_version() { + ::proto::DeviceProps_AppVersion* _msg = _internal_mutable_version(); + // @@protoc_insertion_point(field_mutable:proto.DeviceProps.version) + return _msg; +} +inline void DeviceProps::set_allocated_version(::proto::DeviceProps_AppVersion* version) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.version_; + } + if (version) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(version); + if (message_arena != submessage_arena) { + version = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, version, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.version_ = version; + // @@protoc_insertion_point(field_set_allocated:proto.DeviceProps.version) +} + +// optional .proto.DeviceProps.PlatformType platformType = 3; +inline bool DeviceProps::_internal_has_platformtype() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool DeviceProps::has_platformtype() const { + return _internal_has_platformtype(); +} +inline void DeviceProps::clear_platformtype() { + _impl_.platformtype_ = 0; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline ::proto::DeviceProps_PlatformType DeviceProps::_internal_platformtype() const { + return static_cast< ::proto::DeviceProps_PlatformType >(_impl_.platformtype_); +} +inline ::proto::DeviceProps_PlatformType DeviceProps::platformtype() const { + // @@protoc_insertion_point(field_get:proto.DeviceProps.platformType) + return _internal_platformtype(); +} +inline void DeviceProps::_internal_set_platformtype(::proto::DeviceProps_PlatformType value) { + assert(::proto::DeviceProps_PlatformType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.platformtype_ = value; +} +inline void DeviceProps::set_platformtype(::proto::DeviceProps_PlatformType value) { + _internal_set_platformtype(value); + // @@protoc_insertion_point(field_set:proto.DeviceProps.platformType) +} + +// optional bool requireFullSync = 4; +inline bool DeviceProps::_internal_has_requirefullsync() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool DeviceProps::has_requirefullsync() const { + return _internal_has_requirefullsync(); +} +inline void DeviceProps::clear_requirefullsync() { + _impl_.requirefullsync_ = false; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline bool DeviceProps::_internal_requirefullsync() const { + return _impl_.requirefullsync_; +} +inline bool DeviceProps::requirefullsync() const { + // @@protoc_insertion_point(field_get:proto.DeviceProps.requireFullSync) + return _internal_requirefullsync(); +} +inline void DeviceProps::_internal_set_requirefullsync(bool value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.requirefullsync_ = value; +} +inline void DeviceProps::set_requirefullsync(bool value) { + _internal_set_requirefullsync(value); + // @@protoc_insertion_point(field_set:proto.DeviceProps.requireFullSync) +} + +// ------------------------------------------------------------------- + +// DisappearingMode + +// optional .proto.DisappearingMode.Initiator initiator = 1; +inline bool DisappearingMode::_internal_has_initiator() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool DisappearingMode::has_initiator() const { + return _internal_has_initiator(); +} +inline void DisappearingMode::clear_initiator() { + _impl_.initiator_ = 0; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline ::proto::DisappearingMode_Initiator DisappearingMode::_internal_initiator() const { + return static_cast< ::proto::DisappearingMode_Initiator >(_impl_.initiator_); +} +inline ::proto::DisappearingMode_Initiator DisappearingMode::initiator() const { + // @@protoc_insertion_point(field_get:proto.DisappearingMode.initiator) + return _internal_initiator(); +} +inline void DisappearingMode::_internal_set_initiator(::proto::DisappearingMode_Initiator value) { + assert(::proto::DisappearingMode_Initiator_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.initiator_ = value; +} +inline void DisappearingMode::set_initiator(::proto::DisappearingMode_Initiator value) { + _internal_set_initiator(value); + // @@protoc_insertion_point(field_set:proto.DisappearingMode.initiator) +} + +// ------------------------------------------------------------------- + +// EphemeralSetting + +// optional sfixed32 duration = 1; +inline bool EphemeralSetting::_internal_has_duration() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool EphemeralSetting::has_duration() const { + return _internal_has_duration(); +} +inline void EphemeralSetting::clear_duration() { + _impl_.duration_ = 0; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline int32_t EphemeralSetting::_internal_duration() const { + return _impl_.duration_; +} +inline int32_t EphemeralSetting::duration() const { + // @@protoc_insertion_point(field_get:proto.EphemeralSetting.duration) + return _internal_duration(); +} +inline void EphemeralSetting::_internal_set_duration(int32_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.duration_ = value; +} +inline void EphemeralSetting::set_duration(int32_t value) { + _internal_set_duration(value); + // @@protoc_insertion_point(field_set:proto.EphemeralSetting.duration) +} + +// optional sfixed64 timestamp = 2; +inline bool EphemeralSetting::_internal_has_timestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool EphemeralSetting::has_timestamp() const { + return _internal_has_timestamp(); +} +inline void EphemeralSetting::clear_timestamp() { + _impl_.timestamp_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline int64_t EphemeralSetting::_internal_timestamp() const { + return _impl_.timestamp_; +} +inline int64_t EphemeralSetting::timestamp() const { + // @@protoc_insertion_point(field_get:proto.EphemeralSetting.timestamp) + return _internal_timestamp(); +} +inline void EphemeralSetting::_internal_set_timestamp(int64_t value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.timestamp_ = value; +} +inline void EphemeralSetting::set_timestamp(int64_t value) { + _internal_set_timestamp(value); + // @@protoc_insertion_point(field_set:proto.EphemeralSetting.timestamp) +} + +// ------------------------------------------------------------------- + +// ExitCode + +// optional uint64 code = 1; +inline bool ExitCode::_internal_has_code() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ExitCode::has_code() const { + return _internal_has_code(); +} +inline void ExitCode::clear_code() { + _impl_.code_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline uint64_t ExitCode::_internal_code() const { + return _impl_.code_; +} +inline uint64_t ExitCode::code() const { + // @@protoc_insertion_point(field_get:proto.ExitCode.code) + return _internal_code(); +} +inline void ExitCode::_internal_set_code(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.code_ = value; +} +inline void ExitCode::set_code(uint64_t value) { + _internal_set_code(value); + // @@protoc_insertion_point(field_set:proto.ExitCode.code) +} + +// optional string text = 2; +inline bool ExitCode::_internal_has_text() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ExitCode::has_text() const { + return _internal_has_text(); +} +inline void ExitCode::clear_text() { + _impl_.text_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ExitCode::text() const { + // @@protoc_insertion_point(field_get:proto.ExitCode.text) + return _internal_text(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ExitCode::set_text(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.text_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ExitCode.text) +} +inline std::string* ExitCode::mutable_text() { + std::string* _s = _internal_mutable_text(); + // @@protoc_insertion_point(field_mutable:proto.ExitCode.text) + return _s; +} +inline const std::string& ExitCode::_internal_text() const { + return _impl_.text_.Get(); +} +inline void ExitCode::_internal_set_text(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.text_.Set(value, GetArenaForAllocation()); +} +inline std::string* ExitCode::_internal_mutable_text() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.text_.Mutable(GetArenaForAllocation()); +} +inline std::string* ExitCode::release_text() { + // @@protoc_insertion_point(field_release:proto.ExitCode.text) + if (!_internal_has_text()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.text_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.text_.IsDefault()) { + _impl_.text_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ExitCode::set_allocated_text(std::string* text) { + if (text != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.text_.SetAllocated(text, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.text_.IsDefault()) { + _impl_.text_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ExitCode.text) +} + +// ------------------------------------------------------------------- + +// ExternalBlobReference + +// optional bytes mediaKey = 1; +inline bool ExternalBlobReference::_internal_has_mediakey() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ExternalBlobReference::has_mediakey() const { + return _internal_has_mediakey(); +} +inline void ExternalBlobReference::clear_mediakey() { + _impl_.mediakey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ExternalBlobReference::mediakey() const { + // @@protoc_insertion_point(field_get:proto.ExternalBlobReference.mediaKey) + return _internal_mediakey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ExternalBlobReference::set_mediakey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.mediakey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ExternalBlobReference.mediaKey) +} +inline std::string* ExternalBlobReference::mutable_mediakey() { + std::string* _s = _internal_mutable_mediakey(); + // @@protoc_insertion_point(field_mutable:proto.ExternalBlobReference.mediaKey) + return _s; +} +inline const std::string& ExternalBlobReference::_internal_mediakey() const { + return _impl_.mediakey_.Get(); +} +inline void ExternalBlobReference::_internal_set_mediakey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.mediakey_.Set(value, GetArenaForAllocation()); +} +inline std::string* ExternalBlobReference::_internal_mutable_mediakey() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.mediakey_.Mutable(GetArenaForAllocation()); +} +inline std::string* ExternalBlobReference::release_mediakey() { + // @@protoc_insertion_point(field_release:proto.ExternalBlobReference.mediaKey) + if (!_internal_has_mediakey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.mediakey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mediakey_.IsDefault()) { + _impl_.mediakey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ExternalBlobReference::set_allocated_mediakey(std::string* mediakey) { + if (mediakey != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mediakey_.IsDefault()) { + _impl_.mediakey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ExternalBlobReference.mediaKey) +} + +// optional string directPath = 2; +inline bool ExternalBlobReference::_internal_has_directpath() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ExternalBlobReference::has_directpath() const { + return _internal_has_directpath(); +} +inline void ExternalBlobReference::clear_directpath() { + _impl_.directpath_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& ExternalBlobReference::directpath() const { + // @@protoc_insertion_point(field_get:proto.ExternalBlobReference.directPath) + return _internal_directpath(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ExternalBlobReference::set_directpath(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.directpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ExternalBlobReference.directPath) +} +inline std::string* ExternalBlobReference::mutable_directpath() { + std::string* _s = _internal_mutable_directpath(); + // @@protoc_insertion_point(field_mutable:proto.ExternalBlobReference.directPath) + return _s; +} +inline const std::string& ExternalBlobReference::_internal_directpath() const { + return _impl_.directpath_.Get(); +} +inline void ExternalBlobReference::_internal_set_directpath(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.directpath_.Set(value, GetArenaForAllocation()); +} +inline std::string* ExternalBlobReference::_internal_mutable_directpath() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.directpath_.Mutable(GetArenaForAllocation()); +} +inline std::string* ExternalBlobReference::release_directpath() { + // @@protoc_insertion_point(field_release:proto.ExternalBlobReference.directPath) + if (!_internal_has_directpath()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.directpath_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.directpath_.IsDefault()) { + _impl_.directpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ExternalBlobReference::set_allocated_directpath(std::string* directpath) { + if (directpath != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.directpath_.IsDefault()) { + _impl_.directpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ExternalBlobReference.directPath) +} + +// optional string handle = 3; +inline bool ExternalBlobReference::_internal_has_handle() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ExternalBlobReference::has_handle() const { + return _internal_has_handle(); +} +inline void ExternalBlobReference::clear_handle() { + _impl_.handle_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& ExternalBlobReference::handle() const { + // @@protoc_insertion_point(field_get:proto.ExternalBlobReference.handle) + return _internal_handle(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ExternalBlobReference::set_handle(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.handle_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ExternalBlobReference.handle) +} +inline std::string* ExternalBlobReference::mutable_handle() { + std::string* _s = _internal_mutable_handle(); + // @@protoc_insertion_point(field_mutable:proto.ExternalBlobReference.handle) + return _s; +} +inline const std::string& ExternalBlobReference::_internal_handle() const { + return _impl_.handle_.Get(); +} +inline void ExternalBlobReference::_internal_set_handle(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.handle_.Set(value, GetArenaForAllocation()); +} +inline std::string* ExternalBlobReference::_internal_mutable_handle() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.handle_.Mutable(GetArenaForAllocation()); +} +inline std::string* ExternalBlobReference::release_handle() { + // @@protoc_insertion_point(field_release:proto.ExternalBlobReference.handle) + if (!_internal_has_handle()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.handle_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.handle_.IsDefault()) { + _impl_.handle_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ExternalBlobReference::set_allocated_handle(std::string* handle) { + if (handle != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.handle_.SetAllocated(handle, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.handle_.IsDefault()) { + _impl_.handle_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ExternalBlobReference.handle) +} + +// optional uint64 fileSizeBytes = 4; +inline bool ExternalBlobReference::_internal_has_filesizebytes() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool ExternalBlobReference::has_filesizebytes() const { + return _internal_has_filesizebytes(); +} +inline void ExternalBlobReference::clear_filesizebytes() { + _impl_.filesizebytes_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline uint64_t ExternalBlobReference::_internal_filesizebytes() const { + return _impl_.filesizebytes_; +} +inline uint64_t ExternalBlobReference::filesizebytes() const { + // @@protoc_insertion_point(field_get:proto.ExternalBlobReference.fileSizeBytes) + return _internal_filesizebytes(); +} +inline void ExternalBlobReference::_internal_set_filesizebytes(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.filesizebytes_ = value; +} +inline void ExternalBlobReference::set_filesizebytes(uint64_t value) { + _internal_set_filesizebytes(value); + // @@protoc_insertion_point(field_set:proto.ExternalBlobReference.fileSizeBytes) +} + +// optional bytes fileSha256 = 5; +inline bool ExternalBlobReference::_internal_has_filesha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ExternalBlobReference::has_filesha256() const { + return _internal_has_filesha256(); +} +inline void ExternalBlobReference::clear_filesha256() { + _impl_.filesha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const std::string& ExternalBlobReference::filesha256() const { + // @@protoc_insertion_point(field_get:proto.ExternalBlobReference.fileSha256) + return _internal_filesha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ExternalBlobReference::set_filesha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.filesha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ExternalBlobReference.fileSha256) +} +inline std::string* ExternalBlobReference::mutable_filesha256() { + std::string* _s = _internal_mutable_filesha256(); + // @@protoc_insertion_point(field_mutable:proto.ExternalBlobReference.fileSha256) + return _s; +} +inline const std::string& ExternalBlobReference::_internal_filesha256() const { + return _impl_.filesha256_.Get(); +} +inline void ExternalBlobReference::_internal_set_filesha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.filesha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* ExternalBlobReference::_internal_mutable_filesha256() { + _impl_._has_bits_[0] |= 0x00000008u; + return _impl_.filesha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* ExternalBlobReference::release_filesha256() { + // @@protoc_insertion_point(field_release:proto.ExternalBlobReference.fileSha256) + if (!_internal_has_filesha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000008u; + auto* p = _impl_.filesha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.filesha256_.IsDefault()) { + _impl_.filesha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ExternalBlobReference::set_allocated_filesha256(std::string* filesha256) { + if (filesha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.filesha256_.IsDefault()) { + _impl_.filesha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ExternalBlobReference.fileSha256) +} + +// optional bytes fileEncSha256 = 6; +inline bool ExternalBlobReference::_internal_has_fileencsha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool ExternalBlobReference::has_fileencsha256() const { + return _internal_has_fileencsha256(); +} +inline void ExternalBlobReference::clear_fileencsha256() { + _impl_.fileencsha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const std::string& ExternalBlobReference::fileencsha256() const { + // @@protoc_insertion_point(field_get:proto.ExternalBlobReference.fileEncSha256) + return _internal_fileencsha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ExternalBlobReference::set_fileencsha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.fileencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ExternalBlobReference.fileEncSha256) +} +inline std::string* ExternalBlobReference::mutable_fileencsha256() { + std::string* _s = _internal_mutable_fileencsha256(); + // @@protoc_insertion_point(field_mutable:proto.ExternalBlobReference.fileEncSha256) + return _s; +} +inline const std::string& ExternalBlobReference::_internal_fileencsha256() const { + return _impl_.fileencsha256_.Get(); +} +inline void ExternalBlobReference::_internal_set_fileencsha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.fileencsha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* ExternalBlobReference::_internal_mutable_fileencsha256() { + _impl_._has_bits_[0] |= 0x00000010u; + return _impl_.fileencsha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* ExternalBlobReference::release_fileencsha256() { + // @@protoc_insertion_point(field_release:proto.ExternalBlobReference.fileEncSha256) + if (!_internal_has_fileencsha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000010u; + auto* p = _impl_.fileencsha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fileencsha256_.IsDefault()) { + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ExternalBlobReference::set_allocated_fileencsha256(std::string* fileencsha256) { + if (fileencsha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fileencsha256_.IsDefault()) { + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ExternalBlobReference.fileEncSha256) +} + +// ------------------------------------------------------------------- + +// GlobalSettings + +// optional .proto.WallpaperSettings lightThemeWallpaper = 1; +inline bool GlobalSettings::_internal_has_lightthemewallpaper() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.lightthemewallpaper_ != nullptr); + return value; +} +inline bool GlobalSettings::has_lightthemewallpaper() const { + return _internal_has_lightthemewallpaper(); +} +inline void GlobalSettings::clear_lightthemewallpaper() { + if (_impl_.lightthemewallpaper_ != nullptr) _impl_.lightthemewallpaper_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::WallpaperSettings& GlobalSettings::_internal_lightthemewallpaper() const { + const ::proto::WallpaperSettings* p = _impl_.lightthemewallpaper_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_WallpaperSettings_default_instance_); +} +inline const ::proto::WallpaperSettings& GlobalSettings::lightthemewallpaper() const { + // @@protoc_insertion_point(field_get:proto.GlobalSettings.lightThemeWallpaper) + return _internal_lightthemewallpaper(); +} +inline void GlobalSettings::unsafe_arena_set_allocated_lightthemewallpaper( + ::proto::WallpaperSettings* lightthemewallpaper) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.lightthemewallpaper_); + } + _impl_.lightthemewallpaper_ = lightthemewallpaper; + if (lightthemewallpaper) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.GlobalSettings.lightThemeWallpaper) +} +inline ::proto::WallpaperSettings* GlobalSettings::release_lightthemewallpaper() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::WallpaperSettings* temp = _impl_.lightthemewallpaper_; + _impl_.lightthemewallpaper_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::WallpaperSettings* GlobalSettings::unsafe_arena_release_lightthemewallpaper() { + // @@protoc_insertion_point(field_release:proto.GlobalSettings.lightThemeWallpaper) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::WallpaperSettings* temp = _impl_.lightthemewallpaper_; + _impl_.lightthemewallpaper_ = nullptr; + return temp; +} +inline ::proto::WallpaperSettings* GlobalSettings::_internal_mutable_lightthemewallpaper() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.lightthemewallpaper_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::WallpaperSettings>(GetArenaForAllocation()); + _impl_.lightthemewallpaper_ = p; + } + return _impl_.lightthemewallpaper_; +} +inline ::proto::WallpaperSettings* GlobalSettings::mutable_lightthemewallpaper() { + ::proto::WallpaperSettings* _msg = _internal_mutable_lightthemewallpaper(); + // @@protoc_insertion_point(field_mutable:proto.GlobalSettings.lightThemeWallpaper) + return _msg; +} +inline void GlobalSettings::set_allocated_lightthemewallpaper(::proto::WallpaperSettings* lightthemewallpaper) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.lightthemewallpaper_; + } + if (lightthemewallpaper) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(lightthemewallpaper); + if (message_arena != submessage_arena) { + lightthemewallpaper = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, lightthemewallpaper, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.lightthemewallpaper_ = lightthemewallpaper; + // @@protoc_insertion_point(field_set_allocated:proto.GlobalSettings.lightThemeWallpaper) +} + +// optional .proto.MediaVisibility mediaVisibility = 2; +inline bool GlobalSettings::_internal_has_mediavisibility() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool GlobalSettings::has_mediavisibility() const { + return _internal_has_mediavisibility(); +} +inline void GlobalSettings::clear_mediavisibility() { + _impl_.mediavisibility_ = 0; + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline ::proto::MediaVisibility GlobalSettings::_internal_mediavisibility() const { + return static_cast< ::proto::MediaVisibility >(_impl_.mediavisibility_); +} +inline ::proto::MediaVisibility GlobalSettings::mediavisibility() const { + // @@protoc_insertion_point(field_get:proto.GlobalSettings.mediaVisibility) + return _internal_mediavisibility(); +} +inline void GlobalSettings::_internal_set_mediavisibility(::proto::MediaVisibility value) { + assert(::proto::MediaVisibility_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.mediavisibility_ = value; +} +inline void GlobalSettings::set_mediavisibility(::proto::MediaVisibility value) { + _internal_set_mediavisibility(value); + // @@protoc_insertion_point(field_set:proto.GlobalSettings.mediaVisibility) +} + +// optional .proto.WallpaperSettings darkThemeWallpaper = 3; +inline bool GlobalSettings::_internal_has_darkthemewallpaper() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.darkthemewallpaper_ != nullptr); + return value; +} +inline bool GlobalSettings::has_darkthemewallpaper() const { + return _internal_has_darkthemewallpaper(); +} +inline void GlobalSettings::clear_darkthemewallpaper() { + if (_impl_.darkthemewallpaper_ != nullptr) _impl_.darkthemewallpaper_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::WallpaperSettings& GlobalSettings::_internal_darkthemewallpaper() const { + const ::proto::WallpaperSettings* p = _impl_.darkthemewallpaper_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_WallpaperSettings_default_instance_); +} +inline const ::proto::WallpaperSettings& GlobalSettings::darkthemewallpaper() const { + // @@protoc_insertion_point(field_get:proto.GlobalSettings.darkThemeWallpaper) + return _internal_darkthemewallpaper(); +} +inline void GlobalSettings::unsafe_arena_set_allocated_darkthemewallpaper( + ::proto::WallpaperSettings* darkthemewallpaper) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.darkthemewallpaper_); + } + _impl_.darkthemewallpaper_ = darkthemewallpaper; + if (darkthemewallpaper) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.GlobalSettings.darkThemeWallpaper) +} +inline ::proto::WallpaperSettings* GlobalSettings::release_darkthemewallpaper() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::WallpaperSettings* temp = _impl_.darkthemewallpaper_; + _impl_.darkthemewallpaper_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::WallpaperSettings* GlobalSettings::unsafe_arena_release_darkthemewallpaper() { + // @@protoc_insertion_point(field_release:proto.GlobalSettings.darkThemeWallpaper) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::WallpaperSettings* temp = _impl_.darkthemewallpaper_; + _impl_.darkthemewallpaper_ = nullptr; + return temp; +} +inline ::proto::WallpaperSettings* GlobalSettings::_internal_mutable_darkthemewallpaper() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.darkthemewallpaper_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::WallpaperSettings>(GetArenaForAllocation()); + _impl_.darkthemewallpaper_ = p; + } + return _impl_.darkthemewallpaper_; +} +inline ::proto::WallpaperSettings* GlobalSettings::mutable_darkthemewallpaper() { + ::proto::WallpaperSettings* _msg = _internal_mutable_darkthemewallpaper(); + // @@protoc_insertion_point(field_mutable:proto.GlobalSettings.darkThemeWallpaper) + return _msg; +} +inline void GlobalSettings::set_allocated_darkthemewallpaper(::proto::WallpaperSettings* darkthemewallpaper) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.darkthemewallpaper_; + } + if (darkthemewallpaper) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(darkthemewallpaper); + if (message_arena != submessage_arena) { + darkthemewallpaper = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, darkthemewallpaper, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.darkthemewallpaper_ = darkthemewallpaper; + // @@protoc_insertion_point(field_set_allocated:proto.GlobalSettings.darkThemeWallpaper) +} + +// optional .proto.AutoDownloadSettings autoDownloadWiFi = 4; +inline bool GlobalSettings::_internal_has_autodownloadwifi() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.autodownloadwifi_ != nullptr); + return value; +} +inline bool GlobalSettings::has_autodownloadwifi() const { + return _internal_has_autodownloadwifi(); +} +inline void GlobalSettings::clear_autodownloadwifi() { + if (_impl_.autodownloadwifi_ != nullptr) _impl_.autodownloadwifi_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::proto::AutoDownloadSettings& GlobalSettings::_internal_autodownloadwifi() const { + const ::proto::AutoDownloadSettings* p = _impl_.autodownloadwifi_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_AutoDownloadSettings_default_instance_); +} +inline const ::proto::AutoDownloadSettings& GlobalSettings::autodownloadwifi() const { + // @@protoc_insertion_point(field_get:proto.GlobalSettings.autoDownloadWiFi) + return _internal_autodownloadwifi(); +} +inline void GlobalSettings::unsafe_arena_set_allocated_autodownloadwifi( + ::proto::AutoDownloadSettings* autodownloadwifi) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.autodownloadwifi_); + } + _impl_.autodownloadwifi_ = autodownloadwifi; + if (autodownloadwifi) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.GlobalSettings.autoDownloadWiFi) +} +inline ::proto::AutoDownloadSettings* GlobalSettings::release_autodownloadwifi() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::AutoDownloadSettings* temp = _impl_.autodownloadwifi_; + _impl_.autodownloadwifi_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::AutoDownloadSettings* GlobalSettings::unsafe_arena_release_autodownloadwifi() { + // @@protoc_insertion_point(field_release:proto.GlobalSettings.autoDownloadWiFi) + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::AutoDownloadSettings* temp = _impl_.autodownloadwifi_; + _impl_.autodownloadwifi_ = nullptr; + return temp; +} +inline ::proto::AutoDownloadSettings* GlobalSettings::_internal_mutable_autodownloadwifi() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.autodownloadwifi_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::AutoDownloadSettings>(GetArenaForAllocation()); + _impl_.autodownloadwifi_ = p; + } + return _impl_.autodownloadwifi_; +} +inline ::proto::AutoDownloadSettings* GlobalSettings::mutable_autodownloadwifi() { + ::proto::AutoDownloadSettings* _msg = _internal_mutable_autodownloadwifi(); + // @@protoc_insertion_point(field_mutable:proto.GlobalSettings.autoDownloadWiFi) + return _msg; +} +inline void GlobalSettings::set_allocated_autodownloadwifi(::proto::AutoDownloadSettings* autodownloadwifi) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.autodownloadwifi_; + } + if (autodownloadwifi) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(autodownloadwifi); + if (message_arena != submessage_arena) { + autodownloadwifi = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, autodownloadwifi, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.autodownloadwifi_ = autodownloadwifi; + // @@protoc_insertion_point(field_set_allocated:proto.GlobalSettings.autoDownloadWiFi) +} + +// optional .proto.AutoDownloadSettings autoDownloadCellular = 5; +inline bool GlobalSettings::_internal_has_autodownloadcellular() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || _impl_.autodownloadcellular_ != nullptr); + return value; +} +inline bool GlobalSettings::has_autodownloadcellular() const { + return _internal_has_autodownloadcellular(); +} +inline void GlobalSettings::clear_autodownloadcellular() { + if (_impl_.autodownloadcellular_ != nullptr) _impl_.autodownloadcellular_->Clear(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const ::proto::AutoDownloadSettings& GlobalSettings::_internal_autodownloadcellular() const { + const ::proto::AutoDownloadSettings* p = _impl_.autodownloadcellular_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_AutoDownloadSettings_default_instance_); +} +inline const ::proto::AutoDownloadSettings& GlobalSettings::autodownloadcellular() const { + // @@protoc_insertion_point(field_get:proto.GlobalSettings.autoDownloadCellular) + return _internal_autodownloadcellular(); +} +inline void GlobalSettings::unsafe_arena_set_allocated_autodownloadcellular( + ::proto::AutoDownloadSettings* autodownloadcellular) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.autodownloadcellular_); + } + _impl_.autodownloadcellular_ = autodownloadcellular; + if (autodownloadcellular) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.GlobalSettings.autoDownloadCellular) +} +inline ::proto::AutoDownloadSettings* GlobalSettings::release_autodownloadcellular() { + _impl_._has_bits_[0] &= ~0x00000008u; + ::proto::AutoDownloadSettings* temp = _impl_.autodownloadcellular_; + _impl_.autodownloadcellular_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::AutoDownloadSettings* GlobalSettings::unsafe_arena_release_autodownloadcellular() { + // @@protoc_insertion_point(field_release:proto.GlobalSettings.autoDownloadCellular) + _impl_._has_bits_[0] &= ~0x00000008u; + ::proto::AutoDownloadSettings* temp = _impl_.autodownloadcellular_; + _impl_.autodownloadcellular_ = nullptr; + return temp; +} +inline ::proto::AutoDownloadSettings* GlobalSettings::_internal_mutable_autodownloadcellular() { + _impl_._has_bits_[0] |= 0x00000008u; + if (_impl_.autodownloadcellular_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::AutoDownloadSettings>(GetArenaForAllocation()); + _impl_.autodownloadcellular_ = p; + } + return _impl_.autodownloadcellular_; +} +inline ::proto::AutoDownloadSettings* GlobalSettings::mutable_autodownloadcellular() { + ::proto::AutoDownloadSettings* _msg = _internal_mutable_autodownloadcellular(); + // @@protoc_insertion_point(field_mutable:proto.GlobalSettings.autoDownloadCellular) + return _msg; +} +inline void GlobalSettings::set_allocated_autodownloadcellular(::proto::AutoDownloadSettings* autodownloadcellular) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.autodownloadcellular_; + } + if (autodownloadcellular) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(autodownloadcellular); + if (message_arena != submessage_arena) { + autodownloadcellular = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, autodownloadcellular, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.autodownloadcellular_ = autodownloadcellular; + // @@protoc_insertion_point(field_set_allocated:proto.GlobalSettings.autoDownloadCellular) +} + +// optional .proto.AutoDownloadSettings autoDownloadRoaming = 6; +inline bool GlobalSettings::_internal_has_autodownloadroaming() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + PROTOBUF_ASSUME(!value || _impl_.autodownloadroaming_ != nullptr); + return value; +} +inline bool GlobalSettings::has_autodownloadroaming() const { + return _internal_has_autodownloadroaming(); +} +inline void GlobalSettings::clear_autodownloadroaming() { + if (_impl_.autodownloadroaming_ != nullptr) _impl_.autodownloadroaming_->Clear(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const ::proto::AutoDownloadSettings& GlobalSettings::_internal_autodownloadroaming() const { + const ::proto::AutoDownloadSettings* p = _impl_.autodownloadroaming_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_AutoDownloadSettings_default_instance_); +} +inline const ::proto::AutoDownloadSettings& GlobalSettings::autodownloadroaming() const { + // @@protoc_insertion_point(field_get:proto.GlobalSettings.autoDownloadRoaming) + return _internal_autodownloadroaming(); +} +inline void GlobalSettings::unsafe_arena_set_allocated_autodownloadroaming( + ::proto::AutoDownloadSettings* autodownloadroaming) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.autodownloadroaming_); + } + _impl_.autodownloadroaming_ = autodownloadroaming; + if (autodownloadroaming) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.GlobalSettings.autoDownloadRoaming) +} +inline ::proto::AutoDownloadSettings* GlobalSettings::release_autodownloadroaming() { + _impl_._has_bits_[0] &= ~0x00000010u; + ::proto::AutoDownloadSettings* temp = _impl_.autodownloadroaming_; + _impl_.autodownloadroaming_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::AutoDownloadSettings* GlobalSettings::unsafe_arena_release_autodownloadroaming() { + // @@protoc_insertion_point(field_release:proto.GlobalSettings.autoDownloadRoaming) + _impl_._has_bits_[0] &= ~0x00000010u; + ::proto::AutoDownloadSettings* temp = _impl_.autodownloadroaming_; + _impl_.autodownloadroaming_ = nullptr; + return temp; +} +inline ::proto::AutoDownloadSettings* GlobalSettings::_internal_mutable_autodownloadroaming() { + _impl_._has_bits_[0] |= 0x00000010u; + if (_impl_.autodownloadroaming_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::AutoDownloadSettings>(GetArenaForAllocation()); + _impl_.autodownloadroaming_ = p; + } + return _impl_.autodownloadroaming_; +} +inline ::proto::AutoDownloadSettings* GlobalSettings::mutable_autodownloadroaming() { + ::proto::AutoDownloadSettings* _msg = _internal_mutable_autodownloadroaming(); + // @@protoc_insertion_point(field_mutable:proto.GlobalSettings.autoDownloadRoaming) + return _msg; +} +inline void GlobalSettings::set_allocated_autodownloadroaming(::proto::AutoDownloadSettings* autodownloadroaming) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.autodownloadroaming_; + } + if (autodownloadroaming) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(autodownloadroaming); + if (message_arena != submessage_arena) { + autodownloadroaming = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, autodownloadroaming, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.autodownloadroaming_ = autodownloadroaming; + // @@protoc_insertion_point(field_set_allocated:proto.GlobalSettings.autoDownloadRoaming) +} + +// optional bool showIndividualNotificationsPreview = 7; +inline bool GlobalSettings::_internal_has_showindividualnotificationspreview() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool GlobalSettings::has_showindividualnotificationspreview() const { + return _internal_has_showindividualnotificationspreview(); +} +inline void GlobalSettings::clear_showindividualnotificationspreview() { + _impl_.showindividualnotificationspreview_ = false; + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline bool GlobalSettings::_internal_showindividualnotificationspreview() const { + return _impl_.showindividualnotificationspreview_; +} +inline bool GlobalSettings::showindividualnotificationspreview() const { + // @@protoc_insertion_point(field_get:proto.GlobalSettings.showIndividualNotificationsPreview) + return _internal_showindividualnotificationspreview(); +} +inline void GlobalSettings::_internal_set_showindividualnotificationspreview(bool value) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.showindividualnotificationspreview_ = value; +} +inline void GlobalSettings::set_showindividualnotificationspreview(bool value) { + _internal_set_showindividualnotificationspreview(value); + // @@protoc_insertion_point(field_set:proto.GlobalSettings.showIndividualNotificationsPreview) +} + +// optional bool showGroupNotificationsPreview = 8; +inline bool GlobalSettings::_internal_has_showgroupnotificationspreview() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool GlobalSettings::has_showgroupnotificationspreview() const { + return _internal_has_showgroupnotificationspreview(); +} +inline void GlobalSettings::clear_showgroupnotificationspreview() { + _impl_.showgroupnotificationspreview_ = false; + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline bool GlobalSettings::_internal_showgroupnotificationspreview() const { + return _impl_.showgroupnotificationspreview_; +} +inline bool GlobalSettings::showgroupnotificationspreview() const { + // @@protoc_insertion_point(field_get:proto.GlobalSettings.showGroupNotificationsPreview) + return _internal_showgroupnotificationspreview(); +} +inline void GlobalSettings::_internal_set_showgroupnotificationspreview(bool value) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.showgroupnotificationspreview_ = value; +} +inline void GlobalSettings::set_showgroupnotificationspreview(bool value) { + _internal_set_showgroupnotificationspreview(value); + // @@protoc_insertion_point(field_set:proto.GlobalSettings.showGroupNotificationsPreview) +} + +// optional int32 disappearingModeDuration = 9; +inline bool GlobalSettings::_internal_has_disappearingmodeduration() const { + bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool GlobalSettings::has_disappearingmodeduration() const { + return _internal_has_disappearingmodeduration(); +} +inline void GlobalSettings::clear_disappearingmodeduration() { + _impl_.disappearingmodeduration_ = 0; + _impl_._has_bits_[0] &= ~0x00000200u; +} +inline int32_t GlobalSettings::_internal_disappearingmodeduration() const { + return _impl_.disappearingmodeduration_; +} +inline int32_t GlobalSettings::disappearingmodeduration() const { + // @@protoc_insertion_point(field_get:proto.GlobalSettings.disappearingModeDuration) + return _internal_disappearingmodeduration(); +} +inline void GlobalSettings::_internal_set_disappearingmodeduration(int32_t value) { + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.disappearingmodeduration_ = value; +} +inline void GlobalSettings::set_disappearingmodeduration(int32_t value) { + _internal_set_disappearingmodeduration(value); + // @@protoc_insertion_point(field_set:proto.GlobalSettings.disappearingModeDuration) +} + +// optional int64 disappearingModeTimestamp = 10; +inline bool GlobalSettings::_internal_has_disappearingmodetimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool GlobalSettings::has_disappearingmodetimestamp() const { + return _internal_has_disappearingmodetimestamp(); +} +inline void GlobalSettings::clear_disappearingmodetimestamp() { + _impl_.disappearingmodetimestamp_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000100u; +} +inline int64_t GlobalSettings::_internal_disappearingmodetimestamp() const { + return _impl_.disappearingmodetimestamp_; +} +inline int64_t GlobalSettings::disappearingmodetimestamp() const { + // @@protoc_insertion_point(field_get:proto.GlobalSettings.disappearingModeTimestamp) + return _internal_disappearingmodetimestamp(); +} +inline void GlobalSettings::_internal_set_disappearingmodetimestamp(int64_t value) { + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.disappearingmodetimestamp_ = value; +} +inline void GlobalSettings::set_disappearingmodetimestamp(int64_t value) { + _internal_set_disappearingmodetimestamp(value); + // @@protoc_insertion_point(field_set:proto.GlobalSettings.disappearingModeTimestamp) +} + +// ------------------------------------------------------------------- + +// GroupParticipant + +// required string userJid = 1; +inline bool GroupParticipant::_internal_has_userjid() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool GroupParticipant::has_userjid() const { + return _internal_has_userjid(); +} +inline void GroupParticipant::clear_userjid() { + _impl_.userjid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& GroupParticipant::userjid() const { + // @@protoc_insertion_point(field_get:proto.GroupParticipant.userJid) + return _internal_userjid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void GroupParticipant::set_userjid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.userjid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.GroupParticipant.userJid) +} +inline std::string* GroupParticipant::mutable_userjid() { + std::string* _s = _internal_mutable_userjid(); + // @@protoc_insertion_point(field_mutable:proto.GroupParticipant.userJid) + return _s; +} +inline const std::string& GroupParticipant::_internal_userjid() const { + return _impl_.userjid_.Get(); +} +inline void GroupParticipant::_internal_set_userjid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.userjid_.Set(value, GetArenaForAllocation()); +} +inline std::string* GroupParticipant::_internal_mutable_userjid() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.userjid_.Mutable(GetArenaForAllocation()); +} +inline std::string* GroupParticipant::release_userjid() { + // @@protoc_insertion_point(field_release:proto.GroupParticipant.userJid) + if (!_internal_has_userjid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.userjid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.userjid_.IsDefault()) { + _impl_.userjid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void GroupParticipant::set_allocated_userjid(std::string* userjid) { + if (userjid != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.userjid_.SetAllocated(userjid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.userjid_.IsDefault()) { + _impl_.userjid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.GroupParticipant.userJid) +} + +// optional .proto.GroupParticipant.Rank rank = 2; +inline bool GroupParticipant::_internal_has_rank() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool GroupParticipant::has_rank() const { + return _internal_has_rank(); +} +inline void GroupParticipant::clear_rank() { + _impl_.rank_ = 0; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline ::proto::GroupParticipant_Rank GroupParticipant::_internal_rank() const { + return static_cast< ::proto::GroupParticipant_Rank >(_impl_.rank_); +} +inline ::proto::GroupParticipant_Rank GroupParticipant::rank() const { + // @@protoc_insertion_point(field_get:proto.GroupParticipant.rank) + return _internal_rank(); +} +inline void GroupParticipant::_internal_set_rank(::proto::GroupParticipant_Rank value) { + assert(::proto::GroupParticipant_Rank_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.rank_ = value; +} +inline void GroupParticipant::set_rank(::proto::GroupParticipant_Rank value) { + _internal_set_rank(value); + // @@protoc_insertion_point(field_set:proto.GroupParticipant.rank) +} + +// ------------------------------------------------------------------- + +// HandshakeMessage_ClientFinish + +// optional bytes static = 1; +inline bool HandshakeMessage_ClientFinish::_internal_has_static_() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool HandshakeMessage_ClientFinish::has_static_() const { + return _internal_has_static_(); +} +inline void HandshakeMessage_ClientFinish::clear_static_() { + _impl_.static__.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& HandshakeMessage_ClientFinish::static_() const { + // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ClientFinish.static) + return _internal_static_(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void HandshakeMessage_ClientFinish::set_static_(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.static__.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ClientFinish.static) +} +inline std::string* HandshakeMessage_ClientFinish::mutable_static_() { + std::string* _s = _internal_mutable_static_(); + // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ClientFinish.static) + return _s; +} +inline const std::string& HandshakeMessage_ClientFinish::_internal_static_() const { + return _impl_.static__.Get(); +} +inline void HandshakeMessage_ClientFinish::_internal_set_static_(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.static__.Set(value, GetArenaForAllocation()); +} +inline std::string* HandshakeMessage_ClientFinish::_internal_mutable_static_() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.static__.Mutable(GetArenaForAllocation()); +} +inline std::string* HandshakeMessage_ClientFinish::release_static_() { + // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ClientFinish.static) + if (!_internal_has_static_()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.static__.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.static__.IsDefault()) { + _impl_.static__.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void HandshakeMessage_ClientFinish::set_allocated_static_(std::string* static_) { + if (static_ != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.static__.SetAllocated(static_, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.static__.IsDefault()) { + _impl_.static__.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ClientFinish.static) +} + +// optional bytes payload = 2; +inline bool HandshakeMessage_ClientFinish::_internal_has_payload() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool HandshakeMessage_ClientFinish::has_payload() const { + return _internal_has_payload(); +} +inline void HandshakeMessage_ClientFinish::clear_payload() { + _impl_.payload_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& HandshakeMessage_ClientFinish::payload() const { + // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ClientFinish.payload) + return _internal_payload(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void HandshakeMessage_ClientFinish::set_payload(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.payload_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ClientFinish.payload) +} +inline std::string* HandshakeMessage_ClientFinish::mutable_payload() { + std::string* _s = _internal_mutable_payload(); + // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ClientFinish.payload) + return _s; +} +inline const std::string& HandshakeMessage_ClientFinish::_internal_payload() const { + return _impl_.payload_.Get(); +} +inline void HandshakeMessage_ClientFinish::_internal_set_payload(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.payload_.Set(value, GetArenaForAllocation()); +} +inline std::string* HandshakeMessage_ClientFinish::_internal_mutable_payload() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.payload_.Mutable(GetArenaForAllocation()); +} +inline std::string* HandshakeMessage_ClientFinish::release_payload() { + // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ClientFinish.payload) + if (!_internal_has_payload()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.payload_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.payload_.IsDefault()) { + _impl_.payload_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void HandshakeMessage_ClientFinish::set_allocated_payload(std::string* payload) { + if (payload != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.payload_.SetAllocated(payload, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.payload_.IsDefault()) { + _impl_.payload_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ClientFinish.payload) +} + +// ------------------------------------------------------------------- + +// HandshakeMessage_ClientHello + +// optional bytes ephemeral = 1; +inline bool HandshakeMessage_ClientHello::_internal_has_ephemeral() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool HandshakeMessage_ClientHello::has_ephemeral() const { + return _internal_has_ephemeral(); +} +inline void HandshakeMessage_ClientHello::clear_ephemeral() { + _impl_.ephemeral_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& HandshakeMessage_ClientHello::ephemeral() const { + // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ClientHello.ephemeral) + return _internal_ephemeral(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void HandshakeMessage_ClientHello::set_ephemeral(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.ephemeral_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ClientHello.ephemeral) +} +inline std::string* HandshakeMessage_ClientHello::mutable_ephemeral() { + std::string* _s = _internal_mutable_ephemeral(); + // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ClientHello.ephemeral) + return _s; +} +inline const std::string& HandshakeMessage_ClientHello::_internal_ephemeral() const { + return _impl_.ephemeral_.Get(); +} +inline void HandshakeMessage_ClientHello::_internal_set_ephemeral(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.ephemeral_.Set(value, GetArenaForAllocation()); +} +inline std::string* HandshakeMessage_ClientHello::_internal_mutable_ephemeral() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.ephemeral_.Mutable(GetArenaForAllocation()); +} +inline std::string* HandshakeMessage_ClientHello::release_ephemeral() { + // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ClientHello.ephemeral) + if (!_internal_has_ephemeral()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.ephemeral_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.ephemeral_.IsDefault()) { + _impl_.ephemeral_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void HandshakeMessage_ClientHello::set_allocated_ephemeral(std::string* ephemeral) { + if (ephemeral != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.ephemeral_.SetAllocated(ephemeral, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.ephemeral_.IsDefault()) { + _impl_.ephemeral_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ClientHello.ephemeral) +} + +// optional bytes static = 2; +inline bool HandshakeMessage_ClientHello::_internal_has_static_() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool HandshakeMessage_ClientHello::has_static_() const { + return _internal_has_static_(); +} +inline void HandshakeMessage_ClientHello::clear_static_() { + _impl_.static__.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& HandshakeMessage_ClientHello::static_() const { + // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ClientHello.static) + return _internal_static_(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void HandshakeMessage_ClientHello::set_static_(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.static__.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ClientHello.static) +} +inline std::string* HandshakeMessage_ClientHello::mutable_static_() { + std::string* _s = _internal_mutable_static_(); + // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ClientHello.static) + return _s; +} +inline const std::string& HandshakeMessage_ClientHello::_internal_static_() const { + return _impl_.static__.Get(); +} +inline void HandshakeMessage_ClientHello::_internal_set_static_(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.static__.Set(value, GetArenaForAllocation()); +} +inline std::string* HandshakeMessage_ClientHello::_internal_mutable_static_() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.static__.Mutable(GetArenaForAllocation()); +} +inline std::string* HandshakeMessage_ClientHello::release_static_() { + // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ClientHello.static) + if (!_internal_has_static_()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.static__.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.static__.IsDefault()) { + _impl_.static__.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void HandshakeMessage_ClientHello::set_allocated_static_(std::string* static_) { + if (static_ != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.static__.SetAllocated(static_, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.static__.IsDefault()) { + _impl_.static__.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ClientHello.static) +} + +// optional bytes payload = 3; +inline bool HandshakeMessage_ClientHello::_internal_has_payload() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool HandshakeMessage_ClientHello::has_payload() const { + return _internal_has_payload(); +} +inline void HandshakeMessage_ClientHello::clear_payload() { + _impl_.payload_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& HandshakeMessage_ClientHello::payload() const { + // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ClientHello.payload) + return _internal_payload(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void HandshakeMessage_ClientHello::set_payload(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.payload_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ClientHello.payload) +} +inline std::string* HandshakeMessage_ClientHello::mutable_payload() { + std::string* _s = _internal_mutable_payload(); + // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ClientHello.payload) + return _s; +} +inline const std::string& HandshakeMessage_ClientHello::_internal_payload() const { + return _impl_.payload_.Get(); +} +inline void HandshakeMessage_ClientHello::_internal_set_payload(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.payload_.Set(value, GetArenaForAllocation()); +} +inline std::string* HandshakeMessage_ClientHello::_internal_mutable_payload() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.payload_.Mutable(GetArenaForAllocation()); +} +inline std::string* HandshakeMessage_ClientHello::release_payload() { + // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ClientHello.payload) + if (!_internal_has_payload()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.payload_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.payload_.IsDefault()) { + _impl_.payload_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void HandshakeMessage_ClientHello::set_allocated_payload(std::string* payload) { + if (payload != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.payload_.SetAllocated(payload, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.payload_.IsDefault()) { + _impl_.payload_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ClientHello.payload) +} + +// ------------------------------------------------------------------- + +// HandshakeMessage_ServerHello + +// optional bytes ephemeral = 1; +inline bool HandshakeMessage_ServerHello::_internal_has_ephemeral() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool HandshakeMessage_ServerHello::has_ephemeral() const { + return _internal_has_ephemeral(); +} +inline void HandshakeMessage_ServerHello::clear_ephemeral() { + _impl_.ephemeral_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& HandshakeMessage_ServerHello::ephemeral() const { + // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ServerHello.ephemeral) + return _internal_ephemeral(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void HandshakeMessage_ServerHello::set_ephemeral(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.ephemeral_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ServerHello.ephemeral) +} +inline std::string* HandshakeMessage_ServerHello::mutable_ephemeral() { + std::string* _s = _internal_mutable_ephemeral(); + // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ServerHello.ephemeral) + return _s; +} +inline const std::string& HandshakeMessage_ServerHello::_internal_ephemeral() const { + return _impl_.ephemeral_.Get(); +} +inline void HandshakeMessage_ServerHello::_internal_set_ephemeral(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.ephemeral_.Set(value, GetArenaForAllocation()); +} +inline std::string* HandshakeMessage_ServerHello::_internal_mutable_ephemeral() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.ephemeral_.Mutable(GetArenaForAllocation()); +} +inline std::string* HandshakeMessage_ServerHello::release_ephemeral() { + // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ServerHello.ephemeral) + if (!_internal_has_ephemeral()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.ephemeral_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.ephemeral_.IsDefault()) { + _impl_.ephemeral_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void HandshakeMessage_ServerHello::set_allocated_ephemeral(std::string* ephemeral) { + if (ephemeral != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.ephemeral_.SetAllocated(ephemeral, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.ephemeral_.IsDefault()) { + _impl_.ephemeral_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ServerHello.ephemeral) +} + +// optional bytes static = 2; +inline bool HandshakeMessage_ServerHello::_internal_has_static_() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool HandshakeMessage_ServerHello::has_static_() const { + return _internal_has_static_(); +} +inline void HandshakeMessage_ServerHello::clear_static_() { + _impl_.static__.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& HandshakeMessage_ServerHello::static_() const { + // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ServerHello.static) + return _internal_static_(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void HandshakeMessage_ServerHello::set_static_(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.static__.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ServerHello.static) +} +inline std::string* HandshakeMessage_ServerHello::mutable_static_() { + std::string* _s = _internal_mutable_static_(); + // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ServerHello.static) + return _s; +} +inline const std::string& HandshakeMessage_ServerHello::_internal_static_() const { + return _impl_.static__.Get(); +} +inline void HandshakeMessage_ServerHello::_internal_set_static_(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.static__.Set(value, GetArenaForAllocation()); +} +inline std::string* HandshakeMessage_ServerHello::_internal_mutable_static_() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.static__.Mutable(GetArenaForAllocation()); +} +inline std::string* HandshakeMessage_ServerHello::release_static_() { + // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ServerHello.static) + if (!_internal_has_static_()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.static__.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.static__.IsDefault()) { + _impl_.static__.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void HandshakeMessage_ServerHello::set_allocated_static_(std::string* static_) { + if (static_ != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.static__.SetAllocated(static_, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.static__.IsDefault()) { + _impl_.static__.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ServerHello.static) +} + +// optional bytes payload = 3; +inline bool HandshakeMessage_ServerHello::_internal_has_payload() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool HandshakeMessage_ServerHello::has_payload() const { + return _internal_has_payload(); +} +inline void HandshakeMessage_ServerHello::clear_payload() { + _impl_.payload_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& HandshakeMessage_ServerHello::payload() const { + // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ServerHello.payload) + return _internal_payload(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void HandshakeMessage_ServerHello::set_payload(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.payload_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ServerHello.payload) +} +inline std::string* HandshakeMessage_ServerHello::mutable_payload() { + std::string* _s = _internal_mutable_payload(); + // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ServerHello.payload) + return _s; +} +inline const std::string& HandshakeMessage_ServerHello::_internal_payload() const { + return _impl_.payload_.Get(); +} +inline void HandshakeMessage_ServerHello::_internal_set_payload(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.payload_.Set(value, GetArenaForAllocation()); +} +inline std::string* HandshakeMessage_ServerHello::_internal_mutable_payload() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.payload_.Mutable(GetArenaForAllocation()); +} +inline std::string* HandshakeMessage_ServerHello::release_payload() { + // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ServerHello.payload) + if (!_internal_has_payload()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.payload_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.payload_.IsDefault()) { + _impl_.payload_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void HandshakeMessage_ServerHello::set_allocated_payload(std::string* payload) { + if (payload != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.payload_.SetAllocated(payload, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.payload_.IsDefault()) { + _impl_.payload_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ServerHello.payload) +} + +// ------------------------------------------------------------------- + +// HandshakeMessage + +// optional .proto.HandshakeMessage.ClientHello clientHello = 2; +inline bool HandshakeMessage::_internal_has_clienthello() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.clienthello_ != nullptr); + return value; +} +inline bool HandshakeMessage::has_clienthello() const { + return _internal_has_clienthello(); +} +inline void HandshakeMessage::clear_clienthello() { + if (_impl_.clienthello_ != nullptr) _impl_.clienthello_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::HandshakeMessage_ClientHello& HandshakeMessage::_internal_clienthello() const { + const ::proto::HandshakeMessage_ClientHello* p = _impl_.clienthello_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_HandshakeMessage_ClientHello_default_instance_); +} +inline const ::proto::HandshakeMessage_ClientHello& HandshakeMessage::clienthello() const { + // @@protoc_insertion_point(field_get:proto.HandshakeMessage.clientHello) + return _internal_clienthello(); +} +inline void HandshakeMessage::unsafe_arena_set_allocated_clienthello( + ::proto::HandshakeMessage_ClientHello* clienthello) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.clienthello_); + } + _impl_.clienthello_ = clienthello; + if (clienthello) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HandshakeMessage.clientHello) +} +inline ::proto::HandshakeMessage_ClientHello* HandshakeMessage::release_clienthello() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::HandshakeMessage_ClientHello* temp = _impl_.clienthello_; + _impl_.clienthello_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::HandshakeMessage_ClientHello* HandshakeMessage::unsafe_arena_release_clienthello() { + // @@protoc_insertion_point(field_release:proto.HandshakeMessage.clientHello) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::HandshakeMessage_ClientHello* temp = _impl_.clienthello_; + _impl_.clienthello_ = nullptr; + return temp; +} +inline ::proto::HandshakeMessage_ClientHello* HandshakeMessage::_internal_mutable_clienthello() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.clienthello_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::HandshakeMessage_ClientHello>(GetArenaForAllocation()); + _impl_.clienthello_ = p; + } + return _impl_.clienthello_; +} +inline ::proto::HandshakeMessage_ClientHello* HandshakeMessage::mutable_clienthello() { + ::proto::HandshakeMessage_ClientHello* _msg = _internal_mutable_clienthello(); + // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.clientHello) + return _msg; +} +inline void HandshakeMessage::set_allocated_clienthello(::proto::HandshakeMessage_ClientHello* clienthello) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.clienthello_; + } + if (clienthello) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(clienthello); + if (message_arena != submessage_arena) { + clienthello = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, clienthello, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.clienthello_ = clienthello; + // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.clientHello) +} + +// optional .proto.HandshakeMessage.ServerHello serverHello = 3; +inline bool HandshakeMessage::_internal_has_serverhello() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.serverhello_ != nullptr); + return value; +} +inline bool HandshakeMessage::has_serverhello() const { + return _internal_has_serverhello(); +} +inline void HandshakeMessage::clear_serverhello() { + if (_impl_.serverhello_ != nullptr) _impl_.serverhello_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::HandshakeMessage_ServerHello& HandshakeMessage::_internal_serverhello() const { + const ::proto::HandshakeMessage_ServerHello* p = _impl_.serverhello_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_HandshakeMessage_ServerHello_default_instance_); +} +inline const ::proto::HandshakeMessage_ServerHello& HandshakeMessage::serverhello() const { + // @@protoc_insertion_point(field_get:proto.HandshakeMessage.serverHello) + return _internal_serverhello(); +} +inline void HandshakeMessage::unsafe_arena_set_allocated_serverhello( + ::proto::HandshakeMessage_ServerHello* serverhello) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.serverhello_); + } + _impl_.serverhello_ = serverhello; + if (serverhello) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HandshakeMessage.serverHello) +} +inline ::proto::HandshakeMessage_ServerHello* HandshakeMessage::release_serverhello() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::HandshakeMessage_ServerHello* temp = _impl_.serverhello_; + _impl_.serverhello_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::HandshakeMessage_ServerHello* HandshakeMessage::unsafe_arena_release_serverhello() { + // @@protoc_insertion_point(field_release:proto.HandshakeMessage.serverHello) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::HandshakeMessage_ServerHello* temp = _impl_.serverhello_; + _impl_.serverhello_ = nullptr; + return temp; +} +inline ::proto::HandshakeMessage_ServerHello* HandshakeMessage::_internal_mutable_serverhello() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.serverhello_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::HandshakeMessage_ServerHello>(GetArenaForAllocation()); + _impl_.serverhello_ = p; + } + return _impl_.serverhello_; +} +inline ::proto::HandshakeMessage_ServerHello* HandshakeMessage::mutable_serverhello() { + ::proto::HandshakeMessage_ServerHello* _msg = _internal_mutable_serverhello(); + // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.serverHello) + return _msg; +} +inline void HandshakeMessage::set_allocated_serverhello(::proto::HandshakeMessage_ServerHello* serverhello) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.serverhello_; + } + if (serverhello) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(serverhello); + if (message_arena != submessage_arena) { + serverhello = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, serverhello, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.serverhello_ = serverhello; + // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.serverHello) +} + +// optional .proto.HandshakeMessage.ClientFinish clientFinish = 4; +inline bool HandshakeMessage::_internal_has_clientfinish() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.clientfinish_ != nullptr); + return value; +} +inline bool HandshakeMessage::has_clientfinish() const { + return _internal_has_clientfinish(); +} +inline void HandshakeMessage::clear_clientfinish() { + if (_impl_.clientfinish_ != nullptr) _impl_.clientfinish_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::proto::HandshakeMessage_ClientFinish& HandshakeMessage::_internal_clientfinish() const { + const ::proto::HandshakeMessage_ClientFinish* p = _impl_.clientfinish_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_HandshakeMessage_ClientFinish_default_instance_); +} +inline const ::proto::HandshakeMessage_ClientFinish& HandshakeMessage::clientfinish() const { + // @@protoc_insertion_point(field_get:proto.HandshakeMessage.clientFinish) + return _internal_clientfinish(); +} +inline void HandshakeMessage::unsafe_arena_set_allocated_clientfinish( + ::proto::HandshakeMessage_ClientFinish* clientfinish) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.clientfinish_); + } + _impl_.clientfinish_ = clientfinish; + if (clientfinish) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HandshakeMessage.clientFinish) +} +inline ::proto::HandshakeMessage_ClientFinish* HandshakeMessage::release_clientfinish() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::HandshakeMessage_ClientFinish* temp = _impl_.clientfinish_; + _impl_.clientfinish_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::HandshakeMessage_ClientFinish* HandshakeMessage::unsafe_arena_release_clientfinish() { + // @@protoc_insertion_point(field_release:proto.HandshakeMessage.clientFinish) + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::HandshakeMessage_ClientFinish* temp = _impl_.clientfinish_; + _impl_.clientfinish_ = nullptr; + return temp; +} +inline ::proto::HandshakeMessage_ClientFinish* HandshakeMessage::_internal_mutable_clientfinish() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.clientfinish_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::HandshakeMessage_ClientFinish>(GetArenaForAllocation()); + _impl_.clientfinish_ = p; + } + return _impl_.clientfinish_; +} +inline ::proto::HandshakeMessage_ClientFinish* HandshakeMessage::mutable_clientfinish() { + ::proto::HandshakeMessage_ClientFinish* _msg = _internal_mutable_clientfinish(); + // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.clientFinish) + return _msg; +} +inline void HandshakeMessage::set_allocated_clientfinish(::proto::HandshakeMessage_ClientFinish* clientfinish) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.clientfinish_; + } + if (clientfinish) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(clientfinish); + if (message_arena != submessage_arena) { + clientfinish = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, clientfinish, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.clientfinish_ = clientfinish; + // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.clientFinish) +} + +// ------------------------------------------------------------------- + +// HistorySync + +// required .proto.HistorySync.HistorySyncType syncType = 1; +inline bool HistorySync::_internal_has_synctype() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool HistorySync::has_synctype() const { + return _internal_has_synctype(); +} +inline void HistorySync::clear_synctype() { + _impl_.synctype_ = 0; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline ::proto::HistorySync_HistorySyncType HistorySync::_internal_synctype() const { + return static_cast< ::proto::HistorySync_HistorySyncType >(_impl_.synctype_); +} +inline ::proto::HistorySync_HistorySyncType HistorySync::synctype() const { + // @@protoc_insertion_point(field_get:proto.HistorySync.syncType) + return _internal_synctype(); +} +inline void HistorySync::_internal_set_synctype(::proto::HistorySync_HistorySyncType value) { + assert(::proto::HistorySync_HistorySyncType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.synctype_ = value; +} +inline void HistorySync::set_synctype(::proto::HistorySync_HistorySyncType value) { + _internal_set_synctype(value); + // @@protoc_insertion_point(field_set:proto.HistorySync.syncType) +} + +// repeated .proto.Conversation conversations = 2; +inline int HistorySync::_internal_conversations_size() const { + return _impl_.conversations_.size(); +} +inline int HistorySync::conversations_size() const { + return _internal_conversations_size(); +} +inline void HistorySync::clear_conversations() { + _impl_.conversations_.Clear(); +} +inline ::proto::Conversation* HistorySync::mutable_conversations(int index) { + // @@protoc_insertion_point(field_mutable:proto.HistorySync.conversations) + return _impl_.conversations_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Conversation >* +HistorySync::mutable_conversations() { + // @@protoc_insertion_point(field_mutable_list:proto.HistorySync.conversations) + return &_impl_.conversations_; +} +inline const ::proto::Conversation& HistorySync::_internal_conversations(int index) const { + return _impl_.conversations_.Get(index); +} +inline const ::proto::Conversation& HistorySync::conversations(int index) const { + // @@protoc_insertion_point(field_get:proto.HistorySync.conversations) + return _internal_conversations(index); +} +inline ::proto::Conversation* HistorySync::_internal_add_conversations() { + return _impl_.conversations_.Add(); +} +inline ::proto::Conversation* HistorySync::add_conversations() { + ::proto::Conversation* _add = _internal_add_conversations(); + // @@protoc_insertion_point(field_add:proto.HistorySync.conversations) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Conversation >& +HistorySync::conversations() const { + // @@protoc_insertion_point(field_list:proto.HistorySync.conversations) + return _impl_.conversations_; +} + +// repeated .proto.WebMessageInfo statusV3Messages = 3; +inline int HistorySync::_internal_statusv3messages_size() const { + return _impl_.statusv3messages_.size(); +} +inline int HistorySync::statusv3messages_size() const { + return _internal_statusv3messages_size(); +} +inline void HistorySync::clear_statusv3messages() { + _impl_.statusv3messages_.Clear(); +} +inline ::proto::WebMessageInfo* HistorySync::mutable_statusv3messages(int index) { + // @@protoc_insertion_point(field_mutable:proto.HistorySync.statusV3Messages) + return _impl_.statusv3messages_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >* +HistorySync::mutable_statusv3messages() { + // @@protoc_insertion_point(field_mutable_list:proto.HistorySync.statusV3Messages) + return &_impl_.statusv3messages_; +} +inline const ::proto::WebMessageInfo& HistorySync::_internal_statusv3messages(int index) const { + return _impl_.statusv3messages_.Get(index); +} +inline const ::proto::WebMessageInfo& HistorySync::statusv3messages(int index) const { + // @@protoc_insertion_point(field_get:proto.HistorySync.statusV3Messages) + return _internal_statusv3messages(index); +} +inline ::proto::WebMessageInfo* HistorySync::_internal_add_statusv3messages() { + return _impl_.statusv3messages_.Add(); +} +inline ::proto::WebMessageInfo* HistorySync::add_statusv3messages() { + ::proto::WebMessageInfo* _add = _internal_add_statusv3messages(); + // @@protoc_insertion_point(field_add:proto.HistorySync.statusV3Messages) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >& +HistorySync::statusv3messages() const { + // @@protoc_insertion_point(field_list:proto.HistorySync.statusV3Messages) + return _impl_.statusv3messages_; +} + +// optional uint32 chunkOrder = 5; +inline bool HistorySync::_internal_has_chunkorder() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool HistorySync::has_chunkorder() const { + return _internal_has_chunkorder(); +} +inline void HistorySync::clear_chunkorder() { + _impl_.chunkorder_ = 0u; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline uint32_t HistorySync::_internal_chunkorder() const { + return _impl_.chunkorder_; +} +inline uint32_t HistorySync::chunkorder() const { + // @@protoc_insertion_point(field_get:proto.HistorySync.chunkOrder) + return _internal_chunkorder(); +} +inline void HistorySync::_internal_set_chunkorder(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.chunkorder_ = value; +} +inline void HistorySync::set_chunkorder(uint32_t value) { + _internal_set_chunkorder(value); + // @@protoc_insertion_point(field_set:proto.HistorySync.chunkOrder) +} + +// optional uint32 progress = 6; +inline bool HistorySync::_internal_has_progress() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool HistorySync::has_progress() const { + return _internal_has_progress(); +} +inline void HistorySync::clear_progress() { + _impl_.progress_ = 0u; + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline uint32_t HistorySync::_internal_progress() const { + return _impl_.progress_; +} +inline uint32_t HistorySync::progress() const { + // @@protoc_insertion_point(field_get:proto.HistorySync.progress) + return _internal_progress(); +} +inline void HistorySync::_internal_set_progress(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.progress_ = value; +} +inline void HistorySync::set_progress(uint32_t value) { + _internal_set_progress(value); + // @@protoc_insertion_point(field_set:proto.HistorySync.progress) +} + +// repeated .proto.Pushname pushnames = 7; +inline int HistorySync::_internal_pushnames_size() const { + return _impl_.pushnames_.size(); +} +inline int HistorySync::pushnames_size() const { + return _internal_pushnames_size(); +} +inline void HistorySync::clear_pushnames() { + _impl_.pushnames_.Clear(); +} +inline ::proto::Pushname* HistorySync::mutable_pushnames(int index) { + // @@protoc_insertion_point(field_mutable:proto.HistorySync.pushnames) + return _impl_.pushnames_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Pushname >* +HistorySync::mutable_pushnames() { + // @@protoc_insertion_point(field_mutable_list:proto.HistorySync.pushnames) + return &_impl_.pushnames_; +} +inline const ::proto::Pushname& HistorySync::_internal_pushnames(int index) const { + return _impl_.pushnames_.Get(index); +} +inline const ::proto::Pushname& HistorySync::pushnames(int index) const { + // @@protoc_insertion_point(field_get:proto.HistorySync.pushnames) + return _internal_pushnames(index); +} +inline ::proto::Pushname* HistorySync::_internal_add_pushnames() { + return _impl_.pushnames_.Add(); +} +inline ::proto::Pushname* HistorySync::add_pushnames() { + ::proto::Pushname* _add = _internal_add_pushnames(); + // @@protoc_insertion_point(field_add:proto.HistorySync.pushnames) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Pushname >& +HistorySync::pushnames() const { + // @@protoc_insertion_point(field_list:proto.HistorySync.pushnames) + return _impl_.pushnames_; +} + +// optional .proto.GlobalSettings globalSettings = 8; +inline bool HistorySync::_internal_has_globalsettings() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.globalsettings_ != nullptr); + return value; +} +inline bool HistorySync::has_globalsettings() const { + return _internal_has_globalsettings(); +} +inline void HistorySync::clear_globalsettings() { + if (_impl_.globalsettings_ != nullptr) _impl_.globalsettings_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::GlobalSettings& HistorySync::_internal_globalsettings() const { + const ::proto::GlobalSettings* p = _impl_.globalsettings_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_GlobalSettings_default_instance_); +} +inline const ::proto::GlobalSettings& HistorySync::globalsettings() const { + // @@protoc_insertion_point(field_get:proto.HistorySync.globalSettings) + return _internal_globalsettings(); +} +inline void HistorySync::unsafe_arena_set_allocated_globalsettings( + ::proto::GlobalSettings* globalsettings) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.globalsettings_); + } + _impl_.globalsettings_ = globalsettings; + if (globalsettings) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HistorySync.globalSettings) +} +inline ::proto::GlobalSettings* HistorySync::release_globalsettings() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::GlobalSettings* temp = _impl_.globalsettings_; + _impl_.globalsettings_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::GlobalSettings* HistorySync::unsafe_arena_release_globalsettings() { + // @@protoc_insertion_point(field_release:proto.HistorySync.globalSettings) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::GlobalSettings* temp = _impl_.globalsettings_; + _impl_.globalsettings_ = nullptr; + return temp; +} +inline ::proto::GlobalSettings* HistorySync::_internal_mutable_globalsettings() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.globalsettings_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::GlobalSettings>(GetArenaForAllocation()); + _impl_.globalsettings_ = p; + } + return _impl_.globalsettings_; +} +inline ::proto::GlobalSettings* HistorySync::mutable_globalsettings() { + ::proto::GlobalSettings* _msg = _internal_mutable_globalsettings(); + // @@protoc_insertion_point(field_mutable:proto.HistorySync.globalSettings) + return _msg; +} +inline void HistorySync::set_allocated_globalsettings(::proto::GlobalSettings* globalsettings) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.globalsettings_; + } + if (globalsettings) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(globalsettings); + if (message_arena != submessage_arena) { + globalsettings = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, globalsettings, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.globalsettings_ = globalsettings; + // @@protoc_insertion_point(field_set_allocated:proto.HistorySync.globalSettings) +} + +// optional bytes threadIdUserSecret = 9; +inline bool HistorySync::_internal_has_threadidusersecret() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool HistorySync::has_threadidusersecret() const { + return _internal_has_threadidusersecret(); +} +inline void HistorySync::clear_threadidusersecret() { + _impl_.threadidusersecret_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& HistorySync::threadidusersecret() const { + // @@protoc_insertion_point(field_get:proto.HistorySync.threadIdUserSecret) + return _internal_threadidusersecret(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void HistorySync::set_threadidusersecret(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.threadidusersecret_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.HistorySync.threadIdUserSecret) +} +inline std::string* HistorySync::mutable_threadidusersecret() { + std::string* _s = _internal_mutable_threadidusersecret(); + // @@protoc_insertion_point(field_mutable:proto.HistorySync.threadIdUserSecret) + return _s; +} +inline const std::string& HistorySync::_internal_threadidusersecret() const { + return _impl_.threadidusersecret_.Get(); +} +inline void HistorySync::_internal_set_threadidusersecret(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.threadidusersecret_.Set(value, GetArenaForAllocation()); +} +inline std::string* HistorySync::_internal_mutable_threadidusersecret() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.threadidusersecret_.Mutable(GetArenaForAllocation()); +} +inline std::string* HistorySync::release_threadidusersecret() { + // @@protoc_insertion_point(field_release:proto.HistorySync.threadIdUserSecret) + if (!_internal_has_threadidusersecret()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.threadidusersecret_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.threadidusersecret_.IsDefault()) { + _impl_.threadidusersecret_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void HistorySync::set_allocated_threadidusersecret(std::string* threadidusersecret) { + if (threadidusersecret != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.threadidusersecret_.SetAllocated(threadidusersecret, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.threadidusersecret_.IsDefault()) { + _impl_.threadidusersecret_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.HistorySync.threadIdUserSecret) +} + +// optional uint32 threadDsTimeframeOffset = 10; +inline bool HistorySync::_internal_has_threaddstimeframeoffset() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool HistorySync::has_threaddstimeframeoffset() const { + return _internal_has_threaddstimeframeoffset(); +} +inline void HistorySync::clear_threaddstimeframeoffset() { + _impl_.threaddstimeframeoffset_ = 0u; + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline uint32_t HistorySync::_internal_threaddstimeframeoffset() const { + return _impl_.threaddstimeframeoffset_; +} +inline uint32_t HistorySync::threaddstimeframeoffset() const { + // @@protoc_insertion_point(field_get:proto.HistorySync.threadDsTimeframeOffset) + return _internal_threaddstimeframeoffset(); +} +inline void HistorySync::_internal_set_threaddstimeframeoffset(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.threaddstimeframeoffset_ = value; +} +inline void HistorySync::set_threaddstimeframeoffset(uint32_t value) { + _internal_set_threaddstimeframeoffset(value); + // @@protoc_insertion_point(field_set:proto.HistorySync.threadDsTimeframeOffset) +} + +// repeated .proto.StickerMetadata recentStickers = 11; +inline int HistorySync::_internal_recentstickers_size() const { + return _impl_.recentstickers_.size(); +} +inline int HistorySync::recentstickers_size() const { + return _internal_recentstickers_size(); +} +inline void HistorySync::clear_recentstickers() { + _impl_.recentstickers_.Clear(); +} +inline ::proto::StickerMetadata* HistorySync::mutable_recentstickers(int index) { + // @@protoc_insertion_point(field_mutable:proto.HistorySync.recentStickers) + return _impl_.recentstickers_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::StickerMetadata >* +HistorySync::mutable_recentstickers() { + // @@protoc_insertion_point(field_mutable_list:proto.HistorySync.recentStickers) + return &_impl_.recentstickers_; +} +inline const ::proto::StickerMetadata& HistorySync::_internal_recentstickers(int index) const { + return _impl_.recentstickers_.Get(index); +} +inline const ::proto::StickerMetadata& HistorySync::recentstickers(int index) const { + // @@protoc_insertion_point(field_get:proto.HistorySync.recentStickers) + return _internal_recentstickers(index); +} +inline ::proto::StickerMetadata* HistorySync::_internal_add_recentstickers() { + return _impl_.recentstickers_.Add(); +} +inline ::proto::StickerMetadata* HistorySync::add_recentstickers() { + ::proto::StickerMetadata* _add = _internal_add_recentstickers(); + // @@protoc_insertion_point(field_add:proto.HistorySync.recentStickers) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::StickerMetadata >& +HistorySync::recentstickers() const { + // @@protoc_insertion_point(field_list:proto.HistorySync.recentStickers) + return _impl_.recentstickers_; +} + +// repeated .proto.PastParticipants pastParticipants = 12; +inline int HistorySync::_internal_pastparticipants_size() const { + return _impl_.pastparticipants_.size(); +} +inline int HistorySync::pastparticipants_size() const { + return _internal_pastparticipants_size(); +} +inline void HistorySync::clear_pastparticipants() { + _impl_.pastparticipants_.Clear(); +} +inline ::proto::PastParticipants* HistorySync::mutable_pastparticipants(int index) { + // @@protoc_insertion_point(field_mutable:proto.HistorySync.pastParticipants) + return _impl_.pastparticipants_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipants >* +HistorySync::mutable_pastparticipants() { + // @@protoc_insertion_point(field_mutable_list:proto.HistorySync.pastParticipants) + return &_impl_.pastparticipants_; +} +inline const ::proto::PastParticipants& HistorySync::_internal_pastparticipants(int index) const { + return _impl_.pastparticipants_.Get(index); +} +inline const ::proto::PastParticipants& HistorySync::pastparticipants(int index) const { + // @@protoc_insertion_point(field_get:proto.HistorySync.pastParticipants) + return _internal_pastparticipants(index); +} +inline ::proto::PastParticipants* HistorySync::_internal_add_pastparticipants() { + return _impl_.pastparticipants_.Add(); +} +inline ::proto::PastParticipants* HistorySync::add_pastparticipants() { + ::proto::PastParticipants* _add = _internal_add_pastparticipants(); + // @@protoc_insertion_point(field_add:proto.HistorySync.pastParticipants) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipants >& +HistorySync::pastparticipants() const { + // @@protoc_insertion_point(field_list:proto.HistorySync.pastParticipants) + return _impl_.pastparticipants_; +} + +// ------------------------------------------------------------------- + +// HistorySyncMsg + +// optional .proto.WebMessageInfo message = 1; +inline bool HistorySyncMsg::_internal_has_message() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.message_ != nullptr); + return value; +} +inline bool HistorySyncMsg::has_message() const { + return _internal_has_message(); +} +inline void HistorySyncMsg::clear_message() { + if (_impl_.message_ != nullptr) _impl_.message_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::WebMessageInfo& HistorySyncMsg::_internal_message() const { + const ::proto::WebMessageInfo* p = _impl_.message_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_WebMessageInfo_default_instance_); +} +inline const ::proto::WebMessageInfo& HistorySyncMsg::message() const { + // @@protoc_insertion_point(field_get:proto.HistorySyncMsg.message) + return _internal_message(); +} +inline void HistorySyncMsg::unsafe_arena_set_allocated_message( + ::proto::WebMessageInfo* message) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.message_); + } + _impl_.message_ = message; + if (message) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HistorySyncMsg.message) +} +inline ::proto::WebMessageInfo* HistorySyncMsg::release_message() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::WebMessageInfo* temp = _impl_.message_; + _impl_.message_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::WebMessageInfo* HistorySyncMsg::unsafe_arena_release_message() { + // @@protoc_insertion_point(field_release:proto.HistorySyncMsg.message) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::WebMessageInfo* temp = _impl_.message_; + _impl_.message_ = nullptr; + return temp; +} +inline ::proto::WebMessageInfo* HistorySyncMsg::_internal_mutable_message() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.message_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::WebMessageInfo>(GetArenaForAllocation()); + _impl_.message_ = p; + } + return _impl_.message_; +} +inline ::proto::WebMessageInfo* HistorySyncMsg::mutable_message() { + ::proto::WebMessageInfo* _msg = _internal_mutable_message(); + // @@protoc_insertion_point(field_mutable:proto.HistorySyncMsg.message) + return _msg; +} +inline void HistorySyncMsg::set_allocated_message(::proto::WebMessageInfo* message) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.message_; + } + if (message) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(message); + if (message_arena != submessage_arena) { + message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, message, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.message_ = message; + // @@protoc_insertion_point(field_set_allocated:proto.HistorySyncMsg.message) +} + +// optional uint64 msgOrderId = 2; +inline bool HistorySyncMsg::_internal_has_msgorderid() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool HistorySyncMsg::has_msgorderid() const { + return _internal_has_msgorderid(); +} +inline void HistorySyncMsg::clear_msgorderid() { + _impl_.msgorderid_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline uint64_t HistorySyncMsg::_internal_msgorderid() const { + return _impl_.msgorderid_; +} +inline uint64_t HistorySyncMsg::msgorderid() const { + // @@protoc_insertion_point(field_get:proto.HistorySyncMsg.msgOrderId) + return _internal_msgorderid(); +} +inline void HistorySyncMsg::_internal_set_msgorderid(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.msgorderid_ = value; +} +inline void HistorySyncMsg::set_msgorderid(uint64_t value) { + _internal_set_msgorderid(value); + // @@protoc_insertion_point(field_set:proto.HistorySyncMsg.msgOrderId) +} + +// ------------------------------------------------------------------- + +// HydratedTemplateButton_HydratedCallButton + +// optional string displayText = 1; +inline bool HydratedTemplateButton_HydratedCallButton::_internal_has_displaytext() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool HydratedTemplateButton_HydratedCallButton::has_displaytext() const { + return _internal_has_displaytext(); +} +inline void HydratedTemplateButton_HydratedCallButton::clear_displaytext() { + _impl_.displaytext_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& HydratedTemplateButton_HydratedCallButton::displaytext() const { + // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.HydratedCallButton.displayText) + return _internal_displaytext(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void HydratedTemplateButton_HydratedCallButton::set_displaytext(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.displaytext_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.HydratedTemplateButton.HydratedCallButton.displayText) +} +inline std::string* HydratedTemplateButton_HydratedCallButton::mutable_displaytext() { + std::string* _s = _internal_mutable_displaytext(); + // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.HydratedCallButton.displayText) + return _s; +} +inline const std::string& HydratedTemplateButton_HydratedCallButton::_internal_displaytext() const { + return _impl_.displaytext_.Get(); +} +inline void HydratedTemplateButton_HydratedCallButton::_internal_set_displaytext(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.displaytext_.Set(value, GetArenaForAllocation()); +} +inline std::string* HydratedTemplateButton_HydratedCallButton::_internal_mutable_displaytext() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.displaytext_.Mutable(GetArenaForAllocation()); +} +inline std::string* HydratedTemplateButton_HydratedCallButton::release_displaytext() { + // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.HydratedCallButton.displayText) + if (!_internal_has_displaytext()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.displaytext_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.displaytext_.IsDefault()) { + _impl_.displaytext_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void HydratedTemplateButton_HydratedCallButton::set_allocated_displaytext(std::string* displaytext) { + if (displaytext != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.displaytext_.SetAllocated(displaytext, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.displaytext_.IsDefault()) { + _impl_.displaytext_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.HydratedCallButton.displayText) +} + +// optional string phoneNumber = 2; +inline bool HydratedTemplateButton_HydratedCallButton::_internal_has_phonenumber() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool HydratedTemplateButton_HydratedCallButton::has_phonenumber() const { + return _internal_has_phonenumber(); +} +inline void HydratedTemplateButton_HydratedCallButton::clear_phonenumber() { + _impl_.phonenumber_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& HydratedTemplateButton_HydratedCallButton::phonenumber() const { + // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.HydratedCallButton.phoneNumber) + return _internal_phonenumber(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void HydratedTemplateButton_HydratedCallButton::set_phonenumber(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.phonenumber_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.HydratedTemplateButton.HydratedCallButton.phoneNumber) +} +inline std::string* HydratedTemplateButton_HydratedCallButton::mutable_phonenumber() { + std::string* _s = _internal_mutable_phonenumber(); + // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.HydratedCallButton.phoneNumber) + return _s; +} +inline const std::string& HydratedTemplateButton_HydratedCallButton::_internal_phonenumber() const { + return _impl_.phonenumber_.Get(); +} +inline void HydratedTemplateButton_HydratedCallButton::_internal_set_phonenumber(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.phonenumber_.Set(value, GetArenaForAllocation()); +} +inline std::string* HydratedTemplateButton_HydratedCallButton::_internal_mutable_phonenumber() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.phonenumber_.Mutable(GetArenaForAllocation()); +} +inline std::string* HydratedTemplateButton_HydratedCallButton::release_phonenumber() { + // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.HydratedCallButton.phoneNumber) + if (!_internal_has_phonenumber()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.phonenumber_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.phonenumber_.IsDefault()) { + _impl_.phonenumber_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void HydratedTemplateButton_HydratedCallButton::set_allocated_phonenumber(std::string* phonenumber) { + if (phonenumber != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.phonenumber_.SetAllocated(phonenumber, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.phonenumber_.IsDefault()) { + _impl_.phonenumber_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.HydratedCallButton.phoneNumber) +} + +// ------------------------------------------------------------------- + +// HydratedTemplateButton_HydratedQuickReplyButton + +// optional string displayText = 1; +inline bool HydratedTemplateButton_HydratedQuickReplyButton::_internal_has_displaytext() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool HydratedTemplateButton_HydratedQuickReplyButton::has_displaytext() const { + return _internal_has_displaytext(); +} +inline void HydratedTemplateButton_HydratedQuickReplyButton::clear_displaytext() { + _impl_.displaytext_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& HydratedTemplateButton_HydratedQuickReplyButton::displaytext() const { + // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.HydratedQuickReplyButton.displayText) + return _internal_displaytext(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void HydratedTemplateButton_HydratedQuickReplyButton::set_displaytext(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.displaytext_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.HydratedTemplateButton.HydratedQuickReplyButton.displayText) +} +inline std::string* HydratedTemplateButton_HydratedQuickReplyButton::mutable_displaytext() { + std::string* _s = _internal_mutable_displaytext(); + // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.HydratedQuickReplyButton.displayText) + return _s; +} +inline const std::string& HydratedTemplateButton_HydratedQuickReplyButton::_internal_displaytext() const { + return _impl_.displaytext_.Get(); +} +inline void HydratedTemplateButton_HydratedQuickReplyButton::_internal_set_displaytext(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.displaytext_.Set(value, GetArenaForAllocation()); +} +inline std::string* HydratedTemplateButton_HydratedQuickReplyButton::_internal_mutable_displaytext() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.displaytext_.Mutable(GetArenaForAllocation()); +} +inline std::string* HydratedTemplateButton_HydratedQuickReplyButton::release_displaytext() { + // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.HydratedQuickReplyButton.displayText) + if (!_internal_has_displaytext()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.displaytext_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.displaytext_.IsDefault()) { + _impl_.displaytext_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void HydratedTemplateButton_HydratedQuickReplyButton::set_allocated_displaytext(std::string* displaytext) { + if (displaytext != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.displaytext_.SetAllocated(displaytext, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.displaytext_.IsDefault()) { + _impl_.displaytext_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.HydratedQuickReplyButton.displayText) +} + +// optional string id = 2; +inline bool HydratedTemplateButton_HydratedQuickReplyButton::_internal_has_id() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool HydratedTemplateButton_HydratedQuickReplyButton::has_id() const { + return _internal_has_id(); +} +inline void HydratedTemplateButton_HydratedQuickReplyButton::clear_id() { + _impl_.id_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& HydratedTemplateButton_HydratedQuickReplyButton::id() const { + // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.HydratedQuickReplyButton.id) + return _internal_id(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void HydratedTemplateButton_HydratedQuickReplyButton::set_id(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.id_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.HydratedTemplateButton.HydratedQuickReplyButton.id) +} +inline std::string* HydratedTemplateButton_HydratedQuickReplyButton::mutable_id() { + std::string* _s = _internal_mutable_id(); + // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.HydratedQuickReplyButton.id) + return _s; +} +inline const std::string& HydratedTemplateButton_HydratedQuickReplyButton::_internal_id() const { + return _impl_.id_.Get(); +} +inline void HydratedTemplateButton_HydratedQuickReplyButton::_internal_set_id(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.id_.Set(value, GetArenaForAllocation()); +} +inline std::string* HydratedTemplateButton_HydratedQuickReplyButton::_internal_mutable_id() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.id_.Mutable(GetArenaForAllocation()); +} +inline std::string* HydratedTemplateButton_HydratedQuickReplyButton::release_id() { + // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.HydratedQuickReplyButton.id) + if (!_internal_has_id()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.id_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.id_.IsDefault()) { + _impl_.id_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void HydratedTemplateButton_HydratedQuickReplyButton::set_allocated_id(std::string* id) { + if (id != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.id_.SetAllocated(id, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.id_.IsDefault()) { + _impl_.id_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.HydratedQuickReplyButton.id) +} + +// ------------------------------------------------------------------- + +// HydratedTemplateButton_HydratedURLButton + +// optional string displayText = 1; +inline bool HydratedTemplateButton_HydratedURLButton::_internal_has_displaytext() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool HydratedTemplateButton_HydratedURLButton::has_displaytext() const { + return _internal_has_displaytext(); +} +inline void HydratedTemplateButton_HydratedURLButton::clear_displaytext() { + _impl_.displaytext_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& HydratedTemplateButton_HydratedURLButton::displaytext() const { + // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.HydratedURLButton.displayText) + return _internal_displaytext(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void HydratedTemplateButton_HydratedURLButton::set_displaytext(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.displaytext_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.HydratedTemplateButton.HydratedURLButton.displayText) +} +inline std::string* HydratedTemplateButton_HydratedURLButton::mutable_displaytext() { + std::string* _s = _internal_mutable_displaytext(); + // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.HydratedURLButton.displayText) + return _s; +} +inline const std::string& HydratedTemplateButton_HydratedURLButton::_internal_displaytext() const { + return _impl_.displaytext_.Get(); +} +inline void HydratedTemplateButton_HydratedURLButton::_internal_set_displaytext(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.displaytext_.Set(value, GetArenaForAllocation()); +} +inline std::string* HydratedTemplateButton_HydratedURLButton::_internal_mutable_displaytext() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.displaytext_.Mutable(GetArenaForAllocation()); +} +inline std::string* HydratedTemplateButton_HydratedURLButton::release_displaytext() { + // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.HydratedURLButton.displayText) + if (!_internal_has_displaytext()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.displaytext_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.displaytext_.IsDefault()) { + _impl_.displaytext_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void HydratedTemplateButton_HydratedURLButton::set_allocated_displaytext(std::string* displaytext) { + if (displaytext != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.displaytext_.SetAllocated(displaytext, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.displaytext_.IsDefault()) { + _impl_.displaytext_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.HydratedURLButton.displayText) +} + +// optional string url = 2; +inline bool HydratedTemplateButton_HydratedURLButton::_internal_has_url() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool HydratedTemplateButton_HydratedURLButton::has_url() const { + return _internal_has_url(); +} +inline void HydratedTemplateButton_HydratedURLButton::clear_url() { + _impl_.url_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& HydratedTemplateButton_HydratedURLButton::url() const { + // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.HydratedURLButton.url) + return _internal_url(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void HydratedTemplateButton_HydratedURLButton::set_url(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.url_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.HydratedTemplateButton.HydratedURLButton.url) +} +inline std::string* HydratedTemplateButton_HydratedURLButton::mutable_url() { + std::string* _s = _internal_mutable_url(); + // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.HydratedURLButton.url) + return _s; +} +inline const std::string& HydratedTemplateButton_HydratedURLButton::_internal_url() const { + return _impl_.url_.Get(); +} +inline void HydratedTemplateButton_HydratedURLButton::_internal_set_url(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.url_.Set(value, GetArenaForAllocation()); +} +inline std::string* HydratedTemplateButton_HydratedURLButton::_internal_mutable_url() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.url_.Mutable(GetArenaForAllocation()); +} +inline std::string* HydratedTemplateButton_HydratedURLButton::release_url() { + // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.HydratedURLButton.url) + if (!_internal_has_url()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.url_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.url_.IsDefault()) { + _impl_.url_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void HydratedTemplateButton_HydratedURLButton::set_allocated_url(std::string* url) { + if (url != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.url_.SetAllocated(url, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.url_.IsDefault()) { + _impl_.url_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.HydratedURLButton.url) +} + +// ------------------------------------------------------------------- + +// HydratedTemplateButton + +// optional uint32 index = 4; +inline bool HydratedTemplateButton::_internal_has_index() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool HydratedTemplateButton::has_index() const { + return _internal_has_index(); +} +inline void HydratedTemplateButton::clear_index() { + _impl_.index_ = 0u; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline uint32_t HydratedTemplateButton::_internal_index() const { + return _impl_.index_; +} +inline uint32_t HydratedTemplateButton::index() const { + // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.index) + return _internal_index(); +} +inline void HydratedTemplateButton::_internal_set_index(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.index_ = value; +} +inline void HydratedTemplateButton::set_index(uint32_t value) { + _internal_set_index(value); + // @@protoc_insertion_point(field_set:proto.HydratedTemplateButton.index) +} + +// .proto.HydratedTemplateButton.HydratedQuickReplyButton quickReplyButton = 1; +inline bool HydratedTemplateButton::_internal_has_quickreplybutton() const { + return hydratedButton_case() == kQuickReplyButton; +} +inline bool HydratedTemplateButton::has_quickreplybutton() const { + return _internal_has_quickreplybutton(); +} +inline void HydratedTemplateButton::set_has_quickreplybutton() { + _impl_._oneof_case_[0] = kQuickReplyButton; +} +inline void HydratedTemplateButton::clear_quickreplybutton() { + if (_internal_has_quickreplybutton()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.hydratedButton_.quickreplybutton_; + } + clear_has_hydratedButton(); + } +} +inline ::proto::HydratedTemplateButton_HydratedQuickReplyButton* HydratedTemplateButton::release_quickreplybutton() { + // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.quickReplyButton) + if (_internal_has_quickreplybutton()) { + clear_has_hydratedButton(); + ::proto::HydratedTemplateButton_HydratedQuickReplyButton* temp = _impl_.hydratedButton_.quickreplybutton_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.hydratedButton_.quickreplybutton_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::HydratedTemplateButton_HydratedQuickReplyButton& HydratedTemplateButton::_internal_quickreplybutton() const { + return _internal_has_quickreplybutton() + ? *_impl_.hydratedButton_.quickreplybutton_ + : reinterpret_cast< ::proto::HydratedTemplateButton_HydratedQuickReplyButton&>(::proto::_HydratedTemplateButton_HydratedQuickReplyButton_default_instance_); +} +inline const ::proto::HydratedTemplateButton_HydratedQuickReplyButton& HydratedTemplateButton::quickreplybutton() const { + // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.quickReplyButton) + return _internal_quickreplybutton(); +} +inline ::proto::HydratedTemplateButton_HydratedQuickReplyButton* HydratedTemplateButton::unsafe_arena_release_quickreplybutton() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.HydratedTemplateButton.quickReplyButton) + if (_internal_has_quickreplybutton()) { + clear_has_hydratedButton(); + ::proto::HydratedTemplateButton_HydratedQuickReplyButton* temp = _impl_.hydratedButton_.quickreplybutton_; + _impl_.hydratedButton_.quickreplybutton_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void HydratedTemplateButton::unsafe_arena_set_allocated_quickreplybutton(::proto::HydratedTemplateButton_HydratedQuickReplyButton* quickreplybutton) { + clear_hydratedButton(); + if (quickreplybutton) { + set_has_quickreplybutton(); + _impl_.hydratedButton_.quickreplybutton_ = quickreplybutton; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HydratedTemplateButton.quickReplyButton) +} +inline ::proto::HydratedTemplateButton_HydratedQuickReplyButton* HydratedTemplateButton::_internal_mutable_quickreplybutton() { + if (!_internal_has_quickreplybutton()) { + clear_hydratedButton(); + set_has_quickreplybutton(); + _impl_.hydratedButton_.quickreplybutton_ = CreateMaybeMessage< ::proto::HydratedTemplateButton_HydratedQuickReplyButton >(GetArenaForAllocation()); + } + return _impl_.hydratedButton_.quickreplybutton_; +} +inline ::proto::HydratedTemplateButton_HydratedQuickReplyButton* HydratedTemplateButton::mutable_quickreplybutton() { + ::proto::HydratedTemplateButton_HydratedQuickReplyButton* _msg = _internal_mutable_quickreplybutton(); + // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.quickReplyButton) + return _msg; +} + +// .proto.HydratedTemplateButton.HydratedURLButton urlButton = 2; +inline bool HydratedTemplateButton::_internal_has_urlbutton() const { + return hydratedButton_case() == kUrlButton; +} +inline bool HydratedTemplateButton::has_urlbutton() const { + return _internal_has_urlbutton(); +} +inline void HydratedTemplateButton::set_has_urlbutton() { + _impl_._oneof_case_[0] = kUrlButton; +} +inline void HydratedTemplateButton::clear_urlbutton() { + if (_internal_has_urlbutton()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.hydratedButton_.urlbutton_; + } + clear_has_hydratedButton(); + } +} +inline ::proto::HydratedTemplateButton_HydratedURLButton* HydratedTemplateButton::release_urlbutton() { + // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.urlButton) + if (_internal_has_urlbutton()) { + clear_has_hydratedButton(); + ::proto::HydratedTemplateButton_HydratedURLButton* temp = _impl_.hydratedButton_.urlbutton_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.hydratedButton_.urlbutton_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::HydratedTemplateButton_HydratedURLButton& HydratedTemplateButton::_internal_urlbutton() const { + return _internal_has_urlbutton() + ? *_impl_.hydratedButton_.urlbutton_ + : reinterpret_cast< ::proto::HydratedTemplateButton_HydratedURLButton&>(::proto::_HydratedTemplateButton_HydratedURLButton_default_instance_); +} +inline const ::proto::HydratedTemplateButton_HydratedURLButton& HydratedTemplateButton::urlbutton() const { + // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.urlButton) + return _internal_urlbutton(); +} +inline ::proto::HydratedTemplateButton_HydratedURLButton* HydratedTemplateButton::unsafe_arena_release_urlbutton() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.HydratedTemplateButton.urlButton) + if (_internal_has_urlbutton()) { + clear_has_hydratedButton(); + ::proto::HydratedTemplateButton_HydratedURLButton* temp = _impl_.hydratedButton_.urlbutton_; + _impl_.hydratedButton_.urlbutton_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void HydratedTemplateButton::unsafe_arena_set_allocated_urlbutton(::proto::HydratedTemplateButton_HydratedURLButton* urlbutton) { + clear_hydratedButton(); + if (urlbutton) { + set_has_urlbutton(); + _impl_.hydratedButton_.urlbutton_ = urlbutton; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HydratedTemplateButton.urlButton) +} +inline ::proto::HydratedTemplateButton_HydratedURLButton* HydratedTemplateButton::_internal_mutable_urlbutton() { + if (!_internal_has_urlbutton()) { + clear_hydratedButton(); + set_has_urlbutton(); + _impl_.hydratedButton_.urlbutton_ = CreateMaybeMessage< ::proto::HydratedTemplateButton_HydratedURLButton >(GetArenaForAllocation()); + } + return _impl_.hydratedButton_.urlbutton_; +} +inline ::proto::HydratedTemplateButton_HydratedURLButton* HydratedTemplateButton::mutable_urlbutton() { + ::proto::HydratedTemplateButton_HydratedURLButton* _msg = _internal_mutable_urlbutton(); + // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.urlButton) + return _msg; +} + +// .proto.HydratedTemplateButton.HydratedCallButton callButton = 3; +inline bool HydratedTemplateButton::_internal_has_callbutton() const { + return hydratedButton_case() == kCallButton; +} +inline bool HydratedTemplateButton::has_callbutton() const { + return _internal_has_callbutton(); +} +inline void HydratedTemplateButton::set_has_callbutton() { + _impl_._oneof_case_[0] = kCallButton; +} +inline void HydratedTemplateButton::clear_callbutton() { + if (_internal_has_callbutton()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.hydratedButton_.callbutton_; + } + clear_has_hydratedButton(); + } +} +inline ::proto::HydratedTemplateButton_HydratedCallButton* HydratedTemplateButton::release_callbutton() { + // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.callButton) + if (_internal_has_callbutton()) { + clear_has_hydratedButton(); + ::proto::HydratedTemplateButton_HydratedCallButton* temp = _impl_.hydratedButton_.callbutton_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.hydratedButton_.callbutton_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::HydratedTemplateButton_HydratedCallButton& HydratedTemplateButton::_internal_callbutton() const { + return _internal_has_callbutton() + ? *_impl_.hydratedButton_.callbutton_ + : reinterpret_cast< ::proto::HydratedTemplateButton_HydratedCallButton&>(::proto::_HydratedTemplateButton_HydratedCallButton_default_instance_); +} +inline const ::proto::HydratedTemplateButton_HydratedCallButton& HydratedTemplateButton::callbutton() const { + // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.callButton) + return _internal_callbutton(); +} +inline ::proto::HydratedTemplateButton_HydratedCallButton* HydratedTemplateButton::unsafe_arena_release_callbutton() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.HydratedTemplateButton.callButton) + if (_internal_has_callbutton()) { + clear_has_hydratedButton(); + ::proto::HydratedTemplateButton_HydratedCallButton* temp = _impl_.hydratedButton_.callbutton_; + _impl_.hydratedButton_.callbutton_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void HydratedTemplateButton::unsafe_arena_set_allocated_callbutton(::proto::HydratedTemplateButton_HydratedCallButton* callbutton) { + clear_hydratedButton(); + if (callbutton) { + set_has_callbutton(); + _impl_.hydratedButton_.callbutton_ = callbutton; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HydratedTemplateButton.callButton) +} +inline ::proto::HydratedTemplateButton_HydratedCallButton* HydratedTemplateButton::_internal_mutable_callbutton() { + if (!_internal_has_callbutton()) { + clear_hydratedButton(); + set_has_callbutton(); + _impl_.hydratedButton_.callbutton_ = CreateMaybeMessage< ::proto::HydratedTemplateButton_HydratedCallButton >(GetArenaForAllocation()); + } + return _impl_.hydratedButton_.callbutton_; +} +inline ::proto::HydratedTemplateButton_HydratedCallButton* HydratedTemplateButton::mutable_callbutton() { + ::proto::HydratedTemplateButton_HydratedCallButton* _msg = _internal_mutable_callbutton(); + // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.callButton) + return _msg; +} + +inline bool HydratedTemplateButton::has_hydratedButton() const { + return hydratedButton_case() != HYDRATEDBUTTON_NOT_SET; +} +inline void HydratedTemplateButton::clear_has_hydratedButton() { + _impl_._oneof_case_[0] = HYDRATEDBUTTON_NOT_SET; +} +inline HydratedTemplateButton::HydratedButtonCase HydratedTemplateButton::hydratedButton_case() const { + return HydratedTemplateButton::HydratedButtonCase(_impl_._oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// IdentityKeyPairStructure + +// optional bytes publicKey = 1; +inline bool IdentityKeyPairStructure::_internal_has_publickey() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool IdentityKeyPairStructure::has_publickey() const { + return _internal_has_publickey(); +} +inline void IdentityKeyPairStructure::clear_publickey() { + _impl_.publickey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& IdentityKeyPairStructure::publickey() const { + // @@protoc_insertion_point(field_get:proto.IdentityKeyPairStructure.publicKey) + return _internal_publickey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void IdentityKeyPairStructure::set_publickey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.publickey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.IdentityKeyPairStructure.publicKey) +} +inline std::string* IdentityKeyPairStructure::mutable_publickey() { + std::string* _s = _internal_mutable_publickey(); + // @@protoc_insertion_point(field_mutable:proto.IdentityKeyPairStructure.publicKey) + return _s; +} +inline const std::string& IdentityKeyPairStructure::_internal_publickey() const { + return _impl_.publickey_.Get(); +} +inline void IdentityKeyPairStructure::_internal_set_publickey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.publickey_.Set(value, GetArenaForAllocation()); +} +inline std::string* IdentityKeyPairStructure::_internal_mutable_publickey() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.publickey_.Mutable(GetArenaForAllocation()); +} +inline std::string* IdentityKeyPairStructure::release_publickey() { + // @@protoc_insertion_point(field_release:proto.IdentityKeyPairStructure.publicKey) + if (!_internal_has_publickey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.publickey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.publickey_.IsDefault()) { + _impl_.publickey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void IdentityKeyPairStructure::set_allocated_publickey(std::string* publickey) { + if (publickey != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.publickey_.SetAllocated(publickey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.publickey_.IsDefault()) { + _impl_.publickey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.IdentityKeyPairStructure.publicKey) +} + +// optional bytes privateKey = 2; +inline bool IdentityKeyPairStructure::_internal_has_privatekey() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool IdentityKeyPairStructure::has_privatekey() const { + return _internal_has_privatekey(); +} +inline void IdentityKeyPairStructure::clear_privatekey() { + _impl_.privatekey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& IdentityKeyPairStructure::privatekey() const { + // @@protoc_insertion_point(field_get:proto.IdentityKeyPairStructure.privateKey) + return _internal_privatekey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void IdentityKeyPairStructure::set_privatekey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.privatekey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.IdentityKeyPairStructure.privateKey) +} +inline std::string* IdentityKeyPairStructure::mutable_privatekey() { + std::string* _s = _internal_mutable_privatekey(); + // @@protoc_insertion_point(field_mutable:proto.IdentityKeyPairStructure.privateKey) + return _s; +} +inline const std::string& IdentityKeyPairStructure::_internal_privatekey() const { + return _impl_.privatekey_.Get(); +} +inline void IdentityKeyPairStructure::_internal_set_privatekey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.privatekey_.Set(value, GetArenaForAllocation()); +} +inline std::string* IdentityKeyPairStructure::_internal_mutable_privatekey() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.privatekey_.Mutable(GetArenaForAllocation()); +} +inline std::string* IdentityKeyPairStructure::release_privatekey() { + // @@protoc_insertion_point(field_release:proto.IdentityKeyPairStructure.privateKey) + if (!_internal_has_privatekey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.privatekey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.privatekey_.IsDefault()) { + _impl_.privatekey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void IdentityKeyPairStructure::set_allocated_privatekey(std::string* privatekey) { + if (privatekey != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.privatekey_.SetAllocated(privatekey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.privatekey_.IsDefault()) { + _impl_.privatekey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.IdentityKeyPairStructure.privateKey) +} + +// ------------------------------------------------------------------- + +// InteractiveAnnotation + +// repeated .proto.Point polygonVertices = 1; +inline int InteractiveAnnotation::_internal_polygonvertices_size() const { + return _impl_.polygonvertices_.size(); +} +inline int InteractiveAnnotation::polygonvertices_size() const { + return _internal_polygonvertices_size(); +} +inline void InteractiveAnnotation::clear_polygonvertices() { + _impl_.polygonvertices_.Clear(); +} +inline ::proto::Point* InteractiveAnnotation::mutable_polygonvertices(int index) { + // @@protoc_insertion_point(field_mutable:proto.InteractiveAnnotation.polygonVertices) + return _impl_.polygonvertices_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Point >* +InteractiveAnnotation::mutable_polygonvertices() { + // @@protoc_insertion_point(field_mutable_list:proto.InteractiveAnnotation.polygonVertices) + return &_impl_.polygonvertices_; +} +inline const ::proto::Point& InteractiveAnnotation::_internal_polygonvertices(int index) const { + return _impl_.polygonvertices_.Get(index); +} +inline const ::proto::Point& InteractiveAnnotation::polygonvertices(int index) const { + // @@protoc_insertion_point(field_get:proto.InteractiveAnnotation.polygonVertices) + return _internal_polygonvertices(index); +} +inline ::proto::Point* InteractiveAnnotation::_internal_add_polygonvertices() { + return _impl_.polygonvertices_.Add(); +} +inline ::proto::Point* InteractiveAnnotation::add_polygonvertices() { + ::proto::Point* _add = _internal_add_polygonvertices(); + // @@protoc_insertion_point(field_add:proto.InteractiveAnnotation.polygonVertices) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Point >& +InteractiveAnnotation::polygonvertices() const { + // @@protoc_insertion_point(field_list:proto.InteractiveAnnotation.polygonVertices) + return _impl_.polygonvertices_; +} + +// .proto.Location location = 2; +inline bool InteractiveAnnotation::_internal_has_location() const { + return action_case() == kLocation; +} +inline bool InteractiveAnnotation::has_location() const { + return _internal_has_location(); +} +inline void InteractiveAnnotation::set_has_location() { + _impl_._oneof_case_[0] = kLocation; +} +inline void InteractiveAnnotation::clear_location() { + if (_internal_has_location()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.action_.location_; + } + clear_has_action(); + } +} +inline ::proto::Location* InteractiveAnnotation::release_location() { + // @@protoc_insertion_point(field_release:proto.InteractiveAnnotation.location) + if (_internal_has_location()) { + clear_has_action(); + ::proto::Location* temp = _impl_.action_.location_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.action_.location_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::Location& InteractiveAnnotation::_internal_location() const { + return _internal_has_location() + ? *_impl_.action_.location_ + : reinterpret_cast< ::proto::Location&>(::proto::_Location_default_instance_); +} +inline const ::proto::Location& InteractiveAnnotation::location() const { + // @@protoc_insertion_point(field_get:proto.InteractiveAnnotation.location) + return _internal_location(); +} +inline ::proto::Location* InteractiveAnnotation::unsafe_arena_release_location() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.InteractiveAnnotation.location) + if (_internal_has_location()) { + clear_has_action(); + ::proto::Location* temp = _impl_.action_.location_; + _impl_.action_.location_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void InteractiveAnnotation::unsafe_arena_set_allocated_location(::proto::Location* location) { + clear_action(); + if (location) { + set_has_location(); + _impl_.action_.location_ = location; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.InteractiveAnnotation.location) +} +inline ::proto::Location* InteractiveAnnotation::_internal_mutable_location() { + if (!_internal_has_location()) { + clear_action(); + set_has_location(); + _impl_.action_.location_ = CreateMaybeMessage< ::proto::Location >(GetArenaForAllocation()); + } + return _impl_.action_.location_; +} +inline ::proto::Location* InteractiveAnnotation::mutable_location() { + ::proto::Location* _msg = _internal_mutable_location(); + // @@protoc_insertion_point(field_mutable:proto.InteractiveAnnotation.location) + return _msg; +} + +inline bool InteractiveAnnotation::has_action() const { + return action_case() != ACTION_NOT_SET; +} +inline void InteractiveAnnotation::clear_has_action() { + _impl_._oneof_case_[0] = ACTION_NOT_SET; +} +inline InteractiveAnnotation::ActionCase InteractiveAnnotation::action_case() const { + return InteractiveAnnotation::ActionCase(_impl_._oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// KeepInChat + +// optional .proto.KeepType keepType = 1; +inline bool KeepInChat::_internal_has_keeptype() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool KeepInChat::has_keeptype() const { + return _internal_has_keeptype(); +} +inline void KeepInChat::clear_keeptype() { + _impl_.keeptype_ = 0; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline ::proto::KeepType KeepInChat::_internal_keeptype() const { + return static_cast< ::proto::KeepType >(_impl_.keeptype_); +} +inline ::proto::KeepType KeepInChat::keeptype() const { + // @@protoc_insertion_point(field_get:proto.KeepInChat.keepType) + return _internal_keeptype(); +} +inline void KeepInChat::_internal_set_keeptype(::proto::KeepType value) { + assert(::proto::KeepType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.keeptype_ = value; +} +inline void KeepInChat::set_keeptype(::proto::KeepType value) { + _internal_set_keeptype(value); + // @@protoc_insertion_point(field_set:proto.KeepInChat.keepType) +} + +// optional int64 serverTimestamp = 2; +inline bool KeepInChat::_internal_has_servertimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool KeepInChat::has_servertimestamp() const { + return _internal_has_servertimestamp(); +} +inline void KeepInChat::clear_servertimestamp() { + _impl_.servertimestamp_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline int64_t KeepInChat::_internal_servertimestamp() const { + return _impl_.servertimestamp_; +} +inline int64_t KeepInChat::servertimestamp() const { + // @@protoc_insertion_point(field_get:proto.KeepInChat.serverTimestamp) + return _internal_servertimestamp(); +} +inline void KeepInChat::_internal_set_servertimestamp(int64_t value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.servertimestamp_ = value; +} +inline void KeepInChat::set_servertimestamp(int64_t value) { + _internal_set_servertimestamp(value); + // @@protoc_insertion_point(field_set:proto.KeepInChat.serverTimestamp) +} + +// optional .proto.MessageKey key = 3; +inline bool KeepInChat::_internal_has_key() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr); + return value; +} +inline bool KeepInChat::has_key() const { + return _internal_has_key(); +} +inline void KeepInChat::clear_key() { + if (_impl_.key_ != nullptr) _impl_.key_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::MessageKey& KeepInChat::_internal_key() const { + const ::proto::MessageKey* p = _impl_.key_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_MessageKey_default_instance_); +} +inline const ::proto::MessageKey& KeepInChat::key() const { + // @@protoc_insertion_point(field_get:proto.KeepInChat.key) + return _internal_key(); +} +inline void KeepInChat::unsafe_arena_set_allocated_key( + ::proto::MessageKey* key) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_); + } + _impl_.key_ = key; + if (key) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.KeepInChat.key) +} +inline ::proto::MessageKey* KeepInChat::release_key() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::MessageKey* temp = _impl_.key_; + _impl_.key_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::MessageKey* KeepInChat::unsafe_arena_release_key() { + // @@protoc_insertion_point(field_release:proto.KeepInChat.key) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::MessageKey* temp = _impl_.key_; + _impl_.key_ = nullptr; + return temp; +} +inline ::proto::MessageKey* KeepInChat::_internal_mutable_key() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.key_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation()); + _impl_.key_ = p; + } + return _impl_.key_; +} +inline ::proto::MessageKey* KeepInChat::mutable_key() { + ::proto::MessageKey* _msg = _internal_mutable_key(); + // @@protoc_insertion_point(field_mutable:proto.KeepInChat.key) + return _msg; +} +inline void KeepInChat::set_allocated_key(::proto::MessageKey* key) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.key_; + } + if (key) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key); + if (message_arena != submessage_arena) { + key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, key, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.key_ = key; + // @@protoc_insertion_point(field_set_allocated:proto.KeepInChat.key) +} + +// optional string deviceJid = 4; +inline bool KeepInChat::_internal_has_devicejid() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool KeepInChat::has_devicejid() const { + return _internal_has_devicejid(); +} +inline void KeepInChat::clear_devicejid() { + _impl_.devicejid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& KeepInChat::devicejid() const { + // @@protoc_insertion_point(field_get:proto.KeepInChat.deviceJid) + return _internal_devicejid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void KeepInChat::set_devicejid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.devicejid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.KeepInChat.deviceJid) +} +inline std::string* KeepInChat::mutable_devicejid() { + std::string* _s = _internal_mutable_devicejid(); + // @@protoc_insertion_point(field_mutable:proto.KeepInChat.deviceJid) + return _s; +} +inline const std::string& KeepInChat::_internal_devicejid() const { + return _impl_.devicejid_.Get(); +} +inline void KeepInChat::_internal_set_devicejid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.devicejid_.Set(value, GetArenaForAllocation()); +} +inline std::string* KeepInChat::_internal_mutable_devicejid() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.devicejid_.Mutable(GetArenaForAllocation()); +} +inline std::string* KeepInChat::release_devicejid() { + // @@protoc_insertion_point(field_release:proto.KeepInChat.deviceJid) + if (!_internal_has_devicejid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.devicejid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.devicejid_.IsDefault()) { + _impl_.devicejid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void KeepInChat::set_allocated_devicejid(std::string* devicejid) { + if (devicejid != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.devicejid_.SetAllocated(devicejid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.devicejid_.IsDefault()) { + _impl_.devicejid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.KeepInChat.deviceJid) +} + +// ------------------------------------------------------------------- + +// KeyId + +// optional bytes id = 1; +inline bool KeyId::_internal_has_id() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool KeyId::has_id() const { + return _internal_has_id(); +} +inline void KeyId::clear_id() { + _impl_.id_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& KeyId::id() const { + // @@protoc_insertion_point(field_get:proto.KeyId.id) + return _internal_id(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void KeyId::set_id(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.id_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.KeyId.id) +} +inline std::string* KeyId::mutable_id() { + std::string* _s = _internal_mutable_id(); + // @@protoc_insertion_point(field_mutable:proto.KeyId.id) + return _s; +} +inline const std::string& KeyId::_internal_id() const { + return _impl_.id_.Get(); +} +inline void KeyId::_internal_set_id(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.id_.Set(value, GetArenaForAllocation()); +} +inline std::string* KeyId::_internal_mutable_id() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.id_.Mutable(GetArenaForAllocation()); +} +inline std::string* KeyId::release_id() { + // @@protoc_insertion_point(field_release:proto.KeyId.id) + if (!_internal_has_id()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.id_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.id_.IsDefault()) { + _impl_.id_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void KeyId::set_allocated_id(std::string* id) { + if (id != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.id_.SetAllocated(id, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.id_.IsDefault()) { + _impl_.id_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.KeyId.id) +} + +// ------------------------------------------------------------------- + +// LocalizedName + +// optional string lg = 1; +inline bool LocalizedName::_internal_has_lg() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool LocalizedName::has_lg() const { + return _internal_has_lg(); +} +inline void LocalizedName::clear_lg() { + _impl_.lg_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& LocalizedName::lg() const { + // @@protoc_insertion_point(field_get:proto.LocalizedName.lg) + return _internal_lg(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void LocalizedName::set_lg(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.lg_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.LocalizedName.lg) +} +inline std::string* LocalizedName::mutable_lg() { + std::string* _s = _internal_mutable_lg(); + // @@protoc_insertion_point(field_mutable:proto.LocalizedName.lg) + return _s; +} +inline const std::string& LocalizedName::_internal_lg() const { + return _impl_.lg_.Get(); +} +inline void LocalizedName::_internal_set_lg(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.lg_.Set(value, GetArenaForAllocation()); +} +inline std::string* LocalizedName::_internal_mutable_lg() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.lg_.Mutable(GetArenaForAllocation()); +} +inline std::string* LocalizedName::release_lg() { + // @@protoc_insertion_point(field_release:proto.LocalizedName.lg) + if (!_internal_has_lg()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.lg_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.lg_.IsDefault()) { + _impl_.lg_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void LocalizedName::set_allocated_lg(std::string* lg) { + if (lg != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.lg_.SetAllocated(lg, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.lg_.IsDefault()) { + _impl_.lg_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.LocalizedName.lg) +} + +// optional string lc = 2; +inline bool LocalizedName::_internal_has_lc() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool LocalizedName::has_lc() const { + return _internal_has_lc(); +} +inline void LocalizedName::clear_lc() { + _impl_.lc_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& LocalizedName::lc() const { + // @@protoc_insertion_point(field_get:proto.LocalizedName.lc) + return _internal_lc(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void LocalizedName::set_lc(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.lc_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.LocalizedName.lc) +} +inline std::string* LocalizedName::mutable_lc() { + std::string* _s = _internal_mutable_lc(); + // @@protoc_insertion_point(field_mutable:proto.LocalizedName.lc) + return _s; +} +inline const std::string& LocalizedName::_internal_lc() const { + return _impl_.lc_.Get(); +} +inline void LocalizedName::_internal_set_lc(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.lc_.Set(value, GetArenaForAllocation()); +} +inline std::string* LocalizedName::_internal_mutable_lc() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.lc_.Mutable(GetArenaForAllocation()); +} +inline std::string* LocalizedName::release_lc() { + // @@protoc_insertion_point(field_release:proto.LocalizedName.lc) + if (!_internal_has_lc()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.lc_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.lc_.IsDefault()) { + _impl_.lc_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void LocalizedName::set_allocated_lc(std::string* lc) { + if (lc != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.lc_.SetAllocated(lc, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.lc_.IsDefault()) { + _impl_.lc_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.LocalizedName.lc) +} + +// optional string verifiedName = 3; +inline bool LocalizedName::_internal_has_verifiedname() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool LocalizedName::has_verifiedname() const { + return _internal_has_verifiedname(); +} +inline void LocalizedName::clear_verifiedname() { + _impl_.verifiedname_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& LocalizedName::verifiedname() const { + // @@protoc_insertion_point(field_get:proto.LocalizedName.verifiedName) + return _internal_verifiedname(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void LocalizedName::set_verifiedname(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.verifiedname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.LocalizedName.verifiedName) +} +inline std::string* LocalizedName::mutable_verifiedname() { + std::string* _s = _internal_mutable_verifiedname(); + // @@protoc_insertion_point(field_mutable:proto.LocalizedName.verifiedName) + return _s; +} +inline const std::string& LocalizedName::_internal_verifiedname() const { + return _impl_.verifiedname_.Get(); +} +inline void LocalizedName::_internal_set_verifiedname(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.verifiedname_.Set(value, GetArenaForAllocation()); +} +inline std::string* LocalizedName::_internal_mutable_verifiedname() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.verifiedname_.Mutable(GetArenaForAllocation()); +} +inline std::string* LocalizedName::release_verifiedname() { + // @@protoc_insertion_point(field_release:proto.LocalizedName.verifiedName) + if (!_internal_has_verifiedname()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.verifiedname_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.verifiedname_.IsDefault()) { + _impl_.verifiedname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void LocalizedName::set_allocated_verifiedname(std::string* verifiedname) { + if (verifiedname != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.verifiedname_.SetAllocated(verifiedname, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.verifiedname_.IsDefault()) { + _impl_.verifiedname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.LocalizedName.verifiedName) +} + +// ------------------------------------------------------------------- + +// Location + +// optional double degreesLatitude = 1; +inline bool Location::_internal_has_degreeslatitude() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Location::has_degreeslatitude() const { + return _internal_has_degreeslatitude(); +} +inline void Location::clear_degreeslatitude() { + _impl_.degreeslatitude_ = 0; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline double Location::_internal_degreeslatitude() const { + return _impl_.degreeslatitude_; +} +inline double Location::degreeslatitude() const { + // @@protoc_insertion_point(field_get:proto.Location.degreesLatitude) + return _internal_degreeslatitude(); +} +inline void Location::_internal_set_degreeslatitude(double value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.degreeslatitude_ = value; +} +inline void Location::set_degreeslatitude(double value) { + _internal_set_degreeslatitude(value); + // @@protoc_insertion_point(field_set:proto.Location.degreesLatitude) +} + +// optional double degreesLongitude = 2; +inline bool Location::_internal_has_degreeslongitude() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Location::has_degreeslongitude() const { + return _internal_has_degreeslongitude(); +} +inline void Location::clear_degreeslongitude() { + _impl_.degreeslongitude_ = 0; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline double Location::_internal_degreeslongitude() const { + return _impl_.degreeslongitude_; +} +inline double Location::degreeslongitude() const { + // @@protoc_insertion_point(field_get:proto.Location.degreesLongitude) + return _internal_degreeslongitude(); +} +inline void Location::_internal_set_degreeslongitude(double value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.degreeslongitude_ = value; +} +inline void Location::set_degreeslongitude(double value) { + _internal_set_degreeslongitude(value); + // @@protoc_insertion_point(field_set:proto.Location.degreesLongitude) +} + +// optional string name = 3; +inline bool Location::_internal_has_name() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Location::has_name() const { + return _internal_has_name(); +} +inline void Location::clear_name() { + _impl_.name_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Location::name() const { + // @@protoc_insertion_point(field_get:proto.Location.name) + return _internal_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Location::set_name(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Location.name) +} +inline std::string* Location::mutable_name() { + std::string* _s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:proto.Location.name) + return _s; +} +inline const std::string& Location::_internal_name() const { + return _impl_.name_.Get(); +} +inline void Location::_internal_set_name(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.name_.Set(value, GetArenaForAllocation()); +} +inline std::string* Location::_internal_mutable_name() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.name_.Mutable(GetArenaForAllocation()); +} +inline std::string* Location::release_name() { + // @@protoc_insertion_point(field_release:proto.Location.name) + if (!_internal_has_name()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.name_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.name_.IsDefault()) { + _impl_.name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Location::set_allocated_name(std::string* name) { + if (name != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.name_.SetAllocated(name, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.name_.IsDefault()) { + _impl_.name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Location.name) +} + +// ------------------------------------------------------------------- + +// MediaData + +// optional string localPath = 1; +inline bool MediaData::_internal_has_localpath() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool MediaData::has_localpath() const { + return _internal_has_localpath(); +} +inline void MediaData::clear_localpath() { + _impl_.localpath_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& MediaData::localpath() const { + // @@protoc_insertion_point(field_get:proto.MediaData.localPath) + return _internal_localpath(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void MediaData::set_localpath(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.localpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.MediaData.localPath) +} +inline std::string* MediaData::mutable_localpath() { + std::string* _s = _internal_mutable_localpath(); + // @@protoc_insertion_point(field_mutable:proto.MediaData.localPath) + return _s; +} +inline const std::string& MediaData::_internal_localpath() const { + return _impl_.localpath_.Get(); +} +inline void MediaData::_internal_set_localpath(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.localpath_.Set(value, GetArenaForAllocation()); +} +inline std::string* MediaData::_internal_mutable_localpath() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.localpath_.Mutable(GetArenaForAllocation()); +} +inline std::string* MediaData::release_localpath() { + // @@protoc_insertion_point(field_release:proto.MediaData.localPath) + if (!_internal_has_localpath()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.localpath_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.localpath_.IsDefault()) { + _impl_.localpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void MediaData::set_allocated_localpath(std::string* localpath) { + if (localpath != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.localpath_.SetAllocated(localpath, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.localpath_.IsDefault()) { + _impl_.localpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.MediaData.localPath) +} + +// ------------------------------------------------------------------- + +// MediaRetryNotification + +// optional string stanzaId = 1; +inline bool MediaRetryNotification::_internal_has_stanzaid() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool MediaRetryNotification::has_stanzaid() const { + return _internal_has_stanzaid(); +} +inline void MediaRetryNotification::clear_stanzaid() { + _impl_.stanzaid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& MediaRetryNotification::stanzaid() const { + // @@protoc_insertion_point(field_get:proto.MediaRetryNotification.stanzaId) + return _internal_stanzaid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void MediaRetryNotification::set_stanzaid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.stanzaid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.MediaRetryNotification.stanzaId) +} +inline std::string* MediaRetryNotification::mutable_stanzaid() { + std::string* _s = _internal_mutable_stanzaid(); + // @@protoc_insertion_point(field_mutable:proto.MediaRetryNotification.stanzaId) + return _s; +} +inline const std::string& MediaRetryNotification::_internal_stanzaid() const { + return _impl_.stanzaid_.Get(); +} +inline void MediaRetryNotification::_internal_set_stanzaid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.stanzaid_.Set(value, GetArenaForAllocation()); +} +inline std::string* MediaRetryNotification::_internal_mutable_stanzaid() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.stanzaid_.Mutable(GetArenaForAllocation()); +} +inline std::string* MediaRetryNotification::release_stanzaid() { + // @@protoc_insertion_point(field_release:proto.MediaRetryNotification.stanzaId) + if (!_internal_has_stanzaid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.stanzaid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.stanzaid_.IsDefault()) { + _impl_.stanzaid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void MediaRetryNotification::set_allocated_stanzaid(std::string* stanzaid) { + if (stanzaid != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.stanzaid_.SetAllocated(stanzaid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.stanzaid_.IsDefault()) { + _impl_.stanzaid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.MediaRetryNotification.stanzaId) +} + +// optional string directPath = 2; +inline bool MediaRetryNotification::_internal_has_directpath() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool MediaRetryNotification::has_directpath() const { + return _internal_has_directpath(); +} +inline void MediaRetryNotification::clear_directpath() { + _impl_.directpath_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& MediaRetryNotification::directpath() const { + // @@protoc_insertion_point(field_get:proto.MediaRetryNotification.directPath) + return _internal_directpath(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void MediaRetryNotification::set_directpath(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.directpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.MediaRetryNotification.directPath) +} +inline std::string* MediaRetryNotification::mutable_directpath() { + std::string* _s = _internal_mutable_directpath(); + // @@protoc_insertion_point(field_mutable:proto.MediaRetryNotification.directPath) + return _s; +} +inline const std::string& MediaRetryNotification::_internal_directpath() const { + return _impl_.directpath_.Get(); +} +inline void MediaRetryNotification::_internal_set_directpath(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.directpath_.Set(value, GetArenaForAllocation()); +} +inline std::string* MediaRetryNotification::_internal_mutable_directpath() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.directpath_.Mutable(GetArenaForAllocation()); +} +inline std::string* MediaRetryNotification::release_directpath() { + // @@protoc_insertion_point(field_release:proto.MediaRetryNotification.directPath) + if (!_internal_has_directpath()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.directpath_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.directpath_.IsDefault()) { + _impl_.directpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void MediaRetryNotification::set_allocated_directpath(std::string* directpath) { + if (directpath != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.directpath_.IsDefault()) { + _impl_.directpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.MediaRetryNotification.directPath) +} + +// optional .proto.MediaRetryNotification.ResultType result = 3; +inline bool MediaRetryNotification::_internal_has_result() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool MediaRetryNotification::has_result() const { + return _internal_has_result(); +} +inline void MediaRetryNotification::clear_result() { + _impl_.result_ = 0; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline ::proto::MediaRetryNotification_ResultType MediaRetryNotification::_internal_result() const { + return static_cast< ::proto::MediaRetryNotification_ResultType >(_impl_.result_); +} +inline ::proto::MediaRetryNotification_ResultType MediaRetryNotification::result() const { + // @@protoc_insertion_point(field_get:proto.MediaRetryNotification.result) + return _internal_result(); +} +inline void MediaRetryNotification::_internal_set_result(::proto::MediaRetryNotification_ResultType value) { + assert(::proto::MediaRetryNotification_ResultType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.result_ = value; +} +inline void MediaRetryNotification::set_result(::proto::MediaRetryNotification_ResultType value) { + _internal_set_result(value); + // @@protoc_insertion_point(field_set:proto.MediaRetryNotification.result) +} + +// ------------------------------------------------------------------- + +// Message_AppStateFatalExceptionNotification + +// repeated string collectionNames = 1; +inline int Message_AppStateFatalExceptionNotification::_internal_collectionnames_size() const { + return _impl_.collectionnames_.size(); +} +inline int Message_AppStateFatalExceptionNotification::collectionnames_size() const { + return _internal_collectionnames_size(); +} +inline void Message_AppStateFatalExceptionNotification::clear_collectionnames() { + _impl_.collectionnames_.Clear(); +} +inline std::string* Message_AppStateFatalExceptionNotification::add_collectionnames() { + std::string* _s = _internal_add_collectionnames(); + // @@protoc_insertion_point(field_add_mutable:proto.Message.AppStateFatalExceptionNotification.collectionNames) + return _s; +} +inline const std::string& Message_AppStateFatalExceptionNotification::_internal_collectionnames(int index) const { + return _impl_.collectionnames_.Get(index); +} +inline const std::string& Message_AppStateFatalExceptionNotification::collectionnames(int index) const { + // @@protoc_insertion_point(field_get:proto.Message.AppStateFatalExceptionNotification.collectionNames) + return _internal_collectionnames(index); +} +inline std::string* Message_AppStateFatalExceptionNotification::mutable_collectionnames(int index) { + // @@protoc_insertion_point(field_mutable:proto.Message.AppStateFatalExceptionNotification.collectionNames) + return _impl_.collectionnames_.Mutable(index); +} +inline void Message_AppStateFatalExceptionNotification::set_collectionnames(int index, const std::string& value) { + _impl_.collectionnames_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:proto.Message.AppStateFatalExceptionNotification.collectionNames) +} +inline void Message_AppStateFatalExceptionNotification::set_collectionnames(int index, std::string&& value) { + _impl_.collectionnames_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:proto.Message.AppStateFatalExceptionNotification.collectionNames) +} +inline void Message_AppStateFatalExceptionNotification::set_collectionnames(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + _impl_.collectionnames_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:proto.Message.AppStateFatalExceptionNotification.collectionNames) +} +inline void Message_AppStateFatalExceptionNotification::set_collectionnames(int index, const char* value, size_t size) { + _impl_.collectionnames_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:proto.Message.AppStateFatalExceptionNotification.collectionNames) +} +inline std::string* Message_AppStateFatalExceptionNotification::_internal_add_collectionnames() { + return _impl_.collectionnames_.Add(); +} +inline void Message_AppStateFatalExceptionNotification::add_collectionnames(const std::string& value) { + _impl_.collectionnames_.Add()->assign(value); + // @@protoc_insertion_point(field_add:proto.Message.AppStateFatalExceptionNotification.collectionNames) +} +inline void Message_AppStateFatalExceptionNotification::add_collectionnames(std::string&& value) { + _impl_.collectionnames_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:proto.Message.AppStateFatalExceptionNotification.collectionNames) +} +inline void Message_AppStateFatalExceptionNotification::add_collectionnames(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _impl_.collectionnames_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:proto.Message.AppStateFatalExceptionNotification.collectionNames) +} +inline void Message_AppStateFatalExceptionNotification::add_collectionnames(const char* value, size_t size) { + _impl_.collectionnames_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:proto.Message.AppStateFatalExceptionNotification.collectionNames) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +Message_AppStateFatalExceptionNotification::collectionnames() const { + // @@protoc_insertion_point(field_list:proto.Message.AppStateFatalExceptionNotification.collectionNames) + return _impl_.collectionnames_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +Message_AppStateFatalExceptionNotification::mutable_collectionnames() { + // @@protoc_insertion_point(field_mutable_list:proto.Message.AppStateFatalExceptionNotification.collectionNames) + return &_impl_.collectionnames_; +} + +// optional int64 timestamp = 2; +inline bool Message_AppStateFatalExceptionNotification::_internal_has_timestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_AppStateFatalExceptionNotification::has_timestamp() const { + return _internal_has_timestamp(); +} +inline void Message_AppStateFatalExceptionNotification::clear_timestamp() { + _impl_.timestamp_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline int64_t Message_AppStateFatalExceptionNotification::_internal_timestamp() const { + return _impl_.timestamp_; +} +inline int64_t Message_AppStateFatalExceptionNotification::timestamp() const { + // @@protoc_insertion_point(field_get:proto.Message.AppStateFatalExceptionNotification.timestamp) + return _internal_timestamp(); +} +inline void Message_AppStateFatalExceptionNotification::_internal_set_timestamp(int64_t value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.timestamp_ = value; +} +inline void Message_AppStateFatalExceptionNotification::set_timestamp(int64_t value) { + _internal_set_timestamp(value); + // @@protoc_insertion_point(field_set:proto.Message.AppStateFatalExceptionNotification.timestamp) +} + +// ------------------------------------------------------------------- + +// Message_AppStateSyncKeyData + +// optional bytes keyData = 1; +inline bool Message_AppStateSyncKeyData::_internal_has_keydata() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_AppStateSyncKeyData::has_keydata() const { + return _internal_has_keydata(); +} +inline void Message_AppStateSyncKeyData::clear_keydata() { + _impl_.keydata_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_AppStateSyncKeyData::keydata() const { + // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyData.keyData) + return _internal_keydata(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_AppStateSyncKeyData::set_keydata(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.keydata_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.AppStateSyncKeyData.keyData) +} +inline std::string* Message_AppStateSyncKeyData::mutable_keydata() { + std::string* _s = _internal_mutable_keydata(); + // @@protoc_insertion_point(field_mutable:proto.Message.AppStateSyncKeyData.keyData) + return _s; +} +inline const std::string& Message_AppStateSyncKeyData::_internal_keydata() const { + return _impl_.keydata_.Get(); +} +inline void Message_AppStateSyncKeyData::_internal_set_keydata(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.keydata_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_AppStateSyncKeyData::_internal_mutable_keydata() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.keydata_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_AppStateSyncKeyData::release_keydata() { + // @@protoc_insertion_point(field_release:proto.Message.AppStateSyncKeyData.keyData) + if (!_internal_has_keydata()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.keydata_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.keydata_.IsDefault()) { + _impl_.keydata_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_AppStateSyncKeyData::set_allocated_keydata(std::string* keydata) { + if (keydata != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.keydata_.SetAllocated(keydata, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.keydata_.IsDefault()) { + _impl_.keydata_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.AppStateSyncKeyData.keyData) +} + +// optional .proto.Message.AppStateSyncKeyFingerprint fingerprint = 2; +inline bool Message_AppStateSyncKeyData::_internal_has_fingerprint() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.fingerprint_ != nullptr); + return value; +} +inline bool Message_AppStateSyncKeyData::has_fingerprint() const { + return _internal_has_fingerprint(); +} +inline void Message_AppStateSyncKeyData::clear_fingerprint() { + if (_impl_.fingerprint_ != nullptr) _impl_.fingerprint_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::Message_AppStateSyncKeyFingerprint& Message_AppStateSyncKeyData::_internal_fingerprint() const { + const ::proto::Message_AppStateSyncKeyFingerprint* p = _impl_.fingerprint_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_AppStateSyncKeyFingerprint_default_instance_); +} +inline const ::proto::Message_AppStateSyncKeyFingerprint& Message_AppStateSyncKeyData::fingerprint() const { + // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyData.fingerprint) + return _internal_fingerprint(); +} +inline void Message_AppStateSyncKeyData::unsafe_arena_set_allocated_fingerprint( + ::proto::Message_AppStateSyncKeyFingerprint* fingerprint) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.fingerprint_); + } + _impl_.fingerprint_ = fingerprint; + if (fingerprint) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.AppStateSyncKeyData.fingerprint) +} +inline ::proto::Message_AppStateSyncKeyFingerprint* Message_AppStateSyncKeyData::release_fingerprint() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::Message_AppStateSyncKeyFingerprint* temp = _impl_.fingerprint_; + _impl_.fingerprint_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_AppStateSyncKeyFingerprint* Message_AppStateSyncKeyData::unsafe_arena_release_fingerprint() { + // @@protoc_insertion_point(field_release:proto.Message.AppStateSyncKeyData.fingerprint) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::Message_AppStateSyncKeyFingerprint* temp = _impl_.fingerprint_; + _impl_.fingerprint_ = nullptr; + return temp; +} +inline ::proto::Message_AppStateSyncKeyFingerprint* Message_AppStateSyncKeyData::_internal_mutable_fingerprint() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.fingerprint_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_AppStateSyncKeyFingerprint>(GetArenaForAllocation()); + _impl_.fingerprint_ = p; + } + return _impl_.fingerprint_; +} +inline ::proto::Message_AppStateSyncKeyFingerprint* Message_AppStateSyncKeyData::mutable_fingerprint() { + ::proto::Message_AppStateSyncKeyFingerprint* _msg = _internal_mutable_fingerprint(); + // @@protoc_insertion_point(field_mutable:proto.Message.AppStateSyncKeyData.fingerprint) + return _msg; +} +inline void Message_AppStateSyncKeyData::set_allocated_fingerprint(::proto::Message_AppStateSyncKeyFingerprint* fingerprint) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.fingerprint_; + } + if (fingerprint) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(fingerprint); + if (message_arena != submessage_arena) { + fingerprint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, fingerprint, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.fingerprint_ = fingerprint; + // @@protoc_insertion_point(field_set_allocated:proto.Message.AppStateSyncKeyData.fingerprint) +} + +// optional int64 timestamp = 3; +inline bool Message_AppStateSyncKeyData::_internal_has_timestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Message_AppStateSyncKeyData::has_timestamp() const { + return _internal_has_timestamp(); +} +inline void Message_AppStateSyncKeyData::clear_timestamp() { + _impl_.timestamp_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline int64_t Message_AppStateSyncKeyData::_internal_timestamp() const { + return _impl_.timestamp_; +} +inline int64_t Message_AppStateSyncKeyData::timestamp() const { + // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyData.timestamp) + return _internal_timestamp(); +} +inline void Message_AppStateSyncKeyData::_internal_set_timestamp(int64_t value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.timestamp_ = value; +} +inline void Message_AppStateSyncKeyData::set_timestamp(int64_t value) { + _internal_set_timestamp(value); + // @@protoc_insertion_point(field_set:proto.Message.AppStateSyncKeyData.timestamp) +} + +// ------------------------------------------------------------------- + +// Message_AppStateSyncKeyFingerprint + +// optional uint32 rawId = 1; +inline bool Message_AppStateSyncKeyFingerprint::_internal_has_rawid() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_AppStateSyncKeyFingerprint::has_rawid() const { + return _internal_has_rawid(); +} +inline void Message_AppStateSyncKeyFingerprint::clear_rawid() { + _impl_.rawid_ = 0u; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline uint32_t Message_AppStateSyncKeyFingerprint::_internal_rawid() const { + return _impl_.rawid_; +} +inline uint32_t Message_AppStateSyncKeyFingerprint::rawid() const { + // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyFingerprint.rawId) + return _internal_rawid(); +} +inline void Message_AppStateSyncKeyFingerprint::_internal_set_rawid(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.rawid_ = value; +} +inline void Message_AppStateSyncKeyFingerprint::set_rawid(uint32_t value) { + _internal_set_rawid(value); + // @@protoc_insertion_point(field_set:proto.Message.AppStateSyncKeyFingerprint.rawId) +} + +// optional uint32 currentIndex = 2; +inline bool Message_AppStateSyncKeyFingerprint::_internal_has_currentindex() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_AppStateSyncKeyFingerprint::has_currentindex() const { + return _internal_has_currentindex(); +} +inline void Message_AppStateSyncKeyFingerprint::clear_currentindex() { + _impl_.currentindex_ = 0u; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline uint32_t Message_AppStateSyncKeyFingerprint::_internal_currentindex() const { + return _impl_.currentindex_; +} +inline uint32_t Message_AppStateSyncKeyFingerprint::currentindex() const { + // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyFingerprint.currentIndex) + return _internal_currentindex(); +} +inline void Message_AppStateSyncKeyFingerprint::_internal_set_currentindex(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.currentindex_ = value; +} +inline void Message_AppStateSyncKeyFingerprint::set_currentindex(uint32_t value) { + _internal_set_currentindex(value); + // @@protoc_insertion_point(field_set:proto.Message.AppStateSyncKeyFingerprint.currentIndex) +} + +// repeated uint32 deviceIndexes = 3 [packed = true]; +inline int Message_AppStateSyncKeyFingerprint::_internal_deviceindexes_size() const { + return _impl_.deviceindexes_.size(); +} +inline int Message_AppStateSyncKeyFingerprint::deviceindexes_size() const { + return _internal_deviceindexes_size(); +} +inline void Message_AppStateSyncKeyFingerprint::clear_deviceindexes() { + _impl_.deviceindexes_.Clear(); +} +inline uint32_t Message_AppStateSyncKeyFingerprint::_internal_deviceindexes(int index) const { + return _impl_.deviceindexes_.Get(index); +} +inline uint32_t Message_AppStateSyncKeyFingerprint::deviceindexes(int index) const { + // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyFingerprint.deviceIndexes) + return _internal_deviceindexes(index); +} +inline void Message_AppStateSyncKeyFingerprint::set_deviceindexes(int index, uint32_t value) { + _impl_.deviceindexes_.Set(index, value); + // @@protoc_insertion_point(field_set:proto.Message.AppStateSyncKeyFingerprint.deviceIndexes) +} +inline void Message_AppStateSyncKeyFingerprint::_internal_add_deviceindexes(uint32_t value) { + _impl_.deviceindexes_.Add(value); +} +inline void Message_AppStateSyncKeyFingerprint::add_deviceindexes(uint32_t value) { + _internal_add_deviceindexes(value); + // @@protoc_insertion_point(field_add:proto.Message.AppStateSyncKeyFingerprint.deviceIndexes) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +Message_AppStateSyncKeyFingerprint::_internal_deviceindexes() const { + return _impl_.deviceindexes_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +Message_AppStateSyncKeyFingerprint::deviceindexes() const { + // @@protoc_insertion_point(field_list:proto.Message.AppStateSyncKeyFingerprint.deviceIndexes) + return _internal_deviceindexes(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +Message_AppStateSyncKeyFingerprint::_internal_mutable_deviceindexes() { + return &_impl_.deviceindexes_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +Message_AppStateSyncKeyFingerprint::mutable_deviceindexes() { + // @@protoc_insertion_point(field_mutable_list:proto.Message.AppStateSyncKeyFingerprint.deviceIndexes) + return _internal_mutable_deviceindexes(); +} + +// ------------------------------------------------------------------- + +// Message_AppStateSyncKeyId + +// optional bytes keyId = 1; +inline bool Message_AppStateSyncKeyId::_internal_has_keyid() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_AppStateSyncKeyId::has_keyid() const { + return _internal_has_keyid(); +} +inline void Message_AppStateSyncKeyId::clear_keyid() { + _impl_.keyid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_AppStateSyncKeyId::keyid() const { + // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyId.keyId) + return _internal_keyid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_AppStateSyncKeyId::set_keyid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.keyid_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.AppStateSyncKeyId.keyId) +} +inline std::string* Message_AppStateSyncKeyId::mutable_keyid() { + std::string* _s = _internal_mutable_keyid(); + // @@protoc_insertion_point(field_mutable:proto.Message.AppStateSyncKeyId.keyId) + return _s; +} +inline const std::string& Message_AppStateSyncKeyId::_internal_keyid() const { + return _impl_.keyid_.Get(); +} +inline void Message_AppStateSyncKeyId::_internal_set_keyid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.keyid_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_AppStateSyncKeyId::_internal_mutable_keyid() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.keyid_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_AppStateSyncKeyId::release_keyid() { + // @@protoc_insertion_point(field_release:proto.Message.AppStateSyncKeyId.keyId) + if (!_internal_has_keyid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.keyid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.keyid_.IsDefault()) { + _impl_.keyid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_AppStateSyncKeyId::set_allocated_keyid(std::string* keyid) { + if (keyid != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.keyid_.SetAllocated(keyid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.keyid_.IsDefault()) { + _impl_.keyid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.AppStateSyncKeyId.keyId) +} + +// ------------------------------------------------------------------- + +// Message_AppStateSyncKeyRequest + +// repeated .proto.Message.AppStateSyncKeyId keyIds = 1; +inline int Message_AppStateSyncKeyRequest::_internal_keyids_size() const { + return _impl_.keyids_.size(); +} +inline int Message_AppStateSyncKeyRequest::keyids_size() const { + return _internal_keyids_size(); +} +inline void Message_AppStateSyncKeyRequest::clear_keyids() { + _impl_.keyids_.Clear(); +} +inline ::proto::Message_AppStateSyncKeyId* Message_AppStateSyncKeyRequest::mutable_keyids(int index) { + // @@protoc_insertion_point(field_mutable:proto.Message.AppStateSyncKeyRequest.keyIds) + return _impl_.keyids_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKeyId >* +Message_AppStateSyncKeyRequest::mutable_keyids() { + // @@protoc_insertion_point(field_mutable_list:proto.Message.AppStateSyncKeyRequest.keyIds) + return &_impl_.keyids_; +} +inline const ::proto::Message_AppStateSyncKeyId& Message_AppStateSyncKeyRequest::_internal_keyids(int index) const { + return _impl_.keyids_.Get(index); +} +inline const ::proto::Message_AppStateSyncKeyId& Message_AppStateSyncKeyRequest::keyids(int index) const { + // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyRequest.keyIds) + return _internal_keyids(index); +} +inline ::proto::Message_AppStateSyncKeyId* Message_AppStateSyncKeyRequest::_internal_add_keyids() { + return _impl_.keyids_.Add(); +} +inline ::proto::Message_AppStateSyncKeyId* Message_AppStateSyncKeyRequest::add_keyids() { + ::proto::Message_AppStateSyncKeyId* _add = _internal_add_keyids(); + // @@protoc_insertion_point(field_add:proto.Message.AppStateSyncKeyRequest.keyIds) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKeyId >& +Message_AppStateSyncKeyRequest::keyids() const { + // @@protoc_insertion_point(field_list:proto.Message.AppStateSyncKeyRequest.keyIds) + return _impl_.keyids_; +} + +// ------------------------------------------------------------------- + +// Message_AppStateSyncKeyShare + +// repeated .proto.Message.AppStateSyncKey keys = 1; +inline int Message_AppStateSyncKeyShare::_internal_keys_size() const { + return _impl_.keys_.size(); +} +inline int Message_AppStateSyncKeyShare::keys_size() const { + return _internal_keys_size(); +} +inline void Message_AppStateSyncKeyShare::clear_keys() { + _impl_.keys_.Clear(); +} +inline ::proto::Message_AppStateSyncKey* Message_AppStateSyncKeyShare::mutable_keys(int index) { + // @@protoc_insertion_point(field_mutable:proto.Message.AppStateSyncKeyShare.keys) + return _impl_.keys_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKey >* +Message_AppStateSyncKeyShare::mutable_keys() { + // @@protoc_insertion_point(field_mutable_list:proto.Message.AppStateSyncKeyShare.keys) + return &_impl_.keys_; +} +inline const ::proto::Message_AppStateSyncKey& Message_AppStateSyncKeyShare::_internal_keys(int index) const { + return _impl_.keys_.Get(index); +} +inline const ::proto::Message_AppStateSyncKey& Message_AppStateSyncKeyShare::keys(int index) const { + // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyShare.keys) + return _internal_keys(index); +} +inline ::proto::Message_AppStateSyncKey* Message_AppStateSyncKeyShare::_internal_add_keys() { + return _impl_.keys_.Add(); +} +inline ::proto::Message_AppStateSyncKey* Message_AppStateSyncKeyShare::add_keys() { + ::proto::Message_AppStateSyncKey* _add = _internal_add_keys(); + // @@protoc_insertion_point(field_add:proto.Message.AppStateSyncKeyShare.keys) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKey >& +Message_AppStateSyncKeyShare::keys() const { + // @@protoc_insertion_point(field_list:proto.Message.AppStateSyncKeyShare.keys) + return _impl_.keys_; +} + +// ------------------------------------------------------------------- + +// Message_AppStateSyncKey + +// optional .proto.Message.AppStateSyncKeyId keyId = 1; +inline bool Message_AppStateSyncKey::_internal_has_keyid() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.keyid_ != nullptr); + return value; +} +inline bool Message_AppStateSyncKey::has_keyid() const { + return _internal_has_keyid(); +} +inline void Message_AppStateSyncKey::clear_keyid() { + if (_impl_.keyid_ != nullptr) _impl_.keyid_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::Message_AppStateSyncKeyId& Message_AppStateSyncKey::_internal_keyid() const { + const ::proto::Message_AppStateSyncKeyId* p = _impl_.keyid_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_AppStateSyncKeyId_default_instance_); +} +inline const ::proto::Message_AppStateSyncKeyId& Message_AppStateSyncKey::keyid() const { + // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKey.keyId) + return _internal_keyid(); +} +inline void Message_AppStateSyncKey::unsafe_arena_set_allocated_keyid( + ::proto::Message_AppStateSyncKeyId* keyid) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keyid_); + } + _impl_.keyid_ = keyid; + if (keyid) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.AppStateSyncKey.keyId) +} +inline ::proto::Message_AppStateSyncKeyId* Message_AppStateSyncKey::release_keyid() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::Message_AppStateSyncKeyId* temp = _impl_.keyid_; + _impl_.keyid_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_AppStateSyncKeyId* Message_AppStateSyncKey::unsafe_arena_release_keyid() { + // @@protoc_insertion_point(field_release:proto.Message.AppStateSyncKey.keyId) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::Message_AppStateSyncKeyId* temp = _impl_.keyid_; + _impl_.keyid_ = nullptr; + return temp; +} +inline ::proto::Message_AppStateSyncKeyId* Message_AppStateSyncKey::_internal_mutable_keyid() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.keyid_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_AppStateSyncKeyId>(GetArenaForAllocation()); + _impl_.keyid_ = p; + } + return _impl_.keyid_; +} +inline ::proto::Message_AppStateSyncKeyId* Message_AppStateSyncKey::mutable_keyid() { + ::proto::Message_AppStateSyncKeyId* _msg = _internal_mutable_keyid(); + // @@protoc_insertion_point(field_mutable:proto.Message.AppStateSyncKey.keyId) + return _msg; +} +inline void Message_AppStateSyncKey::set_allocated_keyid(::proto::Message_AppStateSyncKeyId* keyid) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.keyid_; + } + if (keyid) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keyid); + if (message_arena != submessage_arena) { + keyid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, keyid, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.keyid_ = keyid; + // @@protoc_insertion_point(field_set_allocated:proto.Message.AppStateSyncKey.keyId) +} + +// optional .proto.Message.AppStateSyncKeyData keyData = 2; +inline bool Message_AppStateSyncKey::_internal_has_keydata() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.keydata_ != nullptr); + return value; +} +inline bool Message_AppStateSyncKey::has_keydata() const { + return _internal_has_keydata(); +} +inline void Message_AppStateSyncKey::clear_keydata() { + if (_impl_.keydata_ != nullptr) _impl_.keydata_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::Message_AppStateSyncKeyData& Message_AppStateSyncKey::_internal_keydata() const { + const ::proto::Message_AppStateSyncKeyData* p = _impl_.keydata_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_AppStateSyncKeyData_default_instance_); +} +inline const ::proto::Message_AppStateSyncKeyData& Message_AppStateSyncKey::keydata() const { + // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKey.keyData) + return _internal_keydata(); +} +inline void Message_AppStateSyncKey::unsafe_arena_set_allocated_keydata( + ::proto::Message_AppStateSyncKeyData* keydata) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keydata_); + } + _impl_.keydata_ = keydata; + if (keydata) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.AppStateSyncKey.keyData) +} +inline ::proto::Message_AppStateSyncKeyData* Message_AppStateSyncKey::release_keydata() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::Message_AppStateSyncKeyData* temp = _impl_.keydata_; + _impl_.keydata_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_AppStateSyncKeyData* Message_AppStateSyncKey::unsafe_arena_release_keydata() { + // @@protoc_insertion_point(field_release:proto.Message.AppStateSyncKey.keyData) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::Message_AppStateSyncKeyData* temp = _impl_.keydata_; + _impl_.keydata_ = nullptr; + return temp; +} +inline ::proto::Message_AppStateSyncKeyData* Message_AppStateSyncKey::_internal_mutable_keydata() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.keydata_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_AppStateSyncKeyData>(GetArenaForAllocation()); + _impl_.keydata_ = p; + } + return _impl_.keydata_; +} +inline ::proto::Message_AppStateSyncKeyData* Message_AppStateSyncKey::mutable_keydata() { + ::proto::Message_AppStateSyncKeyData* _msg = _internal_mutable_keydata(); + // @@protoc_insertion_point(field_mutable:proto.Message.AppStateSyncKey.keyData) + return _msg; +} +inline void Message_AppStateSyncKey::set_allocated_keydata(::proto::Message_AppStateSyncKeyData* keydata) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.keydata_; + } + if (keydata) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keydata); + if (message_arena != submessage_arena) { + keydata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, keydata, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.keydata_ = keydata; + // @@protoc_insertion_point(field_set_allocated:proto.Message.AppStateSyncKey.keyData) +} + +// ------------------------------------------------------------------- + +// Message_AudioMessage + +// optional string url = 1; +inline bool Message_AudioMessage::_internal_has_url() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_AudioMessage::has_url() const { + return _internal_has_url(); +} +inline void Message_AudioMessage::clear_url() { + _impl_.url_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_AudioMessage::url() const { + // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.url) + return _internal_url(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_AudioMessage::set_url(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.url_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.url) +} +inline std::string* Message_AudioMessage::mutable_url() { + std::string* _s = _internal_mutable_url(); + // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.url) + return _s; +} +inline const std::string& Message_AudioMessage::_internal_url() const { + return _impl_.url_.Get(); +} +inline void Message_AudioMessage::_internal_set_url(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.url_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_AudioMessage::_internal_mutable_url() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.url_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_AudioMessage::release_url() { + // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.url) + if (!_internal_has_url()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.url_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.url_.IsDefault()) { + _impl_.url_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_AudioMessage::set_allocated_url(std::string* url) { + if (url != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.url_.SetAllocated(url, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.url_.IsDefault()) { + _impl_.url_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.url) +} + +// optional string mimetype = 2; +inline bool Message_AudioMessage::_internal_has_mimetype() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_AudioMessage::has_mimetype() const { + return _internal_has_mimetype(); +} +inline void Message_AudioMessage::clear_mimetype() { + _impl_.mimetype_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_AudioMessage::mimetype() const { + // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.mimetype) + return _internal_mimetype(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_AudioMessage::set_mimetype(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.mimetype_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.mimetype) +} +inline std::string* Message_AudioMessage::mutable_mimetype() { + std::string* _s = _internal_mutable_mimetype(); + // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.mimetype) + return _s; +} +inline const std::string& Message_AudioMessage::_internal_mimetype() const { + return _impl_.mimetype_.Get(); +} +inline void Message_AudioMessage::_internal_set_mimetype(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.mimetype_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_AudioMessage::_internal_mutable_mimetype() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.mimetype_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_AudioMessage::release_mimetype() { + // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.mimetype) + if (!_internal_has_mimetype()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.mimetype_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mimetype_.IsDefault()) { + _impl_.mimetype_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_AudioMessage::set_allocated_mimetype(std::string* mimetype) { + if (mimetype != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mimetype_.IsDefault()) { + _impl_.mimetype_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.mimetype) +} + +// optional bytes fileSha256 = 3; +inline bool Message_AudioMessage::_internal_has_filesha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Message_AudioMessage::has_filesha256() const { + return _internal_has_filesha256(); +} +inline void Message_AudioMessage::clear_filesha256() { + _impl_.filesha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& Message_AudioMessage::filesha256() const { + // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.fileSha256) + return _internal_filesha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_AudioMessage::set_filesha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.filesha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.fileSha256) +} +inline std::string* Message_AudioMessage::mutable_filesha256() { + std::string* _s = _internal_mutable_filesha256(); + // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.fileSha256) + return _s; +} +inline const std::string& Message_AudioMessage::_internal_filesha256() const { + return _impl_.filesha256_.Get(); +} +inline void Message_AudioMessage::_internal_set_filesha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.filesha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_AudioMessage::_internal_mutable_filesha256() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.filesha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_AudioMessage::release_filesha256() { + // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.fileSha256) + if (!_internal_has_filesha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.filesha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.filesha256_.IsDefault()) { + _impl_.filesha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_AudioMessage::set_allocated_filesha256(std::string* filesha256) { + if (filesha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.filesha256_.IsDefault()) { + _impl_.filesha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.fileSha256) +} + +// optional uint64 fileLength = 4; +inline bool Message_AudioMessage::_internal_has_filelength() const { + bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool Message_AudioMessage::has_filelength() const { + return _internal_has_filelength(); +} +inline void Message_AudioMessage::clear_filelength() { + _impl_.filelength_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000200u; +} +inline uint64_t Message_AudioMessage::_internal_filelength() const { + return _impl_.filelength_; +} +inline uint64_t Message_AudioMessage::filelength() const { + // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.fileLength) + return _internal_filelength(); +} +inline void Message_AudioMessage::_internal_set_filelength(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.filelength_ = value; +} +inline void Message_AudioMessage::set_filelength(uint64_t value) { + _internal_set_filelength(value); + // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.fileLength) +} + +// optional uint32 seconds = 5; +inline bool Message_AudioMessage::_internal_has_seconds() const { + bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool Message_AudioMessage::has_seconds() const { + return _internal_has_seconds(); +} +inline void Message_AudioMessage::clear_seconds() { + _impl_.seconds_ = 0u; + _impl_._has_bits_[0] &= ~0x00000400u; +} +inline uint32_t Message_AudioMessage::_internal_seconds() const { + return _impl_.seconds_; +} +inline uint32_t Message_AudioMessage::seconds() const { + // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.seconds) + return _internal_seconds(); +} +inline void Message_AudioMessage::_internal_set_seconds(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000400u; + _impl_.seconds_ = value; +} +inline void Message_AudioMessage::set_seconds(uint32_t value) { + _internal_set_seconds(value); + // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.seconds) +} + +// optional bool ptt = 6; +inline bool Message_AudioMessage::_internal_has_ptt() const { + bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; + return value; +} +inline bool Message_AudioMessage::has_ptt() const { + return _internal_has_ptt(); +} +inline void Message_AudioMessage::clear_ptt() { + _impl_.ptt_ = false; + _impl_._has_bits_[0] &= ~0x00000800u; +} +inline bool Message_AudioMessage::_internal_ptt() const { + return _impl_.ptt_; +} +inline bool Message_AudioMessage::ptt() const { + // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.ptt) + return _internal_ptt(); +} +inline void Message_AudioMessage::_internal_set_ptt(bool value) { + _impl_._has_bits_[0] |= 0x00000800u; + _impl_.ptt_ = value; +} +inline void Message_AudioMessage::set_ptt(bool value) { + _internal_set_ptt(value); + // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.ptt) +} + +// optional bytes mediaKey = 7; +inline bool Message_AudioMessage::_internal_has_mediakey() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool Message_AudioMessage::has_mediakey() const { + return _internal_has_mediakey(); +} +inline void Message_AudioMessage::clear_mediakey() { + _impl_.mediakey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const std::string& Message_AudioMessage::mediakey() const { + // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.mediaKey) + return _internal_mediakey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_AudioMessage::set_mediakey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.mediakey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.mediaKey) +} +inline std::string* Message_AudioMessage::mutable_mediakey() { + std::string* _s = _internal_mutable_mediakey(); + // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.mediaKey) + return _s; +} +inline const std::string& Message_AudioMessage::_internal_mediakey() const { + return _impl_.mediakey_.Get(); +} +inline void Message_AudioMessage::_internal_set_mediakey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.mediakey_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_AudioMessage::_internal_mutable_mediakey() { + _impl_._has_bits_[0] |= 0x00000008u; + return _impl_.mediakey_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_AudioMessage::release_mediakey() { + // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.mediaKey) + if (!_internal_has_mediakey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000008u; + auto* p = _impl_.mediakey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mediakey_.IsDefault()) { + _impl_.mediakey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_AudioMessage::set_allocated_mediakey(std::string* mediakey) { + if (mediakey != nullptr) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mediakey_.IsDefault()) { + _impl_.mediakey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.mediaKey) +} + +// optional bytes fileEncSha256 = 8; +inline bool Message_AudioMessage::_internal_has_fileencsha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool Message_AudioMessage::has_fileencsha256() const { + return _internal_has_fileencsha256(); +} +inline void Message_AudioMessage::clear_fileencsha256() { + _impl_.fileencsha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const std::string& Message_AudioMessage::fileencsha256() const { + // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.fileEncSha256) + return _internal_fileencsha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_AudioMessage::set_fileencsha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.fileencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.fileEncSha256) +} +inline std::string* Message_AudioMessage::mutable_fileencsha256() { + std::string* _s = _internal_mutable_fileencsha256(); + // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.fileEncSha256) + return _s; +} +inline const std::string& Message_AudioMessage::_internal_fileencsha256() const { + return _impl_.fileencsha256_.Get(); +} +inline void Message_AudioMessage::_internal_set_fileencsha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.fileencsha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_AudioMessage::_internal_mutable_fileencsha256() { + _impl_._has_bits_[0] |= 0x00000010u; + return _impl_.fileencsha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_AudioMessage::release_fileencsha256() { + // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.fileEncSha256) + if (!_internal_has_fileencsha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000010u; + auto* p = _impl_.fileencsha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fileencsha256_.IsDefault()) { + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_AudioMessage::set_allocated_fileencsha256(std::string* fileencsha256) { + if (fileencsha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fileencsha256_.IsDefault()) { + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.fileEncSha256) +} + +// optional string directPath = 9; +inline bool Message_AudioMessage::_internal_has_directpath() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool Message_AudioMessage::has_directpath() const { + return _internal_has_directpath(); +} +inline void Message_AudioMessage::clear_directpath() { + _impl_.directpath_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline const std::string& Message_AudioMessage::directpath() const { + // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.directPath) + return _internal_directpath(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_AudioMessage::set_directpath(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.directpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.directPath) +} +inline std::string* Message_AudioMessage::mutable_directpath() { + std::string* _s = _internal_mutable_directpath(); + // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.directPath) + return _s; +} +inline const std::string& Message_AudioMessage::_internal_directpath() const { + return _impl_.directpath_.Get(); +} +inline void Message_AudioMessage::_internal_set_directpath(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.directpath_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_AudioMessage::_internal_mutable_directpath() { + _impl_._has_bits_[0] |= 0x00000020u; + return _impl_.directpath_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_AudioMessage::release_directpath() { + // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.directPath) + if (!_internal_has_directpath()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000020u; + auto* p = _impl_.directpath_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.directpath_.IsDefault()) { + _impl_.directpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_AudioMessage::set_allocated_directpath(std::string* directpath) { + if (directpath != nullptr) { + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.directpath_.IsDefault()) { + _impl_.directpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.directPath) +} + +// optional int64 mediaKeyTimestamp = 10; +inline bool Message_AudioMessage::_internal_has_mediakeytimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; + return value; +} +inline bool Message_AudioMessage::has_mediakeytimestamp() const { + return _internal_has_mediakeytimestamp(); +} +inline void Message_AudioMessage::clear_mediakeytimestamp() { + _impl_.mediakeytimestamp_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00001000u; +} +inline int64_t Message_AudioMessage::_internal_mediakeytimestamp() const { + return _impl_.mediakeytimestamp_; +} +inline int64_t Message_AudioMessage::mediakeytimestamp() const { + // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.mediaKeyTimestamp) + return _internal_mediakeytimestamp(); +} +inline void Message_AudioMessage::_internal_set_mediakeytimestamp(int64_t value) { + _impl_._has_bits_[0] |= 0x00001000u; + _impl_.mediakeytimestamp_ = value; +} +inline void Message_AudioMessage::set_mediakeytimestamp(int64_t value) { + _internal_set_mediakeytimestamp(value); + // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.mediaKeyTimestamp) +} + +// optional .proto.ContextInfo contextInfo = 17; +inline bool Message_AudioMessage::_internal_has_contextinfo() const { + bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; + PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); + return value; +} +inline bool Message_AudioMessage::has_contextinfo() const { + return _internal_has_contextinfo(); +} +inline void Message_AudioMessage::clear_contextinfo() { + if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); + _impl_._has_bits_[0] &= ~0x00000100u; +} +inline const ::proto::ContextInfo& Message_AudioMessage::_internal_contextinfo() const { + const ::proto::ContextInfo* p = _impl_.contextinfo_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ContextInfo_default_instance_); +} +inline const ::proto::ContextInfo& Message_AudioMessage::contextinfo() const { + // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.contextInfo) + return _internal_contextinfo(); +} +inline void Message_AudioMessage::unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); + } + _impl_.contextinfo_ = contextinfo; + if (contextinfo) { + _impl_._has_bits_[0] |= 0x00000100u; + } else { + _impl_._has_bits_[0] &= ~0x00000100u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.AudioMessage.contextInfo) +} +inline ::proto::ContextInfo* Message_AudioMessage::release_contextinfo() { + _impl_._has_bits_[0] &= ~0x00000100u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ContextInfo* Message_AudioMessage::unsafe_arena_release_contextinfo() { + // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.contextInfo) + _impl_._has_bits_[0] &= ~0x00000100u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; + return temp; +} +inline ::proto::ContextInfo* Message_AudioMessage::_internal_mutable_contextinfo() { + _impl_._has_bits_[0] |= 0x00000100u; + if (_impl_.contextinfo_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); + _impl_.contextinfo_ = p; + } + return _impl_.contextinfo_; +} +inline ::proto::ContextInfo* Message_AudioMessage::mutable_contextinfo() { + ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); + // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.contextInfo) + return _msg; +} +inline void Message_AudioMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.contextinfo_; + } + if (contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); + if (message_arena != submessage_arena) { + contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, contextinfo, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000100u; + } else { + _impl_._has_bits_[0] &= ~0x00000100u; + } + _impl_.contextinfo_ = contextinfo; + // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.contextInfo) +} + +// optional bytes streamingSidecar = 18; +inline bool Message_AudioMessage::_internal_has_streamingsidecar() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool Message_AudioMessage::has_streamingsidecar() const { + return _internal_has_streamingsidecar(); +} +inline void Message_AudioMessage::clear_streamingsidecar() { + _impl_.streamingsidecar_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline const std::string& Message_AudioMessage::streamingsidecar() const { + // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.streamingSidecar) + return _internal_streamingsidecar(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_AudioMessage::set_streamingsidecar(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.streamingsidecar_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.streamingSidecar) +} +inline std::string* Message_AudioMessage::mutable_streamingsidecar() { + std::string* _s = _internal_mutable_streamingsidecar(); + // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.streamingSidecar) + return _s; +} +inline const std::string& Message_AudioMessage::_internal_streamingsidecar() const { + return _impl_.streamingsidecar_.Get(); +} +inline void Message_AudioMessage::_internal_set_streamingsidecar(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.streamingsidecar_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_AudioMessage::_internal_mutable_streamingsidecar() { + _impl_._has_bits_[0] |= 0x00000040u; + return _impl_.streamingsidecar_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_AudioMessage::release_streamingsidecar() { + // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.streamingSidecar) + if (!_internal_has_streamingsidecar()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000040u; + auto* p = _impl_.streamingsidecar_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.streamingsidecar_.IsDefault()) { + _impl_.streamingsidecar_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_AudioMessage::set_allocated_streamingsidecar(std::string* streamingsidecar) { + if (streamingsidecar != nullptr) { + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + _impl_.streamingsidecar_.SetAllocated(streamingsidecar, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.streamingsidecar_.IsDefault()) { + _impl_.streamingsidecar_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.streamingSidecar) +} + +// optional bytes waveform = 19; +inline bool Message_AudioMessage::_internal_has_waveform() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool Message_AudioMessage::has_waveform() const { + return _internal_has_waveform(); +} +inline void Message_AudioMessage::clear_waveform() { + _impl_.waveform_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline const std::string& Message_AudioMessage::waveform() const { + // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.waveform) + return _internal_waveform(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_AudioMessage::set_waveform(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.waveform_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.waveform) +} +inline std::string* Message_AudioMessage::mutable_waveform() { + std::string* _s = _internal_mutable_waveform(); + // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.waveform) + return _s; +} +inline const std::string& Message_AudioMessage::_internal_waveform() const { + return _impl_.waveform_.Get(); +} +inline void Message_AudioMessage::_internal_set_waveform(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.waveform_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_AudioMessage::_internal_mutable_waveform() { + _impl_._has_bits_[0] |= 0x00000080u; + return _impl_.waveform_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_AudioMessage::release_waveform() { + // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.waveform) + if (!_internal_has_waveform()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000080u; + auto* p = _impl_.waveform_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.waveform_.IsDefault()) { + _impl_.waveform_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_AudioMessage::set_allocated_waveform(std::string* waveform) { + if (waveform != nullptr) { + _impl_._has_bits_[0] |= 0x00000080u; + } else { + _impl_._has_bits_[0] &= ~0x00000080u; + } + _impl_.waveform_.SetAllocated(waveform, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.waveform_.IsDefault()) { + _impl_.waveform_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.waveform) +} + +// ------------------------------------------------------------------- + +// Message_ButtonsMessage_Button_ButtonText + +// optional string displayText = 1; +inline bool Message_ButtonsMessage_Button_ButtonText::_internal_has_displaytext() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_ButtonsMessage_Button_ButtonText::has_displaytext() const { + return _internal_has_displaytext(); +} +inline void Message_ButtonsMessage_Button_ButtonText::clear_displaytext() { + _impl_.displaytext_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_ButtonsMessage_Button_ButtonText::displaytext() const { + // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.Button.ButtonText.displayText) + return _internal_displaytext(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ButtonsMessage_Button_ButtonText::set_displaytext(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.displaytext_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.Button.ButtonText.displayText) +} +inline std::string* Message_ButtonsMessage_Button_ButtonText::mutable_displaytext() { + std::string* _s = _internal_mutable_displaytext(); + // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.Button.ButtonText.displayText) + return _s; +} +inline const std::string& Message_ButtonsMessage_Button_ButtonText::_internal_displaytext() const { + return _impl_.displaytext_.Get(); +} +inline void Message_ButtonsMessage_Button_ButtonText::_internal_set_displaytext(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.displaytext_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ButtonsMessage_Button_ButtonText::_internal_mutable_displaytext() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.displaytext_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ButtonsMessage_Button_ButtonText::release_displaytext() { + // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.Button.ButtonText.displayText) + if (!_internal_has_displaytext()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.displaytext_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.displaytext_.IsDefault()) { + _impl_.displaytext_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ButtonsMessage_Button_ButtonText::set_allocated_displaytext(std::string* displaytext) { + if (displaytext != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.displaytext_.SetAllocated(displaytext, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.displaytext_.IsDefault()) { + _impl_.displaytext_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.Button.ButtonText.displayText) +} + +// ------------------------------------------------------------------- + +// Message_ButtonsMessage_Button_NativeFlowInfo + +// optional string name = 1; +inline bool Message_ButtonsMessage_Button_NativeFlowInfo::_internal_has_name() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_ButtonsMessage_Button_NativeFlowInfo::has_name() const { + return _internal_has_name(); +} +inline void Message_ButtonsMessage_Button_NativeFlowInfo::clear_name() { + _impl_.name_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_ButtonsMessage_Button_NativeFlowInfo::name() const { + // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.Button.NativeFlowInfo.name) + return _internal_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ButtonsMessage_Button_NativeFlowInfo::set_name(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.Button.NativeFlowInfo.name) +} +inline std::string* Message_ButtonsMessage_Button_NativeFlowInfo::mutable_name() { + std::string* _s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.Button.NativeFlowInfo.name) + return _s; +} +inline const std::string& Message_ButtonsMessage_Button_NativeFlowInfo::_internal_name() const { + return _impl_.name_.Get(); +} +inline void Message_ButtonsMessage_Button_NativeFlowInfo::_internal_set_name(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.name_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ButtonsMessage_Button_NativeFlowInfo::_internal_mutable_name() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.name_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ButtonsMessage_Button_NativeFlowInfo::release_name() { + // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.Button.NativeFlowInfo.name) + if (!_internal_has_name()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.name_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.name_.IsDefault()) { + _impl_.name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ButtonsMessage_Button_NativeFlowInfo::set_allocated_name(std::string* name) { + if (name != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.name_.SetAllocated(name, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.name_.IsDefault()) { + _impl_.name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.Button.NativeFlowInfo.name) +} + +// optional string paramsJson = 2; +inline bool Message_ButtonsMessage_Button_NativeFlowInfo::_internal_has_paramsjson() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_ButtonsMessage_Button_NativeFlowInfo::has_paramsjson() const { + return _internal_has_paramsjson(); +} +inline void Message_ButtonsMessage_Button_NativeFlowInfo::clear_paramsjson() { + _impl_.paramsjson_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_ButtonsMessage_Button_NativeFlowInfo::paramsjson() const { + // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.Button.NativeFlowInfo.paramsJson) + return _internal_paramsjson(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ButtonsMessage_Button_NativeFlowInfo::set_paramsjson(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.paramsjson_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.Button.NativeFlowInfo.paramsJson) +} +inline std::string* Message_ButtonsMessage_Button_NativeFlowInfo::mutable_paramsjson() { + std::string* _s = _internal_mutable_paramsjson(); + // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.Button.NativeFlowInfo.paramsJson) + return _s; +} +inline const std::string& Message_ButtonsMessage_Button_NativeFlowInfo::_internal_paramsjson() const { + return _impl_.paramsjson_.Get(); +} +inline void Message_ButtonsMessage_Button_NativeFlowInfo::_internal_set_paramsjson(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.paramsjson_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ButtonsMessage_Button_NativeFlowInfo::_internal_mutable_paramsjson() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.paramsjson_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ButtonsMessage_Button_NativeFlowInfo::release_paramsjson() { + // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.Button.NativeFlowInfo.paramsJson) + if (!_internal_has_paramsjson()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.paramsjson_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.paramsjson_.IsDefault()) { + _impl_.paramsjson_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ButtonsMessage_Button_NativeFlowInfo::set_allocated_paramsjson(std::string* paramsjson) { + if (paramsjson != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.paramsjson_.SetAllocated(paramsjson, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.paramsjson_.IsDefault()) { + _impl_.paramsjson_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.Button.NativeFlowInfo.paramsJson) +} + +// ------------------------------------------------------------------- + +// Message_ButtonsMessage_Button + +// optional string buttonId = 1; +inline bool Message_ButtonsMessage_Button::_internal_has_buttonid() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_ButtonsMessage_Button::has_buttonid() const { + return _internal_has_buttonid(); +} +inline void Message_ButtonsMessage_Button::clear_buttonid() { + _impl_.buttonid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_ButtonsMessage_Button::buttonid() const { + // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.Button.buttonId) + return _internal_buttonid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ButtonsMessage_Button::set_buttonid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.buttonid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.Button.buttonId) +} +inline std::string* Message_ButtonsMessage_Button::mutable_buttonid() { + std::string* _s = _internal_mutable_buttonid(); + // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.Button.buttonId) + return _s; +} +inline const std::string& Message_ButtonsMessage_Button::_internal_buttonid() const { + return _impl_.buttonid_.Get(); +} +inline void Message_ButtonsMessage_Button::_internal_set_buttonid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.buttonid_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ButtonsMessage_Button::_internal_mutable_buttonid() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.buttonid_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ButtonsMessage_Button::release_buttonid() { + // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.Button.buttonId) + if (!_internal_has_buttonid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.buttonid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.buttonid_.IsDefault()) { + _impl_.buttonid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ButtonsMessage_Button::set_allocated_buttonid(std::string* buttonid) { + if (buttonid != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.buttonid_.SetAllocated(buttonid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.buttonid_.IsDefault()) { + _impl_.buttonid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.Button.buttonId) +} + +// optional .proto.Message.ButtonsMessage.Button.ButtonText buttonText = 2; +inline bool Message_ButtonsMessage_Button::_internal_has_buttontext() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.buttontext_ != nullptr); + return value; +} +inline bool Message_ButtonsMessage_Button::has_buttontext() const { + return _internal_has_buttontext(); +} +inline void Message_ButtonsMessage_Button::clear_buttontext() { + if (_impl_.buttontext_ != nullptr) _impl_.buttontext_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::Message_ButtonsMessage_Button_ButtonText& Message_ButtonsMessage_Button::_internal_buttontext() const { + const ::proto::Message_ButtonsMessage_Button_ButtonText* p = _impl_.buttontext_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_ButtonsMessage_Button_ButtonText_default_instance_); +} +inline const ::proto::Message_ButtonsMessage_Button_ButtonText& Message_ButtonsMessage_Button::buttontext() const { + // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.Button.buttonText) + return _internal_buttontext(); +} +inline void Message_ButtonsMessage_Button::unsafe_arena_set_allocated_buttontext( + ::proto::Message_ButtonsMessage_Button_ButtonText* buttontext) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.buttontext_); + } + _impl_.buttontext_ = buttontext; + if (buttontext) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsMessage.Button.buttonText) +} +inline ::proto::Message_ButtonsMessage_Button_ButtonText* Message_ButtonsMessage_Button::release_buttontext() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::Message_ButtonsMessage_Button_ButtonText* temp = _impl_.buttontext_; + _impl_.buttontext_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_ButtonsMessage_Button_ButtonText* Message_ButtonsMessage_Button::unsafe_arena_release_buttontext() { + // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.Button.buttonText) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::Message_ButtonsMessage_Button_ButtonText* temp = _impl_.buttontext_; + _impl_.buttontext_ = nullptr; + return temp; +} +inline ::proto::Message_ButtonsMessage_Button_ButtonText* Message_ButtonsMessage_Button::_internal_mutable_buttontext() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.buttontext_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_ButtonsMessage_Button_ButtonText>(GetArenaForAllocation()); + _impl_.buttontext_ = p; + } + return _impl_.buttontext_; +} +inline ::proto::Message_ButtonsMessage_Button_ButtonText* Message_ButtonsMessage_Button::mutable_buttontext() { + ::proto::Message_ButtonsMessage_Button_ButtonText* _msg = _internal_mutable_buttontext(); + // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.Button.buttonText) + return _msg; +} +inline void Message_ButtonsMessage_Button::set_allocated_buttontext(::proto::Message_ButtonsMessage_Button_ButtonText* buttontext) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.buttontext_; + } + if (buttontext) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(buttontext); + if (message_arena != submessage_arena) { + buttontext = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, buttontext, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.buttontext_ = buttontext; + // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.Button.buttonText) +} + +// optional .proto.Message.ButtonsMessage.Button.Type type = 3; +inline bool Message_ButtonsMessage_Button::_internal_has_type() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool Message_ButtonsMessage_Button::has_type() const { + return _internal_has_type(); +} +inline void Message_ButtonsMessage_Button::clear_type() { + _impl_.type_ = 0; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline ::proto::Message_ButtonsMessage_Button_Type Message_ButtonsMessage_Button::_internal_type() const { + return static_cast< ::proto::Message_ButtonsMessage_Button_Type >(_impl_.type_); +} +inline ::proto::Message_ButtonsMessage_Button_Type Message_ButtonsMessage_Button::type() const { + // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.Button.type) + return _internal_type(); +} +inline void Message_ButtonsMessage_Button::_internal_set_type(::proto::Message_ButtonsMessage_Button_Type value) { + assert(::proto::Message_ButtonsMessage_Button_Type_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.type_ = value; +} +inline void Message_ButtonsMessage_Button::set_type(::proto::Message_ButtonsMessage_Button_Type value) { + _internal_set_type(value); + // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.Button.type) +} + +// optional .proto.Message.ButtonsMessage.Button.NativeFlowInfo nativeFlowInfo = 4; +inline bool Message_ButtonsMessage_Button::_internal_has_nativeflowinfo() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.nativeflowinfo_ != nullptr); + return value; +} +inline bool Message_ButtonsMessage_Button::has_nativeflowinfo() const { + return _internal_has_nativeflowinfo(); +} +inline void Message_ButtonsMessage_Button::clear_nativeflowinfo() { + if (_impl_.nativeflowinfo_ != nullptr) _impl_.nativeflowinfo_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::proto::Message_ButtonsMessage_Button_NativeFlowInfo& Message_ButtonsMessage_Button::_internal_nativeflowinfo() const { + const ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* p = _impl_.nativeflowinfo_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_ButtonsMessage_Button_NativeFlowInfo_default_instance_); +} +inline const ::proto::Message_ButtonsMessage_Button_NativeFlowInfo& Message_ButtonsMessage_Button::nativeflowinfo() const { + // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.Button.nativeFlowInfo) + return _internal_nativeflowinfo(); +} +inline void Message_ButtonsMessage_Button::unsafe_arena_set_allocated_nativeflowinfo( + ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* nativeflowinfo) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.nativeflowinfo_); + } + _impl_.nativeflowinfo_ = nativeflowinfo; + if (nativeflowinfo) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsMessage.Button.nativeFlowInfo) +} +inline ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* Message_ButtonsMessage_Button::release_nativeflowinfo() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* temp = _impl_.nativeflowinfo_; + _impl_.nativeflowinfo_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* Message_ButtonsMessage_Button::unsafe_arena_release_nativeflowinfo() { + // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.Button.nativeFlowInfo) + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* temp = _impl_.nativeflowinfo_; + _impl_.nativeflowinfo_ = nullptr; + return temp; +} +inline ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* Message_ButtonsMessage_Button::_internal_mutable_nativeflowinfo() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.nativeflowinfo_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_ButtonsMessage_Button_NativeFlowInfo>(GetArenaForAllocation()); + _impl_.nativeflowinfo_ = p; + } + return _impl_.nativeflowinfo_; +} +inline ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* Message_ButtonsMessage_Button::mutable_nativeflowinfo() { + ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* _msg = _internal_mutable_nativeflowinfo(); + // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.Button.nativeFlowInfo) + return _msg; +} +inline void Message_ButtonsMessage_Button::set_allocated_nativeflowinfo(::proto::Message_ButtonsMessage_Button_NativeFlowInfo* nativeflowinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.nativeflowinfo_; + } + if (nativeflowinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(nativeflowinfo); + if (message_arena != submessage_arena) { + nativeflowinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, nativeflowinfo, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.nativeflowinfo_ = nativeflowinfo; + // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.Button.nativeFlowInfo) +} + +// ------------------------------------------------------------------- + +// Message_ButtonsMessage + +// optional string contentText = 6; +inline bool Message_ButtonsMessage::_internal_has_contenttext() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_ButtonsMessage::has_contenttext() const { + return _internal_has_contenttext(); +} +inline void Message_ButtonsMessage::clear_contenttext() { + _impl_.contenttext_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_ButtonsMessage::contenttext() const { + // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.contentText) + return _internal_contenttext(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ButtonsMessage::set_contenttext(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.contenttext_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.contentText) +} +inline std::string* Message_ButtonsMessage::mutable_contenttext() { + std::string* _s = _internal_mutable_contenttext(); + // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.contentText) + return _s; +} +inline const std::string& Message_ButtonsMessage::_internal_contenttext() const { + return _impl_.contenttext_.Get(); +} +inline void Message_ButtonsMessage::_internal_set_contenttext(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.contenttext_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ButtonsMessage::_internal_mutable_contenttext() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.contenttext_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ButtonsMessage::release_contenttext() { + // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.contentText) + if (!_internal_has_contenttext()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.contenttext_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.contenttext_.IsDefault()) { + _impl_.contenttext_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ButtonsMessage::set_allocated_contenttext(std::string* contenttext) { + if (contenttext != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.contenttext_.SetAllocated(contenttext, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.contenttext_.IsDefault()) { + _impl_.contenttext_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.contentText) +} + +// optional string footerText = 7; +inline bool Message_ButtonsMessage::_internal_has_footertext() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_ButtonsMessage::has_footertext() const { + return _internal_has_footertext(); +} +inline void Message_ButtonsMessage::clear_footertext() { + _impl_.footertext_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_ButtonsMessage::footertext() const { + // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.footerText) + return _internal_footertext(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ButtonsMessage::set_footertext(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.footertext_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.footerText) +} +inline std::string* Message_ButtonsMessage::mutable_footertext() { + std::string* _s = _internal_mutable_footertext(); + // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.footerText) + return _s; +} +inline const std::string& Message_ButtonsMessage::_internal_footertext() const { + return _impl_.footertext_.Get(); +} +inline void Message_ButtonsMessage::_internal_set_footertext(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.footertext_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ButtonsMessage::_internal_mutable_footertext() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.footertext_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ButtonsMessage::release_footertext() { + // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.footerText) + if (!_internal_has_footertext()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.footertext_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.footertext_.IsDefault()) { + _impl_.footertext_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ButtonsMessage::set_allocated_footertext(std::string* footertext) { + if (footertext != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.footertext_.SetAllocated(footertext, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.footertext_.IsDefault()) { + _impl_.footertext_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.footerText) +} + +// optional .proto.ContextInfo contextInfo = 8; +inline bool Message_ButtonsMessage::_internal_has_contextinfo() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); + return value; +} +inline bool Message_ButtonsMessage::has_contextinfo() const { + return _internal_has_contextinfo(); +} +inline void Message_ButtonsMessage::clear_contextinfo() { + if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::proto::ContextInfo& Message_ButtonsMessage::_internal_contextinfo() const { + const ::proto::ContextInfo* p = _impl_.contextinfo_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ContextInfo_default_instance_); +} +inline const ::proto::ContextInfo& Message_ButtonsMessage::contextinfo() const { + // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.contextInfo) + return _internal_contextinfo(); +} +inline void Message_ButtonsMessage::unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); + } + _impl_.contextinfo_ = contextinfo; + if (contextinfo) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsMessage.contextInfo) +} +inline ::proto::ContextInfo* Message_ButtonsMessage::release_contextinfo() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ContextInfo* Message_ButtonsMessage::unsafe_arena_release_contextinfo() { + // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.contextInfo) + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; + return temp; +} +inline ::proto::ContextInfo* Message_ButtonsMessage::_internal_mutable_contextinfo() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.contextinfo_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); + _impl_.contextinfo_ = p; + } + return _impl_.contextinfo_; +} +inline ::proto::ContextInfo* Message_ButtonsMessage::mutable_contextinfo() { + ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); + // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.contextInfo) + return _msg; +} +inline void Message_ButtonsMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.contextinfo_; + } + if (contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); + if (message_arena != submessage_arena) { + contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, contextinfo, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.contextinfo_ = contextinfo; + // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.contextInfo) +} + +// repeated .proto.Message.ButtonsMessage.Button buttons = 9; +inline int Message_ButtonsMessage::_internal_buttons_size() const { + return _impl_.buttons_.size(); +} +inline int Message_ButtonsMessage::buttons_size() const { + return _internal_buttons_size(); +} +inline void Message_ButtonsMessage::clear_buttons() { + _impl_.buttons_.Clear(); +} +inline ::proto::Message_ButtonsMessage_Button* Message_ButtonsMessage::mutable_buttons(int index) { + // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.buttons) + return _impl_.buttons_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ButtonsMessage_Button >* +Message_ButtonsMessage::mutable_buttons() { + // @@protoc_insertion_point(field_mutable_list:proto.Message.ButtonsMessage.buttons) + return &_impl_.buttons_; +} +inline const ::proto::Message_ButtonsMessage_Button& Message_ButtonsMessage::_internal_buttons(int index) const { + return _impl_.buttons_.Get(index); +} +inline const ::proto::Message_ButtonsMessage_Button& Message_ButtonsMessage::buttons(int index) const { + // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.buttons) + return _internal_buttons(index); +} +inline ::proto::Message_ButtonsMessage_Button* Message_ButtonsMessage::_internal_add_buttons() { + return _impl_.buttons_.Add(); +} +inline ::proto::Message_ButtonsMessage_Button* Message_ButtonsMessage::add_buttons() { + ::proto::Message_ButtonsMessage_Button* _add = _internal_add_buttons(); + // @@protoc_insertion_point(field_add:proto.Message.ButtonsMessage.buttons) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ButtonsMessage_Button >& +Message_ButtonsMessage::buttons() const { + // @@protoc_insertion_point(field_list:proto.Message.ButtonsMessage.buttons) + return _impl_.buttons_; +} + +// optional .proto.Message.ButtonsMessage.HeaderType headerType = 10; +inline bool Message_ButtonsMessage::_internal_has_headertype() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool Message_ButtonsMessage::has_headertype() const { + return _internal_has_headertype(); +} +inline void Message_ButtonsMessage::clear_headertype() { + _impl_.headertype_ = 0; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline ::proto::Message_ButtonsMessage_HeaderType Message_ButtonsMessage::_internal_headertype() const { + return static_cast< ::proto::Message_ButtonsMessage_HeaderType >(_impl_.headertype_); +} +inline ::proto::Message_ButtonsMessage_HeaderType Message_ButtonsMessage::headertype() const { + // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.headerType) + return _internal_headertype(); +} +inline void Message_ButtonsMessage::_internal_set_headertype(::proto::Message_ButtonsMessage_HeaderType value) { + assert(::proto::Message_ButtonsMessage_HeaderType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.headertype_ = value; +} +inline void Message_ButtonsMessage::set_headertype(::proto::Message_ButtonsMessage_HeaderType value) { + _internal_set_headertype(value); + // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.headerType) +} + +// string text = 1; +inline bool Message_ButtonsMessage::_internal_has_text() const { + return header_case() == kText; +} +inline bool Message_ButtonsMessage::has_text() const { + return _internal_has_text(); +} +inline void Message_ButtonsMessage::set_has_text() { + _impl_._oneof_case_[0] = kText; +} +inline void Message_ButtonsMessage::clear_text() { + if (_internal_has_text()) { + _impl_.header_.text_.Destroy(); + clear_has_header(); + } +} +inline const std::string& Message_ButtonsMessage::text() const { + // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.text) + return _internal_text(); +} +template +inline void Message_ButtonsMessage::set_text(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_text()) { + clear_header(); + set_has_text(); + _impl_.header_.text_.InitDefault(); + } + _impl_.header_.text_.Set( static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.text) +} +inline std::string* Message_ButtonsMessage::mutable_text() { + std::string* _s = _internal_mutable_text(); + // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.text) + return _s; +} +inline const std::string& Message_ButtonsMessage::_internal_text() const { + if (_internal_has_text()) { + return _impl_.header_.text_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void Message_ButtonsMessage::_internal_set_text(const std::string& value) { + if (!_internal_has_text()) { + clear_header(); + set_has_text(); + _impl_.header_.text_.InitDefault(); + } + _impl_.header_.text_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ButtonsMessage::_internal_mutable_text() { + if (!_internal_has_text()) { + clear_header(); + set_has_text(); + _impl_.header_.text_.InitDefault(); + } + return _impl_.header_.text_.Mutable( GetArenaForAllocation()); +} +inline std::string* Message_ButtonsMessage::release_text() { + // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.text) + if (_internal_has_text()) { + clear_has_header(); + return _impl_.header_.text_.Release(); + } else { + return nullptr; + } +} +inline void Message_ButtonsMessage::set_allocated_text(std::string* text) { + if (has_header()) { + clear_header(); + } + if (text != nullptr) { + set_has_text(); + _impl_.header_.text_.InitAllocated(text, GetArenaForAllocation()); + } + // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.text) +} + +// .proto.Message.DocumentMessage documentMessage = 2; +inline bool Message_ButtonsMessage::_internal_has_documentmessage() const { + return header_case() == kDocumentMessage; +} +inline bool Message_ButtonsMessage::has_documentmessage() const { + return _internal_has_documentmessage(); +} +inline void Message_ButtonsMessage::set_has_documentmessage() { + _impl_._oneof_case_[0] = kDocumentMessage; +} +inline void Message_ButtonsMessage::clear_documentmessage() { + if (_internal_has_documentmessage()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.header_.documentmessage_; + } + clear_has_header(); + } +} +inline ::proto::Message_DocumentMessage* Message_ButtonsMessage::release_documentmessage() { + // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.documentMessage) + if (_internal_has_documentmessage()) { + clear_has_header(); + ::proto::Message_DocumentMessage* temp = _impl_.header_.documentmessage_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.header_.documentmessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::Message_DocumentMessage& Message_ButtonsMessage::_internal_documentmessage() const { + return _internal_has_documentmessage() + ? *_impl_.header_.documentmessage_ + : reinterpret_cast< ::proto::Message_DocumentMessage&>(::proto::_Message_DocumentMessage_default_instance_); +} +inline const ::proto::Message_DocumentMessage& Message_ButtonsMessage::documentmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.documentMessage) + return _internal_documentmessage(); +} +inline ::proto::Message_DocumentMessage* Message_ButtonsMessage::unsafe_arena_release_documentmessage() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.ButtonsMessage.documentMessage) + if (_internal_has_documentmessage()) { + clear_has_header(); + ::proto::Message_DocumentMessage* temp = _impl_.header_.documentmessage_; + _impl_.header_.documentmessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Message_ButtonsMessage::unsafe_arena_set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) { + clear_header(); + if (documentmessage) { + set_has_documentmessage(); + _impl_.header_.documentmessage_ = documentmessage; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsMessage.documentMessage) +} +inline ::proto::Message_DocumentMessage* Message_ButtonsMessage::_internal_mutable_documentmessage() { + if (!_internal_has_documentmessage()) { + clear_header(); + set_has_documentmessage(); + _impl_.header_.documentmessage_ = CreateMaybeMessage< ::proto::Message_DocumentMessage >(GetArenaForAllocation()); + } + return _impl_.header_.documentmessage_; +} +inline ::proto::Message_DocumentMessage* Message_ButtonsMessage::mutable_documentmessage() { + ::proto::Message_DocumentMessage* _msg = _internal_mutable_documentmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.documentMessage) + return _msg; +} + +// .proto.Message.ImageMessage imageMessage = 3; +inline bool Message_ButtonsMessage::_internal_has_imagemessage() const { + return header_case() == kImageMessage; +} +inline bool Message_ButtonsMessage::has_imagemessage() const { + return _internal_has_imagemessage(); +} +inline void Message_ButtonsMessage::set_has_imagemessage() { + _impl_._oneof_case_[0] = kImageMessage; +} +inline void Message_ButtonsMessage::clear_imagemessage() { + if (_internal_has_imagemessage()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.header_.imagemessage_; + } + clear_has_header(); + } +} +inline ::proto::Message_ImageMessage* Message_ButtonsMessage::release_imagemessage() { + // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.imageMessage) + if (_internal_has_imagemessage()) { + clear_has_header(); + ::proto::Message_ImageMessage* temp = _impl_.header_.imagemessage_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.header_.imagemessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::Message_ImageMessage& Message_ButtonsMessage::_internal_imagemessage() const { + return _internal_has_imagemessage() + ? *_impl_.header_.imagemessage_ + : reinterpret_cast< ::proto::Message_ImageMessage&>(::proto::_Message_ImageMessage_default_instance_); +} +inline const ::proto::Message_ImageMessage& Message_ButtonsMessage::imagemessage() const { + // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.imageMessage) + return _internal_imagemessage(); +} +inline ::proto::Message_ImageMessage* Message_ButtonsMessage::unsafe_arena_release_imagemessage() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.ButtonsMessage.imageMessage) + if (_internal_has_imagemessage()) { + clear_has_header(); + ::proto::Message_ImageMessage* temp = _impl_.header_.imagemessage_; + _impl_.header_.imagemessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Message_ButtonsMessage::unsafe_arena_set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) { + clear_header(); + if (imagemessage) { + set_has_imagemessage(); + _impl_.header_.imagemessage_ = imagemessage; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsMessage.imageMessage) +} +inline ::proto::Message_ImageMessage* Message_ButtonsMessage::_internal_mutable_imagemessage() { + if (!_internal_has_imagemessage()) { + clear_header(); + set_has_imagemessage(); + _impl_.header_.imagemessage_ = CreateMaybeMessage< ::proto::Message_ImageMessage >(GetArenaForAllocation()); + } + return _impl_.header_.imagemessage_; +} +inline ::proto::Message_ImageMessage* Message_ButtonsMessage::mutable_imagemessage() { + ::proto::Message_ImageMessage* _msg = _internal_mutable_imagemessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.imageMessage) + return _msg; +} + +// .proto.Message.VideoMessage videoMessage = 4; +inline bool Message_ButtonsMessage::_internal_has_videomessage() const { + return header_case() == kVideoMessage; +} +inline bool Message_ButtonsMessage::has_videomessage() const { + return _internal_has_videomessage(); +} +inline void Message_ButtonsMessage::set_has_videomessage() { + _impl_._oneof_case_[0] = kVideoMessage; +} +inline void Message_ButtonsMessage::clear_videomessage() { + if (_internal_has_videomessage()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.header_.videomessage_; + } + clear_has_header(); + } +} +inline ::proto::Message_VideoMessage* Message_ButtonsMessage::release_videomessage() { + // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.videoMessage) + if (_internal_has_videomessage()) { + clear_has_header(); + ::proto::Message_VideoMessage* temp = _impl_.header_.videomessage_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.header_.videomessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::Message_VideoMessage& Message_ButtonsMessage::_internal_videomessage() const { + return _internal_has_videomessage() + ? *_impl_.header_.videomessage_ + : reinterpret_cast< ::proto::Message_VideoMessage&>(::proto::_Message_VideoMessage_default_instance_); +} +inline const ::proto::Message_VideoMessage& Message_ButtonsMessage::videomessage() const { + // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.videoMessage) + return _internal_videomessage(); +} +inline ::proto::Message_VideoMessage* Message_ButtonsMessage::unsafe_arena_release_videomessage() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.ButtonsMessage.videoMessage) + if (_internal_has_videomessage()) { + clear_has_header(); + ::proto::Message_VideoMessage* temp = _impl_.header_.videomessage_; + _impl_.header_.videomessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Message_ButtonsMessage::unsafe_arena_set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) { + clear_header(); + if (videomessage) { + set_has_videomessage(); + _impl_.header_.videomessage_ = videomessage; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsMessage.videoMessage) +} +inline ::proto::Message_VideoMessage* Message_ButtonsMessage::_internal_mutable_videomessage() { + if (!_internal_has_videomessage()) { + clear_header(); + set_has_videomessage(); + _impl_.header_.videomessage_ = CreateMaybeMessage< ::proto::Message_VideoMessage >(GetArenaForAllocation()); + } + return _impl_.header_.videomessage_; +} +inline ::proto::Message_VideoMessage* Message_ButtonsMessage::mutable_videomessage() { + ::proto::Message_VideoMessage* _msg = _internal_mutable_videomessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.videoMessage) + return _msg; +} + +// .proto.Message.LocationMessage locationMessage = 5; +inline bool Message_ButtonsMessage::_internal_has_locationmessage() const { + return header_case() == kLocationMessage; +} +inline bool Message_ButtonsMessage::has_locationmessage() const { + return _internal_has_locationmessage(); +} +inline void Message_ButtonsMessage::set_has_locationmessage() { + _impl_._oneof_case_[0] = kLocationMessage; +} +inline void Message_ButtonsMessage::clear_locationmessage() { + if (_internal_has_locationmessage()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.header_.locationmessage_; + } + clear_has_header(); + } +} +inline ::proto::Message_LocationMessage* Message_ButtonsMessage::release_locationmessage() { + // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.locationMessage) + if (_internal_has_locationmessage()) { + clear_has_header(); + ::proto::Message_LocationMessage* temp = _impl_.header_.locationmessage_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.header_.locationmessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::Message_LocationMessage& Message_ButtonsMessage::_internal_locationmessage() const { + return _internal_has_locationmessage() + ? *_impl_.header_.locationmessage_ + : reinterpret_cast< ::proto::Message_LocationMessage&>(::proto::_Message_LocationMessage_default_instance_); +} +inline const ::proto::Message_LocationMessage& Message_ButtonsMessage::locationmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.locationMessage) + return _internal_locationmessage(); +} +inline ::proto::Message_LocationMessage* Message_ButtonsMessage::unsafe_arena_release_locationmessage() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.ButtonsMessage.locationMessage) + if (_internal_has_locationmessage()) { + clear_has_header(); + ::proto::Message_LocationMessage* temp = _impl_.header_.locationmessage_; + _impl_.header_.locationmessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Message_ButtonsMessage::unsafe_arena_set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage) { + clear_header(); + if (locationmessage) { + set_has_locationmessage(); + _impl_.header_.locationmessage_ = locationmessage; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsMessage.locationMessage) +} +inline ::proto::Message_LocationMessage* Message_ButtonsMessage::_internal_mutable_locationmessage() { + if (!_internal_has_locationmessage()) { + clear_header(); + set_has_locationmessage(); + _impl_.header_.locationmessage_ = CreateMaybeMessage< ::proto::Message_LocationMessage >(GetArenaForAllocation()); + } + return _impl_.header_.locationmessage_; +} +inline ::proto::Message_LocationMessage* Message_ButtonsMessage::mutable_locationmessage() { + ::proto::Message_LocationMessage* _msg = _internal_mutable_locationmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.locationMessage) + return _msg; +} + +inline bool Message_ButtonsMessage::has_header() const { + return header_case() != HEADER_NOT_SET; +} +inline void Message_ButtonsMessage::clear_has_header() { + _impl_._oneof_case_[0] = HEADER_NOT_SET; +} +inline Message_ButtonsMessage::HeaderCase Message_ButtonsMessage::header_case() const { + return Message_ButtonsMessage::HeaderCase(_impl_._oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// Message_ButtonsResponseMessage + +// optional string selectedButtonId = 1; +inline bool Message_ButtonsResponseMessage::_internal_has_selectedbuttonid() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_ButtonsResponseMessage::has_selectedbuttonid() const { + return _internal_has_selectedbuttonid(); +} +inline void Message_ButtonsResponseMessage::clear_selectedbuttonid() { + _impl_.selectedbuttonid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_ButtonsResponseMessage::selectedbuttonid() const { + // @@protoc_insertion_point(field_get:proto.Message.ButtonsResponseMessage.selectedButtonId) + return _internal_selectedbuttonid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ButtonsResponseMessage::set_selectedbuttonid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.selectedbuttonid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ButtonsResponseMessage.selectedButtonId) +} +inline std::string* Message_ButtonsResponseMessage::mutable_selectedbuttonid() { + std::string* _s = _internal_mutable_selectedbuttonid(); + // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsResponseMessage.selectedButtonId) + return _s; +} +inline const std::string& Message_ButtonsResponseMessage::_internal_selectedbuttonid() const { + return _impl_.selectedbuttonid_.Get(); +} +inline void Message_ButtonsResponseMessage::_internal_set_selectedbuttonid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.selectedbuttonid_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ButtonsResponseMessage::_internal_mutable_selectedbuttonid() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.selectedbuttonid_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ButtonsResponseMessage::release_selectedbuttonid() { + // @@protoc_insertion_point(field_release:proto.Message.ButtonsResponseMessage.selectedButtonId) + if (!_internal_has_selectedbuttonid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.selectedbuttonid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.selectedbuttonid_.IsDefault()) { + _impl_.selectedbuttonid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ButtonsResponseMessage::set_allocated_selectedbuttonid(std::string* selectedbuttonid) { + if (selectedbuttonid != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.selectedbuttonid_.SetAllocated(selectedbuttonid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.selectedbuttonid_.IsDefault()) { + _impl_.selectedbuttonid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsResponseMessage.selectedButtonId) +} + +// optional .proto.ContextInfo contextInfo = 3; +inline bool Message_ButtonsResponseMessage::_internal_has_contextinfo() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); + return value; +} +inline bool Message_ButtonsResponseMessage::has_contextinfo() const { + return _internal_has_contextinfo(); +} +inline void Message_ButtonsResponseMessage::clear_contextinfo() { + if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::ContextInfo& Message_ButtonsResponseMessage::_internal_contextinfo() const { + const ::proto::ContextInfo* p = _impl_.contextinfo_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ContextInfo_default_instance_); +} +inline const ::proto::ContextInfo& Message_ButtonsResponseMessage::contextinfo() const { + // @@protoc_insertion_point(field_get:proto.Message.ButtonsResponseMessage.contextInfo) + return _internal_contextinfo(); +} +inline void Message_ButtonsResponseMessage::unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); + } + _impl_.contextinfo_ = contextinfo; + if (contextinfo) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsResponseMessage.contextInfo) +} +inline ::proto::ContextInfo* Message_ButtonsResponseMessage::release_contextinfo() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ContextInfo* Message_ButtonsResponseMessage::unsafe_arena_release_contextinfo() { + // @@protoc_insertion_point(field_release:proto.Message.ButtonsResponseMessage.contextInfo) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; + return temp; +} +inline ::proto::ContextInfo* Message_ButtonsResponseMessage::_internal_mutable_contextinfo() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.contextinfo_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); + _impl_.contextinfo_ = p; + } + return _impl_.contextinfo_; +} +inline ::proto::ContextInfo* Message_ButtonsResponseMessage::mutable_contextinfo() { + ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); + // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsResponseMessage.contextInfo) + return _msg; +} +inline void Message_ButtonsResponseMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.contextinfo_; + } + if (contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); + if (message_arena != submessage_arena) { + contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, contextinfo, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.contextinfo_ = contextinfo; + // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsResponseMessage.contextInfo) +} + +// optional .proto.Message.ButtonsResponseMessage.Type type = 4; +inline bool Message_ButtonsResponseMessage::_internal_has_type() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Message_ButtonsResponseMessage::has_type() const { + return _internal_has_type(); +} +inline void Message_ButtonsResponseMessage::clear_type() { + _impl_.type_ = 0; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline ::proto::Message_ButtonsResponseMessage_Type Message_ButtonsResponseMessage::_internal_type() const { + return static_cast< ::proto::Message_ButtonsResponseMessage_Type >(_impl_.type_); +} +inline ::proto::Message_ButtonsResponseMessage_Type Message_ButtonsResponseMessage::type() const { + // @@protoc_insertion_point(field_get:proto.Message.ButtonsResponseMessage.type) + return _internal_type(); +} +inline void Message_ButtonsResponseMessage::_internal_set_type(::proto::Message_ButtonsResponseMessage_Type value) { + assert(::proto::Message_ButtonsResponseMessage_Type_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.type_ = value; +} +inline void Message_ButtonsResponseMessage::set_type(::proto::Message_ButtonsResponseMessage_Type value) { + _internal_set_type(value); + // @@protoc_insertion_point(field_set:proto.Message.ButtonsResponseMessage.type) +} + +// string selectedDisplayText = 2; +inline bool Message_ButtonsResponseMessage::_internal_has_selecteddisplaytext() const { + return response_case() == kSelectedDisplayText; +} +inline bool Message_ButtonsResponseMessage::has_selecteddisplaytext() const { + return _internal_has_selecteddisplaytext(); +} +inline void Message_ButtonsResponseMessage::set_has_selecteddisplaytext() { + _impl_._oneof_case_[0] = kSelectedDisplayText; +} +inline void Message_ButtonsResponseMessage::clear_selecteddisplaytext() { + if (_internal_has_selecteddisplaytext()) { + _impl_.response_.selecteddisplaytext_.Destroy(); + clear_has_response(); + } +} +inline const std::string& Message_ButtonsResponseMessage::selecteddisplaytext() const { + // @@protoc_insertion_point(field_get:proto.Message.ButtonsResponseMessage.selectedDisplayText) + return _internal_selecteddisplaytext(); +} +template +inline void Message_ButtonsResponseMessage::set_selecteddisplaytext(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_selecteddisplaytext()) { + clear_response(); + set_has_selecteddisplaytext(); + _impl_.response_.selecteddisplaytext_.InitDefault(); + } + _impl_.response_.selecteddisplaytext_.Set( static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ButtonsResponseMessage.selectedDisplayText) +} +inline std::string* Message_ButtonsResponseMessage::mutable_selecteddisplaytext() { + std::string* _s = _internal_mutable_selecteddisplaytext(); + // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsResponseMessage.selectedDisplayText) + return _s; +} +inline const std::string& Message_ButtonsResponseMessage::_internal_selecteddisplaytext() const { + if (_internal_has_selecteddisplaytext()) { + return _impl_.response_.selecteddisplaytext_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void Message_ButtonsResponseMessage::_internal_set_selecteddisplaytext(const std::string& value) { + if (!_internal_has_selecteddisplaytext()) { + clear_response(); + set_has_selecteddisplaytext(); + _impl_.response_.selecteddisplaytext_.InitDefault(); + } + _impl_.response_.selecteddisplaytext_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ButtonsResponseMessage::_internal_mutable_selecteddisplaytext() { + if (!_internal_has_selecteddisplaytext()) { + clear_response(); + set_has_selecteddisplaytext(); + _impl_.response_.selecteddisplaytext_.InitDefault(); + } + return _impl_.response_.selecteddisplaytext_.Mutable( GetArenaForAllocation()); +} +inline std::string* Message_ButtonsResponseMessage::release_selecteddisplaytext() { + // @@protoc_insertion_point(field_release:proto.Message.ButtonsResponseMessage.selectedDisplayText) + if (_internal_has_selecteddisplaytext()) { + clear_has_response(); + return _impl_.response_.selecteddisplaytext_.Release(); + } else { + return nullptr; + } +} +inline void Message_ButtonsResponseMessage::set_allocated_selecteddisplaytext(std::string* selecteddisplaytext) { + if (has_response()) { + clear_response(); + } + if (selecteddisplaytext != nullptr) { + set_has_selecteddisplaytext(); + _impl_.response_.selecteddisplaytext_.InitAllocated(selecteddisplaytext, GetArenaForAllocation()); + } + // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsResponseMessage.selectedDisplayText) +} + +inline bool Message_ButtonsResponseMessage::has_response() const { + return response_case() != RESPONSE_NOT_SET; +} +inline void Message_ButtonsResponseMessage::clear_has_response() { + _impl_._oneof_case_[0] = RESPONSE_NOT_SET; +} +inline Message_ButtonsResponseMessage::ResponseCase Message_ButtonsResponseMessage::response_case() const { + return Message_ButtonsResponseMessage::ResponseCase(_impl_._oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// Message_Call + +// optional bytes callKey = 1; +inline bool Message_Call::_internal_has_callkey() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_Call::has_callkey() const { + return _internal_has_callkey(); +} +inline void Message_Call::clear_callkey() { + _impl_.callkey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_Call::callkey() const { + // @@protoc_insertion_point(field_get:proto.Message.Call.callKey) + return _internal_callkey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_Call::set_callkey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.callkey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.Call.callKey) +} +inline std::string* Message_Call::mutable_callkey() { + std::string* _s = _internal_mutable_callkey(); + // @@protoc_insertion_point(field_mutable:proto.Message.Call.callKey) + return _s; +} +inline const std::string& Message_Call::_internal_callkey() const { + return _impl_.callkey_.Get(); +} +inline void Message_Call::_internal_set_callkey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.callkey_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_Call::_internal_mutable_callkey() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.callkey_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_Call::release_callkey() { + // @@protoc_insertion_point(field_release:proto.Message.Call.callKey) + if (!_internal_has_callkey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.callkey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.callkey_.IsDefault()) { + _impl_.callkey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_Call::set_allocated_callkey(std::string* callkey) { + if (callkey != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.callkey_.SetAllocated(callkey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.callkey_.IsDefault()) { + _impl_.callkey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.Call.callKey) +} + +// optional string conversionSource = 2; +inline bool Message_Call::_internal_has_conversionsource() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_Call::has_conversionsource() const { + return _internal_has_conversionsource(); +} +inline void Message_Call::clear_conversionsource() { + _impl_.conversionsource_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_Call::conversionsource() const { + // @@protoc_insertion_point(field_get:proto.Message.Call.conversionSource) + return _internal_conversionsource(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_Call::set_conversionsource(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.conversionsource_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.Call.conversionSource) +} +inline std::string* Message_Call::mutable_conversionsource() { + std::string* _s = _internal_mutable_conversionsource(); + // @@protoc_insertion_point(field_mutable:proto.Message.Call.conversionSource) + return _s; +} +inline const std::string& Message_Call::_internal_conversionsource() const { + return _impl_.conversionsource_.Get(); +} +inline void Message_Call::_internal_set_conversionsource(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.conversionsource_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_Call::_internal_mutable_conversionsource() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.conversionsource_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_Call::release_conversionsource() { + // @@protoc_insertion_point(field_release:proto.Message.Call.conversionSource) + if (!_internal_has_conversionsource()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.conversionsource_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.conversionsource_.IsDefault()) { + _impl_.conversionsource_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_Call::set_allocated_conversionsource(std::string* conversionsource) { + if (conversionsource != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.conversionsource_.SetAllocated(conversionsource, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.conversionsource_.IsDefault()) { + _impl_.conversionsource_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.Call.conversionSource) +} + +// optional bytes conversionData = 3; +inline bool Message_Call::_internal_has_conversiondata() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Message_Call::has_conversiondata() const { + return _internal_has_conversiondata(); +} +inline void Message_Call::clear_conversiondata() { + _impl_.conversiondata_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& Message_Call::conversiondata() const { + // @@protoc_insertion_point(field_get:proto.Message.Call.conversionData) + return _internal_conversiondata(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_Call::set_conversiondata(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.conversiondata_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.Call.conversionData) +} +inline std::string* Message_Call::mutable_conversiondata() { + std::string* _s = _internal_mutable_conversiondata(); + // @@protoc_insertion_point(field_mutable:proto.Message.Call.conversionData) + return _s; +} +inline const std::string& Message_Call::_internal_conversiondata() const { + return _impl_.conversiondata_.Get(); +} +inline void Message_Call::_internal_set_conversiondata(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.conversiondata_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_Call::_internal_mutable_conversiondata() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.conversiondata_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_Call::release_conversiondata() { + // @@protoc_insertion_point(field_release:proto.Message.Call.conversionData) + if (!_internal_has_conversiondata()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.conversiondata_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.conversiondata_.IsDefault()) { + _impl_.conversiondata_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_Call::set_allocated_conversiondata(std::string* conversiondata) { + if (conversiondata != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.conversiondata_.SetAllocated(conversiondata, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.conversiondata_.IsDefault()) { + _impl_.conversiondata_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.Call.conversionData) +} + +// optional uint32 conversionDelaySeconds = 4; +inline bool Message_Call::_internal_has_conversiondelayseconds() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool Message_Call::has_conversiondelayseconds() const { + return _internal_has_conversiondelayseconds(); +} +inline void Message_Call::clear_conversiondelayseconds() { + _impl_.conversiondelayseconds_ = 0u; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline uint32_t Message_Call::_internal_conversiondelayseconds() const { + return _impl_.conversiondelayseconds_; +} +inline uint32_t Message_Call::conversiondelayseconds() const { + // @@protoc_insertion_point(field_get:proto.Message.Call.conversionDelaySeconds) + return _internal_conversiondelayseconds(); +} +inline void Message_Call::_internal_set_conversiondelayseconds(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.conversiondelayseconds_ = value; +} +inline void Message_Call::set_conversiondelayseconds(uint32_t value) { + _internal_set_conversiondelayseconds(value); + // @@protoc_insertion_point(field_set:proto.Message.Call.conversionDelaySeconds) +} + +// ------------------------------------------------------------------- + +// Message_CancelPaymentRequestMessage + +// optional .proto.MessageKey key = 1; +inline bool Message_CancelPaymentRequestMessage::_internal_has_key() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr); + return value; +} +inline bool Message_CancelPaymentRequestMessage::has_key() const { + return _internal_has_key(); +} +inline void Message_CancelPaymentRequestMessage::clear_key() { + if (_impl_.key_ != nullptr) _impl_.key_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::MessageKey& Message_CancelPaymentRequestMessage::_internal_key() const { + const ::proto::MessageKey* p = _impl_.key_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_MessageKey_default_instance_); +} +inline const ::proto::MessageKey& Message_CancelPaymentRequestMessage::key() const { + // @@protoc_insertion_point(field_get:proto.Message.CancelPaymentRequestMessage.key) + return _internal_key(); +} +inline void Message_CancelPaymentRequestMessage::unsafe_arena_set_allocated_key( + ::proto::MessageKey* key) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_); + } + _impl_.key_ = key; + if (key) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.CancelPaymentRequestMessage.key) +} +inline ::proto::MessageKey* Message_CancelPaymentRequestMessage::release_key() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::MessageKey* temp = _impl_.key_; + _impl_.key_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::MessageKey* Message_CancelPaymentRequestMessage::unsafe_arena_release_key() { + // @@protoc_insertion_point(field_release:proto.Message.CancelPaymentRequestMessage.key) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::MessageKey* temp = _impl_.key_; + _impl_.key_ = nullptr; + return temp; +} +inline ::proto::MessageKey* Message_CancelPaymentRequestMessage::_internal_mutable_key() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.key_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation()); + _impl_.key_ = p; + } + return _impl_.key_; +} +inline ::proto::MessageKey* Message_CancelPaymentRequestMessage::mutable_key() { + ::proto::MessageKey* _msg = _internal_mutable_key(); + // @@protoc_insertion_point(field_mutable:proto.Message.CancelPaymentRequestMessage.key) + return _msg; +} +inline void Message_CancelPaymentRequestMessage::set_allocated_key(::proto::MessageKey* key) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.key_; + } + if (key) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key); + if (message_arena != submessage_arena) { + key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, key, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.key_ = key; + // @@protoc_insertion_point(field_set_allocated:proto.Message.CancelPaymentRequestMessage.key) +} + +// ------------------------------------------------------------------- + +// Message_Chat + +// optional string displayName = 1; +inline bool Message_Chat::_internal_has_displayname() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_Chat::has_displayname() const { + return _internal_has_displayname(); +} +inline void Message_Chat::clear_displayname() { + _impl_.displayname_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_Chat::displayname() const { + // @@protoc_insertion_point(field_get:proto.Message.Chat.displayName) + return _internal_displayname(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_Chat::set_displayname(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.displayname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.Chat.displayName) +} +inline std::string* Message_Chat::mutable_displayname() { + std::string* _s = _internal_mutable_displayname(); + // @@protoc_insertion_point(field_mutable:proto.Message.Chat.displayName) + return _s; +} +inline const std::string& Message_Chat::_internal_displayname() const { + return _impl_.displayname_.Get(); +} +inline void Message_Chat::_internal_set_displayname(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.displayname_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_Chat::_internal_mutable_displayname() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.displayname_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_Chat::release_displayname() { + // @@protoc_insertion_point(field_release:proto.Message.Chat.displayName) + if (!_internal_has_displayname()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.displayname_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.displayname_.IsDefault()) { + _impl_.displayname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_Chat::set_allocated_displayname(std::string* displayname) { + if (displayname != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.displayname_.SetAllocated(displayname, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.displayname_.IsDefault()) { + _impl_.displayname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.Chat.displayName) +} + +// optional string id = 2; +inline bool Message_Chat::_internal_has_id() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_Chat::has_id() const { + return _internal_has_id(); +} +inline void Message_Chat::clear_id() { + _impl_.id_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_Chat::id() const { + // @@protoc_insertion_point(field_get:proto.Message.Chat.id) + return _internal_id(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_Chat::set_id(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.id_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.Chat.id) +} +inline std::string* Message_Chat::mutable_id() { + std::string* _s = _internal_mutable_id(); + // @@protoc_insertion_point(field_mutable:proto.Message.Chat.id) + return _s; +} +inline const std::string& Message_Chat::_internal_id() const { + return _impl_.id_.Get(); +} +inline void Message_Chat::_internal_set_id(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.id_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_Chat::_internal_mutable_id() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.id_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_Chat::release_id() { + // @@protoc_insertion_point(field_release:proto.Message.Chat.id) + if (!_internal_has_id()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.id_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.id_.IsDefault()) { + _impl_.id_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_Chat::set_allocated_id(std::string* id) { + if (id != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.id_.SetAllocated(id, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.id_.IsDefault()) { + _impl_.id_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.Chat.id) +} + +// ------------------------------------------------------------------- + +// Message_ContactMessage + +// optional string displayName = 1; +inline bool Message_ContactMessage::_internal_has_displayname() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_ContactMessage::has_displayname() const { + return _internal_has_displayname(); +} +inline void Message_ContactMessage::clear_displayname() { + _impl_.displayname_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_ContactMessage::displayname() const { + // @@protoc_insertion_point(field_get:proto.Message.ContactMessage.displayName) + return _internal_displayname(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ContactMessage::set_displayname(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.displayname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ContactMessage.displayName) +} +inline std::string* Message_ContactMessage::mutable_displayname() { + std::string* _s = _internal_mutable_displayname(); + // @@protoc_insertion_point(field_mutable:proto.Message.ContactMessage.displayName) + return _s; +} +inline const std::string& Message_ContactMessage::_internal_displayname() const { + return _impl_.displayname_.Get(); +} +inline void Message_ContactMessage::_internal_set_displayname(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.displayname_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ContactMessage::_internal_mutable_displayname() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.displayname_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ContactMessage::release_displayname() { + // @@protoc_insertion_point(field_release:proto.Message.ContactMessage.displayName) + if (!_internal_has_displayname()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.displayname_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.displayname_.IsDefault()) { + _impl_.displayname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ContactMessage::set_allocated_displayname(std::string* displayname) { + if (displayname != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.displayname_.SetAllocated(displayname, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.displayname_.IsDefault()) { + _impl_.displayname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ContactMessage.displayName) +} + +// optional string vcard = 16; +inline bool Message_ContactMessage::_internal_has_vcard() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_ContactMessage::has_vcard() const { + return _internal_has_vcard(); +} +inline void Message_ContactMessage::clear_vcard() { + _impl_.vcard_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_ContactMessage::vcard() const { + // @@protoc_insertion_point(field_get:proto.Message.ContactMessage.vcard) + return _internal_vcard(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ContactMessage::set_vcard(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.vcard_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ContactMessage.vcard) +} +inline std::string* Message_ContactMessage::mutable_vcard() { + std::string* _s = _internal_mutable_vcard(); + // @@protoc_insertion_point(field_mutable:proto.Message.ContactMessage.vcard) + return _s; +} +inline const std::string& Message_ContactMessage::_internal_vcard() const { + return _impl_.vcard_.Get(); +} +inline void Message_ContactMessage::_internal_set_vcard(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.vcard_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ContactMessage::_internal_mutable_vcard() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.vcard_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ContactMessage::release_vcard() { + // @@protoc_insertion_point(field_release:proto.Message.ContactMessage.vcard) + if (!_internal_has_vcard()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.vcard_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.vcard_.IsDefault()) { + _impl_.vcard_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ContactMessage::set_allocated_vcard(std::string* vcard) { + if (vcard != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.vcard_.SetAllocated(vcard, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.vcard_.IsDefault()) { + _impl_.vcard_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ContactMessage.vcard) +} + +// optional .proto.ContextInfo contextInfo = 17; +inline bool Message_ContactMessage::_internal_has_contextinfo() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); + return value; +} +inline bool Message_ContactMessage::has_contextinfo() const { + return _internal_has_contextinfo(); +} +inline void Message_ContactMessage::clear_contextinfo() { + if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::proto::ContextInfo& Message_ContactMessage::_internal_contextinfo() const { + const ::proto::ContextInfo* p = _impl_.contextinfo_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ContextInfo_default_instance_); +} +inline const ::proto::ContextInfo& Message_ContactMessage::contextinfo() const { + // @@protoc_insertion_point(field_get:proto.Message.ContactMessage.contextInfo) + return _internal_contextinfo(); +} +inline void Message_ContactMessage::unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); + } + _impl_.contextinfo_ = contextinfo; + if (contextinfo) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ContactMessage.contextInfo) +} +inline ::proto::ContextInfo* Message_ContactMessage::release_contextinfo() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ContextInfo* Message_ContactMessage::unsafe_arena_release_contextinfo() { + // @@protoc_insertion_point(field_release:proto.Message.ContactMessage.contextInfo) + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; + return temp; +} +inline ::proto::ContextInfo* Message_ContactMessage::_internal_mutable_contextinfo() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.contextinfo_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); + _impl_.contextinfo_ = p; + } + return _impl_.contextinfo_; +} +inline ::proto::ContextInfo* Message_ContactMessage::mutable_contextinfo() { + ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); + // @@protoc_insertion_point(field_mutable:proto.Message.ContactMessage.contextInfo) + return _msg; +} +inline void Message_ContactMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.contextinfo_; + } + if (contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); + if (message_arena != submessage_arena) { + contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, contextinfo, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.contextinfo_ = contextinfo; + // @@protoc_insertion_point(field_set_allocated:proto.Message.ContactMessage.contextInfo) +} + +// ------------------------------------------------------------------- + +// Message_ContactsArrayMessage + +// optional string displayName = 1; +inline bool Message_ContactsArrayMessage::_internal_has_displayname() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_ContactsArrayMessage::has_displayname() const { + return _internal_has_displayname(); +} +inline void Message_ContactsArrayMessage::clear_displayname() { + _impl_.displayname_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_ContactsArrayMessage::displayname() const { + // @@protoc_insertion_point(field_get:proto.Message.ContactsArrayMessage.displayName) + return _internal_displayname(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ContactsArrayMessage::set_displayname(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.displayname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ContactsArrayMessage.displayName) +} +inline std::string* Message_ContactsArrayMessage::mutable_displayname() { + std::string* _s = _internal_mutable_displayname(); + // @@protoc_insertion_point(field_mutable:proto.Message.ContactsArrayMessage.displayName) + return _s; +} +inline const std::string& Message_ContactsArrayMessage::_internal_displayname() const { + return _impl_.displayname_.Get(); +} +inline void Message_ContactsArrayMessage::_internal_set_displayname(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.displayname_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ContactsArrayMessage::_internal_mutable_displayname() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.displayname_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ContactsArrayMessage::release_displayname() { + // @@protoc_insertion_point(field_release:proto.Message.ContactsArrayMessage.displayName) + if (!_internal_has_displayname()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.displayname_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.displayname_.IsDefault()) { + _impl_.displayname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ContactsArrayMessage::set_allocated_displayname(std::string* displayname) { + if (displayname != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.displayname_.SetAllocated(displayname, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.displayname_.IsDefault()) { + _impl_.displayname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ContactsArrayMessage.displayName) +} + +// repeated .proto.Message.ContactMessage contacts = 2; +inline int Message_ContactsArrayMessage::_internal_contacts_size() const { + return _impl_.contacts_.size(); +} +inline int Message_ContactsArrayMessage::contacts_size() const { + return _internal_contacts_size(); +} +inline void Message_ContactsArrayMessage::clear_contacts() { + _impl_.contacts_.Clear(); +} +inline ::proto::Message_ContactMessage* Message_ContactsArrayMessage::mutable_contacts(int index) { + // @@protoc_insertion_point(field_mutable:proto.Message.ContactsArrayMessage.contacts) + return _impl_.contacts_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ContactMessage >* +Message_ContactsArrayMessage::mutable_contacts() { + // @@protoc_insertion_point(field_mutable_list:proto.Message.ContactsArrayMessage.contacts) + return &_impl_.contacts_; +} +inline const ::proto::Message_ContactMessage& Message_ContactsArrayMessage::_internal_contacts(int index) const { + return _impl_.contacts_.Get(index); +} +inline const ::proto::Message_ContactMessage& Message_ContactsArrayMessage::contacts(int index) const { + // @@protoc_insertion_point(field_get:proto.Message.ContactsArrayMessage.contacts) + return _internal_contacts(index); +} +inline ::proto::Message_ContactMessage* Message_ContactsArrayMessage::_internal_add_contacts() { + return _impl_.contacts_.Add(); +} +inline ::proto::Message_ContactMessage* Message_ContactsArrayMessage::add_contacts() { + ::proto::Message_ContactMessage* _add = _internal_add_contacts(); + // @@protoc_insertion_point(field_add:proto.Message.ContactsArrayMessage.contacts) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ContactMessage >& +Message_ContactsArrayMessage::contacts() const { + // @@protoc_insertion_point(field_list:proto.Message.ContactsArrayMessage.contacts) + return _impl_.contacts_; +} + +// optional .proto.ContextInfo contextInfo = 17; +inline bool Message_ContactsArrayMessage::_internal_has_contextinfo() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); + return value; +} +inline bool Message_ContactsArrayMessage::has_contextinfo() const { + return _internal_has_contextinfo(); +} +inline void Message_ContactsArrayMessage::clear_contextinfo() { + if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::ContextInfo& Message_ContactsArrayMessage::_internal_contextinfo() const { + const ::proto::ContextInfo* p = _impl_.contextinfo_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ContextInfo_default_instance_); +} +inline const ::proto::ContextInfo& Message_ContactsArrayMessage::contextinfo() const { + // @@protoc_insertion_point(field_get:proto.Message.ContactsArrayMessage.contextInfo) + return _internal_contextinfo(); +} +inline void Message_ContactsArrayMessage::unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); + } + _impl_.contextinfo_ = contextinfo; + if (contextinfo) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ContactsArrayMessage.contextInfo) +} +inline ::proto::ContextInfo* Message_ContactsArrayMessage::release_contextinfo() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ContextInfo* Message_ContactsArrayMessage::unsafe_arena_release_contextinfo() { + // @@protoc_insertion_point(field_release:proto.Message.ContactsArrayMessage.contextInfo) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; + return temp; +} +inline ::proto::ContextInfo* Message_ContactsArrayMessage::_internal_mutable_contextinfo() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.contextinfo_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); + _impl_.contextinfo_ = p; + } + return _impl_.contextinfo_; +} +inline ::proto::ContextInfo* Message_ContactsArrayMessage::mutable_contextinfo() { + ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); + // @@protoc_insertion_point(field_mutable:proto.Message.ContactsArrayMessage.contextInfo) + return _msg; +} +inline void Message_ContactsArrayMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.contextinfo_; + } + if (contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); + if (message_arena != submessage_arena) { + contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, contextinfo, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.contextinfo_ = contextinfo; + // @@protoc_insertion_point(field_set_allocated:proto.Message.ContactsArrayMessage.contextInfo) +} + +// ------------------------------------------------------------------- + +// Message_DeclinePaymentRequestMessage + +// optional .proto.MessageKey key = 1; +inline bool Message_DeclinePaymentRequestMessage::_internal_has_key() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr); + return value; +} +inline bool Message_DeclinePaymentRequestMessage::has_key() const { + return _internal_has_key(); +} +inline void Message_DeclinePaymentRequestMessage::clear_key() { + if (_impl_.key_ != nullptr) _impl_.key_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::MessageKey& Message_DeclinePaymentRequestMessage::_internal_key() const { + const ::proto::MessageKey* p = _impl_.key_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_MessageKey_default_instance_); +} +inline const ::proto::MessageKey& Message_DeclinePaymentRequestMessage::key() const { + // @@protoc_insertion_point(field_get:proto.Message.DeclinePaymentRequestMessage.key) + return _internal_key(); +} +inline void Message_DeclinePaymentRequestMessage::unsafe_arena_set_allocated_key( + ::proto::MessageKey* key) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_); + } + _impl_.key_ = key; + if (key) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.DeclinePaymentRequestMessage.key) +} +inline ::proto::MessageKey* Message_DeclinePaymentRequestMessage::release_key() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::MessageKey* temp = _impl_.key_; + _impl_.key_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::MessageKey* Message_DeclinePaymentRequestMessage::unsafe_arena_release_key() { + // @@protoc_insertion_point(field_release:proto.Message.DeclinePaymentRequestMessage.key) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::MessageKey* temp = _impl_.key_; + _impl_.key_ = nullptr; + return temp; +} +inline ::proto::MessageKey* Message_DeclinePaymentRequestMessage::_internal_mutable_key() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.key_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation()); + _impl_.key_ = p; + } + return _impl_.key_; +} +inline ::proto::MessageKey* Message_DeclinePaymentRequestMessage::mutable_key() { + ::proto::MessageKey* _msg = _internal_mutable_key(); + // @@protoc_insertion_point(field_mutable:proto.Message.DeclinePaymentRequestMessage.key) + return _msg; +} +inline void Message_DeclinePaymentRequestMessage::set_allocated_key(::proto::MessageKey* key) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.key_; + } + if (key) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key); + if (message_arena != submessage_arena) { + key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, key, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.key_ = key; + // @@protoc_insertion_point(field_set_allocated:proto.Message.DeclinePaymentRequestMessage.key) +} + +// ------------------------------------------------------------------- + +// Message_DeviceSentMessage + +// optional string destinationJid = 1; +inline bool Message_DeviceSentMessage::_internal_has_destinationjid() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_DeviceSentMessage::has_destinationjid() const { + return _internal_has_destinationjid(); +} +inline void Message_DeviceSentMessage::clear_destinationjid() { + _impl_.destinationjid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_DeviceSentMessage::destinationjid() const { + // @@protoc_insertion_point(field_get:proto.Message.DeviceSentMessage.destinationJid) + return _internal_destinationjid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_DeviceSentMessage::set_destinationjid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.destinationjid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.DeviceSentMessage.destinationJid) +} +inline std::string* Message_DeviceSentMessage::mutable_destinationjid() { + std::string* _s = _internal_mutable_destinationjid(); + // @@protoc_insertion_point(field_mutable:proto.Message.DeviceSentMessage.destinationJid) + return _s; +} +inline const std::string& Message_DeviceSentMessage::_internal_destinationjid() const { + return _impl_.destinationjid_.Get(); +} +inline void Message_DeviceSentMessage::_internal_set_destinationjid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.destinationjid_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_DeviceSentMessage::_internal_mutable_destinationjid() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.destinationjid_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_DeviceSentMessage::release_destinationjid() { + // @@protoc_insertion_point(field_release:proto.Message.DeviceSentMessage.destinationJid) + if (!_internal_has_destinationjid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.destinationjid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.destinationjid_.IsDefault()) { + _impl_.destinationjid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_DeviceSentMessage::set_allocated_destinationjid(std::string* destinationjid) { + if (destinationjid != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.destinationjid_.SetAllocated(destinationjid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.destinationjid_.IsDefault()) { + _impl_.destinationjid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.DeviceSentMessage.destinationJid) +} + +// optional .proto.Message message = 2; +inline bool Message_DeviceSentMessage::_internal_has_message() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.message_ != nullptr); + return value; +} +inline bool Message_DeviceSentMessage::has_message() const { + return _internal_has_message(); +} +inline void Message_DeviceSentMessage::clear_message() { + if (_impl_.message_ != nullptr) _impl_.message_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::proto::Message& Message_DeviceSentMessage::_internal_message() const { + const ::proto::Message* p = _impl_.message_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_default_instance_); +} +inline const ::proto::Message& Message_DeviceSentMessage::message() const { + // @@protoc_insertion_point(field_get:proto.Message.DeviceSentMessage.message) + return _internal_message(); +} +inline void Message_DeviceSentMessage::unsafe_arena_set_allocated_message( + ::proto::Message* message) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.message_); + } + _impl_.message_ = message; + if (message) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.DeviceSentMessage.message) +} +inline ::proto::Message* Message_DeviceSentMessage::release_message() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::Message* temp = _impl_.message_; + _impl_.message_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message* Message_DeviceSentMessage::unsafe_arena_release_message() { + // @@protoc_insertion_point(field_release:proto.Message.DeviceSentMessage.message) + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::Message* temp = _impl_.message_; + _impl_.message_ = nullptr; + return temp; +} +inline ::proto::Message* Message_DeviceSentMessage::_internal_mutable_message() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.message_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message>(GetArenaForAllocation()); + _impl_.message_ = p; + } + return _impl_.message_; +} +inline ::proto::Message* Message_DeviceSentMessage::mutable_message() { + ::proto::Message* _msg = _internal_mutable_message(); + // @@protoc_insertion_point(field_mutable:proto.Message.DeviceSentMessage.message) + return _msg; +} +inline void Message_DeviceSentMessage::set_allocated_message(::proto::Message* message) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.message_; + } + if (message) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(message); + if (message_arena != submessage_arena) { + message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, message, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.message_ = message; + // @@protoc_insertion_point(field_set_allocated:proto.Message.DeviceSentMessage.message) +} + +// optional string phash = 3; +inline bool Message_DeviceSentMessage::_internal_has_phash() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_DeviceSentMessage::has_phash() const { + return _internal_has_phash(); +} +inline void Message_DeviceSentMessage::clear_phash() { + _impl_.phash_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_DeviceSentMessage::phash() const { + // @@protoc_insertion_point(field_get:proto.Message.DeviceSentMessage.phash) + return _internal_phash(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_DeviceSentMessage::set_phash(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.phash_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.DeviceSentMessage.phash) +} +inline std::string* Message_DeviceSentMessage::mutable_phash() { + std::string* _s = _internal_mutable_phash(); + // @@protoc_insertion_point(field_mutable:proto.Message.DeviceSentMessage.phash) + return _s; +} +inline const std::string& Message_DeviceSentMessage::_internal_phash() const { + return _impl_.phash_.Get(); +} +inline void Message_DeviceSentMessage::_internal_set_phash(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.phash_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_DeviceSentMessage::_internal_mutable_phash() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.phash_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_DeviceSentMessage::release_phash() { + // @@protoc_insertion_point(field_release:proto.Message.DeviceSentMessage.phash) + if (!_internal_has_phash()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.phash_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.phash_.IsDefault()) { + _impl_.phash_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_DeviceSentMessage::set_allocated_phash(std::string* phash) { + if (phash != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.phash_.SetAllocated(phash, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.phash_.IsDefault()) { + _impl_.phash_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.DeviceSentMessage.phash) +} + +// ------------------------------------------------------------------- + +// Message_DocumentMessage + +// optional string url = 1; +inline bool Message_DocumentMessage::_internal_has_url() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_DocumentMessage::has_url() const { + return _internal_has_url(); +} +inline void Message_DocumentMessage::clear_url() { + _impl_.url_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_DocumentMessage::url() const { + // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.url) + return _internal_url(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_DocumentMessage::set_url(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.url_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.url) +} +inline std::string* Message_DocumentMessage::mutable_url() { + std::string* _s = _internal_mutable_url(); + // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.url) + return _s; +} +inline const std::string& Message_DocumentMessage::_internal_url() const { + return _impl_.url_.Get(); +} +inline void Message_DocumentMessage::_internal_set_url(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.url_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_DocumentMessage::_internal_mutable_url() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.url_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_DocumentMessage::release_url() { + // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.url) + if (!_internal_has_url()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.url_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.url_.IsDefault()) { + _impl_.url_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_DocumentMessage::set_allocated_url(std::string* url) { + if (url != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.url_.SetAllocated(url, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.url_.IsDefault()) { + _impl_.url_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.url) +} + +// optional string mimetype = 2; +inline bool Message_DocumentMessage::_internal_has_mimetype() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_DocumentMessage::has_mimetype() const { + return _internal_has_mimetype(); +} +inline void Message_DocumentMessage::clear_mimetype() { + _impl_.mimetype_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_DocumentMessage::mimetype() const { + // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.mimetype) + return _internal_mimetype(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_DocumentMessage::set_mimetype(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.mimetype_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.mimetype) +} +inline std::string* Message_DocumentMessage::mutable_mimetype() { + std::string* _s = _internal_mutable_mimetype(); + // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.mimetype) + return _s; +} +inline const std::string& Message_DocumentMessage::_internal_mimetype() const { + return _impl_.mimetype_.Get(); +} +inline void Message_DocumentMessage::_internal_set_mimetype(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.mimetype_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_DocumentMessage::_internal_mutable_mimetype() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.mimetype_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_DocumentMessage::release_mimetype() { + // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.mimetype) + if (!_internal_has_mimetype()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.mimetype_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mimetype_.IsDefault()) { + _impl_.mimetype_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_DocumentMessage::set_allocated_mimetype(std::string* mimetype) { + if (mimetype != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mimetype_.IsDefault()) { + _impl_.mimetype_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.mimetype) +} + +// optional string title = 3; +inline bool Message_DocumentMessage::_internal_has_title() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Message_DocumentMessage::has_title() const { + return _internal_has_title(); +} +inline void Message_DocumentMessage::clear_title() { + _impl_.title_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& Message_DocumentMessage::title() const { + // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.title) + return _internal_title(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_DocumentMessage::set_title(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.title_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.title) +} +inline std::string* Message_DocumentMessage::mutable_title() { + std::string* _s = _internal_mutable_title(); + // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.title) + return _s; +} +inline const std::string& Message_DocumentMessage::_internal_title() const { + return _impl_.title_.Get(); +} +inline void Message_DocumentMessage::_internal_set_title(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.title_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_DocumentMessage::_internal_mutable_title() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.title_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_DocumentMessage::release_title() { + // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.title) + if (!_internal_has_title()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.title_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.title_.IsDefault()) { + _impl_.title_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_DocumentMessage::set_allocated_title(std::string* title) { + if (title != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.title_.SetAllocated(title, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.title_.IsDefault()) { + _impl_.title_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.title) +} + +// optional bytes fileSha256 = 4; +inline bool Message_DocumentMessage::_internal_has_filesha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool Message_DocumentMessage::has_filesha256() const { + return _internal_has_filesha256(); +} +inline void Message_DocumentMessage::clear_filesha256() { + _impl_.filesha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const std::string& Message_DocumentMessage::filesha256() const { + // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.fileSha256) + return _internal_filesha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_DocumentMessage::set_filesha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.filesha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.fileSha256) +} +inline std::string* Message_DocumentMessage::mutable_filesha256() { + std::string* _s = _internal_mutable_filesha256(); + // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.fileSha256) + return _s; +} +inline const std::string& Message_DocumentMessage::_internal_filesha256() const { + return _impl_.filesha256_.Get(); +} +inline void Message_DocumentMessage::_internal_set_filesha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.filesha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_DocumentMessage::_internal_mutable_filesha256() { + _impl_._has_bits_[0] |= 0x00000008u; + return _impl_.filesha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_DocumentMessage::release_filesha256() { + // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.fileSha256) + if (!_internal_has_filesha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000008u; + auto* p = _impl_.filesha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.filesha256_.IsDefault()) { + _impl_.filesha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_DocumentMessage::set_allocated_filesha256(std::string* filesha256) { + if (filesha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.filesha256_.IsDefault()) { + _impl_.filesha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.fileSha256) +} + +// optional uint64 fileLength = 5; +inline bool Message_DocumentMessage::_internal_has_filelength() const { + bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0; + return value; +} +inline bool Message_DocumentMessage::has_filelength() const { + return _internal_has_filelength(); +} +inline void Message_DocumentMessage::clear_filelength() { + _impl_.filelength_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00004000u; +} +inline uint64_t Message_DocumentMessage::_internal_filelength() const { + return _impl_.filelength_; +} +inline uint64_t Message_DocumentMessage::filelength() const { + // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.fileLength) + return _internal_filelength(); +} +inline void Message_DocumentMessage::_internal_set_filelength(uint64_t value) { + _impl_._has_bits_[0] |= 0x00004000u; + _impl_.filelength_ = value; +} +inline void Message_DocumentMessage::set_filelength(uint64_t value) { + _internal_set_filelength(value); + // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.fileLength) +} + +// optional uint32 pageCount = 6; +inline bool Message_DocumentMessage::_internal_has_pagecount() const { + bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0; + return value; +} +inline bool Message_DocumentMessage::has_pagecount() const { + return _internal_has_pagecount(); +} +inline void Message_DocumentMessage::clear_pagecount() { + _impl_.pagecount_ = 0u; + _impl_._has_bits_[0] &= ~0x00008000u; +} +inline uint32_t Message_DocumentMessage::_internal_pagecount() const { + return _impl_.pagecount_; +} +inline uint32_t Message_DocumentMessage::pagecount() const { + // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.pageCount) + return _internal_pagecount(); +} +inline void Message_DocumentMessage::_internal_set_pagecount(uint32_t value) { + _impl_._has_bits_[0] |= 0x00008000u; + _impl_.pagecount_ = value; +} +inline void Message_DocumentMessage::set_pagecount(uint32_t value) { + _internal_set_pagecount(value); + // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.pageCount) +} + +// optional bytes mediaKey = 7; +inline bool Message_DocumentMessage::_internal_has_mediakey() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool Message_DocumentMessage::has_mediakey() const { + return _internal_has_mediakey(); +} +inline void Message_DocumentMessage::clear_mediakey() { + _impl_.mediakey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const std::string& Message_DocumentMessage::mediakey() const { + // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.mediaKey) + return _internal_mediakey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_DocumentMessage::set_mediakey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.mediakey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.mediaKey) +} +inline std::string* Message_DocumentMessage::mutable_mediakey() { + std::string* _s = _internal_mutable_mediakey(); + // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.mediaKey) + return _s; +} +inline const std::string& Message_DocumentMessage::_internal_mediakey() const { + return _impl_.mediakey_.Get(); +} +inline void Message_DocumentMessage::_internal_set_mediakey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.mediakey_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_DocumentMessage::_internal_mutable_mediakey() { + _impl_._has_bits_[0] |= 0x00000010u; + return _impl_.mediakey_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_DocumentMessage::release_mediakey() { + // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.mediaKey) + if (!_internal_has_mediakey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000010u; + auto* p = _impl_.mediakey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mediakey_.IsDefault()) { + _impl_.mediakey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_DocumentMessage::set_allocated_mediakey(std::string* mediakey) { + if (mediakey != nullptr) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mediakey_.IsDefault()) { + _impl_.mediakey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.mediaKey) +} + +// optional string fileName = 8; +inline bool Message_DocumentMessage::_internal_has_filename() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool Message_DocumentMessage::has_filename() const { + return _internal_has_filename(); +} +inline void Message_DocumentMessage::clear_filename() { + _impl_.filename_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline const std::string& Message_DocumentMessage::filename() const { + // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.fileName) + return _internal_filename(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_DocumentMessage::set_filename(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.filename_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.fileName) +} +inline std::string* Message_DocumentMessage::mutable_filename() { + std::string* _s = _internal_mutable_filename(); + // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.fileName) + return _s; +} +inline const std::string& Message_DocumentMessage::_internal_filename() const { + return _impl_.filename_.Get(); +} +inline void Message_DocumentMessage::_internal_set_filename(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.filename_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_DocumentMessage::_internal_mutable_filename() { + _impl_._has_bits_[0] |= 0x00000020u; + return _impl_.filename_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_DocumentMessage::release_filename() { + // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.fileName) + if (!_internal_has_filename()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000020u; + auto* p = _impl_.filename_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.filename_.IsDefault()) { + _impl_.filename_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_DocumentMessage::set_allocated_filename(std::string* filename) { + if (filename != nullptr) { + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + _impl_.filename_.SetAllocated(filename, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.filename_.IsDefault()) { + _impl_.filename_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.fileName) +} + +// optional bytes fileEncSha256 = 9; +inline bool Message_DocumentMessage::_internal_has_fileencsha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool Message_DocumentMessage::has_fileencsha256() const { + return _internal_has_fileencsha256(); +} +inline void Message_DocumentMessage::clear_fileencsha256() { + _impl_.fileencsha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline const std::string& Message_DocumentMessage::fileencsha256() const { + // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.fileEncSha256) + return _internal_fileencsha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_DocumentMessage::set_fileencsha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.fileencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.fileEncSha256) +} +inline std::string* Message_DocumentMessage::mutable_fileencsha256() { + std::string* _s = _internal_mutable_fileencsha256(); + // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.fileEncSha256) + return _s; +} +inline const std::string& Message_DocumentMessage::_internal_fileencsha256() const { + return _impl_.fileencsha256_.Get(); +} +inline void Message_DocumentMessage::_internal_set_fileencsha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.fileencsha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_DocumentMessage::_internal_mutable_fileencsha256() { + _impl_._has_bits_[0] |= 0x00000040u; + return _impl_.fileencsha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_DocumentMessage::release_fileencsha256() { + // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.fileEncSha256) + if (!_internal_has_fileencsha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000040u; + auto* p = _impl_.fileencsha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fileencsha256_.IsDefault()) { + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_DocumentMessage::set_allocated_fileencsha256(std::string* fileencsha256) { + if (fileencsha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fileencsha256_.IsDefault()) { + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.fileEncSha256) +} + +// optional string directPath = 10; +inline bool Message_DocumentMessage::_internal_has_directpath() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool Message_DocumentMessage::has_directpath() const { + return _internal_has_directpath(); +} +inline void Message_DocumentMessage::clear_directpath() { + _impl_.directpath_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline const std::string& Message_DocumentMessage::directpath() const { + // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.directPath) + return _internal_directpath(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_DocumentMessage::set_directpath(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.directpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.directPath) +} +inline std::string* Message_DocumentMessage::mutable_directpath() { + std::string* _s = _internal_mutable_directpath(); + // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.directPath) + return _s; +} +inline const std::string& Message_DocumentMessage::_internal_directpath() const { + return _impl_.directpath_.Get(); +} +inline void Message_DocumentMessage::_internal_set_directpath(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.directpath_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_DocumentMessage::_internal_mutable_directpath() { + _impl_._has_bits_[0] |= 0x00000080u; + return _impl_.directpath_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_DocumentMessage::release_directpath() { + // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.directPath) + if (!_internal_has_directpath()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000080u; + auto* p = _impl_.directpath_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.directpath_.IsDefault()) { + _impl_.directpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_DocumentMessage::set_allocated_directpath(std::string* directpath) { + if (directpath != nullptr) { + _impl_._has_bits_[0] |= 0x00000080u; + } else { + _impl_._has_bits_[0] &= ~0x00000080u; + } + _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.directpath_.IsDefault()) { + _impl_.directpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.directPath) +} + +// optional int64 mediaKeyTimestamp = 11; +inline bool Message_DocumentMessage::_internal_has_mediakeytimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0; + return value; +} +inline bool Message_DocumentMessage::has_mediakeytimestamp() const { + return _internal_has_mediakeytimestamp(); +} +inline void Message_DocumentMessage::clear_mediakeytimestamp() { + _impl_.mediakeytimestamp_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00020000u; +} +inline int64_t Message_DocumentMessage::_internal_mediakeytimestamp() const { + return _impl_.mediakeytimestamp_; +} +inline int64_t Message_DocumentMessage::mediakeytimestamp() const { + // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.mediaKeyTimestamp) + return _internal_mediakeytimestamp(); +} +inline void Message_DocumentMessage::_internal_set_mediakeytimestamp(int64_t value) { + _impl_._has_bits_[0] |= 0x00020000u; + _impl_.mediakeytimestamp_ = value; +} +inline void Message_DocumentMessage::set_mediakeytimestamp(int64_t value) { + _internal_set_mediakeytimestamp(value); + // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.mediaKeyTimestamp) +} + +// optional bool contactVcard = 12; +inline bool Message_DocumentMessage::_internal_has_contactvcard() const { + bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0; + return value; +} +inline bool Message_DocumentMessage::has_contactvcard() const { + return _internal_has_contactvcard(); +} +inline void Message_DocumentMessage::clear_contactvcard() { + _impl_.contactvcard_ = false; + _impl_._has_bits_[0] &= ~0x00010000u; +} +inline bool Message_DocumentMessage::_internal_contactvcard() const { + return _impl_.contactvcard_; +} +inline bool Message_DocumentMessage::contactvcard() const { + // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.contactVcard) + return _internal_contactvcard(); +} +inline void Message_DocumentMessage::_internal_set_contactvcard(bool value) { + _impl_._has_bits_[0] |= 0x00010000u; + _impl_.contactvcard_ = value; +} +inline void Message_DocumentMessage::set_contactvcard(bool value) { + _internal_set_contactvcard(value); + // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.contactVcard) +} + +// optional string thumbnailDirectPath = 13; +inline bool Message_DocumentMessage::_internal_has_thumbnaildirectpath() const { + bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool Message_DocumentMessage::has_thumbnaildirectpath() const { + return _internal_has_thumbnaildirectpath(); +} +inline void Message_DocumentMessage::clear_thumbnaildirectpath() { + _impl_.thumbnaildirectpath_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000100u; +} +inline const std::string& Message_DocumentMessage::thumbnaildirectpath() const { + // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.thumbnailDirectPath) + return _internal_thumbnaildirectpath(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_DocumentMessage::set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.thumbnaildirectpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.thumbnailDirectPath) +} +inline std::string* Message_DocumentMessage::mutable_thumbnaildirectpath() { + std::string* _s = _internal_mutable_thumbnaildirectpath(); + // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.thumbnailDirectPath) + return _s; +} +inline const std::string& Message_DocumentMessage::_internal_thumbnaildirectpath() const { + return _impl_.thumbnaildirectpath_.Get(); +} +inline void Message_DocumentMessage::_internal_set_thumbnaildirectpath(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.thumbnaildirectpath_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_DocumentMessage::_internal_mutable_thumbnaildirectpath() { + _impl_._has_bits_[0] |= 0x00000100u; + return _impl_.thumbnaildirectpath_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_DocumentMessage::release_thumbnaildirectpath() { + // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.thumbnailDirectPath) + if (!_internal_has_thumbnaildirectpath()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000100u; + auto* p = _impl_.thumbnaildirectpath_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.thumbnaildirectpath_.IsDefault()) { + _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_DocumentMessage::set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath) { + if (thumbnaildirectpath != nullptr) { + _impl_._has_bits_[0] |= 0x00000100u; + } else { + _impl_._has_bits_[0] &= ~0x00000100u; + } + _impl_.thumbnaildirectpath_.SetAllocated(thumbnaildirectpath, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.thumbnaildirectpath_.IsDefault()) { + _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.thumbnailDirectPath) +} + +// optional bytes thumbnailSha256 = 14; +inline bool Message_DocumentMessage::_internal_has_thumbnailsha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool Message_DocumentMessage::has_thumbnailsha256() const { + return _internal_has_thumbnailsha256(); +} +inline void Message_DocumentMessage::clear_thumbnailsha256() { + _impl_.thumbnailsha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000200u; +} +inline const std::string& Message_DocumentMessage::thumbnailsha256() const { + // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.thumbnailSha256) + return _internal_thumbnailsha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_DocumentMessage::set_thumbnailsha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.thumbnailsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.thumbnailSha256) +} +inline std::string* Message_DocumentMessage::mutable_thumbnailsha256() { + std::string* _s = _internal_mutable_thumbnailsha256(); + // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.thumbnailSha256) + return _s; +} +inline const std::string& Message_DocumentMessage::_internal_thumbnailsha256() const { + return _impl_.thumbnailsha256_.Get(); +} +inline void Message_DocumentMessage::_internal_set_thumbnailsha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.thumbnailsha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_DocumentMessage::_internal_mutable_thumbnailsha256() { + _impl_._has_bits_[0] |= 0x00000200u; + return _impl_.thumbnailsha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_DocumentMessage::release_thumbnailsha256() { + // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.thumbnailSha256) + if (!_internal_has_thumbnailsha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000200u; + auto* p = _impl_.thumbnailsha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.thumbnailsha256_.IsDefault()) { + _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_DocumentMessage::set_allocated_thumbnailsha256(std::string* thumbnailsha256) { + if (thumbnailsha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000200u; + } else { + _impl_._has_bits_[0] &= ~0x00000200u; + } + _impl_.thumbnailsha256_.SetAllocated(thumbnailsha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.thumbnailsha256_.IsDefault()) { + _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.thumbnailSha256) +} + +// optional bytes thumbnailEncSha256 = 15; +inline bool Message_DocumentMessage::_internal_has_thumbnailencsha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool Message_DocumentMessage::has_thumbnailencsha256() const { + return _internal_has_thumbnailencsha256(); +} +inline void Message_DocumentMessage::clear_thumbnailencsha256() { + _impl_.thumbnailencsha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000400u; +} +inline const std::string& Message_DocumentMessage::thumbnailencsha256() const { + // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.thumbnailEncSha256) + return _internal_thumbnailencsha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_DocumentMessage::set_thumbnailencsha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000400u; + _impl_.thumbnailencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.thumbnailEncSha256) +} +inline std::string* Message_DocumentMessage::mutable_thumbnailencsha256() { + std::string* _s = _internal_mutable_thumbnailencsha256(); + // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.thumbnailEncSha256) + return _s; +} +inline const std::string& Message_DocumentMessage::_internal_thumbnailencsha256() const { + return _impl_.thumbnailencsha256_.Get(); +} +inline void Message_DocumentMessage::_internal_set_thumbnailencsha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000400u; + _impl_.thumbnailencsha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_DocumentMessage::_internal_mutable_thumbnailencsha256() { + _impl_._has_bits_[0] |= 0x00000400u; + return _impl_.thumbnailencsha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_DocumentMessage::release_thumbnailencsha256() { + // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.thumbnailEncSha256) + if (!_internal_has_thumbnailencsha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000400u; + auto* p = _impl_.thumbnailencsha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.thumbnailencsha256_.IsDefault()) { + _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_DocumentMessage::set_allocated_thumbnailencsha256(std::string* thumbnailencsha256) { + if (thumbnailencsha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000400u; + } else { + _impl_._has_bits_[0] &= ~0x00000400u; + } + _impl_.thumbnailencsha256_.SetAllocated(thumbnailencsha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.thumbnailencsha256_.IsDefault()) { + _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.thumbnailEncSha256) +} + +// optional bytes jpegThumbnail = 16; +inline bool Message_DocumentMessage::_internal_has_jpegthumbnail() const { + bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; + return value; +} +inline bool Message_DocumentMessage::has_jpegthumbnail() const { + return _internal_has_jpegthumbnail(); +} +inline void Message_DocumentMessage::clear_jpegthumbnail() { + _impl_.jpegthumbnail_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000800u; +} +inline const std::string& Message_DocumentMessage::jpegthumbnail() const { + // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.jpegThumbnail) + return _internal_jpegthumbnail(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_DocumentMessage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000800u; + _impl_.jpegthumbnail_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.jpegThumbnail) +} +inline std::string* Message_DocumentMessage::mutable_jpegthumbnail() { + std::string* _s = _internal_mutable_jpegthumbnail(); + // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.jpegThumbnail) + return _s; +} +inline const std::string& Message_DocumentMessage::_internal_jpegthumbnail() const { + return _impl_.jpegthumbnail_.Get(); +} +inline void Message_DocumentMessage::_internal_set_jpegthumbnail(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000800u; + _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_DocumentMessage::_internal_mutable_jpegthumbnail() { + _impl_._has_bits_[0] |= 0x00000800u; + return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_DocumentMessage::release_jpegthumbnail() { + // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.jpegThumbnail) + if (!_internal_has_jpegthumbnail()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000800u; + auto* p = _impl_.jpegthumbnail_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.jpegthumbnail_.IsDefault()) { + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_DocumentMessage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) { + if (jpegthumbnail != nullptr) { + _impl_._has_bits_[0] |= 0x00000800u; + } else { + _impl_._has_bits_[0] &= ~0x00000800u; + } + _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.jpegthumbnail_.IsDefault()) { + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.jpegThumbnail) +} + +// optional .proto.ContextInfo contextInfo = 17; +inline bool Message_DocumentMessage::_internal_has_contextinfo() const { + bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); + return value; +} +inline bool Message_DocumentMessage::has_contextinfo() const { + return _internal_has_contextinfo(); +} +inline void Message_DocumentMessage::clear_contextinfo() { + if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); + _impl_._has_bits_[0] &= ~0x00002000u; +} +inline const ::proto::ContextInfo& Message_DocumentMessage::_internal_contextinfo() const { + const ::proto::ContextInfo* p = _impl_.contextinfo_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ContextInfo_default_instance_); +} +inline const ::proto::ContextInfo& Message_DocumentMessage::contextinfo() const { + // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.contextInfo) + return _internal_contextinfo(); +} +inline void Message_DocumentMessage::unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); + } + _impl_.contextinfo_ = contextinfo; + if (contextinfo) { + _impl_._has_bits_[0] |= 0x00002000u; + } else { + _impl_._has_bits_[0] &= ~0x00002000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.DocumentMessage.contextInfo) +} +inline ::proto::ContextInfo* Message_DocumentMessage::release_contextinfo() { + _impl_._has_bits_[0] &= ~0x00002000u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ContextInfo* Message_DocumentMessage::unsafe_arena_release_contextinfo() { + // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.contextInfo) + _impl_._has_bits_[0] &= ~0x00002000u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; + return temp; +} +inline ::proto::ContextInfo* Message_DocumentMessage::_internal_mutable_contextinfo() { + _impl_._has_bits_[0] |= 0x00002000u; + if (_impl_.contextinfo_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); + _impl_.contextinfo_ = p; + } + return _impl_.contextinfo_; +} +inline ::proto::ContextInfo* Message_DocumentMessage::mutable_contextinfo() { + ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); + // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.contextInfo) + return _msg; +} +inline void Message_DocumentMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.contextinfo_; + } + if (contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); + if (message_arena != submessage_arena) { + contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, contextinfo, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00002000u; + } else { + _impl_._has_bits_[0] &= ~0x00002000u; + } + _impl_.contextinfo_ = contextinfo; + // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.contextInfo) +} + +// optional uint32 thumbnailHeight = 18; +inline bool Message_DocumentMessage::_internal_has_thumbnailheight() const { + bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0; + return value; +} +inline bool Message_DocumentMessage::has_thumbnailheight() const { + return _internal_has_thumbnailheight(); +} +inline void Message_DocumentMessage::clear_thumbnailheight() { + _impl_.thumbnailheight_ = 0u; + _impl_._has_bits_[0] &= ~0x00040000u; +} +inline uint32_t Message_DocumentMessage::_internal_thumbnailheight() const { + return _impl_.thumbnailheight_; +} +inline uint32_t Message_DocumentMessage::thumbnailheight() const { + // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.thumbnailHeight) + return _internal_thumbnailheight(); +} +inline void Message_DocumentMessage::_internal_set_thumbnailheight(uint32_t value) { + _impl_._has_bits_[0] |= 0x00040000u; + _impl_.thumbnailheight_ = value; +} +inline void Message_DocumentMessage::set_thumbnailheight(uint32_t value) { + _internal_set_thumbnailheight(value); + // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.thumbnailHeight) +} + +// optional uint32 thumbnailWidth = 19; +inline bool Message_DocumentMessage::_internal_has_thumbnailwidth() const { + bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0; + return value; +} +inline bool Message_DocumentMessage::has_thumbnailwidth() const { + return _internal_has_thumbnailwidth(); +} +inline void Message_DocumentMessage::clear_thumbnailwidth() { + _impl_.thumbnailwidth_ = 0u; + _impl_._has_bits_[0] &= ~0x00080000u; +} +inline uint32_t Message_DocumentMessage::_internal_thumbnailwidth() const { + return _impl_.thumbnailwidth_; +} +inline uint32_t Message_DocumentMessage::thumbnailwidth() const { + // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.thumbnailWidth) + return _internal_thumbnailwidth(); +} +inline void Message_DocumentMessage::_internal_set_thumbnailwidth(uint32_t value) { + _impl_._has_bits_[0] |= 0x00080000u; + _impl_.thumbnailwidth_ = value; +} +inline void Message_DocumentMessage::set_thumbnailwidth(uint32_t value) { + _internal_set_thumbnailwidth(value); + // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.thumbnailWidth) +} + +// optional string caption = 20; +inline bool Message_DocumentMessage::_internal_has_caption() const { + bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; + return value; +} +inline bool Message_DocumentMessage::has_caption() const { + return _internal_has_caption(); +} +inline void Message_DocumentMessage::clear_caption() { + _impl_.caption_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00001000u; +} +inline const std::string& Message_DocumentMessage::caption() const { + // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.caption) + return _internal_caption(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_DocumentMessage::set_caption(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00001000u; + _impl_.caption_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.caption) +} +inline std::string* Message_DocumentMessage::mutable_caption() { + std::string* _s = _internal_mutable_caption(); + // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.caption) + return _s; +} +inline const std::string& Message_DocumentMessage::_internal_caption() const { + return _impl_.caption_.Get(); +} +inline void Message_DocumentMessage::_internal_set_caption(const std::string& value) { + _impl_._has_bits_[0] |= 0x00001000u; + _impl_.caption_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_DocumentMessage::_internal_mutable_caption() { + _impl_._has_bits_[0] |= 0x00001000u; + return _impl_.caption_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_DocumentMessage::release_caption() { + // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.caption) + if (!_internal_has_caption()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00001000u; + auto* p = _impl_.caption_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.caption_.IsDefault()) { + _impl_.caption_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_DocumentMessage::set_allocated_caption(std::string* caption) { + if (caption != nullptr) { + _impl_._has_bits_[0] |= 0x00001000u; + } else { + _impl_._has_bits_[0] &= ~0x00001000u; + } + _impl_.caption_.SetAllocated(caption, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.caption_.IsDefault()) { + _impl_.caption_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.caption) +} + +// ------------------------------------------------------------------- + +// Message_ExtendedTextMessage + +// optional string text = 1; +inline bool Message_ExtendedTextMessage::_internal_has_text() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_ExtendedTextMessage::has_text() const { + return _internal_has_text(); +} +inline void Message_ExtendedTextMessage::clear_text() { + _impl_.text_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_ExtendedTextMessage::text() const { + // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.text) + return _internal_text(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ExtendedTextMessage::set_text(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.text_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.text) +} +inline std::string* Message_ExtendedTextMessage::mutable_text() { + std::string* _s = _internal_mutable_text(); + // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.text) + return _s; +} +inline const std::string& Message_ExtendedTextMessage::_internal_text() const { + return _impl_.text_.Get(); +} +inline void Message_ExtendedTextMessage::_internal_set_text(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.text_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ExtendedTextMessage::_internal_mutable_text() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.text_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ExtendedTextMessage::release_text() { + // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.text) + if (!_internal_has_text()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.text_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.text_.IsDefault()) { + _impl_.text_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ExtendedTextMessage::set_allocated_text(std::string* text) { + if (text != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.text_.SetAllocated(text, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.text_.IsDefault()) { + _impl_.text_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.text) +} + +// optional string matchedText = 2; +inline bool Message_ExtendedTextMessage::_internal_has_matchedtext() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_ExtendedTextMessage::has_matchedtext() const { + return _internal_has_matchedtext(); +} +inline void Message_ExtendedTextMessage::clear_matchedtext() { + _impl_.matchedtext_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_ExtendedTextMessage::matchedtext() const { + // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.matchedText) + return _internal_matchedtext(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ExtendedTextMessage::set_matchedtext(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.matchedtext_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.matchedText) +} +inline std::string* Message_ExtendedTextMessage::mutable_matchedtext() { + std::string* _s = _internal_mutable_matchedtext(); + // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.matchedText) + return _s; +} +inline const std::string& Message_ExtendedTextMessage::_internal_matchedtext() const { + return _impl_.matchedtext_.Get(); +} +inline void Message_ExtendedTextMessage::_internal_set_matchedtext(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.matchedtext_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ExtendedTextMessage::_internal_mutable_matchedtext() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.matchedtext_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ExtendedTextMessage::release_matchedtext() { + // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.matchedText) + if (!_internal_has_matchedtext()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.matchedtext_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.matchedtext_.IsDefault()) { + _impl_.matchedtext_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ExtendedTextMessage::set_allocated_matchedtext(std::string* matchedtext) { + if (matchedtext != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.matchedtext_.SetAllocated(matchedtext, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.matchedtext_.IsDefault()) { + _impl_.matchedtext_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.matchedText) +} + +// optional string canonicalUrl = 4; +inline bool Message_ExtendedTextMessage::_internal_has_canonicalurl() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Message_ExtendedTextMessage::has_canonicalurl() const { + return _internal_has_canonicalurl(); +} +inline void Message_ExtendedTextMessage::clear_canonicalurl() { + _impl_.canonicalurl_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& Message_ExtendedTextMessage::canonicalurl() const { + // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.canonicalUrl) + return _internal_canonicalurl(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ExtendedTextMessage::set_canonicalurl(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.canonicalurl_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.canonicalUrl) +} +inline std::string* Message_ExtendedTextMessage::mutable_canonicalurl() { + std::string* _s = _internal_mutable_canonicalurl(); + // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.canonicalUrl) + return _s; +} +inline const std::string& Message_ExtendedTextMessage::_internal_canonicalurl() const { + return _impl_.canonicalurl_.Get(); +} +inline void Message_ExtendedTextMessage::_internal_set_canonicalurl(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.canonicalurl_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ExtendedTextMessage::_internal_mutable_canonicalurl() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.canonicalurl_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ExtendedTextMessage::release_canonicalurl() { + // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.canonicalUrl) + if (!_internal_has_canonicalurl()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.canonicalurl_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.canonicalurl_.IsDefault()) { + _impl_.canonicalurl_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ExtendedTextMessage::set_allocated_canonicalurl(std::string* canonicalurl) { + if (canonicalurl != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.canonicalurl_.SetAllocated(canonicalurl, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.canonicalurl_.IsDefault()) { + _impl_.canonicalurl_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.canonicalUrl) +} + +// optional string description = 5; +inline bool Message_ExtendedTextMessage::_internal_has_description() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool Message_ExtendedTextMessage::has_description() const { + return _internal_has_description(); +} +inline void Message_ExtendedTextMessage::clear_description() { + _impl_.description_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const std::string& Message_ExtendedTextMessage::description() const { + // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.description) + return _internal_description(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ExtendedTextMessage::set_description(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.description_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.description) +} +inline std::string* Message_ExtendedTextMessage::mutable_description() { + std::string* _s = _internal_mutable_description(); + // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.description) + return _s; +} +inline const std::string& Message_ExtendedTextMessage::_internal_description() const { + return _impl_.description_.Get(); +} +inline void Message_ExtendedTextMessage::_internal_set_description(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.description_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ExtendedTextMessage::_internal_mutable_description() { + _impl_._has_bits_[0] |= 0x00000008u; + return _impl_.description_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ExtendedTextMessage::release_description() { + // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.description) + if (!_internal_has_description()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000008u; + auto* p = _impl_.description_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.description_.IsDefault()) { + _impl_.description_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ExtendedTextMessage::set_allocated_description(std::string* description) { + if (description != nullptr) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.description_.SetAllocated(description, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.description_.IsDefault()) { + _impl_.description_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.description) +} + +// optional string title = 6; +inline bool Message_ExtendedTextMessage::_internal_has_title() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool Message_ExtendedTextMessage::has_title() const { + return _internal_has_title(); +} +inline void Message_ExtendedTextMessage::clear_title() { + _impl_.title_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const std::string& Message_ExtendedTextMessage::title() const { + // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.title) + return _internal_title(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ExtendedTextMessage::set_title(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.title_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.title) +} +inline std::string* Message_ExtendedTextMessage::mutable_title() { + std::string* _s = _internal_mutable_title(); + // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.title) + return _s; +} +inline const std::string& Message_ExtendedTextMessage::_internal_title() const { + return _impl_.title_.Get(); +} +inline void Message_ExtendedTextMessage::_internal_set_title(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.title_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ExtendedTextMessage::_internal_mutable_title() { + _impl_._has_bits_[0] |= 0x00000010u; + return _impl_.title_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ExtendedTextMessage::release_title() { + // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.title) + if (!_internal_has_title()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000010u; + auto* p = _impl_.title_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.title_.IsDefault()) { + _impl_.title_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ExtendedTextMessage::set_allocated_title(std::string* title) { + if (title != nullptr) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.title_.SetAllocated(title, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.title_.IsDefault()) { + _impl_.title_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.title) +} + +// optional fixed32 textArgb = 7; +inline bool Message_ExtendedTextMessage::_internal_has_textargb() const { + bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0; + return value; +} +inline bool Message_ExtendedTextMessage::has_textargb() const { + return _internal_has_textargb(); +} +inline void Message_ExtendedTextMessage::clear_textargb() { + _impl_.textargb_ = 0u; + _impl_._has_bits_[0] &= ~0x00002000u; +} +inline uint32_t Message_ExtendedTextMessage::_internal_textargb() const { + return _impl_.textargb_; +} +inline uint32_t Message_ExtendedTextMessage::textargb() const { + // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.textArgb) + return _internal_textargb(); +} +inline void Message_ExtendedTextMessage::_internal_set_textargb(uint32_t value) { + _impl_._has_bits_[0] |= 0x00002000u; + _impl_.textargb_ = value; +} +inline void Message_ExtendedTextMessage::set_textargb(uint32_t value) { + _internal_set_textargb(value); + // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.textArgb) +} + +// optional fixed32 backgroundArgb = 8; +inline bool Message_ExtendedTextMessage::_internal_has_backgroundargb() const { + bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0; + return value; +} +inline bool Message_ExtendedTextMessage::has_backgroundargb() const { + return _internal_has_backgroundargb(); +} +inline void Message_ExtendedTextMessage::clear_backgroundargb() { + _impl_.backgroundargb_ = 0u; + _impl_._has_bits_[0] &= ~0x00004000u; +} +inline uint32_t Message_ExtendedTextMessage::_internal_backgroundargb() const { + return _impl_.backgroundargb_; +} +inline uint32_t Message_ExtendedTextMessage::backgroundargb() const { + // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.backgroundArgb) + return _internal_backgroundargb(); +} +inline void Message_ExtendedTextMessage::_internal_set_backgroundargb(uint32_t value) { + _impl_._has_bits_[0] |= 0x00004000u; + _impl_.backgroundargb_ = value; +} +inline void Message_ExtendedTextMessage::set_backgroundargb(uint32_t value) { + _internal_set_backgroundargb(value); + // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.backgroundArgb) +} + +// optional .proto.Message.ExtendedTextMessage.FontType font = 9; +inline bool Message_ExtendedTextMessage::_internal_has_font() const { + bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0; + return value; +} +inline bool Message_ExtendedTextMessage::has_font() const { + return _internal_has_font(); +} +inline void Message_ExtendedTextMessage::clear_font() { + _impl_.font_ = 0; + _impl_._has_bits_[0] &= ~0x00008000u; +} +inline ::proto::Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::_internal_font() const { + return static_cast< ::proto::Message_ExtendedTextMessage_FontType >(_impl_.font_); +} +inline ::proto::Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::font() const { + // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.font) + return _internal_font(); +} +inline void Message_ExtendedTextMessage::_internal_set_font(::proto::Message_ExtendedTextMessage_FontType value) { + assert(::proto::Message_ExtendedTextMessage_FontType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00008000u; + _impl_.font_ = value; +} +inline void Message_ExtendedTextMessage::set_font(::proto::Message_ExtendedTextMessage_FontType value) { + _internal_set_font(value); + // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.font) +} + +// optional .proto.Message.ExtendedTextMessage.PreviewType previewType = 10; +inline bool Message_ExtendedTextMessage::_internal_has_previewtype() const { + bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0; + return value; +} +inline bool Message_ExtendedTextMessage::has_previewtype() const { + return _internal_has_previewtype(); +} +inline void Message_ExtendedTextMessage::clear_previewtype() { + _impl_.previewtype_ = 0; + _impl_._has_bits_[0] &= ~0x00010000u; +} +inline ::proto::Message_ExtendedTextMessage_PreviewType Message_ExtendedTextMessage::_internal_previewtype() const { + return static_cast< ::proto::Message_ExtendedTextMessage_PreviewType >(_impl_.previewtype_); +} +inline ::proto::Message_ExtendedTextMessage_PreviewType Message_ExtendedTextMessage::previewtype() const { + // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.previewType) + return _internal_previewtype(); +} +inline void Message_ExtendedTextMessage::_internal_set_previewtype(::proto::Message_ExtendedTextMessage_PreviewType value) { + assert(::proto::Message_ExtendedTextMessage_PreviewType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00010000u; + _impl_.previewtype_ = value; +} +inline void Message_ExtendedTextMessage::set_previewtype(::proto::Message_ExtendedTextMessage_PreviewType value) { + _internal_set_previewtype(value); + // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.previewType) +} + +// optional bytes jpegThumbnail = 16; +inline bool Message_ExtendedTextMessage::_internal_has_jpegthumbnail() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool Message_ExtendedTextMessage::has_jpegthumbnail() const { + return _internal_has_jpegthumbnail(); +} +inline void Message_ExtendedTextMessage::clear_jpegthumbnail() { + _impl_.jpegthumbnail_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline const std::string& Message_ExtendedTextMessage::jpegthumbnail() const { + // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.jpegThumbnail) + return _internal_jpegthumbnail(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ExtendedTextMessage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.jpegthumbnail_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.jpegThumbnail) +} +inline std::string* Message_ExtendedTextMessage::mutable_jpegthumbnail() { + std::string* _s = _internal_mutable_jpegthumbnail(); + // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.jpegThumbnail) + return _s; +} +inline const std::string& Message_ExtendedTextMessage::_internal_jpegthumbnail() const { + return _impl_.jpegthumbnail_.Get(); +} +inline void Message_ExtendedTextMessage::_internal_set_jpegthumbnail(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ExtendedTextMessage::_internal_mutable_jpegthumbnail() { + _impl_._has_bits_[0] |= 0x00000020u; + return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ExtendedTextMessage::release_jpegthumbnail() { + // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.jpegThumbnail) + if (!_internal_has_jpegthumbnail()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000020u; + auto* p = _impl_.jpegthumbnail_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.jpegthumbnail_.IsDefault()) { + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ExtendedTextMessage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) { + if (jpegthumbnail != nullptr) { + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.jpegthumbnail_.IsDefault()) { + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.jpegThumbnail) +} + +// optional .proto.ContextInfo contextInfo = 17; +inline bool Message_ExtendedTextMessage::_internal_has_contextinfo() const { + bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); + return value; +} +inline bool Message_ExtendedTextMessage::has_contextinfo() const { + return _internal_has_contextinfo(); +} +inline void Message_ExtendedTextMessage::clear_contextinfo() { + if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); + _impl_._has_bits_[0] &= ~0x00001000u; +} +inline const ::proto::ContextInfo& Message_ExtendedTextMessage::_internal_contextinfo() const { + const ::proto::ContextInfo* p = _impl_.contextinfo_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ContextInfo_default_instance_); +} +inline const ::proto::ContextInfo& Message_ExtendedTextMessage::contextinfo() const { + // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.contextInfo) + return _internal_contextinfo(); +} +inline void Message_ExtendedTextMessage::unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); + } + _impl_.contextinfo_ = contextinfo; + if (contextinfo) { + _impl_._has_bits_[0] |= 0x00001000u; + } else { + _impl_._has_bits_[0] &= ~0x00001000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ExtendedTextMessage.contextInfo) +} +inline ::proto::ContextInfo* Message_ExtendedTextMessage::release_contextinfo() { + _impl_._has_bits_[0] &= ~0x00001000u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ContextInfo* Message_ExtendedTextMessage::unsafe_arena_release_contextinfo() { + // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.contextInfo) + _impl_._has_bits_[0] &= ~0x00001000u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; + return temp; +} +inline ::proto::ContextInfo* Message_ExtendedTextMessage::_internal_mutable_contextinfo() { + _impl_._has_bits_[0] |= 0x00001000u; + if (_impl_.contextinfo_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); + _impl_.contextinfo_ = p; + } + return _impl_.contextinfo_; +} +inline ::proto::ContextInfo* Message_ExtendedTextMessage::mutable_contextinfo() { + ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); + // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.contextInfo) + return _msg; +} +inline void Message_ExtendedTextMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.contextinfo_; + } + if (contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); + if (message_arena != submessage_arena) { + contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, contextinfo, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00001000u; + } else { + _impl_._has_bits_[0] &= ~0x00001000u; + } + _impl_.contextinfo_ = contextinfo; + // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.contextInfo) +} + +// optional bool doNotPlayInline = 18; +inline bool Message_ExtendedTextMessage::_internal_has_donotplayinline() const { + bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0; + return value; +} +inline bool Message_ExtendedTextMessage::has_donotplayinline() const { + return _internal_has_donotplayinline(); +} +inline void Message_ExtendedTextMessage::clear_donotplayinline() { + _impl_.donotplayinline_ = false; + _impl_._has_bits_[0] &= ~0x00020000u; +} +inline bool Message_ExtendedTextMessage::_internal_donotplayinline() const { + return _impl_.donotplayinline_; +} +inline bool Message_ExtendedTextMessage::donotplayinline() const { + // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.doNotPlayInline) + return _internal_donotplayinline(); +} +inline void Message_ExtendedTextMessage::_internal_set_donotplayinline(bool value) { + _impl_._has_bits_[0] |= 0x00020000u; + _impl_.donotplayinline_ = value; +} +inline void Message_ExtendedTextMessage::set_donotplayinline(bool value) { + _internal_set_donotplayinline(value); + // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.doNotPlayInline) +} + +// optional string thumbnailDirectPath = 19; +inline bool Message_ExtendedTextMessage::_internal_has_thumbnaildirectpath() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool Message_ExtendedTextMessage::has_thumbnaildirectpath() const { + return _internal_has_thumbnaildirectpath(); +} +inline void Message_ExtendedTextMessage::clear_thumbnaildirectpath() { + _impl_.thumbnaildirectpath_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline const std::string& Message_ExtendedTextMessage::thumbnaildirectpath() const { + // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.thumbnailDirectPath) + return _internal_thumbnaildirectpath(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ExtendedTextMessage::set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.thumbnaildirectpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.thumbnailDirectPath) +} +inline std::string* Message_ExtendedTextMessage::mutable_thumbnaildirectpath() { + std::string* _s = _internal_mutable_thumbnaildirectpath(); + // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.thumbnailDirectPath) + return _s; +} +inline const std::string& Message_ExtendedTextMessage::_internal_thumbnaildirectpath() const { + return _impl_.thumbnaildirectpath_.Get(); +} +inline void Message_ExtendedTextMessage::_internal_set_thumbnaildirectpath(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.thumbnaildirectpath_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ExtendedTextMessage::_internal_mutable_thumbnaildirectpath() { + _impl_._has_bits_[0] |= 0x00000040u; + return _impl_.thumbnaildirectpath_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ExtendedTextMessage::release_thumbnaildirectpath() { + // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.thumbnailDirectPath) + if (!_internal_has_thumbnaildirectpath()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000040u; + auto* p = _impl_.thumbnaildirectpath_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.thumbnaildirectpath_.IsDefault()) { + _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ExtendedTextMessage::set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath) { + if (thumbnaildirectpath != nullptr) { + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + _impl_.thumbnaildirectpath_.SetAllocated(thumbnaildirectpath, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.thumbnaildirectpath_.IsDefault()) { + _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.thumbnailDirectPath) +} + +// optional bytes thumbnailSha256 = 20; +inline bool Message_ExtendedTextMessage::_internal_has_thumbnailsha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool Message_ExtendedTextMessage::has_thumbnailsha256() const { + return _internal_has_thumbnailsha256(); +} +inline void Message_ExtendedTextMessage::clear_thumbnailsha256() { + _impl_.thumbnailsha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline const std::string& Message_ExtendedTextMessage::thumbnailsha256() const { + // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.thumbnailSha256) + return _internal_thumbnailsha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ExtendedTextMessage::set_thumbnailsha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.thumbnailsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.thumbnailSha256) +} +inline std::string* Message_ExtendedTextMessage::mutable_thumbnailsha256() { + std::string* _s = _internal_mutable_thumbnailsha256(); + // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.thumbnailSha256) + return _s; +} +inline const std::string& Message_ExtendedTextMessage::_internal_thumbnailsha256() const { + return _impl_.thumbnailsha256_.Get(); +} +inline void Message_ExtendedTextMessage::_internal_set_thumbnailsha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.thumbnailsha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ExtendedTextMessage::_internal_mutable_thumbnailsha256() { + _impl_._has_bits_[0] |= 0x00000080u; + return _impl_.thumbnailsha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ExtendedTextMessage::release_thumbnailsha256() { + // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.thumbnailSha256) + if (!_internal_has_thumbnailsha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000080u; + auto* p = _impl_.thumbnailsha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.thumbnailsha256_.IsDefault()) { + _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ExtendedTextMessage::set_allocated_thumbnailsha256(std::string* thumbnailsha256) { + if (thumbnailsha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000080u; + } else { + _impl_._has_bits_[0] &= ~0x00000080u; + } + _impl_.thumbnailsha256_.SetAllocated(thumbnailsha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.thumbnailsha256_.IsDefault()) { + _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.thumbnailSha256) +} + +// optional bytes thumbnailEncSha256 = 21; +inline bool Message_ExtendedTextMessage::_internal_has_thumbnailencsha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool Message_ExtendedTextMessage::has_thumbnailencsha256() const { + return _internal_has_thumbnailencsha256(); +} +inline void Message_ExtendedTextMessage::clear_thumbnailencsha256() { + _impl_.thumbnailencsha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000100u; +} +inline const std::string& Message_ExtendedTextMessage::thumbnailencsha256() const { + // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.thumbnailEncSha256) + return _internal_thumbnailencsha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ExtendedTextMessage::set_thumbnailencsha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.thumbnailencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.thumbnailEncSha256) +} +inline std::string* Message_ExtendedTextMessage::mutable_thumbnailencsha256() { + std::string* _s = _internal_mutable_thumbnailencsha256(); + // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.thumbnailEncSha256) + return _s; +} +inline const std::string& Message_ExtendedTextMessage::_internal_thumbnailencsha256() const { + return _impl_.thumbnailencsha256_.Get(); +} +inline void Message_ExtendedTextMessage::_internal_set_thumbnailencsha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.thumbnailencsha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ExtendedTextMessage::_internal_mutable_thumbnailencsha256() { + _impl_._has_bits_[0] |= 0x00000100u; + return _impl_.thumbnailencsha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ExtendedTextMessage::release_thumbnailencsha256() { + // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.thumbnailEncSha256) + if (!_internal_has_thumbnailencsha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000100u; + auto* p = _impl_.thumbnailencsha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.thumbnailencsha256_.IsDefault()) { + _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ExtendedTextMessage::set_allocated_thumbnailencsha256(std::string* thumbnailencsha256) { + if (thumbnailencsha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000100u; + } else { + _impl_._has_bits_[0] &= ~0x00000100u; + } + _impl_.thumbnailencsha256_.SetAllocated(thumbnailencsha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.thumbnailencsha256_.IsDefault()) { + _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.thumbnailEncSha256) +} + +// optional bytes mediaKey = 22; +inline bool Message_ExtendedTextMessage::_internal_has_mediakey() const { + bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool Message_ExtendedTextMessage::has_mediakey() const { + return _internal_has_mediakey(); +} +inline void Message_ExtendedTextMessage::clear_mediakey() { + _impl_.mediakey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000200u; +} +inline const std::string& Message_ExtendedTextMessage::mediakey() const { + // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.mediaKey) + return _internal_mediakey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ExtendedTextMessage::set_mediakey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.mediakey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.mediaKey) +} +inline std::string* Message_ExtendedTextMessage::mutable_mediakey() { + std::string* _s = _internal_mutable_mediakey(); + // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.mediaKey) + return _s; +} +inline const std::string& Message_ExtendedTextMessage::_internal_mediakey() const { + return _impl_.mediakey_.Get(); +} +inline void Message_ExtendedTextMessage::_internal_set_mediakey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.mediakey_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ExtendedTextMessage::_internal_mutable_mediakey() { + _impl_._has_bits_[0] |= 0x00000200u; + return _impl_.mediakey_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ExtendedTextMessage::release_mediakey() { + // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.mediaKey) + if (!_internal_has_mediakey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000200u; + auto* p = _impl_.mediakey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mediakey_.IsDefault()) { + _impl_.mediakey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ExtendedTextMessage::set_allocated_mediakey(std::string* mediakey) { + if (mediakey != nullptr) { + _impl_._has_bits_[0] |= 0x00000200u; + } else { + _impl_._has_bits_[0] &= ~0x00000200u; + } + _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mediakey_.IsDefault()) { + _impl_.mediakey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.mediaKey) +} + +// optional int64 mediaKeyTimestamp = 23; +inline bool Message_ExtendedTextMessage::_internal_has_mediakeytimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0; + return value; +} +inline bool Message_ExtendedTextMessage::has_mediakeytimestamp() const { + return _internal_has_mediakeytimestamp(); +} +inline void Message_ExtendedTextMessage::clear_mediakeytimestamp() { + _impl_.mediakeytimestamp_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00080000u; +} +inline int64_t Message_ExtendedTextMessage::_internal_mediakeytimestamp() const { + return _impl_.mediakeytimestamp_; +} +inline int64_t Message_ExtendedTextMessage::mediakeytimestamp() const { + // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.mediaKeyTimestamp) + return _internal_mediakeytimestamp(); +} +inline void Message_ExtendedTextMessage::_internal_set_mediakeytimestamp(int64_t value) { + _impl_._has_bits_[0] |= 0x00080000u; + _impl_.mediakeytimestamp_ = value; +} +inline void Message_ExtendedTextMessage::set_mediakeytimestamp(int64_t value) { + _internal_set_mediakeytimestamp(value); + // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.mediaKeyTimestamp) +} + +// optional uint32 thumbnailHeight = 24; +inline bool Message_ExtendedTextMessage::_internal_has_thumbnailheight() const { + bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0; + return value; +} +inline bool Message_ExtendedTextMessage::has_thumbnailheight() const { + return _internal_has_thumbnailheight(); +} +inline void Message_ExtendedTextMessage::clear_thumbnailheight() { + _impl_.thumbnailheight_ = 0u; + _impl_._has_bits_[0] &= ~0x00040000u; +} +inline uint32_t Message_ExtendedTextMessage::_internal_thumbnailheight() const { + return _impl_.thumbnailheight_; +} +inline uint32_t Message_ExtendedTextMessage::thumbnailheight() const { + // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.thumbnailHeight) + return _internal_thumbnailheight(); +} +inline void Message_ExtendedTextMessage::_internal_set_thumbnailheight(uint32_t value) { + _impl_._has_bits_[0] |= 0x00040000u; + _impl_.thumbnailheight_ = value; +} +inline void Message_ExtendedTextMessage::set_thumbnailheight(uint32_t value) { + _internal_set_thumbnailheight(value); + // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.thumbnailHeight) +} + +// optional uint32 thumbnailWidth = 25; +inline bool Message_ExtendedTextMessage::_internal_has_thumbnailwidth() const { + bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0; + return value; +} +inline bool Message_ExtendedTextMessage::has_thumbnailwidth() const { + return _internal_has_thumbnailwidth(); +} +inline void Message_ExtendedTextMessage::clear_thumbnailwidth() { + _impl_.thumbnailwidth_ = 0u; + _impl_._has_bits_[0] &= ~0x00100000u; +} +inline uint32_t Message_ExtendedTextMessage::_internal_thumbnailwidth() const { + return _impl_.thumbnailwidth_; +} +inline uint32_t Message_ExtendedTextMessage::thumbnailwidth() const { + // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.thumbnailWidth) + return _internal_thumbnailwidth(); +} +inline void Message_ExtendedTextMessage::_internal_set_thumbnailwidth(uint32_t value) { + _impl_._has_bits_[0] |= 0x00100000u; + _impl_.thumbnailwidth_ = value; +} +inline void Message_ExtendedTextMessage::set_thumbnailwidth(uint32_t value) { + _internal_set_thumbnailwidth(value); + // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.thumbnailWidth) +} + +// optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupType = 26; +inline bool Message_ExtendedTextMessage::_internal_has_invitelinkgrouptype() const { + bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0; + return value; +} +inline bool Message_ExtendedTextMessage::has_invitelinkgrouptype() const { + return _internal_has_invitelinkgrouptype(); +} +inline void Message_ExtendedTextMessage::clear_invitelinkgrouptype() { + _impl_.invitelinkgrouptype_ = 0; + _impl_._has_bits_[0] &= ~0x00200000u; +} +inline ::proto::Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::_internal_invitelinkgrouptype() const { + return static_cast< ::proto::Message_ExtendedTextMessage_InviteLinkGroupType >(_impl_.invitelinkgrouptype_); +} +inline ::proto::Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::invitelinkgrouptype() const { + // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.inviteLinkGroupType) + return _internal_invitelinkgrouptype(); +} +inline void Message_ExtendedTextMessage::_internal_set_invitelinkgrouptype(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value) { + assert(::proto::Message_ExtendedTextMessage_InviteLinkGroupType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00200000u; + _impl_.invitelinkgrouptype_ = value; +} +inline void Message_ExtendedTextMessage::set_invitelinkgrouptype(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value) { + _internal_set_invitelinkgrouptype(value); + // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.inviteLinkGroupType) +} + +// optional string inviteLinkParentGroupSubjectV2 = 27; +inline bool Message_ExtendedTextMessage::_internal_has_invitelinkparentgroupsubjectv2() const { + bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool Message_ExtendedTextMessage::has_invitelinkparentgroupsubjectv2() const { + return _internal_has_invitelinkparentgroupsubjectv2(); +} +inline void Message_ExtendedTextMessage::clear_invitelinkparentgroupsubjectv2() { + _impl_.invitelinkparentgroupsubjectv2_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000400u; +} +inline const std::string& Message_ExtendedTextMessage::invitelinkparentgroupsubjectv2() const { + // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.inviteLinkParentGroupSubjectV2) + return _internal_invitelinkparentgroupsubjectv2(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ExtendedTextMessage::set_invitelinkparentgroupsubjectv2(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000400u; + _impl_.invitelinkparentgroupsubjectv2_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.inviteLinkParentGroupSubjectV2) +} +inline std::string* Message_ExtendedTextMessage::mutable_invitelinkparentgroupsubjectv2() { + std::string* _s = _internal_mutable_invitelinkparentgroupsubjectv2(); + // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.inviteLinkParentGroupSubjectV2) + return _s; +} +inline const std::string& Message_ExtendedTextMessage::_internal_invitelinkparentgroupsubjectv2() const { + return _impl_.invitelinkparentgroupsubjectv2_.Get(); +} +inline void Message_ExtendedTextMessage::_internal_set_invitelinkparentgroupsubjectv2(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000400u; + _impl_.invitelinkparentgroupsubjectv2_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ExtendedTextMessage::_internal_mutable_invitelinkparentgroupsubjectv2() { + _impl_._has_bits_[0] |= 0x00000400u; + return _impl_.invitelinkparentgroupsubjectv2_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ExtendedTextMessage::release_invitelinkparentgroupsubjectv2() { + // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.inviteLinkParentGroupSubjectV2) + if (!_internal_has_invitelinkparentgroupsubjectv2()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000400u; + auto* p = _impl_.invitelinkparentgroupsubjectv2_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.invitelinkparentgroupsubjectv2_.IsDefault()) { + _impl_.invitelinkparentgroupsubjectv2_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ExtendedTextMessage::set_allocated_invitelinkparentgroupsubjectv2(std::string* invitelinkparentgroupsubjectv2) { + if (invitelinkparentgroupsubjectv2 != nullptr) { + _impl_._has_bits_[0] |= 0x00000400u; + } else { + _impl_._has_bits_[0] &= ~0x00000400u; + } + _impl_.invitelinkparentgroupsubjectv2_.SetAllocated(invitelinkparentgroupsubjectv2, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.invitelinkparentgroupsubjectv2_.IsDefault()) { + _impl_.invitelinkparentgroupsubjectv2_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.inviteLinkParentGroupSubjectV2) +} + +// optional bytes inviteLinkParentGroupThumbnailV2 = 28; +inline bool Message_ExtendedTextMessage::_internal_has_invitelinkparentgroupthumbnailv2() const { + bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; + return value; +} +inline bool Message_ExtendedTextMessage::has_invitelinkparentgroupthumbnailv2() const { + return _internal_has_invitelinkparentgroupthumbnailv2(); +} +inline void Message_ExtendedTextMessage::clear_invitelinkparentgroupthumbnailv2() { + _impl_.invitelinkparentgroupthumbnailv2_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000800u; +} +inline const std::string& Message_ExtendedTextMessage::invitelinkparentgroupthumbnailv2() const { + // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.inviteLinkParentGroupThumbnailV2) + return _internal_invitelinkparentgroupthumbnailv2(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ExtendedTextMessage::set_invitelinkparentgroupthumbnailv2(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000800u; + _impl_.invitelinkparentgroupthumbnailv2_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.inviteLinkParentGroupThumbnailV2) +} +inline std::string* Message_ExtendedTextMessage::mutable_invitelinkparentgroupthumbnailv2() { + std::string* _s = _internal_mutable_invitelinkparentgroupthumbnailv2(); + // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.inviteLinkParentGroupThumbnailV2) + return _s; +} +inline const std::string& Message_ExtendedTextMessage::_internal_invitelinkparentgroupthumbnailv2() const { + return _impl_.invitelinkparentgroupthumbnailv2_.Get(); +} +inline void Message_ExtendedTextMessage::_internal_set_invitelinkparentgroupthumbnailv2(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000800u; + _impl_.invitelinkparentgroupthumbnailv2_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ExtendedTextMessage::_internal_mutable_invitelinkparentgroupthumbnailv2() { + _impl_._has_bits_[0] |= 0x00000800u; + return _impl_.invitelinkparentgroupthumbnailv2_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ExtendedTextMessage::release_invitelinkparentgroupthumbnailv2() { + // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.inviteLinkParentGroupThumbnailV2) + if (!_internal_has_invitelinkparentgroupthumbnailv2()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000800u; + auto* p = _impl_.invitelinkparentgroupthumbnailv2_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.invitelinkparentgroupthumbnailv2_.IsDefault()) { + _impl_.invitelinkparentgroupthumbnailv2_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ExtendedTextMessage::set_allocated_invitelinkparentgroupthumbnailv2(std::string* invitelinkparentgroupthumbnailv2) { + if (invitelinkparentgroupthumbnailv2 != nullptr) { + _impl_._has_bits_[0] |= 0x00000800u; + } else { + _impl_._has_bits_[0] &= ~0x00000800u; + } + _impl_.invitelinkparentgroupthumbnailv2_.SetAllocated(invitelinkparentgroupthumbnailv2, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.invitelinkparentgroupthumbnailv2_.IsDefault()) { + _impl_.invitelinkparentgroupthumbnailv2_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.inviteLinkParentGroupThumbnailV2) +} + +// optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupTypeV2 = 29; +inline bool Message_ExtendedTextMessage::_internal_has_invitelinkgrouptypev2() const { + bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0; + return value; +} +inline bool Message_ExtendedTextMessage::has_invitelinkgrouptypev2() const { + return _internal_has_invitelinkgrouptypev2(); +} +inline void Message_ExtendedTextMessage::clear_invitelinkgrouptypev2() { + _impl_.invitelinkgrouptypev2_ = 0; + _impl_._has_bits_[0] &= ~0x00400000u; +} +inline ::proto::Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::_internal_invitelinkgrouptypev2() const { + return static_cast< ::proto::Message_ExtendedTextMessage_InviteLinkGroupType >(_impl_.invitelinkgrouptypev2_); +} +inline ::proto::Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::invitelinkgrouptypev2() const { + // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.inviteLinkGroupTypeV2) + return _internal_invitelinkgrouptypev2(); +} +inline void Message_ExtendedTextMessage::_internal_set_invitelinkgrouptypev2(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value) { + assert(::proto::Message_ExtendedTextMessage_InviteLinkGroupType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00400000u; + _impl_.invitelinkgrouptypev2_ = value; +} +inline void Message_ExtendedTextMessage::set_invitelinkgrouptypev2(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value) { + _internal_set_invitelinkgrouptypev2(value); + // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.inviteLinkGroupTypeV2) +} + +// ------------------------------------------------------------------- + +// Message_FutureProofMessage + +// optional .proto.Message message = 1; +inline bool Message_FutureProofMessage::_internal_has_message() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.message_ != nullptr); + return value; +} +inline bool Message_FutureProofMessage::has_message() const { + return _internal_has_message(); +} +inline void Message_FutureProofMessage::clear_message() { + if (_impl_.message_ != nullptr) _impl_.message_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::Message& Message_FutureProofMessage::_internal_message() const { + const ::proto::Message* p = _impl_.message_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_default_instance_); +} +inline const ::proto::Message& Message_FutureProofMessage::message() const { + // @@protoc_insertion_point(field_get:proto.Message.FutureProofMessage.message) + return _internal_message(); +} +inline void Message_FutureProofMessage::unsafe_arena_set_allocated_message( + ::proto::Message* message) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.message_); + } + _impl_.message_ = message; + if (message) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.FutureProofMessage.message) +} +inline ::proto::Message* Message_FutureProofMessage::release_message() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::Message* temp = _impl_.message_; + _impl_.message_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message* Message_FutureProofMessage::unsafe_arena_release_message() { + // @@protoc_insertion_point(field_release:proto.Message.FutureProofMessage.message) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::Message* temp = _impl_.message_; + _impl_.message_ = nullptr; + return temp; +} +inline ::proto::Message* Message_FutureProofMessage::_internal_mutable_message() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.message_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message>(GetArenaForAllocation()); + _impl_.message_ = p; + } + return _impl_.message_; +} +inline ::proto::Message* Message_FutureProofMessage::mutable_message() { + ::proto::Message* _msg = _internal_mutable_message(); + // @@protoc_insertion_point(field_mutable:proto.Message.FutureProofMessage.message) + return _msg; +} +inline void Message_FutureProofMessage::set_allocated_message(::proto::Message* message) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.message_; + } + if (message) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(message); + if (message_arena != submessage_arena) { + message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, message, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.message_ = message; + // @@protoc_insertion_point(field_set_allocated:proto.Message.FutureProofMessage.message) +} + +// ------------------------------------------------------------------- + +// Message_GroupInviteMessage + +// optional string groupJid = 1; +inline bool Message_GroupInviteMessage::_internal_has_groupjid() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_GroupInviteMessage::has_groupjid() const { + return _internal_has_groupjid(); +} +inline void Message_GroupInviteMessage::clear_groupjid() { + _impl_.groupjid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_GroupInviteMessage::groupjid() const { + // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.groupJid) + return _internal_groupjid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_GroupInviteMessage::set_groupjid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.groupjid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.GroupInviteMessage.groupJid) +} +inline std::string* Message_GroupInviteMessage::mutable_groupjid() { + std::string* _s = _internal_mutable_groupjid(); + // @@protoc_insertion_point(field_mutable:proto.Message.GroupInviteMessage.groupJid) + return _s; +} +inline const std::string& Message_GroupInviteMessage::_internal_groupjid() const { + return _impl_.groupjid_.Get(); +} +inline void Message_GroupInviteMessage::_internal_set_groupjid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.groupjid_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_GroupInviteMessage::_internal_mutable_groupjid() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.groupjid_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_GroupInviteMessage::release_groupjid() { + // @@protoc_insertion_point(field_release:proto.Message.GroupInviteMessage.groupJid) + if (!_internal_has_groupjid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.groupjid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.groupjid_.IsDefault()) { + _impl_.groupjid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_GroupInviteMessage::set_allocated_groupjid(std::string* groupjid) { + if (groupjid != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.groupjid_.SetAllocated(groupjid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.groupjid_.IsDefault()) { + _impl_.groupjid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.GroupInviteMessage.groupJid) +} + +// optional string inviteCode = 2; +inline bool Message_GroupInviteMessage::_internal_has_invitecode() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_GroupInviteMessage::has_invitecode() const { + return _internal_has_invitecode(); +} +inline void Message_GroupInviteMessage::clear_invitecode() { + _impl_.invitecode_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_GroupInviteMessage::invitecode() const { + // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.inviteCode) + return _internal_invitecode(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_GroupInviteMessage::set_invitecode(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.invitecode_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.GroupInviteMessage.inviteCode) +} +inline std::string* Message_GroupInviteMessage::mutable_invitecode() { + std::string* _s = _internal_mutable_invitecode(); + // @@protoc_insertion_point(field_mutable:proto.Message.GroupInviteMessage.inviteCode) + return _s; +} +inline const std::string& Message_GroupInviteMessage::_internal_invitecode() const { + return _impl_.invitecode_.Get(); +} +inline void Message_GroupInviteMessage::_internal_set_invitecode(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.invitecode_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_GroupInviteMessage::_internal_mutable_invitecode() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.invitecode_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_GroupInviteMessage::release_invitecode() { + // @@protoc_insertion_point(field_release:proto.Message.GroupInviteMessage.inviteCode) + if (!_internal_has_invitecode()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.invitecode_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.invitecode_.IsDefault()) { + _impl_.invitecode_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_GroupInviteMessage::set_allocated_invitecode(std::string* invitecode) { + if (invitecode != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.invitecode_.SetAllocated(invitecode, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.invitecode_.IsDefault()) { + _impl_.invitecode_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.GroupInviteMessage.inviteCode) +} + +// optional int64 inviteExpiration = 3; +inline bool Message_GroupInviteMessage::_internal_has_inviteexpiration() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool Message_GroupInviteMessage::has_inviteexpiration() const { + return _internal_has_inviteexpiration(); +} +inline void Message_GroupInviteMessage::clear_inviteexpiration() { + _impl_.inviteexpiration_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline int64_t Message_GroupInviteMessage::_internal_inviteexpiration() const { + return _impl_.inviteexpiration_; +} +inline int64_t Message_GroupInviteMessage::inviteexpiration() const { + // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.inviteExpiration) + return _internal_inviteexpiration(); +} +inline void Message_GroupInviteMessage::_internal_set_inviteexpiration(int64_t value) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.inviteexpiration_ = value; +} +inline void Message_GroupInviteMessage::set_inviteexpiration(int64_t value) { + _internal_set_inviteexpiration(value); + // @@protoc_insertion_point(field_set:proto.Message.GroupInviteMessage.inviteExpiration) +} + +// optional string groupName = 4; +inline bool Message_GroupInviteMessage::_internal_has_groupname() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Message_GroupInviteMessage::has_groupname() const { + return _internal_has_groupname(); +} +inline void Message_GroupInviteMessage::clear_groupname() { + _impl_.groupname_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& Message_GroupInviteMessage::groupname() const { + // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.groupName) + return _internal_groupname(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_GroupInviteMessage::set_groupname(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.groupname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.GroupInviteMessage.groupName) +} +inline std::string* Message_GroupInviteMessage::mutable_groupname() { + std::string* _s = _internal_mutable_groupname(); + // @@protoc_insertion_point(field_mutable:proto.Message.GroupInviteMessage.groupName) + return _s; +} +inline const std::string& Message_GroupInviteMessage::_internal_groupname() const { + return _impl_.groupname_.Get(); +} +inline void Message_GroupInviteMessage::_internal_set_groupname(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.groupname_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_GroupInviteMessage::_internal_mutable_groupname() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.groupname_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_GroupInviteMessage::release_groupname() { + // @@protoc_insertion_point(field_release:proto.Message.GroupInviteMessage.groupName) + if (!_internal_has_groupname()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.groupname_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.groupname_.IsDefault()) { + _impl_.groupname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_GroupInviteMessage::set_allocated_groupname(std::string* groupname) { + if (groupname != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.groupname_.SetAllocated(groupname, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.groupname_.IsDefault()) { + _impl_.groupname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.GroupInviteMessage.groupName) +} + +// optional bytes jpegThumbnail = 5; +inline bool Message_GroupInviteMessage::_internal_has_jpegthumbnail() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool Message_GroupInviteMessage::has_jpegthumbnail() const { + return _internal_has_jpegthumbnail(); +} +inline void Message_GroupInviteMessage::clear_jpegthumbnail() { + _impl_.jpegthumbnail_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const std::string& Message_GroupInviteMessage::jpegthumbnail() const { + // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.jpegThumbnail) + return _internal_jpegthumbnail(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_GroupInviteMessage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.jpegthumbnail_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.GroupInviteMessage.jpegThumbnail) +} +inline std::string* Message_GroupInviteMessage::mutable_jpegthumbnail() { + std::string* _s = _internal_mutable_jpegthumbnail(); + // @@protoc_insertion_point(field_mutable:proto.Message.GroupInviteMessage.jpegThumbnail) + return _s; +} +inline const std::string& Message_GroupInviteMessage::_internal_jpegthumbnail() const { + return _impl_.jpegthumbnail_.Get(); +} +inline void Message_GroupInviteMessage::_internal_set_jpegthumbnail(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_GroupInviteMessage::_internal_mutable_jpegthumbnail() { + _impl_._has_bits_[0] |= 0x00000008u; + return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_GroupInviteMessage::release_jpegthumbnail() { + // @@protoc_insertion_point(field_release:proto.Message.GroupInviteMessage.jpegThumbnail) + if (!_internal_has_jpegthumbnail()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000008u; + auto* p = _impl_.jpegthumbnail_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.jpegthumbnail_.IsDefault()) { + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_GroupInviteMessage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) { + if (jpegthumbnail != nullptr) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.jpegthumbnail_.IsDefault()) { + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.GroupInviteMessage.jpegThumbnail) +} + +// optional string caption = 6; +inline bool Message_GroupInviteMessage::_internal_has_caption() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool Message_GroupInviteMessage::has_caption() const { + return _internal_has_caption(); +} +inline void Message_GroupInviteMessage::clear_caption() { + _impl_.caption_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const std::string& Message_GroupInviteMessage::caption() const { + // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.caption) + return _internal_caption(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_GroupInviteMessage::set_caption(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.caption_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.GroupInviteMessage.caption) +} +inline std::string* Message_GroupInviteMessage::mutable_caption() { + std::string* _s = _internal_mutable_caption(); + // @@protoc_insertion_point(field_mutable:proto.Message.GroupInviteMessage.caption) + return _s; +} +inline const std::string& Message_GroupInviteMessage::_internal_caption() const { + return _impl_.caption_.Get(); +} +inline void Message_GroupInviteMessage::_internal_set_caption(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.caption_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_GroupInviteMessage::_internal_mutable_caption() { + _impl_._has_bits_[0] |= 0x00000010u; + return _impl_.caption_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_GroupInviteMessage::release_caption() { + // @@protoc_insertion_point(field_release:proto.Message.GroupInviteMessage.caption) + if (!_internal_has_caption()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000010u; + auto* p = _impl_.caption_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.caption_.IsDefault()) { + _impl_.caption_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_GroupInviteMessage::set_allocated_caption(std::string* caption) { + if (caption != nullptr) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.caption_.SetAllocated(caption, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.caption_.IsDefault()) { + _impl_.caption_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.GroupInviteMessage.caption) +} + +// optional .proto.ContextInfo contextInfo = 7; +inline bool Message_GroupInviteMessage::_internal_has_contextinfo() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); + return value; +} +inline bool Message_GroupInviteMessage::has_contextinfo() const { + return _internal_has_contextinfo(); +} +inline void Message_GroupInviteMessage::clear_contextinfo() { + if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline const ::proto::ContextInfo& Message_GroupInviteMessage::_internal_contextinfo() const { + const ::proto::ContextInfo* p = _impl_.contextinfo_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ContextInfo_default_instance_); +} +inline const ::proto::ContextInfo& Message_GroupInviteMessage::contextinfo() const { + // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.contextInfo) + return _internal_contextinfo(); +} +inline void Message_GroupInviteMessage::unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); + } + _impl_.contextinfo_ = contextinfo; + if (contextinfo) { + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.GroupInviteMessage.contextInfo) +} +inline ::proto::ContextInfo* Message_GroupInviteMessage::release_contextinfo() { + _impl_._has_bits_[0] &= ~0x00000020u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ContextInfo* Message_GroupInviteMessage::unsafe_arena_release_contextinfo() { + // @@protoc_insertion_point(field_release:proto.Message.GroupInviteMessage.contextInfo) + _impl_._has_bits_[0] &= ~0x00000020u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; + return temp; +} +inline ::proto::ContextInfo* Message_GroupInviteMessage::_internal_mutable_contextinfo() { + _impl_._has_bits_[0] |= 0x00000020u; + if (_impl_.contextinfo_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); + _impl_.contextinfo_ = p; + } + return _impl_.contextinfo_; +} +inline ::proto::ContextInfo* Message_GroupInviteMessage::mutable_contextinfo() { + ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); + // @@protoc_insertion_point(field_mutable:proto.Message.GroupInviteMessage.contextInfo) + return _msg; +} +inline void Message_GroupInviteMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.contextinfo_; + } + if (contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); + if (message_arena != submessage_arena) { + contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, contextinfo, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + _impl_.contextinfo_ = contextinfo; + // @@protoc_insertion_point(field_set_allocated:proto.Message.GroupInviteMessage.contextInfo) +} + +// optional .proto.Message.GroupInviteMessage.GroupType groupType = 8; +inline bool Message_GroupInviteMessage::_internal_has_grouptype() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool Message_GroupInviteMessage::has_grouptype() const { + return _internal_has_grouptype(); +} +inline void Message_GroupInviteMessage::clear_grouptype() { + _impl_.grouptype_ = 0; + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline ::proto::Message_GroupInviteMessage_GroupType Message_GroupInviteMessage::_internal_grouptype() const { + return static_cast< ::proto::Message_GroupInviteMessage_GroupType >(_impl_.grouptype_); +} +inline ::proto::Message_GroupInviteMessage_GroupType Message_GroupInviteMessage::grouptype() const { + // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.groupType) + return _internal_grouptype(); +} +inline void Message_GroupInviteMessage::_internal_set_grouptype(::proto::Message_GroupInviteMessage_GroupType value) { + assert(::proto::Message_GroupInviteMessage_GroupType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.grouptype_ = value; +} +inline void Message_GroupInviteMessage::set_grouptype(::proto::Message_GroupInviteMessage_GroupType value) { + _internal_set_grouptype(value); + // @@protoc_insertion_point(field_set:proto.Message.GroupInviteMessage.groupType) +} + +// ------------------------------------------------------------------- + +// Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency + +// optional string currencyCode = 1; +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_internal_has_currencycode() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::has_currencycode() const { + return _internal_has_currencycode(); +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::clear_currencycode() { + _impl_.currencycode_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::currencycode() const { + // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.currencyCode) + return _internal_currencycode(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::set_currencycode(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.currencycode_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.currencyCode) +} +inline std::string* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::mutable_currencycode() { + std::string* _s = _internal_mutable_currencycode(); + // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.currencyCode) + return _s; +} +inline const std::string& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_internal_currencycode() const { + return _impl_.currencycode_.Get(); +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_internal_set_currencycode(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.currencycode_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_internal_mutable_currencycode() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.currencycode_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::release_currencycode() { + // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.currencyCode) + if (!_internal_has_currencycode()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.currencycode_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.currencycode_.IsDefault()) { + _impl_.currencycode_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::set_allocated_currencycode(std::string* currencycode) { + if (currencycode != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.currencycode_.SetAllocated(currencycode, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.currencycode_.IsDefault()) { + _impl_.currencycode_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.currencyCode) +} + +// optional int64 amount1000 = 2; +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_internal_has_amount1000() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::has_amount1000() const { + return _internal_has_amount1000(); +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::clear_amount1000() { + _impl_.amount1000_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline int64_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_internal_amount1000() const { + return _impl_.amount1000_; +} +inline int64_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::amount1000() const { + // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.amount1000) + return _internal_amount1000(); +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_internal_set_amount1000(int64_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.amount1000_ = value; +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::set_amount1000(int64_t value) { + _internal_set_amount1000(value); + // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.amount1000) +} + +// ------------------------------------------------------------------- + +// Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent + +// optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.DayOfWeekType dayOfWeek = 1; +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_has_dayofweek() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::has_dayofweek() const { + return _internal_has_dayofweek(); +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::clear_dayofweek() { + _impl_.dayofweek_ = 1; + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_dayofweek() const { + return static_cast< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType >(_impl_.dayofweek_); +} +inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::dayofweek() const { + // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.dayOfWeek) + return _internal_dayofweek(); +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_set_dayofweek(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType value) { + assert(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.dayofweek_ = value; +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::set_dayofweek(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType value) { + _internal_set_dayofweek(value); + // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.dayOfWeek) +} + +// optional uint32 year = 2; +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_has_year() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::has_year() const { + return _internal_has_year(); +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::clear_year() { + _impl_.year_ = 0u; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_year() const { + return _impl_.year_; +} +inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::year() const { + // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.year) + return _internal_year(); +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_set_year(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.year_ = value; +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::set_year(uint32_t value) { + _internal_set_year(value); + // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.year) +} + +// optional uint32 month = 3; +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_has_month() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::has_month() const { + return _internal_has_month(); +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::clear_month() { + _impl_.month_ = 0u; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_month() const { + return _impl_.month_; +} +inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::month() const { + // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.month) + return _internal_month(); +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_set_month(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.month_ = value; +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::set_month(uint32_t value) { + _internal_set_month(value); + // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.month) +} + +// optional uint32 dayOfMonth = 4; +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_has_dayofmonth() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::has_dayofmonth() const { + return _internal_has_dayofmonth(); +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::clear_dayofmonth() { + _impl_.dayofmonth_ = 0u; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_dayofmonth() const { + return _impl_.dayofmonth_; +} +inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::dayofmonth() const { + // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.dayOfMonth) + return _internal_dayofmonth(); +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_set_dayofmonth(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.dayofmonth_ = value; +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::set_dayofmonth(uint32_t value) { + _internal_set_dayofmonth(value); + // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.dayOfMonth) +} + +// optional uint32 hour = 5; +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_has_hour() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::has_hour() const { + return _internal_has_hour(); +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::clear_hour() { + _impl_.hour_ = 0u; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_hour() const { + return _impl_.hour_; +} +inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::hour() const { + // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.hour) + return _internal_hour(); +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_set_hour(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.hour_ = value; +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::set_hour(uint32_t value) { + _internal_set_hour(value); + // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.hour) +} + +// optional uint32 minute = 6; +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_has_minute() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::has_minute() const { + return _internal_has_minute(); +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::clear_minute() { + _impl_.minute_ = 0u; + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_minute() const { + return _impl_.minute_; +} +inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::minute() const { + // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.minute) + return _internal_minute(); +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_set_minute(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.minute_ = value; +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::set_minute(uint32_t value) { + _internal_set_minute(value); + // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.minute) +} + +// optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.CalendarType calendar = 7; +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_has_calendar() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::has_calendar() const { + return _internal_has_calendar(); +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::clear_calendar() { + _impl_.calendar_ = 1; + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_calendar() const { + return static_cast< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType >(_impl_.calendar_); +} +inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::calendar() const { + // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.calendar) + return _internal_calendar(); +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_set_calendar(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType value) { + assert(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.calendar_ = value; +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::set_calendar(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType value) { + _internal_set_calendar(value); + // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.calendar) +} + +// ------------------------------------------------------------------- + +// Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch + +// optional int64 timestamp = 1; +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::_internal_has_timestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::has_timestamp() const { + return _internal_has_timestamp(); +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::clear_timestamp() { + _impl_.timestamp_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline int64_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::_internal_timestamp() const { + return _impl_.timestamp_; +} +inline int64_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::timestamp() const { + // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch.timestamp) + return _internal_timestamp(); +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::_internal_set_timestamp(int64_t value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.timestamp_ = value; +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::set_timestamp(int64_t value) { + _internal_set_timestamp(value); + // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch.timestamp) +} + +// ------------------------------------------------------------------- + +// Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime + +// .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent component = 1; +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_internal_has_component() const { + return datetimeOneof_case() == kComponent; +} +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::has_component() const { + return _internal_has_component(); +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::set_has_component() { + _impl_._oneof_case_[0] = kComponent; +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::clear_component() { + if (_internal_has_component()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.datetimeOneof_.component_; + } + clear_has_datetimeOneof(); + } +} +inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::release_component() { + // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.component) + if (_internal_has_component()) { + clear_has_datetimeOneof(); + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* temp = _impl_.datetimeOneof_.component_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.datetimeOneof_.component_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_internal_component() const { + return _internal_has_component() + ? *_impl_.datetimeOneof_.component_ + : reinterpret_cast< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent&>(::proto::_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_default_instance_); +} +inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::component() const { + // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.component) + return _internal_component(); +} +inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::unsafe_arena_release_component() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.component) + if (_internal_has_component()) { + clear_has_datetimeOneof(); + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* temp = _impl_.datetimeOneof_.component_; + _impl_.datetimeOneof_.component_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::unsafe_arena_set_allocated_component(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* component) { + clear_datetimeOneof(); + if (component) { + set_has_component(); + _impl_.datetimeOneof_.component_ = component; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.component) +} +inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_internal_mutable_component() { + if (!_internal_has_component()) { + clear_datetimeOneof(); + set_has_component(); + _impl_.datetimeOneof_.component_ = CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent >(GetArenaForAllocation()); + } + return _impl_.datetimeOneof_.component_; +} +inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::mutable_component() { + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* _msg = _internal_mutable_component(); + // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.component) + return _msg; +} + +// .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch unixEpoch = 2; +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_internal_has_unixepoch() const { + return datetimeOneof_case() == kUnixEpoch; +} +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::has_unixepoch() const { + return _internal_has_unixepoch(); +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::set_has_unixepoch() { + _impl_._oneof_case_[0] = kUnixEpoch; +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::clear_unixepoch() { + if (_internal_has_unixepoch()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.datetimeOneof_.unixepoch_; + } + clear_has_datetimeOneof(); + } +} +inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::release_unixepoch() { + // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.unixEpoch) + if (_internal_has_unixepoch()) { + clear_has_datetimeOneof(); + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* temp = _impl_.datetimeOneof_.unixepoch_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.datetimeOneof_.unixepoch_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_internal_unixepoch() const { + return _internal_has_unixepoch() + ? *_impl_.datetimeOneof_.unixepoch_ + : reinterpret_cast< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch&>(::proto::_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch_default_instance_); +} +inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::unixepoch() const { + // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.unixEpoch) + return _internal_unixepoch(); +} +inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::unsafe_arena_release_unixepoch() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.unixEpoch) + if (_internal_has_unixepoch()) { + clear_has_datetimeOneof(); + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* temp = _impl_.datetimeOneof_.unixepoch_; + _impl_.datetimeOneof_.unixepoch_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::unsafe_arena_set_allocated_unixepoch(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* unixepoch) { + clear_datetimeOneof(); + if (unixepoch) { + set_has_unixepoch(); + _impl_.datetimeOneof_.unixepoch_ = unixepoch; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.unixEpoch) +} +inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_internal_mutable_unixepoch() { + if (!_internal_has_unixepoch()) { + clear_datetimeOneof(); + set_has_unixepoch(); + _impl_.datetimeOneof_.unixepoch_ = CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch >(GetArenaForAllocation()); + } + return _impl_.datetimeOneof_.unixepoch_; +} +inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::mutable_unixepoch() { + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* _msg = _internal_mutable_unixepoch(); + // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.unixEpoch) + return _msg; +} + +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::has_datetimeOneof() const { + return datetimeOneof_case() != DATETIMEONEOF_NOT_SET; +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::clear_has_datetimeOneof() { + _impl_._oneof_case_[0] = DATETIMEONEOF_NOT_SET; +} +inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::DatetimeOneofCase Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::datetimeOneof_case() const { + return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::DatetimeOneofCase(_impl_._oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// Message_HighlyStructuredMessage_HSMLocalizableParameter + +// optional string default = 1; +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_has_default_() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter::has_default_() const { + return _internal_has_default_(); +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::clear_default_() { + _impl_.default__.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_HighlyStructuredMessage_HSMLocalizableParameter::default_() const { + // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.default) + return _internal_default_(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_HighlyStructuredMessage_HSMLocalizableParameter::set_default_(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.default__.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.default) +} +inline std::string* Message_HighlyStructuredMessage_HSMLocalizableParameter::mutable_default_() { + std::string* _s = _internal_mutable_default_(); + // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.default) + return _s; +} +inline const std::string& Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_default_() const { + return _impl_.default__.Get(); +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_set_default_(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.default__.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_mutable_default_() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.default__.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_HighlyStructuredMessage_HSMLocalizableParameter::release_default_() { + // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.default) + if (!_internal_has_default_()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.default__.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.default__.IsDefault()) { + _impl_.default__.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::set_allocated_default_(std::string* default_) { + if (default_ != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.default__.SetAllocated(default_, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.default__.IsDefault()) { + _impl_.default__.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.default) +} + +// .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency currency = 2; +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_has_currency() const { + return paramOneof_case() == kCurrency; +} +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter::has_currency() const { + return _internal_has_currency(); +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::set_has_currency() { + _impl_._oneof_case_[0] = kCurrency; +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::clear_currency() { + if (_internal_has_currency()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.paramOneof_.currency_; + } + clear_has_paramOneof(); + } +} +inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* Message_HighlyStructuredMessage_HSMLocalizableParameter::release_currency() { + // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.currency) + if (_internal_has_currency()) { + clear_has_paramOneof(); + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* temp = _impl_.paramOneof_.currency_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.paramOneof_.currency_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_currency() const { + return _internal_has_currency() + ? *_impl_.paramOneof_.currency_ + : reinterpret_cast< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency&>(::proto::_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency_default_instance_); +} +inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& Message_HighlyStructuredMessage_HSMLocalizableParameter::currency() const { + // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.currency) + return _internal_currency(); +} +inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* Message_HighlyStructuredMessage_HSMLocalizableParameter::unsafe_arena_release_currency() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.currency) + if (_internal_has_currency()) { + clear_has_paramOneof(); + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* temp = _impl_.paramOneof_.currency_; + _impl_.paramOneof_.currency_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::unsafe_arena_set_allocated_currency(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* currency) { + clear_paramOneof(); + if (currency) { + set_has_currency(); + _impl_.paramOneof_.currency_ = currency; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.currency) +} +inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_mutable_currency() { + if (!_internal_has_currency()) { + clear_paramOneof(); + set_has_currency(); + _impl_.paramOneof_.currency_ = CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency >(GetArenaForAllocation()); + } + return _impl_.paramOneof_.currency_; +} +inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* Message_HighlyStructuredMessage_HSMLocalizableParameter::mutable_currency() { + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* _msg = _internal_mutable_currency(); + // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.currency) + return _msg; +} + +// .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime dateTime = 3; +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_has_datetime() const { + return paramOneof_case() == kDateTime; +} +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter::has_datetime() const { + return _internal_has_datetime(); +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::set_has_datetime() { + _impl_._oneof_case_[0] = kDateTime; +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::clear_datetime() { + if (_internal_has_datetime()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.paramOneof_.datetime_; + } + clear_has_paramOneof(); + } +} +inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* Message_HighlyStructuredMessage_HSMLocalizableParameter::release_datetime() { + // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.dateTime) + if (_internal_has_datetime()) { + clear_has_paramOneof(); + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* temp = _impl_.paramOneof_.datetime_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.paramOneof_.datetime_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_datetime() const { + return _internal_has_datetime() + ? *_impl_.paramOneof_.datetime_ + : reinterpret_cast< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime&>(::proto::_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_default_instance_); +} +inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& Message_HighlyStructuredMessage_HSMLocalizableParameter::datetime() const { + // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.dateTime) + return _internal_datetime(); +} +inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* Message_HighlyStructuredMessage_HSMLocalizableParameter::unsafe_arena_release_datetime() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.dateTime) + if (_internal_has_datetime()) { + clear_has_paramOneof(); + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* temp = _impl_.paramOneof_.datetime_; + _impl_.paramOneof_.datetime_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::unsafe_arena_set_allocated_datetime(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* datetime) { + clear_paramOneof(); + if (datetime) { + set_has_datetime(); + _impl_.paramOneof_.datetime_ = datetime; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.dateTime) +} +inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_mutable_datetime() { + if (!_internal_has_datetime()) { + clear_paramOneof(); + set_has_datetime(); + _impl_.paramOneof_.datetime_ = CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime >(GetArenaForAllocation()); + } + return _impl_.paramOneof_.datetime_; +} +inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* Message_HighlyStructuredMessage_HSMLocalizableParameter::mutable_datetime() { + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* _msg = _internal_mutable_datetime(); + // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.dateTime) + return _msg; +} + +inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter::has_paramOneof() const { + return paramOneof_case() != PARAMONEOF_NOT_SET; +} +inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::clear_has_paramOneof() { + _impl_._oneof_case_[0] = PARAMONEOF_NOT_SET; +} +inline Message_HighlyStructuredMessage_HSMLocalizableParameter::ParamOneofCase Message_HighlyStructuredMessage_HSMLocalizableParameter::paramOneof_case() const { + return Message_HighlyStructuredMessage_HSMLocalizableParameter::ParamOneofCase(_impl_._oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// Message_HighlyStructuredMessage + +// optional string namespace = 1; +inline bool Message_HighlyStructuredMessage::_internal_has_namespace_() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_HighlyStructuredMessage::has_namespace_() const { + return _internal_has_namespace_(); +} +inline void Message_HighlyStructuredMessage::clear_namespace_() { + _impl_.namespace__.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_HighlyStructuredMessage::namespace_() const { + // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.namespace) + return _internal_namespace_(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_HighlyStructuredMessage::set_namespace_(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.namespace__.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.namespace) +} +inline std::string* Message_HighlyStructuredMessage::mutable_namespace_() { + std::string* _s = _internal_mutable_namespace_(); + // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.namespace) + return _s; +} +inline const std::string& Message_HighlyStructuredMessage::_internal_namespace_() const { + return _impl_.namespace__.Get(); +} +inline void Message_HighlyStructuredMessage::_internal_set_namespace_(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.namespace__.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_HighlyStructuredMessage::_internal_mutable_namespace_() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.namespace__.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_HighlyStructuredMessage::release_namespace_() { + // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.namespace) + if (!_internal_has_namespace_()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.namespace__.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.namespace__.IsDefault()) { + _impl_.namespace__.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_HighlyStructuredMessage::set_allocated_namespace_(std::string* namespace_) { + if (namespace_ != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.namespace__.SetAllocated(namespace_, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.namespace__.IsDefault()) { + _impl_.namespace__.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.namespace) +} + +// optional string elementName = 2; +inline bool Message_HighlyStructuredMessage::_internal_has_elementname() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_HighlyStructuredMessage::has_elementname() const { + return _internal_has_elementname(); +} +inline void Message_HighlyStructuredMessage::clear_elementname() { + _impl_.elementname_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_HighlyStructuredMessage::elementname() const { + // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.elementName) + return _internal_elementname(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_HighlyStructuredMessage::set_elementname(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.elementname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.elementName) +} +inline std::string* Message_HighlyStructuredMessage::mutable_elementname() { + std::string* _s = _internal_mutable_elementname(); + // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.elementName) + return _s; +} +inline const std::string& Message_HighlyStructuredMessage::_internal_elementname() const { + return _impl_.elementname_.Get(); +} +inline void Message_HighlyStructuredMessage::_internal_set_elementname(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.elementname_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_HighlyStructuredMessage::_internal_mutable_elementname() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.elementname_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_HighlyStructuredMessage::release_elementname() { + // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.elementName) + if (!_internal_has_elementname()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.elementname_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.elementname_.IsDefault()) { + _impl_.elementname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_HighlyStructuredMessage::set_allocated_elementname(std::string* elementname) { + if (elementname != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.elementname_.SetAllocated(elementname, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.elementname_.IsDefault()) { + _impl_.elementname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.elementName) +} + +// repeated string params = 3; +inline int Message_HighlyStructuredMessage::_internal_params_size() const { + return _impl_.params_.size(); +} +inline int Message_HighlyStructuredMessage::params_size() const { + return _internal_params_size(); +} +inline void Message_HighlyStructuredMessage::clear_params() { + _impl_.params_.Clear(); +} +inline std::string* Message_HighlyStructuredMessage::add_params() { + std::string* _s = _internal_add_params(); + // @@protoc_insertion_point(field_add_mutable:proto.Message.HighlyStructuredMessage.params) + return _s; +} +inline const std::string& Message_HighlyStructuredMessage::_internal_params(int index) const { + return _impl_.params_.Get(index); +} +inline const std::string& Message_HighlyStructuredMessage::params(int index) const { + // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.params) + return _internal_params(index); +} +inline std::string* Message_HighlyStructuredMessage::mutable_params(int index) { + // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.params) + return _impl_.params_.Mutable(index); +} +inline void Message_HighlyStructuredMessage::set_params(int index, const std::string& value) { + _impl_.params_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.params) +} +inline void Message_HighlyStructuredMessage::set_params(int index, std::string&& value) { + _impl_.params_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.params) +} +inline void Message_HighlyStructuredMessage::set_params(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + _impl_.params_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:proto.Message.HighlyStructuredMessage.params) +} +inline void Message_HighlyStructuredMessage::set_params(int index, const char* value, size_t size) { + _impl_.params_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:proto.Message.HighlyStructuredMessage.params) +} +inline std::string* Message_HighlyStructuredMessage::_internal_add_params() { + return _impl_.params_.Add(); +} +inline void Message_HighlyStructuredMessage::add_params(const std::string& value) { + _impl_.params_.Add()->assign(value); + // @@protoc_insertion_point(field_add:proto.Message.HighlyStructuredMessage.params) +} +inline void Message_HighlyStructuredMessage::add_params(std::string&& value) { + _impl_.params_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:proto.Message.HighlyStructuredMessage.params) +} +inline void Message_HighlyStructuredMessage::add_params(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _impl_.params_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:proto.Message.HighlyStructuredMessage.params) +} +inline void Message_HighlyStructuredMessage::add_params(const char* value, size_t size) { + _impl_.params_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:proto.Message.HighlyStructuredMessage.params) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +Message_HighlyStructuredMessage::params() const { + // @@protoc_insertion_point(field_list:proto.Message.HighlyStructuredMessage.params) + return _impl_.params_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +Message_HighlyStructuredMessage::mutable_params() { + // @@protoc_insertion_point(field_mutable_list:proto.Message.HighlyStructuredMessage.params) + return &_impl_.params_; +} + +// optional string fallbackLg = 4; +inline bool Message_HighlyStructuredMessage::_internal_has_fallbacklg() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Message_HighlyStructuredMessage::has_fallbacklg() const { + return _internal_has_fallbacklg(); +} +inline void Message_HighlyStructuredMessage::clear_fallbacklg() { + _impl_.fallbacklg_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& Message_HighlyStructuredMessage::fallbacklg() const { + // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.fallbackLg) + return _internal_fallbacklg(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_HighlyStructuredMessage::set_fallbacklg(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.fallbacklg_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.fallbackLg) +} +inline std::string* Message_HighlyStructuredMessage::mutable_fallbacklg() { + std::string* _s = _internal_mutable_fallbacklg(); + // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.fallbackLg) + return _s; +} +inline const std::string& Message_HighlyStructuredMessage::_internal_fallbacklg() const { + return _impl_.fallbacklg_.Get(); +} +inline void Message_HighlyStructuredMessage::_internal_set_fallbacklg(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.fallbacklg_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_HighlyStructuredMessage::_internal_mutable_fallbacklg() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.fallbacklg_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_HighlyStructuredMessage::release_fallbacklg() { + // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.fallbackLg) + if (!_internal_has_fallbacklg()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.fallbacklg_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fallbacklg_.IsDefault()) { + _impl_.fallbacklg_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_HighlyStructuredMessage::set_allocated_fallbacklg(std::string* fallbacklg) { + if (fallbacklg != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.fallbacklg_.SetAllocated(fallbacklg, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fallbacklg_.IsDefault()) { + _impl_.fallbacklg_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.fallbackLg) +} + +// optional string fallbackLc = 5; +inline bool Message_HighlyStructuredMessage::_internal_has_fallbacklc() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool Message_HighlyStructuredMessage::has_fallbacklc() const { + return _internal_has_fallbacklc(); +} +inline void Message_HighlyStructuredMessage::clear_fallbacklc() { + _impl_.fallbacklc_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const std::string& Message_HighlyStructuredMessage::fallbacklc() const { + // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.fallbackLc) + return _internal_fallbacklc(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_HighlyStructuredMessage::set_fallbacklc(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.fallbacklc_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.fallbackLc) +} +inline std::string* Message_HighlyStructuredMessage::mutable_fallbacklc() { + std::string* _s = _internal_mutable_fallbacklc(); + // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.fallbackLc) + return _s; +} +inline const std::string& Message_HighlyStructuredMessage::_internal_fallbacklc() const { + return _impl_.fallbacklc_.Get(); +} +inline void Message_HighlyStructuredMessage::_internal_set_fallbacklc(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.fallbacklc_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_HighlyStructuredMessage::_internal_mutable_fallbacklc() { + _impl_._has_bits_[0] |= 0x00000008u; + return _impl_.fallbacklc_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_HighlyStructuredMessage::release_fallbacklc() { + // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.fallbackLc) + if (!_internal_has_fallbacklc()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000008u; + auto* p = _impl_.fallbacklc_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fallbacklc_.IsDefault()) { + _impl_.fallbacklc_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_HighlyStructuredMessage::set_allocated_fallbacklc(std::string* fallbacklc) { + if (fallbacklc != nullptr) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.fallbacklc_.SetAllocated(fallbacklc, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fallbacklc_.IsDefault()) { + _impl_.fallbacklc_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.fallbackLc) +} + +// repeated .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter localizableParams = 6; +inline int Message_HighlyStructuredMessage::_internal_localizableparams_size() const { + return _impl_.localizableparams_.size(); +} +inline int Message_HighlyStructuredMessage::localizableparams_size() const { + return _internal_localizableparams_size(); +} +inline void Message_HighlyStructuredMessage::clear_localizableparams() { + _impl_.localizableparams_.Clear(); +} +inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* Message_HighlyStructuredMessage::mutable_localizableparams(int index) { + // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.localizableParams) + return _impl_.localizableparams_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter >* +Message_HighlyStructuredMessage::mutable_localizableparams() { + // @@protoc_insertion_point(field_mutable_list:proto.Message.HighlyStructuredMessage.localizableParams) + return &_impl_.localizableparams_; +} +inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter& Message_HighlyStructuredMessage::_internal_localizableparams(int index) const { + return _impl_.localizableparams_.Get(index); +} +inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter& Message_HighlyStructuredMessage::localizableparams(int index) const { + // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.localizableParams) + return _internal_localizableparams(index); +} +inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* Message_HighlyStructuredMessage::_internal_add_localizableparams() { + return _impl_.localizableparams_.Add(); +} +inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* Message_HighlyStructuredMessage::add_localizableparams() { + ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* _add = _internal_add_localizableparams(); + // @@protoc_insertion_point(field_add:proto.Message.HighlyStructuredMessage.localizableParams) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter >& +Message_HighlyStructuredMessage::localizableparams() const { + // @@protoc_insertion_point(field_list:proto.Message.HighlyStructuredMessage.localizableParams) + return _impl_.localizableparams_; +} + +// optional string deterministicLg = 7; +inline bool Message_HighlyStructuredMessage::_internal_has_deterministiclg() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool Message_HighlyStructuredMessage::has_deterministiclg() const { + return _internal_has_deterministiclg(); +} +inline void Message_HighlyStructuredMessage::clear_deterministiclg() { + _impl_.deterministiclg_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const std::string& Message_HighlyStructuredMessage::deterministiclg() const { + // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.deterministicLg) + return _internal_deterministiclg(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_HighlyStructuredMessage::set_deterministiclg(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.deterministiclg_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.deterministicLg) +} +inline std::string* Message_HighlyStructuredMessage::mutable_deterministiclg() { + std::string* _s = _internal_mutable_deterministiclg(); + // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.deterministicLg) + return _s; +} +inline const std::string& Message_HighlyStructuredMessage::_internal_deterministiclg() const { + return _impl_.deterministiclg_.Get(); +} +inline void Message_HighlyStructuredMessage::_internal_set_deterministiclg(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.deterministiclg_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_HighlyStructuredMessage::_internal_mutable_deterministiclg() { + _impl_._has_bits_[0] |= 0x00000010u; + return _impl_.deterministiclg_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_HighlyStructuredMessage::release_deterministiclg() { + // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.deterministicLg) + if (!_internal_has_deterministiclg()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000010u; + auto* p = _impl_.deterministiclg_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.deterministiclg_.IsDefault()) { + _impl_.deterministiclg_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_HighlyStructuredMessage::set_allocated_deterministiclg(std::string* deterministiclg) { + if (deterministiclg != nullptr) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.deterministiclg_.SetAllocated(deterministiclg, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.deterministiclg_.IsDefault()) { + _impl_.deterministiclg_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.deterministicLg) +} + +// optional string deterministicLc = 8; +inline bool Message_HighlyStructuredMessage::_internal_has_deterministiclc() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool Message_HighlyStructuredMessage::has_deterministiclc() const { + return _internal_has_deterministiclc(); +} +inline void Message_HighlyStructuredMessage::clear_deterministiclc() { + _impl_.deterministiclc_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline const std::string& Message_HighlyStructuredMessage::deterministiclc() const { + // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.deterministicLc) + return _internal_deterministiclc(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_HighlyStructuredMessage::set_deterministiclc(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.deterministiclc_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.deterministicLc) +} +inline std::string* Message_HighlyStructuredMessage::mutable_deterministiclc() { + std::string* _s = _internal_mutable_deterministiclc(); + // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.deterministicLc) + return _s; +} +inline const std::string& Message_HighlyStructuredMessage::_internal_deterministiclc() const { + return _impl_.deterministiclc_.Get(); +} +inline void Message_HighlyStructuredMessage::_internal_set_deterministiclc(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.deterministiclc_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_HighlyStructuredMessage::_internal_mutable_deterministiclc() { + _impl_._has_bits_[0] |= 0x00000020u; + return _impl_.deterministiclc_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_HighlyStructuredMessage::release_deterministiclc() { + // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.deterministicLc) + if (!_internal_has_deterministiclc()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000020u; + auto* p = _impl_.deterministiclc_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.deterministiclc_.IsDefault()) { + _impl_.deterministiclc_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_HighlyStructuredMessage::set_allocated_deterministiclc(std::string* deterministiclc) { + if (deterministiclc != nullptr) { + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + _impl_.deterministiclc_.SetAllocated(deterministiclc, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.deterministiclc_.IsDefault()) { + _impl_.deterministiclc_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.deterministicLc) +} + +// optional .proto.Message.TemplateMessage hydratedHsm = 9; +inline bool Message_HighlyStructuredMessage::_internal_has_hydratedhsm() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + PROTOBUF_ASSUME(!value || _impl_.hydratedhsm_ != nullptr); + return value; +} +inline bool Message_HighlyStructuredMessage::has_hydratedhsm() const { + return _internal_has_hydratedhsm(); +} +inline void Message_HighlyStructuredMessage::clear_hydratedhsm() { + if (_impl_.hydratedhsm_ != nullptr) _impl_.hydratedhsm_->Clear(); + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline const ::proto::Message_TemplateMessage& Message_HighlyStructuredMessage::_internal_hydratedhsm() const { + const ::proto::Message_TemplateMessage* p = _impl_.hydratedhsm_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_TemplateMessage_default_instance_); +} +inline const ::proto::Message_TemplateMessage& Message_HighlyStructuredMessage::hydratedhsm() const { + // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.hydratedHsm) + return _internal_hydratedhsm(); +} +inline void Message_HighlyStructuredMessage::unsafe_arena_set_allocated_hydratedhsm( + ::proto::Message_TemplateMessage* hydratedhsm) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.hydratedhsm_); + } + _impl_.hydratedhsm_ = hydratedhsm; + if (hydratedhsm) { + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.HighlyStructuredMessage.hydratedHsm) +} +inline ::proto::Message_TemplateMessage* Message_HighlyStructuredMessage::release_hydratedhsm() { + _impl_._has_bits_[0] &= ~0x00000040u; + ::proto::Message_TemplateMessage* temp = _impl_.hydratedhsm_; + _impl_.hydratedhsm_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_TemplateMessage* Message_HighlyStructuredMessage::unsafe_arena_release_hydratedhsm() { + // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.hydratedHsm) + _impl_._has_bits_[0] &= ~0x00000040u; + ::proto::Message_TemplateMessage* temp = _impl_.hydratedhsm_; + _impl_.hydratedhsm_ = nullptr; + return temp; +} +inline ::proto::Message_TemplateMessage* Message_HighlyStructuredMessage::_internal_mutable_hydratedhsm() { + _impl_._has_bits_[0] |= 0x00000040u; + if (_impl_.hydratedhsm_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_TemplateMessage>(GetArenaForAllocation()); + _impl_.hydratedhsm_ = p; + } + return _impl_.hydratedhsm_; +} +inline ::proto::Message_TemplateMessage* Message_HighlyStructuredMessage::mutable_hydratedhsm() { + ::proto::Message_TemplateMessage* _msg = _internal_mutable_hydratedhsm(); + // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.hydratedHsm) + return _msg; +} +inline void Message_HighlyStructuredMessage::set_allocated_hydratedhsm(::proto::Message_TemplateMessage* hydratedhsm) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.hydratedhsm_; + } + if (hydratedhsm) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(hydratedhsm); + if (message_arena != submessage_arena) { + hydratedhsm = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, hydratedhsm, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + _impl_.hydratedhsm_ = hydratedhsm; + // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.hydratedHsm) +} + +// ------------------------------------------------------------------- + +// Message_HistorySyncNotification + +// optional bytes fileSha256 = 1; +inline bool Message_HistorySyncNotification::_internal_has_filesha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_HistorySyncNotification::has_filesha256() const { + return _internal_has_filesha256(); +} +inline void Message_HistorySyncNotification::clear_filesha256() { + _impl_.filesha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_HistorySyncNotification::filesha256() const { + // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.fileSha256) + return _internal_filesha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_HistorySyncNotification::set_filesha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.filesha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.fileSha256) +} +inline std::string* Message_HistorySyncNotification::mutable_filesha256() { + std::string* _s = _internal_mutable_filesha256(); + // @@protoc_insertion_point(field_mutable:proto.Message.HistorySyncNotification.fileSha256) + return _s; +} +inline const std::string& Message_HistorySyncNotification::_internal_filesha256() const { + return _impl_.filesha256_.Get(); +} +inline void Message_HistorySyncNotification::_internal_set_filesha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.filesha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_HistorySyncNotification::_internal_mutable_filesha256() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.filesha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_HistorySyncNotification::release_filesha256() { + // @@protoc_insertion_point(field_release:proto.Message.HistorySyncNotification.fileSha256) + if (!_internal_has_filesha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.filesha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.filesha256_.IsDefault()) { + _impl_.filesha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_HistorySyncNotification::set_allocated_filesha256(std::string* filesha256) { + if (filesha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.filesha256_.IsDefault()) { + _impl_.filesha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.HistorySyncNotification.fileSha256) +} + +// optional uint64 fileLength = 2; +inline bool Message_HistorySyncNotification::_internal_has_filelength() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool Message_HistorySyncNotification::has_filelength() const { + return _internal_has_filelength(); +} +inline void Message_HistorySyncNotification::clear_filelength() { + _impl_.filelength_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline uint64_t Message_HistorySyncNotification::_internal_filelength() const { + return _impl_.filelength_; +} +inline uint64_t Message_HistorySyncNotification::filelength() const { + // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.fileLength) + return _internal_filelength(); +} +inline void Message_HistorySyncNotification::_internal_set_filelength(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.filelength_ = value; +} +inline void Message_HistorySyncNotification::set_filelength(uint64_t value) { + _internal_set_filelength(value); + // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.fileLength) +} + +// optional bytes mediaKey = 3; +inline bool Message_HistorySyncNotification::_internal_has_mediakey() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_HistorySyncNotification::has_mediakey() const { + return _internal_has_mediakey(); +} +inline void Message_HistorySyncNotification::clear_mediakey() { + _impl_.mediakey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_HistorySyncNotification::mediakey() const { + // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.mediaKey) + return _internal_mediakey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_HistorySyncNotification::set_mediakey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.mediakey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.mediaKey) +} +inline std::string* Message_HistorySyncNotification::mutable_mediakey() { + std::string* _s = _internal_mutable_mediakey(); + // @@protoc_insertion_point(field_mutable:proto.Message.HistorySyncNotification.mediaKey) + return _s; +} +inline const std::string& Message_HistorySyncNotification::_internal_mediakey() const { + return _impl_.mediakey_.Get(); +} +inline void Message_HistorySyncNotification::_internal_set_mediakey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.mediakey_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_HistorySyncNotification::_internal_mutable_mediakey() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.mediakey_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_HistorySyncNotification::release_mediakey() { + // @@protoc_insertion_point(field_release:proto.Message.HistorySyncNotification.mediaKey) + if (!_internal_has_mediakey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.mediakey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mediakey_.IsDefault()) { + _impl_.mediakey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_HistorySyncNotification::set_allocated_mediakey(std::string* mediakey) { + if (mediakey != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mediakey_.IsDefault()) { + _impl_.mediakey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.HistorySyncNotification.mediaKey) +} + +// optional bytes fileEncSha256 = 4; +inline bool Message_HistorySyncNotification::_internal_has_fileencsha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Message_HistorySyncNotification::has_fileencsha256() const { + return _internal_has_fileencsha256(); +} +inline void Message_HistorySyncNotification::clear_fileencsha256() { + _impl_.fileencsha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& Message_HistorySyncNotification::fileencsha256() const { + // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.fileEncSha256) + return _internal_fileencsha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_HistorySyncNotification::set_fileencsha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.fileencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.fileEncSha256) +} +inline std::string* Message_HistorySyncNotification::mutable_fileencsha256() { + std::string* _s = _internal_mutable_fileencsha256(); + // @@protoc_insertion_point(field_mutable:proto.Message.HistorySyncNotification.fileEncSha256) + return _s; +} +inline const std::string& Message_HistorySyncNotification::_internal_fileencsha256() const { + return _impl_.fileencsha256_.Get(); +} +inline void Message_HistorySyncNotification::_internal_set_fileencsha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.fileencsha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_HistorySyncNotification::_internal_mutable_fileencsha256() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.fileencsha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_HistorySyncNotification::release_fileencsha256() { + // @@protoc_insertion_point(field_release:proto.Message.HistorySyncNotification.fileEncSha256) + if (!_internal_has_fileencsha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.fileencsha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fileencsha256_.IsDefault()) { + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_HistorySyncNotification::set_allocated_fileencsha256(std::string* fileencsha256) { + if (fileencsha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fileencsha256_.IsDefault()) { + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.HistorySyncNotification.fileEncSha256) +} + +// optional string directPath = 5; +inline bool Message_HistorySyncNotification::_internal_has_directpath() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool Message_HistorySyncNotification::has_directpath() const { + return _internal_has_directpath(); +} +inline void Message_HistorySyncNotification::clear_directpath() { + _impl_.directpath_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const std::string& Message_HistorySyncNotification::directpath() const { + // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.directPath) + return _internal_directpath(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_HistorySyncNotification::set_directpath(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.directpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.directPath) +} +inline std::string* Message_HistorySyncNotification::mutable_directpath() { + std::string* _s = _internal_mutable_directpath(); + // @@protoc_insertion_point(field_mutable:proto.Message.HistorySyncNotification.directPath) + return _s; +} +inline const std::string& Message_HistorySyncNotification::_internal_directpath() const { + return _impl_.directpath_.Get(); +} +inline void Message_HistorySyncNotification::_internal_set_directpath(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.directpath_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_HistorySyncNotification::_internal_mutable_directpath() { + _impl_._has_bits_[0] |= 0x00000008u; + return _impl_.directpath_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_HistorySyncNotification::release_directpath() { + // @@protoc_insertion_point(field_release:proto.Message.HistorySyncNotification.directPath) + if (!_internal_has_directpath()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000008u; + auto* p = _impl_.directpath_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.directpath_.IsDefault()) { + _impl_.directpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_HistorySyncNotification::set_allocated_directpath(std::string* directpath) { + if (directpath != nullptr) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.directpath_.IsDefault()) { + _impl_.directpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.HistorySyncNotification.directPath) +} + +// optional .proto.Message.HistorySyncNotification.HistorySyncType syncType = 6; +inline bool Message_HistorySyncNotification::_internal_has_synctype() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool Message_HistorySyncNotification::has_synctype() const { + return _internal_has_synctype(); +} +inline void Message_HistorySyncNotification::clear_synctype() { + _impl_.synctype_ = 0; + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline ::proto::Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification::_internal_synctype() const { + return static_cast< ::proto::Message_HistorySyncNotification_HistorySyncType >(_impl_.synctype_); +} +inline ::proto::Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification::synctype() const { + // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.syncType) + return _internal_synctype(); +} +inline void Message_HistorySyncNotification::_internal_set_synctype(::proto::Message_HistorySyncNotification_HistorySyncType value) { + assert(::proto::Message_HistorySyncNotification_HistorySyncType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.synctype_ = value; +} +inline void Message_HistorySyncNotification::set_synctype(::proto::Message_HistorySyncNotification_HistorySyncType value) { + _internal_set_synctype(value); + // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.syncType) +} + +// optional uint32 chunkOrder = 7; +inline bool Message_HistorySyncNotification::_internal_has_chunkorder() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool Message_HistorySyncNotification::has_chunkorder() const { + return _internal_has_chunkorder(); +} +inline void Message_HistorySyncNotification::clear_chunkorder() { + _impl_.chunkorder_ = 0u; + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline uint32_t Message_HistorySyncNotification::_internal_chunkorder() const { + return _impl_.chunkorder_; +} +inline uint32_t Message_HistorySyncNotification::chunkorder() const { + // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.chunkOrder) + return _internal_chunkorder(); +} +inline void Message_HistorySyncNotification::_internal_set_chunkorder(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.chunkorder_ = value; +} +inline void Message_HistorySyncNotification::set_chunkorder(uint32_t value) { + _internal_set_chunkorder(value); + // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.chunkOrder) +} + +// optional string originalMessageId = 8; +inline bool Message_HistorySyncNotification::_internal_has_originalmessageid() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool Message_HistorySyncNotification::has_originalmessageid() const { + return _internal_has_originalmessageid(); +} +inline void Message_HistorySyncNotification::clear_originalmessageid() { + _impl_.originalmessageid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const std::string& Message_HistorySyncNotification::originalmessageid() const { + // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.originalMessageId) + return _internal_originalmessageid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_HistorySyncNotification::set_originalmessageid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.originalmessageid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.originalMessageId) +} +inline std::string* Message_HistorySyncNotification::mutable_originalmessageid() { + std::string* _s = _internal_mutable_originalmessageid(); + // @@protoc_insertion_point(field_mutable:proto.Message.HistorySyncNotification.originalMessageId) + return _s; +} +inline const std::string& Message_HistorySyncNotification::_internal_originalmessageid() const { + return _impl_.originalmessageid_.Get(); +} +inline void Message_HistorySyncNotification::_internal_set_originalmessageid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.originalmessageid_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_HistorySyncNotification::_internal_mutable_originalmessageid() { + _impl_._has_bits_[0] |= 0x00000010u; + return _impl_.originalmessageid_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_HistorySyncNotification::release_originalmessageid() { + // @@protoc_insertion_point(field_release:proto.Message.HistorySyncNotification.originalMessageId) + if (!_internal_has_originalmessageid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000010u; + auto* p = _impl_.originalmessageid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.originalmessageid_.IsDefault()) { + _impl_.originalmessageid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_HistorySyncNotification::set_allocated_originalmessageid(std::string* originalmessageid) { + if (originalmessageid != nullptr) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.originalmessageid_.SetAllocated(originalmessageid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.originalmessageid_.IsDefault()) { + _impl_.originalmessageid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.HistorySyncNotification.originalMessageId) +} + +// optional uint32 progress = 9; +inline bool Message_HistorySyncNotification::_internal_has_progress() const { + bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool Message_HistorySyncNotification::has_progress() const { + return _internal_has_progress(); +} +inline void Message_HistorySyncNotification::clear_progress() { + _impl_.progress_ = 0u; + _impl_._has_bits_[0] &= ~0x00000100u; +} +inline uint32_t Message_HistorySyncNotification::_internal_progress() const { + return _impl_.progress_; +} +inline uint32_t Message_HistorySyncNotification::progress() const { + // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.progress) + return _internal_progress(); +} +inline void Message_HistorySyncNotification::_internal_set_progress(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.progress_ = value; +} +inline void Message_HistorySyncNotification::set_progress(uint32_t value) { + _internal_set_progress(value); + // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.progress) +} + +// ------------------------------------------------------------------- + +// Message_ImageMessage + +// optional string url = 1; +inline bool Message_ImageMessage::_internal_has_url() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_ImageMessage::has_url() const { + return _internal_has_url(); +} +inline void Message_ImageMessage::clear_url() { + _impl_.url_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_ImageMessage::url() const { + // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.url) + return _internal_url(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ImageMessage::set_url(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.url_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.url) +} +inline std::string* Message_ImageMessage::mutable_url() { + std::string* _s = _internal_mutable_url(); + // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.url) + return _s; +} +inline const std::string& Message_ImageMessage::_internal_url() const { + return _impl_.url_.Get(); +} +inline void Message_ImageMessage::_internal_set_url(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.url_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::_internal_mutable_url() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.url_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::release_url() { + // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.url) + if (!_internal_has_url()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.url_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.url_.IsDefault()) { + _impl_.url_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ImageMessage::set_allocated_url(std::string* url) { + if (url != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.url_.SetAllocated(url, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.url_.IsDefault()) { + _impl_.url_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.url) +} + +// optional string mimetype = 2; +inline bool Message_ImageMessage::_internal_has_mimetype() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_ImageMessage::has_mimetype() const { + return _internal_has_mimetype(); +} +inline void Message_ImageMessage::clear_mimetype() { + _impl_.mimetype_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_ImageMessage::mimetype() const { + // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.mimetype) + return _internal_mimetype(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ImageMessage::set_mimetype(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.mimetype_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.mimetype) +} +inline std::string* Message_ImageMessage::mutable_mimetype() { + std::string* _s = _internal_mutable_mimetype(); + // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.mimetype) + return _s; +} +inline const std::string& Message_ImageMessage::_internal_mimetype() const { + return _impl_.mimetype_.Get(); +} +inline void Message_ImageMessage::_internal_set_mimetype(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.mimetype_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::_internal_mutable_mimetype() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.mimetype_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::release_mimetype() { + // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.mimetype) + if (!_internal_has_mimetype()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.mimetype_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mimetype_.IsDefault()) { + _impl_.mimetype_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ImageMessage::set_allocated_mimetype(std::string* mimetype) { + if (mimetype != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mimetype_.IsDefault()) { + _impl_.mimetype_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.mimetype) +} + +// optional string caption = 3; +inline bool Message_ImageMessage::_internal_has_caption() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Message_ImageMessage::has_caption() const { + return _internal_has_caption(); +} +inline void Message_ImageMessage::clear_caption() { + _impl_.caption_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& Message_ImageMessage::caption() const { + // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.caption) + return _internal_caption(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ImageMessage::set_caption(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.caption_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.caption) +} +inline std::string* Message_ImageMessage::mutable_caption() { + std::string* _s = _internal_mutable_caption(); + // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.caption) + return _s; +} +inline const std::string& Message_ImageMessage::_internal_caption() const { + return _impl_.caption_.Get(); +} +inline void Message_ImageMessage::_internal_set_caption(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.caption_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::_internal_mutable_caption() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.caption_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::release_caption() { + // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.caption) + if (!_internal_has_caption()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.caption_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.caption_.IsDefault()) { + _impl_.caption_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ImageMessage::set_allocated_caption(std::string* caption) { + if (caption != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.caption_.SetAllocated(caption, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.caption_.IsDefault()) { + _impl_.caption_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.caption) +} + +// optional bytes fileSha256 = 4; +inline bool Message_ImageMessage::_internal_has_filesha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool Message_ImageMessage::has_filesha256() const { + return _internal_has_filesha256(); +} +inline void Message_ImageMessage::clear_filesha256() { + _impl_.filesha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const std::string& Message_ImageMessage::filesha256() const { + // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.fileSha256) + return _internal_filesha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ImageMessage::set_filesha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.filesha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.fileSha256) +} +inline std::string* Message_ImageMessage::mutable_filesha256() { + std::string* _s = _internal_mutable_filesha256(); + // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.fileSha256) + return _s; +} +inline const std::string& Message_ImageMessage::_internal_filesha256() const { + return _impl_.filesha256_.Get(); +} +inline void Message_ImageMessage::_internal_set_filesha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.filesha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::_internal_mutable_filesha256() { + _impl_._has_bits_[0] |= 0x00000008u; + return _impl_.filesha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::release_filesha256() { + // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.fileSha256) + if (!_internal_has_filesha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000008u; + auto* p = _impl_.filesha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.filesha256_.IsDefault()) { + _impl_.filesha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ImageMessage::set_allocated_filesha256(std::string* filesha256) { + if (filesha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.filesha256_.IsDefault()) { + _impl_.filesha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.fileSha256) +} + +// optional uint64 fileLength = 5; +inline bool Message_ImageMessage::_internal_has_filelength() const { + bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0; + return value; +} +inline bool Message_ImageMessage::has_filelength() const { + return _internal_has_filelength(); +} +inline void Message_ImageMessage::clear_filelength() { + _impl_.filelength_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00020000u; +} +inline uint64_t Message_ImageMessage::_internal_filelength() const { + return _impl_.filelength_; +} +inline uint64_t Message_ImageMessage::filelength() const { + // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.fileLength) + return _internal_filelength(); +} +inline void Message_ImageMessage::_internal_set_filelength(uint64_t value) { + _impl_._has_bits_[0] |= 0x00020000u; + _impl_.filelength_ = value; +} +inline void Message_ImageMessage::set_filelength(uint64_t value) { + _internal_set_filelength(value); + // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.fileLength) +} + +// optional uint32 height = 6; +inline bool Message_ImageMessage::_internal_has_height() const { + bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0; + return value; +} +inline bool Message_ImageMessage::has_height() const { + return _internal_has_height(); +} +inline void Message_ImageMessage::clear_height() { + _impl_.height_ = 0u; + _impl_._has_bits_[0] &= ~0x00040000u; +} +inline uint32_t Message_ImageMessage::_internal_height() const { + return _impl_.height_; +} +inline uint32_t Message_ImageMessage::height() const { + // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.height) + return _internal_height(); +} +inline void Message_ImageMessage::_internal_set_height(uint32_t value) { + _impl_._has_bits_[0] |= 0x00040000u; + _impl_.height_ = value; +} +inline void Message_ImageMessage::set_height(uint32_t value) { + _internal_set_height(value); + // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.height) +} + +// optional uint32 width = 7; +inline bool Message_ImageMessage::_internal_has_width() const { + bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0; + return value; +} +inline bool Message_ImageMessage::has_width() const { + return _internal_has_width(); +} +inline void Message_ImageMessage::clear_width() { + _impl_.width_ = 0u; + _impl_._has_bits_[0] &= ~0x00080000u; +} +inline uint32_t Message_ImageMessage::_internal_width() const { + return _impl_.width_; +} +inline uint32_t Message_ImageMessage::width() const { + // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.width) + return _internal_width(); +} +inline void Message_ImageMessage::_internal_set_width(uint32_t value) { + _impl_._has_bits_[0] |= 0x00080000u; + _impl_.width_ = value; +} +inline void Message_ImageMessage::set_width(uint32_t value) { + _internal_set_width(value); + // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.width) +} + +// optional bytes mediaKey = 8; +inline bool Message_ImageMessage::_internal_has_mediakey() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool Message_ImageMessage::has_mediakey() const { + return _internal_has_mediakey(); +} +inline void Message_ImageMessage::clear_mediakey() { + _impl_.mediakey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const std::string& Message_ImageMessage::mediakey() const { + // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.mediaKey) + return _internal_mediakey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ImageMessage::set_mediakey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.mediakey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.mediaKey) +} +inline std::string* Message_ImageMessage::mutable_mediakey() { + std::string* _s = _internal_mutable_mediakey(); + // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.mediaKey) + return _s; +} +inline const std::string& Message_ImageMessage::_internal_mediakey() const { + return _impl_.mediakey_.Get(); +} +inline void Message_ImageMessage::_internal_set_mediakey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.mediakey_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::_internal_mutable_mediakey() { + _impl_._has_bits_[0] |= 0x00000010u; + return _impl_.mediakey_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::release_mediakey() { + // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.mediaKey) + if (!_internal_has_mediakey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000010u; + auto* p = _impl_.mediakey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mediakey_.IsDefault()) { + _impl_.mediakey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ImageMessage::set_allocated_mediakey(std::string* mediakey) { + if (mediakey != nullptr) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mediakey_.IsDefault()) { + _impl_.mediakey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.mediaKey) +} + +// optional bytes fileEncSha256 = 9; +inline bool Message_ImageMessage::_internal_has_fileencsha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool Message_ImageMessage::has_fileencsha256() const { + return _internal_has_fileencsha256(); +} +inline void Message_ImageMessage::clear_fileencsha256() { + _impl_.fileencsha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline const std::string& Message_ImageMessage::fileencsha256() const { + // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.fileEncSha256) + return _internal_fileencsha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ImageMessage::set_fileencsha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.fileencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.fileEncSha256) +} +inline std::string* Message_ImageMessage::mutable_fileencsha256() { + std::string* _s = _internal_mutable_fileencsha256(); + // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.fileEncSha256) + return _s; +} +inline const std::string& Message_ImageMessage::_internal_fileencsha256() const { + return _impl_.fileencsha256_.Get(); +} +inline void Message_ImageMessage::_internal_set_fileencsha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.fileencsha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::_internal_mutable_fileencsha256() { + _impl_._has_bits_[0] |= 0x00000020u; + return _impl_.fileencsha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::release_fileencsha256() { + // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.fileEncSha256) + if (!_internal_has_fileencsha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000020u; + auto* p = _impl_.fileencsha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fileencsha256_.IsDefault()) { + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ImageMessage::set_allocated_fileencsha256(std::string* fileencsha256) { + if (fileencsha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fileencsha256_.IsDefault()) { + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.fileEncSha256) +} + +// repeated .proto.InteractiveAnnotation interactiveAnnotations = 10; +inline int Message_ImageMessage::_internal_interactiveannotations_size() const { + return _impl_.interactiveannotations_.size(); +} +inline int Message_ImageMessage::interactiveannotations_size() const { + return _internal_interactiveannotations_size(); +} +inline void Message_ImageMessage::clear_interactiveannotations() { + _impl_.interactiveannotations_.Clear(); +} +inline ::proto::InteractiveAnnotation* Message_ImageMessage::mutable_interactiveannotations(int index) { + // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.interactiveAnnotations) + return _impl_.interactiveannotations_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >* +Message_ImageMessage::mutable_interactiveannotations() { + // @@protoc_insertion_point(field_mutable_list:proto.Message.ImageMessage.interactiveAnnotations) + return &_impl_.interactiveannotations_; +} +inline const ::proto::InteractiveAnnotation& Message_ImageMessage::_internal_interactiveannotations(int index) const { + return _impl_.interactiveannotations_.Get(index); +} +inline const ::proto::InteractiveAnnotation& Message_ImageMessage::interactiveannotations(int index) const { + // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.interactiveAnnotations) + return _internal_interactiveannotations(index); +} +inline ::proto::InteractiveAnnotation* Message_ImageMessage::_internal_add_interactiveannotations() { + return _impl_.interactiveannotations_.Add(); +} +inline ::proto::InteractiveAnnotation* Message_ImageMessage::add_interactiveannotations() { + ::proto::InteractiveAnnotation* _add = _internal_add_interactiveannotations(); + // @@protoc_insertion_point(field_add:proto.Message.ImageMessage.interactiveAnnotations) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >& +Message_ImageMessage::interactiveannotations() const { + // @@protoc_insertion_point(field_list:proto.Message.ImageMessage.interactiveAnnotations) + return _impl_.interactiveannotations_; +} + +// optional string directPath = 11; +inline bool Message_ImageMessage::_internal_has_directpath() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool Message_ImageMessage::has_directpath() const { + return _internal_has_directpath(); +} +inline void Message_ImageMessage::clear_directpath() { + _impl_.directpath_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline const std::string& Message_ImageMessage::directpath() const { + // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.directPath) + return _internal_directpath(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ImageMessage::set_directpath(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.directpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.directPath) +} +inline std::string* Message_ImageMessage::mutable_directpath() { + std::string* _s = _internal_mutable_directpath(); + // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.directPath) + return _s; +} +inline const std::string& Message_ImageMessage::_internal_directpath() const { + return _impl_.directpath_.Get(); +} +inline void Message_ImageMessage::_internal_set_directpath(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.directpath_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::_internal_mutable_directpath() { + _impl_._has_bits_[0] |= 0x00000040u; + return _impl_.directpath_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::release_directpath() { + // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.directPath) + if (!_internal_has_directpath()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000040u; + auto* p = _impl_.directpath_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.directpath_.IsDefault()) { + _impl_.directpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ImageMessage::set_allocated_directpath(std::string* directpath) { + if (directpath != nullptr) { + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.directpath_.IsDefault()) { + _impl_.directpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.directPath) +} + +// optional int64 mediaKeyTimestamp = 12; +inline bool Message_ImageMessage::_internal_has_mediakeytimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0; + return value; +} +inline bool Message_ImageMessage::has_mediakeytimestamp() const { + return _internal_has_mediakeytimestamp(); +} +inline void Message_ImageMessage::clear_mediakeytimestamp() { + _impl_.mediakeytimestamp_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00100000u; +} +inline int64_t Message_ImageMessage::_internal_mediakeytimestamp() const { + return _impl_.mediakeytimestamp_; +} +inline int64_t Message_ImageMessage::mediakeytimestamp() const { + // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.mediaKeyTimestamp) + return _internal_mediakeytimestamp(); +} +inline void Message_ImageMessage::_internal_set_mediakeytimestamp(int64_t value) { + _impl_._has_bits_[0] |= 0x00100000u; + _impl_.mediakeytimestamp_ = value; +} +inline void Message_ImageMessage::set_mediakeytimestamp(int64_t value) { + _internal_set_mediakeytimestamp(value); + // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.mediaKeyTimestamp) +} + +// optional bytes jpegThumbnail = 16; +inline bool Message_ImageMessage::_internal_has_jpegthumbnail() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool Message_ImageMessage::has_jpegthumbnail() const { + return _internal_has_jpegthumbnail(); +} +inline void Message_ImageMessage::clear_jpegthumbnail() { + _impl_.jpegthumbnail_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline const std::string& Message_ImageMessage::jpegthumbnail() const { + // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.jpegThumbnail) + return _internal_jpegthumbnail(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ImageMessage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.jpegthumbnail_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.jpegThumbnail) +} +inline std::string* Message_ImageMessage::mutable_jpegthumbnail() { + std::string* _s = _internal_mutable_jpegthumbnail(); + // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.jpegThumbnail) + return _s; +} +inline const std::string& Message_ImageMessage::_internal_jpegthumbnail() const { + return _impl_.jpegthumbnail_.Get(); +} +inline void Message_ImageMessage::_internal_set_jpegthumbnail(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::_internal_mutable_jpegthumbnail() { + _impl_._has_bits_[0] |= 0x00000080u; + return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::release_jpegthumbnail() { + // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.jpegThumbnail) + if (!_internal_has_jpegthumbnail()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000080u; + auto* p = _impl_.jpegthumbnail_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.jpegthumbnail_.IsDefault()) { + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ImageMessage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) { + if (jpegthumbnail != nullptr) { + _impl_._has_bits_[0] |= 0x00000080u; + } else { + _impl_._has_bits_[0] &= ~0x00000080u; + } + _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.jpegthumbnail_.IsDefault()) { + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.jpegThumbnail) +} + +// optional .proto.ContextInfo contextInfo = 17; +inline bool Message_ImageMessage::_internal_has_contextinfo() const { + bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); + return value; +} +inline bool Message_ImageMessage::has_contextinfo() const { + return _internal_has_contextinfo(); +} +inline void Message_ImageMessage::clear_contextinfo() { + if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); + _impl_._has_bits_[0] &= ~0x00010000u; +} +inline const ::proto::ContextInfo& Message_ImageMessage::_internal_contextinfo() const { + const ::proto::ContextInfo* p = _impl_.contextinfo_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ContextInfo_default_instance_); +} +inline const ::proto::ContextInfo& Message_ImageMessage::contextinfo() const { + // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.contextInfo) + return _internal_contextinfo(); +} +inline void Message_ImageMessage::unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); + } + _impl_.contextinfo_ = contextinfo; + if (contextinfo) { + _impl_._has_bits_[0] |= 0x00010000u; + } else { + _impl_._has_bits_[0] &= ~0x00010000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ImageMessage.contextInfo) +} +inline ::proto::ContextInfo* Message_ImageMessage::release_contextinfo() { + _impl_._has_bits_[0] &= ~0x00010000u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ContextInfo* Message_ImageMessage::unsafe_arena_release_contextinfo() { + // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.contextInfo) + _impl_._has_bits_[0] &= ~0x00010000u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; + return temp; +} +inline ::proto::ContextInfo* Message_ImageMessage::_internal_mutable_contextinfo() { + _impl_._has_bits_[0] |= 0x00010000u; + if (_impl_.contextinfo_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); + _impl_.contextinfo_ = p; + } + return _impl_.contextinfo_; +} +inline ::proto::ContextInfo* Message_ImageMessage::mutable_contextinfo() { + ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); + // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.contextInfo) + return _msg; +} +inline void Message_ImageMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.contextinfo_; + } + if (contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); + if (message_arena != submessage_arena) { + contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, contextinfo, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00010000u; + } else { + _impl_._has_bits_[0] &= ~0x00010000u; + } + _impl_.contextinfo_ = contextinfo; + // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.contextInfo) +} + +// optional bytes firstScanSidecar = 18; +inline bool Message_ImageMessage::_internal_has_firstscansidecar() const { + bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool Message_ImageMessage::has_firstscansidecar() const { + return _internal_has_firstscansidecar(); +} +inline void Message_ImageMessage::clear_firstscansidecar() { + _impl_.firstscansidecar_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000100u; +} +inline const std::string& Message_ImageMessage::firstscansidecar() const { + // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.firstScanSidecar) + return _internal_firstscansidecar(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ImageMessage::set_firstscansidecar(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.firstscansidecar_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.firstScanSidecar) +} +inline std::string* Message_ImageMessage::mutable_firstscansidecar() { + std::string* _s = _internal_mutable_firstscansidecar(); + // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.firstScanSidecar) + return _s; +} +inline const std::string& Message_ImageMessage::_internal_firstscansidecar() const { + return _impl_.firstscansidecar_.Get(); +} +inline void Message_ImageMessage::_internal_set_firstscansidecar(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.firstscansidecar_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::_internal_mutable_firstscansidecar() { + _impl_._has_bits_[0] |= 0x00000100u; + return _impl_.firstscansidecar_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::release_firstscansidecar() { + // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.firstScanSidecar) + if (!_internal_has_firstscansidecar()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000100u; + auto* p = _impl_.firstscansidecar_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.firstscansidecar_.IsDefault()) { + _impl_.firstscansidecar_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ImageMessage::set_allocated_firstscansidecar(std::string* firstscansidecar) { + if (firstscansidecar != nullptr) { + _impl_._has_bits_[0] |= 0x00000100u; + } else { + _impl_._has_bits_[0] &= ~0x00000100u; + } + _impl_.firstscansidecar_.SetAllocated(firstscansidecar, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.firstscansidecar_.IsDefault()) { + _impl_.firstscansidecar_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.firstScanSidecar) +} + +// optional uint32 firstScanLength = 19; +inline bool Message_ImageMessage::_internal_has_firstscanlength() const { + bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0; + return value; +} +inline bool Message_ImageMessage::has_firstscanlength() const { + return _internal_has_firstscanlength(); +} +inline void Message_ImageMessage::clear_firstscanlength() { + _impl_.firstscanlength_ = 0u; + _impl_._has_bits_[0] &= ~0x00200000u; +} +inline uint32_t Message_ImageMessage::_internal_firstscanlength() const { + return _impl_.firstscanlength_; +} +inline uint32_t Message_ImageMessage::firstscanlength() const { + // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.firstScanLength) + return _internal_firstscanlength(); +} +inline void Message_ImageMessage::_internal_set_firstscanlength(uint32_t value) { + _impl_._has_bits_[0] |= 0x00200000u; + _impl_.firstscanlength_ = value; +} +inline void Message_ImageMessage::set_firstscanlength(uint32_t value) { + _internal_set_firstscanlength(value); + // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.firstScanLength) +} + +// optional uint32 experimentGroupId = 20; +inline bool Message_ImageMessage::_internal_has_experimentgroupid() const { + bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0; + return value; +} +inline bool Message_ImageMessage::has_experimentgroupid() const { + return _internal_has_experimentgroupid(); +} +inline void Message_ImageMessage::clear_experimentgroupid() { + _impl_.experimentgroupid_ = 0u; + _impl_._has_bits_[0] &= ~0x00400000u; +} +inline uint32_t Message_ImageMessage::_internal_experimentgroupid() const { + return _impl_.experimentgroupid_; +} +inline uint32_t Message_ImageMessage::experimentgroupid() const { + // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.experimentGroupId) + return _internal_experimentgroupid(); +} +inline void Message_ImageMessage::_internal_set_experimentgroupid(uint32_t value) { + _impl_._has_bits_[0] |= 0x00400000u; + _impl_.experimentgroupid_ = value; +} +inline void Message_ImageMessage::set_experimentgroupid(uint32_t value) { + _internal_set_experimentgroupid(value); + // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.experimentGroupId) +} + +// optional bytes scansSidecar = 21; +inline bool Message_ImageMessage::_internal_has_scanssidecar() const { + bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool Message_ImageMessage::has_scanssidecar() const { + return _internal_has_scanssidecar(); +} +inline void Message_ImageMessage::clear_scanssidecar() { + _impl_.scanssidecar_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000200u; +} +inline const std::string& Message_ImageMessage::scanssidecar() const { + // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.scansSidecar) + return _internal_scanssidecar(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ImageMessage::set_scanssidecar(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.scanssidecar_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.scansSidecar) +} +inline std::string* Message_ImageMessage::mutable_scanssidecar() { + std::string* _s = _internal_mutable_scanssidecar(); + // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.scansSidecar) + return _s; +} +inline const std::string& Message_ImageMessage::_internal_scanssidecar() const { + return _impl_.scanssidecar_.Get(); +} +inline void Message_ImageMessage::_internal_set_scanssidecar(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.scanssidecar_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::_internal_mutable_scanssidecar() { + _impl_._has_bits_[0] |= 0x00000200u; + return _impl_.scanssidecar_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::release_scanssidecar() { + // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.scansSidecar) + if (!_internal_has_scanssidecar()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000200u; + auto* p = _impl_.scanssidecar_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.scanssidecar_.IsDefault()) { + _impl_.scanssidecar_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ImageMessage::set_allocated_scanssidecar(std::string* scanssidecar) { + if (scanssidecar != nullptr) { + _impl_._has_bits_[0] |= 0x00000200u; + } else { + _impl_._has_bits_[0] &= ~0x00000200u; + } + _impl_.scanssidecar_.SetAllocated(scanssidecar, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.scanssidecar_.IsDefault()) { + _impl_.scanssidecar_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.scansSidecar) +} + +// repeated uint32 scanLengths = 22; +inline int Message_ImageMessage::_internal_scanlengths_size() const { + return _impl_.scanlengths_.size(); +} +inline int Message_ImageMessage::scanlengths_size() const { + return _internal_scanlengths_size(); +} +inline void Message_ImageMessage::clear_scanlengths() { + _impl_.scanlengths_.Clear(); +} +inline uint32_t Message_ImageMessage::_internal_scanlengths(int index) const { + return _impl_.scanlengths_.Get(index); +} +inline uint32_t Message_ImageMessage::scanlengths(int index) const { + // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.scanLengths) + return _internal_scanlengths(index); +} +inline void Message_ImageMessage::set_scanlengths(int index, uint32_t value) { + _impl_.scanlengths_.Set(index, value); + // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.scanLengths) +} +inline void Message_ImageMessage::_internal_add_scanlengths(uint32_t value) { + _impl_.scanlengths_.Add(value); +} +inline void Message_ImageMessage::add_scanlengths(uint32_t value) { + _internal_add_scanlengths(value); + // @@protoc_insertion_point(field_add:proto.Message.ImageMessage.scanLengths) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +Message_ImageMessage::_internal_scanlengths() const { + return _impl_.scanlengths_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& +Message_ImageMessage::scanlengths() const { + // @@protoc_insertion_point(field_list:proto.Message.ImageMessage.scanLengths) + return _internal_scanlengths(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +Message_ImageMessage::_internal_mutable_scanlengths() { + return &_impl_.scanlengths_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* +Message_ImageMessage::mutable_scanlengths() { + // @@protoc_insertion_point(field_mutable_list:proto.Message.ImageMessage.scanLengths) + return _internal_mutable_scanlengths(); +} + +// optional bytes midQualityFileSha256 = 23; +inline bool Message_ImageMessage::_internal_has_midqualityfilesha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool Message_ImageMessage::has_midqualityfilesha256() const { + return _internal_has_midqualityfilesha256(); +} +inline void Message_ImageMessage::clear_midqualityfilesha256() { + _impl_.midqualityfilesha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000400u; +} +inline const std::string& Message_ImageMessage::midqualityfilesha256() const { + // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.midQualityFileSha256) + return _internal_midqualityfilesha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ImageMessage::set_midqualityfilesha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000400u; + _impl_.midqualityfilesha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.midQualityFileSha256) +} +inline std::string* Message_ImageMessage::mutable_midqualityfilesha256() { + std::string* _s = _internal_mutable_midqualityfilesha256(); + // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.midQualityFileSha256) + return _s; +} +inline const std::string& Message_ImageMessage::_internal_midqualityfilesha256() const { + return _impl_.midqualityfilesha256_.Get(); +} +inline void Message_ImageMessage::_internal_set_midqualityfilesha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000400u; + _impl_.midqualityfilesha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::_internal_mutable_midqualityfilesha256() { + _impl_._has_bits_[0] |= 0x00000400u; + return _impl_.midqualityfilesha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::release_midqualityfilesha256() { + // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.midQualityFileSha256) + if (!_internal_has_midqualityfilesha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000400u; + auto* p = _impl_.midqualityfilesha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.midqualityfilesha256_.IsDefault()) { + _impl_.midqualityfilesha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ImageMessage::set_allocated_midqualityfilesha256(std::string* midqualityfilesha256) { + if (midqualityfilesha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000400u; + } else { + _impl_._has_bits_[0] &= ~0x00000400u; + } + _impl_.midqualityfilesha256_.SetAllocated(midqualityfilesha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.midqualityfilesha256_.IsDefault()) { + _impl_.midqualityfilesha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.midQualityFileSha256) +} + +// optional bytes midQualityFileEncSha256 = 24; +inline bool Message_ImageMessage::_internal_has_midqualityfileencsha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; + return value; +} +inline bool Message_ImageMessage::has_midqualityfileencsha256() const { + return _internal_has_midqualityfileencsha256(); +} +inline void Message_ImageMessage::clear_midqualityfileencsha256() { + _impl_.midqualityfileencsha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000800u; +} +inline const std::string& Message_ImageMessage::midqualityfileencsha256() const { + // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.midQualityFileEncSha256) + return _internal_midqualityfileencsha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ImageMessage::set_midqualityfileencsha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000800u; + _impl_.midqualityfileencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.midQualityFileEncSha256) +} +inline std::string* Message_ImageMessage::mutable_midqualityfileencsha256() { + std::string* _s = _internal_mutable_midqualityfileencsha256(); + // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.midQualityFileEncSha256) + return _s; +} +inline const std::string& Message_ImageMessage::_internal_midqualityfileencsha256() const { + return _impl_.midqualityfileencsha256_.Get(); +} +inline void Message_ImageMessage::_internal_set_midqualityfileencsha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000800u; + _impl_.midqualityfileencsha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::_internal_mutable_midqualityfileencsha256() { + _impl_._has_bits_[0] |= 0x00000800u; + return _impl_.midqualityfileencsha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::release_midqualityfileencsha256() { + // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.midQualityFileEncSha256) + if (!_internal_has_midqualityfileencsha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000800u; + auto* p = _impl_.midqualityfileencsha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.midqualityfileencsha256_.IsDefault()) { + _impl_.midqualityfileencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ImageMessage::set_allocated_midqualityfileencsha256(std::string* midqualityfileencsha256) { + if (midqualityfileencsha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000800u; + } else { + _impl_._has_bits_[0] &= ~0x00000800u; + } + _impl_.midqualityfileencsha256_.SetAllocated(midqualityfileencsha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.midqualityfileencsha256_.IsDefault()) { + _impl_.midqualityfileencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.midQualityFileEncSha256) +} + +// optional bool viewOnce = 25; +inline bool Message_ImageMessage::_internal_has_viewonce() const { + bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0; + return value; +} +inline bool Message_ImageMessage::has_viewonce() const { + return _internal_has_viewonce(); +} +inline void Message_ImageMessage::clear_viewonce() { + _impl_.viewonce_ = false; + _impl_._has_bits_[0] &= ~0x00800000u; +} +inline bool Message_ImageMessage::_internal_viewonce() const { + return _impl_.viewonce_; +} +inline bool Message_ImageMessage::viewonce() const { + // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.viewOnce) + return _internal_viewonce(); +} +inline void Message_ImageMessage::_internal_set_viewonce(bool value) { + _impl_._has_bits_[0] |= 0x00800000u; + _impl_.viewonce_ = value; +} +inline void Message_ImageMessage::set_viewonce(bool value) { + _internal_set_viewonce(value); + // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.viewOnce) +} + +// optional string thumbnailDirectPath = 26; +inline bool Message_ImageMessage::_internal_has_thumbnaildirectpath() const { + bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; + return value; +} +inline bool Message_ImageMessage::has_thumbnaildirectpath() const { + return _internal_has_thumbnaildirectpath(); +} +inline void Message_ImageMessage::clear_thumbnaildirectpath() { + _impl_.thumbnaildirectpath_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00001000u; +} +inline const std::string& Message_ImageMessage::thumbnaildirectpath() const { + // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.thumbnailDirectPath) + return _internal_thumbnaildirectpath(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ImageMessage::set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00001000u; + _impl_.thumbnaildirectpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.thumbnailDirectPath) +} +inline std::string* Message_ImageMessage::mutable_thumbnaildirectpath() { + std::string* _s = _internal_mutable_thumbnaildirectpath(); + // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.thumbnailDirectPath) + return _s; +} +inline const std::string& Message_ImageMessage::_internal_thumbnaildirectpath() const { + return _impl_.thumbnaildirectpath_.Get(); +} +inline void Message_ImageMessage::_internal_set_thumbnaildirectpath(const std::string& value) { + _impl_._has_bits_[0] |= 0x00001000u; + _impl_.thumbnaildirectpath_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::_internal_mutable_thumbnaildirectpath() { + _impl_._has_bits_[0] |= 0x00001000u; + return _impl_.thumbnaildirectpath_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::release_thumbnaildirectpath() { + // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.thumbnailDirectPath) + if (!_internal_has_thumbnaildirectpath()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00001000u; + auto* p = _impl_.thumbnaildirectpath_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.thumbnaildirectpath_.IsDefault()) { + _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ImageMessage::set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath) { + if (thumbnaildirectpath != nullptr) { + _impl_._has_bits_[0] |= 0x00001000u; + } else { + _impl_._has_bits_[0] &= ~0x00001000u; + } + _impl_.thumbnaildirectpath_.SetAllocated(thumbnaildirectpath, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.thumbnaildirectpath_.IsDefault()) { + _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.thumbnailDirectPath) +} + +// optional bytes thumbnailSha256 = 27; +inline bool Message_ImageMessage::_internal_has_thumbnailsha256() const { + bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0; + return value; +} +inline bool Message_ImageMessage::has_thumbnailsha256() const { + return _internal_has_thumbnailsha256(); +} +inline void Message_ImageMessage::clear_thumbnailsha256() { + _impl_.thumbnailsha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00002000u; +} +inline const std::string& Message_ImageMessage::thumbnailsha256() const { + // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.thumbnailSha256) + return _internal_thumbnailsha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ImageMessage::set_thumbnailsha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00002000u; + _impl_.thumbnailsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.thumbnailSha256) +} +inline std::string* Message_ImageMessage::mutable_thumbnailsha256() { + std::string* _s = _internal_mutable_thumbnailsha256(); + // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.thumbnailSha256) + return _s; +} +inline const std::string& Message_ImageMessage::_internal_thumbnailsha256() const { + return _impl_.thumbnailsha256_.Get(); +} +inline void Message_ImageMessage::_internal_set_thumbnailsha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00002000u; + _impl_.thumbnailsha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::_internal_mutable_thumbnailsha256() { + _impl_._has_bits_[0] |= 0x00002000u; + return _impl_.thumbnailsha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::release_thumbnailsha256() { + // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.thumbnailSha256) + if (!_internal_has_thumbnailsha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00002000u; + auto* p = _impl_.thumbnailsha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.thumbnailsha256_.IsDefault()) { + _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ImageMessage::set_allocated_thumbnailsha256(std::string* thumbnailsha256) { + if (thumbnailsha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00002000u; + } else { + _impl_._has_bits_[0] &= ~0x00002000u; + } + _impl_.thumbnailsha256_.SetAllocated(thumbnailsha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.thumbnailsha256_.IsDefault()) { + _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.thumbnailSha256) +} + +// optional bytes thumbnailEncSha256 = 28; +inline bool Message_ImageMessage::_internal_has_thumbnailencsha256() const { + bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0; + return value; +} +inline bool Message_ImageMessage::has_thumbnailencsha256() const { + return _internal_has_thumbnailencsha256(); +} +inline void Message_ImageMessage::clear_thumbnailencsha256() { + _impl_.thumbnailencsha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00004000u; +} +inline const std::string& Message_ImageMessage::thumbnailencsha256() const { + // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.thumbnailEncSha256) + return _internal_thumbnailencsha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ImageMessage::set_thumbnailencsha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00004000u; + _impl_.thumbnailencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.thumbnailEncSha256) +} +inline std::string* Message_ImageMessage::mutable_thumbnailencsha256() { + std::string* _s = _internal_mutable_thumbnailencsha256(); + // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.thumbnailEncSha256) + return _s; +} +inline const std::string& Message_ImageMessage::_internal_thumbnailencsha256() const { + return _impl_.thumbnailencsha256_.Get(); +} +inline void Message_ImageMessage::_internal_set_thumbnailencsha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00004000u; + _impl_.thumbnailencsha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::_internal_mutable_thumbnailencsha256() { + _impl_._has_bits_[0] |= 0x00004000u; + return _impl_.thumbnailencsha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::release_thumbnailencsha256() { + // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.thumbnailEncSha256) + if (!_internal_has_thumbnailencsha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00004000u; + auto* p = _impl_.thumbnailencsha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.thumbnailencsha256_.IsDefault()) { + _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ImageMessage::set_allocated_thumbnailencsha256(std::string* thumbnailencsha256) { + if (thumbnailencsha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00004000u; + } else { + _impl_._has_bits_[0] &= ~0x00004000u; + } + _impl_.thumbnailencsha256_.SetAllocated(thumbnailencsha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.thumbnailencsha256_.IsDefault()) { + _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.thumbnailEncSha256) +} + +// optional string staticUrl = 29; +inline bool Message_ImageMessage::_internal_has_staticurl() const { + bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0; + return value; +} +inline bool Message_ImageMessage::has_staticurl() const { + return _internal_has_staticurl(); +} +inline void Message_ImageMessage::clear_staticurl() { + _impl_.staticurl_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00008000u; +} +inline const std::string& Message_ImageMessage::staticurl() const { + // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.staticUrl) + return _internal_staticurl(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ImageMessage::set_staticurl(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00008000u; + _impl_.staticurl_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.staticUrl) +} +inline std::string* Message_ImageMessage::mutable_staticurl() { + std::string* _s = _internal_mutable_staticurl(); + // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.staticUrl) + return _s; +} +inline const std::string& Message_ImageMessage::_internal_staticurl() const { + return _impl_.staticurl_.Get(); +} +inline void Message_ImageMessage::_internal_set_staticurl(const std::string& value) { + _impl_._has_bits_[0] |= 0x00008000u; + _impl_.staticurl_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::_internal_mutable_staticurl() { + _impl_._has_bits_[0] |= 0x00008000u; + return _impl_.staticurl_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ImageMessage::release_staticurl() { + // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.staticUrl) + if (!_internal_has_staticurl()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00008000u; + auto* p = _impl_.staticurl_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.staticurl_.IsDefault()) { + _impl_.staticurl_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ImageMessage::set_allocated_staticurl(std::string* staticurl) { + if (staticurl != nullptr) { + _impl_._has_bits_[0] |= 0x00008000u; + } else { + _impl_._has_bits_[0] &= ~0x00008000u; + } + _impl_.staticurl_.SetAllocated(staticurl, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.staticurl_.IsDefault()) { + _impl_.staticurl_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.staticUrl) +} + +// ------------------------------------------------------------------- + +// Message_InitialSecurityNotificationSettingSync + +// optional bool securityNotificationEnabled = 1; +inline bool Message_InitialSecurityNotificationSettingSync::_internal_has_securitynotificationenabled() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_InitialSecurityNotificationSettingSync::has_securitynotificationenabled() const { + return _internal_has_securitynotificationenabled(); +} +inline void Message_InitialSecurityNotificationSettingSync::clear_securitynotificationenabled() { + _impl_.securitynotificationenabled_ = false; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline bool Message_InitialSecurityNotificationSettingSync::_internal_securitynotificationenabled() const { + return _impl_.securitynotificationenabled_; +} +inline bool Message_InitialSecurityNotificationSettingSync::securitynotificationenabled() const { + // @@protoc_insertion_point(field_get:proto.Message.InitialSecurityNotificationSettingSync.securityNotificationEnabled) + return _internal_securitynotificationenabled(); +} +inline void Message_InitialSecurityNotificationSettingSync::_internal_set_securitynotificationenabled(bool value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.securitynotificationenabled_ = value; +} +inline void Message_InitialSecurityNotificationSettingSync::set_securitynotificationenabled(bool value) { + _internal_set_securitynotificationenabled(value); + // @@protoc_insertion_point(field_set:proto.Message.InitialSecurityNotificationSettingSync.securityNotificationEnabled) +} + +// ------------------------------------------------------------------- + +// Message_InteractiveMessage_Body + +// optional string text = 1; +inline bool Message_InteractiveMessage_Body::_internal_has_text() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_InteractiveMessage_Body::has_text() const { + return _internal_has_text(); +} +inline void Message_InteractiveMessage_Body::clear_text() { + _impl_.text_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_InteractiveMessage_Body::text() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Body.text) + return _internal_text(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_InteractiveMessage_Body::set_text(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.text_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.Body.text) +} +inline std::string* Message_InteractiveMessage_Body::mutable_text() { + std::string* _s = _internal_mutable_text(); + // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Body.text) + return _s; +} +inline const std::string& Message_InteractiveMessage_Body::_internal_text() const { + return _impl_.text_.Get(); +} +inline void Message_InteractiveMessage_Body::_internal_set_text(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.text_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_InteractiveMessage_Body::_internal_mutable_text() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.text_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_InteractiveMessage_Body::release_text() { + // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Body.text) + if (!_internal_has_text()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.text_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.text_.IsDefault()) { + _impl_.text_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_InteractiveMessage_Body::set_allocated_text(std::string* text) { + if (text != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.text_.SetAllocated(text, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.text_.IsDefault()) { + _impl_.text_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.Body.text) +} + +// ------------------------------------------------------------------- + +// Message_InteractiveMessage_CollectionMessage + +// optional string bizJid = 1; +inline bool Message_InteractiveMessage_CollectionMessage::_internal_has_bizjid() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_InteractiveMessage_CollectionMessage::has_bizjid() const { + return _internal_has_bizjid(); +} +inline void Message_InteractiveMessage_CollectionMessage::clear_bizjid() { + _impl_.bizjid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_InteractiveMessage_CollectionMessage::bizjid() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.CollectionMessage.bizJid) + return _internal_bizjid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_InteractiveMessage_CollectionMessage::set_bizjid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.bizjid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.CollectionMessage.bizJid) +} +inline std::string* Message_InteractiveMessage_CollectionMessage::mutable_bizjid() { + std::string* _s = _internal_mutable_bizjid(); + // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.CollectionMessage.bizJid) + return _s; +} +inline const std::string& Message_InteractiveMessage_CollectionMessage::_internal_bizjid() const { + return _impl_.bizjid_.Get(); +} +inline void Message_InteractiveMessage_CollectionMessage::_internal_set_bizjid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.bizjid_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_InteractiveMessage_CollectionMessage::_internal_mutable_bizjid() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.bizjid_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_InteractiveMessage_CollectionMessage::release_bizjid() { + // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.CollectionMessage.bizJid) + if (!_internal_has_bizjid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.bizjid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.bizjid_.IsDefault()) { + _impl_.bizjid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_InteractiveMessage_CollectionMessage::set_allocated_bizjid(std::string* bizjid) { + if (bizjid != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.bizjid_.SetAllocated(bizjid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.bizjid_.IsDefault()) { + _impl_.bizjid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.CollectionMessage.bizJid) +} + +// optional string id = 2; +inline bool Message_InteractiveMessage_CollectionMessage::_internal_has_id() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_InteractiveMessage_CollectionMessage::has_id() const { + return _internal_has_id(); +} +inline void Message_InteractiveMessage_CollectionMessage::clear_id() { + _impl_.id_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_InteractiveMessage_CollectionMessage::id() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.CollectionMessage.id) + return _internal_id(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_InteractiveMessage_CollectionMessage::set_id(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.id_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.CollectionMessage.id) +} +inline std::string* Message_InteractiveMessage_CollectionMessage::mutable_id() { + std::string* _s = _internal_mutable_id(); + // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.CollectionMessage.id) + return _s; +} +inline const std::string& Message_InteractiveMessage_CollectionMessage::_internal_id() const { + return _impl_.id_.Get(); +} +inline void Message_InteractiveMessage_CollectionMessage::_internal_set_id(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.id_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_InteractiveMessage_CollectionMessage::_internal_mutable_id() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.id_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_InteractiveMessage_CollectionMessage::release_id() { + // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.CollectionMessage.id) + if (!_internal_has_id()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.id_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.id_.IsDefault()) { + _impl_.id_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_InteractiveMessage_CollectionMessage::set_allocated_id(std::string* id) { + if (id != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.id_.SetAllocated(id, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.id_.IsDefault()) { + _impl_.id_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.CollectionMessage.id) +} + +// optional int32 messageVersion = 3; +inline bool Message_InteractiveMessage_CollectionMessage::_internal_has_messageversion() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Message_InteractiveMessage_CollectionMessage::has_messageversion() const { + return _internal_has_messageversion(); +} +inline void Message_InteractiveMessage_CollectionMessage::clear_messageversion() { + _impl_.messageversion_ = 0; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline int32_t Message_InteractiveMessage_CollectionMessage::_internal_messageversion() const { + return _impl_.messageversion_; +} +inline int32_t Message_InteractiveMessage_CollectionMessage::messageversion() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.CollectionMessage.messageVersion) + return _internal_messageversion(); +} +inline void Message_InteractiveMessage_CollectionMessage::_internal_set_messageversion(int32_t value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.messageversion_ = value; +} +inline void Message_InteractiveMessage_CollectionMessage::set_messageversion(int32_t value) { + _internal_set_messageversion(value); + // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.CollectionMessage.messageVersion) +} + +// ------------------------------------------------------------------- + +// Message_InteractiveMessage_Footer + +// optional string text = 1; +inline bool Message_InteractiveMessage_Footer::_internal_has_text() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_InteractiveMessage_Footer::has_text() const { + return _internal_has_text(); +} +inline void Message_InteractiveMessage_Footer::clear_text() { + _impl_.text_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_InteractiveMessage_Footer::text() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Footer.text) + return _internal_text(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_InteractiveMessage_Footer::set_text(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.text_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.Footer.text) +} +inline std::string* Message_InteractiveMessage_Footer::mutable_text() { + std::string* _s = _internal_mutable_text(); + // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Footer.text) + return _s; +} +inline const std::string& Message_InteractiveMessage_Footer::_internal_text() const { + return _impl_.text_.Get(); +} +inline void Message_InteractiveMessage_Footer::_internal_set_text(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.text_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_InteractiveMessage_Footer::_internal_mutable_text() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.text_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_InteractiveMessage_Footer::release_text() { + // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Footer.text) + if (!_internal_has_text()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.text_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.text_.IsDefault()) { + _impl_.text_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_InteractiveMessage_Footer::set_allocated_text(std::string* text) { + if (text != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.text_.SetAllocated(text, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.text_.IsDefault()) { + _impl_.text_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.Footer.text) +} + +// ------------------------------------------------------------------- + +// Message_InteractiveMessage_Header + +// optional string title = 1; +inline bool Message_InteractiveMessage_Header::_internal_has_title() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_InteractiveMessage_Header::has_title() const { + return _internal_has_title(); +} +inline void Message_InteractiveMessage_Header::clear_title() { + _impl_.title_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_InteractiveMessage_Header::title() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Header.title) + return _internal_title(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_InteractiveMessage_Header::set_title(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.title_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.Header.title) +} +inline std::string* Message_InteractiveMessage_Header::mutable_title() { + std::string* _s = _internal_mutable_title(); + // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Header.title) + return _s; +} +inline const std::string& Message_InteractiveMessage_Header::_internal_title() const { + return _impl_.title_.Get(); +} +inline void Message_InteractiveMessage_Header::_internal_set_title(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.title_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_InteractiveMessage_Header::_internal_mutable_title() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.title_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_InteractiveMessage_Header::release_title() { + // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Header.title) + if (!_internal_has_title()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.title_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.title_.IsDefault()) { + _impl_.title_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_InteractiveMessage_Header::set_allocated_title(std::string* title) { + if (title != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.title_.SetAllocated(title, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.title_.IsDefault()) { + _impl_.title_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.Header.title) +} + +// optional string subtitle = 2; +inline bool Message_InteractiveMessage_Header::_internal_has_subtitle() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_InteractiveMessage_Header::has_subtitle() const { + return _internal_has_subtitle(); +} +inline void Message_InteractiveMessage_Header::clear_subtitle() { + _impl_.subtitle_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_InteractiveMessage_Header::subtitle() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Header.subtitle) + return _internal_subtitle(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_InteractiveMessage_Header::set_subtitle(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.subtitle_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.Header.subtitle) +} +inline std::string* Message_InteractiveMessage_Header::mutable_subtitle() { + std::string* _s = _internal_mutable_subtitle(); + // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Header.subtitle) + return _s; +} +inline const std::string& Message_InteractiveMessage_Header::_internal_subtitle() const { + return _impl_.subtitle_.Get(); +} +inline void Message_InteractiveMessage_Header::_internal_set_subtitle(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.subtitle_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_InteractiveMessage_Header::_internal_mutable_subtitle() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.subtitle_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_InteractiveMessage_Header::release_subtitle() { + // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Header.subtitle) + if (!_internal_has_subtitle()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.subtitle_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.subtitle_.IsDefault()) { + _impl_.subtitle_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_InteractiveMessage_Header::set_allocated_subtitle(std::string* subtitle) { + if (subtitle != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.subtitle_.SetAllocated(subtitle, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.subtitle_.IsDefault()) { + _impl_.subtitle_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.Header.subtitle) +} + +// optional bool hasMediaAttachment = 5; +inline bool Message_InteractiveMessage_Header::_internal_has_hasmediaattachment() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Message_InteractiveMessage_Header::has_hasmediaattachment() const { + return _internal_has_hasmediaattachment(); +} +inline void Message_InteractiveMessage_Header::clear_hasmediaattachment() { + _impl_.hasmediaattachment_ = false; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline bool Message_InteractiveMessage_Header::_internal_hasmediaattachment() const { + return _impl_.hasmediaattachment_; +} +inline bool Message_InteractiveMessage_Header::hasmediaattachment() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Header.hasMediaAttachment) + return _internal_hasmediaattachment(); +} +inline void Message_InteractiveMessage_Header::_internal_set_hasmediaattachment(bool value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.hasmediaattachment_ = value; +} +inline void Message_InteractiveMessage_Header::set_hasmediaattachment(bool value) { + _internal_set_hasmediaattachment(value); + // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.Header.hasMediaAttachment) +} + +// .proto.Message.DocumentMessage documentMessage = 3; +inline bool Message_InteractiveMessage_Header::_internal_has_documentmessage() const { + return media_case() == kDocumentMessage; +} +inline bool Message_InteractiveMessage_Header::has_documentmessage() const { + return _internal_has_documentmessage(); +} +inline void Message_InteractiveMessage_Header::set_has_documentmessage() { + _impl_._oneof_case_[0] = kDocumentMessage; +} +inline void Message_InteractiveMessage_Header::clear_documentmessage() { + if (_internal_has_documentmessage()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.media_.documentmessage_; + } + clear_has_media(); + } +} +inline ::proto::Message_DocumentMessage* Message_InteractiveMessage_Header::release_documentmessage() { + // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Header.documentMessage) + if (_internal_has_documentmessage()) { + clear_has_media(); + ::proto::Message_DocumentMessage* temp = _impl_.media_.documentmessage_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.media_.documentmessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::Message_DocumentMessage& Message_InteractiveMessage_Header::_internal_documentmessage() const { + return _internal_has_documentmessage() + ? *_impl_.media_.documentmessage_ + : reinterpret_cast< ::proto::Message_DocumentMessage&>(::proto::_Message_DocumentMessage_default_instance_); +} +inline const ::proto::Message_DocumentMessage& Message_InteractiveMessage_Header::documentmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Header.documentMessage) + return _internal_documentmessage(); +} +inline ::proto::Message_DocumentMessage* Message_InteractiveMessage_Header::unsafe_arena_release_documentmessage() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.InteractiveMessage.Header.documentMessage) + if (_internal_has_documentmessage()) { + clear_has_media(); + ::proto::Message_DocumentMessage* temp = _impl_.media_.documentmessage_; + _impl_.media_.documentmessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Message_InteractiveMessage_Header::unsafe_arena_set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) { + clear_media(); + if (documentmessage) { + set_has_documentmessage(); + _impl_.media_.documentmessage_ = documentmessage; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.Header.documentMessage) +} +inline ::proto::Message_DocumentMessage* Message_InteractiveMessage_Header::_internal_mutable_documentmessage() { + if (!_internal_has_documentmessage()) { + clear_media(); + set_has_documentmessage(); + _impl_.media_.documentmessage_ = CreateMaybeMessage< ::proto::Message_DocumentMessage >(GetArenaForAllocation()); + } + return _impl_.media_.documentmessage_; +} +inline ::proto::Message_DocumentMessage* Message_InteractiveMessage_Header::mutable_documentmessage() { + ::proto::Message_DocumentMessage* _msg = _internal_mutable_documentmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Header.documentMessage) + return _msg; +} + +// .proto.Message.ImageMessage imageMessage = 4; +inline bool Message_InteractiveMessage_Header::_internal_has_imagemessage() const { + return media_case() == kImageMessage; +} +inline bool Message_InteractiveMessage_Header::has_imagemessage() const { + return _internal_has_imagemessage(); +} +inline void Message_InteractiveMessage_Header::set_has_imagemessage() { + _impl_._oneof_case_[0] = kImageMessage; +} +inline void Message_InteractiveMessage_Header::clear_imagemessage() { + if (_internal_has_imagemessage()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.media_.imagemessage_; + } + clear_has_media(); + } +} +inline ::proto::Message_ImageMessage* Message_InteractiveMessage_Header::release_imagemessage() { + // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Header.imageMessage) + if (_internal_has_imagemessage()) { + clear_has_media(); + ::proto::Message_ImageMessage* temp = _impl_.media_.imagemessage_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.media_.imagemessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::Message_ImageMessage& Message_InteractiveMessage_Header::_internal_imagemessage() const { + return _internal_has_imagemessage() + ? *_impl_.media_.imagemessage_ + : reinterpret_cast< ::proto::Message_ImageMessage&>(::proto::_Message_ImageMessage_default_instance_); +} +inline const ::proto::Message_ImageMessage& Message_InteractiveMessage_Header::imagemessage() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Header.imageMessage) + return _internal_imagemessage(); +} +inline ::proto::Message_ImageMessage* Message_InteractiveMessage_Header::unsafe_arena_release_imagemessage() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.InteractiveMessage.Header.imageMessage) + if (_internal_has_imagemessage()) { + clear_has_media(); + ::proto::Message_ImageMessage* temp = _impl_.media_.imagemessage_; + _impl_.media_.imagemessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Message_InteractiveMessage_Header::unsafe_arena_set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) { + clear_media(); + if (imagemessage) { + set_has_imagemessage(); + _impl_.media_.imagemessage_ = imagemessage; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.Header.imageMessage) +} +inline ::proto::Message_ImageMessage* Message_InteractiveMessage_Header::_internal_mutable_imagemessage() { + if (!_internal_has_imagemessage()) { + clear_media(); + set_has_imagemessage(); + _impl_.media_.imagemessage_ = CreateMaybeMessage< ::proto::Message_ImageMessage >(GetArenaForAllocation()); + } + return _impl_.media_.imagemessage_; +} +inline ::proto::Message_ImageMessage* Message_InteractiveMessage_Header::mutable_imagemessage() { + ::proto::Message_ImageMessage* _msg = _internal_mutable_imagemessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Header.imageMessage) + return _msg; +} + +// bytes jpegThumbnail = 6; +inline bool Message_InteractiveMessage_Header::_internal_has_jpegthumbnail() const { + return media_case() == kJpegThumbnail; +} +inline bool Message_InteractiveMessage_Header::has_jpegthumbnail() const { + return _internal_has_jpegthumbnail(); +} +inline void Message_InteractiveMessage_Header::set_has_jpegthumbnail() { + _impl_._oneof_case_[0] = kJpegThumbnail; +} +inline void Message_InteractiveMessage_Header::clear_jpegthumbnail() { + if (_internal_has_jpegthumbnail()) { + _impl_.media_.jpegthumbnail_.Destroy(); + clear_has_media(); + } +} +inline const std::string& Message_InteractiveMessage_Header::jpegthumbnail() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Header.jpegThumbnail) + return _internal_jpegthumbnail(); +} +template +inline void Message_InteractiveMessage_Header::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_jpegthumbnail()) { + clear_media(); + set_has_jpegthumbnail(); + _impl_.media_.jpegthumbnail_.InitDefault(); + } + _impl_.media_.jpegthumbnail_.SetBytes( static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.Header.jpegThumbnail) +} +inline std::string* Message_InteractiveMessage_Header::mutable_jpegthumbnail() { + std::string* _s = _internal_mutable_jpegthumbnail(); + // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Header.jpegThumbnail) + return _s; +} +inline const std::string& Message_InteractiveMessage_Header::_internal_jpegthumbnail() const { + if (_internal_has_jpegthumbnail()) { + return _impl_.media_.jpegthumbnail_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void Message_InteractiveMessage_Header::_internal_set_jpegthumbnail(const std::string& value) { + if (!_internal_has_jpegthumbnail()) { + clear_media(); + set_has_jpegthumbnail(); + _impl_.media_.jpegthumbnail_.InitDefault(); + } + _impl_.media_.jpegthumbnail_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_InteractiveMessage_Header::_internal_mutable_jpegthumbnail() { + if (!_internal_has_jpegthumbnail()) { + clear_media(); + set_has_jpegthumbnail(); + _impl_.media_.jpegthumbnail_.InitDefault(); + } + return _impl_.media_.jpegthumbnail_.Mutable( GetArenaForAllocation()); +} +inline std::string* Message_InteractiveMessage_Header::release_jpegthumbnail() { + // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Header.jpegThumbnail) + if (_internal_has_jpegthumbnail()) { + clear_has_media(); + return _impl_.media_.jpegthumbnail_.Release(); + } else { + return nullptr; + } +} +inline void Message_InteractiveMessage_Header::set_allocated_jpegthumbnail(std::string* jpegthumbnail) { + if (has_media()) { + clear_media(); + } + if (jpegthumbnail != nullptr) { + set_has_jpegthumbnail(); + _impl_.media_.jpegthumbnail_.InitAllocated(jpegthumbnail, GetArenaForAllocation()); + } + // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.Header.jpegThumbnail) +} + +// .proto.Message.VideoMessage videoMessage = 7; +inline bool Message_InteractiveMessage_Header::_internal_has_videomessage() const { + return media_case() == kVideoMessage; +} +inline bool Message_InteractiveMessage_Header::has_videomessage() const { + return _internal_has_videomessage(); +} +inline void Message_InteractiveMessage_Header::set_has_videomessage() { + _impl_._oneof_case_[0] = kVideoMessage; +} +inline void Message_InteractiveMessage_Header::clear_videomessage() { + if (_internal_has_videomessage()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.media_.videomessage_; + } + clear_has_media(); + } +} +inline ::proto::Message_VideoMessage* Message_InteractiveMessage_Header::release_videomessage() { + // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Header.videoMessage) + if (_internal_has_videomessage()) { + clear_has_media(); + ::proto::Message_VideoMessage* temp = _impl_.media_.videomessage_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.media_.videomessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::Message_VideoMessage& Message_InteractiveMessage_Header::_internal_videomessage() const { + return _internal_has_videomessage() + ? *_impl_.media_.videomessage_ + : reinterpret_cast< ::proto::Message_VideoMessage&>(::proto::_Message_VideoMessage_default_instance_); +} +inline const ::proto::Message_VideoMessage& Message_InteractiveMessage_Header::videomessage() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Header.videoMessage) + return _internal_videomessage(); +} +inline ::proto::Message_VideoMessage* Message_InteractiveMessage_Header::unsafe_arena_release_videomessage() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.InteractiveMessage.Header.videoMessage) + if (_internal_has_videomessage()) { + clear_has_media(); + ::proto::Message_VideoMessage* temp = _impl_.media_.videomessage_; + _impl_.media_.videomessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Message_InteractiveMessage_Header::unsafe_arena_set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) { + clear_media(); + if (videomessage) { + set_has_videomessage(); + _impl_.media_.videomessage_ = videomessage; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.Header.videoMessage) +} +inline ::proto::Message_VideoMessage* Message_InteractiveMessage_Header::_internal_mutable_videomessage() { + if (!_internal_has_videomessage()) { + clear_media(); + set_has_videomessage(); + _impl_.media_.videomessage_ = CreateMaybeMessage< ::proto::Message_VideoMessage >(GetArenaForAllocation()); + } + return _impl_.media_.videomessage_; +} +inline ::proto::Message_VideoMessage* Message_InteractiveMessage_Header::mutable_videomessage() { + ::proto::Message_VideoMessage* _msg = _internal_mutable_videomessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Header.videoMessage) + return _msg; +} + +inline bool Message_InteractiveMessage_Header::has_media() const { + return media_case() != MEDIA_NOT_SET; +} +inline void Message_InteractiveMessage_Header::clear_has_media() { + _impl_._oneof_case_[0] = MEDIA_NOT_SET; +} +inline Message_InteractiveMessage_Header::MediaCase Message_InteractiveMessage_Header::media_case() const { + return Message_InteractiveMessage_Header::MediaCase(_impl_._oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton + +// optional string name = 1; +inline bool Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_has_name() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::has_name() const { + return _internal_has_name(); +} +inline void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::clear_name() { + _impl_.name_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::name() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.name) + return _internal_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::set_name(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.name) +} +inline std::string* Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::mutable_name() { + std::string* _s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.name) + return _s; +} +inline const std::string& Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_name() const { + return _impl_.name_.Get(); +} +inline void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_set_name(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.name_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_mutable_name() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.name_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::release_name() { + // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.name) + if (!_internal_has_name()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.name_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.name_.IsDefault()) { + _impl_.name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::set_allocated_name(std::string* name) { + if (name != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.name_.SetAllocated(name, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.name_.IsDefault()) { + _impl_.name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.name) +} + +// optional string buttonParamsJson = 2; +inline bool Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_has_buttonparamsjson() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::has_buttonparamsjson() const { + return _internal_has_buttonparamsjson(); +} +inline void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::clear_buttonparamsjson() { + _impl_.buttonparamsjson_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::buttonparamsjson() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.buttonParamsJson) + return _internal_buttonparamsjson(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::set_buttonparamsjson(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.buttonparamsjson_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.buttonParamsJson) +} +inline std::string* Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::mutable_buttonparamsjson() { + std::string* _s = _internal_mutable_buttonparamsjson(); + // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.buttonParamsJson) + return _s; +} +inline const std::string& Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_buttonparamsjson() const { + return _impl_.buttonparamsjson_.Get(); +} +inline void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_set_buttonparamsjson(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.buttonparamsjson_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_mutable_buttonparamsjson() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.buttonparamsjson_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::release_buttonparamsjson() { + // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.buttonParamsJson) + if (!_internal_has_buttonparamsjson()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.buttonparamsjson_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.buttonparamsjson_.IsDefault()) { + _impl_.buttonparamsjson_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::set_allocated_buttonparamsjson(std::string* buttonparamsjson) { + if (buttonparamsjson != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.buttonparamsjson_.SetAllocated(buttonparamsjson, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.buttonparamsjson_.IsDefault()) { + _impl_.buttonparamsjson_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.buttonParamsJson) +} + +// ------------------------------------------------------------------- + +// Message_InteractiveMessage_NativeFlowMessage + +// repeated .proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton buttons = 1; +inline int Message_InteractiveMessage_NativeFlowMessage::_internal_buttons_size() const { + return _impl_.buttons_.size(); +} +inline int Message_InteractiveMessage_NativeFlowMessage::buttons_size() const { + return _internal_buttons_size(); +} +inline void Message_InteractiveMessage_NativeFlowMessage::clear_buttons() { + _impl_.buttons_.Clear(); +} +inline ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* Message_InteractiveMessage_NativeFlowMessage::mutable_buttons(int index) { + // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.NativeFlowMessage.buttons) + return _impl_.buttons_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton >* +Message_InteractiveMessage_NativeFlowMessage::mutable_buttons() { + // @@protoc_insertion_point(field_mutable_list:proto.Message.InteractiveMessage.NativeFlowMessage.buttons) + return &_impl_.buttons_; +} +inline const ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& Message_InteractiveMessage_NativeFlowMessage::_internal_buttons(int index) const { + return _impl_.buttons_.Get(index); +} +inline const ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& Message_InteractiveMessage_NativeFlowMessage::buttons(int index) const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.NativeFlowMessage.buttons) + return _internal_buttons(index); +} +inline ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* Message_InteractiveMessage_NativeFlowMessage::_internal_add_buttons() { + return _impl_.buttons_.Add(); +} +inline ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* Message_InteractiveMessage_NativeFlowMessage::add_buttons() { + ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* _add = _internal_add_buttons(); + // @@protoc_insertion_point(field_add:proto.Message.InteractiveMessage.NativeFlowMessage.buttons) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton >& +Message_InteractiveMessage_NativeFlowMessage::buttons() const { + // @@protoc_insertion_point(field_list:proto.Message.InteractiveMessage.NativeFlowMessage.buttons) + return _impl_.buttons_; +} + +// optional string messageParamsJson = 2; +inline bool Message_InteractiveMessage_NativeFlowMessage::_internal_has_messageparamsjson() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_InteractiveMessage_NativeFlowMessage::has_messageparamsjson() const { + return _internal_has_messageparamsjson(); +} +inline void Message_InteractiveMessage_NativeFlowMessage::clear_messageparamsjson() { + _impl_.messageparamsjson_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_InteractiveMessage_NativeFlowMessage::messageparamsjson() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.NativeFlowMessage.messageParamsJson) + return _internal_messageparamsjson(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_InteractiveMessage_NativeFlowMessage::set_messageparamsjson(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.messageparamsjson_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.NativeFlowMessage.messageParamsJson) +} +inline std::string* Message_InteractiveMessage_NativeFlowMessage::mutable_messageparamsjson() { + std::string* _s = _internal_mutable_messageparamsjson(); + // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.NativeFlowMessage.messageParamsJson) + return _s; +} +inline const std::string& Message_InteractiveMessage_NativeFlowMessage::_internal_messageparamsjson() const { + return _impl_.messageparamsjson_.Get(); +} +inline void Message_InteractiveMessage_NativeFlowMessage::_internal_set_messageparamsjson(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.messageparamsjson_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_InteractiveMessage_NativeFlowMessage::_internal_mutable_messageparamsjson() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.messageparamsjson_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_InteractiveMessage_NativeFlowMessage::release_messageparamsjson() { + // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.NativeFlowMessage.messageParamsJson) + if (!_internal_has_messageparamsjson()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.messageparamsjson_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.messageparamsjson_.IsDefault()) { + _impl_.messageparamsjson_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_InteractiveMessage_NativeFlowMessage::set_allocated_messageparamsjson(std::string* messageparamsjson) { + if (messageparamsjson != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.messageparamsjson_.SetAllocated(messageparamsjson, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.messageparamsjson_.IsDefault()) { + _impl_.messageparamsjson_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.NativeFlowMessage.messageParamsJson) +} + +// optional int32 messageVersion = 3; +inline bool Message_InteractiveMessage_NativeFlowMessage::_internal_has_messageversion() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_InteractiveMessage_NativeFlowMessage::has_messageversion() const { + return _internal_has_messageversion(); +} +inline void Message_InteractiveMessage_NativeFlowMessage::clear_messageversion() { + _impl_.messageversion_ = 0; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline int32_t Message_InteractiveMessage_NativeFlowMessage::_internal_messageversion() const { + return _impl_.messageversion_; +} +inline int32_t Message_InteractiveMessage_NativeFlowMessage::messageversion() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.NativeFlowMessage.messageVersion) + return _internal_messageversion(); +} +inline void Message_InteractiveMessage_NativeFlowMessage::_internal_set_messageversion(int32_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.messageversion_ = value; +} +inline void Message_InteractiveMessage_NativeFlowMessage::set_messageversion(int32_t value) { + _internal_set_messageversion(value); + // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.NativeFlowMessage.messageVersion) +} + +// ------------------------------------------------------------------- + +// Message_InteractiveMessage_ShopMessage + +// optional string id = 1; +inline bool Message_InteractiveMessage_ShopMessage::_internal_has_id() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_InteractiveMessage_ShopMessage::has_id() const { + return _internal_has_id(); +} +inline void Message_InteractiveMessage_ShopMessage::clear_id() { + _impl_.id_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_InteractiveMessage_ShopMessage::id() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.ShopMessage.id) + return _internal_id(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_InteractiveMessage_ShopMessage::set_id(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.id_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.ShopMessage.id) +} +inline std::string* Message_InteractiveMessage_ShopMessage::mutable_id() { + std::string* _s = _internal_mutable_id(); + // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.ShopMessage.id) + return _s; +} +inline const std::string& Message_InteractiveMessage_ShopMessage::_internal_id() const { + return _impl_.id_.Get(); +} +inline void Message_InteractiveMessage_ShopMessage::_internal_set_id(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.id_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_InteractiveMessage_ShopMessage::_internal_mutable_id() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.id_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_InteractiveMessage_ShopMessage::release_id() { + // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.ShopMessage.id) + if (!_internal_has_id()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.id_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.id_.IsDefault()) { + _impl_.id_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_InteractiveMessage_ShopMessage::set_allocated_id(std::string* id) { + if (id != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.id_.SetAllocated(id, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.id_.IsDefault()) { + _impl_.id_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.ShopMessage.id) +} + +// optional .proto.Message.InteractiveMessage.ShopMessage.Surface surface = 2; +inline bool Message_InteractiveMessage_ShopMessage::_internal_has_surface() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_InteractiveMessage_ShopMessage::has_surface() const { + return _internal_has_surface(); +} +inline void Message_InteractiveMessage_ShopMessage::clear_surface() { + _impl_.surface_ = 0; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline ::proto::Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage::_internal_surface() const { + return static_cast< ::proto::Message_InteractiveMessage_ShopMessage_Surface >(_impl_.surface_); +} +inline ::proto::Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage::surface() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.ShopMessage.surface) + return _internal_surface(); +} +inline void Message_InteractiveMessage_ShopMessage::_internal_set_surface(::proto::Message_InteractiveMessage_ShopMessage_Surface value) { + assert(::proto::Message_InteractiveMessage_ShopMessage_Surface_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.surface_ = value; +} +inline void Message_InteractiveMessage_ShopMessage::set_surface(::proto::Message_InteractiveMessage_ShopMessage_Surface value) { + _internal_set_surface(value); + // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.ShopMessage.surface) +} + +// optional int32 messageVersion = 3; +inline bool Message_InteractiveMessage_ShopMessage::_internal_has_messageversion() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Message_InteractiveMessage_ShopMessage::has_messageversion() const { + return _internal_has_messageversion(); +} +inline void Message_InteractiveMessage_ShopMessage::clear_messageversion() { + _impl_.messageversion_ = 0; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline int32_t Message_InteractiveMessage_ShopMessage::_internal_messageversion() const { + return _impl_.messageversion_; +} +inline int32_t Message_InteractiveMessage_ShopMessage::messageversion() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.ShopMessage.messageVersion) + return _internal_messageversion(); +} +inline void Message_InteractiveMessage_ShopMessage::_internal_set_messageversion(int32_t value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.messageversion_ = value; +} +inline void Message_InteractiveMessage_ShopMessage::set_messageversion(int32_t value) { + _internal_set_messageversion(value); + // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.ShopMessage.messageVersion) +} + +// ------------------------------------------------------------------- + +// Message_InteractiveMessage + +// optional .proto.Message.InteractiveMessage.Header header = 1; +inline bool Message_InteractiveMessage::_internal_has_header() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.header_ != nullptr); + return value; +} +inline bool Message_InteractiveMessage::has_header() const { + return _internal_has_header(); +} +inline void Message_InteractiveMessage::clear_header() { + if (_impl_.header_ != nullptr) _impl_.header_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::Message_InteractiveMessage_Header& Message_InteractiveMessage::_internal_header() const { + const ::proto::Message_InteractiveMessage_Header* p = _impl_.header_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_InteractiveMessage_Header_default_instance_); +} +inline const ::proto::Message_InteractiveMessage_Header& Message_InteractiveMessage::header() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.header) + return _internal_header(); +} +inline void Message_InteractiveMessage::unsafe_arena_set_allocated_header( + ::proto::Message_InteractiveMessage_Header* header) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.header_); + } + _impl_.header_ = header; + if (header) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.header) +} +inline ::proto::Message_InteractiveMessage_Header* Message_InteractiveMessage::release_header() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::Message_InteractiveMessage_Header* temp = _impl_.header_; + _impl_.header_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_InteractiveMessage_Header* Message_InteractiveMessage::unsafe_arena_release_header() { + // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.header) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::Message_InteractiveMessage_Header* temp = _impl_.header_; + _impl_.header_ = nullptr; + return temp; +} +inline ::proto::Message_InteractiveMessage_Header* Message_InteractiveMessage::_internal_mutable_header() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.header_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_InteractiveMessage_Header>(GetArenaForAllocation()); + _impl_.header_ = p; + } + return _impl_.header_; +} +inline ::proto::Message_InteractiveMessage_Header* Message_InteractiveMessage::mutable_header() { + ::proto::Message_InteractiveMessage_Header* _msg = _internal_mutable_header(); + // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.header) + return _msg; +} +inline void Message_InteractiveMessage::set_allocated_header(::proto::Message_InteractiveMessage_Header* header) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.header_; + } + if (header) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(header); + if (message_arena != submessage_arena) { + header = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, header, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.header_ = header; + // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.header) +} + +// optional .proto.Message.InteractiveMessage.Body body = 2; +inline bool Message_InteractiveMessage::_internal_has_body() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.body_ != nullptr); + return value; +} +inline bool Message_InteractiveMessage::has_body() const { + return _internal_has_body(); +} +inline void Message_InteractiveMessage::clear_body() { + if (_impl_.body_ != nullptr) _impl_.body_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::Message_InteractiveMessage_Body& Message_InteractiveMessage::_internal_body() const { + const ::proto::Message_InteractiveMessage_Body* p = _impl_.body_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_InteractiveMessage_Body_default_instance_); +} +inline const ::proto::Message_InteractiveMessage_Body& Message_InteractiveMessage::body() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.body) + return _internal_body(); +} +inline void Message_InteractiveMessage::unsafe_arena_set_allocated_body( + ::proto::Message_InteractiveMessage_Body* body) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.body_); + } + _impl_.body_ = body; + if (body) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.body) +} +inline ::proto::Message_InteractiveMessage_Body* Message_InteractiveMessage::release_body() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::Message_InteractiveMessage_Body* temp = _impl_.body_; + _impl_.body_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_InteractiveMessage_Body* Message_InteractiveMessage::unsafe_arena_release_body() { + // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.body) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::Message_InteractiveMessage_Body* temp = _impl_.body_; + _impl_.body_ = nullptr; + return temp; +} +inline ::proto::Message_InteractiveMessage_Body* Message_InteractiveMessage::_internal_mutable_body() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.body_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_InteractiveMessage_Body>(GetArenaForAllocation()); + _impl_.body_ = p; + } + return _impl_.body_; +} +inline ::proto::Message_InteractiveMessage_Body* Message_InteractiveMessage::mutable_body() { + ::proto::Message_InteractiveMessage_Body* _msg = _internal_mutable_body(); + // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.body) + return _msg; +} +inline void Message_InteractiveMessage::set_allocated_body(::proto::Message_InteractiveMessage_Body* body) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.body_; + } + if (body) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(body); + if (message_arena != submessage_arena) { + body = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, body, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.body_ = body; + // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.body) +} + +// optional .proto.Message.InteractiveMessage.Footer footer = 3; +inline bool Message_InteractiveMessage::_internal_has_footer() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.footer_ != nullptr); + return value; +} +inline bool Message_InteractiveMessage::has_footer() const { + return _internal_has_footer(); +} +inline void Message_InteractiveMessage::clear_footer() { + if (_impl_.footer_ != nullptr) _impl_.footer_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::proto::Message_InteractiveMessage_Footer& Message_InteractiveMessage::_internal_footer() const { + const ::proto::Message_InteractiveMessage_Footer* p = _impl_.footer_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_InteractiveMessage_Footer_default_instance_); +} +inline const ::proto::Message_InteractiveMessage_Footer& Message_InteractiveMessage::footer() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.footer) + return _internal_footer(); +} +inline void Message_InteractiveMessage::unsafe_arena_set_allocated_footer( + ::proto::Message_InteractiveMessage_Footer* footer) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.footer_); + } + _impl_.footer_ = footer; + if (footer) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.footer) +} +inline ::proto::Message_InteractiveMessage_Footer* Message_InteractiveMessage::release_footer() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::Message_InteractiveMessage_Footer* temp = _impl_.footer_; + _impl_.footer_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_InteractiveMessage_Footer* Message_InteractiveMessage::unsafe_arena_release_footer() { + // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.footer) + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::Message_InteractiveMessage_Footer* temp = _impl_.footer_; + _impl_.footer_ = nullptr; + return temp; +} +inline ::proto::Message_InteractiveMessage_Footer* Message_InteractiveMessage::_internal_mutable_footer() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.footer_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_InteractiveMessage_Footer>(GetArenaForAllocation()); + _impl_.footer_ = p; + } + return _impl_.footer_; +} +inline ::proto::Message_InteractiveMessage_Footer* Message_InteractiveMessage::mutable_footer() { + ::proto::Message_InteractiveMessage_Footer* _msg = _internal_mutable_footer(); + // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.footer) + return _msg; +} +inline void Message_InteractiveMessage::set_allocated_footer(::proto::Message_InteractiveMessage_Footer* footer) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.footer_; + } + if (footer) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(footer); + if (message_arena != submessage_arena) { + footer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, footer, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.footer_ = footer; + // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.footer) +} + +// optional .proto.ContextInfo contextInfo = 15; +inline bool Message_InteractiveMessage::_internal_has_contextinfo() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); + return value; +} +inline bool Message_InteractiveMessage::has_contextinfo() const { + return _internal_has_contextinfo(); +} +inline void Message_InteractiveMessage::clear_contextinfo() { + if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const ::proto::ContextInfo& Message_InteractiveMessage::_internal_contextinfo() const { + const ::proto::ContextInfo* p = _impl_.contextinfo_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ContextInfo_default_instance_); +} +inline const ::proto::ContextInfo& Message_InteractiveMessage::contextinfo() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.contextInfo) + return _internal_contextinfo(); +} +inline void Message_InteractiveMessage::unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); + } + _impl_.contextinfo_ = contextinfo; + if (contextinfo) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.contextInfo) +} +inline ::proto::ContextInfo* Message_InteractiveMessage::release_contextinfo() { + _impl_._has_bits_[0] &= ~0x00000008u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ContextInfo* Message_InteractiveMessage::unsafe_arena_release_contextinfo() { + // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.contextInfo) + _impl_._has_bits_[0] &= ~0x00000008u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; + return temp; +} +inline ::proto::ContextInfo* Message_InteractiveMessage::_internal_mutable_contextinfo() { + _impl_._has_bits_[0] |= 0x00000008u; + if (_impl_.contextinfo_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); + _impl_.contextinfo_ = p; + } + return _impl_.contextinfo_; +} +inline ::proto::ContextInfo* Message_InteractiveMessage::mutable_contextinfo() { + ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); + // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.contextInfo) + return _msg; +} +inline void Message_InteractiveMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.contextinfo_; + } + if (contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); + if (message_arena != submessage_arena) { + contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, contextinfo, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.contextinfo_ = contextinfo; + // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.contextInfo) +} + +// .proto.Message.InteractiveMessage.ShopMessage shopStorefrontMessage = 4; +inline bool Message_InteractiveMessage::_internal_has_shopstorefrontmessage() const { + return interactiveMessage_case() == kShopStorefrontMessage; +} +inline bool Message_InteractiveMessage::has_shopstorefrontmessage() const { + return _internal_has_shopstorefrontmessage(); +} +inline void Message_InteractiveMessage::set_has_shopstorefrontmessage() { + _impl_._oneof_case_[0] = kShopStorefrontMessage; +} +inline void Message_InteractiveMessage::clear_shopstorefrontmessage() { + if (_internal_has_shopstorefrontmessage()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.interactiveMessage_.shopstorefrontmessage_; + } + clear_has_interactiveMessage(); + } +} +inline ::proto::Message_InteractiveMessage_ShopMessage* Message_InteractiveMessage::release_shopstorefrontmessage() { + // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.shopStorefrontMessage) + if (_internal_has_shopstorefrontmessage()) { + clear_has_interactiveMessage(); + ::proto::Message_InteractiveMessage_ShopMessage* temp = _impl_.interactiveMessage_.shopstorefrontmessage_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.interactiveMessage_.shopstorefrontmessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::Message_InteractiveMessage_ShopMessage& Message_InteractiveMessage::_internal_shopstorefrontmessage() const { + return _internal_has_shopstorefrontmessage() + ? *_impl_.interactiveMessage_.shopstorefrontmessage_ + : reinterpret_cast< ::proto::Message_InteractiveMessage_ShopMessage&>(::proto::_Message_InteractiveMessage_ShopMessage_default_instance_); +} +inline const ::proto::Message_InteractiveMessage_ShopMessage& Message_InteractiveMessage::shopstorefrontmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.shopStorefrontMessage) + return _internal_shopstorefrontmessage(); +} +inline ::proto::Message_InteractiveMessage_ShopMessage* Message_InteractiveMessage::unsafe_arena_release_shopstorefrontmessage() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.InteractiveMessage.shopStorefrontMessage) + if (_internal_has_shopstorefrontmessage()) { + clear_has_interactiveMessage(); + ::proto::Message_InteractiveMessage_ShopMessage* temp = _impl_.interactiveMessage_.shopstorefrontmessage_; + _impl_.interactiveMessage_.shopstorefrontmessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Message_InteractiveMessage::unsafe_arena_set_allocated_shopstorefrontmessage(::proto::Message_InteractiveMessage_ShopMessage* shopstorefrontmessage) { + clear_interactiveMessage(); + if (shopstorefrontmessage) { + set_has_shopstorefrontmessage(); + _impl_.interactiveMessage_.shopstorefrontmessage_ = shopstorefrontmessage; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.shopStorefrontMessage) +} +inline ::proto::Message_InteractiveMessage_ShopMessage* Message_InteractiveMessage::_internal_mutable_shopstorefrontmessage() { + if (!_internal_has_shopstorefrontmessage()) { + clear_interactiveMessage(); + set_has_shopstorefrontmessage(); + _impl_.interactiveMessage_.shopstorefrontmessage_ = CreateMaybeMessage< ::proto::Message_InteractiveMessage_ShopMessage >(GetArenaForAllocation()); + } + return _impl_.interactiveMessage_.shopstorefrontmessage_; +} +inline ::proto::Message_InteractiveMessage_ShopMessage* Message_InteractiveMessage::mutable_shopstorefrontmessage() { + ::proto::Message_InteractiveMessage_ShopMessage* _msg = _internal_mutable_shopstorefrontmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.shopStorefrontMessage) + return _msg; +} + +// .proto.Message.InteractiveMessage.CollectionMessage collectionMessage = 5; +inline bool Message_InteractiveMessage::_internal_has_collectionmessage() const { + return interactiveMessage_case() == kCollectionMessage; +} +inline bool Message_InteractiveMessage::has_collectionmessage() const { + return _internal_has_collectionmessage(); +} +inline void Message_InteractiveMessage::set_has_collectionmessage() { + _impl_._oneof_case_[0] = kCollectionMessage; +} +inline void Message_InteractiveMessage::clear_collectionmessage() { + if (_internal_has_collectionmessage()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.interactiveMessage_.collectionmessage_; + } + clear_has_interactiveMessage(); + } +} +inline ::proto::Message_InteractiveMessage_CollectionMessage* Message_InteractiveMessage::release_collectionmessage() { + // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.collectionMessage) + if (_internal_has_collectionmessage()) { + clear_has_interactiveMessage(); + ::proto::Message_InteractiveMessage_CollectionMessage* temp = _impl_.interactiveMessage_.collectionmessage_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.interactiveMessage_.collectionmessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::Message_InteractiveMessage_CollectionMessage& Message_InteractiveMessage::_internal_collectionmessage() const { + return _internal_has_collectionmessage() + ? *_impl_.interactiveMessage_.collectionmessage_ + : reinterpret_cast< ::proto::Message_InteractiveMessage_CollectionMessage&>(::proto::_Message_InteractiveMessage_CollectionMessage_default_instance_); +} +inline const ::proto::Message_InteractiveMessage_CollectionMessage& Message_InteractiveMessage::collectionmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.collectionMessage) + return _internal_collectionmessage(); +} +inline ::proto::Message_InteractiveMessage_CollectionMessage* Message_InteractiveMessage::unsafe_arena_release_collectionmessage() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.InteractiveMessage.collectionMessage) + if (_internal_has_collectionmessage()) { + clear_has_interactiveMessage(); + ::proto::Message_InteractiveMessage_CollectionMessage* temp = _impl_.interactiveMessage_.collectionmessage_; + _impl_.interactiveMessage_.collectionmessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Message_InteractiveMessage::unsafe_arena_set_allocated_collectionmessage(::proto::Message_InteractiveMessage_CollectionMessage* collectionmessage) { + clear_interactiveMessage(); + if (collectionmessage) { + set_has_collectionmessage(); + _impl_.interactiveMessage_.collectionmessage_ = collectionmessage; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.collectionMessage) +} +inline ::proto::Message_InteractiveMessage_CollectionMessage* Message_InteractiveMessage::_internal_mutable_collectionmessage() { + if (!_internal_has_collectionmessage()) { + clear_interactiveMessage(); + set_has_collectionmessage(); + _impl_.interactiveMessage_.collectionmessage_ = CreateMaybeMessage< ::proto::Message_InteractiveMessage_CollectionMessage >(GetArenaForAllocation()); + } + return _impl_.interactiveMessage_.collectionmessage_; +} +inline ::proto::Message_InteractiveMessage_CollectionMessage* Message_InteractiveMessage::mutable_collectionmessage() { + ::proto::Message_InteractiveMessage_CollectionMessage* _msg = _internal_mutable_collectionmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.collectionMessage) + return _msg; +} + +// .proto.Message.InteractiveMessage.NativeFlowMessage nativeFlowMessage = 6; +inline bool Message_InteractiveMessage::_internal_has_nativeflowmessage() const { + return interactiveMessage_case() == kNativeFlowMessage; +} +inline bool Message_InteractiveMessage::has_nativeflowmessage() const { + return _internal_has_nativeflowmessage(); +} +inline void Message_InteractiveMessage::set_has_nativeflowmessage() { + _impl_._oneof_case_[0] = kNativeFlowMessage; +} +inline void Message_InteractiveMessage::clear_nativeflowmessage() { + if (_internal_has_nativeflowmessage()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.interactiveMessage_.nativeflowmessage_; + } + clear_has_interactiveMessage(); + } +} +inline ::proto::Message_InteractiveMessage_NativeFlowMessage* Message_InteractiveMessage::release_nativeflowmessage() { + // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.nativeFlowMessage) + if (_internal_has_nativeflowmessage()) { + clear_has_interactiveMessage(); + ::proto::Message_InteractiveMessage_NativeFlowMessage* temp = _impl_.interactiveMessage_.nativeflowmessage_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.interactiveMessage_.nativeflowmessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::Message_InteractiveMessage_NativeFlowMessage& Message_InteractiveMessage::_internal_nativeflowmessage() const { + return _internal_has_nativeflowmessage() + ? *_impl_.interactiveMessage_.nativeflowmessage_ + : reinterpret_cast< ::proto::Message_InteractiveMessage_NativeFlowMessage&>(::proto::_Message_InteractiveMessage_NativeFlowMessage_default_instance_); +} +inline const ::proto::Message_InteractiveMessage_NativeFlowMessage& Message_InteractiveMessage::nativeflowmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.nativeFlowMessage) + return _internal_nativeflowmessage(); +} +inline ::proto::Message_InteractiveMessage_NativeFlowMessage* Message_InteractiveMessage::unsafe_arena_release_nativeflowmessage() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.InteractiveMessage.nativeFlowMessage) + if (_internal_has_nativeflowmessage()) { + clear_has_interactiveMessage(); + ::proto::Message_InteractiveMessage_NativeFlowMessage* temp = _impl_.interactiveMessage_.nativeflowmessage_; + _impl_.interactiveMessage_.nativeflowmessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Message_InteractiveMessage::unsafe_arena_set_allocated_nativeflowmessage(::proto::Message_InteractiveMessage_NativeFlowMessage* nativeflowmessage) { + clear_interactiveMessage(); + if (nativeflowmessage) { + set_has_nativeflowmessage(); + _impl_.interactiveMessage_.nativeflowmessage_ = nativeflowmessage; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.nativeFlowMessage) +} +inline ::proto::Message_InteractiveMessage_NativeFlowMessage* Message_InteractiveMessage::_internal_mutable_nativeflowmessage() { + if (!_internal_has_nativeflowmessage()) { + clear_interactiveMessage(); + set_has_nativeflowmessage(); + _impl_.interactiveMessage_.nativeflowmessage_ = CreateMaybeMessage< ::proto::Message_InteractiveMessage_NativeFlowMessage >(GetArenaForAllocation()); + } + return _impl_.interactiveMessage_.nativeflowmessage_; +} +inline ::proto::Message_InteractiveMessage_NativeFlowMessage* Message_InteractiveMessage::mutable_nativeflowmessage() { + ::proto::Message_InteractiveMessage_NativeFlowMessage* _msg = _internal_mutable_nativeflowmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.nativeFlowMessage) + return _msg; +} + +inline bool Message_InteractiveMessage::has_interactiveMessage() const { + return interactiveMessage_case() != INTERACTIVEMESSAGE_NOT_SET; +} +inline void Message_InteractiveMessage::clear_has_interactiveMessage() { + _impl_._oneof_case_[0] = INTERACTIVEMESSAGE_NOT_SET; +} +inline Message_InteractiveMessage::InteractiveMessageCase Message_InteractiveMessage::interactiveMessage_case() const { + return Message_InteractiveMessage::InteractiveMessageCase(_impl_._oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// Message_InteractiveResponseMessage_Body + +// optional string text = 1; +inline bool Message_InteractiveResponseMessage_Body::_internal_has_text() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_InteractiveResponseMessage_Body::has_text() const { + return _internal_has_text(); +} +inline void Message_InteractiveResponseMessage_Body::clear_text() { + _impl_.text_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_InteractiveResponseMessage_Body::text() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveResponseMessage.Body.text) + return _internal_text(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_InteractiveResponseMessage_Body::set_text(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.text_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.InteractiveResponseMessage.Body.text) +} +inline std::string* Message_InteractiveResponseMessage_Body::mutable_text() { + std::string* _s = _internal_mutable_text(); + // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveResponseMessage.Body.text) + return _s; +} +inline const std::string& Message_InteractiveResponseMessage_Body::_internal_text() const { + return _impl_.text_.Get(); +} +inline void Message_InteractiveResponseMessage_Body::_internal_set_text(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.text_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_InteractiveResponseMessage_Body::_internal_mutable_text() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.text_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_InteractiveResponseMessage_Body::release_text() { + // @@protoc_insertion_point(field_release:proto.Message.InteractiveResponseMessage.Body.text) + if (!_internal_has_text()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.text_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.text_.IsDefault()) { + _impl_.text_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_InteractiveResponseMessage_Body::set_allocated_text(std::string* text) { + if (text != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.text_.SetAllocated(text, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.text_.IsDefault()) { + _impl_.text_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveResponseMessage.Body.text) +} + +// ------------------------------------------------------------------- + +// Message_InteractiveResponseMessage_NativeFlowResponseMessage + +// optional string name = 1; +inline bool Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_has_name() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_InteractiveResponseMessage_NativeFlowResponseMessage::has_name() const { + return _internal_has_name(); +} +inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::clear_name() { + _impl_.name_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_InteractiveResponseMessage_NativeFlowResponseMessage::name() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.name) + return _internal_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_InteractiveResponseMessage_NativeFlowResponseMessage::set_name(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.name) +} +inline std::string* Message_InteractiveResponseMessage_NativeFlowResponseMessage::mutable_name() { + std::string* _s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.name) + return _s; +} +inline const std::string& Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_name() const { + return _impl_.name_.Get(); +} +inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_set_name(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.name_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_mutable_name() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.name_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_InteractiveResponseMessage_NativeFlowResponseMessage::release_name() { + // @@protoc_insertion_point(field_release:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.name) + if (!_internal_has_name()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.name_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.name_.IsDefault()) { + _impl_.name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::set_allocated_name(std::string* name) { + if (name != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.name_.SetAllocated(name, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.name_.IsDefault()) { + _impl_.name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.name) +} + +// optional string paramsJson = 2; +inline bool Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_has_paramsjson() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_InteractiveResponseMessage_NativeFlowResponseMessage::has_paramsjson() const { + return _internal_has_paramsjson(); +} +inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::clear_paramsjson() { + _impl_.paramsjson_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_InteractiveResponseMessage_NativeFlowResponseMessage::paramsjson() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.paramsJson) + return _internal_paramsjson(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_InteractiveResponseMessage_NativeFlowResponseMessage::set_paramsjson(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.paramsjson_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.paramsJson) +} +inline std::string* Message_InteractiveResponseMessage_NativeFlowResponseMessage::mutable_paramsjson() { + std::string* _s = _internal_mutable_paramsjson(); + // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.paramsJson) + return _s; +} +inline const std::string& Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_paramsjson() const { + return _impl_.paramsjson_.Get(); +} +inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_set_paramsjson(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.paramsjson_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_mutable_paramsjson() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.paramsjson_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_InteractiveResponseMessage_NativeFlowResponseMessage::release_paramsjson() { + // @@protoc_insertion_point(field_release:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.paramsJson) + if (!_internal_has_paramsjson()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.paramsjson_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.paramsjson_.IsDefault()) { + _impl_.paramsjson_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::set_allocated_paramsjson(std::string* paramsjson) { + if (paramsjson != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.paramsjson_.SetAllocated(paramsjson, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.paramsjson_.IsDefault()) { + _impl_.paramsjson_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.paramsJson) +} + +// optional int32 version = 3; +inline bool Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_has_version() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Message_InteractiveResponseMessage_NativeFlowResponseMessage::has_version() const { + return _internal_has_version(); +} +inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::clear_version() { + _impl_.version_ = 0; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline int32_t Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_version() const { + return _impl_.version_; +} +inline int32_t Message_InteractiveResponseMessage_NativeFlowResponseMessage::version() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.version) + return _internal_version(); +} +inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_set_version(int32_t value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.version_ = value; +} +inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::set_version(int32_t value) { + _internal_set_version(value); + // @@protoc_insertion_point(field_set:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.version) +} + +// ------------------------------------------------------------------- + +// Message_InteractiveResponseMessage + +// optional .proto.Message.InteractiveResponseMessage.Body body = 1; +inline bool Message_InteractiveResponseMessage::_internal_has_body() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.body_ != nullptr); + return value; +} +inline bool Message_InteractiveResponseMessage::has_body() const { + return _internal_has_body(); +} +inline void Message_InteractiveResponseMessage::clear_body() { + if (_impl_.body_ != nullptr) _impl_.body_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::Message_InteractiveResponseMessage_Body& Message_InteractiveResponseMessage::_internal_body() const { + const ::proto::Message_InteractiveResponseMessage_Body* p = _impl_.body_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_InteractiveResponseMessage_Body_default_instance_); +} +inline const ::proto::Message_InteractiveResponseMessage_Body& Message_InteractiveResponseMessage::body() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveResponseMessage.body) + return _internal_body(); +} +inline void Message_InteractiveResponseMessage::unsafe_arena_set_allocated_body( + ::proto::Message_InteractiveResponseMessage_Body* body) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.body_); + } + _impl_.body_ = body; + if (body) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveResponseMessage.body) +} +inline ::proto::Message_InteractiveResponseMessage_Body* Message_InteractiveResponseMessage::release_body() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::Message_InteractiveResponseMessage_Body* temp = _impl_.body_; + _impl_.body_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_InteractiveResponseMessage_Body* Message_InteractiveResponseMessage::unsafe_arena_release_body() { + // @@protoc_insertion_point(field_release:proto.Message.InteractiveResponseMessage.body) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::Message_InteractiveResponseMessage_Body* temp = _impl_.body_; + _impl_.body_ = nullptr; + return temp; +} +inline ::proto::Message_InteractiveResponseMessage_Body* Message_InteractiveResponseMessage::_internal_mutable_body() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.body_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_InteractiveResponseMessage_Body>(GetArenaForAllocation()); + _impl_.body_ = p; + } + return _impl_.body_; +} +inline ::proto::Message_InteractiveResponseMessage_Body* Message_InteractiveResponseMessage::mutable_body() { + ::proto::Message_InteractiveResponseMessage_Body* _msg = _internal_mutable_body(); + // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveResponseMessage.body) + return _msg; +} +inline void Message_InteractiveResponseMessage::set_allocated_body(::proto::Message_InteractiveResponseMessage_Body* body) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.body_; + } + if (body) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(body); + if (message_arena != submessage_arena) { + body = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, body, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.body_ = body; + // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveResponseMessage.body) +} + +// optional .proto.ContextInfo contextInfo = 15; +inline bool Message_InteractiveResponseMessage::_internal_has_contextinfo() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); + return value; +} +inline bool Message_InteractiveResponseMessage::has_contextinfo() const { + return _internal_has_contextinfo(); +} +inline void Message_InteractiveResponseMessage::clear_contextinfo() { + if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::ContextInfo& Message_InteractiveResponseMessage::_internal_contextinfo() const { + const ::proto::ContextInfo* p = _impl_.contextinfo_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ContextInfo_default_instance_); +} +inline const ::proto::ContextInfo& Message_InteractiveResponseMessage::contextinfo() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveResponseMessage.contextInfo) + return _internal_contextinfo(); +} +inline void Message_InteractiveResponseMessage::unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); + } + _impl_.contextinfo_ = contextinfo; + if (contextinfo) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveResponseMessage.contextInfo) +} +inline ::proto::ContextInfo* Message_InteractiveResponseMessage::release_contextinfo() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ContextInfo* Message_InteractiveResponseMessage::unsafe_arena_release_contextinfo() { + // @@protoc_insertion_point(field_release:proto.Message.InteractiveResponseMessage.contextInfo) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; + return temp; +} +inline ::proto::ContextInfo* Message_InteractiveResponseMessage::_internal_mutable_contextinfo() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.contextinfo_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); + _impl_.contextinfo_ = p; + } + return _impl_.contextinfo_; +} +inline ::proto::ContextInfo* Message_InteractiveResponseMessage::mutable_contextinfo() { + ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); + // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveResponseMessage.contextInfo) + return _msg; +} +inline void Message_InteractiveResponseMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.contextinfo_; + } + if (contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); + if (message_arena != submessage_arena) { + contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, contextinfo, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.contextinfo_ = contextinfo; + // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveResponseMessage.contextInfo) +} + +// .proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage nativeFlowResponseMessage = 2; +inline bool Message_InteractiveResponseMessage::_internal_has_nativeflowresponsemessage() const { + return interactiveResponseMessage_case() == kNativeFlowResponseMessage; +} +inline bool Message_InteractiveResponseMessage::has_nativeflowresponsemessage() const { + return _internal_has_nativeflowresponsemessage(); +} +inline void Message_InteractiveResponseMessage::set_has_nativeflowresponsemessage() { + _impl_._oneof_case_[0] = kNativeFlowResponseMessage; +} +inline void Message_InteractiveResponseMessage::clear_nativeflowresponsemessage() { + if (_internal_has_nativeflowresponsemessage()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.interactiveResponseMessage_.nativeflowresponsemessage_; + } + clear_has_interactiveResponseMessage(); + } +} +inline ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* Message_InteractiveResponseMessage::release_nativeflowresponsemessage() { + // @@protoc_insertion_point(field_release:proto.Message.InteractiveResponseMessage.nativeFlowResponseMessage) + if (_internal_has_nativeflowresponsemessage()) { + clear_has_interactiveResponseMessage(); + ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* temp = _impl_.interactiveResponseMessage_.nativeflowresponsemessage_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.interactiveResponseMessage_.nativeflowresponsemessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage& Message_InteractiveResponseMessage::_internal_nativeflowresponsemessage() const { + return _internal_has_nativeflowresponsemessage() + ? *_impl_.interactiveResponseMessage_.nativeflowresponsemessage_ + : reinterpret_cast< ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage&>(::proto::_Message_InteractiveResponseMessage_NativeFlowResponseMessage_default_instance_); +} +inline const ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage& Message_InteractiveResponseMessage::nativeflowresponsemessage() const { + // @@protoc_insertion_point(field_get:proto.Message.InteractiveResponseMessage.nativeFlowResponseMessage) + return _internal_nativeflowresponsemessage(); +} +inline ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* Message_InteractiveResponseMessage::unsafe_arena_release_nativeflowresponsemessage() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.InteractiveResponseMessage.nativeFlowResponseMessage) + if (_internal_has_nativeflowresponsemessage()) { + clear_has_interactiveResponseMessage(); + ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* temp = _impl_.interactiveResponseMessage_.nativeflowresponsemessage_; + _impl_.interactiveResponseMessage_.nativeflowresponsemessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Message_InteractiveResponseMessage::unsafe_arena_set_allocated_nativeflowresponsemessage(::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* nativeflowresponsemessage) { + clear_interactiveResponseMessage(); + if (nativeflowresponsemessage) { + set_has_nativeflowresponsemessage(); + _impl_.interactiveResponseMessage_.nativeflowresponsemessage_ = nativeflowresponsemessage; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveResponseMessage.nativeFlowResponseMessage) +} +inline ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* Message_InteractiveResponseMessage::_internal_mutable_nativeflowresponsemessage() { + if (!_internal_has_nativeflowresponsemessage()) { + clear_interactiveResponseMessage(); + set_has_nativeflowresponsemessage(); + _impl_.interactiveResponseMessage_.nativeflowresponsemessage_ = CreateMaybeMessage< ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage >(GetArenaForAllocation()); + } + return _impl_.interactiveResponseMessage_.nativeflowresponsemessage_; +} +inline ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* Message_InteractiveResponseMessage::mutable_nativeflowresponsemessage() { + ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* _msg = _internal_mutable_nativeflowresponsemessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveResponseMessage.nativeFlowResponseMessage) + return _msg; +} + +inline bool Message_InteractiveResponseMessage::has_interactiveResponseMessage() const { + return interactiveResponseMessage_case() != INTERACTIVERESPONSEMESSAGE_NOT_SET; +} +inline void Message_InteractiveResponseMessage::clear_has_interactiveResponseMessage() { + _impl_._oneof_case_[0] = INTERACTIVERESPONSEMESSAGE_NOT_SET; +} +inline Message_InteractiveResponseMessage::InteractiveResponseMessageCase Message_InteractiveResponseMessage::interactiveResponseMessage_case() const { + return Message_InteractiveResponseMessage::InteractiveResponseMessageCase(_impl_._oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// Message_InvoiceMessage + +// optional string note = 1; +inline bool Message_InvoiceMessage::_internal_has_note() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_InvoiceMessage::has_note() const { + return _internal_has_note(); +} +inline void Message_InvoiceMessage::clear_note() { + _impl_.note_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_InvoiceMessage::note() const { + // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.note) + return _internal_note(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_InvoiceMessage::set_note(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.note_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.note) +} +inline std::string* Message_InvoiceMessage::mutable_note() { + std::string* _s = _internal_mutable_note(); + // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.note) + return _s; +} +inline const std::string& Message_InvoiceMessage::_internal_note() const { + return _impl_.note_.Get(); +} +inline void Message_InvoiceMessage::_internal_set_note(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.note_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_InvoiceMessage::_internal_mutable_note() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.note_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_InvoiceMessage::release_note() { + // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.note) + if (!_internal_has_note()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.note_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.note_.IsDefault()) { + _impl_.note_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_InvoiceMessage::set_allocated_note(std::string* note) { + if (note != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.note_.SetAllocated(note, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.note_.IsDefault()) { + _impl_.note_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.note) +} + +// optional string token = 2; +inline bool Message_InvoiceMessage::_internal_has_token() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_InvoiceMessage::has_token() const { + return _internal_has_token(); +} +inline void Message_InvoiceMessage::clear_token() { + _impl_.token_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_InvoiceMessage::token() const { + // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.token) + return _internal_token(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_InvoiceMessage::set_token(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.token_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.token) +} +inline std::string* Message_InvoiceMessage::mutable_token() { + std::string* _s = _internal_mutable_token(); + // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.token) + return _s; +} +inline const std::string& Message_InvoiceMessage::_internal_token() const { + return _impl_.token_.Get(); +} +inline void Message_InvoiceMessage::_internal_set_token(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.token_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_InvoiceMessage::_internal_mutable_token() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.token_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_InvoiceMessage::release_token() { + // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.token) + if (!_internal_has_token()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.token_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.token_.IsDefault()) { + _impl_.token_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_InvoiceMessage::set_allocated_token(std::string* token) { + if (token != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.token_.SetAllocated(token, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.token_.IsDefault()) { + _impl_.token_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.token) +} + +// optional .proto.Message.InvoiceMessage.AttachmentType attachmentType = 3; +inline bool Message_InvoiceMessage::_internal_has_attachmenttype() const { + bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool Message_InvoiceMessage::has_attachmenttype() const { + return _internal_has_attachmenttype(); +} +inline void Message_InvoiceMessage::clear_attachmenttype() { + _impl_.attachmenttype_ = 0; + _impl_._has_bits_[0] &= ~0x00000200u; +} +inline ::proto::Message_InvoiceMessage_AttachmentType Message_InvoiceMessage::_internal_attachmenttype() const { + return static_cast< ::proto::Message_InvoiceMessage_AttachmentType >(_impl_.attachmenttype_); +} +inline ::proto::Message_InvoiceMessage_AttachmentType Message_InvoiceMessage::attachmenttype() const { + // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentType) + return _internal_attachmenttype(); +} +inline void Message_InvoiceMessage::_internal_set_attachmenttype(::proto::Message_InvoiceMessage_AttachmentType value) { + assert(::proto::Message_InvoiceMessage_AttachmentType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.attachmenttype_ = value; +} +inline void Message_InvoiceMessage::set_attachmenttype(::proto::Message_InvoiceMessage_AttachmentType value) { + _internal_set_attachmenttype(value); + // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentType) +} + +// optional string attachmentMimetype = 4; +inline bool Message_InvoiceMessage::_internal_has_attachmentmimetype() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Message_InvoiceMessage::has_attachmentmimetype() const { + return _internal_has_attachmentmimetype(); +} +inline void Message_InvoiceMessage::clear_attachmentmimetype() { + _impl_.attachmentmimetype_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& Message_InvoiceMessage::attachmentmimetype() const { + // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentMimetype) + return _internal_attachmentmimetype(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_InvoiceMessage::set_attachmentmimetype(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.attachmentmimetype_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentMimetype) +} +inline std::string* Message_InvoiceMessage::mutable_attachmentmimetype() { + std::string* _s = _internal_mutable_attachmentmimetype(); + // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.attachmentMimetype) + return _s; +} +inline const std::string& Message_InvoiceMessage::_internal_attachmentmimetype() const { + return _impl_.attachmentmimetype_.Get(); +} +inline void Message_InvoiceMessage::_internal_set_attachmentmimetype(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.attachmentmimetype_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_InvoiceMessage::_internal_mutable_attachmentmimetype() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.attachmentmimetype_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_InvoiceMessage::release_attachmentmimetype() { + // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.attachmentMimetype) + if (!_internal_has_attachmentmimetype()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.attachmentmimetype_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.attachmentmimetype_.IsDefault()) { + _impl_.attachmentmimetype_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_InvoiceMessage::set_allocated_attachmentmimetype(std::string* attachmentmimetype) { + if (attachmentmimetype != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.attachmentmimetype_.SetAllocated(attachmentmimetype, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.attachmentmimetype_.IsDefault()) { + _impl_.attachmentmimetype_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.attachmentMimetype) +} + +// optional bytes attachmentMediaKey = 5; +inline bool Message_InvoiceMessage::_internal_has_attachmentmediakey() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool Message_InvoiceMessage::has_attachmentmediakey() const { + return _internal_has_attachmentmediakey(); +} +inline void Message_InvoiceMessage::clear_attachmentmediakey() { + _impl_.attachmentmediakey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const std::string& Message_InvoiceMessage::attachmentmediakey() const { + // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentMediaKey) + return _internal_attachmentmediakey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_InvoiceMessage::set_attachmentmediakey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.attachmentmediakey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentMediaKey) +} +inline std::string* Message_InvoiceMessage::mutable_attachmentmediakey() { + std::string* _s = _internal_mutable_attachmentmediakey(); + // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.attachmentMediaKey) + return _s; +} +inline const std::string& Message_InvoiceMessage::_internal_attachmentmediakey() const { + return _impl_.attachmentmediakey_.Get(); +} +inline void Message_InvoiceMessage::_internal_set_attachmentmediakey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.attachmentmediakey_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_InvoiceMessage::_internal_mutable_attachmentmediakey() { + _impl_._has_bits_[0] |= 0x00000008u; + return _impl_.attachmentmediakey_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_InvoiceMessage::release_attachmentmediakey() { + // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.attachmentMediaKey) + if (!_internal_has_attachmentmediakey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000008u; + auto* p = _impl_.attachmentmediakey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.attachmentmediakey_.IsDefault()) { + _impl_.attachmentmediakey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_InvoiceMessage::set_allocated_attachmentmediakey(std::string* attachmentmediakey) { + if (attachmentmediakey != nullptr) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.attachmentmediakey_.SetAllocated(attachmentmediakey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.attachmentmediakey_.IsDefault()) { + _impl_.attachmentmediakey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.attachmentMediaKey) +} + +// optional int64 attachmentMediaKeyTimestamp = 6; +inline bool Message_InvoiceMessage::_internal_has_attachmentmediakeytimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool Message_InvoiceMessage::has_attachmentmediakeytimestamp() const { + return _internal_has_attachmentmediakeytimestamp(); +} +inline void Message_InvoiceMessage::clear_attachmentmediakeytimestamp() { + _impl_.attachmentmediakeytimestamp_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000100u; +} +inline int64_t Message_InvoiceMessage::_internal_attachmentmediakeytimestamp() const { + return _impl_.attachmentmediakeytimestamp_; +} +inline int64_t Message_InvoiceMessage::attachmentmediakeytimestamp() const { + // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentMediaKeyTimestamp) + return _internal_attachmentmediakeytimestamp(); +} +inline void Message_InvoiceMessage::_internal_set_attachmentmediakeytimestamp(int64_t value) { + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.attachmentmediakeytimestamp_ = value; +} +inline void Message_InvoiceMessage::set_attachmentmediakeytimestamp(int64_t value) { + _internal_set_attachmentmediakeytimestamp(value); + // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentMediaKeyTimestamp) +} + +// optional bytes attachmentFileSha256 = 7; +inline bool Message_InvoiceMessage::_internal_has_attachmentfilesha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool Message_InvoiceMessage::has_attachmentfilesha256() const { + return _internal_has_attachmentfilesha256(); +} +inline void Message_InvoiceMessage::clear_attachmentfilesha256() { + _impl_.attachmentfilesha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const std::string& Message_InvoiceMessage::attachmentfilesha256() const { + // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentFileSha256) + return _internal_attachmentfilesha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_InvoiceMessage::set_attachmentfilesha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.attachmentfilesha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentFileSha256) +} +inline std::string* Message_InvoiceMessage::mutable_attachmentfilesha256() { + std::string* _s = _internal_mutable_attachmentfilesha256(); + // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.attachmentFileSha256) + return _s; +} +inline const std::string& Message_InvoiceMessage::_internal_attachmentfilesha256() const { + return _impl_.attachmentfilesha256_.Get(); +} +inline void Message_InvoiceMessage::_internal_set_attachmentfilesha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.attachmentfilesha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_InvoiceMessage::_internal_mutable_attachmentfilesha256() { + _impl_._has_bits_[0] |= 0x00000010u; + return _impl_.attachmentfilesha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_InvoiceMessage::release_attachmentfilesha256() { + // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.attachmentFileSha256) + if (!_internal_has_attachmentfilesha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000010u; + auto* p = _impl_.attachmentfilesha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.attachmentfilesha256_.IsDefault()) { + _impl_.attachmentfilesha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_InvoiceMessage::set_allocated_attachmentfilesha256(std::string* attachmentfilesha256) { + if (attachmentfilesha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.attachmentfilesha256_.SetAllocated(attachmentfilesha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.attachmentfilesha256_.IsDefault()) { + _impl_.attachmentfilesha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.attachmentFileSha256) +} + +// optional bytes attachmentFileEncSha256 = 8; +inline bool Message_InvoiceMessage::_internal_has_attachmentfileencsha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool Message_InvoiceMessage::has_attachmentfileencsha256() const { + return _internal_has_attachmentfileencsha256(); +} +inline void Message_InvoiceMessage::clear_attachmentfileencsha256() { + _impl_.attachmentfileencsha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline const std::string& Message_InvoiceMessage::attachmentfileencsha256() const { + // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentFileEncSha256) + return _internal_attachmentfileencsha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_InvoiceMessage::set_attachmentfileencsha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.attachmentfileencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentFileEncSha256) +} +inline std::string* Message_InvoiceMessage::mutable_attachmentfileencsha256() { + std::string* _s = _internal_mutable_attachmentfileencsha256(); + // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.attachmentFileEncSha256) + return _s; +} +inline const std::string& Message_InvoiceMessage::_internal_attachmentfileencsha256() const { + return _impl_.attachmentfileencsha256_.Get(); +} +inline void Message_InvoiceMessage::_internal_set_attachmentfileencsha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.attachmentfileencsha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_InvoiceMessage::_internal_mutable_attachmentfileencsha256() { + _impl_._has_bits_[0] |= 0x00000020u; + return _impl_.attachmentfileencsha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_InvoiceMessage::release_attachmentfileencsha256() { + // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.attachmentFileEncSha256) + if (!_internal_has_attachmentfileencsha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000020u; + auto* p = _impl_.attachmentfileencsha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.attachmentfileencsha256_.IsDefault()) { + _impl_.attachmentfileencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_InvoiceMessage::set_allocated_attachmentfileencsha256(std::string* attachmentfileencsha256) { + if (attachmentfileencsha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + _impl_.attachmentfileencsha256_.SetAllocated(attachmentfileencsha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.attachmentfileencsha256_.IsDefault()) { + _impl_.attachmentfileencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.attachmentFileEncSha256) +} + +// optional string attachmentDirectPath = 9; +inline bool Message_InvoiceMessage::_internal_has_attachmentdirectpath() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool Message_InvoiceMessage::has_attachmentdirectpath() const { + return _internal_has_attachmentdirectpath(); +} +inline void Message_InvoiceMessage::clear_attachmentdirectpath() { + _impl_.attachmentdirectpath_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline const std::string& Message_InvoiceMessage::attachmentdirectpath() const { + // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentDirectPath) + return _internal_attachmentdirectpath(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_InvoiceMessage::set_attachmentdirectpath(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.attachmentdirectpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentDirectPath) +} +inline std::string* Message_InvoiceMessage::mutable_attachmentdirectpath() { + std::string* _s = _internal_mutable_attachmentdirectpath(); + // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.attachmentDirectPath) + return _s; +} +inline const std::string& Message_InvoiceMessage::_internal_attachmentdirectpath() const { + return _impl_.attachmentdirectpath_.Get(); +} +inline void Message_InvoiceMessage::_internal_set_attachmentdirectpath(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.attachmentdirectpath_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_InvoiceMessage::_internal_mutable_attachmentdirectpath() { + _impl_._has_bits_[0] |= 0x00000040u; + return _impl_.attachmentdirectpath_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_InvoiceMessage::release_attachmentdirectpath() { + // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.attachmentDirectPath) + if (!_internal_has_attachmentdirectpath()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000040u; + auto* p = _impl_.attachmentdirectpath_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.attachmentdirectpath_.IsDefault()) { + _impl_.attachmentdirectpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_InvoiceMessage::set_allocated_attachmentdirectpath(std::string* attachmentdirectpath) { + if (attachmentdirectpath != nullptr) { + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + _impl_.attachmentdirectpath_.SetAllocated(attachmentdirectpath, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.attachmentdirectpath_.IsDefault()) { + _impl_.attachmentdirectpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.attachmentDirectPath) +} + +// optional bytes attachmentJpegThumbnail = 10; +inline bool Message_InvoiceMessage::_internal_has_attachmentjpegthumbnail() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool Message_InvoiceMessage::has_attachmentjpegthumbnail() const { + return _internal_has_attachmentjpegthumbnail(); +} +inline void Message_InvoiceMessage::clear_attachmentjpegthumbnail() { + _impl_.attachmentjpegthumbnail_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline const std::string& Message_InvoiceMessage::attachmentjpegthumbnail() const { + // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentJpegThumbnail) + return _internal_attachmentjpegthumbnail(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_InvoiceMessage::set_attachmentjpegthumbnail(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.attachmentjpegthumbnail_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentJpegThumbnail) +} +inline std::string* Message_InvoiceMessage::mutable_attachmentjpegthumbnail() { + std::string* _s = _internal_mutable_attachmentjpegthumbnail(); + // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.attachmentJpegThumbnail) + return _s; +} +inline const std::string& Message_InvoiceMessage::_internal_attachmentjpegthumbnail() const { + return _impl_.attachmentjpegthumbnail_.Get(); +} +inline void Message_InvoiceMessage::_internal_set_attachmentjpegthumbnail(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.attachmentjpegthumbnail_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_InvoiceMessage::_internal_mutable_attachmentjpegthumbnail() { + _impl_._has_bits_[0] |= 0x00000080u; + return _impl_.attachmentjpegthumbnail_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_InvoiceMessage::release_attachmentjpegthumbnail() { + // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.attachmentJpegThumbnail) + if (!_internal_has_attachmentjpegthumbnail()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000080u; + auto* p = _impl_.attachmentjpegthumbnail_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.attachmentjpegthumbnail_.IsDefault()) { + _impl_.attachmentjpegthumbnail_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_InvoiceMessage::set_allocated_attachmentjpegthumbnail(std::string* attachmentjpegthumbnail) { + if (attachmentjpegthumbnail != nullptr) { + _impl_._has_bits_[0] |= 0x00000080u; + } else { + _impl_._has_bits_[0] &= ~0x00000080u; + } + _impl_.attachmentjpegthumbnail_.SetAllocated(attachmentjpegthumbnail, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.attachmentjpegthumbnail_.IsDefault()) { + _impl_.attachmentjpegthumbnail_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.attachmentJpegThumbnail) +} + +// ------------------------------------------------------------------- + +// Message_KeepInChatMessage + +// optional .proto.MessageKey key = 1; +inline bool Message_KeepInChatMessage::_internal_has_key() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr); + return value; +} +inline bool Message_KeepInChatMessage::has_key() const { + return _internal_has_key(); +} +inline void Message_KeepInChatMessage::clear_key() { + if (_impl_.key_ != nullptr) _impl_.key_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::MessageKey& Message_KeepInChatMessage::_internal_key() const { + const ::proto::MessageKey* p = _impl_.key_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_MessageKey_default_instance_); +} +inline const ::proto::MessageKey& Message_KeepInChatMessage::key() const { + // @@protoc_insertion_point(field_get:proto.Message.KeepInChatMessage.key) + return _internal_key(); +} +inline void Message_KeepInChatMessage::unsafe_arena_set_allocated_key( + ::proto::MessageKey* key) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_); + } + _impl_.key_ = key; + if (key) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.KeepInChatMessage.key) +} +inline ::proto::MessageKey* Message_KeepInChatMessage::release_key() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::MessageKey* temp = _impl_.key_; + _impl_.key_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::MessageKey* Message_KeepInChatMessage::unsafe_arena_release_key() { + // @@protoc_insertion_point(field_release:proto.Message.KeepInChatMessage.key) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::MessageKey* temp = _impl_.key_; + _impl_.key_ = nullptr; + return temp; +} +inline ::proto::MessageKey* Message_KeepInChatMessage::_internal_mutable_key() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.key_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation()); + _impl_.key_ = p; + } + return _impl_.key_; +} +inline ::proto::MessageKey* Message_KeepInChatMessage::mutable_key() { + ::proto::MessageKey* _msg = _internal_mutable_key(); + // @@protoc_insertion_point(field_mutable:proto.Message.KeepInChatMessage.key) + return _msg; +} +inline void Message_KeepInChatMessage::set_allocated_key(::proto::MessageKey* key) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.key_; + } + if (key) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key); + if (message_arena != submessage_arena) { + key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, key, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.key_ = key; + // @@protoc_insertion_point(field_set_allocated:proto.Message.KeepInChatMessage.key) +} + +// optional .proto.KeepType keepType = 2; +inline bool Message_KeepInChatMessage::_internal_has_keeptype() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Message_KeepInChatMessage::has_keeptype() const { + return _internal_has_keeptype(); +} +inline void Message_KeepInChatMessage::clear_keeptype() { + _impl_.keeptype_ = 0; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline ::proto::KeepType Message_KeepInChatMessage::_internal_keeptype() const { + return static_cast< ::proto::KeepType >(_impl_.keeptype_); +} +inline ::proto::KeepType Message_KeepInChatMessage::keeptype() const { + // @@protoc_insertion_point(field_get:proto.Message.KeepInChatMessage.keepType) + return _internal_keeptype(); +} +inline void Message_KeepInChatMessage::_internal_set_keeptype(::proto::KeepType value) { + assert(::proto::KeepType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.keeptype_ = value; +} +inline void Message_KeepInChatMessage::set_keeptype(::proto::KeepType value) { + _internal_set_keeptype(value); + // @@protoc_insertion_point(field_set:proto.Message.KeepInChatMessage.keepType) +} + +// optional int64 timestampMs = 3; +inline bool Message_KeepInChatMessage::_internal_has_timestampms() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_KeepInChatMessage::has_timestampms() const { + return _internal_has_timestampms(); +} +inline void Message_KeepInChatMessage::clear_timestampms() { + _impl_.timestampms_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline int64_t Message_KeepInChatMessage::_internal_timestampms() const { + return _impl_.timestampms_; +} +inline int64_t Message_KeepInChatMessage::timestampms() const { + // @@protoc_insertion_point(field_get:proto.Message.KeepInChatMessage.timestampMs) + return _internal_timestampms(); +} +inline void Message_KeepInChatMessage::_internal_set_timestampms(int64_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.timestampms_ = value; +} +inline void Message_KeepInChatMessage::set_timestampms(int64_t value) { + _internal_set_timestampms(value); + // @@protoc_insertion_point(field_set:proto.Message.KeepInChatMessage.timestampMs) +} + +// ------------------------------------------------------------------- + +// Message_ListMessage_ProductListHeaderImage + +// optional string productId = 1; +inline bool Message_ListMessage_ProductListHeaderImage::_internal_has_productid() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_ListMessage_ProductListHeaderImage::has_productid() const { + return _internal_has_productid(); +} +inline void Message_ListMessage_ProductListHeaderImage::clear_productid() { + _impl_.productid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_ListMessage_ProductListHeaderImage::productid() const { + // @@protoc_insertion_point(field_get:proto.Message.ListMessage.ProductListHeaderImage.productId) + return _internal_productid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ListMessage_ProductListHeaderImage::set_productid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.productid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ListMessage.ProductListHeaderImage.productId) +} +inline std::string* Message_ListMessage_ProductListHeaderImage::mutable_productid() { + std::string* _s = _internal_mutable_productid(); + // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.ProductListHeaderImage.productId) + return _s; +} +inline const std::string& Message_ListMessage_ProductListHeaderImage::_internal_productid() const { + return _impl_.productid_.Get(); +} +inline void Message_ListMessage_ProductListHeaderImage::_internal_set_productid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.productid_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ListMessage_ProductListHeaderImage::_internal_mutable_productid() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.productid_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ListMessage_ProductListHeaderImage::release_productid() { + // @@protoc_insertion_point(field_release:proto.Message.ListMessage.ProductListHeaderImage.productId) + if (!_internal_has_productid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.productid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.productid_.IsDefault()) { + _impl_.productid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ListMessage_ProductListHeaderImage::set_allocated_productid(std::string* productid) { + if (productid != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.productid_.SetAllocated(productid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.productid_.IsDefault()) { + _impl_.productid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.ProductListHeaderImage.productId) +} + +// optional bytes jpegThumbnail = 2; +inline bool Message_ListMessage_ProductListHeaderImage::_internal_has_jpegthumbnail() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_ListMessage_ProductListHeaderImage::has_jpegthumbnail() const { + return _internal_has_jpegthumbnail(); +} +inline void Message_ListMessage_ProductListHeaderImage::clear_jpegthumbnail() { + _impl_.jpegthumbnail_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_ListMessage_ProductListHeaderImage::jpegthumbnail() const { + // @@protoc_insertion_point(field_get:proto.Message.ListMessage.ProductListHeaderImage.jpegThumbnail) + return _internal_jpegthumbnail(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ListMessage_ProductListHeaderImage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.jpegthumbnail_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ListMessage.ProductListHeaderImage.jpegThumbnail) +} +inline std::string* Message_ListMessage_ProductListHeaderImage::mutable_jpegthumbnail() { + std::string* _s = _internal_mutable_jpegthumbnail(); + // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.ProductListHeaderImage.jpegThumbnail) + return _s; +} +inline const std::string& Message_ListMessage_ProductListHeaderImage::_internal_jpegthumbnail() const { + return _impl_.jpegthumbnail_.Get(); +} +inline void Message_ListMessage_ProductListHeaderImage::_internal_set_jpegthumbnail(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ListMessage_ProductListHeaderImage::_internal_mutable_jpegthumbnail() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ListMessage_ProductListHeaderImage::release_jpegthumbnail() { + // @@protoc_insertion_point(field_release:proto.Message.ListMessage.ProductListHeaderImage.jpegThumbnail) + if (!_internal_has_jpegthumbnail()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.jpegthumbnail_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.jpegthumbnail_.IsDefault()) { + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ListMessage_ProductListHeaderImage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) { + if (jpegthumbnail != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.jpegthumbnail_.IsDefault()) { + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.ProductListHeaderImage.jpegThumbnail) +} + +// ------------------------------------------------------------------- + +// Message_ListMessage_ProductListInfo + +// repeated .proto.Message.ListMessage.ProductSection productSections = 1; +inline int Message_ListMessage_ProductListInfo::_internal_productsections_size() const { + return _impl_.productsections_.size(); +} +inline int Message_ListMessage_ProductListInfo::productsections_size() const { + return _internal_productsections_size(); +} +inline void Message_ListMessage_ProductListInfo::clear_productsections() { + _impl_.productsections_.Clear(); +} +inline ::proto::Message_ListMessage_ProductSection* Message_ListMessage_ProductListInfo::mutable_productsections(int index) { + // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.ProductListInfo.productSections) + return _impl_.productsections_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_ProductSection >* +Message_ListMessage_ProductListInfo::mutable_productsections() { + // @@protoc_insertion_point(field_mutable_list:proto.Message.ListMessage.ProductListInfo.productSections) + return &_impl_.productsections_; +} +inline const ::proto::Message_ListMessage_ProductSection& Message_ListMessage_ProductListInfo::_internal_productsections(int index) const { + return _impl_.productsections_.Get(index); +} +inline const ::proto::Message_ListMessage_ProductSection& Message_ListMessage_ProductListInfo::productsections(int index) const { + // @@protoc_insertion_point(field_get:proto.Message.ListMessage.ProductListInfo.productSections) + return _internal_productsections(index); +} +inline ::proto::Message_ListMessage_ProductSection* Message_ListMessage_ProductListInfo::_internal_add_productsections() { + return _impl_.productsections_.Add(); +} +inline ::proto::Message_ListMessage_ProductSection* Message_ListMessage_ProductListInfo::add_productsections() { + ::proto::Message_ListMessage_ProductSection* _add = _internal_add_productsections(); + // @@protoc_insertion_point(field_add:proto.Message.ListMessage.ProductListInfo.productSections) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_ProductSection >& +Message_ListMessage_ProductListInfo::productsections() const { + // @@protoc_insertion_point(field_list:proto.Message.ListMessage.ProductListInfo.productSections) + return _impl_.productsections_; +} + +// optional .proto.Message.ListMessage.ProductListHeaderImage headerImage = 2; +inline bool Message_ListMessage_ProductListInfo::_internal_has_headerimage() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.headerimage_ != nullptr); + return value; +} +inline bool Message_ListMessage_ProductListInfo::has_headerimage() const { + return _internal_has_headerimage(); +} +inline void Message_ListMessage_ProductListInfo::clear_headerimage() { + if (_impl_.headerimage_ != nullptr) _impl_.headerimage_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::Message_ListMessage_ProductListHeaderImage& Message_ListMessage_ProductListInfo::_internal_headerimage() const { + const ::proto::Message_ListMessage_ProductListHeaderImage* p = _impl_.headerimage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_ListMessage_ProductListHeaderImage_default_instance_); +} +inline const ::proto::Message_ListMessage_ProductListHeaderImage& Message_ListMessage_ProductListInfo::headerimage() const { + // @@protoc_insertion_point(field_get:proto.Message.ListMessage.ProductListInfo.headerImage) + return _internal_headerimage(); +} +inline void Message_ListMessage_ProductListInfo::unsafe_arena_set_allocated_headerimage( + ::proto::Message_ListMessage_ProductListHeaderImage* headerimage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.headerimage_); + } + _impl_.headerimage_ = headerimage; + if (headerimage) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ListMessage.ProductListInfo.headerImage) +} +inline ::proto::Message_ListMessage_ProductListHeaderImage* Message_ListMessage_ProductListInfo::release_headerimage() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::Message_ListMessage_ProductListHeaderImage* temp = _impl_.headerimage_; + _impl_.headerimage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_ListMessage_ProductListHeaderImage* Message_ListMessage_ProductListInfo::unsafe_arena_release_headerimage() { + // @@protoc_insertion_point(field_release:proto.Message.ListMessage.ProductListInfo.headerImage) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::Message_ListMessage_ProductListHeaderImage* temp = _impl_.headerimage_; + _impl_.headerimage_ = nullptr; + return temp; +} +inline ::proto::Message_ListMessage_ProductListHeaderImage* Message_ListMessage_ProductListInfo::_internal_mutable_headerimage() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.headerimage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_ListMessage_ProductListHeaderImage>(GetArenaForAllocation()); + _impl_.headerimage_ = p; + } + return _impl_.headerimage_; +} +inline ::proto::Message_ListMessage_ProductListHeaderImage* Message_ListMessage_ProductListInfo::mutable_headerimage() { + ::proto::Message_ListMessage_ProductListHeaderImage* _msg = _internal_mutable_headerimage(); + // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.ProductListInfo.headerImage) + return _msg; +} +inline void Message_ListMessage_ProductListInfo::set_allocated_headerimage(::proto::Message_ListMessage_ProductListHeaderImage* headerimage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.headerimage_; + } + if (headerimage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(headerimage); + if (message_arena != submessage_arena) { + headerimage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, headerimage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.headerimage_ = headerimage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.ProductListInfo.headerImage) +} + +// optional string businessOwnerJid = 3; +inline bool Message_ListMessage_ProductListInfo::_internal_has_businessownerjid() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_ListMessage_ProductListInfo::has_businessownerjid() const { + return _internal_has_businessownerjid(); +} +inline void Message_ListMessage_ProductListInfo::clear_businessownerjid() { + _impl_.businessownerjid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_ListMessage_ProductListInfo::businessownerjid() const { + // @@protoc_insertion_point(field_get:proto.Message.ListMessage.ProductListInfo.businessOwnerJid) + return _internal_businessownerjid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ListMessage_ProductListInfo::set_businessownerjid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.businessownerjid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ListMessage.ProductListInfo.businessOwnerJid) +} +inline std::string* Message_ListMessage_ProductListInfo::mutable_businessownerjid() { + std::string* _s = _internal_mutable_businessownerjid(); + // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.ProductListInfo.businessOwnerJid) + return _s; +} +inline const std::string& Message_ListMessage_ProductListInfo::_internal_businessownerjid() const { + return _impl_.businessownerjid_.Get(); +} +inline void Message_ListMessage_ProductListInfo::_internal_set_businessownerjid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.businessownerjid_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ListMessage_ProductListInfo::_internal_mutable_businessownerjid() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.businessownerjid_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ListMessage_ProductListInfo::release_businessownerjid() { + // @@protoc_insertion_point(field_release:proto.Message.ListMessage.ProductListInfo.businessOwnerJid) + if (!_internal_has_businessownerjid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.businessownerjid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.businessownerjid_.IsDefault()) { + _impl_.businessownerjid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ListMessage_ProductListInfo::set_allocated_businessownerjid(std::string* businessownerjid) { + if (businessownerjid != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.businessownerjid_.SetAllocated(businessownerjid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.businessownerjid_.IsDefault()) { + _impl_.businessownerjid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.ProductListInfo.businessOwnerJid) +} + +// ------------------------------------------------------------------- + +// Message_ListMessage_ProductSection + +// optional string title = 1; +inline bool Message_ListMessage_ProductSection::_internal_has_title() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_ListMessage_ProductSection::has_title() const { + return _internal_has_title(); +} +inline void Message_ListMessage_ProductSection::clear_title() { + _impl_.title_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_ListMessage_ProductSection::title() const { + // @@protoc_insertion_point(field_get:proto.Message.ListMessage.ProductSection.title) + return _internal_title(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ListMessage_ProductSection::set_title(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.title_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ListMessage.ProductSection.title) +} +inline std::string* Message_ListMessage_ProductSection::mutable_title() { + std::string* _s = _internal_mutable_title(); + // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.ProductSection.title) + return _s; +} +inline const std::string& Message_ListMessage_ProductSection::_internal_title() const { + return _impl_.title_.Get(); +} +inline void Message_ListMessage_ProductSection::_internal_set_title(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.title_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ListMessage_ProductSection::_internal_mutable_title() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.title_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ListMessage_ProductSection::release_title() { + // @@protoc_insertion_point(field_release:proto.Message.ListMessage.ProductSection.title) + if (!_internal_has_title()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.title_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.title_.IsDefault()) { + _impl_.title_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ListMessage_ProductSection::set_allocated_title(std::string* title) { + if (title != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.title_.SetAllocated(title, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.title_.IsDefault()) { + _impl_.title_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.ProductSection.title) +} + +// repeated .proto.Message.ListMessage.Product products = 2; +inline int Message_ListMessage_ProductSection::_internal_products_size() const { + return _impl_.products_.size(); +} +inline int Message_ListMessage_ProductSection::products_size() const { + return _internal_products_size(); +} +inline void Message_ListMessage_ProductSection::clear_products() { + _impl_.products_.Clear(); +} +inline ::proto::Message_ListMessage_Product* Message_ListMessage_ProductSection::mutable_products(int index) { + // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.ProductSection.products) + return _impl_.products_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Product >* +Message_ListMessage_ProductSection::mutable_products() { + // @@protoc_insertion_point(field_mutable_list:proto.Message.ListMessage.ProductSection.products) + return &_impl_.products_; +} +inline const ::proto::Message_ListMessage_Product& Message_ListMessage_ProductSection::_internal_products(int index) const { + return _impl_.products_.Get(index); +} +inline const ::proto::Message_ListMessage_Product& Message_ListMessage_ProductSection::products(int index) const { + // @@protoc_insertion_point(field_get:proto.Message.ListMessage.ProductSection.products) + return _internal_products(index); +} +inline ::proto::Message_ListMessage_Product* Message_ListMessage_ProductSection::_internal_add_products() { + return _impl_.products_.Add(); +} +inline ::proto::Message_ListMessage_Product* Message_ListMessage_ProductSection::add_products() { + ::proto::Message_ListMessage_Product* _add = _internal_add_products(); + // @@protoc_insertion_point(field_add:proto.Message.ListMessage.ProductSection.products) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Product >& +Message_ListMessage_ProductSection::products() const { + // @@protoc_insertion_point(field_list:proto.Message.ListMessage.ProductSection.products) + return _impl_.products_; +} + +// ------------------------------------------------------------------- + +// Message_ListMessage_Product + +// optional string productId = 1; +inline bool Message_ListMessage_Product::_internal_has_productid() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_ListMessage_Product::has_productid() const { + return _internal_has_productid(); +} +inline void Message_ListMessage_Product::clear_productid() { + _impl_.productid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_ListMessage_Product::productid() const { + // @@protoc_insertion_point(field_get:proto.Message.ListMessage.Product.productId) + return _internal_productid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ListMessage_Product::set_productid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.productid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ListMessage.Product.productId) +} +inline std::string* Message_ListMessage_Product::mutable_productid() { + std::string* _s = _internal_mutable_productid(); + // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.Product.productId) + return _s; +} +inline const std::string& Message_ListMessage_Product::_internal_productid() const { + return _impl_.productid_.Get(); +} +inline void Message_ListMessage_Product::_internal_set_productid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.productid_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ListMessage_Product::_internal_mutable_productid() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.productid_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ListMessage_Product::release_productid() { + // @@protoc_insertion_point(field_release:proto.Message.ListMessage.Product.productId) + if (!_internal_has_productid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.productid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.productid_.IsDefault()) { + _impl_.productid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ListMessage_Product::set_allocated_productid(std::string* productid) { + if (productid != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.productid_.SetAllocated(productid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.productid_.IsDefault()) { + _impl_.productid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.Product.productId) +} + +// ------------------------------------------------------------------- + +// Message_ListMessage_Row + +// optional string title = 1; +inline bool Message_ListMessage_Row::_internal_has_title() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_ListMessage_Row::has_title() const { + return _internal_has_title(); +} +inline void Message_ListMessage_Row::clear_title() { + _impl_.title_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_ListMessage_Row::title() const { + // @@protoc_insertion_point(field_get:proto.Message.ListMessage.Row.title) + return _internal_title(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ListMessage_Row::set_title(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.title_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ListMessage.Row.title) +} +inline std::string* Message_ListMessage_Row::mutable_title() { + std::string* _s = _internal_mutable_title(); + // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.Row.title) + return _s; +} +inline const std::string& Message_ListMessage_Row::_internal_title() const { + return _impl_.title_.Get(); +} +inline void Message_ListMessage_Row::_internal_set_title(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.title_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ListMessage_Row::_internal_mutable_title() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.title_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ListMessage_Row::release_title() { + // @@protoc_insertion_point(field_release:proto.Message.ListMessage.Row.title) + if (!_internal_has_title()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.title_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.title_.IsDefault()) { + _impl_.title_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ListMessage_Row::set_allocated_title(std::string* title) { + if (title != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.title_.SetAllocated(title, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.title_.IsDefault()) { + _impl_.title_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.Row.title) +} + +// optional string description = 2; +inline bool Message_ListMessage_Row::_internal_has_description() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_ListMessage_Row::has_description() const { + return _internal_has_description(); +} +inline void Message_ListMessage_Row::clear_description() { + _impl_.description_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_ListMessage_Row::description() const { + // @@protoc_insertion_point(field_get:proto.Message.ListMessage.Row.description) + return _internal_description(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ListMessage_Row::set_description(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.description_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ListMessage.Row.description) +} +inline std::string* Message_ListMessage_Row::mutable_description() { + std::string* _s = _internal_mutable_description(); + // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.Row.description) + return _s; +} +inline const std::string& Message_ListMessage_Row::_internal_description() const { + return _impl_.description_.Get(); +} +inline void Message_ListMessage_Row::_internal_set_description(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.description_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ListMessage_Row::_internal_mutable_description() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.description_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ListMessage_Row::release_description() { + // @@protoc_insertion_point(field_release:proto.Message.ListMessage.Row.description) + if (!_internal_has_description()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.description_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.description_.IsDefault()) { + _impl_.description_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ListMessage_Row::set_allocated_description(std::string* description) { + if (description != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.description_.SetAllocated(description, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.description_.IsDefault()) { + _impl_.description_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.Row.description) +} + +// optional string rowId = 3; +inline bool Message_ListMessage_Row::_internal_has_rowid() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Message_ListMessage_Row::has_rowid() const { + return _internal_has_rowid(); +} +inline void Message_ListMessage_Row::clear_rowid() { + _impl_.rowid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& Message_ListMessage_Row::rowid() const { + // @@protoc_insertion_point(field_get:proto.Message.ListMessage.Row.rowId) + return _internal_rowid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ListMessage_Row::set_rowid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.rowid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ListMessage.Row.rowId) +} +inline std::string* Message_ListMessage_Row::mutable_rowid() { + std::string* _s = _internal_mutable_rowid(); + // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.Row.rowId) + return _s; +} +inline const std::string& Message_ListMessage_Row::_internal_rowid() const { + return _impl_.rowid_.Get(); +} +inline void Message_ListMessage_Row::_internal_set_rowid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.rowid_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ListMessage_Row::_internal_mutable_rowid() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.rowid_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ListMessage_Row::release_rowid() { + // @@protoc_insertion_point(field_release:proto.Message.ListMessage.Row.rowId) + if (!_internal_has_rowid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.rowid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.rowid_.IsDefault()) { + _impl_.rowid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ListMessage_Row::set_allocated_rowid(std::string* rowid) { + if (rowid != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.rowid_.SetAllocated(rowid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.rowid_.IsDefault()) { + _impl_.rowid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.Row.rowId) +} + +// ------------------------------------------------------------------- + +// Message_ListMessage_Section + +// optional string title = 1; +inline bool Message_ListMessage_Section::_internal_has_title() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_ListMessage_Section::has_title() const { + return _internal_has_title(); +} +inline void Message_ListMessage_Section::clear_title() { + _impl_.title_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_ListMessage_Section::title() const { + // @@protoc_insertion_point(field_get:proto.Message.ListMessage.Section.title) + return _internal_title(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ListMessage_Section::set_title(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.title_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ListMessage.Section.title) +} +inline std::string* Message_ListMessage_Section::mutable_title() { + std::string* _s = _internal_mutable_title(); + // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.Section.title) + return _s; +} +inline const std::string& Message_ListMessage_Section::_internal_title() const { + return _impl_.title_.Get(); +} +inline void Message_ListMessage_Section::_internal_set_title(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.title_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ListMessage_Section::_internal_mutable_title() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.title_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ListMessage_Section::release_title() { + // @@protoc_insertion_point(field_release:proto.Message.ListMessage.Section.title) + if (!_internal_has_title()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.title_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.title_.IsDefault()) { + _impl_.title_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ListMessage_Section::set_allocated_title(std::string* title) { + if (title != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.title_.SetAllocated(title, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.title_.IsDefault()) { + _impl_.title_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.Section.title) +} + +// repeated .proto.Message.ListMessage.Row rows = 2; +inline int Message_ListMessage_Section::_internal_rows_size() const { + return _impl_.rows_.size(); +} +inline int Message_ListMessage_Section::rows_size() const { + return _internal_rows_size(); +} +inline void Message_ListMessage_Section::clear_rows() { + _impl_.rows_.Clear(); +} +inline ::proto::Message_ListMessage_Row* Message_ListMessage_Section::mutable_rows(int index) { + // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.Section.rows) + return _impl_.rows_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Row >* +Message_ListMessage_Section::mutable_rows() { + // @@protoc_insertion_point(field_mutable_list:proto.Message.ListMessage.Section.rows) + return &_impl_.rows_; +} +inline const ::proto::Message_ListMessage_Row& Message_ListMessage_Section::_internal_rows(int index) const { + return _impl_.rows_.Get(index); +} +inline const ::proto::Message_ListMessage_Row& Message_ListMessage_Section::rows(int index) const { + // @@protoc_insertion_point(field_get:proto.Message.ListMessage.Section.rows) + return _internal_rows(index); +} +inline ::proto::Message_ListMessage_Row* Message_ListMessage_Section::_internal_add_rows() { + return _impl_.rows_.Add(); +} +inline ::proto::Message_ListMessage_Row* Message_ListMessage_Section::add_rows() { + ::proto::Message_ListMessage_Row* _add = _internal_add_rows(); + // @@protoc_insertion_point(field_add:proto.Message.ListMessage.Section.rows) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Row >& +Message_ListMessage_Section::rows() const { + // @@protoc_insertion_point(field_list:proto.Message.ListMessage.Section.rows) + return _impl_.rows_; +} + +// ------------------------------------------------------------------- + +// Message_ListMessage + +// optional string title = 1; +inline bool Message_ListMessage::_internal_has_title() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_ListMessage::has_title() const { + return _internal_has_title(); +} +inline void Message_ListMessage::clear_title() { + _impl_.title_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_ListMessage::title() const { + // @@protoc_insertion_point(field_get:proto.Message.ListMessage.title) + return _internal_title(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ListMessage::set_title(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.title_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ListMessage.title) +} +inline std::string* Message_ListMessage::mutable_title() { + std::string* _s = _internal_mutable_title(); + // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.title) + return _s; +} +inline const std::string& Message_ListMessage::_internal_title() const { + return _impl_.title_.Get(); +} +inline void Message_ListMessage::_internal_set_title(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.title_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ListMessage::_internal_mutable_title() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.title_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ListMessage::release_title() { + // @@protoc_insertion_point(field_release:proto.Message.ListMessage.title) + if (!_internal_has_title()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.title_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.title_.IsDefault()) { + _impl_.title_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ListMessage::set_allocated_title(std::string* title) { + if (title != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.title_.SetAllocated(title, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.title_.IsDefault()) { + _impl_.title_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.title) +} + +// optional string description = 2; +inline bool Message_ListMessage::_internal_has_description() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_ListMessage::has_description() const { + return _internal_has_description(); +} +inline void Message_ListMessage::clear_description() { + _impl_.description_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_ListMessage::description() const { + // @@protoc_insertion_point(field_get:proto.Message.ListMessage.description) + return _internal_description(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ListMessage::set_description(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.description_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ListMessage.description) +} +inline std::string* Message_ListMessage::mutable_description() { + std::string* _s = _internal_mutable_description(); + // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.description) + return _s; +} +inline const std::string& Message_ListMessage::_internal_description() const { + return _impl_.description_.Get(); +} +inline void Message_ListMessage::_internal_set_description(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.description_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ListMessage::_internal_mutable_description() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.description_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ListMessage::release_description() { + // @@protoc_insertion_point(field_release:proto.Message.ListMessage.description) + if (!_internal_has_description()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.description_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.description_.IsDefault()) { + _impl_.description_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ListMessage::set_allocated_description(std::string* description) { + if (description != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.description_.SetAllocated(description, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.description_.IsDefault()) { + _impl_.description_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.description) +} + +// optional string buttonText = 3; +inline bool Message_ListMessage::_internal_has_buttontext() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Message_ListMessage::has_buttontext() const { + return _internal_has_buttontext(); +} +inline void Message_ListMessage::clear_buttontext() { + _impl_.buttontext_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& Message_ListMessage::buttontext() const { + // @@protoc_insertion_point(field_get:proto.Message.ListMessage.buttonText) + return _internal_buttontext(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ListMessage::set_buttontext(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.buttontext_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ListMessage.buttonText) +} +inline std::string* Message_ListMessage::mutable_buttontext() { + std::string* _s = _internal_mutable_buttontext(); + // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.buttonText) + return _s; +} +inline const std::string& Message_ListMessage::_internal_buttontext() const { + return _impl_.buttontext_.Get(); +} +inline void Message_ListMessage::_internal_set_buttontext(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.buttontext_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ListMessage::_internal_mutable_buttontext() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.buttontext_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ListMessage::release_buttontext() { + // @@protoc_insertion_point(field_release:proto.Message.ListMessage.buttonText) + if (!_internal_has_buttontext()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.buttontext_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.buttontext_.IsDefault()) { + _impl_.buttontext_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ListMessage::set_allocated_buttontext(std::string* buttontext) { + if (buttontext != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.buttontext_.SetAllocated(buttontext, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.buttontext_.IsDefault()) { + _impl_.buttontext_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.buttonText) +} + +// optional .proto.Message.ListMessage.ListType listType = 4; +inline bool Message_ListMessage::_internal_has_listtype() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool Message_ListMessage::has_listtype() const { + return _internal_has_listtype(); +} +inline void Message_ListMessage::clear_listtype() { + _impl_.listtype_ = 0; + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline ::proto::Message_ListMessage_ListType Message_ListMessage::_internal_listtype() const { + return static_cast< ::proto::Message_ListMessage_ListType >(_impl_.listtype_); +} +inline ::proto::Message_ListMessage_ListType Message_ListMessage::listtype() const { + // @@protoc_insertion_point(field_get:proto.Message.ListMessage.listType) + return _internal_listtype(); +} +inline void Message_ListMessage::_internal_set_listtype(::proto::Message_ListMessage_ListType value) { + assert(::proto::Message_ListMessage_ListType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.listtype_ = value; +} +inline void Message_ListMessage::set_listtype(::proto::Message_ListMessage_ListType value) { + _internal_set_listtype(value); + // @@protoc_insertion_point(field_set:proto.Message.ListMessage.listType) +} + +// repeated .proto.Message.ListMessage.Section sections = 5; +inline int Message_ListMessage::_internal_sections_size() const { + return _impl_.sections_.size(); +} +inline int Message_ListMessage::sections_size() const { + return _internal_sections_size(); +} +inline void Message_ListMessage::clear_sections() { + _impl_.sections_.Clear(); +} +inline ::proto::Message_ListMessage_Section* Message_ListMessage::mutable_sections(int index) { + // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.sections) + return _impl_.sections_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Section >* +Message_ListMessage::mutable_sections() { + // @@protoc_insertion_point(field_mutable_list:proto.Message.ListMessage.sections) + return &_impl_.sections_; +} +inline const ::proto::Message_ListMessage_Section& Message_ListMessage::_internal_sections(int index) const { + return _impl_.sections_.Get(index); +} +inline const ::proto::Message_ListMessage_Section& Message_ListMessage::sections(int index) const { + // @@protoc_insertion_point(field_get:proto.Message.ListMessage.sections) + return _internal_sections(index); +} +inline ::proto::Message_ListMessage_Section* Message_ListMessage::_internal_add_sections() { + return _impl_.sections_.Add(); +} +inline ::proto::Message_ListMessage_Section* Message_ListMessage::add_sections() { + ::proto::Message_ListMessage_Section* _add = _internal_add_sections(); + // @@protoc_insertion_point(field_add:proto.Message.ListMessage.sections) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Section >& +Message_ListMessage::sections() const { + // @@protoc_insertion_point(field_list:proto.Message.ListMessage.sections) + return _impl_.sections_; +} + +// optional .proto.Message.ListMessage.ProductListInfo productListInfo = 6; +inline bool Message_ListMessage::_internal_has_productlistinfo() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + PROTOBUF_ASSUME(!value || _impl_.productlistinfo_ != nullptr); + return value; +} +inline bool Message_ListMessage::has_productlistinfo() const { + return _internal_has_productlistinfo(); +} +inline void Message_ListMessage::clear_productlistinfo() { + if (_impl_.productlistinfo_ != nullptr) _impl_.productlistinfo_->Clear(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const ::proto::Message_ListMessage_ProductListInfo& Message_ListMessage::_internal_productlistinfo() const { + const ::proto::Message_ListMessage_ProductListInfo* p = _impl_.productlistinfo_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_ListMessage_ProductListInfo_default_instance_); +} +inline const ::proto::Message_ListMessage_ProductListInfo& Message_ListMessage::productlistinfo() const { + // @@protoc_insertion_point(field_get:proto.Message.ListMessage.productListInfo) + return _internal_productlistinfo(); +} +inline void Message_ListMessage::unsafe_arena_set_allocated_productlistinfo( + ::proto::Message_ListMessage_ProductListInfo* productlistinfo) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.productlistinfo_); + } + _impl_.productlistinfo_ = productlistinfo; + if (productlistinfo) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ListMessage.productListInfo) +} +inline ::proto::Message_ListMessage_ProductListInfo* Message_ListMessage::release_productlistinfo() { + _impl_._has_bits_[0] &= ~0x00000010u; + ::proto::Message_ListMessage_ProductListInfo* temp = _impl_.productlistinfo_; + _impl_.productlistinfo_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_ListMessage_ProductListInfo* Message_ListMessage::unsafe_arena_release_productlistinfo() { + // @@protoc_insertion_point(field_release:proto.Message.ListMessage.productListInfo) + _impl_._has_bits_[0] &= ~0x00000010u; + ::proto::Message_ListMessage_ProductListInfo* temp = _impl_.productlistinfo_; + _impl_.productlistinfo_ = nullptr; + return temp; +} +inline ::proto::Message_ListMessage_ProductListInfo* Message_ListMessage::_internal_mutable_productlistinfo() { + _impl_._has_bits_[0] |= 0x00000010u; + if (_impl_.productlistinfo_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_ListMessage_ProductListInfo>(GetArenaForAllocation()); + _impl_.productlistinfo_ = p; + } + return _impl_.productlistinfo_; +} +inline ::proto::Message_ListMessage_ProductListInfo* Message_ListMessage::mutable_productlistinfo() { + ::proto::Message_ListMessage_ProductListInfo* _msg = _internal_mutable_productlistinfo(); + // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.productListInfo) + return _msg; +} +inline void Message_ListMessage::set_allocated_productlistinfo(::proto::Message_ListMessage_ProductListInfo* productlistinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.productlistinfo_; + } + if (productlistinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(productlistinfo); + if (message_arena != submessage_arena) { + productlistinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, productlistinfo, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.productlistinfo_ = productlistinfo; + // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.productListInfo) +} + +// optional string footerText = 7; +inline bool Message_ListMessage::_internal_has_footertext() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool Message_ListMessage::has_footertext() const { + return _internal_has_footertext(); +} +inline void Message_ListMessage::clear_footertext() { + _impl_.footertext_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const std::string& Message_ListMessage::footertext() const { + // @@protoc_insertion_point(field_get:proto.Message.ListMessage.footerText) + return _internal_footertext(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ListMessage::set_footertext(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.footertext_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ListMessage.footerText) +} +inline std::string* Message_ListMessage::mutable_footertext() { + std::string* _s = _internal_mutable_footertext(); + // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.footerText) + return _s; +} +inline const std::string& Message_ListMessage::_internal_footertext() const { + return _impl_.footertext_.Get(); +} +inline void Message_ListMessage::_internal_set_footertext(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.footertext_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ListMessage::_internal_mutable_footertext() { + _impl_._has_bits_[0] |= 0x00000008u; + return _impl_.footertext_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ListMessage::release_footertext() { + // @@protoc_insertion_point(field_release:proto.Message.ListMessage.footerText) + if (!_internal_has_footertext()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000008u; + auto* p = _impl_.footertext_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.footertext_.IsDefault()) { + _impl_.footertext_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ListMessage::set_allocated_footertext(std::string* footertext) { + if (footertext != nullptr) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.footertext_.SetAllocated(footertext, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.footertext_.IsDefault()) { + _impl_.footertext_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.footerText) +} + +// optional .proto.ContextInfo contextInfo = 8; +inline bool Message_ListMessage::_internal_has_contextinfo() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); + return value; +} +inline bool Message_ListMessage::has_contextinfo() const { + return _internal_has_contextinfo(); +} +inline void Message_ListMessage::clear_contextinfo() { + if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline const ::proto::ContextInfo& Message_ListMessage::_internal_contextinfo() const { + const ::proto::ContextInfo* p = _impl_.contextinfo_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ContextInfo_default_instance_); +} +inline const ::proto::ContextInfo& Message_ListMessage::contextinfo() const { + // @@protoc_insertion_point(field_get:proto.Message.ListMessage.contextInfo) + return _internal_contextinfo(); +} +inline void Message_ListMessage::unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); + } + _impl_.contextinfo_ = contextinfo; + if (contextinfo) { + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ListMessage.contextInfo) +} +inline ::proto::ContextInfo* Message_ListMessage::release_contextinfo() { + _impl_._has_bits_[0] &= ~0x00000020u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ContextInfo* Message_ListMessage::unsafe_arena_release_contextinfo() { + // @@protoc_insertion_point(field_release:proto.Message.ListMessage.contextInfo) + _impl_._has_bits_[0] &= ~0x00000020u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; + return temp; +} +inline ::proto::ContextInfo* Message_ListMessage::_internal_mutable_contextinfo() { + _impl_._has_bits_[0] |= 0x00000020u; + if (_impl_.contextinfo_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); + _impl_.contextinfo_ = p; + } + return _impl_.contextinfo_; +} +inline ::proto::ContextInfo* Message_ListMessage::mutable_contextinfo() { + ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); + // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.contextInfo) + return _msg; +} +inline void Message_ListMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.contextinfo_; + } + if (contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); + if (message_arena != submessage_arena) { + contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, contextinfo, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + _impl_.contextinfo_ = contextinfo; + // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.contextInfo) +} + +// ------------------------------------------------------------------- + +// Message_ListResponseMessage_SingleSelectReply + +// optional string selectedRowId = 1; +inline bool Message_ListResponseMessage_SingleSelectReply::_internal_has_selectedrowid() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_ListResponseMessage_SingleSelectReply::has_selectedrowid() const { + return _internal_has_selectedrowid(); +} +inline void Message_ListResponseMessage_SingleSelectReply::clear_selectedrowid() { + _impl_.selectedrowid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_ListResponseMessage_SingleSelectReply::selectedrowid() const { + // @@protoc_insertion_point(field_get:proto.Message.ListResponseMessage.SingleSelectReply.selectedRowId) + return _internal_selectedrowid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ListResponseMessage_SingleSelectReply::set_selectedrowid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.selectedrowid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ListResponseMessage.SingleSelectReply.selectedRowId) +} +inline std::string* Message_ListResponseMessage_SingleSelectReply::mutable_selectedrowid() { + std::string* _s = _internal_mutable_selectedrowid(); + // @@protoc_insertion_point(field_mutable:proto.Message.ListResponseMessage.SingleSelectReply.selectedRowId) + return _s; +} +inline const std::string& Message_ListResponseMessage_SingleSelectReply::_internal_selectedrowid() const { + return _impl_.selectedrowid_.Get(); +} +inline void Message_ListResponseMessage_SingleSelectReply::_internal_set_selectedrowid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.selectedrowid_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ListResponseMessage_SingleSelectReply::_internal_mutable_selectedrowid() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.selectedrowid_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ListResponseMessage_SingleSelectReply::release_selectedrowid() { + // @@protoc_insertion_point(field_release:proto.Message.ListResponseMessage.SingleSelectReply.selectedRowId) + if (!_internal_has_selectedrowid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.selectedrowid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.selectedrowid_.IsDefault()) { + _impl_.selectedrowid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ListResponseMessage_SingleSelectReply::set_allocated_selectedrowid(std::string* selectedrowid) { + if (selectedrowid != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.selectedrowid_.SetAllocated(selectedrowid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.selectedrowid_.IsDefault()) { + _impl_.selectedrowid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ListResponseMessage.SingleSelectReply.selectedRowId) +} + +// ------------------------------------------------------------------- + +// Message_ListResponseMessage + +// optional string title = 1; +inline bool Message_ListResponseMessage::_internal_has_title() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_ListResponseMessage::has_title() const { + return _internal_has_title(); +} +inline void Message_ListResponseMessage::clear_title() { + _impl_.title_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_ListResponseMessage::title() const { + // @@protoc_insertion_point(field_get:proto.Message.ListResponseMessage.title) + return _internal_title(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ListResponseMessage::set_title(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.title_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ListResponseMessage.title) +} +inline std::string* Message_ListResponseMessage::mutable_title() { + std::string* _s = _internal_mutable_title(); + // @@protoc_insertion_point(field_mutable:proto.Message.ListResponseMessage.title) + return _s; +} +inline const std::string& Message_ListResponseMessage::_internal_title() const { + return _impl_.title_.Get(); +} +inline void Message_ListResponseMessage::_internal_set_title(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.title_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ListResponseMessage::_internal_mutable_title() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.title_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ListResponseMessage::release_title() { + // @@protoc_insertion_point(field_release:proto.Message.ListResponseMessage.title) + if (!_internal_has_title()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.title_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.title_.IsDefault()) { + _impl_.title_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ListResponseMessage::set_allocated_title(std::string* title) { + if (title != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.title_.SetAllocated(title, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.title_.IsDefault()) { + _impl_.title_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ListResponseMessage.title) +} + +// optional .proto.Message.ListResponseMessage.ListType listType = 2; +inline bool Message_ListResponseMessage::_internal_has_listtype() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool Message_ListResponseMessage::has_listtype() const { + return _internal_has_listtype(); +} +inline void Message_ListResponseMessage::clear_listtype() { + _impl_.listtype_ = 0; + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline ::proto::Message_ListResponseMessage_ListType Message_ListResponseMessage::_internal_listtype() const { + return static_cast< ::proto::Message_ListResponseMessage_ListType >(_impl_.listtype_); +} +inline ::proto::Message_ListResponseMessage_ListType Message_ListResponseMessage::listtype() const { + // @@protoc_insertion_point(field_get:proto.Message.ListResponseMessage.listType) + return _internal_listtype(); +} +inline void Message_ListResponseMessage::_internal_set_listtype(::proto::Message_ListResponseMessage_ListType value) { + assert(::proto::Message_ListResponseMessage_ListType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.listtype_ = value; +} +inline void Message_ListResponseMessage::set_listtype(::proto::Message_ListResponseMessage_ListType value) { + _internal_set_listtype(value); + // @@protoc_insertion_point(field_set:proto.Message.ListResponseMessage.listType) +} + +// optional .proto.Message.ListResponseMessage.SingleSelectReply singleSelectReply = 3; +inline bool Message_ListResponseMessage::_internal_has_singleselectreply() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.singleselectreply_ != nullptr); + return value; +} +inline bool Message_ListResponseMessage::has_singleselectreply() const { + return _internal_has_singleselectreply(); +} +inline void Message_ListResponseMessage::clear_singleselectreply() { + if (_impl_.singleselectreply_ != nullptr) _impl_.singleselectreply_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::proto::Message_ListResponseMessage_SingleSelectReply& Message_ListResponseMessage::_internal_singleselectreply() const { + const ::proto::Message_ListResponseMessage_SingleSelectReply* p = _impl_.singleselectreply_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_ListResponseMessage_SingleSelectReply_default_instance_); +} +inline const ::proto::Message_ListResponseMessage_SingleSelectReply& Message_ListResponseMessage::singleselectreply() const { + // @@protoc_insertion_point(field_get:proto.Message.ListResponseMessage.singleSelectReply) + return _internal_singleselectreply(); +} +inline void Message_ListResponseMessage::unsafe_arena_set_allocated_singleselectreply( + ::proto::Message_ListResponseMessage_SingleSelectReply* singleselectreply) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.singleselectreply_); + } + _impl_.singleselectreply_ = singleselectreply; + if (singleselectreply) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ListResponseMessage.singleSelectReply) +} +inline ::proto::Message_ListResponseMessage_SingleSelectReply* Message_ListResponseMessage::release_singleselectreply() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::Message_ListResponseMessage_SingleSelectReply* temp = _impl_.singleselectreply_; + _impl_.singleselectreply_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_ListResponseMessage_SingleSelectReply* Message_ListResponseMessage::unsafe_arena_release_singleselectreply() { + // @@protoc_insertion_point(field_release:proto.Message.ListResponseMessage.singleSelectReply) + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::Message_ListResponseMessage_SingleSelectReply* temp = _impl_.singleselectreply_; + _impl_.singleselectreply_ = nullptr; + return temp; +} +inline ::proto::Message_ListResponseMessage_SingleSelectReply* Message_ListResponseMessage::_internal_mutable_singleselectreply() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.singleselectreply_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_ListResponseMessage_SingleSelectReply>(GetArenaForAllocation()); + _impl_.singleselectreply_ = p; + } + return _impl_.singleselectreply_; +} +inline ::proto::Message_ListResponseMessage_SingleSelectReply* Message_ListResponseMessage::mutable_singleselectreply() { + ::proto::Message_ListResponseMessage_SingleSelectReply* _msg = _internal_mutable_singleselectreply(); + // @@protoc_insertion_point(field_mutable:proto.Message.ListResponseMessage.singleSelectReply) + return _msg; +} +inline void Message_ListResponseMessage::set_allocated_singleselectreply(::proto::Message_ListResponseMessage_SingleSelectReply* singleselectreply) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.singleselectreply_; + } + if (singleselectreply) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(singleselectreply); + if (message_arena != submessage_arena) { + singleselectreply = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, singleselectreply, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.singleselectreply_ = singleselectreply; + // @@protoc_insertion_point(field_set_allocated:proto.Message.ListResponseMessage.singleSelectReply) +} + +// optional .proto.ContextInfo contextInfo = 4; +inline bool Message_ListResponseMessage::_internal_has_contextinfo() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); + return value; +} +inline bool Message_ListResponseMessage::has_contextinfo() const { + return _internal_has_contextinfo(); +} +inline void Message_ListResponseMessage::clear_contextinfo() { + if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const ::proto::ContextInfo& Message_ListResponseMessage::_internal_contextinfo() const { + const ::proto::ContextInfo* p = _impl_.contextinfo_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ContextInfo_default_instance_); +} +inline const ::proto::ContextInfo& Message_ListResponseMessage::contextinfo() const { + // @@protoc_insertion_point(field_get:proto.Message.ListResponseMessage.contextInfo) + return _internal_contextinfo(); +} +inline void Message_ListResponseMessage::unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); + } + _impl_.contextinfo_ = contextinfo; + if (contextinfo) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ListResponseMessage.contextInfo) +} +inline ::proto::ContextInfo* Message_ListResponseMessage::release_contextinfo() { + _impl_._has_bits_[0] &= ~0x00000008u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ContextInfo* Message_ListResponseMessage::unsafe_arena_release_contextinfo() { + // @@protoc_insertion_point(field_release:proto.Message.ListResponseMessage.contextInfo) + _impl_._has_bits_[0] &= ~0x00000008u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; + return temp; +} +inline ::proto::ContextInfo* Message_ListResponseMessage::_internal_mutable_contextinfo() { + _impl_._has_bits_[0] |= 0x00000008u; + if (_impl_.contextinfo_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); + _impl_.contextinfo_ = p; + } + return _impl_.contextinfo_; +} +inline ::proto::ContextInfo* Message_ListResponseMessage::mutable_contextinfo() { + ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); + // @@protoc_insertion_point(field_mutable:proto.Message.ListResponseMessage.contextInfo) + return _msg; +} +inline void Message_ListResponseMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.contextinfo_; + } + if (contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); + if (message_arena != submessage_arena) { + contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, contextinfo, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.contextinfo_ = contextinfo; + // @@protoc_insertion_point(field_set_allocated:proto.Message.ListResponseMessage.contextInfo) +} + +// optional string description = 5; +inline bool Message_ListResponseMessage::_internal_has_description() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_ListResponseMessage::has_description() const { + return _internal_has_description(); +} +inline void Message_ListResponseMessage::clear_description() { + _impl_.description_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_ListResponseMessage::description() const { + // @@protoc_insertion_point(field_get:proto.Message.ListResponseMessage.description) + return _internal_description(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ListResponseMessage::set_description(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.description_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ListResponseMessage.description) +} +inline std::string* Message_ListResponseMessage::mutable_description() { + std::string* _s = _internal_mutable_description(); + // @@protoc_insertion_point(field_mutable:proto.Message.ListResponseMessage.description) + return _s; +} +inline const std::string& Message_ListResponseMessage::_internal_description() const { + return _impl_.description_.Get(); +} +inline void Message_ListResponseMessage::_internal_set_description(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.description_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ListResponseMessage::_internal_mutable_description() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.description_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ListResponseMessage::release_description() { + // @@protoc_insertion_point(field_release:proto.Message.ListResponseMessage.description) + if (!_internal_has_description()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.description_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.description_.IsDefault()) { + _impl_.description_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ListResponseMessage::set_allocated_description(std::string* description) { + if (description != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.description_.SetAllocated(description, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.description_.IsDefault()) { + _impl_.description_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ListResponseMessage.description) +} + +// ------------------------------------------------------------------- + +// Message_LiveLocationMessage + +// optional double degreesLatitude = 1; +inline bool Message_LiveLocationMessage::_internal_has_degreeslatitude() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool Message_LiveLocationMessage::has_degreeslatitude() const { + return _internal_has_degreeslatitude(); +} +inline void Message_LiveLocationMessage::clear_degreeslatitude() { + _impl_.degreeslatitude_ = 0; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline double Message_LiveLocationMessage::_internal_degreeslatitude() const { + return _impl_.degreeslatitude_; +} +inline double Message_LiveLocationMessage::degreeslatitude() const { + // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.degreesLatitude) + return _internal_degreeslatitude(); +} +inline void Message_LiveLocationMessage::_internal_set_degreeslatitude(double value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.degreeslatitude_ = value; +} +inline void Message_LiveLocationMessage::set_degreeslatitude(double value) { + _internal_set_degreeslatitude(value); + // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.degreesLatitude) +} + +// optional double degreesLongitude = 2; +inline bool Message_LiveLocationMessage::_internal_has_degreeslongitude() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool Message_LiveLocationMessage::has_degreeslongitude() const { + return _internal_has_degreeslongitude(); +} +inline void Message_LiveLocationMessage::clear_degreeslongitude() { + _impl_.degreeslongitude_ = 0; + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline double Message_LiveLocationMessage::_internal_degreeslongitude() const { + return _impl_.degreeslongitude_; +} +inline double Message_LiveLocationMessage::degreeslongitude() const { + // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.degreesLongitude) + return _internal_degreeslongitude(); +} +inline void Message_LiveLocationMessage::_internal_set_degreeslongitude(double value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.degreeslongitude_ = value; +} +inline void Message_LiveLocationMessage::set_degreeslongitude(double value) { + _internal_set_degreeslongitude(value); + // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.degreesLongitude) +} + +// optional uint32 accuracyInMeters = 3; +inline bool Message_LiveLocationMessage::_internal_has_accuracyinmeters() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool Message_LiveLocationMessage::has_accuracyinmeters() const { + return _internal_has_accuracyinmeters(); +} +inline void Message_LiveLocationMessage::clear_accuracyinmeters() { + _impl_.accuracyinmeters_ = 0u; + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline uint32_t Message_LiveLocationMessage::_internal_accuracyinmeters() const { + return _impl_.accuracyinmeters_; +} +inline uint32_t Message_LiveLocationMessage::accuracyinmeters() const { + // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.accuracyInMeters) + return _internal_accuracyinmeters(); +} +inline void Message_LiveLocationMessage::_internal_set_accuracyinmeters(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.accuracyinmeters_ = value; +} +inline void Message_LiveLocationMessage::set_accuracyinmeters(uint32_t value) { + _internal_set_accuracyinmeters(value); + // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.accuracyInMeters) +} + +// optional float speedInMps = 4; +inline bool Message_LiveLocationMessage::_internal_has_speedinmps() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool Message_LiveLocationMessage::has_speedinmps() const { + return _internal_has_speedinmps(); +} +inline void Message_LiveLocationMessage::clear_speedinmps() { + _impl_.speedinmps_ = 0; + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline float Message_LiveLocationMessage::_internal_speedinmps() const { + return _impl_.speedinmps_; +} +inline float Message_LiveLocationMessage::speedinmps() const { + // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.speedInMps) + return _internal_speedinmps(); +} +inline void Message_LiveLocationMessage::_internal_set_speedinmps(float value) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.speedinmps_ = value; +} +inline void Message_LiveLocationMessage::set_speedinmps(float value) { + _internal_set_speedinmps(value); + // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.speedInMps) +} + +// optional uint32 degreesClockwiseFromMagneticNorth = 5; +inline bool Message_LiveLocationMessage::_internal_has_degreesclockwisefrommagneticnorth() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool Message_LiveLocationMessage::has_degreesclockwisefrommagneticnorth() const { + return _internal_has_degreesclockwisefrommagneticnorth(); +} +inline void Message_LiveLocationMessage::clear_degreesclockwisefrommagneticnorth() { + _impl_.degreesclockwisefrommagneticnorth_ = 0u; + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline uint32_t Message_LiveLocationMessage::_internal_degreesclockwisefrommagneticnorth() const { + return _impl_.degreesclockwisefrommagneticnorth_; +} +inline uint32_t Message_LiveLocationMessage::degreesclockwisefrommagneticnorth() const { + // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.degreesClockwiseFromMagneticNorth) + return _internal_degreesclockwisefrommagneticnorth(); +} +inline void Message_LiveLocationMessage::_internal_set_degreesclockwisefrommagneticnorth(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.degreesclockwisefrommagneticnorth_ = value; +} +inline void Message_LiveLocationMessage::set_degreesclockwisefrommagneticnorth(uint32_t value) { + _internal_set_degreesclockwisefrommagneticnorth(value); + // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.degreesClockwiseFromMagneticNorth) +} + +// optional string caption = 6; +inline bool Message_LiveLocationMessage::_internal_has_caption() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_LiveLocationMessage::has_caption() const { + return _internal_has_caption(); +} +inline void Message_LiveLocationMessage::clear_caption() { + _impl_.caption_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_LiveLocationMessage::caption() const { + // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.caption) + return _internal_caption(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_LiveLocationMessage::set_caption(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.caption_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.caption) +} +inline std::string* Message_LiveLocationMessage::mutable_caption() { + std::string* _s = _internal_mutable_caption(); + // @@protoc_insertion_point(field_mutable:proto.Message.LiveLocationMessage.caption) + return _s; +} +inline const std::string& Message_LiveLocationMessage::_internal_caption() const { + return _impl_.caption_.Get(); +} +inline void Message_LiveLocationMessage::_internal_set_caption(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.caption_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_LiveLocationMessage::_internal_mutable_caption() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.caption_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_LiveLocationMessage::release_caption() { + // @@protoc_insertion_point(field_release:proto.Message.LiveLocationMessage.caption) + if (!_internal_has_caption()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.caption_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.caption_.IsDefault()) { + _impl_.caption_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_LiveLocationMessage::set_allocated_caption(std::string* caption) { + if (caption != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.caption_.SetAllocated(caption, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.caption_.IsDefault()) { + _impl_.caption_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.LiveLocationMessage.caption) +} + +// optional int64 sequenceNumber = 7; +inline bool Message_LiveLocationMessage::_internal_has_sequencenumber() const { + bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool Message_LiveLocationMessage::has_sequencenumber() const { + return _internal_has_sequencenumber(); +} +inline void Message_LiveLocationMessage::clear_sequencenumber() { + _impl_.sequencenumber_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000200u; +} +inline int64_t Message_LiveLocationMessage::_internal_sequencenumber() const { + return _impl_.sequencenumber_; +} +inline int64_t Message_LiveLocationMessage::sequencenumber() const { + // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.sequenceNumber) + return _internal_sequencenumber(); +} +inline void Message_LiveLocationMessage::_internal_set_sequencenumber(int64_t value) { + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.sequencenumber_ = value; +} +inline void Message_LiveLocationMessage::set_sequencenumber(int64_t value) { + _internal_set_sequencenumber(value); + // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.sequenceNumber) +} + +// optional uint32 timeOffset = 8; +inline bool Message_LiveLocationMessage::_internal_has_timeoffset() const { + bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool Message_LiveLocationMessage::has_timeoffset() const { + return _internal_has_timeoffset(); +} +inline void Message_LiveLocationMessage::clear_timeoffset() { + _impl_.timeoffset_ = 0u; + _impl_._has_bits_[0] &= ~0x00000100u; +} +inline uint32_t Message_LiveLocationMessage::_internal_timeoffset() const { + return _impl_.timeoffset_; +} +inline uint32_t Message_LiveLocationMessage::timeoffset() const { + // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.timeOffset) + return _internal_timeoffset(); +} +inline void Message_LiveLocationMessage::_internal_set_timeoffset(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.timeoffset_ = value; +} +inline void Message_LiveLocationMessage::set_timeoffset(uint32_t value) { + _internal_set_timeoffset(value); + // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.timeOffset) +} + +// optional bytes jpegThumbnail = 16; +inline bool Message_LiveLocationMessage::_internal_has_jpegthumbnail() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_LiveLocationMessage::has_jpegthumbnail() const { + return _internal_has_jpegthumbnail(); +} +inline void Message_LiveLocationMessage::clear_jpegthumbnail() { + _impl_.jpegthumbnail_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_LiveLocationMessage::jpegthumbnail() const { + // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.jpegThumbnail) + return _internal_jpegthumbnail(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_LiveLocationMessage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.jpegthumbnail_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.jpegThumbnail) +} +inline std::string* Message_LiveLocationMessage::mutable_jpegthumbnail() { + std::string* _s = _internal_mutable_jpegthumbnail(); + // @@protoc_insertion_point(field_mutable:proto.Message.LiveLocationMessage.jpegThumbnail) + return _s; +} +inline const std::string& Message_LiveLocationMessage::_internal_jpegthumbnail() const { + return _impl_.jpegthumbnail_.Get(); +} +inline void Message_LiveLocationMessage::_internal_set_jpegthumbnail(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_LiveLocationMessage::_internal_mutable_jpegthumbnail() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_LiveLocationMessage::release_jpegthumbnail() { + // @@protoc_insertion_point(field_release:proto.Message.LiveLocationMessage.jpegThumbnail) + if (!_internal_has_jpegthumbnail()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.jpegthumbnail_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.jpegthumbnail_.IsDefault()) { + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_LiveLocationMessage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) { + if (jpegthumbnail != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.jpegthumbnail_.IsDefault()) { + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.LiveLocationMessage.jpegThumbnail) +} + +// optional .proto.ContextInfo contextInfo = 17; +inline bool Message_LiveLocationMessage::_internal_has_contextinfo() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); + return value; +} +inline bool Message_LiveLocationMessage::has_contextinfo() const { + return _internal_has_contextinfo(); +} +inline void Message_LiveLocationMessage::clear_contextinfo() { + if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::proto::ContextInfo& Message_LiveLocationMessage::_internal_contextinfo() const { + const ::proto::ContextInfo* p = _impl_.contextinfo_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ContextInfo_default_instance_); +} +inline const ::proto::ContextInfo& Message_LiveLocationMessage::contextinfo() const { + // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.contextInfo) + return _internal_contextinfo(); +} +inline void Message_LiveLocationMessage::unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); + } + _impl_.contextinfo_ = contextinfo; + if (contextinfo) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.LiveLocationMessage.contextInfo) +} +inline ::proto::ContextInfo* Message_LiveLocationMessage::release_contextinfo() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ContextInfo* Message_LiveLocationMessage::unsafe_arena_release_contextinfo() { + // @@protoc_insertion_point(field_release:proto.Message.LiveLocationMessage.contextInfo) + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; + return temp; +} +inline ::proto::ContextInfo* Message_LiveLocationMessage::_internal_mutable_contextinfo() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.contextinfo_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); + _impl_.contextinfo_ = p; + } + return _impl_.contextinfo_; +} +inline ::proto::ContextInfo* Message_LiveLocationMessage::mutable_contextinfo() { + ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); + // @@protoc_insertion_point(field_mutable:proto.Message.LiveLocationMessage.contextInfo) + return _msg; +} +inline void Message_LiveLocationMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.contextinfo_; + } + if (contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); + if (message_arena != submessage_arena) { + contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, contextinfo, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.contextinfo_ = contextinfo; + // @@protoc_insertion_point(field_set_allocated:proto.Message.LiveLocationMessage.contextInfo) +} + +// ------------------------------------------------------------------- + +// Message_LocationMessage + +// optional double degreesLatitude = 1; +inline bool Message_LocationMessage::_internal_has_degreeslatitude() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool Message_LocationMessage::has_degreeslatitude() const { + return _internal_has_degreeslatitude(); +} +inline void Message_LocationMessage::clear_degreeslatitude() { + _impl_.degreeslatitude_ = 0; + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline double Message_LocationMessage::_internal_degreeslatitude() const { + return _impl_.degreeslatitude_; +} +inline double Message_LocationMessage::degreeslatitude() const { + // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.degreesLatitude) + return _internal_degreeslatitude(); +} +inline void Message_LocationMessage::_internal_set_degreeslatitude(double value) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.degreeslatitude_ = value; +} +inline void Message_LocationMessage::set_degreeslatitude(double value) { + _internal_set_degreeslatitude(value); + // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.degreesLatitude) +} + +// optional double degreesLongitude = 2; +inline bool Message_LocationMessage::_internal_has_degreeslongitude() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool Message_LocationMessage::has_degreeslongitude() const { + return _internal_has_degreeslongitude(); +} +inline void Message_LocationMessage::clear_degreeslongitude() { + _impl_.degreeslongitude_ = 0; + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline double Message_LocationMessage::_internal_degreeslongitude() const { + return _impl_.degreeslongitude_; +} +inline double Message_LocationMessage::degreeslongitude() const { + // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.degreesLongitude) + return _internal_degreeslongitude(); +} +inline void Message_LocationMessage::_internal_set_degreeslongitude(double value) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.degreeslongitude_ = value; +} +inline void Message_LocationMessage::set_degreeslongitude(double value) { + _internal_set_degreeslongitude(value); + // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.degreesLongitude) +} + +// optional string name = 3; +inline bool Message_LocationMessage::_internal_has_name() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_LocationMessage::has_name() const { + return _internal_has_name(); +} +inline void Message_LocationMessage::clear_name() { + _impl_.name_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_LocationMessage::name() const { + // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.name) + return _internal_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_LocationMessage::set_name(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.name) +} +inline std::string* Message_LocationMessage::mutable_name() { + std::string* _s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:proto.Message.LocationMessage.name) + return _s; +} +inline const std::string& Message_LocationMessage::_internal_name() const { + return _impl_.name_.Get(); +} +inline void Message_LocationMessage::_internal_set_name(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.name_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_LocationMessage::_internal_mutable_name() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.name_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_LocationMessage::release_name() { + // @@protoc_insertion_point(field_release:proto.Message.LocationMessage.name) + if (!_internal_has_name()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.name_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.name_.IsDefault()) { + _impl_.name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_LocationMessage::set_allocated_name(std::string* name) { + if (name != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.name_.SetAllocated(name, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.name_.IsDefault()) { + _impl_.name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.LocationMessage.name) +} + +// optional string address = 4; +inline bool Message_LocationMessage::_internal_has_address() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_LocationMessage::has_address() const { + return _internal_has_address(); +} +inline void Message_LocationMessage::clear_address() { + _impl_.address_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_LocationMessage::address() const { + // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.address) + return _internal_address(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_LocationMessage::set_address(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.address_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.address) +} +inline std::string* Message_LocationMessage::mutable_address() { + std::string* _s = _internal_mutable_address(); + // @@protoc_insertion_point(field_mutable:proto.Message.LocationMessage.address) + return _s; +} +inline const std::string& Message_LocationMessage::_internal_address() const { + return _impl_.address_.Get(); +} +inline void Message_LocationMessage::_internal_set_address(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.address_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_LocationMessage::_internal_mutable_address() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.address_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_LocationMessage::release_address() { + // @@protoc_insertion_point(field_release:proto.Message.LocationMessage.address) + if (!_internal_has_address()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.address_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.address_.IsDefault()) { + _impl_.address_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_LocationMessage::set_allocated_address(std::string* address) { + if (address != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.address_.SetAllocated(address, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.address_.IsDefault()) { + _impl_.address_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.LocationMessage.address) +} + +// optional string url = 5; +inline bool Message_LocationMessage::_internal_has_url() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Message_LocationMessage::has_url() const { + return _internal_has_url(); +} +inline void Message_LocationMessage::clear_url() { + _impl_.url_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& Message_LocationMessage::url() const { + // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.url) + return _internal_url(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_LocationMessage::set_url(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.url_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.url) +} +inline std::string* Message_LocationMessage::mutable_url() { + std::string* _s = _internal_mutable_url(); + // @@protoc_insertion_point(field_mutable:proto.Message.LocationMessage.url) + return _s; +} +inline const std::string& Message_LocationMessage::_internal_url() const { + return _impl_.url_.Get(); +} +inline void Message_LocationMessage::_internal_set_url(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.url_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_LocationMessage::_internal_mutable_url() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.url_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_LocationMessage::release_url() { + // @@protoc_insertion_point(field_release:proto.Message.LocationMessage.url) + if (!_internal_has_url()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.url_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.url_.IsDefault()) { + _impl_.url_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_LocationMessage::set_allocated_url(std::string* url) { + if (url != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.url_.SetAllocated(url, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.url_.IsDefault()) { + _impl_.url_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.LocationMessage.url) +} + +// optional bool isLive = 6; +inline bool Message_LocationMessage::_internal_has_islive() const { + bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool Message_LocationMessage::has_islive() const { + return _internal_has_islive(); +} +inline void Message_LocationMessage::clear_islive() { + _impl_.islive_ = false; + _impl_._has_bits_[0] &= ~0x00000100u; +} +inline bool Message_LocationMessage::_internal_islive() const { + return _impl_.islive_; +} +inline bool Message_LocationMessage::islive() const { + // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.isLive) + return _internal_islive(); +} +inline void Message_LocationMessage::_internal_set_islive(bool value) { + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.islive_ = value; +} +inline void Message_LocationMessage::set_islive(bool value) { + _internal_set_islive(value); + // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.isLive) +} + +// optional uint32 accuracyInMeters = 7; +inline bool Message_LocationMessage::_internal_has_accuracyinmeters() const { + bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool Message_LocationMessage::has_accuracyinmeters() const { + return _internal_has_accuracyinmeters(); +} +inline void Message_LocationMessage::clear_accuracyinmeters() { + _impl_.accuracyinmeters_ = 0u; + _impl_._has_bits_[0] &= ~0x00000200u; +} +inline uint32_t Message_LocationMessage::_internal_accuracyinmeters() const { + return _impl_.accuracyinmeters_; +} +inline uint32_t Message_LocationMessage::accuracyinmeters() const { + // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.accuracyInMeters) + return _internal_accuracyinmeters(); +} +inline void Message_LocationMessage::_internal_set_accuracyinmeters(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.accuracyinmeters_ = value; +} +inline void Message_LocationMessage::set_accuracyinmeters(uint32_t value) { + _internal_set_accuracyinmeters(value); + // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.accuracyInMeters) +} + +// optional float speedInMps = 8; +inline bool Message_LocationMessage::_internal_has_speedinmps() const { + bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool Message_LocationMessage::has_speedinmps() const { + return _internal_has_speedinmps(); +} +inline void Message_LocationMessage::clear_speedinmps() { + _impl_.speedinmps_ = 0; + _impl_._has_bits_[0] &= ~0x00000400u; +} +inline float Message_LocationMessage::_internal_speedinmps() const { + return _impl_.speedinmps_; +} +inline float Message_LocationMessage::speedinmps() const { + // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.speedInMps) + return _internal_speedinmps(); +} +inline void Message_LocationMessage::_internal_set_speedinmps(float value) { + _impl_._has_bits_[0] |= 0x00000400u; + _impl_.speedinmps_ = value; +} +inline void Message_LocationMessage::set_speedinmps(float value) { + _internal_set_speedinmps(value); + // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.speedInMps) +} + +// optional uint32 degreesClockwiseFromMagneticNorth = 9; +inline bool Message_LocationMessage::_internal_has_degreesclockwisefrommagneticnorth() const { + bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; + return value; +} +inline bool Message_LocationMessage::has_degreesclockwisefrommagneticnorth() const { + return _internal_has_degreesclockwisefrommagneticnorth(); +} +inline void Message_LocationMessage::clear_degreesclockwisefrommagneticnorth() { + _impl_.degreesclockwisefrommagneticnorth_ = 0u; + _impl_._has_bits_[0] &= ~0x00000800u; +} +inline uint32_t Message_LocationMessage::_internal_degreesclockwisefrommagneticnorth() const { + return _impl_.degreesclockwisefrommagneticnorth_; +} +inline uint32_t Message_LocationMessage::degreesclockwisefrommagneticnorth() const { + // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.degreesClockwiseFromMagneticNorth) + return _internal_degreesclockwisefrommagneticnorth(); +} +inline void Message_LocationMessage::_internal_set_degreesclockwisefrommagneticnorth(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000800u; + _impl_.degreesclockwisefrommagneticnorth_ = value; +} +inline void Message_LocationMessage::set_degreesclockwisefrommagneticnorth(uint32_t value) { + _internal_set_degreesclockwisefrommagneticnorth(value); + // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.degreesClockwiseFromMagneticNorth) +} + +// optional string comment = 11; +inline bool Message_LocationMessage::_internal_has_comment() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool Message_LocationMessage::has_comment() const { + return _internal_has_comment(); +} +inline void Message_LocationMessage::clear_comment() { + _impl_.comment_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const std::string& Message_LocationMessage::comment() const { + // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.comment) + return _internal_comment(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_LocationMessage::set_comment(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.comment_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.comment) +} +inline std::string* Message_LocationMessage::mutable_comment() { + std::string* _s = _internal_mutable_comment(); + // @@protoc_insertion_point(field_mutable:proto.Message.LocationMessage.comment) + return _s; +} +inline const std::string& Message_LocationMessage::_internal_comment() const { + return _impl_.comment_.Get(); +} +inline void Message_LocationMessage::_internal_set_comment(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.comment_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_LocationMessage::_internal_mutable_comment() { + _impl_._has_bits_[0] |= 0x00000008u; + return _impl_.comment_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_LocationMessage::release_comment() { + // @@protoc_insertion_point(field_release:proto.Message.LocationMessage.comment) + if (!_internal_has_comment()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000008u; + auto* p = _impl_.comment_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.comment_.IsDefault()) { + _impl_.comment_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_LocationMessage::set_allocated_comment(std::string* comment) { + if (comment != nullptr) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.comment_.SetAllocated(comment, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.comment_.IsDefault()) { + _impl_.comment_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.LocationMessage.comment) +} + +// optional bytes jpegThumbnail = 16; +inline bool Message_LocationMessage::_internal_has_jpegthumbnail() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool Message_LocationMessage::has_jpegthumbnail() const { + return _internal_has_jpegthumbnail(); +} +inline void Message_LocationMessage::clear_jpegthumbnail() { + _impl_.jpegthumbnail_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const std::string& Message_LocationMessage::jpegthumbnail() const { + // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.jpegThumbnail) + return _internal_jpegthumbnail(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_LocationMessage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.jpegthumbnail_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.jpegThumbnail) +} +inline std::string* Message_LocationMessage::mutable_jpegthumbnail() { + std::string* _s = _internal_mutable_jpegthumbnail(); + // @@protoc_insertion_point(field_mutable:proto.Message.LocationMessage.jpegThumbnail) + return _s; +} +inline const std::string& Message_LocationMessage::_internal_jpegthumbnail() const { + return _impl_.jpegthumbnail_.Get(); +} +inline void Message_LocationMessage::_internal_set_jpegthumbnail(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_LocationMessage::_internal_mutable_jpegthumbnail() { + _impl_._has_bits_[0] |= 0x00000010u; + return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_LocationMessage::release_jpegthumbnail() { + // @@protoc_insertion_point(field_release:proto.Message.LocationMessage.jpegThumbnail) + if (!_internal_has_jpegthumbnail()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000010u; + auto* p = _impl_.jpegthumbnail_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.jpegthumbnail_.IsDefault()) { + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_LocationMessage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) { + if (jpegthumbnail != nullptr) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.jpegthumbnail_.IsDefault()) { + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.LocationMessage.jpegThumbnail) +} + +// optional .proto.ContextInfo contextInfo = 17; +inline bool Message_LocationMessage::_internal_has_contextinfo() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); + return value; +} +inline bool Message_LocationMessage::has_contextinfo() const { + return _internal_has_contextinfo(); +} +inline void Message_LocationMessage::clear_contextinfo() { + if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline const ::proto::ContextInfo& Message_LocationMessage::_internal_contextinfo() const { + const ::proto::ContextInfo* p = _impl_.contextinfo_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ContextInfo_default_instance_); +} +inline const ::proto::ContextInfo& Message_LocationMessage::contextinfo() const { + // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.contextInfo) + return _internal_contextinfo(); +} +inline void Message_LocationMessage::unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); + } + _impl_.contextinfo_ = contextinfo; + if (contextinfo) { + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.LocationMessage.contextInfo) +} +inline ::proto::ContextInfo* Message_LocationMessage::release_contextinfo() { + _impl_._has_bits_[0] &= ~0x00000020u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ContextInfo* Message_LocationMessage::unsafe_arena_release_contextinfo() { + // @@protoc_insertion_point(field_release:proto.Message.LocationMessage.contextInfo) + _impl_._has_bits_[0] &= ~0x00000020u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; + return temp; +} +inline ::proto::ContextInfo* Message_LocationMessage::_internal_mutable_contextinfo() { + _impl_._has_bits_[0] |= 0x00000020u; + if (_impl_.contextinfo_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); + _impl_.contextinfo_ = p; + } + return _impl_.contextinfo_; +} +inline ::proto::ContextInfo* Message_LocationMessage::mutable_contextinfo() { + ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); + // @@protoc_insertion_point(field_mutable:proto.Message.LocationMessage.contextInfo) + return _msg; +} +inline void Message_LocationMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.contextinfo_; + } + if (contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); + if (message_arena != submessage_arena) { + contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, contextinfo, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + _impl_.contextinfo_ = contextinfo; + // @@protoc_insertion_point(field_set_allocated:proto.Message.LocationMessage.contextInfo) +} + +// ------------------------------------------------------------------- + +// Message_OrderMessage + +// optional string orderId = 1; +inline bool Message_OrderMessage::_internal_has_orderid() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_OrderMessage::has_orderid() const { + return _internal_has_orderid(); +} +inline void Message_OrderMessage::clear_orderid() { + _impl_.orderid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_OrderMessage::orderid() const { + // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.orderId) + return _internal_orderid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_OrderMessage::set_orderid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.orderid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.orderId) +} +inline std::string* Message_OrderMessage::mutable_orderid() { + std::string* _s = _internal_mutable_orderid(); + // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.orderId) + return _s; +} +inline const std::string& Message_OrderMessage::_internal_orderid() const { + return _impl_.orderid_.Get(); +} +inline void Message_OrderMessage::_internal_set_orderid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.orderid_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_OrderMessage::_internal_mutable_orderid() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.orderid_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_OrderMessage::release_orderid() { + // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.orderId) + if (!_internal_has_orderid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.orderid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.orderid_.IsDefault()) { + _impl_.orderid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_OrderMessage::set_allocated_orderid(std::string* orderid) { + if (orderid != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.orderid_.SetAllocated(orderid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.orderid_.IsDefault()) { + _impl_.orderid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.OrderMessage.orderId) +} + +// optional bytes thumbnail = 2; +inline bool Message_OrderMessage::_internal_has_thumbnail() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_OrderMessage::has_thumbnail() const { + return _internal_has_thumbnail(); +} +inline void Message_OrderMessage::clear_thumbnail() { + _impl_.thumbnail_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_OrderMessage::thumbnail() const { + // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.thumbnail) + return _internal_thumbnail(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_OrderMessage::set_thumbnail(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.thumbnail_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.thumbnail) +} +inline std::string* Message_OrderMessage::mutable_thumbnail() { + std::string* _s = _internal_mutable_thumbnail(); + // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.thumbnail) + return _s; +} +inline const std::string& Message_OrderMessage::_internal_thumbnail() const { + return _impl_.thumbnail_.Get(); +} +inline void Message_OrderMessage::_internal_set_thumbnail(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.thumbnail_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_OrderMessage::_internal_mutable_thumbnail() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.thumbnail_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_OrderMessage::release_thumbnail() { + // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.thumbnail) + if (!_internal_has_thumbnail()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.thumbnail_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.thumbnail_.IsDefault()) { + _impl_.thumbnail_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_OrderMessage::set_allocated_thumbnail(std::string* thumbnail) { + if (thumbnail != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.thumbnail_.SetAllocated(thumbnail, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.thumbnail_.IsDefault()) { + _impl_.thumbnail_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.OrderMessage.thumbnail) +} + +// optional int32 itemCount = 3; +inline bool Message_OrderMessage::_internal_has_itemcount() const { + bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool Message_OrderMessage::has_itemcount() const { + return _internal_has_itemcount(); +} +inline void Message_OrderMessage::clear_itemcount() { + _impl_.itemcount_ = 0; + _impl_._has_bits_[0] &= ~0x00000200u; +} +inline int32_t Message_OrderMessage::_internal_itemcount() const { + return _impl_.itemcount_; +} +inline int32_t Message_OrderMessage::itemcount() const { + // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.itemCount) + return _internal_itemcount(); +} +inline void Message_OrderMessage::_internal_set_itemcount(int32_t value) { + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.itemcount_ = value; +} +inline void Message_OrderMessage::set_itemcount(int32_t value) { + _internal_set_itemcount(value); + // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.itemCount) +} + +// optional .proto.Message.OrderMessage.OrderStatus status = 4; +inline bool Message_OrderMessage::_internal_has_status() const { + bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool Message_OrderMessage::has_status() const { + return _internal_has_status(); +} +inline void Message_OrderMessage::clear_status() { + _impl_.status_ = 1; + _impl_._has_bits_[0] &= ~0x00000400u; +} +inline ::proto::Message_OrderMessage_OrderStatus Message_OrderMessage::_internal_status() const { + return static_cast< ::proto::Message_OrderMessage_OrderStatus >(_impl_.status_); +} +inline ::proto::Message_OrderMessage_OrderStatus Message_OrderMessage::status() const { + // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.status) + return _internal_status(); +} +inline void Message_OrderMessage::_internal_set_status(::proto::Message_OrderMessage_OrderStatus value) { + assert(::proto::Message_OrderMessage_OrderStatus_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000400u; + _impl_.status_ = value; +} +inline void Message_OrderMessage::set_status(::proto::Message_OrderMessage_OrderStatus value) { + _internal_set_status(value); + // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.status) +} + +// optional .proto.Message.OrderMessage.OrderSurface surface = 5; +inline bool Message_OrderMessage::_internal_has_surface() const { + bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; + return value; +} +inline bool Message_OrderMessage::has_surface() const { + return _internal_has_surface(); +} +inline void Message_OrderMessage::clear_surface() { + _impl_.surface_ = 1; + _impl_._has_bits_[0] &= ~0x00000800u; +} +inline ::proto::Message_OrderMessage_OrderSurface Message_OrderMessage::_internal_surface() const { + return static_cast< ::proto::Message_OrderMessage_OrderSurface >(_impl_.surface_); +} +inline ::proto::Message_OrderMessage_OrderSurface Message_OrderMessage::surface() const { + // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.surface) + return _internal_surface(); +} +inline void Message_OrderMessage::_internal_set_surface(::proto::Message_OrderMessage_OrderSurface value) { + assert(::proto::Message_OrderMessage_OrderSurface_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000800u; + _impl_.surface_ = value; +} +inline void Message_OrderMessage::set_surface(::proto::Message_OrderMessage_OrderSurface value) { + _internal_set_surface(value); + // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.surface) +} + +// optional string message = 6; +inline bool Message_OrderMessage::_internal_has_message() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Message_OrderMessage::has_message() const { + return _internal_has_message(); +} +inline void Message_OrderMessage::clear_message() { + _impl_.message_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& Message_OrderMessage::message() const { + // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.message) + return _internal_message(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_OrderMessage::set_message(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.message_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.message) +} +inline std::string* Message_OrderMessage::mutable_message() { + std::string* _s = _internal_mutable_message(); + // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.message) + return _s; +} +inline const std::string& Message_OrderMessage::_internal_message() const { + return _impl_.message_.Get(); +} +inline void Message_OrderMessage::_internal_set_message(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.message_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_OrderMessage::_internal_mutable_message() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.message_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_OrderMessage::release_message() { + // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.message) + if (!_internal_has_message()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.message_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.message_.IsDefault()) { + _impl_.message_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_OrderMessage::set_allocated_message(std::string* message) { + if (message != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.message_.SetAllocated(message, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.message_.IsDefault()) { + _impl_.message_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.OrderMessage.message) +} + +// optional string orderTitle = 7; +inline bool Message_OrderMessage::_internal_has_ordertitle() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool Message_OrderMessage::has_ordertitle() const { + return _internal_has_ordertitle(); +} +inline void Message_OrderMessage::clear_ordertitle() { + _impl_.ordertitle_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const std::string& Message_OrderMessage::ordertitle() const { + // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.orderTitle) + return _internal_ordertitle(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_OrderMessage::set_ordertitle(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.ordertitle_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.orderTitle) +} +inline std::string* Message_OrderMessage::mutable_ordertitle() { + std::string* _s = _internal_mutable_ordertitle(); + // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.orderTitle) + return _s; +} +inline const std::string& Message_OrderMessage::_internal_ordertitle() const { + return _impl_.ordertitle_.Get(); +} +inline void Message_OrderMessage::_internal_set_ordertitle(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.ordertitle_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_OrderMessage::_internal_mutable_ordertitle() { + _impl_._has_bits_[0] |= 0x00000008u; + return _impl_.ordertitle_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_OrderMessage::release_ordertitle() { + // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.orderTitle) + if (!_internal_has_ordertitle()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000008u; + auto* p = _impl_.ordertitle_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.ordertitle_.IsDefault()) { + _impl_.ordertitle_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_OrderMessage::set_allocated_ordertitle(std::string* ordertitle) { + if (ordertitle != nullptr) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.ordertitle_.SetAllocated(ordertitle, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.ordertitle_.IsDefault()) { + _impl_.ordertitle_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.OrderMessage.orderTitle) +} + +// optional string sellerJid = 8; +inline bool Message_OrderMessage::_internal_has_sellerjid() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool Message_OrderMessage::has_sellerjid() const { + return _internal_has_sellerjid(); +} +inline void Message_OrderMessage::clear_sellerjid() { + _impl_.sellerjid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const std::string& Message_OrderMessage::sellerjid() const { + // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.sellerJid) + return _internal_sellerjid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_OrderMessage::set_sellerjid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.sellerjid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.sellerJid) +} +inline std::string* Message_OrderMessage::mutable_sellerjid() { + std::string* _s = _internal_mutable_sellerjid(); + // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.sellerJid) + return _s; +} +inline const std::string& Message_OrderMessage::_internal_sellerjid() const { + return _impl_.sellerjid_.Get(); +} +inline void Message_OrderMessage::_internal_set_sellerjid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.sellerjid_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_OrderMessage::_internal_mutable_sellerjid() { + _impl_._has_bits_[0] |= 0x00000010u; + return _impl_.sellerjid_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_OrderMessage::release_sellerjid() { + // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.sellerJid) + if (!_internal_has_sellerjid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000010u; + auto* p = _impl_.sellerjid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.sellerjid_.IsDefault()) { + _impl_.sellerjid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_OrderMessage::set_allocated_sellerjid(std::string* sellerjid) { + if (sellerjid != nullptr) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.sellerjid_.SetAllocated(sellerjid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.sellerjid_.IsDefault()) { + _impl_.sellerjid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.OrderMessage.sellerJid) +} + +// optional string token = 9; +inline bool Message_OrderMessage::_internal_has_token() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool Message_OrderMessage::has_token() const { + return _internal_has_token(); +} +inline void Message_OrderMessage::clear_token() { + _impl_.token_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline const std::string& Message_OrderMessage::token() const { + // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.token) + return _internal_token(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_OrderMessage::set_token(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.token_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.token) +} +inline std::string* Message_OrderMessage::mutable_token() { + std::string* _s = _internal_mutable_token(); + // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.token) + return _s; +} +inline const std::string& Message_OrderMessage::_internal_token() const { + return _impl_.token_.Get(); +} +inline void Message_OrderMessage::_internal_set_token(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.token_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_OrderMessage::_internal_mutable_token() { + _impl_._has_bits_[0] |= 0x00000020u; + return _impl_.token_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_OrderMessage::release_token() { + // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.token) + if (!_internal_has_token()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000020u; + auto* p = _impl_.token_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.token_.IsDefault()) { + _impl_.token_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_OrderMessage::set_allocated_token(std::string* token) { + if (token != nullptr) { + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + _impl_.token_.SetAllocated(token, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.token_.IsDefault()) { + _impl_.token_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.OrderMessage.token) +} + +// optional int64 totalAmount1000 = 10; +inline bool Message_OrderMessage::_internal_has_totalamount1000() const { + bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool Message_OrderMessage::has_totalamount1000() const { + return _internal_has_totalamount1000(); +} +inline void Message_OrderMessage::clear_totalamount1000() { + _impl_.totalamount1000_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000100u; +} +inline int64_t Message_OrderMessage::_internal_totalamount1000() const { + return _impl_.totalamount1000_; +} +inline int64_t Message_OrderMessage::totalamount1000() const { + // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.totalAmount1000) + return _internal_totalamount1000(); +} +inline void Message_OrderMessage::_internal_set_totalamount1000(int64_t value) { + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.totalamount1000_ = value; +} +inline void Message_OrderMessage::set_totalamount1000(int64_t value) { + _internal_set_totalamount1000(value); + // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.totalAmount1000) +} + +// optional string totalCurrencyCode = 11; +inline bool Message_OrderMessage::_internal_has_totalcurrencycode() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool Message_OrderMessage::has_totalcurrencycode() const { + return _internal_has_totalcurrencycode(); +} +inline void Message_OrderMessage::clear_totalcurrencycode() { + _impl_.totalcurrencycode_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline const std::string& Message_OrderMessage::totalcurrencycode() const { + // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.totalCurrencyCode) + return _internal_totalcurrencycode(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_OrderMessage::set_totalcurrencycode(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.totalcurrencycode_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.totalCurrencyCode) +} +inline std::string* Message_OrderMessage::mutable_totalcurrencycode() { + std::string* _s = _internal_mutable_totalcurrencycode(); + // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.totalCurrencyCode) + return _s; +} +inline const std::string& Message_OrderMessage::_internal_totalcurrencycode() const { + return _impl_.totalcurrencycode_.Get(); +} +inline void Message_OrderMessage::_internal_set_totalcurrencycode(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.totalcurrencycode_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_OrderMessage::_internal_mutable_totalcurrencycode() { + _impl_._has_bits_[0] |= 0x00000040u; + return _impl_.totalcurrencycode_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_OrderMessage::release_totalcurrencycode() { + // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.totalCurrencyCode) + if (!_internal_has_totalcurrencycode()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000040u; + auto* p = _impl_.totalcurrencycode_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.totalcurrencycode_.IsDefault()) { + _impl_.totalcurrencycode_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_OrderMessage::set_allocated_totalcurrencycode(std::string* totalcurrencycode) { + if (totalcurrencycode != nullptr) { + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + _impl_.totalcurrencycode_.SetAllocated(totalcurrencycode, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.totalcurrencycode_.IsDefault()) { + _impl_.totalcurrencycode_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.OrderMessage.totalCurrencyCode) +} + +// optional .proto.ContextInfo contextInfo = 17; +inline bool Message_OrderMessage::_internal_has_contextinfo() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); + return value; +} +inline bool Message_OrderMessage::has_contextinfo() const { + return _internal_has_contextinfo(); +} +inline void Message_OrderMessage::clear_contextinfo() { + if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline const ::proto::ContextInfo& Message_OrderMessage::_internal_contextinfo() const { + const ::proto::ContextInfo* p = _impl_.contextinfo_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ContextInfo_default_instance_); +} +inline const ::proto::ContextInfo& Message_OrderMessage::contextinfo() const { + // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.contextInfo) + return _internal_contextinfo(); +} +inline void Message_OrderMessage::unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); + } + _impl_.contextinfo_ = contextinfo; + if (contextinfo) { + _impl_._has_bits_[0] |= 0x00000080u; + } else { + _impl_._has_bits_[0] &= ~0x00000080u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.OrderMessage.contextInfo) +} +inline ::proto::ContextInfo* Message_OrderMessage::release_contextinfo() { + _impl_._has_bits_[0] &= ~0x00000080u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ContextInfo* Message_OrderMessage::unsafe_arena_release_contextinfo() { + // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.contextInfo) + _impl_._has_bits_[0] &= ~0x00000080u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; + return temp; +} +inline ::proto::ContextInfo* Message_OrderMessage::_internal_mutable_contextinfo() { + _impl_._has_bits_[0] |= 0x00000080u; + if (_impl_.contextinfo_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); + _impl_.contextinfo_ = p; + } + return _impl_.contextinfo_; +} +inline ::proto::ContextInfo* Message_OrderMessage::mutable_contextinfo() { + ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); + // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.contextInfo) + return _msg; +} +inline void Message_OrderMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.contextinfo_; + } + if (contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); + if (message_arena != submessage_arena) { + contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, contextinfo, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000080u; + } else { + _impl_._has_bits_[0] &= ~0x00000080u; + } + _impl_.contextinfo_ = contextinfo; + // @@protoc_insertion_point(field_set_allocated:proto.Message.OrderMessage.contextInfo) +} + +// ------------------------------------------------------------------- + +// Message_PaymentInviteMessage + +// optional .proto.Message.PaymentInviteMessage.ServiceType serviceType = 1; +inline bool Message_PaymentInviteMessage::_internal_has_servicetype() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_PaymentInviteMessage::has_servicetype() const { + return _internal_has_servicetype(); +} +inline void Message_PaymentInviteMessage::clear_servicetype() { + _impl_.servicetype_ = 0; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline ::proto::Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage::_internal_servicetype() const { + return static_cast< ::proto::Message_PaymentInviteMessage_ServiceType >(_impl_.servicetype_); +} +inline ::proto::Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage::servicetype() const { + // @@protoc_insertion_point(field_get:proto.Message.PaymentInviteMessage.serviceType) + return _internal_servicetype(); +} +inline void Message_PaymentInviteMessage::_internal_set_servicetype(::proto::Message_PaymentInviteMessage_ServiceType value) { + assert(::proto::Message_PaymentInviteMessage_ServiceType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.servicetype_ = value; +} +inline void Message_PaymentInviteMessage::set_servicetype(::proto::Message_PaymentInviteMessage_ServiceType value) { + _internal_set_servicetype(value); + // @@protoc_insertion_point(field_set:proto.Message.PaymentInviteMessage.serviceType) +} + +// optional int64 expiryTimestamp = 2; +inline bool Message_PaymentInviteMessage::_internal_has_expirytimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_PaymentInviteMessage::has_expirytimestamp() const { + return _internal_has_expirytimestamp(); +} +inline void Message_PaymentInviteMessage::clear_expirytimestamp() { + _impl_.expirytimestamp_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline int64_t Message_PaymentInviteMessage::_internal_expirytimestamp() const { + return _impl_.expirytimestamp_; +} +inline int64_t Message_PaymentInviteMessage::expirytimestamp() const { + // @@protoc_insertion_point(field_get:proto.Message.PaymentInviteMessage.expiryTimestamp) + return _internal_expirytimestamp(); +} +inline void Message_PaymentInviteMessage::_internal_set_expirytimestamp(int64_t value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.expirytimestamp_ = value; +} +inline void Message_PaymentInviteMessage::set_expirytimestamp(int64_t value) { + _internal_set_expirytimestamp(value); + // @@protoc_insertion_point(field_set:proto.Message.PaymentInviteMessage.expiryTimestamp) +} + +// ------------------------------------------------------------------- + +// Message_PollCreationMessage_Option + +// optional string optionName = 1; +inline bool Message_PollCreationMessage_Option::_internal_has_optionname() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_PollCreationMessage_Option::has_optionname() const { + return _internal_has_optionname(); +} +inline void Message_PollCreationMessage_Option::clear_optionname() { + _impl_.optionname_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_PollCreationMessage_Option::optionname() const { + // @@protoc_insertion_point(field_get:proto.Message.PollCreationMessage.Option.optionName) + return _internal_optionname(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_PollCreationMessage_Option::set_optionname(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.optionname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.PollCreationMessage.Option.optionName) +} +inline std::string* Message_PollCreationMessage_Option::mutable_optionname() { + std::string* _s = _internal_mutable_optionname(); + // @@protoc_insertion_point(field_mutable:proto.Message.PollCreationMessage.Option.optionName) + return _s; +} +inline const std::string& Message_PollCreationMessage_Option::_internal_optionname() const { + return _impl_.optionname_.Get(); +} +inline void Message_PollCreationMessage_Option::_internal_set_optionname(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.optionname_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_PollCreationMessage_Option::_internal_mutable_optionname() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.optionname_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_PollCreationMessage_Option::release_optionname() { + // @@protoc_insertion_point(field_release:proto.Message.PollCreationMessage.Option.optionName) + if (!_internal_has_optionname()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.optionname_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.optionname_.IsDefault()) { + _impl_.optionname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_PollCreationMessage_Option::set_allocated_optionname(std::string* optionname) { + if (optionname != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.optionname_.SetAllocated(optionname, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.optionname_.IsDefault()) { + _impl_.optionname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.PollCreationMessage.Option.optionName) +} + +// ------------------------------------------------------------------- + +// Message_PollCreationMessage + +// optional bytes encKey = 1; +inline bool Message_PollCreationMessage::_internal_has_enckey() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_PollCreationMessage::has_enckey() const { + return _internal_has_enckey(); +} +inline void Message_PollCreationMessage::clear_enckey() { + _impl_.enckey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_PollCreationMessage::enckey() const { + // @@protoc_insertion_point(field_get:proto.Message.PollCreationMessage.encKey) + return _internal_enckey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_PollCreationMessage::set_enckey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.enckey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.PollCreationMessage.encKey) +} +inline std::string* Message_PollCreationMessage::mutable_enckey() { + std::string* _s = _internal_mutable_enckey(); + // @@protoc_insertion_point(field_mutable:proto.Message.PollCreationMessage.encKey) + return _s; +} +inline const std::string& Message_PollCreationMessage::_internal_enckey() const { + return _impl_.enckey_.Get(); +} +inline void Message_PollCreationMessage::_internal_set_enckey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.enckey_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_PollCreationMessage::_internal_mutable_enckey() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.enckey_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_PollCreationMessage::release_enckey() { + // @@protoc_insertion_point(field_release:proto.Message.PollCreationMessage.encKey) + if (!_internal_has_enckey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.enckey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.enckey_.IsDefault()) { + _impl_.enckey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_PollCreationMessage::set_allocated_enckey(std::string* enckey) { + if (enckey != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.enckey_.SetAllocated(enckey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.enckey_.IsDefault()) { + _impl_.enckey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.PollCreationMessage.encKey) +} + +// optional string name = 2; +inline bool Message_PollCreationMessage::_internal_has_name() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_PollCreationMessage::has_name() const { + return _internal_has_name(); +} +inline void Message_PollCreationMessage::clear_name() { + _impl_.name_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_PollCreationMessage::name() const { + // @@protoc_insertion_point(field_get:proto.Message.PollCreationMessage.name) + return _internal_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_PollCreationMessage::set_name(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.PollCreationMessage.name) +} +inline std::string* Message_PollCreationMessage::mutable_name() { + std::string* _s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:proto.Message.PollCreationMessage.name) + return _s; +} +inline const std::string& Message_PollCreationMessage::_internal_name() const { + return _impl_.name_.Get(); +} +inline void Message_PollCreationMessage::_internal_set_name(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.name_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_PollCreationMessage::_internal_mutable_name() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.name_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_PollCreationMessage::release_name() { + // @@protoc_insertion_point(field_release:proto.Message.PollCreationMessage.name) + if (!_internal_has_name()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.name_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.name_.IsDefault()) { + _impl_.name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_PollCreationMessage::set_allocated_name(std::string* name) { + if (name != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.name_.SetAllocated(name, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.name_.IsDefault()) { + _impl_.name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.PollCreationMessage.name) +} + +// repeated .proto.Message.PollCreationMessage.Option options = 3; +inline int Message_PollCreationMessage::_internal_options_size() const { + return _impl_.options_.size(); +} +inline int Message_PollCreationMessage::options_size() const { + return _internal_options_size(); +} +inline void Message_PollCreationMessage::clear_options() { + _impl_.options_.Clear(); +} +inline ::proto::Message_PollCreationMessage_Option* Message_PollCreationMessage::mutable_options(int index) { + // @@protoc_insertion_point(field_mutable:proto.Message.PollCreationMessage.options) + return _impl_.options_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_PollCreationMessage_Option >* +Message_PollCreationMessage::mutable_options() { + // @@protoc_insertion_point(field_mutable_list:proto.Message.PollCreationMessage.options) + return &_impl_.options_; +} +inline const ::proto::Message_PollCreationMessage_Option& Message_PollCreationMessage::_internal_options(int index) const { + return _impl_.options_.Get(index); +} +inline const ::proto::Message_PollCreationMessage_Option& Message_PollCreationMessage::options(int index) const { + // @@protoc_insertion_point(field_get:proto.Message.PollCreationMessage.options) + return _internal_options(index); +} +inline ::proto::Message_PollCreationMessage_Option* Message_PollCreationMessage::_internal_add_options() { + return _impl_.options_.Add(); +} +inline ::proto::Message_PollCreationMessage_Option* Message_PollCreationMessage::add_options() { + ::proto::Message_PollCreationMessage_Option* _add = _internal_add_options(); + // @@protoc_insertion_point(field_add:proto.Message.PollCreationMessage.options) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_PollCreationMessage_Option >& +Message_PollCreationMessage::options() const { + // @@protoc_insertion_point(field_list:proto.Message.PollCreationMessage.options) + return _impl_.options_; +} + +// optional uint32 selectableOptionsCount = 4; +inline bool Message_PollCreationMessage::_internal_has_selectableoptionscount() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool Message_PollCreationMessage::has_selectableoptionscount() const { + return _internal_has_selectableoptionscount(); +} +inline void Message_PollCreationMessage::clear_selectableoptionscount() { + _impl_.selectableoptionscount_ = 0u; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline uint32_t Message_PollCreationMessage::_internal_selectableoptionscount() const { + return _impl_.selectableoptionscount_; +} +inline uint32_t Message_PollCreationMessage::selectableoptionscount() const { + // @@protoc_insertion_point(field_get:proto.Message.PollCreationMessage.selectableOptionsCount) + return _internal_selectableoptionscount(); +} +inline void Message_PollCreationMessage::_internal_set_selectableoptionscount(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.selectableoptionscount_ = value; +} +inline void Message_PollCreationMessage::set_selectableoptionscount(uint32_t value) { + _internal_set_selectableoptionscount(value); + // @@protoc_insertion_point(field_set:proto.Message.PollCreationMessage.selectableOptionsCount) +} + +// optional .proto.ContextInfo contextInfo = 5; +inline bool Message_PollCreationMessage::_internal_has_contextinfo() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); + return value; +} +inline bool Message_PollCreationMessage::has_contextinfo() const { + return _internal_has_contextinfo(); +} +inline void Message_PollCreationMessage::clear_contextinfo() { + if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::proto::ContextInfo& Message_PollCreationMessage::_internal_contextinfo() const { + const ::proto::ContextInfo* p = _impl_.contextinfo_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ContextInfo_default_instance_); +} +inline const ::proto::ContextInfo& Message_PollCreationMessage::contextinfo() const { + // @@protoc_insertion_point(field_get:proto.Message.PollCreationMessage.contextInfo) + return _internal_contextinfo(); +} +inline void Message_PollCreationMessage::unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); + } + _impl_.contextinfo_ = contextinfo; + if (contextinfo) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.PollCreationMessage.contextInfo) +} +inline ::proto::ContextInfo* Message_PollCreationMessage::release_contextinfo() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ContextInfo* Message_PollCreationMessage::unsafe_arena_release_contextinfo() { + // @@protoc_insertion_point(field_release:proto.Message.PollCreationMessage.contextInfo) + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; + return temp; +} +inline ::proto::ContextInfo* Message_PollCreationMessage::_internal_mutable_contextinfo() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.contextinfo_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); + _impl_.contextinfo_ = p; + } + return _impl_.contextinfo_; +} +inline ::proto::ContextInfo* Message_PollCreationMessage::mutable_contextinfo() { + ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); + // @@protoc_insertion_point(field_mutable:proto.Message.PollCreationMessage.contextInfo) + return _msg; +} +inline void Message_PollCreationMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.contextinfo_; + } + if (contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); + if (message_arena != submessage_arena) { + contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, contextinfo, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.contextinfo_ = contextinfo; + // @@protoc_insertion_point(field_set_allocated:proto.Message.PollCreationMessage.contextInfo) +} + +// ------------------------------------------------------------------- + +// Message_PollEncValue + +// optional bytes encPayload = 1; +inline bool Message_PollEncValue::_internal_has_encpayload() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_PollEncValue::has_encpayload() const { + return _internal_has_encpayload(); +} +inline void Message_PollEncValue::clear_encpayload() { + _impl_.encpayload_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_PollEncValue::encpayload() const { + // @@protoc_insertion_point(field_get:proto.Message.PollEncValue.encPayload) + return _internal_encpayload(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_PollEncValue::set_encpayload(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.encpayload_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.PollEncValue.encPayload) +} +inline std::string* Message_PollEncValue::mutable_encpayload() { + std::string* _s = _internal_mutable_encpayload(); + // @@protoc_insertion_point(field_mutable:proto.Message.PollEncValue.encPayload) + return _s; +} +inline const std::string& Message_PollEncValue::_internal_encpayload() const { + return _impl_.encpayload_.Get(); +} +inline void Message_PollEncValue::_internal_set_encpayload(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.encpayload_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_PollEncValue::_internal_mutable_encpayload() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.encpayload_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_PollEncValue::release_encpayload() { + // @@protoc_insertion_point(field_release:proto.Message.PollEncValue.encPayload) + if (!_internal_has_encpayload()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.encpayload_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.encpayload_.IsDefault()) { + _impl_.encpayload_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_PollEncValue::set_allocated_encpayload(std::string* encpayload) { + if (encpayload != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.encpayload_.SetAllocated(encpayload, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.encpayload_.IsDefault()) { + _impl_.encpayload_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.PollEncValue.encPayload) +} + +// optional bytes encIv = 2; +inline bool Message_PollEncValue::_internal_has_enciv() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_PollEncValue::has_enciv() const { + return _internal_has_enciv(); +} +inline void Message_PollEncValue::clear_enciv() { + _impl_.enciv_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_PollEncValue::enciv() const { + // @@protoc_insertion_point(field_get:proto.Message.PollEncValue.encIv) + return _internal_enciv(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_PollEncValue::set_enciv(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.enciv_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.PollEncValue.encIv) +} +inline std::string* Message_PollEncValue::mutable_enciv() { + std::string* _s = _internal_mutable_enciv(); + // @@protoc_insertion_point(field_mutable:proto.Message.PollEncValue.encIv) + return _s; +} +inline const std::string& Message_PollEncValue::_internal_enciv() const { + return _impl_.enciv_.Get(); +} +inline void Message_PollEncValue::_internal_set_enciv(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.enciv_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_PollEncValue::_internal_mutable_enciv() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.enciv_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_PollEncValue::release_enciv() { + // @@protoc_insertion_point(field_release:proto.Message.PollEncValue.encIv) + if (!_internal_has_enciv()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.enciv_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.enciv_.IsDefault()) { + _impl_.enciv_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_PollEncValue::set_allocated_enciv(std::string* enciv) { + if (enciv != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.enciv_.SetAllocated(enciv, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.enciv_.IsDefault()) { + _impl_.enciv_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.PollEncValue.encIv) +} + +// ------------------------------------------------------------------- + +// Message_PollUpdateMessageMetadata + +// ------------------------------------------------------------------- + +// Message_PollUpdateMessage + +// optional .proto.MessageKey pollCreationMessageKey = 1; +inline bool Message_PollUpdateMessage::_internal_has_pollcreationmessagekey() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.pollcreationmessagekey_ != nullptr); + return value; +} +inline bool Message_PollUpdateMessage::has_pollcreationmessagekey() const { + return _internal_has_pollcreationmessagekey(); +} +inline void Message_PollUpdateMessage::clear_pollcreationmessagekey() { + if (_impl_.pollcreationmessagekey_ != nullptr) _impl_.pollcreationmessagekey_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::MessageKey& Message_PollUpdateMessage::_internal_pollcreationmessagekey() const { + const ::proto::MessageKey* p = _impl_.pollcreationmessagekey_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_MessageKey_default_instance_); +} +inline const ::proto::MessageKey& Message_PollUpdateMessage::pollcreationmessagekey() const { + // @@protoc_insertion_point(field_get:proto.Message.PollUpdateMessage.pollCreationMessageKey) + return _internal_pollcreationmessagekey(); +} +inline void Message_PollUpdateMessage::unsafe_arena_set_allocated_pollcreationmessagekey( + ::proto::MessageKey* pollcreationmessagekey) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pollcreationmessagekey_); + } + _impl_.pollcreationmessagekey_ = pollcreationmessagekey; + if (pollcreationmessagekey) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.PollUpdateMessage.pollCreationMessageKey) +} +inline ::proto::MessageKey* Message_PollUpdateMessage::release_pollcreationmessagekey() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::MessageKey* temp = _impl_.pollcreationmessagekey_; + _impl_.pollcreationmessagekey_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::MessageKey* Message_PollUpdateMessage::unsafe_arena_release_pollcreationmessagekey() { + // @@protoc_insertion_point(field_release:proto.Message.PollUpdateMessage.pollCreationMessageKey) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::MessageKey* temp = _impl_.pollcreationmessagekey_; + _impl_.pollcreationmessagekey_ = nullptr; + return temp; +} +inline ::proto::MessageKey* Message_PollUpdateMessage::_internal_mutable_pollcreationmessagekey() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.pollcreationmessagekey_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation()); + _impl_.pollcreationmessagekey_ = p; + } + return _impl_.pollcreationmessagekey_; +} +inline ::proto::MessageKey* Message_PollUpdateMessage::mutable_pollcreationmessagekey() { + ::proto::MessageKey* _msg = _internal_mutable_pollcreationmessagekey(); + // @@protoc_insertion_point(field_mutable:proto.Message.PollUpdateMessage.pollCreationMessageKey) + return _msg; +} +inline void Message_PollUpdateMessage::set_allocated_pollcreationmessagekey(::proto::MessageKey* pollcreationmessagekey) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.pollcreationmessagekey_; + } + if (pollcreationmessagekey) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pollcreationmessagekey); + if (message_arena != submessage_arena) { + pollcreationmessagekey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, pollcreationmessagekey, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.pollcreationmessagekey_ = pollcreationmessagekey; + // @@protoc_insertion_point(field_set_allocated:proto.Message.PollUpdateMessage.pollCreationMessageKey) +} + +// optional .proto.Message.PollEncValue vote = 2; +inline bool Message_PollUpdateMessage::_internal_has_vote() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.vote_ != nullptr); + return value; +} +inline bool Message_PollUpdateMessage::has_vote() const { + return _internal_has_vote(); +} +inline void Message_PollUpdateMessage::clear_vote() { + if (_impl_.vote_ != nullptr) _impl_.vote_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::Message_PollEncValue& Message_PollUpdateMessage::_internal_vote() const { + const ::proto::Message_PollEncValue* p = _impl_.vote_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_PollEncValue_default_instance_); +} +inline const ::proto::Message_PollEncValue& Message_PollUpdateMessage::vote() const { + // @@protoc_insertion_point(field_get:proto.Message.PollUpdateMessage.vote) + return _internal_vote(); +} +inline void Message_PollUpdateMessage::unsafe_arena_set_allocated_vote( + ::proto::Message_PollEncValue* vote) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.vote_); + } + _impl_.vote_ = vote; + if (vote) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.PollUpdateMessage.vote) +} +inline ::proto::Message_PollEncValue* Message_PollUpdateMessage::release_vote() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::Message_PollEncValue* temp = _impl_.vote_; + _impl_.vote_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_PollEncValue* Message_PollUpdateMessage::unsafe_arena_release_vote() { + // @@protoc_insertion_point(field_release:proto.Message.PollUpdateMessage.vote) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::Message_PollEncValue* temp = _impl_.vote_; + _impl_.vote_ = nullptr; + return temp; +} +inline ::proto::Message_PollEncValue* Message_PollUpdateMessage::_internal_mutable_vote() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.vote_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_PollEncValue>(GetArenaForAllocation()); + _impl_.vote_ = p; + } + return _impl_.vote_; +} +inline ::proto::Message_PollEncValue* Message_PollUpdateMessage::mutable_vote() { + ::proto::Message_PollEncValue* _msg = _internal_mutable_vote(); + // @@protoc_insertion_point(field_mutable:proto.Message.PollUpdateMessage.vote) + return _msg; +} +inline void Message_PollUpdateMessage::set_allocated_vote(::proto::Message_PollEncValue* vote) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.vote_; + } + if (vote) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(vote); + if (message_arena != submessage_arena) { + vote = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, vote, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.vote_ = vote; + // @@protoc_insertion_point(field_set_allocated:proto.Message.PollUpdateMessage.vote) +} + +// optional .proto.Message.PollUpdateMessageMetadata metadata = 3; +inline bool Message_PollUpdateMessage::_internal_has_metadata() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.metadata_ != nullptr); + return value; +} +inline bool Message_PollUpdateMessage::has_metadata() const { + return _internal_has_metadata(); +} +inline void Message_PollUpdateMessage::clear_metadata() { + if (_impl_.metadata_ != nullptr) _impl_.metadata_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::proto::Message_PollUpdateMessageMetadata& Message_PollUpdateMessage::_internal_metadata() const { + const ::proto::Message_PollUpdateMessageMetadata* p = _impl_.metadata_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_PollUpdateMessageMetadata_default_instance_); +} +inline const ::proto::Message_PollUpdateMessageMetadata& Message_PollUpdateMessage::metadata() const { + // @@protoc_insertion_point(field_get:proto.Message.PollUpdateMessage.metadata) + return _internal_metadata(); +} +inline void Message_PollUpdateMessage::unsafe_arena_set_allocated_metadata( + ::proto::Message_PollUpdateMessageMetadata* metadata) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.metadata_); + } + _impl_.metadata_ = metadata; + if (metadata) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.PollUpdateMessage.metadata) +} +inline ::proto::Message_PollUpdateMessageMetadata* Message_PollUpdateMessage::release_metadata() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::Message_PollUpdateMessageMetadata* temp = _impl_.metadata_; + _impl_.metadata_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_PollUpdateMessageMetadata* Message_PollUpdateMessage::unsafe_arena_release_metadata() { + // @@protoc_insertion_point(field_release:proto.Message.PollUpdateMessage.metadata) + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::Message_PollUpdateMessageMetadata* temp = _impl_.metadata_; + _impl_.metadata_ = nullptr; + return temp; +} +inline ::proto::Message_PollUpdateMessageMetadata* Message_PollUpdateMessage::_internal_mutable_metadata() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.metadata_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_PollUpdateMessageMetadata>(GetArenaForAllocation()); + _impl_.metadata_ = p; + } + return _impl_.metadata_; +} +inline ::proto::Message_PollUpdateMessageMetadata* Message_PollUpdateMessage::mutable_metadata() { + ::proto::Message_PollUpdateMessageMetadata* _msg = _internal_mutable_metadata(); + // @@protoc_insertion_point(field_mutable:proto.Message.PollUpdateMessage.metadata) + return _msg; +} +inline void Message_PollUpdateMessage::set_allocated_metadata(::proto::Message_PollUpdateMessageMetadata* metadata) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.metadata_; + } + if (metadata) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(metadata); + if (message_arena != submessage_arena) { + metadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, metadata, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.metadata_ = metadata; + // @@protoc_insertion_point(field_set_allocated:proto.Message.PollUpdateMessage.metadata) +} + +// optional int64 senderTimestampMs = 4; +inline bool Message_PollUpdateMessage::_internal_has_sendertimestampms() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool Message_PollUpdateMessage::has_sendertimestampms() const { + return _internal_has_sendertimestampms(); +} +inline void Message_PollUpdateMessage::clear_sendertimestampms() { + _impl_.sendertimestampms_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline int64_t Message_PollUpdateMessage::_internal_sendertimestampms() const { + return _impl_.sendertimestampms_; +} +inline int64_t Message_PollUpdateMessage::sendertimestampms() const { + // @@protoc_insertion_point(field_get:proto.Message.PollUpdateMessage.senderTimestampMs) + return _internal_sendertimestampms(); +} +inline void Message_PollUpdateMessage::_internal_set_sendertimestampms(int64_t value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.sendertimestampms_ = value; +} +inline void Message_PollUpdateMessage::set_sendertimestampms(int64_t value) { + _internal_set_sendertimestampms(value); + // @@protoc_insertion_point(field_set:proto.Message.PollUpdateMessage.senderTimestampMs) +} + +// ------------------------------------------------------------------- + +// Message_PollVoteMessage + +// repeated bytes selectedOptions = 1; +inline int Message_PollVoteMessage::_internal_selectedoptions_size() const { + return _impl_.selectedoptions_.size(); +} +inline int Message_PollVoteMessage::selectedoptions_size() const { + return _internal_selectedoptions_size(); +} +inline void Message_PollVoteMessage::clear_selectedoptions() { + _impl_.selectedoptions_.Clear(); +} +inline std::string* Message_PollVoteMessage::add_selectedoptions() { + std::string* _s = _internal_add_selectedoptions(); + // @@protoc_insertion_point(field_add_mutable:proto.Message.PollVoteMessage.selectedOptions) + return _s; +} +inline const std::string& Message_PollVoteMessage::_internal_selectedoptions(int index) const { + return _impl_.selectedoptions_.Get(index); +} +inline const std::string& Message_PollVoteMessage::selectedoptions(int index) const { + // @@protoc_insertion_point(field_get:proto.Message.PollVoteMessage.selectedOptions) + return _internal_selectedoptions(index); +} +inline std::string* Message_PollVoteMessage::mutable_selectedoptions(int index) { + // @@protoc_insertion_point(field_mutable:proto.Message.PollVoteMessage.selectedOptions) + return _impl_.selectedoptions_.Mutable(index); +} +inline void Message_PollVoteMessage::set_selectedoptions(int index, const std::string& value) { + _impl_.selectedoptions_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:proto.Message.PollVoteMessage.selectedOptions) +} +inline void Message_PollVoteMessage::set_selectedoptions(int index, std::string&& value) { + _impl_.selectedoptions_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:proto.Message.PollVoteMessage.selectedOptions) +} +inline void Message_PollVoteMessage::set_selectedoptions(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + _impl_.selectedoptions_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:proto.Message.PollVoteMessage.selectedOptions) +} +inline void Message_PollVoteMessage::set_selectedoptions(int index, const void* value, size_t size) { + _impl_.selectedoptions_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:proto.Message.PollVoteMessage.selectedOptions) +} +inline std::string* Message_PollVoteMessage::_internal_add_selectedoptions() { + return _impl_.selectedoptions_.Add(); +} +inline void Message_PollVoteMessage::add_selectedoptions(const std::string& value) { + _impl_.selectedoptions_.Add()->assign(value); + // @@protoc_insertion_point(field_add:proto.Message.PollVoteMessage.selectedOptions) +} +inline void Message_PollVoteMessage::add_selectedoptions(std::string&& value) { + _impl_.selectedoptions_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:proto.Message.PollVoteMessage.selectedOptions) +} +inline void Message_PollVoteMessage::add_selectedoptions(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _impl_.selectedoptions_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:proto.Message.PollVoteMessage.selectedOptions) +} +inline void Message_PollVoteMessage::add_selectedoptions(const void* value, size_t size) { + _impl_.selectedoptions_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:proto.Message.PollVoteMessage.selectedOptions) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +Message_PollVoteMessage::selectedoptions() const { + // @@protoc_insertion_point(field_list:proto.Message.PollVoteMessage.selectedOptions) + return _impl_.selectedoptions_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +Message_PollVoteMessage::mutable_selectedoptions() { + // @@protoc_insertion_point(field_mutable_list:proto.Message.PollVoteMessage.selectedOptions) + return &_impl_.selectedoptions_; +} + +// ------------------------------------------------------------------- + +// Message_ProductMessage_CatalogSnapshot + +// optional .proto.Message.ImageMessage catalogImage = 1; +inline bool Message_ProductMessage_CatalogSnapshot::_internal_has_catalogimage() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.catalogimage_ != nullptr); + return value; +} +inline bool Message_ProductMessage_CatalogSnapshot::has_catalogimage() const { + return _internal_has_catalogimage(); +} +inline void Message_ProductMessage_CatalogSnapshot::clear_catalogimage() { + if (_impl_.catalogimage_ != nullptr) _impl_.catalogimage_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::proto::Message_ImageMessage& Message_ProductMessage_CatalogSnapshot::_internal_catalogimage() const { + const ::proto::Message_ImageMessage* p = _impl_.catalogimage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_ImageMessage_default_instance_); +} +inline const ::proto::Message_ImageMessage& Message_ProductMessage_CatalogSnapshot::catalogimage() const { + // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.CatalogSnapshot.catalogImage) + return _internal_catalogimage(); +} +inline void Message_ProductMessage_CatalogSnapshot::unsafe_arena_set_allocated_catalogimage( + ::proto::Message_ImageMessage* catalogimage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.catalogimage_); + } + _impl_.catalogimage_ = catalogimage; + if (catalogimage) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProductMessage.CatalogSnapshot.catalogImage) +} +inline ::proto::Message_ImageMessage* Message_ProductMessage_CatalogSnapshot::release_catalogimage() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::Message_ImageMessage* temp = _impl_.catalogimage_; + _impl_.catalogimage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_ImageMessage* Message_ProductMessage_CatalogSnapshot::unsafe_arena_release_catalogimage() { + // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.CatalogSnapshot.catalogImage) + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::Message_ImageMessage* temp = _impl_.catalogimage_; + _impl_.catalogimage_ = nullptr; + return temp; +} +inline ::proto::Message_ImageMessage* Message_ProductMessage_CatalogSnapshot::_internal_mutable_catalogimage() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.catalogimage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_ImageMessage>(GetArenaForAllocation()); + _impl_.catalogimage_ = p; + } + return _impl_.catalogimage_; +} +inline ::proto::Message_ImageMessage* Message_ProductMessage_CatalogSnapshot::mutable_catalogimage() { + ::proto::Message_ImageMessage* _msg = _internal_mutable_catalogimage(); + // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.CatalogSnapshot.catalogImage) + return _msg; +} +inline void Message_ProductMessage_CatalogSnapshot::set_allocated_catalogimage(::proto::Message_ImageMessage* catalogimage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.catalogimage_; + } + if (catalogimage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(catalogimage); + if (message_arena != submessage_arena) { + catalogimage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, catalogimage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.catalogimage_ = catalogimage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.CatalogSnapshot.catalogImage) +} + +// optional string title = 2; +inline bool Message_ProductMessage_CatalogSnapshot::_internal_has_title() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_ProductMessage_CatalogSnapshot::has_title() const { + return _internal_has_title(); +} +inline void Message_ProductMessage_CatalogSnapshot::clear_title() { + _impl_.title_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_ProductMessage_CatalogSnapshot::title() const { + // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.CatalogSnapshot.title) + return _internal_title(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ProductMessage_CatalogSnapshot::set_title(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.title_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.CatalogSnapshot.title) +} +inline std::string* Message_ProductMessage_CatalogSnapshot::mutable_title() { + std::string* _s = _internal_mutable_title(); + // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.CatalogSnapshot.title) + return _s; +} +inline const std::string& Message_ProductMessage_CatalogSnapshot::_internal_title() const { + return _impl_.title_.Get(); +} +inline void Message_ProductMessage_CatalogSnapshot::_internal_set_title(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.title_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ProductMessage_CatalogSnapshot::_internal_mutable_title() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.title_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ProductMessage_CatalogSnapshot::release_title() { + // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.CatalogSnapshot.title) + if (!_internal_has_title()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.title_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.title_.IsDefault()) { + _impl_.title_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ProductMessage_CatalogSnapshot::set_allocated_title(std::string* title) { + if (title != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.title_.SetAllocated(title, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.title_.IsDefault()) { + _impl_.title_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.CatalogSnapshot.title) +} + +// optional string description = 3; +inline bool Message_ProductMessage_CatalogSnapshot::_internal_has_description() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_ProductMessage_CatalogSnapshot::has_description() const { + return _internal_has_description(); +} +inline void Message_ProductMessage_CatalogSnapshot::clear_description() { + _impl_.description_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_ProductMessage_CatalogSnapshot::description() const { + // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.CatalogSnapshot.description) + return _internal_description(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ProductMessage_CatalogSnapshot::set_description(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.description_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.CatalogSnapshot.description) +} +inline std::string* Message_ProductMessage_CatalogSnapshot::mutable_description() { + std::string* _s = _internal_mutable_description(); + // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.CatalogSnapshot.description) + return _s; +} +inline const std::string& Message_ProductMessage_CatalogSnapshot::_internal_description() const { + return _impl_.description_.Get(); +} +inline void Message_ProductMessage_CatalogSnapshot::_internal_set_description(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.description_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ProductMessage_CatalogSnapshot::_internal_mutable_description() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.description_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ProductMessage_CatalogSnapshot::release_description() { + // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.CatalogSnapshot.description) + if (!_internal_has_description()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.description_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.description_.IsDefault()) { + _impl_.description_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ProductMessage_CatalogSnapshot::set_allocated_description(std::string* description) { + if (description != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.description_.SetAllocated(description, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.description_.IsDefault()) { + _impl_.description_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.CatalogSnapshot.description) +} + +// ------------------------------------------------------------------- + +// Message_ProductMessage_ProductSnapshot + +// optional .proto.Message.ImageMessage productImage = 1; +inline bool Message_ProductMessage_ProductSnapshot::_internal_has_productimage() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + PROTOBUF_ASSUME(!value || _impl_.productimage_ != nullptr); + return value; +} +inline bool Message_ProductMessage_ProductSnapshot::has_productimage() const { + return _internal_has_productimage(); +} +inline void Message_ProductMessage_ProductSnapshot::clear_productimage() { + if (_impl_.productimage_ != nullptr) _impl_.productimage_->Clear(); + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline const ::proto::Message_ImageMessage& Message_ProductMessage_ProductSnapshot::_internal_productimage() const { + const ::proto::Message_ImageMessage* p = _impl_.productimage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_ImageMessage_default_instance_); +} +inline const ::proto::Message_ImageMessage& Message_ProductMessage_ProductSnapshot::productimage() const { + // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.productImage) + return _internal_productimage(); +} +inline void Message_ProductMessage_ProductSnapshot::unsafe_arena_set_allocated_productimage( + ::proto::Message_ImageMessage* productimage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.productimage_); + } + _impl_.productimage_ = productimage; + if (productimage) { + _impl_._has_bits_[0] |= 0x00000080u; + } else { + _impl_._has_bits_[0] &= ~0x00000080u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProductMessage.ProductSnapshot.productImage) +} +inline ::proto::Message_ImageMessage* Message_ProductMessage_ProductSnapshot::release_productimage() { + _impl_._has_bits_[0] &= ~0x00000080u; + ::proto::Message_ImageMessage* temp = _impl_.productimage_; + _impl_.productimage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_ImageMessage* Message_ProductMessage_ProductSnapshot::unsafe_arena_release_productimage() { + // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.productImage) + _impl_._has_bits_[0] &= ~0x00000080u; + ::proto::Message_ImageMessage* temp = _impl_.productimage_; + _impl_.productimage_ = nullptr; + return temp; +} +inline ::proto::Message_ImageMessage* Message_ProductMessage_ProductSnapshot::_internal_mutable_productimage() { + _impl_._has_bits_[0] |= 0x00000080u; + if (_impl_.productimage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_ImageMessage>(GetArenaForAllocation()); + _impl_.productimage_ = p; + } + return _impl_.productimage_; +} +inline ::proto::Message_ImageMessage* Message_ProductMessage_ProductSnapshot::mutable_productimage() { + ::proto::Message_ImageMessage* _msg = _internal_mutable_productimage(); + // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.productImage) + return _msg; +} +inline void Message_ProductMessage_ProductSnapshot::set_allocated_productimage(::proto::Message_ImageMessage* productimage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.productimage_; + } + if (productimage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(productimage); + if (message_arena != submessage_arena) { + productimage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, productimage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000080u; + } else { + _impl_._has_bits_[0] &= ~0x00000080u; + } + _impl_.productimage_ = productimage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.ProductSnapshot.productImage) +} + +// optional string productId = 2; +inline bool Message_ProductMessage_ProductSnapshot::_internal_has_productid() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_ProductMessage_ProductSnapshot::has_productid() const { + return _internal_has_productid(); +} +inline void Message_ProductMessage_ProductSnapshot::clear_productid() { + _impl_.productid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_ProductMessage_ProductSnapshot::productid() const { + // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.productId) + return _internal_productid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ProductMessage_ProductSnapshot::set_productid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.productid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.productId) +} +inline std::string* Message_ProductMessage_ProductSnapshot::mutable_productid() { + std::string* _s = _internal_mutable_productid(); + // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.productId) + return _s; +} +inline const std::string& Message_ProductMessage_ProductSnapshot::_internal_productid() const { + return _impl_.productid_.Get(); +} +inline void Message_ProductMessage_ProductSnapshot::_internal_set_productid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.productid_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ProductMessage_ProductSnapshot::_internal_mutable_productid() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.productid_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ProductMessage_ProductSnapshot::release_productid() { + // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.productId) + if (!_internal_has_productid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.productid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.productid_.IsDefault()) { + _impl_.productid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ProductMessage_ProductSnapshot::set_allocated_productid(std::string* productid) { + if (productid != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.productid_.SetAllocated(productid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.productid_.IsDefault()) { + _impl_.productid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.ProductSnapshot.productId) +} + +// optional string title = 3; +inline bool Message_ProductMessage_ProductSnapshot::_internal_has_title() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_ProductMessage_ProductSnapshot::has_title() const { + return _internal_has_title(); +} +inline void Message_ProductMessage_ProductSnapshot::clear_title() { + _impl_.title_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_ProductMessage_ProductSnapshot::title() const { + // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.title) + return _internal_title(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ProductMessage_ProductSnapshot::set_title(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.title_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.title) +} +inline std::string* Message_ProductMessage_ProductSnapshot::mutable_title() { + std::string* _s = _internal_mutable_title(); + // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.title) + return _s; +} +inline const std::string& Message_ProductMessage_ProductSnapshot::_internal_title() const { + return _impl_.title_.Get(); +} +inline void Message_ProductMessage_ProductSnapshot::_internal_set_title(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.title_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ProductMessage_ProductSnapshot::_internal_mutable_title() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.title_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ProductMessage_ProductSnapshot::release_title() { + // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.title) + if (!_internal_has_title()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.title_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.title_.IsDefault()) { + _impl_.title_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ProductMessage_ProductSnapshot::set_allocated_title(std::string* title) { + if (title != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.title_.SetAllocated(title, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.title_.IsDefault()) { + _impl_.title_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.ProductSnapshot.title) +} + +// optional string description = 4; +inline bool Message_ProductMessage_ProductSnapshot::_internal_has_description() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Message_ProductMessage_ProductSnapshot::has_description() const { + return _internal_has_description(); +} +inline void Message_ProductMessage_ProductSnapshot::clear_description() { + _impl_.description_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& Message_ProductMessage_ProductSnapshot::description() const { + // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.description) + return _internal_description(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ProductMessage_ProductSnapshot::set_description(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.description_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.description) +} +inline std::string* Message_ProductMessage_ProductSnapshot::mutable_description() { + std::string* _s = _internal_mutable_description(); + // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.description) + return _s; +} +inline const std::string& Message_ProductMessage_ProductSnapshot::_internal_description() const { + return _impl_.description_.Get(); +} +inline void Message_ProductMessage_ProductSnapshot::_internal_set_description(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.description_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ProductMessage_ProductSnapshot::_internal_mutable_description() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.description_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ProductMessage_ProductSnapshot::release_description() { + // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.description) + if (!_internal_has_description()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.description_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.description_.IsDefault()) { + _impl_.description_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ProductMessage_ProductSnapshot::set_allocated_description(std::string* description) { + if (description != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.description_.SetAllocated(description, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.description_.IsDefault()) { + _impl_.description_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.ProductSnapshot.description) +} + +// optional string currencyCode = 5; +inline bool Message_ProductMessage_ProductSnapshot::_internal_has_currencycode() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool Message_ProductMessage_ProductSnapshot::has_currencycode() const { + return _internal_has_currencycode(); +} +inline void Message_ProductMessage_ProductSnapshot::clear_currencycode() { + _impl_.currencycode_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const std::string& Message_ProductMessage_ProductSnapshot::currencycode() const { + // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.currencyCode) + return _internal_currencycode(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ProductMessage_ProductSnapshot::set_currencycode(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.currencycode_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.currencyCode) +} +inline std::string* Message_ProductMessage_ProductSnapshot::mutable_currencycode() { + std::string* _s = _internal_mutable_currencycode(); + // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.currencyCode) + return _s; +} +inline const std::string& Message_ProductMessage_ProductSnapshot::_internal_currencycode() const { + return _impl_.currencycode_.Get(); +} +inline void Message_ProductMessage_ProductSnapshot::_internal_set_currencycode(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.currencycode_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ProductMessage_ProductSnapshot::_internal_mutable_currencycode() { + _impl_._has_bits_[0] |= 0x00000008u; + return _impl_.currencycode_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ProductMessage_ProductSnapshot::release_currencycode() { + // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.currencyCode) + if (!_internal_has_currencycode()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000008u; + auto* p = _impl_.currencycode_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.currencycode_.IsDefault()) { + _impl_.currencycode_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ProductMessage_ProductSnapshot::set_allocated_currencycode(std::string* currencycode) { + if (currencycode != nullptr) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.currencycode_.SetAllocated(currencycode, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.currencycode_.IsDefault()) { + _impl_.currencycode_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.ProductSnapshot.currencyCode) +} + +// optional int64 priceAmount1000 = 6; +inline bool Message_ProductMessage_ProductSnapshot::_internal_has_priceamount1000() const { + bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool Message_ProductMessage_ProductSnapshot::has_priceamount1000() const { + return _internal_has_priceamount1000(); +} +inline void Message_ProductMessage_ProductSnapshot::clear_priceamount1000() { + _impl_.priceamount1000_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000100u; +} +inline int64_t Message_ProductMessage_ProductSnapshot::_internal_priceamount1000() const { + return _impl_.priceamount1000_; +} +inline int64_t Message_ProductMessage_ProductSnapshot::priceamount1000() const { + // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.priceAmount1000) + return _internal_priceamount1000(); +} +inline void Message_ProductMessage_ProductSnapshot::_internal_set_priceamount1000(int64_t value) { + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.priceamount1000_ = value; +} +inline void Message_ProductMessage_ProductSnapshot::set_priceamount1000(int64_t value) { + _internal_set_priceamount1000(value); + // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.priceAmount1000) +} + +// optional string retailerId = 7; +inline bool Message_ProductMessage_ProductSnapshot::_internal_has_retailerid() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool Message_ProductMessage_ProductSnapshot::has_retailerid() const { + return _internal_has_retailerid(); +} +inline void Message_ProductMessage_ProductSnapshot::clear_retailerid() { + _impl_.retailerid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const std::string& Message_ProductMessage_ProductSnapshot::retailerid() const { + // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.retailerId) + return _internal_retailerid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ProductMessage_ProductSnapshot::set_retailerid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.retailerid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.retailerId) +} +inline std::string* Message_ProductMessage_ProductSnapshot::mutable_retailerid() { + std::string* _s = _internal_mutable_retailerid(); + // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.retailerId) + return _s; +} +inline const std::string& Message_ProductMessage_ProductSnapshot::_internal_retailerid() const { + return _impl_.retailerid_.Get(); +} +inline void Message_ProductMessage_ProductSnapshot::_internal_set_retailerid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.retailerid_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ProductMessage_ProductSnapshot::_internal_mutable_retailerid() { + _impl_._has_bits_[0] |= 0x00000010u; + return _impl_.retailerid_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ProductMessage_ProductSnapshot::release_retailerid() { + // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.retailerId) + if (!_internal_has_retailerid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000010u; + auto* p = _impl_.retailerid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.retailerid_.IsDefault()) { + _impl_.retailerid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ProductMessage_ProductSnapshot::set_allocated_retailerid(std::string* retailerid) { + if (retailerid != nullptr) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.retailerid_.SetAllocated(retailerid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.retailerid_.IsDefault()) { + _impl_.retailerid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.ProductSnapshot.retailerId) +} + +// optional string url = 8; +inline bool Message_ProductMessage_ProductSnapshot::_internal_has_url() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool Message_ProductMessage_ProductSnapshot::has_url() const { + return _internal_has_url(); +} +inline void Message_ProductMessage_ProductSnapshot::clear_url() { + _impl_.url_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline const std::string& Message_ProductMessage_ProductSnapshot::url() const { + // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.url) + return _internal_url(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ProductMessage_ProductSnapshot::set_url(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.url_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.url) +} +inline std::string* Message_ProductMessage_ProductSnapshot::mutable_url() { + std::string* _s = _internal_mutable_url(); + // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.url) + return _s; +} +inline const std::string& Message_ProductMessage_ProductSnapshot::_internal_url() const { + return _impl_.url_.Get(); +} +inline void Message_ProductMessage_ProductSnapshot::_internal_set_url(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.url_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ProductMessage_ProductSnapshot::_internal_mutable_url() { + _impl_._has_bits_[0] |= 0x00000020u; + return _impl_.url_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ProductMessage_ProductSnapshot::release_url() { + // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.url) + if (!_internal_has_url()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000020u; + auto* p = _impl_.url_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.url_.IsDefault()) { + _impl_.url_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ProductMessage_ProductSnapshot::set_allocated_url(std::string* url) { + if (url != nullptr) { + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + _impl_.url_.SetAllocated(url, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.url_.IsDefault()) { + _impl_.url_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.ProductSnapshot.url) +} + +// optional uint32 productImageCount = 9; +inline bool Message_ProductMessage_ProductSnapshot::_internal_has_productimagecount() const { + bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool Message_ProductMessage_ProductSnapshot::has_productimagecount() const { + return _internal_has_productimagecount(); +} +inline void Message_ProductMessage_ProductSnapshot::clear_productimagecount() { + _impl_.productimagecount_ = 0u; + _impl_._has_bits_[0] &= ~0x00000400u; +} +inline uint32_t Message_ProductMessage_ProductSnapshot::_internal_productimagecount() const { + return _impl_.productimagecount_; +} +inline uint32_t Message_ProductMessage_ProductSnapshot::productimagecount() const { + // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.productImageCount) + return _internal_productimagecount(); +} +inline void Message_ProductMessage_ProductSnapshot::_internal_set_productimagecount(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000400u; + _impl_.productimagecount_ = value; +} +inline void Message_ProductMessage_ProductSnapshot::set_productimagecount(uint32_t value) { + _internal_set_productimagecount(value); + // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.productImageCount) +} + +// optional string firstImageId = 11; +inline bool Message_ProductMessage_ProductSnapshot::_internal_has_firstimageid() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool Message_ProductMessage_ProductSnapshot::has_firstimageid() const { + return _internal_has_firstimageid(); +} +inline void Message_ProductMessage_ProductSnapshot::clear_firstimageid() { + _impl_.firstimageid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline const std::string& Message_ProductMessage_ProductSnapshot::firstimageid() const { + // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.firstImageId) + return _internal_firstimageid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ProductMessage_ProductSnapshot::set_firstimageid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.firstimageid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.firstImageId) +} +inline std::string* Message_ProductMessage_ProductSnapshot::mutable_firstimageid() { + std::string* _s = _internal_mutable_firstimageid(); + // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.firstImageId) + return _s; +} +inline const std::string& Message_ProductMessage_ProductSnapshot::_internal_firstimageid() const { + return _impl_.firstimageid_.Get(); +} +inline void Message_ProductMessage_ProductSnapshot::_internal_set_firstimageid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.firstimageid_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ProductMessage_ProductSnapshot::_internal_mutable_firstimageid() { + _impl_._has_bits_[0] |= 0x00000040u; + return _impl_.firstimageid_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ProductMessage_ProductSnapshot::release_firstimageid() { + // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.firstImageId) + if (!_internal_has_firstimageid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000040u; + auto* p = _impl_.firstimageid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.firstimageid_.IsDefault()) { + _impl_.firstimageid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ProductMessage_ProductSnapshot::set_allocated_firstimageid(std::string* firstimageid) { + if (firstimageid != nullptr) { + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + _impl_.firstimageid_.SetAllocated(firstimageid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.firstimageid_.IsDefault()) { + _impl_.firstimageid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.ProductSnapshot.firstImageId) +} + +// optional int64 salePriceAmount1000 = 12; +inline bool Message_ProductMessage_ProductSnapshot::_internal_has_salepriceamount1000() const { + bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool Message_ProductMessage_ProductSnapshot::has_salepriceamount1000() const { + return _internal_has_salepriceamount1000(); +} +inline void Message_ProductMessage_ProductSnapshot::clear_salepriceamount1000() { + _impl_.salepriceamount1000_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000200u; +} +inline int64_t Message_ProductMessage_ProductSnapshot::_internal_salepriceamount1000() const { + return _impl_.salepriceamount1000_; +} +inline int64_t Message_ProductMessage_ProductSnapshot::salepriceamount1000() const { + // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.salePriceAmount1000) + return _internal_salepriceamount1000(); +} +inline void Message_ProductMessage_ProductSnapshot::_internal_set_salepriceamount1000(int64_t value) { + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.salepriceamount1000_ = value; +} +inline void Message_ProductMessage_ProductSnapshot::set_salepriceamount1000(int64_t value) { + _internal_set_salepriceamount1000(value); + // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.salePriceAmount1000) +} + +// ------------------------------------------------------------------- + +// Message_ProductMessage + +// optional .proto.Message.ProductMessage.ProductSnapshot product = 1; +inline bool Message_ProductMessage::_internal_has_product() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || _impl_.product_ != nullptr); + return value; +} +inline bool Message_ProductMessage::has_product() const { + return _internal_has_product(); +} +inline void Message_ProductMessage::clear_product() { + if (_impl_.product_ != nullptr) _impl_.product_->Clear(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const ::proto::Message_ProductMessage_ProductSnapshot& Message_ProductMessage::_internal_product() const { + const ::proto::Message_ProductMessage_ProductSnapshot* p = _impl_.product_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_ProductMessage_ProductSnapshot_default_instance_); +} +inline const ::proto::Message_ProductMessage_ProductSnapshot& Message_ProductMessage::product() const { + // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.product) + return _internal_product(); +} +inline void Message_ProductMessage::unsafe_arena_set_allocated_product( + ::proto::Message_ProductMessage_ProductSnapshot* product) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.product_); + } + _impl_.product_ = product; + if (product) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProductMessage.product) +} +inline ::proto::Message_ProductMessage_ProductSnapshot* Message_ProductMessage::release_product() { + _impl_._has_bits_[0] &= ~0x00000008u; + ::proto::Message_ProductMessage_ProductSnapshot* temp = _impl_.product_; + _impl_.product_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_ProductMessage_ProductSnapshot* Message_ProductMessage::unsafe_arena_release_product() { + // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.product) + _impl_._has_bits_[0] &= ~0x00000008u; + ::proto::Message_ProductMessage_ProductSnapshot* temp = _impl_.product_; + _impl_.product_ = nullptr; + return temp; +} +inline ::proto::Message_ProductMessage_ProductSnapshot* Message_ProductMessage::_internal_mutable_product() { + _impl_._has_bits_[0] |= 0x00000008u; + if (_impl_.product_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_ProductMessage_ProductSnapshot>(GetArenaForAllocation()); + _impl_.product_ = p; + } + return _impl_.product_; +} +inline ::proto::Message_ProductMessage_ProductSnapshot* Message_ProductMessage::mutable_product() { + ::proto::Message_ProductMessage_ProductSnapshot* _msg = _internal_mutable_product(); + // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.product) + return _msg; +} +inline void Message_ProductMessage::set_allocated_product(::proto::Message_ProductMessage_ProductSnapshot* product) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.product_; + } + if (product) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(product); + if (message_arena != submessage_arena) { + product = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, product, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.product_ = product; + // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.product) +} + +// optional string businessOwnerJid = 2; +inline bool Message_ProductMessage::_internal_has_businessownerjid() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_ProductMessage::has_businessownerjid() const { + return _internal_has_businessownerjid(); +} +inline void Message_ProductMessage::clear_businessownerjid() { + _impl_.businessownerjid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_ProductMessage::businessownerjid() const { + // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.businessOwnerJid) + return _internal_businessownerjid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ProductMessage::set_businessownerjid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.businessownerjid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.businessOwnerJid) +} +inline std::string* Message_ProductMessage::mutable_businessownerjid() { + std::string* _s = _internal_mutable_businessownerjid(); + // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.businessOwnerJid) + return _s; +} +inline const std::string& Message_ProductMessage::_internal_businessownerjid() const { + return _impl_.businessownerjid_.Get(); +} +inline void Message_ProductMessage::_internal_set_businessownerjid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.businessownerjid_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ProductMessage::_internal_mutable_businessownerjid() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.businessownerjid_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ProductMessage::release_businessownerjid() { + // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.businessOwnerJid) + if (!_internal_has_businessownerjid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.businessownerjid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.businessownerjid_.IsDefault()) { + _impl_.businessownerjid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ProductMessage::set_allocated_businessownerjid(std::string* businessownerjid) { + if (businessownerjid != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.businessownerjid_.SetAllocated(businessownerjid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.businessownerjid_.IsDefault()) { + _impl_.businessownerjid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.businessOwnerJid) +} + +// optional .proto.Message.ProductMessage.CatalogSnapshot catalog = 4; +inline bool Message_ProductMessage::_internal_has_catalog() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + PROTOBUF_ASSUME(!value || _impl_.catalog_ != nullptr); + return value; +} +inline bool Message_ProductMessage::has_catalog() const { + return _internal_has_catalog(); +} +inline void Message_ProductMessage::clear_catalog() { + if (_impl_.catalog_ != nullptr) _impl_.catalog_->Clear(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const ::proto::Message_ProductMessage_CatalogSnapshot& Message_ProductMessage::_internal_catalog() const { + const ::proto::Message_ProductMessage_CatalogSnapshot* p = _impl_.catalog_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_ProductMessage_CatalogSnapshot_default_instance_); +} +inline const ::proto::Message_ProductMessage_CatalogSnapshot& Message_ProductMessage::catalog() const { + // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.catalog) + return _internal_catalog(); +} +inline void Message_ProductMessage::unsafe_arena_set_allocated_catalog( + ::proto::Message_ProductMessage_CatalogSnapshot* catalog) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.catalog_); + } + _impl_.catalog_ = catalog; + if (catalog) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProductMessage.catalog) +} +inline ::proto::Message_ProductMessage_CatalogSnapshot* Message_ProductMessage::release_catalog() { + _impl_._has_bits_[0] &= ~0x00000010u; + ::proto::Message_ProductMessage_CatalogSnapshot* temp = _impl_.catalog_; + _impl_.catalog_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_ProductMessage_CatalogSnapshot* Message_ProductMessage::unsafe_arena_release_catalog() { + // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.catalog) + _impl_._has_bits_[0] &= ~0x00000010u; + ::proto::Message_ProductMessage_CatalogSnapshot* temp = _impl_.catalog_; + _impl_.catalog_ = nullptr; + return temp; +} +inline ::proto::Message_ProductMessage_CatalogSnapshot* Message_ProductMessage::_internal_mutable_catalog() { + _impl_._has_bits_[0] |= 0x00000010u; + if (_impl_.catalog_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_ProductMessage_CatalogSnapshot>(GetArenaForAllocation()); + _impl_.catalog_ = p; + } + return _impl_.catalog_; +} +inline ::proto::Message_ProductMessage_CatalogSnapshot* Message_ProductMessage::mutable_catalog() { + ::proto::Message_ProductMessage_CatalogSnapshot* _msg = _internal_mutable_catalog(); + // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.catalog) + return _msg; +} +inline void Message_ProductMessage::set_allocated_catalog(::proto::Message_ProductMessage_CatalogSnapshot* catalog) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.catalog_; + } + if (catalog) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(catalog); + if (message_arena != submessage_arena) { + catalog = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, catalog, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.catalog_ = catalog; + // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.catalog) +} + +// optional string body = 5; +inline bool Message_ProductMessage::_internal_has_body() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_ProductMessage::has_body() const { + return _internal_has_body(); +} +inline void Message_ProductMessage::clear_body() { + _impl_.body_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_ProductMessage::body() const { + // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.body) + return _internal_body(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ProductMessage::set_body(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.body_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.body) +} +inline std::string* Message_ProductMessage::mutable_body() { + std::string* _s = _internal_mutable_body(); + // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.body) + return _s; +} +inline const std::string& Message_ProductMessage::_internal_body() const { + return _impl_.body_.Get(); +} +inline void Message_ProductMessage::_internal_set_body(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.body_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ProductMessage::_internal_mutable_body() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.body_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ProductMessage::release_body() { + // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.body) + if (!_internal_has_body()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.body_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.body_.IsDefault()) { + _impl_.body_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ProductMessage::set_allocated_body(std::string* body) { + if (body != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.body_.SetAllocated(body, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.body_.IsDefault()) { + _impl_.body_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.body) +} + +// optional string footer = 6; +inline bool Message_ProductMessage::_internal_has_footer() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Message_ProductMessage::has_footer() const { + return _internal_has_footer(); +} +inline void Message_ProductMessage::clear_footer() { + _impl_.footer_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& Message_ProductMessage::footer() const { + // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.footer) + return _internal_footer(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ProductMessage::set_footer(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.footer_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.footer) +} +inline std::string* Message_ProductMessage::mutable_footer() { + std::string* _s = _internal_mutable_footer(); + // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.footer) + return _s; +} +inline const std::string& Message_ProductMessage::_internal_footer() const { + return _impl_.footer_.Get(); +} +inline void Message_ProductMessage::_internal_set_footer(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.footer_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ProductMessage::_internal_mutable_footer() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.footer_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ProductMessage::release_footer() { + // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.footer) + if (!_internal_has_footer()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.footer_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.footer_.IsDefault()) { + _impl_.footer_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ProductMessage::set_allocated_footer(std::string* footer) { + if (footer != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.footer_.SetAllocated(footer, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.footer_.IsDefault()) { + _impl_.footer_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.footer) +} + +// optional .proto.ContextInfo contextInfo = 17; +inline bool Message_ProductMessage::_internal_has_contextinfo() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); + return value; +} +inline bool Message_ProductMessage::has_contextinfo() const { + return _internal_has_contextinfo(); +} +inline void Message_ProductMessage::clear_contextinfo() { + if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline const ::proto::ContextInfo& Message_ProductMessage::_internal_contextinfo() const { + const ::proto::ContextInfo* p = _impl_.contextinfo_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ContextInfo_default_instance_); +} +inline const ::proto::ContextInfo& Message_ProductMessage::contextinfo() const { + // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.contextInfo) + return _internal_contextinfo(); +} +inline void Message_ProductMessage::unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); + } + _impl_.contextinfo_ = contextinfo; + if (contextinfo) { + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProductMessage.contextInfo) +} +inline ::proto::ContextInfo* Message_ProductMessage::release_contextinfo() { + _impl_._has_bits_[0] &= ~0x00000020u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ContextInfo* Message_ProductMessage::unsafe_arena_release_contextinfo() { + // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.contextInfo) + _impl_._has_bits_[0] &= ~0x00000020u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; + return temp; +} +inline ::proto::ContextInfo* Message_ProductMessage::_internal_mutable_contextinfo() { + _impl_._has_bits_[0] |= 0x00000020u; + if (_impl_.contextinfo_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); + _impl_.contextinfo_ = p; + } + return _impl_.contextinfo_; +} +inline ::proto::ContextInfo* Message_ProductMessage::mutable_contextinfo() { + ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); + // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.contextInfo) + return _msg; +} +inline void Message_ProductMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.contextinfo_; + } + if (contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); + if (message_arena != submessage_arena) { + contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, contextinfo, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + _impl_.contextinfo_ = contextinfo; + // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.contextInfo) +} + +// ------------------------------------------------------------------- + +// Message_ProtocolMessage + +// optional .proto.MessageKey key = 1; +inline bool Message_ProtocolMessage::_internal_has_key() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr); + return value; +} +inline bool Message_ProtocolMessage::has_key() const { + return _internal_has_key(); +} +inline void Message_ProtocolMessage::clear_key() { + if (_impl_.key_ != nullptr) _impl_.key_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::MessageKey& Message_ProtocolMessage::_internal_key() const { + const ::proto::MessageKey* p = _impl_.key_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_MessageKey_default_instance_); +} +inline const ::proto::MessageKey& Message_ProtocolMessage::key() const { + // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.key) + return _internal_key(); +} +inline void Message_ProtocolMessage::unsafe_arena_set_allocated_key( + ::proto::MessageKey* key) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_); + } + _impl_.key_ = key; + if (key) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.key) +} +inline ::proto::MessageKey* Message_ProtocolMessage::release_key() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::MessageKey* temp = _impl_.key_; + _impl_.key_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::MessageKey* Message_ProtocolMessage::unsafe_arena_release_key() { + // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.key) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::MessageKey* temp = _impl_.key_; + _impl_.key_ = nullptr; + return temp; +} +inline ::proto::MessageKey* Message_ProtocolMessage::_internal_mutable_key() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.key_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation()); + _impl_.key_ = p; + } + return _impl_.key_; +} +inline ::proto::MessageKey* Message_ProtocolMessage::mutable_key() { + ::proto::MessageKey* _msg = _internal_mutable_key(); + // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.key) + return _msg; +} +inline void Message_ProtocolMessage::set_allocated_key(::proto::MessageKey* key) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.key_; + } + if (key) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key); + if (message_arena != submessage_arena) { + key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, key, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.key_ = key; + // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.key) +} + +// optional .proto.Message.ProtocolMessage.Type type = 2; +inline bool Message_ProtocolMessage::_internal_has_type() const { + bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool Message_ProtocolMessage::has_type() const { + return _internal_has_type(); +} +inline void Message_ProtocolMessage::clear_type() { + _impl_.type_ = 0; + _impl_._has_bits_[0] &= ~0x00000200u; +} +inline ::proto::Message_ProtocolMessage_Type Message_ProtocolMessage::_internal_type() const { + return static_cast< ::proto::Message_ProtocolMessage_Type >(_impl_.type_); +} +inline ::proto::Message_ProtocolMessage_Type Message_ProtocolMessage::type() const { + // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.type) + return _internal_type(); +} +inline void Message_ProtocolMessage::_internal_set_type(::proto::Message_ProtocolMessage_Type value) { + assert(::proto::Message_ProtocolMessage_Type_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.type_ = value; +} +inline void Message_ProtocolMessage::set_type(::proto::Message_ProtocolMessage_Type value) { + _internal_set_type(value); + // @@protoc_insertion_point(field_set:proto.Message.ProtocolMessage.type) +} + +// optional uint32 ephemeralExpiration = 4; +inline bool Message_ProtocolMessage::_internal_has_ephemeralexpiration() const { + bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool Message_ProtocolMessage::has_ephemeralexpiration() const { + return _internal_has_ephemeralexpiration(); +} +inline void Message_ProtocolMessage::clear_ephemeralexpiration() { + _impl_.ephemeralexpiration_ = 0u; + _impl_._has_bits_[0] &= ~0x00000400u; +} +inline uint32_t Message_ProtocolMessage::_internal_ephemeralexpiration() const { + return _impl_.ephemeralexpiration_; +} +inline uint32_t Message_ProtocolMessage::ephemeralexpiration() const { + // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.ephemeralExpiration) + return _internal_ephemeralexpiration(); +} +inline void Message_ProtocolMessage::_internal_set_ephemeralexpiration(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000400u; + _impl_.ephemeralexpiration_ = value; +} +inline void Message_ProtocolMessage::set_ephemeralexpiration(uint32_t value) { + _internal_set_ephemeralexpiration(value); + // @@protoc_insertion_point(field_set:proto.Message.ProtocolMessage.ephemeralExpiration) +} + +// optional int64 ephemeralSettingTimestamp = 5; +inline bool Message_ProtocolMessage::_internal_has_ephemeralsettingtimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; + return value; +} +inline bool Message_ProtocolMessage::has_ephemeralsettingtimestamp() const { + return _internal_has_ephemeralsettingtimestamp(); +} +inline void Message_ProtocolMessage::clear_ephemeralsettingtimestamp() { + _impl_.ephemeralsettingtimestamp_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000800u; +} +inline int64_t Message_ProtocolMessage::_internal_ephemeralsettingtimestamp() const { + return _impl_.ephemeralsettingtimestamp_; +} +inline int64_t Message_ProtocolMessage::ephemeralsettingtimestamp() const { + // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.ephemeralSettingTimestamp) + return _internal_ephemeralsettingtimestamp(); +} +inline void Message_ProtocolMessage::_internal_set_ephemeralsettingtimestamp(int64_t value) { + _impl_._has_bits_[0] |= 0x00000800u; + _impl_.ephemeralsettingtimestamp_ = value; +} +inline void Message_ProtocolMessage::set_ephemeralsettingtimestamp(int64_t value) { + _internal_set_ephemeralsettingtimestamp(value); + // @@protoc_insertion_point(field_set:proto.Message.ProtocolMessage.ephemeralSettingTimestamp) +} + +// optional .proto.Message.HistorySyncNotification historySyncNotification = 6; +inline bool Message_ProtocolMessage::_internal_has_historysyncnotification() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.historysyncnotification_ != nullptr); + return value; +} +inline bool Message_ProtocolMessage::has_historysyncnotification() const { + return _internal_has_historysyncnotification(); +} +inline void Message_ProtocolMessage::clear_historysyncnotification() { + if (_impl_.historysyncnotification_ != nullptr) _impl_.historysyncnotification_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::Message_HistorySyncNotification& Message_ProtocolMessage::_internal_historysyncnotification() const { + const ::proto::Message_HistorySyncNotification* p = _impl_.historysyncnotification_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_HistorySyncNotification_default_instance_); +} +inline const ::proto::Message_HistorySyncNotification& Message_ProtocolMessage::historysyncnotification() const { + // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.historySyncNotification) + return _internal_historysyncnotification(); +} +inline void Message_ProtocolMessage::unsafe_arena_set_allocated_historysyncnotification( + ::proto::Message_HistorySyncNotification* historysyncnotification) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.historysyncnotification_); + } + _impl_.historysyncnotification_ = historysyncnotification; + if (historysyncnotification) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.historySyncNotification) +} +inline ::proto::Message_HistorySyncNotification* Message_ProtocolMessage::release_historysyncnotification() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::Message_HistorySyncNotification* temp = _impl_.historysyncnotification_; + _impl_.historysyncnotification_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_HistorySyncNotification* Message_ProtocolMessage::unsafe_arena_release_historysyncnotification() { + // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.historySyncNotification) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::Message_HistorySyncNotification* temp = _impl_.historysyncnotification_; + _impl_.historysyncnotification_ = nullptr; + return temp; +} +inline ::proto::Message_HistorySyncNotification* Message_ProtocolMessage::_internal_mutable_historysyncnotification() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.historysyncnotification_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_HistorySyncNotification>(GetArenaForAllocation()); + _impl_.historysyncnotification_ = p; + } + return _impl_.historysyncnotification_; +} +inline ::proto::Message_HistorySyncNotification* Message_ProtocolMessage::mutable_historysyncnotification() { + ::proto::Message_HistorySyncNotification* _msg = _internal_mutable_historysyncnotification(); + // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.historySyncNotification) + return _msg; +} +inline void Message_ProtocolMessage::set_allocated_historysyncnotification(::proto::Message_HistorySyncNotification* historysyncnotification) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.historysyncnotification_; + } + if (historysyncnotification) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(historysyncnotification); + if (message_arena != submessage_arena) { + historysyncnotification = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, historysyncnotification, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.historysyncnotification_ = historysyncnotification; + // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.historySyncNotification) +} + +// optional .proto.Message.AppStateSyncKeyShare appStateSyncKeyShare = 7; +inline bool Message_ProtocolMessage::_internal_has_appstatesynckeyshare() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.appstatesynckeyshare_ != nullptr); + return value; +} +inline bool Message_ProtocolMessage::has_appstatesynckeyshare() const { + return _internal_has_appstatesynckeyshare(); +} +inline void Message_ProtocolMessage::clear_appstatesynckeyshare() { + if (_impl_.appstatesynckeyshare_ != nullptr) _impl_.appstatesynckeyshare_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::proto::Message_AppStateSyncKeyShare& Message_ProtocolMessage::_internal_appstatesynckeyshare() const { + const ::proto::Message_AppStateSyncKeyShare* p = _impl_.appstatesynckeyshare_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_AppStateSyncKeyShare_default_instance_); +} +inline const ::proto::Message_AppStateSyncKeyShare& Message_ProtocolMessage::appstatesynckeyshare() const { + // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.appStateSyncKeyShare) + return _internal_appstatesynckeyshare(); +} +inline void Message_ProtocolMessage::unsafe_arena_set_allocated_appstatesynckeyshare( + ::proto::Message_AppStateSyncKeyShare* appstatesynckeyshare) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.appstatesynckeyshare_); + } + _impl_.appstatesynckeyshare_ = appstatesynckeyshare; + if (appstatesynckeyshare) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.appStateSyncKeyShare) +} +inline ::proto::Message_AppStateSyncKeyShare* Message_ProtocolMessage::release_appstatesynckeyshare() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::Message_AppStateSyncKeyShare* temp = _impl_.appstatesynckeyshare_; + _impl_.appstatesynckeyshare_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_AppStateSyncKeyShare* Message_ProtocolMessage::unsafe_arena_release_appstatesynckeyshare() { + // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.appStateSyncKeyShare) + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::Message_AppStateSyncKeyShare* temp = _impl_.appstatesynckeyshare_; + _impl_.appstatesynckeyshare_ = nullptr; + return temp; +} +inline ::proto::Message_AppStateSyncKeyShare* Message_ProtocolMessage::_internal_mutable_appstatesynckeyshare() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.appstatesynckeyshare_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_AppStateSyncKeyShare>(GetArenaForAllocation()); + _impl_.appstatesynckeyshare_ = p; + } + return _impl_.appstatesynckeyshare_; +} +inline ::proto::Message_AppStateSyncKeyShare* Message_ProtocolMessage::mutable_appstatesynckeyshare() { + ::proto::Message_AppStateSyncKeyShare* _msg = _internal_mutable_appstatesynckeyshare(); + // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.appStateSyncKeyShare) + return _msg; +} +inline void Message_ProtocolMessage::set_allocated_appstatesynckeyshare(::proto::Message_AppStateSyncKeyShare* appstatesynckeyshare) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.appstatesynckeyshare_; + } + if (appstatesynckeyshare) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(appstatesynckeyshare); + if (message_arena != submessage_arena) { + appstatesynckeyshare = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, appstatesynckeyshare, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.appstatesynckeyshare_ = appstatesynckeyshare; + // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.appStateSyncKeyShare) +} + +// optional .proto.Message.AppStateSyncKeyRequest appStateSyncKeyRequest = 8; +inline bool Message_ProtocolMessage::_internal_has_appstatesynckeyrequest() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || _impl_.appstatesynckeyrequest_ != nullptr); + return value; +} +inline bool Message_ProtocolMessage::has_appstatesynckeyrequest() const { + return _internal_has_appstatesynckeyrequest(); +} +inline void Message_ProtocolMessage::clear_appstatesynckeyrequest() { + if (_impl_.appstatesynckeyrequest_ != nullptr) _impl_.appstatesynckeyrequest_->Clear(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const ::proto::Message_AppStateSyncKeyRequest& Message_ProtocolMessage::_internal_appstatesynckeyrequest() const { + const ::proto::Message_AppStateSyncKeyRequest* p = _impl_.appstatesynckeyrequest_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_AppStateSyncKeyRequest_default_instance_); +} +inline const ::proto::Message_AppStateSyncKeyRequest& Message_ProtocolMessage::appstatesynckeyrequest() const { + // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.appStateSyncKeyRequest) + return _internal_appstatesynckeyrequest(); +} +inline void Message_ProtocolMessage::unsafe_arena_set_allocated_appstatesynckeyrequest( + ::proto::Message_AppStateSyncKeyRequest* appstatesynckeyrequest) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.appstatesynckeyrequest_); + } + _impl_.appstatesynckeyrequest_ = appstatesynckeyrequest; + if (appstatesynckeyrequest) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.appStateSyncKeyRequest) +} +inline ::proto::Message_AppStateSyncKeyRequest* Message_ProtocolMessage::release_appstatesynckeyrequest() { + _impl_._has_bits_[0] &= ~0x00000008u; + ::proto::Message_AppStateSyncKeyRequest* temp = _impl_.appstatesynckeyrequest_; + _impl_.appstatesynckeyrequest_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_AppStateSyncKeyRequest* Message_ProtocolMessage::unsafe_arena_release_appstatesynckeyrequest() { + // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.appStateSyncKeyRequest) + _impl_._has_bits_[0] &= ~0x00000008u; + ::proto::Message_AppStateSyncKeyRequest* temp = _impl_.appstatesynckeyrequest_; + _impl_.appstatesynckeyrequest_ = nullptr; + return temp; +} +inline ::proto::Message_AppStateSyncKeyRequest* Message_ProtocolMessage::_internal_mutable_appstatesynckeyrequest() { + _impl_._has_bits_[0] |= 0x00000008u; + if (_impl_.appstatesynckeyrequest_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_AppStateSyncKeyRequest>(GetArenaForAllocation()); + _impl_.appstatesynckeyrequest_ = p; + } + return _impl_.appstatesynckeyrequest_; +} +inline ::proto::Message_AppStateSyncKeyRequest* Message_ProtocolMessage::mutable_appstatesynckeyrequest() { + ::proto::Message_AppStateSyncKeyRequest* _msg = _internal_mutable_appstatesynckeyrequest(); + // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.appStateSyncKeyRequest) + return _msg; +} +inline void Message_ProtocolMessage::set_allocated_appstatesynckeyrequest(::proto::Message_AppStateSyncKeyRequest* appstatesynckeyrequest) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.appstatesynckeyrequest_; + } + if (appstatesynckeyrequest) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(appstatesynckeyrequest); + if (message_arena != submessage_arena) { + appstatesynckeyrequest = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, appstatesynckeyrequest, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.appstatesynckeyrequest_ = appstatesynckeyrequest; + // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.appStateSyncKeyRequest) +} + +// optional .proto.Message.InitialSecurityNotificationSettingSync initialSecurityNotificationSettingSync = 9; +inline bool Message_ProtocolMessage::_internal_has_initialsecuritynotificationsettingsync() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + PROTOBUF_ASSUME(!value || _impl_.initialsecuritynotificationsettingsync_ != nullptr); + return value; +} +inline bool Message_ProtocolMessage::has_initialsecuritynotificationsettingsync() const { + return _internal_has_initialsecuritynotificationsettingsync(); +} +inline void Message_ProtocolMessage::clear_initialsecuritynotificationsettingsync() { + if (_impl_.initialsecuritynotificationsettingsync_ != nullptr) _impl_.initialsecuritynotificationsettingsync_->Clear(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const ::proto::Message_InitialSecurityNotificationSettingSync& Message_ProtocolMessage::_internal_initialsecuritynotificationsettingsync() const { + const ::proto::Message_InitialSecurityNotificationSettingSync* p = _impl_.initialsecuritynotificationsettingsync_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_InitialSecurityNotificationSettingSync_default_instance_); +} +inline const ::proto::Message_InitialSecurityNotificationSettingSync& Message_ProtocolMessage::initialsecuritynotificationsettingsync() const { + // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.initialSecurityNotificationSettingSync) + return _internal_initialsecuritynotificationsettingsync(); +} +inline void Message_ProtocolMessage::unsafe_arena_set_allocated_initialsecuritynotificationsettingsync( + ::proto::Message_InitialSecurityNotificationSettingSync* initialsecuritynotificationsettingsync) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.initialsecuritynotificationsettingsync_); + } + _impl_.initialsecuritynotificationsettingsync_ = initialsecuritynotificationsettingsync; + if (initialsecuritynotificationsettingsync) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.initialSecurityNotificationSettingSync) +} +inline ::proto::Message_InitialSecurityNotificationSettingSync* Message_ProtocolMessage::release_initialsecuritynotificationsettingsync() { + _impl_._has_bits_[0] &= ~0x00000010u; + ::proto::Message_InitialSecurityNotificationSettingSync* temp = _impl_.initialsecuritynotificationsettingsync_; + _impl_.initialsecuritynotificationsettingsync_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_InitialSecurityNotificationSettingSync* Message_ProtocolMessage::unsafe_arena_release_initialsecuritynotificationsettingsync() { + // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.initialSecurityNotificationSettingSync) + _impl_._has_bits_[0] &= ~0x00000010u; + ::proto::Message_InitialSecurityNotificationSettingSync* temp = _impl_.initialsecuritynotificationsettingsync_; + _impl_.initialsecuritynotificationsettingsync_ = nullptr; + return temp; +} +inline ::proto::Message_InitialSecurityNotificationSettingSync* Message_ProtocolMessage::_internal_mutable_initialsecuritynotificationsettingsync() { + _impl_._has_bits_[0] |= 0x00000010u; + if (_impl_.initialsecuritynotificationsettingsync_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_InitialSecurityNotificationSettingSync>(GetArenaForAllocation()); + _impl_.initialsecuritynotificationsettingsync_ = p; + } + return _impl_.initialsecuritynotificationsettingsync_; +} +inline ::proto::Message_InitialSecurityNotificationSettingSync* Message_ProtocolMessage::mutable_initialsecuritynotificationsettingsync() { + ::proto::Message_InitialSecurityNotificationSettingSync* _msg = _internal_mutable_initialsecuritynotificationsettingsync(); + // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.initialSecurityNotificationSettingSync) + return _msg; +} +inline void Message_ProtocolMessage::set_allocated_initialsecuritynotificationsettingsync(::proto::Message_InitialSecurityNotificationSettingSync* initialsecuritynotificationsettingsync) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.initialsecuritynotificationsettingsync_; + } + if (initialsecuritynotificationsettingsync) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(initialsecuritynotificationsettingsync); + if (message_arena != submessage_arena) { + initialsecuritynotificationsettingsync = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, initialsecuritynotificationsettingsync, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.initialsecuritynotificationsettingsync_ = initialsecuritynotificationsettingsync; + // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.initialSecurityNotificationSettingSync) +} + +// optional .proto.Message.AppStateFatalExceptionNotification appStateFatalExceptionNotification = 10; +inline bool Message_ProtocolMessage::_internal_has_appstatefatalexceptionnotification() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + PROTOBUF_ASSUME(!value || _impl_.appstatefatalexceptionnotification_ != nullptr); + return value; +} +inline bool Message_ProtocolMessage::has_appstatefatalexceptionnotification() const { + return _internal_has_appstatefatalexceptionnotification(); +} +inline void Message_ProtocolMessage::clear_appstatefatalexceptionnotification() { + if (_impl_.appstatefatalexceptionnotification_ != nullptr) _impl_.appstatefatalexceptionnotification_->Clear(); + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline const ::proto::Message_AppStateFatalExceptionNotification& Message_ProtocolMessage::_internal_appstatefatalexceptionnotification() const { + const ::proto::Message_AppStateFatalExceptionNotification* p = _impl_.appstatefatalexceptionnotification_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_AppStateFatalExceptionNotification_default_instance_); +} +inline const ::proto::Message_AppStateFatalExceptionNotification& Message_ProtocolMessage::appstatefatalexceptionnotification() const { + // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.appStateFatalExceptionNotification) + return _internal_appstatefatalexceptionnotification(); +} +inline void Message_ProtocolMessage::unsafe_arena_set_allocated_appstatefatalexceptionnotification( + ::proto::Message_AppStateFatalExceptionNotification* appstatefatalexceptionnotification) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.appstatefatalexceptionnotification_); + } + _impl_.appstatefatalexceptionnotification_ = appstatefatalexceptionnotification; + if (appstatefatalexceptionnotification) { + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.appStateFatalExceptionNotification) +} +inline ::proto::Message_AppStateFatalExceptionNotification* Message_ProtocolMessage::release_appstatefatalexceptionnotification() { + _impl_._has_bits_[0] &= ~0x00000020u; + ::proto::Message_AppStateFatalExceptionNotification* temp = _impl_.appstatefatalexceptionnotification_; + _impl_.appstatefatalexceptionnotification_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_AppStateFatalExceptionNotification* Message_ProtocolMessage::unsafe_arena_release_appstatefatalexceptionnotification() { + // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.appStateFatalExceptionNotification) + _impl_._has_bits_[0] &= ~0x00000020u; + ::proto::Message_AppStateFatalExceptionNotification* temp = _impl_.appstatefatalexceptionnotification_; + _impl_.appstatefatalexceptionnotification_ = nullptr; + return temp; +} +inline ::proto::Message_AppStateFatalExceptionNotification* Message_ProtocolMessage::_internal_mutable_appstatefatalexceptionnotification() { + _impl_._has_bits_[0] |= 0x00000020u; + if (_impl_.appstatefatalexceptionnotification_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_AppStateFatalExceptionNotification>(GetArenaForAllocation()); + _impl_.appstatefatalexceptionnotification_ = p; + } + return _impl_.appstatefatalexceptionnotification_; +} +inline ::proto::Message_AppStateFatalExceptionNotification* Message_ProtocolMessage::mutable_appstatefatalexceptionnotification() { + ::proto::Message_AppStateFatalExceptionNotification* _msg = _internal_mutable_appstatefatalexceptionnotification(); + // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.appStateFatalExceptionNotification) + return _msg; +} +inline void Message_ProtocolMessage::set_allocated_appstatefatalexceptionnotification(::proto::Message_AppStateFatalExceptionNotification* appstatefatalexceptionnotification) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.appstatefatalexceptionnotification_; + } + if (appstatefatalexceptionnotification) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(appstatefatalexceptionnotification); + if (message_arena != submessage_arena) { + appstatefatalexceptionnotification = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, appstatefatalexceptionnotification, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + _impl_.appstatefatalexceptionnotification_ = appstatefatalexceptionnotification; + // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.appStateFatalExceptionNotification) +} + +// optional .proto.DisappearingMode disappearingMode = 11; +inline bool Message_ProtocolMessage::_internal_has_disappearingmode() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + PROTOBUF_ASSUME(!value || _impl_.disappearingmode_ != nullptr); + return value; +} +inline bool Message_ProtocolMessage::has_disappearingmode() const { + return _internal_has_disappearingmode(); +} +inline void Message_ProtocolMessage::clear_disappearingmode() { + if (_impl_.disappearingmode_ != nullptr) _impl_.disappearingmode_->Clear(); + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline const ::proto::DisappearingMode& Message_ProtocolMessage::_internal_disappearingmode() const { + const ::proto::DisappearingMode* p = _impl_.disappearingmode_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_DisappearingMode_default_instance_); +} +inline const ::proto::DisappearingMode& Message_ProtocolMessage::disappearingmode() const { + // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.disappearingMode) + return _internal_disappearingmode(); +} +inline void Message_ProtocolMessage::unsafe_arena_set_allocated_disappearingmode( + ::proto::DisappearingMode* disappearingmode) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.disappearingmode_); + } + _impl_.disappearingmode_ = disappearingmode; + if (disappearingmode) { + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.disappearingMode) +} +inline ::proto::DisappearingMode* Message_ProtocolMessage::release_disappearingmode() { + _impl_._has_bits_[0] &= ~0x00000040u; + ::proto::DisappearingMode* temp = _impl_.disappearingmode_; + _impl_.disappearingmode_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::DisappearingMode* Message_ProtocolMessage::unsafe_arena_release_disappearingmode() { + // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.disappearingMode) + _impl_._has_bits_[0] &= ~0x00000040u; + ::proto::DisappearingMode* temp = _impl_.disappearingmode_; + _impl_.disappearingmode_ = nullptr; + return temp; +} +inline ::proto::DisappearingMode* Message_ProtocolMessage::_internal_mutable_disappearingmode() { + _impl_._has_bits_[0] |= 0x00000040u; + if (_impl_.disappearingmode_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::DisappearingMode>(GetArenaForAllocation()); + _impl_.disappearingmode_ = p; + } + return _impl_.disappearingmode_; +} +inline ::proto::DisappearingMode* Message_ProtocolMessage::mutable_disappearingmode() { + ::proto::DisappearingMode* _msg = _internal_mutable_disappearingmode(); + // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.disappearingMode) + return _msg; +} +inline void Message_ProtocolMessage::set_allocated_disappearingmode(::proto::DisappearingMode* disappearingmode) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.disappearingmode_; + } + if (disappearingmode) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(disappearingmode); + if (message_arena != submessage_arena) { + disappearingmode = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, disappearingmode, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + _impl_.disappearingmode_ = disappearingmode; + // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.disappearingMode) +} + +// optional .proto.Message.RequestMediaUploadMessage requestMediaUploadMessage = 12; +inline bool Message_ProtocolMessage::_internal_has_requestmediauploadmessage() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + PROTOBUF_ASSUME(!value || _impl_.requestmediauploadmessage_ != nullptr); + return value; +} +inline bool Message_ProtocolMessage::has_requestmediauploadmessage() const { + return _internal_has_requestmediauploadmessage(); +} +inline void Message_ProtocolMessage::clear_requestmediauploadmessage() { + if (_impl_.requestmediauploadmessage_ != nullptr) _impl_.requestmediauploadmessage_->Clear(); + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline const ::proto::Message_RequestMediaUploadMessage& Message_ProtocolMessage::_internal_requestmediauploadmessage() const { + const ::proto::Message_RequestMediaUploadMessage* p = _impl_.requestmediauploadmessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_RequestMediaUploadMessage_default_instance_); +} +inline const ::proto::Message_RequestMediaUploadMessage& Message_ProtocolMessage::requestmediauploadmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.requestMediaUploadMessage) + return _internal_requestmediauploadmessage(); +} +inline void Message_ProtocolMessage::unsafe_arena_set_allocated_requestmediauploadmessage( + ::proto::Message_RequestMediaUploadMessage* requestmediauploadmessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.requestmediauploadmessage_); + } + _impl_.requestmediauploadmessage_ = requestmediauploadmessage; + if (requestmediauploadmessage) { + _impl_._has_bits_[0] |= 0x00000080u; + } else { + _impl_._has_bits_[0] &= ~0x00000080u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.requestMediaUploadMessage) +} +inline ::proto::Message_RequestMediaUploadMessage* Message_ProtocolMessage::release_requestmediauploadmessage() { + _impl_._has_bits_[0] &= ~0x00000080u; + ::proto::Message_RequestMediaUploadMessage* temp = _impl_.requestmediauploadmessage_; + _impl_.requestmediauploadmessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_RequestMediaUploadMessage* Message_ProtocolMessage::unsafe_arena_release_requestmediauploadmessage() { + // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.requestMediaUploadMessage) + _impl_._has_bits_[0] &= ~0x00000080u; + ::proto::Message_RequestMediaUploadMessage* temp = _impl_.requestmediauploadmessage_; + _impl_.requestmediauploadmessage_ = nullptr; + return temp; +} +inline ::proto::Message_RequestMediaUploadMessage* Message_ProtocolMessage::_internal_mutable_requestmediauploadmessage() { + _impl_._has_bits_[0] |= 0x00000080u; + if (_impl_.requestmediauploadmessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_RequestMediaUploadMessage>(GetArenaForAllocation()); + _impl_.requestmediauploadmessage_ = p; + } + return _impl_.requestmediauploadmessage_; +} +inline ::proto::Message_RequestMediaUploadMessage* Message_ProtocolMessage::mutable_requestmediauploadmessage() { + ::proto::Message_RequestMediaUploadMessage* _msg = _internal_mutable_requestmediauploadmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.requestMediaUploadMessage) + return _msg; +} +inline void Message_ProtocolMessage::set_allocated_requestmediauploadmessage(::proto::Message_RequestMediaUploadMessage* requestmediauploadmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.requestmediauploadmessage_; + } + if (requestmediauploadmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(requestmediauploadmessage); + if (message_arena != submessage_arena) { + requestmediauploadmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, requestmediauploadmessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000080u; + } else { + _impl_._has_bits_[0] &= ~0x00000080u; + } + _impl_.requestmediauploadmessage_ = requestmediauploadmessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.requestMediaUploadMessage) +} + +// optional .proto.Message.RequestMediaUploadResponseMessage requestMediaUploadResponseMessage = 13; +inline bool Message_ProtocolMessage::_internal_has_requestmediauploadresponsemessage() const { + bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; + PROTOBUF_ASSUME(!value || _impl_.requestmediauploadresponsemessage_ != nullptr); + return value; +} +inline bool Message_ProtocolMessage::has_requestmediauploadresponsemessage() const { + return _internal_has_requestmediauploadresponsemessage(); +} +inline void Message_ProtocolMessage::clear_requestmediauploadresponsemessage() { + if (_impl_.requestmediauploadresponsemessage_ != nullptr) _impl_.requestmediauploadresponsemessage_->Clear(); + _impl_._has_bits_[0] &= ~0x00000100u; +} +inline const ::proto::Message_RequestMediaUploadResponseMessage& Message_ProtocolMessage::_internal_requestmediauploadresponsemessage() const { + const ::proto::Message_RequestMediaUploadResponseMessage* p = _impl_.requestmediauploadresponsemessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_RequestMediaUploadResponseMessage_default_instance_); +} +inline const ::proto::Message_RequestMediaUploadResponseMessage& Message_ProtocolMessage::requestmediauploadresponsemessage() const { + // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.requestMediaUploadResponseMessage) + return _internal_requestmediauploadresponsemessage(); +} +inline void Message_ProtocolMessage::unsafe_arena_set_allocated_requestmediauploadresponsemessage( + ::proto::Message_RequestMediaUploadResponseMessage* requestmediauploadresponsemessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.requestmediauploadresponsemessage_); + } + _impl_.requestmediauploadresponsemessage_ = requestmediauploadresponsemessage; + if (requestmediauploadresponsemessage) { + _impl_._has_bits_[0] |= 0x00000100u; + } else { + _impl_._has_bits_[0] &= ~0x00000100u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.requestMediaUploadResponseMessage) +} +inline ::proto::Message_RequestMediaUploadResponseMessage* Message_ProtocolMessage::release_requestmediauploadresponsemessage() { + _impl_._has_bits_[0] &= ~0x00000100u; + ::proto::Message_RequestMediaUploadResponseMessage* temp = _impl_.requestmediauploadresponsemessage_; + _impl_.requestmediauploadresponsemessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_RequestMediaUploadResponseMessage* Message_ProtocolMessage::unsafe_arena_release_requestmediauploadresponsemessage() { + // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.requestMediaUploadResponseMessage) + _impl_._has_bits_[0] &= ~0x00000100u; + ::proto::Message_RequestMediaUploadResponseMessage* temp = _impl_.requestmediauploadresponsemessage_; + _impl_.requestmediauploadresponsemessage_ = nullptr; + return temp; +} +inline ::proto::Message_RequestMediaUploadResponseMessage* Message_ProtocolMessage::_internal_mutable_requestmediauploadresponsemessage() { + _impl_._has_bits_[0] |= 0x00000100u; + if (_impl_.requestmediauploadresponsemessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_RequestMediaUploadResponseMessage>(GetArenaForAllocation()); + _impl_.requestmediauploadresponsemessage_ = p; + } + return _impl_.requestmediauploadresponsemessage_; +} +inline ::proto::Message_RequestMediaUploadResponseMessage* Message_ProtocolMessage::mutable_requestmediauploadresponsemessage() { + ::proto::Message_RequestMediaUploadResponseMessage* _msg = _internal_mutable_requestmediauploadresponsemessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.requestMediaUploadResponseMessage) + return _msg; +} +inline void Message_ProtocolMessage::set_allocated_requestmediauploadresponsemessage(::proto::Message_RequestMediaUploadResponseMessage* requestmediauploadresponsemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.requestmediauploadresponsemessage_; + } + if (requestmediauploadresponsemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(requestmediauploadresponsemessage); + if (message_arena != submessage_arena) { + requestmediauploadresponsemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, requestmediauploadresponsemessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000100u; + } else { + _impl_._has_bits_[0] &= ~0x00000100u; + } + _impl_.requestmediauploadresponsemessage_ = requestmediauploadresponsemessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.requestMediaUploadResponseMessage) +} + +// ------------------------------------------------------------------- + +// Message_ReactionMessage + +// optional .proto.MessageKey key = 1; +inline bool Message_ReactionMessage::_internal_has_key() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr); + return value; +} +inline bool Message_ReactionMessage::has_key() const { + return _internal_has_key(); +} +inline void Message_ReactionMessage::clear_key() { + if (_impl_.key_ != nullptr) _impl_.key_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::proto::MessageKey& Message_ReactionMessage::_internal_key() const { + const ::proto::MessageKey* p = _impl_.key_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_MessageKey_default_instance_); +} +inline const ::proto::MessageKey& Message_ReactionMessage::key() const { + // @@protoc_insertion_point(field_get:proto.Message.ReactionMessage.key) + return _internal_key(); +} +inline void Message_ReactionMessage::unsafe_arena_set_allocated_key( + ::proto::MessageKey* key) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_); + } + _impl_.key_ = key; + if (key) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ReactionMessage.key) +} +inline ::proto::MessageKey* Message_ReactionMessage::release_key() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::MessageKey* temp = _impl_.key_; + _impl_.key_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::MessageKey* Message_ReactionMessage::unsafe_arena_release_key() { + // @@protoc_insertion_point(field_release:proto.Message.ReactionMessage.key) + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::MessageKey* temp = _impl_.key_; + _impl_.key_ = nullptr; + return temp; +} +inline ::proto::MessageKey* Message_ReactionMessage::_internal_mutable_key() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.key_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation()); + _impl_.key_ = p; + } + return _impl_.key_; +} +inline ::proto::MessageKey* Message_ReactionMessage::mutable_key() { + ::proto::MessageKey* _msg = _internal_mutable_key(); + // @@protoc_insertion_point(field_mutable:proto.Message.ReactionMessage.key) + return _msg; +} +inline void Message_ReactionMessage::set_allocated_key(::proto::MessageKey* key) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.key_; + } + if (key) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key); + if (message_arena != submessage_arena) { + key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, key, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.key_ = key; + // @@protoc_insertion_point(field_set_allocated:proto.Message.ReactionMessage.key) +} + +// optional string text = 2; +inline bool Message_ReactionMessage::_internal_has_text() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_ReactionMessage::has_text() const { + return _internal_has_text(); +} +inline void Message_ReactionMessage::clear_text() { + _impl_.text_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_ReactionMessage::text() const { + // @@protoc_insertion_point(field_get:proto.Message.ReactionMessage.text) + return _internal_text(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ReactionMessage::set_text(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.text_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ReactionMessage.text) +} +inline std::string* Message_ReactionMessage::mutable_text() { + std::string* _s = _internal_mutable_text(); + // @@protoc_insertion_point(field_mutable:proto.Message.ReactionMessage.text) + return _s; +} +inline const std::string& Message_ReactionMessage::_internal_text() const { + return _impl_.text_.Get(); +} +inline void Message_ReactionMessage::_internal_set_text(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.text_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ReactionMessage::_internal_mutable_text() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.text_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ReactionMessage::release_text() { + // @@protoc_insertion_point(field_release:proto.Message.ReactionMessage.text) + if (!_internal_has_text()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.text_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.text_.IsDefault()) { + _impl_.text_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ReactionMessage::set_allocated_text(std::string* text) { + if (text != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.text_.SetAllocated(text, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.text_.IsDefault()) { + _impl_.text_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ReactionMessage.text) +} + +// optional string groupingKey = 3; +inline bool Message_ReactionMessage::_internal_has_groupingkey() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_ReactionMessage::has_groupingkey() const { + return _internal_has_groupingkey(); +} +inline void Message_ReactionMessage::clear_groupingkey() { + _impl_.groupingkey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_ReactionMessage::groupingkey() const { + // @@protoc_insertion_point(field_get:proto.Message.ReactionMessage.groupingKey) + return _internal_groupingkey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_ReactionMessage::set_groupingkey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.groupingkey_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.ReactionMessage.groupingKey) +} +inline std::string* Message_ReactionMessage::mutable_groupingkey() { + std::string* _s = _internal_mutable_groupingkey(); + // @@protoc_insertion_point(field_mutable:proto.Message.ReactionMessage.groupingKey) + return _s; +} +inline const std::string& Message_ReactionMessage::_internal_groupingkey() const { + return _impl_.groupingkey_.Get(); +} +inline void Message_ReactionMessage::_internal_set_groupingkey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.groupingkey_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_ReactionMessage::_internal_mutable_groupingkey() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.groupingkey_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_ReactionMessage::release_groupingkey() { + // @@protoc_insertion_point(field_release:proto.Message.ReactionMessage.groupingKey) + if (!_internal_has_groupingkey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.groupingkey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.groupingkey_.IsDefault()) { + _impl_.groupingkey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_ReactionMessage::set_allocated_groupingkey(std::string* groupingkey) { + if (groupingkey != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.groupingkey_.SetAllocated(groupingkey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.groupingkey_.IsDefault()) { + _impl_.groupingkey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.ReactionMessage.groupingKey) +} + +// optional int64 senderTimestampMs = 4; +inline bool Message_ReactionMessage::_internal_has_sendertimestampms() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool Message_ReactionMessage::has_sendertimestampms() const { + return _internal_has_sendertimestampms(); +} +inline void Message_ReactionMessage::clear_sendertimestampms() { + _impl_.sendertimestampms_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline int64_t Message_ReactionMessage::_internal_sendertimestampms() const { + return _impl_.sendertimestampms_; +} +inline int64_t Message_ReactionMessage::sendertimestampms() const { + // @@protoc_insertion_point(field_get:proto.Message.ReactionMessage.senderTimestampMs) + return _internal_sendertimestampms(); +} +inline void Message_ReactionMessage::_internal_set_sendertimestampms(int64_t value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.sendertimestampms_ = value; +} +inline void Message_ReactionMessage::set_sendertimestampms(int64_t value) { + _internal_set_sendertimestampms(value); + // @@protoc_insertion_point(field_set:proto.Message.ReactionMessage.senderTimestampMs) +} + +// ------------------------------------------------------------------- + +// Message_RequestMediaUploadMessage + +// repeated string fileSha256 = 1; +inline int Message_RequestMediaUploadMessage::_internal_filesha256_size() const { + return _impl_.filesha256_.size(); +} +inline int Message_RequestMediaUploadMessage::filesha256_size() const { + return _internal_filesha256_size(); +} +inline void Message_RequestMediaUploadMessage::clear_filesha256() { + _impl_.filesha256_.Clear(); +} +inline std::string* Message_RequestMediaUploadMessage::add_filesha256() { + std::string* _s = _internal_add_filesha256(); + // @@protoc_insertion_point(field_add_mutable:proto.Message.RequestMediaUploadMessage.fileSha256) + return _s; +} +inline const std::string& Message_RequestMediaUploadMessage::_internal_filesha256(int index) const { + return _impl_.filesha256_.Get(index); +} +inline const std::string& Message_RequestMediaUploadMessage::filesha256(int index) const { + // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadMessage.fileSha256) + return _internal_filesha256(index); +} +inline std::string* Message_RequestMediaUploadMessage::mutable_filesha256(int index) { + // @@protoc_insertion_point(field_mutable:proto.Message.RequestMediaUploadMessage.fileSha256) + return _impl_.filesha256_.Mutable(index); +} +inline void Message_RequestMediaUploadMessage::set_filesha256(int index, const std::string& value) { + _impl_.filesha256_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:proto.Message.RequestMediaUploadMessage.fileSha256) +} +inline void Message_RequestMediaUploadMessage::set_filesha256(int index, std::string&& value) { + _impl_.filesha256_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:proto.Message.RequestMediaUploadMessage.fileSha256) +} +inline void Message_RequestMediaUploadMessage::set_filesha256(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + _impl_.filesha256_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:proto.Message.RequestMediaUploadMessage.fileSha256) +} +inline void Message_RequestMediaUploadMessage::set_filesha256(int index, const char* value, size_t size) { + _impl_.filesha256_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:proto.Message.RequestMediaUploadMessage.fileSha256) +} +inline std::string* Message_RequestMediaUploadMessage::_internal_add_filesha256() { + return _impl_.filesha256_.Add(); +} +inline void Message_RequestMediaUploadMessage::add_filesha256(const std::string& value) { + _impl_.filesha256_.Add()->assign(value); + // @@protoc_insertion_point(field_add:proto.Message.RequestMediaUploadMessage.fileSha256) +} +inline void Message_RequestMediaUploadMessage::add_filesha256(std::string&& value) { + _impl_.filesha256_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:proto.Message.RequestMediaUploadMessage.fileSha256) +} +inline void Message_RequestMediaUploadMessage::add_filesha256(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _impl_.filesha256_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:proto.Message.RequestMediaUploadMessage.fileSha256) +} +inline void Message_RequestMediaUploadMessage::add_filesha256(const char* value, size_t size) { + _impl_.filesha256_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:proto.Message.RequestMediaUploadMessage.fileSha256) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +Message_RequestMediaUploadMessage::filesha256() const { + // @@protoc_insertion_point(field_list:proto.Message.RequestMediaUploadMessage.fileSha256) + return _impl_.filesha256_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +Message_RequestMediaUploadMessage::mutable_filesha256() { + // @@protoc_insertion_point(field_mutable_list:proto.Message.RequestMediaUploadMessage.fileSha256) + return &_impl_.filesha256_; +} + +// optional .proto.Message.RmrSource rmrSource = 2; +inline bool Message_RequestMediaUploadMessage::_internal_has_rmrsource() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_RequestMediaUploadMessage::has_rmrsource() const { + return _internal_has_rmrsource(); +} +inline void Message_RequestMediaUploadMessage::clear_rmrsource() { + _impl_.rmrsource_ = 0; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline ::proto::Message_RmrSource Message_RequestMediaUploadMessage::_internal_rmrsource() const { + return static_cast< ::proto::Message_RmrSource >(_impl_.rmrsource_); +} +inline ::proto::Message_RmrSource Message_RequestMediaUploadMessage::rmrsource() const { + // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadMessage.rmrSource) + return _internal_rmrsource(); +} +inline void Message_RequestMediaUploadMessage::_internal_set_rmrsource(::proto::Message_RmrSource value) { + assert(::proto::Message_RmrSource_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.rmrsource_ = value; +} +inline void Message_RequestMediaUploadMessage::set_rmrsource(::proto::Message_RmrSource value) { + _internal_set_rmrsource(value); + // @@protoc_insertion_point(field_set:proto.Message.RequestMediaUploadMessage.rmrSource) +} + +// ------------------------------------------------------------------- + +// Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult + +// optional string fileSha256 = 1; +inline bool Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_has_filesha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::has_filesha256() const { + return _internal_has_filesha256(); +} +inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::clear_filesha256() { + _impl_.filesha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::filesha256() const { + // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.fileSha256) + return _internal_filesha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::set_filesha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.filesha256_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.fileSha256) +} +inline std::string* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::mutable_filesha256() { + std::string* _s = _internal_mutable_filesha256(); + // @@protoc_insertion_point(field_mutable:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.fileSha256) + return _s; +} +inline const std::string& Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_filesha256() const { + return _impl_.filesha256_.Get(); +} +inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_set_filesha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.filesha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_mutable_filesha256() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.filesha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::release_filesha256() { + // @@protoc_insertion_point(field_release:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.fileSha256) + if (!_internal_has_filesha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.filesha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.filesha256_.IsDefault()) { + _impl_.filesha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::set_allocated_filesha256(std::string* filesha256) { + if (filesha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.filesha256_.IsDefault()) { + _impl_.filesha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.fileSha256) +} + +// optional .proto.MediaRetryNotification.ResultType mediaUploadResult = 2; +inline bool Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_has_mediauploadresult() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::has_mediauploadresult() const { + return _internal_has_mediauploadresult(); +} +inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::clear_mediauploadresult() { + _impl_.mediauploadresult_ = 0; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline ::proto::MediaRetryNotification_ResultType Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_mediauploadresult() const { + return static_cast< ::proto::MediaRetryNotification_ResultType >(_impl_.mediauploadresult_); +} +inline ::proto::MediaRetryNotification_ResultType Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::mediauploadresult() const { + // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.mediaUploadResult) + return _internal_mediauploadresult(); +} +inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_set_mediauploadresult(::proto::MediaRetryNotification_ResultType value) { + assert(::proto::MediaRetryNotification_ResultType_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.mediauploadresult_ = value; +} +inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::set_mediauploadresult(::proto::MediaRetryNotification_ResultType value) { + _internal_set_mediauploadresult(value); + // @@protoc_insertion_point(field_set:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.mediaUploadResult) +} + +// optional .proto.Message.StickerMessage stickerMessage = 3; +inline bool Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_has_stickermessage() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.stickermessage_ != nullptr); + return value; +} +inline bool Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::has_stickermessage() const { + return _internal_has_stickermessage(); +} +inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::clear_stickermessage() { + if (_impl_.stickermessage_ != nullptr) _impl_.stickermessage_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::Message_StickerMessage& Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_stickermessage() const { + const ::proto::Message_StickerMessage* p = _impl_.stickermessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_StickerMessage_default_instance_); +} +inline const ::proto::Message_StickerMessage& Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::stickermessage() const { + // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.stickerMessage) + return _internal_stickermessage(); +} +inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::unsafe_arena_set_allocated_stickermessage( + ::proto::Message_StickerMessage* stickermessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.stickermessage_); + } + _impl_.stickermessage_ = stickermessage; + if (stickermessage) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.stickerMessage) +} +inline ::proto::Message_StickerMessage* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::release_stickermessage() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::Message_StickerMessage* temp = _impl_.stickermessage_; + _impl_.stickermessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_StickerMessage* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::unsafe_arena_release_stickermessage() { + // @@protoc_insertion_point(field_release:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.stickerMessage) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::Message_StickerMessage* temp = _impl_.stickermessage_; + _impl_.stickermessage_ = nullptr; + return temp; +} +inline ::proto::Message_StickerMessage* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_mutable_stickermessage() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.stickermessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_StickerMessage>(GetArenaForAllocation()); + _impl_.stickermessage_ = p; + } + return _impl_.stickermessage_; +} +inline ::proto::Message_StickerMessage* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::mutable_stickermessage() { + ::proto::Message_StickerMessage* _msg = _internal_mutable_stickermessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.stickerMessage) + return _msg; +} +inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::set_allocated_stickermessage(::proto::Message_StickerMessage* stickermessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.stickermessage_; + } + if (stickermessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(stickermessage); + if (message_arena != submessage_arena) { + stickermessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, stickermessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.stickermessage_ = stickermessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.stickerMessage) +} + +// ------------------------------------------------------------------- + +// Message_RequestMediaUploadResponseMessage + +// optional .proto.Message.RmrSource rmrSource = 1; +inline bool Message_RequestMediaUploadResponseMessage::_internal_has_rmrsource() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_RequestMediaUploadResponseMessage::has_rmrsource() const { + return _internal_has_rmrsource(); +} +inline void Message_RequestMediaUploadResponseMessage::clear_rmrsource() { + _impl_.rmrsource_ = 0; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline ::proto::Message_RmrSource Message_RequestMediaUploadResponseMessage::_internal_rmrsource() const { + return static_cast< ::proto::Message_RmrSource >(_impl_.rmrsource_); +} +inline ::proto::Message_RmrSource Message_RequestMediaUploadResponseMessage::rmrsource() const { + // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadResponseMessage.rmrSource) + return _internal_rmrsource(); +} +inline void Message_RequestMediaUploadResponseMessage::_internal_set_rmrsource(::proto::Message_RmrSource value) { + assert(::proto::Message_RmrSource_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.rmrsource_ = value; +} +inline void Message_RequestMediaUploadResponseMessage::set_rmrsource(::proto::Message_RmrSource value) { + _internal_set_rmrsource(value); + // @@protoc_insertion_point(field_set:proto.Message.RequestMediaUploadResponseMessage.rmrSource) +} + +// optional string stanzaId = 2; +inline bool Message_RequestMediaUploadResponseMessage::_internal_has_stanzaid() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_RequestMediaUploadResponseMessage::has_stanzaid() const { + return _internal_has_stanzaid(); +} +inline void Message_RequestMediaUploadResponseMessage::clear_stanzaid() { + _impl_.stanzaid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_RequestMediaUploadResponseMessage::stanzaid() const { + // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadResponseMessage.stanzaId) + return _internal_stanzaid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_RequestMediaUploadResponseMessage::set_stanzaid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.stanzaid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.RequestMediaUploadResponseMessage.stanzaId) +} +inline std::string* Message_RequestMediaUploadResponseMessage::mutable_stanzaid() { + std::string* _s = _internal_mutable_stanzaid(); + // @@protoc_insertion_point(field_mutable:proto.Message.RequestMediaUploadResponseMessage.stanzaId) + return _s; +} +inline const std::string& Message_RequestMediaUploadResponseMessage::_internal_stanzaid() const { + return _impl_.stanzaid_.Get(); +} +inline void Message_RequestMediaUploadResponseMessage::_internal_set_stanzaid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.stanzaid_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_RequestMediaUploadResponseMessage::_internal_mutable_stanzaid() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.stanzaid_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_RequestMediaUploadResponseMessage::release_stanzaid() { + // @@protoc_insertion_point(field_release:proto.Message.RequestMediaUploadResponseMessage.stanzaId) + if (!_internal_has_stanzaid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.stanzaid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.stanzaid_.IsDefault()) { + _impl_.stanzaid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_RequestMediaUploadResponseMessage::set_allocated_stanzaid(std::string* stanzaid) { + if (stanzaid != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.stanzaid_.SetAllocated(stanzaid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.stanzaid_.IsDefault()) { + _impl_.stanzaid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestMediaUploadResponseMessage.stanzaId) +} + +// repeated .proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult reuploadResult = 3; +inline int Message_RequestMediaUploadResponseMessage::_internal_reuploadresult_size() const { + return _impl_.reuploadresult_.size(); +} +inline int Message_RequestMediaUploadResponseMessage::reuploadresult_size() const { + return _internal_reuploadresult_size(); +} +inline void Message_RequestMediaUploadResponseMessage::clear_reuploadresult() { + _impl_.reuploadresult_.Clear(); +} +inline ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* Message_RequestMediaUploadResponseMessage::mutable_reuploadresult(int index) { + // @@protoc_insertion_point(field_mutable:proto.Message.RequestMediaUploadResponseMessage.reuploadResult) + return _impl_.reuploadresult_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult >* +Message_RequestMediaUploadResponseMessage::mutable_reuploadresult() { + // @@protoc_insertion_point(field_mutable_list:proto.Message.RequestMediaUploadResponseMessage.reuploadResult) + return &_impl_.reuploadresult_; +} +inline const ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& Message_RequestMediaUploadResponseMessage::_internal_reuploadresult(int index) const { + return _impl_.reuploadresult_.Get(index); +} +inline const ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& Message_RequestMediaUploadResponseMessage::reuploadresult(int index) const { + // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadResponseMessage.reuploadResult) + return _internal_reuploadresult(index); +} +inline ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* Message_RequestMediaUploadResponseMessage::_internal_add_reuploadresult() { + return _impl_.reuploadresult_.Add(); +} +inline ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* Message_RequestMediaUploadResponseMessage::add_reuploadresult() { + ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* _add = _internal_add_reuploadresult(); + // @@protoc_insertion_point(field_add:proto.Message.RequestMediaUploadResponseMessage.reuploadResult) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult >& +Message_RequestMediaUploadResponseMessage::reuploadresult() const { + // @@protoc_insertion_point(field_list:proto.Message.RequestMediaUploadResponseMessage.reuploadResult) + return _impl_.reuploadresult_; +} + +// ------------------------------------------------------------------- + +// Message_RequestPaymentMessage + +// optional .proto.Message noteMessage = 4; +inline bool Message_RequestPaymentMessage::_internal_has_notemessage() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.notemessage_ != nullptr); + return value; +} +inline bool Message_RequestPaymentMessage::has_notemessage() const { + return _internal_has_notemessage(); +} +inline void Message_RequestPaymentMessage::clear_notemessage() { + if (_impl_.notemessage_ != nullptr) _impl_.notemessage_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::proto::Message& Message_RequestPaymentMessage::_internal_notemessage() const { + const ::proto::Message* p = _impl_.notemessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_default_instance_); +} +inline const ::proto::Message& Message_RequestPaymentMessage::notemessage() const { + // @@protoc_insertion_point(field_get:proto.Message.RequestPaymentMessage.noteMessage) + return _internal_notemessage(); +} +inline void Message_RequestPaymentMessage::unsafe_arena_set_allocated_notemessage( + ::proto::Message* notemessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.notemessage_); + } + _impl_.notemessage_ = notemessage; + if (notemessage) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.RequestPaymentMessage.noteMessage) +} +inline ::proto::Message* Message_RequestPaymentMessage::release_notemessage() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::Message* temp = _impl_.notemessage_; + _impl_.notemessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message* Message_RequestPaymentMessage::unsafe_arena_release_notemessage() { + // @@protoc_insertion_point(field_release:proto.Message.RequestPaymentMessage.noteMessage) + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::Message* temp = _impl_.notemessage_; + _impl_.notemessage_ = nullptr; + return temp; +} +inline ::proto::Message* Message_RequestPaymentMessage::_internal_mutable_notemessage() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.notemessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message>(GetArenaForAllocation()); + _impl_.notemessage_ = p; + } + return _impl_.notemessage_; +} +inline ::proto::Message* Message_RequestPaymentMessage::mutable_notemessage() { + ::proto::Message* _msg = _internal_mutable_notemessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.RequestPaymentMessage.noteMessage) + return _msg; +} +inline void Message_RequestPaymentMessage::set_allocated_notemessage(::proto::Message* notemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.notemessage_; + } + if (notemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(notemessage); + if (message_arena != submessage_arena) { + notemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, notemessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.notemessage_ = notemessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestPaymentMessage.noteMessage) +} + +// optional string currencyCodeIso4217 = 1; +inline bool Message_RequestPaymentMessage::_internal_has_currencycodeiso4217() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_RequestPaymentMessage::has_currencycodeiso4217() const { + return _internal_has_currencycodeiso4217(); +} +inline void Message_RequestPaymentMessage::clear_currencycodeiso4217() { + _impl_.currencycodeiso4217_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_RequestPaymentMessage::currencycodeiso4217() const { + // @@protoc_insertion_point(field_get:proto.Message.RequestPaymentMessage.currencyCodeIso4217) + return _internal_currencycodeiso4217(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_RequestPaymentMessage::set_currencycodeiso4217(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.currencycodeiso4217_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.RequestPaymentMessage.currencyCodeIso4217) +} +inline std::string* Message_RequestPaymentMessage::mutable_currencycodeiso4217() { + std::string* _s = _internal_mutable_currencycodeiso4217(); + // @@protoc_insertion_point(field_mutable:proto.Message.RequestPaymentMessage.currencyCodeIso4217) + return _s; +} +inline const std::string& Message_RequestPaymentMessage::_internal_currencycodeiso4217() const { + return _impl_.currencycodeiso4217_.Get(); +} +inline void Message_RequestPaymentMessage::_internal_set_currencycodeiso4217(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.currencycodeiso4217_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_RequestPaymentMessage::_internal_mutable_currencycodeiso4217() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.currencycodeiso4217_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_RequestPaymentMessage::release_currencycodeiso4217() { + // @@protoc_insertion_point(field_release:proto.Message.RequestPaymentMessage.currencyCodeIso4217) + if (!_internal_has_currencycodeiso4217()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.currencycodeiso4217_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.currencycodeiso4217_.IsDefault()) { + _impl_.currencycodeiso4217_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_RequestPaymentMessage::set_allocated_currencycodeiso4217(std::string* currencycodeiso4217) { + if (currencycodeiso4217 != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.currencycodeiso4217_.SetAllocated(currencycodeiso4217, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.currencycodeiso4217_.IsDefault()) { + _impl_.currencycodeiso4217_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestPaymentMessage.currencyCodeIso4217) +} + +// optional uint64 amount1000 = 2; +inline bool Message_RequestPaymentMessage::_internal_has_amount1000() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool Message_RequestPaymentMessage::has_amount1000() const { + return _internal_has_amount1000(); +} +inline void Message_RequestPaymentMessage::clear_amount1000() { + _impl_.amount1000_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline uint64_t Message_RequestPaymentMessage::_internal_amount1000() const { + return _impl_.amount1000_; +} +inline uint64_t Message_RequestPaymentMessage::amount1000() const { + // @@protoc_insertion_point(field_get:proto.Message.RequestPaymentMessage.amount1000) + return _internal_amount1000(); +} +inline void Message_RequestPaymentMessage::_internal_set_amount1000(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.amount1000_ = value; +} +inline void Message_RequestPaymentMessage::set_amount1000(uint64_t value) { + _internal_set_amount1000(value); + // @@protoc_insertion_point(field_set:proto.Message.RequestPaymentMessage.amount1000) +} + +// optional string requestFrom = 3; +inline bool Message_RequestPaymentMessage::_internal_has_requestfrom() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_RequestPaymentMessage::has_requestfrom() const { + return _internal_has_requestfrom(); +} +inline void Message_RequestPaymentMessage::clear_requestfrom() { + _impl_.requestfrom_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_RequestPaymentMessage::requestfrom() const { + // @@protoc_insertion_point(field_get:proto.Message.RequestPaymentMessage.requestFrom) + return _internal_requestfrom(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_RequestPaymentMessage::set_requestfrom(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.requestfrom_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.RequestPaymentMessage.requestFrom) +} +inline std::string* Message_RequestPaymentMessage::mutable_requestfrom() { + std::string* _s = _internal_mutable_requestfrom(); + // @@protoc_insertion_point(field_mutable:proto.Message.RequestPaymentMessage.requestFrom) + return _s; +} +inline const std::string& Message_RequestPaymentMessage::_internal_requestfrom() const { + return _impl_.requestfrom_.Get(); +} +inline void Message_RequestPaymentMessage::_internal_set_requestfrom(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.requestfrom_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_RequestPaymentMessage::_internal_mutable_requestfrom() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.requestfrom_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_RequestPaymentMessage::release_requestfrom() { + // @@protoc_insertion_point(field_release:proto.Message.RequestPaymentMessage.requestFrom) + if (!_internal_has_requestfrom()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.requestfrom_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.requestfrom_.IsDefault()) { + _impl_.requestfrom_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_RequestPaymentMessage::set_allocated_requestfrom(std::string* requestfrom) { + if (requestfrom != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.requestfrom_.SetAllocated(requestfrom, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.requestfrom_.IsDefault()) { + _impl_.requestfrom_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestPaymentMessage.requestFrom) +} + +// optional int64 expiryTimestamp = 5; +inline bool Message_RequestPaymentMessage::_internal_has_expirytimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool Message_RequestPaymentMessage::has_expirytimestamp() const { + return _internal_has_expirytimestamp(); +} +inline void Message_RequestPaymentMessage::clear_expirytimestamp() { + _impl_.expirytimestamp_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline int64_t Message_RequestPaymentMessage::_internal_expirytimestamp() const { + return _impl_.expirytimestamp_; +} +inline int64_t Message_RequestPaymentMessage::expirytimestamp() const { + // @@protoc_insertion_point(field_get:proto.Message.RequestPaymentMessage.expiryTimestamp) + return _internal_expirytimestamp(); +} +inline void Message_RequestPaymentMessage::_internal_set_expirytimestamp(int64_t value) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.expirytimestamp_ = value; +} +inline void Message_RequestPaymentMessage::set_expirytimestamp(int64_t value) { + _internal_set_expirytimestamp(value); + // @@protoc_insertion_point(field_set:proto.Message.RequestPaymentMessage.expiryTimestamp) +} + +// optional .proto.Money amount = 6; +inline bool Message_RequestPaymentMessage::_internal_has_amount() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || _impl_.amount_ != nullptr); + return value; +} +inline bool Message_RequestPaymentMessage::has_amount() const { + return _internal_has_amount(); +} +inline void Message_RequestPaymentMessage::clear_amount() { + if (_impl_.amount_ != nullptr) _impl_.amount_->Clear(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const ::proto::Money& Message_RequestPaymentMessage::_internal_amount() const { + const ::proto::Money* p = _impl_.amount_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Money_default_instance_); +} +inline const ::proto::Money& Message_RequestPaymentMessage::amount() const { + // @@protoc_insertion_point(field_get:proto.Message.RequestPaymentMessage.amount) + return _internal_amount(); +} +inline void Message_RequestPaymentMessage::unsafe_arena_set_allocated_amount( + ::proto::Money* amount) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.amount_); + } + _impl_.amount_ = amount; + if (amount) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.RequestPaymentMessage.amount) +} +inline ::proto::Money* Message_RequestPaymentMessage::release_amount() { + _impl_._has_bits_[0] &= ~0x00000008u; + ::proto::Money* temp = _impl_.amount_; + _impl_.amount_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Money* Message_RequestPaymentMessage::unsafe_arena_release_amount() { + // @@protoc_insertion_point(field_release:proto.Message.RequestPaymentMessage.amount) + _impl_._has_bits_[0] &= ~0x00000008u; + ::proto::Money* temp = _impl_.amount_; + _impl_.amount_ = nullptr; + return temp; +} +inline ::proto::Money* Message_RequestPaymentMessage::_internal_mutable_amount() { + _impl_._has_bits_[0] |= 0x00000008u; + if (_impl_.amount_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Money>(GetArenaForAllocation()); + _impl_.amount_ = p; + } + return _impl_.amount_; +} +inline ::proto::Money* Message_RequestPaymentMessage::mutable_amount() { + ::proto::Money* _msg = _internal_mutable_amount(); + // @@protoc_insertion_point(field_mutable:proto.Message.RequestPaymentMessage.amount) + return _msg; +} +inline void Message_RequestPaymentMessage::set_allocated_amount(::proto::Money* amount) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.amount_; + } + if (amount) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(amount); + if (message_arena != submessage_arena) { + amount = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, amount, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.amount_ = amount; + // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestPaymentMessage.amount) +} + +// optional .proto.PaymentBackground background = 7; +inline bool Message_RequestPaymentMessage::_internal_has_background() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + PROTOBUF_ASSUME(!value || _impl_.background_ != nullptr); + return value; +} +inline bool Message_RequestPaymentMessage::has_background() const { + return _internal_has_background(); +} +inline void Message_RequestPaymentMessage::clear_background() { + if (_impl_.background_ != nullptr) _impl_.background_->Clear(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const ::proto::PaymentBackground& Message_RequestPaymentMessage::_internal_background() const { + const ::proto::PaymentBackground* p = _impl_.background_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_PaymentBackground_default_instance_); +} +inline const ::proto::PaymentBackground& Message_RequestPaymentMessage::background() const { + // @@protoc_insertion_point(field_get:proto.Message.RequestPaymentMessage.background) + return _internal_background(); +} +inline void Message_RequestPaymentMessage::unsafe_arena_set_allocated_background( + ::proto::PaymentBackground* background) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.background_); + } + _impl_.background_ = background; + if (background) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.RequestPaymentMessage.background) +} +inline ::proto::PaymentBackground* Message_RequestPaymentMessage::release_background() { + _impl_._has_bits_[0] &= ~0x00000010u; + ::proto::PaymentBackground* temp = _impl_.background_; + _impl_.background_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::PaymentBackground* Message_RequestPaymentMessage::unsafe_arena_release_background() { + // @@protoc_insertion_point(field_release:proto.Message.RequestPaymentMessage.background) + _impl_._has_bits_[0] &= ~0x00000010u; + ::proto::PaymentBackground* temp = _impl_.background_; + _impl_.background_ = nullptr; + return temp; +} +inline ::proto::PaymentBackground* Message_RequestPaymentMessage::_internal_mutable_background() { + _impl_._has_bits_[0] |= 0x00000010u; + if (_impl_.background_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::PaymentBackground>(GetArenaForAllocation()); + _impl_.background_ = p; + } + return _impl_.background_; +} +inline ::proto::PaymentBackground* Message_RequestPaymentMessage::mutable_background() { + ::proto::PaymentBackground* _msg = _internal_mutable_background(); + // @@protoc_insertion_point(field_mutable:proto.Message.RequestPaymentMessage.background) + return _msg; +} +inline void Message_RequestPaymentMessage::set_allocated_background(::proto::PaymentBackground* background) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.background_; + } + if (background) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(background); + if (message_arena != submessage_arena) { + background = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, background, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.background_ = background; + // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestPaymentMessage.background) +} + +// ------------------------------------------------------------------- + +// Message_RequestPhoneNumberMessage + +// optional .proto.ContextInfo contextInfo = 1; +inline bool Message_RequestPhoneNumberMessage::_internal_has_contextinfo() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); + return value; +} +inline bool Message_RequestPhoneNumberMessage::has_contextinfo() const { + return _internal_has_contextinfo(); +} +inline void Message_RequestPhoneNumberMessage::clear_contextinfo() { + if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::ContextInfo& Message_RequestPhoneNumberMessage::_internal_contextinfo() const { + const ::proto::ContextInfo* p = _impl_.contextinfo_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ContextInfo_default_instance_); +} +inline const ::proto::ContextInfo& Message_RequestPhoneNumberMessage::contextinfo() const { + // @@protoc_insertion_point(field_get:proto.Message.RequestPhoneNumberMessage.contextInfo) + return _internal_contextinfo(); +} +inline void Message_RequestPhoneNumberMessage::unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); + } + _impl_.contextinfo_ = contextinfo; + if (contextinfo) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.RequestPhoneNumberMessage.contextInfo) +} +inline ::proto::ContextInfo* Message_RequestPhoneNumberMessage::release_contextinfo() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ContextInfo* Message_RequestPhoneNumberMessage::unsafe_arena_release_contextinfo() { + // @@protoc_insertion_point(field_release:proto.Message.RequestPhoneNumberMessage.contextInfo) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; + return temp; +} +inline ::proto::ContextInfo* Message_RequestPhoneNumberMessage::_internal_mutable_contextinfo() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.contextinfo_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); + _impl_.contextinfo_ = p; + } + return _impl_.contextinfo_; +} +inline ::proto::ContextInfo* Message_RequestPhoneNumberMessage::mutable_contextinfo() { + ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); + // @@protoc_insertion_point(field_mutable:proto.Message.RequestPhoneNumberMessage.contextInfo) + return _msg; +} +inline void Message_RequestPhoneNumberMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.contextinfo_; + } + if (contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); + if (message_arena != submessage_arena) { + contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, contextinfo, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.contextinfo_ = contextinfo; + // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestPhoneNumberMessage.contextInfo) +} + +// ------------------------------------------------------------------- + +// Message_SendPaymentMessage + +// optional .proto.Message noteMessage = 2; +inline bool Message_SendPaymentMessage::_internal_has_notemessage() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.notemessage_ != nullptr); + return value; +} +inline bool Message_SendPaymentMessage::has_notemessage() const { + return _internal_has_notemessage(); +} +inline void Message_SendPaymentMessage::clear_notemessage() { + if (_impl_.notemessage_ != nullptr) _impl_.notemessage_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::Message& Message_SendPaymentMessage::_internal_notemessage() const { + const ::proto::Message* p = _impl_.notemessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_default_instance_); +} +inline const ::proto::Message& Message_SendPaymentMessage::notemessage() const { + // @@protoc_insertion_point(field_get:proto.Message.SendPaymentMessage.noteMessage) + return _internal_notemessage(); +} +inline void Message_SendPaymentMessage::unsafe_arena_set_allocated_notemessage( + ::proto::Message* notemessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.notemessage_); + } + _impl_.notemessage_ = notemessage; + if (notemessage) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.SendPaymentMessage.noteMessage) +} +inline ::proto::Message* Message_SendPaymentMessage::release_notemessage() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::Message* temp = _impl_.notemessage_; + _impl_.notemessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message* Message_SendPaymentMessage::unsafe_arena_release_notemessage() { + // @@protoc_insertion_point(field_release:proto.Message.SendPaymentMessage.noteMessage) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::Message* temp = _impl_.notemessage_; + _impl_.notemessage_ = nullptr; + return temp; +} +inline ::proto::Message* Message_SendPaymentMessage::_internal_mutable_notemessage() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.notemessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message>(GetArenaForAllocation()); + _impl_.notemessage_ = p; + } + return _impl_.notemessage_; +} +inline ::proto::Message* Message_SendPaymentMessage::mutable_notemessage() { + ::proto::Message* _msg = _internal_mutable_notemessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.SendPaymentMessage.noteMessage) + return _msg; +} +inline void Message_SendPaymentMessage::set_allocated_notemessage(::proto::Message* notemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.notemessage_; + } + if (notemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(notemessage); + if (message_arena != submessage_arena) { + notemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, notemessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.notemessage_ = notemessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.SendPaymentMessage.noteMessage) +} + +// optional .proto.MessageKey requestMessageKey = 3; +inline bool Message_SendPaymentMessage::_internal_has_requestmessagekey() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.requestmessagekey_ != nullptr); + return value; +} +inline bool Message_SendPaymentMessage::has_requestmessagekey() const { + return _internal_has_requestmessagekey(); +} +inline void Message_SendPaymentMessage::clear_requestmessagekey() { + if (_impl_.requestmessagekey_ != nullptr) _impl_.requestmessagekey_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::MessageKey& Message_SendPaymentMessage::_internal_requestmessagekey() const { + const ::proto::MessageKey* p = _impl_.requestmessagekey_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_MessageKey_default_instance_); +} +inline const ::proto::MessageKey& Message_SendPaymentMessage::requestmessagekey() const { + // @@protoc_insertion_point(field_get:proto.Message.SendPaymentMessage.requestMessageKey) + return _internal_requestmessagekey(); +} +inline void Message_SendPaymentMessage::unsafe_arena_set_allocated_requestmessagekey( + ::proto::MessageKey* requestmessagekey) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.requestmessagekey_); + } + _impl_.requestmessagekey_ = requestmessagekey; + if (requestmessagekey) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.SendPaymentMessage.requestMessageKey) +} +inline ::proto::MessageKey* Message_SendPaymentMessage::release_requestmessagekey() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::MessageKey* temp = _impl_.requestmessagekey_; + _impl_.requestmessagekey_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::MessageKey* Message_SendPaymentMessage::unsafe_arena_release_requestmessagekey() { + // @@protoc_insertion_point(field_release:proto.Message.SendPaymentMessage.requestMessageKey) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::MessageKey* temp = _impl_.requestmessagekey_; + _impl_.requestmessagekey_ = nullptr; + return temp; +} +inline ::proto::MessageKey* Message_SendPaymentMessage::_internal_mutable_requestmessagekey() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.requestmessagekey_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation()); + _impl_.requestmessagekey_ = p; + } + return _impl_.requestmessagekey_; +} +inline ::proto::MessageKey* Message_SendPaymentMessage::mutable_requestmessagekey() { + ::proto::MessageKey* _msg = _internal_mutable_requestmessagekey(); + // @@protoc_insertion_point(field_mutable:proto.Message.SendPaymentMessage.requestMessageKey) + return _msg; +} +inline void Message_SendPaymentMessage::set_allocated_requestmessagekey(::proto::MessageKey* requestmessagekey) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.requestmessagekey_; + } + if (requestmessagekey) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(requestmessagekey); + if (message_arena != submessage_arena) { + requestmessagekey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, requestmessagekey, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.requestmessagekey_ = requestmessagekey; + // @@protoc_insertion_point(field_set_allocated:proto.Message.SendPaymentMessage.requestMessageKey) +} + +// optional .proto.PaymentBackground background = 4; +inline bool Message_SendPaymentMessage::_internal_has_background() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.background_ != nullptr); + return value; +} +inline bool Message_SendPaymentMessage::has_background() const { + return _internal_has_background(); +} +inline void Message_SendPaymentMessage::clear_background() { + if (_impl_.background_ != nullptr) _impl_.background_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::proto::PaymentBackground& Message_SendPaymentMessage::_internal_background() const { + const ::proto::PaymentBackground* p = _impl_.background_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_PaymentBackground_default_instance_); +} +inline const ::proto::PaymentBackground& Message_SendPaymentMessage::background() const { + // @@protoc_insertion_point(field_get:proto.Message.SendPaymentMessage.background) + return _internal_background(); +} +inline void Message_SendPaymentMessage::unsafe_arena_set_allocated_background( + ::proto::PaymentBackground* background) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.background_); + } + _impl_.background_ = background; + if (background) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.SendPaymentMessage.background) +} +inline ::proto::PaymentBackground* Message_SendPaymentMessage::release_background() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::PaymentBackground* temp = _impl_.background_; + _impl_.background_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::PaymentBackground* Message_SendPaymentMessage::unsafe_arena_release_background() { + // @@protoc_insertion_point(field_release:proto.Message.SendPaymentMessage.background) + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::PaymentBackground* temp = _impl_.background_; + _impl_.background_ = nullptr; + return temp; +} +inline ::proto::PaymentBackground* Message_SendPaymentMessage::_internal_mutable_background() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.background_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::PaymentBackground>(GetArenaForAllocation()); + _impl_.background_ = p; + } + return _impl_.background_; +} +inline ::proto::PaymentBackground* Message_SendPaymentMessage::mutable_background() { + ::proto::PaymentBackground* _msg = _internal_mutable_background(); + // @@protoc_insertion_point(field_mutable:proto.Message.SendPaymentMessage.background) + return _msg; +} +inline void Message_SendPaymentMessage::set_allocated_background(::proto::PaymentBackground* background) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.background_; + } + if (background) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(background); + if (message_arena != submessage_arena) { + background = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, background, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.background_ = background; + // @@protoc_insertion_point(field_set_allocated:proto.Message.SendPaymentMessage.background) +} + +// ------------------------------------------------------------------- + +// Message_SenderKeyDistributionMessage + +// optional string groupId = 1; +inline bool Message_SenderKeyDistributionMessage::_internal_has_groupid() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_SenderKeyDistributionMessage::has_groupid() const { + return _internal_has_groupid(); +} +inline void Message_SenderKeyDistributionMessage::clear_groupid() { + _impl_.groupid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_SenderKeyDistributionMessage::groupid() const { + // @@protoc_insertion_point(field_get:proto.Message.SenderKeyDistributionMessage.groupId) + return _internal_groupid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_SenderKeyDistributionMessage::set_groupid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.groupid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.SenderKeyDistributionMessage.groupId) +} +inline std::string* Message_SenderKeyDistributionMessage::mutable_groupid() { + std::string* _s = _internal_mutable_groupid(); + // @@protoc_insertion_point(field_mutable:proto.Message.SenderKeyDistributionMessage.groupId) + return _s; +} +inline const std::string& Message_SenderKeyDistributionMessage::_internal_groupid() const { + return _impl_.groupid_.Get(); +} +inline void Message_SenderKeyDistributionMessage::_internal_set_groupid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.groupid_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_SenderKeyDistributionMessage::_internal_mutable_groupid() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.groupid_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_SenderKeyDistributionMessage::release_groupid() { + // @@protoc_insertion_point(field_release:proto.Message.SenderKeyDistributionMessage.groupId) + if (!_internal_has_groupid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.groupid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.groupid_.IsDefault()) { + _impl_.groupid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_SenderKeyDistributionMessage::set_allocated_groupid(std::string* groupid) { + if (groupid != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.groupid_.SetAllocated(groupid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.groupid_.IsDefault()) { + _impl_.groupid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.SenderKeyDistributionMessage.groupId) +} + +// optional bytes axolotlSenderKeyDistributionMessage = 2; +inline bool Message_SenderKeyDistributionMessage::_internal_has_axolotlsenderkeydistributionmessage() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_SenderKeyDistributionMessage::has_axolotlsenderkeydistributionmessage() const { + return _internal_has_axolotlsenderkeydistributionmessage(); +} +inline void Message_SenderKeyDistributionMessage::clear_axolotlsenderkeydistributionmessage() { + _impl_.axolotlsenderkeydistributionmessage_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_SenderKeyDistributionMessage::axolotlsenderkeydistributionmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.SenderKeyDistributionMessage.axolotlSenderKeyDistributionMessage) + return _internal_axolotlsenderkeydistributionmessage(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_SenderKeyDistributionMessage::set_axolotlsenderkeydistributionmessage(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.axolotlsenderkeydistributionmessage_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.SenderKeyDistributionMessage.axolotlSenderKeyDistributionMessage) +} +inline std::string* Message_SenderKeyDistributionMessage::mutable_axolotlsenderkeydistributionmessage() { + std::string* _s = _internal_mutable_axolotlsenderkeydistributionmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.SenderKeyDistributionMessage.axolotlSenderKeyDistributionMessage) + return _s; +} +inline const std::string& Message_SenderKeyDistributionMessage::_internal_axolotlsenderkeydistributionmessage() const { + return _impl_.axolotlsenderkeydistributionmessage_.Get(); +} +inline void Message_SenderKeyDistributionMessage::_internal_set_axolotlsenderkeydistributionmessage(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.axolotlsenderkeydistributionmessage_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_SenderKeyDistributionMessage::_internal_mutable_axolotlsenderkeydistributionmessage() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.axolotlsenderkeydistributionmessage_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_SenderKeyDistributionMessage::release_axolotlsenderkeydistributionmessage() { + // @@protoc_insertion_point(field_release:proto.Message.SenderKeyDistributionMessage.axolotlSenderKeyDistributionMessage) + if (!_internal_has_axolotlsenderkeydistributionmessage()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.axolotlsenderkeydistributionmessage_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.axolotlsenderkeydistributionmessage_.IsDefault()) { + _impl_.axolotlsenderkeydistributionmessage_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_SenderKeyDistributionMessage::set_allocated_axolotlsenderkeydistributionmessage(std::string* axolotlsenderkeydistributionmessage) { + if (axolotlsenderkeydistributionmessage != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.axolotlsenderkeydistributionmessage_.SetAllocated(axolotlsenderkeydistributionmessage, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.axolotlsenderkeydistributionmessage_.IsDefault()) { + _impl_.axolotlsenderkeydistributionmessage_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.SenderKeyDistributionMessage.axolotlSenderKeyDistributionMessage) +} + +// ------------------------------------------------------------------- + +// Message_StickerMessage + +// optional string url = 1; +inline bool Message_StickerMessage::_internal_has_url() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_StickerMessage::has_url() const { + return _internal_has_url(); +} +inline void Message_StickerMessage::clear_url() { + _impl_.url_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_StickerMessage::url() const { + // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.url) + return _internal_url(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_StickerMessage::set_url(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.url_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.url) +} +inline std::string* Message_StickerMessage::mutable_url() { + std::string* _s = _internal_mutable_url(); + // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.url) + return _s; +} +inline const std::string& Message_StickerMessage::_internal_url() const { + return _impl_.url_.Get(); +} +inline void Message_StickerMessage::_internal_set_url(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.url_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_StickerMessage::_internal_mutable_url() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.url_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_StickerMessage::release_url() { + // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.url) + if (!_internal_has_url()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.url_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.url_.IsDefault()) { + _impl_.url_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_StickerMessage::set_allocated_url(std::string* url) { + if (url != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.url_.SetAllocated(url, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.url_.IsDefault()) { + _impl_.url_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.url) +} + +// optional bytes fileSha256 = 2; +inline bool Message_StickerMessage::_internal_has_filesha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_StickerMessage::has_filesha256() const { + return _internal_has_filesha256(); +} +inline void Message_StickerMessage::clear_filesha256() { + _impl_.filesha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_StickerMessage::filesha256() const { + // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.fileSha256) + return _internal_filesha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_StickerMessage::set_filesha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.filesha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.fileSha256) +} +inline std::string* Message_StickerMessage::mutable_filesha256() { + std::string* _s = _internal_mutable_filesha256(); + // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.fileSha256) + return _s; +} +inline const std::string& Message_StickerMessage::_internal_filesha256() const { + return _impl_.filesha256_.Get(); +} +inline void Message_StickerMessage::_internal_set_filesha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.filesha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_StickerMessage::_internal_mutable_filesha256() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.filesha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_StickerMessage::release_filesha256() { + // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.fileSha256) + if (!_internal_has_filesha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.filesha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.filesha256_.IsDefault()) { + _impl_.filesha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_StickerMessage::set_allocated_filesha256(std::string* filesha256) { + if (filesha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.filesha256_.IsDefault()) { + _impl_.filesha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.fileSha256) +} + +// optional bytes fileEncSha256 = 3; +inline bool Message_StickerMessage::_internal_has_fileencsha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Message_StickerMessage::has_fileencsha256() const { + return _internal_has_fileencsha256(); +} +inline void Message_StickerMessage::clear_fileencsha256() { + _impl_.fileencsha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& Message_StickerMessage::fileencsha256() const { + // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.fileEncSha256) + return _internal_fileencsha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_StickerMessage::set_fileencsha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.fileencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.fileEncSha256) +} +inline std::string* Message_StickerMessage::mutable_fileencsha256() { + std::string* _s = _internal_mutable_fileencsha256(); + // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.fileEncSha256) + return _s; +} +inline const std::string& Message_StickerMessage::_internal_fileencsha256() const { + return _impl_.fileencsha256_.Get(); +} +inline void Message_StickerMessage::_internal_set_fileencsha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.fileencsha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_StickerMessage::_internal_mutable_fileencsha256() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.fileencsha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_StickerMessage::release_fileencsha256() { + // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.fileEncSha256) + if (!_internal_has_fileencsha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.fileencsha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fileencsha256_.IsDefault()) { + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_StickerMessage::set_allocated_fileencsha256(std::string* fileencsha256) { + if (fileencsha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fileencsha256_.IsDefault()) { + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.fileEncSha256) +} + +// optional bytes mediaKey = 4; +inline bool Message_StickerMessage::_internal_has_mediakey() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool Message_StickerMessage::has_mediakey() const { + return _internal_has_mediakey(); +} +inline void Message_StickerMessage::clear_mediakey() { + _impl_.mediakey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const std::string& Message_StickerMessage::mediakey() const { + // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.mediaKey) + return _internal_mediakey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_StickerMessage::set_mediakey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.mediakey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.mediaKey) +} +inline std::string* Message_StickerMessage::mutable_mediakey() { + std::string* _s = _internal_mutable_mediakey(); + // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.mediaKey) + return _s; +} +inline const std::string& Message_StickerMessage::_internal_mediakey() const { + return _impl_.mediakey_.Get(); +} +inline void Message_StickerMessage::_internal_set_mediakey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.mediakey_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_StickerMessage::_internal_mutable_mediakey() { + _impl_._has_bits_[0] |= 0x00000008u; + return _impl_.mediakey_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_StickerMessage::release_mediakey() { + // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.mediaKey) + if (!_internal_has_mediakey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000008u; + auto* p = _impl_.mediakey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mediakey_.IsDefault()) { + _impl_.mediakey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_StickerMessage::set_allocated_mediakey(std::string* mediakey) { + if (mediakey != nullptr) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mediakey_.IsDefault()) { + _impl_.mediakey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.mediaKey) +} + +// optional string mimetype = 5; +inline bool Message_StickerMessage::_internal_has_mimetype() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool Message_StickerMessage::has_mimetype() const { + return _internal_has_mimetype(); +} +inline void Message_StickerMessage::clear_mimetype() { + _impl_.mimetype_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const std::string& Message_StickerMessage::mimetype() const { + // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.mimetype) + return _internal_mimetype(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_StickerMessage::set_mimetype(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.mimetype_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.mimetype) +} +inline std::string* Message_StickerMessage::mutable_mimetype() { + std::string* _s = _internal_mutable_mimetype(); + // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.mimetype) + return _s; +} +inline const std::string& Message_StickerMessage::_internal_mimetype() const { + return _impl_.mimetype_.Get(); +} +inline void Message_StickerMessage::_internal_set_mimetype(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.mimetype_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_StickerMessage::_internal_mutable_mimetype() { + _impl_._has_bits_[0] |= 0x00000010u; + return _impl_.mimetype_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_StickerMessage::release_mimetype() { + // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.mimetype) + if (!_internal_has_mimetype()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000010u; + auto* p = _impl_.mimetype_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mimetype_.IsDefault()) { + _impl_.mimetype_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_StickerMessage::set_allocated_mimetype(std::string* mimetype) { + if (mimetype != nullptr) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mimetype_.IsDefault()) { + _impl_.mimetype_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.mimetype) +} + +// optional uint32 height = 6; +inline bool Message_StickerMessage::_internal_has_height() const { + bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool Message_StickerMessage::has_height() const { + return _internal_has_height(); +} +inline void Message_StickerMessage::clear_height() { + _impl_.height_ = 0u; + _impl_._has_bits_[0] &= ~0x00000200u; +} +inline uint32_t Message_StickerMessage::_internal_height() const { + return _impl_.height_; +} +inline uint32_t Message_StickerMessage::height() const { + // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.height) + return _internal_height(); +} +inline void Message_StickerMessage::_internal_set_height(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.height_ = value; +} +inline void Message_StickerMessage::set_height(uint32_t value) { + _internal_set_height(value); + // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.height) +} + +// optional uint32 width = 7; +inline bool Message_StickerMessage::_internal_has_width() const { + bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool Message_StickerMessage::has_width() const { + return _internal_has_width(); +} +inline void Message_StickerMessage::clear_width() { + _impl_.width_ = 0u; + _impl_._has_bits_[0] &= ~0x00000400u; +} +inline uint32_t Message_StickerMessage::_internal_width() const { + return _impl_.width_; +} +inline uint32_t Message_StickerMessage::width() const { + // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.width) + return _internal_width(); +} +inline void Message_StickerMessage::_internal_set_width(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000400u; + _impl_.width_ = value; +} +inline void Message_StickerMessage::set_width(uint32_t value) { + _internal_set_width(value); + // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.width) +} + +// optional string directPath = 8; +inline bool Message_StickerMessage::_internal_has_directpath() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool Message_StickerMessage::has_directpath() const { + return _internal_has_directpath(); +} +inline void Message_StickerMessage::clear_directpath() { + _impl_.directpath_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline const std::string& Message_StickerMessage::directpath() const { + // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.directPath) + return _internal_directpath(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_StickerMessage::set_directpath(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.directpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.directPath) +} +inline std::string* Message_StickerMessage::mutable_directpath() { + std::string* _s = _internal_mutable_directpath(); + // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.directPath) + return _s; +} +inline const std::string& Message_StickerMessage::_internal_directpath() const { + return _impl_.directpath_.Get(); +} +inline void Message_StickerMessage::_internal_set_directpath(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.directpath_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_StickerMessage::_internal_mutable_directpath() { + _impl_._has_bits_[0] |= 0x00000020u; + return _impl_.directpath_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_StickerMessage::release_directpath() { + // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.directPath) + if (!_internal_has_directpath()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000020u; + auto* p = _impl_.directpath_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.directpath_.IsDefault()) { + _impl_.directpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_StickerMessage::set_allocated_directpath(std::string* directpath) { + if (directpath != nullptr) { + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.directpath_.IsDefault()) { + _impl_.directpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.directPath) +} + +// optional uint64 fileLength = 9; +inline bool Message_StickerMessage::_internal_has_filelength() const { + bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; + return value; +} +inline bool Message_StickerMessage::has_filelength() const { + return _internal_has_filelength(); +} +inline void Message_StickerMessage::clear_filelength() { + _impl_.filelength_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000800u; +} +inline uint64_t Message_StickerMessage::_internal_filelength() const { + return _impl_.filelength_; +} +inline uint64_t Message_StickerMessage::filelength() const { + // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.fileLength) + return _internal_filelength(); +} +inline void Message_StickerMessage::_internal_set_filelength(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000800u; + _impl_.filelength_ = value; +} +inline void Message_StickerMessage::set_filelength(uint64_t value) { + _internal_set_filelength(value); + // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.fileLength) +} + +// optional int64 mediaKeyTimestamp = 10; +inline bool Message_StickerMessage::_internal_has_mediakeytimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; + return value; +} +inline bool Message_StickerMessage::has_mediakeytimestamp() const { + return _internal_has_mediakeytimestamp(); +} +inline void Message_StickerMessage::clear_mediakeytimestamp() { + _impl_.mediakeytimestamp_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00001000u; +} +inline int64_t Message_StickerMessage::_internal_mediakeytimestamp() const { + return _impl_.mediakeytimestamp_; +} +inline int64_t Message_StickerMessage::mediakeytimestamp() const { + // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.mediaKeyTimestamp) + return _internal_mediakeytimestamp(); +} +inline void Message_StickerMessage::_internal_set_mediakeytimestamp(int64_t value) { + _impl_._has_bits_[0] |= 0x00001000u; + _impl_.mediakeytimestamp_ = value; +} +inline void Message_StickerMessage::set_mediakeytimestamp(int64_t value) { + _internal_set_mediakeytimestamp(value); + // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.mediaKeyTimestamp) +} + +// optional uint32 firstFrameLength = 11; +inline bool Message_StickerMessage::_internal_has_firstframelength() const { + bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0; + return value; +} +inline bool Message_StickerMessage::has_firstframelength() const { + return _internal_has_firstframelength(); +} +inline void Message_StickerMessage::clear_firstframelength() { + _impl_.firstframelength_ = 0u; + _impl_._has_bits_[0] &= ~0x00002000u; +} +inline uint32_t Message_StickerMessage::_internal_firstframelength() const { + return _impl_.firstframelength_; +} +inline uint32_t Message_StickerMessage::firstframelength() const { + // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.firstFrameLength) + return _internal_firstframelength(); +} +inline void Message_StickerMessage::_internal_set_firstframelength(uint32_t value) { + _impl_._has_bits_[0] |= 0x00002000u; + _impl_.firstframelength_ = value; +} +inline void Message_StickerMessage::set_firstframelength(uint32_t value) { + _internal_set_firstframelength(value); + // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.firstFrameLength) +} + +// optional bytes firstFrameSidecar = 12; +inline bool Message_StickerMessage::_internal_has_firstframesidecar() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool Message_StickerMessage::has_firstframesidecar() const { + return _internal_has_firstframesidecar(); +} +inline void Message_StickerMessage::clear_firstframesidecar() { + _impl_.firstframesidecar_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline const std::string& Message_StickerMessage::firstframesidecar() const { + // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.firstFrameSidecar) + return _internal_firstframesidecar(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_StickerMessage::set_firstframesidecar(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.firstframesidecar_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.firstFrameSidecar) +} +inline std::string* Message_StickerMessage::mutable_firstframesidecar() { + std::string* _s = _internal_mutable_firstframesidecar(); + // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.firstFrameSidecar) + return _s; +} +inline const std::string& Message_StickerMessage::_internal_firstframesidecar() const { + return _impl_.firstframesidecar_.Get(); +} +inline void Message_StickerMessage::_internal_set_firstframesidecar(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.firstframesidecar_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_StickerMessage::_internal_mutable_firstframesidecar() { + _impl_._has_bits_[0] |= 0x00000040u; + return _impl_.firstframesidecar_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_StickerMessage::release_firstframesidecar() { + // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.firstFrameSidecar) + if (!_internal_has_firstframesidecar()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000040u; + auto* p = _impl_.firstframesidecar_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.firstframesidecar_.IsDefault()) { + _impl_.firstframesidecar_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_StickerMessage::set_allocated_firstframesidecar(std::string* firstframesidecar) { + if (firstframesidecar != nullptr) { + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + _impl_.firstframesidecar_.SetAllocated(firstframesidecar, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.firstframesidecar_.IsDefault()) { + _impl_.firstframesidecar_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.firstFrameSidecar) +} + +// optional bool isAnimated = 13; +inline bool Message_StickerMessage::_internal_has_isanimated() const { + bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0; + return value; +} +inline bool Message_StickerMessage::has_isanimated() const { + return _internal_has_isanimated(); +} +inline void Message_StickerMessage::clear_isanimated() { + _impl_.isanimated_ = false; + _impl_._has_bits_[0] &= ~0x00004000u; +} +inline bool Message_StickerMessage::_internal_isanimated() const { + return _impl_.isanimated_; +} +inline bool Message_StickerMessage::isanimated() const { + // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.isAnimated) + return _internal_isanimated(); +} +inline void Message_StickerMessage::_internal_set_isanimated(bool value) { + _impl_._has_bits_[0] |= 0x00004000u; + _impl_.isanimated_ = value; +} +inline void Message_StickerMessage::set_isanimated(bool value) { + _internal_set_isanimated(value); + // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.isAnimated) +} + +// optional bytes pngThumbnail = 16; +inline bool Message_StickerMessage::_internal_has_pngthumbnail() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool Message_StickerMessage::has_pngthumbnail() const { + return _internal_has_pngthumbnail(); +} +inline void Message_StickerMessage::clear_pngthumbnail() { + _impl_.pngthumbnail_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline const std::string& Message_StickerMessage::pngthumbnail() const { + // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.pngThumbnail) + return _internal_pngthumbnail(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_StickerMessage::set_pngthumbnail(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.pngthumbnail_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.pngThumbnail) +} +inline std::string* Message_StickerMessage::mutable_pngthumbnail() { + std::string* _s = _internal_mutable_pngthumbnail(); + // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.pngThumbnail) + return _s; +} +inline const std::string& Message_StickerMessage::_internal_pngthumbnail() const { + return _impl_.pngthumbnail_.Get(); +} +inline void Message_StickerMessage::_internal_set_pngthumbnail(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.pngthumbnail_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_StickerMessage::_internal_mutable_pngthumbnail() { + _impl_._has_bits_[0] |= 0x00000080u; + return _impl_.pngthumbnail_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_StickerMessage::release_pngthumbnail() { + // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.pngThumbnail) + if (!_internal_has_pngthumbnail()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000080u; + auto* p = _impl_.pngthumbnail_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.pngthumbnail_.IsDefault()) { + _impl_.pngthumbnail_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_StickerMessage::set_allocated_pngthumbnail(std::string* pngthumbnail) { + if (pngthumbnail != nullptr) { + _impl_._has_bits_[0] |= 0x00000080u; + } else { + _impl_._has_bits_[0] &= ~0x00000080u; + } + _impl_.pngthumbnail_.SetAllocated(pngthumbnail, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.pngthumbnail_.IsDefault()) { + _impl_.pngthumbnail_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.pngThumbnail) +} + +// optional .proto.ContextInfo contextInfo = 17; +inline bool Message_StickerMessage::_internal_has_contextinfo() const { + bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; + PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); + return value; +} +inline bool Message_StickerMessage::has_contextinfo() const { + return _internal_has_contextinfo(); +} +inline void Message_StickerMessage::clear_contextinfo() { + if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); + _impl_._has_bits_[0] &= ~0x00000100u; +} +inline const ::proto::ContextInfo& Message_StickerMessage::_internal_contextinfo() const { + const ::proto::ContextInfo* p = _impl_.contextinfo_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ContextInfo_default_instance_); +} +inline const ::proto::ContextInfo& Message_StickerMessage::contextinfo() const { + // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.contextInfo) + return _internal_contextinfo(); +} +inline void Message_StickerMessage::unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); + } + _impl_.contextinfo_ = contextinfo; + if (contextinfo) { + _impl_._has_bits_[0] |= 0x00000100u; + } else { + _impl_._has_bits_[0] &= ~0x00000100u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.StickerMessage.contextInfo) +} +inline ::proto::ContextInfo* Message_StickerMessage::release_contextinfo() { + _impl_._has_bits_[0] &= ~0x00000100u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ContextInfo* Message_StickerMessage::unsafe_arena_release_contextinfo() { + // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.contextInfo) + _impl_._has_bits_[0] &= ~0x00000100u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; + return temp; +} +inline ::proto::ContextInfo* Message_StickerMessage::_internal_mutable_contextinfo() { + _impl_._has_bits_[0] |= 0x00000100u; + if (_impl_.contextinfo_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); + _impl_.contextinfo_ = p; + } + return _impl_.contextinfo_; +} +inline ::proto::ContextInfo* Message_StickerMessage::mutable_contextinfo() { + ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); + // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.contextInfo) + return _msg; +} +inline void Message_StickerMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.contextinfo_; + } + if (contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); + if (message_arena != submessage_arena) { + contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, contextinfo, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000100u; + } else { + _impl_._has_bits_[0] &= ~0x00000100u; + } + _impl_.contextinfo_ = contextinfo; + // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.contextInfo) +} + +// ------------------------------------------------------------------- + +// Message_StickerSyncRMRMessage + +// repeated string filehash = 1; +inline int Message_StickerSyncRMRMessage::_internal_filehash_size() const { + return _impl_.filehash_.size(); +} +inline int Message_StickerSyncRMRMessage::filehash_size() const { + return _internal_filehash_size(); +} +inline void Message_StickerSyncRMRMessage::clear_filehash() { + _impl_.filehash_.Clear(); +} +inline std::string* Message_StickerSyncRMRMessage::add_filehash() { + std::string* _s = _internal_add_filehash(); + // @@protoc_insertion_point(field_add_mutable:proto.Message.StickerSyncRMRMessage.filehash) + return _s; +} +inline const std::string& Message_StickerSyncRMRMessage::_internal_filehash(int index) const { + return _impl_.filehash_.Get(index); +} +inline const std::string& Message_StickerSyncRMRMessage::filehash(int index) const { + // @@protoc_insertion_point(field_get:proto.Message.StickerSyncRMRMessage.filehash) + return _internal_filehash(index); +} +inline std::string* Message_StickerSyncRMRMessage::mutable_filehash(int index) { + // @@protoc_insertion_point(field_mutable:proto.Message.StickerSyncRMRMessage.filehash) + return _impl_.filehash_.Mutable(index); +} +inline void Message_StickerSyncRMRMessage::set_filehash(int index, const std::string& value) { + _impl_.filehash_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:proto.Message.StickerSyncRMRMessage.filehash) +} +inline void Message_StickerSyncRMRMessage::set_filehash(int index, std::string&& value) { + _impl_.filehash_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:proto.Message.StickerSyncRMRMessage.filehash) +} +inline void Message_StickerSyncRMRMessage::set_filehash(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + _impl_.filehash_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:proto.Message.StickerSyncRMRMessage.filehash) +} +inline void Message_StickerSyncRMRMessage::set_filehash(int index, const char* value, size_t size) { + _impl_.filehash_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:proto.Message.StickerSyncRMRMessage.filehash) +} +inline std::string* Message_StickerSyncRMRMessage::_internal_add_filehash() { + return _impl_.filehash_.Add(); +} +inline void Message_StickerSyncRMRMessage::add_filehash(const std::string& value) { + _impl_.filehash_.Add()->assign(value); + // @@protoc_insertion_point(field_add:proto.Message.StickerSyncRMRMessage.filehash) +} +inline void Message_StickerSyncRMRMessage::add_filehash(std::string&& value) { + _impl_.filehash_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:proto.Message.StickerSyncRMRMessage.filehash) +} +inline void Message_StickerSyncRMRMessage::add_filehash(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _impl_.filehash_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:proto.Message.StickerSyncRMRMessage.filehash) +} +inline void Message_StickerSyncRMRMessage::add_filehash(const char* value, size_t size) { + _impl_.filehash_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:proto.Message.StickerSyncRMRMessage.filehash) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +Message_StickerSyncRMRMessage::filehash() const { + // @@protoc_insertion_point(field_list:proto.Message.StickerSyncRMRMessage.filehash) + return _impl_.filehash_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +Message_StickerSyncRMRMessage::mutable_filehash() { + // @@protoc_insertion_point(field_mutable_list:proto.Message.StickerSyncRMRMessage.filehash) + return &_impl_.filehash_; +} + +// optional string rmrSource = 2; +inline bool Message_StickerSyncRMRMessage::_internal_has_rmrsource() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_StickerSyncRMRMessage::has_rmrsource() const { + return _internal_has_rmrsource(); +} +inline void Message_StickerSyncRMRMessage::clear_rmrsource() { + _impl_.rmrsource_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_StickerSyncRMRMessage::rmrsource() const { + // @@protoc_insertion_point(field_get:proto.Message.StickerSyncRMRMessage.rmrSource) + return _internal_rmrsource(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_StickerSyncRMRMessage::set_rmrsource(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.rmrsource_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.StickerSyncRMRMessage.rmrSource) +} +inline std::string* Message_StickerSyncRMRMessage::mutable_rmrsource() { + std::string* _s = _internal_mutable_rmrsource(); + // @@protoc_insertion_point(field_mutable:proto.Message.StickerSyncRMRMessage.rmrSource) + return _s; +} +inline const std::string& Message_StickerSyncRMRMessage::_internal_rmrsource() const { + return _impl_.rmrsource_.Get(); +} +inline void Message_StickerSyncRMRMessage::_internal_set_rmrsource(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.rmrsource_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_StickerSyncRMRMessage::_internal_mutable_rmrsource() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.rmrsource_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_StickerSyncRMRMessage::release_rmrsource() { + // @@protoc_insertion_point(field_release:proto.Message.StickerSyncRMRMessage.rmrSource) + if (!_internal_has_rmrsource()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.rmrsource_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.rmrsource_.IsDefault()) { + _impl_.rmrsource_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_StickerSyncRMRMessage::set_allocated_rmrsource(std::string* rmrsource) { + if (rmrsource != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.rmrsource_.SetAllocated(rmrsource, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.rmrsource_.IsDefault()) { + _impl_.rmrsource_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerSyncRMRMessage.rmrSource) +} + +// optional int64 requestTimestamp = 3; +inline bool Message_StickerSyncRMRMessage::_internal_has_requesttimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_StickerSyncRMRMessage::has_requesttimestamp() const { + return _internal_has_requesttimestamp(); +} +inline void Message_StickerSyncRMRMessage::clear_requesttimestamp() { + _impl_.requesttimestamp_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline int64_t Message_StickerSyncRMRMessage::_internal_requesttimestamp() const { + return _impl_.requesttimestamp_; +} +inline int64_t Message_StickerSyncRMRMessage::requesttimestamp() const { + // @@protoc_insertion_point(field_get:proto.Message.StickerSyncRMRMessage.requestTimestamp) + return _internal_requesttimestamp(); +} +inline void Message_StickerSyncRMRMessage::_internal_set_requesttimestamp(int64_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.requesttimestamp_ = value; +} +inline void Message_StickerSyncRMRMessage::set_requesttimestamp(int64_t value) { + _internal_set_requesttimestamp(value); + // @@protoc_insertion_point(field_set:proto.Message.StickerSyncRMRMessage.requestTimestamp) +} + +// ------------------------------------------------------------------- + +// Message_TemplateButtonReplyMessage + +// optional string selectedId = 1; +inline bool Message_TemplateButtonReplyMessage::_internal_has_selectedid() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_TemplateButtonReplyMessage::has_selectedid() const { + return _internal_has_selectedid(); +} +inline void Message_TemplateButtonReplyMessage::clear_selectedid() { + _impl_.selectedid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_TemplateButtonReplyMessage::selectedid() const { + // @@protoc_insertion_point(field_get:proto.Message.TemplateButtonReplyMessage.selectedId) + return _internal_selectedid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_TemplateButtonReplyMessage::set_selectedid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.selectedid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.TemplateButtonReplyMessage.selectedId) +} +inline std::string* Message_TemplateButtonReplyMessage::mutable_selectedid() { + std::string* _s = _internal_mutable_selectedid(); + // @@protoc_insertion_point(field_mutable:proto.Message.TemplateButtonReplyMessage.selectedId) + return _s; +} +inline const std::string& Message_TemplateButtonReplyMessage::_internal_selectedid() const { + return _impl_.selectedid_.Get(); +} +inline void Message_TemplateButtonReplyMessage::_internal_set_selectedid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.selectedid_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_TemplateButtonReplyMessage::_internal_mutable_selectedid() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.selectedid_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_TemplateButtonReplyMessage::release_selectedid() { + // @@protoc_insertion_point(field_release:proto.Message.TemplateButtonReplyMessage.selectedId) + if (!_internal_has_selectedid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.selectedid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.selectedid_.IsDefault()) { + _impl_.selectedid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_TemplateButtonReplyMessage::set_allocated_selectedid(std::string* selectedid) { + if (selectedid != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.selectedid_.SetAllocated(selectedid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.selectedid_.IsDefault()) { + _impl_.selectedid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateButtonReplyMessage.selectedId) +} + +// optional string selectedDisplayText = 2; +inline bool Message_TemplateButtonReplyMessage::_internal_has_selecteddisplaytext() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_TemplateButtonReplyMessage::has_selecteddisplaytext() const { + return _internal_has_selecteddisplaytext(); +} +inline void Message_TemplateButtonReplyMessage::clear_selecteddisplaytext() { + _impl_.selecteddisplaytext_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_TemplateButtonReplyMessage::selecteddisplaytext() const { + // @@protoc_insertion_point(field_get:proto.Message.TemplateButtonReplyMessage.selectedDisplayText) + return _internal_selecteddisplaytext(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_TemplateButtonReplyMessage::set_selecteddisplaytext(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.selecteddisplaytext_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.TemplateButtonReplyMessage.selectedDisplayText) +} +inline std::string* Message_TemplateButtonReplyMessage::mutable_selecteddisplaytext() { + std::string* _s = _internal_mutable_selecteddisplaytext(); + // @@protoc_insertion_point(field_mutable:proto.Message.TemplateButtonReplyMessage.selectedDisplayText) + return _s; +} +inline const std::string& Message_TemplateButtonReplyMessage::_internal_selecteddisplaytext() const { + return _impl_.selecteddisplaytext_.Get(); +} +inline void Message_TemplateButtonReplyMessage::_internal_set_selecteddisplaytext(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.selecteddisplaytext_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_TemplateButtonReplyMessage::_internal_mutable_selecteddisplaytext() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.selecteddisplaytext_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_TemplateButtonReplyMessage::release_selecteddisplaytext() { + // @@protoc_insertion_point(field_release:proto.Message.TemplateButtonReplyMessage.selectedDisplayText) + if (!_internal_has_selecteddisplaytext()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.selecteddisplaytext_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.selecteddisplaytext_.IsDefault()) { + _impl_.selecteddisplaytext_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_TemplateButtonReplyMessage::set_allocated_selecteddisplaytext(std::string* selecteddisplaytext) { + if (selecteddisplaytext != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.selecteddisplaytext_.SetAllocated(selecteddisplaytext, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.selecteddisplaytext_.IsDefault()) { + _impl_.selecteddisplaytext_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateButtonReplyMessage.selectedDisplayText) +} + +// optional .proto.ContextInfo contextInfo = 3; +inline bool Message_TemplateButtonReplyMessage::_internal_has_contextinfo() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); + return value; +} +inline bool Message_TemplateButtonReplyMessage::has_contextinfo() const { + return _internal_has_contextinfo(); +} +inline void Message_TemplateButtonReplyMessage::clear_contextinfo() { + if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::proto::ContextInfo& Message_TemplateButtonReplyMessage::_internal_contextinfo() const { + const ::proto::ContextInfo* p = _impl_.contextinfo_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ContextInfo_default_instance_); +} +inline const ::proto::ContextInfo& Message_TemplateButtonReplyMessage::contextinfo() const { + // @@protoc_insertion_point(field_get:proto.Message.TemplateButtonReplyMessage.contextInfo) + return _internal_contextinfo(); +} +inline void Message_TemplateButtonReplyMessage::unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); + } + _impl_.contextinfo_ = contextinfo; + if (contextinfo) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateButtonReplyMessage.contextInfo) +} +inline ::proto::ContextInfo* Message_TemplateButtonReplyMessage::release_contextinfo() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ContextInfo* Message_TemplateButtonReplyMessage::unsafe_arena_release_contextinfo() { + // @@protoc_insertion_point(field_release:proto.Message.TemplateButtonReplyMessage.contextInfo) + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; + return temp; +} +inline ::proto::ContextInfo* Message_TemplateButtonReplyMessage::_internal_mutable_contextinfo() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.contextinfo_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); + _impl_.contextinfo_ = p; + } + return _impl_.contextinfo_; +} +inline ::proto::ContextInfo* Message_TemplateButtonReplyMessage::mutable_contextinfo() { + ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); + // @@protoc_insertion_point(field_mutable:proto.Message.TemplateButtonReplyMessage.contextInfo) + return _msg; +} +inline void Message_TemplateButtonReplyMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.contextinfo_; + } + if (contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); + if (message_arena != submessage_arena) { + contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, contextinfo, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.contextinfo_ = contextinfo; + // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateButtonReplyMessage.contextInfo) +} + +// optional uint32 selectedIndex = 4; +inline bool Message_TemplateButtonReplyMessage::_internal_has_selectedindex() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool Message_TemplateButtonReplyMessage::has_selectedindex() const { + return _internal_has_selectedindex(); +} +inline void Message_TemplateButtonReplyMessage::clear_selectedindex() { + _impl_.selectedindex_ = 0u; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline uint32_t Message_TemplateButtonReplyMessage::_internal_selectedindex() const { + return _impl_.selectedindex_; +} +inline uint32_t Message_TemplateButtonReplyMessage::selectedindex() const { + // @@protoc_insertion_point(field_get:proto.Message.TemplateButtonReplyMessage.selectedIndex) + return _internal_selectedindex(); +} +inline void Message_TemplateButtonReplyMessage::_internal_set_selectedindex(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.selectedindex_ = value; +} +inline void Message_TemplateButtonReplyMessage::set_selectedindex(uint32_t value) { + _internal_set_selectedindex(value); + // @@protoc_insertion_point(field_set:proto.Message.TemplateButtonReplyMessage.selectedIndex) +} + +// ------------------------------------------------------------------- + +// Message_TemplateMessage_FourRowTemplate + +// optional .proto.Message.HighlyStructuredMessage content = 6; +inline bool Message_TemplateMessage_FourRowTemplate::_internal_has_content() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.content_ != nullptr); + return value; +} +inline bool Message_TemplateMessage_FourRowTemplate::has_content() const { + return _internal_has_content(); +} +inline void Message_TemplateMessage_FourRowTemplate::clear_content() { + if (_impl_.content_ != nullptr) _impl_.content_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::Message_HighlyStructuredMessage& Message_TemplateMessage_FourRowTemplate::_internal_content() const { + const ::proto::Message_HighlyStructuredMessage* p = _impl_.content_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_HighlyStructuredMessage_default_instance_); +} +inline const ::proto::Message_HighlyStructuredMessage& Message_TemplateMessage_FourRowTemplate::content() const { + // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.content) + return _internal_content(); +} +inline void Message_TemplateMessage_FourRowTemplate::unsafe_arena_set_allocated_content( + ::proto::Message_HighlyStructuredMessage* content) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.content_); + } + _impl_.content_ = content; + if (content) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.content) +} +inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::release_content() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::Message_HighlyStructuredMessage* temp = _impl_.content_; + _impl_.content_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::unsafe_arena_release_content() { + // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.FourRowTemplate.content) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::Message_HighlyStructuredMessage* temp = _impl_.content_; + _impl_.content_ = nullptr; + return temp; +} +inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::_internal_mutable_content() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.content_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation()); + _impl_.content_ = p; + } + return _impl_.content_; +} +inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::mutable_content() { + ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_content(); + // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.content) + return _msg; +} +inline void Message_TemplateMessage_FourRowTemplate::set_allocated_content(::proto::Message_HighlyStructuredMessage* content) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.content_; + } + if (content) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(content); + if (message_arena != submessage_arena) { + content = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, content, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.content_ = content; + // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.content) +} + +// optional .proto.Message.HighlyStructuredMessage footer = 7; +inline bool Message_TemplateMessage_FourRowTemplate::_internal_has_footer() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.footer_ != nullptr); + return value; +} +inline bool Message_TemplateMessage_FourRowTemplate::has_footer() const { + return _internal_has_footer(); +} +inline void Message_TemplateMessage_FourRowTemplate::clear_footer() { + if (_impl_.footer_ != nullptr) _impl_.footer_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::Message_HighlyStructuredMessage& Message_TemplateMessage_FourRowTemplate::_internal_footer() const { + const ::proto::Message_HighlyStructuredMessage* p = _impl_.footer_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_HighlyStructuredMessage_default_instance_); +} +inline const ::proto::Message_HighlyStructuredMessage& Message_TemplateMessage_FourRowTemplate::footer() const { + // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.footer) + return _internal_footer(); +} +inline void Message_TemplateMessage_FourRowTemplate::unsafe_arena_set_allocated_footer( + ::proto::Message_HighlyStructuredMessage* footer) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.footer_); + } + _impl_.footer_ = footer; + if (footer) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.footer) +} +inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::release_footer() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::Message_HighlyStructuredMessage* temp = _impl_.footer_; + _impl_.footer_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::unsafe_arena_release_footer() { + // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.FourRowTemplate.footer) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::Message_HighlyStructuredMessage* temp = _impl_.footer_; + _impl_.footer_ = nullptr; + return temp; +} +inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::_internal_mutable_footer() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.footer_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation()); + _impl_.footer_ = p; + } + return _impl_.footer_; +} +inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::mutable_footer() { + ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_footer(); + // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.footer) + return _msg; +} +inline void Message_TemplateMessage_FourRowTemplate::set_allocated_footer(::proto::Message_HighlyStructuredMessage* footer) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.footer_; + } + if (footer) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(footer); + if (message_arena != submessage_arena) { + footer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, footer, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.footer_ = footer; + // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.footer) +} + +// repeated .proto.TemplateButton buttons = 8; +inline int Message_TemplateMessage_FourRowTemplate::_internal_buttons_size() const { + return _impl_.buttons_.size(); +} +inline int Message_TemplateMessage_FourRowTemplate::buttons_size() const { + return _internal_buttons_size(); +} +inline void Message_TemplateMessage_FourRowTemplate::clear_buttons() { + _impl_.buttons_.Clear(); +} +inline ::proto::TemplateButton* Message_TemplateMessage_FourRowTemplate::mutable_buttons(int index) { + // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.buttons) + return _impl_.buttons_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::TemplateButton >* +Message_TemplateMessage_FourRowTemplate::mutable_buttons() { + // @@protoc_insertion_point(field_mutable_list:proto.Message.TemplateMessage.FourRowTemplate.buttons) + return &_impl_.buttons_; +} +inline const ::proto::TemplateButton& Message_TemplateMessage_FourRowTemplate::_internal_buttons(int index) const { + return _impl_.buttons_.Get(index); +} +inline const ::proto::TemplateButton& Message_TemplateMessage_FourRowTemplate::buttons(int index) const { + // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.buttons) + return _internal_buttons(index); +} +inline ::proto::TemplateButton* Message_TemplateMessage_FourRowTemplate::_internal_add_buttons() { + return _impl_.buttons_.Add(); +} +inline ::proto::TemplateButton* Message_TemplateMessage_FourRowTemplate::add_buttons() { + ::proto::TemplateButton* _add = _internal_add_buttons(); + // @@protoc_insertion_point(field_add:proto.Message.TemplateMessage.FourRowTemplate.buttons) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::TemplateButton >& +Message_TemplateMessage_FourRowTemplate::buttons() const { + // @@protoc_insertion_point(field_list:proto.Message.TemplateMessage.FourRowTemplate.buttons) + return _impl_.buttons_; +} + +// .proto.Message.DocumentMessage documentMessage = 1; +inline bool Message_TemplateMessage_FourRowTemplate::_internal_has_documentmessage() const { + return title_case() == kDocumentMessage; +} +inline bool Message_TemplateMessage_FourRowTemplate::has_documentmessage() const { + return _internal_has_documentmessage(); +} +inline void Message_TemplateMessage_FourRowTemplate::set_has_documentmessage() { + _impl_._oneof_case_[0] = kDocumentMessage; +} +inline void Message_TemplateMessage_FourRowTemplate::clear_documentmessage() { + if (_internal_has_documentmessage()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.title_.documentmessage_; + } + clear_has_title(); + } +} +inline ::proto::Message_DocumentMessage* Message_TemplateMessage_FourRowTemplate::release_documentmessage() { + // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.FourRowTemplate.documentMessage) + if (_internal_has_documentmessage()) { + clear_has_title(); + ::proto::Message_DocumentMessage* temp = _impl_.title_.documentmessage_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.title_.documentmessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::Message_DocumentMessage& Message_TemplateMessage_FourRowTemplate::_internal_documentmessage() const { + return _internal_has_documentmessage() + ? *_impl_.title_.documentmessage_ + : reinterpret_cast< ::proto::Message_DocumentMessage&>(::proto::_Message_DocumentMessage_default_instance_); +} +inline const ::proto::Message_DocumentMessage& Message_TemplateMessage_FourRowTemplate::documentmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.documentMessage) + return _internal_documentmessage(); +} +inline ::proto::Message_DocumentMessage* Message_TemplateMessage_FourRowTemplate::unsafe_arena_release_documentmessage() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.FourRowTemplate.documentMessage) + if (_internal_has_documentmessage()) { + clear_has_title(); + ::proto::Message_DocumentMessage* temp = _impl_.title_.documentmessage_; + _impl_.title_.documentmessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Message_TemplateMessage_FourRowTemplate::unsafe_arena_set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) { + clear_title(); + if (documentmessage) { + set_has_documentmessage(); + _impl_.title_.documentmessage_ = documentmessage; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.documentMessage) +} +inline ::proto::Message_DocumentMessage* Message_TemplateMessage_FourRowTemplate::_internal_mutable_documentmessage() { + if (!_internal_has_documentmessage()) { + clear_title(); + set_has_documentmessage(); + _impl_.title_.documentmessage_ = CreateMaybeMessage< ::proto::Message_DocumentMessage >(GetArenaForAllocation()); + } + return _impl_.title_.documentmessage_; +} +inline ::proto::Message_DocumentMessage* Message_TemplateMessage_FourRowTemplate::mutable_documentmessage() { + ::proto::Message_DocumentMessage* _msg = _internal_mutable_documentmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.documentMessage) + return _msg; +} + +// .proto.Message.HighlyStructuredMessage highlyStructuredMessage = 2; +inline bool Message_TemplateMessage_FourRowTemplate::_internal_has_highlystructuredmessage() const { + return title_case() == kHighlyStructuredMessage; +} +inline bool Message_TemplateMessage_FourRowTemplate::has_highlystructuredmessage() const { + return _internal_has_highlystructuredmessage(); +} +inline void Message_TemplateMessage_FourRowTemplate::set_has_highlystructuredmessage() { + _impl_._oneof_case_[0] = kHighlyStructuredMessage; +} +inline void Message_TemplateMessage_FourRowTemplate::clear_highlystructuredmessage() { + if (_internal_has_highlystructuredmessage()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.title_.highlystructuredmessage_; + } + clear_has_title(); + } +} +inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::release_highlystructuredmessage() { + // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.FourRowTemplate.highlyStructuredMessage) + if (_internal_has_highlystructuredmessage()) { + clear_has_title(); + ::proto::Message_HighlyStructuredMessage* temp = _impl_.title_.highlystructuredmessage_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.title_.highlystructuredmessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::Message_HighlyStructuredMessage& Message_TemplateMessage_FourRowTemplate::_internal_highlystructuredmessage() const { + return _internal_has_highlystructuredmessage() + ? *_impl_.title_.highlystructuredmessage_ + : reinterpret_cast< ::proto::Message_HighlyStructuredMessage&>(::proto::_Message_HighlyStructuredMessage_default_instance_); +} +inline const ::proto::Message_HighlyStructuredMessage& Message_TemplateMessage_FourRowTemplate::highlystructuredmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.highlyStructuredMessage) + return _internal_highlystructuredmessage(); +} +inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::unsafe_arena_release_highlystructuredmessage() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.FourRowTemplate.highlyStructuredMessage) + if (_internal_has_highlystructuredmessage()) { + clear_has_title(); + ::proto::Message_HighlyStructuredMessage* temp = _impl_.title_.highlystructuredmessage_; + _impl_.title_.highlystructuredmessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Message_TemplateMessage_FourRowTemplate::unsafe_arena_set_allocated_highlystructuredmessage(::proto::Message_HighlyStructuredMessage* highlystructuredmessage) { + clear_title(); + if (highlystructuredmessage) { + set_has_highlystructuredmessage(); + _impl_.title_.highlystructuredmessage_ = highlystructuredmessage; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.highlyStructuredMessage) +} +inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::_internal_mutable_highlystructuredmessage() { + if (!_internal_has_highlystructuredmessage()) { + clear_title(); + set_has_highlystructuredmessage(); + _impl_.title_.highlystructuredmessage_ = CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage >(GetArenaForAllocation()); + } + return _impl_.title_.highlystructuredmessage_; +} +inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::mutable_highlystructuredmessage() { + ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_highlystructuredmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.highlyStructuredMessage) + return _msg; +} + +// .proto.Message.ImageMessage imageMessage = 3; +inline bool Message_TemplateMessage_FourRowTemplate::_internal_has_imagemessage() const { + return title_case() == kImageMessage; +} +inline bool Message_TemplateMessage_FourRowTemplate::has_imagemessage() const { + return _internal_has_imagemessage(); +} +inline void Message_TemplateMessage_FourRowTemplate::set_has_imagemessage() { + _impl_._oneof_case_[0] = kImageMessage; +} +inline void Message_TemplateMessage_FourRowTemplate::clear_imagemessage() { + if (_internal_has_imagemessage()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.title_.imagemessage_; + } + clear_has_title(); + } +} +inline ::proto::Message_ImageMessage* Message_TemplateMessage_FourRowTemplate::release_imagemessage() { + // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.FourRowTemplate.imageMessage) + if (_internal_has_imagemessage()) { + clear_has_title(); + ::proto::Message_ImageMessage* temp = _impl_.title_.imagemessage_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.title_.imagemessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::Message_ImageMessage& Message_TemplateMessage_FourRowTemplate::_internal_imagemessage() const { + return _internal_has_imagemessage() + ? *_impl_.title_.imagemessage_ + : reinterpret_cast< ::proto::Message_ImageMessage&>(::proto::_Message_ImageMessage_default_instance_); +} +inline const ::proto::Message_ImageMessage& Message_TemplateMessage_FourRowTemplate::imagemessage() const { + // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.imageMessage) + return _internal_imagemessage(); +} +inline ::proto::Message_ImageMessage* Message_TemplateMessage_FourRowTemplate::unsafe_arena_release_imagemessage() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.FourRowTemplate.imageMessage) + if (_internal_has_imagemessage()) { + clear_has_title(); + ::proto::Message_ImageMessage* temp = _impl_.title_.imagemessage_; + _impl_.title_.imagemessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Message_TemplateMessage_FourRowTemplate::unsafe_arena_set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) { + clear_title(); + if (imagemessage) { + set_has_imagemessage(); + _impl_.title_.imagemessage_ = imagemessage; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.imageMessage) +} +inline ::proto::Message_ImageMessage* Message_TemplateMessage_FourRowTemplate::_internal_mutable_imagemessage() { + if (!_internal_has_imagemessage()) { + clear_title(); + set_has_imagemessage(); + _impl_.title_.imagemessage_ = CreateMaybeMessage< ::proto::Message_ImageMessage >(GetArenaForAllocation()); + } + return _impl_.title_.imagemessage_; +} +inline ::proto::Message_ImageMessage* Message_TemplateMessage_FourRowTemplate::mutable_imagemessage() { + ::proto::Message_ImageMessage* _msg = _internal_mutable_imagemessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.imageMessage) + return _msg; +} + +// .proto.Message.VideoMessage videoMessage = 4; +inline bool Message_TemplateMessage_FourRowTemplate::_internal_has_videomessage() const { + return title_case() == kVideoMessage; +} +inline bool Message_TemplateMessage_FourRowTemplate::has_videomessage() const { + return _internal_has_videomessage(); +} +inline void Message_TemplateMessage_FourRowTemplate::set_has_videomessage() { + _impl_._oneof_case_[0] = kVideoMessage; +} +inline void Message_TemplateMessage_FourRowTemplate::clear_videomessage() { + if (_internal_has_videomessage()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.title_.videomessage_; + } + clear_has_title(); + } +} +inline ::proto::Message_VideoMessage* Message_TemplateMessage_FourRowTemplate::release_videomessage() { + // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.FourRowTemplate.videoMessage) + if (_internal_has_videomessage()) { + clear_has_title(); + ::proto::Message_VideoMessage* temp = _impl_.title_.videomessage_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.title_.videomessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::Message_VideoMessage& Message_TemplateMessage_FourRowTemplate::_internal_videomessage() const { + return _internal_has_videomessage() + ? *_impl_.title_.videomessage_ + : reinterpret_cast< ::proto::Message_VideoMessage&>(::proto::_Message_VideoMessage_default_instance_); +} +inline const ::proto::Message_VideoMessage& Message_TemplateMessage_FourRowTemplate::videomessage() const { + // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.videoMessage) + return _internal_videomessage(); +} +inline ::proto::Message_VideoMessage* Message_TemplateMessage_FourRowTemplate::unsafe_arena_release_videomessage() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.FourRowTemplate.videoMessage) + if (_internal_has_videomessage()) { + clear_has_title(); + ::proto::Message_VideoMessage* temp = _impl_.title_.videomessage_; + _impl_.title_.videomessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Message_TemplateMessage_FourRowTemplate::unsafe_arena_set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) { + clear_title(); + if (videomessage) { + set_has_videomessage(); + _impl_.title_.videomessage_ = videomessage; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.videoMessage) +} +inline ::proto::Message_VideoMessage* Message_TemplateMessage_FourRowTemplate::_internal_mutable_videomessage() { + if (!_internal_has_videomessage()) { + clear_title(); + set_has_videomessage(); + _impl_.title_.videomessage_ = CreateMaybeMessage< ::proto::Message_VideoMessage >(GetArenaForAllocation()); + } + return _impl_.title_.videomessage_; +} +inline ::proto::Message_VideoMessage* Message_TemplateMessage_FourRowTemplate::mutable_videomessage() { + ::proto::Message_VideoMessage* _msg = _internal_mutable_videomessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.videoMessage) + return _msg; +} + +// .proto.Message.LocationMessage locationMessage = 5; +inline bool Message_TemplateMessage_FourRowTemplate::_internal_has_locationmessage() const { + return title_case() == kLocationMessage; +} +inline bool Message_TemplateMessage_FourRowTemplate::has_locationmessage() const { + return _internal_has_locationmessage(); +} +inline void Message_TemplateMessage_FourRowTemplate::set_has_locationmessage() { + _impl_._oneof_case_[0] = kLocationMessage; +} +inline void Message_TemplateMessage_FourRowTemplate::clear_locationmessage() { + if (_internal_has_locationmessage()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.title_.locationmessage_; + } + clear_has_title(); + } +} +inline ::proto::Message_LocationMessage* Message_TemplateMessage_FourRowTemplate::release_locationmessage() { + // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.FourRowTemplate.locationMessage) + if (_internal_has_locationmessage()) { + clear_has_title(); + ::proto::Message_LocationMessage* temp = _impl_.title_.locationmessage_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.title_.locationmessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::Message_LocationMessage& Message_TemplateMessage_FourRowTemplate::_internal_locationmessage() const { + return _internal_has_locationmessage() + ? *_impl_.title_.locationmessage_ + : reinterpret_cast< ::proto::Message_LocationMessage&>(::proto::_Message_LocationMessage_default_instance_); +} +inline const ::proto::Message_LocationMessage& Message_TemplateMessage_FourRowTemplate::locationmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.locationMessage) + return _internal_locationmessage(); +} +inline ::proto::Message_LocationMessage* Message_TemplateMessage_FourRowTemplate::unsafe_arena_release_locationmessage() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.FourRowTemplate.locationMessage) + if (_internal_has_locationmessage()) { + clear_has_title(); + ::proto::Message_LocationMessage* temp = _impl_.title_.locationmessage_; + _impl_.title_.locationmessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Message_TemplateMessage_FourRowTemplate::unsafe_arena_set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage) { + clear_title(); + if (locationmessage) { + set_has_locationmessage(); + _impl_.title_.locationmessage_ = locationmessage; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.locationMessage) +} +inline ::proto::Message_LocationMessage* Message_TemplateMessage_FourRowTemplate::_internal_mutable_locationmessage() { + if (!_internal_has_locationmessage()) { + clear_title(); + set_has_locationmessage(); + _impl_.title_.locationmessage_ = CreateMaybeMessage< ::proto::Message_LocationMessage >(GetArenaForAllocation()); + } + return _impl_.title_.locationmessage_; +} +inline ::proto::Message_LocationMessage* Message_TemplateMessage_FourRowTemplate::mutable_locationmessage() { + ::proto::Message_LocationMessage* _msg = _internal_mutable_locationmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.locationMessage) + return _msg; +} + +inline bool Message_TemplateMessage_FourRowTemplate::has_title() const { + return title_case() != TITLE_NOT_SET; +} +inline void Message_TemplateMessage_FourRowTemplate::clear_has_title() { + _impl_._oneof_case_[0] = TITLE_NOT_SET; +} +inline Message_TemplateMessage_FourRowTemplate::TitleCase Message_TemplateMessage_FourRowTemplate::title_case() const { + return Message_TemplateMessage_FourRowTemplate::TitleCase(_impl_._oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// Message_TemplateMessage_HydratedFourRowTemplate + +// optional string hydratedContentText = 6; +inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_hydratedcontenttext() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_hydratedcontenttext() const { + return _internal_has_hydratedcontenttext(); +} +inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_hydratedcontenttext() { + _impl_.hydratedcontenttext_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::hydratedcontenttext() const { + // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedContentText) + return _internal_hydratedcontenttext(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_TemplateMessage_HydratedFourRowTemplate::set_hydratedcontenttext(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.hydratedcontenttext_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedContentText) +} +inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::mutable_hydratedcontenttext() { + std::string* _s = _internal_mutable_hydratedcontenttext(); + // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedContentText) + return _s; +} +inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::_internal_hydratedcontenttext() const { + return _impl_.hydratedcontenttext_.Get(); +} +inline void Message_TemplateMessage_HydratedFourRowTemplate::_internal_set_hydratedcontenttext(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.hydratedcontenttext_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_hydratedcontenttext() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.hydratedcontenttext_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::release_hydratedcontenttext() { + // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedContentText) + if (!_internal_has_hydratedcontenttext()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.hydratedcontenttext_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.hydratedcontenttext_.IsDefault()) { + _impl_.hydratedcontenttext_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_TemplateMessage_HydratedFourRowTemplate::set_allocated_hydratedcontenttext(std::string* hydratedcontenttext) { + if (hydratedcontenttext != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.hydratedcontenttext_.SetAllocated(hydratedcontenttext, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.hydratedcontenttext_.IsDefault()) { + _impl_.hydratedcontenttext_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedContentText) +} + +// optional string hydratedFooterText = 7; +inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_hydratedfootertext() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_hydratedfootertext() const { + return _internal_has_hydratedfootertext(); +} +inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_hydratedfootertext() { + _impl_.hydratedfootertext_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::hydratedfootertext() const { + // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedFooterText) + return _internal_hydratedfootertext(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_TemplateMessage_HydratedFourRowTemplate::set_hydratedfootertext(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.hydratedfootertext_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedFooterText) +} +inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::mutable_hydratedfootertext() { + std::string* _s = _internal_mutable_hydratedfootertext(); + // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedFooterText) + return _s; +} +inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::_internal_hydratedfootertext() const { + return _impl_.hydratedfootertext_.Get(); +} +inline void Message_TemplateMessage_HydratedFourRowTemplate::_internal_set_hydratedfootertext(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.hydratedfootertext_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_hydratedfootertext() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.hydratedfootertext_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::release_hydratedfootertext() { + // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedFooterText) + if (!_internal_has_hydratedfootertext()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.hydratedfootertext_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.hydratedfootertext_.IsDefault()) { + _impl_.hydratedfootertext_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_TemplateMessage_HydratedFourRowTemplate::set_allocated_hydratedfootertext(std::string* hydratedfootertext) { + if (hydratedfootertext != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.hydratedfootertext_.SetAllocated(hydratedfootertext, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.hydratedfootertext_.IsDefault()) { + _impl_.hydratedfootertext_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedFooterText) +} + +// repeated .proto.HydratedTemplateButton hydratedButtons = 8; +inline int Message_TemplateMessage_HydratedFourRowTemplate::_internal_hydratedbuttons_size() const { + return _impl_.hydratedbuttons_.size(); +} +inline int Message_TemplateMessage_HydratedFourRowTemplate::hydratedbuttons_size() const { + return _internal_hydratedbuttons_size(); +} +inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_hydratedbuttons() { + _impl_.hydratedbuttons_.Clear(); +} +inline ::proto::HydratedTemplateButton* Message_TemplateMessage_HydratedFourRowTemplate::mutable_hydratedbuttons(int index) { + // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedButtons) + return _impl_.hydratedbuttons_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HydratedTemplateButton >* +Message_TemplateMessage_HydratedFourRowTemplate::mutable_hydratedbuttons() { + // @@protoc_insertion_point(field_mutable_list:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedButtons) + return &_impl_.hydratedbuttons_; +} +inline const ::proto::HydratedTemplateButton& Message_TemplateMessage_HydratedFourRowTemplate::_internal_hydratedbuttons(int index) const { + return _impl_.hydratedbuttons_.Get(index); +} +inline const ::proto::HydratedTemplateButton& Message_TemplateMessage_HydratedFourRowTemplate::hydratedbuttons(int index) const { + // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedButtons) + return _internal_hydratedbuttons(index); +} +inline ::proto::HydratedTemplateButton* Message_TemplateMessage_HydratedFourRowTemplate::_internal_add_hydratedbuttons() { + return _impl_.hydratedbuttons_.Add(); +} +inline ::proto::HydratedTemplateButton* Message_TemplateMessage_HydratedFourRowTemplate::add_hydratedbuttons() { + ::proto::HydratedTemplateButton* _add = _internal_add_hydratedbuttons(); + // @@protoc_insertion_point(field_add:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedButtons) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HydratedTemplateButton >& +Message_TemplateMessage_HydratedFourRowTemplate::hydratedbuttons() const { + // @@protoc_insertion_point(field_list:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedButtons) + return _impl_.hydratedbuttons_; +} + +// optional string templateId = 9; +inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_templateid() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_templateid() const { + return _internal_has_templateid(); +} +inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_templateid() { + _impl_.templateid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::templateid() const { + // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.templateId) + return _internal_templateid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_TemplateMessage_HydratedFourRowTemplate::set_templateid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.templateid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.TemplateMessage.HydratedFourRowTemplate.templateId) +} +inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::mutable_templateid() { + std::string* _s = _internal_mutable_templateid(); + // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.templateId) + return _s; +} +inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::_internal_templateid() const { + return _impl_.templateid_.Get(); +} +inline void Message_TemplateMessage_HydratedFourRowTemplate::_internal_set_templateid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.templateid_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_templateid() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.templateid_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::release_templateid() { + // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.templateId) + if (!_internal_has_templateid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.templateid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.templateid_.IsDefault()) { + _impl_.templateid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_TemplateMessage_HydratedFourRowTemplate::set_allocated_templateid(std::string* templateid) { + if (templateid != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.templateid_.SetAllocated(templateid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.templateid_.IsDefault()) { + _impl_.templateid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.templateId) +} + +// .proto.Message.DocumentMessage documentMessage = 1; +inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_documentmessage() const { + return title_case() == kDocumentMessage; +} +inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_documentmessage() const { + return _internal_has_documentmessage(); +} +inline void Message_TemplateMessage_HydratedFourRowTemplate::set_has_documentmessage() { + _impl_._oneof_case_[0] = kDocumentMessage; +} +inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_documentmessage() { + if (_internal_has_documentmessage()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.title_.documentmessage_; + } + clear_has_title(); + } +} +inline ::proto::Message_DocumentMessage* Message_TemplateMessage_HydratedFourRowTemplate::release_documentmessage() { + // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.documentMessage) + if (_internal_has_documentmessage()) { + clear_has_title(); + ::proto::Message_DocumentMessage* temp = _impl_.title_.documentmessage_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.title_.documentmessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::Message_DocumentMessage& Message_TemplateMessage_HydratedFourRowTemplate::_internal_documentmessage() const { + return _internal_has_documentmessage() + ? *_impl_.title_.documentmessage_ + : reinterpret_cast< ::proto::Message_DocumentMessage&>(::proto::_Message_DocumentMessage_default_instance_); +} +inline const ::proto::Message_DocumentMessage& Message_TemplateMessage_HydratedFourRowTemplate::documentmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.documentMessage) + return _internal_documentmessage(); +} +inline ::proto::Message_DocumentMessage* Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_release_documentmessage() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.documentMessage) + if (_internal_has_documentmessage()) { + clear_has_title(); + ::proto::Message_DocumentMessage* temp = _impl_.title_.documentmessage_; + _impl_.title_.documentmessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) { + clear_title(); + if (documentmessage) { + set_has_documentmessage(); + _impl_.title_.documentmessage_ = documentmessage; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.documentMessage) +} +inline ::proto::Message_DocumentMessage* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_documentmessage() { + if (!_internal_has_documentmessage()) { + clear_title(); + set_has_documentmessage(); + _impl_.title_.documentmessage_ = CreateMaybeMessage< ::proto::Message_DocumentMessage >(GetArenaForAllocation()); + } + return _impl_.title_.documentmessage_; +} +inline ::proto::Message_DocumentMessage* Message_TemplateMessage_HydratedFourRowTemplate::mutable_documentmessage() { + ::proto::Message_DocumentMessage* _msg = _internal_mutable_documentmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.documentMessage) + return _msg; +} + +// string hydratedTitleText = 2; +inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_hydratedtitletext() const { + return title_case() == kHydratedTitleText; +} +inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_hydratedtitletext() const { + return _internal_has_hydratedtitletext(); +} +inline void Message_TemplateMessage_HydratedFourRowTemplate::set_has_hydratedtitletext() { + _impl_._oneof_case_[0] = kHydratedTitleText; +} +inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_hydratedtitletext() { + if (_internal_has_hydratedtitletext()) { + _impl_.title_.hydratedtitletext_.Destroy(); + clear_has_title(); + } +} +inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::hydratedtitletext() const { + // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedTitleText) + return _internal_hydratedtitletext(); +} +template +inline void Message_TemplateMessage_HydratedFourRowTemplate::set_hydratedtitletext(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_hydratedtitletext()) { + clear_title(); + set_has_hydratedtitletext(); + _impl_.title_.hydratedtitletext_.InitDefault(); + } + _impl_.title_.hydratedtitletext_.Set( static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedTitleText) +} +inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::mutable_hydratedtitletext() { + std::string* _s = _internal_mutable_hydratedtitletext(); + // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedTitleText) + return _s; +} +inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::_internal_hydratedtitletext() const { + if (_internal_has_hydratedtitletext()) { + return _impl_.title_.hydratedtitletext_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void Message_TemplateMessage_HydratedFourRowTemplate::_internal_set_hydratedtitletext(const std::string& value) { + if (!_internal_has_hydratedtitletext()) { + clear_title(); + set_has_hydratedtitletext(); + _impl_.title_.hydratedtitletext_.InitDefault(); + } + _impl_.title_.hydratedtitletext_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_hydratedtitletext() { + if (!_internal_has_hydratedtitletext()) { + clear_title(); + set_has_hydratedtitletext(); + _impl_.title_.hydratedtitletext_.InitDefault(); + } + return _impl_.title_.hydratedtitletext_.Mutable( GetArenaForAllocation()); +} +inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::release_hydratedtitletext() { + // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedTitleText) + if (_internal_has_hydratedtitletext()) { + clear_has_title(); + return _impl_.title_.hydratedtitletext_.Release(); + } else { + return nullptr; + } +} +inline void Message_TemplateMessage_HydratedFourRowTemplate::set_allocated_hydratedtitletext(std::string* hydratedtitletext) { + if (has_title()) { + clear_title(); + } + if (hydratedtitletext != nullptr) { + set_has_hydratedtitletext(); + _impl_.title_.hydratedtitletext_.InitAllocated(hydratedtitletext, GetArenaForAllocation()); + } + // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedTitleText) +} + +// .proto.Message.ImageMessage imageMessage = 3; +inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_imagemessage() const { + return title_case() == kImageMessage; +} +inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_imagemessage() const { + return _internal_has_imagemessage(); +} +inline void Message_TemplateMessage_HydratedFourRowTemplate::set_has_imagemessage() { + _impl_._oneof_case_[0] = kImageMessage; +} +inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_imagemessage() { + if (_internal_has_imagemessage()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.title_.imagemessage_; + } + clear_has_title(); + } +} +inline ::proto::Message_ImageMessage* Message_TemplateMessage_HydratedFourRowTemplate::release_imagemessage() { + // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.imageMessage) + if (_internal_has_imagemessage()) { + clear_has_title(); + ::proto::Message_ImageMessage* temp = _impl_.title_.imagemessage_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.title_.imagemessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::Message_ImageMessage& Message_TemplateMessage_HydratedFourRowTemplate::_internal_imagemessage() const { + return _internal_has_imagemessage() + ? *_impl_.title_.imagemessage_ + : reinterpret_cast< ::proto::Message_ImageMessage&>(::proto::_Message_ImageMessage_default_instance_); +} +inline const ::proto::Message_ImageMessage& Message_TemplateMessage_HydratedFourRowTemplate::imagemessage() const { + // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.imageMessage) + return _internal_imagemessage(); +} +inline ::proto::Message_ImageMessage* Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_release_imagemessage() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.imageMessage) + if (_internal_has_imagemessage()) { + clear_has_title(); + ::proto::Message_ImageMessage* temp = _impl_.title_.imagemessage_; + _impl_.title_.imagemessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) { + clear_title(); + if (imagemessage) { + set_has_imagemessage(); + _impl_.title_.imagemessage_ = imagemessage; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.imageMessage) +} +inline ::proto::Message_ImageMessage* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_imagemessage() { + if (!_internal_has_imagemessage()) { + clear_title(); + set_has_imagemessage(); + _impl_.title_.imagemessage_ = CreateMaybeMessage< ::proto::Message_ImageMessage >(GetArenaForAllocation()); + } + return _impl_.title_.imagemessage_; +} +inline ::proto::Message_ImageMessage* Message_TemplateMessage_HydratedFourRowTemplate::mutable_imagemessage() { + ::proto::Message_ImageMessage* _msg = _internal_mutable_imagemessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.imageMessage) + return _msg; +} + +// .proto.Message.VideoMessage videoMessage = 4; +inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_videomessage() const { + return title_case() == kVideoMessage; +} +inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_videomessage() const { + return _internal_has_videomessage(); +} +inline void Message_TemplateMessage_HydratedFourRowTemplate::set_has_videomessage() { + _impl_._oneof_case_[0] = kVideoMessage; +} +inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_videomessage() { + if (_internal_has_videomessage()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.title_.videomessage_; + } + clear_has_title(); + } +} +inline ::proto::Message_VideoMessage* Message_TemplateMessage_HydratedFourRowTemplate::release_videomessage() { + // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.videoMessage) + if (_internal_has_videomessage()) { + clear_has_title(); + ::proto::Message_VideoMessage* temp = _impl_.title_.videomessage_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.title_.videomessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::Message_VideoMessage& Message_TemplateMessage_HydratedFourRowTemplate::_internal_videomessage() const { + return _internal_has_videomessage() + ? *_impl_.title_.videomessage_ + : reinterpret_cast< ::proto::Message_VideoMessage&>(::proto::_Message_VideoMessage_default_instance_); +} +inline const ::proto::Message_VideoMessage& Message_TemplateMessage_HydratedFourRowTemplate::videomessage() const { + // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.videoMessage) + return _internal_videomessage(); +} +inline ::proto::Message_VideoMessage* Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_release_videomessage() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.videoMessage) + if (_internal_has_videomessage()) { + clear_has_title(); + ::proto::Message_VideoMessage* temp = _impl_.title_.videomessage_; + _impl_.title_.videomessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) { + clear_title(); + if (videomessage) { + set_has_videomessage(); + _impl_.title_.videomessage_ = videomessage; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.videoMessage) +} +inline ::proto::Message_VideoMessage* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_videomessage() { + if (!_internal_has_videomessage()) { + clear_title(); + set_has_videomessage(); + _impl_.title_.videomessage_ = CreateMaybeMessage< ::proto::Message_VideoMessage >(GetArenaForAllocation()); + } + return _impl_.title_.videomessage_; +} +inline ::proto::Message_VideoMessage* Message_TemplateMessage_HydratedFourRowTemplate::mutable_videomessage() { + ::proto::Message_VideoMessage* _msg = _internal_mutable_videomessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.videoMessage) + return _msg; +} + +// .proto.Message.LocationMessage locationMessage = 5; +inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_locationmessage() const { + return title_case() == kLocationMessage; +} +inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_locationmessage() const { + return _internal_has_locationmessage(); +} +inline void Message_TemplateMessage_HydratedFourRowTemplate::set_has_locationmessage() { + _impl_._oneof_case_[0] = kLocationMessage; +} +inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_locationmessage() { + if (_internal_has_locationmessage()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.title_.locationmessage_; + } + clear_has_title(); + } +} +inline ::proto::Message_LocationMessage* Message_TemplateMessage_HydratedFourRowTemplate::release_locationmessage() { + // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.locationMessage) + if (_internal_has_locationmessage()) { + clear_has_title(); + ::proto::Message_LocationMessage* temp = _impl_.title_.locationmessage_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.title_.locationmessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::Message_LocationMessage& Message_TemplateMessage_HydratedFourRowTemplate::_internal_locationmessage() const { + return _internal_has_locationmessage() + ? *_impl_.title_.locationmessage_ + : reinterpret_cast< ::proto::Message_LocationMessage&>(::proto::_Message_LocationMessage_default_instance_); +} +inline const ::proto::Message_LocationMessage& Message_TemplateMessage_HydratedFourRowTemplate::locationmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.locationMessage) + return _internal_locationmessage(); +} +inline ::proto::Message_LocationMessage* Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_release_locationmessage() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.locationMessage) + if (_internal_has_locationmessage()) { + clear_has_title(); + ::proto::Message_LocationMessage* temp = _impl_.title_.locationmessage_; + _impl_.title_.locationmessage_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage) { + clear_title(); + if (locationmessage) { + set_has_locationmessage(); + _impl_.title_.locationmessage_ = locationmessage; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.locationMessage) +} +inline ::proto::Message_LocationMessage* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_locationmessage() { + if (!_internal_has_locationmessage()) { + clear_title(); + set_has_locationmessage(); + _impl_.title_.locationmessage_ = CreateMaybeMessage< ::proto::Message_LocationMessage >(GetArenaForAllocation()); + } + return _impl_.title_.locationmessage_; +} +inline ::proto::Message_LocationMessage* Message_TemplateMessage_HydratedFourRowTemplate::mutable_locationmessage() { + ::proto::Message_LocationMessage* _msg = _internal_mutable_locationmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.locationMessage) + return _msg; +} + +inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_title() const { + return title_case() != TITLE_NOT_SET; +} +inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_has_title() { + _impl_._oneof_case_[0] = TITLE_NOT_SET; +} +inline Message_TemplateMessage_HydratedFourRowTemplate::TitleCase Message_TemplateMessage_HydratedFourRowTemplate::title_case() const { + return Message_TemplateMessage_HydratedFourRowTemplate::TitleCase(_impl_._oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// Message_TemplateMessage + +// optional .proto.ContextInfo contextInfo = 3; +inline bool Message_TemplateMessage::_internal_has_contextinfo() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); + return value; +} +inline bool Message_TemplateMessage::has_contextinfo() const { + return _internal_has_contextinfo(); +} +inline void Message_TemplateMessage::clear_contextinfo() { + if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::ContextInfo& Message_TemplateMessage::_internal_contextinfo() const { + const ::proto::ContextInfo* p = _impl_.contextinfo_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ContextInfo_default_instance_); +} +inline const ::proto::ContextInfo& Message_TemplateMessage::contextinfo() const { + // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.contextInfo) + return _internal_contextinfo(); +} +inline void Message_TemplateMessage::unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); + } + _impl_.contextinfo_ = contextinfo; + if (contextinfo) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.contextInfo) +} +inline ::proto::ContextInfo* Message_TemplateMessage::release_contextinfo() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ContextInfo* Message_TemplateMessage::unsafe_arena_release_contextinfo() { + // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.contextInfo) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; + return temp; +} +inline ::proto::ContextInfo* Message_TemplateMessage::_internal_mutable_contextinfo() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.contextinfo_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); + _impl_.contextinfo_ = p; + } + return _impl_.contextinfo_; +} +inline ::proto::ContextInfo* Message_TemplateMessage::mutable_contextinfo() { + ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); + // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.contextInfo) + return _msg; +} +inline void Message_TemplateMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.contextinfo_; + } + if (contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); + if (message_arena != submessage_arena) { + contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, contextinfo, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.contextinfo_ = contextinfo; + // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.contextInfo) +} + +// optional .proto.Message.TemplateMessage.HydratedFourRowTemplate hydratedTemplate = 4; +inline bool Message_TemplateMessage::_internal_has_hydratedtemplate() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.hydratedtemplate_ != nullptr); + return value; +} +inline bool Message_TemplateMessage::has_hydratedtemplate() const { + return _internal_has_hydratedtemplate(); +} +inline void Message_TemplateMessage::clear_hydratedtemplate() { + if (_impl_.hydratedtemplate_ != nullptr) _impl_.hydratedtemplate_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& Message_TemplateMessage::_internal_hydratedtemplate() const { + const ::proto::Message_TemplateMessage_HydratedFourRowTemplate* p = _impl_.hydratedtemplate_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_TemplateMessage_HydratedFourRowTemplate_default_instance_); +} +inline const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& Message_TemplateMessage::hydratedtemplate() const { + // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.hydratedTemplate) + return _internal_hydratedtemplate(); +} +inline void Message_TemplateMessage::unsafe_arena_set_allocated_hydratedtemplate( + ::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedtemplate) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.hydratedtemplate_); + } + _impl_.hydratedtemplate_ = hydratedtemplate; + if (hydratedtemplate) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.hydratedTemplate) +} +inline ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::release_hydratedtemplate() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::Message_TemplateMessage_HydratedFourRowTemplate* temp = _impl_.hydratedtemplate_; + _impl_.hydratedtemplate_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::unsafe_arena_release_hydratedtemplate() { + // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.hydratedTemplate) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::Message_TemplateMessage_HydratedFourRowTemplate* temp = _impl_.hydratedtemplate_; + _impl_.hydratedtemplate_ = nullptr; + return temp; +} +inline ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::_internal_mutable_hydratedtemplate() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.hydratedtemplate_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_TemplateMessage_HydratedFourRowTemplate>(GetArenaForAllocation()); + _impl_.hydratedtemplate_ = p; + } + return _impl_.hydratedtemplate_; +} +inline ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::mutable_hydratedtemplate() { + ::proto::Message_TemplateMessage_HydratedFourRowTemplate* _msg = _internal_mutable_hydratedtemplate(); + // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.hydratedTemplate) + return _msg; +} +inline void Message_TemplateMessage::set_allocated_hydratedtemplate(::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedtemplate) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.hydratedtemplate_; + } + if (hydratedtemplate) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(hydratedtemplate); + if (message_arena != submessage_arena) { + hydratedtemplate = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, hydratedtemplate, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.hydratedtemplate_ = hydratedtemplate; + // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.hydratedTemplate) +} + +// .proto.Message.TemplateMessage.FourRowTemplate fourRowTemplate = 1; +inline bool Message_TemplateMessage::_internal_has_fourrowtemplate() const { + return format_case() == kFourRowTemplate; +} +inline bool Message_TemplateMessage::has_fourrowtemplate() const { + return _internal_has_fourrowtemplate(); +} +inline void Message_TemplateMessage::set_has_fourrowtemplate() { + _impl_._oneof_case_[0] = kFourRowTemplate; +} +inline void Message_TemplateMessage::clear_fourrowtemplate() { + if (_internal_has_fourrowtemplate()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.format_.fourrowtemplate_; + } + clear_has_format(); + } +} +inline ::proto::Message_TemplateMessage_FourRowTemplate* Message_TemplateMessage::release_fourrowtemplate() { + // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.fourRowTemplate) + if (_internal_has_fourrowtemplate()) { + clear_has_format(); + ::proto::Message_TemplateMessage_FourRowTemplate* temp = _impl_.format_.fourrowtemplate_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.format_.fourrowtemplate_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::Message_TemplateMessage_FourRowTemplate& Message_TemplateMessage::_internal_fourrowtemplate() const { + return _internal_has_fourrowtemplate() + ? *_impl_.format_.fourrowtemplate_ + : reinterpret_cast< ::proto::Message_TemplateMessage_FourRowTemplate&>(::proto::_Message_TemplateMessage_FourRowTemplate_default_instance_); +} +inline const ::proto::Message_TemplateMessage_FourRowTemplate& Message_TemplateMessage::fourrowtemplate() const { + // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.fourRowTemplate) + return _internal_fourrowtemplate(); +} +inline ::proto::Message_TemplateMessage_FourRowTemplate* Message_TemplateMessage::unsafe_arena_release_fourrowtemplate() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.fourRowTemplate) + if (_internal_has_fourrowtemplate()) { + clear_has_format(); + ::proto::Message_TemplateMessage_FourRowTemplate* temp = _impl_.format_.fourrowtemplate_; + _impl_.format_.fourrowtemplate_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Message_TemplateMessage::unsafe_arena_set_allocated_fourrowtemplate(::proto::Message_TemplateMessage_FourRowTemplate* fourrowtemplate) { + clear_format(); + if (fourrowtemplate) { + set_has_fourrowtemplate(); + _impl_.format_.fourrowtemplate_ = fourrowtemplate; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.fourRowTemplate) +} +inline ::proto::Message_TemplateMessage_FourRowTemplate* Message_TemplateMessage::_internal_mutable_fourrowtemplate() { + if (!_internal_has_fourrowtemplate()) { + clear_format(); + set_has_fourrowtemplate(); + _impl_.format_.fourrowtemplate_ = CreateMaybeMessage< ::proto::Message_TemplateMessage_FourRowTemplate >(GetArenaForAllocation()); + } + return _impl_.format_.fourrowtemplate_; +} +inline ::proto::Message_TemplateMessage_FourRowTemplate* Message_TemplateMessage::mutable_fourrowtemplate() { + ::proto::Message_TemplateMessage_FourRowTemplate* _msg = _internal_mutable_fourrowtemplate(); + // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.fourRowTemplate) + return _msg; +} + +// .proto.Message.TemplateMessage.HydratedFourRowTemplate hydratedFourRowTemplate = 2; +inline bool Message_TemplateMessage::_internal_has_hydratedfourrowtemplate() const { + return format_case() == kHydratedFourRowTemplate; +} +inline bool Message_TemplateMessage::has_hydratedfourrowtemplate() const { + return _internal_has_hydratedfourrowtemplate(); +} +inline void Message_TemplateMessage::set_has_hydratedfourrowtemplate() { + _impl_._oneof_case_[0] = kHydratedFourRowTemplate; +} +inline void Message_TemplateMessage::clear_hydratedfourrowtemplate() { + if (_internal_has_hydratedfourrowtemplate()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.format_.hydratedfourrowtemplate_; + } + clear_has_format(); + } +} +inline ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::release_hydratedfourrowtemplate() { + // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.hydratedFourRowTemplate) + if (_internal_has_hydratedfourrowtemplate()) { + clear_has_format(); + ::proto::Message_TemplateMessage_HydratedFourRowTemplate* temp = _impl_.format_.hydratedfourrowtemplate_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.format_.hydratedfourrowtemplate_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& Message_TemplateMessage::_internal_hydratedfourrowtemplate() const { + return _internal_has_hydratedfourrowtemplate() + ? *_impl_.format_.hydratedfourrowtemplate_ + : reinterpret_cast< ::proto::Message_TemplateMessage_HydratedFourRowTemplate&>(::proto::_Message_TemplateMessage_HydratedFourRowTemplate_default_instance_); +} +inline const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& Message_TemplateMessage::hydratedfourrowtemplate() const { + // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.hydratedFourRowTemplate) + return _internal_hydratedfourrowtemplate(); +} +inline ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::unsafe_arena_release_hydratedfourrowtemplate() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.hydratedFourRowTemplate) + if (_internal_has_hydratedfourrowtemplate()) { + clear_has_format(); + ::proto::Message_TemplateMessage_HydratedFourRowTemplate* temp = _impl_.format_.hydratedfourrowtemplate_; + _impl_.format_.hydratedfourrowtemplate_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Message_TemplateMessage::unsafe_arena_set_allocated_hydratedfourrowtemplate(::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedfourrowtemplate) { + clear_format(); + if (hydratedfourrowtemplate) { + set_has_hydratedfourrowtemplate(); + _impl_.format_.hydratedfourrowtemplate_ = hydratedfourrowtemplate; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.hydratedFourRowTemplate) +} +inline ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::_internal_mutable_hydratedfourrowtemplate() { + if (!_internal_has_hydratedfourrowtemplate()) { + clear_format(); + set_has_hydratedfourrowtemplate(); + _impl_.format_.hydratedfourrowtemplate_ = CreateMaybeMessage< ::proto::Message_TemplateMessage_HydratedFourRowTemplate >(GetArenaForAllocation()); + } + return _impl_.format_.hydratedfourrowtemplate_; +} +inline ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::mutable_hydratedfourrowtemplate() { + ::proto::Message_TemplateMessage_HydratedFourRowTemplate* _msg = _internal_mutable_hydratedfourrowtemplate(); + // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.hydratedFourRowTemplate) + return _msg; +} + +inline bool Message_TemplateMessage::has_format() const { + return format_case() != FORMAT_NOT_SET; +} +inline void Message_TemplateMessage::clear_has_format() { + _impl_._oneof_case_[0] = FORMAT_NOT_SET; +} +inline Message_TemplateMessage::FormatCase Message_TemplateMessage::format_case() const { + return Message_TemplateMessage::FormatCase(_impl_._oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// Message_VideoMessage + +// optional string url = 1; +inline bool Message_VideoMessage::_internal_has_url() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message_VideoMessage::has_url() const { + return _internal_has_url(); +} +inline void Message_VideoMessage::clear_url() { + _impl_.url_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message_VideoMessage::url() const { + // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.url) + return _internal_url(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_VideoMessage::set_url(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.url_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.url) +} +inline std::string* Message_VideoMessage::mutable_url() { + std::string* _s = _internal_mutable_url(); + // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.url) + return _s; +} +inline const std::string& Message_VideoMessage::_internal_url() const { + return _impl_.url_.Get(); +} +inline void Message_VideoMessage::_internal_set_url(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.url_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_VideoMessage::_internal_mutable_url() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.url_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_VideoMessage::release_url() { + // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.url) + if (!_internal_has_url()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.url_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.url_.IsDefault()) { + _impl_.url_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_VideoMessage::set_allocated_url(std::string* url) { + if (url != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.url_.SetAllocated(url, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.url_.IsDefault()) { + _impl_.url_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.url) +} + +// optional string mimetype = 2; +inline bool Message_VideoMessage::_internal_has_mimetype() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Message_VideoMessage::has_mimetype() const { + return _internal_has_mimetype(); +} +inline void Message_VideoMessage::clear_mimetype() { + _impl_.mimetype_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Message_VideoMessage::mimetype() const { + // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.mimetype) + return _internal_mimetype(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_VideoMessage::set_mimetype(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.mimetype_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.mimetype) +} +inline std::string* Message_VideoMessage::mutable_mimetype() { + std::string* _s = _internal_mutable_mimetype(); + // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.mimetype) + return _s; +} +inline const std::string& Message_VideoMessage::_internal_mimetype() const { + return _impl_.mimetype_.Get(); +} +inline void Message_VideoMessage::_internal_set_mimetype(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.mimetype_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_VideoMessage::_internal_mutable_mimetype() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.mimetype_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_VideoMessage::release_mimetype() { + // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.mimetype) + if (!_internal_has_mimetype()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.mimetype_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mimetype_.IsDefault()) { + _impl_.mimetype_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_VideoMessage::set_allocated_mimetype(std::string* mimetype) { + if (mimetype != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mimetype_.IsDefault()) { + _impl_.mimetype_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.mimetype) +} + +// optional bytes fileSha256 = 3; +inline bool Message_VideoMessage::_internal_has_filesha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Message_VideoMessage::has_filesha256() const { + return _internal_has_filesha256(); +} +inline void Message_VideoMessage::clear_filesha256() { + _impl_.filesha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& Message_VideoMessage::filesha256() const { + // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.fileSha256) + return _internal_filesha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_VideoMessage::set_filesha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.filesha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.fileSha256) +} +inline std::string* Message_VideoMessage::mutable_filesha256() { + std::string* _s = _internal_mutable_filesha256(); + // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.fileSha256) + return _s; +} +inline const std::string& Message_VideoMessage::_internal_filesha256() const { + return _impl_.filesha256_.Get(); +} +inline void Message_VideoMessage::_internal_set_filesha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.filesha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_VideoMessage::_internal_mutable_filesha256() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.filesha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_VideoMessage::release_filesha256() { + // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.fileSha256) + if (!_internal_has_filesha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.filesha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.filesha256_.IsDefault()) { + _impl_.filesha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_VideoMessage::set_allocated_filesha256(std::string* filesha256) { + if (filesha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.filesha256_.IsDefault()) { + _impl_.filesha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.fileSha256) +} + +// optional uint64 fileLength = 4; +inline bool Message_VideoMessage::_internal_has_filelength() const { + bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0; + return value; +} +inline bool Message_VideoMessage::has_filelength() const { + return _internal_has_filelength(); +} +inline void Message_VideoMessage::clear_filelength() { + _impl_.filelength_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00004000u; +} +inline uint64_t Message_VideoMessage::_internal_filelength() const { + return _impl_.filelength_; +} +inline uint64_t Message_VideoMessage::filelength() const { + // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.fileLength) + return _internal_filelength(); +} +inline void Message_VideoMessage::_internal_set_filelength(uint64_t value) { + _impl_._has_bits_[0] |= 0x00004000u; + _impl_.filelength_ = value; +} +inline void Message_VideoMessage::set_filelength(uint64_t value) { + _internal_set_filelength(value); + // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.fileLength) +} + +// optional uint32 seconds = 5; +inline bool Message_VideoMessage::_internal_has_seconds() const { + bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0; + return value; +} +inline bool Message_VideoMessage::has_seconds() const { + return _internal_has_seconds(); +} +inline void Message_VideoMessage::clear_seconds() { + _impl_.seconds_ = 0u; + _impl_._has_bits_[0] &= ~0x00008000u; +} +inline uint32_t Message_VideoMessage::_internal_seconds() const { + return _impl_.seconds_; +} +inline uint32_t Message_VideoMessage::seconds() const { + // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.seconds) + return _internal_seconds(); +} +inline void Message_VideoMessage::_internal_set_seconds(uint32_t value) { + _impl_._has_bits_[0] |= 0x00008000u; + _impl_.seconds_ = value; +} +inline void Message_VideoMessage::set_seconds(uint32_t value) { + _internal_set_seconds(value); + // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.seconds) +} + +// optional bytes mediaKey = 6; +inline bool Message_VideoMessage::_internal_has_mediakey() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool Message_VideoMessage::has_mediakey() const { + return _internal_has_mediakey(); +} +inline void Message_VideoMessage::clear_mediakey() { + _impl_.mediakey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const std::string& Message_VideoMessage::mediakey() const { + // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.mediaKey) + return _internal_mediakey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_VideoMessage::set_mediakey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.mediakey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.mediaKey) +} +inline std::string* Message_VideoMessage::mutable_mediakey() { + std::string* _s = _internal_mutable_mediakey(); + // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.mediaKey) + return _s; +} +inline const std::string& Message_VideoMessage::_internal_mediakey() const { + return _impl_.mediakey_.Get(); +} +inline void Message_VideoMessage::_internal_set_mediakey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.mediakey_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_VideoMessage::_internal_mutable_mediakey() { + _impl_._has_bits_[0] |= 0x00000008u; + return _impl_.mediakey_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_VideoMessage::release_mediakey() { + // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.mediaKey) + if (!_internal_has_mediakey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000008u; + auto* p = _impl_.mediakey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mediakey_.IsDefault()) { + _impl_.mediakey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_VideoMessage::set_allocated_mediakey(std::string* mediakey) { + if (mediakey != nullptr) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mediakey_.IsDefault()) { + _impl_.mediakey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.mediaKey) +} + +// optional string caption = 7; +inline bool Message_VideoMessage::_internal_has_caption() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool Message_VideoMessage::has_caption() const { + return _internal_has_caption(); +} +inline void Message_VideoMessage::clear_caption() { + _impl_.caption_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const std::string& Message_VideoMessage::caption() const { + // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.caption) + return _internal_caption(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_VideoMessage::set_caption(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.caption_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.caption) +} +inline std::string* Message_VideoMessage::mutable_caption() { + std::string* _s = _internal_mutable_caption(); + // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.caption) + return _s; +} +inline const std::string& Message_VideoMessage::_internal_caption() const { + return _impl_.caption_.Get(); +} +inline void Message_VideoMessage::_internal_set_caption(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.caption_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_VideoMessage::_internal_mutable_caption() { + _impl_._has_bits_[0] |= 0x00000010u; + return _impl_.caption_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_VideoMessage::release_caption() { + // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.caption) + if (!_internal_has_caption()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000010u; + auto* p = _impl_.caption_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.caption_.IsDefault()) { + _impl_.caption_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_VideoMessage::set_allocated_caption(std::string* caption) { + if (caption != nullptr) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.caption_.SetAllocated(caption, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.caption_.IsDefault()) { + _impl_.caption_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.caption) +} + +// optional bool gifPlayback = 8; +inline bool Message_VideoMessage::_internal_has_gifplayback() const { + bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0; + return value; +} +inline bool Message_VideoMessage::has_gifplayback() const { + return _internal_has_gifplayback(); +} +inline void Message_VideoMessage::clear_gifplayback() { + _impl_.gifplayback_ = false; + _impl_._has_bits_[0] &= ~0x00040000u; +} +inline bool Message_VideoMessage::_internal_gifplayback() const { + return _impl_.gifplayback_; +} +inline bool Message_VideoMessage::gifplayback() const { + // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.gifPlayback) + return _internal_gifplayback(); +} +inline void Message_VideoMessage::_internal_set_gifplayback(bool value) { + _impl_._has_bits_[0] |= 0x00040000u; + _impl_.gifplayback_ = value; +} +inline void Message_VideoMessage::set_gifplayback(bool value) { + _internal_set_gifplayback(value); + // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.gifPlayback) +} + +// optional uint32 height = 9; +inline bool Message_VideoMessage::_internal_has_height() const { + bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0; + return value; +} +inline bool Message_VideoMessage::has_height() const { + return _internal_has_height(); +} +inline void Message_VideoMessage::clear_height() { + _impl_.height_ = 0u; + _impl_._has_bits_[0] &= ~0x00010000u; +} +inline uint32_t Message_VideoMessage::_internal_height() const { + return _impl_.height_; +} +inline uint32_t Message_VideoMessage::height() const { + // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.height) + return _internal_height(); +} +inline void Message_VideoMessage::_internal_set_height(uint32_t value) { + _impl_._has_bits_[0] |= 0x00010000u; + _impl_.height_ = value; +} +inline void Message_VideoMessage::set_height(uint32_t value) { + _internal_set_height(value); + // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.height) +} + +// optional uint32 width = 10; +inline bool Message_VideoMessage::_internal_has_width() const { + bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0; + return value; +} +inline bool Message_VideoMessage::has_width() const { + return _internal_has_width(); +} +inline void Message_VideoMessage::clear_width() { + _impl_.width_ = 0u; + _impl_._has_bits_[0] &= ~0x00020000u; +} +inline uint32_t Message_VideoMessage::_internal_width() const { + return _impl_.width_; +} +inline uint32_t Message_VideoMessage::width() const { + // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.width) + return _internal_width(); +} +inline void Message_VideoMessage::_internal_set_width(uint32_t value) { + _impl_._has_bits_[0] |= 0x00020000u; + _impl_.width_ = value; +} +inline void Message_VideoMessage::set_width(uint32_t value) { + _internal_set_width(value); + // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.width) +} + +// optional bytes fileEncSha256 = 11; +inline bool Message_VideoMessage::_internal_has_fileencsha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool Message_VideoMessage::has_fileencsha256() const { + return _internal_has_fileencsha256(); +} +inline void Message_VideoMessage::clear_fileencsha256() { + _impl_.fileencsha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline const std::string& Message_VideoMessage::fileencsha256() const { + // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.fileEncSha256) + return _internal_fileencsha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_VideoMessage::set_fileencsha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.fileencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.fileEncSha256) +} +inline std::string* Message_VideoMessage::mutable_fileencsha256() { + std::string* _s = _internal_mutable_fileencsha256(); + // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.fileEncSha256) + return _s; +} +inline const std::string& Message_VideoMessage::_internal_fileencsha256() const { + return _impl_.fileencsha256_.Get(); +} +inline void Message_VideoMessage::_internal_set_fileencsha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.fileencsha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_VideoMessage::_internal_mutable_fileencsha256() { + _impl_._has_bits_[0] |= 0x00000020u; + return _impl_.fileencsha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_VideoMessage::release_fileencsha256() { + // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.fileEncSha256) + if (!_internal_has_fileencsha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000020u; + auto* p = _impl_.fileencsha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fileencsha256_.IsDefault()) { + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_VideoMessage::set_allocated_fileencsha256(std::string* fileencsha256) { + if (fileencsha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fileencsha256_.IsDefault()) { + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.fileEncSha256) +} + +// repeated .proto.InteractiveAnnotation interactiveAnnotations = 12; +inline int Message_VideoMessage::_internal_interactiveannotations_size() const { + return _impl_.interactiveannotations_.size(); +} +inline int Message_VideoMessage::interactiveannotations_size() const { + return _internal_interactiveannotations_size(); +} +inline void Message_VideoMessage::clear_interactiveannotations() { + _impl_.interactiveannotations_.Clear(); +} +inline ::proto::InteractiveAnnotation* Message_VideoMessage::mutable_interactiveannotations(int index) { + // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.interactiveAnnotations) + return _impl_.interactiveannotations_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >* +Message_VideoMessage::mutable_interactiveannotations() { + // @@protoc_insertion_point(field_mutable_list:proto.Message.VideoMessage.interactiveAnnotations) + return &_impl_.interactiveannotations_; +} +inline const ::proto::InteractiveAnnotation& Message_VideoMessage::_internal_interactiveannotations(int index) const { + return _impl_.interactiveannotations_.Get(index); +} +inline const ::proto::InteractiveAnnotation& Message_VideoMessage::interactiveannotations(int index) const { + // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.interactiveAnnotations) + return _internal_interactiveannotations(index); +} +inline ::proto::InteractiveAnnotation* Message_VideoMessage::_internal_add_interactiveannotations() { + return _impl_.interactiveannotations_.Add(); +} +inline ::proto::InteractiveAnnotation* Message_VideoMessage::add_interactiveannotations() { + ::proto::InteractiveAnnotation* _add = _internal_add_interactiveannotations(); + // @@protoc_insertion_point(field_add:proto.Message.VideoMessage.interactiveAnnotations) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >& +Message_VideoMessage::interactiveannotations() const { + // @@protoc_insertion_point(field_list:proto.Message.VideoMessage.interactiveAnnotations) + return _impl_.interactiveannotations_; +} + +// optional string directPath = 13; +inline bool Message_VideoMessage::_internal_has_directpath() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool Message_VideoMessage::has_directpath() const { + return _internal_has_directpath(); +} +inline void Message_VideoMessage::clear_directpath() { + _impl_.directpath_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline const std::string& Message_VideoMessage::directpath() const { + // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.directPath) + return _internal_directpath(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_VideoMessage::set_directpath(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.directpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.directPath) +} +inline std::string* Message_VideoMessage::mutable_directpath() { + std::string* _s = _internal_mutable_directpath(); + // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.directPath) + return _s; +} +inline const std::string& Message_VideoMessage::_internal_directpath() const { + return _impl_.directpath_.Get(); +} +inline void Message_VideoMessage::_internal_set_directpath(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.directpath_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_VideoMessage::_internal_mutable_directpath() { + _impl_._has_bits_[0] |= 0x00000040u; + return _impl_.directpath_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_VideoMessage::release_directpath() { + // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.directPath) + if (!_internal_has_directpath()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000040u; + auto* p = _impl_.directpath_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.directpath_.IsDefault()) { + _impl_.directpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_VideoMessage::set_allocated_directpath(std::string* directpath) { + if (directpath != nullptr) { + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.directpath_.IsDefault()) { + _impl_.directpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.directPath) +} + +// optional int64 mediaKeyTimestamp = 14; +inline bool Message_VideoMessage::_internal_has_mediakeytimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0; + return value; +} +inline bool Message_VideoMessage::has_mediakeytimestamp() const { + return _internal_has_mediakeytimestamp(); +} +inline void Message_VideoMessage::clear_mediakeytimestamp() { + _impl_.mediakeytimestamp_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00100000u; +} +inline int64_t Message_VideoMessage::_internal_mediakeytimestamp() const { + return _impl_.mediakeytimestamp_; +} +inline int64_t Message_VideoMessage::mediakeytimestamp() const { + // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.mediaKeyTimestamp) + return _internal_mediakeytimestamp(); +} +inline void Message_VideoMessage::_internal_set_mediakeytimestamp(int64_t value) { + _impl_._has_bits_[0] |= 0x00100000u; + _impl_.mediakeytimestamp_ = value; +} +inline void Message_VideoMessage::set_mediakeytimestamp(int64_t value) { + _internal_set_mediakeytimestamp(value); + // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.mediaKeyTimestamp) +} + +// optional bytes jpegThumbnail = 16; +inline bool Message_VideoMessage::_internal_has_jpegthumbnail() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool Message_VideoMessage::has_jpegthumbnail() const { + return _internal_has_jpegthumbnail(); +} +inline void Message_VideoMessage::clear_jpegthumbnail() { + _impl_.jpegthumbnail_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline const std::string& Message_VideoMessage::jpegthumbnail() const { + // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.jpegThumbnail) + return _internal_jpegthumbnail(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_VideoMessage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.jpegthumbnail_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.jpegThumbnail) +} +inline std::string* Message_VideoMessage::mutable_jpegthumbnail() { + std::string* _s = _internal_mutable_jpegthumbnail(); + // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.jpegThumbnail) + return _s; +} +inline const std::string& Message_VideoMessage::_internal_jpegthumbnail() const { + return _impl_.jpegthumbnail_.Get(); +} +inline void Message_VideoMessage::_internal_set_jpegthumbnail(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_VideoMessage::_internal_mutable_jpegthumbnail() { + _impl_._has_bits_[0] |= 0x00000080u; + return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_VideoMessage::release_jpegthumbnail() { + // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.jpegThumbnail) + if (!_internal_has_jpegthumbnail()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000080u; + auto* p = _impl_.jpegthumbnail_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.jpegthumbnail_.IsDefault()) { + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_VideoMessage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) { + if (jpegthumbnail != nullptr) { + _impl_._has_bits_[0] |= 0x00000080u; + } else { + _impl_._has_bits_[0] &= ~0x00000080u; + } + _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.jpegthumbnail_.IsDefault()) { + _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.jpegThumbnail) +} + +// optional .proto.ContextInfo contextInfo = 17; +inline bool Message_VideoMessage::_internal_has_contextinfo() const { + bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); + return value; +} +inline bool Message_VideoMessage::has_contextinfo() const { + return _internal_has_contextinfo(); +} +inline void Message_VideoMessage::clear_contextinfo() { + if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); + _impl_._has_bits_[0] &= ~0x00002000u; +} +inline const ::proto::ContextInfo& Message_VideoMessage::_internal_contextinfo() const { + const ::proto::ContextInfo* p = _impl_.contextinfo_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ContextInfo_default_instance_); +} +inline const ::proto::ContextInfo& Message_VideoMessage::contextinfo() const { + // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.contextInfo) + return _internal_contextinfo(); +} +inline void Message_VideoMessage::unsafe_arena_set_allocated_contextinfo( + ::proto::ContextInfo* contextinfo) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); + } + _impl_.contextinfo_ = contextinfo; + if (contextinfo) { + _impl_._has_bits_[0] |= 0x00002000u; + } else { + _impl_._has_bits_[0] &= ~0x00002000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.VideoMessage.contextInfo) +} +inline ::proto::ContextInfo* Message_VideoMessage::release_contextinfo() { + _impl_._has_bits_[0] &= ~0x00002000u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ContextInfo* Message_VideoMessage::unsafe_arena_release_contextinfo() { + // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.contextInfo) + _impl_._has_bits_[0] &= ~0x00002000u; + ::proto::ContextInfo* temp = _impl_.contextinfo_; + _impl_.contextinfo_ = nullptr; + return temp; +} +inline ::proto::ContextInfo* Message_VideoMessage::_internal_mutable_contextinfo() { + _impl_._has_bits_[0] |= 0x00002000u; + if (_impl_.contextinfo_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); + _impl_.contextinfo_ = p; + } + return _impl_.contextinfo_; +} +inline ::proto::ContextInfo* Message_VideoMessage::mutable_contextinfo() { + ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); + // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.contextInfo) + return _msg; +} +inline void Message_VideoMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.contextinfo_; + } + if (contextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); + if (message_arena != submessage_arena) { + contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, contextinfo, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00002000u; + } else { + _impl_._has_bits_[0] &= ~0x00002000u; + } + _impl_.contextinfo_ = contextinfo; + // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.contextInfo) +} + +// optional bytes streamingSidecar = 18; +inline bool Message_VideoMessage::_internal_has_streamingsidecar() const { + bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool Message_VideoMessage::has_streamingsidecar() const { + return _internal_has_streamingsidecar(); +} +inline void Message_VideoMessage::clear_streamingsidecar() { + _impl_.streamingsidecar_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000100u; +} +inline const std::string& Message_VideoMessage::streamingsidecar() const { + // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.streamingSidecar) + return _internal_streamingsidecar(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_VideoMessage::set_streamingsidecar(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.streamingsidecar_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.streamingSidecar) +} +inline std::string* Message_VideoMessage::mutable_streamingsidecar() { + std::string* _s = _internal_mutable_streamingsidecar(); + // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.streamingSidecar) + return _s; +} +inline const std::string& Message_VideoMessage::_internal_streamingsidecar() const { + return _impl_.streamingsidecar_.Get(); +} +inline void Message_VideoMessage::_internal_set_streamingsidecar(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.streamingsidecar_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_VideoMessage::_internal_mutable_streamingsidecar() { + _impl_._has_bits_[0] |= 0x00000100u; + return _impl_.streamingsidecar_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_VideoMessage::release_streamingsidecar() { + // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.streamingSidecar) + if (!_internal_has_streamingsidecar()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000100u; + auto* p = _impl_.streamingsidecar_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.streamingsidecar_.IsDefault()) { + _impl_.streamingsidecar_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_VideoMessage::set_allocated_streamingsidecar(std::string* streamingsidecar) { + if (streamingsidecar != nullptr) { + _impl_._has_bits_[0] |= 0x00000100u; + } else { + _impl_._has_bits_[0] &= ~0x00000100u; + } + _impl_.streamingsidecar_.SetAllocated(streamingsidecar, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.streamingsidecar_.IsDefault()) { + _impl_.streamingsidecar_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.streamingSidecar) +} + +// optional .proto.Message.VideoMessage.Attribution gifAttribution = 19; +inline bool Message_VideoMessage::_internal_has_gifattribution() const { + bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0; + return value; +} +inline bool Message_VideoMessage::has_gifattribution() const { + return _internal_has_gifattribution(); +} +inline void Message_VideoMessage::clear_gifattribution() { + _impl_.gifattribution_ = 0; + _impl_._has_bits_[0] &= ~0x00200000u; +} +inline ::proto::Message_VideoMessage_Attribution Message_VideoMessage::_internal_gifattribution() const { + return static_cast< ::proto::Message_VideoMessage_Attribution >(_impl_.gifattribution_); +} +inline ::proto::Message_VideoMessage_Attribution Message_VideoMessage::gifattribution() const { + // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.gifAttribution) + return _internal_gifattribution(); +} +inline void Message_VideoMessage::_internal_set_gifattribution(::proto::Message_VideoMessage_Attribution value) { + assert(::proto::Message_VideoMessage_Attribution_IsValid(value)); + _impl_._has_bits_[0] |= 0x00200000u; + _impl_.gifattribution_ = value; +} +inline void Message_VideoMessage::set_gifattribution(::proto::Message_VideoMessage_Attribution value) { + _internal_set_gifattribution(value); + // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.gifAttribution) +} + +// optional bool viewOnce = 20; +inline bool Message_VideoMessage::_internal_has_viewonce() const { + bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0; + return value; +} +inline bool Message_VideoMessage::has_viewonce() const { + return _internal_has_viewonce(); +} +inline void Message_VideoMessage::clear_viewonce() { + _impl_.viewonce_ = false; + _impl_._has_bits_[0] &= ~0x00080000u; +} +inline bool Message_VideoMessage::_internal_viewonce() const { + return _impl_.viewonce_; +} +inline bool Message_VideoMessage::viewonce() const { + // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.viewOnce) + return _internal_viewonce(); +} +inline void Message_VideoMessage::_internal_set_viewonce(bool value) { + _impl_._has_bits_[0] |= 0x00080000u; + _impl_.viewonce_ = value; +} +inline void Message_VideoMessage::set_viewonce(bool value) { + _internal_set_viewonce(value); + // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.viewOnce) +} + +// optional string thumbnailDirectPath = 21; +inline bool Message_VideoMessage::_internal_has_thumbnaildirectpath() const { + bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool Message_VideoMessage::has_thumbnaildirectpath() const { + return _internal_has_thumbnaildirectpath(); +} +inline void Message_VideoMessage::clear_thumbnaildirectpath() { + _impl_.thumbnaildirectpath_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000200u; +} +inline const std::string& Message_VideoMessage::thumbnaildirectpath() const { + // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.thumbnailDirectPath) + return _internal_thumbnaildirectpath(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_VideoMessage::set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.thumbnaildirectpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.thumbnailDirectPath) +} +inline std::string* Message_VideoMessage::mutable_thumbnaildirectpath() { + std::string* _s = _internal_mutable_thumbnaildirectpath(); + // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.thumbnailDirectPath) + return _s; +} +inline const std::string& Message_VideoMessage::_internal_thumbnaildirectpath() const { + return _impl_.thumbnaildirectpath_.Get(); +} +inline void Message_VideoMessage::_internal_set_thumbnaildirectpath(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.thumbnaildirectpath_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_VideoMessage::_internal_mutable_thumbnaildirectpath() { + _impl_._has_bits_[0] |= 0x00000200u; + return _impl_.thumbnaildirectpath_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_VideoMessage::release_thumbnaildirectpath() { + // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.thumbnailDirectPath) + if (!_internal_has_thumbnaildirectpath()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000200u; + auto* p = _impl_.thumbnaildirectpath_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.thumbnaildirectpath_.IsDefault()) { + _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_VideoMessage::set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath) { + if (thumbnaildirectpath != nullptr) { + _impl_._has_bits_[0] |= 0x00000200u; + } else { + _impl_._has_bits_[0] &= ~0x00000200u; + } + _impl_.thumbnaildirectpath_.SetAllocated(thumbnaildirectpath, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.thumbnaildirectpath_.IsDefault()) { + _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.thumbnailDirectPath) +} + +// optional bytes thumbnailSha256 = 22; +inline bool Message_VideoMessage::_internal_has_thumbnailsha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool Message_VideoMessage::has_thumbnailsha256() const { + return _internal_has_thumbnailsha256(); +} +inline void Message_VideoMessage::clear_thumbnailsha256() { + _impl_.thumbnailsha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000400u; +} +inline const std::string& Message_VideoMessage::thumbnailsha256() const { + // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.thumbnailSha256) + return _internal_thumbnailsha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_VideoMessage::set_thumbnailsha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000400u; + _impl_.thumbnailsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.thumbnailSha256) +} +inline std::string* Message_VideoMessage::mutable_thumbnailsha256() { + std::string* _s = _internal_mutable_thumbnailsha256(); + // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.thumbnailSha256) + return _s; +} +inline const std::string& Message_VideoMessage::_internal_thumbnailsha256() const { + return _impl_.thumbnailsha256_.Get(); +} +inline void Message_VideoMessage::_internal_set_thumbnailsha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000400u; + _impl_.thumbnailsha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_VideoMessage::_internal_mutable_thumbnailsha256() { + _impl_._has_bits_[0] |= 0x00000400u; + return _impl_.thumbnailsha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_VideoMessage::release_thumbnailsha256() { + // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.thumbnailSha256) + if (!_internal_has_thumbnailsha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000400u; + auto* p = _impl_.thumbnailsha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.thumbnailsha256_.IsDefault()) { + _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_VideoMessage::set_allocated_thumbnailsha256(std::string* thumbnailsha256) { + if (thumbnailsha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000400u; + } else { + _impl_._has_bits_[0] &= ~0x00000400u; + } + _impl_.thumbnailsha256_.SetAllocated(thumbnailsha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.thumbnailsha256_.IsDefault()) { + _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.thumbnailSha256) +} + +// optional bytes thumbnailEncSha256 = 23; +inline bool Message_VideoMessage::_internal_has_thumbnailencsha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; + return value; +} +inline bool Message_VideoMessage::has_thumbnailencsha256() const { + return _internal_has_thumbnailencsha256(); +} +inline void Message_VideoMessage::clear_thumbnailencsha256() { + _impl_.thumbnailencsha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000800u; +} +inline const std::string& Message_VideoMessage::thumbnailencsha256() const { + // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.thumbnailEncSha256) + return _internal_thumbnailencsha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_VideoMessage::set_thumbnailencsha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000800u; + _impl_.thumbnailencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.thumbnailEncSha256) +} +inline std::string* Message_VideoMessage::mutable_thumbnailencsha256() { + std::string* _s = _internal_mutable_thumbnailencsha256(); + // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.thumbnailEncSha256) + return _s; +} +inline const std::string& Message_VideoMessage::_internal_thumbnailencsha256() const { + return _impl_.thumbnailencsha256_.Get(); +} +inline void Message_VideoMessage::_internal_set_thumbnailencsha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000800u; + _impl_.thumbnailencsha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_VideoMessage::_internal_mutable_thumbnailencsha256() { + _impl_._has_bits_[0] |= 0x00000800u; + return _impl_.thumbnailencsha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_VideoMessage::release_thumbnailencsha256() { + // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.thumbnailEncSha256) + if (!_internal_has_thumbnailencsha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000800u; + auto* p = _impl_.thumbnailencsha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.thumbnailencsha256_.IsDefault()) { + _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_VideoMessage::set_allocated_thumbnailencsha256(std::string* thumbnailencsha256) { + if (thumbnailencsha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000800u; + } else { + _impl_._has_bits_[0] &= ~0x00000800u; + } + _impl_.thumbnailencsha256_.SetAllocated(thumbnailencsha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.thumbnailencsha256_.IsDefault()) { + _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.thumbnailEncSha256) +} + +// optional string staticUrl = 24; +inline bool Message_VideoMessage::_internal_has_staticurl() const { + bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; + return value; +} +inline bool Message_VideoMessage::has_staticurl() const { + return _internal_has_staticurl(); +} +inline void Message_VideoMessage::clear_staticurl() { + _impl_.staticurl_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00001000u; +} +inline const std::string& Message_VideoMessage::staticurl() const { + // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.staticUrl) + return _internal_staticurl(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message_VideoMessage::set_staticurl(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00001000u; + _impl_.staticurl_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.staticUrl) +} +inline std::string* Message_VideoMessage::mutable_staticurl() { + std::string* _s = _internal_mutable_staticurl(); + // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.staticUrl) + return _s; +} +inline const std::string& Message_VideoMessage::_internal_staticurl() const { + return _impl_.staticurl_.Get(); +} +inline void Message_VideoMessage::_internal_set_staticurl(const std::string& value) { + _impl_._has_bits_[0] |= 0x00001000u; + _impl_.staticurl_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message_VideoMessage::_internal_mutable_staticurl() { + _impl_._has_bits_[0] |= 0x00001000u; + return _impl_.staticurl_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message_VideoMessage::release_staticurl() { + // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.staticUrl) + if (!_internal_has_staticurl()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00001000u; + auto* p = _impl_.staticurl_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.staticurl_.IsDefault()) { + _impl_.staticurl_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message_VideoMessage::set_allocated_staticurl(std::string* staticurl) { + if (staticurl != nullptr) { + _impl_._has_bits_[0] |= 0x00001000u; + } else { + _impl_._has_bits_[0] &= ~0x00001000u; + } + _impl_.staticurl_.SetAllocated(staticurl, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.staticurl_.IsDefault()) { + _impl_.staticurl_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.staticUrl) +} + +// ------------------------------------------------------------------- + +// Message + +// optional string conversation = 1; +inline bool Message::_internal_has_conversation() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Message::has_conversation() const { + return _internal_has_conversation(); +} +inline void Message::clear_conversation() { + _impl_.conversation_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Message::conversation() const { + // @@protoc_insertion_point(field_get:proto.Message.conversation) + return _internal_conversation(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Message::set_conversation(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.conversation_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Message.conversation) +} +inline std::string* Message::mutable_conversation() { + std::string* _s = _internal_mutable_conversation(); + // @@protoc_insertion_point(field_mutable:proto.Message.conversation) + return _s; +} +inline const std::string& Message::_internal_conversation() const { + return _impl_.conversation_.Get(); +} +inline void Message::_internal_set_conversation(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.conversation_.Set(value, GetArenaForAllocation()); +} +inline std::string* Message::_internal_mutable_conversation() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.conversation_.Mutable(GetArenaForAllocation()); +} +inline std::string* Message::release_conversation() { + // @@protoc_insertion_point(field_release:proto.Message.conversation) + if (!_internal_has_conversation()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.conversation_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.conversation_.IsDefault()) { + _impl_.conversation_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Message::set_allocated_conversation(std::string* conversation) { + if (conversation != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.conversation_.SetAllocated(conversation, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.conversation_.IsDefault()) { + _impl_.conversation_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Message.conversation) +} + +// optional .proto.Message.SenderKeyDistributionMessage senderKeyDistributionMessage = 2; +inline bool Message::_internal_has_senderkeydistributionmessage() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.senderkeydistributionmessage_ != nullptr); + return value; +} +inline bool Message::has_senderkeydistributionmessage() const { + return _internal_has_senderkeydistributionmessage(); +} +inline void Message::clear_senderkeydistributionmessage() { + if (_impl_.senderkeydistributionmessage_ != nullptr) _impl_.senderkeydistributionmessage_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::Message_SenderKeyDistributionMessage& Message::_internal_senderkeydistributionmessage() const { + const ::proto::Message_SenderKeyDistributionMessage* p = _impl_.senderkeydistributionmessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_SenderKeyDistributionMessage_default_instance_); +} +inline const ::proto::Message_SenderKeyDistributionMessage& Message::senderkeydistributionmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.senderKeyDistributionMessage) + return _internal_senderkeydistributionmessage(); +} +inline void Message::unsafe_arena_set_allocated_senderkeydistributionmessage( + ::proto::Message_SenderKeyDistributionMessage* senderkeydistributionmessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.senderkeydistributionmessage_); + } + _impl_.senderkeydistributionmessage_ = senderkeydistributionmessage; + if (senderkeydistributionmessage) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.senderKeyDistributionMessage) +} +inline ::proto::Message_SenderKeyDistributionMessage* Message::release_senderkeydistributionmessage() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::Message_SenderKeyDistributionMessage* temp = _impl_.senderkeydistributionmessage_; + _impl_.senderkeydistributionmessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_SenderKeyDistributionMessage* Message::unsafe_arena_release_senderkeydistributionmessage() { + // @@protoc_insertion_point(field_release:proto.Message.senderKeyDistributionMessage) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::Message_SenderKeyDistributionMessage* temp = _impl_.senderkeydistributionmessage_; + _impl_.senderkeydistributionmessage_ = nullptr; + return temp; +} +inline ::proto::Message_SenderKeyDistributionMessage* Message::_internal_mutable_senderkeydistributionmessage() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.senderkeydistributionmessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_SenderKeyDistributionMessage>(GetArenaForAllocation()); + _impl_.senderkeydistributionmessage_ = p; + } + return _impl_.senderkeydistributionmessage_; +} +inline ::proto::Message_SenderKeyDistributionMessage* Message::mutable_senderkeydistributionmessage() { + ::proto::Message_SenderKeyDistributionMessage* _msg = _internal_mutable_senderkeydistributionmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.senderKeyDistributionMessage) + return _msg; +} +inline void Message::set_allocated_senderkeydistributionmessage(::proto::Message_SenderKeyDistributionMessage* senderkeydistributionmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.senderkeydistributionmessage_; + } + if (senderkeydistributionmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(senderkeydistributionmessage); + if (message_arena != submessage_arena) { + senderkeydistributionmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, senderkeydistributionmessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.senderkeydistributionmessage_ = senderkeydistributionmessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.senderKeyDistributionMessage) +} + +// optional .proto.Message.ImageMessage imageMessage = 3; +inline bool Message::_internal_has_imagemessage() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.imagemessage_ != nullptr); + return value; +} +inline bool Message::has_imagemessage() const { + return _internal_has_imagemessage(); +} +inline void Message::clear_imagemessage() { + if (_impl_.imagemessage_ != nullptr) _impl_.imagemessage_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::proto::Message_ImageMessage& Message::_internal_imagemessage() const { + const ::proto::Message_ImageMessage* p = _impl_.imagemessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_ImageMessage_default_instance_); +} +inline const ::proto::Message_ImageMessage& Message::imagemessage() const { + // @@protoc_insertion_point(field_get:proto.Message.imageMessage) + return _internal_imagemessage(); +} +inline void Message::unsafe_arena_set_allocated_imagemessage( + ::proto::Message_ImageMessage* imagemessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.imagemessage_); + } + _impl_.imagemessage_ = imagemessage; + if (imagemessage) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.imageMessage) +} +inline ::proto::Message_ImageMessage* Message::release_imagemessage() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::Message_ImageMessage* temp = _impl_.imagemessage_; + _impl_.imagemessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_ImageMessage* Message::unsafe_arena_release_imagemessage() { + // @@protoc_insertion_point(field_release:proto.Message.imageMessage) + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::Message_ImageMessage* temp = _impl_.imagemessage_; + _impl_.imagemessage_ = nullptr; + return temp; +} +inline ::proto::Message_ImageMessage* Message::_internal_mutable_imagemessage() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.imagemessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_ImageMessage>(GetArenaForAllocation()); + _impl_.imagemessage_ = p; + } + return _impl_.imagemessage_; +} +inline ::proto::Message_ImageMessage* Message::mutable_imagemessage() { + ::proto::Message_ImageMessage* _msg = _internal_mutable_imagemessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.imageMessage) + return _msg; +} +inline void Message::set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.imagemessage_; + } + if (imagemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(imagemessage); + if (message_arena != submessage_arena) { + imagemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, imagemessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.imagemessage_ = imagemessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.imageMessage) +} + +// optional .proto.Message.ContactMessage contactMessage = 4; +inline bool Message::_internal_has_contactmessage() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || _impl_.contactmessage_ != nullptr); + return value; +} +inline bool Message::has_contactmessage() const { + return _internal_has_contactmessage(); +} +inline void Message::clear_contactmessage() { + if (_impl_.contactmessage_ != nullptr) _impl_.contactmessage_->Clear(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const ::proto::Message_ContactMessage& Message::_internal_contactmessage() const { + const ::proto::Message_ContactMessage* p = _impl_.contactmessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_ContactMessage_default_instance_); +} +inline const ::proto::Message_ContactMessage& Message::contactmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.contactMessage) + return _internal_contactmessage(); +} +inline void Message::unsafe_arena_set_allocated_contactmessage( + ::proto::Message_ContactMessage* contactmessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contactmessage_); + } + _impl_.contactmessage_ = contactmessage; + if (contactmessage) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.contactMessage) +} +inline ::proto::Message_ContactMessage* Message::release_contactmessage() { + _impl_._has_bits_[0] &= ~0x00000008u; + ::proto::Message_ContactMessage* temp = _impl_.contactmessage_; + _impl_.contactmessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_ContactMessage* Message::unsafe_arena_release_contactmessage() { + // @@protoc_insertion_point(field_release:proto.Message.contactMessage) + _impl_._has_bits_[0] &= ~0x00000008u; + ::proto::Message_ContactMessage* temp = _impl_.contactmessage_; + _impl_.contactmessage_ = nullptr; + return temp; +} +inline ::proto::Message_ContactMessage* Message::_internal_mutable_contactmessage() { + _impl_._has_bits_[0] |= 0x00000008u; + if (_impl_.contactmessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_ContactMessage>(GetArenaForAllocation()); + _impl_.contactmessage_ = p; + } + return _impl_.contactmessage_; +} +inline ::proto::Message_ContactMessage* Message::mutable_contactmessage() { + ::proto::Message_ContactMessage* _msg = _internal_mutable_contactmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.contactMessage) + return _msg; +} +inline void Message::set_allocated_contactmessage(::proto::Message_ContactMessage* contactmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.contactmessage_; + } + if (contactmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contactmessage); + if (message_arena != submessage_arena) { + contactmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, contactmessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.contactmessage_ = contactmessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.contactMessage) +} + +// optional .proto.Message.LocationMessage locationMessage = 5; +inline bool Message::_internal_has_locationmessage() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + PROTOBUF_ASSUME(!value || _impl_.locationmessage_ != nullptr); + return value; +} +inline bool Message::has_locationmessage() const { + return _internal_has_locationmessage(); +} +inline void Message::clear_locationmessage() { + if (_impl_.locationmessage_ != nullptr) _impl_.locationmessage_->Clear(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const ::proto::Message_LocationMessage& Message::_internal_locationmessage() const { + const ::proto::Message_LocationMessage* p = _impl_.locationmessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_LocationMessage_default_instance_); +} +inline const ::proto::Message_LocationMessage& Message::locationmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.locationMessage) + return _internal_locationmessage(); +} +inline void Message::unsafe_arena_set_allocated_locationmessage( + ::proto::Message_LocationMessage* locationmessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.locationmessage_); + } + _impl_.locationmessage_ = locationmessage; + if (locationmessage) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.locationMessage) +} +inline ::proto::Message_LocationMessage* Message::release_locationmessage() { + _impl_._has_bits_[0] &= ~0x00000010u; + ::proto::Message_LocationMessage* temp = _impl_.locationmessage_; + _impl_.locationmessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_LocationMessage* Message::unsafe_arena_release_locationmessage() { + // @@protoc_insertion_point(field_release:proto.Message.locationMessage) + _impl_._has_bits_[0] &= ~0x00000010u; + ::proto::Message_LocationMessage* temp = _impl_.locationmessage_; + _impl_.locationmessage_ = nullptr; + return temp; +} +inline ::proto::Message_LocationMessage* Message::_internal_mutable_locationmessage() { + _impl_._has_bits_[0] |= 0x00000010u; + if (_impl_.locationmessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_LocationMessage>(GetArenaForAllocation()); + _impl_.locationmessage_ = p; + } + return _impl_.locationmessage_; +} +inline ::proto::Message_LocationMessage* Message::mutable_locationmessage() { + ::proto::Message_LocationMessage* _msg = _internal_mutable_locationmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.locationMessage) + return _msg; +} +inline void Message::set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.locationmessage_; + } + if (locationmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(locationmessage); + if (message_arena != submessage_arena) { + locationmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, locationmessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.locationmessage_ = locationmessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.locationMessage) +} + +// optional .proto.Message.ExtendedTextMessage extendedTextMessage = 6; +inline bool Message::_internal_has_extendedtextmessage() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + PROTOBUF_ASSUME(!value || _impl_.extendedtextmessage_ != nullptr); + return value; +} +inline bool Message::has_extendedtextmessage() const { + return _internal_has_extendedtextmessage(); +} +inline void Message::clear_extendedtextmessage() { + if (_impl_.extendedtextmessage_ != nullptr) _impl_.extendedtextmessage_->Clear(); + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline const ::proto::Message_ExtendedTextMessage& Message::_internal_extendedtextmessage() const { + const ::proto::Message_ExtendedTextMessage* p = _impl_.extendedtextmessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_ExtendedTextMessage_default_instance_); +} +inline const ::proto::Message_ExtendedTextMessage& Message::extendedtextmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.extendedTextMessage) + return _internal_extendedtextmessage(); +} +inline void Message::unsafe_arena_set_allocated_extendedtextmessage( + ::proto::Message_ExtendedTextMessage* extendedtextmessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.extendedtextmessage_); + } + _impl_.extendedtextmessage_ = extendedtextmessage; + if (extendedtextmessage) { + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.extendedTextMessage) +} +inline ::proto::Message_ExtendedTextMessage* Message::release_extendedtextmessage() { + _impl_._has_bits_[0] &= ~0x00000020u; + ::proto::Message_ExtendedTextMessage* temp = _impl_.extendedtextmessage_; + _impl_.extendedtextmessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_ExtendedTextMessage* Message::unsafe_arena_release_extendedtextmessage() { + // @@protoc_insertion_point(field_release:proto.Message.extendedTextMessage) + _impl_._has_bits_[0] &= ~0x00000020u; + ::proto::Message_ExtendedTextMessage* temp = _impl_.extendedtextmessage_; + _impl_.extendedtextmessage_ = nullptr; + return temp; +} +inline ::proto::Message_ExtendedTextMessage* Message::_internal_mutable_extendedtextmessage() { + _impl_._has_bits_[0] |= 0x00000020u; + if (_impl_.extendedtextmessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_ExtendedTextMessage>(GetArenaForAllocation()); + _impl_.extendedtextmessage_ = p; + } + return _impl_.extendedtextmessage_; +} +inline ::proto::Message_ExtendedTextMessage* Message::mutable_extendedtextmessage() { + ::proto::Message_ExtendedTextMessage* _msg = _internal_mutable_extendedtextmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.extendedTextMessage) + return _msg; +} +inline void Message::set_allocated_extendedtextmessage(::proto::Message_ExtendedTextMessage* extendedtextmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.extendedtextmessage_; + } + if (extendedtextmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(extendedtextmessage); + if (message_arena != submessage_arena) { + extendedtextmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, extendedtextmessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + _impl_.extendedtextmessage_ = extendedtextmessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.extendedTextMessage) +} + +// optional .proto.Message.DocumentMessage documentMessage = 7; +inline bool Message::_internal_has_documentmessage() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + PROTOBUF_ASSUME(!value || _impl_.documentmessage_ != nullptr); + return value; +} +inline bool Message::has_documentmessage() const { + return _internal_has_documentmessage(); +} +inline void Message::clear_documentmessage() { + if (_impl_.documentmessage_ != nullptr) _impl_.documentmessage_->Clear(); + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline const ::proto::Message_DocumentMessage& Message::_internal_documentmessage() const { + const ::proto::Message_DocumentMessage* p = _impl_.documentmessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_DocumentMessage_default_instance_); +} +inline const ::proto::Message_DocumentMessage& Message::documentmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.documentMessage) + return _internal_documentmessage(); +} +inline void Message::unsafe_arena_set_allocated_documentmessage( + ::proto::Message_DocumentMessage* documentmessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.documentmessage_); + } + _impl_.documentmessage_ = documentmessage; + if (documentmessage) { + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.documentMessage) +} +inline ::proto::Message_DocumentMessage* Message::release_documentmessage() { + _impl_._has_bits_[0] &= ~0x00000040u; + ::proto::Message_DocumentMessage* temp = _impl_.documentmessage_; + _impl_.documentmessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_DocumentMessage* Message::unsafe_arena_release_documentmessage() { + // @@protoc_insertion_point(field_release:proto.Message.documentMessage) + _impl_._has_bits_[0] &= ~0x00000040u; + ::proto::Message_DocumentMessage* temp = _impl_.documentmessage_; + _impl_.documentmessage_ = nullptr; + return temp; +} +inline ::proto::Message_DocumentMessage* Message::_internal_mutable_documentmessage() { + _impl_._has_bits_[0] |= 0x00000040u; + if (_impl_.documentmessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_DocumentMessage>(GetArenaForAllocation()); + _impl_.documentmessage_ = p; + } + return _impl_.documentmessage_; +} +inline ::proto::Message_DocumentMessage* Message::mutable_documentmessage() { + ::proto::Message_DocumentMessage* _msg = _internal_mutable_documentmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.documentMessage) + return _msg; +} +inline void Message::set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.documentmessage_; + } + if (documentmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(documentmessage); + if (message_arena != submessage_arena) { + documentmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, documentmessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + _impl_.documentmessage_ = documentmessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.documentMessage) +} + +// optional .proto.Message.AudioMessage audioMessage = 8; +inline bool Message::_internal_has_audiomessage() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + PROTOBUF_ASSUME(!value || _impl_.audiomessage_ != nullptr); + return value; +} +inline bool Message::has_audiomessage() const { + return _internal_has_audiomessage(); +} +inline void Message::clear_audiomessage() { + if (_impl_.audiomessage_ != nullptr) _impl_.audiomessage_->Clear(); + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline const ::proto::Message_AudioMessage& Message::_internal_audiomessage() const { + const ::proto::Message_AudioMessage* p = _impl_.audiomessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_AudioMessage_default_instance_); +} +inline const ::proto::Message_AudioMessage& Message::audiomessage() const { + // @@protoc_insertion_point(field_get:proto.Message.audioMessage) + return _internal_audiomessage(); +} +inline void Message::unsafe_arena_set_allocated_audiomessage( + ::proto::Message_AudioMessage* audiomessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.audiomessage_); + } + _impl_.audiomessage_ = audiomessage; + if (audiomessage) { + _impl_._has_bits_[0] |= 0x00000080u; + } else { + _impl_._has_bits_[0] &= ~0x00000080u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.audioMessage) +} +inline ::proto::Message_AudioMessage* Message::release_audiomessage() { + _impl_._has_bits_[0] &= ~0x00000080u; + ::proto::Message_AudioMessage* temp = _impl_.audiomessage_; + _impl_.audiomessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_AudioMessage* Message::unsafe_arena_release_audiomessage() { + // @@protoc_insertion_point(field_release:proto.Message.audioMessage) + _impl_._has_bits_[0] &= ~0x00000080u; + ::proto::Message_AudioMessage* temp = _impl_.audiomessage_; + _impl_.audiomessage_ = nullptr; + return temp; +} +inline ::proto::Message_AudioMessage* Message::_internal_mutable_audiomessage() { + _impl_._has_bits_[0] |= 0x00000080u; + if (_impl_.audiomessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_AudioMessage>(GetArenaForAllocation()); + _impl_.audiomessage_ = p; + } + return _impl_.audiomessage_; +} +inline ::proto::Message_AudioMessage* Message::mutable_audiomessage() { + ::proto::Message_AudioMessage* _msg = _internal_mutable_audiomessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.audioMessage) + return _msg; +} +inline void Message::set_allocated_audiomessage(::proto::Message_AudioMessage* audiomessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.audiomessage_; + } + if (audiomessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(audiomessage); + if (message_arena != submessage_arena) { + audiomessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, audiomessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000080u; + } else { + _impl_._has_bits_[0] &= ~0x00000080u; + } + _impl_.audiomessage_ = audiomessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.audioMessage) +} + +// optional .proto.Message.VideoMessage videoMessage = 9; +inline bool Message::_internal_has_videomessage() const { + bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; + PROTOBUF_ASSUME(!value || _impl_.videomessage_ != nullptr); + return value; +} +inline bool Message::has_videomessage() const { + return _internal_has_videomessage(); +} +inline void Message::clear_videomessage() { + if (_impl_.videomessage_ != nullptr) _impl_.videomessage_->Clear(); + _impl_._has_bits_[0] &= ~0x00000100u; +} +inline const ::proto::Message_VideoMessage& Message::_internal_videomessage() const { + const ::proto::Message_VideoMessage* p = _impl_.videomessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_VideoMessage_default_instance_); +} +inline const ::proto::Message_VideoMessage& Message::videomessage() const { + // @@protoc_insertion_point(field_get:proto.Message.videoMessage) + return _internal_videomessage(); +} +inline void Message::unsafe_arena_set_allocated_videomessage( + ::proto::Message_VideoMessage* videomessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.videomessage_); + } + _impl_.videomessage_ = videomessage; + if (videomessage) { + _impl_._has_bits_[0] |= 0x00000100u; + } else { + _impl_._has_bits_[0] &= ~0x00000100u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.videoMessage) +} +inline ::proto::Message_VideoMessage* Message::release_videomessage() { + _impl_._has_bits_[0] &= ~0x00000100u; + ::proto::Message_VideoMessage* temp = _impl_.videomessage_; + _impl_.videomessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_VideoMessage* Message::unsafe_arena_release_videomessage() { + // @@protoc_insertion_point(field_release:proto.Message.videoMessage) + _impl_._has_bits_[0] &= ~0x00000100u; + ::proto::Message_VideoMessage* temp = _impl_.videomessage_; + _impl_.videomessage_ = nullptr; + return temp; +} +inline ::proto::Message_VideoMessage* Message::_internal_mutable_videomessage() { + _impl_._has_bits_[0] |= 0x00000100u; + if (_impl_.videomessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_VideoMessage>(GetArenaForAllocation()); + _impl_.videomessage_ = p; + } + return _impl_.videomessage_; +} +inline ::proto::Message_VideoMessage* Message::mutable_videomessage() { + ::proto::Message_VideoMessage* _msg = _internal_mutable_videomessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.videoMessage) + return _msg; +} +inline void Message::set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.videomessage_; + } + if (videomessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(videomessage); + if (message_arena != submessage_arena) { + videomessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, videomessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000100u; + } else { + _impl_._has_bits_[0] &= ~0x00000100u; + } + _impl_.videomessage_ = videomessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.videoMessage) +} + +// optional .proto.Message.Call call = 10; +inline bool Message::_internal_has_call() const { + bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; + PROTOBUF_ASSUME(!value || _impl_.call_ != nullptr); + return value; +} +inline bool Message::has_call() const { + return _internal_has_call(); +} +inline void Message::clear_call() { + if (_impl_.call_ != nullptr) _impl_.call_->Clear(); + _impl_._has_bits_[0] &= ~0x00000200u; +} +inline const ::proto::Message_Call& Message::_internal_call() const { + const ::proto::Message_Call* p = _impl_.call_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_Call_default_instance_); +} +inline const ::proto::Message_Call& Message::call() const { + // @@protoc_insertion_point(field_get:proto.Message.call) + return _internal_call(); +} +inline void Message::unsafe_arena_set_allocated_call( + ::proto::Message_Call* call) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.call_); + } + _impl_.call_ = call; + if (call) { + _impl_._has_bits_[0] |= 0x00000200u; + } else { + _impl_._has_bits_[0] &= ~0x00000200u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.call) +} +inline ::proto::Message_Call* Message::release_call() { + _impl_._has_bits_[0] &= ~0x00000200u; + ::proto::Message_Call* temp = _impl_.call_; + _impl_.call_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_Call* Message::unsafe_arena_release_call() { + // @@protoc_insertion_point(field_release:proto.Message.call) + _impl_._has_bits_[0] &= ~0x00000200u; + ::proto::Message_Call* temp = _impl_.call_; + _impl_.call_ = nullptr; + return temp; +} +inline ::proto::Message_Call* Message::_internal_mutable_call() { + _impl_._has_bits_[0] |= 0x00000200u; + if (_impl_.call_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_Call>(GetArenaForAllocation()); + _impl_.call_ = p; + } + return _impl_.call_; +} +inline ::proto::Message_Call* Message::mutable_call() { + ::proto::Message_Call* _msg = _internal_mutable_call(); + // @@protoc_insertion_point(field_mutable:proto.Message.call) + return _msg; +} +inline void Message::set_allocated_call(::proto::Message_Call* call) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.call_; + } + if (call) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(call); + if (message_arena != submessage_arena) { + call = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, call, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000200u; + } else { + _impl_._has_bits_[0] &= ~0x00000200u; + } + _impl_.call_ = call; + // @@protoc_insertion_point(field_set_allocated:proto.Message.call) +} + +// optional .proto.Message.Chat chat = 11; +inline bool Message::_internal_has_chat() const { + bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; + PROTOBUF_ASSUME(!value || _impl_.chat_ != nullptr); + return value; +} +inline bool Message::has_chat() const { + return _internal_has_chat(); +} +inline void Message::clear_chat() { + if (_impl_.chat_ != nullptr) _impl_.chat_->Clear(); + _impl_._has_bits_[0] &= ~0x00000400u; +} +inline const ::proto::Message_Chat& Message::_internal_chat() const { + const ::proto::Message_Chat* p = _impl_.chat_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_Chat_default_instance_); +} +inline const ::proto::Message_Chat& Message::chat() const { + // @@protoc_insertion_point(field_get:proto.Message.chat) + return _internal_chat(); +} +inline void Message::unsafe_arena_set_allocated_chat( + ::proto::Message_Chat* chat) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.chat_); + } + _impl_.chat_ = chat; + if (chat) { + _impl_._has_bits_[0] |= 0x00000400u; + } else { + _impl_._has_bits_[0] &= ~0x00000400u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.chat) +} +inline ::proto::Message_Chat* Message::release_chat() { + _impl_._has_bits_[0] &= ~0x00000400u; + ::proto::Message_Chat* temp = _impl_.chat_; + _impl_.chat_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_Chat* Message::unsafe_arena_release_chat() { + // @@protoc_insertion_point(field_release:proto.Message.chat) + _impl_._has_bits_[0] &= ~0x00000400u; + ::proto::Message_Chat* temp = _impl_.chat_; + _impl_.chat_ = nullptr; + return temp; +} +inline ::proto::Message_Chat* Message::_internal_mutable_chat() { + _impl_._has_bits_[0] |= 0x00000400u; + if (_impl_.chat_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_Chat>(GetArenaForAllocation()); + _impl_.chat_ = p; + } + return _impl_.chat_; +} +inline ::proto::Message_Chat* Message::mutable_chat() { + ::proto::Message_Chat* _msg = _internal_mutable_chat(); + // @@protoc_insertion_point(field_mutable:proto.Message.chat) + return _msg; +} +inline void Message::set_allocated_chat(::proto::Message_Chat* chat) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.chat_; + } + if (chat) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(chat); + if (message_arena != submessage_arena) { + chat = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, chat, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000400u; + } else { + _impl_._has_bits_[0] &= ~0x00000400u; + } + _impl_.chat_ = chat; + // @@protoc_insertion_point(field_set_allocated:proto.Message.chat) +} + +// optional .proto.Message.ProtocolMessage protocolMessage = 12; +inline bool Message::_internal_has_protocolmessage() const { + bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; + PROTOBUF_ASSUME(!value || _impl_.protocolmessage_ != nullptr); + return value; +} +inline bool Message::has_protocolmessage() const { + return _internal_has_protocolmessage(); +} +inline void Message::clear_protocolmessage() { + if (_impl_.protocolmessage_ != nullptr) _impl_.protocolmessage_->Clear(); + _impl_._has_bits_[0] &= ~0x00000800u; +} +inline const ::proto::Message_ProtocolMessage& Message::_internal_protocolmessage() const { + const ::proto::Message_ProtocolMessage* p = _impl_.protocolmessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_ProtocolMessage_default_instance_); +} +inline const ::proto::Message_ProtocolMessage& Message::protocolmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.protocolMessage) + return _internal_protocolmessage(); +} +inline void Message::unsafe_arena_set_allocated_protocolmessage( + ::proto::Message_ProtocolMessage* protocolmessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.protocolmessage_); + } + _impl_.protocolmessage_ = protocolmessage; + if (protocolmessage) { + _impl_._has_bits_[0] |= 0x00000800u; + } else { + _impl_._has_bits_[0] &= ~0x00000800u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.protocolMessage) +} +inline ::proto::Message_ProtocolMessage* Message::release_protocolmessage() { + _impl_._has_bits_[0] &= ~0x00000800u; + ::proto::Message_ProtocolMessage* temp = _impl_.protocolmessage_; + _impl_.protocolmessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_ProtocolMessage* Message::unsafe_arena_release_protocolmessage() { + // @@protoc_insertion_point(field_release:proto.Message.protocolMessage) + _impl_._has_bits_[0] &= ~0x00000800u; + ::proto::Message_ProtocolMessage* temp = _impl_.protocolmessage_; + _impl_.protocolmessage_ = nullptr; + return temp; +} +inline ::proto::Message_ProtocolMessage* Message::_internal_mutable_protocolmessage() { + _impl_._has_bits_[0] |= 0x00000800u; + if (_impl_.protocolmessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_ProtocolMessage>(GetArenaForAllocation()); + _impl_.protocolmessage_ = p; + } + return _impl_.protocolmessage_; +} +inline ::proto::Message_ProtocolMessage* Message::mutable_protocolmessage() { + ::proto::Message_ProtocolMessage* _msg = _internal_mutable_protocolmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.protocolMessage) + return _msg; +} +inline void Message::set_allocated_protocolmessage(::proto::Message_ProtocolMessage* protocolmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.protocolmessage_; + } + if (protocolmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(protocolmessage); + if (message_arena != submessage_arena) { + protocolmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, protocolmessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000800u; + } else { + _impl_._has_bits_[0] &= ~0x00000800u; + } + _impl_.protocolmessage_ = protocolmessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.protocolMessage) +} + +// optional .proto.Message.ContactsArrayMessage contactsArrayMessage = 13; +inline bool Message::_internal_has_contactsarraymessage() const { + bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.contactsarraymessage_ != nullptr); + return value; +} +inline bool Message::has_contactsarraymessage() const { + return _internal_has_contactsarraymessage(); +} +inline void Message::clear_contactsarraymessage() { + if (_impl_.contactsarraymessage_ != nullptr) _impl_.contactsarraymessage_->Clear(); + _impl_._has_bits_[0] &= ~0x00001000u; +} +inline const ::proto::Message_ContactsArrayMessage& Message::_internal_contactsarraymessage() const { + const ::proto::Message_ContactsArrayMessage* p = _impl_.contactsarraymessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_ContactsArrayMessage_default_instance_); +} +inline const ::proto::Message_ContactsArrayMessage& Message::contactsarraymessage() const { + // @@protoc_insertion_point(field_get:proto.Message.contactsArrayMessage) + return _internal_contactsarraymessage(); +} +inline void Message::unsafe_arena_set_allocated_contactsarraymessage( + ::proto::Message_ContactsArrayMessage* contactsarraymessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contactsarraymessage_); + } + _impl_.contactsarraymessage_ = contactsarraymessage; + if (contactsarraymessage) { + _impl_._has_bits_[0] |= 0x00001000u; + } else { + _impl_._has_bits_[0] &= ~0x00001000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.contactsArrayMessage) +} +inline ::proto::Message_ContactsArrayMessage* Message::release_contactsarraymessage() { + _impl_._has_bits_[0] &= ~0x00001000u; + ::proto::Message_ContactsArrayMessage* temp = _impl_.contactsarraymessage_; + _impl_.contactsarraymessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_ContactsArrayMessage* Message::unsafe_arena_release_contactsarraymessage() { + // @@protoc_insertion_point(field_release:proto.Message.contactsArrayMessage) + _impl_._has_bits_[0] &= ~0x00001000u; + ::proto::Message_ContactsArrayMessage* temp = _impl_.contactsarraymessage_; + _impl_.contactsarraymessage_ = nullptr; + return temp; +} +inline ::proto::Message_ContactsArrayMessage* Message::_internal_mutable_contactsarraymessage() { + _impl_._has_bits_[0] |= 0x00001000u; + if (_impl_.contactsarraymessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_ContactsArrayMessage>(GetArenaForAllocation()); + _impl_.contactsarraymessage_ = p; + } + return _impl_.contactsarraymessage_; +} +inline ::proto::Message_ContactsArrayMessage* Message::mutable_contactsarraymessage() { + ::proto::Message_ContactsArrayMessage* _msg = _internal_mutable_contactsarraymessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.contactsArrayMessage) + return _msg; +} +inline void Message::set_allocated_contactsarraymessage(::proto::Message_ContactsArrayMessage* contactsarraymessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.contactsarraymessage_; + } + if (contactsarraymessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contactsarraymessage); + if (message_arena != submessage_arena) { + contactsarraymessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, contactsarraymessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00001000u; + } else { + _impl_._has_bits_[0] &= ~0x00001000u; + } + _impl_.contactsarraymessage_ = contactsarraymessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.contactsArrayMessage) +} + +// optional .proto.Message.HighlyStructuredMessage highlyStructuredMessage = 14; +inline bool Message::_internal_has_highlystructuredmessage() const { + bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.highlystructuredmessage_ != nullptr); + return value; +} +inline bool Message::has_highlystructuredmessage() const { + return _internal_has_highlystructuredmessage(); +} +inline void Message::clear_highlystructuredmessage() { + if (_impl_.highlystructuredmessage_ != nullptr) _impl_.highlystructuredmessage_->Clear(); + _impl_._has_bits_[0] &= ~0x00002000u; +} +inline const ::proto::Message_HighlyStructuredMessage& Message::_internal_highlystructuredmessage() const { + const ::proto::Message_HighlyStructuredMessage* p = _impl_.highlystructuredmessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_HighlyStructuredMessage_default_instance_); +} +inline const ::proto::Message_HighlyStructuredMessage& Message::highlystructuredmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.highlyStructuredMessage) + return _internal_highlystructuredmessage(); +} +inline void Message::unsafe_arena_set_allocated_highlystructuredmessage( + ::proto::Message_HighlyStructuredMessage* highlystructuredmessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.highlystructuredmessage_); + } + _impl_.highlystructuredmessage_ = highlystructuredmessage; + if (highlystructuredmessage) { + _impl_._has_bits_[0] |= 0x00002000u; + } else { + _impl_._has_bits_[0] &= ~0x00002000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.highlyStructuredMessage) +} +inline ::proto::Message_HighlyStructuredMessage* Message::release_highlystructuredmessage() { + _impl_._has_bits_[0] &= ~0x00002000u; + ::proto::Message_HighlyStructuredMessage* temp = _impl_.highlystructuredmessage_; + _impl_.highlystructuredmessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_HighlyStructuredMessage* Message::unsafe_arena_release_highlystructuredmessage() { + // @@protoc_insertion_point(field_release:proto.Message.highlyStructuredMessage) + _impl_._has_bits_[0] &= ~0x00002000u; + ::proto::Message_HighlyStructuredMessage* temp = _impl_.highlystructuredmessage_; + _impl_.highlystructuredmessage_ = nullptr; + return temp; +} +inline ::proto::Message_HighlyStructuredMessage* Message::_internal_mutable_highlystructuredmessage() { + _impl_._has_bits_[0] |= 0x00002000u; + if (_impl_.highlystructuredmessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation()); + _impl_.highlystructuredmessage_ = p; + } + return _impl_.highlystructuredmessage_; +} +inline ::proto::Message_HighlyStructuredMessage* Message::mutable_highlystructuredmessage() { + ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_highlystructuredmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.highlyStructuredMessage) + return _msg; +} +inline void Message::set_allocated_highlystructuredmessage(::proto::Message_HighlyStructuredMessage* highlystructuredmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.highlystructuredmessage_; + } + if (highlystructuredmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(highlystructuredmessage); + if (message_arena != submessage_arena) { + highlystructuredmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, highlystructuredmessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00002000u; + } else { + _impl_._has_bits_[0] &= ~0x00002000u; + } + _impl_.highlystructuredmessage_ = highlystructuredmessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.highlyStructuredMessage) +} + +// optional .proto.Message.SenderKeyDistributionMessage fastRatchetKeySenderKeyDistributionMessage = 15; +inline bool Message::_internal_has_fastratchetkeysenderkeydistributionmessage() const { + bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.fastratchetkeysenderkeydistributionmessage_ != nullptr); + return value; +} +inline bool Message::has_fastratchetkeysenderkeydistributionmessage() const { + return _internal_has_fastratchetkeysenderkeydistributionmessage(); +} +inline void Message::clear_fastratchetkeysenderkeydistributionmessage() { + if (_impl_.fastratchetkeysenderkeydistributionmessage_ != nullptr) _impl_.fastratchetkeysenderkeydistributionmessage_->Clear(); + _impl_._has_bits_[0] &= ~0x00004000u; +} +inline const ::proto::Message_SenderKeyDistributionMessage& Message::_internal_fastratchetkeysenderkeydistributionmessage() const { + const ::proto::Message_SenderKeyDistributionMessage* p = _impl_.fastratchetkeysenderkeydistributionmessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_SenderKeyDistributionMessage_default_instance_); +} +inline const ::proto::Message_SenderKeyDistributionMessage& Message::fastratchetkeysenderkeydistributionmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.fastRatchetKeySenderKeyDistributionMessage) + return _internal_fastratchetkeysenderkeydistributionmessage(); +} +inline void Message::unsafe_arena_set_allocated_fastratchetkeysenderkeydistributionmessage( + ::proto::Message_SenderKeyDistributionMessage* fastratchetkeysenderkeydistributionmessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.fastratchetkeysenderkeydistributionmessage_); + } + _impl_.fastratchetkeysenderkeydistributionmessage_ = fastratchetkeysenderkeydistributionmessage; + if (fastratchetkeysenderkeydistributionmessage) { + _impl_._has_bits_[0] |= 0x00004000u; + } else { + _impl_._has_bits_[0] &= ~0x00004000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.fastRatchetKeySenderKeyDistributionMessage) +} +inline ::proto::Message_SenderKeyDistributionMessage* Message::release_fastratchetkeysenderkeydistributionmessage() { + _impl_._has_bits_[0] &= ~0x00004000u; + ::proto::Message_SenderKeyDistributionMessage* temp = _impl_.fastratchetkeysenderkeydistributionmessage_; + _impl_.fastratchetkeysenderkeydistributionmessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_SenderKeyDistributionMessage* Message::unsafe_arena_release_fastratchetkeysenderkeydistributionmessage() { + // @@protoc_insertion_point(field_release:proto.Message.fastRatchetKeySenderKeyDistributionMessage) + _impl_._has_bits_[0] &= ~0x00004000u; + ::proto::Message_SenderKeyDistributionMessage* temp = _impl_.fastratchetkeysenderkeydistributionmessage_; + _impl_.fastratchetkeysenderkeydistributionmessage_ = nullptr; + return temp; +} +inline ::proto::Message_SenderKeyDistributionMessage* Message::_internal_mutable_fastratchetkeysenderkeydistributionmessage() { + _impl_._has_bits_[0] |= 0x00004000u; + if (_impl_.fastratchetkeysenderkeydistributionmessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_SenderKeyDistributionMessage>(GetArenaForAllocation()); + _impl_.fastratchetkeysenderkeydistributionmessage_ = p; + } + return _impl_.fastratchetkeysenderkeydistributionmessage_; +} +inline ::proto::Message_SenderKeyDistributionMessage* Message::mutable_fastratchetkeysenderkeydistributionmessage() { + ::proto::Message_SenderKeyDistributionMessage* _msg = _internal_mutable_fastratchetkeysenderkeydistributionmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.fastRatchetKeySenderKeyDistributionMessage) + return _msg; +} +inline void Message::set_allocated_fastratchetkeysenderkeydistributionmessage(::proto::Message_SenderKeyDistributionMessage* fastratchetkeysenderkeydistributionmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.fastratchetkeysenderkeydistributionmessage_; + } + if (fastratchetkeysenderkeydistributionmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(fastratchetkeysenderkeydistributionmessage); + if (message_arena != submessage_arena) { + fastratchetkeysenderkeydistributionmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, fastratchetkeysenderkeydistributionmessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00004000u; + } else { + _impl_._has_bits_[0] &= ~0x00004000u; + } + _impl_.fastratchetkeysenderkeydistributionmessage_ = fastratchetkeysenderkeydistributionmessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.fastRatchetKeySenderKeyDistributionMessage) +} + +// optional .proto.Message.SendPaymentMessage sendPaymentMessage = 16; +inline bool Message::_internal_has_sendpaymentmessage() const { + bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.sendpaymentmessage_ != nullptr); + return value; +} +inline bool Message::has_sendpaymentmessage() const { + return _internal_has_sendpaymentmessage(); +} +inline void Message::clear_sendpaymentmessage() { + if (_impl_.sendpaymentmessage_ != nullptr) _impl_.sendpaymentmessage_->Clear(); + _impl_._has_bits_[0] &= ~0x00008000u; +} +inline const ::proto::Message_SendPaymentMessage& Message::_internal_sendpaymentmessage() const { + const ::proto::Message_SendPaymentMessage* p = _impl_.sendpaymentmessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_SendPaymentMessage_default_instance_); +} +inline const ::proto::Message_SendPaymentMessage& Message::sendpaymentmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.sendPaymentMessage) + return _internal_sendpaymentmessage(); +} +inline void Message::unsafe_arena_set_allocated_sendpaymentmessage( + ::proto::Message_SendPaymentMessage* sendpaymentmessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.sendpaymentmessage_); + } + _impl_.sendpaymentmessage_ = sendpaymentmessage; + if (sendpaymentmessage) { + _impl_._has_bits_[0] |= 0x00008000u; + } else { + _impl_._has_bits_[0] &= ~0x00008000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.sendPaymentMessage) +} +inline ::proto::Message_SendPaymentMessage* Message::release_sendpaymentmessage() { + _impl_._has_bits_[0] &= ~0x00008000u; + ::proto::Message_SendPaymentMessage* temp = _impl_.sendpaymentmessage_; + _impl_.sendpaymentmessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_SendPaymentMessage* Message::unsafe_arena_release_sendpaymentmessage() { + // @@protoc_insertion_point(field_release:proto.Message.sendPaymentMessage) + _impl_._has_bits_[0] &= ~0x00008000u; + ::proto::Message_SendPaymentMessage* temp = _impl_.sendpaymentmessage_; + _impl_.sendpaymentmessage_ = nullptr; + return temp; +} +inline ::proto::Message_SendPaymentMessage* Message::_internal_mutable_sendpaymentmessage() { + _impl_._has_bits_[0] |= 0x00008000u; + if (_impl_.sendpaymentmessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_SendPaymentMessage>(GetArenaForAllocation()); + _impl_.sendpaymentmessage_ = p; + } + return _impl_.sendpaymentmessage_; +} +inline ::proto::Message_SendPaymentMessage* Message::mutable_sendpaymentmessage() { + ::proto::Message_SendPaymentMessage* _msg = _internal_mutable_sendpaymentmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.sendPaymentMessage) + return _msg; +} +inline void Message::set_allocated_sendpaymentmessage(::proto::Message_SendPaymentMessage* sendpaymentmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.sendpaymentmessage_; + } + if (sendpaymentmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(sendpaymentmessage); + if (message_arena != submessage_arena) { + sendpaymentmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, sendpaymentmessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00008000u; + } else { + _impl_._has_bits_[0] &= ~0x00008000u; + } + _impl_.sendpaymentmessage_ = sendpaymentmessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.sendPaymentMessage) +} + +// optional .proto.Message.LiveLocationMessage liveLocationMessage = 18; +inline bool Message::_internal_has_livelocationmessage() const { + bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.livelocationmessage_ != nullptr); + return value; +} +inline bool Message::has_livelocationmessage() const { + return _internal_has_livelocationmessage(); +} +inline void Message::clear_livelocationmessage() { + if (_impl_.livelocationmessage_ != nullptr) _impl_.livelocationmessage_->Clear(); + _impl_._has_bits_[0] &= ~0x00010000u; +} +inline const ::proto::Message_LiveLocationMessage& Message::_internal_livelocationmessage() const { + const ::proto::Message_LiveLocationMessage* p = _impl_.livelocationmessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_LiveLocationMessage_default_instance_); +} +inline const ::proto::Message_LiveLocationMessage& Message::livelocationmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.liveLocationMessage) + return _internal_livelocationmessage(); +} +inline void Message::unsafe_arena_set_allocated_livelocationmessage( + ::proto::Message_LiveLocationMessage* livelocationmessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.livelocationmessage_); + } + _impl_.livelocationmessage_ = livelocationmessage; + if (livelocationmessage) { + _impl_._has_bits_[0] |= 0x00010000u; + } else { + _impl_._has_bits_[0] &= ~0x00010000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.liveLocationMessage) +} +inline ::proto::Message_LiveLocationMessage* Message::release_livelocationmessage() { + _impl_._has_bits_[0] &= ~0x00010000u; + ::proto::Message_LiveLocationMessage* temp = _impl_.livelocationmessage_; + _impl_.livelocationmessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_LiveLocationMessage* Message::unsafe_arena_release_livelocationmessage() { + // @@protoc_insertion_point(field_release:proto.Message.liveLocationMessage) + _impl_._has_bits_[0] &= ~0x00010000u; + ::proto::Message_LiveLocationMessage* temp = _impl_.livelocationmessage_; + _impl_.livelocationmessage_ = nullptr; + return temp; +} +inline ::proto::Message_LiveLocationMessage* Message::_internal_mutable_livelocationmessage() { + _impl_._has_bits_[0] |= 0x00010000u; + if (_impl_.livelocationmessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_LiveLocationMessage>(GetArenaForAllocation()); + _impl_.livelocationmessage_ = p; + } + return _impl_.livelocationmessage_; +} +inline ::proto::Message_LiveLocationMessage* Message::mutable_livelocationmessage() { + ::proto::Message_LiveLocationMessage* _msg = _internal_mutable_livelocationmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.liveLocationMessage) + return _msg; +} +inline void Message::set_allocated_livelocationmessage(::proto::Message_LiveLocationMessage* livelocationmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.livelocationmessage_; + } + if (livelocationmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(livelocationmessage); + if (message_arena != submessage_arena) { + livelocationmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, livelocationmessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00010000u; + } else { + _impl_._has_bits_[0] &= ~0x00010000u; + } + _impl_.livelocationmessage_ = livelocationmessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.liveLocationMessage) +} + +// optional .proto.Message.RequestPaymentMessage requestPaymentMessage = 22; +inline bool Message::_internal_has_requestpaymentmessage() const { + bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.requestpaymentmessage_ != nullptr); + return value; +} +inline bool Message::has_requestpaymentmessage() const { + return _internal_has_requestpaymentmessage(); +} +inline void Message::clear_requestpaymentmessage() { + if (_impl_.requestpaymentmessage_ != nullptr) _impl_.requestpaymentmessage_->Clear(); + _impl_._has_bits_[0] &= ~0x00020000u; +} +inline const ::proto::Message_RequestPaymentMessage& Message::_internal_requestpaymentmessage() const { + const ::proto::Message_RequestPaymentMessage* p = _impl_.requestpaymentmessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_RequestPaymentMessage_default_instance_); +} +inline const ::proto::Message_RequestPaymentMessage& Message::requestpaymentmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.requestPaymentMessage) + return _internal_requestpaymentmessage(); +} +inline void Message::unsafe_arena_set_allocated_requestpaymentmessage( + ::proto::Message_RequestPaymentMessage* requestpaymentmessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.requestpaymentmessage_); + } + _impl_.requestpaymentmessage_ = requestpaymentmessage; + if (requestpaymentmessage) { + _impl_._has_bits_[0] |= 0x00020000u; + } else { + _impl_._has_bits_[0] &= ~0x00020000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.requestPaymentMessage) +} +inline ::proto::Message_RequestPaymentMessage* Message::release_requestpaymentmessage() { + _impl_._has_bits_[0] &= ~0x00020000u; + ::proto::Message_RequestPaymentMessage* temp = _impl_.requestpaymentmessage_; + _impl_.requestpaymentmessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_RequestPaymentMessage* Message::unsafe_arena_release_requestpaymentmessage() { + // @@protoc_insertion_point(field_release:proto.Message.requestPaymentMessage) + _impl_._has_bits_[0] &= ~0x00020000u; + ::proto::Message_RequestPaymentMessage* temp = _impl_.requestpaymentmessage_; + _impl_.requestpaymentmessage_ = nullptr; + return temp; +} +inline ::proto::Message_RequestPaymentMessage* Message::_internal_mutable_requestpaymentmessage() { + _impl_._has_bits_[0] |= 0x00020000u; + if (_impl_.requestpaymentmessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_RequestPaymentMessage>(GetArenaForAllocation()); + _impl_.requestpaymentmessage_ = p; + } + return _impl_.requestpaymentmessage_; +} +inline ::proto::Message_RequestPaymentMessage* Message::mutable_requestpaymentmessage() { + ::proto::Message_RequestPaymentMessage* _msg = _internal_mutable_requestpaymentmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.requestPaymentMessage) + return _msg; +} +inline void Message::set_allocated_requestpaymentmessage(::proto::Message_RequestPaymentMessage* requestpaymentmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.requestpaymentmessage_; + } + if (requestpaymentmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(requestpaymentmessage); + if (message_arena != submessage_arena) { + requestpaymentmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, requestpaymentmessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00020000u; + } else { + _impl_._has_bits_[0] &= ~0x00020000u; + } + _impl_.requestpaymentmessage_ = requestpaymentmessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.requestPaymentMessage) +} + +// optional .proto.Message.DeclinePaymentRequestMessage declinePaymentRequestMessage = 23; +inline bool Message::_internal_has_declinepaymentrequestmessage() const { + bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.declinepaymentrequestmessage_ != nullptr); + return value; +} +inline bool Message::has_declinepaymentrequestmessage() const { + return _internal_has_declinepaymentrequestmessage(); +} +inline void Message::clear_declinepaymentrequestmessage() { + if (_impl_.declinepaymentrequestmessage_ != nullptr) _impl_.declinepaymentrequestmessage_->Clear(); + _impl_._has_bits_[0] &= ~0x00040000u; +} +inline const ::proto::Message_DeclinePaymentRequestMessage& Message::_internal_declinepaymentrequestmessage() const { + const ::proto::Message_DeclinePaymentRequestMessage* p = _impl_.declinepaymentrequestmessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_DeclinePaymentRequestMessage_default_instance_); +} +inline const ::proto::Message_DeclinePaymentRequestMessage& Message::declinepaymentrequestmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.declinePaymentRequestMessage) + return _internal_declinepaymentrequestmessage(); +} +inline void Message::unsafe_arena_set_allocated_declinepaymentrequestmessage( + ::proto::Message_DeclinePaymentRequestMessage* declinepaymentrequestmessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.declinepaymentrequestmessage_); + } + _impl_.declinepaymentrequestmessage_ = declinepaymentrequestmessage; + if (declinepaymentrequestmessage) { + _impl_._has_bits_[0] |= 0x00040000u; + } else { + _impl_._has_bits_[0] &= ~0x00040000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.declinePaymentRequestMessage) +} +inline ::proto::Message_DeclinePaymentRequestMessage* Message::release_declinepaymentrequestmessage() { + _impl_._has_bits_[0] &= ~0x00040000u; + ::proto::Message_DeclinePaymentRequestMessage* temp = _impl_.declinepaymentrequestmessage_; + _impl_.declinepaymentrequestmessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_DeclinePaymentRequestMessage* Message::unsafe_arena_release_declinepaymentrequestmessage() { + // @@protoc_insertion_point(field_release:proto.Message.declinePaymentRequestMessage) + _impl_._has_bits_[0] &= ~0x00040000u; + ::proto::Message_DeclinePaymentRequestMessage* temp = _impl_.declinepaymentrequestmessage_; + _impl_.declinepaymentrequestmessage_ = nullptr; + return temp; +} +inline ::proto::Message_DeclinePaymentRequestMessage* Message::_internal_mutable_declinepaymentrequestmessage() { + _impl_._has_bits_[0] |= 0x00040000u; + if (_impl_.declinepaymentrequestmessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_DeclinePaymentRequestMessage>(GetArenaForAllocation()); + _impl_.declinepaymentrequestmessage_ = p; + } + return _impl_.declinepaymentrequestmessage_; +} +inline ::proto::Message_DeclinePaymentRequestMessage* Message::mutable_declinepaymentrequestmessage() { + ::proto::Message_DeclinePaymentRequestMessage* _msg = _internal_mutable_declinepaymentrequestmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.declinePaymentRequestMessage) + return _msg; +} +inline void Message::set_allocated_declinepaymentrequestmessage(::proto::Message_DeclinePaymentRequestMessage* declinepaymentrequestmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.declinepaymentrequestmessage_; + } + if (declinepaymentrequestmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(declinepaymentrequestmessage); + if (message_arena != submessage_arena) { + declinepaymentrequestmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, declinepaymentrequestmessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00040000u; + } else { + _impl_._has_bits_[0] &= ~0x00040000u; + } + _impl_.declinepaymentrequestmessage_ = declinepaymentrequestmessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.declinePaymentRequestMessage) +} + +// optional .proto.Message.CancelPaymentRequestMessage cancelPaymentRequestMessage = 24; +inline bool Message::_internal_has_cancelpaymentrequestmessage() const { + bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.cancelpaymentrequestmessage_ != nullptr); + return value; +} +inline bool Message::has_cancelpaymentrequestmessage() const { + return _internal_has_cancelpaymentrequestmessage(); +} +inline void Message::clear_cancelpaymentrequestmessage() { + if (_impl_.cancelpaymentrequestmessage_ != nullptr) _impl_.cancelpaymentrequestmessage_->Clear(); + _impl_._has_bits_[0] &= ~0x00080000u; +} +inline const ::proto::Message_CancelPaymentRequestMessage& Message::_internal_cancelpaymentrequestmessage() const { + const ::proto::Message_CancelPaymentRequestMessage* p = _impl_.cancelpaymentrequestmessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_CancelPaymentRequestMessage_default_instance_); +} +inline const ::proto::Message_CancelPaymentRequestMessage& Message::cancelpaymentrequestmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.cancelPaymentRequestMessage) + return _internal_cancelpaymentrequestmessage(); +} +inline void Message::unsafe_arena_set_allocated_cancelpaymentrequestmessage( + ::proto::Message_CancelPaymentRequestMessage* cancelpaymentrequestmessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cancelpaymentrequestmessage_); + } + _impl_.cancelpaymentrequestmessage_ = cancelpaymentrequestmessage; + if (cancelpaymentrequestmessage) { + _impl_._has_bits_[0] |= 0x00080000u; + } else { + _impl_._has_bits_[0] &= ~0x00080000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.cancelPaymentRequestMessage) +} +inline ::proto::Message_CancelPaymentRequestMessage* Message::release_cancelpaymentrequestmessage() { + _impl_._has_bits_[0] &= ~0x00080000u; + ::proto::Message_CancelPaymentRequestMessage* temp = _impl_.cancelpaymentrequestmessage_; + _impl_.cancelpaymentrequestmessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_CancelPaymentRequestMessage* Message::unsafe_arena_release_cancelpaymentrequestmessage() { + // @@protoc_insertion_point(field_release:proto.Message.cancelPaymentRequestMessage) + _impl_._has_bits_[0] &= ~0x00080000u; + ::proto::Message_CancelPaymentRequestMessage* temp = _impl_.cancelpaymentrequestmessage_; + _impl_.cancelpaymentrequestmessage_ = nullptr; + return temp; +} +inline ::proto::Message_CancelPaymentRequestMessage* Message::_internal_mutable_cancelpaymentrequestmessage() { + _impl_._has_bits_[0] |= 0x00080000u; + if (_impl_.cancelpaymentrequestmessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_CancelPaymentRequestMessage>(GetArenaForAllocation()); + _impl_.cancelpaymentrequestmessage_ = p; + } + return _impl_.cancelpaymentrequestmessage_; +} +inline ::proto::Message_CancelPaymentRequestMessage* Message::mutable_cancelpaymentrequestmessage() { + ::proto::Message_CancelPaymentRequestMessage* _msg = _internal_mutable_cancelpaymentrequestmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.cancelPaymentRequestMessage) + return _msg; +} +inline void Message::set_allocated_cancelpaymentrequestmessage(::proto::Message_CancelPaymentRequestMessage* cancelpaymentrequestmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.cancelpaymentrequestmessage_; + } + if (cancelpaymentrequestmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(cancelpaymentrequestmessage); + if (message_arena != submessage_arena) { + cancelpaymentrequestmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, cancelpaymentrequestmessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00080000u; + } else { + _impl_._has_bits_[0] &= ~0x00080000u; + } + _impl_.cancelpaymentrequestmessage_ = cancelpaymentrequestmessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.cancelPaymentRequestMessage) +} + +// optional .proto.Message.TemplateMessage templateMessage = 25; +inline bool Message::_internal_has_templatemessage() const { + bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.templatemessage_ != nullptr); + return value; +} +inline bool Message::has_templatemessage() const { + return _internal_has_templatemessage(); +} +inline void Message::clear_templatemessage() { + if (_impl_.templatemessage_ != nullptr) _impl_.templatemessage_->Clear(); + _impl_._has_bits_[0] &= ~0x00100000u; +} +inline const ::proto::Message_TemplateMessage& Message::_internal_templatemessage() const { + const ::proto::Message_TemplateMessage* p = _impl_.templatemessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_TemplateMessage_default_instance_); +} +inline const ::proto::Message_TemplateMessage& Message::templatemessage() const { + // @@protoc_insertion_point(field_get:proto.Message.templateMessage) + return _internal_templatemessage(); +} +inline void Message::unsafe_arena_set_allocated_templatemessage( + ::proto::Message_TemplateMessage* templatemessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.templatemessage_); + } + _impl_.templatemessage_ = templatemessage; + if (templatemessage) { + _impl_._has_bits_[0] |= 0x00100000u; + } else { + _impl_._has_bits_[0] &= ~0x00100000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.templateMessage) +} +inline ::proto::Message_TemplateMessage* Message::release_templatemessage() { + _impl_._has_bits_[0] &= ~0x00100000u; + ::proto::Message_TemplateMessage* temp = _impl_.templatemessage_; + _impl_.templatemessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_TemplateMessage* Message::unsafe_arena_release_templatemessage() { + // @@protoc_insertion_point(field_release:proto.Message.templateMessage) + _impl_._has_bits_[0] &= ~0x00100000u; + ::proto::Message_TemplateMessage* temp = _impl_.templatemessage_; + _impl_.templatemessage_ = nullptr; + return temp; +} +inline ::proto::Message_TemplateMessage* Message::_internal_mutable_templatemessage() { + _impl_._has_bits_[0] |= 0x00100000u; + if (_impl_.templatemessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_TemplateMessage>(GetArenaForAllocation()); + _impl_.templatemessage_ = p; + } + return _impl_.templatemessage_; +} +inline ::proto::Message_TemplateMessage* Message::mutable_templatemessage() { + ::proto::Message_TemplateMessage* _msg = _internal_mutable_templatemessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.templateMessage) + return _msg; +} +inline void Message::set_allocated_templatemessage(::proto::Message_TemplateMessage* templatemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.templatemessage_; + } + if (templatemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(templatemessage); + if (message_arena != submessage_arena) { + templatemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, templatemessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00100000u; + } else { + _impl_._has_bits_[0] &= ~0x00100000u; + } + _impl_.templatemessage_ = templatemessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.templateMessage) +} + +// optional .proto.Message.StickerMessage stickerMessage = 26; +inline bool Message::_internal_has_stickermessage() const { + bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.stickermessage_ != nullptr); + return value; +} +inline bool Message::has_stickermessage() const { + return _internal_has_stickermessage(); +} +inline void Message::clear_stickermessage() { + if (_impl_.stickermessage_ != nullptr) _impl_.stickermessage_->Clear(); + _impl_._has_bits_[0] &= ~0x00200000u; +} +inline const ::proto::Message_StickerMessage& Message::_internal_stickermessage() const { + const ::proto::Message_StickerMessage* p = _impl_.stickermessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_StickerMessage_default_instance_); +} +inline const ::proto::Message_StickerMessage& Message::stickermessage() const { + // @@protoc_insertion_point(field_get:proto.Message.stickerMessage) + return _internal_stickermessage(); +} +inline void Message::unsafe_arena_set_allocated_stickermessage( + ::proto::Message_StickerMessage* stickermessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.stickermessage_); + } + _impl_.stickermessage_ = stickermessage; + if (stickermessage) { + _impl_._has_bits_[0] |= 0x00200000u; + } else { + _impl_._has_bits_[0] &= ~0x00200000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.stickerMessage) +} +inline ::proto::Message_StickerMessage* Message::release_stickermessage() { + _impl_._has_bits_[0] &= ~0x00200000u; + ::proto::Message_StickerMessage* temp = _impl_.stickermessage_; + _impl_.stickermessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_StickerMessage* Message::unsafe_arena_release_stickermessage() { + // @@protoc_insertion_point(field_release:proto.Message.stickerMessage) + _impl_._has_bits_[0] &= ~0x00200000u; + ::proto::Message_StickerMessage* temp = _impl_.stickermessage_; + _impl_.stickermessage_ = nullptr; + return temp; +} +inline ::proto::Message_StickerMessage* Message::_internal_mutable_stickermessage() { + _impl_._has_bits_[0] |= 0x00200000u; + if (_impl_.stickermessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_StickerMessage>(GetArenaForAllocation()); + _impl_.stickermessage_ = p; + } + return _impl_.stickermessage_; +} +inline ::proto::Message_StickerMessage* Message::mutable_stickermessage() { + ::proto::Message_StickerMessage* _msg = _internal_mutable_stickermessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.stickerMessage) + return _msg; +} +inline void Message::set_allocated_stickermessage(::proto::Message_StickerMessage* stickermessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.stickermessage_; + } + if (stickermessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(stickermessage); + if (message_arena != submessage_arena) { + stickermessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, stickermessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00200000u; + } else { + _impl_._has_bits_[0] &= ~0x00200000u; + } + _impl_.stickermessage_ = stickermessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.stickerMessage) +} + +// optional .proto.Message.GroupInviteMessage groupInviteMessage = 28; +inline bool Message::_internal_has_groupinvitemessage() const { + bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.groupinvitemessage_ != nullptr); + return value; +} +inline bool Message::has_groupinvitemessage() const { + return _internal_has_groupinvitemessage(); +} +inline void Message::clear_groupinvitemessage() { + if (_impl_.groupinvitemessage_ != nullptr) _impl_.groupinvitemessage_->Clear(); + _impl_._has_bits_[0] &= ~0x00400000u; +} +inline const ::proto::Message_GroupInviteMessage& Message::_internal_groupinvitemessage() const { + const ::proto::Message_GroupInviteMessage* p = _impl_.groupinvitemessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_GroupInviteMessage_default_instance_); +} +inline const ::proto::Message_GroupInviteMessage& Message::groupinvitemessage() const { + // @@protoc_insertion_point(field_get:proto.Message.groupInviteMessage) + return _internal_groupinvitemessage(); +} +inline void Message::unsafe_arena_set_allocated_groupinvitemessage( + ::proto::Message_GroupInviteMessage* groupinvitemessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.groupinvitemessage_); + } + _impl_.groupinvitemessage_ = groupinvitemessage; + if (groupinvitemessage) { + _impl_._has_bits_[0] |= 0x00400000u; + } else { + _impl_._has_bits_[0] &= ~0x00400000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.groupInviteMessage) +} +inline ::proto::Message_GroupInviteMessage* Message::release_groupinvitemessage() { + _impl_._has_bits_[0] &= ~0x00400000u; + ::proto::Message_GroupInviteMessage* temp = _impl_.groupinvitemessage_; + _impl_.groupinvitemessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_GroupInviteMessage* Message::unsafe_arena_release_groupinvitemessage() { + // @@protoc_insertion_point(field_release:proto.Message.groupInviteMessage) + _impl_._has_bits_[0] &= ~0x00400000u; + ::proto::Message_GroupInviteMessage* temp = _impl_.groupinvitemessage_; + _impl_.groupinvitemessage_ = nullptr; + return temp; +} +inline ::proto::Message_GroupInviteMessage* Message::_internal_mutable_groupinvitemessage() { + _impl_._has_bits_[0] |= 0x00400000u; + if (_impl_.groupinvitemessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_GroupInviteMessage>(GetArenaForAllocation()); + _impl_.groupinvitemessage_ = p; + } + return _impl_.groupinvitemessage_; +} +inline ::proto::Message_GroupInviteMessage* Message::mutable_groupinvitemessage() { + ::proto::Message_GroupInviteMessage* _msg = _internal_mutable_groupinvitemessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.groupInviteMessage) + return _msg; +} +inline void Message::set_allocated_groupinvitemessage(::proto::Message_GroupInviteMessage* groupinvitemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.groupinvitemessage_; + } + if (groupinvitemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(groupinvitemessage); + if (message_arena != submessage_arena) { + groupinvitemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, groupinvitemessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00400000u; + } else { + _impl_._has_bits_[0] &= ~0x00400000u; + } + _impl_.groupinvitemessage_ = groupinvitemessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.groupInviteMessage) +} + +// optional .proto.Message.TemplateButtonReplyMessage templateButtonReplyMessage = 29; +inline bool Message::_internal_has_templatebuttonreplymessage() const { + bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.templatebuttonreplymessage_ != nullptr); + return value; +} +inline bool Message::has_templatebuttonreplymessage() const { + return _internal_has_templatebuttonreplymessage(); +} +inline void Message::clear_templatebuttonreplymessage() { + if (_impl_.templatebuttonreplymessage_ != nullptr) _impl_.templatebuttonreplymessage_->Clear(); + _impl_._has_bits_[0] &= ~0x00800000u; +} +inline const ::proto::Message_TemplateButtonReplyMessage& Message::_internal_templatebuttonreplymessage() const { + const ::proto::Message_TemplateButtonReplyMessage* p = _impl_.templatebuttonreplymessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_TemplateButtonReplyMessage_default_instance_); +} +inline const ::proto::Message_TemplateButtonReplyMessage& Message::templatebuttonreplymessage() const { + // @@protoc_insertion_point(field_get:proto.Message.templateButtonReplyMessage) + return _internal_templatebuttonreplymessage(); +} +inline void Message::unsafe_arena_set_allocated_templatebuttonreplymessage( + ::proto::Message_TemplateButtonReplyMessage* templatebuttonreplymessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.templatebuttonreplymessage_); + } + _impl_.templatebuttonreplymessage_ = templatebuttonreplymessage; + if (templatebuttonreplymessage) { + _impl_._has_bits_[0] |= 0x00800000u; + } else { + _impl_._has_bits_[0] &= ~0x00800000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.templateButtonReplyMessage) +} +inline ::proto::Message_TemplateButtonReplyMessage* Message::release_templatebuttonreplymessage() { + _impl_._has_bits_[0] &= ~0x00800000u; + ::proto::Message_TemplateButtonReplyMessage* temp = _impl_.templatebuttonreplymessage_; + _impl_.templatebuttonreplymessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_TemplateButtonReplyMessage* Message::unsafe_arena_release_templatebuttonreplymessage() { + // @@protoc_insertion_point(field_release:proto.Message.templateButtonReplyMessage) + _impl_._has_bits_[0] &= ~0x00800000u; + ::proto::Message_TemplateButtonReplyMessage* temp = _impl_.templatebuttonreplymessage_; + _impl_.templatebuttonreplymessage_ = nullptr; + return temp; +} +inline ::proto::Message_TemplateButtonReplyMessage* Message::_internal_mutable_templatebuttonreplymessage() { + _impl_._has_bits_[0] |= 0x00800000u; + if (_impl_.templatebuttonreplymessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_TemplateButtonReplyMessage>(GetArenaForAllocation()); + _impl_.templatebuttonreplymessage_ = p; + } + return _impl_.templatebuttonreplymessage_; +} +inline ::proto::Message_TemplateButtonReplyMessage* Message::mutable_templatebuttonreplymessage() { + ::proto::Message_TemplateButtonReplyMessage* _msg = _internal_mutable_templatebuttonreplymessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.templateButtonReplyMessage) + return _msg; +} +inline void Message::set_allocated_templatebuttonreplymessage(::proto::Message_TemplateButtonReplyMessage* templatebuttonreplymessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.templatebuttonreplymessage_; + } + if (templatebuttonreplymessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(templatebuttonreplymessage); + if (message_arena != submessage_arena) { + templatebuttonreplymessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, templatebuttonreplymessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00800000u; + } else { + _impl_._has_bits_[0] &= ~0x00800000u; + } + _impl_.templatebuttonreplymessage_ = templatebuttonreplymessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.templateButtonReplyMessage) +} + +// optional .proto.Message.ProductMessage productMessage = 30; +inline bool Message::_internal_has_productmessage() const { + bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.productmessage_ != nullptr); + return value; +} +inline bool Message::has_productmessage() const { + return _internal_has_productmessage(); +} +inline void Message::clear_productmessage() { + if (_impl_.productmessage_ != nullptr) _impl_.productmessage_->Clear(); + _impl_._has_bits_[0] &= ~0x01000000u; +} +inline const ::proto::Message_ProductMessage& Message::_internal_productmessage() const { + const ::proto::Message_ProductMessage* p = _impl_.productmessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_ProductMessage_default_instance_); +} +inline const ::proto::Message_ProductMessage& Message::productmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.productMessage) + return _internal_productmessage(); +} +inline void Message::unsafe_arena_set_allocated_productmessage( + ::proto::Message_ProductMessage* productmessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.productmessage_); + } + _impl_.productmessage_ = productmessage; + if (productmessage) { + _impl_._has_bits_[0] |= 0x01000000u; + } else { + _impl_._has_bits_[0] &= ~0x01000000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.productMessage) +} +inline ::proto::Message_ProductMessage* Message::release_productmessage() { + _impl_._has_bits_[0] &= ~0x01000000u; + ::proto::Message_ProductMessage* temp = _impl_.productmessage_; + _impl_.productmessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_ProductMessage* Message::unsafe_arena_release_productmessage() { + // @@protoc_insertion_point(field_release:proto.Message.productMessage) + _impl_._has_bits_[0] &= ~0x01000000u; + ::proto::Message_ProductMessage* temp = _impl_.productmessage_; + _impl_.productmessage_ = nullptr; + return temp; +} +inline ::proto::Message_ProductMessage* Message::_internal_mutable_productmessage() { + _impl_._has_bits_[0] |= 0x01000000u; + if (_impl_.productmessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_ProductMessage>(GetArenaForAllocation()); + _impl_.productmessage_ = p; + } + return _impl_.productmessage_; +} +inline ::proto::Message_ProductMessage* Message::mutable_productmessage() { + ::proto::Message_ProductMessage* _msg = _internal_mutable_productmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.productMessage) + return _msg; +} +inline void Message::set_allocated_productmessage(::proto::Message_ProductMessage* productmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.productmessage_; + } + if (productmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(productmessage); + if (message_arena != submessage_arena) { + productmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, productmessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x01000000u; + } else { + _impl_._has_bits_[0] &= ~0x01000000u; + } + _impl_.productmessage_ = productmessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.productMessage) +} + +// optional .proto.Message.DeviceSentMessage deviceSentMessage = 31; +inline bool Message::_internal_has_devicesentmessage() const { + bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.devicesentmessage_ != nullptr); + return value; +} +inline bool Message::has_devicesentmessage() const { + return _internal_has_devicesentmessage(); +} +inline void Message::clear_devicesentmessage() { + if (_impl_.devicesentmessage_ != nullptr) _impl_.devicesentmessage_->Clear(); + _impl_._has_bits_[0] &= ~0x02000000u; +} +inline const ::proto::Message_DeviceSentMessage& Message::_internal_devicesentmessage() const { + const ::proto::Message_DeviceSentMessage* p = _impl_.devicesentmessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_DeviceSentMessage_default_instance_); +} +inline const ::proto::Message_DeviceSentMessage& Message::devicesentmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.deviceSentMessage) + return _internal_devicesentmessage(); +} +inline void Message::unsafe_arena_set_allocated_devicesentmessage( + ::proto::Message_DeviceSentMessage* devicesentmessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.devicesentmessage_); + } + _impl_.devicesentmessage_ = devicesentmessage; + if (devicesentmessage) { + _impl_._has_bits_[0] |= 0x02000000u; + } else { + _impl_._has_bits_[0] &= ~0x02000000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.deviceSentMessage) +} +inline ::proto::Message_DeviceSentMessage* Message::release_devicesentmessage() { + _impl_._has_bits_[0] &= ~0x02000000u; + ::proto::Message_DeviceSentMessage* temp = _impl_.devicesentmessage_; + _impl_.devicesentmessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_DeviceSentMessage* Message::unsafe_arena_release_devicesentmessage() { + // @@protoc_insertion_point(field_release:proto.Message.deviceSentMessage) + _impl_._has_bits_[0] &= ~0x02000000u; + ::proto::Message_DeviceSentMessage* temp = _impl_.devicesentmessage_; + _impl_.devicesentmessage_ = nullptr; + return temp; +} +inline ::proto::Message_DeviceSentMessage* Message::_internal_mutable_devicesentmessage() { + _impl_._has_bits_[0] |= 0x02000000u; + if (_impl_.devicesentmessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_DeviceSentMessage>(GetArenaForAllocation()); + _impl_.devicesentmessage_ = p; + } + return _impl_.devicesentmessage_; +} +inline ::proto::Message_DeviceSentMessage* Message::mutable_devicesentmessage() { + ::proto::Message_DeviceSentMessage* _msg = _internal_mutable_devicesentmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.deviceSentMessage) + return _msg; +} +inline void Message::set_allocated_devicesentmessage(::proto::Message_DeviceSentMessage* devicesentmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.devicesentmessage_; + } + if (devicesentmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(devicesentmessage); + if (message_arena != submessage_arena) { + devicesentmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, devicesentmessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x02000000u; + } else { + _impl_._has_bits_[0] &= ~0x02000000u; + } + _impl_.devicesentmessage_ = devicesentmessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.deviceSentMessage) +} + +// optional .proto.MessageContextInfo messageContextInfo = 35; +inline bool Message::_internal_has_messagecontextinfo() const { + bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.messagecontextinfo_ != nullptr); + return value; +} +inline bool Message::has_messagecontextinfo() const { + return _internal_has_messagecontextinfo(); +} +inline void Message::clear_messagecontextinfo() { + if (_impl_.messagecontextinfo_ != nullptr) _impl_.messagecontextinfo_->Clear(); + _impl_._has_bits_[0] &= ~0x04000000u; +} +inline const ::proto::MessageContextInfo& Message::_internal_messagecontextinfo() const { + const ::proto::MessageContextInfo* p = _impl_.messagecontextinfo_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_MessageContextInfo_default_instance_); +} +inline const ::proto::MessageContextInfo& Message::messagecontextinfo() const { + // @@protoc_insertion_point(field_get:proto.Message.messageContextInfo) + return _internal_messagecontextinfo(); +} +inline void Message::unsafe_arena_set_allocated_messagecontextinfo( + ::proto::MessageContextInfo* messagecontextinfo) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.messagecontextinfo_); + } + _impl_.messagecontextinfo_ = messagecontextinfo; + if (messagecontextinfo) { + _impl_._has_bits_[0] |= 0x04000000u; + } else { + _impl_._has_bits_[0] &= ~0x04000000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.messageContextInfo) +} +inline ::proto::MessageContextInfo* Message::release_messagecontextinfo() { + _impl_._has_bits_[0] &= ~0x04000000u; + ::proto::MessageContextInfo* temp = _impl_.messagecontextinfo_; + _impl_.messagecontextinfo_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::MessageContextInfo* Message::unsafe_arena_release_messagecontextinfo() { + // @@protoc_insertion_point(field_release:proto.Message.messageContextInfo) + _impl_._has_bits_[0] &= ~0x04000000u; + ::proto::MessageContextInfo* temp = _impl_.messagecontextinfo_; + _impl_.messagecontextinfo_ = nullptr; + return temp; +} +inline ::proto::MessageContextInfo* Message::_internal_mutable_messagecontextinfo() { + _impl_._has_bits_[0] |= 0x04000000u; + if (_impl_.messagecontextinfo_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::MessageContextInfo>(GetArenaForAllocation()); + _impl_.messagecontextinfo_ = p; + } + return _impl_.messagecontextinfo_; +} +inline ::proto::MessageContextInfo* Message::mutable_messagecontextinfo() { + ::proto::MessageContextInfo* _msg = _internal_mutable_messagecontextinfo(); + // @@protoc_insertion_point(field_mutable:proto.Message.messageContextInfo) + return _msg; +} +inline void Message::set_allocated_messagecontextinfo(::proto::MessageContextInfo* messagecontextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.messagecontextinfo_; + } + if (messagecontextinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(messagecontextinfo); + if (message_arena != submessage_arena) { + messagecontextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, messagecontextinfo, submessage_arena); + } + _impl_._has_bits_[0] |= 0x04000000u; + } else { + _impl_._has_bits_[0] &= ~0x04000000u; + } + _impl_.messagecontextinfo_ = messagecontextinfo; + // @@protoc_insertion_point(field_set_allocated:proto.Message.messageContextInfo) +} + +// optional .proto.Message.ListMessage listMessage = 36; +inline bool Message::_internal_has_listmessage() const { + bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.listmessage_ != nullptr); + return value; +} +inline bool Message::has_listmessage() const { + return _internal_has_listmessage(); +} +inline void Message::clear_listmessage() { + if (_impl_.listmessage_ != nullptr) _impl_.listmessage_->Clear(); + _impl_._has_bits_[0] &= ~0x08000000u; +} +inline const ::proto::Message_ListMessage& Message::_internal_listmessage() const { + const ::proto::Message_ListMessage* p = _impl_.listmessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_ListMessage_default_instance_); +} +inline const ::proto::Message_ListMessage& Message::listmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.listMessage) + return _internal_listmessage(); +} +inline void Message::unsafe_arena_set_allocated_listmessage( + ::proto::Message_ListMessage* listmessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.listmessage_); + } + _impl_.listmessage_ = listmessage; + if (listmessage) { + _impl_._has_bits_[0] |= 0x08000000u; + } else { + _impl_._has_bits_[0] &= ~0x08000000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.listMessage) +} +inline ::proto::Message_ListMessage* Message::release_listmessage() { + _impl_._has_bits_[0] &= ~0x08000000u; + ::proto::Message_ListMessage* temp = _impl_.listmessage_; + _impl_.listmessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_ListMessage* Message::unsafe_arena_release_listmessage() { + // @@protoc_insertion_point(field_release:proto.Message.listMessage) + _impl_._has_bits_[0] &= ~0x08000000u; + ::proto::Message_ListMessage* temp = _impl_.listmessage_; + _impl_.listmessage_ = nullptr; + return temp; +} +inline ::proto::Message_ListMessage* Message::_internal_mutable_listmessage() { + _impl_._has_bits_[0] |= 0x08000000u; + if (_impl_.listmessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_ListMessage>(GetArenaForAllocation()); + _impl_.listmessage_ = p; + } + return _impl_.listmessage_; +} +inline ::proto::Message_ListMessage* Message::mutable_listmessage() { + ::proto::Message_ListMessage* _msg = _internal_mutable_listmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.listMessage) + return _msg; +} +inline void Message::set_allocated_listmessage(::proto::Message_ListMessage* listmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.listmessage_; + } + if (listmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(listmessage); + if (message_arena != submessage_arena) { + listmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, listmessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x08000000u; + } else { + _impl_._has_bits_[0] &= ~0x08000000u; + } + _impl_.listmessage_ = listmessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.listMessage) +} + +// optional .proto.Message.FutureProofMessage viewOnceMessage = 37; +inline bool Message::_internal_has_viewoncemessage() const { + bool value = (_impl_._has_bits_[0] & 0x10000000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.viewoncemessage_ != nullptr); + return value; +} +inline bool Message::has_viewoncemessage() const { + return _internal_has_viewoncemessage(); +} +inline void Message::clear_viewoncemessage() { + if (_impl_.viewoncemessage_ != nullptr) _impl_.viewoncemessage_->Clear(); + _impl_._has_bits_[0] &= ~0x10000000u; +} +inline const ::proto::Message_FutureProofMessage& Message::_internal_viewoncemessage() const { + const ::proto::Message_FutureProofMessage* p = _impl_.viewoncemessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_FutureProofMessage_default_instance_); +} +inline const ::proto::Message_FutureProofMessage& Message::viewoncemessage() const { + // @@protoc_insertion_point(field_get:proto.Message.viewOnceMessage) + return _internal_viewoncemessage(); +} +inline void Message::unsafe_arena_set_allocated_viewoncemessage( + ::proto::Message_FutureProofMessage* viewoncemessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.viewoncemessage_); + } + _impl_.viewoncemessage_ = viewoncemessage; + if (viewoncemessage) { + _impl_._has_bits_[0] |= 0x10000000u; + } else { + _impl_._has_bits_[0] &= ~0x10000000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.viewOnceMessage) +} +inline ::proto::Message_FutureProofMessage* Message::release_viewoncemessage() { + _impl_._has_bits_[0] &= ~0x10000000u; + ::proto::Message_FutureProofMessage* temp = _impl_.viewoncemessage_; + _impl_.viewoncemessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_FutureProofMessage* Message::unsafe_arena_release_viewoncemessage() { + // @@protoc_insertion_point(field_release:proto.Message.viewOnceMessage) + _impl_._has_bits_[0] &= ~0x10000000u; + ::proto::Message_FutureProofMessage* temp = _impl_.viewoncemessage_; + _impl_.viewoncemessage_ = nullptr; + return temp; +} +inline ::proto::Message_FutureProofMessage* Message::_internal_mutable_viewoncemessage() { + _impl_._has_bits_[0] |= 0x10000000u; + if (_impl_.viewoncemessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_FutureProofMessage>(GetArenaForAllocation()); + _impl_.viewoncemessage_ = p; + } + return _impl_.viewoncemessage_; +} +inline ::proto::Message_FutureProofMessage* Message::mutable_viewoncemessage() { + ::proto::Message_FutureProofMessage* _msg = _internal_mutable_viewoncemessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.viewOnceMessage) + return _msg; +} +inline void Message::set_allocated_viewoncemessage(::proto::Message_FutureProofMessage* viewoncemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.viewoncemessage_; + } + if (viewoncemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(viewoncemessage); + if (message_arena != submessage_arena) { + viewoncemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, viewoncemessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x10000000u; + } else { + _impl_._has_bits_[0] &= ~0x10000000u; + } + _impl_.viewoncemessage_ = viewoncemessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.viewOnceMessage) +} + +// optional .proto.Message.OrderMessage orderMessage = 38; +inline bool Message::_internal_has_ordermessage() const { + bool value = (_impl_._has_bits_[0] & 0x20000000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.ordermessage_ != nullptr); + return value; +} +inline bool Message::has_ordermessage() const { + return _internal_has_ordermessage(); +} +inline void Message::clear_ordermessage() { + if (_impl_.ordermessage_ != nullptr) _impl_.ordermessage_->Clear(); + _impl_._has_bits_[0] &= ~0x20000000u; +} +inline const ::proto::Message_OrderMessage& Message::_internal_ordermessage() const { + const ::proto::Message_OrderMessage* p = _impl_.ordermessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_OrderMessage_default_instance_); +} +inline const ::proto::Message_OrderMessage& Message::ordermessage() const { + // @@protoc_insertion_point(field_get:proto.Message.orderMessage) + return _internal_ordermessage(); +} +inline void Message::unsafe_arena_set_allocated_ordermessage( + ::proto::Message_OrderMessage* ordermessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.ordermessage_); + } + _impl_.ordermessage_ = ordermessage; + if (ordermessage) { + _impl_._has_bits_[0] |= 0x20000000u; + } else { + _impl_._has_bits_[0] &= ~0x20000000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.orderMessage) +} +inline ::proto::Message_OrderMessage* Message::release_ordermessage() { + _impl_._has_bits_[0] &= ~0x20000000u; + ::proto::Message_OrderMessage* temp = _impl_.ordermessage_; + _impl_.ordermessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_OrderMessage* Message::unsafe_arena_release_ordermessage() { + // @@protoc_insertion_point(field_release:proto.Message.orderMessage) + _impl_._has_bits_[0] &= ~0x20000000u; + ::proto::Message_OrderMessage* temp = _impl_.ordermessage_; + _impl_.ordermessage_ = nullptr; + return temp; +} +inline ::proto::Message_OrderMessage* Message::_internal_mutable_ordermessage() { + _impl_._has_bits_[0] |= 0x20000000u; + if (_impl_.ordermessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_OrderMessage>(GetArenaForAllocation()); + _impl_.ordermessage_ = p; + } + return _impl_.ordermessage_; +} +inline ::proto::Message_OrderMessage* Message::mutable_ordermessage() { + ::proto::Message_OrderMessage* _msg = _internal_mutable_ordermessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.orderMessage) + return _msg; +} +inline void Message::set_allocated_ordermessage(::proto::Message_OrderMessage* ordermessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.ordermessage_; + } + if (ordermessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(ordermessage); + if (message_arena != submessage_arena) { + ordermessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, ordermessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x20000000u; + } else { + _impl_._has_bits_[0] &= ~0x20000000u; + } + _impl_.ordermessage_ = ordermessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.orderMessage) +} + +// optional .proto.Message.ListResponseMessage listResponseMessage = 39; +inline bool Message::_internal_has_listresponsemessage() const { + bool value = (_impl_._has_bits_[0] & 0x40000000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.listresponsemessage_ != nullptr); + return value; +} +inline bool Message::has_listresponsemessage() const { + return _internal_has_listresponsemessage(); +} +inline void Message::clear_listresponsemessage() { + if (_impl_.listresponsemessage_ != nullptr) _impl_.listresponsemessage_->Clear(); + _impl_._has_bits_[0] &= ~0x40000000u; +} +inline const ::proto::Message_ListResponseMessage& Message::_internal_listresponsemessage() const { + const ::proto::Message_ListResponseMessage* p = _impl_.listresponsemessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_ListResponseMessage_default_instance_); +} +inline const ::proto::Message_ListResponseMessage& Message::listresponsemessage() const { + // @@protoc_insertion_point(field_get:proto.Message.listResponseMessage) + return _internal_listresponsemessage(); +} +inline void Message::unsafe_arena_set_allocated_listresponsemessage( + ::proto::Message_ListResponseMessage* listresponsemessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.listresponsemessage_); + } + _impl_.listresponsemessage_ = listresponsemessage; + if (listresponsemessage) { + _impl_._has_bits_[0] |= 0x40000000u; + } else { + _impl_._has_bits_[0] &= ~0x40000000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.listResponseMessage) +} +inline ::proto::Message_ListResponseMessage* Message::release_listresponsemessage() { + _impl_._has_bits_[0] &= ~0x40000000u; + ::proto::Message_ListResponseMessage* temp = _impl_.listresponsemessage_; + _impl_.listresponsemessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_ListResponseMessage* Message::unsafe_arena_release_listresponsemessage() { + // @@protoc_insertion_point(field_release:proto.Message.listResponseMessage) + _impl_._has_bits_[0] &= ~0x40000000u; + ::proto::Message_ListResponseMessage* temp = _impl_.listresponsemessage_; + _impl_.listresponsemessage_ = nullptr; + return temp; +} +inline ::proto::Message_ListResponseMessage* Message::_internal_mutable_listresponsemessage() { + _impl_._has_bits_[0] |= 0x40000000u; + if (_impl_.listresponsemessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_ListResponseMessage>(GetArenaForAllocation()); + _impl_.listresponsemessage_ = p; + } + return _impl_.listresponsemessage_; +} +inline ::proto::Message_ListResponseMessage* Message::mutable_listresponsemessage() { + ::proto::Message_ListResponseMessage* _msg = _internal_mutable_listresponsemessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.listResponseMessage) + return _msg; +} +inline void Message::set_allocated_listresponsemessage(::proto::Message_ListResponseMessage* listresponsemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.listresponsemessage_; + } + if (listresponsemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(listresponsemessage); + if (message_arena != submessage_arena) { + listresponsemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, listresponsemessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x40000000u; + } else { + _impl_._has_bits_[0] &= ~0x40000000u; + } + _impl_.listresponsemessage_ = listresponsemessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.listResponseMessage) +} + +// optional .proto.Message.FutureProofMessage ephemeralMessage = 40; +inline bool Message::_internal_has_ephemeralmessage() const { + bool value = (_impl_._has_bits_[0] & 0x80000000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.ephemeralmessage_ != nullptr); + return value; +} +inline bool Message::has_ephemeralmessage() const { + return _internal_has_ephemeralmessage(); +} +inline void Message::clear_ephemeralmessage() { + if (_impl_.ephemeralmessage_ != nullptr) _impl_.ephemeralmessage_->Clear(); + _impl_._has_bits_[0] &= ~0x80000000u; +} +inline const ::proto::Message_FutureProofMessage& Message::_internal_ephemeralmessage() const { + const ::proto::Message_FutureProofMessage* p = _impl_.ephemeralmessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_FutureProofMessage_default_instance_); +} +inline const ::proto::Message_FutureProofMessage& Message::ephemeralmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.ephemeralMessage) + return _internal_ephemeralmessage(); +} +inline void Message::unsafe_arena_set_allocated_ephemeralmessage( + ::proto::Message_FutureProofMessage* ephemeralmessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.ephemeralmessage_); + } + _impl_.ephemeralmessage_ = ephemeralmessage; + if (ephemeralmessage) { + _impl_._has_bits_[0] |= 0x80000000u; + } else { + _impl_._has_bits_[0] &= ~0x80000000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ephemeralMessage) +} +inline ::proto::Message_FutureProofMessage* Message::release_ephemeralmessage() { + _impl_._has_bits_[0] &= ~0x80000000u; + ::proto::Message_FutureProofMessage* temp = _impl_.ephemeralmessage_; + _impl_.ephemeralmessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_FutureProofMessage* Message::unsafe_arena_release_ephemeralmessage() { + // @@protoc_insertion_point(field_release:proto.Message.ephemeralMessage) + _impl_._has_bits_[0] &= ~0x80000000u; + ::proto::Message_FutureProofMessage* temp = _impl_.ephemeralmessage_; + _impl_.ephemeralmessage_ = nullptr; + return temp; +} +inline ::proto::Message_FutureProofMessage* Message::_internal_mutable_ephemeralmessage() { + _impl_._has_bits_[0] |= 0x80000000u; + if (_impl_.ephemeralmessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_FutureProofMessage>(GetArenaForAllocation()); + _impl_.ephemeralmessage_ = p; + } + return _impl_.ephemeralmessage_; +} +inline ::proto::Message_FutureProofMessage* Message::mutable_ephemeralmessage() { + ::proto::Message_FutureProofMessage* _msg = _internal_mutable_ephemeralmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.ephemeralMessage) + return _msg; +} +inline void Message::set_allocated_ephemeralmessage(::proto::Message_FutureProofMessage* ephemeralmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.ephemeralmessage_; + } + if (ephemeralmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(ephemeralmessage); + if (message_arena != submessage_arena) { + ephemeralmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, ephemeralmessage, submessage_arena); + } + _impl_._has_bits_[0] |= 0x80000000u; + } else { + _impl_._has_bits_[0] &= ~0x80000000u; + } + _impl_.ephemeralmessage_ = ephemeralmessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.ephemeralMessage) +} + +// optional .proto.Message.InvoiceMessage invoiceMessage = 41; +inline bool Message::_internal_has_invoicemessage() const { + bool value = (_impl_._has_bits_[1] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.invoicemessage_ != nullptr); + return value; +} +inline bool Message::has_invoicemessage() const { + return _internal_has_invoicemessage(); +} +inline void Message::clear_invoicemessage() { + if (_impl_.invoicemessage_ != nullptr) _impl_.invoicemessage_->Clear(); + _impl_._has_bits_[1] &= ~0x00000001u; +} +inline const ::proto::Message_InvoiceMessage& Message::_internal_invoicemessage() const { + const ::proto::Message_InvoiceMessage* p = _impl_.invoicemessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_InvoiceMessage_default_instance_); +} +inline const ::proto::Message_InvoiceMessage& Message::invoicemessage() const { + // @@protoc_insertion_point(field_get:proto.Message.invoiceMessage) + return _internal_invoicemessage(); +} +inline void Message::unsafe_arena_set_allocated_invoicemessage( + ::proto::Message_InvoiceMessage* invoicemessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.invoicemessage_); + } + _impl_.invoicemessage_ = invoicemessage; + if (invoicemessage) { + _impl_._has_bits_[1] |= 0x00000001u; + } else { + _impl_._has_bits_[1] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.invoiceMessage) +} +inline ::proto::Message_InvoiceMessage* Message::release_invoicemessage() { + _impl_._has_bits_[1] &= ~0x00000001u; + ::proto::Message_InvoiceMessage* temp = _impl_.invoicemessage_; + _impl_.invoicemessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_InvoiceMessage* Message::unsafe_arena_release_invoicemessage() { + // @@protoc_insertion_point(field_release:proto.Message.invoiceMessage) + _impl_._has_bits_[1] &= ~0x00000001u; + ::proto::Message_InvoiceMessage* temp = _impl_.invoicemessage_; + _impl_.invoicemessage_ = nullptr; + return temp; +} +inline ::proto::Message_InvoiceMessage* Message::_internal_mutable_invoicemessage() { + _impl_._has_bits_[1] |= 0x00000001u; + if (_impl_.invoicemessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_InvoiceMessage>(GetArenaForAllocation()); + _impl_.invoicemessage_ = p; + } + return _impl_.invoicemessage_; +} +inline ::proto::Message_InvoiceMessage* Message::mutable_invoicemessage() { + ::proto::Message_InvoiceMessage* _msg = _internal_mutable_invoicemessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.invoiceMessage) + return _msg; +} +inline void Message::set_allocated_invoicemessage(::proto::Message_InvoiceMessage* invoicemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.invoicemessage_; + } + if (invoicemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(invoicemessage); + if (message_arena != submessage_arena) { + invoicemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, invoicemessage, submessage_arena); + } + _impl_._has_bits_[1] |= 0x00000001u; + } else { + _impl_._has_bits_[1] &= ~0x00000001u; + } + _impl_.invoicemessage_ = invoicemessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.invoiceMessage) +} + +// optional .proto.Message.ButtonsMessage buttonsMessage = 42; +inline bool Message::_internal_has_buttonsmessage() const { + bool value = (_impl_._has_bits_[1] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.buttonsmessage_ != nullptr); + return value; +} +inline bool Message::has_buttonsmessage() const { + return _internal_has_buttonsmessage(); +} +inline void Message::clear_buttonsmessage() { + if (_impl_.buttonsmessage_ != nullptr) _impl_.buttonsmessage_->Clear(); + _impl_._has_bits_[1] &= ~0x00000002u; +} +inline const ::proto::Message_ButtonsMessage& Message::_internal_buttonsmessage() const { + const ::proto::Message_ButtonsMessage* p = _impl_.buttonsmessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_ButtonsMessage_default_instance_); +} +inline const ::proto::Message_ButtonsMessage& Message::buttonsmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.buttonsMessage) + return _internal_buttonsmessage(); +} +inline void Message::unsafe_arena_set_allocated_buttonsmessage( + ::proto::Message_ButtonsMessage* buttonsmessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.buttonsmessage_); + } + _impl_.buttonsmessage_ = buttonsmessage; + if (buttonsmessage) { + _impl_._has_bits_[1] |= 0x00000002u; + } else { + _impl_._has_bits_[1] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.buttonsMessage) +} +inline ::proto::Message_ButtonsMessage* Message::release_buttonsmessage() { + _impl_._has_bits_[1] &= ~0x00000002u; + ::proto::Message_ButtonsMessage* temp = _impl_.buttonsmessage_; + _impl_.buttonsmessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_ButtonsMessage* Message::unsafe_arena_release_buttonsmessage() { + // @@protoc_insertion_point(field_release:proto.Message.buttonsMessage) + _impl_._has_bits_[1] &= ~0x00000002u; + ::proto::Message_ButtonsMessage* temp = _impl_.buttonsmessage_; + _impl_.buttonsmessage_ = nullptr; + return temp; +} +inline ::proto::Message_ButtonsMessage* Message::_internal_mutable_buttonsmessage() { + _impl_._has_bits_[1] |= 0x00000002u; + if (_impl_.buttonsmessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_ButtonsMessage>(GetArenaForAllocation()); + _impl_.buttonsmessage_ = p; + } + return _impl_.buttonsmessage_; +} +inline ::proto::Message_ButtonsMessage* Message::mutable_buttonsmessage() { + ::proto::Message_ButtonsMessage* _msg = _internal_mutable_buttonsmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.buttonsMessage) + return _msg; +} +inline void Message::set_allocated_buttonsmessage(::proto::Message_ButtonsMessage* buttonsmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.buttonsmessage_; + } + if (buttonsmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(buttonsmessage); + if (message_arena != submessage_arena) { + buttonsmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, buttonsmessage, submessage_arena); + } + _impl_._has_bits_[1] |= 0x00000002u; + } else { + _impl_._has_bits_[1] &= ~0x00000002u; + } + _impl_.buttonsmessage_ = buttonsmessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.buttonsMessage) +} + +// optional .proto.Message.ButtonsResponseMessage buttonsResponseMessage = 43; +inline bool Message::_internal_has_buttonsresponsemessage() const { + bool value = (_impl_._has_bits_[1] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.buttonsresponsemessage_ != nullptr); + return value; +} +inline bool Message::has_buttonsresponsemessage() const { + return _internal_has_buttonsresponsemessage(); +} +inline void Message::clear_buttonsresponsemessage() { + if (_impl_.buttonsresponsemessage_ != nullptr) _impl_.buttonsresponsemessage_->Clear(); + _impl_._has_bits_[1] &= ~0x00000004u; +} +inline const ::proto::Message_ButtonsResponseMessage& Message::_internal_buttonsresponsemessage() const { + const ::proto::Message_ButtonsResponseMessage* p = _impl_.buttonsresponsemessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_ButtonsResponseMessage_default_instance_); +} +inline const ::proto::Message_ButtonsResponseMessage& Message::buttonsresponsemessage() const { + // @@protoc_insertion_point(field_get:proto.Message.buttonsResponseMessage) + return _internal_buttonsresponsemessage(); +} +inline void Message::unsafe_arena_set_allocated_buttonsresponsemessage( + ::proto::Message_ButtonsResponseMessage* buttonsresponsemessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.buttonsresponsemessage_); + } + _impl_.buttonsresponsemessage_ = buttonsresponsemessage; + if (buttonsresponsemessage) { + _impl_._has_bits_[1] |= 0x00000004u; + } else { + _impl_._has_bits_[1] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.buttonsResponseMessage) +} +inline ::proto::Message_ButtonsResponseMessage* Message::release_buttonsresponsemessage() { + _impl_._has_bits_[1] &= ~0x00000004u; + ::proto::Message_ButtonsResponseMessage* temp = _impl_.buttonsresponsemessage_; + _impl_.buttonsresponsemessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_ButtonsResponseMessage* Message::unsafe_arena_release_buttonsresponsemessage() { + // @@protoc_insertion_point(field_release:proto.Message.buttonsResponseMessage) + _impl_._has_bits_[1] &= ~0x00000004u; + ::proto::Message_ButtonsResponseMessage* temp = _impl_.buttonsresponsemessage_; + _impl_.buttonsresponsemessage_ = nullptr; + return temp; +} +inline ::proto::Message_ButtonsResponseMessage* Message::_internal_mutable_buttonsresponsemessage() { + _impl_._has_bits_[1] |= 0x00000004u; + if (_impl_.buttonsresponsemessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_ButtonsResponseMessage>(GetArenaForAllocation()); + _impl_.buttonsresponsemessage_ = p; + } + return _impl_.buttonsresponsemessage_; +} +inline ::proto::Message_ButtonsResponseMessage* Message::mutable_buttonsresponsemessage() { + ::proto::Message_ButtonsResponseMessage* _msg = _internal_mutable_buttonsresponsemessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.buttonsResponseMessage) + return _msg; +} +inline void Message::set_allocated_buttonsresponsemessage(::proto::Message_ButtonsResponseMessage* buttonsresponsemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.buttonsresponsemessage_; + } + if (buttonsresponsemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(buttonsresponsemessage); + if (message_arena != submessage_arena) { + buttonsresponsemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, buttonsresponsemessage, submessage_arena); + } + _impl_._has_bits_[1] |= 0x00000004u; + } else { + _impl_._has_bits_[1] &= ~0x00000004u; + } + _impl_.buttonsresponsemessage_ = buttonsresponsemessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.buttonsResponseMessage) +} + +// optional .proto.Message.PaymentInviteMessage paymentInviteMessage = 44; +inline bool Message::_internal_has_paymentinvitemessage() const { + bool value = (_impl_._has_bits_[1] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || _impl_.paymentinvitemessage_ != nullptr); + return value; +} +inline bool Message::has_paymentinvitemessage() const { + return _internal_has_paymentinvitemessage(); +} +inline void Message::clear_paymentinvitemessage() { + if (_impl_.paymentinvitemessage_ != nullptr) _impl_.paymentinvitemessage_->Clear(); + _impl_._has_bits_[1] &= ~0x00000008u; +} +inline const ::proto::Message_PaymentInviteMessage& Message::_internal_paymentinvitemessage() const { + const ::proto::Message_PaymentInviteMessage* p = _impl_.paymentinvitemessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_PaymentInviteMessage_default_instance_); +} +inline const ::proto::Message_PaymentInviteMessage& Message::paymentinvitemessage() const { + // @@protoc_insertion_point(field_get:proto.Message.paymentInviteMessage) + return _internal_paymentinvitemessage(); +} +inline void Message::unsafe_arena_set_allocated_paymentinvitemessage( + ::proto::Message_PaymentInviteMessage* paymentinvitemessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.paymentinvitemessage_); + } + _impl_.paymentinvitemessage_ = paymentinvitemessage; + if (paymentinvitemessage) { + _impl_._has_bits_[1] |= 0x00000008u; + } else { + _impl_._has_bits_[1] &= ~0x00000008u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.paymentInviteMessage) +} +inline ::proto::Message_PaymentInviteMessage* Message::release_paymentinvitemessage() { + _impl_._has_bits_[1] &= ~0x00000008u; + ::proto::Message_PaymentInviteMessage* temp = _impl_.paymentinvitemessage_; + _impl_.paymentinvitemessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_PaymentInviteMessage* Message::unsafe_arena_release_paymentinvitemessage() { + // @@protoc_insertion_point(field_release:proto.Message.paymentInviteMessage) + _impl_._has_bits_[1] &= ~0x00000008u; + ::proto::Message_PaymentInviteMessage* temp = _impl_.paymentinvitemessage_; + _impl_.paymentinvitemessage_ = nullptr; + return temp; +} +inline ::proto::Message_PaymentInviteMessage* Message::_internal_mutable_paymentinvitemessage() { + _impl_._has_bits_[1] |= 0x00000008u; + if (_impl_.paymentinvitemessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_PaymentInviteMessage>(GetArenaForAllocation()); + _impl_.paymentinvitemessage_ = p; + } + return _impl_.paymentinvitemessage_; +} +inline ::proto::Message_PaymentInviteMessage* Message::mutable_paymentinvitemessage() { + ::proto::Message_PaymentInviteMessage* _msg = _internal_mutable_paymentinvitemessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.paymentInviteMessage) + return _msg; +} +inline void Message::set_allocated_paymentinvitemessage(::proto::Message_PaymentInviteMessage* paymentinvitemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.paymentinvitemessage_; + } + if (paymentinvitemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(paymentinvitemessage); + if (message_arena != submessage_arena) { + paymentinvitemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, paymentinvitemessage, submessage_arena); + } + _impl_._has_bits_[1] |= 0x00000008u; + } else { + _impl_._has_bits_[1] &= ~0x00000008u; + } + _impl_.paymentinvitemessage_ = paymentinvitemessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.paymentInviteMessage) +} + +// optional .proto.Message.InteractiveMessage interactiveMessage = 45; +inline bool Message::_internal_has_interactivemessage() const { + bool value = (_impl_._has_bits_[1] & 0x00000010u) != 0; + PROTOBUF_ASSUME(!value || _impl_.interactivemessage_ != nullptr); + return value; +} +inline bool Message::has_interactivemessage() const { + return _internal_has_interactivemessage(); +} +inline void Message::clear_interactivemessage() { + if (_impl_.interactivemessage_ != nullptr) _impl_.interactivemessage_->Clear(); + _impl_._has_bits_[1] &= ~0x00000010u; +} +inline const ::proto::Message_InteractiveMessage& Message::_internal_interactivemessage() const { + const ::proto::Message_InteractiveMessage* p = _impl_.interactivemessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_InteractiveMessage_default_instance_); +} +inline const ::proto::Message_InteractiveMessage& Message::interactivemessage() const { + // @@protoc_insertion_point(field_get:proto.Message.interactiveMessage) + return _internal_interactivemessage(); +} +inline void Message::unsafe_arena_set_allocated_interactivemessage( + ::proto::Message_InteractiveMessage* interactivemessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.interactivemessage_); + } + _impl_.interactivemessage_ = interactivemessage; + if (interactivemessage) { + _impl_._has_bits_[1] |= 0x00000010u; + } else { + _impl_._has_bits_[1] &= ~0x00000010u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.interactiveMessage) +} +inline ::proto::Message_InteractiveMessage* Message::release_interactivemessage() { + _impl_._has_bits_[1] &= ~0x00000010u; + ::proto::Message_InteractiveMessage* temp = _impl_.interactivemessage_; + _impl_.interactivemessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_InteractiveMessage* Message::unsafe_arena_release_interactivemessage() { + // @@protoc_insertion_point(field_release:proto.Message.interactiveMessage) + _impl_._has_bits_[1] &= ~0x00000010u; + ::proto::Message_InteractiveMessage* temp = _impl_.interactivemessage_; + _impl_.interactivemessage_ = nullptr; + return temp; +} +inline ::proto::Message_InteractiveMessage* Message::_internal_mutable_interactivemessage() { + _impl_._has_bits_[1] |= 0x00000010u; + if (_impl_.interactivemessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_InteractiveMessage>(GetArenaForAllocation()); + _impl_.interactivemessage_ = p; + } + return _impl_.interactivemessage_; +} +inline ::proto::Message_InteractiveMessage* Message::mutable_interactivemessage() { + ::proto::Message_InteractiveMessage* _msg = _internal_mutable_interactivemessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.interactiveMessage) + return _msg; +} +inline void Message::set_allocated_interactivemessage(::proto::Message_InteractiveMessage* interactivemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.interactivemessage_; + } + if (interactivemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(interactivemessage); + if (message_arena != submessage_arena) { + interactivemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, interactivemessage, submessage_arena); + } + _impl_._has_bits_[1] |= 0x00000010u; + } else { + _impl_._has_bits_[1] &= ~0x00000010u; + } + _impl_.interactivemessage_ = interactivemessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.interactiveMessage) +} + +// optional .proto.Message.ReactionMessage reactionMessage = 46; +inline bool Message::_internal_has_reactionmessage() const { + bool value = (_impl_._has_bits_[1] & 0x00000020u) != 0; + PROTOBUF_ASSUME(!value || _impl_.reactionmessage_ != nullptr); + return value; +} +inline bool Message::has_reactionmessage() const { + return _internal_has_reactionmessage(); +} +inline void Message::clear_reactionmessage() { + if (_impl_.reactionmessage_ != nullptr) _impl_.reactionmessage_->Clear(); + _impl_._has_bits_[1] &= ~0x00000020u; +} +inline const ::proto::Message_ReactionMessage& Message::_internal_reactionmessage() const { + const ::proto::Message_ReactionMessage* p = _impl_.reactionmessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_ReactionMessage_default_instance_); +} +inline const ::proto::Message_ReactionMessage& Message::reactionmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.reactionMessage) + return _internal_reactionmessage(); +} +inline void Message::unsafe_arena_set_allocated_reactionmessage( + ::proto::Message_ReactionMessage* reactionmessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.reactionmessage_); + } + _impl_.reactionmessage_ = reactionmessage; + if (reactionmessage) { + _impl_._has_bits_[1] |= 0x00000020u; + } else { + _impl_._has_bits_[1] &= ~0x00000020u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.reactionMessage) +} +inline ::proto::Message_ReactionMessage* Message::release_reactionmessage() { + _impl_._has_bits_[1] &= ~0x00000020u; + ::proto::Message_ReactionMessage* temp = _impl_.reactionmessage_; + _impl_.reactionmessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_ReactionMessage* Message::unsafe_arena_release_reactionmessage() { + // @@protoc_insertion_point(field_release:proto.Message.reactionMessage) + _impl_._has_bits_[1] &= ~0x00000020u; + ::proto::Message_ReactionMessage* temp = _impl_.reactionmessage_; + _impl_.reactionmessage_ = nullptr; + return temp; +} +inline ::proto::Message_ReactionMessage* Message::_internal_mutable_reactionmessage() { + _impl_._has_bits_[1] |= 0x00000020u; + if (_impl_.reactionmessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_ReactionMessage>(GetArenaForAllocation()); + _impl_.reactionmessage_ = p; + } + return _impl_.reactionmessage_; +} +inline ::proto::Message_ReactionMessage* Message::mutable_reactionmessage() { + ::proto::Message_ReactionMessage* _msg = _internal_mutable_reactionmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.reactionMessage) + return _msg; +} +inline void Message::set_allocated_reactionmessage(::proto::Message_ReactionMessage* reactionmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.reactionmessage_; + } + if (reactionmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(reactionmessage); + if (message_arena != submessage_arena) { + reactionmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, reactionmessage, submessage_arena); + } + _impl_._has_bits_[1] |= 0x00000020u; + } else { + _impl_._has_bits_[1] &= ~0x00000020u; + } + _impl_.reactionmessage_ = reactionmessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.reactionMessage) +} + +// optional .proto.Message.StickerSyncRMRMessage stickerSyncRmrMessage = 47; +inline bool Message::_internal_has_stickersyncrmrmessage() const { + bool value = (_impl_._has_bits_[1] & 0x00000040u) != 0; + PROTOBUF_ASSUME(!value || _impl_.stickersyncrmrmessage_ != nullptr); + return value; +} +inline bool Message::has_stickersyncrmrmessage() const { + return _internal_has_stickersyncrmrmessage(); +} +inline void Message::clear_stickersyncrmrmessage() { + if (_impl_.stickersyncrmrmessage_ != nullptr) _impl_.stickersyncrmrmessage_->Clear(); + _impl_._has_bits_[1] &= ~0x00000040u; +} +inline const ::proto::Message_StickerSyncRMRMessage& Message::_internal_stickersyncrmrmessage() const { + const ::proto::Message_StickerSyncRMRMessage* p = _impl_.stickersyncrmrmessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_StickerSyncRMRMessage_default_instance_); +} +inline const ::proto::Message_StickerSyncRMRMessage& Message::stickersyncrmrmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.stickerSyncRmrMessage) + return _internal_stickersyncrmrmessage(); +} +inline void Message::unsafe_arena_set_allocated_stickersyncrmrmessage( + ::proto::Message_StickerSyncRMRMessage* stickersyncrmrmessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.stickersyncrmrmessage_); + } + _impl_.stickersyncrmrmessage_ = stickersyncrmrmessage; + if (stickersyncrmrmessage) { + _impl_._has_bits_[1] |= 0x00000040u; + } else { + _impl_._has_bits_[1] &= ~0x00000040u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.stickerSyncRmrMessage) +} +inline ::proto::Message_StickerSyncRMRMessage* Message::release_stickersyncrmrmessage() { + _impl_._has_bits_[1] &= ~0x00000040u; + ::proto::Message_StickerSyncRMRMessage* temp = _impl_.stickersyncrmrmessage_; + _impl_.stickersyncrmrmessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_StickerSyncRMRMessage* Message::unsafe_arena_release_stickersyncrmrmessage() { + // @@protoc_insertion_point(field_release:proto.Message.stickerSyncRmrMessage) + _impl_._has_bits_[1] &= ~0x00000040u; + ::proto::Message_StickerSyncRMRMessage* temp = _impl_.stickersyncrmrmessage_; + _impl_.stickersyncrmrmessage_ = nullptr; + return temp; +} +inline ::proto::Message_StickerSyncRMRMessage* Message::_internal_mutable_stickersyncrmrmessage() { + _impl_._has_bits_[1] |= 0x00000040u; + if (_impl_.stickersyncrmrmessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_StickerSyncRMRMessage>(GetArenaForAllocation()); + _impl_.stickersyncrmrmessage_ = p; + } + return _impl_.stickersyncrmrmessage_; +} +inline ::proto::Message_StickerSyncRMRMessage* Message::mutable_stickersyncrmrmessage() { + ::proto::Message_StickerSyncRMRMessage* _msg = _internal_mutable_stickersyncrmrmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.stickerSyncRmrMessage) + return _msg; +} +inline void Message::set_allocated_stickersyncrmrmessage(::proto::Message_StickerSyncRMRMessage* stickersyncrmrmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.stickersyncrmrmessage_; + } + if (stickersyncrmrmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(stickersyncrmrmessage); + if (message_arena != submessage_arena) { + stickersyncrmrmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, stickersyncrmrmessage, submessage_arena); + } + _impl_._has_bits_[1] |= 0x00000040u; + } else { + _impl_._has_bits_[1] &= ~0x00000040u; + } + _impl_.stickersyncrmrmessage_ = stickersyncrmrmessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.stickerSyncRmrMessage) +} + +// optional .proto.Message.InteractiveResponseMessage interactiveResponseMessage = 48; +inline bool Message::_internal_has_interactiveresponsemessage() const { + bool value = (_impl_._has_bits_[1] & 0x00000080u) != 0; + PROTOBUF_ASSUME(!value || _impl_.interactiveresponsemessage_ != nullptr); + return value; +} +inline bool Message::has_interactiveresponsemessage() const { + return _internal_has_interactiveresponsemessage(); +} +inline void Message::clear_interactiveresponsemessage() { + if (_impl_.interactiveresponsemessage_ != nullptr) _impl_.interactiveresponsemessage_->Clear(); + _impl_._has_bits_[1] &= ~0x00000080u; +} +inline const ::proto::Message_InteractiveResponseMessage& Message::_internal_interactiveresponsemessage() const { + const ::proto::Message_InteractiveResponseMessage* p = _impl_.interactiveresponsemessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_InteractiveResponseMessage_default_instance_); +} +inline const ::proto::Message_InteractiveResponseMessage& Message::interactiveresponsemessage() const { + // @@protoc_insertion_point(field_get:proto.Message.interactiveResponseMessage) + return _internal_interactiveresponsemessage(); +} +inline void Message::unsafe_arena_set_allocated_interactiveresponsemessage( + ::proto::Message_InteractiveResponseMessage* interactiveresponsemessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.interactiveresponsemessage_); + } + _impl_.interactiveresponsemessage_ = interactiveresponsemessage; + if (interactiveresponsemessage) { + _impl_._has_bits_[1] |= 0x00000080u; + } else { + _impl_._has_bits_[1] &= ~0x00000080u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.interactiveResponseMessage) +} +inline ::proto::Message_InteractiveResponseMessage* Message::release_interactiveresponsemessage() { + _impl_._has_bits_[1] &= ~0x00000080u; + ::proto::Message_InteractiveResponseMessage* temp = _impl_.interactiveresponsemessage_; + _impl_.interactiveresponsemessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_InteractiveResponseMessage* Message::unsafe_arena_release_interactiveresponsemessage() { + // @@protoc_insertion_point(field_release:proto.Message.interactiveResponseMessage) + _impl_._has_bits_[1] &= ~0x00000080u; + ::proto::Message_InteractiveResponseMessage* temp = _impl_.interactiveresponsemessage_; + _impl_.interactiveresponsemessage_ = nullptr; + return temp; +} +inline ::proto::Message_InteractiveResponseMessage* Message::_internal_mutable_interactiveresponsemessage() { + _impl_._has_bits_[1] |= 0x00000080u; + if (_impl_.interactiveresponsemessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_InteractiveResponseMessage>(GetArenaForAllocation()); + _impl_.interactiveresponsemessage_ = p; + } + return _impl_.interactiveresponsemessage_; +} +inline ::proto::Message_InteractiveResponseMessage* Message::mutable_interactiveresponsemessage() { + ::proto::Message_InteractiveResponseMessage* _msg = _internal_mutable_interactiveresponsemessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.interactiveResponseMessage) + return _msg; +} +inline void Message::set_allocated_interactiveresponsemessage(::proto::Message_InteractiveResponseMessage* interactiveresponsemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.interactiveresponsemessage_; + } + if (interactiveresponsemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(interactiveresponsemessage); + if (message_arena != submessage_arena) { + interactiveresponsemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, interactiveresponsemessage, submessage_arena); + } + _impl_._has_bits_[1] |= 0x00000080u; + } else { + _impl_._has_bits_[1] &= ~0x00000080u; + } + _impl_.interactiveresponsemessage_ = interactiveresponsemessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.interactiveResponseMessage) +} + +// optional .proto.Message.PollCreationMessage pollCreationMessage = 49; +inline bool Message::_internal_has_pollcreationmessage() const { + bool value = (_impl_._has_bits_[1] & 0x00000100u) != 0; + PROTOBUF_ASSUME(!value || _impl_.pollcreationmessage_ != nullptr); + return value; +} +inline bool Message::has_pollcreationmessage() const { + return _internal_has_pollcreationmessage(); +} +inline void Message::clear_pollcreationmessage() { + if (_impl_.pollcreationmessage_ != nullptr) _impl_.pollcreationmessage_->Clear(); + _impl_._has_bits_[1] &= ~0x00000100u; +} +inline const ::proto::Message_PollCreationMessage& Message::_internal_pollcreationmessage() const { + const ::proto::Message_PollCreationMessage* p = _impl_.pollcreationmessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_PollCreationMessage_default_instance_); +} +inline const ::proto::Message_PollCreationMessage& Message::pollcreationmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.pollCreationMessage) + return _internal_pollcreationmessage(); +} +inline void Message::unsafe_arena_set_allocated_pollcreationmessage( + ::proto::Message_PollCreationMessage* pollcreationmessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pollcreationmessage_); + } + _impl_.pollcreationmessage_ = pollcreationmessage; + if (pollcreationmessage) { + _impl_._has_bits_[1] |= 0x00000100u; + } else { + _impl_._has_bits_[1] &= ~0x00000100u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.pollCreationMessage) +} +inline ::proto::Message_PollCreationMessage* Message::release_pollcreationmessage() { + _impl_._has_bits_[1] &= ~0x00000100u; + ::proto::Message_PollCreationMessage* temp = _impl_.pollcreationmessage_; + _impl_.pollcreationmessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_PollCreationMessage* Message::unsafe_arena_release_pollcreationmessage() { + // @@protoc_insertion_point(field_release:proto.Message.pollCreationMessage) + _impl_._has_bits_[1] &= ~0x00000100u; + ::proto::Message_PollCreationMessage* temp = _impl_.pollcreationmessage_; + _impl_.pollcreationmessage_ = nullptr; + return temp; +} +inline ::proto::Message_PollCreationMessage* Message::_internal_mutable_pollcreationmessage() { + _impl_._has_bits_[1] |= 0x00000100u; + if (_impl_.pollcreationmessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_PollCreationMessage>(GetArenaForAllocation()); + _impl_.pollcreationmessage_ = p; + } + return _impl_.pollcreationmessage_; +} +inline ::proto::Message_PollCreationMessage* Message::mutable_pollcreationmessage() { + ::proto::Message_PollCreationMessage* _msg = _internal_mutable_pollcreationmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.pollCreationMessage) + return _msg; +} +inline void Message::set_allocated_pollcreationmessage(::proto::Message_PollCreationMessage* pollcreationmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.pollcreationmessage_; + } + if (pollcreationmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pollcreationmessage); + if (message_arena != submessage_arena) { + pollcreationmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, pollcreationmessage, submessage_arena); + } + _impl_._has_bits_[1] |= 0x00000100u; + } else { + _impl_._has_bits_[1] &= ~0x00000100u; + } + _impl_.pollcreationmessage_ = pollcreationmessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.pollCreationMessage) +} + +// optional .proto.Message.PollUpdateMessage pollUpdateMessage = 50; +inline bool Message::_internal_has_pollupdatemessage() const { + bool value = (_impl_._has_bits_[1] & 0x00000200u) != 0; + PROTOBUF_ASSUME(!value || _impl_.pollupdatemessage_ != nullptr); + return value; +} +inline bool Message::has_pollupdatemessage() const { + return _internal_has_pollupdatemessage(); +} +inline void Message::clear_pollupdatemessage() { + if (_impl_.pollupdatemessage_ != nullptr) _impl_.pollupdatemessage_->Clear(); + _impl_._has_bits_[1] &= ~0x00000200u; +} +inline const ::proto::Message_PollUpdateMessage& Message::_internal_pollupdatemessage() const { + const ::proto::Message_PollUpdateMessage* p = _impl_.pollupdatemessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_PollUpdateMessage_default_instance_); +} +inline const ::proto::Message_PollUpdateMessage& Message::pollupdatemessage() const { + // @@protoc_insertion_point(field_get:proto.Message.pollUpdateMessage) + return _internal_pollupdatemessage(); +} +inline void Message::unsafe_arena_set_allocated_pollupdatemessage( + ::proto::Message_PollUpdateMessage* pollupdatemessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pollupdatemessage_); + } + _impl_.pollupdatemessage_ = pollupdatemessage; + if (pollupdatemessage) { + _impl_._has_bits_[1] |= 0x00000200u; + } else { + _impl_._has_bits_[1] &= ~0x00000200u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.pollUpdateMessage) +} +inline ::proto::Message_PollUpdateMessage* Message::release_pollupdatemessage() { + _impl_._has_bits_[1] &= ~0x00000200u; + ::proto::Message_PollUpdateMessage* temp = _impl_.pollupdatemessage_; + _impl_.pollupdatemessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_PollUpdateMessage* Message::unsafe_arena_release_pollupdatemessage() { + // @@protoc_insertion_point(field_release:proto.Message.pollUpdateMessage) + _impl_._has_bits_[1] &= ~0x00000200u; + ::proto::Message_PollUpdateMessage* temp = _impl_.pollupdatemessage_; + _impl_.pollupdatemessage_ = nullptr; + return temp; +} +inline ::proto::Message_PollUpdateMessage* Message::_internal_mutable_pollupdatemessage() { + _impl_._has_bits_[1] |= 0x00000200u; + if (_impl_.pollupdatemessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_PollUpdateMessage>(GetArenaForAllocation()); + _impl_.pollupdatemessage_ = p; + } + return _impl_.pollupdatemessage_; +} +inline ::proto::Message_PollUpdateMessage* Message::mutable_pollupdatemessage() { + ::proto::Message_PollUpdateMessage* _msg = _internal_mutable_pollupdatemessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.pollUpdateMessage) + return _msg; +} +inline void Message::set_allocated_pollupdatemessage(::proto::Message_PollUpdateMessage* pollupdatemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.pollupdatemessage_; + } + if (pollupdatemessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pollupdatemessage); + if (message_arena != submessage_arena) { + pollupdatemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, pollupdatemessage, submessage_arena); + } + _impl_._has_bits_[1] |= 0x00000200u; + } else { + _impl_._has_bits_[1] &= ~0x00000200u; + } + _impl_.pollupdatemessage_ = pollupdatemessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.pollUpdateMessage) +} + +// optional .proto.Message.KeepInChatMessage keepInChatMessage = 51; +inline bool Message::_internal_has_keepinchatmessage() const { + bool value = (_impl_._has_bits_[1] & 0x00000400u) != 0; + PROTOBUF_ASSUME(!value || _impl_.keepinchatmessage_ != nullptr); + return value; +} +inline bool Message::has_keepinchatmessage() const { + return _internal_has_keepinchatmessage(); +} +inline void Message::clear_keepinchatmessage() { + if (_impl_.keepinchatmessage_ != nullptr) _impl_.keepinchatmessage_->Clear(); + _impl_._has_bits_[1] &= ~0x00000400u; +} +inline const ::proto::Message_KeepInChatMessage& Message::_internal_keepinchatmessage() const { + const ::proto::Message_KeepInChatMessage* p = _impl_.keepinchatmessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_KeepInChatMessage_default_instance_); +} +inline const ::proto::Message_KeepInChatMessage& Message::keepinchatmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.keepInChatMessage) + return _internal_keepinchatmessage(); +} +inline void Message::unsafe_arena_set_allocated_keepinchatmessage( + ::proto::Message_KeepInChatMessage* keepinchatmessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keepinchatmessage_); + } + _impl_.keepinchatmessage_ = keepinchatmessage; + if (keepinchatmessage) { + _impl_._has_bits_[1] |= 0x00000400u; + } else { + _impl_._has_bits_[1] &= ~0x00000400u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.keepInChatMessage) +} +inline ::proto::Message_KeepInChatMessage* Message::release_keepinchatmessage() { + _impl_._has_bits_[1] &= ~0x00000400u; + ::proto::Message_KeepInChatMessage* temp = _impl_.keepinchatmessage_; + _impl_.keepinchatmessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_KeepInChatMessage* Message::unsafe_arena_release_keepinchatmessage() { + // @@protoc_insertion_point(field_release:proto.Message.keepInChatMessage) + _impl_._has_bits_[1] &= ~0x00000400u; + ::proto::Message_KeepInChatMessage* temp = _impl_.keepinchatmessage_; + _impl_.keepinchatmessage_ = nullptr; + return temp; +} +inline ::proto::Message_KeepInChatMessage* Message::_internal_mutable_keepinchatmessage() { + _impl_._has_bits_[1] |= 0x00000400u; + if (_impl_.keepinchatmessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_KeepInChatMessage>(GetArenaForAllocation()); + _impl_.keepinchatmessage_ = p; + } + return _impl_.keepinchatmessage_; +} +inline ::proto::Message_KeepInChatMessage* Message::mutable_keepinchatmessage() { + ::proto::Message_KeepInChatMessage* _msg = _internal_mutable_keepinchatmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.keepInChatMessage) + return _msg; +} +inline void Message::set_allocated_keepinchatmessage(::proto::Message_KeepInChatMessage* keepinchatmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.keepinchatmessage_; + } + if (keepinchatmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keepinchatmessage); + if (message_arena != submessage_arena) { + keepinchatmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, keepinchatmessage, submessage_arena); + } + _impl_._has_bits_[1] |= 0x00000400u; + } else { + _impl_._has_bits_[1] &= ~0x00000400u; + } + _impl_.keepinchatmessage_ = keepinchatmessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.keepInChatMessage) +} + +// optional .proto.Message.FutureProofMessage documentWithCaptionMessage = 53; +inline bool Message::_internal_has_documentwithcaptionmessage() const { + bool value = (_impl_._has_bits_[1] & 0x00000800u) != 0; + PROTOBUF_ASSUME(!value || _impl_.documentwithcaptionmessage_ != nullptr); + return value; +} +inline bool Message::has_documentwithcaptionmessage() const { + return _internal_has_documentwithcaptionmessage(); +} +inline void Message::clear_documentwithcaptionmessage() { + if (_impl_.documentwithcaptionmessage_ != nullptr) _impl_.documentwithcaptionmessage_->Clear(); + _impl_._has_bits_[1] &= ~0x00000800u; +} +inline const ::proto::Message_FutureProofMessage& Message::_internal_documentwithcaptionmessage() const { + const ::proto::Message_FutureProofMessage* p = _impl_.documentwithcaptionmessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_FutureProofMessage_default_instance_); +} +inline const ::proto::Message_FutureProofMessage& Message::documentwithcaptionmessage() const { + // @@protoc_insertion_point(field_get:proto.Message.documentWithCaptionMessage) + return _internal_documentwithcaptionmessage(); +} +inline void Message::unsafe_arena_set_allocated_documentwithcaptionmessage( + ::proto::Message_FutureProofMessage* documentwithcaptionmessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.documentwithcaptionmessage_); + } + _impl_.documentwithcaptionmessage_ = documentwithcaptionmessage; + if (documentwithcaptionmessage) { + _impl_._has_bits_[1] |= 0x00000800u; + } else { + _impl_._has_bits_[1] &= ~0x00000800u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.documentWithCaptionMessage) +} +inline ::proto::Message_FutureProofMessage* Message::release_documentwithcaptionmessage() { + _impl_._has_bits_[1] &= ~0x00000800u; + ::proto::Message_FutureProofMessage* temp = _impl_.documentwithcaptionmessage_; + _impl_.documentwithcaptionmessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_FutureProofMessage* Message::unsafe_arena_release_documentwithcaptionmessage() { + // @@protoc_insertion_point(field_release:proto.Message.documentWithCaptionMessage) + _impl_._has_bits_[1] &= ~0x00000800u; + ::proto::Message_FutureProofMessage* temp = _impl_.documentwithcaptionmessage_; + _impl_.documentwithcaptionmessage_ = nullptr; + return temp; +} +inline ::proto::Message_FutureProofMessage* Message::_internal_mutable_documentwithcaptionmessage() { + _impl_._has_bits_[1] |= 0x00000800u; + if (_impl_.documentwithcaptionmessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_FutureProofMessage>(GetArenaForAllocation()); + _impl_.documentwithcaptionmessage_ = p; + } + return _impl_.documentwithcaptionmessage_; +} +inline ::proto::Message_FutureProofMessage* Message::mutable_documentwithcaptionmessage() { + ::proto::Message_FutureProofMessage* _msg = _internal_mutable_documentwithcaptionmessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.documentWithCaptionMessage) + return _msg; +} +inline void Message::set_allocated_documentwithcaptionmessage(::proto::Message_FutureProofMessage* documentwithcaptionmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.documentwithcaptionmessage_; + } + if (documentwithcaptionmessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(documentwithcaptionmessage); + if (message_arena != submessage_arena) { + documentwithcaptionmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, documentwithcaptionmessage, submessage_arena); + } + _impl_._has_bits_[1] |= 0x00000800u; + } else { + _impl_._has_bits_[1] &= ~0x00000800u; + } + _impl_.documentwithcaptionmessage_ = documentwithcaptionmessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.documentWithCaptionMessage) +} + +// optional .proto.Message.RequestPhoneNumberMessage requestPhoneNumberMessage = 54; +inline bool Message::_internal_has_requestphonenumbermessage() const { + bool value = (_impl_._has_bits_[1] & 0x00001000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.requestphonenumbermessage_ != nullptr); + return value; +} +inline bool Message::has_requestphonenumbermessage() const { + return _internal_has_requestphonenumbermessage(); +} +inline void Message::clear_requestphonenumbermessage() { + if (_impl_.requestphonenumbermessage_ != nullptr) _impl_.requestphonenumbermessage_->Clear(); + _impl_._has_bits_[1] &= ~0x00001000u; +} +inline const ::proto::Message_RequestPhoneNumberMessage& Message::_internal_requestphonenumbermessage() const { + const ::proto::Message_RequestPhoneNumberMessage* p = _impl_.requestphonenumbermessage_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_RequestPhoneNumberMessage_default_instance_); +} +inline const ::proto::Message_RequestPhoneNumberMessage& Message::requestphonenumbermessage() const { + // @@protoc_insertion_point(field_get:proto.Message.requestPhoneNumberMessage) + return _internal_requestphonenumbermessage(); +} +inline void Message::unsafe_arena_set_allocated_requestphonenumbermessage( + ::proto::Message_RequestPhoneNumberMessage* requestphonenumbermessage) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.requestphonenumbermessage_); + } + _impl_.requestphonenumbermessage_ = requestphonenumbermessage; + if (requestphonenumbermessage) { + _impl_._has_bits_[1] |= 0x00001000u; + } else { + _impl_._has_bits_[1] &= ~0x00001000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.requestPhoneNumberMessage) +} +inline ::proto::Message_RequestPhoneNumberMessage* Message::release_requestphonenumbermessage() { + _impl_._has_bits_[1] &= ~0x00001000u; + ::proto::Message_RequestPhoneNumberMessage* temp = _impl_.requestphonenumbermessage_; + _impl_.requestphonenumbermessage_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_RequestPhoneNumberMessage* Message::unsafe_arena_release_requestphonenumbermessage() { + // @@protoc_insertion_point(field_release:proto.Message.requestPhoneNumberMessage) + _impl_._has_bits_[1] &= ~0x00001000u; + ::proto::Message_RequestPhoneNumberMessage* temp = _impl_.requestphonenumbermessage_; + _impl_.requestphonenumbermessage_ = nullptr; + return temp; +} +inline ::proto::Message_RequestPhoneNumberMessage* Message::_internal_mutable_requestphonenumbermessage() { + _impl_._has_bits_[1] |= 0x00001000u; + if (_impl_.requestphonenumbermessage_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_RequestPhoneNumberMessage>(GetArenaForAllocation()); + _impl_.requestphonenumbermessage_ = p; + } + return _impl_.requestphonenumbermessage_; +} +inline ::proto::Message_RequestPhoneNumberMessage* Message::mutable_requestphonenumbermessage() { + ::proto::Message_RequestPhoneNumberMessage* _msg = _internal_mutable_requestphonenumbermessage(); + // @@protoc_insertion_point(field_mutable:proto.Message.requestPhoneNumberMessage) + return _msg; +} +inline void Message::set_allocated_requestphonenumbermessage(::proto::Message_RequestPhoneNumberMessage* requestphonenumbermessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.requestphonenumbermessage_; + } + if (requestphonenumbermessage) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(requestphonenumbermessage); + if (message_arena != submessage_arena) { + requestphonenumbermessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, requestphonenumbermessage, submessage_arena); + } + _impl_._has_bits_[1] |= 0x00001000u; + } else { + _impl_._has_bits_[1] &= ~0x00001000u; + } + _impl_.requestphonenumbermessage_ = requestphonenumbermessage; + // @@protoc_insertion_point(field_set_allocated:proto.Message.requestPhoneNumberMessage) +} + +// optional .proto.Message.FutureProofMessage viewOnceMessageV2 = 55; +inline bool Message::_internal_has_viewoncemessagev2() const { + bool value = (_impl_._has_bits_[1] & 0x00002000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.viewoncemessagev2_ != nullptr); + return value; +} +inline bool Message::has_viewoncemessagev2() const { + return _internal_has_viewoncemessagev2(); +} +inline void Message::clear_viewoncemessagev2() { + if (_impl_.viewoncemessagev2_ != nullptr) _impl_.viewoncemessagev2_->Clear(); + _impl_._has_bits_[1] &= ~0x00002000u; +} +inline const ::proto::Message_FutureProofMessage& Message::_internal_viewoncemessagev2() const { + const ::proto::Message_FutureProofMessage* p = _impl_.viewoncemessagev2_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_FutureProofMessage_default_instance_); +} +inline const ::proto::Message_FutureProofMessage& Message::viewoncemessagev2() const { + // @@protoc_insertion_point(field_get:proto.Message.viewOnceMessageV2) + return _internal_viewoncemessagev2(); +} +inline void Message::unsafe_arena_set_allocated_viewoncemessagev2( + ::proto::Message_FutureProofMessage* viewoncemessagev2) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.viewoncemessagev2_); + } + _impl_.viewoncemessagev2_ = viewoncemessagev2; + if (viewoncemessagev2) { + _impl_._has_bits_[1] |= 0x00002000u; + } else { + _impl_._has_bits_[1] &= ~0x00002000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.viewOnceMessageV2) +} +inline ::proto::Message_FutureProofMessage* Message::release_viewoncemessagev2() { + _impl_._has_bits_[1] &= ~0x00002000u; + ::proto::Message_FutureProofMessage* temp = _impl_.viewoncemessagev2_; + _impl_.viewoncemessagev2_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_FutureProofMessage* Message::unsafe_arena_release_viewoncemessagev2() { + // @@protoc_insertion_point(field_release:proto.Message.viewOnceMessageV2) + _impl_._has_bits_[1] &= ~0x00002000u; + ::proto::Message_FutureProofMessage* temp = _impl_.viewoncemessagev2_; + _impl_.viewoncemessagev2_ = nullptr; + return temp; +} +inline ::proto::Message_FutureProofMessage* Message::_internal_mutable_viewoncemessagev2() { + _impl_._has_bits_[1] |= 0x00002000u; + if (_impl_.viewoncemessagev2_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_FutureProofMessage>(GetArenaForAllocation()); + _impl_.viewoncemessagev2_ = p; + } + return _impl_.viewoncemessagev2_; +} +inline ::proto::Message_FutureProofMessage* Message::mutable_viewoncemessagev2() { + ::proto::Message_FutureProofMessage* _msg = _internal_mutable_viewoncemessagev2(); + // @@protoc_insertion_point(field_mutable:proto.Message.viewOnceMessageV2) + return _msg; +} +inline void Message::set_allocated_viewoncemessagev2(::proto::Message_FutureProofMessage* viewoncemessagev2) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.viewoncemessagev2_; + } + if (viewoncemessagev2) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(viewoncemessagev2); + if (message_arena != submessage_arena) { + viewoncemessagev2 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, viewoncemessagev2, submessage_arena); + } + _impl_._has_bits_[1] |= 0x00002000u; + } else { + _impl_._has_bits_[1] &= ~0x00002000u; + } + _impl_.viewoncemessagev2_ = viewoncemessagev2; + // @@protoc_insertion_point(field_set_allocated:proto.Message.viewOnceMessageV2) +} + +// ------------------------------------------------------------------- + +// MessageContextInfo + +// optional .proto.DeviceListMetadata deviceListMetadata = 1; +inline bool MessageContextInfo::_internal_has_devicelistmetadata() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.devicelistmetadata_ != nullptr); + return value; +} +inline bool MessageContextInfo::has_devicelistmetadata() const { + return _internal_has_devicelistmetadata(); +} +inline void MessageContextInfo::clear_devicelistmetadata() { + if (_impl_.devicelistmetadata_ != nullptr) _impl_.devicelistmetadata_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::proto::DeviceListMetadata& MessageContextInfo::_internal_devicelistmetadata() const { + const ::proto::DeviceListMetadata* p = _impl_.devicelistmetadata_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_DeviceListMetadata_default_instance_); +} +inline const ::proto::DeviceListMetadata& MessageContextInfo::devicelistmetadata() const { + // @@protoc_insertion_point(field_get:proto.MessageContextInfo.deviceListMetadata) + return _internal_devicelistmetadata(); +} +inline void MessageContextInfo::unsafe_arena_set_allocated_devicelistmetadata( + ::proto::DeviceListMetadata* devicelistmetadata) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.devicelistmetadata_); + } + _impl_.devicelistmetadata_ = devicelistmetadata; + if (devicelistmetadata) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.MessageContextInfo.deviceListMetadata) +} +inline ::proto::DeviceListMetadata* MessageContextInfo::release_devicelistmetadata() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::DeviceListMetadata* temp = _impl_.devicelistmetadata_; + _impl_.devicelistmetadata_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::DeviceListMetadata* MessageContextInfo::unsafe_arena_release_devicelistmetadata() { + // @@protoc_insertion_point(field_release:proto.MessageContextInfo.deviceListMetadata) + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::DeviceListMetadata* temp = _impl_.devicelistmetadata_; + _impl_.devicelistmetadata_ = nullptr; + return temp; +} +inline ::proto::DeviceListMetadata* MessageContextInfo::_internal_mutable_devicelistmetadata() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.devicelistmetadata_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::DeviceListMetadata>(GetArenaForAllocation()); + _impl_.devicelistmetadata_ = p; + } + return _impl_.devicelistmetadata_; +} +inline ::proto::DeviceListMetadata* MessageContextInfo::mutable_devicelistmetadata() { + ::proto::DeviceListMetadata* _msg = _internal_mutable_devicelistmetadata(); + // @@protoc_insertion_point(field_mutable:proto.MessageContextInfo.deviceListMetadata) + return _msg; +} +inline void MessageContextInfo::set_allocated_devicelistmetadata(::proto::DeviceListMetadata* devicelistmetadata) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.devicelistmetadata_; + } + if (devicelistmetadata) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(devicelistmetadata); + if (message_arena != submessage_arena) { + devicelistmetadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, devicelistmetadata, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.devicelistmetadata_ = devicelistmetadata; + // @@protoc_insertion_point(field_set_allocated:proto.MessageContextInfo.deviceListMetadata) +} + +// optional int32 deviceListMetadataVersion = 2; +inline bool MessageContextInfo::_internal_has_devicelistmetadataversion() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool MessageContextInfo::has_devicelistmetadataversion() const { + return _internal_has_devicelistmetadataversion(); +} +inline void MessageContextInfo::clear_devicelistmetadataversion() { + _impl_.devicelistmetadataversion_ = 0; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline int32_t MessageContextInfo::_internal_devicelistmetadataversion() const { + return _impl_.devicelistmetadataversion_; +} +inline int32_t MessageContextInfo::devicelistmetadataversion() const { + // @@protoc_insertion_point(field_get:proto.MessageContextInfo.deviceListMetadataVersion) + return _internal_devicelistmetadataversion(); +} +inline void MessageContextInfo::_internal_set_devicelistmetadataversion(int32_t value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.devicelistmetadataversion_ = value; +} +inline void MessageContextInfo::set_devicelistmetadataversion(int32_t value) { + _internal_set_devicelistmetadataversion(value); + // @@protoc_insertion_point(field_set:proto.MessageContextInfo.deviceListMetadataVersion) +} + +// optional bytes messageSecret = 3; +inline bool MessageContextInfo::_internal_has_messagesecret() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool MessageContextInfo::has_messagesecret() const { + return _internal_has_messagesecret(); +} +inline void MessageContextInfo::clear_messagesecret() { + _impl_.messagesecret_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& MessageContextInfo::messagesecret() const { + // @@protoc_insertion_point(field_get:proto.MessageContextInfo.messageSecret) + return _internal_messagesecret(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void MessageContextInfo::set_messagesecret(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.messagesecret_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.MessageContextInfo.messageSecret) +} +inline std::string* MessageContextInfo::mutable_messagesecret() { + std::string* _s = _internal_mutable_messagesecret(); + // @@protoc_insertion_point(field_mutable:proto.MessageContextInfo.messageSecret) + return _s; +} +inline const std::string& MessageContextInfo::_internal_messagesecret() const { + return _impl_.messagesecret_.Get(); +} +inline void MessageContextInfo::_internal_set_messagesecret(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.messagesecret_.Set(value, GetArenaForAllocation()); +} +inline std::string* MessageContextInfo::_internal_mutable_messagesecret() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.messagesecret_.Mutable(GetArenaForAllocation()); +} +inline std::string* MessageContextInfo::release_messagesecret() { + // @@protoc_insertion_point(field_release:proto.MessageContextInfo.messageSecret) + if (!_internal_has_messagesecret()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.messagesecret_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.messagesecret_.IsDefault()) { + _impl_.messagesecret_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void MessageContextInfo::set_allocated_messagesecret(std::string* messagesecret) { + if (messagesecret != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.messagesecret_.SetAllocated(messagesecret, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.messagesecret_.IsDefault()) { + _impl_.messagesecret_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.MessageContextInfo.messageSecret) +} + +// optional bytes paddingBytes = 4; +inline bool MessageContextInfo::_internal_has_paddingbytes() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool MessageContextInfo::has_paddingbytes() const { + return _internal_has_paddingbytes(); +} +inline void MessageContextInfo::clear_paddingbytes() { + _impl_.paddingbytes_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& MessageContextInfo::paddingbytes() const { + // @@protoc_insertion_point(field_get:proto.MessageContextInfo.paddingBytes) + return _internal_paddingbytes(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void MessageContextInfo::set_paddingbytes(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.paddingbytes_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.MessageContextInfo.paddingBytes) +} +inline std::string* MessageContextInfo::mutable_paddingbytes() { + std::string* _s = _internal_mutable_paddingbytes(); + // @@protoc_insertion_point(field_mutable:proto.MessageContextInfo.paddingBytes) + return _s; +} +inline const std::string& MessageContextInfo::_internal_paddingbytes() const { + return _impl_.paddingbytes_.Get(); +} +inline void MessageContextInfo::_internal_set_paddingbytes(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.paddingbytes_.Set(value, GetArenaForAllocation()); +} +inline std::string* MessageContextInfo::_internal_mutable_paddingbytes() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.paddingbytes_.Mutable(GetArenaForAllocation()); +} +inline std::string* MessageContextInfo::release_paddingbytes() { + // @@protoc_insertion_point(field_release:proto.MessageContextInfo.paddingBytes) + if (!_internal_has_paddingbytes()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.paddingbytes_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.paddingbytes_.IsDefault()) { + _impl_.paddingbytes_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void MessageContextInfo::set_allocated_paddingbytes(std::string* paddingbytes) { + if (paddingbytes != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.paddingbytes_.SetAllocated(paddingbytes, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.paddingbytes_.IsDefault()) { + _impl_.paddingbytes_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.MessageContextInfo.paddingBytes) +} + +// ------------------------------------------------------------------- + +// MessageKey + +// optional string remoteJid = 1; +inline bool MessageKey::_internal_has_remotejid() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool MessageKey::has_remotejid() const { + return _internal_has_remotejid(); +} +inline void MessageKey::clear_remotejid() { + _impl_.remotejid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& MessageKey::remotejid() const { + // @@protoc_insertion_point(field_get:proto.MessageKey.remoteJid) + return _internal_remotejid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void MessageKey::set_remotejid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.remotejid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.MessageKey.remoteJid) +} +inline std::string* MessageKey::mutable_remotejid() { + std::string* _s = _internal_mutable_remotejid(); + // @@protoc_insertion_point(field_mutable:proto.MessageKey.remoteJid) + return _s; +} +inline const std::string& MessageKey::_internal_remotejid() const { + return _impl_.remotejid_.Get(); +} +inline void MessageKey::_internal_set_remotejid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.remotejid_.Set(value, GetArenaForAllocation()); +} +inline std::string* MessageKey::_internal_mutable_remotejid() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.remotejid_.Mutable(GetArenaForAllocation()); +} +inline std::string* MessageKey::release_remotejid() { + // @@protoc_insertion_point(field_release:proto.MessageKey.remoteJid) + if (!_internal_has_remotejid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.remotejid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.remotejid_.IsDefault()) { + _impl_.remotejid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void MessageKey::set_allocated_remotejid(std::string* remotejid) { + if (remotejid != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.remotejid_.SetAllocated(remotejid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.remotejid_.IsDefault()) { + _impl_.remotejid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.MessageKey.remoteJid) +} + +// optional bool fromMe = 2; +inline bool MessageKey::_internal_has_fromme() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool MessageKey::has_fromme() const { + return _internal_has_fromme(); +} +inline void MessageKey::clear_fromme() { + _impl_.fromme_ = false; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline bool MessageKey::_internal_fromme() const { + return _impl_.fromme_; +} +inline bool MessageKey::fromme() const { + // @@protoc_insertion_point(field_get:proto.MessageKey.fromMe) + return _internal_fromme(); +} +inline void MessageKey::_internal_set_fromme(bool value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.fromme_ = value; +} +inline void MessageKey::set_fromme(bool value) { + _internal_set_fromme(value); + // @@protoc_insertion_point(field_set:proto.MessageKey.fromMe) +} + +// optional string id = 3; +inline bool MessageKey::_internal_has_id() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool MessageKey::has_id() const { + return _internal_has_id(); +} +inline void MessageKey::clear_id() { + _impl_.id_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& MessageKey::id() const { + // @@protoc_insertion_point(field_get:proto.MessageKey.id) + return _internal_id(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void MessageKey::set_id(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.id_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.MessageKey.id) +} +inline std::string* MessageKey::mutable_id() { + std::string* _s = _internal_mutable_id(); + // @@protoc_insertion_point(field_mutable:proto.MessageKey.id) + return _s; +} +inline const std::string& MessageKey::_internal_id() const { + return _impl_.id_.Get(); +} +inline void MessageKey::_internal_set_id(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.id_.Set(value, GetArenaForAllocation()); +} +inline std::string* MessageKey::_internal_mutable_id() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.id_.Mutable(GetArenaForAllocation()); +} +inline std::string* MessageKey::release_id() { + // @@protoc_insertion_point(field_release:proto.MessageKey.id) + if (!_internal_has_id()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.id_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.id_.IsDefault()) { + _impl_.id_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void MessageKey::set_allocated_id(std::string* id) { + if (id != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.id_.SetAllocated(id, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.id_.IsDefault()) { + _impl_.id_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.MessageKey.id) +} + +// optional string participant = 4; +inline bool MessageKey::_internal_has_participant() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool MessageKey::has_participant() const { + return _internal_has_participant(); +} +inline void MessageKey::clear_participant() { + _impl_.participant_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& MessageKey::participant() const { + // @@protoc_insertion_point(field_get:proto.MessageKey.participant) + return _internal_participant(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void MessageKey::set_participant(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.participant_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.MessageKey.participant) +} +inline std::string* MessageKey::mutable_participant() { + std::string* _s = _internal_mutable_participant(); + // @@protoc_insertion_point(field_mutable:proto.MessageKey.participant) + return _s; +} +inline const std::string& MessageKey::_internal_participant() const { + return _impl_.participant_.Get(); +} +inline void MessageKey::_internal_set_participant(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.participant_.Set(value, GetArenaForAllocation()); +} +inline std::string* MessageKey::_internal_mutable_participant() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.participant_.Mutable(GetArenaForAllocation()); +} +inline std::string* MessageKey::release_participant() { + // @@protoc_insertion_point(field_release:proto.MessageKey.participant) + if (!_internal_has_participant()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.participant_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.participant_.IsDefault()) { + _impl_.participant_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void MessageKey::set_allocated_participant(std::string* participant) { + if (participant != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.participant_.SetAllocated(participant, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.participant_.IsDefault()) { + _impl_.participant_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.MessageKey.participant) +} + +// ------------------------------------------------------------------- + +// Money + +// optional int64 value = 1; +inline bool Money::_internal_has_value() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Money::has_value() const { + return _internal_has_value(); +} +inline void Money::clear_value() { + _impl_.value_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline int64_t Money::_internal_value() const { + return _impl_.value_; +} +inline int64_t Money::value() const { + // @@protoc_insertion_point(field_get:proto.Money.value) + return _internal_value(); +} +inline void Money::_internal_set_value(int64_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.value_ = value; +} +inline void Money::set_value(int64_t value) { + _internal_set_value(value); + // @@protoc_insertion_point(field_set:proto.Money.value) +} + +// optional uint32 offset = 2; +inline bool Money::_internal_has_offset() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Money::has_offset() const { + return _internal_has_offset(); +} +inline void Money::clear_offset() { + _impl_.offset_ = 0u; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline uint32_t Money::_internal_offset() const { + return _impl_.offset_; +} +inline uint32_t Money::offset() const { + // @@protoc_insertion_point(field_get:proto.Money.offset) + return _internal_offset(); +} +inline void Money::_internal_set_offset(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.offset_ = value; +} +inline void Money::set_offset(uint32_t value) { + _internal_set_offset(value); + // @@protoc_insertion_point(field_set:proto.Money.offset) +} + +// optional string currencyCode = 3; +inline bool Money::_internal_has_currencycode() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Money::has_currencycode() const { + return _internal_has_currencycode(); +} +inline void Money::clear_currencycode() { + _impl_.currencycode_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Money::currencycode() const { + // @@protoc_insertion_point(field_get:proto.Money.currencyCode) + return _internal_currencycode(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Money::set_currencycode(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.currencycode_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Money.currencyCode) +} +inline std::string* Money::mutable_currencycode() { + std::string* _s = _internal_mutable_currencycode(); + // @@protoc_insertion_point(field_mutable:proto.Money.currencyCode) + return _s; +} +inline const std::string& Money::_internal_currencycode() const { + return _impl_.currencycode_.Get(); +} +inline void Money::_internal_set_currencycode(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.currencycode_.Set(value, GetArenaForAllocation()); +} +inline std::string* Money::_internal_mutable_currencycode() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.currencycode_.Mutable(GetArenaForAllocation()); +} +inline std::string* Money::release_currencycode() { + // @@protoc_insertion_point(field_release:proto.Money.currencyCode) + if (!_internal_has_currencycode()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.currencycode_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.currencycode_.IsDefault()) { + _impl_.currencycode_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Money::set_allocated_currencycode(std::string* currencycode) { + if (currencycode != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.currencycode_.SetAllocated(currencycode, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.currencycode_.IsDefault()) { + _impl_.currencycode_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Money.currencyCode) +} + +// ------------------------------------------------------------------- + +// MsgOpaqueData_PollOption + +// optional string name = 1; +inline bool MsgOpaqueData_PollOption::_internal_has_name() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool MsgOpaqueData_PollOption::has_name() const { + return _internal_has_name(); +} +inline void MsgOpaqueData_PollOption::clear_name() { + _impl_.name_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& MsgOpaqueData_PollOption::name() const { + // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.PollOption.name) + return _internal_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void MsgOpaqueData_PollOption::set_name(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.PollOption.name) +} +inline std::string* MsgOpaqueData_PollOption::mutable_name() { + std::string* _s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.PollOption.name) + return _s; +} +inline const std::string& MsgOpaqueData_PollOption::_internal_name() const { + return _impl_.name_.Get(); +} +inline void MsgOpaqueData_PollOption::_internal_set_name(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.name_.Set(value, GetArenaForAllocation()); +} +inline std::string* MsgOpaqueData_PollOption::_internal_mutable_name() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.name_.Mutable(GetArenaForAllocation()); +} +inline std::string* MsgOpaqueData_PollOption::release_name() { + // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.PollOption.name) + if (!_internal_has_name()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.name_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.name_.IsDefault()) { + _impl_.name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void MsgOpaqueData_PollOption::set_allocated_name(std::string* name) { + if (name != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.name_.SetAllocated(name, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.name_.IsDefault()) { + _impl_.name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.PollOption.name) +} + +// ------------------------------------------------------------------- + +// MsgOpaqueData + +// optional string body = 1; +inline bool MsgOpaqueData::_internal_has_body() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool MsgOpaqueData::has_body() const { + return _internal_has_body(); +} +inline void MsgOpaqueData::clear_body() { + _impl_.body_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& MsgOpaqueData::body() const { + // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.body) + return _internal_body(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void MsgOpaqueData::set_body(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.body_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.body) +} +inline std::string* MsgOpaqueData::mutable_body() { + std::string* _s = _internal_mutable_body(); + // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.body) + return _s; +} +inline const std::string& MsgOpaqueData::_internal_body() const { + return _impl_.body_.Get(); +} +inline void MsgOpaqueData::_internal_set_body(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.body_.Set(value, GetArenaForAllocation()); +} +inline std::string* MsgOpaqueData::_internal_mutable_body() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.body_.Mutable(GetArenaForAllocation()); +} +inline std::string* MsgOpaqueData::release_body() { + // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.body) + if (!_internal_has_body()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.body_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.body_.IsDefault()) { + _impl_.body_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void MsgOpaqueData::set_allocated_body(std::string* body) { + if (body != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.body_.SetAllocated(body, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.body_.IsDefault()) { + _impl_.body_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.body) +} + +// optional string caption = 3; +inline bool MsgOpaqueData::_internal_has_caption() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool MsgOpaqueData::has_caption() const { + return _internal_has_caption(); +} +inline void MsgOpaqueData::clear_caption() { + _impl_.caption_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& MsgOpaqueData::caption() const { + // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.caption) + return _internal_caption(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void MsgOpaqueData::set_caption(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.caption_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.caption) +} +inline std::string* MsgOpaqueData::mutable_caption() { + std::string* _s = _internal_mutable_caption(); + // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.caption) + return _s; +} +inline const std::string& MsgOpaqueData::_internal_caption() const { + return _impl_.caption_.Get(); +} +inline void MsgOpaqueData::_internal_set_caption(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.caption_.Set(value, GetArenaForAllocation()); +} +inline std::string* MsgOpaqueData::_internal_mutable_caption() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.caption_.Mutable(GetArenaForAllocation()); +} +inline std::string* MsgOpaqueData::release_caption() { + // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.caption) + if (!_internal_has_caption()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.caption_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.caption_.IsDefault()) { + _impl_.caption_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void MsgOpaqueData::set_allocated_caption(std::string* caption) { + if (caption != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.caption_.SetAllocated(caption, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.caption_.IsDefault()) { + _impl_.caption_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.caption) +} + +// optional double lng = 5; +inline bool MsgOpaqueData::_internal_has_lng() const { + bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0; + return value; +} +inline bool MsgOpaqueData::has_lng() const { + return _internal_has_lng(); +} +inline void MsgOpaqueData::clear_lng() { + _impl_.lng_ = 0; + _impl_._has_bits_[0] &= ~0x00004000u; +} +inline double MsgOpaqueData::_internal_lng() const { + return _impl_.lng_; +} +inline double MsgOpaqueData::lng() const { + // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.lng) + return _internal_lng(); +} +inline void MsgOpaqueData::_internal_set_lng(double value) { + _impl_._has_bits_[0] |= 0x00004000u; + _impl_.lng_ = value; +} +inline void MsgOpaqueData::set_lng(double value) { + _internal_set_lng(value); + // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.lng) +} + +// optional bool isLive = 6; +inline bool MsgOpaqueData::_internal_has_islive() const { + bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0; + return value; +} +inline bool MsgOpaqueData::has_islive() const { + return _internal_has_islive(); +} +inline void MsgOpaqueData::clear_islive() { + _impl_.islive_ = false; + _impl_._has_bits_[0] &= ~0x00010000u; +} +inline bool MsgOpaqueData::_internal_islive() const { + return _impl_.islive_; +} +inline bool MsgOpaqueData::islive() const { + // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.isLive) + return _internal_islive(); +} +inline void MsgOpaqueData::_internal_set_islive(bool value) { + _impl_._has_bits_[0] |= 0x00010000u; + _impl_.islive_ = value; +} +inline void MsgOpaqueData::set_islive(bool value) { + _internal_set_islive(value); + // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.isLive) +} + +// optional double lat = 7; +inline bool MsgOpaqueData::_internal_has_lat() const { + bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0; + return value; +} +inline bool MsgOpaqueData::has_lat() const { + return _internal_has_lat(); +} +inline void MsgOpaqueData::clear_lat() { + _impl_.lat_ = 0; + _impl_._has_bits_[0] &= ~0x00008000u; +} +inline double MsgOpaqueData::_internal_lat() const { + return _impl_.lat_; +} +inline double MsgOpaqueData::lat() const { + // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.lat) + return _internal_lat(); +} +inline void MsgOpaqueData::_internal_set_lat(double value) { + _impl_._has_bits_[0] |= 0x00008000u; + _impl_.lat_ = value; +} +inline void MsgOpaqueData::set_lat(double value) { + _internal_set_lat(value); + // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.lat) +} + +// optional int32 paymentAmount1000 = 8; +inline bool MsgOpaqueData::_internal_has_paymentamount1000() const { + bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0; + return value; +} +inline bool MsgOpaqueData::has_paymentamount1000() const { + return _internal_has_paymentamount1000(); +} +inline void MsgOpaqueData::clear_paymentamount1000() { + _impl_.paymentamount1000_ = 0; + _impl_._has_bits_[0] &= ~0x00020000u; +} +inline int32_t MsgOpaqueData::_internal_paymentamount1000() const { + return _impl_.paymentamount1000_; +} +inline int32_t MsgOpaqueData::paymentamount1000() const { + // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.paymentAmount1000) + return _internal_paymentamount1000(); +} +inline void MsgOpaqueData::_internal_set_paymentamount1000(int32_t value) { + _impl_._has_bits_[0] |= 0x00020000u; + _impl_.paymentamount1000_ = value; +} +inline void MsgOpaqueData::set_paymentamount1000(int32_t value) { + _internal_set_paymentamount1000(value); + // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.paymentAmount1000) +} + +// optional string paymentNoteMsgBody = 9; +inline bool MsgOpaqueData::_internal_has_paymentnotemsgbody() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool MsgOpaqueData::has_paymentnotemsgbody() const { + return _internal_has_paymentnotemsgbody(); +} +inline void MsgOpaqueData::clear_paymentnotemsgbody() { + _impl_.paymentnotemsgbody_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& MsgOpaqueData::paymentnotemsgbody() const { + // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.paymentNoteMsgBody) + return _internal_paymentnotemsgbody(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void MsgOpaqueData::set_paymentnotemsgbody(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.paymentnotemsgbody_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.paymentNoteMsgBody) +} +inline std::string* MsgOpaqueData::mutable_paymentnotemsgbody() { + std::string* _s = _internal_mutable_paymentnotemsgbody(); + // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.paymentNoteMsgBody) + return _s; +} +inline const std::string& MsgOpaqueData::_internal_paymentnotemsgbody() const { + return _impl_.paymentnotemsgbody_.Get(); +} +inline void MsgOpaqueData::_internal_set_paymentnotemsgbody(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.paymentnotemsgbody_.Set(value, GetArenaForAllocation()); +} +inline std::string* MsgOpaqueData::_internal_mutable_paymentnotemsgbody() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.paymentnotemsgbody_.Mutable(GetArenaForAllocation()); +} +inline std::string* MsgOpaqueData::release_paymentnotemsgbody() { + // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.paymentNoteMsgBody) + if (!_internal_has_paymentnotemsgbody()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.paymentnotemsgbody_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.paymentnotemsgbody_.IsDefault()) { + _impl_.paymentnotemsgbody_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void MsgOpaqueData::set_allocated_paymentnotemsgbody(std::string* paymentnotemsgbody) { + if (paymentnotemsgbody != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.paymentnotemsgbody_.SetAllocated(paymentnotemsgbody, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.paymentnotemsgbody_.IsDefault()) { + _impl_.paymentnotemsgbody_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.paymentNoteMsgBody) +} + +// optional string canonicalUrl = 10; +inline bool MsgOpaqueData::_internal_has_canonicalurl() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool MsgOpaqueData::has_canonicalurl() const { + return _internal_has_canonicalurl(); +} +inline void MsgOpaqueData::clear_canonicalurl() { + _impl_.canonicalurl_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const std::string& MsgOpaqueData::canonicalurl() const { + // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.canonicalUrl) + return _internal_canonicalurl(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void MsgOpaqueData::set_canonicalurl(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.canonicalurl_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.canonicalUrl) +} +inline std::string* MsgOpaqueData::mutable_canonicalurl() { + std::string* _s = _internal_mutable_canonicalurl(); + // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.canonicalUrl) + return _s; +} +inline const std::string& MsgOpaqueData::_internal_canonicalurl() const { + return _impl_.canonicalurl_.Get(); +} +inline void MsgOpaqueData::_internal_set_canonicalurl(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.canonicalurl_.Set(value, GetArenaForAllocation()); +} +inline std::string* MsgOpaqueData::_internal_mutable_canonicalurl() { + _impl_._has_bits_[0] |= 0x00000008u; + return _impl_.canonicalurl_.Mutable(GetArenaForAllocation()); +} +inline std::string* MsgOpaqueData::release_canonicalurl() { + // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.canonicalUrl) + if (!_internal_has_canonicalurl()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000008u; + auto* p = _impl_.canonicalurl_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.canonicalurl_.IsDefault()) { + _impl_.canonicalurl_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void MsgOpaqueData::set_allocated_canonicalurl(std::string* canonicalurl) { + if (canonicalurl != nullptr) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.canonicalurl_.SetAllocated(canonicalurl, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.canonicalurl_.IsDefault()) { + _impl_.canonicalurl_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.canonicalUrl) +} + +// optional string matchedText = 11; +inline bool MsgOpaqueData::_internal_has_matchedtext() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool MsgOpaqueData::has_matchedtext() const { + return _internal_has_matchedtext(); +} +inline void MsgOpaqueData::clear_matchedtext() { + _impl_.matchedtext_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const std::string& MsgOpaqueData::matchedtext() const { + // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.matchedText) + return _internal_matchedtext(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void MsgOpaqueData::set_matchedtext(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.matchedtext_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.matchedText) +} +inline std::string* MsgOpaqueData::mutable_matchedtext() { + std::string* _s = _internal_mutable_matchedtext(); + // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.matchedText) + return _s; +} +inline const std::string& MsgOpaqueData::_internal_matchedtext() const { + return _impl_.matchedtext_.Get(); +} +inline void MsgOpaqueData::_internal_set_matchedtext(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.matchedtext_.Set(value, GetArenaForAllocation()); +} +inline std::string* MsgOpaqueData::_internal_mutable_matchedtext() { + _impl_._has_bits_[0] |= 0x00000010u; + return _impl_.matchedtext_.Mutable(GetArenaForAllocation()); +} +inline std::string* MsgOpaqueData::release_matchedtext() { + // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.matchedText) + if (!_internal_has_matchedtext()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000010u; + auto* p = _impl_.matchedtext_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.matchedtext_.IsDefault()) { + _impl_.matchedtext_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void MsgOpaqueData::set_allocated_matchedtext(std::string* matchedtext) { + if (matchedtext != nullptr) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.matchedtext_.SetAllocated(matchedtext, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.matchedtext_.IsDefault()) { + _impl_.matchedtext_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.matchedText) +} + +// optional string title = 12; +inline bool MsgOpaqueData::_internal_has_title() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool MsgOpaqueData::has_title() const { + return _internal_has_title(); +} +inline void MsgOpaqueData::clear_title() { + _impl_.title_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline const std::string& MsgOpaqueData::title() const { + // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.title) + return _internal_title(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void MsgOpaqueData::set_title(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.title_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.title) +} +inline std::string* MsgOpaqueData::mutable_title() { + std::string* _s = _internal_mutable_title(); + // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.title) + return _s; +} +inline const std::string& MsgOpaqueData::_internal_title() const { + return _impl_.title_.Get(); +} +inline void MsgOpaqueData::_internal_set_title(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.title_.Set(value, GetArenaForAllocation()); +} +inline std::string* MsgOpaqueData::_internal_mutable_title() { + _impl_._has_bits_[0] |= 0x00000020u; + return _impl_.title_.Mutable(GetArenaForAllocation()); +} +inline std::string* MsgOpaqueData::release_title() { + // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.title) + if (!_internal_has_title()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000020u; + auto* p = _impl_.title_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.title_.IsDefault()) { + _impl_.title_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void MsgOpaqueData::set_allocated_title(std::string* title) { + if (title != nullptr) { + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + _impl_.title_.SetAllocated(title, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.title_.IsDefault()) { + _impl_.title_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.title) +} + +// optional string description = 13; +inline bool MsgOpaqueData::_internal_has_description() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool MsgOpaqueData::has_description() const { + return _internal_has_description(); +} +inline void MsgOpaqueData::clear_description() { + _impl_.description_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline const std::string& MsgOpaqueData::description() const { + // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.description) + return _internal_description(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void MsgOpaqueData::set_description(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.description_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.description) +} +inline std::string* MsgOpaqueData::mutable_description() { + std::string* _s = _internal_mutable_description(); + // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.description) + return _s; +} +inline const std::string& MsgOpaqueData::_internal_description() const { + return _impl_.description_.Get(); +} +inline void MsgOpaqueData::_internal_set_description(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.description_.Set(value, GetArenaForAllocation()); +} +inline std::string* MsgOpaqueData::_internal_mutable_description() { + _impl_._has_bits_[0] |= 0x00000040u; + return _impl_.description_.Mutable(GetArenaForAllocation()); +} +inline std::string* MsgOpaqueData::release_description() { + // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.description) + if (!_internal_has_description()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000040u; + auto* p = _impl_.description_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.description_.IsDefault()) { + _impl_.description_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void MsgOpaqueData::set_allocated_description(std::string* description) { + if (description != nullptr) { + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + _impl_.description_.SetAllocated(description, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.description_.IsDefault()) { + _impl_.description_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.description) +} + +// optional bytes futureproofBuffer = 14; +inline bool MsgOpaqueData::_internal_has_futureproofbuffer() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool MsgOpaqueData::has_futureproofbuffer() const { + return _internal_has_futureproofbuffer(); +} +inline void MsgOpaqueData::clear_futureproofbuffer() { + _impl_.futureproofbuffer_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline const std::string& MsgOpaqueData::futureproofbuffer() const { + // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.futureproofBuffer) + return _internal_futureproofbuffer(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void MsgOpaqueData::set_futureproofbuffer(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.futureproofbuffer_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.futureproofBuffer) +} +inline std::string* MsgOpaqueData::mutable_futureproofbuffer() { + std::string* _s = _internal_mutable_futureproofbuffer(); + // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.futureproofBuffer) + return _s; +} +inline const std::string& MsgOpaqueData::_internal_futureproofbuffer() const { + return _impl_.futureproofbuffer_.Get(); +} +inline void MsgOpaqueData::_internal_set_futureproofbuffer(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.futureproofbuffer_.Set(value, GetArenaForAllocation()); +} +inline std::string* MsgOpaqueData::_internal_mutable_futureproofbuffer() { + _impl_._has_bits_[0] |= 0x00000080u; + return _impl_.futureproofbuffer_.Mutable(GetArenaForAllocation()); +} +inline std::string* MsgOpaqueData::release_futureproofbuffer() { + // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.futureproofBuffer) + if (!_internal_has_futureproofbuffer()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000080u; + auto* p = _impl_.futureproofbuffer_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.futureproofbuffer_.IsDefault()) { + _impl_.futureproofbuffer_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void MsgOpaqueData::set_allocated_futureproofbuffer(std::string* futureproofbuffer) { + if (futureproofbuffer != nullptr) { + _impl_._has_bits_[0] |= 0x00000080u; + } else { + _impl_._has_bits_[0] &= ~0x00000080u; + } + _impl_.futureproofbuffer_.SetAllocated(futureproofbuffer, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.futureproofbuffer_.IsDefault()) { + _impl_.futureproofbuffer_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.futureproofBuffer) +} + +// optional string clientUrl = 15; +inline bool MsgOpaqueData::_internal_has_clienturl() const { + bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool MsgOpaqueData::has_clienturl() const { + return _internal_has_clienturl(); +} +inline void MsgOpaqueData::clear_clienturl() { + _impl_.clienturl_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000100u; +} +inline const std::string& MsgOpaqueData::clienturl() const { + // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.clientUrl) + return _internal_clienturl(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void MsgOpaqueData::set_clienturl(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.clienturl_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.clientUrl) +} +inline std::string* MsgOpaqueData::mutable_clienturl() { + std::string* _s = _internal_mutable_clienturl(); + // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.clientUrl) + return _s; +} +inline const std::string& MsgOpaqueData::_internal_clienturl() const { + return _impl_.clienturl_.Get(); +} +inline void MsgOpaqueData::_internal_set_clienturl(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.clienturl_.Set(value, GetArenaForAllocation()); +} +inline std::string* MsgOpaqueData::_internal_mutable_clienturl() { + _impl_._has_bits_[0] |= 0x00000100u; + return _impl_.clienturl_.Mutable(GetArenaForAllocation()); +} +inline std::string* MsgOpaqueData::release_clienturl() { + // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.clientUrl) + if (!_internal_has_clienturl()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000100u; + auto* p = _impl_.clienturl_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.clienturl_.IsDefault()) { + _impl_.clienturl_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void MsgOpaqueData::set_allocated_clienturl(std::string* clienturl) { + if (clienturl != nullptr) { + _impl_._has_bits_[0] |= 0x00000100u; + } else { + _impl_._has_bits_[0] &= ~0x00000100u; + } + _impl_.clienturl_.SetAllocated(clienturl, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.clienturl_.IsDefault()) { + _impl_.clienturl_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.clientUrl) +} + +// optional string loc = 16; +inline bool MsgOpaqueData::_internal_has_loc() const { + bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool MsgOpaqueData::has_loc() const { + return _internal_has_loc(); +} +inline void MsgOpaqueData::clear_loc() { + _impl_.loc_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000200u; +} +inline const std::string& MsgOpaqueData::loc() const { + // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.loc) + return _internal_loc(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void MsgOpaqueData::set_loc(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.loc_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.loc) +} +inline std::string* MsgOpaqueData::mutable_loc() { + std::string* _s = _internal_mutable_loc(); + // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.loc) + return _s; +} +inline const std::string& MsgOpaqueData::_internal_loc() const { + return _impl_.loc_.Get(); +} +inline void MsgOpaqueData::_internal_set_loc(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.loc_.Set(value, GetArenaForAllocation()); +} +inline std::string* MsgOpaqueData::_internal_mutable_loc() { + _impl_._has_bits_[0] |= 0x00000200u; + return _impl_.loc_.Mutable(GetArenaForAllocation()); +} +inline std::string* MsgOpaqueData::release_loc() { + // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.loc) + if (!_internal_has_loc()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000200u; + auto* p = _impl_.loc_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.loc_.IsDefault()) { + _impl_.loc_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void MsgOpaqueData::set_allocated_loc(std::string* loc) { + if (loc != nullptr) { + _impl_._has_bits_[0] |= 0x00000200u; + } else { + _impl_._has_bits_[0] &= ~0x00000200u; + } + _impl_.loc_.SetAllocated(loc, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.loc_.IsDefault()) { + _impl_.loc_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.loc) +} + +// optional string pollName = 17; +inline bool MsgOpaqueData::_internal_has_pollname() const { + bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool MsgOpaqueData::has_pollname() const { + return _internal_has_pollname(); +} +inline void MsgOpaqueData::clear_pollname() { + _impl_.pollname_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000400u; +} +inline const std::string& MsgOpaqueData::pollname() const { + // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.pollName) + return _internal_pollname(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void MsgOpaqueData::set_pollname(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000400u; + _impl_.pollname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.pollName) +} +inline std::string* MsgOpaqueData::mutable_pollname() { + std::string* _s = _internal_mutable_pollname(); + // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.pollName) + return _s; +} +inline const std::string& MsgOpaqueData::_internal_pollname() const { + return _impl_.pollname_.Get(); +} +inline void MsgOpaqueData::_internal_set_pollname(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000400u; + _impl_.pollname_.Set(value, GetArenaForAllocation()); +} +inline std::string* MsgOpaqueData::_internal_mutable_pollname() { + _impl_._has_bits_[0] |= 0x00000400u; + return _impl_.pollname_.Mutable(GetArenaForAllocation()); +} +inline std::string* MsgOpaqueData::release_pollname() { + // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.pollName) + if (!_internal_has_pollname()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000400u; + auto* p = _impl_.pollname_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.pollname_.IsDefault()) { + _impl_.pollname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void MsgOpaqueData::set_allocated_pollname(std::string* pollname) { + if (pollname != nullptr) { + _impl_._has_bits_[0] |= 0x00000400u; + } else { + _impl_._has_bits_[0] &= ~0x00000400u; + } + _impl_.pollname_.SetAllocated(pollname, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.pollname_.IsDefault()) { + _impl_.pollname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.pollName) +} + +// repeated .proto.MsgOpaqueData.PollOption pollOptions = 18; +inline int MsgOpaqueData::_internal_polloptions_size() const { + return _impl_.polloptions_.size(); +} +inline int MsgOpaqueData::polloptions_size() const { + return _internal_polloptions_size(); +} +inline void MsgOpaqueData::clear_polloptions() { + _impl_.polloptions_.Clear(); +} +inline ::proto::MsgOpaqueData_PollOption* MsgOpaqueData::mutable_polloptions(int index) { + // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.pollOptions) + return _impl_.polloptions_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MsgOpaqueData_PollOption >* +MsgOpaqueData::mutable_polloptions() { + // @@protoc_insertion_point(field_mutable_list:proto.MsgOpaqueData.pollOptions) + return &_impl_.polloptions_; +} +inline const ::proto::MsgOpaqueData_PollOption& MsgOpaqueData::_internal_polloptions(int index) const { + return _impl_.polloptions_.Get(index); +} +inline const ::proto::MsgOpaqueData_PollOption& MsgOpaqueData::polloptions(int index) const { + // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.pollOptions) + return _internal_polloptions(index); +} +inline ::proto::MsgOpaqueData_PollOption* MsgOpaqueData::_internal_add_polloptions() { + return _impl_.polloptions_.Add(); +} +inline ::proto::MsgOpaqueData_PollOption* MsgOpaqueData::add_polloptions() { + ::proto::MsgOpaqueData_PollOption* _add = _internal_add_polloptions(); + // @@protoc_insertion_point(field_add:proto.MsgOpaqueData.pollOptions) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MsgOpaqueData_PollOption >& +MsgOpaqueData::polloptions() const { + // @@protoc_insertion_point(field_list:proto.MsgOpaqueData.pollOptions) + return _impl_.polloptions_; +} + +// optional uint32 pollSelectableOptionsCount = 20; +inline bool MsgOpaqueData::_internal_has_pollselectableoptionscount() const { + bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0; + return value; +} +inline bool MsgOpaqueData::has_pollselectableoptionscount() const { + return _internal_has_pollselectableoptionscount(); +} +inline void MsgOpaqueData::clear_pollselectableoptionscount() { + _impl_.pollselectableoptionscount_ = 0u; + _impl_._has_bits_[0] &= ~0x00080000u; +} +inline uint32_t MsgOpaqueData::_internal_pollselectableoptionscount() const { + return _impl_.pollselectableoptionscount_; +} +inline uint32_t MsgOpaqueData::pollselectableoptionscount() const { + // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.pollSelectableOptionsCount) + return _internal_pollselectableoptionscount(); +} +inline void MsgOpaqueData::_internal_set_pollselectableoptionscount(uint32_t value) { + _impl_._has_bits_[0] |= 0x00080000u; + _impl_.pollselectableoptionscount_ = value; +} +inline void MsgOpaqueData::set_pollselectableoptionscount(uint32_t value) { + _internal_set_pollselectableoptionscount(value); + // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.pollSelectableOptionsCount) +} + +// optional bytes messageSecret = 21; +inline bool MsgOpaqueData::_internal_has_messagesecret() const { + bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; + return value; +} +inline bool MsgOpaqueData::has_messagesecret() const { + return _internal_has_messagesecret(); +} +inline void MsgOpaqueData::clear_messagesecret() { + _impl_.messagesecret_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000800u; +} +inline const std::string& MsgOpaqueData::messagesecret() const { + // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.messageSecret) + return _internal_messagesecret(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void MsgOpaqueData::set_messagesecret(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000800u; + _impl_.messagesecret_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.messageSecret) +} +inline std::string* MsgOpaqueData::mutable_messagesecret() { + std::string* _s = _internal_mutable_messagesecret(); + // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.messageSecret) + return _s; +} +inline const std::string& MsgOpaqueData::_internal_messagesecret() const { + return _impl_.messagesecret_.Get(); +} +inline void MsgOpaqueData::_internal_set_messagesecret(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000800u; + _impl_.messagesecret_.Set(value, GetArenaForAllocation()); +} +inline std::string* MsgOpaqueData::_internal_mutable_messagesecret() { + _impl_._has_bits_[0] |= 0x00000800u; + return _impl_.messagesecret_.Mutable(GetArenaForAllocation()); +} +inline std::string* MsgOpaqueData::release_messagesecret() { + // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.messageSecret) + if (!_internal_has_messagesecret()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000800u; + auto* p = _impl_.messagesecret_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.messagesecret_.IsDefault()) { + _impl_.messagesecret_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void MsgOpaqueData::set_allocated_messagesecret(std::string* messagesecret) { + if (messagesecret != nullptr) { + _impl_._has_bits_[0] |= 0x00000800u; + } else { + _impl_._has_bits_[0] &= ~0x00000800u; + } + _impl_.messagesecret_.SetAllocated(messagesecret, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.messagesecret_.IsDefault()) { + _impl_.messagesecret_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.messageSecret) +} + +// optional int64 senderTimestampMs = 22; +inline bool MsgOpaqueData::_internal_has_sendertimestampms() const { + bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0; + return value; +} +inline bool MsgOpaqueData::has_sendertimestampms() const { + return _internal_has_sendertimestampms(); +} +inline void MsgOpaqueData::clear_sendertimestampms() { + _impl_.sendertimestampms_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00040000u; +} +inline int64_t MsgOpaqueData::_internal_sendertimestampms() const { + return _impl_.sendertimestampms_; +} +inline int64_t MsgOpaqueData::sendertimestampms() const { + // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.senderTimestampMs) + return _internal_sendertimestampms(); +} +inline void MsgOpaqueData::_internal_set_sendertimestampms(int64_t value) { + _impl_._has_bits_[0] |= 0x00040000u; + _impl_.sendertimestampms_ = value; +} +inline void MsgOpaqueData::set_sendertimestampms(int64_t value) { + _internal_set_sendertimestampms(value); + // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.senderTimestampMs) +} + +// optional string pollUpdateParentKey = 23; +inline bool MsgOpaqueData::_internal_has_pollupdateparentkey() const { + bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; + return value; +} +inline bool MsgOpaqueData::has_pollupdateparentkey() const { + return _internal_has_pollupdateparentkey(); +} +inline void MsgOpaqueData::clear_pollupdateparentkey() { + _impl_.pollupdateparentkey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00001000u; +} +inline const std::string& MsgOpaqueData::pollupdateparentkey() const { + // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.pollUpdateParentKey) + return _internal_pollupdateparentkey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void MsgOpaqueData::set_pollupdateparentkey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00001000u; + _impl_.pollupdateparentkey_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.pollUpdateParentKey) +} +inline std::string* MsgOpaqueData::mutable_pollupdateparentkey() { + std::string* _s = _internal_mutable_pollupdateparentkey(); + // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.pollUpdateParentKey) + return _s; +} +inline const std::string& MsgOpaqueData::_internal_pollupdateparentkey() const { + return _impl_.pollupdateparentkey_.Get(); +} +inline void MsgOpaqueData::_internal_set_pollupdateparentkey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00001000u; + _impl_.pollupdateparentkey_.Set(value, GetArenaForAllocation()); +} +inline std::string* MsgOpaqueData::_internal_mutable_pollupdateparentkey() { + _impl_._has_bits_[0] |= 0x00001000u; + return _impl_.pollupdateparentkey_.Mutable(GetArenaForAllocation()); +} +inline std::string* MsgOpaqueData::release_pollupdateparentkey() { + // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.pollUpdateParentKey) + if (!_internal_has_pollupdateparentkey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00001000u; + auto* p = _impl_.pollupdateparentkey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.pollupdateparentkey_.IsDefault()) { + _impl_.pollupdateparentkey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void MsgOpaqueData::set_allocated_pollupdateparentkey(std::string* pollupdateparentkey) { + if (pollupdateparentkey != nullptr) { + _impl_._has_bits_[0] |= 0x00001000u; + } else { + _impl_._has_bits_[0] &= ~0x00001000u; + } + _impl_.pollupdateparentkey_.SetAllocated(pollupdateparentkey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.pollupdateparentkey_.IsDefault()) { + _impl_.pollupdateparentkey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.pollUpdateParentKey) +} + +// optional .proto.PollEncValue encPollVote = 24; +inline bool MsgOpaqueData::_internal_has_encpollvote() const { + bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.encpollvote_ != nullptr); + return value; +} +inline bool MsgOpaqueData::has_encpollvote() const { + return _internal_has_encpollvote(); +} +inline void MsgOpaqueData::clear_encpollvote() { + if (_impl_.encpollvote_ != nullptr) _impl_.encpollvote_->Clear(); + _impl_._has_bits_[0] &= ~0x00002000u; +} +inline const ::proto::PollEncValue& MsgOpaqueData::_internal_encpollvote() const { + const ::proto::PollEncValue* p = _impl_.encpollvote_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_PollEncValue_default_instance_); +} +inline const ::proto::PollEncValue& MsgOpaqueData::encpollvote() const { + // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.encPollVote) + return _internal_encpollvote(); +} +inline void MsgOpaqueData::unsafe_arena_set_allocated_encpollvote( + ::proto::PollEncValue* encpollvote) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.encpollvote_); + } + _impl_.encpollvote_ = encpollvote; + if (encpollvote) { + _impl_._has_bits_[0] |= 0x00002000u; + } else { + _impl_._has_bits_[0] &= ~0x00002000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.MsgOpaqueData.encPollVote) +} +inline ::proto::PollEncValue* MsgOpaqueData::release_encpollvote() { + _impl_._has_bits_[0] &= ~0x00002000u; + ::proto::PollEncValue* temp = _impl_.encpollvote_; + _impl_.encpollvote_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::PollEncValue* MsgOpaqueData::unsafe_arena_release_encpollvote() { + // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.encPollVote) + _impl_._has_bits_[0] &= ~0x00002000u; + ::proto::PollEncValue* temp = _impl_.encpollvote_; + _impl_.encpollvote_ = nullptr; + return temp; +} +inline ::proto::PollEncValue* MsgOpaqueData::_internal_mutable_encpollvote() { + _impl_._has_bits_[0] |= 0x00002000u; + if (_impl_.encpollvote_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::PollEncValue>(GetArenaForAllocation()); + _impl_.encpollvote_ = p; + } + return _impl_.encpollvote_; +} +inline ::proto::PollEncValue* MsgOpaqueData::mutable_encpollvote() { + ::proto::PollEncValue* _msg = _internal_mutable_encpollvote(); + // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.encPollVote) + return _msg; +} +inline void MsgOpaqueData::set_allocated_encpollvote(::proto::PollEncValue* encpollvote) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.encpollvote_; + } + if (encpollvote) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(encpollvote); + if (message_arena != submessage_arena) { + encpollvote = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, encpollvote, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00002000u; + } else { + _impl_._has_bits_[0] &= ~0x00002000u; + } + _impl_.encpollvote_ = encpollvote; + // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.encPollVote) +} + +// ------------------------------------------------------------------- + +// MsgRowOpaqueData + +// optional .proto.MsgOpaqueData currentMsg = 1; +inline bool MsgRowOpaqueData::_internal_has_currentmsg() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.currentmsg_ != nullptr); + return value; +} +inline bool MsgRowOpaqueData::has_currentmsg() const { + return _internal_has_currentmsg(); +} +inline void MsgRowOpaqueData::clear_currentmsg() { + if (_impl_.currentmsg_ != nullptr) _impl_.currentmsg_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::MsgOpaqueData& MsgRowOpaqueData::_internal_currentmsg() const { + const ::proto::MsgOpaqueData* p = _impl_.currentmsg_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_MsgOpaqueData_default_instance_); +} +inline const ::proto::MsgOpaqueData& MsgRowOpaqueData::currentmsg() const { + // @@protoc_insertion_point(field_get:proto.MsgRowOpaqueData.currentMsg) + return _internal_currentmsg(); +} +inline void MsgRowOpaqueData::unsafe_arena_set_allocated_currentmsg( + ::proto::MsgOpaqueData* currentmsg) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.currentmsg_); + } + _impl_.currentmsg_ = currentmsg; + if (currentmsg) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.MsgRowOpaqueData.currentMsg) +} +inline ::proto::MsgOpaqueData* MsgRowOpaqueData::release_currentmsg() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::MsgOpaqueData* temp = _impl_.currentmsg_; + _impl_.currentmsg_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::MsgOpaqueData* MsgRowOpaqueData::unsafe_arena_release_currentmsg() { + // @@protoc_insertion_point(field_release:proto.MsgRowOpaqueData.currentMsg) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::MsgOpaqueData* temp = _impl_.currentmsg_; + _impl_.currentmsg_ = nullptr; + return temp; +} +inline ::proto::MsgOpaqueData* MsgRowOpaqueData::_internal_mutable_currentmsg() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.currentmsg_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::MsgOpaqueData>(GetArenaForAllocation()); + _impl_.currentmsg_ = p; + } + return _impl_.currentmsg_; +} +inline ::proto::MsgOpaqueData* MsgRowOpaqueData::mutable_currentmsg() { + ::proto::MsgOpaqueData* _msg = _internal_mutable_currentmsg(); + // @@protoc_insertion_point(field_mutable:proto.MsgRowOpaqueData.currentMsg) + return _msg; +} +inline void MsgRowOpaqueData::set_allocated_currentmsg(::proto::MsgOpaqueData* currentmsg) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.currentmsg_; + } + if (currentmsg) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(currentmsg); + if (message_arena != submessage_arena) { + currentmsg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, currentmsg, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.currentmsg_ = currentmsg; + // @@protoc_insertion_point(field_set_allocated:proto.MsgRowOpaqueData.currentMsg) +} + +// optional .proto.MsgOpaqueData quotedMsg = 2; +inline bool MsgRowOpaqueData::_internal_has_quotedmsg() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.quotedmsg_ != nullptr); + return value; +} +inline bool MsgRowOpaqueData::has_quotedmsg() const { + return _internal_has_quotedmsg(); +} +inline void MsgRowOpaqueData::clear_quotedmsg() { + if (_impl_.quotedmsg_ != nullptr) _impl_.quotedmsg_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::MsgOpaqueData& MsgRowOpaqueData::_internal_quotedmsg() const { + const ::proto::MsgOpaqueData* p = _impl_.quotedmsg_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_MsgOpaqueData_default_instance_); +} +inline const ::proto::MsgOpaqueData& MsgRowOpaqueData::quotedmsg() const { + // @@protoc_insertion_point(field_get:proto.MsgRowOpaqueData.quotedMsg) + return _internal_quotedmsg(); +} +inline void MsgRowOpaqueData::unsafe_arena_set_allocated_quotedmsg( + ::proto::MsgOpaqueData* quotedmsg) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quotedmsg_); + } + _impl_.quotedmsg_ = quotedmsg; + if (quotedmsg) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.MsgRowOpaqueData.quotedMsg) +} +inline ::proto::MsgOpaqueData* MsgRowOpaqueData::release_quotedmsg() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::MsgOpaqueData* temp = _impl_.quotedmsg_; + _impl_.quotedmsg_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::MsgOpaqueData* MsgRowOpaqueData::unsafe_arena_release_quotedmsg() { + // @@protoc_insertion_point(field_release:proto.MsgRowOpaqueData.quotedMsg) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::MsgOpaqueData* temp = _impl_.quotedmsg_; + _impl_.quotedmsg_ = nullptr; + return temp; +} +inline ::proto::MsgOpaqueData* MsgRowOpaqueData::_internal_mutable_quotedmsg() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.quotedmsg_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::MsgOpaqueData>(GetArenaForAllocation()); + _impl_.quotedmsg_ = p; + } + return _impl_.quotedmsg_; +} +inline ::proto::MsgOpaqueData* MsgRowOpaqueData::mutable_quotedmsg() { + ::proto::MsgOpaqueData* _msg = _internal_mutable_quotedmsg(); + // @@protoc_insertion_point(field_mutable:proto.MsgRowOpaqueData.quotedMsg) + return _msg; +} +inline void MsgRowOpaqueData::set_allocated_quotedmsg(::proto::MsgOpaqueData* quotedmsg) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.quotedmsg_; + } + if (quotedmsg) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quotedmsg); + if (message_arena != submessage_arena) { + quotedmsg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, quotedmsg, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.quotedmsg_ = quotedmsg; + // @@protoc_insertion_point(field_set_allocated:proto.MsgRowOpaqueData.quotedMsg) +} + +// ------------------------------------------------------------------- + +// NoiseCertificate_Details + +// optional uint32 serial = 1; +inline bool NoiseCertificate_Details::_internal_has_serial() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool NoiseCertificate_Details::has_serial() const { + return _internal_has_serial(); +} +inline void NoiseCertificate_Details::clear_serial() { + _impl_.serial_ = 0u; + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline uint32_t NoiseCertificate_Details::_internal_serial() const { + return _impl_.serial_; +} +inline uint32_t NoiseCertificate_Details::serial() const { + // @@protoc_insertion_point(field_get:proto.NoiseCertificate.Details.serial) + return _internal_serial(); +} +inline void NoiseCertificate_Details::_internal_set_serial(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.serial_ = value; +} +inline void NoiseCertificate_Details::set_serial(uint32_t value) { + _internal_set_serial(value); + // @@protoc_insertion_point(field_set:proto.NoiseCertificate.Details.serial) +} + +// optional string issuer = 2; +inline bool NoiseCertificate_Details::_internal_has_issuer() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool NoiseCertificate_Details::has_issuer() const { + return _internal_has_issuer(); +} +inline void NoiseCertificate_Details::clear_issuer() { + _impl_.issuer_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& NoiseCertificate_Details::issuer() const { + // @@protoc_insertion_point(field_get:proto.NoiseCertificate.Details.issuer) + return _internal_issuer(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void NoiseCertificate_Details::set_issuer(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.issuer_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.NoiseCertificate.Details.issuer) +} +inline std::string* NoiseCertificate_Details::mutable_issuer() { + std::string* _s = _internal_mutable_issuer(); + // @@protoc_insertion_point(field_mutable:proto.NoiseCertificate.Details.issuer) + return _s; +} +inline const std::string& NoiseCertificate_Details::_internal_issuer() const { + return _impl_.issuer_.Get(); +} +inline void NoiseCertificate_Details::_internal_set_issuer(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.issuer_.Set(value, GetArenaForAllocation()); +} +inline std::string* NoiseCertificate_Details::_internal_mutable_issuer() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.issuer_.Mutable(GetArenaForAllocation()); +} +inline std::string* NoiseCertificate_Details::release_issuer() { + // @@protoc_insertion_point(field_release:proto.NoiseCertificate.Details.issuer) + if (!_internal_has_issuer()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.issuer_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.issuer_.IsDefault()) { + _impl_.issuer_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void NoiseCertificate_Details::set_allocated_issuer(std::string* issuer) { + if (issuer != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.issuer_.SetAllocated(issuer, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.issuer_.IsDefault()) { + _impl_.issuer_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.NoiseCertificate.Details.issuer) +} + +// optional uint64 expires = 3; +inline bool NoiseCertificate_Details::_internal_has_expires() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool NoiseCertificate_Details::has_expires() const { + return _internal_has_expires(); +} +inline void NoiseCertificate_Details::clear_expires() { + _impl_.expires_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline uint64_t NoiseCertificate_Details::_internal_expires() const { + return _impl_.expires_; +} +inline uint64_t NoiseCertificate_Details::expires() const { + // @@protoc_insertion_point(field_get:proto.NoiseCertificate.Details.expires) + return _internal_expires(); +} +inline void NoiseCertificate_Details::_internal_set_expires(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.expires_ = value; +} +inline void NoiseCertificate_Details::set_expires(uint64_t value) { + _internal_set_expires(value); + // @@protoc_insertion_point(field_set:proto.NoiseCertificate.Details.expires) +} + +// optional string subject = 4; +inline bool NoiseCertificate_Details::_internal_has_subject() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool NoiseCertificate_Details::has_subject() const { + return _internal_has_subject(); +} +inline void NoiseCertificate_Details::clear_subject() { + _impl_.subject_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& NoiseCertificate_Details::subject() const { + // @@protoc_insertion_point(field_get:proto.NoiseCertificate.Details.subject) + return _internal_subject(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void NoiseCertificate_Details::set_subject(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.subject_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.NoiseCertificate.Details.subject) +} +inline std::string* NoiseCertificate_Details::mutable_subject() { + std::string* _s = _internal_mutable_subject(); + // @@protoc_insertion_point(field_mutable:proto.NoiseCertificate.Details.subject) + return _s; +} +inline const std::string& NoiseCertificate_Details::_internal_subject() const { + return _impl_.subject_.Get(); +} +inline void NoiseCertificate_Details::_internal_set_subject(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.subject_.Set(value, GetArenaForAllocation()); +} +inline std::string* NoiseCertificate_Details::_internal_mutable_subject() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.subject_.Mutable(GetArenaForAllocation()); +} +inline std::string* NoiseCertificate_Details::release_subject() { + // @@protoc_insertion_point(field_release:proto.NoiseCertificate.Details.subject) + if (!_internal_has_subject()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.subject_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.subject_.IsDefault()) { + _impl_.subject_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void NoiseCertificate_Details::set_allocated_subject(std::string* subject) { + if (subject != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.subject_.SetAllocated(subject, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.subject_.IsDefault()) { + _impl_.subject_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.NoiseCertificate.Details.subject) +} + +// optional bytes key = 5; +inline bool NoiseCertificate_Details::_internal_has_key() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool NoiseCertificate_Details::has_key() const { + return _internal_has_key(); +} +inline void NoiseCertificate_Details::clear_key() { + _impl_.key_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& NoiseCertificate_Details::key() const { + // @@protoc_insertion_point(field_get:proto.NoiseCertificate.Details.key) + return _internal_key(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void NoiseCertificate_Details::set_key(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.key_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.NoiseCertificate.Details.key) +} +inline std::string* NoiseCertificate_Details::mutable_key() { + std::string* _s = _internal_mutable_key(); + // @@protoc_insertion_point(field_mutable:proto.NoiseCertificate.Details.key) + return _s; +} +inline const std::string& NoiseCertificate_Details::_internal_key() const { + return _impl_.key_.Get(); +} +inline void NoiseCertificate_Details::_internal_set_key(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.key_.Set(value, GetArenaForAllocation()); +} +inline std::string* NoiseCertificate_Details::_internal_mutable_key() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.key_.Mutable(GetArenaForAllocation()); +} +inline std::string* NoiseCertificate_Details::release_key() { + // @@protoc_insertion_point(field_release:proto.NoiseCertificate.Details.key) + if (!_internal_has_key()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.key_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.key_.IsDefault()) { + _impl_.key_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void NoiseCertificate_Details::set_allocated_key(std::string* key) { + if (key != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.key_.SetAllocated(key, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.key_.IsDefault()) { + _impl_.key_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.NoiseCertificate.Details.key) +} + +// ------------------------------------------------------------------- + +// NoiseCertificate + +// optional bytes details = 1; +inline bool NoiseCertificate::_internal_has_details() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool NoiseCertificate::has_details() const { + return _internal_has_details(); +} +inline void NoiseCertificate::clear_details() { + _impl_.details_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& NoiseCertificate::details() const { + // @@protoc_insertion_point(field_get:proto.NoiseCertificate.details) + return _internal_details(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void NoiseCertificate::set_details(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.details_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.NoiseCertificate.details) +} +inline std::string* NoiseCertificate::mutable_details() { + std::string* _s = _internal_mutable_details(); + // @@protoc_insertion_point(field_mutable:proto.NoiseCertificate.details) + return _s; +} +inline const std::string& NoiseCertificate::_internal_details() const { + return _impl_.details_.Get(); +} +inline void NoiseCertificate::_internal_set_details(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.details_.Set(value, GetArenaForAllocation()); +} +inline std::string* NoiseCertificate::_internal_mutable_details() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.details_.Mutable(GetArenaForAllocation()); +} +inline std::string* NoiseCertificate::release_details() { + // @@protoc_insertion_point(field_release:proto.NoiseCertificate.details) + if (!_internal_has_details()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.details_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.details_.IsDefault()) { + _impl_.details_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void NoiseCertificate::set_allocated_details(std::string* details) { + if (details != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.details_.SetAllocated(details, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.details_.IsDefault()) { + _impl_.details_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.NoiseCertificate.details) +} + +// optional bytes signature = 2; +inline bool NoiseCertificate::_internal_has_signature() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool NoiseCertificate::has_signature() const { + return _internal_has_signature(); +} +inline void NoiseCertificate::clear_signature() { + _impl_.signature_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& NoiseCertificate::signature() const { + // @@protoc_insertion_point(field_get:proto.NoiseCertificate.signature) + return _internal_signature(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void NoiseCertificate::set_signature(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.signature_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.NoiseCertificate.signature) +} +inline std::string* NoiseCertificate::mutable_signature() { + std::string* _s = _internal_mutable_signature(); + // @@protoc_insertion_point(field_mutable:proto.NoiseCertificate.signature) + return _s; +} +inline const std::string& NoiseCertificate::_internal_signature() const { + return _impl_.signature_.Get(); +} +inline void NoiseCertificate::_internal_set_signature(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.signature_.Set(value, GetArenaForAllocation()); +} +inline std::string* NoiseCertificate::_internal_mutable_signature() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.signature_.Mutable(GetArenaForAllocation()); +} +inline std::string* NoiseCertificate::release_signature() { + // @@protoc_insertion_point(field_release:proto.NoiseCertificate.signature) + if (!_internal_has_signature()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.signature_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.signature_.IsDefault()) { + _impl_.signature_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void NoiseCertificate::set_allocated_signature(std::string* signature) { + if (signature != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.signature_.SetAllocated(signature, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.signature_.IsDefault()) { + _impl_.signature_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.NoiseCertificate.signature) +} + +// ------------------------------------------------------------------- + +// NotificationMessageInfo + +// optional .proto.MessageKey key = 1; +inline bool NotificationMessageInfo::_internal_has_key() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr); + return value; +} +inline bool NotificationMessageInfo::has_key() const { + return _internal_has_key(); +} +inline void NotificationMessageInfo::clear_key() { + if (_impl_.key_ != nullptr) _impl_.key_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::MessageKey& NotificationMessageInfo::_internal_key() const { + const ::proto::MessageKey* p = _impl_.key_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_MessageKey_default_instance_); +} +inline const ::proto::MessageKey& NotificationMessageInfo::key() const { + // @@protoc_insertion_point(field_get:proto.NotificationMessageInfo.key) + return _internal_key(); +} +inline void NotificationMessageInfo::unsafe_arena_set_allocated_key( + ::proto::MessageKey* key) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_); + } + _impl_.key_ = key; + if (key) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.NotificationMessageInfo.key) +} +inline ::proto::MessageKey* NotificationMessageInfo::release_key() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::MessageKey* temp = _impl_.key_; + _impl_.key_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::MessageKey* NotificationMessageInfo::unsafe_arena_release_key() { + // @@protoc_insertion_point(field_release:proto.NotificationMessageInfo.key) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::MessageKey* temp = _impl_.key_; + _impl_.key_ = nullptr; + return temp; +} +inline ::proto::MessageKey* NotificationMessageInfo::_internal_mutable_key() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.key_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation()); + _impl_.key_ = p; + } + return _impl_.key_; +} +inline ::proto::MessageKey* NotificationMessageInfo::mutable_key() { + ::proto::MessageKey* _msg = _internal_mutable_key(); + // @@protoc_insertion_point(field_mutable:proto.NotificationMessageInfo.key) + return _msg; +} +inline void NotificationMessageInfo::set_allocated_key(::proto::MessageKey* key) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.key_; + } + if (key) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key); + if (message_arena != submessage_arena) { + key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, key, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.key_ = key; + // @@protoc_insertion_point(field_set_allocated:proto.NotificationMessageInfo.key) +} + +// optional .proto.Message message = 2; +inline bool NotificationMessageInfo::_internal_has_message() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.message_ != nullptr); + return value; +} +inline bool NotificationMessageInfo::has_message() const { + return _internal_has_message(); +} +inline void NotificationMessageInfo::clear_message() { + if (_impl_.message_ != nullptr) _impl_.message_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::proto::Message& NotificationMessageInfo::_internal_message() const { + const ::proto::Message* p = _impl_.message_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_default_instance_); +} +inline const ::proto::Message& NotificationMessageInfo::message() const { + // @@protoc_insertion_point(field_get:proto.NotificationMessageInfo.message) + return _internal_message(); +} +inline void NotificationMessageInfo::unsafe_arena_set_allocated_message( + ::proto::Message* message) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.message_); + } + _impl_.message_ = message; + if (message) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.NotificationMessageInfo.message) +} +inline ::proto::Message* NotificationMessageInfo::release_message() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::Message* temp = _impl_.message_; + _impl_.message_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message* NotificationMessageInfo::unsafe_arena_release_message() { + // @@protoc_insertion_point(field_release:proto.NotificationMessageInfo.message) + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::Message* temp = _impl_.message_; + _impl_.message_ = nullptr; + return temp; +} +inline ::proto::Message* NotificationMessageInfo::_internal_mutable_message() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.message_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message>(GetArenaForAllocation()); + _impl_.message_ = p; + } + return _impl_.message_; +} +inline ::proto::Message* NotificationMessageInfo::mutable_message() { + ::proto::Message* _msg = _internal_mutable_message(); + // @@protoc_insertion_point(field_mutable:proto.NotificationMessageInfo.message) + return _msg; +} +inline void NotificationMessageInfo::set_allocated_message(::proto::Message* message) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.message_; + } + if (message) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(message); + if (message_arena != submessage_arena) { + message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, message, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.message_ = message; + // @@protoc_insertion_point(field_set_allocated:proto.NotificationMessageInfo.message) +} + +// optional uint64 messageTimestamp = 3; +inline bool NotificationMessageInfo::_internal_has_messagetimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool NotificationMessageInfo::has_messagetimestamp() const { + return _internal_has_messagetimestamp(); +} +inline void NotificationMessageInfo::clear_messagetimestamp() { + _impl_.messagetimestamp_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline uint64_t NotificationMessageInfo::_internal_messagetimestamp() const { + return _impl_.messagetimestamp_; +} +inline uint64_t NotificationMessageInfo::messagetimestamp() const { + // @@protoc_insertion_point(field_get:proto.NotificationMessageInfo.messageTimestamp) + return _internal_messagetimestamp(); +} +inline void NotificationMessageInfo::_internal_set_messagetimestamp(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.messagetimestamp_ = value; +} +inline void NotificationMessageInfo::set_messagetimestamp(uint64_t value) { + _internal_set_messagetimestamp(value); + // @@protoc_insertion_point(field_set:proto.NotificationMessageInfo.messageTimestamp) +} + +// optional string participant = 4; +inline bool NotificationMessageInfo::_internal_has_participant() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool NotificationMessageInfo::has_participant() const { + return _internal_has_participant(); +} +inline void NotificationMessageInfo::clear_participant() { + _impl_.participant_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& NotificationMessageInfo::participant() const { + // @@protoc_insertion_point(field_get:proto.NotificationMessageInfo.participant) + return _internal_participant(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void NotificationMessageInfo::set_participant(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.participant_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.NotificationMessageInfo.participant) +} +inline std::string* NotificationMessageInfo::mutable_participant() { + std::string* _s = _internal_mutable_participant(); + // @@protoc_insertion_point(field_mutable:proto.NotificationMessageInfo.participant) + return _s; +} +inline const std::string& NotificationMessageInfo::_internal_participant() const { + return _impl_.participant_.Get(); +} +inline void NotificationMessageInfo::_internal_set_participant(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.participant_.Set(value, GetArenaForAllocation()); +} +inline std::string* NotificationMessageInfo::_internal_mutable_participant() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.participant_.Mutable(GetArenaForAllocation()); +} +inline std::string* NotificationMessageInfo::release_participant() { + // @@protoc_insertion_point(field_release:proto.NotificationMessageInfo.participant) + if (!_internal_has_participant()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.participant_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.participant_.IsDefault()) { + _impl_.participant_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void NotificationMessageInfo::set_allocated_participant(std::string* participant) { + if (participant != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.participant_.SetAllocated(participant, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.participant_.IsDefault()) { + _impl_.participant_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.NotificationMessageInfo.participant) +} + +// ------------------------------------------------------------------- + +// PastParticipant + +// required string userJid = 1; +inline bool PastParticipant::_internal_has_userjid() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool PastParticipant::has_userjid() const { + return _internal_has_userjid(); +} +inline void PastParticipant::clear_userjid() { + _impl_.userjid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& PastParticipant::userjid() const { + // @@protoc_insertion_point(field_get:proto.PastParticipant.userJid) + return _internal_userjid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void PastParticipant::set_userjid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.userjid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.PastParticipant.userJid) +} +inline std::string* PastParticipant::mutable_userjid() { + std::string* _s = _internal_mutable_userjid(); + // @@protoc_insertion_point(field_mutable:proto.PastParticipant.userJid) + return _s; +} +inline const std::string& PastParticipant::_internal_userjid() const { + return _impl_.userjid_.Get(); +} +inline void PastParticipant::_internal_set_userjid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.userjid_.Set(value, GetArenaForAllocation()); +} +inline std::string* PastParticipant::_internal_mutable_userjid() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.userjid_.Mutable(GetArenaForAllocation()); +} +inline std::string* PastParticipant::release_userjid() { + // @@protoc_insertion_point(field_release:proto.PastParticipant.userJid) + if (!_internal_has_userjid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.userjid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.userjid_.IsDefault()) { + _impl_.userjid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void PastParticipant::set_allocated_userjid(std::string* userjid) { + if (userjid != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.userjid_.SetAllocated(userjid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.userjid_.IsDefault()) { + _impl_.userjid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.PastParticipant.userJid) +} + +// required .proto.PastParticipant.LeaveReason leaveReason = 2; +inline bool PastParticipant::_internal_has_leavereason() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool PastParticipant::has_leavereason() const { + return _internal_has_leavereason(); +} +inline void PastParticipant::clear_leavereason() { + _impl_.leavereason_ = 0; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline ::proto::PastParticipant_LeaveReason PastParticipant::_internal_leavereason() const { + return static_cast< ::proto::PastParticipant_LeaveReason >(_impl_.leavereason_); +} +inline ::proto::PastParticipant_LeaveReason PastParticipant::leavereason() const { + // @@protoc_insertion_point(field_get:proto.PastParticipant.leaveReason) + return _internal_leavereason(); +} +inline void PastParticipant::_internal_set_leavereason(::proto::PastParticipant_LeaveReason value) { + assert(::proto::PastParticipant_LeaveReason_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.leavereason_ = value; +} +inline void PastParticipant::set_leavereason(::proto::PastParticipant_LeaveReason value) { + _internal_set_leavereason(value); + // @@protoc_insertion_point(field_set:proto.PastParticipant.leaveReason) +} + +// required uint64 leaveTs = 3; +inline bool PastParticipant::_internal_has_leavets() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool PastParticipant::has_leavets() const { + return _internal_has_leavets(); +} +inline void PastParticipant::clear_leavets() { + _impl_.leavets_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline uint64_t PastParticipant::_internal_leavets() const { + return _impl_.leavets_; +} +inline uint64_t PastParticipant::leavets() const { + // @@protoc_insertion_point(field_get:proto.PastParticipant.leaveTs) + return _internal_leavets(); +} +inline void PastParticipant::_internal_set_leavets(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.leavets_ = value; +} +inline void PastParticipant::set_leavets(uint64_t value) { + _internal_set_leavets(value); + // @@protoc_insertion_point(field_set:proto.PastParticipant.leaveTs) +} + +// ------------------------------------------------------------------- + +// PastParticipants + +// required string groupJid = 1; +inline bool PastParticipants::_internal_has_groupjid() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool PastParticipants::has_groupjid() const { + return _internal_has_groupjid(); +} +inline void PastParticipants::clear_groupjid() { + _impl_.groupjid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& PastParticipants::groupjid() const { + // @@protoc_insertion_point(field_get:proto.PastParticipants.groupJid) + return _internal_groupjid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void PastParticipants::set_groupjid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.groupjid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.PastParticipants.groupJid) +} +inline std::string* PastParticipants::mutable_groupjid() { + std::string* _s = _internal_mutable_groupjid(); + // @@protoc_insertion_point(field_mutable:proto.PastParticipants.groupJid) + return _s; +} +inline const std::string& PastParticipants::_internal_groupjid() const { + return _impl_.groupjid_.Get(); +} +inline void PastParticipants::_internal_set_groupjid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.groupjid_.Set(value, GetArenaForAllocation()); +} +inline std::string* PastParticipants::_internal_mutable_groupjid() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.groupjid_.Mutable(GetArenaForAllocation()); +} +inline std::string* PastParticipants::release_groupjid() { + // @@protoc_insertion_point(field_release:proto.PastParticipants.groupJid) + if (!_internal_has_groupjid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.groupjid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.groupjid_.IsDefault()) { + _impl_.groupjid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void PastParticipants::set_allocated_groupjid(std::string* groupjid) { + if (groupjid != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.groupjid_.SetAllocated(groupjid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.groupjid_.IsDefault()) { + _impl_.groupjid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.PastParticipants.groupJid) +} + +// repeated .proto.PastParticipant pastParticipants = 2; +inline int PastParticipants::_internal_pastparticipants_size() const { + return _impl_.pastparticipants_.size(); +} +inline int PastParticipants::pastparticipants_size() const { + return _internal_pastparticipants_size(); +} +inline void PastParticipants::clear_pastparticipants() { + _impl_.pastparticipants_.Clear(); +} +inline ::proto::PastParticipant* PastParticipants::mutable_pastparticipants(int index) { + // @@protoc_insertion_point(field_mutable:proto.PastParticipants.pastParticipants) + return _impl_.pastparticipants_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipant >* +PastParticipants::mutable_pastparticipants() { + // @@protoc_insertion_point(field_mutable_list:proto.PastParticipants.pastParticipants) + return &_impl_.pastparticipants_; +} +inline const ::proto::PastParticipant& PastParticipants::_internal_pastparticipants(int index) const { + return _impl_.pastparticipants_.Get(index); +} +inline const ::proto::PastParticipant& PastParticipants::pastparticipants(int index) const { + // @@protoc_insertion_point(field_get:proto.PastParticipants.pastParticipants) + return _internal_pastparticipants(index); +} +inline ::proto::PastParticipant* PastParticipants::_internal_add_pastparticipants() { + return _impl_.pastparticipants_.Add(); +} +inline ::proto::PastParticipant* PastParticipants::add_pastparticipants() { + ::proto::PastParticipant* _add = _internal_add_pastparticipants(); + // @@protoc_insertion_point(field_add:proto.PastParticipants.pastParticipants) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipant >& +PastParticipants::pastparticipants() const { + // @@protoc_insertion_point(field_list:proto.PastParticipants.pastParticipants) + return _impl_.pastparticipants_; +} + +// ------------------------------------------------------------------- + +// PaymentBackground_MediaData + +// optional bytes mediaKey = 1; +inline bool PaymentBackground_MediaData::_internal_has_mediakey() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool PaymentBackground_MediaData::has_mediakey() const { + return _internal_has_mediakey(); +} +inline void PaymentBackground_MediaData::clear_mediakey() { + _impl_.mediakey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& PaymentBackground_MediaData::mediakey() const { + // @@protoc_insertion_point(field_get:proto.PaymentBackground.MediaData.mediaKey) + return _internal_mediakey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void PaymentBackground_MediaData::set_mediakey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.mediakey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.PaymentBackground.MediaData.mediaKey) +} +inline std::string* PaymentBackground_MediaData::mutable_mediakey() { + std::string* _s = _internal_mutable_mediakey(); + // @@protoc_insertion_point(field_mutable:proto.PaymentBackground.MediaData.mediaKey) + return _s; +} +inline const std::string& PaymentBackground_MediaData::_internal_mediakey() const { + return _impl_.mediakey_.Get(); +} +inline void PaymentBackground_MediaData::_internal_set_mediakey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.mediakey_.Set(value, GetArenaForAllocation()); +} +inline std::string* PaymentBackground_MediaData::_internal_mutable_mediakey() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.mediakey_.Mutable(GetArenaForAllocation()); +} +inline std::string* PaymentBackground_MediaData::release_mediakey() { + // @@protoc_insertion_point(field_release:proto.PaymentBackground.MediaData.mediaKey) + if (!_internal_has_mediakey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.mediakey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mediakey_.IsDefault()) { + _impl_.mediakey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void PaymentBackground_MediaData::set_allocated_mediakey(std::string* mediakey) { + if (mediakey != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mediakey_.IsDefault()) { + _impl_.mediakey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.PaymentBackground.MediaData.mediaKey) +} + +// optional int64 mediaKeyTimestamp = 2; +inline bool PaymentBackground_MediaData::_internal_has_mediakeytimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool PaymentBackground_MediaData::has_mediakeytimestamp() const { + return _internal_has_mediakeytimestamp(); +} +inline void PaymentBackground_MediaData::clear_mediakeytimestamp() { + _impl_.mediakeytimestamp_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline int64_t PaymentBackground_MediaData::_internal_mediakeytimestamp() const { + return _impl_.mediakeytimestamp_; +} +inline int64_t PaymentBackground_MediaData::mediakeytimestamp() const { + // @@protoc_insertion_point(field_get:proto.PaymentBackground.MediaData.mediaKeyTimestamp) + return _internal_mediakeytimestamp(); +} +inline void PaymentBackground_MediaData::_internal_set_mediakeytimestamp(int64_t value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.mediakeytimestamp_ = value; +} +inline void PaymentBackground_MediaData::set_mediakeytimestamp(int64_t value) { + _internal_set_mediakeytimestamp(value); + // @@protoc_insertion_point(field_set:proto.PaymentBackground.MediaData.mediaKeyTimestamp) +} + +// optional bytes fileSha256 = 3; +inline bool PaymentBackground_MediaData::_internal_has_filesha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool PaymentBackground_MediaData::has_filesha256() const { + return _internal_has_filesha256(); +} +inline void PaymentBackground_MediaData::clear_filesha256() { + _impl_.filesha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& PaymentBackground_MediaData::filesha256() const { + // @@protoc_insertion_point(field_get:proto.PaymentBackground.MediaData.fileSha256) + return _internal_filesha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void PaymentBackground_MediaData::set_filesha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.filesha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.PaymentBackground.MediaData.fileSha256) +} +inline std::string* PaymentBackground_MediaData::mutable_filesha256() { + std::string* _s = _internal_mutable_filesha256(); + // @@protoc_insertion_point(field_mutable:proto.PaymentBackground.MediaData.fileSha256) + return _s; +} +inline const std::string& PaymentBackground_MediaData::_internal_filesha256() const { + return _impl_.filesha256_.Get(); +} +inline void PaymentBackground_MediaData::_internal_set_filesha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.filesha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* PaymentBackground_MediaData::_internal_mutable_filesha256() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.filesha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* PaymentBackground_MediaData::release_filesha256() { + // @@protoc_insertion_point(field_release:proto.PaymentBackground.MediaData.fileSha256) + if (!_internal_has_filesha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.filesha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.filesha256_.IsDefault()) { + _impl_.filesha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void PaymentBackground_MediaData::set_allocated_filesha256(std::string* filesha256) { + if (filesha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.filesha256_.IsDefault()) { + _impl_.filesha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.PaymentBackground.MediaData.fileSha256) +} + +// optional bytes fileEncSha256 = 4; +inline bool PaymentBackground_MediaData::_internal_has_fileencsha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool PaymentBackground_MediaData::has_fileencsha256() const { + return _internal_has_fileencsha256(); +} +inline void PaymentBackground_MediaData::clear_fileencsha256() { + _impl_.fileencsha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& PaymentBackground_MediaData::fileencsha256() const { + // @@protoc_insertion_point(field_get:proto.PaymentBackground.MediaData.fileEncSha256) + return _internal_fileencsha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void PaymentBackground_MediaData::set_fileencsha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.fileencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.PaymentBackground.MediaData.fileEncSha256) +} +inline std::string* PaymentBackground_MediaData::mutable_fileencsha256() { + std::string* _s = _internal_mutable_fileencsha256(); + // @@protoc_insertion_point(field_mutable:proto.PaymentBackground.MediaData.fileEncSha256) + return _s; +} +inline const std::string& PaymentBackground_MediaData::_internal_fileencsha256() const { + return _impl_.fileencsha256_.Get(); +} +inline void PaymentBackground_MediaData::_internal_set_fileencsha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.fileencsha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* PaymentBackground_MediaData::_internal_mutable_fileencsha256() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.fileencsha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* PaymentBackground_MediaData::release_fileencsha256() { + // @@protoc_insertion_point(field_release:proto.PaymentBackground.MediaData.fileEncSha256) + if (!_internal_has_fileencsha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.fileencsha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fileencsha256_.IsDefault()) { + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void PaymentBackground_MediaData::set_allocated_fileencsha256(std::string* fileencsha256) { + if (fileencsha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fileencsha256_.IsDefault()) { + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.PaymentBackground.MediaData.fileEncSha256) +} + +// optional string directPath = 5; +inline bool PaymentBackground_MediaData::_internal_has_directpath() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool PaymentBackground_MediaData::has_directpath() const { + return _internal_has_directpath(); +} +inline void PaymentBackground_MediaData::clear_directpath() { + _impl_.directpath_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const std::string& PaymentBackground_MediaData::directpath() const { + // @@protoc_insertion_point(field_get:proto.PaymentBackground.MediaData.directPath) + return _internal_directpath(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void PaymentBackground_MediaData::set_directpath(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.directpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.PaymentBackground.MediaData.directPath) +} +inline std::string* PaymentBackground_MediaData::mutable_directpath() { + std::string* _s = _internal_mutable_directpath(); + // @@protoc_insertion_point(field_mutable:proto.PaymentBackground.MediaData.directPath) + return _s; +} +inline const std::string& PaymentBackground_MediaData::_internal_directpath() const { + return _impl_.directpath_.Get(); +} +inline void PaymentBackground_MediaData::_internal_set_directpath(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.directpath_.Set(value, GetArenaForAllocation()); +} +inline std::string* PaymentBackground_MediaData::_internal_mutable_directpath() { + _impl_._has_bits_[0] |= 0x00000008u; + return _impl_.directpath_.Mutable(GetArenaForAllocation()); +} +inline std::string* PaymentBackground_MediaData::release_directpath() { + // @@protoc_insertion_point(field_release:proto.PaymentBackground.MediaData.directPath) + if (!_internal_has_directpath()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000008u; + auto* p = _impl_.directpath_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.directpath_.IsDefault()) { + _impl_.directpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void PaymentBackground_MediaData::set_allocated_directpath(std::string* directpath) { + if (directpath != nullptr) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.directpath_.IsDefault()) { + _impl_.directpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.PaymentBackground.MediaData.directPath) +} + +// ------------------------------------------------------------------- + +// PaymentBackground + +// optional string id = 1; +inline bool PaymentBackground::_internal_has_id() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool PaymentBackground::has_id() const { + return _internal_has_id(); +} +inline void PaymentBackground::clear_id() { + _impl_.id_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& PaymentBackground::id() const { + // @@protoc_insertion_point(field_get:proto.PaymentBackground.id) + return _internal_id(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void PaymentBackground::set_id(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.id_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.PaymentBackground.id) +} +inline std::string* PaymentBackground::mutable_id() { + std::string* _s = _internal_mutable_id(); + // @@protoc_insertion_point(field_mutable:proto.PaymentBackground.id) + return _s; +} +inline const std::string& PaymentBackground::_internal_id() const { + return _impl_.id_.Get(); +} +inline void PaymentBackground::_internal_set_id(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.id_.Set(value, GetArenaForAllocation()); +} +inline std::string* PaymentBackground::_internal_mutable_id() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.id_.Mutable(GetArenaForAllocation()); +} +inline std::string* PaymentBackground::release_id() { + // @@protoc_insertion_point(field_release:proto.PaymentBackground.id) + if (!_internal_has_id()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.id_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.id_.IsDefault()) { + _impl_.id_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void PaymentBackground::set_allocated_id(std::string* id) { + if (id != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.id_.SetAllocated(id, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.id_.IsDefault()) { + _impl_.id_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.PaymentBackground.id) +} + +// optional uint64 fileLength = 2; +inline bool PaymentBackground::_internal_has_filelength() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool PaymentBackground::has_filelength() const { + return _internal_has_filelength(); +} +inline void PaymentBackground::clear_filelength() { + _impl_.filelength_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline uint64_t PaymentBackground::_internal_filelength() const { + return _impl_.filelength_; +} +inline uint64_t PaymentBackground::filelength() const { + // @@protoc_insertion_point(field_get:proto.PaymentBackground.fileLength) + return _internal_filelength(); +} +inline void PaymentBackground::_internal_set_filelength(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.filelength_ = value; +} +inline void PaymentBackground::set_filelength(uint64_t value) { + _internal_set_filelength(value); + // @@protoc_insertion_point(field_set:proto.PaymentBackground.fileLength) +} + +// optional uint32 width = 3; +inline bool PaymentBackground::_internal_has_width() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool PaymentBackground::has_width() const { + return _internal_has_width(); +} +inline void PaymentBackground::clear_width() { + _impl_.width_ = 0u; + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline uint32_t PaymentBackground::_internal_width() const { + return _impl_.width_; +} +inline uint32_t PaymentBackground::width() const { + // @@protoc_insertion_point(field_get:proto.PaymentBackground.width) + return _internal_width(); +} +inline void PaymentBackground::_internal_set_width(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.width_ = value; +} +inline void PaymentBackground::set_width(uint32_t value) { + _internal_set_width(value); + // @@protoc_insertion_point(field_set:proto.PaymentBackground.width) +} + +// optional uint32 height = 4; +inline bool PaymentBackground::_internal_has_height() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool PaymentBackground::has_height() const { + return _internal_has_height(); +} +inline void PaymentBackground::clear_height() { + _impl_.height_ = 0u; + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline uint32_t PaymentBackground::_internal_height() const { + return _impl_.height_; +} +inline uint32_t PaymentBackground::height() const { + // @@protoc_insertion_point(field_get:proto.PaymentBackground.height) + return _internal_height(); +} +inline void PaymentBackground::_internal_set_height(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.height_ = value; +} +inline void PaymentBackground::set_height(uint32_t value) { + _internal_set_height(value); + // @@protoc_insertion_point(field_set:proto.PaymentBackground.height) +} + +// optional string mimetype = 5; +inline bool PaymentBackground::_internal_has_mimetype() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool PaymentBackground::has_mimetype() const { + return _internal_has_mimetype(); +} +inline void PaymentBackground::clear_mimetype() { + _impl_.mimetype_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& PaymentBackground::mimetype() const { + // @@protoc_insertion_point(field_get:proto.PaymentBackground.mimetype) + return _internal_mimetype(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void PaymentBackground::set_mimetype(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.mimetype_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.PaymentBackground.mimetype) +} +inline std::string* PaymentBackground::mutable_mimetype() { + std::string* _s = _internal_mutable_mimetype(); + // @@protoc_insertion_point(field_mutable:proto.PaymentBackground.mimetype) + return _s; +} +inline const std::string& PaymentBackground::_internal_mimetype() const { + return _impl_.mimetype_.Get(); +} +inline void PaymentBackground::_internal_set_mimetype(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.mimetype_.Set(value, GetArenaForAllocation()); +} +inline std::string* PaymentBackground::_internal_mutable_mimetype() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.mimetype_.Mutable(GetArenaForAllocation()); +} +inline std::string* PaymentBackground::release_mimetype() { + // @@protoc_insertion_point(field_release:proto.PaymentBackground.mimetype) + if (!_internal_has_mimetype()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.mimetype_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mimetype_.IsDefault()) { + _impl_.mimetype_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void PaymentBackground::set_allocated_mimetype(std::string* mimetype) { + if (mimetype != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mimetype_.IsDefault()) { + _impl_.mimetype_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.PaymentBackground.mimetype) +} + +// optional fixed32 placeholderArgb = 6; +inline bool PaymentBackground::_internal_has_placeholderargb() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool PaymentBackground::has_placeholderargb() const { + return _internal_has_placeholderargb(); +} +inline void PaymentBackground::clear_placeholderargb() { + _impl_.placeholderargb_ = 0u; + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline uint32_t PaymentBackground::_internal_placeholderargb() const { + return _impl_.placeholderargb_; +} +inline uint32_t PaymentBackground::placeholderargb() const { + // @@protoc_insertion_point(field_get:proto.PaymentBackground.placeholderArgb) + return _internal_placeholderargb(); +} +inline void PaymentBackground::_internal_set_placeholderargb(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.placeholderargb_ = value; +} +inline void PaymentBackground::set_placeholderargb(uint32_t value) { + _internal_set_placeholderargb(value); + // @@protoc_insertion_point(field_set:proto.PaymentBackground.placeholderArgb) +} + +// optional fixed32 textArgb = 7; +inline bool PaymentBackground::_internal_has_textargb() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool PaymentBackground::has_textargb() const { + return _internal_has_textargb(); +} +inline void PaymentBackground::clear_textargb() { + _impl_.textargb_ = 0u; + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline uint32_t PaymentBackground::_internal_textargb() const { + return _impl_.textargb_; +} +inline uint32_t PaymentBackground::textargb() const { + // @@protoc_insertion_point(field_get:proto.PaymentBackground.textArgb) + return _internal_textargb(); +} +inline void PaymentBackground::_internal_set_textargb(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.textargb_ = value; +} +inline void PaymentBackground::set_textargb(uint32_t value) { + _internal_set_textargb(value); + // @@protoc_insertion_point(field_set:proto.PaymentBackground.textArgb) +} + +// optional fixed32 subtextArgb = 8; +inline bool PaymentBackground::_internal_has_subtextargb() const { + bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool PaymentBackground::has_subtextargb() const { + return _internal_has_subtextargb(); +} +inline void PaymentBackground::clear_subtextargb() { + _impl_.subtextargb_ = 0u; + _impl_._has_bits_[0] &= ~0x00000100u; +} +inline uint32_t PaymentBackground::_internal_subtextargb() const { + return _impl_.subtextargb_; +} +inline uint32_t PaymentBackground::subtextargb() const { + // @@protoc_insertion_point(field_get:proto.PaymentBackground.subtextArgb) + return _internal_subtextargb(); +} +inline void PaymentBackground::_internal_set_subtextargb(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.subtextargb_ = value; +} +inline void PaymentBackground::set_subtextargb(uint32_t value) { + _internal_set_subtextargb(value); + // @@protoc_insertion_point(field_set:proto.PaymentBackground.subtextArgb) +} + +// optional .proto.PaymentBackground.MediaData mediaData = 9; +inline bool PaymentBackground::_internal_has_mediadata() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.mediadata_ != nullptr); + return value; +} +inline bool PaymentBackground::has_mediadata() const { + return _internal_has_mediadata(); +} +inline void PaymentBackground::clear_mediadata() { + if (_impl_.mediadata_ != nullptr) _impl_.mediadata_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::proto::PaymentBackground_MediaData& PaymentBackground::_internal_mediadata() const { + const ::proto::PaymentBackground_MediaData* p = _impl_.mediadata_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_PaymentBackground_MediaData_default_instance_); +} +inline const ::proto::PaymentBackground_MediaData& PaymentBackground::mediadata() const { + // @@protoc_insertion_point(field_get:proto.PaymentBackground.mediaData) + return _internal_mediadata(); +} +inline void PaymentBackground::unsafe_arena_set_allocated_mediadata( + ::proto::PaymentBackground_MediaData* mediadata) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.mediadata_); + } + _impl_.mediadata_ = mediadata; + if (mediadata) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.PaymentBackground.mediaData) +} +inline ::proto::PaymentBackground_MediaData* PaymentBackground::release_mediadata() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::PaymentBackground_MediaData* temp = _impl_.mediadata_; + _impl_.mediadata_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::PaymentBackground_MediaData* PaymentBackground::unsafe_arena_release_mediadata() { + // @@protoc_insertion_point(field_release:proto.PaymentBackground.mediaData) + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::PaymentBackground_MediaData* temp = _impl_.mediadata_; + _impl_.mediadata_ = nullptr; + return temp; +} +inline ::proto::PaymentBackground_MediaData* PaymentBackground::_internal_mutable_mediadata() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.mediadata_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::PaymentBackground_MediaData>(GetArenaForAllocation()); + _impl_.mediadata_ = p; + } + return _impl_.mediadata_; +} +inline ::proto::PaymentBackground_MediaData* PaymentBackground::mutable_mediadata() { + ::proto::PaymentBackground_MediaData* _msg = _internal_mutable_mediadata(); + // @@protoc_insertion_point(field_mutable:proto.PaymentBackground.mediaData) + return _msg; +} +inline void PaymentBackground::set_allocated_mediadata(::proto::PaymentBackground_MediaData* mediadata) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.mediadata_; + } + if (mediadata) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(mediadata); + if (message_arena != submessage_arena) { + mediadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, mediadata, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.mediadata_ = mediadata; + // @@protoc_insertion_point(field_set_allocated:proto.PaymentBackground.mediaData) +} + +// optional .proto.PaymentBackground.Type type = 10; +inline bool PaymentBackground::_internal_has_type() const { + bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool PaymentBackground::has_type() const { + return _internal_has_type(); +} +inline void PaymentBackground::clear_type() { + _impl_.type_ = 0; + _impl_._has_bits_[0] &= ~0x00000200u; +} +inline ::proto::PaymentBackground_Type PaymentBackground::_internal_type() const { + return static_cast< ::proto::PaymentBackground_Type >(_impl_.type_); +} +inline ::proto::PaymentBackground_Type PaymentBackground::type() const { + // @@protoc_insertion_point(field_get:proto.PaymentBackground.type) + return _internal_type(); +} +inline void PaymentBackground::_internal_set_type(::proto::PaymentBackground_Type value) { + assert(::proto::PaymentBackground_Type_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.type_ = value; +} +inline void PaymentBackground::set_type(::proto::PaymentBackground_Type value) { + _internal_set_type(value); + // @@protoc_insertion_point(field_set:proto.PaymentBackground.type) +} + +// ------------------------------------------------------------------- + +// PaymentInfo + +// optional .proto.PaymentInfo.Currency currencyDeprecated = 1; +inline bool PaymentInfo::_internal_has_currencydeprecated() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool PaymentInfo::has_currencydeprecated() const { + return _internal_has_currencydeprecated(); +} +inline void PaymentInfo::clear_currencydeprecated() { + _impl_.currencydeprecated_ = 0; + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline ::proto::PaymentInfo_Currency PaymentInfo::_internal_currencydeprecated() const { + return static_cast< ::proto::PaymentInfo_Currency >(_impl_.currencydeprecated_); +} +inline ::proto::PaymentInfo_Currency PaymentInfo::currencydeprecated() const { + // @@protoc_insertion_point(field_get:proto.PaymentInfo.currencyDeprecated) + return _internal_currencydeprecated(); +} +inline void PaymentInfo::_internal_set_currencydeprecated(::proto::PaymentInfo_Currency value) { + assert(::proto::PaymentInfo_Currency_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.currencydeprecated_ = value; +} +inline void PaymentInfo::set_currencydeprecated(::proto::PaymentInfo_Currency value) { + _internal_set_currencydeprecated(value); + // @@protoc_insertion_point(field_set:proto.PaymentInfo.currencyDeprecated) +} + +// optional uint64 amount1000 = 2; +inline bool PaymentInfo::_internal_has_amount1000() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool PaymentInfo::has_amount1000() const { + return _internal_has_amount1000(); +} +inline void PaymentInfo::clear_amount1000() { + _impl_.amount1000_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline uint64_t PaymentInfo::_internal_amount1000() const { + return _impl_.amount1000_; +} +inline uint64_t PaymentInfo::amount1000() const { + // @@protoc_insertion_point(field_get:proto.PaymentInfo.amount1000) + return _internal_amount1000(); +} +inline void PaymentInfo::_internal_set_amount1000(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.amount1000_ = value; +} +inline void PaymentInfo::set_amount1000(uint64_t value) { + _internal_set_amount1000(value); + // @@protoc_insertion_point(field_set:proto.PaymentInfo.amount1000) +} + +// optional string receiverJid = 3; +inline bool PaymentInfo::_internal_has_receiverjid() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool PaymentInfo::has_receiverjid() const { + return _internal_has_receiverjid(); +} +inline void PaymentInfo::clear_receiverjid() { + _impl_.receiverjid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& PaymentInfo::receiverjid() const { + // @@protoc_insertion_point(field_get:proto.PaymentInfo.receiverJid) + return _internal_receiverjid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void PaymentInfo::set_receiverjid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.receiverjid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.PaymentInfo.receiverJid) +} +inline std::string* PaymentInfo::mutable_receiverjid() { + std::string* _s = _internal_mutable_receiverjid(); + // @@protoc_insertion_point(field_mutable:proto.PaymentInfo.receiverJid) + return _s; +} +inline const std::string& PaymentInfo::_internal_receiverjid() const { + return _impl_.receiverjid_.Get(); +} +inline void PaymentInfo::_internal_set_receiverjid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.receiverjid_.Set(value, GetArenaForAllocation()); +} +inline std::string* PaymentInfo::_internal_mutable_receiverjid() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.receiverjid_.Mutable(GetArenaForAllocation()); +} +inline std::string* PaymentInfo::release_receiverjid() { + // @@protoc_insertion_point(field_release:proto.PaymentInfo.receiverJid) + if (!_internal_has_receiverjid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.receiverjid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.receiverjid_.IsDefault()) { + _impl_.receiverjid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void PaymentInfo::set_allocated_receiverjid(std::string* receiverjid) { + if (receiverjid != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.receiverjid_.SetAllocated(receiverjid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.receiverjid_.IsDefault()) { + _impl_.receiverjid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.PaymentInfo.receiverJid) +} + +// optional .proto.PaymentInfo.Status status = 4; +inline bool PaymentInfo::_internal_has_status() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool PaymentInfo::has_status() const { + return _internal_has_status(); +} +inline void PaymentInfo::clear_status() { + _impl_.status_ = 0; + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline ::proto::PaymentInfo_Status PaymentInfo::_internal_status() const { + return static_cast< ::proto::PaymentInfo_Status >(_impl_.status_); +} +inline ::proto::PaymentInfo_Status PaymentInfo::status() const { + // @@protoc_insertion_point(field_get:proto.PaymentInfo.status) + return _internal_status(); +} +inline void PaymentInfo::_internal_set_status(::proto::PaymentInfo_Status value) { + assert(::proto::PaymentInfo_Status_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.status_ = value; +} +inline void PaymentInfo::set_status(::proto::PaymentInfo_Status value) { + _internal_set_status(value); + // @@protoc_insertion_point(field_set:proto.PaymentInfo.status) +} + +// optional uint64 transactionTimestamp = 5; +inline bool PaymentInfo::_internal_has_transactiontimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool PaymentInfo::has_transactiontimestamp() const { + return _internal_has_transactiontimestamp(); +} +inline void PaymentInfo::clear_transactiontimestamp() { + _impl_.transactiontimestamp_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000100u; +} +inline uint64_t PaymentInfo::_internal_transactiontimestamp() const { + return _impl_.transactiontimestamp_; +} +inline uint64_t PaymentInfo::transactiontimestamp() const { + // @@protoc_insertion_point(field_get:proto.PaymentInfo.transactionTimestamp) + return _internal_transactiontimestamp(); +} +inline void PaymentInfo::_internal_set_transactiontimestamp(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.transactiontimestamp_ = value; +} +inline void PaymentInfo::set_transactiontimestamp(uint64_t value) { + _internal_set_transactiontimestamp(value); + // @@protoc_insertion_point(field_set:proto.PaymentInfo.transactionTimestamp) +} + +// optional .proto.MessageKey requestMessageKey = 6; +inline bool PaymentInfo::_internal_has_requestmessagekey() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.requestmessagekey_ != nullptr); + return value; +} +inline bool PaymentInfo::has_requestmessagekey() const { + return _internal_has_requestmessagekey(); +} +inline void PaymentInfo::clear_requestmessagekey() { + if (_impl_.requestmessagekey_ != nullptr) _impl_.requestmessagekey_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::proto::MessageKey& PaymentInfo::_internal_requestmessagekey() const { + const ::proto::MessageKey* p = _impl_.requestmessagekey_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_MessageKey_default_instance_); +} +inline const ::proto::MessageKey& PaymentInfo::requestmessagekey() const { + // @@protoc_insertion_point(field_get:proto.PaymentInfo.requestMessageKey) + return _internal_requestmessagekey(); +} +inline void PaymentInfo::unsafe_arena_set_allocated_requestmessagekey( + ::proto::MessageKey* requestmessagekey) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.requestmessagekey_); + } + _impl_.requestmessagekey_ = requestmessagekey; + if (requestmessagekey) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.PaymentInfo.requestMessageKey) +} +inline ::proto::MessageKey* PaymentInfo::release_requestmessagekey() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::MessageKey* temp = _impl_.requestmessagekey_; + _impl_.requestmessagekey_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::MessageKey* PaymentInfo::unsafe_arena_release_requestmessagekey() { + // @@protoc_insertion_point(field_release:proto.PaymentInfo.requestMessageKey) + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::MessageKey* temp = _impl_.requestmessagekey_; + _impl_.requestmessagekey_ = nullptr; + return temp; +} +inline ::proto::MessageKey* PaymentInfo::_internal_mutable_requestmessagekey() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.requestmessagekey_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation()); + _impl_.requestmessagekey_ = p; + } + return _impl_.requestmessagekey_; +} +inline ::proto::MessageKey* PaymentInfo::mutable_requestmessagekey() { + ::proto::MessageKey* _msg = _internal_mutable_requestmessagekey(); + // @@protoc_insertion_point(field_mutable:proto.PaymentInfo.requestMessageKey) + return _msg; +} +inline void PaymentInfo::set_allocated_requestmessagekey(::proto::MessageKey* requestmessagekey) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.requestmessagekey_; + } + if (requestmessagekey) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(requestmessagekey); + if (message_arena != submessage_arena) { + requestmessagekey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, requestmessagekey, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.requestmessagekey_ = requestmessagekey; + // @@protoc_insertion_point(field_set_allocated:proto.PaymentInfo.requestMessageKey) +} + +// optional uint64 expiryTimestamp = 7; +inline bool PaymentInfo::_internal_has_expirytimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool PaymentInfo::has_expirytimestamp() const { + return _internal_has_expirytimestamp(); +} +inline void PaymentInfo::clear_expirytimestamp() { + _impl_.expirytimestamp_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000200u; +} +inline uint64_t PaymentInfo::_internal_expirytimestamp() const { + return _impl_.expirytimestamp_; +} +inline uint64_t PaymentInfo::expirytimestamp() const { + // @@protoc_insertion_point(field_get:proto.PaymentInfo.expiryTimestamp) + return _internal_expirytimestamp(); +} +inline void PaymentInfo::_internal_set_expirytimestamp(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.expirytimestamp_ = value; +} +inline void PaymentInfo::set_expirytimestamp(uint64_t value) { + _internal_set_expirytimestamp(value); + // @@protoc_insertion_point(field_set:proto.PaymentInfo.expiryTimestamp) +} + +// optional bool futureproofed = 8; +inline bool PaymentInfo::_internal_has_futureproofed() const { + bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool PaymentInfo::has_futureproofed() const { + return _internal_has_futureproofed(); +} +inline void PaymentInfo::clear_futureproofed() { + _impl_.futureproofed_ = false; + _impl_._has_bits_[0] &= ~0x00000400u; +} +inline bool PaymentInfo::_internal_futureproofed() const { + return _impl_.futureproofed_; +} +inline bool PaymentInfo::futureproofed() const { + // @@protoc_insertion_point(field_get:proto.PaymentInfo.futureproofed) + return _internal_futureproofed(); +} +inline void PaymentInfo::_internal_set_futureproofed(bool value) { + _impl_._has_bits_[0] |= 0x00000400u; + _impl_.futureproofed_ = value; +} +inline void PaymentInfo::set_futureproofed(bool value) { + _internal_set_futureproofed(value); + // @@protoc_insertion_point(field_set:proto.PaymentInfo.futureproofed) +} + +// optional string currency = 9; +inline bool PaymentInfo::_internal_has_currency() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool PaymentInfo::has_currency() const { + return _internal_has_currency(); +} +inline void PaymentInfo::clear_currency() { + _impl_.currency_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& PaymentInfo::currency() const { + // @@protoc_insertion_point(field_get:proto.PaymentInfo.currency) + return _internal_currency(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void PaymentInfo::set_currency(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.currency_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.PaymentInfo.currency) +} +inline std::string* PaymentInfo::mutable_currency() { + std::string* _s = _internal_mutable_currency(); + // @@protoc_insertion_point(field_mutable:proto.PaymentInfo.currency) + return _s; +} +inline const std::string& PaymentInfo::_internal_currency() const { + return _impl_.currency_.Get(); +} +inline void PaymentInfo::_internal_set_currency(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.currency_.Set(value, GetArenaForAllocation()); +} +inline std::string* PaymentInfo::_internal_mutable_currency() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.currency_.Mutable(GetArenaForAllocation()); +} +inline std::string* PaymentInfo::release_currency() { + // @@protoc_insertion_point(field_release:proto.PaymentInfo.currency) + if (!_internal_has_currency()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.currency_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.currency_.IsDefault()) { + _impl_.currency_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void PaymentInfo::set_allocated_currency(std::string* currency) { + if (currency != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.currency_.SetAllocated(currency, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.currency_.IsDefault()) { + _impl_.currency_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.PaymentInfo.currency) +} + +// optional .proto.PaymentInfo.TxnStatus txnStatus = 10; +inline bool PaymentInfo::_internal_has_txnstatus() const { + bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; + return value; +} +inline bool PaymentInfo::has_txnstatus() const { + return _internal_has_txnstatus(); +} +inline void PaymentInfo::clear_txnstatus() { + _impl_.txnstatus_ = 0; + _impl_._has_bits_[0] &= ~0x00001000u; +} +inline ::proto::PaymentInfo_TxnStatus PaymentInfo::_internal_txnstatus() const { + return static_cast< ::proto::PaymentInfo_TxnStatus >(_impl_.txnstatus_); +} +inline ::proto::PaymentInfo_TxnStatus PaymentInfo::txnstatus() const { + // @@protoc_insertion_point(field_get:proto.PaymentInfo.txnStatus) + return _internal_txnstatus(); +} +inline void PaymentInfo::_internal_set_txnstatus(::proto::PaymentInfo_TxnStatus value) { + assert(::proto::PaymentInfo_TxnStatus_IsValid(value)); + _impl_._has_bits_[0] |= 0x00001000u; + _impl_.txnstatus_ = value; +} +inline void PaymentInfo::set_txnstatus(::proto::PaymentInfo_TxnStatus value) { + _internal_set_txnstatus(value); + // @@protoc_insertion_point(field_set:proto.PaymentInfo.txnStatus) +} + +// optional bool useNoviFiatFormat = 11; +inline bool PaymentInfo::_internal_has_usenovifiatformat() const { + bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; + return value; +} +inline bool PaymentInfo::has_usenovifiatformat() const { + return _internal_has_usenovifiatformat(); +} +inline void PaymentInfo::clear_usenovifiatformat() { + _impl_.usenovifiatformat_ = false; + _impl_._has_bits_[0] &= ~0x00000800u; +} +inline bool PaymentInfo::_internal_usenovifiatformat() const { + return _impl_.usenovifiatformat_; +} +inline bool PaymentInfo::usenovifiatformat() const { + // @@protoc_insertion_point(field_get:proto.PaymentInfo.useNoviFiatFormat) + return _internal_usenovifiatformat(); +} +inline void PaymentInfo::_internal_set_usenovifiatformat(bool value) { + _impl_._has_bits_[0] |= 0x00000800u; + _impl_.usenovifiatformat_ = value; +} +inline void PaymentInfo::set_usenovifiatformat(bool value) { + _internal_set_usenovifiatformat(value); + // @@protoc_insertion_point(field_set:proto.PaymentInfo.useNoviFiatFormat) +} + +// optional .proto.Money primaryAmount = 12; +inline bool PaymentInfo::_internal_has_primaryamount() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || _impl_.primaryamount_ != nullptr); + return value; +} +inline bool PaymentInfo::has_primaryamount() const { + return _internal_has_primaryamount(); +} +inline void PaymentInfo::clear_primaryamount() { + if (_impl_.primaryamount_ != nullptr) _impl_.primaryamount_->Clear(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const ::proto::Money& PaymentInfo::_internal_primaryamount() const { + const ::proto::Money* p = _impl_.primaryamount_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Money_default_instance_); +} +inline const ::proto::Money& PaymentInfo::primaryamount() const { + // @@protoc_insertion_point(field_get:proto.PaymentInfo.primaryAmount) + return _internal_primaryamount(); +} +inline void PaymentInfo::unsafe_arena_set_allocated_primaryamount( + ::proto::Money* primaryamount) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.primaryamount_); + } + _impl_.primaryamount_ = primaryamount; + if (primaryamount) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.PaymentInfo.primaryAmount) +} +inline ::proto::Money* PaymentInfo::release_primaryamount() { + _impl_._has_bits_[0] &= ~0x00000008u; + ::proto::Money* temp = _impl_.primaryamount_; + _impl_.primaryamount_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Money* PaymentInfo::unsafe_arena_release_primaryamount() { + // @@protoc_insertion_point(field_release:proto.PaymentInfo.primaryAmount) + _impl_._has_bits_[0] &= ~0x00000008u; + ::proto::Money* temp = _impl_.primaryamount_; + _impl_.primaryamount_ = nullptr; + return temp; +} +inline ::proto::Money* PaymentInfo::_internal_mutable_primaryamount() { + _impl_._has_bits_[0] |= 0x00000008u; + if (_impl_.primaryamount_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Money>(GetArenaForAllocation()); + _impl_.primaryamount_ = p; + } + return _impl_.primaryamount_; +} +inline ::proto::Money* PaymentInfo::mutable_primaryamount() { + ::proto::Money* _msg = _internal_mutable_primaryamount(); + // @@protoc_insertion_point(field_mutable:proto.PaymentInfo.primaryAmount) + return _msg; +} +inline void PaymentInfo::set_allocated_primaryamount(::proto::Money* primaryamount) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.primaryamount_; + } + if (primaryamount) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(primaryamount); + if (message_arena != submessage_arena) { + primaryamount = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, primaryamount, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.primaryamount_ = primaryamount; + // @@protoc_insertion_point(field_set_allocated:proto.PaymentInfo.primaryAmount) +} + +// optional .proto.Money exchangeAmount = 13; +inline bool PaymentInfo::_internal_has_exchangeamount() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + PROTOBUF_ASSUME(!value || _impl_.exchangeamount_ != nullptr); + return value; +} +inline bool PaymentInfo::has_exchangeamount() const { + return _internal_has_exchangeamount(); +} +inline void PaymentInfo::clear_exchangeamount() { + if (_impl_.exchangeamount_ != nullptr) _impl_.exchangeamount_->Clear(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const ::proto::Money& PaymentInfo::_internal_exchangeamount() const { + const ::proto::Money* p = _impl_.exchangeamount_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Money_default_instance_); +} +inline const ::proto::Money& PaymentInfo::exchangeamount() const { + // @@protoc_insertion_point(field_get:proto.PaymentInfo.exchangeAmount) + return _internal_exchangeamount(); +} +inline void PaymentInfo::unsafe_arena_set_allocated_exchangeamount( + ::proto::Money* exchangeamount) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.exchangeamount_); + } + _impl_.exchangeamount_ = exchangeamount; + if (exchangeamount) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.PaymentInfo.exchangeAmount) +} +inline ::proto::Money* PaymentInfo::release_exchangeamount() { + _impl_._has_bits_[0] &= ~0x00000010u; + ::proto::Money* temp = _impl_.exchangeamount_; + _impl_.exchangeamount_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Money* PaymentInfo::unsafe_arena_release_exchangeamount() { + // @@protoc_insertion_point(field_release:proto.PaymentInfo.exchangeAmount) + _impl_._has_bits_[0] &= ~0x00000010u; + ::proto::Money* temp = _impl_.exchangeamount_; + _impl_.exchangeamount_ = nullptr; + return temp; +} +inline ::proto::Money* PaymentInfo::_internal_mutable_exchangeamount() { + _impl_._has_bits_[0] |= 0x00000010u; + if (_impl_.exchangeamount_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Money>(GetArenaForAllocation()); + _impl_.exchangeamount_ = p; + } + return _impl_.exchangeamount_; +} +inline ::proto::Money* PaymentInfo::mutable_exchangeamount() { + ::proto::Money* _msg = _internal_mutable_exchangeamount(); + // @@protoc_insertion_point(field_mutable:proto.PaymentInfo.exchangeAmount) + return _msg; +} +inline void PaymentInfo::set_allocated_exchangeamount(::proto::Money* exchangeamount) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.exchangeamount_; + } + if (exchangeamount) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(exchangeamount); + if (message_arena != submessage_arena) { + exchangeamount = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, exchangeamount, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.exchangeamount_ = exchangeamount; + // @@protoc_insertion_point(field_set_allocated:proto.PaymentInfo.exchangeAmount) +} + +// ------------------------------------------------------------------- + +// PendingKeyExchange + +// optional uint32 sequence = 1; +inline bool PendingKeyExchange::_internal_has_sequence() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool PendingKeyExchange::has_sequence() const { + return _internal_has_sequence(); +} +inline void PendingKeyExchange::clear_sequence() { + _impl_.sequence_ = 0u; + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline uint32_t PendingKeyExchange::_internal_sequence() const { + return _impl_.sequence_; +} +inline uint32_t PendingKeyExchange::sequence() const { + // @@protoc_insertion_point(field_get:proto.PendingKeyExchange.sequence) + return _internal_sequence(); +} +inline void PendingKeyExchange::_internal_set_sequence(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.sequence_ = value; +} +inline void PendingKeyExchange::set_sequence(uint32_t value) { + _internal_set_sequence(value); + // @@protoc_insertion_point(field_set:proto.PendingKeyExchange.sequence) +} + +// optional bytes localBaseKey = 2; +inline bool PendingKeyExchange::_internal_has_localbasekey() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool PendingKeyExchange::has_localbasekey() const { + return _internal_has_localbasekey(); +} +inline void PendingKeyExchange::clear_localbasekey() { + _impl_.localbasekey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& PendingKeyExchange::localbasekey() const { + // @@protoc_insertion_point(field_get:proto.PendingKeyExchange.localBaseKey) + return _internal_localbasekey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void PendingKeyExchange::set_localbasekey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.localbasekey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.PendingKeyExchange.localBaseKey) +} +inline std::string* PendingKeyExchange::mutable_localbasekey() { + std::string* _s = _internal_mutable_localbasekey(); + // @@protoc_insertion_point(field_mutable:proto.PendingKeyExchange.localBaseKey) + return _s; +} +inline const std::string& PendingKeyExchange::_internal_localbasekey() const { + return _impl_.localbasekey_.Get(); +} +inline void PendingKeyExchange::_internal_set_localbasekey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.localbasekey_.Set(value, GetArenaForAllocation()); +} +inline std::string* PendingKeyExchange::_internal_mutable_localbasekey() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.localbasekey_.Mutable(GetArenaForAllocation()); +} +inline std::string* PendingKeyExchange::release_localbasekey() { + // @@protoc_insertion_point(field_release:proto.PendingKeyExchange.localBaseKey) + if (!_internal_has_localbasekey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.localbasekey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.localbasekey_.IsDefault()) { + _impl_.localbasekey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void PendingKeyExchange::set_allocated_localbasekey(std::string* localbasekey) { + if (localbasekey != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.localbasekey_.SetAllocated(localbasekey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.localbasekey_.IsDefault()) { + _impl_.localbasekey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.PendingKeyExchange.localBaseKey) +} + +// optional bytes localBaseKeyPrivate = 3; +inline bool PendingKeyExchange::_internal_has_localbasekeyprivate() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool PendingKeyExchange::has_localbasekeyprivate() const { + return _internal_has_localbasekeyprivate(); +} +inline void PendingKeyExchange::clear_localbasekeyprivate() { + _impl_.localbasekeyprivate_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& PendingKeyExchange::localbasekeyprivate() const { + // @@protoc_insertion_point(field_get:proto.PendingKeyExchange.localBaseKeyPrivate) + return _internal_localbasekeyprivate(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void PendingKeyExchange::set_localbasekeyprivate(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.localbasekeyprivate_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.PendingKeyExchange.localBaseKeyPrivate) +} +inline std::string* PendingKeyExchange::mutable_localbasekeyprivate() { + std::string* _s = _internal_mutable_localbasekeyprivate(); + // @@protoc_insertion_point(field_mutable:proto.PendingKeyExchange.localBaseKeyPrivate) + return _s; +} +inline const std::string& PendingKeyExchange::_internal_localbasekeyprivate() const { + return _impl_.localbasekeyprivate_.Get(); +} +inline void PendingKeyExchange::_internal_set_localbasekeyprivate(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.localbasekeyprivate_.Set(value, GetArenaForAllocation()); +} +inline std::string* PendingKeyExchange::_internal_mutable_localbasekeyprivate() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.localbasekeyprivate_.Mutable(GetArenaForAllocation()); +} +inline std::string* PendingKeyExchange::release_localbasekeyprivate() { + // @@protoc_insertion_point(field_release:proto.PendingKeyExchange.localBaseKeyPrivate) + if (!_internal_has_localbasekeyprivate()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.localbasekeyprivate_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.localbasekeyprivate_.IsDefault()) { + _impl_.localbasekeyprivate_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void PendingKeyExchange::set_allocated_localbasekeyprivate(std::string* localbasekeyprivate) { + if (localbasekeyprivate != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.localbasekeyprivate_.SetAllocated(localbasekeyprivate, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.localbasekeyprivate_.IsDefault()) { + _impl_.localbasekeyprivate_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.PendingKeyExchange.localBaseKeyPrivate) +} + +// optional bytes localRatchetKey = 4; +inline bool PendingKeyExchange::_internal_has_localratchetkey() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool PendingKeyExchange::has_localratchetkey() const { + return _internal_has_localratchetkey(); +} +inline void PendingKeyExchange::clear_localratchetkey() { + _impl_.localratchetkey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& PendingKeyExchange::localratchetkey() const { + // @@protoc_insertion_point(field_get:proto.PendingKeyExchange.localRatchetKey) + return _internal_localratchetkey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void PendingKeyExchange::set_localratchetkey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.localratchetkey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.PendingKeyExchange.localRatchetKey) +} +inline std::string* PendingKeyExchange::mutable_localratchetkey() { + std::string* _s = _internal_mutable_localratchetkey(); + // @@protoc_insertion_point(field_mutable:proto.PendingKeyExchange.localRatchetKey) + return _s; +} +inline const std::string& PendingKeyExchange::_internal_localratchetkey() const { + return _impl_.localratchetkey_.Get(); +} +inline void PendingKeyExchange::_internal_set_localratchetkey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.localratchetkey_.Set(value, GetArenaForAllocation()); +} +inline std::string* PendingKeyExchange::_internal_mutable_localratchetkey() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.localratchetkey_.Mutable(GetArenaForAllocation()); +} +inline std::string* PendingKeyExchange::release_localratchetkey() { + // @@protoc_insertion_point(field_release:proto.PendingKeyExchange.localRatchetKey) + if (!_internal_has_localratchetkey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.localratchetkey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.localratchetkey_.IsDefault()) { + _impl_.localratchetkey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void PendingKeyExchange::set_allocated_localratchetkey(std::string* localratchetkey) { + if (localratchetkey != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.localratchetkey_.SetAllocated(localratchetkey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.localratchetkey_.IsDefault()) { + _impl_.localratchetkey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.PendingKeyExchange.localRatchetKey) +} + +// optional bytes localRatchetKeyPrivate = 5; +inline bool PendingKeyExchange::_internal_has_localratchetkeyprivate() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool PendingKeyExchange::has_localratchetkeyprivate() const { + return _internal_has_localratchetkeyprivate(); +} +inline void PendingKeyExchange::clear_localratchetkeyprivate() { + _impl_.localratchetkeyprivate_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const std::string& PendingKeyExchange::localratchetkeyprivate() const { + // @@protoc_insertion_point(field_get:proto.PendingKeyExchange.localRatchetKeyPrivate) + return _internal_localratchetkeyprivate(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void PendingKeyExchange::set_localratchetkeyprivate(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.localratchetkeyprivate_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.PendingKeyExchange.localRatchetKeyPrivate) +} +inline std::string* PendingKeyExchange::mutable_localratchetkeyprivate() { + std::string* _s = _internal_mutable_localratchetkeyprivate(); + // @@protoc_insertion_point(field_mutable:proto.PendingKeyExchange.localRatchetKeyPrivate) + return _s; +} +inline const std::string& PendingKeyExchange::_internal_localratchetkeyprivate() const { + return _impl_.localratchetkeyprivate_.Get(); +} +inline void PendingKeyExchange::_internal_set_localratchetkeyprivate(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.localratchetkeyprivate_.Set(value, GetArenaForAllocation()); +} +inline std::string* PendingKeyExchange::_internal_mutable_localratchetkeyprivate() { + _impl_._has_bits_[0] |= 0x00000008u; + return _impl_.localratchetkeyprivate_.Mutable(GetArenaForAllocation()); +} +inline std::string* PendingKeyExchange::release_localratchetkeyprivate() { + // @@protoc_insertion_point(field_release:proto.PendingKeyExchange.localRatchetKeyPrivate) + if (!_internal_has_localratchetkeyprivate()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000008u; + auto* p = _impl_.localratchetkeyprivate_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.localratchetkeyprivate_.IsDefault()) { + _impl_.localratchetkeyprivate_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void PendingKeyExchange::set_allocated_localratchetkeyprivate(std::string* localratchetkeyprivate) { + if (localratchetkeyprivate != nullptr) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.localratchetkeyprivate_.SetAllocated(localratchetkeyprivate, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.localratchetkeyprivate_.IsDefault()) { + _impl_.localratchetkeyprivate_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.PendingKeyExchange.localRatchetKeyPrivate) +} + +// optional bytes localIdentityKey = 7; +inline bool PendingKeyExchange::_internal_has_localidentitykey() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool PendingKeyExchange::has_localidentitykey() const { + return _internal_has_localidentitykey(); +} +inline void PendingKeyExchange::clear_localidentitykey() { + _impl_.localidentitykey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const std::string& PendingKeyExchange::localidentitykey() const { + // @@protoc_insertion_point(field_get:proto.PendingKeyExchange.localIdentityKey) + return _internal_localidentitykey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void PendingKeyExchange::set_localidentitykey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.localidentitykey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.PendingKeyExchange.localIdentityKey) +} +inline std::string* PendingKeyExchange::mutable_localidentitykey() { + std::string* _s = _internal_mutable_localidentitykey(); + // @@protoc_insertion_point(field_mutable:proto.PendingKeyExchange.localIdentityKey) + return _s; +} +inline const std::string& PendingKeyExchange::_internal_localidentitykey() const { + return _impl_.localidentitykey_.Get(); +} +inline void PendingKeyExchange::_internal_set_localidentitykey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.localidentitykey_.Set(value, GetArenaForAllocation()); +} +inline std::string* PendingKeyExchange::_internal_mutable_localidentitykey() { + _impl_._has_bits_[0] |= 0x00000010u; + return _impl_.localidentitykey_.Mutable(GetArenaForAllocation()); +} +inline std::string* PendingKeyExchange::release_localidentitykey() { + // @@protoc_insertion_point(field_release:proto.PendingKeyExchange.localIdentityKey) + if (!_internal_has_localidentitykey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000010u; + auto* p = _impl_.localidentitykey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.localidentitykey_.IsDefault()) { + _impl_.localidentitykey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void PendingKeyExchange::set_allocated_localidentitykey(std::string* localidentitykey) { + if (localidentitykey != nullptr) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.localidentitykey_.SetAllocated(localidentitykey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.localidentitykey_.IsDefault()) { + _impl_.localidentitykey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.PendingKeyExchange.localIdentityKey) +} + +// optional bytes localIdentityKeyPrivate = 8; +inline bool PendingKeyExchange::_internal_has_localidentitykeyprivate() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool PendingKeyExchange::has_localidentitykeyprivate() const { + return _internal_has_localidentitykeyprivate(); +} +inline void PendingKeyExchange::clear_localidentitykeyprivate() { + _impl_.localidentitykeyprivate_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline const std::string& PendingKeyExchange::localidentitykeyprivate() const { + // @@protoc_insertion_point(field_get:proto.PendingKeyExchange.localIdentityKeyPrivate) + return _internal_localidentitykeyprivate(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void PendingKeyExchange::set_localidentitykeyprivate(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.localidentitykeyprivate_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.PendingKeyExchange.localIdentityKeyPrivate) +} +inline std::string* PendingKeyExchange::mutable_localidentitykeyprivate() { + std::string* _s = _internal_mutable_localidentitykeyprivate(); + // @@protoc_insertion_point(field_mutable:proto.PendingKeyExchange.localIdentityKeyPrivate) + return _s; +} +inline const std::string& PendingKeyExchange::_internal_localidentitykeyprivate() const { + return _impl_.localidentitykeyprivate_.Get(); +} +inline void PendingKeyExchange::_internal_set_localidentitykeyprivate(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.localidentitykeyprivate_.Set(value, GetArenaForAllocation()); +} +inline std::string* PendingKeyExchange::_internal_mutable_localidentitykeyprivate() { + _impl_._has_bits_[0] |= 0x00000020u; + return _impl_.localidentitykeyprivate_.Mutable(GetArenaForAllocation()); +} +inline std::string* PendingKeyExchange::release_localidentitykeyprivate() { + // @@protoc_insertion_point(field_release:proto.PendingKeyExchange.localIdentityKeyPrivate) + if (!_internal_has_localidentitykeyprivate()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000020u; + auto* p = _impl_.localidentitykeyprivate_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.localidentitykeyprivate_.IsDefault()) { + _impl_.localidentitykeyprivate_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void PendingKeyExchange::set_allocated_localidentitykeyprivate(std::string* localidentitykeyprivate) { + if (localidentitykeyprivate != nullptr) { + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + _impl_.localidentitykeyprivate_.SetAllocated(localidentitykeyprivate, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.localidentitykeyprivate_.IsDefault()) { + _impl_.localidentitykeyprivate_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.PendingKeyExchange.localIdentityKeyPrivate) +} + +// ------------------------------------------------------------------- + +// PendingPreKey + +// optional uint32 preKeyId = 1; +inline bool PendingPreKey::_internal_has_prekeyid() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool PendingPreKey::has_prekeyid() const { + return _internal_has_prekeyid(); +} +inline void PendingPreKey::clear_prekeyid() { + _impl_.prekeyid_ = 0u; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline uint32_t PendingPreKey::_internal_prekeyid() const { + return _impl_.prekeyid_; +} +inline uint32_t PendingPreKey::prekeyid() const { + // @@protoc_insertion_point(field_get:proto.PendingPreKey.preKeyId) + return _internal_prekeyid(); +} +inline void PendingPreKey::_internal_set_prekeyid(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.prekeyid_ = value; +} +inline void PendingPreKey::set_prekeyid(uint32_t value) { + _internal_set_prekeyid(value); + // @@protoc_insertion_point(field_set:proto.PendingPreKey.preKeyId) +} + +// optional int32 signedPreKeyId = 3; +inline bool PendingPreKey::_internal_has_signedprekeyid() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool PendingPreKey::has_signedprekeyid() const { + return _internal_has_signedprekeyid(); +} +inline void PendingPreKey::clear_signedprekeyid() { + _impl_.signedprekeyid_ = 0; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline int32_t PendingPreKey::_internal_signedprekeyid() const { + return _impl_.signedprekeyid_; +} +inline int32_t PendingPreKey::signedprekeyid() const { + // @@protoc_insertion_point(field_get:proto.PendingPreKey.signedPreKeyId) + return _internal_signedprekeyid(); +} +inline void PendingPreKey::_internal_set_signedprekeyid(int32_t value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.signedprekeyid_ = value; +} +inline void PendingPreKey::set_signedprekeyid(int32_t value) { + _internal_set_signedprekeyid(value); + // @@protoc_insertion_point(field_set:proto.PendingPreKey.signedPreKeyId) +} + +// optional bytes baseKey = 2; +inline bool PendingPreKey::_internal_has_basekey() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool PendingPreKey::has_basekey() const { + return _internal_has_basekey(); +} +inline void PendingPreKey::clear_basekey() { + _impl_.basekey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& PendingPreKey::basekey() const { + // @@protoc_insertion_point(field_get:proto.PendingPreKey.baseKey) + return _internal_basekey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void PendingPreKey::set_basekey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.basekey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.PendingPreKey.baseKey) +} +inline std::string* PendingPreKey::mutable_basekey() { + std::string* _s = _internal_mutable_basekey(); + // @@protoc_insertion_point(field_mutable:proto.PendingPreKey.baseKey) + return _s; +} +inline const std::string& PendingPreKey::_internal_basekey() const { + return _impl_.basekey_.Get(); +} +inline void PendingPreKey::_internal_set_basekey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.basekey_.Set(value, GetArenaForAllocation()); +} +inline std::string* PendingPreKey::_internal_mutable_basekey() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.basekey_.Mutable(GetArenaForAllocation()); +} +inline std::string* PendingPreKey::release_basekey() { + // @@protoc_insertion_point(field_release:proto.PendingPreKey.baseKey) + if (!_internal_has_basekey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.basekey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.basekey_.IsDefault()) { + _impl_.basekey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void PendingPreKey::set_allocated_basekey(std::string* basekey) { + if (basekey != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.basekey_.SetAllocated(basekey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.basekey_.IsDefault()) { + _impl_.basekey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.PendingPreKey.baseKey) +} + +// ------------------------------------------------------------------- + +// PhotoChange + +// optional bytes oldPhoto = 1; +inline bool PhotoChange::_internal_has_oldphoto() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool PhotoChange::has_oldphoto() const { + return _internal_has_oldphoto(); +} +inline void PhotoChange::clear_oldphoto() { + _impl_.oldphoto_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& PhotoChange::oldphoto() const { + // @@protoc_insertion_point(field_get:proto.PhotoChange.oldPhoto) + return _internal_oldphoto(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void PhotoChange::set_oldphoto(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.oldphoto_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.PhotoChange.oldPhoto) +} +inline std::string* PhotoChange::mutable_oldphoto() { + std::string* _s = _internal_mutable_oldphoto(); + // @@protoc_insertion_point(field_mutable:proto.PhotoChange.oldPhoto) + return _s; +} +inline const std::string& PhotoChange::_internal_oldphoto() const { + return _impl_.oldphoto_.Get(); +} +inline void PhotoChange::_internal_set_oldphoto(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.oldphoto_.Set(value, GetArenaForAllocation()); +} +inline std::string* PhotoChange::_internal_mutable_oldphoto() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.oldphoto_.Mutable(GetArenaForAllocation()); +} +inline std::string* PhotoChange::release_oldphoto() { + // @@protoc_insertion_point(field_release:proto.PhotoChange.oldPhoto) + if (!_internal_has_oldphoto()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.oldphoto_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.oldphoto_.IsDefault()) { + _impl_.oldphoto_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void PhotoChange::set_allocated_oldphoto(std::string* oldphoto) { + if (oldphoto != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.oldphoto_.SetAllocated(oldphoto, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.oldphoto_.IsDefault()) { + _impl_.oldphoto_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.PhotoChange.oldPhoto) +} + +// optional bytes newPhoto = 2; +inline bool PhotoChange::_internal_has_newphoto() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool PhotoChange::has_newphoto() const { + return _internal_has_newphoto(); +} +inline void PhotoChange::clear_newphoto() { + _impl_.newphoto_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& PhotoChange::newphoto() const { + // @@protoc_insertion_point(field_get:proto.PhotoChange.newPhoto) + return _internal_newphoto(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void PhotoChange::set_newphoto(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.newphoto_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.PhotoChange.newPhoto) +} +inline std::string* PhotoChange::mutable_newphoto() { + std::string* _s = _internal_mutable_newphoto(); + // @@protoc_insertion_point(field_mutable:proto.PhotoChange.newPhoto) + return _s; +} +inline const std::string& PhotoChange::_internal_newphoto() const { + return _impl_.newphoto_.Get(); +} +inline void PhotoChange::_internal_set_newphoto(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.newphoto_.Set(value, GetArenaForAllocation()); +} +inline std::string* PhotoChange::_internal_mutable_newphoto() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.newphoto_.Mutable(GetArenaForAllocation()); +} +inline std::string* PhotoChange::release_newphoto() { + // @@protoc_insertion_point(field_release:proto.PhotoChange.newPhoto) + if (!_internal_has_newphoto()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.newphoto_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.newphoto_.IsDefault()) { + _impl_.newphoto_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void PhotoChange::set_allocated_newphoto(std::string* newphoto) { + if (newphoto != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.newphoto_.SetAllocated(newphoto, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.newphoto_.IsDefault()) { + _impl_.newphoto_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.PhotoChange.newPhoto) +} + +// optional uint32 newPhotoId = 3; +inline bool PhotoChange::_internal_has_newphotoid() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool PhotoChange::has_newphotoid() const { + return _internal_has_newphotoid(); +} +inline void PhotoChange::clear_newphotoid() { + _impl_.newphotoid_ = 0u; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline uint32_t PhotoChange::_internal_newphotoid() const { + return _impl_.newphotoid_; +} +inline uint32_t PhotoChange::newphotoid() const { + // @@protoc_insertion_point(field_get:proto.PhotoChange.newPhotoId) + return _internal_newphotoid(); +} +inline void PhotoChange::_internal_set_newphotoid(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.newphotoid_ = value; +} +inline void PhotoChange::set_newphotoid(uint32_t value) { + _internal_set_newphotoid(value); + // @@protoc_insertion_point(field_set:proto.PhotoChange.newPhotoId) +} + +// ------------------------------------------------------------------- + +// Point + +// optional int32 xDeprecated = 1; +inline bool Point::_internal_has_xdeprecated() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Point::has_xdeprecated() const { + return _internal_has_xdeprecated(); +} +inline void Point::clear_xdeprecated() { + _impl_.xdeprecated_ = 0; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline int32_t Point::_internal_xdeprecated() const { + return _impl_.xdeprecated_; +} +inline int32_t Point::xdeprecated() const { + // @@protoc_insertion_point(field_get:proto.Point.xDeprecated) + return _internal_xdeprecated(); +} +inline void Point::_internal_set_xdeprecated(int32_t value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.xdeprecated_ = value; +} +inline void Point::set_xdeprecated(int32_t value) { + _internal_set_xdeprecated(value); + // @@protoc_insertion_point(field_set:proto.Point.xDeprecated) +} + +// optional int32 yDeprecated = 2; +inline bool Point::_internal_has_ydeprecated() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Point::has_ydeprecated() const { + return _internal_has_ydeprecated(); +} +inline void Point::clear_ydeprecated() { + _impl_.ydeprecated_ = 0; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline int32_t Point::_internal_ydeprecated() const { + return _impl_.ydeprecated_; +} +inline int32_t Point::ydeprecated() const { + // @@protoc_insertion_point(field_get:proto.Point.yDeprecated) + return _internal_ydeprecated(); +} +inline void Point::_internal_set_ydeprecated(int32_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.ydeprecated_ = value; +} +inline void Point::set_ydeprecated(int32_t value) { + _internal_set_ydeprecated(value); + // @@protoc_insertion_point(field_set:proto.Point.yDeprecated) +} + +// optional double x = 3; +inline bool Point::_internal_has_x() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool Point::has_x() const { + return _internal_has_x(); +} +inline void Point::clear_x() { + _impl_.x_ = 0; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline double Point::_internal_x() const { + return _impl_.x_; +} +inline double Point::x() const { + // @@protoc_insertion_point(field_get:proto.Point.x) + return _internal_x(); +} +inline void Point::_internal_set_x(double value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.x_ = value; +} +inline void Point::set_x(double value) { + _internal_set_x(value); + // @@protoc_insertion_point(field_set:proto.Point.x) +} + +// optional double y = 4; +inline bool Point::_internal_has_y() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool Point::has_y() const { + return _internal_has_y(); +} +inline void Point::clear_y() { + _impl_.y_ = 0; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline double Point::_internal_y() const { + return _impl_.y_; +} +inline double Point::y() const { + // @@protoc_insertion_point(field_get:proto.Point.y) + return _internal_y(); +} +inline void Point::_internal_set_y(double value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.y_ = value; +} +inline void Point::set_y(double value) { + _internal_set_y(value); + // @@protoc_insertion_point(field_set:proto.Point.y) +} + +// ------------------------------------------------------------------- + +// PollAdditionalMetadata + +// optional bool pollInvalidated = 1; +inline bool PollAdditionalMetadata::_internal_has_pollinvalidated() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool PollAdditionalMetadata::has_pollinvalidated() const { + return _internal_has_pollinvalidated(); +} +inline void PollAdditionalMetadata::clear_pollinvalidated() { + _impl_.pollinvalidated_ = false; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline bool PollAdditionalMetadata::_internal_pollinvalidated() const { + return _impl_.pollinvalidated_; +} +inline bool PollAdditionalMetadata::pollinvalidated() const { + // @@protoc_insertion_point(field_get:proto.PollAdditionalMetadata.pollInvalidated) + return _internal_pollinvalidated(); +} +inline void PollAdditionalMetadata::_internal_set_pollinvalidated(bool value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.pollinvalidated_ = value; +} +inline void PollAdditionalMetadata::set_pollinvalidated(bool value) { + _internal_set_pollinvalidated(value); + // @@protoc_insertion_point(field_set:proto.PollAdditionalMetadata.pollInvalidated) +} + +// ------------------------------------------------------------------- + +// PollEncValue + +// optional bytes encPayload = 1; +inline bool PollEncValue::_internal_has_encpayload() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool PollEncValue::has_encpayload() const { + return _internal_has_encpayload(); +} +inline void PollEncValue::clear_encpayload() { + _impl_.encpayload_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& PollEncValue::encpayload() const { + // @@protoc_insertion_point(field_get:proto.PollEncValue.encPayload) + return _internal_encpayload(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void PollEncValue::set_encpayload(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.encpayload_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.PollEncValue.encPayload) +} +inline std::string* PollEncValue::mutable_encpayload() { + std::string* _s = _internal_mutable_encpayload(); + // @@protoc_insertion_point(field_mutable:proto.PollEncValue.encPayload) + return _s; +} +inline const std::string& PollEncValue::_internal_encpayload() const { + return _impl_.encpayload_.Get(); +} +inline void PollEncValue::_internal_set_encpayload(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.encpayload_.Set(value, GetArenaForAllocation()); +} +inline std::string* PollEncValue::_internal_mutable_encpayload() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.encpayload_.Mutable(GetArenaForAllocation()); +} +inline std::string* PollEncValue::release_encpayload() { + // @@protoc_insertion_point(field_release:proto.PollEncValue.encPayload) + if (!_internal_has_encpayload()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.encpayload_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.encpayload_.IsDefault()) { + _impl_.encpayload_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void PollEncValue::set_allocated_encpayload(std::string* encpayload) { + if (encpayload != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.encpayload_.SetAllocated(encpayload, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.encpayload_.IsDefault()) { + _impl_.encpayload_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.PollEncValue.encPayload) +} + +// optional bytes encIv = 2; +inline bool PollEncValue::_internal_has_enciv() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool PollEncValue::has_enciv() const { + return _internal_has_enciv(); +} +inline void PollEncValue::clear_enciv() { + _impl_.enciv_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& PollEncValue::enciv() const { + // @@protoc_insertion_point(field_get:proto.PollEncValue.encIv) + return _internal_enciv(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void PollEncValue::set_enciv(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.enciv_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.PollEncValue.encIv) +} +inline std::string* PollEncValue::mutable_enciv() { + std::string* _s = _internal_mutable_enciv(); + // @@protoc_insertion_point(field_mutable:proto.PollEncValue.encIv) + return _s; +} +inline const std::string& PollEncValue::_internal_enciv() const { + return _impl_.enciv_.Get(); +} +inline void PollEncValue::_internal_set_enciv(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.enciv_.Set(value, GetArenaForAllocation()); +} +inline std::string* PollEncValue::_internal_mutable_enciv() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.enciv_.Mutable(GetArenaForAllocation()); +} +inline std::string* PollEncValue::release_enciv() { + // @@protoc_insertion_point(field_release:proto.PollEncValue.encIv) + if (!_internal_has_enciv()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.enciv_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.enciv_.IsDefault()) { + _impl_.enciv_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void PollEncValue::set_allocated_enciv(std::string* enciv) { + if (enciv != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.enciv_.SetAllocated(enciv, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.enciv_.IsDefault()) { + _impl_.enciv_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.PollEncValue.encIv) +} + +// ------------------------------------------------------------------- + +// PollUpdate + +// optional .proto.MessageKey pollUpdateMessageKey = 1; +inline bool PollUpdate::_internal_has_pollupdatemessagekey() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.pollupdatemessagekey_ != nullptr); + return value; +} +inline bool PollUpdate::has_pollupdatemessagekey() const { + return _internal_has_pollupdatemessagekey(); +} +inline void PollUpdate::clear_pollupdatemessagekey() { + if (_impl_.pollupdatemessagekey_ != nullptr) _impl_.pollupdatemessagekey_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::MessageKey& PollUpdate::_internal_pollupdatemessagekey() const { + const ::proto::MessageKey* p = _impl_.pollupdatemessagekey_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_MessageKey_default_instance_); +} +inline const ::proto::MessageKey& PollUpdate::pollupdatemessagekey() const { + // @@protoc_insertion_point(field_get:proto.PollUpdate.pollUpdateMessageKey) + return _internal_pollupdatemessagekey(); +} +inline void PollUpdate::unsafe_arena_set_allocated_pollupdatemessagekey( + ::proto::MessageKey* pollupdatemessagekey) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pollupdatemessagekey_); + } + _impl_.pollupdatemessagekey_ = pollupdatemessagekey; + if (pollupdatemessagekey) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.PollUpdate.pollUpdateMessageKey) +} +inline ::proto::MessageKey* PollUpdate::release_pollupdatemessagekey() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::MessageKey* temp = _impl_.pollupdatemessagekey_; + _impl_.pollupdatemessagekey_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::MessageKey* PollUpdate::unsafe_arena_release_pollupdatemessagekey() { + // @@protoc_insertion_point(field_release:proto.PollUpdate.pollUpdateMessageKey) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::MessageKey* temp = _impl_.pollupdatemessagekey_; + _impl_.pollupdatemessagekey_ = nullptr; + return temp; +} +inline ::proto::MessageKey* PollUpdate::_internal_mutable_pollupdatemessagekey() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.pollupdatemessagekey_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation()); + _impl_.pollupdatemessagekey_ = p; + } + return _impl_.pollupdatemessagekey_; +} +inline ::proto::MessageKey* PollUpdate::mutable_pollupdatemessagekey() { + ::proto::MessageKey* _msg = _internal_mutable_pollupdatemessagekey(); + // @@protoc_insertion_point(field_mutable:proto.PollUpdate.pollUpdateMessageKey) + return _msg; +} +inline void PollUpdate::set_allocated_pollupdatemessagekey(::proto::MessageKey* pollupdatemessagekey) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.pollupdatemessagekey_; + } + if (pollupdatemessagekey) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pollupdatemessagekey); + if (message_arena != submessage_arena) { + pollupdatemessagekey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, pollupdatemessagekey, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.pollupdatemessagekey_ = pollupdatemessagekey; + // @@protoc_insertion_point(field_set_allocated:proto.PollUpdate.pollUpdateMessageKey) +} + +// optional .proto.Message.PollVoteMessage vote = 2; +inline bool PollUpdate::_internal_has_vote() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.vote_ != nullptr); + return value; +} +inline bool PollUpdate::has_vote() const { + return _internal_has_vote(); +} +inline void PollUpdate::clear_vote() { + if (_impl_.vote_ != nullptr) _impl_.vote_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::Message_PollVoteMessage& PollUpdate::_internal_vote() const { + const ::proto::Message_PollVoteMessage* p = _impl_.vote_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_PollVoteMessage_default_instance_); +} +inline const ::proto::Message_PollVoteMessage& PollUpdate::vote() const { + // @@protoc_insertion_point(field_get:proto.PollUpdate.vote) + return _internal_vote(); +} +inline void PollUpdate::unsafe_arena_set_allocated_vote( + ::proto::Message_PollVoteMessage* vote) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.vote_); + } + _impl_.vote_ = vote; + if (vote) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.PollUpdate.vote) +} +inline ::proto::Message_PollVoteMessage* PollUpdate::release_vote() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::Message_PollVoteMessage* temp = _impl_.vote_; + _impl_.vote_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_PollVoteMessage* PollUpdate::unsafe_arena_release_vote() { + // @@protoc_insertion_point(field_release:proto.PollUpdate.vote) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::Message_PollVoteMessage* temp = _impl_.vote_; + _impl_.vote_ = nullptr; + return temp; +} +inline ::proto::Message_PollVoteMessage* PollUpdate::_internal_mutable_vote() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.vote_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_PollVoteMessage>(GetArenaForAllocation()); + _impl_.vote_ = p; + } + return _impl_.vote_; +} +inline ::proto::Message_PollVoteMessage* PollUpdate::mutable_vote() { + ::proto::Message_PollVoteMessage* _msg = _internal_mutable_vote(); + // @@protoc_insertion_point(field_mutable:proto.PollUpdate.vote) + return _msg; +} +inline void PollUpdate::set_allocated_vote(::proto::Message_PollVoteMessage* vote) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.vote_; + } + if (vote) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(vote); + if (message_arena != submessage_arena) { + vote = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, vote, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.vote_ = vote; + // @@protoc_insertion_point(field_set_allocated:proto.PollUpdate.vote) +} + +// optional int64 senderTimestampMs = 3; +inline bool PollUpdate::_internal_has_sendertimestampms() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool PollUpdate::has_sendertimestampms() const { + return _internal_has_sendertimestampms(); +} +inline void PollUpdate::clear_sendertimestampms() { + _impl_.sendertimestampms_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline int64_t PollUpdate::_internal_sendertimestampms() const { + return _impl_.sendertimestampms_; +} +inline int64_t PollUpdate::sendertimestampms() const { + // @@protoc_insertion_point(field_get:proto.PollUpdate.senderTimestampMs) + return _internal_sendertimestampms(); +} +inline void PollUpdate::_internal_set_sendertimestampms(int64_t value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.sendertimestampms_ = value; +} +inline void PollUpdate::set_sendertimestampms(int64_t value) { + _internal_set_sendertimestampms(value); + // @@protoc_insertion_point(field_set:proto.PollUpdate.senderTimestampMs) +} + +// ------------------------------------------------------------------- + +// PreKeyRecordStructure + +// optional uint32 id = 1; +inline bool PreKeyRecordStructure::_internal_has_id() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool PreKeyRecordStructure::has_id() const { + return _internal_has_id(); +} +inline void PreKeyRecordStructure::clear_id() { + _impl_.id_ = 0u; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline uint32_t PreKeyRecordStructure::_internal_id() const { + return _impl_.id_; +} +inline uint32_t PreKeyRecordStructure::id() const { + // @@protoc_insertion_point(field_get:proto.PreKeyRecordStructure.id) + return _internal_id(); +} +inline void PreKeyRecordStructure::_internal_set_id(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.id_ = value; +} +inline void PreKeyRecordStructure::set_id(uint32_t value) { + _internal_set_id(value); + // @@protoc_insertion_point(field_set:proto.PreKeyRecordStructure.id) +} + +// optional bytes publicKey = 2; +inline bool PreKeyRecordStructure::_internal_has_publickey() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool PreKeyRecordStructure::has_publickey() const { + return _internal_has_publickey(); +} +inline void PreKeyRecordStructure::clear_publickey() { + _impl_.publickey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& PreKeyRecordStructure::publickey() const { + // @@protoc_insertion_point(field_get:proto.PreKeyRecordStructure.publicKey) + return _internal_publickey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void PreKeyRecordStructure::set_publickey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.publickey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.PreKeyRecordStructure.publicKey) +} +inline std::string* PreKeyRecordStructure::mutable_publickey() { + std::string* _s = _internal_mutable_publickey(); + // @@protoc_insertion_point(field_mutable:proto.PreKeyRecordStructure.publicKey) + return _s; +} +inline const std::string& PreKeyRecordStructure::_internal_publickey() const { + return _impl_.publickey_.Get(); +} +inline void PreKeyRecordStructure::_internal_set_publickey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.publickey_.Set(value, GetArenaForAllocation()); +} +inline std::string* PreKeyRecordStructure::_internal_mutable_publickey() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.publickey_.Mutable(GetArenaForAllocation()); +} +inline std::string* PreKeyRecordStructure::release_publickey() { + // @@protoc_insertion_point(field_release:proto.PreKeyRecordStructure.publicKey) + if (!_internal_has_publickey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.publickey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.publickey_.IsDefault()) { + _impl_.publickey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void PreKeyRecordStructure::set_allocated_publickey(std::string* publickey) { + if (publickey != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.publickey_.SetAllocated(publickey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.publickey_.IsDefault()) { + _impl_.publickey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.PreKeyRecordStructure.publicKey) +} + +// optional bytes privateKey = 3; +inline bool PreKeyRecordStructure::_internal_has_privatekey() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool PreKeyRecordStructure::has_privatekey() const { + return _internal_has_privatekey(); +} +inline void PreKeyRecordStructure::clear_privatekey() { + _impl_.privatekey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& PreKeyRecordStructure::privatekey() const { + // @@protoc_insertion_point(field_get:proto.PreKeyRecordStructure.privateKey) + return _internal_privatekey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void PreKeyRecordStructure::set_privatekey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.privatekey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.PreKeyRecordStructure.privateKey) +} +inline std::string* PreKeyRecordStructure::mutable_privatekey() { + std::string* _s = _internal_mutable_privatekey(); + // @@protoc_insertion_point(field_mutable:proto.PreKeyRecordStructure.privateKey) + return _s; +} +inline const std::string& PreKeyRecordStructure::_internal_privatekey() const { + return _impl_.privatekey_.Get(); +} +inline void PreKeyRecordStructure::_internal_set_privatekey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.privatekey_.Set(value, GetArenaForAllocation()); +} +inline std::string* PreKeyRecordStructure::_internal_mutable_privatekey() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.privatekey_.Mutable(GetArenaForAllocation()); +} +inline std::string* PreKeyRecordStructure::release_privatekey() { + // @@protoc_insertion_point(field_release:proto.PreKeyRecordStructure.privateKey) + if (!_internal_has_privatekey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.privatekey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.privatekey_.IsDefault()) { + _impl_.privatekey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void PreKeyRecordStructure::set_allocated_privatekey(std::string* privatekey) { + if (privatekey != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.privatekey_.SetAllocated(privatekey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.privatekey_.IsDefault()) { + _impl_.privatekey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.PreKeyRecordStructure.privateKey) +} + +// ------------------------------------------------------------------- + +// Pushname + +// optional string id = 1; +inline bool Pushname::_internal_has_id() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Pushname::has_id() const { + return _internal_has_id(); +} +inline void Pushname::clear_id() { + _impl_.id_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Pushname::id() const { + // @@protoc_insertion_point(field_get:proto.Pushname.id) + return _internal_id(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Pushname::set_id(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.id_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Pushname.id) +} +inline std::string* Pushname::mutable_id() { + std::string* _s = _internal_mutable_id(); + // @@protoc_insertion_point(field_mutable:proto.Pushname.id) + return _s; +} +inline const std::string& Pushname::_internal_id() const { + return _impl_.id_.Get(); +} +inline void Pushname::_internal_set_id(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.id_.Set(value, GetArenaForAllocation()); +} +inline std::string* Pushname::_internal_mutable_id() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.id_.Mutable(GetArenaForAllocation()); +} +inline std::string* Pushname::release_id() { + // @@protoc_insertion_point(field_release:proto.Pushname.id) + if (!_internal_has_id()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.id_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.id_.IsDefault()) { + _impl_.id_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Pushname::set_allocated_id(std::string* id) { + if (id != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.id_.SetAllocated(id, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.id_.IsDefault()) { + _impl_.id_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Pushname.id) +} + +// optional string pushname = 2; +inline bool Pushname::_internal_has_pushname() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Pushname::has_pushname() const { + return _internal_has_pushname(); +} +inline void Pushname::clear_pushname() { + _impl_.pushname_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Pushname::pushname() const { + // @@protoc_insertion_point(field_get:proto.Pushname.pushname) + return _internal_pushname(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Pushname::set_pushname(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.pushname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Pushname.pushname) +} +inline std::string* Pushname::mutable_pushname() { + std::string* _s = _internal_mutable_pushname(); + // @@protoc_insertion_point(field_mutable:proto.Pushname.pushname) + return _s; +} +inline const std::string& Pushname::_internal_pushname() const { + return _impl_.pushname_.Get(); +} +inline void Pushname::_internal_set_pushname(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.pushname_.Set(value, GetArenaForAllocation()); +} +inline std::string* Pushname::_internal_mutable_pushname() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.pushname_.Mutable(GetArenaForAllocation()); +} +inline std::string* Pushname::release_pushname() { + // @@protoc_insertion_point(field_release:proto.Pushname.pushname) + if (!_internal_has_pushname()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.pushname_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.pushname_.IsDefault()) { + _impl_.pushname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Pushname::set_allocated_pushname(std::string* pushname) { + if (pushname != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.pushname_.SetAllocated(pushname, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.pushname_.IsDefault()) { + _impl_.pushname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Pushname.pushname) +} + +// ------------------------------------------------------------------- + +// Reaction + +// optional .proto.MessageKey key = 1; +inline bool Reaction::_internal_has_key() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr); + return value; +} +inline bool Reaction::has_key() const { + return _internal_has_key(); +} +inline void Reaction::clear_key() { + if (_impl_.key_ != nullptr) _impl_.key_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::proto::MessageKey& Reaction::_internal_key() const { + const ::proto::MessageKey* p = _impl_.key_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_MessageKey_default_instance_); +} +inline const ::proto::MessageKey& Reaction::key() const { + // @@protoc_insertion_point(field_get:proto.Reaction.key) + return _internal_key(); +} +inline void Reaction::unsafe_arena_set_allocated_key( + ::proto::MessageKey* key) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_); + } + _impl_.key_ = key; + if (key) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Reaction.key) +} +inline ::proto::MessageKey* Reaction::release_key() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::MessageKey* temp = _impl_.key_; + _impl_.key_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::MessageKey* Reaction::unsafe_arena_release_key() { + // @@protoc_insertion_point(field_release:proto.Reaction.key) + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::MessageKey* temp = _impl_.key_; + _impl_.key_ = nullptr; + return temp; +} +inline ::proto::MessageKey* Reaction::_internal_mutable_key() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.key_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation()); + _impl_.key_ = p; + } + return _impl_.key_; +} +inline ::proto::MessageKey* Reaction::mutable_key() { + ::proto::MessageKey* _msg = _internal_mutable_key(); + // @@protoc_insertion_point(field_mutable:proto.Reaction.key) + return _msg; +} +inline void Reaction::set_allocated_key(::proto::MessageKey* key) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.key_; + } + if (key) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key); + if (message_arena != submessage_arena) { + key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, key, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.key_ = key; + // @@protoc_insertion_point(field_set_allocated:proto.Reaction.key) +} + +// optional string text = 2; +inline bool Reaction::_internal_has_text() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool Reaction::has_text() const { + return _internal_has_text(); +} +inline void Reaction::clear_text() { + _impl_.text_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& Reaction::text() const { + // @@protoc_insertion_point(field_get:proto.Reaction.text) + return _internal_text(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Reaction::set_text(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.text_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Reaction.text) +} +inline std::string* Reaction::mutable_text() { + std::string* _s = _internal_mutable_text(); + // @@protoc_insertion_point(field_mutable:proto.Reaction.text) + return _s; +} +inline const std::string& Reaction::_internal_text() const { + return _impl_.text_.Get(); +} +inline void Reaction::_internal_set_text(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.text_.Set(value, GetArenaForAllocation()); +} +inline std::string* Reaction::_internal_mutable_text() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.text_.Mutable(GetArenaForAllocation()); +} +inline std::string* Reaction::release_text() { + // @@protoc_insertion_point(field_release:proto.Reaction.text) + if (!_internal_has_text()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.text_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.text_.IsDefault()) { + _impl_.text_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Reaction::set_allocated_text(std::string* text) { + if (text != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.text_.SetAllocated(text, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.text_.IsDefault()) { + _impl_.text_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Reaction.text) +} + +// optional string groupingKey = 3; +inline bool Reaction::_internal_has_groupingkey() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool Reaction::has_groupingkey() const { + return _internal_has_groupingkey(); +} +inline void Reaction::clear_groupingkey() { + _impl_.groupingkey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& Reaction::groupingkey() const { + // @@protoc_insertion_point(field_get:proto.Reaction.groupingKey) + return _internal_groupingkey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void Reaction::set_groupingkey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.groupingkey_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.Reaction.groupingKey) +} +inline std::string* Reaction::mutable_groupingkey() { + std::string* _s = _internal_mutable_groupingkey(); + // @@protoc_insertion_point(field_mutable:proto.Reaction.groupingKey) + return _s; +} +inline const std::string& Reaction::_internal_groupingkey() const { + return _impl_.groupingkey_.Get(); +} +inline void Reaction::_internal_set_groupingkey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.groupingkey_.Set(value, GetArenaForAllocation()); +} +inline std::string* Reaction::_internal_mutable_groupingkey() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.groupingkey_.Mutable(GetArenaForAllocation()); +} +inline std::string* Reaction::release_groupingkey() { + // @@protoc_insertion_point(field_release:proto.Reaction.groupingKey) + if (!_internal_has_groupingkey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.groupingkey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.groupingkey_.IsDefault()) { + _impl_.groupingkey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void Reaction::set_allocated_groupingkey(std::string* groupingkey) { + if (groupingkey != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.groupingkey_.SetAllocated(groupingkey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.groupingkey_.IsDefault()) { + _impl_.groupingkey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.Reaction.groupingKey) +} + +// optional int64 senderTimestampMs = 4; +inline bool Reaction::_internal_has_sendertimestampms() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool Reaction::has_sendertimestampms() const { + return _internal_has_sendertimestampms(); +} +inline void Reaction::clear_sendertimestampms() { + _impl_.sendertimestampms_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline int64_t Reaction::_internal_sendertimestampms() const { + return _impl_.sendertimestampms_; +} +inline int64_t Reaction::sendertimestampms() const { + // @@protoc_insertion_point(field_get:proto.Reaction.senderTimestampMs) + return _internal_sendertimestampms(); +} +inline void Reaction::_internal_set_sendertimestampms(int64_t value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.sendertimestampms_ = value; +} +inline void Reaction::set_sendertimestampms(int64_t value) { + _internal_set_sendertimestampms(value); + // @@protoc_insertion_point(field_set:proto.Reaction.senderTimestampMs) +} + +// optional bool unread = 5; +inline bool Reaction::_internal_has_unread() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool Reaction::has_unread() const { + return _internal_has_unread(); +} +inline void Reaction::clear_unread() { + _impl_.unread_ = false; + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline bool Reaction::_internal_unread() const { + return _impl_.unread_; +} +inline bool Reaction::unread() const { + // @@protoc_insertion_point(field_get:proto.Reaction.unread) + return _internal_unread(); +} +inline void Reaction::_internal_set_unread(bool value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.unread_ = value; +} +inline void Reaction::set_unread(bool value) { + _internal_set_unread(value); + // @@protoc_insertion_point(field_set:proto.Reaction.unread) +} + +// ------------------------------------------------------------------- + +// RecentEmojiWeight + +// optional string emoji = 1; +inline bool RecentEmojiWeight::_internal_has_emoji() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool RecentEmojiWeight::has_emoji() const { + return _internal_has_emoji(); +} +inline void RecentEmojiWeight::clear_emoji() { + _impl_.emoji_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& RecentEmojiWeight::emoji() const { + // @@protoc_insertion_point(field_get:proto.RecentEmojiWeight.emoji) + return _internal_emoji(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void RecentEmojiWeight::set_emoji(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.emoji_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.RecentEmojiWeight.emoji) +} +inline std::string* RecentEmojiWeight::mutable_emoji() { + std::string* _s = _internal_mutable_emoji(); + // @@protoc_insertion_point(field_mutable:proto.RecentEmojiWeight.emoji) + return _s; +} +inline const std::string& RecentEmojiWeight::_internal_emoji() const { + return _impl_.emoji_.Get(); +} +inline void RecentEmojiWeight::_internal_set_emoji(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.emoji_.Set(value, GetArenaForAllocation()); +} +inline std::string* RecentEmojiWeight::_internal_mutable_emoji() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.emoji_.Mutable(GetArenaForAllocation()); +} +inline std::string* RecentEmojiWeight::release_emoji() { + // @@protoc_insertion_point(field_release:proto.RecentEmojiWeight.emoji) + if (!_internal_has_emoji()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.emoji_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.emoji_.IsDefault()) { + _impl_.emoji_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void RecentEmojiWeight::set_allocated_emoji(std::string* emoji) { + if (emoji != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.emoji_.SetAllocated(emoji, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.emoji_.IsDefault()) { + _impl_.emoji_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.RecentEmojiWeight.emoji) +} + +// optional float weight = 2; +inline bool RecentEmojiWeight::_internal_has_weight() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool RecentEmojiWeight::has_weight() const { + return _internal_has_weight(); +} +inline void RecentEmojiWeight::clear_weight() { + _impl_.weight_ = 0; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline float RecentEmojiWeight::_internal_weight() const { + return _impl_.weight_; +} +inline float RecentEmojiWeight::weight() const { + // @@protoc_insertion_point(field_get:proto.RecentEmojiWeight.weight) + return _internal_weight(); +} +inline void RecentEmojiWeight::_internal_set_weight(float value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.weight_ = value; +} +inline void RecentEmojiWeight::set_weight(float value) { + _internal_set_weight(value); + // @@protoc_insertion_point(field_set:proto.RecentEmojiWeight.weight) +} + +// ------------------------------------------------------------------- + +// RecordStructure + +// optional .proto.SessionStructure currentSession = 1; +inline bool RecordStructure::_internal_has_currentsession() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.currentsession_ != nullptr); + return value; +} +inline bool RecordStructure::has_currentsession() const { + return _internal_has_currentsession(); +} +inline void RecordStructure::clear_currentsession() { + if (_impl_.currentsession_ != nullptr) _impl_.currentsession_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::SessionStructure& RecordStructure::_internal_currentsession() const { + const ::proto::SessionStructure* p = _impl_.currentsession_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SessionStructure_default_instance_); +} +inline const ::proto::SessionStructure& RecordStructure::currentsession() const { + // @@protoc_insertion_point(field_get:proto.RecordStructure.currentSession) + return _internal_currentsession(); +} +inline void RecordStructure::unsafe_arena_set_allocated_currentsession( + ::proto::SessionStructure* currentsession) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.currentsession_); + } + _impl_.currentsession_ = currentsession; + if (currentsession) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.RecordStructure.currentSession) +} +inline ::proto::SessionStructure* RecordStructure::release_currentsession() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::SessionStructure* temp = _impl_.currentsession_; + _impl_.currentsession_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SessionStructure* RecordStructure::unsafe_arena_release_currentsession() { + // @@protoc_insertion_point(field_release:proto.RecordStructure.currentSession) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::SessionStructure* temp = _impl_.currentsession_; + _impl_.currentsession_ = nullptr; + return temp; +} +inline ::proto::SessionStructure* RecordStructure::_internal_mutable_currentsession() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.currentsession_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SessionStructure>(GetArenaForAllocation()); + _impl_.currentsession_ = p; + } + return _impl_.currentsession_; +} +inline ::proto::SessionStructure* RecordStructure::mutable_currentsession() { + ::proto::SessionStructure* _msg = _internal_mutable_currentsession(); + // @@protoc_insertion_point(field_mutable:proto.RecordStructure.currentSession) + return _msg; +} +inline void RecordStructure::set_allocated_currentsession(::proto::SessionStructure* currentsession) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.currentsession_; + } + if (currentsession) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(currentsession); + if (message_arena != submessage_arena) { + currentsession = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, currentsession, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.currentsession_ = currentsession; + // @@protoc_insertion_point(field_set_allocated:proto.RecordStructure.currentSession) +} + +// repeated .proto.SessionStructure previousSessions = 2; +inline int RecordStructure::_internal_previoussessions_size() const { + return _impl_.previoussessions_.size(); +} +inline int RecordStructure::previoussessions_size() const { + return _internal_previoussessions_size(); +} +inline void RecordStructure::clear_previoussessions() { + _impl_.previoussessions_.Clear(); +} +inline ::proto::SessionStructure* RecordStructure::mutable_previoussessions(int index) { + // @@protoc_insertion_point(field_mutable:proto.RecordStructure.previousSessions) + return _impl_.previoussessions_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SessionStructure >* +RecordStructure::mutable_previoussessions() { + // @@protoc_insertion_point(field_mutable_list:proto.RecordStructure.previousSessions) + return &_impl_.previoussessions_; +} +inline const ::proto::SessionStructure& RecordStructure::_internal_previoussessions(int index) const { + return _impl_.previoussessions_.Get(index); +} +inline const ::proto::SessionStructure& RecordStructure::previoussessions(int index) const { + // @@protoc_insertion_point(field_get:proto.RecordStructure.previousSessions) + return _internal_previoussessions(index); +} +inline ::proto::SessionStructure* RecordStructure::_internal_add_previoussessions() { + return _impl_.previoussessions_.Add(); +} +inline ::proto::SessionStructure* RecordStructure::add_previoussessions() { + ::proto::SessionStructure* _add = _internal_add_previoussessions(); + // @@protoc_insertion_point(field_add:proto.RecordStructure.previousSessions) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SessionStructure >& +RecordStructure::previoussessions() const { + // @@protoc_insertion_point(field_list:proto.RecordStructure.previousSessions) + return _impl_.previoussessions_; +} + +// ------------------------------------------------------------------- + +// SenderChainKey + +// optional uint32 iteration = 1; +inline bool SenderChainKey::_internal_has_iteration() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SenderChainKey::has_iteration() const { + return _internal_has_iteration(); +} +inline void SenderChainKey::clear_iteration() { + _impl_.iteration_ = 0u; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline uint32_t SenderChainKey::_internal_iteration() const { + return _impl_.iteration_; +} +inline uint32_t SenderChainKey::iteration() const { + // @@protoc_insertion_point(field_get:proto.SenderChainKey.iteration) + return _internal_iteration(); +} +inline void SenderChainKey::_internal_set_iteration(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.iteration_ = value; +} +inline void SenderChainKey::set_iteration(uint32_t value) { + _internal_set_iteration(value); + // @@protoc_insertion_point(field_set:proto.SenderChainKey.iteration) +} + +// optional bytes seed = 2; +inline bool SenderChainKey::_internal_has_seed() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SenderChainKey::has_seed() const { + return _internal_has_seed(); +} +inline void SenderChainKey::clear_seed() { + _impl_.seed_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& SenderChainKey::seed() const { + // @@protoc_insertion_point(field_get:proto.SenderChainKey.seed) + return _internal_seed(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SenderChainKey::set_seed(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.seed_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SenderChainKey.seed) +} +inline std::string* SenderChainKey::mutable_seed() { + std::string* _s = _internal_mutable_seed(); + // @@protoc_insertion_point(field_mutable:proto.SenderChainKey.seed) + return _s; +} +inline const std::string& SenderChainKey::_internal_seed() const { + return _impl_.seed_.Get(); +} +inline void SenderChainKey::_internal_set_seed(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.seed_.Set(value, GetArenaForAllocation()); +} +inline std::string* SenderChainKey::_internal_mutable_seed() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.seed_.Mutable(GetArenaForAllocation()); +} +inline std::string* SenderChainKey::release_seed() { + // @@protoc_insertion_point(field_release:proto.SenderChainKey.seed) + if (!_internal_has_seed()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.seed_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.seed_.IsDefault()) { + _impl_.seed_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SenderChainKey::set_allocated_seed(std::string* seed) { + if (seed != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.seed_.SetAllocated(seed, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.seed_.IsDefault()) { + _impl_.seed_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SenderChainKey.seed) +} + +// ------------------------------------------------------------------- + +// SenderKeyRecordStructure + +// repeated .proto.SenderKeyStateStructure senderKeyStates = 1; +inline int SenderKeyRecordStructure::_internal_senderkeystates_size() const { + return _impl_.senderkeystates_.size(); +} +inline int SenderKeyRecordStructure::senderkeystates_size() const { + return _internal_senderkeystates_size(); +} +inline void SenderKeyRecordStructure::clear_senderkeystates() { + _impl_.senderkeystates_.Clear(); +} +inline ::proto::SenderKeyStateStructure* SenderKeyRecordStructure::mutable_senderkeystates(int index) { + // @@protoc_insertion_point(field_mutable:proto.SenderKeyRecordStructure.senderKeyStates) + return _impl_.senderkeystates_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderKeyStateStructure >* +SenderKeyRecordStructure::mutable_senderkeystates() { + // @@protoc_insertion_point(field_mutable_list:proto.SenderKeyRecordStructure.senderKeyStates) + return &_impl_.senderkeystates_; +} +inline const ::proto::SenderKeyStateStructure& SenderKeyRecordStructure::_internal_senderkeystates(int index) const { + return _impl_.senderkeystates_.Get(index); +} +inline const ::proto::SenderKeyStateStructure& SenderKeyRecordStructure::senderkeystates(int index) const { + // @@protoc_insertion_point(field_get:proto.SenderKeyRecordStructure.senderKeyStates) + return _internal_senderkeystates(index); +} +inline ::proto::SenderKeyStateStructure* SenderKeyRecordStructure::_internal_add_senderkeystates() { + return _impl_.senderkeystates_.Add(); +} +inline ::proto::SenderKeyStateStructure* SenderKeyRecordStructure::add_senderkeystates() { + ::proto::SenderKeyStateStructure* _add = _internal_add_senderkeystates(); + // @@protoc_insertion_point(field_add:proto.SenderKeyRecordStructure.senderKeyStates) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderKeyStateStructure >& +SenderKeyRecordStructure::senderkeystates() const { + // @@protoc_insertion_point(field_list:proto.SenderKeyRecordStructure.senderKeyStates) + return _impl_.senderkeystates_; +} + +// ------------------------------------------------------------------- + +// SenderKeyStateStructure + +// optional uint32 senderKeyId = 1; +inline bool SenderKeyStateStructure::_internal_has_senderkeyid() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool SenderKeyStateStructure::has_senderkeyid() const { + return _internal_has_senderkeyid(); +} +inline void SenderKeyStateStructure::clear_senderkeyid() { + _impl_.senderkeyid_ = 0u; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline uint32_t SenderKeyStateStructure::_internal_senderkeyid() const { + return _impl_.senderkeyid_; +} +inline uint32_t SenderKeyStateStructure::senderkeyid() const { + // @@protoc_insertion_point(field_get:proto.SenderKeyStateStructure.senderKeyId) + return _internal_senderkeyid(); +} +inline void SenderKeyStateStructure::_internal_set_senderkeyid(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.senderkeyid_ = value; +} +inline void SenderKeyStateStructure::set_senderkeyid(uint32_t value) { + _internal_set_senderkeyid(value); + // @@protoc_insertion_point(field_set:proto.SenderKeyStateStructure.senderKeyId) +} + +// optional .proto.SenderChainKey senderChainKey = 2; +inline bool SenderKeyStateStructure::_internal_has_senderchainkey() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.senderchainkey_ != nullptr); + return value; +} +inline bool SenderKeyStateStructure::has_senderchainkey() const { + return _internal_has_senderchainkey(); +} +inline void SenderKeyStateStructure::clear_senderchainkey() { + if (_impl_.senderchainkey_ != nullptr) _impl_.senderchainkey_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::SenderChainKey& SenderKeyStateStructure::_internal_senderchainkey() const { + const ::proto::SenderChainKey* p = _impl_.senderchainkey_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SenderChainKey_default_instance_); +} +inline const ::proto::SenderChainKey& SenderKeyStateStructure::senderchainkey() const { + // @@protoc_insertion_point(field_get:proto.SenderKeyStateStructure.senderChainKey) + return _internal_senderchainkey(); +} +inline void SenderKeyStateStructure::unsafe_arena_set_allocated_senderchainkey( + ::proto::SenderChainKey* senderchainkey) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.senderchainkey_); + } + _impl_.senderchainkey_ = senderchainkey; + if (senderchainkey) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SenderKeyStateStructure.senderChainKey) +} +inline ::proto::SenderChainKey* SenderKeyStateStructure::release_senderchainkey() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::SenderChainKey* temp = _impl_.senderchainkey_; + _impl_.senderchainkey_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SenderChainKey* SenderKeyStateStructure::unsafe_arena_release_senderchainkey() { + // @@protoc_insertion_point(field_release:proto.SenderKeyStateStructure.senderChainKey) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::SenderChainKey* temp = _impl_.senderchainkey_; + _impl_.senderchainkey_ = nullptr; + return temp; +} +inline ::proto::SenderChainKey* SenderKeyStateStructure::_internal_mutable_senderchainkey() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.senderchainkey_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SenderChainKey>(GetArenaForAllocation()); + _impl_.senderchainkey_ = p; + } + return _impl_.senderchainkey_; +} +inline ::proto::SenderChainKey* SenderKeyStateStructure::mutable_senderchainkey() { + ::proto::SenderChainKey* _msg = _internal_mutable_senderchainkey(); + // @@protoc_insertion_point(field_mutable:proto.SenderKeyStateStructure.senderChainKey) + return _msg; +} +inline void SenderKeyStateStructure::set_allocated_senderchainkey(::proto::SenderChainKey* senderchainkey) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.senderchainkey_; + } + if (senderchainkey) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(senderchainkey); + if (message_arena != submessage_arena) { + senderchainkey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, senderchainkey, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.senderchainkey_ = senderchainkey; + // @@protoc_insertion_point(field_set_allocated:proto.SenderKeyStateStructure.senderChainKey) +} + +// optional .proto.SenderSigningKey senderSigningKey = 3; +inline bool SenderKeyStateStructure::_internal_has_sendersigningkey() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.sendersigningkey_ != nullptr); + return value; +} +inline bool SenderKeyStateStructure::has_sendersigningkey() const { + return _internal_has_sendersigningkey(); +} +inline void SenderKeyStateStructure::clear_sendersigningkey() { + if (_impl_.sendersigningkey_ != nullptr) _impl_.sendersigningkey_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::SenderSigningKey& SenderKeyStateStructure::_internal_sendersigningkey() const { + const ::proto::SenderSigningKey* p = _impl_.sendersigningkey_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SenderSigningKey_default_instance_); +} +inline const ::proto::SenderSigningKey& SenderKeyStateStructure::sendersigningkey() const { + // @@protoc_insertion_point(field_get:proto.SenderKeyStateStructure.senderSigningKey) + return _internal_sendersigningkey(); +} +inline void SenderKeyStateStructure::unsafe_arena_set_allocated_sendersigningkey( + ::proto::SenderSigningKey* sendersigningkey) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.sendersigningkey_); + } + _impl_.sendersigningkey_ = sendersigningkey; + if (sendersigningkey) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SenderKeyStateStructure.senderSigningKey) +} +inline ::proto::SenderSigningKey* SenderKeyStateStructure::release_sendersigningkey() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::SenderSigningKey* temp = _impl_.sendersigningkey_; + _impl_.sendersigningkey_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SenderSigningKey* SenderKeyStateStructure::unsafe_arena_release_sendersigningkey() { + // @@protoc_insertion_point(field_release:proto.SenderKeyStateStructure.senderSigningKey) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::SenderSigningKey* temp = _impl_.sendersigningkey_; + _impl_.sendersigningkey_ = nullptr; + return temp; +} +inline ::proto::SenderSigningKey* SenderKeyStateStructure::_internal_mutable_sendersigningkey() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.sendersigningkey_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SenderSigningKey>(GetArenaForAllocation()); + _impl_.sendersigningkey_ = p; + } + return _impl_.sendersigningkey_; +} +inline ::proto::SenderSigningKey* SenderKeyStateStructure::mutable_sendersigningkey() { + ::proto::SenderSigningKey* _msg = _internal_mutable_sendersigningkey(); + // @@protoc_insertion_point(field_mutable:proto.SenderKeyStateStructure.senderSigningKey) + return _msg; +} +inline void SenderKeyStateStructure::set_allocated_sendersigningkey(::proto::SenderSigningKey* sendersigningkey) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.sendersigningkey_; + } + if (sendersigningkey) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(sendersigningkey); + if (message_arena != submessage_arena) { + sendersigningkey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, sendersigningkey, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.sendersigningkey_ = sendersigningkey; + // @@protoc_insertion_point(field_set_allocated:proto.SenderKeyStateStructure.senderSigningKey) +} + +// repeated .proto.SenderMessageKey senderMessageKeys = 4; +inline int SenderKeyStateStructure::_internal_sendermessagekeys_size() const { + return _impl_.sendermessagekeys_.size(); +} +inline int SenderKeyStateStructure::sendermessagekeys_size() const { + return _internal_sendermessagekeys_size(); +} +inline void SenderKeyStateStructure::clear_sendermessagekeys() { + _impl_.sendermessagekeys_.Clear(); +} +inline ::proto::SenderMessageKey* SenderKeyStateStructure::mutable_sendermessagekeys(int index) { + // @@protoc_insertion_point(field_mutable:proto.SenderKeyStateStructure.senderMessageKeys) + return _impl_.sendermessagekeys_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderMessageKey >* +SenderKeyStateStructure::mutable_sendermessagekeys() { + // @@protoc_insertion_point(field_mutable_list:proto.SenderKeyStateStructure.senderMessageKeys) + return &_impl_.sendermessagekeys_; +} +inline const ::proto::SenderMessageKey& SenderKeyStateStructure::_internal_sendermessagekeys(int index) const { + return _impl_.sendermessagekeys_.Get(index); +} +inline const ::proto::SenderMessageKey& SenderKeyStateStructure::sendermessagekeys(int index) const { + // @@protoc_insertion_point(field_get:proto.SenderKeyStateStructure.senderMessageKeys) + return _internal_sendermessagekeys(index); +} +inline ::proto::SenderMessageKey* SenderKeyStateStructure::_internal_add_sendermessagekeys() { + return _impl_.sendermessagekeys_.Add(); +} +inline ::proto::SenderMessageKey* SenderKeyStateStructure::add_sendermessagekeys() { + ::proto::SenderMessageKey* _add = _internal_add_sendermessagekeys(); + // @@protoc_insertion_point(field_add:proto.SenderKeyStateStructure.senderMessageKeys) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderMessageKey >& +SenderKeyStateStructure::sendermessagekeys() const { + // @@protoc_insertion_point(field_list:proto.SenderKeyStateStructure.senderMessageKeys) + return _impl_.sendermessagekeys_; +} + +// ------------------------------------------------------------------- + +// SenderMessageKey + +// optional uint32 iteration = 1; +inline bool SenderMessageKey::_internal_has_iteration() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SenderMessageKey::has_iteration() const { + return _internal_has_iteration(); +} +inline void SenderMessageKey::clear_iteration() { + _impl_.iteration_ = 0u; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline uint32_t SenderMessageKey::_internal_iteration() const { + return _impl_.iteration_; +} +inline uint32_t SenderMessageKey::iteration() const { + // @@protoc_insertion_point(field_get:proto.SenderMessageKey.iteration) + return _internal_iteration(); +} +inline void SenderMessageKey::_internal_set_iteration(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.iteration_ = value; +} +inline void SenderMessageKey::set_iteration(uint32_t value) { + _internal_set_iteration(value); + // @@protoc_insertion_point(field_set:proto.SenderMessageKey.iteration) +} + +// optional bytes seed = 2; +inline bool SenderMessageKey::_internal_has_seed() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SenderMessageKey::has_seed() const { + return _internal_has_seed(); +} +inline void SenderMessageKey::clear_seed() { + _impl_.seed_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& SenderMessageKey::seed() const { + // @@protoc_insertion_point(field_get:proto.SenderMessageKey.seed) + return _internal_seed(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SenderMessageKey::set_seed(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.seed_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SenderMessageKey.seed) +} +inline std::string* SenderMessageKey::mutable_seed() { + std::string* _s = _internal_mutable_seed(); + // @@protoc_insertion_point(field_mutable:proto.SenderMessageKey.seed) + return _s; +} +inline const std::string& SenderMessageKey::_internal_seed() const { + return _impl_.seed_.Get(); +} +inline void SenderMessageKey::_internal_set_seed(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.seed_.Set(value, GetArenaForAllocation()); +} +inline std::string* SenderMessageKey::_internal_mutable_seed() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.seed_.Mutable(GetArenaForAllocation()); +} +inline std::string* SenderMessageKey::release_seed() { + // @@protoc_insertion_point(field_release:proto.SenderMessageKey.seed) + if (!_internal_has_seed()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.seed_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.seed_.IsDefault()) { + _impl_.seed_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SenderMessageKey::set_allocated_seed(std::string* seed) { + if (seed != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.seed_.SetAllocated(seed, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.seed_.IsDefault()) { + _impl_.seed_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SenderMessageKey.seed) +} + +// ------------------------------------------------------------------- + +// SenderSigningKey + +// optional bytes public = 1; +inline bool SenderSigningKey::_internal_has_public_() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SenderSigningKey::has_public_() const { + return _internal_has_public_(); +} +inline void SenderSigningKey::clear_public_() { + _impl_.public__.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& SenderSigningKey::public_() const { + // @@protoc_insertion_point(field_get:proto.SenderSigningKey.public) + return _internal_public_(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SenderSigningKey::set_public_(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.public__.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SenderSigningKey.public) +} +inline std::string* SenderSigningKey::mutable_public_() { + std::string* _s = _internal_mutable_public_(); + // @@protoc_insertion_point(field_mutable:proto.SenderSigningKey.public) + return _s; +} +inline const std::string& SenderSigningKey::_internal_public_() const { + return _impl_.public__.Get(); +} +inline void SenderSigningKey::_internal_set_public_(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.public__.Set(value, GetArenaForAllocation()); +} +inline std::string* SenderSigningKey::_internal_mutable_public_() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.public__.Mutable(GetArenaForAllocation()); +} +inline std::string* SenderSigningKey::release_public_() { + // @@protoc_insertion_point(field_release:proto.SenderSigningKey.public) + if (!_internal_has_public_()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.public__.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.public__.IsDefault()) { + _impl_.public__.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SenderSigningKey::set_allocated_public_(std::string* public_) { + if (public_ != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.public__.SetAllocated(public_, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.public__.IsDefault()) { + _impl_.public__.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SenderSigningKey.public) +} + +// optional bytes private = 2; +inline bool SenderSigningKey::_internal_has_private_() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SenderSigningKey::has_private_() const { + return _internal_has_private_(); +} +inline void SenderSigningKey::clear_private_() { + _impl_.private__.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& SenderSigningKey::private_() const { + // @@protoc_insertion_point(field_get:proto.SenderSigningKey.private) + return _internal_private_(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SenderSigningKey::set_private_(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.private__.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SenderSigningKey.private) +} +inline std::string* SenderSigningKey::mutable_private_() { + std::string* _s = _internal_mutable_private_(); + // @@protoc_insertion_point(field_mutable:proto.SenderSigningKey.private) + return _s; +} +inline const std::string& SenderSigningKey::_internal_private_() const { + return _impl_.private__.Get(); +} +inline void SenderSigningKey::_internal_set_private_(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.private__.Set(value, GetArenaForAllocation()); +} +inline std::string* SenderSigningKey::_internal_mutable_private_() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.private__.Mutable(GetArenaForAllocation()); +} +inline std::string* SenderSigningKey::release_private_() { + // @@protoc_insertion_point(field_release:proto.SenderSigningKey.private) + if (!_internal_has_private_()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.private__.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.private__.IsDefault()) { + _impl_.private__.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SenderSigningKey::set_allocated_private_(std::string* private_) { + if (private_ != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.private__.SetAllocated(private_, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.private__.IsDefault()) { + _impl_.private__.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SenderSigningKey.private) +} + +// ------------------------------------------------------------------- + +// ServerErrorReceipt + +// optional string stanzaId = 1; +inline bool ServerErrorReceipt::_internal_has_stanzaid() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ServerErrorReceipt::has_stanzaid() const { + return _internal_has_stanzaid(); +} +inline void ServerErrorReceipt::clear_stanzaid() { + _impl_.stanzaid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ServerErrorReceipt::stanzaid() const { + // @@protoc_insertion_point(field_get:proto.ServerErrorReceipt.stanzaId) + return _internal_stanzaid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ServerErrorReceipt::set_stanzaid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.stanzaid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.ServerErrorReceipt.stanzaId) +} +inline std::string* ServerErrorReceipt::mutable_stanzaid() { + std::string* _s = _internal_mutable_stanzaid(); + // @@protoc_insertion_point(field_mutable:proto.ServerErrorReceipt.stanzaId) + return _s; +} +inline const std::string& ServerErrorReceipt::_internal_stanzaid() const { + return _impl_.stanzaid_.Get(); +} +inline void ServerErrorReceipt::_internal_set_stanzaid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.stanzaid_.Set(value, GetArenaForAllocation()); +} +inline std::string* ServerErrorReceipt::_internal_mutable_stanzaid() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.stanzaid_.Mutable(GetArenaForAllocation()); +} +inline std::string* ServerErrorReceipt::release_stanzaid() { + // @@protoc_insertion_point(field_release:proto.ServerErrorReceipt.stanzaId) + if (!_internal_has_stanzaid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.stanzaid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.stanzaid_.IsDefault()) { + _impl_.stanzaid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ServerErrorReceipt::set_allocated_stanzaid(std::string* stanzaid) { + if (stanzaid != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.stanzaid_.SetAllocated(stanzaid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.stanzaid_.IsDefault()) { + _impl_.stanzaid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.ServerErrorReceipt.stanzaId) +} + +// ------------------------------------------------------------------- + +// SessionStructure + +// optional uint32 sessionVersion = 1; +inline bool SessionStructure::_internal_has_sessionversion() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool SessionStructure::has_sessionversion() const { + return _internal_has_sessionversion(); +} +inline void SessionStructure::clear_sessionversion() { + _impl_.sessionversion_ = 0u; + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline uint32_t SessionStructure::_internal_sessionversion() const { + return _impl_.sessionversion_; +} +inline uint32_t SessionStructure::sessionversion() const { + // @@protoc_insertion_point(field_get:proto.SessionStructure.sessionVersion) + return _internal_sessionversion(); +} +inline void SessionStructure::_internal_set_sessionversion(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.sessionversion_ = value; +} +inline void SessionStructure::set_sessionversion(uint32_t value) { + _internal_set_sessionversion(value); + // @@protoc_insertion_point(field_set:proto.SessionStructure.sessionVersion) +} + +// optional bytes localIdentityPublic = 2; +inline bool SessionStructure::_internal_has_localidentitypublic() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SessionStructure::has_localidentitypublic() const { + return _internal_has_localidentitypublic(); +} +inline void SessionStructure::clear_localidentitypublic() { + _impl_.localidentitypublic_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& SessionStructure::localidentitypublic() const { + // @@protoc_insertion_point(field_get:proto.SessionStructure.localIdentityPublic) + return _internal_localidentitypublic(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SessionStructure::set_localidentitypublic(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.localidentitypublic_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SessionStructure.localIdentityPublic) +} +inline std::string* SessionStructure::mutable_localidentitypublic() { + std::string* _s = _internal_mutable_localidentitypublic(); + // @@protoc_insertion_point(field_mutable:proto.SessionStructure.localIdentityPublic) + return _s; +} +inline const std::string& SessionStructure::_internal_localidentitypublic() const { + return _impl_.localidentitypublic_.Get(); +} +inline void SessionStructure::_internal_set_localidentitypublic(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.localidentitypublic_.Set(value, GetArenaForAllocation()); +} +inline std::string* SessionStructure::_internal_mutable_localidentitypublic() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.localidentitypublic_.Mutable(GetArenaForAllocation()); +} +inline std::string* SessionStructure::release_localidentitypublic() { + // @@protoc_insertion_point(field_release:proto.SessionStructure.localIdentityPublic) + if (!_internal_has_localidentitypublic()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.localidentitypublic_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.localidentitypublic_.IsDefault()) { + _impl_.localidentitypublic_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SessionStructure::set_allocated_localidentitypublic(std::string* localidentitypublic) { + if (localidentitypublic != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.localidentitypublic_.SetAllocated(localidentitypublic, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.localidentitypublic_.IsDefault()) { + _impl_.localidentitypublic_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SessionStructure.localIdentityPublic) +} + +// optional bytes remoteIdentityPublic = 3; +inline bool SessionStructure::_internal_has_remoteidentitypublic() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SessionStructure::has_remoteidentitypublic() const { + return _internal_has_remoteidentitypublic(); +} +inline void SessionStructure::clear_remoteidentitypublic() { + _impl_.remoteidentitypublic_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& SessionStructure::remoteidentitypublic() const { + // @@protoc_insertion_point(field_get:proto.SessionStructure.remoteIdentityPublic) + return _internal_remoteidentitypublic(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SessionStructure::set_remoteidentitypublic(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.remoteidentitypublic_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SessionStructure.remoteIdentityPublic) +} +inline std::string* SessionStructure::mutable_remoteidentitypublic() { + std::string* _s = _internal_mutable_remoteidentitypublic(); + // @@protoc_insertion_point(field_mutable:proto.SessionStructure.remoteIdentityPublic) + return _s; +} +inline const std::string& SessionStructure::_internal_remoteidentitypublic() const { + return _impl_.remoteidentitypublic_.Get(); +} +inline void SessionStructure::_internal_set_remoteidentitypublic(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.remoteidentitypublic_.Set(value, GetArenaForAllocation()); +} +inline std::string* SessionStructure::_internal_mutable_remoteidentitypublic() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.remoteidentitypublic_.Mutable(GetArenaForAllocation()); +} +inline std::string* SessionStructure::release_remoteidentitypublic() { + // @@protoc_insertion_point(field_release:proto.SessionStructure.remoteIdentityPublic) + if (!_internal_has_remoteidentitypublic()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.remoteidentitypublic_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.remoteidentitypublic_.IsDefault()) { + _impl_.remoteidentitypublic_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SessionStructure::set_allocated_remoteidentitypublic(std::string* remoteidentitypublic) { + if (remoteidentitypublic != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.remoteidentitypublic_.SetAllocated(remoteidentitypublic, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.remoteidentitypublic_.IsDefault()) { + _impl_.remoteidentitypublic_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SessionStructure.remoteIdentityPublic) +} + +// optional bytes rootKey = 4; +inline bool SessionStructure::_internal_has_rootkey() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool SessionStructure::has_rootkey() const { + return _internal_has_rootkey(); +} +inline void SessionStructure::clear_rootkey() { + _impl_.rootkey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& SessionStructure::rootkey() const { + // @@protoc_insertion_point(field_get:proto.SessionStructure.rootKey) + return _internal_rootkey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SessionStructure::set_rootkey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.rootkey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SessionStructure.rootKey) +} +inline std::string* SessionStructure::mutable_rootkey() { + std::string* _s = _internal_mutable_rootkey(); + // @@protoc_insertion_point(field_mutable:proto.SessionStructure.rootKey) + return _s; +} +inline const std::string& SessionStructure::_internal_rootkey() const { + return _impl_.rootkey_.Get(); +} +inline void SessionStructure::_internal_set_rootkey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.rootkey_.Set(value, GetArenaForAllocation()); +} +inline std::string* SessionStructure::_internal_mutable_rootkey() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.rootkey_.Mutable(GetArenaForAllocation()); +} +inline std::string* SessionStructure::release_rootkey() { + // @@protoc_insertion_point(field_release:proto.SessionStructure.rootKey) + if (!_internal_has_rootkey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.rootkey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.rootkey_.IsDefault()) { + _impl_.rootkey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SessionStructure::set_allocated_rootkey(std::string* rootkey) { + if (rootkey != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.rootkey_.SetAllocated(rootkey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.rootkey_.IsDefault()) { + _impl_.rootkey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SessionStructure.rootKey) +} + +// optional uint32 previousCounter = 5; +inline bool SessionStructure::_internal_has_previouscounter() const { + bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool SessionStructure::has_previouscounter() const { + return _internal_has_previouscounter(); +} +inline void SessionStructure::clear_previouscounter() { + _impl_.previouscounter_ = 0u; + _impl_._has_bits_[0] &= ~0x00000100u; +} +inline uint32_t SessionStructure::_internal_previouscounter() const { + return _impl_.previouscounter_; +} +inline uint32_t SessionStructure::previouscounter() const { + // @@protoc_insertion_point(field_get:proto.SessionStructure.previousCounter) + return _internal_previouscounter(); +} +inline void SessionStructure::_internal_set_previouscounter(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.previouscounter_ = value; +} +inline void SessionStructure::set_previouscounter(uint32_t value) { + _internal_set_previouscounter(value); + // @@protoc_insertion_point(field_set:proto.SessionStructure.previousCounter) +} + +// optional .proto.Chain senderChain = 6; +inline bool SessionStructure::_internal_has_senderchain() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + PROTOBUF_ASSUME(!value || _impl_.senderchain_ != nullptr); + return value; +} +inline bool SessionStructure::has_senderchain() const { + return _internal_has_senderchain(); +} +inline void SessionStructure::clear_senderchain() { + if (_impl_.senderchain_ != nullptr) _impl_.senderchain_->Clear(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const ::proto::Chain& SessionStructure::_internal_senderchain() const { + const ::proto::Chain* p = _impl_.senderchain_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Chain_default_instance_); +} +inline const ::proto::Chain& SessionStructure::senderchain() const { + // @@protoc_insertion_point(field_get:proto.SessionStructure.senderChain) + return _internal_senderchain(); +} +inline void SessionStructure::unsafe_arena_set_allocated_senderchain( + ::proto::Chain* senderchain) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.senderchain_); + } + _impl_.senderchain_ = senderchain; + if (senderchain) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SessionStructure.senderChain) +} +inline ::proto::Chain* SessionStructure::release_senderchain() { + _impl_._has_bits_[0] &= ~0x00000010u; + ::proto::Chain* temp = _impl_.senderchain_; + _impl_.senderchain_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Chain* SessionStructure::unsafe_arena_release_senderchain() { + // @@protoc_insertion_point(field_release:proto.SessionStructure.senderChain) + _impl_._has_bits_[0] &= ~0x00000010u; + ::proto::Chain* temp = _impl_.senderchain_; + _impl_.senderchain_ = nullptr; + return temp; +} +inline ::proto::Chain* SessionStructure::_internal_mutable_senderchain() { + _impl_._has_bits_[0] |= 0x00000010u; + if (_impl_.senderchain_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Chain>(GetArenaForAllocation()); + _impl_.senderchain_ = p; + } + return _impl_.senderchain_; +} +inline ::proto::Chain* SessionStructure::mutable_senderchain() { + ::proto::Chain* _msg = _internal_mutable_senderchain(); + // @@protoc_insertion_point(field_mutable:proto.SessionStructure.senderChain) + return _msg; +} +inline void SessionStructure::set_allocated_senderchain(::proto::Chain* senderchain) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.senderchain_; + } + if (senderchain) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(senderchain); + if (message_arena != submessage_arena) { + senderchain = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, senderchain, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.senderchain_ = senderchain; + // @@protoc_insertion_point(field_set_allocated:proto.SessionStructure.senderChain) +} + +// repeated .proto.Chain receiverChains = 7; +inline int SessionStructure::_internal_receiverchains_size() const { + return _impl_.receiverchains_.size(); +} +inline int SessionStructure::receiverchains_size() const { + return _internal_receiverchains_size(); +} +inline void SessionStructure::clear_receiverchains() { + _impl_.receiverchains_.Clear(); +} +inline ::proto::Chain* SessionStructure::mutable_receiverchains(int index) { + // @@protoc_insertion_point(field_mutable:proto.SessionStructure.receiverChains) + return _impl_.receiverchains_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Chain >* +SessionStructure::mutable_receiverchains() { + // @@protoc_insertion_point(field_mutable_list:proto.SessionStructure.receiverChains) + return &_impl_.receiverchains_; +} +inline const ::proto::Chain& SessionStructure::_internal_receiverchains(int index) const { + return _impl_.receiverchains_.Get(index); +} +inline const ::proto::Chain& SessionStructure::receiverchains(int index) const { + // @@protoc_insertion_point(field_get:proto.SessionStructure.receiverChains) + return _internal_receiverchains(index); +} +inline ::proto::Chain* SessionStructure::_internal_add_receiverchains() { + return _impl_.receiverchains_.Add(); +} +inline ::proto::Chain* SessionStructure::add_receiverchains() { + ::proto::Chain* _add = _internal_add_receiverchains(); + // @@protoc_insertion_point(field_add:proto.SessionStructure.receiverChains) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Chain >& +SessionStructure::receiverchains() const { + // @@protoc_insertion_point(field_list:proto.SessionStructure.receiverChains) + return _impl_.receiverchains_; +} + +// optional .proto.PendingKeyExchange pendingKeyExchange = 8; +inline bool SessionStructure::_internal_has_pendingkeyexchange() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + PROTOBUF_ASSUME(!value || _impl_.pendingkeyexchange_ != nullptr); + return value; +} +inline bool SessionStructure::has_pendingkeyexchange() const { + return _internal_has_pendingkeyexchange(); +} +inline void SessionStructure::clear_pendingkeyexchange() { + if (_impl_.pendingkeyexchange_ != nullptr) _impl_.pendingkeyexchange_->Clear(); + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline const ::proto::PendingKeyExchange& SessionStructure::_internal_pendingkeyexchange() const { + const ::proto::PendingKeyExchange* p = _impl_.pendingkeyexchange_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_PendingKeyExchange_default_instance_); +} +inline const ::proto::PendingKeyExchange& SessionStructure::pendingkeyexchange() const { + // @@protoc_insertion_point(field_get:proto.SessionStructure.pendingKeyExchange) + return _internal_pendingkeyexchange(); +} +inline void SessionStructure::unsafe_arena_set_allocated_pendingkeyexchange( + ::proto::PendingKeyExchange* pendingkeyexchange) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pendingkeyexchange_); + } + _impl_.pendingkeyexchange_ = pendingkeyexchange; + if (pendingkeyexchange) { + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SessionStructure.pendingKeyExchange) +} +inline ::proto::PendingKeyExchange* SessionStructure::release_pendingkeyexchange() { + _impl_._has_bits_[0] &= ~0x00000020u; + ::proto::PendingKeyExchange* temp = _impl_.pendingkeyexchange_; + _impl_.pendingkeyexchange_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::PendingKeyExchange* SessionStructure::unsafe_arena_release_pendingkeyexchange() { + // @@protoc_insertion_point(field_release:proto.SessionStructure.pendingKeyExchange) + _impl_._has_bits_[0] &= ~0x00000020u; + ::proto::PendingKeyExchange* temp = _impl_.pendingkeyexchange_; + _impl_.pendingkeyexchange_ = nullptr; + return temp; +} +inline ::proto::PendingKeyExchange* SessionStructure::_internal_mutable_pendingkeyexchange() { + _impl_._has_bits_[0] |= 0x00000020u; + if (_impl_.pendingkeyexchange_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::PendingKeyExchange>(GetArenaForAllocation()); + _impl_.pendingkeyexchange_ = p; + } + return _impl_.pendingkeyexchange_; +} +inline ::proto::PendingKeyExchange* SessionStructure::mutable_pendingkeyexchange() { + ::proto::PendingKeyExchange* _msg = _internal_mutable_pendingkeyexchange(); + // @@protoc_insertion_point(field_mutable:proto.SessionStructure.pendingKeyExchange) + return _msg; +} +inline void SessionStructure::set_allocated_pendingkeyexchange(::proto::PendingKeyExchange* pendingkeyexchange) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.pendingkeyexchange_; + } + if (pendingkeyexchange) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pendingkeyexchange); + if (message_arena != submessage_arena) { + pendingkeyexchange = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, pendingkeyexchange, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + _impl_.pendingkeyexchange_ = pendingkeyexchange; + // @@protoc_insertion_point(field_set_allocated:proto.SessionStructure.pendingKeyExchange) +} + +// optional .proto.PendingPreKey pendingPreKey = 9; +inline bool SessionStructure::_internal_has_pendingprekey() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + PROTOBUF_ASSUME(!value || _impl_.pendingprekey_ != nullptr); + return value; +} +inline bool SessionStructure::has_pendingprekey() const { + return _internal_has_pendingprekey(); +} +inline void SessionStructure::clear_pendingprekey() { + if (_impl_.pendingprekey_ != nullptr) _impl_.pendingprekey_->Clear(); + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline const ::proto::PendingPreKey& SessionStructure::_internal_pendingprekey() const { + const ::proto::PendingPreKey* p = _impl_.pendingprekey_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_PendingPreKey_default_instance_); +} +inline const ::proto::PendingPreKey& SessionStructure::pendingprekey() const { + // @@protoc_insertion_point(field_get:proto.SessionStructure.pendingPreKey) + return _internal_pendingprekey(); +} +inline void SessionStructure::unsafe_arena_set_allocated_pendingprekey( + ::proto::PendingPreKey* pendingprekey) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pendingprekey_); + } + _impl_.pendingprekey_ = pendingprekey; + if (pendingprekey) { + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SessionStructure.pendingPreKey) +} +inline ::proto::PendingPreKey* SessionStructure::release_pendingprekey() { + _impl_._has_bits_[0] &= ~0x00000040u; + ::proto::PendingPreKey* temp = _impl_.pendingprekey_; + _impl_.pendingprekey_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::PendingPreKey* SessionStructure::unsafe_arena_release_pendingprekey() { + // @@protoc_insertion_point(field_release:proto.SessionStructure.pendingPreKey) + _impl_._has_bits_[0] &= ~0x00000040u; + ::proto::PendingPreKey* temp = _impl_.pendingprekey_; + _impl_.pendingprekey_ = nullptr; + return temp; +} +inline ::proto::PendingPreKey* SessionStructure::_internal_mutable_pendingprekey() { + _impl_._has_bits_[0] |= 0x00000040u; + if (_impl_.pendingprekey_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::PendingPreKey>(GetArenaForAllocation()); + _impl_.pendingprekey_ = p; + } + return _impl_.pendingprekey_; +} +inline ::proto::PendingPreKey* SessionStructure::mutable_pendingprekey() { + ::proto::PendingPreKey* _msg = _internal_mutable_pendingprekey(); + // @@protoc_insertion_point(field_mutable:proto.SessionStructure.pendingPreKey) + return _msg; +} +inline void SessionStructure::set_allocated_pendingprekey(::proto::PendingPreKey* pendingprekey) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.pendingprekey_; + } + if (pendingprekey) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pendingprekey); + if (message_arena != submessage_arena) { + pendingprekey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, pendingprekey, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + _impl_.pendingprekey_ = pendingprekey; + // @@protoc_insertion_point(field_set_allocated:proto.SessionStructure.pendingPreKey) +} + +// optional uint32 remoteRegistrationId = 10; +inline bool SessionStructure::_internal_has_remoteregistrationid() const { + bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool SessionStructure::has_remoteregistrationid() const { + return _internal_has_remoteregistrationid(); +} +inline void SessionStructure::clear_remoteregistrationid() { + _impl_.remoteregistrationid_ = 0u; + _impl_._has_bits_[0] &= ~0x00000200u; +} +inline uint32_t SessionStructure::_internal_remoteregistrationid() const { + return _impl_.remoteregistrationid_; +} +inline uint32_t SessionStructure::remoteregistrationid() const { + // @@protoc_insertion_point(field_get:proto.SessionStructure.remoteRegistrationId) + return _internal_remoteregistrationid(); +} +inline void SessionStructure::_internal_set_remoteregistrationid(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.remoteregistrationid_ = value; +} +inline void SessionStructure::set_remoteregistrationid(uint32_t value) { + _internal_set_remoteregistrationid(value); + // @@protoc_insertion_point(field_set:proto.SessionStructure.remoteRegistrationId) +} + +// optional uint32 localRegistrationId = 11; +inline bool SessionStructure::_internal_has_localregistrationid() const { + bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool SessionStructure::has_localregistrationid() const { + return _internal_has_localregistrationid(); +} +inline void SessionStructure::clear_localregistrationid() { + _impl_.localregistrationid_ = 0u; + _impl_._has_bits_[0] &= ~0x00000400u; +} +inline uint32_t SessionStructure::_internal_localregistrationid() const { + return _impl_.localregistrationid_; +} +inline uint32_t SessionStructure::localregistrationid() const { + // @@protoc_insertion_point(field_get:proto.SessionStructure.localRegistrationId) + return _internal_localregistrationid(); +} +inline void SessionStructure::_internal_set_localregistrationid(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000400u; + _impl_.localregistrationid_ = value; +} +inline void SessionStructure::set_localregistrationid(uint32_t value) { + _internal_set_localregistrationid(value); + // @@protoc_insertion_point(field_set:proto.SessionStructure.localRegistrationId) +} + +// optional bool needsRefresh = 12; +inline bool SessionStructure::_internal_has_needsrefresh() const { + bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; + return value; +} +inline bool SessionStructure::has_needsrefresh() const { + return _internal_has_needsrefresh(); +} +inline void SessionStructure::clear_needsrefresh() { + _impl_.needsrefresh_ = false; + _impl_._has_bits_[0] &= ~0x00000800u; +} +inline bool SessionStructure::_internal_needsrefresh() const { + return _impl_.needsrefresh_; +} +inline bool SessionStructure::needsrefresh() const { + // @@protoc_insertion_point(field_get:proto.SessionStructure.needsRefresh) + return _internal_needsrefresh(); +} +inline void SessionStructure::_internal_set_needsrefresh(bool value) { + _impl_._has_bits_[0] |= 0x00000800u; + _impl_.needsrefresh_ = value; +} +inline void SessionStructure::set_needsrefresh(bool value) { + _internal_set_needsrefresh(value); + // @@protoc_insertion_point(field_set:proto.SessionStructure.needsRefresh) +} + +// optional bytes aliceBaseKey = 13; +inline bool SessionStructure::_internal_has_alicebasekey() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool SessionStructure::has_alicebasekey() const { + return _internal_has_alicebasekey(); +} +inline void SessionStructure::clear_alicebasekey() { + _impl_.alicebasekey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const std::string& SessionStructure::alicebasekey() const { + // @@protoc_insertion_point(field_get:proto.SessionStructure.aliceBaseKey) + return _internal_alicebasekey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SessionStructure::set_alicebasekey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.alicebasekey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SessionStructure.aliceBaseKey) +} +inline std::string* SessionStructure::mutable_alicebasekey() { + std::string* _s = _internal_mutable_alicebasekey(); + // @@protoc_insertion_point(field_mutable:proto.SessionStructure.aliceBaseKey) + return _s; +} +inline const std::string& SessionStructure::_internal_alicebasekey() const { + return _impl_.alicebasekey_.Get(); +} +inline void SessionStructure::_internal_set_alicebasekey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.alicebasekey_.Set(value, GetArenaForAllocation()); +} +inline std::string* SessionStructure::_internal_mutable_alicebasekey() { + _impl_._has_bits_[0] |= 0x00000008u; + return _impl_.alicebasekey_.Mutable(GetArenaForAllocation()); +} +inline std::string* SessionStructure::release_alicebasekey() { + // @@protoc_insertion_point(field_release:proto.SessionStructure.aliceBaseKey) + if (!_internal_has_alicebasekey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000008u; + auto* p = _impl_.alicebasekey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.alicebasekey_.IsDefault()) { + _impl_.alicebasekey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SessionStructure::set_allocated_alicebasekey(std::string* alicebasekey) { + if (alicebasekey != nullptr) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.alicebasekey_.SetAllocated(alicebasekey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.alicebasekey_.IsDefault()) { + _impl_.alicebasekey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SessionStructure.aliceBaseKey) +} + +// ------------------------------------------------------------------- + +// SignedPreKeyRecordStructure + +// optional uint32 id = 1; +inline bool SignedPreKeyRecordStructure::_internal_has_id() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool SignedPreKeyRecordStructure::has_id() const { + return _internal_has_id(); +} +inline void SignedPreKeyRecordStructure::clear_id() { + _impl_.id_ = 0u; + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline uint32_t SignedPreKeyRecordStructure::_internal_id() const { + return _impl_.id_; +} +inline uint32_t SignedPreKeyRecordStructure::id() const { + // @@protoc_insertion_point(field_get:proto.SignedPreKeyRecordStructure.id) + return _internal_id(); +} +inline void SignedPreKeyRecordStructure::_internal_set_id(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.id_ = value; +} +inline void SignedPreKeyRecordStructure::set_id(uint32_t value) { + _internal_set_id(value); + // @@protoc_insertion_point(field_set:proto.SignedPreKeyRecordStructure.id) +} + +// optional bytes publicKey = 2; +inline bool SignedPreKeyRecordStructure::_internal_has_publickey() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SignedPreKeyRecordStructure::has_publickey() const { + return _internal_has_publickey(); +} +inline void SignedPreKeyRecordStructure::clear_publickey() { + _impl_.publickey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& SignedPreKeyRecordStructure::publickey() const { + // @@protoc_insertion_point(field_get:proto.SignedPreKeyRecordStructure.publicKey) + return _internal_publickey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SignedPreKeyRecordStructure::set_publickey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.publickey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SignedPreKeyRecordStructure.publicKey) +} +inline std::string* SignedPreKeyRecordStructure::mutable_publickey() { + std::string* _s = _internal_mutable_publickey(); + // @@protoc_insertion_point(field_mutable:proto.SignedPreKeyRecordStructure.publicKey) + return _s; +} +inline const std::string& SignedPreKeyRecordStructure::_internal_publickey() const { + return _impl_.publickey_.Get(); +} +inline void SignedPreKeyRecordStructure::_internal_set_publickey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.publickey_.Set(value, GetArenaForAllocation()); +} +inline std::string* SignedPreKeyRecordStructure::_internal_mutable_publickey() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.publickey_.Mutable(GetArenaForAllocation()); +} +inline std::string* SignedPreKeyRecordStructure::release_publickey() { + // @@protoc_insertion_point(field_release:proto.SignedPreKeyRecordStructure.publicKey) + if (!_internal_has_publickey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.publickey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.publickey_.IsDefault()) { + _impl_.publickey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SignedPreKeyRecordStructure::set_allocated_publickey(std::string* publickey) { + if (publickey != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.publickey_.SetAllocated(publickey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.publickey_.IsDefault()) { + _impl_.publickey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SignedPreKeyRecordStructure.publicKey) +} + +// optional bytes privateKey = 3; +inline bool SignedPreKeyRecordStructure::_internal_has_privatekey() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SignedPreKeyRecordStructure::has_privatekey() const { + return _internal_has_privatekey(); +} +inline void SignedPreKeyRecordStructure::clear_privatekey() { + _impl_.privatekey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& SignedPreKeyRecordStructure::privatekey() const { + // @@protoc_insertion_point(field_get:proto.SignedPreKeyRecordStructure.privateKey) + return _internal_privatekey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SignedPreKeyRecordStructure::set_privatekey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.privatekey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SignedPreKeyRecordStructure.privateKey) +} +inline std::string* SignedPreKeyRecordStructure::mutable_privatekey() { + std::string* _s = _internal_mutable_privatekey(); + // @@protoc_insertion_point(field_mutable:proto.SignedPreKeyRecordStructure.privateKey) + return _s; +} +inline const std::string& SignedPreKeyRecordStructure::_internal_privatekey() const { + return _impl_.privatekey_.Get(); +} +inline void SignedPreKeyRecordStructure::_internal_set_privatekey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.privatekey_.Set(value, GetArenaForAllocation()); +} +inline std::string* SignedPreKeyRecordStructure::_internal_mutable_privatekey() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.privatekey_.Mutable(GetArenaForAllocation()); +} +inline std::string* SignedPreKeyRecordStructure::release_privatekey() { + // @@protoc_insertion_point(field_release:proto.SignedPreKeyRecordStructure.privateKey) + if (!_internal_has_privatekey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.privatekey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.privatekey_.IsDefault()) { + _impl_.privatekey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SignedPreKeyRecordStructure::set_allocated_privatekey(std::string* privatekey) { + if (privatekey != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.privatekey_.SetAllocated(privatekey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.privatekey_.IsDefault()) { + _impl_.privatekey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SignedPreKeyRecordStructure.privateKey) +} + +// optional bytes signature = 4; +inline bool SignedPreKeyRecordStructure::_internal_has_signature() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool SignedPreKeyRecordStructure::has_signature() const { + return _internal_has_signature(); +} +inline void SignedPreKeyRecordStructure::clear_signature() { + _impl_.signature_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& SignedPreKeyRecordStructure::signature() const { + // @@protoc_insertion_point(field_get:proto.SignedPreKeyRecordStructure.signature) + return _internal_signature(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SignedPreKeyRecordStructure::set_signature(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.signature_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SignedPreKeyRecordStructure.signature) +} +inline std::string* SignedPreKeyRecordStructure::mutable_signature() { + std::string* _s = _internal_mutable_signature(); + // @@protoc_insertion_point(field_mutable:proto.SignedPreKeyRecordStructure.signature) + return _s; +} +inline const std::string& SignedPreKeyRecordStructure::_internal_signature() const { + return _impl_.signature_.Get(); +} +inline void SignedPreKeyRecordStructure::_internal_set_signature(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.signature_.Set(value, GetArenaForAllocation()); +} +inline std::string* SignedPreKeyRecordStructure::_internal_mutable_signature() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.signature_.Mutable(GetArenaForAllocation()); +} +inline std::string* SignedPreKeyRecordStructure::release_signature() { + // @@protoc_insertion_point(field_release:proto.SignedPreKeyRecordStructure.signature) + if (!_internal_has_signature()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.signature_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.signature_.IsDefault()) { + _impl_.signature_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SignedPreKeyRecordStructure::set_allocated_signature(std::string* signature) { + if (signature != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.signature_.SetAllocated(signature, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.signature_.IsDefault()) { + _impl_.signature_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SignedPreKeyRecordStructure.signature) +} + +// optional fixed64 timestamp = 5; +inline bool SignedPreKeyRecordStructure::_internal_has_timestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool SignedPreKeyRecordStructure::has_timestamp() const { + return _internal_has_timestamp(); +} +inline void SignedPreKeyRecordStructure::clear_timestamp() { + _impl_.timestamp_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline uint64_t SignedPreKeyRecordStructure::_internal_timestamp() const { + return _impl_.timestamp_; +} +inline uint64_t SignedPreKeyRecordStructure::timestamp() const { + // @@protoc_insertion_point(field_get:proto.SignedPreKeyRecordStructure.timestamp) + return _internal_timestamp(); +} +inline void SignedPreKeyRecordStructure::_internal_set_timestamp(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.timestamp_ = value; +} +inline void SignedPreKeyRecordStructure::set_timestamp(uint64_t value) { + _internal_set_timestamp(value); + // @@protoc_insertion_point(field_set:proto.SignedPreKeyRecordStructure.timestamp) +} + +// ------------------------------------------------------------------- + +// StatusPSA + +// required uint64 campaignId = 44; +inline bool StatusPSA::_internal_has_campaignid() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool StatusPSA::has_campaignid() const { + return _internal_has_campaignid(); +} +inline void StatusPSA::clear_campaignid() { + _impl_.campaignid_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline uint64_t StatusPSA::_internal_campaignid() const { + return _impl_.campaignid_; +} +inline uint64_t StatusPSA::campaignid() const { + // @@protoc_insertion_point(field_get:proto.StatusPSA.campaignId) + return _internal_campaignid(); +} +inline void StatusPSA::_internal_set_campaignid(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.campaignid_ = value; +} +inline void StatusPSA::set_campaignid(uint64_t value) { + _internal_set_campaignid(value); + // @@protoc_insertion_point(field_set:proto.StatusPSA.campaignId) +} + +// optional uint64 campaignExpirationTimestamp = 45; +inline bool StatusPSA::_internal_has_campaignexpirationtimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool StatusPSA::has_campaignexpirationtimestamp() const { + return _internal_has_campaignexpirationtimestamp(); +} +inline void StatusPSA::clear_campaignexpirationtimestamp() { + _impl_.campaignexpirationtimestamp_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline uint64_t StatusPSA::_internal_campaignexpirationtimestamp() const { + return _impl_.campaignexpirationtimestamp_; +} +inline uint64_t StatusPSA::campaignexpirationtimestamp() const { + // @@protoc_insertion_point(field_get:proto.StatusPSA.campaignExpirationTimestamp) + return _internal_campaignexpirationtimestamp(); +} +inline void StatusPSA::_internal_set_campaignexpirationtimestamp(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.campaignexpirationtimestamp_ = value; +} +inline void StatusPSA::set_campaignexpirationtimestamp(uint64_t value) { + _internal_set_campaignexpirationtimestamp(value); + // @@protoc_insertion_point(field_set:proto.StatusPSA.campaignExpirationTimestamp) +} + +// ------------------------------------------------------------------- + +// StickerMetadata + +// optional string url = 1; +inline bool StickerMetadata::_internal_has_url() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool StickerMetadata::has_url() const { + return _internal_has_url(); +} +inline void StickerMetadata::clear_url() { + _impl_.url_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& StickerMetadata::url() const { + // @@protoc_insertion_point(field_get:proto.StickerMetadata.url) + return _internal_url(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void StickerMetadata::set_url(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.url_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.StickerMetadata.url) +} +inline std::string* StickerMetadata::mutable_url() { + std::string* _s = _internal_mutable_url(); + // @@protoc_insertion_point(field_mutable:proto.StickerMetadata.url) + return _s; +} +inline const std::string& StickerMetadata::_internal_url() const { + return _impl_.url_.Get(); +} +inline void StickerMetadata::_internal_set_url(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.url_.Set(value, GetArenaForAllocation()); +} +inline std::string* StickerMetadata::_internal_mutable_url() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.url_.Mutable(GetArenaForAllocation()); +} +inline std::string* StickerMetadata::release_url() { + // @@protoc_insertion_point(field_release:proto.StickerMetadata.url) + if (!_internal_has_url()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.url_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.url_.IsDefault()) { + _impl_.url_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void StickerMetadata::set_allocated_url(std::string* url) { + if (url != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.url_.SetAllocated(url, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.url_.IsDefault()) { + _impl_.url_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.StickerMetadata.url) +} + +// optional bytes fileSha256 = 2; +inline bool StickerMetadata::_internal_has_filesha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool StickerMetadata::has_filesha256() const { + return _internal_has_filesha256(); +} +inline void StickerMetadata::clear_filesha256() { + _impl_.filesha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& StickerMetadata::filesha256() const { + // @@protoc_insertion_point(field_get:proto.StickerMetadata.fileSha256) + return _internal_filesha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void StickerMetadata::set_filesha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.filesha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.StickerMetadata.fileSha256) +} +inline std::string* StickerMetadata::mutable_filesha256() { + std::string* _s = _internal_mutable_filesha256(); + // @@protoc_insertion_point(field_mutable:proto.StickerMetadata.fileSha256) + return _s; +} +inline const std::string& StickerMetadata::_internal_filesha256() const { + return _impl_.filesha256_.Get(); +} +inline void StickerMetadata::_internal_set_filesha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.filesha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* StickerMetadata::_internal_mutable_filesha256() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.filesha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* StickerMetadata::release_filesha256() { + // @@protoc_insertion_point(field_release:proto.StickerMetadata.fileSha256) + if (!_internal_has_filesha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.filesha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.filesha256_.IsDefault()) { + _impl_.filesha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void StickerMetadata::set_allocated_filesha256(std::string* filesha256) { + if (filesha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.filesha256_.IsDefault()) { + _impl_.filesha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.StickerMetadata.fileSha256) +} + +// optional bytes fileEncSha256 = 3; +inline bool StickerMetadata::_internal_has_fileencsha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool StickerMetadata::has_fileencsha256() const { + return _internal_has_fileencsha256(); +} +inline void StickerMetadata::clear_fileencsha256() { + _impl_.fileencsha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& StickerMetadata::fileencsha256() const { + // @@protoc_insertion_point(field_get:proto.StickerMetadata.fileEncSha256) + return _internal_fileencsha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void StickerMetadata::set_fileencsha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.fileencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.StickerMetadata.fileEncSha256) +} +inline std::string* StickerMetadata::mutable_fileencsha256() { + std::string* _s = _internal_mutable_fileencsha256(); + // @@protoc_insertion_point(field_mutable:proto.StickerMetadata.fileEncSha256) + return _s; +} +inline const std::string& StickerMetadata::_internal_fileencsha256() const { + return _impl_.fileencsha256_.Get(); +} +inline void StickerMetadata::_internal_set_fileencsha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.fileencsha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* StickerMetadata::_internal_mutable_fileencsha256() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.fileencsha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* StickerMetadata::release_fileencsha256() { + // @@protoc_insertion_point(field_release:proto.StickerMetadata.fileEncSha256) + if (!_internal_has_fileencsha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.fileencsha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fileencsha256_.IsDefault()) { + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void StickerMetadata::set_allocated_fileencsha256(std::string* fileencsha256) { + if (fileencsha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fileencsha256_.IsDefault()) { + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.StickerMetadata.fileEncSha256) +} + +// optional bytes mediaKey = 4; +inline bool StickerMetadata::_internal_has_mediakey() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool StickerMetadata::has_mediakey() const { + return _internal_has_mediakey(); +} +inline void StickerMetadata::clear_mediakey() { + _impl_.mediakey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const std::string& StickerMetadata::mediakey() const { + // @@protoc_insertion_point(field_get:proto.StickerMetadata.mediaKey) + return _internal_mediakey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void StickerMetadata::set_mediakey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.mediakey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.StickerMetadata.mediaKey) +} +inline std::string* StickerMetadata::mutable_mediakey() { + std::string* _s = _internal_mutable_mediakey(); + // @@protoc_insertion_point(field_mutable:proto.StickerMetadata.mediaKey) + return _s; +} +inline const std::string& StickerMetadata::_internal_mediakey() const { + return _impl_.mediakey_.Get(); +} +inline void StickerMetadata::_internal_set_mediakey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.mediakey_.Set(value, GetArenaForAllocation()); +} +inline std::string* StickerMetadata::_internal_mutable_mediakey() { + _impl_._has_bits_[0] |= 0x00000008u; + return _impl_.mediakey_.Mutable(GetArenaForAllocation()); +} +inline std::string* StickerMetadata::release_mediakey() { + // @@protoc_insertion_point(field_release:proto.StickerMetadata.mediaKey) + if (!_internal_has_mediakey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000008u; + auto* p = _impl_.mediakey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mediakey_.IsDefault()) { + _impl_.mediakey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void StickerMetadata::set_allocated_mediakey(std::string* mediakey) { + if (mediakey != nullptr) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mediakey_.IsDefault()) { + _impl_.mediakey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.StickerMetadata.mediaKey) +} + +// optional string mimetype = 5; +inline bool StickerMetadata::_internal_has_mimetype() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool StickerMetadata::has_mimetype() const { + return _internal_has_mimetype(); +} +inline void StickerMetadata::clear_mimetype() { + _impl_.mimetype_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const std::string& StickerMetadata::mimetype() const { + // @@protoc_insertion_point(field_get:proto.StickerMetadata.mimetype) + return _internal_mimetype(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void StickerMetadata::set_mimetype(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.mimetype_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.StickerMetadata.mimetype) +} +inline std::string* StickerMetadata::mutable_mimetype() { + std::string* _s = _internal_mutable_mimetype(); + // @@protoc_insertion_point(field_mutable:proto.StickerMetadata.mimetype) + return _s; +} +inline const std::string& StickerMetadata::_internal_mimetype() const { + return _impl_.mimetype_.Get(); +} +inline void StickerMetadata::_internal_set_mimetype(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.mimetype_.Set(value, GetArenaForAllocation()); +} +inline std::string* StickerMetadata::_internal_mutable_mimetype() { + _impl_._has_bits_[0] |= 0x00000010u; + return _impl_.mimetype_.Mutable(GetArenaForAllocation()); +} +inline std::string* StickerMetadata::release_mimetype() { + // @@protoc_insertion_point(field_release:proto.StickerMetadata.mimetype) + if (!_internal_has_mimetype()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000010u; + auto* p = _impl_.mimetype_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mimetype_.IsDefault()) { + _impl_.mimetype_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void StickerMetadata::set_allocated_mimetype(std::string* mimetype) { + if (mimetype != nullptr) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mimetype_.IsDefault()) { + _impl_.mimetype_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.StickerMetadata.mimetype) +} + +// optional uint32 height = 6; +inline bool StickerMetadata::_internal_has_height() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool StickerMetadata::has_height() const { + return _internal_has_height(); +} +inline void StickerMetadata::clear_height() { + _impl_.height_ = 0u; + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline uint32_t StickerMetadata::_internal_height() const { + return _impl_.height_; +} +inline uint32_t StickerMetadata::height() const { + // @@protoc_insertion_point(field_get:proto.StickerMetadata.height) + return _internal_height(); +} +inline void StickerMetadata::_internal_set_height(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.height_ = value; +} +inline void StickerMetadata::set_height(uint32_t value) { + _internal_set_height(value); + // @@protoc_insertion_point(field_set:proto.StickerMetadata.height) +} + +// optional uint32 width = 7; +inline bool StickerMetadata::_internal_has_width() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool StickerMetadata::has_width() const { + return _internal_has_width(); +} +inline void StickerMetadata::clear_width() { + _impl_.width_ = 0u; + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline uint32_t StickerMetadata::_internal_width() const { + return _impl_.width_; +} +inline uint32_t StickerMetadata::width() const { + // @@protoc_insertion_point(field_get:proto.StickerMetadata.width) + return _internal_width(); +} +inline void StickerMetadata::_internal_set_width(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.width_ = value; +} +inline void StickerMetadata::set_width(uint32_t value) { + _internal_set_width(value); + // @@protoc_insertion_point(field_set:proto.StickerMetadata.width) +} + +// optional string directPath = 8; +inline bool StickerMetadata::_internal_has_directpath() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool StickerMetadata::has_directpath() const { + return _internal_has_directpath(); +} +inline void StickerMetadata::clear_directpath() { + _impl_.directpath_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline const std::string& StickerMetadata::directpath() const { + // @@protoc_insertion_point(field_get:proto.StickerMetadata.directPath) + return _internal_directpath(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void StickerMetadata::set_directpath(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.directpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.StickerMetadata.directPath) +} +inline std::string* StickerMetadata::mutable_directpath() { + std::string* _s = _internal_mutable_directpath(); + // @@protoc_insertion_point(field_mutable:proto.StickerMetadata.directPath) + return _s; +} +inline const std::string& StickerMetadata::_internal_directpath() const { + return _impl_.directpath_.Get(); +} +inline void StickerMetadata::_internal_set_directpath(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.directpath_.Set(value, GetArenaForAllocation()); +} +inline std::string* StickerMetadata::_internal_mutable_directpath() { + _impl_._has_bits_[0] |= 0x00000020u; + return _impl_.directpath_.Mutable(GetArenaForAllocation()); +} +inline std::string* StickerMetadata::release_directpath() { + // @@protoc_insertion_point(field_release:proto.StickerMetadata.directPath) + if (!_internal_has_directpath()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000020u; + auto* p = _impl_.directpath_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.directpath_.IsDefault()) { + _impl_.directpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void StickerMetadata::set_allocated_directpath(std::string* directpath) { + if (directpath != nullptr) { + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.directpath_.IsDefault()) { + _impl_.directpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.StickerMetadata.directPath) +} + +// optional uint64 fileLength = 9; +inline bool StickerMetadata::_internal_has_filelength() const { + bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool StickerMetadata::has_filelength() const { + return _internal_has_filelength(); +} +inline void StickerMetadata::clear_filelength() { + _impl_.filelength_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000100u; +} +inline uint64_t StickerMetadata::_internal_filelength() const { + return _impl_.filelength_; +} +inline uint64_t StickerMetadata::filelength() const { + // @@protoc_insertion_point(field_get:proto.StickerMetadata.fileLength) + return _internal_filelength(); +} +inline void StickerMetadata::_internal_set_filelength(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.filelength_ = value; +} +inline void StickerMetadata::set_filelength(uint64_t value) { + _internal_set_filelength(value); + // @@protoc_insertion_point(field_set:proto.StickerMetadata.fileLength) +} + +// optional float weight = 10; +inline bool StickerMetadata::_internal_has_weight() const { + bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool StickerMetadata::has_weight() const { + return _internal_has_weight(); +} +inline void StickerMetadata::clear_weight() { + _impl_.weight_ = 0; + _impl_._has_bits_[0] &= ~0x00000200u; +} +inline float StickerMetadata::_internal_weight() const { + return _impl_.weight_; +} +inline float StickerMetadata::weight() const { + // @@protoc_insertion_point(field_get:proto.StickerMetadata.weight) + return _internal_weight(); +} +inline void StickerMetadata::_internal_set_weight(float value) { + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.weight_ = value; +} +inline void StickerMetadata::set_weight(float value) { + _internal_set_weight(value); + // @@protoc_insertion_point(field_set:proto.StickerMetadata.weight) +} + +// ------------------------------------------------------------------- + +// SyncActionData + +// optional bytes index = 1; +inline bool SyncActionData::_internal_has_index() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SyncActionData::has_index() const { + return _internal_has_index(); +} +inline void SyncActionData::clear_index() { + _impl_.index_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& SyncActionData::index() const { + // @@protoc_insertion_point(field_get:proto.SyncActionData.index) + return _internal_index(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SyncActionData::set_index(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.index_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SyncActionData.index) +} +inline std::string* SyncActionData::mutable_index() { + std::string* _s = _internal_mutable_index(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionData.index) + return _s; +} +inline const std::string& SyncActionData::_internal_index() const { + return _impl_.index_.Get(); +} +inline void SyncActionData::_internal_set_index(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.index_.Set(value, GetArenaForAllocation()); +} +inline std::string* SyncActionData::_internal_mutable_index() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.index_.Mutable(GetArenaForAllocation()); +} +inline std::string* SyncActionData::release_index() { + // @@protoc_insertion_point(field_release:proto.SyncActionData.index) + if (!_internal_has_index()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.index_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.index_.IsDefault()) { + _impl_.index_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SyncActionData::set_allocated_index(std::string* index) { + if (index != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.index_.SetAllocated(index, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.index_.IsDefault()) { + _impl_.index_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionData.index) +} + +// optional .proto.SyncActionValue value = 2; +inline bool SyncActionData::_internal_has_value() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.value_ != nullptr); + return value; +} +inline bool SyncActionData::has_value() const { + return _internal_has_value(); +} +inline void SyncActionData::clear_value() { + if (_impl_.value_ != nullptr) _impl_.value_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::proto::SyncActionValue& SyncActionData::_internal_value() const { + const ::proto::SyncActionValue* p = _impl_.value_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_default_instance_); +} +inline const ::proto::SyncActionValue& SyncActionData::value() const { + // @@protoc_insertion_point(field_get:proto.SyncActionData.value) + return _internal_value(); +} +inline void SyncActionData::unsafe_arena_set_allocated_value( + ::proto::SyncActionValue* value) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.value_); + } + _impl_.value_ = value; + if (value) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionData.value) +} +inline ::proto::SyncActionValue* SyncActionData::release_value() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::SyncActionValue* temp = _impl_.value_; + _impl_.value_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue* SyncActionData::unsafe_arena_release_value() { + // @@protoc_insertion_point(field_release:proto.SyncActionData.value) + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::SyncActionValue* temp = _impl_.value_; + _impl_.value_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue* SyncActionData::_internal_mutable_value() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.value_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue>(GetArenaForAllocation()); + _impl_.value_ = p; + } + return _impl_.value_; +} +inline ::proto::SyncActionValue* SyncActionData::mutable_value() { + ::proto::SyncActionValue* _msg = _internal_mutable_value(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionData.value) + return _msg; +} +inline void SyncActionData::set_allocated_value(::proto::SyncActionValue* value) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.value_; + } + if (value) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(value); + if (message_arena != submessage_arena) { + value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.value_ = value; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionData.value) +} + +// optional bytes padding = 3; +inline bool SyncActionData::_internal_has_padding() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SyncActionData::has_padding() const { + return _internal_has_padding(); +} +inline void SyncActionData::clear_padding() { + _impl_.padding_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& SyncActionData::padding() const { + // @@protoc_insertion_point(field_get:proto.SyncActionData.padding) + return _internal_padding(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SyncActionData::set_padding(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.padding_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SyncActionData.padding) +} +inline std::string* SyncActionData::mutable_padding() { + std::string* _s = _internal_mutable_padding(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionData.padding) + return _s; +} +inline const std::string& SyncActionData::_internal_padding() const { + return _impl_.padding_.Get(); +} +inline void SyncActionData::_internal_set_padding(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.padding_.Set(value, GetArenaForAllocation()); +} +inline std::string* SyncActionData::_internal_mutable_padding() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.padding_.Mutable(GetArenaForAllocation()); +} +inline std::string* SyncActionData::release_padding() { + // @@protoc_insertion_point(field_release:proto.SyncActionData.padding) + if (!_internal_has_padding()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.padding_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.padding_.IsDefault()) { + _impl_.padding_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SyncActionData::set_allocated_padding(std::string* padding) { + if (padding != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.padding_.SetAllocated(padding, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.padding_.IsDefault()) { + _impl_.padding_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionData.padding) +} + +// optional int32 version = 4; +inline bool SyncActionData::_internal_has_version() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool SyncActionData::has_version() const { + return _internal_has_version(); +} +inline void SyncActionData::clear_version() { + _impl_.version_ = 0; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline int32_t SyncActionData::_internal_version() const { + return _impl_.version_; +} +inline int32_t SyncActionData::version() const { + // @@protoc_insertion_point(field_get:proto.SyncActionData.version) + return _internal_version(); +} +inline void SyncActionData::_internal_set_version(int32_t value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.version_ = value; +} +inline void SyncActionData::set_version(int32_t value) { + _internal_set_version(value); + // @@protoc_insertion_point(field_set:proto.SyncActionData.version) +} + +// ------------------------------------------------------------------- + +// SyncActionValue_AgentAction + +// optional string name = 1; +inline bool SyncActionValue_AgentAction::_internal_has_name() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SyncActionValue_AgentAction::has_name() const { + return _internal_has_name(); +} +inline void SyncActionValue_AgentAction::clear_name() { + _impl_.name_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& SyncActionValue_AgentAction::name() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.AgentAction.name) + return _internal_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SyncActionValue_AgentAction::set_name(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.AgentAction.name) +} +inline std::string* SyncActionValue_AgentAction::mutable_name() { + std::string* _s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.AgentAction.name) + return _s; +} +inline const std::string& SyncActionValue_AgentAction::_internal_name() const { + return _impl_.name_.Get(); +} +inline void SyncActionValue_AgentAction::_internal_set_name(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.name_.Set(value, GetArenaForAllocation()); +} +inline std::string* SyncActionValue_AgentAction::_internal_mutable_name() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.name_.Mutable(GetArenaForAllocation()); +} +inline std::string* SyncActionValue_AgentAction::release_name() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.AgentAction.name) + if (!_internal_has_name()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.name_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.name_.IsDefault()) { + _impl_.name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SyncActionValue_AgentAction::set_allocated_name(std::string* name) { + if (name != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.name_.SetAllocated(name, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.name_.IsDefault()) { + _impl_.name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.AgentAction.name) +} + +// optional int32 deviceID = 2; +inline bool SyncActionValue_AgentAction::_internal_has_deviceid() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SyncActionValue_AgentAction::has_deviceid() const { + return _internal_has_deviceid(); +} +inline void SyncActionValue_AgentAction::clear_deviceid() { + _impl_.deviceid_ = 0; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline int32_t SyncActionValue_AgentAction::_internal_deviceid() const { + return _impl_.deviceid_; +} +inline int32_t SyncActionValue_AgentAction::deviceid() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.AgentAction.deviceID) + return _internal_deviceid(); +} +inline void SyncActionValue_AgentAction::_internal_set_deviceid(int32_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.deviceid_ = value; +} +inline void SyncActionValue_AgentAction::set_deviceid(int32_t value) { + _internal_set_deviceid(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.AgentAction.deviceID) +} + +// optional bool isDeleted = 3; +inline bool SyncActionValue_AgentAction::_internal_has_isdeleted() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool SyncActionValue_AgentAction::has_isdeleted() const { + return _internal_has_isdeleted(); +} +inline void SyncActionValue_AgentAction::clear_isdeleted() { + _impl_.isdeleted_ = false; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline bool SyncActionValue_AgentAction::_internal_isdeleted() const { + return _impl_.isdeleted_; +} +inline bool SyncActionValue_AgentAction::isdeleted() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.AgentAction.isDeleted) + return _internal_isdeleted(); +} +inline void SyncActionValue_AgentAction::_internal_set_isdeleted(bool value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.isdeleted_ = value; +} +inline void SyncActionValue_AgentAction::set_isdeleted(bool value) { + _internal_set_isdeleted(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.AgentAction.isDeleted) +} + +// ------------------------------------------------------------------- + +// SyncActionValue_AndroidUnsupportedActions + +// optional bool allowed = 1; +inline bool SyncActionValue_AndroidUnsupportedActions::_internal_has_allowed() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SyncActionValue_AndroidUnsupportedActions::has_allowed() const { + return _internal_has_allowed(); +} +inline void SyncActionValue_AndroidUnsupportedActions::clear_allowed() { + _impl_.allowed_ = false; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline bool SyncActionValue_AndroidUnsupportedActions::_internal_allowed() const { + return _impl_.allowed_; +} +inline bool SyncActionValue_AndroidUnsupportedActions::allowed() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.AndroidUnsupportedActions.allowed) + return _internal_allowed(); +} +inline void SyncActionValue_AndroidUnsupportedActions::_internal_set_allowed(bool value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.allowed_ = value; +} +inline void SyncActionValue_AndroidUnsupportedActions::set_allowed(bool value) { + _internal_set_allowed(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.AndroidUnsupportedActions.allowed) +} + +// ------------------------------------------------------------------- + +// SyncActionValue_ArchiveChatAction + +// optional bool archived = 1; +inline bool SyncActionValue_ArchiveChatAction::_internal_has_archived() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SyncActionValue_ArchiveChatAction::has_archived() const { + return _internal_has_archived(); +} +inline void SyncActionValue_ArchiveChatAction::clear_archived() { + _impl_.archived_ = false; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline bool SyncActionValue_ArchiveChatAction::_internal_archived() const { + return _impl_.archived_; +} +inline bool SyncActionValue_ArchiveChatAction::archived() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.ArchiveChatAction.archived) + return _internal_archived(); +} +inline void SyncActionValue_ArchiveChatAction::_internal_set_archived(bool value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.archived_ = value; +} +inline void SyncActionValue_ArchiveChatAction::set_archived(bool value) { + _internal_set_archived(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.ArchiveChatAction.archived) +} + +// optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2; +inline bool SyncActionValue_ArchiveChatAction::_internal_has_messagerange() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.messagerange_ != nullptr); + return value; +} +inline bool SyncActionValue_ArchiveChatAction::has_messagerange() const { + return _internal_has_messagerange(); +} +inline void SyncActionValue_ArchiveChatAction::clear_messagerange() { + if (_impl_.messagerange_ != nullptr) _impl_.messagerange_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_ArchiveChatAction::_internal_messagerange() const { + const ::proto::SyncActionValue_SyncActionMessageRange* p = _impl_.messagerange_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_SyncActionMessageRange_default_instance_); +} +inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_ArchiveChatAction::messagerange() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.ArchiveChatAction.messageRange) + return _internal_messagerange(); +} +inline void SyncActionValue_ArchiveChatAction::unsafe_arena_set_allocated_messagerange( + ::proto::SyncActionValue_SyncActionMessageRange* messagerange) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.messagerange_); + } + _impl_.messagerange_ = messagerange; + if (messagerange) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.ArchiveChatAction.messageRange) +} +inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ArchiveChatAction::release_messagerange() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_; + _impl_.messagerange_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ArchiveChatAction::unsafe_arena_release_messagerange() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.ArchiveChatAction.messageRange) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_; + _impl_.messagerange_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ArchiveChatAction::_internal_mutable_messagerange() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.messagerange_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue_SyncActionMessageRange>(GetArenaForAllocation()); + _impl_.messagerange_ = p; + } + return _impl_.messagerange_; +} +inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ArchiveChatAction::mutable_messagerange() { + ::proto::SyncActionValue_SyncActionMessageRange* _msg = _internal_mutable_messagerange(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.ArchiveChatAction.messageRange) + return _msg; +} +inline void SyncActionValue_ArchiveChatAction::set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.messagerange_; + } + if (messagerange) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(messagerange); + if (message_arena != submessage_arena) { + messagerange = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, messagerange, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.messagerange_ = messagerange; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.ArchiveChatAction.messageRange) +} + +// ------------------------------------------------------------------- + +// SyncActionValue_ClearChatAction + +// optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1; +inline bool SyncActionValue_ClearChatAction::_internal_has_messagerange() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.messagerange_ != nullptr); + return value; +} +inline bool SyncActionValue_ClearChatAction::has_messagerange() const { + return _internal_has_messagerange(); +} +inline void SyncActionValue_ClearChatAction::clear_messagerange() { + if (_impl_.messagerange_ != nullptr) _impl_.messagerange_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_ClearChatAction::_internal_messagerange() const { + const ::proto::SyncActionValue_SyncActionMessageRange* p = _impl_.messagerange_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_SyncActionMessageRange_default_instance_); +} +inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_ClearChatAction::messagerange() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.ClearChatAction.messageRange) + return _internal_messagerange(); +} +inline void SyncActionValue_ClearChatAction::unsafe_arena_set_allocated_messagerange( + ::proto::SyncActionValue_SyncActionMessageRange* messagerange) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.messagerange_); + } + _impl_.messagerange_ = messagerange; + if (messagerange) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.ClearChatAction.messageRange) +} +inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ClearChatAction::release_messagerange() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_; + _impl_.messagerange_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ClearChatAction::unsafe_arena_release_messagerange() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.ClearChatAction.messageRange) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_; + _impl_.messagerange_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ClearChatAction::_internal_mutable_messagerange() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.messagerange_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue_SyncActionMessageRange>(GetArenaForAllocation()); + _impl_.messagerange_ = p; + } + return _impl_.messagerange_; +} +inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ClearChatAction::mutable_messagerange() { + ::proto::SyncActionValue_SyncActionMessageRange* _msg = _internal_mutable_messagerange(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.ClearChatAction.messageRange) + return _msg; +} +inline void SyncActionValue_ClearChatAction::set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.messagerange_; + } + if (messagerange) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(messagerange); + if (message_arena != submessage_arena) { + messagerange = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, messagerange, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.messagerange_ = messagerange; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.ClearChatAction.messageRange) +} + +// ------------------------------------------------------------------- + +// SyncActionValue_ContactAction + +// optional string fullName = 1; +inline bool SyncActionValue_ContactAction::_internal_has_fullname() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SyncActionValue_ContactAction::has_fullname() const { + return _internal_has_fullname(); +} +inline void SyncActionValue_ContactAction::clear_fullname() { + _impl_.fullname_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& SyncActionValue_ContactAction::fullname() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.ContactAction.fullName) + return _internal_fullname(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SyncActionValue_ContactAction::set_fullname(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.fullname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.ContactAction.fullName) +} +inline std::string* SyncActionValue_ContactAction::mutable_fullname() { + std::string* _s = _internal_mutable_fullname(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.ContactAction.fullName) + return _s; +} +inline const std::string& SyncActionValue_ContactAction::_internal_fullname() const { + return _impl_.fullname_.Get(); +} +inline void SyncActionValue_ContactAction::_internal_set_fullname(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.fullname_.Set(value, GetArenaForAllocation()); +} +inline std::string* SyncActionValue_ContactAction::_internal_mutable_fullname() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.fullname_.Mutable(GetArenaForAllocation()); +} +inline std::string* SyncActionValue_ContactAction::release_fullname() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.ContactAction.fullName) + if (!_internal_has_fullname()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.fullname_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fullname_.IsDefault()) { + _impl_.fullname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SyncActionValue_ContactAction::set_allocated_fullname(std::string* fullname) { + if (fullname != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.fullname_.SetAllocated(fullname, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fullname_.IsDefault()) { + _impl_.fullname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.ContactAction.fullName) +} + +// optional string firstName = 2; +inline bool SyncActionValue_ContactAction::_internal_has_firstname() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SyncActionValue_ContactAction::has_firstname() const { + return _internal_has_firstname(); +} +inline void SyncActionValue_ContactAction::clear_firstname() { + _impl_.firstname_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& SyncActionValue_ContactAction::firstname() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.ContactAction.firstName) + return _internal_firstname(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SyncActionValue_ContactAction::set_firstname(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.firstname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.ContactAction.firstName) +} +inline std::string* SyncActionValue_ContactAction::mutable_firstname() { + std::string* _s = _internal_mutable_firstname(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.ContactAction.firstName) + return _s; +} +inline const std::string& SyncActionValue_ContactAction::_internal_firstname() const { + return _impl_.firstname_.Get(); +} +inline void SyncActionValue_ContactAction::_internal_set_firstname(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.firstname_.Set(value, GetArenaForAllocation()); +} +inline std::string* SyncActionValue_ContactAction::_internal_mutable_firstname() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.firstname_.Mutable(GetArenaForAllocation()); +} +inline std::string* SyncActionValue_ContactAction::release_firstname() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.ContactAction.firstName) + if (!_internal_has_firstname()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.firstname_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.firstname_.IsDefault()) { + _impl_.firstname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SyncActionValue_ContactAction::set_allocated_firstname(std::string* firstname) { + if (firstname != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.firstname_.SetAllocated(firstname, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.firstname_.IsDefault()) { + _impl_.firstname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.ContactAction.firstName) +} + +// ------------------------------------------------------------------- + +// SyncActionValue_DeleteChatAction + +// optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1; +inline bool SyncActionValue_DeleteChatAction::_internal_has_messagerange() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.messagerange_ != nullptr); + return value; +} +inline bool SyncActionValue_DeleteChatAction::has_messagerange() const { + return _internal_has_messagerange(); +} +inline void SyncActionValue_DeleteChatAction::clear_messagerange() { + if (_impl_.messagerange_ != nullptr) _impl_.messagerange_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_DeleteChatAction::_internal_messagerange() const { + const ::proto::SyncActionValue_SyncActionMessageRange* p = _impl_.messagerange_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_SyncActionMessageRange_default_instance_); +} +inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_DeleteChatAction::messagerange() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.DeleteChatAction.messageRange) + return _internal_messagerange(); +} +inline void SyncActionValue_DeleteChatAction::unsafe_arena_set_allocated_messagerange( + ::proto::SyncActionValue_SyncActionMessageRange* messagerange) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.messagerange_); + } + _impl_.messagerange_ = messagerange; + if (messagerange) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.DeleteChatAction.messageRange) +} +inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_DeleteChatAction::release_messagerange() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_; + _impl_.messagerange_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_DeleteChatAction::unsafe_arena_release_messagerange() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.DeleteChatAction.messageRange) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_; + _impl_.messagerange_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_DeleteChatAction::_internal_mutable_messagerange() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.messagerange_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue_SyncActionMessageRange>(GetArenaForAllocation()); + _impl_.messagerange_ = p; + } + return _impl_.messagerange_; +} +inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_DeleteChatAction::mutable_messagerange() { + ::proto::SyncActionValue_SyncActionMessageRange* _msg = _internal_mutable_messagerange(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.DeleteChatAction.messageRange) + return _msg; +} +inline void SyncActionValue_DeleteChatAction::set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.messagerange_; + } + if (messagerange) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(messagerange); + if (message_arena != submessage_arena) { + messagerange = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, messagerange, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.messagerange_ = messagerange; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.DeleteChatAction.messageRange) +} + +// ------------------------------------------------------------------- + +// SyncActionValue_DeleteMessageForMeAction + +// optional bool deleteMedia = 1; +inline bool SyncActionValue_DeleteMessageForMeAction::_internal_has_deletemedia() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SyncActionValue_DeleteMessageForMeAction::has_deletemedia() const { + return _internal_has_deletemedia(); +} +inline void SyncActionValue_DeleteMessageForMeAction::clear_deletemedia() { + _impl_.deletemedia_ = false; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline bool SyncActionValue_DeleteMessageForMeAction::_internal_deletemedia() const { + return _impl_.deletemedia_; +} +inline bool SyncActionValue_DeleteMessageForMeAction::deletemedia() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.DeleteMessageForMeAction.deleteMedia) + return _internal_deletemedia(); +} +inline void SyncActionValue_DeleteMessageForMeAction::_internal_set_deletemedia(bool value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.deletemedia_ = value; +} +inline void SyncActionValue_DeleteMessageForMeAction::set_deletemedia(bool value) { + _internal_set_deletemedia(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.DeleteMessageForMeAction.deleteMedia) +} + +// optional int64 messageTimestamp = 2; +inline bool SyncActionValue_DeleteMessageForMeAction::_internal_has_messagetimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SyncActionValue_DeleteMessageForMeAction::has_messagetimestamp() const { + return _internal_has_messagetimestamp(); +} +inline void SyncActionValue_DeleteMessageForMeAction::clear_messagetimestamp() { + _impl_.messagetimestamp_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline int64_t SyncActionValue_DeleteMessageForMeAction::_internal_messagetimestamp() const { + return _impl_.messagetimestamp_; +} +inline int64_t SyncActionValue_DeleteMessageForMeAction::messagetimestamp() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.DeleteMessageForMeAction.messageTimestamp) + return _internal_messagetimestamp(); +} +inline void SyncActionValue_DeleteMessageForMeAction::_internal_set_messagetimestamp(int64_t value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.messagetimestamp_ = value; +} +inline void SyncActionValue_DeleteMessageForMeAction::set_messagetimestamp(int64_t value) { + _internal_set_messagetimestamp(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.DeleteMessageForMeAction.messageTimestamp) +} + +// ------------------------------------------------------------------- + +// SyncActionValue_KeyExpiration + +// optional int32 expiredKeyEpoch = 1; +inline bool SyncActionValue_KeyExpiration::_internal_has_expiredkeyepoch() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SyncActionValue_KeyExpiration::has_expiredkeyepoch() const { + return _internal_has_expiredkeyepoch(); +} +inline void SyncActionValue_KeyExpiration::clear_expiredkeyepoch() { + _impl_.expiredkeyepoch_ = 0; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline int32_t SyncActionValue_KeyExpiration::_internal_expiredkeyepoch() const { + return _impl_.expiredkeyepoch_; +} +inline int32_t SyncActionValue_KeyExpiration::expiredkeyepoch() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.KeyExpiration.expiredKeyEpoch) + return _internal_expiredkeyepoch(); +} +inline void SyncActionValue_KeyExpiration::_internal_set_expiredkeyepoch(int32_t value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.expiredkeyepoch_ = value; +} +inline void SyncActionValue_KeyExpiration::set_expiredkeyepoch(int32_t value) { + _internal_set_expiredkeyepoch(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.KeyExpiration.expiredKeyEpoch) +} + +// ------------------------------------------------------------------- + +// SyncActionValue_LabelAssociationAction + +// optional bool labeled = 1; +inline bool SyncActionValue_LabelAssociationAction::_internal_has_labeled() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SyncActionValue_LabelAssociationAction::has_labeled() const { + return _internal_has_labeled(); +} +inline void SyncActionValue_LabelAssociationAction::clear_labeled() { + _impl_.labeled_ = false; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline bool SyncActionValue_LabelAssociationAction::_internal_labeled() const { + return _impl_.labeled_; +} +inline bool SyncActionValue_LabelAssociationAction::labeled() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.LabelAssociationAction.labeled) + return _internal_labeled(); +} +inline void SyncActionValue_LabelAssociationAction::_internal_set_labeled(bool value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.labeled_ = value; +} +inline void SyncActionValue_LabelAssociationAction::set_labeled(bool value) { + _internal_set_labeled(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.LabelAssociationAction.labeled) +} + +// ------------------------------------------------------------------- + +// SyncActionValue_LabelEditAction + +// optional string name = 1; +inline bool SyncActionValue_LabelEditAction::_internal_has_name() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SyncActionValue_LabelEditAction::has_name() const { + return _internal_has_name(); +} +inline void SyncActionValue_LabelEditAction::clear_name() { + _impl_.name_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& SyncActionValue_LabelEditAction::name() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.LabelEditAction.name) + return _internal_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SyncActionValue_LabelEditAction::set_name(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.LabelEditAction.name) +} +inline std::string* SyncActionValue_LabelEditAction::mutable_name() { + std::string* _s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.LabelEditAction.name) + return _s; +} +inline const std::string& SyncActionValue_LabelEditAction::_internal_name() const { + return _impl_.name_.Get(); +} +inline void SyncActionValue_LabelEditAction::_internal_set_name(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.name_.Set(value, GetArenaForAllocation()); +} +inline std::string* SyncActionValue_LabelEditAction::_internal_mutable_name() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.name_.Mutable(GetArenaForAllocation()); +} +inline std::string* SyncActionValue_LabelEditAction::release_name() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.LabelEditAction.name) + if (!_internal_has_name()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.name_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.name_.IsDefault()) { + _impl_.name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SyncActionValue_LabelEditAction::set_allocated_name(std::string* name) { + if (name != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.name_.SetAllocated(name, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.name_.IsDefault()) { + _impl_.name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.LabelEditAction.name) +} + +// optional int32 color = 2; +inline bool SyncActionValue_LabelEditAction::_internal_has_color() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SyncActionValue_LabelEditAction::has_color() const { + return _internal_has_color(); +} +inline void SyncActionValue_LabelEditAction::clear_color() { + _impl_.color_ = 0; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline int32_t SyncActionValue_LabelEditAction::_internal_color() const { + return _impl_.color_; +} +inline int32_t SyncActionValue_LabelEditAction::color() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.LabelEditAction.color) + return _internal_color(); +} +inline void SyncActionValue_LabelEditAction::_internal_set_color(int32_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.color_ = value; +} +inline void SyncActionValue_LabelEditAction::set_color(int32_t value) { + _internal_set_color(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.LabelEditAction.color) +} + +// optional int32 predefinedId = 3; +inline bool SyncActionValue_LabelEditAction::_internal_has_predefinedid() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool SyncActionValue_LabelEditAction::has_predefinedid() const { + return _internal_has_predefinedid(); +} +inline void SyncActionValue_LabelEditAction::clear_predefinedid() { + _impl_.predefinedid_ = 0; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline int32_t SyncActionValue_LabelEditAction::_internal_predefinedid() const { + return _impl_.predefinedid_; +} +inline int32_t SyncActionValue_LabelEditAction::predefinedid() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.LabelEditAction.predefinedId) + return _internal_predefinedid(); +} +inline void SyncActionValue_LabelEditAction::_internal_set_predefinedid(int32_t value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.predefinedid_ = value; +} +inline void SyncActionValue_LabelEditAction::set_predefinedid(int32_t value) { + _internal_set_predefinedid(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.LabelEditAction.predefinedId) +} + +// optional bool deleted = 4; +inline bool SyncActionValue_LabelEditAction::_internal_has_deleted() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool SyncActionValue_LabelEditAction::has_deleted() const { + return _internal_has_deleted(); +} +inline void SyncActionValue_LabelEditAction::clear_deleted() { + _impl_.deleted_ = false; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline bool SyncActionValue_LabelEditAction::_internal_deleted() const { + return _impl_.deleted_; +} +inline bool SyncActionValue_LabelEditAction::deleted() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.LabelEditAction.deleted) + return _internal_deleted(); +} +inline void SyncActionValue_LabelEditAction::_internal_set_deleted(bool value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.deleted_ = value; +} +inline void SyncActionValue_LabelEditAction::set_deleted(bool value) { + _internal_set_deleted(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.LabelEditAction.deleted) +} + +// ------------------------------------------------------------------- + +// SyncActionValue_LocaleSetting + +// optional string locale = 1; +inline bool SyncActionValue_LocaleSetting::_internal_has_locale() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SyncActionValue_LocaleSetting::has_locale() const { + return _internal_has_locale(); +} +inline void SyncActionValue_LocaleSetting::clear_locale() { + _impl_.locale_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& SyncActionValue_LocaleSetting::locale() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.LocaleSetting.locale) + return _internal_locale(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SyncActionValue_LocaleSetting::set_locale(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.locale_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.LocaleSetting.locale) +} +inline std::string* SyncActionValue_LocaleSetting::mutable_locale() { + std::string* _s = _internal_mutable_locale(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.LocaleSetting.locale) + return _s; +} +inline const std::string& SyncActionValue_LocaleSetting::_internal_locale() const { + return _impl_.locale_.Get(); +} +inline void SyncActionValue_LocaleSetting::_internal_set_locale(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.locale_.Set(value, GetArenaForAllocation()); +} +inline std::string* SyncActionValue_LocaleSetting::_internal_mutable_locale() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.locale_.Mutable(GetArenaForAllocation()); +} +inline std::string* SyncActionValue_LocaleSetting::release_locale() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.LocaleSetting.locale) + if (!_internal_has_locale()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.locale_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.locale_.IsDefault()) { + _impl_.locale_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SyncActionValue_LocaleSetting::set_allocated_locale(std::string* locale) { + if (locale != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.locale_.SetAllocated(locale, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.locale_.IsDefault()) { + _impl_.locale_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.LocaleSetting.locale) +} + +// ------------------------------------------------------------------- + +// SyncActionValue_MarkChatAsReadAction + +// optional bool read = 1; +inline bool SyncActionValue_MarkChatAsReadAction::_internal_has_read() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SyncActionValue_MarkChatAsReadAction::has_read() const { + return _internal_has_read(); +} +inline void SyncActionValue_MarkChatAsReadAction::clear_read() { + _impl_.read_ = false; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline bool SyncActionValue_MarkChatAsReadAction::_internal_read() const { + return _impl_.read_; +} +inline bool SyncActionValue_MarkChatAsReadAction::read() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.MarkChatAsReadAction.read) + return _internal_read(); +} +inline void SyncActionValue_MarkChatAsReadAction::_internal_set_read(bool value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.read_ = value; +} +inline void SyncActionValue_MarkChatAsReadAction::set_read(bool value) { + _internal_set_read(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.MarkChatAsReadAction.read) +} + +// optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2; +inline bool SyncActionValue_MarkChatAsReadAction::_internal_has_messagerange() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.messagerange_ != nullptr); + return value; +} +inline bool SyncActionValue_MarkChatAsReadAction::has_messagerange() const { + return _internal_has_messagerange(); +} +inline void SyncActionValue_MarkChatAsReadAction::clear_messagerange() { + if (_impl_.messagerange_ != nullptr) _impl_.messagerange_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_MarkChatAsReadAction::_internal_messagerange() const { + const ::proto::SyncActionValue_SyncActionMessageRange* p = _impl_.messagerange_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_SyncActionMessageRange_default_instance_); +} +inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_MarkChatAsReadAction::messagerange() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.MarkChatAsReadAction.messageRange) + return _internal_messagerange(); +} +inline void SyncActionValue_MarkChatAsReadAction::unsafe_arena_set_allocated_messagerange( + ::proto::SyncActionValue_SyncActionMessageRange* messagerange) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.messagerange_); + } + _impl_.messagerange_ = messagerange; + if (messagerange) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.MarkChatAsReadAction.messageRange) +} +inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_MarkChatAsReadAction::release_messagerange() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_; + _impl_.messagerange_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_MarkChatAsReadAction::unsafe_arena_release_messagerange() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.MarkChatAsReadAction.messageRange) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_; + _impl_.messagerange_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_MarkChatAsReadAction::_internal_mutable_messagerange() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.messagerange_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue_SyncActionMessageRange>(GetArenaForAllocation()); + _impl_.messagerange_ = p; + } + return _impl_.messagerange_; +} +inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_MarkChatAsReadAction::mutable_messagerange() { + ::proto::SyncActionValue_SyncActionMessageRange* _msg = _internal_mutable_messagerange(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.MarkChatAsReadAction.messageRange) + return _msg; +} +inline void SyncActionValue_MarkChatAsReadAction::set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.messagerange_; + } + if (messagerange) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(messagerange); + if (message_arena != submessage_arena) { + messagerange = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, messagerange, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.messagerange_ = messagerange; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.MarkChatAsReadAction.messageRange) +} + +// ------------------------------------------------------------------- + +// SyncActionValue_MuteAction + +// optional bool muted = 1; +inline bool SyncActionValue_MuteAction::_internal_has_muted() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SyncActionValue_MuteAction::has_muted() const { + return _internal_has_muted(); +} +inline void SyncActionValue_MuteAction::clear_muted() { + _impl_.muted_ = false; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline bool SyncActionValue_MuteAction::_internal_muted() const { + return _impl_.muted_; +} +inline bool SyncActionValue_MuteAction::muted() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.MuteAction.muted) + return _internal_muted(); +} +inline void SyncActionValue_MuteAction::_internal_set_muted(bool value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.muted_ = value; +} +inline void SyncActionValue_MuteAction::set_muted(bool value) { + _internal_set_muted(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.MuteAction.muted) +} + +// optional int64 muteEndTimestamp = 2; +inline bool SyncActionValue_MuteAction::_internal_has_muteendtimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SyncActionValue_MuteAction::has_muteendtimestamp() const { + return _internal_has_muteendtimestamp(); +} +inline void SyncActionValue_MuteAction::clear_muteendtimestamp() { + _impl_.muteendtimestamp_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline int64_t SyncActionValue_MuteAction::_internal_muteendtimestamp() const { + return _impl_.muteendtimestamp_; +} +inline int64_t SyncActionValue_MuteAction::muteendtimestamp() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.MuteAction.muteEndTimestamp) + return _internal_muteendtimestamp(); +} +inline void SyncActionValue_MuteAction::_internal_set_muteendtimestamp(int64_t value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.muteendtimestamp_ = value; +} +inline void SyncActionValue_MuteAction::set_muteendtimestamp(int64_t value) { + _internal_set_muteendtimestamp(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.MuteAction.muteEndTimestamp) +} + +// ------------------------------------------------------------------- + +// SyncActionValue_NuxAction + +// optional bool acknowledged = 1; +inline bool SyncActionValue_NuxAction::_internal_has_acknowledged() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SyncActionValue_NuxAction::has_acknowledged() const { + return _internal_has_acknowledged(); +} +inline void SyncActionValue_NuxAction::clear_acknowledged() { + _impl_.acknowledged_ = false; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline bool SyncActionValue_NuxAction::_internal_acknowledged() const { + return _impl_.acknowledged_; +} +inline bool SyncActionValue_NuxAction::acknowledged() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.NuxAction.acknowledged) + return _internal_acknowledged(); +} +inline void SyncActionValue_NuxAction::_internal_set_acknowledged(bool value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.acknowledged_ = value; +} +inline void SyncActionValue_NuxAction::set_acknowledged(bool value) { + _internal_set_acknowledged(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.NuxAction.acknowledged) +} + +// ------------------------------------------------------------------- + +// SyncActionValue_PinAction + +// optional bool pinned = 1; +inline bool SyncActionValue_PinAction::_internal_has_pinned() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SyncActionValue_PinAction::has_pinned() const { + return _internal_has_pinned(); +} +inline void SyncActionValue_PinAction::clear_pinned() { + _impl_.pinned_ = false; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline bool SyncActionValue_PinAction::_internal_pinned() const { + return _impl_.pinned_; +} +inline bool SyncActionValue_PinAction::pinned() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.PinAction.pinned) + return _internal_pinned(); +} +inline void SyncActionValue_PinAction::_internal_set_pinned(bool value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.pinned_ = value; +} +inline void SyncActionValue_PinAction::set_pinned(bool value) { + _internal_set_pinned(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.PinAction.pinned) +} + +// ------------------------------------------------------------------- + +// SyncActionValue_PrimaryFeature + +// repeated string flags = 1; +inline int SyncActionValue_PrimaryFeature::_internal_flags_size() const { + return _impl_.flags_.size(); +} +inline int SyncActionValue_PrimaryFeature::flags_size() const { + return _internal_flags_size(); +} +inline void SyncActionValue_PrimaryFeature::clear_flags() { + _impl_.flags_.Clear(); +} +inline std::string* SyncActionValue_PrimaryFeature::add_flags() { + std::string* _s = _internal_add_flags(); + // @@protoc_insertion_point(field_add_mutable:proto.SyncActionValue.PrimaryFeature.flags) + return _s; +} +inline const std::string& SyncActionValue_PrimaryFeature::_internal_flags(int index) const { + return _impl_.flags_.Get(index); +} +inline const std::string& SyncActionValue_PrimaryFeature::flags(int index) const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.PrimaryFeature.flags) + return _internal_flags(index); +} +inline std::string* SyncActionValue_PrimaryFeature::mutable_flags(int index) { + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.PrimaryFeature.flags) + return _impl_.flags_.Mutable(index); +} +inline void SyncActionValue_PrimaryFeature::set_flags(int index, const std::string& value) { + _impl_.flags_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.PrimaryFeature.flags) +} +inline void SyncActionValue_PrimaryFeature::set_flags(int index, std::string&& value) { + _impl_.flags_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.PrimaryFeature.flags) +} +inline void SyncActionValue_PrimaryFeature::set_flags(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + _impl_.flags_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:proto.SyncActionValue.PrimaryFeature.flags) +} +inline void SyncActionValue_PrimaryFeature::set_flags(int index, const char* value, size_t size) { + _impl_.flags_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:proto.SyncActionValue.PrimaryFeature.flags) +} +inline std::string* SyncActionValue_PrimaryFeature::_internal_add_flags() { + return _impl_.flags_.Add(); +} +inline void SyncActionValue_PrimaryFeature::add_flags(const std::string& value) { + _impl_.flags_.Add()->assign(value); + // @@protoc_insertion_point(field_add:proto.SyncActionValue.PrimaryFeature.flags) +} +inline void SyncActionValue_PrimaryFeature::add_flags(std::string&& value) { + _impl_.flags_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:proto.SyncActionValue.PrimaryFeature.flags) +} +inline void SyncActionValue_PrimaryFeature::add_flags(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _impl_.flags_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:proto.SyncActionValue.PrimaryFeature.flags) +} +inline void SyncActionValue_PrimaryFeature::add_flags(const char* value, size_t size) { + _impl_.flags_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:proto.SyncActionValue.PrimaryFeature.flags) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +SyncActionValue_PrimaryFeature::flags() const { + // @@protoc_insertion_point(field_list:proto.SyncActionValue.PrimaryFeature.flags) + return _impl_.flags_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +SyncActionValue_PrimaryFeature::mutable_flags() { + // @@protoc_insertion_point(field_mutable_list:proto.SyncActionValue.PrimaryFeature.flags) + return &_impl_.flags_; +} + +// ------------------------------------------------------------------- + +// SyncActionValue_PrimaryVersionAction + +// optional string version = 1; +inline bool SyncActionValue_PrimaryVersionAction::_internal_has_version() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SyncActionValue_PrimaryVersionAction::has_version() const { + return _internal_has_version(); +} +inline void SyncActionValue_PrimaryVersionAction::clear_version() { + _impl_.version_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& SyncActionValue_PrimaryVersionAction::version() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.PrimaryVersionAction.version) + return _internal_version(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SyncActionValue_PrimaryVersionAction::set_version(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.version_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.PrimaryVersionAction.version) +} +inline std::string* SyncActionValue_PrimaryVersionAction::mutable_version() { + std::string* _s = _internal_mutable_version(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.PrimaryVersionAction.version) + return _s; +} +inline const std::string& SyncActionValue_PrimaryVersionAction::_internal_version() const { + return _impl_.version_.Get(); +} +inline void SyncActionValue_PrimaryVersionAction::_internal_set_version(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.version_.Set(value, GetArenaForAllocation()); +} +inline std::string* SyncActionValue_PrimaryVersionAction::_internal_mutable_version() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.version_.Mutable(GetArenaForAllocation()); +} +inline std::string* SyncActionValue_PrimaryVersionAction::release_version() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.PrimaryVersionAction.version) + if (!_internal_has_version()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.version_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.version_.IsDefault()) { + _impl_.version_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SyncActionValue_PrimaryVersionAction::set_allocated_version(std::string* version) { + if (version != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.version_.SetAllocated(version, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.version_.IsDefault()) { + _impl_.version_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.PrimaryVersionAction.version) +} + +// ------------------------------------------------------------------- + +// SyncActionValue_PushNameSetting + +// optional string name = 1; +inline bool SyncActionValue_PushNameSetting::_internal_has_name() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SyncActionValue_PushNameSetting::has_name() const { + return _internal_has_name(); +} +inline void SyncActionValue_PushNameSetting::clear_name() { + _impl_.name_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& SyncActionValue_PushNameSetting::name() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.PushNameSetting.name) + return _internal_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SyncActionValue_PushNameSetting::set_name(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.PushNameSetting.name) +} +inline std::string* SyncActionValue_PushNameSetting::mutable_name() { + std::string* _s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.PushNameSetting.name) + return _s; +} +inline const std::string& SyncActionValue_PushNameSetting::_internal_name() const { + return _impl_.name_.Get(); +} +inline void SyncActionValue_PushNameSetting::_internal_set_name(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.name_.Set(value, GetArenaForAllocation()); +} +inline std::string* SyncActionValue_PushNameSetting::_internal_mutable_name() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.name_.Mutable(GetArenaForAllocation()); +} +inline std::string* SyncActionValue_PushNameSetting::release_name() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.PushNameSetting.name) + if (!_internal_has_name()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.name_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.name_.IsDefault()) { + _impl_.name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SyncActionValue_PushNameSetting::set_allocated_name(std::string* name) { + if (name != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.name_.SetAllocated(name, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.name_.IsDefault()) { + _impl_.name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.PushNameSetting.name) +} + +// ------------------------------------------------------------------- + +// SyncActionValue_QuickReplyAction + +// optional string shortcut = 1; +inline bool SyncActionValue_QuickReplyAction::_internal_has_shortcut() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SyncActionValue_QuickReplyAction::has_shortcut() const { + return _internal_has_shortcut(); +} +inline void SyncActionValue_QuickReplyAction::clear_shortcut() { + _impl_.shortcut_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& SyncActionValue_QuickReplyAction::shortcut() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.QuickReplyAction.shortcut) + return _internal_shortcut(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SyncActionValue_QuickReplyAction::set_shortcut(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.shortcut_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.QuickReplyAction.shortcut) +} +inline std::string* SyncActionValue_QuickReplyAction::mutable_shortcut() { + std::string* _s = _internal_mutable_shortcut(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.QuickReplyAction.shortcut) + return _s; +} +inline const std::string& SyncActionValue_QuickReplyAction::_internal_shortcut() const { + return _impl_.shortcut_.Get(); +} +inline void SyncActionValue_QuickReplyAction::_internal_set_shortcut(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.shortcut_.Set(value, GetArenaForAllocation()); +} +inline std::string* SyncActionValue_QuickReplyAction::_internal_mutable_shortcut() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.shortcut_.Mutable(GetArenaForAllocation()); +} +inline std::string* SyncActionValue_QuickReplyAction::release_shortcut() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.QuickReplyAction.shortcut) + if (!_internal_has_shortcut()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.shortcut_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.shortcut_.IsDefault()) { + _impl_.shortcut_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SyncActionValue_QuickReplyAction::set_allocated_shortcut(std::string* shortcut) { + if (shortcut != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.shortcut_.SetAllocated(shortcut, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.shortcut_.IsDefault()) { + _impl_.shortcut_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.QuickReplyAction.shortcut) +} + +// optional string message = 2; +inline bool SyncActionValue_QuickReplyAction::_internal_has_message() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SyncActionValue_QuickReplyAction::has_message() const { + return _internal_has_message(); +} +inline void SyncActionValue_QuickReplyAction::clear_message() { + _impl_.message_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& SyncActionValue_QuickReplyAction::message() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.QuickReplyAction.message) + return _internal_message(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SyncActionValue_QuickReplyAction::set_message(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.message_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.QuickReplyAction.message) +} +inline std::string* SyncActionValue_QuickReplyAction::mutable_message() { + std::string* _s = _internal_mutable_message(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.QuickReplyAction.message) + return _s; +} +inline const std::string& SyncActionValue_QuickReplyAction::_internal_message() const { + return _impl_.message_.Get(); +} +inline void SyncActionValue_QuickReplyAction::_internal_set_message(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.message_.Set(value, GetArenaForAllocation()); +} +inline std::string* SyncActionValue_QuickReplyAction::_internal_mutable_message() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.message_.Mutable(GetArenaForAllocation()); +} +inline std::string* SyncActionValue_QuickReplyAction::release_message() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.QuickReplyAction.message) + if (!_internal_has_message()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.message_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.message_.IsDefault()) { + _impl_.message_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SyncActionValue_QuickReplyAction::set_allocated_message(std::string* message) { + if (message != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.message_.SetAllocated(message, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.message_.IsDefault()) { + _impl_.message_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.QuickReplyAction.message) +} + +// repeated string keywords = 3; +inline int SyncActionValue_QuickReplyAction::_internal_keywords_size() const { + return _impl_.keywords_.size(); +} +inline int SyncActionValue_QuickReplyAction::keywords_size() const { + return _internal_keywords_size(); +} +inline void SyncActionValue_QuickReplyAction::clear_keywords() { + _impl_.keywords_.Clear(); +} +inline std::string* SyncActionValue_QuickReplyAction::add_keywords() { + std::string* _s = _internal_add_keywords(); + // @@protoc_insertion_point(field_add_mutable:proto.SyncActionValue.QuickReplyAction.keywords) + return _s; +} +inline const std::string& SyncActionValue_QuickReplyAction::_internal_keywords(int index) const { + return _impl_.keywords_.Get(index); +} +inline const std::string& SyncActionValue_QuickReplyAction::keywords(int index) const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.QuickReplyAction.keywords) + return _internal_keywords(index); +} +inline std::string* SyncActionValue_QuickReplyAction::mutable_keywords(int index) { + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.QuickReplyAction.keywords) + return _impl_.keywords_.Mutable(index); +} +inline void SyncActionValue_QuickReplyAction::set_keywords(int index, const std::string& value) { + _impl_.keywords_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.QuickReplyAction.keywords) +} +inline void SyncActionValue_QuickReplyAction::set_keywords(int index, std::string&& value) { + _impl_.keywords_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.QuickReplyAction.keywords) +} +inline void SyncActionValue_QuickReplyAction::set_keywords(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + _impl_.keywords_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:proto.SyncActionValue.QuickReplyAction.keywords) +} +inline void SyncActionValue_QuickReplyAction::set_keywords(int index, const char* value, size_t size) { + _impl_.keywords_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:proto.SyncActionValue.QuickReplyAction.keywords) +} +inline std::string* SyncActionValue_QuickReplyAction::_internal_add_keywords() { + return _impl_.keywords_.Add(); +} +inline void SyncActionValue_QuickReplyAction::add_keywords(const std::string& value) { + _impl_.keywords_.Add()->assign(value); + // @@protoc_insertion_point(field_add:proto.SyncActionValue.QuickReplyAction.keywords) +} +inline void SyncActionValue_QuickReplyAction::add_keywords(std::string&& value) { + _impl_.keywords_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:proto.SyncActionValue.QuickReplyAction.keywords) +} +inline void SyncActionValue_QuickReplyAction::add_keywords(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _impl_.keywords_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:proto.SyncActionValue.QuickReplyAction.keywords) +} +inline void SyncActionValue_QuickReplyAction::add_keywords(const char* value, size_t size) { + _impl_.keywords_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:proto.SyncActionValue.QuickReplyAction.keywords) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +SyncActionValue_QuickReplyAction::keywords() const { + // @@protoc_insertion_point(field_list:proto.SyncActionValue.QuickReplyAction.keywords) + return _impl_.keywords_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +SyncActionValue_QuickReplyAction::mutable_keywords() { + // @@protoc_insertion_point(field_mutable_list:proto.SyncActionValue.QuickReplyAction.keywords) + return &_impl_.keywords_; +} + +// optional int32 count = 4; +inline bool SyncActionValue_QuickReplyAction::_internal_has_count() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool SyncActionValue_QuickReplyAction::has_count() const { + return _internal_has_count(); +} +inline void SyncActionValue_QuickReplyAction::clear_count() { + _impl_.count_ = 0; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline int32_t SyncActionValue_QuickReplyAction::_internal_count() const { + return _impl_.count_; +} +inline int32_t SyncActionValue_QuickReplyAction::count() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.QuickReplyAction.count) + return _internal_count(); +} +inline void SyncActionValue_QuickReplyAction::_internal_set_count(int32_t value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.count_ = value; +} +inline void SyncActionValue_QuickReplyAction::set_count(int32_t value) { + _internal_set_count(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.QuickReplyAction.count) +} + +// optional bool deleted = 5; +inline bool SyncActionValue_QuickReplyAction::_internal_has_deleted() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool SyncActionValue_QuickReplyAction::has_deleted() const { + return _internal_has_deleted(); +} +inline void SyncActionValue_QuickReplyAction::clear_deleted() { + _impl_.deleted_ = false; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline bool SyncActionValue_QuickReplyAction::_internal_deleted() const { + return _impl_.deleted_; +} +inline bool SyncActionValue_QuickReplyAction::deleted() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.QuickReplyAction.deleted) + return _internal_deleted(); +} +inline void SyncActionValue_QuickReplyAction::_internal_set_deleted(bool value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.deleted_ = value; +} +inline void SyncActionValue_QuickReplyAction::set_deleted(bool value) { + _internal_set_deleted(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.QuickReplyAction.deleted) +} + +// ------------------------------------------------------------------- + +// SyncActionValue_RecentEmojiWeightsAction + +// repeated .proto.RecentEmojiWeight weights = 1; +inline int SyncActionValue_RecentEmojiWeightsAction::_internal_weights_size() const { + return _impl_.weights_.size(); +} +inline int SyncActionValue_RecentEmojiWeightsAction::weights_size() const { + return _internal_weights_size(); +} +inline void SyncActionValue_RecentEmojiWeightsAction::clear_weights() { + _impl_.weights_.Clear(); +} +inline ::proto::RecentEmojiWeight* SyncActionValue_RecentEmojiWeightsAction::mutable_weights(int index) { + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.RecentEmojiWeightsAction.weights) + return _impl_.weights_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::RecentEmojiWeight >* +SyncActionValue_RecentEmojiWeightsAction::mutable_weights() { + // @@protoc_insertion_point(field_mutable_list:proto.SyncActionValue.RecentEmojiWeightsAction.weights) + return &_impl_.weights_; +} +inline const ::proto::RecentEmojiWeight& SyncActionValue_RecentEmojiWeightsAction::_internal_weights(int index) const { + return _impl_.weights_.Get(index); +} +inline const ::proto::RecentEmojiWeight& SyncActionValue_RecentEmojiWeightsAction::weights(int index) const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.RecentEmojiWeightsAction.weights) + return _internal_weights(index); +} +inline ::proto::RecentEmojiWeight* SyncActionValue_RecentEmojiWeightsAction::_internal_add_weights() { + return _impl_.weights_.Add(); +} +inline ::proto::RecentEmojiWeight* SyncActionValue_RecentEmojiWeightsAction::add_weights() { + ::proto::RecentEmojiWeight* _add = _internal_add_weights(); + // @@protoc_insertion_point(field_add:proto.SyncActionValue.RecentEmojiWeightsAction.weights) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::RecentEmojiWeight >& +SyncActionValue_RecentEmojiWeightsAction::weights() const { + // @@protoc_insertion_point(field_list:proto.SyncActionValue.RecentEmojiWeightsAction.weights) + return _impl_.weights_; +} + +// ------------------------------------------------------------------- + +// SyncActionValue_SecurityNotificationSetting + +// optional bool showNotification = 1; +inline bool SyncActionValue_SecurityNotificationSetting::_internal_has_shownotification() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SyncActionValue_SecurityNotificationSetting::has_shownotification() const { + return _internal_has_shownotification(); +} +inline void SyncActionValue_SecurityNotificationSetting::clear_shownotification() { + _impl_.shownotification_ = false; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline bool SyncActionValue_SecurityNotificationSetting::_internal_shownotification() const { + return _impl_.shownotification_; +} +inline bool SyncActionValue_SecurityNotificationSetting::shownotification() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.SecurityNotificationSetting.showNotification) + return _internal_shownotification(); +} +inline void SyncActionValue_SecurityNotificationSetting::_internal_set_shownotification(bool value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.shownotification_ = value; +} +inline void SyncActionValue_SecurityNotificationSetting::set_shownotification(bool value) { + _internal_set_shownotification(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.SecurityNotificationSetting.showNotification) +} + +// ------------------------------------------------------------------- + +// SyncActionValue_StarAction + +// optional bool starred = 1; +inline bool SyncActionValue_StarAction::_internal_has_starred() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SyncActionValue_StarAction::has_starred() const { + return _internal_has_starred(); +} +inline void SyncActionValue_StarAction::clear_starred() { + _impl_.starred_ = false; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline bool SyncActionValue_StarAction::_internal_starred() const { + return _impl_.starred_; +} +inline bool SyncActionValue_StarAction::starred() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.StarAction.starred) + return _internal_starred(); +} +inline void SyncActionValue_StarAction::_internal_set_starred(bool value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.starred_ = value; +} +inline void SyncActionValue_StarAction::set_starred(bool value) { + _internal_set_starred(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.StarAction.starred) +} + +// ------------------------------------------------------------------- + +// SyncActionValue_StickerAction + +// optional string url = 1; +inline bool SyncActionValue_StickerAction::_internal_has_url() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SyncActionValue_StickerAction::has_url() const { + return _internal_has_url(); +} +inline void SyncActionValue_StickerAction::clear_url() { + _impl_.url_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& SyncActionValue_StickerAction::url() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.url) + return _internal_url(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SyncActionValue_StickerAction::set_url(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.url_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.url) +} +inline std::string* SyncActionValue_StickerAction::mutable_url() { + std::string* _s = _internal_mutable_url(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.StickerAction.url) + return _s; +} +inline const std::string& SyncActionValue_StickerAction::_internal_url() const { + return _impl_.url_.Get(); +} +inline void SyncActionValue_StickerAction::_internal_set_url(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.url_.Set(value, GetArenaForAllocation()); +} +inline std::string* SyncActionValue_StickerAction::_internal_mutable_url() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.url_.Mutable(GetArenaForAllocation()); +} +inline std::string* SyncActionValue_StickerAction::release_url() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.StickerAction.url) + if (!_internal_has_url()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.url_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.url_.IsDefault()) { + _impl_.url_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SyncActionValue_StickerAction::set_allocated_url(std::string* url) { + if (url != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.url_.SetAllocated(url, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.url_.IsDefault()) { + _impl_.url_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.StickerAction.url) +} + +// optional bytes fileEncSha256 = 2; +inline bool SyncActionValue_StickerAction::_internal_has_fileencsha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SyncActionValue_StickerAction::has_fileencsha256() const { + return _internal_has_fileencsha256(); +} +inline void SyncActionValue_StickerAction::clear_fileencsha256() { + _impl_.fileencsha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& SyncActionValue_StickerAction::fileencsha256() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.fileEncSha256) + return _internal_fileencsha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SyncActionValue_StickerAction::set_fileencsha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.fileencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.fileEncSha256) +} +inline std::string* SyncActionValue_StickerAction::mutable_fileencsha256() { + std::string* _s = _internal_mutable_fileencsha256(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.StickerAction.fileEncSha256) + return _s; +} +inline const std::string& SyncActionValue_StickerAction::_internal_fileencsha256() const { + return _impl_.fileencsha256_.Get(); +} +inline void SyncActionValue_StickerAction::_internal_set_fileencsha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.fileencsha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* SyncActionValue_StickerAction::_internal_mutable_fileencsha256() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.fileencsha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* SyncActionValue_StickerAction::release_fileencsha256() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.StickerAction.fileEncSha256) + if (!_internal_has_fileencsha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.fileencsha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fileencsha256_.IsDefault()) { + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SyncActionValue_StickerAction::set_allocated_fileencsha256(std::string* fileencsha256) { + if (fileencsha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.fileencsha256_.IsDefault()) { + _impl_.fileencsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.StickerAction.fileEncSha256) +} + +// optional bytes mediaKey = 3; +inline bool SyncActionValue_StickerAction::_internal_has_mediakey() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool SyncActionValue_StickerAction::has_mediakey() const { + return _internal_has_mediakey(); +} +inline void SyncActionValue_StickerAction::clear_mediakey() { + _impl_.mediakey_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& SyncActionValue_StickerAction::mediakey() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.mediaKey) + return _internal_mediakey(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SyncActionValue_StickerAction::set_mediakey(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.mediakey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.mediaKey) +} +inline std::string* SyncActionValue_StickerAction::mutable_mediakey() { + std::string* _s = _internal_mutable_mediakey(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.StickerAction.mediaKey) + return _s; +} +inline const std::string& SyncActionValue_StickerAction::_internal_mediakey() const { + return _impl_.mediakey_.Get(); +} +inline void SyncActionValue_StickerAction::_internal_set_mediakey(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.mediakey_.Set(value, GetArenaForAllocation()); +} +inline std::string* SyncActionValue_StickerAction::_internal_mutable_mediakey() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.mediakey_.Mutable(GetArenaForAllocation()); +} +inline std::string* SyncActionValue_StickerAction::release_mediakey() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.StickerAction.mediaKey) + if (!_internal_has_mediakey()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.mediakey_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mediakey_.IsDefault()) { + _impl_.mediakey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SyncActionValue_StickerAction::set_allocated_mediakey(std::string* mediakey) { + if (mediakey != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mediakey_.IsDefault()) { + _impl_.mediakey_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.StickerAction.mediaKey) +} + +// optional string mimetype = 4; +inline bool SyncActionValue_StickerAction::_internal_has_mimetype() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool SyncActionValue_StickerAction::has_mimetype() const { + return _internal_has_mimetype(); +} +inline void SyncActionValue_StickerAction::clear_mimetype() { + _impl_.mimetype_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const std::string& SyncActionValue_StickerAction::mimetype() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.mimetype) + return _internal_mimetype(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SyncActionValue_StickerAction::set_mimetype(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.mimetype_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.mimetype) +} +inline std::string* SyncActionValue_StickerAction::mutable_mimetype() { + std::string* _s = _internal_mutable_mimetype(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.StickerAction.mimetype) + return _s; +} +inline const std::string& SyncActionValue_StickerAction::_internal_mimetype() const { + return _impl_.mimetype_.Get(); +} +inline void SyncActionValue_StickerAction::_internal_set_mimetype(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.mimetype_.Set(value, GetArenaForAllocation()); +} +inline std::string* SyncActionValue_StickerAction::_internal_mutable_mimetype() { + _impl_._has_bits_[0] |= 0x00000008u; + return _impl_.mimetype_.Mutable(GetArenaForAllocation()); +} +inline std::string* SyncActionValue_StickerAction::release_mimetype() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.StickerAction.mimetype) + if (!_internal_has_mimetype()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000008u; + auto* p = _impl_.mimetype_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mimetype_.IsDefault()) { + _impl_.mimetype_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SyncActionValue_StickerAction::set_allocated_mimetype(std::string* mimetype) { + if (mimetype != nullptr) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mimetype_.IsDefault()) { + _impl_.mimetype_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.StickerAction.mimetype) +} + +// optional uint32 height = 5; +inline bool SyncActionValue_StickerAction::_internal_has_height() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool SyncActionValue_StickerAction::has_height() const { + return _internal_has_height(); +} +inline void SyncActionValue_StickerAction::clear_height() { + _impl_.height_ = 0u; + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline uint32_t SyncActionValue_StickerAction::_internal_height() const { + return _impl_.height_; +} +inline uint32_t SyncActionValue_StickerAction::height() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.height) + return _internal_height(); +} +inline void SyncActionValue_StickerAction::_internal_set_height(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.height_ = value; +} +inline void SyncActionValue_StickerAction::set_height(uint32_t value) { + _internal_set_height(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.height) +} + +// optional uint32 width = 6; +inline bool SyncActionValue_StickerAction::_internal_has_width() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool SyncActionValue_StickerAction::has_width() const { + return _internal_has_width(); +} +inline void SyncActionValue_StickerAction::clear_width() { + _impl_.width_ = 0u; + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline uint32_t SyncActionValue_StickerAction::_internal_width() const { + return _impl_.width_; +} +inline uint32_t SyncActionValue_StickerAction::width() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.width) + return _internal_width(); +} +inline void SyncActionValue_StickerAction::_internal_set_width(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.width_ = value; +} +inline void SyncActionValue_StickerAction::set_width(uint32_t value) { + _internal_set_width(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.width) +} + +// optional string directPath = 7; +inline bool SyncActionValue_StickerAction::_internal_has_directpath() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool SyncActionValue_StickerAction::has_directpath() const { + return _internal_has_directpath(); +} +inline void SyncActionValue_StickerAction::clear_directpath() { + _impl_.directpath_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const std::string& SyncActionValue_StickerAction::directpath() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.directPath) + return _internal_directpath(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SyncActionValue_StickerAction::set_directpath(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.directpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.directPath) +} +inline std::string* SyncActionValue_StickerAction::mutable_directpath() { + std::string* _s = _internal_mutable_directpath(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.StickerAction.directPath) + return _s; +} +inline const std::string& SyncActionValue_StickerAction::_internal_directpath() const { + return _impl_.directpath_.Get(); +} +inline void SyncActionValue_StickerAction::_internal_set_directpath(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.directpath_.Set(value, GetArenaForAllocation()); +} +inline std::string* SyncActionValue_StickerAction::_internal_mutable_directpath() { + _impl_._has_bits_[0] |= 0x00000010u; + return _impl_.directpath_.Mutable(GetArenaForAllocation()); +} +inline std::string* SyncActionValue_StickerAction::release_directpath() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.StickerAction.directPath) + if (!_internal_has_directpath()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000010u; + auto* p = _impl_.directpath_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.directpath_.IsDefault()) { + _impl_.directpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SyncActionValue_StickerAction::set_allocated_directpath(std::string* directpath) { + if (directpath != nullptr) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.directpath_.IsDefault()) { + _impl_.directpath_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.StickerAction.directPath) +} + +// optional uint64 fileLength = 8; +inline bool SyncActionValue_StickerAction::_internal_has_filelength() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool SyncActionValue_StickerAction::has_filelength() const { + return _internal_has_filelength(); +} +inline void SyncActionValue_StickerAction::clear_filelength() { + _impl_.filelength_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline uint64_t SyncActionValue_StickerAction::_internal_filelength() const { + return _impl_.filelength_; +} +inline uint64_t SyncActionValue_StickerAction::filelength() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.fileLength) + return _internal_filelength(); +} +inline void SyncActionValue_StickerAction::_internal_set_filelength(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.filelength_ = value; +} +inline void SyncActionValue_StickerAction::set_filelength(uint64_t value) { + _internal_set_filelength(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.fileLength) +} + +// optional bool isFavorite = 9; +inline bool SyncActionValue_StickerAction::_internal_has_isfavorite() const { + bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool SyncActionValue_StickerAction::has_isfavorite() const { + return _internal_has_isfavorite(); +} +inline void SyncActionValue_StickerAction::clear_isfavorite() { + _impl_.isfavorite_ = false; + _impl_._has_bits_[0] &= ~0x00000100u; +} +inline bool SyncActionValue_StickerAction::_internal_isfavorite() const { + return _impl_.isfavorite_; +} +inline bool SyncActionValue_StickerAction::isfavorite() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.isFavorite) + return _internal_isfavorite(); +} +inline void SyncActionValue_StickerAction::_internal_set_isfavorite(bool value) { + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.isfavorite_ = value; +} +inline void SyncActionValue_StickerAction::set_isfavorite(bool value) { + _internal_set_isfavorite(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.isFavorite) +} + +// optional uint32 deviceIdHint = 10; +inline bool SyncActionValue_StickerAction::_internal_has_deviceidhint() const { + bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool SyncActionValue_StickerAction::has_deviceidhint() const { + return _internal_has_deviceidhint(); +} +inline void SyncActionValue_StickerAction::clear_deviceidhint() { + _impl_.deviceidhint_ = 0u; + _impl_._has_bits_[0] &= ~0x00000200u; +} +inline uint32_t SyncActionValue_StickerAction::_internal_deviceidhint() const { + return _impl_.deviceidhint_; +} +inline uint32_t SyncActionValue_StickerAction::deviceidhint() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.deviceIdHint) + return _internal_deviceidhint(); +} +inline void SyncActionValue_StickerAction::_internal_set_deviceidhint(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.deviceidhint_ = value; +} +inline void SyncActionValue_StickerAction::set_deviceidhint(uint32_t value) { + _internal_set_deviceidhint(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.deviceIdHint) +} + +// ------------------------------------------------------------------- + +// SyncActionValue_SubscriptionAction + +// optional bool isDeactivated = 1; +inline bool SyncActionValue_SubscriptionAction::_internal_has_isdeactivated() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SyncActionValue_SubscriptionAction::has_isdeactivated() const { + return _internal_has_isdeactivated(); +} +inline void SyncActionValue_SubscriptionAction::clear_isdeactivated() { + _impl_.isdeactivated_ = false; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline bool SyncActionValue_SubscriptionAction::_internal_isdeactivated() const { + return _impl_.isdeactivated_; +} +inline bool SyncActionValue_SubscriptionAction::isdeactivated() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.SubscriptionAction.isDeactivated) + return _internal_isdeactivated(); +} +inline void SyncActionValue_SubscriptionAction::_internal_set_isdeactivated(bool value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.isdeactivated_ = value; +} +inline void SyncActionValue_SubscriptionAction::set_isdeactivated(bool value) { + _internal_set_isdeactivated(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.SubscriptionAction.isDeactivated) +} + +// optional bool isAutoRenewing = 2; +inline bool SyncActionValue_SubscriptionAction::_internal_has_isautorenewing() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool SyncActionValue_SubscriptionAction::has_isautorenewing() const { + return _internal_has_isautorenewing(); +} +inline void SyncActionValue_SubscriptionAction::clear_isautorenewing() { + _impl_.isautorenewing_ = false; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline bool SyncActionValue_SubscriptionAction::_internal_isautorenewing() const { + return _impl_.isautorenewing_; +} +inline bool SyncActionValue_SubscriptionAction::isautorenewing() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.SubscriptionAction.isAutoRenewing) + return _internal_isautorenewing(); +} +inline void SyncActionValue_SubscriptionAction::_internal_set_isautorenewing(bool value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.isautorenewing_ = value; +} +inline void SyncActionValue_SubscriptionAction::set_isautorenewing(bool value) { + _internal_set_isautorenewing(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.SubscriptionAction.isAutoRenewing) +} + +// optional int64 expirationDate = 3; +inline bool SyncActionValue_SubscriptionAction::_internal_has_expirationdate() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SyncActionValue_SubscriptionAction::has_expirationdate() const { + return _internal_has_expirationdate(); +} +inline void SyncActionValue_SubscriptionAction::clear_expirationdate() { + _impl_.expirationdate_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline int64_t SyncActionValue_SubscriptionAction::_internal_expirationdate() const { + return _impl_.expirationdate_; +} +inline int64_t SyncActionValue_SubscriptionAction::expirationdate() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.SubscriptionAction.expirationDate) + return _internal_expirationdate(); +} +inline void SyncActionValue_SubscriptionAction::_internal_set_expirationdate(int64_t value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.expirationdate_ = value; +} +inline void SyncActionValue_SubscriptionAction::set_expirationdate(int64_t value) { + _internal_set_expirationdate(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.SubscriptionAction.expirationDate) +} + +// ------------------------------------------------------------------- + +// SyncActionValue_SyncActionMessageRange + +// optional int64 lastMessageTimestamp = 1; +inline bool SyncActionValue_SyncActionMessageRange::_internal_has_lastmessagetimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SyncActionValue_SyncActionMessageRange::has_lastmessagetimestamp() const { + return _internal_has_lastmessagetimestamp(); +} +inline void SyncActionValue_SyncActionMessageRange::clear_lastmessagetimestamp() { + _impl_.lastmessagetimestamp_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline int64_t SyncActionValue_SyncActionMessageRange::_internal_lastmessagetimestamp() const { + return _impl_.lastmessagetimestamp_; +} +inline int64_t SyncActionValue_SyncActionMessageRange::lastmessagetimestamp() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.SyncActionMessageRange.lastMessageTimestamp) + return _internal_lastmessagetimestamp(); +} +inline void SyncActionValue_SyncActionMessageRange::_internal_set_lastmessagetimestamp(int64_t value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.lastmessagetimestamp_ = value; +} +inline void SyncActionValue_SyncActionMessageRange::set_lastmessagetimestamp(int64_t value) { + _internal_set_lastmessagetimestamp(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.SyncActionMessageRange.lastMessageTimestamp) +} + +// optional int64 lastSystemMessageTimestamp = 2; +inline bool SyncActionValue_SyncActionMessageRange::_internal_has_lastsystemmessagetimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SyncActionValue_SyncActionMessageRange::has_lastsystemmessagetimestamp() const { + return _internal_has_lastsystemmessagetimestamp(); +} +inline void SyncActionValue_SyncActionMessageRange::clear_lastsystemmessagetimestamp() { + _impl_.lastsystemmessagetimestamp_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline int64_t SyncActionValue_SyncActionMessageRange::_internal_lastsystemmessagetimestamp() const { + return _impl_.lastsystemmessagetimestamp_; +} +inline int64_t SyncActionValue_SyncActionMessageRange::lastsystemmessagetimestamp() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.SyncActionMessageRange.lastSystemMessageTimestamp) + return _internal_lastsystemmessagetimestamp(); +} +inline void SyncActionValue_SyncActionMessageRange::_internal_set_lastsystemmessagetimestamp(int64_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.lastsystemmessagetimestamp_ = value; +} +inline void SyncActionValue_SyncActionMessageRange::set_lastsystemmessagetimestamp(int64_t value) { + _internal_set_lastsystemmessagetimestamp(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.SyncActionMessageRange.lastSystemMessageTimestamp) +} + +// repeated .proto.SyncActionValue.SyncActionMessage messages = 3; +inline int SyncActionValue_SyncActionMessageRange::_internal_messages_size() const { + return _impl_.messages_.size(); +} +inline int SyncActionValue_SyncActionMessageRange::messages_size() const { + return _internal_messages_size(); +} +inline void SyncActionValue_SyncActionMessageRange::clear_messages() { + _impl_.messages_.Clear(); +} +inline ::proto::SyncActionValue_SyncActionMessage* SyncActionValue_SyncActionMessageRange::mutable_messages(int index) { + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.SyncActionMessageRange.messages) + return _impl_.messages_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncActionValue_SyncActionMessage >* +SyncActionValue_SyncActionMessageRange::mutable_messages() { + // @@protoc_insertion_point(field_mutable_list:proto.SyncActionValue.SyncActionMessageRange.messages) + return &_impl_.messages_; +} +inline const ::proto::SyncActionValue_SyncActionMessage& SyncActionValue_SyncActionMessageRange::_internal_messages(int index) const { + return _impl_.messages_.Get(index); +} +inline const ::proto::SyncActionValue_SyncActionMessage& SyncActionValue_SyncActionMessageRange::messages(int index) const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.SyncActionMessageRange.messages) + return _internal_messages(index); +} +inline ::proto::SyncActionValue_SyncActionMessage* SyncActionValue_SyncActionMessageRange::_internal_add_messages() { + return _impl_.messages_.Add(); +} +inline ::proto::SyncActionValue_SyncActionMessage* SyncActionValue_SyncActionMessageRange::add_messages() { + ::proto::SyncActionValue_SyncActionMessage* _add = _internal_add_messages(); + // @@protoc_insertion_point(field_add:proto.SyncActionValue.SyncActionMessageRange.messages) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncActionValue_SyncActionMessage >& +SyncActionValue_SyncActionMessageRange::messages() const { + // @@protoc_insertion_point(field_list:proto.SyncActionValue.SyncActionMessageRange.messages) + return _impl_.messages_; +} + +// ------------------------------------------------------------------- + +// SyncActionValue_SyncActionMessage + +// optional .proto.MessageKey key = 1; +inline bool SyncActionValue_SyncActionMessage::_internal_has_key() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr); + return value; +} +inline bool SyncActionValue_SyncActionMessage::has_key() const { + return _internal_has_key(); +} +inline void SyncActionValue_SyncActionMessage::clear_key() { + if (_impl_.key_ != nullptr) _impl_.key_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::MessageKey& SyncActionValue_SyncActionMessage::_internal_key() const { + const ::proto::MessageKey* p = _impl_.key_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_MessageKey_default_instance_); +} +inline const ::proto::MessageKey& SyncActionValue_SyncActionMessage::key() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.SyncActionMessage.key) + return _internal_key(); +} +inline void SyncActionValue_SyncActionMessage::unsafe_arena_set_allocated_key( + ::proto::MessageKey* key) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_); + } + _impl_.key_ = key; + if (key) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.SyncActionMessage.key) +} +inline ::proto::MessageKey* SyncActionValue_SyncActionMessage::release_key() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::MessageKey* temp = _impl_.key_; + _impl_.key_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::MessageKey* SyncActionValue_SyncActionMessage::unsafe_arena_release_key() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.SyncActionMessage.key) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::MessageKey* temp = _impl_.key_; + _impl_.key_ = nullptr; + return temp; +} +inline ::proto::MessageKey* SyncActionValue_SyncActionMessage::_internal_mutable_key() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.key_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation()); + _impl_.key_ = p; + } + return _impl_.key_; +} +inline ::proto::MessageKey* SyncActionValue_SyncActionMessage::mutable_key() { + ::proto::MessageKey* _msg = _internal_mutable_key(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.SyncActionMessage.key) + return _msg; +} +inline void SyncActionValue_SyncActionMessage::set_allocated_key(::proto::MessageKey* key) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.key_; + } + if (key) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key); + if (message_arena != submessage_arena) { + key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, key, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.key_ = key; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.SyncActionMessage.key) +} + +// optional int64 timestamp = 2; +inline bool SyncActionValue_SyncActionMessage::_internal_has_timestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SyncActionValue_SyncActionMessage::has_timestamp() const { + return _internal_has_timestamp(); +} +inline void SyncActionValue_SyncActionMessage::clear_timestamp() { + _impl_.timestamp_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline int64_t SyncActionValue_SyncActionMessage::_internal_timestamp() const { + return _impl_.timestamp_; +} +inline int64_t SyncActionValue_SyncActionMessage::timestamp() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.SyncActionMessage.timestamp) + return _internal_timestamp(); +} +inline void SyncActionValue_SyncActionMessage::_internal_set_timestamp(int64_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.timestamp_ = value; +} +inline void SyncActionValue_SyncActionMessage::set_timestamp(int64_t value) { + _internal_set_timestamp(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.SyncActionMessage.timestamp) +} + +// ------------------------------------------------------------------- + +// SyncActionValue_TimeFormatAction + +// optional bool isTwentyFourHourFormatEnabled = 1; +inline bool SyncActionValue_TimeFormatAction::_internal_has_istwentyfourhourformatenabled() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SyncActionValue_TimeFormatAction::has_istwentyfourhourformatenabled() const { + return _internal_has_istwentyfourhourformatenabled(); +} +inline void SyncActionValue_TimeFormatAction::clear_istwentyfourhourformatenabled() { + _impl_.istwentyfourhourformatenabled_ = false; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline bool SyncActionValue_TimeFormatAction::_internal_istwentyfourhourformatenabled() const { + return _impl_.istwentyfourhourformatenabled_; +} +inline bool SyncActionValue_TimeFormatAction::istwentyfourhourformatenabled() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.TimeFormatAction.isTwentyFourHourFormatEnabled) + return _internal_istwentyfourhourformatenabled(); +} +inline void SyncActionValue_TimeFormatAction::_internal_set_istwentyfourhourformatenabled(bool value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.istwentyfourhourformatenabled_ = value; +} +inline void SyncActionValue_TimeFormatAction::set_istwentyfourhourformatenabled(bool value) { + _internal_set_istwentyfourhourformatenabled(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.TimeFormatAction.isTwentyFourHourFormatEnabled) +} + +// ------------------------------------------------------------------- + +// SyncActionValue_UnarchiveChatsSetting + +// optional bool unarchiveChats = 1; +inline bool SyncActionValue_UnarchiveChatsSetting::_internal_has_unarchivechats() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SyncActionValue_UnarchiveChatsSetting::has_unarchivechats() const { + return _internal_has_unarchivechats(); +} +inline void SyncActionValue_UnarchiveChatsSetting::clear_unarchivechats() { + _impl_.unarchivechats_ = false; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline bool SyncActionValue_UnarchiveChatsSetting::_internal_unarchivechats() const { + return _impl_.unarchivechats_; +} +inline bool SyncActionValue_UnarchiveChatsSetting::unarchivechats() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.UnarchiveChatsSetting.unarchiveChats) + return _internal_unarchivechats(); +} +inline void SyncActionValue_UnarchiveChatsSetting::_internal_set_unarchivechats(bool value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.unarchivechats_ = value; +} +inline void SyncActionValue_UnarchiveChatsSetting::set_unarchivechats(bool value) { + _internal_set_unarchivechats(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.UnarchiveChatsSetting.unarchiveChats) +} + +// ------------------------------------------------------------------- + +// SyncActionValue_UserStatusMuteAction + +// optional bool muted = 1; +inline bool SyncActionValue_UserStatusMuteAction::_internal_has_muted() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SyncActionValue_UserStatusMuteAction::has_muted() const { + return _internal_has_muted(); +} +inline void SyncActionValue_UserStatusMuteAction::clear_muted() { + _impl_.muted_ = false; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline bool SyncActionValue_UserStatusMuteAction::_internal_muted() const { + return _impl_.muted_; +} +inline bool SyncActionValue_UserStatusMuteAction::muted() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.UserStatusMuteAction.muted) + return _internal_muted(); +} +inline void SyncActionValue_UserStatusMuteAction::_internal_set_muted(bool value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.muted_ = value; +} +inline void SyncActionValue_UserStatusMuteAction::set_muted(bool value) { + _internal_set_muted(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.UserStatusMuteAction.muted) +} + +// ------------------------------------------------------------------- + +// SyncActionValue + +// optional int64 timestamp = 1; +inline bool SyncActionValue::_internal_has_timestamp() const { + bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0; + return value; +} +inline bool SyncActionValue::has_timestamp() const { + return _internal_has_timestamp(); +} +inline void SyncActionValue::clear_timestamp() { + _impl_.timestamp_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x08000000u; +} +inline int64_t SyncActionValue::_internal_timestamp() const { + return _impl_.timestamp_; +} +inline int64_t SyncActionValue::timestamp() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.timestamp) + return _internal_timestamp(); +} +inline void SyncActionValue::_internal_set_timestamp(int64_t value) { + _impl_._has_bits_[0] |= 0x08000000u; + _impl_.timestamp_ = value; +} +inline void SyncActionValue::set_timestamp(int64_t value) { + _internal_set_timestamp(value); + // @@protoc_insertion_point(field_set:proto.SyncActionValue.timestamp) +} + +// optional .proto.SyncActionValue.StarAction starAction = 2; +inline bool SyncActionValue::_internal_has_staraction() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.staraction_ != nullptr); + return value; +} +inline bool SyncActionValue::has_staraction() const { + return _internal_has_staraction(); +} +inline void SyncActionValue::clear_staraction() { + if (_impl_.staraction_ != nullptr) _impl_.staraction_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::SyncActionValue_StarAction& SyncActionValue::_internal_staraction() const { + const ::proto::SyncActionValue_StarAction* p = _impl_.staraction_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_StarAction_default_instance_); +} +inline const ::proto::SyncActionValue_StarAction& SyncActionValue::staraction() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.starAction) + return _internal_staraction(); +} +inline void SyncActionValue::unsafe_arena_set_allocated_staraction( + ::proto::SyncActionValue_StarAction* staraction) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.staraction_); + } + _impl_.staraction_ = staraction; + if (staraction) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.starAction) +} +inline ::proto::SyncActionValue_StarAction* SyncActionValue::release_staraction() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::SyncActionValue_StarAction* temp = _impl_.staraction_; + _impl_.staraction_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue_StarAction* SyncActionValue::unsafe_arena_release_staraction() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.starAction) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::SyncActionValue_StarAction* temp = _impl_.staraction_; + _impl_.staraction_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue_StarAction* SyncActionValue::_internal_mutable_staraction() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.staraction_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue_StarAction>(GetArenaForAllocation()); + _impl_.staraction_ = p; + } + return _impl_.staraction_; +} +inline ::proto::SyncActionValue_StarAction* SyncActionValue::mutable_staraction() { + ::proto::SyncActionValue_StarAction* _msg = _internal_mutable_staraction(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.starAction) + return _msg; +} +inline void SyncActionValue::set_allocated_staraction(::proto::SyncActionValue_StarAction* staraction) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.staraction_; + } + if (staraction) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(staraction); + if (message_arena != submessage_arena) { + staraction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, staraction, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.staraction_ = staraction; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.starAction) +} + +// optional .proto.SyncActionValue.ContactAction contactAction = 3; +inline bool SyncActionValue::_internal_has_contactaction() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.contactaction_ != nullptr); + return value; +} +inline bool SyncActionValue::has_contactaction() const { + return _internal_has_contactaction(); +} +inline void SyncActionValue::clear_contactaction() { + if (_impl_.contactaction_ != nullptr) _impl_.contactaction_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::SyncActionValue_ContactAction& SyncActionValue::_internal_contactaction() const { + const ::proto::SyncActionValue_ContactAction* p = _impl_.contactaction_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_ContactAction_default_instance_); +} +inline const ::proto::SyncActionValue_ContactAction& SyncActionValue::contactaction() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.contactAction) + return _internal_contactaction(); +} +inline void SyncActionValue::unsafe_arena_set_allocated_contactaction( + ::proto::SyncActionValue_ContactAction* contactaction) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contactaction_); + } + _impl_.contactaction_ = contactaction; + if (contactaction) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.contactAction) +} +inline ::proto::SyncActionValue_ContactAction* SyncActionValue::release_contactaction() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::SyncActionValue_ContactAction* temp = _impl_.contactaction_; + _impl_.contactaction_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue_ContactAction* SyncActionValue::unsafe_arena_release_contactaction() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.contactAction) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::SyncActionValue_ContactAction* temp = _impl_.contactaction_; + _impl_.contactaction_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue_ContactAction* SyncActionValue::_internal_mutable_contactaction() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.contactaction_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue_ContactAction>(GetArenaForAllocation()); + _impl_.contactaction_ = p; + } + return _impl_.contactaction_; +} +inline ::proto::SyncActionValue_ContactAction* SyncActionValue::mutable_contactaction() { + ::proto::SyncActionValue_ContactAction* _msg = _internal_mutable_contactaction(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.contactAction) + return _msg; +} +inline void SyncActionValue::set_allocated_contactaction(::proto::SyncActionValue_ContactAction* contactaction) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.contactaction_; + } + if (contactaction) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contactaction); + if (message_arena != submessage_arena) { + contactaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, contactaction, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.contactaction_ = contactaction; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.contactAction) +} + +// optional .proto.SyncActionValue.MuteAction muteAction = 4; +inline bool SyncActionValue::_internal_has_muteaction() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.muteaction_ != nullptr); + return value; +} +inline bool SyncActionValue::has_muteaction() const { + return _internal_has_muteaction(); +} +inline void SyncActionValue::clear_muteaction() { + if (_impl_.muteaction_ != nullptr) _impl_.muteaction_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::proto::SyncActionValue_MuteAction& SyncActionValue::_internal_muteaction() const { + const ::proto::SyncActionValue_MuteAction* p = _impl_.muteaction_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_MuteAction_default_instance_); +} +inline const ::proto::SyncActionValue_MuteAction& SyncActionValue::muteaction() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.muteAction) + return _internal_muteaction(); +} +inline void SyncActionValue::unsafe_arena_set_allocated_muteaction( + ::proto::SyncActionValue_MuteAction* muteaction) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.muteaction_); + } + _impl_.muteaction_ = muteaction; + if (muteaction) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.muteAction) +} +inline ::proto::SyncActionValue_MuteAction* SyncActionValue::release_muteaction() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::SyncActionValue_MuteAction* temp = _impl_.muteaction_; + _impl_.muteaction_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue_MuteAction* SyncActionValue::unsafe_arena_release_muteaction() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.muteAction) + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::SyncActionValue_MuteAction* temp = _impl_.muteaction_; + _impl_.muteaction_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue_MuteAction* SyncActionValue::_internal_mutable_muteaction() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.muteaction_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue_MuteAction>(GetArenaForAllocation()); + _impl_.muteaction_ = p; + } + return _impl_.muteaction_; +} +inline ::proto::SyncActionValue_MuteAction* SyncActionValue::mutable_muteaction() { + ::proto::SyncActionValue_MuteAction* _msg = _internal_mutable_muteaction(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.muteAction) + return _msg; +} +inline void SyncActionValue::set_allocated_muteaction(::proto::SyncActionValue_MuteAction* muteaction) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.muteaction_; + } + if (muteaction) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(muteaction); + if (message_arena != submessage_arena) { + muteaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, muteaction, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.muteaction_ = muteaction; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.muteAction) +} + +// optional .proto.SyncActionValue.PinAction pinAction = 5; +inline bool SyncActionValue::_internal_has_pinaction() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || _impl_.pinaction_ != nullptr); + return value; +} +inline bool SyncActionValue::has_pinaction() const { + return _internal_has_pinaction(); +} +inline void SyncActionValue::clear_pinaction() { + if (_impl_.pinaction_ != nullptr) _impl_.pinaction_->Clear(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const ::proto::SyncActionValue_PinAction& SyncActionValue::_internal_pinaction() const { + const ::proto::SyncActionValue_PinAction* p = _impl_.pinaction_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_PinAction_default_instance_); +} +inline const ::proto::SyncActionValue_PinAction& SyncActionValue::pinaction() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.pinAction) + return _internal_pinaction(); +} +inline void SyncActionValue::unsafe_arena_set_allocated_pinaction( + ::proto::SyncActionValue_PinAction* pinaction) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pinaction_); + } + _impl_.pinaction_ = pinaction; + if (pinaction) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.pinAction) +} +inline ::proto::SyncActionValue_PinAction* SyncActionValue::release_pinaction() { + _impl_._has_bits_[0] &= ~0x00000008u; + ::proto::SyncActionValue_PinAction* temp = _impl_.pinaction_; + _impl_.pinaction_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue_PinAction* SyncActionValue::unsafe_arena_release_pinaction() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.pinAction) + _impl_._has_bits_[0] &= ~0x00000008u; + ::proto::SyncActionValue_PinAction* temp = _impl_.pinaction_; + _impl_.pinaction_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue_PinAction* SyncActionValue::_internal_mutable_pinaction() { + _impl_._has_bits_[0] |= 0x00000008u; + if (_impl_.pinaction_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue_PinAction>(GetArenaForAllocation()); + _impl_.pinaction_ = p; + } + return _impl_.pinaction_; +} +inline ::proto::SyncActionValue_PinAction* SyncActionValue::mutable_pinaction() { + ::proto::SyncActionValue_PinAction* _msg = _internal_mutable_pinaction(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.pinAction) + return _msg; +} +inline void SyncActionValue::set_allocated_pinaction(::proto::SyncActionValue_PinAction* pinaction) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.pinaction_; + } + if (pinaction) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pinaction); + if (message_arena != submessage_arena) { + pinaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, pinaction, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.pinaction_ = pinaction; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.pinAction) +} + +// optional .proto.SyncActionValue.SecurityNotificationSetting securityNotificationSetting = 6; +inline bool SyncActionValue::_internal_has_securitynotificationsetting() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + PROTOBUF_ASSUME(!value || _impl_.securitynotificationsetting_ != nullptr); + return value; +} +inline bool SyncActionValue::has_securitynotificationsetting() const { + return _internal_has_securitynotificationsetting(); +} +inline void SyncActionValue::clear_securitynotificationsetting() { + if (_impl_.securitynotificationsetting_ != nullptr) _impl_.securitynotificationsetting_->Clear(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const ::proto::SyncActionValue_SecurityNotificationSetting& SyncActionValue::_internal_securitynotificationsetting() const { + const ::proto::SyncActionValue_SecurityNotificationSetting* p = _impl_.securitynotificationsetting_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_SecurityNotificationSetting_default_instance_); +} +inline const ::proto::SyncActionValue_SecurityNotificationSetting& SyncActionValue::securitynotificationsetting() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.securityNotificationSetting) + return _internal_securitynotificationsetting(); +} +inline void SyncActionValue::unsafe_arena_set_allocated_securitynotificationsetting( + ::proto::SyncActionValue_SecurityNotificationSetting* securitynotificationsetting) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.securitynotificationsetting_); + } + _impl_.securitynotificationsetting_ = securitynotificationsetting; + if (securitynotificationsetting) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.securityNotificationSetting) +} +inline ::proto::SyncActionValue_SecurityNotificationSetting* SyncActionValue::release_securitynotificationsetting() { + _impl_._has_bits_[0] &= ~0x00000010u; + ::proto::SyncActionValue_SecurityNotificationSetting* temp = _impl_.securitynotificationsetting_; + _impl_.securitynotificationsetting_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue_SecurityNotificationSetting* SyncActionValue::unsafe_arena_release_securitynotificationsetting() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.securityNotificationSetting) + _impl_._has_bits_[0] &= ~0x00000010u; + ::proto::SyncActionValue_SecurityNotificationSetting* temp = _impl_.securitynotificationsetting_; + _impl_.securitynotificationsetting_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue_SecurityNotificationSetting* SyncActionValue::_internal_mutable_securitynotificationsetting() { + _impl_._has_bits_[0] |= 0x00000010u; + if (_impl_.securitynotificationsetting_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue_SecurityNotificationSetting>(GetArenaForAllocation()); + _impl_.securitynotificationsetting_ = p; + } + return _impl_.securitynotificationsetting_; +} +inline ::proto::SyncActionValue_SecurityNotificationSetting* SyncActionValue::mutable_securitynotificationsetting() { + ::proto::SyncActionValue_SecurityNotificationSetting* _msg = _internal_mutable_securitynotificationsetting(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.securityNotificationSetting) + return _msg; +} +inline void SyncActionValue::set_allocated_securitynotificationsetting(::proto::SyncActionValue_SecurityNotificationSetting* securitynotificationsetting) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.securitynotificationsetting_; + } + if (securitynotificationsetting) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(securitynotificationsetting); + if (message_arena != submessage_arena) { + securitynotificationsetting = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, securitynotificationsetting, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.securitynotificationsetting_ = securitynotificationsetting; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.securityNotificationSetting) +} + +// optional .proto.SyncActionValue.PushNameSetting pushNameSetting = 7; +inline bool SyncActionValue::_internal_has_pushnamesetting() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + PROTOBUF_ASSUME(!value || _impl_.pushnamesetting_ != nullptr); + return value; +} +inline bool SyncActionValue::has_pushnamesetting() const { + return _internal_has_pushnamesetting(); +} +inline void SyncActionValue::clear_pushnamesetting() { + if (_impl_.pushnamesetting_ != nullptr) _impl_.pushnamesetting_->Clear(); + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline const ::proto::SyncActionValue_PushNameSetting& SyncActionValue::_internal_pushnamesetting() const { + const ::proto::SyncActionValue_PushNameSetting* p = _impl_.pushnamesetting_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_PushNameSetting_default_instance_); +} +inline const ::proto::SyncActionValue_PushNameSetting& SyncActionValue::pushnamesetting() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.pushNameSetting) + return _internal_pushnamesetting(); +} +inline void SyncActionValue::unsafe_arena_set_allocated_pushnamesetting( + ::proto::SyncActionValue_PushNameSetting* pushnamesetting) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pushnamesetting_); + } + _impl_.pushnamesetting_ = pushnamesetting; + if (pushnamesetting) { + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.pushNameSetting) +} +inline ::proto::SyncActionValue_PushNameSetting* SyncActionValue::release_pushnamesetting() { + _impl_._has_bits_[0] &= ~0x00000020u; + ::proto::SyncActionValue_PushNameSetting* temp = _impl_.pushnamesetting_; + _impl_.pushnamesetting_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue_PushNameSetting* SyncActionValue::unsafe_arena_release_pushnamesetting() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.pushNameSetting) + _impl_._has_bits_[0] &= ~0x00000020u; + ::proto::SyncActionValue_PushNameSetting* temp = _impl_.pushnamesetting_; + _impl_.pushnamesetting_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue_PushNameSetting* SyncActionValue::_internal_mutable_pushnamesetting() { + _impl_._has_bits_[0] |= 0x00000020u; + if (_impl_.pushnamesetting_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue_PushNameSetting>(GetArenaForAllocation()); + _impl_.pushnamesetting_ = p; + } + return _impl_.pushnamesetting_; +} +inline ::proto::SyncActionValue_PushNameSetting* SyncActionValue::mutable_pushnamesetting() { + ::proto::SyncActionValue_PushNameSetting* _msg = _internal_mutable_pushnamesetting(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.pushNameSetting) + return _msg; +} +inline void SyncActionValue::set_allocated_pushnamesetting(::proto::SyncActionValue_PushNameSetting* pushnamesetting) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.pushnamesetting_; + } + if (pushnamesetting) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pushnamesetting); + if (message_arena != submessage_arena) { + pushnamesetting = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, pushnamesetting, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + _impl_.pushnamesetting_ = pushnamesetting; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.pushNameSetting) +} + +// optional .proto.SyncActionValue.QuickReplyAction quickReplyAction = 8; +inline bool SyncActionValue::_internal_has_quickreplyaction() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + PROTOBUF_ASSUME(!value || _impl_.quickreplyaction_ != nullptr); + return value; +} +inline bool SyncActionValue::has_quickreplyaction() const { + return _internal_has_quickreplyaction(); +} +inline void SyncActionValue::clear_quickreplyaction() { + if (_impl_.quickreplyaction_ != nullptr) _impl_.quickreplyaction_->Clear(); + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline const ::proto::SyncActionValue_QuickReplyAction& SyncActionValue::_internal_quickreplyaction() const { + const ::proto::SyncActionValue_QuickReplyAction* p = _impl_.quickreplyaction_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_QuickReplyAction_default_instance_); +} +inline const ::proto::SyncActionValue_QuickReplyAction& SyncActionValue::quickreplyaction() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.quickReplyAction) + return _internal_quickreplyaction(); +} +inline void SyncActionValue::unsafe_arena_set_allocated_quickreplyaction( + ::proto::SyncActionValue_QuickReplyAction* quickreplyaction) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quickreplyaction_); + } + _impl_.quickreplyaction_ = quickreplyaction; + if (quickreplyaction) { + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.quickReplyAction) +} +inline ::proto::SyncActionValue_QuickReplyAction* SyncActionValue::release_quickreplyaction() { + _impl_._has_bits_[0] &= ~0x00000040u; + ::proto::SyncActionValue_QuickReplyAction* temp = _impl_.quickreplyaction_; + _impl_.quickreplyaction_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue_QuickReplyAction* SyncActionValue::unsafe_arena_release_quickreplyaction() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.quickReplyAction) + _impl_._has_bits_[0] &= ~0x00000040u; + ::proto::SyncActionValue_QuickReplyAction* temp = _impl_.quickreplyaction_; + _impl_.quickreplyaction_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue_QuickReplyAction* SyncActionValue::_internal_mutable_quickreplyaction() { + _impl_._has_bits_[0] |= 0x00000040u; + if (_impl_.quickreplyaction_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue_QuickReplyAction>(GetArenaForAllocation()); + _impl_.quickreplyaction_ = p; + } + return _impl_.quickreplyaction_; +} +inline ::proto::SyncActionValue_QuickReplyAction* SyncActionValue::mutable_quickreplyaction() { + ::proto::SyncActionValue_QuickReplyAction* _msg = _internal_mutable_quickreplyaction(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.quickReplyAction) + return _msg; +} +inline void SyncActionValue::set_allocated_quickreplyaction(::proto::SyncActionValue_QuickReplyAction* quickreplyaction) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.quickreplyaction_; + } + if (quickreplyaction) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quickreplyaction); + if (message_arena != submessage_arena) { + quickreplyaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, quickreplyaction, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + _impl_.quickreplyaction_ = quickreplyaction; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.quickReplyAction) +} + +// optional .proto.SyncActionValue.RecentEmojiWeightsAction recentEmojiWeightsAction = 11; +inline bool SyncActionValue::_internal_has_recentemojiweightsaction() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + PROTOBUF_ASSUME(!value || _impl_.recentemojiweightsaction_ != nullptr); + return value; +} +inline bool SyncActionValue::has_recentemojiweightsaction() const { + return _internal_has_recentemojiweightsaction(); +} +inline void SyncActionValue::clear_recentemojiweightsaction() { + if (_impl_.recentemojiweightsaction_ != nullptr) _impl_.recentemojiweightsaction_->Clear(); + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline const ::proto::SyncActionValue_RecentEmojiWeightsAction& SyncActionValue::_internal_recentemojiweightsaction() const { + const ::proto::SyncActionValue_RecentEmojiWeightsAction* p = _impl_.recentemojiweightsaction_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_RecentEmojiWeightsAction_default_instance_); +} +inline const ::proto::SyncActionValue_RecentEmojiWeightsAction& SyncActionValue::recentemojiweightsaction() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.recentEmojiWeightsAction) + return _internal_recentemojiweightsaction(); +} +inline void SyncActionValue::unsafe_arena_set_allocated_recentemojiweightsaction( + ::proto::SyncActionValue_RecentEmojiWeightsAction* recentemojiweightsaction) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.recentemojiweightsaction_); + } + _impl_.recentemojiweightsaction_ = recentemojiweightsaction; + if (recentemojiweightsaction) { + _impl_._has_bits_[0] |= 0x00000080u; + } else { + _impl_._has_bits_[0] &= ~0x00000080u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.recentEmojiWeightsAction) +} +inline ::proto::SyncActionValue_RecentEmojiWeightsAction* SyncActionValue::release_recentemojiweightsaction() { + _impl_._has_bits_[0] &= ~0x00000080u; + ::proto::SyncActionValue_RecentEmojiWeightsAction* temp = _impl_.recentemojiweightsaction_; + _impl_.recentemojiweightsaction_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue_RecentEmojiWeightsAction* SyncActionValue::unsafe_arena_release_recentemojiweightsaction() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.recentEmojiWeightsAction) + _impl_._has_bits_[0] &= ~0x00000080u; + ::proto::SyncActionValue_RecentEmojiWeightsAction* temp = _impl_.recentemojiweightsaction_; + _impl_.recentemojiweightsaction_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue_RecentEmojiWeightsAction* SyncActionValue::_internal_mutable_recentemojiweightsaction() { + _impl_._has_bits_[0] |= 0x00000080u; + if (_impl_.recentemojiweightsaction_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue_RecentEmojiWeightsAction>(GetArenaForAllocation()); + _impl_.recentemojiweightsaction_ = p; + } + return _impl_.recentemojiweightsaction_; +} +inline ::proto::SyncActionValue_RecentEmojiWeightsAction* SyncActionValue::mutable_recentemojiweightsaction() { + ::proto::SyncActionValue_RecentEmojiWeightsAction* _msg = _internal_mutable_recentemojiweightsaction(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.recentEmojiWeightsAction) + return _msg; +} +inline void SyncActionValue::set_allocated_recentemojiweightsaction(::proto::SyncActionValue_RecentEmojiWeightsAction* recentemojiweightsaction) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.recentemojiweightsaction_; + } + if (recentemojiweightsaction) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(recentemojiweightsaction); + if (message_arena != submessage_arena) { + recentemojiweightsaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, recentemojiweightsaction, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000080u; + } else { + _impl_._has_bits_[0] &= ~0x00000080u; + } + _impl_.recentemojiweightsaction_ = recentemojiweightsaction; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.recentEmojiWeightsAction) +} + +// optional .proto.SyncActionValue.LabelEditAction labelEditAction = 14; +inline bool SyncActionValue::_internal_has_labeleditaction() const { + bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; + PROTOBUF_ASSUME(!value || _impl_.labeleditaction_ != nullptr); + return value; +} +inline bool SyncActionValue::has_labeleditaction() const { + return _internal_has_labeleditaction(); +} +inline void SyncActionValue::clear_labeleditaction() { + if (_impl_.labeleditaction_ != nullptr) _impl_.labeleditaction_->Clear(); + _impl_._has_bits_[0] &= ~0x00000100u; +} +inline const ::proto::SyncActionValue_LabelEditAction& SyncActionValue::_internal_labeleditaction() const { + const ::proto::SyncActionValue_LabelEditAction* p = _impl_.labeleditaction_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_LabelEditAction_default_instance_); +} +inline const ::proto::SyncActionValue_LabelEditAction& SyncActionValue::labeleditaction() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.labelEditAction) + return _internal_labeleditaction(); +} +inline void SyncActionValue::unsafe_arena_set_allocated_labeleditaction( + ::proto::SyncActionValue_LabelEditAction* labeleditaction) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.labeleditaction_); + } + _impl_.labeleditaction_ = labeleditaction; + if (labeleditaction) { + _impl_._has_bits_[0] |= 0x00000100u; + } else { + _impl_._has_bits_[0] &= ~0x00000100u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.labelEditAction) +} +inline ::proto::SyncActionValue_LabelEditAction* SyncActionValue::release_labeleditaction() { + _impl_._has_bits_[0] &= ~0x00000100u; + ::proto::SyncActionValue_LabelEditAction* temp = _impl_.labeleditaction_; + _impl_.labeleditaction_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue_LabelEditAction* SyncActionValue::unsafe_arena_release_labeleditaction() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.labelEditAction) + _impl_._has_bits_[0] &= ~0x00000100u; + ::proto::SyncActionValue_LabelEditAction* temp = _impl_.labeleditaction_; + _impl_.labeleditaction_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue_LabelEditAction* SyncActionValue::_internal_mutable_labeleditaction() { + _impl_._has_bits_[0] |= 0x00000100u; + if (_impl_.labeleditaction_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue_LabelEditAction>(GetArenaForAllocation()); + _impl_.labeleditaction_ = p; + } + return _impl_.labeleditaction_; +} +inline ::proto::SyncActionValue_LabelEditAction* SyncActionValue::mutable_labeleditaction() { + ::proto::SyncActionValue_LabelEditAction* _msg = _internal_mutable_labeleditaction(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.labelEditAction) + return _msg; +} +inline void SyncActionValue::set_allocated_labeleditaction(::proto::SyncActionValue_LabelEditAction* labeleditaction) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.labeleditaction_; + } + if (labeleditaction) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(labeleditaction); + if (message_arena != submessage_arena) { + labeleditaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, labeleditaction, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000100u; + } else { + _impl_._has_bits_[0] &= ~0x00000100u; + } + _impl_.labeleditaction_ = labeleditaction; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.labelEditAction) +} + +// optional .proto.SyncActionValue.LabelAssociationAction labelAssociationAction = 15; +inline bool SyncActionValue::_internal_has_labelassociationaction() const { + bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; + PROTOBUF_ASSUME(!value || _impl_.labelassociationaction_ != nullptr); + return value; +} +inline bool SyncActionValue::has_labelassociationaction() const { + return _internal_has_labelassociationaction(); +} +inline void SyncActionValue::clear_labelassociationaction() { + if (_impl_.labelassociationaction_ != nullptr) _impl_.labelassociationaction_->Clear(); + _impl_._has_bits_[0] &= ~0x00000200u; +} +inline const ::proto::SyncActionValue_LabelAssociationAction& SyncActionValue::_internal_labelassociationaction() const { + const ::proto::SyncActionValue_LabelAssociationAction* p = _impl_.labelassociationaction_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_LabelAssociationAction_default_instance_); +} +inline const ::proto::SyncActionValue_LabelAssociationAction& SyncActionValue::labelassociationaction() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.labelAssociationAction) + return _internal_labelassociationaction(); +} +inline void SyncActionValue::unsafe_arena_set_allocated_labelassociationaction( + ::proto::SyncActionValue_LabelAssociationAction* labelassociationaction) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.labelassociationaction_); + } + _impl_.labelassociationaction_ = labelassociationaction; + if (labelassociationaction) { + _impl_._has_bits_[0] |= 0x00000200u; + } else { + _impl_._has_bits_[0] &= ~0x00000200u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.labelAssociationAction) +} +inline ::proto::SyncActionValue_LabelAssociationAction* SyncActionValue::release_labelassociationaction() { + _impl_._has_bits_[0] &= ~0x00000200u; + ::proto::SyncActionValue_LabelAssociationAction* temp = _impl_.labelassociationaction_; + _impl_.labelassociationaction_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue_LabelAssociationAction* SyncActionValue::unsafe_arena_release_labelassociationaction() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.labelAssociationAction) + _impl_._has_bits_[0] &= ~0x00000200u; + ::proto::SyncActionValue_LabelAssociationAction* temp = _impl_.labelassociationaction_; + _impl_.labelassociationaction_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue_LabelAssociationAction* SyncActionValue::_internal_mutable_labelassociationaction() { + _impl_._has_bits_[0] |= 0x00000200u; + if (_impl_.labelassociationaction_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue_LabelAssociationAction>(GetArenaForAllocation()); + _impl_.labelassociationaction_ = p; + } + return _impl_.labelassociationaction_; +} +inline ::proto::SyncActionValue_LabelAssociationAction* SyncActionValue::mutable_labelassociationaction() { + ::proto::SyncActionValue_LabelAssociationAction* _msg = _internal_mutable_labelassociationaction(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.labelAssociationAction) + return _msg; +} +inline void SyncActionValue::set_allocated_labelassociationaction(::proto::SyncActionValue_LabelAssociationAction* labelassociationaction) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.labelassociationaction_; + } + if (labelassociationaction) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(labelassociationaction); + if (message_arena != submessage_arena) { + labelassociationaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, labelassociationaction, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000200u; + } else { + _impl_._has_bits_[0] &= ~0x00000200u; + } + _impl_.labelassociationaction_ = labelassociationaction; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.labelAssociationAction) +} + +// optional .proto.SyncActionValue.LocaleSetting localeSetting = 16; +inline bool SyncActionValue::_internal_has_localesetting() const { + bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; + PROTOBUF_ASSUME(!value || _impl_.localesetting_ != nullptr); + return value; +} +inline bool SyncActionValue::has_localesetting() const { + return _internal_has_localesetting(); +} +inline void SyncActionValue::clear_localesetting() { + if (_impl_.localesetting_ != nullptr) _impl_.localesetting_->Clear(); + _impl_._has_bits_[0] &= ~0x00000400u; +} +inline const ::proto::SyncActionValue_LocaleSetting& SyncActionValue::_internal_localesetting() const { + const ::proto::SyncActionValue_LocaleSetting* p = _impl_.localesetting_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_LocaleSetting_default_instance_); +} +inline const ::proto::SyncActionValue_LocaleSetting& SyncActionValue::localesetting() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.localeSetting) + return _internal_localesetting(); +} +inline void SyncActionValue::unsafe_arena_set_allocated_localesetting( + ::proto::SyncActionValue_LocaleSetting* localesetting) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.localesetting_); + } + _impl_.localesetting_ = localesetting; + if (localesetting) { + _impl_._has_bits_[0] |= 0x00000400u; + } else { + _impl_._has_bits_[0] &= ~0x00000400u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.localeSetting) +} +inline ::proto::SyncActionValue_LocaleSetting* SyncActionValue::release_localesetting() { + _impl_._has_bits_[0] &= ~0x00000400u; + ::proto::SyncActionValue_LocaleSetting* temp = _impl_.localesetting_; + _impl_.localesetting_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue_LocaleSetting* SyncActionValue::unsafe_arena_release_localesetting() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.localeSetting) + _impl_._has_bits_[0] &= ~0x00000400u; + ::proto::SyncActionValue_LocaleSetting* temp = _impl_.localesetting_; + _impl_.localesetting_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue_LocaleSetting* SyncActionValue::_internal_mutable_localesetting() { + _impl_._has_bits_[0] |= 0x00000400u; + if (_impl_.localesetting_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue_LocaleSetting>(GetArenaForAllocation()); + _impl_.localesetting_ = p; + } + return _impl_.localesetting_; +} +inline ::proto::SyncActionValue_LocaleSetting* SyncActionValue::mutable_localesetting() { + ::proto::SyncActionValue_LocaleSetting* _msg = _internal_mutable_localesetting(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.localeSetting) + return _msg; +} +inline void SyncActionValue::set_allocated_localesetting(::proto::SyncActionValue_LocaleSetting* localesetting) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.localesetting_; + } + if (localesetting) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(localesetting); + if (message_arena != submessage_arena) { + localesetting = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, localesetting, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000400u; + } else { + _impl_._has_bits_[0] &= ~0x00000400u; + } + _impl_.localesetting_ = localesetting; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.localeSetting) +} + +// optional .proto.SyncActionValue.ArchiveChatAction archiveChatAction = 17; +inline bool SyncActionValue::_internal_has_archivechataction() const { + bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; + PROTOBUF_ASSUME(!value || _impl_.archivechataction_ != nullptr); + return value; +} +inline bool SyncActionValue::has_archivechataction() const { + return _internal_has_archivechataction(); +} +inline void SyncActionValue::clear_archivechataction() { + if (_impl_.archivechataction_ != nullptr) _impl_.archivechataction_->Clear(); + _impl_._has_bits_[0] &= ~0x00000800u; +} +inline const ::proto::SyncActionValue_ArchiveChatAction& SyncActionValue::_internal_archivechataction() const { + const ::proto::SyncActionValue_ArchiveChatAction* p = _impl_.archivechataction_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_ArchiveChatAction_default_instance_); +} +inline const ::proto::SyncActionValue_ArchiveChatAction& SyncActionValue::archivechataction() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.archiveChatAction) + return _internal_archivechataction(); +} +inline void SyncActionValue::unsafe_arena_set_allocated_archivechataction( + ::proto::SyncActionValue_ArchiveChatAction* archivechataction) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.archivechataction_); + } + _impl_.archivechataction_ = archivechataction; + if (archivechataction) { + _impl_._has_bits_[0] |= 0x00000800u; + } else { + _impl_._has_bits_[0] &= ~0x00000800u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.archiveChatAction) +} +inline ::proto::SyncActionValue_ArchiveChatAction* SyncActionValue::release_archivechataction() { + _impl_._has_bits_[0] &= ~0x00000800u; + ::proto::SyncActionValue_ArchiveChatAction* temp = _impl_.archivechataction_; + _impl_.archivechataction_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue_ArchiveChatAction* SyncActionValue::unsafe_arena_release_archivechataction() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.archiveChatAction) + _impl_._has_bits_[0] &= ~0x00000800u; + ::proto::SyncActionValue_ArchiveChatAction* temp = _impl_.archivechataction_; + _impl_.archivechataction_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue_ArchiveChatAction* SyncActionValue::_internal_mutable_archivechataction() { + _impl_._has_bits_[0] |= 0x00000800u; + if (_impl_.archivechataction_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue_ArchiveChatAction>(GetArenaForAllocation()); + _impl_.archivechataction_ = p; + } + return _impl_.archivechataction_; +} +inline ::proto::SyncActionValue_ArchiveChatAction* SyncActionValue::mutable_archivechataction() { + ::proto::SyncActionValue_ArchiveChatAction* _msg = _internal_mutable_archivechataction(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.archiveChatAction) + return _msg; +} +inline void SyncActionValue::set_allocated_archivechataction(::proto::SyncActionValue_ArchiveChatAction* archivechataction) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.archivechataction_; + } + if (archivechataction) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(archivechataction); + if (message_arena != submessage_arena) { + archivechataction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, archivechataction, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000800u; + } else { + _impl_._has_bits_[0] &= ~0x00000800u; + } + _impl_.archivechataction_ = archivechataction; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.archiveChatAction) +} + +// optional .proto.SyncActionValue.DeleteMessageForMeAction deleteMessageForMeAction = 18; +inline bool SyncActionValue::_internal_has_deletemessageformeaction() const { + bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.deletemessageformeaction_ != nullptr); + return value; +} +inline bool SyncActionValue::has_deletemessageformeaction() const { + return _internal_has_deletemessageformeaction(); +} +inline void SyncActionValue::clear_deletemessageformeaction() { + if (_impl_.deletemessageformeaction_ != nullptr) _impl_.deletemessageformeaction_->Clear(); + _impl_._has_bits_[0] &= ~0x00001000u; +} +inline const ::proto::SyncActionValue_DeleteMessageForMeAction& SyncActionValue::_internal_deletemessageformeaction() const { + const ::proto::SyncActionValue_DeleteMessageForMeAction* p = _impl_.deletemessageformeaction_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_DeleteMessageForMeAction_default_instance_); +} +inline const ::proto::SyncActionValue_DeleteMessageForMeAction& SyncActionValue::deletemessageformeaction() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.deleteMessageForMeAction) + return _internal_deletemessageformeaction(); +} +inline void SyncActionValue::unsafe_arena_set_allocated_deletemessageformeaction( + ::proto::SyncActionValue_DeleteMessageForMeAction* deletemessageformeaction) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.deletemessageformeaction_); + } + _impl_.deletemessageformeaction_ = deletemessageformeaction; + if (deletemessageformeaction) { + _impl_._has_bits_[0] |= 0x00001000u; + } else { + _impl_._has_bits_[0] &= ~0x00001000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.deleteMessageForMeAction) +} +inline ::proto::SyncActionValue_DeleteMessageForMeAction* SyncActionValue::release_deletemessageformeaction() { + _impl_._has_bits_[0] &= ~0x00001000u; + ::proto::SyncActionValue_DeleteMessageForMeAction* temp = _impl_.deletemessageformeaction_; + _impl_.deletemessageformeaction_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue_DeleteMessageForMeAction* SyncActionValue::unsafe_arena_release_deletemessageformeaction() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.deleteMessageForMeAction) + _impl_._has_bits_[0] &= ~0x00001000u; + ::proto::SyncActionValue_DeleteMessageForMeAction* temp = _impl_.deletemessageformeaction_; + _impl_.deletemessageformeaction_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue_DeleteMessageForMeAction* SyncActionValue::_internal_mutable_deletemessageformeaction() { + _impl_._has_bits_[0] |= 0x00001000u; + if (_impl_.deletemessageformeaction_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue_DeleteMessageForMeAction>(GetArenaForAllocation()); + _impl_.deletemessageformeaction_ = p; + } + return _impl_.deletemessageformeaction_; +} +inline ::proto::SyncActionValue_DeleteMessageForMeAction* SyncActionValue::mutable_deletemessageformeaction() { + ::proto::SyncActionValue_DeleteMessageForMeAction* _msg = _internal_mutable_deletemessageformeaction(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.deleteMessageForMeAction) + return _msg; +} +inline void SyncActionValue::set_allocated_deletemessageformeaction(::proto::SyncActionValue_DeleteMessageForMeAction* deletemessageformeaction) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.deletemessageformeaction_; + } + if (deletemessageformeaction) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(deletemessageformeaction); + if (message_arena != submessage_arena) { + deletemessageformeaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, deletemessageformeaction, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00001000u; + } else { + _impl_._has_bits_[0] &= ~0x00001000u; + } + _impl_.deletemessageformeaction_ = deletemessageformeaction; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.deleteMessageForMeAction) +} + +// optional .proto.SyncActionValue.KeyExpiration keyExpiration = 19; +inline bool SyncActionValue::_internal_has_keyexpiration() const { + bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.keyexpiration_ != nullptr); + return value; +} +inline bool SyncActionValue::has_keyexpiration() const { + return _internal_has_keyexpiration(); +} +inline void SyncActionValue::clear_keyexpiration() { + if (_impl_.keyexpiration_ != nullptr) _impl_.keyexpiration_->Clear(); + _impl_._has_bits_[0] &= ~0x00002000u; +} +inline const ::proto::SyncActionValue_KeyExpiration& SyncActionValue::_internal_keyexpiration() const { + const ::proto::SyncActionValue_KeyExpiration* p = _impl_.keyexpiration_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_KeyExpiration_default_instance_); +} +inline const ::proto::SyncActionValue_KeyExpiration& SyncActionValue::keyexpiration() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.keyExpiration) + return _internal_keyexpiration(); +} +inline void SyncActionValue::unsafe_arena_set_allocated_keyexpiration( + ::proto::SyncActionValue_KeyExpiration* keyexpiration) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keyexpiration_); + } + _impl_.keyexpiration_ = keyexpiration; + if (keyexpiration) { + _impl_._has_bits_[0] |= 0x00002000u; + } else { + _impl_._has_bits_[0] &= ~0x00002000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.keyExpiration) +} +inline ::proto::SyncActionValue_KeyExpiration* SyncActionValue::release_keyexpiration() { + _impl_._has_bits_[0] &= ~0x00002000u; + ::proto::SyncActionValue_KeyExpiration* temp = _impl_.keyexpiration_; + _impl_.keyexpiration_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue_KeyExpiration* SyncActionValue::unsafe_arena_release_keyexpiration() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.keyExpiration) + _impl_._has_bits_[0] &= ~0x00002000u; + ::proto::SyncActionValue_KeyExpiration* temp = _impl_.keyexpiration_; + _impl_.keyexpiration_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue_KeyExpiration* SyncActionValue::_internal_mutable_keyexpiration() { + _impl_._has_bits_[0] |= 0x00002000u; + if (_impl_.keyexpiration_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue_KeyExpiration>(GetArenaForAllocation()); + _impl_.keyexpiration_ = p; + } + return _impl_.keyexpiration_; +} +inline ::proto::SyncActionValue_KeyExpiration* SyncActionValue::mutable_keyexpiration() { + ::proto::SyncActionValue_KeyExpiration* _msg = _internal_mutable_keyexpiration(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.keyExpiration) + return _msg; +} +inline void SyncActionValue::set_allocated_keyexpiration(::proto::SyncActionValue_KeyExpiration* keyexpiration) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.keyexpiration_; + } + if (keyexpiration) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keyexpiration); + if (message_arena != submessage_arena) { + keyexpiration = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, keyexpiration, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00002000u; + } else { + _impl_._has_bits_[0] &= ~0x00002000u; + } + _impl_.keyexpiration_ = keyexpiration; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.keyExpiration) +} + +// optional .proto.SyncActionValue.MarkChatAsReadAction markChatAsReadAction = 20; +inline bool SyncActionValue::_internal_has_markchatasreadaction() const { + bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.markchatasreadaction_ != nullptr); + return value; +} +inline bool SyncActionValue::has_markchatasreadaction() const { + return _internal_has_markchatasreadaction(); +} +inline void SyncActionValue::clear_markchatasreadaction() { + if (_impl_.markchatasreadaction_ != nullptr) _impl_.markchatasreadaction_->Clear(); + _impl_._has_bits_[0] &= ~0x00004000u; +} +inline const ::proto::SyncActionValue_MarkChatAsReadAction& SyncActionValue::_internal_markchatasreadaction() const { + const ::proto::SyncActionValue_MarkChatAsReadAction* p = _impl_.markchatasreadaction_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_MarkChatAsReadAction_default_instance_); +} +inline const ::proto::SyncActionValue_MarkChatAsReadAction& SyncActionValue::markchatasreadaction() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.markChatAsReadAction) + return _internal_markchatasreadaction(); +} +inline void SyncActionValue::unsafe_arena_set_allocated_markchatasreadaction( + ::proto::SyncActionValue_MarkChatAsReadAction* markchatasreadaction) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.markchatasreadaction_); + } + _impl_.markchatasreadaction_ = markchatasreadaction; + if (markchatasreadaction) { + _impl_._has_bits_[0] |= 0x00004000u; + } else { + _impl_._has_bits_[0] &= ~0x00004000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.markChatAsReadAction) +} +inline ::proto::SyncActionValue_MarkChatAsReadAction* SyncActionValue::release_markchatasreadaction() { + _impl_._has_bits_[0] &= ~0x00004000u; + ::proto::SyncActionValue_MarkChatAsReadAction* temp = _impl_.markchatasreadaction_; + _impl_.markchatasreadaction_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue_MarkChatAsReadAction* SyncActionValue::unsafe_arena_release_markchatasreadaction() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.markChatAsReadAction) + _impl_._has_bits_[0] &= ~0x00004000u; + ::proto::SyncActionValue_MarkChatAsReadAction* temp = _impl_.markchatasreadaction_; + _impl_.markchatasreadaction_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue_MarkChatAsReadAction* SyncActionValue::_internal_mutable_markchatasreadaction() { + _impl_._has_bits_[0] |= 0x00004000u; + if (_impl_.markchatasreadaction_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue_MarkChatAsReadAction>(GetArenaForAllocation()); + _impl_.markchatasreadaction_ = p; + } + return _impl_.markchatasreadaction_; +} +inline ::proto::SyncActionValue_MarkChatAsReadAction* SyncActionValue::mutable_markchatasreadaction() { + ::proto::SyncActionValue_MarkChatAsReadAction* _msg = _internal_mutable_markchatasreadaction(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.markChatAsReadAction) + return _msg; +} +inline void SyncActionValue::set_allocated_markchatasreadaction(::proto::SyncActionValue_MarkChatAsReadAction* markchatasreadaction) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.markchatasreadaction_; + } + if (markchatasreadaction) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(markchatasreadaction); + if (message_arena != submessage_arena) { + markchatasreadaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, markchatasreadaction, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00004000u; + } else { + _impl_._has_bits_[0] &= ~0x00004000u; + } + _impl_.markchatasreadaction_ = markchatasreadaction; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.markChatAsReadAction) +} + +// optional .proto.SyncActionValue.ClearChatAction clearChatAction = 21; +inline bool SyncActionValue::_internal_has_clearchataction() const { + bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.clearchataction_ != nullptr); + return value; +} +inline bool SyncActionValue::has_clearchataction() const { + return _internal_has_clearchataction(); +} +inline void SyncActionValue::clear_clearchataction() { + if (_impl_.clearchataction_ != nullptr) _impl_.clearchataction_->Clear(); + _impl_._has_bits_[0] &= ~0x00008000u; +} +inline const ::proto::SyncActionValue_ClearChatAction& SyncActionValue::_internal_clearchataction() const { + const ::proto::SyncActionValue_ClearChatAction* p = _impl_.clearchataction_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_ClearChatAction_default_instance_); +} +inline const ::proto::SyncActionValue_ClearChatAction& SyncActionValue::clearchataction() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.clearChatAction) + return _internal_clearchataction(); +} +inline void SyncActionValue::unsafe_arena_set_allocated_clearchataction( + ::proto::SyncActionValue_ClearChatAction* clearchataction) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.clearchataction_); + } + _impl_.clearchataction_ = clearchataction; + if (clearchataction) { + _impl_._has_bits_[0] |= 0x00008000u; + } else { + _impl_._has_bits_[0] &= ~0x00008000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.clearChatAction) +} +inline ::proto::SyncActionValue_ClearChatAction* SyncActionValue::release_clearchataction() { + _impl_._has_bits_[0] &= ~0x00008000u; + ::proto::SyncActionValue_ClearChatAction* temp = _impl_.clearchataction_; + _impl_.clearchataction_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue_ClearChatAction* SyncActionValue::unsafe_arena_release_clearchataction() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.clearChatAction) + _impl_._has_bits_[0] &= ~0x00008000u; + ::proto::SyncActionValue_ClearChatAction* temp = _impl_.clearchataction_; + _impl_.clearchataction_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue_ClearChatAction* SyncActionValue::_internal_mutable_clearchataction() { + _impl_._has_bits_[0] |= 0x00008000u; + if (_impl_.clearchataction_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue_ClearChatAction>(GetArenaForAllocation()); + _impl_.clearchataction_ = p; + } + return _impl_.clearchataction_; +} +inline ::proto::SyncActionValue_ClearChatAction* SyncActionValue::mutable_clearchataction() { + ::proto::SyncActionValue_ClearChatAction* _msg = _internal_mutable_clearchataction(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.clearChatAction) + return _msg; +} +inline void SyncActionValue::set_allocated_clearchataction(::proto::SyncActionValue_ClearChatAction* clearchataction) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.clearchataction_; + } + if (clearchataction) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(clearchataction); + if (message_arena != submessage_arena) { + clearchataction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, clearchataction, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00008000u; + } else { + _impl_._has_bits_[0] &= ~0x00008000u; + } + _impl_.clearchataction_ = clearchataction; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.clearChatAction) +} + +// optional .proto.SyncActionValue.DeleteChatAction deleteChatAction = 22; +inline bool SyncActionValue::_internal_has_deletechataction() const { + bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.deletechataction_ != nullptr); + return value; +} +inline bool SyncActionValue::has_deletechataction() const { + return _internal_has_deletechataction(); +} +inline void SyncActionValue::clear_deletechataction() { + if (_impl_.deletechataction_ != nullptr) _impl_.deletechataction_->Clear(); + _impl_._has_bits_[0] &= ~0x00010000u; +} +inline const ::proto::SyncActionValue_DeleteChatAction& SyncActionValue::_internal_deletechataction() const { + const ::proto::SyncActionValue_DeleteChatAction* p = _impl_.deletechataction_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_DeleteChatAction_default_instance_); +} +inline const ::proto::SyncActionValue_DeleteChatAction& SyncActionValue::deletechataction() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.deleteChatAction) + return _internal_deletechataction(); +} +inline void SyncActionValue::unsafe_arena_set_allocated_deletechataction( + ::proto::SyncActionValue_DeleteChatAction* deletechataction) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.deletechataction_); + } + _impl_.deletechataction_ = deletechataction; + if (deletechataction) { + _impl_._has_bits_[0] |= 0x00010000u; + } else { + _impl_._has_bits_[0] &= ~0x00010000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.deleteChatAction) +} +inline ::proto::SyncActionValue_DeleteChatAction* SyncActionValue::release_deletechataction() { + _impl_._has_bits_[0] &= ~0x00010000u; + ::proto::SyncActionValue_DeleteChatAction* temp = _impl_.deletechataction_; + _impl_.deletechataction_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue_DeleteChatAction* SyncActionValue::unsafe_arena_release_deletechataction() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.deleteChatAction) + _impl_._has_bits_[0] &= ~0x00010000u; + ::proto::SyncActionValue_DeleteChatAction* temp = _impl_.deletechataction_; + _impl_.deletechataction_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue_DeleteChatAction* SyncActionValue::_internal_mutable_deletechataction() { + _impl_._has_bits_[0] |= 0x00010000u; + if (_impl_.deletechataction_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue_DeleteChatAction>(GetArenaForAllocation()); + _impl_.deletechataction_ = p; + } + return _impl_.deletechataction_; +} +inline ::proto::SyncActionValue_DeleteChatAction* SyncActionValue::mutable_deletechataction() { + ::proto::SyncActionValue_DeleteChatAction* _msg = _internal_mutable_deletechataction(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.deleteChatAction) + return _msg; +} +inline void SyncActionValue::set_allocated_deletechataction(::proto::SyncActionValue_DeleteChatAction* deletechataction) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.deletechataction_; + } + if (deletechataction) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(deletechataction); + if (message_arena != submessage_arena) { + deletechataction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, deletechataction, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00010000u; + } else { + _impl_._has_bits_[0] &= ~0x00010000u; + } + _impl_.deletechataction_ = deletechataction; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.deleteChatAction) +} + +// optional .proto.SyncActionValue.UnarchiveChatsSetting unarchiveChatsSetting = 23; +inline bool SyncActionValue::_internal_has_unarchivechatssetting() const { + bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.unarchivechatssetting_ != nullptr); + return value; +} +inline bool SyncActionValue::has_unarchivechatssetting() const { + return _internal_has_unarchivechatssetting(); +} +inline void SyncActionValue::clear_unarchivechatssetting() { + if (_impl_.unarchivechatssetting_ != nullptr) _impl_.unarchivechatssetting_->Clear(); + _impl_._has_bits_[0] &= ~0x00020000u; +} +inline const ::proto::SyncActionValue_UnarchiveChatsSetting& SyncActionValue::_internal_unarchivechatssetting() const { + const ::proto::SyncActionValue_UnarchiveChatsSetting* p = _impl_.unarchivechatssetting_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_UnarchiveChatsSetting_default_instance_); +} +inline const ::proto::SyncActionValue_UnarchiveChatsSetting& SyncActionValue::unarchivechatssetting() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.unarchiveChatsSetting) + return _internal_unarchivechatssetting(); +} +inline void SyncActionValue::unsafe_arena_set_allocated_unarchivechatssetting( + ::proto::SyncActionValue_UnarchiveChatsSetting* unarchivechatssetting) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.unarchivechatssetting_); + } + _impl_.unarchivechatssetting_ = unarchivechatssetting; + if (unarchivechatssetting) { + _impl_._has_bits_[0] |= 0x00020000u; + } else { + _impl_._has_bits_[0] &= ~0x00020000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.unarchiveChatsSetting) +} +inline ::proto::SyncActionValue_UnarchiveChatsSetting* SyncActionValue::release_unarchivechatssetting() { + _impl_._has_bits_[0] &= ~0x00020000u; + ::proto::SyncActionValue_UnarchiveChatsSetting* temp = _impl_.unarchivechatssetting_; + _impl_.unarchivechatssetting_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue_UnarchiveChatsSetting* SyncActionValue::unsafe_arena_release_unarchivechatssetting() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.unarchiveChatsSetting) + _impl_._has_bits_[0] &= ~0x00020000u; + ::proto::SyncActionValue_UnarchiveChatsSetting* temp = _impl_.unarchivechatssetting_; + _impl_.unarchivechatssetting_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue_UnarchiveChatsSetting* SyncActionValue::_internal_mutable_unarchivechatssetting() { + _impl_._has_bits_[0] |= 0x00020000u; + if (_impl_.unarchivechatssetting_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue_UnarchiveChatsSetting>(GetArenaForAllocation()); + _impl_.unarchivechatssetting_ = p; + } + return _impl_.unarchivechatssetting_; +} +inline ::proto::SyncActionValue_UnarchiveChatsSetting* SyncActionValue::mutable_unarchivechatssetting() { + ::proto::SyncActionValue_UnarchiveChatsSetting* _msg = _internal_mutable_unarchivechatssetting(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.unarchiveChatsSetting) + return _msg; +} +inline void SyncActionValue::set_allocated_unarchivechatssetting(::proto::SyncActionValue_UnarchiveChatsSetting* unarchivechatssetting) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.unarchivechatssetting_; + } + if (unarchivechatssetting) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(unarchivechatssetting); + if (message_arena != submessage_arena) { + unarchivechatssetting = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, unarchivechatssetting, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00020000u; + } else { + _impl_._has_bits_[0] &= ~0x00020000u; + } + _impl_.unarchivechatssetting_ = unarchivechatssetting; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.unarchiveChatsSetting) +} + +// optional .proto.SyncActionValue.PrimaryFeature primaryFeature = 24; +inline bool SyncActionValue::_internal_has_primaryfeature() const { + bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.primaryfeature_ != nullptr); + return value; +} +inline bool SyncActionValue::has_primaryfeature() const { + return _internal_has_primaryfeature(); +} +inline void SyncActionValue::clear_primaryfeature() { + if (_impl_.primaryfeature_ != nullptr) _impl_.primaryfeature_->Clear(); + _impl_._has_bits_[0] &= ~0x00040000u; +} +inline const ::proto::SyncActionValue_PrimaryFeature& SyncActionValue::_internal_primaryfeature() const { + const ::proto::SyncActionValue_PrimaryFeature* p = _impl_.primaryfeature_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_PrimaryFeature_default_instance_); +} +inline const ::proto::SyncActionValue_PrimaryFeature& SyncActionValue::primaryfeature() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.primaryFeature) + return _internal_primaryfeature(); +} +inline void SyncActionValue::unsafe_arena_set_allocated_primaryfeature( + ::proto::SyncActionValue_PrimaryFeature* primaryfeature) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.primaryfeature_); + } + _impl_.primaryfeature_ = primaryfeature; + if (primaryfeature) { + _impl_._has_bits_[0] |= 0x00040000u; + } else { + _impl_._has_bits_[0] &= ~0x00040000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.primaryFeature) +} +inline ::proto::SyncActionValue_PrimaryFeature* SyncActionValue::release_primaryfeature() { + _impl_._has_bits_[0] &= ~0x00040000u; + ::proto::SyncActionValue_PrimaryFeature* temp = _impl_.primaryfeature_; + _impl_.primaryfeature_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue_PrimaryFeature* SyncActionValue::unsafe_arena_release_primaryfeature() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.primaryFeature) + _impl_._has_bits_[0] &= ~0x00040000u; + ::proto::SyncActionValue_PrimaryFeature* temp = _impl_.primaryfeature_; + _impl_.primaryfeature_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue_PrimaryFeature* SyncActionValue::_internal_mutable_primaryfeature() { + _impl_._has_bits_[0] |= 0x00040000u; + if (_impl_.primaryfeature_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue_PrimaryFeature>(GetArenaForAllocation()); + _impl_.primaryfeature_ = p; + } + return _impl_.primaryfeature_; +} +inline ::proto::SyncActionValue_PrimaryFeature* SyncActionValue::mutable_primaryfeature() { + ::proto::SyncActionValue_PrimaryFeature* _msg = _internal_mutable_primaryfeature(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.primaryFeature) + return _msg; +} +inline void SyncActionValue::set_allocated_primaryfeature(::proto::SyncActionValue_PrimaryFeature* primaryfeature) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.primaryfeature_; + } + if (primaryfeature) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(primaryfeature); + if (message_arena != submessage_arena) { + primaryfeature = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, primaryfeature, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00040000u; + } else { + _impl_._has_bits_[0] &= ~0x00040000u; + } + _impl_.primaryfeature_ = primaryfeature; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.primaryFeature) +} + +// optional .proto.SyncActionValue.AndroidUnsupportedActions androidUnsupportedActions = 26; +inline bool SyncActionValue::_internal_has_androidunsupportedactions() const { + bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.androidunsupportedactions_ != nullptr); + return value; +} +inline bool SyncActionValue::has_androidunsupportedactions() const { + return _internal_has_androidunsupportedactions(); +} +inline void SyncActionValue::clear_androidunsupportedactions() { + if (_impl_.androidunsupportedactions_ != nullptr) _impl_.androidunsupportedactions_->Clear(); + _impl_._has_bits_[0] &= ~0x00080000u; +} +inline const ::proto::SyncActionValue_AndroidUnsupportedActions& SyncActionValue::_internal_androidunsupportedactions() const { + const ::proto::SyncActionValue_AndroidUnsupportedActions* p = _impl_.androidunsupportedactions_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_AndroidUnsupportedActions_default_instance_); +} +inline const ::proto::SyncActionValue_AndroidUnsupportedActions& SyncActionValue::androidunsupportedactions() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.androidUnsupportedActions) + return _internal_androidunsupportedactions(); +} +inline void SyncActionValue::unsafe_arena_set_allocated_androidunsupportedactions( + ::proto::SyncActionValue_AndroidUnsupportedActions* androidunsupportedactions) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.androidunsupportedactions_); + } + _impl_.androidunsupportedactions_ = androidunsupportedactions; + if (androidunsupportedactions) { + _impl_._has_bits_[0] |= 0x00080000u; + } else { + _impl_._has_bits_[0] &= ~0x00080000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.androidUnsupportedActions) +} +inline ::proto::SyncActionValue_AndroidUnsupportedActions* SyncActionValue::release_androidunsupportedactions() { + _impl_._has_bits_[0] &= ~0x00080000u; + ::proto::SyncActionValue_AndroidUnsupportedActions* temp = _impl_.androidunsupportedactions_; + _impl_.androidunsupportedactions_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue_AndroidUnsupportedActions* SyncActionValue::unsafe_arena_release_androidunsupportedactions() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.androidUnsupportedActions) + _impl_._has_bits_[0] &= ~0x00080000u; + ::proto::SyncActionValue_AndroidUnsupportedActions* temp = _impl_.androidunsupportedactions_; + _impl_.androidunsupportedactions_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue_AndroidUnsupportedActions* SyncActionValue::_internal_mutable_androidunsupportedactions() { + _impl_._has_bits_[0] |= 0x00080000u; + if (_impl_.androidunsupportedactions_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue_AndroidUnsupportedActions>(GetArenaForAllocation()); + _impl_.androidunsupportedactions_ = p; + } + return _impl_.androidunsupportedactions_; +} +inline ::proto::SyncActionValue_AndroidUnsupportedActions* SyncActionValue::mutable_androidunsupportedactions() { + ::proto::SyncActionValue_AndroidUnsupportedActions* _msg = _internal_mutable_androidunsupportedactions(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.androidUnsupportedActions) + return _msg; +} +inline void SyncActionValue::set_allocated_androidunsupportedactions(::proto::SyncActionValue_AndroidUnsupportedActions* androidunsupportedactions) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.androidunsupportedactions_; + } + if (androidunsupportedactions) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(androidunsupportedactions); + if (message_arena != submessage_arena) { + androidunsupportedactions = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, androidunsupportedactions, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00080000u; + } else { + _impl_._has_bits_[0] &= ~0x00080000u; + } + _impl_.androidunsupportedactions_ = androidunsupportedactions; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.androidUnsupportedActions) +} + +// optional .proto.SyncActionValue.AgentAction agentAction = 27; +inline bool SyncActionValue::_internal_has_agentaction() const { + bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.agentaction_ != nullptr); + return value; +} +inline bool SyncActionValue::has_agentaction() const { + return _internal_has_agentaction(); +} +inline void SyncActionValue::clear_agentaction() { + if (_impl_.agentaction_ != nullptr) _impl_.agentaction_->Clear(); + _impl_._has_bits_[0] &= ~0x00100000u; +} +inline const ::proto::SyncActionValue_AgentAction& SyncActionValue::_internal_agentaction() const { + const ::proto::SyncActionValue_AgentAction* p = _impl_.agentaction_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_AgentAction_default_instance_); +} +inline const ::proto::SyncActionValue_AgentAction& SyncActionValue::agentaction() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.agentAction) + return _internal_agentaction(); +} +inline void SyncActionValue::unsafe_arena_set_allocated_agentaction( + ::proto::SyncActionValue_AgentAction* agentaction) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.agentaction_); + } + _impl_.agentaction_ = agentaction; + if (agentaction) { + _impl_._has_bits_[0] |= 0x00100000u; + } else { + _impl_._has_bits_[0] &= ~0x00100000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.agentAction) +} +inline ::proto::SyncActionValue_AgentAction* SyncActionValue::release_agentaction() { + _impl_._has_bits_[0] &= ~0x00100000u; + ::proto::SyncActionValue_AgentAction* temp = _impl_.agentaction_; + _impl_.agentaction_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue_AgentAction* SyncActionValue::unsafe_arena_release_agentaction() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.agentAction) + _impl_._has_bits_[0] &= ~0x00100000u; + ::proto::SyncActionValue_AgentAction* temp = _impl_.agentaction_; + _impl_.agentaction_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue_AgentAction* SyncActionValue::_internal_mutable_agentaction() { + _impl_._has_bits_[0] |= 0x00100000u; + if (_impl_.agentaction_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue_AgentAction>(GetArenaForAllocation()); + _impl_.agentaction_ = p; + } + return _impl_.agentaction_; +} +inline ::proto::SyncActionValue_AgentAction* SyncActionValue::mutable_agentaction() { + ::proto::SyncActionValue_AgentAction* _msg = _internal_mutable_agentaction(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.agentAction) + return _msg; +} +inline void SyncActionValue::set_allocated_agentaction(::proto::SyncActionValue_AgentAction* agentaction) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.agentaction_; + } + if (agentaction) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(agentaction); + if (message_arena != submessage_arena) { + agentaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, agentaction, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00100000u; + } else { + _impl_._has_bits_[0] &= ~0x00100000u; + } + _impl_.agentaction_ = agentaction; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.agentAction) +} + +// optional .proto.SyncActionValue.SubscriptionAction subscriptionAction = 28; +inline bool SyncActionValue::_internal_has_subscriptionaction() const { + bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.subscriptionaction_ != nullptr); + return value; +} +inline bool SyncActionValue::has_subscriptionaction() const { + return _internal_has_subscriptionaction(); +} +inline void SyncActionValue::clear_subscriptionaction() { + if (_impl_.subscriptionaction_ != nullptr) _impl_.subscriptionaction_->Clear(); + _impl_._has_bits_[0] &= ~0x00200000u; +} +inline const ::proto::SyncActionValue_SubscriptionAction& SyncActionValue::_internal_subscriptionaction() const { + const ::proto::SyncActionValue_SubscriptionAction* p = _impl_.subscriptionaction_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_SubscriptionAction_default_instance_); +} +inline const ::proto::SyncActionValue_SubscriptionAction& SyncActionValue::subscriptionaction() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.subscriptionAction) + return _internal_subscriptionaction(); +} +inline void SyncActionValue::unsafe_arena_set_allocated_subscriptionaction( + ::proto::SyncActionValue_SubscriptionAction* subscriptionaction) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.subscriptionaction_); + } + _impl_.subscriptionaction_ = subscriptionaction; + if (subscriptionaction) { + _impl_._has_bits_[0] |= 0x00200000u; + } else { + _impl_._has_bits_[0] &= ~0x00200000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.subscriptionAction) +} +inline ::proto::SyncActionValue_SubscriptionAction* SyncActionValue::release_subscriptionaction() { + _impl_._has_bits_[0] &= ~0x00200000u; + ::proto::SyncActionValue_SubscriptionAction* temp = _impl_.subscriptionaction_; + _impl_.subscriptionaction_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue_SubscriptionAction* SyncActionValue::unsafe_arena_release_subscriptionaction() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.subscriptionAction) + _impl_._has_bits_[0] &= ~0x00200000u; + ::proto::SyncActionValue_SubscriptionAction* temp = _impl_.subscriptionaction_; + _impl_.subscriptionaction_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue_SubscriptionAction* SyncActionValue::_internal_mutable_subscriptionaction() { + _impl_._has_bits_[0] |= 0x00200000u; + if (_impl_.subscriptionaction_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue_SubscriptionAction>(GetArenaForAllocation()); + _impl_.subscriptionaction_ = p; + } + return _impl_.subscriptionaction_; +} +inline ::proto::SyncActionValue_SubscriptionAction* SyncActionValue::mutable_subscriptionaction() { + ::proto::SyncActionValue_SubscriptionAction* _msg = _internal_mutable_subscriptionaction(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.subscriptionAction) + return _msg; +} +inline void SyncActionValue::set_allocated_subscriptionaction(::proto::SyncActionValue_SubscriptionAction* subscriptionaction) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.subscriptionaction_; + } + if (subscriptionaction) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(subscriptionaction); + if (message_arena != submessage_arena) { + subscriptionaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, subscriptionaction, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00200000u; + } else { + _impl_._has_bits_[0] &= ~0x00200000u; + } + _impl_.subscriptionaction_ = subscriptionaction; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.subscriptionAction) +} + +// optional .proto.SyncActionValue.UserStatusMuteAction userStatusMuteAction = 29; +inline bool SyncActionValue::_internal_has_userstatusmuteaction() const { + bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.userstatusmuteaction_ != nullptr); + return value; +} +inline bool SyncActionValue::has_userstatusmuteaction() const { + return _internal_has_userstatusmuteaction(); +} +inline void SyncActionValue::clear_userstatusmuteaction() { + if (_impl_.userstatusmuteaction_ != nullptr) _impl_.userstatusmuteaction_->Clear(); + _impl_._has_bits_[0] &= ~0x00400000u; +} +inline const ::proto::SyncActionValue_UserStatusMuteAction& SyncActionValue::_internal_userstatusmuteaction() const { + const ::proto::SyncActionValue_UserStatusMuteAction* p = _impl_.userstatusmuteaction_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_UserStatusMuteAction_default_instance_); +} +inline const ::proto::SyncActionValue_UserStatusMuteAction& SyncActionValue::userstatusmuteaction() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.userStatusMuteAction) + return _internal_userstatusmuteaction(); +} +inline void SyncActionValue::unsafe_arena_set_allocated_userstatusmuteaction( + ::proto::SyncActionValue_UserStatusMuteAction* userstatusmuteaction) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.userstatusmuteaction_); + } + _impl_.userstatusmuteaction_ = userstatusmuteaction; + if (userstatusmuteaction) { + _impl_._has_bits_[0] |= 0x00400000u; + } else { + _impl_._has_bits_[0] &= ~0x00400000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.userStatusMuteAction) +} +inline ::proto::SyncActionValue_UserStatusMuteAction* SyncActionValue::release_userstatusmuteaction() { + _impl_._has_bits_[0] &= ~0x00400000u; + ::proto::SyncActionValue_UserStatusMuteAction* temp = _impl_.userstatusmuteaction_; + _impl_.userstatusmuteaction_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue_UserStatusMuteAction* SyncActionValue::unsafe_arena_release_userstatusmuteaction() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.userStatusMuteAction) + _impl_._has_bits_[0] &= ~0x00400000u; + ::proto::SyncActionValue_UserStatusMuteAction* temp = _impl_.userstatusmuteaction_; + _impl_.userstatusmuteaction_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue_UserStatusMuteAction* SyncActionValue::_internal_mutable_userstatusmuteaction() { + _impl_._has_bits_[0] |= 0x00400000u; + if (_impl_.userstatusmuteaction_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue_UserStatusMuteAction>(GetArenaForAllocation()); + _impl_.userstatusmuteaction_ = p; + } + return _impl_.userstatusmuteaction_; +} +inline ::proto::SyncActionValue_UserStatusMuteAction* SyncActionValue::mutable_userstatusmuteaction() { + ::proto::SyncActionValue_UserStatusMuteAction* _msg = _internal_mutable_userstatusmuteaction(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.userStatusMuteAction) + return _msg; +} +inline void SyncActionValue::set_allocated_userstatusmuteaction(::proto::SyncActionValue_UserStatusMuteAction* userstatusmuteaction) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.userstatusmuteaction_; + } + if (userstatusmuteaction) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(userstatusmuteaction); + if (message_arena != submessage_arena) { + userstatusmuteaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, userstatusmuteaction, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00400000u; + } else { + _impl_._has_bits_[0] &= ~0x00400000u; + } + _impl_.userstatusmuteaction_ = userstatusmuteaction; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.userStatusMuteAction) +} + +// optional .proto.SyncActionValue.TimeFormatAction timeFormatAction = 30; +inline bool SyncActionValue::_internal_has_timeformataction() const { + bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.timeformataction_ != nullptr); + return value; +} +inline bool SyncActionValue::has_timeformataction() const { + return _internal_has_timeformataction(); +} +inline void SyncActionValue::clear_timeformataction() { + if (_impl_.timeformataction_ != nullptr) _impl_.timeformataction_->Clear(); + _impl_._has_bits_[0] &= ~0x00800000u; +} +inline const ::proto::SyncActionValue_TimeFormatAction& SyncActionValue::_internal_timeformataction() const { + const ::proto::SyncActionValue_TimeFormatAction* p = _impl_.timeformataction_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_TimeFormatAction_default_instance_); +} +inline const ::proto::SyncActionValue_TimeFormatAction& SyncActionValue::timeformataction() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.timeFormatAction) + return _internal_timeformataction(); +} +inline void SyncActionValue::unsafe_arena_set_allocated_timeformataction( + ::proto::SyncActionValue_TimeFormatAction* timeformataction) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.timeformataction_); + } + _impl_.timeformataction_ = timeformataction; + if (timeformataction) { + _impl_._has_bits_[0] |= 0x00800000u; + } else { + _impl_._has_bits_[0] &= ~0x00800000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.timeFormatAction) +} +inline ::proto::SyncActionValue_TimeFormatAction* SyncActionValue::release_timeformataction() { + _impl_._has_bits_[0] &= ~0x00800000u; + ::proto::SyncActionValue_TimeFormatAction* temp = _impl_.timeformataction_; + _impl_.timeformataction_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue_TimeFormatAction* SyncActionValue::unsafe_arena_release_timeformataction() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.timeFormatAction) + _impl_._has_bits_[0] &= ~0x00800000u; + ::proto::SyncActionValue_TimeFormatAction* temp = _impl_.timeformataction_; + _impl_.timeformataction_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue_TimeFormatAction* SyncActionValue::_internal_mutable_timeformataction() { + _impl_._has_bits_[0] |= 0x00800000u; + if (_impl_.timeformataction_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue_TimeFormatAction>(GetArenaForAllocation()); + _impl_.timeformataction_ = p; + } + return _impl_.timeformataction_; +} +inline ::proto::SyncActionValue_TimeFormatAction* SyncActionValue::mutable_timeformataction() { + ::proto::SyncActionValue_TimeFormatAction* _msg = _internal_mutable_timeformataction(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.timeFormatAction) + return _msg; +} +inline void SyncActionValue::set_allocated_timeformataction(::proto::SyncActionValue_TimeFormatAction* timeformataction) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.timeformataction_; + } + if (timeformataction) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(timeformataction); + if (message_arena != submessage_arena) { + timeformataction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, timeformataction, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00800000u; + } else { + _impl_._has_bits_[0] &= ~0x00800000u; + } + _impl_.timeformataction_ = timeformataction; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.timeFormatAction) +} + +// optional .proto.SyncActionValue.NuxAction nuxAction = 31; +inline bool SyncActionValue::_internal_has_nuxaction() const { + bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.nuxaction_ != nullptr); + return value; +} +inline bool SyncActionValue::has_nuxaction() const { + return _internal_has_nuxaction(); +} +inline void SyncActionValue::clear_nuxaction() { + if (_impl_.nuxaction_ != nullptr) _impl_.nuxaction_->Clear(); + _impl_._has_bits_[0] &= ~0x01000000u; +} +inline const ::proto::SyncActionValue_NuxAction& SyncActionValue::_internal_nuxaction() const { + const ::proto::SyncActionValue_NuxAction* p = _impl_.nuxaction_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_NuxAction_default_instance_); +} +inline const ::proto::SyncActionValue_NuxAction& SyncActionValue::nuxaction() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.nuxAction) + return _internal_nuxaction(); +} +inline void SyncActionValue::unsafe_arena_set_allocated_nuxaction( + ::proto::SyncActionValue_NuxAction* nuxaction) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.nuxaction_); + } + _impl_.nuxaction_ = nuxaction; + if (nuxaction) { + _impl_._has_bits_[0] |= 0x01000000u; + } else { + _impl_._has_bits_[0] &= ~0x01000000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.nuxAction) +} +inline ::proto::SyncActionValue_NuxAction* SyncActionValue::release_nuxaction() { + _impl_._has_bits_[0] &= ~0x01000000u; + ::proto::SyncActionValue_NuxAction* temp = _impl_.nuxaction_; + _impl_.nuxaction_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue_NuxAction* SyncActionValue::unsafe_arena_release_nuxaction() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.nuxAction) + _impl_._has_bits_[0] &= ~0x01000000u; + ::proto::SyncActionValue_NuxAction* temp = _impl_.nuxaction_; + _impl_.nuxaction_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue_NuxAction* SyncActionValue::_internal_mutable_nuxaction() { + _impl_._has_bits_[0] |= 0x01000000u; + if (_impl_.nuxaction_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue_NuxAction>(GetArenaForAllocation()); + _impl_.nuxaction_ = p; + } + return _impl_.nuxaction_; +} +inline ::proto::SyncActionValue_NuxAction* SyncActionValue::mutable_nuxaction() { + ::proto::SyncActionValue_NuxAction* _msg = _internal_mutable_nuxaction(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.nuxAction) + return _msg; +} +inline void SyncActionValue::set_allocated_nuxaction(::proto::SyncActionValue_NuxAction* nuxaction) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.nuxaction_; + } + if (nuxaction) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(nuxaction); + if (message_arena != submessage_arena) { + nuxaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, nuxaction, submessage_arena); + } + _impl_._has_bits_[0] |= 0x01000000u; + } else { + _impl_._has_bits_[0] &= ~0x01000000u; + } + _impl_.nuxaction_ = nuxaction; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.nuxAction) +} + +// optional .proto.SyncActionValue.PrimaryVersionAction primaryVersionAction = 32; +inline bool SyncActionValue::_internal_has_primaryversionaction() const { + bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.primaryversionaction_ != nullptr); + return value; +} +inline bool SyncActionValue::has_primaryversionaction() const { + return _internal_has_primaryversionaction(); +} +inline void SyncActionValue::clear_primaryversionaction() { + if (_impl_.primaryversionaction_ != nullptr) _impl_.primaryversionaction_->Clear(); + _impl_._has_bits_[0] &= ~0x02000000u; +} +inline const ::proto::SyncActionValue_PrimaryVersionAction& SyncActionValue::_internal_primaryversionaction() const { + const ::proto::SyncActionValue_PrimaryVersionAction* p = _impl_.primaryversionaction_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_PrimaryVersionAction_default_instance_); +} +inline const ::proto::SyncActionValue_PrimaryVersionAction& SyncActionValue::primaryversionaction() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.primaryVersionAction) + return _internal_primaryversionaction(); +} +inline void SyncActionValue::unsafe_arena_set_allocated_primaryversionaction( + ::proto::SyncActionValue_PrimaryVersionAction* primaryversionaction) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.primaryversionaction_); + } + _impl_.primaryversionaction_ = primaryversionaction; + if (primaryversionaction) { + _impl_._has_bits_[0] |= 0x02000000u; + } else { + _impl_._has_bits_[0] &= ~0x02000000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.primaryVersionAction) +} +inline ::proto::SyncActionValue_PrimaryVersionAction* SyncActionValue::release_primaryversionaction() { + _impl_._has_bits_[0] &= ~0x02000000u; + ::proto::SyncActionValue_PrimaryVersionAction* temp = _impl_.primaryversionaction_; + _impl_.primaryversionaction_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue_PrimaryVersionAction* SyncActionValue::unsafe_arena_release_primaryversionaction() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.primaryVersionAction) + _impl_._has_bits_[0] &= ~0x02000000u; + ::proto::SyncActionValue_PrimaryVersionAction* temp = _impl_.primaryversionaction_; + _impl_.primaryversionaction_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue_PrimaryVersionAction* SyncActionValue::_internal_mutable_primaryversionaction() { + _impl_._has_bits_[0] |= 0x02000000u; + if (_impl_.primaryversionaction_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue_PrimaryVersionAction>(GetArenaForAllocation()); + _impl_.primaryversionaction_ = p; + } + return _impl_.primaryversionaction_; +} +inline ::proto::SyncActionValue_PrimaryVersionAction* SyncActionValue::mutable_primaryversionaction() { + ::proto::SyncActionValue_PrimaryVersionAction* _msg = _internal_mutable_primaryversionaction(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.primaryVersionAction) + return _msg; +} +inline void SyncActionValue::set_allocated_primaryversionaction(::proto::SyncActionValue_PrimaryVersionAction* primaryversionaction) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.primaryversionaction_; + } + if (primaryversionaction) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(primaryversionaction); + if (message_arena != submessage_arena) { + primaryversionaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, primaryversionaction, submessage_arena); + } + _impl_._has_bits_[0] |= 0x02000000u; + } else { + _impl_._has_bits_[0] &= ~0x02000000u; + } + _impl_.primaryversionaction_ = primaryversionaction; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.primaryVersionAction) +} + +// optional .proto.SyncActionValue.StickerAction stickerAction = 33; +inline bool SyncActionValue::_internal_has_stickeraction() const { + bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.stickeraction_ != nullptr); + return value; +} +inline bool SyncActionValue::has_stickeraction() const { + return _internal_has_stickeraction(); +} +inline void SyncActionValue::clear_stickeraction() { + if (_impl_.stickeraction_ != nullptr) _impl_.stickeraction_->Clear(); + _impl_._has_bits_[0] &= ~0x04000000u; +} +inline const ::proto::SyncActionValue_StickerAction& SyncActionValue::_internal_stickeraction() const { + const ::proto::SyncActionValue_StickerAction* p = _impl_.stickeraction_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncActionValue_StickerAction_default_instance_); +} +inline const ::proto::SyncActionValue_StickerAction& SyncActionValue::stickeraction() const { + // @@protoc_insertion_point(field_get:proto.SyncActionValue.stickerAction) + return _internal_stickeraction(); +} +inline void SyncActionValue::unsafe_arena_set_allocated_stickeraction( + ::proto::SyncActionValue_StickerAction* stickeraction) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.stickeraction_); + } + _impl_.stickeraction_ = stickeraction; + if (stickeraction) { + _impl_._has_bits_[0] |= 0x04000000u; + } else { + _impl_._has_bits_[0] &= ~0x04000000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.stickerAction) +} +inline ::proto::SyncActionValue_StickerAction* SyncActionValue::release_stickeraction() { + _impl_._has_bits_[0] &= ~0x04000000u; + ::proto::SyncActionValue_StickerAction* temp = _impl_.stickeraction_; + _impl_.stickeraction_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncActionValue_StickerAction* SyncActionValue::unsafe_arena_release_stickeraction() { + // @@protoc_insertion_point(field_release:proto.SyncActionValue.stickerAction) + _impl_._has_bits_[0] &= ~0x04000000u; + ::proto::SyncActionValue_StickerAction* temp = _impl_.stickeraction_; + _impl_.stickeraction_ = nullptr; + return temp; +} +inline ::proto::SyncActionValue_StickerAction* SyncActionValue::_internal_mutable_stickeraction() { + _impl_._has_bits_[0] |= 0x04000000u; + if (_impl_.stickeraction_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncActionValue_StickerAction>(GetArenaForAllocation()); + _impl_.stickeraction_ = p; + } + return _impl_.stickeraction_; +} +inline ::proto::SyncActionValue_StickerAction* SyncActionValue::mutable_stickeraction() { + ::proto::SyncActionValue_StickerAction* _msg = _internal_mutable_stickeraction(); + // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.stickerAction) + return _msg; +} +inline void SyncActionValue::set_allocated_stickeraction(::proto::SyncActionValue_StickerAction* stickeraction) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.stickeraction_; + } + if (stickeraction) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(stickeraction); + if (message_arena != submessage_arena) { + stickeraction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, stickeraction, submessage_arena); + } + _impl_._has_bits_[0] |= 0x04000000u; + } else { + _impl_._has_bits_[0] &= ~0x04000000u; + } + _impl_.stickeraction_ = stickeraction; + // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.stickerAction) +} + +// ------------------------------------------------------------------- + +// SyncdIndex + +// optional bytes blob = 1; +inline bool SyncdIndex::_internal_has_blob() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SyncdIndex::has_blob() const { + return _internal_has_blob(); +} +inline void SyncdIndex::clear_blob() { + _impl_.blob_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& SyncdIndex::blob() const { + // @@protoc_insertion_point(field_get:proto.SyncdIndex.blob) + return _internal_blob(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SyncdIndex::set_blob(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.blob_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SyncdIndex.blob) +} +inline std::string* SyncdIndex::mutable_blob() { + std::string* _s = _internal_mutable_blob(); + // @@protoc_insertion_point(field_mutable:proto.SyncdIndex.blob) + return _s; +} +inline const std::string& SyncdIndex::_internal_blob() const { + return _impl_.blob_.Get(); +} +inline void SyncdIndex::_internal_set_blob(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.blob_.Set(value, GetArenaForAllocation()); +} +inline std::string* SyncdIndex::_internal_mutable_blob() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.blob_.Mutable(GetArenaForAllocation()); +} +inline std::string* SyncdIndex::release_blob() { + // @@protoc_insertion_point(field_release:proto.SyncdIndex.blob) + if (!_internal_has_blob()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.blob_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.blob_.IsDefault()) { + _impl_.blob_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SyncdIndex::set_allocated_blob(std::string* blob) { + if (blob != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.blob_.SetAllocated(blob, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.blob_.IsDefault()) { + _impl_.blob_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SyncdIndex.blob) +} + +// ------------------------------------------------------------------- + +// SyncdMutation + +// optional .proto.SyncdMutation.SyncdOperation operation = 1; +inline bool SyncdMutation::_internal_has_operation() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SyncdMutation::has_operation() const { + return _internal_has_operation(); +} +inline void SyncdMutation::clear_operation() { + _impl_.operation_ = 0; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline ::proto::SyncdMutation_SyncdOperation SyncdMutation::_internal_operation() const { + return static_cast< ::proto::SyncdMutation_SyncdOperation >(_impl_.operation_); +} +inline ::proto::SyncdMutation_SyncdOperation SyncdMutation::operation() const { + // @@protoc_insertion_point(field_get:proto.SyncdMutation.operation) + return _internal_operation(); +} +inline void SyncdMutation::_internal_set_operation(::proto::SyncdMutation_SyncdOperation value) { + assert(::proto::SyncdMutation_SyncdOperation_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.operation_ = value; +} +inline void SyncdMutation::set_operation(::proto::SyncdMutation_SyncdOperation value) { + _internal_set_operation(value); + // @@protoc_insertion_point(field_set:proto.SyncdMutation.operation) +} + +// optional .proto.SyncdRecord record = 2; +inline bool SyncdMutation::_internal_has_record() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.record_ != nullptr); + return value; +} +inline bool SyncdMutation::has_record() const { + return _internal_has_record(); +} +inline void SyncdMutation::clear_record() { + if (_impl_.record_ != nullptr) _impl_.record_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::SyncdRecord& SyncdMutation::_internal_record() const { + const ::proto::SyncdRecord* p = _impl_.record_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncdRecord_default_instance_); +} +inline const ::proto::SyncdRecord& SyncdMutation::record() const { + // @@protoc_insertion_point(field_get:proto.SyncdMutation.record) + return _internal_record(); +} +inline void SyncdMutation::unsafe_arena_set_allocated_record( + ::proto::SyncdRecord* record) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.record_); + } + _impl_.record_ = record; + if (record) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdMutation.record) +} +inline ::proto::SyncdRecord* SyncdMutation::release_record() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::SyncdRecord* temp = _impl_.record_; + _impl_.record_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncdRecord* SyncdMutation::unsafe_arena_release_record() { + // @@protoc_insertion_point(field_release:proto.SyncdMutation.record) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::SyncdRecord* temp = _impl_.record_; + _impl_.record_ = nullptr; + return temp; +} +inline ::proto::SyncdRecord* SyncdMutation::_internal_mutable_record() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.record_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncdRecord>(GetArenaForAllocation()); + _impl_.record_ = p; + } + return _impl_.record_; +} +inline ::proto::SyncdRecord* SyncdMutation::mutable_record() { + ::proto::SyncdRecord* _msg = _internal_mutable_record(); + // @@protoc_insertion_point(field_mutable:proto.SyncdMutation.record) + return _msg; +} +inline void SyncdMutation::set_allocated_record(::proto::SyncdRecord* record) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.record_; + } + if (record) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(record); + if (message_arena != submessage_arena) { + record = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, record, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.record_ = record; + // @@protoc_insertion_point(field_set_allocated:proto.SyncdMutation.record) +} + +// ------------------------------------------------------------------- + +// SyncdMutations + +// repeated .proto.SyncdMutation mutations = 1; +inline int SyncdMutations::_internal_mutations_size() const { + return _impl_.mutations_.size(); +} +inline int SyncdMutations::mutations_size() const { + return _internal_mutations_size(); +} +inline void SyncdMutations::clear_mutations() { + _impl_.mutations_.Clear(); +} +inline ::proto::SyncdMutation* SyncdMutations::mutable_mutations(int index) { + // @@protoc_insertion_point(field_mutable:proto.SyncdMutations.mutations) + return _impl_.mutations_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >* +SyncdMutations::mutable_mutations() { + // @@protoc_insertion_point(field_mutable_list:proto.SyncdMutations.mutations) + return &_impl_.mutations_; +} +inline const ::proto::SyncdMutation& SyncdMutations::_internal_mutations(int index) const { + return _impl_.mutations_.Get(index); +} +inline const ::proto::SyncdMutation& SyncdMutations::mutations(int index) const { + // @@protoc_insertion_point(field_get:proto.SyncdMutations.mutations) + return _internal_mutations(index); +} +inline ::proto::SyncdMutation* SyncdMutations::_internal_add_mutations() { + return _impl_.mutations_.Add(); +} +inline ::proto::SyncdMutation* SyncdMutations::add_mutations() { + ::proto::SyncdMutation* _add = _internal_add_mutations(); + // @@protoc_insertion_point(field_add:proto.SyncdMutations.mutations) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >& +SyncdMutations::mutations() const { + // @@protoc_insertion_point(field_list:proto.SyncdMutations.mutations) + return _impl_.mutations_; +} + +// ------------------------------------------------------------------- + +// SyncdPatch + +// optional .proto.SyncdVersion version = 1; +inline bool SyncdPatch::_internal_has_version() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.version_ != nullptr); + return value; +} +inline bool SyncdPatch::has_version() const { + return _internal_has_version(); +} +inline void SyncdPatch::clear_version() { + if (_impl_.version_ != nullptr) _impl_.version_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::proto::SyncdVersion& SyncdPatch::_internal_version() const { + const ::proto::SyncdVersion* p = _impl_.version_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncdVersion_default_instance_); +} +inline const ::proto::SyncdVersion& SyncdPatch::version() const { + // @@protoc_insertion_point(field_get:proto.SyncdPatch.version) + return _internal_version(); +} +inline void SyncdPatch::unsafe_arena_set_allocated_version( + ::proto::SyncdVersion* version) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.version_); + } + _impl_.version_ = version; + if (version) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdPatch.version) +} +inline ::proto::SyncdVersion* SyncdPatch::release_version() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::SyncdVersion* temp = _impl_.version_; + _impl_.version_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncdVersion* SyncdPatch::unsafe_arena_release_version() { + // @@protoc_insertion_point(field_release:proto.SyncdPatch.version) + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::SyncdVersion* temp = _impl_.version_; + _impl_.version_ = nullptr; + return temp; +} +inline ::proto::SyncdVersion* SyncdPatch::_internal_mutable_version() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.version_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncdVersion>(GetArenaForAllocation()); + _impl_.version_ = p; + } + return _impl_.version_; +} +inline ::proto::SyncdVersion* SyncdPatch::mutable_version() { + ::proto::SyncdVersion* _msg = _internal_mutable_version(); + // @@protoc_insertion_point(field_mutable:proto.SyncdPatch.version) + return _msg; +} +inline void SyncdPatch::set_allocated_version(::proto::SyncdVersion* version) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.version_; + } + if (version) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(version); + if (message_arena != submessage_arena) { + version = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, version, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.version_ = version; + // @@protoc_insertion_point(field_set_allocated:proto.SyncdPatch.version) +} + +// repeated .proto.SyncdMutation mutations = 2; +inline int SyncdPatch::_internal_mutations_size() const { + return _impl_.mutations_.size(); +} +inline int SyncdPatch::mutations_size() const { + return _internal_mutations_size(); +} +inline void SyncdPatch::clear_mutations() { + _impl_.mutations_.Clear(); +} +inline ::proto::SyncdMutation* SyncdPatch::mutable_mutations(int index) { + // @@protoc_insertion_point(field_mutable:proto.SyncdPatch.mutations) + return _impl_.mutations_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >* +SyncdPatch::mutable_mutations() { + // @@protoc_insertion_point(field_mutable_list:proto.SyncdPatch.mutations) + return &_impl_.mutations_; +} +inline const ::proto::SyncdMutation& SyncdPatch::_internal_mutations(int index) const { + return _impl_.mutations_.Get(index); +} +inline const ::proto::SyncdMutation& SyncdPatch::mutations(int index) const { + // @@protoc_insertion_point(field_get:proto.SyncdPatch.mutations) + return _internal_mutations(index); +} +inline ::proto::SyncdMutation* SyncdPatch::_internal_add_mutations() { + return _impl_.mutations_.Add(); +} +inline ::proto::SyncdMutation* SyncdPatch::add_mutations() { + ::proto::SyncdMutation* _add = _internal_add_mutations(); + // @@protoc_insertion_point(field_add:proto.SyncdPatch.mutations) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >& +SyncdPatch::mutations() const { + // @@protoc_insertion_point(field_list:proto.SyncdPatch.mutations) + return _impl_.mutations_; +} + +// optional .proto.ExternalBlobReference externalMutations = 3; +inline bool SyncdPatch::_internal_has_externalmutations() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || _impl_.externalmutations_ != nullptr); + return value; +} +inline bool SyncdPatch::has_externalmutations() const { + return _internal_has_externalmutations(); +} +inline void SyncdPatch::clear_externalmutations() { + if (_impl_.externalmutations_ != nullptr) _impl_.externalmutations_->Clear(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const ::proto::ExternalBlobReference& SyncdPatch::_internal_externalmutations() const { + const ::proto::ExternalBlobReference* p = _impl_.externalmutations_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ExternalBlobReference_default_instance_); +} +inline const ::proto::ExternalBlobReference& SyncdPatch::externalmutations() const { + // @@protoc_insertion_point(field_get:proto.SyncdPatch.externalMutations) + return _internal_externalmutations(); +} +inline void SyncdPatch::unsafe_arena_set_allocated_externalmutations( + ::proto::ExternalBlobReference* externalmutations) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.externalmutations_); + } + _impl_.externalmutations_ = externalmutations; + if (externalmutations) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdPatch.externalMutations) +} +inline ::proto::ExternalBlobReference* SyncdPatch::release_externalmutations() { + _impl_._has_bits_[0] &= ~0x00000008u; + ::proto::ExternalBlobReference* temp = _impl_.externalmutations_; + _impl_.externalmutations_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ExternalBlobReference* SyncdPatch::unsafe_arena_release_externalmutations() { + // @@protoc_insertion_point(field_release:proto.SyncdPatch.externalMutations) + _impl_._has_bits_[0] &= ~0x00000008u; + ::proto::ExternalBlobReference* temp = _impl_.externalmutations_; + _impl_.externalmutations_ = nullptr; + return temp; +} +inline ::proto::ExternalBlobReference* SyncdPatch::_internal_mutable_externalmutations() { + _impl_._has_bits_[0] |= 0x00000008u; + if (_impl_.externalmutations_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ExternalBlobReference>(GetArenaForAllocation()); + _impl_.externalmutations_ = p; + } + return _impl_.externalmutations_; +} +inline ::proto::ExternalBlobReference* SyncdPatch::mutable_externalmutations() { + ::proto::ExternalBlobReference* _msg = _internal_mutable_externalmutations(); + // @@protoc_insertion_point(field_mutable:proto.SyncdPatch.externalMutations) + return _msg; +} +inline void SyncdPatch::set_allocated_externalmutations(::proto::ExternalBlobReference* externalmutations) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.externalmutations_; + } + if (externalmutations) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(externalmutations); + if (message_arena != submessage_arena) { + externalmutations = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, externalmutations, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.externalmutations_ = externalmutations; + // @@protoc_insertion_point(field_set_allocated:proto.SyncdPatch.externalMutations) +} + +// optional bytes snapshotMac = 4; +inline bool SyncdPatch::_internal_has_snapshotmac() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SyncdPatch::has_snapshotmac() const { + return _internal_has_snapshotmac(); +} +inline void SyncdPatch::clear_snapshotmac() { + _impl_.snapshotmac_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& SyncdPatch::snapshotmac() const { + // @@protoc_insertion_point(field_get:proto.SyncdPatch.snapshotMac) + return _internal_snapshotmac(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SyncdPatch::set_snapshotmac(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.snapshotmac_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SyncdPatch.snapshotMac) +} +inline std::string* SyncdPatch::mutable_snapshotmac() { + std::string* _s = _internal_mutable_snapshotmac(); + // @@protoc_insertion_point(field_mutable:proto.SyncdPatch.snapshotMac) + return _s; +} +inline const std::string& SyncdPatch::_internal_snapshotmac() const { + return _impl_.snapshotmac_.Get(); +} +inline void SyncdPatch::_internal_set_snapshotmac(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.snapshotmac_.Set(value, GetArenaForAllocation()); +} +inline std::string* SyncdPatch::_internal_mutable_snapshotmac() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.snapshotmac_.Mutable(GetArenaForAllocation()); +} +inline std::string* SyncdPatch::release_snapshotmac() { + // @@protoc_insertion_point(field_release:proto.SyncdPatch.snapshotMac) + if (!_internal_has_snapshotmac()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.snapshotmac_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.snapshotmac_.IsDefault()) { + _impl_.snapshotmac_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SyncdPatch::set_allocated_snapshotmac(std::string* snapshotmac) { + if (snapshotmac != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.snapshotmac_.SetAllocated(snapshotmac, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.snapshotmac_.IsDefault()) { + _impl_.snapshotmac_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SyncdPatch.snapshotMac) +} + +// optional bytes patchMac = 5; +inline bool SyncdPatch::_internal_has_patchmac() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SyncdPatch::has_patchmac() const { + return _internal_has_patchmac(); +} +inline void SyncdPatch::clear_patchmac() { + _impl_.patchmac_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& SyncdPatch::patchmac() const { + // @@protoc_insertion_point(field_get:proto.SyncdPatch.patchMac) + return _internal_patchmac(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SyncdPatch::set_patchmac(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.patchmac_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SyncdPatch.patchMac) +} +inline std::string* SyncdPatch::mutable_patchmac() { + std::string* _s = _internal_mutable_patchmac(); + // @@protoc_insertion_point(field_mutable:proto.SyncdPatch.patchMac) + return _s; +} +inline const std::string& SyncdPatch::_internal_patchmac() const { + return _impl_.patchmac_.Get(); +} +inline void SyncdPatch::_internal_set_patchmac(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.patchmac_.Set(value, GetArenaForAllocation()); +} +inline std::string* SyncdPatch::_internal_mutable_patchmac() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.patchmac_.Mutable(GetArenaForAllocation()); +} +inline std::string* SyncdPatch::release_patchmac() { + // @@protoc_insertion_point(field_release:proto.SyncdPatch.patchMac) + if (!_internal_has_patchmac()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.patchmac_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.patchmac_.IsDefault()) { + _impl_.patchmac_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SyncdPatch::set_allocated_patchmac(std::string* patchmac) { + if (patchmac != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.patchmac_.SetAllocated(patchmac, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.patchmac_.IsDefault()) { + _impl_.patchmac_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SyncdPatch.patchMac) +} + +// optional .proto.KeyId keyId = 6; +inline bool SyncdPatch::_internal_has_keyid() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + PROTOBUF_ASSUME(!value || _impl_.keyid_ != nullptr); + return value; +} +inline bool SyncdPatch::has_keyid() const { + return _internal_has_keyid(); +} +inline void SyncdPatch::clear_keyid() { + if (_impl_.keyid_ != nullptr) _impl_.keyid_->Clear(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const ::proto::KeyId& SyncdPatch::_internal_keyid() const { + const ::proto::KeyId* p = _impl_.keyid_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_KeyId_default_instance_); +} +inline const ::proto::KeyId& SyncdPatch::keyid() const { + // @@protoc_insertion_point(field_get:proto.SyncdPatch.keyId) + return _internal_keyid(); +} +inline void SyncdPatch::unsafe_arena_set_allocated_keyid( + ::proto::KeyId* keyid) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keyid_); + } + _impl_.keyid_ = keyid; + if (keyid) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdPatch.keyId) +} +inline ::proto::KeyId* SyncdPatch::release_keyid() { + _impl_._has_bits_[0] &= ~0x00000010u; + ::proto::KeyId* temp = _impl_.keyid_; + _impl_.keyid_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::KeyId* SyncdPatch::unsafe_arena_release_keyid() { + // @@protoc_insertion_point(field_release:proto.SyncdPatch.keyId) + _impl_._has_bits_[0] &= ~0x00000010u; + ::proto::KeyId* temp = _impl_.keyid_; + _impl_.keyid_ = nullptr; + return temp; +} +inline ::proto::KeyId* SyncdPatch::_internal_mutable_keyid() { + _impl_._has_bits_[0] |= 0x00000010u; + if (_impl_.keyid_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::KeyId>(GetArenaForAllocation()); + _impl_.keyid_ = p; + } + return _impl_.keyid_; +} +inline ::proto::KeyId* SyncdPatch::mutable_keyid() { + ::proto::KeyId* _msg = _internal_mutable_keyid(); + // @@protoc_insertion_point(field_mutable:proto.SyncdPatch.keyId) + return _msg; +} +inline void SyncdPatch::set_allocated_keyid(::proto::KeyId* keyid) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.keyid_; + } + if (keyid) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keyid); + if (message_arena != submessage_arena) { + keyid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, keyid, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.keyid_ = keyid; + // @@protoc_insertion_point(field_set_allocated:proto.SyncdPatch.keyId) +} + +// optional .proto.ExitCode exitCode = 7; +inline bool SyncdPatch::_internal_has_exitcode() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + PROTOBUF_ASSUME(!value || _impl_.exitcode_ != nullptr); + return value; +} +inline bool SyncdPatch::has_exitcode() const { + return _internal_has_exitcode(); +} +inline void SyncdPatch::clear_exitcode() { + if (_impl_.exitcode_ != nullptr) _impl_.exitcode_->Clear(); + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline const ::proto::ExitCode& SyncdPatch::_internal_exitcode() const { + const ::proto::ExitCode* p = _impl_.exitcode_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_ExitCode_default_instance_); +} +inline const ::proto::ExitCode& SyncdPatch::exitcode() const { + // @@protoc_insertion_point(field_get:proto.SyncdPatch.exitCode) + return _internal_exitcode(); +} +inline void SyncdPatch::unsafe_arena_set_allocated_exitcode( + ::proto::ExitCode* exitcode) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.exitcode_); + } + _impl_.exitcode_ = exitcode; + if (exitcode) { + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdPatch.exitCode) +} +inline ::proto::ExitCode* SyncdPatch::release_exitcode() { + _impl_._has_bits_[0] &= ~0x00000020u; + ::proto::ExitCode* temp = _impl_.exitcode_; + _impl_.exitcode_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::ExitCode* SyncdPatch::unsafe_arena_release_exitcode() { + // @@protoc_insertion_point(field_release:proto.SyncdPatch.exitCode) + _impl_._has_bits_[0] &= ~0x00000020u; + ::proto::ExitCode* temp = _impl_.exitcode_; + _impl_.exitcode_ = nullptr; + return temp; +} +inline ::proto::ExitCode* SyncdPatch::_internal_mutable_exitcode() { + _impl_._has_bits_[0] |= 0x00000020u; + if (_impl_.exitcode_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::ExitCode>(GetArenaForAllocation()); + _impl_.exitcode_ = p; + } + return _impl_.exitcode_; +} +inline ::proto::ExitCode* SyncdPatch::mutable_exitcode() { + ::proto::ExitCode* _msg = _internal_mutable_exitcode(); + // @@protoc_insertion_point(field_mutable:proto.SyncdPatch.exitCode) + return _msg; +} +inline void SyncdPatch::set_allocated_exitcode(::proto::ExitCode* exitcode) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.exitcode_; + } + if (exitcode) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(exitcode); + if (message_arena != submessage_arena) { + exitcode = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, exitcode, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + _impl_.exitcode_ = exitcode; + // @@protoc_insertion_point(field_set_allocated:proto.SyncdPatch.exitCode) +} + +// optional uint32 deviceIndex = 8; +inline bool SyncdPatch::_internal_has_deviceindex() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool SyncdPatch::has_deviceindex() const { + return _internal_has_deviceindex(); +} +inline void SyncdPatch::clear_deviceindex() { + _impl_.deviceindex_ = 0u; + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline uint32_t SyncdPatch::_internal_deviceindex() const { + return _impl_.deviceindex_; +} +inline uint32_t SyncdPatch::deviceindex() const { + // @@protoc_insertion_point(field_get:proto.SyncdPatch.deviceIndex) + return _internal_deviceindex(); +} +inline void SyncdPatch::_internal_set_deviceindex(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.deviceindex_ = value; +} +inline void SyncdPatch::set_deviceindex(uint32_t value) { + _internal_set_deviceindex(value); + // @@protoc_insertion_point(field_set:proto.SyncdPatch.deviceIndex) +} + +// ------------------------------------------------------------------- + +// SyncdRecord + +// optional .proto.SyncdIndex index = 1; +inline bool SyncdRecord::_internal_has_index() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.index_ != nullptr); + return value; +} +inline bool SyncdRecord::has_index() const { + return _internal_has_index(); +} +inline void SyncdRecord::clear_index() { + if (_impl_.index_ != nullptr) _impl_.index_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::SyncdIndex& SyncdRecord::_internal_index() const { + const ::proto::SyncdIndex* p = _impl_.index_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncdIndex_default_instance_); +} +inline const ::proto::SyncdIndex& SyncdRecord::index() const { + // @@protoc_insertion_point(field_get:proto.SyncdRecord.index) + return _internal_index(); +} +inline void SyncdRecord::unsafe_arena_set_allocated_index( + ::proto::SyncdIndex* index) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.index_); + } + _impl_.index_ = index; + if (index) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdRecord.index) +} +inline ::proto::SyncdIndex* SyncdRecord::release_index() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::SyncdIndex* temp = _impl_.index_; + _impl_.index_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncdIndex* SyncdRecord::unsafe_arena_release_index() { + // @@protoc_insertion_point(field_release:proto.SyncdRecord.index) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::SyncdIndex* temp = _impl_.index_; + _impl_.index_ = nullptr; + return temp; +} +inline ::proto::SyncdIndex* SyncdRecord::_internal_mutable_index() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.index_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncdIndex>(GetArenaForAllocation()); + _impl_.index_ = p; + } + return _impl_.index_; +} +inline ::proto::SyncdIndex* SyncdRecord::mutable_index() { + ::proto::SyncdIndex* _msg = _internal_mutable_index(); + // @@protoc_insertion_point(field_mutable:proto.SyncdRecord.index) + return _msg; +} +inline void SyncdRecord::set_allocated_index(::proto::SyncdIndex* index) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.index_; + } + if (index) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(index); + if (message_arena != submessage_arena) { + index = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, index, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.index_ = index; + // @@protoc_insertion_point(field_set_allocated:proto.SyncdRecord.index) +} + +// optional .proto.SyncdValue value = 2; +inline bool SyncdRecord::_internal_has_value() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.value_ != nullptr); + return value; +} +inline bool SyncdRecord::has_value() const { + return _internal_has_value(); +} +inline void SyncdRecord::clear_value() { + if (_impl_.value_ != nullptr) _impl_.value_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::SyncdValue& SyncdRecord::_internal_value() const { + const ::proto::SyncdValue* p = _impl_.value_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncdValue_default_instance_); +} +inline const ::proto::SyncdValue& SyncdRecord::value() const { + // @@protoc_insertion_point(field_get:proto.SyncdRecord.value) + return _internal_value(); +} +inline void SyncdRecord::unsafe_arena_set_allocated_value( + ::proto::SyncdValue* value) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.value_); + } + _impl_.value_ = value; + if (value) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdRecord.value) +} +inline ::proto::SyncdValue* SyncdRecord::release_value() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::SyncdValue* temp = _impl_.value_; + _impl_.value_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncdValue* SyncdRecord::unsafe_arena_release_value() { + // @@protoc_insertion_point(field_release:proto.SyncdRecord.value) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::SyncdValue* temp = _impl_.value_; + _impl_.value_ = nullptr; + return temp; +} +inline ::proto::SyncdValue* SyncdRecord::_internal_mutable_value() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.value_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncdValue>(GetArenaForAllocation()); + _impl_.value_ = p; + } + return _impl_.value_; +} +inline ::proto::SyncdValue* SyncdRecord::mutable_value() { + ::proto::SyncdValue* _msg = _internal_mutable_value(); + // @@protoc_insertion_point(field_mutable:proto.SyncdRecord.value) + return _msg; +} +inline void SyncdRecord::set_allocated_value(::proto::SyncdValue* value) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.value_; + } + if (value) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(value); + if (message_arena != submessage_arena) { + value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, value, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.value_ = value; + // @@protoc_insertion_point(field_set_allocated:proto.SyncdRecord.value) +} + +// optional .proto.KeyId keyId = 3; +inline bool SyncdRecord::_internal_has_keyid() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.keyid_ != nullptr); + return value; +} +inline bool SyncdRecord::has_keyid() const { + return _internal_has_keyid(); +} +inline void SyncdRecord::clear_keyid() { + if (_impl_.keyid_ != nullptr) _impl_.keyid_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::proto::KeyId& SyncdRecord::_internal_keyid() const { + const ::proto::KeyId* p = _impl_.keyid_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_KeyId_default_instance_); +} +inline const ::proto::KeyId& SyncdRecord::keyid() const { + // @@protoc_insertion_point(field_get:proto.SyncdRecord.keyId) + return _internal_keyid(); +} +inline void SyncdRecord::unsafe_arena_set_allocated_keyid( + ::proto::KeyId* keyid) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keyid_); + } + _impl_.keyid_ = keyid; + if (keyid) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdRecord.keyId) +} +inline ::proto::KeyId* SyncdRecord::release_keyid() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::KeyId* temp = _impl_.keyid_; + _impl_.keyid_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::KeyId* SyncdRecord::unsafe_arena_release_keyid() { + // @@protoc_insertion_point(field_release:proto.SyncdRecord.keyId) + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::KeyId* temp = _impl_.keyid_; + _impl_.keyid_ = nullptr; + return temp; +} +inline ::proto::KeyId* SyncdRecord::_internal_mutable_keyid() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.keyid_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::KeyId>(GetArenaForAllocation()); + _impl_.keyid_ = p; + } + return _impl_.keyid_; +} +inline ::proto::KeyId* SyncdRecord::mutable_keyid() { + ::proto::KeyId* _msg = _internal_mutable_keyid(); + // @@protoc_insertion_point(field_mutable:proto.SyncdRecord.keyId) + return _msg; +} +inline void SyncdRecord::set_allocated_keyid(::proto::KeyId* keyid) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.keyid_; + } + if (keyid) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keyid); + if (message_arena != submessage_arena) { + keyid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, keyid, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.keyid_ = keyid; + // @@protoc_insertion_point(field_set_allocated:proto.SyncdRecord.keyId) +} + +// ------------------------------------------------------------------- + +// SyncdSnapshot + +// optional .proto.SyncdVersion version = 1; +inline bool SyncdSnapshot::_internal_has_version() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.version_ != nullptr); + return value; +} +inline bool SyncdSnapshot::has_version() const { + return _internal_has_version(); +} +inline void SyncdSnapshot::clear_version() { + if (_impl_.version_ != nullptr) _impl_.version_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::SyncdVersion& SyncdSnapshot::_internal_version() const { + const ::proto::SyncdVersion* p = _impl_.version_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_SyncdVersion_default_instance_); +} +inline const ::proto::SyncdVersion& SyncdSnapshot::version() const { + // @@protoc_insertion_point(field_get:proto.SyncdSnapshot.version) + return _internal_version(); +} +inline void SyncdSnapshot::unsafe_arena_set_allocated_version( + ::proto::SyncdVersion* version) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.version_); + } + _impl_.version_ = version; + if (version) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdSnapshot.version) +} +inline ::proto::SyncdVersion* SyncdSnapshot::release_version() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::SyncdVersion* temp = _impl_.version_; + _impl_.version_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::SyncdVersion* SyncdSnapshot::unsafe_arena_release_version() { + // @@protoc_insertion_point(field_release:proto.SyncdSnapshot.version) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::SyncdVersion* temp = _impl_.version_; + _impl_.version_ = nullptr; + return temp; +} +inline ::proto::SyncdVersion* SyncdSnapshot::_internal_mutable_version() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.version_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::SyncdVersion>(GetArenaForAllocation()); + _impl_.version_ = p; + } + return _impl_.version_; +} +inline ::proto::SyncdVersion* SyncdSnapshot::mutable_version() { + ::proto::SyncdVersion* _msg = _internal_mutable_version(); + // @@protoc_insertion_point(field_mutable:proto.SyncdSnapshot.version) + return _msg; +} +inline void SyncdSnapshot::set_allocated_version(::proto::SyncdVersion* version) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.version_; + } + if (version) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(version); + if (message_arena != submessage_arena) { + version = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, version, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.version_ = version; + // @@protoc_insertion_point(field_set_allocated:proto.SyncdSnapshot.version) +} + +// repeated .proto.SyncdRecord records = 2; +inline int SyncdSnapshot::_internal_records_size() const { + return _impl_.records_.size(); +} +inline int SyncdSnapshot::records_size() const { + return _internal_records_size(); +} +inline void SyncdSnapshot::clear_records() { + _impl_.records_.Clear(); +} +inline ::proto::SyncdRecord* SyncdSnapshot::mutable_records(int index) { + // @@protoc_insertion_point(field_mutable:proto.SyncdSnapshot.records) + return _impl_.records_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdRecord >* +SyncdSnapshot::mutable_records() { + // @@protoc_insertion_point(field_mutable_list:proto.SyncdSnapshot.records) + return &_impl_.records_; +} +inline const ::proto::SyncdRecord& SyncdSnapshot::_internal_records(int index) const { + return _impl_.records_.Get(index); +} +inline const ::proto::SyncdRecord& SyncdSnapshot::records(int index) const { + // @@protoc_insertion_point(field_get:proto.SyncdSnapshot.records) + return _internal_records(index); +} +inline ::proto::SyncdRecord* SyncdSnapshot::_internal_add_records() { + return _impl_.records_.Add(); +} +inline ::proto::SyncdRecord* SyncdSnapshot::add_records() { + ::proto::SyncdRecord* _add = _internal_add_records(); + // @@protoc_insertion_point(field_add:proto.SyncdSnapshot.records) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdRecord >& +SyncdSnapshot::records() const { + // @@protoc_insertion_point(field_list:proto.SyncdSnapshot.records) + return _impl_.records_; +} + +// optional bytes mac = 3; +inline bool SyncdSnapshot::_internal_has_mac() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SyncdSnapshot::has_mac() const { + return _internal_has_mac(); +} +inline void SyncdSnapshot::clear_mac() { + _impl_.mac_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& SyncdSnapshot::mac() const { + // @@protoc_insertion_point(field_get:proto.SyncdSnapshot.mac) + return _internal_mac(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SyncdSnapshot::set_mac(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.mac_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SyncdSnapshot.mac) +} +inline std::string* SyncdSnapshot::mutable_mac() { + std::string* _s = _internal_mutable_mac(); + // @@protoc_insertion_point(field_mutable:proto.SyncdSnapshot.mac) + return _s; +} +inline const std::string& SyncdSnapshot::_internal_mac() const { + return _impl_.mac_.Get(); +} +inline void SyncdSnapshot::_internal_set_mac(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.mac_.Set(value, GetArenaForAllocation()); +} +inline std::string* SyncdSnapshot::_internal_mutable_mac() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.mac_.Mutable(GetArenaForAllocation()); +} +inline std::string* SyncdSnapshot::release_mac() { + // @@protoc_insertion_point(field_release:proto.SyncdSnapshot.mac) + if (!_internal_has_mac()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.mac_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mac_.IsDefault()) { + _impl_.mac_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SyncdSnapshot::set_allocated_mac(std::string* mac) { + if (mac != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.mac_.SetAllocated(mac, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mac_.IsDefault()) { + _impl_.mac_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SyncdSnapshot.mac) +} + +// optional .proto.KeyId keyId = 4; +inline bool SyncdSnapshot::_internal_has_keyid() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || _impl_.keyid_ != nullptr); + return value; +} +inline bool SyncdSnapshot::has_keyid() const { + return _internal_has_keyid(); +} +inline void SyncdSnapshot::clear_keyid() { + if (_impl_.keyid_ != nullptr) _impl_.keyid_->Clear(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const ::proto::KeyId& SyncdSnapshot::_internal_keyid() const { + const ::proto::KeyId* p = _impl_.keyid_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_KeyId_default_instance_); +} +inline const ::proto::KeyId& SyncdSnapshot::keyid() const { + // @@protoc_insertion_point(field_get:proto.SyncdSnapshot.keyId) + return _internal_keyid(); +} +inline void SyncdSnapshot::unsafe_arena_set_allocated_keyid( + ::proto::KeyId* keyid) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keyid_); + } + _impl_.keyid_ = keyid; + if (keyid) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdSnapshot.keyId) +} +inline ::proto::KeyId* SyncdSnapshot::release_keyid() { + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::KeyId* temp = _impl_.keyid_; + _impl_.keyid_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::KeyId* SyncdSnapshot::unsafe_arena_release_keyid() { + // @@protoc_insertion_point(field_release:proto.SyncdSnapshot.keyId) + _impl_._has_bits_[0] &= ~0x00000004u; + ::proto::KeyId* temp = _impl_.keyid_; + _impl_.keyid_ = nullptr; + return temp; +} +inline ::proto::KeyId* SyncdSnapshot::_internal_mutable_keyid() { + _impl_._has_bits_[0] |= 0x00000004u; + if (_impl_.keyid_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::KeyId>(GetArenaForAllocation()); + _impl_.keyid_ = p; + } + return _impl_.keyid_; +} +inline ::proto::KeyId* SyncdSnapshot::mutable_keyid() { + ::proto::KeyId* _msg = _internal_mutable_keyid(); + // @@protoc_insertion_point(field_mutable:proto.SyncdSnapshot.keyId) + return _msg; +} +inline void SyncdSnapshot::set_allocated_keyid(::proto::KeyId* keyid) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.keyid_; + } + if (keyid) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keyid); + if (message_arena != submessage_arena) { + keyid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, keyid, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.keyid_ = keyid; + // @@protoc_insertion_point(field_set_allocated:proto.SyncdSnapshot.keyId) +} + +// ------------------------------------------------------------------- + +// SyncdValue + +// optional bytes blob = 1; +inline bool SyncdValue::_internal_has_blob() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SyncdValue::has_blob() const { + return _internal_has_blob(); +} +inline void SyncdValue::clear_blob() { + _impl_.blob_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& SyncdValue::blob() const { + // @@protoc_insertion_point(field_get:proto.SyncdValue.blob) + return _internal_blob(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SyncdValue::set_blob(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.blob_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.SyncdValue.blob) +} +inline std::string* SyncdValue::mutable_blob() { + std::string* _s = _internal_mutable_blob(); + // @@protoc_insertion_point(field_mutable:proto.SyncdValue.blob) + return _s; +} +inline const std::string& SyncdValue::_internal_blob() const { + return _impl_.blob_.Get(); +} +inline void SyncdValue::_internal_set_blob(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.blob_.Set(value, GetArenaForAllocation()); +} +inline std::string* SyncdValue::_internal_mutable_blob() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.blob_.Mutable(GetArenaForAllocation()); +} +inline std::string* SyncdValue::release_blob() { + // @@protoc_insertion_point(field_release:proto.SyncdValue.blob) + if (!_internal_has_blob()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.blob_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.blob_.IsDefault()) { + _impl_.blob_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SyncdValue::set_allocated_blob(std::string* blob) { + if (blob != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.blob_.SetAllocated(blob, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.blob_.IsDefault()) { + _impl_.blob_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.SyncdValue.blob) +} + +// ------------------------------------------------------------------- + +// SyncdVersion + +// optional uint64 version = 1; +inline bool SyncdVersion::_internal_has_version() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SyncdVersion::has_version() const { + return _internal_has_version(); +} +inline void SyncdVersion::clear_version() { + _impl_.version_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline uint64_t SyncdVersion::_internal_version() const { + return _impl_.version_; +} +inline uint64_t SyncdVersion::version() const { + // @@protoc_insertion_point(field_get:proto.SyncdVersion.version) + return _internal_version(); +} +inline void SyncdVersion::_internal_set_version(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.version_ = value; +} +inline void SyncdVersion::set_version(uint64_t value) { + _internal_set_version(value); + // @@protoc_insertion_point(field_set:proto.SyncdVersion.version) +} + +// ------------------------------------------------------------------- + +// TemplateButton_CallButton + +// optional .proto.Message.HighlyStructuredMessage displayText = 1; +inline bool TemplateButton_CallButton::_internal_has_displaytext() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.displaytext_ != nullptr); + return value; +} +inline bool TemplateButton_CallButton::has_displaytext() const { + return _internal_has_displaytext(); +} +inline void TemplateButton_CallButton::clear_displaytext() { + if (_impl_.displaytext_ != nullptr) _impl_.displaytext_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_CallButton::_internal_displaytext() const { + const ::proto::Message_HighlyStructuredMessage* p = _impl_.displaytext_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_HighlyStructuredMessage_default_instance_); +} +inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_CallButton::displaytext() const { + // @@protoc_insertion_point(field_get:proto.TemplateButton.CallButton.displayText) + return _internal_displaytext(); +} +inline void TemplateButton_CallButton::unsafe_arena_set_allocated_displaytext( + ::proto::Message_HighlyStructuredMessage* displaytext) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.displaytext_); + } + _impl_.displaytext_ = displaytext; + if (displaytext) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.CallButton.displayText) +} +inline ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::release_displaytext() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::Message_HighlyStructuredMessage* temp = _impl_.displaytext_; + _impl_.displaytext_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::unsafe_arena_release_displaytext() { + // @@protoc_insertion_point(field_release:proto.TemplateButton.CallButton.displayText) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::Message_HighlyStructuredMessage* temp = _impl_.displaytext_; + _impl_.displaytext_ = nullptr; + return temp; +} +inline ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::_internal_mutable_displaytext() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.displaytext_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation()); + _impl_.displaytext_ = p; + } + return _impl_.displaytext_; +} +inline ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::mutable_displaytext() { + ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_displaytext(); + // @@protoc_insertion_point(field_mutable:proto.TemplateButton.CallButton.displayText) + return _msg; +} +inline void TemplateButton_CallButton::set_allocated_displaytext(::proto::Message_HighlyStructuredMessage* displaytext) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.displaytext_; + } + if (displaytext) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(displaytext); + if (message_arena != submessage_arena) { + displaytext = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, displaytext, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.displaytext_ = displaytext; + // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.CallButton.displayText) +} + +// optional .proto.Message.HighlyStructuredMessage phoneNumber = 2; +inline bool TemplateButton_CallButton::_internal_has_phonenumber() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.phonenumber_ != nullptr); + return value; +} +inline bool TemplateButton_CallButton::has_phonenumber() const { + return _internal_has_phonenumber(); +} +inline void TemplateButton_CallButton::clear_phonenumber() { + if (_impl_.phonenumber_ != nullptr) _impl_.phonenumber_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_CallButton::_internal_phonenumber() const { + const ::proto::Message_HighlyStructuredMessage* p = _impl_.phonenumber_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_HighlyStructuredMessage_default_instance_); +} +inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_CallButton::phonenumber() const { + // @@protoc_insertion_point(field_get:proto.TemplateButton.CallButton.phoneNumber) + return _internal_phonenumber(); +} +inline void TemplateButton_CallButton::unsafe_arena_set_allocated_phonenumber( + ::proto::Message_HighlyStructuredMessage* phonenumber) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.phonenumber_); + } + _impl_.phonenumber_ = phonenumber; + if (phonenumber) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.CallButton.phoneNumber) +} +inline ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::release_phonenumber() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::Message_HighlyStructuredMessage* temp = _impl_.phonenumber_; + _impl_.phonenumber_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::unsafe_arena_release_phonenumber() { + // @@protoc_insertion_point(field_release:proto.TemplateButton.CallButton.phoneNumber) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::Message_HighlyStructuredMessage* temp = _impl_.phonenumber_; + _impl_.phonenumber_ = nullptr; + return temp; +} +inline ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::_internal_mutable_phonenumber() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.phonenumber_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation()); + _impl_.phonenumber_ = p; + } + return _impl_.phonenumber_; +} +inline ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::mutable_phonenumber() { + ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_phonenumber(); + // @@protoc_insertion_point(field_mutable:proto.TemplateButton.CallButton.phoneNumber) + return _msg; +} +inline void TemplateButton_CallButton::set_allocated_phonenumber(::proto::Message_HighlyStructuredMessage* phonenumber) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.phonenumber_; + } + if (phonenumber) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(phonenumber); + if (message_arena != submessage_arena) { + phonenumber = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, phonenumber, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.phonenumber_ = phonenumber; + // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.CallButton.phoneNumber) +} + +// ------------------------------------------------------------------- + +// TemplateButton_QuickReplyButton + +// optional .proto.Message.HighlyStructuredMessage displayText = 1; +inline bool TemplateButton_QuickReplyButton::_internal_has_displaytext() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.displaytext_ != nullptr); + return value; +} +inline bool TemplateButton_QuickReplyButton::has_displaytext() const { + return _internal_has_displaytext(); +} +inline void TemplateButton_QuickReplyButton::clear_displaytext() { + if (_impl_.displaytext_ != nullptr) _impl_.displaytext_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_QuickReplyButton::_internal_displaytext() const { + const ::proto::Message_HighlyStructuredMessage* p = _impl_.displaytext_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_HighlyStructuredMessage_default_instance_); +} +inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_QuickReplyButton::displaytext() const { + // @@protoc_insertion_point(field_get:proto.TemplateButton.QuickReplyButton.displayText) + return _internal_displaytext(); +} +inline void TemplateButton_QuickReplyButton::unsafe_arena_set_allocated_displaytext( + ::proto::Message_HighlyStructuredMessage* displaytext) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.displaytext_); + } + _impl_.displaytext_ = displaytext; + if (displaytext) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.QuickReplyButton.displayText) +} +inline ::proto::Message_HighlyStructuredMessage* TemplateButton_QuickReplyButton::release_displaytext() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::Message_HighlyStructuredMessage* temp = _impl_.displaytext_; + _impl_.displaytext_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_HighlyStructuredMessage* TemplateButton_QuickReplyButton::unsafe_arena_release_displaytext() { + // @@protoc_insertion_point(field_release:proto.TemplateButton.QuickReplyButton.displayText) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::Message_HighlyStructuredMessage* temp = _impl_.displaytext_; + _impl_.displaytext_ = nullptr; + return temp; +} +inline ::proto::Message_HighlyStructuredMessage* TemplateButton_QuickReplyButton::_internal_mutable_displaytext() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.displaytext_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation()); + _impl_.displaytext_ = p; + } + return _impl_.displaytext_; +} +inline ::proto::Message_HighlyStructuredMessage* TemplateButton_QuickReplyButton::mutable_displaytext() { + ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_displaytext(); + // @@protoc_insertion_point(field_mutable:proto.TemplateButton.QuickReplyButton.displayText) + return _msg; +} +inline void TemplateButton_QuickReplyButton::set_allocated_displaytext(::proto::Message_HighlyStructuredMessage* displaytext) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.displaytext_; + } + if (displaytext) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(displaytext); + if (message_arena != submessage_arena) { + displaytext = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, displaytext, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.displaytext_ = displaytext; + // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.QuickReplyButton.displayText) +} + +// optional string id = 2; +inline bool TemplateButton_QuickReplyButton::_internal_has_id() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool TemplateButton_QuickReplyButton::has_id() const { + return _internal_has_id(); +} +inline void TemplateButton_QuickReplyButton::clear_id() { + _impl_.id_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& TemplateButton_QuickReplyButton::id() const { + // @@protoc_insertion_point(field_get:proto.TemplateButton.QuickReplyButton.id) + return _internal_id(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void TemplateButton_QuickReplyButton::set_id(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.id_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.TemplateButton.QuickReplyButton.id) +} +inline std::string* TemplateButton_QuickReplyButton::mutable_id() { + std::string* _s = _internal_mutable_id(); + // @@protoc_insertion_point(field_mutable:proto.TemplateButton.QuickReplyButton.id) + return _s; +} +inline const std::string& TemplateButton_QuickReplyButton::_internal_id() const { + return _impl_.id_.Get(); +} +inline void TemplateButton_QuickReplyButton::_internal_set_id(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.id_.Set(value, GetArenaForAllocation()); +} +inline std::string* TemplateButton_QuickReplyButton::_internal_mutable_id() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.id_.Mutable(GetArenaForAllocation()); +} +inline std::string* TemplateButton_QuickReplyButton::release_id() { + // @@protoc_insertion_point(field_release:proto.TemplateButton.QuickReplyButton.id) + if (!_internal_has_id()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.id_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.id_.IsDefault()) { + _impl_.id_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void TemplateButton_QuickReplyButton::set_allocated_id(std::string* id) { + if (id != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.id_.SetAllocated(id, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.id_.IsDefault()) { + _impl_.id_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.QuickReplyButton.id) +} + +// ------------------------------------------------------------------- + +// TemplateButton_URLButton + +// optional .proto.Message.HighlyStructuredMessage displayText = 1; +inline bool TemplateButton_URLButton::_internal_has_displaytext() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || _impl_.displaytext_ != nullptr); + return value; +} +inline bool TemplateButton_URLButton::has_displaytext() const { + return _internal_has_displaytext(); +} +inline void TemplateButton_URLButton::clear_displaytext() { + if (_impl_.displaytext_ != nullptr) _impl_.displaytext_->Clear(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_URLButton::_internal_displaytext() const { + const ::proto::Message_HighlyStructuredMessage* p = _impl_.displaytext_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_HighlyStructuredMessage_default_instance_); +} +inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_URLButton::displaytext() const { + // @@protoc_insertion_point(field_get:proto.TemplateButton.URLButton.displayText) + return _internal_displaytext(); +} +inline void TemplateButton_URLButton::unsafe_arena_set_allocated_displaytext( + ::proto::Message_HighlyStructuredMessage* displaytext) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.displaytext_); + } + _impl_.displaytext_ = displaytext; + if (displaytext) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.URLButton.displayText) +} +inline ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::release_displaytext() { + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::Message_HighlyStructuredMessage* temp = _impl_.displaytext_; + _impl_.displaytext_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::unsafe_arena_release_displaytext() { + // @@protoc_insertion_point(field_release:proto.TemplateButton.URLButton.displayText) + _impl_._has_bits_[0] &= ~0x00000001u; + ::proto::Message_HighlyStructuredMessage* temp = _impl_.displaytext_; + _impl_.displaytext_ = nullptr; + return temp; +} +inline ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::_internal_mutable_displaytext() { + _impl_._has_bits_[0] |= 0x00000001u; + if (_impl_.displaytext_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation()); + _impl_.displaytext_ = p; + } + return _impl_.displaytext_; +} +inline ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::mutable_displaytext() { + ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_displaytext(); + // @@protoc_insertion_point(field_mutable:proto.TemplateButton.URLButton.displayText) + return _msg; +} +inline void TemplateButton_URLButton::set_allocated_displaytext(::proto::Message_HighlyStructuredMessage* displaytext) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.displaytext_; + } + if (displaytext) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(displaytext); + if (message_arena != submessage_arena) { + displaytext = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, displaytext, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.displaytext_ = displaytext; + // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.URLButton.displayText) +} + +// optional .proto.Message.HighlyStructuredMessage url = 2; +inline bool TemplateButton_URLButton::_internal_has_url() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || _impl_.url_ != nullptr); + return value; +} +inline bool TemplateButton_URLButton::has_url() const { + return _internal_has_url(); +} +inline void TemplateButton_URLButton::clear_url() { + if (_impl_.url_ != nullptr) _impl_.url_->Clear(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_URLButton::_internal_url() const { + const ::proto::Message_HighlyStructuredMessage* p = _impl_.url_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_HighlyStructuredMessage_default_instance_); +} +inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_URLButton::url() const { + // @@protoc_insertion_point(field_get:proto.TemplateButton.URLButton.url) + return _internal_url(); +} +inline void TemplateButton_URLButton::unsafe_arena_set_allocated_url( + ::proto::Message_HighlyStructuredMessage* url) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.url_); + } + _impl_.url_ = url; + if (url) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.URLButton.url) +} +inline ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::release_url() { + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::Message_HighlyStructuredMessage* temp = _impl_.url_; + _impl_.url_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::unsafe_arena_release_url() { + // @@protoc_insertion_point(field_release:proto.TemplateButton.URLButton.url) + _impl_._has_bits_[0] &= ~0x00000002u; + ::proto::Message_HighlyStructuredMessage* temp = _impl_.url_; + _impl_.url_ = nullptr; + return temp; +} +inline ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::_internal_mutable_url() { + _impl_._has_bits_[0] |= 0x00000002u; + if (_impl_.url_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation()); + _impl_.url_ = p; + } + return _impl_.url_; +} +inline ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::mutable_url() { + ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_url(); + // @@protoc_insertion_point(field_mutable:proto.TemplateButton.URLButton.url) + return _msg; +} +inline void TemplateButton_URLButton::set_allocated_url(::proto::Message_HighlyStructuredMessage* url) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.url_; + } + if (url) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(url); + if (message_arena != submessage_arena) { + url = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, url, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.url_ = url; + // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.URLButton.url) +} + +// ------------------------------------------------------------------- + +// TemplateButton + +// optional uint32 index = 4; +inline bool TemplateButton::_internal_has_index() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool TemplateButton::has_index() const { + return _internal_has_index(); +} +inline void TemplateButton::clear_index() { + _impl_.index_ = 0u; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline uint32_t TemplateButton::_internal_index() const { + return _impl_.index_; +} +inline uint32_t TemplateButton::index() const { + // @@protoc_insertion_point(field_get:proto.TemplateButton.index) + return _internal_index(); +} +inline void TemplateButton::_internal_set_index(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.index_ = value; +} +inline void TemplateButton::set_index(uint32_t value) { + _internal_set_index(value); + // @@protoc_insertion_point(field_set:proto.TemplateButton.index) +} + +// .proto.TemplateButton.QuickReplyButton quickReplyButton = 1; +inline bool TemplateButton::_internal_has_quickreplybutton() const { + return button_case() == kQuickReplyButton; +} +inline bool TemplateButton::has_quickreplybutton() const { + return _internal_has_quickreplybutton(); +} +inline void TemplateButton::set_has_quickreplybutton() { + _impl_._oneof_case_[0] = kQuickReplyButton; +} +inline void TemplateButton::clear_quickreplybutton() { + if (_internal_has_quickreplybutton()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.button_.quickreplybutton_; + } + clear_has_button(); + } +} +inline ::proto::TemplateButton_QuickReplyButton* TemplateButton::release_quickreplybutton() { + // @@protoc_insertion_point(field_release:proto.TemplateButton.quickReplyButton) + if (_internal_has_quickreplybutton()) { + clear_has_button(); + ::proto::TemplateButton_QuickReplyButton* temp = _impl_.button_.quickreplybutton_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.button_.quickreplybutton_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::TemplateButton_QuickReplyButton& TemplateButton::_internal_quickreplybutton() const { + return _internal_has_quickreplybutton() + ? *_impl_.button_.quickreplybutton_ + : reinterpret_cast< ::proto::TemplateButton_QuickReplyButton&>(::proto::_TemplateButton_QuickReplyButton_default_instance_); +} +inline const ::proto::TemplateButton_QuickReplyButton& TemplateButton::quickreplybutton() const { + // @@protoc_insertion_point(field_get:proto.TemplateButton.quickReplyButton) + return _internal_quickreplybutton(); +} +inline ::proto::TemplateButton_QuickReplyButton* TemplateButton::unsafe_arena_release_quickreplybutton() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.TemplateButton.quickReplyButton) + if (_internal_has_quickreplybutton()) { + clear_has_button(); + ::proto::TemplateButton_QuickReplyButton* temp = _impl_.button_.quickreplybutton_; + _impl_.button_.quickreplybutton_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void TemplateButton::unsafe_arena_set_allocated_quickreplybutton(::proto::TemplateButton_QuickReplyButton* quickreplybutton) { + clear_button(); + if (quickreplybutton) { + set_has_quickreplybutton(); + _impl_.button_.quickreplybutton_ = quickreplybutton; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.quickReplyButton) +} +inline ::proto::TemplateButton_QuickReplyButton* TemplateButton::_internal_mutable_quickreplybutton() { + if (!_internal_has_quickreplybutton()) { + clear_button(); + set_has_quickreplybutton(); + _impl_.button_.quickreplybutton_ = CreateMaybeMessage< ::proto::TemplateButton_QuickReplyButton >(GetArenaForAllocation()); + } + return _impl_.button_.quickreplybutton_; +} +inline ::proto::TemplateButton_QuickReplyButton* TemplateButton::mutable_quickreplybutton() { + ::proto::TemplateButton_QuickReplyButton* _msg = _internal_mutable_quickreplybutton(); + // @@protoc_insertion_point(field_mutable:proto.TemplateButton.quickReplyButton) + return _msg; +} + +// .proto.TemplateButton.URLButton urlButton = 2; +inline bool TemplateButton::_internal_has_urlbutton() const { + return button_case() == kUrlButton; +} +inline bool TemplateButton::has_urlbutton() const { + return _internal_has_urlbutton(); +} +inline void TemplateButton::set_has_urlbutton() { + _impl_._oneof_case_[0] = kUrlButton; +} +inline void TemplateButton::clear_urlbutton() { + if (_internal_has_urlbutton()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.button_.urlbutton_; + } + clear_has_button(); + } +} +inline ::proto::TemplateButton_URLButton* TemplateButton::release_urlbutton() { + // @@protoc_insertion_point(field_release:proto.TemplateButton.urlButton) + if (_internal_has_urlbutton()) { + clear_has_button(); + ::proto::TemplateButton_URLButton* temp = _impl_.button_.urlbutton_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.button_.urlbutton_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::TemplateButton_URLButton& TemplateButton::_internal_urlbutton() const { + return _internal_has_urlbutton() + ? *_impl_.button_.urlbutton_ + : reinterpret_cast< ::proto::TemplateButton_URLButton&>(::proto::_TemplateButton_URLButton_default_instance_); +} +inline const ::proto::TemplateButton_URLButton& TemplateButton::urlbutton() const { + // @@protoc_insertion_point(field_get:proto.TemplateButton.urlButton) + return _internal_urlbutton(); +} +inline ::proto::TemplateButton_URLButton* TemplateButton::unsafe_arena_release_urlbutton() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.TemplateButton.urlButton) + if (_internal_has_urlbutton()) { + clear_has_button(); + ::proto::TemplateButton_URLButton* temp = _impl_.button_.urlbutton_; + _impl_.button_.urlbutton_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void TemplateButton::unsafe_arena_set_allocated_urlbutton(::proto::TemplateButton_URLButton* urlbutton) { + clear_button(); + if (urlbutton) { + set_has_urlbutton(); + _impl_.button_.urlbutton_ = urlbutton; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.urlButton) +} +inline ::proto::TemplateButton_URLButton* TemplateButton::_internal_mutable_urlbutton() { + if (!_internal_has_urlbutton()) { + clear_button(); + set_has_urlbutton(); + _impl_.button_.urlbutton_ = CreateMaybeMessage< ::proto::TemplateButton_URLButton >(GetArenaForAllocation()); + } + return _impl_.button_.urlbutton_; +} +inline ::proto::TemplateButton_URLButton* TemplateButton::mutable_urlbutton() { + ::proto::TemplateButton_URLButton* _msg = _internal_mutable_urlbutton(); + // @@protoc_insertion_point(field_mutable:proto.TemplateButton.urlButton) + return _msg; +} + +// .proto.TemplateButton.CallButton callButton = 3; +inline bool TemplateButton::_internal_has_callbutton() const { + return button_case() == kCallButton; +} +inline bool TemplateButton::has_callbutton() const { + return _internal_has_callbutton(); +} +inline void TemplateButton::set_has_callbutton() { + _impl_._oneof_case_[0] = kCallButton; +} +inline void TemplateButton::clear_callbutton() { + if (_internal_has_callbutton()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.button_.callbutton_; + } + clear_has_button(); + } +} +inline ::proto::TemplateButton_CallButton* TemplateButton::release_callbutton() { + // @@protoc_insertion_point(field_release:proto.TemplateButton.callButton) + if (_internal_has_callbutton()) { + clear_has_button(); + ::proto::TemplateButton_CallButton* temp = _impl_.button_.callbutton_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.button_.callbutton_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::proto::TemplateButton_CallButton& TemplateButton::_internal_callbutton() const { + return _internal_has_callbutton() + ? *_impl_.button_.callbutton_ + : reinterpret_cast< ::proto::TemplateButton_CallButton&>(::proto::_TemplateButton_CallButton_default_instance_); +} +inline const ::proto::TemplateButton_CallButton& TemplateButton::callbutton() const { + // @@protoc_insertion_point(field_get:proto.TemplateButton.callButton) + return _internal_callbutton(); +} +inline ::proto::TemplateButton_CallButton* TemplateButton::unsafe_arena_release_callbutton() { + // @@protoc_insertion_point(field_unsafe_arena_release:proto.TemplateButton.callButton) + if (_internal_has_callbutton()) { + clear_has_button(); + ::proto::TemplateButton_CallButton* temp = _impl_.button_.callbutton_; + _impl_.button_.callbutton_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void TemplateButton::unsafe_arena_set_allocated_callbutton(::proto::TemplateButton_CallButton* callbutton) { + clear_button(); + if (callbutton) { + set_has_callbutton(); + _impl_.button_.callbutton_ = callbutton; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.callButton) +} +inline ::proto::TemplateButton_CallButton* TemplateButton::_internal_mutable_callbutton() { + if (!_internal_has_callbutton()) { + clear_button(); + set_has_callbutton(); + _impl_.button_.callbutton_ = CreateMaybeMessage< ::proto::TemplateButton_CallButton >(GetArenaForAllocation()); + } + return _impl_.button_.callbutton_; +} +inline ::proto::TemplateButton_CallButton* TemplateButton::mutable_callbutton() { + ::proto::TemplateButton_CallButton* _msg = _internal_mutable_callbutton(); + // @@protoc_insertion_point(field_mutable:proto.TemplateButton.callButton) + return _msg; +} + +inline bool TemplateButton::has_button() const { + return button_case() != BUTTON_NOT_SET; +} +inline void TemplateButton::clear_has_button() { + _impl_._oneof_case_[0] = BUTTON_NOT_SET; +} +inline TemplateButton::ButtonCase TemplateButton::button_case() const { + return TemplateButton::ButtonCase(_impl_._oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// UserReceipt + +// required string userJid = 1; +inline bool UserReceipt::_internal_has_userjid() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool UserReceipt::has_userjid() const { + return _internal_has_userjid(); +} +inline void UserReceipt::clear_userjid() { + _impl_.userjid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& UserReceipt::userjid() const { + // @@protoc_insertion_point(field_get:proto.UserReceipt.userJid) + return _internal_userjid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void UserReceipt::set_userjid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.userjid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.UserReceipt.userJid) +} +inline std::string* UserReceipt::mutable_userjid() { + std::string* _s = _internal_mutable_userjid(); + // @@protoc_insertion_point(field_mutable:proto.UserReceipt.userJid) + return _s; +} +inline const std::string& UserReceipt::_internal_userjid() const { + return _impl_.userjid_.Get(); +} +inline void UserReceipt::_internal_set_userjid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.userjid_.Set(value, GetArenaForAllocation()); +} +inline std::string* UserReceipt::_internal_mutable_userjid() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.userjid_.Mutable(GetArenaForAllocation()); +} +inline std::string* UserReceipt::release_userjid() { + // @@protoc_insertion_point(field_release:proto.UserReceipt.userJid) + if (!_internal_has_userjid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.userjid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.userjid_.IsDefault()) { + _impl_.userjid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void UserReceipt::set_allocated_userjid(std::string* userjid) { + if (userjid != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.userjid_.SetAllocated(userjid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.userjid_.IsDefault()) { + _impl_.userjid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.UserReceipt.userJid) +} + +// optional int64 receiptTimestamp = 2; +inline bool UserReceipt::_internal_has_receipttimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool UserReceipt::has_receipttimestamp() const { + return _internal_has_receipttimestamp(); +} +inline void UserReceipt::clear_receipttimestamp() { + _impl_.receipttimestamp_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline int64_t UserReceipt::_internal_receipttimestamp() const { + return _impl_.receipttimestamp_; +} +inline int64_t UserReceipt::receipttimestamp() const { + // @@protoc_insertion_point(field_get:proto.UserReceipt.receiptTimestamp) + return _internal_receipttimestamp(); +} +inline void UserReceipt::_internal_set_receipttimestamp(int64_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.receipttimestamp_ = value; +} +inline void UserReceipt::set_receipttimestamp(int64_t value) { + _internal_set_receipttimestamp(value); + // @@protoc_insertion_point(field_set:proto.UserReceipt.receiptTimestamp) +} + +// optional int64 readTimestamp = 3; +inline bool UserReceipt::_internal_has_readtimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool UserReceipt::has_readtimestamp() const { + return _internal_has_readtimestamp(); +} +inline void UserReceipt::clear_readtimestamp() { + _impl_.readtimestamp_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline int64_t UserReceipt::_internal_readtimestamp() const { + return _impl_.readtimestamp_; +} +inline int64_t UserReceipt::readtimestamp() const { + // @@protoc_insertion_point(field_get:proto.UserReceipt.readTimestamp) + return _internal_readtimestamp(); +} +inline void UserReceipt::_internal_set_readtimestamp(int64_t value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.readtimestamp_ = value; +} +inline void UserReceipt::set_readtimestamp(int64_t value) { + _internal_set_readtimestamp(value); + // @@protoc_insertion_point(field_set:proto.UserReceipt.readTimestamp) +} + +// optional int64 playedTimestamp = 4; +inline bool UserReceipt::_internal_has_playedtimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool UserReceipt::has_playedtimestamp() const { + return _internal_has_playedtimestamp(); +} +inline void UserReceipt::clear_playedtimestamp() { + _impl_.playedtimestamp_ = int64_t{0}; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline int64_t UserReceipt::_internal_playedtimestamp() const { + return _impl_.playedtimestamp_; +} +inline int64_t UserReceipt::playedtimestamp() const { + // @@protoc_insertion_point(field_get:proto.UserReceipt.playedTimestamp) + return _internal_playedtimestamp(); +} +inline void UserReceipt::_internal_set_playedtimestamp(int64_t value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.playedtimestamp_ = value; +} +inline void UserReceipt::set_playedtimestamp(int64_t value) { + _internal_set_playedtimestamp(value); + // @@protoc_insertion_point(field_set:proto.UserReceipt.playedTimestamp) +} + +// repeated string pendingDeviceJid = 5; +inline int UserReceipt::_internal_pendingdevicejid_size() const { + return _impl_.pendingdevicejid_.size(); +} +inline int UserReceipt::pendingdevicejid_size() const { + return _internal_pendingdevicejid_size(); +} +inline void UserReceipt::clear_pendingdevicejid() { + _impl_.pendingdevicejid_.Clear(); +} +inline std::string* UserReceipt::add_pendingdevicejid() { + std::string* _s = _internal_add_pendingdevicejid(); + // @@protoc_insertion_point(field_add_mutable:proto.UserReceipt.pendingDeviceJid) + return _s; +} +inline const std::string& UserReceipt::_internal_pendingdevicejid(int index) const { + return _impl_.pendingdevicejid_.Get(index); +} +inline const std::string& UserReceipt::pendingdevicejid(int index) const { + // @@protoc_insertion_point(field_get:proto.UserReceipt.pendingDeviceJid) + return _internal_pendingdevicejid(index); +} +inline std::string* UserReceipt::mutable_pendingdevicejid(int index) { + // @@protoc_insertion_point(field_mutable:proto.UserReceipt.pendingDeviceJid) + return _impl_.pendingdevicejid_.Mutable(index); +} +inline void UserReceipt::set_pendingdevicejid(int index, const std::string& value) { + _impl_.pendingdevicejid_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:proto.UserReceipt.pendingDeviceJid) +} +inline void UserReceipt::set_pendingdevicejid(int index, std::string&& value) { + _impl_.pendingdevicejid_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:proto.UserReceipt.pendingDeviceJid) +} +inline void UserReceipt::set_pendingdevicejid(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + _impl_.pendingdevicejid_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:proto.UserReceipt.pendingDeviceJid) +} +inline void UserReceipt::set_pendingdevicejid(int index, const char* value, size_t size) { + _impl_.pendingdevicejid_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:proto.UserReceipt.pendingDeviceJid) +} +inline std::string* UserReceipt::_internal_add_pendingdevicejid() { + return _impl_.pendingdevicejid_.Add(); +} +inline void UserReceipt::add_pendingdevicejid(const std::string& value) { + _impl_.pendingdevicejid_.Add()->assign(value); + // @@protoc_insertion_point(field_add:proto.UserReceipt.pendingDeviceJid) +} +inline void UserReceipt::add_pendingdevicejid(std::string&& value) { + _impl_.pendingdevicejid_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:proto.UserReceipt.pendingDeviceJid) +} +inline void UserReceipt::add_pendingdevicejid(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _impl_.pendingdevicejid_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:proto.UserReceipt.pendingDeviceJid) +} +inline void UserReceipt::add_pendingdevicejid(const char* value, size_t size) { + _impl_.pendingdevicejid_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:proto.UserReceipt.pendingDeviceJid) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +UserReceipt::pendingdevicejid() const { + // @@protoc_insertion_point(field_list:proto.UserReceipt.pendingDeviceJid) + return _impl_.pendingdevicejid_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +UserReceipt::mutable_pendingdevicejid() { + // @@protoc_insertion_point(field_mutable_list:proto.UserReceipt.pendingDeviceJid) + return &_impl_.pendingdevicejid_; +} + +// repeated string deliveredDeviceJid = 6; +inline int UserReceipt::_internal_delivereddevicejid_size() const { + return _impl_.delivereddevicejid_.size(); +} +inline int UserReceipt::delivereddevicejid_size() const { + return _internal_delivereddevicejid_size(); +} +inline void UserReceipt::clear_delivereddevicejid() { + _impl_.delivereddevicejid_.Clear(); +} +inline std::string* UserReceipt::add_delivereddevicejid() { + std::string* _s = _internal_add_delivereddevicejid(); + // @@protoc_insertion_point(field_add_mutable:proto.UserReceipt.deliveredDeviceJid) + return _s; +} +inline const std::string& UserReceipt::_internal_delivereddevicejid(int index) const { + return _impl_.delivereddevicejid_.Get(index); +} +inline const std::string& UserReceipt::delivereddevicejid(int index) const { + // @@protoc_insertion_point(field_get:proto.UserReceipt.deliveredDeviceJid) + return _internal_delivereddevicejid(index); +} +inline std::string* UserReceipt::mutable_delivereddevicejid(int index) { + // @@protoc_insertion_point(field_mutable:proto.UserReceipt.deliveredDeviceJid) + return _impl_.delivereddevicejid_.Mutable(index); +} +inline void UserReceipt::set_delivereddevicejid(int index, const std::string& value) { + _impl_.delivereddevicejid_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:proto.UserReceipt.deliveredDeviceJid) +} +inline void UserReceipt::set_delivereddevicejid(int index, std::string&& value) { + _impl_.delivereddevicejid_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:proto.UserReceipt.deliveredDeviceJid) +} +inline void UserReceipt::set_delivereddevicejid(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + _impl_.delivereddevicejid_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:proto.UserReceipt.deliveredDeviceJid) +} +inline void UserReceipt::set_delivereddevicejid(int index, const char* value, size_t size) { + _impl_.delivereddevicejid_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:proto.UserReceipt.deliveredDeviceJid) +} +inline std::string* UserReceipt::_internal_add_delivereddevicejid() { + return _impl_.delivereddevicejid_.Add(); +} +inline void UserReceipt::add_delivereddevicejid(const std::string& value) { + _impl_.delivereddevicejid_.Add()->assign(value); + // @@protoc_insertion_point(field_add:proto.UserReceipt.deliveredDeviceJid) +} +inline void UserReceipt::add_delivereddevicejid(std::string&& value) { + _impl_.delivereddevicejid_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:proto.UserReceipt.deliveredDeviceJid) +} +inline void UserReceipt::add_delivereddevicejid(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _impl_.delivereddevicejid_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:proto.UserReceipt.deliveredDeviceJid) +} +inline void UserReceipt::add_delivereddevicejid(const char* value, size_t size) { + _impl_.delivereddevicejid_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:proto.UserReceipt.deliveredDeviceJid) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +UserReceipt::delivereddevicejid() const { + // @@protoc_insertion_point(field_list:proto.UserReceipt.deliveredDeviceJid) + return _impl_.delivereddevicejid_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +UserReceipt::mutable_delivereddevicejid() { + // @@protoc_insertion_point(field_mutable_list:proto.UserReceipt.deliveredDeviceJid) + return &_impl_.delivereddevicejid_; +} + +// ------------------------------------------------------------------- + +// VerifiedNameCertificate_Details + +// optional uint64 serial = 1; +inline bool VerifiedNameCertificate_Details::_internal_has_serial() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool VerifiedNameCertificate_Details::has_serial() const { + return _internal_has_serial(); +} +inline void VerifiedNameCertificate_Details::clear_serial() { + _impl_.serial_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline uint64_t VerifiedNameCertificate_Details::_internal_serial() const { + return _impl_.serial_; +} +inline uint64_t VerifiedNameCertificate_Details::serial() const { + // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.Details.serial) + return _internal_serial(); +} +inline void VerifiedNameCertificate_Details::_internal_set_serial(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.serial_ = value; +} +inline void VerifiedNameCertificate_Details::set_serial(uint64_t value) { + _internal_set_serial(value); + // @@protoc_insertion_point(field_set:proto.VerifiedNameCertificate.Details.serial) +} + +// optional string issuer = 2; +inline bool VerifiedNameCertificate_Details::_internal_has_issuer() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool VerifiedNameCertificate_Details::has_issuer() const { + return _internal_has_issuer(); +} +inline void VerifiedNameCertificate_Details::clear_issuer() { + _impl_.issuer_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& VerifiedNameCertificate_Details::issuer() const { + // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.Details.issuer) + return _internal_issuer(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void VerifiedNameCertificate_Details::set_issuer(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.issuer_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.VerifiedNameCertificate.Details.issuer) +} +inline std::string* VerifiedNameCertificate_Details::mutable_issuer() { + std::string* _s = _internal_mutable_issuer(); + // @@protoc_insertion_point(field_mutable:proto.VerifiedNameCertificate.Details.issuer) + return _s; +} +inline const std::string& VerifiedNameCertificate_Details::_internal_issuer() const { + return _impl_.issuer_.Get(); +} +inline void VerifiedNameCertificate_Details::_internal_set_issuer(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.issuer_.Set(value, GetArenaForAllocation()); +} +inline std::string* VerifiedNameCertificate_Details::_internal_mutable_issuer() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.issuer_.Mutable(GetArenaForAllocation()); +} +inline std::string* VerifiedNameCertificate_Details::release_issuer() { + // @@protoc_insertion_point(field_release:proto.VerifiedNameCertificate.Details.issuer) + if (!_internal_has_issuer()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.issuer_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.issuer_.IsDefault()) { + _impl_.issuer_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void VerifiedNameCertificate_Details::set_allocated_issuer(std::string* issuer) { + if (issuer != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.issuer_.SetAllocated(issuer, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.issuer_.IsDefault()) { + _impl_.issuer_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.VerifiedNameCertificate.Details.issuer) +} + +// optional string verifiedName = 4; +inline bool VerifiedNameCertificate_Details::_internal_has_verifiedname() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool VerifiedNameCertificate_Details::has_verifiedname() const { + return _internal_has_verifiedname(); +} +inline void VerifiedNameCertificate_Details::clear_verifiedname() { + _impl_.verifiedname_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& VerifiedNameCertificate_Details::verifiedname() const { + // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.Details.verifiedName) + return _internal_verifiedname(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void VerifiedNameCertificate_Details::set_verifiedname(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.verifiedname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.VerifiedNameCertificate.Details.verifiedName) +} +inline std::string* VerifiedNameCertificate_Details::mutable_verifiedname() { + std::string* _s = _internal_mutable_verifiedname(); + // @@protoc_insertion_point(field_mutable:proto.VerifiedNameCertificate.Details.verifiedName) + return _s; +} +inline const std::string& VerifiedNameCertificate_Details::_internal_verifiedname() const { + return _impl_.verifiedname_.Get(); +} +inline void VerifiedNameCertificate_Details::_internal_set_verifiedname(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.verifiedname_.Set(value, GetArenaForAllocation()); +} +inline std::string* VerifiedNameCertificate_Details::_internal_mutable_verifiedname() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.verifiedname_.Mutable(GetArenaForAllocation()); +} +inline std::string* VerifiedNameCertificate_Details::release_verifiedname() { + // @@protoc_insertion_point(field_release:proto.VerifiedNameCertificate.Details.verifiedName) + if (!_internal_has_verifiedname()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.verifiedname_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.verifiedname_.IsDefault()) { + _impl_.verifiedname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void VerifiedNameCertificate_Details::set_allocated_verifiedname(std::string* verifiedname) { + if (verifiedname != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.verifiedname_.SetAllocated(verifiedname, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.verifiedname_.IsDefault()) { + _impl_.verifiedname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.VerifiedNameCertificate.Details.verifiedName) +} + +// repeated .proto.LocalizedName localizedNames = 8; +inline int VerifiedNameCertificate_Details::_internal_localizednames_size() const { + return _impl_.localizednames_.size(); +} +inline int VerifiedNameCertificate_Details::localizednames_size() const { + return _internal_localizednames_size(); +} +inline void VerifiedNameCertificate_Details::clear_localizednames() { + _impl_.localizednames_.Clear(); +} +inline ::proto::LocalizedName* VerifiedNameCertificate_Details::mutable_localizednames(int index) { + // @@protoc_insertion_point(field_mutable:proto.VerifiedNameCertificate.Details.localizedNames) + return _impl_.localizednames_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::LocalizedName >* +VerifiedNameCertificate_Details::mutable_localizednames() { + // @@protoc_insertion_point(field_mutable_list:proto.VerifiedNameCertificate.Details.localizedNames) + return &_impl_.localizednames_; +} +inline const ::proto::LocalizedName& VerifiedNameCertificate_Details::_internal_localizednames(int index) const { + return _impl_.localizednames_.Get(index); +} +inline const ::proto::LocalizedName& VerifiedNameCertificate_Details::localizednames(int index) const { + // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.Details.localizedNames) + return _internal_localizednames(index); +} +inline ::proto::LocalizedName* VerifiedNameCertificate_Details::_internal_add_localizednames() { + return _impl_.localizednames_.Add(); +} +inline ::proto::LocalizedName* VerifiedNameCertificate_Details::add_localizednames() { + ::proto::LocalizedName* _add = _internal_add_localizednames(); + // @@protoc_insertion_point(field_add:proto.VerifiedNameCertificate.Details.localizedNames) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::LocalizedName >& +VerifiedNameCertificate_Details::localizednames() const { + // @@protoc_insertion_point(field_list:proto.VerifiedNameCertificate.Details.localizedNames) + return _impl_.localizednames_; +} + +// optional uint64 issueTime = 10; +inline bool VerifiedNameCertificate_Details::_internal_has_issuetime() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool VerifiedNameCertificate_Details::has_issuetime() const { + return _internal_has_issuetime(); +} +inline void VerifiedNameCertificate_Details::clear_issuetime() { + _impl_.issuetime_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline uint64_t VerifiedNameCertificate_Details::_internal_issuetime() const { + return _impl_.issuetime_; +} +inline uint64_t VerifiedNameCertificate_Details::issuetime() const { + // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.Details.issueTime) + return _internal_issuetime(); +} +inline void VerifiedNameCertificate_Details::_internal_set_issuetime(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.issuetime_ = value; +} +inline void VerifiedNameCertificate_Details::set_issuetime(uint64_t value) { + _internal_set_issuetime(value); + // @@protoc_insertion_point(field_set:proto.VerifiedNameCertificate.Details.issueTime) +} + +// ------------------------------------------------------------------- + +// VerifiedNameCertificate + +// optional bytes details = 1; +inline bool VerifiedNameCertificate::_internal_has_details() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool VerifiedNameCertificate::has_details() const { + return _internal_has_details(); +} +inline void VerifiedNameCertificate::clear_details() { + _impl_.details_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& VerifiedNameCertificate::details() const { + // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.details) + return _internal_details(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void VerifiedNameCertificate::set_details(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.details_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.VerifiedNameCertificate.details) +} +inline std::string* VerifiedNameCertificate::mutable_details() { + std::string* _s = _internal_mutable_details(); + // @@protoc_insertion_point(field_mutable:proto.VerifiedNameCertificate.details) + return _s; +} +inline const std::string& VerifiedNameCertificate::_internal_details() const { + return _impl_.details_.Get(); +} +inline void VerifiedNameCertificate::_internal_set_details(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.details_.Set(value, GetArenaForAllocation()); +} +inline std::string* VerifiedNameCertificate::_internal_mutable_details() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.details_.Mutable(GetArenaForAllocation()); +} +inline std::string* VerifiedNameCertificate::release_details() { + // @@protoc_insertion_point(field_release:proto.VerifiedNameCertificate.details) + if (!_internal_has_details()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.details_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.details_.IsDefault()) { + _impl_.details_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void VerifiedNameCertificate::set_allocated_details(std::string* details) { + if (details != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.details_.SetAllocated(details, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.details_.IsDefault()) { + _impl_.details_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.VerifiedNameCertificate.details) +} + +// optional bytes signature = 2; +inline bool VerifiedNameCertificate::_internal_has_signature() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool VerifiedNameCertificate::has_signature() const { + return _internal_has_signature(); +} +inline void VerifiedNameCertificate::clear_signature() { + _impl_.signature_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& VerifiedNameCertificate::signature() const { + // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.signature) + return _internal_signature(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void VerifiedNameCertificate::set_signature(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.signature_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.VerifiedNameCertificate.signature) +} +inline std::string* VerifiedNameCertificate::mutable_signature() { + std::string* _s = _internal_mutable_signature(); + // @@protoc_insertion_point(field_mutable:proto.VerifiedNameCertificate.signature) + return _s; +} +inline const std::string& VerifiedNameCertificate::_internal_signature() const { + return _impl_.signature_.Get(); +} +inline void VerifiedNameCertificate::_internal_set_signature(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.signature_.Set(value, GetArenaForAllocation()); +} +inline std::string* VerifiedNameCertificate::_internal_mutable_signature() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.signature_.Mutable(GetArenaForAllocation()); +} +inline std::string* VerifiedNameCertificate::release_signature() { + // @@protoc_insertion_point(field_release:proto.VerifiedNameCertificate.signature) + if (!_internal_has_signature()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.signature_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.signature_.IsDefault()) { + _impl_.signature_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void VerifiedNameCertificate::set_allocated_signature(std::string* signature) { + if (signature != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.signature_.SetAllocated(signature, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.signature_.IsDefault()) { + _impl_.signature_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.VerifiedNameCertificate.signature) +} + +// optional bytes serverSignature = 3; +inline bool VerifiedNameCertificate::_internal_has_serversignature() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool VerifiedNameCertificate::has_serversignature() const { + return _internal_has_serversignature(); +} +inline void VerifiedNameCertificate::clear_serversignature() { + _impl_.serversignature_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& VerifiedNameCertificate::serversignature() const { + // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.serverSignature) + return _internal_serversignature(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void VerifiedNameCertificate::set_serversignature(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.serversignature_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.VerifiedNameCertificate.serverSignature) +} +inline std::string* VerifiedNameCertificate::mutable_serversignature() { + std::string* _s = _internal_mutable_serversignature(); + // @@protoc_insertion_point(field_mutable:proto.VerifiedNameCertificate.serverSignature) + return _s; +} +inline const std::string& VerifiedNameCertificate::_internal_serversignature() const { + return _impl_.serversignature_.Get(); +} +inline void VerifiedNameCertificate::_internal_set_serversignature(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.serversignature_.Set(value, GetArenaForAllocation()); +} +inline std::string* VerifiedNameCertificate::_internal_mutable_serversignature() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.serversignature_.Mutable(GetArenaForAllocation()); +} +inline std::string* VerifiedNameCertificate::release_serversignature() { + // @@protoc_insertion_point(field_release:proto.VerifiedNameCertificate.serverSignature) + if (!_internal_has_serversignature()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.serversignature_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.serversignature_.IsDefault()) { + _impl_.serversignature_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void VerifiedNameCertificate::set_allocated_serversignature(std::string* serversignature) { + if (serversignature != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.serversignature_.SetAllocated(serversignature, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.serversignature_.IsDefault()) { + _impl_.serversignature_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.VerifiedNameCertificate.serverSignature) +} + +// ------------------------------------------------------------------- + +// WallpaperSettings + +// optional string filename = 1; +inline bool WallpaperSettings::_internal_has_filename() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool WallpaperSettings::has_filename() const { + return _internal_has_filename(); +} +inline void WallpaperSettings::clear_filename() { + _impl_.filename_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& WallpaperSettings::filename() const { + // @@protoc_insertion_point(field_get:proto.WallpaperSettings.filename) + return _internal_filename(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void WallpaperSettings::set_filename(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.filename_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.WallpaperSettings.filename) +} +inline std::string* WallpaperSettings::mutable_filename() { + std::string* _s = _internal_mutable_filename(); + // @@protoc_insertion_point(field_mutable:proto.WallpaperSettings.filename) + return _s; +} +inline const std::string& WallpaperSettings::_internal_filename() const { + return _impl_.filename_.Get(); +} +inline void WallpaperSettings::_internal_set_filename(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.filename_.Set(value, GetArenaForAllocation()); +} +inline std::string* WallpaperSettings::_internal_mutable_filename() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.filename_.Mutable(GetArenaForAllocation()); +} +inline std::string* WallpaperSettings::release_filename() { + // @@protoc_insertion_point(field_release:proto.WallpaperSettings.filename) + if (!_internal_has_filename()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.filename_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.filename_.IsDefault()) { + _impl_.filename_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void WallpaperSettings::set_allocated_filename(std::string* filename) { + if (filename != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.filename_.SetAllocated(filename, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.filename_.IsDefault()) { + _impl_.filename_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.WallpaperSettings.filename) +} + +// optional uint32 opacity = 2; +inline bool WallpaperSettings::_internal_has_opacity() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool WallpaperSettings::has_opacity() const { + return _internal_has_opacity(); +} +inline void WallpaperSettings::clear_opacity() { + _impl_.opacity_ = 0u; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline uint32_t WallpaperSettings::_internal_opacity() const { + return _impl_.opacity_; +} +inline uint32_t WallpaperSettings::opacity() const { + // @@protoc_insertion_point(field_get:proto.WallpaperSettings.opacity) + return _internal_opacity(); +} +inline void WallpaperSettings::_internal_set_opacity(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.opacity_ = value; +} +inline void WallpaperSettings::set_opacity(uint32_t value) { + _internal_set_opacity(value); + // @@protoc_insertion_point(field_set:proto.WallpaperSettings.opacity) +} + +// ------------------------------------------------------------------- + +// WebFeatures + +// optional .proto.WebFeatures.Flag labelsDisplay = 1; +inline bool WebFeatures::_internal_has_labelsdisplay() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool WebFeatures::has_labelsdisplay() const { + return _internal_has_labelsdisplay(); +} +inline void WebFeatures::clear_labelsdisplay() { + _impl_.labelsdisplay_ = 0; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_labelsdisplay() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.labelsdisplay_); +} +inline ::proto::WebFeatures_Flag WebFeatures::labelsdisplay() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.labelsDisplay) + return _internal_labelsdisplay(); +} +inline void WebFeatures::_internal_set_labelsdisplay(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.labelsdisplay_ = value; +} +inline void WebFeatures::set_labelsdisplay(::proto::WebFeatures_Flag value) { + _internal_set_labelsdisplay(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.labelsDisplay) +} + +// optional .proto.WebFeatures.Flag voipIndividualOutgoing = 2; +inline bool WebFeatures::_internal_has_voipindividualoutgoing() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool WebFeatures::has_voipindividualoutgoing() const { + return _internal_has_voipindividualoutgoing(); +} +inline void WebFeatures::clear_voipindividualoutgoing() { + _impl_.voipindividualoutgoing_ = 0; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_voipindividualoutgoing() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.voipindividualoutgoing_); +} +inline ::proto::WebFeatures_Flag WebFeatures::voipindividualoutgoing() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.voipIndividualOutgoing) + return _internal_voipindividualoutgoing(); +} +inline void WebFeatures::_internal_set_voipindividualoutgoing(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.voipindividualoutgoing_ = value; +} +inline void WebFeatures::set_voipindividualoutgoing(::proto::WebFeatures_Flag value) { + _internal_set_voipindividualoutgoing(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.voipIndividualOutgoing) +} + +// optional .proto.WebFeatures.Flag groupsV3 = 3; +inline bool WebFeatures::_internal_has_groupsv3() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool WebFeatures::has_groupsv3() const { + return _internal_has_groupsv3(); +} +inline void WebFeatures::clear_groupsv3() { + _impl_.groupsv3_ = 0; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_groupsv3() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.groupsv3_); +} +inline ::proto::WebFeatures_Flag WebFeatures::groupsv3() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.groupsV3) + return _internal_groupsv3(); +} +inline void WebFeatures::_internal_set_groupsv3(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.groupsv3_ = value; +} +inline void WebFeatures::set_groupsv3(::proto::WebFeatures_Flag value) { + _internal_set_groupsv3(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.groupsV3) +} + +// optional .proto.WebFeatures.Flag groupsV3Create = 4; +inline bool WebFeatures::_internal_has_groupsv3create() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool WebFeatures::has_groupsv3create() const { + return _internal_has_groupsv3create(); +} +inline void WebFeatures::clear_groupsv3create() { + _impl_.groupsv3create_ = 0; + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_groupsv3create() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.groupsv3create_); +} +inline ::proto::WebFeatures_Flag WebFeatures::groupsv3create() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.groupsV3Create) + return _internal_groupsv3create(); +} +inline void WebFeatures::_internal_set_groupsv3create(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.groupsv3create_ = value; +} +inline void WebFeatures::set_groupsv3create(::proto::WebFeatures_Flag value) { + _internal_set_groupsv3create(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.groupsV3Create) +} + +// optional .proto.WebFeatures.Flag changeNumberV2 = 5; +inline bool WebFeatures::_internal_has_changenumberv2() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool WebFeatures::has_changenumberv2() const { + return _internal_has_changenumberv2(); +} +inline void WebFeatures::clear_changenumberv2() { + _impl_.changenumberv2_ = 0; + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_changenumberv2() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.changenumberv2_); +} +inline ::proto::WebFeatures_Flag WebFeatures::changenumberv2() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.changeNumberV2) + return _internal_changenumberv2(); +} +inline void WebFeatures::_internal_set_changenumberv2(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.changenumberv2_ = value; +} +inline void WebFeatures::set_changenumberv2(::proto::WebFeatures_Flag value) { + _internal_set_changenumberv2(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.changeNumberV2) +} + +// optional .proto.WebFeatures.Flag queryStatusV3Thumbnail = 6; +inline bool WebFeatures::_internal_has_querystatusv3thumbnail() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool WebFeatures::has_querystatusv3thumbnail() const { + return _internal_has_querystatusv3thumbnail(); +} +inline void WebFeatures::clear_querystatusv3thumbnail() { + _impl_.querystatusv3thumbnail_ = 0; + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_querystatusv3thumbnail() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.querystatusv3thumbnail_); +} +inline ::proto::WebFeatures_Flag WebFeatures::querystatusv3thumbnail() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.queryStatusV3Thumbnail) + return _internal_querystatusv3thumbnail(); +} +inline void WebFeatures::_internal_set_querystatusv3thumbnail(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.querystatusv3thumbnail_ = value; +} +inline void WebFeatures::set_querystatusv3thumbnail(::proto::WebFeatures_Flag value) { + _internal_set_querystatusv3thumbnail(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.queryStatusV3Thumbnail) +} + +// optional .proto.WebFeatures.Flag liveLocations = 7; +inline bool WebFeatures::_internal_has_livelocations() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool WebFeatures::has_livelocations() const { + return _internal_has_livelocations(); +} +inline void WebFeatures::clear_livelocations() { + _impl_.livelocations_ = 0; + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_livelocations() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.livelocations_); +} +inline ::proto::WebFeatures_Flag WebFeatures::livelocations() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.liveLocations) + return _internal_livelocations(); +} +inline void WebFeatures::_internal_set_livelocations(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.livelocations_ = value; +} +inline void WebFeatures::set_livelocations(::proto::WebFeatures_Flag value) { + _internal_set_livelocations(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.liveLocations) +} + +// optional .proto.WebFeatures.Flag queryVname = 8; +inline bool WebFeatures::_internal_has_queryvname() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool WebFeatures::has_queryvname() const { + return _internal_has_queryvname(); +} +inline void WebFeatures::clear_queryvname() { + _impl_.queryvname_ = 0; + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_queryvname() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.queryvname_); +} +inline ::proto::WebFeatures_Flag WebFeatures::queryvname() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.queryVname) + return _internal_queryvname(); +} +inline void WebFeatures::_internal_set_queryvname(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.queryvname_ = value; +} +inline void WebFeatures::set_queryvname(::proto::WebFeatures_Flag value) { + _internal_set_queryvname(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.queryVname) +} + +// optional .proto.WebFeatures.Flag voipIndividualIncoming = 9; +inline bool WebFeatures::_internal_has_voipindividualincoming() const { + bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool WebFeatures::has_voipindividualincoming() const { + return _internal_has_voipindividualincoming(); +} +inline void WebFeatures::clear_voipindividualincoming() { + _impl_.voipindividualincoming_ = 0; + _impl_._has_bits_[0] &= ~0x00000100u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_voipindividualincoming() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.voipindividualincoming_); +} +inline ::proto::WebFeatures_Flag WebFeatures::voipindividualincoming() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.voipIndividualIncoming) + return _internal_voipindividualincoming(); +} +inline void WebFeatures::_internal_set_voipindividualincoming(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000100u; + _impl_.voipindividualincoming_ = value; +} +inline void WebFeatures::set_voipindividualincoming(::proto::WebFeatures_Flag value) { + _internal_set_voipindividualincoming(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.voipIndividualIncoming) +} + +// optional .proto.WebFeatures.Flag quickRepliesQuery = 10; +inline bool WebFeatures::_internal_has_quickrepliesquery() const { + bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool WebFeatures::has_quickrepliesquery() const { + return _internal_has_quickrepliesquery(); +} +inline void WebFeatures::clear_quickrepliesquery() { + _impl_.quickrepliesquery_ = 0; + _impl_._has_bits_[0] &= ~0x00000200u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_quickrepliesquery() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.quickrepliesquery_); +} +inline ::proto::WebFeatures_Flag WebFeatures::quickrepliesquery() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.quickRepliesQuery) + return _internal_quickrepliesquery(); +} +inline void WebFeatures::_internal_set_quickrepliesquery(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000200u; + _impl_.quickrepliesquery_ = value; +} +inline void WebFeatures::set_quickrepliesquery(::proto::WebFeatures_Flag value) { + _internal_set_quickrepliesquery(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.quickRepliesQuery) +} + +// optional .proto.WebFeatures.Flag payments = 11; +inline bool WebFeatures::_internal_has_payments() const { + bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool WebFeatures::has_payments() const { + return _internal_has_payments(); +} +inline void WebFeatures::clear_payments() { + _impl_.payments_ = 0; + _impl_._has_bits_[0] &= ~0x00000400u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_payments() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.payments_); +} +inline ::proto::WebFeatures_Flag WebFeatures::payments() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.payments) + return _internal_payments(); +} +inline void WebFeatures::_internal_set_payments(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000400u; + _impl_.payments_ = value; +} +inline void WebFeatures::set_payments(::proto::WebFeatures_Flag value) { + _internal_set_payments(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.payments) +} + +// optional .proto.WebFeatures.Flag stickerPackQuery = 12; +inline bool WebFeatures::_internal_has_stickerpackquery() const { + bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; + return value; +} +inline bool WebFeatures::has_stickerpackquery() const { + return _internal_has_stickerpackquery(); +} +inline void WebFeatures::clear_stickerpackquery() { + _impl_.stickerpackquery_ = 0; + _impl_._has_bits_[0] &= ~0x00000800u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_stickerpackquery() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.stickerpackquery_); +} +inline ::proto::WebFeatures_Flag WebFeatures::stickerpackquery() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.stickerPackQuery) + return _internal_stickerpackquery(); +} +inline void WebFeatures::_internal_set_stickerpackquery(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x00000800u; + _impl_.stickerpackquery_ = value; +} +inline void WebFeatures::set_stickerpackquery(::proto::WebFeatures_Flag value) { + _internal_set_stickerpackquery(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.stickerPackQuery) +} + +// optional .proto.WebFeatures.Flag liveLocationsFinal = 13; +inline bool WebFeatures::_internal_has_livelocationsfinal() const { + bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; + return value; +} +inline bool WebFeatures::has_livelocationsfinal() const { + return _internal_has_livelocationsfinal(); +} +inline void WebFeatures::clear_livelocationsfinal() { + _impl_.livelocationsfinal_ = 0; + _impl_._has_bits_[0] &= ~0x00001000u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_livelocationsfinal() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.livelocationsfinal_); +} +inline ::proto::WebFeatures_Flag WebFeatures::livelocationsfinal() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.liveLocationsFinal) + return _internal_livelocationsfinal(); +} +inline void WebFeatures::_internal_set_livelocationsfinal(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x00001000u; + _impl_.livelocationsfinal_ = value; +} +inline void WebFeatures::set_livelocationsfinal(::proto::WebFeatures_Flag value) { + _internal_set_livelocationsfinal(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.liveLocationsFinal) +} + +// optional .proto.WebFeatures.Flag labelsEdit = 14; +inline bool WebFeatures::_internal_has_labelsedit() const { + bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0; + return value; +} +inline bool WebFeatures::has_labelsedit() const { + return _internal_has_labelsedit(); +} +inline void WebFeatures::clear_labelsedit() { + _impl_.labelsedit_ = 0; + _impl_._has_bits_[0] &= ~0x00002000u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_labelsedit() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.labelsedit_); +} +inline ::proto::WebFeatures_Flag WebFeatures::labelsedit() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.labelsEdit) + return _internal_labelsedit(); +} +inline void WebFeatures::_internal_set_labelsedit(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x00002000u; + _impl_.labelsedit_ = value; +} +inline void WebFeatures::set_labelsedit(::proto::WebFeatures_Flag value) { + _internal_set_labelsedit(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.labelsEdit) +} + +// optional .proto.WebFeatures.Flag mediaUpload = 15; +inline bool WebFeatures::_internal_has_mediaupload() const { + bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0; + return value; +} +inline bool WebFeatures::has_mediaupload() const { + return _internal_has_mediaupload(); +} +inline void WebFeatures::clear_mediaupload() { + _impl_.mediaupload_ = 0; + _impl_._has_bits_[0] &= ~0x00004000u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_mediaupload() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.mediaupload_); +} +inline ::proto::WebFeatures_Flag WebFeatures::mediaupload() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.mediaUpload) + return _internal_mediaupload(); +} +inline void WebFeatures::_internal_set_mediaupload(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x00004000u; + _impl_.mediaupload_ = value; +} +inline void WebFeatures::set_mediaupload(::proto::WebFeatures_Flag value) { + _internal_set_mediaupload(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.mediaUpload) +} + +// optional .proto.WebFeatures.Flag mediaUploadRichQuickReplies = 18; +inline bool WebFeatures::_internal_has_mediauploadrichquickreplies() const { + bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0; + return value; +} +inline bool WebFeatures::has_mediauploadrichquickreplies() const { + return _internal_has_mediauploadrichquickreplies(); +} +inline void WebFeatures::clear_mediauploadrichquickreplies() { + _impl_.mediauploadrichquickreplies_ = 0; + _impl_._has_bits_[0] &= ~0x00008000u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_mediauploadrichquickreplies() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.mediauploadrichquickreplies_); +} +inline ::proto::WebFeatures_Flag WebFeatures::mediauploadrichquickreplies() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.mediaUploadRichQuickReplies) + return _internal_mediauploadrichquickreplies(); +} +inline void WebFeatures::_internal_set_mediauploadrichquickreplies(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x00008000u; + _impl_.mediauploadrichquickreplies_ = value; +} +inline void WebFeatures::set_mediauploadrichquickreplies(::proto::WebFeatures_Flag value) { + _internal_set_mediauploadrichquickreplies(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.mediaUploadRichQuickReplies) +} + +// optional .proto.WebFeatures.Flag vnameV2 = 19; +inline bool WebFeatures::_internal_has_vnamev2() const { + bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0; + return value; +} +inline bool WebFeatures::has_vnamev2() const { + return _internal_has_vnamev2(); +} +inline void WebFeatures::clear_vnamev2() { + _impl_.vnamev2_ = 0; + _impl_._has_bits_[0] &= ~0x00010000u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_vnamev2() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.vnamev2_); +} +inline ::proto::WebFeatures_Flag WebFeatures::vnamev2() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.vnameV2) + return _internal_vnamev2(); +} +inline void WebFeatures::_internal_set_vnamev2(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x00010000u; + _impl_.vnamev2_ = value; +} +inline void WebFeatures::set_vnamev2(::proto::WebFeatures_Flag value) { + _internal_set_vnamev2(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.vnameV2) +} + +// optional .proto.WebFeatures.Flag videoPlaybackUrl = 20; +inline bool WebFeatures::_internal_has_videoplaybackurl() const { + bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0; + return value; +} +inline bool WebFeatures::has_videoplaybackurl() const { + return _internal_has_videoplaybackurl(); +} +inline void WebFeatures::clear_videoplaybackurl() { + _impl_.videoplaybackurl_ = 0; + _impl_._has_bits_[0] &= ~0x00020000u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_videoplaybackurl() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.videoplaybackurl_); +} +inline ::proto::WebFeatures_Flag WebFeatures::videoplaybackurl() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.videoPlaybackUrl) + return _internal_videoplaybackurl(); +} +inline void WebFeatures::_internal_set_videoplaybackurl(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x00020000u; + _impl_.videoplaybackurl_ = value; +} +inline void WebFeatures::set_videoplaybackurl(::proto::WebFeatures_Flag value) { + _internal_set_videoplaybackurl(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.videoPlaybackUrl) +} + +// optional .proto.WebFeatures.Flag statusRanking = 21; +inline bool WebFeatures::_internal_has_statusranking() const { + bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0; + return value; +} +inline bool WebFeatures::has_statusranking() const { + return _internal_has_statusranking(); +} +inline void WebFeatures::clear_statusranking() { + _impl_.statusranking_ = 0; + _impl_._has_bits_[0] &= ~0x00040000u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_statusranking() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.statusranking_); +} +inline ::proto::WebFeatures_Flag WebFeatures::statusranking() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.statusRanking) + return _internal_statusranking(); +} +inline void WebFeatures::_internal_set_statusranking(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x00040000u; + _impl_.statusranking_ = value; +} +inline void WebFeatures::set_statusranking(::proto::WebFeatures_Flag value) { + _internal_set_statusranking(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.statusRanking) +} + +// optional .proto.WebFeatures.Flag voipIndividualVideo = 22; +inline bool WebFeatures::_internal_has_voipindividualvideo() const { + bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0; + return value; +} +inline bool WebFeatures::has_voipindividualvideo() const { + return _internal_has_voipindividualvideo(); +} +inline void WebFeatures::clear_voipindividualvideo() { + _impl_.voipindividualvideo_ = 0; + _impl_._has_bits_[0] &= ~0x00080000u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_voipindividualvideo() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.voipindividualvideo_); +} +inline ::proto::WebFeatures_Flag WebFeatures::voipindividualvideo() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.voipIndividualVideo) + return _internal_voipindividualvideo(); +} +inline void WebFeatures::_internal_set_voipindividualvideo(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x00080000u; + _impl_.voipindividualvideo_ = value; +} +inline void WebFeatures::set_voipindividualvideo(::proto::WebFeatures_Flag value) { + _internal_set_voipindividualvideo(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.voipIndividualVideo) +} + +// optional .proto.WebFeatures.Flag thirdPartyStickers = 23; +inline bool WebFeatures::_internal_has_thirdpartystickers() const { + bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0; + return value; +} +inline bool WebFeatures::has_thirdpartystickers() const { + return _internal_has_thirdpartystickers(); +} +inline void WebFeatures::clear_thirdpartystickers() { + _impl_.thirdpartystickers_ = 0; + _impl_._has_bits_[0] &= ~0x00100000u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_thirdpartystickers() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.thirdpartystickers_); +} +inline ::proto::WebFeatures_Flag WebFeatures::thirdpartystickers() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.thirdPartyStickers) + return _internal_thirdpartystickers(); +} +inline void WebFeatures::_internal_set_thirdpartystickers(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x00100000u; + _impl_.thirdpartystickers_ = value; +} +inline void WebFeatures::set_thirdpartystickers(::proto::WebFeatures_Flag value) { + _internal_set_thirdpartystickers(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.thirdPartyStickers) +} + +// optional .proto.WebFeatures.Flag frequentlyForwardedSetting = 24; +inline bool WebFeatures::_internal_has_frequentlyforwardedsetting() const { + bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0; + return value; +} +inline bool WebFeatures::has_frequentlyforwardedsetting() const { + return _internal_has_frequentlyforwardedsetting(); +} +inline void WebFeatures::clear_frequentlyforwardedsetting() { + _impl_.frequentlyforwardedsetting_ = 0; + _impl_._has_bits_[0] &= ~0x00200000u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_frequentlyforwardedsetting() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.frequentlyforwardedsetting_); +} +inline ::proto::WebFeatures_Flag WebFeatures::frequentlyforwardedsetting() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.frequentlyForwardedSetting) + return _internal_frequentlyforwardedsetting(); +} +inline void WebFeatures::_internal_set_frequentlyforwardedsetting(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x00200000u; + _impl_.frequentlyforwardedsetting_ = value; +} +inline void WebFeatures::set_frequentlyforwardedsetting(::proto::WebFeatures_Flag value) { + _internal_set_frequentlyforwardedsetting(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.frequentlyForwardedSetting) +} + +// optional .proto.WebFeatures.Flag groupsV4JoinPermission = 25; +inline bool WebFeatures::_internal_has_groupsv4joinpermission() const { + bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0; + return value; +} +inline bool WebFeatures::has_groupsv4joinpermission() const { + return _internal_has_groupsv4joinpermission(); +} +inline void WebFeatures::clear_groupsv4joinpermission() { + _impl_.groupsv4joinpermission_ = 0; + _impl_._has_bits_[0] &= ~0x00400000u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_groupsv4joinpermission() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.groupsv4joinpermission_); +} +inline ::proto::WebFeatures_Flag WebFeatures::groupsv4joinpermission() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.groupsV4JoinPermission) + return _internal_groupsv4joinpermission(); +} +inline void WebFeatures::_internal_set_groupsv4joinpermission(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x00400000u; + _impl_.groupsv4joinpermission_ = value; +} +inline void WebFeatures::set_groupsv4joinpermission(::proto::WebFeatures_Flag value) { + _internal_set_groupsv4joinpermission(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.groupsV4JoinPermission) +} + +// optional .proto.WebFeatures.Flag recentStickers = 26; +inline bool WebFeatures::_internal_has_recentstickers() const { + bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0; + return value; +} +inline bool WebFeatures::has_recentstickers() const { + return _internal_has_recentstickers(); +} +inline void WebFeatures::clear_recentstickers() { + _impl_.recentstickers_ = 0; + _impl_._has_bits_[0] &= ~0x00800000u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_recentstickers() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.recentstickers_); +} +inline ::proto::WebFeatures_Flag WebFeatures::recentstickers() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.recentStickers) + return _internal_recentstickers(); +} +inline void WebFeatures::_internal_set_recentstickers(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x00800000u; + _impl_.recentstickers_ = value; +} +inline void WebFeatures::set_recentstickers(::proto::WebFeatures_Flag value) { + _internal_set_recentstickers(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.recentStickers) +} + +// optional .proto.WebFeatures.Flag catalog = 27; +inline bool WebFeatures::_internal_has_catalog() const { + bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0; + return value; +} +inline bool WebFeatures::has_catalog() const { + return _internal_has_catalog(); +} +inline void WebFeatures::clear_catalog() { + _impl_.catalog_ = 0; + _impl_._has_bits_[0] &= ~0x01000000u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_catalog() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.catalog_); +} +inline ::proto::WebFeatures_Flag WebFeatures::catalog() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.catalog) + return _internal_catalog(); +} +inline void WebFeatures::_internal_set_catalog(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x01000000u; + _impl_.catalog_ = value; +} +inline void WebFeatures::set_catalog(::proto::WebFeatures_Flag value) { + _internal_set_catalog(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.catalog) +} + +// optional .proto.WebFeatures.Flag starredStickers = 28; +inline bool WebFeatures::_internal_has_starredstickers() const { + bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0; + return value; +} +inline bool WebFeatures::has_starredstickers() const { + return _internal_has_starredstickers(); +} +inline void WebFeatures::clear_starredstickers() { + _impl_.starredstickers_ = 0; + _impl_._has_bits_[0] &= ~0x02000000u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_starredstickers() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.starredstickers_); +} +inline ::proto::WebFeatures_Flag WebFeatures::starredstickers() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.starredStickers) + return _internal_starredstickers(); +} +inline void WebFeatures::_internal_set_starredstickers(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x02000000u; + _impl_.starredstickers_ = value; +} +inline void WebFeatures::set_starredstickers(::proto::WebFeatures_Flag value) { + _internal_set_starredstickers(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.starredStickers) +} + +// optional .proto.WebFeatures.Flag voipGroupCall = 29; +inline bool WebFeatures::_internal_has_voipgroupcall() const { + bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0; + return value; +} +inline bool WebFeatures::has_voipgroupcall() const { + return _internal_has_voipgroupcall(); +} +inline void WebFeatures::clear_voipgroupcall() { + _impl_.voipgroupcall_ = 0; + _impl_._has_bits_[0] &= ~0x04000000u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_voipgroupcall() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.voipgroupcall_); +} +inline ::proto::WebFeatures_Flag WebFeatures::voipgroupcall() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.voipGroupCall) + return _internal_voipgroupcall(); +} +inline void WebFeatures::_internal_set_voipgroupcall(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x04000000u; + _impl_.voipgroupcall_ = value; +} +inline void WebFeatures::set_voipgroupcall(::proto::WebFeatures_Flag value) { + _internal_set_voipgroupcall(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.voipGroupCall) +} + +// optional .proto.WebFeatures.Flag templateMessage = 30; +inline bool WebFeatures::_internal_has_templatemessage() const { + bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0; + return value; +} +inline bool WebFeatures::has_templatemessage() const { + return _internal_has_templatemessage(); +} +inline void WebFeatures::clear_templatemessage() { + _impl_.templatemessage_ = 0; + _impl_._has_bits_[0] &= ~0x08000000u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_templatemessage() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.templatemessage_); +} +inline ::proto::WebFeatures_Flag WebFeatures::templatemessage() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.templateMessage) + return _internal_templatemessage(); +} +inline void WebFeatures::_internal_set_templatemessage(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x08000000u; + _impl_.templatemessage_ = value; +} +inline void WebFeatures::set_templatemessage(::proto::WebFeatures_Flag value) { + _internal_set_templatemessage(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.templateMessage) +} + +// optional .proto.WebFeatures.Flag templateMessageInteractivity = 31; +inline bool WebFeatures::_internal_has_templatemessageinteractivity() const { + bool value = (_impl_._has_bits_[0] & 0x10000000u) != 0; + return value; +} +inline bool WebFeatures::has_templatemessageinteractivity() const { + return _internal_has_templatemessageinteractivity(); +} +inline void WebFeatures::clear_templatemessageinteractivity() { + _impl_.templatemessageinteractivity_ = 0; + _impl_._has_bits_[0] &= ~0x10000000u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_templatemessageinteractivity() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.templatemessageinteractivity_); +} +inline ::proto::WebFeatures_Flag WebFeatures::templatemessageinteractivity() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.templateMessageInteractivity) + return _internal_templatemessageinteractivity(); +} +inline void WebFeatures::_internal_set_templatemessageinteractivity(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x10000000u; + _impl_.templatemessageinteractivity_ = value; +} +inline void WebFeatures::set_templatemessageinteractivity(::proto::WebFeatures_Flag value) { + _internal_set_templatemessageinteractivity(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.templateMessageInteractivity) +} + +// optional .proto.WebFeatures.Flag ephemeralMessages = 32; +inline bool WebFeatures::_internal_has_ephemeralmessages() const { + bool value = (_impl_._has_bits_[0] & 0x20000000u) != 0; + return value; +} +inline bool WebFeatures::has_ephemeralmessages() const { + return _internal_has_ephemeralmessages(); +} +inline void WebFeatures::clear_ephemeralmessages() { + _impl_.ephemeralmessages_ = 0; + _impl_._has_bits_[0] &= ~0x20000000u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_ephemeralmessages() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.ephemeralmessages_); +} +inline ::proto::WebFeatures_Flag WebFeatures::ephemeralmessages() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.ephemeralMessages) + return _internal_ephemeralmessages(); +} +inline void WebFeatures::_internal_set_ephemeralmessages(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x20000000u; + _impl_.ephemeralmessages_ = value; +} +inline void WebFeatures::set_ephemeralmessages(::proto::WebFeatures_Flag value) { + _internal_set_ephemeralmessages(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.ephemeralMessages) +} + +// optional .proto.WebFeatures.Flag e2ENotificationSync = 33; +inline bool WebFeatures::_internal_has_e2enotificationsync() const { + bool value = (_impl_._has_bits_[0] & 0x40000000u) != 0; + return value; +} +inline bool WebFeatures::has_e2enotificationsync() const { + return _internal_has_e2enotificationsync(); +} +inline void WebFeatures::clear_e2enotificationsync() { + _impl_.e2enotificationsync_ = 0; + _impl_._has_bits_[0] &= ~0x40000000u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_e2enotificationsync() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.e2enotificationsync_); +} +inline ::proto::WebFeatures_Flag WebFeatures::e2enotificationsync() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.e2ENotificationSync) + return _internal_e2enotificationsync(); +} +inline void WebFeatures::_internal_set_e2enotificationsync(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x40000000u; + _impl_.e2enotificationsync_ = value; +} +inline void WebFeatures::set_e2enotificationsync(::proto::WebFeatures_Flag value) { + _internal_set_e2enotificationsync(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.e2ENotificationSync) +} + +// optional .proto.WebFeatures.Flag recentStickersV2 = 34; +inline bool WebFeatures::_internal_has_recentstickersv2() const { + bool value = (_impl_._has_bits_[0] & 0x80000000u) != 0; + return value; +} +inline bool WebFeatures::has_recentstickersv2() const { + return _internal_has_recentstickersv2(); +} +inline void WebFeatures::clear_recentstickersv2() { + _impl_.recentstickersv2_ = 0; + _impl_._has_bits_[0] &= ~0x80000000u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_recentstickersv2() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.recentstickersv2_); +} +inline ::proto::WebFeatures_Flag WebFeatures::recentstickersv2() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.recentStickersV2) + return _internal_recentstickersv2(); +} +inline void WebFeatures::_internal_set_recentstickersv2(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[0] |= 0x80000000u; + _impl_.recentstickersv2_ = value; +} +inline void WebFeatures::set_recentstickersv2(::proto::WebFeatures_Flag value) { + _internal_set_recentstickersv2(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.recentStickersV2) +} + +// optional .proto.WebFeatures.Flag recentStickersV3 = 36; +inline bool WebFeatures::_internal_has_recentstickersv3() const { + bool value = (_impl_._has_bits_[1] & 0x00000001u) != 0; + return value; +} +inline bool WebFeatures::has_recentstickersv3() const { + return _internal_has_recentstickersv3(); +} +inline void WebFeatures::clear_recentstickersv3() { + _impl_.recentstickersv3_ = 0; + _impl_._has_bits_[1] &= ~0x00000001u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_recentstickersv3() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.recentstickersv3_); +} +inline ::proto::WebFeatures_Flag WebFeatures::recentstickersv3() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.recentStickersV3) + return _internal_recentstickersv3(); +} +inline void WebFeatures::_internal_set_recentstickersv3(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[1] |= 0x00000001u; + _impl_.recentstickersv3_ = value; +} +inline void WebFeatures::set_recentstickersv3(::proto::WebFeatures_Flag value) { + _internal_set_recentstickersv3(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.recentStickersV3) +} + +// optional .proto.WebFeatures.Flag userNotice = 37; +inline bool WebFeatures::_internal_has_usernotice() const { + bool value = (_impl_._has_bits_[1] & 0x00000002u) != 0; + return value; +} +inline bool WebFeatures::has_usernotice() const { + return _internal_has_usernotice(); +} +inline void WebFeatures::clear_usernotice() { + _impl_.usernotice_ = 0; + _impl_._has_bits_[1] &= ~0x00000002u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_usernotice() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.usernotice_); +} +inline ::proto::WebFeatures_Flag WebFeatures::usernotice() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.userNotice) + return _internal_usernotice(); +} +inline void WebFeatures::_internal_set_usernotice(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[1] |= 0x00000002u; + _impl_.usernotice_ = value; +} +inline void WebFeatures::set_usernotice(::proto::WebFeatures_Flag value) { + _internal_set_usernotice(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.userNotice) +} + +// optional .proto.WebFeatures.Flag support = 39; +inline bool WebFeatures::_internal_has_support() const { + bool value = (_impl_._has_bits_[1] & 0x00000004u) != 0; + return value; +} +inline bool WebFeatures::has_support() const { + return _internal_has_support(); +} +inline void WebFeatures::clear_support() { + _impl_.support_ = 0; + _impl_._has_bits_[1] &= ~0x00000004u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_support() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.support_); +} +inline ::proto::WebFeatures_Flag WebFeatures::support() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.support) + return _internal_support(); +} +inline void WebFeatures::_internal_set_support(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[1] |= 0x00000004u; + _impl_.support_ = value; +} +inline void WebFeatures::set_support(::proto::WebFeatures_Flag value) { + _internal_set_support(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.support) +} + +// optional .proto.WebFeatures.Flag groupUiiCleanup = 40; +inline bool WebFeatures::_internal_has_groupuiicleanup() const { + bool value = (_impl_._has_bits_[1] & 0x00000008u) != 0; + return value; +} +inline bool WebFeatures::has_groupuiicleanup() const { + return _internal_has_groupuiicleanup(); +} +inline void WebFeatures::clear_groupuiicleanup() { + _impl_.groupuiicleanup_ = 0; + _impl_._has_bits_[1] &= ~0x00000008u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_groupuiicleanup() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.groupuiicleanup_); +} +inline ::proto::WebFeatures_Flag WebFeatures::groupuiicleanup() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.groupUiiCleanup) + return _internal_groupuiicleanup(); +} +inline void WebFeatures::_internal_set_groupuiicleanup(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[1] |= 0x00000008u; + _impl_.groupuiicleanup_ = value; +} +inline void WebFeatures::set_groupuiicleanup(::proto::WebFeatures_Flag value) { + _internal_set_groupuiicleanup(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.groupUiiCleanup) +} + +// optional .proto.WebFeatures.Flag groupDogfoodingInternalOnly = 41; +inline bool WebFeatures::_internal_has_groupdogfoodinginternalonly() const { + bool value = (_impl_._has_bits_[1] & 0x00000010u) != 0; + return value; +} +inline bool WebFeatures::has_groupdogfoodinginternalonly() const { + return _internal_has_groupdogfoodinginternalonly(); +} +inline void WebFeatures::clear_groupdogfoodinginternalonly() { + _impl_.groupdogfoodinginternalonly_ = 0; + _impl_._has_bits_[1] &= ~0x00000010u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_groupdogfoodinginternalonly() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.groupdogfoodinginternalonly_); +} +inline ::proto::WebFeatures_Flag WebFeatures::groupdogfoodinginternalonly() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.groupDogfoodingInternalOnly) + return _internal_groupdogfoodinginternalonly(); +} +inline void WebFeatures::_internal_set_groupdogfoodinginternalonly(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[1] |= 0x00000010u; + _impl_.groupdogfoodinginternalonly_ = value; +} +inline void WebFeatures::set_groupdogfoodinginternalonly(::proto::WebFeatures_Flag value) { + _internal_set_groupdogfoodinginternalonly(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.groupDogfoodingInternalOnly) +} + +// optional .proto.WebFeatures.Flag settingsSync = 42; +inline bool WebFeatures::_internal_has_settingssync() const { + bool value = (_impl_._has_bits_[1] & 0x00000020u) != 0; + return value; +} +inline bool WebFeatures::has_settingssync() const { + return _internal_has_settingssync(); +} +inline void WebFeatures::clear_settingssync() { + _impl_.settingssync_ = 0; + _impl_._has_bits_[1] &= ~0x00000020u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_settingssync() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.settingssync_); +} +inline ::proto::WebFeatures_Flag WebFeatures::settingssync() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.settingsSync) + return _internal_settingssync(); +} +inline void WebFeatures::_internal_set_settingssync(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[1] |= 0x00000020u; + _impl_.settingssync_ = value; +} +inline void WebFeatures::set_settingssync(::proto::WebFeatures_Flag value) { + _internal_set_settingssync(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.settingsSync) +} + +// optional .proto.WebFeatures.Flag archiveV2 = 43; +inline bool WebFeatures::_internal_has_archivev2() const { + bool value = (_impl_._has_bits_[1] & 0x00000040u) != 0; + return value; +} +inline bool WebFeatures::has_archivev2() const { + return _internal_has_archivev2(); +} +inline void WebFeatures::clear_archivev2() { + _impl_.archivev2_ = 0; + _impl_._has_bits_[1] &= ~0x00000040u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_archivev2() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.archivev2_); +} +inline ::proto::WebFeatures_Flag WebFeatures::archivev2() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.archiveV2) + return _internal_archivev2(); +} +inline void WebFeatures::_internal_set_archivev2(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[1] |= 0x00000040u; + _impl_.archivev2_ = value; +} +inline void WebFeatures::set_archivev2(::proto::WebFeatures_Flag value) { + _internal_set_archivev2(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.archiveV2) +} + +// optional .proto.WebFeatures.Flag ephemeralAllowGroupMembers = 44; +inline bool WebFeatures::_internal_has_ephemeralallowgroupmembers() const { + bool value = (_impl_._has_bits_[1] & 0x00000080u) != 0; + return value; +} +inline bool WebFeatures::has_ephemeralallowgroupmembers() const { + return _internal_has_ephemeralallowgroupmembers(); +} +inline void WebFeatures::clear_ephemeralallowgroupmembers() { + _impl_.ephemeralallowgroupmembers_ = 0; + _impl_._has_bits_[1] &= ~0x00000080u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_ephemeralallowgroupmembers() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.ephemeralallowgroupmembers_); +} +inline ::proto::WebFeatures_Flag WebFeatures::ephemeralallowgroupmembers() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.ephemeralAllowGroupMembers) + return _internal_ephemeralallowgroupmembers(); +} +inline void WebFeatures::_internal_set_ephemeralallowgroupmembers(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[1] |= 0x00000080u; + _impl_.ephemeralallowgroupmembers_ = value; +} +inline void WebFeatures::set_ephemeralallowgroupmembers(::proto::WebFeatures_Flag value) { + _internal_set_ephemeralallowgroupmembers(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.ephemeralAllowGroupMembers) +} + +// optional .proto.WebFeatures.Flag ephemeral24HDuration = 45; +inline bool WebFeatures::_internal_has_ephemeral24hduration() const { + bool value = (_impl_._has_bits_[1] & 0x00000100u) != 0; + return value; +} +inline bool WebFeatures::has_ephemeral24hduration() const { + return _internal_has_ephemeral24hduration(); +} +inline void WebFeatures::clear_ephemeral24hduration() { + _impl_.ephemeral24hduration_ = 0; + _impl_._has_bits_[1] &= ~0x00000100u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_ephemeral24hduration() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.ephemeral24hduration_); +} +inline ::proto::WebFeatures_Flag WebFeatures::ephemeral24hduration() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.ephemeral24HDuration) + return _internal_ephemeral24hduration(); +} +inline void WebFeatures::_internal_set_ephemeral24hduration(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[1] |= 0x00000100u; + _impl_.ephemeral24hduration_ = value; +} +inline void WebFeatures::set_ephemeral24hduration(::proto::WebFeatures_Flag value) { + _internal_set_ephemeral24hduration(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.ephemeral24HDuration) +} + +// optional .proto.WebFeatures.Flag mdForceUpgrade = 46; +inline bool WebFeatures::_internal_has_mdforceupgrade() const { + bool value = (_impl_._has_bits_[1] & 0x00000200u) != 0; + return value; +} +inline bool WebFeatures::has_mdforceupgrade() const { + return _internal_has_mdforceupgrade(); +} +inline void WebFeatures::clear_mdforceupgrade() { + _impl_.mdforceupgrade_ = 0; + _impl_._has_bits_[1] &= ~0x00000200u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_mdforceupgrade() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.mdforceupgrade_); +} +inline ::proto::WebFeatures_Flag WebFeatures::mdforceupgrade() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.mdForceUpgrade) + return _internal_mdforceupgrade(); +} +inline void WebFeatures::_internal_set_mdforceupgrade(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[1] |= 0x00000200u; + _impl_.mdforceupgrade_ = value; +} +inline void WebFeatures::set_mdforceupgrade(::proto::WebFeatures_Flag value) { + _internal_set_mdforceupgrade(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.mdForceUpgrade) +} + +// optional .proto.WebFeatures.Flag disappearingMode = 47; +inline bool WebFeatures::_internal_has_disappearingmode() const { + bool value = (_impl_._has_bits_[1] & 0x00000400u) != 0; + return value; +} +inline bool WebFeatures::has_disappearingmode() const { + return _internal_has_disappearingmode(); +} +inline void WebFeatures::clear_disappearingmode() { + _impl_.disappearingmode_ = 0; + _impl_._has_bits_[1] &= ~0x00000400u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_disappearingmode() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.disappearingmode_); +} +inline ::proto::WebFeatures_Flag WebFeatures::disappearingmode() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.disappearingMode) + return _internal_disappearingmode(); +} +inline void WebFeatures::_internal_set_disappearingmode(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[1] |= 0x00000400u; + _impl_.disappearingmode_ = value; +} +inline void WebFeatures::set_disappearingmode(::proto::WebFeatures_Flag value) { + _internal_set_disappearingmode(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.disappearingMode) +} + +// optional .proto.WebFeatures.Flag externalMdOptInAvailable = 48; +inline bool WebFeatures::_internal_has_externalmdoptinavailable() const { + bool value = (_impl_._has_bits_[1] & 0x00000800u) != 0; + return value; +} +inline bool WebFeatures::has_externalmdoptinavailable() const { + return _internal_has_externalmdoptinavailable(); +} +inline void WebFeatures::clear_externalmdoptinavailable() { + _impl_.externalmdoptinavailable_ = 0; + _impl_._has_bits_[1] &= ~0x00000800u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_externalmdoptinavailable() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.externalmdoptinavailable_); +} +inline ::proto::WebFeatures_Flag WebFeatures::externalmdoptinavailable() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.externalMdOptInAvailable) + return _internal_externalmdoptinavailable(); +} +inline void WebFeatures::_internal_set_externalmdoptinavailable(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[1] |= 0x00000800u; + _impl_.externalmdoptinavailable_ = value; +} +inline void WebFeatures::set_externalmdoptinavailable(::proto::WebFeatures_Flag value) { + _internal_set_externalmdoptinavailable(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.externalMdOptInAvailable) +} + +// optional .proto.WebFeatures.Flag noDeleteMessageTimeLimit = 49; +inline bool WebFeatures::_internal_has_nodeletemessagetimelimit() const { + bool value = (_impl_._has_bits_[1] & 0x00001000u) != 0; + return value; +} +inline bool WebFeatures::has_nodeletemessagetimelimit() const { + return _internal_has_nodeletemessagetimelimit(); +} +inline void WebFeatures::clear_nodeletemessagetimelimit() { + _impl_.nodeletemessagetimelimit_ = 0; + _impl_._has_bits_[1] &= ~0x00001000u; +} +inline ::proto::WebFeatures_Flag WebFeatures::_internal_nodeletemessagetimelimit() const { + return static_cast< ::proto::WebFeatures_Flag >(_impl_.nodeletemessagetimelimit_); +} +inline ::proto::WebFeatures_Flag WebFeatures::nodeletemessagetimelimit() const { + // @@protoc_insertion_point(field_get:proto.WebFeatures.noDeleteMessageTimeLimit) + return _internal_nodeletemessagetimelimit(); +} +inline void WebFeatures::_internal_set_nodeletemessagetimelimit(::proto::WebFeatures_Flag value) { + assert(::proto::WebFeatures_Flag_IsValid(value)); + _impl_._has_bits_[1] |= 0x00001000u; + _impl_.nodeletemessagetimelimit_ = value; +} +inline void WebFeatures::set_nodeletemessagetimelimit(::proto::WebFeatures_Flag value) { + _internal_set_nodeletemessagetimelimit(value); + // @@protoc_insertion_point(field_set:proto.WebFeatures.noDeleteMessageTimeLimit) +} + +// ------------------------------------------------------------------- + +// WebMessageInfo + +// required .proto.MessageKey key = 1; +inline bool WebMessageInfo::_internal_has_key() const { + bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; + PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr); + return value; +} +inline bool WebMessageInfo::has_key() const { + return _internal_has_key(); +} +inline void WebMessageInfo::clear_key() { + if (_impl_.key_ != nullptr) _impl_.key_->Clear(); + _impl_._has_bits_[0] &= ~0x00000100u; +} +inline const ::proto::MessageKey& WebMessageInfo::_internal_key() const { + const ::proto::MessageKey* p = _impl_.key_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_MessageKey_default_instance_); +} +inline const ::proto::MessageKey& WebMessageInfo::key() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.key) + return _internal_key(); +} +inline void WebMessageInfo::unsafe_arena_set_allocated_key( + ::proto::MessageKey* key) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_); + } + _impl_.key_ = key; + if (key) { + _impl_._has_bits_[0] |= 0x00000100u; + } else { + _impl_._has_bits_[0] &= ~0x00000100u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.key) +} +inline ::proto::MessageKey* WebMessageInfo::release_key() { + _impl_._has_bits_[0] &= ~0x00000100u; + ::proto::MessageKey* temp = _impl_.key_; + _impl_.key_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::MessageKey* WebMessageInfo::unsafe_arena_release_key() { + // @@protoc_insertion_point(field_release:proto.WebMessageInfo.key) + _impl_._has_bits_[0] &= ~0x00000100u; + ::proto::MessageKey* temp = _impl_.key_; + _impl_.key_ = nullptr; + return temp; +} +inline ::proto::MessageKey* WebMessageInfo::_internal_mutable_key() { + _impl_._has_bits_[0] |= 0x00000100u; + if (_impl_.key_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation()); + _impl_.key_ = p; + } + return _impl_.key_; +} +inline ::proto::MessageKey* WebMessageInfo::mutable_key() { + ::proto::MessageKey* _msg = _internal_mutable_key(); + // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.key) + return _msg; +} +inline void WebMessageInfo::set_allocated_key(::proto::MessageKey* key) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.key_; + } + if (key) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key); + if (message_arena != submessage_arena) { + key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, key, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000100u; + } else { + _impl_._has_bits_[0] &= ~0x00000100u; + } + _impl_.key_ = key; + // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.key) +} + +// optional .proto.Message message = 2; +inline bool WebMessageInfo::_internal_has_message() const { + bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; + PROTOBUF_ASSUME(!value || _impl_.message_ != nullptr); + return value; +} +inline bool WebMessageInfo::has_message() const { + return _internal_has_message(); +} +inline void WebMessageInfo::clear_message() { + if (_impl_.message_ != nullptr) _impl_.message_->Clear(); + _impl_._has_bits_[0] &= ~0x00000200u; +} +inline const ::proto::Message& WebMessageInfo::_internal_message() const { + const ::proto::Message* p = _impl_.message_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_default_instance_); +} +inline const ::proto::Message& WebMessageInfo::message() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.message) + return _internal_message(); +} +inline void WebMessageInfo::unsafe_arena_set_allocated_message( + ::proto::Message* message) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.message_); + } + _impl_.message_ = message; + if (message) { + _impl_._has_bits_[0] |= 0x00000200u; + } else { + _impl_._has_bits_[0] &= ~0x00000200u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.message) +} +inline ::proto::Message* WebMessageInfo::release_message() { + _impl_._has_bits_[0] &= ~0x00000200u; + ::proto::Message* temp = _impl_.message_; + _impl_.message_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message* WebMessageInfo::unsafe_arena_release_message() { + // @@protoc_insertion_point(field_release:proto.WebMessageInfo.message) + _impl_._has_bits_[0] &= ~0x00000200u; + ::proto::Message* temp = _impl_.message_; + _impl_.message_ = nullptr; + return temp; +} +inline ::proto::Message* WebMessageInfo::_internal_mutable_message() { + _impl_._has_bits_[0] |= 0x00000200u; + if (_impl_.message_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message>(GetArenaForAllocation()); + _impl_.message_ = p; + } + return _impl_.message_; +} +inline ::proto::Message* WebMessageInfo::mutable_message() { + ::proto::Message* _msg = _internal_mutable_message(); + // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.message) + return _msg; +} +inline void WebMessageInfo::set_allocated_message(::proto::Message* message) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.message_; + } + if (message) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(message); + if (message_arena != submessage_arena) { + message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, message, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000200u; + } else { + _impl_._has_bits_[0] &= ~0x00000200u; + } + _impl_.message_ = message; + // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.message) +} + +// optional uint64 messageTimestamp = 3; +inline bool WebMessageInfo::_internal_has_messagetimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0; + return value; +} +inline bool WebMessageInfo::has_messagetimestamp() const { + return _internal_has_messagetimestamp(); +} +inline void WebMessageInfo::clear_messagetimestamp() { + _impl_.messagetimestamp_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00080000u; +} +inline uint64_t WebMessageInfo::_internal_messagetimestamp() const { + return _impl_.messagetimestamp_; +} +inline uint64_t WebMessageInfo::messagetimestamp() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.messageTimestamp) + return _internal_messagetimestamp(); +} +inline void WebMessageInfo::_internal_set_messagetimestamp(uint64_t value) { + _impl_._has_bits_[0] |= 0x00080000u; + _impl_.messagetimestamp_ = value; +} +inline void WebMessageInfo::set_messagetimestamp(uint64_t value) { + _internal_set_messagetimestamp(value); + // @@protoc_insertion_point(field_set:proto.WebMessageInfo.messageTimestamp) +} + +// optional .proto.WebMessageInfo.Status status = 4; +inline bool WebMessageInfo::_internal_has_status() const { + bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0; + return value; +} +inline bool WebMessageInfo::has_status() const { + return _internal_has_status(); +} +inline void WebMessageInfo::clear_status() { + _impl_.status_ = 0; + _impl_._has_bits_[0] &= ~0x00200000u; +} +inline ::proto::WebMessageInfo_Status WebMessageInfo::_internal_status() const { + return static_cast< ::proto::WebMessageInfo_Status >(_impl_.status_); +} +inline ::proto::WebMessageInfo_Status WebMessageInfo::status() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.status) + return _internal_status(); +} +inline void WebMessageInfo::_internal_set_status(::proto::WebMessageInfo_Status value) { + assert(::proto::WebMessageInfo_Status_IsValid(value)); + _impl_._has_bits_[0] |= 0x00200000u; + _impl_.status_ = value; +} +inline void WebMessageInfo::set_status(::proto::WebMessageInfo_Status value) { + _internal_set_status(value); + // @@protoc_insertion_point(field_set:proto.WebMessageInfo.status) +} + +// optional string participant = 5; +inline bool WebMessageInfo::_internal_has_participant() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool WebMessageInfo::has_participant() const { + return _internal_has_participant(); +} +inline void WebMessageInfo::clear_participant() { + _impl_.participant_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline const std::string& WebMessageInfo::participant() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.participant) + return _internal_participant(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void WebMessageInfo::set_participant(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.participant_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.WebMessageInfo.participant) +} +inline std::string* WebMessageInfo::mutable_participant() { + std::string* _s = _internal_mutable_participant(); + // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.participant) + return _s; +} +inline const std::string& WebMessageInfo::_internal_participant() const { + return _impl_.participant_.Get(); +} +inline void WebMessageInfo::_internal_set_participant(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.participant_.Set(value, GetArenaForAllocation()); +} +inline std::string* WebMessageInfo::_internal_mutable_participant() { + _impl_._has_bits_[0] |= 0x00000001u; + return _impl_.participant_.Mutable(GetArenaForAllocation()); +} +inline std::string* WebMessageInfo::release_participant() { + // @@protoc_insertion_point(field_release:proto.WebMessageInfo.participant) + if (!_internal_has_participant()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000001u; + auto* p = _impl_.participant_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.participant_.IsDefault()) { + _impl_.participant_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void WebMessageInfo::set_allocated_participant(std::string* participant) { + if (participant != nullptr) { + _impl_._has_bits_[0] |= 0x00000001u; + } else { + _impl_._has_bits_[0] &= ~0x00000001u; + } + _impl_.participant_.SetAllocated(participant, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.participant_.IsDefault()) { + _impl_.participant_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.participant) +} + +// optional uint64 messageC2STimestamp = 6; +inline bool WebMessageInfo::_internal_has_messagec2stimestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0; + return value; +} +inline bool WebMessageInfo::has_messagec2stimestamp() const { + return _internal_has_messagec2stimestamp(); +} +inline void WebMessageInfo::clear_messagec2stimestamp() { + _impl_.messagec2stimestamp_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00100000u; +} +inline uint64_t WebMessageInfo::_internal_messagec2stimestamp() const { + return _impl_.messagec2stimestamp_; +} +inline uint64_t WebMessageInfo::messagec2stimestamp() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.messageC2STimestamp) + return _internal_messagec2stimestamp(); +} +inline void WebMessageInfo::_internal_set_messagec2stimestamp(uint64_t value) { + _impl_._has_bits_[0] |= 0x00100000u; + _impl_.messagec2stimestamp_ = value; +} +inline void WebMessageInfo::set_messagec2stimestamp(uint64_t value) { + _internal_set_messagec2stimestamp(value); + // @@protoc_insertion_point(field_set:proto.WebMessageInfo.messageC2STimestamp) +} + +// optional bool ignore = 16; +inline bool WebMessageInfo::_internal_has_ignore() const { + bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0; + return value; +} +inline bool WebMessageInfo::has_ignore() const { + return _internal_has_ignore(); +} +inline void WebMessageInfo::clear_ignore() { + _impl_.ignore_ = false; + _impl_._has_bits_[0] &= ~0x00400000u; +} +inline bool WebMessageInfo::_internal_ignore() const { + return _impl_.ignore_; +} +inline bool WebMessageInfo::ignore() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.ignore) + return _internal_ignore(); +} +inline void WebMessageInfo::_internal_set_ignore(bool value) { + _impl_._has_bits_[0] |= 0x00400000u; + _impl_.ignore_ = value; +} +inline void WebMessageInfo::set_ignore(bool value) { + _internal_set_ignore(value); + // @@protoc_insertion_point(field_set:proto.WebMessageInfo.ignore) +} + +// optional bool starred = 17; +inline bool WebMessageInfo::_internal_has_starred() const { + bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0; + return value; +} +inline bool WebMessageInfo::has_starred() const { + return _internal_has_starred(); +} +inline void WebMessageInfo::clear_starred() { + _impl_.starred_ = false; + _impl_._has_bits_[0] &= ~0x00800000u; +} +inline bool WebMessageInfo::_internal_starred() const { + return _impl_.starred_; +} +inline bool WebMessageInfo::starred() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.starred) + return _internal_starred(); +} +inline void WebMessageInfo::_internal_set_starred(bool value) { + _impl_._has_bits_[0] |= 0x00800000u; + _impl_.starred_ = value; +} +inline void WebMessageInfo::set_starred(bool value) { + _internal_set_starred(value); + // @@protoc_insertion_point(field_set:proto.WebMessageInfo.starred) +} + +// optional bool broadcast = 18; +inline bool WebMessageInfo::_internal_has_broadcast() const { + bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0; + return value; +} +inline bool WebMessageInfo::has_broadcast() const { + return _internal_has_broadcast(); +} +inline void WebMessageInfo::clear_broadcast() { + _impl_.broadcast_ = false; + _impl_._has_bits_[0] &= ~0x01000000u; +} +inline bool WebMessageInfo::_internal_broadcast() const { + return _impl_.broadcast_; +} +inline bool WebMessageInfo::broadcast() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.broadcast) + return _internal_broadcast(); +} +inline void WebMessageInfo::_internal_set_broadcast(bool value) { + _impl_._has_bits_[0] |= 0x01000000u; + _impl_.broadcast_ = value; +} +inline void WebMessageInfo::set_broadcast(bool value) { + _internal_set_broadcast(value); + // @@protoc_insertion_point(field_set:proto.WebMessageInfo.broadcast) +} + +// optional string pushName = 19; +inline bool WebMessageInfo::_internal_has_pushname() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool WebMessageInfo::has_pushname() const { + return _internal_has_pushname(); +} +inline void WebMessageInfo::clear_pushname() { + _impl_.pushname_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline const std::string& WebMessageInfo::pushname() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.pushName) + return _internal_pushname(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void WebMessageInfo::set_pushname(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.pushname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.WebMessageInfo.pushName) +} +inline std::string* WebMessageInfo::mutable_pushname() { + std::string* _s = _internal_mutable_pushname(); + // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.pushName) + return _s; +} +inline const std::string& WebMessageInfo::_internal_pushname() const { + return _impl_.pushname_.Get(); +} +inline void WebMessageInfo::_internal_set_pushname(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.pushname_.Set(value, GetArenaForAllocation()); +} +inline std::string* WebMessageInfo::_internal_mutable_pushname() { + _impl_._has_bits_[0] |= 0x00000002u; + return _impl_.pushname_.Mutable(GetArenaForAllocation()); +} +inline std::string* WebMessageInfo::release_pushname() { + // @@protoc_insertion_point(field_release:proto.WebMessageInfo.pushName) + if (!_internal_has_pushname()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000002u; + auto* p = _impl_.pushname_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.pushname_.IsDefault()) { + _impl_.pushname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void WebMessageInfo::set_allocated_pushname(std::string* pushname) { + if (pushname != nullptr) { + _impl_._has_bits_[0] |= 0x00000002u; + } else { + _impl_._has_bits_[0] &= ~0x00000002u; + } + _impl_.pushname_.SetAllocated(pushname, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.pushname_.IsDefault()) { + _impl_.pushname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.pushName) +} + +// optional bytes mediaCiphertextSha256 = 20; +inline bool WebMessageInfo::_internal_has_mediaciphertextsha256() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool WebMessageInfo::has_mediaciphertextsha256() const { + return _internal_has_mediaciphertextsha256(); +} +inline void WebMessageInfo::clear_mediaciphertextsha256() { + _impl_.mediaciphertextsha256_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline const std::string& WebMessageInfo::mediaciphertextsha256() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.mediaCiphertextSha256) + return _internal_mediaciphertextsha256(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void WebMessageInfo::set_mediaciphertextsha256(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.mediaciphertextsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.WebMessageInfo.mediaCiphertextSha256) +} +inline std::string* WebMessageInfo::mutable_mediaciphertextsha256() { + std::string* _s = _internal_mutable_mediaciphertextsha256(); + // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.mediaCiphertextSha256) + return _s; +} +inline const std::string& WebMessageInfo::_internal_mediaciphertextsha256() const { + return _impl_.mediaciphertextsha256_.Get(); +} +inline void WebMessageInfo::_internal_set_mediaciphertextsha256(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.mediaciphertextsha256_.Set(value, GetArenaForAllocation()); +} +inline std::string* WebMessageInfo::_internal_mutable_mediaciphertextsha256() { + _impl_._has_bits_[0] |= 0x00000004u; + return _impl_.mediaciphertextsha256_.Mutable(GetArenaForAllocation()); +} +inline std::string* WebMessageInfo::release_mediaciphertextsha256() { + // @@protoc_insertion_point(field_release:proto.WebMessageInfo.mediaCiphertextSha256) + if (!_internal_has_mediaciphertextsha256()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000004u; + auto* p = _impl_.mediaciphertextsha256_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mediaciphertextsha256_.IsDefault()) { + _impl_.mediaciphertextsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void WebMessageInfo::set_allocated_mediaciphertextsha256(std::string* mediaciphertextsha256) { + if (mediaciphertextsha256 != nullptr) { + _impl_._has_bits_[0] |= 0x00000004u; + } else { + _impl_._has_bits_[0] &= ~0x00000004u; + } + _impl_.mediaciphertextsha256_.SetAllocated(mediaciphertextsha256, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.mediaciphertextsha256_.IsDefault()) { + _impl_.mediaciphertextsha256_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.mediaCiphertextSha256) +} + +// optional bool multicast = 21; +inline bool WebMessageInfo::_internal_has_multicast() const { + bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0; + return value; +} +inline bool WebMessageInfo::has_multicast() const { + return _internal_has_multicast(); +} +inline void WebMessageInfo::clear_multicast() { + _impl_.multicast_ = false; + _impl_._has_bits_[0] &= ~0x02000000u; +} +inline bool WebMessageInfo::_internal_multicast() const { + return _impl_.multicast_; +} +inline bool WebMessageInfo::multicast() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.multicast) + return _internal_multicast(); +} +inline void WebMessageInfo::_internal_set_multicast(bool value) { + _impl_._has_bits_[0] |= 0x02000000u; + _impl_.multicast_ = value; +} +inline void WebMessageInfo::set_multicast(bool value) { + _internal_set_multicast(value); + // @@protoc_insertion_point(field_set:proto.WebMessageInfo.multicast) +} + +// optional bool urlText = 22; +inline bool WebMessageInfo::_internal_has_urltext() const { + bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0; + return value; +} +inline bool WebMessageInfo::has_urltext() const { + return _internal_has_urltext(); +} +inline void WebMessageInfo::clear_urltext() { + _impl_.urltext_ = false; + _impl_._has_bits_[0] &= ~0x08000000u; +} +inline bool WebMessageInfo::_internal_urltext() const { + return _impl_.urltext_; +} +inline bool WebMessageInfo::urltext() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.urlText) + return _internal_urltext(); +} +inline void WebMessageInfo::_internal_set_urltext(bool value) { + _impl_._has_bits_[0] |= 0x08000000u; + _impl_.urltext_ = value; +} +inline void WebMessageInfo::set_urltext(bool value) { + _internal_set_urltext(value); + // @@protoc_insertion_point(field_set:proto.WebMessageInfo.urlText) +} + +// optional bool urlNumber = 23; +inline bool WebMessageInfo::_internal_has_urlnumber() const { + bool value = (_impl_._has_bits_[0] & 0x10000000u) != 0; + return value; +} +inline bool WebMessageInfo::has_urlnumber() const { + return _internal_has_urlnumber(); +} +inline void WebMessageInfo::clear_urlnumber() { + _impl_.urlnumber_ = false; + _impl_._has_bits_[0] &= ~0x10000000u; +} +inline bool WebMessageInfo::_internal_urlnumber() const { + return _impl_.urlnumber_; +} +inline bool WebMessageInfo::urlnumber() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.urlNumber) + return _internal_urlnumber(); +} +inline void WebMessageInfo::_internal_set_urlnumber(bool value) { + _impl_._has_bits_[0] |= 0x10000000u; + _impl_.urlnumber_ = value; +} +inline void WebMessageInfo::set_urlnumber(bool value) { + _internal_set_urlnumber(value); + // @@protoc_insertion_point(field_set:proto.WebMessageInfo.urlNumber) +} + +// optional .proto.WebMessageInfo.StubType messageStubType = 24; +inline bool WebMessageInfo::_internal_has_messagestubtype() const { + bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0; + return value; +} +inline bool WebMessageInfo::has_messagestubtype() const { + return _internal_has_messagestubtype(); +} +inline void WebMessageInfo::clear_messagestubtype() { + _impl_.messagestubtype_ = 0; + _impl_._has_bits_[0] &= ~0x04000000u; +} +inline ::proto::WebMessageInfo_StubType WebMessageInfo::_internal_messagestubtype() const { + return static_cast< ::proto::WebMessageInfo_StubType >(_impl_.messagestubtype_); +} +inline ::proto::WebMessageInfo_StubType WebMessageInfo::messagestubtype() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.messageStubType) + return _internal_messagestubtype(); +} +inline void WebMessageInfo::_internal_set_messagestubtype(::proto::WebMessageInfo_StubType value) { + assert(::proto::WebMessageInfo_StubType_IsValid(value)); + _impl_._has_bits_[0] |= 0x04000000u; + _impl_.messagestubtype_ = value; +} +inline void WebMessageInfo::set_messagestubtype(::proto::WebMessageInfo_StubType value) { + _internal_set_messagestubtype(value); + // @@protoc_insertion_point(field_set:proto.WebMessageInfo.messageStubType) +} + +// optional bool clearMedia = 25; +inline bool WebMessageInfo::_internal_has_clearmedia() const { + bool value = (_impl_._has_bits_[0] & 0x20000000u) != 0; + return value; +} +inline bool WebMessageInfo::has_clearmedia() const { + return _internal_has_clearmedia(); +} +inline void WebMessageInfo::clear_clearmedia() { + _impl_.clearmedia_ = false; + _impl_._has_bits_[0] &= ~0x20000000u; +} +inline bool WebMessageInfo::_internal_clearmedia() const { + return _impl_.clearmedia_; +} +inline bool WebMessageInfo::clearmedia() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.clearMedia) + return _internal_clearmedia(); +} +inline void WebMessageInfo::_internal_set_clearmedia(bool value) { + _impl_._has_bits_[0] |= 0x20000000u; + _impl_.clearmedia_ = value; +} +inline void WebMessageInfo::set_clearmedia(bool value) { + _internal_set_clearmedia(value); + // @@protoc_insertion_point(field_set:proto.WebMessageInfo.clearMedia) +} + +// repeated string messageStubParameters = 26; +inline int WebMessageInfo::_internal_messagestubparameters_size() const { + return _impl_.messagestubparameters_.size(); +} +inline int WebMessageInfo::messagestubparameters_size() const { + return _internal_messagestubparameters_size(); +} +inline void WebMessageInfo::clear_messagestubparameters() { + _impl_.messagestubparameters_.Clear(); +} +inline std::string* WebMessageInfo::add_messagestubparameters() { + std::string* _s = _internal_add_messagestubparameters(); + // @@protoc_insertion_point(field_add_mutable:proto.WebMessageInfo.messageStubParameters) + return _s; +} +inline const std::string& WebMessageInfo::_internal_messagestubparameters(int index) const { + return _impl_.messagestubparameters_.Get(index); +} +inline const std::string& WebMessageInfo::messagestubparameters(int index) const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.messageStubParameters) + return _internal_messagestubparameters(index); +} +inline std::string* WebMessageInfo::mutable_messagestubparameters(int index) { + // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.messageStubParameters) + return _impl_.messagestubparameters_.Mutable(index); +} +inline void WebMessageInfo::set_messagestubparameters(int index, const std::string& value) { + _impl_.messagestubparameters_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:proto.WebMessageInfo.messageStubParameters) +} +inline void WebMessageInfo::set_messagestubparameters(int index, std::string&& value) { + _impl_.messagestubparameters_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:proto.WebMessageInfo.messageStubParameters) +} +inline void WebMessageInfo::set_messagestubparameters(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + _impl_.messagestubparameters_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:proto.WebMessageInfo.messageStubParameters) +} +inline void WebMessageInfo::set_messagestubparameters(int index, const char* value, size_t size) { + _impl_.messagestubparameters_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:proto.WebMessageInfo.messageStubParameters) +} +inline std::string* WebMessageInfo::_internal_add_messagestubparameters() { + return _impl_.messagestubparameters_.Add(); +} +inline void WebMessageInfo::add_messagestubparameters(const std::string& value) { + _impl_.messagestubparameters_.Add()->assign(value); + // @@protoc_insertion_point(field_add:proto.WebMessageInfo.messageStubParameters) +} +inline void WebMessageInfo::add_messagestubparameters(std::string&& value) { + _impl_.messagestubparameters_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:proto.WebMessageInfo.messageStubParameters) +} +inline void WebMessageInfo::add_messagestubparameters(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _impl_.messagestubparameters_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:proto.WebMessageInfo.messageStubParameters) +} +inline void WebMessageInfo::add_messagestubparameters(const char* value, size_t size) { + _impl_.messagestubparameters_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:proto.WebMessageInfo.messageStubParameters) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +WebMessageInfo::messagestubparameters() const { + // @@protoc_insertion_point(field_list:proto.WebMessageInfo.messageStubParameters) + return _impl_.messagestubparameters_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +WebMessageInfo::mutable_messagestubparameters() { + // @@protoc_insertion_point(field_mutable_list:proto.WebMessageInfo.messageStubParameters) + return &_impl_.messagestubparameters_; +} + +// optional uint32 duration = 27; +inline bool WebMessageInfo::_internal_has_duration() const { + bool value = (_impl_._has_bits_[0] & 0x80000000u) != 0; + return value; +} +inline bool WebMessageInfo::has_duration() const { + return _internal_has_duration(); +} +inline void WebMessageInfo::clear_duration() { + _impl_.duration_ = 0u; + _impl_._has_bits_[0] &= ~0x80000000u; +} +inline uint32_t WebMessageInfo::_internal_duration() const { + return _impl_.duration_; +} +inline uint32_t WebMessageInfo::duration() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.duration) + return _internal_duration(); +} +inline void WebMessageInfo::_internal_set_duration(uint32_t value) { + _impl_._has_bits_[0] |= 0x80000000u; + _impl_.duration_ = value; +} +inline void WebMessageInfo::set_duration(uint32_t value) { + _internal_set_duration(value); + // @@protoc_insertion_point(field_set:proto.WebMessageInfo.duration) +} + +// repeated string labels = 28; +inline int WebMessageInfo::_internal_labels_size() const { + return _impl_.labels_.size(); +} +inline int WebMessageInfo::labels_size() const { + return _internal_labels_size(); +} +inline void WebMessageInfo::clear_labels() { + _impl_.labels_.Clear(); +} +inline std::string* WebMessageInfo::add_labels() { + std::string* _s = _internal_add_labels(); + // @@protoc_insertion_point(field_add_mutable:proto.WebMessageInfo.labels) + return _s; +} +inline const std::string& WebMessageInfo::_internal_labels(int index) const { + return _impl_.labels_.Get(index); +} +inline const std::string& WebMessageInfo::labels(int index) const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.labels) + return _internal_labels(index); +} +inline std::string* WebMessageInfo::mutable_labels(int index) { + // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.labels) + return _impl_.labels_.Mutable(index); +} +inline void WebMessageInfo::set_labels(int index, const std::string& value) { + _impl_.labels_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:proto.WebMessageInfo.labels) +} +inline void WebMessageInfo::set_labels(int index, std::string&& value) { + _impl_.labels_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:proto.WebMessageInfo.labels) +} +inline void WebMessageInfo::set_labels(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + _impl_.labels_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:proto.WebMessageInfo.labels) +} +inline void WebMessageInfo::set_labels(int index, const char* value, size_t size) { + _impl_.labels_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:proto.WebMessageInfo.labels) +} +inline std::string* WebMessageInfo::_internal_add_labels() { + return _impl_.labels_.Add(); +} +inline void WebMessageInfo::add_labels(const std::string& value) { + _impl_.labels_.Add()->assign(value); + // @@protoc_insertion_point(field_add:proto.WebMessageInfo.labels) +} +inline void WebMessageInfo::add_labels(std::string&& value) { + _impl_.labels_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:proto.WebMessageInfo.labels) +} +inline void WebMessageInfo::add_labels(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _impl_.labels_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:proto.WebMessageInfo.labels) +} +inline void WebMessageInfo::add_labels(const char* value, size_t size) { + _impl_.labels_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:proto.WebMessageInfo.labels) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +WebMessageInfo::labels() const { + // @@protoc_insertion_point(field_list:proto.WebMessageInfo.labels) + return _impl_.labels_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +WebMessageInfo::mutable_labels() { + // @@protoc_insertion_point(field_mutable_list:proto.WebMessageInfo.labels) + return &_impl_.labels_; +} + +// optional .proto.PaymentInfo paymentInfo = 29; +inline bool WebMessageInfo::_internal_has_paymentinfo() const { + bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; + PROTOBUF_ASSUME(!value || _impl_.paymentinfo_ != nullptr); + return value; +} +inline bool WebMessageInfo::has_paymentinfo() const { + return _internal_has_paymentinfo(); +} +inline void WebMessageInfo::clear_paymentinfo() { + if (_impl_.paymentinfo_ != nullptr) _impl_.paymentinfo_->Clear(); + _impl_._has_bits_[0] &= ~0x00000400u; +} +inline const ::proto::PaymentInfo& WebMessageInfo::_internal_paymentinfo() const { + const ::proto::PaymentInfo* p = _impl_.paymentinfo_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_PaymentInfo_default_instance_); +} +inline const ::proto::PaymentInfo& WebMessageInfo::paymentinfo() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.paymentInfo) + return _internal_paymentinfo(); +} +inline void WebMessageInfo::unsafe_arena_set_allocated_paymentinfo( + ::proto::PaymentInfo* paymentinfo) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.paymentinfo_); + } + _impl_.paymentinfo_ = paymentinfo; + if (paymentinfo) { + _impl_._has_bits_[0] |= 0x00000400u; + } else { + _impl_._has_bits_[0] &= ~0x00000400u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.paymentInfo) +} +inline ::proto::PaymentInfo* WebMessageInfo::release_paymentinfo() { + _impl_._has_bits_[0] &= ~0x00000400u; + ::proto::PaymentInfo* temp = _impl_.paymentinfo_; + _impl_.paymentinfo_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::PaymentInfo* WebMessageInfo::unsafe_arena_release_paymentinfo() { + // @@protoc_insertion_point(field_release:proto.WebMessageInfo.paymentInfo) + _impl_._has_bits_[0] &= ~0x00000400u; + ::proto::PaymentInfo* temp = _impl_.paymentinfo_; + _impl_.paymentinfo_ = nullptr; + return temp; +} +inline ::proto::PaymentInfo* WebMessageInfo::_internal_mutable_paymentinfo() { + _impl_._has_bits_[0] |= 0x00000400u; + if (_impl_.paymentinfo_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::PaymentInfo>(GetArenaForAllocation()); + _impl_.paymentinfo_ = p; + } + return _impl_.paymentinfo_; +} +inline ::proto::PaymentInfo* WebMessageInfo::mutable_paymentinfo() { + ::proto::PaymentInfo* _msg = _internal_mutable_paymentinfo(); + // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.paymentInfo) + return _msg; +} +inline void WebMessageInfo::set_allocated_paymentinfo(::proto::PaymentInfo* paymentinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.paymentinfo_; + } + if (paymentinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(paymentinfo); + if (message_arena != submessage_arena) { + paymentinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, paymentinfo, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000400u; + } else { + _impl_._has_bits_[0] &= ~0x00000400u; + } + _impl_.paymentinfo_ = paymentinfo; + // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.paymentInfo) +} + +// optional .proto.Message.LiveLocationMessage finalLiveLocation = 30; +inline bool WebMessageInfo::_internal_has_finallivelocation() const { + bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; + PROTOBUF_ASSUME(!value || _impl_.finallivelocation_ != nullptr); + return value; +} +inline bool WebMessageInfo::has_finallivelocation() const { + return _internal_has_finallivelocation(); +} +inline void WebMessageInfo::clear_finallivelocation() { + if (_impl_.finallivelocation_ != nullptr) _impl_.finallivelocation_->Clear(); + _impl_._has_bits_[0] &= ~0x00000800u; +} +inline const ::proto::Message_LiveLocationMessage& WebMessageInfo::_internal_finallivelocation() const { + const ::proto::Message_LiveLocationMessage* p = _impl_.finallivelocation_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_Message_LiveLocationMessage_default_instance_); +} +inline const ::proto::Message_LiveLocationMessage& WebMessageInfo::finallivelocation() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.finalLiveLocation) + return _internal_finallivelocation(); +} +inline void WebMessageInfo::unsafe_arena_set_allocated_finallivelocation( + ::proto::Message_LiveLocationMessage* finallivelocation) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.finallivelocation_); + } + _impl_.finallivelocation_ = finallivelocation; + if (finallivelocation) { + _impl_._has_bits_[0] |= 0x00000800u; + } else { + _impl_._has_bits_[0] &= ~0x00000800u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.finalLiveLocation) +} +inline ::proto::Message_LiveLocationMessage* WebMessageInfo::release_finallivelocation() { + _impl_._has_bits_[0] &= ~0x00000800u; + ::proto::Message_LiveLocationMessage* temp = _impl_.finallivelocation_; + _impl_.finallivelocation_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::Message_LiveLocationMessage* WebMessageInfo::unsafe_arena_release_finallivelocation() { + // @@protoc_insertion_point(field_release:proto.WebMessageInfo.finalLiveLocation) + _impl_._has_bits_[0] &= ~0x00000800u; + ::proto::Message_LiveLocationMessage* temp = _impl_.finallivelocation_; + _impl_.finallivelocation_ = nullptr; + return temp; +} +inline ::proto::Message_LiveLocationMessage* WebMessageInfo::_internal_mutable_finallivelocation() { + _impl_._has_bits_[0] |= 0x00000800u; + if (_impl_.finallivelocation_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::Message_LiveLocationMessage>(GetArenaForAllocation()); + _impl_.finallivelocation_ = p; + } + return _impl_.finallivelocation_; +} +inline ::proto::Message_LiveLocationMessage* WebMessageInfo::mutable_finallivelocation() { + ::proto::Message_LiveLocationMessage* _msg = _internal_mutable_finallivelocation(); + // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.finalLiveLocation) + return _msg; +} +inline void WebMessageInfo::set_allocated_finallivelocation(::proto::Message_LiveLocationMessage* finallivelocation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.finallivelocation_; + } + if (finallivelocation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(finallivelocation); + if (message_arena != submessage_arena) { + finallivelocation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, finallivelocation, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00000800u; + } else { + _impl_._has_bits_[0] &= ~0x00000800u; + } + _impl_.finallivelocation_ = finallivelocation; + // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.finalLiveLocation) +} + +// optional .proto.PaymentInfo quotedPaymentInfo = 31; +inline bool WebMessageInfo::_internal_has_quotedpaymentinfo() const { + bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.quotedpaymentinfo_ != nullptr); + return value; +} +inline bool WebMessageInfo::has_quotedpaymentinfo() const { + return _internal_has_quotedpaymentinfo(); +} +inline void WebMessageInfo::clear_quotedpaymentinfo() { + if (_impl_.quotedpaymentinfo_ != nullptr) _impl_.quotedpaymentinfo_->Clear(); + _impl_._has_bits_[0] &= ~0x00001000u; +} +inline const ::proto::PaymentInfo& WebMessageInfo::_internal_quotedpaymentinfo() const { + const ::proto::PaymentInfo* p = _impl_.quotedpaymentinfo_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_PaymentInfo_default_instance_); +} +inline const ::proto::PaymentInfo& WebMessageInfo::quotedpaymentinfo() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.quotedPaymentInfo) + return _internal_quotedpaymentinfo(); +} +inline void WebMessageInfo::unsafe_arena_set_allocated_quotedpaymentinfo( + ::proto::PaymentInfo* quotedpaymentinfo) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quotedpaymentinfo_); + } + _impl_.quotedpaymentinfo_ = quotedpaymentinfo; + if (quotedpaymentinfo) { + _impl_._has_bits_[0] |= 0x00001000u; + } else { + _impl_._has_bits_[0] &= ~0x00001000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.quotedPaymentInfo) +} +inline ::proto::PaymentInfo* WebMessageInfo::release_quotedpaymentinfo() { + _impl_._has_bits_[0] &= ~0x00001000u; + ::proto::PaymentInfo* temp = _impl_.quotedpaymentinfo_; + _impl_.quotedpaymentinfo_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::PaymentInfo* WebMessageInfo::unsafe_arena_release_quotedpaymentinfo() { + // @@protoc_insertion_point(field_release:proto.WebMessageInfo.quotedPaymentInfo) + _impl_._has_bits_[0] &= ~0x00001000u; + ::proto::PaymentInfo* temp = _impl_.quotedpaymentinfo_; + _impl_.quotedpaymentinfo_ = nullptr; + return temp; +} +inline ::proto::PaymentInfo* WebMessageInfo::_internal_mutable_quotedpaymentinfo() { + _impl_._has_bits_[0] |= 0x00001000u; + if (_impl_.quotedpaymentinfo_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::PaymentInfo>(GetArenaForAllocation()); + _impl_.quotedpaymentinfo_ = p; + } + return _impl_.quotedpaymentinfo_; +} +inline ::proto::PaymentInfo* WebMessageInfo::mutable_quotedpaymentinfo() { + ::proto::PaymentInfo* _msg = _internal_mutable_quotedpaymentinfo(); + // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.quotedPaymentInfo) + return _msg; +} +inline void WebMessageInfo::set_allocated_quotedpaymentinfo(::proto::PaymentInfo* quotedpaymentinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.quotedpaymentinfo_; + } + if (quotedpaymentinfo) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quotedpaymentinfo); + if (message_arena != submessage_arena) { + quotedpaymentinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, quotedpaymentinfo, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00001000u; + } else { + _impl_._has_bits_[0] &= ~0x00001000u; + } + _impl_.quotedpaymentinfo_ = quotedpaymentinfo; + // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.quotedPaymentInfo) +} + +// optional uint64 ephemeralStartTimestamp = 32; +inline bool WebMessageInfo::_internal_has_ephemeralstarttimestamp() const { + bool value = (_impl_._has_bits_[1] & 0x00000002u) != 0; + return value; +} +inline bool WebMessageInfo::has_ephemeralstarttimestamp() const { + return _internal_has_ephemeralstarttimestamp(); +} +inline void WebMessageInfo::clear_ephemeralstarttimestamp() { + _impl_.ephemeralstarttimestamp_ = uint64_t{0u}; + _impl_._has_bits_[1] &= ~0x00000002u; +} +inline uint64_t WebMessageInfo::_internal_ephemeralstarttimestamp() const { + return _impl_.ephemeralstarttimestamp_; +} +inline uint64_t WebMessageInfo::ephemeralstarttimestamp() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.ephemeralStartTimestamp) + return _internal_ephemeralstarttimestamp(); +} +inline void WebMessageInfo::_internal_set_ephemeralstarttimestamp(uint64_t value) { + _impl_._has_bits_[1] |= 0x00000002u; + _impl_.ephemeralstarttimestamp_ = value; +} +inline void WebMessageInfo::set_ephemeralstarttimestamp(uint64_t value) { + _internal_set_ephemeralstarttimestamp(value); + // @@protoc_insertion_point(field_set:proto.WebMessageInfo.ephemeralStartTimestamp) +} + +// optional uint32 ephemeralDuration = 33; +inline bool WebMessageInfo::_internal_has_ephemeralduration() const { + bool value = (_impl_._has_bits_[1] & 0x00000001u) != 0; + return value; +} +inline bool WebMessageInfo::has_ephemeralduration() const { + return _internal_has_ephemeralduration(); +} +inline void WebMessageInfo::clear_ephemeralduration() { + _impl_.ephemeralduration_ = 0u; + _impl_._has_bits_[1] &= ~0x00000001u; +} +inline uint32_t WebMessageInfo::_internal_ephemeralduration() const { + return _impl_.ephemeralduration_; +} +inline uint32_t WebMessageInfo::ephemeralduration() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.ephemeralDuration) + return _internal_ephemeralduration(); +} +inline void WebMessageInfo::_internal_set_ephemeralduration(uint32_t value) { + _impl_._has_bits_[1] |= 0x00000001u; + _impl_.ephemeralduration_ = value; +} +inline void WebMessageInfo::set_ephemeralduration(uint32_t value) { + _internal_set_ephemeralduration(value); + // @@protoc_insertion_point(field_set:proto.WebMessageInfo.ephemeralDuration) +} + +// optional bool ephemeralOffToOn = 34; +inline bool WebMessageInfo::_internal_has_ephemeralofftoon() const { + bool value = (_impl_._has_bits_[0] & 0x40000000u) != 0; + return value; +} +inline bool WebMessageInfo::has_ephemeralofftoon() const { + return _internal_has_ephemeralofftoon(); +} +inline void WebMessageInfo::clear_ephemeralofftoon() { + _impl_.ephemeralofftoon_ = false; + _impl_._has_bits_[0] &= ~0x40000000u; +} +inline bool WebMessageInfo::_internal_ephemeralofftoon() const { + return _impl_.ephemeralofftoon_; +} +inline bool WebMessageInfo::ephemeralofftoon() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.ephemeralOffToOn) + return _internal_ephemeralofftoon(); +} +inline void WebMessageInfo::_internal_set_ephemeralofftoon(bool value) { + _impl_._has_bits_[0] |= 0x40000000u; + _impl_.ephemeralofftoon_ = value; +} +inline void WebMessageInfo::set_ephemeralofftoon(bool value) { + _internal_set_ephemeralofftoon(value); + // @@protoc_insertion_point(field_set:proto.WebMessageInfo.ephemeralOffToOn) +} + +// optional bool ephemeralOutOfSync = 35; +inline bool WebMessageInfo::_internal_has_ephemeraloutofsync() const { + bool value = (_impl_._has_bits_[1] & 0x00000008u) != 0; + return value; +} +inline bool WebMessageInfo::has_ephemeraloutofsync() const { + return _internal_has_ephemeraloutofsync(); +} +inline void WebMessageInfo::clear_ephemeraloutofsync() { + _impl_.ephemeraloutofsync_ = false; + _impl_._has_bits_[1] &= ~0x00000008u; +} +inline bool WebMessageInfo::_internal_ephemeraloutofsync() const { + return _impl_.ephemeraloutofsync_; +} +inline bool WebMessageInfo::ephemeraloutofsync() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.ephemeralOutOfSync) + return _internal_ephemeraloutofsync(); +} +inline void WebMessageInfo::_internal_set_ephemeraloutofsync(bool value) { + _impl_._has_bits_[1] |= 0x00000008u; + _impl_.ephemeraloutofsync_ = value; +} +inline void WebMessageInfo::set_ephemeraloutofsync(bool value) { + _internal_set_ephemeraloutofsync(value); + // @@protoc_insertion_point(field_set:proto.WebMessageInfo.ephemeralOutOfSync) +} + +// optional .proto.WebMessageInfo.BizPrivacyStatus bizPrivacyStatus = 36; +inline bool WebMessageInfo::_internal_has_bizprivacystatus() const { + bool value = (_impl_._has_bits_[1] & 0x00000004u) != 0; + return value; +} +inline bool WebMessageInfo::has_bizprivacystatus() const { + return _internal_has_bizprivacystatus(); +} +inline void WebMessageInfo::clear_bizprivacystatus() { + _impl_.bizprivacystatus_ = 0; + _impl_._has_bits_[1] &= ~0x00000004u; +} +inline ::proto::WebMessageInfo_BizPrivacyStatus WebMessageInfo::_internal_bizprivacystatus() const { + return static_cast< ::proto::WebMessageInfo_BizPrivacyStatus >(_impl_.bizprivacystatus_); +} +inline ::proto::WebMessageInfo_BizPrivacyStatus WebMessageInfo::bizprivacystatus() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.bizPrivacyStatus) + return _internal_bizprivacystatus(); +} +inline void WebMessageInfo::_internal_set_bizprivacystatus(::proto::WebMessageInfo_BizPrivacyStatus value) { + assert(::proto::WebMessageInfo_BizPrivacyStatus_IsValid(value)); + _impl_._has_bits_[1] |= 0x00000004u; + _impl_.bizprivacystatus_ = value; +} +inline void WebMessageInfo::set_bizprivacystatus(::proto::WebMessageInfo_BizPrivacyStatus value) { + _internal_set_bizprivacystatus(value); + // @@protoc_insertion_point(field_set:proto.WebMessageInfo.bizPrivacyStatus) +} + +// optional string verifiedBizName = 37; +inline bool WebMessageInfo::_internal_has_verifiedbizname() const { + bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool WebMessageInfo::has_verifiedbizname() const { + return _internal_has_verifiedbizname(); +} +inline void WebMessageInfo::clear_verifiedbizname() { + _impl_.verifiedbizname_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000008u; +} +inline const std::string& WebMessageInfo::verifiedbizname() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.verifiedBizName) + return _internal_verifiedbizname(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void WebMessageInfo::set_verifiedbizname(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.verifiedbizname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.WebMessageInfo.verifiedBizName) +} +inline std::string* WebMessageInfo::mutable_verifiedbizname() { + std::string* _s = _internal_mutable_verifiedbizname(); + // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.verifiedBizName) + return _s; +} +inline const std::string& WebMessageInfo::_internal_verifiedbizname() const { + return _impl_.verifiedbizname_.Get(); +} +inline void WebMessageInfo::_internal_set_verifiedbizname(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000008u; + _impl_.verifiedbizname_.Set(value, GetArenaForAllocation()); +} +inline std::string* WebMessageInfo::_internal_mutable_verifiedbizname() { + _impl_._has_bits_[0] |= 0x00000008u; + return _impl_.verifiedbizname_.Mutable(GetArenaForAllocation()); +} +inline std::string* WebMessageInfo::release_verifiedbizname() { + // @@protoc_insertion_point(field_release:proto.WebMessageInfo.verifiedBizName) + if (!_internal_has_verifiedbizname()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000008u; + auto* p = _impl_.verifiedbizname_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.verifiedbizname_.IsDefault()) { + _impl_.verifiedbizname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void WebMessageInfo::set_allocated_verifiedbizname(std::string* verifiedbizname) { + if (verifiedbizname != nullptr) { + _impl_._has_bits_[0] |= 0x00000008u; + } else { + _impl_._has_bits_[0] &= ~0x00000008u; + } + _impl_.verifiedbizname_.SetAllocated(verifiedbizname, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.verifiedbizname_.IsDefault()) { + _impl_.verifiedbizname_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.verifiedBizName) +} + +// optional .proto.MediaData mediaData = 38; +inline bool WebMessageInfo::_internal_has_mediadata() const { + bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.mediadata_ != nullptr); + return value; +} +inline bool WebMessageInfo::has_mediadata() const { + return _internal_has_mediadata(); +} +inline void WebMessageInfo::clear_mediadata() { + if (_impl_.mediadata_ != nullptr) _impl_.mediadata_->Clear(); + _impl_._has_bits_[0] &= ~0x00002000u; +} +inline const ::proto::MediaData& WebMessageInfo::_internal_mediadata() const { + const ::proto::MediaData* p = _impl_.mediadata_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_MediaData_default_instance_); +} +inline const ::proto::MediaData& WebMessageInfo::mediadata() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.mediaData) + return _internal_mediadata(); +} +inline void WebMessageInfo::unsafe_arena_set_allocated_mediadata( + ::proto::MediaData* mediadata) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.mediadata_); + } + _impl_.mediadata_ = mediadata; + if (mediadata) { + _impl_._has_bits_[0] |= 0x00002000u; + } else { + _impl_._has_bits_[0] &= ~0x00002000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.mediaData) +} +inline ::proto::MediaData* WebMessageInfo::release_mediadata() { + _impl_._has_bits_[0] &= ~0x00002000u; + ::proto::MediaData* temp = _impl_.mediadata_; + _impl_.mediadata_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::MediaData* WebMessageInfo::unsafe_arena_release_mediadata() { + // @@protoc_insertion_point(field_release:proto.WebMessageInfo.mediaData) + _impl_._has_bits_[0] &= ~0x00002000u; + ::proto::MediaData* temp = _impl_.mediadata_; + _impl_.mediadata_ = nullptr; + return temp; +} +inline ::proto::MediaData* WebMessageInfo::_internal_mutable_mediadata() { + _impl_._has_bits_[0] |= 0x00002000u; + if (_impl_.mediadata_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::MediaData>(GetArenaForAllocation()); + _impl_.mediadata_ = p; + } + return _impl_.mediadata_; +} +inline ::proto::MediaData* WebMessageInfo::mutable_mediadata() { + ::proto::MediaData* _msg = _internal_mutable_mediadata(); + // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.mediaData) + return _msg; +} +inline void WebMessageInfo::set_allocated_mediadata(::proto::MediaData* mediadata) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.mediadata_; + } + if (mediadata) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(mediadata); + if (message_arena != submessage_arena) { + mediadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, mediadata, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00002000u; + } else { + _impl_._has_bits_[0] &= ~0x00002000u; + } + _impl_.mediadata_ = mediadata; + // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.mediaData) +} + +// optional .proto.PhotoChange photoChange = 39; +inline bool WebMessageInfo::_internal_has_photochange() const { + bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.photochange_ != nullptr); + return value; +} +inline bool WebMessageInfo::has_photochange() const { + return _internal_has_photochange(); +} +inline void WebMessageInfo::clear_photochange() { + if (_impl_.photochange_ != nullptr) _impl_.photochange_->Clear(); + _impl_._has_bits_[0] &= ~0x00004000u; +} +inline const ::proto::PhotoChange& WebMessageInfo::_internal_photochange() const { + const ::proto::PhotoChange* p = _impl_.photochange_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_PhotoChange_default_instance_); +} +inline const ::proto::PhotoChange& WebMessageInfo::photochange() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.photoChange) + return _internal_photochange(); +} +inline void WebMessageInfo::unsafe_arena_set_allocated_photochange( + ::proto::PhotoChange* photochange) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.photochange_); + } + _impl_.photochange_ = photochange; + if (photochange) { + _impl_._has_bits_[0] |= 0x00004000u; + } else { + _impl_._has_bits_[0] &= ~0x00004000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.photoChange) +} +inline ::proto::PhotoChange* WebMessageInfo::release_photochange() { + _impl_._has_bits_[0] &= ~0x00004000u; + ::proto::PhotoChange* temp = _impl_.photochange_; + _impl_.photochange_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::PhotoChange* WebMessageInfo::unsafe_arena_release_photochange() { + // @@protoc_insertion_point(field_release:proto.WebMessageInfo.photoChange) + _impl_._has_bits_[0] &= ~0x00004000u; + ::proto::PhotoChange* temp = _impl_.photochange_; + _impl_.photochange_ = nullptr; + return temp; +} +inline ::proto::PhotoChange* WebMessageInfo::_internal_mutable_photochange() { + _impl_._has_bits_[0] |= 0x00004000u; + if (_impl_.photochange_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::PhotoChange>(GetArenaForAllocation()); + _impl_.photochange_ = p; + } + return _impl_.photochange_; +} +inline ::proto::PhotoChange* WebMessageInfo::mutable_photochange() { + ::proto::PhotoChange* _msg = _internal_mutable_photochange(); + // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.photoChange) + return _msg; +} +inline void WebMessageInfo::set_allocated_photochange(::proto::PhotoChange* photochange) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.photochange_; + } + if (photochange) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(photochange); + if (message_arena != submessage_arena) { + photochange = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, photochange, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00004000u; + } else { + _impl_._has_bits_[0] &= ~0x00004000u; + } + _impl_.photochange_ = photochange; + // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.photoChange) +} + +// repeated .proto.UserReceipt userReceipt = 40; +inline int WebMessageInfo::_internal_userreceipt_size() const { + return _impl_.userreceipt_.size(); +} +inline int WebMessageInfo::userreceipt_size() const { + return _internal_userreceipt_size(); +} +inline void WebMessageInfo::clear_userreceipt() { + _impl_.userreceipt_.Clear(); +} +inline ::proto::UserReceipt* WebMessageInfo::mutable_userreceipt(int index) { + // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.userReceipt) + return _impl_.userreceipt_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::UserReceipt >* +WebMessageInfo::mutable_userreceipt() { + // @@protoc_insertion_point(field_mutable_list:proto.WebMessageInfo.userReceipt) + return &_impl_.userreceipt_; +} +inline const ::proto::UserReceipt& WebMessageInfo::_internal_userreceipt(int index) const { + return _impl_.userreceipt_.Get(index); +} +inline const ::proto::UserReceipt& WebMessageInfo::userreceipt(int index) const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.userReceipt) + return _internal_userreceipt(index); +} +inline ::proto::UserReceipt* WebMessageInfo::_internal_add_userreceipt() { + return _impl_.userreceipt_.Add(); +} +inline ::proto::UserReceipt* WebMessageInfo::add_userreceipt() { + ::proto::UserReceipt* _add = _internal_add_userreceipt(); + // @@protoc_insertion_point(field_add:proto.WebMessageInfo.userReceipt) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::UserReceipt >& +WebMessageInfo::userreceipt() const { + // @@protoc_insertion_point(field_list:proto.WebMessageInfo.userReceipt) + return _impl_.userreceipt_; +} + +// repeated .proto.Reaction reactions = 41; +inline int WebMessageInfo::_internal_reactions_size() const { + return _impl_.reactions_.size(); +} +inline int WebMessageInfo::reactions_size() const { + return _internal_reactions_size(); +} +inline void WebMessageInfo::clear_reactions() { + _impl_.reactions_.Clear(); +} +inline ::proto::Reaction* WebMessageInfo::mutable_reactions(int index) { + // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.reactions) + return _impl_.reactions_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Reaction >* +WebMessageInfo::mutable_reactions() { + // @@protoc_insertion_point(field_mutable_list:proto.WebMessageInfo.reactions) + return &_impl_.reactions_; +} +inline const ::proto::Reaction& WebMessageInfo::_internal_reactions(int index) const { + return _impl_.reactions_.Get(index); +} +inline const ::proto::Reaction& WebMessageInfo::reactions(int index) const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.reactions) + return _internal_reactions(index); +} +inline ::proto::Reaction* WebMessageInfo::_internal_add_reactions() { + return _impl_.reactions_.Add(); +} +inline ::proto::Reaction* WebMessageInfo::add_reactions() { + ::proto::Reaction* _add = _internal_add_reactions(); + // @@protoc_insertion_point(field_add:proto.WebMessageInfo.reactions) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Reaction >& +WebMessageInfo::reactions() const { + // @@protoc_insertion_point(field_list:proto.WebMessageInfo.reactions) + return _impl_.reactions_; +} + +// optional .proto.MediaData quotedStickerData = 42; +inline bool WebMessageInfo::_internal_has_quotedstickerdata() const { + bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.quotedstickerdata_ != nullptr); + return value; +} +inline bool WebMessageInfo::has_quotedstickerdata() const { + return _internal_has_quotedstickerdata(); +} +inline void WebMessageInfo::clear_quotedstickerdata() { + if (_impl_.quotedstickerdata_ != nullptr) _impl_.quotedstickerdata_->Clear(); + _impl_._has_bits_[0] &= ~0x00008000u; +} +inline const ::proto::MediaData& WebMessageInfo::_internal_quotedstickerdata() const { + const ::proto::MediaData* p = _impl_.quotedstickerdata_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_MediaData_default_instance_); +} +inline const ::proto::MediaData& WebMessageInfo::quotedstickerdata() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.quotedStickerData) + return _internal_quotedstickerdata(); +} +inline void WebMessageInfo::unsafe_arena_set_allocated_quotedstickerdata( + ::proto::MediaData* quotedstickerdata) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quotedstickerdata_); + } + _impl_.quotedstickerdata_ = quotedstickerdata; + if (quotedstickerdata) { + _impl_._has_bits_[0] |= 0x00008000u; + } else { + _impl_._has_bits_[0] &= ~0x00008000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.quotedStickerData) +} +inline ::proto::MediaData* WebMessageInfo::release_quotedstickerdata() { + _impl_._has_bits_[0] &= ~0x00008000u; + ::proto::MediaData* temp = _impl_.quotedstickerdata_; + _impl_.quotedstickerdata_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::MediaData* WebMessageInfo::unsafe_arena_release_quotedstickerdata() { + // @@protoc_insertion_point(field_release:proto.WebMessageInfo.quotedStickerData) + _impl_._has_bits_[0] &= ~0x00008000u; + ::proto::MediaData* temp = _impl_.quotedstickerdata_; + _impl_.quotedstickerdata_ = nullptr; + return temp; +} +inline ::proto::MediaData* WebMessageInfo::_internal_mutable_quotedstickerdata() { + _impl_._has_bits_[0] |= 0x00008000u; + if (_impl_.quotedstickerdata_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::MediaData>(GetArenaForAllocation()); + _impl_.quotedstickerdata_ = p; + } + return _impl_.quotedstickerdata_; +} +inline ::proto::MediaData* WebMessageInfo::mutable_quotedstickerdata() { + ::proto::MediaData* _msg = _internal_mutable_quotedstickerdata(); + // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.quotedStickerData) + return _msg; +} +inline void WebMessageInfo::set_allocated_quotedstickerdata(::proto::MediaData* quotedstickerdata) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.quotedstickerdata_; + } + if (quotedstickerdata) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quotedstickerdata); + if (message_arena != submessage_arena) { + quotedstickerdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, quotedstickerdata, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00008000u; + } else { + _impl_._has_bits_[0] &= ~0x00008000u; + } + _impl_.quotedstickerdata_ = quotedstickerdata; + // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.quotedStickerData) +} + +// optional bytes futureproofData = 43; +inline bool WebMessageInfo::_internal_has_futureproofdata() const { + bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool WebMessageInfo::has_futureproofdata() const { + return _internal_has_futureproofdata(); +} +inline void WebMessageInfo::clear_futureproofdata() { + _impl_.futureproofdata_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000010u; +} +inline const std::string& WebMessageInfo::futureproofdata() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.futureproofData) + return _internal_futureproofdata(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void WebMessageInfo::set_futureproofdata(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.futureproofdata_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.WebMessageInfo.futureproofData) +} +inline std::string* WebMessageInfo::mutable_futureproofdata() { + std::string* _s = _internal_mutable_futureproofdata(); + // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.futureproofData) + return _s; +} +inline const std::string& WebMessageInfo::_internal_futureproofdata() const { + return _impl_.futureproofdata_.Get(); +} +inline void WebMessageInfo::_internal_set_futureproofdata(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000010u; + _impl_.futureproofdata_.Set(value, GetArenaForAllocation()); +} +inline std::string* WebMessageInfo::_internal_mutable_futureproofdata() { + _impl_._has_bits_[0] |= 0x00000010u; + return _impl_.futureproofdata_.Mutable(GetArenaForAllocation()); +} +inline std::string* WebMessageInfo::release_futureproofdata() { + // @@protoc_insertion_point(field_release:proto.WebMessageInfo.futureproofData) + if (!_internal_has_futureproofdata()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000010u; + auto* p = _impl_.futureproofdata_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.futureproofdata_.IsDefault()) { + _impl_.futureproofdata_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void WebMessageInfo::set_allocated_futureproofdata(std::string* futureproofdata) { + if (futureproofdata != nullptr) { + _impl_._has_bits_[0] |= 0x00000010u; + } else { + _impl_._has_bits_[0] &= ~0x00000010u; + } + _impl_.futureproofdata_.SetAllocated(futureproofdata, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.futureproofdata_.IsDefault()) { + _impl_.futureproofdata_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.futureproofData) +} + +// optional .proto.StatusPSA statusPsa = 44; +inline bool WebMessageInfo::_internal_has_statuspsa() const { + bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.statuspsa_ != nullptr); + return value; +} +inline bool WebMessageInfo::has_statuspsa() const { + return _internal_has_statuspsa(); +} +inline void WebMessageInfo::clear_statuspsa() { + if (_impl_.statuspsa_ != nullptr) _impl_.statuspsa_->Clear(); + _impl_._has_bits_[0] &= ~0x00010000u; +} +inline const ::proto::StatusPSA& WebMessageInfo::_internal_statuspsa() const { + const ::proto::StatusPSA* p = _impl_.statuspsa_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_StatusPSA_default_instance_); +} +inline const ::proto::StatusPSA& WebMessageInfo::statuspsa() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.statusPsa) + return _internal_statuspsa(); +} +inline void WebMessageInfo::unsafe_arena_set_allocated_statuspsa( + ::proto::StatusPSA* statuspsa) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.statuspsa_); + } + _impl_.statuspsa_ = statuspsa; + if (statuspsa) { + _impl_._has_bits_[0] |= 0x00010000u; + } else { + _impl_._has_bits_[0] &= ~0x00010000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.statusPsa) +} +inline ::proto::StatusPSA* WebMessageInfo::release_statuspsa() { + _impl_._has_bits_[0] &= ~0x00010000u; + ::proto::StatusPSA* temp = _impl_.statuspsa_; + _impl_.statuspsa_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::StatusPSA* WebMessageInfo::unsafe_arena_release_statuspsa() { + // @@protoc_insertion_point(field_release:proto.WebMessageInfo.statusPsa) + _impl_._has_bits_[0] &= ~0x00010000u; + ::proto::StatusPSA* temp = _impl_.statuspsa_; + _impl_.statuspsa_ = nullptr; + return temp; +} +inline ::proto::StatusPSA* WebMessageInfo::_internal_mutable_statuspsa() { + _impl_._has_bits_[0] |= 0x00010000u; + if (_impl_.statuspsa_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::StatusPSA>(GetArenaForAllocation()); + _impl_.statuspsa_ = p; + } + return _impl_.statuspsa_; +} +inline ::proto::StatusPSA* WebMessageInfo::mutable_statuspsa() { + ::proto::StatusPSA* _msg = _internal_mutable_statuspsa(); + // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.statusPsa) + return _msg; +} +inline void WebMessageInfo::set_allocated_statuspsa(::proto::StatusPSA* statuspsa) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.statuspsa_; + } + if (statuspsa) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(statuspsa); + if (message_arena != submessage_arena) { + statuspsa = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, statuspsa, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00010000u; + } else { + _impl_._has_bits_[0] &= ~0x00010000u; + } + _impl_.statuspsa_ = statuspsa; + // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.statusPsa) +} + +// repeated .proto.PollUpdate pollUpdates = 45; +inline int WebMessageInfo::_internal_pollupdates_size() const { + return _impl_.pollupdates_.size(); +} +inline int WebMessageInfo::pollupdates_size() const { + return _internal_pollupdates_size(); +} +inline void WebMessageInfo::clear_pollupdates() { + _impl_.pollupdates_.Clear(); +} +inline ::proto::PollUpdate* WebMessageInfo::mutable_pollupdates(int index) { + // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.pollUpdates) + return _impl_.pollupdates_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PollUpdate >* +WebMessageInfo::mutable_pollupdates() { + // @@protoc_insertion_point(field_mutable_list:proto.WebMessageInfo.pollUpdates) + return &_impl_.pollupdates_; +} +inline const ::proto::PollUpdate& WebMessageInfo::_internal_pollupdates(int index) const { + return _impl_.pollupdates_.Get(index); +} +inline const ::proto::PollUpdate& WebMessageInfo::pollupdates(int index) const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.pollUpdates) + return _internal_pollupdates(index); +} +inline ::proto::PollUpdate* WebMessageInfo::_internal_add_pollupdates() { + return _impl_.pollupdates_.Add(); +} +inline ::proto::PollUpdate* WebMessageInfo::add_pollupdates() { + ::proto::PollUpdate* _add = _internal_add_pollupdates(); + // @@protoc_insertion_point(field_add:proto.WebMessageInfo.pollUpdates) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PollUpdate >& +WebMessageInfo::pollupdates() const { + // @@protoc_insertion_point(field_list:proto.WebMessageInfo.pollUpdates) + return _impl_.pollupdates_; +} + +// optional .proto.PollAdditionalMetadata pollAdditionalMetadata = 46; +inline bool WebMessageInfo::_internal_has_polladditionalmetadata() const { + bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.polladditionalmetadata_ != nullptr); + return value; +} +inline bool WebMessageInfo::has_polladditionalmetadata() const { + return _internal_has_polladditionalmetadata(); +} +inline void WebMessageInfo::clear_polladditionalmetadata() { + if (_impl_.polladditionalmetadata_ != nullptr) _impl_.polladditionalmetadata_->Clear(); + _impl_._has_bits_[0] &= ~0x00020000u; +} +inline const ::proto::PollAdditionalMetadata& WebMessageInfo::_internal_polladditionalmetadata() const { + const ::proto::PollAdditionalMetadata* p = _impl_.polladditionalmetadata_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_PollAdditionalMetadata_default_instance_); +} +inline const ::proto::PollAdditionalMetadata& WebMessageInfo::polladditionalmetadata() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.pollAdditionalMetadata) + return _internal_polladditionalmetadata(); +} +inline void WebMessageInfo::unsafe_arena_set_allocated_polladditionalmetadata( + ::proto::PollAdditionalMetadata* polladditionalmetadata) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.polladditionalmetadata_); + } + _impl_.polladditionalmetadata_ = polladditionalmetadata; + if (polladditionalmetadata) { + _impl_._has_bits_[0] |= 0x00020000u; + } else { + _impl_._has_bits_[0] &= ~0x00020000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.pollAdditionalMetadata) +} +inline ::proto::PollAdditionalMetadata* WebMessageInfo::release_polladditionalmetadata() { + _impl_._has_bits_[0] &= ~0x00020000u; + ::proto::PollAdditionalMetadata* temp = _impl_.polladditionalmetadata_; + _impl_.polladditionalmetadata_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::PollAdditionalMetadata* WebMessageInfo::unsafe_arena_release_polladditionalmetadata() { + // @@protoc_insertion_point(field_release:proto.WebMessageInfo.pollAdditionalMetadata) + _impl_._has_bits_[0] &= ~0x00020000u; + ::proto::PollAdditionalMetadata* temp = _impl_.polladditionalmetadata_; + _impl_.polladditionalmetadata_ = nullptr; + return temp; +} +inline ::proto::PollAdditionalMetadata* WebMessageInfo::_internal_mutable_polladditionalmetadata() { + _impl_._has_bits_[0] |= 0x00020000u; + if (_impl_.polladditionalmetadata_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::PollAdditionalMetadata>(GetArenaForAllocation()); + _impl_.polladditionalmetadata_ = p; + } + return _impl_.polladditionalmetadata_; +} +inline ::proto::PollAdditionalMetadata* WebMessageInfo::mutable_polladditionalmetadata() { + ::proto::PollAdditionalMetadata* _msg = _internal_mutable_polladditionalmetadata(); + // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.pollAdditionalMetadata) + return _msg; +} +inline void WebMessageInfo::set_allocated_polladditionalmetadata(::proto::PollAdditionalMetadata* polladditionalmetadata) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.polladditionalmetadata_; + } + if (polladditionalmetadata) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(polladditionalmetadata); + if (message_arena != submessage_arena) { + polladditionalmetadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, polladditionalmetadata, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00020000u; + } else { + _impl_._has_bits_[0] &= ~0x00020000u; + } + _impl_.polladditionalmetadata_ = polladditionalmetadata; + // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.pollAdditionalMetadata) +} + +// optional string agentId = 47; +inline bool WebMessageInfo::_internal_has_agentid() const { + bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool WebMessageInfo::has_agentid() const { + return _internal_has_agentid(); +} +inline void WebMessageInfo::clear_agentid() { + _impl_.agentid_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000020u; +} +inline const std::string& WebMessageInfo::agentid() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.agentId) + return _internal_agentid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void WebMessageInfo::set_agentid(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.agentid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.WebMessageInfo.agentId) +} +inline std::string* WebMessageInfo::mutable_agentid() { + std::string* _s = _internal_mutable_agentid(); + // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.agentId) + return _s; +} +inline const std::string& WebMessageInfo::_internal_agentid() const { + return _impl_.agentid_.Get(); +} +inline void WebMessageInfo::_internal_set_agentid(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000020u; + _impl_.agentid_.Set(value, GetArenaForAllocation()); +} +inline std::string* WebMessageInfo::_internal_mutable_agentid() { + _impl_._has_bits_[0] |= 0x00000020u; + return _impl_.agentid_.Mutable(GetArenaForAllocation()); +} +inline std::string* WebMessageInfo::release_agentid() { + // @@protoc_insertion_point(field_release:proto.WebMessageInfo.agentId) + if (!_internal_has_agentid()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000020u; + auto* p = _impl_.agentid_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.agentid_.IsDefault()) { + _impl_.agentid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void WebMessageInfo::set_allocated_agentid(std::string* agentid) { + if (agentid != nullptr) { + _impl_._has_bits_[0] |= 0x00000020u; + } else { + _impl_._has_bits_[0] &= ~0x00000020u; + } + _impl_.agentid_.SetAllocated(agentid, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.agentid_.IsDefault()) { + _impl_.agentid_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.agentId) +} + +// optional bool statusAlreadyViewed = 48; +inline bool WebMessageInfo::_internal_has_statusalreadyviewed() const { + bool value = (_impl_._has_bits_[1] & 0x00000010u) != 0; + return value; +} +inline bool WebMessageInfo::has_statusalreadyviewed() const { + return _internal_has_statusalreadyviewed(); +} +inline void WebMessageInfo::clear_statusalreadyviewed() { + _impl_.statusalreadyviewed_ = false; + _impl_._has_bits_[1] &= ~0x00000010u; +} +inline bool WebMessageInfo::_internal_statusalreadyviewed() const { + return _impl_.statusalreadyviewed_; +} +inline bool WebMessageInfo::statusalreadyviewed() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.statusAlreadyViewed) + return _internal_statusalreadyviewed(); +} +inline void WebMessageInfo::_internal_set_statusalreadyviewed(bool value) { + _impl_._has_bits_[1] |= 0x00000010u; + _impl_.statusalreadyviewed_ = value; +} +inline void WebMessageInfo::set_statusalreadyviewed(bool value) { + _internal_set_statusalreadyviewed(value); + // @@protoc_insertion_point(field_set:proto.WebMessageInfo.statusAlreadyViewed) +} + +// optional bytes messageSecret = 49; +inline bool WebMessageInfo::_internal_has_messagesecret() const { + bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool WebMessageInfo::has_messagesecret() const { + return _internal_has_messagesecret(); +} +inline void WebMessageInfo::clear_messagesecret() { + _impl_.messagesecret_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000040u; +} +inline const std::string& WebMessageInfo::messagesecret() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.messageSecret) + return _internal_messagesecret(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void WebMessageInfo::set_messagesecret(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.messagesecret_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.WebMessageInfo.messageSecret) +} +inline std::string* WebMessageInfo::mutable_messagesecret() { + std::string* _s = _internal_mutable_messagesecret(); + // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.messageSecret) + return _s; +} +inline const std::string& WebMessageInfo::_internal_messagesecret() const { + return _impl_.messagesecret_.Get(); +} +inline void WebMessageInfo::_internal_set_messagesecret(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000040u; + _impl_.messagesecret_.Set(value, GetArenaForAllocation()); +} +inline std::string* WebMessageInfo::_internal_mutable_messagesecret() { + _impl_._has_bits_[0] |= 0x00000040u; + return _impl_.messagesecret_.Mutable(GetArenaForAllocation()); +} +inline std::string* WebMessageInfo::release_messagesecret() { + // @@protoc_insertion_point(field_release:proto.WebMessageInfo.messageSecret) + if (!_internal_has_messagesecret()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000040u; + auto* p = _impl_.messagesecret_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.messagesecret_.IsDefault()) { + _impl_.messagesecret_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void WebMessageInfo::set_allocated_messagesecret(std::string* messagesecret) { + if (messagesecret != nullptr) { + _impl_._has_bits_[0] |= 0x00000040u; + } else { + _impl_._has_bits_[0] &= ~0x00000040u; + } + _impl_.messagesecret_.SetAllocated(messagesecret, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.messagesecret_.IsDefault()) { + _impl_.messagesecret_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.messageSecret) +} + +// optional .proto.KeepInChat keepInChat = 50; +inline bool WebMessageInfo::_internal_has_keepinchat() const { + bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0; + PROTOBUF_ASSUME(!value || _impl_.keepinchat_ != nullptr); + return value; +} +inline bool WebMessageInfo::has_keepinchat() const { + return _internal_has_keepinchat(); +} +inline void WebMessageInfo::clear_keepinchat() { + if (_impl_.keepinchat_ != nullptr) _impl_.keepinchat_->Clear(); + _impl_._has_bits_[0] &= ~0x00040000u; +} +inline const ::proto::KeepInChat& WebMessageInfo::_internal_keepinchat() const { + const ::proto::KeepInChat* p = _impl_.keepinchat_; + return p != nullptr ? *p : reinterpret_cast( + ::proto::_KeepInChat_default_instance_); +} +inline const ::proto::KeepInChat& WebMessageInfo::keepinchat() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.keepInChat) + return _internal_keepinchat(); +} +inline void WebMessageInfo::unsafe_arena_set_allocated_keepinchat( + ::proto::KeepInChat* keepinchat) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keepinchat_); + } + _impl_.keepinchat_ = keepinchat; + if (keepinchat) { + _impl_._has_bits_[0] |= 0x00040000u; + } else { + _impl_._has_bits_[0] &= ~0x00040000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.keepInChat) +} +inline ::proto::KeepInChat* WebMessageInfo::release_keepinchat() { + _impl_._has_bits_[0] &= ~0x00040000u; + ::proto::KeepInChat* temp = _impl_.keepinchat_; + _impl_.keepinchat_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::proto::KeepInChat* WebMessageInfo::unsafe_arena_release_keepinchat() { + // @@protoc_insertion_point(field_release:proto.WebMessageInfo.keepInChat) + _impl_._has_bits_[0] &= ~0x00040000u; + ::proto::KeepInChat* temp = _impl_.keepinchat_; + _impl_.keepinchat_ = nullptr; + return temp; +} +inline ::proto::KeepInChat* WebMessageInfo::_internal_mutable_keepinchat() { + _impl_._has_bits_[0] |= 0x00040000u; + if (_impl_.keepinchat_ == nullptr) { + auto* p = CreateMaybeMessage<::proto::KeepInChat>(GetArenaForAllocation()); + _impl_.keepinchat_ = p; + } + return _impl_.keepinchat_; +} +inline ::proto::KeepInChat* WebMessageInfo::mutable_keepinchat() { + ::proto::KeepInChat* _msg = _internal_mutable_keepinchat(); + // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.keepInChat) + return _msg; +} +inline void WebMessageInfo::set_allocated_keepinchat(::proto::KeepInChat* keepinchat) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.keepinchat_; + } + if (keepinchat) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keepinchat); + if (message_arena != submessage_arena) { + keepinchat = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, keepinchat, submessage_arena); + } + _impl_._has_bits_[0] |= 0x00040000u; + } else { + _impl_._has_bits_[0] &= ~0x00040000u; + } + _impl_.keepinchat_ = keepinchat; + // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.keepInChat) +} + +// optional string originalSelfAuthorUserJidString = 51; +inline bool WebMessageInfo::_internal_has_originalselfauthoruserjidstring() const { + bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool WebMessageInfo::has_originalselfauthoruserjidstring() const { + return _internal_has_originalselfauthoruserjidstring(); +} +inline void WebMessageInfo::clear_originalselfauthoruserjidstring() { + _impl_.originalselfauthoruserjidstring_.ClearToEmpty(); + _impl_._has_bits_[0] &= ~0x00000080u; +} +inline const std::string& WebMessageInfo::originalselfauthoruserjidstring() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.originalSelfAuthorUserJidString) + return _internal_originalselfauthoruserjidstring(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void WebMessageInfo::set_originalselfauthoruserjidstring(ArgT0&& arg0, ArgT... args) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.originalselfauthoruserjidstring_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:proto.WebMessageInfo.originalSelfAuthorUserJidString) +} +inline std::string* WebMessageInfo::mutable_originalselfauthoruserjidstring() { + std::string* _s = _internal_mutable_originalselfauthoruserjidstring(); + // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.originalSelfAuthorUserJidString) + return _s; +} +inline const std::string& WebMessageInfo::_internal_originalselfauthoruserjidstring() const { + return _impl_.originalselfauthoruserjidstring_.Get(); +} +inline void WebMessageInfo::_internal_set_originalselfauthoruserjidstring(const std::string& value) { + _impl_._has_bits_[0] |= 0x00000080u; + _impl_.originalselfauthoruserjidstring_.Set(value, GetArenaForAllocation()); +} +inline std::string* WebMessageInfo::_internal_mutable_originalselfauthoruserjidstring() { + _impl_._has_bits_[0] |= 0x00000080u; + return _impl_.originalselfauthoruserjidstring_.Mutable(GetArenaForAllocation()); +} +inline std::string* WebMessageInfo::release_originalselfauthoruserjidstring() { + // @@protoc_insertion_point(field_release:proto.WebMessageInfo.originalSelfAuthorUserJidString) + if (!_internal_has_originalselfauthoruserjidstring()) { + return nullptr; + } + _impl_._has_bits_[0] &= ~0x00000080u; + auto* p = _impl_.originalselfauthoruserjidstring_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.originalselfauthoruserjidstring_.IsDefault()) { + _impl_.originalselfauthoruserjidstring_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void WebMessageInfo::set_allocated_originalselfauthoruserjidstring(std::string* originalselfauthoruserjidstring) { + if (originalselfauthoruserjidstring != nullptr) { + _impl_._has_bits_[0] |= 0x00000080u; + } else { + _impl_._has_bits_[0] &= ~0x00000080u; + } + _impl_.originalselfauthoruserjidstring_.SetAllocated(originalselfauthoruserjidstring, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (_impl_.originalselfauthoruserjidstring_.IsDefault()) { + _impl_.originalselfauthoruserjidstring_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.originalSelfAuthorUserJidString) +} + +// optional uint64 revokeMessageTimestamp = 52; +inline bool WebMessageInfo::_internal_has_revokemessagetimestamp() const { + bool value = (_impl_._has_bits_[1] & 0x00000020u) != 0; + return value; +} +inline bool WebMessageInfo::has_revokemessagetimestamp() const { + return _internal_has_revokemessagetimestamp(); +} +inline void WebMessageInfo::clear_revokemessagetimestamp() { + _impl_.revokemessagetimestamp_ = uint64_t{0u}; + _impl_._has_bits_[1] &= ~0x00000020u; +} +inline uint64_t WebMessageInfo::_internal_revokemessagetimestamp() const { + return _impl_.revokemessagetimestamp_; +} +inline uint64_t WebMessageInfo::revokemessagetimestamp() const { + // @@protoc_insertion_point(field_get:proto.WebMessageInfo.revokeMessageTimestamp) + return _internal_revokemessagetimestamp(); +} +inline void WebMessageInfo::_internal_set_revokemessagetimestamp(uint64_t value) { + _impl_._has_bits_[1] |= 0x00000020u; + _impl_.revokemessagetimestamp_ = value; +} +inline void WebMessageInfo::set_revokemessagetimestamp(uint64_t value) { + _internal_set_revokemessagetimestamp(value); + // @@protoc_insertion_point(field_set:proto.WebMessageInfo.revokeMessageTimestamp) +} + +// ------------------------------------------------------------------- + +// WebNotificationsInfo + +// optional uint64 timestamp = 2; +inline bool WebNotificationsInfo::_internal_has_timestamp() const { + bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool WebNotificationsInfo::has_timestamp() const { + return _internal_has_timestamp(); +} +inline void WebNotificationsInfo::clear_timestamp() { + _impl_.timestamp_ = uint64_t{0u}; + _impl_._has_bits_[0] &= ~0x00000001u; +} +inline uint64_t WebNotificationsInfo::_internal_timestamp() const { + return _impl_.timestamp_; +} +inline uint64_t WebNotificationsInfo::timestamp() const { + // @@protoc_insertion_point(field_get:proto.WebNotificationsInfo.timestamp) + return _internal_timestamp(); +} +inline void WebNotificationsInfo::_internal_set_timestamp(uint64_t value) { + _impl_._has_bits_[0] |= 0x00000001u; + _impl_.timestamp_ = value; +} +inline void WebNotificationsInfo::set_timestamp(uint64_t value) { + _internal_set_timestamp(value); + // @@protoc_insertion_point(field_set:proto.WebNotificationsInfo.timestamp) +} + +// optional uint32 unreadChats = 3; +inline bool WebNotificationsInfo::_internal_has_unreadchats() const { + bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool WebNotificationsInfo::has_unreadchats() const { + return _internal_has_unreadchats(); +} +inline void WebNotificationsInfo::clear_unreadchats() { + _impl_.unreadchats_ = 0u; + _impl_._has_bits_[0] &= ~0x00000002u; +} +inline uint32_t WebNotificationsInfo::_internal_unreadchats() const { + return _impl_.unreadchats_; +} +inline uint32_t WebNotificationsInfo::unreadchats() const { + // @@protoc_insertion_point(field_get:proto.WebNotificationsInfo.unreadChats) + return _internal_unreadchats(); +} +inline void WebNotificationsInfo::_internal_set_unreadchats(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000002u; + _impl_.unreadchats_ = value; +} +inline void WebNotificationsInfo::set_unreadchats(uint32_t value) { + _internal_set_unreadchats(value); + // @@protoc_insertion_point(field_set:proto.WebNotificationsInfo.unreadChats) +} + +// optional uint32 notifyMessageCount = 4; +inline bool WebNotificationsInfo::_internal_has_notifymessagecount() const { + bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool WebNotificationsInfo::has_notifymessagecount() const { + return _internal_has_notifymessagecount(); +} +inline void WebNotificationsInfo::clear_notifymessagecount() { + _impl_.notifymessagecount_ = 0u; + _impl_._has_bits_[0] &= ~0x00000004u; +} +inline uint32_t WebNotificationsInfo::_internal_notifymessagecount() const { + return _impl_.notifymessagecount_; +} +inline uint32_t WebNotificationsInfo::notifymessagecount() const { + // @@protoc_insertion_point(field_get:proto.WebNotificationsInfo.notifyMessageCount) + return _internal_notifymessagecount(); +} +inline void WebNotificationsInfo::_internal_set_notifymessagecount(uint32_t value) { + _impl_._has_bits_[0] |= 0x00000004u; + _impl_.notifymessagecount_ = value; +} +inline void WebNotificationsInfo::set_notifymessagecount(uint32_t value) { + _internal_set_notifymessagecount(value); + // @@protoc_insertion_point(field_set:proto.WebNotificationsInfo.notifyMessageCount) +} + +// repeated .proto.WebMessageInfo notifyMessages = 5; +inline int WebNotificationsInfo::_internal_notifymessages_size() const { + return _impl_.notifymessages_.size(); +} +inline int WebNotificationsInfo::notifymessages_size() const { + return _internal_notifymessages_size(); +} +inline void WebNotificationsInfo::clear_notifymessages() { + _impl_.notifymessages_.Clear(); +} +inline ::proto::WebMessageInfo* WebNotificationsInfo::mutable_notifymessages(int index) { + // @@protoc_insertion_point(field_mutable:proto.WebNotificationsInfo.notifyMessages) + return _impl_.notifymessages_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >* +WebNotificationsInfo::mutable_notifymessages() { + // @@protoc_insertion_point(field_mutable_list:proto.WebNotificationsInfo.notifyMessages) + return &_impl_.notifymessages_; +} +inline const ::proto::WebMessageInfo& WebNotificationsInfo::_internal_notifymessages(int index) const { + return _impl_.notifymessages_.Get(index); +} +inline const ::proto::WebMessageInfo& WebNotificationsInfo::notifymessages(int index) const { + // @@protoc_insertion_point(field_get:proto.WebNotificationsInfo.notifyMessages) + return _internal_notifymessages(index); +} +inline ::proto::WebMessageInfo* WebNotificationsInfo::_internal_add_notifymessages() { + return _impl_.notifymessages_.Add(); +} +inline ::proto::WebMessageInfo* WebNotificationsInfo::add_notifymessages() { + ::proto::WebMessageInfo* _add = _internal_add_notifymessages(); + // @@protoc_insertion_point(field_add:proto.WebNotificationsInfo.notifyMessages) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >& +WebNotificationsInfo::notifymessages() const { + // @@protoc_insertion_point(field_list:proto.WebNotificationsInfo.notifyMessages) + return _impl_.notifymessages_; +} + +#ifdef __GNUC__ + #pragma GCC diagnostic pop +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace proto + +PROTOBUF_NAMESPACE_OPEN + +template <> struct is_proto_enum< ::proto::BizAccountLinkInfo_AccountType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::BizAccountLinkInfo_AccountType>() { + return ::proto::BizAccountLinkInfo_AccountType_descriptor(); +} +template <> struct is_proto_enum< ::proto::BizAccountLinkInfo_HostStorageType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::BizAccountLinkInfo_HostStorageType>() { + return ::proto::BizAccountLinkInfo_HostStorageType_descriptor(); +} +template <> struct is_proto_enum< ::proto::BizIdentityInfo_ActualActorsType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::BizIdentityInfo_ActualActorsType>() { + return ::proto::BizIdentityInfo_ActualActorsType_descriptor(); +} +template <> struct is_proto_enum< ::proto::BizIdentityInfo_HostStorageType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::BizIdentityInfo_HostStorageType>() { + return ::proto::BizIdentityInfo_HostStorageType_descriptor(); +} +template <> struct is_proto_enum< ::proto::BizIdentityInfo_VerifiedLevelValue> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::BizIdentityInfo_VerifiedLevelValue>() { + return ::proto::BizIdentityInfo_VerifiedLevelValue_descriptor(); +} +template <> struct is_proto_enum< ::proto::ClientPayload_DNSSource_DNSResolutionMethod> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_DNSSource_DNSResolutionMethod>() { + return ::proto::ClientPayload_DNSSource_DNSResolutionMethod_descriptor(); +} +template <> struct is_proto_enum< ::proto::ClientPayload_UserAgent_Platform> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_UserAgent_Platform>() { + return ::proto::ClientPayload_UserAgent_Platform_descriptor(); +} +template <> struct is_proto_enum< ::proto::ClientPayload_UserAgent_ReleaseChannel> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_UserAgent_ReleaseChannel>() { + return ::proto::ClientPayload_UserAgent_ReleaseChannel_descriptor(); +} +template <> struct is_proto_enum< ::proto::ClientPayload_WebInfo_WebSubPlatform> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_WebInfo_WebSubPlatform>() { + return ::proto::ClientPayload_WebInfo_WebSubPlatform_descriptor(); +} +template <> struct is_proto_enum< ::proto::ClientPayload_ConnectReason> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_ConnectReason>() { + return ::proto::ClientPayload_ConnectReason_descriptor(); +} +template <> struct is_proto_enum< ::proto::ClientPayload_ConnectType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_ConnectType>() { + return ::proto::ClientPayload_ConnectType_descriptor(); +} +template <> struct is_proto_enum< ::proto::ClientPayload_IOSAppExtension> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_IOSAppExtension>() { + return ::proto::ClientPayload_IOSAppExtension_descriptor(); +} +template <> struct is_proto_enum< ::proto::ClientPayload_Product> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_Product>() { + return ::proto::ClientPayload_Product_descriptor(); +} +template <> struct is_proto_enum< ::proto::ContextInfo_AdReplyInfo_MediaType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::ContextInfo_AdReplyInfo_MediaType>() { + return ::proto::ContextInfo_AdReplyInfo_MediaType_descriptor(); +} +template <> struct is_proto_enum< ::proto::ContextInfo_ExternalAdReplyInfo_MediaType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::ContextInfo_ExternalAdReplyInfo_MediaType>() { + return ::proto::ContextInfo_ExternalAdReplyInfo_MediaType_descriptor(); +} +template <> struct is_proto_enum< ::proto::Conversation_EndOfHistoryTransferType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::Conversation_EndOfHistoryTransferType>() { + return ::proto::Conversation_EndOfHistoryTransferType_descriptor(); +} +template <> struct is_proto_enum< ::proto::DeviceProps_PlatformType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::DeviceProps_PlatformType>() { + return ::proto::DeviceProps_PlatformType_descriptor(); +} +template <> struct is_proto_enum< ::proto::DisappearingMode_Initiator> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::DisappearingMode_Initiator>() { + return ::proto::DisappearingMode_Initiator_descriptor(); +} +template <> struct is_proto_enum< ::proto::GroupParticipant_Rank> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::GroupParticipant_Rank>() { + return ::proto::GroupParticipant_Rank_descriptor(); +} +template <> struct is_proto_enum< ::proto::HistorySync_HistorySyncType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::HistorySync_HistorySyncType>() { + return ::proto::HistorySync_HistorySyncType_descriptor(); +} +template <> struct is_proto_enum< ::proto::MediaRetryNotification_ResultType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::MediaRetryNotification_ResultType>() { + return ::proto::MediaRetryNotification_ResultType_descriptor(); +} +template <> struct is_proto_enum< ::proto::Message_ButtonsMessage_Button_Type> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ButtonsMessage_Button_Type>() { + return ::proto::Message_ButtonsMessage_Button_Type_descriptor(); +} +template <> struct is_proto_enum< ::proto::Message_ButtonsMessage_HeaderType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ButtonsMessage_HeaderType>() { + return ::proto::Message_ButtonsMessage_HeaderType_descriptor(); +} +template <> struct is_proto_enum< ::proto::Message_ButtonsResponseMessage_Type> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ButtonsResponseMessage_Type>() { + return ::proto::Message_ButtonsResponseMessage_Type_descriptor(); +} +template <> struct is_proto_enum< ::proto::Message_ExtendedTextMessage_FontType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ExtendedTextMessage_FontType>() { + return ::proto::Message_ExtendedTextMessage_FontType_descriptor(); +} +template <> struct is_proto_enum< ::proto::Message_ExtendedTextMessage_InviteLinkGroupType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ExtendedTextMessage_InviteLinkGroupType>() { + return ::proto::Message_ExtendedTextMessage_InviteLinkGroupType_descriptor(); +} +template <> struct is_proto_enum< ::proto::Message_ExtendedTextMessage_PreviewType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ExtendedTextMessage_PreviewType>() { + return ::proto::Message_ExtendedTextMessage_PreviewType_descriptor(); +} +template <> struct is_proto_enum< ::proto::Message_GroupInviteMessage_GroupType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_GroupInviteMessage_GroupType>() { + return ::proto::Message_GroupInviteMessage_GroupType_descriptor(); +} +template <> struct is_proto_enum< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType>() { + return ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_descriptor(); +} +template <> struct is_proto_enum< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType>() { + return ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_descriptor(); +} +template <> struct is_proto_enum< ::proto::Message_HistorySyncNotification_HistorySyncType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_HistorySyncNotification_HistorySyncType>() { + return ::proto::Message_HistorySyncNotification_HistorySyncType_descriptor(); +} +template <> struct is_proto_enum< ::proto::Message_InteractiveMessage_ShopMessage_Surface> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_InteractiveMessage_ShopMessage_Surface>() { + return ::proto::Message_InteractiveMessage_ShopMessage_Surface_descriptor(); +} +template <> struct is_proto_enum< ::proto::Message_InvoiceMessage_AttachmentType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_InvoiceMessage_AttachmentType>() { + return ::proto::Message_InvoiceMessage_AttachmentType_descriptor(); +} +template <> struct is_proto_enum< ::proto::Message_ListMessage_ListType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ListMessage_ListType>() { + return ::proto::Message_ListMessage_ListType_descriptor(); +} +template <> struct is_proto_enum< ::proto::Message_ListResponseMessage_ListType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ListResponseMessage_ListType>() { + return ::proto::Message_ListResponseMessage_ListType_descriptor(); +} +template <> struct is_proto_enum< ::proto::Message_OrderMessage_OrderStatus> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_OrderMessage_OrderStatus>() { + return ::proto::Message_OrderMessage_OrderStatus_descriptor(); +} +template <> struct is_proto_enum< ::proto::Message_OrderMessage_OrderSurface> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_OrderMessage_OrderSurface>() { + return ::proto::Message_OrderMessage_OrderSurface_descriptor(); +} +template <> struct is_proto_enum< ::proto::Message_PaymentInviteMessage_ServiceType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_PaymentInviteMessage_ServiceType>() { + return ::proto::Message_PaymentInviteMessage_ServiceType_descriptor(); +} +template <> struct is_proto_enum< ::proto::Message_ProtocolMessage_Type> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ProtocolMessage_Type>() { + return ::proto::Message_ProtocolMessage_Type_descriptor(); +} +template <> struct is_proto_enum< ::proto::Message_VideoMessage_Attribution> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_VideoMessage_Attribution>() { + return ::proto::Message_VideoMessage_Attribution_descriptor(); +} +template <> struct is_proto_enum< ::proto::Message_RmrSource> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_RmrSource>() { + return ::proto::Message_RmrSource_descriptor(); +} +template <> struct is_proto_enum< ::proto::PastParticipant_LeaveReason> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::PastParticipant_LeaveReason>() { + return ::proto::PastParticipant_LeaveReason_descriptor(); +} +template <> struct is_proto_enum< ::proto::PaymentBackground_Type> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::PaymentBackground_Type>() { + return ::proto::PaymentBackground_Type_descriptor(); +} +template <> struct is_proto_enum< ::proto::PaymentInfo_Currency> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::PaymentInfo_Currency>() { + return ::proto::PaymentInfo_Currency_descriptor(); +} +template <> struct is_proto_enum< ::proto::PaymentInfo_Status> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::PaymentInfo_Status>() { + return ::proto::PaymentInfo_Status_descriptor(); +} +template <> struct is_proto_enum< ::proto::PaymentInfo_TxnStatus> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::PaymentInfo_TxnStatus>() { + return ::proto::PaymentInfo_TxnStatus_descriptor(); +} +template <> struct is_proto_enum< ::proto::SyncdMutation_SyncdOperation> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::SyncdMutation_SyncdOperation>() { + return ::proto::SyncdMutation_SyncdOperation_descriptor(); +} +template <> struct is_proto_enum< ::proto::WebFeatures_Flag> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::WebFeatures_Flag>() { + return ::proto::WebFeatures_Flag_descriptor(); +} +template <> struct is_proto_enum< ::proto::WebMessageInfo_BizPrivacyStatus> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::WebMessageInfo_BizPrivacyStatus>() { + return ::proto::WebMessageInfo_BizPrivacyStatus_descriptor(); +} +template <> struct is_proto_enum< ::proto::WebMessageInfo_Status> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::WebMessageInfo_Status>() { + return ::proto::WebMessageInfo_Status_descriptor(); +} +template <> struct is_proto_enum< ::proto::WebMessageInfo_StubType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::WebMessageInfo_StubType>() { + return ::proto::WebMessageInfo_StubType_descriptor(); +} +template <> struct is_proto_enum< ::proto::KeepType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::KeepType>() { + return ::proto::KeepType_descriptor(); +} +template <> struct is_proto_enum< ::proto::MediaVisibility> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::proto::MediaVisibility>() { + return ::proto::MediaVisibility_descriptor(); +} + +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) + +#include +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_pmsg_2eproto diff --git a/protocols/WhatsApp/src/pmsg.proto b/protocols/WhatsApp/src/pmsg.proto new file mode 100644 index 0000000000..e874f35591 --- /dev/null +++ b/protocols/WhatsApp/src/pmsg.proto @@ -0,0 +1,2361 @@ +syntax = "proto2"; +package proto; + +message ADVDeviceIdentity { + optional uint32 rawId = 1; + optional uint64 timestamp = 2; + optional uint32 keyIndex = 3; +} + +message ADVKeyIndexList { + optional uint32 rawId = 1; + optional uint64 timestamp = 2; + optional uint32 currentIndex = 3; + repeated uint32 validIndexes = 4 [packed=true]; +} + +message ADVSignedDeviceIdentity { + optional bytes details = 1; + optional bytes accountSignatureKey = 2; + optional bytes accountSignature = 3; + optional bytes deviceSignature = 4; +} + +message ADVSignedDeviceIdentityHMAC { + optional bytes details = 1; + optional bytes hmac = 2; +} + +message ADVSignedKeyIndexList { + optional bytes details = 1; + optional bytes accountSignature = 2; +} + +message ActionLink { + optional string url = 1; + optional string buttonTitle = 2; +} + +message AutoDownloadSettings { + optional bool downloadImages = 1; + optional bool downloadAudio = 2; + optional bool downloadVideo = 3; + optional bool downloadDocuments = 4; +} + +message BizAccountLinkInfo { + optional uint64 whatsappBizAcctFbid = 1; + optional string whatsappAcctNumber = 2; + optional uint64 issueTime = 3; + optional HostStorageType hostStorage = 4; + optional AccountType accountType = 5; + enum AccountType { + ENTERPRISE = 0; + } + enum HostStorageType { + ON_PREMISE = 0; + FACEBOOK = 1; + } +} + +message BizAccountPayload { + optional VerifiedNameCertificate vnameCert = 1; + optional bytes bizAcctLinkInfo = 2; +} + +message BizIdentityInfo { + optional VerifiedLevelValue vlevel = 1; + optional VerifiedNameCertificate vnameCert = 2; + optional bool signed = 3; + optional bool revoked = 4; + optional HostStorageType hostStorage = 5; + optional ActualActorsType actualActors = 6; + optional uint64 privacyModeTs = 7; + optional uint64 featureControls = 8; + enum ActualActorsType { + SELF = 0; + BSP = 1; + } + enum HostStorageType { + ON_PREMISE = 0; + FACEBOOK = 1; + } + enum VerifiedLevelValue { + UNKNOWN = 0; + LOW = 1; + HIGH = 2; + } +} + +message CertChain { + optional NoiseCertificate leaf = 1; + optional NoiseCertificate intermediate = 2; + message NoiseCertificate { + optional bytes details = 1; + optional bytes signature = 2; + message Details { + optional uint32 serial = 1; + optional uint32 issuerSerial = 2; + optional bytes key = 3; + optional uint64 notBefore = 4; + optional uint64 notAfter = 5; + } + + } + +} + +message Chain { + optional bytes senderRatchetKey = 1; + optional bytes senderRatchetKeyPrivate = 2; + optional ChainKey chainKey = 3; + repeated MessageKey messageKeys = 4; +} + +message ChainKey { + optional uint32 index = 1; + optional bytes key = 2; +} + +message ClientPayload { + optional uint64 username = 1; + optional bool passive = 3; + optional UserAgent userAgent = 5; + optional WebInfo webInfo = 6; + optional string pushName = 7; + optional sfixed32 sessionId = 9; + optional bool shortConnect = 10; + optional ConnectType connectType = 12; + optional ConnectReason connectReason = 13; + repeated int32 shards = 14; + optional DNSSource dnsSource = 15; + optional uint32 connectAttemptCount = 16; + optional uint32 device = 18; + optional DevicePairingRegistrationData devicePairingData = 19; + optional Product product = 20; + optional bytes fbCat = 21; + optional bytes fbUserAgent = 22; + optional bool oc = 23; + optional int32 lc = 24; + optional IOSAppExtension iosAppExtension = 30; + optional uint64 fbAppId = 31; + optional bytes fbDeviceId = 32; + optional bool pull = 33; + optional bytes paddingBytes = 34; + enum ConnectReason { + PUSH = 0; + USER_ACTIVATED = 1; + SCHEDULED = 2; + ERROR_RECONNECT = 3; + NETWORK_SWITCH = 4; + PING_RECONNECT = 5; + } + enum ConnectType { + CELLULAR_UNKNOWN = 0; + WIFI_UNKNOWN = 1; + CELLULAR_EDGE = 100; + CELLULAR_IDEN = 101; + CELLULAR_UMTS = 102; + CELLULAR_EVDO = 103; + CELLULAR_GPRS = 104; + CELLULAR_HSDPA = 105; + CELLULAR_HSUPA = 106; + CELLULAR_HSPA = 107; + CELLULAR_CDMA = 108; + CELLULAR_1XRTT = 109; + CELLULAR_EHRPD = 110; + CELLULAR_LTE = 111; + CELLULAR_HSPAP = 112; + } + message DNSSource { + optional DNSResolutionMethod dnsMethod = 15; + optional bool appCached = 16; + enum DNSResolutionMethod { + SYSTEM = 0; + GOOGLE = 1; + HARDCODED = 2; + OVERRIDE = 3; + FALLBACK = 4; + } + } + + message DevicePairingRegistrationData { + optional bytes eRegid = 1; + optional bytes eKeytype = 2; + optional bytes eIdent = 3; + optional bytes eSkeyId = 4; + optional bytes eSkeyVal = 5; + optional bytes eSkeySig = 6; + optional bytes buildHash = 7; + optional bytes deviceProps = 8; + } + + enum IOSAppExtension { + SHARE_EXTENSION = 0; + SERVICE_EXTENSION = 1; + INTENTS_EXTENSION = 2; + } + enum Product { + WHATSAPP = 0; + MESSENGER = 1; + } + message UserAgent { + optional Platform platform = 1; + optional AppVersion appVersion = 2; + optional string mcc = 3; + optional string mnc = 4; + optional string osVersion = 5; + optional string manufacturer = 6; + optional string device = 7; + optional string osBuildNumber = 8; + optional string phoneId = 9; + optional ReleaseChannel releaseChannel = 10; + optional string localeLanguageIso6391 = 11; + optional string localeCountryIso31661Alpha2 = 12; + optional string deviceBoard = 13; + message AppVersion { + optional uint32 primary = 1; + optional uint32 secondary = 2; + optional uint32 tertiary = 3; + optional uint32 quaternary = 4; + optional uint32 quinary = 5; + } + + enum Platform { + ANDROID = 0; + IOS = 1; + WINDOWS_PHONE = 2; + BLACKBERRY = 3; + BLACKBERRYX = 4; + S40 = 5; + S60 = 6; + PYTHON_CLIENT = 7; + TIZEN = 8; + ENTERPRISE = 9; + SMB_ANDROID = 10; + KAIOS = 11; + SMB_IOS = 12; + WINDOWS = 13; + WEB = 14; + PORTAL = 15; + GREEN_ANDROID = 16; + GREEN_IPHONE = 17; + BLUE_ANDROID = 18; + BLUE_IPHONE = 19; + FBLITE_ANDROID = 20; + MLITE_ANDROID = 21; + IGLITE_ANDROID = 22; + PAGE = 23; + MACOS = 24; + OCULUS_MSG = 25; + OCULUS_CALL = 26; + MILAN = 27; + CAPI = 28; + } + enum ReleaseChannel { + RELEASE = 0; + BETA = 1; + ALPHA = 2; + DEBUG = 3; + } + } + + message WebInfo { + optional string refToken = 1; + optional string version = 2; + optional WebdPayload webdPayload = 3; + optional WebSubPlatform webSubPlatform = 4; + enum WebSubPlatform { + WEB_BROWSER = 0; + APP_STORE = 1; + WIN_STORE = 2; + DARWIN = 3; + WINDA = 4; + } + message WebdPayload { + optional bool usesParticipantInKey = 1; + optional bool supportsStarredMessages = 2; + optional bool supportsDocumentMessages = 3; + optional bool supportsUrlMessages = 4; + optional bool supportsMediaRetry = 5; + optional bool supportsE2EImage = 6; + optional bool supportsE2EVideo = 7; + optional bool supportsE2EAudio = 8; + optional bool supportsE2EDocument = 9; + optional string documentTypes = 10; + optional bytes features = 11; + } + + } + +} + +message ContextInfo { + optional string stanzaId = 1; + optional string participant = 2; + optional Message quotedMessage = 3; + optional string remoteJid = 4; + repeated string mentionedJid = 15; + optional string conversionSource = 18; + optional bytes conversionData = 19; + optional uint32 conversionDelaySeconds = 20; + optional uint32 forwardingScore = 21; + optional bool isForwarded = 22; + optional AdReplyInfo quotedAd = 23; + optional MessageKey placeholderKey = 24; + optional uint32 expiration = 25; + optional int64 ephemeralSettingTimestamp = 26; + optional bytes ephemeralSharedSecret = 27; + optional ExternalAdReplyInfo externalAdReply = 28; + optional string entryPointConversionSource = 29; + optional string entryPointConversionApp = 30; + optional uint32 entryPointConversionDelaySeconds = 31; + optional DisappearingMode disappearingMode = 32; + optional ActionLink actionLink = 33; + optional string groupSubject = 34; + optional string parentGroupJid = 35; + message AdReplyInfo { + optional string advertiserName = 1; + optional MediaType mediaType = 2; + optional bytes jpegThumbnail = 16; + optional string caption = 17; + enum MediaType { + NONE = 0; + IMAGE = 1; + VIDEO = 2; + } + } + + message ExternalAdReplyInfo { + optional string title = 1; + optional string body = 2; + optional MediaType mediaType = 3; + optional string thumbnailUrl = 4; + optional string mediaUrl = 5; + optional bytes thumbnail = 6; + optional string sourceType = 7; + optional string sourceId = 8; + optional string sourceUrl = 9; + optional bool containsAutoReply = 10; + optional bool renderLargerThumbnail = 11; + optional bool showAdAttribution = 12; + enum MediaType { + NONE = 0; + IMAGE = 1; + VIDEO = 2; + } + } + +} + +message Conversation { + required string id = 1; + repeated HistorySyncMsg messages = 2; + optional string newJid = 3; + optional string oldJid = 4; + optional uint64 lastMsgTimestamp = 5; + optional uint32 unreadCount = 6; + optional bool readOnly = 7; + optional bool endOfHistoryTransfer = 8; + optional uint32 ephemeralExpiration = 9; + optional int64 ephemeralSettingTimestamp = 10; + optional EndOfHistoryTransferType endOfHistoryTransferType = 11; + optional uint64 conversationTimestamp = 12; + optional string name = 13; + optional string pHash = 14; + optional bool notSpam = 15; + optional bool archived = 16; + optional DisappearingMode disappearingMode = 17; + optional uint32 unreadMentionCount = 18; + optional bool markedAsUnread = 19; + repeated GroupParticipant participant = 20; + optional bytes tcToken = 21; + optional uint64 tcTokenTimestamp = 22; + optional bytes contactPrimaryIdentityKey = 23; + optional uint32 pinned = 24; + optional uint64 muteEndTime = 25; + optional WallpaperSettings wallpaper = 26; + optional MediaVisibility mediaVisibility = 27; + optional uint64 tcTokenSenderTimestamp = 28; + optional bool suspended = 29; + optional bool terminated = 30; + optional uint64 createdAt = 31; + optional string createdBy = 32; + optional string description = 33; + optional bool support = 34; + optional bool isParentGroup = 35; + optional bool isDefaultSubgroup = 36; + optional string parentGroupId = 37; + optional string displayName = 38; + optional string pnJid = 39; + optional bool selfPnExposed = 40; + enum EndOfHistoryTransferType { + COMPLETE_BUT_MORE_MESSAGES_REMAIN_ON_PRIMARY = 0; + COMPLETE_AND_NO_MORE_MESSAGE_REMAIN_ON_PRIMARY = 1; + } +} + +message DeviceListMetadata { + optional bytes senderKeyHash = 1; + optional uint64 senderTimestamp = 2; + repeated uint32 senderKeyIndexes = 3 [packed=true]; + optional bytes recipientKeyHash = 8; + optional uint64 recipientTimestamp = 9; + repeated uint32 recipientKeyIndexes = 10 [packed=true]; +} + +message DeviceProps { + optional string os = 1; + optional AppVersion version = 2; + optional PlatformType platformType = 3; + optional bool requireFullSync = 4; + message AppVersion { + optional uint32 primary = 1; + optional uint32 secondary = 2; + optional uint32 tertiary = 3; + optional uint32 quaternary = 4; + optional uint32 quinary = 5; + } + + enum PlatformType { + UNKNOWN = 0; + CHROME = 1; + FIREFOX = 2; + IE = 3; + OPERA = 4; + SAFARI = 5; + EDGE = 6; + DESKTOP = 7; + IPAD = 8; + ANDROID_TABLET = 9; + OHANA = 10; + ALOHA = 11; + CATALINA = 12; + TCL_TV = 13; + } +} + +message DisappearingMode { + optional Initiator initiator = 1; + enum Initiator { + CHANGED_IN_CHAT = 0; + INITIATED_BY_ME = 1; + INITIATED_BY_OTHER = 2; + } +} + +message EphemeralSetting { + optional sfixed32 duration = 1; + optional sfixed64 timestamp = 2; +} + +message ExitCode { + optional uint64 code = 1; + optional string text = 2; +} + +message ExternalBlobReference { + optional bytes mediaKey = 1; + optional string directPath = 2; + optional string handle = 3; + optional uint64 fileSizeBytes = 4; + optional bytes fileSha256 = 5; + optional bytes fileEncSha256 = 6; +} + +message GlobalSettings { + optional WallpaperSettings lightThemeWallpaper = 1; + optional MediaVisibility mediaVisibility = 2; + optional WallpaperSettings darkThemeWallpaper = 3; + optional AutoDownloadSettings autoDownloadWiFi = 4; + optional AutoDownloadSettings autoDownloadCellular = 5; + optional AutoDownloadSettings autoDownloadRoaming = 6; + optional bool showIndividualNotificationsPreview = 7; + optional bool showGroupNotificationsPreview = 8; + optional int32 disappearingModeDuration = 9; + optional int64 disappearingModeTimestamp = 10; +} + +message GroupParticipant { + required string userJid = 1; + optional Rank rank = 2; + enum Rank { + REGULAR = 0; + ADMIN = 1; + SUPERADMIN = 2; + } +} + +message HandshakeMessage { + optional ClientHello clientHello = 2; + optional ServerHello serverHello = 3; + optional ClientFinish clientFinish = 4; + message ClientFinish { + optional bytes static = 1; + optional bytes payload = 2; + } + + message ClientHello { + optional bytes ephemeral = 1; + optional bytes static = 2; + optional bytes payload = 3; + } + + message ServerHello { + optional bytes ephemeral = 1; + optional bytes static = 2; + optional bytes payload = 3; + } + +} + +message HistorySync { + required HistorySyncType syncType = 1; + repeated Conversation conversations = 2; + repeated WebMessageInfo statusV3Messages = 3; + optional uint32 chunkOrder = 5; + optional uint32 progress = 6; + repeated Pushname pushnames = 7; + optional GlobalSettings globalSettings = 8; + optional bytes threadIdUserSecret = 9; + optional uint32 threadDsTimeframeOffset = 10; + repeated StickerMetadata recentStickers = 11; + repeated PastParticipants pastParticipants = 12; + enum HistorySyncType { + INITIAL_BOOTSTRAP = 0; + INITIAL_STATUS_V3 = 1; + FULL = 2; + RECENT = 3; + PUSH_NAME = 4; + UNBLOCKING_DATA = 5; + } +} + +message HistorySyncMsg { + optional WebMessageInfo message = 1; + optional uint64 msgOrderId = 2; +} + +message HydratedTemplateButton { + optional uint32 index = 4; + oneof hydratedButton { + HydratedTemplateButton.HydratedQuickReplyButton quickReplyButton = 1; + HydratedTemplateButton.HydratedURLButton urlButton = 2; + HydratedTemplateButton.HydratedCallButton callButton = 3; + } + message HydratedCallButton { + optional string displayText = 1; + optional string phoneNumber = 2; + } + + message HydratedQuickReplyButton { + optional string displayText = 1; + optional string id = 2; + } + + message HydratedURLButton { + optional string displayText = 1; + optional string url = 2; + } + +} + +message IdentityKeyPairStructure { + optional bytes publicKey = 1; + optional bytes privateKey = 2; +} + +message InteractiveAnnotation { + repeated Point polygonVertices = 1; + oneof action { + Location location = 2; + } +} + +message KeepInChat { + optional KeepType keepType = 1; + optional int64 serverTimestamp = 2; + optional MessageKey key = 3; + optional string deviceJid = 4; +} + +enum KeepType { + UNKNOWN = 0; + KEEP_FOR_ALL = 1; + UNDO_KEEP_FOR_ALL = 2; +} +message KeyId { + optional bytes id = 1; +} + +message LocalizedName { + optional string lg = 1; + optional string lc = 2; + optional string verifiedName = 3; +} + +message Location { + optional double degreesLatitude = 1; + optional double degreesLongitude = 2; + optional string name = 3; +} + +message MediaData { + optional string localPath = 1; +} + +message MediaRetryNotification { + optional string stanzaId = 1; + optional string directPath = 2; + optional ResultType result = 3; + enum ResultType { + GENERAL_ERROR = 0; + SUCCESS = 1; + NOT_FOUND = 2; + DECRYPTION_ERROR = 3; + } +} + +enum MediaVisibility { + DEFAULT = 0; + OFF = 1; + ON = 2; +} +message Message { + optional string conversation = 1; + optional SenderKeyDistributionMessage senderKeyDistributionMessage = 2; + optional ImageMessage imageMessage = 3; + optional ContactMessage contactMessage = 4; + optional LocationMessage locationMessage = 5; + optional ExtendedTextMessage extendedTextMessage = 6; + optional DocumentMessage documentMessage = 7; + optional AudioMessage audioMessage = 8; + optional VideoMessage videoMessage = 9; + optional Call call = 10; + optional Chat chat = 11; + optional ProtocolMessage protocolMessage = 12; + optional ContactsArrayMessage contactsArrayMessage = 13; + optional HighlyStructuredMessage highlyStructuredMessage = 14; + optional SenderKeyDistributionMessage fastRatchetKeySenderKeyDistributionMessage = 15; + optional SendPaymentMessage sendPaymentMessage = 16; + optional LiveLocationMessage liveLocationMessage = 18; + optional RequestPaymentMessage requestPaymentMessage = 22; + optional DeclinePaymentRequestMessage declinePaymentRequestMessage = 23; + optional CancelPaymentRequestMessage cancelPaymentRequestMessage = 24; + optional TemplateMessage templateMessage = 25; + optional StickerMessage stickerMessage = 26; + optional GroupInviteMessage groupInviteMessage = 28; + optional TemplateButtonReplyMessage templateButtonReplyMessage = 29; + optional ProductMessage productMessage = 30; + optional DeviceSentMessage deviceSentMessage = 31; + optional MessageContextInfo messageContextInfo = 35; + optional ListMessage listMessage = 36; + optional FutureProofMessage viewOnceMessage = 37; + optional OrderMessage orderMessage = 38; + optional ListResponseMessage listResponseMessage = 39; + optional FutureProofMessage ephemeralMessage = 40; + optional InvoiceMessage invoiceMessage = 41; + optional ButtonsMessage buttonsMessage = 42; + optional ButtonsResponseMessage buttonsResponseMessage = 43; + optional PaymentInviteMessage paymentInviteMessage = 44; + optional InteractiveMessage interactiveMessage = 45; + optional ReactionMessage reactionMessage = 46; + optional StickerSyncRMRMessage stickerSyncRmrMessage = 47; + optional InteractiveResponseMessage interactiveResponseMessage = 48; + optional PollCreationMessage pollCreationMessage = 49; + optional PollUpdateMessage pollUpdateMessage = 50; + optional KeepInChatMessage keepInChatMessage = 51; + optional FutureProofMessage documentWithCaptionMessage = 53; + optional RequestPhoneNumberMessage requestPhoneNumberMessage = 54; + optional FutureProofMessage viewOnceMessageV2 = 55; + message AppStateFatalExceptionNotification { + repeated string collectionNames = 1; + optional int64 timestamp = 2; + } + + message AppStateSyncKeyData { + optional bytes keyData = 1; + optional Message.AppStateSyncKeyFingerprint fingerprint = 2; + optional int64 timestamp = 3; + } + + message AppStateSyncKeyFingerprint { + optional uint32 rawId = 1; + optional uint32 currentIndex = 2; + repeated uint32 deviceIndexes = 3 [packed=true]; + } + + message AppStateSyncKeyId { + optional bytes keyId = 1; + } + + message AppStateSyncKeyRequest { + repeated Message.AppStateSyncKeyId keyIds = 1; + } + + message AppStateSyncKeyShare { + repeated Message.AppStateSyncKey keys = 1; + } + + message AppStateSyncKey { + optional Message.AppStateSyncKeyId keyId = 1; + optional Message.AppStateSyncKeyData keyData = 2; + } + + message AudioMessage { + optional string url = 1; + optional string mimetype = 2; + optional bytes fileSha256 = 3; + optional uint64 fileLength = 4; + optional uint32 seconds = 5; + optional bool ptt = 6; + optional bytes mediaKey = 7; + optional bytes fileEncSha256 = 8; + optional string directPath = 9; + optional int64 mediaKeyTimestamp = 10; + optional ContextInfo contextInfo = 17; + optional bytes streamingSidecar = 18; + optional bytes waveform = 19; + } + + message ButtonsMessage { + optional string contentText = 6; + optional string footerText = 7; + optional ContextInfo contextInfo = 8; + repeated Button buttons = 9; + optional HeaderType headerType = 10; + oneof header { + string text = 1; + Message.DocumentMessage documentMessage = 2; + Message.ImageMessage imageMessage = 3; + Message.VideoMessage videoMessage = 4; + Message.LocationMessage locationMessage = 5; + } + message Button { + optional string buttonId = 1; + optional ButtonText buttonText = 2; + optional Type type = 3; + optional NativeFlowInfo nativeFlowInfo = 4; + message ButtonText { + optional string displayText = 1; + } + + message NativeFlowInfo { + optional string name = 1; + optional string paramsJson = 2; + } + + enum Type { + UNKNOWN = 0; + RESPONSE = 1; + NATIVE_FLOW = 2; + } + } + + enum HeaderType { + UNKNOWN = 0; + EMPTY = 1; + TEXT = 2; + DOCUMENT = 3; + IMAGE = 4; + VIDEO = 5; + LOCATION = 6; + } + } + + message ButtonsResponseMessage { + optional string selectedButtonId = 1; + optional ContextInfo contextInfo = 3; + optional Type type = 4; + oneof response { + string selectedDisplayText = 2; + } + enum Type { + UNKNOWN = 0; + DISPLAY_TEXT = 1; + } + } + + message Call { + optional bytes callKey = 1; + optional string conversionSource = 2; + optional bytes conversionData = 3; + optional uint32 conversionDelaySeconds = 4; + } + + message CancelPaymentRequestMessage { + optional MessageKey key = 1; + } + + message Chat { + optional string displayName = 1; + optional string id = 2; + } + + message ContactMessage { + optional string displayName = 1; + optional string vcard = 16; + optional ContextInfo contextInfo = 17; + } + + message ContactsArrayMessage { + optional string displayName = 1; + repeated Message.ContactMessage contacts = 2; + optional ContextInfo contextInfo = 17; + } + + message DeclinePaymentRequestMessage { + optional MessageKey key = 1; + } + + message DeviceSentMessage { + optional string destinationJid = 1; + optional Message message = 2; + optional string phash = 3; + } + + message DocumentMessage { + optional string url = 1; + optional string mimetype = 2; + optional string title = 3; + optional bytes fileSha256 = 4; + optional uint64 fileLength = 5; + optional uint32 pageCount = 6; + optional bytes mediaKey = 7; + optional string fileName = 8; + optional bytes fileEncSha256 = 9; + optional string directPath = 10; + optional int64 mediaKeyTimestamp = 11; + optional bool contactVcard = 12; + optional string thumbnailDirectPath = 13; + optional bytes thumbnailSha256 = 14; + optional bytes thumbnailEncSha256 = 15; + optional bytes jpegThumbnail = 16; + optional ContextInfo contextInfo = 17; + optional uint32 thumbnailHeight = 18; + optional uint32 thumbnailWidth = 19; + optional string caption = 20; + } + + message ExtendedTextMessage { + optional string text = 1; + optional string matchedText = 2; + optional string canonicalUrl = 4; + optional string description = 5; + optional string title = 6; + optional fixed32 textArgb = 7; + optional fixed32 backgroundArgb = 8; + optional FontType font = 9; + optional PreviewType previewType = 10; + optional bytes jpegThumbnail = 16; + optional ContextInfo contextInfo = 17; + optional bool doNotPlayInline = 18; + optional string thumbnailDirectPath = 19; + optional bytes thumbnailSha256 = 20; + optional bytes thumbnailEncSha256 = 21; + optional bytes mediaKey = 22; + optional int64 mediaKeyTimestamp = 23; + optional uint32 thumbnailHeight = 24; + optional uint32 thumbnailWidth = 25; + optional InviteLinkGroupType inviteLinkGroupType = 26; + optional string inviteLinkParentGroupSubjectV2 = 27; + optional bytes inviteLinkParentGroupThumbnailV2 = 28; + optional InviteLinkGroupType inviteLinkGroupTypeV2 = 29; + enum FontType { + SANS_SERIF = 0; + SERIF = 1; + NORICAN_REGULAR = 2; + BRYNDAN_WRITE = 3; + BEBASNEUE_REGULAR = 4; + OSWALD_HEAVY = 5; + } + enum InviteLinkGroupType { + DEFAULT = 0; + PARENT = 1; + SUB = 2; + DEFAULT_SUB = 3; + } + enum PreviewType { + NONE = 0; + VIDEO = 1; + } + } + + message FutureProofMessage { + optional Message message = 1; + } + + message GroupInviteMessage { + optional string groupJid = 1; + optional string inviteCode = 2; + optional int64 inviteExpiration = 3; + optional string groupName = 4; + optional bytes jpegThumbnail = 5; + optional string caption = 6; + optional ContextInfo contextInfo = 7; + optional GroupType groupType = 8; + enum GroupType { + DEFAULT = 0; + PARENT = 1; + } + } + + message HighlyStructuredMessage { + optional string namespace = 1; + optional string elementName = 2; + repeated string params = 3; + optional string fallbackLg = 4; + optional string fallbackLc = 5; + repeated HSMLocalizableParameter localizableParams = 6; + optional string deterministicLg = 7; + optional string deterministicLc = 8; + optional Message.TemplateMessage hydratedHsm = 9; + message HSMLocalizableParameter { + optional string default = 1; + oneof paramOneof { + Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency currency = 2; + Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime dateTime = 3; + } + message HSMCurrency { + optional string currencyCode = 1; + optional int64 amount1000 = 2; + } + + message HSMDateTime { + oneof datetimeOneof { + Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent component = 1; + Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch unixEpoch = 2; + } + message HSMDateTimeComponent { + optional DayOfWeekType dayOfWeek = 1; + optional uint32 year = 2; + optional uint32 month = 3; + optional uint32 dayOfMonth = 4; + optional uint32 hour = 5; + optional uint32 minute = 6; + optional CalendarType calendar = 7; + enum CalendarType { + GREGORIAN = 1; + SOLAR_HIJRI = 2; + } + enum DayOfWeekType { + MONDAY = 1; + TUESDAY = 2; + WEDNESDAY = 3; + THURSDAY = 4; + FRIDAY = 5; + SATURDAY = 6; + SUNDAY = 7; + } + } + + message HSMDateTimeUnixEpoch { + optional int64 timestamp = 1; + } + + } + + } + + } + + message HistorySyncNotification { + optional bytes fileSha256 = 1; + optional uint64 fileLength = 2; + optional bytes mediaKey = 3; + optional bytes fileEncSha256 = 4; + optional string directPath = 5; + optional HistorySyncType syncType = 6; + optional uint32 chunkOrder = 7; + optional string originalMessageId = 8; + optional uint32 progress = 9; + enum HistorySyncType { + INITIAL_BOOTSTRAP = 0; + INITIAL_STATUS_V3 = 1; + FULL = 2; + RECENT = 3; + PUSH_NAME = 4; + } + } + + message ImageMessage { + optional string url = 1; + optional string mimetype = 2; + optional string caption = 3; + optional bytes fileSha256 = 4; + optional uint64 fileLength = 5; + optional uint32 height = 6; + optional uint32 width = 7; + optional bytes mediaKey = 8; + optional bytes fileEncSha256 = 9; + repeated InteractiveAnnotation interactiveAnnotations = 10; + optional string directPath = 11; + optional int64 mediaKeyTimestamp = 12; + optional bytes jpegThumbnail = 16; + optional ContextInfo contextInfo = 17; + optional bytes firstScanSidecar = 18; + optional uint32 firstScanLength = 19; + optional uint32 experimentGroupId = 20; + optional bytes scansSidecar = 21; + repeated uint32 scanLengths = 22; + optional bytes midQualityFileSha256 = 23; + optional bytes midQualityFileEncSha256 = 24; + optional bool viewOnce = 25; + optional string thumbnailDirectPath = 26; + optional bytes thumbnailSha256 = 27; + optional bytes thumbnailEncSha256 = 28; + optional string staticUrl = 29; + } + + message InitialSecurityNotificationSettingSync { + optional bool securityNotificationEnabled = 1; + } + + message InteractiveMessage { + optional Header header = 1; + optional Body body = 2; + optional Footer footer = 3; + optional ContextInfo contextInfo = 15; + oneof interactiveMessage { + Message.InteractiveMessage.ShopMessage shopStorefrontMessage = 4; + Message.InteractiveMessage.CollectionMessage collectionMessage = 5; + Message.InteractiveMessage.NativeFlowMessage nativeFlowMessage = 6; + } + message Body { + optional string text = 1; + } + + message CollectionMessage { + optional string bizJid = 1; + optional string id = 2; + optional int32 messageVersion = 3; + } + + message Footer { + optional string text = 1; + } + + message Header { + optional string title = 1; + optional string subtitle = 2; + optional bool hasMediaAttachment = 5; + oneof media { + Message.DocumentMessage documentMessage = 3; + Message.ImageMessage imageMessage = 4; + bytes jpegThumbnail = 6; + Message.VideoMessage videoMessage = 7; + } + } + + message NativeFlowMessage { + repeated NativeFlowButton buttons = 1; + optional string messageParamsJson = 2; + optional int32 messageVersion = 3; + message NativeFlowButton { + optional string name = 1; + optional string buttonParamsJson = 2; + } + + } + + message ShopMessage { + optional string id = 1; + optional Surface surface = 2; + optional int32 messageVersion = 3; + enum Surface { + UNKNOWN_SURFACE = 0; + FB = 1; + IG = 2; + WA = 3; + } + } + + } + + message InteractiveResponseMessage { + optional Body body = 1; + optional ContextInfo contextInfo = 15; + oneof interactiveResponseMessage { + Message.InteractiveResponseMessage.NativeFlowResponseMessage nativeFlowResponseMessage = 2; + } + message Body { + optional string text = 1; + } + + message NativeFlowResponseMessage { + optional string name = 1; + optional string paramsJson = 2; + optional int32 version = 3; + } + + } + + message InvoiceMessage { + optional string note = 1; + optional string token = 2; + optional AttachmentType attachmentType = 3; + optional string attachmentMimetype = 4; + optional bytes attachmentMediaKey = 5; + optional int64 attachmentMediaKeyTimestamp = 6; + optional bytes attachmentFileSha256 = 7; + optional bytes attachmentFileEncSha256 = 8; + optional string attachmentDirectPath = 9; + optional bytes attachmentJpegThumbnail = 10; + enum AttachmentType { + IMAGE = 0; + PDF = 1; + } + } + + message KeepInChatMessage { + optional MessageKey key = 1; + optional KeepType keepType = 2; + optional int64 timestampMs = 3; + } + + message ListMessage { + optional string title = 1; + optional string description = 2; + optional string buttonText = 3; + optional ListType listType = 4; + repeated Section sections = 5; + optional ProductListInfo productListInfo = 6; + optional string footerText = 7; + optional ContextInfo contextInfo = 8; + enum ListType { + UNKNOWN = 0; + SINGLE_SELECT = 1; + PRODUCT_LIST = 2; + } + message ProductListHeaderImage { + optional string productId = 1; + optional bytes jpegThumbnail = 2; + } + + message ProductListInfo { + repeated Message.ListMessage.ProductSection productSections = 1; + optional Message.ListMessage.ProductListHeaderImage headerImage = 2; + optional string businessOwnerJid = 3; + } + + message ProductSection { + optional string title = 1; + repeated Message.ListMessage.Product products = 2; + } + + message Product { + optional string productId = 1; + } + + message Row { + optional string title = 1; + optional string description = 2; + optional string rowId = 3; + } + + message Section { + optional string title = 1; + repeated Message.ListMessage.Row rows = 2; + } + + } + + message ListResponseMessage { + optional string title = 1; + optional ListType listType = 2; + optional SingleSelectReply singleSelectReply = 3; + optional ContextInfo contextInfo = 4; + optional string description = 5; + enum ListType { + UNKNOWN = 0; + SINGLE_SELECT = 1; + } + message SingleSelectReply { + optional string selectedRowId = 1; + } + + } + + message LiveLocationMessage { + optional double degreesLatitude = 1; + optional double degreesLongitude = 2; + optional uint32 accuracyInMeters = 3; + optional float speedInMps = 4; + optional uint32 degreesClockwiseFromMagneticNorth = 5; + optional string caption = 6; + optional int64 sequenceNumber = 7; + optional uint32 timeOffset = 8; + optional bytes jpegThumbnail = 16; + optional ContextInfo contextInfo = 17; + } + + message LocationMessage { + optional double degreesLatitude = 1; + optional double degreesLongitude = 2; + optional string name = 3; + optional string address = 4; + optional string url = 5; + optional bool isLive = 6; + optional uint32 accuracyInMeters = 7; + optional float speedInMps = 8; + optional uint32 degreesClockwiseFromMagneticNorth = 9; + optional string comment = 11; + optional bytes jpegThumbnail = 16; + optional ContextInfo contextInfo = 17; + } + + message OrderMessage { + optional string orderId = 1; + optional bytes thumbnail = 2; + optional int32 itemCount = 3; + optional OrderStatus status = 4; + optional OrderSurface surface = 5; + optional string message = 6; + optional string orderTitle = 7; + optional string sellerJid = 8; + optional string token = 9; + optional int64 totalAmount1000 = 10; + optional string totalCurrencyCode = 11; + optional ContextInfo contextInfo = 17; + enum OrderStatus { + INQUIRY = 1; + } + enum OrderSurface { + CATALOG = 1; + } + } + + message PaymentInviteMessage { + optional ServiceType serviceType = 1; + optional int64 expiryTimestamp = 2; + enum ServiceType { + UNKNOWN = 0; + FBPAY = 1; + NOVI = 2; + UPI = 3; + } + } + + message PollCreationMessage { + optional bytes encKey = 1; + optional string name = 2; + repeated Option options = 3; + optional uint32 selectableOptionsCount = 4; + optional ContextInfo contextInfo = 5; + message Option { + optional string optionName = 1; + } + + } + + message PollEncValue { + optional bytes encPayload = 1; + optional bytes encIv = 2; + } + + message PollUpdateMessageMetadata { + } + + message PollUpdateMessage { + optional MessageKey pollCreationMessageKey = 1; + optional Message.PollEncValue vote = 2; + optional Message.PollUpdateMessageMetadata metadata = 3; + optional int64 senderTimestampMs = 4; + } + + message PollVoteMessage { + repeated bytes selectedOptions = 1; + } + + message ProductMessage { + optional ProductSnapshot product = 1; + optional string businessOwnerJid = 2; + optional CatalogSnapshot catalog = 4; + optional string body = 5; + optional string footer = 6; + optional ContextInfo contextInfo = 17; + message CatalogSnapshot { + optional Message.ImageMessage catalogImage = 1; + optional string title = 2; + optional string description = 3; + } + + message ProductSnapshot { + optional Message.ImageMessage productImage = 1; + optional string productId = 2; + optional string title = 3; + optional string description = 4; + optional string currencyCode = 5; + optional int64 priceAmount1000 = 6; + optional string retailerId = 7; + optional string url = 8; + optional uint32 productImageCount = 9; + optional string firstImageId = 11; + optional int64 salePriceAmount1000 = 12; + } + + } + + message ProtocolMessage { + optional MessageKey key = 1; + optional Type type = 2; + optional uint32 ephemeralExpiration = 4; + optional int64 ephemeralSettingTimestamp = 5; + optional Message.HistorySyncNotification historySyncNotification = 6; + optional Message.AppStateSyncKeyShare appStateSyncKeyShare = 7; + optional Message.AppStateSyncKeyRequest appStateSyncKeyRequest = 8; + optional Message.InitialSecurityNotificationSettingSync initialSecurityNotificationSettingSync = 9; + optional Message.AppStateFatalExceptionNotification appStateFatalExceptionNotification = 10; + optional DisappearingMode disappearingMode = 11; + optional Message.RequestMediaUploadMessage requestMediaUploadMessage = 12; + optional Message.RequestMediaUploadResponseMessage requestMediaUploadResponseMessage = 13; + enum Type { + REVOKE = 0; + EPHEMERAL_SETTING = 3; + EPHEMERAL_SYNC_RESPONSE = 4; + HISTORY_SYNC_NOTIFICATION = 5; + APP_STATE_SYNC_KEY_SHARE = 6; + APP_STATE_SYNC_KEY_REQUEST = 7; + MSG_FANOUT_BACKFILL_REQUEST = 8; + INITIAL_SECURITY_NOTIFICATION_SETTING_SYNC = 9; + APP_STATE_FATAL_EXCEPTION_NOTIFICATION = 10; + SHARE_PHONE_NUMBER = 11; + REQUEST_MEDIA_UPLOAD_MESSAGE = 12; + REQUEST_MEDIA_UPLOAD_RESPONSE_MESSAGE = 13; + } + } + + message ReactionMessage { + optional MessageKey key = 1; + optional string text = 2; + optional string groupingKey = 3; + optional int64 senderTimestampMs = 4; + } + + message RequestMediaUploadMessage { + repeated string fileSha256 = 1; + optional Message.RmrSource rmrSource = 2; + } + + message RequestMediaUploadResponseMessage { + optional Message.RmrSource rmrSource = 1; + optional string stanzaId = 2; + repeated RequestMediaUploadResult reuploadResult = 3; + message RequestMediaUploadResult { + optional string fileSha256 = 1; + optional MediaRetryNotification.ResultType mediaUploadResult = 2; + optional Message.StickerMessage stickerMessage = 3; + } + + } + + message RequestPaymentMessage { + optional Message noteMessage = 4; + optional string currencyCodeIso4217 = 1; + optional uint64 amount1000 = 2; + optional string requestFrom = 3; + optional int64 expiryTimestamp = 5; + optional Money amount = 6; + optional PaymentBackground background = 7; + } + + message RequestPhoneNumberMessage { + optional ContextInfo contextInfo = 1; + } + + enum RmrSource { + FAVORITE_STICKER = 0; + RECENT_STICKER = 1; + } + message SendPaymentMessage { + optional Message noteMessage = 2; + optional MessageKey requestMessageKey = 3; + optional PaymentBackground background = 4; + } + + message SenderKeyDistributionMessage { + optional string groupId = 1; + optional bytes axolotlSenderKeyDistributionMessage = 2; + } + + message StickerMessage { + optional string url = 1; + optional bytes fileSha256 = 2; + optional bytes fileEncSha256 = 3; + optional bytes mediaKey = 4; + optional string mimetype = 5; + optional uint32 height = 6; + optional uint32 width = 7; + optional string directPath = 8; + optional uint64 fileLength = 9; + optional int64 mediaKeyTimestamp = 10; + optional uint32 firstFrameLength = 11; + optional bytes firstFrameSidecar = 12; + optional bool isAnimated = 13; + optional bytes pngThumbnail = 16; + optional ContextInfo contextInfo = 17; + } + + message StickerSyncRMRMessage { + repeated string filehash = 1; + optional string rmrSource = 2; + optional int64 requestTimestamp = 3; + } + + message TemplateButtonReplyMessage { + optional string selectedId = 1; + optional string selectedDisplayText = 2; + optional ContextInfo contextInfo = 3; + optional uint32 selectedIndex = 4; + } + + message TemplateMessage { + optional ContextInfo contextInfo = 3; + optional HydratedFourRowTemplate hydratedTemplate = 4; + oneof format { + Message.TemplateMessage.FourRowTemplate fourRowTemplate = 1; + Message.TemplateMessage.HydratedFourRowTemplate hydratedFourRowTemplate = 2; + } + message FourRowTemplate { + optional Message.HighlyStructuredMessage content = 6; + optional Message.HighlyStructuredMessage footer = 7; + repeated TemplateButton buttons = 8; + oneof title { + Message.DocumentMessage documentMessage = 1; + Message.HighlyStructuredMessage highlyStructuredMessage = 2; + Message.ImageMessage imageMessage = 3; + Message.VideoMessage videoMessage = 4; + Message.LocationMessage locationMessage = 5; + } + } + + message HydratedFourRowTemplate { + optional string hydratedContentText = 6; + optional string hydratedFooterText = 7; + repeated HydratedTemplateButton hydratedButtons = 8; + optional string templateId = 9; + oneof title { + Message.DocumentMessage documentMessage = 1; + string hydratedTitleText = 2; + Message.ImageMessage imageMessage = 3; + Message.VideoMessage videoMessage = 4; + Message.LocationMessage locationMessage = 5; + } + } + + } + + message VideoMessage { + optional string url = 1; + optional string mimetype = 2; + optional bytes fileSha256 = 3; + optional uint64 fileLength = 4; + optional uint32 seconds = 5; + optional bytes mediaKey = 6; + optional string caption = 7; + optional bool gifPlayback = 8; + optional uint32 height = 9; + optional uint32 width = 10; + optional bytes fileEncSha256 = 11; + repeated InteractiveAnnotation interactiveAnnotations = 12; + optional string directPath = 13; + optional int64 mediaKeyTimestamp = 14; + optional bytes jpegThumbnail = 16; + optional ContextInfo contextInfo = 17; + optional bytes streamingSidecar = 18; + optional Attribution gifAttribution = 19; + optional bool viewOnce = 20; + optional string thumbnailDirectPath = 21; + optional bytes thumbnailSha256 = 22; + optional bytes thumbnailEncSha256 = 23; + optional string staticUrl = 24; + enum Attribution { + NONE = 0; + GIPHY = 1; + TENOR = 2; + } + } + +} + +message MessageContextInfo { + optional DeviceListMetadata deviceListMetadata = 1; + optional int32 deviceListMetadataVersion = 2; + optional bytes messageSecret = 3; + optional bytes paddingBytes = 4; +} + +message MessageKey { + optional string remoteJid = 1; + optional bool fromMe = 2; + optional string id = 3; + optional string participant = 4; +} + +message Money { + optional int64 value = 1; + optional uint32 offset = 2; + optional string currencyCode = 3; +} + +message MsgOpaqueData { + optional string body = 1; + optional string caption = 3; + optional double lng = 5; + optional bool isLive = 6; + optional double lat = 7; + optional int32 paymentAmount1000 = 8; + optional string paymentNoteMsgBody = 9; + optional string canonicalUrl = 10; + optional string matchedText = 11; + optional string title = 12; + optional string description = 13; + optional bytes futureproofBuffer = 14; + optional string clientUrl = 15; + optional string loc = 16; + optional string pollName = 17; + repeated PollOption pollOptions = 18; + optional uint32 pollSelectableOptionsCount = 20; + optional bytes messageSecret = 21; + optional int64 senderTimestampMs = 22; + optional string pollUpdateParentKey = 23; + optional PollEncValue encPollVote = 24; + message PollOption { + optional string name = 1; + } + +} + +message MsgRowOpaqueData { + optional MsgOpaqueData currentMsg = 1; + optional MsgOpaqueData quotedMsg = 2; +} + +message NoiseCertificate { + optional bytes details = 1; + optional bytes signature = 2; + message Details { + optional uint32 serial = 1; + optional string issuer = 2; + optional uint64 expires = 3; + optional string subject = 4; + optional bytes key = 5; + } + +} + +message NotificationMessageInfo { + optional MessageKey key = 1; + optional Message message = 2; + optional uint64 messageTimestamp = 3; + optional string participant = 4; +} + +message PastParticipant { + required string userJid = 1; + required LeaveReason leaveReason = 2; + required uint64 leaveTs = 3; + enum LeaveReason { + LEFT = 0; + REMOVED = 1; + } +} + +message PastParticipants { + required string groupJid = 1; + repeated PastParticipant pastParticipants = 2; +} + +message PaymentBackground { + optional string id = 1; + optional uint64 fileLength = 2; + optional uint32 width = 3; + optional uint32 height = 4; + optional string mimetype = 5; + optional fixed32 placeholderArgb = 6; + optional fixed32 textArgb = 7; + optional fixed32 subtextArgb = 8; + optional MediaData mediaData = 9; + optional Type type = 10; + message MediaData { + optional bytes mediaKey = 1; + optional int64 mediaKeyTimestamp = 2; + optional bytes fileSha256 = 3; + optional bytes fileEncSha256 = 4; + optional string directPath = 5; + } + + enum Type { + UNKNOWN = 0; + DEFAULT = 1; + } +} + +message PaymentInfo { + optional Currency currencyDeprecated = 1; + optional uint64 amount1000 = 2; + optional string receiverJid = 3; + optional Status status = 4; + optional uint64 transactionTimestamp = 5; + optional MessageKey requestMessageKey = 6; + optional uint64 expiryTimestamp = 7; + optional bool futureproofed = 8; + optional string currency = 9; + optional TxnStatus txnStatus = 10; + optional bool useNoviFiatFormat = 11; + optional Money primaryAmount = 12; + optional Money exchangeAmount = 13; + enum Currency { + UNKNOWN_CURRENCY = 0; + INR = 1; + } + enum Status { + UNKNOWN_STATUS = 0; + PROCESSING = 1; + SENT = 2; + NEED_TO_ACCEPT = 3; + COMPLETE = 4; + COULD_NOT_COMPLETE = 5; + REFUNDED = 6; + EXPIRED = 7; + REJECTED = 8; + CANCELLED = 9; + WAITING_FOR_PAYER = 10; + WAITING = 11; + } + enum TxnStatus { + UNKNOWN = 0; + PENDING_SETUP = 1; + PENDING_RECEIVER_SETUP = 2; + INIT = 3; + SUCCESS = 4; + COMPLETED = 5; + FAILED = 6; + FAILED_RISK = 7; + FAILED_PROCESSING = 8; + FAILED_RECEIVER_PROCESSING = 9; + FAILED_DA = 10; + FAILED_DA_FINAL = 11; + REFUNDED_TXN = 12; + REFUND_FAILED = 13; + REFUND_FAILED_PROCESSING = 14; + REFUND_FAILED_DA = 15; + EXPIRED_TXN = 16; + AUTH_CANCELED = 17; + AUTH_CANCEL_FAILED_PROCESSING = 18; + AUTH_CANCEL_FAILED = 19; + COLLECT_INIT = 20; + COLLECT_SUCCESS = 21; + COLLECT_FAILED = 22; + COLLECT_FAILED_RISK = 23; + COLLECT_REJECTED = 24; + COLLECT_EXPIRED = 25; + COLLECT_CANCELED = 26; + COLLECT_CANCELLING = 27; + IN_REVIEW = 28; + REVERSAL_SUCCESS = 29; + REVERSAL_PENDING = 30; + REFUND_PENDING = 31; + } +} + +message PendingKeyExchange { + optional uint32 sequence = 1; + optional bytes localBaseKey = 2; + optional bytes localBaseKeyPrivate = 3; + optional bytes localRatchetKey = 4; + optional bytes localRatchetKeyPrivate = 5; + optional bytes localIdentityKey = 7; + optional bytes localIdentityKeyPrivate = 8; +} + +message PendingPreKey { + optional uint32 preKeyId = 1; + optional int32 signedPreKeyId = 3; + optional bytes baseKey = 2; +} + +message PhotoChange { + optional bytes oldPhoto = 1; + optional bytes newPhoto = 2; + optional uint32 newPhotoId = 3; +} + +message Point { + optional int32 xDeprecated = 1; + optional int32 yDeprecated = 2; + optional double x = 3; + optional double y = 4; +} + +message PollAdditionalMetadata { + optional bool pollInvalidated = 1; +} + +message PollEncValue { + optional bytes encPayload = 1; + optional bytes encIv = 2; +} + +message PollUpdate { + optional MessageKey pollUpdateMessageKey = 1; + optional Message.PollVoteMessage vote = 2; + optional int64 senderTimestampMs = 3; +} + +message PreKeyRecordStructure { + optional uint32 id = 1; + optional bytes publicKey = 2; + optional bytes privateKey = 3; +} + +message Pushname { + optional string id = 1; + optional string pushname = 2; +} + +message Reaction { + optional MessageKey key = 1; + optional string text = 2; + optional string groupingKey = 3; + optional int64 senderTimestampMs = 4; + optional bool unread = 5; +} + +message RecentEmojiWeight { + optional string emoji = 1; + optional float weight = 2; +} + +message RecordStructure { + optional SessionStructure currentSession = 1; + repeated SessionStructure previousSessions = 2; +} + +message SenderChainKey { + optional uint32 iteration = 1; + optional bytes seed = 2; +} + +message SenderKeyRecordStructure { + repeated SenderKeyStateStructure senderKeyStates = 1; +} + +message SenderKeyStateStructure { + optional uint32 senderKeyId = 1; + optional SenderChainKey senderChainKey = 2; + optional SenderSigningKey senderSigningKey = 3; + repeated SenderMessageKey senderMessageKeys = 4; +} + +message SenderMessageKey { + optional uint32 iteration = 1; + optional bytes seed = 2; +} + +message SenderSigningKey { + optional bytes public = 1; + optional bytes private = 2; +} + +message ServerErrorReceipt { + optional string stanzaId = 1; +} + +message SessionStructure { + optional uint32 sessionVersion = 1; + optional bytes localIdentityPublic = 2; + optional bytes remoteIdentityPublic = 3; + optional bytes rootKey = 4; + optional uint32 previousCounter = 5; + optional Chain senderChain = 6; + repeated Chain receiverChains = 7; + optional PendingKeyExchange pendingKeyExchange = 8; + optional PendingPreKey pendingPreKey = 9; + optional uint32 remoteRegistrationId = 10; + optional uint32 localRegistrationId = 11; + optional bool needsRefresh = 12; + optional bytes aliceBaseKey = 13; +} + +message SignedPreKeyRecordStructure { + optional uint32 id = 1; + optional bytes publicKey = 2; + optional bytes privateKey = 3; + optional bytes signature = 4; + optional fixed64 timestamp = 5; +} + +message StatusPSA { + required uint64 campaignId = 44; + optional uint64 campaignExpirationTimestamp = 45; +} + +message StickerMetadata { + optional string url = 1; + optional bytes fileSha256 = 2; + optional bytes fileEncSha256 = 3; + optional bytes mediaKey = 4; + optional string mimetype = 5; + optional uint32 height = 6; + optional uint32 width = 7; + optional string directPath = 8; + optional uint64 fileLength = 9; + optional float weight = 10; +} + +message SyncActionData { + optional bytes index = 1; + optional SyncActionValue value = 2; + optional bytes padding = 3; + optional int32 version = 4; +} + +message SyncActionValue { + optional int64 timestamp = 1; + optional StarAction starAction = 2; + optional ContactAction contactAction = 3; + optional MuteAction muteAction = 4; + optional PinAction pinAction = 5; + optional SecurityNotificationSetting securityNotificationSetting = 6; + optional PushNameSetting pushNameSetting = 7; + optional QuickReplyAction quickReplyAction = 8; + optional RecentEmojiWeightsAction recentEmojiWeightsAction = 11; + optional LabelEditAction labelEditAction = 14; + optional LabelAssociationAction labelAssociationAction = 15; + optional LocaleSetting localeSetting = 16; + optional ArchiveChatAction archiveChatAction = 17; + optional DeleteMessageForMeAction deleteMessageForMeAction = 18; + optional KeyExpiration keyExpiration = 19; + optional MarkChatAsReadAction markChatAsReadAction = 20; + optional ClearChatAction clearChatAction = 21; + optional DeleteChatAction deleteChatAction = 22; + optional UnarchiveChatsSetting unarchiveChatsSetting = 23; + optional PrimaryFeature primaryFeature = 24; + optional AndroidUnsupportedActions androidUnsupportedActions = 26; + optional AgentAction agentAction = 27; + optional SubscriptionAction subscriptionAction = 28; + optional UserStatusMuteAction userStatusMuteAction = 29; + optional TimeFormatAction timeFormatAction = 30; + optional NuxAction nuxAction = 31; + optional PrimaryVersionAction primaryVersionAction = 32; + optional StickerAction stickerAction = 33; + message AgentAction { + optional string name = 1; + optional int32 deviceID = 2; + optional bool isDeleted = 3; + } + + message AndroidUnsupportedActions { + optional bool allowed = 1; + } + + message ArchiveChatAction { + optional bool archived = 1; + optional SyncActionValue.SyncActionMessageRange messageRange = 2; + } + + message ClearChatAction { + optional SyncActionValue.SyncActionMessageRange messageRange = 1; + } + + message ContactAction { + optional string fullName = 1; + optional string firstName = 2; + } + + message DeleteChatAction { + optional SyncActionValue.SyncActionMessageRange messageRange = 1; + } + + message DeleteMessageForMeAction { + optional bool deleteMedia = 1; + optional int64 messageTimestamp = 2; + } + + message KeyExpiration { + optional int32 expiredKeyEpoch = 1; + } + + message LabelAssociationAction { + optional bool labeled = 1; + } + + message LabelEditAction { + optional string name = 1; + optional int32 color = 2; + optional int32 predefinedId = 3; + optional bool deleted = 4; + } + + message LocaleSetting { + optional string locale = 1; + } + + message MarkChatAsReadAction { + optional bool read = 1; + optional SyncActionValue.SyncActionMessageRange messageRange = 2; + } + + message MuteAction { + optional bool muted = 1; + optional int64 muteEndTimestamp = 2; + } + + message NuxAction { + optional bool acknowledged = 1; + } + + message PinAction { + optional bool pinned = 1; + } + + message PrimaryFeature { + repeated string flags = 1; + } + + message PrimaryVersionAction { + optional string version = 1; + } + + message PushNameSetting { + optional string name = 1; + } + + message QuickReplyAction { + optional string shortcut = 1; + optional string message = 2; + repeated string keywords = 3; + optional int32 count = 4; + optional bool deleted = 5; + } + + message RecentEmojiWeightsAction { + repeated RecentEmojiWeight weights = 1; + } + + message SecurityNotificationSetting { + optional bool showNotification = 1; + } + + message StarAction { + optional bool starred = 1; + } + + message StickerAction { + optional string url = 1; + optional bytes fileEncSha256 = 2; + optional bytes mediaKey = 3; + optional string mimetype = 4; + optional uint32 height = 5; + optional uint32 width = 6; + optional string directPath = 7; + optional uint64 fileLength = 8; + optional bool isFavorite = 9; + optional uint32 deviceIdHint = 10; + } + + message SubscriptionAction { + optional bool isDeactivated = 1; + optional bool isAutoRenewing = 2; + optional int64 expirationDate = 3; + } + + message SyncActionMessageRange { + optional int64 lastMessageTimestamp = 1; + optional int64 lastSystemMessageTimestamp = 2; + repeated SyncActionValue.SyncActionMessage messages = 3; + } + + message SyncActionMessage { + optional MessageKey key = 1; + optional int64 timestamp = 2; + } + + message TimeFormatAction { + optional bool isTwentyFourHourFormatEnabled = 1; + } + + message UnarchiveChatsSetting { + optional bool unarchiveChats = 1; + } + + message UserStatusMuteAction { + optional bool muted = 1; + } + +} + +message SyncdIndex { + optional bytes blob = 1; +} + +message SyncdMutation { + optional SyncdOperation operation = 1; + optional SyncdRecord record = 2; + enum SyncdOperation { + SET = 0; + REMOVE = 1; + } +} + +message SyncdMutations { + repeated SyncdMutation mutations = 1; +} + +message SyncdPatch { + optional SyncdVersion version = 1; + repeated SyncdMutation mutations = 2; + optional ExternalBlobReference externalMutations = 3; + optional bytes snapshotMac = 4; + optional bytes patchMac = 5; + optional KeyId keyId = 6; + optional ExitCode exitCode = 7; + optional uint32 deviceIndex = 8; +} + +message SyncdRecord { + optional SyncdIndex index = 1; + optional SyncdValue value = 2; + optional KeyId keyId = 3; +} + +message SyncdSnapshot { + optional SyncdVersion version = 1; + repeated SyncdRecord records = 2; + optional bytes mac = 3; + optional KeyId keyId = 4; +} + +message SyncdValue { + optional bytes blob = 1; +} + +message SyncdVersion { + optional uint64 version = 1; +} + +message TemplateButton { + optional uint32 index = 4; + oneof button { + TemplateButton.QuickReplyButton quickReplyButton = 1; + TemplateButton.URLButton urlButton = 2; + TemplateButton.CallButton callButton = 3; + } + message CallButton { + optional Message.HighlyStructuredMessage displayText = 1; + optional Message.HighlyStructuredMessage phoneNumber = 2; + } + + message QuickReplyButton { + optional Message.HighlyStructuredMessage displayText = 1; + optional string id = 2; + } + + message URLButton { + optional Message.HighlyStructuredMessage displayText = 1; + optional Message.HighlyStructuredMessage url = 2; + } + +} + +message UserReceipt { + required string userJid = 1; + optional int64 receiptTimestamp = 2; + optional int64 readTimestamp = 3; + optional int64 playedTimestamp = 4; + repeated string pendingDeviceJid = 5; + repeated string deliveredDeviceJid = 6; +} + +message VerifiedNameCertificate { + optional bytes details = 1; + optional bytes signature = 2; + optional bytes serverSignature = 3; + message Details { + optional uint64 serial = 1; + optional string issuer = 2; + optional string verifiedName = 4; + repeated LocalizedName localizedNames = 8; + optional uint64 issueTime = 10; + } + +} + +message WallpaperSettings { + optional string filename = 1; + optional uint32 opacity = 2; +} + +message WebFeatures { + optional Flag labelsDisplay = 1; + optional Flag voipIndividualOutgoing = 2; + optional Flag groupsV3 = 3; + optional Flag groupsV3Create = 4; + optional Flag changeNumberV2 = 5; + optional Flag queryStatusV3Thumbnail = 6; + optional Flag liveLocations = 7; + optional Flag queryVname = 8; + optional Flag voipIndividualIncoming = 9; + optional Flag quickRepliesQuery = 10; + optional Flag payments = 11; + optional Flag stickerPackQuery = 12; + optional Flag liveLocationsFinal = 13; + optional Flag labelsEdit = 14; + optional Flag mediaUpload = 15; + optional Flag mediaUploadRichQuickReplies = 18; + optional Flag vnameV2 = 19; + optional Flag videoPlaybackUrl = 20; + optional Flag statusRanking = 21; + optional Flag voipIndividualVideo = 22; + optional Flag thirdPartyStickers = 23; + optional Flag frequentlyForwardedSetting = 24; + optional Flag groupsV4JoinPermission = 25; + optional Flag recentStickers = 26; + optional Flag catalog = 27; + optional Flag starredStickers = 28; + optional Flag voipGroupCall = 29; + optional Flag templateMessage = 30; + optional Flag templateMessageInteractivity = 31; + optional Flag ephemeralMessages = 32; + optional Flag e2ENotificationSync = 33; + optional Flag recentStickersV2 = 34; + optional Flag recentStickersV3 = 36; + optional Flag userNotice = 37; + optional Flag support = 39; + optional Flag groupUiiCleanup = 40; + optional Flag groupDogfoodingInternalOnly = 41; + optional Flag settingsSync = 42; + optional Flag archiveV2 = 43; + optional Flag ephemeralAllowGroupMembers = 44; + optional Flag ephemeral24HDuration = 45; + optional Flag mdForceUpgrade = 46; + optional Flag disappearingMode = 47; + optional Flag externalMdOptInAvailable = 48; + optional Flag noDeleteMessageTimeLimit = 49; + enum Flag { + NOT_STARTED = 0; + FORCE_UPGRADE = 1; + DEVELOPMENT = 2; + PRODUCTION = 3; + } +} + +message WebMessageInfo { + required MessageKey key = 1; + optional Message message = 2; + optional uint64 messageTimestamp = 3; + optional Status status = 4; + optional string participant = 5; + optional uint64 messageC2STimestamp = 6; + optional bool ignore = 16; + optional bool starred = 17; + optional bool broadcast = 18; + optional string pushName = 19; + optional bytes mediaCiphertextSha256 = 20; + optional bool multicast = 21; + optional bool urlText = 22; + optional bool urlNumber = 23; + optional StubType messageStubType = 24; + optional bool clearMedia = 25; + repeated string messageStubParameters = 26; + optional uint32 duration = 27; + repeated string labels = 28; + optional PaymentInfo paymentInfo = 29; + optional Message.LiveLocationMessage finalLiveLocation = 30; + optional PaymentInfo quotedPaymentInfo = 31; + optional uint64 ephemeralStartTimestamp = 32; + optional uint32 ephemeralDuration = 33; + optional bool ephemeralOffToOn = 34; + optional bool ephemeralOutOfSync = 35; + optional BizPrivacyStatus bizPrivacyStatus = 36; + optional string verifiedBizName = 37; + optional MediaData mediaData = 38; + optional PhotoChange photoChange = 39; + repeated UserReceipt userReceipt = 40; + repeated Reaction reactions = 41; + optional MediaData quotedStickerData = 42; + optional bytes futureproofData = 43; + optional StatusPSA statusPsa = 44; + repeated PollUpdate pollUpdates = 45; + optional PollAdditionalMetadata pollAdditionalMetadata = 46; + optional string agentId = 47; + optional bool statusAlreadyViewed = 48; + optional bytes messageSecret = 49; + optional KeepInChat keepInChat = 50; + optional string originalSelfAuthorUserJidString = 51; + optional uint64 revokeMessageTimestamp = 52; + enum BizPrivacyStatus { + E2EE = 0; + FB = 2; + BSP = 1; + BSP_AND_FB = 3; + } + enum Status { + ERROR = 0; + PENDING = 1; + SERVER_ACK = 2; + DELIVERY_ACK = 3; + READ = 4; + PLAYED = 5; + } + enum StubType { + UNKNOWN = 0; + REVOKE = 1; + CIPHERTEXT = 2; + FUTUREPROOF = 3; + NON_VERIFIED_TRANSITION = 4; + UNVERIFIED_TRANSITION = 5; + VERIFIED_TRANSITION = 6; + VERIFIED_LOW_UNKNOWN = 7; + VERIFIED_HIGH = 8; + VERIFIED_INITIAL_UNKNOWN = 9; + VERIFIED_INITIAL_LOW = 10; + VERIFIED_INITIAL_HIGH = 11; + VERIFIED_TRANSITION_ANY_TO_NONE = 12; + VERIFIED_TRANSITION_ANY_TO_HIGH = 13; + VERIFIED_TRANSITION_HIGH_TO_LOW = 14; + VERIFIED_TRANSITION_HIGH_TO_UNKNOWN = 15; + VERIFIED_TRANSITION_UNKNOWN_TO_LOW = 16; + VERIFIED_TRANSITION_LOW_TO_UNKNOWN = 17; + VERIFIED_TRANSITION_NONE_TO_LOW = 18; + VERIFIED_TRANSITION_NONE_TO_UNKNOWN = 19; + GROUP_CREATE = 20; + GROUP_CHANGE_SUBJECT = 21; + GROUP_CHANGE_ICON = 22; + GROUP_CHANGE_INVITE_LINK = 23; + GROUP_CHANGE_DESCRIPTION = 24; + GROUP_CHANGE_RESTRICT = 25; + GROUP_CHANGE_ANNOUNCE = 26; + GROUP_PARTICIPANT_ADD = 27; + GROUP_PARTICIPANT_REMOVE = 28; + GROUP_PARTICIPANT_PROMOTE = 29; + GROUP_PARTICIPANT_DEMOTE = 30; + GROUP_PARTICIPANT_INVITE = 31; + GROUP_PARTICIPANT_LEAVE = 32; + GROUP_PARTICIPANT_CHANGE_NUMBER = 33; + BROADCAST_CREATE = 34; + BROADCAST_ADD = 35; + BROADCAST_REMOVE = 36; + GENERIC_NOTIFICATION = 37; + E2E_IDENTITY_CHANGED = 38; + E2E_ENCRYPTED = 39; + CALL_MISSED_VOICE = 40; + CALL_MISSED_VIDEO = 41; + INDIVIDUAL_CHANGE_NUMBER = 42; + GROUP_DELETE = 43; + GROUP_ANNOUNCE_MODE_MESSAGE_BOUNCE = 44; + CALL_MISSED_GROUP_VOICE = 45; + CALL_MISSED_GROUP_VIDEO = 46; + PAYMENT_CIPHERTEXT = 47; + PAYMENT_FUTUREPROOF = 48; + PAYMENT_TRANSACTION_STATUS_UPDATE_FAILED = 49; + PAYMENT_TRANSACTION_STATUS_UPDATE_REFUNDED = 50; + PAYMENT_TRANSACTION_STATUS_UPDATE_REFUND_FAILED = 51; + PAYMENT_TRANSACTION_STATUS_RECEIVER_PENDING_SETUP = 52; + PAYMENT_TRANSACTION_STATUS_RECEIVER_SUCCESS_AFTER_HICCUP = 53; + PAYMENT_ACTION_ACCOUNT_SETUP_REMINDER = 54; + PAYMENT_ACTION_SEND_PAYMENT_REMINDER = 55; + PAYMENT_ACTION_SEND_PAYMENT_INVITATION = 56; + PAYMENT_ACTION_REQUEST_DECLINED = 57; + PAYMENT_ACTION_REQUEST_EXPIRED = 58; + PAYMENT_ACTION_REQUEST_CANCELLED = 59; + BIZ_VERIFIED_TRANSITION_TOP_TO_BOTTOM = 60; + BIZ_VERIFIED_TRANSITION_BOTTOM_TO_TOP = 61; + BIZ_INTRO_TOP = 62; + BIZ_INTRO_BOTTOM = 63; + BIZ_NAME_CHANGE = 64; + BIZ_MOVE_TO_CONSUMER_APP = 65; + BIZ_TWO_TIER_MIGRATION_TOP = 66; + BIZ_TWO_TIER_MIGRATION_BOTTOM = 67; + OVERSIZED = 68; + GROUP_CHANGE_NO_FREQUENTLY_FORWARDED = 69; + GROUP_V4_ADD_INVITE_SENT = 70; + GROUP_PARTICIPANT_ADD_REQUEST_JOIN = 71; + CHANGE_EPHEMERAL_SETTING = 72; + E2E_DEVICE_CHANGED = 73; + VIEWED_ONCE = 74; + E2E_ENCRYPTED_NOW = 75; + BLUE_MSG_BSP_FB_TO_BSP_PREMISE = 76; + BLUE_MSG_BSP_FB_TO_SELF_FB = 77; + BLUE_MSG_BSP_FB_TO_SELF_PREMISE = 78; + BLUE_MSG_BSP_FB_UNVERIFIED = 79; + BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED = 80; + BLUE_MSG_BSP_FB_VERIFIED = 81; + BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED = 82; + BLUE_MSG_BSP_PREMISE_TO_SELF_PREMISE = 83; + BLUE_MSG_BSP_PREMISE_UNVERIFIED = 84; + BLUE_MSG_BSP_PREMISE_UNVERIFIED_TO_SELF_PREMISE_VERIFIED = 85; + BLUE_MSG_BSP_PREMISE_VERIFIED = 86; + BLUE_MSG_BSP_PREMISE_VERIFIED_TO_SELF_PREMISE_UNVERIFIED = 87; + BLUE_MSG_CONSUMER_TO_BSP_FB_UNVERIFIED = 88; + BLUE_MSG_CONSUMER_TO_BSP_PREMISE_UNVERIFIED = 89; + BLUE_MSG_CONSUMER_TO_SELF_FB_UNVERIFIED = 90; + BLUE_MSG_CONSUMER_TO_SELF_PREMISE_UNVERIFIED = 91; + BLUE_MSG_SELF_FB_TO_BSP_PREMISE = 92; + BLUE_MSG_SELF_FB_TO_SELF_PREMISE = 93; + BLUE_MSG_SELF_FB_UNVERIFIED = 94; + BLUE_MSG_SELF_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED = 95; + BLUE_MSG_SELF_FB_VERIFIED = 96; + BLUE_MSG_SELF_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED = 97; + BLUE_MSG_SELF_PREMISE_TO_BSP_PREMISE = 98; + BLUE_MSG_SELF_PREMISE_UNVERIFIED = 99; + BLUE_MSG_SELF_PREMISE_VERIFIED = 100; + BLUE_MSG_TO_BSP_FB = 101; + BLUE_MSG_TO_CONSUMER = 102; + BLUE_MSG_TO_SELF_FB = 103; + BLUE_MSG_UNVERIFIED_TO_BSP_FB_VERIFIED = 104; + BLUE_MSG_UNVERIFIED_TO_BSP_PREMISE_VERIFIED = 105; + BLUE_MSG_UNVERIFIED_TO_SELF_FB_VERIFIED = 106; + BLUE_MSG_UNVERIFIED_TO_VERIFIED = 107; + BLUE_MSG_VERIFIED_TO_BSP_FB_UNVERIFIED = 108; + BLUE_MSG_VERIFIED_TO_BSP_PREMISE_UNVERIFIED = 109; + BLUE_MSG_VERIFIED_TO_SELF_FB_UNVERIFIED = 110; + BLUE_MSG_VERIFIED_TO_UNVERIFIED = 111; + BLUE_MSG_BSP_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED = 112; + BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_FB_VERIFIED = 113; + BLUE_MSG_BSP_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED = 114; + BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_FB_UNVERIFIED = 115; + BLUE_MSG_SELF_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED = 116; + BLUE_MSG_SELF_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED = 117; + E2E_IDENTITY_UNAVAILABLE = 118; + GROUP_CREATING = 119; + GROUP_CREATE_FAILED = 120; + GROUP_BOUNCED = 121; + BLOCK_CONTACT = 122; + EPHEMERAL_SETTING_NOT_APPLIED = 123; + SYNC_FAILED = 124; + SYNCING = 125; + BIZ_PRIVACY_MODE_INIT_FB = 126; + BIZ_PRIVACY_MODE_INIT_BSP = 127; + BIZ_PRIVACY_MODE_TO_FB = 128; + BIZ_PRIVACY_MODE_TO_BSP = 129; + DISAPPEARING_MODE = 130; + E2E_DEVICE_FETCH_FAILED = 131; + ADMIN_REVOKE = 132; + GROUP_INVITE_LINK_GROWTH_LOCKED = 133; + COMMUNITY_LINK_PARENT_GROUP = 134; + COMMUNITY_LINK_SIBLING_GROUP = 135; + COMMUNITY_LINK_SUB_GROUP = 136; + COMMUNITY_UNLINK_PARENT_GROUP = 137; + COMMUNITY_UNLINK_SIBLING_GROUP = 138; + COMMUNITY_UNLINK_SUB_GROUP = 139; + GROUP_PARTICIPANT_ACCEPT = 140; + GROUP_PARTICIPANT_LINKED_GROUP_JOIN = 141; + COMMUNITY_CREATE = 142; + EPHEMERAL_KEEP_IN_CHAT = 143; + GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST = 144; + GROUP_MEMBERSHIP_JOIN_APPROVAL_MODE = 145; + INTEGRITY_UNLINK_PARENT_GROUP = 146; + COMMUNITY_PARTICIPANT_PROMOTE = 147; + COMMUNITY_PARTICIPANT_DEMOTE = 148; + COMMUNITY_PARENT_GROUP_DELETED = 149; + } +} + +message WebNotificationsInfo { + optional uint64 timestamp = 2; + optional uint32 unreadChats = 3; + optional uint32 notifyMessageCount = 4; + repeated WebMessageInfo notifyMessages = 5; +} diff --git a/protocols/WhatsApp/src/proto.cpp b/protocols/WhatsApp/src/proto.cpp new file mode 100644 index 0000000000..0b6fab3b19 --- /dev/null +++ b/protocols/WhatsApp/src/proto.cpp @@ -0,0 +1,333 @@ +/* + +WhatsApp plugin for Miranda NG +Copyright © 2019-22 George Hazan + +*/ + +#include "stdafx.h" + +struct SearchParam +{ + SearchParam(const wchar_t *_jid, LONG _id) : + jid(_jid), id(_id) + {} + + std::wstring jid; + LONG id; +}; + +static int CompareOwnMsgs(const WAOwnMessage *p1, const WAOwnMessage *p2) +{ + return strcmp(p1->szPrefix, p2->szPrefix); +} + +static int CompareUsers(const WAUser *p1, const WAUser *p2) +{ + return strcmp(p1->szId, p2->szId); +} + +static int CompareCollections(const WACollection *p1, const WACollection *p2) +{ + return strcmp(p1->szName, p2->szName); +} + +WhatsAppProto::WhatsAppProto(const char *proto_name, const wchar_t *username) : + PROTO(proto_name, username), + m_impl(*this), + m_signalStore(this, ""), + m_szJid(getMStringA(DBKEY_JID)), + m_tszDefaultGroup(getWStringA(DBKEY_DEF_GROUP)), + m_arUsers(10, CompareUsers), + m_arDevices(1), + m_arOwnMsgs(1, CompareOwnMsgs), + m_arPersistent(1), + m_arPacketQueue(10), + m_arCollections(10, CompareCollections), + + m_wszNick(this, "Nick"), + m_wszDefaultGroup(this, "DefaultGroup", L"WhatsApp"), + m_bUsePopups(this, "UsePopups", true), + m_bHideGroupchats(this, "HideChats", true) +{ + db_set_resident(m_szModuleName, "StatusMsg"); + + CreateProtoService(PS_CREATEACCMGRUI, &WhatsAppProto::SvcCreateAccMgrUI); + + CreateProtoService(PS_GETAVATARINFO, &WhatsAppProto::GetAvatarInfo); + CreateProtoService(PS_GETAVATARCAPS, &WhatsAppProto::GetAvatarCaps); + CreateProtoService(PS_GETMYAVATAR, &WhatsAppProto::GetMyAvatar); + CreateProtoService(PS_SETMYAVATAR, &WhatsAppProto::SetMyAvatar); + + HookProtoEvent(ME_OPT_INITIALISE, &WhatsAppProto::OnOptionsInit); + + InitCollections(); + InitPopups(); + InitPersistentHandlers(); + + // Create standard network connection + wchar_t descr[512]; + mir_snwprintf(descr, TranslateT("%s (server)"), m_tszUserName); + + NETLIBUSER nlu = {}; + nlu.flags = NUF_INCOMING | NUF_OUTGOING | NUF_HTTPCONNS | NUF_UNICODE; + nlu.szSettingsModule = m_szModuleName; + nlu.szDescriptiveName.w = descr; + m_hNetlibUser = Netlib_RegisterUser(&nlu); + + // Temporary folder + CreateDirectoryTreeW(CMStringW(VARSW(L"%miranda_userdata%")) + L"\\" + _A2T(m_szModuleName)); + + // Avatars folder + m_tszAvatarFolder = CMStringW(VARSW(L"%miranda_avatarcache%")) + L"\\" + m_tszUserName; + DWORD dwAttributes = GetFileAttributes(m_tszAvatarFolder.c_str()); + if (dwAttributes == 0xffffffff || (dwAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) + CreateDirectoryTreeW(m_tszAvatarFolder.c_str()); + + // default contacts group + if (m_tszDefaultGroup == NULL) + m_tszDefaultGroup = mir_wstrdup(L"WhatsApp"); + Clist_GroupCreate(0, m_tszDefaultGroup); + + // groupchat initialization + GCREGISTER gcr = {}; + gcr.dwFlags = GC_TYPNOTIF; + gcr.ptszDispName = m_tszUserName; + gcr.pszModule = m_szModuleName; + Chat_Register(&gcr); +} + +WhatsAppProto::~WhatsAppProto() +{ +} + +///////////////////////////////////////////////////////////////////////////////////////// +// OnModulesLoaded emulator for an account + +void WhatsAppProto::OnModulesLoaded() +{ + // initialize contacts cache + m_arUsers.insert(new WAUser(0, m_szJid, false)); + + for (auto &cc : AccContacts()) { + bool bIsChat = isChatRoom(cc); + CMStringA szId(getMStringA(cc, bIsChat ? "ChatRoomID" : DBKEY_JID)); + if (!szId.IsEmpty()) + m_arUsers.insert(new WAUser(cc, szId, bIsChat)); + } +} + +///////////////////////////////////////////////////////////////////////////////////////// +// PROTO_INTERFACE implementation + +MCONTACT WhatsAppProto::AddToList(int flags, PROTOSEARCHRESULT *psr) +{ + if (psr->id.w == nullptr) + return NULL; + + auto *pUser = AddUser(T2Utf(psr->id.w), (flags & PALF_TEMPORARY) != 0); + db_unset(pUser->hContact, "CList", "NotOnList"); + + return pUser->hContact; +} + +INT_PTR WhatsAppProto::GetCaps(int type, MCONTACT) +{ + switch (type) { + case PFLAGNUM_1: + return PF1_IM | PF1_FILE | PF1_CHAT | PF1_BASICSEARCH | PF1_ADDSEARCHRES | PF1_MODEMSGRECV; + case PFLAGNUM_2: + return PF2_ONLINE; + case PFLAGNUM_3: + return 0; + case PFLAGNUM_4: + return PF4_NOCUSTOMAUTH | PF4_NOAUTHDENYREASON | PF4_IMSENDOFFLINE | PF4_OFFLINEFILES | PF4_SUPPORTTYPING | PF4_AVATARS | PF4_SERVERMSGID; + case PFLAGNUM_5: + return 0; + case PFLAG_UNIQUEIDTEXT: + return (DWORD_PTR)"WhatsApp ID"; + } + return 0; +} + +int WhatsAppProto::SetStatus(int new_status) +{ + if (m_iDesiredStatus == new_status) + return 0; + + if (!mir_wstrlen(m_wszNick)) { + Popup(0, LPGENW("You need to specify nick name in the Options dialog"), LPGENW("Error")); + return 0; + } + + int oldStatus = m_iStatus; + + // Routing statuses not supported by WhatsApp + switch (new_status) { + case ID_STATUS_OFFLINE: + m_iDesiredStatus = new_status; + break; + + case ID_STATUS_ONLINE: + case ID_STATUS_FREECHAT: + default: + m_iDesiredStatus = ID_STATUS_ONLINE; + break; + } + + if (m_iDesiredStatus == ID_STATUS_OFFLINE) { + SetServerStatus(m_iDesiredStatus); + + if (m_hServerConn != nullptr) + Netlib_Shutdown(m_hServerConn); + + m_iStatus = m_iDesiredStatus = ID_STATUS_OFFLINE; + ProtoBroadcastAck(NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE)oldStatus, m_iStatus); + } + else if (m_hServerConn == nullptr && !IsStatusConnecting(m_iStatus)) { + m_iStatus = ID_STATUS_CONNECTING; + ProtoBroadcastAck(NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE)oldStatus, m_iStatus); + + ForkThread(&WhatsAppProto::ServerThread); + } + else if (m_hServerConn != nullptr) { + SetServerStatus(m_iDesiredStatus); + + m_iStatus = m_iDesiredStatus; + ProtoBroadcastAck(0, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE)oldStatus, m_iStatus); + } + else ProtoBroadcastAck(NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE)oldStatus, m_iStatus); + + return 0; +} + +///////////////////////////////////////////////////////////////////////////////////////// + +void WhatsAppProto::OnSendMessage(const JSONNode &node, void*) +{ + CMStringA szPrefix= node["$id$"].as_mstring(); + + WAOwnMessage tmp(0, 0, szPrefix); + { + mir_cslock lck(m_csOwnMessages); + auto *pOwn = m_arOwnMsgs.find(&tmp); + if (pOwn == nullptr) + return; + + tmp.pktId = pOwn->pktId; + tmp.hContact = pOwn->hContact; + m_arOwnMsgs.remove(pOwn); + } + + int status = node["status"].as_int(); + if (status == 200) + ProtoBroadcastAck(tmp.hContact, ACKTYPE_MESSAGE, ACKRESULT_SUCCESS, (HANDLE)tmp.pktId); + else { + CMStringW wszError(FORMAT, TranslateT("Operation failed with server error status %d"), status); + ProtoBroadcastAck(tmp.hContact, ACKTYPE_MESSAGE, ACKRESULT_FAILED, (HANDLE)tmp.pktId, LPARAM(wszError.c_str())); + } +} + +int WhatsAppProto::SendMsg(MCONTACT hContact, int, const char *pszMsg) +{ + ptrA jid(getStringA(hContact, DBKEY_JID)); + if (jid == nullptr || pszMsg == nullptr) + return 0; + + if (!isOnline()) { + debugLogA("No connection"); + return 0; + } + + char msgId[16], szMsgId[33]; + Utils_GetRandom(msgId, sizeof(msgId)); + bin2hex(msgId, sizeof(msgId), szMsgId); + + auto *key = new proto::MessageKey(); + key->set_remotejid(jid); + key->set_fromme(true); + key->set_id(szMsgId); + + proto::WebMessageInfo msg; + msg.set_allocated_key(key); + msg.mutable_message()->set_conversation(pszMsg); + msg.set_messagetimestamp(_time64(0)); + + size_t cbBinaryLen = msg.ByteSizeLong(); + mir_ptr pBuf((BYTE *)mir_alloc(cbBinaryLen)); + msg.SerializeToArray(pBuf, (int)cbBinaryLen); + + WANode payLoad; + payLoad.title = "action"; + payLoad.addAttr("type", "relay"); + payLoad.content.assign(pBuf, cbBinaryLen); + + int pktId = WSSendNode(payLoad); + + mir_cslock lck(m_csOwnMessages); + m_arOwnMsgs.insert(new WAOwnMessage(pktId, hContact, szMsgId)); + return pktId; +} + +int WhatsAppProto::UserIsTyping(MCONTACT hContact, int) +{ + if (hContact && isOnline()) { + ptrA jid(getStringA(hContact, DBKEY_JID)); + if (jid && isOnline()) { + } + } + + return 0; +} + +///////////////////////////////////////////////////////////////////////////////////////// +// contacts search + +void WhatsAppProto::SearchAckThread(void *targ) +{ + Sleep(100); + + SearchParam *param = (SearchParam*)targ; + PROTOSEARCHRESULT psr = {}; + psr.cbSize = sizeof(psr); + psr.flags = PSR_UNICODE; + psr.nick.w = psr.firstName.w = psr.lastName.w = L""; + psr.id.w = (wchar_t*)param->jid.c_str(); + + ProtoBroadcastAck(NULL, ACKTYPE_SEARCH, ACKRESULT_DATA, (HANDLE)param->id, (LPARAM)&psr); + ProtoBroadcastAck(NULL, ACKTYPE_SEARCH, ACKRESULT_SUCCESS, (HANDLE)param->id, 0); + + delete param; +} + +HANDLE WhatsAppProto::SearchBasic(const wchar_t* id) +{ + if (!isOnline()) + return nullptr; + + // fake - we always accept search + SearchParam *param = new SearchParam(id, -1); + ForkThread(&WhatsAppProto::SearchAckThread, param); + return (HANDLE)param->id; +} + +////////////////////////////////////////////////////////////////////////////// + +static int enumCollections(const char *szSetting, void *param) +{ + auto *pList = (LIST *)param; + if (!memcmp(szSetting, "Collection_", 11)) + pList->insert(mir_strdup(szSetting)); + return 0; +} + +void WhatsAppProto::InitCollections() +{ + LIST settings(10); + db_enum_settings(0, enumCollections, m_szModuleName, &settings); + + for (auto &it : settings) { + m_arCollections.insert(new WACollection(it + 11, getDword(it))); + mir_free(it); + } +} diff --git a/protocols/WhatsApp/src/proto.h b/protocols/WhatsApp/src/proto.h new file mode 100644 index 0000000000..d5fb32e80d --- /dev/null +++ b/protocols/WhatsApp/src/proto.h @@ -0,0 +1,425 @@ +/* + +WhatsApp plugin for Miranda NG +Copyright © 2019-22 George Hazan + +*/ + +#if !defined(PROTO_H) +#define PROTO_H + +#define S_WHATSAPP_NET "@s.whatsapp.net" +#define APP_VERSION "2.2230.15" +#define KEY_BUNDLE_TYPE "\x05" + +class WhatsAppProto; +typedef void (WhatsAppProto:: *WA_PKT_HANDLER)(const WANode &node); + +struct WAMSG +{ + union { + uint32_t dwFlags = 0; + struct { + bool bPrivateChat : 1; + bool bGroupChat : 1; + bool bDirectStatus : 1; + bool bOtherStatus : 1; + bool bPeerBroadcast : 1; + bool bOtherBroadcast : 1; + bool bOffline : 1; + }; + }; +}; + +struct WARequest +{ + WARequest(const CMStringA &_1, WA_PKT_HANDLER _2, void *_3 = nullptr) : + szPacketId(_1), + pHandler(_2), + pUserInfo(_3) + {} + + CMStringA szPacketId; + WA_PKT_HANDLER pHandler; + void *pUserInfo; +}; + +struct WADevice +{ + WADevice(const char *_1, int _2) : + jid(_1), + key_index(_2) + {} + + WAJid jid; + int key_index; +}; + +struct WAPersistentHandler +{ + WAPersistentHandler(const char *_1, const char *_2, const char *_3, const char *_4, WA_PKT_HANDLER _5) : + pszTitle(_1), pszType(_2), pszXmlns(_3), pszChild(_4), pHandler(_5) + {} + + const char *pszTitle, *pszType, *pszXmlns, *pszChild; + WA_PKT_HANDLER pHandler; +}; + +struct WAHistoryMessage +{ + CMStringA jid, text; + DWORD timestamp; +}; + +struct WAUser +{ + WAUser(MCONTACT _1, const char *_2, bool _3 = false) : + hContact(_1), + szId(mir_strdup(_2)), + bIsGroupChat(_3), + arHistory(1) + { + } + + ~WAUser() + { + mir_free(szId); + } + + MCONTACT hContact; + DWORD dwModifyTag = 0; + char *szId; + bool bInited = false, bIsGroupChat; + SESSION_INFO *si = 0; + DWORD m_time1 = 0, m_time2 = 0; + OBJLIST arHistory; +}; + +struct WAOwnMessage +{ + WAOwnMessage(int _1, MCONTACT _2, const char *_3) : + pktId(_1), + hContact(_2), + szPrefix(_3) + {} + + int pktId; + MCONTACT hContact; + CMStringA szPrefix; +}; + +struct WACollection +{ + WACollection(const char *_1, int _2) : + szName(mir_strdup(_1)), + version(_2) + {} + + ptrA szName; + int version; + + MBinBuffer hash; + std::map indexValueMap; + + void parseRecord(const proto::SyncdRecord &rec, bool bSet); +}; + +class WANoise +{ + friend class WhatsAppProto; + + WhatsAppProto *ppro; + int readCounter = 0, writeCounter = 0; + bool bInitFinished = false, bSendIntro = false; + MBinBuffer salt, encKey, decKey; + uint8_t hash[32]; + + struct { + MBinBuffer priv, pub; + } noiseKeys, ephemeral; + + void deriveKey(const void *pData, size_t cbLen, MBinBuffer &write, MBinBuffer &read); + void mixIntoKey(const void *n, const void *p); + void updateHash(const void *pData, size_t cbLen); + +public: + WANoise(WhatsAppProto *_ppro); + + void finish(); + void init(); + + MBinBuffer decrypt(const void *pData, size_t cbLen); + MBinBuffer encrypt(const void *pData, size_t cbLen); + + size_t decodeFrame(const void *&pData, size_t &cbLen); + MBinBuffer encodeFrame(const void *pData, size_t cbLen); +}; + +class MSignalSession : public MZeroedObject +{ + friend class MSignalStore; + signal_protocol_address address; + session_cipher *cipher = nullptr; + +public: + CMStringA szName; + MBinBuffer sessionData, userData; + + MSignalSession(const CMStringA &_1, int _2); + ~MSignalSession(); + + bool hasAddress(const char *name, size_t name_len) const; + + __forceinline session_cipher* getCipher(void) const { return cipher; } + __forceinline int getDeviceId() const { return address.device_id; } +}; + +class MSignalStore +{ + void init(); + + signal_context *m_pContext; + signal_protocol_store_context *m_pStore; + +public: + PROTO_INTERFACE *pProto; + const char *prefix; + + OBJLIST arSessions; + + struct + { + MBinBuffer priv, pub; + } + signedIdentity; + + struct + { + MBinBuffer priv, pub, signature; + uint32_t keyid; + } preKey; + + MSignalStore(PROTO_INTERFACE *_1, const char *_2); + ~MSignalStore(); + + __forceinline signal_context *CTX() const { return m_pContext; } + + MSignalSession *createSession(const CMStringA &szName, int deviceId); + + signal_buffer* decryptSignalProto(const CMStringA &from, const char *pszType, const MBinBuffer &encrypted); + signal_buffer* decryptGroupSignalProto(const CMStringA &from, const CMStringA &author, const MBinBuffer &encrypted); + + void generatePrekeys(int count); + + void processSenderKeyMessage(const proto::Message_SenderKeyDistributionMessage &msg); +}; + +class WhatsAppProto : public PROTO +{ + friend class WANoise; + + class CWhatsAppProtoImpl + { + friend class WhatsAppProto; + WhatsAppProto &m_proto; + + CTimer m_keepAlive; + void OnKeepAlive(CTimer *) { + m_proto.SendKeepAlive(); + } + + CWhatsAppProtoImpl(WhatsAppProto &pro) : + m_proto(pro), + m_keepAlive(Miranda_GetSystemWindow(), UINT_PTR(this)) + { + m_keepAlive.OnEvent = Callback(this, &CWhatsAppProtoImpl::OnKeepAlive); + } + } m_impl; + + + bool m_bTerminated, m_bRespawn; + ptrW m_tszDefaultGroup; + + CMStringA m_szJid; + CMStringW m_tszAvatarFolder; + + EVP_PKEY *m_pKeys; // private & public keys + WANoise *m_noise; + + void UploadMorePrekeys(); + + // App state management + OBJLIST m_arCollections; + + void InitCollections(); + void ResyncServer(const OBJLIST &task); + + __forceinline WACollection *FindCollection(const char *pszName) + { return m_arCollections.find((WACollection *)&pszName); + } + + // Contacts management ///////////////////////////////////////////////////////////////// + + mir_cs m_csUsers; + OBJLIST m_arUsers; + + mir_cs m_csOwnMessages; + OBJLIST m_arOwnMsgs; + + OBJLIST m_arDevices; + + WAUser* FindUser(const char *szId); + WAUser* AddUser(const char *szId, bool bTemporary, bool isChat = false); + + // Group chats ///////////////////////////////////////////////////////////////////////// + + void InitChat(WAUser *pUser); + + // UI ////////////////////////////////////////////////////////////////////////////////// + + void CloseQrDialog(); + bool ShowQrCode(const CMStringA &ref); + + /// Network //////////////////////////////////////////////////////////////////////////// + + time_t m_lastRecvTime; + HNETLIBCONN m_hServerConn; + + mir_cs m_csPacketQueue; + OBJLIST m_arPacketQueue; + + LIST m_arPersistent; + WA_PKT_HANDLER FindPersistentHandler(const WANode &node); + + int m_iPacketId; + uint16_t m_wMsgPrefix[2]; + CMStringA GenerateMessageId(); + void ProcessMessage(WAMSG type, const proto::WebMessageInfo &msg); + + bool WSReadPacket(const WSHeader &hdr, MBinBuffer &buf); + int WSSend(const MessageLite &msg); + int WSSendNode(WANode &node, WA_PKT_HANDLER = nullptr); + + MBinBuffer DownloadEncryptedFile(const char *url, const std::string &mediaKeys, const char *pszType); + CMStringW GetTmpFileName(const char *pszClass, const char *addition); + + void OnLoggedIn(void); + void OnLoggedOut(void); + void ServerThreadWorker(void); + void ShutdownSession(void); + + void SendReceipt(const char *pszTo, const char *pszParticipant, const char *pszId, const char *pszType); + void SendKeepAlive(); + void SetServerStatus(int iStatus); + + /// Popups ///////////////////////////////////////////////////////////////////////////// + + HANDLE m_hPopupClass; + CMOption m_bUsePopups; + + void InitPopups(void); + void Popup(MCONTACT hContact, const wchar_t *szMsg, const wchar_t *szTitle); + + /// Request handlers /////////////////////////////////////////////////////////////////// + + void OnGetAvatarInfo(const JSONNode &node, void*); + void OnGetChatInfo(const JSONNode &node, void*); + void OnSendMessage(const JSONNode &node, void*); + + void OnProcessHandshake(const void *pData, int cbLen); + + void InitPersistentHandlers(); + void OnAccountSync(const WANode &node); + void OnIqBlockList(const WANode &node); + void OnIqCountPrekeys(const WANode &node); + void OnIqDoNothing(const WANode &node); + void OnIqPairDevice(const WANode &node); + void OnIqPairSuccess(const WANode &node); + void OnIqResult(const WANode &node); + void OnIqServerSync(const WANode &node); + void OnNotifyEncrypt(const WANode &node); + void OnReceiveInfo(const WANode &node); + void OnReceiveMessage(const WANode &node); + void OnServerSync(const WANode &node); + void OnStreamError(const WANode &node); + void OnSuccess(const WANode &node); + + // Signal + MSignalStore m_signalStore; + + // Binary packets + void ProcessBinaryPacket(const void *pData, size_t cbLen); + + // unzip operations + MBinBuffer unzip(const MBinBuffer &src); + + /// Avatars //////////////////////////////////////////////////////////////////////////// + CMStringW GetAvatarFileName(MCONTACT hContact); + + INT_PTR __cdecl GetAvatarInfo(WPARAM, LPARAM); + INT_PTR __cdecl GetAvatarCaps(WPARAM, LPARAM); + INT_PTR __cdecl GetMyAvatar(WPARAM, LPARAM); + INT_PTR __cdecl SetMyAvatar(WPARAM, LPARAM); + +public: + WhatsAppProto(const char *proto_name, const wchar_t *username); + ~WhatsAppProto(); + + __forceinline bool isOnline() const + { return m_hServerConn != 0; + } + + __forceinline void writeStr(const char *pszSetting, const JSONNode &node) + { + CMStringW str(node.as_mstring()); + if (!str.IsEmpty()) + setWString(pszSetting, str); + } + + class CWhatsAppQRDlg *m_pQRDlg; + + // PROTO_INTERFACE ///////////////////////////////////////////////////////////////////// + + MCONTACT AddToList(int flags, PROTOSEARCHRESULT *psr) override; + INT_PTR GetCaps(int type, MCONTACT hContact = NULL) override; + HANDLE SearchBasic(const wchar_t* id) override; + int SendMsg(MCONTACT hContact, int flags, const char* msg) override; + int SetStatus(int iNewStatus) override; + int UserIsTyping(MCONTACT hContact, int type) override; + + void OnModulesLoaded() override; + + // Services //////////////////////////////////////////////////////////////////////////// + + INT_PTR __cdecl SvcCreateAccMgrUI(WPARAM, LPARAM); + + // Events ////////////////////////////////////////////////////////////////////////////// + + int __cdecl OnOptionsInit(WPARAM, LPARAM); + int __cdecl OnBuildStatusMenu(WPARAM, LPARAM); + + // Options ///////////////////////////////////////////////////////////////////////////// + + CMOption m_wszNick; // your nick name in presence + CMOption m_wszDefaultGroup; // clist group to store contacts + CMOption m_bHideGroupchats; // do not open chat windows on creation + + // Processing Threads ////////////////////////////////////////////////////////////////// + + void __cdecl SearchAckThread(void*); + void __cdecl ServerThread(void*); +}; + +struct CMPlugin : public ACCPROTOPLUGIN +{ + HNETLIBUSER hAvatarUser = nullptr; + HNETLIBCONN hAvatarConn = nullptr; + bool SaveFile(const char *pszUrl, PROTO_AVATAR_INFORMATION &ai); + + CMPlugin(); + + int Load() override; + int Unload() override; +}; + +#endif diff --git a/protocols/WhatsApp/src/qrcode.cpp b/protocols/WhatsApp/src/qrcode.cpp new file mode 100644 index 0000000000..f38ef2f286 --- /dev/null +++ b/protocols/WhatsApp/src/qrcode.cpp @@ -0,0 +1,124 @@ +/* + +WhatsApp plugin for Miranda NG +Copyright © 2019-22 George Hazan + +*/ + +#include "stdafx.h" + +class CWhatsAppQRDlg : public CProtoDlgBase +{ +public: + CWhatsAppQRDlg(WhatsAppProto *ppro) : + CProtoDlgBase(ppro, IDD_SHOWQR) + {} + + void SetData(const CMStringA &str) + { + auto *pQR = QRcode_encodeString(str, 0, QR_ECLEVEL_L, QR_MODE_8, 1); + + HWND hwndRc = GetDlgItem(m_hwnd, IDC_QRPIC); + RECT rc; + GetClientRect(hwndRc, &rc); + + ::SetForegroundWindow(m_hwnd); + + int scale = 8; // (rc.bottom - rc.top) / pQR->width; + int rowLen = pQR->width * scale * 3; + if (rowLen % 4) + rowLen = (rowLen / 4 + 1) * 4; + int dataLen = rowLen * pQR->width * scale; + + mir_ptr pData((BYTE *)mir_alloc(dataLen)); + if (pData == nullptr) { + QRcode_free(pQR); + return; + } + + memset(pData, 0xFF, dataLen); // white background by default + + const BYTE *s = pQR->data; + for (int y = 0; y < pQR->width; y++) { + BYTE *d = pData.get() + rowLen * y * scale; + for (int x = 0; x < pQR->width; x++) { + if (*s & 1) + for (int i = 0; i < scale; i++) + for (int j = 0; j < scale; j++) { + d[j * 3 + i * rowLen] = 0; + d[1 + j * 3 + i * rowLen] = 0; + d[2 + j * 3 + i * rowLen] = 0; + } + + d += scale * 3; + s++; + } + } + + BITMAPFILEHEADER fih = {}; + fih.bfType = 0x4d42; // "BM" + fih.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + dataLen; + fih.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER); + + BITMAPINFOHEADER bih = {}; + bih.biSize = sizeof(BITMAPINFOHEADER); + bih.biWidth = pQR->width * scale; + bih.biHeight = -bih.biWidth; + bih.biPlanes = 1; + bih.biBitCount = 24; + bih.biCompression = BI_RGB; + + wchar_t wszTempPath[MAX_PATH], wszTempFile[MAX_PATH]; + GetTempPathW(_countof(wszTempPath), wszTempPath); + GetTempFileNameW(wszTempPath, L"wa_", TRUE, wszTempFile); + FILE *f = _wfopen(wszTempFile, L"wb"); + fwrite(&fih, sizeof(BITMAPFILEHEADER), 1, f); + fwrite(&bih, sizeof(BITMAPINFOHEADER), 1, f); + fwrite(pData, sizeof(unsigned char), dataLen, f); + fclose(f); + + SendMessage(hwndRc, STM_SETIMAGE, IMAGE_BITMAP, (LPARAM)Image_Load(wszTempFile)); + + DeleteFileW(wszTempFile); + QRcode_free(pQR); + } +}; + +static INT_PTR __stdcall sttShowDialog(void *param) +{ + WhatsAppProto *ppro = (WhatsAppProto *)param; + + if (ppro->m_pQRDlg == nullptr) { + ppro->m_pQRDlg = new CWhatsAppQRDlg(ppro); + ppro->m_pQRDlg->Show(); + } + else { + SetForegroundWindow(ppro->m_pQRDlg->GetHwnd()); + SetActiveWindow(ppro->m_pQRDlg->GetHwnd()); + } + return 0; +} + +///////////////////////////////////////////////////////////////////////////////////////// + +void WhatsAppProto::CloseQrDialog() +{ + if (m_pQRDlg) { + m_pQRDlg->Close(); + m_pQRDlg = nullptr; + } +} + +bool WhatsAppProto::ShowQrCode(const CMStringA &ref) +{ + CallFunctionSync(sttShowDialog, this); + + MBinBuffer secret(getBlob(DBKEY_SECRET_KEY)); + + ptrA s1(mir_base64_encode(m_noise->noiseKeys.pub)); + ptrA s2(mir_base64_encode(m_signalStore.signedIdentity.pub)); + ptrA s3(mir_base64_encode(secret)); + CMStringA szQrData(FORMAT, "%s,%s,%s,%s", ref.c_str(), s1.get(), s2.get(), s3.get()); + m_pQRDlg->SetData(szQrData); + return true; +} diff --git a/protocols/WhatsApp/src/resource.h b/protocols/WhatsApp/src/resource.h new file mode 100644 index 0000000000..79cce313c0 --- /dev/null +++ b/protocols/WhatsApp/src/resource.h @@ -0,0 +1,26 @@ +//{{NO_DEPENDENCIES}} +// Microsoft Visual C++ generated include file. +// Used by W:\miranda-ng\protocols\WhatsApp\res\whatsapp.rc +// +#define IDI_WHATSAPP 100 +#define IDD_ACCMGRUI 101 +#define IDD_OPTIONS 102 +#define IDD_SHOWQR 103 +#define IDC_HIDECHATS 1000 +#define IDC_DEFGROUP 1001 +#define IDC_QRPIC 1002 +#define IDC_DEFGROUP2 1002 +#define IDC_CLIST 1003 +#define IDC_NEWJID 1004 +#define IDC_NICK 1005 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 104 +#define _APS_NEXT_COMMAND_VALUE 40001 +#define _APS_NEXT_CONTROL_VALUE 1006 +#define _APS_NEXT_SYMED_VALUE 101 +#endif +#endif diff --git a/protocols/WhatsApp/src/server.cpp b/protocols/WhatsApp/src/server.cpp new file mode 100644 index 0000000000..b61b5d193a --- /dev/null +++ b/protocols/WhatsApp/src/server.cpp @@ -0,0 +1,329 @@ +/* + +WhatsApp plugin for Miranda NG +Copyright © 2019-22 George Hazan + +*/ + +#include "stdafx.h" + +///////////////////////////////////////////////////////////////////////////////////////// +// gateway worker thread + +void WhatsAppProto::ServerThread(void *) +{ + do { + m_bRespawn = false; + ServerThreadWorker(); + } + while (m_bRespawn); + + OnLoggedOut(); +} + +void WhatsAppProto::ServerThreadWorker() +{ + // connect websocket + NETLIBHTTPHEADER hdrs[] = + { + { "Origin", "https://web.whatsapp.com" }, + { 0, 0 } + }; + + NLHR_PTR pReply(WebSocket_Connect(m_hNetlibUser, "web.whatsapp.com/ws/chat", hdrs)); + if (pReply == nullptr) { + debugLogA("Server connection failed, exiting"); + return; + } + + if (pReply->resultCode != 101) + return; + + delete m_noise; + m_noise = new WANoise(this); + m_noise->init(); + + debugLogA("Server connection succeeded"); + m_hServerConn = pReply->nlc; + m_lastRecvTime = time(0); + m_iPacketId = 1; + + Utils_GetRandom(m_wMsgPrefix, sizeof(m_wMsgPrefix)); + + auto &pubKey = m_noise->ephemeral.pub; + auto *client = new proto::HandshakeMessage::ClientHello(); client->set_ephemeral(pubKey.data(), pubKey.length()); + proto::HandshakeMessage msg; msg.set_allocated_clienthello(client); + WSSend(msg); + + MBinBuffer netbuf; + + for (m_bTerminated = false; !m_bTerminated;) { + unsigned char buf[2048]; + int bufSize = Netlib_Recv(m_hServerConn, (char *)buf, _countof(buf), MSG_NODUMP); + if (bufSize == 0) { + debugLogA("Gateway connection gracefully closed"); + break; + } + if (bufSize < 0) { + debugLogA("Gateway connection error, exiting"); + break; + } + + netbuf.append(buf, bufSize); + + WSHeader hdr; + if (!WebSocket_InitHeader(hdr, netbuf.data(), netbuf.length())) + continue; + + // we lack some data, let's read them + if (netbuf.length() < hdr.headerSize + hdr.payloadSize) + if (!WSReadPacket(hdr, netbuf)) + break; + + // debugLogA("Got packet: buffer = %d, opcode = %d, headerSize = %d, payloadSize = %d, final = %d, masked = %d", + // netbuf.length(), hdr.opCode, hdr.headerSize, hdr.payloadSize, hdr.bIsFinal, hdr.bIsMasked); + // Netlib_Dump(m_hServerConn, netbuf.data(), netbuf.length(), false, 0); + + m_lastRecvTime = time(0); + + // read all payloads from the current buffer, one by one + while (true) { + MBinBuffer currPacket; + currPacket.assign(netbuf.data() + hdr.headerSize, hdr.payloadSize); + + switch (hdr.opCode) { + case 1: // json packet + debugLogA("Text packet, skipping"); + /* + currPacket.append("", 1); // add 0 to use strchr safely + CMStringA szJson(pos, (int)dataSize); + + JSONNode root = JSONNode::parse(szJson); + if (root) { + debugLogA("JSON received:\n%s", start); + + CMStringA szPrefix(start, int(pos - start - 1)); + auto *pReq = m_arPacketQueue.find((WARequest *)&szPrefix); + if (pReq != nullptr) { + root << CHAR_PARAM("$id$", szPrefix); + } + } + } + */ + break; + + case 2: // binary packet + if (hdr.payloadSize > 32) + ProcessBinaryPacket(currPacket.data(), hdr.payloadSize); + break; + + case 8: // close + debugLogA("server required to exit"); + m_bRespawn = m_bTerminated = true; // simply reconnect, don't exit + break; + + default: + Netlib_Dump(m_hServerConn, currPacket.data(), hdr.payloadSize, false, 0); + } + + netbuf.remove(hdr.headerSize + hdr.payloadSize); + // debugLogA("%d bytes removed from network buffer, %d bytes remain", hdr.headerSize + hdr.payloadSize, netbuf.length()); + if (netbuf.length() == 0) + break; + + // if we have not enough data for header, continue reading + if (!WebSocket_InitHeader(hdr, netbuf.data(), netbuf.length())) { + debugLogA("not enough data for header, continue reading"); + break; + } + + // if we have not enough data for data, continue reading + if (hdr.headerSize + hdr.payloadSize > netbuf.length()) { + debugLogA("not enough place for data (%d+%d > %d), continue reading", hdr.headerSize, hdr.payloadSize, netbuf.length()); + break; + } + + debugLogA("Got inner packet: buffer = %d, opcode = %d, headerSize = %d, payloadSize = %d, final = %d, masked = %d", + netbuf.length(), hdr.opCode, hdr.headerSize, hdr.payloadSize, hdr.bIsFinal, hdr.bIsMasked); + } + } + + debugLogA("Server connection dropped"); + Netlib_CloseHandle(m_hServerConn); + m_hServerConn = nullptr; +} + +bool WhatsAppProto::WSReadPacket(const WSHeader &hdr, MBinBuffer &res) +{ + size_t currPacketSize = res.length() - hdr.headerSize; + + char buf[1024]; + while (currPacketSize < hdr.payloadSize) { + int result = Netlib_Recv(m_hServerConn, buf, _countof(buf), MSG_NODUMP); + if (result == 0) { + debugLogA("Gateway connection gracefully closed"); + return false; + } + if (result < 0) { + debugLogA("Gateway connection error, exiting"); + return false; + } + + currPacketSize += result; + res.append(buf, result); + } + return true; +} + +///////////////////////////////////////////////////////////////////////////////////////// +// Binary data processing + +void WhatsAppProto::ProcessBinaryPacket(const void *pData, size_t cbDataLen) +{ + while (size_t payloadLen = m_noise->decodeFrame(pData, cbDataLen)) { + if (m_noise->bInitFinished) { + MBinBuffer buf = m_noise->decrypt(pData, payloadLen); + + WAReader rdr(buf.data(), buf.length()); + auto b = rdr.readInt8(); + if (b & 2) { + buf.remove(1); + buf = unzip(buf); + rdr = WAReader(buf.data(), buf.length()); + } + + if (WANode *pNode = rdr.readNode()) { + CMStringA szText; + pNode->print(szText); + debugLogA("Got binary node:\n%s", szText.c_str()); + + auto pHandler = FindPersistentHandler(*pNode); + if (pHandler) + (this->*pHandler)(*pNode); + else + debugLogA("cannot handle incoming message"); + + delete pNode; + } + else { + debugLogA("wrong or broken payload"); + Netlib_Dump(m_hServerConn, pData, cbDataLen, false, 0); + } + } + else OnProcessHandshake(pData, (int)payloadLen); + + pData = (BYTE*)pData + payloadLen; + cbDataLen -= payloadLen; + } +} + +///////////////////////////////////////////////////////////////////////////////////////// + +void WhatsAppProto::OnLoggedIn() +{ + debugLogA("WhatsAppProto::OnLoggedIn"); + + SetServerStatus(m_iDesiredStatus); + + ProtoBroadcastAck(0, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE)m_iStatus, m_iDesiredStatus); + m_iStatus = m_iDesiredStatus; + + m_impl.m_keepAlive.Start(1000); + + // retrieve loaded prekeys count + WSSendNode( + WANodeIq(IQ::GET, "encrypt") << XCHILD("count"), + &WhatsAppProto::OnIqCountPrekeys); + + // retrieve initial info + WANodeIq abt(IQ::GET, "abt"); + abt.addChild("props")->addAttr("protocol", "1"); + WSSendNode(abt, &WhatsAppProto::OnIqDoNothing); + + WSSendNode( + WANodeIq(IQ::GET, "w") << XCHILD("props"), + &WhatsAppProto::OnIqDoNothing); + + WSSendNode( + WANodeIq(IQ::GET, "blocklist"), + &WhatsAppProto::OnIqBlockList); + + WSSendNode( + WANodeIq(IQ::GET, "privacy") << XCHILD("privacy"), + &WhatsAppProto::OnIqDoNothing); + + /* + OBJLIST task(1); + task.insert(new WACollection("regular_high", 9)); + task.insert(new WACollection("regular_low", 11)); + ResyncServer(task); + */ +} + +void WhatsAppProto::OnLoggedOut(void) +{ + m_impl.m_keepAlive.Stop(); + + debugLogA("WhatsAppProto::OnLoggedOut"); + m_bTerminated = true; + + ProtoBroadcastAck(0, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE)m_iStatus, ID_STATUS_OFFLINE); + m_iStatus = m_iDesiredStatus = ID_STATUS_OFFLINE; + + setAllContactStatuses(ID_STATUS_OFFLINE, false); +} + +void WhatsAppProto::SendKeepAlive() +{ + time_t now = time(0); + if (now - m_lastRecvTime > 20) { + WSSendNode(WANodeIq(IQ::GET, "w:p") << XCHILD("ping"), &WhatsAppProto::OnIqDoNothing); + + m_lastRecvTime = now; + } +} + +void WhatsAppProto::SendReceipt(const char *pszTo, const char *pszParticipant, const char *pszId, const char *pszType) +{ + WANode receipt("receipt"); + receipt << CHAR_PARAM("id", pszId); + + if (!mir_strcmp(pszType, "read") || !mir_strcmp(pszType, "read-self")) + receipt << INT_PARAM("t", time(0)); + + if (!mir_strcmp(pszType, "sender") && WAJid(pszTo).isUser()) + receipt << CHAR_PARAM("to", pszParticipant) << CHAR_PARAM("recipient", pszTo); + else { + receipt << CHAR_PARAM("to", pszTo); + if (pszParticipant) + receipt << CHAR_PARAM("participant", pszParticipant); + } + + if (pszType) + receipt << CHAR_PARAM("type", pszType); + WSSendNode(receipt, &WhatsAppProto::OnIqDoNothing); +} + +void WhatsAppProto::SetServerStatus(int iStatus) +{ + if (mir_wstrlen(m_wszNick)) + WSSendNode( + WANode("presence") << CHAR_PARAM("name", T2Utf(m_wszNick)) << CHAR_PARAM("type", (iStatus == ID_STATUS_ONLINE) ? "available" : "unavailable"), + &WhatsAppProto::OnIqDoNothing); +} + +///////////////////////////////////////////////////////////////////////////////////////// + +void WhatsAppProto::ShutdownSession() +{ + if (m_bTerminated) + return; + + debugLogA("WhatsAppProto::ShutdownSession"); + + // shutdown all resources + if (m_hServerConn) + Netlib_Shutdown(m_hServerConn); + + OnLoggedOut(); +} diff --git a/protocols/WhatsApp/src/signal.cpp b/protocols/WhatsApp/src/signal.cpp new file mode 100644 index 0000000000..e80eeac4ee --- /dev/null +++ b/protocols/WhatsApp/src/signal.cpp @@ -0,0 +1,529 @@ +/* + +WhatsApp plugin for Miranda NG +Copyright © 2019-22 George Hazan + +*/ + +#include "stdafx.h" + +///////////////////////////////////////////////////////////////////////////////////////// +// MSignalStore members + +static int CompareSessions(const MSignalSession *p1, const MSignalSession *p2) +{ + if (int ret = mir_strcmp(p1->szName, p2->szName)) + return ret; + + return p1->getDeviceId() - p2->getDeviceId(); +} + +MSignalStore::MSignalStore(PROTO_INTERFACE *_1, const char *_2) : + pProto(_1), + prefix(_2), + arSessions(1, &CompareSessions) +{ + init(); +} + +MSignalStore::~MSignalStore() +{ + signal_protocol_store_context_destroy(m_pStore); + signal_context_destroy(m_pContext); +} + +///////////////////////////////////////////////////////////////////////////////////////// + +static void log_func(int level, const char *pmsg, size_t /*msgLen*/, void *pUserData) +{ + auto *pStore = (MSignalStore *)pUserData; + pStore->pProto->debugLogA("libsignal {%d}: %s", level, pmsg); +} + +static int hmac_sha256_init(void **hmac_context, const uint8_t *key, size_t key_len, void *) +{ + HMAC_CTX *ctx = HMAC_CTX_new(); + *hmac_context = ctx; + HMAC_Init(ctx, key, (int)key_len, EVP_sha256()); + return 0; +} + +static int hmac_sha256_update(void *hmac_context, const uint8_t *data, size_t data_len, void *) +{ + return HMAC_Update((HMAC_CTX *)hmac_context, data, data_len); +} + +static int hmac_sha256_final(void *hmac_context, signal_buffer **output, void *) +{ + BYTE data[200]; + unsigned len = 0; + if (!HMAC_Final((HMAC_CTX *)hmac_context, data, &len)) + return 1; + + *output = signal_buffer_create(data, len); + return 0; +} + +static void hmac_sha256_cleanup(void *hmac_context, void *) +{ + HMAC_CTX_free((HMAC_CTX *)hmac_context); +} + +static int random_func(uint8_t *pData, size_t size, void *) +{ + Utils_GetRandom(pData, size); + return 0; +} + +static int decrypt_func(signal_buffer **output, + int /*cipher*/, + const uint8_t *key, size_t /*key_len*/, + const uint8_t *iv, size_t /*iv_len*/, + const uint8_t *ciphertext, size_t ciphertext_len, + void * /*user_data*/) +{ + MBinBuffer res = aesDecrypt(EVP_aes_256_cbc(), key, iv, ciphertext, ciphertext_len); + *output = signal_buffer_create(res.data(), res.length()); + return SG_SUCCESS; +} + +static int contains_session_func(const signal_protocol_address *address, void *user_data) +{ + auto *pStore = (MSignalStore *)user_data; + + MSignalSession tmp(CMStringA(address->name, (int)address->name_len), address->device_id); + return pStore->arSessions.find(&tmp) == nullptr; +} + +static int delete_all_sessions_func(const char *name, size_t name_len, void *user_data) +{ + auto *pStore = (MSignalStore *)user_data; + auto &pList = pStore->arSessions; + + int count = 0; + for (auto &it : pList.rev_iter()) { + if (it->hasAddress(name, name_len)) { + pList.remove(pList.indexOf(&it)); + count++; + } + } + return count; +} + +int delete_session_func(const signal_protocol_address *address, void *user_data) +{ + auto *pStore = (MSignalStore *)user_data; + auto &pList = pStore->arSessions; + + MSignalSession tmp(CMStringA(address->name, (int)address->name_len), address->device_id); + int idx = pList.getIndex(&tmp); + if (idx != -1) + pList.remove(idx); + return 0; +} + +static int get_sub_device_sessions_func(signal_int_list **sessions, const char *name, size_t name_len, void *user_data) +{ + auto *pStore = (MSignalStore *)user_data; + CMStringA szName(name, (int)name_len); + + signal_int_list *l = signal_int_list_alloc(); + unsigned int array_size = 0; + + for (auto &it : pStore->arSessions) + if (it->szName == szName) { + array_size++; + signal_int_list_push_back(l, it->getDeviceId()); + } + + *sessions = l; + return array_size; +} + +static void destroy_func(void *) +{} + +int load_session_func(signal_buffer **record, signal_buffer **user_data_storage, const signal_protocol_address *address, void *user_data) +{ + auto *pStore = (MSignalStore *)user_data; + + MSignalSession tmp(CMStringA(address->name, (int)address->name_len), address->device_id); + if (auto *pSession = pStore->arSessions.find(&tmp)) { + *record = signal_buffer_create((uint8_t *)pSession->sessionData.data(), pSession->sessionData.length()); + *user_data_storage = signal_buffer_create((uint8_t *)pSession->userData.data(), pSession->userData.length()); + return 1; + } + + return 0; +} + +static int store_session_func(const signal_protocol_address *address, uint8_t *record, size_t record_len, uint8_t *user_record, size_t user_record_len, void *user_data) +{ + auto *pStore = (MSignalStore *)user_data; + + MSignalSession tmp(CMStringA(address->name, (int)address->name_len), address->device_id); + auto *pSession = pStore->arSessions.find(&tmp); + if (pSession == nullptr) { + pSession = new MSignalSession(tmp); + pStore->arSessions.insert(pSession); + } + + pSession->sessionData.assign(record, record_len); + pSession->userData.assign(user_record, user_record_len); + return 0; +} + +static int contains_pre_key(uint32_t pre_key_id, void *user_data) +{ + auto *pStore = (MSignalStore *)user_data; + + CMStringA szSetting(FORMAT, "%s%d", "PreKey", pre_key_id); + MBinBuffer blob(pStore->pProto->getBlob(szSetting)); + return (blob.data() != 0); +} + +static int load_pre_key(signal_buffer **record, uint32_t pre_key_id, void *user_data) +{ + auto *pStore = (MSignalStore *)user_data; + + CMStringA szSetting(FORMAT, "%s%d", "PreKey", pre_key_id); + MBinBuffer blob(pStore->pProto->getBlob(szSetting)); + if (blob.data() == 0) + return SG_ERR_INVALID_KEY_ID; + + *record = signal_buffer_create((uint8_t *)blob.data(), blob.length()); + return SG_SUCCESS; //key exists and succesfully loaded +} + +static int remove_pre_key(uint32_t pre_key_id, void *user_data) +{ + auto *pStore = (MSignalStore *)user_data; + + CMStringA szSetting(FORMAT, "%s%d", "PreKey", pre_key_id); + pStore->pProto->delSetting(szSetting); + + szSetting.Format("PreKey%uPublic", pre_key_id); + pStore->pProto->delSetting(szSetting); + + szSetting.Format("PreKey%uPrivate", pre_key_id); + pStore->pProto->delSetting(szSetting); + return 0; +} + +static int store_pre_key(uint32_t pre_key_id, uint8_t *record, size_t record_len, void *user_data) +{ + auto *pStore = (MSignalStore *)user_data; + + CMStringA szSetting(FORMAT, "%s%d", "PreKey", pre_key_id); + db_set_blob(0, pStore->pProto->m_szModuleName, szSetting, record, (unsigned int)record_len); + + session_pre_key *prekey = nullptr; + session_pre_key_deserialize(&prekey, record, record_len, pStore->CTX()); //TODO: handle error + if (prekey) { + ec_key_pair *pre_key_pair = session_pre_key_get_key_pair(prekey); + + SignalBuffer key_buf(ec_key_pair_get_public(pre_key_pair)); + szSetting.Format("PreKey%uPublic", pre_key_id); + db_set_blob(0, pStore->pProto->m_szModuleName, szSetting, key_buf.data(), key_buf.len()); + } + + return 0; +} + +static int contains_signed_pre_key(uint32_t signed_pre_key_id, void *user_data) +{ + auto *pStore = (MSignalStore *)user_data; + + CMStringA szSetting(FORMAT, "%s%d", "SignedPreKey", signed_pre_key_id); + MBinBuffer blob(pStore->pProto->getBlob(szSetting)); + return blob.data() != 0; +} + +static int load_signed_pre_key(signal_buffer **record, uint32_t signed_pre_key_id, void *user_data) +{ + auto *pStore = (MSignalStore *)user_data; + + CMStringA szSetting(FORMAT, "%s%d", "SignedPreKey", signed_pre_key_id); + MBinBuffer blob(pStore->pProto->getBlob(szSetting)); + if (blob.data() == 0) + return SG_ERR_INVALID_KEY_ID; + + *record = signal_buffer_create(blob.data(), blob.length()); + return SG_SUCCESS; //key exist and succesfully loaded +} + +static int store_signed_pre_key(uint32_t signed_pre_key_id, uint8_t *record, size_t record_len, void *user_data) +{ + auto *pStore = (MSignalStore *)user_data; + + CMStringA szSetting(FORMAT, "%s%d", "SignedPreKey", signed_pre_key_id); + db_set_blob(0, pStore->pProto->m_szModuleName, szSetting, record, (unsigned int)record_len); + return 0; +} + +static int remove_signed_pre_key(uint32_t signed_pre_key_id, void *user_data) +{ + auto *pStore = (MSignalStore *)user_data; + + CMStringA szSetting(FORMAT, "%s%d", "SignedPreKey", signed_pre_key_id); + pStore->pProto->delSetting(szSetting); + return 0; +} + +static int get_identity_key_pair(signal_buffer **public_data, signal_buffer **private_data, void *user_data) +{ + auto *pStore = (MSignalStore *)user_data; + + MBinBuffer buf; + buf.append(KEY_BUNDLE_TYPE, 1); + buf.append(pStore->signedIdentity.pub); + *public_data = signal_buffer_create(buf.data(), (int)buf.length()); + + *private_data = signal_buffer_create((uint8_t *)pStore->signedIdentity.priv.data(), (int)pStore->signedIdentity.priv.length()); + return 0; +} + +static int get_local_registration_id(void *user_data, uint32_t *registration_id) +{ + auto *pStore = (MSignalStore *)user_data; + *registration_id = pStore->pProto->getDword(DBKEY_REG_ID); + return 0; +} + +static int save_identity(const signal_protocol_address *address, uint8_t *key_data, size_t key_len, void *user_data) +{ + auto *pStore = (MSignalStore *)user_data; + + CMStringA szSetting(FORMAT, "%s_%s_%d", "SignalIdentity", CMStringA(address->name, (int)address->name_len).c_str(), address->device_id); + if (key_data != nullptr) + db_set_blob(0, pStore->pProto->m_szModuleName, szSetting, key_data, (unsigned int)key_len); //TODO: check return value + else + pStore->pProto->delSetting(szSetting); + return 0; +} + +static int is_trusted_identity(const signal_protocol_address * /*address*/, uint8_t * /*key_data*/, size_t /*key_len*/, void * /*user_data*/) +{ + return 1; +} + +void MSignalStore::init() +{ + signal_context_create(&m_pContext, this); + signal_context_set_log_function(m_pContext, log_func); + + signal_crypto_provider prov; + memset(&prov, 0xFF, sizeof(prov)); + prov.hmac_sha256_init_func = hmac_sha256_init; + prov.hmac_sha256_final_func = hmac_sha256_final; + prov.hmac_sha256_update_func = hmac_sha256_update; + prov.hmac_sha256_cleanup_func = hmac_sha256_cleanup; + prov.random_func = random_func; + prov.decrypt_func = decrypt_func; + signal_context_set_crypto_provider(m_pContext, &prov); + + // default values calculation + if (pProto->getDword(DBKEY_PREKEY_NEXT_ID, 0xFFFF) == 0xFFFF) { + // generate signed identity keys (private & public) + ratchet_identity_key_pair *keyPair; + signal_protocol_key_helper_generate_identity_key_pair(&keyPair, m_pContext); + + auto *pPubKey = ratchet_identity_key_pair_get_public(keyPair); + db_set_blob(0, pProto->m_szModuleName, DBKEY_SIGNED_IDENTITY_PUB, pPubKey->data, sizeof(pPubKey->data)); + + auto *pPrivKey = ratchet_identity_key_pair_get_private(keyPair); + db_set_blob(0, pProto->m_szModuleName, DBKEY_SIGNED_IDENTITY_PRIV, pPrivKey->data, sizeof(pPrivKey->data)); + + session_signed_pre_key *signed_pre_key; + signal_protocol_key_helper_generate_signed_pre_key(&signed_pre_key, keyPair, 1, time(0), m_pContext); + + SignalBuffer prekeyBuf(signed_pre_key); + db_set_blob(0, pProto->m_szModuleName, DBKEY_PREKEY, prekeyBuf.data(), prekeyBuf.len()); + SIGNAL_UNREF(signed_pre_key); + SIGNAL_UNREF(keyPair); + } + + // read resident data from database + signedIdentity.pub = pProto->getBlob(DBKEY_SIGNED_IDENTITY_PUB); + signedIdentity.priv = pProto->getBlob(DBKEY_SIGNED_IDENTITY_PRIV); + + MBinBuffer blob(pProto->getBlob(DBKEY_PREKEY)); + session_signed_pre_key *signed_pre_key; + session_signed_pre_key_deserialize(&signed_pre_key, blob.data(), blob.length(), m_pContext); + + ec_key_pair *pKeys = session_signed_pre_key_get_key_pair(signed_pre_key); + auto *pPubKey = ec_key_pair_get_public(pKeys); + preKey.pub.assign(pPubKey->data, sizeof(pPubKey->data)); + + auto *pPrivKey = ec_key_pair_get_private(pKeys); + preKey.priv.assign(pPrivKey->data, sizeof(pPrivKey->data)); + + preKey.signature.assign(session_signed_pre_key_get_signature(signed_pre_key), session_signed_pre_key_get_signature_len(signed_pre_key)); + preKey.keyid = session_signed_pre_key_get_id(signed_pre_key); + SIGNAL_UNREF(signed_pre_key); + + // create store with callbacks + signal_protocol_store_context_create(&m_pStore, m_pContext); + + signal_protocol_session_store ss; + ss.contains_session_func = &contains_session_func; + ss.delete_all_sessions_func = &delete_all_sessions_func; + ss.delete_session_func = &delete_session_func; + ss.destroy_func = &destroy_func; + ss.get_sub_device_sessions_func = &get_sub_device_sessions_func; + ss.load_session_func = &load_session_func; + ss.store_session_func = &store_session_func; + ss.user_data = this; + signal_protocol_store_context_set_session_store(m_pStore, &ss); + + signal_protocol_pre_key_store sp; + sp.contains_pre_key = &contains_pre_key; + sp.destroy_func = &destroy_func; + sp.load_pre_key = &load_pre_key; + sp.remove_pre_key = &remove_pre_key; + sp.store_pre_key = &store_pre_key; + sp.user_data = this; + signal_protocol_store_context_set_pre_key_store(m_pStore, &sp); + + signal_protocol_signed_pre_key_store ssp; + ssp.contains_signed_pre_key = &contains_signed_pre_key; + ssp.destroy_func = &destroy_func; + ssp.load_signed_pre_key = &load_signed_pre_key; + ssp.remove_signed_pre_key = &remove_signed_pre_key; + ssp.store_signed_pre_key = &store_signed_pre_key; + ssp.user_data = this; + signal_protocol_store_context_set_signed_pre_key_store(m_pStore, &ssp); + + signal_protocol_identity_key_store sip; + sip.destroy_func = &destroy_func; + sip.get_identity_key_pair = &get_identity_key_pair; + sip.get_local_registration_id = &get_local_registration_id; + sip.is_trusted_identity = &is_trusted_identity; + sip.save_identity = &save_identity; + sip.user_data = this; + signal_protocol_store_context_set_identity_key_store(m_pStore, &sip); +} + +///////////////////////////////////////////////////////////////////////////////////////// +// MSignalSession members + +MSignalSession::MSignalSession(const CMStringA &_1, int _2) : + szName(_1) +{ + address.name = szName.GetBuffer(); + address.name_len = szName.GetLength(); + address.device_id = _2; +} + +MSignalSession::~MSignalSession() +{ + session_cipher_free(cipher); +} + +bool MSignalSession::hasAddress(const char *name, size_t name_len) const +{ + if (address.name_len != name_len) + return false; + return memcmp(address.name, name, name_len) == 0; +} + +///////////////////////////////////////////////////////////////////////////////////////// + +MSignalSession* MSignalStore::createSession(const CMStringA &szName, int deviceId) +{ + MSignalSession tmp(szName, deviceId); + auto *pSession = arSessions.find(&tmp); + if (pSession == nullptr) { + pSession = new MSignalSession(szName, deviceId); + arSessions.insert(pSession); + } + + if (pSession->cipher == nullptr) + if (session_cipher_create(&pSession->cipher, m_pStore, &pSession->address, m_pContext) < 0) + throw "session_cipher_create failure"; + + return pSession; +} + +///////////////////////////////////////////////////////////////////////////////////////// + +signal_buffer* MSignalStore::decryptSignalProto(const CMStringA &from, const char *pszType, const MBinBuffer &encrypted) +{ + WAJid jid(from); + auto *pSession = createSession(jid.user, 0); + + signal_buffer *result = nullptr; + if (!mir_strcmp(pszType, "pkmsg")) { + pre_key_signal_message *pMsg; + if (pre_key_signal_message_deserialize(&pMsg, (BYTE *)encrypted.data(), encrypted.length(), m_pContext) < 0) + throw "unable to deserialize prekey message"; + + if (session_cipher_decrypt_pre_key_signal_message(pSession->getCipher(), pMsg, this, &result) < 0) + throw "unable to decrypt prekey message"; + + pre_key_signal_message_destroy((signal_type_base*)pMsg); + } + else { + signal_message *pMsg; + if (signal_message_deserialize(&pMsg, (BYTE *)encrypted.data(), encrypted.length(), m_pContext) < 0) + throw "unable to deserialize signal message"; + + if (session_cipher_decrypt_signal_message(pSession->getCipher(), pMsg, this, &result) < 0) + throw "unable to decrypt signal message"; + + signal_message_destroy((signal_type_base *)pMsg); + } + + return result; +} + +signal_buffer* MSignalStore::decryptGroupSignalProto(const CMStringA &group, const CMStringA &sender, const MBinBuffer &encrypted) +{ + WAJid jid(sender); + auto *pSession = createSession(group + CMStringA(FORMAT, "::%s::%d", jid.user.c_str(), jid.device), 0); + + signal_message *pMsg; + if (signal_message_deserialize(&pMsg, (BYTE *)encrypted.data(), encrypted.length(), m_pContext) < 0) + throw "unable to deserialize signal message"; + + signal_buffer *result = nullptr; + if (session_cipher_decrypt_signal_message(pSession->getCipher(), pMsg, this, &result) < 0) + throw "unable to decrypt signal message"; + + signal_message_destroy((signal_type_base *)pMsg); + return result; +} + +///////////////////////////////////////////////////////////////////////////////////////// +// generate and save pre keys set + +void MSignalStore::generatePrekeys(int count) +{ + int iNextKeyId = pProto->getDword(DBKEY_PREKEY_NEXT_ID, 1); + + CMStringA szSetting; + signal_protocol_key_helper_pre_key_list_node *keys_root; + signal_protocol_key_helper_generate_pre_keys(&keys_root, iNextKeyId, count, m_pContext); + for (auto *it = keys_root; it; it = signal_protocol_key_helper_key_list_next(it)) { + session_pre_key *pre_key = signal_protocol_key_helper_key_list_element(it); + uint32_t pre_key_id = session_pre_key_get_id(pre_key); + + SignalBuffer buf(pre_key); + szSetting.Format("PreKey%d", pre_key_id); + db_set_blob(0, pProto->m_szModuleName, szSetting, buf.data(), buf.len()); + + ec_key_pair *pre_key_pair = session_pre_key_get_key_pair(pre_key); + auto *pPubKey = ec_key_pair_get_public(pre_key_pair); + szSetting.Format("PreKey%dPublic", pre_key_id); + db_set_blob(0, pProto->m_szModuleName, szSetting, pPubKey->data, sizeof(pPubKey->data)); + } + signal_protocol_key_helper_key_list_free(keys_root); + + pProto->setDword(DBKEY_PREKEY_NEXT_ID, iNextKeyId + count); +} + +///////////////////////////////////////////////////////////////////////////////////////// + +void MSignalStore::processSenderKeyMessage(const proto::Message_SenderKeyDistributionMessage &) +{ +} diff --git a/protocols/WhatsApp/src/stdafx.cxx b/protocols/WhatsApp/src/stdafx.cxx new file mode 100644 index 0000000000..7942e82b45 --- /dev/null +++ b/protocols/WhatsApp/src/stdafx.cxx @@ -0,0 +1,8 @@ +/* + +WhatsApp plugin for Miranda NG +Copyright © 2019-22 George Hazan + +*/ + +#include "stdafx.h" diff --git a/protocols/WhatsApp/src/stdafx.h b/protocols/WhatsApp/src/stdafx.h new file mode 100644 index 0000000000..80d130a5ec --- /dev/null +++ b/protocols/WhatsApp/src/stdafx.h @@ -0,0 +1,81 @@ +/* + +WhatsApp plugin for Miranda NG +Copyright © 2019-22 George Hazan + +*/ + +#pragma once +#pragma warning(disable:4996 4290 4200 4239 4324) + +#include +#include +#include +#include +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include "../../libs/libqrencode/src/qrencode.h" +#include "../../libs/zlib/src/zlib.h" + +#include "../../utils/mir_signal.h" + +///////////////////////////////////////////////////////////////////////////////////////// +// to obtain protobuf library do the following +// - install vcpkg (https://github.com/microsoft/vcpkg); +// - integrage vcpkg into Visual Studio: +// >vcpkg.exe integrate install +// - install dynamic libraries of protobuf: +// >vcpkg.exe install protobuf:x86-windows +// >vcpkg.exe install protobuf:x64-windows + +#include "google/protobuf/message.h" +#include "pmsg.pb.h" + +using namespace google::protobuf; + +///////////////////////////////////////////////////////////////////////////////////////// + +#include "db.h" +#include "utils.h" +#include "proto.h" +#include "resource.h" + +#pragma comment(lib, "libcrypto.lib") diff --git a/protocols/WhatsApp/src/utils.cpp b/protocols/WhatsApp/src/utils.cpp new file mode 100644 index 0000000000..debfa43f42 --- /dev/null +++ b/protocols/WhatsApp/src/utils.cpp @@ -0,0 +1,373 @@ +/* + +WhatsApp plugin for Miranda NG +Copyright © 2019-22 George Hazan + +*/ + +#include "stdafx.h" + +WAJid::WAJid(const char *pszUser, const char *pszServer, int iDevice, int iAgent) : + user(pszUser ? pszUser : ""), + server(pszServer ? pszServer : ""), + device(iDevice), + agent(iAgent) +{} + +WAJid::WAJid(const char *pszJid) +{ + if (pszJid == nullptr) + pszJid = ""; + + auto *tmp = NEWSTR_ALLOCA(pszJid); + auto *p = strrchr(tmp, '@'); + if (p) { + *p = 0; + server = p + 1; + } + + if (p = strrchr(tmp, ':')) { + *p = 0; + device = atoi(p + 1); + } + else device = 0; + + if (p = strrchr(tmp, '_')) { + *p = 0; + agent = atoi(p + 1); + } + else agent = 0; + + user = tmp; +} + +bool WAJid::isUser() const +{ return server == "s.whatsapp.net"; +} + +bool WAJid::isGroup() const +{ return server == "g.us"; +} + +bool WAJid::isBroadcast() const +{ + return server == "broadcast"; +} + +bool WAJid::isStatusBroadcast() const +{ + return isBroadcast() && user == "status"; +} + +CMStringA WAJid::toString() const +{ + CMStringA ret(user); + if (agent > 0) + ret.AppendFormat("_%d", agent); + if (device > 0) + ret.AppendFormat(":%d", device); + ret.AppendFormat("@%s", server.c_str()); + return ret; +} + +///////////////////////////////////////////////////////////////////////////////////////// + +WAUser* WhatsAppProto::FindUser(const char *szId) +{ + mir_cslock lck(m_csUsers); + auto *tmp = (WAUser *)_alloca(sizeof(WAUser)); + tmp->szId = (char*)szId; + return m_arUsers.find(tmp); +} + +WAUser* WhatsAppProto::AddUser(const char *szId, bool bTemporary, bool isChat) +{ + auto *pUser = FindUser(szId); + if (pUser != nullptr) + return pUser; + + MCONTACT hContact = db_add_contact(); + Proto_AddToContact(hContact, m_szModuleName); + + if (isChat) { + setByte(hContact, "ChatRoom", 1); + setString(hContact, "ChatRoomID", szId); + } + else { + setString(hContact, DBKEY_JID, szId); + if (m_wszDefaultGroup) + Clist_SetGroup(hContact, m_wszDefaultGroup); + } + + if (bTemporary) + Contact::RemoveFromList(hContact); + + pUser = new WAUser(hContact, mir_strdup(szId)); + pUser->bIsGroupChat = isChat; + + mir_cslock lck(m_csUsers); + m_arUsers.insert(pUser); + return pUser; +} + +///////////////////////////////////////////////////////////////////////////////////////// + +WA_PKT_HANDLER WhatsAppProto::FindPersistentHandler(const WANode &pNode) +{ + auto *pChild = pNode.getFirstChild(); + CMStringA szChild = (pChild) ? pChild->title : ""; + CMStringA szTitle = pNode.title; + CMStringA szType = pNode.getAttr("type"); + CMStringA szXmlns = pNode.getAttr("xmlns"); + + for (auto &it : m_arPersistent) { + if (it->pszTitle && szTitle != it->pszTitle) + continue; + if (it->pszType && szType != it->pszType) + continue; + if (it->pszXmlns && szXmlns != it->pszXmlns) + continue; + if (it->pszChild && szChild != it->pszChild) + continue; + return it->pHandler; + } + + return nullptr; +} + +///////////////////////////////////////////////////////////////////////////////////////// + +CMStringA WhatsAppProto::GenerateMessageId() +{ + return CMStringA(FORMAT, "%d.%d-%d", m_wMsgPrefix[0], m_wMsgPrefix[1], m_iPacketId++); +} + +///////////////////////////////////////////////////////////////////////////////////////// +// sends a piece of JSON to a server via a websocket, masked + +int WhatsAppProto::WSSend(const MessageLite &msg) +{ + if (m_hServerConn == nullptr) + return -1; + + int cbLen = msg.ByteSize(); + ptrA protoBuf((char *)mir_alloc(cbLen)); + msg.SerializeToArray(protoBuf, cbLen); + + Netlib_Dump(m_hServerConn, protoBuf, cbLen, true, 0); + + MBinBuffer payload = m_noise->encodeFrame(protoBuf, cbLen); + WebSocket_SendBinary(m_hServerConn, payload.data(), payload.length()); + return 0; +} + +///////////////////////////////////////////////////////////////////////////////////////// + +static char zeroData[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + +int WhatsAppProto::WSSendNode(WANode &node, WA_PKT_HANDLER pHandler) +{ + if (m_hServerConn == nullptr) + return 0; + + if (pHandler != nullptr) { + CMStringA id(GenerateMessageId()); + node.addAttr("id", id); + + mir_cslock lck(m_csPacketQueue); + m_arPacketQueue.insert(new WARequest(id, pHandler)); + } + + CMStringA szText; + node.print(szText); + debugLogA("Sending binary node:\n%s", szText.c_str()); + + WAWriter writer; + writer.writeNode(&node); + + MBinBuffer encData = m_noise->encrypt(writer.body.data(), writer.body.length()); + MBinBuffer payload = m_noise->encodeFrame(encData.data(), encData.length()); + WebSocket_SendBinary(m_hServerConn, payload.data(), payload.length()); + return 1; +} + +///////////////////////////////////////////////////////////////////////////////////////// + +uint32_t decodeBigEndian(const std::string &buf) +{ + uint32_t ret = 0; + for (auto &cc : buf) { + ret <<= 8; + ret += (uint8_t)cc; + } + + return ret; +} + +std::string encodeBigEndian(uint32_t num, size_t len) +{ + std::string res; + for (int i = 0; i < len; i++) { + char c = num & 0xFF; + res = c + res; + num >>= 8; + } + return res; +} + +void generateIV(uint8_t *iv, int &pVar) +{ + auto counter = encodeBigEndian(pVar); + memset(iv, 0, sizeof(iv)); + memcpy(iv + 8, counter.c_str(), sizeof(int)); + + pVar++; +} + +///////////////////////////////////////////////////////////////////////////////////////// +// Popups + +void WhatsAppProto::InitPopups(void) +{ + g_plugin.addPopupOption(CMStringW(FORMAT, TranslateT("%s error notifications"), m_tszUserName), m_bUsePopups); + + char name[256]; + mir_snprintf(name, "%s_%s", m_szModuleName, "Error"); + + wchar_t desc[256]; + mir_snwprintf(desc, L"%s/%s", m_tszUserName, TranslateT("Errors")); + + POPUPCLASS ppc = {}; + ppc.flags = PCF_UNICODE; + ppc.pszName = name; + ppc.pszDescription.w = desc; + ppc.hIcon = IcoLib_GetIconByHandle(m_hProtoIcon); + ppc.colorBack = RGB(191, 0, 0); //Red + ppc.colorText = RGB(255, 245, 225); //Yellow + ppc.iSeconds = 60; + m_hPopupClass = Popup_RegisterClass(&ppc); + + IcoLib_ReleaseIcon(ppc.hIcon); +} + +void WhatsAppProto::Popup(MCONTACT hContact, const wchar_t *szMsg, const wchar_t *szTitle) +{ + if (!m_bUsePopups) + return; + + char name[256]; + mir_snprintf(name, "%s_%s", m_szModuleName, "Error"); + + CMStringW wszTitle(szTitle); + if (hContact == 0) { + wszTitle.Insert(0, L": "); + wszTitle.Insert(0, m_tszUserName); + } + + POPUPDATACLASS ppd = {}; + ppd.szTitle.w = wszTitle; + ppd.szText.w = szMsg; + ppd.pszClassName = name; + ppd.hContact = hContact; + Popup_AddClass(&ppd); +} + +///////////////////////////////////////////////////////////////////////////////////////// + +MBinBuffer WhatsAppProto::unzip(const MBinBuffer &src) +{ + z_stream strm = {}; + inflateInit(&strm); + + strm.avail_in = (uInt)src.length(); + strm.next_in = (Bytef *)src.data(); + + MBinBuffer res; + Bytef buf[2048]; + + while (strm.avail_in > 0) { + strm.avail_out = sizeof(buf); + strm.next_out = buf; + + int ret = inflate(&strm, Z_NO_FLUSH); + switch (ret) { + case Z_NEED_DICT: + ret = Z_DATA_ERROR; + __fallthrough; + + case Z_DATA_ERROR: + case Z_MEM_ERROR: + inflateEnd(&strm); + return res; + } + + res.append(buf, sizeof(buf) - strm.avail_out); + } + + inflateEnd(&strm); + return res; +} + +///////////////////////////////////////////////////////////////////////////////////////// + +void bin2file(const MBinBuffer &buf, const wchar_t *pwszFileName) +{ + int fileId = _wopen(pwszFileName, _O_WRONLY | _O_TRUNC | _O_BINARY | _O_CREAT, _S_IREAD | _S_IWRITE); + if (fileId != -1) { + write(fileId, buf.data(), (unsigned)buf.length()); + close(fileId); + } +} + +void string2file(const std::string &str, const wchar_t *pwszFileName) +{ + int fileId = _wopen(pwszFileName, _O_WRONLY | _O_TRUNC | _O_BINARY | _O_CREAT, _S_IREAD | _S_IWRITE); + if (fileId != -1) { + write(fileId, str.c_str(), (unsigned)str.size()); + close(fileId); + } +} + +CMStringA directPath2url(const char *pszDirectPath) +{ + return CMStringA("https://mmg.whatsapp.net") + pszDirectPath; +} + +MBinBuffer WhatsAppProto::DownloadEncryptedFile(const char *url, const std::string &mediaKeys, const char *pszMediaType) +{ + NETLIBHTTPHEADER headers[1] = {{"Origin", "https://web.whatsapp.com"}}; + + NETLIBHTTPREQUEST req = {}; + req.cbSize = sizeof(req); + req.requestType = REQUEST_GET; + req.szUrl = (char*)url; + req.headersCount = _countof(headers); + req.headers = headers; + + MBinBuffer ret; + auto *pResp = Netlib_HttpTransaction(m_hNetlibUser, &req); + if (pResp) { + if (pResp->resultCode == 200) { + CMStringA pszHkdfString = pszMediaType; + pszHkdfString.SetAt(_toupper(pszHkdfString[0]), 0); + pszHkdfString = "WhatsApp " + pszHkdfString + " Keys"; + + // 0 - 15: iv + // 16 - 47: cipherKey + // 48 - 111: macKey + uint8_t out[112]; + HKDF(EVP_sha256(), (BYTE *)"", 0, (BYTE *)mediaKeys.c_str(), (int)mediaKeys.size(), (BYTE *)pszHkdfString.c_str(), pszHkdfString.GetLength(), out, sizeof(out)); + + ret = aesDecrypt(EVP_aes_256_cbc(), out + 16, out, pResp->pData, pResp->dataLength); + } + } + + return ret; +} + +CMStringW WhatsAppProto::GetTmpFileName(const char *pszClass, const char *pszAddition) +{ + CMStringW ret(VARSW(L"%miranda_userdata%")); + ret.AppendFormat(L"/%S/%S_%S", m_szModuleName, pszClass, pszAddition); + return ret; +} diff --git a/protocols/WhatsApp/src/utils.h b/protocols/WhatsApp/src/utils.h new file mode 100644 index 0000000000..778732e312 --- /dev/null +++ b/protocols/WhatsApp/src/utils.h @@ -0,0 +1,199 @@ +/* + +WhatsApp plugin for Miranda NG +Copyright © 2019-22 George Hazan + +*/ + +#define DICT_VERSION 2 + +#define LIST_EMPTY 0 +#define STREAM_END 2 +#define DICTIONARY_0 236 +#define DICTIONARY_1 237 +#define DICTIONARY_2 238 +#define DICTIONARY_3 239 +#define AD_JID 247 +#define LIST_8 248 +#define LIST_16 249 +#define JID_PAIR 250 +#define HEX_8 251 +#define BINARY_8 252 +#define BINARY_20 253 +#define BINARY_32 254 +#define NIBBLE_8 255 + +class WANode // kinda XML +{ + friend class WAReader; + friend class WAWriter; + + WANode *pParent = nullptr; + OBJLIST attrs; + OBJLIST children; + +public: + WANode(); + WANode(const char *pszTitle); + ~WANode(); + + void addAttr(const char *pszName, const char *pszValue); + void addAttr(const char *pszName, int iValue); + int getAttrInt(const char *pszName) const; + const char *getAttr(const char *pszName) const; + + CMStringA getBody() const; + + WANode *addChild(const char *pszName); + WANode *getChild(const char *pszName) const; + WANode *getFirstChild(void) const; + const OBJLIST &getChildren(void) const + { return children; + } + + void print(CMStringA &dest, int level = 0) const; + + CMStringA title; + MBinBuffer content; +}; + +__forceinline WANode &operator<<(WANode &node, const CHAR_PARAM ¶m) +{ + node.addAttr(param.szName, param.szValue); + return node; +} + +__forceinline WANode &operator<<(WANode &node, const INT_PARAM ¶m) +{ + node.addAttr(param.szName, param.iValue); + return node; +} + +///////////////////////////////////////////////////////////////////////////////////////// + +namespace IQ +{ + enum Type { GET, SET, RESULT }; +}; + +struct WANodeIq : public WANode +{ + WANodeIq(IQ::Type type, const char *pszXmlns = nullptr, const char *pszTo = nullptr); +}; + +///////////////////////////////////////////////////////////////////////////////////////// + +struct XCHILD +{ + const char *name, *value; + + __forceinline XCHILD(const char *_name) : + name(_name) + {} +}; + +__forceinline WANode& operator<<(WANode &node, const XCHILD &child) +{ + node.addChild(child.name); + return node; +} + +///////////////////////////////////////////////////////////////////////////////////////// +// WAReader + +class WAReader +{ + const BYTE *m_buf, *m_limit; + + uint32_t readIntN(int i); + CMStringA readStringFromChars(int size); + + bool readAttributes(WANode *node, int count); + uint32_t readInt20(); + bool readList(WANode *pParent, int tag); + int readListSize(int tag); + CMStringA readPacked(int tag); + CMStringA readString(int tag); + +public: + WAReader(const void *buf, size_t cbLen) : + m_buf((BYTE*)buf), + m_limit((BYTE*)buf + cbLen) + {} + + WANode* readNode(); + + __forceinline uint32_t readInt8() { return readIntN(1); } + __forceinline uint32_t readInt16() { return readIntN(2); } + __forceinline uint32_t readInt32() { return readIntN(4); } +}; + +///////////////////////////////////////////////////////////////////////////////////////// +// WAWriter + +class WAWriter +{ + __forceinline void writeInt8(int value) { writeIntN(value, 1); } + __forceinline void writeInt16(int value) { writeIntN(value, 2); } + __forceinline void writeInt32(int value) { writeIntN(value, 4); } + + void writeByte(uint8_t b); + void writeIntN(int value, int i); + void writeInt20(int value); + void writeLength(int value); + void writeListSize(int tag); + void writePacked(const CMStringA &str, int tag); + void writeString(const char *str); + bool writeToken(const char *str); + +public: + void writeNode(const WANode *pNode); + + MBinBuffer body; +}; + +///////////////////////////////////////////////////////////////////////////////////////// + +struct WAJid +{ + int device, agent; + CMStringA user, server; + + WAJid(const char *pszJid); + WAJid(const char *pszUser, const char *pszServer, int device = 0, int agent = 0); + + CMStringA toString() const; + + bool isUser() const; + bool isGroup() const; + bool isBroadcast() const; + bool isStatusBroadcast() const; +}; + +///////////////////////////////////////////////////////////////////////////////////////// + +void bin2file(const MBinBuffer &buf, const wchar_t *pwszFileName); +void string2file(const std::string &str, const wchar_t *pwszFileName); +CMStringA directPath2url(const char *pszDirectPath); + +MBinBuffer aesDecrypt( + const EVP_CIPHER *cipher, + const uint8_t *key, + const uint8_t *iv, + const void *data, size_t dataLen, + const void *additionalData = 0, size_t additionalLen = 0); + +uint32_t decodeBigEndian(const std::string &buf); +std::string encodeBigEndian(uint32_t num, size_t len = sizeof(uint32_t)); + +void generateIV(uint8_t *iv, int &pVar); + +__forceinline bool operator<<(MessageLite &msg, const MBinBuffer &buf) +{ return msg.ParseFromArray(buf.data(), (int)buf.length()); +} + +unsigned char* HKDF(const EVP_MD *evp_md, + const unsigned char *salt, size_t salt_len, + const unsigned char *key, size_t key_len, + const unsigned char *info, size_t info_len, + unsigned char *okm, size_t okm_len); diff --git a/protocols/WhatsApp/src/version.h b/protocols/WhatsApp/src/version.h new file mode 100644 index 0000000000..18e50dd07e --- /dev/null +++ b/protocols/WhatsApp/src/version.h @@ -0,0 +1,14 @@ +#define __MAJOR_VERSION 0 +#define __MINOR_VERSION 0 +#define __RELEASE_NUM 1 +#define __BUILD_NUM 1 + +#include + +#define __PLUGIN_NAME "WhatsApp protocol" +#define __FILENAME "WhatsApp.dll" +#define __DESCRIPTION "WhatsApp protocol support for Miranda NG." +#define __AUTHOR "George Hazan" +#define __AUTHOREMAIL "" +#define __AUTHORWEB "https://miranda-ng.org/p/WhatsApp/" +#define __COPYRIGHT "© 2019-22 Miranda NG Team" diff --git a/protocols/WhatsApp/src/wanode.cpp b/protocols/WhatsApp/src/wanode.cpp new file mode 100644 index 0000000000..cbe9408f20 --- /dev/null +++ b/protocols/WhatsApp/src/wanode.cpp @@ -0,0 +1,599 @@ +/* + +WhatsApp plugin for Miranda NG +Copyright © 2019-22 George Hazan + +*/ + +#include "stdafx.h" +#include "dicts.h" + +struct Attr +{ + Attr(const char *pszName, const char *pszValue) : + name(pszName), + value(pszValue) + {} + + Attr(const char *pszName, int iValue) : + name(pszName), + value(FORMAT, "%d", iValue) + {} + + CMStringA name, value; +}; + +///////////////////////////////////////////////////////////////////////////////////////// +// WANodeIq members + +WANodeIq::WANodeIq(IQ::Type type, const char *pszXmlns, const char *pszTo) : + WANode("iq") +{ + switch (type) { + case IQ::GET: addAttr("type", "get"); break; + case IQ::SET: addAttr("type", "set"); break; + case IQ::RESULT: addAttr("type", "result"); break; + } + + if (pszXmlns) + addAttr("xmlns", pszXmlns); + + addAttr("to", pszTo ? pszTo : S_WHATSAPP_NET); +} + +///////////////////////////////////////////////////////////////////////////////////////// +// WANode members + +WANode::WANode() : + attrs(1), + children(1) +{} + +WANode::WANode(const char *pszTitle) : + attrs(1), + children(1), + title(pszTitle) +{} + +WANode::~WANode() +{ +} + +const char *WANode::getAttr(const char *pszName) const +{ + if (this != nullptr) + for (auto &p : attrs) + if (p->name == pszName) + return p->value.c_str(); + + return nullptr; +} + +int WANode::getAttrInt(const char *pszName) const +{ + if (this != nullptr) + for (auto &p : attrs) + if (p->name == pszName) + return atoi(p->value.c_str()); + + return 0; +} + +void WANode::addAttr(const char *pszName, const char *pszValue) +{ + attrs.insert(new Attr(pszName, pszValue)); +} + +void WANode::addAttr(const char *pszName, int iValue) +{ + attrs.insert(new Attr(pszName, iValue)); +} + +CMStringA WANode::getBody() const +{ + return CMStringA((char *)content.data(), (int)content.length()); +} + +WANode *WANode::addChild(const char *pszName) +{ + auto *pNew = new WANode(pszName); + pNew->pParent = this; + children.insert(pNew); + return pNew; +} + +WANode* WANode::getChild(const char *pszName) const +{ + for (auto &it : children) + if (it->title == pszName) + return it; + + return nullptr; +} + +WANode* WANode::getFirstChild(void) const +{ + return (children.getCount()) ? &children[0] : nullptr; +} + +void WANode::print(CMStringA &dest, int level) const +{ + for (int i = 0; i < level; i++) + dest.Append(" "); + + dest.AppendFormat("<%s ", title.c_str()); + for (auto &p : attrs) + dest.AppendFormat("%s=\"%s\" ", p->name.c_str(), p->value.c_str()); + dest.Truncate(dest.GetLength() - 1); + + if (content.isEmpty() && !children.getCount()) { + dest.Append("/>\n"); + return; + } + + dest.Append(">"); + if (!content.isEmpty()) { + ptrA tmp((char *)mir_alloc(content.length() * 2 + 1)); + bin2hex(content.data(), content.length(), tmp); + dest.AppendFormat("%s", tmp.get()); + } + + if (children.getCount()) { + dest.Append("\n"); + + for (auto &p : children) + p->print(dest, level + 1); + + for (int i = 0; i < level; i++) + dest.Append(" "); + } + + dest.AppendFormat("\n", title.c_str()); +} + +///////////////////////////////////////////////////////////////////////////////////////// +// WAReader class members + +bool WAReader::readAttributes(WANode *pNode, int count) +{ + if (count == 0) + return true; + + for (int i = 0; i < count; i++) { + CMStringA name = readString(readInt8()); + if (name.IsEmpty()) + return false; + + CMStringA value = readString(readInt8()); + if (value.IsEmpty()) + return false; + + pNode->addAttr(name, value); + } + return true; +} + +uint32_t WAReader::readInt20() +{ + if (m_limit - m_buf < 3) + return 0; + + int ret = (int(m_buf[0] & 0x0F) << 16) + (int(m_buf[1]) << 8) + int(m_buf[2]); + m_buf += 3; + return ret; +} + +uint32_t WAReader::readIntN(int n) +{ + if (m_limit - m_buf < n) + return 0; + + uint32_t res = 0; + for (int i = 0; i < n; i++, m_buf++) + res = (res <<= 8) + *m_buf; + return res; +} + +bool WAReader::readList(WANode *pParent, int tag) +{ + int size = readListSize(tag); + if (size == -1) + return false; + + for (int i = 0; i < size; i++) { + WANode *pNew = readNode(); + if (pNew == nullptr) + return false; + pParent->children.insert(pNew); + } + + return true; +} + +int WAReader::readListSize(int tag) +{ + switch (tag) { + case LIST_EMPTY: + return 0; + case LIST_8: + return readInt8(); + case LIST_16: + return readInt16(); + } + return -1; +} + +WANode *WAReader::readNode() +{ + int listSize = readListSize(readInt8()); + if (listSize == -1) + return nullptr; + + int descrTag = readInt8(); + if (descrTag == STREAM_END) + return nullptr; + + CMStringA name = readString(descrTag); + if (name.IsEmpty()) + return nullptr; + + std::unique_ptr ret(new WANode()); + ret->title = name.c_str(); + + if (!readAttributes(ret.get(), (listSize - 1) >> 1)) + return nullptr; + + if ((listSize % 2) == 1) + return ret.release(); + + int size, tag = readInt8(); + switch (tag) { + case LIST_EMPTY: case LIST_8: case LIST_16: + readList(ret.get(), tag); + break; + + case BINARY_8: + size = readInt8(); + +LBL_Binary: + if (m_limit - m_buf < size) + return false; + + ret->content.assign((void *)m_buf, size); + m_buf += size; + break; + + case BINARY_20: + size = readInt20(); + goto LBL_Binary; + + case BINARY_32: + size = readInt32(); + goto LBL_Binary; + + default: + CMStringA str = readString(tag); + ret->content.assign(str.GetBuffer(), str.GetLength() + 1); + } + + return ret.release(); +} + +///////////////////////////////////////////////////////////////////////////////////////// + +static int unpackHex(int val) +{ + if (val < 0 || val > 15) + return -1; + + return (val < 10) ? val + '0' : val - 10 + 'A'; +} + +static int unpackNibble(int val) +{ + if (val < 0 || val > 15) + return -1; + + switch (val) { + case 10: return '-'; + case 11: return '.'; + case 15: return 0; + default: return '0' + val; + } +} + +CMStringA WAReader::readPacked(int tag) +{ + int startByte = readInt8(); + bool bTrim = false; + if (startByte & 0x80) { + startByte &= ~0x80; + bTrim = true; + } + + CMStringA ret; + for (int i = 0; i < startByte; i++) { + BYTE b = readInt8(); + int lower = (tag == NIBBLE_8) ? unpackNibble(b >> 4) : unpackHex(b >> 4); + if (lower == -1) + return ""; + + int higher = (tag == NIBBLE_8) ? unpackNibble(b & 0x0F) : unpackHex(b & 0x0F); + if (higher == -1) + return ""; + + ret.AppendChar(lower); + ret.AppendChar(higher); + } + + if (bTrim && !ret.IsEmpty()) + ret.Truncate(ret.GetLength() - 1); + return ret; +} + +CMStringA WAReader::readString(int tag) +{ + if (tag >= 1 && tag < _countof(SingleByteTokens)) + return SingleByteTokens[tag]; + + int idx; + switch (tag) { + case DICTIONARY_0: + idx = readInt8(); + return (idx < _countof(dict0)) ? dict0[idx] : ""; + + case DICTIONARY_1: + idx = readInt8(); + return (idx < _countof(dict1)) ? dict1[idx] : ""; + + case DICTIONARY_2: + idx = readInt8(); + return (idx < _countof(dict2)) ? dict2[idx] : ""; + + case DICTIONARY_3: + idx = readInt8(); + return (idx < _countof(dict3)) ? dict3[idx] : ""; + + case LIST_EMPTY: + return ""; + + case BINARY_8: + return readStringFromChars(readInt8()); + + case BINARY_20: + return readStringFromChars(readInt20()); + + case BINARY_32: + return readStringFromChars(readInt32()); + + case NIBBLE_8: + case HEX_8: + return readPacked(tag); + + case AD_JID: + { + int agent = readInt8(); + int device = readInt8(); + WAJid jid(readString(readInt8()), "s.whatsapp.net", device, agent); + return jid.toString(); + } + + case JID_PAIR: + CMStringA s1 = readString(readInt8()); + CMStringA s2 = readString(readInt8()); + if (s1.IsEmpty() && s2.IsEmpty()) + break; + + return CMStringA(FORMAT, "%s@%s", s1.c_str(), s2.c_str()); + } + + // error + return ""; +} + +CMStringA WAReader::readStringFromChars(int size) +{ + if (m_limit - m_buf < size) + return ""; + + CMStringA ret((char *)m_buf, size); + m_buf += size; + return ret; +} + +///////////////////////////////////////////////////////////////////////////////////////// +// WAWriter class members + +void WAWriter::writeByte(uint8_t b) +{ + body.append(&b, 1); +} + +void WAWriter::writeIntN(int value, int n) +{ + for (int i = n - 1; i >= 0; i--) + writeByte((value >> i * 8) & 0xFF); +} + +void WAWriter::writeInt20(int value) +{ + writeByte((value >> 16) & 0xFF); + writeByte((value >> 8) & 0xFF); + writeByte(value & 0xFF); +} + +void WAWriter::writeLength(int value) +{ + if (value >= (1 << 20)) { + writeByte(BINARY_32); + writeInt32(value); + } + else if (value >= 256) { + writeByte(BINARY_20); + writeInt20(value); + } + else { + writeByte(BINARY_8); + writeInt8(value); + } +} + +void WAWriter::writeListSize(int length) +{ + if (length == 0) + writeByte(LIST_EMPTY); + else if (length < 256) { + writeByte(LIST_8); + writeInt8(length); + } + else { + writeByte(LIST_16); + writeInt16(length); + } +} + +void WAWriter::writeNode(const WANode *pNode) +{ + // we never send zipped content + if (pNode->pParent == nullptr) + writeByte(0); + + int numAttrs = (int)pNode->attrs.getCount(); + int hasContent = pNode->content.length() != 0 || pNode->children.getCount() != 0; + writeListSize(2 * numAttrs + 1 + hasContent); + + writeString(pNode->title.c_str()); + + // write attributes + for (auto &it : pNode->attrs) { + if (it->value.IsEmpty()) + continue; + + writeString(it->name.c_str()); + writeString(it->value.c_str()); + } + + // write contents + if (pNode->content.length()) { + writeLength((int)pNode->content.length()); + body.append(pNode->content.data(), pNode->content.length()); + } + // write children + else if (pNode->children.getCount()) { + writeListSize(pNode->children.getCount()); + for (auto &it : pNode->children) + writeNode(it); + } +} + +bool WAWriter::writeToken(const char *str) +{ + for (auto &it : SingleByteTokens) + if (!strcmp(str, it)) { + writeByte(int(&it - SingleByteTokens)); + return true; + } + + return false; +} + +///////////////////////////////////////////////////////////////////////////////////////// + +static BYTE packNibble(char c) +{ + if (c >= '0' && c <= '9') + return c - '0'; + + switch (c) { + case '-': return 10; + case '.': return 11; + case 0: return 15; + } + + return -1; +} + +static BYTE packHex(char c) +{ + if (c == 0) + return 15; + + if (c >= '0' && c <= '9') + return c - '0'; + + if (c >= 'A' && c <= 'F') + return c - 'A'; + + if (c >= 'a' && c <= 'f') + return c - 'a'; + + return -1; +} + +static BYTE packPair(int type, char c1, char c2) +{ + BYTE b1 = (type == NIBBLE_8) ? packNibble(c1) : packHex(c1); + BYTE b2 = (type == NIBBLE_8) ? packNibble(c2) : packHex(c2); + return (b1 << 4) + b2; +} + +static bool isNibble(const CMStringA &str) +{ + return strspn(str, "0123456789-.") == str.GetLength(); +} + +static bool isHex(const CMStringA &str) +{ + return strspn(str, "0123456789abcdefABCDEF-.") == str.GetLength(); +} + +void WAWriter::writePacked(const CMStringA &str, int tag) +{ + if (str.GetLength() > 254) + return; + + writeByte(tag); + + int len = str.GetLength() / 2; + BYTE firstByte = (str.GetLength() % 2) == 0 ? 0 : 0x81; + writeByte(firstByte + len); + + const char *p = str; + for (int i = 0; i < len; i++, p += 2) + writeByte(packPair(tag, p[0], p[1])); + + if (firstByte != 0) + writeByte(packPair(tag, p[0], 0)); +} + +void WAWriter::writeString(const char *str) +{ + if (writeToken(str)) + return; + + auto *pszDelimiter = strchr(str, '@'); + if (pszDelimiter) { + writeByte(JID_PAIR); + + if (pszDelimiter == str) // empty jid + writeByte(LIST_EMPTY); + else + writeString(CMStringA(str, int(pszDelimiter - str))); + + if (pszDelimiter[1] == 0) // empty jid + writeByte(LIST_EMPTY); + else + writeString(pszDelimiter + 1); + } + else { + CMStringA buf(str); + if (isNibble(buf)) + writePacked(buf, NIBBLE_8); + else if (isHex(buf)) + writePacked(buf, HEX_8); + else { + writeLength(buf.GetLength()); + body.append(buf, buf.GetLength()); + } + } +} diff --git a/protocols/WhatsAppWeb/WhatsAppWeb.vcxproj b/protocols/WhatsAppWeb/WhatsAppWeb.vcxproj deleted file mode 100644 index a3c27bbfc6..0000000000 --- a/protocols/WhatsAppWeb/WhatsAppWeb.vcxproj +++ /dev/null @@ -1,94 +0,0 @@ - - - - - Debug - Win32 - - - Debug - x64 - - - Release - Win32 - - - Release - x64 - - - - - {4d3554de-6e14-4f94-a909-a4b19151a47e} - - - {620e0be7-3763-4f35-9dbd-4770104e269c} - - - {e2a369cd-eda3-414f-8ad0-e732cd7ee68c} - - - - - - - {13E796AD-BEA4-4213-A1B8-E18E2397E544} - WhatsApp - - - false - x86-windows - $(Configuration) - - - false - x64-windows - $(Configuration) - - - - - - - Sync - - - - - NotUsing - - - - - - - - - - - NotUsing - - - - - - - Create - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/protocols/WhatsAppWeb/WhatsAppWeb.vcxproj.filters b/protocols/WhatsAppWeb/WhatsAppWeb.vcxproj.filters deleted file mode 100644 index a86fb8be96..0000000000 --- a/protocols/WhatsAppWeb/WhatsAppWeb.vcxproj.filters +++ /dev/null @@ -1,96 +0,0 @@ - - - - - - Source Files - - - Source Files - - - Source Files - - - Source Files - - - Source Files - - - Source Files - - - Source Files - - - Source Files - - - Source Files - - - Source Files - - - Source Files - - - Source Files - - - Source Files - - - Source Files - - - Source Files - - - Source Files - - - Source Files - - - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - - - Resource Files - - - Resource Files - - - - - Resource Files - - - \ No newline at end of file diff --git a/protocols/WhatsAppWeb/proto_whatsapp/CMakeLists.txt b/protocols/WhatsAppWeb/proto_whatsapp/CMakeLists.txt deleted file mode 100644 index 5193619806..0000000000 --- a/protocols/WhatsAppWeb/proto_whatsapp/CMakeLists.txt +++ /dev/null @@ -1,2 +0,0 @@ -set(TARGET Proto_WhatsApp) -include(${CMAKE_SOURCE_DIR}/cmake/icons.cmake) \ No newline at end of file diff --git a/protocols/WhatsAppWeb/proto_whatsapp/Proto_WhatsApp.vcxproj b/protocols/WhatsAppWeb/proto_whatsapp/Proto_WhatsApp.vcxproj deleted file mode 100644 index c802604562..0000000000 --- a/protocols/WhatsAppWeb/proto_whatsapp/Proto_WhatsApp.vcxproj +++ /dev/null @@ -1,32 +0,0 @@ - - - - - Debug - Win32 - - - Debug - x64 - - - Release - Win32 - - - Release - x64 - - - - Proto_WhatsApp - {64A2B403-90AF-4CF8-BC69-4E8D33872D64} - - - - - - - - - \ No newline at end of file diff --git a/protocols/WhatsAppWeb/proto_whatsapp/Proto_WhatsApp.vcxproj.filters b/protocols/WhatsAppWeb/proto_whatsapp/Proto_WhatsApp.vcxproj.filters deleted file mode 100644 index 5a286dab98..0000000000 --- a/protocols/WhatsAppWeb/proto_whatsapp/Proto_WhatsApp.vcxproj.filters +++ /dev/null @@ -1,18 +0,0 @@ - - - - - - Header Files - - - Source Files - - - Resource Files - - - Resource Files - - - \ No newline at end of file diff --git a/protocols/WhatsAppWeb/proto_whatsapp/res/Away.ico b/protocols/WhatsAppWeb/proto_whatsapp/res/Away.ico deleted file mode 100644 index 9c07e3fa13..0000000000 Binary files a/protocols/WhatsAppWeb/proto_whatsapp/res/Away.ico and /dev/null differ diff --git a/protocols/WhatsAppWeb/proto_whatsapp/res/Invisible.ico b/protocols/WhatsAppWeb/proto_whatsapp/res/Invisible.ico deleted file mode 100644 index cb743a4bfe..0000000000 Binary files a/protocols/WhatsAppWeb/proto_whatsapp/res/Invisible.ico and /dev/null differ diff --git a/protocols/WhatsAppWeb/proto_whatsapp/res/Offline.ico b/protocols/WhatsAppWeb/proto_whatsapp/res/Offline.ico deleted file mode 100644 index 4019c68283..0000000000 Binary files a/protocols/WhatsAppWeb/proto_whatsapp/res/Offline.ico and /dev/null differ diff --git a/protocols/WhatsAppWeb/proto_whatsapp/res/Online.ico b/protocols/WhatsAppWeb/proto_whatsapp/res/Online.ico deleted file mode 100644 index 2143ea1438..0000000000 Binary files a/protocols/WhatsAppWeb/proto_whatsapp/res/Online.ico and /dev/null differ diff --git a/protocols/WhatsAppWeb/proto_whatsapp/res/Proto_WhatsApp.rc b/protocols/WhatsAppWeb/proto_whatsapp/res/Proto_WhatsApp.rc deleted file mode 100644 index 469a8d4484..0000000000 --- a/protocols/WhatsAppWeb/proto_whatsapp/res/Proto_WhatsApp.rc +++ /dev/null @@ -1,72 +0,0 @@ -// Microsoft Visual C++ generated resource script. -// -#include "..\src\resource.h" - -#define APSTUDIO_READONLY_SYMBOLS -///////////////////////////////////////////////////////////////////////////// -// -// Generated from the TEXTINCLUDE 2 resource. -// -#include "afxres.h" - -///////////////////////////////////////////////////////////////////////////// -#undef APSTUDIO_READONLY_SYMBOLS - -///////////////////////////////////////////////////////////////////////////// -// Russian (Russia) resources - -#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_RUS) -LANGUAGE LANG_RUSSIAN, SUBLANG_DEFAULT - -#ifdef APSTUDIO_INVOKED -///////////////////////////////////////////////////////////////////////////// -// -// TEXTINCLUDE -// - -1 TEXTINCLUDE -BEGIN - "..\\src\\resource.h\0" -END - -2 TEXTINCLUDE -BEGIN - "#include ""afxres.h""\r\n" - "\0" -END - -3 TEXTINCLUDE -BEGIN - "\r\n" - "\0" -END - -#endif // APSTUDIO_INVOKED - - -///////////////////////////////////////////////////////////////////////////// -// -// Icon -// - -// Icon with lowest ID value placed first to ensure application icon -// remains consistent on all systems. -IDI_ICON1 ICON "Offline.ico" -IDI_ICON2 ICON "Online.ico" -IDI_ICON3 ICON "Away.ico" -IDI_ICON4 ICON "Invisible.ico" -#endif // Russian (Russia) resources -///////////////////////////////////////////////////////////////////////////// - - - -#ifndef APSTUDIO_INVOKED -///////////////////////////////////////////////////////////////////////////// -// -// Generated from the TEXTINCLUDE 3 resource. -// - - -///////////////////////////////////////////////////////////////////////////// -#endif // not APSTUDIO_INVOKED - diff --git a/protocols/WhatsAppWeb/proto_whatsapp/src/resource.h b/protocols/WhatsAppWeb/proto_whatsapp/src/resource.h deleted file mode 100644 index e9d1373ca0..0000000000 --- a/protocols/WhatsAppWeb/proto_whatsapp/src/resource.h +++ /dev/null @@ -1,20 +0,0 @@ -//{{NO_DEPENDENCIES}} -// Microsoft Visual C++ generated include file. -// Used by Proto_WhatsApp.rc -// -#define IDI_ICON1 105 -#define IDI_ICON2 104 -#define IDI_ICON3 128 -#define IDI_ICON4 130 -//#define IDI_ICON5 1002 - -// Next default values for new objects -// -#ifdef APSTUDIO_INVOKED -#ifndef APSTUDIO_READONLY_SYMBOLS -#define _APS_NEXT_RESOURCE_VALUE 106 -#define _APS_NEXT_COMMAND_VALUE 40001 -#define _APS_NEXT_CONTROL_VALUE 1001 -#define _APS_NEXT_SYMED_VALUE 101 -#endif -#endif diff --git a/protocols/WhatsAppWeb/res/version.rc b/protocols/WhatsAppWeb/res/version.rc deleted file mode 100644 index 5a5ddd63ed..0000000000 --- a/protocols/WhatsAppWeb/res/version.rc +++ /dev/null @@ -1,9 +0,0 @@ -// Microsoft Visual C++ generated resource script. -// -#ifdef APSTUDIO_INVOKED -#error this file is not editable by Microsoft Visual C++ -#endif //APSTUDIO_INVOKED - -#include "..\src\version.h" - -#include "..\..\build\Version.rc" diff --git a/protocols/WhatsAppWeb/res/whatsapp.ico b/protocols/WhatsAppWeb/res/whatsapp.ico deleted file mode 100644 index 7a0dc4c68d..0000000000 Binary files a/protocols/WhatsAppWeb/res/whatsapp.ico and /dev/null differ diff --git a/protocols/WhatsAppWeb/res/whatsapp.rc b/protocols/WhatsAppWeb/res/whatsapp.rc deleted file mode 100644 index 1d32f6b828..0000000000 --- a/protocols/WhatsAppWeb/res/whatsapp.rc +++ /dev/null @@ -1,171 +0,0 @@ -// Microsoft Visual C++ generated resource script. -// -#pragma code_page(65001) - -#include "..\src\resource.h" - -#define APSTUDIO_READONLY_SYMBOLS -///////////////////////////////////////////////////////////////////////////// -// -// Generated from the TEXTINCLUDE 2 resource. -// -#include "afxres.h" - -///////////////////////////////////////////////////////////////////////////// -#undef APSTUDIO_READONLY_SYMBOLS - -///////////////////////////////////////////////////////////////////////////// -// English (United States) resources - -#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) -LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US - -///////////////////////////////////////////////////////////////////////////// -// -// Dialog -// - -IDD_SHOWQR DIALOGEX 0, 0, 318, 337 -STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU -CAPTION "Dialog" -FONT 8, "MS Shell Dlg", 400, 0, 0x1 -BEGIN - CONTROL "",IDC_QRPIC,"Static",SS_BITMAP | SS_NOTIFY | SS_CENTERIMAGE | SS_REALSIZEIMAGE | SS_SUNKEN,7,7,304,304 - CTEXT "Open WhatsApp application on your mobile phone and use it to read this QR code\nA window will disappear automatically after it",IDC_STATIC,8,314,302,17 -END - -IDD_ACCMGRUI DIALOGEX 0, 0, 188, 144 -STYLE DS_SETFONT | DS_FIXEDSYS | WS_CHILD -EXSTYLE WS_EX_CONTROLPARENT -FONT 8, "MS Shell Dlg", 400, 0, 0x0 -BEGIN - LTEXT "Nick:",IDC_STATIC,3,6,55,10 - EDITTEXT IDC_NICK,61,4,119,12,ES_AUTOHSCROLL - LTEXT "Default group:",IDC_STATIC,4,23,55,10 - EDITTEXT IDC_DEFGROUP,62,21,119,12,ES_AUTOHSCROLL - CONTROL "Do not open chat windows on creation",IDC_HIDECHATS, - "Button",BS_AUTOCHECKBOX | WS_TABSTOP,0,37,182,10 -END - -IDD_OPTIONS DIALOGEX 0, 0, 305, 188 -STYLE DS_SETFONT | DS_FIXEDSYS | WS_CHILD -EXSTYLE WS_EX_CONTROLPARENT -FONT 8, "MS Shell Dlg", 0, 0, 0x1 -BEGIN - LTEXT "Nick:",IDC_STATIC,5,6,79,10 - EDITTEXT IDC_NICK,87,5,211,12,ES_AUTOHSCROLL - LTEXT "Default group:",IDC_STATIC,5,24,79,10 - EDITTEXT IDC_DEFGROUP,87,23,211,12,ES_AUTOHSCROLL - CONTROL "Do not open chat windows on creation",IDC_HIDECHATS, - "Button",BS_AUTOCHECKBOX | WS_TABSTOP,4,43,294,10 -END - -IDD_GROUPCHAT_INVITE DIALOGEX 0, 0, 215, 170 -STYLE DS_SETFONT | DS_MODALFRAME | DS_SETFOREGROUND | DS_FIXEDSYS | DS_CENTER | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU -CAPTION "Invite users" -FONT 8, "MS Shell Dlg", 0, 0, 0x1 -BEGIN - GROUPBOX "Choose a user",IDC_STATIC,4,2,208,130 - CONTROL "",IDC_CLIST,"CListControl",WS_TABSTOP | 0x1,12,12,192,112,WS_EX_CLIENTEDGE - LTEXT "Other user:",IDC_STATIC,4,138,55,8 - EDITTEXT IDC_NEWJID,60,136,152,12,ES_AUTOHSCROLL - DEFPUSHBUTTON "&Invite",IDOK,108,152,50,14 - PUSHBUTTON "Cancel",IDCANCEL,162,152,50,14 -END - - -///////////////////////////////////////////////////////////////////////////// -// -// Icon -// - -// Icon with lowest ID value placed first to ensure application icon -// remains consistent on all systems. -IDI_WHATSAPP ICON "whatsapp.ico" - - -#ifdef APSTUDIO_INVOKED -///////////////////////////////////////////////////////////////////////////// -// -// TEXTINCLUDE -// - -1 TEXTINCLUDE -BEGIN - "..\\src\\resource.h\0" -END - -2 TEXTINCLUDE -BEGIN - "#include ""afxres.h""\r\n" - "\0" -END - -3 TEXTINCLUDE -BEGIN - "\r\n" - "\0" -END - -#endif // APSTUDIO_INVOKED - - -///////////////////////////////////////////////////////////////////////////// -// -// DESIGNINFO -// - -#ifdef APSTUDIO_INVOKED -GUIDELINES DESIGNINFO -BEGIN - IDD_SHOWQR, DIALOG - BEGIN - BOTTOMMARGIN, 332 - END - - IDD_ACCMGRUI, DIALOG - BEGIN - END - - IDD_OPTIONS, DIALOG - BEGIN - END -END -#endif // APSTUDIO_INVOKED - - -///////////////////////////////////////////////////////////////////////////// -// -// AFX_DIALOG_LAYOUT -// - -IDD_SHOWQR AFX_DIALOG_LAYOUT -BEGIN - 0 -END - -IDD_ACCMGRUI AFX_DIALOG_LAYOUT -BEGIN - 0 -END - -IDD_OPTIONS AFX_DIALOG_LAYOUT -BEGIN - 0 -END - -#endif // English (United States) resources -///////////////////////////////////////////////////////////////////////////// - - - -#ifndef APSTUDIO_INVOKED -///////////////////////////////////////////////////////////////////////////// -// -// Generated from the TEXTINCLUDE 3 resource. -// - - -///////////////////////////////////////////////////////////////////////////// -#endif // not APSTUDIO_INVOKED - diff --git a/protocols/WhatsAppWeb/src/avatars.cpp b/protocols/WhatsAppWeb/src/avatars.cpp deleted file mode 100644 index c9eefb9d6b..0000000000 --- a/protocols/WhatsAppWeb/src/avatars.cpp +++ /dev/null @@ -1,158 +0,0 @@ -/* - -WhatsAppWeb plugin for Miranda NG -Copyright © 2019-22 George Hazan - -*/ - -#include "stdafx.h" - -void WhatsAppProto::OnGetAvatarInfo(const JSONNode &root, void *pUserInfo) -{ - if (!root) return; - - MCONTACT hContact = (UINT_PTR)pUserInfo; - - PROTO_AVATAR_INFORMATION ai = {}; - ai.hContact = hContact; - ai.format = PA_FORMAT_JPEG; - wcsncpy_s(ai.filename, GetAvatarFileName(hContact), _TRUNCATE); - - DWORD dwLastChangeTime = _wtoi(root["tag"].as_mstring()); - - CMStringA szUrl(root["eurl"].as_mstring()); - if (szUrl.IsEmpty()) { - setDword(hContact, DBKEY_AVATAR_TAG, 0); // avatar doesn't exist, don't check it later - -LBL_Error: - ProtoBroadcastAck(hContact, ACKTYPE_AVATAR, ACKRESULT_FAILED, HANDLE(&ai)); - return; - } - - // if avatar was changed or not present at all, download it - if (dwLastChangeTime > getDword(hContact, DBKEY_AVATAR_TAG)) { - if (!g_plugin.SaveFile(szUrl, ai)) - goto LBL_Error; - - // set timestamp of avatar being saved - setDword(hContact, DBKEY_AVATAR_TAG, dwLastChangeTime); - } - ProtoBroadcastAck(hContact, ACKTYPE_AVATAR, ACKRESULT_SUCCESS, HANDLE(&ai)); -} - -INT_PTR WhatsAppProto::GetAvatarInfo(WPARAM wParam, LPARAM lParam) -{ - PROTO_AVATAR_INFORMATION *pai = (PROTO_AVATAR_INFORMATION*)lParam; - - ptrA id(getStringA(pai->hContact, isChatRoom(pai->hContact) ? "ChatRoomID" : DBKEY_JID)); - if (id == NULL) - return GAIR_NOAVATAR; - - CMStringW tszFileName(GetAvatarFileName(pai->hContact)); - wcsncpy_s(pai->filename, tszFileName.c_str(), _TRUNCATE); - pai->format = PA_FORMAT_JPEG; - - DWORD dwTag = getDword(pai->hContact, DBKEY_AVATAR_TAG, -1); - if (dwTag == -1 || (wParam & GAIF_FORCE) != 0) - if (pai->hContact != NULL && isOnline()) { - // WSSend(CMStringA(FORMAT, "[\"query\",\"ProfilePicThumb\",\"%s\"]", id.get()), &WhatsAppProto::OnGetAvatarInfo, (void*)pai->hContact); - return GAIR_WAITFOR; - } - - debugLogA("No avatar"); - return GAIR_NOAVATAR; -} - -///////////////////////////////////////////////////////////////////////////////////////// - -INT_PTR WhatsAppProto::GetAvatarCaps(WPARAM wParam, LPARAM lParam) -{ - switch (wParam) { - case AF_PROPORTION: - return PIP_SQUARE; - - case AF_FORMATSUPPORTED: // Jabber supports avatars of virtually all formats - return PA_FORMAT_JPEG; - - case AF_ENABLED: - return TRUE; - - case AF_MAXSIZE: - POINT *size = (POINT*)lParam; - if (size) - size->x = size->y = 640; - return 0; - } - return -1; -} - -CMStringW WhatsAppProto::GetAvatarFileName(MCONTACT hContact) -{ - CMStringW result = m_tszAvatarFolder + L"\\"; - - CMStringA jid; - if (hContact != NULL) { - ptrA szId(getStringA(hContact, isChatRoom(hContact) ? "ChatRoomID" : DBKEY_JID)); - if (szId == NULL) - return L""; - - jid = szId; - } - else jid = m_szJid; - - return result + _A2T(jid.c_str()) + L".jpg"; -} - -INT_PTR WhatsAppProto::GetMyAvatar(WPARAM wParam, LPARAM lParam) -{ - std::wstring tszOwnAvatar(m_tszAvatarFolder + L"\\myavatar.jpg"); - wcsncpy_s((wchar_t*)wParam, lParam, tszOwnAvatar.c_str(), _TRUNCATE); - return 0; -} - -INT_PTR WhatsAppProto::SetMyAvatar(WPARAM, LPARAM) -{ - return 0; -} - -///////////////////////////////////////////////////////////////////////////////////////// - -bool CMPlugin::SaveFile(const char *pszUrl, PROTO_AVATAR_INFORMATION &ai) -{ - NETLIBHTTPREQUEST req = {}; - req.cbSize = sizeof(req); - req.flags = NLHRF_NODUMP | NLHRF_PERSISTENT | NLHRF_SSL | NLHRF_HTTP11 | NLHRF_REDIRECT; - req.requestType = REQUEST_GET; - req.szUrl = (char*)pszUrl; - req.nlc = hAvatarConn; - - NETLIBHTTPREQUEST *pReply = Netlib_HttpTransaction(hAvatarUser, &req); - if (pReply == nullptr) { - hAvatarConn = nullptr; - debugLogA("Failed to retrieve avatar from url: %s", pszUrl); - return false; - } - - hAvatarConn = pReply->nlc; - - bool bSuccess = false; - if (pReply->resultCode == 200 && pReply->pData && pReply->dataLength) { - if (auto *pszHdr = Netlib_GetHeader(pReply, "Content-Type")) - ai.format = ProtoGetAvatarFormatByMimeType(pszHdr); - - if (ai.format != PA_FORMAT_UNKNOWN) { - FILE *fout = _wfopen(ai.filename, L"wb"); - if (fout) { - fwrite(pReply->pData, 1, pReply->dataLength, fout); - fclose(fout); - bSuccess = true; - } - else debugLogA("Error saving avatar to file %S", ai.filename); - } - else debugLogA("unknown avatar mime type"); - } - else debugLogA("Error %d reading avatar from url: %s", pReply->resultCode, pszUrl); - - Netlib_FreeHttpRequest(pReply); - return bSuccess; -} diff --git a/protocols/WhatsAppWeb/src/chats.cpp b/protocols/WhatsAppWeb/src/chats.cpp deleted file mode 100644 index a478fae692..0000000000 --- a/protocols/WhatsAppWeb/src/chats.cpp +++ /dev/null @@ -1,99 +0,0 @@ -/* - -WhatsAppWeb plugin for Miranda NG -Copyright © 2019-22 George Hazan - -*/ - -#include "stdafx.h" - -void WhatsAppProto::InitChat(WAUser *pUser) -{ - CMStringA jid = ""; - CMStringW wszId(Utf2T(jid.c_str())), wszNick(Utf2T("")); - - setWString(pUser->hContact, "Nick", wszNick); - - pUser->si = Chat_NewSession(GCW_CHATROOM, m_szModuleName, wszId, wszNick); - - Chat_AddGroup(pUser->si, TranslateT("Owner")); - Chat_AddGroup(pUser->si, TranslateT("SuperAdmin")); - Chat_AddGroup(pUser->si, TranslateT("Admin")); - Chat_AddGroup(pUser->si, TranslateT("Participant")); - - Chat_Control(m_szModuleName, wszId, m_bHideGroupchats ? WINDOW_HIDDEN : SESSION_INITDONE); - Chat_Control(m_szModuleName, wszId, SESSION_ONLINE); - - if (!pUser->bInited) { - // CMStringA query(FORMAT, "[\"query\",\"GroupMetadata\",\"%s\"]", jid.c_str()); - // WSSend(query, &WhatsAppProto::OnGetChatInfo, pUser); - } -} - -void WhatsAppProto::OnGetChatInfo(const JSONNode &root, void *param) -{ - auto *pChatUser = (WAUser *)param; - pChatUser->bInited = true; - - CMStringW wszOwner(root["owner"].as_mstring()), wszNick; - - for (auto &it : root["participants"]) { - CMStringW jid(it["id"].as_mstring()); - CMStringA szJid(jid); - - GCEVENT gce = { m_szModuleName, 0, GC_EVENT_JOIN }; - gce.pszID.w = pChatUser->si->ptszID; - gce.pszUID.w = jid; - gce.bIsMe = (szJid == m_szJid); - - if (jid == wszOwner) - gce.pszStatus.w = L"Owner"; - else if (it["isSuperAdmin"].as_bool()) - gce.pszStatus.w = L"SuperAdmin"; - else if (it["isAdmin"].as_bool()) - gce.pszStatus.w = L"Admin"; - else - gce.pszStatus.w = L"Participant"; - - if (gce.bIsMe) - wszNick = getMStringW(DBKEY_NICK); - else if (auto *pUser = FindUser(szJid)) - wszNick = Clist_GetContactDisplayName(pUser->hContact); - else { - int iPos = jid.Find('@'); - wszNick = (iPos != -1) ? jid.Left(iPos - 1) : jid; - } - - gce.pszNick.w = wszNick; - Chat_Event(&gce); - } - - if (pChatUser->arHistory.getCount()) { - for (auto &it : pChatUser->arHistory) { - CMStringW jid(it->jid), text(Utf2T(it->text)); - - GCEVENT gce = { m_szModuleName, 0, GC_EVENT_MESSAGE }; - gce.pszID.w = pChatUser->si->ptszID; - gce.dwFlags = GCEF_ADDTOLOG; - gce.pszUID.w = jid; - gce.pszText.w = text; - gce.time = it->timestamp; - gce.bIsMe = (it->jid == m_szJid); - Chat_Event(&gce); - } - pChatUser->arHistory.destroy(); - } - - CMStringW wszSubject(root["subject"].as_mstring()); - if (!wszSubject.IsEmpty()) { - time_t iSubjectTime(root["subjectTime"].as_int()); - CMStringW wszSubjectSet(root["subjectOwner"].as_mstring()); - - GCEVENT gce = { m_szModuleName, 0, GC_EVENT_TOPIC }; - gce.pszID.w = pChatUser->si->ptszID; - gce.pszUID.w = wszSubjectSet; - gce.pszText.w = wszSubject; - gce.time = iSubjectTime; - Chat_Event(&gce); - } -} diff --git a/protocols/WhatsAppWeb/src/crypt.cpp b/protocols/WhatsAppWeb/src/crypt.cpp deleted file mode 100644 index 6d3e86d919..0000000000 --- a/protocols/WhatsAppWeb/src/crypt.cpp +++ /dev/null @@ -1,140 +0,0 @@ -/* - -WhatsAppWeb plugin for Miranda NG -Copyright © 2019-22 George Hazan - -*/ - -#include "stdafx.h" - -MBinBuffer aesDecrypt( - const EVP_CIPHER *cipher, - const uint8_t *key, - const uint8_t *iv, - const void *data, size_t dataLen, - const void *additionalData, size_t additionalLen) -{ - int tag_len = 0, dec_len = 0, final_len = 0; - EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new(); - EVP_DecryptInit_ex(ctx, cipher, NULL, key, iv); - - if (additionalLen) - EVP_DecryptUpdate(ctx, nullptr, &tag_len, (uint8_t *)additionalData, (int)additionalLen); - - dataLen -= 16; - EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_TAG, 16, (uint8_t *)data + dataLen); - - MBinBuffer ret; - uint8_t outbuf[2000]; - for (size_t len = 0; len < dataLen; len += 1024) { - size_t portionSize = dataLen - len; - EVP_DecryptUpdate(ctx, outbuf, &dec_len, (uint8_t *)data + len, (int)min(portionSize, 1024)); - ret.append(outbuf, dec_len); - } - - EVP_DecryptFinal_ex(ctx, outbuf, &final_len); - if (final_len) - ret.append(outbuf, final_len); - - EVP_CIPHER_CTX_free(ctx); - return ret; -} - -///////////////////////////////////////////////////////////////////////////////////////// - -static unsigned char *HKDF_Extract(const EVP_MD *evp_md, - const unsigned char *salt, size_t salt_len, - const unsigned char *key, size_t key_len, - unsigned char *prk, size_t *prk_len) -{ - unsigned int tmp_len; - - if (!HMAC(evp_md, salt, (int)salt_len, key, (int)key_len, prk, &tmp_len)) - return NULL; - - *prk_len = tmp_len; - return prk; -} - -static unsigned char *HKDF_Expand(const EVP_MD *evp_md, - const unsigned char *prk, size_t prk_len, - const unsigned char *info, size_t info_len, - unsigned char *okm, size_t okm_len) -{ - HMAC_CTX *hmac; - unsigned char *ret = NULL; - - unsigned int i; - - unsigned char prev[EVP_MAX_MD_SIZE]; - - size_t done_len = 0, dig_len = EVP_MD_size(evp_md); - - size_t n = okm_len / dig_len; - if (okm_len % dig_len) - n++; - - if (n > 255 || okm == NULL) - return NULL; - - if ((hmac = HMAC_CTX_new()) == NULL) - return NULL; - - if (!HMAC_Init_ex(hmac, prk, (int)prk_len, evp_md, NULL)) - goto err; - - for (i = 1; i <= n; i++) { - size_t copy_len; - const unsigned char ctr = i; - - if (i > 1) { - if (!HMAC_Init_ex(hmac, NULL, 0, NULL, NULL)) - goto err; - - if (!HMAC_Update(hmac, prev, dig_len)) - goto err; - } - - if (!HMAC_Update(hmac, info, info_len)) - goto err; - - if (!HMAC_Update(hmac, &ctr, 1)) - goto err; - - if (!HMAC_Final(hmac, prev, NULL)) - goto err; - - copy_len = (done_len + dig_len > okm_len) ? - okm_len - done_len : - dig_len; - - memcpy(okm + done_len, prev, copy_len); - - done_len += copy_len; - } - ret = okm; - -err: - OPENSSL_cleanse(prev, sizeof(prev)); - HMAC_CTX_free(hmac); - return ret; -} - -unsigned char *HKDF(const EVP_MD *evp_md, - const unsigned char *salt, size_t salt_len, - const unsigned char *key, size_t key_len, - const unsigned char *info, size_t info_len, - unsigned char *okm, size_t okm_len) -{ - unsigned char prk[EVP_MAX_MD_SIZE]; - unsigned char *ret; - size_t prk_len; - - if (!HKDF_Extract(evp_md, salt, salt_len, key, key_len, prk, &prk_len)) - return NULL; - - ret = HKDF_Expand(evp_md, prk, prk_len, info, info_len, okm, okm_len); - OPENSSL_cleanse(prk, sizeof(prk)); - - return ret; -} diff --git a/protocols/WhatsAppWeb/src/db.h b/protocols/WhatsAppWeb/src/db.h deleted file mode 100644 index 10c6f33822..0000000000 --- a/protocols/WhatsAppWeb/src/db.h +++ /dev/null @@ -1,43 +0,0 @@ -/* - -WhatsAppWeb plugin for Miranda NG -Copyright © 2019-22 George Hazan - -*/ - -#define MODULENAME "WhatsApp" - -// DB keys -#define DBKEY_JID "jid" -#define DBKEY_DEVICE_ID "DeviceId" -#define DBKEY_EPHEMERAL_TS "EphemeralTS" -#define DBKEY_EPHEMERAL_EXPIRE "EphemeralExpire" - -#define DBKEY_NOISE_PUB "NoisePublicKey" -#define DBKEY_NOISE_PRIV "NoisePrivateKey" - -#define DBKEY_SIGNED_IDENTITY_PUB "SignedIdentityPublicKey" -#define DBKEY_SIGNED_IDENTITY_PRIV "SignedIdentityPrivateKey" - -#define DBKEY_PREKEY "SignedPreKey0" -#define DBKEY_PREKEY_NEXT_ID "PrekeyNextId" -#define DBKEY_PREKEY_UPLOAD_ID "PrekeyUploadId" - -#define DBKEY_REG_ID "RegistrationId" -#define DBKEY_SECRET_KEY "AdvSecretKey" - -#define DBKEY_NICK "Nick" -#define DBKEY_DEF_GROUP "DefaultGroup" -#define DBKEY_AUTORUNCHATS "AutoRunChats" -#define DBKEY_AVATAR_TAG "AvatarTag" - -#define DBKEY_EVENT_CLIENT_COLBACK "PopupClientColorBack" -#define DBKEY_EVENT_CLIENT_COLTEXT "PopupClientColorText" -#define DBKEY_EVENT_CLIENT_TIMEOUT "PopupClientTimeout" -#define DBKEY_EVENT_CLIENT_DEFAULT "PopupClientColorDefault" - -#define DBKEY_EVENT_OTHER_COLBACK "PopupOtherColorBack" -#define DBKEY_EVENT_OTHER_COLTEXT "PopupOtherColorText" -#define DBKEY_EVENT_OTHER_TIMEOUT "PopupOtherTimeout" -#define DBKEY_EVENT_OTHER_DEFAULT "PopupOtherColorDefault" - diff --git a/protocols/WhatsAppWeb/src/dicts.h b/protocols/WhatsAppWeb/src/dicts.h deleted file mode 100644 index 281983c618..0000000000 --- a/protocols/WhatsAppWeb/src/dicts.h +++ /dev/null @@ -1,194 +0,0 @@ -/* - -WhatsAppWeb plugin for Miranda NG -Copyright © 2019-22 George Hazan - -*/ - -static char *SingleByteTokens[] = { - "", "xmlstreamstart", "xmlstreamend", "s.whatsapp.net", "type", "participant", "from", "receipt", "id", "broadcast", "status", "message", "notification", "notify", "to", "jid", "user", - "class", "offline", "g.us", "result", "mediatype", "enc", "skmsg", "off_cnt", "xmlns", "presence", "participants", "ack", "t", "iq", "device_hash", "read", "value", "media", "picture", - "chatstate", "unavailable", "text", "urn:xmpp:whatsapp:push", "devices", "verified_name", "contact", "composing", "edge_routing", "routing_info", "item", "image", "verified_level", - "get", "fallback_hostname", "2", "media_conn", "1", "v", "handshake", "fallback_class", "count", "config", "offline_preview", "download_buckets", "w:profile:picture", "set", - "creation", "location", "fallback_ip4", "msg", "urn:xmpp:ping", "fallback_ip6", "call-creator", "relaylatency", "success", "subscribe", "video", "business_hours_config", - "platform", "hostname", "version", "unknown", "0", "ping", "hash", "edit", "subject", "max_buckets", "download", "delivery", "props", "sticker", "name", "last", "contacts", - "business", "primary", "preview", "w:p", "pkmsg", "call-id", "retry", "prop", "call", "auth_ttl", "available", "relay_id", "last_id", "day_of_week", "w", "host", "seen", - "bits", "list", "atn", "upload", "is_new", "w:stats", "key", "paused", "specific_hours", "multicast", "stream:error", "mmg.whatsapp.net", "code", "deny", "played", "profile", - "fna", "device-list", "close_time", "latency", "gcm", "pop", "audio", "26", "w:web", "open_time", "error", "auth", "ip4", "update", "profile_options", "config_value", "category", - "catalog_not_created", "00", "config_code", "mode", "catalog_status", "ip6", "blocklist", "registration", "7", "web", "fail", "w:m", "cart_enabled", "ttl", "gif", "300", - "device_orientation", "identity", "query", "401", "media-gig2-1.cdn.whatsapp.net", "in", "3", "te2", "add", "fallback", "categories", "ptt", "encrypt", "notice", - "thumbnail-document", "item-not-found", "12", "thumbnail-image", "stage", "thumbnail-link", "usync", "out", "thumbnail-video", "8", "01", "context", "sidelist", - "thumbnail-gif", "terminate", "not-authorized", "orientation", "dhash", "capability", "side_list", "md-app-state", "description", "serial", "readreceipts", "te", - "business_hours", "md-msg-hist", "tag", "attribute_padding", "document", "open_24h", "delete", "expiration", "active", "prev_v_id", "true", "passive", "index", "4", - "conflict", "remove", "w:gp2", "config_expo_key", "screen_height", "replaced", "02", "screen_width", "uploadfieldstat", "2:47DEQpj8", "media-bog1-1.cdn.whatsapp.net", - "encopt", "url", "catalog_exists", "keygen", "rate", "offer", "opus", "media-mia3-1.cdn.whatsapp.net", "privacy", "media-mia3-2.cdn.whatsapp.net", "signature", - "preaccept", "token_id", "media-eze1-1.cdn.whatsapp.net" -}; - -static char *dict0[] = { - "media-for1-1.cdn.whatsapp.net", "relay", "media-gru2-2.cdn.whatsapp.net", "uncompressed", "medium", "voip_settings", "device", "reason", - "media-lim1-1.cdn.whatsapp.net", "media-qro1-2.cdn.whatsapp.net", "media-gru1-2.cdn.whatsapp.net", "action", "features", "media-gru2-1.cdn.whatsapp.net", - "media-gru1-1.cdn.whatsapp.net", "media-otp1-1.cdn.whatsapp.net", "kyc-id", "priority", "phash", "mute", "token", "100", "media-qro1-1.cdn.whatsapp.net", - "none", "media-mrs2-2.cdn.whatsapp.net", "sign_credential", "03", "media-mrs2-1.cdn.whatsapp.net", "protocol", "timezone", "transport", "eph_setting", "1080", - "original_dimensions", "media-frx5-1.cdn.whatsapp.net", "background", "disable", "original_image_url", "5", "transaction-id", "direct_path", "103", "appointment_only", - "request_image_url", "peer_pid", "address", "105", "104", "102", "media-cdt1-1.cdn.whatsapp.net", "101", "109", "110", "106", "background_location", "v_id", "sync", - "status-old", "111", "107", "ppic", "media-scl2-1.cdn.whatsapp.net", "business_profile", "108", "invite", "04", "audio_duration", "media-mct1-1.cdn.whatsapp.net", - "media-cdg2-1.cdn.whatsapp.net", "media-los2-1.cdn.whatsapp.net", "invis", "net", "voip_payload_type", "status-revoke-delay", "404", "state", "use_correct_order_for_hmac_sha1", - "ver", "media-mad1-1.cdn.whatsapp.net", "order", "540", "skey", "blinded_credential", "android", "contact_remove", "enable_downlink_relay_latency_only", "duration", - "enable_vid_one_way_codec_nego", "6", "media-sof1-1.cdn.whatsapp.net", "accept", "all", "signed_credential", "media-atl3-1.cdn.whatsapp.net", "media-lhr8-1.cdn.whatsapp.net", - "website", "05", "latitude", "media-dfw5-1.cdn.whatsapp.net", "forbidden", "enable_audio_piggyback_network_mtu_fix", "media-dfw5-2.cdn.whatsapp.net", "note.m4r", - "media-atl3-2.cdn.whatsapp.net", "jb_nack_discard_count_fix", "longitude", "Opening.m4r", "media-arn2-1.cdn.whatsapp.net", "email", "timestamp", "admin", - "media-pmo1-1.cdn.whatsapp.net", "America/Sao_Paulo", "contact_add", "media-sin6-1.cdn.whatsapp.net", "interactive", "8000", "acs_public_key", - "sigquit_anr_detector_release_rollover_percent", "media.fmed1-2.fna.whatsapp.net", "groupadd", "enabled_for_video_upgrade", "latency_update_threshold", - "media-frt3-2.cdn.whatsapp.net", "calls_row_constraint_layout", "media.fgbb2-1.fna.whatsapp.net", "mms4_media_retry_notification_encryption_enabled", "timeout", - "media-sin6-3.cdn.whatsapp.net", "audio_nack_jitter_multiplier", "jb_discard_count_adjust_pct_rc", "audio_reserve_bps", "delta", "account_sync", "default", - "media.fjed4-6.fna.whatsapp.net", "06", "lock_video_orientation", "media-frt3-1.cdn.whatsapp.net", "w:g2", "media-sin6-2.cdn.whatsapp.net", "audio_nack_algo_mask", - "media.fgbb2-2.fna.whatsapp.net", "media.fmed1-1.fna.whatsapp.net", "cond_range_target_bitrate", "mms4_server_error_receipt_encryption_enabled", "vid_rc_dyn", "fri", - "cart_v1_1_order_message_changes_enabled", "reg_push", "jb_hist_deposit_value", "privatestats", "media.fist7-2.fna.whatsapp.net", "thu", "jb_discard_count_adjust_pct", - "mon", "group_call_video_maximization_enabled", "mms_cat_v1_forward_hot_override_enabled", "audio_nack_new_rtt", "media.fsub2-3.fna.whatsapp.net", - "media_upload_aggressive_retry_exponential_backoff_enabled", "tue", "wed", "media.fruh4-2.fna.whatsapp.net", "audio_nack_max_seq_req", "max_rtp_audio_packet_resends", - "jb_hist_max_cdf_value", "07", "audio_nack_max_jb_delay", "mms_forward_partially_downloaded_video", "media-lcy1-1.cdn.whatsapp.net", "resume", "jb_inband_fec_aware", - "new_commerce_entry_point_enabled", "480", "payments_upi_generate_qr_amount_limit", "sigquit_anr_detector_rollover_percent", "media.fsdu2-1.fna.whatsapp.net", "fbns", - "aud_pkt_reorder_pct", "dec", "stop_probing_before_accept_send", "media_upload_max_aggressive_retries", "edit_business_profile_new_mode_enabled", - "media.fhex4-1.fna.whatsapp.net", "media.fjed4-3.fna.whatsapp.net", "sigquit_anr_detector_64bit_rollover_percent", "cond_range_ema_jb_last_delay", - "watls_enable_early_data_http_get", "media.fsdu2-2.fna.whatsapp.net", "message_qr_disambiguation_enabled", "media-mxp1-1.cdn.whatsapp.net", "sat", "vertical", - "media.fruh4-5.fna.whatsapp.net", "200", "media-sof1-2.cdn.whatsapp.net", "-1", "height", "product_catalog_hide_show_items_enabled", "deep_copy_frm_last", - "tsoffline", "vp8/h.264", "media.fgye5-3.fna.whatsapp.net", "media.ftuc1-2.fna.whatsapp.net", "smb_upsell_chat_banner_enabled", "canonical", "08", "9", ".", - "media.fgyd4-4.fna.whatsapp.net", "media.fsti4-1.fna.whatsapp.net", "mms_vcache_aggregation_enabled", "mms_hot_content_timespan_in_seconds", "nse_ver", "rte", - "third_party_sticker_web_sync", "cond_range_target_total_bitrate", "media_upload_aggressive_retry_enabled", "instrument_spam_report_enabled", "disable_reconnect_tone", - "move_media_folder_from_sister_app", "one_tap_calling_in_group_chat_size", "10", "storage_mgmt_banner_threshold_mb", "enable_backup_passive_mode", "sharechat_inline_player_enabled", - "media.fcnq2-1.fna.whatsapp.net", "media.fhex4-2.fna.whatsapp.net", "media.fist6-3.fna.whatsapp.net", "ephemeral_drop_column_stage", "reconnecting_after_network_change_threshold_ms", - "media-lhr8-2.cdn.whatsapp.net", "cond_jb_last_delay_ema_alpha", "entry_point_block_logging_enabled", "critical_event_upload_log_config", "respect_initial_bitrate_estimate", - "smaller_image_thumbs_status_enabled", "media.fbtz1-4.fna.whatsapp.net", "media.fjed4-1.fna.whatsapp.net", "width", "720", "enable_frame_dropper", "enable_one_side_mode", - "urn:xmpp:whatsapp:dirty", "new_sticker_animation_behavior_v2", "media.flim3-2.fna.whatsapp.net", "media.fuio6-2.fna.whatsapp.net", "skip_forced_signaling", "dleq_proof", - "status_video_max_bitrate", "lazy_send_probing_req", "enhanced_storage_management", "android_privatestats_endpoint_dit_enabled", "media.fscl13-2.fna.whatsapp.net", "video_duration" -}; - -static char *dict1[] = { - "group_call_discoverability_enabled", "media.faep9-2.fna.whatsapp.net", "msgr", "bloks_loggedin_access_app_id", "db_status_migration_step", "watls_prefer_ip6", - "jabber:iq:privacy", "68", "media.fsaw1-11.fna.whatsapp.net", "mms4_media_conn_persist_enabled", "animated_stickers_thread_clean_up", "media.fcgk3-2.fna.whatsapp.net", - "media.fcgk4-6.fna.whatsapp.net", "media.fgye5-2.fna.whatsapp.net", "media.flpb1-1.fna.whatsapp.net", "media.fsub2-1.fna.whatsapp.net", "media.fuio6-3.fna.whatsapp.net", - "not-allowed", "partial_pjpeg_bw_threshold", "cap_estimated_bitrate", "mms_chatd_resume_check_over_thrift", "smb_upsell_business_profile_enabled", "product_catalog_webclient", - "groups", "sigquit_anr_detector_release_updated_rollout", "syncd_key_rotation_enabled", "media.fdmm2-1.fna.whatsapp.net", "media-hou1-1.cdn.whatsapp.net", - "remove_old_chat_notifications", "smb_biztools_deeplink_enabled", "use_downloadable_filters_int", "group_qr_codes_enabled", "max_receipt_processing_time", - "optimistic_image_processing_enabled", "smaller_video_thumbs_status_enabled", "watls_early_data", "reconnecting_before_relay_failover_threshold_ms", "cond_range_packet_loss_pct", - "groups_privacy_blacklist", "status-revoke-drop", "stickers_animated_thumbnail_download", "dedupe_transcode_shared_images", "dedupe_transcode_shared_videos", - "media.fcnq2-2.fna.whatsapp.net", "media.fgyd4-1.fna.whatsapp.net", "media.fist7-1.fna.whatsapp.net", "media.flim3-3.fna.whatsapp.net", "add_contact_by_qr_enabled", - "https://faq.whatsapp.com/payments", "multicast_limit_global", "sticker_notification_preview", "smb_better_catalog_list_adapters_enabled", "bloks_use_minscript_android", - "pen_smoothing_enabled", "media.fcgk4-5.fna.whatsapp.net", "media.fevn1-3.fna.whatsapp.net", "media.fpoj7-1.fna.whatsapp.net", "media-arn2-2.cdn.whatsapp.net", - "reconnecting_before_network_change_threshold_ms", "android_media_use_fresco_for_gifs", "cond_in_congestion", "status_image_max_edge", "sticker_search_enabled", - "starred_stickers_web_sync", "db_blank_me_jid_migration_step", "media.fist6-2.fna.whatsapp.net", "media.ftuc1-1.fna.whatsapp.net", "09", "anr_fast_logs_upload_rollout", - "camera_core_integration_enabled", "11", "third_party_sticker_caching", "thread_dump_contact_support", "wam_privatestats_enabled", "vcard_as_document_size_kb", "maxfpp", - "fbip", "ephemeral_allow_group_members", "media-bom1-2.cdn.whatsapp.net", "media-xsp1-1.cdn.whatsapp.net", "disable_prewarm", "frequently_forwarded_max", - "media.fbtz1-5.fna.whatsapp.net", "media.fevn7-1.fna.whatsapp.net", "media.fgyd4-2.fna.whatsapp.net", "sticker_tray_animation_fully_visible_items", - "green_alert_banner_duration", "reconnecting_after_p2p_failover_threshold_ms", "connected", "share_biz_vcard_enabled", "stickers_animation", "0a", "1200", "WhatsApp", - "group_description_length", "p_v_id", "payments_upi_intent_transaction_limit", "frequently_forwarded_messages", "media-xsp1-2.cdn.whatsapp.net", - "media.faep8-1.fna.whatsapp.net", "media.faep8-2.fna.whatsapp.net", "media.faep9-1.fna.whatsapp.net", "media.fdmm2-2.fna.whatsapp.net", "media.fgzt3-1.fna.whatsapp.net", - "media.flim4-2.fna.whatsapp.net", "media.frao1-1.fna.whatsapp.net", "media.fscl9-2.fna.whatsapp.net", "media.fsub2-2.fna.whatsapp.net", "superadmin", - "media.fbog10-1.fna.whatsapp.net", "media.fcgh28-1.fna.whatsapp.net", "media.fjdo10-1.fna.whatsapp.net", "third_party_animated_sticker_import", "delay_fec", - "attachment_picker_refresh", "android_linked_devices_re_auth_enabled", "rc_dyn", "green_alert_block_jitter", "add_contact_logging_enabled", "biz_message_logging_enabled", - "conversation_media_preview_v2", "media-jnb1-1.cdn.whatsapp.net", "ab_key", "media.fcgk4-2.fna.whatsapp.net", "media.fevn1-1.fna.whatsapp.net", "media.fist6-1.fna.whatsapp.net", - "media.fruh4-4.fna.whatsapp.net", "media.fsti4-2.fna.whatsapp.net", "mms_vcard_autodownload_size_kb", "watls_enabled", "notif_ch_override_off", "media.fsaw1-14.fna.whatsapp.net", - "media.fscl13-1.fna.whatsapp.net", "db_group_participant_migration_step", "1020", "cond_range_sterm_rtt", "invites_logging_enabled", "triggered_block_enabled", - "group_call_max_participants", "media-iad3-1.cdn.whatsapp.net", "product_catalog_open_deeplink", "shops_required_tos_version", "image_max_kbytes", - "cond_low_quality_vid_mode", "db_receipt_migration_step", "jb_early_prob_hist_shrink", "media.fdmm2-3.fna.whatsapp.net", "media.fdmm2-4.fna.whatsapp.net", - "media.fruh4-1.fna.whatsapp.net", "media.fsaw2-2.fna.whatsapp.net", "remove_geolocation_videos", "new_animation_behavior", "fieldstats_beacon_chance", "403", - "authkey_reset_on_ban", "continuous_ptt_playback", "reconnecting_after_relay_failover_threshold_ms", "false", "group", "sun", "conversation_swipe_to_reply", - "ephemeral_messages_setting", "smaller_video_thumbs_enabled", "md_device_sync_enabled", "bloks_shops_pdp_url_regex", "lasso_integration_enabled", - "media-bom1-1.cdn.whatsapp.net", "new_backup_format_enabled", "256", "media.faep6-1.fna.whatsapp.net", "media.fasr1-1.fna.whatsapp.net", "media.fbtz1-7.fna.whatsapp.net", - "media.fesb4-1.fna.whatsapp.net", "media.fjdo1-2.fna.whatsapp.net", "media.frba2-1.fna.whatsapp.net", "watls_no_dns", "600", "db_broadcast_me_jid_migration_step", - "new_wam_runtime_enabled", "group_update", "enhanced_block_enabled", "sync_wifi_threshold_kb", "mms_download_nc_cat", "bloks_minification_enabled", - "ephemeral_messages_enabled", "reject", "voip_outgoing_xml_signaling", "creator", "dl_bw", "payments_request_messages", "target_bitrate", "bloks_rendercore_enabled", - "media-hbe1-1.cdn.whatsapp.net", "media-hel3-1.cdn.whatsapp.net", "media-kut2-2.cdn.whatsapp.net", "media-lax3-1.cdn.whatsapp.net", "media-lax3-2.cdn.whatsapp.net", - "sticker_pack_deeplink_enabled", "hq_image_bw_threshold", "status_info", "voip", "dedupe_transcode_videos", "grp_uii_cleanup", "linked_device_max_count", - "media.flim1-1.fna.whatsapp.net", "media.fsaw2-1.fna.whatsapp.net", "reconnecting_after_call_active_threshold_ms", "1140", "catalog_pdp_new_design", - "media.fbtz1-10.fna.whatsapp.net", "media.fsaw1-15.fna.whatsapp.net", "0b", "consumer_rc_provider", "mms_async_fast_forward_ttl", "jb_eff_size_fix", - "voip_incoming_xml_signaling", "media_provider_share_by_uuid", "suspicious_links", "dedupe_transcode_images", "green_alert_modal_start", "media-cgk1-1.cdn.whatsapp.net", - "media-lga3-1.cdn.whatsapp.net", "template_doc_mime_types", "important_messages", "user_add", "vcard_max_size_kb", "media.fada2-1.fna.whatsapp.net", - "media.fbog2-5.fna.whatsapp.net", "media.fbtz1-3.fna.whatsapp.net", "media.fcgk3-1.fna.whatsapp.net", "media.fcgk7-1.fna.whatsapp.net", "media.flim1-3.fna.whatsapp.net", - "media.fscl9-1.fna.whatsapp.net", "ctwa_context_enterprise_enabled", "media.fsaw1-13.fna.whatsapp.net", "media.fuio11-2.fna.whatsapp.net", "status_collapse_muted", - "db_migration_level_force", "recent_stickers_web_sync", "bloks_session_state", "bloks_shops_enabled", "green_alert_setting_deep_links_enabled", "restrict_groups", - "battery", "green_alert_block_start", "refresh", "ctwa_context_enabled", "md_messaging_enabled", "status_image_quality", "md_blocklist_v2_server", - "media-del1-1.cdn.whatsapp.net", "13", "userrate", "a_v_id", "cond_rtt_ema_alpha", "invalid" -}; - -static char *dict2[] = { - "media.fada1-1.fna.whatsapp.net", "media.fadb3-2.fna.whatsapp.net", "media.fbhz2-1.fna.whatsapp.net", "media.fcor2-1.fna.whatsapp.net", "media.fjed4-2.fna.whatsapp.net", - "media.flhe4-1.fna.whatsapp.net", "media.frak1-2.fna.whatsapp.net", "media.fsub6-3.fna.whatsapp.net", "media.fsub6-7.fna.whatsapp.net", "media.fvvi1-1.fna.whatsapp.net", - "search_v5_eligible", "wam_real_time_enabled", "report_disk_event", "max_tx_rott_based_bitrate", "product", "media.fjdo10-2.fna.whatsapp.net", "video_frame_crc_sample_interval", - "media_max_autodownload", "15", "h.264", "wam_privatestats_buffer_count", "md_phash_v2_enabled", "account_transfer_enabled", "business_product_catalog", - "enable_non_dyn_codec_param_fix", "is_user_under_epd_jurisdiction", "media.fbog2-4.fna.whatsapp.net", "media.fbtz1-2.fna.whatsapp.net", "media.fcfc1-1.fna.whatsapp.net", - "media.fjed4-5.fna.whatsapp.net", "media.flhe4-2.fna.whatsapp.net", "media.flim1-2.fna.whatsapp.net", "media.flos5-1.fna.whatsapp.net", "android_key_store_auth_ver", - "010", "anr_process_monitor", "delete_old_auth_key", "media.fcor10-3.fna.whatsapp.net", "storage_usage_enabled", "android_camera2_support_level", "dirty", - "consumer_content_provider", "status_video_max_duration", "0c", "bloks_cache_enabled", "media.fadb2-2.fna.whatsapp.net", "media.fbko1-1.fna.whatsapp.net", - "media.fbtz1-9.fna.whatsapp.net", "media.fcgk4-4.fna.whatsapp.net", "media.fesb4-2.fna.whatsapp.net", "media.fevn1-2.fna.whatsapp.net", "media.fist2-4.fna.whatsapp.net", - "media.fjdo1-1.fna.whatsapp.net", "media.fruh4-6.fna.whatsapp.net", "media.fsrg5-1.fna.whatsapp.net", "media.fsub6-6.fna.whatsapp.net", "minfpp", "5000", "locales", - "video_max_bitrate", "use_new_auth_key", "bloks_http_enabled", "heartbeat_interval", "media.fbog11-1.fna.whatsapp.net", "ephemeral_group_query_ts", "fec_nack", - "search_in_storage_usage", "c", "media-amt2-1.cdn.whatsapp.net", "linked_devices_ui_enabled", "14", "async_data_load_on_startup", "voip_incoming_xml_ack", "16", - "db_migration_step", "init_bwe", "max_participants", "wam_buffer_count", "media.fada2-2.fna.whatsapp.net", "media.fadb3-1.fna.whatsapp.net", "media.fcor2-2.fna.whatsapp.net", - "media.fdiy1-2.fna.whatsapp.net", "media.frba3-2.fna.whatsapp.net", "media.fsaw2-3.fna.whatsapp.net", "1280", "status_grid_enabled", "w:biz", "product_catalog_deeplink", - "media.fgye10-2.fna.whatsapp.net", "media.fuio11-1.fna.whatsapp.net", "optimistic_upload", "work_manager_init", "lc", "catalog_message", "cond_net_medium", - "enable_periodical_aud_rr_processing", "cond_range_ema_rtt", "media-tir2-1.cdn.whatsapp.net", "frame_ms", "group_invite_sending", "payments_web_enabled", - "wallpapers_v2", "0d", "browser", "hq_image_max_edge", "image_edit_zoom", "linked_devices_re_auth_enabled", "media.faly3-2.fna.whatsapp.net", - "media.fdoh5-3.fna.whatsapp.net", "media.fesb3-1.fna.whatsapp.net", "media.fknu1-1.fna.whatsapp.net", "media.fmex3-1.fna.whatsapp.net", "media.fruh4-3.fna.whatsapp.net", - "255", "web_upgrade_to_md_modal", "audio_piggyback_timeout_msec", "enable_audio_oob_fec_feature", "from_ip", "image_max_edge", "message_qr_enabled", "powersave", - "receipt_pre_acking", "video_max_edge", "full", "011", "012", "enable_audio_oob_fec_for_sender", "md_voip_enabled", "enable_privatestats", "max_fec_ratio", - "payments_cs_faq_url", "media-xsp1-3.cdn.whatsapp.net", "hq_image_quality", "media.fasr1-2.fna.whatsapp.net", "media.fbog3-1.fna.whatsapp.net", - "media.ffjr1-6.fna.whatsapp.net", "media.fist2-3.fna.whatsapp.net", "media.flim4-3.fna.whatsapp.net", "media.fpbc2-4.fna.whatsapp.net", "media.fpku1-1.fna.whatsapp.net", - "media.frba1-1.fna.whatsapp.net", "media.fudi1-1.fna.whatsapp.net", "media.fvvi1-2.fna.whatsapp.net", "gcm_fg_service", "enable_dec_ltr_size_check", "clear", "lg", - "media.fgru11-1.fna.whatsapp.net", "18", "media-lga3-2.cdn.whatsapp.net", "pkey", "0e", "max_subject", "cond_range_lterm_rtt", "announcement_groups", "biz_profile_options", - "s_t", "media.fabv2-1.fna.whatsapp.net", "media.fcai3-1.fna.whatsapp.net", "media.fcgh1-1.fna.whatsapp.net", "media.fctg1-4.fna.whatsapp.net", "media.fdiy1-1.fna.whatsapp.net", - "media.fisb4-1.fna.whatsapp.net", "media.fpku1-2.fna.whatsapp.net", "media.fros9-1.fna.whatsapp.net", "status_v3_text", "usync_sidelist", "17", "announcement", "...", - "md_group_notification", "0f", "animated_pack_in_store", "013", "America/Mexico_City", "1260", "media-ams4-1.cdn.whatsapp.net", "media-cgk1-2.cdn.whatsapp.net", - "media-cpt1-1.cdn.whatsapp.net", "media-maa2-1.cdn.whatsapp.net", "media.fgye10-1.fna.whatsapp.net", "e", "catalog_cart", "hfm_string_changes", "init_bitrate", - "packless_hsm", "group_info", "America/Belem", "50", "960", "cond_range_bwe", "decode", "encode", "media.fada1-8.fna.whatsapp.net", "media.fadb1-2.fna.whatsapp.net", - "media.fasu6-1.fna.whatsapp.net", "media.fbog4-1.fna.whatsapp.net", "media.fcgk9-2.fna.whatsapp.net", "media.fdoh5-2.fna.whatsapp.net", "media.ffjr1-2.fna.whatsapp.net", - "media.fgua1-1.fna.whatsapp.net", "media.fgye1-1.fna.whatsapp.net", "media.fist1-4.fna.whatsapp.net", "media.fpbc2-2.fna.whatsapp.net", "media.fres2-1.fna.whatsapp.net", - "media.fsdq1-2.fna.whatsapp.net", "media.fsub6-5.fna.whatsapp.net", "profilo_enabled", "template_hsm", "use_disorder_prefetching_timer", "video_codec_priority", - "vpx_max_qp", "ptt_reduce_recording_delay", "25", "iphone", "Windows", "s_o", "Africa/Lagos", "abt", "media-kut2-1.cdn.whatsapp.net", "media-mba1-1.cdn.whatsapp.net", - "media-mxp1-2.cdn.whatsapp.net", "md_blocklist_v2", "url_text", "enable_short_offset", "group_join_permissions", "enable_audio_piggyback_feature", "image_quality", - "media.fcgk7-2.fna.whatsapp.net", "media.fcgk8-2.fna.whatsapp.net", "media.fclo7-1.fna.whatsapp.net", "media.fcmn1-1.fna.whatsapp.net", "media.feoh1-1.fna.whatsapp.net", - "media.fgyd4-3.fna.whatsapp.net", "media.fjed4-4.fna.whatsapp.net", "media.flim1-4.fna.whatsapp.net", "media.flim2-4.fna.whatsapp.net", "media.fplu6-1.fna.whatsapp.net", - "media.frak1-1.fna.whatsapp.net", "media.fsdq1-1.fna.whatsapp.net", "to_ip", "015", "vp8", "19", "21", "1320", "auth_key_ver", "message_processing_dedup", "server-error", - "wap4_enabled", "420", "014", "cond_range_rtt", "ptt_fast_lock_enabled", "media-ort2-1.cdn.whatsapp.net", "fwd_ui_start_ts" -}; - -static char *dict3[] = { - "contact_blacklist", "Asia/Jakarta", "media.fepa10-1.fna.whatsapp.net", "media.fmex10-3.fna.whatsapp.net", "disorder_prefetching_start_when_empty", "America/Bogota", - "use_local_probing_rx_bitrate", "America/Argentina/Buenos_Aires", "cross_post", "media.fabb1-1.fna.whatsapp.net", "media.fbog4-2.fna.whatsapp.net", "media.fcgk9-1.fna.whatsapp.net", - "media.fcmn2-1.fna.whatsapp.net", "media.fdel3-1.fna.whatsapp.net", "media.ffjr1-1.fna.whatsapp.net", "media.fgdl5-1.fna.whatsapp.net", "media.flpb1-2.fna.whatsapp.net", - "media.fmex2-1.fna.whatsapp.net", "media.frba2-2.fna.whatsapp.net", "media.fros2-2.fna.whatsapp.net", "media.fruh2-1.fna.whatsapp.net", "media.fybz2-2.fna.whatsapp.net", - "options", "20", "a", "017", "018", "mute_always", "user_notice", "Asia/Kolkata", "gif_provider", "locked", "media-gua1-1.cdn.whatsapp.net", "piggyback_exclude_force_flush", - "24", "media.frec39-1.fna.whatsapp.net", "user_remove", "file_max_size", "cond_packet_loss_pct_ema_alpha", "media.facc1-1.fna.whatsapp.net", "media.fadb2-1.fna.whatsapp.net", - "media.faly3-1.fna.whatsapp.net", "media.fbdo6-2.fna.whatsapp.net", "media.fcmn2-2.fna.whatsapp.net", "media.fctg1-3.fna.whatsapp.net", "media.ffez1-2.fna.whatsapp.net", - "media.fist1-3.fna.whatsapp.net", "media.fist2-2.fna.whatsapp.net", "media.flim2-2.fna.whatsapp.net", "media.fmct2-3.fna.whatsapp.net", "media.fpei3-1.fna.whatsapp.net", - "media.frba3-1.fna.whatsapp.net", "media.fsdu8-2.fna.whatsapp.net", "media.fstu2-1.fna.whatsapp.net", "media_type", "receipt_agg", "016", "enable_pli_for_crc_mismatch", - "live", "enc_rekey", "frskmsg", "d", "media.fdel11-2.fna.whatsapp.net", "proto", "2250", "audio_piggyback_enable_cache", "skip_nack_if_ltrp_sent", "mark_dtx_jb_frames", - "web_service_delay", "7282", "catalog_send_all", "outgoing", "360", "30", "LIMITED", "019", "audio_picker", "bpv2_phase", "media.fada1-7.fna.whatsapp.net", - "media.faep7-1.fna.whatsapp.net", "media.fbko1-2.fna.whatsapp.net", "media.fbni1-2.fna.whatsapp.net", "media.fbtz1-1.fna.whatsapp.net", "media.fbtz1-8.fna.whatsapp.net", - "media.fcjs3-1.fna.whatsapp.net", "media.fesb3-2.fna.whatsapp.net", "media.fgdl5-4.fna.whatsapp.net", "media.fist2-1.fna.whatsapp.net", "media.flhe2-2.fna.whatsapp.net", - "media.flim2-1.fna.whatsapp.net", "media.fmex1-1.fna.whatsapp.net", "media.fpat3-2.fna.whatsapp.net", "media.fpat3-3.fna.whatsapp.net", "media.fros2-1.fna.whatsapp.net", - "media.fsdu8-1.fna.whatsapp.net", "media.fsub3-2.fna.whatsapp.net", "payments_chat_plugin", "cond_congestion_no_rtcp_thr", "green_alert", "not-a-biz", "..", - "shops_pdp_urls_config", "source", "media-dus1-1.cdn.whatsapp.net", "mute_video", "01b", "currency", "max_keys", "resume_check", "contact_array", "qr_scanning", "23", - "b", "media.fbfh15-1.fna.whatsapp.net", "media.flim22-1.fna.whatsapp.net", "media.fsdu11-1.fna.whatsapp.net", "media.fsdu15-1.fna.whatsapp.net", "Chrome", "fts_version", - "60", "media.fada1-6.fna.whatsapp.net", "media.faep4-2.fna.whatsapp.net", "media.fbaq5-1.fna.whatsapp.net", "media.fbni1-1.fna.whatsapp.net", "media.fcai3-2.fna.whatsapp.net", - "media.fdel3-2.fna.whatsapp.net", "media.fdmm3-2.fna.whatsapp.net", "media.fhex3-1.fna.whatsapp.net", "media.fisb4-2.fna.whatsapp.net", "media.fkhi5-2.fna.whatsapp.net", - "media.flos2-1.fna.whatsapp.net", "media.fmct2-1.fna.whatsapp.net", "media.fntr7-1.fna.whatsapp.net", "media.frak3-1.fna.whatsapp.net", "media.fruh5-2.fna.whatsapp.net", - "media.fsub6-1.fna.whatsapp.net", "media.fuab1-2.fna.whatsapp.net", "media.fuio1-1.fna.whatsapp.net", "media.fver1-1.fna.whatsapp.net", "media.fymy1-1.fna.whatsapp.net", - "product_catalog", "1380", "audio_oob_fec_max_pkts", "22", "254", "media-ort2-2.cdn.whatsapp.net", "media-sjc3-1.cdn.whatsapp.net", "1600", "01a", "01c", "405", - "key_frame_interval", "body", "media.fcgh20-1.fna.whatsapp.net", "media.fesb10-2.fna.whatsapp.net", "125", "2000", "media.fbsb1-1.fna.whatsapp.net", - "media.fcmn3-2.fna.whatsapp.net", "media.fcpq1-1.fna.whatsapp.net", "media.fdel1-2.fna.whatsapp.net", "media.ffor2-1.fna.whatsapp.net", "media.fgdl1-4.fna.whatsapp.net", - "media.fhex2-1.fna.whatsapp.net", "media.fist1-2.fna.whatsapp.net", "media.fjed5-2.fna.whatsapp.net", "media.flim6-4.fna.whatsapp.net", "media.flos2-2.fna.whatsapp.net", - "media.fntr6-2.fna.whatsapp.net", "media.fpku3-2.fna.whatsapp.net", "media.fros8-1.fna.whatsapp.net", "media.fymy1-2.fna.whatsapp.net", "ul_bw", "ltrp_qp_offset", - "request", "nack", "dtx_delay_state_reset", "timeoffline", "28", "01f", "32", "enable_ltr_pool", "wa_msys_crypto", "01d", "58", "dtx_freeze_hg_update", - "nack_if_rpsi_throttled", "253", "840", "media.famd15-1.fna.whatsapp.net", "media.fbog17-2.fna.whatsapp.net", "media.fcai19-2.fna.whatsapp.net", "media.fcai21-4.fna.whatsapp.net", - "media.fesb10-4.fna.whatsapp.net", "media.fesb10-5.fna.whatsapp.net", "media.fmaa12-1.fna.whatsapp.net", "media.fmex11-3.fna.whatsapp.net", "media.fpoa33-1.fna.whatsapp.net", - "1050", "021", "clean", "cond_range_ema_packet_loss_pct", "media.fadb6-5.fna.whatsapp.net", "media.faqp4-1.fna.whatsapp.net", "media.fbaq3-1.fna.whatsapp.net", - "media.fbel2-1.fna.whatsapp.net", "media.fblr4-2.fna.whatsapp.net", "media.fclo8-1.fna.whatsapp.net", "media.fcoo1-2.fna.whatsapp.net", "media.ffjr1-4.fna.whatsapp.net", - "media.ffor9-1.fna.whatsapp.net", "media.fisb3-1.fna.whatsapp.net", "media.fkhi2-2.fna.whatsapp.net", "media.fkhi4-1.fna.whatsapp.net", "media.fpbc1-2.fna.whatsapp.net", - "media.fruh2-2.fna.whatsapp.net", "media.fruh5-1.fna.whatsapp.net", "media.fsub3-1.fna.whatsapp.net", "payments_transaction_limit", "252", "27", "29", "tintagel", "01e", - "237", "780", "callee_updated_payload", "020", "257", "price", "025", "239", "payments_cs_phone_number", "mediaretry", "w:auth:backup:token", "Glass.caf", "max_bitrate", - "240", "251", "660", "media.fbog16-1.fna.whatsapp.net", "media.fcgh21-1.fna.whatsapp.net", "media.fkul19-2.fna.whatsapp.net", "media.flim21-2.fna.whatsapp.net", - "media.fmex10-4.fna.whatsapp.net", "64", "33", "34", "35", "interruption", "media.fabv3-1.fna.whatsapp.net", "media.fadb6-1.fna.whatsapp.net", "media.fagr1-1.fna.whatsapp.net", - "media.famd1-1.fna.whatsapp.net", "media.famm6-1.fna.whatsapp.net", "media.faqp2-3.fna.whatsapp.net" -}; diff --git a/protocols/WhatsAppWeb/src/iq.cpp b/protocols/WhatsAppWeb/src/iq.cpp deleted file mode 100644 index 4f74567f0c..0000000000 --- a/protocols/WhatsAppWeb/src/iq.cpp +++ /dev/null @@ -1,709 +0,0 @@ -/* - -WhatsAppWeb plugin for Miranda NG -Copyright © 2019-22 George Hazan - -*/ - -#include "stdafx.h" - -void WhatsAppProto::OnAccountSync(const WANode &node) -{ - m_arDevices.destroy(); - - for (auto &it : node.getChild("devices")->getChildren()) - if (it->title == "device") - m_arDevices.insert(new WADevice(it->getAttr("jid"), it->getAttrInt("key-index"))); -} - -///////////////////////////////////////////////////////////////////////////////////////// - -void WhatsAppProto::OnIqBlockList(const WANode &node) -{ - for (auto &it : node.getChild("list")->getChildren()) { - auto *pUser = AddUser(it->getAttr("jid"), false); - Contact::Hide(pUser->hContact); - } -} - -///////////////////////////////////////////////////////////////////////////////////////// - -void WhatsAppProto::OnIqCountPrekeys(const WANode &node) -{ - int iCount = node.getChild("count")->getAttrInt("value"); - if (iCount < 5) - UploadMorePrekeys(); -} - -void WhatsAppProto::UploadMorePrekeys() -{ - WANodeIq iq(IQ::SET, "encrypt"); - - auto regId = encodeBigEndian(getDword(DBKEY_REG_ID)); - iq.addChild("registration")->content.append(regId.c_str(), regId.size()); - - iq.addChild("type")->content.append(KEY_BUNDLE_TYPE, 1); - iq.addChild("identity")->content.append(m_signalStore.signedIdentity.pub); - - const int PORTION = 10; - m_signalStore.generatePrekeys(PORTION); - - int iStart = getDword(DBKEY_PREKEY_UPLOAD_ID, 1); - auto *n = iq.addChild("list"); - for (int i = 0; i < PORTION; i++) { - auto *nKey = n->addChild("key"); - - int keyId = iStart + i; - auto encId = encodeBigEndian(keyId, 3); - nKey->addChild("id")->content.append(encId.c_str(), encId.size()); - nKey->addChild("value")->content.append(getBlob(CMStringA(FORMAT, "PreKey%dPublic", keyId))); - } - setDword(DBKEY_PREKEY_UPLOAD_ID, iStart + PORTION); - - auto *skey = iq.addChild("skey"); - - auto encId = encodeBigEndian(m_signalStore.preKey.keyid, 3); - skey->addChild("id")->content.append(encId.c_str(), encId.size()); - skey->addChild("value")->content.append(m_signalStore.preKey.pub); - skey->addChild("signature")->content.append(m_signalStore.preKey.signature); - - WSSendNode(iq, &WhatsAppProto::OnIqDoNothing); -} - -///////////////////////////////////////////////////////////////////////////////////////// - -void WhatsAppProto::OnIqDoNothing(const WANode &) -{ -} - -///////////////////////////////////////////////////////////////////////////////////////// - -void WhatsAppProto::OnNotifyEncrypt(const WANode &node) -{ - auto *pszFrom = node.getAttr("from"); - if (!mir_strcmp(pszFrom, S_WHATSAPP_NET)) { - - } -} - -///////////////////////////////////////////////////////////////////////////////////////// - -void WhatsAppProto::OnReceiveInfo(const WANode &node) -{ - if (auto *pChild = node.getFirstChild()) { - if (pChild->title == "offline") - debugLogA("Processed %d offline events", pChild->getAttrInt("count")); - } -} - -///////////////////////////////////////////////////////////////////////////////////////// - -void WhatsAppProto::OnReceiveMessage(const WANode &node) -{ - auto *msgId = node.getAttr("id"); - auto *msgType = node.getAttr("type"); - auto *msgFrom = node.getAttr("from"); - auto *category = node.getAttr("category"); - auto *recipient = node.getAttr("recipient"); - auto *participant = node.getAttr("participant"); - - if (msgType == nullptr || msgFrom == nullptr || msgId == nullptr) { - debugLogA("bad message received: <%s> <%s> <%s>", msgType, msgFrom, msgId); - return; - } - - WAMSG type; - WAJid jid(msgFrom); - CMStringA szAuthor, szChatId; - - if (node.getAttr("offline")) - type.bOffline = true; - - // message from one user to another - if (jid.isUser()) { - if (recipient) { - if (m_szJid != msgFrom) { - debugLogA("strange message: with recipient, but not from me"); - return; - } - szChatId = recipient; - } - else szChatId = msgFrom; - - type.bPrivateChat = true; - szAuthor = msgFrom; - } - else if (jid.isGroup()) { - if (!participant) { - debugLogA("strange message: from group, but without participant"); - return; - } - - type.bGroupChat = true; - szAuthor = participant; - szChatId = msgFrom; - } - else if (jid.isBroadcast()) { - if (!participant) { - debugLogA("strange message: from group, but without participant"); - return; - } - - bool bIsMe = m_szJid == participant; - if (jid.isStatusBroadcast()) { - if (bIsMe) - type.bDirectStatus = true; - else - type.bOtherStatus = true; - } - else { - if (bIsMe) - type.bPeerBroadcast = true; - else - type.bOtherBroadcast = true; - } - szChatId = msgFrom; - szAuthor = participant; - } - else { - debugLogA("invalid message type"); - return; - } - - CMStringA szSender = (type.bPrivateChat) ? szAuthor : szChatId; - bool bFromMe = (m_szJid == msgFrom); - if (!bFromMe && participant) - bFromMe = m_szJid == participant; - - auto *pKey = new proto::MessageKey(); - pKey->set_remotejid(szChatId); - pKey->set_id(msgId); - pKey->set_fromme(bFromMe); - if (participant) - pKey->set_participant(participant); - - proto::WebMessageInfo msg; - msg.set_allocated_key(pKey); - msg.set_messagetimestamp(_atoi64(node.getAttr("t"))); - msg.set_pushname(node.getAttr("notify")); - if (bFromMe) - msg.set_status(proto::WebMessageInfo_Status_SERVER_ACK); - - int iDecryptable = 0; - - for (auto &it: node.getChildren()) { - if (it->title == "verified_name") { - proto::VerifiedNameCertificate cert; - cert << it->content; - - proto::VerifiedNameCertificate::Details details; - details.ParseFromString(cert.details()); - - msg.set_verifiedbizname(details.verifiedname()); - continue; - } - - if (it->title != "enc" || it->content.length() == 0) - continue; - - SignalBuffer msgBody; - auto *pszType = it->getAttr("type"); - try { - if (!mir_strcmp(pszType, "pkmsg") || !mir_strcmp(pszType, "msg")) { - CMStringA szUser = (WAJid(szSender).isUser()) ? szSender : szAuthor; - msgBody = m_signalStore.decryptSignalProto(szUser, pszType, it->content); - } - else if (!mir_strcmp(pszType, "skmsg")) { - msgBody = m_signalStore.decryptGroupSignalProto(szSender, szAuthor, it->content); - } - else throw "Invalid e2e type"; - - if (!msgBody) - throw "Invalid e2e message"; - - iDecryptable++; - - // remove message padding - if (size_t len = msgBody.len()) { - size_t c = msgBody.data()[len - 1]; - if (c < len) - msgBody.reset(len - c); - } - - proto::Message encMsg; - encMsg.ParseFromArray(msgBody.data(), msgBody.len()); - if (encMsg.devicesentmessage().has_message()) - msg.set_allocated_message(new proto::Message(encMsg.devicesentmessage().message())); - else - msg.set_allocated_message(new proto::Message(encMsg)); - - if (encMsg.has_senderkeydistributionmessage()) - m_signalStore.processSenderKeyMessage(encMsg.senderkeydistributionmessage()); - - ProcessMessage(type, msg); - msg.clear_message(); - - // send receipt - const char *pszReceiptType = nullptr, *pszReceiptTo = participant; - if (!mir_strcmp(category, "peer")) - pszReceiptType = "peer_msg"; - else if (bFromMe) { - // message was sent by me from a different device - pszReceiptType = "sender"; - if (WAJid(szChatId).isUser()) - pszReceiptTo = szAuthor; - } - else if (!m_hServerConn) - pszReceiptType = "inactive"; - - SendReceipt(szChatId, pszReceiptTo, msgId, pszReceiptType); - } - catch (const char *pszError) { - debugLogA("Message cannot be parsed: %s", pszError); - } - - if (!iDecryptable) { - debugLogA("Nothing to decrypt"); - return; - } - } -} - -///////////////////////////////////////////////////////////////////////////////////////// - -void WhatsAppProto::OnStreamError(const WANode &node) -{ - m_bTerminated = true; - - if (auto *pszCode = node.getAttr("code")) { - switch (atoi(pszCode)) { - case 401: - debugLogA("Connection logged out from another device, exiting"); - break; - - case 408: - debugLogA("Connection lost, exiting"); - break; - - case 411: - debugLogA("Conflict between two devices, exiting"); - break; - - case 428: - debugLogA("Connection forcibly closed by the server, exiting"); - break; - - case 440: - debugLogA("Connection replaced from another device, exiting"); - break; - - case 515: - debugLogA("Server required to restart immediately, leaving thread"); - m_bRespawn = true; - break; - } - } -} - -///////////////////////////////////////////////////////////////////////////////////////// - -void WhatsAppProto::OnIqResult(const WANode &node) -{ - if (auto *pszId = node.getAttr("id")) - for (auto &it: m_arPacketQueue) - if (it->szPacketId == pszId) - (this->*it->pHandler)(node); -} - -///////////////////////////////////////////////////////////////////////////////////////// - -void WhatsAppProto::OnIqPairDevice(const WANode &node) -{ - WSSendNode(WANodeIq(IQ::RESULT) << CHAR_PARAM("id", node.getAttr("id"))); - - if (auto *pRef = node.getChild("pair-device")->getChild("ref")) { - ShowQrCode(pRef->getBody()); - } - else { - debugLogA("OnIqPairDevice: got reply without ref, exiting"); - ShutdownSession(); - } -} - -void WhatsAppProto::OnIqPairSuccess(const WANode &node) -{ - CloseQrDialog(); - - auto *pRoot = node.getChild("pair-success"); - - try { - if (auto *pPlatform = pRoot->getChild("platform")) - debugLogA("Got response from platform: %s", pPlatform->getBody().c_str()); - - if (auto *pBiz = pRoot->getChild("biz")) - if (auto *pszName = pBiz->getAttr("name")) - setUString("Nick", pszName); - - if (auto *pDevice = pRoot->getChild("device")) { - if (auto *pszJid = pDevice->getAttr("jid")) { - WAJid jid(pszJid); - m_szJid = jid.user + "@" + jid.server; - setUString(DBKEY_JID, m_szJid); - setDword(DBKEY_DEVICE_ID, jid.device); - } - } - else throw "OnIqPairSuccess: got reply without device info, exiting"; - - if (auto *pIdentity = pRoot->getChild("device-identity")) { - proto::ADVSignedDeviceIdentityHMAC payload; - if (!payload.ParseFromArray(pIdentity->content.data(), (int)pIdentity->content.length())) - throw "OnIqPairSuccess: got reply with invalid identity, exiting"; - - auto &hmac = payload.hmac(); - auto &details = payload.details(); - { - // check details signature using HMAC - uint8_t signature[32]; - unsigned int out_len = sizeof(signature); - MBinBuffer secret(getBlob(DBKEY_SECRET_KEY)); - HMAC(EVP_sha256(), secret.data(), (int)secret.length(), (BYTE *)details.c_str(), (int)details.size(), signature, &out_len); - if (memcmp(hmac.c_str(), signature, sizeof(signature))) - throw "OnIqPairSuccess: got reply with invalid details signature, exiting"; - } - - proto::ADVSignedDeviceIdentity account; - if (!account.ParseFromString(details)) - throw "OnIqPairSuccess: got reply with invalid account, exiting"; - - auto &deviceDetails = account.details(); - auto &accountSignature = account.accountsignature(); - auto &accountSignatureKey = account.accountsignaturekey(); - { - MBinBuffer buf; - buf.append("\x06\x00", 2); - buf.append(deviceDetails.c_str(), deviceDetails.size()); - buf.append(m_signalStore.signedIdentity.pub); - - ec_public_key key = {}; - memcpy(key.data, accountSignatureKey.c_str(), sizeof(key.data)); - if (1 != curve_verify_signature(&key, (BYTE *)buf.data(), buf.length(), (BYTE *)accountSignature.c_str(), accountSignature.size())) - throw "OnIqPairSuccess: got reply with invalid account signature, exiting"; - } - debugLogA("Received valid account signature"); - { - MBinBuffer buf; - buf.append("\x06\x01", 2); - buf.append(deviceDetails.c_str(), deviceDetails.size()); - buf.append(m_signalStore.signedIdentity.pub); - buf.append(accountSignatureKey.c_str(), accountSignatureKey.size()); - - signal_buffer *result; - ec_private_key key = {}; - memcpy(key.data, m_signalStore.signedIdentity.priv.data(), m_signalStore.signedIdentity.priv.length()); - if (curve_calculate_signature(m_signalStore.CTX(), &result, &key, (BYTE *)buf.data(), buf.length()) != 0) - throw "OnIqPairSuccess: cannot calculate account signature, exiting"; - - account.set_devicesignature(result->data, result->len); - signal_buffer_free(result); - } - - setDword("SignalDeviceId", 0); - { - MBinBuffer key; - if (accountSignatureKey.size() == 32) - key.append(KEY_BUNDLE_TYPE, 1); - key.append(accountSignatureKey.c_str(), accountSignatureKey.size()); - db_set_blob(0, m_szModuleName, "SignalIdentifierKey", key.data(), (int)key.length()); - } - - account.clear_accountsignaturekey(); - - MBinBuffer accountEnc(account.ByteSize()); - account.SerializeToArray(accountEnc.data(), (int)accountEnc.length()); - db_set_blob(0, m_szModuleName, "WAAccount", accountEnc.data(), (int)accountEnc.length()); - - proto::ADVDeviceIdentity deviceIdentity; - deviceIdentity.ParseFromString(deviceDetails); - - WANodeIq reply(IQ::RESULT); reply << CHAR_PARAM("id", node.getAttr("id")); - - WANode *nodePair = reply.addChild("pair-device-sign"); - - WANode *nodeDeviceIdentity = nodePair->addChild("device-identity"); - nodeDeviceIdentity->addAttr("key-index", deviceIdentity.keyindex()); - nodeDeviceIdentity->content.append(accountEnc.data(), accountEnc.length()); - WSSendNode(reply); - } - else throw "OnIqPairSuccess: got reply without identity, exiting"; - } - catch (const char *pErrMsg) { - debugLogA(pErrMsg); - ShutdownSession(); - } -} - -///////////////////////////////////////////////////////////////////////////////////////// - -void WhatsAppProto::OnProcessHandshake(const void *pData, int cbLen) -{ - proto::HandshakeMessage msg; - if (!msg.ParseFromArray(pData, cbLen)) { - debugLogA("Error parsing data, exiting"); - -LBL_Error: - ShutdownSession(); - return; - } - - auto &static_ = msg.serverhello().static_(); - auto &payload_ = msg.serverhello().payload(); - auto &ephemeral_ = msg.serverhello().ephemeral(); - - m_noise->updateHash(ephemeral_.c_str(), ephemeral_.size()); - m_noise->mixIntoKey(m_noise->ephemeral.priv.data(), ephemeral_.c_str()); - - MBinBuffer decryptedStatic = m_noise->decrypt(static_.c_str(), static_.size()); - m_noise->mixIntoKey(m_noise->ephemeral.priv.data(), decryptedStatic.data()); - - MBinBuffer decryptedCert = m_noise->decrypt(payload_.c_str(), payload_.size()); - - proto::CertChain cert; cert.ParseFromArray(decryptedCert.data(), (int)decryptedCert.length()); - proto::CertChain::NoiseCertificate::Details details; details.ParseFromString(cert.intermediate().details()); - if (details.issuerserial() != 0) { - debugLogA("Invalid certificate serial number, exiting"); - goto LBL_Error; - } - - MBinBuffer encryptedPub = m_noise->encrypt(m_noise->noiseKeys.pub.data(), m_noise->noiseKeys.pub.length()); - m_noise->mixIntoKey(m_noise->noiseKeys.priv.data(), ephemeral_.c_str()); - - // create reply - proto::ClientPayload node; - - MFileVersion v; - Miranda_GetFileVersion(&v); - - // not received our jid from server? generate registration packet then - if (m_szJid.IsEmpty()) { - uint8_t appVersion[16]; - mir_md5_hash((BYTE *)APP_VERSION, sizeof(APP_VERSION) - 1, appVersion); - - auto *pAppVersion = new proto::DeviceProps_AppVersion(); - pAppVersion->set_primary(v[0]); - pAppVersion->set_secondary(v[1]); - pAppVersion->set_tertiary(v[2]); - pAppVersion->set_quaternary(v[3]); - - proto::DeviceProps pCompanion; - pCompanion.set_os("Miranda"); - pCompanion.set_allocated_version(pAppVersion); - pCompanion.set_platformtype(proto::DeviceProps_PlatformType_DESKTOP); - pCompanion.set_requirefullsync(false); - - MBinBuffer buf(pCompanion.ByteSize()); - pCompanion.SerializeToArray(buf.data(), (int)buf.length()); - - auto *pPairingData = new proto::ClientPayload_DevicePairingRegistrationData(); - pPairingData->set_deviceprops(buf.data(), buf.length()); - pPairingData->set_buildhash(appVersion, sizeof(appVersion)); - pPairingData->set_eregid(encodeBigEndian(getDword(DBKEY_REG_ID))); - pPairingData->set_ekeytype(KEY_BUNDLE_TYPE); - pPairingData->set_eident(m_signalStore.signedIdentity.pub.data(), m_signalStore.signedIdentity.pub.length()); - pPairingData->set_eskeyid(encodeBigEndian(m_signalStore.preKey.keyid)); - pPairingData->set_eskeyval(m_signalStore.preKey.pub.data(), m_signalStore.preKey.pub.length()); - pPairingData->set_eskeysig(m_signalStore.preKey.signature.data(), m_signalStore.preKey.signature.length()); - node.set_allocated_devicepairingdata(pPairingData); - - node.set_passive(false); - } - // generate login packet - else { - WAJid jid(m_szJid); - node.set_username(_atoi64(jid.user)); - node.set_device(getDword(DBKEY_DEVICE_ID)); - node.set_passive(true); - } - - auto *pUserVersion = new proto::ClientPayload_UserAgent_AppVersion(); - pUserVersion->set_primary(2); - pUserVersion->set_secondary(2230); - pUserVersion->set_tertiary(15); - - auto *pUserAgent = new proto::ClientPayload_UserAgent(); - pUserAgent->set_allocated_appversion(pUserVersion); - pUserAgent->set_platform(proto::ClientPayload_UserAgent_Platform_WEB); - pUserAgent->set_releasechannel(proto::ClientPayload_UserAgent_ReleaseChannel_RELEASE); - pUserAgent->set_mcc("000"); - pUserAgent->set_mnc("000"); - pUserAgent->set_osversion("0.1"); - pUserAgent->set_osbuildnumber("0.1"); - pUserAgent->set_manufacturer(""); - pUserAgent->set_device("Desktop"); - pUserAgent->set_localelanguageiso6391("en"); - pUserAgent->set_localecountryiso31661alpha2("US"); - - auto *pWebInfo = new proto::ClientPayload_WebInfo(); - pWebInfo->set_websubplatform(proto::ClientPayload_WebInfo_WebSubPlatform_WEB_BROWSER); - - node.set_connecttype(proto::ClientPayload_ConnectType_WIFI_UNKNOWN); - node.set_connectreason(proto::ClientPayload_ConnectReason_USER_ACTIVATED); - node.set_allocated_useragent(pUserAgent); - node.set_allocated_webinfo(pWebInfo); - - MBinBuffer payload(node.ByteSize()); - node.SerializeToArray(payload.data(), (int)payload.length()); - - MBinBuffer payloadEnc = m_noise->encrypt(payload.data(), payload.length()); - - auto *pFinish = new proto::HandshakeMessage_ClientFinish(); - pFinish->set_payload(payloadEnc.data(), payloadEnc.length()); - pFinish->set_static_(encryptedPub.data(), encryptedPub.length()); - - proto::HandshakeMessage handshake; - handshake.set_allocated_clientfinish(pFinish); - WSSend(handshake); - - m_noise->finish(); -} - -///////////////////////////////////////////////////////////////////////////////////////// - -void WhatsAppProto::OnServerSync(const WANode &node) -{ - OBJLIST task(1); - - for (auto &it : node.getChildren()) - if (it->title == "collection") - task.insert(new WACollection(it->getAttr("name"), it->getAttrInt("version"))); - - ResyncServer(task); -} - -void WhatsAppProto::ResyncServer(const OBJLIST &task) -{ - WANodeIq iq(IQ::SET, "w:sync:app:state"); - - auto *pList = iq.addChild("sync"); - for (auto &it : task) { - auto *pCollection = m_arCollections.find(it); - if (pCollection == nullptr) - m_arCollections.insert(pCollection = new WACollection(it->szName, 0)); - - if (pCollection->version < it->version) { - auto *pNode = pList->addChild("collection"); - *pNode << CHAR_PARAM("name", it->szName) << INT_PARAM("version", pCollection->version) - << CHAR_PARAM("return_snapshot", (!pCollection->version) ? "true" : "false"); - } - } - - if (pList->getFirstChild() != nullptr) - WSSendNode(iq, &WhatsAppProto::OnIqServerSync); -} - -void WhatsAppProto::OnIqServerSync(const WANode &node) -{ - for (auto &coll : node.getChild("sync")->getChildren()) { - if (coll->title != "collection") - continue; - - auto *pszName = coll->getAttr("name"); - - auto *pCollection = FindCollection(pszName); - if (pCollection == nullptr) { - pCollection = new WACollection(pszName, 0); - m_arCollections.insert(pCollection); - } - - int dwVersion = 0; - - CMStringW wszSnapshotPath(GetTmpFileName("collection", pszName)); - if (auto *pSnapshot = coll->getChild("snapshot")) { - proto::ExternalBlobReference body; - body << pSnapshot->content; - if (!body.has_directpath() || !body.has_mediakey()) { - debugLogA("Invalid snapshot data, skipping"); - continue; - } - - MBinBuffer buf = DownloadEncryptedFile(directPath2url(body.directpath().c_str()), body.mediakey(), "App State"); - if (!buf.data()) { - debugLogA("Invalid downloaded snapshot data, skipping"); - continue; - } - - proto::SyncdSnapshot snapshot; - snapshot << buf; - - dwVersion = snapshot.version().version(); - if (dwVersion > pCollection->version) { - auto &hash = snapshot.mac(); - pCollection->hash.assign(hash.c_str(), hash.size()); - - for (auto &it : snapshot.records()) - pCollection->parseRecord(it, true); - } - } - - if (auto *pPatchList = coll->getChild("patches")) { - for (auto &it : pPatchList->getChildren()) { - proto::SyncdPatch patch; - patch << it->content; - - dwVersion = patch.version().version(); - if (dwVersion > pCollection->version) - for (auto &jt : patch.mutations()) - pCollection->parseRecord(jt.record(), jt.operation() == proto::SyncdMutation_SyncdOperation::SyncdMutation_SyncdOperation_SET); - } - } - - CMStringA szSetting(FORMAT, "Collection_%s", pszName); - // setDword(szSetting, dwVersion); - - JSONNode jsonRoot, jsonMap; - for (auto &it : pCollection->indexValueMap) - jsonMap << CHAR_PARAM(ptrA(mir_base64_encode(it.first.c_str(), it.first.size())), ptrA(mir_base64_encode(it.second.c_str(), it.second.size()))); - jsonRoot << INT_PARAM("version", dwVersion) << JSON_PARAM("indexValueMap", jsonMap); - - // string2file(jsonRoot.write(), GetTmpFileName("collection", CMStringA(pszName) + ".json")); - } -} - -void WACollection::parseRecord(const ::proto::SyncdRecord &rec, bool bSet) -{ - // auto &id = rec.keyid().id(); - auto &index = rec.index().blob(); - auto &value = rec.value().blob(); - - if (bSet) { - indexValueMap[index] = value.substr(0, value.size() - 32); - } - else indexValueMap.erase(index); -} - -///////////////////////////////////////////////////////////////////////////////////////// - -void WhatsAppProto::OnSuccess(const WANode &) -{ - OnLoggedIn(); - - WSSendNode(WANodeIq(IQ::SET, "passive") << XCHILD("active"), &WhatsAppProto::OnIqDoNothing); -} - -///////////////////////////////////////////////////////////////////////////////////////// - -void WhatsAppProto::InitPersistentHandlers() -{ - m_arPersistent.insert(new WAPersistentHandler("iq", "set", "md", "pair-device", &WhatsAppProto::OnIqPairDevice)); - m_arPersistent.insert(new WAPersistentHandler("iq", "set", "md", "pair-success", &WhatsAppProto::OnIqPairSuccess)); - - m_arPersistent.insert(new WAPersistentHandler("notification", "encrypt", 0, 0, &WhatsAppProto::OnNotifyEncrypt)); - m_arPersistent.insert(new WAPersistentHandler("notification", "account_sync", 0, 0, &WhatsAppProto::OnAccountSync)); - m_arPersistent.insert(new WAPersistentHandler("notification", "server_sync", 0, 0, &WhatsAppProto::OnServerSync)); - - m_arPersistent.insert(new WAPersistentHandler("ib", 0, 0, 0, &WhatsAppProto::OnReceiveInfo)); - m_arPersistent.insert(new WAPersistentHandler("message", 0, 0, 0, &WhatsAppProto::OnReceiveMessage)); - m_arPersistent.insert(new WAPersistentHandler("stream:error", 0, 0, 0, &WhatsAppProto::OnStreamError)); - m_arPersistent.insert(new WAPersistentHandler("success", 0, 0, 0, &WhatsAppProto::OnSuccess)); - - m_arPersistent.insert(new WAPersistentHandler(0, "result", 0, 0, &WhatsAppProto::OnIqResult)); -} diff --git a/protocols/WhatsAppWeb/src/main.cpp b/protocols/WhatsAppWeb/src/main.cpp deleted file mode 100644 index dc6ac65afe..0000000000 --- a/protocols/WhatsAppWeb/src/main.cpp +++ /dev/null @@ -1,69 +0,0 @@ -/* - -WhatsAppWeb plugin for Miranda NG -Copyright © 2019-22 George Hazan - -*/ - -#include "stdafx.h" -#include "version.h" - -#ifdef _DEBUG -#pragma comment(lib, "libprotobufd.lib") -#else -#pragma comment(lib, "libprotobuf.lib") -#endif - -CMPlugin g_plugin; - -PLUGININFOEX pluginInfo = { - sizeof(PLUGININFOEX), - __PLUGIN_NAME, - PLUGIN_MAKE_VERSION(__MAJOR_VERSION, __MINOR_VERSION, __RELEASE_NUM, __BUILD_NUM), - __DESCRIPTION, - __AUTHOR, - __AUTHOREMAIL, - __COPYRIGHT, - UNICODE_AWARE, //not transient - // {008B9CE1-154B-44E4-9823-97C1AAB00C3C} - { 0x8b9ce1, 0x154b, 0x44e4, { 0x98, 0x23, 0x97, 0xc1, 0xaa, 0xb0, 0xc, 0x3c }} -}; - -///////////////////////////////////////////////////////////////////////////////////////// -// Interface information - -extern "C" __declspec(dllexport) const MUUID MirandaInterfaces[] = { MIID_PROTOCOL, MIID_LAST }; - -///////////////////////////////////////////////////////////////////////////////////////// - -CMPlugin::CMPlugin() : - ACCPROTOPLUGIN(MODULENAME, pluginInfo) -{ - SetUniqueId(DBKEY_JID); -} - -///////////////////////////////////////////////////////////////////////////////////////// -// Load - -int CMPlugin::Load() -{ - // InitIcons(); - // InitContactMenus(); - - NETLIBUSER nlu = {}; - nlu.flags = NUF_INCOMING | NUF_OUTGOING | NUF_HTTPCONNS | NUF_UNICODE; - nlu.szSettingsModule = "WhatsApp"; - nlu.szDescriptiveName.w = TranslateT("WhatsApp (HTTP)"); - hAvatarUser = Netlib_RegisterUser(&nlu); - return 0; -} - -///////////////////////////////////////////////////////////////////////////////////////// -// Unload - -int CMPlugin::Unload() -{ - Netlib_CloseHandle(hAvatarConn); - Netlib_CloseHandle(hAvatarUser); - return 0; -} diff --git a/protocols/WhatsAppWeb/src/message.cpp b/protocols/WhatsAppWeb/src/message.cpp deleted file mode 100644 index 8e7ff03046..0000000000 --- a/protocols/WhatsAppWeb/src/message.cpp +++ /dev/null @@ -1,130 +0,0 @@ -/* - -WhatsAppWeb plugin for Miranda NG -Copyright © 2019-22 George Hazan - -*/ - -#include "stdafx.h" - -static const proto::Message& getBody(const proto::Message &message) -{ - if (message.has_ephemeralmessage()) { - auto &pMsg = message.ephemeralmessage().message(); - return (pMsg.has_viewoncemessage()) ? pMsg.viewoncemessage().message() : pMsg; - } - - if (message.has_viewoncemessage()) - return message.viewoncemessage().message(); - - return message; -} - -void WhatsAppProto::ProcessMessage(WAMSG type, const proto::WebMessageInfo &msg) -{ - auto &key = msg.key(); - auto &body = getBody(msg.message()); - bool bFromMe = key.fromme(); - - debugLogA("Got a message: %s", msg.Utf8DebugString().c_str()); - - uint32_t timestamp = msg.messagetimestamp(); - auto &participant = key.participant(); - auto &chatId = key.remotejid(); - auto &msgId = key.id(); - - WAUser *pUser = FindUser(chatId.c_str()); - if (pUser == nullptr) { - if (type.bPrivateChat) - pUser = AddUser(chatId.c_str(), false, false); - else if (type.bGroupChat) - pUser = AddUser(chatId.c_str(), false, true); - } - - if (!bFromMe && msg.has_pushname() && pUser && !pUser->bIsGroupChat) - setUString(pUser->hContact, "Nick", msg.pushname().c_str()); - - // try to extract some text - if (body.has_conversation()) { - auto &conversation = body.conversation(); - if (!conversation.empty()) { - PROTORECVEVENT pre = {}; - pre.timestamp = timestamp; - pre.szMessage = (char*)conversation.c_str(); - pre.szMsgId = msgId.c_str(); - if (type.bOffline) - pre.flags |= PREF_CREATEREAD; - if (bFromMe) - pre.flags |= PREF_SENT; - ProtoChainRecvMsg(pUser->hContact, &pre); - } - } - - if (body.has_protocolmessage()) { - auto &protoMsg = body.protocolmessage(); - switch (protoMsg.type()) { - case proto::Message_ProtocolMessage_Type_APP_STATE_SYNC_KEY_SHARE: - if (protoMsg.appstatesynckeyshare().keys_size()) { - for (auto &it : protoMsg.appstatesynckeyshare().keys()) { - auto &keyid = it.keyid().keyid(); - auto &keydata = it.keydata().keydata(); - - CMStringA szSetting(FORMAT, "AppSyncKey%d", decodeBigEndian(keyid)); - db_set_blob(0, m_szModuleName, szSetting, keydata.c_str(), (unsigned)keydata.size()); - } - } - break; - - case proto::Message_ProtocolMessage_Type_HISTORY_SYNC_NOTIFICATION: - debugLogA("History sync notification"); - break; - - case proto::Message_ProtocolMessage_Type_REVOKE: - break; - - case proto::Message_ProtocolMessage_Type_EPHEMERAL_SETTING: - if (pUser) { - setDword(pUser->hContact, DBKEY_EPHEMERAL_TS, timestamp); - setDword(pUser->hContact, DBKEY_EPHEMERAL_EXPIRE, protoMsg.ephemeralexpiration()); - } - break; - } - } - else if (body.has_reactionmessage()) { - debugLogA("Got a reaction to a message"); - } - else if (msg.has_messagestubtype()) { - switch (msg.messagestubtype()) { - case proto::WebMessageInfo::GROUP_PARTICIPANT_LEAVE: - case proto::WebMessageInfo::GROUP_PARTICIPANT_REMOVE: - debugLogA("Participant %s removed from chat", participant.c_str()); - break; - - case proto::WebMessageInfo::GROUP_PARTICIPANT_ADD: - case proto::WebMessageInfo::GROUP_PARTICIPANT_INVITE: - case proto::WebMessageInfo::GROUP_PARTICIPANT_ADD_REQUEST_JOIN: - debugLogA("Participant %s added to chat", participant.c_str()); - break; - - case proto::WebMessageInfo::GROUP_PARTICIPANT_DEMOTE: - debugLogA("Participant %s demoted", participant.c_str()); - break; - - case proto::WebMessageInfo::GROUP_PARTICIPANT_PROMOTE: - debugLogA("Participant %s promoted", participant.c_str()); - break; - - case proto::WebMessageInfo::GROUP_CHANGE_ANNOUNCE: - debugLogA("Groupchat announce", participant.c_str()); - break; - - case proto::WebMessageInfo::GROUP_CHANGE_RESTRICT: - debugLogA("Groupchat restriction", participant.c_str()); - break; - - case proto::WebMessageInfo::GROUP_CHANGE_SUBJECT: - debugLogA("Groupchat subject was changed", participant.c_str()); - break; - } - } -} diff --git a/protocols/WhatsAppWeb/src/noise.cpp b/protocols/WhatsAppWeb/src/noise.cpp deleted file mode 100644 index 190e5740f6..0000000000 --- a/protocols/WhatsAppWeb/src/noise.cpp +++ /dev/null @@ -1,203 +0,0 @@ -/* - -WhatsAppWeb plugin for Miranda NG -Copyright © 2019-22 George Hazan - -WANoise class implementation - -*/ - -#include "stdafx.h" - -static uint8_t intro_header[] = {87, 65, 6, DICT_VERSION}; -static uint8_t noise_init[] = "Noise_XX_25519_AESGCM_SHA256\0\0\0\0"; - -WANoise::WANoise(WhatsAppProto *_ppro) : - ppro(_ppro) -{ - salt.assign(noise_init, 32); - encKey.assign(noise_init, 32); - decKey.assign(noise_init, 32); - - // generate ephemeral keys: public & private - ec_key_pair *pKeys; - curve_generate_key_pair(ppro->m_signalStore.CTX(), &pKeys); - - auto *pPubKey = ec_key_pair_get_public(pKeys); - ephemeral.pub.assign(pPubKey->data, sizeof(pPubKey->data)); - - auto *pPrivKey = ec_key_pair_get_private(pKeys); - ephemeral.priv.assign(pPrivKey->data, sizeof(pPrivKey->data)); - ec_key_pair_destroy((signal_type_base*)pKeys); - - // prepare hash - memcpy(hash, noise_init, 32); - updateHash(intro_header, 4); - updateHash(ephemeral.pub.data(), ephemeral.pub.length()); -} - -///////////////////////////////////////////////////////////////////////////////////////// -// libsignal data initialization - -void WANoise::init() -{ - // no data? generate them - if (ppro->getDword(DBKEY_REG_ID, 0xFFFF) == 0xFFFF) { - // generate registration id - uint32_t regId; - Utils_GetRandom(®Id, sizeof(regId)); - ppro->setDword(DBKEY_REG_ID, regId & 0x3FFF); - - // generate secret key - uint8_t secretKey[32]; - Utils_GetRandom(secretKey, sizeof(secretKey)); - db_set_blob(0, ppro->m_szModuleName, DBKEY_SECRET_KEY, secretKey, sizeof(secretKey)); - - // generate noise keys (private & public) - ec_key_pair *pKeys; - curve_generate_key_pair(ppro->m_signalStore.CTX(), &pKeys); - - auto *pPubKey = ec_key_pair_get_public(pKeys); - db_set_blob(0, ppro->m_szModuleName, DBKEY_NOISE_PUB, pPubKey->data, sizeof(pPubKey->data)); - - auto *pPrivKey = ec_key_pair_get_private(pKeys); - db_set_blob(0, ppro->m_szModuleName, DBKEY_NOISE_PRIV, pPrivKey->data, sizeof(pPrivKey->data)); - ec_key_pair_destroy((signal_type_base *)pKeys); - } - - noiseKeys.pub = ppro->getBlob(DBKEY_NOISE_PUB); - noiseKeys.priv = ppro->getBlob(DBKEY_NOISE_PRIV); -} - -void WANoise::finish() -{ - deriveKey("", 0, encKey, decKey); - readCounter = writeCounter = 0; - memset(hash, 0, sizeof(hash)); - bInitFinished = true; -} - -void WANoise::deriveKey(const void *pData, size_t cbLen, MBinBuffer &write, MBinBuffer &read) -{ - size_t outlen = 64; - uint8_t out[64]; - HKDF(EVP_sha256(), (BYTE *)salt.data(), (int)salt.length(), (BYTE *)pData, (int)cbLen, (BYTE *)"", 0, out, outlen); - - write.assign(out, 32); - read.assign(out + 32, 32); -} - -void WANoise::mixIntoKey(const void *n, const void *p) -{ - uint8_t tmp[32]; - curve25519_donna((unsigned char *)tmp, (const unsigned char *)n, (const unsigned char *)p); - - deriveKey(tmp, sizeof(tmp), salt, encKey); - decKey.assign(encKey.data(), encKey.length()); - readCounter = writeCounter = 0; -} - -MBinBuffer WANoise::decrypt(const void *pData, size_t cbLen) -{ - uint8_t iv[12]; - generateIV(iv, (bInitFinished) ? readCounter : writeCounter); - - MBinBuffer res; - if (!bInitFinished) - res = aesDecrypt(EVP_aes_256_gcm(), (BYTE *)decKey.data(), iv, pData, cbLen, hash, sizeof(hash)); - else - res = aesDecrypt(EVP_aes_256_gcm(), (BYTE *)decKey.data(), iv, pData, cbLen); - - updateHash(pData, cbLen); - return res; -} - -size_t WANoise::decodeFrame(const void *&pData, size_t &cbLen) -{ - auto *p = (const uint8_t *)pData; - - if (cbLen < 3) - return 0; - - size_t payloadLen = 0; - for (int i = 0; i < 3; i++) { - payloadLen <<= 8; - payloadLen += p[i]; - } - - // ppro->debugLogA("got payload of size %d", payloadLen); - - cbLen -= 3; - if (payloadLen > cbLen) { - ppro->debugLogA("payload length %d exceeds capacity %d", payloadLen, cbLen); - return 0; - } - - pData = p + 3; - return payloadLen; -} - -MBinBuffer WANoise::encodeFrame(const void *pData, size_t cbLen) -{ - MBinBuffer res; - if (!bSendIntro) { - bSendIntro = true; - res.append(intro_header, 4); - } - - uint8_t buf[3]; - size_t foo = cbLen; - for (int i = 0; i < 3; i++) { - buf[2 - i] = foo & 0xFF; - foo >>= 8; - } - res.append(buf, 3); - res.append(pData, cbLen); - return res; -} - -MBinBuffer WANoise::encrypt(const void *pData, size_t cbLen) -{ - uint8_t iv[12]; - generateIV(iv, writeCounter); - - MBinBuffer res; - uint8_t outbuf[1024 + 64]; - - int enc_len = 0, final_len = 0; - EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new(); - EVP_EncryptInit_ex(ctx, EVP_aes_256_gcm(), NULL, (BYTE *)encKey.data(), iv); - - if (!bInitFinished) - EVP_EncryptUpdate(ctx, NULL, &enc_len, hash, sizeof(hash)); - - for (size_t len = 0; len < cbLen; len += 1024) { - size_t portionSize = cbLen - len; - EVP_EncryptUpdate(ctx, outbuf, &enc_len, (BYTE *)pData + len, (int)min(portionSize, 1024)); - res.append(outbuf, enc_len); - } - EVP_EncryptFinal_ex(ctx, outbuf, &final_len); - if (final_len) - res.append(outbuf, final_len); - - uint8_t tag[16]; - EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_GET_TAG, sizeof(tag), tag); - res.append(tag, sizeof(tag)); - - EVP_CIPHER_CTX_free(ctx); - - updateHash(res.data(), res.length()); - return res; -} - -void WANoise::updateHash(const void *pData, size_t cbLen) -{ - if (bInitFinished) - return; - - SHA256_CTX ctx; - SHA256_Init(&ctx); - SHA256_Update(&ctx, hash, sizeof(hash)); - SHA256_Update(&ctx, pData, cbLen); - SHA256_Final(hash, &ctx); -} diff --git a/protocols/WhatsAppWeb/src/options.cpp b/protocols/WhatsAppWeb/src/options.cpp deleted file mode 100644 index 46b4d8da97..0000000000 --- a/protocols/WhatsAppWeb/src/options.cpp +++ /dev/null @@ -1,68 +0,0 @@ -/* - -WhatsAppWeb plugin for Miranda NG -Copyright © 2019-22 George Hazan - -*/ - -#include "stdafx.h" - -///////////////////////////////////////////////////////////////////////////////////////// - -class COptionsDlg : public CProtoDlgBase -{ - CCtrlCheck chkHideChats; - CCtrlEdit edtGroup, edtNick; - ptrW m_wszOldGroup; - -public: - COptionsDlg(WhatsAppProto *ppro, int iDlgID, bool bFullDlg) : - CProtoDlgBase(ppro, iDlgID), - chkHideChats(this, IDC_HIDECHATS), - edtNick(this, IDC_NICK), - edtGroup(this, IDC_DEFGROUP), - m_wszOldGroup(mir_wstrdup(ppro->m_wszDefaultGroup)) - { - CreateLink(edtNick, ppro->m_wszNick); - CreateLink(edtGroup, ppro->m_wszDefaultGroup); - - if (bFullDlg) - CreateLink(chkHideChats, ppro->m_bHideGroupchats); - } - - bool OnApply() override - { - if (mir_wstrlen(m_proto->m_wszNick)) { - SetFocus(edtNick.GetHwnd()); - return false; - } - - if (mir_wstrcmp(m_proto->m_wszDefaultGroup, m_wszOldGroup)) - Clist_GroupCreate(0, m_proto->m_wszDefaultGroup); - return true; - } -}; - -///////////////////////////////////////////////////////////////////////////////////////// - -INT_PTR WhatsAppProto::SvcCreateAccMgrUI(WPARAM, LPARAM hwndParent) -{ - auto *pDlg = new COptionsDlg(this, IDD_ACCMGRUI, false); - pDlg->SetParent((HWND)hwndParent); - pDlg->Create(); - return (INT_PTR)pDlg->GetHwnd(); -} - -int WhatsAppProto::OnOptionsInit(WPARAM wParam, LPARAM) -{ - OPTIONSDIALOGPAGE odp = {}; - odp.szTitle.w = m_tszUserName; - odp.flags = ODPF_UNICODE; - odp.szGroup.w = LPGENW("Network"); - - odp.position = 1; - odp.szTab.w = LPGENW("Account"); - odp.pDialog = new COptionsDlg(this, IDD_OPTIONS, true); - g_plugin.addOptions(wParam, &odp); - return 0; -} diff --git a/protocols/WhatsAppWeb/src/pmsg.pb.cc b/protocols/WhatsAppWeb/src/pmsg.pb.cc deleted file mode 100644 index 6c4a99abc5..0000000000 --- a/protocols/WhatsAppWeb/src/pmsg.pb.cc +++ /dev/null @@ -1,100321 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: pmsg.proto - -#include "pmsg.pb.h" - -#include - -#include -#include -#include -#include -#include -#include -#include -// @@protoc_insertion_point(includes) -#include - -PROTOBUF_PRAGMA_INIT_SEG - -namespace _pb = ::PROTOBUF_NAMESPACE_ID; -namespace _pbi = _pb::internal; - -namespace proto { -PROTOBUF_CONSTEXPR ADVDeviceIdentity::ADVDeviceIdentity( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.timestamp_)*/uint64_t{0u} - , /*decltype(_impl_.rawid_)*/0u - , /*decltype(_impl_.keyindex_)*/0u} {} -struct ADVDeviceIdentityDefaultTypeInternal { - PROTOBUF_CONSTEXPR ADVDeviceIdentityDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~ADVDeviceIdentityDefaultTypeInternal() {} - union { - ADVDeviceIdentity _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ADVDeviceIdentityDefaultTypeInternal _ADVDeviceIdentity_default_instance_; -PROTOBUF_CONSTEXPR ADVKeyIndexList::ADVKeyIndexList( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.validindexes_)*/{} - , /*decltype(_impl_._validindexes_cached_byte_size_)*/{0} - , /*decltype(_impl_.timestamp_)*/uint64_t{0u} - , /*decltype(_impl_.rawid_)*/0u - , /*decltype(_impl_.currentindex_)*/0u} {} -struct ADVKeyIndexListDefaultTypeInternal { - PROTOBUF_CONSTEXPR ADVKeyIndexListDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~ADVKeyIndexListDefaultTypeInternal() {} - union { - ADVKeyIndexList _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ADVKeyIndexListDefaultTypeInternal _ADVKeyIndexList_default_instance_; -PROTOBUF_CONSTEXPR ADVSignedDeviceIdentity::ADVSignedDeviceIdentity( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.details_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.accountsignaturekey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.accountsignature_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.devicesignature_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct ADVSignedDeviceIdentityDefaultTypeInternal { - PROTOBUF_CONSTEXPR ADVSignedDeviceIdentityDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~ADVSignedDeviceIdentityDefaultTypeInternal() {} - union { - ADVSignedDeviceIdentity _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ADVSignedDeviceIdentityDefaultTypeInternal _ADVSignedDeviceIdentity_default_instance_; -PROTOBUF_CONSTEXPR ADVSignedDeviceIdentityHMAC::ADVSignedDeviceIdentityHMAC( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.details_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.hmac_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct ADVSignedDeviceIdentityHMACDefaultTypeInternal { - PROTOBUF_CONSTEXPR ADVSignedDeviceIdentityHMACDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~ADVSignedDeviceIdentityHMACDefaultTypeInternal() {} - union { - ADVSignedDeviceIdentityHMAC _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ADVSignedDeviceIdentityHMACDefaultTypeInternal _ADVSignedDeviceIdentityHMAC_default_instance_; -PROTOBUF_CONSTEXPR ADVSignedKeyIndexList::ADVSignedKeyIndexList( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.details_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.accountsignature_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct ADVSignedKeyIndexListDefaultTypeInternal { - PROTOBUF_CONSTEXPR ADVSignedKeyIndexListDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~ADVSignedKeyIndexListDefaultTypeInternal() {} - union { - ADVSignedKeyIndexList _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ADVSignedKeyIndexListDefaultTypeInternal _ADVSignedKeyIndexList_default_instance_; -PROTOBUF_CONSTEXPR ActionLink::ActionLink( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.buttontitle_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct ActionLinkDefaultTypeInternal { - PROTOBUF_CONSTEXPR ActionLinkDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~ActionLinkDefaultTypeInternal() {} - union { - ActionLink _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ActionLinkDefaultTypeInternal _ActionLink_default_instance_; -PROTOBUF_CONSTEXPR AutoDownloadSettings::AutoDownloadSettings( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.downloadimages_)*/false - , /*decltype(_impl_.downloadaudio_)*/false - , /*decltype(_impl_.downloadvideo_)*/false - , /*decltype(_impl_.downloaddocuments_)*/false} {} -struct AutoDownloadSettingsDefaultTypeInternal { - PROTOBUF_CONSTEXPR AutoDownloadSettingsDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~AutoDownloadSettingsDefaultTypeInternal() {} - union { - AutoDownloadSettings _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AutoDownloadSettingsDefaultTypeInternal _AutoDownloadSettings_default_instance_; -PROTOBUF_CONSTEXPR BizAccountLinkInfo::BizAccountLinkInfo( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.whatsappacctnumber_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.whatsappbizacctfbid_)*/uint64_t{0u} - , /*decltype(_impl_.issuetime_)*/uint64_t{0u} - , /*decltype(_impl_.hoststorage_)*/0 - , /*decltype(_impl_.accounttype_)*/0} {} -struct BizAccountLinkInfoDefaultTypeInternal { - PROTOBUF_CONSTEXPR BizAccountLinkInfoDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~BizAccountLinkInfoDefaultTypeInternal() {} - union { - BizAccountLinkInfo _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BizAccountLinkInfoDefaultTypeInternal _BizAccountLinkInfo_default_instance_; -PROTOBUF_CONSTEXPR BizAccountPayload::BizAccountPayload( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.bizacctlinkinfo_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.vnamecert_)*/nullptr} {} -struct BizAccountPayloadDefaultTypeInternal { - PROTOBUF_CONSTEXPR BizAccountPayloadDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~BizAccountPayloadDefaultTypeInternal() {} - union { - BizAccountPayload _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BizAccountPayloadDefaultTypeInternal _BizAccountPayload_default_instance_; -PROTOBUF_CONSTEXPR BizIdentityInfo::BizIdentityInfo( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.vnamecert_)*/nullptr - , /*decltype(_impl_.vlevel_)*/0 - , /*decltype(_impl_.signed__)*/false - , /*decltype(_impl_.revoked_)*/false - , /*decltype(_impl_.hoststorage_)*/0 - , /*decltype(_impl_.actualactors_)*/0 - , /*decltype(_impl_.privacymodets_)*/uint64_t{0u} - , /*decltype(_impl_.featurecontrols_)*/uint64_t{0u}} {} -struct BizIdentityInfoDefaultTypeInternal { - PROTOBUF_CONSTEXPR BizIdentityInfoDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~BizIdentityInfoDefaultTypeInternal() {} - union { - BizIdentityInfo _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BizIdentityInfoDefaultTypeInternal _BizIdentityInfo_default_instance_; -PROTOBUF_CONSTEXPR CertChain_NoiseCertificate_Details::CertChain_NoiseCertificate_Details( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.key_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.serial_)*/0u - , /*decltype(_impl_.issuerserial_)*/0u - , /*decltype(_impl_.notbefore_)*/uint64_t{0u} - , /*decltype(_impl_.notafter_)*/uint64_t{0u}} {} -struct CertChain_NoiseCertificate_DetailsDefaultTypeInternal { - PROTOBUF_CONSTEXPR CertChain_NoiseCertificate_DetailsDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~CertChain_NoiseCertificate_DetailsDefaultTypeInternal() {} - union { - CertChain_NoiseCertificate_Details _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CertChain_NoiseCertificate_DetailsDefaultTypeInternal _CertChain_NoiseCertificate_Details_default_instance_; -PROTOBUF_CONSTEXPR CertChain_NoiseCertificate::CertChain_NoiseCertificate( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.details_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.signature_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct CertChain_NoiseCertificateDefaultTypeInternal { - PROTOBUF_CONSTEXPR CertChain_NoiseCertificateDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~CertChain_NoiseCertificateDefaultTypeInternal() {} - union { - CertChain_NoiseCertificate _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CertChain_NoiseCertificateDefaultTypeInternal _CertChain_NoiseCertificate_default_instance_; -PROTOBUF_CONSTEXPR CertChain::CertChain( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.leaf_)*/nullptr - , /*decltype(_impl_.intermediate_)*/nullptr} {} -struct CertChainDefaultTypeInternal { - PROTOBUF_CONSTEXPR CertChainDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~CertChainDefaultTypeInternal() {} - union { - CertChain _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CertChainDefaultTypeInternal _CertChain_default_instance_; -PROTOBUF_CONSTEXPR Chain::Chain( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.messagekeys_)*/{} - , /*decltype(_impl_.senderratchetkey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.senderratchetkeyprivate_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.chainkey_)*/nullptr} {} -struct ChainDefaultTypeInternal { - PROTOBUF_CONSTEXPR ChainDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~ChainDefaultTypeInternal() {} - union { - Chain _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ChainDefaultTypeInternal _Chain_default_instance_; -PROTOBUF_CONSTEXPR ChainKey::ChainKey( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.key_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.index_)*/0u} {} -struct ChainKeyDefaultTypeInternal { - PROTOBUF_CONSTEXPR ChainKeyDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~ChainKeyDefaultTypeInternal() {} - union { - ChainKey _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ChainKeyDefaultTypeInternal _ChainKey_default_instance_; -PROTOBUF_CONSTEXPR ClientPayload_DNSSource::ClientPayload_DNSSource( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.dnsmethod_)*/0 - , /*decltype(_impl_.appcached_)*/false} {} -struct ClientPayload_DNSSourceDefaultTypeInternal { - PROTOBUF_CONSTEXPR ClientPayload_DNSSourceDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~ClientPayload_DNSSourceDefaultTypeInternal() {} - union { - ClientPayload_DNSSource _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientPayload_DNSSourceDefaultTypeInternal _ClientPayload_DNSSource_default_instance_; -PROTOBUF_CONSTEXPR ClientPayload_DevicePairingRegistrationData::ClientPayload_DevicePairingRegistrationData( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.eregid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.ekeytype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.eident_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.eskeyid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.eskeyval_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.eskeysig_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.buildhash_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.deviceprops_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct ClientPayload_DevicePairingRegistrationDataDefaultTypeInternal { - PROTOBUF_CONSTEXPR ClientPayload_DevicePairingRegistrationDataDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~ClientPayload_DevicePairingRegistrationDataDefaultTypeInternal() {} - union { - ClientPayload_DevicePairingRegistrationData _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientPayload_DevicePairingRegistrationDataDefaultTypeInternal _ClientPayload_DevicePairingRegistrationData_default_instance_; -PROTOBUF_CONSTEXPR ClientPayload_UserAgent_AppVersion::ClientPayload_UserAgent_AppVersion( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.primary_)*/0u - , /*decltype(_impl_.secondary_)*/0u - , /*decltype(_impl_.tertiary_)*/0u - , /*decltype(_impl_.quaternary_)*/0u - , /*decltype(_impl_.quinary_)*/0u} {} -struct ClientPayload_UserAgent_AppVersionDefaultTypeInternal { - PROTOBUF_CONSTEXPR ClientPayload_UserAgent_AppVersionDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~ClientPayload_UserAgent_AppVersionDefaultTypeInternal() {} - union { - ClientPayload_UserAgent_AppVersion _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientPayload_UserAgent_AppVersionDefaultTypeInternal _ClientPayload_UserAgent_AppVersion_default_instance_; -PROTOBUF_CONSTEXPR ClientPayload_UserAgent::ClientPayload_UserAgent( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.mcc_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.mnc_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.osversion_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.manufacturer_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.device_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.osbuildnumber_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.phoneid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.localelanguageiso6391_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.localecountryiso31661alpha2_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.deviceboard_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.appversion_)*/nullptr - , /*decltype(_impl_.platform_)*/0 - , /*decltype(_impl_.releasechannel_)*/0} {} -struct ClientPayload_UserAgentDefaultTypeInternal { - PROTOBUF_CONSTEXPR ClientPayload_UserAgentDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~ClientPayload_UserAgentDefaultTypeInternal() {} - union { - ClientPayload_UserAgent _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientPayload_UserAgentDefaultTypeInternal _ClientPayload_UserAgent_default_instance_; -PROTOBUF_CONSTEXPR ClientPayload_WebInfo_WebdPayload::ClientPayload_WebInfo_WebdPayload( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.documenttypes_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.features_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.usesparticipantinkey_)*/false - , /*decltype(_impl_.supportsstarredmessages_)*/false - , /*decltype(_impl_.supportsdocumentmessages_)*/false - , /*decltype(_impl_.supportsurlmessages_)*/false - , /*decltype(_impl_.supportsmediaretry_)*/false - , /*decltype(_impl_.supportse2eimage_)*/false - , /*decltype(_impl_.supportse2evideo_)*/false - , /*decltype(_impl_.supportse2eaudio_)*/false - , /*decltype(_impl_.supportse2edocument_)*/false} {} -struct ClientPayload_WebInfo_WebdPayloadDefaultTypeInternal { - PROTOBUF_CONSTEXPR ClientPayload_WebInfo_WebdPayloadDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~ClientPayload_WebInfo_WebdPayloadDefaultTypeInternal() {} - union { - ClientPayload_WebInfo_WebdPayload _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientPayload_WebInfo_WebdPayloadDefaultTypeInternal _ClientPayload_WebInfo_WebdPayload_default_instance_; -PROTOBUF_CONSTEXPR ClientPayload_WebInfo::ClientPayload_WebInfo( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.reftoken_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.version_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.webdpayload_)*/nullptr - , /*decltype(_impl_.websubplatform_)*/0} {} -struct ClientPayload_WebInfoDefaultTypeInternal { - PROTOBUF_CONSTEXPR ClientPayload_WebInfoDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~ClientPayload_WebInfoDefaultTypeInternal() {} - union { - ClientPayload_WebInfo _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientPayload_WebInfoDefaultTypeInternal _ClientPayload_WebInfo_default_instance_; -PROTOBUF_CONSTEXPR ClientPayload::ClientPayload( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.shards_)*/{} - , /*decltype(_impl_.pushname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.fbcat_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.fbuseragent_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.fbdeviceid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.paddingbytes_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.useragent_)*/nullptr - , /*decltype(_impl_.webinfo_)*/nullptr - , /*decltype(_impl_.dnssource_)*/nullptr - , /*decltype(_impl_.devicepairingdata_)*/nullptr - , /*decltype(_impl_.username_)*/uint64_t{0u} - , /*decltype(_impl_.sessionid_)*/0 - , /*decltype(_impl_.connecttype_)*/0 - , /*decltype(_impl_.connectreason_)*/0 - , /*decltype(_impl_.connectattemptcount_)*/0u - , /*decltype(_impl_.passive_)*/false - , /*decltype(_impl_.shortconnect_)*/false - , /*decltype(_impl_.oc_)*/false - , /*decltype(_impl_.pull_)*/false - , /*decltype(_impl_.device_)*/0u - , /*decltype(_impl_.product_)*/0 - , /*decltype(_impl_.lc_)*/0 - , /*decltype(_impl_.fbappid_)*/uint64_t{0u} - , /*decltype(_impl_.iosappextension_)*/0} {} -struct ClientPayloadDefaultTypeInternal { - PROTOBUF_CONSTEXPR ClientPayloadDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~ClientPayloadDefaultTypeInternal() {} - union { - ClientPayload _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientPayloadDefaultTypeInternal _ClientPayload_default_instance_; -PROTOBUF_CONSTEXPR ContextInfo_AdReplyInfo::ContextInfo_AdReplyInfo( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.advertisername_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.jpegthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.caption_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.mediatype_)*/0} {} -struct ContextInfo_AdReplyInfoDefaultTypeInternal { - PROTOBUF_CONSTEXPR ContextInfo_AdReplyInfoDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~ContextInfo_AdReplyInfoDefaultTypeInternal() {} - union { - ContextInfo_AdReplyInfo _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ContextInfo_AdReplyInfoDefaultTypeInternal _ContextInfo_AdReplyInfo_default_instance_; -PROTOBUF_CONSTEXPR ContextInfo_ExternalAdReplyInfo::ContextInfo_ExternalAdReplyInfo( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.body_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.thumbnailurl_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.mediaurl_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.thumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.sourcetype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.sourceid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.sourceurl_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.mediatype_)*/0 - , /*decltype(_impl_.containsautoreply_)*/false - , /*decltype(_impl_.renderlargerthumbnail_)*/false - , /*decltype(_impl_.showadattribution_)*/false} {} -struct ContextInfo_ExternalAdReplyInfoDefaultTypeInternal { - PROTOBUF_CONSTEXPR ContextInfo_ExternalAdReplyInfoDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~ContextInfo_ExternalAdReplyInfoDefaultTypeInternal() {} - union { - ContextInfo_ExternalAdReplyInfo _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ContextInfo_ExternalAdReplyInfoDefaultTypeInternal _ContextInfo_ExternalAdReplyInfo_default_instance_; -PROTOBUF_CONSTEXPR ContextInfo::ContextInfo( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.mentionedjid_)*/{} - , /*decltype(_impl_.stanzaid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.participant_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.remotejid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.conversionsource_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.conversiondata_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.ephemeralsharedsecret_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.entrypointconversionsource_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.entrypointconversionapp_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.groupsubject_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.parentgroupjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.quotedmessage_)*/nullptr - , /*decltype(_impl_.quotedad_)*/nullptr - , /*decltype(_impl_.placeholderkey_)*/nullptr - , /*decltype(_impl_.externaladreply_)*/nullptr - , /*decltype(_impl_.disappearingmode_)*/nullptr - , /*decltype(_impl_.actionlink_)*/nullptr - , /*decltype(_impl_.conversiondelayseconds_)*/0u - , /*decltype(_impl_.forwardingscore_)*/0u - , /*decltype(_impl_.isforwarded_)*/false - , /*decltype(_impl_.expiration_)*/0u - , /*decltype(_impl_.ephemeralsettingtimestamp_)*/int64_t{0} - , /*decltype(_impl_.entrypointconversiondelayseconds_)*/0u} {} -struct ContextInfoDefaultTypeInternal { - PROTOBUF_CONSTEXPR ContextInfoDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~ContextInfoDefaultTypeInternal() {} - union { - ContextInfo _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ContextInfoDefaultTypeInternal _ContextInfo_default_instance_; -PROTOBUF_CONSTEXPR Conversation::Conversation( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.messages_)*/{} - , /*decltype(_impl_.participant_)*/{} - , /*decltype(_impl_.id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.newjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.oldjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.phash_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.tctoken_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.contactprimaryidentitykey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.createdby_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.description_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.parentgroupid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.displayname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.pnjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.disappearingmode_)*/nullptr - , /*decltype(_impl_.wallpaper_)*/nullptr - , /*decltype(_impl_.lastmsgtimestamp_)*/uint64_t{0u} - , /*decltype(_impl_.unreadcount_)*/0u - , /*decltype(_impl_.ephemeralexpiration_)*/0u - , /*decltype(_impl_.ephemeralsettingtimestamp_)*/int64_t{0} - , /*decltype(_impl_.endofhistorytransfertype_)*/0 - , /*decltype(_impl_.readonly_)*/false - , /*decltype(_impl_.endofhistorytransfer_)*/false - , /*decltype(_impl_.notspam_)*/false - , /*decltype(_impl_.archived_)*/false - , /*decltype(_impl_.conversationtimestamp_)*/uint64_t{0u} - , /*decltype(_impl_.unreadmentioncount_)*/0u - , /*decltype(_impl_.pinned_)*/0u - , /*decltype(_impl_.tctokentimestamp_)*/uint64_t{0u} - , /*decltype(_impl_.muteendtime_)*/uint64_t{0u} - , /*decltype(_impl_.mediavisibility_)*/0 - , /*decltype(_impl_.markedasunread_)*/false - , /*decltype(_impl_.suspended_)*/false - , /*decltype(_impl_.terminated_)*/false - , /*decltype(_impl_.support_)*/false - , /*decltype(_impl_.tctokensendertimestamp_)*/uint64_t{0u} - , /*decltype(_impl_.createdat_)*/uint64_t{0u} - , /*decltype(_impl_.isparentgroup_)*/false - , /*decltype(_impl_.isdefaultsubgroup_)*/false - , /*decltype(_impl_.selfpnexposed_)*/false} {} -struct ConversationDefaultTypeInternal { - PROTOBUF_CONSTEXPR ConversationDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~ConversationDefaultTypeInternal() {} - union { - Conversation _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ConversationDefaultTypeInternal _Conversation_default_instance_; -PROTOBUF_CONSTEXPR DeviceListMetadata::DeviceListMetadata( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.senderkeyindexes_)*/{} - , /*decltype(_impl_._senderkeyindexes_cached_byte_size_)*/{0} - , /*decltype(_impl_.recipientkeyindexes_)*/{} - , /*decltype(_impl_._recipientkeyindexes_cached_byte_size_)*/{0} - , /*decltype(_impl_.senderkeyhash_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.recipientkeyhash_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.sendertimestamp_)*/uint64_t{0u} - , /*decltype(_impl_.recipienttimestamp_)*/uint64_t{0u}} {} -struct DeviceListMetadataDefaultTypeInternal { - PROTOBUF_CONSTEXPR DeviceListMetadataDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~DeviceListMetadataDefaultTypeInternal() {} - union { - DeviceListMetadata _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeviceListMetadataDefaultTypeInternal _DeviceListMetadata_default_instance_; -PROTOBUF_CONSTEXPR DeviceProps_AppVersion::DeviceProps_AppVersion( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.primary_)*/0u - , /*decltype(_impl_.secondary_)*/0u - , /*decltype(_impl_.tertiary_)*/0u - , /*decltype(_impl_.quaternary_)*/0u - , /*decltype(_impl_.quinary_)*/0u} {} -struct DeviceProps_AppVersionDefaultTypeInternal { - PROTOBUF_CONSTEXPR DeviceProps_AppVersionDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~DeviceProps_AppVersionDefaultTypeInternal() {} - union { - DeviceProps_AppVersion _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeviceProps_AppVersionDefaultTypeInternal _DeviceProps_AppVersion_default_instance_; -PROTOBUF_CONSTEXPR DeviceProps::DeviceProps( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.os_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.version_)*/nullptr - , /*decltype(_impl_.platformtype_)*/0 - , /*decltype(_impl_.requirefullsync_)*/false} {} -struct DevicePropsDefaultTypeInternal { - PROTOBUF_CONSTEXPR DevicePropsDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~DevicePropsDefaultTypeInternal() {} - union { - DeviceProps _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DevicePropsDefaultTypeInternal _DeviceProps_default_instance_; -PROTOBUF_CONSTEXPR DisappearingMode::DisappearingMode( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.initiator_)*/0} {} -struct DisappearingModeDefaultTypeInternal { - PROTOBUF_CONSTEXPR DisappearingModeDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~DisappearingModeDefaultTypeInternal() {} - union { - DisappearingMode _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DisappearingModeDefaultTypeInternal _DisappearingMode_default_instance_; -PROTOBUF_CONSTEXPR EphemeralSetting::EphemeralSetting( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.timestamp_)*/int64_t{0} - , /*decltype(_impl_.duration_)*/0} {} -struct EphemeralSettingDefaultTypeInternal { - PROTOBUF_CONSTEXPR EphemeralSettingDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~EphemeralSettingDefaultTypeInternal() {} - union { - EphemeralSetting _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EphemeralSettingDefaultTypeInternal _EphemeralSetting_default_instance_; -PROTOBUF_CONSTEXPR ExitCode::ExitCode( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.text_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.code_)*/uint64_t{0u}} {} -struct ExitCodeDefaultTypeInternal { - PROTOBUF_CONSTEXPR ExitCodeDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~ExitCodeDefaultTypeInternal() {} - union { - ExitCode _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ExitCodeDefaultTypeInternal _ExitCode_default_instance_; -PROTOBUF_CONSTEXPR ExternalBlobReference::ExternalBlobReference( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.handle_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.filesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.fileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.filesizebytes_)*/uint64_t{0u}} {} -struct ExternalBlobReferenceDefaultTypeInternal { - PROTOBUF_CONSTEXPR ExternalBlobReferenceDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~ExternalBlobReferenceDefaultTypeInternal() {} - union { - ExternalBlobReference _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ExternalBlobReferenceDefaultTypeInternal _ExternalBlobReference_default_instance_; -PROTOBUF_CONSTEXPR GlobalSettings::GlobalSettings( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.lightthemewallpaper_)*/nullptr - , /*decltype(_impl_.darkthemewallpaper_)*/nullptr - , /*decltype(_impl_.autodownloadwifi_)*/nullptr - , /*decltype(_impl_.autodownloadcellular_)*/nullptr - , /*decltype(_impl_.autodownloadroaming_)*/nullptr - , /*decltype(_impl_.mediavisibility_)*/0 - , /*decltype(_impl_.showindividualnotificationspreview_)*/false - , /*decltype(_impl_.showgroupnotificationspreview_)*/false - , /*decltype(_impl_.disappearingmodetimestamp_)*/int64_t{0} - , /*decltype(_impl_.disappearingmodeduration_)*/0} {} -struct GlobalSettingsDefaultTypeInternal { - PROTOBUF_CONSTEXPR GlobalSettingsDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~GlobalSettingsDefaultTypeInternal() {} - union { - GlobalSettings _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GlobalSettingsDefaultTypeInternal _GlobalSettings_default_instance_; -PROTOBUF_CONSTEXPR GroupParticipant::GroupParticipant( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.userjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.rank_)*/0} {} -struct GroupParticipantDefaultTypeInternal { - PROTOBUF_CONSTEXPR GroupParticipantDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~GroupParticipantDefaultTypeInternal() {} - union { - GroupParticipant _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GroupParticipantDefaultTypeInternal _GroupParticipant_default_instance_; -PROTOBUF_CONSTEXPR HandshakeMessage_ClientFinish::HandshakeMessage_ClientFinish( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.static__)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.payload_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct HandshakeMessage_ClientFinishDefaultTypeInternal { - PROTOBUF_CONSTEXPR HandshakeMessage_ClientFinishDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~HandshakeMessage_ClientFinishDefaultTypeInternal() {} - union { - HandshakeMessage_ClientFinish _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HandshakeMessage_ClientFinishDefaultTypeInternal _HandshakeMessage_ClientFinish_default_instance_; -PROTOBUF_CONSTEXPR HandshakeMessage_ClientHello::HandshakeMessage_ClientHello( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.ephemeral_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.static__)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.payload_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct HandshakeMessage_ClientHelloDefaultTypeInternal { - PROTOBUF_CONSTEXPR HandshakeMessage_ClientHelloDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~HandshakeMessage_ClientHelloDefaultTypeInternal() {} - union { - HandshakeMessage_ClientHello _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HandshakeMessage_ClientHelloDefaultTypeInternal _HandshakeMessage_ClientHello_default_instance_; -PROTOBUF_CONSTEXPR HandshakeMessage_ServerHello::HandshakeMessage_ServerHello( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.ephemeral_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.static__)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.payload_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct HandshakeMessage_ServerHelloDefaultTypeInternal { - PROTOBUF_CONSTEXPR HandshakeMessage_ServerHelloDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~HandshakeMessage_ServerHelloDefaultTypeInternal() {} - union { - HandshakeMessage_ServerHello _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HandshakeMessage_ServerHelloDefaultTypeInternal _HandshakeMessage_ServerHello_default_instance_; -PROTOBUF_CONSTEXPR HandshakeMessage::HandshakeMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.clienthello_)*/nullptr - , /*decltype(_impl_.serverhello_)*/nullptr - , /*decltype(_impl_.clientfinish_)*/nullptr} {} -struct HandshakeMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR HandshakeMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~HandshakeMessageDefaultTypeInternal() {} - union { - HandshakeMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HandshakeMessageDefaultTypeInternal _HandshakeMessage_default_instance_; -PROTOBUF_CONSTEXPR HistorySync::HistorySync( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.conversations_)*/{} - , /*decltype(_impl_.statusv3messages_)*/{} - , /*decltype(_impl_.pushnames_)*/{} - , /*decltype(_impl_.recentstickers_)*/{} - , /*decltype(_impl_.pastparticipants_)*/{} - , /*decltype(_impl_.threadidusersecret_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.globalsettings_)*/nullptr - , /*decltype(_impl_.synctype_)*/0 - , /*decltype(_impl_.chunkorder_)*/0u - , /*decltype(_impl_.progress_)*/0u - , /*decltype(_impl_.threaddstimeframeoffset_)*/0u} {} -struct HistorySyncDefaultTypeInternal { - PROTOBUF_CONSTEXPR HistorySyncDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~HistorySyncDefaultTypeInternal() {} - union { - HistorySync _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HistorySyncDefaultTypeInternal _HistorySync_default_instance_; -PROTOBUF_CONSTEXPR HistorySyncMsg::HistorySyncMsg( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.message_)*/nullptr - , /*decltype(_impl_.msgorderid_)*/uint64_t{0u}} {} -struct HistorySyncMsgDefaultTypeInternal { - PROTOBUF_CONSTEXPR HistorySyncMsgDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~HistorySyncMsgDefaultTypeInternal() {} - union { - HistorySyncMsg _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HistorySyncMsgDefaultTypeInternal _HistorySyncMsg_default_instance_; -PROTOBUF_CONSTEXPR HydratedTemplateButton_HydratedCallButton::HydratedTemplateButton_HydratedCallButton( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.displaytext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.phonenumber_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct HydratedTemplateButton_HydratedCallButtonDefaultTypeInternal { - PROTOBUF_CONSTEXPR HydratedTemplateButton_HydratedCallButtonDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~HydratedTemplateButton_HydratedCallButtonDefaultTypeInternal() {} - union { - HydratedTemplateButton_HydratedCallButton _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HydratedTemplateButton_HydratedCallButtonDefaultTypeInternal _HydratedTemplateButton_HydratedCallButton_default_instance_; -PROTOBUF_CONSTEXPR HydratedTemplateButton_HydratedQuickReplyButton::HydratedTemplateButton_HydratedQuickReplyButton( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.displaytext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct HydratedTemplateButton_HydratedQuickReplyButtonDefaultTypeInternal { - PROTOBUF_CONSTEXPR HydratedTemplateButton_HydratedQuickReplyButtonDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~HydratedTemplateButton_HydratedQuickReplyButtonDefaultTypeInternal() {} - union { - HydratedTemplateButton_HydratedQuickReplyButton _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HydratedTemplateButton_HydratedQuickReplyButtonDefaultTypeInternal _HydratedTemplateButton_HydratedQuickReplyButton_default_instance_; -PROTOBUF_CONSTEXPR HydratedTemplateButton_HydratedURLButton::HydratedTemplateButton_HydratedURLButton( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.displaytext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct HydratedTemplateButton_HydratedURLButtonDefaultTypeInternal { - PROTOBUF_CONSTEXPR HydratedTemplateButton_HydratedURLButtonDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~HydratedTemplateButton_HydratedURLButtonDefaultTypeInternal() {} - union { - HydratedTemplateButton_HydratedURLButton _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HydratedTemplateButton_HydratedURLButtonDefaultTypeInternal _HydratedTemplateButton_HydratedURLButton_default_instance_; -PROTOBUF_CONSTEXPR HydratedTemplateButton::HydratedTemplateButton( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.index_)*/0u - , /*decltype(_impl_.hydratedButton_)*/{} - , /*decltype(_impl_._oneof_case_)*/{}} {} -struct HydratedTemplateButtonDefaultTypeInternal { - PROTOBUF_CONSTEXPR HydratedTemplateButtonDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~HydratedTemplateButtonDefaultTypeInternal() {} - union { - HydratedTemplateButton _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HydratedTemplateButtonDefaultTypeInternal _HydratedTemplateButton_default_instance_; -PROTOBUF_CONSTEXPR IdentityKeyPairStructure::IdentityKeyPairStructure( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.publickey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.privatekey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct IdentityKeyPairStructureDefaultTypeInternal { - PROTOBUF_CONSTEXPR IdentityKeyPairStructureDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~IdentityKeyPairStructureDefaultTypeInternal() {} - union { - IdentityKeyPairStructure _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IdentityKeyPairStructureDefaultTypeInternal _IdentityKeyPairStructure_default_instance_; -PROTOBUF_CONSTEXPR InteractiveAnnotation::InteractiveAnnotation( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_.polygonvertices_)*/{} - , /*decltype(_impl_.action_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_._oneof_case_)*/{}} {} -struct InteractiveAnnotationDefaultTypeInternal { - PROTOBUF_CONSTEXPR InteractiveAnnotationDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~InteractiveAnnotationDefaultTypeInternal() {} - union { - InteractiveAnnotation _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 InteractiveAnnotationDefaultTypeInternal _InteractiveAnnotation_default_instance_; -PROTOBUF_CONSTEXPR KeepInChat::KeepInChat( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.devicejid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.key_)*/nullptr - , /*decltype(_impl_.servertimestamp_)*/int64_t{0} - , /*decltype(_impl_.keeptype_)*/0} {} -struct KeepInChatDefaultTypeInternal { - PROTOBUF_CONSTEXPR KeepInChatDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~KeepInChatDefaultTypeInternal() {} - union { - KeepInChat _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 KeepInChatDefaultTypeInternal _KeepInChat_default_instance_; -PROTOBUF_CONSTEXPR KeyId::KeyId( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct KeyIdDefaultTypeInternal { - PROTOBUF_CONSTEXPR KeyIdDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~KeyIdDefaultTypeInternal() {} - union { - KeyId _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 KeyIdDefaultTypeInternal _KeyId_default_instance_; -PROTOBUF_CONSTEXPR LocalizedName::LocalizedName( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.lg_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.lc_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.verifiedname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct LocalizedNameDefaultTypeInternal { - PROTOBUF_CONSTEXPR LocalizedNameDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~LocalizedNameDefaultTypeInternal() {} - union { - LocalizedName _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LocalizedNameDefaultTypeInternal _LocalizedName_default_instance_; -PROTOBUF_CONSTEXPR Location::Location( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.degreeslatitude_)*/0 - , /*decltype(_impl_.degreeslongitude_)*/0} {} -struct LocationDefaultTypeInternal { - PROTOBUF_CONSTEXPR LocationDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~LocationDefaultTypeInternal() {} - union { - Location _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LocationDefaultTypeInternal _Location_default_instance_; -PROTOBUF_CONSTEXPR MediaData::MediaData( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.localpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct MediaDataDefaultTypeInternal { - PROTOBUF_CONSTEXPR MediaDataDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~MediaDataDefaultTypeInternal() {} - union { - MediaData _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MediaDataDefaultTypeInternal _MediaData_default_instance_; -PROTOBUF_CONSTEXPR MediaRetryNotification::MediaRetryNotification( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.stanzaid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.result_)*/0} {} -struct MediaRetryNotificationDefaultTypeInternal { - PROTOBUF_CONSTEXPR MediaRetryNotificationDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~MediaRetryNotificationDefaultTypeInternal() {} - union { - MediaRetryNotification _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MediaRetryNotificationDefaultTypeInternal _MediaRetryNotification_default_instance_; -PROTOBUF_CONSTEXPR Message_AppStateFatalExceptionNotification::Message_AppStateFatalExceptionNotification( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.collectionnames_)*/{} - , /*decltype(_impl_.timestamp_)*/int64_t{0}} {} -struct Message_AppStateFatalExceptionNotificationDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_AppStateFatalExceptionNotificationDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_AppStateFatalExceptionNotificationDefaultTypeInternal() {} - union { - Message_AppStateFatalExceptionNotification _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_AppStateFatalExceptionNotificationDefaultTypeInternal _Message_AppStateFatalExceptionNotification_default_instance_; -PROTOBUF_CONSTEXPR Message_AppStateSyncKeyData::Message_AppStateSyncKeyData( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.keydata_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.fingerprint_)*/nullptr - , /*decltype(_impl_.timestamp_)*/int64_t{0}} {} -struct Message_AppStateSyncKeyDataDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_AppStateSyncKeyDataDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_AppStateSyncKeyDataDefaultTypeInternal() {} - union { - Message_AppStateSyncKeyData _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_AppStateSyncKeyDataDefaultTypeInternal _Message_AppStateSyncKeyData_default_instance_; -PROTOBUF_CONSTEXPR Message_AppStateSyncKeyFingerprint::Message_AppStateSyncKeyFingerprint( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.deviceindexes_)*/{} - , /*decltype(_impl_._deviceindexes_cached_byte_size_)*/{0} - , /*decltype(_impl_.rawid_)*/0u - , /*decltype(_impl_.currentindex_)*/0u} {} -struct Message_AppStateSyncKeyFingerprintDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_AppStateSyncKeyFingerprintDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_AppStateSyncKeyFingerprintDefaultTypeInternal() {} - union { - Message_AppStateSyncKeyFingerprint _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_AppStateSyncKeyFingerprintDefaultTypeInternal _Message_AppStateSyncKeyFingerprint_default_instance_; -PROTOBUF_CONSTEXPR Message_AppStateSyncKeyId::Message_AppStateSyncKeyId( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.keyid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct Message_AppStateSyncKeyIdDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_AppStateSyncKeyIdDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_AppStateSyncKeyIdDefaultTypeInternal() {} - union { - Message_AppStateSyncKeyId _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_AppStateSyncKeyIdDefaultTypeInternal _Message_AppStateSyncKeyId_default_instance_; -PROTOBUF_CONSTEXPR Message_AppStateSyncKeyRequest::Message_AppStateSyncKeyRequest( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_.keyids_)*/{} - , /*decltype(_impl_._cached_size_)*/{}} {} -struct Message_AppStateSyncKeyRequestDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_AppStateSyncKeyRequestDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_AppStateSyncKeyRequestDefaultTypeInternal() {} - union { - Message_AppStateSyncKeyRequest _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_AppStateSyncKeyRequestDefaultTypeInternal _Message_AppStateSyncKeyRequest_default_instance_; -PROTOBUF_CONSTEXPR Message_AppStateSyncKeyShare::Message_AppStateSyncKeyShare( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_.keys_)*/{} - , /*decltype(_impl_._cached_size_)*/{}} {} -struct Message_AppStateSyncKeyShareDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_AppStateSyncKeyShareDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_AppStateSyncKeyShareDefaultTypeInternal() {} - union { - Message_AppStateSyncKeyShare _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_AppStateSyncKeyShareDefaultTypeInternal _Message_AppStateSyncKeyShare_default_instance_; -PROTOBUF_CONSTEXPR Message_AppStateSyncKey::Message_AppStateSyncKey( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.keyid_)*/nullptr - , /*decltype(_impl_.keydata_)*/nullptr} {} -struct Message_AppStateSyncKeyDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_AppStateSyncKeyDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_AppStateSyncKeyDefaultTypeInternal() {} - union { - Message_AppStateSyncKey _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_AppStateSyncKeyDefaultTypeInternal _Message_AppStateSyncKey_default_instance_; -PROTOBUF_CONSTEXPR Message_AudioMessage::Message_AudioMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.mimetype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.filesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.fileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.streamingsidecar_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.waveform_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.contextinfo_)*/nullptr - , /*decltype(_impl_.filelength_)*/uint64_t{0u} - , /*decltype(_impl_.seconds_)*/0u - , /*decltype(_impl_.ptt_)*/false - , /*decltype(_impl_.mediakeytimestamp_)*/int64_t{0}} {} -struct Message_AudioMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_AudioMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_AudioMessageDefaultTypeInternal() {} - union { - Message_AudioMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_AudioMessageDefaultTypeInternal _Message_AudioMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_ButtonsMessage_Button_ButtonText::Message_ButtonsMessage_Button_ButtonText( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.displaytext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct Message_ButtonsMessage_Button_ButtonTextDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_ButtonsMessage_Button_ButtonTextDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_ButtonsMessage_Button_ButtonTextDefaultTypeInternal() {} - union { - Message_ButtonsMessage_Button_ButtonText _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ButtonsMessage_Button_ButtonTextDefaultTypeInternal _Message_ButtonsMessage_Button_ButtonText_default_instance_; -PROTOBUF_CONSTEXPR Message_ButtonsMessage_Button_NativeFlowInfo::Message_ButtonsMessage_Button_NativeFlowInfo( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.paramsjson_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct Message_ButtonsMessage_Button_NativeFlowInfoDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_ButtonsMessage_Button_NativeFlowInfoDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_ButtonsMessage_Button_NativeFlowInfoDefaultTypeInternal() {} - union { - Message_ButtonsMessage_Button_NativeFlowInfo _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ButtonsMessage_Button_NativeFlowInfoDefaultTypeInternal _Message_ButtonsMessage_Button_NativeFlowInfo_default_instance_; -PROTOBUF_CONSTEXPR Message_ButtonsMessage_Button::Message_ButtonsMessage_Button( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.buttonid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.buttontext_)*/nullptr - , /*decltype(_impl_.nativeflowinfo_)*/nullptr - , /*decltype(_impl_.type_)*/0} {} -struct Message_ButtonsMessage_ButtonDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_ButtonsMessage_ButtonDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_ButtonsMessage_ButtonDefaultTypeInternal() {} - union { - Message_ButtonsMessage_Button _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ButtonsMessage_ButtonDefaultTypeInternal _Message_ButtonsMessage_Button_default_instance_; -PROTOBUF_CONSTEXPR Message_ButtonsMessage::Message_ButtonsMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.buttons_)*/{} - , /*decltype(_impl_.contenttext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.footertext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.contextinfo_)*/nullptr - , /*decltype(_impl_.headertype_)*/0 - , /*decltype(_impl_.header_)*/{} - , /*decltype(_impl_._oneof_case_)*/{}} {} -struct Message_ButtonsMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_ButtonsMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_ButtonsMessageDefaultTypeInternal() {} - union { - Message_ButtonsMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ButtonsMessageDefaultTypeInternal _Message_ButtonsMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_ButtonsResponseMessage::Message_ButtonsResponseMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.selectedbuttonid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.contextinfo_)*/nullptr - , /*decltype(_impl_.type_)*/0 - , /*decltype(_impl_.response_)*/{} - , /*decltype(_impl_._oneof_case_)*/{}} {} -struct Message_ButtonsResponseMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_ButtonsResponseMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_ButtonsResponseMessageDefaultTypeInternal() {} - union { - Message_ButtonsResponseMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ButtonsResponseMessageDefaultTypeInternal _Message_ButtonsResponseMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_Call::Message_Call( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.callkey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.conversionsource_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.conversiondata_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.conversiondelayseconds_)*/0u} {} -struct Message_CallDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_CallDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_CallDefaultTypeInternal() {} - union { - Message_Call _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_CallDefaultTypeInternal _Message_Call_default_instance_; -PROTOBUF_CONSTEXPR Message_CancelPaymentRequestMessage::Message_CancelPaymentRequestMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.key_)*/nullptr} {} -struct Message_CancelPaymentRequestMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_CancelPaymentRequestMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_CancelPaymentRequestMessageDefaultTypeInternal() {} - union { - Message_CancelPaymentRequestMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_CancelPaymentRequestMessageDefaultTypeInternal _Message_CancelPaymentRequestMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_Chat::Message_Chat( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.displayname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct Message_ChatDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_ChatDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_ChatDefaultTypeInternal() {} - union { - Message_Chat _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ChatDefaultTypeInternal _Message_Chat_default_instance_; -PROTOBUF_CONSTEXPR Message_ContactMessage::Message_ContactMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.displayname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.vcard_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.contextinfo_)*/nullptr} {} -struct Message_ContactMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_ContactMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_ContactMessageDefaultTypeInternal() {} - union { - Message_ContactMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ContactMessageDefaultTypeInternal _Message_ContactMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_ContactsArrayMessage::Message_ContactsArrayMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.contacts_)*/{} - , /*decltype(_impl_.displayname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.contextinfo_)*/nullptr} {} -struct Message_ContactsArrayMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_ContactsArrayMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_ContactsArrayMessageDefaultTypeInternal() {} - union { - Message_ContactsArrayMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ContactsArrayMessageDefaultTypeInternal _Message_ContactsArrayMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_DeclinePaymentRequestMessage::Message_DeclinePaymentRequestMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.key_)*/nullptr} {} -struct Message_DeclinePaymentRequestMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_DeclinePaymentRequestMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_DeclinePaymentRequestMessageDefaultTypeInternal() {} - union { - Message_DeclinePaymentRequestMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_DeclinePaymentRequestMessageDefaultTypeInternal _Message_DeclinePaymentRequestMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_DeviceSentMessage::Message_DeviceSentMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.destinationjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.phash_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.message_)*/nullptr} {} -struct Message_DeviceSentMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_DeviceSentMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_DeviceSentMessageDefaultTypeInternal() {} - union { - Message_DeviceSentMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_DeviceSentMessageDefaultTypeInternal _Message_DeviceSentMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_DocumentMessage::Message_DocumentMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.mimetype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.filesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.filename_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.fileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.thumbnaildirectpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.thumbnailsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.thumbnailencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.jpegthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.caption_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.contextinfo_)*/nullptr - , /*decltype(_impl_.filelength_)*/uint64_t{0u} - , /*decltype(_impl_.pagecount_)*/0u - , /*decltype(_impl_.contactvcard_)*/false - , /*decltype(_impl_.mediakeytimestamp_)*/int64_t{0} - , /*decltype(_impl_.thumbnailheight_)*/0u - , /*decltype(_impl_.thumbnailwidth_)*/0u} {} -struct Message_DocumentMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_DocumentMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_DocumentMessageDefaultTypeInternal() {} - union { - Message_DocumentMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_DocumentMessageDefaultTypeInternal _Message_DocumentMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_ExtendedTextMessage::Message_ExtendedTextMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.text_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.matchedtext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.canonicalurl_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.description_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.jpegthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.thumbnaildirectpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.thumbnailsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.thumbnailencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.invitelinkparentgroupsubjectv2_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.invitelinkparentgroupthumbnailv2_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.contextinfo_)*/nullptr - , /*decltype(_impl_.textargb_)*/0u - , /*decltype(_impl_.backgroundargb_)*/0u - , /*decltype(_impl_.font_)*/0 - , /*decltype(_impl_.previewtype_)*/0 - , /*decltype(_impl_.donotplayinline_)*/false - , /*decltype(_impl_.thumbnailheight_)*/0u - , /*decltype(_impl_.mediakeytimestamp_)*/int64_t{0} - , /*decltype(_impl_.thumbnailwidth_)*/0u - , /*decltype(_impl_.invitelinkgrouptype_)*/0 - , /*decltype(_impl_.invitelinkgrouptypev2_)*/0} {} -struct Message_ExtendedTextMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_ExtendedTextMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_ExtendedTextMessageDefaultTypeInternal() {} - union { - Message_ExtendedTextMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ExtendedTextMessageDefaultTypeInternal _Message_ExtendedTextMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_FutureProofMessage::Message_FutureProofMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.message_)*/nullptr} {} -struct Message_FutureProofMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_FutureProofMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_FutureProofMessageDefaultTypeInternal() {} - union { - Message_FutureProofMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_FutureProofMessageDefaultTypeInternal _Message_FutureProofMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_GroupInviteMessage::Message_GroupInviteMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.groupjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.invitecode_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.groupname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.jpegthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.caption_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.contextinfo_)*/nullptr - , /*decltype(_impl_.inviteexpiration_)*/int64_t{0} - , /*decltype(_impl_.grouptype_)*/0} {} -struct Message_GroupInviteMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_GroupInviteMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_GroupInviteMessageDefaultTypeInternal() {} - union { - Message_GroupInviteMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_GroupInviteMessageDefaultTypeInternal _Message_GroupInviteMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.currencycode_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.amount1000_)*/int64_t{0}} {} -struct Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrencyDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrencyDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrencyDefaultTypeInternal() {} - union { - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrencyDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency_default_instance_; -PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.year_)*/0u - , /*decltype(_impl_.month_)*/0u - , /*decltype(_impl_.dayofmonth_)*/0u - , /*decltype(_impl_.hour_)*/0u - , /*decltype(_impl_.minute_)*/0u - , /*decltype(_impl_.dayofweek_)*/1 - , /*decltype(_impl_.calendar_)*/1} {} -struct Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponentDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponentDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponentDefaultTypeInternal() {} - union { - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponentDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_default_instance_; -PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.timestamp_)*/int64_t{0}} {} -struct Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpochDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpochDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpochDefaultTypeInternal() {} - union { - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpochDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch_default_instance_; -PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_.datetimeOneof_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_._oneof_case_)*/{}} {} -struct Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTimeDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTimeDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTimeDefaultTypeInternal() {} - union { - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTimeDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_default_instance_; -PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter::Message_HighlyStructuredMessage_HSMLocalizableParameter( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.default__)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.paramOneof_)*/{} - , /*decltype(_impl_._oneof_case_)*/{}} {} -struct Message_HighlyStructuredMessage_HSMLocalizableParameterDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameterDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_HighlyStructuredMessage_HSMLocalizableParameterDefaultTypeInternal() {} - union { - Message_HighlyStructuredMessage_HSMLocalizableParameter _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_HighlyStructuredMessage_HSMLocalizableParameterDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_default_instance_; -PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage::Message_HighlyStructuredMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.params_)*/{} - , /*decltype(_impl_.localizableparams_)*/{} - , /*decltype(_impl_.namespace__)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.elementname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.fallbacklg_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.fallbacklc_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.deterministiclg_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.deterministiclc_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.hydratedhsm_)*/nullptr} {} -struct Message_HighlyStructuredMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_HighlyStructuredMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_HighlyStructuredMessageDefaultTypeInternal() {} - union { - Message_HighlyStructuredMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_HighlyStructuredMessageDefaultTypeInternal _Message_HighlyStructuredMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_HistorySyncNotification::Message_HistorySyncNotification( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.filesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.fileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.originalmessageid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.filelength_)*/uint64_t{0u} - , /*decltype(_impl_.synctype_)*/0 - , /*decltype(_impl_.chunkorder_)*/0u - , /*decltype(_impl_.progress_)*/0u} {} -struct Message_HistorySyncNotificationDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_HistorySyncNotificationDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_HistorySyncNotificationDefaultTypeInternal() {} - union { - Message_HistorySyncNotification _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_HistorySyncNotificationDefaultTypeInternal _Message_HistorySyncNotification_default_instance_; -PROTOBUF_CONSTEXPR Message_ImageMessage::Message_ImageMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.interactiveannotations_)*/{} - , /*decltype(_impl_.scanlengths_)*/{} - , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.mimetype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.caption_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.filesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.fileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.jpegthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.firstscansidecar_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.scanssidecar_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.midqualityfilesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.midqualityfileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.thumbnaildirectpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.thumbnailsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.thumbnailencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.staticurl_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.contextinfo_)*/nullptr - , /*decltype(_impl_.filelength_)*/uint64_t{0u} - , /*decltype(_impl_.height_)*/0u - , /*decltype(_impl_.width_)*/0u - , /*decltype(_impl_.mediakeytimestamp_)*/int64_t{0} - , /*decltype(_impl_.firstscanlength_)*/0u - , /*decltype(_impl_.experimentgroupid_)*/0u - , /*decltype(_impl_.viewonce_)*/false} {} -struct Message_ImageMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_ImageMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_ImageMessageDefaultTypeInternal() {} - union { - Message_ImageMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ImageMessageDefaultTypeInternal _Message_ImageMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_InitialSecurityNotificationSettingSync::Message_InitialSecurityNotificationSettingSync( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.securitynotificationenabled_)*/false} {} -struct Message_InitialSecurityNotificationSettingSyncDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_InitialSecurityNotificationSettingSyncDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_InitialSecurityNotificationSettingSyncDefaultTypeInternal() {} - union { - Message_InitialSecurityNotificationSettingSync _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InitialSecurityNotificationSettingSyncDefaultTypeInternal _Message_InitialSecurityNotificationSettingSync_default_instance_; -PROTOBUF_CONSTEXPR Message_InteractiveMessage_Body::Message_InteractiveMessage_Body( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.text_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct Message_InteractiveMessage_BodyDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_InteractiveMessage_BodyDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_InteractiveMessage_BodyDefaultTypeInternal() {} - union { - Message_InteractiveMessage_Body _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveMessage_BodyDefaultTypeInternal _Message_InteractiveMessage_Body_default_instance_; -PROTOBUF_CONSTEXPR Message_InteractiveMessage_CollectionMessage::Message_InteractiveMessage_CollectionMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.bizjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.messageversion_)*/0} {} -struct Message_InteractiveMessage_CollectionMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_InteractiveMessage_CollectionMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_InteractiveMessage_CollectionMessageDefaultTypeInternal() {} - union { - Message_InteractiveMessage_CollectionMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveMessage_CollectionMessageDefaultTypeInternal _Message_InteractiveMessage_CollectionMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_InteractiveMessage_Footer::Message_InteractiveMessage_Footer( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.text_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct Message_InteractiveMessage_FooterDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_InteractiveMessage_FooterDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_InteractiveMessage_FooterDefaultTypeInternal() {} - union { - Message_InteractiveMessage_Footer _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveMessage_FooterDefaultTypeInternal _Message_InteractiveMessage_Footer_default_instance_; -PROTOBUF_CONSTEXPR Message_InteractiveMessage_Header::Message_InteractiveMessage_Header( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.subtitle_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.hasmediaattachment_)*/false - , /*decltype(_impl_.media_)*/{} - , /*decltype(_impl_._oneof_case_)*/{}} {} -struct Message_InteractiveMessage_HeaderDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_InteractiveMessage_HeaderDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_InteractiveMessage_HeaderDefaultTypeInternal() {} - union { - Message_InteractiveMessage_Header _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveMessage_HeaderDefaultTypeInternal _Message_InteractiveMessage_Header_default_instance_; -PROTOBUF_CONSTEXPR Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.buttonparamsjson_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct Message_InteractiveMessage_NativeFlowMessage_NativeFlowButtonDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_InteractiveMessage_NativeFlowMessage_NativeFlowButtonDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_InteractiveMessage_NativeFlowMessage_NativeFlowButtonDefaultTypeInternal() {} - union { - Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveMessage_NativeFlowMessage_NativeFlowButtonDefaultTypeInternal _Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton_default_instance_; -PROTOBUF_CONSTEXPR Message_InteractiveMessage_NativeFlowMessage::Message_InteractiveMessage_NativeFlowMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.buttons_)*/{} - , /*decltype(_impl_.messageparamsjson_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.messageversion_)*/0} {} -struct Message_InteractiveMessage_NativeFlowMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_InteractiveMessage_NativeFlowMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_InteractiveMessage_NativeFlowMessageDefaultTypeInternal() {} - union { - Message_InteractiveMessage_NativeFlowMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveMessage_NativeFlowMessageDefaultTypeInternal _Message_InteractiveMessage_NativeFlowMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_InteractiveMessage_ShopMessage::Message_InteractiveMessage_ShopMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.surface_)*/0 - , /*decltype(_impl_.messageversion_)*/0} {} -struct Message_InteractiveMessage_ShopMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_InteractiveMessage_ShopMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_InteractiveMessage_ShopMessageDefaultTypeInternal() {} - union { - Message_InteractiveMessage_ShopMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveMessage_ShopMessageDefaultTypeInternal _Message_InteractiveMessage_ShopMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_InteractiveMessage::Message_InteractiveMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.header_)*/nullptr - , /*decltype(_impl_.body_)*/nullptr - , /*decltype(_impl_.footer_)*/nullptr - , /*decltype(_impl_.contextinfo_)*/nullptr - , /*decltype(_impl_.interactiveMessage_)*/{} - , /*decltype(_impl_._oneof_case_)*/{}} {} -struct Message_InteractiveMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_InteractiveMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_InteractiveMessageDefaultTypeInternal() {} - union { - Message_InteractiveMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveMessageDefaultTypeInternal _Message_InteractiveMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_InteractiveResponseMessage_Body::Message_InteractiveResponseMessage_Body( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.text_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct Message_InteractiveResponseMessage_BodyDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_InteractiveResponseMessage_BodyDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_InteractiveResponseMessage_BodyDefaultTypeInternal() {} - union { - Message_InteractiveResponseMessage_Body _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveResponseMessage_BodyDefaultTypeInternal _Message_InteractiveResponseMessage_Body_default_instance_; -PROTOBUF_CONSTEXPR Message_InteractiveResponseMessage_NativeFlowResponseMessage::Message_InteractiveResponseMessage_NativeFlowResponseMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.paramsjson_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.version_)*/0} {} -struct Message_InteractiveResponseMessage_NativeFlowResponseMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_InteractiveResponseMessage_NativeFlowResponseMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_InteractiveResponseMessage_NativeFlowResponseMessageDefaultTypeInternal() {} - union { - Message_InteractiveResponseMessage_NativeFlowResponseMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveResponseMessage_NativeFlowResponseMessageDefaultTypeInternal _Message_InteractiveResponseMessage_NativeFlowResponseMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_InteractiveResponseMessage::Message_InteractiveResponseMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.body_)*/nullptr - , /*decltype(_impl_.contextinfo_)*/nullptr - , /*decltype(_impl_.interactiveResponseMessage_)*/{} - , /*decltype(_impl_._oneof_case_)*/{}} {} -struct Message_InteractiveResponseMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_InteractiveResponseMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_InteractiveResponseMessageDefaultTypeInternal() {} - union { - Message_InteractiveResponseMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InteractiveResponseMessageDefaultTypeInternal _Message_InteractiveResponseMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_InvoiceMessage::Message_InvoiceMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.note_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.token_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.attachmentmimetype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.attachmentmediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.attachmentfilesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.attachmentfileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.attachmentdirectpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.attachmentjpegthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.attachmentmediakeytimestamp_)*/int64_t{0} - , /*decltype(_impl_.attachmenttype_)*/0} {} -struct Message_InvoiceMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_InvoiceMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_InvoiceMessageDefaultTypeInternal() {} - union { - Message_InvoiceMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_InvoiceMessageDefaultTypeInternal _Message_InvoiceMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_KeepInChatMessage::Message_KeepInChatMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.key_)*/nullptr - , /*decltype(_impl_.timestampms_)*/int64_t{0} - , /*decltype(_impl_.keeptype_)*/0} {} -struct Message_KeepInChatMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_KeepInChatMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_KeepInChatMessageDefaultTypeInternal() {} - union { - Message_KeepInChatMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_KeepInChatMessageDefaultTypeInternal _Message_KeepInChatMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_ListMessage_ProductListHeaderImage::Message_ListMessage_ProductListHeaderImage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.productid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.jpegthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct Message_ListMessage_ProductListHeaderImageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_ListMessage_ProductListHeaderImageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_ListMessage_ProductListHeaderImageDefaultTypeInternal() {} - union { - Message_ListMessage_ProductListHeaderImage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ListMessage_ProductListHeaderImageDefaultTypeInternal _Message_ListMessage_ProductListHeaderImage_default_instance_; -PROTOBUF_CONSTEXPR Message_ListMessage_ProductListInfo::Message_ListMessage_ProductListInfo( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.productsections_)*/{} - , /*decltype(_impl_.businessownerjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.headerimage_)*/nullptr} {} -struct Message_ListMessage_ProductListInfoDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_ListMessage_ProductListInfoDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_ListMessage_ProductListInfoDefaultTypeInternal() {} - union { - Message_ListMessage_ProductListInfo _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ListMessage_ProductListInfoDefaultTypeInternal _Message_ListMessage_ProductListInfo_default_instance_; -PROTOBUF_CONSTEXPR Message_ListMessage_ProductSection::Message_ListMessage_ProductSection( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.products_)*/{} - , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct Message_ListMessage_ProductSectionDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_ListMessage_ProductSectionDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_ListMessage_ProductSectionDefaultTypeInternal() {} - union { - Message_ListMessage_ProductSection _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ListMessage_ProductSectionDefaultTypeInternal _Message_ListMessage_ProductSection_default_instance_; -PROTOBUF_CONSTEXPR Message_ListMessage_Product::Message_ListMessage_Product( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.productid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct Message_ListMessage_ProductDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_ListMessage_ProductDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_ListMessage_ProductDefaultTypeInternal() {} - union { - Message_ListMessage_Product _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ListMessage_ProductDefaultTypeInternal _Message_ListMessage_Product_default_instance_; -PROTOBUF_CONSTEXPR Message_ListMessage_Row::Message_ListMessage_Row( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.description_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.rowid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct Message_ListMessage_RowDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_ListMessage_RowDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_ListMessage_RowDefaultTypeInternal() {} - union { - Message_ListMessage_Row _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ListMessage_RowDefaultTypeInternal _Message_ListMessage_Row_default_instance_; -PROTOBUF_CONSTEXPR Message_ListMessage_Section::Message_ListMessage_Section( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.rows_)*/{} - , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct Message_ListMessage_SectionDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_ListMessage_SectionDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_ListMessage_SectionDefaultTypeInternal() {} - union { - Message_ListMessage_Section _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ListMessage_SectionDefaultTypeInternal _Message_ListMessage_Section_default_instance_; -PROTOBUF_CONSTEXPR Message_ListMessage::Message_ListMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.sections_)*/{} - , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.description_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.buttontext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.footertext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.productlistinfo_)*/nullptr - , /*decltype(_impl_.contextinfo_)*/nullptr - , /*decltype(_impl_.listtype_)*/0} {} -struct Message_ListMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_ListMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_ListMessageDefaultTypeInternal() {} - union { - Message_ListMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ListMessageDefaultTypeInternal _Message_ListMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_ListResponseMessage_SingleSelectReply::Message_ListResponseMessage_SingleSelectReply( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.selectedrowid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct Message_ListResponseMessage_SingleSelectReplyDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_ListResponseMessage_SingleSelectReplyDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_ListResponseMessage_SingleSelectReplyDefaultTypeInternal() {} - union { - Message_ListResponseMessage_SingleSelectReply _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ListResponseMessage_SingleSelectReplyDefaultTypeInternal _Message_ListResponseMessage_SingleSelectReply_default_instance_; -PROTOBUF_CONSTEXPR Message_ListResponseMessage::Message_ListResponseMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.description_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.singleselectreply_)*/nullptr - , /*decltype(_impl_.contextinfo_)*/nullptr - , /*decltype(_impl_.listtype_)*/0} {} -struct Message_ListResponseMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_ListResponseMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_ListResponseMessageDefaultTypeInternal() {} - union { - Message_ListResponseMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ListResponseMessageDefaultTypeInternal _Message_ListResponseMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_LiveLocationMessage::Message_LiveLocationMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.caption_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.jpegthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.contextinfo_)*/nullptr - , /*decltype(_impl_.degreeslatitude_)*/0 - , /*decltype(_impl_.degreeslongitude_)*/0 - , /*decltype(_impl_.accuracyinmeters_)*/0u - , /*decltype(_impl_.speedinmps_)*/0 - , /*decltype(_impl_.degreesclockwisefrommagneticnorth_)*/0u - , /*decltype(_impl_.timeoffset_)*/0u - , /*decltype(_impl_.sequencenumber_)*/int64_t{0}} {} -struct Message_LiveLocationMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_LiveLocationMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_LiveLocationMessageDefaultTypeInternal() {} - union { - Message_LiveLocationMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_LiveLocationMessageDefaultTypeInternal _Message_LiveLocationMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_LocationMessage::Message_LocationMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.address_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.comment_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.jpegthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.contextinfo_)*/nullptr - , /*decltype(_impl_.degreeslatitude_)*/0 - , /*decltype(_impl_.degreeslongitude_)*/0 - , /*decltype(_impl_.islive_)*/false - , /*decltype(_impl_.accuracyinmeters_)*/0u - , /*decltype(_impl_.speedinmps_)*/0 - , /*decltype(_impl_.degreesclockwisefrommagneticnorth_)*/0u} {} -struct Message_LocationMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_LocationMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_LocationMessageDefaultTypeInternal() {} - union { - Message_LocationMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_LocationMessageDefaultTypeInternal _Message_LocationMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_OrderMessage::Message_OrderMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.orderid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.thumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.message_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.ordertitle_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.sellerjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.token_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.totalcurrencycode_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.contextinfo_)*/nullptr - , /*decltype(_impl_.totalamount1000_)*/int64_t{0} - , /*decltype(_impl_.itemcount_)*/0 - , /*decltype(_impl_.status_)*/1 - , /*decltype(_impl_.surface_)*/1} {} -struct Message_OrderMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_OrderMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_OrderMessageDefaultTypeInternal() {} - union { - Message_OrderMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_OrderMessageDefaultTypeInternal _Message_OrderMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_PaymentInviteMessage::Message_PaymentInviteMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.expirytimestamp_)*/int64_t{0} - , /*decltype(_impl_.servicetype_)*/0} {} -struct Message_PaymentInviteMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_PaymentInviteMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_PaymentInviteMessageDefaultTypeInternal() {} - union { - Message_PaymentInviteMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_PaymentInviteMessageDefaultTypeInternal _Message_PaymentInviteMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_PollCreationMessage_Option::Message_PollCreationMessage_Option( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.optionname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct Message_PollCreationMessage_OptionDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_PollCreationMessage_OptionDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_PollCreationMessage_OptionDefaultTypeInternal() {} - union { - Message_PollCreationMessage_Option _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_PollCreationMessage_OptionDefaultTypeInternal _Message_PollCreationMessage_Option_default_instance_; -PROTOBUF_CONSTEXPR Message_PollCreationMessage::Message_PollCreationMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.options_)*/{} - , /*decltype(_impl_.enckey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.contextinfo_)*/nullptr - , /*decltype(_impl_.selectableoptionscount_)*/0u} {} -struct Message_PollCreationMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_PollCreationMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_PollCreationMessageDefaultTypeInternal() {} - union { - Message_PollCreationMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_PollCreationMessageDefaultTypeInternal _Message_PollCreationMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_PollEncValue::Message_PollEncValue( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.encpayload_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.enciv_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct Message_PollEncValueDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_PollEncValueDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_PollEncValueDefaultTypeInternal() {} - union { - Message_PollEncValue _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_PollEncValueDefaultTypeInternal _Message_PollEncValue_default_instance_; -PROTOBUF_CONSTEXPR Message_PollUpdateMessageMetadata::Message_PollUpdateMessageMetadata( - ::_pbi::ConstantInitialized) {} -struct Message_PollUpdateMessageMetadataDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_PollUpdateMessageMetadataDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_PollUpdateMessageMetadataDefaultTypeInternal() {} - union { - Message_PollUpdateMessageMetadata _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_PollUpdateMessageMetadataDefaultTypeInternal _Message_PollUpdateMessageMetadata_default_instance_; -PROTOBUF_CONSTEXPR Message_PollUpdateMessage::Message_PollUpdateMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.pollcreationmessagekey_)*/nullptr - , /*decltype(_impl_.vote_)*/nullptr - , /*decltype(_impl_.metadata_)*/nullptr - , /*decltype(_impl_.sendertimestampms_)*/int64_t{0}} {} -struct Message_PollUpdateMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_PollUpdateMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_PollUpdateMessageDefaultTypeInternal() {} - union { - Message_PollUpdateMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_PollUpdateMessageDefaultTypeInternal _Message_PollUpdateMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_PollVoteMessage::Message_PollVoteMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_.selectedoptions_)*/{} - , /*decltype(_impl_._cached_size_)*/{}} {} -struct Message_PollVoteMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_PollVoteMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_PollVoteMessageDefaultTypeInternal() {} - union { - Message_PollVoteMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_PollVoteMessageDefaultTypeInternal _Message_PollVoteMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_ProductMessage_CatalogSnapshot::Message_ProductMessage_CatalogSnapshot( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.description_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.catalogimage_)*/nullptr} {} -struct Message_ProductMessage_CatalogSnapshotDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_ProductMessage_CatalogSnapshotDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_ProductMessage_CatalogSnapshotDefaultTypeInternal() {} - union { - Message_ProductMessage_CatalogSnapshot _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ProductMessage_CatalogSnapshotDefaultTypeInternal _Message_ProductMessage_CatalogSnapshot_default_instance_; -PROTOBUF_CONSTEXPR Message_ProductMessage_ProductSnapshot::Message_ProductMessage_ProductSnapshot( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.productid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.description_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.currencycode_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.retailerid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.firstimageid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.productimage_)*/nullptr - , /*decltype(_impl_.priceamount1000_)*/int64_t{0} - , /*decltype(_impl_.salepriceamount1000_)*/int64_t{0} - , /*decltype(_impl_.productimagecount_)*/0u} {} -struct Message_ProductMessage_ProductSnapshotDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_ProductMessage_ProductSnapshotDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_ProductMessage_ProductSnapshotDefaultTypeInternal() {} - union { - Message_ProductMessage_ProductSnapshot _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ProductMessage_ProductSnapshotDefaultTypeInternal _Message_ProductMessage_ProductSnapshot_default_instance_; -PROTOBUF_CONSTEXPR Message_ProductMessage::Message_ProductMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.businessownerjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.body_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.footer_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.product_)*/nullptr - , /*decltype(_impl_.catalog_)*/nullptr - , /*decltype(_impl_.contextinfo_)*/nullptr} {} -struct Message_ProductMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_ProductMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_ProductMessageDefaultTypeInternal() {} - union { - Message_ProductMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ProductMessageDefaultTypeInternal _Message_ProductMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_ProtocolMessage::Message_ProtocolMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.key_)*/nullptr - , /*decltype(_impl_.historysyncnotification_)*/nullptr - , /*decltype(_impl_.appstatesynckeyshare_)*/nullptr - , /*decltype(_impl_.appstatesynckeyrequest_)*/nullptr - , /*decltype(_impl_.initialsecuritynotificationsettingsync_)*/nullptr - , /*decltype(_impl_.appstatefatalexceptionnotification_)*/nullptr - , /*decltype(_impl_.disappearingmode_)*/nullptr - , /*decltype(_impl_.requestmediauploadmessage_)*/nullptr - , /*decltype(_impl_.requestmediauploadresponsemessage_)*/nullptr - , /*decltype(_impl_.type_)*/0 - , /*decltype(_impl_.ephemeralexpiration_)*/0u - , /*decltype(_impl_.ephemeralsettingtimestamp_)*/int64_t{0}} {} -struct Message_ProtocolMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_ProtocolMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_ProtocolMessageDefaultTypeInternal() {} - union { - Message_ProtocolMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ProtocolMessageDefaultTypeInternal _Message_ProtocolMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_ReactionMessage::Message_ReactionMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.text_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.groupingkey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.key_)*/nullptr - , /*decltype(_impl_.sendertimestampms_)*/int64_t{0}} {} -struct Message_ReactionMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_ReactionMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_ReactionMessageDefaultTypeInternal() {} - union { - Message_ReactionMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_ReactionMessageDefaultTypeInternal _Message_ReactionMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_RequestMediaUploadMessage::Message_RequestMediaUploadMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.filesha256_)*/{} - , /*decltype(_impl_.rmrsource_)*/0} {} -struct Message_RequestMediaUploadMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_RequestMediaUploadMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_RequestMediaUploadMessageDefaultTypeInternal() {} - union { - Message_RequestMediaUploadMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_RequestMediaUploadMessageDefaultTypeInternal _Message_RequestMediaUploadMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.filesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.stickermessage_)*/nullptr - , /*decltype(_impl_.mediauploadresult_)*/0} {} -struct Message_RequestMediaUploadResponseMessage_RequestMediaUploadResultDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_RequestMediaUploadResponseMessage_RequestMediaUploadResultDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_RequestMediaUploadResponseMessage_RequestMediaUploadResultDefaultTypeInternal() {} - union { - Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_RequestMediaUploadResponseMessage_RequestMediaUploadResultDefaultTypeInternal _Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult_default_instance_; -PROTOBUF_CONSTEXPR Message_RequestMediaUploadResponseMessage::Message_RequestMediaUploadResponseMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.reuploadresult_)*/{} - , /*decltype(_impl_.stanzaid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.rmrsource_)*/0} {} -struct Message_RequestMediaUploadResponseMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_RequestMediaUploadResponseMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_RequestMediaUploadResponseMessageDefaultTypeInternal() {} - union { - Message_RequestMediaUploadResponseMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_RequestMediaUploadResponseMessageDefaultTypeInternal _Message_RequestMediaUploadResponseMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_RequestPaymentMessage::Message_RequestPaymentMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.currencycodeiso4217_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.requestfrom_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.notemessage_)*/nullptr - , /*decltype(_impl_.amount_)*/nullptr - , /*decltype(_impl_.background_)*/nullptr - , /*decltype(_impl_.amount1000_)*/uint64_t{0u} - , /*decltype(_impl_.expirytimestamp_)*/int64_t{0}} {} -struct Message_RequestPaymentMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_RequestPaymentMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_RequestPaymentMessageDefaultTypeInternal() {} - union { - Message_RequestPaymentMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_RequestPaymentMessageDefaultTypeInternal _Message_RequestPaymentMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_RequestPhoneNumberMessage::Message_RequestPhoneNumberMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.contextinfo_)*/nullptr} {} -struct Message_RequestPhoneNumberMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_RequestPhoneNumberMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_RequestPhoneNumberMessageDefaultTypeInternal() {} - union { - Message_RequestPhoneNumberMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_RequestPhoneNumberMessageDefaultTypeInternal _Message_RequestPhoneNumberMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_SendPaymentMessage::Message_SendPaymentMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.notemessage_)*/nullptr - , /*decltype(_impl_.requestmessagekey_)*/nullptr - , /*decltype(_impl_.background_)*/nullptr} {} -struct Message_SendPaymentMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_SendPaymentMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_SendPaymentMessageDefaultTypeInternal() {} - union { - Message_SendPaymentMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_SendPaymentMessageDefaultTypeInternal _Message_SendPaymentMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_SenderKeyDistributionMessage::Message_SenderKeyDistributionMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.groupid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.axolotlsenderkeydistributionmessage_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct Message_SenderKeyDistributionMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_SenderKeyDistributionMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_SenderKeyDistributionMessageDefaultTypeInternal() {} - union { - Message_SenderKeyDistributionMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_SenderKeyDistributionMessageDefaultTypeInternal _Message_SenderKeyDistributionMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_StickerMessage::Message_StickerMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.filesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.fileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.mimetype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.firstframesidecar_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.pngthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.contextinfo_)*/nullptr - , /*decltype(_impl_.height_)*/0u - , /*decltype(_impl_.width_)*/0u - , /*decltype(_impl_.filelength_)*/uint64_t{0u} - , /*decltype(_impl_.mediakeytimestamp_)*/int64_t{0} - , /*decltype(_impl_.firstframelength_)*/0u - , /*decltype(_impl_.isanimated_)*/false} {} -struct Message_StickerMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_StickerMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_StickerMessageDefaultTypeInternal() {} - union { - Message_StickerMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_StickerMessageDefaultTypeInternal _Message_StickerMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_StickerSyncRMRMessage::Message_StickerSyncRMRMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.filehash_)*/{} - , /*decltype(_impl_.rmrsource_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.requesttimestamp_)*/int64_t{0}} {} -struct Message_StickerSyncRMRMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_StickerSyncRMRMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_StickerSyncRMRMessageDefaultTypeInternal() {} - union { - Message_StickerSyncRMRMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_StickerSyncRMRMessageDefaultTypeInternal _Message_StickerSyncRMRMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_TemplateButtonReplyMessage::Message_TemplateButtonReplyMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.selectedid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.selecteddisplaytext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.contextinfo_)*/nullptr - , /*decltype(_impl_.selectedindex_)*/0u} {} -struct Message_TemplateButtonReplyMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_TemplateButtonReplyMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_TemplateButtonReplyMessageDefaultTypeInternal() {} - union { - Message_TemplateButtonReplyMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_TemplateButtonReplyMessageDefaultTypeInternal _Message_TemplateButtonReplyMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_TemplateMessage_FourRowTemplate::Message_TemplateMessage_FourRowTemplate( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.buttons_)*/{} - , /*decltype(_impl_.content_)*/nullptr - , /*decltype(_impl_.footer_)*/nullptr - , /*decltype(_impl_.title_)*/{} - , /*decltype(_impl_._oneof_case_)*/{}} {} -struct Message_TemplateMessage_FourRowTemplateDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_TemplateMessage_FourRowTemplateDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_TemplateMessage_FourRowTemplateDefaultTypeInternal() {} - union { - Message_TemplateMessage_FourRowTemplate _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_TemplateMessage_FourRowTemplateDefaultTypeInternal _Message_TemplateMessage_FourRowTemplate_default_instance_; -PROTOBUF_CONSTEXPR Message_TemplateMessage_HydratedFourRowTemplate::Message_TemplateMessage_HydratedFourRowTemplate( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.hydratedbuttons_)*/{} - , /*decltype(_impl_.hydratedcontenttext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.hydratedfootertext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.templateid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.title_)*/{} - , /*decltype(_impl_._oneof_case_)*/{}} {} -struct Message_TemplateMessage_HydratedFourRowTemplateDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_TemplateMessage_HydratedFourRowTemplateDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_TemplateMessage_HydratedFourRowTemplateDefaultTypeInternal() {} - union { - Message_TemplateMessage_HydratedFourRowTemplate _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_TemplateMessage_HydratedFourRowTemplateDefaultTypeInternal _Message_TemplateMessage_HydratedFourRowTemplate_default_instance_; -PROTOBUF_CONSTEXPR Message_TemplateMessage::Message_TemplateMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.contextinfo_)*/nullptr - , /*decltype(_impl_.hydratedtemplate_)*/nullptr - , /*decltype(_impl_.format_)*/{} - , /*decltype(_impl_._oneof_case_)*/{}} {} -struct Message_TemplateMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_TemplateMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_TemplateMessageDefaultTypeInternal() {} - union { - Message_TemplateMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_TemplateMessageDefaultTypeInternal _Message_TemplateMessage_default_instance_; -PROTOBUF_CONSTEXPR Message_VideoMessage::Message_VideoMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.interactiveannotations_)*/{} - , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.mimetype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.filesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.caption_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.fileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.jpegthumbnail_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.streamingsidecar_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.thumbnaildirectpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.thumbnailsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.thumbnailencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.staticurl_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.contextinfo_)*/nullptr - , /*decltype(_impl_.filelength_)*/uint64_t{0u} - , /*decltype(_impl_.seconds_)*/0u - , /*decltype(_impl_.height_)*/0u - , /*decltype(_impl_.width_)*/0u - , /*decltype(_impl_.gifplayback_)*/false - , /*decltype(_impl_.viewonce_)*/false - , /*decltype(_impl_.mediakeytimestamp_)*/int64_t{0} - , /*decltype(_impl_.gifattribution_)*/0} {} -struct Message_VideoMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR Message_VideoMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~Message_VideoMessageDefaultTypeInternal() {} - union { - Message_VideoMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Message_VideoMessageDefaultTypeInternal _Message_VideoMessage_default_instance_; -PROTOBUF_CONSTEXPR Message::Message( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.conversation_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.senderkeydistributionmessage_)*/nullptr - , /*decltype(_impl_.imagemessage_)*/nullptr - , /*decltype(_impl_.contactmessage_)*/nullptr - , /*decltype(_impl_.locationmessage_)*/nullptr - , /*decltype(_impl_.extendedtextmessage_)*/nullptr - , /*decltype(_impl_.documentmessage_)*/nullptr - , /*decltype(_impl_.audiomessage_)*/nullptr - , /*decltype(_impl_.videomessage_)*/nullptr - , /*decltype(_impl_.call_)*/nullptr - , /*decltype(_impl_.chat_)*/nullptr - , /*decltype(_impl_.protocolmessage_)*/nullptr - , /*decltype(_impl_.contactsarraymessage_)*/nullptr - , /*decltype(_impl_.highlystructuredmessage_)*/nullptr - , /*decltype(_impl_.fastratchetkeysenderkeydistributionmessage_)*/nullptr - , /*decltype(_impl_.sendpaymentmessage_)*/nullptr - , /*decltype(_impl_.livelocationmessage_)*/nullptr - , /*decltype(_impl_.requestpaymentmessage_)*/nullptr - , /*decltype(_impl_.declinepaymentrequestmessage_)*/nullptr - , /*decltype(_impl_.cancelpaymentrequestmessage_)*/nullptr - , /*decltype(_impl_.templatemessage_)*/nullptr - , /*decltype(_impl_.stickermessage_)*/nullptr - , /*decltype(_impl_.groupinvitemessage_)*/nullptr - , /*decltype(_impl_.templatebuttonreplymessage_)*/nullptr - , /*decltype(_impl_.productmessage_)*/nullptr - , /*decltype(_impl_.devicesentmessage_)*/nullptr - , /*decltype(_impl_.messagecontextinfo_)*/nullptr - , /*decltype(_impl_.listmessage_)*/nullptr - , /*decltype(_impl_.viewoncemessage_)*/nullptr - , /*decltype(_impl_.ordermessage_)*/nullptr - , /*decltype(_impl_.listresponsemessage_)*/nullptr - , /*decltype(_impl_.ephemeralmessage_)*/nullptr - , /*decltype(_impl_.invoicemessage_)*/nullptr - , /*decltype(_impl_.buttonsmessage_)*/nullptr - , /*decltype(_impl_.buttonsresponsemessage_)*/nullptr - , /*decltype(_impl_.paymentinvitemessage_)*/nullptr - , /*decltype(_impl_.interactivemessage_)*/nullptr - , /*decltype(_impl_.reactionmessage_)*/nullptr - , /*decltype(_impl_.stickersyncrmrmessage_)*/nullptr - , /*decltype(_impl_.interactiveresponsemessage_)*/nullptr - , /*decltype(_impl_.pollcreationmessage_)*/nullptr - , /*decltype(_impl_.pollupdatemessage_)*/nullptr - , /*decltype(_impl_.keepinchatmessage_)*/nullptr - , /*decltype(_impl_.documentwithcaptionmessage_)*/nullptr - , /*decltype(_impl_.requestphonenumbermessage_)*/nullptr - , /*decltype(_impl_.viewoncemessagev2_)*/nullptr} {} -struct MessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR MessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~MessageDefaultTypeInternal() {} - union { - Message _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MessageDefaultTypeInternal _Message_default_instance_; -PROTOBUF_CONSTEXPR MessageContextInfo::MessageContextInfo( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.messagesecret_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.paddingbytes_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.devicelistmetadata_)*/nullptr - , /*decltype(_impl_.devicelistmetadataversion_)*/0} {} -struct MessageContextInfoDefaultTypeInternal { - PROTOBUF_CONSTEXPR MessageContextInfoDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~MessageContextInfoDefaultTypeInternal() {} - union { - MessageContextInfo _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MessageContextInfoDefaultTypeInternal _MessageContextInfo_default_instance_; -PROTOBUF_CONSTEXPR MessageKey::MessageKey( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.remotejid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.participant_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.fromme_)*/false} {} -struct MessageKeyDefaultTypeInternal { - PROTOBUF_CONSTEXPR MessageKeyDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~MessageKeyDefaultTypeInternal() {} - union { - MessageKey _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MessageKeyDefaultTypeInternal _MessageKey_default_instance_; -PROTOBUF_CONSTEXPR Money::Money( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.currencycode_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.value_)*/int64_t{0} - , /*decltype(_impl_.offset_)*/0u} {} -struct MoneyDefaultTypeInternal { - PROTOBUF_CONSTEXPR MoneyDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~MoneyDefaultTypeInternal() {} - union { - Money _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MoneyDefaultTypeInternal _Money_default_instance_; -PROTOBUF_CONSTEXPR MsgOpaqueData_PollOption::MsgOpaqueData_PollOption( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct MsgOpaqueData_PollOptionDefaultTypeInternal { - PROTOBUF_CONSTEXPR MsgOpaqueData_PollOptionDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~MsgOpaqueData_PollOptionDefaultTypeInternal() {} - union { - MsgOpaqueData_PollOption _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MsgOpaqueData_PollOptionDefaultTypeInternal _MsgOpaqueData_PollOption_default_instance_; -PROTOBUF_CONSTEXPR MsgOpaqueData::MsgOpaqueData( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.polloptions_)*/{} - , /*decltype(_impl_.body_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.caption_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.paymentnotemsgbody_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.canonicalurl_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.matchedtext_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.title_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.description_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.futureproofbuffer_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.clienturl_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.loc_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.pollname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.messagesecret_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.pollupdateparentkey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.encpollvote_)*/nullptr - , /*decltype(_impl_.lng_)*/0 - , /*decltype(_impl_.lat_)*/0 - , /*decltype(_impl_.islive_)*/false - , /*decltype(_impl_.paymentamount1000_)*/0 - , /*decltype(_impl_.sendertimestampms_)*/int64_t{0} - , /*decltype(_impl_.pollselectableoptionscount_)*/0u} {} -struct MsgOpaqueDataDefaultTypeInternal { - PROTOBUF_CONSTEXPR MsgOpaqueDataDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~MsgOpaqueDataDefaultTypeInternal() {} - union { - MsgOpaqueData _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MsgOpaqueDataDefaultTypeInternal _MsgOpaqueData_default_instance_; -PROTOBUF_CONSTEXPR MsgRowOpaqueData::MsgRowOpaqueData( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.currentmsg_)*/nullptr - , /*decltype(_impl_.quotedmsg_)*/nullptr} {} -struct MsgRowOpaqueDataDefaultTypeInternal { - PROTOBUF_CONSTEXPR MsgRowOpaqueDataDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~MsgRowOpaqueDataDefaultTypeInternal() {} - union { - MsgRowOpaqueData _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MsgRowOpaqueDataDefaultTypeInternal _MsgRowOpaqueData_default_instance_; -PROTOBUF_CONSTEXPR NoiseCertificate_Details::NoiseCertificate_Details( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.issuer_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.subject_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.key_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.expires_)*/uint64_t{0u} - , /*decltype(_impl_.serial_)*/0u} {} -struct NoiseCertificate_DetailsDefaultTypeInternal { - PROTOBUF_CONSTEXPR NoiseCertificate_DetailsDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~NoiseCertificate_DetailsDefaultTypeInternal() {} - union { - NoiseCertificate_Details _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NoiseCertificate_DetailsDefaultTypeInternal _NoiseCertificate_Details_default_instance_; -PROTOBUF_CONSTEXPR NoiseCertificate::NoiseCertificate( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.details_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.signature_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct NoiseCertificateDefaultTypeInternal { - PROTOBUF_CONSTEXPR NoiseCertificateDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~NoiseCertificateDefaultTypeInternal() {} - union { - NoiseCertificate _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NoiseCertificateDefaultTypeInternal _NoiseCertificate_default_instance_; -PROTOBUF_CONSTEXPR NotificationMessageInfo::NotificationMessageInfo( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.participant_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.key_)*/nullptr - , /*decltype(_impl_.message_)*/nullptr - , /*decltype(_impl_.messagetimestamp_)*/uint64_t{0u}} {} -struct NotificationMessageInfoDefaultTypeInternal { - PROTOBUF_CONSTEXPR NotificationMessageInfoDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~NotificationMessageInfoDefaultTypeInternal() {} - union { - NotificationMessageInfo _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NotificationMessageInfoDefaultTypeInternal _NotificationMessageInfo_default_instance_; -PROTOBUF_CONSTEXPR PastParticipant::PastParticipant( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.userjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.leavets_)*/uint64_t{0u} - , /*decltype(_impl_.leavereason_)*/0} {} -struct PastParticipantDefaultTypeInternal { - PROTOBUF_CONSTEXPR PastParticipantDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~PastParticipantDefaultTypeInternal() {} - union { - PastParticipant _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PastParticipantDefaultTypeInternal _PastParticipant_default_instance_; -PROTOBUF_CONSTEXPR PastParticipants::PastParticipants( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.pastparticipants_)*/{} - , /*decltype(_impl_.groupjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct PastParticipantsDefaultTypeInternal { - PROTOBUF_CONSTEXPR PastParticipantsDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~PastParticipantsDefaultTypeInternal() {} - union { - PastParticipants _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PastParticipantsDefaultTypeInternal _PastParticipants_default_instance_; -PROTOBUF_CONSTEXPR PaymentBackground_MediaData::PaymentBackground_MediaData( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.filesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.fileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.mediakeytimestamp_)*/int64_t{0}} {} -struct PaymentBackground_MediaDataDefaultTypeInternal { - PROTOBUF_CONSTEXPR PaymentBackground_MediaDataDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~PaymentBackground_MediaDataDefaultTypeInternal() {} - union { - PaymentBackground_MediaData _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PaymentBackground_MediaDataDefaultTypeInternal _PaymentBackground_MediaData_default_instance_; -PROTOBUF_CONSTEXPR PaymentBackground::PaymentBackground( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.mimetype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.mediadata_)*/nullptr - , /*decltype(_impl_.filelength_)*/uint64_t{0u} - , /*decltype(_impl_.width_)*/0u - , /*decltype(_impl_.height_)*/0u - , /*decltype(_impl_.placeholderargb_)*/0u - , /*decltype(_impl_.textargb_)*/0u - , /*decltype(_impl_.subtextargb_)*/0u - , /*decltype(_impl_.type_)*/0} {} -struct PaymentBackgroundDefaultTypeInternal { - PROTOBUF_CONSTEXPR PaymentBackgroundDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~PaymentBackgroundDefaultTypeInternal() {} - union { - PaymentBackground _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PaymentBackgroundDefaultTypeInternal _PaymentBackground_default_instance_; -PROTOBUF_CONSTEXPR PaymentInfo::PaymentInfo( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.receiverjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.currency_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.requestmessagekey_)*/nullptr - , /*decltype(_impl_.primaryamount_)*/nullptr - , /*decltype(_impl_.exchangeamount_)*/nullptr - , /*decltype(_impl_.amount1000_)*/uint64_t{0u} - , /*decltype(_impl_.currencydeprecated_)*/0 - , /*decltype(_impl_.status_)*/0 - , /*decltype(_impl_.transactiontimestamp_)*/uint64_t{0u} - , /*decltype(_impl_.expirytimestamp_)*/uint64_t{0u} - , /*decltype(_impl_.futureproofed_)*/false - , /*decltype(_impl_.usenovifiatformat_)*/false - , /*decltype(_impl_.txnstatus_)*/0} {} -struct PaymentInfoDefaultTypeInternal { - PROTOBUF_CONSTEXPR PaymentInfoDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~PaymentInfoDefaultTypeInternal() {} - union { - PaymentInfo _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PaymentInfoDefaultTypeInternal _PaymentInfo_default_instance_; -PROTOBUF_CONSTEXPR PendingKeyExchange::PendingKeyExchange( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.localbasekey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.localbasekeyprivate_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.localratchetkey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.localratchetkeyprivate_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.localidentitykey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.localidentitykeyprivate_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.sequence_)*/0u} {} -struct PendingKeyExchangeDefaultTypeInternal { - PROTOBUF_CONSTEXPR PendingKeyExchangeDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~PendingKeyExchangeDefaultTypeInternal() {} - union { - PendingKeyExchange _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PendingKeyExchangeDefaultTypeInternal _PendingKeyExchange_default_instance_; -PROTOBUF_CONSTEXPR PendingPreKey::PendingPreKey( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.basekey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.prekeyid_)*/0u - , /*decltype(_impl_.signedprekeyid_)*/0} {} -struct PendingPreKeyDefaultTypeInternal { - PROTOBUF_CONSTEXPR PendingPreKeyDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~PendingPreKeyDefaultTypeInternal() {} - union { - PendingPreKey _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PendingPreKeyDefaultTypeInternal _PendingPreKey_default_instance_; -PROTOBUF_CONSTEXPR PhotoChange::PhotoChange( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.oldphoto_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.newphoto_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.newphotoid_)*/0u} {} -struct PhotoChangeDefaultTypeInternal { - PROTOBUF_CONSTEXPR PhotoChangeDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~PhotoChangeDefaultTypeInternal() {} - union { - PhotoChange _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PhotoChangeDefaultTypeInternal _PhotoChange_default_instance_; -PROTOBUF_CONSTEXPR Point::Point( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.xdeprecated_)*/0 - , /*decltype(_impl_.ydeprecated_)*/0 - , /*decltype(_impl_.x_)*/0 - , /*decltype(_impl_.y_)*/0} {} -struct PointDefaultTypeInternal { - PROTOBUF_CONSTEXPR PointDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~PointDefaultTypeInternal() {} - union { - Point _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PointDefaultTypeInternal _Point_default_instance_; -PROTOBUF_CONSTEXPR PollAdditionalMetadata::PollAdditionalMetadata( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.pollinvalidated_)*/false} {} -struct PollAdditionalMetadataDefaultTypeInternal { - PROTOBUF_CONSTEXPR PollAdditionalMetadataDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~PollAdditionalMetadataDefaultTypeInternal() {} - union { - PollAdditionalMetadata _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PollAdditionalMetadataDefaultTypeInternal _PollAdditionalMetadata_default_instance_; -PROTOBUF_CONSTEXPR PollEncValue::PollEncValue( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.encpayload_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.enciv_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct PollEncValueDefaultTypeInternal { - PROTOBUF_CONSTEXPR PollEncValueDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~PollEncValueDefaultTypeInternal() {} - union { - PollEncValue _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PollEncValueDefaultTypeInternal _PollEncValue_default_instance_; -PROTOBUF_CONSTEXPR PollUpdate::PollUpdate( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.pollupdatemessagekey_)*/nullptr - , /*decltype(_impl_.vote_)*/nullptr - , /*decltype(_impl_.sendertimestampms_)*/int64_t{0}} {} -struct PollUpdateDefaultTypeInternal { - PROTOBUF_CONSTEXPR PollUpdateDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~PollUpdateDefaultTypeInternal() {} - union { - PollUpdate _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PollUpdateDefaultTypeInternal _PollUpdate_default_instance_; -PROTOBUF_CONSTEXPR PreKeyRecordStructure::PreKeyRecordStructure( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.publickey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.privatekey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.id_)*/0u} {} -struct PreKeyRecordStructureDefaultTypeInternal { - PROTOBUF_CONSTEXPR PreKeyRecordStructureDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~PreKeyRecordStructureDefaultTypeInternal() {} - union { - PreKeyRecordStructure _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PreKeyRecordStructureDefaultTypeInternal _PreKeyRecordStructure_default_instance_; -PROTOBUF_CONSTEXPR Pushname::Pushname( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.pushname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct PushnameDefaultTypeInternal { - PROTOBUF_CONSTEXPR PushnameDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~PushnameDefaultTypeInternal() {} - union { - Pushname _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PushnameDefaultTypeInternal _Pushname_default_instance_; -PROTOBUF_CONSTEXPR Reaction::Reaction( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.text_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.groupingkey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.key_)*/nullptr - , /*decltype(_impl_.sendertimestampms_)*/int64_t{0} - , /*decltype(_impl_.unread_)*/false} {} -struct ReactionDefaultTypeInternal { - PROTOBUF_CONSTEXPR ReactionDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~ReactionDefaultTypeInternal() {} - union { - Reaction _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ReactionDefaultTypeInternal _Reaction_default_instance_; -PROTOBUF_CONSTEXPR RecentEmojiWeight::RecentEmojiWeight( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.emoji_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.weight_)*/0} {} -struct RecentEmojiWeightDefaultTypeInternal { - PROTOBUF_CONSTEXPR RecentEmojiWeightDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~RecentEmojiWeightDefaultTypeInternal() {} - union { - RecentEmojiWeight _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RecentEmojiWeightDefaultTypeInternal _RecentEmojiWeight_default_instance_; -PROTOBUF_CONSTEXPR RecordStructure::RecordStructure( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.previoussessions_)*/{} - , /*decltype(_impl_.currentsession_)*/nullptr} {} -struct RecordStructureDefaultTypeInternal { - PROTOBUF_CONSTEXPR RecordStructureDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~RecordStructureDefaultTypeInternal() {} - union { - RecordStructure _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RecordStructureDefaultTypeInternal _RecordStructure_default_instance_; -PROTOBUF_CONSTEXPR SenderChainKey::SenderChainKey( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.seed_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.iteration_)*/0u} {} -struct SenderChainKeyDefaultTypeInternal { - PROTOBUF_CONSTEXPR SenderChainKeyDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SenderChainKeyDefaultTypeInternal() {} - union { - SenderChainKey _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SenderChainKeyDefaultTypeInternal _SenderChainKey_default_instance_; -PROTOBUF_CONSTEXPR SenderKeyRecordStructure::SenderKeyRecordStructure( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_.senderkeystates_)*/{} - , /*decltype(_impl_._cached_size_)*/{}} {} -struct SenderKeyRecordStructureDefaultTypeInternal { - PROTOBUF_CONSTEXPR SenderKeyRecordStructureDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SenderKeyRecordStructureDefaultTypeInternal() {} - union { - SenderKeyRecordStructure _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SenderKeyRecordStructureDefaultTypeInternal _SenderKeyRecordStructure_default_instance_; -PROTOBUF_CONSTEXPR SenderKeyStateStructure::SenderKeyStateStructure( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.sendermessagekeys_)*/{} - , /*decltype(_impl_.senderchainkey_)*/nullptr - , /*decltype(_impl_.sendersigningkey_)*/nullptr - , /*decltype(_impl_.senderkeyid_)*/0u} {} -struct SenderKeyStateStructureDefaultTypeInternal { - PROTOBUF_CONSTEXPR SenderKeyStateStructureDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SenderKeyStateStructureDefaultTypeInternal() {} - union { - SenderKeyStateStructure _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SenderKeyStateStructureDefaultTypeInternal _SenderKeyStateStructure_default_instance_; -PROTOBUF_CONSTEXPR SenderMessageKey::SenderMessageKey( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.seed_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.iteration_)*/0u} {} -struct SenderMessageKeyDefaultTypeInternal { - PROTOBUF_CONSTEXPR SenderMessageKeyDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SenderMessageKeyDefaultTypeInternal() {} - union { - SenderMessageKey _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SenderMessageKeyDefaultTypeInternal _SenderMessageKey_default_instance_; -PROTOBUF_CONSTEXPR SenderSigningKey::SenderSigningKey( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.public__)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.private__)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct SenderSigningKeyDefaultTypeInternal { - PROTOBUF_CONSTEXPR SenderSigningKeyDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SenderSigningKeyDefaultTypeInternal() {} - union { - SenderSigningKey _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SenderSigningKeyDefaultTypeInternal _SenderSigningKey_default_instance_; -PROTOBUF_CONSTEXPR ServerErrorReceipt::ServerErrorReceipt( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.stanzaid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct ServerErrorReceiptDefaultTypeInternal { - PROTOBUF_CONSTEXPR ServerErrorReceiptDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~ServerErrorReceiptDefaultTypeInternal() {} - union { - ServerErrorReceipt _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ServerErrorReceiptDefaultTypeInternal _ServerErrorReceipt_default_instance_; -PROTOBUF_CONSTEXPR SessionStructure::SessionStructure( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.receiverchains_)*/{} - , /*decltype(_impl_.localidentitypublic_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.remoteidentitypublic_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.rootkey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.alicebasekey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.senderchain_)*/nullptr - , /*decltype(_impl_.pendingkeyexchange_)*/nullptr - , /*decltype(_impl_.pendingprekey_)*/nullptr - , /*decltype(_impl_.sessionversion_)*/0u - , /*decltype(_impl_.previouscounter_)*/0u - , /*decltype(_impl_.remoteregistrationid_)*/0u - , /*decltype(_impl_.localregistrationid_)*/0u - , /*decltype(_impl_.needsrefresh_)*/false} {} -struct SessionStructureDefaultTypeInternal { - PROTOBUF_CONSTEXPR SessionStructureDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SessionStructureDefaultTypeInternal() {} - union { - SessionStructure _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SessionStructureDefaultTypeInternal _SessionStructure_default_instance_; -PROTOBUF_CONSTEXPR SignedPreKeyRecordStructure::SignedPreKeyRecordStructure( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.publickey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.privatekey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.signature_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.timestamp_)*/uint64_t{0u} - , /*decltype(_impl_.id_)*/0u} {} -struct SignedPreKeyRecordStructureDefaultTypeInternal { - PROTOBUF_CONSTEXPR SignedPreKeyRecordStructureDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SignedPreKeyRecordStructureDefaultTypeInternal() {} - union { - SignedPreKeyRecordStructure _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SignedPreKeyRecordStructureDefaultTypeInternal _SignedPreKeyRecordStructure_default_instance_; -PROTOBUF_CONSTEXPR StatusPSA::StatusPSA( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.campaignid_)*/uint64_t{0u} - , /*decltype(_impl_.campaignexpirationtimestamp_)*/uint64_t{0u}} {} -struct StatusPSADefaultTypeInternal { - PROTOBUF_CONSTEXPR StatusPSADefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~StatusPSADefaultTypeInternal() {} - union { - StatusPSA _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StatusPSADefaultTypeInternal _StatusPSA_default_instance_; -PROTOBUF_CONSTEXPR StickerMetadata::StickerMetadata( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.filesha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.fileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.mimetype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.height_)*/0u - , /*decltype(_impl_.width_)*/0u - , /*decltype(_impl_.filelength_)*/uint64_t{0u} - , /*decltype(_impl_.weight_)*/0} {} -struct StickerMetadataDefaultTypeInternal { - PROTOBUF_CONSTEXPR StickerMetadataDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~StickerMetadataDefaultTypeInternal() {} - union { - StickerMetadata _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StickerMetadataDefaultTypeInternal _StickerMetadata_default_instance_; -PROTOBUF_CONSTEXPR SyncActionData::SyncActionData( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.index_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.padding_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.value_)*/nullptr - , /*decltype(_impl_.version_)*/0} {} -struct SyncActionDataDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncActionDataDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncActionDataDefaultTypeInternal() {} - union { - SyncActionData _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionDataDefaultTypeInternal _SyncActionData_default_instance_; -PROTOBUF_CONSTEXPR SyncActionValue_AgentAction::SyncActionValue_AgentAction( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.deviceid_)*/0 - , /*decltype(_impl_.isdeleted_)*/false} {} -struct SyncActionValue_AgentActionDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncActionValue_AgentActionDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncActionValue_AgentActionDefaultTypeInternal() {} - union { - SyncActionValue_AgentAction _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_AgentActionDefaultTypeInternal _SyncActionValue_AgentAction_default_instance_; -PROTOBUF_CONSTEXPR SyncActionValue_AndroidUnsupportedActions::SyncActionValue_AndroidUnsupportedActions( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.allowed_)*/false} {} -struct SyncActionValue_AndroidUnsupportedActionsDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncActionValue_AndroidUnsupportedActionsDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncActionValue_AndroidUnsupportedActionsDefaultTypeInternal() {} - union { - SyncActionValue_AndroidUnsupportedActions _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_AndroidUnsupportedActionsDefaultTypeInternal _SyncActionValue_AndroidUnsupportedActions_default_instance_; -PROTOBUF_CONSTEXPR SyncActionValue_ArchiveChatAction::SyncActionValue_ArchiveChatAction( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.messagerange_)*/nullptr - , /*decltype(_impl_.archived_)*/false} {} -struct SyncActionValue_ArchiveChatActionDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncActionValue_ArchiveChatActionDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncActionValue_ArchiveChatActionDefaultTypeInternal() {} - union { - SyncActionValue_ArchiveChatAction _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_ArchiveChatActionDefaultTypeInternal _SyncActionValue_ArchiveChatAction_default_instance_; -PROTOBUF_CONSTEXPR SyncActionValue_ClearChatAction::SyncActionValue_ClearChatAction( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.messagerange_)*/nullptr} {} -struct SyncActionValue_ClearChatActionDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncActionValue_ClearChatActionDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncActionValue_ClearChatActionDefaultTypeInternal() {} - union { - SyncActionValue_ClearChatAction _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_ClearChatActionDefaultTypeInternal _SyncActionValue_ClearChatAction_default_instance_; -PROTOBUF_CONSTEXPR SyncActionValue_ContactAction::SyncActionValue_ContactAction( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.fullname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.firstname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct SyncActionValue_ContactActionDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncActionValue_ContactActionDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncActionValue_ContactActionDefaultTypeInternal() {} - union { - SyncActionValue_ContactAction _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_ContactActionDefaultTypeInternal _SyncActionValue_ContactAction_default_instance_; -PROTOBUF_CONSTEXPR SyncActionValue_DeleteChatAction::SyncActionValue_DeleteChatAction( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.messagerange_)*/nullptr} {} -struct SyncActionValue_DeleteChatActionDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncActionValue_DeleteChatActionDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncActionValue_DeleteChatActionDefaultTypeInternal() {} - union { - SyncActionValue_DeleteChatAction _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_DeleteChatActionDefaultTypeInternal _SyncActionValue_DeleteChatAction_default_instance_; -PROTOBUF_CONSTEXPR SyncActionValue_DeleteMessageForMeAction::SyncActionValue_DeleteMessageForMeAction( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.messagetimestamp_)*/int64_t{0} - , /*decltype(_impl_.deletemedia_)*/false} {} -struct SyncActionValue_DeleteMessageForMeActionDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncActionValue_DeleteMessageForMeActionDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncActionValue_DeleteMessageForMeActionDefaultTypeInternal() {} - union { - SyncActionValue_DeleteMessageForMeAction _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_DeleteMessageForMeActionDefaultTypeInternal _SyncActionValue_DeleteMessageForMeAction_default_instance_; -PROTOBUF_CONSTEXPR SyncActionValue_KeyExpiration::SyncActionValue_KeyExpiration( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.expiredkeyepoch_)*/0} {} -struct SyncActionValue_KeyExpirationDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncActionValue_KeyExpirationDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncActionValue_KeyExpirationDefaultTypeInternal() {} - union { - SyncActionValue_KeyExpiration _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_KeyExpirationDefaultTypeInternal _SyncActionValue_KeyExpiration_default_instance_; -PROTOBUF_CONSTEXPR SyncActionValue_LabelAssociationAction::SyncActionValue_LabelAssociationAction( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.labeled_)*/false} {} -struct SyncActionValue_LabelAssociationActionDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncActionValue_LabelAssociationActionDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncActionValue_LabelAssociationActionDefaultTypeInternal() {} - union { - SyncActionValue_LabelAssociationAction _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_LabelAssociationActionDefaultTypeInternal _SyncActionValue_LabelAssociationAction_default_instance_; -PROTOBUF_CONSTEXPR SyncActionValue_LabelEditAction::SyncActionValue_LabelEditAction( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.color_)*/0 - , /*decltype(_impl_.predefinedid_)*/0 - , /*decltype(_impl_.deleted_)*/false} {} -struct SyncActionValue_LabelEditActionDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncActionValue_LabelEditActionDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncActionValue_LabelEditActionDefaultTypeInternal() {} - union { - SyncActionValue_LabelEditAction _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_LabelEditActionDefaultTypeInternal _SyncActionValue_LabelEditAction_default_instance_; -PROTOBUF_CONSTEXPR SyncActionValue_LocaleSetting::SyncActionValue_LocaleSetting( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.locale_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct SyncActionValue_LocaleSettingDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncActionValue_LocaleSettingDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncActionValue_LocaleSettingDefaultTypeInternal() {} - union { - SyncActionValue_LocaleSetting _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_LocaleSettingDefaultTypeInternal _SyncActionValue_LocaleSetting_default_instance_; -PROTOBUF_CONSTEXPR SyncActionValue_MarkChatAsReadAction::SyncActionValue_MarkChatAsReadAction( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.messagerange_)*/nullptr - , /*decltype(_impl_.read_)*/false} {} -struct SyncActionValue_MarkChatAsReadActionDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncActionValue_MarkChatAsReadActionDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncActionValue_MarkChatAsReadActionDefaultTypeInternal() {} - union { - SyncActionValue_MarkChatAsReadAction _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_MarkChatAsReadActionDefaultTypeInternal _SyncActionValue_MarkChatAsReadAction_default_instance_; -PROTOBUF_CONSTEXPR SyncActionValue_MuteAction::SyncActionValue_MuteAction( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.muteendtimestamp_)*/int64_t{0} - , /*decltype(_impl_.muted_)*/false} {} -struct SyncActionValue_MuteActionDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncActionValue_MuteActionDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncActionValue_MuteActionDefaultTypeInternal() {} - union { - SyncActionValue_MuteAction _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_MuteActionDefaultTypeInternal _SyncActionValue_MuteAction_default_instance_; -PROTOBUF_CONSTEXPR SyncActionValue_NuxAction::SyncActionValue_NuxAction( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.acknowledged_)*/false} {} -struct SyncActionValue_NuxActionDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncActionValue_NuxActionDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncActionValue_NuxActionDefaultTypeInternal() {} - union { - SyncActionValue_NuxAction _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_NuxActionDefaultTypeInternal _SyncActionValue_NuxAction_default_instance_; -PROTOBUF_CONSTEXPR SyncActionValue_PinAction::SyncActionValue_PinAction( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.pinned_)*/false} {} -struct SyncActionValue_PinActionDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncActionValue_PinActionDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncActionValue_PinActionDefaultTypeInternal() {} - union { - SyncActionValue_PinAction _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_PinActionDefaultTypeInternal _SyncActionValue_PinAction_default_instance_; -PROTOBUF_CONSTEXPR SyncActionValue_PrimaryFeature::SyncActionValue_PrimaryFeature( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_.flags_)*/{} - , /*decltype(_impl_._cached_size_)*/{}} {} -struct SyncActionValue_PrimaryFeatureDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncActionValue_PrimaryFeatureDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncActionValue_PrimaryFeatureDefaultTypeInternal() {} - union { - SyncActionValue_PrimaryFeature _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_PrimaryFeatureDefaultTypeInternal _SyncActionValue_PrimaryFeature_default_instance_; -PROTOBUF_CONSTEXPR SyncActionValue_PrimaryVersionAction::SyncActionValue_PrimaryVersionAction( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.version_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct SyncActionValue_PrimaryVersionActionDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncActionValue_PrimaryVersionActionDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncActionValue_PrimaryVersionActionDefaultTypeInternal() {} - union { - SyncActionValue_PrimaryVersionAction _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_PrimaryVersionActionDefaultTypeInternal _SyncActionValue_PrimaryVersionAction_default_instance_; -PROTOBUF_CONSTEXPR SyncActionValue_PushNameSetting::SyncActionValue_PushNameSetting( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct SyncActionValue_PushNameSettingDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncActionValue_PushNameSettingDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncActionValue_PushNameSettingDefaultTypeInternal() {} - union { - SyncActionValue_PushNameSetting _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_PushNameSettingDefaultTypeInternal _SyncActionValue_PushNameSetting_default_instance_; -PROTOBUF_CONSTEXPR SyncActionValue_QuickReplyAction::SyncActionValue_QuickReplyAction( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.keywords_)*/{} - , /*decltype(_impl_.shortcut_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.message_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.count_)*/0 - , /*decltype(_impl_.deleted_)*/false} {} -struct SyncActionValue_QuickReplyActionDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncActionValue_QuickReplyActionDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncActionValue_QuickReplyActionDefaultTypeInternal() {} - union { - SyncActionValue_QuickReplyAction _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_QuickReplyActionDefaultTypeInternal _SyncActionValue_QuickReplyAction_default_instance_; -PROTOBUF_CONSTEXPR SyncActionValue_RecentEmojiWeightsAction::SyncActionValue_RecentEmojiWeightsAction( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_.weights_)*/{} - , /*decltype(_impl_._cached_size_)*/{}} {} -struct SyncActionValue_RecentEmojiWeightsActionDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncActionValue_RecentEmojiWeightsActionDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncActionValue_RecentEmojiWeightsActionDefaultTypeInternal() {} - union { - SyncActionValue_RecentEmojiWeightsAction _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_RecentEmojiWeightsActionDefaultTypeInternal _SyncActionValue_RecentEmojiWeightsAction_default_instance_; -PROTOBUF_CONSTEXPR SyncActionValue_SecurityNotificationSetting::SyncActionValue_SecurityNotificationSetting( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.shownotification_)*/false} {} -struct SyncActionValue_SecurityNotificationSettingDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncActionValue_SecurityNotificationSettingDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncActionValue_SecurityNotificationSettingDefaultTypeInternal() {} - union { - SyncActionValue_SecurityNotificationSetting _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_SecurityNotificationSettingDefaultTypeInternal _SyncActionValue_SecurityNotificationSetting_default_instance_; -PROTOBUF_CONSTEXPR SyncActionValue_StarAction::SyncActionValue_StarAction( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.starred_)*/false} {} -struct SyncActionValue_StarActionDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncActionValue_StarActionDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncActionValue_StarActionDefaultTypeInternal() {} - union { - SyncActionValue_StarAction _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_StarActionDefaultTypeInternal _SyncActionValue_StarAction_default_instance_; -PROTOBUF_CONSTEXPR SyncActionValue_StickerAction::SyncActionValue_StickerAction( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.fileencsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.mediakey_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.mimetype_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.directpath_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.height_)*/0u - , /*decltype(_impl_.width_)*/0u - , /*decltype(_impl_.filelength_)*/uint64_t{0u} - , /*decltype(_impl_.isfavorite_)*/false - , /*decltype(_impl_.deviceidhint_)*/0u} {} -struct SyncActionValue_StickerActionDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncActionValue_StickerActionDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncActionValue_StickerActionDefaultTypeInternal() {} - union { - SyncActionValue_StickerAction _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_StickerActionDefaultTypeInternal _SyncActionValue_StickerAction_default_instance_; -PROTOBUF_CONSTEXPR SyncActionValue_SubscriptionAction::SyncActionValue_SubscriptionAction( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.expirationdate_)*/int64_t{0} - , /*decltype(_impl_.isdeactivated_)*/false - , /*decltype(_impl_.isautorenewing_)*/false} {} -struct SyncActionValue_SubscriptionActionDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncActionValue_SubscriptionActionDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncActionValue_SubscriptionActionDefaultTypeInternal() {} - union { - SyncActionValue_SubscriptionAction _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_SubscriptionActionDefaultTypeInternal _SyncActionValue_SubscriptionAction_default_instance_; -PROTOBUF_CONSTEXPR SyncActionValue_SyncActionMessageRange::SyncActionValue_SyncActionMessageRange( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.messages_)*/{} - , /*decltype(_impl_.lastmessagetimestamp_)*/int64_t{0} - , /*decltype(_impl_.lastsystemmessagetimestamp_)*/int64_t{0}} {} -struct SyncActionValue_SyncActionMessageRangeDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncActionValue_SyncActionMessageRangeDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncActionValue_SyncActionMessageRangeDefaultTypeInternal() {} - union { - SyncActionValue_SyncActionMessageRange _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_SyncActionMessageRangeDefaultTypeInternal _SyncActionValue_SyncActionMessageRange_default_instance_; -PROTOBUF_CONSTEXPR SyncActionValue_SyncActionMessage::SyncActionValue_SyncActionMessage( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.key_)*/nullptr - , /*decltype(_impl_.timestamp_)*/int64_t{0}} {} -struct SyncActionValue_SyncActionMessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncActionValue_SyncActionMessageDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncActionValue_SyncActionMessageDefaultTypeInternal() {} - union { - SyncActionValue_SyncActionMessage _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_SyncActionMessageDefaultTypeInternal _SyncActionValue_SyncActionMessage_default_instance_; -PROTOBUF_CONSTEXPR SyncActionValue_TimeFormatAction::SyncActionValue_TimeFormatAction( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.istwentyfourhourformatenabled_)*/false} {} -struct SyncActionValue_TimeFormatActionDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncActionValue_TimeFormatActionDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncActionValue_TimeFormatActionDefaultTypeInternal() {} - union { - SyncActionValue_TimeFormatAction _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_TimeFormatActionDefaultTypeInternal _SyncActionValue_TimeFormatAction_default_instance_; -PROTOBUF_CONSTEXPR SyncActionValue_UnarchiveChatsSetting::SyncActionValue_UnarchiveChatsSetting( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.unarchivechats_)*/false} {} -struct SyncActionValue_UnarchiveChatsSettingDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncActionValue_UnarchiveChatsSettingDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncActionValue_UnarchiveChatsSettingDefaultTypeInternal() {} - union { - SyncActionValue_UnarchiveChatsSetting _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_UnarchiveChatsSettingDefaultTypeInternal _SyncActionValue_UnarchiveChatsSetting_default_instance_; -PROTOBUF_CONSTEXPR SyncActionValue_UserStatusMuteAction::SyncActionValue_UserStatusMuteAction( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.muted_)*/false} {} -struct SyncActionValue_UserStatusMuteActionDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncActionValue_UserStatusMuteActionDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncActionValue_UserStatusMuteActionDefaultTypeInternal() {} - union { - SyncActionValue_UserStatusMuteAction _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValue_UserStatusMuteActionDefaultTypeInternal _SyncActionValue_UserStatusMuteAction_default_instance_; -PROTOBUF_CONSTEXPR SyncActionValue::SyncActionValue( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.staraction_)*/nullptr - , /*decltype(_impl_.contactaction_)*/nullptr - , /*decltype(_impl_.muteaction_)*/nullptr - , /*decltype(_impl_.pinaction_)*/nullptr - , /*decltype(_impl_.securitynotificationsetting_)*/nullptr - , /*decltype(_impl_.pushnamesetting_)*/nullptr - , /*decltype(_impl_.quickreplyaction_)*/nullptr - , /*decltype(_impl_.recentemojiweightsaction_)*/nullptr - , /*decltype(_impl_.labeleditaction_)*/nullptr - , /*decltype(_impl_.labelassociationaction_)*/nullptr - , /*decltype(_impl_.localesetting_)*/nullptr - , /*decltype(_impl_.archivechataction_)*/nullptr - , /*decltype(_impl_.deletemessageformeaction_)*/nullptr - , /*decltype(_impl_.keyexpiration_)*/nullptr - , /*decltype(_impl_.markchatasreadaction_)*/nullptr - , /*decltype(_impl_.clearchataction_)*/nullptr - , /*decltype(_impl_.deletechataction_)*/nullptr - , /*decltype(_impl_.unarchivechatssetting_)*/nullptr - , /*decltype(_impl_.primaryfeature_)*/nullptr - , /*decltype(_impl_.androidunsupportedactions_)*/nullptr - , /*decltype(_impl_.agentaction_)*/nullptr - , /*decltype(_impl_.subscriptionaction_)*/nullptr - , /*decltype(_impl_.userstatusmuteaction_)*/nullptr - , /*decltype(_impl_.timeformataction_)*/nullptr - , /*decltype(_impl_.nuxaction_)*/nullptr - , /*decltype(_impl_.primaryversionaction_)*/nullptr - , /*decltype(_impl_.stickeraction_)*/nullptr - , /*decltype(_impl_.timestamp_)*/int64_t{0}} {} -struct SyncActionValueDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncActionValueDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncActionValueDefaultTypeInternal() {} - union { - SyncActionValue _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncActionValueDefaultTypeInternal _SyncActionValue_default_instance_; -PROTOBUF_CONSTEXPR SyncdIndex::SyncdIndex( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.blob_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct SyncdIndexDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncdIndexDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncdIndexDefaultTypeInternal() {} - union { - SyncdIndex _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncdIndexDefaultTypeInternal _SyncdIndex_default_instance_; -PROTOBUF_CONSTEXPR SyncdMutation::SyncdMutation( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.record_)*/nullptr - , /*decltype(_impl_.operation_)*/0} {} -struct SyncdMutationDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncdMutationDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncdMutationDefaultTypeInternal() {} - union { - SyncdMutation _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncdMutationDefaultTypeInternal _SyncdMutation_default_instance_; -PROTOBUF_CONSTEXPR SyncdMutations::SyncdMutations( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_.mutations_)*/{} - , /*decltype(_impl_._cached_size_)*/{}} {} -struct SyncdMutationsDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncdMutationsDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncdMutationsDefaultTypeInternal() {} - union { - SyncdMutations _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncdMutationsDefaultTypeInternal _SyncdMutations_default_instance_; -PROTOBUF_CONSTEXPR SyncdPatch::SyncdPatch( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.mutations_)*/{} - , /*decltype(_impl_.snapshotmac_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.patchmac_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.version_)*/nullptr - , /*decltype(_impl_.externalmutations_)*/nullptr - , /*decltype(_impl_.keyid_)*/nullptr - , /*decltype(_impl_.exitcode_)*/nullptr - , /*decltype(_impl_.deviceindex_)*/0u} {} -struct SyncdPatchDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncdPatchDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncdPatchDefaultTypeInternal() {} - union { - SyncdPatch _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncdPatchDefaultTypeInternal _SyncdPatch_default_instance_; -PROTOBUF_CONSTEXPR SyncdRecord::SyncdRecord( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.index_)*/nullptr - , /*decltype(_impl_.value_)*/nullptr - , /*decltype(_impl_.keyid_)*/nullptr} {} -struct SyncdRecordDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncdRecordDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncdRecordDefaultTypeInternal() {} - union { - SyncdRecord _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncdRecordDefaultTypeInternal _SyncdRecord_default_instance_; -PROTOBUF_CONSTEXPR SyncdSnapshot::SyncdSnapshot( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.records_)*/{} - , /*decltype(_impl_.mac_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.version_)*/nullptr - , /*decltype(_impl_.keyid_)*/nullptr} {} -struct SyncdSnapshotDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncdSnapshotDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncdSnapshotDefaultTypeInternal() {} - union { - SyncdSnapshot _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncdSnapshotDefaultTypeInternal _SyncdSnapshot_default_instance_; -PROTOBUF_CONSTEXPR SyncdValue::SyncdValue( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.blob_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct SyncdValueDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncdValueDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncdValueDefaultTypeInternal() {} - union { - SyncdValue _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncdValueDefaultTypeInternal _SyncdValue_default_instance_; -PROTOBUF_CONSTEXPR SyncdVersion::SyncdVersion( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.version_)*/uint64_t{0u}} {} -struct SyncdVersionDefaultTypeInternal { - PROTOBUF_CONSTEXPR SyncdVersionDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~SyncdVersionDefaultTypeInternal() {} - union { - SyncdVersion _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncdVersionDefaultTypeInternal _SyncdVersion_default_instance_; -PROTOBUF_CONSTEXPR TemplateButton_CallButton::TemplateButton_CallButton( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.displaytext_)*/nullptr - , /*decltype(_impl_.phonenumber_)*/nullptr} {} -struct TemplateButton_CallButtonDefaultTypeInternal { - PROTOBUF_CONSTEXPR TemplateButton_CallButtonDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~TemplateButton_CallButtonDefaultTypeInternal() {} - union { - TemplateButton_CallButton _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemplateButton_CallButtonDefaultTypeInternal _TemplateButton_CallButton_default_instance_; -PROTOBUF_CONSTEXPR TemplateButton_QuickReplyButton::TemplateButton_QuickReplyButton( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.displaytext_)*/nullptr} {} -struct TemplateButton_QuickReplyButtonDefaultTypeInternal { - PROTOBUF_CONSTEXPR TemplateButton_QuickReplyButtonDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~TemplateButton_QuickReplyButtonDefaultTypeInternal() {} - union { - TemplateButton_QuickReplyButton _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemplateButton_QuickReplyButtonDefaultTypeInternal _TemplateButton_QuickReplyButton_default_instance_; -PROTOBUF_CONSTEXPR TemplateButton_URLButton::TemplateButton_URLButton( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.displaytext_)*/nullptr - , /*decltype(_impl_.url_)*/nullptr} {} -struct TemplateButton_URLButtonDefaultTypeInternal { - PROTOBUF_CONSTEXPR TemplateButton_URLButtonDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~TemplateButton_URLButtonDefaultTypeInternal() {} - union { - TemplateButton_URLButton _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemplateButton_URLButtonDefaultTypeInternal _TemplateButton_URLButton_default_instance_; -PROTOBUF_CONSTEXPR TemplateButton::TemplateButton( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.index_)*/0u - , /*decltype(_impl_.button_)*/{} - , /*decltype(_impl_._oneof_case_)*/{}} {} -struct TemplateButtonDefaultTypeInternal { - PROTOBUF_CONSTEXPR TemplateButtonDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~TemplateButtonDefaultTypeInternal() {} - union { - TemplateButton _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemplateButtonDefaultTypeInternal _TemplateButton_default_instance_; -PROTOBUF_CONSTEXPR UserReceipt::UserReceipt( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.pendingdevicejid_)*/{} - , /*decltype(_impl_.delivereddevicejid_)*/{} - , /*decltype(_impl_.userjid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.receipttimestamp_)*/int64_t{0} - , /*decltype(_impl_.readtimestamp_)*/int64_t{0} - , /*decltype(_impl_.playedtimestamp_)*/int64_t{0}} {} -struct UserReceiptDefaultTypeInternal { - PROTOBUF_CONSTEXPR UserReceiptDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~UserReceiptDefaultTypeInternal() {} - union { - UserReceipt _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UserReceiptDefaultTypeInternal _UserReceipt_default_instance_; -PROTOBUF_CONSTEXPR VerifiedNameCertificate_Details::VerifiedNameCertificate_Details( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.localizednames_)*/{} - , /*decltype(_impl_.issuer_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.verifiedname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.serial_)*/uint64_t{0u} - , /*decltype(_impl_.issuetime_)*/uint64_t{0u}} {} -struct VerifiedNameCertificate_DetailsDefaultTypeInternal { - PROTOBUF_CONSTEXPR VerifiedNameCertificate_DetailsDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~VerifiedNameCertificate_DetailsDefaultTypeInternal() {} - union { - VerifiedNameCertificate_Details _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 VerifiedNameCertificate_DetailsDefaultTypeInternal _VerifiedNameCertificate_Details_default_instance_; -PROTOBUF_CONSTEXPR VerifiedNameCertificate::VerifiedNameCertificate( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.details_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.signature_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.serversignature_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {} -struct VerifiedNameCertificateDefaultTypeInternal { - PROTOBUF_CONSTEXPR VerifiedNameCertificateDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~VerifiedNameCertificateDefaultTypeInternal() {} - union { - VerifiedNameCertificate _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 VerifiedNameCertificateDefaultTypeInternal _VerifiedNameCertificate_default_instance_; -PROTOBUF_CONSTEXPR WallpaperSettings::WallpaperSettings( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.filename_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.opacity_)*/0u} {} -struct WallpaperSettingsDefaultTypeInternal { - PROTOBUF_CONSTEXPR WallpaperSettingsDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~WallpaperSettingsDefaultTypeInternal() {} - union { - WallpaperSettings _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WallpaperSettingsDefaultTypeInternal _WallpaperSettings_default_instance_; -PROTOBUF_CONSTEXPR WebFeatures::WebFeatures( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.labelsdisplay_)*/0 - , /*decltype(_impl_.voipindividualoutgoing_)*/0 - , /*decltype(_impl_.groupsv3_)*/0 - , /*decltype(_impl_.groupsv3create_)*/0 - , /*decltype(_impl_.changenumberv2_)*/0 - , /*decltype(_impl_.querystatusv3thumbnail_)*/0 - , /*decltype(_impl_.livelocations_)*/0 - , /*decltype(_impl_.queryvname_)*/0 - , /*decltype(_impl_.voipindividualincoming_)*/0 - , /*decltype(_impl_.quickrepliesquery_)*/0 - , /*decltype(_impl_.payments_)*/0 - , /*decltype(_impl_.stickerpackquery_)*/0 - , /*decltype(_impl_.livelocationsfinal_)*/0 - , /*decltype(_impl_.labelsedit_)*/0 - , /*decltype(_impl_.mediaupload_)*/0 - , /*decltype(_impl_.mediauploadrichquickreplies_)*/0 - , /*decltype(_impl_.vnamev2_)*/0 - , /*decltype(_impl_.videoplaybackurl_)*/0 - , /*decltype(_impl_.statusranking_)*/0 - , /*decltype(_impl_.voipindividualvideo_)*/0 - , /*decltype(_impl_.thirdpartystickers_)*/0 - , /*decltype(_impl_.frequentlyforwardedsetting_)*/0 - , /*decltype(_impl_.groupsv4joinpermission_)*/0 - , /*decltype(_impl_.recentstickers_)*/0 - , /*decltype(_impl_.catalog_)*/0 - , /*decltype(_impl_.starredstickers_)*/0 - , /*decltype(_impl_.voipgroupcall_)*/0 - , /*decltype(_impl_.templatemessage_)*/0 - , /*decltype(_impl_.templatemessageinteractivity_)*/0 - , /*decltype(_impl_.ephemeralmessages_)*/0 - , /*decltype(_impl_.e2enotificationsync_)*/0 - , /*decltype(_impl_.recentstickersv2_)*/0 - , /*decltype(_impl_.recentstickersv3_)*/0 - , /*decltype(_impl_.usernotice_)*/0 - , /*decltype(_impl_.support_)*/0 - , /*decltype(_impl_.groupuiicleanup_)*/0 - , /*decltype(_impl_.groupdogfoodinginternalonly_)*/0 - , /*decltype(_impl_.settingssync_)*/0 - , /*decltype(_impl_.archivev2_)*/0 - , /*decltype(_impl_.ephemeralallowgroupmembers_)*/0 - , /*decltype(_impl_.ephemeral24hduration_)*/0 - , /*decltype(_impl_.mdforceupgrade_)*/0 - , /*decltype(_impl_.disappearingmode_)*/0 - , /*decltype(_impl_.externalmdoptinavailable_)*/0 - , /*decltype(_impl_.nodeletemessagetimelimit_)*/0} {} -struct WebFeaturesDefaultTypeInternal { - PROTOBUF_CONSTEXPR WebFeaturesDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~WebFeaturesDefaultTypeInternal() {} - union { - WebFeatures _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WebFeaturesDefaultTypeInternal _WebFeatures_default_instance_; -PROTOBUF_CONSTEXPR WebMessageInfo::WebMessageInfo( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.messagestubparameters_)*/{} - , /*decltype(_impl_.labels_)*/{} - , /*decltype(_impl_.userreceipt_)*/{} - , /*decltype(_impl_.reactions_)*/{} - , /*decltype(_impl_.pollupdates_)*/{} - , /*decltype(_impl_.participant_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.pushname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.mediaciphertextsha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.verifiedbizname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.futureproofdata_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.agentid_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.messagesecret_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.originalselfauthoruserjidstring_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}} - , /*decltype(_impl_.key_)*/nullptr - , /*decltype(_impl_.message_)*/nullptr - , /*decltype(_impl_.paymentinfo_)*/nullptr - , /*decltype(_impl_.finallivelocation_)*/nullptr - , /*decltype(_impl_.quotedpaymentinfo_)*/nullptr - , /*decltype(_impl_.mediadata_)*/nullptr - , /*decltype(_impl_.photochange_)*/nullptr - , /*decltype(_impl_.quotedstickerdata_)*/nullptr - , /*decltype(_impl_.statuspsa_)*/nullptr - , /*decltype(_impl_.polladditionalmetadata_)*/nullptr - , /*decltype(_impl_.keepinchat_)*/nullptr - , /*decltype(_impl_.messagetimestamp_)*/uint64_t{0u} - , /*decltype(_impl_.messagec2stimestamp_)*/uint64_t{0u} - , /*decltype(_impl_.status_)*/0 - , /*decltype(_impl_.ignore_)*/false - , /*decltype(_impl_.starred_)*/false - , /*decltype(_impl_.broadcast_)*/false - , /*decltype(_impl_.multicast_)*/false - , /*decltype(_impl_.messagestubtype_)*/0 - , /*decltype(_impl_.urltext_)*/false - , /*decltype(_impl_.urlnumber_)*/false - , /*decltype(_impl_.clearmedia_)*/false - , /*decltype(_impl_.ephemeralofftoon_)*/false - , /*decltype(_impl_.duration_)*/0u - , /*decltype(_impl_.ephemeralduration_)*/0u - , /*decltype(_impl_.ephemeralstarttimestamp_)*/uint64_t{0u} - , /*decltype(_impl_.bizprivacystatus_)*/0 - , /*decltype(_impl_.ephemeraloutofsync_)*/false - , /*decltype(_impl_.statusalreadyviewed_)*/false - , /*decltype(_impl_.revokemessagetimestamp_)*/uint64_t{0u}} {} -struct WebMessageInfoDefaultTypeInternal { - PROTOBUF_CONSTEXPR WebMessageInfoDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~WebMessageInfoDefaultTypeInternal() {} - union { - WebMessageInfo _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WebMessageInfoDefaultTypeInternal _WebMessageInfo_default_instance_; -PROTOBUF_CONSTEXPR WebNotificationsInfo::WebNotificationsInfo( - ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_._has_bits_)*/{} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_.notifymessages_)*/{} - , /*decltype(_impl_.timestamp_)*/uint64_t{0u} - , /*decltype(_impl_.unreadchats_)*/0u - , /*decltype(_impl_.notifymessagecount_)*/0u} {} -struct WebNotificationsInfoDefaultTypeInternal { - PROTOBUF_CONSTEXPR WebNotificationsInfoDefaultTypeInternal() - : _instance(::_pbi::ConstantInitialized{}) {} - ~WebNotificationsInfoDefaultTypeInternal() {} - union { - WebNotificationsInfo _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WebNotificationsInfoDefaultTypeInternal _WebNotificationsInfo_default_instance_; -} // namespace proto -static ::_pb::Metadata file_level_metadata_pmsg_2eproto[224]; -static const ::_pb::EnumDescriptor* file_level_enum_descriptors_pmsg_2eproto[53]; -static constexpr ::_pb::ServiceDescriptor const** file_level_service_descriptors_pmsg_2eproto = nullptr; - -const uint32_t TableStruct_pmsg_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - PROTOBUF_FIELD_OFFSET(::proto::ADVDeviceIdentity, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::ADVDeviceIdentity, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::ADVDeviceIdentity, _impl_.rawid_), - PROTOBUF_FIELD_OFFSET(::proto::ADVDeviceIdentity, _impl_.timestamp_), - PROTOBUF_FIELD_OFFSET(::proto::ADVDeviceIdentity, _impl_.keyindex_), - 1, - 0, - 2, - PROTOBUF_FIELD_OFFSET(::proto::ADVKeyIndexList, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::ADVKeyIndexList, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::ADVKeyIndexList, _impl_.rawid_), - PROTOBUF_FIELD_OFFSET(::proto::ADVKeyIndexList, _impl_.timestamp_), - PROTOBUF_FIELD_OFFSET(::proto::ADVKeyIndexList, _impl_.currentindex_), - PROTOBUF_FIELD_OFFSET(::proto::ADVKeyIndexList, _impl_.validindexes_), - 1, - 0, - 2, - ~0u, - PROTOBUF_FIELD_OFFSET(::proto::ADVSignedDeviceIdentity, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::ADVSignedDeviceIdentity, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::ADVSignedDeviceIdentity, _impl_.details_), - PROTOBUF_FIELD_OFFSET(::proto::ADVSignedDeviceIdentity, _impl_.accountsignaturekey_), - PROTOBUF_FIELD_OFFSET(::proto::ADVSignedDeviceIdentity, _impl_.accountsignature_), - PROTOBUF_FIELD_OFFSET(::proto::ADVSignedDeviceIdentity, _impl_.devicesignature_), - 0, - 1, - 2, - 3, - PROTOBUF_FIELD_OFFSET(::proto::ADVSignedDeviceIdentityHMAC, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::ADVSignedDeviceIdentityHMAC, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::ADVSignedDeviceIdentityHMAC, _impl_.details_), - PROTOBUF_FIELD_OFFSET(::proto::ADVSignedDeviceIdentityHMAC, _impl_.hmac_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::ADVSignedKeyIndexList, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::ADVSignedKeyIndexList, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::ADVSignedKeyIndexList, _impl_.details_), - PROTOBUF_FIELD_OFFSET(::proto::ADVSignedKeyIndexList, _impl_.accountsignature_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::ActionLink, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::ActionLink, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::ActionLink, _impl_.url_), - PROTOBUF_FIELD_OFFSET(::proto::ActionLink, _impl_.buttontitle_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::AutoDownloadSettings, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::AutoDownloadSettings, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::AutoDownloadSettings, _impl_.downloadimages_), - PROTOBUF_FIELD_OFFSET(::proto::AutoDownloadSettings, _impl_.downloadaudio_), - PROTOBUF_FIELD_OFFSET(::proto::AutoDownloadSettings, _impl_.downloadvideo_), - PROTOBUF_FIELD_OFFSET(::proto::AutoDownloadSettings, _impl_.downloaddocuments_), - 0, - 1, - 2, - 3, - PROTOBUF_FIELD_OFFSET(::proto::BizAccountLinkInfo, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::BizAccountLinkInfo, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::BizAccountLinkInfo, _impl_.whatsappbizacctfbid_), - PROTOBUF_FIELD_OFFSET(::proto::BizAccountLinkInfo, _impl_.whatsappacctnumber_), - PROTOBUF_FIELD_OFFSET(::proto::BizAccountLinkInfo, _impl_.issuetime_), - PROTOBUF_FIELD_OFFSET(::proto::BizAccountLinkInfo, _impl_.hoststorage_), - PROTOBUF_FIELD_OFFSET(::proto::BizAccountLinkInfo, _impl_.accounttype_), - 1, - 0, - 2, - 3, - 4, - PROTOBUF_FIELD_OFFSET(::proto::BizAccountPayload, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::BizAccountPayload, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::BizAccountPayload, _impl_.vnamecert_), - PROTOBUF_FIELD_OFFSET(::proto::BizAccountPayload, _impl_.bizacctlinkinfo_), - 1, - 0, - PROTOBUF_FIELD_OFFSET(::proto::BizIdentityInfo, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::BizIdentityInfo, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::BizIdentityInfo, _impl_.vlevel_), - PROTOBUF_FIELD_OFFSET(::proto::BizIdentityInfo, _impl_.vnamecert_), - PROTOBUF_FIELD_OFFSET(::proto::BizIdentityInfo, _impl_.signed__), - PROTOBUF_FIELD_OFFSET(::proto::BizIdentityInfo, _impl_.revoked_), - PROTOBUF_FIELD_OFFSET(::proto::BizIdentityInfo, _impl_.hoststorage_), - PROTOBUF_FIELD_OFFSET(::proto::BizIdentityInfo, _impl_.actualactors_), - PROTOBUF_FIELD_OFFSET(::proto::BizIdentityInfo, _impl_.privacymodets_), - PROTOBUF_FIELD_OFFSET(::proto::BizIdentityInfo, _impl_.featurecontrols_), - 1, - 0, - 2, - 3, - 4, - 5, - 6, - 7, - PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate_Details, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate_Details, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate_Details, _impl_.serial_), - PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate_Details, _impl_.issuerserial_), - PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate_Details, _impl_.key_), - PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate_Details, _impl_.notbefore_), - PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate_Details, _impl_.notafter_), - 1, - 2, - 0, - 3, - 4, - PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate, _impl_.details_), - PROTOBUF_FIELD_OFFSET(::proto::CertChain_NoiseCertificate, _impl_.signature_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::CertChain, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::CertChain, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::CertChain, _impl_.leaf_), - PROTOBUF_FIELD_OFFSET(::proto::CertChain, _impl_.intermediate_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::Chain, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Chain, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Chain, _impl_.senderratchetkey_), - PROTOBUF_FIELD_OFFSET(::proto::Chain, _impl_.senderratchetkeyprivate_), - PROTOBUF_FIELD_OFFSET(::proto::Chain, _impl_.chainkey_), - PROTOBUF_FIELD_OFFSET(::proto::Chain, _impl_.messagekeys_), - 0, - 1, - 2, - ~0u, - PROTOBUF_FIELD_OFFSET(::proto::ChainKey, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::ChainKey, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::ChainKey, _impl_.index_), - PROTOBUF_FIELD_OFFSET(::proto::ChainKey, _impl_.key_), - 1, - 0, - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DNSSource, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DNSSource, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DNSSource, _impl_.dnsmethod_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DNSSource, _impl_.appcached_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DevicePairingRegistrationData, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DevicePairingRegistrationData, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DevicePairingRegistrationData, _impl_.eregid_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DevicePairingRegistrationData, _impl_.ekeytype_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DevicePairingRegistrationData, _impl_.eident_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DevicePairingRegistrationData, _impl_.eskeyid_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DevicePairingRegistrationData, _impl_.eskeyval_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DevicePairingRegistrationData, _impl_.eskeysig_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DevicePairingRegistrationData, _impl_.buildhash_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_DevicePairingRegistrationData, _impl_.deviceprops_), - 0, - 1, - 2, - 3, - 4, - 5, - 6, - 7, - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent_AppVersion, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent_AppVersion, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent_AppVersion, _impl_.primary_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent_AppVersion, _impl_.secondary_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent_AppVersion, _impl_.tertiary_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent_AppVersion, _impl_.quaternary_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent_AppVersion, _impl_.quinary_), - 0, - 1, - 2, - 3, - 4, - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.platform_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.appversion_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.mcc_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.mnc_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.osversion_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.manufacturer_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.device_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.osbuildnumber_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.phoneid_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.releasechannel_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.localelanguageiso6391_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.localecountryiso31661alpha2_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_UserAgent, _impl_.deviceboard_), - 11, - 10, - 0, - 1, - 2, - 3, - 4, - 5, - 6, - 12, - 7, - 8, - 9, - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.usesparticipantinkey_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.supportsstarredmessages_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.supportsdocumentmessages_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.supportsurlmessages_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.supportsmediaretry_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.supportse2eimage_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.supportse2evideo_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.supportse2eaudio_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.supportse2edocument_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.documenttypes_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo_WebdPayload, _impl_.features_), - 2, - 3, - 4, - 5, - 6, - 7, - 8, - 9, - 10, - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo, _impl_.reftoken_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo, _impl_.version_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo, _impl_.webdpayload_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload_WebInfo, _impl_.websubplatform_), - 0, - 1, - 2, - 3, - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.username_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.passive_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.useragent_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.webinfo_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.pushname_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.sessionid_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.shortconnect_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.connecttype_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.connectreason_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.shards_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.dnssource_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.connectattemptcount_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.device_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.devicepairingdata_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.product_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.fbcat_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.fbuseragent_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.oc_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.lc_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.iosappextension_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.fbappid_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.fbdeviceid_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.pull_), - PROTOBUF_FIELD_OFFSET(::proto::ClientPayload, _impl_.paddingbytes_), - 9, - 14, - 5, - 6, - 0, - 10, - 15, - 11, - 12, - ~0u, - 7, - 13, - 18, - 8, - 19, - 1, - 2, - 16, - 20, - 22, - 21, - 3, - 17, - 4, - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_AdReplyInfo, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_AdReplyInfo, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_AdReplyInfo, _impl_.advertisername_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_AdReplyInfo, _impl_.mediatype_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_AdReplyInfo, _impl_.jpegthumbnail_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_AdReplyInfo, _impl_.caption_), - 0, - 3, - 1, - 2, - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.title_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.body_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.mediatype_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.thumbnailurl_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.mediaurl_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.thumbnail_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.sourcetype_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.sourceid_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.sourceurl_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.containsautoreply_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.renderlargerthumbnail_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo_ExternalAdReplyInfo, _impl_.showadattribution_), - 0, - 1, - 8, - 2, - 3, - 4, - 5, - 6, - 7, - 9, - 10, - 11, - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.stanzaid_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.participant_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.quotedmessage_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.remotejid_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.mentionedjid_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.conversionsource_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.conversiondata_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.conversiondelayseconds_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.forwardingscore_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.isforwarded_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.quotedad_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.placeholderkey_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.expiration_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.ephemeralsettingtimestamp_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.ephemeralsharedsecret_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.externaladreply_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.entrypointconversionsource_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.entrypointconversionapp_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.entrypointconversiondelayseconds_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.disappearingmode_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.actionlink_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.groupsubject_), - PROTOBUF_FIELD_OFFSET(::proto::ContextInfo, _impl_.parentgroupjid_), - 0, - 1, - 10, - 2, - ~0u, - 3, - 4, - 16, - 17, - 18, - 11, - 12, - 19, - 20, - 5, - 13, - 6, - 7, - 21, - 14, - 15, - 8, - 9, - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.id_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.messages_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.newjid_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.oldjid_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.lastmsgtimestamp_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.unreadcount_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.readonly_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.endofhistorytransfer_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.ephemeralexpiration_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.ephemeralsettingtimestamp_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.endofhistorytransfertype_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.conversationtimestamp_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.name_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.phash_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.notspam_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.archived_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.disappearingmode_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.unreadmentioncount_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.markedasunread_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.participant_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.tctoken_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.tctokentimestamp_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.contactprimaryidentitykey_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.pinned_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.muteendtime_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.wallpaper_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.mediavisibility_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.tctokensendertimestamp_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.suspended_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.terminated_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.createdat_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.createdby_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.description_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.support_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.isparentgroup_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.isdefaultsubgroup_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.parentgroupid_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.displayname_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.pnjid_), - PROTOBUF_FIELD_OFFSET(::proto::Conversation, _impl_.selfpnexposed_), - 0, - ~0u, - 1, - 2, - 14, - 15, - 19, - 20, - 16, - 17, - 18, - 23, - 3, - 4, - 21, - 22, - 12, - 24, - 29, - ~0u, - 5, - 26, - 6, - 25, - 27, - 13, - 28, - 33, - 30, - 31, - 34, - 7, - 8, - 32, - 35, - 36, - 9, - 10, - 11, - 37, - PROTOBUF_FIELD_OFFSET(::proto::DeviceListMetadata, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::DeviceListMetadata, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::DeviceListMetadata, _impl_.senderkeyhash_), - PROTOBUF_FIELD_OFFSET(::proto::DeviceListMetadata, _impl_.sendertimestamp_), - PROTOBUF_FIELD_OFFSET(::proto::DeviceListMetadata, _impl_.senderkeyindexes_), - PROTOBUF_FIELD_OFFSET(::proto::DeviceListMetadata, _impl_.recipientkeyhash_), - PROTOBUF_FIELD_OFFSET(::proto::DeviceListMetadata, _impl_.recipienttimestamp_), - PROTOBUF_FIELD_OFFSET(::proto::DeviceListMetadata, _impl_.recipientkeyindexes_), - 0, - 2, - ~0u, - 1, - 3, - ~0u, - PROTOBUF_FIELD_OFFSET(::proto::DeviceProps_AppVersion, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::DeviceProps_AppVersion, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::DeviceProps_AppVersion, _impl_.primary_), - PROTOBUF_FIELD_OFFSET(::proto::DeviceProps_AppVersion, _impl_.secondary_), - PROTOBUF_FIELD_OFFSET(::proto::DeviceProps_AppVersion, _impl_.tertiary_), - PROTOBUF_FIELD_OFFSET(::proto::DeviceProps_AppVersion, _impl_.quaternary_), - PROTOBUF_FIELD_OFFSET(::proto::DeviceProps_AppVersion, _impl_.quinary_), - 0, - 1, - 2, - 3, - 4, - PROTOBUF_FIELD_OFFSET(::proto::DeviceProps, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::DeviceProps, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::DeviceProps, _impl_.os_), - PROTOBUF_FIELD_OFFSET(::proto::DeviceProps, _impl_.version_), - PROTOBUF_FIELD_OFFSET(::proto::DeviceProps, _impl_.platformtype_), - PROTOBUF_FIELD_OFFSET(::proto::DeviceProps, _impl_.requirefullsync_), - 0, - 1, - 2, - 3, - PROTOBUF_FIELD_OFFSET(::proto::DisappearingMode, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::DisappearingMode, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::DisappearingMode, _impl_.initiator_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::EphemeralSetting, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::EphemeralSetting, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::EphemeralSetting, _impl_.duration_), - PROTOBUF_FIELD_OFFSET(::proto::EphemeralSetting, _impl_.timestamp_), - 1, - 0, - PROTOBUF_FIELD_OFFSET(::proto::ExitCode, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::ExitCode, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::ExitCode, _impl_.code_), - PROTOBUF_FIELD_OFFSET(::proto::ExitCode, _impl_.text_), - 1, - 0, - PROTOBUF_FIELD_OFFSET(::proto::ExternalBlobReference, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::ExternalBlobReference, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::ExternalBlobReference, _impl_.mediakey_), - PROTOBUF_FIELD_OFFSET(::proto::ExternalBlobReference, _impl_.directpath_), - PROTOBUF_FIELD_OFFSET(::proto::ExternalBlobReference, _impl_.handle_), - PROTOBUF_FIELD_OFFSET(::proto::ExternalBlobReference, _impl_.filesizebytes_), - PROTOBUF_FIELD_OFFSET(::proto::ExternalBlobReference, _impl_.filesha256_), - PROTOBUF_FIELD_OFFSET(::proto::ExternalBlobReference, _impl_.fileencsha256_), - 0, - 1, - 2, - 5, - 3, - 4, - PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_.lightthemewallpaper_), - PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_.mediavisibility_), - PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_.darkthemewallpaper_), - PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_.autodownloadwifi_), - PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_.autodownloadcellular_), - PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_.autodownloadroaming_), - PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_.showindividualnotificationspreview_), - PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_.showgroupnotificationspreview_), - PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_.disappearingmodeduration_), - PROTOBUF_FIELD_OFFSET(::proto::GlobalSettings, _impl_.disappearingmodetimestamp_), - 0, - 5, - 1, - 2, - 3, - 4, - 6, - 7, - 9, - 8, - PROTOBUF_FIELD_OFFSET(::proto::GroupParticipant, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::GroupParticipant, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::GroupParticipant, _impl_.userjid_), - PROTOBUF_FIELD_OFFSET(::proto::GroupParticipant, _impl_.rank_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ClientFinish, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ClientFinish, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ClientFinish, _impl_.static__), - PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ClientFinish, _impl_.payload_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ClientHello, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ClientHello, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ClientHello, _impl_.ephemeral_), - PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ClientHello, _impl_.static__), - PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ClientHello, _impl_.payload_), - 0, - 1, - 2, - PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ServerHello, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ServerHello, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ServerHello, _impl_.ephemeral_), - PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ServerHello, _impl_.static__), - PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage_ServerHello, _impl_.payload_), - 0, - 1, - 2, - PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage, _impl_.clienthello_), - PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage, _impl_.serverhello_), - PROTOBUF_FIELD_OFFSET(::proto::HandshakeMessage, _impl_.clientfinish_), - 0, - 1, - 2, - PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.synctype_), - PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.conversations_), - PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.statusv3messages_), - PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.chunkorder_), - PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.progress_), - PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.pushnames_), - PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.globalsettings_), - PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.threadidusersecret_), - PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.threaddstimeframeoffset_), - PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.recentstickers_), - PROTOBUF_FIELD_OFFSET(::proto::HistorySync, _impl_.pastparticipants_), - 2, - ~0u, - ~0u, - 3, - 4, - ~0u, - 1, - 0, - 5, - ~0u, - ~0u, - PROTOBUF_FIELD_OFFSET(::proto::HistorySyncMsg, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::HistorySyncMsg, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::HistorySyncMsg, _impl_.message_), - PROTOBUF_FIELD_OFFSET(::proto::HistorySyncMsg, _impl_.msgorderid_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedCallButton, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedCallButton, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedCallButton, _impl_.displaytext_), - PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedCallButton, _impl_.phonenumber_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedQuickReplyButton, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedQuickReplyButton, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedQuickReplyButton, _impl_.displaytext_), - PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedQuickReplyButton, _impl_.id_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedURLButton, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedURLButton, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedURLButton, _impl_.displaytext_), - PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton_HydratedURLButton, _impl_.url_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton, _impl_._oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton, _impl_.index_), - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::proto::HydratedTemplateButton, _impl_.hydratedButton_), - 0, - ~0u, - ~0u, - ~0u, - PROTOBUF_FIELD_OFFSET(::proto::IdentityKeyPairStructure, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::IdentityKeyPairStructure, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::IdentityKeyPairStructure, _impl_.publickey_), - PROTOBUF_FIELD_OFFSET(::proto::IdentityKeyPairStructure, _impl_.privatekey_), - 0, - 1, - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::proto::InteractiveAnnotation, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::proto::InteractiveAnnotation, _impl_._oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::InteractiveAnnotation, _impl_.polygonvertices_), - ::_pbi::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::proto::InteractiveAnnotation, _impl_.action_), - PROTOBUF_FIELD_OFFSET(::proto::KeepInChat, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::KeepInChat, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::KeepInChat, _impl_.keeptype_), - PROTOBUF_FIELD_OFFSET(::proto::KeepInChat, _impl_.servertimestamp_), - PROTOBUF_FIELD_OFFSET(::proto::KeepInChat, _impl_.key_), - PROTOBUF_FIELD_OFFSET(::proto::KeepInChat, _impl_.devicejid_), - 3, - 2, - 1, - 0, - PROTOBUF_FIELD_OFFSET(::proto::KeyId, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::KeyId, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::KeyId, _impl_.id_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::LocalizedName, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::LocalizedName, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::LocalizedName, _impl_.lg_), - PROTOBUF_FIELD_OFFSET(::proto::LocalizedName, _impl_.lc_), - PROTOBUF_FIELD_OFFSET(::proto::LocalizedName, _impl_.verifiedname_), - 0, - 1, - 2, - PROTOBUF_FIELD_OFFSET(::proto::Location, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Location, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Location, _impl_.degreeslatitude_), - PROTOBUF_FIELD_OFFSET(::proto::Location, _impl_.degreeslongitude_), - PROTOBUF_FIELD_OFFSET(::proto::Location, _impl_.name_), - 1, - 2, - 0, - PROTOBUF_FIELD_OFFSET(::proto::MediaData, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::MediaData, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::MediaData, _impl_.localpath_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::MediaRetryNotification, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::MediaRetryNotification, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::MediaRetryNotification, _impl_.stanzaid_), - PROTOBUF_FIELD_OFFSET(::proto::MediaRetryNotification, _impl_.directpath_), - PROTOBUF_FIELD_OFFSET(::proto::MediaRetryNotification, _impl_.result_), - 0, - 1, - 2, - PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateFatalExceptionNotification, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateFatalExceptionNotification, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateFatalExceptionNotification, _impl_.collectionnames_), - PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateFatalExceptionNotification, _impl_.timestamp_), - ~0u, - 0, - PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyData, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyData, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyData, _impl_.keydata_), - PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyData, _impl_.fingerprint_), - PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyData, _impl_.timestamp_), - 0, - 1, - 2, - PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyFingerprint, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyFingerprint, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyFingerprint, _impl_.rawid_), - PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyFingerprint, _impl_.currentindex_), - PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyFingerprint, _impl_.deviceindexes_), - 0, - 1, - ~0u, - PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyId, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyId, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyId, _impl_.keyid_), - 0, - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyRequest, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyRequest, _impl_.keyids_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyShare, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKeyShare, _impl_.keys_), - PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKey, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKey, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKey, _impl_.keyid_), - PROTOBUF_FIELD_OFFSET(::proto::Message_AppStateSyncKey, _impl_.keydata_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.url_), - PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.mimetype_), - PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.filesha256_), - PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.filelength_), - PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.seconds_), - PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.ptt_), - PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.mediakey_), - PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.fileencsha256_), - PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.directpath_), - PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.mediakeytimestamp_), - PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.contextinfo_), - PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.streamingsidecar_), - PROTOBUF_FIELD_OFFSET(::proto::Message_AudioMessage, _impl_.waveform_), - 0, - 1, - 2, - 9, - 10, - 11, - 3, - 4, - 5, - 12, - 8, - 6, - 7, - PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button_ButtonText, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button_ButtonText, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button_ButtonText, _impl_.displaytext_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button_NativeFlowInfo, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button_NativeFlowInfo, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button_NativeFlowInfo, _impl_.name_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button_NativeFlowInfo, _impl_.paramsjson_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button, _impl_.buttonid_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button, _impl_.buttontext_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button, _impl_.type_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage_Button, _impl_.nativeflowinfo_), - 0, - 1, - 3, - 2, - PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage, _impl_._oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage, _impl_.contenttext_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage, _impl_.footertext_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage, _impl_.contextinfo_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage, _impl_.buttons_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage, _impl_.headertype_), - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsMessage, _impl_.header_), - 0, - 1, - 2, - ~0u, - 3, - ~0u, - ~0u, - ~0u, - ~0u, - ~0u, - PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsResponseMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsResponseMessage, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsResponseMessage, _impl_._oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsResponseMessage, _impl_.selectedbuttonid_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsResponseMessage, _impl_.contextinfo_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsResponseMessage, _impl_.type_), - ::_pbi::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::proto::Message_ButtonsResponseMessage, _impl_.response_), - 0, - 1, - 2, - ~0u, - PROTOBUF_FIELD_OFFSET(::proto::Message_Call, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_Call, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_Call, _impl_.callkey_), - PROTOBUF_FIELD_OFFSET(::proto::Message_Call, _impl_.conversionsource_), - PROTOBUF_FIELD_OFFSET(::proto::Message_Call, _impl_.conversiondata_), - PROTOBUF_FIELD_OFFSET(::proto::Message_Call, _impl_.conversiondelayseconds_), - 0, - 1, - 2, - 3, - PROTOBUF_FIELD_OFFSET(::proto::Message_CancelPaymentRequestMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_CancelPaymentRequestMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_CancelPaymentRequestMessage, _impl_.key_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::Message_Chat, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_Chat, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_Chat, _impl_.displayname_), - PROTOBUF_FIELD_OFFSET(::proto::Message_Chat, _impl_.id_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::Message_ContactMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ContactMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_ContactMessage, _impl_.displayname_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ContactMessage, _impl_.vcard_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ContactMessage, _impl_.contextinfo_), - 0, - 1, - 2, - PROTOBUF_FIELD_OFFSET(::proto::Message_ContactsArrayMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ContactsArrayMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_ContactsArrayMessage, _impl_.displayname_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ContactsArrayMessage, _impl_.contacts_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ContactsArrayMessage, _impl_.contextinfo_), - 0, - ~0u, - 1, - PROTOBUF_FIELD_OFFSET(::proto::Message_DeclinePaymentRequestMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_DeclinePaymentRequestMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_DeclinePaymentRequestMessage, _impl_.key_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::Message_DeviceSentMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_DeviceSentMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_DeviceSentMessage, _impl_.destinationjid_), - PROTOBUF_FIELD_OFFSET(::proto::Message_DeviceSentMessage, _impl_.message_), - PROTOBUF_FIELD_OFFSET(::proto::Message_DeviceSentMessage, _impl_.phash_), - 0, - 2, - 1, - PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.url_), - PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.mimetype_), - PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.title_), - PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.filesha256_), - PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.filelength_), - PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.pagecount_), - PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.mediakey_), - PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.filename_), - PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.fileencsha256_), - PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.directpath_), - PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.mediakeytimestamp_), - PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.contactvcard_), - PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.thumbnaildirectpath_), - PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.thumbnailsha256_), - PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.thumbnailencsha256_), - PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.jpegthumbnail_), - PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.contextinfo_), - PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.thumbnailheight_), - PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.thumbnailwidth_), - PROTOBUF_FIELD_OFFSET(::proto::Message_DocumentMessage, _impl_.caption_), - 0, - 1, - 2, - 3, - 14, - 15, - 4, - 5, - 6, - 7, - 17, - 16, - 8, - 9, - 10, - 11, - 13, - 18, - 19, - 12, - PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.text_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.matchedtext_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.canonicalurl_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.description_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.title_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.textargb_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.backgroundargb_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.font_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.previewtype_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.jpegthumbnail_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.contextinfo_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.donotplayinline_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.thumbnaildirectpath_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.thumbnailsha256_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.thumbnailencsha256_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.mediakey_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.mediakeytimestamp_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.thumbnailheight_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.thumbnailwidth_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.invitelinkgrouptype_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.invitelinkparentgroupsubjectv2_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.invitelinkparentgroupthumbnailv2_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ExtendedTextMessage, _impl_.invitelinkgrouptypev2_), - 0, - 1, - 2, - 3, - 4, - 13, - 14, - 15, - 16, - 5, - 12, - 17, - 6, - 7, - 8, - 9, - 19, - 18, - 20, - 21, - 10, - 11, - 22, - PROTOBUF_FIELD_OFFSET(::proto::Message_FutureProofMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_FutureProofMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_FutureProofMessage, _impl_.message_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::Message_GroupInviteMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_GroupInviteMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_GroupInviteMessage, _impl_.groupjid_), - PROTOBUF_FIELD_OFFSET(::proto::Message_GroupInviteMessage, _impl_.invitecode_), - PROTOBUF_FIELD_OFFSET(::proto::Message_GroupInviteMessage, _impl_.inviteexpiration_), - PROTOBUF_FIELD_OFFSET(::proto::Message_GroupInviteMessage, _impl_.groupname_), - PROTOBUF_FIELD_OFFSET(::proto::Message_GroupInviteMessage, _impl_.jpegthumbnail_), - PROTOBUF_FIELD_OFFSET(::proto::Message_GroupInviteMessage, _impl_.caption_), - PROTOBUF_FIELD_OFFSET(::proto::Message_GroupInviteMessage, _impl_.contextinfo_), - PROTOBUF_FIELD_OFFSET(::proto::Message_GroupInviteMessage, _impl_.grouptype_), - 0, - 1, - 6, - 2, - 3, - 4, - 5, - 7, - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency, _impl_.currencycode_), - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency, _impl_.amount1000_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _impl_.dayofweek_), - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _impl_.year_), - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _impl_.month_), - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _impl_.dayofmonth_), - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _impl_.hour_), - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _impl_.minute_), - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _impl_.calendar_), - 5, - 0, - 1, - 2, - 3, - 4, - 6, - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch, _impl_.timestamp_), - 0, - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime, _impl_._oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime, _impl_.datetimeOneof_), - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter, _impl_._oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter, _impl_.default__), - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter, _impl_.paramOneof_), - 0, - ~0u, - ~0u, - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _impl_.namespace__), - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _impl_.elementname_), - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _impl_.params_), - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _impl_.fallbacklg_), - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _impl_.fallbacklc_), - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _impl_.localizableparams_), - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _impl_.deterministiclg_), - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _impl_.deterministiclc_), - PROTOBUF_FIELD_OFFSET(::proto::Message_HighlyStructuredMessage, _impl_.hydratedhsm_), - 0, - 1, - ~0u, - 2, - 3, - ~0u, - 4, - 5, - 6, - PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _impl_.filesha256_), - PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _impl_.filelength_), - PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _impl_.mediakey_), - PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _impl_.fileencsha256_), - PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _impl_.directpath_), - PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _impl_.synctype_), - PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _impl_.chunkorder_), - PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _impl_.originalmessageid_), - PROTOBUF_FIELD_OFFSET(::proto::Message_HistorySyncNotification, _impl_.progress_), - 0, - 5, - 1, - 2, - 3, - 6, - 7, - 4, - 8, - PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.url_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.mimetype_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.caption_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.filesha256_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.filelength_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.height_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.width_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.mediakey_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.fileencsha256_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.interactiveannotations_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.directpath_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.mediakeytimestamp_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.jpegthumbnail_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.contextinfo_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.firstscansidecar_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.firstscanlength_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.experimentgroupid_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.scanssidecar_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.scanlengths_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.midqualityfilesha256_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.midqualityfileencsha256_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.viewonce_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.thumbnaildirectpath_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.thumbnailsha256_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.thumbnailencsha256_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ImageMessage, _impl_.staticurl_), - 0, - 1, - 2, - 3, - 17, - 18, - 19, - 4, - 5, - ~0u, - 6, - 20, - 7, - 16, - 8, - 21, - 22, - 9, - ~0u, - 10, - 11, - 23, - 12, - 13, - 14, - 15, - PROTOBUF_FIELD_OFFSET(::proto::Message_InitialSecurityNotificationSettingSync, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InitialSecurityNotificationSettingSync, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_InitialSecurityNotificationSettingSync, _impl_.securitynotificationenabled_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Body, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Body, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Body, _impl_.text_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_CollectionMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_CollectionMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_CollectionMessage, _impl_.bizjid_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_CollectionMessage, _impl_.id_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_CollectionMessage, _impl_.messageversion_), - 0, - 1, - 2, - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Footer, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Footer, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Footer, _impl_.text_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Header, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Header, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Header, _impl_._oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Header, _impl_.title_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Header, _impl_.subtitle_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Header, _impl_.hasmediaattachment_), - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_Header, _impl_.media_), - 0, - 1, - 2, - ~0u, - ~0u, - ~0u, - ~0u, - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton, _impl_.name_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton, _impl_.buttonparamsjson_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_NativeFlowMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_NativeFlowMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_NativeFlowMessage, _impl_.buttons_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_NativeFlowMessage, _impl_.messageparamsjson_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_NativeFlowMessage, _impl_.messageversion_), - ~0u, - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_ShopMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_ShopMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_ShopMessage, _impl_.id_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_ShopMessage, _impl_.surface_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage_ShopMessage, _impl_.messageversion_), - 0, - 1, - 2, - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage, _impl_._oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage, _impl_.header_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage, _impl_.body_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage, _impl_.footer_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage, _impl_.contextinfo_), - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveMessage, _impl_.interactiveMessage_), - 0, - 1, - 2, - 3, - ~0u, - ~0u, - ~0u, - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage_Body, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage_Body, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage_Body, _impl_.text_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage, _impl_.name_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage, _impl_.paramsjson_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage, _impl_.version_), - 0, - 1, - 2, - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage, _impl_._oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage, _impl_.body_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage, _impl_.contextinfo_), - ::_pbi::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::proto::Message_InteractiveResponseMessage, _impl_.interactiveResponseMessage_), - 0, - 1, - ~0u, - PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_.note_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_.token_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_.attachmenttype_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_.attachmentmimetype_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_.attachmentmediakey_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_.attachmentmediakeytimestamp_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_.attachmentfilesha256_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_.attachmentfileencsha256_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_.attachmentdirectpath_), - PROTOBUF_FIELD_OFFSET(::proto::Message_InvoiceMessage, _impl_.attachmentjpegthumbnail_), - 0, - 1, - 9, - 2, - 3, - 8, - 4, - 5, - 6, - 7, - PROTOBUF_FIELD_OFFSET(::proto::Message_KeepInChatMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_KeepInChatMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_KeepInChatMessage, _impl_.key_), - PROTOBUF_FIELD_OFFSET(::proto::Message_KeepInChatMessage, _impl_.keeptype_), - PROTOBUF_FIELD_OFFSET(::proto::Message_KeepInChatMessage, _impl_.timestampms_), - 0, - 2, - 1, - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductListHeaderImage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductListHeaderImage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductListHeaderImage, _impl_.productid_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductListHeaderImage, _impl_.jpegthumbnail_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductListInfo, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductListInfo, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductListInfo, _impl_.productsections_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductListInfo, _impl_.headerimage_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductListInfo, _impl_.businessownerjid_), - ~0u, - 1, - 0, - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductSection, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductSection, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductSection, _impl_.title_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_ProductSection, _impl_.products_), - 0, - ~0u, - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Product, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Product, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Product, _impl_.productid_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Row, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Row, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Row, _impl_.title_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Row, _impl_.description_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Row, _impl_.rowid_), - 0, - 1, - 2, - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Section, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Section, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Section, _impl_.title_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage_Section, _impl_.rows_), - 0, - ~0u, - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage, _impl_.title_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage, _impl_.description_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage, _impl_.buttontext_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage, _impl_.listtype_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage, _impl_.sections_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage, _impl_.productlistinfo_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage, _impl_.footertext_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ListMessage, _impl_.contextinfo_), - 0, - 1, - 2, - 6, - ~0u, - 4, - 3, - 5, - PROTOBUF_FIELD_OFFSET(::proto::Message_ListResponseMessage_SingleSelectReply, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ListResponseMessage_SingleSelectReply, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_ListResponseMessage_SingleSelectReply, _impl_.selectedrowid_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::Message_ListResponseMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ListResponseMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_ListResponseMessage, _impl_.title_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ListResponseMessage, _impl_.listtype_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ListResponseMessage, _impl_.singleselectreply_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ListResponseMessage, _impl_.contextinfo_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ListResponseMessage, _impl_.description_), - 0, - 4, - 2, - 3, - 1, - PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_.degreeslatitude_), - PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_.degreeslongitude_), - PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_.accuracyinmeters_), - PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_.speedinmps_), - PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_.degreesclockwisefrommagneticnorth_), - PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_.caption_), - PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_.sequencenumber_), - PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_.timeoffset_), - PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_.jpegthumbnail_), - PROTOBUF_FIELD_OFFSET(::proto::Message_LiveLocationMessage, _impl_.contextinfo_), - 3, - 4, - 5, - 6, - 7, - 0, - 9, - 8, - 1, - 2, - PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.degreeslatitude_), - PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.degreeslongitude_), - PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.name_), - PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.address_), - PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.url_), - PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.islive_), - PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.accuracyinmeters_), - PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.speedinmps_), - PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.degreesclockwisefrommagneticnorth_), - PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.comment_), - PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.jpegthumbnail_), - PROTOBUF_FIELD_OFFSET(::proto::Message_LocationMessage, _impl_.contextinfo_), - 6, - 7, - 0, - 1, - 2, - 8, - 9, - 10, - 11, - 3, - 4, - 5, - PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.orderid_), - PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.thumbnail_), - PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.itemcount_), - PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.status_), - PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.surface_), - PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.message_), - PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.ordertitle_), - PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.sellerjid_), - PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.token_), - PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.totalamount1000_), - PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.totalcurrencycode_), - PROTOBUF_FIELD_OFFSET(::proto::Message_OrderMessage, _impl_.contextinfo_), - 0, - 1, - 9, - 10, - 11, - 2, - 3, - 4, - 5, - 8, - 6, - 7, - PROTOBUF_FIELD_OFFSET(::proto::Message_PaymentInviteMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_PaymentInviteMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_PaymentInviteMessage, _impl_.servicetype_), - PROTOBUF_FIELD_OFFSET(::proto::Message_PaymentInviteMessage, _impl_.expirytimestamp_), - 1, - 0, - PROTOBUF_FIELD_OFFSET(::proto::Message_PollCreationMessage_Option, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_PollCreationMessage_Option, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_PollCreationMessage_Option, _impl_.optionname_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::Message_PollCreationMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_PollCreationMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_PollCreationMessage, _impl_.enckey_), - PROTOBUF_FIELD_OFFSET(::proto::Message_PollCreationMessage, _impl_.name_), - PROTOBUF_FIELD_OFFSET(::proto::Message_PollCreationMessage, _impl_.options_), - PROTOBUF_FIELD_OFFSET(::proto::Message_PollCreationMessage, _impl_.selectableoptionscount_), - PROTOBUF_FIELD_OFFSET(::proto::Message_PollCreationMessage, _impl_.contextinfo_), - 0, - 1, - ~0u, - 3, - 2, - PROTOBUF_FIELD_OFFSET(::proto::Message_PollEncValue, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_PollEncValue, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_PollEncValue, _impl_.encpayload_), - PROTOBUF_FIELD_OFFSET(::proto::Message_PollEncValue, _impl_.enciv_), - 0, - 1, - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::proto::Message_PollUpdateMessageMetadata, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_PollUpdateMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_PollUpdateMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_PollUpdateMessage, _impl_.pollcreationmessagekey_), - PROTOBUF_FIELD_OFFSET(::proto::Message_PollUpdateMessage, _impl_.vote_), - PROTOBUF_FIELD_OFFSET(::proto::Message_PollUpdateMessage, _impl_.metadata_), - PROTOBUF_FIELD_OFFSET(::proto::Message_PollUpdateMessage, _impl_.sendertimestampms_), - 0, - 1, - 2, - 3, - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::proto::Message_PollVoteMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_PollVoteMessage, _impl_.selectedoptions_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_CatalogSnapshot, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_CatalogSnapshot, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_CatalogSnapshot, _impl_.catalogimage_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_CatalogSnapshot, _impl_.title_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_CatalogSnapshot, _impl_.description_), - 2, - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.productimage_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.productid_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.title_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.description_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.currencycode_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.priceamount1000_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.retailerid_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.url_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.productimagecount_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.firstimageid_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage_ProductSnapshot, _impl_.salepriceamount1000_), - 7, - 0, - 1, - 2, - 3, - 8, - 4, - 5, - 10, - 6, - 9, - PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage, _impl_.product_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage, _impl_.businessownerjid_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage, _impl_.catalog_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage, _impl_.body_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage, _impl_.footer_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProductMessage, _impl_.contextinfo_), - 3, - 0, - 4, - 1, - 2, - 5, - PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.key_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.type_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.ephemeralexpiration_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.ephemeralsettingtimestamp_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.historysyncnotification_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.appstatesynckeyshare_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.appstatesynckeyrequest_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.initialsecuritynotificationsettingsync_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.appstatefatalexceptionnotification_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.disappearingmode_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.requestmediauploadmessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ProtocolMessage, _impl_.requestmediauploadresponsemessage_), - 0, - 9, - 10, - 11, - 1, - 2, - 3, - 4, - 5, - 6, - 7, - 8, - PROTOBUF_FIELD_OFFSET(::proto::Message_ReactionMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ReactionMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_ReactionMessage, _impl_.key_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ReactionMessage, _impl_.text_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ReactionMessage, _impl_.groupingkey_), - PROTOBUF_FIELD_OFFSET(::proto::Message_ReactionMessage, _impl_.sendertimestampms_), - 2, - 0, - 1, - 3, - PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadMessage, _impl_.filesha256_), - PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadMessage, _impl_.rmrsource_), - ~0u, - 0, - PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult, _impl_.filesha256_), - PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult, _impl_.mediauploadresult_), - PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult, _impl_.stickermessage_), - 0, - 2, - 1, - PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadResponseMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadResponseMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadResponseMessage, _impl_.rmrsource_), - PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadResponseMessage, _impl_.stanzaid_), - PROTOBUF_FIELD_OFFSET(::proto::Message_RequestMediaUploadResponseMessage, _impl_.reuploadresult_), - 1, - 0, - ~0u, - PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPaymentMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPaymentMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPaymentMessage, _impl_.notemessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPaymentMessage, _impl_.currencycodeiso4217_), - PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPaymentMessage, _impl_.amount1000_), - PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPaymentMessage, _impl_.requestfrom_), - PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPaymentMessage, _impl_.expirytimestamp_), - PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPaymentMessage, _impl_.amount_), - PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPaymentMessage, _impl_.background_), - 2, - 0, - 5, - 1, - 6, - 3, - 4, - PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPhoneNumberMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPhoneNumberMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_RequestPhoneNumberMessage, _impl_.contextinfo_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::Message_SendPaymentMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_SendPaymentMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_SendPaymentMessage, _impl_.notemessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message_SendPaymentMessage, _impl_.requestmessagekey_), - PROTOBUF_FIELD_OFFSET(::proto::Message_SendPaymentMessage, _impl_.background_), - 0, - 1, - 2, - PROTOBUF_FIELD_OFFSET(::proto::Message_SenderKeyDistributionMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_SenderKeyDistributionMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_SenderKeyDistributionMessage, _impl_.groupid_), - PROTOBUF_FIELD_OFFSET(::proto::Message_SenderKeyDistributionMessage, _impl_.axolotlsenderkeydistributionmessage_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.url_), - PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.filesha256_), - PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.fileencsha256_), - PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.mediakey_), - PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.mimetype_), - PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.height_), - PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.width_), - PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.directpath_), - PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.filelength_), - PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.mediakeytimestamp_), - PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.firstframelength_), - PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.firstframesidecar_), - PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.isanimated_), - PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.pngthumbnail_), - PROTOBUF_FIELD_OFFSET(::proto::Message_StickerMessage, _impl_.contextinfo_), - 0, - 1, - 2, - 3, - 4, - 9, - 10, - 5, - 11, - 12, - 13, - 6, - 14, - 7, - 8, - PROTOBUF_FIELD_OFFSET(::proto::Message_StickerSyncRMRMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_StickerSyncRMRMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_StickerSyncRMRMessage, _impl_.filehash_), - PROTOBUF_FIELD_OFFSET(::proto::Message_StickerSyncRMRMessage, _impl_.rmrsource_), - PROTOBUF_FIELD_OFFSET(::proto::Message_StickerSyncRMRMessage, _impl_.requesttimestamp_), - ~0u, - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateButtonReplyMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateButtonReplyMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateButtonReplyMessage, _impl_.selectedid_), - PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateButtonReplyMessage, _impl_.selecteddisplaytext_), - PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateButtonReplyMessage, _impl_.contextinfo_), - PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateButtonReplyMessage, _impl_.selectedindex_), - 0, - 1, - 2, - 3, - PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_FourRowTemplate, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_FourRowTemplate, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_FourRowTemplate, _impl_._oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_FourRowTemplate, _impl_.content_), - PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_FourRowTemplate, _impl_.footer_), - PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_FourRowTemplate, _impl_.buttons_), - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_FourRowTemplate, _impl_.title_), - 0, - 1, - ~0u, - ~0u, - ~0u, - ~0u, - ~0u, - ~0u, - PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_HydratedFourRowTemplate, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_HydratedFourRowTemplate, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_HydratedFourRowTemplate, _impl_._oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_HydratedFourRowTemplate, _impl_.hydratedcontenttext_), - PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_HydratedFourRowTemplate, _impl_.hydratedfootertext_), - PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_HydratedFourRowTemplate, _impl_.hydratedbuttons_), - PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_HydratedFourRowTemplate, _impl_.templateid_), - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage_HydratedFourRowTemplate, _impl_.title_), - 0, - 1, - ~0u, - 2, - ~0u, - ~0u, - ~0u, - ~0u, - ~0u, - PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage, _impl_._oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage, _impl_.contextinfo_), - PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage, _impl_.hydratedtemplate_), - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::proto::Message_TemplateMessage, _impl_.format_), - 0, - 1, - ~0u, - ~0u, - PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.url_), - PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.mimetype_), - PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.filesha256_), - PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.filelength_), - PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.seconds_), - PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.mediakey_), - PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.caption_), - PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.gifplayback_), - PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.height_), - PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.width_), - PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.fileencsha256_), - PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.interactiveannotations_), - PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.directpath_), - PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.mediakeytimestamp_), - PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.jpegthumbnail_), - PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.contextinfo_), - PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.streamingsidecar_), - PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.gifattribution_), - PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.viewonce_), - PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.thumbnaildirectpath_), - PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.thumbnailsha256_), - PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.thumbnailencsha256_), - PROTOBUF_FIELD_OFFSET(::proto::Message_VideoMessage, _impl_.staticurl_), - 0, - 1, - 2, - 14, - 15, - 3, - 4, - 18, - 16, - 17, - 5, - ~0u, - 6, - 20, - 7, - 13, - 8, - 21, - 19, - 9, - 10, - 11, - 12, - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.conversation_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.senderkeydistributionmessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.imagemessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.contactmessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.locationmessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.extendedtextmessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.documentmessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.audiomessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.videomessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.call_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.chat_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.protocolmessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.contactsarraymessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.highlystructuredmessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.fastratchetkeysenderkeydistributionmessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.sendpaymentmessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.livelocationmessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.requestpaymentmessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.declinepaymentrequestmessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.cancelpaymentrequestmessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.templatemessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.stickermessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.groupinvitemessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.templatebuttonreplymessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.productmessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.devicesentmessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.messagecontextinfo_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.listmessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.viewoncemessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.ordermessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.listresponsemessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.ephemeralmessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.invoicemessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.buttonsmessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.buttonsresponsemessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.paymentinvitemessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.interactivemessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.reactionmessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.stickersyncrmrmessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.interactiveresponsemessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.pollcreationmessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.pollupdatemessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.keepinchatmessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.documentwithcaptionmessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.requestphonenumbermessage_), - PROTOBUF_FIELD_OFFSET(::proto::Message, _impl_.viewoncemessagev2_), - 0, - 1, - 2, - 3, - 4, - 5, - 6, - 7, - 8, - 9, - 10, - 11, - 12, - 13, - 14, - 15, - 16, - 17, - 18, - 19, - 20, - 21, - 22, - 23, - 24, - 25, - 26, - 27, - 28, - 29, - 30, - 31, - 32, - 33, - 34, - 35, - 36, - 37, - 38, - 39, - 40, - 41, - 42, - 43, - 44, - 45, - PROTOBUF_FIELD_OFFSET(::proto::MessageContextInfo, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::MessageContextInfo, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::MessageContextInfo, _impl_.devicelistmetadata_), - PROTOBUF_FIELD_OFFSET(::proto::MessageContextInfo, _impl_.devicelistmetadataversion_), - PROTOBUF_FIELD_OFFSET(::proto::MessageContextInfo, _impl_.messagesecret_), - PROTOBUF_FIELD_OFFSET(::proto::MessageContextInfo, _impl_.paddingbytes_), - 2, - 3, - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::MessageKey, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::MessageKey, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::MessageKey, _impl_.remotejid_), - PROTOBUF_FIELD_OFFSET(::proto::MessageKey, _impl_.fromme_), - PROTOBUF_FIELD_OFFSET(::proto::MessageKey, _impl_.id_), - PROTOBUF_FIELD_OFFSET(::proto::MessageKey, _impl_.participant_), - 0, - 3, - 1, - 2, - PROTOBUF_FIELD_OFFSET(::proto::Money, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Money, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Money, _impl_.value_), - PROTOBUF_FIELD_OFFSET(::proto::Money, _impl_.offset_), - PROTOBUF_FIELD_OFFSET(::proto::Money, _impl_.currencycode_), - 1, - 2, - 0, - PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData_PollOption, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData_PollOption, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData_PollOption, _impl_.name_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.body_), - PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.caption_), - PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.lng_), - PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.islive_), - PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.lat_), - PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.paymentamount1000_), - PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.paymentnotemsgbody_), - PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.canonicalurl_), - PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.matchedtext_), - PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.title_), - PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.description_), - PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.futureproofbuffer_), - PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.clienturl_), - PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.loc_), - PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.pollname_), - PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.polloptions_), - PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.pollselectableoptionscount_), - PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.messagesecret_), - PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.sendertimestampms_), - PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.pollupdateparentkey_), - PROTOBUF_FIELD_OFFSET(::proto::MsgOpaqueData, _impl_.encpollvote_), - 0, - 1, - 14, - 16, - 15, - 17, - 2, - 3, - 4, - 5, - 6, - 7, - 8, - 9, - 10, - ~0u, - 19, - 11, - 18, - 12, - 13, - PROTOBUF_FIELD_OFFSET(::proto::MsgRowOpaqueData, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::MsgRowOpaqueData, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::MsgRowOpaqueData, _impl_.currentmsg_), - PROTOBUF_FIELD_OFFSET(::proto::MsgRowOpaqueData, _impl_.quotedmsg_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate_Details, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate_Details, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate_Details, _impl_.serial_), - PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate_Details, _impl_.issuer_), - PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate_Details, _impl_.expires_), - PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate_Details, _impl_.subject_), - PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate_Details, _impl_.key_), - 4, - 0, - 3, - 1, - 2, - PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate, _impl_.details_), - PROTOBUF_FIELD_OFFSET(::proto::NoiseCertificate, _impl_.signature_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::NotificationMessageInfo, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::NotificationMessageInfo, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::NotificationMessageInfo, _impl_.key_), - PROTOBUF_FIELD_OFFSET(::proto::NotificationMessageInfo, _impl_.message_), - PROTOBUF_FIELD_OFFSET(::proto::NotificationMessageInfo, _impl_.messagetimestamp_), - PROTOBUF_FIELD_OFFSET(::proto::NotificationMessageInfo, _impl_.participant_), - 1, - 2, - 3, - 0, - PROTOBUF_FIELD_OFFSET(::proto::PastParticipant, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::PastParticipant, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::PastParticipant, _impl_.userjid_), - PROTOBUF_FIELD_OFFSET(::proto::PastParticipant, _impl_.leavereason_), - PROTOBUF_FIELD_OFFSET(::proto::PastParticipant, _impl_.leavets_), - 0, - 2, - 1, - PROTOBUF_FIELD_OFFSET(::proto::PastParticipants, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::PastParticipants, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::PastParticipants, _impl_.groupjid_), - PROTOBUF_FIELD_OFFSET(::proto::PastParticipants, _impl_.pastparticipants_), - 0, - ~0u, - PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground_MediaData, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground_MediaData, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground_MediaData, _impl_.mediakey_), - PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground_MediaData, _impl_.mediakeytimestamp_), - PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground_MediaData, _impl_.filesha256_), - PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground_MediaData, _impl_.fileencsha256_), - PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground_MediaData, _impl_.directpath_), - 0, - 4, - 1, - 2, - 3, - PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_.id_), - PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_.filelength_), - PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_.width_), - PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_.height_), - PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_.mimetype_), - PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_.placeholderargb_), - PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_.textargb_), - PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_.subtextargb_), - PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_.mediadata_), - PROTOBUF_FIELD_OFFSET(::proto::PaymentBackground, _impl_.type_), - 0, - 3, - 4, - 5, - 1, - 6, - 7, - 8, - 2, - 9, - PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.currencydeprecated_), - PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.amount1000_), - PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.receiverjid_), - PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.status_), - PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.transactiontimestamp_), - PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.requestmessagekey_), - PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.expirytimestamp_), - PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.futureproofed_), - PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.currency_), - PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.txnstatus_), - PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.usenovifiatformat_), - PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.primaryamount_), - PROTOBUF_FIELD_OFFSET(::proto::PaymentInfo, _impl_.exchangeamount_), - 6, - 5, - 0, - 7, - 8, - 2, - 9, - 10, - 1, - 12, - 11, - 3, - 4, - PROTOBUF_FIELD_OFFSET(::proto::PendingKeyExchange, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::PendingKeyExchange, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::PendingKeyExchange, _impl_.sequence_), - PROTOBUF_FIELD_OFFSET(::proto::PendingKeyExchange, _impl_.localbasekey_), - PROTOBUF_FIELD_OFFSET(::proto::PendingKeyExchange, _impl_.localbasekeyprivate_), - PROTOBUF_FIELD_OFFSET(::proto::PendingKeyExchange, _impl_.localratchetkey_), - PROTOBUF_FIELD_OFFSET(::proto::PendingKeyExchange, _impl_.localratchetkeyprivate_), - PROTOBUF_FIELD_OFFSET(::proto::PendingKeyExchange, _impl_.localidentitykey_), - PROTOBUF_FIELD_OFFSET(::proto::PendingKeyExchange, _impl_.localidentitykeyprivate_), - 6, - 0, - 1, - 2, - 3, - 4, - 5, - PROTOBUF_FIELD_OFFSET(::proto::PendingPreKey, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::PendingPreKey, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::PendingPreKey, _impl_.prekeyid_), - PROTOBUF_FIELD_OFFSET(::proto::PendingPreKey, _impl_.signedprekeyid_), - PROTOBUF_FIELD_OFFSET(::proto::PendingPreKey, _impl_.basekey_), - 1, - 2, - 0, - PROTOBUF_FIELD_OFFSET(::proto::PhotoChange, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::PhotoChange, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::PhotoChange, _impl_.oldphoto_), - PROTOBUF_FIELD_OFFSET(::proto::PhotoChange, _impl_.newphoto_), - PROTOBUF_FIELD_OFFSET(::proto::PhotoChange, _impl_.newphotoid_), - 0, - 1, - 2, - PROTOBUF_FIELD_OFFSET(::proto::Point, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Point, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Point, _impl_.xdeprecated_), - PROTOBUF_FIELD_OFFSET(::proto::Point, _impl_.ydeprecated_), - PROTOBUF_FIELD_OFFSET(::proto::Point, _impl_.x_), - PROTOBUF_FIELD_OFFSET(::proto::Point, _impl_.y_), - 0, - 1, - 2, - 3, - PROTOBUF_FIELD_OFFSET(::proto::PollAdditionalMetadata, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::PollAdditionalMetadata, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::PollAdditionalMetadata, _impl_.pollinvalidated_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::PollEncValue, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::PollEncValue, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::PollEncValue, _impl_.encpayload_), - PROTOBUF_FIELD_OFFSET(::proto::PollEncValue, _impl_.enciv_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::PollUpdate, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::PollUpdate, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::PollUpdate, _impl_.pollupdatemessagekey_), - PROTOBUF_FIELD_OFFSET(::proto::PollUpdate, _impl_.vote_), - PROTOBUF_FIELD_OFFSET(::proto::PollUpdate, _impl_.sendertimestampms_), - 0, - 1, - 2, - PROTOBUF_FIELD_OFFSET(::proto::PreKeyRecordStructure, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::PreKeyRecordStructure, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::PreKeyRecordStructure, _impl_.id_), - PROTOBUF_FIELD_OFFSET(::proto::PreKeyRecordStructure, _impl_.publickey_), - PROTOBUF_FIELD_OFFSET(::proto::PreKeyRecordStructure, _impl_.privatekey_), - 2, - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::Pushname, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Pushname, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Pushname, _impl_.id_), - PROTOBUF_FIELD_OFFSET(::proto::Pushname, _impl_.pushname_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::Reaction, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::Reaction, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::Reaction, _impl_.key_), - PROTOBUF_FIELD_OFFSET(::proto::Reaction, _impl_.text_), - PROTOBUF_FIELD_OFFSET(::proto::Reaction, _impl_.groupingkey_), - PROTOBUF_FIELD_OFFSET(::proto::Reaction, _impl_.sendertimestampms_), - PROTOBUF_FIELD_OFFSET(::proto::Reaction, _impl_.unread_), - 2, - 0, - 1, - 3, - 4, - PROTOBUF_FIELD_OFFSET(::proto::RecentEmojiWeight, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::RecentEmojiWeight, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::RecentEmojiWeight, _impl_.emoji_), - PROTOBUF_FIELD_OFFSET(::proto::RecentEmojiWeight, _impl_.weight_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::RecordStructure, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::RecordStructure, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::RecordStructure, _impl_.currentsession_), - PROTOBUF_FIELD_OFFSET(::proto::RecordStructure, _impl_.previoussessions_), - 0, - ~0u, - PROTOBUF_FIELD_OFFSET(::proto::SenderChainKey, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SenderChainKey, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SenderChainKey, _impl_.iteration_), - PROTOBUF_FIELD_OFFSET(::proto::SenderChainKey, _impl_.seed_), - 1, - 0, - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::proto::SenderKeyRecordStructure, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SenderKeyRecordStructure, _impl_.senderkeystates_), - PROTOBUF_FIELD_OFFSET(::proto::SenderKeyStateStructure, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SenderKeyStateStructure, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SenderKeyStateStructure, _impl_.senderkeyid_), - PROTOBUF_FIELD_OFFSET(::proto::SenderKeyStateStructure, _impl_.senderchainkey_), - PROTOBUF_FIELD_OFFSET(::proto::SenderKeyStateStructure, _impl_.sendersigningkey_), - PROTOBUF_FIELD_OFFSET(::proto::SenderKeyStateStructure, _impl_.sendermessagekeys_), - 2, - 0, - 1, - ~0u, - PROTOBUF_FIELD_OFFSET(::proto::SenderMessageKey, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SenderMessageKey, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SenderMessageKey, _impl_.iteration_), - PROTOBUF_FIELD_OFFSET(::proto::SenderMessageKey, _impl_.seed_), - 1, - 0, - PROTOBUF_FIELD_OFFSET(::proto::SenderSigningKey, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SenderSigningKey, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SenderSigningKey, _impl_.public__), - PROTOBUF_FIELD_OFFSET(::proto::SenderSigningKey, _impl_.private__), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::ServerErrorReceipt, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::ServerErrorReceipt, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::ServerErrorReceipt, _impl_.stanzaid_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.sessionversion_), - PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.localidentitypublic_), - PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.remoteidentitypublic_), - PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.rootkey_), - PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.previouscounter_), - PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.senderchain_), - PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.receiverchains_), - PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.pendingkeyexchange_), - PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.pendingprekey_), - PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.remoteregistrationid_), - PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.localregistrationid_), - PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.needsrefresh_), - PROTOBUF_FIELD_OFFSET(::proto::SessionStructure, _impl_.alicebasekey_), - 7, - 0, - 1, - 2, - 8, - 4, - ~0u, - 5, - 6, - 9, - 10, - 11, - 3, - PROTOBUF_FIELD_OFFSET(::proto::SignedPreKeyRecordStructure, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SignedPreKeyRecordStructure, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SignedPreKeyRecordStructure, _impl_.id_), - PROTOBUF_FIELD_OFFSET(::proto::SignedPreKeyRecordStructure, _impl_.publickey_), - PROTOBUF_FIELD_OFFSET(::proto::SignedPreKeyRecordStructure, _impl_.privatekey_), - PROTOBUF_FIELD_OFFSET(::proto::SignedPreKeyRecordStructure, _impl_.signature_), - PROTOBUF_FIELD_OFFSET(::proto::SignedPreKeyRecordStructure, _impl_.timestamp_), - 4, - 0, - 1, - 2, - 3, - PROTOBUF_FIELD_OFFSET(::proto::StatusPSA, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::StatusPSA, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::StatusPSA, _impl_.campaignid_), - PROTOBUF_FIELD_OFFSET(::proto::StatusPSA, _impl_.campaignexpirationtimestamp_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_.url_), - PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_.filesha256_), - PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_.fileencsha256_), - PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_.mediakey_), - PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_.mimetype_), - PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_.height_), - PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_.width_), - PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_.directpath_), - PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_.filelength_), - PROTOBUF_FIELD_OFFSET(::proto::StickerMetadata, _impl_.weight_), - 0, - 1, - 2, - 3, - 4, - 6, - 7, - 5, - 8, - 9, - PROTOBUF_FIELD_OFFSET(::proto::SyncActionData, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionData, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionData, _impl_.index_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionData, _impl_.value_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionData, _impl_.padding_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionData, _impl_.version_), - 0, - 2, - 1, - 3, - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_AgentAction, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_AgentAction, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_AgentAction, _impl_.name_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_AgentAction, _impl_.deviceid_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_AgentAction, _impl_.isdeleted_), - 0, - 1, - 2, - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_AndroidUnsupportedActions, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_AndroidUnsupportedActions, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_AndroidUnsupportedActions, _impl_.allowed_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ArchiveChatAction, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ArchiveChatAction, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ArchiveChatAction, _impl_.archived_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ArchiveChatAction, _impl_.messagerange_), - 1, - 0, - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ClearChatAction, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ClearChatAction, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ClearChatAction, _impl_.messagerange_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ContactAction, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ContactAction, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ContactAction, _impl_.fullname_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_ContactAction, _impl_.firstname_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_DeleteChatAction, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_DeleteChatAction, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_DeleteChatAction, _impl_.messagerange_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_DeleteMessageForMeAction, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_DeleteMessageForMeAction, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_DeleteMessageForMeAction, _impl_.deletemedia_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_DeleteMessageForMeAction, _impl_.messagetimestamp_), - 1, - 0, - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_KeyExpiration, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_KeyExpiration, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_KeyExpiration, _impl_.expiredkeyepoch_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LabelAssociationAction, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LabelAssociationAction, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LabelAssociationAction, _impl_.labeled_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LabelEditAction, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LabelEditAction, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LabelEditAction, _impl_.name_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LabelEditAction, _impl_.color_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LabelEditAction, _impl_.predefinedid_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LabelEditAction, _impl_.deleted_), - 0, - 1, - 2, - 3, - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LocaleSetting, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LocaleSetting, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_LocaleSetting, _impl_.locale_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_MarkChatAsReadAction, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_MarkChatAsReadAction, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_MarkChatAsReadAction, _impl_.read_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_MarkChatAsReadAction, _impl_.messagerange_), - 1, - 0, - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_MuteAction, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_MuteAction, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_MuteAction, _impl_.muted_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_MuteAction, _impl_.muteendtimestamp_), - 1, - 0, - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_NuxAction, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_NuxAction, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_NuxAction, _impl_.acknowledged_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PinAction, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PinAction, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PinAction, _impl_.pinned_), - 0, - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PrimaryFeature, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PrimaryFeature, _impl_.flags_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PrimaryVersionAction, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PrimaryVersionAction, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PrimaryVersionAction, _impl_.version_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PushNameSetting, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PushNameSetting, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_PushNameSetting, _impl_.name_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_QuickReplyAction, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_QuickReplyAction, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_QuickReplyAction, _impl_.shortcut_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_QuickReplyAction, _impl_.message_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_QuickReplyAction, _impl_.keywords_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_QuickReplyAction, _impl_.count_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_QuickReplyAction, _impl_.deleted_), - 0, - 1, - ~0u, - 2, - 3, - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_RecentEmojiWeightsAction, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_RecentEmojiWeightsAction, _impl_.weights_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SecurityNotificationSetting, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SecurityNotificationSetting, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SecurityNotificationSetting, _impl_.shownotification_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StarAction, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StarAction, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StarAction, _impl_.starred_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_.url_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_.fileencsha256_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_.mediakey_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_.mimetype_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_.height_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_.width_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_.directpath_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_.filelength_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_.isfavorite_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_StickerAction, _impl_.deviceidhint_), - 0, - 1, - 2, - 3, - 5, - 6, - 4, - 7, - 8, - 9, - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SubscriptionAction, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SubscriptionAction, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SubscriptionAction, _impl_.isdeactivated_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SubscriptionAction, _impl_.isautorenewing_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SubscriptionAction, _impl_.expirationdate_), - 1, - 2, - 0, - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SyncActionMessageRange, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SyncActionMessageRange, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SyncActionMessageRange, _impl_.lastmessagetimestamp_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SyncActionMessageRange, _impl_.lastsystemmessagetimestamp_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SyncActionMessageRange, _impl_.messages_), - 0, - 1, - ~0u, - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SyncActionMessage, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SyncActionMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SyncActionMessage, _impl_.key_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_SyncActionMessage, _impl_.timestamp_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_TimeFormatAction, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_TimeFormatAction, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_TimeFormatAction, _impl_.istwentyfourhourformatenabled_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_UnarchiveChatsSetting, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_UnarchiveChatsSetting, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_UnarchiveChatsSetting, _impl_.unarchivechats_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_UserStatusMuteAction, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_UserStatusMuteAction, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue_UserStatusMuteAction, _impl_.muted_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.timestamp_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.staraction_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.contactaction_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.muteaction_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.pinaction_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.securitynotificationsetting_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.pushnamesetting_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.quickreplyaction_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.recentemojiweightsaction_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.labeleditaction_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.labelassociationaction_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.localesetting_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.archivechataction_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.deletemessageformeaction_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.keyexpiration_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.markchatasreadaction_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.clearchataction_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.deletechataction_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.unarchivechatssetting_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.primaryfeature_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.androidunsupportedactions_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.agentaction_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.subscriptionaction_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.userstatusmuteaction_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.timeformataction_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.nuxaction_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.primaryversionaction_), - PROTOBUF_FIELD_OFFSET(::proto::SyncActionValue, _impl_.stickeraction_), - 27, - 0, - 1, - 2, - 3, - 4, - 5, - 6, - 7, - 8, - 9, - 10, - 11, - 12, - 13, - 14, - 15, - 16, - 17, - 18, - 19, - 20, - 21, - 22, - 23, - 24, - 25, - 26, - PROTOBUF_FIELD_OFFSET(::proto::SyncdIndex, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncdIndex, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncdIndex, _impl_.blob_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::SyncdMutation, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncdMutation, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncdMutation, _impl_.operation_), - PROTOBUF_FIELD_OFFSET(::proto::SyncdMutation, _impl_.record_), - 1, - 0, - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::proto::SyncdMutations, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncdMutations, _impl_.mutations_), - PROTOBUF_FIELD_OFFSET(::proto::SyncdPatch, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncdPatch, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncdPatch, _impl_.version_), - PROTOBUF_FIELD_OFFSET(::proto::SyncdPatch, _impl_.mutations_), - PROTOBUF_FIELD_OFFSET(::proto::SyncdPatch, _impl_.externalmutations_), - PROTOBUF_FIELD_OFFSET(::proto::SyncdPatch, _impl_.snapshotmac_), - PROTOBUF_FIELD_OFFSET(::proto::SyncdPatch, _impl_.patchmac_), - PROTOBUF_FIELD_OFFSET(::proto::SyncdPatch, _impl_.keyid_), - PROTOBUF_FIELD_OFFSET(::proto::SyncdPatch, _impl_.exitcode_), - PROTOBUF_FIELD_OFFSET(::proto::SyncdPatch, _impl_.deviceindex_), - 2, - ~0u, - 3, - 0, - 1, - 4, - 5, - 6, - PROTOBUF_FIELD_OFFSET(::proto::SyncdRecord, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncdRecord, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncdRecord, _impl_.index_), - PROTOBUF_FIELD_OFFSET(::proto::SyncdRecord, _impl_.value_), - PROTOBUF_FIELD_OFFSET(::proto::SyncdRecord, _impl_.keyid_), - 0, - 1, - 2, - PROTOBUF_FIELD_OFFSET(::proto::SyncdSnapshot, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncdSnapshot, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncdSnapshot, _impl_.version_), - PROTOBUF_FIELD_OFFSET(::proto::SyncdSnapshot, _impl_.records_), - PROTOBUF_FIELD_OFFSET(::proto::SyncdSnapshot, _impl_.mac_), - PROTOBUF_FIELD_OFFSET(::proto::SyncdSnapshot, _impl_.keyid_), - 1, - ~0u, - 0, - 2, - PROTOBUF_FIELD_OFFSET(::proto::SyncdValue, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncdValue, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncdValue, _impl_.blob_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::SyncdVersion, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::SyncdVersion, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::SyncdVersion, _impl_.version_), - 0, - PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_CallButton, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_CallButton, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_CallButton, _impl_.displaytext_), - PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_CallButton, _impl_.phonenumber_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_QuickReplyButton, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_QuickReplyButton, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_QuickReplyButton, _impl_.displaytext_), - PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_QuickReplyButton, _impl_.id_), - 1, - 0, - PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_URLButton, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_URLButton, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_URLButton, _impl_.displaytext_), - PROTOBUF_FIELD_OFFSET(::proto::TemplateButton_URLButton, _impl_.url_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::TemplateButton, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::TemplateButton, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::proto::TemplateButton, _impl_._oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::TemplateButton, _impl_.index_), - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - ::_pbi::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::proto::TemplateButton, _impl_.button_), - 0, - ~0u, - ~0u, - ~0u, - PROTOBUF_FIELD_OFFSET(::proto::UserReceipt, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::UserReceipt, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::UserReceipt, _impl_.userjid_), - PROTOBUF_FIELD_OFFSET(::proto::UserReceipt, _impl_.receipttimestamp_), - PROTOBUF_FIELD_OFFSET(::proto::UserReceipt, _impl_.readtimestamp_), - PROTOBUF_FIELD_OFFSET(::proto::UserReceipt, _impl_.playedtimestamp_), - PROTOBUF_FIELD_OFFSET(::proto::UserReceipt, _impl_.pendingdevicejid_), - PROTOBUF_FIELD_OFFSET(::proto::UserReceipt, _impl_.delivereddevicejid_), - 0, - 1, - 2, - 3, - ~0u, - ~0u, - PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate_Details, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate_Details, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate_Details, _impl_.serial_), - PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate_Details, _impl_.issuer_), - PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate_Details, _impl_.verifiedname_), - PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate_Details, _impl_.localizednames_), - PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate_Details, _impl_.issuetime_), - 2, - 0, - 1, - ~0u, - 3, - PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate, _impl_.details_), - PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate, _impl_.signature_), - PROTOBUF_FIELD_OFFSET(::proto::VerifiedNameCertificate, _impl_.serversignature_), - 0, - 1, - 2, - PROTOBUF_FIELD_OFFSET(::proto::WallpaperSettings, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::WallpaperSettings, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::WallpaperSettings, _impl_.filename_), - PROTOBUF_FIELD_OFFSET(::proto::WallpaperSettings, _impl_.opacity_), - 0, - 1, - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.labelsdisplay_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.voipindividualoutgoing_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.groupsv3_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.groupsv3create_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.changenumberv2_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.querystatusv3thumbnail_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.livelocations_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.queryvname_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.voipindividualincoming_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.quickrepliesquery_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.payments_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.stickerpackquery_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.livelocationsfinal_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.labelsedit_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.mediaupload_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.mediauploadrichquickreplies_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.vnamev2_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.videoplaybackurl_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.statusranking_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.voipindividualvideo_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.thirdpartystickers_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.frequentlyforwardedsetting_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.groupsv4joinpermission_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.recentstickers_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.catalog_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.starredstickers_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.voipgroupcall_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.templatemessage_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.templatemessageinteractivity_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.ephemeralmessages_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.e2enotificationsync_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.recentstickersv2_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.recentstickersv3_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.usernotice_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.support_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.groupuiicleanup_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.groupdogfoodinginternalonly_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.settingssync_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.archivev2_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.ephemeralallowgroupmembers_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.ephemeral24hduration_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.mdforceupgrade_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.disappearingmode_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.externalmdoptinavailable_), - PROTOBUF_FIELD_OFFSET(::proto::WebFeatures, _impl_.nodeletemessagetimelimit_), - 0, - 1, - 2, - 3, - 4, - 5, - 6, - 7, - 8, - 9, - 10, - 11, - 12, - 13, - 14, - 15, - 16, - 17, - 18, - 19, - 20, - 21, - 22, - 23, - 24, - 25, - 26, - 27, - 28, - 29, - 30, - 31, - 32, - 33, - 34, - 35, - 36, - 37, - 38, - 39, - 40, - 41, - 42, - 43, - 44, - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.key_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.message_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.messagetimestamp_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.status_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.participant_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.messagec2stimestamp_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.ignore_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.starred_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.broadcast_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.pushname_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.mediaciphertextsha256_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.multicast_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.urltext_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.urlnumber_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.messagestubtype_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.clearmedia_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.messagestubparameters_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.duration_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.labels_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.paymentinfo_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.finallivelocation_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.quotedpaymentinfo_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.ephemeralstarttimestamp_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.ephemeralduration_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.ephemeralofftoon_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.ephemeraloutofsync_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.bizprivacystatus_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.verifiedbizname_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.mediadata_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.photochange_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.userreceipt_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.reactions_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.quotedstickerdata_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.futureproofdata_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.statuspsa_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.pollupdates_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.polladditionalmetadata_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.agentid_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.statusalreadyviewed_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.messagesecret_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.keepinchat_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.originalselfauthoruserjidstring_), - PROTOBUF_FIELD_OFFSET(::proto::WebMessageInfo, _impl_.revokemessagetimestamp_), - 8, - 9, - 19, - 21, - 0, - 20, - 22, - 23, - 24, - 1, - 2, - 25, - 27, - 28, - 26, - 29, - ~0u, - 31, - ~0u, - 10, - 11, - 12, - 33, - 32, - 30, - 35, - 34, - 3, - 13, - 14, - ~0u, - ~0u, - 15, - 4, - 16, - ~0u, - 17, - 5, - 36, - 6, - 18, - 7, - 37, - PROTOBUF_FIELD_OFFSET(::proto::WebNotificationsInfo, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::proto::WebNotificationsInfo, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::proto::WebNotificationsInfo, _impl_.timestamp_), - PROTOBUF_FIELD_OFFSET(::proto::WebNotificationsInfo, _impl_.unreadchats_), - PROTOBUF_FIELD_OFFSET(::proto::WebNotificationsInfo, _impl_.notifymessagecount_), - PROTOBUF_FIELD_OFFSET(::proto::WebNotificationsInfo, _impl_.notifymessages_), - 0, - 1, - 2, - ~0u, -}; -static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, 9, -1, sizeof(::proto::ADVDeviceIdentity)}, - { 12, 22, -1, sizeof(::proto::ADVKeyIndexList)}, - { 26, 36, -1, sizeof(::proto::ADVSignedDeviceIdentity)}, - { 40, 48, -1, sizeof(::proto::ADVSignedDeviceIdentityHMAC)}, - { 50, 58, -1, sizeof(::proto::ADVSignedKeyIndexList)}, - { 60, 68, -1, sizeof(::proto::ActionLink)}, - { 70, 80, -1, sizeof(::proto::AutoDownloadSettings)}, - { 84, 95, -1, sizeof(::proto::BizAccountLinkInfo)}, - { 100, 108, -1, sizeof(::proto::BizAccountPayload)}, - { 110, 124, -1, sizeof(::proto::BizIdentityInfo)}, - { 132, 143, -1, sizeof(::proto::CertChain_NoiseCertificate_Details)}, - { 148, 156, -1, sizeof(::proto::CertChain_NoiseCertificate)}, - { 158, 166, -1, sizeof(::proto::CertChain)}, - { 168, 178, -1, sizeof(::proto::Chain)}, - { 182, 190, -1, sizeof(::proto::ChainKey)}, - { 192, 200, -1, sizeof(::proto::ClientPayload_DNSSource)}, - { 202, 216, -1, sizeof(::proto::ClientPayload_DevicePairingRegistrationData)}, - { 224, 235, -1, sizeof(::proto::ClientPayload_UserAgent_AppVersion)}, - { 240, 259, -1, sizeof(::proto::ClientPayload_UserAgent)}, - { 272, 289, -1, sizeof(::proto::ClientPayload_WebInfo_WebdPayload)}, - { 300, 310, -1, sizeof(::proto::ClientPayload_WebInfo)}, - { 314, 344, -1, sizeof(::proto::ClientPayload)}, - { 368, 378, -1, sizeof(::proto::ContextInfo_AdReplyInfo)}, - { 382, 400, -1, sizeof(::proto::ContextInfo_ExternalAdReplyInfo)}, - { 412, 441, -1, sizeof(::proto::ContextInfo)}, - { 464, 510, -1, sizeof(::proto::Conversation)}, - { 550, 562, -1, sizeof(::proto::DeviceListMetadata)}, - { 568, 579, -1, sizeof(::proto::DeviceProps_AppVersion)}, - { 584, 594, -1, sizeof(::proto::DeviceProps)}, - { 598, 605, -1, sizeof(::proto::DisappearingMode)}, - { 606, 614, -1, sizeof(::proto::EphemeralSetting)}, - { 616, 624, -1, sizeof(::proto::ExitCode)}, - { 626, 638, -1, sizeof(::proto::ExternalBlobReference)}, - { 644, 660, -1, sizeof(::proto::GlobalSettings)}, - { 670, 678, -1, sizeof(::proto::GroupParticipant)}, - { 680, 688, -1, sizeof(::proto::HandshakeMessage_ClientFinish)}, - { 690, 699, -1, sizeof(::proto::HandshakeMessage_ClientHello)}, - { 702, 711, -1, sizeof(::proto::HandshakeMessage_ServerHello)}, - { 714, 723, -1, sizeof(::proto::HandshakeMessage)}, - { 726, 743, -1, sizeof(::proto::HistorySync)}, - { 754, 762, -1, sizeof(::proto::HistorySyncMsg)}, - { 764, 772, -1, sizeof(::proto::HydratedTemplateButton_HydratedCallButton)}, - { 774, 782, -1, sizeof(::proto::HydratedTemplateButton_HydratedQuickReplyButton)}, - { 784, 792, -1, sizeof(::proto::HydratedTemplateButton_HydratedURLButton)}, - { 794, 805, -1, sizeof(::proto::HydratedTemplateButton)}, - { 809, 817, -1, sizeof(::proto::IdentityKeyPairStructure)}, - { 819, -1, -1, sizeof(::proto::InteractiveAnnotation)}, - { 828, 838, -1, sizeof(::proto::KeepInChat)}, - { 842, 849, -1, sizeof(::proto::KeyId)}, - { 850, 859, -1, sizeof(::proto::LocalizedName)}, - { 862, 871, -1, sizeof(::proto::Location)}, - { 874, 881, -1, sizeof(::proto::MediaData)}, - { 882, 891, -1, sizeof(::proto::MediaRetryNotification)}, - { 894, 902, -1, sizeof(::proto::Message_AppStateFatalExceptionNotification)}, - { 904, 913, -1, sizeof(::proto::Message_AppStateSyncKeyData)}, - { 916, 925, -1, sizeof(::proto::Message_AppStateSyncKeyFingerprint)}, - { 928, 935, -1, sizeof(::proto::Message_AppStateSyncKeyId)}, - { 936, -1, -1, sizeof(::proto::Message_AppStateSyncKeyRequest)}, - { 943, -1, -1, sizeof(::proto::Message_AppStateSyncKeyShare)}, - { 950, 958, -1, sizeof(::proto::Message_AppStateSyncKey)}, - { 960, 979, -1, sizeof(::proto::Message_AudioMessage)}, - { 992, 999, -1, sizeof(::proto::Message_ButtonsMessage_Button_ButtonText)}, - { 1000, 1008, -1, sizeof(::proto::Message_ButtonsMessage_Button_NativeFlowInfo)}, - { 1010, 1020, -1, sizeof(::proto::Message_ButtonsMessage_Button)}, - { 1024, 1041, -1, sizeof(::proto::Message_ButtonsMessage)}, - { 1051, 1062, -1, sizeof(::proto::Message_ButtonsResponseMessage)}, - { 1066, 1076, -1, sizeof(::proto::Message_Call)}, - { 1080, 1087, -1, sizeof(::proto::Message_CancelPaymentRequestMessage)}, - { 1088, 1096, -1, sizeof(::proto::Message_Chat)}, - { 1098, 1107, -1, sizeof(::proto::Message_ContactMessage)}, - { 1110, 1119, -1, sizeof(::proto::Message_ContactsArrayMessage)}, - { 1122, 1129, -1, sizeof(::proto::Message_DeclinePaymentRequestMessage)}, - { 1130, 1139, -1, sizeof(::proto::Message_DeviceSentMessage)}, - { 1142, 1168, -1, sizeof(::proto::Message_DocumentMessage)}, - { 1188, 1217, -1, sizeof(::proto::Message_ExtendedTextMessage)}, - { 1240, 1247, -1, sizeof(::proto::Message_FutureProofMessage)}, - { 1248, 1262, -1, sizeof(::proto::Message_GroupInviteMessage)}, - { 1270, 1278, -1, sizeof(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency)}, - { 1280, 1293, -1, sizeof(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent)}, - { 1300, 1307, -1, sizeof(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch)}, - { 1308, -1, -1, sizeof(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime)}, - { 1317, 1327, -1, sizeof(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter)}, - { 1330, 1345, -1, sizeof(::proto::Message_HighlyStructuredMessage)}, - { 1354, 1369, -1, sizeof(::proto::Message_HistorySyncNotification)}, - { 1378, 1410, -1, sizeof(::proto::Message_ImageMessage)}, - { 1436, 1443, -1, sizeof(::proto::Message_InitialSecurityNotificationSettingSync)}, - { 1444, 1451, -1, sizeof(::proto::Message_InteractiveMessage_Body)}, - { 1452, 1461, -1, sizeof(::proto::Message_InteractiveMessage_CollectionMessage)}, - { 1464, 1471, -1, sizeof(::proto::Message_InteractiveMessage_Footer)}, - { 1472, 1486, -1, sizeof(::proto::Message_InteractiveMessage_Header)}, - { 1493, 1501, -1, sizeof(::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton)}, - { 1503, 1512, -1, sizeof(::proto::Message_InteractiveMessage_NativeFlowMessage)}, - { 1515, 1524, -1, sizeof(::proto::Message_InteractiveMessage_ShopMessage)}, - { 1527, 1541, -1, sizeof(::proto::Message_InteractiveMessage)}, - { 1548, 1555, -1, sizeof(::proto::Message_InteractiveResponseMessage_Body)}, - { 1556, 1565, -1, sizeof(::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage)}, - { 1568, 1578, -1, sizeof(::proto::Message_InteractiveResponseMessage)}, - { 1581, 1597, -1, sizeof(::proto::Message_InvoiceMessage)}, - { 1607, 1616, -1, sizeof(::proto::Message_KeepInChatMessage)}, - { 1619, 1627, -1, sizeof(::proto::Message_ListMessage_ProductListHeaderImage)}, - { 1629, 1638, -1, sizeof(::proto::Message_ListMessage_ProductListInfo)}, - { 1641, 1649, -1, sizeof(::proto::Message_ListMessage_ProductSection)}, - { 1651, 1658, -1, sizeof(::proto::Message_ListMessage_Product)}, - { 1659, 1668, -1, sizeof(::proto::Message_ListMessage_Row)}, - { 1671, 1679, -1, sizeof(::proto::Message_ListMessage_Section)}, - { 1681, 1695, -1, sizeof(::proto::Message_ListMessage)}, - { 1703, 1710, -1, sizeof(::proto::Message_ListResponseMessage_SingleSelectReply)}, - { 1711, 1722, -1, sizeof(::proto::Message_ListResponseMessage)}, - { 1727, 1743, -1, sizeof(::proto::Message_LiveLocationMessage)}, - { 1753, 1771, -1, sizeof(::proto::Message_LocationMessage)}, - { 1783, 1801, -1, sizeof(::proto::Message_OrderMessage)}, - { 1813, 1821, -1, sizeof(::proto::Message_PaymentInviteMessage)}, - { 1823, 1830, -1, sizeof(::proto::Message_PollCreationMessage_Option)}, - { 1831, 1842, -1, sizeof(::proto::Message_PollCreationMessage)}, - { 1847, 1855, -1, sizeof(::proto::Message_PollEncValue)}, - { 1857, -1, -1, sizeof(::proto::Message_PollUpdateMessageMetadata)}, - { 1863, 1873, -1, sizeof(::proto::Message_PollUpdateMessage)}, - { 1877, -1, -1, sizeof(::proto::Message_PollVoteMessage)}, - { 1884, 1893, -1, sizeof(::proto::Message_ProductMessage_CatalogSnapshot)}, - { 1896, 1913, -1, sizeof(::proto::Message_ProductMessage_ProductSnapshot)}, - { 1924, 1936, -1, sizeof(::proto::Message_ProductMessage)}, - { 1942, 1960, -1, sizeof(::proto::Message_ProtocolMessage)}, - { 1972, 1982, -1, sizeof(::proto::Message_ReactionMessage)}, - { 1986, 1994, -1, sizeof(::proto::Message_RequestMediaUploadMessage)}, - { 1996, 2005, -1, sizeof(::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult)}, - { 2008, 2017, -1, sizeof(::proto::Message_RequestMediaUploadResponseMessage)}, - { 2020, 2033, -1, sizeof(::proto::Message_RequestPaymentMessage)}, - { 2040, 2047, -1, sizeof(::proto::Message_RequestPhoneNumberMessage)}, - { 2048, 2057, -1, sizeof(::proto::Message_SendPaymentMessage)}, - { 2060, 2068, -1, sizeof(::proto::Message_SenderKeyDistributionMessage)}, - { 2070, 2091, -1, sizeof(::proto::Message_StickerMessage)}, - { 2106, 2115, -1, sizeof(::proto::Message_StickerSyncRMRMessage)}, - { 2118, 2128, -1, sizeof(::proto::Message_TemplateButtonReplyMessage)}, - { 2132, 2147, -1, sizeof(::proto::Message_TemplateMessage_FourRowTemplate)}, - { 2155, 2171, -1, sizeof(::proto::Message_TemplateMessage_HydratedFourRowTemplate)}, - { 2180, 2191, -1, sizeof(::proto::Message_TemplateMessage)}, - { 2195, 2224, -1, sizeof(::proto::Message_VideoMessage)}, - { 2247, 2299, -1, sizeof(::proto::Message)}, - { 2345, 2355, -1, sizeof(::proto::MessageContextInfo)}, - { 2359, 2369, -1, sizeof(::proto::MessageKey)}, - { 2373, 2382, -1, sizeof(::proto::Money)}, - { 2385, 2392, -1, sizeof(::proto::MsgOpaqueData_PollOption)}, - { 2393, 2420, -1, sizeof(::proto::MsgOpaqueData)}, - { 2441, 2449, -1, sizeof(::proto::MsgRowOpaqueData)}, - { 2451, 2462, -1, sizeof(::proto::NoiseCertificate_Details)}, - { 2467, 2475, -1, sizeof(::proto::NoiseCertificate)}, - { 2477, 2487, -1, sizeof(::proto::NotificationMessageInfo)}, - { 2491, 2500, -1, sizeof(::proto::PastParticipant)}, - { 2503, 2511, -1, sizeof(::proto::PastParticipants)}, - { 2513, 2524, -1, sizeof(::proto::PaymentBackground_MediaData)}, - { 2529, 2545, -1, sizeof(::proto::PaymentBackground)}, - { 2555, 2574, -1, sizeof(::proto::PaymentInfo)}, - { 2587, 2600, -1, sizeof(::proto::PendingKeyExchange)}, - { 2607, 2616, -1, sizeof(::proto::PendingPreKey)}, - { 2619, 2628, -1, sizeof(::proto::PhotoChange)}, - { 2631, 2641, -1, sizeof(::proto::Point)}, - { 2645, 2652, -1, sizeof(::proto::PollAdditionalMetadata)}, - { 2653, 2661, -1, sizeof(::proto::PollEncValue)}, - { 2663, 2672, -1, sizeof(::proto::PollUpdate)}, - { 2675, 2684, -1, sizeof(::proto::PreKeyRecordStructure)}, - { 2687, 2695, -1, sizeof(::proto::Pushname)}, - { 2697, 2708, -1, sizeof(::proto::Reaction)}, - { 2713, 2721, -1, sizeof(::proto::RecentEmojiWeight)}, - { 2723, 2731, -1, sizeof(::proto::RecordStructure)}, - { 2733, 2741, -1, sizeof(::proto::SenderChainKey)}, - { 2743, -1, -1, sizeof(::proto::SenderKeyRecordStructure)}, - { 2750, 2760, -1, sizeof(::proto::SenderKeyStateStructure)}, - { 2764, 2772, -1, sizeof(::proto::SenderMessageKey)}, - { 2774, 2782, -1, sizeof(::proto::SenderSigningKey)}, - { 2784, 2791, -1, sizeof(::proto::ServerErrorReceipt)}, - { 2792, 2811, -1, sizeof(::proto::SessionStructure)}, - { 2824, 2835, -1, sizeof(::proto::SignedPreKeyRecordStructure)}, - { 2840, 2848, -1, sizeof(::proto::StatusPSA)}, - { 2850, 2866, -1, sizeof(::proto::StickerMetadata)}, - { 2876, 2886, -1, sizeof(::proto::SyncActionData)}, - { 2890, 2899, -1, sizeof(::proto::SyncActionValue_AgentAction)}, - { 2902, 2909, -1, sizeof(::proto::SyncActionValue_AndroidUnsupportedActions)}, - { 2910, 2918, -1, sizeof(::proto::SyncActionValue_ArchiveChatAction)}, - { 2920, 2927, -1, sizeof(::proto::SyncActionValue_ClearChatAction)}, - { 2928, 2936, -1, sizeof(::proto::SyncActionValue_ContactAction)}, - { 2938, 2945, -1, sizeof(::proto::SyncActionValue_DeleteChatAction)}, - { 2946, 2954, -1, sizeof(::proto::SyncActionValue_DeleteMessageForMeAction)}, - { 2956, 2963, -1, sizeof(::proto::SyncActionValue_KeyExpiration)}, - { 2964, 2971, -1, sizeof(::proto::SyncActionValue_LabelAssociationAction)}, - { 2972, 2982, -1, sizeof(::proto::SyncActionValue_LabelEditAction)}, - { 2986, 2993, -1, sizeof(::proto::SyncActionValue_LocaleSetting)}, - { 2994, 3002, -1, sizeof(::proto::SyncActionValue_MarkChatAsReadAction)}, - { 3004, 3012, -1, sizeof(::proto::SyncActionValue_MuteAction)}, - { 3014, 3021, -1, sizeof(::proto::SyncActionValue_NuxAction)}, - { 3022, 3029, -1, sizeof(::proto::SyncActionValue_PinAction)}, - { 3030, -1, -1, sizeof(::proto::SyncActionValue_PrimaryFeature)}, - { 3037, 3044, -1, sizeof(::proto::SyncActionValue_PrimaryVersionAction)}, - { 3045, 3052, -1, sizeof(::proto::SyncActionValue_PushNameSetting)}, - { 3053, 3064, -1, sizeof(::proto::SyncActionValue_QuickReplyAction)}, - { 3069, -1, -1, sizeof(::proto::SyncActionValue_RecentEmojiWeightsAction)}, - { 3076, 3083, -1, sizeof(::proto::SyncActionValue_SecurityNotificationSetting)}, - { 3084, 3091, -1, sizeof(::proto::SyncActionValue_StarAction)}, - { 3092, 3108, -1, sizeof(::proto::SyncActionValue_StickerAction)}, - { 3118, 3127, -1, sizeof(::proto::SyncActionValue_SubscriptionAction)}, - { 3130, 3139, -1, sizeof(::proto::SyncActionValue_SyncActionMessageRange)}, - { 3142, 3150, -1, sizeof(::proto::SyncActionValue_SyncActionMessage)}, - { 3152, 3159, -1, sizeof(::proto::SyncActionValue_TimeFormatAction)}, - { 3160, 3167, -1, sizeof(::proto::SyncActionValue_UnarchiveChatsSetting)}, - { 3168, 3175, -1, sizeof(::proto::SyncActionValue_UserStatusMuteAction)}, - { 3176, 3210, -1, sizeof(::proto::SyncActionValue)}, - { 3238, 3245, -1, sizeof(::proto::SyncdIndex)}, - { 3246, 3254, -1, sizeof(::proto::SyncdMutation)}, - { 3256, -1, -1, sizeof(::proto::SyncdMutations)}, - { 3263, 3277, -1, sizeof(::proto::SyncdPatch)}, - { 3285, 3294, -1, sizeof(::proto::SyncdRecord)}, - { 3297, 3307, -1, sizeof(::proto::SyncdSnapshot)}, - { 3311, 3318, -1, sizeof(::proto::SyncdValue)}, - { 3319, 3326, -1, sizeof(::proto::SyncdVersion)}, - { 3327, 3335, -1, sizeof(::proto::TemplateButton_CallButton)}, - { 3337, 3345, -1, sizeof(::proto::TemplateButton_QuickReplyButton)}, - { 3347, 3355, -1, sizeof(::proto::TemplateButton_URLButton)}, - { 3357, 3368, -1, sizeof(::proto::TemplateButton)}, - { 3372, 3384, -1, sizeof(::proto::UserReceipt)}, - { 3390, 3401, -1, sizeof(::proto::VerifiedNameCertificate_Details)}, - { 3406, 3415, -1, sizeof(::proto::VerifiedNameCertificate)}, - { 3418, 3426, -1, sizeof(::proto::WallpaperSettings)}, - { 3428, 3479, -1, sizeof(::proto::WebFeatures)}, - { 3524, 3573, -1, sizeof(::proto::WebMessageInfo)}, - { 3616, 3626, -1, sizeof(::proto::WebNotificationsInfo)}, -}; - -static const ::_pb::Message* const file_default_instances[] = { - &::proto::_ADVDeviceIdentity_default_instance_._instance, - &::proto::_ADVKeyIndexList_default_instance_._instance, - &::proto::_ADVSignedDeviceIdentity_default_instance_._instance, - &::proto::_ADVSignedDeviceIdentityHMAC_default_instance_._instance, - &::proto::_ADVSignedKeyIndexList_default_instance_._instance, - &::proto::_ActionLink_default_instance_._instance, - &::proto::_AutoDownloadSettings_default_instance_._instance, - &::proto::_BizAccountLinkInfo_default_instance_._instance, - &::proto::_BizAccountPayload_default_instance_._instance, - &::proto::_BizIdentityInfo_default_instance_._instance, - &::proto::_CertChain_NoiseCertificate_Details_default_instance_._instance, - &::proto::_CertChain_NoiseCertificate_default_instance_._instance, - &::proto::_CertChain_default_instance_._instance, - &::proto::_Chain_default_instance_._instance, - &::proto::_ChainKey_default_instance_._instance, - &::proto::_ClientPayload_DNSSource_default_instance_._instance, - &::proto::_ClientPayload_DevicePairingRegistrationData_default_instance_._instance, - &::proto::_ClientPayload_UserAgent_AppVersion_default_instance_._instance, - &::proto::_ClientPayload_UserAgent_default_instance_._instance, - &::proto::_ClientPayload_WebInfo_WebdPayload_default_instance_._instance, - &::proto::_ClientPayload_WebInfo_default_instance_._instance, - &::proto::_ClientPayload_default_instance_._instance, - &::proto::_ContextInfo_AdReplyInfo_default_instance_._instance, - &::proto::_ContextInfo_ExternalAdReplyInfo_default_instance_._instance, - &::proto::_ContextInfo_default_instance_._instance, - &::proto::_Conversation_default_instance_._instance, - &::proto::_DeviceListMetadata_default_instance_._instance, - &::proto::_DeviceProps_AppVersion_default_instance_._instance, - &::proto::_DeviceProps_default_instance_._instance, - &::proto::_DisappearingMode_default_instance_._instance, - &::proto::_EphemeralSetting_default_instance_._instance, - &::proto::_ExitCode_default_instance_._instance, - &::proto::_ExternalBlobReference_default_instance_._instance, - &::proto::_GlobalSettings_default_instance_._instance, - &::proto::_GroupParticipant_default_instance_._instance, - &::proto::_HandshakeMessage_ClientFinish_default_instance_._instance, - &::proto::_HandshakeMessage_ClientHello_default_instance_._instance, - &::proto::_HandshakeMessage_ServerHello_default_instance_._instance, - &::proto::_HandshakeMessage_default_instance_._instance, - &::proto::_HistorySync_default_instance_._instance, - &::proto::_HistorySyncMsg_default_instance_._instance, - &::proto::_HydratedTemplateButton_HydratedCallButton_default_instance_._instance, - &::proto::_HydratedTemplateButton_HydratedQuickReplyButton_default_instance_._instance, - &::proto::_HydratedTemplateButton_HydratedURLButton_default_instance_._instance, - &::proto::_HydratedTemplateButton_default_instance_._instance, - &::proto::_IdentityKeyPairStructure_default_instance_._instance, - &::proto::_InteractiveAnnotation_default_instance_._instance, - &::proto::_KeepInChat_default_instance_._instance, - &::proto::_KeyId_default_instance_._instance, - &::proto::_LocalizedName_default_instance_._instance, - &::proto::_Location_default_instance_._instance, - &::proto::_MediaData_default_instance_._instance, - &::proto::_MediaRetryNotification_default_instance_._instance, - &::proto::_Message_AppStateFatalExceptionNotification_default_instance_._instance, - &::proto::_Message_AppStateSyncKeyData_default_instance_._instance, - &::proto::_Message_AppStateSyncKeyFingerprint_default_instance_._instance, - &::proto::_Message_AppStateSyncKeyId_default_instance_._instance, - &::proto::_Message_AppStateSyncKeyRequest_default_instance_._instance, - &::proto::_Message_AppStateSyncKeyShare_default_instance_._instance, - &::proto::_Message_AppStateSyncKey_default_instance_._instance, - &::proto::_Message_AudioMessage_default_instance_._instance, - &::proto::_Message_ButtonsMessage_Button_ButtonText_default_instance_._instance, - &::proto::_Message_ButtonsMessage_Button_NativeFlowInfo_default_instance_._instance, - &::proto::_Message_ButtonsMessage_Button_default_instance_._instance, - &::proto::_Message_ButtonsMessage_default_instance_._instance, - &::proto::_Message_ButtonsResponseMessage_default_instance_._instance, - &::proto::_Message_Call_default_instance_._instance, - &::proto::_Message_CancelPaymentRequestMessage_default_instance_._instance, - &::proto::_Message_Chat_default_instance_._instance, - &::proto::_Message_ContactMessage_default_instance_._instance, - &::proto::_Message_ContactsArrayMessage_default_instance_._instance, - &::proto::_Message_DeclinePaymentRequestMessage_default_instance_._instance, - &::proto::_Message_DeviceSentMessage_default_instance_._instance, - &::proto::_Message_DocumentMessage_default_instance_._instance, - &::proto::_Message_ExtendedTextMessage_default_instance_._instance, - &::proto::_Message_FutureProofMessage_default_instance_._instance, - &::proto::_Message_GroupInviteMessage_default_instance_._instance, - &::proto::_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency_default_instance_._instance, - &::proto::_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_default_instance_._instance, - &::proto::_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch_default_instance_._instance, - &::proto::_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_default_instance_._instance, - &::proto::_Message_HighlyStructuredMessage_HSMLocalizableParameter_default_instance_._instance, - &::proto::_Message_HighlyStructuredMessage_default_instance_._instance, - &::proto::_Message_HistorySyncNotification_default_instance_._instance, - &::proto::_Message_ImageMessage_default_instance_._instance, - &::proto::_Message_InitialSecurityNotificationSettingSync_default_instance_._instance, - &::proto::_Message_InteractiveMessage_Body_default_instance_._instance, - &::proto::_Message_InteractiveMessage_CollectionMessage_default_instance_._instance, - &::proto::_Message_InteractiveMessage_Footer_default_instance_._instance, - &::proto::_Message_InteractiveMessage_Header_default_instance_._instance, - &::proto::_Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton_default_instance_._instance, - &::proto::_Message_InteractiveMessage_NativeFlowMessage_default_instance_._instance, - &::proto::_Message_InteractiveMessage_ShopMessage_default_instance_._instance, - &::proto::_Message_InteractiveMessage_default_instance_._instance, - &::proto::_Message_InteractiveResponseMessage_Body_default_instance_._instance, - &::proto::_Message_InteractiveResponseMessage_NativeFlowResponseMessage_default_instance_._instance, - &::proto::_Message_InteractiveResponseMessage_default_instance_._instance, - &::proto::_Message_InvoiceMessage_default_instance_._instance, - &::proto::_Message_KeepInChatMessage_default_instance_._instance, - &::proto::_Message_ListMessage_ProductListHeaderImage_default_instance_._instance, - &::proto::_Message_ListMessage_ProductListInfo_default_instance_._instance, - &::proto::_Message_ListMessage_ProductSection_default_instance_._instance, - &::proto::_Message_ListMessage_Product_default_instance_._instance, - &::proto::_Message_ListMessage_Row_default_instance_._instance, - &::proto::_Message_ListMessage_Section_default_instance_._instance, - &::proto::_Message_ListMessage_default_instance_._instance, - &::proto::_Message_ListResponseMessage_SingleSelectReply_default_instance_._instance, - &::proto::_Message_ListResponseMessage_default_instance_._instance, - &::proto::_Message_LiveLocationMessage_default_instance_._instance, - &::proto::_Message_LocationMessage_default_instance_._instance, - &::proto::_Message_OrderMessage_default_instance_._instance, - &::proto::_Message_PaymentInviteMessage_default_instance_._instance, - &::proto::_Message_PollCreationMessage_Option_default_instance_._instance, - &::proto::_Message_PollCreationMessage_default_instance_._instance, - &::proto::_Message_PollEncValue_default_instance_._instance, - &::proto::_Message_PollUpdateMessageMetadata_default_instance_._instance, - &::proto::_Message_PollUpdateMessage_default_instance_._instance, - &::proto::_Message_PollVoteMessage_default_instance_._instance, - &::proto::_Message_ProductMessage_CatalogSnapshot_default_instance_._instance, - &::proto::_Message_ProductMessage_ProductSnapshot_default_instance_._instance, - &::proto::_Message_ProductMessage_default_instance_._instance, - &::proto::_Message_ProtocolMessage_default_instance_._instance, - &::proto::_Message_ReactionMessage_default_instance_._instance, - &::proto::_Message_RequestMediaUploadMessage_default_instance_._instance, - &::proto::_Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult_default_instance_._instance, - &::proto::_Message_RequestMediaUploadResponseMessage_default_instance_._instance, - &::proto::_Message_RequestPaymentMessage_default_instance_._instance, - &::proto::_Message_RequestPhoneNumberMessage_default_instance_._instance, - &::proto::_Message_SendPaymentMessage_default_instance_._instance, - &::proto::_Message_SenderKeyDistributionMessage_default_instance_._instance, - &::proto::_Message_StickerMessage_default_instance_._instance, - &::proto::_Message_StickerSyncRMRMessage_default_instance_._instance, - &::proto::_Message_TemplateButtonReplyMessage_default_instance_._instance, - &::proto::_Message_TemplateMessage_FourRowTemplate_default_instance_._instance, - &::proto::_Message_TemplateMessage_HydratedFourRowTemplate_default_instance_._instance, - &::proto::_Message_TemplateMessage_default_instance_._instance, - &::proto::_Message_VideoMessage_default_instance_._instance, - &::proto::_Message_default_instance_._instance, - &::proto::_MessageContextInfo_default_instance_._instance, - &::proto::_MessageKey_default_instance_._instance, - &::proto::_Money_default_instance_._instance, - &::proto::_MsgOpaqueData_PollOption_default_instance_._instance, - &::proto::_MsgOpaqueData_default_instance_._instance, - &::proto::_MsgRowOpaqueData_default_instance_._instance, - &::proto::_NoiseCertificate_Details_default_instance_._instance, - &::proto::_NoiseCertificate_default_instance_._instance, - &::proto::_NotificationMessageInfo_default_instance_._instance, - &::proto::_PastParticipant_default_instance_._instance, - &::proto::_PastParticipants_default_instance_._instance, - &::proto::_PaymentBackground_MediaData_default_instance_._instance, - &::proto::_PaymentBackground_default_instance_._instance, - &::proto::_PaymentInfo_default_instance_._instance, - &::proto::_PendingKeyExchange_default_instance_._instance, - &::proto::_PendingPreKey_default_instance_._instance, - &::proto::_PhotoChange_default_instance_._instance, - &::proto::_Point_default_instance_._instance, - &::proto::_PollAdditionalMetadata_default_instance_._instance, - &::proto::_PollEncValue_default_instance_._instance, - &::proto::_PollUpdate_default_instance_._instance, - &::proto::_PreKeyRecordStructure_default_instance_._instance, - &::proto::_Pushname_default_instance_._instance, - &::proto::_Reaction_default_instance_._instance, - &::proto::_RecentEmojiWeight_default_instance_._instance, - &::proto::_RecordStructure_default_instance_._instance, - &::proto::_SenderChainKey_default_instance_._instance, - &::proto::_SenderKeyRecordStructure_default_instance_._instance, - &::proto::_SenderKeyStateStructure_default_instance_._instance, - &::proto::_SenderMessageKey_default_instance_._instance, - &::proto::_SenderSigningKey_default_instance_._instance, - &::proto::_ServerErrorReceipt_default_instance_._instance, - &::proto::_SessionStructure_default_instance_._instance, - &::proto::_SignedPreKeyRecordStructure_default_instance_._instance, - &::proto::_StatusPSA_default_instance_._instance, - &::proto::_StickerMetadata_default_instance_._instance, - &::proto::_SyncActionData_default_instance_._instance, - &::proto::_SyncActionValue_AgentAction_default_instance_._instance, - &::proto::_SyncActionValue_AndroidUnsupportedActions_default_instance_._instance, - &::proto::_SyncActionValue_ArchiveChatAction_default_instance_._instance, - &::proto::_SyncActionValue_ClearChatAction_default_instance_._instance, - &::proto::_SyncActionValue_ContactAction_default_instance_._instance, - &::proto::_SyncActionValue_DeleteChatAction_default_instance_._instance, - &::proto::_SyncActionValue_DeleteMessageForMeAction_default_instance_._instance, - &::proto::_SyncActionValue_KeyExpiration_default_instance_._instance, - &::proto::_SyncActionValue_LabelAssociationAction_default_instance_._instance, - &::proto::_SyncActionValue_LabelEditAction_default_instance_._instance, - &::proto::_SyncActionValue_LocaleSetting_default_instance_._instance, - &::proto::_SyncActionValue_MarkChatAsReadAction_default_instance_._instance, - &::proto::_SyncActionValue_MuteAction_default_instance_._instance, - &::proto::_SyncActionValue_NuxAction_default_instance_._instance, - &::proto::_SyncActionValue_PinAction_default_instance_._instance, - &::proto::_SyncActionValue_PrimaryFeature_default_instance_._instance, - &::proto::_SyncActionValue_PrimaryVersionAction_default_instance_._instance, - &::proto::_SyncActionValue_PushNameSetting_default_instance_._instance, - &::proto::_SyncActionValue_QuickReplyAction_default_instance_._instance, - &::proto::_SyncActionValue_RecentEmojiWeightsAction_default_instance_._instance, - &::proto::_SyncActionValue_SecurityNotificationSetting_default_instance_._instance, - &::proto::_SyncActionValue_StarAction_default_instance_._instance, - &::proto::_SyncActionValue_StickerAction_default_instance_._instance, - &::proto::_SyncActionValue_SubscriptionAction_default_instance_._instance, - &::proto::_SyncActionValue_SyncActionMessageRange_default_instance_._instance, - &::proto::_SyncActionValue_SyncActionMessage_default_instance_._instance, - &::proto::_SyncActionValue_TimeFormatAction_default_instance_._instance, - &::proto::_SyncActionValue_UnarchiveChatsSetting_default_instance_._instance, - &::proto::_SyncActionValue_UserStatusMuteAction_default_instance_._instance, - &::proto::_SyncActionValue_default_instance_._instance, - &::proto::_SyncdIndex_default_instance_._instance, - &::proto::_SyncdMutation_default_instance_._instance, - &::proto::_SyncdMutations_default_instance_._instance, - &::proto::_SyncdPatch_default_instance_._instance, - &::proto::_SyncdRecord_default_instance_._instance, - &::proto::_SyncdSnapshot_default_instance_._instance, - &::proto::_SyncdValue_default_instance_._instance, - &::proto::_SyncdVersion_default_instance_._instance, - &::proto::_TemplateButton_CallButton_default_instance_._instance, - &::proto::_TemplateButton_QuickReplyButton_default_instance_._instance, - &::proto::_TemplateButton_URLButton_default_instance_._instance, - &::proto::_TemplateButton_default_instance_._instance, - &::proto::_UserReceipt_default_instance_._instance, - &::proto::_VerifiedNameCertificate_Details_default_instance_._instance, - &::proto::_VerifiedNameCertificate_default_instance_._instance, - &::proto::_WallpaperSettings_default_instance_._instance, - &::proto::_WebFeatures_default_instance_._instance, - &::proto::_WebMessageInfo_default_instance_._instance, - &::proto::_WebNotificationsInfo_default_instance_._instance, -}; - -const char descriptor_table_protodef_pmsg_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = - "\n\npmsg.proto\022\005proto\"G\n\021ADVDeviceIdentity" - "\022\r\n\005rawId\030\001 \001(\r\022\021\n\ttimestamp\030\002 \001(\004\022\020\n\010ke" - "yIndex\030\003 \001(\r\"c\n\017ADVKeyIndexList\022\r\n\005rawId" - "\030\001 \001(\r\022\021\n\ttimestamp\030\002 \001(\004\022\024\n\014currentInde" - "x\030\003 \001(\r\022\030\n\014validIndexes\030\004 \003(\rB\002\020\001\"z\n\027ADV" - "SignedDeviceIdentity\022\017\n\007details\030\001 \001(\014\022\033\n" - "\023accountSignatureKey\030\002 \001(\014\022\030\n\020accountSig" - "nature\030\003 \001(\014\022\027\n\017deviceSignature\030\004 \001(\014\"<\n" - "\033ADVSignedDeviceIdentityHMAC\022\017\n\007details\030" - "\001 \001(\014\022\014\n\004hmac\030\002 \001(\014\"B\n\025ADVSignedKeyIndex" - "List\022\017\n\007details\030\001 \001(\014\022\030\n\020accountSignatur" - "e\030\002 \001(\014\".\n\nActionLink\022\013\n\003url\030\001 \001(\t\022\023\n\013bu" - "ttonTitle\030\002 \001(\t\"w\n\024AutoDownloadSettings\022" - "\026\n\016downloadImages\030\001 \001(\010\022\025\n\rdownloadAudio" - "\030\002 \001(\010\022\025\n\rdownloadVideo\030\003 \001(\010\022\031\n\021downloa" - "dDocuments\030\004 \001(\010\"\254\002\n\022BizAccountLinkInfo\022" - "\033\n\023whatsappBizAcctFbid\030\001 \001(\004\022\032\n\022whatsapp" - "AcctNumber\030\002 \001(\t\022\021\n\tissueTime\030\003 \001(\004\022>\n\013h" - "ostStorage\030\004 \001(\0162).proto.BizAccountLinkI" - "nfo.HostStorageType\022:\n\013accountType\030\005 \001(\016" - "2%.proto.BizAccountLinkInfo.AccountType\"" - "\035\n\013AccountType\022\016\n\nENTERPRISE\020\000\"/\n\017HostSt" - "orageType\022\016\n\nON_PREMISE\020\000\022\014\n\010FACEBOOK\020\001\"" - "_\n\021BizAccountPayload\0221\n\tvnameCert\030\001 \001(\0132" - "\036.proto.VerifiedNameCertificate\022\027\n\017bizAc" - "ctLinkInfo\030\002 \001(\014\"\332\003\n\017BizIdentityInfo\0229\n\006" - "vlevel\030\001 \001(\0162).proto.BizIdentityInfo.Ver" - "ifiedLevelValue\0221\n\tvnameCert\030\002 \001(\0132\036.pro" - "to.VerifiedNameCertificate\022\016\n\006signed\030\003 \001" - "(\010\022\017\n\007revoked\030\004 \001(\010\022;\n\013hostStorage\030\005 \001(\016" - "2&.proto.BizIdentityInfo.HostStorageType" - "\022=\n\014actualActors\030\006 \001(\0162\'.proto.BizIdenti" - "tyInfo.ActualActorsType\022\025\n\rprivacyModeTs" - "\030\007 \001(\004\022\027\n\017featureControls\030\010 \001(\004\"%\n\020Actua" - "lActorsType\022\010\n\004SELF\020\000\022\007\n\003BSP\020\001\"/\n\017HostSt" - "orageType\022\016\n\nON_PREMISE\020\000\022\014\n\010FACEBOOK\020\001\"" - "4\n\022VerifiedLevelValue\022\013\n\007UNKNOWN\020\000\022\007\n\003LO" - "W\020\001\022\010\n\004HIGH\020\002\"\221\002\n\tCertChain\022/\n\004leaf\030\001 \001(" - "\0132!.proto.CertChain.NoiseCertificate\0227\n\014" - "intermediate\030\002 \001(\0132!.proto.CertChain.Noi" - "seCertificate\032\231\001\n\020NoiseCertificate\022\017\n\007de" - "tails\030\001 \001(\014\022\021\n\tsignature\030\002 \001(\014\032a\n\007Detail" - "s\022\016\n\006serial\030\001 \001(\r\022\024\n\014issuerSerial\030\002 \001(\r\022" - "\013\n\003key\030\003 \001(\014\022\021\n\tnotBefore\030\004 \001(\004\022\020\n\010notAf" - "ter\030\005 \001(\004\"\215\001\n\005Chain\022\030\n\020senderRatchetKey\030" - "\001 \001(\014\022\037\n\027senderRatchetKeyPrivate\030\002 \001(\014\022!" - "\n\010chainKey\030\003 \001(\0132\017.proto.ChainKey\022&\n\013mes" - "sageKeys\030\004 \003(\0132\021.proto.MessageKey\"&\n\010Cha" - "inKey\022\r\n\005index\030\001 \001(\r\022\013\n\003key\030\002 \001(\014\"\326\031\n\rCl" - "ientPayload\022\020\n\010username\030\001 \001(\004\022\017\n\007passive" - "\030\003 \001(\010\0221\n\tuserAgent\030\005 \001(\0132\036.proto.Client" - "Payload.UserAgent\022-\n\007webInfo\030\006 \001(\0132\034.pro" - "to.ClientPayload.WebInfo\022\020\n\010pushName\030\007 \001" - "(\t\022\021\n\tsessionId\030\t \001(\017\022\024\n\014shortConnect\030\n " - "\001(\010\0225\n\013connectType\030\014 \001(\0162 .proto.ClientP" - "ayload.ConnectType\0229\n\rconnectReason\030\r \001(" - "\0162\".proto.ClientPayload.ConnectReason\022\016\n" - "\006shards\030\016 \003(\005\0221\n\tdnsSource\030\017 \001(\0132\036.proto" - ".ClientPayload.DNSSource\022\033\n\023connectAttem" - "ptCount\030\020 \001(\r\022\016\n\006device\030\022 \001(\r\022M\n\021deviceP" - "airingData\030\023 \001(\01322.proto.ClientPayload.D" - "evicePairingRegistrationData\022-\n\007product\030" - "\024 \001(\0162\034.proto.ClientPayload.Product\022\r\n\005f" - "bCat\030\025 \001(\014\022\023\n\013fbUserAgent\030\026 \001(\014\022\n\n\002oc\030\027 " - "\001(\010\022\n\n\002lc\030\030 \001(\005\022=\n\017iosAppExtension\030\036 \001(\016" - "2$.proto.ClientPayload.IOSAppExtension\022\017" - "\n\007fbAppId\030\037 \001(\004\022\022\n\nfbDeviceId\030 \001(\014\022\014\n\004p" - "ull\030! \001(\010\022\024\n\014paddingBytes\030\" \001(\014\032\277\001\n\tDNSS" - "ource\022E\n\tdnsMethod\030\017 \001(\01622.proto.ClientP" - "ayload.DNSSource.DNSResolutionMethod\022\021\n\t" - "appCached\030\020 \001(\010\"X\n\023DNSResolutionMethod\022\n" - "\n\006SYSTEM\020\000\022\n\n\006GOOGLE\020\001\022\r\n\tHARDCODED\020\002\022\014\n" - "\010OVERRIDE\020\003\022\014\n\010FALLBACK\020\004\032\256\001\n\035DevicePair" - "ingRegistrationData\022\016\n\006eRegid\030\001 \001(\014\022\020\n\010e" - "Keytype\030\002 \001(\014\022\016\n\006eIdent\030\003 \001(\014\022\017\n\007eSkeyId" - "\030\004 \001(\014\022\020\n\010eSkeyVal\030\005 \001(\014\022\020\n\010eSkeySig\030\006 \001" - "(\014\022\021\n\tbuildHash\030\007 \001(\014\022\023\n\013deviceProps\030\010 \001" - "(\014\032\370\007\n\tUserAgent\0229\n\010platform\030\001 \001(\0162\'.pro" - "to.ClientPayload.UserAgent.Platform\022=\n\na" - "ppVersion\030\002 \001(\0132).proto.ClientPayload.Us" - "erAgent.AppVersion\022\013\n\003mcc\030\003 \001(\t\022\013\n\003mnc\030\004" - " \001(\t\022\021\n\tosVersion\030\005 \001(\t\022\024\n\014manufacturer\030" - "\006 \001(\t\022\016\n\006device\030\007 \001(\t\022\025\n\rosBuildNumber\030\010" - " \001(\t\022\017\n\007phoneId\030\t \001(\t\022E\n\016releaseChannel\030" - "\n \001(\0162-.proto.ClientPayload.UserAgent.Re" - "leaseChannel\022\035\n\025localeLanguageIso6391\030\013 " - "\001(\t\022#\n\033localeCountryIso31661Alpha2\030\014 \001(\t" - "\022\023\n\013deviceBoard\030\r \001(\t\032g\n\nAppVersion\022\017\n\007p" - "rimary\030\001 \001(\r\022\021\n\tsecondary\030\002 \001(\r\022\020\n\010terti" - "ary\030\003 \001(\r\022\022\n\nquaternary\030\004 \001(\r\022\017\n\007quinary" - "\030\005 \001(\r\"\255\003\n\010Platform\022\013\n\007ANDROID\020\000\022\007\n\003IOS\020" - "\001\022\021\n\rWINDOWS_PHONE\020\002\022\016\n\nBLACKBERRY\020\003\022\017\n\013" - "BLACKBERRYX\020\004\022\007\n\003S40\020\005\022\007\n\003S60\020\006\022\021\n\rPYTHO" - "N_CLIENT\020\007\022\t\n\005TIZEN\020\010\022\016\n\nENTERPRISE\020\t\022\017\n" - "\013SMB_ANDROID\020\n\022\t\n\005KAIOS\020\013\022\013\n\007SMB_IOS\020\014\022\013" - "\n\007WINDOWS\020\r\022\007\n\003WEB\020\016\022\n\n\006PORTAL\020\017\022\021\n\rGREE" - "N_ANDROID\020\020\022\020\n\014GREEN_IPHONE\020\021\022\020\n\014BLUE_AN" - "DROID\020\022\022\017\n\013BLUE_IPHONE\020\023\022\022\n\016FBLITE_ANDRO" - "ID\020\024\022\021\n\rMLITE_ANDROID\020\025\022\022\n\016IGLITE_ANDROI" - "D\020\026\022\010\n\004PAGE\020\027\022\t\n\005MACOS\020\030\022\016\n\nOCULUS_MSG\020\031" - "\022\017\n\013OCULUS_CALL\020\032\022\t\n\005MILAN\020\033\022\010\n\004CAPI\020\034\"=" - "\n\016ReleaseChannel\022\013\n\007RELEASE\020\000\022\010\n\004BETA\020\001\022" - "\t\n\005ALPHA\020\002\022\t\n\005DEBUG\020\003\032\306\004\n\007WebInfo\022\020\n\010ref" - "Token\030\001 \001(\t\022\017\n\007version\030\002 \001(\t\022=\n\013webdPayl" - "oad\030\003 \001(\0132(.proto.ClientPayload.WebInfo." - "WebdPayload\022C\n\016webSubPlatform\030\004 \001(\0162+.pr" - "oto.ClientPayload.WebInfo.WebSubPlatform" - "\032\273\002\n\013WebdPayload\022\034\n\024usesParticipantInKey" - "\030\001 \001(\010\022\037\n\027supportsStarredMessages\030\002 \001(\010\022" - " \n\030supportsDocumentMessages\030\003 \001(\010\022\033\n\023sup" - "portsUrlMessages\030\004 \001(\010\022\032\n\022supportsMediaR" - "etry\030\005 \001(\010\022\030\n\020supportsE2EImage\030\006 \001(\010\022\030\n\020" - "supportsE2EVideo\030\007 \001(\010\022\030\n\020supportsE2EAud" - "io\030\010 \001(\010\022\033\n\023supportsE2EDocument\030\t \001(\010\022\025\n" - "\rdocumentTypes\030\n \001(\t\022\020\n\010features\030\013 \001(\014\"V" - "\n\016WebSubPlatform\022\017\n\013WEB_BROWSER\020\000\022\r\n\tAPP" - "_STORE\020\001\022\r\n\tWIN_STORE\020\002\022\n\n\006DARWIN\020\003\022\t\n\005W" - "INDA\020\004\"y\n\rConnectReason\022\010\n\004PUSH\020\000\022\022\n\016USE" - "R_ACTIVATED\020\001\022\r\n\tSCHEDULED\020\002\022\023\n\017ERROR_RE" - "CONNECT\020\003\022\022\n\016NETWORK_SWITCH\020\004\022\022\n\016PING_RE" - "CONNECT\020\005\"\260\002\n\013ConnectType\022\024\n\020CELLULAR_UN" - "KNOWN\020\000\022\020\n\014WIFI_UNKNOWN\020\001\022\021\n\rCELLULAR_ED" - "GE\020d\022\021\n\rCELLULAR_IDEN\020e\022\021\n\rCELLULAR_UMTS" - "\020f\022\021\n\rCELLULAR_EVDO\020g\022\021\n\rCELLULAR_GPRS\020h" - "\022\022\n\016CELLULAR_HSDPA\020i\022\022\n\016CELLULAR_HSUPA\020j" - "\022\021\n\rCELLULAR_HSPA\020k\022\021\n\rCELLULAR_CDMA\020l\022\022" - "\n\016CELLULAR_1XRTT\020m\022\022\n\016CELLULAR_EHRPD\020n\022\020" - "\n\014CELLULAR_LTE\020o\022\022\n\016CELLULAR_HSPAP\020p\"T\n\017" - "IOSAppExtension\022\023\n\017SHARE_EXTENSION\020\000\022\025\n\021" - "SERVICE_EXTENSION\020\001\022\025\n\021INTENTS_EXTENSION" - "\020\002\"&\n\007Product\022\014\n\010WHATSAPP\020\000\022\r\n\tMESSENGER" - "\020\001\"\231\n\n\013ContextInfo\022\020\n\010stanzaId\030\001 \001(\t\022\023\n\013" - "participant\030\002 \001(\t\022%\n\rquotedMessage\030\003 \001(\013" - "2\016.proto.Message\022\021\n\tremoteJid\030\004 \001(\t\022\024\n\014m" - "entionedJid\030\017 \003(\t\022\030\n\020conversionSource\030\022 " - "\001(\t\022\026\n\016conversionData\030\023 \001(\014\022\036\n\026conversio" - "nDelaySeconds\030\024 \001(\r\022\027\n\017forwardingScore\030\025" - " \001(\r\022\023\n\013isForwarded\030\026 \001(\010\0220\n\010quotedAd\030\027 " - "\001(\0132\036.proto.ContextInfo.AdReplyInfo\022)\n\016p" - "laceholderKey\030\030 \001(\0132\021.proto.MessageKey\022\022" - "\n\nexpiration\030\031 \001(\r\022!\n\031ephemeralSettingTi" - "mestamp\030\032 \001(\003\022\035\n\025ephemeralSharedSecret\030\033" - " \001(\014\022\?\n\017externalAdReply\030\034 \001(\0132&.proto.Co" - "ntextInfo.ExternalAdReplyInfo\022\"\n\032entryPo" - "intConversionSource\030\035 \001(\t\022\037\n\027entryPointC" - "onversionApp\030\036 \001(\t\022(\n entryPointConversi" - "onDelaySeconds\030\037 \001(\r\0221\n\020disappearingMode" - "\030 \001(\0132\027.proto.DisappearingMode\022%\n\nactio" - "nLink\030! \001(\0132\021.proto.ActionLink\022\024\n\014groupS" - "ubject\030\" \001(\t\022\026\n\016parentGroupJid\030# \001(\t\032\267\001\n" - "\013AdReplyInfo\022\026\n\016advertiserName\030\001 \001(\t\022;\n\t" - "mediaType\030\002 \001(\0162(.proto.ContextInfo.AdRe" - "plyInfo.MediaType\022\025\n\rjpegThumbnail\030\020 \001(\014" - "\022\017\n\007caption\030\021 \001(\t\"+\n\tMediaType\022\010\n\004NONE\020\000" - "\022\t\n\005IMAGE\020\001\022\t\n\005VIDEO\020\002\032\355\002\n\023ExternalAdRep" - "lyInfo\022\r\n\005title\030\001 \001(\t\022\014\n\004body\030\002 \001(\t\022C\n\tm" - "ediaType\030\003 \001(\01620.proto.ContextInfo.Exter" - "nalAdReplyInfo.MediaType\022\024\n\014thumbnailUrl" - "\030\004 \001(\t\022\020\n\010mediaUrl\030\005 \001(\t\022\021\n\tthumbnail\030\006 " - "\001(\014\022\022\n\nsourceType\030\007 \001(\t\022\020\n\010sourceId\030\010 \001(" - "\t\022\021\n\tsourceUrl\030\t \001(\t\022\031\n\021containsAutoRepl" - "y\030\n \001(\010\022\035\n\025renderLargerThumbnail\030\013 \001(\010\022\031" - "\n\021showAdAttribution\030\014 \001(\010\"+\n\tMediaType\022\010" - "\n\004NONE\020\000\022\t\n\005IMAGE\020\001\022\t\n\005VIDEO\020\002\"\261\t\n\014Conve" - "rsation\022\n\n\002id\030\001 \002(\t\022\'\n\010messages\030\002 \003(\0132\025." - "proto.HistorySyncMsg\022\016\n\006newJid\030\003 \001(\t\022\016\n\006" - "oldJid\030\004 \001(\t\022\030\n\020lastMsgTimestamp\030\005 \001(\004\022\023" - "\n\013unreadCount\030\006 \001(\r\022\020\n\010readOnly\030\007 \001(\010\022\034\n" - "\024endOfHistoryTransfer\030\010 \001(\010\022\033\n\023ephemeral" - "Expiration\030\t \001(\r\022!\n\031ephemeralSettingTime" - "stamp\030\n \001(\003\022N\n\030endOfHistoryTransferType\030" - "\013 \001(\0162,.proto.Conversation.EndOfHistoryT" - "ransferType\022\035\n\025conversationTimestamp\030\014 \001" - "(\004\022\014\n\004name\030\r \001(\t\022\r\n\005pHash\030\016 \001(\t\022\017\n\007notSp" - "am\030\017 \001(\010\022\020\n\010archived\030\020 \001(\010\0221\n\020disappeari" - "ngMode\030\021 \001(\0132\027.proto.DisappearingMode\022\032\n" - "\022unreadMentionCount\030\022 \001(\r\022\026\n\016markedAsUnr" - "ead\030\023 \001(\010\022,\n\013participant\030\024 \003(\0132\027.proto.G" - "roupParticipant\022\017\n\007tcToken\030\025 \001(\014\022\030\n\020tcTo" - "kenTimestamp\030\026 \001(\004\022!\n\031contactPrimaryIden" - "tityKey\030\027 \001(\014\022\016\n\006pinned\030\030 \001(\r\022\023\n\013muteEnd" - "Time\030\031 \001(\004\022+\n\twallpaper\030\032 \001(\0132\030.proto.Wa" - "llpaperSettings\022/\n\017mediaVisibility\030\033 \001(\016" - "2\026.proto.MediaVisibility\022\036\n\026tcTokenSende" - "rTimestamp\030\034 \001(\004\022\021\n\tsuspended\030\035 \001(\010\022\022\n\nt" - "erminated\030\036 \001(\010\022\021\n\tcreatedAt\030\037 \001(\004\022\021\n\tcr" - "eatedBy\030 \001(\t\022\023\n\013description\030! \001(\t\022\017\n\007su" - "pport\030\" \001(\010\022\025\n\risParentGroup\030# \001(\010\022\031\n\021is" - "DefaultSubgroup\030$ \001(\010\022\025\n\rparentGroupId\030%" - " \001(\t\022\023\n\013displayName\030& \001(\t\022\r\n\005pnJid\030\' \001(\t" - "\022\025\n\rselfPnExposed\030( \001(\010\"\200\001\n\030EndOfHistory" - "TransferType\0220\n,COMPLETE_BUT_MORE_MESSAG" - "ES_REMAIN_ON_PRIMARY\020\000\0222\n.COMPLETE_AND_N" - "O_MORE_MESSAGE_REMAIN_ON_PRIMARY\020\001\"\271\001\n\022D" - "eviceListMetadata\022\025\n\rsenderKeyHash\030\001 \001(\014" - "\022\027\n\017senderTimestamp\030\002 \001(\004\022\034\n\020senderKeyIn" - "dexes\030\003 \003(\rB\002\020\001\022\030\n\020recipientKeyHash\030\010 \001(" - "\014\022\032\n\022recipientTimestamp\030\t \001(\004\022\037\n\023recipie" - "ntKeyIndexes\030\n \003(\rB\002\020\001\"\275\003\n\013DeviceProps\022\n" - "\n\002os\030\001 \001(\t\022.\n\007version\030\002 \001(\0132\035.proto.Devi" - "ceProps.AppVersion\0225\n\014platformType\030\003 \001(\016" - "2\037.proto.DeviceProps.PlatformType\022\027\n\017req" - "uireFullSync\030\004 \001(\010\032g\n\nAppVersion\022\017\n\007prim" - "ary\030\001 \001(\r\022\021\n\tsecondary\030\002 \001(\r\022\020\n\010tertiary" - "\030\003 \001(\r\022\022\n\nquaternary\030\004 \001(\r\022\017\n\007quinary\030\005 " - "\001(\r\"\270\001\n\014PlatformType\022\013\n\007UNKNOWN\020\000\022\n\n\006CHR" - "OME\020\001\022\013\n\007FIREFOX\020\002\022\006\n\002IE\020\003\022\t\n\005OPERA\020\004\022\n\n" - "\006SAFARI\020\005\022\010\n\004EDGE\020\006\022\013\n\007DESKTOP\020\007\022\010\n\004IPAD" - "\020\010\022\022\n\016ANDROID_TABLET\020\t\022\t\n\005OHANA\020\n\022\t\n\005ALO" - "HA\020\013\022\014\n\010CATALINA\020\014\022\n\n\006TCL_TV\020\r\"\227\001\n\020Disap" - "pearingMode\0224\n\tinitiator\030\001 \001(\0162!.proto.D" - "isappearingMode.Initiator\"M\n\tInitiator\022\023" - "\n\017CHANGED_IN_CHAT\020\000\022\023\n\017INITIATED_BY_ME\020\001" - "\022\026\n\022INITIATED_BY_OTHER\020\002\"7\n\020EphemeralSet" - "ting\022\020\n\010duration\030\001 \001(\017\022\021\n\ttimestamp\030\002 \001(" - "\020\"&\n\010ExitCode\022\014\n\004code\030\001 \001(\004\022\014\n\004text\030\002 \001(" - "\t\"\217\001\n\025ExternalBlobReference\022\020\n\010mediaKey\030" - "\001 \001(\014\022\022\n\ndirectPath\030\002 \001(\t\022\016\n\006handle\030\003 \001(" - "\t\022\025\n\rfileSizeBytes\030\004 \001(\004\022\022\n\nfileSha256\030\005" - " \001(\014\022\025\n\rfileEncSha256\030\006 \001(\014\"\362\003\n\016GlobalSe" - "ttings\0225\n\023lightThemeWallpaper\030\001 \001(\0132\030.pr" - "oto.WallpaperSettings\022/\n\017mediaVisibility" - "\030\002 \001(\0162\026.proto.MediaVisibility\0224\n\022darkTh" - "emeWallpaper\030\003 \001(\0132\030.proto.WallpaperSett" - "ings\0225\n\020autoDownloadWiFi\030\004 \001(\0132\033.proto.A" - "utoDownloadSettings\0229\n\024autoDownloadCellu" - "lar\030\005 \001(\0132\033.proto.AutoDownloadSettings\0228" - "\n\023autoDownloadRoaming\030\006 \001(\0132\033.proto.Auto" - "DownloadSettings\022*\n\"showIndividualNotifi" - "cationsPreview\030\007 \001(\010\022%\n\035showGroupNotific" - "ationsPreview\030\010 \001(\010\022 \n\030disappearingModeD" - "uration\030\t \001(\005\022!\n\031disappearingModeTimesta" - "mp\030\n \001(\003\"\177\n\020GroupParticipant\022\017\n\007userJid\030" - "\001 \002(\t\022*\n\004rank\030\002 \001(\0162\034.proto.GroupPartici" - "pant.Rank\".\n\004Rank\022\013\n\007REGULAR\020\000\022\t\n\005ADMIN\020" - "\001\022\016\n\nSUPERADMIN\020\002\"\371\002\n\020HandshakeMessage\0228" - "\n\013clientHello\030\002 \001(\0132#.proto.HandshakeMes" - "sage.ClientHello\0228\n\013serverHello\030\003 \001(\0132#." - "proto.HandshakeMessage.ServerHello\022:\n\014cl" - "ientFinish\030\004 \001(\0132$.proto.HandshakeMessag" - "e.ClientFinish\032/\n\014ClientFinish\022\016\n\006static" - "\030\001 \001(\014\022\017\n\007payload\030\002 \001(\014\032A\n\013ClientHello\022\021" - "\n\tephemeral\030\001 \001(\014\022\016\n\006static\030\002 \001(\014\022\017\n\007pay" - "load\030\003 \001(\014\032A\n\013ServerHello\022\021\n\tephemeral\030\001" - " \001(\014\022\016\n\006static\030\002 \001(\014\022\017\n\007payload\030\003 \001(\014\"\264\004" - "\n\013HistorySync\0224\n\010syncType\030\001 \002(\0162\".proto." - "HistorySync.HistorySyncType\022*\n\rconversat" - "ions\030\002 \003(\0132\023.proto.Conversation\022/\n\020statu" - "sV3Messages\030\003 \003(\0132\025.proto.WebMessageInfo" - "\022\022\n\nchunkOrder\030\005 \001(\r\022\020\n\010progress\030\006 \001(\r\022\"" - "\n\tpushnames\030\007 \003(\0132\017.proto.Pushname\022-\n\016gl" - "obalSettings\030\010 \001(\0132\025.proto.GlobalSetting" - "s\022\032\n\022threadIdUserSecret\030\t \001(\014\022\037\n\027threadD" - "sTimeframeOffset\030\n \001(\r\022.\n\016recentStickers" - "\030\013 \003(\0132\026.proto.StickerMetadata\0221\n\020pastPa" - "rticipants\030\014 \003(\0132\027.proto.PastParticipant" - "s\"y\n\017HistorySyncType\022\025\n\021INITIAL_BOOTSTRA" - "P\020\000\022\025\n\021INITIAL_STATUS_V3\020\001\022\010\n\004FULL\020\002\022\n\n\006" - "RECENT\020\003\022\r\n\tPUSH_NAME\020\004\022\023\n\017UNBLOCKING_DA" - "TA\020\005\"L\n\016HistorySyncMsg\022&\n\007message\030\001 \001(\0132" - "\025.proto.WebMessageInfo\022\022\n\nmsgOrderId\030\002 \001" - "(\004\"\317\003\n\026HydratedTemplateButton\022\r\n\005index\030\004" - " \001(\r\022R\n\020quickReplyButton\030\001 \001(\01326.proto.H" - "ydratedTemplateButton.HydratedQuickReply" - "ButtonH\000\022D\n\turlButton\030\002 \001(\0132/.proto.Hydr" - "atedTemplateButton.HydratedURLButtonH\000\022F" - "\n\ncallButton\030\003 \001(\01320.proto.HydratedTempl" - "ateButton.HydratedCallButtonH\000\032>\n\022Hydrat" - "edCallButton\022\023\n\013displayText\030\001 \001(\t\022\023\n\013pho" - "neNumber\030\002 \001(\t\032;\n\030HydratedQuickReplyButt" - "on\022\023\n\013displayText\030\001 \001(\t\022\n\n\002id\030\002 \001(\t\0325\n\021H" - "ydratedURLButton\022\023\n\013displayText\030\001 \001(\t\022\013\n" - "\003url\030\002 \001(\tB\020\n\016hydratedButton\"A\n\030Identity" - "KeyPairStructure\022\021\n\tpublicKey\030\001 \001(\014\022\022\n\np" - "rivateKey\030\002 \001(\014\"m\n\025InteractiveAnnotation" - "\022%\n\017polygonVertices\030\001 \003(\0132\014.proto.Point\022" - "#\n\010location\030\002 \001(\0132\017.proto.LocationH\000B\010\n\006" - "action\"{\n\nKeepInChat\022!\n\010keepType\030\001 \001(\0162\017" - ".proto.KeepType\022\027\n\017serverTimestamp\030\002 \001(\003" - "\022\036\n\003key\030\003 \001(\0132\021.proto.MessageKey\022\021\n\tdevi" - "ceJid\030\004 \001(\t\"\023\n\005KeyId\022\n\n\002id\030\001 \001(\014\"=\n\rLoca" - "lizedName\022\n\n\002lg\030\001 \001(\t\022\n\n\002lc\030\002 \001(\t\022\024\n\014ver" - "ifiedName\030\003 \001(\t\"K\n\010Location\022\027\n\017degreesLa" - "titude\030\001 \001(\001\022\030\n\020degreesLongitude\030\002 \001(\001\022\014" - "\n\004name\030\003 \001(\t\"\036\n\tMediaData\022\021\n\tlocalPath\030\001" - " \001(\t\"\313\001\n\026MediaRetryNotification\022\020\n\010stanz" - "aId\030\001 \001(\t\022\022\n\ndirectPath\030\002 \001(\t\0228\n\006result\030" - "\003 \001(\0162(.proto.MediaRetryNotification.Res" - "ultType\"Q\n\nResultType\022\021\n\rGENERAL_ERROR\020\000" - "\022\013\n\007SUCCESS\020\001\022\r\n\tNOT_FOUND\020\002\022\024\n\020DECRYPTI" - "ON_ERROR\020\003\"\335\237\001\n\007Message\022\024\n\014conversation\030" - "\001 \001(\t\022Q\n\034senderKeyDistributionMessage\030\002 " - "\001(\0132+.proto.Message.SenderKeyDistributio" - "nMessage\0221\n\014imageMessage\030\003 \001(\0132\033.proto.M" - "essage.ImageMessage\0225\n\016contactMessage\030\004 " - "\001(\0132\035.proto.Message.ContactMessage\0227\n\017lo" - "cationMessage\030\005 \001(\0132\036.proto.Message.Loca" - "tionMessage\022\?\n\023extendedTextMessage\030\006 \001(\013" - "2\".proto.Message.ExtendedTextMessage\0227\n\017" - "documentMessage\030\007 \001(\0132\036.proto.Message.Do" - "cumentMessage\0221\n\014audioMessage\030\010 \001(\0132\033.pr" - "oto.Message.AudioMessage\0221\n\014videoMessage" - "\030\t \001(\0132\033.proto.Message.VideoMessage\022!\n\004c" - "all\030\n \001(\0132\023.proto.Message.Call\022!\n\004chat\030\013" - " \001(\0132\023.proto.Message.Chat\0227\n\017protocolMes" - "sage\030\014 \001(\0132\036.proto.Message.ProtocolMessa" - "ge\022A\n\024contactsArrayMessage\030\r \001(\0132#.proto" - ".Message.ContactsArrayMessage\022G\n\027highlyS" - "tructuredMessage\030\016 \001(\0132&.proto.Message.H" - "ighlyStructuredMessage\022_\n*fastRatchetKey" - "SenderKeyDistributionMessage\030\017 \001(\0132+.pro" - "to.Message.SenderKeyDistributionMessage\022" - "=\n\022sendPaymentMessage\030\020 \001(\0132!.proto.Mess" - "age.SendPaymentMessage\022\?\n\023liveLocationMe" - "ssage\030\022 \001(\0132\".proto.Message.LiveLocation" - "Message\022C\n\025requestPaymentMessage\030\026 \001(\0132$" - ".proto.Message.RequestPaymentMessage\022Q\n\034" - "declinePaymentRequestMessage\030\027 \001(\0132+.pro" - "to.Message.DeclinePaymentRequestMessage\022" - "O\n\033cancelPaymentRequestMessage\030\030 \001(\0132*.p" - "roto.Message.CancelPaymentRequestMessage" - "\0227\n\017templateMessage\030\031 \001(\0132\036.proto.Messag" - "e.TemplateMessage\0225\n\016stickerMessage\030\032 \001(" - "\0132\035.proto.Message.StickerMessage\022=\n\022grou" - "pInviteMessage\030\034 \001(\0132!.proto.Message.Gro" - "upInviteMessage\022M\n\032templateButtonReplyMe" - "ssage\030\035 \001(\0132).proto.Message.TemplateButt" - "onReplyMessage\0225\n\016productMessage\030\036 \001(\0132\035" - ".proto.Message.ProductMessage\022;\n\021deviceS" - "entMessage\030\037 \001(\0132 .proto.Message.DeviceS" - "entMessage\0225\n\022messageContextInfo\030# \001(\0132\031" - ".proto.MessageContextInfo\022/\n\013listMessage" - "\030$ \001(\0132\032.proto.Message.ListMessage\022:\n\017vi" - "ewOnceMessage\030% \001(\0132!.proto.Message.Futu" - "reProofMessage\0221\n\014orderMessage\030& \001(\0132\033.p" - "roto.Message.OrderMessage\022\?\n\023listRespons" - "eMessage\030\' \001(\0132\".proto.Message.ListRespo" - "nseMessage\022;\n\020ephemeralMessage\030( \001(\0132!.p" - "roto.Message.FutureProofMessage\0225\n\016invoi" - "ceMessage\030) \001(\0132\035.proto.Message.InvoiceM" - "essage\0225\n\016buttonsMessage\030* \001(\0132\035.proto.M" - "essage.ButtonsMessage\022E\n\026buttonsResponse" - "Message\030+ \001(\0132%.proto.Message.ButtonsRes" - "ponseMessage\022A\n\024paymentInviteMessage\030, \001" - "(\0132#.proto.Message.PaymentInviteMessage\022" - "=\n\022interactiveMessage\030- \001(\0132!.proto.Mess" - "age.InteractiveMessage\0227\n\017reactionMessag" - "e\030. \001(\0132\036.proto.Message.ReactionMessage\022" - "C\n\025stickerSyncRmrMessage\030/ \001(\0132$.proto.M" - "essage.StickerSyncRMRMessage\022M\n\032interact" - "iveResponseMessage\0300 \001(\0132).proto.Message" - ".InteractiveResponseMessage\022\?\n\023pollCreat" - "ionMessage\0301 \001(\0132\".proto.Message.PollCre" - "ationMessage\022;\n\021pollUpdateMessage\0302 \001(\0132" - " .proto.Message.PollUpdateMessage\022;\n\021kee" - "pInChatMessage\0303 \001(\0132 .proto.Message.Kee" - "pInChatMessage\022E\n\032documentWithCaptionMes" - "sage\0305 \001(\0132!.proto.Message.FutureProofMe" - "ssage\022K\n\031requestPhoneNumberMessage\0306 \001(\013" - "2(.proto.Message.RequestPhoneNumberMessa" - "ge\022<\n\021viewOnceMessageV2\0307 \001(\0132!.proto.Me" - "ssage.FutureProofMessage\032P\n\"AppStateFata" - "lExceptionNotification\022\027\n\017collectionName" - "s\030\001 \003(\t\022\021\n\ttimestamp\030\002 \001(\003\032y\n\023AppStateSy" - "ncKeyData\022\017\n\007keyData\030\001 \001(\014\022>\n\013fingerprin" - "t\030\002 \001(\0132).proto.Message.AppStateSyncKeyF" - "ingerprint\022\021\n\ttimestamp\030\003 \001(\003\032\\\n\032AppStat" - "eSyncKeyFingerprint\022\r\n\005rawId\030\001 \001(\r\022\024\n\014cu" - "rrentIndex\030\002 \001(\r\022\031\n\rdeviceIndexes\030\003 \003(\rB" - "\002\020\001\032\"\n\021AppStateSyncKeyId\022\r\n\005keyId\030\001 \001(\014\032" - "J\n\026AppStateSyncKeyRequest\0220\n\006keyIds\030\001 \003(" - "\0132 .proto.Message.AppStateSyncKeyId\032D\n\024A" - "ppStateSyncKeyShare\022,\n\004keys\030\001 \003(\0132\036.prot" - "o.Message.AppStateSyncKey\032w\n\017AppStateSyn" - "cKey\022/\n\005keyId\030\001 \001(\0132 .proto.Message.AppS" - "tateSyncKeyId\0223\n\007keyData\030\002 \001(\0132\".proto.M" - "essage.AppStateSyncKeyData\032\240\002\n\014AudioMess" - "age\022\013\n\003url\030\001 \001(\t\022\020\n\010mimetype\030\002 \001(\t\022\022\n\nfi" - "leSha256\030\003 \001(\014\022\022\n\nfileLength\030\004 \001(\004\022\017\n\007se" - "conds\030\005 \001(\r\022\013\n\003ptt\030\006 \001(\010\022\020\n\010mediaKey\030\007 \001" - "(\014\022\025\n\rfileEncSha256\030\010 \001(\014\022\022\n\ndirectPath\030" - "\t \001(\t\022\031\n\021mediaKeyTimestamp\030\n \001(\003\022\'\n\013cont" - "extInfo\030\021 \001(\0132\022.proto.ContextInfo\022\030\n\020str" - "eamingSidecar\030\022 \001(\014\022\020\n\010waveform\030\023 \001(\014\032\246\007" - "\n\016ButtonsMessage\022\023\n\013contentText\030\006 \001(\t\022\022\n" - "\nfooterText\030\007 \001(\t\022\'\n\013contextInfo\030\010 \001(\0132\022" - ".proto.ContextInfo\0225\n\007buttons\030\t \003(\0132$.pr" - "oto.Message.ButtonsMessage.Button\022<\n\nhea" - "derType\030\n \001(\0162(.proto.Message.ButtonsMes" - "sage.HeaderType\022\016\n\004text\030\001 \001(\tH\000\0229\n\017docum" - "entMessage\030\002 \001(\0132\036.proto.Message.Documen" - "tMessageH\000\0223\n\014imageMessage\030\003 \001(\0132\033.proto" - ".Message.ImageMessageH\000\0223\n\014videoMessage\030" - "\004 \001(\0132\033.proto.Message.VideoMessageH\000\0229\n\017" - "locationMessage\030\005 \001(\0132\036.proto.Message.Lo" - "cationMessageH\000\032\360\002\n\006Button\022\020\n\010buttonId\030\001" - " \001(\t\022C\n\nbuttonText\030\002 \001(\0132/.proto.Message" - ".ButtonsMessage.Button.ButtonText\0227\n\004typ" - "e\030\003 \001(\0162).proto.Message.ButtonsMessage.B" - "utton.Type\022K\n\016nativeFlowInfo\030\004 \001(\01323.pro" - "to.Message.ButtonsMessage.Button.NativeF" - "lowInfo\032!\n\nButtonText\022\023\n\013displayText\030\001 \001" - "(\t\0322\n\016NativeFlowInfo\022\014\n\004name\030\001 \001(\t\022\022\n\npa" - "ramsJson\030\002 \001(\t\"2\n\004Type\022\013\n\007UNKNOWN\020\000\022\014\n\010R" - "ESPONSE\020\001\022\017\n\013NATIVE_FLOW\020\002\"`\n\nHeaderType" - "\022\013\n\007UNKNOWN\020\000\022\t\n\005EMPTY\020\001\022\010\n\004TEXT\020\002\022\014\n\010DO" - "CUMENT\020\003\022\t\n\005IMAGE\020\004\022\t\n\005VIDEO\020\005\022\014\n\010LOCATI" - "ON\020\006B\010\n\006header\032\347\001\n\026ButtonsResponseMessag" - "e\022\030\n\020selectedButtonId\030\001 \001(\t\022\'\n\013contextIn" - "fo\030\003 \001(\0132\022.proto.ContextInfo\0228\n\004type\030\004 \001" - "(\0162*.proto.Message.ButtonsResponseMessag" - "e.Type\022\035\n\023selectedDisplayText\030\002 \001(\tH\000\"%\n" - "\004Type\022\013\n\007UNKNOWN\020\000\022\020\n\014DISPLAY_TEXT\020\001B\n\n\010" - "response\032i\n\004Call\022\017\n\007callKey\030\001 \001(\014\022\030\n\020con" - "versionSource\030\002 \001(\t\022\026\n\016conversionData\030\003 " - "\001(\014\022\036\n\026conversionDelaySeconds\030\004 \001(\r\032=\n\033C" - "ancelPaymentRequestMessage\022\036\n\003key\030\001 \001(\0132" - "\021.proto.MessageKey\032\'\n\004Chat\022\023\n\013displayNam" - "e\030\001 \001(\t\022\n\n\002id\030\002 \001(\t\032]\n\016ContactMessage\022\023\n" - "\013displayName\030\001 \001(\t\022\r\n\005vcard\030\020 \001(\t\022\'\n\013con" - "textInfo\030\021 \001(\0132\022.proto.ContextInfo\032\205\001\n\024C" - "ontactsArrayMessage\022\023\n\013displayName\030\001 \001(\t" - "\022/\n\010contacts\030\002 \003(\0132\035.proto.Message.Conta" - "ctMessage\022\'\n\013contextInfo\030\021 \001(\0132\022.proto.C" - "ontextInfo\032>\n\034DeclinePaymentRequestMessa" - "ge\022\036\n\003key\030\001 \001(\0132\021.proto.MessageKey\032[\n\021De" - "viceSentMessage\022\026\n\016destinationJid\030\001 \001(\t\022" - "\037\n\007message\030\002 \001(\0132\016.proto.Message\022\r\n\005phas" - "h\030\003 \001(\t\032\316\003\n\017DocumentMessage\022\013\n\003url\030\001 \001(\t" - "\022\020\n\010mimetype\030\002 \001(\t\022\r\n\005title\030\003 \001(\t\022\022\n\nfil" - "eSha256\030\004 \001(\014\022\022\n\nfileLength\030\005 \001(\004\022\021\n\tpag" - "eCount\030\006 \001(\r\022\020\n\010mediaKey\030\007 \001(\014\022\020\n\010fileNa" - "me\030\010 \001(\t\022\025\n\rfileEncSha256\030\t \001(\014\022\022\n\ndirec" - "tPath\030\n \001(\t\022\031\n\021mediaKeyTimestamp\030\013 \001(\003\022\024" - "\n\014contactVcard\030\014 \001(\010\022\033\n\023thumbnailDirectP" - "ath\030\r \001(\t\022\027\n\017thumbnailSha256\030\016 \001(\014\022\032\n\022th" - "umbnailEncSha256\030\017 \001(\014\022\025\n\rjpegThumbnail\030" - "\020 \001(\014\022\'\n\013contextInfo\030\021 \001(\0132\022.proto.Conte" - "xtInfo\022\027\n\017thumbnailHeight\030\022 \001(\r\022\026\n\016thumb" - "nailWidth\030\023 \001(\r\022\017\n\007caption\030\024 \001(\t\032\211\010\n\023Ext" - "endedTextMessage\022\014\n\004text\030\001 \001(\t\022\023\n\013matche" - "dText\030\002 \001(\t\022\024\n\014canonicalUrl\030\004 \001(\t\022\023\n\013des" - "cription\030\005 \001(\t\022\r\n\005title\030\006 \001(\t\022\020\n\010textArg" - "b\030\007 \001(\007\022\026\n\016backgroundArgb\030\010 \001(\007\0229\n\004font\030" - "\t \001(\0162+.proto.Message.ExtendedTextMessag" - "e.FontType\022C\n\013previewType\030\n \001(\0162..proto." - "Message.ExtendedTextMessage.PreviewType\022" - "\025\n\rjpegThumbnail\030\020 \001(\014\022\'\n\013contextInfo\030\021 " - "\001(\0132\022.proto.ContextInfo\022\027\n\017doNotPlayInli" - "ne\030\022 \001(\010\022\033\n\023thumbnailDirectPath\030\023 \001(\t\022\027\n" - "\017thumbnailSha256\030\024 \001(\014\022\032\n\022thumbnailEncSh" - "a256\030\025 \001(\014\022\020\n\010mediaKey\030\026 \001(\014\022\031\n\021mediaKey" - "Timestamp\030\027 \001(\003\022\027\n\017thumbnailHeight\030\030 \001(\r" - "\022\026\n\016thumbnailWidth\030\031 \001(\r\022S\n\023inviteLinkGr" - "oupType\030\032 \001(\01626.proto.Message.ExtendedTe" - "xtMessage.InviteLinkGroupType\022&\n\036inviteL" - "inkParentGroupSubjectV2\030\033 \001(\t\022(\n inviteL" - "inkParentGroupThumbnailV2\030\034 \001(\014\022U\n\025invit" - "eLinkGroupTypeV2\030\035 \001(\01626.proto.Message.E" - "xtendedTextMessage.InviteLinkGroupType\"v" - "\n\010FontType\022\016\n\nSANS_SERIF\020\000\022\t\n\005SERIF\020\001\022\023\n" - "\017NORICAN_REGULAR\020\002\022\021\n\rBRYNDAN_WRITE\020\003\022\025\n" - "\021BEBASNEUE_REGULAR\020\004\022\020\n\014OSWALD_HEAVY\020\005\"H" - "\n\023InviteLinkGroupType\022\013\n\007DEFAULT\020\000\022\n\n\006PA" - "RENT\020\001\022\007\n\003SUB\020\002\022\017\n\013DEFAULT_SUB\020\003\"\"\n\013Prev" - "iewType\022\010\n\004NONE\020\000\022\t\n\005VIDEO\020\001\0325\n\022FuturePr" - "oofMessage\022\037\n\007message\030\001 \001(\0132\016.proto.Mess" - "age\032\236\002\n\022GroupInviteMessage\022\020\n\010groupJid\030\001" - " \001(\t\022\022\n\ninviteCode\030\002 \001(\t\022\030\n\020inviteExpira" - "tion\030\003 \001(\003\022\021\n\tgroupName\030\004 \001(\t\022\025\n\rjpegThu" - "mbnail\030\005 \001(\014\022\017\n\007caption\030\006 \001(\t\022\'\n\013context" - "Info\030\007 \001(\0132\022.proto.ContextInfo\022>\n\tgroupT" - "ype\030\010 \001(\0162+.proto.Message.GroupInviteMes" - "sage.GroupType\"$\n\tGroupType\022\013\n\007DEFAULT\020\000" - "\022\n\n\006PARENT\020\001\032\257\013\n\027HighlyStructuredMessage" - "\022\021\n\tnamespace\030\001 \001(\t\022\023\n\013elementName\030\002 \001(\t" - "\022\016\n\006params\030\003 \003(\t\022\022\n\nfallbackLg\030\004 \001(\t\022\022\n\n" - "fallbackLc\030\005 \001(\t\022Y\n\021localizableParams\030\006 " - "\003(\0132>.proto.Message.HighlyStructuredMess" - "age.HSMLocalizableParameter\022\027\n\017determini" - "sticLg\030\007 \001(\t\022\027\n\017deterministicLc\030\010 \001(\t\0223\n" - "\013hydratedHsm\030\t \001(\0132\036.proto.Message.Templ" - "ateMessage\032\361\010\n\027HSMLocalizableParameter\022\017" - "\n\007default\030\001 \001(\t\022^\n\010currency\030\002 \001(\0132J.prot" - "o.Message.HighlyStructuredMessage.HSMLoc" - "alizableParameter.HSMCurrencyH\000\022^\n\010dateT" - "ime\030\003 \001(\0132J.proto.Message.HighlyStructur" - "edMessage.HSMLocalizableParameter.HSMDat" - "eTimeH\000\0327\n\013HSMCurrency\022\024\n\014currencyCode\030\001" - " \001(\t\022\022\n\namount1000\030\002 \001(\003\032\275\006\n\013HSMDateTime" - "\022t\n\tcomponent\030\001 \001(\0132_.proto.Message.High" - "lyStructuredMessage.HSMLocalizableParame" - "ter.HSMDateTime.HSMDateTimeComponentH\000\022t" - "\n\tunixEpoch\030\002 \001(\0132_.proto.Message.Highly" - "StructuredMessage.HSMLocalizableParamete" - "r.HSMDateTime.HSMDateTimeUnixEpochH\000\032\205\004\n" - "\024HSMDateTimeComponent\022\200\001\n\tdayOfWeek\030\001 \001(" - "\0162m.proto.Message.HighlyStructuredMessag" - "e.HSMLocalizableParameter.HSMDateTime.HS" - "MDateTimeComponent.DayOfWeekType\022\014\n\004year" - "\030\002 \001(\r\022\r\n\005month\030\003 \001(\r\022\022\n\ndayOfMonth\030\004 \001(" - "\r\022\014\n\004hour\030\005 \001(\r\022\016\n\006minute\030\006 \001(\r\022~\n\010calen" - "dar\030\007 \001(\0162l.proto.Message.HighlyStructur" - "edMessage.HSMLocalizableParameter.HSMDat" - "eTime.HSMDateTimeComponent.CalendarType\"" - ".\n\014CalendarType\022\r\n\tGREGORIAN\020\001\022\017\n\013SOLAR_" - "HIJRI\020\002\"k\n\rDayOfWeekType\022\n\n\006MONDAY\020\001\022\013\n\007" - "TUESDAY\020\002\022\r\n\tWEDNESDAY\020\003\022\014\n\010THURSDAY\020\004\022\n" - "\n\006FRIDAY\020\005\022\014\n\010SATURDAY\020\006\022\n\n\006SUNDAY\020\007\032)\n\024" - "HSMDateTimeUnixEpoch\022\021\n\ttimestamp\030\001 \001(\003B" - "\017\n\rdatetimeOneofB\014\n\nparamOneof\032\357\002\n\027Histo" - "rySyncNotification\022\022\n\nfileSha256\030\001 \001(\014\022\022" - "\n\nfileLength\030\002 \001(\004\022\020\n\010mediaKey\030\003 \001(\014\022\025\n\r" - "fileEncSha256\030\004 \001(\014\022\022\n\ndirectPath\030\005 \001(\t\022" - "H\n\010syncType\030\006 \001(\01626.proto.Message.Histor" - "ySyncNotification.HistorySyncType\022\022\n\nchu" - "nkOrder\030\007 \001(\r\022\031\n\021originalMessageId\030\010 \001(\t" - "\022\020\n\010progress\030\t \001(\r\"d\n\017HistorySyncType\022\025\n" - "\021INITIAL_BOOTSTRAP\020\000\022\025\n\021INITIAL_STATUS_V" - "3\020\001\022\010\n\004FULL\020\002\022\n\n\006RECENT\020\003\022\r\n\tPUSH_NAME\020\004" - "\032\212\005\n\014ImageMessage\022\013\n\003url\030\001 \001(\t\022\020\n\010mimety" - "pe\030\002 \001(\t\022\017\n\007caption\030\003 \001(\t\022\022\n\nfileSha256\030" - "\004 \001(\014\022\022\n\nfileLength\030\005 \001(\004\022\016\n\006height\030\006 \001(" - "\r\022\r\n\005width\030\007 \001(\r\022\020\n\010mediaKey\030\010 \001(\014\022\025\n\rfi" - "leEncSha256\030\t \001(\014\022<\n\026interactiveAnnotati" - "ons\030\n \003(\0132\034.proto.InteractiveAnnotation\022" - "\022\n\ndirectPath\030\013 \001(\t\022\031\n\021mediaKeyTimestamp" - "\030\014 \001(\003\022\025\n\rjpegThumbnail\030\020 \001(\014\022\'\n\013context" - "Info\030\021 \001(\0132\022.proto.ContextInfo\022\030\n\020firstS" - "canSidecar\030\022 \001(\014\022\027\n\017firstScanLength\030\023 \001(" - "\r\022\031\n\021experimentGroupId\030\024 \001(\r\022\024\n\014scansSid" - "ecar\030\025 \001(\014\022\023\n\013scanLengths\030\026 \003(\r\022\034\n\024midQu" - "alityFileSha256\030\027 \001(\014\022\037\n\027midQualityFileE" - "ncSha256\030\030 \001(\014\022\020\n\010viewOnce\030\031 \001(\010\022\033\n\023thum" - "bnailDirectPath\030\032 \001(\t\022\027\n\017thumbnailSha256" - "\030\033 \001(\014\022\032\n\022thumbnailEncSha256\030\034 \001(\014\022\021\n\tst" - "aticUrl\030\035 \001(\t\032M\n&InitialSecurityNotifica" - "tionSettingSync\022#\n\033securityNotificationE" - "nabled\030\001 \001(\010\032\207\n\n\022InteractiveMessage\0228\n\006h" - "eader\030\001 \001(\0132(.proto.Message.InteractiveM" - "essage.Header\0224\n\004body\030\002 \001(\0132&.proto.Mess" - "age.InteractiveMessage.Body\0228\n\006footer\030\003 " - "\001(\0132(.proto.Message.InteractiveMessage.F" - "ooter\022\'\n\013contextInfo\030\017 \001(\0132\022.proto.Conte" - "xtInfo\022N\n\025shopStorefrontMessage\030\004 \001(\0132-." - "proto.Message.InteractiveMessage.ShopMes" - "sageH\000\022P\n\021collectionMessage\030\005 \001(\01323.prot" - "o.Message.InteractiveMessage.CollectionM" - "essageH\000\022P\n\021nativeFlowMessage\030\006 \001(\01323.pr" - "oto.Message.InteractiveMessage.NativeFlo" - "wMessageH\000\032\024\n\004Body\022\014\n\004text\030\001 \001(\t\032G\n\021Coll" - "ectionMessage\022\016\n\006bizJid\030\001 \001(\t\022\n\n\002id\030\002 \001(" - "\t\022\026\n\016messageVersion\030\003 \001(\005\032\026\n\006Footer\022\014\n\004t" - "ext\030\001 \001(\t\032\214\002\n\006Header\022\r\n\005title\030\001 \001(\t\022\020\n\010s" - "ubtitle\030\002 \001(\t\022\032\n\022hasMediaAttachment\030\005 \001(" - "\010\0229\n\017documentMessage\030\003 \001(\0132\036.proto.Messa" - "ge.DocumentMessageH\000\0223\n\014imageMessage\030\004 \001" - "(\0132\033.proto.Message.ImageMessageH\000\022\027\n\rjpe" - "gThumbnail\030\006 \001(\014H\000\0223\n\014videoMessage\030\007 \001(\013" - "2\033.proto.Message.VideoMessageH\000B\007\n\005media" - "\032\331\001\n\021NativeFlowMessage\022U\n\007buttons\030\001 \003(\0132" - "D.proto.Message.InteractiveMessage.Nativ" - "eFlowMessage.NativeFlowButton\022\031\n\021message" - "ParamsJson\030\002 \001(\t\022\026\n\016messageVersion\030\003 \001(\005" - "\032:\n\020NativeFlowButton\022\014\n\004name\030\001 \001(\t\022\030\n\020bu" - "ttonParamsJson\030\002 \001(\t\032\261\001\n\013ShopMessage\022\n\n\002" - "id\030\001 \001(\t\022F\n\007surface\030\002 \001(\01625.proto.Messag" - "e.InteractiveMessage.ShopMessage.Surface" - "\022\026\n\016messageVersion\030\003 \001(\005\"6\n\007Surface\022\023\n\017U" - "NKNOWN_SURFACE\020\000\022\006\n\002FB\020\001\022\006\n\002IG\020\002\022\006\n\002WA\020\003" - "B\024\n\022interactiveMessage\032\361\002\n\032InteractiveRe" - "sponseMessage\022<\n\004body\030\001 \001(\0132..proto.Mess" - "age.InteractiveResponseMessage.Body\022\'\n\013c" - "ontextInfo\030\017 \001(\0132\022.proto.ContextInfo\022h\n\031" - "nativeFlowResponseMessage\030\002 \001(\0132C.proto." - "Message.InteractiveResponseMessage.Nativ" - "eFlowResponseMessageH\000\032\024\n\004Body\022\014\n\004text\030\001" - " \001(\t\032N\n\031NativeFlowResponseMessage\022\014\n\004nam" - "e\030\001 \001(\t\022\022\n\nparamsJson\030\002 \001(\t\022\017\n\007version\030\003" - " \001(\005B\034\n\032interactiveResponseMessage\032\364\002\n\016I" - "nvoiceMessage\022\014\n\004note\030\001 \001(\t\022\r\n\005token\030\002 \001" - "(\t\022D\n\016attachmentType\030\003 \001(\0162,.proto.Messa" - "ge.InvoiceMessage.AttachmentType\022\032\n\022atta" - "chmentMimetype\030\004 \001(\t\022\032\n\022attachmentMediaK" - "ey\030\005 \001(\014\022#\n\033attachmentMediaKeyTimestamp\030" - "\006 \001(\003\022\034\n\024attachmentFileSha256\030\007 \001(\014\022\037\n\027a" - "ttachmentFileEncSha256\030\010 \001(\014\022\034\n\024attachme" - "ntDirectPath\030\t \001(\t\022\037\n\027attachmentJpegThum" - "bnail\030\n \001(\014\"$\n\016AttachmentType\022\t\n\005IMAGE\020\000" - "\022\007\n\003PDF\020\001\032k\n\021KeepInChatMessage\022\036\n\003key\030\001 " - "\001(\0132\021.proto.MessageKey\022!\n\010keepType\030\002 \001(\016" - "2\017.proto.KeepType\022\023\n\013timestampMs\030\003 \001(\003\032\347" - "\006\n\013ListMessage\022\r\n\005title\030\001 \001(\t\022\023\n\013descrip" - "tion\030\002 \001(\t\022\022\n\nbuttonText\030\003 \001(\t\0225\n\010listTy" - "pe\030\004 \001(\0162#.proto.Message.ListMessage.Lis" - "tType\0224\n\010sections\030\005 \003(\0132\".proto.Message." - "ListMessage.Section\022C\n\017productListInfo\030\006" - " \001(\0132*.proto.Message.ListMessage.Product" - "ListInfo\022\022\n\nfooterText\030\007 \001(\t\022\'\n\013contextI" - "nfo\030\010 \001(\0132\022.proto.ContextInfo\032B\n\026Product" - "ListHeaderImage\022\021\n\tproductId\030\001 \001(\t\022\025\n\rjp" - "egThumbnail\030\002 \001(\014\032\267\001\n\017ProductListInfo\022B\n" - "\017productSections\030\001 \003(\0132).proto.Message.L" - "istMessage.ProductSection\022F\n\013headerImage" - "\030\002 \001(\01321.proto.Message.ListMessage.Produ" - "ctListHeaderImage\022\030\n\020businessOwnerJid\030\003 " - "\001(\t\032U\n\016ProductSection\022\r\n\005title\030\001 \001(\t\0224\n\010" - "products\030\002 \003(\0132\".proto.Message.ListMessa" - "ge.Product\032\034\n\007Product\022\021\n\tproductId\030\001 \001(\t" - "\0328\n\003Row\022\r\n\005title\030\001 \001(\t\022\023\n\013description\030\002 " - "\001(\t\022\r\n\005rowId\030\003 \001(\t\032F\n\007Section\022\r\n\005title\030\001" - " \001(\t\022,\n\004rows\030\002 \003(\0132\036.proto.Message.ListM" - "essage.Row\"<\n\010ListType\022\013\n\007UNKNOWN\020\000\022\021\n\rS" - "INGLE_SELECT\020\001\022\020\n\014PRODUCT_LIST\020\002\032\312\002\n\023Lis" - "tResponseMessage\022\r\n\005title\030\001 \001(\t\022=\n\010listT" - "ype\030\002 \001(\0162+.proto.Message.ListResponseMe" - "ssage.ListType\022O\n\021singleSelectReply\030\003 \001(" - "\01324.proto.Message.ListResponseMessage.Si" - "ngleSelectReply\022\'\n\013contextInfo\030\004 \001(\0132\022.p" - "roto.ContextInfo\022\023\n\013description\030\005 \001(\t\032*\n" - "\021SingleSelectReply\022\025\n\rselectedRowId\030\001 \001(" - "\t\"*\n\010ListType\022\013\n\007UNKNOWN\020\000\022\021\n\rSINGLE_SEL" - "ECT\020\001\032\236\002\n\023LiveLocationMessage\022\027\n\017degrees" - "Latitude\030\001 \001(\001\022\030\n\020degreesLongitude\030\002 \001(\001" - "\022\030\n\020accuracyInMeters\030\003 \001(\r\022\022\n\nspeedInMps" - "\030\004 \001(\002\022)\n!degreesClockwiseFromMagneticNo" - "rth\030\005 \001(\r\022\017\n\007caption\030\006 \001(\t\022\026\n\016sequenceNu" - "mber\030\007 \001(\003\022\022\n\ntimeOffset\030\010 \001(\r\022\025\n\rjpegTh" - "umbnail\030\020 \001(\014\022\'\n\013contextInfo\030\021 \001(\0132\022.pro" - "to.ContextInfo\032\252\002\n\017LocationMessage\022\027\n\017de" - "greesLatitude\030\001 \001(\001\022\030\n\020degreesLongitude\030" - "\002 \001(\001\022\014\n\004name\030\003 \001(\t\022\017\n\007address\030\004 \001(\t\022\013\n\003" - "url\030\005 \001(\t\022\016\n\006isLive\030\006 \001(\010\022\030\n\020accuracyInM" - "eters\030\007 \001(\r\022\022\n\nspeedInMps\030\010 \001(\002\022)\n!degre" - "esClockwiseFromMagneticNorth\030\t \001(\r\022\017\n\007co" - "mment\030\013 \001(\t\022\025\n\rjpegThumbnail\030\020 \001(\014\022\'\n\013co" - "ntextInfo\030\021 \001(\0132\022.proto.ContextInfo\032\226\003\n\014" - "OrderMessage\022\017\n\007orderId\030\001 \001(\t\022\021\n\tthumbna" - "il\030\002 \001(\014\022\021\n\titemCount\030\003 \001(\005\0227\n\006status\030\004 " - "\001(\0162\'.proto.Message.OrderMessage.OrderSt" - "atus\0229\n\007surface\030\005 \001(\0162(.proto.Message.Or" - "derMessage.OrderSurface\022\017\n\007message\030\006 \001(\t" - "\022\022\n\norderTitle\030\007 \001(\t\022\021\n\tsellerJid\030\010 \001(\t\022" - "\r\n\005token\030\t \001(\t\022\027\n\017totalAmount1000\030\n \001(\003\022" - "\031\n\021totalCurrencyCode\030\013 \001(\t\022\'\n\013contextInf" - "o\030\021 \001(\0132\022.proto.ContextInfo\"\032\n\013OrderStat" - "us\022\013\n\007INQUIRY\020\001\"\033\n\014OrderSurface\022\013\n\007CATAL" - "OG\020\001\032\257\001\n\024PaymentInviteMessage\022D\n\013service" - "Type\030\001 \001(\0162/.proto.Message.PaymentInvite" - "Message.ServiceType\022\027\n\017expiryTimestamp\030\002" - " \001(\003\"8\n\013ServiceType\022\013\n\007UNKNOWN\020\000\022\t\n\005FBPA" - "Y\020\001\022\010\n\004NOVI\020\002\022\007\n\003UPI\020\003\032\326\001\n\023PollCreationM" - "essage\022\016\n\006encKey\030\001 \001(\014\022\014\n\004name\030\002 \001(\t\022:\n\007" - "options\030\003 \003(\0132).proto.Message.PollCreati" - "onMessage.Option\022\036\n\026selectableOptionsCou" - "nt\030\004 \001(\r\022\'\n\013contextInfo\030\005 \001(\0132\022.proto.Co" - "ntextInfo\032\034\n\006Option\022\022\n\noptionName\030\001 \001(\t\032" - "1\n\014PollEncValue\022\022\n\nencPayload\030\001 \001(\014\022\r\n\005e" - "ncIv\030\002 \001(\014\032\033\n\031PollUpdateMessageMetadata\032" - "\310\001\n\021PollUpdateMessage\0221\n\026pollCreationMes" - "sageKey\030\001 \001(\0132\021.proto.MessageKey\022)\n\004vote" - "\030\002 \001(\0132\033.proto.Message.PollEncValue\022:\n\010m" - "etadata\030\003 \001(\0132(.proto.Message.PollUpdate" - "MessageMetadata\022\031\n\021senderTimestampMs\030\004 \001" - "(\003\032*\n\017PollVoteMessage\022\027\n\017selectedOptions" - "\030\001 \003(\014\032\367\004\n\016ProductMessage\022>\n\007product\030\001 \001" - "(\0132-.proto.Message.ProductMessage.Produc" - "tSnapshot\022\030\n\020businessOwnerJid\030\002 \001(\t\022>\n\007c" - "atalog\030\004 \001(\0132-.proto.Message.ProductMess" - "age.CatalogSnapshot\022\014\n\004body\030\005 \001(\t\022\016\n\006foo" - "ter\030\006 \001(\t\022\'\n\013contextInfo\030\021 \001(\0132\022.proto.C" - "ontextInfo\032h\n\017CatalogSnapshot\0221\n\014catalog" - "Image\030\001 \001(\0132\033.proto.Message.ImageMessage" - "\022\r\n\005title\030\002 \001(\t\022\023\n\013description\030\003 \001(\t\032\231\002\n" - "\017ProductSnapshot\0221\n\014productImage\030\001 \001(\0132\033" - ".proto.Message.ImageMessage\022\021\n\tproductId" - "\030\002 \001(\t\022\r\n\005title\030\003 \001(\t\022\023\n\013description\030\004 \001" - "(\t\022\024\n\014currencyCode\030\005 \001(\t\022\027\n\017priceAmount1" - "000\030\006 \001(\003\022\022\n\nretailerId\030\007 \001(\t\022\013\n\003url\030\010 \001" - "(\t\022\031\n\021productImageCount\030\t \001(\r\022\024\n\014firstIm" - "ageId\030\013 \001(\t\022\033\n\023salePriceAmount1000\030\014 \001(\003" - "\032\242\t\n\017ProtocolMessage\022\036\n\003key\030\001 \001(\0132\021.prot" - "o.MessageKey\0221\n\004type\030\002 \001(\0162#.proto.Messa" - "ge.ProtocolMessage.Type\022\033\n\023ephemeralExpi" - "ration\030\004 \001(\r\022!\n\031ephemeralSettingTimestam" - "p\030\005 \001(\003\022G\n\027historySyncNotification\030\006 \001(\013" - "2&.proto.Message.HistorySyncNotification" - "\022A\n\024appStateSyncKeyShare\030\007 \001(\0132#.proto.M" - "essage.AppStateSyncKeyShare\022E\n\026appStateS" - "yncKeyRequest\030\010 \001(\0132%.proto.Message.AppS" - "tateSyncKeyRequest\022e\n&initialSecurityNot" - "ificationSettingSync\030\t \001(\01325.proto.Messa" - "ge.InitialSecurityNotificationSettingSyn" - "c\022]\n\"appStateFatalExceptionNotification\030" - "\n \001(\01321.proto.Message.AppStateFatalExcep" - "tionNotification\0221\n\020disappearingMode\030\013 \001" - "(\0132\027.proto.DisappearingMode\022K\n\031requestMe" - "diaUploadMessage\030\014 \001(\0132(.proto.Message.R" - "equestMediaUploadMessage\022[\n!requestMedia" - "UploadResponseMessage\030\r \001(\01320.proto.Mess" - "age.RequestMediaUploadResponseMessage\"\205\003" - "\n\004Type\022\n\n\006REVOKE\020\000\022\025\n\021EPHEMERAL_SETTING\020" - "\003\022\033\n\027EPHEMERAL_SYNC_RESPONSE\020\004\022\035\n\031HISTOR" - "Y_SYNC_NOTIFICATION\020\005\022\034\n\030APP_STATE_SYNC_" - "KEY_SHARE\020\006\022\036\n\032APP_STATE_SYNC_KEY_REQUES" - "T\020\007\022\037\n\033MSG_FANOUT_BACKFILL_REQUEST\020\010\022.\n*" - "INITIAL_SECURITY_NOTIFICATION_SETTING_SY" - "NC\020\t\022*\n&APP_STATE_FATAL_EXCEPTION_NOTIFI" - "CATION\020\n\022\026\n\022SHARE_PHONE_NUMBER\020\013\022 \n\034REQU" - "EST_MEDIA_UPLOAD_MESSAGE\020\014\022)\n%REQUEST_ME" - "DIA_UPLOAD_RESPONSE_MESSAGE\020\r\032o\n\017Reactio" - "nMessage\022\036\n\003key\030\001 \001(\0132\021.proto.MessageKey" - "\022\014\n\004text\030\002 \001(\t\022\023\n\013groupingKey\030\003 \001(\t\022\031\n\021s" - "enderTimestampMs\030\004 \001(\003\032\\\n\031RequestMediaUp" - "loadMessage\022\022\n\nfileSha256\030\001 \003(\t\022+\n\trmrSo" - "urce\030\002 \001(\0162\030.proto.Message.RmrSource\032\362\002\n" - "!RequestMediaUploadResponseMessage\022+\n\trm" - "rSource\030\001 \001(\0162\030.proto.Message.RmrSource\022" - "\020\n\010stanzaId\030\002 \001(\t\022a\n\016reuploadResult\030\003 \003(" - "\0132I.proto.Message.RequestMediaUploadResp" - "onseMessage.RequestMediaUploadResult\032\252\001\n" - "\030RequestMediaUploadResult\022\022\n\nfileSha256\030" - "\001 \001(\t\022C\n\021mediaUploadResult\030\002 \001(\0162(.proto" - ".MediaRetryNotification.ResultType\0225\n\016st" - "ickerMessage\030\003 \001(\0132\035.proto.Message.Stick" - "erMessage\032\347\001\n\025RequestPaymentMessage\022#\n\013n" - "oteMessage\030\004 \001(\0132\016.proto.Message\022\033\n\023curr" - "encyCodeIso4217\030\001 \001(\t\022\022\n\namount1000\030\002 \001(" - "\004\022\023\n\013requestFrom\030\003 \001(\t\022\027\n\017expiryTimestam" - "p\030\005 \001(\003\022\034\n\006amount\030\006 \001(\0132\014.proto.Money\022,\n" - "\nbackground\030\007 \001(\0132\030.proto.PaymentBackgro" - "und\032D\n\031RequestPhoneNumberMessage\022\'\n\013cont" - "extInfo\030\001 \001(\0132\022.proto.ContextInfo\032\225\001\n\022Se" - "ndPaymentMessage\022#\n\013noteMessage\030\002 \001(\0132\016." - "proto.Message\022,\n\021requestMessageKey\030\003 \001(\013" - "2\021.proto.MessageKey\022,\n\nbackground\030\004 \001(\0132" - "\030.proto.PaymentBackground\032\\\n\034SenderKeyDi" - "stributionMessage\022\017\n\007groupId\030\001 \001(\t\022+\n#ax" - "olotlSenderKeyDistributionMessage\030\002 \001(\014\032" - "\326\002\n\016StickerMessage\022\013\n\003url\030\001 \001(\t\022\022\n\nfileS" - "ha256\030\002 \001(\014\022\025\n\rfileEncSha256\030\003 \001(\014\022\020\n\010me" - "diaKey\030\004 \001(\014\022\020\n\010mimetype\030\005 \001(\t\022\016\n\006height" - "\030\006 \001(\r\022\r\n\005width\030\007 \001(\r\022\022\n\ndirectPath\030\010 \001(" - "\t\022\022\n\nfileLength\030\t \001(\004\022\031\n\021mediaKeyTimesta" - "mp\030\n \001(\003\022\030\n\020firstFrameLength\030\013 \001(\r\022\031\n\021fi" - "rstFrameSidecar\030\014 \001(\014\022\022\n\nisAnimated\030\r \001(" - "\010\022\024\n\014pngThumbnail\030\020 \001(\014\022\'\n\013contextInfo\030\021" - " \001(\0132\022.proto.ContextInfo\032V\n\025StickerSyncR" - "MRMessage\022\020\n\010filehash\030\001 \003(\t\022\021\n\trmrSource" - "\030\002 \001(\t\022\030\n\020requestTimestamp\030\003 \001(\003\032\215\001\n\032Tem" - "plateButtonReplyMessage\022\022\n\nselectedId\030\001 " - "\001(\t\022\033\n\023selectedDisplayText\030\002 \001(\t\022\'\n\013cont" - "extInfo\030\003 \001(\0132\022.proto.ContextInfo\022\025\n\rsel" - "ectedIndex\030\004 \001(\r\032\304\t\n\017TemplateMessage\022\'\n\013" - "contextInfo\030\003 \001(\0132\022.proto.ContextInfo\022P\n" - "\020hydratedTemplate\030\004 \001(\01326.proto.Message." - "TemplateMessage.HydratedFourRowTemplate\022" - "I\n\017fourRowTemplate\030\001 \001(\0132..proto.Message" - ".TemplateMessage.FourRowTemplateH\000\022Y\n\027hy" - "dratedFourRowTemplate\030\002 \001(\01326.proto.Mess" - "age.TemplateMessage.HydratedFourRowTempl" - "ateH\000\032\336\003\n\017FourRowTemplate\0227\n\007content\030\006 \001" - "(\0132&.proto.Message.HighlyStructuredMessa" - "ge\0226\n\006footer\030\007 \001(\0132&.proto.Message.Highl" - "yStructuredMessage\022&\n\007buttons\030\010 \003(\0132\025.pr" - "oto.TemplateButton\0229\n\017documentMessage\030\001 " - "\001(\0132\036.proto.Message.DocumentMessageH\000\022I\n" - "\027highlyStructuredMessage\030\002 \001(\0132&.proto.M" - "essage.HighlyStructuredMessageH\000\0223\n\014imag" - "eMessage\030\003 \001(\0132\033.proto.Message.ImageMess" - "ageH\000\0223\n\014videoMessage\030\004 \001(\0132\033.proto.Mess" - "age.VideoMessageH\000\0229\n\017locationMessage\030\005 " - "\001(\0132\036.proto.Message.LocationMessageH\000B\007\n" - "\005title\032\244\003\n\027HydratedFourRowTemplate\022\033\n\023hy" - "dratedContentText\030\006 \001(\t\022\032\n\022hydratedFoote" - "rText\030\007 \001(\t\0226\n\017hydratedButtons\030\010 \003(\0132\035.p" - "roto.HydratedTemplateButton\022\022\n\ntemplateI" - "d\030\t \001(\t\0229\n\017documentMessage\030\001 \001(\0132\036.proto" - ".Message.DocumentMessageH\000\022\033\n\021hydratedTi" - "tleText\030\002 \001(\tH\000\0223\n\014imageMessage\030\003 \001(\0132\033." - "proto.Message.ImageMessageH\000\0223\n\014videoMes" - "sage\030\004 \001(\0132\033.proto.Message.VideoMessageH" - "\000\0229\n\017locationMessage\030\005 \001(\0132\036.proto.Messa" - "ge.LocationMessageH\000B\007\n\005titleB\010\n\006format\032" - "\202\005\n\014VideoMessage\022\013\n\003url\030\001 \001(\t\022\020\n\010mimetyp" - "e\030\002 \001(\t\022\022\n\nfileSha256\030\003 \001(\014\022\022\n\nfileLengt" - "h\030\004 \001(\004\022\017\n\007seconds\030\005 \001(\r\022\020\n\010mediaKey\030\006 \001" - "(\014\022\017\n\007caption\030\007 \001(\t\022\023\n\013gifPlayback\030\010 \001(\010" - "\022\016\n\006height\030\t \001(\r\022\r\n\005width\030\n \001(\r\022\025\n\rfileE" - "ncSha256\030\013 \001(\014\022<\n\026interactiveAnnotations" - "\030\014 \003(\0132\034.proto.InteractiveAnnotation\022\022\n\n" - "directPath\030\r \001(\t\022\031\n\021mediaKeyTimestamp\030\016 " - "\001(\003\022\025\n\rjpegThumbnail\030\020 \001(\014\022\'\n\013contextInf" - "o\030\021 \001(\0132\022.proto.ContextInfo\022\030\n\020streaming" - "Sidecar\030\022 \001(\014\022\?\n\016gifAttribution\030\023 \001(\0162\'." - "proto.Message.VideoMessage.Attribution\022\020" - "\n\010viewOnce\030\024 \001(\010\022\033\n\023thumbnailDirectPath\030" - "\025 \001(\t\022\027\n\017thumbnailSha256\030\026 \001(\014\022\032\n\022thumbn" - "ailEncSha256\030\027 \001(\014\022\021\n\tstaticUrl\030\030 \001(\t\"-\n" - "\013Attribution\022\010\n\004NONE\020\000\022\t\n\005GIPHY\020\001\022\t\n\005TEN" - "OR\020\002\"5\n\tRmrSource\022\024\n\020FAVORITE_STICKER\020\000\022" - "\022\n\016RECENT_STICKER\020\001\"\233\001\n\022MessageContextIn" - "fo\0225\n\022deviceListMetadata\030\001 \001(\0132\031.proto.D" - "eviceListMetadata\022!\n\031deviceListMetadataV" - "ersion\030\002 \001(\005\022\025\n\rmessageSecret\030\003 \001(\014\022\024\n\014p" - "addingBytes\030\004 \001(\014\"P\n\nMessageKey\022\021\n\tremot" - "eJid\030\001 \001(\t\022\016\n\006fromMe\030\002 \001(\010\022\n\n\002id\030\003 \001(\t\022\023" - "\n\013participant\030\004 \001(\t\"<\n\005Money\022\r\n\005value\030\001 " - "\001(\003\022\016\n\006offset\030\002 \001(\r\022\024\n\014currencyCode\030\003 \001(" - "\t\"\232\004\n\rMsgOpaqueData\022\014\n\004body\030\001 \001(\t\022\017\n\007cap" - "tion\030\003 \001(\t\022\013\n\003lng\030\005 \001(\001\022\016\n\006isLive\030\006 \001(\010\022" - "\013\n\003lat\030\007 \001(\001\022\031\n\021paymentAmount1000\030\010 \001(\005\022" - "\032\n\022paymentNoteMsgBody\030\t \001(\t\022\024\n\014canonical" - "Url\030\n \001(\t\022\023\n\013matchedText\030\013 \001(\t\022\r\n\005title\030" - "\014 \001(\t\022\023\n\013description\030\r \001(\t\022\031\n\021futureproo" - "fBuffer\030\016 \001(\014\022\021\n\tclientUrl\030\017 \001(\t\022\013\n\003loc\030" - "\020 \001(\t\022\020\n\010pollName\030\021 \001(\t\0224\n\013pollOptions\030\022" - " \003(\0132\037.proto.MsgOpaqueData.PollOption\022\"\n" - "\032pollSelectableOptionsCount\030\024 \001(\r\022\025\n\rmes" - "sageSecret\030\025 \001(\014\022\031\n\021senderTimestampMs\030\026 " - "\001(\003\022\033\n\023pollUpdateParentKey\030\027 \001(\t\022(\n\013encP" - "ollVote\030\030 \001(\0132\023.proto.PollEncValue\032\032\n\nPo" - "llOption\022\014\n\004name\030\001 \001(\t\"e\n\020MsgRowOpaqueDa" - "ta\022(\n\ncurrentMsg\030\001 \001(\0132\024.proto.MsgOpaque" - "Data\022\'\n\tquotedMsg\030\002 \001(\0132\024.proto.MsgOpaqu" - "eData\"\220\001\n\020NoiseCertificate\022\017\n\007details\030\001 " - "\001(\014\022\021\n\tsignature\030\002 \001(\014\032X\n\007Details\022\016\n\006ser" - "ial\030\001 \001(\r\022\016\n\006issuer\030\002 \001(\t\022\017\n\007expires\030\003 \001" - "(\004\022\017\n\007subject\030\004 \001(\t\022\013\n\003key\030\005 \001(\014\"\211\001\n\027Not" - "ificationMessageInfo\022\036\n\003key\030\001 \001(\0132\021.prot" - "o.MessageKey\022\037\n\007message\030\002 \001(\0132\016.proto.Me" - "ssage\022\030\n\020messageTimestamp\030\003 \001(\004\022\023\n\013parti" - "cipant\030\004 \001(\t\"\222\001\n\017PastParticipant\022\017\n\007user" - "Jid\030\001 \002(\t\0227\n\013leaveReason\030\002 \002(\0162\".proto.P" - "astParticipant.LeaveReason\022\017\n\007leaveTs\030\003 " - "\002(\004\"$\n\013LeaveReason\022\010\n\004LEFT\020\000\022\013\n\007REMOVED\020" - "\001\"V\n\020PastParticipants\022\020\n\010groupJid\030\001 \002(\t\022" - "0\n\020pastParticipants\030\002 \003(\0132\026.proto.PastPa" - "rticipant\"\243\003\n\021PaymentBackground\022\n\n\002id\030\001 " - "\001(\t\022\022\n\nfileLength\030\002 \001(\004\022\r\n\005width\030\003 \001(\r\022\016" - "\n\006height\030\004 \001(\r\022\020\n\010mimetype\030\005 \001(\t\022\027\n\017plac" - "eholderArgb\030\006 \001(\007\022\020\n\010textArgb\030\007 \001(\007\022\023\n\013s" - "ubtextArgb\030\010 \001(\007\0225\n\tmediaData\030\t \001(\0132\".pr" - "oto.PaymentBackground.MediaData\022+\n\004type\030" - "\n \001(\0162\035.proto.PaymentBackground.Type\032w\n\t" - "MediaData\022\020\n\010mediaKey\030\001 \001(\014\022\031\n\021mediaKeyT" - "imestamp\030\002 \001(\003\022\022\n\nfileSha256\030\003 \001(\014\022\025\n\rfi" - "leEncSha256\030\004 \001(\014\022\022\n\ndirectPath\030\005 \001(\t\" \n" - "\004Type\022\013\n\007UNKNOWN\020\000\022\013\n\007DEFAULT\020\001\"\325\n\n\013Paym" - "entInfo\0227\n\022currencyDeprecated\030\001 \001(\0162\033.pr" - "oto.PaymentInfo.Currency\022\022\n\namount1000\030\002" - " \001(\004\022\023\n\013receiverJid\030\003 \001(\t\022)\n\006status\030\004 \001(" - "\0162\031.proto.PaymentInfo.Status\022\034\n\024transact" - "ionTimestamp\030\005 \001(\004\022,\n\021requestMessageKey\030" - "\006 \001(\0132\021.proto.MessageKey\022\027\n\017expiryTimest" - "amp\030\007 \001(\004\022\025\n\rfutureproofed\030\010 \001(\010\022\020\n\010curr" - "ency\030\t \001(\t\022/\n\ttxnStatus\030\n \001(\0162\034.proto.Pa" - "ymentInfo.TxnStatus\022\031\n\021useNoviFiatFormat" - "\030\013 \001(\010\022#\n\rprimaryAmount\030\014 \001(\0132\014.proto.Mo" - "ney\022$\n\016exchangeAmount\030\r \001(\0132\014.proto.Mone" - "y\")\n\010Currency\022\024\n\020UNKNOWN_CURRENCY\020\000\022\007\n\003I" - "NR\020\001\"\314\001\n\006Status\022\022\n\016UNKNOWN_STATUS\020\000\022\016\n\nP" - "ROCESSING\020\001\022\010\n\004SENT\020\002\022\022\n\016NEED_TO_ACCEPT\020" - "\003\022\014\n\010COMPLETE\020\004\022\026\n\022COULD_NOT_COMPLETE\020\005\022" - "\014\n\010REFUNDED\020\006\022\013\n\007EXPIRED\020\007\022\014\n\010REJECTED\020\010" - "\022\r\n\tCANCELLED\020\t\022\025\n\021WAITING_FOR_PAYER\020\n\022\013" - "\n\007WAITING\020\013\"\231\005\n\tTxnStatus\022\013\n\007UNKNOWN\020\000\022\021" - "\n\rPENDING_SETUP\020\001\022\032\n\026PENDING_RECEIVER_SE" - "TUP\020\002\022\010\n\004INIT\020\003\022\013\n\007SUCCESS\020\004\022\r\n\tCOMPLETE" - "D\020\005\022\n\n\006FAILED\020\006\022\017\n\013FAILED_RISK\020\007\022\025\n\021FAIL" - "ED_PROCESSING\020\010\022\036\n\032FAILED_RECEIVER_PROCE" - "SSING\020\t\022\r\n\tFAILED_DA\020\n\022\023\n\017FAILED_DA_FINA" - "L\020\013\022\020\n\014REFUNDED_TXN\020\014\022\021\n\rREFUND_FAILED\020\r" - "\022\034\n\030REFUND_FAILED_PROCESSING\020\016\022\024\n\020REFUND" - "_FAILED_DA\020\017\022\017\n\013EXPIRED_TXN\020\020\022\021\n\rAUTH_CA" - "NCELED\020\021\022!\n\035AUTH_CANCEL_FAILED_PROCESSIN" - "G\020\022\022\026\n\022AUTH_CANCEL_FAILED\020\023\022\020\n\014COLLECT_I" - "NIT\020\024\022\023\n\017COLLECT_SUCCESS\020\025\022\022\n\016COLLECT_FA" - "ILED\020\026\022\027\n\023COLLECT_FAILED_RISK\020\027\022\024\n\020COLLE" - "CT_REJECTED\020\030\022\023\n\017COLLECT_EXPIRED\020\031\022\024\n\020CO" - "LLECT_CANCELED\020\032\022\026\n\022COLLECT_CANCELLING\020\033" - "\022\r\n\tIN_REVIEW\020\034\022\024\n\020REVERSAL_SUCCESS\020\035\022\024\n" - "\020REVERSAL_PENDING\020\036\022\022\n\016REFUND_PENDING\020\037\"" - "\315\001\n\022PendingKeyExchange\022\020\n\010sequence\030\001 \001(\r" - "\022\024\n\014localBaseKey\030\002 \001(\014\022\033\n\023localBaseKeyPr" - "ivate\030\003 \001(\014\022\027\n\017localRatchetKey\030\004 \001(\014\022\036\n\026" - "localRatchetKeyPrivate\030\005 \001(\014\022\030\n\020localIde" - "ntityKey\030\007 \001(\014\022\037\n\027localIdentityKeyPrivat" - "e\030\010 \001(\014\"J\n\rPendingPreKey\022\020\n\010preKeyId\030\001 \001" - "(\r\022\026\n\016signedPreKeyId\030\003 \001(\005\022\017\n\007baseKey\030\002 " - "\001(\014\"E\n\013PhotoChange\022\020\n\010oldPhoto\030\001 \001(\014\022\020\n\010" - "newPhoto\030\002 \001(\014\022\022\n\nnewPhotoId\030\003 \001(\r\"G\n\005Po" - "int\022\023\n\013xDeprecated\030\001 \001(\005\022\023\n\013yDeprecated\030" - "\002 \001(\005\022\t\n\001x\030\003 \001(\001\022\t\n\001y\030\004 \001(\001\"1\n\026PollAddit" - "ionalMetadata\022\027\n\017pollInvalidated\030\001 \001(\010\"1" - "\n\014PollEncValue\022\022\n\nencPayload\030\001 \001(\014\022\r\n\005en" - "cIv\030\002 \001(\014\"\206\001\n\nPollUpdate\022/\n\024pollUpdateMe" - "ssageKey\030\001 \001(\0132\021.proto.MessageKey\022,\n\004vot" - "e\030\002 \001(\0132\036.proto.Message.PollVoteMessage\022" - "\031\n\021senderTimestampMs\030\003 \001(\003\"J\n\025PreKeyReco" - "rdStructure\022\n\n\002id\030\001 \001(\r\022\021\n\tpublicKey\030\002 \001" - "(\014\022\022\n\nprivateKey\030\003 \001(\014\"(\n\010Pushname\022\n\n\002id" - "\030\001 \001(\t\022\020\n\010pushname\030\002 \001(\t\"x\n\010Reaction\022\036\n\003" - "key\030\001 \001(\0132\021.proto.MessageKey\022\014\n\004text\030\002 \001" - "(\t\022\023\n\013groupingKey\030\003 \001(\t\022\031\n\021senderTimesta" - "mpMs\030\004 \001(\003\022\016\n\006unread\030\005 \001(\010\"2\n\021RecentEmoj" - "iWeight\022\r\n\005emoji\030\001 \001(\t\022\016\n\006weight\030\002 \001(\002\"u" - "\n\017RecordStructure\022/\n\016currentSession\030\001 \001(" - "\0132\027.proto.SessionStructure\0221\n\020previousSe" - "ssions\030\002 \003(\0132\027.proto.SessionStructure\"1\n" - "\016SenderChainKey\022\021\n\titeration\030\001 \001(\r\022\014\n\004se" - "ed\030\002 \001(\014\"S\n\030SenderKeyRecordStructure\0227\n\017" - "senderKeyStates\030\001 \003(\0132\036.proto.SenderKeyS" - "tateStructure\"\304\001\n\027SenderKeyStateStructur" - "e\022\023\n\013senderKeyId\030\001 \001(\r\022-\n\016senderChainKey" - "\030\002 \001(\0132\025.proto.SenderChainKey\0221\n\020senderS" - "igningKey\030\003 \001(\0132\027.proto.SenderSigningKey" - "\0222\n\021senderMessageKeys\030\004 \003(\0132\027.proto.Send" - "erMessageKey\"3\n\020SenderMessageKey\022\021\n\titer" - "ation\030\001 \001(\r\022\014\n\004seed\030\002 \001(\014\"3\n\020SenderSigni" - "ngKey\022\016\n\006public\030\001 \001(\014\022\017\n\007private\030\002 \001(\014\"&" - "\n\022ServerErrorReceipt\022\020\n\010stanzaId\030\001 \001(\t\"\243" - "\003\n\020SessionStructure\022\026\n\016sessionVersion\030\001 " - "\001(\r\022\033\n\023localIdentityPublic\030\002 \001(\014\022\034\n\024remo" - "teIdentityPublic\030\003 \001(\014\022\017\n\007rootKey\030\004 \001(\014\022" - "\027\n\017previousCounter\030\005 \001(\r\022!\n\013senderChain\030" - "\006 \001(\0132\014.proto.Chain\022$\n\016receiverChains\030\007 " - "\003(\0132\014.proto.Chain\0225\n\022pendingKeyExchange\030" - "\010 \001(\0132\031.proto.PendingKeyExchange\022+\n\rpend" - "ingPreKey\030\t \001(\0132\024.proto.PendingPreKey\022\034\n" - "\024remoteRegistrationId\030\n \001(\r\022\033\n\023localRegi" - "strationId\030\013 \001(\r\022\024\n\014needsRefresh\030\014 \001(\010\022\024" - "\n\014aliceBaseKey\030\r \001(\014\"v\n\033SignedPreKeyReco" - "rdStructure\022\n\n\002id\030\001 \001(\r\022\021\n\tpublicKey\030\002 \001" - "(\014\022\022\n\nprivateKey\030\003 \001(\014\022\021\n\tsignature\030\004 \001(" - "\014\022\021\n\ttimestamp\030\005 \001(\006\"D\n\tStatusPSA\022\022\n\ncam" - "paignId\030, \002(\004\022#\n\033campaignExpirationTimes" - "tamp\030- \001(\004\"\304\001\n\017StickerMetadata\022\013\n\003url\030\001 " - "\001(\t\022\022\n\nfileSha256\030\002 \001(\014\022\025\n\rfileEncSha256" - "\030\003 \001(\014\022\020\n\010mediaKey\030\004 \001(\014\022\020\n\010mimetype\030\005 \001" - "(\t\022\016\n\006height\030\006 \001(\r\022\r\n\005width\030\007 \001(\r\022\022\n\ndir" - "ectPath\030\010 \001(\t\022\022\n\nfileLength\030\t \001(\004\022\016\n\006wei" - "ght\030\n \001(\002\"h\n\016SyncActionData\022\r\n\005index\030\001 \001" - "(\014\022%\n\005value\030\002 \001(\0132\026.proto.SyncActionValu" - "e\022\017\n\007padding\030\003 \001(\014\022\017\n\007version\030\004 \001(\005\"\235\036\n\017" - "SyncActionValue\022\021\n\ttimestamp\030\001 \001(\003\0225\n\nst" - "arAction\030\002 \001(\0132!.proto.SyncActionValue.S" - "tarAction\022;\n\rcontactAction\030\003 \001(\0132$.proto" - ".SyncActionValue.ContactAction\0225\n\nmuteAc" - "tion\030\004 \001(\0132!.proto.SyncActionValue.MuteA" - "ction\0223\n\tpinAction\030\005 \001(\0132 .proto.SyncAct" - "ionValue.PinAction\022W\n\033securityNotificati" - "onSetting\030\006 \001(\01322.proto.SyncActionValue." - "SecurityNotificationSetting\022\?\n\017pushNameS" - "etting\030\007 \001(\0132&.proto.SyncActionValue.Pus" - "hNameSetting\022A\n\020quickReplyAction\030\010 \001(\0132\'" - ".proto.SyncActionValue.QuickReplyAction\022" - "Q\n\030recentEmojiWeightsAction\030\013 \001(\0132/.prot" - "o.SyncActionValue.RecentEmojiWeightsActi" - "on\022\?\n\017labelEditAction\030\016 \001(\0132&.proto.Sync" - "ActionValue.LabelEditAction\022M\n\026labelAsso" - "ciationAction\030\017 \001(\0132-.proto.SyncActionVa" - "lue.LabelAssociationAction\022;\n\rlocaleSett" - "ing\030\020 \001(\0132$.proto.SyncActionValue.Locale" - "Setting\022C\n\021archiveChatAction\030\021 \001(\0132(.pro" - "to.SyncActionValue.ArchiveChatAction\022Q\n\030" - "deleteMessageForMeAction\030\022 \001(\0132/.proto.S" - "yncActionValue.DeleteMessageForMeAction\022" - ";\n\rkeyExpiration\030\023 \001(\0132$.proto.SyncActio" - "nValue.KeyExpiration\022I\n\024markChatAsReadAc" - "tion\030\024 \001(\0132+.proto.SyncActionValue.MarkC" - "hatAsReadAction\022\?\n\017clearChatAction\030\025 \001(\013" - "2&.proto.SyncActionValue.ClearChatAction" - "\022A\n\020deleteChatAction\030\026 \001(\0132\'.proto.SyncA" - "ctionValue.DeleteChatAction\022K\n\025unarchive" - "ChatsSetting\030\027 \001(\0132,.proto.SyncActionVal" - "ue.UnarchiveChatsSetting\022=\n\016primaryFeatu" - "re\030\030 \001(\0132%.proto.SyncActionValue.Primary" - "Feature\022S\n\031androidUnsupportedActions\030\032 \001" - "(\01320.proto.SyncActionValue.AndroidUnsupp" - "ortedActions\0227\n\013agentAction\030\033 \001(\0132\".prot" - "o.SyncActionValue.AgentAction\022E\n\022subscri" - "ptionAction\030\034 \001(\0132).proto.SyncActionValu" - "e.SubscriptionAction\022I\n\024userStatusMuteAc" - "tion\030\035 \001(\0132+.proto.SyncActionValue.UserS" - "tatusMuteAction\022A\n\020timeFormatAction\030\036 \001(" - "\0132\'.proto.SyncActionValue.TimeFormatActi" - "on\0223\n\tnuxAction\030\037 \001(\0132 .proto.SyncAction" - "Value.NuxAction\022I\n\024primaryVersionAction\030" - " \001(\0132+.proto.SyncActionValue.PrimaryVer" - "sionAction\022;\n\rstickerAction\030! \001(\0132$.prot" - "o.SyncActionValue.StickerAction\032@\n\013Agent" - "Action\022\014\n\004name\030\001 \001(\t\022\020\n\010deviceID\030\002 \001(\005\022\021" - "\n\tisDeleted\030\003 \001(\010\032,\n\031AndroidUnsupportedA" - "ctions\022\017\n\007allowed\030\001 \001(\010\032j\n\021ArchiveChatAc" - "tion\022\020\n\010archived\030\001 \001(\010\022C\n\014messageRange\030\002" - " \001(\0132-.proto.SyncActionValue.SyncActionM" - "essageRange\032V\n\017ClearChatAction\022C\n\014messag" - "eRange\030\001 \001(\0132-.proto.SyncActionValue.Syn" - "cActionMessageRange\0324\n\rContactAction\022\020\n\010" - "fullName\030\001 \001(\t\022\021\n\tfirstName\030\002 \001(\t\032W\n\020Del" - "eteChatAction\022C\n\014messageRange\030\001 \001(\0132-.pr" - "oto.SyncActionValue.SyncActionMessageRan" - "ge\032I\n\030DeleteMessageForMeAction\022\023\n\013delete" - "Media\030\001 \001(\010\022\030\n\020messageTimestamp\030\002 \001(\003\032(\n" - "\rKeyExpiration\022\027\n\017expiredKeyEpoch\030\001 \001(\005\032" - ")\n\026LabelAssociationAction\022\017\n\007labeled\030\001 \001" - "(\010\032U\n\017LabelEditAction\022\014\n\004name\030\001 \001(\t\022\r\n\005c" - "olor\030\002 \001(\005\022\024\n\014predefinedId\030\003 \001(\005\022\017\n\007dele" - "ted\030\004 \001(\010\032\037\n\rLocaleSetting\022\016\n\006locale\030\001 \001" - "(\t\032i\n\024MarkChatAsReadAction\022\014\n\004read\030\001 \001(\010" - "\022C\n\014messageRange\030\002 \001(\0132-.proto.SyncActio" - "nValue.SyncActionMessageRange\0325\n\nMuteAct" - "ion\022\r\n\005muted\030\001 \001(\010\022\030\n\020muteEndTimestamp\030\002" - " \001(\003\032!\n\tNuxAction\022\024\n\014acknowledged\030\001 \001(\010\032" - "\033\n\tPinAction\022\016\n\006pinned\030\001 \001(\010\032\037\n\016PrimaryF" - "eature\022\r\n\005flags\030\001 \003(\t\032\'\n\024PrimaryVersionA" - "ction\022\017\n\007version\030\001 \001(\t\032\037\n\017PushNameSettin" - "g\022\014\n\004name\030\001 \001(\t\032g\n\020QuickReplyAction\022\020\n\010s" - "hortcut\030\001 \001(\t\022\017\n\007message\030\002 \001(\t\022\020\n\010keywor" - "ds\030\003 \003(\t\022\r\n\005count\030\004 \001(\005\022\017\n\007deleted\030\005 \001(\010" - "\032E\n\030RecentEmojiWeightsAction\022)\n\007weights\030" - "\001 \003(\0132\030.proto.RecentEmojiWeight\0327\n\033Secur" - "ityNotificationSetting\022\030\n\020showNotificati" - "on\030\001 \001(\010\032\035\n\nStarAction\022\017\n\007starred\030\001 \001(\010\032" - "\310\001\n\rStickerAction\022\013\n\003url\030\001 \001(\t\022\025\n\rfileEn" - "cSha256\030\002 \001(\014\022\020\n\010mediaKey\030\003 \001(\014\022\020\n\010mimet" - "ype\030\004 \001(\t\022\016\n\006height\030\005 \001(\r\022\r\n\005width\030\006 \001(\r" - "\022\022\n\ndirectPath\030\007 \001(\t\022\022\n\nfileLength\030\010 \001(\004" - "\022\022\n\nisFavorite\030\t \001(\010\022\024\n\014deviceIdHint\030\n \001" - "(\r\032[\n\022SubscriptionAction\022\025\n\risDeactivate" - "d\030\001 \001(\010\022\026\n\016isAutoRenewing\030\002 \001(\010\022\026\n\016expir" - "ationDate\030\003 \001(\003\032\226\001\n\026SyncActionMessageRan" - "ge\022\034\n\024lastMessageTimestamp\030\001 \001(\003\022\"\n\032last" - "SystemMessageTimestamp\030\002 \001(\003\022:\n\010messages" - "\030\003 \003(\0132(.proto.SyncActionValue.SyncActio" - "nMessage\032F\n\021SyncActionMessage\022\036\n\003key\030\001 \001" - "(\0132\021.proto.MessageKey\022\021\n\ttimestamp\030\002 \001(\003" - "\0329\n\020TimeFormatAction\022%\n\035isTwentyFourHour" - "FormatEnabled\030\001 \001(\010\032/\n\025UnarchiveChatsSet" - "ting\022\026\n\016unarchiveChats\030\001 \001(\010\032%\n\024UserStat" - "usMuteAction\022\r\n\005muted\030\001 \001(\010\"\032\n\nSyncdInde" - "x\022\014\n\004blob\030\001 \001(\014\"\222\001\n\rSyncdMutation\0226\n\tope" - "ration\030\001 \001(\0162#.proto.SyncdMutation.Syncd" - "Operation\022\"\n\006record\030\002 \001(\0132\022.proto.SyncdR" - "ecord\"%\n\016SyncdOperation\022\007\n\003SET\020\000\022\n\n\006REMO" - "VE\020\001\"9\n\016SyncdMutations\022\'\n\tmutations\030\001 \003(" - "\0132\024.proto.SyncdMutation\"\220\002\n\nSyncdPatch\022$" - "\n\007version\030\001 \001(\0132\023.proto.SyncdVersion\022\'\n\t" - "mutations\030\002 \003(\0132\024.proto.SyncdMutation\0227\n" - "\021externalMutations\030\003 \001(\0132\034.proto.Externa" - "lBlobReference\022\023\n\013snapshotMac\030\004 \001(\014\022\020\n\010p" - "atchMac\030\005 \001(\014\022\033\n\005keyId\030\006 \001(\0132\014.proto.Key" - "Id\022!\n\010exitCode\030\007 \001(\0132\017.proto.ExitCode\022\023\n" - "\013deviceIndex\030\010 \001(\r\"n\n\013SyncdRecord\022 \n\005ind" - "ex\030\001 \001(\0132\021.proto.SyncdIndex\022 \n\005value\030\002 \001" - "(\0132\021.proto.SyncdValue\022\033\n\005keyId\030\003 \001(\0132\014.p" - "roto.KeyId\"\204\001\n\rSyncdSnapshot\022$\n\007version\030" - "\001 \001(\0132\023.proto.SyncdVersion\022#\n\007records\030\002 " - "\003(\0132\022.proto.SyncdRecord\022\013\n\003mac\030\003 \001(\014\022\033\n\005" - "keyId\030\004 \001(\0132\014.proto.KeyId\"\032\n\nSyncdValue\022" - "\014\n\004blob\030\001 \001(\014\"\037\n\014SyncdVersion\022\017\n\007version" - "\030\001 \001(\004\"\300\004\n\016TemplateButton\022\r\n\005index\030\004 \001(\r" - "\022B\n\020quickReplyButton\030\001 \001(\0132&.proto.Templ" - "ateButton.QuickReplyButtonH\000\0224\n\turlButto" - "n\030\002 \001(\0132\037.proto.TemplateButton.URLButton" - "H\000\0226\n\ncallButton\030\003 \001(\0132 .proto.TemplateB" - "utton.CallButtonH\000\032\206\001\n\nCallButton\022;\n\013dis" - "playText\030\001 \001(\0132&.proto.Message.HighlyStr" - "ucturedMessage\022;\n\013phoneNumber\030\002 \001(\0132&.pr" - "oto.Message.HighlyStructuredMessage\032[\n\020Q" - "uickReplyButton\022;\n\013displayText\030\001 \001(\0132&.p" - "roto.Message.HighlyStructuredMessage\022\n\n\002" - "id\030\002 \001(\t\032}\n\tURLButton\022;\n\013displayText\030\001 \001" - "(\0132&.proto.Message.HighlyStructuredMessa" - "ge\0223\n\003url\030\002 \001(\0132&.proto.Message.HighlySt" - "ructuredMessageB\010\n\006button\"\236\001\n\013UserReceip" - "t\022\017\n\007userJid\030\001 \002(\t\022\030\n\020receiptTimestamp\030\002" - " \001(\003\022\025\n\rreadTimestamp\030\003 \001(\003\022\027\n\017playedTim" - "estamp\030\004 \001(\003\022\030\n\020pendingDeviceJid\030\005 \003(\t\022\032" - "\n\022deliveredDeviceJid\030\006 \003(\t\"\331\001\n\027VerifiedN" - "ameCertificate\022\017\n\007details\030\001 \001(\014\022\021\n\tsigna" - "ture\030\002 \001(\014\022\027\n\017serverSignature\030\003 \001(\014\032\200\001\n\007" - "Details\022\016\n\006serial\030\001 \001(\004\022\016\n\006issuer\030\002 \001(\t\022" - "\024\n\014verifiedName\030\004 \001(\t\022,\n\016localizedNames\030" - "\010 \003(\0132\024.proto.LocalizedName\022\021\n\tissueTime" - "\030\n \001(\004\"6\n\021WallpaperSettings\022\020\n\010filename\030" - "\001 \001(\t\022\017\n\007opacity\030\002 \001(\r\"\333\022\n\013WebFeatures\022." - "\n\rlabelsDisplay\030\001 \001(\0162\027.proto.WebFeature" - "s.Flag\0227\n\026voipIndividualOutgoing\030\002 \001(\0162\027" - ".proto.WebFeatures.Flag\022)\n\010groupsV3\030\003 \001(" - "\0162\027.proto.WebFeatures.Flag\022/\n\016groupsV3Cr" - "eate\030\004 \001(\0162\027.proto.WebFeatures.Flag\022/\n\016c" - "hangeNumberV2\030\005 \001(\0162\027.proto.WebFeatures." - "Flag\0227\n\026queryStatusV3Thumbnail\030\006 \001(\0162\027.p" - "roto.WebFeatures.Flag\022.\n\rliveLocations\030\007" - " \001(\0162\027.proto.WebFeatures.Flag\022+\n\nqueryVn" - "ame\030\010 \001(\0162\027.proto.WebFeatures.Flag\0227\n\026vo" - "ipIndividualIncoming\030\t \001(\0162\027.proto.WebFe" - "atures.Flag\0222\n\021quickRepliesQuery\030\n \001(\0162\027" - ".proto.WebFeatures.Flag\022)\n\010payments\030\013 \001(" - "\0162\027.proto.WebFeatures.Flag\0221\n\020stickerPac" - "kQuery\030\014 \001(\0162\027.proto.WebFeatures.Flag\0223\n" - "\022liveLocationsFinal\030\r \001(\0162\027.proto.WebFea" - "tures.Flag\022+\n\nlabelsEdit\030\016 \001(\0162\027.proto.W" - "ebFeatures.Flag\022,\n\013mediaUpload\030\017 \001(\0162\027.p" - "roto.WebFeatures.Flag\022<\n\033mediaUploadRich" - "QuickReplies\030\022 \001(\0162\027.proto.WebFeatures.F" - "lag\022(\n\007vnameV2\030\023 \001(\0162\027.proto.WebFeatures" - ".Flag\0221\n\020videoPlaybackUrl\030\024 \001(\0162\027.proto." - "WebFeatures.Flag\022.\n\rstatusRanking\030\025 \001(\0162" - "\027.proto.WebFeatures.Flag\0224\n\023voipIndividu" - "alVideo\030\026 \001(\0162\027.proto.WebFeatures.Flag\0223" - "\n\022thirdPartyStickers\030\027 \001(\0162\027.proto.WebFe" - "atures.Flag\022;\n\032frequentlyForwardedSettin" - "g\030\030 \001(\0162\027.proto.WebFeatures.Flag\0227\n\026grou" - "psV4JoinPermission\030\031 \001(\0162\027.proto.WebFeat" - "ures.Flag\022/\n\016recentStickers\030\032 \001(\0162\027.prot" - "o.WebFeatures.Flag\022(\n\007catalog\030\033 \001(\0162\027.pr" - "oto.WebFeatures.Flag\0220\n\017starredStickers\030" - "\034 \001(\0162\027.proto.WebFeatures.Flag\022.\n\rvoipGr" - "oupCall\030\035 \001(\0162\027.proto.WebFeatures.Flag\0220" - "\n\017templateMessage\030\036 \001(\0162\027.proto.WebFeatu" - "res.Flag\022=\n\034templateMessageInteractivity" - "\030\037 \001(\0162\027.proto.WebFeatures.Flag\0222\n\021ephem" - "eralMessages\030 \001(\0162\027.proto.WebFeatures.F" - "lag\0224\n\023e2ENotificationSync\030! \001(\0162\027.proto" - ".WebFeatures.Flag\0221\n\020recentStickersV2\030\" " - "\001(\0162\027.proto.WebFeatures.Flag\0221\n\020recentSt" - "ickersV3\030$ \001(\0162\027.proto.WebFeatures.Flag\022" - "+\n\nuserNotice\030% \001(\0162\027.proto.WebFeatures." - "Flag\022(\n\007support\030\' \001(\0162\027.proto.WebFeature" - "s.Flag\0220\n\017groupUiiCleanup\030( \001(\0162\027.proto." - "WebFeatures.Flag\022<\n\033groupDogfoodingInter" - "nalOnly\030) \001(\0162\027.proto.WebFeatures.Flag\022-" - "\n\014settingsSync\030* \001(\0162\027.proto.WebFeatures" - ".Flag\022*\n\tarchiveV2\030+ \001(\0162\027.proto.WebFeat" - "ures.Flag\022;\n\032ephemeralAllowGroupMembers\030" - ", \001(\0162\027.proto.WebFeatures.Flag\0225\n\024epheme" - "ral24HDuration\030- \001(\0162\027.proto.WebFeatures" - ".Flag\022/\n\016mdForceUpgrade\030. \001(\0162\027.proto.We" - "bFeatures.Flag\0221\n\020disappearingMode\030/ \001(\016" - "2\027.proto.WebFeatures.Flag\0229\n\030externalMdO" - "ptInAvailable\0300 \001(\0162\027.proto.WebFeatures." - "Flag\0229\n\030noDeleteMessageTimeLimit\0301 \001(\0162\027" - ".proto.WebFeatures.Flag\"K\n\004Flag\022\017\n\013NOT_S" - "TARTED\020\000\022\021\n\rFORCE_UPGRADE\020\001\022\017\n\013DEVELOPME" - "NT\020\002\022\016\n\nPRODUCTION\020\003\"\2424\n\016WebMessageInfo\022" - "\036\n\003key\030\001 \002(\0132\021.proto.MessageKey\022\037\n\007messa" - "ge\030\002 \001(\0132\016.proto.Message\022\030\n\020messageTimes" - "tamp\030\003 \001(\004\022,\n\006status\030\004 \001(\0162\034.proto.WebMe" - "ssageInfo.Status\022\023\n\013participant\030\005 \001(\t\022\033\n" - "\023messageC2STimestamp\030\006 \001(\004\022\016\n\006ignore\030\020 \001" - "(\010\022\017\n\007starred\030\021 \001(\010\022\021\n\tbroadcast\030\022 \001(\010\022\020" - "\n\010pushName\030\023 \001(\t\022\035\n\025mediaCiphertextSha25" - "6\030\024 \001(\014\022\021\n\tmulticast\030\025 \001(\010\022\017\n\007urlText\030\026 " - "\001(\010\022\021\n\turlNumber\030\027 \001(\010\0227\n\017messageStubTyp" - "e\030\030 \001(\0162\036.proto.WebMessageInfo.StubType\022" - "\022\n\nclearMedia\030\031 \001(\010\022\035\n\025messageStubParame" - "ters\030\032 \003(\t\022\020\n\010duration\030\033 \001(\r\022\016\n\006labels\030\034" - " \003(\t\022\'\n\013paymentInfo\030\035 \001(\0132\022.proto.Paymen" - "tInfo\022=\n\021finalLiveLocation\030\036 \001(\0132\".proto" - ".Message.LiveLocationMessage\022-\n\021quotedPa" - "ymentInfo\030\037 \001(\0132\022.proto.PaymentInfo\022\037\n\027e" - "phemeralStartTimestamp\030 \001(\004\022\031\n\021ephemera" - "lDuration\030! \001(\r\022\030\n\020ephemeralOffToOn\030\" \001(" - "\010\022\032\n\022ephemeralOutOfSync\030# \001(\010\022@\n\020bizPriv" - "acyStatus\030$ \001(\0162&.proto.WebMessageInfo.B" - "izPrivacyStatus\022\027\n\017verifiedBizName\030% \001(\t" - "\022#\n\tmediaData\030& \001(\0132\020.proto.MediaData\022\'\n" - "\013photoChange\030\' \001(\0132\022.proto.PhotoChange\022\'" - "\n\013userReceipt\030( \003(\0132\022.proto.UserReceipt\022" - "\"\n\treactions\030) \003(\0132\017.proto.Reaction\022+\n\021q" - "uotedStickerData\030* \001(\0132\020.proto.MediaData" - "\022\027\n\017futureproofData\030+ \001(\014\022#\n\tstatusPsa\030," - " \001(\0132\020.proto.StatusPSA\022&\n\013pollUpdates\030- " - "\003(\0132\021.proto.PollUpdate\022=\n\026pollAdditional" - "Metadata\030. \001(\0132\035.proto.PollAdditionalMet" - "adata\022\017\n\007agentId\030/ \001(\t\022\033\n\023statusAlreadyV" - "iewed\0300 \001(\010\022\025\n\rmessageSecret\0301 \001(\014\022%\n\nke" - "epInChat\0302 \001(\0132\021.proto.KeepInChat\022\'\n\037ori" - "ginalSelfAuthorUserJidString\0303 \001(\t\022\036\n\026re" - "vokeMessageTimestamp\0304 \001(\004\"=\n\020BizPrivacy" - "Status\022\010\n\004E2EE\020\000\022\006\n\002FB\020\002\022\007\n\003BSP\020\001\022\016\n\nBSP" - "_AND_FB\020\003\"X\n\006Status\022\t\n\005ERROR\020\000\022\013\n\007PENDIN" - "G\020\001\022\016\n\nSERVER_ACK\020\002\022\020\n\014DELIVERY_ACK\020\003\022\010\n" - "\004READ\020\004\022\n\n\006PLAYED\020\005\"\213(\n\010StubType\022\013\n\007UNKN" - "OWN\020\000\022\n\n\006REVOKE\020\001\022\016\n\nCIPHERTEXT\020\002\022\017\n\013FUT" - "UREPROOF\020\003\022\033\n\027NON_VERIFIED_TRANSITION\020\004\022" - "\031\n\025UNVERIFIED_TRANSITION\020\005\022\027\n\023VERIFIED_T" - "RANSITION\020\006\022\030\n\024VERIFIED_LOW_UNKNOWN\020\007\022\021\n" - "\rVERIFIED_HIGH\020\010\022\034\n\030VERIFIED_INITIAL_UNK" - "NOWN\020\t\022\030\n\024VERIFIED_INITIAL_LOW\020\n\022\031\n\025VERI" - "FIED_INITIAL_HIGH\020\013\022#\n\037VERIFIED_TRANSITI" - "ON_ANY_TO_NONE\020\014\022#\n\037VERIFIED_TRANSITION_" - "ANY_TO_HIGH\020\r\022#\n\037VERIFIED_TRANSITION_HIG" - "H_TO_LOW\020\016\022\'\n#VERIFIED_TRANSITION_HIGH_T" - "O_UNKNOWN\020\017\022&\n\"VERIFIED_TRANSITION_UNKNO" - "WN_TO_LOW\020\020\022&\n\"VERIFIED_TRANSITION_LOW_T" - "O_UNKNOWN\020\021\022#\n\037VERIFIED_TRANSITION_NONE_" - "TO_LOW\020\022\022\'\n#VERIFIED_TRANSITION_NONE_TO_" - "UNKNOWN\020\023\022\020\n\014GROUP_CREATE\020\024\022\030\n\024GROUP_CHA" - "NGE_SUBJECT\020\025\022\025\n\021GROUP_CHANGE_ICON\020\026\022\034\n\030" - "GROUP_CHANGE_INVITE_LINK\020\027\022\034\n\030GROUP_CHAN" - "GE_DESCRIPTION\020\030\022\031\n\025GROUP_CHANGE_RESTRIC" - "T\020\031\022\031\n\025GROUP_CHANGE_ANNOUNCE\020\032\022\031\n\025GROUP_" - "PARTICIPANT_ADD\020\033\022\034\n\030GROUP_PARTICIPANT_R" - "EMOVE\020\034\022\035\n\031GROUP_PARTICIPANT_PROMOTE\020\035\022\034" - "\n\030GROUP_PARTICIPANT_DEMOTE\020\036\022\034\n\030GROUP_PA" - "RTICIPANT_INVITE\020\037\022\033\n\027GROUP_PARTICIPANT_" - "LEAVE\020 \022#\n\037GROUP_PARTICIPANT_CHANGE_NUMB" - "ER\020!\022\024\n\020BROADCAST_CREATE\020\"\022\021\n\rBROADCAST_" - "ADD\020#\022\024\n\020BROADCAST_REMOVE\020$\022\030\n\024GENERIC_N" - "OTIFICATION\020%\022\030\n\024E2E_IDENTITY_CHANGED\020&\022" - "\021\n\rE2E_ENCRYPTED\020\'\022\025\n\021CALL_MISSED_VOICE\020" - "(\022\025\n\021CALL_MISSED_VIDEO\020)\022\034\n\030INDIVIDUAL_C" - "HANGE_NUMBER\020*\022\020\n\014GROUP_DELETE\020+\022&\n\"GROU" - "P_ANNOUNCE_MODE_MESSAGE_BOUNCE\020,\022\033\n\027CALL" - "_MISSED_GROUP_VOICE\020-\022\033\n\027CALL_MISSED_GRO" - "UP_VIDEO\020.\022\026\n\022PAYMENT_CIPHERTEXT\020/\022\027\n\023PA" - "YMENT_FUTUREPROOF\0200\022,\n(PAYMENT_TRANSACTI" - "ON_STATUS_UPDATE_FAILED\0201\022.\n*PAYMENT_TRA" - "NSACTION_STATUS_UPDATE_REFUNDED\0202\0223\n/PAY" - "MENT_TRANSACTION_STATUS_UPDATE_REFUND_FA" - "ILED\0203\0225\n1PAYMENT_TRANSACTION_STATUS_REC" - "EIVER_PENDING_SETUP\0204\022<\n8PAYMENT_TRANSAC" - "TION_STATUS_RECEIVER_SUCCESS_AFTER_HICCU" - "P\0205\022)\n%PAYMENT_ACTION_ACCOUNT_SETUP_REMI" - "NDER\0206\022(\n$PAYMENT_ACTION_SEND_PAYMENT_RE" - "MINDER\0207\022*\n&PAYMENT_ACTION_SEND_PAYMENT_" - "INVITATION\0208\022#\n\037PAYMENT_ACTION_REQUEST_D" - "ECLINED\0209\022\"\n\036PAYMENT_ACTION_REQUEST_EXPI" - "RED\020:\022$\n PAYMENT_ACTION_REQUEST_CANCELLE" - "D\020;\022)\n%BIZ_VERIFIED_TRANSITION_TOP_TO_BO" - "TTOM\020<\022)\n%BIZ_VERIFIED_TRANSITION_BOTTOM" - "_TO_TOP\020=\022\021\n\rBIZ_INTRO_TOP\020>\022\024\n\020BIZ_INTR" - "O_BOTTOM\020\?\022\023\n\017BIZ_NAME_CHANGE\020@\022\034\n\030BIZ_M" - "OVE_TO_CONSUMER_APP\020A\022\036\n\032BIZ_TWO_TIER_MI" - "GRATION_TOP\020B\022!\n\035BIZ_TWO_TIER_MIGRATION_" - "BOTTOM\020C\022\r\n\tOVERSIZED\020D\022(\n$GROUP_CHANGE_" - "NO_FREQUENTLY_FORWARDED\020E\022\034\n\030GROUP_V4_AD" - "D_INVITE_SENT\020F\022&\n\"GROUP_PARTICIPANT_ADD" - "_REQUEST_JOIN\020G\022\034\n\030CHANGE_EPHEMERAL_SETT" - "ING\020H\022\026\n\022E2E_DEVICE_CHANGED\020I\022\017\n\013VIEWED_" - "ONCE\020J\022\025\n\021E2E_ENCRYPTED_NOW\020K\022\"\n\036BLUE_MS" - "G_BSP_FB_TO_BSP_PREMISE\020L\022\036\n\032BLUE_MSG_BS" - "P_FB_TO_SELF_FB\020M\022#\n\037BLUE_MSG_BSP_FB_TO_" - "SELF_PREMISE\020N\022\036\n\032BLUE_MSG_BSP_FB_UNVERI" - "FIED\020O\0227\n3BLUE_MSG_BSP_FB_UNVERIFIED_TO_" - "SELF_PREMISE_VERIFIED\020P\022\034\n\030BLUE_MSG_BSP_" - "FB_VERIFIED\020Q\0227\n3BLUE_MSG_BSP_FB_VERIFIE" - "D_TO_SELF_PREMISE_UNVERIFIED\020R\022(\n$BLUE_M" - "SG_BSP_PREMISE_TO_SELF_PREMISE\020S\022#\n\037BLUE" - "_MSG_BSP_PREMISE_UNVERIFIED\020T\022<\n8BLUE_MS" - "G_BSP_PREMISE_UNVERIFIED_TO_SELF_PREMISE" - "_VERIFIED\020U\022!\n\035BLUE_MSG_BSP_PREMISE_VERI" - "FIED\020V\022<\n8BLUE_MSG_BSP_PREMISE_VERIFIED_" - "TO_SELF_PREMISE_UNVERIFIED\020W\022*\n&BLUE_MSG" - "_CONSUMER_TO_BSP_FB_UNVERIFIED\020X\022/\n+BLUE" - "_MSG_CONSUMER_TO_BSP_PREMISE_UNVERIFIED\020" - "Y\022+\n\'BLUE_MSG_CONSUMER_TO_SELF_FB_UNVERI" - "FIED\020Z\0220\n,BLUE_MSG_CONSUMER_TO_SELF_PREM" - "ISE_UNVERIFIED\020[\022#\n\037BLUE_MSG_SELF_FB_TO_" - "BSP_PREMISE\020\\\022$\n BLUE_MSG_SELF_FB_TO_SEL" - "F_PREMISE\020]\022\037\n\033BLUE_MSG_SELF_FB_UNVERIFI" - "ED\020^\0228\n4BLUE_MSG_SELF_FB_UNVERIFIED_TO_S" - "ELF_PREMISE_VERIFIED\020_\022\035\n\031BLUE_MSG_SELF_" - "FB_VERIFIED\020`\0228\n4BLUE_MSG_SELF_FB_VERIFI" - "ED_TO_SELF_PREMISE_UNVERIFIED\020a\022(\n$BLUE_" - "MSG_SELF_PREMISE_TO_BSP_PREMISE\020b\022$\n BLU" - "E_MSG_SELF_PREMISE_UNVERIFIED\020c\022\"\n\036BLUE_" - "MSG_SELF_PREMISE_VERIFIED\020d\022\026\n\022BLUE_MSG_" - "TO_BSP_FB\020e\022\030\n\024BLUE_MSG_TO_CONSUMER\020f\022\027\n" - "\023BLUE_MSG_TO_SELF_FB\020g\022*\n&BLUE_MSG_UNVER" - "IFIED_TO_BSP_FB_VERIFIED\020h\022/\n+BLUE_MSG_U" - "NVERIFIED_TO_BSP_PREMISE_VERIFIED\020i\022+\n\'B" - "LUE_MSG_UNVERIFIED_TO_SELF_FB_VERIFIED\020j" - "\022#\n\037BLUE_MSG_UNVERIFIED_TO_VERIFIED\020k\022*\n" - "&BLUE_MSG_VERIFIED_TO_BSP_FB_UNVERIFIED\020" - "l\022/\n+BLUE_MSG_VERIFIED_TO_BSP_PREMISE_UN" - "VERIFIED\020m\022+\n\'BLUE_MSG_VERIFIED_TO_SELF_" - "FB_UNVERIFIED\020n\022#\n\037BLUE_MSG_VERIFIED_TO_" - "UNVERIFIED\020o\0226\n2BLUE_MSG_BSP_FB_UNVERIFI" - "ED_TO_BSP_PREMISE_VERIFIED\020p\0222\n.BLUE_MSG" - "_BSP_FB_UNVERIFIED_TO_SELF_FB_VERIFIED\020q" - "\0226\n2BLUE_MSG_BSP_FB_VERIFIED_TO_BSP_PREM" - "ISE_UNVERIFIED\020r\0222\n.BLUE_MSG_BSP_FB_VERI" - "FIED_TO_SELF_FB_UNVERIFIED\020s\0227\n3BLUE_MSG" - "_SELF_FB_UNVERIFIED_TO_BSP_PREMISE_VERIF" - "IED\020t\0227\n3BLUE_MSG_SELF_FB_VERIFIED_TO_BS" - "P_PREMISE_UNVERIFIED\020u\022\034\n\030E2E_IDENTITY_U" - "NAVAILABLE\020v\022\022\n\016GROUP_CREATING\020w\022\027\n\023GROU" - "P_CREATE_FAILED\020x\022\021\n\rGROUP_BOUNCED\020y\022\021\n\r" - "BLOCK_CONTACT\020z\022!\n\035EPHEMERAL_SETTING_NOT" - "_APPLIED\020{\022\017\n\013SYNC_FAILED\020|\022\013\n\007SYNCING\020}" - "\022\034\n\030BIZ_PRIVACY_MODE_INIT_FB\020~\022\035\n\031BIZ_PR" - "IVACY_MODE_INIT_BSP\020\177\022\033\n\026BIZ_PRIVACY_MOD" - "E_TO_FB\020\200\001\022\034\n\027BIZ_PRIVACY_MODE_TO_BSP\020\201\001" - "\022\026\n\021DISAPPEARING_MODE\020\202\001\022\034\n\027E2E_DEVICE_F" - "ETCH_FAILED\020\203\001\022\021\n\014ADMIN_REVOKE\020\204\001\022$\n\037GRO" - "UP_INVITE_LINK_GROWTH_LOCKED\020\205\001\022 \n\033COMMU" - "NITY_LINK_PARENT_GROUP\020\206\001\022!\n\034COMMUNITY_L" - "INK_SIBLING_GROUP\020\207\001\022\035\n\030COMMUNITY_LINK_S" - "UB_GROUP\020\210\001\022\"\n\035COMMUNITY_UNLINK_PARENT_G" - "ROUP\020\211\001\022#\n\036COMMUNITY_UNLINK_SIBLING_GROU" - "P\020\212\001\022\037\n\032COMMUNITY_UNLINK_SUB_GROUP\020\213\001\022\035\n" - "\030GROUP_PARTICIPANT_ACCEPT\020\214\001\022(\n#GROUP_PA" - "RTICIPANT_LINKED_GROUP_JOIN\020\215\001\022\025\n\020COMMUN" - "ITY_CREATE\020\216\001\022\033\n\026EPHEMERAL_KEEP_IN_CHAT\020" - "\217\001\022+\n&GROUP_MEMBERSHIP_JOIN_APPROVAL_REQ" - "UEST\020\220\001\022(\n#GROUP_MEMBERSHIP_JOIN_APPROVA" - "L_MODE\020\221\001\022\"\n\035INTEGRITY_UNLINK_PARENT_GRO" - "UP\020\222\001\022\"\n\035COMMUNITY_PARTICIPANT_PROMOTE\020\223" - "\001\022!\n\034COMMUNITY_PARTICIPANT_DEMOTE\020\224\001\022#\n\036" - "COMMUNITY_PARENT_GROUP_DELETED\020\225\001\"\211\001\n\024We" - "bNotificationsInfo\022\021\n\ttimestamp\030\002 \001(\004\022\023\n" - "\013unreadChats\030\003 \001(\r\022\032\n\022notifyMessageCount" - "\030\004 \001(\r\022-\n\016notifyMessages\030\005 \003(\0132\025.proto.W" - "ebMessageInfo*@\n\010KeepType\022\013\n\007UNKNOWN\020\000\022\020" - "\n\014KEEP_FOR_ALL\020\001\022\025\n\021UNDO_KEEP_FOR_ALL\020\002*" - "/\n\017MediaVisibility\022\013\n\007DEFAULT\020\000\022\007\n\003OFF\020\001" - "\022\006\n\002ON\020\002" - ; -static ::_pbi::once_flag descriptor_table_pmsg_2eproto_once; -const ::_pbi::DescriptorTable descriptor_table_pmsg_2eproto = { - false, false, 52848, descriptor_table_protodef_pmsg_2eproto, - "pmsg.proto", - &descriptor_table_pmsg_2eproto_once, nullptr, 0, 224, - schemas, file_default_instances, TableStruct_pmsg_2eproto::offsets, - file_level_metadata_pmsg_2eproto, file_level_enum_descriptors_pmsg_2eproto, - file_level_service_descriptors_pmsg_2eproto, -}; -PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_pmsg_2eproto_getter() { - return &descriptor_table_pmsg_2eproto; -} - -// Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_pmsg_2eproto(&descriptor_table_pmsg_2eproto); -namespace proto { -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizAccountLinkInfo_AccountType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[0]; -} -bool BizAccountLinkInfo_AccountType_IsValid(int value) { - switch (value) { - case 0: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr BizAccountLinkInfo_AccountType BizAccountLinkInfo::ENTERPRISE; -constexpr BizAccountLinkInfo_AccountType BizAccountLinkInfo::AccountType_MIN; -constexpr BizAccountLinkInfo_AccountType BizAccountLinkInfo::AccountType_MAX; -constexpr int BizAccountLinkInfo::AccountType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizAccountLinkInfo_HostStorageType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[1]; -} -bool BizAccountLinkInfo_HostStorageType_IsValid(int value) { - switch (value) { - case 0: - case 1: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr BizAccountLinkInfo_HostStorageType BizAccountLinkInfo::ON_PREMISE; -constexpr BizAccountLinkInfo_HostStorageType BizAccountLinkInfo::FACEBOOK; -constexpr BizAccountLinkInfo_HostStorageType BizAccountLinkInfo::HostStorageType_MIN; -constexpr BizAccountLinkInfo_HostStorageType BizAccountLinkInfo::HostStorageType_MAX; -constexpr int BizAccountLinkInfo::HostStorageType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizIdentityInfo_ActualActorsType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[2]; -} -bool BizIdentityInfo_ActualActorsType_IsValid(int value) { - switch (value) { - case 0: - case 1: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr BizIdentityInfo_ActualActorsType BizIdentityInfo::SELF; -constexpr BizIdentityInfo_ActualActorsType BizIdentityInfo::BSP; -constexpr BizIdentityInfo_ActualActorsType BizIdentityInfo::ActualActorsType_MIN; -constexpr BizIdentityInfo_ActualActorsType BizIdentityInfo::ActualActorsType_MAX; -constexpr int BizIdentityInfo::ActualActorsType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizIdentityInfo_HostStorageType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[3]; -} -bool BizIdentityInfo_HostStorageType_IsValid(int value) { - switch (value) { - case 0: - case 1: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr BizIdentityInfo_HostStorageType BizIdentityInfo::ON_PREMISE; -constexpr BizIdentityInfo_HostStorageType BizIdentityInfo::FACEBOOK; -constexpr BizIdentityInfo_HostStorageType BizIdentityInfo::HostStorageType_MIN; -constexpr BizIdentityInfo_HostStorageType BizIdentityInfo::HostStorageType_MAX; -constexpr int BizIdentityInfo::HostStorageType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizIdentityInfo_VerifiedLevelValue_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[4]; -} -bool BizIdentityInfo_VerifiedLevelValue_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr BizIdentityInfo_VerifiedLevelValue BizIdentityInfo::UNKNOWN; -constexpr BizIdentityInfo_VerifiedLevelValue BizIdentityInfo::LOW; -constexpr BizIdentityInfo_VerifiedLevelValue BizIdentityInfo::HIGH; -constexpr BizIdentityInfo_VerifiedLevelValue BizIdentityInfo::VerifiedLevelValue_MIN; -constexpr BizIdentityInfo_VerifiedLevelValue BizIdentityInfo::VerifiedLevelValue_MAX; -constexpr int BizIdentityInfo::VerifiedLevelValue_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_DNSSource_DNSResolutionMethod_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[5]; -} -bool ClientPayload_DNSSource_DNSResolutionMethod_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - case 3: - case 4: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource::SYSTEM; -constexpr ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource::GOOGLE; -constexpr ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource::HARDCODED; -constexpr ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource::OVERRIDE; -constexpr ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource::FALLBACK; -constexpr ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource::DNSResolutionMethod_MIN; -constexpr ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource::DNSResolutionMethod_MAX; -constexpr int ClientPayload_DNSSource::DNSResolutionMethod_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_UserAgent_Platform_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[6]; -} -bool ClientPayload_UserAgent_Platform_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - case 3: - case 4: - case 5: - case 6: - case 7: - case 8: - case 9: - case 10: - case 11: - case 12: - case 13: - case 14: - case 15: - case 16: - case 17: - case 18: - case 19: - case 20: - case 21: - case 22: - case 23: - case 24: - case 25: - case 26: - case 27: - case 28: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::ANDROID; -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::IOS; -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::WINDOWS_PHONE; -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::BLACKBERRY; -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::BLACKBERRYX; -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::S40; -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::S60; -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::PYTHON_CLIENT; -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::TIZEN; -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::ENTERPRISE; -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::SMB_ANDROID; -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::KAIOS; -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::SMB_IOS; -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::WINDOWS; -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::WEB; -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::PORTAL; -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::GREEN_ANDROID; -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::GREEN_IPHONE; -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::BLUE_ANDROID; -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::BLUE_IPHONE; -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::FBLITE_ANDROID; -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::MLITE_ANDROID; -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::IGLITE_ANDROID; -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::PAGE; -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::MACOS; -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::OCULUS_MSG; -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::OCULUS_CALL; -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::MILAN; -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::CAPI; -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::Platform_MIN; -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent::Platform_MAX; -constexpr int ClientPayload_UserAgent::Platform_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_UserAgent_ReleaseChannel_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[7]; -} -bool ClientPayload_UserAgent_ReleaseChannel_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - case 3: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent::RELEASE; -constexpr ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent::BETA; -constexpr ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent::ALPHA; -constexpr ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent::DEBUG; -constexpr ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent::ReleaseChannel_MIN; -constexpr ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent::ReleaseChannel_MAX; -constexpr int ClientPayload_UserAgent::ReleaseChannel_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_WebInfo_WebSubPlatform_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[8]; -} -bool ClientPayload_WebInfo_WebSubPlatform_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - case 3: - case 4: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo::WEB_BROWSER; -constexpr ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo::APP_STORE; -constexpr ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo::WIN_STORE; -constexpr ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo::DARWIN; -constexpr ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo::WINDA; -constexpr ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo::WebSubPlatform_MIN; -constexpr ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo::WebSubPlatform_MAX; -constexpr int ClientPayload_WebInfo::WebSubPlatform_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_ConnectReason_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[9]; -} -bool ClientPayload_ConnectReason_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - case 3: - case 4: - case 5: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr ClientPayload_ConnectReason ClientPayload::PUSH; -constexpr ClientPayload_ConnectReason ClientPayload::USER_ACTIVATED; -constexpr ClientPayload_ConnectReason ClientPayload::SCHEDULED; -constexpr ClientPayload_ConnectReason ClientPayload::ERROR_RECONNECT; -constexpr ClientPayload_ConnectReason ClientPayload::NETWORK_SWITCH; -constexpr ClientPayload_ConnectReason ClientPayload::PING_RECONNECT; -constexpr ClientPayload_ConnectReason ClientPayload::ConnectReason_MIN; -constexpr ClientPayload_ConnectReason ClientPayload::ConnectReason_MAX; -constexpr int ClientPayload::ConnectReason_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_ConnectType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[10]; -} -bool ClientPayload_ConnectType_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 100: - case 101: - case 102: - case 103: - case 104: - case 105: - case 106: - case 107: - case 108: - case 109: - case 110: - case 111: - case 112: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_UNKNOWN; -constexpr ClientPayload_ConnectType ClientPayload::WIFI_UNKNOWN; -constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_EDGE; -constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_IDEN; -constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_UMTS; -constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_EVDO; -constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_GPRS; -constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_HSDPA; -constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_HSUPA; -constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_HSPA; -constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_CDMA; -constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_1XRTT; -constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_EHRPD; -constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_LTE; -constexpr ClientPayload_ConnectType ClientPayload::CELLULAR_HSPAP; -constexpr ClientPayload_ConnectType ClientPayload::ConnectType_MIN; -constexpr ClientPayload_ConnectType ClientPayload::ConnectType_MAX; -constexpr int ClientPayload::ConnectType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_IOSAppExtension_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[11]; -} -bool ClientPayload_IOSAppExtension_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr ClientPayload_IOSAppExtension ClientPayload::SHARE_EXTENSION; -constexpr ClientPayload_IOSAppExtension ClientPayload::SERVICE_EXTENSION; -constexpr ClientPayload_IOSAppExtension ClientPayload::INTENTS_EXTENSION; -constexpr ClientPayload_IOSAppExtension ClientPayload::IOSAppExtension_MIN; -constexpr ClientPayload_IOSAppExtension ClientPayload::IOSAppExtension_MAX; -constexpr int ClientPayload::IOSAppExtension_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_Product_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[12]; -} -bool ClientPayload_Product_IsValid(int value) { - switch (value) { - case 0: - case 1: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr ClientPayload_Product ClientPayload::WHATSAPP; -constexpr ClientPayload_Product ClientPayload::MESSENGER; -constexpr ClientPayload_Product ClientPayload::Product_MIN; -constexpr ClientPayload_Product ClientPayload::Product_MAX; -constexpr int ClientPayload::Product_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ContextInfo_AdReplyInfo_MediaType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[13]; -} -bool ContextInfo_AdReplyInfo_MediaType_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr ContextInfo_AdReplyInfo_MediaType ContextInfo_AdReplyInfo::NONE; -constexpr ContextInfo_AdReplyInfo_MediaType ContextInfo_AdReplyInfo::IMAGE; -constexpr ContextInfo_AdReplyInfo_MediaType ContextInfo_AdReplyInfo::VIDEO; -constexpr ContextInfo_AdReplyInfo_MediaType ContextInfo_AdReplyInfo::MediaType_MIN; -constexpr ContextInfo_AdReplyInfo_MediaType ContextInfo_AdReplyInfo::MediaType_MAX; -constexpr int ContextInfo_AdReplyInfo::MediaType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ContextInfo_ExternalAdReplyInfo_MediaType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[14]; -} -bool ContextInfo_ExternalAdReplyInfo_MediaType_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr ContextInfo_ExternalAdReplyInfo_MediaType ContextInfo_ExternalAdReplyInfo::NONE; -constexpr ContextInfo_ExternalAdReplyInfo_MediaType ContextInfo_ExternalAdReplyInfo::IMAGE; -constexpr ContextInfo_ExternalAdReplyInfo_MediaType ContextInfo_ExternalAdReplyInfo::VIDEO; -constexpr ContextInfo_ExternalAdReplyInfo_MediaType ContextInfo_ExternalAdReplyInfo::MediaType_MIN; -constexpr ContextInfo_ExternalAdReplyInfo_MediaType ContextInfo_ExternalAdReplyInfo::MediaType_MAX; -constexpr int ContextInfo_ExternalAdReplyInfo::MediaType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Conversation_EndOfHistoryTransferType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[15]; -} -bool Conversation_EndOfHistoryTransferType_IsValid(int value) { - switch (value) { - case 0: - case 1: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr Conversation_EndOfHistoryTransferType Conversation::COMPLETE_BUT_MORE_MESSAGES_REMAIN_ON_PRIMARY; -constexpr Conversation_EndOfHistoryTransferType Conversation::COMPLETE_AND_NO_MORE_MESSAGE_REMAIN_ON_PRIMARY; -constexpr Conversation_EndOfHistoryTransferType Conversation::EndOfHistoryTransferType_MIN; -constexpr Conversation_EndOfHistoryTransferType Conversation::EndOfHistoryTransferType_MAX; -constexpr int Conversation::EndOfHistoryTransferType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceProps_PlatformType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[16]; -} -bool DeviceProps_PlatformType_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - case 3: - case 4: - case 5: - case 6: - case 7: - case 8: - case 9: - case 10: - case 11: - case 12: - case 13: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr DeviceProps_PlatformType DeviceProps::UNKNOWN; -constexpr DeviceProps_PlatformType DeviceProps::CHROME; -constexpr DeviceProps_PlatformType DeviceProps::FIREFOX; -constexpr DeviceProps_PlatformType DeviceProps::IE; -constexpr DeviceProps_PlatformType DeviceProps::OPERA; -constexpr DeviceProps_PlatformType DeviceProps::SAFARI; -constexpr DeviceProps_PlatformType DeviceProps::EDGE; -constexpr DeviceProps_PlatformType DeviceProps::DESKTOP; -constexpr DeviceProps_PlatformType DeviceProps::IPAD; -constexpr DeviceProps_PlatformType DeviceProps::ANDROID_TABLET; -constexpr DeviceProps_PlatformType DeviceProps::OHANA; -constexpr DeviceProps_PlatformType DeviceProps::ALOHA; -constexpr DeviceProps_PlatformType DeviceProps::CATALINA; -constexpr DeviceProps_PlatformType DeviceProps::TCL_TV; -constexpr DeviceProps_PlatformType DeviceProps::PlatformType_MIN; -constexpr DeviceProps_PlatformType DeviceProps::PlatformType_MAX; -constexpr int DeviceProps::PlatformType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DisappearingMode_Initiator_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[17]; -} -bool DisappearingMode_Initiator_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr DisappearingMode_Initiator DisappearingMode::CHANGED_IN_CHAT; -constexpr DisappearingMode_Initiator DisappearingMode::INITIATED_BY_ME; -constexpr DisappearingMode_Initiator DisappearingMode::INITIATED_BY_OTHER; -constexpr DisappearingMode_Initiator DisappearingMode::Initiator_MIN; -constexpr DisappearingMode_Initiator DisappearingMode::Initiator_MAX; -constexpr int DisappearingMode::Initiator_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* GroupParticipant_Rank_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[18]; -} -bool GroupParticipant_Rank_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr GroupParticipant_Rank GroupParticipant::REGULAR; -constexpr GroupParticipant_Rank GroupParticipant::ADMIN; -constexpr GroupParticipant_Rank GroupParticipant::SUPERADMIN; -constexpr GroupParticipant_Rank GroupParticipant::Rank_MIN; -constexpr GroupParticipant_Rank GroupParticipant::Rank_MAX; -constexpr int GroupParticipant::Rank_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HistorySync_HistorySyncType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[19]; -} -bool HistorySync_HistorySyncType_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - case 3: - case 4: - case 5: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr HistorySync_HistorySyncType HistorySync::INITIAL_BOOTSTRAP; -constexpr HistorySync_HistorySyncType HistorySync::INITIAL_STATUS_V3; -constexpr HistorySync_HistorySyncType HistorySync::FULL; -constexpr HistorySync_HistorySyncType HistorySync::RECENT; -constexpr HistorySync_HistorySyncType HistorySync::PUSH_NAME; -constexpr HistorySync_HistorySyncType HistorySync::UNBLOCKING_DATA; -constexpr HistorySync_HistorySyncType HistorySync::HistorySyncType_MIN; -constexpr HistorySync_HistorySyncType HistorySync::HistorySyncType_MAX; -constexpr int HistorySync::HistorySyncType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MediaRetryNotification_ResultType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[20]; -} -bool MediaRetryNotification_ResultType_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - case 3: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr MediaRetryNotification_ResultType MediaRetryNotification::GENERAL_ERROR; -constexpr MediaRetryNotification_ResultType MediaRetryNotification::SUCCESS; -constexpr MediaRetryNotification_ResultType MediaRetryNotification::NOT_FOUND; -constexpr MediaRetryNotification_ResultType MediaRetryNotification::DECRYPTION_ERROR; -constexpr MediaRetryNotification_ResultType MediaRetryNotification::ResultType_MIN; -constexpr MediaRetryNotification_ResultType MediaRetryNotification::ResultType_MAX; -constexpr int MediaRetryNotification::ResultType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ButtonsMessage_Button_Type_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[21]; -} -bool Message_ButtonsMessage_Button_Type_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr Message_ButtonsMessage_Button_Type Message_ButtonsMessage_Button::UNKNOWN; -constexpr Message_ButtonsMessage_Button_Type Message_ButtonsMessage_Button::RESPONSE; -constexpr Message_ButtonsMessage_Button_Type Message_ButtonsMessage_Button::NATIVE_FLOW; -constexpr Message_ButtonsMessage_Button_Type Message_ButtonsMessage_Button::Type_MIN; -constexpr Message_ButtonsMessage_Button_Type Message_ButtonsMessage_Button::Type_MAX; -constexpr int Message_ButtonsMessage_Button::Type_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ButtonsMessage_HeaderType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[22]; -} -bool Message_ButtonsMessage_HeaderType_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - case 3: - case 4: - case 5: - case 6: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage::UNKNOWN; -constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage::EMPTY; -constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage::TEXT; -constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage::DOCUMENT; -constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage::IMAGE; -constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage::VIDEO; -constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage::LOCATION; -constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage::HeaderType_MIN; -constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage::HeaderType_MAX; -constexpr int Message_ButtonsMessage::HeaderType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ButtonsResponseMessage_Type_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[23]; -} -bool Message_ButtonsResponseMessage_Type_IsValid(int value) { - switch (value) { - case 0: - case 1: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr Message_ButtonsResponseMessage_Type Message_ButtonsResponseMessage::UNKNOWN; -constexpr Message_ButtonsResponseMessage_Type Message_ButtonsResponseMessage::DISPLAY_TEXT; -constexpr Message_ButtonsResponseMessage_Type Message_ButtonsResponseMessage::Type_MIN; -constexpr Message_ButtonsResponseMessage_Type Message_ButtonsResponseMessage::Type_MAX; -constexpr int Message_ButtonsResponseMessage::Type_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ExtendedTextMessage_FontType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[24]; -} -bool Message_ExtendedTextMessage_FontType_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - case 3: - case 4: - case 5: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::SANS_SERIF; -constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::SERIF; -constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::NORICAN_REGULAR; -constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::BRYNDAN_WRITE; -constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::BEBASNEUE_REGULAR; -constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::OSWALD_HEAVY; -constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::FontType_MIN; -constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::FontType_MAX; -constexpr int Message_ExtendedTextMessage::FontType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ExtendedTextMessage_InviteLinkGroupType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[25]; -} -bool Message_ExtendedTextMessage_InviteLinkGroupType_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - case 3: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::DEFAULT; -constexpr Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::PARENT; -constexpr Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::SUB; -constexpr Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::DEFAULT_SUB; -constexpr Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::InviteLinkGroupType_MIN; -constexpr Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::InviteLinkGroupType_MAX; -constexpr int Message_ExtendedTextMessage::InviteLinkGroupType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ExtendedTextMessage_PreviewType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[26]; -} -bool Message_ExtendedTextMessage_PreviewType_IsValid(int value) { - switch (value) { - case 0: - case 1: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr Message_ExtendedTextMessage_PreviewType Message_ExtendedTextMessage::NONE; -constexpr Message_ExtendedTextMessage_PreviewType Message_ExtendedTextMessage::VIDEO; -constexpr Message_ExtendedTextMessage_PreviewType Message_ExtendedTextMessage::PreviewType_MIN; -constexpr Message_ExtendedTextMessage_PreviewType Message_ExtendedTextMessage::PreviewType_MAX; -constexpr int Message_ExtendedTextMessage::PreviewType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_GroupInviteMessage_GroupType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[27]; -} -bool Message_GroupInviteMessage_GroupType_IsValid(int value) { - switch (value) { - case 0: - case 1: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr Message_GroupInviteMessage_GroupType Message_GroupInviteMessage::DEFAULT; -constexpr Message_GroupInviteMessage_GroupType Message_GroupInviteMessage::PARENT; -constexpr Message_GroupInviteMessage_GroupType Message_GroupInviteMessage::GroupType_MIN; -constexpr Message_GroupInviteMessage_GroupType Message_GroupInviteMessage::GroupType_MAX; -constexpr int Message_GroupInviteMessage::GroupType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[28]; -} -bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_IsValid(int value) { - switch (value) { - case 1: - case 2: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::GREGORIAN; -constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::SOLAR_HIJRI; -constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::CalendarType_MIN; -constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::CalendarType_MAX; -constexpr int Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::CalendarType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[29]; -} -bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_IsValid(int value) { - switch (value) { - case 1: - case 2: - case 3: - case 4: - case 5: - case 6: - case 7: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::MONDAY; -constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::TUESDAY; -constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::WEDNESDAY; -constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::THURSDAY; -constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::FRIDAY; -constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::SATURDAY; -constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::SUNDAY; -constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::DayOfWeekType_MIN; -constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::DayOfWeekType_MAX; -constexpr int Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::DayOfWeekType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_HistorySyncNotification_HistorySyncType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[30]; -} -bool Message_HistorySyncNotification_HistorySyncType_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - case 3: - case 4: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification::INITIAL_BOOTSTRAP; -constexpr Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification::INITIAL_STATUS_V3; -constexpr Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification::FULL; -constexpr Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification::RECENT; -constexpr Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification::PUSH_NAME; -constexpr Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification::HistorySyncType_MIN; -constexpr Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification::HistorySyncType_MAX; -constexpr int Message_HistorySyncNotification::HistorySyncType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_InteractiveMessage_ShopMessage_Surface_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[31]; -} -bool Message_InteractiveMessage_ShopMessage_Surface_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - case 3: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage::UNKNOWN_SURFACE; -constexpr Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage::FB; -constexpr Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage::IG; -constexpr Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage::WA; -constexpr Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage::Surface_MIN; -constexpr Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage::Surface_MAX; -constexpr int Message_InteractiveMessage_ShopMessage::Surface_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_InvoiceMessage_AttachmentType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[32]; -} -bool Message_InvoiceMessage_AttachmentType_IsValid(int value) { - switch (value) { - case 0: - case 1: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr Message_InvoiceMessage_AttachmentType Message_InvoiceMessage::IMAGE; -constexpr Message_InvoiceMessage_AttachmentType Message_InvoiceMessage::PDF; -constexpr Message_InvoiceMessage_AttachmentType Message_InvoiceMessage::AttachmentType_MIN; -constexpr Message_InvoiceMessage_AttachmentType Message_InvoiceMessage::AttachmentType_MAX; -constexpr int Message_InvoiceMessage::AttachmentType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ListMessage_ListType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[33]; -} -bool Message_ListMessage_ListType_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr Message_ListMessage_ListType Message_ListMessage::UNKNOWN; -constexpr Message_ListMessage_ListType Message_ListMessage::SINGLE_SELECT; -constexpr Message_ListMessage_ListType Message_ListMessage::PRODUCT_LIST; -constexpr Message_ListMessage_ListType Message_ListMessage::ListType_MIN; -constexpr Message_ListMessage_ListType Message_ListMessage::ListType_MAX; -constexpr int Message_ListMessage::ListType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ListResponseMessage_ListType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[34]; -} -bool Message_ListResponseMessage_ListType_IsValid(int value) { - switch (value) { - case 0: - case 1: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr Message_ListResponseMessage_ListType Message_ListResponseMessage::UNKNOWN; -constexpr Message_ListResponseMessage_ListType Message_ListResponseMessage::SINGLE_SELECT; -constexpr Message_ListResponseMessage_ListType Message_ListResponseMessage::ListType_MIN; -constexpr Message_ListResponseMessage_ListType Message_ListResponseMessage::ListType_MAX; -constexpr int Message_ListResponseMessage::ListType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_OrderMessage_OrderStatus_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[35]; -} -bool Message_OrderMessage_OrderStatus_IsValid(int value) { - switch (value) { - case 1: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr Message_OrderMessage_OrderStatus Message_OrderMessage::INQUIRY; -constexpr Message_OrderMessage_OrderStatus Message_OrderMessage::OrderStatus_MIN; -constexpr Message_OrderMessage_OrderStatus Message_OrderMessage::OrderStatus_MAX; -constexpr int Message_OrderMessage::OrderStatus_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_OrderMessage_OrderSurface_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[36]; -} -bool Message_OrderMessage_OrderSurface_IsValid(int value) { - switch (value) { - case 1: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr Message_OrderMessage_OrderSurface Message_OrderMessage::CATALOG; -constexpr Message_OrderMessage_OrderSurface Message_OrderMessage::OrderSurface_MIN; -constexpr Message_OrderMessage_OrderSurface Message_OrderMessage::OrderSurface_MAX; -constexpr int Message_OrderMessage::OrderSurface_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_PaymentInviteMessage_ServiceType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[37]; -} -bool Message_PaymentInviteMessage_ServiceType_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - case 3: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage::UNKNOWN; -constexpr Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage::FBPAY; -constexpr Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage::NOVI; -constexpr Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage::UPI; -constexpr Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage::ServiceType_MIN; -constexpr Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage::ServiceType_MAX; -constexpr int Message_PaymentInviteMessage::ServiceType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ProtocolMessage_Type_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[38]; -} -bool Message_ProtocolMessage_Type_IsValid(int value) { - switch (value) { - case 0: - case 3: - case 4: - case 5: - case 6: - case 7: - case 8: - case 9: - case 10: - case 11: - case 12: - case 13: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::REVOKE; -constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::EPHEMERAL_SETTING; -constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::EPHEMERAL_SYNC_RESPONSE; -constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::HISTORY_SYNC_NOTIFICATION; -constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::APP_STATE_SYNC_KEY_SHARE; -constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::APP_STATE_SYNC_KEY_REQUEST; -constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::MSG_FANOUT_BACKFILL_REQUEST; -constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::INITIAL_SECURITY_NOTIFICATION_SETTING_SYNC; -constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::APP_STATE_FATAL_EXCEPTION_NOTIFICATION; -constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::SHARE_PHONE_NUMBER; -constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::REQUEST_MEDIA_UPLOAD_MESSAGE; -constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::REQUEST_MEDIA_UPLOAD_RESPONSE_MESSAGE; -constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::Type_MIN; -constexpr Message_ProtocolMessage_Type Message_ProtocolMessage::Type_MAX; -constexpr int Message_ProtocolMessage::Type_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_VideoMessage_Attribution_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[39]; -} -bool Message_VideoMessage_Attribution_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr Message_VideoMessage_Attribution Message_VideoMessage::NONE; -constexpr Message_VideoMessage_Attribution Message_VideoMessage::GIPHY; -constexpr Message_VideoMessage_Attribution Message_VideoMessage::TENOR; -constexpr Message_VideoMessage_Attribution Message_VideoMessage::Attribution_MIN; -constexpr Message_VideoMessage_Attribution Message_VideoMessage::Attribution_MAX; -constexpr int Message_VideoMessage::Attribution_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_RmrSource_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[40]; -} -bool Message_RmrSource_IsValid(int value) { - switch (value) { - case 0: - case 1: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr Message_RmrSource Message::FAVORITE_STICKER; -constexpr Message_RmrSource Message::RECENT_STICKER; -constexpr Message_RmrSource Message::RmrSource_MIN; -constexpr Message_RmrSource Message::RmrSource_MAX; -constexpr int Message::RmrSource_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PastParticipant_LeaveReason_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[41]; -} -bool PastParticipant_LeaveReason_IsValid(int value) { - switch (value) { - case 0: - case 1: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr PastParticipant_LeaveReason PastParticipant::LEFT; -constexpr PastParticipant_LeaveReason PastParticipant::REMOVED; -constexpr PastParticipant_LeaveReason PastParticipant::LeaveReason_MIN; -constexpr PastParticipant_LeaveReason PastParticipant::LeaveReason_MAX; -constexpr int PastParticipant::LeaveReason_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PaymentBackground_Type_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[42]; -} -bool PaymentBackground_Type_IsValid(int value) { - switch (value) { - case 0: - case 1: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr PaymentBackground_Type PaymentBackground::UNKNOWN; -constexpr PaymentBackground_Type PaymentBackground::DEFAULT; -constexpr PaymentBackground_Type PaymentBackground::Type_MIN; -constexpr PaymentBackground_Type PaymentBackground::Type_MAX; -constexpr int PaymentBackground::Type_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PaymentInfo_Currency_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[43]; -} -bool PaymentInfo_Currency_IsValid(int value) { - switch (value) { - case 0: - case 1: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr PaymentInfo_Currency PaymentInfo::UNKNOWN_CURRENCY; -constexpr PaymentInfo_Currency PaymentInfo::INR; -constexpr PaymentInfo_Currency PaymentInfo::Currency_MIN; -constexpr PaymentInfo_Currency PaymentInfo::Currency_MAX; -constexpr int PaymentInfo::Currency_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PaymentInfo_Status_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[44]; -} -bool PaymentInfo_Status_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - case 3: - case 4: - case 5: - case 6: - case 7: - case 8: - case 9: - case 10: - case 11: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr PaymentInfo_Status PaymentInfo::UNKNOWN_STATUS; -constexpr PaymentInfo_Status PaymentInfo::PROCESSING; -constexpr PaymentInfo_Status PaymentInfo::SENT; -constexpr PaymentInfo_Status PaymentInfo::NEED_TO_ACCEPT; -constexpr PaymentInfo_Status PaymentInfo::COMPLETE; -constexpr PaymentInfo_Status PaymentInfo::COULD_NOT_COMPLETE; -constexpr PaymentInfo_Status PaymentInfo::REFUNDED; -constexpr PaymentInfo_Status PaymentInfo::EXPIRED; -constexpr PaymentInfo_Status PaymentInfo::REJECTED; -constexpr PaymentInfo_Status PaymentInfo::CANCELLED; -constexpr PaymentInfo_Status PaymentInfo::WAITING_FOR_PAYER; -constexpr PaymentInfo_Status PaymentInfo::WAITING; -constexpr PaymentInfo_Status PaymentInfo::Status_MIN; -constexpr PaymentInfo_Status PaymentInfo::Status_MAX; -constexpr int PaymentInfo::Status_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PaymentInfo_TxnStatus_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[45]; -} -bool PaymentInfo_TxnStatus_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - case 3: - case 4: - case 5: - case 6: - case 7: - case 8: - case 9: - case 10: - case 11: - case 12: - case 13: - case 14: - case 15: - case 16: - case 17: - case 18: - case 19: - case 20: - case 21: - case 22: - case 23: - case 24: - case 25: - case 26: - case 27: - case 28: - case 29: - case 30: - case 31: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr PaymentInfo_TxnStatus PaymentInfo::UNKNOWN; -constexpr PaymentInfo_TxnStatus PaymentInfo::PENDING_SETUP; -constexpr PaymentInfo_TxnStatus PaymentInfo::PENDING_RECEIVER_SETUP; -constexpr PaymentInfo_TxnStatus PaymentInfo::INIT; -constexpr PaymentInfo_TxnStatus PaymentInfo::SUCCESS; -constexpr PaymentInfo_TxnStatus PaymentInfo::COMPLETED; -constexpr PaymentInfo_TxnStatus PaymentInfo::FAILED; -constexpr PaymentInfo_TxnStatus PaymentInfo::FAILED_RISK; -constexpr PaymentInfo_TxnStatus PaymentInfo::FAILED_PROCESSING; -constexpr PaymentInfo_TxnStatus PaymentInfo::FAILED_RECEIVER_PROCESSING; -constexpr PaymentInfo_TxnStatus PaymentInfo::FAILED_DA; -constexpr PaymentInfo_TxnStatus PaymentInfo::FAILED_DA_FINAL; -constexpr PaymentInfo_TxnStatus PaymentInfo::REFUNDED_TXN; -constexpr PaymentInfo_TxnStatus PaymentInfo::REFUND_FAILED; -constexpr PaymentInfo_TxnStatus PaymentInfo::REFUND_FAILED_PROCESSING; -constexpr PaymentInfo_TxnStatus PaymentInfo::REFUND_FAILED_DA; -constexpr PaymentInfo_TxnStatus PaymentInfo::EXPIRED_TXN; -constexpr PaymentInfo_TxnStatus PaymentInfo::AUTH_CANCELED; -constexpr PaymentInfo_TxnStatus PaymentInfo::AUTH_CANCEL_FAILED_PROCESSING; -constexpr PaymentInfo_TxnStatus PaymentInfo::AUTH_CANCEL_FAILED; -constexpr PaymentInfo_TxnStatus PaymentInfo::COLLECT_INIT; -constexpr PaymentInfo_TxnStatus PaymentInfo::COLLECT_SUCCESS; -constexpr PaymentInfo_TxnStatus PaymentInfo::COLLECT_FAILED; -constexpr PaymentInfo_TxnStatus PaymentInfo::COLLECT_FAILED_RISK; -constexpr PaymentInfo_TxnStatus PaymentInfo::COLLECT_REJECTED; -constexpr PaymentInfo_TxnStatus PaymentInfo::COLLECT_EXPIRED; -constexpr PaymentInfo_TxnStatus PaymentInfo::COLLECT_CANCELED; -constexpr PaymentInfo_TxnStatus PaymentInfo::COLLECT_CANCELLING; -constexpr PaymentInfo_TxnStatus PaymentInfo::IN_REVIEW; -constexpr PaymentInfo_TxnStatus PaymentInfo::REVERSAL_SUCCESS; -constexpr PaymentInfo_TxnStatus PaymentInfo::REVERSAL_PENDING; -constexpr PaymentInfo_TxnStatus PaymentInfo::REFUND_PENDING; -constexpr PaymentInfo_TxnStatus PaymentInfo::TxnStatus_MIN; -constexpr PaymentInfo_TxnStatus PaymentInfo::TxnStatus_MAX; -constexpr int PaymentInfo::TxnStatus_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SyncdMutation_SyncdOperation_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[46]; -} -bool SyncdMutation_SyncdOperation_IsValid(int value) { - switch (value) { - case 0: - case 1: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr SyncdMutation_SyncdOperation SyncdMutation::SET; -constexpr SyncdMutation_SyncdOperation SyncdMutation::REMOVE; -constexpr SyncdMutation_SyncdOperation SyncdMutation::SyncdOperation_MIN; -constexpr SyncdMutation_SyncdOperation SyncdMutation::SyncdOperation_MAX; -constexpr int SyncdMutation::SyncdOperation_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WebFeatures_Flag_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[47]; -} -bool WebFeatures_Flag_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - case 3: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr WebFeatures_Flag WebFeatures::NOT_STARTED; -constexpr WebFeatures_Flag WebFeatures::FORCE_UPGRADE; -constexpr WebFeatures_Flag WebFeatures::DEVELOPMENT; -constexpr WebFeatures_Flag WebFeatures::PRODUCTION; -constexpr WebFeatures_Flag WebFeatures::Flag_MIN; -constexpr WebFeatures_Flag WebFeatures::Flag_MAX; -constexpr int WebFeatures::Flag_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WebMessageInfo_BizPrivacyStatus_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[48]; -} -bool WebMessageInfo_BizPrivacyStatus_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - case 3: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr WebMessageInfo_BizPrivacyStatus WebMessageInfo::E2EE; -constexpr WebMessageInfo_BizPrivacyStatus WebMessageInfo::FB; -constexpr WebMessageInfo_BizPrivacyStatus WebMessageInfo::BSP; -constexpr WebMessageInfo_BizPrivacyStatus WebMessageInfo::BSP_AND_FB; -constexpr WebMessageInfo_BizPrivacyStatus WebMessageInfo::BizPrivacyStatus_MIN; -constexpr WebMessageInfo_BizPrivacyStatus WebMessageInfo::BizPrivacyStatus_MAX; -constexpr int WebMessageInfo::BizPrivacyStatus_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WebMessageInfo_Status_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[49]; -} -bool WebMessageInfo_Status_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - case 3: - case 4: - case 5: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr WebMessageInfo_Status WebMessageInfo::ERROR; -constexpr WebMessageInfo_Status WebMessageInfo::PENDING; -constexpr WebMessageInfo_Status WebMessageInfo::SERVER_ACK; -constexpr WebMessageInfo_Status WebMessageInfo::DELIVERY_ACK; -constexpr WebMessageInfo_Status WebMessageInfo::READ; -constexpr WebMessageInfo_Status WebMessageInfo::PLAYED; -constexpr WebMessageInfo_Status WebMessageInfo::Status_MIN; -constexpr WebMessageInfo_Status WebMessageInfo::Status_MAX; -constexpr int WebMessageInfo::Status_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WebMessageInfo_StubType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[50]; -} -bool WebMessageInfo_StubType_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - case 3: - case 4: - case 5: - case 6: - case 7: - case 8: - case 9: - case 10: - case 11: - case 12: - case 13: - case 14: - case 15: - case 16: - case 17: - case 18: - case 19: - case 20: - case 21: - case 22: - case 23: - case 24: - case 25: - case 26: - case 27: - case 28: - case 29: - case 30: - case 31: - case 32: - case 33: - case 34: - case 35: - case 36: - case 37: - case 38: - case 39: - case 40: - case 41: - case 42: - case 43: - case 44: - case 45: - case 46: - case 47: - case 48: - case 49: - case 50: - case 51: - case 52: - case 53: - case 54: - case 55: - case 56: - case 57: - case 58: - case 59: - case 60: - case 61: - case 62: - case 63: - case 64: - case 65: - case 66: - case 67: - case 68: - case 69: - case 70: - case 71: - case 72: - case 73: - case 74: - case 75: - case 76: - case 77: - case 78: - case 79: - case 80: - case 81: - case 82: - case 83: - case 84: - case 85: - case 86: - case 87: - case 88: - case 89: - case 90: - case 91: - case 92: - case 93: - case 94: - case 95: - case 96: - case 97: - case 98: - case 99: - case 100: - case 101: - case 102: - case 103: - case 104: - case 105: - case 106: - case 107: - case 108: - case 109: - case 110: - case 111: - case 112: - case 113: - case 114: - case 115: - case 116: - case 117: - case 118: - case 119: - case 120: - case 121: - case 122: - case 123: - case 124: - case 125: - case 126: - case 127: - case 128: - case 129: - case 130: - case 131: - case 132: - case 133: - case 134: - case 135: - case 136: - case 137: - case 138: - case 139: - case 140: - case 141: - case 142: - case 143: - case 144: - case 145: - case 146: - case 147: - case 148: - case 149: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr WebMessageInfo_StubType WebMessageInfo::UNKNOWN; -constexpr WebMessageInfo_StubType WebMessageInfo::REVOKE; -constexpr WebMessageInfo_StubType WebMessageInfo::CIPHERTEXT; -constexpr WebMessageInfo_StubType WebMessageInfo::FUTUREPROOF; -constexpr WebMessageInfo_StubType WebMessageInfo::NON_VERIFIED_TRANSITION; -constexpr WebMessageInfo_StubType WebMessageInfo::UNVERIFIED_TRANSITION; -constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_TRANSITION; -constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_LOW_UNKNOWN; -constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_HIGH; -constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_INITIAL_UNKNOWN; -constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_INITIAL_LOW; -constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_INITIAL_HIGH; -constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_TRANSITION_ANY_TO_NONE; -constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_TRANSITION_ANY_TO_HIGH; -constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_TRANSITION_HIGH_TO_LOW; -constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_TRANSITION_HIGH_TO_UNKNOWN; -constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_TRANSITION_UNKNOWN_TO_LOW; -constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_TRANSITION_LOW_TO_UNKNOWN; -constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_TRANSITION_NONE_TO_LOW; -constexpr WebMessageInfo_StubType WebMessageInfo::VERIFIED_TRANSITION_NONE_TO_UNKNOWN; -constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_CREATE; -constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_CHANGE_SUBJECT; -constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_CHANGE_ICON; -constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_CHANGE_INVITE_LINK; -constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_CHANGE_DESCRIPTION; -constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_CHANGE_RESTRICT; -constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_CHANGE_ANNOUNCE; -constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_PARTICIPANT_ADD; -constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_PARTICIPANT_REMOVE; -constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_PARTICIPANT_PROMOTE; -constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_PARTICIPANT_DEMOTE; -constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_PARTICIPANT_INVITE; -constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_PARTICIPANT_LEAVE; -constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_PARTICIPANT_CHANGE_NUMBER; -constexpr WebMessageInfo_StubType WebMessageInfo::BROADCAST_CREATE; -constexpr WebMessageInfo_StubType WebMessageInfo::BROADCAST_ADD; -constexpr WebMessageInfo_StubType WebMessageInfo::BROADCAST_REMOVE; -constexpr WebMessageInfo_StubType WebMessageInfo::GENERIC_NOTIFICATION; -constexpr WebMessageInfo_StubType WebMessageInfo::E2E_IDENTITY_CHANGED; -constexpr WebMessageInfo_StubType WebMessageInfo::E2E_ENCRYPTED; -constexpr WebMessageInfo_StubType WebMessageInfo::CALL_MISSED_VOICE; -constexpr WebMessageInfo_StubType WebMessageInfo::CALL_MISSED_VIDEO; -constexpr WebMessageInfo_StubType WebMessageInfo::INDIVIDUAL_CHANGE_NUMBER; -constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_DELETE; -constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_ANNOUNCE_MODE_MESSAGE_BOUNCE; -constexpr WebMessageInfo_StubType WebMessageInfo::CALL_MISSED_GROUP_VOICE; -constexpr WebMessageInfo_StubType WebMessageInfo::CALL_MISSED_GROUP_VIDEO; -constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_CIPHERTEXT; -constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_FUTUREPROOF; -constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_TRANSACTION_STATUS_UPDATE_FAILED; -constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_TRANSACTION_STATUS_UPDATE_REFUNDED; -constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_TRANSACTION_STATUS_UPDATE_REFUND_FAILED; -constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_TRANSACTION_STATUS_RECEIVER_PENDING_SETUP; -constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_TRANSACTION_STATUS_RECEIVER_SUCCESS_AFTER_HICCUP; -constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_ACTION_ACCOUNT_SETUP_REMINDER; -constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_ACTION_SEND_PAYMENT_REMINDER; -constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_ACTION_SEND_PAYMENT_INVITATION; -constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_ACTION_REQUEST_DECLINED; -constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_ACTION_REQUEST_EXPIRED; -constexpr WebMessageInfo_StubType WebMessageInfo::PAYMENT_ACTION_REQUEST_CANCELLED; -constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_VERIFIED_TRANSITION_TOP_TO_BOTTOM; -constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_VERIFIED_TRANSITION_BOTTOM_TO_TOP; -constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_INTRO_TOP; -constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_INTRO_BOTTOM; -constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_NAME_CHANGE; -constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_MOVE_TO_CONSUMER_APP; -constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_TWO_TIER_MIGRATION_TOP; -constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_TWO_TIER_MIGRATION_BOTTOM; -constexpr WebMessageInfo_StubType WebMessageInfo::OVERSIZED; -constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_CHANGE_NO_FREQUENTLY_FORWARDED; -constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_V4_ADD_INVITE_SENT; -constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_PARTICIPANT_ADD_REQUEST_JOIN; -constexpr WebMessageInfo_StubType WebMessageInfo::CHANGE_EPHEMERAL_SETTING; -constexpr WebMessageInfo_StubType WebMessageInfo::E2E_DEVICE_CHANGED; -constexpr WebMessageInfo_StubType WebMessageInfo::VIEWED_ONCE; -constexpr WebMessageInfo_StubType WebMessageInfo::E2E_ENCRYPTED_NOW; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_TO_BSP_PREMISE; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_TO_SELF_FB; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_TO_SELF_PREMISE; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_UNVERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_VERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_PREMISE_TO_SELF_PREMISE; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_PREMISE_UNVERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_PREMISE_UNVERIFIED_TO_SELF_PREMISE_VERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_PREMISE_VERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_PREMISE_VERIFIED_TO_SELF_PREMISE_UNVERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_CONSUMER_TO_BSP_FB_UNVERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_CONSUMER_TO_BSP_PREMISE_UNVERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_CONSUMER_TO_SELF_FB_UNVERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_CONSUMER_TO_SELF_PREMISE_UNVERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_FB_TO_BSP_PREMISE; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_FB_TO_SELF_PREMISE; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_FB_UNVERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_FB_VERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_PREMISE_TO_BSP_PREMISE; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_PREMISE_UNVERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_PREMISE_VERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_TO_BSP_FB; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_TO_CONSUMER; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_TO_SELF_FB; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_UNVERIFIED_TO_BSP_FB_VERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_UNVERIFIED_TO_BSP_PREMISE_VERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_UNVERIFIED_TO_SELF_FB_VERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_UNVERIFIED_TO_VERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_VERIFIED_TO_BSP_FB_UNVERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_VERIFIED_TO_BSP_PREMISE_UNVERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_VERIFIED_TO_SELF_FB_UNVERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_VERIFIED_TO_UNVERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_FB_VERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_FB_UNVERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLUE_MSG_SELF_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED; -constexpr WebMessageInfo_StubType WebMessageInfo::E2E_IDENTITY_UNAVAILABLE; -constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_CREATING; -constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_CREATE_FAILED; -constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_BOUNCED; -constexpr WebMessageInfo_StubType WebMessageInfo::BLOCK_CONTACT; -constexpr WebMessageInfo_StubType WebMessageInfo::EPHEMERAL_SETTING_NOT_APPLIED; -constexpr WebMessageInfo_StubType WebMessageInfo::SYNC_FAILED; -constexpr WebMessageInfo_StubType WebMessageInfo::SYNCING; -constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_PRIVACY_MODE_INIT_FB; -constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_PRIVACY_MODE_INIT_BSP; -constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_PRIVACY_MODE_TO_FB; -constexpr WebMessageInfo_StubType WebMessageInfo::BIZ_PRIVACY_MODE_TO_BSP; -constexpr WebMessageInfo_StubType WebMessageInfo::DISAPPEARING_MODE; -constexpr WebMessageInfo_StubType WebMessageInfo::E2E_DEVICE_FETCH_FAILED; -constexpr WebMessageInfo_StubType WebMessageInfo::ADMIN_REVOKE; -constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_INVITE_LINK_GROWTH_LOCKED; -constexpr WebMessageInfo_StubType WebMessageInfo::COMMUNITY_LINK_PARENT_GROUP; -constexpr WebMessageInfo_StubType WebMessageInfo::COMMUNITY_LINK_SIBLING_GROUP; -constexpr WebMessageInfo_StubType WebMessageInfo::COMMUNITY_LINK_SUB_GROUP; -constexpr WebMessageInfo_StubType WebMessageInfo::COMMUNITY_UNLINK_PARENT_GROUP; -constexpr WebMessageInfo_StubType WebMessageInfo::COMMUNITY_UNLINK_SIBLING_GROUP; -constexpr WebMessageInfo_StubType WebMessageInfo::COMMUNITY_UNLINK_SUB_GROUP; -constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_PARTICIPANT_ACCEPT; -constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_PARTICIPANT_LINKED_GROUP_JOIN; -constexpr WebMessageInfo_StubType WebMessageInfo::COMMUNITY_CREATE; -constexpr WebMessageInfo_StubType WebMessageInfo::EPHEMERAL_KEEP_IN_CHAT; -constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST; -constexpr WebMessageInfo_StubType WebMessageInfo::GROUP_MEMBERSHIP_JOIN_APPROVAL_MODE; -constexpr WebMessageInfo_StubType WebMessageInfo::INTEGRITY_UNLINK_PARENT_GROUP; -constexpr WebMessageInfo_StubType WebMessageInfo::COMMUNITY_PARTICIPANT_PROMOTE; -constexpr WebMessageInfo_StubType WebMessageInfo::COMMUNITY_PARTICIPANT_DEMOTE; -constexpr WebMessageInfo_StubType WebMessageInfo::COMMUNITY_PARENT_GROUP_DELETED; -constexpr WebMessageInfo_StubType WebMessageInfo::StubType_MIN; -constexpr WebMessageInfo_StubType WebMessageInfo::StubType_MAX; -constexpr int WebMessageInfo::StubType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* KeepType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[51]; -} -bool KeepType_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - return true; - default: - return false; - } -} - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MediaVisibility_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_pmsg_2eproto); - return file_level_enum_descriptors_pmsg_2eproto[52]; -} -bool MediaVisibility_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - return true; - default: - return false; - } -} - - -// =================================================================== - -class ADVDeviceIdentity::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_rawid(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_timestamp(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_keyindex(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } -}; - -ADVDeviceIdentity::ADVDeviceIdentity(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.ADVDeviceIdentity) -} -ADVDeviceIdentity::ADVDeviceIdentity(const ADVDeviceIdentity& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - ADVDeviceIdentity* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.timestamp_){} - , decltype(_impl_.rawid_){} - , decltype(_impl_.keyindex_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&_impl_.timestamp_, &from._impl_.timestamp_, - static_cast(reinterpret_cast(&_impl_.keyindex_) - - reinterpret_cast(&_impl_.timestamp_)) + sizeof(_impl_.keyindex_)); - // @@protoc_insertion_point(copy_constructor:proto.ADVDeviceIdentity) -} - -inline void ADVDeviceIdentity::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.timestamp_){uint64_t{0u}} - , decltype(_impl_.rawid_){0u} - , decltype(_impl_.keyindex_){0u} - }; -} - -ADVDeviceIdentity::~ADVDeviceIdentity() { - // @@protoc_insertion_point(destructor:proto.ADVDeviceIdentity) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void ADVDeviceIdentity::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void ADVDeviceIdentity::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void ADVDeviceIdentity::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.ADVDeviceIdentity) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - ::memset(&_impl_.timestamp_, 0, static_cast( - reinterpret_cast(&_impl_.keyindex_) - - reinterpret_cast(&_impl_.timestamp_)) + sizeof(_impl_.keyindex_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ADVDeviceIdentity::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional uint32 rawId = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_rawid(&has_bits); - _impl_.rawid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint64 timestamp = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_timestamp(&has_bits); - _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 keyIndex = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_keyindex(&has_bits); - _impl_.keyindex_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ADVDeviceIdentity::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.ADVDeviceIdentity) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional uint32 rawId = 1; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_rawid(), target); - } - - // optional uint64 timestamp = 2; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_timestamp(), target); - } - - // optional uint32 keyIndex = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_keyindex(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.ADVDeviceIdentity) - return target; -} - -size_t ADVDeviceIdentity::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.ADVDeviceIdentity) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional uint64 timestamp = 2; - if (cached_has_bits & 0x00000001u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_timestamp()); - } - - // optional uint32 rawId = 1; - if (cached_has_bits & 0x00000002u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_rawid()); - } - - // optional uint32 keyIndex = 3; - if (cached_has_bits & 0x00000004u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_keyindex()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ADVDeviceIdentity::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - ADVDeviceIdentity::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ADVDeviceIdentity::GetClassData() const { return &_class_data_; } - - -void ADVDeviceIdentity::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.ADVDeviceIdentity) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_impl_.timestamp_ = from._impl_.timestamp_; - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.rawid_ = from._impl_.rawid_; - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.keyindex_ = from._impl_.keyindex_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ADVDeviceIdentity::CopyFrom(const ADVDeviceIdentity& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.ADVDeviceIdentity) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ADVDeviceIdentity::IsInitialized() const { - return true; -} - -void ADVDeviceIdentity::InternalSwap(ADVDeviceIdentity* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ADVDeviceIdentity, _impl_.keyindex_) - + sizeof(ADVDeviceIdentity::_impl_.keyindex_) - - PROTOBUF_FIELD_OFFSET(ADVDeviceIdentity, _impl_.timestamp_)>( - reinterpret_cast(&_impl_.timestamp_), - reinterpret_cast(&other->_impl_.timestamp_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ADVDeviceIdentity::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[0]); -} - -// =================================================================== - -class ADVKeyIndexList::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_rawid(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_timestamp(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_currentindex(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } -}; - -ADVKeyIndexList::ADVKeyIndexList(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.ADVKeyIndexList) -} -ADVKeyIndexList::ADVKeyIndexList(const ADVKeyIndexList& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - ADVKeyIndexList* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.validindexes_){from._impl_.validindexes_} - , /*decltype(_impl_._validindexes_cached_byte_size_)*/{0} - , decltype(_impl_.timestamp_){} - , decltype(_impl_.rawid_){} - , decltype(_impl_.currentindex_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&_impl_.timestamp_, &from._impl_.timestamp_, - static_cast(reinterpret_cast(&_impl_.currentindex_) - - reinterpret_cast(&_impl_.timestamp_)) + sizeof(_impl_.currentindex_)); - // @@protoc_insertion_point(copy_constructor:proto.ADVKeyIndexList) -} - -inline void ADVKeyIndexList::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.validindexes_){arena} - , /*decltype(_impl_._validindexes_cached_byte_size_)*/{0} - , decltype(_impl_.timestamp_){uint64_t{0u}} - , decltype(_impl_.rawid_){0u} - , decltype(_impl_.currentindex_){0u} - }; -} - -ADVKeyIndexList::~ADVKeyIndexList() { - // @@protoc_insertion_point(destructor:proto.ADVKeyIndexList) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void ADVKeyIndexList::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.validindexes_.~RepeatedField(); -} - -void ADVKeyIndexList::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void ADVKeyIndexList::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.ADVKeyIndexList) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.validindexes_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - ::memset(&_impl_.timestamp_, 0, static_cast( - reinterpret_cast(&_impl_.currentindex_) - - reinterpret_cast(&_impl_.timestamp_)) + sizeof(_impl_.currentindex_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ADVKeyIndexList::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional uint32 rawId = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_rawid(&has_bits); - _impl_.rawid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint64 timestamp = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_timestamp(&has_bits); - _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 currentIndex = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_currentindex(&has_bits); - _impl_.currentindex_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated uint32 validIndexes = 4 [packed = true]; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_validindexes(), ptr, ctx); - CHK_(ptr); - } else if (static_cast(tag) == 32) { - _internal_add_validindexes(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ADVKeyIndexList::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.ADVKeyIndexList) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional uint32 rawId = 1; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_rawid(), target); - } - - // optional uint64 timestamp = 2; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_timestamp(), target); - } - - // optional uint32 currentIndex = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_currentindex(), target); - } - - // repeated uint32 validIndexes = 4 [packed = true]; - { - int byte_size = _impl_._validindexes_cached_byte_size_.load(std::memory_order_relaxed); - if (byte_size > 0) { - target = stream->WriteUInt32Packed( - 4, _internal_validindexes(), byte_size, target); - } - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.ADVKeyIndexList) - return target; -} - -size_t ADVKeyIndexList::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.ADVKeyIndexList) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated uint32 validIndexes = 4 [packed = true]; - { - size_t data_size = ::_pbi::WireFormatLite:: - UInt32Size(this->_impl_.validindexes_); - if (data_size > 0) { - total_size += 1 + - ::_pbi::WireFormatLite::Int32Size(static_cast(data_size)); - } - int cached_size = ::_pbi::ToCachedSize(data_size); - _impl_._validindexes_cached_byte_size_.store(cached_size, - std::memory_order_relaxed); - total_size += data_size; - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional uint64 timestamp = 2; - if (cached_has_bits & 0x00000001u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_timestamp()); - } - - // optional uint32 rawId = 1; - if (cached_has_bits & 0x00000002u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_rawid()); - } - - // optional uint32 currentIndex = 3; - if (cached_has_bits & 0x00000004u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_currentindex()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ADVKeyIndexList::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - ADVKeyIndexList::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ADVKeyIndexList::GetClassData() const { return &_class_data_; } - - -void ADVKeyIndexList::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.ADVKeyIndexList) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.validindexes_.MergeFrom(from._impl_.validindexes_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_impl_.timestamp_ = from._impl_.timestamp_; - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.rawid_ = from._impl_.rawid_; - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.currentindex_ = from._impl_.currentindex_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ADVKeyIndexList::CopyFrom(const ADVKeyIndexList& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.ADVKeyIndexList) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ADVKeyIndexList::IsInitialized() const { - return true; -} - -void ADVKeyIndexList::InternalSwap(ADVKeyIndexList* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.validindexes_.InternalSwap(&other->_impl_.validindexes_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ADVKeyIndexList, _impl_.currentindex_) - + sizeof(ADVKeyIndexList::_impl_.currentindex_) - - PROTOBUF_FIELD_OFFSET(ADVKeyIndexList, _impl_.timestamp_)>( - reinterpret_cast(&_impl_.timestamp_), - reinterpret_cast(&other->_impl_.timestamp_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ADVKeyIndexList::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[1]); -} - -// =================================================================== - -class ADVSignedDeviceIdentity::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_details(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_accountsignaturekey(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_accountsignature(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_devicesignature(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } -}; - -ADVSignedDeviceIdentity::ADVSignedDeviceIdentity(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.ADVSignedDeviceIdentity) -} -ADVSignedDeviceIdentity::ADVSignedDeviceIdentity(const ADVSignedDeviceIdentity& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - ADVSignedDeviceIdentity* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.details_){} - , decltype(_impl_.accountsignaturekey_){} - , decltype(_impl_.accountsignature_){} - , decltype(_impl_.devicesignature_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.details_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.details_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_details()) { - _this->_impl_.details_.Set(from._internal_details(), - _this->GetArenaForAllocation()); - } - _impl_.accountsignaturekey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.accountsignaturekey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_accountsignaturekey()) { - _this->_impl_.accountsignaturekey_.Set(from._internal_accountsignaturekey(), - _this->GetArenaForAllocation()); - } - _impl_.accountsignature_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.accountsignature_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_accountsignature()) { - _this->_impl_.accountsignature_.Set(from._internal_accountsignature(), - _this->GetArenaForAllocation()); - } - _impl_.devicesignature_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.devicesignature_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_devicesignature()) { - _this->_impl_.devicesignature_.Set(from._internal_devicesignature(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.ADVSignedDeviceIdentity) -} - -inline void ADVSignedDeviceIdentity::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.details_){} - , decltype(_impl_.accountsignaturekey_){} - , decltype(_impl_.accountsignature_){} - , decltype(_impl_.devicesignature_){} - }; - _impl_.details_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.details_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.accountsignaturekey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.accountsignaturekey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.accountsignature_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.accountsignature_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.devicesignature_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.devicesignature_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -ADVSignedDeviceIdentity::~ADVSignedDeviceIdentity() { - // @@protoc_insertion_point(destructor:proto.ADVSignedDeviceIdentity) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void ADVSignedDeviceIdentity::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.details_.Destroy(); - _impl_.accountsignaturekey_.Destroy(); - _impl_.accountsignature_.Destroy(); - _impl_.devicesignature_.Destroy(); -} - -void ADVSignedDeviceIdentity::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void ADVSignedDeviceIdentity::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.ADVSignedDeviceIdentity) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - if (cached_has_bits & 0x00000001u) { - _impl_.details_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.accountsignaturekey_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.accountsignature_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000008u) { - _impl_.devicesignature_.ClearNonDefaultToEmpty(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ADVSignedDeviceIdentity::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bytes details = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_details(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes accountSignatureKey = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_accountsignaturekey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes accountSignature = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_accountsignature(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes deviceSignature = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - auto str = _internal_mutable_devicesignature(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ADVSignedDeviceIdentity::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.ADVSignedDeviceIdentity) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bytes details = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 1, this->_internal_details(), target); - } - - // optional bytes accountSignatureKey = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_accountsignaturekey(), target); - } - - // optional bytes accountSignature = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->WriteBytesMaybeAliased( - 3, this->_internal_accountsignature(), target); - } - - // optional bytes deviceSignature = 4; - if (cached_has_bits & 0x00000008u) { - target = stream->WriteBytesMaybeAliased( - 4, this->_internal_devicesignature(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.ADVSignedDeviceIdentity) - return target; -} - -size_t ADVSignedDeviceIdentity::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.ADVSignedDeviceIdentity) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - // optional bytes details = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_details()); - } - - // optional bytes accountSignatureKey = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_accountsignaturekey()); - } - - // optional bytes accountSignature = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_accountsignature()); - } - - // optional bytes deviceSignature = 4; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_devicesignature()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ADVSignedDeviceIdentity::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - ADVSignedDeviceIdentity::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ADVSignedDeviceIdentity::GetClassData() const { return &_class_data_; } - - -void ADVSignedDeviceIdentity::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.ADVSignedDeviceIdentity) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_details(from._internal_details()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_accountsignaturekey(from._internal_accountsignaturekey()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_accountsignature(from._internal_accountsignature()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_set_devicesignature(from._internal_devicesignature()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ADVSignedDeviceIdentity::CopyFrom(const ADVSignedDeviceIdentity& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.ADVSignedDeviceIdentity) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ADVSignedDeviceIdentity::IsInitialized() const { - return true; -} - -void ADVSignedDeviceIdentity::InternalSwap(ADVSignedDeviceIdentity* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.details_, lhs_arena, - &other->_impl_.details_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.accountsignaturekey_, lhs_arena, - &other->_impl_.accountsignaturekey_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.accountsignature_, lhs_arena, - &other->_impl_.accountsignature_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.devicesignature_, lhs_arena, - &other->_impl_.devicesignature_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ADVSignedDeviceIdentity::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[2]); -} - -// =================================================================== - -class ADVSignedDeviceIdentityHMAC::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_details(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_hmac(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -ADVSignedDeviceIdentityHMAC::ADVSignedDeviceIdentityHMAC(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.ADVSignedDeviceIdentityHMAC) -} -ADVSignedDeviceIdentityHMAC::ADVSignedDeviceIdentityHMAC(const ADVSignedDeviceIdentityHMAC& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - ADVSignedDeviceIdentityHMAC* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.details_){} - , decltype(_impl_.hmac_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.details_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.details_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_details()) { - _this->_impl_.details_.Set(from._internal_details(), - _this->GetArenaForAllocation()); - } - _impl_.hmac_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.hmac_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_hmac()) { - _this->_impl_.hmac_.Set(from._internal_hmac(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.ADVSignedDeviceIdentityHMAC) -} - -inline void ADVSignedDeviceIdentityHMAC::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.details_){} - , decltype(_impl_.hmac_){} - }; - _impl_.details_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.details_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.hmac_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.hmac_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -ADVSignedDeviceIdentityHMAC::~ADVSignedDeviceIdentityHMAC() { - // @@protoc_insertion_point(destructor:proto.ADVSignedDeviceIdentityHMAC) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void ADVSignedDeviceIdentityHMAC::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.details_.Destroy(); - _impl_.hmac_.Destroy(); -} - -void ADVSignedDeviceIdentityHMAC::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void ADVSignedDeviceIdentityHMAC::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.ADVSignedDeviceIdentityHMAC) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.details_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.hmac_.ClearNonDefaultToEmpty(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ADVSignedDeviceIdentityHMAC::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bytes details = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_details(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes hmac = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_hmac(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ADVSignedDeviceIdentityHMAC::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.ADVSignedDeviceIdentityHMAC) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bytes details = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 1, this->_internal_details(), target); - } - - // optional bytes hmac = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_hmac(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.ADVSignedDeviceIdentityHMAC) - return target; -} - -size_t ADVSignedDeviceIdentityHMAC::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.ADVSignedDeviceIdentityHMAC) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional bytes details = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_details()); - } - - // optional bytes hmac = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_hmac()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ADVSignedDeviceIdentityHMAC::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - ADVSignedDeviceIdentityHMAC::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ADVSignedDeviceIdentityHMAC::GetClassData() const { return &_class_data_; } - - -void ADVSignedDeviceIdentityHMAC::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.ADVSignedDeviceIdentityHMAC) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_details(from._internal_details()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_hmac(from._internal_hmac()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ADVSignedDeviceIdentityHMAC::CopyFrom(const ADVSignedDeviceIdentityHMAC& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.ADVSignedDeviceIdentityHMAC) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ADVSignedDeviceIdentityHMAC::IsInitialized() const { - return true; -} - -void ADVSignedDeviceIdentityHMAC::InternalSwap(ADVSignedDeviceIdentityHMAC* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.details_, lhs_arena, - &other->_impl_.details_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.hmac_, lhs_arena, - &other->_impl_.hmac_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ADVSignedDeviceIdentityHMAC::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[3]); -} - -// =================================================================== - -class ADVSignedKeyIndexList::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_details(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_accountsignature(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -ADVSignedKeyIndexList::ADVSignedKeyIndexList(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.ADVSignedKeyIndexList) -} -ADVSignedKeyIndexList::ADVSignedKeyIndexList(const ADVSignedKeyIndexList& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - ADVSignedKeyIndexList* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.details_){} - , decltype(_impl_.accountsignature_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.details_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.details_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_details()) { - _this->_impl_.details_.Set(from._internal_details(), - _this->GetArenaForAllocation()); - } - _impl_.accountsignature_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.accountsignature_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_accountsignature()) { - _this->_impl_.accountsignature_.Set(from._internal_accountsignature(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.ADVSignedKeyIndexList) -} - -inline void ADVSignedKeyIndexList::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.details_){} - , decltype(_impl_.accountsignature_){} - }; - _impl_.details_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.details_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.accountsignature_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.accountsignature_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -ADVSignedKeyIndexList::~ADVSignedKeyIndexList() { - // @@protoc_insertion_point(destructor:proto.ADVSignedKeyIndexList) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void ADVSignedKeyIndexList::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.details_.Destroy(); - _impl_.accountsignature_.Destroy(); -} - -void ADVSignedKeyIndexList::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void ADVSignedKeyIndexList::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.ADVSignedKeyIndexList) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.details_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.accountsignature_.ClearNonDefaultToEmpty(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ADVSignedKeyIndexList::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bytes details = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_details(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes accountSignature = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_accountsignature(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ADVSignedKeyIndexList::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.ADVSignedKeyIndexList) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bytes details = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 1, this->_internal_details(), target); - } - - // optional bytes accountSignature = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_accountsignature(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.ADVSignedKeyIndexList) - return target; -} - -size_t ADVSignedKeyIndexList::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.ADVSignedKeyIndexList) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional bytes details = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_details()); - } - - // optional bytes accountSignature = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_accountsignature()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ADVSignedKeyIndexList::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - ADVSignedKeyIndexList::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ADVSignedKeyIndexList::GetClassData() const { return &_class_data_; } - - -void ADVSignedKeyIndexList::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.ADVSignedKeyIndexList) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_details(from._internal_details()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_accountsignature(from._internal_accountsignature()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ADVSignedKeyIndexList::CopyFrom(const ADVSignedKeyIndexList& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.ADVSignedKeyIndexList) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ADVSignedKeyIndexList::IsInitialized() const { - return true; -} - -void ADVSignedKeyIndexList::InternalSwap(ADVSignedKeyIndexList* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.details_, lhs_arena, - &other->_impl_.details_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.accountsignature_, lhs_arena, - &other->_impl_.accountsignature_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ADVSignedKeyIndexList::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[4]); -} - -// =================================================================== - -class ActionLink::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_url(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_buttontitle(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -ActionLink::ActionLink(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.ActionLink) -} -ActionLink::ActionLink(const ActionLink& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - ActionLink* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.url_){} - , decltype(_impl_.buttontitle_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.url_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.url_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_url()) { - _this->_impl_.url_.Set(from._internal_url(), - _this->GetArenaForAllocation()); - } - _impl_.buttontitle_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.buttontitle_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_buttontitle()) { - _this->_impl_.buttontitle_.Set(from._internal_buttontitle(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.ActionLink) -} - -inline void ActionLink::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.url_){} - , decltype(_impl_.buttontitle_){} - }; - _impl_.url_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.url_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.buttontitle_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.buttontitle_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -ActionLink::~ActionLink() { - // @@protoc_insertion_point(destructor:proto.ActionLink) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void ActionLink::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.url_.Destroy(); - _impl_.buttontitle_.Destroy(); -} - -void ActionLink::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void ActionLink::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.ActionLink) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.url_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.buttontitle_.ClearNonDefaultToEmpty(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ActionLink::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string url = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_url(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ActionLink.url"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string buttonTitle = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_buttontitle(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ActionLink.buttonTitle"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ActionLink::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.ActionLink) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string url = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_url().data(), static_cast(this->_internal_url().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ActionLink.url"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_url(), target); - } - - // optional string buttonTitle = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_buttontitle().data(), static_cast(this->_internal_buttontitle().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ActionLink.buttonTitle"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_buttontitle(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.ActionLink) - return target; -} - -size_t ActionLink::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.ActionLink) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional string url = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_url()); - } - - // optional string buttonTitle = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_buttontitle()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ActionLink::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - ActionLink::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ActionLink::GetClassData() const { return &_class_data_; } - - -void ActionLink::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.ActionLink) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_url(from._internal_url()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_buttontitle(from._internal_buttontitle()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ActionLink::CopyFrom(const ActionLink& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.ActionLink) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ActionLink::IsInitialized() const { - return true; -} - -void ActionLink::InternalSwap(ActionLink* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.url_, lhs_arena, - &other->_impl_.url_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.buttontitle_, lhs_arena, - &other->_impl_.buttontitle_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ActionLink::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[5]); -} - -// =================================================================== - -class AutoDownloadSettings::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_downloadimages(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_downloadaudio(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_downloadvideo(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_downloaddocuments(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } -}; - -AutoDownloadSettings::AutoDownloadSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.AutoDownloadSettings) -} -AutoDownloadSettings::AutoDownloadSettings(const AutoDownloadSettings& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - AutoDownloadSettings* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.downloadimages_){} - , decltype(_impl_.downloadaudio_){} - , decltype(_impl_.downloadvideo_){} - , decltype(_impl_.downloaddocuments_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&_impl_.downloadimages_, &from._impl_.downloadimages_, - static_cast(reinterpret_cast(&_impl_.downloaddocuments_) - - reinterpret_cast(&_impl_.downloadimages_)) + sizeof(_impl_.downloaddocuments_)); - // @@protoc_insertion_point(copy_constructor:proto.AutoDownloadSettings) -} - -inline void AutoDownloadSettings::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.downloadimages_){false} - , decltype(_impl_.downloadaudio_){false} - , decltype(_impl_.downloadvideo_){false} - , decltype(_impl_.downloaddocuments_){false} - }; -} - -AutoDownloadSettings::~AutoDownloadSettings() { - // @@protoc_insertion_point(destructor:proto.AutoDownloadSettings) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void AutoDownloadSettings::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void AutoDownloadSettings::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void AutoDownloadSettings::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.AutoDownloadSettings) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&_impl_.downloadimages_, 0, static_cast( - reinterpret_cast(&_impl_.downloaddocuments_) - - reinterpret_cast(&_impl_.downloadimages_)) + sizeof(_impl_.downloaddocuments_)); - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* AutoDownloadSettings::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bool downloadImages = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_downloadimages(&has_bits); - _impl_.downloadimages_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool downloadAudio = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_downloadaudio(&has_bits); - _impl_.downloadaudio_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool downloadVideo = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_downloadvideo(&has_bits); - _impl_.downloadvideo_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool downloadDocuments = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - _Internal::set_has_downloaddocuments(&has_bits); - _impl_.downloaddocuments_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* AutoDownloadSettings::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.AutoDownloadSettings) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bool downloadImages = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_downloadimages(), target); - } - - // optional bool downloadAudio = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(2, this->_internal_downloadaudio(), target); - } - - // optional bool downloadVideo = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_downloadvideo(), target); - } - - // optional bool downloadDocuments = 4; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(4, this->_internal_downloaddocuments(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.AutoDownloadSettings) - return target; -} - -size_t AutoDownloadSettings::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.AutoDownloadSettings) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - // optional bool downloadImages = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + 1; - } - - // optional bool downloadAudio = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + 1; - } - - // optional bool downloadVideo = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + 1; - } - - // optional bool downloadDocuments = 4; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + 1; - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData AutoDownloadSettings::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - AutoDownloadSettings::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*AutoDownloadSettings::GetClassData() const { return &_class_data_; } - - -void AutoDownloadSettings::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.AutoDownloadSettings) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - if (cached_has_bits & 0x00000001u) { - _this->_impl_.downloadimages_ = from._impl_.downloadimages_; - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.downloadaudio_ = from._impl_.downloadaudio_; - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.downloadvideo_ = from._impl_.downloadvideo_; - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.downloaddocuments_ = from._impl_.downloaddocuments_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void AutoDownloadSettings::CopyFrom(const AutoDownloadSettings& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.AutoDownloadSettings) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool AutoDownloadSettings::IsInitialized() const { - return true; -} - -void AutoDownloadSettings::InternalSwap(AutoDownloadSettings* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(AutoDownloadSettings, _impl_.downloaddocuments_) - + sizeof(AutoDownloadSettings::_impl_.downloaddocuments_) - - PROTOBUF_FIELD_OFFSET(AutoDownloadSettings, _impl_.downloadimages_)>( - reinterpret_cast(&_impl_.downloadimages_), - reinterpret_cast(&other->_impl_.downloadimages_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata AutoDownloadSettings::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[6]); -} - -// =================================================================== - -class BizAccountLinkInfo::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_whatsappbizacctfbid(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_whatsappacctnumber(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_issuetime(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_hoststorage(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_accounttype(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } -}; - -BizAccountLinkInfo::BizAccountLinkInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.BizAccountLinkInfo) -} -BizAccountLinkInfo::BizAccountLinkInfo(const BizAccountLinkInfo& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - BizAccountLinkInfo* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.whatsappacctnumber_){} - , decltype(_impl_.whatsappbizacctfbid_){} - , decltype(_impl_.issuetime_){} - , decltype(_impl_.hoststorage_){} - , decltype(_impl_.accounttype_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.whatsappacctnumber_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.whatsappacctnumber_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_whatsappacctnumber()) { - _this->_impl_.whatsappacctnumber_.Set(from._internal_whatsappacctnumber(), - _this->GetArenaForAllocation()); - } - ::memcpy(&_impl_.whatsappbizacctfbid_, &from._impl_.whatsappbizacctfbid_, - static_cast(reinterpret_cast(&_impl_.accounttype_) - - reinterpret_cast(&_impl_.whatsappbizacctfbid_)) + sizeof(_impl_.accounttype_)); - // @@protoc_insertion_point(copy_constructor:proto.BizAccountLinkInfo) -} - -inline void BizAccountLinkInfo::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.whatsappacctnumber_){} - , decltype(_impl_.whatsappbizacctfbid_){uint64_t{0u}} - , decltype(_impl_.issuetime_){uint64_t{0u}} - , decltype(_impl_.hoststorage_){0} - , decltype(_impl_.accounttype_){0} - }; - _impl_.whatsappacctnumber_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.whatsappacctnumber_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -BizAccountLinkInfo::~BizAccountLinkInfo() { - // @@protoc_insertion_point(destructor:proto.BizAccountLinkInfo) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void BizAccountLinkInfo::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.whatsappacctnumber_.Destroy(); -} - -void BizAccountLinkInfo::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void BizAccountLinkInfo::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.BizAccountLinkInfo) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.whatsappacctnumber_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x0000001eu) { - ::memset(&_impl_.whatsappbizacctfbid_, 0, static_cast( - reinterpret_cast(&_impl_.accounttype_) - - reinterpret_cast(&_impl_.whatsappbizacctfbid_)) + sizeof(_impl_.accounttype_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* BizAccountLinkInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional uint64 whatsappBizAcctFbid = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_whatsappbizacctfbid(&has_bits); - _impl_.whatsappbizacctfbid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string whatsappAcctNumber = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_whatsappacctnumber(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.BizAccountLinkInfo.whatsappAcctNumber"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional uint64 issueTime = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_issuetime(&has_bits); - _impl_.issuetime_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.BizAccountLinkInfo.HostStorageType hostStorage = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::BizAccountLinkInfo_HostStorageType_IsValid(val))) { - _internal_set_hoststorage(static_cast<::proto::BizAccountLinkInfo_HostStorageType>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.BizAccountLinkInfo.AccountType accountType = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::BizAccountLinkInfo_AccountType_IsValid(val))) { - _internal_set_accounttype(static_cast<::proto::BizAccountLinkInfo_AccountType>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* BizAccountLinkInfo::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.BizAccountLinkInfo) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional uint64 whatsappBizAcctFbid = 1; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_whatsappbizacctfbid(), target); - } - - // optional string whatsappAcctNumber = 2; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_whatsappacctnumber().data(), static_cast(this->_internal_whatsappacctnumber().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.BizAccountLinkInfo.whatsappAcctNumber"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_whatsappacctnumber(), target); - } - - // optional uint64 issueTime = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_issuetime(), target); - } - - // optional .proto.BizAccountLinkInfo.HostStorageType hostStorage = 4; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 4, this->_internal_hoststorage(), target); - } - - // optional .proto.BizAccountLinkInfo.AccountType accountType = 5; - if (cached_has_bits & 0x00000010u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 5, this->_internal_accounttype(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.BizAccountLinkInfo) - return target; -} - -size_t BizAccountLinkInfo::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.BizAccountLinkInfo) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { - // optional string whatsappAcctNumber = 2; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_whatsappacctnumber()); - } - - // optional uint64 whatsappBizAcctFbid = 1; - if (cached_has_bits & 0x00000002u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_whatsappbizacctfbid()); - } - - // optional uint64 issueTime = 3; - if (cached_has_bits & 0x00000004u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_issuetime()); - } - - // optional .proto.BizAccountLinkInfo.HostStorageType hostStorage = 4; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_hoststorage()); - } - - // optional .proto.BizAccountLinkInfo.AccountType accountType = 5; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_accounttype()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData BizAccountLinkInfo::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - BizAccountLinkInfo::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*BizAccountLinkInfo::GetClassData() const { return &_class_data_; } - - -void BizAccountLinkInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.BizAccountLinkInfo) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_whatsappacctnumber(from._internal_whatsappacctnumber()); - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.whatsappbizacctfbid_ = from._impl_.whatsappbizacctfbid_; - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.issuetime_ = from._impl_.issuetime_; - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.hoststorage_ = from._impl_.hoststorage_; - } - if (cached_has_bits & 0x00000010u) { - _this->_impl_.accounttype_ = from._impl_.accounttype_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void BizAccountLinkInfo::CopyFrom(const BizAccountLinkInfo& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.BizAccountLinkInfo) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool BizAccountLinkInfo::IsInitialized() const { - return true; -} - -void BizAccountLinkInfo::InternalSwap(BizAccountLinkInfo* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.whatsappacctnumber_, lhs_arena, - &other->_impl_.whatsappacctnumber_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(BizAccountLinkInfo, _impl_.accounttype_) - + sizeof(BizAccountLinkInfo::_impl_.accounttype_) - - PROTOBUF_FIELD_OFFSET(BizAccountLinkInfo, _impl_.whatsappbizacctfbid_)>( - reinterpret_cast(&_impl_.whatsappbizacctfbid_), - reinterpret_cast(&other->_impl_.whatsappbizacctfbid_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata BizAccountLinkInfo::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[7]); -} - -// =================================================================== - -class BizAccountPayload::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::VerifiedNameCertificate& vnamecert(const BizAccountPayload* msg); - static void set_has_vnamecert(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_bizacctlinkinfo(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -const ::proto::VerifiedNameCertificate& -BizAccountPayload::_Internal::vnamecert(const BizAccountPayload* msg) { - return *msg->_impl_.vnamecert_; -} -BizAccountPayload::BizAccountPayload(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.BizAccountPayload) -} -BizAccountPayload::BizAccountPayload(const BizAccountPayload& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - BizAccountPayload* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.bizacctlinkinfo_){} - , decltype(_impl_.vnamecert_){nullptr}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.bizacctlinkinfo_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.bizacctlinkinfo_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_bizacctlinkinfo()) { - _this->_impl_.bizacctlinkinfo_.Set(from._internal_bizacctlinkinfo(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_vnamecert()) { - _this->_impl_.vnamecert_ = new ::proto::VerifiedNameCertificate(*from._impl_.vnamecert_); - } - // @@protoc_insertion_point(copy_constructor:proto.BizAccountPayload) -} - -inline void BizAccountPayload::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.bizacctlinkinfo_){} - , decltype(_impl_.vnamecert_){nullptr} - }; - _impl_.bizacctlinkinfo_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.bizacctlinkinfo_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -BizAccountPayload::~BizAccountPayload() { - // @@protoc_insertion_point(destructor:proto.BizAccountPayload) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void BizAccountPayload::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.bizacctlinkinfo_.Destroy(); - if (this != internal_default_instance()) delete _impl_.vnamecert_; -} - -void BizAccountPayload::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void BizAccountPayload::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.BizAccountPayload) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.bizacctlinkinfo_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.vnamecert_ != nullptr); - _impl_.vnamecert_->Clear(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* BizAccountPayload::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.VerifiedNameCertificate vnameCert = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_vnamecert(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes bizAcctLinkInfo = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_bizacctlinkinfo(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* BizAccountPayload::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.BizAccountPayload) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.VerifiedNameCertificate vnameCert = 1; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::vnamecert(this), - _Internal::vnamecert(this).GetCachedSize(), target, stream); - } - - // optional bytes bizAcctLinkInfo = 2; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_bizacctlinkinfo(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.BizAccountPayload) - return target; -} - -size_t BizAccountPayload::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.BizAccountPayload) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional bytes bizAcctLinkInfo = 2; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_bizacctlinkinfo()); - } - - // optional .proto.VerifiedNameCertificate vnameCert = 1; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.vnamecert_); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData BizAccountPayload::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - BizAccountPayload::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*BizAccountPayload::GetClassData() const { return &_class_data_; } - - -void BizAccountPayload::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.BizAccountPayload) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_bizacctlinkinfo(from._internal_bizacctlinkinfo()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_vnamecert()->::proto::VerifiedNameCertificate::MergeFrom( - from._internal_vnamecert()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void BizAccountPayload::CopyFrom(const BizAccountPayload& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.BizAccountPayload) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool BizAccountPayload::IsInitialized() const { - return true; -} - -void BizAccountPayload::InternalSwap(BizAccountPayload* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.bizacctlinkinfo_, lhs_arena, - &other->_impl_.bizacctlinkinfo_, rhs_arena - ); - swap(_impl_.vnamecert_, other->_impl_.vnamecert_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata BizAccountPayload::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[8]); -} - -// =================================================================== - -class BizIdentityInfo::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_vlevel(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::proto::VerifiedNameCertificate& vnamecert(const BizIdentityInfo* msg); - static void set_has_vnamecert(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_signed_(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_revoked(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_hoststorage(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_actualactors(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static void set_has_privacymodets(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static void set_has_featurecontrols(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } -}; - -const ::proto::VerifiedNameCertificate& -BizIdentityInfo::_Internal::vnamecert(const BizIdentityInfo* msg) { - return *msg->_impl_.vnamecert_; -} -BizIdentityInfo::BizIdentityInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.BizIdentityInfo) -} -BizIdentityInfo::BizIdentityInfo(const BizIdentityInfo& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - BizIdentityInfo* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.vnamecert_){nullptr} - , decltype(_impl_.vlevel_){} - , decltype(_impl_.signed__){} - , decltype(_impl_.revoked_){} - , decltype(_impl_.hoststorage_){} - , decltype(_impl_.actualactors_){} - , decltype(_impl_.privacymodets_){} - , decltype(_impl_.featurecontrols_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_vnamecert()) { - _this->_impl_.vnamecert_ = new ::proto::VerifiedNameCertificate(*from._impl_.vnamecert_); - } - ::memcpy(&_impl_.vlevel_, &from._impl_.vlevel_, - static_cast(reinterpret_cast(&_impl_.featurecontrols_) - - reinterpret_cast(&_impl_.vlevel_)) + sizeof(_impl_.featurecontrols_)); - // @@protoc_insertion_point(copy_constructor:proto.BizIdentityInfo) -} - -inline void BizIdentityInfo::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.vnamecert_){nullptr} - , decltype(_impl_.vlevel_){0} - , decltype(_impl_.signed__){false} - , decltype(_impl_.revoked_){false} - , decltype(_impl_.hoststorage_){0} - , decltype(_impl_.actualactors_){0} - , decltype(_impl_.privacymodets_){uint64_t{0u}} - , decltype(_impl_.featurecontrols_){uint64_t{0u}} - }; -} - -BizIdentityInfo::~BizIdentityInfo() { - // @@protoc_insertion_point(destructor:proto.BizIdentityInfo) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void BizIdentityInfo::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete _impl_.vnamecert_; -} - -void BizIdentityInfo::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void BizIdentityInfo::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.BizIdentityInfo) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.vnamecert_ != nullptr); - _impl_.vnamecert_->Clear(); - } - if (cached_has_bits & 0x000000feu) { - ::memset(&_impl_.vlevel_, 0, static_cast( - reinterpret_cast(&_impl_.featurecontrols_) - - reinterpret_cast(&_impl_.vlevel_)) + sizeof(_impl_.featurecontrols_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* BizIdentityInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.BizIdentityInfo.VerifiedLevelValue vlevel = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::BizIdentityInfo_VerifiedLevelValue_IsValid(val))) { - _internal_set_vlevel(static_cast<::proto::BizIdentityInfo_VerifiedLevelValue>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.VerifiedNameCertificate vnameCert = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_vnamecert(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool signed = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_signed_(&has_bits); - _impl_.signed__ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool revoked = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - _Internal::set_has_revoked(&has_bits); - _impl_.revoked_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.BizIdentityInfo.HostStorageType hostStorage = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::BizIdentityInfo_HostStorageType_IsValid(val))) { - _internal_set_hoststorage(static_cast<::proto::BizIdentityInfo_HostStorageType>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.BizIdentityInfo.ActualActorsType actualActors = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::BizIdentityInfo_ActualActorsType_IsValid(val))) { - _internal_set_actualactors(static_cast<::proto::BizIdentityInfo_ActualActorsType>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(6, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional uint64 privacyModeTs = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { - _Internal::set_has_privacymodets(&has_bits); - _impl_.privacymodets_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint64 featureControls = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { - _Internal::set_has_featurecontrols(&has_bits); - _impl_.featurecontrols_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* BizIdentityInfo::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.BizIdentityInfo) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.BizIdentityInfo.VerifiedLevelValue vlevel = 1; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 1, this->_internal_vlevel(), target); - } - - // optional .proto.VerifiedNameCertificate vnameCert = 2; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::vnamecert(this), - _Internal::vnamecert(this).GetCachedSize(), target, stream); - } - - // optional bool signed = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_signed_(), target); - } - - // optional bool revoked = 4; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(4, this->_internal_revoked(), target); - } - - // optional .proto.BizIdentityInfo.HostStorageType hostStorage = 5; - if (cached_has_bits & 0x00000010u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 5, this->_internal_hoststorage(), target); - } - - // optional .proto.BizIdentityInfo.ActualActorsType actualActors = 6; - if (cached_has_bits & 0x00000020u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 6, this->_internal_actualactors(), target); - } - - // optional uint64 privacyModeTs = 7; - if (cached_has_bits & 0x00000040u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(7, this->_internal_privacymodets(), target); - } - - // optional uint64 featureControls = 8; - if (cached_has_bits & 0x00000080u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(8, this->_internal_featurecontrols(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.BizIdentityInfo) - return target; -} - -size_t BizIdentityInfo::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.BizIdentityInfo) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional .proto.VerifiedNameCertificate vnameCert = 2; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.vnamecert_); - } - - // optional .proto.BizIdentityInfo.VerifiedLevelValue vlevel = 1; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_vlevel()); - } - - // optional bool signed = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + 1; - } - - // optional bool revoked = 4; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + 1; - } - - // optional .proto.BizIdentityInfo.HostStorageType hostStorage = 5; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_hoststorage()); - } - - // optional .proto.BizIdentityInfo.ActualActorsType actualActors = 6; - if (cached_has_bits & 0x00000020u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_actualactors()); - } - - // optional uint64 privacyModeTs = 7; - if (cached_has_bits & 0x00000040u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_privacymodets()); - } - - // optional uint64 featureControls = 8; - if (cached_has_bits & 0x00000080u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_featurecontrols()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData BizIdentityInfo::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - BizIdentityInfo::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*BizIdentityInfo::GetClassData() const { return &_class_data_; } - - -void BizIdentityInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.BizIdentityInfo) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_mutable_vnamecert()->::proto::VerifiedNameCertificate::MergeFrom( - from._internal_vnamecert()); - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.vlevel_ = from._impl_.vlevel_; - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.signed__ = from._impl_.signed__; - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.revoked_ = from._impl_.revoked_; - } - if (cached_has_bits & 0x00000010u) { - _this->_impl_.hoststorage_ = from._impl_.hoststorage_; - } - if (cached_has_bits & 0x00000020u) { - _this->_impl_.actualactors_ = from._impl_.actualactors_; - } - if (cached_has_bits & 0x00000040u) { - _this->_impl_.privacymodets_ = from._impl_.privacymodets_; - } - if (cached_has_bits & 0x00000080u) { - _this->_impl_.featurecontrols_ = from._impl_.featurecontrols_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void BizIdentityInfo::CopyFrom(const BizIdentityInfo& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.BizIdentityInfo) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool BizIdentityInfo::IsInitialized() const { - return true; -} - -void BizIdentityInfo::InternalSwap(BizIdentityInfo* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(BizIdentityInfo, _impl_.featurecontrols_) - + sizeof(BizIdentityInfo::_impl_.featurecontrols_) - - PROTOBUF_FIELD_OFFSET(BizIdentityInfo, _impl_.vnamecert_)>( - reinterpret_cast(&_impl_.vnamecert_), - reinterpret_cast(&other->_impl_.vnamecert_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata BizIdentityInfo::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[9]); -} - -// =================================================================== - -class CertChain_NoiseCertificate_Details::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_serial(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_issuerserial(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_key(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_notbefore(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_notafter(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } -}; - -CertChain_NoiseCertificate_Details::CertChain_NoiseCertificate_Details(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.CertChain.NoiseCertificate.Details) -} -CertChain_NoiseCertificate_Details::CertChain_NoiseCertificate_Details(const CertChain_NoiseCertificate_Details& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - CertChain_NoiseCertificate_Details* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.key_){} - , decltype(_impl_.serial_){} - , decltype(_impl_.issuerserial_){} - , decltype(_impl_.notbefore_){} - , decltype(_impl_.notafter_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.key_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.key_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_key()) { - _this->_impl_.key_.Set(from._internal_key(), - _this->GetArenaForAllocation()); - } - ::memcpy(&_impl_.serial_, &from._impl_.serial_, - static_cast(reinterpret_cast(&_impl_.notafter_) - - reinterpret_cast(&_impl_.serial_)) + sizeof(_impl_.notafter_)); - // @@protoc_insertion_point(copy_constructor:proto.CertChain.NoiseCertificate.Details) -} - -inline void CertChain_NoiseCertificate_Details::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.key_){} - , decltype(_impl_.serial_){0u} - , decltype(_impl_.issuerserial_){0u} - , decltype(_impl_.notbefore_){uint64_t{0u}} - , decltype(_impl_.notafter_){uint64_t{0u}} - }; - _impl_.key_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.key_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -CertChain_NoiseCertificate_Details::~CertChain_NoiseCertificate_Details() { - // @@protoc_insertion_point(destructor:proto.CertChain.NoiseCertificate.Details) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void CertChain_NoiseCertificate_Details::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.key_.Destroy(); -} - -void CertChain_NoiseCertificate_Details::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void CertChain_NoiseCertificate_Details::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.CertChain.NoiseCertificate.Details) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.key_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x0000001eu) { - ::memset(&_impl_.serial_, 0, static_cast( - reinterpret_cast(&_impl_.notafter_) - - reinterpret_cast(&_impl_.serial_)) + sizeof(_impl_.notafter_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* CertChain_NoiseCertificate_Details::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional uint32 serial = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_serial(&has_bits); - _impl_.serial_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 issuerSerial = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_issuerserial(&has_bits); - _impl_.issuerserial_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes key = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_key(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint64 notBefore = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - _Internal::set_has_notbefore(&has_bits); - _impl_.notbefore_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint64 notAfter = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { - _Internal::set_has_notafter(&has_bits); - _impl_.notafter_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* CertChain_NoiseCertificate_Details::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.CertChain.NoiseCertificate.Details) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional uint32 serial = 1; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_serial(), target); - } - - // optional uint32 issuerSerial = 2; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_issuerserial(), target); - } - - // optional bytes key = 3; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 3, this->_internal_key(), target); - } - - // optional uint64 notBefore = 4; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_notbefore(), target); - } - - // optional uint64 notAfter = 5; - if (cached_has_bits & 0x00000010u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_notafter(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.CertChain.NoiseCertificate.Details) - return target; -} - -size_t CertChain_NoiseCertificate_Details::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.CertChain.NoiseCertificate.Details) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { - // optional bytes key = 3; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_key()); - } - - // optional uint32 serial = 1; - if (cached_has_bits & 0x00000002u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_serial()); - } - - // optional uint32 issuerSerial = 2; - if (cached_has_bits & 0x00000004u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_issuerserial()); - } - - // optional uint64 notBefore = 4; - if (cached_has_bits & 0x00000008u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_notbefore()); - } - - // optional uint64 notAfter = 5; - if (cached_has_bits & 0x00000010u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_notafter()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CertChain_NoiseCertificate_Details::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - CertChain_NoiseCertificate_Details::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CertChain_NoiseCertificate_Details::GetClassData() const { return &_class_data_; } - - -void CertChain_NoiseCertificate_Details::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.CertChain.NoiseCertificate.Details) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_key(from._internal_key()); - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.serial_ = from._impl_.serial_; - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.issuerserial_ = from._impl_.issuerserial_; - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.notbefore_ = from._impl_.notbefore_; - } - if (cached_has_bits & 0x00000010u) { - _this->_impl_.notafter_ = from._impl_.notafter_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void CertChain_NoiseCertificate_Details::CopyFrom(const CertChain_NoiseCertificate_Details& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.CertChain.NoiseCertificate.Details) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool CertChain_NoiseCertificate_Details::IsInitialized() const { - return true; -} - -void CertChain_NoiseCertificate_Details::InternalSwap(CertChain_NoiseCertificate_Details* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.key_, lhs_arena, - &other->_impl_.key_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(CertChain_NoiseCertificate_Details, _impl_.notafter_) - + sizeof(CertChain_NoiseCertificate_Details::_impl_.notafter_) - - PROTOBUF_FIELD_OFFSET(CertChain_NoiseCertificate_Details, _impl_.serial_)>( - reinterpret_cast(&_impl_.serial_), - reinterpret_cast(&other->_impl_.serial_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata CertChain_NoiseCertificate_Details::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[10]); -} - -// =================================================================== - -class CertChain_NoiseCertificate::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_details(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_signature(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -CertChain_NoiseCertificate::CertChain_NoiseCertificate(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.CertChain.NoiseCertificate) -} -CertChain_NoiseCertificate::CertChain_NoiseCertificate(const CertChain_NoiseCertificate& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - CertChain_NoiseCertificate* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.details_){} - , decltype(_impl_.signature_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.details_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.details_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_details()) { - _this->_impl_.details_.Set(from._internal_details(), - _this->GetArenaForAllocation()); - } - _impl_.signature_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.signature_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_signature()) { - _this->_impl_.signature_.Set(from._internal_signature(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.CertChain.NoiseCertificate) -} - -inline void CertChain_NoiseCertificate::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.details_){} - , decltype(_impl_.signature_){} - }; - _impl_.details_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.details_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.signature_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.signature_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -CertChain_NoiseCertificate::~CertChain_NoiseCertificate() { - // @@protoc_insertion_point(destructor:proto.CertChain.NoiseCertificate) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void CertChain_NoiseCertificate::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.details_.Destroy(); - _impl_.signature_.Destroy(); -} - -void CertChain_NoiseCertificate::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void CertChain_NoiseCertificate::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.CertChain.NoiseCertificate) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.details_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.signature_.ClearNonDefaultToEmpty(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* CertChain_NoiseCertificate::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bytes details = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_details(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes signature = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_signature(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* CertChain_NoiseCertificate::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.CertChain.NoiseCertificate) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bytes details = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 1, this->_internal_details(), target); - } - - // optional bytes signature = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_signature(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.CertChain.NoiseCertificate) - return target; -} - -size_t CertChain_NoiseCertificate::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.CertChain.NoiseCertificate) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional bytes details = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_details()); - } - - // optional bytes signature = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_signature()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CertChain_NoiseCertificate::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - CertChain_NoiseCertificate::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CertChain_NoiseCertificate::GetClassData() const { return &_class_data_; } - - -void CertChain_NoiseCertificate::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.CertChain.NoiseCertificate) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_details(from._internal_details()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_signature(from._internal_signature()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void CertChain_NoiseCertificate::CopyFrom(const CertChain_NoiseCertificate& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.CertChain.NoiseCertificate) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool CertChain_NoiseCertificate::IsInitialized() const { - return true; -} - -void CertChain_NoiseCertificate::InternalSwap(CertChain_NoiseCertificate* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.details_, lhs_arena, - &other->_impl_.details_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.signature_, lhs_arena, - &other->_impl_.signature_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata CertChain_NoiseCertificate::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[11]); -} - -// =================================================================== - -class CertChain::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::CertChain_NoiseCertificate& leaf(const CertChain* msg); - static void set_has_leaf(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::proto::CertChain_NoiseCertificate& intermediate(const CertChain* msg); - static void set_has_intermediate(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -const ::proto::CertChain_NoiseCertificate& -CertChain::_Internal::leaf(const CertChain* msg) { - return *msg->_impl_.leaf_; -} -const ::proto::CertChain_NoiseCertificate& -CertChain::_Internal::intermediate(const CertChain* msg) { - return *msg->_impl_.intermediate_; -} -CertChain::CertChain(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.CertChain) -} -CertChain::CertChain(const CertChain& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - CertChain* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.leaf_){nullptr} - , decltype(_impl_.intermediate_){nullptr}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_leaf()) { - _this->_impl_.leaf_ = new ::proto::CertChain_NoiseCertificate(*from._impl_.leaf_); - } - if (from._internal_has_intermediate()) { - _this->_impl_.intermediate_ = new ::proto::CertChain_NoiseCertificate(*from._impl_.intermediate_); - } - // @@protoc_insertion_point(copy_constructor:proto.CertChain) -} - -inline void CertChain::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.leaf_){nullptr} - , decltype(_impl_.intermediate_){nullptr} - }; -} - -CertChain::~CertChain() { - // @@protoc_insertion_point(destructor:proto.CertChain) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void CertChain::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete _impl_.leaf_; - if (this != internal_default_instance()) delete _impl_.intermediate_; -} - -void CertChain::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void CertChain::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.CertChain) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.leaf_ != nullptr); - _impl_.leaf_->Clear(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.intermediate_ != nullptr); - _impl_.intermediate_->Clear(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* CertChain::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.CertChain.NoiseCertificate leaf = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_leaf(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.CertChain.NoiseCertificate intermediate = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_intermediate(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* CertChain::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.CertChain) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.CertChain.NoiseCertificate leaf = 1; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::leaf(this), - _Internal::leaf(this).GetCachedSize(), target, stream); - } - - // optional .proto.CertChain.NoiseCertificate intermediate = 2; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::intermediate(this), - _Internal::intermediate(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.CertChain) - return target; -} - -size_t CertChain::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.CertChain) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional .proto.CertChain.NoiseCertificate leaf = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.leaf_); - } - - // optional .proto.CertChain.NoiseCertificate intermediate = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.intermediate_); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CertChain::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - CertChain::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CertChain::GetClassData() const { return &_class_data_; } - - -void CertChain::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.CertChain) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_mutable_leaf()->::proto::CertChain_NoiseCertificate::MergeFrom( - from._internal_leaf()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_intermediate()->::proto::CertChain_NoiseCertificate::MergeFrom( - from._internal_intermediate()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void CertChain::CopyFrom(const CertChain& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.CertChain) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool CertChain::IsInitialized() const { - return true; -} - -void CertChain::InternalSwap(CertChain* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(CertChain, _impl_.intermediate_) - + sizeof(CertChain::_impl_.intermediate_) - - PROTOBUF_FIELD_OFFSET(CertChain, _impl_.leaf_)>( - reinterpret_cast(&_impl_.leaf_), - reinterpret_cast(&other->_impl_.leaf_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata CertChain::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[12]); -} - -// =================================================================== - -class Chain::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_senderratchetkey(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_senderratchetkeyprivate(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::proto::ChainKey& chainkey(const Chain* msg); - static void set_has_chainkey(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } -}; - -const ::proto::ChainKey& -Chain::_Internal::chainkey(const Chain* msg) { - return *msg->_impl_.chainkey_; -} -Chain::Chain(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Chain) -} -Chain::Chain(const Chain& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Chain* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.messagekeys_){from._impl_.messagekeys_} - , decltype(_impl_.senderratchetkey_){} - , decltype(_impl_.senderratchetkeyprivate_){} - , decltype(_impl_.chainkey_){nullptr}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.senderratchetkey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.senderratchetkey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_senderratchetkey()) { - _this->_impl_.senderratchetkey_.Set(from._internal_senderratchetkey(), - _this->GetArenaForAllocation()); - } - _impl_.senderratchetkeyprivate_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.senderratchetkeyprivate_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_senderratchetkeyprivate()) { - _this->_impl_.senderratchetkeyprivate_.Set(from._internal_senderratchetkeyprivate(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_chainkey()) { - _this->_impl_.chainkey_ = new ::proto::ChainKey(*from._impl_.chainkey_); - } - // @@protoc_insertion_point(copy_constructor:proto.Chain) -} - -inline void Chain::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.messagekeys_){arena} - , decltype(_impl_.senderratchetkey_){} - , decltype(_impl_.senderratchetkeyprivate_){} - , decltype(_impl_.chainkey_){nullptr} - }; - _impl_.senderratchetkey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.senderratchetkey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.senderratchetkeyprivate_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.senderratchetkeyprivate_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Chain::~Chain() { - // @@protoc_insertion_point(destructor:proto.Chain) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Chain::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.messagekeys_.~RepeatedPtrField(); - _impl_.senderratchetkey_.Destroy(); - _impl_.senderratchetkeyprivate_.Destroy(); - if (this != internal_default_instance()) delete _impl_.chainkey_; -} - -void Chain::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Chain::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Chain) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.messagekeys_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _impl_.senderratchetkey_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.senderratchetkeyprivate_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - GOOGLE_DCHECK(_impl_.chainkey_ != nullptr); - _impl_.chainkey_->Clear(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Chain::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bytes senderRatchetKey = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_senderratchetkey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes senderRatchetKeyPrivate = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_senderratchetkeyprivate(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.ChainKey chainKey = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_chainkey(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated .proto.MessageKey messageKeys = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_messagekeys(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Chain::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Chain) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bytes senderRatchetKey = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 1, this->_internal_senderratchetkey(), target); - } - - // optional bytes senderRatchetKeyPrivate = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_senderratchetkeyprivate(), target); - } - - // optional .proto.ChainKey chainKey = 3; - if (cached_has_bits & 0x00000004u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, _Internal::chainkey(this), - _Internal::chainkey(this).GetCachedSize(), target, stream); - } - - // repeated .proto.MessageKey messageKeys = 4; - for (unsigned i = 0, - n = static_cast(this->_internal_messagekeys_size()); i < n; i++) { - const auto& repfield = this->_internal_messagekeys(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(4, repfield, repfield.GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Chain) - return target; -} - -size_t Chain::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Chain) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.MessageKey messageKeys = 4; - total_size += 1UL * this->_internal_messagekeys_size(); - for (const auto& msg : this->_impl_.messagekeys_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional bytes senderRatchetKey = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_senderratchetkey()); - } - - // optional bytes senderRatchetKeyPrivate = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_senderratchetkeyprivate()); - } - - // optional .proto.ChainKey chainKey = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.chainkey_); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Chain::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Chain::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Chain::GetClassData() const { return &_class_data_; } - - -void Chain::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Chain) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.messagekeys_.MergeFrom(from._impl_.messagekeys_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_senderratchetkey(from._internal_senderratchetkey()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_senderratchetkeyprivate(from._internal_senderratchetkeyprivate()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_mutable_chainkey()->::proto::ChainKey::MergeFrom( - from._internal_chainkey()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Chain::CopyFrom(const Chain& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Chain) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Chain::IsInitialized() const { - return true; -} - -void Chain::InternalSwap(Chain* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.messagekeys_.InternalSwap(&other->_impl_.messagekeys_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.senderratchetkey_, lhs_arena, - &other->_impl_.senderratchetkey_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.senderratchetkeyprivate_, lhs_arena, - &other->_impl_.senderratchetkeyprivate_, rhs_arena - ); - swap(_impl_.chainkey_, other->_impl_.chainkey_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Chain::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[13]); -} - -// =================================================================== - -class ChainKey::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_index(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_key(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -ChainKey::ChainKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.ChainKey) -} -ChainKey::ChainKey(const ChainKey& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - ChainKey* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.key_){} - , decltype(_impl_.index_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.key_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.key_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_key()) { - _this->_impl_.key_.Set(from._internal_key(), - _this->GetArenaForAllocation()); - } - _this->_impl_.index_ = from._impl_.index_; - // @@protoc_insertion_point(copy_constructor:proto.ChainKey) -} - -inline void ChainKey::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.key_){} - , decltype(_impl_.index_){0u} - }; - _impl_.key_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.key_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -ChainKey::~ChainKey() { - // @@protoc_insertion_point(destructor:proto.ChainKey) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void ChainKey::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.key_.Destroy(); -} - -void ChainKey::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void ChainKey::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.ChainKey) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.key_.ClearNonDefaultToEmpty(); - } - _impl_.index_ = 0u; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ChainKey::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional uint32 index = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_index(&has_bits); - _impl_.index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes key = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_key(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ChainKey::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.ChainKey) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional uint32 index = 1; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_index(), target); - } - - // optional bytes key = 2; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_key(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.ChainKey) - return target; -} - -size_t ChainKey::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.ChainKey) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional bytes key = 2; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_key()); - } - - // optional uint32 index = 1; - if (cached_has_bits & 0x00000002u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_index()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ChainKey::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - ChainKey::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ChainKey::GetClassData() const { return &_class_data_; } - - -void ChainKey::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.ChainKey) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_key(from._internal_key()); - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.index_ = from._impl_.index_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ChainKey::CopyFrom(const ChainKey& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.ChainKey) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ChainKey::IsInitialized() const { - return true; -} - -void ChainKey::InternalSwap(ChainKey* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.key_, lhs_arena, - &other->_impl_.key_, rhs_arena - ); - swap(_impl_.index_, other->_impl_.index_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ChainKey::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[14]); -} - -// =================================================================== - -class ClientPayload_DNSSource::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_dnsmethod(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_appcached(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -ClientPayload_DNSSource::ClientPayload_DNSSource(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.ClientPayload.DNSSource) -} -ClientPayload_DNSSource::ClientPayload_DNSSource(const ClientPayload_DNSSource& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - ClientPayload_DNSSource* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.dnsmethod_){} - , decltype(_impl_.appcached_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&_impl_.dnsmethod_, &from._impl_.dnsmethod_, - static_cast(reinterpret_cast(&_impl_.appcached_) - - reinterpret_cast(&_impl_.dnsmethod_)) + sizeof(_impl_.appcached_)); - // @@protoc_insertion_point(copy_constructor:proto.ClientPayload.DNSSource) -} - -inline void ClientPayload_DNSSource::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.dnsmethod_){0} - , decltype(_impl_.appcached_){false} - }; -} - -ClientPayload_DNSSource::~ClientPayload_DNSSource() { - // @@protoc_insertion_point(destructor:proto.ClientPayload.DNSSource) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void ClientPayload_DNSSource::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void ClientPayload_DNSSource::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void ClientPayload_DNSSource::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.ClientPayload.DNSSource) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - ::memset(&_impl_.dnsmethod_, 0, static_cast( - reinterpret_cast(&_impl_.appcached_) - - reinterpret_cast(&_impl_.dnsmethod_)) + sizeof(_impl_.appcached_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ClientPayload_DNSSource::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.ClientPayload.DNSSource.DNSResolutionMethod dnsMethod = 15; - case 15: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 120)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::ClientPayload_DNSSource_DNSResolutionMethod_IsValid(val))) { - _internal_set_dnsmethod(static_cast<::proto::ClientPayload_DNSSource_DNSResolutionMethod>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(15, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional bool appCached = 16; - case 16: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 128)) { - _Internal::set_has_appcached(&has_bits); - _impl_.appcached_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ClientPayload_DNSSource::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.ClientPayload.DNSSource) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.ClientPayload.DNSSource.DNSResolutionMethod dnsMethod = 15; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 15, this->_internal_dnsmethod(), target); - } - - // optional bool appCached = 16; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(16, this->_internal_appcached(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.ClientPayload.DNSSource) - return target; -} - -size_t ClientPayload_DNSSource::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.ClientPayload.DNSSource) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional .proto.ClientPayload.DNSSource.DNSResolutionMethod dnsMethod = 15; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_dnsmethod()); - } - - // optional bool appCached = 16; - if (cached_has_bits & 0x00000002u) { - total_size += 2 + 1; - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ClientPayload_DNSSource::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - ClientPayload_DNSSource::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ClientPayload_DNSSource::GetClassData() const { return &_class_data_; } - - -void ClientPayload_DNSSource::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.ClientPayload.DNSSource) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_impl_.dnsmethod_ = from._impl_.dnsmethod_; - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.appcached_ = from._impl_.appcached_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ClientPayload_DNSSource::CopyFrom(const ClientPayload_DNSSource& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.ClientPayload.DNSSource) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ClientPayload_DNSSource::IsInitialized() const { - return true; -} - -void ClientPayload_DNSSource::InternalSwap(ClientPayload_DNSSource* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ClientPayload_DNSSource, _impl_.appcached_) - + sizeof(ClientPayload_DNSSource::_impl_.appcached_) - - PROTOBUF_FIELD_OFFSET(ClientPayload_DNSSource, _impl_.dnsmethod_)>( - reinterpret_cast(&_impl_.dnsmethod_), - reinterpret_cast(&other->_impl_.dnsmethod_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ClientPayload_DNSSource::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[15]); -} - -// =================================================================== - -class ClientPayload_DevicePairingRegistrationData::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_eregid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_ekeytype(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_eident(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_eskeyid(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_eskeyval(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_eskeysig(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static void set_has_buildhash(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static void set_has_deviceprops(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } -}; - -ClientPayload_DevicePairingRegistrationData::ClientPayload_DevicePairingRegistrationData(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.ClientPayload.DevicePairingRegistrationData) -} -ClientPayload_DevicePairingRegistrationData::ClientPayload_DevicePairingRegistrationData(const ClientPayload_DevicePairingRegistrationData& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - ClientPayload_DevicePairingRegistrationData* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.eregid_){} - , decltype(_impl_.ekeytype_){} - , decltype(_impl_.eident_){} - , decltype(_impl_.eskeyid_){} - , decltype(_impl_.eskeyval_){} - , decltype(_impl_.eskeysig_){} - , decltype(_impl_.buildhash_){} - , decltype(_impl_.deviceprops_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.eregid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.eregid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_eregid()) { - _this->_impl_.eregid_.Set(from._internal_eregid(), - _this->GetArenaForAllocation()); - } - _impl_.ekeytype_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.ekeytype_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_ekeytype()) { - _this->_impl_.ekeytype_.Set(from._internal_ekeytype(), - _this->GetArenaForAllocation()); - } - _impl_.eident_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.eident_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_eident()) { - _this->_impl_.eident_.Set(from._internal_eident(), - _this->GetArenaForAllocation()); - } - _impl_.eskeyid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.eskeyid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_eskeyid()) { - _this->_impl_.eskeyid_.Set(from._internal_eskeyid(), - _this->GetArenaForAllocation()); - } - _impl_.eskeyval_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.eskeyval_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_eskeyval()) { - _this->_impl_.eskeyval_.Set(from._internal_eskeyval(), - _this->GetArenaForAllocation()); - } - _impl_.eskeysig_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.eskeysig_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_eskeysig()) { - _this->_impl_.eskeysig_.Set(from._internal_eskeysig(), - _this->GetArenaForAllocation()); - } - _impl_.buildhash_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.buildhash_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_buildhash()) { - _this->_impl_.buildhash_.Set(from._internal_buildhash(), - _this->GetArenaForAllocation()); - } - _impl_.deviceprops_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.deviceprops_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_deviceprops()) { - _this->_impl_.deviceprops_.Set(from._internal_deviceprops(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.ClientPayload.DevicePairingRegistrationData) -} - -inline void ClientPayload_DevicePairingRegistrationData::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.eregid_){} - , decltype(_impl_.ekeytype_){} - , decltype(_impl_.eident_){} - , decltype(_impl_.eskeyid_){} - , decltype(_impl_.eskeyval_){} - , decltype(_impl_.eskeysig_){} - , decltype(_impl_.buildhash_){} - , decltype(_impl_.deviceprops_){} - }; - _impl_.eregid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.eregid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.ekeytype_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.ekeytype_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.eident_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.eident_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.eskeyid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.eskeyid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.eskeyval_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.eskeyval_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.eskeysig_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.eskeysig_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.buildhash_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.buildhash_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.deviceprops_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.deviceprops_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -ClientPayload_DevicePairingRegistrationData::~ClientPayload_DevicePairingRegistrationData() { - // @@protoc_insertion_point(destructor:proto.ClientPayload.DevicePairingRegistrationData) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void ClientPayload_DevicePairingRegistrationData::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.eregid_.Destroy(); - _impl_.ekeytype_.Destroy(); - _impl_.eident_.Destroy(); - _impl_.eskeyid_.Destroy(); - _impl_.eskeyval_.Destroy(); - _impl_.eskeysig_.Destroy(); - _impl_.buildhash_.Destroy(); - _impl_.deviceprops_.Destroy(); -} - -void ClientPayload_DevicePairingRegistrationData::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void ClientPayload_DevicePairingRegistrationData::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.ClientPayload.DevicePairingRegistrationData) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _impl_.eregid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.ekeytype_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.eident_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000008u) { - _impl_.eskeyid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000010u) { - _impl_.eskeyval_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000020u) { - _impl_.eskeysig_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000040u) { - _impl_.buildhash_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000080u) { - _impl_.deviceprops_.ClearNonDefaultToEmpty(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ClientPayload_DevicePairingRegistrationData::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bytes eRegid = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_eregid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes eKeytype = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_ekeytype(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes eIdent = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_eident(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes eSkeyId = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - auto str = _internal_mutable_eskeyid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes eSkeyVal = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - auto str = _internal_mutable_eskeyval(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes eSkeySig = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - auto str = _internal_mutable_eskeysig(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes buildHash = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - auto str = _internal_mutable_buildhash(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes deviceProps = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { - auto str = _internal_mutable_deviceprops(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ClientPayload_DevicePairingRegistrationData::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.ClientPayload.DevicePairingRegistrationData) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bytes eRegid = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 1, this->_internal_eregid(), target); - } - - // optional bytes eKeytype = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_ekeytype(), target); - } - - // optional bytes eIdent = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->WriteBytesMaybeAliased( - 3, this->_internal_eident(), target); - } - - // optional bytes eSkeyId = 4; - if (cached_has_bits & 0x00000008u) { - target = stream->WriteBytesMaybeAliased( - 4, this->_internal_eskeyid(), target); - } - - // optional bytes eSkeyVal = 5; - if (cached_has_bits & 0x00000010u) { - target = stream->WriteBytesMaybeAliased( - 5, this->_internal_eskeyval(), target); - } - - // optional bytes eSkeySig = 6; - if (cached_has_bits & 0x00000020u) { - target = stream->WriteBytesMaybeAliased( - 6, this->_internal_eskeysig(), target); - } - - // optional bytes buildHash = 7; - if (cached_has_bits & 0x00000040u) { - target = stream->WriteBytesMaybeAliased( - 7, this->_internal_buildhash(), target); - } - - // optional bytes deviceProps = 8; - if (cached_has_bits & 0x00000080u) { - target = stream->WriteBytesMaybeAliased( - 8, this->_internal_deviceprops(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.ClientPayload.DevicePairingRegistrationData) - return target; -} - -size_t ClientPayload_DevicePairingRegistrationData::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.ClientPayload.DevicePairingRegistrationData) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional bytes eRegid = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_eregid()); - } - - // optional bytes eKeytype = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_ekeytype()); - } - - // optional bytes eIdent = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_eident()); - } - - // optional bytes eSkeyId = 4; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_eskeyid()); - } - - // optional bytes eSkeyVal = 5; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_eskeyval()); - } - - // optional bytes eSkeySig = 6; - if (cached_has_bits & 0x00000020u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_eskeysig()); - } - - // optional bytes buildHash = 7; - if (cached_has_bits & 0x00000040u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_buildhash()); - } - - // optional bytes deviceProps = 8; - if (cached_has_bits & 0x00000080u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_deviceprops()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ClientPayload_DevicePairingRegistrationData::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - ClientPayload_DevicePairingRegistrationData::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ClientPayload_DevicePairingRegistrationData::GetClassData() const { return &_class_data_; } - - -void ClientPayload_DevicePairingRegistrationData::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.ClientPayload.DevicePairingRegistrationData) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_eregid(from._internal_eregid()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_ekeytype(from._internal_ekeytype()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_eident(from._internal_eident()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_set_eskeyid(from._internal_eskeyid()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_set_eskeyval(from._internal_eskeyval()); - } - if (cached_has_bits & 0x00000020u) { - _this->_internal_set_eskeysig(from._internal_eskeysig()); - } - if (cached_has_bits & 0x00000040u) { - _this->_internal_set_buildhash(from._internal_buildhash()); - } - if (cached_has_bits & 0x00000080u) { - _this->_internal_set_deviceprops(from._internal_deviceprops()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ClientPayload_DevicePairingRegistrationData::CopyFrom(const ClientPayload_DevicePairingRegistrationData& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.ClientPayload.DevicePairingRegistrationData) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ClientPayload_DevicePairingRegistrationData::IsInitialized() const { - return true; -} - -void ClientPayload_DevicePairingRegistrationData::InternalSwap(ClientPayload_DevicePairingRegistrationData* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.eregid_, lhs_arena, - &other->_impl_.eregid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.ekeytype_, lhs_arena, - &other->_impl_.ekeytype_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.eident_, lhs_arena, - &other->_impl_.eident_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.eskeyid_, lhs_arena, - &other->_impl_.eskeyid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.eskeyval_, lhs_arena, - &other->_impl_.eskeyval_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.eskeysig_, lhs_arena, - &other->_impl_.eskeysig_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.buildhash_, lhs_arena, - &other->_impl_.buildhash_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.deviceprops_, lhs_arena, - &other->_impl_.deviceprops_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ClientPayload_DevicePairingRegistrationData::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[16]); -} - -// =================================================================== - -class ClientPayload_UserAgent_AppVersion::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_primary(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_secondary(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_tertiary(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_quaternary(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_quinary(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } -}; - -ClientPayload_UserAgent_AppVersion::ClientPayload_UserAgent_AppVersion(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.ClientPayload.UserAgent.AppVersion) -} -ClientPayload_UserAgent_AppVersion::ClientPayload_UserAgent_AppVersion(const ClientPayload_UserAgent_AppVersion& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - ClientPayload_UserAgent_AppVersion* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.primary_){} - , decltype(_impl_.secondary_){} - , decltype(_impl_.tertiary_){} - , decltype(_impl_.quaternary_){} - , decltype(_impl_.quinary_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&_impl_.primary_, &from._impl_.primary_, - static_cast(reinterpret_cast(&_impl_.quinary_) - - reinterpret_cast(&_impl_.primary_)) + sizeof(_impl_.quinary_)); - // @@protoc_insertion_point(copy_constructor:proto.ClientPayload.UserAgent.AppVersion) -} - -inline void ClientPayload_UserAgent_AppVersion::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.primary_){0u} - , decltype(_impl_.secondary_){0u} - , decltype(_impl_.tertiary_){0u} - , decltype(_impl_.quaternary_){0u} - , decltype(_impl_.quinary_){0u} - }; -} - -ClientPayload_UserAgent_AppVersion::~ClientPayload_UserAgent_AppVersion() { - // @@protoc_insertion_point(destructor:proto.ClientPayload.UserAgent.AppVersion) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void ClientPayload_UserAgent_AppVersion::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void ClientPayload_UserAgent_AppVersion::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void ClientPayload_UserAgent_AppVersion::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.ClientPayload.UserAgent.AppVersion) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { - ::memset(&_impl_.primary_, 0, static_cast( - reinterpret_cast(&_impl_.quinary_) - - reinterpret_cast(&_impl_.primary_)) + sizeof(_impl_.quinary_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ClientPayload_UserAgent_AppVersion::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional uint32 primary = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_primary(&has_bits); - _impl_.primary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 secondary = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_secondary(&has_bits); - _impl_.secondary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 tertiary = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_tertiary(&has_bits); - _impl_.tertiary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 quaternary = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - _Internal::set_has_quaternary(&has_bits); - _impl_.quaternary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 quinary = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { - _Internal::set_has_quinary(&has_bits); - _impl_.quinary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ClientPayload_UserAgent_AppVersion::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.ClientPayload.UserAgent.AppVersion) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional uint32 primary = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_primary(), target); - } - - // optional uint32 secondary = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_secondary(), target); - } - - // optional uint32 tertiary = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_tertiary(), target); - } - - // optional uint32 quaternary = 4; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_quaternary(), target); - } - - // optional uint32 quinary = 5; - if (cached_has_bits & 0x00000010u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_quinary(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.ClientPayload.UserAgent.AppVersion) - return target; -} - -size_t ClientPayload_UserAgent_AppVersion::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.ClientPayload.UserAgent.AppVersion) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { - // optional uint32 primary = 1; - if (cached_has_bits & 0x00000001u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_primary()); - } - - // optional uint32 secondary = 2; - if (cached_has_bits & 0x00000002u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_secondary()); - } - - // optional uint32 tertiary = 3; - if (cached_has_bits & 0x00000004u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_tertiary()); - } - - // optional uint32 quaternary = 4; - if (cached_has_bits & 0x00000008u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_quaternary()); - } - - // optional uint32 quinary = 5; - if (cached_has_bits & 0x00000010u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_quinary()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ClientPayload_UserAgent_AppVersion::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - ClientPayload_UserAgent_AppVersion::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ClientPayload_UserAgent_AppVersion::GetClassData() const { return &_class_data_; } - - -void ClientPayload_UserAgent_AppVersion::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.ClientPayload.UserAgent.AppVersion) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { - if (cached_has_bits & 0x00000001u) { - _this->_impl_.primary_ = from._impl_.primary_; - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.secondary_ = from._impl_.secondary_; - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.tertiary_ = from._impl_.tertiary_; - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.quaternary_ = from._impl_.quaternary_; - } - if (cached_has_bits & 0x00000010u) { - _this->_impl_.quinary_ = from._impl_.quinary_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ClientPayload_UserAgent_AppVersion::CopyFrom(const ClientPayload_UserAgent_AppVersion& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.ClientPayload.UserAgent.AppVersion) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ClientPayload_UserAgent_AppVersion::IsInitialized() const { - return true; -} - -void ClientPayload_UserAgent_AppVersion::InternalSwap(ClientPayload_UserAgent_AppVersion* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ClientPayload_UserAgent_AppVersion, _impl_.quinary_) - + sizeof(ClientPayload_UserAgent_AppVersion::_impl_.quinary_) - - PROTOBUF_FIELD_OFFSET(ClientPayload_UserAgent_AppVersion, _impl_.primary_)>( - reinterpret_cast(&_impl_.primary_), - reinterpret_cast(&other->_impl_.primary_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ClientPayload_UserAgent_AppVersion::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[17]); -} - -// =================================================================== - -class ClientPayload_UserAgent::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_platform(HasBits* has_bits) { - (*has_bits)[0] |= 2048u; - } - static const ::proto::ClientPayload_UserAgent_AppVersion& appversion(const ClientPayload_UserAgent* msg); - static void set_has_appversion(HasBits* has_bits) { - (*has_bits)[0] |= 1024u; - } - static void set_has_mcc(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_mnc(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_osversion(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_manufacturer(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_device(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_osbuildnumber(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static void set_has_phoneid(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static void set_has_releasechannel(HasBits* has_bits) { - (*has_bits)[0] |= 4096u; - } - static void set_has_localelanguageiso6391(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } - static void set_has_localecountryiso31661alpha2(HasBits* has_bits) { - (*has_bits)[0] |= 256u; - } - static void set_has_deviceboard(HasBits* has_bits) { - (*has_bits)[0] |= 512u; - } -}; - -const ::proto::ClientPayload_UserAgent_AppVersion& -ClientPayload_UserAgent::_Internal::appversion(const ClientPayload_UserAgent* msg) { - return *msg->_impl_.appversion_; -} -ClientPayload_UserAgent::ClientPayload_UserAgent(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.ClientPayload.UserAgent) -} -ClientPayload_UserAgent::ClientPayload_UserAgent(const ClientPayload_UserAgent& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - ClientPayload_UserAgent* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.mcc_){} - , decltype(_impl_.mnc_){} - , decltype(_impl_.osversion_){} - , decltype(_impl_.manufacturer_){} - , decltype(_impl_.device_){} - , decltype(_impl_.osbuildnumber_){} - , decltype(_impl_.phoneid_){} - , decltype(_impl_.localelanguageiso6391_){} - , decltype(_impl_.localecountryiso31661alpha2_){} - , decltype(_impl_.deviceboard_){} - , decltype(_impl_.appversion_){nullptr} - , decltype(_impl_.platform_){} - , decltype(_impl_.releasechannel_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.mcc_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mcc_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_mcc()) { - _this->_impl_.mcc_.Set(from._internal_mcc(), - _this->GetArenaForAllocation()); - } - _impl_.mnc_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mnc_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_mnc()) { - _this->_impl_.mnc_.Set(from._internal_mnc(), - _this->GetArenaForAllocation()); - } - _impl_.osversion_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.osversion_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_osversion()) { - _this->_impl_.osversion_.Set(from._internal_osversion(), - _this->GetArenaForAllocation()); - } - _impl_.manufacturer_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.manufacturer_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_manufacturer()) { - _this->_impl_.manufacturer_.Set(from._internal_manufacturer(), - _this->GetArenaForAllocation()); - } - _impl_.device_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.device_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_device()) { - _this->_impl_.device_.Set(from._internal_device(), - _this->GetArenaForAllocation()); - } - _impl_.osbuildnumber_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.osbuildnumber_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_osbuildnumber()) { - _this->_impl_.osbuildnumber_.Set(from._internal_osbuildnumber(), - _this->GetArenaForAllocation()); - } - _impl_.phoneid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.phoneid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_phoneid()) { - _this->_impl_.phoneid_.Set(from._internal_phoneid(), - _this->GetArenaForAllocation()); - } - _impl_.localelanguageiso6391_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.localelanguageiso6391_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_localelanguageiso6391()) { - _this->_impl_.localelanguageiso6391_.Set(from._internal_localelanguageiso6391(), - _this->GetArenaForAllocation()); - } - _impl_.localecountryiso31661alpha2_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.localecountryiso31661alpha2_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_localecountryiso31661alpha2()) { - _this->_impl_.localecountryiso31661alpha2_.Set(from._internal_localecountryiso31661alpha2(), - _this->GetArenaForAllocation()); - } - _impl_.deviceboard_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.deviceboard_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_deviceboard()) { - _this->_impl_.deviceboard_.Set(from._internal_deviceboard(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_appversion()) { - _this->_impl_.appversion_ = new ::proto::ClientPayload_UserAgent_AppVersion(*from._impl_.appversion_); - } - ::memcpy(&_impl_.platform_, &from._impl_.platform_, - static_cast(reinterpret_cast(&_impl_.releasechannel_) - - reinterpret_cast(&_impl_.platform_)) + sizeof(_impl_.releasechannel_)); - // @@protoc_insertion_point(copy_constructor:proto.ClientPayload.UserAgent) -} - -inline void ClientPayload_UserAgent::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.mcc_){} - , decltype(_impl_.mnc_){} - , decltype(_impl_.osversion_){} - , decltype(_impl_.manufacturer_){} - , decltype(_impl_.device_){} - , decltype(_impl_.osbuildnumber_){} - , decltype(_impl_.phoneid_){} - , decltype(_impl_.localelanguageiso6391_){} - , decltype(_impl_.localecountryiso31661alpha2_){} - , decltype(_impl_.deviceboard_){} - , decltype(_impl_.appversion_){nullptr} - , decltype(_impl_.platform_){0} - , decltype(_impl_.releasechannel_){0} - }; - _impl_.mcc_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mcc_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mnc_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mnc_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.osversion_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.osversion_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.manufacturer_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.manufacturer_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.device_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.device_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.osbuildnumber_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.osbuildnumber_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.phoneid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.phoneid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.localelanguageiso6391_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.localelanguageiso6391_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.localecountryiso31661alpha2_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.localecountryiso31661alpha2_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.deviceboard_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.deviceboard_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -ClientPayload_UserAgent::~ClientPayload_UserAgent() { - // @@protoc_insertion_point(destructor:proto.ClientPayload.UserAgent) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void ClientPayload_UserAgent::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.mcc_.Destroy(); - _impl_.mnc_.Destroy(); - _impl_.osversion_.Destroy(); - _impl_.manufacturer_.Destroy(); - _impl_.device_.Destroy(); - _impl_.osbuildnumber_.Destroy(); - _impl_.phoneid_.Destroy(); - _impl_.localelanguageiso6391_.Destroy(); - _impl_.localecountryiso31661alpha2_.Destroy(); - _impl_.deviceboard_.Destroy(); - if (this != internal_default_instance()) delete _impl_.appversion_; -} - -void ClientPayload_UserAgent::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void ClientPayload_UserAgent::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.ClientPayload.UserAgent) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _impl_.mcc_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.mnc_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.osversion_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000008u) { - _impl_.manufacturer_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000010u) { - _impl_.device_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000020u) { - _impl_.osbuildnumber_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000040u) { - _impl_.phoneid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000080u) { - _impl_.localelanguageiso6391_.ClearNonDefaultToEmpty(); - } - } - if (cached_has_bits & 0x00000700u) { - if (cached_has_bits & 0x00000100u) { - _impl_.localecountryiso31661alpha2_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000200u) { - _impl_.deviceboard_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000400u) { - GOOGLE_DCHECK(_impl_.appversion_ != nullptr); - _impl_.appversion_->Clear(); - } - } - if (cached_has_bits & 0x00001800u) { - ::memset(&_impl_.platform_, 0, static_cast( - reinterpret_cast(&_impl_.releasechannel_) - - reinterpret_cast(&_impl_.platform_)) + sizeof(_impl_.releasechannel_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ClientPayload_UserAgent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.ClientPayload.UserAgent.Platform platform = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::ClientPayload_UserAgent_Platform_IsValid(val))) { - _internal_set_platform(static_cast<::proto::ClientPayload_UserAgent_Platform>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.ClientPayload.UserAgent.AppVersion appVersion = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_appversion(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string mcc = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_mcc(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ClientPayload.UserAgent.mcc"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string mnc = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - auto str = _internal_mutable_mnc(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ClientPayload.UserAgent.mnc"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string osVersion = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - auto str = _internal_mutable_osversion(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ClientPayload.UserAgent.osVersion"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string manufacturer = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - auto str = _internal_mutable_manufacturer(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ClientPayload.UserAgent.manufacturer"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string device = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - auto str = _internal_mutable_device(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ClientPayload.UserAgent.device"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string osBuildNumber = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { - auto str = _internal_mutable_osbuildnumber(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ClientPayload.UserAgent.osBuildNumber"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string phoneId = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { - auto str = _internal_mutable_phoneid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ClientPayload.UserAgent.phoneId"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.ClientPayload.UserAgent.ReleaseChannel releaseChannel = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::ClientPayload_UserAgent_ReleaseChannel_IsValid(val))) { - _internal_set_releasechannel(static_cast<::proto::ClientPayload_UserAgent_ReleaseChannel>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(10, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional string localeLanguageIso6391 = 11; - case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { - auto str = _internal_mutable_localelanguageiso6391(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ClientPayload.UserAgent.localeLanguageIso6391"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string localeCountryIso31661Alpha2 = 12; - case 12: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { - auto str = _internal_mutable_localecountryiso31661alpha2(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ClientPayload.UserAgent.localeCountryIso31661Alpha2"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string deviceBoard = 13; - case 13: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { - auto str = _internal_mutable_deviceboard(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ClientPayload.UserAgent.deviceBoard"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ClientPayload_UserAgent::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.ClientPayload.UserAgent) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.ClientPayload.UserAgent.Platform platform = 1; - if (cached_has_bits & 0x00000800u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 1, this->_internal_platform(), target); - } - - // optional .proto.ClientPayload.UserAgent.AppVersion appVersion = 2; - if (cached_has_bits & 0x00000400u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::appversion(this), - _Internal::appversion(this).GetCachedSize(), target, stream); - } - - // optional string mcc = 3; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_mcc().data(), static_cast(this->_internal_mcc().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ClientPayload.UserAgent.mcc"); - target = stream->WriteStringMaybeAliased( - 3, this->_internal_mcc(), target); - } - - // optional string mnc = 4; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_mnc().data(), static_cast(this->_internal_mnc().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ClientPayload.UserAgent.mnc"); - target = stream->WriteStringMaybeAliased( - 4, this->_internal_mnc(), target); - } - - // optional string osVersion = 5; - if (cached_has_bits & 0x00000004u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_osversion().data(), static_cast(this->_internal_osversion().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ClientPayload.UserAgent.osVersion"); - target = stream->WriteStringMaybeAliased( - 5, this->_internal_osversion(), target); - } - - // optional string manufacturer = 6; - if (cached_has_bits & 0x00000008u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_manufacturer().data(), static_cast(this->_internal_manufacturer().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ClientPayload.UserAgent.manufacturer"); - target = stream->WriteStringMaybeAliased( - 6, this->_internal_manufacturer(), target); - } - - // optional string device = 7; - if (cached_has_bits & 0x00000010u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_device().data(), static_cast(this->_internal_device().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ClientPayload.UserAgent.device"); - target = stream->WriteStringMaybeAliased( - 7, this->_internal_device(), target); - } - - // optional string osBuildNumber = 8; - if (cached_has_bits & 0x00000020u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_osbuildnumber().data(), static_cast(this->_internal_osbuildnumber().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ClientPayload.UserAgent.osBuildNumber"); - target = stream->WriteStringMaybeAliased( - 8, this->_internal_osbuildnumber(), target); - } - - // optional string phoneId = 9; - if (cached_has_bits & 0x00000040u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_phoneid().data(), static_cast(this->_internal_phoneid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ClientPayload.UserAgent.phoneId"); - target = stream->WriteStringMaybeAliased( - 9, this->_internal_phoneid(), target); - } - - // optional .proto.ClientPayload.UserAgent.ReleaseChannel releaseChannel = 10; - if (cached_has_bits & 0x00001000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 10, this->_internal_releasechannel(), target); - } - - // optional string localeLanguageIso6391 = 11; - if (cached_has_bits & 0x00000080u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_localelanguageiso6391().data(), static_cast(this->_internal_localelanguageiso6391().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ClientPayload.UserAgent.localeLanguageIso6391"); - target = stream->WriteStringMaybeAliased( - 11, this->_internal_localelanguageiso6391(), target); - } - - // optional string localeCountryIso31661Alpha2 = 12; - if (cached_has_bits & 0x00000100u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_localecountryiso31661alpha2().data(), static_cast(this->_internal_localecountryiso31661alpha2().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ClientPayload.UserAgent.localeCountryIso31661Alpha2"); - target = stream->WriteStringMaybeAliased( - 12, this->_internal_localecountryiso31661alpha2(), target); - } - - // optional string deviceBoard = 13; - if (cached_has_bits & 0x00000200u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_deviceboard().data(), static_cast(this->_internal_deviceboard().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ClientPayload.UserAgent.deviceBoard"); - target = stream->WriteStringMaybeAliased( - 13, this->_internal_deviceboard(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.ClientPayload.UserAgent) - return target; -} - -size_t ClientPayload_UserAgent::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.ClientPayload.UserAgent) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional string mcc = 3; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_mcc()); - } - - // optional string mnc = 4; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_mnc()); - } - - // optional string osVersion = 5; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_osversion()); - } - - // optional string manufacturer = 6; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_manufacturer()); - } - - // optional string device = 7; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_device()); - } - - // optional string osBuildNumber = 8; - if (cached_has_bits & 0x00000020u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_osbuildnumber()); - } - - // optional string phoneId = 9; - if (cached_has_bits & 0x00000040u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_phoneid()); - } - - // optional string localeLanguageIso6391 = 11; - if (cached_has_bits & 0x00000080u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_localelanguageiso6391()); - } - - } - if (cached_has_bits & 0x00001f00u) { - // optional string localeCountryIso31661Alpha2 = 12; - if (cached_has_bits & 0x00000100u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_localecountryiso31661alpha2()); - } - - // optional string deviceBoard = 13; - if (cached_has_bits & 0x00000200u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_deviceboard()); - } - - // optional .proto.ClientPayload.UserAgent.AppVersion appVersion = 2; - if (cached_has_bits & 0x00000400u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.appversion_); - } - - // optional .proto.ClientPayload.UserAgent.Platform platform = 1; - if (cached_has_bits & 0x00000800u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_platform()); - } - - // optional .proto.ClientPayload.UserAgent.ReleaseChannel releaseChannel = 10; - if (cached_has_bits & 0x00001000u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_releasechannel()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ClientPayload_UserAgent::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - ClientPayload_UserAgent::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ClientPayload_UserAgent::GetClassData() const { return &_class_data_; } - - -void ClientPayload_UserAgent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.ClientPayload.UserAgent) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_mcc(from._internal_mcc()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_mnc(from._internal_mnc()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_osversion(from._internal_osversion()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_set_manufacturer(from._internal_manufacturer()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_set_device(from._internal_device()); - } - if (cached_has_bits & 0x00000020u) { - _this->_internal_set_osbuildnumber(from._internal_osbuildnumber()); - } - if (cached_has_bits & 0x00000040u) { - _this->_internal_set_phoneid(from._internal_phoneid()); - } - if (cached_has_bits & 0x00000080u) { - _this->_internal_set_localelanguageiso6391(from._internal_localelanguageiso6391()); - } - } - if (cached_has_bits & 0x00001f00u) { - if (cached_has_bits & 0x00000100u) { - _this->_internal_set_localecountryiso31661alpha2(from._internal_localecountryiso31661alpha2()); - } - if (cached_has_bits & 0x00000200u) { - _this->_internal_set_deviceboard(from._internal_deviceboard()); - } - if (cached_has_bits & 0x00000400u) { - _this->_internal_mutable_appversion()->::proto::ClientPayload_UserAgent_AppVersion::MergeFrom( - from._internal_appversion()); - } - if (cached_has_bits & 0x00000800u) { - _this->_impl_.platform_ = from._impl_.platform_; - } - if (cached_has_bits & 0x00001000u) { - _this->_impl_.releasechannel_ = from._impl_.releasechannel_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ClientPayload_UserAgent::CopyFrom(const ClientPayload_UserAgent& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.ClientPayload.UserAgent) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ClientPayload_UserAgent::IsInitialized() const { - return true; -} - -void ClientPayload_UserAgent::InternalSwap(ClientPayload_UserAgent* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.mcc_, lhs_arena, - &other->_impl_.mcc_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.mnc_, lhs_arena, - &other->_impl_.mnc_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.osversion_, lhs_arena, - &other->_impl_.osversion_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.manufacturer_, lhs_arena, - &other->_impl_.manufacturer_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.device_, lhs_arena, - &other->_impl_.device_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.osbuildnumber_, lhs_arena, - &other->_impl_.osbuildnumber_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.phoneid_, lhs_arena, - &other->_impl_.phoneid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.localelanguageiso6391_, lhs_arena, - &other->_impl_.localelanguageiso6391_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.localecountryiso31661alpha2_, lhs_arena, - &other->_impl_.localecountryiso31661alpha2_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.deviceboard_, lhs_arena, - &other->_impl_.deviceboard_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ClientPayload_UserAgent, _impl_.releasechannel_) - + sizeof(ClientPayload_UserAgent::_impl_.releasechannel_) - - PROTOBUF_FIELD_OFFSET(ClientPayload_UserAgent, _impl_.appversion_)>( - reinterpret_cast(&_impl_.appversion_), - reinterpret_cast(&other->_impl_.appversion_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ClientPayload_UserAgent::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[18]); -} - -// =================================================================== - -class ClientPayload_WebInfo_WebdPayload::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_usesparticipantinkey(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_supportsstarredmessages(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_supportsdocumentmessages(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_supportsurlmessages(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static void set_has_supportsmediaretry(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static void set_has_supportse2eimage(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } - static void set_has_supportse2evideo(HasBits* has_bits) { - (*has_bits)[0] |= 256u; - } - static void set_has_supportse2eaudio(HasBits* has_bits) { - (*has_bits)[0] |= 512u; - } - static void set_has_supportse2edocument(HasBits* has_bits) { - (*has_bits)[0] |= 1024u; - } - static void set_has_documenttypes(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_features(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -ClientPayload_WebInfo_WebdPayload::ClientPayload_WebInfo_WebdPayload(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.ClientPayload.WebInfo.WebdPayload) -} -ClientPayload_WebInfo_WebdPayload::ClientPayload_WebInfo_WebdPayload(const ClientPayload_WebInfo_WebdPayload& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - ClientPayload_WebInfo_WebdPayload* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.documenttypes_){} - , decltype(_impl_.features_){} - , decltype(_impl_.usesparticipantinkey_){} - , decltype(_impl_.supportsstarredmessages_){} - , decltype(_impl_.supportsdocumentmessages_){} - , decltype(_impl_.supportsurlmessages_){} - , decltype(_impl_.supportsmediaretry_){} - , decltype(_impl_.supportse2eimage_){} - , decltype(_impl_.supportse2evideo_){} - , decltype(_impl_.supportse2eaudio_){} - , decltype(_impl_.supportse2edocument_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.documenttypes_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.documenttypes_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_documenttypes()) { - _this->_impl_.documenttypes_.Set(from._internal_documenttypes(), - _this->GetArenaForAllocation()); - } - _impl_.features_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.features_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_features()) { - _this->_impl_.features_.Set(from._internal_features(), - _this->GetArenaForAllocation()); - } - ::memcpy(&_impl_.usesparticipantinkey_, &from._impl_.usesparticipantinkey_, - static_cast(reinterpret_cast(&_impl_.supportse2edocument_) - - reinterpret_cast(&_impl_.usesparticipantinkey_)) + sizeof(_impl_.supportse2edocument_)); - // @@protoc_insertion_point(copy_constructor:proto.ClientPayload.WebInfo.WebdPayload) -} - -inline void ClientPayload_WebInfo_WebdPayload::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.documenttypes_){} - , decltype(_impl_.features_){} - , decltype(_impl_.usesparticipantinkey_){false} - , decltype(_impl_.supportsstarredmessages_){false} - , decltype(_impl_.supportsdocumentmessages_){false} - , decltype(_impl_.supportsurlmessages_){false} - , decltype(_impl_.supportsmediaretry_){false} - , decltype(_impl_.supportse2eimage_){false} - , decltype(_impl_.supportse2evideo_){false} - , decltype(_impl_.supportse2eaudio_){false} - , decltype(_impl_.supportse2edocument_){false} - }; - _impl_.documenttypes_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.documenttypes_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.features_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.features_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -ClientPayload_WebInfo_WebdPayload::~ClientPayload_WebInfo_WebdPayload() { - // @@protoc_insertion_point(destructor:proto.ClientPayload.WebInfo.WebdPayload) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void ClientPayload_WebInfo_WebdPayload::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.documenttypes_.Destroy(); - _impl_.features_.Destroy(); -} - -void ClientPayload_WebInfo_WebdPayload::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void ClientPayload_WebInfo_WebdPayload::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.ClientPayload.WebInfo.WebdPayload) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.documenttypes_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.features_.ClearNonDefaultToEmpty(); - } - } - if (cached_has_bits & 0x000000fcu) { - ::memset(&_impl_.usesparticipantinkey_, 0, static_cast( - reinterpret_cast(&_impl_.supportse2eimage_) - - reinterpret_cast(&_impl_.usesparticipantinkey_)) + sizeof(_impl_.supportse2eimage_)); - } - if (cached_has_bits & 0x00000700u) { - ::memset(&_impl_.supportse2evideo_, 0, static_cast( - reinterpret_cast(&_impl_.supportse2edocument_) - - reinterpret_cast(&_impl_.supportse2evideo_)) + sizeof(_impl_.supportse2edocument_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ClientPayload_WebInfo_WebdPayload::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bool usesParticipantInKey = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_usesparticipantinkey(&has_bits); - _impl_.usesparticipantinkey_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool supportsStarredMessages = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_supportsstarredmessages(&has_bits); - _impl_.supportsstarredmessages_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool supportsDocumentMessages = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_supportsdocumentmessages(&has_bits); - _impl_.supportsdocumentmessages_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool supportsUrlMessages = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - _Internal::set_has_supportsurlmessages(&has_bits); - _impl_.supportsurlmessages_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool supportsMediaRetry = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { - _Internal::set_has_supportsmediaretry(&has_bits); - _impl_.supportsmediaretry_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool supportsE2EImage = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { - _Internal::set_has_supportse2eimage(&has_bits); - _impl_.supportse2eimage_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool supportsE2EVideo = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { - _Internal::set_has_supportse2evideo(&has_bits); - _impl_.supportse2evideo_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool supportsE2EAudio = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { - _Internal::set_has_supportse2eaudio(&has_bits); - _impl_.supportse2eaudio_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool supportsE2EDocument = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { - _Internal::set_has_supportse2edocument(&has_bits); - _impl_.supportse2edocument_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string documentTypes = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { - auto str = _internal_mutable_documenttypes(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ClientPayload.WebInfo.WebdPayload.documentTypes"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bytes features = 11; - case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { - auto str = _internal_mutable_features(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ClientPayload_WebInfo_WebdPayload::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.ClientPayload.WebInfo.WebdPayload) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bool usesParticipantInKey = 1; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_usesparticipantinkey(), target); - } - - // optional bool supportsStarredMessages = 2; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(2, this->_internal_supportsstarredmessages(), target); - } - - // optional bool supportsDocumentMessages = 3; - if (cached_has_bits & 0x00000010u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_supportsdocumentmessages(), target); - } - - // optional bool supportsUrlMessages = 4; - if (cached_has_bits & 0x00000020u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(4, this->_internal_supportsurlmessages(), target); - } - - // optional bool supportsMediaRetry = 5; - if (cached_has_bits & 0x00000040u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(5, this->_internal_supportsmediaretry(), target); - } - - // optional bool supportsE2EImage = 6; - if (cached_has_bits & 0x00000080u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(6, this->_internal_supportse2eimage(), target); - } - - // optional bool supportsE2EVideo = 7; - if (cached_has_bits & 0x00000100u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(7, this->_internal_supportse2evideo(), target); - } - - // optional bool supportsE2EAudio = 8; - if (cached_has_bits & 0x00000200u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(8, this->_internal_supportse2eaudio(), target); - } - - // optional bool supportsE2EDocument = 9; - if (cached_has_bits & 0x00000400u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(9, this->_internal_supportse2edocument(), target); - } - - // optional string documentTypes = 10; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_documenttypes().data(), static_cast(this->_internal_documenttypes().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ClientPayload.WebInfo.WebdPayload.documentTypes"); - target = stream->WriteStringMaybeAliased( - 10, this->_internal_documenttypes(), target); - } - - // optional bytes features = 11; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 11, this->_internal_features(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.ClientPayload.WebInfo.WebdPayload) - return target; -} - -size_t ClientPayload_WebInfo_WebdPayload::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.ClientPayload.WebInfo.WebdPayload) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional string documentTypes = 10; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_documenttypes()); - } - - // optional bytes features = 11; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_features()); - } - - // optional bool usesParticipantInKey = 1; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + 1; - } - - // optional bool supportsStarredMessages = 2; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + 1; - } - - // optional bool supportsDocumentMessages = 3; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + 1; - } - - // optional bool supportsUrlMessages = 4; - if (cached_has_bits & 0x00000020u) { - total_size += 1 + 1; - } - - // optional bool supportsMediaRetry = 5; - if (cached_has_bits & 0x00000040u) { - total_size += 1 + 1; - } - - // optional bool supportsE2EImage = 6; - if (cached_has_bits & 0x00000080u) { - total_size += 1 + 1; - } - - } - if (cached_has_bits & 0x00000700u) { - // optional bool supportsE2EVideo = 7; - if (cached_has_bits & 0x00000100u) { - total_size += 1 + 1; - } - - // optional bool supportsE2EAudio = 8; - if (cached_has_bits & 0x00000200u) { - total_size += 1 + 1; - } - - // optional bool supportsE2EDocument = 9; - if (cached_has_bits & 0x00000400u) { - total_size += 1 + 1; - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ClientPayload_WebInfo_WebdPayload::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - ClientPayload_WebInfo_WebdPayload::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ClientPayload_WebInfo_WebdPayload::GetClassData() const { return &_class_data_; } - - -void ClientPayload_WebInfo_WebdPayload::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.ClientPayload.WebInfo.WebdPayload) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_documenttypes(from._internal_documenttypes()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_features(from._internal_features()); - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.usesparticipantinkey_ = from._impl_.usesparticipantinkey_; - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.supportsstarredmessages_ = from._impl_.supportsstarredmessages_; - } - if (cached_has_bits & 0x00000010u) { - _this->_impl_.supportsdocumentmessages_ = from._impl_.supportsdocumentmessages_; - } - if (cached_has_bits & 0x00000020u) { - _this->_impl_.supportsurlmessages_ = from._impl_.supportsurlmessages_; - } - if (cached_has_bits & 0x00000040u) { - _this->_impl_.supportsmediaretry_ = from._impl_.supportsmediaretry_; - } - if (cached_has_bits & 0x00000080u) { - _this->_impl_.supportse2eimage_ = from._impl_.supportse2eimage_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - if (cached_has_bits & 0x00000700u) { - if (cached_has_bits & 0x00000100u) { - _this->_impl_.supportse2evideo_ = from._impl_.supportse2evideo_; - } - if (cached_has_bits & 0x00000200u) { - _this->_impl_.supportse2eaudio_ = from._impl_.supportse2eaudio_; - } - if (cached_has_bits & 0x00000400u) { - _this->_impl_.supportse2edocument_ = from._impl_.supportse2edocument_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ClientPayload_WebInfo_WebdPayload::CopyFrom(const ClientPayload_WebInfo_WebdPayload& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.ClientPayload.WebInfo.WebdPayload) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ClientPayload_WebInfo_WebdPayload::IsInitialized() const { - return true; -} - -void ClientPayload_WebInfo_WebdPayload::InternalSwap(ClientPayload_WebInfo_WebdPayload* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.documenttypes_, lhs_arena, - &other->_impl_.documenttypes_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.features_, lhs_arena, - &other->_impl_.features_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ClientPayload_WebInfo_WebdPayload, _impl_.supportse2edocument_) - + sizeof(ClientPayload_WebInfo_WebdPayload::_impl_.supportse2edocument_) - - PROTOBUF_FIELD_OFFSET(ClientPayload_WebInfo_WebdPayload, _impl_.usesparticipantinkey_)>( - reinterpret_cast(&_impl_.usesparticipantinkey_), - reinterpret_cast(&other->_impl_.usesparticipantinkey_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ClientPayload_WebInfo_WebdPayload::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[19]); -} - -// =================================================================== - -class ClientPayload_WebInfo::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_reftoken(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_version(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::proto::ClientPayload_WebInfo_WebdPayload& webdpayload(const ClientPayload_WebInfo* msg); - static void set_has_webdpayload(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_websubplatform(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } -}; - -const ::proto::ClientPayload_WebInfo_WebdPayload& -ClientPayload_WebInfo::_Internal::webdpayload(const ClientPayload_WebInfo* msg) { - return *msg->_impl_.webdpayload_; -} -ClientPayload_WebInfo::ClientPayload_WebInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.ClientPayload.WebInfo) -} -ClientPayload_WebInfo::ClientPayload_WebInfo(const ClientPayload_WebInfo& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - ClientPayload_WebInfo* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.reftoken_){} - , decltype(_impl_.version_){} - , decltype(_impl_.webdpayload_){nullptr} - , decltype(_impl_.websubplatform_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.reftoken_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.reftoken_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_reftoken()) { - _this->_impl_.reftoken_.Set(from._internal_reftoken(), - _this->GetArenaForAllocation()); - } - _impl_.version_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.version_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_version()) { - _this->_impl_.version_.Set(from._internal_version(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_webdpayload()) { - _this->_impl_.webdpayload_ = new ::proto::ClientPayload_WebInfo_WebdPayload(*from._impl_.webdpayload_); - } - _this->_impl_.websubplatform_ = from._impl_.websubplatform_; - // @@protoc_insertion_point(copy_constructor:proto.ClientPayload.WebInfo) -} - -inline void ClientPayload_WebInfo::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.reftoken_){} - , decltype(_impl_.version_){} - , decltype(_impl_.webdpayload_){nullptr} - , decltype(_impl_.websubplatform_){0} - }; - _impl_.reftoken_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.reftoken_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.version_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.version_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -ClientPayload_WebInfo::~ClientPayload_WebInfo() { - // @@protoc_insertion_point(destructor:proto.ClientPayload.WebInfo) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void ClientPayload_WebInfo::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.reftoken_.Destroy(); - _impl_.version_.Destroy(); - if (this != internal_default_instance()) delete _impl_.webdpayload_; -} - -void ClientPayload_WebInfo::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void ClientPayload_WebInfo::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.ClientPayload.WebInfo) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _impl_.reftoken_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.version_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - GOOGLE_DCHECK(_impl_.webdpayload_ != nullptr); - _impl_.webdpayload_->Clear(); - } - } - _impl_.websubplatform_ = 0; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ClientPayload_WebInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string refToken = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_reftoken(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ClientPayload.WebInfo.refToken"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string version = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_version(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ClientPayload.WebInfo.version"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.ClientPayload.WebInfo.WebdPayload webdPayload = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_webdpayload(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.ClientPayload.WebInfo.WebSubPlatform webSubPlatform = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::ClientPayload_WebInfo_WebSubPlatform_IsValid(val))) { - _internal_set_websubplatform(static_cast<::proto::ClientPayload_WebInfo_WebSubPlatform>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ClientPayload_WebInfo::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.ClientPayload.WebInfo) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string refToken = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_reftoken().data(), static_cast(this->_internal_reftoken().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ClientPayload.WebInfo.refToken"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_reftoken(), target); - } - - // optional string version = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_version().data(), static_cast(this->_internal_version().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ClientPayload.WebInfo.version"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_version(), target); - } - - // optional .proto.ClientPayload.WebInfo.WebdPayload webdPayload = 3; - if (cached_has_bits & 0x00000004u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, _Internal::webdpayload(this), - _Internal::webdpayload(this).GetCachedSize(), target, stream); - } - - // optional .proto.ClientPayload.WebInfo.WebSubPlatform webSubPlatform = 4; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 4, this->_internal_websubplatform(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.ClientPayload.WebInfo) - return target; -} - -size_t ClientPayload_WebInfo::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.ClientPayload.WebInfo) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - // optional string refToken = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_reftoken()); - } - - // optional string version = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_version()); - } - - // optional .proto.ClientPayload.WebInfo.WebdPayload webdPayload = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.webdpayload_); - } - - // optional .proto.ClientPayload.WebInfo.WebSubPlatform webSubPlatform = 4; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_websubplatform()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ClientPayload_WebInfo::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - ClientPayload_WebInfo::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ClientPayload_WebInfo::GetClassData() const { return &_class_data_; } - - -void ClientPayload_WebInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.ClientPayload.WebInfo) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_reftoken(from._internal_reftoken()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_version(from._internal_version()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_mutable_webdpayload()->::proto::ClientPayload_WebInfo_WebdPayload::MergeFrom( - from._internal_webdpayload()); - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.websubplatform_ = from._impl_.websubplatform_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ClientPayload_WebInfo::CopyFrom(const ClientPayload_WebInfo& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.ClientPayload.WebInfo) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ClientPayload_WebInfo::IsInitialized() const { - return true; -} - -void ClientPayload_WebInfo::InternalSwap(ClientPayload_WebInfo* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.reftoken_, lhs_arena, - &other->_impl_.reftoken_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.version_, lhs_arena, - &other->_impl_.version_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ClientPayload_WebInfo, _impl_.websubplatform_) - + sizeof(ClientPayload_WebInfo::_impl_.websubplatform_) - - PROTOBUF_FIELD_OFFSET(ClientPayload_WebInfo, _impl_.webdpayload_)>( - reinterpret_cast(&_impl_.webdpayload_), - reinterpret_cast(&other->_impl_.webdpayload_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ClientPayload_WebInfo::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[20]); -} - -// =================================================================== - -class ClientPayload::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_username(HasBits* has_bits) { - (*has_bits)[0] |= 512u; - } - static void set_has_passive(HasBits* has_bits) { - (*has_bits)[0] |= 16384u; - } - static const ::proto::ClientPayload_UserAgent& useragent(const ClientPayload* msg); - static void set_has_useragent(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static const ::proto::ClientPayload_WebInfo& webinfo(const ClientPayload* msg); - static void set_has_webinfo(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static void set_has_pushname(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_sessionid(HasBits* has_bits) { - (*has_bits)[0] |= 1024u; - } - static void set_has_shortconnect(HasBits* has_bits) { - (*has_bits)[0] |= 32768u; - } - static void set_has_connecttype(HasBits* has_bits) { - (*has_bits)[0] |= 2048u; - } - static void set_has_connectreason(HasBits* has_bits) { - (*has_bits)[0] |= 4096u; - } - static const ::proto::ClientPayload_DNSSource& dnssource(const ClientPayload* msg); - static void set_has_dnssource(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } - static void set_has_connectattemptcount(HasBits* has_bits) { - (*has_bits)[0] |= 8192u; - } - static void set_has_device(HasBits* has_bits) { - (*has_bits)[0] |= 262144u; - } - static const ::proto::ClientPayload_DevicePairingRegistrationData& devicepairingdata(const ClientPayload* msg); - static void set_has_devicepairingdata(HasBits* has_bits) { - (*has_bits)[0] |= 256u; - } - static void set_has_product(HasBits* has_bits) { - (*has_bits)[0] |= 524288u; - } - static void set_has_fbcat(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_fbuseragent(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_oc(HasBits* has_bits) { - (*has_bits)[0] |= 65536u; - } - static void set_has_lc(HasBits* has_bits) { - (*has_bits)[0] |= 1048576u; - } - static void set_has_iosappextension(HasBits* has_bits) { - (*has_bits)[0] |= 4194304u; - } - static void set_has_fbappid(HasBits* has_bits) { - (*has_bits)[0] |= 2097152u; - } - static void set_has_fbdeviceid(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_pull(HasBits* has_bits) { - (*has_bits)[0] |= 131072u; - } - static void set_has_paddingbytes(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } -}; - -const ::proto::ClientPayload_UserAgent& -ClientPayload::_Internal::useragent(const ClientPayload* msg) { - return *msg->_impl_.useragent_; -} -const ::proto::ClientPayload_WebInfo& -ClientPayload::_Internal::webinfo(const ClientPayload* msg) { - return *msg->_impl_.webinfo_; -} -const ::proto::ClientPayload_DNSSource& -ClientPayload::_Internal::dnssource(const ClientPayload* msg) { - return *msg->_impl_.dnssource_; -} -const ::proto::ClientPayload_DevicePairingRegistrationData& -ClientPayload::_Internal::devicepairingdata(const ClientPayload* msg) { - return *msg->_impl_.devicepairingdata_; -} -ClientPayload::ClientPayload(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.ClientPayload) -} -ClientPayload::ClientPayload(const ClientPayload& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - ClientPayload* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.shards_){from._impl_.shards_} - , decltype(_impl_.pushname_){} - , decltype(_impl_.fbcat_){} - , decltype(_impl_.fbuseragent_){} - , decltype(_impl_.fbdeviceid_){} - , decltype(_impl_.paddingbytes_){} - , decltype(_impl_.useragent_){nullptr} - , decltype(_impl_.webinfo_){nullptr} - , decltype(_impl_.dnssource_){nullptr} - , decltype(_impl_.devicepairingdata_){nullptr} - , decltype(_impl_.username_){} - , decltype(_impl_.sessionid_){} - , decltype(_impl_.connecttype_){} - , decltype(_impl_.connectreason_){} - , decltype(_impl_.connectattemptcount_){} - , decltype(_impl_.passive_){} - , decltype(_impl_.shortconnect_){} - , decltype(_impl_.oc_){} - , decltype(_impl_.pull_){} - , decltype(_impl_.device_){} - , decltype(_impl_.product_){} - , decltype(_impl_.lc_){} - , decltype(_impl_.fbappid_){} - , decltype(_impl_.iosappextension_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.pushname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.pushname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_pushname()) { - _this->_impl_.pushname_.Set(from._internal_pushname(), - _this->GetArenaForAllocation()); - } - _impl_.fbcat_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fbcat_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_fbcat()) { - _this->_impl_.fbcat_.Set(from._internal_fbcat(), - _this->GetArenaForAllocation()); - } - _impl_.fbuseragent_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fbuseragent_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_fbuseragent()) { - _this->_impl_.fbuseragent_.Set(from._internal_fbuseragent(), - _this->GetArenaForAllocation()); - } - _impl_.fbdeviceid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fbdeviceid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_fbdeviceid()) { - _this->_impl_.fbdeviceid_.Set(from._internal_fbdeviceid(), - _this->GetArenaForAllocation()); - } - _impl_.paddingbytes_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.paddingbytes_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_paddingbytes()) { - _this->_impl_.paddingbytes_.Set(from._internal_paddingbytes(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_useragent()) { - _this->_impl_.useragent_ = new ::proto::ClientPayload_UserAgent(*from._impl_.useragent_); - } - if (from._internal_has_webinfo()) { - _this->_impl_.webinfo_ = new ::proto::ClientPayload_WebInfo(*from._impl_.webinfo_); - } - if (from._internal_has_dnssource()) { - _this->_impl_.dnssource_ = new ::proto::ClientPayload_DNSSource(*from._impl_.dnssource_); - } - if (from._internal_has_devicepairingdata()) { - _this->_impl_.devicepairingdata_ = new ::proto::ClientPayload_DevicePairingRegistrationData(*from._impl_.devicepairingdata_); - } - ::memcpy(&_impl_.username_, &from._impl_.username_, - static_cast(reinterpret_cast(&_impl_.iosappextension_) - - reinterpret_cast(&_impl_.username_)) + sizeof(_impl_.iosappextension_)); - // @@protoc_insertion_point(copy_constructor:proto.ClientPayload) -} - -inline void ClientPayload::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.shards_){arena} - , decltype(_impl_.pushname_){} - , decltype(_impl_.fbcat_){} - , decltype(_impl_.fbuseragent_){} - , decltype(_impl_.fbdeviceid_){} - , decltype(_impl_.paddingbytes_){} - , decltype(_impl_.useragent_){nullptr} - , decltype(_impl_.webinfo_){nullptr} - , decltype(_impl_.dnssource_){nullptr} - , decltype(_impl_.devicepairingdata_){nullptr} - , decltype(_impl_.username_){uint64_t{0u}} - , decltype(_impl_.sessionid_){0} - , decltype(_impl_.connecttype_){0} - , decltype(_impl_.connectreason_){0} - , decltype(_impl_.connectattemptcount_){0u} - , decltype(_impl_.passive_){false} - , decltype(_impl_.shortconnect_){false} - , decltype(_impl_.oc_){false} - , decltype(_impl_.pull_){false} - , decltype(_impl_.device_){0u} - , decltype(_impl_.product_){0} - , decltype(_impl_.lc_){0} - , decltype(_impl_.fbappid_){uint64_t{0u}} - , decltype(_impl_.iosappextension_){0} - }; - _impl_.pushname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.pushname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fbcat_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fbcat_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fbuseragent_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fbuseragent_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fbdeviceid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fbdeviceid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.paddingbytes_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.paddingbytes_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -ClientPayload::~ClientPayload() { - // @@protoc_insertion_point(destructor:proto.ClientPayload) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void ClientPayload::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.shards_.~RepeatedField(); - _impl_.pushname_.Destroy(); - _impl_.fbcat_.Destroy(); - _impl_.fbuseragent_.Destroy(); - _impl_.fbdeviceid_.Destroy(); - _impl_.paddingbytes_.Destroy(); - if (this != internal_default_instance()) delete _impl_.useragent_; - if (this != internal_default_instance()) delete _impl_.webinfo_; - if (this != internal_default_instance()) delete _impl_.dnssource_; - if (this != internal_default_instance()) delete _impl_.devicepairingdata_; -} - -void ClientPayload::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void ClientPayload::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.ClientPayload) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.shards_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _impl_.pushname_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.fbcat_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.fbuseragent_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000008u) { - _impl_.fbdeviceid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000010u) { - _impl_.paddingbytes_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000020u) { - GOOGLE_DCHECK(_impl_.useragent_ != nullptr); - _impl_.useragent_->Clear(); - } - if (cached_has_bits & 0x00000040u) { - GOOGLE_DCHECK(_impl_.webinfo_ != nullptr); - _impl_.webinfo_->Clear(); - } - if (cached_has_bits & 0x00000080u) { - GOOGLE_DCHECK(_impl_.dnssource_ != nullptr); - _impl_.dnssource_->Clear(); - } - } - if (cached_has_bits & 0x00000100u) { - GOOGLE_DCHECK(_impl_.devicepairingdata_ != nullptr); - _impl_.devicepairingdata_->Clear(); - } - if (cached_has_bits & 0x0000fe00u) { - ::memset(&_impl_.username_, 0, static_cast( - reinterpret_cast(&_impl_.shortconnect_) - - reinterpret_cast(&_impl_.username_)) + sizeof(_impl_.shortconnect_)); - } - if (cached_has_bits & 0x007f0000u) { - ::memset(&_impl_.oc_, 0, static_cast( - reinterpret_cast(&_impl_.iosappextension_) - - reinterpret_cast(&_impl_.oc_)) + sizeof(_impl_.iosappextension_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ClientPayload::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional uint64 username = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_username(&has_bits); - _impl_.username_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool passive = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_passive(&has_bits); - _impl_.passive_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.ClientPayload.UserAgent userAgent = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - ptr = ctx->ParseMessage(_internal_mutable_useragent(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.ClientPayload.WebInfo webInfo = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - ptr = ctx->ParseMessage(_internal_mutable_webinfo(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string pushName = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - auto str = _internal_mutable_pushname(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ClientPayload.pushName"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional sfixed32 sessionId = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 77)) { - _Internal::set_has_sessionid(&has_bits); - _impl_.sessionid_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); - ptr += sizeof(int32_t); - } else - goto handle_unusual; - continue; - // optional bool shortConnect = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { - _Internal::set_has_shortconnect(&has_bits); - _impl_.shortconnect_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.ClientPayload.ConnectType connectType = 12; - case 12: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::ClientPayload_ConnectType_IsValid(val))) { - _internal_set_connecttype(static_cast<::proto::ClientPayload_ConnectType>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(12, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.ClientPayload.ConnectReason connectReason = 13; - case 13: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 104)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::ClientPayload_ConnectReason_IsValid(val))) { - _internal_set_connectreason(static_cast<::proto::ClientPayload_ConnectReason>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(13, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // repeated int32 shards = 14; - case 14: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 112)) { - ptr -= 1; - do { - ptr += 1; - _internal_add_shards(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<112>(ptr)); - } else if (static_cast(tag) == 114) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_shards(), ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.ClientPayload.DNSSource dnsSource = 15; - case 15: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { - ptr = ctx->ParseMessage(_internal_mutable_dnssource(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 connectAttemptCount = 16; - case 16: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 128)) { - _Internal::set_has_connectattemptcount(&has_bits); - _impl_.connectattemptcount_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 device = 18; - case 18: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 144)) { - _Internal::set_has_device(&has_bits); - _impl_.device_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.ClientPayload.DevicePairingRegistrationData devicePairingData = 19; - case 19: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) { - ptr = ctx->ParseMessage(_internal_mutable_devicepairingdata(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.ClientPayload.Product product = 20; - case 20: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 160)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::ClientPayload_Product_IsValid(val))) { - _internal_set_product(static_cast<::proto::ClientPayload_Product>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(20, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional bytes fbCat = 21; - case 21: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { - auto str = _internal_mutable_fbcat(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes fbUserAgent = 22; - case 22: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 178)) { - auto str = _internal_mutable_fbuseragent(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool oc = 23; - case 23: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 184)) { - _Internal::set_has_oc(&has_bits); - _impl_.oc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional int32 lc = 24; - case 24: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 192)) { - _Internal::set_has_lc(&has_bits); - _impl_.lc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.ClientPayload.IOSAppExtension iosAppExtension = 30; - case 30: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 240)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::ClientPayload_IOSAppExtension_IsValid(val))) { - _internal_set_iosappextension(static_cast<::proto::ClientPayload_IOSAppExtension>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(30, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional uint64 fbAppId = 31; - case 31: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 248)) { - _Internal::set_has_fbappid(&has_bits); - _impl_.fbappid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes fbDeviceId = 32; - case 32: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 2)) { - auto str = _internal_mutable_fbdeviceid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool pull = 33; - case 33: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_pull(&has_bits); - _impl_.pull_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes paddingBytes = 34; - case 34: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_paddingbytes(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ClientPayload::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.ClientPayload) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional uint64 username = 1; - if (cached_has_bits & 0x00000200u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_username(), target); - } - - // optional bool passive = 3; - if (cached_has_bits & 0x00004000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_passive(), target); - } - - // optional .proto.ClientPayload.UserAgent userAgent = 5; - if (cached_has_bits & 0x00000020u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(5, _Internal::useragent(this), - _Internal::useragent(this).GetCachedSize(), target, stream); - } - - // optional .proto.ClientPayload.WebInfo webInfo = 6; - if (cached_has_bits & 0x00000040u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(6, _Internal::webinfo(this), - _Internal::webinfo(this).GetCachedSize(), target, stream); - } - - // optional string pushName = 7; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_pushname().data(), static_cast(this->_internal_pushname().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ClientPayload.pushName"); - target = stream->WriteStringMaybeAliased( - 7, this->_internal_pushname(), target); - } - - // optional sfixed32 sessionId = 9; - if (cached_has_bits & 0x00000400u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSFixed32ToArray(9, this->_internal_sessionid(), target); - } - - // optional bool shortConnect = 10; - if (cached_has_bits & 0x00008000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(10, this->_internal_shortconnect(), target); - } - - // optional .proto.ClientPayload.ConnectType connectType = 12; - if (cached_has_bits & 0x00000800u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 12, this->_internal_connecttype(), target); - } - - // optional .proto.ClientPayload.ConnectReason connectReason = 13; - if (cached_has_bits & 0x00001000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 13, this->_internal_connectreason(), target); - } - - // repeated int32 shards = 14; - for (int i = 0, n = this->_internal_shards_size(); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt32ToArray(14, this->_internal_shards(i), target); - } - - // optional .proto.ClientPayload.DNSSource dnsSource = 15; - if (cached_has_bits & 0x00000080u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(15, _Internal::dnssource(this), - _Internal::dnssource(this).GetCachedSize(), target, stream); - } - - // optional uint32 connectAttemptCount = 16; - if (cached_has_bits & 0x00002000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(16, this->_internal_connectattemptcount(), target); - } - - // optional uint32 device = 18; - if (cached_has_bits & 0x00040000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(18, this->_internal_device(), target); - } - - // optional .proto.ClientPayload.DevicePairingRegistrationData devicePairingData = 19; - if (cached_has_bits & 0x00000100u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(19, _Internal::devicepairingdata(this), - _Internal::devicepairingdata(this).GetCachedSize(), target, stream); - } - - // optional .proto.ClientPayload.Product product = 20; - if (cached_has_bits & 0x00080000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 20, this->_internal_product(), target); - } - - // optional bytes fbCat = 21; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 21, this->_internal_fbcat(), target); - } - - // optional bytes fbUserAgent = 22; - if (cached_has_bits & 0x00000004u) { - target = stream->WriteBytesMaybeAliased( - 22, this->_internal_fbuseragent(), target); - } - - // optional bool oc = 23; - if (cached_has_bits & 0x00010000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(23, this->_internal_oc(), target); - } - - // optional int32 lc = 24; - if (cached_has_bits & 0x00100000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt32ToArray(24, this->_internal_lc(), target); - } - - // optional .proto.ClientPayload.IOSAppExtension iosAppExtension = 30; - if (cached_has_bits & 0x00400000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 30, this->_internal_iosappextension(), target); - } - - // optional uint64 fbAppId = 31; - if (cached_has_bits & 0x00200000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(31, this->_internal_fbappid(), target); - } - - // optional bytes fbDeviceId = 32; - if (cached_has_bits & 0x00000008u) { - target = stream->WriteBytesMaybeAliased( - 32, this->_internal_fbdeviceid(), target); - } - - // optional bool pull = 33; - if (cached_has_bits & 0x00020000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(33, this->_internal_pull(), target); - } - - // optional bytes paddingBytes = 34; - if (cached_has_bits & 0x00000010u) { - target = stream->WriteBytesMaybeAliased( - 34, this->_internal_paddingbytes(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.ClientPayload) - return target; -} - -size_t ClientPayload::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.ClientPayload) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated int32 shards = 14; - { - size_t data_size = ::_pbi::WireFormatLite:: - Int32Size(this->_impl_.shards_); - total_size += 1 * - ::_pbi::FromIntSize(this->_internal_shards_size()); - total_size += data_size; - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional string pushName = 7; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_pushname()); - } - - // optional bytes fbCat = 21; - if (cached_has_bits & 0x00000002u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_fbcat()); - } - - // optional bytes fbUserAgent = 22; - if (cached_has_bits & 0x00000004u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_fbuseragent()); - } - - // optional bytes fbDeviceId = 32; - if (cached_has_bits & 0x00000008u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_fbdeviceid()); - } - - // optional bytes paddingBytes = 34; - if (cached_has_bits & 0x00000010u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_paddingbytes()); - } - - // optional .proto.ClientPayload.UserAgent userAgent = 5; - if (cached_has_bits & 0x00000020u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.useragent_); - } - - // optional .proto.ClientPayload.WebInfo webInfo = 6; - if (cached_has_bits & 0x00000040u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.webinfo_); - } - - // optional .proto.ClientPayload.DNSSource dnsSource = 15; - if (cached_has_bits & 0x00000080u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.dnssource_); - } - - } - if (cached_has_bits & 0x0000ff00u) { - // optional .proto.ClientPayload.DevicePairingRegistrationData devicePairingData = 19; - if (cached_has_bits & 0x00000100u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.devicepairingdata_); - } - - // optional uint64 username = 1; - if (cached_has_bits & 0x00000200u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_username()); - } - - // optional sfixed32 sessionId = 9; - if (cached_has_bits & 0x00000400u) { - total_size += 1 + 4; - } - - // optional .proto.ClientPayload.ConnectType connectType = 12; - if (cached_has_bits & 0x00000800u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_connecttype()); - } - - // optional .proto.ClientPayload.ConnectReason connectReason = 13; - if (cached_has_bits & 0x00001000u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_connectreason()); - } - - // optional uint32 connectAttemptCount = 16; - if (cached_has_bits & 0x00002000u) { - total_size += 2 + - ::_pbi::WireFormatLite::UInt32Size( - this->_internal_connectattemptcount()); - } - - // optional bool passive = 3; - if (cached_has_bits & 0x00004000u) { - total_size += 1 + 1; - } - - // optional bool shortConnect = 10; - if (cached_has_bits & 0x00008000u) { - total_size += 1 + 1; - } - - } - if (cached_has_bits & 0x007f0000u) { - // optional bool oc = 23; - if (cached_has_bits & 0x00010000u) { - total_size += 2 + 1; - } - - // optional bool pull = 33; - if (cached_has_bits & 0x00020000u) { - total_size += 2 + 1; - } - - // optional uint32 device = 18; - if (cached_has_bits & 0x00040000u) { - total_size += 2 + - ::_pbi::WireFormatLite::UInt32Size( - this->_internal_device()); - } - - // optional .proto.ClientPayload.Product product = 20; - if (cached_has_bits & 0x00080000u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_product()); - } - - // optional int32 lc = 24; - if (cached_has_bits & 0x00100000u) { - total_size += 2 + - ::_pbi::WireFormatLite::Int32Size( - this->_internal_lc()); - } - - // optional uint64 fbAppId = 31; - if (cached_has_bits & 0x00200000u) { - total_size += 2 + - ::_pbi::WireFormatLite::UInt64Size( - this->_internal_fbappid()); - } - - // optional .proto.ClientPayload.IOSAppExtension iosAppExtension = 30; - if (cached_has_bits & 0x00400000u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_iosappextension()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ClientPayload::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - ClientPayload::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ClientPayload::GetClassData() const { return &_class_data_; } - - -void ClientPayload::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.ClientPayload) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.shards_.MergeFrom(from._impl_.shards_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_pushname(from._internal_pushname()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_fbcat(from._internal_fbcat()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_fbuseragent(from._internal_fbuseragent()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_set_fbdeviceid(from._internal_fbdeviceid()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_set_paddingbytes(from._internal_paddingbytes()); - } - if (cached_has_bits & 0x00000020u) { - _this->_internal_mutable_useragent()->::proto::ClientPayload_UserAgent::MergeFrom( - from._internal_useragent()); - } - if (cached_has_bits & 0x00000040u) { - _this->_internal_mutable_webinfo()->::proto::ClientPayload_WebInfo::MergeFrom( - from._internal_webinfo()); - } - if (cached_has_bits & 0x00000080u) { - _this->_internal_mutable_dnssource()->::proto::ClientPayload_DNSSource::MergeFrom( - from._internal_dnssource()); - } - } - if (cached_has_bits & 0x0000ff00u) { - if (cached_has_bits & 0x00000100u) { - _this->_internal_mutable_devicepairingdata()->::proto::ClientPayload_DevicePairingRegistrationData::MergeFrom( - from._internal_devicepairingdata()); - } - if (cached_has_bits & 0x00000200u) { - _this->_impl_.username_ = from._impl_.username_; - } - if (cached_has_bits & 0x00000400u) { - _this->_impl_.sessionid_ = from._impl_.sessionid_; - } - if (cached_has_bits & 0x00000800u) { - _this->_impl_.connecttype_ = from._impl_.connecttype_; - } - if (cached_has_bits & 0x00001000u) { - _this->_impl_.connectreason_ = from._impl_.connectreason_; - } - if (cached_has_bits & 0x00002000u) { - _this->_impl_.connectattemptcount_ = from._impl_.connectattemptcount_; - } - if (cached_has_bits & 0x00004000u) { - _this->_impl_.passive_ = from._impl_.passive_; - } - if (cached_has_bits & 0x00008000u) { - _this->_impl_.shortconnect_ = from._impl_.shortconnect_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - if (cached_has_bits & 0x007f0000u) { - if (cached_has_bits & 0x00010000u) { - _this->_impl_.oc_ = from._impl_.oc_; - } - if (cached_has_bits & 0x00020000u) { - _this->_impl_.pull_ = from._impl_.pull_; - } - if (cached_has_bits & 0x00040000u) { - _this->_impl_.device_ = from._impl_.device_; - } - if (cached_has_bits & 0x00080000u) { - _this->_impl_.product_ = from._impl_.product_; - } - if (cached_has_bits & 0x00100000u) { - _this->_impl_.lc_ = from._impl_.lc_; - } - if (cached_has_bits & 0x00200000u) { - _this->_impl_.fbappid_ = from._impl_.fbappid_; - } - if (cached_has_bits & 0x00400000u) { - _this->_impl_.iosappextension_ = from._impl_.iosappextension_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ClientPayload::CopyFrom(const ClientPayload& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.ClientPayload) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ClientPayload::IsInitialized() const { - return true; -} - -void ClientPayload::InternalSwap(ClientPayload* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.shards_.InternalSwap(&other->_impl_.shards_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.pushname_, lhs_arena, - &other->_impl_.pushname_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.fbcat_, lhs_arena, - &other->_impl_.fbcat_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.fbuseragent_, lhs_arena, - &other->_impl_.fbuseragent_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.fbdeviceid_, lhs_arena, - &other->_impl_.fbdeviceid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.paddingbytes_, lhs_arena, - &other->_impl_.paddingbytes_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ClientPayload, _impl_.iosappextension_) - + sizeof(ClientPayload::_impl_.iosappextension_) - - PROTOBUF_FIELD_OFFSET(ClientPayload, _impl_.useragent_)>( - reinterpret_cast(&_impl_.useragent_), - reinterpret_cast(&other->_impl_.useragent_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ClientPayload::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[21]); -} - -// =================================================================== - -class ContextInfo_AdReplyInfo::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_advertisername(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_mediatype(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_jpegthumbnail(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_caption(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } -}; - -ContextInfo_AdReplyInfo::ContextInfo_AdReplyInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.ContextInfo.AdReplyInfo) -} -ContextInfo_AdReplyInfo::ContextInfo_AdReplyInfo(const ContextInfo_AdReplyInfo& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - ContextInfo_AdReplyInfo* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.advertisername_){} - , decltype(_impl_.jpegthumbnail_){} - , decltype(_impl_.caption_){} - , decltype(_impl_.mediatype_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.advertisername_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.advertisername_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_advertisername()) { - _this->_impl_.advertisername_.Set(from._internal_advertisername(), - _this->GetArenaForAllocation()); - } - _impl_.jpegthumbnail_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_jpegthumbnail()) { - _this->_impl_.jpegthumbnail_.Set(from._internal_jpegthumbnail(), - _this->GetArenaForAllocation()); - } - _impl_.caption_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.caption_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_caption()) { - _this->_impl_.caption_.Set(from._internal_caption(), - _this->GetArenaForAllocation()); - } - _this->_impl_.mediatype_ = from._impl_.mediatype_; - // @@protoc_insertion_point(copy_constructor:proto.ContextInfo.AdReplyInfo) -} - -inline void ContextInfo_AdReplyInfo::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.advertisername_){} - , decltype(_impl_.jpegthumbnail_){} - , decltype(_impl_.caption_){} - , decltype(_impl_.mediatype_){0} - }; - _impl_.advertisername_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.advertisername_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.jpegthumbnail_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.caption_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.caption_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -ContextInfo_AdReplyInfo::~ContextInfo_AdReplyInfo() { - // @@protoc_insertion_point(destructor:proto.ContextInfo.AdReplyInfo) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void ContextInfo_AdReplyInfo::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.advertisername_.Destroy(); - _impl_.jpegthumbnail_.Destroy(); - _impl_.caption_.Destroy(); -} - -void ContextInfo_AdReplyInfo::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void ContextInfo_AdReplyInfo::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.ContextInfo.AdReplyInfo) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _impl_.advertisername_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.jpegthumbnail_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.caption_.ClearNonDefaultToEmpty(); - } - } - _impl_.mediatype_ = 0; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ContextInfo_AdReplyInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string advertiserName = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_advertisername(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ContextInfo.AdReplyInfo.advertiserName"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.ContextInfo.AdReplyInfo.MediaType mediaType = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::ContextInfo_AdReplyInfo_MediaType_IsValid(val))) { - _internal_set_mediatype(static_cast<::proto::ContextInfo_AdReplyInfo_MediaType>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional bytes jpegThumbnail = 16; - case 16: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { - auto str = _internal_mutable_jpegthumbnail(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string caption = 17; - case 17: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { - auto str = _internal_mutable_caption(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ContextInfo.AdReplyInfo.caption"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ContextInfo_AdReplyInfo::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.ContextInfo.AdReplyInfo) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string advertiserName = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_advertisername().data(), static_cast(this->_internal_advertisername().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ContextInfo.AdReplyInfo.advertiserName"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_advertisername(), target); - } - - // optional .proto.ContextInfo.AdReplyInfo.MediaType mediaType = 2; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 2, this->_internal_mediatype(), target); - } - - // optional bytes jpegThumbnail = 16; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 16, this->_internal_jpegthumbnail(), target); - } - - // optional string caption = 17; - if (cached_has_bits & 0x00000004u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_caption().data(), static_cast(this->_internal_caption().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ContextInfo.AdReplyInfo.caption"); - target = stream->WriteStringMaybeAliased( - 17, this->_internal_caption(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.ContextInfo.AdReplyInfo) - return target; -} - -size_t ContextInfo_AdReplyInfo::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.ContextInfo.AdReplyInfo) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - // optional string advertiserName = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_advertisername()); - } - - // optional bytes jpegThumbnail = 16; - if (cached_has_bits & 0x00000002u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_jpegthumbnail()); - } - - // optional string caption = 17; - if (cached_has_bits & 0x00000004u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_caption()); - } - - // optional .proto.ContextInfo.AdReplyInfo.MediaType mediaType = 2; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_mediatype()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ContextInfo_AdReplyInfo::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - ContextInfo_AdReplyInfo::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ContextInfo_AdReplyInfo::GetClassData() const { return &_class_data_; } - - -void ContextInfo_AdReplyInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.ContextInfo.AdReplyInfo) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_advertisername(from._internal_advertisername()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_caption(from._internal_caption()); - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.mediatype_ = from._impl_.mediatype_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ContextInfo_AdReplyInfo::CopyFrom(const ContextInfo_AdReplyInfo& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.ContextInfo.AdReplyInfo) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ContextInfo_AdReplyInfo::IsInitialized() const { - return true; -} - -void ContextInfo_AdReplyInfo::InternalSwap(ContextInfo_AdReplyInfo* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.advertisername_, lhs_arena, - &other->_impl_.advertisername_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.jpegthumbnail_, lhs_arena, - &other->_impl_.jpegthumbnail_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.caption_, lhs_arena, - &other->_impl_.caption_, rhs_arena - ); - swap(_impl_.mediatype_, other->_impl_.mediatype_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ContextInfo_AdReplyInfo::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[22]); -} - -// =================================================================== - -class ContextInfo_ExternalAdReplyInfo::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_title(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_body(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_mediatype(HasBits* has_bits) { - (*has_bits)[0] |= 256u; - } - static void set_has_thumbnailurl(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_mediaurl(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_thumbnail(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_sourcetype(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static void set_has_sourceid(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static void set_has_sourceurl(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } - static void set_has_containsautoreply(HasBits* has_bits) { - (*has_bits)[0] |= 512u; - } - static void set_has_renderlargerthumbnail(HasBits* has_bits) { - (*has_bits)[0] |= 1024u; - } - static void set_has_showadattribution(HasBits* has_bits) { - (*has_bits)[0] |= 2048u; - } -}; - -ContextInfo_ExternalAdReplyInfo::ContextInfo_ExternalAdReplyInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.ContextInfo.ExternalAdReplyInfo) -} -ContextInfo_ExternalAdReplyInfo::ContextInfo_ExternalAdReplyInfo(const ContextInfo_ExternalAdReplyInfo& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - ContextInfo_ExternalAdReplyInfo* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.title_){} - , decltype(_impl_.body_){} - , decltype(_impl_.thumbnailurl_){} - , decltype(_impl_.mediaurl_){} - , decltype(_impl_.thumbnail_){} - , decltype(_impl_.sourcetype_){} - , decltype(_impl_.sourceid_){} - , decltype(_impl_.sourceurl_){} - , decltype(_impl_.mediatype_){} - , decltype(_impl_.containsautoreply_){} - , decltype(_impl_.renderlargerthumbnail_){} - , decltype(_impl_.showadattribution_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.title_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.title_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_title()) { - _this->_impl_.title_.Set(from._internal_title(), - _this->GetArenaForAllocation()); - } - _impl_.body_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.body_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_body()) { - _this->_impl_.body_.Set(from._internal_body(), - _this->GetArenaForAllocation()); - } - _impl_.thumbnailurl_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnailurl_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_thumbnailurl()) { - _this->_impl_.thumbnailurl_.Set(from._internal_thumbnailurl(), - _this->GetArenaForAllocation()); - } - _impl_.mediaurl_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediaurl_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_mediaurl()) { - _this->_impl_.mediaurl_.Set(from._internal_mediaurl(), - _this->GetArenaForAllocation()); - } - _impl_.thumbnail_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnail_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_thumbnail()) { - _this->_impl_.thumbnail_.Set(from._internal_thumbnail(), - _this->GetArenaForAllocation()); - } - _impl_.sourcetype_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.sourcetype_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_sourcetype()) { - _this->_impl_.sourcetype_.Set(from._internal_sourcetype(), - _this->GetArenaForAllocation()); - } - _impl_.sourceid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.sourceid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_sourceid()) { - _this->_impl_.sourceid_.Set(from._internal_sourceid(), - _this->GetArenaForAllocation()); - } - _impl_.sourceurl_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.sourceurl_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_sourceurl()) { - _this->_impl_.sourceurl_.Set(from._internal_sourceurl(), - _this->GetArenaForAllocation()); - } - ::memcpy(&_impl_.mediatype_, &from._impl_.mediatype_, - static_cast(reinterpret_cast(&_impl_.showadattribution_) - - reinterpret_cast(&_impl_.mediatype_)) + sizeof(_impl_.showadattribution_)); - // @@protoc_insertion_point(copy_constructor:proto.ContextInfo.ExternalAdReplyInfo) -} - -inline void ContextInfo_ExternalAdReplyInfo::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.title_){} - , decltype(_impl_.body_){} - , decltype(_impl_.thumbnailurl_){} - , decltype(_impl_.mediaurl_){} - , decltype(_impl_.thumbnail_){} - , decltype(_impl_.sourcetype_){} - , decltype(_impl_.sourceid_){} - , decltype(_impl_.sourceurl_){} - , decltype(_impl_.mediatype_){0} - , decltype(_impl_.containsautoreply_){false} - , decltype(_impl_.renderlargerthumbnail_){false} - , decltype(_impl_.showadattribution_){false} - }; - _impl_.title_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.title_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.body_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.body_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnailurl_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnailurl_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediaurl_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediaurl_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnail_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnail_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.sourcetype_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.sourcetype_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.sourceid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.sourceid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.sourceurl_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.sourceurl_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -ContextInfo_ExternalAdReplyInfo::~ContextInfo_ExternalAdReplyInfo() { - // @@protoc_insertion_point(destructor:proto.ContextInfo.ExternalAdReplyInfo) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void ContextInfo_ExternalAdReplyInfo::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.title_.Destroy(); - _impl_.body_.Destroy(); - _impl_.thumbnailurl_.Destroy(); - _impl_.mediaurl_.Destroy(); - _impl_.thumbnail_.Destroy(); - _impl_.sourcetype_.Destroy(); - _impl_.sourceid_.Destroy(); - _impl_.sourceurl_.Destroy(); -} - -void ContextInfo_ExternalAdReplyInfo::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void ContextInfo_ExternalAdReplyInfo::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.ContextInfo.ExternalAdReplyInfo) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _impl_.title_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.body_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.thumbnailurl_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000008u) { - _impl_.mediaurl_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000010u) { - _impl_.thumbnail_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000020u) { - _impl_.sourcetype_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000040u) { - _impl_.sourceid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000080u) { - _impl_.sourceurl_.ClearNonDefaultToEmpty(); - } - } - if (cached_has_bits & 0x00000f00u) { - ::memset(&_impl_.mediatype_, 0, static_cast( - reinterpret_cast(&_impl_.showadattribution_) - - reinterpret_cast(&_impl_.mediatype_)) + sizeof(_impl_.showadattribution_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ContextInfo_ExternalAdReplyInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string title = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_title(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ContextInfo.ExternalAdReplyInfo.title"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string body = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_body(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ContextInfo.ExternalAdReplyInfo.body"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.ContextInfo.ExternalAdReplyInfo.MediaType mediaType = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::ContextInfo_ExternalAdReplyInfo_MediaType_IsValid(val))) { - _internal_set_mediatype(static_cast<::proto::ContextInfo_ExternalAdReplyInfo_MediaType>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional string thumbnailUrl = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - auto str = _internal_mutable_thumbnailurl(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ContextInfo.ExternalAdReplyInfo.thumbnailUrl"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string mediaUrl = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - auto str = _internal_mutable_mediaurl(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ContextInfo.ExternalAdReplyInfo.mediaUrl"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bytes thumbnail = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - auto str = _internal_mutable_thumbnail(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string sourceType = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - auto str = _internal_mutable_sourcetype(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ContextInfo.ExternalAdReplyInfo.sourceType"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string sourceId = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { - auto str = _internal_mutable_sourceid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ContextInfo.ExternalAdReplyInfo.sourceId"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string sourceUrl = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { - auto str = _internal_mutable_sourceurl(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ContextInfo.ExternalAdReplyInfo.sourceUrl"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bool containsAutoReply = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { - _Internal::set_has_containsautoreply(&has_bits); - _impl_.containsautoreply_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool renderLargerThumbnail = 11; - case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { - _Internal::set_has_renderlargerthumbnail(&has_bits); - _impl_.renderlargerthumbnail_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool showAdAttribution = 12; - case 12: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { - _Internal::set_has_showadattribution(&has_bits); - _impl_.showadattribution_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ContextInfo_ExternalAdReplyInfo::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.ContextInfo.ExternalAdReplyInfo) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string title = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_title().data(), static_cast(this->_internal_title().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ContextInfo.ExternalAdReplyInfo.title"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_title(), target); - } - - // optional string body = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_body().data(), static_cast(this->_internal_body().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ContextInfo.ExternalAdReplyInfo.body"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_body(), target); - } - - // optional .proto.ContextInfo.ExternalAdReplyInfo.MediaType mediaType = 3; - if (cached_has_bits & 0x00000100u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 3, this->_internal_mediatype(), target); - } - - // optional string thumbnailUrl = 4; - if (cached_has_bits & 0x00000004u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_thumbnailurl().data(), static_cast(this->_internal_thumbnailurl().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ContextInfo.ExternalAdReplyInfo.thumbnailUrl"); - target = stream->WriteStringMaybeAliased( - 4, this->_internal_thumbnailurl(), target); - } - - // optional string mediaUrl = 5; - if (cached_has_bits & 0x00000008u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_mediaurl().data(), static_cast(this->_internal_mediaurl().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ContextInfo.ExternalAdReplyInfo.mediaUrl"); - target = stream->WriteStringMaybeAliased( - 5, this->_internal_mediaurl(), target); - } - - // optional bytes thumbnail = 6; - if (cached_has_bits & 0x00000010u) { - target = stream->WriteBytesMaybeAliased( - 6, this->_internal_thumbnail(), target); - } - - // optional string sourceType = 7; - if (cached_has_bits & 0x00000020u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_sourcetype().data(), static_cast(this->_internal_sourcetype().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ContextInfo.ExternalAdReplyInfo.sourceType"); - target = stream->WriteStringMaybeAliased( - 7, this->_internal_sourcetype(), target); - } - - // optional string sourceId = 8; - if (cached_has_bits & 0x00000040u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_sourceid().data(), static_cast(this->_internal_sourceid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ContextInfo.ExternalAdReplyInfo.sourceId"); - target = stream->WriteStringMaybeAliased( - 8, this->_internal_sourceid(), target); - } - - // optional string sourceUrl = 9; - if (cached_has_bits & 0x00000080u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_sourceurl().data(), static_cast(this->_internal_sourceurl().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ContextInfo.ExternalAdReplyInfo.sourceUrl"); - target = stream->WriteStringMaybeAliased( - 9, this->_internal_sourceurl(), target); - } - - // optional bool containsAutoReply = 10; - if (cached_has_bits & 0x00000200u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(10, this->_internal_containsautoreply(), target); - } - - // optional bool renderLargerThumbnail = 11; - if (cached_has_bits & 0x00000400u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(11, this->_internal_renderlargerthumbnail(), target); - } - - // optional bool showAdAttribution = 12; - if (cached_has_bits & 0x00000800u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(12, this->_internal_showadattribution(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.ContextInfo.ExternalAdReplyInfo) - return target; -} - -size_t ContextInfo_ExternalAdReplyInfo::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.ContextInfo.ExternalAdReplyInfo) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional string title = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_title()); - } - - // optional string body = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_body()); - } - - // optional string thumbnailUrl = 4; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_thumbnailurl()); - } - - // optional string mediaUrl = 5; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_mediaurl()); - } - - // optional bytes thumbnail = 6; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_thumbnail()); - } - - // optional string sourceType = 7; - if (cached_has_bits & 0x00000020u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_sourcetype()); - } - - // optional string sourceId = 8; - if (cached_has_bits & 0x00000040u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_sourceid()); - } - - // optional string sourceUrl = 9; - if (cached_has_bits & 0x00000080u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_sourceurl()); - } - - } - if (cached_has_bits & 0x00000f00u) { - // optional .proto.ContextInfo.ExternalAdReplyInfo.MediaType mediaType = 3; - if (cached_has_bits & 0x00000100u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_mediatype()); - } - - // optional bool containsAutoReply = 10; - if (cached_has_bits & 0x00000200u) { - total_size += 1 + 1; - } - - // optional bool renderLargerThumbnail = 11; - if (cached_has_bits & 0x00000400u) { - total_size += 1 + 1; - } - - // optional bool showAdAttribution = 12; - if (cached_has_bits & 0x00000800u) { - total_size += 1 + 1; - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ContextInfo_ExternalAdReplyInfo::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - ContextInfo_ExternalAdReplyInfo::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ContextInfo_ExternalAdReplyInfo::GetClassData() const { return &_class_data_; } - - -void ContextInfo_ExternalAdReplyInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.ContextInfo.ExternalAdReplyInfo) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_title(from._internal_title()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_body(from._internal_body()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_thumbnailurl(from._internal_thumbnailurl()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_set_mediaurl(from._internal_mediaurl()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_set_thumbnail(from._internal_thumbnail()); - } - if (cached_has_bits & 0x00000020u) { - _this->_internal_set_sourcetype(from._internal_sourcetype()); - } - if (cached_has_bits & 0x00000040u) { - _this->_internal_set_sourceid(from._internal_sourceid()); - } - if (cached_has_bits & 0x00000080u) { - _this->_internal_set_sourceurl(from._internal_sourceurl()); - } - } - if (cached_has_bits & 0x00000f00u) { - if (cached_has_bits & 0x00000100u) { - _this->_impl_.mediatype_ = from._impl_.mediatype_; - } - if (cached_has_bits & 0x00000200u) { - _this->_impl_.containsautoreply_ = from._impl_.containsautoreply_; - } - if (cached_has_bits & 0x00000400u) { - _this->_impl_.renderlargerthumbnail_ = from._impl_.renderlargerthumbnail_; - } - if (cached_has_bits & 0x00000800u) { - _this->_impl_.showadattribution_ = from._impl_.showadattribution_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ContextInfo_ExternalAdReplyInfo::CopyFrom(const ContextInfo_ExternalAdReplyInfo& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.ContextInfo.ExternalAdReplyInfo) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ContextInfo_ExternalAdReplyInfo::IsInitialized() const { - return true; -} - -void ContextInfo_ExternalAdReplyInfo::InternalSwap(ContextInfo_ExternalAdReplyInfo* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.title_, lhs_arena, - &other->_impl_.title_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.body_, lhs_arena, - &other->_impl_.body_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.thumbnailurl_, lhs_arena, - &other->_impl_.thumbnailurl_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.mediaurl_, lhs_arena, - &other->_impl_.mediaurl_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.thumbnail_, lhs_arena, - &other->_impl_.thumbnail_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.sourcetype_, lhs_arena, - &other->_impl_.sourcetype_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.sourceid_, lhs_arena, - &other->_impl_.sourceid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.sourceurl_, lhs_arena, - &other->_impl_.sourceurl_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ContextInfo_ExternalAdReplyInfo, _impl_.showadattribution_) - + sizeof(ContextInfo_ExternalAdReplyInfo::_impl_.showadattribution_) - - PROTOBUF_FIELD_OFFSET(ContextInfo_ExternalAdReplyInfo, _impl_.mediatype_)>( - reinterpret_cast(&_impl_.mediatype_), - reinterpret_cast(&other->_impl_.mediatype_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ContextInfo_ExternalAdReplyInfo::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[23]); -} - -// =================================================================== - -class ContextInfo::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_stanzaid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_participant(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::proto::Message& quotedmessage(const ContextInfo* msg); - static void set_has_quotedmessage(HasBits* has_bits) { - (*has_bits)[0] |= 1024u; - } - static void set_has_remotejid(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_conversionsource(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_conversiondata(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_conversiondelayseconds(HasBits* has_bits) { - (*has_bits)[0] |= 65536u; - } - static void set_has_forwardingscore(HasBits* has_bits) { - (*has_bits)[0] |= 131072u; - } - static void set_has_isforwarded(HasBits* has_bits) { - (*has_bits)[0] |= 262144u; - } - static const ::proto::ContextInfo_AdReplyInfo& quotedad(const ContextInfo* msg); - static void set_has_quotedad(HasBits* has_bits) { - (*has_bits)[0] |= 2048u; - } - static const ::proto::MessageKey& placeholderkey(const ContextInfo* msg); - static void set_has_placeholderkey(HasBits* has_bits) { - (*has_bits)[0] |= 4096u; - } - static void set_has_expiration(HasBits* has_bits) { - (*has_bits)[0] |= 524288u; - } - static void set_has_ephemeralsettingtimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 1048576u; - } - static void set_has_ephemeralsharedsecret(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static const ::proto::ContextInfo_ExternalAdReplyInfo& externaladreply(const ContextInfo* msg); - static void set_has_externaladreply(HasBits* has_bits) { - (*has_bits)[0] |= 8192u; - } - static void set_has_entrypointconversionsource(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static void set_has_entrypointconversionapp(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } - static void set_has_entrypointconversiondelayseconds(HasBits* has_bits) { - (*has_bits)[0] |= 2097152u; - } - static const ::proto::DisappearingMode& disappearingmode(const ContextInfo* msg); - static void set_has_disappearingmode(HasBits* has_bits) { - (*has_bits)[0] |= 16384u; - } - static const ::proto::ActionLink& actionlink(const ContextInfo* msg); - static void set_has_actionlink(HasBits* has_bits) { - (*has_bits)[0] |= 32768u; - } - static void set_has_groupsubject(HasBits* has_bits) { - (*has_bits)[0] |= 256u; - } - static void set_has_parentgroupjid(HasBits* has_bits) { - (*has_bits)[0] |= 512u; - } -}; - -const ::proto::Message& -ContextInfo::_Internal::quotedmessage(const ContextInfo* msg) { - return *msg->_impl_.quotedmessage_; -} -const ::proto::ContextInfo_AdReplyInfo& -ContextInfo::_Internal::quotedad(const ContextInfo* msg) { - return *msg->_impl_.quotedad_; -} -const ::proto::MessageKey& -ContextInfo::_Internal::placeholderkey(const ContextInfo* msg) { - return *msg->_impl_.placeholderkey_; -} -const ::proto::ContextInfo_ExternalAdReplyInfo& -ContextInfo::_Internal::externaladreply(const ContextInfo* msg) { - return *msg->_impl_.externaladreply_; -} -const ::proto::DisappearingMode& -ContextInfo::_Internal::disappearingmode(const ContextInfo* msg) { - return *msg->_impl_.disappearingmode_; -} -const ::proto::ActionLink& -ContextInfo::_Internal::actionlink(const ContextInfo* msg) { - return *msg->_impl_.actionlink_; -} -ContextInfo::ContextInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.ContextInfo) -} -ContextInfo::ContextInfo(const ContextInfo& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - ContextInfo* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.mentionedjid_){from._impl_.mentionedjid_} - , decltype(_impl_.stanzaid_){} - , decltype(_impl_.participant_){} - , decltype(_impl_.remotejid_){} - , decltype(_impl_.conversionsource_){} - , decltype(_impl_.conversiondata_){} - , decltype(_impl_.ephemeralsharedsecret_){} - , decltype(_impl_.entrypointconversionsource_){} - , decltype(_impl_.entrypointconversionapp_){} - , decltype(_impl_.groupsubject_){} - , decltype(_impl_.parentgroupjid_){} - , decltype(_impl_.quotedmessage_){nullptr} - , decltype(_impl_.quotedad_){nullptr} - , decltype(_impl_.placeholderkey_){nullptr} - , decltype(_impl_.externaladreply_){nullptr} - , decltype(_impl_.disappearingmode_){nullptr} - , decltype(_impl_.actionlink_){nullptr} - , decltype(_impl_.conversiondelayseconds_){} - , decltype(_impl_.forwardingscore_){} - , decltype(_impl_.isforwarded_){} - , decltype(_impl_.expiration_){} - , decltype(_impl_.ephemeralsettingtimestamp_){} - , decltype(_impl_.entrypointconversiondelayseconds_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.stanzaid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.stanzaid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_stanzaid()) { - _this->_impl_.stanzaid_.Set(from._internal_stanzaid(), - _this->GetArenaForAllocation()); - } - _impl_.participant_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.participant_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_participant()) { - _this->_impl_.participant_.Set(from._internal_participant(), - _this->GetArenaForAllocation()); - } - _impl_.remotejid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.remotejid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_remotejid()) { - _this->_impl_.remotejid_.Set(from._internal_remotejid(), - _this->GetArenaForAllocation()); - } - _impl_.conversionsource_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.conversionsource_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_conversionsource()) { - _this->_impl_.conversionsource_.Set(from._internal_conversionsource(), - _this->GetArenaForAllocation()); - } - _impl_.conversiondata_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.conversiondata_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_conversiondata()) { - _this->_impl_.conversiondata_.Set(from._internal_conversiondata(), - _this->GetArenaForAllocation()); - } - _impl_.ephemeralsharedsecret_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.ephemeralsharedsecret_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_ephemeralsharedsecret()) { - _this->_impl_.ephemeralsharedsecret_.Set(from._internal_ephemeralsharedsecret(), - _this->GetArenaForAllocation()); - } - _impl_.entrypointconversionsource_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.entrypointconversionsource_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_entrypointconversionsource()) { - _this->_impl_.entrypointconversionsource_.Set(from._internal_entrypointconversionsource(), - _this->GetArenaForAllocation()); - } - _impl_.entrypointconversionapp_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.entrypointconversionapp_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_entrypointconversionapp()) { - _this->_impl_.entrypointconversionapp_.Set(from._internal_entrypointconversionapp(), - _this->GetArenaForAllocation()); - } - _impl_.groupsubject_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.groupsubject_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_groupsubject()) { - _this->_impl_.groupsubject_.Set(from._internal_groupsubject(), - _this->GetArenaForAllocation()); - } - _impl_.parentgroupjid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.parentgroupjid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_parentgroupjid()) { - _this->_impl_.parentgroupjid_.Set(from._internal_parentgroupjid(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_quotedmessage()) { - _this->_impl_.quotedmessage_ = new ::proto::Message(*from._impl_.quotedmessage_); - } - if (from._internal_has_quotedad()) { - _this->_impl_.quotedad_ = new ::proto::ContextInfo_AdReplyInfo(*from._impl_.quotedad_); - } - if (from._internal_has_placeholderkey()) { - _this->_impl_.placeholderkey_ = new ::proto::MessageKey(*from._impl_.placeholderkey_); - } - if (from._internal_has_externaladreply()) { - _this->_impl_.externaladreply_ = new ::proto::ContextInfo_ExternalAdReplyInfo(*from._impl_.externaladreply_); - } - if (from._internal_has_disappearingmode()) { - _this->_impl_.disappearingmode_ = new ::proto::DisappearingMode(*from._impl_.disappearingmode_); - } - if (from._internal_has_actionlink()) { - _this->_impl_.actionlink_ = new ::proto::ActionLink(*from._impl_.actionlink_); - } - ::memcpy(&_impl_.conversiondelayseconds_, &from._impl_.conversiondelayseconds_, - static_cast(reinterpret_cast(&_impl_.entrypointconversiondelayseconds_) - - reinterpret_cast(&_impl_.conversiondelayseconds_)) + sizeof(_impl_.entrypointconversiondelayseconds_)); - // @@protoc_insertion_point(copy_constructor:proto.ContextInfo) -} - -inline void ContextInfo::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.mentionedjid_){arena} - , decltype(_impl_.stanzaid_){} - , decltype(_impl_.participant_){} - , decltype(_impl_.remotejid_){} - , decltype(_impl_.conversionsource_){} - , decltype(_impl_.conversiondata_){} - , decltype(_impl_.ephemeralsharedsecret_){} - , decltype(_impl_.entrypointconversionsource_){} - , decltype(_impl_.entrypointconversionapp_){} - , decltype(_impl_.groupsubject_){} - , decltype(_impl_.parentgroupjid_){} - , decltype(_impl_.quotedmessage_){nullptr} - , decltype(_impl_.quotedad_){nullptr} - , decltype(_impl_.placeholderkey_){nullptr} - , decltype(_impl_.externaladreply_){nullptr} - , decltype(_impl_.disappearingmode_){nullptr} - , decltype(_impl_.actionlink_){nullptr} - , decltype(_impl_.conversiondelayseconds_){0u} - , decltype(_impl_.forwardingscore_){0u} - , decltype(_impl_.isforwarded_){false} - , decltype(_impl_.expiration_){0u} - , decltype(_impl_.ephemeralsettingtimestamp_){int64_t{0}} - , decltype(_impl_.entrypointconversiondelayseconds_){0u} - }; - _impl_.stanzaid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.stanzaid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.participant_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.participant_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.remotejid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.remotejid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.conversionsource_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.conversionsource_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.conversiondata_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.conversiondata_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.ephemeralsharedsecret_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.ephemeralsharedsecret_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.entrypointconversionsource_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.entrypointconversionsource_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.entrypointconversionapp_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.entrypointconversionapp_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.groupsubject_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.groupsubject_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.parentgroupjid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.parentgroupjid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -ContextInfo::~ContextInfo() { - // @@protoc_insertion_point(destructor:proto.ContextInfo) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void ContextInfo::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.mentionedjid_.~RepeatedPtrField(); - _impl_.stanzaid_.Destroy(); - _impl_.participant_.Destroy(); - _impl_.remotejid_.Destroy(); - _impl_.conversionsource_.Destroy(); - _impl_.conversiondata_.Destroy(); - _impl_.ephemeralsharedsecret_.Destroy(); - _impl_.entrypointconversionsource_.Destroy(); - _impl_.entrypointconversionapp_.Destroy(); - _impl_.groupsubject_.Destroy(); - _impl_.parentgroupjid_.Destroy(); - if (this != internal_default_instance()) delete _impl_.quotedmessage_; - if (this != internal_default_instance()) delete _impl_.quotedad_; - if (this != internal_default_instance()) delete _impl_.placeholderkey_; - if (this != internal_default_instance()) delete _impl_.externaladreply_; - if (this != internal_default_instance()) delete _impl_.disappearingmode_; - if (this != internal_default_instance()) delete _impl_.actionlink_; -} - -void ContextInfo::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void ContextInfo::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.ContextInfo) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.mentionedjid_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _impl_.stanzaid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.participant_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.remotejid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000008u) { - _impl_.conversionsource_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000010u) { - _impl_.conversiondata_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000020u) { - _impl_.ephemeralsharedsecret_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000040u) { - _impl_.entrypointconversionsource_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000080u) { - _impl_.entrypointconversionapp_.ClearNonDefaultToEmpty(); - } - } - if (cached_has_bits & 0x0000ff00u) { - if (cached_has_bits & 0x00000100u) { - _impl_.groupsubject_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000200u) { - _impl_.parentgroupjid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000400u) { - GOOGLE_DCHECK(_impl_.quotedmessage_ != nullptr); - _impl_.quotedmessage_->Clear(); - } - if (cached_has_bits & 0x00000800u) { - GOOGLE_DCHECK(_impl_.quotedad_ != nullptr); - _impl_.quotedad_->Clear(); - } - if (cached_has_bits & 0x00001000u) { - GOOGLE_DCHECK(_impl_.placeholderkey_ != nullptr); - _impl_.placeholderkey_->Clear(); - } - if (cached_has_bits & 0x00002000u) { - GOOGLE_DCHECK(_impl_.externaladreply_ != nullptr); - _impl_.externaladreply_->Clear(); - } - if (cached_has_bits & 0x00004000u) { - GOOGLE_DCHECK(_impl_.disappearingmode_ != nullptr); - _impl_.disappearingmode_->Clear(); - } - if (cached_has_bits & 0x00008000u) { - GOOGLE_DCHECK(_impl_.actionlink_ != nullptr); - _impl_.actionlink_->Clear(); - } - } - if (cached_has_bits & 0x003f0000u) { - ::memset(&_impl_.conversiondelayseconds_, 0, static_cast( - reinterpret_cast(&_impl_.entrypointconversiondelayseconds_) - - reinterpret_cast(&_impl_.conversiondelayseconds_)) + sizeof(_impl_.entrypointconversiondelayseconds_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ContextInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string stanzaId = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_stanzaid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ContextInfo.stanzaId"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string participant = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_participant(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ContextInfo.participant"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.Message quotedMessage = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_quotedmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string remoteJid = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - auto str = _internal_mutable_remotejid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ContextInfo.remoteJid"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // repeated string mentionedJid = 15; - case 15: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { - ptr -= 1; - do { - ptr += 1; - auto str = _internal_add_mentionedjid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ContextInfo.mentionedJid"); - #endif // !NDEBUG - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<122>(ptr)); - } else - goto handle_unusual; - continue; - // optional string conversionSource = 18; - case 18: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { - auto str = _internal_mutable_conversionsource(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ContextInfo.conversionSource"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bytes conversionData = 19; - case 19: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) { - auto str = _internal_mutable_conversiondata(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 conversionDelaySeconds = 20; - case 20: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 160)) { - _Internal::set_has_conversiondelayseconds(&has_bits); - _impl_.conversiondelayseconds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 forwardingScore = 21; - case 21: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 168)) { - _Internal::set_has_forwardingscore(&has_bits); - _impl_.forwardingscore_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool isForwarded = 22; - case 22: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 176)) { - _Internal::set_has_isforwarded(&has_bits); - _impl_.isforwarded_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.ContextInfo.AdReplyInfo quotedAd = 23; - case 23: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { - ptr = ctx->ParseMessage(_internal_mutable_quotedad(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.MessageKey placeholderKey = 24; - case 24: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 194)) { - ptr = ctx->ParseMessage(_internal_mutable_placeholderkey(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 expiration = 25; - case 25: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 200)) { - _Internal::set_has_expiration(&has_bits); - _impl_.expiration_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional int64 ephemeralSettingTimestamp = 26; - case 26: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 208)) { - _Internal::set_has_ephemeralsettingtimestamp(&has_bits); - _impl_.ephemeralsettingtimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes ephemeralSharedSecret = 27; - case 27: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 218)) { - auto str = _internal_mutable_ephemeralsharedsecret(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.ContextInfo.ExternalAdReplyInfo externalAdReply = 28; - case 28: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 226)) { - ptr = ctx->ParseMessage(_internal_mutable_externaladreply(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string entryPointConversionSource = 29; - case 29: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 234)) { - auto str = _internal_mutable_entrypointconversionsource(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ContextInfo.entryPointConversionSource"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string entryPointConversionApp = 30; - case 30: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 242)) { - auto str = _internal_mutable_entrypointconversionapp(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ContextInfo.entryPointConversionApp"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional uint32 entryPointConversionDelaySeconds = 31; - case 31: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 248)) { - _Internal::set_has_entrypointconversiondelayseconds(&has_bits); - _impl_.entrypointconversiondelayseconds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.DisappearingMode disappearingMode = 32; - case 32: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 2)) { - ptr = ctx->ParseMessage(_internal_mutable_disappearingmode(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.ActionLink actionLink = 33; - case 33: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_actionlink(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string groupSubject = 34; - case 34: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_groupsubject(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ContextInfo.groupSubject"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string parentGroupJid = 35; - case 35: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_parentgroupjid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ContextInfo.parentGroupJid"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ContextInfo::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.ContextInfo) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string stanzaId = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_stanzaid().data(), static_cast(this->_internal_stanzaid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ContextInfo.stanzaId"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_stanzaid(), target); - } - - // optional string participant = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_participant().data(), static_cast(this->_internal_participant().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ContextInfo.participant"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_participant(), target); - } - - // optional .proto.Message quotedMessage = 3; - if (cached_has_bits & 0x00000400u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, _Internal::quotedmessage(this), - _Internal::quotedmessage(this).GetCachedSize(), target, stream); - } - - // optional string remoteJid = 4; - if (cached_has_bits & 0x00000004u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_remotejid().data(), static_cast(this->_internal_remotejid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ContextInfo.remoteJid"); - target = stream->WriteStringMaybeAliased( - 4, this->_internal_remotejid(), target); - } - - // repeated string mentionedJid = 15; - for (int i = 0, n = this->_internal_mentionedjid_size(); i < n; i++) { - const auto& s = this->_internal_mentionedjid(i); - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - s.data(), static_cast(s.length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ContextInfo.mentionedJid"); - target = stream->WriteString(15, s, target); - } - - // optional string conversionSource = 18; - if (cached_has_bits & 0x00000008u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_conversionsource().data(), static_cast(this->_internal_conversionsource().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ContextInfo.conversionSource"); - target = stream->WriteStringMaybeAliased( - 18, this->_internal_conversionsource(), target); - } - - // optional bytes conversionData = 19; - if (cached_has_bits & 0x00000010u) { - target = stream->WriteBytesMaybeAliased( - 19, this->_internal_conversiondata(), target); - } - - // optional uint32 conversionDelaySeconds = 20; - if (cached_has_bits & 0x00010000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(20, this->_internal_conversiondelayseconds(), target); - } - - // optional uint32 forwardingScore = 21; - if (cached_has_bits & 0x00020000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(21, this->_internal_forwardingscore(), target); - } - - // optional bool isForwarded = 22; - if (cached_has_bits & 0x00040000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(22, this->_internal_isforwarded(), target); - } - - // optional .proto.ContextInfo.AdReplyInfo quotedAd = 23; - if (cached_has_bits & 0x00000800u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(23, _Internal::quotedad(this), - _Internal::quotedad(this).GetCachedSize(), target, stream); - } - - // optional .proto.MessageKey placeholderKey = 24; - if (cached_has_bits & 0x00001000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(24, _Internal::placeholderkey(this), - _Internal::placeholderkey(this).GetCachedSize(), target, stream); - } - - // optional uint32 expiration = 25; - if (cached_has_bits & 0x00080000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(25, this->_internal_expiration(), target); - } - - // optional int64 ephemeralSettingTimestamp = 26; - if (cached_has_bits & 0x00100000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(26, this->_internal_ephemeralsettingtimestamp(), target); - } - - // optional bytes ephemeralSharedSecret = 27; - if (cached_has_bits & 0x00000020u) { - target = stream->WriteBytesMaybeAliased( - 27, this->_internal_ephemeralsharedsecret(), target); - } - - // optional .proto.ContextInfo.ExternalAdReplyInfo externalAdReply = 28; - if (cached_has_bits & 0x00002000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(28, _Internal::externaladreply(this), - _Internal::externaladreply(this).GetCachedSize(), target, stream); - } - - // optional string entryPointConversionSource = 29; - if (cached_has_bits & 0x00000040u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_entrypointconversionsource().data(), static_cast(this->_internal_entrypointconversionsource().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ContextInfo.entryPointConversionSource"); - target = stream->WriteStringMaybeAliased( - 29, this->_internal_entrypointconversionsource(), target); - } - - // optional string entryPointConversionApp = 30; - if (cached_has_bits & 0x00000080u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_entrypointconversionapp().data(), static_cast(this->_internal_entrypointconversionapp().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ContextInfo.entryPointConversionApp"); - target = stream->WriteStringMaybeAliased( - 30, this->_internal_entrypointconversionapp(), target); - } - - // optional uint32 entryPointConversionDelaySeconds = 31; - if (cached_has_bits & 0x00200000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(31, this->_internal_entrypointconversiondelayseconds(), target); - } - - // optional .proto.DisappearingMode disappearingMode = 32; - if (cached_has_bits & 0x00004000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(32, _Internal::disappearingmode(this), - _Internal::disappearingmode(this).GetCachedSize(), target, stream); - } - - // optional .proto.ActionLink actionLink = 33; - if (cached_has_bits & 0x00008000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(33, _Internal::actionlink(this), - _Internal::actionlink(this).GetCachedSize(), target, stream); - } - - // optional string groupSubject = 34; - if (cached_has_bits & 0x00000100u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_groupsubject().data(), static_cast(this->_internal_groupsubject().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ContextInfo.groupSubject"); - target = stream->WriteStringMaybeAliased( - 34, this->_internal_groupsubject(), target); - } - - // optional string parentGroupJid = 35; - if (cached_has_bits & 0x00000200u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_parentgroupjid().data(), static_cast(this->_internal_parentgroupjid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ContextInfo.parentGroupJid"); - target = stream->WriteStringMaybeAliased( - 35, this->_internal_parentgroupjid(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.ContextInfo) - return target; -} - -size_t ContextInfo::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.ContextInfo) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated string mentionedJid = 15; - total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.mentionedjid_.size()); - for (int i = 0, n = _impl_.mentionedjid_.size(); i < n; i++) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - _impl_.mentionedjid_.Get(i)); - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional string stanzaId = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_stanzaid()); - } - - // optional string participant = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_participant()); - } - - // optional string remoteJid = 4; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_remotejid()); - } - - // optional string conversionSource = 18; - if (cached_has_bits & 0x00000008u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_conversionsource()); - } - - // optional bytes conversionData = 19; - if (cached_has_bits & 0x00000010u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_conversiondata()); - } - - // optional bytes ephemeralSharedSecret = 27; - if (cached_has_bits & 0x00000020u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_ephemeralsharedsecret()); - } - - // optional string entryPointConversionSource = 29; - if (cached_has_bits & 0x00000040u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_entrypointconversionsource()); - } - - // optional string entryPointConversionApp = 30; - if (cached_has_bits & 0x00000080u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_entrypointconversionapp()); - } - - } - if (cached_has_bits & 0x0000ff00u) { - // optional string groupSubject = 34; - if (cached_has_bits & 0x00000100u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_groupsubject()); - } - - // optional string parentGroupJid = 35; - if (cached_has_bits & 0x00000200u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_parentgroupjid()); - } - - // optional .proto.Message quotedMessage = 3; - if (cached_has_bits & 0x00000400u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.quotedmessage_); - } - - // optional .proto.ContextInfo.AdReplyInfo quotedAd = 23; - if (cached_has_bits & 0x00000800u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.quotedad_); - } - - // optional .proto.MessageKey placeholderKey = 24; - if (cached_has_bits & 0x00001000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.placeholderkey_); - } - - // optional .proto.ContextInfo.ExternalAdReplyInfo externalAdReply = 28; - if (cached_has_bits & 0x00002000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.externaladreply_); - } - - // optional .proto.DisappearingMode disappearingMode = 32; - if (cached_has_bits & 0x00004000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.disappearingmode_); - } - - // optional .proto.ActionLink actionLink = 33; - if (cached_has_bits & 0x00008000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.actionlink_); - } - - } - if (cached_has_bits & 0x003f0000u) { - // optional uint32 conversionDelaySeconds = 20; - if (cached_has_bits & 0x00010000u) { - total_size += 2 + - ::_pbi::WireFormatLite::UInt32Size( - this->_internal_conversiondelayseconds()); - } - - // optional uint32 forwardingScore = 21; - if (cached_has_bits & 0x00020000u) { - total_size += 2 + - ::_pbi::WireFormatLite::UInt32Size( - this->_internal_forwardingscore()); - } - - // optional bool isForwarded = 22; - if (cached_has_bits & 0x00040000u) { - total_size += 2 + 1; - } - - // optional uint32 expiration = 25; - if (cached_has_bits & 0x00080000u) { - total_size += 2 + - ::_pbi::WireFormatLite::UInt32Size( - this->_internal_expiration()); - } - - // optional int64 ephemeralSettingTimestamp = 26; - if (cached_has_bits & 0x00100000u) { - total_size += 2 + - ::_pbi::WireFormatLite::Int64Size( - this->_internal_ephemeralsettingtimestamp()); - } - - // optional uint32 entryPointConversionDelaySeconds = 31; - if (cached_has_bits & 0x00200000u) { - total_size += 2 + - ::_pbi::WireFormatLite::UInt32Size( - this->_internal_entrypointconversiondelayseconds()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ContextInfo::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - ContextInfo::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ContextInfo::GetClassData() const { return &_class_data_; } - - -void ContextInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.ContextInfo) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.mentionedjid_.MergeFrom(from._impl_.mentionedjid_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_stanzaid(from._internal_stanzaid()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_participant(from._internal_participant()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_remotejid(from._internal_remotejid()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_set_conversionsource(from._internal_conversionsource()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_set_conversiondata(from._internal_conversiondata()); - } - if (cached_has_bits & 0x00000020u) { - _this->_internal_set_ephemeralsharedsecret(from._internal_ephemeralsharedsecret()); - } - if (cached_has_bits & 0x00000040u) { - _this->_internal_set_entrypointconversionsource(from._internal_entrypointconversionsource()); - } - if (cached_has_bits & 0x00000080u) { - _this->_internal_set_entrypointconversionapp(from._internal_entrypointconversionapp()); - } - } - if (cached_has_bits & 0x0000ff00u) { - if (cached_has_bits & 0x00000100u) { - _this->_internal_set_groupsubject(from._internal_groupsubject()); - } - if (cached_has_bits & 0x00000200u) { - _this->_internal_set_parentgroupjid(from._internal_parentgroupjid()); - } - if (cached_has_bits & 0x00000400u) { - _this->_internal_mutable_quotedmessage()->::proto::Message::MergeFrom( - from._internal_quotedmessage()); - } - if (cached_has_bits & 0x00000800u) { - _this->_internal_mutable_quotedad()->::proto::ContextInfo_AdReplyInfo::MergeFrom( - from._internal_quotedad()); - } - if (cached_has_bits & 0x00001000u) { - _this->_internal_mutable_placeholderkey()->::proto::MessageKey::MergeFrom( - from._internal_placeholderkey()); - } - if (cached_has_bits & 0x00002000u) { - _this->_internal_mutable_externaladreply()->::proto::ContextInfo_ExternalAdReplyInfo::MergeFrom( - from._internal_externaladreply()); - } - if (cached_has_bits & 0x00004000u) { - _this->_internal_mutable_disappearingmode()->::proto::DisappearingMode::MergeFrom( - from._internal_disappearingmode()); - } - if (cached_has_bits & 0x00008000u) { - _this->_internal_mutable_actionlink()->::proto::ActionLink::MergeFrom( - from._internal_actionlink()); - } - } - if (cached_has_bits & 0x003f0000u) { - if (cached_has_bits & 0x00010000u) { - _this->_impl_.conversiondelayseconds_ = from._impl_.conversiondelayseconds_; - } - if (cached_has_bits & 0x00020000u) { - _this->_impl_.forwardingscore_ = from._impl_.forwardingscore_; - } - if (cached_has_bits & 0x00040000u) { - _this->_impl_.isforwarded_ = from._impl_.isforwarded_; - } - if (cached_has_bits & 0x00080000u) { - _this->_impl_.expiration_ = from._impl_.expiration_; - } - if (cached_has_bits & 0x00100000u) { - _this->_impl_.ephemeralsettingtimestamp_ = from._impl_.ephemeralsettingtimestamp_; - } - if (cached_has_bits & 0x00200000u) { - _this->_impl_.entrypointconversiondelayseconds_ = from._impl_.entrypointconversiondelayseconds_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ContextInfo::CopyFrom(const ContextInfo& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.ContextInfo) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ContextInfo::IsInitialized() const { - return true; -} - -void ContextInfo::InternalSwap(ContextInfo* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.mentionedjid_.InternalSwap(&other->_impl_.mentionedjid_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.stanzaid_, lhs_arena, - &other->_impl_.stanzaid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.participant_, lhs_arena, - &other->_impl_.participant_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.remotejid_, lhs_arena, - &other->_impl_.remotejid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.conversionsource_, lhs_arena, - &other->_impl_.conversionsource_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.conversiondata_, lhs_arena, - &other->_impl_.conversiondata_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.ephemeralsharedsecret_, lhs_arena, - &other->_impl_.ephemeralsharedsecret_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.entrypointconversionsource_, lhs_arena, - &other->_impl_.entrypointconversionsource_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.entrypointconversionapp_, lhs_arena, - &other->_impl_.entrypointconversionapp_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.groupsubject_, lhs_arena, - &other->_impl_.groupsubject_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.parentgroupjid_, lhs_arena, - &other->_impl_.parentgroupjid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ContextInfo, _impl_.entrypointconversiondelayseconds_) - + sizeof(ContextInfo::_impl_.entrypointconversiondelayseconds_) - - PROTOBUF_FIELD_OFFSET(ContextInfo, _impl_.quotedmessage_)>( - reinterpret_cast(&_impl_.quotedmessage_), - reinterpret_cast(&other->_impl_.quotedmessage_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ContextInfo::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[24]); -} - -// =================================================================== - -class Conversation::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_id(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_newjid(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_oldjid(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_lastmsgtimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 16384u; - } - static void set_has_unreadcount(HasBits* has_bits) { - (*has_bits)[0] |= 32768u; - } - static void set_has_readonly(HasBits* has_bits) { - (*has_bits)[0] |= 524288u; - } - static void set_has_endofhistorytransfer(HasBits* has_bits) { - (*has_bits)[0] |= 1048576u; - } - static void set_has_ephemeralexpiration(HasBits* has_bits) { - (*has_bits)[0] |= 65536u; - } - static void set_has_ephemeralsettingtimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 131072u; - } - static void set_has_endofhistorytransfertype(HasBits* has_bits) { - (*has_bits)[0] |= 262144u; - } - static void set_has_conversationtimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 8388608u; - } - static void set_has_name(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_phash(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_notspam(HasBits* has_bits) { - (*has_bits)[0] |= 2097152u; - } - static void set_has_archived(HasBits* has_bits) { - (*has_bits)[0] |= 4194304u; - } - static const ::proto::DisappearingMode& disappearingmode(const Conversation* msg); - static void set_has_disappearingmode(HasBits* has_bits) { - (*has_bits)[0] |= 4096u; - } - static void set_has_unreadmentioncount(HasBits* has_bits) { - (*has_bits)[0] |= 16777216u; - } - static void set_has_markedasunread(HasBits* has_bits) { - (*has_bits)[0] |= 536870912u; - } - static void set_has_tctoken(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static void set_has_tctokentimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 67108864u; - } - static void set_has_contactprimaryidentitykey(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static void set_has_pinned(HasBits* has_bits) { - (*has_bits)[0] |= 33554432u; - } - static void set_has_muteendtime(HasBits* has_bits) { - (*has_bits)[0] |= 134217728u; - } - static const ::proto::WallpaperSettings& wallpaper(const Conversation* msg); - static void set_has_wallpaper(HasBits* has_bits) { - (*has_bits)[0] |= 8192u; - } - static void set_has_mediavisibility(HasBits* has_bits) { - (*has_bits)[0] |= 268435456u; - } - static void set_has_tctokensendertimestamp(HasBits* has_bits) { - (*has_bits)[1] |= 2u; - } - static void set_has_suspended(HasBits* has_bits) { - (*has_bits)[0] |= 1073741824u; - } - static void set_has_terminated(HasBits* has_bits) { - (*has_bits)[0] |= 2147483648u; - } - static void set_has_createdat(HasBits* has_bits) { - (*has_bits)[1] |= 4u; - } - static void set_has_createdby(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } - static void set_has_description(HasBits* has_bits) { - (*has_bits)[0] |= 256u; - } - static void set_has_support(HasBits* has_bits) { - (*has_bits)[1] |= 1u; - } - static void set_has_isparentgroup(HasBits* has_bits) { - (*has_bits)[1] |= 8u; - } - static void set_has_isdefaultsubgroup(HasBits* has_bits) { - (*has_bits)[1] |= 16u; - } - static void set_has_parentgroupid(HasBits* has_bits) { - (*has_bits)[0] |= 512u; - } - static void set_has_displayname(HasBits* has_bits) { - (*has_bits)[0] |= 1024u; - } - static void set_has_pnjid(HasBits* has_bits) { - (*has_bits)[0] |= 2048u; - } - static void set_has_selfpnexposed(HasBits* has_bits) { - (*has_bits)[1] |= 32u; - } - static bool MissingRequiredFields(const HasBits& has_bits) { - return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0; - } -}; - -const ::proto::DisappearingMode& -Conversation::_Internal::disappearingmode(const Conversation* msg) { - return *msg->_impl_.disappearingmode_; -} -const ::proto::WallpaperSettings& -Conversation::_Internal::wallpaper(const Conversation* msg) { - return *msg->_impl_.wallpaper_; -} -Conversation::Conversation(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Conversation) -} -Conversation::Conversation(const Conversation& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Conversation* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.messages_){from._impl_.messages_} - , decltype(_impl_.participant_){from._impl_.participant_} - , decltype(_impl_.id_){} - , decltype(_impl_.newjid_){} - , decltype(_impl_.oldjid_){} - , decltype(_impl_.name_){} - , decltype(_impl_.phash_){} - , decltype(_impl_.tctoken_){} - , decltype(_impl_.contactprimaryidentitykey_){} - , decltype(_impl_.createdby_){} - , decltype(_impl_.description_){} - , decltype(_impl_.parentgroupid_){} - , decltype(_impl_.displayname_){} - , decltype(_impl_.pnjid_){} - , decltype(_impl_.disappearingmode_){nullptr} - , decltype(_impl_.wallpaper_){nullptr} - , decltype(_impl_.lastmsgtimestamp_){} - , decltype(_impl_.unreadcount_){} - , decltype(_impl_.ephemeralexpiration_){} - , decltype(_impl_.ephemeralsettingtimestamp_){} - , decltype(_impl_.endofhistorytransfertype_){} - , decltype(_impl_.readonly_){} - , decltype(_impl_.endofhistorytransfer_){} - , decltype(_impl_.notspam_){} - , decltype(_impl_.archived_){} - , decltype(_impl_.conversationtimestamp_){} - , decltype(_impl_.unreadmentioncount_){} - , decltype(_impl_.pinned_){} - , decltype(_impl_.tctokentimestamp_){} - , decltype(_impl_.muteendtime_){} - , decltype(_impl_.mediavisibility_){} - , decltype(_impl_.markedasunread_){} - , decltype(_impl_.suspended_){} - , decltype(_impl_.terminated_){} - , decltype(_impl_.support_){} - , decltype(_impl_.tctokensendertimestamp_){} - , decltype(_impl_.createdat_){} - , decltype(_impl_.isparentgroup_){} - , decltype(_impl_.isdefaultsubgroup_){} - , decltype(_impl_.selfpnexposed_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.id_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.id_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_id()) { - _this->_impl_.id_.Set(from._internal_id(), - _this->GetArenaForAllocation()); - } - _impl_.newjid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.newjid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_newjid()) { - _this->_impl_.newjid_.Set(from._internal_newjid(), - _this->GetArenaForAllocation()); - } - _impl_.oldjid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.oldjid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_oldjid()) { - _this->_impl_.oldjid_.Set(from._internal_oldjid(), - _this->GetArenaForAllocation()); - } - _impl_.name_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.name_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_name()) { - _this->_impl_.name_.Set(from._internal_name(), - _this->GetArenaForAllocation()); - } - _impl_.phash_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.phash_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_phash()) { - _this->_impl_.phash_.Set(from._internal_phash(), - _this->GetArenaForAllocation()); - } - _impl_.tctoken_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.tctoken_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_tctoken()) { - _this->_impl_.tctoken_.Set(from._internal_tctoken(), - _this->GetArenaForAllocation()); - } - _impl_.contactprimaryidentitykey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.contactprimaryidentitykey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_contactprimaryidentitykey()) { - _this->_impl_.contactprimaryidentitykey_.Set(from._internal_contactprimaryidentitykey(), - _this->GetArenaForAllocation()); - } - _impl_.createdby_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.createdby_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_createdby()) { - _this->_impl_.createdby_.Set(from._internal_createdby(), - _this->GetArenaForAllocation()); - } - _impl_.description_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.description_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_description()) { - _this->_impl_.description_.Set(from._internal_description(), - _this->GetArenaForAllocation()); - } - _impl_.parentgroupid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.parentgroupid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_parentgroupid()) { - _this->_impl_.parentgroupid_.Set(from._internal_parentgroupid(), - _this->GetArenaForAllocation()); - } - _impl_.displayname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.displayname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_displayname()) { - _this->_impl_.displayname_.Set(from._internal_displayname(), - _this->GetArenaForAllocation()); - } - _impl_.pnjid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.pnjid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_pnjid()) { - _this->_impl_.pnjid_.Set(from._internal_pnjid(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_disappearingmode()) { - _this->_impl_.disappearingmode_ = new ::proto::DisappearingMode(*from._impl_.disappearingmode_); - } - if (from._internal_has_wallpaper()) { - _this->_impl_.wallpaper_ = new ::proto::WallpaperSettings(*from._impl_.wallpaper_); - } - ::memcpy(&_impl_.lastmsgtimestamp_, &from._impl_.lastmsgtimestamp_, - static_cast(reinterpret_cast(&_impl_.selfpnexposed_) - - reinterpret_cast(&_impl_.lastmsgtimestamp_)) + sizeof(_impl_.selfpnexposed_)); - // @@protoc_insertion_point(copy_constructor:proto.Conversation) -} - -inline void Conversation::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.messages_){arena} - , decltype(_impl_.participant_){arena} - , decltype(_impl_.id_){} - , decltype(_impl_.newjid_){} - , decltype(_impl_.oldjid_){} - , decltype(_impl_.name_){} - , decltype(_impl_.phash_){} - , decltype(_impl_.tctoken_){} - , decltype(_impl_.contactprimaryidentitykey_){} - , decltype(_impl_.createdby_){} - , decltype(_impl_.description_){} - , decltype(_impl_.parentgroupid_){} - , decltype(_impl_.displayname_){} - , decltype(_impl_.pnjid_){} - , decltype(_impl_.disappearingmode_){nullptr} - , decltype(_impl_.wallpaper_){nullptr} - , decltype(_impl_.lastmsgtimestamp_){uint64_t{0u}} - , decltype(_impl_.unreadcount_){0u} - , decltype(_impl_.ephemeralexpiration_){0u} - , decltype(_impl_.ephemeralsettingtimestamp_){int64_t{0}} - , decltype(_impl_.endofhistorytransfertype_){0} - , decltype(_impl_.readonly_){false} - , decltype(_impl_.endofhistorytransfer_){false} - , decltype(_impl_.notspam_){false} - , decltype(_impl_.archived_){false} - , decltype(_impl_.conversationtimestamp_){uint64_t{0u}} - , decltype(_impl_.unreadmentioncount_){0u} - , decltype(_impl_.pinned_){0u} - , decltype(_impl_.tctokentimestamp_){uint64_t{0u}} - , decltype(_impl_.muteendtime_){uint64_t{0u}} - , decltype(_impl_.mediavisibility_){0} - , decltype(_impl_.markedasunread_){false} - , decltype(_impl_.suspended_){false} - , decltype(_impl_.terminated_){false} - , decltype(_impl_.support_){false} - , decltype(_impl_.tctokensendertimestamp_){uint64_t{0u}} - , decltype(_impl_.createdat_){uint64_t{0u}} - , decltype(_impl_.isparentgroup_){false} - , decltype(_impl_.isdefaultsubgroup_){false} - , decltype(_impl_.selfpnexposed_){false} - }; - _impl_.id_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.id_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.newjid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.newjid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.oldjid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.oldjid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.name_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.name_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.phash_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.phash_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.tctoken_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.tctoken_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.contactprimaryidentitykey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.contactprimaryidentitykey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.createdby_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.createdby_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.description_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.description_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.parentgroupid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.parentgroupid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.displayname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.displayname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.pnjid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.pnjid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Conversation::~Conversation() { - // @@protoc_insertion_point(destructor:proto.Conversation) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Conversation::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.messages_.~RepeatedPtrField(); - _impl_.participant_.~RepeatedPtrField(); - _impl_.id_.Destroy(); - _impl_.newjid_.Destroy(); - _impl_.oldjid_.Destroy(); - _impl_.name_.Destroy(); - _impl_.phash_.Destroy(); - _impl_.tctoken_.Destroy(); - _impl_.contactprimaryidentitykey_.Destroy(); - _impl_.createdby_.Destroy(); - _impl_.description_.Destroy(); - _impl_.parentgroupid_.Destroy(); - _impl_.displayname_.Destroy(); - _impl_.pnjid_.Destroy(); - if (this != internal_default_instance()) delete _impl_.disappearingmode_; - if (this != internal_default_instance()) delete _impl_.wallpaper_; -} - -void Conversation::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Conversation::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Conversation) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.messages_.Clear(); - _impl_.participant_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _impl_.id_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.newjid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.oldjid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000008u) { - _impl_.name_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000010u) { - _impl_.phash_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000020u) { - _impl_.tctoken_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000040u) { - _impl_.contactprimaryidentitykey_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000080u) { - _impl_.createdby_.ClearNonDefaultToEmpty(); - } - } - if (cached_has_bits & 0x00003f00u) { - if (cached_has_bits & 0x00000100u) { - _impl_.description_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000200u) { - _impl_.parentgroupid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000400u) { - _impl_.displayname_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000800u) { - _impl_.pnjid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00001000u) { - GOOGLE_DCHECK(_impl_.disappearingmode_ != nullptr); - _impl_.disappearingmode_->Clear(); - } - if (cached_has_bits & 0x00002000u) { - GOOGLE_DCHECK(_impl_.wallpaper_ != nullptr); - _impl_.wallpaper_->Clear(); - } - } - if (cached_has_bits & 0x0000c000u) { - ::memset(&_impl_.lastmsgtimestamp_, 0, static_cast( - reinterpret_cast(&_impl_.unreadcount_) - - reinterpret_cast(&_impl_.lastmsgtimestamp_)) + sizeof(_impl_.unreadcount_)); - } - if (cached_has_bits & 0x00ff0000u) { - ::memset(&_impl_.ephemeralexpiration_, 0, static_cast( - reinterpret_cast(&_impl_.conversationtimestamp_) - - reinterpret_cast(&_impl_.ephemeralexpiration_)) + sizeof(_impl_.conversationtimestamp_)); - } - if (cached_has_bits & 0xff000000u) { - ::memset(&_impl_.unreadmentioncount_, 0, static_cast( - reinterpret_cast(&_impl_.terminated_) - - reinterpret_cast(&_impl_.unreadmentioncount_)) + sizeof(_impl_.terminated_)); - } - cached_has_bits = _impl_._has_bits_[1]; - if (cached_has_bits & 0x0000003fu) { - ::memset(&_impl_.support_, 0, static_cast( - reinterpret_cast(&_impl_.selfpnexposed_) - - reinterpret_cast(&_impl_.support_)) + sizeof(_impl_.selfpnexposed_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Conversation::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // required string id = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_id(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Conversation.id"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // repeated .proto.HistorySyncMsg messages = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_messages(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else - goto handle_unusual; - continue; - // optional string newJid = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_newjid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Conversation.newJid"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string oldJid = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - auto str = _internal_mutable_oldjid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Conversation.oldJid"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional uint64 lastMsgTimestamp = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { - _Internal::set_has_lastmsgtimestamp(&_impl_._has_bits_); - _impl_.lastmsgtimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 unreadCount = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { - _Internal::set_has_unreadcount(&_impl_._has_bits_); - _impl_.unreadcount_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool readOnly = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { - _Internal::set_has_readonly(&_impl_._has_bits_); - _impl_.readonly_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool endOfHistoryTransfer = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { - _Internal::set_has_endofhistorytransfer(&_impl_._has_bits_); - _impl_.endofhistorytransfer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 ephemeralExpiration = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { - _Internal::set_has_ephemeralexpiration(&_impl_._has_bits_); - _impl_.ephemeralexpiration_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional int64 ephemeralSettingTimestamp = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { - _Internal::set_has_ephemeralsettingtimestamp(&_impl_._has_bits_); - _impl_.ephemeralsettingtimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Conversation.EndOfHistoryTransferType endOfHistoryTransferType = 11; - case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::Conversation_EndOfHistoryTransferType_IsValid(val))) { - _internal_set_endofhistorytransfertype(static_cast<::proto::Conversation_EndOfHistoryTransferType>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(11, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional uint64 conversationTimestamp = 12; - case 12: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { - _Internal::set_has_conversationtimestamp(&_impl_._has_bits_); - _impl_.conversationtimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string name = 13; - case 13: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { - auto str = _internal_mutable_name(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Conversation.name"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string pHash = 14; - case 14: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) { - auto str = _internal_mutable_phash(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Conversation.pHash"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bool notSpam = 15; - case 15: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 120)) { - _Internal::set_has_notspam(&_impl_._has_bits_); - _impl_.notspam_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool archived = 16; - case 16: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 128)) { - _Internal::set_has_archived(&_impl_._has_bits_); - _impl_.archived_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.DisappearingMode disappearingMode = 17; - case 17: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { - ptr = ctx->ParseMessage(_internal_mutable_disappearingmode(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 unreadMentionCount = 18; - case 18: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 144)) { - _Internal::set_has_unreadmentioncount(&_impl_._has_bits_); - _impl_.unreadmentioncount_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool markedAsUnread = 19; - case 19: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 152)) { - _Internal::set_has_markedasunread(&_impl_._has_bits_); - _impl_.markedasunread_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated .proto.GroupParticipant participant = 20; - case 20: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 162)) { - ptr -= 2; - do { - ptr += 2; - ptr = ctx->ParseMessage(_internal_add_participant(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<162>(ptr)); - } else - goto handle_unusual; - continue; - // optional bytes tcToken = 21; - case 21: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { - auto str = _internal_mutable_tctoken(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint64 tcTokenTimestamp = 22; - case 22: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 176)) { - _Internal::set_has_tctokentimestamp(&_impl_._has_bits_); - _impl_.tctokentimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes contactPrimaryIdentityKey = 23; - case 23: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { - auto str = _internal_mutable_contactprimaryidentitykey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 pinned = 24; - case 24: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 192)) { - _Internal::set_has_pinned(&_impl_._has_bits_); - _impl_.pinned_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint64 muteEndTime = 25; - case 25: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 200)) { - _Internal::set_has_muteendtime(&_impl_._has_bits_); - _impl_.muteendtime_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.WallpaperSettings wallpaper = 26; - case 26: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 210)) { - ptr = ctx->ParseMessage(_internal_mutable_wallpaper(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.MediaVisibility mediaVisibility = 27; - case 27: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 216)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::MediaVisibility_IsValid(val))) { - _internal_set_mediavisibility(static_cast<::proto::MediaVisibility>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(27, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional uint64 tcTokenSenderTimestamp = 28; - case 28: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 224)) { - _Internal::set_has_tctokensendertimestamp(&_impl_._has_bits_); - _impl_.tctokensendertimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool suspended = 29; - case 29: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 232)) { - _Internal::set_has_suspended(&_impl_._has_bits_); - _impl_.suspended_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool terminated = 30; - case 30: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 240)) { - _Internal::set_has_terminated(&_impl_._has_bits_); - _impl_.terminated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint64 createdAt = 31; - case 31: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 248)) { - _Internal::set_has_createdat(&_impl_._has_bits_); - _impl_.createdat_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string createdBy = 32; - case 32: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 2)) { - auto str = _internal_mutable_createdby(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Conversation.createdBy"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string description = 33; - case 33: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_description(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Conversation.description"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bool support = 34; - case 34: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_support(&_impl_._has_bits_); - _impl_.support_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool isParentGroup = 35; - case 35: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_isparentgroup(&_impl_._has_bits_); - _impl_.isparentgroup_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool isDefaultSubgroup = 36; - case 36: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - _Internal::set_has_isdefaultsubgroup(&_impl_._has_bits_); - _impl_.isdefaultsubgroup_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string parentGroupId = 37; - case 37: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - auto str = _internal_mutable_parentgroupid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Conversation.parentGroupId"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string displayName = 38; - case 38: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - auto str = _internal_mutable_displayname(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Conversation.displayName"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string pnJid = 39; - case 39: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - auto str = _internal_mutable_pnjid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Conversation.pnJid"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bool selfPnExposed = 40; - case 40: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { - _Internal::set_has_selfpnexposed(&_impl_._has_bits_); - _impl_.selfpnexposed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Conversation::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Conversation) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // required string id = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_id().data(), static_cast(this->_internal_id().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Conversation.id"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_id(), target); - } - - // repeated .proto.HistorySyncMsg messages = 2; - for (unsigned i = 0, - n = static_cast(this->_internal_messages_size()); i < n; i++) { - const auto& repfield = this->_internal_messages(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream); - } - - // optional string newJid = 3; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_newjid().data(), static_cast(this->_internal_newjid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Conversation.newJid"); - target = stream->WriteStringMaybeAliased( - 3, this->_internal_newjid(), target); - } - - // optional string oldJid = 4; - if (cached_has_bits & 0x00000004u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_oldjid().data(), static_cast(this->_internal_oldjid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Conversation.oldJid"); - target = stream->WriteStringMaybeAliased( - 4, this->_internal_oldjid(), target); - } - - // optional uint64 lastMsgTimestamp = 5; - if (cached_has_bits & 0x00004000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_lastmsgtimestamp(), target); - } - - // optional uint32 unreadCount = 6; - if (cached_has_bits & 0x00008000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_unreadcount(), target); - } - - // optional bool readOnly = 7; - if (cached_has_bits & 0x00080000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(7, this->_internal_readonly(), target); - } - - // optional bool endOfHistoryTransfer = 8; - if (cached_has_bits & 0x00100000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(8, this->_internal_endofhistorytransfer(), target); - } - - // optional uint32 ephemeralExpiration = 9; - if (cached_has_bits & 0x00010000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(9, this->_internal_ephemeralexpiration(), target); - } - - // optional int64 ephemeralSettingTimestamp = 10; - if (cached_has_bits & 0x00020000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(10, this->_internal_ephemeralsettingtimestamp(), target); - } - - // optional .proto.Conversation.EndOfHistoryTransferType endOfHistoryTransferType = 11; - if (cached_has_bits & 0x00040000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 11, this->_internal_endofhistorytransfertype(), target); - } - - // optional uint64 conversationTimestamp = 12; - if (cached_has_bits & 0x00800000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(12, this->_internal_conversationtimestamp(), target); - } - - // optional string name = 13; - if (cached_has_bits & 0x00000008u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_name().data(), static_cast(this->_internal_name().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Conversation.name"); - target = stream->WriteStringMaybeAliased( - 13, this->_internal_name(), target); - } - - // optional string pHash = 14; - if (cached_has_bits & 0x00000010u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_phash().data(), static_cast(this->_internal_phash().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Conversation.pHash"); - target = stream->WriteStringMaybeAliased( - 14, this->_internal_phash(), target); - } - - // optional bool notSpam = 15; - if (cached_has_bits & 0x00200000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(15, this->_internal_notspam(), target); - } - - // optional bool archived = 16; - if (cached_has_bits & 0x00400000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(16, this->_internal_archived(), target); - } - - // optional .proto.DisappearingMode disappearingMode = 17; - if (cached_has_bits & 0x00001000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(17, _Internal::disappearingmode(this), - _Internal::disappearingmode(this).GetCachedSize(), target, stream); - } - - // optional uint32 unreadMentionCount = 18; - if (cached_has_bits & 0x01000000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(18, this->_internal_unreadmentioncount(), target); - } - - // optional bool markedAsUnread = 19; - if (cached_has_bits & 0x20000000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(19, this->_internal_markedasunread(), target); - } - - // repeated .proto.GroupParticipant participant = 20; - for (unsigned i = 0, - n = static_cast(this->_internal_participant_size()); i < n; i++) { - const auto& repfield = this->_internal_participant(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(20, repfield, repfield.GetCachedSize(), target, stream); - } - - // optional bytes tcToken = 21; - if (cached_has_bits & 0x00000020u) { - target = stream->WriteBytesMaybeAliased( - 21, this->_internal_tctoken(), target); - } - - // optional uint64 tcTokenTimestamp = 22; - if (cached_has_bits & 0x04000000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(22, this->_internal_tctokentimestamp(), target); - } - - // optional bytes contactPrimaryIdentityKey = 23; - if (cached_has_bits & 0x00000040u) { - target = stream->WriteBytesMaybeAliased( - 23, this->_internal_contactprimaryidentitykey(), target); - } - - // optional uint32 pinned = 24; - if (cached_has_bits & 0x02000000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(24, this->_internal_pinned(), target); - } - - // optional uint64 muteEndTime = 25; - if (cached_has_bits & 0x08000000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(25, this->_internal_muteendtime(), target); - } - - // optional .proto.WallpaperSettings wallpaper = 26; - if (cached_has_bits & 0x00002000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(26, _Internal::wallpaper(this), - _Internal::wallpaper(this).GetCachedSize(), target, stream); - } - - // optional .proto.MediaVisibility mediaVisibility = 27; - if (cached_has_bits & 0x10000000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 27, this->_internal_mediavisibility(), target); - } - - cached_has_bits = _impl_._has_bits_[1]; - // optional uint64 tcTokenSenderTimestamp = 28; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(28, this->_internal_tctokensendertimestamp(), target); - } - - cached_has_bits = _impl_._has_bits_[0]; - // optional bool suspended = 29; - if (cached_has_bits & 0x40000000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(29, this->_internal_suspended(), target); - } - - // optional bool terminated = 30; - if (cached_has_bits & 0x80000000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(30, this->_internal_terminated(), target); - } - - cached_has_bits = _impl_._has_bits_[1]; - // optional uint64 createdAt = 31; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(31, this->_internal_createdat(), target); - } - - cached_has_bits = _impl_._has_bits_[0]; - // optional string createdBy = 32; - if (cached_has_bits & 0x00000080u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_createdby().data(), static_cast(this->_internal_createdby().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Conversation.createdBy"); - target = stream->WriteStringMaybeAliased( - 32, this->_internal_createdby(), target); - } - - // optional string description = 33; - if (cached_has_bits & 0x00000100u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_description().data(), static_cast(this->_internal_description().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Conversation.description"); - target = stream->WriteStringMaybeAliased( - 33, this->_internal_description(), target); - } - - cached_has_bits = _impl_._has_bits_[1]; - // optional bool support = 34; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(34, this->_internal_support(), target); - } - - // optional bool isParentGroup = 35; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(35, this->_internal_isparentgroup(), target); - } - - // optional bool isDefaultSubgroup = 36; - if (cached_has_bits & 0x00000010u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(36, this->_internal_isdefaultsubgroup(), target); - } - - cached_has_bits = _impl_._has_bits_[0]; - // optional string parentGroupId = 37; - if (cached_has_bits & 0x00000200u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_parentgroupid().data(), static_cast(this->_internal_parentgroupid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Conversation.parentGroupId"); - target = stream->WriteStringMaybeAliased( - 37, this->_internal_parentgroupid(), target); - } - - // optional string displayName = 38; - if (cached_has_bits & 0x00000400u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_displayname().data(), static_cast(this->_internal_displayname().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Conversation.displayName"); - target = stream->WriteStringMaybeAliased( - 38, this->_internal_displayname(), target); - } - - // optional string pnJid = 39; - if (cached_has_bits & 0x00000800u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_pnjid().data(), static_cast(this->_internal_pnjid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Conversation.pnJid"); - target = stream->WriteStringMaybeAliased( - 39, this->_internal_pnjid(), target); - } - - cached_has_bits = _impl_._has_bits_[1]; - // optional bool selfPnExposed = 40; - if (cached_has_bits & 0x00000020u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(40, this->_internal_selfpnexposed(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Conversation) - return target; -} - -size_t Conversation::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Conversation) - size_t total_size = 0; - - // required string id = 1; - if (_internal_has_id()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_id()); - } - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.HistorySyncMsg messages = 2; - total_size += 1UL * this->_internal_messages_size(); - for (const auto& msg : this->_impl_.messages_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // repeated .proto.GroupParticipant participant = 20; - total_size += 2UL * this->_internal_participant_size(); - for (const auto& msg : this->_impl_.participant_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000feu) { - // optional string newJid = 3; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_newjid()); - } - - // optional string oldJid = 4; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_oldjid()); - } - - // optional string name = 13; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_name()); - } - - // optional string pHash = 14; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_phash()); - } - - // optional bytes tcToken = 21; - if (cached_has_bits & 0x00000020u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_tctoken()); - } - - // optional bytes contactPrimaryIdentityKey = 23; - if (cached_has_bits & 0x00000040u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_contactprimaryidentitykey()); - } - - // optional string createdBy = 32; - if (cached_has_bits & 0x00000080u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_createdby()); - } - - } - if (cached_has_bits & 0x0000ff00u) { - // optional string description = 33; - if (cached_has_bits & 0x00000100u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_description()); - } - - // optional string parentGroupId = 37; - if (cached_has_bits & 0x00000200u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_parentgroupid()); - } - - // optional string displayName = 38; - if (cached_has_bits & 0x00000400u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_displayname()); - } - - // optional string pnJid = 39; - if (cached_has_bits & 0x00000800u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_pnjid()); - } - - // optional .proto.DisappearingMode disappearingMode = 17; - if (cached_has_bits & 0x00001000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.disappearingmode_); - } - - // optional .proto.WallpaperSettings wallpaper = 26; - if (cached_has_bits & 0x00002000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.wallpaper_); - } - - // optional uint64 lastMsgTimestamp = 5; - if (cached_has_bits & 0x00004000u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_lastmsgtimestamp()); - } - - // optional uint32 unreadCount = 6; - if (cached_has_bits & 0x00008000u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_unreadcount()); - } - - } - if (cached_has_bits & 0x00ff0000u) { - // optional uint32 ephemeralExpiration = 9; - if (cached_has_bits & 0x00010000u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_ephemeralexpiration()); - } - - // optional int64 ephemeralSettingTimestamp = 10; - if (cached_has_bits & 0x00020000u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_ephemeralsettingtimestamp()); - } - - // optional .proto.Conversation.EndOfHistoryTransferType endOfHistoryTransferType = 11; - if (cached_has_bits & 0x00040000u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_endofhistorytransfertype()); - } - - // optional bool readOnly = 7; - if (cached_has_bits & 0x00080000u) { - total_size += 1 + 1; - } - - // optional bool endOfHistoryTransfer = 8; - if (cached_has_bits & 0x00100000u) { - total_size += 1 + 1; - } - - // optional bool notSpam = 15; - if (cached_has_bits & 0x00200000u) { - total_size += 1 + 1; - } - - // optional bool archived = 16; - if (cached_has_bits & 0x00400000u) { - total_size += 2 + 1; - } - - // optional uint64 conversationTimestamp = 12; - if (cached_has_bits & 0x00800000u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_conversationtimestamp()); - } - - } - if (cached_has_bits & 0xff000000u) { - // optional uint32 unreadMentionCount = 18; - if (cached_has_bits & 0x01000000u) { - total_size += 2 + - ::_pbi::WireFormatLite::UInt32Size( - this->_internal_unreadmentioncount()); - } - - // optional uint32 pinned = 24; - if (cached_has_bits & 0x02000000u) { - total_size += 2 + - ::_pbi::WireFormatLite::UInt32Size( - this->_internal_pinned()); - } - - // optional uint64 tcTokenTimestamp = 22; - if (cached_has_bits & 0x04000000u) { - total_size += 2 + - ::_pbi::WireFormatLite::UInt64Size( - this->_internal_tctokentimestamp()); - } - - // optional uint64 muteEndTime = 25; - if (cached_has_bits & 0x08000000u) { - total_size += 2 + - ::_pbi::WireFormatLite::UInt64Size( - this->_internal_muteendtime()); - } - - // optional .proto.MediaVisibility mediaVisibility = 27; - if (cached_has_bits & 0x10000000u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_mediavisibility()); - } - - // optional bool markedAsUnread = 19; - if (cached_has_bits & 0x20000000u) { - total_size += 2 + 1; - } - - // optional bool suspended = 29; - if (cached_has_bits & 0x40000000u) { - total_size += 2 + 1; - } - - // optional bool terminated = 30; - if (cached_has_bits & 0x80000000u) { - total_size += 2 + 1; - } - - } - cached_has_bits = _impl_._has_bits_[1]; - if (cached_has_bits & 0x0000003fu) { - // optional bool support = 34; - if (cached_has_bits & 0x00000001u) { - total_size += 2 + 1; - } - - // optional uint64 tcTokenSenderTimestamp = 28; - if (cached_has_bits & 0x00000002u) { - total_size += 2 + - ::_pbi::WireFormatLite::UInt64Size( - this->_internal_tctokensendertimestamp()); - } - - // optional uint64 createdAt = 31; - if (cached_has_bits & 0x00000004u) { - total_size += 2 + - ::_pbi::WireFormatLite::UInt64Size( - this->_internal_createdat()); - } - - // optional bool isParentGroup = 35; - if (cached_has_bits & 0x00000008u) { - total_size += 2 + 1; - } - - // optional bool isDefaultSubgroup = 36; - if (cached_has_bits & 0x00000010u) { - total_size += 2 + 1; - } - - // optional bool selfPnExposed = 40; - if (cached_has_bits & 0x00000020u) { - total_size += 2 + 1; - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Conversation::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Conversation::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Conversation::GetClassData() const { return &_class_data_; } - - -void Conversation::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Conversation) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.messages_.MergeFrom(from._impl_.messages_); - _this->_impl_.participant_.MergeFrom(from._impl_.participant_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_id(from._internal_id()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_newjid(from._internal_newjid()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_oldjid(from._internal_oldjid()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_set_name(from._internal_name()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_set_phash(from._internal_phash()); - } - if (cached_has_bits & 0x00000020u) { - _this->_internal_set_tctoken(from._internal_tctoken()); - } - if (cached_has_bits & 0x00000040u) { - _this->_internal_set_contactprimaryidentitykey(from._internal_contactprimaryidentitykey()); - } - if (cached_has_bits & 0x00000080u) { - _this->_internal_set_createdby(from._internal_createdby()); - } - } - if (cached_has_bits & 0x0000ff00u) { - if (cached_has_bits & 0x00000100u) { - _this->_internal_set_description(from._internal_description()); - } - if (cached_has_bits & 0x00000200u) { - _this->_internal_set_parentgroupid(from._internal_parentgroupid()); - } - if (cached_has_bits & 0x00000400u) { - _this->_internal_set_displayname(from._internal_displayname()); - } - if (cached_has_bits & 0x00000800u) { - _this->_internal_set_pnjid(from._internal_pnjid()); - } - if (cached_has_bits & 0x00001000u) { - _this->_internal_mutable_disappearingmode()->::proto::DisappearingMode::MergeFrom( - from._internal_disappearingmode()); - } - if (cached_has_bits & 0x00002000u) { - _this->_internal_mutable_wallpaper()->::proto::WallpaperSettings::MergeFrom( - from._internal_wallpaper()); - } - if (cached_has_bits & 0x00004000u) { - _this->_impl_.lastmsgtimestamp_ = from._impl_.lastmsgtimestamp_; - } - if (cached_has_bits & 0x00008000u) { - _this->_impl_.unreadcount_ = from._impl_.unreadcount_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - if (cached_has_bits & 0x00ff0000u) { - if (cached_has_bits & 0x00010000u) { - _this->_impl_.ephemeralexpiration_ = from._impl_.ephemeralexpiration_; - } - if (cached_has_bits & 0x00020000u) { - _this->_impl_.ephemeralsettingtimestamp_ = from._impl_.ephemeralsettingtimestamp_; - } - if (cached_has_bits & 0x00040000u) { - _this->_impl_.endofhistorytransfertype_ = from._impl_.endofhistorytransfertype_; - } - if (cached_has_bits & 0x00080000u) { - _this->_impl_.readonly_ = from._impl_.readonly_; - } - if (cached_has_bits & 0x00100000u) { - _this->_impl_.endofhistorytransfer_ = from._impl_.endofhistorytransfer_; - } - if (cached_has_bits & 0x00200000u) { - _this->_impl_.notspam_ = from._impl_.notspam_; - } - if (cached_has_bits & 0x00400000u) { - _this->_impl_.archived_ = from._impl_.archived_; - } - if (cached_has_bits & 0x00800000u) { - _this->_impl_.conversationtimestamp_ = from._impl_.conversationtimestamp_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - if (cached_has_bits & 0xff000000u) { - if (cached_has_bits & 0x01000000u) { - _this->_impl_.unreadmentioncount_ = from._impl_.unreadmentioncount_; - } - if (cached_has_bits & 0x02000000u) { - _this->_impl_.pinned_ = from._impl_.pinned_; - } - if (cached_has_bits & 0x04000000u) { - _this->_impl_.tctokentimestamp_ = from._impl_.tctokentimestamp_; - } - if (cached_has_bits & 0x08000000u) { - _this->_impl_.muteendtime_ = from._impl_.muteendtime_; - } - if (cached_has_bits & 0x10000000u) { - _this->_impl_.mediavisibility_ = from._impl_.mediavisibility_; - } - if (cached_has_bits & 0x20000000u) { - _this->_impl_.markedasunread_ = from._impl_.markedasunread_; - } - if (cached_has_bits & 0x40000000u) { - _this->_impl_.suspended_ = from._impl_.suspended_; - } - if (cached_has_bits & 0x80000000u) { - _this->_impl_.terminated_ = from._impl_.terminated_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - cached_has_bits = from._impl_._has_bits_[1]; - if (cached_has_bits & 0x0000003fu) { - if (cached_has_bits & 0x00000001u) { - _this->_impl_.support_ = from._impl_.support_; - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.tctokensendertimestamp_ = from._impl_.tctokensendertimestamp_; - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.createdat_ = from._impl_.createdat_; - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.isparentgroup_ = from._impl_.isparentgroup_; - } - if (cached_has_bits & 0x00000010u) { - _this->_impl_.isdefaultsubgroup_ = from._impl_.isdefaultsubgroup_; - } - if (cached_has_bits & 0x00000020u) { - _this->_impl_.selfpnexposed_ = from._impl_.selfpnexposed_; - } - _this->_impl_._has_bits_[1] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Conversation::CopyFrom(const Conversation& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Conversation) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Conversation::IsInitialized() const { - if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false; - if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.messages_)) - return false; - if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.participant_)) - return false; - return true; -} - -void Conversation::InternalSwap(Conversation* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - swap(_impl_._has_bits_[1], other->_impl_._has_bits_[1]); - _impl_.messages_.InternalSwap(&other->_impl_.messages_); - _impl_.participant_.InternalSwap(&other->_impl_.participant_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.id_, lhs_arena, - &other->_impl_.id_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.newjid_, lhs_arena, - &other->_impl_.newjid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.oldjid_, lhs_arena, - &other->_impl_.oldjid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.name_, lhs_arena, - &other->_impl_.name_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.phash_, lhs_arena, - &other->_impl_.phash_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.tctoken_, lhs_arena, - &other->_impl_.tctoken_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.contactprimaryidentitykey_, lhs_arena, - &other->_impl_.contactprimaryidentitykey_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.createdby_, lhs_arena, - &other->_impl_.createdby_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.description_, lhs_arena, - &other->_impl_.description_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.parentgroupid_, lhs_arena, - &other->_impl_.parentgroupid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.displayname_, lhs_arena, - &other->_impl_.displayname_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.pnjid_, lhs_arena, - &other->_impl_.pnjid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Conversation, _impl_.selfpnexposed_) - + sizeof(Conversation::_impl_.selfpnexposed_) - - PROTOBUF_FIELD_OFFSET(Conversation, _impl_.disappearingmode_)>( - reinterpret_cast(&_impl_.disappearingmode_), - reinterpret_cast(&other->_impl_.disappearingmode_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Conversation::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[25]); -} - -// =================================================================== - -class DeviceListMetadata::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_senderkeyhash(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_sendertimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_recipientkeyhash(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_recipienttimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } -}; - -DeviceListMetadata::DeviceListMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.DeviceListMetadata) -} -DeviceListMetadata::DeviceListMetadata(const DeviceListMetadata& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - DeviceListMetadata* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.senderkeyindexes_){from._impl_.senderkeyindexes_} - , /*decltype(_impl_._senderkeyindexes_cached_byte_size_)*/{0} - , decltype(_impl_.recipientkeyindexes_){from._impl_.recipientkeyindexes_} - , /*decltype(_impl_._recipientkeyindexes_cached_byte_size_)*/{0} - , decltype(_impl_.senderkeyhash_){} - , decltype(_impl_.recipientkeyhash_){} - , decltype(_impl_.sendertimestamp_){} - , decltype(_impl_.recipienttimestamp_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.senderkeyhash_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.senderkeyhash_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_senderkeyhash()) { - _this->_impl_.senderkeyhash_.Set(from._internal_senderkeyhash(), - _this->GetArenaForAllocation()); - } - _impl_.recipientkeyhash_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.recipientkeyhash_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_recipientkeyhash()) { - _this->_impl_.recipientkeyhash_.Set(from._internal_recipientkeyhash(), - _this->GetArenaForAllocation()); - } - ::memcpy(&_impl_.sendertimestamp_, &from._impl_.sendertimestamp_, - static_cast(reinterpret_cast(&_impl_.recipienttimestamp_) - - reinterpret_cast(&_impl_.sendertimestamp_)) + sizeof(_impl_.recipienttimestamp_)); - // @@protoc_insertion_point(copy_constructor:proto.DeviceListMetadata) -} - -inline void DeviceListMetadata::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.senderkeyindexes_){arena} - , /*decltype(_impl_._senderkeyindexes_cached_byte_size_)*/{0} - , decltype(_impl_.recipientkeyindexes_){arena} - , /*decltype(_impl_._recipientkeyindexes_cached_byte_size_)*/{0} - , decltype(_impl_.senderkeyhash_){} - , decltype(_impl_.recipientkeyhash_){} - , decltype(_impl_.sendertimestamp_){uint64_t{0u}} - , decltype(_impl_.recipienttimestamp_){uint64_t{0u}} - }; - _impl_.senderkeyhash_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.senderkeyhash_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.recipientkeyhash_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.recipientkeyhash_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -DeviceListMetadata::~DeviceListMetadata() { - // @@protoc_insertion_point(destructor:proto.DeviceListMetadata) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void DeviceListMetadata::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.senderkeyindexes_.~RepeatedField(); - _impl_.recipientkeyindexes_.~RepeatedField(); - _impl_.senderkeyhash_.Destroy(); - _impl_.recipientkeyhash_.Destroy(); -} - -void DeviceListMetadata::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void DeviceListMetadata::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.DeviceListMetadata) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.senderkeyindexes_.Clear(); - _impl_.recipientkeyindexes_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.senderkeyhash_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.recipientkeyhash_.ClearNonDefaultToEmpty(); - } - } - if (cached_has_bits & 0x0000000cu) { - ::memset(&_impl_.sendertimestamp_, 0, static_cast( - reinterpret_cast(&_impl_.recipienttimestamp_) - - reinterpret_cast(&_impl_.sendertimestamp_)) + sizeof(_impl_.recipienttimestamp_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* DeviceListMetadata::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bytes senderKeyHash = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_senderkeyhash(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint64 senderTimestamp = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_sendertimestamp(&has_bits); - _impl_.sendertimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated uint32 senderKeyIndexes = 3 [packed = true]; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_senderkeyindexes(), ptr, ctx); - CHK_(ptr); - } else if (static_cast(tag) == 24) { - _internal_add_senderkeyindexes(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes recipientKeyHash = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { - auto str = _internal_mutable_recipientkeyhash(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint64 recipientTimestamp = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { - _Internal::set_has_recipienttimestamp(&has_bits); - _impl_.recipienttimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated uint32 recipientKeyIndexes = 10 [packed = true]; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_recipientkeyindexes(), ptr, ctx); - CHK_(ptr); - } else if (static_cast(tag) == 80) { - _internal_add_recipientkeyindexes(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* DeviceListMetadata::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.DeviceListMetadata) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bytes senderKeyHash = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 1, this->_internal_senderkeyhash(), target); - } - - // optional uint64 senderTimestamp = 2; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_sendertimestamp(), target); - } - - // repeated uint32 senderKeyIndexes = 3 [packed = true]; - { - int byte_size = _impl_._senderkeyindexes_cached_byte_size_.load(std::memory_order_relaxed); - if (byte_size > 0) { - target = stream->WriteUInt32Packed( - 3, _internal_senderkeyindexes(), byte_size, target); - } - } - - // optional bytes recipientKeyHash = 8; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 8, this->_internal_recipientkeyhash(), target); - } - - // optional uint64 recipientTimestamp = 9; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(9, this->_internal_recipienttimestamp(), target); - } - - // repeated uint32 recipientKeyIndexes = 10 [packed = true]; - { - int byte_size = _impl_._recipientkeyindexes_cached_byte_size_.load(std::memory_order_relaxed); - if (byte_size > 0) { - target = stream->WriteUInt32Packed( - 10, _internal_recipientkeyindexes(), byte_size, target); - } - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.DeviceListMetadata) - return target; -} - -size_t DeviceListMetadata::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.DeviceListMetadata) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated uint32 senderKeyIndexes = 3 [packed = true]; - { - size_t data_size = ::_pbi::WireFormatLite:: - UInt32Size(this->_impl_.senderkeyindexes_); - if (data_size > 0) { - total_size += 1 + - ::_pbi::WireFormatLite::Int32Size(static_cast(data_size)); - } - int cached_size = ::_pbi::ToCachedSize(data_size); - _impl_._senderkeyindexes_cached_byte_size_.store(cached_size, - std::memory_order_relaxed); - total_size += data_size; - } - - // repeated uint32 recipientKeyIndexes = 10 [packed = true]; - { - size_t data_size = ::_pbi::WireFormatLite:: - UInt32Size(this->_impl_.recipientkeyindexes_); - if (data_size > 0) { - total_size += 1 + - ::_pbi::WireFormatLite::Int32Size(static_cast(data_size)); - } - int cached_size = ::_pbi::ToCachedSize(data_size); - _impl_._recipientkeyindexes_cached_byte_size_.store(cached_size, - std::memory_order_relaxed); - total_size += data_size; - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - // optional bytes senderKeyHash = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_senderkeyhash()); - } - - // optional bytes recipientKeyHash = 8; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_recipientkeyhash()); - } - - // optional uint64 senderTimestamp = 2; - if (cached_has_bits & 0x00000004u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_sendertimestamp()); - } - - // optional uint64 recipientTimestamp = 9; - if (cached_has_bits & 0x00000008u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_recipienttimestamp()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DeviceListMetadata::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - DeviceListMetadata::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DeviceListMetadata::GetClassData() const { return &_class_data_; } - - -void DeviceListMetadata::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.DeviceListMetadata) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.senderkeyindexes_.MergeFrom(from._impl_.senderkeyindexes_); - _this->_impl_.recipientkeyindexes_.MergeFrom(from._impl_.recipientkeyindexes_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_senderkeyhash(from._internal_senderkeyhash()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_recipientkeyhash(from._internal_recipientkeyhash()); - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.sendertimestamp_ = from._impl_.sendertimestamp_; - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.recipienttimestamp_ = from._impl_.recipienttimestamp_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void DeviceListMetadata::CopyFrom(const DeviceListMetadata& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.DeviceListMetadata) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool DeviceListMetadata::IsInitialized() const { - return true; -} - -void DeviceListMetadata::InternalSwap(DeviceListMetadata* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.senderkeyindexes_.InternalSwap(&other->_impl_.senderkeyindexes_); - _impl_.recipientkeyindexes_.InternalSwap(&other->_impl_.recipientkeyindexes_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.senderkeyhash_, lhs_arena, - &other->_impl_.senderkeyhash_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.recipientkeyhash_, lhs_arena, - &other->_impl_.recipientkeyhash_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(DeviceListMetadata, _impl_.recipienttimestamp_) - + sizeof(DeviceListMetadata::_impl_.recipienttimestamp_) - - PROTOBUF_FIELD_OFFSET(DeviceListMetadata, _impl_.sendertimestamp_)>( - reinterpret_cast(&_impl_.sendertimestamp_), - reinterpret_cast(&other->_impl_.sendertimestamp_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata DeviceListMetadata::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[26]); -} - -// =================================================================== - -class DeviceProps_AppVersion::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_primary(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_secondary(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_tertiary(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_quaternary(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_quinary(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } -}; - -DeviceProps_AppVersion::DeviceProps_AppVersion(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.DeviceProps.AppVersion) -} -DeviceProps_AppVersion::DeviceProps_AppVersion(const DeviceProps_AppVersion& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - DeviceProps_AppVersion* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.primary_){} - , decltype(_impl_.secondary_){} - , decltype(_impl_.tertiary_){} - , decltype(_impl_.quaternary_){} - , decltype(_impl_.quinary_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&_impl_.primary_, &from._impl_.primary_, - static_cast(reinterpret_cast(&_impl_.quinary_) - - reinterpret_cast(&_impl_.primary_)) + sizeof(_impl_.quinary_)); - // @@protoc_insertion_point(copy_constructor:proto.DeviceProps.AppVersion) -} - -inline void DeviceProps_AppVersion::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.primary_){0u} - , decltype(_impl_.secondary_){0u} - , decltype(_impl_.tertiary_){0u} - , decltype(_impl_.quaternary_){0u} - , decltype(_impl_.quinary_){0u} - }; -} - -DeviceProps_AppVersion::~DeviceProps_AppVersion() { - // @@protoc_insertion_point(destructor:proto.DeviceProps.AppVersion) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void DeviceProps_AppVersion::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void DeviceProps_AppVersion::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void DeviceProps_AppVersion::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.DeviceProps.AppVersion) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { - ::memset(&_impl_.primary_, 0, static_cast( - reinterpret_cast(&_impl_.quinary_) - - reinterpret_cast(&_impl_.primary_)) + sizeof(_impl_.quinary_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* DeviceProps_AppVersion::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional uint32 primary = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_primary(&has_bits); - _impl_.primary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 secondary = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_secondary(&has_bits); - _impl_.secondary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 tertiary = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_tertiary(&has_bits); - _impl_.tertiary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 quaternary = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - _Internal::set_has_quaternary(&has_bits); - _impl_.quaternary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 quinary = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { - _Internal::set_has_quinary(&has_bits); - _impl_.quinary_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* DeviceProps_AppVersion::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.DeviceProps.AppVersion) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional uint32 primary = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_primary(), target); - } - - // optional uint32 secondary = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_secondary(), target); - } - - // optional uint32 tertiary = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_tertiary(), target); - } - - // optional uint32 quaternary = 4; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_quaternary(), target); - } - - // optional uint32 quinary = 5; - if (cached_has_bits & 0x00000010u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_quinary(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.DeviceProps.AppVersion) - return target; -} - -size_t DeviceProps_AppVersion::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.DeviceProps.AppVersion) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { - // optional uint32 primary = 1; - if (cached_has_bits & 0x00000001u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_primary()); - } - - // optional uint32 secondary = 2; - if (cached_has_bits & 0x00000002u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_secondary()); - } - - // optional uint32 tertiary = 3; - if (cached_has_bits & 0x00000004u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_tertiary()); - } - - // optional uint32 quaternary = 4; - if (cached_has_bits & 0x00000008u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_quaternary()); - } - - // optional uint32 quinary = 5; - if (cached_has_bits & 0x00000010u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_quinary()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DeviceProps_AppVersion::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - DeviceProps_AppVersion::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DeviceProps_AppVersion::GetClassData() const { return &_class_data_; } - - -void DeviceProps_AppVersion::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.DeviceProps.AppVersion) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { - if (cached_has_bits & 0x00000001u) { - _this->_impl_.primary_ = from._impl_.primary_; - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.secondary_ = from._impl_.secondary_; - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.tertiary_ = from._impl_.tertiary_; - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.quaternary_ = from._impl_.quaternary_; - } - if (cached_has_bits & 0x00000010u) { - _this->_impl_.quinary_ = from._impl_.quinary_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void DeviceProps_AppVersion::CopyFrom(const DeviceProps_AppVersion& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.DeviceProps.AppVersion) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool DeviceProps_AppVersion::IsInitialized() const { - return true; -} - -void DeviceProps_AppVersion::InternalSwap(DeviceProps_AppVersion* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(DeviceProps_AppVersion, _impl_.quinary_) - + sizeof(DeviceProps_AppVersion::_impl_.quinary_) - - PROTOBUF_FIELD_OFFSET(DeviceProps_AppVersion, _impl_.primary_)>( - reinterpret_cast(&_impl_.primary_), - reinterpret_cast(&other->_impl_.primary_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata DeviceProps_AppVersion::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[27]); -} - -// =================================================================== - -class DeviceProps::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_os(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::proto::DeviceProps_AppVersion& version(const DeviceProps* msg); - static void set_has_version(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_platformtype(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_requirefullsync(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } -}; - -const ::proto::DeviceProps_AppVersion& -DeviceProps::_Internal::version(const DeviceProps* msg) { - return *msg->_impl_.version_; -} -DeviceProps::DeviceProps(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.DeviceProps) -} -DeviceProps::DeviceProps(const DeviceProps& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - DeviceProps* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.os_){} - , decltype(_impl_.version_){nullptr} - , decltype(_impl_.platformtype_){} - , decltype(_impl_.requirefullsync_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.os_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.os_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_os()) { - _this->_impl_.os_.Set(from._internal_os(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_version()) { - _this->_impl_.version_ = new ::proto::DeviceProps_AppVersion(*from._impl_.version_); - } - ::memcpy(&_impl_.platformtype_, &from._impl_.platformtype_, - static_cast(reinterpret_cast(&_impl_.requirefullsync_) - - reinterpret_cast(&_impl_.platformtype_)) + sizeof(_impl_.requirefullsync_)); - // @@protoc_insertion_point(copy_constructor:proto.DeviceProps) -} - -inline void DeviceProps::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.os_){} - , decltype(_impl_.version_){nullptr} - , decltype(_impl_.platformtype_){0} - , decltype(_impl_.requirefullsync_){false} - }; - _impl_.os_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.os_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -DeviceProps::~DeviceProps() { - // @@protoc_insertion_point(destructor:proto.DeviceProps) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void DeviceProps::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.os_.Destroy(); - if (this != internal_default_instance()) delete _impl_.version_; -} - -void DeviceProps::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void DeviceProps::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.DeviceProps) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.os_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.version_ != nullptr); - _impl_.version_->Clear(); - } - } - if (cached_has_bits & 0x0000000cu) { - ::memset(&_impl_.platformtype_, 0, static_cast( - reinterpret_cast(&_impl_.requirefullsync_) - - reinterpret_cast(&_impl_.platformtype_)) + sizeof(_impl_.requirefullsync_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* DeviceProps::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string os = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_os(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.DeviceProps.os"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.DeviceProps.AppVersion version = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_version(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.DeviceProps.PlatformType platformType = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::DeviceProps_PlatformType_IsValid(val))) { - _internal_set_platformtype(static_cast<::proto::DeviceProps_PlatformType>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional bool requireFullSync = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - _Internal::set_has_requirefullsync(&has_bits); - _impl_.requirefullsync_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* DeviceProps::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.DeviceProps) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string os = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_os().data(), static_cast(this->_internal_os().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.DeviceProps.os"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_os(), target); - } - - // optional .proto.DeviceProps.AppVersion version = 2; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::version(this), - _Internal::version(this).GetCachedSize(), target, stream); - } - - // optional .proto.DeviceProps.PlatformType platformType = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 3, this->_internal_platformtype(), target); - } - - // optional bool requireFullSync = 4; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(4, this->_internal_requirefullsync(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.DeviceProps) - return target; -} - -size_t DeviceProps::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.DeviceProps) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - // optional string os = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_os()); - } - - // optional .proto.DeviceProps.AppVersion version = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.version_); - } - - // optional .proto.DeviceProps.PlatformType platformType = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_platformtype()); - } - - // optional bool requireFullSync = 4; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + 1; - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DeviceProps::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - DeviceProps::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DeviceProps::GetClassData() const { return &_class_data_; } - - -void DeviceProps::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.DeviceProps) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_os(from._internal_os()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_version()->::proto::DeviceProps_AppVersion::MergeFrom( - from._internal_version()); - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.platformtype_ = from._impl_.platformtype_; - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.requirefullsync_ = from._impl_.requirefullsync_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void DeviceProps::CopyFrom(const DeviceProps& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.DeviceProps) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool DeviceProps::IsInitialized() const { - return true; -} - -void DeviceProps::InternalSwap(DeviceProps* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.os_, lhs_arena, - &other->_impl_.os_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(DeviceProps, _impl_.requirefullsync_) - + sizeof(DeviceProps::_impl_.requirefullsync_) - - PROTOBUF_FIELD_OFFSET(DeviceProps, _impl_.version_)>( - reinterpret_cast(&_impl_.version_), - reinterpret_cast(&other->_impl_.version_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata DeviceProps::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[28]); -} - -// =================================================================== - -class DisappearingMode::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_initiator(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -DisappearingMode::DisappearingMode(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.DisappearingMode) -} -DisappearingMode::DisappearingMode(const DisappearingMode& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - DisappearingMode* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.initiator_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _this->_impl_.initiator_ = from._impl_.initiator_; - // @@protoc_insertion_point(copy_constructor:proto.DisappearingMode) -} - -inline void DisappearingMode::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.initiator_){0} - }; -} - -DisappearingMode::~DisappearingMode() { - // @@protoc_insertion_point(destructor:proto.DisappearingMode) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void DisappearingMode::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void DisappearingMode::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void DisappearingMode::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.DisappearingMode) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.initiator_ = 0; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* DisappearingMode::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.DisappearingMode.Initiator initiator = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::DisappearingMode_Initiator_IsValid(val))) { - _internal_set_initiator(static_cast<::proto::DisappearingMode_Initiator>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* DisappearingMode::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.DisappearingMode) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.DisappearingMode.Initiator initiator = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 1, this->_internal_initiator(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.DisappearingMode) - return target; -} - -size_t DisappearingMode::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.DisappearingMode) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional .proto.DisappearingMode.Initiator initiator = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_initiator()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DisappearingMode::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - DisappearingMode::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DisappearingMode::GetClassData() const { return &_class_data_; } - - -void DisappearingMode::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.DisappearingMode) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_initiator()) { - _this->_internal_set_initiator(from._internal_initiator()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void DisappearingMode::CopyFrom(const DisappearingMode& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.DisappearingMode) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool DisappearingMode::IsInitialized() const { - return true; -} - -void DisappearingMode::InternalSwap(DisappearingMode* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - swap(_impl_.initiator_, other->_impl_.initiator_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata DisappearingMode::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[29]); -} - -// =================================================================== - -class EphemeralSetting::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_duration(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_timestamp(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -EphemeralSetting::EphemeralSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.EphemeralSetting) -} -EphemeralSetting::EphemeralSetting(const EphemeralSetting& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - EphemeralSetting* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.timestamp_){} - , decltype(_impl_.duration_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&_impl_.timestamp_, &from._impl_.timestamp_, - static_cast(reinterpret_cast(&_impl_.duration_) - - reinterpret_cast(&_impl_.timestamp_)) + sizeof(_impl_.duration_)); - // @@protoc_insertion_point(copy_constructor:proto.EphemeralSetting) -} - -inline void EphemeralSetting::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.timestamp_){int64_t{0}} - , decltype(_impl_.duration_){0} - }; -} - -EphemeralSetting::~EphemeralSetting() { - // @@protoc_insertion_point(destructor:proto.EphemeralSetting) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void EphemeralSetting::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void EphemeralSetting::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void EphemeralSetting::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.EphemeralSetting) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - ::memset(&_impl_.timestamp_, 0, static_cast( - reinterpret_cast(&_impl_.duration_) - - reinterpret_cast(&_impl_.timestamp_)) + sizeof(_impl_.duration_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* EphemeralSetting::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional sfixed32 duration = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 13)) { - _Internal::set_has_duration(&has_bits); - _impl_.duration_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); - ptr += sizeof(int32_t); - } else - goto handle_unusual; - continue; - // optional sfixed64 timestamp = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 17)) { - _Internal::set_has_timestamp(&has_bits); - _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); - ptr += sizeof(int64_t); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* EphemeralSetting::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.EphemeralSetting) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional sfixed32 duration = 1; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSFixed32ToArray(1, this->_internal_duration(), target); - } - - // optional sfixed64 timestamp = 2; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSFixed64ToArray(2, this->_internal_timestamp(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.EphemeralSetting) - return target; -} - -size_t EphemeralSetting::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.EphemeralSetting) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional sfixed64 timestamp = 2; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + 8; - } - - // optional sfixed32 duration = 1; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + 4; - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData EphemeralSetting::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - EphemeralSetting::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*EphemeralSetting::GetClassData() const { return &_class_data_; } - - -void EphemeralSetting::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.EphemeralSetting) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_impl_.timestamp_ = from._impl_.timestamp_; - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.duration_ = from._impl_.duration_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void EphemeralSetting::CopyFrom(const EphemeralSetting& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.EphemeralSetting) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool EphemeralSetting::IsInitialized() const { - return true; -} - -void EphemeralSetting::InternalSwap(EphemeralSetting* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(EphemeralSetting, _impl_.duration_) - + sizeof(EphemeralSetting::_impl_.duration_) - - PROTOBUF_FIELD_OFFSET(EphemeralSetting, _impl_.timestamp_)>( - reinterpret_cast(&_impl_.timestamp_), - reinterpret_cast(&other->_impl_.timestamp_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata EphemeralSetting::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[30]); -} - -// =================================================================== - -class ExitCode::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_code(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_text(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -ExitCode::ExitCode(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.ExitCode) -} -ExitCode::ExitCode(const ExitCode& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - ExitCode* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.text_){} - , decltype(_impl_.code_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.text_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.text_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_text()) { - _this->_impl_.text_.Set(from._internal_text(), - _this->GetArenaForAllocation()); - } - _this->_impl_.code_ = from._impl_.code_; - // @@protoc_insertion_point(copy_constructor:proto.ExitCode) -} - -inline void ExitCode::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.text_){} - , decltype(_impl_.code_){uint64_t{0u}} - }; - _impl_.text_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.text_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -ExitCode::~ExitCode() { - // @@protoc_insertion_point(destructor:proto.ExitCode) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void ExitCode::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.text_.Destroy(); -} - -void ExitCode::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void ExitCode::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.ExitCode) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.text_.ClearNonDefaultToEmpty(); - } - _impl_.code_ = uint64_t{0u}; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ExitCode::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional uint64 code = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_code(&has_bits); - _impl_.code_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string text = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_text(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ExitCode.text"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ExitCode::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.ExitCode) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional uint64 code = 1; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_code(), target); - } - - // optional string text = 2; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_text().data(), static_cast(this->_internal_text().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ExitCode.text"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_text(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.ExitCode) - return target; -} - -size_t ExitCode::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.ExitCode) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional string text = 2; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_text()); - } - - // optional uint64 code = 1; - if (cached_has_bits & 0x00000002u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_code()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ExitCode::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - ExitCode::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ExitCode::GetClassData() const { return &_class_data_; } - - -void ExitCode::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.ExitCode) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_text(from._internal_text()); - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.code_ = from._impl_.code_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ExitCode::CopyFrom(const ExitCode& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.ExitCode) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ExitCode::IsInitialized() const { - return true; -} - -void ExitCode::InternalSwap(ExitCode* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.text_, lhs_arena, - &other->_impl_.text_, rhs_arena - ); - swap(_impl_.code_, other->_impl_.code_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ExitCode::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[31]); -} - -// =================================================================== - -class ExternalBlobReference::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_mediakey(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_directpath(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_handle(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_filesizebytes(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static void set_has_filesha256(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_fileencsha256(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } -}; - -ExternalBlobReference::ExternalBlobReference(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.ExternalBlobReference) -} -ExternalBlobReference::ExternalBlobReference(const ExternalBlobReference& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - ExternalBlobReference* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.mediakey_){} - , decltype(_impl_.directpath_){} - , decltype(_impl_.handle_){} - , decltype(_impl_.filesha256_){} - , decltype(_impl_.fileencsha256_){} - , decltype(_impl_.filesizebytes_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.mediakey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediakey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_mediakey()) { - _this->_impl_.mediakey_.Set(from._internal_mediakey(), - _this->GetArenaForAllocation()); - } - _impl_.directpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_directpath()) { - _this->_impl_.directpath_.Set(from._internal_directpath(), - _this->GetArenaForAllocation()); - } - _impl_.handle_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.handle_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_handle()) { - _this->_impl_.handle_.Set(from._internal_handle(), - _this->GetArenaForAllocation()); - } - _impl_.filesha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filesha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_filesha256()) { - _this->_impl_.filesha256_.Set(from._internal_filesha256(), - _this->GetArenaForAllocation()); - } - _impl_.fileencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_fileencsha256()) { - _this->_impl_.fileencsha256_.Set(from._internal_fileencsha256(), - _this->GetArenaForAllocation()); - } - _this->_impl_.filesizebytes_ = from._impl_.filesizebytes_; - // @@protoc_insertion_point(copy_constructor:proto.ExternalBlobReference) -} - -inline void ExternalBlobReference::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.mediakey_){} - , decltype(_impl_.directpath_){} - , decltype(_impl_.handle_){} - , decltype(_impl_.filesha256_){} - , decltype(_impl_.fileencsha256_){} - , decltype(_impl_.filesizebytes_){uint64_t{0u}} - }; - _impl_.mediakey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediakey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.handle_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.handle_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filesha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filesha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fileencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -ExternalBlobReference::~ExternalBlobReference() { - // @@protoc_insertion_point(destructor:proto.ExternalBlobReference) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void ExternalBlobReference::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.mediakey_.Destroy(); - _impl_.directpath_.Destroy(); - _impl_.handle_.Destroy(); - _impl_.filesha256_.Destroy(); - _impl_.fileencsha256_.Destroy(); -} - -void ExternalBlobReference::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void ExternalBlobReference::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.ExternalBlobReference) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { - if (cached_has_bits & 0x00000001u) { - _impl_.mediakey_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.directpath_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.handle_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000008u) { - _impl_.filesha256_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000010u) { - _impl_.fileencsha256_.ClearNonDefaultToEmpty(); - } - } - _impl_.filesizebytes_ = uint64_t{0u}; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ExternalBlobReference::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bytes mediaKey = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_mediakey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string directPath = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_directpath(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ExternalBlobReference.directPath"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string handle = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_handle(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ExternalBlobReference.handle"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional uint64 fileSizeBytes = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - _Internal::set_has_filesizebytes(&has_bits); - _impl_.filesizebytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes fileSha256 = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - auto str = _internal_mutable_filesha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes fileEncSha256 = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - auto str = _internal_mutable_fileencsha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ExternalBlobReference::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.ExternalBlobReference) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bytes mediaKey = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 1, this->_internal_mediakey(), target); - } - - // optional string directPath = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_directpath().data(), static_cast(this->_internal_directpath().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ExternalBlobReference.directPath"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_directpath(), target); - } - - // optional string handle = 3; - if (cached_has_bits & 0x00000004u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_handle().data(), static_cast(this->_internal_handle().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ExternalBlobReference.handle"); - target = stream->WriteStringMaybeAliased( - 3, this->_internal_handle(), target); - } - - // optional uint64 fileSizeBytes = 4; - if (cached_has_bits & 0x00000020u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_filesizebytes(), target); - } - - // optional bytes fileSha256 = 5; - if (cached_has_bits & 0x00000008u) { - target = stream->WriteBytesMaybeAliased( - 5, this->_internal_filesha256(), target); - } - - // optional bytes fileEncSha256 = 6; - if (cached_has_bits & 0x00000010u) { - target = stream->WriteBytesMaybeAliased( - 6, this->_internal_fileencsha256(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.ExternalBlobReference) - return target; -} - -size_t ExternalBlobReference::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.ExternalBlobReference) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000003fu) { - // optional bytes mediaKey = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_mediakey()); - } - - // optional string directPath = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_directpath()); - } - - // optional string handle = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_handle()); - } - - // optional bytes fileSha256 = 5; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_filesha256()); - } - - // optional bytes fileEncSha256 = 6; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_fileencsha256()); - } - - // optional uint64 fileSizeBytes = 4; - if (cached_has_bits & 0x00000020u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_filesizebytes()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ExternalBlobReference::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - ExternalBlobReference::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ExternalBlobReference::GetClassData() const { return &_class_data_; } - - -void ExternalBlobReference::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.ExternalBlobReference) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000003fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_mediakey(from._internal_mediakey()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_directpath(from._internal_directpath()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_handle(from._internal_handle()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_set_filesha256(from._internal_filesha256()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_set_fileencsha256(from._internal_fileencsha256()); - } - if (cached_has_bits & 0x00000020u) { - _this->_impl_.filesizebytes_ = from._impl_.filesizebytes_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ExternalBlobReference::CopyFrom(const ExternalBlobReference& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.ExternalBlobReference) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ExternalBlobReference::IsInitialized() const { - return true; -} - -void ExternalBlobReference::InternalSwap(ExternalBlobReference* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.mediakey_, lhs_arena, - &other->_impl_.mediakey_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.directpath_, lhs_arena, - &other->_impl_.directpath_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.handle_, lhs_arena, - &other->_impl_.handle_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.filesha256_, lhs_arena, - &other->_impl_.filesha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.fileencsha256_, lhs_arena, - &other->_impl_.fileencsha256_, rhs_arena - ); - swap(_impl_.filesizebytes_, other->_impl_.filesizebytes_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ExternalBlobReference::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[32]); -} - -// =================================================================== - -class GlobalSettings::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::WallpaperSettings& lightthemewallpaper(const GlobalSettings* msg); - static void set_has_lightthemewallpaper(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_mediavisibility(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static const ::proto::WallpaperSettings& darkthemewallpaper(const GlobalSettings* msg); - static void set_has_darkthemewallpaper(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::proto::AutoDownloadSettings& autodownloadwifi(const GlobalSettings* msg); - static void set_has_autodownloadwifi(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static const ::proto::AutoDownloadSettings& autodownloadcellular(const GlobalSettings* msg); - static void set_has_autodownloadcellular(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static const ::proto::AutoDownloadSettings& autodownloadroaming(const GlobalSettings* msg); - static void set_has_autodownloadroaming(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_showindividualnotificationspreview(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static void set_has_showgroupnotificationspreview(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } - static void set_has_disappearingmodeduration(HasBits* has_bits) { - (*has_bits)[0] |= 512u; - } - static void set_has_disappearingmodetimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 256u; - } -}; - -const ::proto::WallpaperSettings& -GlobalSettings::_Internal::lightthemewallpaper(const GlobalSettings* msg) { - return *msg->_impl_.lightthemewallpaper_; -} -const ::proto::WallpaperSettings& -GlobalSettings::_Internal::darkthemewallpaper(const GlobalSettings* msg) { - return *msg->_impl_.darkthemewallpaper_; -} -const ::proto::AutoDownloadSettings& -GlobalSettings::_Internal::autodownloadwifi(const GlobalSettings* msg) { - return *msg->_impl_.autodownloadwifi_; -} -const ::proto::AutoDownloadSettings& -GlobalSettings::_Internal::autodownloadcellular(const GlobalSettings* msg) { - return *msg->_impl_.autodownloadcellular_; -} -const ::proto::AutoDownloadSettings& -GlobalSettings::_Internal::autodownloadroaming(const GlobalSettings* msg) { - return *msg->_impl_.autodownloadroaming_; -} -GlobalSettings::GlobalSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.GlobalSettings) -} -GlobalSettings::GlobalSettings(const GlobalSettings& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - GlobalSettings* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.lightthemewallpaper_){nullptr} - , decltype(_impl_.darkthemewallpaper_){nullptr} - , decltype(_impl_.autodownloadwifi_){nullptr} - , decltype(_impl_.autodownloadcellular_){nullptr} - , decltype(_impl_.autodownloadroaming_){nullptr} - , decltype(_impl_.mediavisibility_){} - , decltype(_impl_.showindividualnotificationspreview_){} - , decltype(_impl_.showgroupnotificationspreview_){} - , decltype(_impl_.disappearingmodetimestamp_){} - , decltype(_impl_.disappearingmodeduration_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_lightthemewallpaper()) { - _this->_impl_.lightthemewallpaper_ = new ::proto::WallpaperSettings(*from._impl_.lightthemewallpaper_); - } - if (from._internal_has_darkthemewallpaper()) { - _this->_impl_.darkthemewallpaper_ = new ::proto::WallpaperSettings(*from._impl_.darkthemewallpaper_); - } - if (from._internal_has_autodownloadwifi()) { - _this->_impl_.autodownloadwifi_ = new ::proto::AutoDownloadSettings(*from._impl_.autodownloadwifi_); - } - if (from._internal_has_autodownloadcellular()) { - _this->_impl_.autodownloadcellular_ = new ::proto::AutoDownloadSettings(*from._impl_.autodownloadcellular_); - } - if (from._internal_has_autodownloadroaming()) { - _this->_impl_.autodownloadroaming_ = new ::proto::AutoDownloadSettings(*from._impl_.autodownloadroaming_); - } - ::memcpy(&_impl_.mediavisibility_, &from._impl_.mediavisibility_, - static_cast(reinterpret_cast(&_impl_.disappearingmodeduration_) - - reinterpret_cast(&_impl_.mediavisibility_)) + sizeof(_impl_.disappearingmodeduration_)); - // @@protoc_insertion_point(copy_constructor:proto.GlobalSettings) -} - -inline void GlobalSettings::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.lightthemewallpaper_){nullptr} - , decltype(_impl_.darkthemewallpaper_){nullptr} - , decltype(_impl_.autodownloadwifi_){nullptr} - , decltype(_impl_.autodownloadcellular_){nullptr} - , decltype(_impl_.autodownloadroaming_){nullptr} - , decltype(_impl_.mediavisibility_){0} - , decltype(_impl_.showindividualnotificationspreview_){false} - , decltype(_impl_.showgroupnotificationspreview_){false} - , decltype(_impl_.disappearingmodetimestamp_){int64_t{0}} - , decltype(_impl_.disappearingmodeduration_){0} - }; -} - -GlobalSettings::~GlobalSettings() { - // @@protoc_insertion_point(destructor:proto.GlobalSettings) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void GlobalSettings::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete _impl_.lightthemewallpaper_; - if (this != internal_default_instance()) delete _impl_.darkthemewallpaper_; - if (this != internal_default_instance()) delete _impl_.autodownloadwifi_; - if (this != internal_default_instance()) delete _impl_.autodownloadcellular_; - if (this != internal_default_instance()) delete _impl_.autodownloadroaming_; -} - -void GlobalSettings::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void GlobalSettings::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.GlobalSettings) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.lightthemewallpaper_ != nullptr); - _impl_.lightthemewallpaper_->Clear(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.darkthemewallpaper_ != nullptr); - _impl_.darkthemewallpaper_->Clear(); - } - if (cached_has_bits & 0x00000004u) { - GOOGLE_DCHECK(_impl_.autodownloadwifi_ != nullptr); - _impl_.autodownloadwifi_->Clear(); - } - if (cached_has_bits & 0x00000008u) { - GOOGLE_DCHECK(_impl_.autodownloadcellular_ != nullptr); - _impl_.autodownloadcellular_->Clear(); - } - if (cached_has_bits & 0x00000010u) { - GOOGLE_DCHECK(_impl_.autodownloadroaming_ != nullptr); - _impl_.autodownloadroaming_->Clear(); - } - } - if (cached_has_bits & 0x000000e0u) { - ::memset(&_impl_.mediavisibility_, 0, static_cast( - reinterpret_cast(&_impl_.showgroupnotificationspreview_) - - reinterpret_cast(&_impl_.mediavisibility_)) + sizeof(_impl_.showgroupnotificationspreview_)); - } - if (cached_has_bits & 0x00000300u) { - ::memset(&_impl_.disappearingmodetimestamp_, 0, static_cast( - reinterpret_cast(&_impl_.disappearingmodeduration_) - - reinterpret_cast(&_impl_.disappearingmodetimestamp_)) + sizeof(_impl_.disappearingmodeduration_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* GlobalSettings::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.WallpaperSettings lightThemeWallpaper = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_lightthemewallpaper(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.MediaVisibility mediaVisibility = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::MediaVisibility_IsValid(val))) { - _internal_set_mediavisibility(static_cast<::proto::MediaVisibility>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WallpaperSettings darkThemeWallpaper = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_darkthemewallpaper(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.AutoDownloadSettings autoDownloadWiFi = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_autodownloadwifi(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.AutoDownloadSettings autoDownloadCellular = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - ptr = ctx->ParseMessage(_internal_mutable_autodownloadcellular(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.AutoDownloadSettings autoDownloadRoaming = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - ptr = ctx->ParseMessage(_internal_mutable_autodownloadroaming(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool showIndividualNotificationsPreview = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { - _Internal::set_has_showindividualnotificationspreview(&has_bits); - _impl_.showindividualnotificationspreview_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool showGroupNotificationsPreview = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { - _Internal::set_has_showgroupnotificationspreview(&has_bits); - _impl_.showgroupnotificationspreview_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional int32 disappearingModeDuration = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { - _Internal::set_has_disappearingmodeduration(&has_bits); - _impl_.disappearingmodeduration_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional int64 disappearingModeTimestamp = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { - _Internal::set_has_disappearingmodetimestamp(&has_bits); - _impl_.disappearingmodetimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* GlobalSettings::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.GlobalSettings) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.WallpaperSettings lightThemeWallpaper = 1; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::lightthemewallpaper(this), - _Internal::lightthemewallpaper(this).GetCachedSize(), target, stream); - } - - // optional .proto.MediaVisibility mediaVisibility = 2; - if (cached_has_bits & 0x00000020u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 2, this->_internal_mediavisibility(), target); - } - - // optional .proto.WallpaperSettings darkThemeWallpaper = 3; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, _Internal::darkthemewallpaper(this), - _Internal::darkthemewallpaper(this).GetCachedSize(), target, stream); - } - - // optional .proto.AutoDownloadSettings autoDownloadWiFi = 4; - if (cached_has_bits & 0x00000004u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(4, _Internal::autodownloadwifi(this), - _Internal::autodownloadwifi(this).GetCachedSize(), target, stream); - } - - // optional .proto.AutoDownloadSettings autoDownloadCellular = 5; - if (cached_has_bits & 0x00000008u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(5, _Internal::autodownloadcellular(this), - _Internal::autodownloadcellular(this).GetCachedSize(), target, stream); - } - - // optional .proto.AutoDownloadSettings autoDownloadRoaming = 6; - if (cached_has_bits & 0x00000010u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(6, _Internal::autodownloadroaming(this), - _Internal::autodownloadroaming(this).GetCachedSize(), target, stream); - } - - // optional bool showIndividualNotificationsPreview = 7; - if (cached_has_bits & 0x00000040u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(7, this->_internal_showindividualnotificationspreview(), target); - } - - // optional bool showGroupNotificationsPreview = 8; - if (cached_has_bits & 0x00000080u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(8, this->_internal_showgroupnotificationspreview(), target); - } - - // optional int32 disappearingModeDuration = 9; - if (cached_has_bits & 0x00000200u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt32ToArray(9, this->_internal_disappearingmodeduration(), target); - } - - // optional int64 disappearingModeTimestamp = 10; - if (cached_has_bits & 0x00000100u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(10, this->_internal_disappearingmodetimestamp(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.GlobalSettings) - return target; -} - -size_t GlobalSettings::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.GlobalSettings) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional .proto.WallpaperSettings lightThemeWallpaper = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.lightthemewallpaper_); - } - - // optional .proto.WallpaperSettings darkThemeWallpaper = 3; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.darkthemewallpaper_); - } - - // optional .proto.AutoDownloadSettings autoDownloadWiFi = 4; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.autodownloadwifi_); - } - - // optional .proto.AutoDownloadSettings autoDownloadCellular = 5; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.autodownloadcellular_); - } - - // optional .proto.AutoDownloadSettings autoDownloadRoaming = 6; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.autodownloadroaming_); - } - - // optional .proto.MediaVisibility mediaVisibility = 2; - if (cached_has_bits & 0x00000020u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_mediavisibility()); - } - - // optional bool showIndividualNotificationsPreview = 7; - if (cached_has_bits & 0x00000040u) { - total_size += 1 + 1; - } - - // optional bool showGroupNotificationsPreview = 8; - if (cached_has_bits & 0x00000080u) { - total_size += 1 + 1; - } - - } - if (cached_has_bits & 0x00000300u) { - // optional int64 disappearingModeTimestamp = 10; - if (cached_has_bits & 0x00000100u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_disappearingmodetimestamp()); - } - - // optional int32 disappearingModeDuration = 9; - if (cached_has_bits & 0x00000200u) { - total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_disappearingmodeduration()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData GlobalSettings::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - GlobalSettings::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GlobalSettings::GetClassData() const { return &_class_data_; } - - -void GlobalSettings::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.GlobalSettings) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_mutable_lightthemewallpaper()->::proto::WallpaperSettings::MergeFrom( - from._internal_lightthemewallpaper()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_darkthemewallpaper()->::proto::WallpaperSettings::MergeFrom( - from._internal_darkthemewallpaper()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_mutable_autodownloadwifi()->::proto::AutoDownloadSettings::MergeFrom( - from._internal_autodownloadwifi()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_mutable_autodownloadcellular()->::proto::AutoDownloadSettings::MergeFrom( - from._internal_autodownloadcellular()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_mutable_autodownloadroaming()->::proto::AutoDownloadSettings::MergeFrom( - from._internal_autodownloadroaming()); - } - if (cached_has_bits & 0x00000020u) { - _this->_impl_.mediavisibility_ = from._impl_.mediavisibility_; - } - if (cached_has_bits & 0x00000040u) { - _this->_impl_.showindividualnotificationspreview_ = from._impl_.showindividualnotificationspreview_; - } - if (cached_has_bits & 0x00000080u) { - _this->_impl_.showgroupnotificationspreview_ = from._impl_.showgroupnotificationspreview_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - if (cached_has_bits & 0x00000300u) { - if (cached_has_bits & 0x00000100u) { - _this->_impl_.disappearingmodetimestamp_ = from._impl_.disappearingmodetimestamp_; - } - if (cached_has_bits & 0x00000200u) { - _this->_impl_.disappearingmodeduration_ = from._impl_.disappearingmodeduration_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void GlobalSettings::CopyFrom(const GlobalSettings& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.GlobalSettings) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool GlobalSettings::IsInitialized() const { - return true; -} - -void GlobalSettings::InternalSwap(GlobalSettings* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(GlobalSettings, _impl_.disappearingmodeduration_) - + sizeof(GlobalSettings::_impl_.disappearingmodeduration_) - - PROTOBUF_FIELD_OFFSET(GlobalSettings, _impl_.lightthemewallpaper_)>( - reinterpret_cast(&_impl_.lightthemewallpaper_), - reinterpret_cast(&other->_impl_.lightthemewallpaper_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata GlobalSettings::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[33]); -} - -// =================================================================== - -class GroupParticipant::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_userjid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_rank(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static bool MissingRequiredFields(const HasBits& has_bits) { - return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0; - } -}; - -GroupParticipant::GroupParticipant(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.GroupParticipant) -} -GroupParticipant::GroupParticipant(const GroupParticipant& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - GroupParticipant* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.userjid_){} - , decltype(_impl_.rank_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.userjid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.userjid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_userjid()) { - _this->_impl_.userjid_.Set(from._internal_userjid(), - _this->GetArenaForAllocation()); - } - _this->_impl_.rank_ = from._impl_.rank_; - // @@protoc_insertion_point(copy_constructor:proto.GroupParticipant) -} - -inline void GroupParticipant::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.userjid_){} - , decltype(_impl_.rank_){0} - }; - _impl_.userjid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.userjid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -GroupParticipant::~GroupParticipant() { - // @@protoc_insertion_point(destructor:proto.GroupParticipant) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void GroupParticipant::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.userjid_.Destroy(); -} - -void GroupParticipant::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void GroupParticipant::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.GroupParticipant) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.userjid_.ClearNonDefaultToEmpty(); - } - _impl_.rank_ = 0; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* GroupParticipant::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // required string userJid = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_userjid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.GroupParticipant.userJid"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.GroupParticipant.Rank rank = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::GroupParticipant_Rank_IsValid(val))) { - _internal_set_rank(static_cast<::proto::GroupParticipant_Rank>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* GroupParticipant::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.GroupParticipant) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // required string userJid = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_userjid().data(), static_cast(this->_internal_userjid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.GroupParticipant.userJid"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_userjid(), target); - } - - // optional .proto.GroupParticipant.Rank rank = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 2, this->_internal_rank(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.GroupParticipant) - return target; -} - -size_t GroupParticipant::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.GroupParticipant) - size_t total_size = 0; - - // required string userJid = 1; - if (_internal_has_userjid()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_userjid()); - } - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional .proto.GroupParticipant.Rank rank = 2; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_rank()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData GroupParticipant::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - GroupParticipant::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GroupParticipant::GetClassData() const { return &_class_data_; } - - -void GroupParticipant::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.GroupParticipant) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_userjid(from._internal_userjid()); - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.rank_ = from._impl_.rank_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void GroupParticipant::CopyFrom(const GroupParticipant& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.GroupParticipant) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool GroupParticipant::IsInitialized() const { - if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false; - return true; -} - -void GroupParticipant::InternalSwap(GroupParticipant* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.userjid_, lhs_arena, - &other->_impl_.userjid_, rhs_arena - ); - swap(_impl_.rank_, other->_impl_.rank_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata GroupParticipant::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[34]); -} - -// =================================================================== - -class HandshakeMessage_ClientFinish::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_static_(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_payload(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -HandshakeMessage_ClientFinish::HandshakeMessage_ClientFinish(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.HandshakeMessage.ClientFinish) -} -HandshakeMessage_ClientFinish::HandshakeMessage_ClientFinish(const HandshakeMessage_ClientFinish& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - HandshakeMessage_ClientFinish* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.static__){} - , decltype(_impl_.payload_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.static__.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.static__.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_static_()) { - _this->_impl_.static__.Set(from._internal_static_(), - _this->GetArenaForAllocation()); - } - _impl_.payload_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.payload_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_payload()) { - _this->_impl_.payload_.Set(from._internal_payload(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.HandshakeMessage.ClientFinish) -} - -inline void HandshakeMessage_ClientFinish::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.static__){} - , decltype(_impl_.payload_){} - }; - _impl_.static__.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.static__.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.payload_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.payload_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -HandshakeMessage_ClientFinish::~HandshakeMessage_ClientFinish() { - // @@protoc_insertion_point(destructor:proto.HandshakeMessage.ClientFinish) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void HandshakeMessage_ClientFinish::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.static__.Destroy(); - _impl_.payload_.Destroy(); -} - -void HandshakeMessage_ClientFinish::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void HandshakeMessage_ClientFinish::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.HandshakeMessage.ClientFinish) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.static__.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.payload_.ClearNonDefaultToEmpty(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* HandshakeMessage_ClientFinish::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bytes static = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_static_(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes payload = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_payload(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* HandshakeMessage_ClientFinish::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.HandshakeMessage.ClientFinish) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bytes static = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 1, this->_internal_static_(), target); - } - - // optional bytes payload = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_payload(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.HandshakeMessage.ClientFinish) - return target; -} - -size_t HandshakeMessage_ClientFinish::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.HandshakeMessage.ClientFinish) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional bytes static = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_static_()); - } - - // optional bytes payload = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_payload()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HandshakeMessage_ClientFinish::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - HandshakeMessage_ClientFinish::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HandshakeMessage_ClientFinish::GetClassData() const { return &_class_data_; } - - -void HandshakeMessage_ClientFinish::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.HandshakeMessage.ClientFinish) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_static_(from._internal_static_()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_payload(from._internal_payload()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void HandshakeMessage_ClientFinish::CopyFrom(const HandshakeMessage_ClientFinish& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.HandshakeMessage.ClientFinish) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool HandshakeMessage_ClientFinish::IsInitialized() const { - return true; -} - -void HandshakeMessage_ClientFinish::InternalSwap(HandshakeMessage_ClientFinish* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.static__, lhs_arena, - &other->_impl_.static__, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.payload_, lhs_arena, - &other->_impl_.payload_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata HandshakeMessage_ClientFinish::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[35]); -} - -// =================================================================== - -class HandshakeMessage_ClientHello::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_ephemeral(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_static_(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_payload(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } -}; - -HandshakeMessage_ClientHello::HandshakeMessage_ClientHello(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.HandshakeMessage.ClientHello) -} -HandshakeMessage_ClientHello::HandshakeMessage_ClientHello(const HandshakeMessage_ClientHello& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - HandshakeMessage_ClientHello* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.ephemeral_){} - , decltype(_impl_.static__){} - , decltype(_impl_.payload_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.ephemeral_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.ephemeral_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_ephemeral()) { - _this->_impl_.ephemeral_.Set(from._internal_ephemeral(), - _this->GetArenaForAllocation()); - } - _impl_.static__.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.static__.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_static_()) { - _this->_impl_.static__.Set(from._internal_static_(), - _this->GetArenaForAllocation()); - } - _impl_.payload_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.payload_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_payload()) { - _this->_impl_.payload_.Set(from._internal_payload(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.HandshakeMessage.ClientHello) -} - -inline void HandshakeMessage_ClientHello::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.ephemeral_){} - , decltype(_impl_.static__){} - , decltype(_impl_.payload_){} - }; - _impl_.ephemeral_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.ephemeral_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.static__.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.static__.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.payload_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.payload_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -HandshakeMessage_ClientHello::~HandshakeMessage_ClientHello() { - // @@protoc_insertion_point(destructor:proto.HandshakeMessage.ClientHello) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void HandshakeMessage_ClientHello::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.ephemeral_.Destroy(); - _impl_.static__.Destroy(); - _impl_.payload_.Destroy(); -} - -void HandshakeMessage_ClientHello::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void HandshakeMessage_ClientHello::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.HandshakeMessage.ClientHello) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _impl_.ephemeral_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.static__.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.payload_.ClearNonDefaultToEmpty(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* HandshakeMessage_ClientHello::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bytes ephemeral = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_ephemeral(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes static = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_static_(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes payload = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_payload(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* HandshakeMessage_ClientHello::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.HandshakeMessage.ClientHello) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bytes ephemeral = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 1, this->_internal_ephemeral(), target); - } - - // optional bytes static = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_static_(), target); - } - - // optional bytes payload = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->WriteBytesMaybeAliased( - 3, this->_internal_payload(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.HandshakeMessage.ClientHello) - return target; -} - -size_t HandshakeMessage_ClientHello::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.HandshakeMessage.ClientHello) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional bytes ephemeral = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_ephemeral()); - } - - // optional bytes static = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_static_()); - } - - // optional bytes payload = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_payload()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HandshakeMessage_ClientHello::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - HandshakeMessage_ClientHello::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HandshakeMessage_ClientHello::GetClassData() const { return &_class_data_; } - - -void HandshakeMessage_ClientHello::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.HandshakeMessage.ClientHello) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_ephemeral(from._internal_ephemeral()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_static_(from._internal_static_()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_payload(from._internal_payload()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void HandshakeMessage_ClientHello::CopyFrom(const HandshakeMessage_ClientHello& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.HandshakeMessage.ClientHello) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool HandshakeMessage_ClientHello::IsInitialized() const { - return true; -} - -void HandshakeMessage_ClientHello::InternalSwap(HandshakeMessage_ClientHello* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.ephemeral_, lhs_arena, - &other->_impl_.ephemeral_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.static__, lhs_arena, - &other->_impl_.static__, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.payload_, lhs_arena, - &other->_impl_.payload_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata HandshakeMessage_ClientHello::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[36]); -} - -// =================================================================== - -class HandshakeMessage_ServerHello::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_ephemeral(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_static_(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_payload(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } -}; - -HandshakeMessage_ServerHello::HandshakeMessage_ServerHello(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.HandshakeMessage.ServerHello) -} -HandshakeMessage_ServerHello::HandshakeMessage_ServerHello(const HandshakeMessage_ServerHello& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - HandshakeMessage_ServerHello* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.ephemeral_){} - , decltype(_impl_.static__){} - , decltype(_impl_.payload_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.ephemeral_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.ephemeral_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_ephemeral()) { - _this->_impl_.ephemeral_.Set(from._internal_ephemeral(), - _this->GetArenaForAllocation()); - } - _impl_.static__.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.static__.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_static_()) { - _this->_impl_.static__.Set(from._internal_static_(), - _this->GetArenaForAllocation()); - } - _impl_.payload_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.payload_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_payload()) { - _this->_impl_.payload_.Set(from._internal_payload(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.HandshakeMessage.ServerHello) -} - -inline void HandshakeMessage_ServerHello::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.ephemeral_){} - , decltype(_impl_.static__){} - , decltype(_impl_.payload_){} - }; - _impl_.ephemeral_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.ephemeral_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.static__.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.static__.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.payload_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.payload_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -HandshakeMessage_ServerHello::~HandshakeMessage_ServerHello() { - // @@protoc_insertion_point(destructor:proto.HandshakeMessage.ServerHello) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void HandshakeMessage_ServerHello::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.ephemeral_.Destroy(); - _impl_.static__.Destroy(); - _impl_.payload_.Destroy(); -} - -void HandshakeMessage_ServerHello::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void HandshakeMessage_ServerHello::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.HandshakeMessage.ServerHello) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _impl_.ephemeral_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.static__.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.payload_.ClearNonDefaultToEmpty(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* HandshakeMessage_ServerHello::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bytes ephemeral = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_ephemeral(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes static = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_static_(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes payload = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_payload(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* HandshakeMessage_ServerHello::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.HandshakeMessage.ServerHello) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bytes ephemeral = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 1, this->_internal_ephemeral(), target); - } - - // optional bytes static = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_static_(), target); - } - - // optional bytes payload = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->WriteBytesMaybeAliased( - 3, this->_internal_payload(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.HandshakeMessage.ServerHello) - return target; -} - -size_t HandshakeMessage_ServerHello::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.HandshakeMessage.ServerHello) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional bytes ephemeral = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_ephemeral()); - } - - // optional bytes static = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_static_()); - } - - // optional bytes payload = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_payload()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HandshakeMessage_ServerHello::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - HandshakeMessage_ServerHello::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HandshakeMessage_ServerHello::GetClassData() const { return &_class_data_; } - - -void HandshakeMessage_ServerHello::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.HandshakeMessage.ServerHello) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_ephemeral(from._internal_ephemeral()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_static_(from._internal_static_()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_payload(from._internal_payload()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void HandshakeMessage_ServerHello::CopyFrom(const HandshakeMessage_ServerHello& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.HandshakeMessage.ServerHello) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool HandshakeMessage_ServerHello::IsInitialized() const { - return true; -} - -void HandshakeMessage_ServerHello::InternalSwap(HandshakeMessage_ServerHello* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.ephemeral_, lhs_arena, - &other->_impl_.ephemeral_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.static__, lhs_arena, - &other->_impl_.static__, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.payload_, lhs_arena, - &other->_impl_.payload_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata HandshakeMessage_ServerHello::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[37]); -} - -// =================================================================== - -class HandshakeMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::HandshakeMessage_ClientHello& clienthello(const HandshakeMessage* msg); - static void set_has_clienthello(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::proto::HandshakeMessage_ServerHello& serverhello(const HandshakeMessage* msg); - static void set_has_serverhello(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::proto::HandshakeMessage_ClientFinish& clientfinish(const HandshakeMessage* msg); - static void set_has_clientfinish(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } -}; - -const ::proto::HandshakeMessage_ClientHello& -HandshakeMessage::_Internal::clienthello(const HandshakeMessage* msg) { - return *msg->_impl_.clienthello_; -} -const ::proto::HandshakeMessage_ServerHello& -HandshakeMessage::_Internal::serverhello(const HandshakeMessage* msg) { - return *msg->_impl_.serverhello_; -} -const ::proto::HandshakeMessage_ClientFinish& -HandshakeMessage::_Internal::clientfinish(const HandshakeMessage* msg) { - return *msg->_impl_.clientfinish_; -} -HandshakeMessage::HandshakeMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.HandshakeMessage) -} -HandshakeMessage::HandshakeMessage(const HandshakeMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - HandshakeMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.clienthello_){nullptr} - , decltype(_impl_.serverhello_){nullptr} - , decltype(_impl_.clientfinish_){nullptr}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_clienthello()) { - _this->_impl_.clienthello_ = new ::proto::HandshakeMessage_ClientHello(*from._impl_.clienthello_); - } - if (from._internal_has_serverhello()) { - _this->_impl_.serverhello_ = new ::proto::HandshakeMessage_ServerHello(*from._impl_.serverhello_); - } - if (from._internal_has_clientfinish()) { - _this->_impl_.clientfinish_ = new ::proto::HandshakeMessage_ClientFinish(*from._impl_.clientfinish_); - } - // @@protoc_insertion_point(copy_constructor:proto.HandshakeMessage) -} - -inline void HandshakeMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.clienthello_){nullptr} - , decltype(_impl_.serverhello_){nullptr} - , decltype(_impl_.clientfinish_){nullptr} - }; -} - -HandshakeMessage::~HandshakeMessage() { - // @@protoc_insertion_point(destructor:proto.HandshakeMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void HandshakeMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete _impl_.clienthello_; - if (this != internal_default_instance()) delete _impl_.serverhello_; - if (this != internal_default_instance()) delete _impl_.clientfinish_; -} - -void HandshakeMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void HandshakeMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.HandshakeMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.clienthello_ != nullptr); - _impl_.clienthello_->Clear(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.serverhello_ != nullptr); - _impl_.serverhello_->Clear(); - } - if (cached_has_bits & 0x00000004u) { - GOOGLE_DCHECK(_impl_.clientfinish_ != nullptr); - _impl_.clientfinish_->Clear(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* HandshakeMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.HandshakeMessage.ClientHello clientHello = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_clienthello(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.HandshakeMessage.ServerHello serverHello = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_serverhello(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.HandshakeMessage.ClientFinish clientFinish = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_clientfinish(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* HandshakeMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.HandshakeMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.HandshakeMessage.ClientHello clientHello = 2; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::clienthello(this), - _Internal::clienthello(this).GetCachedSize(), target, stream); - } - - // optional .proto.HandshakeMessage.ServerHello serverHello = 3; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, _Internal::serverhello(this), - _Internal::serverhello(this).GetCachedSize(), target, stream); - } - - // optional .proto.HandshakeMessage.ClientFinish clientFinish = 4; - if (cached_has_bits & 0x00000004u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(4, _Internal::clientfinish(this), - _Internal::clientfinish(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.HandshakeMessage) - return target; -} - -size_t HandshakeMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.HandshakeMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional .proto.HandshakeMessage.ClientHello clientHello = 2; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.clienthello_); - } - - // optional .proto.HandshakeMessage.ServerHello serverHello = 3; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.serverhello_); - } - - // optional .proto.HandshakeMessage.ClientFinish clientFinish = 4; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.clientfinish_); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HandshakeMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - HandshakeMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HandshakeMessage::GetClassData() const { return &_class_data_; } - - -void HandshakeMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.HandshakeMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_mutable_clienthello()->::proto::HandshakeMessage_ClientHello::MergeFrom( - from._internal_clienthello()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_serverhello()->::proto::HandshakeMessage_ServerHello::MergeFrom( - from._internal_serverhello()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_mutable_clientfinish()->::proto::HandshakeMessage_ClientFinish::MergeFrom( - from._internal_clientfinish()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void HandshakeMessage::CopyFrom(const HandshakeMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.HandshakeMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool HandshakeMessage::IsInitialized() const { - return true; -} - -void HandshakeMessage::InternalSwap(HandshakeMessage* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(HandshakeMessage, _impl_.clientfinish_) - + sizeof(HandshakeMessage::_impl_.clientfinish_) - - PROTOBUF_FIELD_OFFSET(HandshakeMessage, _impl_.clienthello_)>( - reinterpret_cast(&_impl_.clienthello_), - reinterpret_cast(&other->_impl_.clienthello_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata HandshakeMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[38]); -} - -// =================================================================== - -class HistorySync::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_synctype(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_chunkorder(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_progress(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static const ::proto::GlobalSettings& globalsettings(const HistorySync* msg); - static void set_has_globalsettings(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_threadidusersecret(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_threaddstimeframeoffset(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static bool MissingRequiredFields(const HasBits& has_bits) { - return ((has_bits[0] & 0x00000004) ^ 0x00000004) != 0; - } -}; - -const ::proto::GlobalSettings& -HistorySync::_Internal::globalsettings(const HistorySync* msg) { - return *msg->_impl_.globalsettings_; -} -HistorySync::HistorySync(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.HistorySync) -} -HistorySync::HistorySync(const HistorySync& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - HistorySync* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.conversations_){from._impl_.conversations_} - , decltype(_impl_.statusv3messages_){from._impl_.statusv3messages_} - , decltype(_impl_.pushnames_){from._impl_.pushnames_} - , decltype(_impl_.recentstickers_){from._impl_.recentstickers_} - , decltype(_impl_.pastparticipants_){from._impl_.pastparticipants_} - , decltype(_impl_.threadidusersecret_){} - , decltype(_impl_.globalsettings_){nullptr} - , decltype(_impl_.synctype_){} - , decltype(_impl_.chunkorder_){} - , decltype(_impl_.progress_){} - , decltype(_impl_.threaddstimeframeoffset_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.threadidusersecret_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.threadidusersecret_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_threadidusersecret()) { - _this->_impl_.threadidusersecret_.Set(from._internal_threadidusersecret(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_globalsettings()) { - _this->_impl_.globalsettings_ = new ::proto::GlobalSettings(*from._impl_.globalsettings_); - } - ::memcpy(&_impl_.synctype_, &from._impl_.synctype_, - static_cast(reinterpret_cast(&_impl_.threaddstimeframeoffset_) - - reinterpret_cast(&_impl_.synctype_)) + sizeof(_impl_.threaddstimeframeoffset_)); - // @@protoc_insertion_point(copy_constructor:proto.HistorySync) -} - -inline void HistorySync::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.conversations_){arena} - , decltype(_impl_.statusv3messages_){arena} - , decltype(_impl_.pushnames_){arena} - , decltype(_impl_.recentstickers_){arena} - , decltype(_impl_.pastparticipants_){arena} - , decltype(_impl_.threadidusersecret_){} - , decltype(_impl_.globalsettings_){nullptr} - , decltype(_impl_.synctype_){0} - , decltype(_impl_.chunkorder_){0u} - , decltype(_impl_.progress_){0u} - , decltype(_impl_.threaddstimeframeoffset_){0u} - }; - _impl_.threadidusersecret_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.threadidusersecret_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -HistorySync::~HistorySync() { - // @@protoc_insertion_point(destructor:proto.HistorySync) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void HistorySync::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.conversations_.~RepeatedPtrField(); - _impl_.statusv3messages_.~RepeatedPtrField(); - _impl_.pushnames_.~RepeatedPtrField(); - _impl_.recentstickers_.~RepeatedPtrField(); - _impl_.pastparticipants_.~RepeatedPtrField(); - _impl_.threadidusersecret_.Destroy(); - if (this != internal_default_instance()) delete _impl_.globalsettings_; -} - -void HistorySync::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void HistorySync::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.HistorySync) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.conversations_.Clear(); - _impl_.statusv3messages_.Clear(); - _impl_.pushnames_.Clear(); - _impl_.recentstickers_.Clear(); - _impl_.pastparticipants_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.threadidusersecret_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.globalsettings_ != nullptr); - _impl_.globalsettings_->Clear(); - } - } - if (cached_has_bits & 0x0000003cu) { - ::memset(&_impl_.synctype_, 0, static_cast( - reinterpret_cast(&_impl_.threaddstimeframeoffset_) - - reinterpret_cast(&_impl_.synctype_)) + sizeof(_impl_.threaddstimeframeoffset_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* HistorySync::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // required .proto.HistorySync.HistorySyncType syncType = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::HistorySync_HistorySyncType_IsValid(val))) { - _internal_set_synctype(static_cast<::proto::HistorySync_HistorySyncType>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // repeated .proto.Conversation conversations = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_conversations(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else - goto handle_unusual; - continue; - // repeated .proto.WebMessageInfo statusV3Messages = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_statusv3messages(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); - } else - goto handle_unusual; - continue; - // optional uint32 chunkOrder = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { - _Internal::set_has_chunkorder(&has_bits); - _impl_.chunkorder_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 progress = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { - _Internal::set_has_progress(&has_bits); - _impl_.progress_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated .proto.Pushname pushnames = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_pushnames(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<58>(ptr)); - } else - goto handle_unusual; - continue; - // optional .proto.GlobalSettings globalSettings = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { - ptr = ctx->ParseMessage(_internal_mutable_globalsettings(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes threadIdUserSecret = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { - auto str = _internal_mutable_threadidusersecret(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 threadDsTimeframeOffset = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { - _Internal::set_has_threaddstimeframeoffset(&has_bits); - _impl_.threaddstimeframeoffset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated .proto.StickerMetadata recentStickers = 11; - case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_recentstickers(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<90>(ptr)); - } else - goto handle_unusual; - continue; - // repeated .proto.PastParticipants pastParticipants = 12; - case 12: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_pastparticipants(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<98>(ptr)); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* HistorySync::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.HistorySync) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // required .proto.HistorySync.HistorySyncType syncType = 1; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 1, this->_internal_synctype(), target); - } - - // repeated .proto.Conversation conversations = 2; - for (unsigned i = 0, - n = static_cast(this->_internal_conversations_size()); i < n; i++) { - const auto& repfield = this->_internal_conversations(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream); - } - - // repeated .proto.WebMessageInfo statusV3Messages = 3; - for (unsigned i = 0, - n = static_cast(this->_internal_statusv3messages_size()); i < n; i++) { - const auto& repfield = this->_internal_statusv3messages(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream); - } - - // optional uint32 chunkOrder = 5; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_chunkorder(), target); - } - - // optional uint32 progress = 6; - if (cached_has_bits & 0x00000010u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_progress(), target); - } - - // repeated .proto.Pushname pushnames = 7; - for (unsigned i = 0, - n = static_cast(this->_internal_pushnames_size()); i < n; i++) { - const auto& repfield = this->_internal_pushnames(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(7, repfield, repfield.GetCachedSize(), target, stream); - } - - // optional .proto.GlobalSettings globalSettings = 8; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(8, _Internal::globalsettings(this), - _Internal::globalsettings(this).GetCachedSize(), target, stream); - } - - // optional bytes threadIdUserSecret = 9; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 9, this->_internal_threadidusersecret(), target); - } - - // optional uint32 threadDsTimeframeOffset = 10; - if (cached_has_bits & 0x00000020u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(10, this->_internal_threaddstimeframeoffset(), target); - } - - // repeated .proto.StickerMetadata recentStickers = 11; - for (unsigned i = 0, - n = static_cast(this->_internal_recentstickers_size()); i < n; i++) { - const auto& repfield = this->_internal_recentstickers(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(11, repfield, repfield.GetCachedSize(), target, stream); - } - - // repeated .proto.PastParticipants pastParticipants = 12; - for (unsigned i = 0, - n = static_cast(this->_internal_pastparticipants_size()); i < n; i++) { - const auto& repfield = this->_internal_pastparticipants(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(12, repfield, repfield.GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.HistorySync) - return target; -} - -size_t HistorySync::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.HistorySync) - size_t total_size = 0; - - // required .proto.HistorySync.HistorySyncType syncType = 1; - if (_internal_has_synctype()) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_synctype()); - } - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.Conversation conversations = 2; - total_size += 1UL * this->_internal_conversations_size(); - for (const auto& msg : this->_impl_.conversations_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // repeated .proto.WebMessageInfo statusV3Messages = 3; - total_size += 1UL * this->_internal_statusv3messages_size(); - for (const auto& msg : this->_impl_.statusv3messages_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // repeated .proto.Pushname pushnames = 7; - total_size += 1UL * this->_internal_pushnames_size(); - for (const auto& msg : this->_impl_.pushnames_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // repeated .proto.StickerMetadata recentStickers = 11; - total_size += 1UL * this->_internal_recentstickers_size(); - for (const auto& msg : this->_impl_.recentstickers_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // repeated .proto.PastParticipants pastParticipants = 12; - total_size += 1UL * this->_internal_pastparticipants_size(); - for (const auto& msg : this->_impl_.pastparticipants_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional bytes threadIdUserSecret = 9; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_threadidusersecret()); - } - - // optional .proto.GlobalSettings globalSettings = 8; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.globalsettings_); - } - - } - if (cached_has_bits & 0x00000038u) { - // optional uint32 chunkOrder = 5; - if (cached_has_bits & 0x00000008u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_chunkorder()); - } - - // optional uint32 progress = 6; - if (cached_has_bits & 0x00000010u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_progress()); - } - - // optional uint32 threadDsTimeframeOffset = 10; - if (cached_has_bits & 0x00000020u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_threaddstimeframeoffset()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HistorySync::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - HistorySync::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HistorySync::GetClassData() const { return &_class_data_; } - - -void HistorySync::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.HistorySync) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.conversations_.MergeFrom(from._impl_.conversations_); - _this->_impl_.statusv3messages_.MergeFrom(from._impl_.statusv3messages_); - _this->_impl_.pushnames_.MergeFrom(from._impl_.pushnames_); - _this->_impl_.recentstickers_.MergeFrom(from._impl_.recentstickers_); - _this->_impl_.pastparticipants_.MergeFrom(from._impl_.pastparticipants_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000003fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_threadidusersecret(from._internal_threadidusersecret()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_globalsettings()->::proto::GlobalSettings::MergeFrom( - from._internal_globalsettings()); - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.synctype_ = from._impl_.synctype_; - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.chunkorder_ = from._impl_.chunkorder_; - } - if (cached_has_bits & 0x00000010u) { - _this->_impl_.progress_ = from._impl_.progress_; - } - if (cached_has_bits & 0x00000020u) { - _this->_impl_.threaddstimeframeoffset_ = from._impl_.threaddstimeframeoffset_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void HistorySync::CopyFrom(const HistorySync& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.HistorySync) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool HistorySync::IsInitialized() const { - if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false; - if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.conversations_)) - return false; - if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.statusv3messages_)) - return false; - if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.pastparticipants_)) - return false; - return true; -} - -void HistorySync::InternalSwap(HistorySync* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.conversations_.InternalSwap(&other->_impl_.conversations_); - _impl_.statusv3messages_.InternalSwap(&other->_impl_.statusv3messages_); - _impl_.pushnames_.InternalSwap(&other->_impl_.pushnames_); - _impl_.recentstickers_.InternalSwap(&other->_impl_.recentstickers_); - _impl_.pastparticipants_.InternalSwap(&other->_impl_.pastparticipants_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.threadidusersecret_, lhs_arena, - &other->_impl_.threadidusersecret_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(HistorySync, _impl_.threaddstimeframeoffset_) - + sizeof(HistorySync::_impl_.threaddstimeframeoffset_) - - PROTOBUF_FIELD_OFFSET(HistorySync, _impl_.globalsettings_)>( - reinterpret_cast(&_impl_.globalsettings_), - reinterpret_cast(&other->_impl_.globalsettings_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata HistorySync::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[39]); -} - -// =================================================================== - -class HistorySyncMsg::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::WebMessageInfo& message(const HistorySyncMsg* msg); - static void set_has_message(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_msgorderid(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -const ::proto::WebMessageInfo& -HistorySyncMsg::_Internal::message(const HistorySyncMsg* msg) { - return *msg->_impl_.message_; -} -HistorySyncMsg::HistorySyncMsg(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.HistorySyncMsg) -} -HistorySyncMsg::HistorySyncMsg(const HistorySyncMsg& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - HistorySyncMsg* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.message_){nullptr} - , decltype(_impl_.msgorderid_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_message()) { - _this->_impl_.message_ = new ::proto::WebMessageInfo(*from._impl_.message_); - } - _this->_impl_.msgorderid_ = from._impl_.msgorderid_; - // @@protoc_insertion_point(copy_constructor:proto.HistorySyncMsg) -} - -inline void HistorySyncMsg::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.message_){nullptr} - , decltype(_impl_.msgorderid_){uint64_t{0u}} - }; -} - -HistorySyncMsg::~HistorySyncMsg() { - // @@protoc_insertion_point(destructor:proto.HistorySyncMsg) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void HistorySyncMsg::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete _impl_.message_; -} - -void HistorySyncMsg::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void HistorySyncMsg::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.HistorySyncMsg) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.message_ != nullptr); - _impl_.message_->Clear(); - } - _impl_.msgorderid_ = uint64_t{0u}; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* HistorySyncMsg::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.WebMessageInfo message = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_message(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint64 msgOrderId = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_msgorderid(&has_bits); - _impl_.msgorderid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* HistorySyncMsg::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.HistorySyncMsg) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.WebMessageInfo message = 1; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::message(this), - _Internal::message(this).GetCachedSize(), target, stream); - } - - // optional uint64 msgOrderId = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_msgorderid(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.HistorySyncMsg) - return target; -} - -size_t HistorySyncMsg::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.HistorySyncMsg) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional .proto.WebMessageInfo message = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.message_); - } - - // optional uint64 msgOrderId = 2; - if (cached_has_bits & 0x00000002u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_msgorderid()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HistorySyncMsg::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - HistorySyncMsg::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HistorySyncMsg::GetClassData() const { return &_class_data_; } - - -void HistorySyncMsg::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.HistorySyncMsg) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_mutable_message()->::proto::WebMessageInfo::MergeFrom( - from._internal_message()); - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.msgorderid_ = from._impl_.msgorderid_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void HistorySyncMsg::CopyFrom(const HistorySyncMsg& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.HistorySyncMsg) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool HistorySyncMsg::IsInitialized() const { - if (_internal_has_message()) { - if (!_impl_.message_->IsInitialized()) return false; - } - return true; -} - -void HistorySyncMsg::InternalSwap(HistorySyncMsg* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(HistorySyncMsg, _impl_.msgorderid_) - + sizeof(HistorySyncMsg::_impl_.msgorderid_) - - PROTOBUF_FIELD_OFFSET(HistorySyncMsg, _impl_.message_)>( - reinterpret_cast(&_impl_.message_), - reinterpret_cast(&other->_impl_.message_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata HistorySyncMsg::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[40]); -} - -// =================================================================== - -class HydratedTemplateButton_HydratedCallButton::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_displaytext(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_phonenumber(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -HydratedTemplateButton_HydratedCallButton::HydratedTemplateButton_HydratedCallButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.HydratedTemplateButton.HydratedCallButton) -} -HydratedTemplateButton_HydratedCallButton::HydratedTemplateButton_HydratedCallButton(const HydratedTemplateButton_HydratedCallButton& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - HydratedTemplateButton_HydratedCallButton* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.displaytext_){} - , decltype(_impl_.phonenumber_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.displaytext_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.displaytext_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_displaytext()) { - _this->_impl_.displaytext_.Set(from._internal_displaytext(), - _this->GetArenaForAllocation()); - } - _impl_.phonenumber_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.phonenumber_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_phonenumber()) { - _this->_impl_.phonenumber_.Set(from._internal_phonenumber(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.HydratedTemplateButton.HydratedCallButton) -} - -inline void HydratedTemplateButton_HydratedCallButton::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.displaytext_){} - , decltype(_impl_.phonenumber_){} - }; - _impl_.displaytext_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.displaytext_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.phonenumber_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.phonenumber_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -HydratedTemplateButton_HydratedCallButton::~HydratedTemplateButton_HydratedCallButton() { - // @@protoc_insertion_point(destructor:proto.HydratedTemplateButton.HydratedCallButton) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void HydratedTemplateButton_HydratedCallButton::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.displaytext_.Destroy(); - _impl_.phonenumber_.Destroy(); -} - -void HydratedTemplateButton_HydratedCallButton::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void HydratedTemplateButton_HydratedCallButton::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.HydratedTemplateButton.HydratedCallButton) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.displaytext_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.phonenumber_.ClearNonDefaultToEmpty(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* HydratedTemplateButton_HydratedCallButton::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string displayText = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_displaytext(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.HydratedTemplateButton.HydratedCallButton.displayText"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string phoneNumber = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_phonenumber(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.HydratedTemplateButton.HydratedCallButton.phoneNumber"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* HydratedTemplateButton_HydratedCallButton::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.HydratedTemplateButton.HydratedCallButton) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string displayText = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_displaytext().data(), static_cast(this->_internal_displaytext().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.HydratedTemplateButton.HydratedCallButton.displayText"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_displaytext(), target); - } - - // optional string phoneNumber = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_phonenumber().data(), static_cast(this->_internal_phonenumber().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.HydratedTemplateButton.HydratedCallButton.phoneNumber"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_phonenumber(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.HydratedTemplateButton.HydratedCallButton) - return target; -} - -size_t HydratedTemplateButton_HydratedCallButton::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.HydratedTemplateButton.HydratedCallButton) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional string displayText = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_displaytext()); - } - - // optional string phoneNumber = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_phonenumber()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HydratedTemplateButton_HydratedCallButton::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - HydratedTemplateButton_HydratedCallButton::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HydratedTemplateButton_HydratedCallButton::GetClassData() const { return &_class_data_; } - - -void HydratedTemplateButton_HydratedCallButton::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.HydratedTemplateButton.HydratedCallButton) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_displaytext(from._internal_displaytext()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_phonenumber(from._internal_phonenumber()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void HydratedTemplateButton_HydratedCallButton::CopyFrom(const HydratedTemplateButton_HydratedCallButton& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.HydratedTemplateButton.HydratedCallButton) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool HydratedTemplateButton_HydratedCallButton::IsInitialized() const { - return true; -} - -void HydratedTemplateButton_HydratedCallButton::InternalSwap(HydratedTemplateButton_HydratedCallButton* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.displaytext_, lhs_arena, - &other->_impl_.displaytext_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.phonenumber_, lhs_arena, - &other->_impl_.phonenumber_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata HydratedTemplateButton_HydratedCallButton::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[41]); -} - -// =================================================================== - -class HydratedTemplateButton_HydratedQuickReplyButton::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_displaytext(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_id(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -HydratedTemplateButton_HydratedQuickReplyButton::HydratedTemplateButton_HydratedQuickReplyButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.HydratedTemplateButton.HydratedQuickReplyButton) -} -HydratedTemplateButton_HydratedQuickReplyButton::HydratedTemplateButton_HydratedQuickReplyButton(const HydratedTemplateButton_HydratedQuickReplyButton& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - HydratedTemplateButton_HydratedQuickReplyButton* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.displaytext_){} - , decltype(_impl_.id_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.displaytext_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.displaytext_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_displaytext()) { - _this->_impl_.displaytext_.Set(from._internal_displaytext(), - _this->GetArenaForAllocation()); - } - _impl_.id_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.id_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_id()) { - _this->_impl_.id_.Set(from._internal_id(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.HydratedTemplateButton.HydratedQuickReplyButton) -} - -inline void HydratedTemplateButton_HydratedQuickReplyButton::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.displaytext_){} - , decltype(_impl_.id_){} - }; - _impl_.displaytext_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.displaytext_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.id_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.id_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -HydratedTemplateButton_HydratedQuickReplyButton::~HydratedTemplateButton_HydratedQuickReplyButton() { - // @@protoc_insertion_point(destructor:proto.HydratedTemplateButton.HydratedQuickReplyButton) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void HydratedTemplateButton_HydratedQuickReplyButton::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.displaytext_.Destroy(); - _impl_.id_.Destroy(); -} - -void HydratedTemplateButton_HydratedQuickReplyButton::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void HydratedTemplateButton_HydratedQuickReplyButton::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.HydratedTemplateButton.HydratedQuickReplyButton) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.displaytext_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.id_.ClearNonDefaultToEmpty(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* HydratedTemplateButton_HydratedQuickReplyButton::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string displayText = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_displaytext(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.HydratedTemplateButton.HydratedQuickReplyButton.displayText"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string id = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_id(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.HydratedTemplateButton.HydratedQuickReplyButton.id"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* HydratedTemplateButton_HydratedQuickReplyButton::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.HydratedTemplateButton.HydratedQuickReplyButton) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string displayText = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_displaytext().data(), static_cast(this->_internal_displaytext().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.HydratedTemplateButton.HydratedQuickReplyButton.displayText"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_displaytext(), target); - } - - // optional string id = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_id().data(), static_cast(this->_internal_id().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.HydratedTemplateButton.HydratedQuickReplyButton.id"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_id(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.HydratedTemplateButton.HydratedQuickReplyButton) - return target; -} - -size_t HydratedTemplateButton_HydratedQuickReplyButton::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.HydratedTemplateButton.HydratedQuickReplyButton) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional string displayText = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_displaytext()); - } - - // optional string id = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_id()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HydratedTemplateButton_HydratedQuickReplyButton::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - HydratedTemplateButton_HydratedQuickReplyButton::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HydratedTemplateButton_HydratedQuickReplyButton::GetClassData() const { return &_class_data_; } - - -void HydratedTemplateButton_HydratedQuickReplyButton::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.HydratedTemplateButton.HydratedQuickReplyButton) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_displaytext(from._internal_displaytext()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_id(from._internal_id()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void HydratedTemplateButton_HydratedQuickReplyButton::CopyFrom(const HydratedTemplateButton_HydratedQuickReplyButton& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.HydratedTemplateButton.HydratedQuickReplyButton) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool HydratedTemplateButton_HydratedQuickReplyButton::IsInitialized() const { - return true; -} - -void HydratedTemplateButton_HydratedQuickReplyButton::InternalSwap(HydratedTemplateButton_HydratedQuickReplyButton* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.displaytext_, lhs_arena, - &other->_impl_.displaytext_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.id_, lhs_arena, - &other->_impl_.id_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata HydratedTemplateButton_HydratedQuickReplyButton::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[42]); -} - -// =================================================================== - -class HydratedTemplateButton_HydratedURLButton::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_displaytext(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_url(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -HydratedTemplateButton_HydratedURLButton::HydratedTemplateButton_HydratedURLButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.HydratedTemplateButton.HydratedURLButton) -} -HydratedTemplateButton_HydratedURLButton::HydratedTemplateButton_HydratedURLButton(const HydratedTemplateButton_HydratedURLButton& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - HydratedTemplateButton_HydratedURLButton* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.displaytext_){} - , decltype(_impl_.url_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.displaytext_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.displaytext_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_displaytext()) { - _this->_impl_.displaytext_.Set(from._internal_displaytext(), - _this->GetArenaForAllocation()); - } - _impl_.url_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.url_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_url()) { - _this->_impl_.url_.Set(from._internal_url(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.HydratedTemplateButton.HydratedURLButton) -} - -inline void HydratedTemplateButton_HydratedURLButton::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.displaytext_){} - , decltype(_impl_.url_){} - }; - _impl_.displaytext_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.displaytext_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.url_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.url_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -HydratedTemplateButton_HydratedURLButton::~HydratedTemplateButton_HydratedURLButton() { - // @@protoc_insertion_point(destructor:proto.HydratedTemplateButton.HydratedURLButton) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void HydratedTemplateButton_HydratedURLButton::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.displaytext_.Destroy(); - _impl_.url_.Destroy(); -} - -void HydratedTemplateButton_HydratedURLButton::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void HydratedTemplateButton_HydratedURLButton::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.HydratedTemplateButton.HydratedURLButton) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.displaytext_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.url_.ClearNonDefaultToEmpty(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* HydratedTemplateButton_HydratedURLButton::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string displayText = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_displaytext(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.HydratedTemplateButton.HydratedURLButton.displayText"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string url = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_url(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.HydratedTemplateButton.HydratedURLButton.url"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* HydratedTemplateButton_HydratedURLButton::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.HydratedTemplateButton.HydratedURLButton) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string displayText = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_displaytext().data(), static_cast(this->_internal_displaytext().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.HydratedTemplateButton.HydratedURLButton.displayText"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_displaytext(), target); - } - - // optional string url = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_url().data(), static_cast(this->_internal_url().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.HydratedTemplateButton.HydratedURLButton.url"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_url(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.HydratedTemplateButton.HydratedURLButton) - return target; -} - -size_t HydratedTemplateButton_HydratedURLButton::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.HydratedTemplateButton.HydratedURLButton) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional string displayText = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_displaytext()); - } - - // optional string url = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_url()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HydratedTemplateButton_HydratedURLButton::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - HydratedTemplateButton_HydratedURLButton::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HydratedTemplateButton_HydratedURLButton::GetClassData() const { return &_class_data_; } - - -void HydratedTemplateButton_HydratedURLButton::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.HydratedTemplateButton.HydratedURLButton) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_displaytext(from._internal_displaytext()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_url(from._internal_url()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void HydratedTemplateButton_HydratedURLButton::CopyFrom(const HydratedTemplateButton_HydratedURLButton& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.HydratedTemplateButton.HydratedURLButton) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool HydratedTemplateButton_HydratedURLButton::IsInitialized() const { - return true; -} - -void HydratedTemplateButton_HydratedURLButton::InternalSwap(HydratedTemplateButton_HydratedURLButton* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.displaytext_, lhs_arena, - &other->_impl_.displaytext_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.url_, lhs_arena, - &other->_impl_.url_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata HydratedTemplateButton_HydratedURLButton::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[43]); -} - -// =================================================================== - -class HydratedTemplateButton::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_index(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::proto::HydratedTemplateButton_HydratedQuickReplyButton& quickreplybutton(const HydratedTemplateButton* msg); - static const ::proto::HydratedTemplateButton_HydratedURLButton& urlbutton(const HydratedTemplateButton* msg); - static const ::proto::HydratedTemplateButton_HydratedCallButton& callbutton(const HydratedTemplateButton* msg); -}; - -const ::proto::HydratedTemplateButton_HydratedQuickReplyButton& -HydratedTemplateButton::_Internal::quickreplybutton(const HydratedTemplateButton* msg) { - return *msg->_impl_.hydratedButton_.quickreplybutton_; -} -const ::proto::HydratedTemplateButton_HydratedURLButton& -HydratedTemplateButton::_Internal::urlbutton(const HydratedTemplateButton* msg) { - return *msg->_impl_.hydratedButton_.urlbutton_; -} -const ::proto::HydratedTemplateButton_HydratedCallButton& -HydratedTemplateButton::_Internal::callbutton(const HydratedTemplateButton* msg) { - return *msg->_impl_.hydratedButton_.callbutton_; -} -void HydratedTemplateButton::set_allocated_quickreplybutton(::proto::HydratedTemplateButton_HydratedQuickReplyButton* quickreplybutton) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_hydratedButton(); - if (quickreplybutton) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quickreplybutton); - if (message_arena != submessage_arena) { - quickreplybutton = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, quickreplybutton, submessage_arena); - } - set_has_quickreplybutton(); - _impl_.hydratedButton_.quickreplybutton_ = quickreplybutton; - } - // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.quickReplyButton) -} -void HydratedTemplateButton::set_allocated_urlbutton(::proto::HydratedTemplateButton_HydratedURLButton* urlbutton) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_hydratedButton(); - if (urlbutton) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(urlbutton); - if (message_arena != submessage_arena) { - urlbutton = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, urlbutton, submessage_arena); - } - set_has_urlbutton(); - _impl_.hydratedButton_.urlbutton_ = urlbutton; - } - // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.urlButton) -} -void HydratedTemplateButton::set_allocated_callbutton(::proto::HydratedTemplateButton_HydratedCallButton* callbutton) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_hydratedButton(); - if (callbutton) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(callbutton); - if (message_arena != submessage_arena) { - callbutton = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, callbutton, submessage_arena); - } - set_has_callbutton(); - _impl_.hydratedButton_.callbutton_ = callbutton; - } - // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.callButton) -} -HydratedTemplateButton::HydratedTemplateButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.HydratedTemplateButton) -} -HydratedTemplateButton::HydratedTemplateButton(const HydratedTemplateButton& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - HydratedTemplateButton* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.index_){} - , decltype(_impl_.hydratedButton_){} - , /*decltype(_impl_._oneof_case_)*/{}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _this->_impl_.index_ = from._impl_.index_; - clear_has_hydratedButton(); - switch (from.hydratedButton_case()) { - case kQuickReplyButton: { - _this->_internal_mutable_quickreplybutton()->::proto::HydratedTemplateButton_HydratedQuickReplyButton::MergeFrom( - from._internal_quickreplybutton()); - break; - } - case kUrlButton: { - _this->_internal_mutable_urlbutton()->::proto::HydratedTemplateButton_HydratedURLButton::MergeFrom( - from._internal_urlbutton()); - break; - } - case kCallButton: { - _this->_internal_mutable_callbutton()->::proto::HydratedTemplateButton_HydratedCallButton::MergeFrom( - from._internal_callbutton()); - break; - } - case HYDRATEDBUTTON_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:proto.HydratedTemplateButton) -} - -inline void HydratedTemplateButton::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.index_){0u} - , decltype(_impl_.hydratedButton_){} - , /*decltype(_impl_._oneof_case_)*/{} - }; - clear_has_hydratedButton(); -} - -HydratedTemplateButton::~HydratedTemplateButton() { - // @@protoc_insertion_point(destructor:proto.HydratedTemplateButton) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void HydratedTemplateButton::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (has_hydratedButton()) { - clear_hydratedButton(); - } -} - -void HydratedTemplateButton::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void HydratedTemplateButton::clear_hydratedButton() { -// @@protoc_insertion_point(one_of_clear_start:proto.HydratedTemplateButton) - switch (hydratedButton_case()) { - case kQuickReplyButton: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.hydratedButton_.quickreplybutton_; - } - break; - } - case kUrlButton: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.hydratedButton_.urlbutton_; - } - break; - } - case kCallButton: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.hydratedButton_.callbutton_; - } - break; - } - case HYDRATEDBUTTON_NOT_SET: { - break; - } - } - _impl_._oneof_case_[0] = HYDRATEDBUTTON_NOT_SET; -} - - -void HydratedTemplateButton::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.HydratedTemplateButton) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.index_ = 0u; - clear_hydratedButton(); - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* HydratedTemplateButton::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .proto.HydratedTemplateButton.HydratedQuickReplyButton quickReplyButton = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_quickreplybutton(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .proto.HydratedTemplateButton.HydratedURLButton urlButton = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_urlbutton(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .proto.HydratedTemplateButton.HydratedCallButton callButton = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_callbutton(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 index = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - _Internal::set_has_index(&has_bits); - _impl_.index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* HydratedTemplateButton::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.HydratedTemplateButton) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - switch (hydratedButton_case()) { - case kQuickReplyButton: { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::quickreplybutton(this), - _Internal::quickreplybutton(this).GetCachedSize(), target, stream); - break; - } - case kUrlButton: { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::urlbutton(this), - _Internal::urlbutton(this).GetCachedSize(), target, stream); - break; - } - case kCallButton: { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, _Internal::callbutton(this), - _Internal::callbutton(this).GetCachedSize(), target, stream); - break; - } - default: ; - } - cached_has_bits = _impl_._has_bits_[0]; - // optional uint32 index = 4; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_index(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.HydratedTemplateButton) - return target; -} - -size_t HydratedTemplateButton::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.HydratedTemplateButton) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional uint32 index = 4; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_index()); - } - - switch (hydratedButton_case()) { - // .proto.HydratedTemplateButton.HydratedQuickReplyButton quickReplyButton = 1; - case kQuickReplyButton: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.hydratedButton_.quickreplybutton_); - break; - } - // .proto.HydratedTemplateButton.HydratedURLButton urlButton = 2; - case kUrlButton: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.hydratedButton_.urlbutton_); - break; - } - // .proto.HydratedTemplateButton.HydratedCallButton callButton = 3; - case kCallButton: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.hydratedButton_.callbutton_); - break; - } - case HYDRATEDBUTTON_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HydratedTemplateButton::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - HydratedTemplateButton::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HydratedTemplateButton::GetClassData() const { return &_class_data_; } - - -void HydratedTemplateButton::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.HydratedTemplateButton) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_index()) { - _this->_internal_set_index(from._internal_index()); - } - switch (from.hydratedButton_case()) { - case kQuickReplyButton: { - _this->_internal_mutable_quickreplybutton()->::proto::HydratedTemplateButton_HydratedQuickReplyButton::MergeFrom( - from._internal_quickreplybutton()); - break; - } - case kUrlButton: { - _this->_internal_mutable_urlbutton()->::proto::HydratedTemplateButton_HydratedURLButton::MergeFrom( - from._internal_urlbutton()); - break; - } - case kCallButton: { - _this->_internal_mutable_callbutton()->::proto::HydratedTemplateButton_HydratedCallButton::MergeFrom( - from._internal_callbutton()); - break; - } - case HYDRATEDBUTTON_NOT_SET: { - break; - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void HydratedTemplateButton::CopyFrom(const HydratedTemplateButton& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.HydratedTemplateButton) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool HydratedTemplateButton::IsInitialized() const { - return true; -} - -void HydratedTemplateButton::InternalSwap(HydratedTemplateButton* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - swap(_impl_.index_, other->_impl_.index_); - swap(_impl_.hydratedButton_, other->_impl_.hydratedButton_); - swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata HydratedTemplateButton::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[44]); -} - -// =================================================================== - -class IdentityKeyPairStructure::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_publickey(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_privatekey(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -IdentityKeyPairStructure::IdentityKeyPairStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.IdentityKeyPairStructure) -} -IdentityKeyPairStructure::IdentityKeyPairStructure(const IdentityKeyPairStructure& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - IdentityKeyPairStructure* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.publickey_){} - , decltype(_impl_.privatekey_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.publickey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.publickey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_publickey()) { - _this->_impl_.publickey_.Set(from._internal_publickey(), - _this->GetArenaForAllocation()); - } - _impl_.privatekey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.privatekey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_privatekey()) { - _this->_impl_.privatekey_.Set(from._internal_privatekey(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.IdentityKeyPairStructure) -} - -inline void IdentityKeyPairStructure::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.publickey_){} - , decltype(_impl_.privatekey_){} - }; - _impl_.publickey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.publickey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.privatekey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.privatekey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -IdentityKeyPairStructure::~IdentityKeyPairStructure() { - // @@protoc_insertion_point(destructor:proto.IdentityKeyPairStructure) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void IdentityKeyPairStructure::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.publickey_.Destroy(); - _impl_.privatekey_.Destroy(); -} - -void IdentityKeyPairStructure::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void IdentityKeyPairStructure::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.IdentityKeyPairStructure) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.publickey_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.privatekey_.ClearNonDefaultToEmpty(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* IdentityKeyPairStructure::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bytes publicKey = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_publickey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes privateKey = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_privatekey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* IdentityKeyPairStructure::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.IdentityKeyPairStructure) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bytes publicKey = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 1, this->_internal_publickey(), target); - } - - // optional bytes privateKey = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_privatekey(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.IdentityKeyPairStructure) - return target; -} - -size_t IdentityKeyPairStructure::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.IdentityKeyPairStructure) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional bytes publicKey = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_publickey()); - } - - // optional bytes privateKey = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_privatekey()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData IdentityKeyPairStructure::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - IdentityKeyPairStructure::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*IdentityKeyPairStructure::GetClassData() const { return &_class_data_; } - - -void IdentityKeyPairStructure::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.IdentityKeyPairStructure) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_publickey(from._internal_publickey()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_privatekey(from._internal_privatekey()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void IdentityKeyPairStructure::CopyFrom(const IdentityKeyPairStructure& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.IdentityKeyPairStructure) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool IdentityKeyPairStructure::IsInitialized() const { - return true; -} - -void IdentityKeyPairStructure::InternalSwap(IdentityKeyPairStructure* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.publickey_, lhs_arena, - &other->_impl_.publickey_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.privatekey_, lhs_arena, - &other->_impl_.privatekey_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata IdentityKeyPairStructure::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[45]); -} - -// =================================================================== - -class InteractiveAnnotation::_Internal { - public: - static const ::proto::Location& location(const InteractiveAnnotation* msg); -}; - -const ::proto::Location& -InteractiveAnnotation::_Internal::location(const InteractiveAnnotation* msg) { - return *msg->_impl_.action_.location_; -} -void InteractiveAnnotation::set_allocated_location(::proto::Location* location) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_action(); - if (location) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(location); - if (message_arena != submessage_arena) { - location = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, location, submessage_arena); - } - set_has_location(); - _impl_.action_.location_ = location; - } - // @@protoc_insertion_point(field_set_allocated:proto.InteractiveAnnotation.location) -} -InteractiveAnnotation::InteractiveAnnotation(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.InteractiveAnnotation) -} -InteractiveAnnotation::InteractiveAnnotation(const InteractiveAnnotation& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - InteractiveAnnotation* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_.polygonvertices_){from._impl_.polygonvertices_} - , decltype(_impl_.action_){} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_._oneof_case_)*/{}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - clear_has_action(); - switch (from.action_case()) { - case kLocation: { - _this->_internal_mutable_location()->::proto::Location::MergeFrom( - from._internal_location()); - break; - } - case ACTION_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:proto.InteractiveAnnotation) -} - -inline void InteractiveAnnotation::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_.polygonvertices_){arena} - , decltype(_impl_.action_){} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_._oneof_case_)*/{} - }; - clear_has_action(); -} - -InteractiveAnnotation::~InteractiveAnnotation() { - // @@protoc_insertion_point(destructor:proto.InteractiveAnnotation) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void InteractiveAnnotation::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.polygonvertices_.~RepeatedPtrField(); - if (has_action()) { - clear_action(); - } -} - -void InteractiveAnnotation::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void InteractiveAnnotation::clear_action() { -// @@protoc_insertion_point(one_of_clear_start:proto.InteractiveAnnotation) - switch (action_case()) { - case kLocation: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.action_.location_; - } - break; - } - case ACTION_NOT_SET: { - break; - } - } - _impl_._oneof_case_[0] = ACTION_NOT_SET; -} - - -void InteractiveAnnotation::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.InteractiveAnnotation) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.polygonvertices_.Clear(); - clear_action(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* InteractiveAnnotation::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated .proto.Point polygonVertices = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_polygonvertices(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else - goto handle_unusual; - continue; - // .proto.Location location = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_location(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* InteractiveAnnotation::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.InteractiveAnnotation) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .proto.Point polygonVertices = 1; - for (unsigned i = 0, - n = static_cast(this->_internal_polygonvertices_size()); i < n; i++) { - const auto& repfield = this->_internal_polygonvertices(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream); - } - - // .proto.Location location = 2; - if (_internal_has_location()) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::location(this), - _Internal::location(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.InteractiveAnnotation) - return target; -} - -size_t InteractiveAnnotation::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.InteractiveAnnotation) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.Point polygonVertices = 1; - total_size += 1UL * this->_internal_polygonvertices_size(); - for (const auto& msg : this->_impl_.polygonvertices_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - switch (action_case()) { - // .proto.Location location = 2; - case kLocation: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.action_.location_); - break; - } - case ACTION_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData InteractiveAnnotation::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - InteractiveAnnotation::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*InteractiveAnnotation::GetClassData() const { return &_class_data_; } - - -void InteractiveAnnotation::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.InteractiveAnnotation) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.polygonvertices_.MergeFrom(from._impl_.polygonvertices_); - switch (from.action_case()) { - case kLocation: { - _this->_internal_mutable_location()->::proto::Location::MergeFrom( - from._internal_location()); - break; - } - case ACTION_NOT_SET: { - break; - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void InteractiveAnnotation::CopyFrom(const InteractiveAnnotation& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.InteractiveAnnotation) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool InteractiveAnnotation::IsInitialized() const { - return true; -} - -void InteractiveAnnotation::InternalSwap(InteractiveAnnotation* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - _impl_.polygonvertices_.InternalSwap(&other->_impl_.polygonvertices_); - swap(_impl_.action_, other->_impl_.action_); - swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata InteractiveAnnotation::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[46]); -} - -// =================================================================== - -class KeepInChat::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_keeptype(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_servertimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static const ::proto::MessageKey& key(const KeepInChat* msg); - static void set_has_key(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_devicejid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -const ::proto::MessageKey& -KeepInChat::_Internal::key(const KeepInChat* msg) { - return *msg->_impl_.key_; -} -KeepInChat::KeepInChat(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.KeepInChat) -} -KeepInChat::KeepInChat(const KeepInChat& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - KeepInChat* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.devicejid_){} - , decltype(_impl_.key_){nullptr} - , decltype(_impl_.servertimestamp_){} - , decltype(_impl_.keeptype_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.devicejid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.devicejid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_devicejid()) { - _this->_impl_.devicejid_.Set(from._internal_devicejid(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_key()) { - _this->_impl_.key_ = new ::proto::MessageKey(*from._impl_.key_); - } - ::memcpy(&_impl_.servertimestamp_, &from._impl_.servertimestamp_, - static_cast(reinterpret_cast(&_impl_.keeptype_) - - reinterpret_cast(&_impl_.servertimestamp_)) + sizeof(_impl_.keeptype_)); - // @@protoc_insertion_point(copy_constructor:proto.KeepInChat) -} - -inline void KeepInChat::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.devicejid_){} - , decltype(_impl_.key_){nullptr} - , decltype(_impl_.servertimestamp_){int64_t{0}} - , decltype(_impl_.keeptype_){0} - }; - _impl_.devicejid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.devicejid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -KeepInChat::~KeepInChat() { - // @@protoc_insertion_point(destructor:proto.KeepInChat) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void KeepInChat::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.devicejid_.Destroy(); - if (this != internal_default_instance()) delete _impl_.key_; -} - -void KeepInChat::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void KeepInChat::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.KeepInChat) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.devicejid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.key_ != nullptr); - _impl_.key_->Clear(); - } - } - if (cached_has_bits & 0x0000000cu) { - ::memset(&_impl_.servertimestamp_, 0, static_cast( - reinterpret_cast(&_impl_.keeptype_) - - reinterpret_cast(&_impl_.servertimestamp_)) + sizeof(_impl_.keeptype_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* KeepInChat::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.KeepType keepType = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::KeepType_IsValid(val))) { - _internal_set_keeptype(static_cast<::proto::KeepType>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional int64 serverTimestamp = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_servertimestamp(&has_bits); - _impl_.servertimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.MessageKey key = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string deviceJid = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - auto str = _internal_mutable_devicejid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.KeepInChat.deviceJid"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* KeepInChat::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.KeepInChat) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.KeepType keepType = 1; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 1, this->_internal_keeptype(), target); - } - - // optional int64 serverTimestamp = 2; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_servertimestamp(), target); - } - - // optional .proto.MessageKey key = 3; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, _Internal::key(this), - _Internal::key(this).GetCachedSize(), target, stream); - } - - // optional string deviceJid = 4; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_devicejid().data(), static_cast(this->_internal_devicejid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.KeepInChat.deviceJid"); - target = stream->WriteStringMaybeAliased( - 4, this->_internal_devicejid(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.KeepInChat) - return target; -} - -size_t KeepInChat::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.KeepInChat) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - // optional string deviceJid = 4; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_devicejid()); - } - - // optional .proto.MessageKey key = 3; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.key_); - } - - // optional int64 serverTimestamp = 2; - if (cached_has_bits & 0x00000004u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_servertimestamp()); - } - - // optional .proto.KeepType keepType = 1; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_keeptype()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData KeepInChat::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - KeepInChat::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*KeepInChat::GetClassData() const { return &_class_data_; } - - -void KeepInChat::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.KeepInChat) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_devicejid(from._internal_devicejid()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_key()->::proto::MessageKey::MergeFrom( - from._internal_key()); - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.servertimestamp_ = from._impl_.servertimestamp_; - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.keeptype_ = from._impl_.keeptype_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void KeepInChat::CopyFrom(const KeepInChat& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.KeepInChat) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool KeepInChat::IsInitialized() const { - return true; -} - -void KeepInChat::InternalSwap(KeepInChat* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.devicejid_, lhs_arena, - &other->_impl_.devicejid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(KeepInChat, _impl_.keeptype_) - + sizeof(KeepInChat::_impl_.keeptype_) - - PROTOBUF_FIELD_OFFSET(KeepInChat, _impl_.key_)>( - reinterpret_cast(&_impl_.key_), - reinterpret_cast(&other->_impl_.key_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata KeepInChat::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[47]); -} - -// =================================================================== - -class KeyId::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_id(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -KeyId::KeyId(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.KeyId) -} -KeyId::KeyId(const KeyId& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - KeyId* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.id_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.id_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.id_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_id()) { - _this->_impl_.id_.Set(from._internal_id(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.KeyId) -} - -inline void KeyId::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.id_){} - }; - _impl_.id_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.id_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -KeyId::~KeyId() { - // @@protoc_insertion_point(destructor:proto.KeyId) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void KeyId::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.id_.Destroy(); -} - -void KeyId::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void KeyId::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.KeyId) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.id_.ClearNonDefaultToEmpty(); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* KeyId::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bytes id = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_id(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* KeyId::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.KeyId) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bytes id = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 1, this->_internal_id(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.KeyId) - return target; -} - -size_t KeyId::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.KeyId) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional bytes id = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_id()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData KeyId::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - KeyId::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*KeyId::GetClassData() const { return &_class_data_; } - - -void KeyId::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.KeyId) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_id()) { - _this->_internal_set_id(from._internal_id()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void KeyId::CopyFrom(const KeyId& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.KeyId) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool KeyId::IsInitialized() const { - return true; -} - -void KeyId::InternalSwap(KeyId* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.id_, lhs_arena, - &other->_impl_.id_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata KeyId::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[48]); -} - -// =================================================================== - -class LocalizedName::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_lg(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_lc(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_verifiedname(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } -}; - -LocalizedName::LocalizedName(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.LocalizedName) -} -LocalizedName::LocalizedName(const LocalizedName& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - LocalizedName* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.lg_){} - , decltype(_impl_.lc_){} - , decltype(_impl_.verifiedname_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.lg_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.lg_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_lg()) { - _this->_impl_.lg_.Set(from._internal_lg(), - _this->GetArenaForAllocation()); - } - _impl_.lc_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.lc_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_lc()) { - _this->_impl_.lc_.Set(from._internal_lc(), - _this->GetArenaForAllocation()); - } - _impl_.verifiedname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.verifiedname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_verifiedname()) { - _this->_impl_.verifiedname_.Set(from._internal_verifiedname(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.LocalizedName) -} - -inline void LocalizedName::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.lg_){} - , decltype(_impl_.lc_){} - , decltype(_impl_.verifiedname_){} - }; - _impl_.lg_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.lg_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.lc_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.lc_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.verifiedname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.verifiedname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -LocalizedName::~LocalizedName() { - // @@protoc_insertion_point(destructor:proto.LocalizedName) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void LocalizedName::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.lg_.Destroy(); - _impl_.lc_.Destroy(); - _impl_.verifiedname_.Destroy(); -} - -void LocalizedName::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void LocalizedName::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.LocalizedName) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _impl_.lg_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.lc_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.verifiedname_.ClearNonDefaultToEmpty(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* LocalizedName::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string lg = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_lg(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.LocalizedName.lg"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string lc = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_lc(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.LocalizedName.lc"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string verifiedName = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_verifiedname(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.LocalizedName.verifiedName"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* LocalizedName::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.LocalizedName) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string lg = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_lg().data(), static_cast(this->_internal_lg().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.LocalizedName.lg"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_lg(), target); - } - - // optional string lc = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_lc().data(), static_cast(this->_internal_lc().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.LocalizedName.lc"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_lc(), target); - } - - // optional string verifiedName = 3; - if (cached_has_bits & 0x00000004u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_verifiedname().data(), static_cast(this->_internal_verifiedname().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.LocalizedName.verifiedName"); - target = stream->WriteStringMaybeAliased( - 3, this->_internal_verifiedname(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.LocalizedName) - return target; -} - -size_t LocalizedName::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.LocalizedName) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional string lg = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_lg()); - } - - // optional string lc = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_lc()); - } - - // optional string verifiedName = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_verifiedname()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData LocalizedName::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - LocalizedName::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*LocalizedName::GetClassData() const { return &_class_data_; } - - -void LocalizedName::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.LocalizedName) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_lg(from._internal_lg()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_lc(from._internal_lc()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_verifiedname(from._internal_verifiedname()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void LocalizedName::CopyFrom(const LocalizedName& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.LocalizedName) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool LocalizedName::IsInitialized() const { - return true; -} - -void LocalizedName::InternalSwap(LocalizedName* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.lg_, lhs_arena, - &other->_impl_.lg_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.lc_, lhs_arena, - &other->_impl_.lc_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.verifiedname_, lhs_arena, - &other->_impl_.verifiedname_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata LocalizedName::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[49]); -} - -// =================================================================== - -class Location::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_degreeslatitude(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_degreeslongitude(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_name(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -Location::Location(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Location) -} -Location::Location(const Location& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Location* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.name_){} - , decltype(_impl_.degreeslatitude_){} - , decltype(_impl_.degreeslongitude_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.name_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.name_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_name()) { - _this->_impl_.name_.Set(from._internal_name(), - _this->GetArenaForAllocation()); - } - ::memcpy(&_impl_.degreeslatitude_, &from._impl_.degreeslatitude_, - static_cast(reinterpret_cast(&_impl_.degreeslongitude_) - - reinterpret_cast(&_impl_.degreeslatitude_)) + sizeof(_impl_.degreeslongitude_)); - // @@protoc_insertion_point(copy_constructor:proto.Location) -} - -inline void Location::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.name_){} - , decltype(_impl_.degreeslatitude_){0} - , decltype(_impl_.degreeslongitude_){0} - }; - _impl_.name_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.name_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Location::~Location() { - // @@protoc_insertion_point(destructor:proto.Location) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Location::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.name_.Destroy(); -} - -void Location::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Location::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Location) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.name_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000006u) { - ::memset(&_impl_.degreeslatitude_, 0, static_cast( - reinterpret_cast(&_impl_.degreeslongitude_) - - reinterpret_cast(&_impl_.degreeslatitude_)) + sizeof(_impl_.degreeslongitude_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Location::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional double degreesLatitude = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 9)) { - _Internal::set_has_degreeslatitude(&has_bits); - _impl_.degreeslatitude_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); - ptr += sizeof(double); - } else - goto handle_unusual; - continue; - // optional double degreesLongitude = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 17)) { - _Internal::set_has_degreeslongitude(&has_bits); - _impl_.degreeslongitude_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); - ptr += sizeof(double); - } else - goto handle_unusual; - continue; - // optional string name = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_name(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Location.name"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Location::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Location) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional double degreesLatitude = 1; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteDoubleToArray(1, this->_internal_degreeslatitude(), target); - } - - // optional double degreesLongitude = 2; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteDoubleToArray(2, this->_internal_degreeslongitude(), target); - } - - // optional string name = 3; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_name().data(), static_cast(this->_internal_name().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Location.name"); - target = stream->WriteStringMaybeAliased( - 3, this->_internal_name(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Location) - return target; -} - -size_t Location::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Location) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional string name = 3; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_name()); - } - - // optional double degreesLatitude = 1; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + 8; - } - - // optional double degreesLongitude = 2; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + 8; - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Location::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Location::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Location::GetClassData() const { return &_class_data_; } - - -void Location::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Location) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_name(from._internal_name()); - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.degreeslatitude_ = from._impl_.degreeslatitude_; - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.degreeslongitude_ = from._impl_.degreeslongitude_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Location::CopyFrom(const Location& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Location) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Location::IsInitialized() const { - return true; -} - -void Location::InternalSwap(Location* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.name_, lhs_arena, - &other->_impl_.name_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Location, _impl_.degreeslongitude_) - + sizeof(Location::_impl_.degreeslongitude_) - - PROTOBUF_FIELD_OFFSET(Location, _impl_.degreeslatitude_)>( - reinterpret_cast(&_impl_.degreeslatitude_), - reinterpret_cast(&other->_impl_.degreeslatitude_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Location::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[50]); -} - -// =================================================================== - -class MediaData::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_localpath(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -MediaData::MediaData(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.MediaData) -} -MediaData::MediaData(const MediaData& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - MediaData* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.localpath_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.localpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.localpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_localpath()) { - _this->_impl_.localpath_.Set(from._internal_localpath(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.MediaData) -} - -inline void MediaData::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.localpath_){} - }; - _impl_.localpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.localpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -MediaData::~MediaData() { - // @@protoc_insertion_point(destructor:proto.MediaData) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void MediaData::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.localpath_.Destroy(); -} - -void MediaData::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void MediaData::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.MediaData) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.localpath_.ClearNonDefaultToEmpty(); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* MediaData::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string localPath = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_localpath(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.MediaData.localPath"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* MediaData::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.MediaData) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string localPath = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_localpath().data(), static_cast(this->_internal_localpath().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.MediaData.localPath"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_localpath(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.MediaData) - return target; -} - -size_t MediaData::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.MediaData) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional string localPath = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_localpath()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MediaData::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - MediaData::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MediaData::GetClassData() const { return &_class_data_; } - - -void MediaData::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.MediaData) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_localpath()) { - _this->_internal_set_localpath(from._internal_localpath()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void MediaData::CopyFrom(const MediaData& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.MediaData) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool MediaData::IsInitialized() const { - return true; -} - -void MediaData::InternalSwap(MediaData* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.localpath_, lhs_arena, - &other->_impl_.localpath_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata MediaData::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[51]); -} - -// =================================================================== - -class MediaRetryNotification::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_stanzaid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_directpath(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_result(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } -}; - -MediaRetryNotification::MediaRetryNotification(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.MediaRetryNotification) -} -MediaRetryNotification::MediaRetryNotification(const MediaRetryNotification& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - MediaRetryNotification* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.stanzaid_){} - , decltype(_impl_.directpath_){} - , decltype(_impl_.result_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.stanzaid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.stanzaid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_stanzaid()) { - _this->_impl_.stanzaid_.Set(from._internal_stanzaid(), - _this->GetArenaForAllocation()); - } - _impl_.directpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_directpath()) { - _this->_impl_.directpath_.Set(from._internal_directpath(), - _this->GetArenaForAllocation()); - } - _this->_impl_.result_ = from._impl_.result_; - // @@protoc_insertion_point(copy_constructor:proto.MediaRetryNotification) -} - -inline void MediaRetryNotification::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.stanzaid_){} - , decltype(_impl_.directpath_){} - , decltype(_impl_.result_){0} - }; - _impl_.stanzaid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.stanzaid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -MediaRetryNotification::~MediaRetryNotification() { - // @@protoc_insertion_point(destructor:proto.MediaRetryNotification) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void MediaRetryNotification::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.stanzaid_.Destroy(); - _impl_.directpath_.Destroy(); -} - -void MediaRetryNotification::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void MediaRetryNotification::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.MediaRetryNotification) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.stanzaid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.directpath_.ClearNonDefaultToEmpty(); - } - } - _impl_.result_ = 0; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* MediaRetryNotification::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string stanzaId = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_stanzaid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.MediaRetryNotification.stanzaId"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string directPath = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_directpath(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.MediaRetryNotification.directPath"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.MediaRetryNotification.ResultType result = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::MediaRetryNotification_ResultType_IsValid(val))) { - _internal_set_result(static_cast<::proto::MediaRetryNotification_ResultType>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* MediaRetryNotification::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.MediaRetryNotification) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string stanzaId = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_stanzaid().data(), static_cast(this->_internal_stanzaid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.MediaRetryNotification.stanzaId"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_stanzaid(), target); - } - - // optional string directPath = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_directpath().data(), static_cast(this->_internal_directpath().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.MediaRetryNotification.directPath"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_directpath(), target); - } - - // optional .proto.MediaRetryNotification.ResultType result = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 3, this->_internal_result(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.MediaRetryNotification) - return target; -} - -size_t MediaRetryNotification::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.MediaRetryNotification) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional string stanzaId = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_stanzaid()); - } - - // optional string directPath = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_directpath()); - } - - // optional .proto.MediaRetryNotification.ResultType result = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_result()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MediaRetryNotification::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - MediaRetryNotification::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MediaRetryNotification::GetClassData() const { return &_class_data_; } - - -void MediaRetryNotification::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.MediaRetryNotification) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_stanzaid(from._internal_stanzaid()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_directpath(from._internal_directpath()); - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.result_ = from._impl_.result_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void MediaRetryNotification::CopyFrom(const MediaRetryNotification& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.MediaRetryNotification) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool MediaRetryNotification::IsInitialized() const { - return true; -} - -void MediaRetryNotification::InternalSwap(MediaRetryNotification* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.stanzaid_, lhs_arena, - &other->_impl_.stanzaid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.directpath_, lhs_arena, - &other->_impl_.directpath_, rhs_arena - ); - swap(_impl_.result_, other->_impl_.result_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata MediaRetryNotification::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[52]); -} - -// =================================================================== - -class Message_AppStateFatalExceptionNotification::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_timestamp(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -Message_AppStateFatalExceptionNotification::Message_AppStateFatalExceptionNotification(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.AppStateFatalExceptionNotification) -} -Message_AppStateFatalExceptionNotification::Message_AppStateFatalExceptionNotification(const Message_AppStateFatalExceptionNotification& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_AppStateFatalExceptionNotification* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.collectionnames_){from._impl_.collectionnames_} - , decltype(_impl_.timestamp_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _this->_impl_.timestamp_ = from._impl_.timestamp_; - // @@protoc_insertion_point(copy_constructor:proto.Message.AppStateFatalExceptionNotification) -} - -inline void Message_AppStateFatalExceptionNotification::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.collectionnames_){arena} - , decltype(_impl_.timestamp_){int64_t{0}} - }; -} - -Message_AppStateFatalExceptionNotification::~Message_AppStateFatalExceptionNotification() { - // @@protoc_insertion_point(destructor:proto.Message.AppStateFatalExceptionNotification) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_AppStateFatalExceptionNotification::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.collectionnames_.~RepeatedPtrField(); -} - -void Message_AppStateFatalExceptionNotification::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_AppStateFatalExceptionNotification::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.AppStateFatalExceptionNotification) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.collectionnames_.Clear(); - _impl_.timestamp_ = int64_t{0}; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_AppStateFatalExceptionNotification::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated string collectionNames = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - auto str = _internal_add_collectionnames(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.AppStateFatalExceptionNotification.collectionNames"); - #endif // !NDEBUG - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else - goto handle_unusual; - continue; - // optional int64 timestamp = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_timestamp(&has_bits); - _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_AppStateFatalExceptionNotification::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.AppStateFatalExceptionNotification) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated string collectionNames = 1; - for (int i = 0, n = this->_internal_collectionnames_size(); i < n; i++) { - const auto& s = this->_internal_collectionnames(i); - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - s.data(), static_cast(s.length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.AppStateFatalExceptionNotification.collectionNames"); - target = stream->WriteString(1, s, target); - } - - cached_has_bits = _impl_._has_bits_[0]; - // optional int64 timestamp = 2; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_timestamp(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.AppStateFatalExceptionNotification) - return target; -} - -size_t Message_AppStateFatalExceptionNotification::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.AppStateFatalExceptionNotification) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated string collectionNames = 1; - total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.collectionnames_.size()); - for (int i = 0, n = _impl_.collectionnames_.size(); i < n; i++) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - _impl_.collectionnames_.Get(i)); - } - - // optional int64 timestamp = 2; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_timestamp()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_AppStateFatalExceptionNotification::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_AppStateFatalExceptionNotification::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_AppStateFatalExceptionNotification::GetClassData() const { return &_class_data_; } - - -void Message_AppStateFatalExceptionNotification::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.AppStateFatalExceptionNotification) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.collectionnames_.MergeFrom(from._impl_.collectionnames_); - if (from._internal_has_timestamp()) { - _this->_internal_set_timestamp(from._internal_timestamp()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_AppStateFatalExceptionNotification::CopyFrom(const Message_AppStateFatalExceptionNotification& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.AppStateFatalExceptionNotification) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_AppStateFatalExceptionNotification::IsInitialized() const { - return true; -} - -void Message_AppStateFatalExceptionNotification::InternalSwap(Message_AppStateFatalExceptionNotification* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.collectionnames_.InternalSwap(&other->_impl_.collectionnames_); - swap(_impl_.timestamp_, other->_impl_.timestamp_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_AppStateFatalExceptionNotification::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[53]); -} - -// =================================================================== - -class Message_AppStateSyncKeyData::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_keydata(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::proto::Message_AppStateSyncKeyFingerprint& fingerprint(const Message_AppStateSyncKeyData* msg); - static void set_has_fingerprint(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_timestamp(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } -}; - -const ::proto::Message_AppStateSyncKeyFingerprint& -Message_AppStateSyncKeyData::_Internal::fingerprint(const Message_AppStateSyncKeyData* msg) { - return *msg->_impl_.fingerprint_; -} -Message_AppStateSyncKeyData::Message_AppStateSyncKeyData(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.AppStateSyncKeyData) -} -Message_AppStateSyncKeyData::Message_AppStateSyncKeyData(const Message_AppStateSyncKeyData& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_AppStateSyncKeyData* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.keydata_){} - , decltype(_impl_.fingerprint_){nullptr} - , decltype(_impl_.timestamp_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.keydata_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.keydata_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_keydata()) { - _this->_impl_.keydata_.Set(from._internal_keydata(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_fingerprint()) { - _this->_impl_.fingerprint_ = new ::proto::Message_AppStateSyncKeyFingerprint(*from._impl_.fingerprint_); - } - _this->_impl_.timestamp_ = from._impl_.timestamp_; - // @@protoc_insertion_point(copy_constructor:proto.Message.AppStateSyncKeyData) -} - -inline void Message_AppStateSyncKeyData::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.keydata_){} - , decltype(_impl_.fingerprint_){nullptr} - , decltype(_impl_.timestamp_){int64_t{0}} - }; - _impl_.keydata_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.keydata_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_AppStateSyncKeyData::~Message_AppStateSyncKeyData() { - // @@protoc_insertion_point(destructor:proto.Message.AppStateSyncKeyData) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_AppStateSyncKeyData::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.keydata_.Destroy(); - if (this != internal_default_instance()) delete _impl_.fingerprint_; -} - -void Message_AppStateSyncKeyData::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_AppStateSyncKeyData::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.AppStateSyncKeyData) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.keydata_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.fingerprint_ != nullptr); - _impl_.fingerprint_->Clear(); - } - } - _impl_.timestamp_ = int64_t{0}; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_AppStateSyncKeyData::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bytes keyData = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_keydata(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.AppStateSyncKeyFingerprint fingerprint = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_fingerprint(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional int64 timestamp = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_timestamp(&has_bits); - _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_AppStateSyncKeyData::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.AppStateSyncKeyData) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bytes keyData = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 1, this->_internal_keydata(), target); - } - - // optional .proto.Message.AppStateSyncKeyFingerprint fingerprint = 2; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::fingerprint(this), - _Internal::fingerprint(this).GetCachedSize(), target, stream); - } - - // optional int64 timestamp = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_timestamp(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.AppStateSyncKeyData) - return target; -} - -size_t Message_AppStateSyncKeyData::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.AppStateSyncKeyData) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional bytes keyData = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_keydata()); - } - - // optional .proto.Message.AppStateSyncKeyFingerprint fingerprint = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.fingerprint_); - } - - // optional int64 timestamp = 3; - if (cached_has_bits & 0x00000004u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_timestamp()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_AppStateSyncKeyData::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_AppStateSyncKeyData::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_AppStateSyncKeyData::GetClassData() const { return &_class_data_; } - - -void Message_AppStateSyncKeyData::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.AppStateSyncKeyData) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_keydata(from._internal_keydata()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_fingerprint()->::proto::Message_AppStateSyncKeyFingerprint::MergeFrom( - from._internal_fingerprint()); - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.timestamp_ = from._impl_.timestamp_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_AppStateSyncKeyData::CopyFrom(const Message_AppStateSyncKeyData& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.AppStateSyncKeyData) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_AppStateSyncKeyData::IsInitialized() const { - return true; -} - -void Message_AppStateSyncKeyData::InternalSwap(Message_AppStateSyncKeyData* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.keydata_, lhs_arena, - &other->_impl_.keydata_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_AppStateSyncKeyData, _impl_.timestamp_) - + sizeof(Message_AppStateSyncKeyData::_impl_.timestamp_) - - PROTOBUF_FIELD_OFFSET(Message_AppStateSyncKeyData, _impl_.fingerprint_)>( - reinterpret_cast(&_impl_.fingerprint_), - reinterpret_cast(&other->_impl_.fingerprint_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_AppStateSyncKeyData::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[54]); -} - -// =================================================================== - -class Message_AppStateSyncKeyFingerprint::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_rawid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_currentindex(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -Message_AppStateSyncKeyFingerprint::Message_AppStateSyncKeyFingerprint(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.AppStateSyncKeyFingerprint) -} -Message_AppStateSyncKeyFingerprint::Message_AppStateSyncKeyFingerprint(const Message_AppStateSyncKeyFingerprint& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_AppStateSyncKeyFingerprint* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.deviceindexes_){from._impl_.deviceindexes_} - , /*decltype(_impl_._deviceindexes_cached_byte_size_)*/{0} - , decltype(_impl_.rawid_){} - , decltype(_impl_.currentindex_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&_impl_.rawid_, &from._impl_.rawid_, - static_cast(reinterpret_cast(&_impl_.currentindex_) - - reinterpret_cast(&_impl_.rawid_)) + sizeof(_impl_.currentindex_)); - // @@protoc_insertion_point(copy_constructor:proto.Message.AppStateSyncKeyFingerprint) -} - -inline void Message_AppStateSyncKeyFingerprint::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.deviceindexes_){arena} - , /*decltype(_impl_._deviceindexes_cached_byte_size_)*/{0} - , decltype(_impl_.rawid_){0u} - , decltype(_impl_.currentindex_){0u} - }; -} - -Message_AppStateSyncKeyFingerprint::~Message_AppStateSyncKeyFingerprint() { - // @@protoc_insertion_point(destructor:proto.Message.AppStateSyncKeyFingerprint) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_AppStateSyncKeyFingerprint::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.deviceindexes_.~RepeatedField(); -} - -void Message_AppStateSyncKeyFingerprint::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_AppStateSyncKeyFingerprint::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.AppStateSyncKeyFingerprint) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.deviceindexes_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - ::memset(&_impl_.rawid_, 0, static_cast( - reinterpret_cast(&_impl_.currentindex_) - - reinterpret_cast(&_impl_.rawid_)) + sizeof(_impl_.currentindex_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_AppStateSyncKeyFingerprint::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional uint32 rawId = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_rawid(&has_bits); - _impl_.rawid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 currentIndex = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_currentindex(&has_bits); - _impl_.currentindex_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated uint32 deviceIndexes = 3 [packed = true]; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_deviceindexes(), ptr, ctx); - CHK_(ptr); - } else if (static_cast(tag) == 24) { - _internal_add_deviceindexes(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_AppStateSyncKeyFingerprint::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.AppStateSyncKeyFingerprint) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional uint32 rawId = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_rawid(), target); - } - - // optional uint32 currentIndex = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_currentindex(), target); - } - - // repeated uint32 deviceIndexes = 3 [packed = true]; - { - int byte_size = _impl_._deviceindexes_cached_byte_size_.load(std::memory_order_relaxed); - if (byte_size > 0) { - target = stream->WriteUInt32Packed( - 3, _internal_deviceindexes(), byte_size, target); - } - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.AppStateSyncKeyFingerprint) - return target; -} - -size_t Message_AppStateSyncKeyFingerprint::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.AppStateSyncKeyFingerprint) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated uint32 deviceIndexes = 3 [packed = true]; - { - size_t data_size = ::_pbi::WireFormatLite:: - UInt32Size(this->_impl_.deviceindexes_); - if (data_size > 0) { - total_size += 1 + - ::_pbi::WireFormatLite::Int32Size(static_cast(data_size)); - } - int cached_size = ::_pbi::ToCachedSize(data_size); - _impl_._deviceindexes_cached_byte_size_.store(cached_size, - std::memory_order_relaxed); - total_size += data_size; - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional uint32 rawId = 1; - if (cached_has_bits & 0x00000001u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_rawid()); - } - - // optional uint32 currentIndex = 2; - if (cached_has_bits & 0x00000002u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_currentindex()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_AppStateSyncKeyFingerprint::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_AppStateSyncKeyFingerprint::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_AppStateSyncKeyFingerprint::GetClassData() const { return &_class_data_; } - - -void Message_AppStateSyncKeyFingerprint::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.AppStateSyncKeyFingerprint) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.deviceindexes_.MergeFrom(from._impl_.deviceindexes_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_impl_.rawid_ = from._impl_.rawid_; - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.currentindex_ = from._impl_.currentindex_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_AppStateSyncKeyFingerprint::CopyFrom(const Message_AppStateSyncKeyFingerprint& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.AppStateSyncKeyFingerprint) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_AppStateSyncKeyFingerprint::IsInitialized() const { - return true; -} - -void Message_AppStateSyncKeyFingerprint::InternalSwap(Message_AppStateSyncKeyFingerprint* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.deviceindexes_.InternalSwap(&other->_impl_.deviceindexes_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_AppStateSyncKeyFingerprint, _impl_.currentindex_) - + sizeof(Message_AppStateSyncKeyFingerprint::_impl_.currentindex_) - - PROTOBUF_FIELD_OFFSET(Message_AppStateSyncKeyFingerprint, _impl_.rawid_)>( - reinterpret_cast(&_impl_.rawid_), - reinterpret_cast(&other->_impl_.rawid_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_AppStateSyncKeyFingerprint::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[55]); -} - -// =================================================================== - -class Message_AppStateSyncKeyId::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_keyid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -Message_AppStateSyncKeyId::Message_AppStateSyncKeyId(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.AppStateSyncKeyId) -} -Message_AppStateSyncKeyId::Message_AppStateSyncKeyId(const Message_AppStateSyncKeyId& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_AppStateSyncKeyId* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.keyid_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.keyid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.keyid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_keyid()) { - _this->_impl_.keyid_.Set(from._internal_keyid(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.Message.AppStateSyncKeyId) -} - -inline void Message_AppStateSyncKeyId::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.keyid_){} - }; - _impl_.keyid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.keyid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_AppStateSyncKeyId::~Message_AppStateSyncKeyId() { - // @@protoc_insertion_point(destructor:proto.Message.AppStateSyncKeyId) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_AppStateSyncKeyId::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.keyid_.Destroy(); -} - -void Message_AppStateSyncKeyId::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_AppStateSyncKeyId::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.AppStateSyncKeyId) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.keyid_.ClearNonDefaultToEmpty(); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_AppStateSyncKeyId::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bytes keyId = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_keyid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_AppStateSyncKeyId::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.AppStateSyncKeyId) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bytes keyId = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 1, this->_internal_keyid(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.AppStateSyncKeyId) - return target; -} - -size_t Message_AppStateSyncKeyId::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.AppStateSyncKeyId) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional bytes keyId = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_keyid()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_AppStateSyncKeyId::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_AppStateSyncKeyId::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_AppStateSyncKeyId::GetClassData() const { return &_class_data_; } - - -void Message_AppStateSyncKeyId::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.AppStateSyncKeyId) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_keyid()) { - _this->_internal_set_keyid(from._internal_keyid()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_AppStateSyncKeyId::CopyFrom(const Message_AppStateSyncKeyId& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.AppStateSyncKeyId) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_AppStateSyncKeyId::IsInitialized() const { - return true; -} - -void Message_AppStateSyncKeyId::InternalSwap(Message_AppStateSyncKeyId* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.keyid_, lhs_arena, - &other->_impl_.keyid_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_AppStateSyncKeyId::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[56]); -} - -// =================================================================== - -class Message_AppStateSyncKeyRequest::_Internal { - public: -}; - -Message_AppStateSyncKeyRequest::Message_AppStateSyncKeyRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.AppStateSyncKeyRequest) -} -Message_AppStateSyncKeyRequest::Message_AppStateSyncKeyRequest(const Message_AppStateSyncKeyRequest& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_AppStateSyncKeyRequest* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_.keyids_){from._impl_.keyids_} - , /*decltype(_impl_._cached_size_)*/{}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:proto.Message.AppStateSyncKeyRequest) -} - -inline void Message_AppStateSyncKeyRequest::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_.keyids_){arena} - , /*decltype(_impl_._cached_size_)*/{} - }; -} - -Message_AppStateSyncKeyRequest::~Message_AppStateSyncKeyRequest() { - // @@protoc_insertion_point(destructor:proto.Message.AppStateSyncKeyRequest) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_AppStateSyncKeyRequest::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.keyids_.~RepeatedPtrField(); -} - -void Message_AppStateSyncKeyRequest::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_AppStateSyncKeyRequest::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.AppStateSyncKeyRequest) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.keyids_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_AppStateSyncKeyRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated .proto.Message.AppStateSyncKeyId keyIds = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_keyids(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_AppStateSyncKeyRequest::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.AppStateSyncKeyRequest) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .proto.Message.AppStateSyncKeyId keyIds = 1; - for (unsigned i = 0, - n = static_cast(this->_internal_keyids_size()); i < n; i++) { - const auto& repfield = this->_internal_keyids(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.AppStateSyncKeyRequest) - return target; -} - -size_t Message_AppStateSyncKeyRequest::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.AppStateSyncKeyRequest) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.Message.AppStateSyncKeyId keyIds = 1; - total_size += 1UL * this->_internal_keyids_size(); - for (const auto& msg : this->_impl_.keyids_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_AppStateSyncKeyRequest::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_AppStateSyncKeyRequest::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_AppStateSyncKeyRequest::GetClassData() const { return &_class_data_; } - - -void Message_AppStateSyncKeyRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.AppStateSyncKeyRequest) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.keyids_.MergeFrom(from._impl_.keyids_); - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_AppStateSyncKeyRequest::CopyFrom(const Message_AppStateSyncKeyRequest& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.AppStateSyncKeyRequest) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_AppStateSyncKeyRequest::IsInitialized() const { - return true; -} - -void Message_AppStateSyncKeyRequest::InternalSwap(Message_AppStateSyncKeyRequest* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - _impl_.keyids_.InternalSwap(&other->_impl_.keyids_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_AppStateSyncKeyRequest::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[57]); -} - -// =================================================================== - -class Message_AppStateSyncKeyShare::_Internal { - public: -}; - -Message_AppStateSyncKeyShare::Message_AppStateSyncKeyShare(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.AppStateSyncKeyShare) -} -Message_AppStateSyncKeyShare::Message_AppStateSyncKeyShare(const Message_AppStateSyncKeyShare& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_AppStateSyncKeyShare* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_.keys_){from._impl_.keys_} - , /*decltype(_impl_._cached_size_)*/{}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:proto.Message.AppStateSyncKeyShare) -} - -inline void Message_AppStateSyncKeyShare::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_.keys_){arena} - , /*decltype(_impl_._cached_size_)*/{} - }; -} - -Message_AppStateSyncKeyShare::~Message_AppStateSyncKeyShare() { - // @@protoc_insertion_point(destructor:proto.Message.AppStateSyncKeyShare) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_AppStateSyncKeyShare::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.keys_.~RepeatedPtrField(); -} - -void Message_AppStateSyncKeyShare::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_AppStateSyncKeyShare::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.AppStateSyncKeyShare) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.keys_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_AppStateSyncKeyShare::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated .proto.Message.AppStateSyncKey keys = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_keys(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_AppStateSyncKeyShare::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.AppStateSyncKeyShare) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .proto.Message.AppStateSyncKey keys = 1; - for (unsigned i = 0, - n = static_cast(this->_internal_keys_size()); i < n; i++) { - const auto& repfield = this->_internal_keys(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.AppStateSyncKeyShare) - return target; -} - -size_t Message_AppStateSyncKeyShare::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.AppStateSyncKeyShare) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.Message.AppStateSyncKey keys = 1; - total_size += 1UL * this->_internal_keys_size(); - for (const auto& msg : this->_impl_.keys_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_AppStateSyncKeyShare::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_AppStateSyncKeyShare::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_AppStateSyncKeyShare::GetClassData() const { return &_class_data_; } - - -void Message_AppStateSyncKeyShare::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.AppStateSyncKeyShare) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.keys_.MergeFrom(from._impl_.keys_); - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_AppStateSyncKeyShare::CopyFrom(const Message_AppStateSyncKeyShare& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.AppStateSyncKeyShare) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_AppStateSyncKeyShare::IsInitialized() const { - return true; -} - -void Message_AppStateSyncKeyShare::InternalSwap(Message_AppStateSyncKeyShare* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - _impl_.keys_.InternalSwap(&other->_impl_.keys_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_AppStateSyncKeyShare::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[58]); -} - -// =================================================================== - -class Message_AppStateSyncKey::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::Message_AppStateSyncKeyId& keyid(const Message_AppStateSyncKey* msg); - static void set_has_keyid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::proto::Message_AppStateSyncKeyData& keydata(const Message_AppStateSyncKey* msg); - static void set_has_keydata(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -const ::proto::Message_AppStateSyncKeyId& -Message_AppStateSyncKey::_Internal::keyid(const Message_AppStateSyncKey* msg) { - return *msg->_impl_.keyid_; -} -const ::proto::Message_AppStateSyncKeyData& -Message_AppStateSyncKey::_Internal::keydata(const Message_AppStateSyncKey* msg) { - return *msg->_impl_.keydata_; -} -Message_AppStateSyncKey::Message_AppStateSyncKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.AppStateSyncKey) -} -Message_AppStateSyncKey::Message_AppStateSyncKey(const Message_AppStateSyncKey& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_AppStateSyncKey* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.keyid_){nullptr} - , decltype(_impl_.keydata_){nullptr}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_keyid()) { - _this->_impl_.keyid_ = new ::proto::Message_AppStateSyncKeyId(*from._impl_.keyid_); - } - if (from._internal_has_keydata()) { - _this->_impl_.keydata_ = new ::proto::Message_AppStateSyncKeyData(*from._impl_.keydata_); - } - // @@protoc_insertion_point(copy_constructor:proto.Message.AppStateSyncKey) -} - -inline void Message_AppStateSyncKey::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.keyid_){nullptr} - , decltype(_impl_.keydata_){nullptr} - }; -} - -Message_AppStateSyncKey::~Message_AppStateSyncKey() { - // @@protoc_insertion_point(destructor:proto.Message.AppStateSyncKey) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_AppStateSyncKey::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete _impl_.keyid_; - if (this != internal_default_instance()) delete _impl_.keydata_; -} - -void Message_AppStateSyncKey::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_AppStateSyncKey::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.AppStateSyncKey) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.keyid_ != nullptr); - _impl_.keyid_->Clear(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.keydata_ != nullptr); - _impl_.keydata_->Clear(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_AppStateSyncKey::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.Message.AppStateSyncKeyId keyId = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_keyid(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.AppStateSyncKeyData keyData = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_keydata(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_AppStateSyncKey::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.AppStateSyncKey) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.Message.AppStateSyncKeyId keyId = 1; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::keyid(this), - _Internal::keyid(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.AppStateSyncKeyData keyData = 2; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::keydata(this), - _Internal::keydata(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.AppStateSyncKey) - return target; -} - -size_t Message_AppStateSyncKey::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.AppStateSyncKey) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional .proto.Message.AppStateSyncKeyId keyId = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.keyid_); - } - - // optional .proto.Message.AppStateSyncKeyData keyData = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.keydata_); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_AppStateSyncKey::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_AppStateSyncKey::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_AppStateSyncKey::GetClassData() const { return &_class_data_; } - - -void Message_AppStateSyncKey::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.AppStateSyncKey) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_mutable_keyid()->::proto::Message_AppStateSyncKeyId::MergeFrom( - from._internal_keyid()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_keydata()->::proto::Message_AppStateSyncKeyData::MergeFrom( - from._internal_keydata()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_AppStateSyncKey::CopyFrom(const Message_AppStateSyncKey& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.AppStateSyncKey) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_AppStateSyncKey::IsInitialized() const { - return true; -} - -void Message_AppStateSyncKey::InternalSwap(Message_AppStateSyncKey* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_AppStateSyncKey, _impl_.keydata_) - + sizeof(Message_AppStateSyncKey::_impl_.keydata_) - - PROTOBUF_FIELD_OFFSET(Message_AppStateSyncKey, _impl_.keyid_)>( - reinterpret_cast(&_impl_.keyid_), - reinterpret_cast(&other->_impl_.keyid_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_AppStateSyncKey::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[59]); -} - -// =================================================================== - -class Message_AudioMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_url(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_mimetype(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_filesha256(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_filelength(HasBits* has_bits) { - (*has_bits)[0] |= 512u; - } - static void set_has_seconds(HasBits* has_bits) { - (*has_bits)[0] |= 1024u; - } - static void set_has_ptt(HasBits* has_bits) { - (*has_bits)[0] |= 2048u; - } - static void set_has_mediakey(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_fileencsha256(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_directpath(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static void set_has_mediakeytimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 4096u; - } - static const ::proto::ContextInfo& contextinfo(const Message_AudioMessage* msg); - static void set_has_contextinfo(HasBits* has_bits) { - (*has_bits)[0] |= 256u; - } - static void set_has_streamingsidecar(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static void set_has_waveform(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } -}; - -const ::proto::ContextInfo& -Message_AudioMessage::_Internal::contextinfo(const Message_AudioMessage* msg) { - return *msg->_impl_.contextinfo_; -} -Message_AudioMessage::Message_AudioMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.AudioMessage) -} -Message_AudioMessage::Message_AudioMessage(const Message_AudioMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_AudioMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.url_){} - , decltype(_impl_.mimetype_){} - , decltype(_impl_.filesha256_){} - , decltype(_impl_.mediakey_){} - , decltype(_impl_.fileencsha256_){} - , decltype(_impl_.directpath_){} - , decltype(_impl_.streamingsidecar_){} - , decltype(_impl_.waveform_){} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.filelength_){} - , decltype(_impl_.seconds_){} - , decltype(_impl_.ptt_){} - , decltype(_impl_.mediakeytimestamp_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.url_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.url_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_url()) { - _this->_impl_.url_.Set(from._internal_url(), - _this->GetArenaForAllocation()); - } - _impl_.mimetype_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mimetype_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_mimetype()) { - _this->_impl_.mimetype_.Set(from._internal_mimetype(), - _this->GetArenaForAllocation()); - } - _impl_.filesha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filesha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_filesha256()) { - _this->_impl_.filesha256_.Set(from._internal_filesha256(), - _this->GetArenaForAllocation()); - } - _impl_.mediakey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediakey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_mediakey()) { - _this->_impl_.mediakey_.Set(from._internal_mediakey(), - _this->GetArenaForAllocation()); - } - _impl_.fileencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_fileencsha256()) { - _this->_impl_.fileencsha256_.Set(from._internal_fileencsha256(), - _this->GetArenaForAllocation()); - } - _impl_.directpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_directpath()) { - _this->_impl_.directpath_.Set(from._internal_directpath(), - _this->GetArenaForAllocation()); - } - _impl_.streamingsidecar_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.streamingsidecar_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_streamingsidecar()) { - _this->_impl_.streamingsidecar_.Set(from._internal_streamingsidecar(), - _this->GetArenaForAllocation()); - } - _impl_.waveform_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.waveform_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_waveform()) { - _this->_impl_.waveform_.Set(from._internal_waveform(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_contextinfo()) { - _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); - } - ::memcpy(&_impl_.filelength_, &from._impl_.filelength_, - static_cast(reinterpret_cast(&_impl_.mediakeytimestamp_) - - reinterpret_cast(&_impl_.filelength_)) + sizeof(_impl_.mediakeytimestamp_)); - // @@protoc_insertion_point(copy_constructor:proto.Message.AudioMessage) -} - -inline void Message_AudioMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.url_){} - , decltype(_impl_.mimetype_){} - , decltype(_impl_.filesha256_){} - , decltype(_impl_.mediakey_){} - , decltype(_impl_.fileencsha256_){} - , decltype(_impl_.directpath_){} - , decltype(_impl_.streamingsidecar_){} - , decltype(_impl_.waveform_){} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.filelength_){uint64_t{0u}} - , decltype(_impl_.seconds_){0u} - , decltype(_impl_.ptt_){false} - , decltype(_impl_.mediakeytimestamp_){int64_t{0}} - }; - _impl_.url_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.url_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mimetype_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mimetype_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filesha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filesha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediakey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediakey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fileencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.streamingsidecar_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.streamingsidecar_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.waveform_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.waveform_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_AudioMessage::~Message_AudioMessage() { - // @@protoc_insertion_point(destructor:proto.Message.AudioMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_AudioMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.url_.Destroy(); - _impl_.mimetype_.Destroy(); - _impl_.filesha256_.Destroy(); - _impl_.mediakey_.Destroy(); - _impl_.fileencsha256_.Destroy(); - _impl_.directpath_.Destroy(); - _impl_.streamingsidecar_.Destroy(); - _impl_.waveform_.Destroy(); - if (this != internal_default_instance()) delete _impl_.contextinfo_; -} - -void Message_AudioMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_AudioMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.AudioMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _impl_.url_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.mimetype_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.filesha256_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000008u) { - _impl_.mediakey_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000010u) { - _impl_.fileencsha256_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000020u) { - _impl_.directpath_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000040u) { - _impl_.streamingsidecar_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000080u) { - _impl_.waveform_.ClearNonDefaultToEmpty(); - } - } - if (cached_has_bits & 0x00000100u) { - GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); - _impl_.contextinfo_->Clear(); - } - if (cached_has_bits & 0x00001e00u) { - ::memset(&_impl_.filelength_, 0, static_cast( - reinterpret_cast(&_impl_.mediakeytimestamp_) - - reinterpret_cast(&_impl_.filelength_)) + sizeof(_impl_.mediakeytimestamp_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_AudioMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string url = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_url(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.AudioMessage.url"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string mimetype = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_mimetype(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.AudioMessage.mimetype"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bytes fileSha256 = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_filesha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint64 fileLength = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - _Internal::set_has_filelength(&has_bits); - _impl_.filelength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 seconds = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { - _Internal::set_has_seconds(&has_bits); - _impl_.seconds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool ptt = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { - _Internal::set_has_ptt(&has_bits); - _impl_.ptt_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes mediaKey = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - auto str = _internal_mutable_mediakey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes fileEncSha256 = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { - auto str = _internal_mutable_fileencsha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string directPath = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { - auto str = _internal_mutable_directpath(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.AudioMessage.directPath"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional int64 mediaKeyTimestamp = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { - _Internal::set_has_mediakeytimestamp(&has_bits); - _impl_.mediakeytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.ContextInfo contextInfo = 17; - case 17: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { - ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes streamingSidecar = 18; - case 18: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { - auto str = _internal_mutable_streamingsidecar(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes waveform = 19; - case 19: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) { - auto str = _internal_mutable_waveform(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_AudioMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.AudioMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string url = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_url().data(), static_cast(this->_internal_url().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.AudioMessage.url"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_url(), target); - } - - // optional string mimetype = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_mimetype().data(), static_cast(this->_internal_mimetype().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.AudioMessage.mimetype"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_mimetype(), target); - } - - // optional bytes fileSha256 = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->WriteBytesMaybeAliased( - 3, this->_internal_filesha256(), target); - } - - // optional uint64 fileLength = 4; - if (cached_has_bits & 0x00000200u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_filelength(), target); - } - - // optional uint32 seconds = 5; - if (cached_has_bits & 0x00000400u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_seconds(), target); - } - - // optional bool ptt = 6; - if (cached_has_bits & 0x00000800u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(6, this->_internal_ptt(), target); - } - - // optional bytes mediaKey = 7; - if (cached_has_bits & 0x00000008u) { - target = stream->WriteBytesMaybeAliased( - 7, this->_internal_mediakey(), target); - } - - // optional bytes fileEncSha256 = 8; - if (cached_has_bits & 0x00000010u) { - target = stream->WriteBytesMaybeAliased( - 8, this->_internal_fileencsha256(), target); - } - - // optional string directPath = 9; - if (cached_has_bits & 0x00000020u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_directpath().data(), static_cast(this->_internal_directpath().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.AudioMessage.directPath"); - target = stream->WriteStringMaybeAliased( - 9, this->_internal_directpath(), target); - } - - // optional int64 mediaKeyTimestamp = 10; - if (cached_has_bits & 0x00001000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(10, this->_internal_mediakeytimestamp(), target); - } - - // optional .proto.ContextInfo contextInfo = 17; - if (cached_has_bits & 0x00000100u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(17, _Internal::contextinfo(this), - _Internal::contextinfo(this).GetCachedSize(), target, stream); - } - - // optional bytes streamingSidecar = 18; - if (cached_has_bits & 0x00000040u) { - target = stream->WriteBytesMaybeAliased( - 18, this->_internal_streamingsidecar(), target); - } - - // optional bytes waveform = 19; - if (cached_has_bits & 0x00000080u) { - target = stream->WriteBytesMaybeAliased( - 19, this->_internal_waveform(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.AudioMessage) - return target; -} - -size_t Message_AudioMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.AudioMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional string url = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_url()); - } - - // optional string mimetype = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_mimetype()); - } - - // optional bytes fileSha256 = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_filesha256()); - } - - // optional bytes mediaKey = 7; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_mediakey()); - } - - // optional bytes fileEncSha256 = 8; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_fileencsha256()); - } - - // optional string directPath = 9; - if (cached_has_bits & 0x00000020u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_directpath()); - } - - // optional bytes streamingSidecar = 18; - if (cached_has_bits & 0x00000040u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_streamingsidecar()); - } - - // optional bytes waveform = 19; - if (cached_has_bits & 0x00000080u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_waveform()); - } - - } - if (cached_has_bits & 0x00001f00u) { - // optional .proto.ContextInfo contextInfo = 17; - if (cached_has_bits & 0x00000100u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.contextinfo_); - } - - // optional uint64 fileLength = 4; - if (cached_has_bits & 0x00000200u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_filelength()); - } - - // optional uint32 seconds = 5; - if (cached_has_bits & 0x00000400u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_seconds()); - } - - // optional bool ptt = 6; - if (cached_has_bits & 0x00000800u) { - total_size += 1 + 1; - } - - // optional int64 mediaKeyTimestamp = 10; - if (cached_has_bits & 0x00001000u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_mediakeytimestamp()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_AudioMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_AudioMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_AudioMessage::GetClassData() const { return &_class_data_; } - - -void Message_AudioMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.AudioMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_url(from._internal_url()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_mimetype(from._internal_mimetype()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_filesha256(from._internal_filesha256()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_set_mediakey(from._internal_mediakey()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_set_fileencsha256(from._internal_fileencsha256()); - } - if (cached_has_bits & 0x00000020u) { - _this->_internal_set_directpath(from._internal_directpath()); - } - if (cached_has_bits & 0x00000040u) { - _this->_internal_set_streamingsidecar(from._internal_streamingsidecar()); - } - if (cached_has_bits & 0x00000080u) { - _this->_internal_set_waveform(from._internal_waveform()); - } - } - if (cached_has_bits & 0x00001f00u) { - if (cached_has_bits & 0x00000100u) { - _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( - from._internal_contextinfo()); - } - if (cached_has_bits & 0x00000200u) { - _this->_impl_.filelength_ = from._impl_.filelength_; - } - if (cached_has_bits & 0x00000400u) { - _this->_impl_.seconds_ = from._impl_.seconds_; - } - if (cached_has_bits & 0x00000800u) { - _this->_impl_.ptt_ = from._impl_.ptt_; - } - if (cached_has_bits & 0x00001000u) { - _this->_impl_.mediakeytimestamp_ = from._impl_.mediakeytimestamp_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_AudioMessage::CopyFrom(const Message_AudioMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.AudioMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_AudioMessage::IsInitialized() const { - return true; -} - -void Message_AudioMessage::InternalSwap(Message_AudioMessage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.url_, lhs_arena, - &other->_impl_.url_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.mimetype_, lhs_arena, - &other->_impl_.mimetype_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.filesha256_, lhs_arena, - &other->_impl_.filesha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.mediakey_, lhs_arena, - &other->_impl_.mediakey_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.fileencsha256_, lhs_arena, - &other->_impl_.fileencsha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.directpath_, lhs_arena, - &other->_impl_.directpath_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.streamingsidecar_, lhs_arena, - &other->_impl_.streamingsidecar_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.waveform_, lhs_arena, - &other->_impl_.waveform_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_AudioMessage, _impl_.mediakeytimestamp_) - + sizeof(Message_AudioMessage::_impl_.mediakeytimestamp_) - - PROTOBUF_FIELD_OFFSET(Message_AudioMessage, _impl_.contextinfo_)>( - reinterpret_cast(&_impl_.contextinfo_), - reinterpret_cast(&other->_impl_.contextinfo_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_AudioMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[60]); -} - -// =================================================================== - -class Message_ButtonsMessage_Button_ButtonText::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_displaytext(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -Message_ButtonsMessage_Button_ButtonText::Message_ButtonsMessage_Button_ButtonText(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.ButtonsMessage.Button.ButtonText) -} -Message_ButtonsMessage_Button_ButtonText::Message_ButtonsMessage_Button_ButtonText(const Message_ButtonsMessage_Button_ButtonText& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_ButtonsMessage_Button_ButtonText* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.displaytext_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.displaytext_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.displaytext_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_displaytext()) { - _this->_impl_.displaytext_.Set(from._internal_displaytext(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.Message.ButtonsMessage.Button.ButtonText) -} - -inline void Message_ButtonsMessage_Button_ButtonText::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.displaytext_){} - }; - _impl_.displaytext_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.displaytext_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_ButtonsMessage_Button_ButtonText::~Message_ButtonsMessage_Button_ButtonText() { - // @@protoc_insertion_point(destructor:proto.Message.ButtonsMessage.Button.ButtonText) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_ButtonsMessage_Button_ButtonText::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.displaytext_.Destroy(); -} - -void Message_ButtonsMessage_Button_ButtonText::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_ButtonsMessage_Button_ButtonText::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.ButtonsMessage.Button.ButtonText) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.displaytext_.ClearNonDefaultToEmpty(); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_ButtonsMessage_Button_ButtonText::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string displayText = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_displaytext(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ButtonsMessage.Button.ButtonText.displayText"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_ButtonsMessage_Button_ButtonText::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ButtonsMessage.Button.ButtonText) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string displayText = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_displaytext().data(), static_cast(this->_internal_displaytext().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ButtonsMessage.Button.ButtonText.displayText"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_displaytext(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ButtonsMessage.Button.ButtonText) - return target; -} - -size_t Message_ButtonsMessage_Button_ButtonText::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.ButtonsMessage.Button.ButtonText) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional string displayText = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_displaytext()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ButtonsMessage_Button_ButtonText::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_ButtonsMessage_Button_ButtonText::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ButtonsMessage_Button_ButtonText::GetClassData() const { return &_class_data_; } - - -void Message_ButtonsMessage_Button_ButtonText::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ButtonsMessage.Button.ButtonText) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_displaytext()) { - _this->_internal_set_displaytext(from._internal_displaytext()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_ButtonsMessage_Button_ButtonText::CopyFrom(const Message_ButtonsMessage_Button_ButtonText& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ButtonsMessage.Button.ButtonText) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_ButtonsMessage_Button_ButtonText::IsInitialized() const { - return true; -} - -void Message_ButtonsMessage_Button_ButtonText::InternalSwap(Message_ButtonsMessage_Button_ButtonText* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.displaytext_, lhs_arena, - &other->_impl_.displaytext_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_ButtonsMessage_Button_ButtonText::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[61]); -} - -// =================================================================== - -class Message_ButtonsMessage_Button_NativeFlowInfo::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_name(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_paramsjson(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -Message_ButtonsMessage_Button_NativeFlowInfo::Message_ButtonsMessage_Button_NativeFlowInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.ButtonsMessage.Button.NativeFlowInfo) -} -Message_ButtonsMessage_Button_NativeFlowInfo::Message_ButtonsMessage_Button_NativeFlowInfo(const Message_ButtonsMessage_Button_NativeFlowInfo& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_ButtonsMessage_Button_NativeFlowInfo* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.name_){} - , decltype(_impl_.paramsjson_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.name_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.name_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_name()) { - _this->_impl_.name_.Set(from._internal_name(), - _this->GetArenaForAllocation()); - } - _impl_.paramsjson_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.paramsjson_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_paramsjson()) { - _this->_impl_.paramsjson_.Set(from._internal_paramsjson(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.Message.ButtonsMessage.Button.NativeFlowInfo) -} - -inline void Message_ButtonsMessage_Button_NativeFlowInfo::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.name_){} - , decltype(_impl_.paramsjson_){} - }; - _impl_.name_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.name_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.paramsjson_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.paramsjson_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_ButtonsMessage_Button_NativeFlowInfo::~Message_ButtonsMessage_Button_NativeFlowInfo() { - // @@protoc_insertion_point(destructor:proto.Message.ButtonsMessage.Button.NativeFlowInfo) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_ButtonsMessage_Button_NativeFlowInfo::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.name_.Destroy(); - _impl_.paramsjson_.Destroy(); -} - -void Message_ButtonsMessage_Button_NativeFlowInfo::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_ButtonsMessage_Button_NativeFlowInfo::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.ButtonsMessage.Button.NativeFlowInfo) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.name_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.paramsjson_.ClearNonDefaultToEmpty(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_ButtonsMessage_Button_NativeFlowInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string name = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_name(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ButtonsMessage.Button.NativeFlowInfo.name"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string paramsJson = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_paramsjson(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ButtonsMessage.Button.NativeFlowInfo.paramsJson"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_ButtonsMessage_Button_NativeFlowInfo::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ButtonsMessage.Button.NativeFlowInfo) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string name = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_name().data(), static_cast(this->_internal_name().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ButtonsMessage.Button.NativeFlowInfo.name"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_name(), target); - } - - // optional string paramsJson = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_paramsjson().data(), static_cast(this->_internal_paramsjson().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ButtonsMessage.Button.NativeFlowInfo.paramsJson"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_paramsjson(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ButtonsMessage.Button.NativeFlowInfo) - return target; -} - -size_t Message_ButtonsMessage_Button_NativeFlowInfo::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.ButtonsMessage.Button.NativeFlowInfo) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional string name = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_name()); - } - - // optional string paramsJson = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_paramsjson()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ButtonsMessage_Button_NativeFlowInfo::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_ButtonsMessage_Button_NativeFlowInfo::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ButtonsMessage_Button_NativeFlowInfo::GetClassData() const { return &_class_data_; } - - -void Message_ButtonsMessage_Button_NativeFlowInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ButtonsMessage.Button.NativeFlowInfo) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_name(from._internal_name()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_paramsjson(from._internal_paramsjson()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_ButtonsMessage_Button_NativeFlowInfo::CopyFrom(const Message_ButtonsMessage_Button_NativeFlowInfo& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ButtonsMessage.Button.NativeFlowInfo) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_ButtonsMessage_Button_NativeFlowInfo::IsInitialized() const { - return true; -} - -void Message_ButtonsMessage_Button_NativeFlowInfo::InternalSwap(Message_ButtonsMessage_Button_NativeFlowInfo* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.name_, lhs_arena, - &other->_impl_.name_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.paramsjson_, lhs_arena, - &other->_impl_.paramsjson_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_ButtonsMessage_Button_NativeFlowInfo::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[62]); -} - -// =================================================================== - -class Message_ButtonsMessage_Button::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_buttonid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::proto::Message_ButtonsMessage_Button_ButtonText& buttontext(const Message_ButtonsMessage_Button* msg); - static void set_has_buttontext(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_type(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static const ::proto::Message_ButtonsMessage_Button_NativeFlowInfo& nativeflowinfo(const Message_ButtonsMessage_Button* msg); - static void set_has_nativeflowinfo(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } -}; - -const ::proto::Message_ButtonsMessage_Button_ButtonText& -Message_ButtonsMessage_Button::_Internal::buttontext(const Message_ButtonsMessage_Button* msg) { - return *msg->_impl_.buttontext_; -} -const ::proto::Message_ButtonsMessage_Button_NativeFlowInfo& -Message_ButtonsMessage_Button::_Internal::nativeflowinfo(const Message_ButtonsMessage_Button* msg) { - return *msg->_impl_.nativeflowinfo_; -} -Message_ButtonsMessage_Button::Message_ButtonsMessage_Button(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.ButtonsMessage.Button) -} -Message_ButtonsMessage_Button::Message_ButtonsMessage_Button(const Message_ButtonsMessage_Button& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_ButtonsMessage_Button* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.buttonid_){} - , decltype(_impl_.buttontext_){nullptr} - , decltype(_impl_.nativeflowinfo_){nullptr} - , decltype(_impl_.type_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.buttonid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.buttonid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_buttonid()) { - _this->_impl_.buttonid_.Set(from._internal_buttonid(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_buttontext()) { - _this->_impl_.buttontext_ = new ::proto::Message_ButtonsMessage_Button_ButtonText(*from._impl_.buttontext_); - } - if (from._internal_has_nativeflowinfo()) { - _this->_impl_.nativeflowinfo_ = new ::proto::Message_ButtonsMessage_Button_NativeFlowInfo(*from._impl_.nativeflowinfo_); - } - _this->_impl_.type_ = from._impl_.type_; - // @@protoc_insertion_point(copy_constructor:proto.Message.ButtonsMessage.Button) -} - -inline void Message_ButtonsMessage_Button::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.buttonid_){} - , decltype(_impl_.buttontext_){nullptr} - , decltype(_impl_.nativeflowinfo_){nullptr} - , decltype(_impl_.type_){0} - }; - _impl_.buttonid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.buttonid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_ButtonsMessage_Button::~Message_ButtonsMessage_Button() { - // @@protoc_insertion_point(destructor:proto.Message.ButtonsMessage.Button) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_ButtonsMessage_Button::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.buttonid_.Destroy(); - if (this != internal_default_instance()) delete _impl_.buttontext_; - if (this != internal_default_instance()) delete _impl_.nativeflowinfo_; -} - -void Message_ButtonsMessage_Button::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_ButtonsMessage_Button::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.ButtonsMessage.Button) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _impl_.buttonid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.buttontext_ != nullptr); - _impl_.buttontext_->Clear(); - } - if (cached_has_bits & 0x00000004u) { - GOOGLE_DCHECK(_impl_.nativeflowinfo_ != nullptr); - _impl_.nativeflowinfo_->Clear(); - } - } - _impl_.type_ = 0; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_ButtonsMessage_Button::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string buttonId = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_buttonid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ButtonsMessage.Button.buttonId"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.Message.ButtonsMessage.Button.ButtonText buttonText = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_buttontext(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.ButtonsMessage.Button.Type type = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::Message_ButtonsMessage_Button_Type_IsValid(val))) { - _internal_set_type(static_cast<::proto::Message_ButtonsMessage_Button_Type>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.Message.ButtonsMessage.Button.NativeFlowInfo nativeFlowInfo = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_nativeflowinfo(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_ButtonsMessage_Button::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ButtonsMessage.Button) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string buttonId = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_buttonid().data(), static_cast(this->_internal_buttonid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ButtonsMessage.Button.buttonId"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_buttonid(), target); - } - - // optional .proto.Message.ButtonsMessage.Button.ButtonText buttonText = 2; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::buttontext(this), - _Internal::buttontext(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.ButtonsMessage.Button.Type type = 3; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 3, this->_internal_type(), target); - } - - // optional .proto.Message.ButtonsMessage.Button.NativeFlowInfo nativeFlowInfo = 4; - if (cached_has_bits & 0x00000004u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(4, _Internal::nativeflowinfo(this), - _Internal::nativeflowinfo(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ButtonsMessage.Button) - return target; -} - -size_t Message_ButtonsMessage_Button::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.ButtonsMessage.Button) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - // optional string buttonId = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_buttonid()); - } - - // optional .proto.Message.ButtonsMessage.Button.ButtonText buttonText = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.buttontext_); - } - - // optional .proto.Message.ButtonsMessage.Button.NativeFlowInfo nativeFlowInfo = 4; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.nativeflowinfo_); - } - - // optional .proto.Message.ButtonsMessage.Button.Type type = 3; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_type()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ButtonsMessage_Button::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_ButtonsMessage_Button::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ButtonsMessage_Button::GetClassData() const { return &_class_data_; } - - -void Message_ButtonsMessage_Button::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ButtonsMessage.Button) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_buttonid(from._internal_buttonid()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_buttontext()->::proto::Message_ButtonsMessage_Button_ButtonText::MergeFrom( - from._internal_buttontext()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_mutable_nativeflowinfo()->::proto::Message_ButtonsMessage_Button_NativeFlowInfo::MergeFrom( - from._internal_nativeflowinfo()); - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.type_ = from._impl_.type_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_ButtonsMessage_Button::CopyFrom(const Message_ButtonsMessage_Button& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ButtonsMessage.Button) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_ButtonsMessage_Button::IsInitialized() const { - return true; -} - -void Message_ButtonsMessage_Button::InternalSwap(Message_ButtonsMessage_Button* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.buttonid_, lhs_arena, - &other->_impl_.buttonid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_ButtonsMessage_Button, _impl_.type_) - + sizeof(Message_ButtonsMessage_Button::_impl_.type_) - - PROTOBUF_FIELD_OFFSET(Message_ButtonsMessage_Button, _impl_.buttontext_)>( - reinterpret_cast(&_impl_.buttontext_), - reinterpret_cast(&other->_impl_.buttontext_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_ButtonsMessage_Button::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[63]); -} - -// =================================================================== - -class Message_ButtonsMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_contenttext(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_footertext(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::proto::ContextInfo& contextinfo(const Message_ButtonsMessage* msg); - static void set_has_contextinfo(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_headertype(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static const ::proto::Message_DocumentMessage& documentmessage(const Message_ButtonsMessage* msg); - static const ::proto::Message_ImageMessage& imagemessage(const Message_ButtonsMessage* msg); - static const ::proto::Message_VideoMessage& videomessage(const Message_ButtonsMessage* msg); - static const ::proto::Message_LocationMessage& locationmessage(const Message_ButtonsMessage* msg); -}; - -const ::proto::ContextInfo& -Message_ButtonsMessage::_Internal::contextinfo(const Message_ButtonsMessage* msg) { - return *msg->_impl_.contextinfo_; -} -const ::proto::Message_DocumentMessage& -Message_ButtonsMessage::_Internal::documentmessage(const Message_ButtonsMessage* msg) { - return *msg->_impl_.header_.documentmessage_; -} -const ::proto::Message_ImageMessage& -Message_ButtonsMessage::_Internal::imagemessage(const Message_ButtonsMessage* msg) { - return *msg->_impl_.header_.imagemessage_; -} -const ::proto::Message_VideoMessage& -Message_ButtonsMessage::_Internal::videomessage(const Message_ButtonsMessage* msg) { - return *msg->_impl_.header_.videomessage_; -} -const ::proto::Message_LocationMessage& -Message_ButtonsMessage::_Internal::locationmessage(const Message_ButtonsMessage* msg) { - return *msg->_impl_.header_.locationmessage_; -} -void Message_ButtonsMessage::set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_header(); - if (documentmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(documentmessage); - if (message_arena != submessage_arena) { - documentmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, documentmessage, submessage_arena); - } - set_has_documentmessage(); - _impl_.header_.documentmessage_ = documentmessage; - } - // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.documentMessage) -} -void Message_ButtonsMessage::set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_header(); - if (imagemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(imagemessage); - if (message_arena != submessage_arena) { - imagemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, imagemessage, submessage_arena); - } - set_has_imagemessage(); - _impl_.header_.imagemessage_ = imagemessage; - } - // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.imageMessage) -} -void Message_ButtonsMessage::set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_header(); - if (videomessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(videomessage); - if (message_arena != submessage_arena) { - videomessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, videomessage, submessage_arena); - } - set_has_videomessage(); - _impl_.header_.videomessage_ = videomessage; - } - // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.videoMessage) -} -void Message_ButtonsMessage::set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_header(); - if (locationmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(locationmessage); - if (message_arena != submessage_arena) { - locationmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, locationmessage, submessage_arena); - } - set_has_locationmessage(); - _impl_.header_.locationmessage_ = locationmessage; - } - // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.locationMessage) -} -Message_ButtonsMessage::Message_ButtonsMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.ButtonsMessage) -} -Message_ButtonsMessage::Message_ButtonsMessage(const Message_ButtonsMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_ButtonsMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.buttons_){from._impl_.buttons_} - , decltype(_impl_.contenttext_){} - , decltype(_impl_.footertext_){} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.headertype_){} - , decltype(_impl_.header_){} - , /*decltype(_impl_._oneof_case_)*/{}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.contenttext_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.contenttext_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_contenttext()) { - _this->_impl_.contenttext_.Set(from._internal_contenttext(), - _this->GetArenaForAllocation()); - } - _impl_.footertext_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.footertext_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_footertext()) { - _this->_impl_.footertext_.Set(from._internal_footertext(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_contextinfo()) { - _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); - } - _this->_impl_.headertype_ = from._impl_.headertype_; - clear_has_header(); - switch (from.header_case()) { - case kText: { - _this->_internal_set_text(from._internal_text()); - break; - } - case kDocumentMessage: { - _this->_internal_mutable_documentmessage()->::proto::Message_DocumentMessage::MergeFrom( - from._internal_documentmessage()); - break; - } - case kImageMessage: { - _this->_internal_mutable_imagemessage()->::proto::Message_ImageMessage::MergeFrom( - from._internal_imagemessage()); - break; - } - case kVideoMessage: { - _this->_internal_mutable_videomessage()->::proto::Message_VideoMessage::MergeFrom( - from._internal_videomessage()); - break; - } - case kLocationMessage: { - _this->_internal_mutable_locationmessage()->::proto::Message_LocationMessage::MergeFrom( - from._internal_locationmessage()); - break; - } - case HEADER_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:proto.Message.ButtonsMessage) -} - -inline void Message_ButtonsMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.buttons_){arena} - , decltype(_impl_.contenttext_){} - , decltype(_impl_.footertext_){} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.headertype_){0} - , decltype(_impl_.header_){} - , /*decltype(_impl_._oneof_case_)*/{} - }; - _impl_.contenttext_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.contenttext_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.footertext_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.footertext_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - clear_has_header(); -} - -Message_ButtonsMessage::~Message_ButtonsMessage() { - // @@protoc_insertion_point(destructor:proto.Message.ButtonsMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_ButtonsMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.buttons_.~RepeatedPtrField(); - _impl_.contenttext_.Destroy(); - _impl_.footertext_.Destroy(); - if (this != internal_default_instance()) delete _impl_.contextinfo_; - if (has_header()) { - clear_header(); - } -} - -void Message_ButtonsMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_ButtonsMessage::clear_header() { -// @@protoc_insertion_point(one_of_clear_start:proto.Message.ButtonsMessage) - switch (header_case()) { - case kText: { - _impl_.header_.text_.Destroy(); - break; - } - case kDocumentMessage: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.header_.documentmessage_; - } - break; - } - case kImageMessage: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.header_.imagemessage_; - } - break; - } - case kVideoMessage: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.header_.videomessage_; - } - break; - } - case kLocationMessage: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.header_.locationmessage_; - } - break; - } - case HEADER_NOT_SET: { - break; - } - } - _impl_._oneof_case_[0] = HEADER_NOT_SET; -} - - -void Message_ButtonsMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.ButtonsMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.buttons_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _impl_.contenttext_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.footertext_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); - _impl_.contextinfo_->Clear(); - } - } - _impl_.headertype_ = 0; - clear_header(); - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_ButtonsMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // string text = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_text(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ButtonsMessage.text"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // .proto.Message.DocumentMessage documentMessage = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_documentmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .proto.Message.ImageMessage imageMessage = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_imagemessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .proto.Message.VideoMessage videoMessage = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_videomessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .proto.Message.LocationMessage locationMessage = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - ptr = ctx->ParseMessage(_internal_mutable_locationmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string contentText = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - auto str = _internal_mutable_contenttext(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ButtonsMessage.contentText"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string footerText = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - auto str = _internal_mutable_footertext(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ButtonsMessage.footerText"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.ContextInfo contextInfo = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { - ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated .proto.Message.ButtonsMessage.Button buttons = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_buttons(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<74>(ptr)); - } else - goto handle_unusual; - continue; - // optional .proto.Message.ButtonsMessage.HeaderType headerType = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::Message_ButtonsMessage_HeaderType_IsValid(val))) { - _internal_set_headertype(static_cast<::proto::Message_ButtonsMessage_HeaderType>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(10, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_ButtonsMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ButtonsMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - switch (header_case()) { - case kText: { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_text().data(), static_cast(this->_internal_text().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ButtonsMessage.text"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_text(), target); - break; - } - case kDocumentMessage: { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::documentmessage(this), - _Internal::documentmessage(this).GetCachedSize(), target, stream); - break; - } - case kImageMessage: { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, _Internal::imagemessage(this), - _Internal::imagemessage(this).GetCachedSize(), target, stream); - break; - } - case kVideoMessage: { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(4, _Internal::videomessage(this), - _Internal::videomessage(this).GetCachedSize(), target, stream); - break; - } - case kLocationMessage: { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(5, _Internal::locationmessage(this), - _Internal::locationmessage(this).GetCachedSize(), target, stream); - break; - } - default: ; - } - cached_has_bits = _impl_._has_bits_[0]; - // optional string contentText = 6; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_contenttext().data(), static_cast(this->_internal_contenttext().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ButtonsMessage.contentText"); - target = stream->WriteStringMaybeAliased( - 6, this->_internal_contenttext(), target); - } - - // optional string footerText = 7; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_footertext().data(), static_cast(this->_internal_footertext().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ButtonsMessage.footerText"); - target = stream->WriteStringMaybeAliased( - 7, this->_internal_footertext(), target); - } - - // optional .proto.ContextInfo contextInfo = 8; - if (cached_has_bits & 0x00000004u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(8, _Internal::contextinfo(this), - _Internal::contextinfo(this).GetCachedSize(), target, stream); - } - - // repeated .proto.Message.ButtonsMessage.Button buttons = 9; - for (unsigned i = 0, - n = static_cast(this->_internal_buttons_size()); i < n; i++) { - const auto& repfield = this->_internal_buttons(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(9, repfield, repfield.GetCachedSize(), target, stream); - } - - // optional .proto.Message.ButtonsMessage.HeaderType headerType = 10; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 10, this->_internal_headertype(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ButtonsMessage) - return target; -} - -size_t Message_ButtonsMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.ButtonsMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.Message.ButtonsMessage.Button buttons = 9; - total_size += 1UL * this->_internal_buttons_size(); - for (const auto& msg : this->_impl_.buttons_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - // optional string contentText = 6; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_contenttext()); - } - - // optional string footerText = 7; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_footertext()); - } - - // optional .proto.ContextInfo contextInfo = 8; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.contextinfo_); - } - - // optional .proto.Message.ButtonsMessage.HeaderType headerType = 10; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_headertype()); - } - - } - switch (header_case()) { - // string text = 1; - case kText: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_text()); - break; - } - // .proto.Message.DocumentMessage documentMessage = 2; - case kDocumentMessage: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.header_.documentmessage_); - break; - } - // .proto.Message.ImageMessage imageMessage = 3; - case kImageMessage: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.header_.imagemessage_); - break; - } - // .proto.Message.VideoMessage videoMessage = 4; - case kVideoMessage: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.header_.videomessage_); - break; - } - // .proto.Message.LocationMessage locationMessage = 5; - case kLocationMessage: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.header_.locationmessage_); - break; - } - case HEADER_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ButtonsMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_ButtonsMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ButtonsMessage::GetClassData() const { return &_class_data_; } - - -void Message_ButtonsMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ButtonsMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.buttons_.MergeFrom(from._impl_.buttons_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_contenttext(from._internal_contenttext()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_footertext(from._internal_footertext()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( - from._internal_contextinfo()); - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.headertype_ = from._impl_.headertype_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - switch (from.header_case()) { - case kText: { - _this->_internal_set_text(from._internal_text()); - break; - } - case kDocumentMessage: { - _this->_internal_mutable_documentmessage()->::proto::Message_DocumentMessage::MergeFrom( - from._internal_documentmessage()); - break; - } - case kImageMessage: { - _this->_internal_mutable_imagemessage()->::proto::Message_ImageMessage::MergeFrom( - from._internal_imagemessage()); - break; - } - case kVideoMessage: { - _this->_internal_mutable_videomessage()->::proto::Message_VideoMessage::MergeFrom( - from._internal_videomessage()); - break; - } - case kLocationMessage: { - _this->_internal_mutable_locationmessage()->::proto::Message_LocationMessage::MergeFrom( - from._internal_locationmessage()); - break; - } - case HEADER_NOT_SET: { - break; - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_ButtonsMessage::CopyFrom(const Message_ButtonsMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ButtonsMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_ButtonsMessage::IsInitialized() const { - return true; -} - -void Message_ButtonsMessage::InternalSwap(Message_ButtonsMessage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.buttons_.InternalSwap(&other->_impl_.buttons_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.contenttext_, lhs_arena, - &other->_impl_.contenttext_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.footertext_, lhs_arena, - &other->_impl_.footertext_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_ButtonsMessage, _impl_.headertype_) - + sizeof(Message_ButtonsMessage::_impl_.headertype_) - - PROTOBUF_FIELD_OFFSET(Message_ButtonsMessage, _impl_.contextinfo_)>( - reinterpret_cast(&_impl_.contextinfo_), - reinterpret_cast(&other->_impl_.contextinfo_)); - swap(_impl_.header_, other->_impl_.header_); - swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_ButtonsMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[64]); -} - -// =================================================================== - -class Message_ButtonsResponseMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_selectedbuttonid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::proto::ContextInfo& contextinfo(const Message_ButtonsResponseMessage* msg); - static void set_has_contextinfo(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_type(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } -}; - -const ::proto::ContextInfo& -Message_ButtonsResponseMessage::_Internal::contextinfo(const Message_ButtonsResponseMessage* msg) { - return *msg->_impl_.contextinfo_; -} -Message_ButtonsResponseMessage::Message_ButtonsResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.ButtonsResponseMessage) -} -Message_ButtonsResponseMessage::Message_ButtonsResponseMessage(const Message_ButtonsResponseMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_ButtonsResponseMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.selectedbuttonid_){} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.type_){} - , decltype(_impl_.response_){} - , /*decltype(_impl_._oneof_case_)*/{}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.selectedbuttonid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.selectedbuttonid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_selectedbuttonid()) { - _this->_impl_.selectedbuttonid_.Set(from._internal_selectedbuttonid(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_contextinfo()) { - _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); - } - _this->_impl_.type_ = from._impl_.type_; - clear_has_response(); - switch (from.response_case()) { - case kSelectedDisplayText: { - _this->_internal_set_selecteddisplaytext(from._internal_selecteddisplaytext()); - break; - } - case RESPONSE_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:proto.Message.ButtonsResponseMessage) -} - -inline void Message_ButtonsResponseMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.selectedbuttonid_){} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.type_){0} - , decltype(_impl_.response_){} - , /*decltype(_impl_._oneof_case_)*/{} - }; - _impl_.selectedbuttonid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.selectedbuttonid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - clear_has_response(); -} - -Message_ButtonsResponseMessage::~Message_ButtonsResponseMessage() { - // @@protoc_insertion_point(destructor:proto.Message.ButtonsResponseMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_ButtonsResponseMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.selectedbuttonid_.Destroy(); - if (this != internal_default_instance()) delete _impl_.contextinfo_; - if (has_response()) { - clear_response(); - } -} - -void Message_ButtonsResponseMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_ButtonsResponseMessage::clear_response() { -// @@protoc_insertion_point(one_of_clear_start:proto.Message.ButtonsResponseMessage) - switch (response_case()) { - case kSelectedDisplayText: { - _impl_.response_.selecteddisplaytext_.Destroy(); - break; - } - case RESPONSE_NOT_SET: { - break; - } - } - _impl_._oneof_case_[0] = RESPONSE_NOT_SET; -} - - -void Message_ButtonsResponseMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.ButtonsResponseMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.selectedbuttonid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); - _impl_.contextinfo_->Clear(); - } - } - _impl_.type_ = 0; - clear_response(); - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_ButtonsResponseMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string selectedButtonId = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_selectedbuttonid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ButtonsResponseMessage.selectedButtonId"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // string selectedDisplayText = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_selecteddisplaytext(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ButtonsResponseMessage.selectedDisplayText"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.ContextInfo contextInfo = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.ButtonsResponseMessage.Type type = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::Message_ButtonsResponseMessage_Type_IsValid(val))) { - _internal_set_type(static_cast<::proto::Message_ButtonsResponseMessage_Type>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_ButtonsResponseMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ButtonsResponseMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string selectedButtonId = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_selectedbuttonid().data(), static_cast(this->_internal_selectedbuttonid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ButtonsResponseMessage.selectedButtonId"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_selectedbuttonid(), target); - } - - // string selectedDisplayText = 2; - if (_internal_has_selecteddisplaytext()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_selecteddisplaytext().data(), static_cast(this->_internal_selecteddisplaytext().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ButtonsResponseMessage.selectedDisplayText"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_selecteddisplaytext(), target); - } - - // optional .proto.ContextInfo contextInfo = 3; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, _Internal::contextinfo(this), - _Internal::contextinfo(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.ButtonsResponseMessage.Type type = 4; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 4, this->_internal_type(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ButtonsResponseMessage) - return target; -} - -size_t Message_ButtonsResponseMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.ButtonsResponseMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional string selectedButtonId = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_selectedbuttonid()); - } - - // optional .proto.ContextInfo contextInfo = 3; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.contextinfo_); - } - - // optional .proto.Message.ButtonsResponseMessage.Type type = 4; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_type()); - } - - } - switch (response_case()) { - // string selectedDisplayText = 2; - case kSelectedDisplayText: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_selecteddisplaytext()); - break; - } - case RESPONSE_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ButtonsResponseMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_ButtonsResponseMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ButtonsResponseMessage::GetClassData() const { return &_class_data_; } - - -void Message_ButtonsResponseMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ButtonsResponseMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_selectedbuttonid(from._internal_selectedbuttonid()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( - from._internal_contextinfo()); - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.type_ = from._impl_.type_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - switch (from.response_case()) { - case kSelectedDisplayText: { - _this->_internal_set_selecteddisplaytext(from._internal_selecteddisplaytext()); - break; - } - case RESPONSE_NOT_SET: { - break; - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_ButtonsResponseMessage::CopyFrom(const Message_ButtonsResponseMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ButtonsResponseMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_ButtonsResponseMessage::IsInitialized() const { - return true; -} - -void Message_ButtonsResponseMessage::InternalSwap(Message_ButtonsResponseMessage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.selectedbuttonid_, lhs_arena, - &other->_impl_.selectedbuttonid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_ButtonsResponseMessage, _impl_.type_) - + sizeof(Message_ButtonsResponseMessage::_impl_.type_) - - PROTOBUF_FIELD_OFFSET(Message_ButtonsResponseMessage, _impl_.contextinfo_)>( - reinterpret_cast(&_impl_.contextinfo_), - reinterpret_cast(&other->_impl_.contextinfo_)); - swap(_impl_.response_, other->_impl_.response_); - swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_ButtonsResponseMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[65]); -} - -// =================================================================== - -class Message_Call::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_callkey(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_conversionsource(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_conversiondata(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_conversiondelayseconds(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } -}; - -Message_Call::Message_Call(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.Call) -} -Message_Call::Message_Call(const Message_Call& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_Call* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.callkey_){} - , decltype(_impl_.conversionsource_){} - , decltype(_impl_.conversiondata_){} - , decltype(_impl_.conversiondelayseconds_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.callkey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.callkey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_callkey()) { - _this->_impl_.callkey_.Set(from._internal_callkey(), - _this->GetArenaForAllocation()); - } - _impl_.conversionsource_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.conversionsource_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_conversionsource()) { - _this->_impl_.conversionsource_.Set(from._internal_conversionsource(), - _this->GetArenaForAllocation()); - } - _impl_.conversiondata_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.conversiondata_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_conversiondata()) { - _this->_impl_.conversiondata_.Set(from._internal_conversiondata(), - _this->GetArenaForAllocation()); - } - _this->_impl_.conversiondelayseconds_ = from._impl_.conversiondelayseconds_; - // @@protoc_insertion_point(copy_constructor:proto.Message.Call) -} - -inline void Message_Call::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.callkey_){} - , decltype(_impl_.conversionsource_){} - , decltype(_impl_.conversiondata_){} - , decltype(_impl_.conversiondelayseconds_){0u} - }; - _impl_.callkey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.callkey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.conversionsource_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.conversionsource_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.conversiondata_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.conversiondata_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_Call::~Message_Call() { - // @@protoc_insertion_point(destructor:proto.Message.Call) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_Call::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.callkey_.Destroy(); - _impl_.conversionsource_.Destroy(); - _impl_.conversiondata_.Destroy(); -} - -void Message_Call::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_Call::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.Call) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _impl_.callkey_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.conversionsource_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.conversiondata_.ClearNonDefaultToEmpty(); - } - } - _impl_.conversiondelayseconds_ = 0u; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_Call::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bytes callKey = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_callkey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string conversionSource = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_conversionsource(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.Call.conversionSource"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bytes conversionData = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_conversiondata(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 conversionDelaySeconds = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - _Internal::set_has_conversiondelayseconds(&has_bits); - _impl_.conversiondelayseconds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_Call::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.Call) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bytes callKey = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 1, this->_internal_callkey(), target); - } - - // optional string conversionSource = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_conversionsource().data(), static_cast(this->_internal_conversionsource().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.Call.conversionSource"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_conversionsource(), target); - } - - // optional bytes conversionData = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->WriteBytesMaybeAliased( - 3, this->_internal_conversiondata(), target); - } - - // optional uint32 conversionDelaySeconds = 4; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_conversiondelayseconds(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.Call) - return target; -} - -size_t Message_Call::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.Call) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - // optional bytes callKey = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_callkey()); - } - - // optional string conversionSource = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_conversionsource()); - } - - // optional bytes conversionData = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_conversiondata()); - } - - // optional uint32 conversionDelaySeconds = 4; - if (cached_has_bits & 0x00000008u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_conversiondelayseconds()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_Call::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_Call::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_Call::GetClassData() const { return &_class_data_; } - - -void Message_Call::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.Call) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_callkey(from._internal_callkey()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_conversionsource(from._internal_conversionsource()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_conversiondata(from._internal_conversiondata()); - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.conversiondelayseconds_ = from._impl_.conversiondelayseconds_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_Call::CopyFrom(const Message_Call& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.Call) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_Call::IsInitialized() const { - return true; -} - -void Message_Call::InternalSwap(Message_Call* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.callkey_, lhs_arena, - &other->_impl_.callkey_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.conversionsource_, lhs_arena, - &other->_impl_.conversionsource_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.conversiondata_, lhs_arena, - &other->_impl_.conversiondata_, rhs_arena - ); - swap(_impl_.conversiondelayseconds_, other->_impl_.conversiondelayseconds_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_Call::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[66]); -} - -// =================================================================== - -class Message_CancelPaymentRequestMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::MessageKey& key(const Message_CancelPaymentRequestMessage* msg); - static void set_has_key(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -const ::proto::MessageKey& -Message_CancelPaymentRequestMessage::_Internal::key(const Message_CancelPaymentRequestMessage* msg) { - return *msg->_impl_.key_; -} -Message_CancelPaymentRequestMessage::Message_CancelPaymentRequestMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.CancelPaymentRequestMessage) -} -Message_CancelPaymentRequestMessage::Message_CancelPaymentRequestMessage(const Message_CancelPaymentRequestMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_CancelPaymentRequestMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.key_){nullptr}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_key()) { - _this->_impl_.key_ = new ::proto::MessageKey(*from._impl_.key_); - } - // @@protoc_insertion_point(copy_constructor:proto.Message.CancelPaymentRequestMessage) -} - -inline void Message_CancelPaymentRequestMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.key_){nullptr} - }; -} - -Message_CancelPaymentRequestMessage::~Message_CancelPaymentRequestMessage() { - // @@protoc_insertion_point(destructor:proto.Message.CancelPaymentRequestMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_CancelPaymentRequestMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete _impl_.key_; -} - -void Message_CancelPaymentRequestMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_CancelPaymentRequestMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.CancelPaymentRequestMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.key_ != nullptr); - _impl_.key_->Clear(); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_CancelPaymentRequestMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.MessageKey key = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_CancelPaymentRequestMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.CancelPaymentRequestMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.MessageKey key = 1; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::key(this), - _Internal::key(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.CancelPaymentRequestMessage) - return target; -} - -size_t Message_CancelPaymentRequestMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.CancelPaymentRequestMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional .proto.MessageKey key = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.key_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_CancelPaymentRequestMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_CancelPaymentRequestMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_CancelPaymentRequestMessage::GetClassData() const { return &_class_data_; } - - -void Message_CancelPaymentRequestMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.CancelPaymentRequestMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_key()) { - _this->_internal_mutable_key()->::proto::MessageKey::MergeFrom( - from._internal_key()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_CancelPaymentRequestMessage::CopyFrom(const Message_CancelPaymentRequestMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.CancelPaymentRequestMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_CancelPaymentRequestMessage::IsInitialized() const { - return true; -} - -void Message_CancelPaymentRequestMessage::InternalSwap(Message_CancelPaymentRequestMessage* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - swap(_impl_.key_, other->_impl_.key_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_CancelPaymentRequestMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[67]); -} - -// =================================================================== - -class Message_Chat::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_displayname(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_id(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -Message_Chat::Message_Chat(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.Chat) -} -Message_Chat::Message_Chat(const Message_Chat& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_Chat* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.displayname_){} - , decltype(_impl_.id_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.displayname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.displayname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_displayname()) { - _this->_impl_.displayname_.Set(from._internal_displayname(), - _this->GetArenaForAllocation()); - } - _impl_.id_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.id_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_id()) { - _this->_impl_.id_.Set(from._internal_id(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.Message.Chat) -} - -inline void Message_Chat::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.displayname_){} - , decltype(_impl_.id_){} - }; - _impl_.displayname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.displayname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.id_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.id_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_Chat::~Message_Chat() { - // @@protoc_insertion_point(destructor:proto.Message.Chat) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_Chat::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.displayname_.Destroy(); - _impl_.id_.Destroy(); -} - -void Message_Chat::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_Chat::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.Chat) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.displayname_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.id_.ClearNonDefaultToEmpty(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_Chat::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string displayName = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_displayname(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.Chat.displayName"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string id = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_id(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.Chat.id"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_Chat::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.Chat) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string displayName = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_displayname().data(), static_cast(this->_internal_displayname().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.Chat.displayName"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_displayname(), target); - } - - // optional string id = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_id().data(), static_cast(this->_internal_id().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.Chat.id"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_id(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.Chat) - return target; -} - -size_t Message_Chat::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.Chat) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional string displayName = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_displayname()); - } - - // optional string id = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_id()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_Chat::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_Chat::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_Chat::GetClassData() const { return &_class_data_; } - - -void Message_Chat::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.Chat) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_displayname(from._internal_displayname()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_id(from._internal_id()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_Chat::CopyFrom(const Message_Chat& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.Chat) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_Chat::IsInitialized() const { - return true; -} - -void Message_Chat::InternalSwap(Message_Chat* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.displayname_, lhs_arena, - &other->_impl_.displayname_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.id_, lhs_arena, - &other->_impl_.id_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_Chat::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[68]); -} - -// =================================================================== - -class Message_ContactMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_displayname(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_vcard(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::proto::ContextInfo& contextinfo(const Message_ContactMessage* msg); - static void set_has_contextinfo(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } -}; - -const ::proto::ContextInfo& -Message_ContactMessage::_Internal::contextinfo(const Message_ContactMessage* msg) { - return *msg->_impl_.contextinfo_; -} -Message_ContactMessage::Message_ContactMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.ContactMessage) -} -Message_ContactMessage::Message_ContactMessage(const Message_ContactMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_ContactMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.displayname_){} - , decltype(_impl_.vcard_){} - , decltype(_impl_.contextinfo_){nullptr}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.displayname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.displayname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_displayname()) { - _this->_impl_.displayname_.Set(from._internal_displayname(), - _this->GetArenaForAllocation()); - } - _impl_.vcard_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.vcard_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_vcard()) { - _this->_impl_.vcard_.Set(from._internal_vcard(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_contextinfo()) { - _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); - } - // @@protoc_insertion_point(copy_constructor:proto.Message.ContactMessage) -} - -inline void Message_ContactMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.displayname_){} - , decltype(_impl_.vcard_){} - , decltype(_impl_.contextinfo_){nullptr} - }; - _impl_.displayname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.displayname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.vcard_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.vcard_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_ContactMessage::~Message_ContactMessage() { - // @@protoc_insertion_point(destructor:proto.Message.ContactMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_ContactMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.displayname_.Destroy(); - _impl_.vcard_.Destroy(); - if (this != internal_default_instance()) delete _impl_.contextinfo_; -} - -void Message_ContactMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_ContactMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.ContactMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _impl_.displayname_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.vcard_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); - _impl_.contextinfo_->Clear(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_ContactMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string displayName = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_displayname(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ContactMessage.displayName"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string vcard = 16; - case 16: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { - auto str = _internal_mutable_vcard(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ContactMessage.vcard"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.ContextInfo contextInfo = 17; - case 17: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { - ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_ContactMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ContactMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string displayName = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_displayname().data(), static_cast(this->_internal_displayname().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ContactMessage.displayName"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_displayname(), target); - } - - // optional string vcard = 16; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_vcard().data(), static_cast(this->_internal_vcard().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ContactMessage.vcard"); - target = stream->WriteStringMaybeAliased( - 16, this->_internal_vcard(), target); - } - - // optional .proto.ContextInfo contextInfo = 17; - if (cached_has_bits & 0x00000004u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(17, _Internal::contextinfo(this), - _Internal::contextinfo(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ContactMessage) - return target; -} - -size_t Message_ContactMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.ContactMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional string displayName = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_displayname()); - } - - // optional string vcard = 16; - if (cached_has_bits & 0x00000002u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_vcard()); - } - - // optional .proto.ContextInfo contextInfo = 17; - if (cached_has_bits & 0x00000004u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.contextinfo_); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ContactMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_ContactMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ContactMessage::GetClassData() const { return &_class_data_; } - - -void Message_ContactMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ContactMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_displayname(from._internal_displayname()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_vcard(from._internal_vcard()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( - from._internal_contextinfo()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_ContactMessage::CopyFrom(const Message_ContactMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ContactMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_ContactMessage::IsInitialized() const { - return true; -} - -void Message_ContactMessage::InternalSwap(Message_ContactMessage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.displayname_, lhs_arena, - &other->_impl_.displayname_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.vcard_, lhs_arena, - &other->_impl_.vcard_, rhs_arena - ); - swap(_impl_.contextinfo_, other->_impl_.contextinfo_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_ContactMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[69]); -} - -// =================================================================== - -class Message_ContactsArrayMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_displayname(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::proto::ContextInfo& contextinfo(const Message_ContactsArrayMessage* msg); - static void set_has_contextinfo(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -const ::proto::ContextInfo& -Message_ContactsArrayMessage::_Internal::contextinfo(const Message_ContactsArrayMessage* msg) { - return *msg->_impl_.contextinfo_; -} -Message_ContactsArrayMessage::Message_ContactsArrayMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.ContactsArrayMessage) -} -Message_ContactsArrayMessage::Message_ContactsArrayMessage(const Message_ContactsArrayMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_ContactsArrayMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.contacts_){from._impl_.contacts_} - , decltype(_impl_.displayname_){} - , decltype(_impl_.contextinfo_){nullptr}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.displayname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.displayname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_displayname()) { - _this->_impl_.displayname_.Set(from._internal_displayname(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_contextinfo()) { - _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); - } - // @@protoc_insertion_point(copy_constructor:proto.Message.ContactsArrayMessage) -} - -inline void Message_ContactsArrayMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.contacts_){arena} - , decltype(_impl_.displayname_){} - , decltype(_impl_.contextinfo_){nullptr} - }; - _impl_.displayname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.displayname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_ContactsArrayMessage::~Message_ContactsArrayMessage() { - // @@protoc_insertion_point(destructor:proto.Message.ContactsArrayMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_ContactsArrayMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.contacts_.~RepeatedPtrField(); - _impl_.displayname_.Destroy(); - if (this != internal_default_instance()) delete _impl_.contextinfo_; -} - -void Message_ContactsArrayMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_ContactsArrayMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.ContactsArrayMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.contacts_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.displayname_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); - _impl_.contextinfo_->Clear(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_ContactsArrayMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string displayName = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_displayname(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ContactsArrayMessage.displayName"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // repeated .proto.Message.ContactMessage contacts = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_contacts(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else - goto handle_unusual; - continue; - // optional .proto.ContextInfo contextInfo = 17; - case 17: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { - ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_ContactsArrayMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ContactsArrayMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string displayName = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_displayname().data(), static_cast(this->_internal_displayname().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ContactsArrayMessage.displayName"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_displayname(), target); - } - - // repeated .proto.Message.ContactMessage contacts = 2; - for (unsigned i = 0, - n = static_cast(this->_internal_contacts_size()); i < n; i++) { - const auto& repfield = this->_internal_contacts(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream); - } - - // optional .proto.ContextInfo contextInfo = 17; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(17, _Internal::contextinfo(this), - _Internal::contextinfo(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ContactsArrayMessage) - return target; -} - -size_t Message_ContactsArrayMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.ContactsArrayMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.Message.ContactMessage contacts = 2; - total_size += 1UL * this->_internal_contacts_size(); - for (const auto& msg : this->_impl_.contacts_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional string displayName = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_displayname()); - } - - // optional .proto.ContextInfo contextInfo = 17; - if (cached_has_bits & 0x00000002u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.contextinfo_); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ContactsArrayMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_ContactsArrayMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ContactsArrayMessage::GetClassData() const { return &_class_data_; } - - -void Message_ContactsArrayMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ContactsArrayMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.contacts_.MergeFrom(from._impl_.contacts_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_displayname(from._internal_displayname()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( - from._internal_contextinfo()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_ContactsArrayMessage::CopyFrom(const Message_ContactsArrayMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ContactsArrayMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_ContactsArrayMessage::IsInitialized() const { - return true; -} - -void Message_ContactsArrayMessage::InternalSwap(Message_ContactsArrayMessage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.contacts_.InternalSwap(&other->_impl_.contacts_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.displayname_, lhs_arena, - &other->_impl_.displayname_, rhs_arena - ); - swap(_impl_.contextinfo_, other->_impl_.contextinfo_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_ContactsArrayMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[70]); -} - -// =================================================================== - -class Message_DeclinePaymentRequestMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::MessageKey& key(const Message_DeclinePaymentRequestMessage* msg); - static void set_has_key(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -const ::proto::MessageKey& -Message_DeclinePaymentRequestMessage::_Internal::key(const Message_DeclinePaymentRequestMessage* msg) { - return *msg->_impl_.key_; -} -Message_DeclinePaymentRequestMessage::Message_DeclinePaymentRequestMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.DeclinePaymentRequestMessage) -} -Message_DeclinePaymentRequestMessage::Message_DeclinePaymentRequestMessage(const Message_DeclinePaymentRequestMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_DeclinePaymentRequestMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.key_){nullptr}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_key()) { - _this->_impl_.key_ = new ::proto::MessageKey(*from._impl_.key_); - } - // @@protoc_insertion_point(copy_constructor:proto.Message.DeclinePaymentRequestMessage) -} - -inline void Message_DeclinePaymentRequestMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.key_){nullptr} - }; -} - -Message_DeclinePaymentRequestMessage::~Message_DeclinePaymentRequestMessage() { - // @@protoc_insertion_point(destructor:proto.Message.DeclinePaymentRequestMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_DeclinePaymentRequestMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete _impl_.key_; -} - -void Message_DeclinePaymentRequestMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_DeclinePaymentRequestMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.DeclinePaymentRequestMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.key_ != nullptr); - _impl_.key_->Clear(); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_DeclinePaymentRequestMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.MessageKey key = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_DeclinePaymentRequestMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.DeclinePaymentRequestMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.MessageKey key = 1; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::key(this), - _Internal::key(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.DeclinePaymentRequestMessage) - return target; -} - -size_t Message_DeclinePaymentRequestMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.DeclinePaymentRequestMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional .proto.MessageKey key = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.key_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_DeclinePaymentRequestMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_DeclinePaymentRequestMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_DeclinePaymentRequestMessage::GetClassData() const { return &_class_data_; } - - -void Message_DeclinePaymentRequestMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.DeclinePaymentRequestMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_key()) { - _this->_internal_mutable_key()->::proto::MessageKey::MergeFrom( - from._internal_key()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_DeclinePaymentRequestMessage::CopyFrom(const Message_DeclinePaymentRequestMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.DeclinePaymentRequestMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_DeclinePaymentRequestMessage::IsInitialized() const { - return true; -} - -void Message_DeclinePaymentRequestMessage::InternalSwap(Message_DeclinePaymentRequestMessage* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - swap(_impl_.key_, other->_impl_.key_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_DeclinePaymentRequestMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[71]); -} - -// =================================================================== - -class Message_DeviceSentMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_destinationjid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::proto::Message& message(const Message_DeviceSentMessage* msg); - static void set_has_message(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_phash(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -const ::proto::Message& -Message_DeviceSentMessage::_Internal::message(const Message_DeviceSentMessage* msg) { - return *msg->_impl_.message_; -} -Message_DeviceSentMessage::Message_DeviceSentMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.DeviceSentMessage) -} -Message_DeviceSentMessage::Message_DeviceSentMessage(const Message_DeviceSentMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_DeviceSentMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.destinationjid_){} - , decltype(_impl_.phash_){} - , decltype(_impl_.message_){nullptr}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.destinationjid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.destinationjid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_destinationjid()) { - _this->_impl_.destinationjid_.Set(from._internal_destinationjid(), - _this->GetArenaForAllocation()); - } - _impl_.phash_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.phash_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_phash()) { - _this->_impl_.phash_.Set(from._internal_phash(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_message()) { - _this->_impl_.message_ = new ::proto::Message(*from._impl_.message_); - } - // @@protoc_insertion_point(copy_constructor:proto.Message.DeviceSentMessage) -} - -inline void Message_DeviceSentMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.destinationjid_){} - , decltype(_impl_.phash_){} - , decltype(_impl_.message_){nullptr} - }; - _impl_.destinationjid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.destinationjid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.phash_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.phash_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_DeviceSentMessage::~Message_DeviceSentMessage() { - // @@protoc_insertion_point(destructor:proto.Message.DeviceSentMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_DeviceSentMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.destinationjid_.Destroy(); - _impl_.phash_.Destroy(); - if (this != internal_default_instance()) delete _impl_.message_; -} - -void Message_DeviceSentMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_DeviceSentMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.DeviceSentMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _impl_.destinationjid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.phash_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - GOOGLE_DCHECK(_impl_.message_ != nullptr); - _impl_.message_->Clear(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_DeviceSentMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string destinationJid = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_destinationjid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.DeviceSentMessage.destinationJid"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.Message message = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_message(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string phash = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_phash(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.DeviceSentMessage.phash"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_DeviceSentMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.DeviceSentMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string destinationJid = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_destinationjid().data(), static_cast(this->_internal_destinationjid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.DeviceSentMessage.destinationJid"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_destinationjid(), target); - } - - // optional .proto.Message message = 2; - if (cached_has_bits & 0x00000004u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::message(this), - _Internal::message(this).GetCachedSize(), target, stream); - } - - // optional string phash = 3; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_phash().data(), static_cast(this->_internal_phash().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.DeviceSentMessage.phash"); - target = stream->WriteStringMaybeAliased( - 3, this->_internal_phash(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.DeviceSentMessage) - return target; -} - -size_t Message_DeviceSentMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.DeviceSentMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional string destinationJid = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_destinationjid()); - } - - // optional string phash = 3; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_phash()); - } - - // optional .proto.Message message = 2; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.message_); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_DeviceSentMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_DeviceSentMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_DeviceSentMessage::GetClassData() const { return &_class_data_; } - - -void Message_DeviceSentMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.DeviceSentMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_destinationjid(from._internal_destinationjid()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_phash(from._internal_phash()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_mutable_message()->::proto::Message::MergeFrom( - from._internal_message()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_DeviceSentMessage::CopyFrom(const Message_DeviceSentMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.DeviceSentMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_DeviceSentMessage::IsInitialized() const { - return true; -} - -void Message_DeviceSentMessage::InternalSwap(Message_DeviceSentMessage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.destinationjid_, lhs_arena, - &other->_impl_.destinationjid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.phash_, lhs_arena, - &other->_impl_.phash_, rhs_arena - ); - swap(_impl_.message_, other->_impl_.message_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_DeviceSentMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[72]); -} - -// =================================================================== - -class Message_DocumentMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_url(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_mimetype(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_title(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_filesha256(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_filelength(HasBits* has_bits) { - (*has_bits)[0] |= 16384u; - } - static void set_has_pagecount(HasBits* has_bits) { - (*has_bits)[0] |= 32768u; - } - static void set_has_mediakey(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_filename(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static void set_has_fileencsha256(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static void set_has_directpath(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } - static void set_has_mediakeytimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 131072u; - } - static void set_has_contactvcard(HasBits* has_bits) { - (*has_bits)[0] |= 65536u; - } - static void set_has_thumbnaildirectpath(HasBits* has_bits) { - (*has_bits)[0] |= 256u; - } - static void set_has_thumbnailsha256(HasBits* has_bits) { - (*has_bits)[0] |= 512u; - } - static void set_has_thumbnailencsha256(HasBits* has_bits) { - (*has_bits)[0] |= 1024u; - } - static void set_has_jpegthumbnail(HasBits* has_bits) { - (*has_bits)[0] |= 2048u; - } - static const ::proto::ContextInfo& contextinfo(const Message_DocumentMessage* msg); - static void set_has_contextinfo(HasBits* has_bits) { - (*has_bits)[0] |= 8192u; - } - static void set_has_thumbnailheight(HasBits* has_bits) { - (*has_bits)[0] |= 262144u; - } - static void set_has_thumbnailwidth(HasBits* has_bits) { - (*has_bits)[0] |= 524288u; - } - static void set_has_caption(HasBits* has_bits) { - (*has_bits)[0] |= 4096u; - } -}; - -const ::proto::ContextInfo& -Message_DocumentMessage::_Internal::contextinfo(const Message_DocumentMessage* msg) { - return *msg->_impl_.contextinfo_; -} -Message_DocumentMessage::Message_DocumentMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.DocumentMessage) -} -Message_DocumentMessage::Message_DocumentMessage(const Message_DocumentMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_DocumentMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.url_){} - , decltype(_impl_.mimetype_){} - , decltype(_impl_.title_){} - , decltype(_impl_.filesha256_){} - , decltype(_impl_.mediakey_){} - , decltype(_impl_.filename_){} - , decltype(_impl_.fileencsha256_){} - , decltype(_impl_.directpath_){} - , decltype(_impl_.thumbnaildirectpath_){} - , decltype(_impl_.thumbnailsha256_){} - , decltype(_impl_.thumbnailencsha256_){} - , decltype(_impl_.jpegthumbnail_){} - , decltype(_impl_.caption_){} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.filelength_){} - , decltype(_impl_.pagecount_){} - , decltype(_impl_.contactvcard_){} - , decltype(_impl_.mediakeytimestamp_){} - , decltype(_impl_.thumbnailheight_){} - , decltype(_impl_.thumbnailwidth_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.url_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.url_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_url()) { - _this->_impl_.url_.Set(from._internal_url(), - _this->GetArenaForAllocation()); - } - _impl_.mimetype_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mimetype_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_mimetype()) { - _this->_impl_.mimetype_.Set(from._internal_mimetype(), - _this->GetArenaForAllocation()); - } - _impl_.title_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.title_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_title()) { - _this->_impl_.title_.Set(from._internal_title(), - _this->GetArenaForAllocation()); - } - _impl_.filesha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filesha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_filesha256()) { - _this->_impl_.filesha256_.Set(from._internal_filesha256(), - _this->GetArenaForAllocation()); - } - _impl_.mediakey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediakey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_mediakey()) { - _this->_impl_.mediakey_.Set(from._internal_mediakey(), - _this->GetArenaForAllocation()); - } - _impl_.filename_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filename_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_filename()) { - _this->_impl_.filename_.Set(from._internal_filename(), - _this->GetArenaForAllocation()); - } - _impl_.fileencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_fileencsha256()) { - _this->_impl_.fileencsha256_.Set(from._internal_fileencsha256(), - _this->GetArenaForAllocation()); - } - _impl_.directpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_directpath()) { - _this->_impl_.directpath_.Set(from._internal_directpath(), - _this->GetArenaForAllocation()); - } - _impl_.thumbnaildirectpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_thumbnaildirectpath()) { - _this->_impl_.thumbnaildirectpath_.Set(from._internal_thumbnaildirectpath(), - _this->GetArenaForAllocation()); - } - _impl_.thumbnailsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_thumbnailsha256()) { - _this->_impl_.thumbnailsha256_.Set(from._internal_thumbnailsha256(), - _this->GetArenaForAllocation()); - } - _impl_.thumbnailencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_thumbnailencsha256()) { - _this->_impl_.thumbnailencsha256_.Set(from._internal_thumbnailencsha256(), - _this->GetArenaForAllocation()); - } - _impl_.jpegthumbnail_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_jpegthumbnail()) { - _this->_impl_.jpegthumbnail_.Set(from._internal_jpegthumbnail(), - _this->GetArenaForAllocation()); - } - _impl_.caption_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.caption_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_caption()) { - _this->_impl_.caption_.Set(from._internal_caption(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_contextinfo()) { - _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); - } - ::memcpy(&_impl_.filelength_, &from._impl_.filelength_, - static_cast(reinterpret_cast(&_impl_.thumbnailwidth_) - - reinterpret_cast(&_impl_.filelength_)) + sizeof(_impl_.thumbnailwidth_)); - // @@protoc_insertion_point(copy_constructor:proto.Message.DocumentMessage) -} - -inline void Message_DocumentMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.url_){} - , decltype(_impl_.mimetype_){} - , decltype(_impl_.title_){} - , decltype(_impl_.filesha256_){} - , decltype(_impl_.mediakey_){} - , decltype(_impl_.filename_){} - , decltype(_impl_.fileencsha256_){} - , decltype(_impl_.directpath_){} - , decltype(_impl_.thumbnaildirectpath_){} - , decltype(_impl_.thumbnailsha256_){} - , decltype(_impl_.thumbnailencsha256_){} - , decltype(_impl_.jpegthumbnail_){} - , decltype(_impl_.caption_){} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.filelength_){uint64_t{0u}} - , decltype(_impl_.pagecount_){0u} - , decltype(_impl_.contactvcard_){false} - , decltype(_impl_.mediakeytimestamp_){int64_t{0}} - , decltype(_impl_.thumbnailheight_){0u} - , decltype(_impl_.thumbnailwidth_){0u} - }; - _impl_.url_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.url_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mimetype_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mimetype_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.title_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.title_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filesha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filesha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediakey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediakey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filename_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filename_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fileencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnaildirectpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnailsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnailencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.jpegthumbnail_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.caption_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.caption_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_DocumentMessage::~Message_DocumentMessage() { - // @@protoc_insertion_point(destructor:proto.Message.DocumentMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_DocumentMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.url_.Destroy(); - _impl_.mimetype_.Destroy(); - _impl_.title_.Destroy(); - _impl_.filesha256_.Destroy(); - _impl_.mediakey_.Destroy(); - _impl_.filename_.Destroy(); - _impl_.fileencsha256_.Destroy(); - _impl_.directpath_.Destroy(); - _impl_.thumbnaildirectpath_.Destroy(); - _impl_.thumbnailsha256_.Destroy(); - _impl_.thumbnailencsha256_.Destroy(); - _impl_.jpegthumbnail_.Destroy(); - _impl_.caption_.Destroy(); - if (this != internal_default_instance()) delete _impl_.contextinfo_; -} - -void Message_DocumentMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_DocumentMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.DocumentMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _impl_.url_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.mimetype_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.title_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000008u) { - _impl_.filesha256_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000010u) { - _impl_.mediakey_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000020u) { - _impl_.filename_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000040u) { - _impl_.fileencsha256_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000080u) { - _impl_.directpath_.ClearNonDefaultToEmpty(); - } - } - if (cached_has_bits & 0x00003f00u) { - if (cached_has_bits & 0x00000100u) { - _impl_.thumbnaildirectpath_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000200u) { - _impl_.thumbnailsha256_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000400u) { - _impl_.thumbnailencsha256_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000800u) { - _impl_.jpegthumbnail_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00001000u) { - _impl_.caption_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00002000u) { - GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); - _impl_.contextinfo_->Clear(); - } - } - if (cached_has_bits & 0x0000c000u) { - ::memset(&_impl_.filelength_, 0, static_cast( - reinterpret_cast(&_impl_.pagecount_) - - reinterpret_cast(&_impl_.filelength_)) + sizeof(_impl_.pagecount_)); - } - if (cached_has_bits & 0x000f0000u) { - ::memset(&_impl_.contactvcard_, 0, static_cast( - reinterpret_cast(&_impl_.thumbnailwidth_) - - reinterpret_cast(&_impl_.contactvcard_)) + sizeof(_impl_.thumbnailwidth_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_DocumentMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string url = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_url(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.DocumentMessage.url"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string mimetype = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_mimetype(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.DocumentMessage.mimetype"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string title = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_title(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.DocumentMessage.title"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bytes fileSha256 = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - auto str = _internal_mutable_filesha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint64 fileLength = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { - _Internal::set_has_filelength(&has_bits); - _impl_.filelength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 pageCount = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { - _Internal::set_has_pagecount(&has_bits); - _impl_.pagecount_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes mediaKey = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - auto str = _internal_mutable_mediakey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string fileName = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { - auto str = _internal_mutable_filename(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.DocumentMessage.fileName"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bytes fileEncSha256 = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { - auto str = _internal_mutable_fileencsha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string directPath = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { - auto str = _internal_mutable_directpath(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.DocumentMessage.directPath"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional int64 mediaKeyTimestamp = 11; - case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { - _Internal::set_has_mediakeytimestamp(&has_bits); - _impl_.mediakeytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool contactVcard = 12; - case 12: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { - _Internal::set_has_contactvcard(&has_bits); - _impl_.contactvcard_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string thumbnailDirectPath = 13; - case 13: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { - auto str = _internal_mutable_thumbnaildirectpath(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.DocumentMessage.thumbnailDirectPath"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bytes thumbnailSha256 = 14; - case 14: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) { - auto str = _internal_mutable_thumbnailsha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes thumbnailEncSha256 = 15; - case 15: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { - auto str = _internal_mutable_thumbnailencsha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes jpegThumbnail = 16; - case 16: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { - auto str = _internal_mutable_jpegthumbnail(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.ContextInfo contextInfo = 17; - case 17: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { - ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 thumbnailHeight = 18; - case 18: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 144)) { - _Internal::set_has_thumbnailheight(&has_bits); - _impl_.thumbnailheight_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 thumbnailWidth = 19; - case 19: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 152)) { - _Internal::set_has_thumbnailwidth(&has_bits); - _impl_.thumbnailwidth_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string caption = 20; - case 20: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 162)) { - auto str = _internal_mutable_caption(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.DocumentMessage.caption"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_DocumentMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.DocumentMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string url = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_url().data(), static_cast(this->_internal_url().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.DocumentMessage.url"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_url(), target); - } - - // optional string mimetype = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_mimetype().data(), static_cast(this->_internal_mimetype().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.DocumentMessage.mimetype"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_mimetype(), target); - } - - // optional string title = 3; - if (cached_has_bits & 0x00000004u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_title().data(), static_cast(this->_internal_title().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.DocumentMessage.title"); - target = stream->WriteStringMaybeAliased( - 3, this->_internal_title(), target); - } - - // optional bytes fileSha256 = 4; - if (cached_has_bits & 0x00000008u) { - target = stream->WriteBytesMaybeAliased( - 4, this->_internal_filesha256(), target); - } - - // optional uint64 fileLength = 5; - if (cached_has_bits & 0x00004000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_filelength(), target); - } - - // optional uint32 pageCount = 6; - if (cached_has_bits & 0x00008000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_pagecount(), target); - } - - // optional bytes mediaKey = 7; - if (cached_has_bits & 0x00000010u) { - target = stream->WriteBytesMaybeAliased( - 7, this->_internal_mediakey(), target); - } - - // optional string fileName = 8; - if (cached_has_bits & 0x00000020u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_filename().data(), static_cast(this->_internal_filename().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.DocumentMessage.fileName"); - target = stream->WriteStringMaybeAliased( - 8, this->_internal_filename(), target); - } - - // optional bytes fileEncSha256 = 9; - if (cached_has_bits & 0x00000040u) { - target = stream->WriteBytesMaybeAliased( - 9, this->_internal_fileencsha256(), target); - } - - // optional string directPath = 10; - if (cached_has_bits & 0x00000080u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_directpath().data(), static_cast(this->_internal_directpath().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.DocumentMessage.directPath"); - target = stream->WriteStringMaybeAliased( - 10, this->_internal_directpath(), target); - } - - // optional int64 mediaKeyTimestamp = 11; - if (cached_has_bits & 0x00020000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(11, this->_internal_mediakeytimestamp(), target); - } - - // optional bool contactVcard = 12; - if (cached_has_bits & 0x00010000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(12, this->_internal_contactvcard(), target); - } - - // optional string thumbnailDirectPath = 13; - if (cached_has_bits & 0x00000100u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_thumbnaildirectpath().data(), static_cast(this->_internal_thumbnaildirectpath().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.DocumentMessage.thumbnailDirectPath"); - target = stream->WriteStringMaybeAliased( - 13, this->_internal_thumbnaildirectpath(), target); - } - - // optional bytes thumbnailSha256 = 14; - if (cached_has_bits & 0x00000200u) { - target = stream->WriteBytesMaybeAliased( - 14, this->_internal_thumbnailsha256(), target); - } - - // optional bytes thumbnailEncSha256 = 15; - if (cached_has_bits & 0x00000400u) { - target = stream->WriteBytesMaybeAliased( - 15, this->_internal_thumbnailencsha256(), target); - } - - // optional bytes jpegThumbnail = 16; - if (cached_has_bits & 0x00000800u) { - target = stream->WriteBytesMaybeAliased( - 16, this->_internal_jpegthumbnail(), target); - } - - // optional .proto.ContextInfo contextInfo = 17; - if (cached_has_bits & 0x00002000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(17, _Internal::contextinfo(this), - _Internal::contextinfo(this).GetCachedSize(), target, stream); - } - - // optional uint32 thumbnailHeight = 18; - if (cached_has_bits & 0x00040000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(18, this->_internal_thumbnailheight(), target); - } - - // optional uint32 thumbnailWidth = 19; - if (cached_has_bits & 0x00080000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(19, this->_internal_thumbnailwidth(), target); - } - - // optional string caption = 20; - if (cached_has_bits & 0x00001000u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_caption().data(), static_cast(this->_internal_caption().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.DocumentMessage.caption"); - target = stream->WriteStringMaybeAliased( - 20, this->_internal_caption(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.DocumentMessage) - return target; -} - -size_t Message_DocumentMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.DocumentMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional string url = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_url()); - } - - // optional string mimetype = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_mimetype()); - } - - // optional string title = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_title()); - } - - // optional bytes fileSha256 = 4; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_filesha256()); - } - - // optional bytes mediaKey = 7; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_mediakey()); - } - - // optional string fileName = 8; - if (cached_has_bits & 0x00000020u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_filename()); - } - - // optional bytes fileEncSha256 = 9; - if (cached_has_bits & 0x00000040u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_fileencsha256()); - } - - // optional string directPath = 10; - if (cached_has_bits & 0x00000080u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_directpath()); - } - - } - if (cached_has_bits & 0x0000ff00u) { - // optional string thumbnailDirectPath = 13; - if (cached_has_bits & 0x00000100u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_thumbnaildirectpath()); - } - - // optional bytes thumbnailSha256 = 14; - if (cached_has_bits & 0x00000200u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_thumbnailsha256()); - } - - // optional bytes thumbnailEncSha256 = 15; - if (cached_has_bits & 0x00000400u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_thumbnailencsha256()); - } - - // optional bytes jpegThumbnail = 16; - if (cached_has_bits & 0x00000800u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_jpegthumbnail()); - } - - // optional string caption = 20; - if (cached_has_bits & 0x00001000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_caption()); - } - - // optional .proto.ContextInfo contextInfo = 17; - if (cached_has_bits & 0x00002000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.contextinfo_); - } - - // optional uint64 fileLength = 5; - if (cached_has_bits & 0x00004000u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_filelength()); - } - - // optional uint32 pageCount = 6; - if (cached_has_bits & 0x00008000u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_pagecount()); - } - - } - if (cached_has_bits & 0x000f0000u) { - // optional bool contactVcard = 12; - if (cached_has_bits & 0x00010000u) { - total_size += 1 + 1; - } - - // optional int64 mediaKeyTimestamp = 11; - if (cached_has_bits & 0x00020000u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_mediakeytimestamp()); - } - - // optional uint32 thumbnailHeight = 18; - if (cached_has_bits & 0x00040000u) { - total_size += 2 + - ::_pbi::WireFormatLite::UInt32Size( - this->_internal_thumbnailheight()); - } - - // optional uint32 thumbnailWidth = 19; - if (cached_has_bits & 0x00080000u) { - total_size += 2 + - ::_pbi::WireFormatLite::UInt32Size( - this->_internal_thumbnailwidth()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_DocumentMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_DocumentMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_DocumentMessage::GetClassData() const { return &_class_data_; } - - -void Message_DocumentMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.DocumentMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_url(from._internal_url()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_mimetype(from._internal_mimetype()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_title(from._internal_title()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_set_filesha256(from._internal_filesha256()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_set_mediakey(from._internal_mediakey()); - } - if (cached_has_bits & 0x00000020u) { - _this->_internal_set_filename(from._internal_filename()); - } - if (cached_has_bits & 0x00000040u) { - _this->_internal_set_fileencsha256(from._internal_fileencsha256()); - } - if (cached_has_bits & 0x00000080u) { - _this->_internal_set_directpath(from._internal_directpath()); - } - } - if (cached_has_bits & 0x0000ff00u) { - if (cached_has_bits & 0x00000100u) { - _this->_internal_set_thumbnaildirectpath(from._internal_thumbnaildirectpath()); - } - if (cached_has_bits & 0x00000200u) { - _this->_internal_set_thumbnailsha256(from._internal_thumbnailsha256()); - } - if (cached_has_bits & 0x00000400u) { - _this->_internal_set_thumbnailencsha256(from._internal_thumbnailencsha256()); - } - if (cached_has_bits & 0x00000800u) { - _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail()); - } - if (cached_has_bits & 0x00001000u) { - _this->_internal_set_caption(from._internal_caption()); - } - if (cached_has_bits & 0x00002000u) { - _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( - from._internal_contextinfo()); - } - if (cached_has_bits & 0x00004000u) { - _this->_impl_.filelength_ = from._impl_.filelength_; - } - if (cached_has_bits & 0x00008000u) { - _this->_impl_.pagecount_ = from._impl_.pagecount_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - if (cached_has_bits & 0x000f0000u) { - if (cached_has_bits & 0x00010000u) { - _this->_impl_.contactvcard_ = from._impl_.contactvcard_; - } - if (cached_has_bits & 0x00020000u) { - _this->_impl_.mediakeytimestamp_ = from._impl_.mediakeytimestamp_; - } - if (cached_has_bits & 0x00040000u) { - _this->_impl_.thumbnailheight_ = from._impl_.thumbnailheight_; - } - if (cached_has_bits & 0x00080000u) { - _this->_impl_.thumbnailwidth_ = from._impl_.thumbnailwidth_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_DocumentMessage::CopyFrom(const Message_DocumentMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.DocumentMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_DocumentMessage::IsInitialized() const { - return true; -} - -void Message_DocumentMessage::InternalSwap(Message_DocumentMessage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.url_, lhs_arena, - &other->_impl_.url_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.mimetype_, lhs_arena, - &other->_impl_.mimetype_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.title_, lhs_arena, - &other->_impl_.title_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.filesha256_, lhs_arena, - &other->_impl_.filesha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.mediakey_, lhs_arena, - &other->_impl_.mediakey_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.filename_, lhs_arena, - &other->_impl_.filename_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.fileencsha256_, lhs_arena, - &other->_impl_.fileencsha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.directpath_, lhs_arena, - &other->_impl_.directpath_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.thumbnaildirectpath_, lhs_arena, - &other->_impl_.thumbnaildirectpath_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.thumbnailsha256_, lhs_arena, - &other->_impl_.thumbnailsha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.thumbnailencsha256_, lhs_arena, - &other->_impl_.thumbnailencsha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.jpegthumbnail_, lhs_arena, - &other->_impl_.jpegthumbnail_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.caption_, lhs_arena, - &other->_impl_.caption_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_DocumentMessage, _impl_.thumbnailwidth_) - + sizeof(Message_DocumentMessage::_impl_.thumbnailwidth_) - - PROTOBUF_FIELD_OFFSET(Message_DocumentMessage, _impl_.contextinfo_)>( - reinterpret_cast(&_impl_.contextinfo_), - reinterpret_cast(&other->_impl_.contextinfo_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_DocumentMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[73]); -} - -// =================================================================== - -class Message_ExtendedTextMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_text(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_matchedtext(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_canonicalurl(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_description(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_title(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_textargb(HasBits* has_bits) { - (*has_bits)[0] |= 8192u; - } - static void set_has_backgroundargb(HasBits* has_bits) { - (*has_bits)[0] |= 16384u; - } - static void set_has_font(HasBits* has_bits) { - (*has_bits)[0] |= 32768u; - } - static void set_has_previewtype(HasBits* has_bits) { - (*has_bits)[0] |= 65536u; - } - static void set_has_jpegthumbnail(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static const ::proto::ContextInfo& contextinfo(const Message_ExtendedTextMessage* msg); - static void set_has_contextinfo(HasBits* has_bits) { - (*has_bits)[0] |= 4096u; - } - static void set_has_donotplayinline(HasBits* has_bits) { - (*has_bits)[0] |= 131072u; - } - static void set_has_thumbnaildirectpath(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static void set_has_thumbnailsha256(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } - static void set_has_thumbnailencsha256(HasBits* has_bits) { - (*has_bits)[0] |= 256u; - } - static void set_has_mediakey(HasBits* has_bits) { - (*has_bits)[0] |= 512u; - } - static void set_has_mediakeytimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 524288u; - } - static void set_has_thumbnailheight(HasBits* has_bits) { - (*has_bits)[0] |= 262144u; - } - static void set_has_thumbnailwidth(HasBits* has_bits) { - (*has_bits)[0] |= 1048576u; - } - static void set_has_invitelinkgrouptype(HasBits* has_bits) { - (*has_bits)[0] |= 2097152u; - } - static void set_has_invitelinkparentgroupsubjectv2(HasBits* has_bits) { - (*has_bits)[0] |= 1024u; - } - static void set_has_invitelinkparentgroupthumbnailv2(HasBits* has_bits) { - (*has_bits)[0] |= 2048u; - } - static void set_has_invitelinkgrouptypev2(HasBits* has_bits) { - (*has_bits)[0] |= 4194304u; - } -}; - -const ::proto::ContextInfo& -Message_ExtendedTextMessage::_Internal::contextinfo(const Message_ExtendedTextMessage* msg) { - return *msg->_impl_.contextinfo_; -} -Message_ExtendedTextMessage::Message_ExtendedTextMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.ExtendedTextMessage) -} -Message_ExtendedTextMessage::Message_ExtendedTextMessage(const Message_ExtendedTextMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_ExtendedTextMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.text_){} - , decltype(_impl_.matchedtext_){} - , decltype(_impl_.canonicalurl_){} - , decltype(_impl_.description_){} - , decltype(_impl_.title_){} - , decltype(_impl_.jpegthumbnail_){} - , decltype(_impl_.thumbnaildirectpath_){} - , decltype(_impl_.thumbnailsha256_){} - , decltype(_impl_.thumbnailencsha256_){} - , decltype(_impl_.mediakey_){} - , decltype(_impl_.invitelinkparentgroupsubjectv2_){} - , decltype(_impl_.invitelinkparentgroupthumbnailv2_){} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.textargb_){} - , decltype(_impl_.backgroundargb_){} - , decltype(_impl_.font_){} - , decltype(_impl_.previewtype_){} - , decltype(_impl_.donotplayinline_){} - , decltype(_impl_.thumbnailheight_){} - , decltype(_impl_.mediakeytimestamp_){} - , decltype(_impl_.thumbnailwidth_){} - , decltype(_impl_.invitelinkgrouptype_){} - , decltype(_impl_.invitelinkgrouptypev2_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.text_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.text_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_text()) { - _this->_impl_.text_.Set(from._internal_text(), - _this->GetArenaForAllocation()); - } - _impl_.matchedtext_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.matchedtext_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_matchedtext()) { - _this->_impl_.matchedtext_.Set(from._internal_matchedtext(), - _this->GetArenaForAllocation()); - } - _impl_.canonicalurl_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.canonicalurl_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_canonicalurl()) { - _this->_impl_.canonicalurl_.Set(from._internal_canonicalurl(), - _this->GetArenaForAllocation()); - } - _impl_.description_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.description_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_description()) { - _this->_impl_.description_.Set(from._internal_description(), - _this->GetArenaForAllocation()); - } - _impl_.title_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.title_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_title()) { - _this->_impl_.title_.Set(from._internal_title(), - _this->GetArenaForAllocation()); - } - _impl_.jpegthumbnail_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_jpegthumbnail()) { - _this->_impl_.jpegthumbnail_.Set(from._internal_jpegthumbnail(), - _this->GetArenaForAllocation()); - } - _impl_.thumbnaildirectpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_thumbnaildirectpath()) { - _this->_impl_.thumbnaildirectpath_.Set(from._internal_thumbnaildirectpath(), - _this->GetArenaForAllocation()); - } - _impl_.thumbnailsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_thumbnailsha256()) { - _this->_impl_.thumbnailsha256_.Set(from._internal_thumbnailsha256(), - _this->GetArenaForAllocation()); - } - _impl_.thumbnailencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_thumbnailencsha256()) { - _this->_impl_.thumbnailencsha256_.Set(from._internal_thumbnailencsha256(), - _this->GetArenaForAllocation()); - } - _impl_.mediakey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediakey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_mediakey()) { - _this->_impl_.mediakey_.Set(from._internal_mediakey(), - _this->GetArenaForAllocation()); - } - _impl_.invitelinkparentgroupsubjectv2_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.invitelinkparentgroupsubjectv2_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_invitelinkparentgroupsubjectv2()) { - _this->_impl_.invitelinkparentgroupsubjectv2_.Set(from._internal_invitelinkparentgroupsubjectv2(), - _this->GetArenaForAllocation()); - } - _impl_.invitelinkparentgroupthumbnailv2_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.invitelinkparentgroupthumbnailv2_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_invitelinkparentgroupthumbnailv2()) { - _this->_impl_.invitelinkparentgroupthumbnailv2_.Set(from._internal_invitelinkparentgroupthumbnailv2(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_contextinfo()) { - _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); - } - ::memcpy(&_impl_.textargb_, &from._impl_.textargb_, - static_cast(reinterpret_cast(&_impl_.invitelinkgrouptypev2_) - - reinterpret_cast(&_impl_.textargb_)) + sizeof(_impl_.invitelinkgrouptypev2_)); - // @@protoc_insertion_point(copy_constructor:proto.Message.ExtendedTextMessage) -} - -inline void Message_ExtendedTextMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.text_){} - , decltype(_impl_.matchedtext_){} - , decltype(_impl_.canonicalurl_){} - , decltype(_impl_.description_){} - , decltype(_impl_.title_){} - , decltype(_impl_.jpegthumbnail_){} - , decltype(_impl_.thumbnaildirectpath_){} - , decltype(_impl_.thumbnailsha256_){} - , decltype(_impl_.thumbnailencsha256_){} - , decltype(_impl_.mediakey_){} - , decltype(_impl_.invitelinkparentgroupsubjectv2_){} - , decltype(_impl_.invitelinkparentgroupthumbnailv2_){} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.textargb_){0u} - , decltype(_impl_.backgroundargb_){0u} - , decltype(_impl_.font_){0} - , decltype(_impl_.previewtype_){0} - , decltype(_impl_.donotplayinline_){false} - , decltype(_impl_.thumbnailheight_){0u} - , decltype(_impl_.mediakeytimestamp_){int64_t{0}} - , decltype(_impl_.thumbnailwidth_){0u} - , decltype(_impl_.invitelinkgrouptype_){0} - , decltype(_impl_.invitelinkgrouptypev2_){0} - }; - _impl_.text_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.text_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.matchedtext_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.matchedtext_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.canonicalurl_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.canonicalurl_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.description_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.description_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.title_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.title_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.jpegthumbnail_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnaildirectpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnailsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnailencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediakey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediakey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.invitelinkparentgroupsubjectv2_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.invitelinkparentgroupsubjectv2_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.invitelinkparentgroupthumbnailv2_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.invitelinkparentgroupthumbnailv2_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_ExtendedTextMessage::~Message_ExtendedTextMessage() { - // @@protoc_insertion_point(destructor:proto.Message.ExtendedTextMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_ExtendedTextMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.text_.Destroy(); - _impl_.matchedtext_.Destroy(); - _impl_.canonicalurl_.Destroy(); - _impl_.description_.Destroy(); - _impl_.title_.Destroy(); - _impl_.jpegthumbnail_.Destroy(); - _impl_.thumbnaildirectpath_.Destroy(); - _impl_.thumbnailsha256_.Destroy(); - _impl_.thumbnailencsha256_.Destroy(); - _impl_.mediakey_.Destroy(); - _impl_.invitelinkparentgroupsubjectv2_.Destroy(); - _impl_.invitelinkparentgroupthumbnailv2_.Destroy(); - if (this != internal_default_instance()) delete _impl_.contextinfo_; -} - -void Message_ExtendedTextMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_ExtendedTextMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.ExtendedTextMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _impl_.text_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.matchedtext_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.canonicalurl_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000008u) { - _impl_.description_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000010u) { - _impl_.title_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000020u) { - _impl_.jpegthumbnail_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000040u) { - _impl_.thumbnaildirectpath_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000080u) { - _impl_.thumbnailsha256_.ClearNonDefaultToEmpty(); - } - } - if (cached_has_bits & 0x00001f00u) { - if (cached_has_bits & 0x00000100u) { - _impl_.thumbnailencsha256_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000200u) { - _impl_.mediakey_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000400u) { - _impl_.invitelinkparentgroupsubjectv2_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000800u) { - _impl_.invitelinkparentgroupthumbnailv2_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00001000u) { - GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); - _impl_.contextinfo_->Clear(); - } - } - if (cached_has_bits & 0x0000e000u) { - ::memset(&_impl_.textargb_, 0, static_cast( - reinterpret_cast(&_impl_.font_) - - reinterpret_cast(&_impl_.textargb_)) + sizeof(_impl_.font_)); - } - if (cached_has_bits & 0x007f0000u) { - ::memset(&_impl_.previewtype_, 0, static_cast( - reinterpret_cast(&_impl_.invitelinkgrouptypev2_) - - reinterpret_cast(&_impl_.previewtype_)) + sizeof(_impl_.invitelinkgrouptypev2_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_ExtendedTextMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string text = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_text(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ExtendedTextMessage.text"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string matchedText = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_matchedtext(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ExtendedTextMessage.matchedText"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string canonicalUrl = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - auto str = _internal_mutable_canonicalurl(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ExtendedTextMessage.canonicalUrl"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string description = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - auto str = _internal_mutable_description(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ExtendedTextMessage.description"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string title = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - auto str = _internal_mutable_title(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ExtendedTextMessage.title"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional fixed32 textArgb = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 61)) { - _Internal::set_has_textargb(&has_bits); - _impl_.textargb_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); - ptr += sizeof(uint32_t); - } else - goto handle_unusual; - continue; - // optional fixed32 backgroundArgb = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 69)) { - _Internal::set_has_backgroundargb(&has_bits); - _impl_.backgroundargb_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); - ptr += sizeof(uint32_t); - } else - goto handle_unusual; - continue; - // optional .proto.Message.ExtendedTextMessage.FontType font = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::Message_ExtendedTextMessage_FontType_IsValid(val))) { - _internal_set_font(static_cast<::proto::Message_ExtendedTextMessage_FontType>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(9, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.Message.ExtendedTextMessage.PreviewType previewType = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::Message_ExtendedTextMessage_PreviewType_IsValid(val))) { - _internal_set_previewtype(static_cast<::proto::Message_ExtendedTextMessage_PreviewType>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(10, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional bytes jpegThumbnail = 16; - case 16: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { - auto str = _internal_mutable_jpegthumbnail(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.ContextInfo contextInfo = 17; - case 17: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { - ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool doNotPlayInline = 18; - case 18: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 144)) { - _Internal::set_has_donotplayinline(&has_bits); - _impl_.donotplayinline_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string thumbnailDirectPath = 19; - case 19: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) { - auto str = _internal_mutable_thumbnaildirectpath(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ExtendedTextMessage.thumbnailDirectPath"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bytes thumbnailSha256 = 20; - case 20: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 162)) { - auto str = _internal_mutable_thumbnailsha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes thumbnailEncSha256 = 21; - case 21: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { - auto str = _internal_mutable_thumbnailencsha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes mediaKey = 22; - case 22: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 178)) { - auto str = _internal_mutable_mediakey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional int64 mediaKeyTimestamp = 23; - case 23: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 184)) { - _Internal::set_has_mediakeytimestamp(&has_bits); - _impl_.mediakeytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 thumbnailHeight = 24; - case 24: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 192)) { - _Internal::set_has_thumbnailheight(&has_bits); - _impl_.thumbnailheight_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 thumbnailWidth = 25; - case 25: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 200)) { - _Internal::set_has_thumbnailwidth(&has_bits); - _impl_.thumbnailwidth_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupType = 26; - case 26: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 208)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::Message_ExtendedTextMessage_InviteLinkGroupType_IsValid(val))) { - _internal_set_invitelinkgrouptype(static_cast<::proto::Message_ExtendedTextMessage_InviteLinkGroupType>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(26, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional string inviteLinkParentGroupSubjectV2 = 27; - case 27: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 218)) { - auto str = _internal_mutable_invitelinkparentgroupsubjectv2(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ExtendedTextMessage.inviteLinkParentGroupSubjectV2"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bytes inviteLinkParentGroupThumbnailV2 = 28; - case 28: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 226)) { - auto str = _internal_mutable_invitelinkparentgroupthumbnailv2(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupTypeV2 = 29; - case 29: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 232)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::Message_ExtendedTextMessage_InviteLinkGroupType_IsValid(val))) { - _internal_set_invitelinkgrouptypev2(static_cast<::proto::Message_ExtendedTextMessage_InviteLinkGroupType>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(29, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_ExtendedTextMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ExtendedTextMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string text = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_text().data(), static_cast(this->_internal_text().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ExtendedTextMessage.text"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_text(), target); - } - - // optional string matchedText = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_matchedtext().data(), static_cast(this->_internal_matchedtext().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ExtendedTextMessage.matchedText"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_matchedtext(), target); - } - - // optional string canonicalUrl = 4; - if (cached_has_bits & 0x00000004u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_canonicalurl().data(), static_cast(this->_internal_canonicalurl().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ExtendedTextMessage.canonicalUrl"); - target = stream->WriteStringMaybeAliased( - 4, this->_internal_canonicalurl(), target); - } - - // optional string description = 5; - if (cached_has_bits & 0x00000008u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_description().data(), static_cast(this->_internal_description().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ExtendedTextMessage.description"); - target = stream->WriteStringMaybeAliased( - 5, this->_internal_description(), target); - } - - // optional string title = 6; - if (cached_has_bits & 0x00000010u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_title().data(), static_cast(this->_internal_title().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ExtendedTextMessage.title"); - target = stream->WriteStringMaybeAliased( - 6, this->_internal_title(), target); - } - - // optional fixed32 textArgb = 7; - if (cached_has_bits & 0x00002000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteFixed32ToArray(7, this->_internal_textargb(), target); - } - - // optional fixed32 backgroundArgb = 8; - if (cached_has_bits & 0x00004000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteFixed32ToArray(8, this->_internal_backgroundargb(), target); - } - - // optional .proto.Message.ExtendedTextMessage.FontType font = 9; - if (cached_has_bits & 0x00008000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 9, this->_internal_font(), target); - } - - // optional .proto.Message.ExtendedTextMessage.PreviewType previewType = 10; - if (cached_has_bits & 0x00010000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 10, this->_internal_previewtype(), target); - } - - // optional bytes jpegThumbnail = 16; - if (cached_has_bits & 0x00000020u) { - target = stream->WriteBytesMaybeAliased( - 16, this->_internal_jpegthumbnail(), target); - } - - // optional .proto.ContextInfo contextInfo = 17; - if (cached_has_bits & 0x00001000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(17, _Internal::contextinfo(this), - _Internal::contextinfo(this).GetCachedSize(), target, stream); - } - - // optional bool doNotPlayInline = 18; - if (cached_has_bits & 0x00020000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(18, this->_internal_donotplayinline(), target); - } - - // optional string thumbnailDirectPath = 19; - if (cached_has_bits & 0x00000040u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_thumbnaildirectpath().data(), static_cast(this->_internal_thumbnaildirectpath().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ExtendedTextMessage.thumbnailDirectPath"); - target = stream->WriteStringMaybeAliased( - 19, this->_internal_thumbnaildirectpath(), target); - } - - // optional bytes thumbnailSha256 = 20; - if (cached_has_bits & 0x00000080u) { - target = stream->WriteBytesMaybeAliased( - 20, this->_internal_thumbnailsha256(), target); - } - - // optional bytes thumbnailEncSha256 = 21; - if (cached_has_bits & 0x00000100u) { - target = stream->WriteBytesMaybeAliased( - 21, this->_internal_thumbnailencsha256(), target); - } - - // optional bytes mediaKey = 22; - if (cached_has_bits & 0x00000200u) { - target = stream->WriteBytesMaybeAliased( - 22, this->_internal_mediakey(), target); - } - - // optional int64 mediaKeyTimestamp = 23; - if (cached_has_bits & 0x00080000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(23, this->_internal_mediakeytimestamp(), target); - } - - // optional uint32 thumbnailHeight = 24; - if (cached_has_bits & 0x00040000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(24, this->_internal_thumbnailheight(), target); - } - - // optional uint32 thumbnailWidth = 25; - if (cached_has_bits & 0x00100000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(25, this->_internal_thumbnailwidth(), target); - } - - // optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupType = 26; - if (cached_has_bits & 0x00200000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 26, this->_internal_invitelinkgrouptype(), target); - } - - // optional string inviteLinkParentGroupSubjectV2 = 27; - if (cached_has_bits & 0x00000400u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_invitelinkparentgroupsubjectv2().data(), static_cast(this->_internal_invitelinkparentgroupsubjectv2().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ExtendedTextMessage.inviteLinkParentGroupSubjectV2"); - target = stream->WriteStringMaybeAliased( - 27, this->_internal_invitelinkparentgroupsubjectv2(), target); - } - - // optional bytes inviteLinkParentGroupThumbnailV2 = 28; - if (cached_has_bits & 0x00000800u) { - target = stream->WriteBytesMaybeAliased( - 28, this->_internal_invitelinkparentgroupthumbnailv2(), target); - } - - // optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupTypeV2 = 29; - if (cached_has_bits & 0x00400000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 29, this->_internal_invitelinkgrouptypev2(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ExtendedTextMessage) - return target; -} - -size_t Message_ExtendedTextMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.ExtendedTextMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional string text = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_text()); - } - - // optional string matchedText = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_matchedtext()); - } - - // optional string canonicalUrl = 4; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_canonicalurl()); - } - - // optional string description = 5; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_description()); - } - - // optional string title = 6; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_title()); - } - - // optional bytes jpegThumbnail = 16; - if (cached_has_bits & 0x00000020u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_jpegthumbnail()); - } - - // optional string thumbnailDirectPath = 19; - if (cached_has_bits & 0x00000040u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_thumbnaildirectpath()); - } - - // optional bytes thumbnailSha256 = 20; - if (cached_has_bits & 0x00000080u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_thumbnailsha256()); - } - - } - if (cached_has_bits & 0x0000ff00u) { - // optional bytes thumbnailEncSha256 = 21; - if (cached_has_bits & 0x00000100u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_thumbnailencsha256()); - } - - // optional bytes mediaKey = 22; - if (cached_has_bits & 0x00000200u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_mediakey()); - } - - // optional string inviteLinkParentGroupSubjectV2 = 27; - if (cached_has_bits & 0x00000400u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_invitelinkparentgroupsubjectv2()); - } - - // optional bytes inviteLinkParentGroupThumbnailV2 = 28; - if (cached_has_bits & 0x00000800u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_invitelinkparentgroupthumbnailv2()); - } - - // optional .proto.ContextInfo contextInfo = 17; - if (cached_has_bits & 0x00001000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.contextinfo_); - } - - // optional fixed32 textArgb = 7; - if (cached_has_bits & 0x00002000u) { - total_size += 1 + 4; - } - - // optional fixed32 backgroundArgb = 8; - if (cached_has_bits & 0x00004000u) { - total_size += 1 + 4; - } - - // optional .proto.Message.ExtendedTextMessage.FontType font = 9; - if (cached_has_bits & 0x00008000u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_font()); - } - - } - if (cached_has_bits & 0x007f0000u) { - // optional .proto.Message.ExtendedTextMessage.PreviewType previewType = 10; - if (cached_has_bits & 0x00010000u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_previewtype()); - } - - // optional bool doNotPlayInline = 18; - if (cached_has_bits & 0x00020000u) { - total_size += 2 + 1; - } - - // optional uint32 thumbnailHeight = 24; - if (cached_has_bits & 0x00040000u) { - total_size += 2 + - ::_pbi::WireFormatLite::UInt32Size( - this->_internal_thumbnailheight()); - } - - // optional int64 mediaKeyTimestamp = 23; - if (cached_has_bits & 0x00080000u) { - total_size += 2 + - ::_pbi::WireFormatLite::Int64Size( - this->_internal_mediakeytimestamp()); - } - - // optional uint32 thumbnailWidth = 25; - if (cached_has_bits & 0x00100000u) { - total_size += 2 + - ::_pbi::WireFormatLite::UInt32Size( - this->_internal_thumbnailwidth()); - } - - // optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupType = 26; - if (cached_has_bits & 0x00200000u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_invitelinkgrouptype()); - } - - // optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupTypeV2 = 29; - if (cached_has_bits & 0x00400000u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_invitelinkgrouptypev2()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ExtendedTextMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_ExtendedTextMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ExtendedTextMessage::GetClassData() const { return &_class_data_; } - - -void Message_ExtendedTextMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ExtendedTextMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_text(from._internal_text()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_matchedtext(from._internal_matchedtext()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_canonicalurl(from._internal_canonicalurl()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_set_description(from._internal_description()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_set_title(from._internal_title()); - } - if (cached_has_bits & 0x00000020u) { - _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail()); - } - if (cached_has_bits & 0x00000040u) { - _this->_internal_set_thumbnaildirectpath(from._internal_thumbnaildirectpath()); - } - if (cached_has_bits & 0x00000080u) { - _this->_internal_set_thumbnailsha256(from._internal_thumbnailsha256()); - } - } - if (cached_has_bits & 0x0000ff00u) { - if (cached_has_bits & 0x00000100u) { - _this->_internal_set_thumbnailencsha256(from._internal_thumbnailencsha256()); - } - if (cached_has_bits & 0x00000200u) { - _this->_internal_set_mediakey(from._internal_mediakey()); - } - if (cached_has_bits & 0x00000400u) { - _this->_internal_set_invitelinkparentgroupsubjectv2(from._internal_invitelinkparentgroupsubjectv2()); - } - if (cached_has_bits & 0x00000800u) { - _this->_internal_set_invitelinkparentgroupthumbnailv2(from._internal_invitelinkparentgroupthumbnailv2()); - } - if (cached_has_bits & 0x00001000u) { - _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( - from._internal_contextinfo()); - } - if (cached_has_bits & 0x00002000u) { - _this->_impl_.textargb_ = from._impl_.textargb_; - } - if (cached_has_bits & 0x00004000u) { - _this->_impl_.backgroundargb_ = from._impl_.backgroundargb_; - } - if (cached_has_bits & 0x00008000u) { - _this->_impl_.font_ = from._impl_.font_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - if (cached_has_bits & 0x007f0000u) { - if (cached_has_bits & 0x00010000u) { - _this->_impl_.previewtype_ = from._impl_.previewtype_; - } - if (cached_has_bits & 0x00020000u) { - _this->_impl_.donotplayinline_ = from._impl_.donotplayinline_; - } - if (cached_has_bits & 0x00040000u) { - _this->_impl_.thumbnailheight_ = from._impl_.thumbnailheight_; - } - if (cached_has_bits & 0x00080000u) { - _this->_impl_.mediakeytimestamp_ = from._impl_.mediakeytimestamp_; - } - if (cached_has_bits & 0x00100000u) { - _this->_impl_.thumbnailwidth_ = from._impl_.thumbnailwidth_; - } - if (cached_has_bits & 0x00200000u) { - _this->_impl_.invitelinkgrouptype_ = from._impl_.invitelinkgrouptype_; - } - if (cached_has_bits & 0x00400000u) { - _this->_impl_.invitelinkgrouptypev2_ = from._impl_.invitelinkgrouptypev2_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_ExtendedTextMessage::CopyFrom(const Message_ExtendedTextMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ExtendedTextMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_ExtendedTextMessage::IsInitialized() const { - return true; -} - -void Message_ExtendedTextMessage::InternalSwap(Message_ExtendedTextMessage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.text_, lhs_arena, - &other->_impl_.text_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.matchedtext_, lhs_arena, - &other->_impl_.matchedtext_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.canonicalurl_, lhs_arena, - &other->_impl_.canonicalurl_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.description_, lhs_arena, - &other->_impl_.description_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.title_, lhs_arena, - &other->_impl_.title_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.jpegthumbnail_, lhs_arena, - &other->_impl_.jpegthumbnail_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.thumbnaildirectpath_, lhs_arena, - &other->_impl_.thumbnaildirectpath_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.thumbnailsha256_, lhs_arena, - &other->_impl_.thumbnailsha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.thumbnailencsha256_, lhs_arena, - &other->_impl_.thumbnailencsha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.mediakey_, lhs_arena, - &other->_impl_.mediakey_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.invitelinkparentgroupsubjectv2_, lhs_arena, - &other->_impl_.invitelinkparentgroupsubjectv2_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.invitelinkparentgroupthumbnailv2_, lhs_arena, - &other->_impl_.invitelinkparentgroupthumbnailv2_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_ExtendedTextMessage, _impl_.invitelinkgrouptypev2_) - + sizeof(Message_ExtendedTextMessage::_impl_.invitelinkgrouptypev2_) - - PROTOBUF_FIELD_OFFSET(Message_ExtendedTextMessage, _impl_.contextinfo_)>( - reinterpret_cast(&_impl_.contextinfo_), - reinterpret_cast(&other->_impl_.contextinfo_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_ExtendedTextMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[74]); -} - -// =================================================================== - -class Message_FutureProofMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::Message& message(const Message_FutureProofMessage* msg); - static void set_has_message(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -const ::proto::Message& -Message_FutureProofMessage::_Internal::message(const Message_FutureProofMessage* msg) { - return *msg->_impl_.message_; -} -Message_FutureProofMessage::Message_FutureProofMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.FutureProofMessage) -} -Message_FutureProofMessage::Message_FutureProofMessage(const Message_FutureProofMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_FutureProofMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.message_){nullptr}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_message()) { - _this->_impl_.message_ = new ::proto::Message(*from._impl_.message_); - } - // @@protoc_insertion_point(copy_constructor:proto.Message.FutureProofMessage) -} - -inline void Message_FutureProofMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.message_){nullptr} - }; -} - -Message_FutureProofMessage::~Message_FutureProofMessage() { - // @@protoc_insertion_point(destructor:proto.Message.FutureProofMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_FutureProofMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete _impl_.message_; -} - -void Message_FutureProofMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_FutureProofMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.FutureProofMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.message_ != nullptr); - _impl_.message_->Clear(); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_FutureProofMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.Message message = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_message(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_FutureProofMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.FutureProofMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.Message message = 1; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::message(this), - _Internal::message(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.FutureProofMessage) - return target; -} - -size_t Message_FutureProofMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.FutureProofMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional .proto.Message message = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.message_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_FutureProofMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_FutureProofMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_FutureProofMessage::GetClassData() const { return &_class_data_; } - - -void Message_FutureProofMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.FutureProofMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_message()) { - _this->_internal_mutable_message()->::proto::Message::MergeFrom( - from._internal_message()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_FutureProofMessage::CopyFrom(const Message_FutureProofMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.FutureProofMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_FutureProofMessage::IsInitialized() const { - return true; -} - -void Message_FutureProofMessage::InternalSwap(Message_FutureProofMessage* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - swap(_impl_.message_, other->_impl_.message_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_FutureProofMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[75]); -} - -// =================================================================== - -class Message_GroupInviteMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_groupjid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_invitecode(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_inviteexpiration(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static void set_has_groupname(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_jpegthumbnail(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_caption(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static const ::proto::ContextInfo& contextinfo(const Message_GroupInviteMessage* msg); - static void set_has_contextinfo(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static void set_has_grouptype(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } -}; - -const ::proto::ContextInfo& -Message_GroupInviteMessage::_Internal::contextinfo(const Message_GroupInviteMessage* msg) { - return *msg->_impl_.contextinfo_; -} -Message_GroupInviteMessage::Message_GroupInviteMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.GroupInviteMessage) -} -Message_GroupInviteMessage::Message_GroupInviteMessage(const Message_GroupInviteMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_GroupInviteMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.groupjid_){} - , decltype(_impl_.invitecode_){} - , decltype(_impl_.groupname_){} - , decltype(_impl_.jpegthumbnail_){} - , decltype(_impl_.caption_){} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.inviteexpiration_){} - , decltype(_impl_.grouptype_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.groupjid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.groupjid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_groupjid()) { - _this->_impl_.groupjid_.Set(from._internal_groupjid(), - _this->GetArenaForAllocation()); - } - _impl_.invitecode_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.invitecode_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_invitecode()) { - _this->_impl_.invitecode_.Set(from._internal_invitecode(), - _this->GetArenaForAllocation()); - } - _impl_.groupname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.groupname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_groupname()) { - _this->_impl_.groupname_.Set(from._internal_groupname(), - _this->GetArenaForAllocation()); - } - _impl_.jpegthumbnail_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_jpegthumbnail()) { - _this->_impl_.jpegthumbnail_.Set(from._internal_jpegthumbnail(), - _this->GetArenaForAllocation()); - } - _impl_.caption_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.caption_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_caption()) { - _this->_impl_.caption_.Set(from._internal_caption(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_contextinfo()) { - _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); - } - ::memcpy(&_impl_.inviteexpiration_, &from._impl_.inviteexpiration_, - static_cast(reinterpret_cast(&_impl_.grouptype_) - - reinterpret_cast(&_impl_.inviteexpiration_)) + sizeof(_impl_.grouptype_)); - // @@protoc_insertion_point(copy_constructor:proto.Message.GroupInviteMessage) -} - -inline void Message_GroupInviteMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.groupjid_){} - , decltype(_impl_.invitecode_){} - , decltype(_impl_.groupname_){} - , decltype(_impl_.jpegthumbnail_){} - , decltype(_impl_.caption_){} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.inviteexpiration_){int64_t{0}} - , decltype(_impl_.grouptype_){0} - }; - _impl_.groupjid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.groupjid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.invitecode_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.invitecode_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.groupname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.groupname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.jpegthumbnail_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.caption_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.caption_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_GroupInviteMessage::~Message_GroupInviteMessage() { - // @@protoc_insertion_point(destructor:proto.Message.GroupInviteMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_GroupInviteMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.groupjid_.Destroy(); - _impl_.invitecode_.Destroy(); - _impl_.groupname_.Destroy(); - _impl_.jpegthumbnail_.Destroy(); - _impl_.caption_.Destroy(); - if (this != internal_default_instance()) delete _impl_.contextinfo_; -} - -void Message_GroupInviteMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_GroupInviteMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.GroupInviteMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000003fu) { - if (cached_has_bits & 0x00000001u) { - _impl_.groupjid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.invitecode_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.groupname_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000008u) { - _impl_.jpegthumbnail_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000010u) { - _impl_.caption_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000020u) { - GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); - _impl_.contextinfo_->Clear(); - } - } - if (cached_has_bits & 0x000000c0u) { - ::memset(&_impl_.inviteexpiration_, 0, static_cast( - reinterpret_cast(&_impl_.grouptype_) - - reinterpret_cast(&_impl_.inviteexpiration_)) + sizeof(_impl_.grouptype_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_GroupInviteMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string groupJid = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_groupjid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.GroupInviteMessage.groupJid"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string inviteCode = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_invitecode(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.GroupInviteMessage.inviteCode"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional int64 inviteExpiration = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_inviteexpiration(&has_bits); - _impl_.inviteexpiration_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string groupName = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - auto str = _internal_mutable_groupname(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.GroupInviteMessage.groupName"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bytes jpegThumbnail = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - auto str = _internal_mutable_jpegthumbnail(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string caption = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - auto str = _internal_mutable_caption(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.GroupInviteMessage.caption"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.ContextInfo contextInfo = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.GroupInviteMessage.GroupType groupType = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::Message_GroupInviteMessage_GroupType_IsValid(val))) { - _internal_set_grouptype(static_cast<::proto::Message_GroupInviteMessage_GroupType>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(8, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_GroupInviteMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.GroupInviteMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string groupJid = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_groupjid().data(), static_cast(this->_internal_groupjid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.GroupInviteMessage.groupJid"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_groupjid(), target); - } - - // optional string inviteCode = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_invitecode().data(), static_cast(this->_internal_invitecode().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.GroupInviteMessage.inviteCode"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_invitecode(), target); - } - - // optional int64 inviteExpiration = 3; - if (cached_has_bits & 0x00000040u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_inviteexpiration(), target); - } - - // optional string groupName = 4; - if (cached_has_bits & 0x00000004u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_groupname().data(), static_cast(this->_internal_groupname().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.GroupInviteMessage.groupName"); - target = stream->WriteStringMaybeAliased( - 4, this->_internal_groupname(), target); - } - - // optional bytes jpegThumbnail = 5; - if (cached_has_bits & 0x00000008u) { - target = stream->WriteBytesMaybeAliased( - 5, this->_internal_jpegthumbnail(), target); - } - - // optional string caption = 6; - if (cached_has_bits & 0x00000010u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_caption().data(), static_cast(this->_internal_caption().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.GroupInviteMessage.caption"); - target = stream->WriteStringMaybeAliased( - 6, this->_internal_caption(), target); - } - - // optional .proto.ContextInfo contextInfo = 7; - if (cached_has_bits & 0x00000020u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(7, _Internal::contextinfo(this), - _Internal::contextinfo(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.GroupInviteMessage.GroupType groupType = 8; - if (cached_has_bits & 0x00000080u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 8, this->_internal_grouptype(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.GroupInviteMessage) - return target; -} - -size_t Message_GroupInviteMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.GroupInviteMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional string groupJid = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_groupjid()); - } - - // optional string inviteCode = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_invitecode()); - } - - // optional string groupName = 4; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_groupname()); - } - - // optional bytes jpegThumbnail = 5; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_jpegthumbnail()); - } - - // optional string caption = 6; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_caption()); - } - - // optional .proto.ContextInfo contextInfo = 7; - if (cached_has_bits & 0x00000020u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.contextinfo_); - } - - // optional int64 inviteExpiration = 3; - if (cached_has_bits & 0x00000040u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_inviteexpiration()); - } - - // optional .proto.Message.GroupInviteMessage.GroupType groupType = 8; - if (cached_has_bits & 0x00000080u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_grouptype()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_GroupInviteMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_GroupInviteMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_GroupInviteMessage::GetClassData() const { return &_class_data_; } - - -void Message_GroupInviteMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.GroupInviteMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_groupjid(from._internal_groupjid()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_invitecode(from._internal_invitecode()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_groupname(from._internal_groupname()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_set_caption(from._internal_caption()); - } - if (cached_has_bits & 0x00000020u) { - _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( - from._internal_contextinfo()); - } - if (cached_has_bits & 0x00000040u) { - _this->_impl_.inviteexpiration_ = from._impl_.inviteexpiration_; - } - if (cached_has_bits & 0x00000080u) { - _this->_impl_.grouptype_ = from._impl_.grouptype_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_GroupInviteMessage::CopyFrom(const Message_GroupInviteMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.GroupInviteMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_GroupInviteMessage::IsInitialized() const { - return true; -} - -void Message_GroupInviteMessage::InternalSwap(Message_GroupInviteMessage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.groupjid_, lhs_arena, - &other->_impl_.groupjid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.invitecode_, lhs_arena, - &other->_impl_.invitecode_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.groupname_, lhs_arena, - &other->_impl_.groupname_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.jpegthumbnail_, lhs_arena, - &other->_impl_.jpegthumbnail_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.caption_, lhs_arena, - &other->_impl_.caption_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_GroupInviteMessage, _impl_.grouptype_) - + sizeof(Message_GroupInviteMessage::_impl_.grouptype_) - - PROTOBUF_FIELD_OFFSET(Message_GroupInviteMessage, _impl_.contextinfo_)>( - reinterpret_cast(&_impl_.contextinfo_), - reinterpret_cast(&other->_impl_.contextinfo_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_GroupInviteMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[76]); -} - -// =================================================================== - -class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_currencycode(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_amount1000(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency) -} -Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.currencycode_){} - , decltype(_impl_.amount1000_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.currencycode_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.currencycode_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_currencycode()) { - _this->_impl_.currencycode_.Set(from._internal_currencycode(), - _this->GetArenaForAllocation()); - } - _this->_impl_.amount1000_ = from._impl_.amount1000_; - // @@protoc_insertion_point(copy_constructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency) -} - -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.currencycode_){} - , decltype(_impl_.amount1000_){int64_t{0}} - }; - _impl_.currencycode_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.currencycode_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency() { - // @@protoc_insertion_point(destructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.currencycode_.Destroy(); -} - -void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.currencycode_.ClearNonDefaultToEmpty(); - } - _impl_.amount1000_ = int64_t{0}; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string currencyCode = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_currencycode(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.currencyCode"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional int64 amount1000 = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_amount1000(&has_bits); - _impl_.amount1000_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string currencyCode = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_currencycode().data(), static_cast(this->_internal_currencycode().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.currencyCode"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_currencycode(), target); - } - - // optional int64 amount1000 = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_amount1000(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency) - return target; -} - -size_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional string currencyCode = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_currencycode()); - } - - // optional int64 amount1000 = 2; - if (cached_has_bits & 0x00000002u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_amount1000()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::GetClassData() const { return &_class_data_; } - - -void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_currencycode(from._internal_currencycode()); - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.amount1000_ = from._impl_.amount1000_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::IsInitialized() const { - return true; -} - -void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.currencycode_, lhs_arena, - &other->_impl_.currencycode_, rhs_arena - ); - swap(_impl_.amount1000_, other->_impl_.amount1000_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[77]); -} - -// =================================================================== - -class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_dayofweek(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static void set_has_year(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_month(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_dayofmonth(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_hour(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_minute(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_calendar(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } -}; - -Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent) -} -Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.year_){} - , decltype(_impl_.month_){} - , decltype(_impl_.dayofmonth_){} - , decltype(_impl_.hour_){} - , decltype(_impl_.minute_){} - , decltype(_impl_.dayofweek_){} - , decltype(_impl_.calendar_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&_impl_.year_, &from._impl_.year_, - static_cast(reinterpret_cast(&_impl_.calendar_) - - reinterpret_cast(&_impl_.year_)) + sizeof(_impl_.calendar_)); - // @@protoc_insertion_point(copy_constructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent) -} - -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.year_){0u} - , decltype(_impl_.month_){0u} - , decltype(_impl_.dayofmonth_){0u} - , decltype(_impl_.hour_){0u} - , decltype(_impl_.minute_){0u} - , decltype(_impl_.dayofweek_){1} - , decltype(_impl_.calendar_){1} - }; -} - -Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent() { - // @@protoc_insertion_point(destructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000007fu) { - ::memset(&_impl_.year_, 0, static_cast( - reinterpret_cast(&_impl_.minute_) - - reinterpret_cast(&_impl_.year_)) + sizeof(_impl_.minute_)); - _impl_.dayofweek_ = 1; - _impl_.calendar_ = 1; - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.DayOfWeekType dayOfWeek = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_IsValid(val))) { - _internal_set_dayofweek(static_cast<::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional uint32 year = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_year(&has_bits); - _impl_.year_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 month = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_month(&has_bits); - _impl_.month_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 dayOfMonth = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - _Internal::set_has_dayofmonth(&has_bits); - _impl_.dayofmonth_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 hour = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { - _Internal::set_has_hour(&has_bits); - _impl_.hour_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 minute = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { - _Internal::set_has_minute(&has_bits); - _impl_.minute_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.CalendarType calendar = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_IsValid(val))) { - _internal_set_calendar(static_cast<::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(7, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.DayOfWeekType dayOfWeek = 1; - if (cached_has_bits & 0x00000020u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 1, this->_internal_dayofweek(), target); - } - - // optional uint32 year = 2; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_year(), target); - } - - // optional uint32 month = 3; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_month(), target); - } - - // optional uint32 dayOfMonth = 4; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_dayofmonth(), target); - } - - // optional uint32 hour = 5; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_hour(), target); - } - - // optional uint32 minute = 6; - if (cached_has_bits & 0x00000010u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_minute(), target); - } - - // optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.CalendarType calendar = 7; - if (cached_has_bits & 0x00000040u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 7, this->_internal_calendar(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent) - return target; -} - -size_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000007fu) { - // optional uint32 year = 2; - if (cached_has_bits & 0x00000001u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_year()); - } - - // optional uint32 month = 3; - if (cached_has_bits & 0x00000002u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_month()); - } - - // optional uint32 dayOfMonth = 4; - if (cached_has_bits & 0x00000004u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_dayofmonth()); - } - - // optional uint32 hour = 5; - if (cached_has_bits & 0x00000008u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_hour()); - } - - // optional uint32 minute = 6; - if (cached_has_bits & 0x00000010u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_minute()); - } - - // optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.DayOfWeekType dayOfWeek = 1; - if (cached_has_bits & 0x00000020u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_dayofweek()); - } - - // optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.CalendarType calendar = 7; - if (cached_has_bits & 0x00000040u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_calendar()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::GetClassData() const { return &_class_data_; } - - -void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000007fu) { - if (cached_has_bits & 0x00000001u) { - _this->_impl_.year_ = from._impl_.year_; - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.month_ = from._impl_.month_; - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.dayofmonth_ = from._impl_.dayofmonth_; - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.hour_ = from._impl_.hour_; - } - if (cached_has_bits & 0x00000010u) { - _this->_impl_.minute_ = from._impl_.minute_; - } - if (cached_has_bits & 0x00000020u) { - _this->_impl_.dayofweek_ = from._impl_.dayofweek_; - } - if (cached_has_bits & 0x00000040u) { - _this->_impl_.calendar_ = from._impl_.calendar_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::IsInitialized() const { - return true; -} - -void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _impl_.minute_) - + sizeof(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_impl_.minute_) - - PROTOBUF_FIELD_OFFSET(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent, _impl_.year_)>( - reinterpret_cast(&_impl_.year_), - reinterpret_cast(&other->_impl_.year_)); - swap(_impl_.dayofweek_, other->_impl_.dayofweek_); - swap(_impl_.calendar_, other->_impl_.calendar_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[78]); -} - -// =================================================================== - -class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_timestamp(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch) -} -Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.timestamp_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _this->_impl_.timestamp_ = from._impl_.timestamp_; - // @@protoc_insertion_point(copy_constructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch) -} - -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.timestamp_){int64_t{0}} - }; -} - -Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch() { - // @@protoc_insertion_point(destructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.timestamp_ = int64_t{0}; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional int64 timestamp = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_timestamp(&has_bits); - _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional int64 timestamp = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_timestamp(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch) - return target; -} - -size_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional int64 timestamp = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_timestamp()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::GetClassData() const { return &_class_data_; } - - -void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_timestamp()) { - _this->_internal_set_timestamp(from._internal_timestamp()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::IsInitialized() const { - return true; -} - -void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - swap(_impl_.timestamp_, other->_impl_.timestamp_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[79]); -} - -// =================================================================== - -class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_Internal { - public: - static const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& component(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* msg); - static const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& unixepoch(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* msg); -}; - -const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& -Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_Internal::component(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* msg) { - return *msg->_impl_.datetimeOneof_.component_; -} -const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& -Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_Internal::unixepoch(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* msg) { - return *msg->_impl_.datetimeOneof_.unixepoch_; -} -void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::set_allocated_component(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* component) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_datetimeOneof(); - if (component) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(component); - if (message_arena != submessage_arena) { - component = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, component, submessage_arena); - } - set_has_component(); - _impl_.datetimeOneof_.component_ = component; - } - // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.component) -} -void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::set_allocated_unixepoch(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* unixepoch) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_datetimeOneof(); - if (unixepoch) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(unixepoch); - if (message_arena != submessage_arena) { - unixepoch = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, unixepoch, submessage_arena); - } - set_has_unixepoch(); - _impl_.datetimeOneof_.unixepoch_ = unixepoch; - } - // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.unixEpoch) -} -Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime) -} -Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_.datetimeOneof_){} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_._oneof_case_)*/{}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - clear_has_datetimeOneof(); - switch (from.datetimeOneof_case()) { - case kComponent: { - _this->_internal_mutable_component()->::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::MergeFrom( - from._internal_component()); - break; - } - case kUnixEpoch: { - _this->_internal_mutable_unixepoch()->::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::MergeFrom( - from._internal_unixepoch()); - break; - } - case DATETIMEONEOF_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime) -} - -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_.datetimeOneof_){} - , /*decltype(_impl_._cached_size_)*/{} - , /*decltype(_impl_._oneof_case_)*/{} - }; - clear_has_datetimeOneof(); -} - -Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime() { - // @@protoc_insertion_point(destructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (has_datetimeOneof()) { - clear_datetimeOneof(); - } -} - -void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::clear_datetimeOneof() { -// @@protoc_insertion_point(one_of_clear_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime) - switch (datetimeOneof_case()) { - case kComponent: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.datetimeOneof_.component_; - } - break; - } - case kUnixEpoch: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.datetimeOneof_.unixepoch_; - } - break; - } - case DATETIMEONEOF_NOT_SET: { - break; - } - } - _impl_._oneof_case_[0] = DATETIMEONEOF_NOT_SET; -} - - -void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - clear_datetimeOneof(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent component = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_component(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch unixEpoch = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_unixepoch(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - switch (datetimeOneof_case()) { - case kComponent: { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::component(this), - _Internal::component(this).GetCachedSize(), target, stream); - break; - } - case kUnixEpoch: { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::unixepoch(this), - _Internal::unixepoch(this).GetCachedSize(), target, stream); - break; - } - default: ; - } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime) - return target; -} - -size_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - switch (datetimeOneof_case()) { - // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent component = 1; - case kComponent: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.datetimeOneof_.component_); - break; - } - // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch unixEpoch = 2; - case kUnixEpoch: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.datetimeOneof_.unixepoch_); - break; - } - case DATETIMEONEOF_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::GetClassData() const { return &_class_data_; } - - -void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - switch (from.datetimeOneof_case()) { - case kComponent: { - _this->_internal_mutable_component()->::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::MergeFrom( - from._internal_component()); - break; - } - case kUnixEpoch: { - _this->_internal_mutable_unixepoch()->::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::MergeFrom( - from._internal_unixepoch()); - break; - } - case DATETIMEONEOF_NOT_SET: { - break; - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::IsInitialized() const { - return true; -} - -void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_.datetimeOneof_, other->_impl_.datetimeOneof_); - swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[80]); -} - -// =================================================================== - -class Message_HighlyStructuredMessage_HSMLocalizableParameter::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_default_(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& currency(const Message_HighlyStructuredMessage_HSMLocalizableParameter* msg); - static const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& datetime(const Message_HighlyStructuredMessage_HSMLocalizableParameter* msg); -}; - -const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& -Message_HighlyStructuredMessage_HSMLocalizableParameter::_Internal::currency(const Message_HighlyStructuredMessage_HSMLocalizableParameter* msg) { - return *msg->_impl_.paramOneof_.currency_; -} -const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& -Message_HighlyStructuredMessage_HSMLocalizableParameter::_Internal::datetime(const Message_HighlyStructuredMessage_HSMLocalizableParameter* msg) { - return *msg->_impl_.paramOneof_.datetime_; -} -void Message_HighlyStructuredMessage_HSMLocalizableParameter::set_allocated_currency(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* currency) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_paramOneof(); - if (currency) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(currency); - if (message_arena != submessage_arena) { - currency = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, currency, submessage_arena); - } - set_has_currency(); - _impl_.paramOneof_.currency_ = currency; - } - // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.currency) -} -void Message_HighlyStructuredMessage_HSMLocalizableParameter::set_allocated_datetime(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* datetime) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_paramOneof(); - if (datetime) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(datetime); - if (message_arena != submessage_arena) { - datetime = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, datetime, submessage_arena); - } - set_has_datetime(); - _impl_.paramOneof_.datetime_ = datetime; - } - // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.dateTime) -} -Message_HighlyStructuredMessage_HSMLocalizableParameter::Message_HighlyStructuredMessage_HSMLocalizableParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter) -} -Message_HighlyStructuredMessage_HSMLocalizableParameter::Message_HighlyStructuredMessage_HSMLocalizableParameter(const Message_HighlyStructuredMessage_HSMLocalizableParameter& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_HighlyStructuredMessage_HSMLocalizableParameter* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.default__){} - , decltype(_impl_.paramOneof_){} - , /*decltype(_impl_._oneof_case_)*/{}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.default__.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.default__.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_default_()) { - _this->_impl_.default__.Set(from._internal_default_(), - _this->GetArenaForAllocation()); - } - clear_has_paramOneof(); - switch (from.paramOneof_case()) { - case kCurrency: { - _this->_internal_mutable_currency()->::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::MergeFrom( - from._internal_currency()); - break; - } - case kDateTime: { - _this->_internal_mutable_datetime()->::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::MergeFrom( - from._internal_datetime()); - break; - } - case PARAMONEOF_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter) -} - -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.default__){} - , decltype(_impl_.paramOneof_){} - , /*decltype(_impl_._oneof_case_)*/{} - }; - _impl_.default__.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.default__.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - clear_has_paramOneof(); -} - -Message_HighlyStructuredMessage_HSMLocalizableParameter::~Message_HighlyStructuredMessage_HSMLocalizableParameter() { - // @@protoc_insertion_point(destructor:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.default__.Destroy(); - if (has_paramOneof()) { - clear_paramOneof(); - } -} - -void Message_HighlyStructuredMessage_HSMLocalizableParameter::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_HighlyStructuredMessage_HSMLocalizableParameter::clear_paramOneof() { -// @@protoc_insertion_point(one_of_clear_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter) - switch (paramOneof_case()) { - case kCurrency: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.paramOneof_.currency_; - } - break; - } - case kDateTime: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.paramOneof_.datetime_; - } - break; - } - case PARAMONEOF_NOT_SET: { - break; - } - } - _impl_._oneof_case_[0] = PARAMONEOF_NOT_SET; -} - - -void Message_HighlyStructuredMessage_HSMLocalizableParameter::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.default__.ClearNonDefaultToEmpty(); - } - clear_paramOneof(); - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_HighlyStructuredMessage_HSMLocalizableParameter::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string default = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_default_(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.default"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency currency = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_currency(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime dateTime = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_datetime(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_HighlyStructuredMessage_HSMLocalizableParameter::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string default = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_default_().data(), static_cast(this->_internal_default_().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.default"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_default_(), target); - } - - switch (paramOneof_case()) { - case kCurrency: { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::currency(this), - _Internal::currency(this).GetCachedSize(), target, stream); - break; - } - case kDateTime: { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, _Internal::datetime(this), - _Internal::datetime(this).GetCachedSize(), target, stream); - break; - } - default: ; - } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter) - return target; -} - -size_t Message_HighlyStructuredMessage_HSMLocalizableParameter::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional string default = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_default_()); - } - - switch (paramOneof_case()) { - // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency currency = 2; - case kCurrency: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.paramOneof_.currency_); - break; - } - // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime dateTime = 3; - case kDateTime: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.paramOneof_.datetime_); - break; - } - case PARAMONEOF_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_HighlyStructuredMessage_HSMLocalizableParameter::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_HighlyStructuredMessage_HSMLocalizableParameter::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_HighlyStructuredMessage_HSMLocalizableParameter::GetClassData() const { return &_class_data_; } - - -void Message_HighlyStructuredMessage_HSMLocalizableParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_default_()) { - _this->_internal_set_default_(from._internal_default_()); - } - switch (from.paramOneof_case()) { - case kCurrency: { - _this->_internal_mutable_currency()->::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::MergeFrom( - from._internal_currency()); - break; - } - case kDateTime: { - _this->_internal_mutable_datetime()->::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::MergeFrom( - from._internal_datetime()); - break; - } - case PARAMONEOF_NOT_SET: { - break; - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_HighlyStructuredMessage_HSMLocalizableParameter::CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_HighlyStructuredMessage_HSMLocalizableParameter::IsInitialized() const { - return true; -} - -void Message_HighlyStructuredMessage_HSMLocalizableParameter::InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.default__, lhs_arena, - &other->_impl_.default__, rhs_arena - ); - swap(_impl_.paramOneof_, other->_impl_.paramOneof_); - swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_HighlyStructuredMessage_HSMLocalizableParameter::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[81]); -} - -// =================================================================== - -class Message_HighlyStructuredMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_namespace_(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_elementname(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_fallbacklg(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_fallbacklc(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_deterministiclg(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_deterministiclc(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static const ::proto::Message_TemplateMessage& hydratedhsm(const Message_HighlyStructuredMessage* msg); - static void set_has_hydratedhsm(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } -}; - -const ::proto::Message_TemplateMessage& -Message_HighlyStructuredMessage::_Internal::hydratedhsm(const Message_HighlyStructuredMessage* msg) { - return *msg->_impl_.hydratedhsm_; -} -Message_HighlyStructuredMessage::Message_HighlyStructuredMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.HighlyStructuredMessage) -} -Message_HighlyStructuredMessage::Message_HighlyStructuredMessage(const Message_HighlyStructuredMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_HighlyStructuredMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.params_){from._impl_.params_} - , decltype(_impl_.localizableparams_){from._impl_.localizableparams_} - , decltype(_impl_.namespace__){} - , decltype(_impl_.elementname_){} - , decltype(_impl_.fallbacklg_){} - , decltype(_impl_.fallbacklc_){} - , decltype(_impl_.deterministiclg_){} - , decltype(_impl_.deterministiclc_){} - , decltype(_impl_.hydratedhsm_){nullptr}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.namespace__.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.namespace__.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_namespace_()) { - _this->_impl_.namespace__.Set(from._internal_namespace_(), - _this->GetArenaForAllocation()); - } - _impl_.elementname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.elementname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_elementname()) { - _this->_impl_.elementname_.Set(from._internal_elementname(), - _this->GetArenaForAllocation()); - } - _impl_.fallbacklg_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fallbacklg_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_fallbacklg()) { - _this->_impl_.fallbacklg_.Set(from._internal_fallbacklg(), - _this->GetArenaForAllocation()); - } - _impl_.fallbacklc_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fallbacklc_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_fallbacklc()) { - _this->_impl_.fallbacklc_.Set(from._internal_fallbacklc(), - _this->GetArenaForAllocation()); - } - _impl_.deterministiclg_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.deterministiclg_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_deterministiclg()) { - _this->_impl_.deterministiclg_.Set(from._internal_deterministiclg(), - _this->GetArenaForAllocation()); - } - _impl_.deterministiclc_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.deterministiclc_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_deterministiclc()) { - _this->_impl_.deterministiclc_.Set(from._internal_deterministiclc(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_hydratedhsm()) { - _this->_impl_.hydratedhsm_ = new ::proto::Message_TemplateMessage(*from._impl_.hydratedhsm_); - } - // @@protoc_insertion_point(copy_constructor:proto.Message.HighlyStructuredMessage) -} - -inline void Message_HighlyStructuredMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.params_){arena} - , decltype(_impl_.localizableparams_){arena} - , decltype(_impl_.namespace__){} - , decltype(_impl_.elementname_){} - , decltype(_impl_.fallbacklg_){} - , decltype(_impl_.fallbacklc_){} - , decltype(_impl_.deterministiclg_){} - , decltype(_impl_.deterministiclc_){} - , decltype(_impl_.hydratedhsm_){nullptr} - }; - _impl_.namespace__.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.namespace__.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.elementname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.elementname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fallbacklg_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fallbacklg_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fallbacklc_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fallbacklc_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.deterministiclg_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.deterministiclg_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.deterministiclc_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.deterministiclc_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_HighlyStructuredMessage::~Message_HighlyStructuredMessage() { - // @@protoc_insertion_point(destructor:proto.Message.HighlyStructuredMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_HighlyStructuredMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.params_.~RepeatedPtrField(); - _impl_.localizableparams_.~RepeatedPtrField(); - _impl_.namespace__.Destroy(); - _impl_.elementname_.Destroy(); - _impl_.fallbacklg_.Destroy(); - _impl_.fallbacklc_.Destroy(); - _impl_.deterministiclg_.Destroy(); - _impl_.deterministiclc_.Destroy(); - if (this != internal_default_instance()) delete _impl_.hydratedhsm_; -} - -void Message_HighlyStructuredMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_HighlyStructuredMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.HighlyStructuredMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.params_.Clear(); - _impl_.localizableparams_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000007fu) { - if (cached_has_bits & 0x00000001u) { - _impl_.namespace__.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.elementname_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.fallbacklg_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000008u) { - _impl_.fallbacklc_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000010u) { - _impl_.deterministiclg_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000020u) { - _impl_.deterministiclc_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000040u) { - GOOGLE_DCHECK(_impl_.hydratedhsm_ != nullptr); - _impl_.hydratedhsm_->Clear(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_HighlyStructuredMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string namespace = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_namespace_(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.HighlyStructuredMessage.namespace"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string elementName = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_elementname(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.HighlyStructuredMessage.elementName"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // repeated string params = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr -= 1; - do { - ptr += 1; - auto str = _internal_add_params(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.HighlyStructuredMessage.params"); - #endif // !NDEBUG - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); - } else - goto handle_unusual; - continue; - // optional string fallbackLg = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - auto str = _internal_mutable_fallbacklg(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.HighlyStructuredMessage.fallbackLg"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string fallbackLc = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - auto str = _internal_mutable_fallbacklc(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.HighlyStructuredMessage.fallbackLc"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // repeated .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter localizableParams = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_localizableparams(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr)); - } else - goto handle_unusual; - continue; - // optional string deterministicLg = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - auto str = _internal_mutable_deterministiclg(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.HighlyStructuredMessage.deterministicLg"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string deterministicLc = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { - auto str = _internal_mutable_deterministiclc(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.HighlyStructuredMessage.deterministicLc"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.Message.TemplateMessage hydratedHsm = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { - ptr = ctx->ParseMessage(_internal_mutable_hydratedhsm(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_HighlyStructuredMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.HighlyStructuredMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string namespace = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_namespace_().data(), static_cast(this->_internal_namespace_().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.HighlyStructuredMessage.namespace"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_namespace_(), target); - } - - // optional string elementName = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_elementname().data(), static_cast(this->_internal_elementname().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.HighlyStructuredMessage.elementName"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_elementname(), target); - } - - // repeated string params = 3; - for (int i = 0, n = this->_internal_params_size(); i < n; i++) { - const auto& s = this->_internal_params(i); - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - s.data(), static_cast(s.length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.HighlyStructuredMessage.params"); - target = stream->WriteString(3, s, target); - } - - // optional string fallbackLg = 4; - if (cached_has_bits & 0x00000004u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_fallbacklg().data(), static_cast(this->_internal_fallbacklg().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.HighlyStructuredMessage.fallbackLg"); - target = stream->WriteStringMaybeAliased( - 4, this->_internal_fallbacklg(), target); - } - - // optional string fallbackLc = 5; - if (cached_has_bits & 0x00000008u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_fallbacklc().data(), static_cast(this->_internal_fallbacklc().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.HighlyStructuredMessage.fallbackLc"); - target = stream->WriteStringMaybeAliased( - 5, this->_internal_fallbacklc(), target); - } - - // repeated .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter localizableParams = 6; - for (unsigned i = 0, - n = static_cast(this->_internal_localizableparams_size()); i < n; i++) { - const auto& repfield = this->_internal_localizableparams(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(6, repfield, repfield.GetCachedSize(), target, stream); - } - - // optional string deterministicLg = 7; - if (cached_has_bits & 0x00000010u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_deterministiclg().data(), static_cast(this->_internal_deterministiclg().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.HighlyStructuredMessage.deterministicLg"); - target = stream->WriteStringMaybeAliased( - 7, this->_internal_deterministiclg(), target); - } - - // optional string deterministicLc = 8; - if (cached_has_bits & 0x00000020u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_deterministiclc().data(), static_cast(this->_internal_deterministiclc().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.HighlyStructuredMessage.deterministicLc"); - target = stream->WriteStringMaybeAliased( - 8, this->_internal_deterministiclc(), target); - } - - // optional .proto.Message.TemplateMessage hydratedHsm = 9; - if (cached_has_bits & 0x00000040u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(9, _Internal::hydratedhsm(this), - _Internal::hydratedhsm(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.HighlyStructuredMessage) - return target; -} - -size_t Message_HighlyStructuredMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.HighlyStructuredMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated string params = 3; - total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.params_.size()); - for (int i = 0, n = _impl_.params_.size(); i < n; i++) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - _impl_.params_.Get(i)); - } - - // repeated .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter localizableParams = 6; - total_size += 1UL * this->_internal_localizableparams_size(); - for (const auto& msg : this->_impl_.localizableparams_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000007fu) { - // optional string namespace = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_namespace_()); - } - - // optional string elementName = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_elementname()); - } - - // optional string fallbackLg = 4; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_fallbacklg()); - } - - // optional string fallbackLc = 5; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_fallbacklc()); - } - - // optional string deterministicLg = 7; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_deterministiclg()); - } - - // optional string deterministicLc = 8; - if (cached_has_bits & 0x00000020u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_deterministiclc()); - } - - // optional .proto.Message.TemplateMessage hydratedHsm = 9; - if (cached_has_bits & 0x00000040u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.hydratedhsm_); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_HighlyStructuredMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_HighlyStructuredMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_HighlyStructuredMessage::GetClassData() const { return &_class_data_; } - - -void Message_HighlyStructuredMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.HighlyStructuredMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.params_.MergeFrom(from._impl_.params_); - _this->_impl_.localizableparams_.MergeFrom(from._impl_.localizableparams_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000007fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_namespace_(from._internal_namespace_()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_elementname(from._internal_elementname()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_fallbacklg(from._internal_fallbacklg()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_set_fallbacklc(from._internal_fallbacklc()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_set_deterministiclg(from._internal_deterministiclg()); - } - if (cached_has_bits & 0x00000020u) { - _this->_internal_set_deterministiclc(from._internal_deterministiclc()); - } - if (cached_has_bits & 0x00000040u) { - _this->_internal_mutable_hydratedhsm()->::proto::Message_TemplateMessage::MergeFrom( - from._internal_hydratedhsm()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_HighlyStructuredMessage::CopyFrom(const Message_HighlyStructuredMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.HighlyStructuredMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_HighlyStructuredMessage::IsInitialized() const { - return true; -} - -void Message_HighlyStructuredMessage::InternalSwap(Message_HighlyStructuredMessage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.params_.InternalSwap(&other->_impl_.params_); - _impl_.localizableparams_.InternalSwap(&other->_impl_.localizableparams_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.namespace__, lhs_arena, - &other->_impl_.namespace__, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.elementname_, lhs_arena, - &other->_impl_.elementname_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.fallbacklg_, lhs_arena, - &other->_impl_.fallbacklg_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.fallbacklc_, lhs_arena, - &other->_impl_.fallbacklc_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.deterministiclg_, lhs_arena, - &other->_impl_.deterministiclg_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.deterministiclc_, lhs_arena, - &other->_impl_.deterministiclc_, rhs_arena - ); - swap(_impl_.hydratedhsm_, other->_impl_.hydratedhsm_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_HighlyStructuredMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[82]); -} - -// =================================================================== - -class Message_HistorySyncNotification::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_filesha256(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_filelength(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static void set_has_mediakey(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_fileencsha256(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_directpath(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_synctype(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static void set_has_chunkorder(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } - static void set_has_originalmessageid(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_progress(HasBits* has_bits) { - (*has_bits)[0] |= 256u; - } -}; - -Message_HistorySyncNotification::Message_HistorySyncNotification(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.HistorySyncNotification) -} -Message_HistorySyncNotification::Message_HistorySyncNotification(const Message_HistorySyncNotification& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_HistorySyncNotification* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.filesha256_){} - , decltype(_impl_.mediakey_){} - , decltype(_impl_.fileencsha256_){} - , decltype(_impl_.directpath_){} - , decltype(_impl_.originalmessageid_){} - , decltype(_impl_.filelength_){} - , decltype(_impl_.synctype_){} - , decltype(_impl_.chunkorder_){} - , decltype(_impl_.progress_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.filesha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filesha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_filesha256()) { - _this->_impl_.filesha256_.Set(from._internal_filesha256(), - _this->GetArenaForAllocation()); - } - _impl_.mediakey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediakey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_mediakey()) { - _this->_impl_.mediakey_.Set(from._internal_mediakey(), - _this->GetArenaForAllocation()); - } - _impl_.fileencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_fileencsha256()) { - _this->_impl_.fileencsha256_.Set(from._internal_fileencsha256(), - _this->GetArenaForAllocation()); - } - _impl_.directpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_directpath()) { - _this->_impl_.directpath_.Set(from._internal_directpath(), - _this->GetArenaForAllocation()); - } - _impl_.originalmessageid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.originalmessageid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_originalmessageid()) { - _this->_impl_.originalmessageid_.Set(from._internal_originalmessageid(), - _this->GetArenaForAllocation()); - } - ::memcpy(&_impl_.filelength_, &from._impl_.filelength_, - static_cast(reinterpret_cast(&_impl_.progress_) - - reinterpret_cast(&_impl_.filelength_)) + sizeof(_impl_.progress_)); - // @@protoc_insertion_point(copy_constructor:proto.Message.HistorySyncNotification) -} - -inline void Message_HistorySyncNotification::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.filesha256_){} - , decltype(_impl_.mediakey_){} - , decltype(_impl_.fileencsha256_){} - , decltype(_impl_.directpath_){} - , decltype(_impl_.originalmessageid_){} - , decltype(_impl_.filelength_){uint64_t{0u}} - , decltype(_impl_.synctype_){0} - , decltype(_impl_.chunkorder_){0u} - , decltype(_impl_.progress_){0u} - }; - _impl_.filesha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filesha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediakey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediakey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fileencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.originalmessageid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.originalmessageid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_HistorySyncNotification::~Message_HistorySyncNotification() { - // @@protoc_insertion_point(destructor:proto.Message.HistorySyncNotification) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_HistorySyncNotification::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.filesha256_.Destroy(); - _impl_.mediakey_.Destroy(); - _impl_.fileencsha256_.Destroy(); - _impl_.directpath_.Destroy(); - _impl_.originalmessageid_.Destroy(); -} - -void Message_HistorySyncNotification::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_HistorySyncNotification::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.HistorySyncNotification) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { - if (cached_has_bits & 0x00000001u) { - _impl_.filesha256_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.mediakey_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.fileencsha256_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000008u) { - _impl_.directpath_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000010u) { - _impl_.originalmessageid_.ClearNonDefaultToEmpty(); - } - } - if (cached_has_bits & 0x000000e0u) { - ::memset(&_impl_.filelength_, 0, static_cast( - reinterpret_cast(&_impl_.chunkorder_) - - reinterpret_cast(&_impl_.filelength_)) + sizeof(_impl_.chunkorder_)); - } - _impl_.progress_ = 0u; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_HistorySyncNotification::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bytes fileSha256 = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_filesha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint64 fileLength = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_filelength(&has_bits); - _impl_.filelength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes mediaKey = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_mediakey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes fileEncSha256 = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - auto str = _internal_mutable_fileencsha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string directPath = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - auto str = _internal_mutable_directpath(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.HistorySyncNotification.directPath"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.Message.HistorySyncNotification.HistorySyncType syncType = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::Message_HistorySyncNotification_HistorySyncType_IsValid(val))) { - _internal_set_synctype(static_cast<::proto::Message_HistorySyncNotification_HistorySyncType>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(6, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional uint32 chunkOrder = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { - _Internal::set_has_chunkorder(&has_bits); - _impl_.chunkorder_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string originalMessageId = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { - auto str = _internal_mutable_originalmessageid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.HistorySyncNotification.originalMessageId"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional uint32 progress = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { - _Internal::set_has_progress(&has_bits); - _impl_.progress_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_HistorySyncNotification::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.HistorySyncNotification) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bytes fileSha256 = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 1, this->_internal_filesha256(), target); - } - - // optional uint64 fileLength = 2; - if (cached_has_bits & 0x00000020u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_filelength(), target); - } - - // optional bytes mediaKey = 3; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 3, this->_internal_mediakey(), target); - } - - // optional bytes fileEncSha256 = 4; - if (cached_has_bits & 0x00000004u) { - target = stream->WriteBytesMaybeAliased( - 4, this->_internal_fileencsha256(), target); - } - - // optional string directPath = 5; - if (cached_has_bits & 0x00000008u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_directpath().data(), static_cast(this->_internal_directpath().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.HistorySyncNotification.directPath"); - target = stream->WriteStringMaybeAliased( - 5, this->_internal_directpath(), target); - } - - // optional .proto.Message.HistorySyncNotification.HistorySyncType syncType = 6; - if (cached_has_bits & 0x00000040u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 6, this->_internal_synctype(), target); - } - - // optional uint32 chunkOrder = 7; - if (cached_has_bits & 0x00000080u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(7, this->_internal_chunkorder(), target); - } - - // optional string originalMessageId = 8; - if (cached_has_bits & 0x00000010u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_originalmessageid().data(), static_cast(this->_internal_originalmessageid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.HistorySyncNotification.originalMessageId"); - target = stream->WriteStringMaybeAliased( - 8, this->_internal_originalmessageid(), target); - } - - // optional uint32 progress = 9; - if (cached_has_bits & 0x00000100u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(9, this->_internal_progress(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.HistorySyncNotification) - return target; -} - -size_t Message_HistorySyncNotification::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.HistorySyncNotification) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional bytes fileSha256 = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_filesha256()); - } - - // optional bytes mediaKey = 3; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_mediakey()); - } - - // optional bytes fileEncSha256 = 4; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_fileencsha256()); - } - - // optional string directPath = 5; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_directpath()); - } - - // optional string originalMessageId = 8; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_originalmessageid()); - } - - // optional uint64 fileLength = 2; - if (cached_has_bits & 0x00000020u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_filelength()); - } - - // optional .proto.Message.HistorySyncNotification.HistorySyncType syncType = 6; - if (cached_has_bits & 0x00000040u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_synctype()); - } - - // optional uint32 chunkOrder = 7; - if (cached_has_bits & 0x00000080u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_chunkorder()); - } - - } - // optional uint32 progress = 9; - if (cached_has_bits & 0x00000100u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_progress()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_HistorySyncNotification::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_HistorySyncNotification::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_HistorySyncNotification::GetClassData() const { return &_class_data_; } - - -void Message_HistorySyncNotification::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.HistorySyncNotification) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_filesha256(from._internal_filesha256()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_mediakey(from._internal_mediakey()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_fileencsha256(from._internal_fileencsha256()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_set_directpath(from._internal_directpath()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_set_originalmessageid(from._internal_originalmessageid()); - } - if (cached_has_bits & 0x00000020u) { - _this->_impl_.filelength_ = from._impl_.filelength_; - } - if (cached_has_bits & 0x00000040u) { - _this->_impl_.synctype_ = from._impl_.synctype_; - } - if (cached_has_bits & 0x00000080u) { - _this->_impl_.chunkorder_ = from._impl_.chunkorder_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - if (cached_has_bits & 0x00000100u) { - _this->_internal_set_progress(from._internal_progress()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_HistorySyncNotification::CopyFrom(const Message_HistorySyncNotification& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.HistorySyncNotification) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_HistorySyncNotification::IsInitialized() const { - return true; -} - -void Message_HistorySyncNotification::InternalSwap(Message_HistorySyncNotification* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.filesha256_, lhs_arena, - &other->_impl_.filesha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.mediakey_, lhs_arena, - &other->_impl_.mediakey_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.fileencsha256_, lhs_arena, - &other->_impl_.fileencsha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.directpath_, lhs_arena, - &other->_impl_.directpath_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.originalmessageid_, lhs_arena, - &other->_impl_.originalmessageid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_HistorySyncNotification, _impl_.progress_) - + sizeof(Message_HistorySyncNotification::_impl_.progress_) - - PROTOBUF_FIELD_OFFSET(Message_HistorySyncNotification, _impl_.filelength_)>( - reinterpret_cast(&_impl_.filelength_), - reinterpret_cast(&other->_impl_.filelength_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_HistorySyncNotification::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[83]); -} - -// =================================================================== - -class Message_ImageMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_url(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_mimetype(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_caption(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_filesha256(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_filelength(HasBits* has_bits) { - (*has_bits)[0] |= 131072u; - } - static void set_has_height(HasBits* has_bits) { - (*has_bits)[0] |= 262144u; - } - static void set_has_width(HasBits* has_bits) { - (*has_bits)[0] |= 524288u; - } - static void set_has_mediakey(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_fileencsha256(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static void set_has_directpath(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static void set_has_mediakeytimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 1048576u; - } - static void set_has_jpegthumbnail(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } - static const ::proto::ContextInfo& contextinfo(const Message_ImageMessage* msg); - static void set_has_contextinfo(HasBits* has_bits) { - (*has_bits)[0] |= 65536u; - } - static void set_has_firstscansidecar(HasBits* has_bits) { - (*has_bits)[0] |= 256u; - } - static void set_has_firstscanlength(HasBits* has_bits) { - (*has_bits)[0] |= 2097152u; - } - static void set_has_experimentgroupid(HasBits* has_bits) { - (*has_bits)[0] |= 4194304u; - } - static void set_has_scanssidecar(HasBits* has_bits) { - (*has_bits)[0] |= 512u; - } - static void set_has_midqualityfilesha256(HasBits* has_bits) { - (*has_bits)[0] |= 1024u; - } - static void set_has_midqualityfileencsha256(HasBits* has_bits) { - (*has_bits)[0] |= 2048u; - } - static void set_has_viewonce(HasBits* has_bits) { - (*has_bits)[0] |= 8388608u; - } - static void set_has_thumbnaildirectpath(HasBits* has_bits) { - (*has_bits)[0] |= 4096u; - } - static void set_has_thumbnailsha256(HasBits* has_bits) { - (*has_bits)[0] |= 8192u; - } - static void set_has_thumbnailencsha256(HasBits* has_bits) { - (*has_bits)[0] |= 16384u; - } - static void set_has_staticurl(HasBits* has_bits) { - (*has_bits)[0] |= 32768u; - } -}; - -const ::proto::ContextInfo& -Message_ImageMessage::_Internal::contextinfo(const Message_ImageMessage* msg) { - return *msg->_impl_.contextinfo_; -} -Message_ImageMessage::Message_ImageMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.ImageMessage) -} -Message_ImageMessage::Message_ImageMessage(const Message_ImageMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_ImageMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.interactiveannotations_){from._impl_.interactiveannotations_} - , decltype(_impl_.scanlengths_){from._impl_.scanlengths_} - , decltype(_impl_.url_){} - , decltype(_impl_.mimetype_){} - , decltype(_impl_.caption_){} - , decltype(_impl_.filesha256_){} - , decltype(_impl_.mediakey_){} - , decltype(_impl_.fileencsha256_){} - , decltype(_impl_.directpath_){} - , decltype(_impl_.jpegthumbnail_){} - , decltype(_impl_.firstscansidecar_){} - , decltype(_impl_.scanssidecar_){} - , decltype(_impl_.midqualityfilesha256_){} - , decltype(_impl_.midqualityfileencsha256_){} - , decltype(_impl_.thumbnaildirectpath_){} - , decltype(_impl_.thumbnailsha256_){} - , decltype(_impl_.thumbnailencsha256_){} - , decltype(_impl_.staticurl_){} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.filelength_){} - , decltype(_impl_.height_){} - , decltype(_impl_.width_){} - , decltype(_impl_.mediakeytimestamp_){} - , decltype(_impl_.firstscanlength_){} - , decltype(_impl_.experimentgroupid_){} - , decltype(_impl_.viewonce_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.url_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.url_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_url()) { - _this->_impl_.url_.Set(from._internal_url(), - _this->GetArenaForAllocation()); - } - _impl_.mimetype_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mimetype_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_mimetype()) { - _this->_impl_.mimetype_.Set(from._internal_mimetype(), - _this->GetArenaForAllocation()); - } - _impl_.caption_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.caption_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_caption()) { - _this->_impl_.caption_.Set(from._internal_caption(), - _this->GetArenaForAllocation()); - } - _impl_.filesha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filesha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_filesha256()) { - _this->_impl_.filesha256_.Set(from._internal_filesha256(), - _this->GetArenaForAllocation()); - } - _impl_.mediakey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediakey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_mediakey()) { - _this->_impl_.mediakey_.Set(from._internal_mediakey(), - _this->GetArenaForAllocation()); - } - _impl_.fileencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_fileencsha256()) { - _this->_impl_.fileencsha256_.Set(from._internal_fileencsha256(), - _this->GetArenaForAllocation()); - } - _impl_.directpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_directpath()) { - _this->_impl_.directpath_.Set(from._internal_directpath(), - _this->GetArenaForAllocation()); - } - _impl_.jpegthumbnail_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_jpegthumbnail()) { - _this->_impl_.jpegthumbnail_.Set(from._internal_jpegthumbnail(), - _this->GetArenaForAllocation()); - } - _impl_.firstscansidecar_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.firstscansidecar_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_firstscansidecar()) { - _this->_impl_.firstscansidecar_.Set(from._internal_firstscansidecar(), - _this->GetArenaForAllocation()); - } - _impl_.scanssidecar_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.scanssidecar_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_scanssidecar()) { - _this->_impl_.scanssidecar_.Set(from._internal_scanssidecar(), - _this->GetArenaForAllocation()); - } - _impl_.midqualityfilesha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.midqualityfilesha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_midqualityfilesha256()) { - _this->_impl_.midqualityfilesha256_.Set(from._internal_midqualityfilesha256(), - _this->GetArenaForAllocation()); - } - _impl_.midqualityfileencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.midqualityfileencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_midqualityfileencsha256()) { - _this->_impl_.midqualityfileencsha256_.Set(from._internal_midqualityfileencsha256(), - _this->GetArenaForAllocation()); - } - _impl_.thumbnaildirectpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_thumbnaildirectpath()) { - _this->_impl_.thumbnaildirectpath_.Set(from._internal_thumbnaildirectpath(), - _this->GetArenaForAllocation()); - } - _impl_.thumbnailsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_thumbnailsha256()) { - _this->_impl_.thumbnailsha256_.Set(from._internal_thumbnailsha256(), - _this->GetArenaForAllocation()); - } - _impl_.thumbnailencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_thumbnailencsha256()) { - _this->_impl_.thumbnailencsha256_.Set(from._internal_thumbnailencsha256(), - _this->GetArenaForAllocation()); - } - _impl_.staticurl_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.staticurl_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_staticurl()) { - _this->_impl_.staticurl_.Set(from._internal_staticurl(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_contextinfo()) { - _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); - } - ::memcpy(&_impl_.filelength_, &from._impl_.filelength_, - static_cast(reinterpret_cast(&_impl_.viewonce_) - - reinterpret_cast(&_impl_.filelength_)) + sizeof(_impl_.viewonce_)); - // @@protoc_insertion_point(copy_constructor:proto.Message.ImageMessage) -} - -inline void Message_ImageMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.interactiveannotations_){arena} - , decltype(_impl_.scanlengths_){arena} - , decltype(_impl_.url_){} - , decltype(_impl_.mimetype_){} - , decltype(_impl_.caption_){} - , decltype(_impl_.filesha256_){} - , decltype(_impl_.mediakey_){} - , decltype(_impl_.fileencsha256_){} - , decltype(_impl_.directpath_){} - , decltype(_impl_.jpegthumbnail_){} - , decltype(_impl_.firstscansidecar_){} - , decltype(_impl_.scanssidecar_){} - , decltype(_impl_.midqualityfilesha256_){} - , decltype(_impl_.midqualityfileencsha256_){} - , decltype(_impl_.thumbnaildirectpath_){} - , decltype(_impl_.thumbnailsha256_){} - , decltype(_impl_.thumbnailencsha256_){} - , decltype(_impl_.staticurl_){} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.filelength_){uint64_t{0u}} - , decltype(_impl_.height_){0u} - , decltype(_impl_.width_){0u} - , decltype(_impl_.mediakeytimestamp_){int64_t{0}} - , decltype(_impl_.firstscanlength_){0u} - , decltype(_impl_.experimentgroupid_){0u} - , decltype(_impl_.viewonce_){false} - }; - _impl_.url_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.url_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mimetype_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mimetype_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.caption_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.caption_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filesha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filesha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediakey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediakey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fileencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.jpegthumbnail_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.firstscansidecar_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.firstscansidecar_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.scanssidecar_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.scanssidecar_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.midqualityfilesha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.midqualityfilesha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.midqualityfileencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.midqualityfileencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnaildirectpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnailsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnailencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.staticurl_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.staticurl_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_ImageMessage::~Message_ImageMessage() { - // @@protoc_insertion_point(destructor:proto.Message.ImageMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_ImageMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.interactiveannotations_.~RepeatedPtrField(); - _impl_.scanlengths_.~RepeatedField(); - _impl_.url_.Destroy(); - _impl_.mimetype_.Destroy(); - _impl_.caption_.Destroy(); - _impl_.filesha256_.Destroy(); - _impl_.mediakey_.Destroy(); - _impl_.fileencsha256_.Destroy(); - _impl_.directpath_.Destroy(); - _impl_.jpegthumbnail_.Destroy(); - _impl_.firstscansidecar_.Destroy(); - _impl_.scanssidecar_.Destroy(); - _impl_.midqualityfilesha256_.Destroy(); - _impl_.midqualityfileencsha256_.Destroy(); - _impl_.thumbnaildirectpath_.Destroy(); - _impl_.thumbnailsha256_.Destroy(); - _impl_.thumbnailencsha256_.Destroy(); - _impl_.staticurl_.Destroy(); - if (this != internal_default_instance()) delete _impl_.contextinfo_; -} - -void Message_ImageMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_ImageMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.ImageMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.interactiveannotations_.Clear(); - _impl_.scanlengths_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _impl_.url_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.mimetype_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.caption_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000008u) { - _impl_.filesha256_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000010u) { - _impl_.mediakey_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000020u) { - _impl_.fileencsha256_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000040u) { - _impl_.directpath_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000080u) { - _impl_.jpegthumbnail_.ClearNonDefaultToEmpty(); - } - } - if (cached_has_bits & 0x0000ff00u) { - if (cached_has_bits & 0x00000100u) { - _impl_.firstscansidecar_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000200u) { - _impl_.scanssidecar_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000400u) { - _impl_.midqualityfilesha256_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000800u) { - _impl_.midqualityfileencsha256_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00001000u) { - _impl_.thumbnaildirectpath_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00002000u) { - _impl_.thumbnailsha256_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00004000u) { - _impl_.thumbnailencsha256_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00008000u) { - _impl_.staticurl_.ClearNonDefaultToEmpty(); - } - } - if (cached_has_bits & 0x00010000u) { - GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); - _impl_.contextinfo_->Clear(); - } - if (cached_has_bits & 0x00fe0000u) { - ::memset(&_impl_.filelength_, 0, static_cast( - reinterpret_cast(&_impl_.viewonce_) - - reinterpret_cast(&_impl_.filelength_)) + sizeof(_impl_.viewonce_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_ImageMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string url = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_url(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ImageMessage.url"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string mimetype = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_mimetype(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ImageMessage.mimetype"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string caption = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_caption(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ImageMessage.caption"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bytes fileSha256 = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - auto str = _internal_mutable_filesha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint64 fileLength = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { - _Internal::set_has_filelength(&has_bits); - _impl_.filelength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 height = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { - _Internal::set_has_height(&has_bits); - _impl_.height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 width = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { - _Internal::set_has_width(&has_bits); - _impl_.width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes mediaKey = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { - auto str = _internal_mutable_mediakey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes fileEncSha256 = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { - auto str = _internal_mutable_fileencsha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated .proto.InteractiveAnnotation interactiveAnnotations = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_interactiveannotations(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<82>(ptr)); - } else - goto handle_unusual; - continue; - // optional string directPath = 11; - case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { - auto str = _internal_mutable_directpath(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ImageMessage.directPath"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional int64 mediaKeyTimestamp = 12; - case 12: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { - _Internal::set_has_mediakeytimestamp(&has_bits); - _impl_.mediakeytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes jpegThumbnail = 16; - case 16: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { - auto str = _internal_mutable_jpegthumbnail(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.ContextInfo contextInfo = 17; - case 17: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { - ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes firstScanSidecar = 18; - case 18: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { - auto str = _internal_mutable_firstscansidecar(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 firstScanLength = 19; - case 19: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 152)) { - _Internal::set_has_firstscanlength(&has_bits); - _impl_.firstscanlength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 experimentGroupId = 20; - case 20: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 160)) { - _Internal::set_has_experimentgroupid(&has_bits); - _impl_.experimentgroupid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes scansSidecar = 21; - case 21: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { - auto str = _internal_mutable_scanssidecar(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated uint32 scanLengths = 22; - case 22: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 176)) { - ptr -= 2; - do { - ptr += 2; - _internal_add_scanlengths(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<176>(ptr)); - } else if (static_cast(tag) == 178) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_scanlengths(), ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes midQualityFileSha256 = 23; - case 23: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { - auto str = _internal_mutable_midqualityfilesha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes midQualityFileEncSha256 = 24; - case 24: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 194)) { - auto str = _internal_mutable_midqualityfileencsha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool viewOnce = 25; - case 25: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 200)) { - _Internal::set_has_viewonce(&has_bits); - _impl_.viewonce_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string thumbnailDirectPath = 26; - case 26: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 210)) { - auto str = _internal_mutable_thumbnaildirectpath(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ImageMessage.thumbnailDirectPath"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bytes thumbnailSha256 = 27; - case 27: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 218)) { - auto str = _internal_mutable_thumbnailsha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes thumbnailEncSha256 = 28; - case 28: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 226)) { - auto str = _internal_mutable_thumbnailencsha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string staticUrl = 29; - case 29: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 234)) { - auto str = _internal_mutable_staticurl(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ImageMessage.staticUrl"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_ImageMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ImageMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string url = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_url().data(), static_cast(this->_internal_url().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ImageMessage.url"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_url(), target); - } - - // optional string mimetype = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_mimetype().data(), static_cast(this->_internal_mimetype().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ImageMessage.mimetype"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_mimetype(), target); - } - - // optional string caption = 3; - if (cached_has_bits & 0x00000004u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_caption().data(), static_cast(this->_internal_caption().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ImageMessage.caption"); - target = stream->WriteStringMaybeAliased( - 3, this->_internal_caption(), target); - } - - // optional bytes fileSha256 = 4; - if (cached_has_bits & 0x00000008u) { - target = stream->WriteBytesMaybeAliased( - 4, this->_internal_filesha256(), target); - } - - // optional uint64 fileLength = 5; - if (cached_has_bits & 0x00020000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_filelength(), target); - } - - // optional uint32 height = 6; - if (cached_has_bits & 0x00040000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_height(), target); - } - - // optional uint32 width = 7; - if (cached_has_bits & 0x00080000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(7, this->_internal_width(), target); - } - - // optional bytes mediaKey = 8; - if (cached_has_bits & 0x00000010u) { - target = stream->WriteBytesMaybeAliased( - 8, this->_internal_mediakey(), target); - } - - // optional bytes fileEncSha256 = 9; - if (cached_has_bits & 0x00000020u) { - target = stream->WriteBytesMaybeAliased( - 9, this->_internal_fileencsha256(), target); - } - - // repeated .proto.InteractiveAnnotation interactiveAnnotations = 10; - for (unsigned i = 0, - n = static_cast(this->_internal_interactiveannotations_size()); i < n; i++) { - const auto& repfield = this->_internal_interactiveannotations(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(10, repfield, repfield.GetCachedSize(), target, stream); - } - - // optional string directPath = 11; - if (cached_has_bits & 0x00000040u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_directpath().data(), static_cast(this->_internal_directpath().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ImageMessage.directPath"); - target = stream->WriteStringMaybeAliased( - 11, this->_internal_directpath(), target); - } - - // optional int64 mediaKeyTimestamp = 12; - if (cached_has_bits & 0x00100000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(12, this->_internal_mediakeytimestamp(), target); - } - - // optional bytes jpegThumbnail = 16; - if (cached_has_bits & 0x00000080u) { - target = stream->WriteBytesMaybeAliased( - 16, this->_internal_jpegthumbnail(), target); - } - - // optional .proto.ContextInfo contextInfo = 17; - if (cached_has_bits & 0x00010000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(17, _Internal::contextinfo(this), - _Internal::contextinfo(this).GetCachedSize(), target, stream); - } - - // optional bytes firstScanSidecar = 18; - if (cached_has_bits & 0x00000100u) { - target = stream->WriteBytesMaybeAliased( - 18, this->_internal_firstscansidecar(), target); - } - - // optional uint32 firstScanLength = 19; - if (cached_has_bits & 0x00200000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(19, this->_internal_firstscanlength(), target); - } - - // optional uint32 experimentGroupId = 20; - if (cached_has_bits & 0x00400000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(20, this->_internal_experimentgroupid(), target); - } - - // optional bytes scansSidecar = 21; - if (cached_has_bits & 0x00000200u) { - target = stream->WriteBytesMaybeAliased( - 21, this->_internal_scanssidecar(), target); - } - - // repeated uint32 scanLengths = 22; - for (int i = 0, n = this->_internal_scanlengths_size(); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(22, this->_internal_scanlengths(i), target); - } - - // optional bytes midQualityFileSha256 = 23; - if (cached_has_bits & 0x00000400u) { - target = stream->WriteBytesMaybeAliased( - 23, this->_internal_midqualityfilesha256(), target); - } - - // optional bytes midQualityFileEncSha256 = 24; - if (cached_has_bits & 0x00000800u) { - target = stream->WriteBytesMaybeAliased( - 24, this->_internal_midqualityfileencsha256(), target); - } - - // optional bool viewOnce = 25; - if (cached_has_bits & 0x00800000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(25, this->_internal_viewonce(), target); - } - - // optional string thumbnailDirectPath = 26; - if (cached_has_bits & 0x00001000u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_thumbnaildirectpath().data(), static_cast(this->_internal_thumbnaildirectpath().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ImageMessage.thumbnailDirectPath"); - target = stream->WriteStringMaybeAliased( - 26, this->_internal_thumbnaildirectpath(), target); - } - - // optional bytes thumbnailSha256 = 27; - if (cached_has_bits & 0x00002000u) { - target = stream->WriteBytesMaybeAliased( - 27, this->_internal_thumbnailsha256(), target); - } - - // optional bytes thumbnailEncSha256 = 28; - if (cached_has_bits & 0x00004000u) { - target = stream->WriteBytesMaybeAliased( - 28, this->_internal_thumbnailencsha256(), target); - } - - // optional string staticUrl = 29; - if (cached_has_bits & 0x00008000u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_staticurl().data(), static_cast(this->_internal_staticurl().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ImageMessage.staticUrl"); - target = stream->WriteStringMaybeAliased( - 29, this->_internal_staticurl(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ImageMessage) - return target; -} - -size_t Message_ImageMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.ImageMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.InteractiveAnnotation interactiveAnnotations = 10; - total_size += 1UL * this->_internal_interactiveannotations_size(); - for (const auto& msg : this->_impl_.interactiveannotations_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // repeated uint32 scanLengths = 22; - { - size_t data_size = ::_pbi::WireFormatLite:: - UInt32Size(this->_impl_.scanlengths_); - total_size += 2 * - ::_pbi::FromIntSize(this->_internal_scanlengths_size()); - total_size += data_size; - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional string url = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_url()); - } - - // optional string mimetype = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_mimetype()); - } - - // optional string caption = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_caption()); - } - - // optional bytes fileSha256 = 4; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_filesha256()); - } - - // optional bytes mediaKey = 8; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_mediakey()); - } - - // optional bytes fileEncSha256 = 9; - if (cached_has_bits & 0x00000020u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_fileencsha256()); - } - - // optional string directPath = 11; - if (cached_has_bits & 0x00000040u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_directpath()); - } - - // optional bytes jpegThumbnail = 16; - if (cached_has_bits & 0x00000080u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_jpegthumbnail()); - } - - } - if (cached_has_bits & 0x0000ff00u) { - // optional bytes firstScanSidecar = 18; - if (cached_has_bits & 0x00000100u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_firstscansidecar()); - } - - // optional bytes scansSidecar = 21; - if (cached_has_bits & 0x00000200u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_scanssidecar()); - } - - // optional bytes midQualityFileSha256 = 23; - if (cached_has_bits & 0x00000400u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_midqualityfilesha256()); - } - - // optional bytes midQualityFileEncSha256 = 24; - if (cached_has_bits & 0x00000800u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_midqualityfileencsha256()); - } - - // optional string thumbnailDirectPath = 26; - if (cached_has_bits & 0x00001000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_thumbnaildirectpath()); - } - - // optional bytes thumbnailSha256 = 27; - if (cached_has_bits & 0x00002000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_thumbnailsha256()); - } - - // optional bytes thumbnailEncSha256 = 28; - if (cached_has_bits & 0x00004000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_thumbnailencsha256()); - } - - // optional string staticUrl = 29; - if (cached_has_bits & 0x00008000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_staticurl()); - } - - } - if (cached_has_bits & 0x00ff0000u) { - // optional .proto.ContextInfo contextInfo = 17; - if (cached_has_bits & 0x00010000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.contextinfo_); - } - - // optional uint64 fileLength = 5; - if (cached_has_bits & 0x00020000u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_filelength()); - } - - // optional uint32 height = 6; - if (cached_has_bits & 0x00040000u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_height()); - } - - // optional uint32 width = 7; - if (cached_has_bits & 0x00080000u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_width()); - } - - // optional int64 mediaKeyTimestamp = 12; - if (cached_has_bits & 0x00100000u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_mediakeytimestamp()); - } - - // optional uint32 firstScanLength = 19; - if (cached_has_bits & 0x00200000u) { - total_size += 2 + - ::_pbi::WireFormatLite::UInt32Size( - this->_internal_firstscanlength()); - } - - // optional uint32 experimentGroupId = 20; - if (cached_has_bits & 0x00400000u) { - total_size += 2 + - ::_pbi::WireFormatLite::UInt32Size( - this->_internal_experimentgroupid()); - } - - // optional bool viewOnce = 25; - if (cached_has_bits & 0x00800000u) { - total_size += 2 + 1; - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ImageMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_ImageMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ImageMessage::GetClassData() const { return &_class_data_; } - - -void Message_ImageMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ImageMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.interactiveannotations_.MergeFrom(from._impl_.interactiveannotations_); - _this->_impl_.scanlengths_.MergeFrom(from._impl_.scanlengths_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_url(from._internal_url()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_mimetype(from._internal_mimetype()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_caption(from._internal_caption()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_set_filesha256(from._internal_filesha256()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_set_mediakey(from._internal_mediakey()); - } - if (cached_has_bits & 0x00000020u) { - _this->_internal_set_fileencsha256(from._internal_fileencsha256()); - } - if (cached_has_bits & 0x00000040u) { - _this->_internal_set_directpath(from._internal_directpath()); - } - if (cached_has_bits & 0x00000080u) { - _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail()); - } - } - if (cached_has_bits & 0x0000ff00u) { - if (cached_has_bits & 0x00000100u) { - _this->_internal_set_firstscansidecar(from._internal_firstscansidecar()); - } - if (cached_has_bits & 0x00000200u) { - _this->_internal_set_scanssidecar(from._internal_scanssidecar()); - } - if (cached_has_bits & 0x00000400u) { - _this->_internal_set_midqualityfilesha256(from._internal_midqualityfilesha256()); - } - if (cached_has_bits & 0x00000800u) { - _this->_internal_set_midqualityfileencsha256(from._internal_midqualityfileencsha256()); - } - if (cached_has_bits & 0x00001000u) { - _this->_internal_set_thumbnaildirectpath(from._internal_thumbnaildirectpath()); - } - if (cached_has_bits & 0x00002000u) { - _this->_internal_set_thumbnailsha256(from._internal_thumbnailsha256()); - } - if (cached_has_bits & 0x00004000u) { - _this->_internal_set_thumbnailencsha256(from._internal_thumbnailencsha256()); - } - if (cached_has_bits & 0x00008000u) { - _this->_internal_set_staticurl(from._internal_staticurl()); - } - } - if (cached_has_bits & 0x00ff0000u) { - if (cached_has_bits & 0x00010000u) { - _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( - from._internal_contextinfo()); - } - if (cached_has_bits & 0x00020000u) { - _this->_impl_.filelength_ = from._impl_.filelength_; - } - if (cached_has_bits & 0x00040000u) { - _this->_impl_.height_ = from._impl_.height_; - } - if (cached_has_bits & 0x00080000u) { - _this->_impl_.width_ = from._impl_.width_; - } - if (cached_has_bits & 0x00100000u) { - _this->_impl_.mediakeytimestamp_ = from._impl_.mediakeytimestamp_; - } - if (cached_has_bits & 0x00200000u) { - _this->_impl_.firstscanlength_ = from._impl_.firstscanlength_; - } - if (cached_has_bits & 0x00400000u) { - _this->_impl_.experimentgroupid_ = from._impl_.experimentgroupid_; - } - if (cached_has_bits & 0x00800000u) { - _this->_impl_.viewonce_ = from._impl_.viewonce_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_ImageMessage::CopyFrom(const Message_ImageMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ImageMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_ImageMessage::IsInitialized() const { - return true; -} - -void Message_ImageMessage::InternalSwap(Message_ImageMessage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.interactiveannotations_.InternalSwap(&other->_impl_.interactiveannotations_); - _impl_.scanlengths_.InternalSwap(&other->_impl_.scanlengths_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.url_, lhs_arena, - &other->_impl_.url_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.mimetype_, lhs_arena, - &other->_impl_.mimetype_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.caption_, lhs_arena, - &other->_impl_.caption_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.filesha256_, lhs_arena, - &other->_impl_.filesha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.mediakey_, lhs_arena, - &other->_impl_.mediakey_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.fileencsha256_, lhs_arena, - &other->_impl_.fileencsha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.directpath_, lhs_arena, - &other->_impl_.directpath_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.jpegthumbnail_, lhs_arena, - &other->_impl_.jpegthumbnail_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.firstscansidecar_, lhs_arena, - &other->_impl_.firstscansidecar_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.scanssidecar_, lhs_arena, - &other->_impl_.scanssidecar_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.midqualityfilesha256_, lhs_arena, - &other->_impl_.midqualityfilesha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.midqualityfileencsha256_, lhs_arena, - &other->_impl_.midqualityfileencsha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.thumbnaildirectpath_, lhs_arena, - &other->_impl_.thumbnaildirectpath_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.thumbnailsha256_, lhs_arena, - &other->_impl_.thumbnailsha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.thumbnailencsha256_, lhs_arena, - &other->_impl_.thumbnailencsha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.staticurl_, lhs_arena, - &other->_impl_.staticurl_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_ImageMessage, _impl_.viewonce_) - + sizeof(Message_ImageMessage::_impl_.viewonce_) - - PROTOBUF_FIELD_OFFSET(Message_ImageMessage, _impl_.contextinfo_)>( - reinterpret_cast(&_impl_.contextinfo_), - reinterpret_cast(&other->_impl_.contextinfo_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_ImageMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[84]); -} - -// =================================================================== - -class Message_InitialSecurityNotificationSettingSync::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_securitynotificationenabled(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -Message_InitialSecurityNotificationSettingSync::Message_InitialSecurityNotificationSettingSync(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.InitialSecurityNotificationSettingSync) -} -Message_InitialSecurityNotificationSettingSync::Message_InitialSecurityNotificationSettingSync(const Message_InitialSecurityNotificationSettingSync& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_InitialSecurityNotificationSettingSync* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.securitynotificationenabled_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _this->_impl_.securitynotificationenabled_ = from._impl_.securitynotificationenabled_; - // @@protoc_insertion_point(copy_constructor:proto.Message.InitialSecurityNotificationSettingSync) -} - -inline void Message_InitialSecurityNotificationSettingSync::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.securitynotificationenabled_){false} - }; -} - -Message_InitialSecurityNotificationSettingSync::~Message_InitialSecurityNotificationSettingSync() { - // @@protoc_insertion_point(destructor:proto.Message.InitialSecurityNotificationSettingSync) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_InitialSecurityNotificationSettingSync::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Message_InitialSecurityNotificationSettingSync::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_InitialSecurityNotificationSettingSync::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.InitialSecurityNotificationSettingSync) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.securitynotificationenabled_ = false; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_InitialSecurityNotificationSettingSync::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bool securityNotificationEnabled = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_securitynotificationenabled(&has_bits); - _impl_.securitynotificationenabled_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_InitialSecurityNotificationSettingSync::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InitialSecurityNotificationSettingSync) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bool securityNotificationEnabled = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_securitynotificationenabled(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.InitialSecurityNotificationSettingSync) - return target; -} - -size_t Message_InitialSecurityNotificationSettingSync::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.InitialSecurityNotificationSettingSync) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional bool securityNotificationEnabled = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + 1; - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InitialSecurityNotificationSettingSync::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_InitialSecurityNotificationSettingSync::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InitialSecurityNotificationSettingSync::GetClassData() const { return &_class_data_; } - - -void Message_InitialSecurityNotificationSettingSync::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InitialSecurityNotificationSettingSync) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_securitynotificationenabled()) { - _this->_internal_set_securitynotificationenabled(from._internal_securitynotificationenabled()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_InitialSecurityNotificationSettingSync::CopyFrom(const Message_InitialSecurityNotificationSettingSync& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InitialSecurityNotificationSettingSync) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_InitialSecurityNotificationSettingSync::IsInitialized() const { - return true; -} - -void Message_InitialSecurityNotificationSettingSync::InternalSwap(Message_InitialSecurityNotificationSettingSync* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - swap(_impl_.securitynotificationenabled_, other->_impl_.securitynotificationenabled_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_InitialSecurityNotificationSettingSync::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[85]); -} - -// =================================================================== - -class Message_InteractiveMessage_Body::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_text(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -Message_InteractiveMessage_Body::Message_InteractiveMessage_Body(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveMessage.Body) -} -Message_InteractiveMessage_Body::Message_InteractiveMessage_Body(const Message_InteractiveMessage_Body& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_InteractiveMessage_Body* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.text_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.text_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.text_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_text()) { - _this->_impl_.text_.Set(from._internal_text(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveMessage.Body) -} - -inline void Message_InteractiveMessage_Body::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.text_){} - }; - _impl_.text_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.text_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_InteractiveMessage_Body::~Message_InteractiveMessage_Body() { - // @@protoc_insertion_point(destructor:proto.Message.InteractiveMessage.Body) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_InteractiveMessage_Body::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.text_.Destroy(); -} - -void Message_InteractiveMessage_Body::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_InteractiveMessage_Body::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveMessage.Body) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.text_.ClearNonDefaultToEmpty(); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_InteractiveMessage_Body::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string text = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_text(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveMessage.Body.text"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_InteractiveMessage_Body::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveMessage.Body) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string text = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_text().data(), static_cast(this->_internal_text().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.InteractiveMessage.Body.text"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_text(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.InteractiveMessage.Body) - return target; -} - -size_t Message_InteractiveMessage_Body::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveMessage.Body) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional string text = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_text()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveMessage_Body::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_InteractiveMessage_Body::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveMessage_Body::GetClassData() const { return &_class_data_; } - - -void Message_InteractiveMessage_Body::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveMessage.Body) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_text()) { - _this->_internal_set_text(from._internal_text()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_InteractiveMessage_Body::CopyFrom(const Message_InteractiveMessage_Body& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveMessage.Body) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_InteractiveMessage_Body::IsInitialized() const { - return true; -} - -void Message_InteractiveMessage_Body::InternalSwap(Message_InteractiveMessage_Body* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.text_, lhs_arena, - &other->_impl_.text_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveMessage_Body::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[86]); -} - -// =================================================================== - -class Message_InteractiveMessage_CollectionMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_bizjid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_id(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_messageversion(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } -}; - -Message_InteractiveMessage_CollectionMessage::Message_InteractiveMessage_CollectionMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveMessage.CollectionMessage) -} -Message_InteractiveMessage_CollectionMessage::Message_InteractiveMessage_CollectionMessage(const Message_InteractiveMessage_CollectionMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_InteractiveMessage_CollectionMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.bizjid_){} - , decltype(_impl_.id_){} - , decltype(_impl_.messageversion_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.bizjid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.bizjid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_bizjid()) { - _this->_impl_.bizjid_.Set(from._internal_bizjid(), - _this->GetArenaForAllocation()); - } - _impl_.id_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.id_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_id()) { - _this->_impl_.id_.Set(from._internal_id(), - _this->GetArenaForAllocation()); - } - _this->_impl_.messageversion_ = from._impl_.messageversion_; - // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveMessage.CollectionMessage) -} - -inline void Message_InteractiveMessage_CollectionMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.bizjid_){} - , decltype(_impl_.id_){} - , decltype(_impl_.messageversion_){0} - }; - _impl_.bizjid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.bizjid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.id_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.id_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_InteractiveMessage_CollectionMessage::~Message_InteractiveMessage_CollectionMessage() { - // @@protoc_insertion_point(destructor:proto.Message.InteractiveMessage.CollectionMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_InteractiveMessage_CollectionMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.bizjid_.Destroy(); - _impl_.id_.Destroy(); -} - -void Message_InteractiveMessage_CollectionMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_InteractiveMessage_CollectionMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveMessage.CollectionMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.bizjid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.id_.ClearNonDefaultToEmpty(); - } - } - _impl_.messageversion_ = 0; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_InteractiveMessage_CollectionMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string bizJid = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_bizjid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveMessage.CollectionMessage.bizJid"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string id = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_id(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveMessage.CollectionMessage.id"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional int32 messageVersion = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_messageversion(&has_bits); - _impl_.messageversion_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_InteractiveMessage_CollectionMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveMessage.CollectionMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string bizJid = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_bizjid().data(), static_cast(this->_internal_bizjid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.InteractiveMessage.CollectionMessage.bizJid"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_bizjid(), target); - } - - // optional string id = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_id().data(), static_cast(this->_internal_id().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.InteractiveMessage.CollectionMessage.id"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_id(), target); - } - - // optional int32 messageVersion = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_messageversion(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.InteractiveMessage.CollectionMessage) - return target; -} - -size_t Message_InteractiveMessage_CollectionMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveMessage.CollectionMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional string bizJid = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_bizjid()); - } - - // optional string id = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_id()); - } - - // optional int32 messageVersion = 3; - if (cached_has_bits & 0x00000004u) { - total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_messageversion()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveMessage_CollectionMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_InteractiveMessage_CollectionMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveMessage_CollectionMessage::GetClassData() const { return &_class_data_; } - - -void Message_InteractiveMessage_CollectionMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveMessage.CollectionMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_bizjid(from._internal_bizjid()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_id(from._internal_id()); - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.messageversion_ = from._impl_.messageversion_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_InteractiveMessage_CollectionMessage::CopyFrom(const Message_InteractiveMessage_CollectionMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveMessage.CollectionMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_InteractiveMessage_CollectionMessage::IsInitialized() const { - return true; -} - -void Message_InteractiveMessage_CollectionMessage::InternalSwap(Message_InteractiveMessage_CollectionMessage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.bizjid_, lhs_arena, - &other->_impl_.bizjid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.id_, lhs_arena, - &other->_impl_.id_, rhs_arena - ); - swap(_impl_.messageversion_, other->_impl_.messageversion_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveMessage_CollectionMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[87]); -} - -// =================================================================== - -class Message_InteractiveMessage_Footer::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_text(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -Message_InteractiveMessage_Footer::Message_InteractiveMessage_Footer(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveMessage.Footer) -} -Message_InteractiveMessage_Footer::Message_InteractiveMessage_Footer(const Message_InteractiveMessage_Footer& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_InteractiveMessage_Footer* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.text_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.text_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.text_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_text()) { - _this->_impl_.text_.Set(from._internal_text(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveMessage.Footer) -} - -inline void Message_InteractiveMessage_Footer::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.text_){} - }; - _impl_.text_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.text_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_InteractiveMessage_Footer::~Message_InteractiveMessage_Footer() { - // @@protoc_insertion_point(destructor:proto.Message.InteractiveMessage.Footer) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_InteractiveMessage_Footer::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.text_.Destroy(); -} - -void Message_InteractiveMessage_Footer::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_InteractiveMessage_Footer::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveMessage.Footer) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.text_.ClearNonDefaultToEmpty(); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_InteractiveMessage_Footer::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string text = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_text(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveMessage.Footer.text"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_InteractiveMessage_Footer::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveMessage.Footer) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string text = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_text().data(), static_cast(this->_internal_text().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.InteractiveMessage.Footer.text"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_text(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.InteractiveMessage.Footer) - return target; -} - -size_t Message_InteractiveMessage_Footer::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveMessage.Footer) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional string text = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_text()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveMessage_Footer::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_InteractiveMessage_Footer::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveMessage_Footer::GetClassData() const { return &_class_data_; } - - -void Message_InteractiveMessage_Footer::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveMessage.Footer) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_text()) { - _this->_internal_set_text(from._internal_text()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_InteractiveMessage_Footer::CopyFrom(const Message_InteractiveMessage_Footer& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveMessage.Footer) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_InteractiveMessage_Footer::IsInitialized() const { - return true; -} - -void Message_InteractiveMessage_Footer::InternalSwap(Message_InteractiveMessage_Footer* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.text_, lhs_arena, - &other->_impl_.text_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveMessage_Footer::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[88]); -} - -// =================================================================== - -class Message_InteractiveMessage_Header::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_title(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_subtitle(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_hasmediaattachment(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static const ::proto::Message_DocumentMessage& documentmessage(const Message_InteractiveMessage_Header* msg); - static const ::proto::Message_ImageMessage& imagemessage(const Message_InteractiveMessage_Header* msg); - static const ::proto::Message_VideoMessage& videomessage(const Message_InteractiveMessage_Header* msg); -}; - -const ::proto::Message_DocumentMessage& -Message_InteractiveMessage_Header::_Internal::documentmessage(const Message_InteractiveMessage_Header* msg) { - return *msg->_impl_.media_.documentmessage_; -} -const ::proto::Message_ImageMessage& -Message_InteractiveMessage_Header::_Internal::imagemessage(const Message_InteractiveMessage_Header* msg) { - return *msg->_impl_.media_.imagemessage_; -} -const ::proto::Message_VideoMessage& -Message_InteractiveMessage_Header::_Internal::videomessage(const Message_InteractiveMessage_Header* msg) { - return *msg->_impl_.media_.videomessage_; -} -void Message_InteractiveMessage_Header::set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_media(); - if (documentmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(documentmessage); - if (message_arena != submessage_arena) { - documentmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, documentmessage, submessage_arena); - } - set_has_documentmessage(); - _impl_.media_.documentmessage_ = documentmessage; - } - // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.Header.documentMessage) -} -void Message_InteractiveMessage_Header::set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_media(); - if (imagemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(imagemessage); - if (message_arena != submessage_arena) { - imagemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, imagemessage, submessage_arena); - } - set_has_imagemessage(); - _impl_.media_.imagemessage_ = imagemessage; - } - // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.Header.imageMessage) -} -void Message_InteractiveMessage_Header::set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_media(); - if (videomessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(videomessage); - if (message_arena != submessage_arena) { - videomessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, videomessage, submessage_arena); - } - set_has_videomessage(); - _impl_.media_.videomessage_ = videomessage; - } - // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.Header.videoMessage) -} -Message_InteractiveMessage_Header::Message_InteractiveMessage_Header(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveMessage.Header) -} -Message_InteractiveMessage_Header::Message_InteractiveMessage_Header(const Message_InteractiveMessage_Header& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_InteractiveMessage_Header* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.title_){} - , decltype(_impl_.subtitle_){} - , decltype(_impl_.hasmediaattachment_){} - , decltype(_impl_.media_){} - , /*decltype(_impl_._oneof_case_)*/{}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.title_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.title_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_title()) { - _this->_impl_.title_.Set(from._internal_title(), - _this->GetArenaForAllocation()); - } - _impl_.subtitle_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.subtitle_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_subtitle()) { - _this->_impl_.subtitle_.Set(from._internal_subtitle(), - _this->GetArenaForAllocation()); - } - _this->_impl_.hasmediaattachment_ = from._impl_.hasmediaattachment_; - clear_has_media(); - switch (from.media_case()) { - case kDocumentMessage: { - _this->_internal_mutable_documentmessage()->::proto::Message_DocumentMessage::MergeFrom( - from._internal_documentmessage()); - break; - } - case kImageMessage: { - _this->_internal_mutable_imagemessage()->::proto::Message_ImageMessage::MergeFrom( - from._internal_imagemessage()); - break; - } - case kJpegThumbnail: { - _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail()); - break; - } - case kVideoMessage: { - _this->_internal_mutable_videomessage()->::proto::Message_VideoMessage::MergeFrom( - from._internal_videomessage()); - break; - } - case MEDIA_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveMessage.Header) -} - -inline void Message_InteractiveMessage_Header::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.title_){} - , decltype(_impl_.subtitle_){} - , decltype(_impl_.hasmediaattachment_){false} - , decltype(_impl_.media_){} - , /*decltype(_impl_._oneof_case_)*/{} - }; - _impl_.title_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.title_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.subtitle_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.subtitle_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - clear_has_media(); -} - -Message_InteractiveMessage_Header::~Message_InteractiveMessage_Header() { - // @@protoc_insertion_point(destructor:proto.Message.InteractiveMessage.Header) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_InteractiveMessage_Header::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.title_.Destroy(); - _impl_.subtitle_.Destroy(); - if (has_media()) { - clear_media(); - } -} - -void Message_InteractiveMessage_Header::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_InteractiveMessage_Header::clear_media() { -// @@protoc_insertion_point(one_of_clear_start:proto.Message.InteractiveMessage.Header) - switch (media_case()) { - case kDocumentMessage: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.media_.documentmessage_; - } - break; - } - case kImageMessage: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.media_.imagemessage_; - } - break; - } - case kJpegThumbnail: { - _impl_.media_.jpegthumbnail_.Destroy(); - break; - } - case kVideoMessage: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.media_.videomessage_; - } - break; - } - case MEDIA_NOT_SET: { - break; - } - } - _impl_._oneof_case_[0] = MEDIA_NOT_SET; -} - - -void Message_InteractiveMessage_Header::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveMessage.Header) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.title_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.subtitle_.ClearNonDefaultToEmpty(); - } - } - _impl_.hasmediaattachment_ = false; - clear_media(); - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_InteractiveMessage_Header::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string title = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_title(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveMessage.Header.title"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string subtitle = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_subtitle(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveMessage.Header.subtitle"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // .proto.Message.DocumentMessage documentMessage = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_documentmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .proto.Message.ImageMessage imageMessage = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_imagemessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool hasMediaAttachment = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { - _Internal::set_has_hasmediaattachment(&has_bits); - _impl_.hasmediaattachment_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // bytes jpegThumbnail = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - auto str = _internal_mutable_jpegthumbnail(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .proto.Message.VideoMessage videoMessage = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - ptr = ctx->ParseMessage(_internal_mutable_videomessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_InteractiveMessage_Header::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveMessage.Header) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string title = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_title().data(), static_cast(this->_internal_title().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.InteractiveMessage.Header.title"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_title(), target); - } - - // optional string subtitle = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_subtitle().data(), static_cast(this->_internal_subtitle().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.InteractiveMessage.Header.subtitle"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_subtitle(), target); - } - - switch (media_case()) { - case kDocumentMessage: { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, _Internal::documentmessage(this), - _Internal::documentmessage(this).GetCachedSize(), target, stream); - break; - } - case kImageMessage: { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(4, _Internal::imagemessage(this), - _Internal::imagemessage(this).GetCachedSize(), target, stream); - break; - } - default: ; - } - // optional bool hasMediaAttachment = 5; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(5, this->_internal_hasmediaattachment(), target); - } - - switch (media_case()) { - case kJpegThumbnail: { - target = stream->WriteBytesMaybeAliased( - 6, this->_internal_jpegthumbnail(), target); - break; - } - case kVideoMessage: { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(7, _Internal::videomessage(this), - _Internal::videomessage(this).GetCachedSize(), target, stream); - break; - } - default: ; - } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.InteractiveMessage.Header) - return target; -} - -size_t Message_InteractiveMessage_Header::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveMessage.Header) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional string title = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_title()); - } - - // optional string subtitle = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_subtitle()); - } - - // optional bool hasMediaAttachment = 5; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + 1; - } - - } - switch (media_case()) { - // .proto.Message.DocumentMessage documentMessage = 3; - case kDocumentMessage: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.media_.documentmessage_); - break; - } - // .proto.Message.ImageMessage imageMessage = 4; - case kImageMessage: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.media_.imagemessage_); - break; - } - // bytes jpegThumbnail = 6; - case kJpegThumbnail: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_jpegthumbnail()); - break; - } - // .proto.Message.VideoMessage videoMessage = 7; - case kVideoMessage: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.media_.videomessage_); - break; - } - case MEDIA_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveMessage_Header::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_InteractiveMessage_Header::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveMessage_Header::GetClassData() const { return &_class_data_; } - - -void Message_InteractiveMessage_Header::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveMessage.Header) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_title(from._internal_title()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_subtitle(from._internal_subtitle()); - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.hasmediaattachment_ = from._impl_.hasmediaattachment_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - switch (from.media_case()) { - case kDocumentMessage: { - _this->_internal_mutable_documentmessage()->::proto::Message_DocumentMessage::MergeFrom( - from._internal_documentmessage()); - break; - } - case kImageMessage: { - _this->_internal_mutable_imagemessage()->::proto::Message_ImageMessage::MergeFrom( - from._internal_imagemessage()); - break; - } - case kJpegThumbnail: { - _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail()); - break; - } - case kVideoMessage: { - _this->_internal_mutable_videomessage()->::proto::Message_VideoMessage::MergeFrom( - from._internal_videomessage()); - break; - } - case MEDIA_NOT_SET: { - break; - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_InteractiveMessage_Header::CopyFrom(const Message_InteractiveMessage_Header& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveMessage.Header) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_InteractiveMessage_Header::IsInitialized() const { - return true; -} - -void Message_InteractiveMessage_Header::InternalSwap(Message_InteractiveMessage_Header* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.title_, lhs_arena, - &other->_impl_.title_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.subtitle_, lhs_arena, - &other->_impl_.subtitle_, rhs_arena - ); - swap(_impl_.hasmediaattachment_, other->_impl_.hasmediaattachment_); - swap(_impl_.media_, other->_impl_.media_); - swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveMessage_Header::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[89]); -} - -// =================================================================== - -class Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_name(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_buttonparamsjson(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton) -} -Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton(const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.name_){} - , decltype(_impl_.buttonparamsjson_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.name_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.name_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_name()) { - _this->_impl_.name_.Set(from._internal_name(), - _this->GetArenaForAllocation()); - } - _impl_.buttonparamsjson_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.buttonparamsjson_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_buttonparamsjson()) { - _this->_impl_.buttonparamsjson_.Set(from._internal_buttonparamsjson(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton) -} - -inline void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.name_){} - , decltype(_impl_.buttonparamsjson_){} - }; - _impl_.name_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.name_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.buttonparamsjson_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.buttonparamsjson_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::~Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton() { - // @@protoc_insertion_point(destructor:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.name_.Destroy(); - _impl_.buttonparamsjson_.Destroy(); -} - -void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.name_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.buttonparamsjson_.ClearNonDefaultToEmpty(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string name = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_name(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.name"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string buttonParamsJson = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_buttonparamsjson(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.buttonParamsJson"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string name = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_name().data(), static_cast(this->_internal_name().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.name"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_name(), target); - } - - // optional string buttonParamsJson = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_buttonparamsjson().data(), static_cast(this->_internal_buttonparamsjson().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.buttonParamsJson"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_buttonparamsjson(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton) - return target; -} - -size_t Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional string name = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_name()); - } - - // optional string buttonParamsJson = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_buttonparamsjson()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::GetClassData() const { return &_class_data_; } - - -void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_name(from._internal_name()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_buttonparamsjson(from._internal_buttonparamsjson()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::CopyFrom(const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::IsInitialized() const { - return true; -} - -void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::InternalSwap(Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.name_, lhs_arena, - &other->_impl_.name_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.buttonparamsjson_, lhs_arena, - &other->_impl_.buttonparamsjson_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[90]); -} - -// =================================================================== - -class Message_InteractiveMessage_NativeFlowMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_messageparamsjson(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_messageversion(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -Message_InteractiveMessage_NativeFlowMessage::Message_InteractiveMessage_NativeFlowMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveMessage.NativeFlowMessage) -} -Message_InteractiveMessage_NativeFlowMessage::Message_InteractiveMessage_NativeFlowMessage(const Message_InteractiveMessage_NativeFlowMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_InteractiveMessage_NativeFlowMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.buttons_){from._impl_.buttons_} - , decltype(_impl_.messageparamsjson_){} - , decltype(_impl_.messageversion_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.messageparamsjson_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.messageparamsjson_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_messageparamsjson()) { - _this->_impl_.messageparamsjson_.Set(from._internal_messageparamsjson(), - _this->GetArenaForAllocation()); - } - _this->_impl_.messageversion_ = from._impl_.messageversion_; - // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveMessage.NativeFlowMessage) -} - -inline void Message_InteractiveMessage_NativeFlowMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.buttons_){arena} - , decltype(_impl_.messageparamsjson_){} - , decltype(_impl_.messageversion_){0} - }; - _impl_.messageparamsjson_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.messageparamsjson_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_InteractiveMessage_NativeFlowMessage::~Message_InteractiveMessage_NativeFlowMessage() { - // @@protoc_insertion_point(destructor:proto.Message.InteractiveMessage.NativeFlowMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_InteractiveMessage_NativeFlowMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.buttons_.~RepeatedPtrField(); - _impl_.messageparamsjson_.Destroy(); -} - -void Message_InteractiveMessage_NativeFlowMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_InteractiveMessage_NativeFlowMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveMessage.NativeFlowMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.buttons_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.messageparamsjson_.ClearNonDefaultToEmpty(); - } - _impl_.messageversion_ = 0; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_InteractiveMessage_NativeFlowMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated .proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton buttons = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_buttons(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else - goto handle_unusual; - continue; - // optional string messageParamsJson = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_messageparamsjson(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveMessage.NativeFlowMessage.messageParamsJson"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional int32 messageVersion = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_messageversion(&has_bits); - _impl_.messageversion_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_InteractiveMessage_NativeFlowMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveMessage.NativeFlowMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton buttons = 1; - for (unsigned i = 0, - n = static_cast(this->_internal_buttons_size()); i < n; i++) { - const auto& repfield = this->_internal_buttons(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream); - } - - cached_has_bits = _impl_._has_bits_[0]; - // optional string messageParamsJson = 2; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_messageparamsjson().data(), static_cast(this->_internal_messageparamsjson().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.InteractiveMessage.NativeFlowMessage.messageParamsJson"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_messageparamsjson(), target); - } - - // optional int32 messageVersion = 3; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_messageversion(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.InteractiveMessage.NativeFlowMessage) - return target; -} - -size_t Message_InteractiveMessage_NativeFlowMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveMessage.NativeFlowMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton buttons = 1; - total_size += 1UL * this->_internal_buttons_size(); - for (const auto& msg : this->_impl_.buttons_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional string messageParamsJson = 2; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_messageparamsjson()); - } - - // optional int32 messageVersion = 3; - if (cached_has_bits & 0x00000002u) { - total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_messageversion()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveMessage_NativeFlowMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_InteractiveMessage_NativeFlowMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveMessage_NativeFlowMessage::GetClassData() const { return &_class_data_; } - - -void Message_InteractiveMessage_NativeFlowMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveMessage.NativeFlowMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.buttons_.MergeFrom(from._impl_.buttons_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_messageparamsjson(from._internal_messageparamsjson()); - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.messageversion_ = from._impl_.messageversion_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_InteractiveMessage_NativeFlowMessage::CopyFrom(const Message_InteractiveMessage_NativeFlowMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveMessage.NativeFlowMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_InteractiveMessage_NativeFlowMessage::IsInitialized() const { - return true; -} - -void Message_InteractiveMessage_NativeFlowMessage::InternalSwap(Message_InteractiveMessage_NativeFlowMessage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.buttons_.InternalSwap(&other->_impl_.buttons_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.messageparamsjson_, lhs_arena, - &other->_impl_.messageparamsjson_, rhs_arena - ); - swap(_impl_.messageversion_, other->_impl_.messageversion_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveMessage_NativeFlowMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[91]); -} - -// =================================================================== - -class Message_InteractiveMessage_ShopMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_id(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_surface(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_messageversion(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } -}; - -Message_InteractiveMessage_ShopMessage::Message_InteractiveMessage_ShopMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveMessage.ShopMessage) -} -Message_InteractiveMessage_ShopMessage::Message_InteractiveMessage_ShopMessage(const Message_InteractiveMessage_ShopMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_InteractiveMessage_ShopMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.id_){} - , decltype(_impl_.surface_){} - , decltype(_impl_.messageversion_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.id_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.id_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_id()) { - _this->_impl_.id_.Set(from._internal_id(), - _this->GetArenaForAllocation()); - } - ::memcpy(&_impl_.surface_, &from._impl_.surface_, - static_cast(reinterpret_cast(&_impl_.messageversion_) - - reinterpret_cast(&_impl_.surface_)) + sizeof(_impl_.messageversion_)); - // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveMessage.ShopMessage) -} - -inline void Message_InteractiveMessage_ShopMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.id_){} - , decltype(_impl_.surface_){0} - , decltype(_impl_.messageversion_){0} - }; - _impl_.id_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.id_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_InteractiveMessage_ShopMessage::~Message_InteractiveMessage_ShopMessage() { - // @@protoc_insertion_point(destructor:proto.Message.InteractiveMessage.ShopMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_InteractiveMessage_ShopMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.id_.Destroy(); -} - -void Message_InteractiveMessage_ShopMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_InteractiveMessage_ShopMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveMessage.ShopMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.id_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000006u) { - ::memset(&_impl_.surface_, 0, static_cast( - reinterpret_cast(&_impl_.messageversion_) - - reinterpret_cast(&_impl_.surface_)) + sizeof(_impl_.messageversion_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_InteractiveMessage_ShopMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string id = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_id(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveMessage.ShopMessage.id"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.Message.InteractiveMessage.ShopMessage.Surface surface = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::Message_InteractiveMessage_ShopMessage_Surface_IsValid(val))) { - _internal_set_surface(static_cast<::proto::Message_InteractiveMessage_ShopMessage_Surface>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional int32 messageVersion = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_messageversion(&has_bits); - _impl_.messageversion_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_InteractiveMessage_ShopMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveMessage.ShopMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string id = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_id().data(), static_cast(this->_internal_id().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.InteractiveMessage.ShopMessage.id"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_id(), target); - } - - // optional .proto.Message.InteractiveMessage.ShopMessage.Surface surface = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 2, this->_internal_surface(), target); - } - - // optional int32 messageVersion = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_messageversion(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.InteractiveMessage.ShopMessage) - return target; -} - -size_t Message_InteractiveMessage_ShopMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveMessage.ShopMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional string id = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_id()); - } - - // optional .proto.Message.InteractiveMessage.ShopMessage.Surface surface = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_surface()); - } - - // optional int32 messageVersion = 3; - if (cached_has_bits & 0x00000004u) { - total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_messageversion()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveMessage_ShopMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_InteractiveMessage_ShopMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveMessage_ShopMessage::GetClassData() const { return &_class_data_; } - - -void Message_InteractiveMessage_ShopMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveMessage.ShopMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_id(from._internal_id()); - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.surface_ = from._impl_.surface_; - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.messageversion_ = from._impl_.messageversion_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_InteractiveMessage_ShopMessage::CopyFrom(const Message_InteractiveMessage_ShopMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveMessage.ShopMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_InteractiveMessage_ShopMessage::IsInitialized() const { - return true; -} - -void Message_InteractiveMessage_ShopMessage::InternalSwap(Message_InteractiveMessage_ShopMessage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.id_, lhs_arena, - &other->_impl_.id_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_InteractiveMessage_ShopMessage, _impl_.messageversion_) - + sizeof(Message_InteractiveMessage_ShopMessage::_impl_.messageversion_) - - PROTOBUF_FIELD_OFFSET(Message_InteractiveMessage_ShopMessage, _impl_.surface_)>( - reinterpret_cast(&_impl_.surface_), - reinterpret_cast(&other->_impl_.surface_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveMessage_ShopMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[92]); -} - -// =================================================================== - -class Message_InteractiveMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::Message_InteractiveMessage_Header& header(const Message_InteractiveMessage* msg); - static void set_has_header(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::proto::Message_InteractiveMessage_Body& body(const Message_InteractiveMessage* msg); - static void set_has_body(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::proto::Message_InteractiveMessage_Footer& footer(const Message_InteractiveMessage* msg); - static void set_has_footer(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static const ::proto::ContextInfo& contextinfo(const Message_InteractiveMessage* msg); - static void set_has_contextinfo(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static const ::proto::Message_InteractiveMessage_ShopMessage& shopstorefrontmessage(const Message_InteractiveMessage* msg); - static const ::proto::Message_InteractiveMessage_CollectionMessage& collectionmessage(const Message_InteractiveMessage* msg); - static const ::proto::Message_InteractiveMessage_NativeFlowMessage& nativeflowmessage(const Message_InteractiveMessage* msg); -}; - -const ::proto::Message_InteractiveMessage_Header& -Message_InteractiveMessage::_Internal::header(const Message_InteractiveMessage* msg) { - return *msg->_impl_.header_; -} -const ::proto::Message_InteractiveMessage_Body& -Message_InteractiveMessage::_Internal::body(const Message_InteractiveMessage* msg) { - return *msg->_impl_.body_; -} -const ::proto::Message_InteractiveMessage_Footer& -Message_InteractiveMessage::_Internal::footer(const Message_InteractiveMessage* msg) { - return *msg->_impl_.footer_; -} -const ::proto::ContextInfo& -Message_InteractiveMessage::_Internal::contextinfo(const Message_InteractiveMessage* msg) { - return *msg->_impl_.contextinfo_; -} -const ::proto::Message_InteractiveMessage_ShopMessage& -Message_InteractiveMessage::_Internal::shopstorefrontmessage(const Message_InteractiveMessage* msg) { - return *msg->_impl_.interactiveMessage_.shopstorefrontmessage_; -} -const ::proto::Message_InteractiveMessage_CollectionMessage& -Message_InteractiveMessage::_Internal::collectionmessage(const Message_InteractiveMessage* msg) { - return *msg->_impl_.interactiveMessage_.collectionmessage_; -} -const ::proto::Message_InteractiveMessage_NativeFlowMessage& -Message_InteractiveMessage::_Internal::nativeflowmessage(const Message_InteractiveMessage* msg) { - return *msg->_impl_.interactiveMessage_.nativeflowmessage_; -} -void Message_InteractiveMessage::set_allocated_shopstorefrontmessage(::proto::Message_InteractiveMessage_ShopMessage* shopstorefrontmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_interactiveMessage(); - if (shopstorefrontmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(shopstorefrontmessage); - if (message_arena != submessage_arena) { - shopstorefrontmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, shopstorefrontmessage, submessage_arena); - } - set_has_shopstorefrontmessage(); - _impl_.interactiveMessage_.shopstorefrontmessage_ = shopstorefrontmessage; - } - // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.shopStorefrontMessage) -} -void Message_InteractiveMessage::set_allocated_collectionmessage(::proto::Message_InteractiveMessage_CollectionMessage* collectionmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_interactiveMessage(); - if (collectionmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(collectionmessage); - if (message_arena != submessage_arena) { - collectionmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, collectionmessage, submessage_arena); - } - set_has_collectionmessage(); - _impl_.interactiveMessage_.collectionmessage_ = collectionmessage; - } - // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.collectionMessage) -} -void Message_InteractiveMessage::set_allocated_nativeflowmessage(::proto::Message_InteractiveMessage_NativeFlowMessage* nativeflowmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_interactiveMessage(); - if (nativeflowmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(nativeflowmessage); - if (message_arena != submessage_arena) { - nativeflowmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, nativeflowmessage, submessage_arena); - } - set_has_nativeflowmessage(); - _impl_.interactiveMessage_.nativeflowmessage_ = nativeflowmessage; - } - // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.nativeFlowMessage) -} -Message_InteractiveMessage::Message_InteractiveMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveMessage) -} -Message_InteractiveMessage::Message_InteractiveMessage(const Message_InteractiveMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_InteractiveMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.header_){nullptr} - , decltype(_impl_.body_){nullptr} - , decltype(_impl_.footer_){nullptr} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.interactiveMessage_){} - , /*decltype(_impl_._oneof_case_)*/{}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_header()) { - _this->_impl_.header_ = new ::proto::Message_InteractiveMessage_Header(*from._impl_.header_); - } - if (from._internal_has_body()) { - _this->_impl_.body_ = new ::proto::Message_InteractiveMessage_Body(*from._impl_.body_); - } - if (from._internal_has_footer()) { - _this->_impl_.footer_ = new ::proto::Message_InteractiveMessage_Footer(*from._impl_.footer_); - } - if (from._internal_has_contextinfo()) { - _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); - } - clear_has_interactiveMessage(); - switch (from.interactiveMessage_case()) { - case kShopStorefrontMessage: { - _this->_internal_mutable_shopstorefrontmessage()->::proto::Message_InteractiveMessage_ShopMessage::MergeFrom( - from._internal_shopstorefrontmessage()); - break; - } - case kCollectionMessage: { - _this->_internal_mutable_collectionmessage()->::proto::Message_InteractiveMessage_CollectionMessage::MergeFrom( - from._internal_collectionmessage()); - break; - } - case kNativeFlowMessage: { - _this->_internal_mutable_nativeflowmessage()->::proto::Message_InteractiveMessage_NativeFlowMessage::MergeFrom( - from._internal_nativeflowmessage()); - break; - } - case INTERACTIVEMESSAGE_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveMessage) -} - -inline void Message_InteractiveMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.header_){nullptr} - , decltype(_impl_.body_){nullptr} - , decltype(_impl_.footer_){nullptr} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.interactiveMessage_){} - , /*decltype(_impl_._oneof_case_)*/{} - }; - clear_has_interactiveMessage(); -} - -Message_InteractiveMessage::~Message_InteractiveMessage() { - // @@protoc_insertion_point(destructor:proto.Message.InteractiveMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_InteractiveMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete _impl_.header_; - if (this != internal_default_instance()) delete _impl_.body_; - if (this != internal_default_instance()) delete _impl_.footer_; - if (this != internal_default_instance()) delete _impl_.contextinfo_; - if (has_interactiveMessage()) { - clear_interactiveMessage(); - } -} - -void Message_InteractiveMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_InteractiveMessage::clear_interactiveMessage() { -// @@protoc_insertion_point(one_of_clear_start:proto.Message.InteractiveMessage) - switch (interactiveMessage_case()) { - case kShopStorefrontMessage: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.interactiveMessage_.shopstorefrontmessage_; - } - break; - } - case kCollectionMessage: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.interactiveMessage_.collectionmessage_; - } - break; - } - case kNativeFlowMessage: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.interactiveMessage_.nativeflowmessage_; - } - break; - } - case INTERACTIVEMESSAGE_NOT_SET: { - break; - } - } - _impl_._oneof_case_[0] = INTERACTIVEMESSAGE_NOT_SET; -} - - -void Message_InteractiveMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.header_ != nullptr); - _impl_.header_->Clear(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.body_ != nullptr); - _impl_.body_->Clear(); - } - if (cached_has_bits & 0x00000004u) { - GOOGLE_DCHECK(_impl_.footer_ != nullptr); - _impl_.footer_->Clear(); - } - if (cached_has_bits & 0x00000008u) { - GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); - _impl_.contextinfo_->Clear(); - } - } - clear_interactiveMessage(); - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_InteractiveMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.Message.InteractiveMessage.Header header = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_header(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.InteractiveMessage.Body body = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_body(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.InteractiveMessage.Footer footer = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_footer(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .proto.Message.InteractiveMessage.ShopMessage shopStorefrontMessage = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_shopstorefrontmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .proto.Message.InteractiveMessage.CollectionMessage collectionMessage = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - ptr = ctx->ParseMessage(_internal_mutable_collectionmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .proto.Message.InteractiveMessage.NativeFlowMessage nativeFlowMessage = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - ptr = ctx->ParseMessage(_internal_mutable_nativeflowmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.ContextInfo contextInfo = 15; - case 15: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { - ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_InteractiveMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.Message.InteractiveMessage.Header header = 1; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::header(this), - _Internal::header(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.InteractiveMessage.Body body = 2; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::body(this), - _Internal::body(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.InteractiveMessage.Footer footer = 3; - if (cached_has_bits & 0x00000004u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, _Internal::footer(this), - _Internal::footer(this).GetCachedSize(), target, stream); - } - - switch (interactiveMessage_case()) { - case kShopStorefrontMessage: { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(4, _Internal::shopstorefrontmessage(this), - _Internal::shopstorefrontmessage(this).GetCachedSize(), target, stream); - break; - } - case kCollectionMessage: { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(5, _Internal::collectionmessage(this), - _Internal::collectionmessage(this).GetCachedSize(), target, stream); - break; - } - case kNativeFlowMessage: { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(6, _Internal::nativeflowmessage(this), - _Internal::nativeflowmessage(this).GetCachedSize(), target, stream); - break; - } - default: ; - } - // optional .proto.ContextInfo contextInfo = 15; - if (cached_has_bits & 0x00000008u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(15, _Internal::contextinfo(this), - _Internal::contextinfo(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.InteractiveMessage) - return target; -} - -size_t Message_InteractiveMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - // optional .proto.Message.InteractiveMessage.Header header = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.header_); - } - - // optional .proto.Message.InteractiveMessage.Body body = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.body_); - } - - // optional .proto.Message.InteractiveMessage.Footer footer = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.footer_); - } - - // optional .proto.ContextInfo contextInfo = 15; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.contextinfo_); - } - - } - switch (interactiveMessage_case()) { - // .proto.Message.InteractiveMessage.ShopMessage shopStorefrontMessage = 4; - case kShopStorefrontMessage: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.interactiveMessage_.shopstorefrontmessage_); - break; - } - // .proto.Message.InteractiveMessage.CollectionMessage collectionMessage = 5; - case kCollectionMessage: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.interactiveMessage_.collectionmessage_); - break; - } - // .proto.Message.InteractiveMessage.NativeFlowMessage nativeFlowMessage = 6; - case kNativeFlowMessage: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.interactiveMessage_.nativeflowmessage_); - break; - } - case INTERACTIVEMESSAGE_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_InteractiveMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveMessage::GetClassData() const { return &_class_data_; } - - -void Message_InteractiveMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_mutable_header()->::proto::Message_InteractiveMessage_Header::MergeFrom( - from._internal_header()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_body()->::proto::Message_InteractiveMessage_Body::MergeFrom( - from._internal_body()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_mutable_footer()->::proto::Message_InteractiveMessage_Footer::MergeFrom( - from._internal_footer()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( - from._internal_contextinfo()); - } - } - switch (from.interactiveMessage_case()) { - case kShopStorefrontMessage: { - _this->_internal_mutable_shopstorefrontmessage()->::proto::Message_InteractiveMessage_ShopMessage::MergeFrom( - from._internal_shopstorefrontmessage()); - break; - } - case kCollectionMessage: { - _this->_internal_mutable_collectionmessage()->::proto::Message_InteractiveMessage_CollectionMessage::MergeFrom( - from._internal_collectionmessage()); - break; - } - case kNativeFlowMessage: { - _this->_internal_mutable_nativeflowmessage()->::proto::Message_InteractiveMessage_NativeFlowMessage::MergeFrom( - from._internal_nativeflowmessage()); - break; - } - case INTERACTIVEMESSAGE_NOT_SET: { - break; - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_InteractiveMessage::CopyFrom(const Message_InteractiveMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_InteractiveMessage::IsInitialized() const { - return true; -} - -void Message_InteractiveMessage::InternalSwap(Message_InteractiveMessage* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_InteractiveMessage, _impl_.contextinfo_) - + sizeof(Message_InteractiveMessage::_impl_.contextinfo_) - - PROTOBUF_FIELD_OFFSET(Message_InteractiveMessage, _impl_.header_)>( - reinterpret_cast(&_impl_.header_), - reinterpret_cast(&other->_impl_.header_)); - swap(_impl_.interactiveMessage_, other->_impl_.interactiveMessage_); - swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[93]); -} - -// =================================================================== - -class Message_InteractiveResponseMessage_Body::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_text(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -Message_InteractiveResponseMessage_Body::Message_InteractiveResponseMessage_Body(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveResponseMessage.Body) -} -Message_InteractiveResponseMessage_Body::Message_InteractiveResponseMessage_Body(const Message_InteractiveResponseMessage_Body& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_InteractiveResponseMessage_Body* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.text_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.text_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.text_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_text()) { - _this->_impl_.text_.Set(from._internal_text(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveResponseMessage.Body) -} - -inline void Message_InteractiveResponseMessage_Body::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.text_){} - }; - _impl_.text_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.text_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_InteractiveResponseMessage_Body::~Message_InteractiveResponseMessage_Body() { - // @@protoc_insertion_point(destructor:proto.Message.InteractiveResponseMessage.Body) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_InteractiveResponseMessage_Body::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.text_.Destroy(); -} - -void Message_InteractiveResponseMessage_Body::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_InteractiveResponseMessage_Body::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveResponseMessage.Body) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.text_.ClearNonDefaultToEmpty(); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_InteractiveResponseMessage_Body::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string text = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_text(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveResponseMessage.Body.text"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_InteractiveResponseMessage_Body::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveResponseMessage.Body) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string text = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_text().data(), static_cast(this->_internal_text().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.InteractiveResponseMessage.Body.text"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_text(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.InteractiveResponseMessage.Body) - return target; -} - -size_t Message_InteractiveResponseMessage_Body::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveResponseMessage.Body) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional string text = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_text()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveResponseMessage_Body::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_InteractiveResponseMessage_Body::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveResponseMessage_Body::GetClassData() const { return &_class_data_; } - - -void Message_InteractiveResponseMessage_Body::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveResponseMessage.Body) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_text()) { - _this->_internal_set_text(from._internal_text()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_InteractiveResponseMessage_Body::CopyFrom(const Message_InteractiveResponseMessage_Body& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveResponseMessage.Body) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_InteractiveResponseMessage_Body::IsInitialized() const { - return true; -} - -void Message_InteractiveResponseMessage_Body::InternalSwap(Message_InteractiveResponseMessage_Body* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.text_, lhs_arena, - &other->_impl_.text_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveResponseMessage_Body::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[94]); -} - -// =================================================================== - -class Message_InteractiveResponseMessage_NativeFlowResponseMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_name(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_paramsjson(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_version(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } -}; - -Message_InteractiveResponseMessage_NativeFlowResponseMessage::Message_InteractiveResponseMessage_NativeFlowResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage) -} -Message_InteractiveResponseMessage_NativeFlowResponseMessage::Message_InteractiveResponseMessage_NativeFlowResponseMessage(const Message_InteractiveResponseMessage_NativeFlowResponseMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_InteractiveResponseMessage_NativeFlowResponseMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.name_){} - , decltype(_impl_.paramsjson_){} - , decltype(_impl_.version_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.name_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.name_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_name()) { - _this->_impl_.name_.Set(from._internal_name(), - _this->GetArenaForAllocation()); - } - _impl_.paramsjson_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.paramsjson_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_paramsjson()) { - _this->_impl_.paramsjson_.Set(from._internal_paramsjson(), - _this->GetArenaForAllocation()); - } - _this->_impl_.version_ = from._impl_.version_; - // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage) -} - -inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.name_){} - , decltype(_impl_.paramsjson_){} - , decltype(_impl_.version_){0} - }; - _impl_.name_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.name_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.paramsjson_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.paramsjson_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_InteractiveResponseMessage_NativeFlowResponseMessage::~Message_InteractiveResponseMessage_NativeFlowResponseMessage() { - // @@protoc_insertion_point(destructor:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.name_.Destroy(); - _impl_.paramsjson_.Destroy(); -} - -void Message_InteractiveResponseMessage_NativeFlowResponseMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_InteractiveResponseMessage_NativeFlowResponseMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.name_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.paramsjson_.ClearNonDefaultToEmpty(); - } - } - _impl_.version_ = 0; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_InteractiveResponseMessage_NativeFlowResponseMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string name = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_name(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.name"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string paramsJson = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_paramsjson(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.paramsJson"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional int32 version = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_version(&has_bits); - _impl_.version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_InteractiveResponseMessage_NativeFlowResponseMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string name = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_name().data(), static_cast(this->_internal_name().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.name"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_name(), target); - } - - // optional string paramsJson = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_paramsjson().data(), static_cast(this->_internal_paramsjson().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.paramsJson"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_paramsjson(), target); - } - - // optional int32 version = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_version(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage) - return target; -} - -size_t Message_InteractiveResponseMessage_NativeFlowResponseMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional string name = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_name()); - } - - // optional string paramsJson = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_paramsjson()); - } - - // optional int32 version = 3; - if (cached_has_bits & 0x00000004u) { - total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_version()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveResponseMessage_NativeFlowResponseMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_InteractiveResponseMessage_NativeFlowResponseMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveResponseMessage_NativeFlowResponseMessage::GetClassData() const { return &_class_data_; } - - -void Message_InteractiveResponseMessage_NativeFlowResponseMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_name(from._internal_name()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_paramsjson(from._internal_paramsjson()); - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.version_ = from._impl_.version_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_InteractiveResponseMessage_NativeFlowResponseMessage::CopyFrom(const Message_InteractiveResponseMessage_NativeFlowResponseMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_InteractiveResponseMessage_NativeFlowResponseMessage::IsInitialized() const { - return true; -} - -void Message_InteractiveResponseMessage_NativeFlowResponseMessage::InternalSwap(Message_InteractiveResponseMessage_NativeFlowResponseMessage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.name_, lhs_arena, - &other->_impl_.name_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.paramsjson_, lhs_arena, - &other->_impl_.paramsjson_, rhs_arena - ); - swap(_impl_.version_, other->_impl_.version_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveResponseMessage_NativeFlowResponseMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[95]); -} - -// =================================================================== - -class Message_InteractiveResponseMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::Message_InteractiveResponseMessage_Body& body(const Message_InteractiveResponseMessage* msg); - static void set_has_body(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::proto::ContextInfo& contextinfo(const Message_InteractiveResponseMessage* msg); - static void set_has_contextinfo(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage& nativeflowresponsemessage(const Message_InteractiveResponseMessage* msg); -}; - -const ::proto::Message_InteractiveResponseMessage_Body& -Message_InteractiveResponseMessage::_Internal::body(const Message_InteractiveResponseMessage* msg) { - return *msg->_impl_.body_; -} -const ::proto::ContextInfo& -Message_InteractiveResponseMessage::_Internal::contextinfo(const Message_InteractiveResponseMessage* msg) { - return *msg->_impl_.contextinfo_; -} -const ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage& -Message_InteractiveResponseMessage::_Internal::nativeflowresponsemessage(const Message_InteractiveResponseMessage* msg) { - return *msg->_impl_.interactiveResponseMessage_.nativeflowresponsemessage_; -} -void Message_InteractiveResponseMessage::set_allocated_nativeflowresponsemessage(::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* nativeflowresponsemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_interactiveResponseMessage(); - if (nativeflowresponsemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(nativeflowresponsemessage); - if (message_arena != submessage_arena) { - nativeflowresponsemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, nativeflowresponsemessage, submessage_arena); - } - set_has_nativeflowresponsemessage(); - _impl_.interactiveResponseMessage_.nativeflowresponsemessage_ = nativeflowresponsemessage; - } - // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveResponseMessage.nativeFlowResponseMessage) -} -Message_InteractiveResponseMessage::Message_InteractiveResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.InteractiveResponseMessage) -} -Message_InteractiveResponseMessage::Message_InteractiveResponseMessage(const Message_InteractiveResponseMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_InteractiveResponseMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.body_){nullptr} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.interactiveResponseMessage_){} - , /*decltype(_impl_._oneof_case_)*/{}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_body()) { - _this->_impl_.body_ = new ::proto::Message_InteractiveResponseMessage_Body(*from._impl_.body_); - } - if (from._internal_has_contextinfo()) { - _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); - } - clear_has_interactiveResponseMessage(); - switch (from.interactiveResponseMessage_case()) { - case kNativeFlowResponseMessage: { - _this->_internal_mutable_nativeflowresponsemessage()->::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage::MergeFrom( - from._internal_nativeflowresponsemessage()); - break; - } - case INTERACTIVERESPONSEMESSAGE_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:proto.Message.InteractiveResponseMessage) -} - -inline void Message_InteractiveResponseMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.body_){nullptr} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.interactiveResponseMessage_){} - , /*decltype(_impl_._oneof_case_)*/{} - }; - clear_has_interactiveResponseMessage(); -} - -Message_InteractiveResponseMessage::~Message_InteractiveResponseMessage() { - // @@protoc_insertion_point(destructor:proto.Message.InteractiveResponseMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_InteractiveResponseMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete _impl_.body_; - if (this != internal_default_instance()) delete _impl_.contextinfo_; - if (has_interactiveResponseMessage()) { - clear_interactiveResponseMessage(); - } -} - -void Message_InteractiveResponseMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_InteractiveResponseMessage::clear_interactiveResponseMessage() { -// @@protoc_insertion_point(one_of_clear_start:proto.Message.InteractiveResponseMessage) - switch (interactiveResponseMessage_case()) { - case kNativeFlowResponseMessage: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.interactiveResponseMessage_.nativeflowresponsemessage_; - } - break; - } - case INTERACTIVERESPONSEMESSAGE_NOT_SET: { - break; - } - } - _impl_._oneof_case_[0] = INTERACTIVERESPONSEMESSAGE_NOT_SET; -} - - -void Message_InteractiveResponseMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.InteractiveResponseMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.body_ != nullptr); - _impl_.body_->Clear(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); - _impl_.contextinfo_->Clear(); - } - } - clear_interactiveResponseMessage(); - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_InteractiveResponseMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.Message.InteractiveResponseMessage.Body body = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_body(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage nativeFlowResponseMessage = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_nativeflowresponsemessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.ContextInfo contextInfo = 15; - case 15: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { - ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_InteractiveResponseMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InteractiveResponseMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.Message.InteractiveResponseMessage.Body body = 1; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::body(this), - _Internal::body(this).GetCachedSize(), target, stream); - } - - // .proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage nativeFlowResponseMessage = 2; - if (_internal_has_nativeflowresponsemessage()) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::nativeflowresponsemessage(this), - _Internal::nativeflowresponsemessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.ContextInfo contextInfo = 15; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(15, _Internal::contextinfo(this), - _Internal::contextinfo(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.InteractiveResponseMessage) - return target; -} - -size_t Message_InteractiveResponseMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.InteractiveResponseMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional .proto.Message.InteractiveResponseMessage.Body body = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.body_); - } - - // optional .proto.ContextInfo contextInfo = 15; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.contextinfo_); - } - - } - switch (interactiveResponseMessage_case()) { - // .proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage nativeFlowResponseMessage = 2; - case kNativeFlowResponseMessage: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.interactiveResponseMessage_.nativeflowresponsemessage_); - break; - } - case INTERACTIVERESPONSEMESSAGE_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InteractiveResponseMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_InteractiveResponseMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InteractiveResponseMessage::GetClassData() const { return &_class_data_; } - - -void Message_InteractiveResponseMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InteractiveResponseMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_mutable_body()->::proto::Message_InteractiveResponseMessage_Body::MergeFrom( - from._internal_body()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( - from._internal_contextinfo()); - } - } - switch (from.interactiveResponseMessage_case()) { - case kNativeFlowResponseMessage: { - _this->_internal_mutable_nativeflowresponsemessage()->::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage::MergeFrom( - from._internal_nativeflowresponsemessage()); - break; - } - case INTERACTIVERESPONSEMESSAGE_NOT_SET: { - break; - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_InteractiveResponseMessage::CopyFrom(const Message_InteractiveResponseMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InteractiveResponseMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_InteractiveResponseMessage::IsInitialized() const { - return true; -} - -void Message_InteractiveResponseMessage::InternalSwap(Message_InteractiveResponseMessage* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_InteractiveResponseMessage, _impl_.contextinfo_) - + sizeof(Message_InteractiveResponseMessage::_impl_.contextinfo_) - - PROTOBUF_FIELD_OFFSET(Message_InteractiveResponseMessage, _impl_.body_)>( - reinterpret_cast(&_impl_.body_), - reinterpret_cast(&other->_impl_.body_)); - swap(_impl_.interactiveResponseMessage_, other->_impl_.interactiveResponseMessage_); - swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_InteractiveResponseMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[96]); -} - -// =================================================================== - -class Message_InvoiceMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_note(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_token(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_attachmenttype(HasBits* has_bits) { - (*has_bits)[0] |= 512u; - } - static void set_has_attachmentmimetype(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_attachmentmediakey(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_attachmentmediakeytimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 256u; - } - static void set_has_attachmentfilesha256(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_attachmentfileencsha256(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static void set_has_attachmentdirectpath(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static void set_has_attachmentjpegthumbnail(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } -}; - -Message_InvoiceMessage::Message_InvoiceMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.InvoiceMessage) -} -Message_InvoiceMessage::Message_InvoiceMessage(const Message_InvoiceMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_InvoiceMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.note_){} - , decltype(_impl_.token_){} - , decltype(_impl_.attachmentmimetype_){} - , decltype(_impl_.attachmentmediakey_){} - , decltype(_impl_.attachmentfilesha256_){} - , decltype(_impl_.attachmentfileencsha256_){} - , decltype(_impl_.attachmentdirectpath_){} - , decltype(_impl_.attachmentjpegthumbnail_){} - , decltype(_impl_.attachmentmediakeytimestamp_){} - , decltype(_impl_.attachmenttype_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.note_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.note_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_note()) { - _this->_impl_.note_.Set(from._internal_note(), - _this->GetArenaForAllocation()); - } - _impl_.token_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.token_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_token()) { - _this->_impl_.token_.Set(from._internal_token(), - _this->GetArenaForAllocation()); - } - _impl_.attachmentmimetype_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.attachmentmimetype_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_attachmentmimetype()) { - _this->_impl_.attachmentmimetype_.Set(from._internal_attachmentmimetype(), - _this->GetArenaForAllocation()); - } - _impl_.attachmentmediakey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.attachmentmediakey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_attachmentmediakey()) { - _this->_impl_.attachmentmediakey_.Set(from._internal_attachmentmediakey(), - _this->GetArenaForAllocation()); - } - _impl_.attachmentfilesha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.attachmentfilesha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_attachmentfilesha256()) { - _this->_impl_.attachmentfilesha256_.Set(from._internal_attachmentfilesha256(), - _this->GetArenaForAllocation()); - } - _impl_.attachmentfileencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.attachmentfileencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_attachmentfileencsha256()) { - _this->_impl_.attachmentfileencsha256_.Set(from._internal_attachmentfileencsha256(), - _this->GetArenaForAllocation()); - } - _impl_.attachmentdirectpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.attachmentdirectpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_attachmentdirectpath()) { - _this->_impl_.attachmentdirectpath_.Set(from._internal_attachmentdirectpath(), - _this->GetArenaForAllocation()); - } - _impl_.attachmentjpegthumbnail_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.attachmentjpegthumbnail_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_attachmentjpegthumbnail()) { - _this->_impl_.attachmentjpegthumbnail_.Set(from._internal_attachmentjpegthumbnail(), - _this->GetArenaForAllocation()); - } - ::memcpy(&_impl_.attachmentmediakeytimestamp_, &from._impl_.attachmentmediakeytimestamp_, - static_cast(reinterpret_cast(&_impl_.attachmenttype_) - - reinterpret_cast(&_impl_.attachmentmediakeytimestamp_)) + sizeof(_impl_.attachmenttype_)); - // @@protoc_insertion_point(copy_constructor:proto.Message.InvoiceMessage) -} - -inline void Message_InvoiceMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.note_){} - , decltype(_impl_.token_){} - , decltype(_impl_.attachmentmimetype_){} - , decltype(_impl_.attachmentmediakey_){} - , decltype(_impl_.attachmentfilesha256_){} - , decltype(_impl_.attachmentfileencsha256_){} - , decltype(_impl_.attachmentdirectpath_){} - , decltype(_impl_.attachmentjpegthumbnail_){} - , decltype(_impl_.attachmentmediakeytimestamp_){int64_t{0}} - , decltype(_impl_.attachmenttype_){0} - }; - _impl_.note_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.note_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.token_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.token_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.attachmentmimetype_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.attachmentmimetype_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.attachmentmediakey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.attachmentmediakey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.attachmentfilesha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.attachmentfilesha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.attachmentfileencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.attachmentfileencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.attachmentdirectpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.attachmentdirectpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.attachmentjpegthumbnail_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.attachmentjpegthumbnail_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_InvoiceMessage::~Message_InvoiceMessage() { - // @@protoc_insertion_point(destructor:proto.Message.InvoiceMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_InvoiceMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.note_.Destroy(); - _impl_.token_.Destroy(); - _impl_.attachmentmimetype_.Destroy(); - _impl_.attachmentmediakey_.Destroy(); - _impl_.attachmentfilesha256_.Destroy(); - _impl_.attachmentfileencsha256_.Destroy(); - _impl_.attachmentdirectpath_.Destroy(); - _impl_.attachmentjpegthumbnail_.Destroy(); -} - -void Message_InvoiceMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_InvoiceMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.InvoiceMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _impl_.note_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.token_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.attachmentmimetype_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000008u) { - _impl_.attachmentmediakey_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000010u) { - _impl_.attachmentfilesha256_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000020u) { - _impl_.attachmentfileencsha256_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000040u) { - _impl_.attachmentdirectpath_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000080u) { - _impl_.attachmentjpegthumbnail_.ClearNonDefaultToEmpty(); - } - } - if (cached_has_bits & 0x00000300u) { - ::memset(&_impl_.attachmentmediakeytimestamp_, 0, static_cast( - reinterpret_cast(&_impl_.attachmenttype_) - - reinterpret_cast(&_impl_.attachmentmediakeytimestamp_)) + sizeof(_impl_.attachmenttype_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_InvoiceMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string note = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_note(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.InvoiceMessage.note"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string token = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_token(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.InvoiceMessage.token"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.Message.InvoiceMessage.AttachmentType attachmentType = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::Message_InvoiceMessage_AttachmentType_IsValid(val))) { - _internal_set_attachmenttype(static_cast<::proto::Message_InvoiceMessage_AttachmentType>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional string attachmentMimetype = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - auto str = _internal_mutable_attachmentmimetype(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.InvoiceMessage.attachmentMimetype"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bytes attachmentMediaKey = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - auto str = _internal_mutable_attachmentmediakey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional int64 attachmentMediaKeyTimestamp = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { - _Internal::set_has_attachmentmediakeytimestamp(&has_bits); - _impl_.attachmentmediakeytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes attachmentFileSha256 = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - auto str = _internal_mutable_attachmentfilesha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes attachmentFileEncSha256 = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { - auto str = _internal_mutable_attachmentfileencsha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string attachmentDirectPath = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { - auto str = _internal_mutable_attachmentdirectpath(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.InvoiceMessage.attachmentDirectPath"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bytes attachmentJpegThumbnail = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { - auto str = _internal_mutable_attachmentjpegthumbnail(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_InvoiceMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.InvoiceMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string note = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_note().data(), static_cast(this->_internal_note().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.InvoiceMessage.note"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_note(), target); - } - - // optional string token = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_token().data(), static_cast(this->_internal_token().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.InvoiceMessage.token"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_token(), target); - } - - // optional .proto.Message.InvoiceMessage.AttachmentType attachmentType = 3; - if (cached_has_bits & 0x00000200u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 3, this->_internal_attachmenttype(), target); - } - - // optional string attachmentMimetype = 4; - if (cached_has_bits & 0x00000004u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_attachmentmimetype().data(), static_cast(this->_internal_attachmentmimetype().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.InvoiceMessage.attachmentMimetype"); - target = stream->WriteStringMaybeAliased( - 4, this->_internal_attachmentmimetype(), target); - } - - // optional bytes attachmentMediaKey = 5; - if (cached_has_bits & 0x00000008u) { - target = stream->WriteBytesMaybeAliased( - 5, this->_internal_attachmentmediakey(), target); - } - - // optional int64 attachmentMediaKeyTimestamp = 6; - if (cached_has_bits & 0x00000100u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(6, this->_internal_attachmentmediakeytimestamp(), target); - } - - // optional bytes attachmentFileSha256 = 7; - if (cached_has_bits & 0x00000010u) { - target = stream->WriteBytesMaybeAliased( - 7, this->_internal_attachmentfilesha256(), target); - } - - // optional bytes attachmentFileEncSha256 = 8; - if (cached_has_bits & 0x00000020u) { - target = stream->WriteBytesMaybeAliased( - 8, this->_internal_attachmentfileencsha256(), target); - } - - // optional string attachmentDirectPath = 9; - if (cached_has_bits & 0x00000040u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_attachmentdirectpath().data(), static_cast(this->_internal_attachmentdirectpath().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.InvoiceMessage.attachmentDirectPath"); - target = stream->WriteStringMaybeAliased( - 9, this->_internal_attachmentdirectpath(), target); - } - - // optional bytes attachmentJpegThumbnail = 10; - if (cached_has_bits & 0x00000080u) { - target = stream->WriteBytesMaybeAliased( - 10, this->_internal_attachmentjpegthumbnail(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.InvoiceMessage) - return target; -} - -size_t Message_InvoiceMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.InvoiceMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional string note = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_note()); - } - - // optional string token = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_token()); - } - - // optional string attachmentMimetype = 4; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_attachmentmimetype()); - } - - // optional bytes attachmentMediaKey = 5; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_attachmentmediakey()); - } - - // optional bytes attachmentFileSha256 = 7; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_attachmentfilesha256()); - } - - // optional bytes attachmentFileEncSha256 = 8; - if (cached_has_bits & 0x00000020u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_attachmentfileencsha256()); - } - - // optional string attachmentDirectPath = 9; - if (cached_has_bits & 0x00000040u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_attachmentdirectpath()); - } - - // optional bytes attachmentJpegThumbnail = 10; - if (cached_has_bits & 0x00000080u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_attachmentjpegthumbnail()); - } - - } - if (cached_has_bits & 0x00000300u) { - // optional int64 attachmentMediaKeyTimestamp = 6; - if (cached_has_bits & 0x00000100u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_attachmentmediakeytimestamp()); - } - - // optional .proto.Message.InvoiceMessage.AttachmentType attachmentType = 3; - if (cached_has_bits & 0x00000200u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_attachmenttype()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_InvoiceMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_InvoiceMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_InvoiceMessage::GetClassData() const { return &_class_data_; } - - -void Message_InvoiceMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.InvoiceMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_note(from._internal_note()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_token(from._internal_token()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_attachmentmimetype(from._internal_attachmentmimetype()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_set_attachmentmediakey(from._internal_attachmentmediakey()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_set_attachmentfilesha256(from._internal_attachmentfilesha256()); - } - if (cached_has_bits & 0x00000020u) { - _this->_internal_set_attachmentfileencsha256(from._internal_attachmentfileencsha256()); - } - if (cached_has_bits & 0x00000040u) { - _this->_internal_set_attachmentdirectpath(from._internal_attachmentdirectpath()); - } - if (cached_has_bits & 0x00000080u) { - _this->_internal_set_attachmentjpegthumbnail(from._internal_attachmentjpegthumbnail()); - } - } - if (cached_has_bits & 0x00000300u) { - if (cached_has_bits & 0x00000100u) { - _this->_impl_.attachmentmediakeytimestamp_ = from._impl_.attachmentmediakeytimestamp_; - } - if (cached_has_bits & 0x00000200u) { - _this->_impl_.attachmenttype_ = from._impl_.attachmenttype_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_InvoiceMessage::CopyFrom(const Message_InvoiceMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.InvoiceMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_InvoiceMessage::IsInitialized() const { - return true; -} - -void Message_InvoiceMessage::InternalSwap(Message_InvoiceMessage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.note_, lhs_arena, - &other->_impl_.note_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.token_, lhs_arena, - &other->_impl_.token_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.attachmentmimetype_, lhs_arena, - &other->_impl_.attachmentmimetype_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.attachmentmediakey_, lhs_arena, - &other->_impl_.attachmentmediakey_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.attachmentfilesha256_, lhs_arena, - &other->_impl_.attachmentfilesha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.attachmentfileencsha256_, lhs_arena, - &other->_impl_.attachmentfileencsha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.attachmentdirectpath_, lhs_arena, - &other->_impl_.attachmentdirectpath_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.attachmentjpegthumbnail_, lhs_arena, - &other->_impl_.attachmentjpegthumbnail_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_InvoiceMessage, _impl_.attachmenttype_) - + sizeof(Message_InvoiceMessage::_impl_.attachmenttype_) - - PROTOBUF_FIELD_OFFSET(Message_InvoiceMessage, _impl_.attachmentmediakeytimestamp_)>( - reinterpret_cast(&_impl_.attachmentmediakeytimestamp_), - reinterpret_cast(&other->_impl_.attachmentmediakeytimestamp_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_InvoiceMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[97]); -} - -// =================================================================== - -class Message_KeepInChatMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::MessageKey& key(const Message_KeepInChatMessage* msg); - static void set_has_key(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_keeptype(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_timestampms(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -const ::proto::MessageKey& -Message_KeepInChatMessage::_Internal::key(const Message_KeepInChatMessage* msg) { - return *msg->_impl_.key_; -} -Message_KeepInChatMessage::Message_KeepInChatMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.KeepInChatMessage) -} -Message_KeepInChatMessage::Message_KeepInChatMessage(const Message_KeepInChatMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_KeepInChatMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.key_){nullptr} - , decltype(_impl_.timestampms_){} - , decltype(_impl_.keeptype_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_key()) { - _this->_impl_.key_ = new ::proto::MessageKey(*from._impl_.key_); - } - ::memcpy(&_impl_.timestampms_, &from._impl_.timestampms_, - static_cast(reinterpret_cast(&_impl_.keeptype_) - - reinterpret_cast(&_impl_.timestampms_)) + sizeof(_impl_.keeptype_)); - // @@protoc_insertion_point(copy_constructor:proto.Message.KeepInChatMessage) -} - -inline void Message_KeepInChatMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.key_){nullptr} - , decltype(_impl_.timestampms_){int64_t{0}} - , decltype(_impl_.keeptype_){0} - }; -} - -Message_KeepInChatMessage::~Message_KeepInChatMessage() { - // @@protoc_insertion_point(destructor:proto.Message.KeepInChatMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_KeepInChatMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete _impl_.key_; -} - -void Message_KeepInChatMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_KeepInChatMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.KeepInChatMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.key_ != nullptr); - _impl_.key_->Clear(); - } - if (cached_has_bits & 0x00000006u) { - ::memset(&_impl_.timestampms_, 0, static_cast( - reinterpret_cast(&_impl_.keeptype_) - - reinterpret_cast(&_impl_.timestampms_)) + sizeof(_impl_.keeptype_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_KeepInChatMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.MessageKey key = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.KeepType keepType = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::KeepType_IsValid(val))) { - _internal_set_keeptype(static_cast<::proto::KeepType>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional int64 timestampMs = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_timestampms(&has_bits); - _impl_.timestampms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_KeepInChatMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.KeepInChatMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.MessageKey key = 1; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::key(this), - _Internal::key(this).GetCachedSize(), target, stream); - } - - // optional .proto.KeepType keepType = 2; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 2, this->_internal_keeptype(), target); - } - - // optional int64 timestampMs = 3; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_timestampms(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.KeepInChatMessage) - return target; -} - -size_t Message_KeepInChatMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.KeepInChatMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional .proto.MessageKey key = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.key_); - } - - // optional int64 timestampMs = 3; - if (cached_has_bits & 0x00000002u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_timestampms()); - } - - // optional .proto.KeepType keepType = 2; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_keeptype()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_KeepInChatMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_KeepInChatMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_KeepInChatMessage::GetClassData() const { return &_class_data_; } - - -void Message_KeepInChatMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.KeepInChatMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_mutable_key()->::proto::MessageKey::MergeFrom( - from._internal_key()); - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.timestampms_ = from._impl_.timestampms_; - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.keeptype_ = from._impl_.keeptype_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_KeepInChatMessage::CopyFrom(const Message_KeepInChatMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.KeepInChatMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_KeepInChatMessage::IsInitialized() const { - return true; -} - -void Message_KeepInChatMessage::InternalSwap(Message_KeepInChatMessage* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_KeepInChatMessage, _impl_.keeptype_) - + sizeof(Message_KeepInChatMessage::_impl_.keeptype_) - - PROTOBUF_FIELD_OFFSET(Message_KeepInChatMessage, _impl_.key_)>( - reinterpret_cast(&_impl_.key_), - reinterpret_cast(&other->_impl_.key_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_KeepInChatMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[98]); -} - -// =================================================================== - -class Message_ListMessage_ProductListHeaderImage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_productid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_jpegthumbnail(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -Message_ListMessage_ProductListHeaderImage::Message_ListMessage_ProductListHeaderImage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.ListMessage.ProductListHeaderImage) -} -Message_ListMessage_ProductListHeaderImage::Message_ListMessage_ProductListHeaderImage(const Message_ListMessage_ProductListHeaderImage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_ListMessage_ProductListHeaderImage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.productid_){} - , decltype(_impl_.jpegthumbnail_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.productid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.productid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_productid()) { - _this->_impl_.productid_.Set(from._internal_productid(), - _this->GetArenaForAllocation()); - } - _impl_.jpegthumbnail_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_jpegthumbnail()) { - _this->_impl_.jpegthumbnail_.Set(from._internal_jpegthumbnail(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.Message.ListMessage.ProductListHeaderImage) -} - -inline void Message_ListMessage_ProductListHeaderImage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.productid_){} - , decltype(_impl_.jpegthumbnail_){} - }; - _impl_.productid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.productid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.jpegthumbnail_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_ListMessage_ProductListHeaderImage::~Message_ListMessage_ProductListHeaderImage() { - // @@protoc_insertion_point(destructor:proto.Message.ListMessage.ProductListHeaderImage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_ListMessage_ProductListHeaderImage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.productid_.Destroy(); - _impl_.jpegthumbnail_.Destroy(); -} - -void Message_ListMessage_ProductListHeaderImage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_ListMessage_ProductListHeaderImage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.ListMessage.ProductListHeaderImage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.productid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.jpegthumbnail_.ClearNonDefaultToEmpty(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_ListMessage_ProductListHeaderImage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string productId = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_productid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.ProductListHeaderImage.productId"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bytes jpegThumbnail = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_jpegthumbnail(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_ListMessage_ProductListHeaderImage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ListMessage.ProductListHeaderImage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string productId = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_productid().data(), static_cast(this->_internal_productid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ListMessage.ProductListHeaderImage.productId"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_productid(), target); - } - - // optional bytes jpegThumbnail = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_jpegthumbnail(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ListMessage.ProductListHeaderImage) - return target; -} - -size_t Message_ListMessage_ProductListHeaderImage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.ListMessage.ProductListHeaderImage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional string productId = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_productid()); - } - - // optional bytes jpegThumbnail = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_jpegthumbnail()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ListMessage_ProductListHeaderImage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_ListMessage_ProductListHeaderImage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ListMessage_ProductListHeaderImage::GetClassData() const { return &_class_data_; } - - -void Message_ListMessage_ProductListHeaderImage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ListMessage.ProductListHeaderImage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_productid(from._internal_productid()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_ListMessage_ProductListHeaderImage::CopyFrom(const Message_ListMessage_ProductListHeaderImage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ListMessage.ProductListHeaderImage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_ListMessage_ProductListHeaderImage::IsInitialized() const { - return true; -} - -void Message_ListMessage_ProductListHeaderImage::InternalSwap(Message_ListMessage_ProductListHeaderImage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.productid_, lhs_arena, - &other->_impl_.productid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.jpegthumbnail_, lhs_arena, - &other->_impl_.jpegthumbnail_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_ListMessage_ProductListHeaderImage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[99]); -} - -// =================================================================== - -class Message_ListMessage_ProductListInfo::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::Message_ListMessage_ProductListHeaderImage& headerimage(const Message_ListMessage_ProductListInfo* msg); - static void set_has_headerimage(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_businessownerjid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -const ::proto::Message_ListMessage_ProductListHeaderImage& -Message_ListMessage_ProductListInfo::_Internal::headerimage(const Message_ListMessage_ProductListInfo* msg) { - return *msg->_impl_.headerimage_; -} -Message_ListMessage_ProductListInfo::Message_ListMessage_ProductListInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.ListMessage.ProductListInfo) -} -Message_ListMessage_ProductListInfo::Message_ListMessage_ProductListInfo(const Message_ListMessage_ProductListInfo& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_ListMessage_ProductListInfo* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.productsections_){from._impl_.productsections_} - , decltype(_impl_.businessownerjid_){} - , decltype(_impl_.headerimage_){nullptr}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.businessownerjid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.businessownerjid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_businessownerjid()) { - _this->_impl_.businessownerjid_.Set(from._internal_businessownerjid(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_headerimage()) { - _this->_impl_.headerimage_ = new ::proto::Message_ListMessage_ProductListHeaderImage(*from._impl_.headerimage_); - } - // @@protoc_insertion_point(copy_constructor:proto.Message.ListMessage.ProductListInfo) -} - -inline void Message_ListMessage_ProductListInfo::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.productsections_){arena} - , decltype(_impl_.businessownerjid_){} - , decltype(_impl_.headerimage_){nullptr} - }; - _impl_.businessownerjid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.businessownerjid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_ListMessage_ProductListInfo::~Message_ListMessage_ProductListInfo() { - // @@protoc_insertion_point(destructor:proto.Message.ListMessage.ProductListInfo) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_ListMessage_ProductListInfo::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.productsections_.~RepeatedPtrField(); - _impl_.businessownerjid_.Destroy(); - if (this != internal_default_instance()) delete _impl_.headerimage_; -} - -void Message_ListMessage_ProductListInfo::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_ListMessage_ProductListInfo::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.ListMessage.ProductListInfo) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.productsections_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.businessownerjid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.headerimage_ != nullptr); - _impl_.headerimage_->Clear(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_ListMessage_ProductListInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated .proto.Message.ListMessage.ProductSection productSections = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_productsections(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else - goto handle_unusual; - continue; - // optional .proto.Message.ListMessage.ProductListHeaderImage headerImage = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_headerimage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string businessOwnerJid = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_businessownerjid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.ProductListInfo.businessOwnerJid"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_ListMessage_ProductListInfo::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ListMessage.ProductListInfo) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .proto.Message.ListMessage.ProductSection productSections = 1; - for (unsigned i = 0, - n = static_cast(this->_internal_productsections_size()); i < n; i++) { - const auto& repfield = this->_internal_productsections(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream); - } - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.Message.ListMessage.ProductListHeaderImage headerImage = 2; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::headerimage(this), - _Internal::headerimage(this).GetCachedSize(), target, stream); - } - - // optional string businessOwnerJid = 3; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_businessownerjid().data(), static_cast(this->_internal_businessownerjid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ListMessage.ProductListInfo.businessOwnerJid"); - target = stream->WriteStringMaybeAliased( - 3, this->_internal_businessownerjid(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ListMessage.ProductListInfo) - return target; -} - -size_t Message_ListMessage_ProductListInfo::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.ListMessage.ProductListInfo) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.Message.ListMessage.ProductSection productSections = 1; - total_size += 1UL * this->_internal_productsections_size(); - for (const auto& msg : this->_impl_.productsections_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional string businessOwnerJid = 3; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_businessownerjid()); - } - - // optional .proto.Message.ListMessage.ProductListHeaderImage headerImage = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.headerimage_); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ListMessage_ProductListInfo::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_ListMessage_ProductListInfo::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ListMessage_ProductListInfo::GetClassData() const { return &_class_data_; } - - -void Message_ListMessage_ProductListInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ListMessage.ProductListInfo) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.productsections_.MergeFrom(from._impl_.productsections_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_businessownerjid(from._internal_businessownerjid()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_headerimage()->::proto::Message_ListMessage_ProductListHeaderImage::MergeFrom( - from._internal_headerimage()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_ListMessage_ProductListInfo::CopyFrom(const Message_ListMessage_ProductListInfo& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ListMessage.ProductListInfo) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_ListMessage_ProductListInfo::IsInitialized() const { - return true; -} - -void Message_ListMessage_ProductListInfo::InternalSwap(Message_ListMessage_ProductListInfo* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.productsections_.InternalSwap(&other->_impl_.productsections_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.businessownerjid_, lhs_arena, - &other->_impl_.businessownerjid_, rhs_arena - ); - swap(_impl_.headerimage_, other->_impl_.headerimage_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_ListMessage_ProductListInfo::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[100]); -} - -// =================================================================== - -class Message_ListMessage_ProductSection::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_title(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -Message_ListMessage_ProductSection::Message_ListMessage_ProductSection(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.ListMessage.ProductSection) -} -Message_ListMessage_ProductSection::Message_ListMessage_ProductSection(const Message_ListMessage_ProductSection& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_ListMessage_ProductSection* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.products_){from._impl_.products_} - , decltype(_impl_.title_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.title_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.title_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_title()) { - _this->_impl_.title_.Set(from._internal_title(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.Message.ListMessage.ProductSection) -} - -inline void Message_ListMessage_ProductSection::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.products_){arena} - , decltype(_impl_.title_){} - }; - _impl_.title_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.title_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_ListMessage_ProductSection::~Message_ListMessage_ProductSection() { - // @@protoc_insertion_point(destructor:proto.Message.ListMessage.ProductSection) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_ListMessage_ProductSection::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.products_.~RepeatedPtrField(); - _impl_.title_.Destroy(); -} - -void Message_ListMessage_ProductSection::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_ListMessage_ProductSection::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.ListMessage.ProductSection) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.products_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.title_.ClearNonDefaultToEmpty(); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_ListMessage_ProductSection::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string title = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_title(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.ProductSection.title"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // repeated .proto.Message.ListMessage.Product products = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_products(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_ListMessage_ProductSection::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ListMessage.ProductSection) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string title = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_title().data(), static_cast(this->_internal_title().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ListMessage.ProductSection.title"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_title(), target); - } - - // repeated .proto.Message.ListMessage.Product products = 2; - for (unsigned i = 0, - n = static_cast(this->_internal_products_size()); i < n; i++) { - const auto& repfield = this->_internal_products(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ListMessage.ProductSection) - return target; -} - -size_t Message_ListMessage_ProductSection::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.ListMessage.ProductSection) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.Message.ListMessage.Product products = 2; - total_size += 1UL * this->_internal_products_size(); - for (const auto& msg : this->_impl_.products_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // optional string title = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_title()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ListMessage_ProductSection::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_ListMessage_ProductSection::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ListMessage_ProductSection::GetClassData() const { return &_class_data_; } - - -void Message_ListMessage_ProductSection::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ListMessage.ProductSection) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.products_.MergeFrom(from._impl_.products_); - if (from._internal_has_title()) { - _this->_internal_set_title(from._internal_title()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_ListMessage_ProductSection::CopyFrom(const Message_ListMessage_ProductSection& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ListMessage.ProductSection) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_ListMessage_ProductSection::IsInitialized() const { - return true; -} - -void Message_ListMessage_ProductSection::InternalSwap(Message_ListMessage_ProductSection* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.products_.InternalSwap(&other->_impl_.products_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.title_, lhs_arena, - &other->_impl_.title_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_ListMessage_ProductSection::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[101]); -} - -// =================================================================== - -class Message_ListMessage_Product::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_productid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -Message_ListMessage_Product::Message_ListMessage_Product(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.ListMessage.Product) -} -Message_ListMessage_Product::Message_ListMessage_Product(const Message_ListMessage_Product& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_ListMessage_Product* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.productid_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.productid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.productid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_productid()) { - _this->_impl_.productid_.Set(from._internal_productid(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.Message.ListMessage.Product) -} - -inline void Message_ListMessage_Product::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.productid_){} - }; - _impl_.productid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.productid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_ListMessage_Product::~Message_ListMessage_Product() { - // @@protoc_insertion_point(destructor:proto.Message.ListMessage.Product) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_ListMessage_Product::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.productid_.Destroy(); -} - -void Message_ListMessage_Product::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_ListMessage_Product::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.ListMessage.Product) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.productid_.ClearNonDefaultToEmpty(); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_ListMessage_Product::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string productId = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_productid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.Product.productId"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_ListMessage_Product::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ListMessage.Product) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string productId = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_productid().data(), static_cast(this->_internal_productid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ListMessage.Product.productId"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_productid(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ListMessage.Product) - return target; -} - -size_t Message_ListMessage_Product::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.ListMessage.Product) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional string productId = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_productid()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ListMessage_Product::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_ListMessage_Product::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ListMessage_Product::GetClassData() const { return &_class_data_; } - - -void Message_ListMessage_Product::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ListMessage.Product) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_productid()) { - _this->_internal_set_productid(from._internal_productid()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_ListMessage_Product::CopyFrom(const Message_ListMessage_Product& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ListMessage.Product) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_ListMessage_Product::IsInitialized() const { - return true; -} - -void Message_ListMessage_Product::InternalSwap(Message_ListMessage_Product* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.productid_, lhs_arena, - &other->_impl_.productid_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_ListMessage_Product::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[102]); -} - -// =================================================================== - -class Message_ListMessage_Row::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_title(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_description(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_rowid(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } -}; - -Message_ListMessage_Row::Message_ListMessage_Row(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.ListMessage.Row) -} -Message_ListMessage_Row::Message_ListMessage_Row(const Message_ListMessage_Row& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_ListMessage_Row* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.title_){} - , decltype(_impl_.description_){} - , decltype(_impl_.rowid_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.title_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.title_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_title()) { - _this->_impl_.title_.Set(from._internal_title(), - _this->GetArenaForAllocation()); - } - _impl_.description_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.description_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_description()) { - _this->_impl_.description_.Set(from._internal_description(), - _this->GetArenaForAllocation()); - } - _impl_.rowid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.rowid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_rowid()) { - _this->_impl_.rowid_.Set(from._internal_rowid(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.Message.ListMessage.Row) -} - -inline void Message_ListMessage_Row::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.title_){} - , decltype(_impl_.description_){} - , decltype(_impl_.rowid_){} - }; - _impl_.title_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.title_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.description_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.description_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.rowid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.rowid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_ListMessage_Row::~Message_ListMessage_Row() { - // @@protoc_insertion_point(destructor:proto.Message.ListMessage.Row) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_ListMessage_Row::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.title_.Destroy(); - _impl_.description_.Destroy(); - _impl_.rowid_.Destroy(); -} - -void Message_ListMessage_Row::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_ListMessage_Row::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.ListMessage.Row) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _impl_.title_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.description_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.rowid_.ClearNonDefaultToEmpty(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_ListMessage_Row::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string title = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_title(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.Row.title"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string description = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_description(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.Row.description"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string rowId = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_rowid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.Row.rowId"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_ListMessage_Row::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ListMessage.Row) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string title = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_title().data(), static_cast(this->_internal_title().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ListMessage.Row.title"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_title(), target); - } - - // optional string description = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_description().data(), static_cast(this->_internal_description().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ListMessage.Row.description"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_description(), target); - } - - // optional string rowId = 3; - if (cached_has_bits & 0x00000004u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_rowid().data(), static_cast(this->_internal_rowid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ListMessage.Row.rowId"); - target = stream->WriteStringMaybeAliased( - 3, this->_internal_rowid(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ListMessage.Row) - return target; -} - -size_t Message_ListMessage_Row::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.ListMessage.Row) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional string title = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_title()); - } - - // optional string description = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_description()); - } - - // optional string rowId = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_rowid()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ListMessage_Row::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_ListMessage_Row::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ListMessage_Row::GetClassData() const { return &_class_data_; } - - -void Message_ListMessage_Row::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ListMessage.Row) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_title(from._internal_title()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_description(from._internal_description()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_rowid(from._internal_rowid()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_ListMessage_Row::CopyFrom(const Message_ListMessage_Row& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ListMessage.Row) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_ListMessage_Row::IsInitialized() const { - return true; -} - -void Message_ListMessage_Row::InternalSwap(Message_ListMessage_Row* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.title_, lhs_arena, - &other->_impl_.title_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.description_, lhs_arena, - &other->_impl_.description_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.rowid_, lhs_arena, - &other->_impl_.rowid_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_ListMessage_Row::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[103]); -} - -// =================================================================== - -class Message_ListMessage_Section::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_title(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -Message_ListMessage_Section::Message_ListMessage_Section(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.ListMessage.Section) -} -Message_ListMessage_Section::Message_ListMessage_Section(const Message_ListMessage_Section& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_ListMessage_Section* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.rows_){from._impl_.rows_} - , decltype(_impl_.title_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.title_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.title_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_title()) { - _this->_impl_.title_.Set(from._internal_title(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.Message.ListMessage.Section) -} - -inline void Message_ListMessage_Section::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.rows_){arena} - , decltype(_impl_.title_){} - }; - _impl_.title_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.title_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_ListMessage_Section::~Message_ListMessage_Section() { - // @@protoc_insertion_point(destructor:proto.Message.ListMessage.Section) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_ListMessage_Section::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.rows_.~RepeatedPtrField(); - _impl_.title_.Destroy(); -} - -void Message_ListMessage_Section::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_ListMessage_Section::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.ListMessage.Section) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.rows_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.title_.ClearNonDefaultToEmpty(); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_ListMessage_Section::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string title = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_title(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.Section.title"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // repeated .proto.Message.ListMessage.Row rows = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_rows(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_ListMessage_Section::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ListMessage.Section) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string title = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_title().data(), static_cast(this->_internal_title().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ListMessage.Section.title"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_title(), target); - } - - // repeated .proto.Message.ListMessage.Row rows = 2; - for (unsigned i = 0, - n = static_cast(this->_internal_rows_size()); i < n; i++) { - const auto& repfield = this->_internal_rows(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ListMessage.Section) - return target; -} - -size_t Message_ListMessage_Section::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.ListMessage.Section) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.Message.ListMessage.Row rows = 2; - total_size += 1UL * this->_internal_rows_size(); - for (const auto& msg : this->_impl_.rows_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // optional string title = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_title()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ListMessage_Section::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_ListMessage_Section::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ListMessage_Section::GetClassData() const { return &_class_data_; } - - -void Message_ListMessage_Section::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ListMessage.Section) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.rows_.MergeFrom(from._impl_.rows_); - if (from._internal_has_title()) { - _this->_internal_set_title(from._internal_title()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_ListMessage_Section::CopyFrom(const Message_ListMessage_Section& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ListMessage.Section) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_ListMessage_Section::IsInitialized() const { - return true; -} - -void Message_ListMessage_Section::InternalSwap(Message_ListMessage_Section* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.rows_.InternalSwap(&other->_impl_.rows_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.title_, lhs_arena, - &other->_impl_.title_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_ListMessage_Section::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[104]); -} - -// =================================================================== - -class Message_ListMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_title(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_description(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_buttontext(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_listtype(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static const ::proto::Message_ListMessage_ProductListInfo& productlistinfo(const Message_ListMessage* msg); - static void set_has_productlistinfo(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_footertext(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static const ::proto::ContextInfo& contextinfo(const Message_ListMessage* msg); - static void set_has_contextinfo(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } -}; - -const ::proto::Message_ListMessage_ProductListInfo& -Message_ListMessage::_Internal::productlistinfo(const Message_ListMessage* msg) { - return *msg->_impl_.productlistinfo_; -} -const ::proto::ContextInfo& -Message_ListMessage::_Internal::contextinfo(const Message_ListMessage* msg) { - return *msg->_impl_.contextinfo_; -} -Message_ListMessage::Message_ListMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.ListMessage) -} -Message_ListMessage::Message_ListMessage(const Message_ListMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_ListMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.sections_){from._impl_.sections_} - , decltype(_impl_.title_){} - , decltype(_impl_.description_){} - , decltype(_impl_.buttontext_){} - , decltype(_impl_.footertext_){} - , decltype(_impl_.productlistinfo_){nullptr} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.listtype_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.title_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.title_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_title()) { - _this->_impl_.title_.Set(from._internal_title(), - _this->GetArenaForAllocation()); - } - _impl_.description_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.description_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_description()) { - _this->_impl_.description_.Set(from._internal_description(), - _this->GetArenaForAllocation()); - } - _impl_.buttontext_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.buttontext_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_buttontext()) { - _this->_impl_.buttontext_.Set(from._internal_buttontext(), - _this->GetArenaForAllocation()); - } - _impl_.footertext_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.footertext_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_footertext()) { - _this->_impl_.footertext_.Set(from._internal_footertext(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_productlistinfo()) { - _this->_impl_.productlistinfo_ = new ::proto::Message_ListMessage_ProductListInfo(*from._impl_.productlistinfo_); - } - if (from._internal_has_contextinfo()) { - _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); - } - _this->_impl_.listtype_ = from._impl_.listtype_; - // @@protoc_insertion_point(copy_constructor:proto.Message.ListMessage) -} - -inline void Message_ListMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.sections_){arena} - , decltype(_impl_.title_){} - , decltype(_impl_.description_){} - , decltype(_impl_.buttontext_){} - , decltype(_impl_.footertext_){} - , decltype(_impl_.productlistinfo_){nullptr} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.listtype_){0} - }; - _impl_.title_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.title_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.description_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.description_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.buttontext_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.buttontext_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.footertext_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.footertext_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_ListMessage::~Message_ListMessage() { - // @@protoc_insertion_point(destructor:proto.Message.ListMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_ListMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.sections_.~RepeatedPtrField(); - _impl_.title_.Destroy(); - _impl_.description_.Destroy(); - _impl_.buttontext_.Destroy(); - _impl_.footertext_.Destroy(); - if (this != internal_default_instance()) delete _impl_.productlistinfo_; - if (this != internal_default_instance()) delete _impl_.contextinfo_; -} - -void Message_ListMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_ListMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.ListMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.sections_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000003fu) { - if (cached_has_bits & 0x00000001u) { - _impl_.title_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.description_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.buttontext_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000008u) { - _impl_.footertext_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000010u) { - GOOGLE_DCHECK(_impl_.productlistinfo_ != nullptr); - _impl_.productlistinfo_->Clear(); - } - if (cached_has_bits & 0x00000020u) { - GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); - _impl_.contextinfo_->Clear(); - } - } - _impl_.listtype_ = 0; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_ListMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string title = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_title(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.title"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string description = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_description(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.description"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string buttonText = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_buttontext(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.buttonText"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.Message.ListMessage.ListType listType = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::Message_ListMessage_ListType_IsValid(val))) { - _internal_set_listtype(static_cast<::proto::Message_ListMessage_ListType>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // repeated .proto.Message.ListMessage.Section sections = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_sections(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr)); - } else - goto handle_unusual; - continue; - // optional .proto.Message.ListMessage.ProductListInfo productListInfo = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - ptr = ctx->ParseMessage(_internal_mutable_productlistinfo(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string footerText = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - auto str = _internal_mutable_footertext(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ListMessage.footerText"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.ContextInfo contextInfo = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { - ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_ListMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ListMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string title = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_title().data(), static_cast(this->_internal_title().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ListMessage.title"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_title(), target); - } - - // optional string description = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_description().data(), static_cast(this->_internal_description().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ListMessage.description"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_description(), target); - } - - // optional string buttonText = 3; - if (cached_has_bits & 0x00000004u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_buttontext().data(), static_cast(this->_internal_buttontext().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ListMessage.buttonText"); - target = stream->WriteStringMaybeAliased( - 3, this->_internal_buttontext(), target); - } - - // optional .proto.Message.ListMessage.ListType listType = 4; - if (cached_has_bits & 0x00000040u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 4, this->_internal_listtype(), target); - } - - // repeated .proto.Message.ListMessage.Section sections = 5; - for (unsigned i = 0, - n = static_cast(this->_internal_sections_size()); i < n; i++) { - const auto& repfield = this->_internal_sections(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(5, repfield, repfield.GetCachedSize(), target, stream); - } - - // optional .proto.Message.ListMessage.ProductListInfo productListInfo = 6; - if (cached_has_bits & 0x00000010u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(6, _Internal::productlistinfo(this), - _Internal::productlistinfo(this).GetCachedSize(), target, stream); - } - - // optional string footerText = 7; - if (cached_has_bits & 0x00000008u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_footertext().data(), static_cast(this->_internal_footertext().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ListMessage.footerText"); - target = stream->WriteStringMaybeAliased( - 7, this->_internal_footertext(), target); - } - - // optional .proto.ContextInfo contextInfo = 8; - if (cached_has_bits & 0x00000020u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(8, _Internal::contextinfo(this), - _Internal::contextinfo(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ListMessage) - return target; -} - -size_t Message_ListMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.ListMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.Message.ListMessage.Section sections = 5; - total_size += 1UL * this->_internal_sections_size(); - for (const auto& msg : this->_impl_.sections_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000007fu) { - // optional string title = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_title()); - } - - // optional string description = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_description()); - } - - // optional string buttonText = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_buttontext()); - } - - // optional string footerText = 7; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_footertext()); - } - - // optional .proto.Message.ListMessage.ProductListInfo productListInfo = 6; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.productlistinfo_); - } - - // optional .proto.ContextInfo contextInfo = 8; - if (cached_has_bits & 0x00000020u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.contextinfo_); - } - - // optional .proto.Message.ListMessage.ListType listType = 4; - if (cached_has_bits & 0x00000040u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_listtype()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ListMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_ListMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ListMessage::GetClassData() const { return &_class_data_; } - - -void Message_ListMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ListMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.sections_.MergeFrom(from._impl_.sections_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000007fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_title(from._internal_title()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_description(from._internal_description()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_buttontext(from._internal_buttontext()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_set_footertext(from._internal_footertext()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_mutable_productlistinfo()->::proto::Message_ListMessage_ProductListInfo::MergeFrom( - from._internal_productlistinfo()); - } - if (cached_has_bits & 0x00000020u) { - _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( - from._internal_contextinfo()); - } - if (cached_has_bits & 0x00000040u) { - _this->_impl_.listtype_ = from._impl_.listtype_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_ListMessage::CopyFrom(const Message_ListMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ListMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_ListMessage::IsInitialized() const { - return true; -} - -void Message_ListMessage::InternalSwap(Message_ListMessage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.sections_.InternalSwap(&other->_impl_.sections_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.title_, lhs_arena, - &other->_impl_.title_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.description_, lhs_arena, - &other->_impl_.description_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.buttontext_, lhs_arena, - &other->_impl_.buttontext_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.footertext_, lhs_arena, - &other->_impl_.footertext_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_ListMessage, _impl_.listtype_) - + sizeof(Message_ListMessage::_impl_.listtype_) - - PROTOBUF_FIELD_OFFSET(Message_ListMessage, _impl_.productlistinfo_)>( - reinterpret_cast(&_impl_.productlistinfo_), - reinterpret_cast(&other->_impl_.productlistinfo_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_ListMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[105]); -} - -// =================================================================== - -class Message_ListResponseMessage_SingleSelectReply::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_selectedrowid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -Message_ListResponseMessage_SingleSelectReply::Message_ListResponseMessage_SingleSelectReply(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.ListResponseMessage.SingleSelectReply) -} -Message_ListResponseMessage_SingleSelectReply::Message_ListResponseMessage_SingleSelectReply(const Message_ListResponseMessage_SingleSelectReply& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_ListResponseMessage_SingleSelectReply* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.selectedrowid_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.selectedrowid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.selectedrowid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_selectedrowid()) { - _this->_impl_.selectedrowid_.Set(from._internal_selectedrowid(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.Message.ListResponseMessage.SingleSelectReply) -} - -inline void Message_ListResponseMessage_SingleSelectReply::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.selectedrowid_){} - }; - _impl_.selectedrowid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.selectedrowid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_ListResponseMessage_SingleSelectReply::~Message_ListResponseMessage_SingleSelectReply() { - // @@protoc_insertion_point(destructor:proto.Message.ListResponseMessage.SingleSelectReply) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_ListResponseMessage_SingleSelectReply::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.selectedrowid_.Destroy(); -} - -void Message_ListResponseMessage_SingleSelectReply::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_ListResponseMessage_SingleSelectReply::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.ListResponseMessage.SingleSelectReply) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.selectedrowid_.ClearNonDefaultToEmpty(); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_ListResponseMessage_SingleSelectReply::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string selectedRowId = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_selectedrowid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ListResponseMessage.SingleSelectReply.selectedRowId"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_ListResponseMessage_SingleSelectReply::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ListResponseMessage.SingleSelectReply) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string selectedRowId = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_selectedrowid().data(), static_cast(this->_internal_selectedrowid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ListResponseMessage.SingleSelectReply.selectedRowId"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_selectedrowid(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ListResponseMessage.SingleSelectReply) - return target; -} - -size_t Message_ListResponseMessage_SingleSelectReply::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.ListResponseMessage.SingleSelectReply) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional string selectedRowId = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_selectedrowid()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ListResponseMessage_SingleSelectReply::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_ListResponseMessage_SingleSelectReply::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ListResponseMessage_SingleSelectReply::GetClassData() const { return &_class_data_; } - - -void Message_ListResponseMessage_SingleSelectReply::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ListResponseMessage.SingleSelectReply) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_selectedrowid()) { - _this->_internal_set_selectedrowid(from._internal_selectedrowid()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_ListResponseMessage_SingleSelectReply::CopyFrom(const Message_ListResponseMessage_SingleSelectReply& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ListResponseMessage.SingleSelectReply) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_ListResponseMessage_SingleSelectReply::IsInitialized() const { - return true; -} - -void Message_ListResponseMessage_SingleSelectReply::InternalSwap(Message_ListResponseMessage_SingleSelectReply* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.selectedrowid_, lhs_arena, - &other->_impl_.selectedrowid_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_ListResponseMessage_SingleSelectReply::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[106]); -} - -// =================================================================== - -class Message_ListResponseMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_title(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_listtype(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static const ::proto::Message_ListResponseMessage_SingleSelectReply& singleselectreply(const Message_ListResponseMessage* msg); - static void set_has_singleselectreply(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static const ::proto::ContextInfo& contextinfo(const Message_ListResponseMessage* msg); - static void set_has_contextinfo(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_description(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -const ::proto::Message_ListResponseMessage_SingleSelectReply& -Message_ListResponseMessage::_Internal::singleselectreply(const Message_ListResponseMessage* msg) { - return *msg->_impl_.singleselectreply_; -} -const ::proto::ContextInfo& -Message_ListResponseMessage::_Internal::contextinfo(const Message_ListResponseMessage* msg) { - return *msg->_impl_.contextinfo_; -} -Message_ListResponseMessage::Message_ListResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.ListResponseMessage) -} -Message_ListResponseMessage::Message_ListResponseMessage(const Message_ListResponseMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_ListResponseMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.title_){} - , decltype(_impl_.description_){} - , decltype(_impl_.singleselectreply_){nullptr} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.listtype_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.title_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.title_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_title()) { - _this->_impl_.title_.Set(from._internal_title(), - _this->GetArenaForAllocation()); - } - _impl_.description_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.description_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_description()) { - _this->_impl_.description_.Set(from._internal_description(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_singleselectreply()) { - _this->_impl_.singleselectreply_ = new ::proto::Message_ListResponseMessage_SingleSelectReply(*from._impl_.singleselectreply_); - } - if (from._internal_has_contextinfo()) { - _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); - } - _this->_impl_.listtype_ = from._impl_.listtype_; - // @@protoc_insertion_point(copy_constructor:proto.Message.ListResponseMessage) -} - -inline void Message_ListResponseMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.title_){} - , decltype(_impl_.description_){} - , decltype(_impl_.singleselectreply_){nullptr} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.listtype_){0} - }; - _impl_.title_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.title_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.description_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.description_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_ListResponseMessage::~Message_ListResponseMessage() { - // @@protoc_insertion_point(destructor:proto.Message.ListResponseMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_ListResponseMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.title_.Destroy(); - _impl_.description_.Destroy(); - if (this != internal_default_instance()) delete _impl_.singleselectreply_; - if (this != internal_default_instance()) delete _impl_.contextinfo_; -} - -void Message_ListResponseMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_ListResponseMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.ListResponseMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - if (cached_has_bits & 0x00000001u) { - _impl_.title_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.description_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - GOOGLE_DCHECK(_impl_.singleselectreply_ != nullptr); - _impl_.singleselectreply_->Clear(); - } - if (cached_has_bits & 0x00000008u) { - GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); - _impl_.contextinfo_->Clear(); - } - } - _impl_.listtype_ = 0; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_ListResponseMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string title = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_title(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ListResponseMessage.title"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.Message.ListResponseMessage.ListType listType = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::Message_ListResponseMessage_ListType_IsValid(val))) { - _internal_set_listtype(static_cast<::proto::Message_ListResponseMessage_ListType>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.Message.ListResponseMessage.SingleSelectReply singleSelectReply = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_singleselectreply(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.ContextInfo contextInfo = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string description = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - auto str = _internal_mutable_description(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ListResponseMessage.description"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_ListResponseMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ListResponseMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string title = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_title().data(), static_cast(this->_internal_title().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ListResponseMessage.title"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_title(), target); - } - - // optional .proto.Message.ListResponseMessage.ListType listType = 2; - if (cached_has_bits & 0x00000010u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 2, this->_internal_listtype(), target); - } - - // optional .proto.Message.ListResponseMessage.SingleSelectReply singleSelectReply = 3; - if (cached_has_bits & 0x00000004u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, _Internal::singleselectreply(this), - _Internal::singleselectreply(this).GetCachedSize(), target, stream); - } - - // optional .proto.ContextInfo contextInfo = 4; - if (cached_has_bits & 0x00000008u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(4, _Internal::contextinfo(this), - _Internal::contextinfo(this).GetCachedSize(), target, stream); - } - - // optional string description = 5; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_description().data(), static_cast(this->_internal_description().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ListResponseMessage.description"); - target = stream->WriteStringMaybeAliased( - 5, this->_internal_description(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ListResponseMessage) - return target; -} - -size_t Message_ListResponseMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.ListResponseMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { - // optional string title = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_title()); - } - - // optional string description = 5; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_description()); - } - - // optional .proto.Message.ListResponseMessage.SingleSelectReply singleSelectReply = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.singleselectreply_); - } - - // optional .proto.ContextInfo contextInfo = 4; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.contextinfo_); - } - - // optional .proto.Message.ListResponseMessage.ListType listType = 2; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_listtype()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ListResponseMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_ListResponseMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ListResponseMessage::GetClassData() const { return &_class_data_; } - - -void Message_ListResponseMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ListResponseMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_title(from._internal_title()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_description(from._internal_description()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_mutable_singleselectreply()->::proto::Message_ListResponseMessage_SingleSelectReply::MergeFrom( - from._internal_singleselectreply()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( - from._internal_contextinfo()); - } - if (cached_has_bits & 0x00000010u) { - _this->_impl_.listtype_ = from._impl_.listtype_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_ListResponseMessage::CopyFrom(const Message_ListResponseMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ListResponseMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_ListResponseMessage::IsInitialized() const { - return true; -} - -void Message_ListResponseMessage::InternalSwap(Message_ListResponseMessage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.title_, lhs_arena, - &other->_impl_.title_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.description_, lhs_arena, - &other->_impl_.description_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_ListResponseMessage, _impl_.listtype_) - + sizeof(Message_ListResponseMessage::_impl_.listtype_) - - PROTOBUF_FIELD_OFFSET(Message_ListResponseMessage, _impl_.singleselectreply_)>( - reinterpret_cast(&_impl_.singleselectreply_), - reinterpret_cast(&other->_impl_.singleselectreply_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_ListResponseMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[107]); -} - -// =================================================================== - -class Message_LiveLocationMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_degreeslatitude(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_degreeslongitude(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_accuracyinmeters(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static void set_has_speedinmps(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static void set_has_degreesclockwisefrommagneticnorth(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } - static void set_has_caption(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_sequencenumber(HasBits* has_bits) { - (*has_bits)[0] |= 512u; - } - static void set_has_timeoffset(HasBits* has_bits) { - (*has_bits)[0] |= 256u; - } - static void set_has_jpegthumbnail(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::proto::ContextInfo& contextinfo(const Message_LiveLocationMessage* msg); - static void set_has_contextinfo(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } -}; - -const ::proto::ContextInfo& -Message_LiveLocationMessage::_Internal::contextinfo(const Message_LiveLocationMessage* msg) { - return *msg->_impl_.contextinfo_; -} -Message_LiveLocationMessage::Message_LiveLocationMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.LiveLocationMessage) -} -Message_LiveLocationMessage::Message_LiveLocationMessage(const Message_LiveLocationMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_LiveLocationMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.caption_){} - , decltype(_impl_.jpegthumbnail_){} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.degreeslatitude_){} - , decltype(_impl_.degreeslongitude_){} - , decltype(_impl_.accuracyinmeters_){} - , decltype(_impl_.speedinmps_){} - , decltype(_impl_.degreesclockwisefrommagneticnorth_){} - , decltype(_impl_.timeoffset_){} - , decltype(_impl_.sequencenumber_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.caption_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.caption_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_caption()) { - _this->_impl_.caption_.Set(from._internal_caption(), - _this->GetArenaForAllocation()); - } - _impl_.jpegthumbnail_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_jpegthumbnail()) { - _this->_impl_.jpegthumbnail_.Set(from._internal_jpegthumbnail(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_contextinfo()) { - _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); - } - ::memcpy(&_impl_.degreeslatitude_, &from._impl_.degreeslatitude_, - static_cast(reinterpret_cast(&_impl_.sequencenumber_) - - reinterpret_cast(&_impl_.degreeslatitude_)) + sizeof(_impl_.sequencenumber_)); - // @@protoc_insertion_point(copy_constructor:proto.Message.LiveLocationMessage) -} - -inline void Message_LiveLocationMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.caption_){} - , decltype(_impl_.jpegthumbnail_){} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.degreeslatitude_){0} - , decltype(_impl_.degreeslongitude_){0} - , decltype(_impl_.accuracyinmeters_){0u} - , decltype(_impl_.speedinmps_){0} - , decltype(_impl_.degreesclockwisefrommagneticnorth_){0u} - , decltype(_impl_.timeoffset_){0u} - , decltype(_impl_.sequencenumber_){int64_t{0}} - }; - _impl_.caption_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.caption_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.jpegthumbnail_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_LiveLocationMessage::~Message_LiveLocationMessage() { - // @@protoc_insertion_point(destructor:proto.Message.LiveLocationMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_LiveLocationMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.caption_.Destroy(); - _impl_.jpegthumbnail_.Destroy(); - if (this != internal_default_instance()) delete _impl_.contextinfo_; -} - -void Message_LiveLocationMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_LiveLocationMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.LiveLocationMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _impl_.caption_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.jpegthumbnail_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); - _impl_.contextinfo_->Clear(); - } - } - if (cached_has_bits & 0x000000f8u) { - ::memset(&_impl_.degreeslatitude_, 0, static_cast( - reinterpret_cast(&_impl_.degreesclockwisefrommagneticnorth_) - - reinterpret_cast(&_impl_.degreeslatitude_)) + sizeof(_impl_.degreesclockwisefrommagneticnorth_)); - } - if (cached_has_bits & 0x00000300u) { - ::memset(&_impl_.timeoffset_, 0, static_cast( - reinterpret_cast(&_impl_.sequencenumber_) - - reinterpret_cast(&_impl_.timeoffset_)) + sizeof(_impl_.sequencenumber_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_LiveLocationMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional double degreesLatitude = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 9)) { - _Internal::set_has_degreeslatitude(&has_bits); - _impl_.degreeslatitude_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); - ptr += sizeof(double); - } else - goto handle_unusual; - continue; - // optional double degreesLongitude = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 17)) { - _Internal::set_has_degreeslongitude(&has_bits); - _impl_.degreeslongitude_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); - ptr += sizeof(double); - } else - goto handle_unusual; - continue; - // optional uint32 accuracyInMeters = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_accuracyinmeters(&has_bits); - _impl_.accuracyinmeters_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional float speedInMps = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 37)) { - _Internal::set_has_speedinmps(&has_bits); - _impl_.speedinmps_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); - ptr += sizeof(float); - } else - goto handle_unusual; - continue; - // optional uint32 degreesClockwiseFromMagneticNorth = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { - _Internal::set_has_degreesclockwisefrommagneticnorth(&has_bits); - _impl_.degreesclockwisefrommagneticnorth_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string caption = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - auto str = _internal_mutable_caption(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.LiveLocationMessage.caption"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional int64 sequenceNumber = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { - _Internal::set_has_sequencenumber(&has_bits); - _impl_.sequencenumber_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 timeOffset = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { - _Internal::set_has_timeoffset(&has_bits); - _impl_.timeoffset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes jpegThumbnail = 16; - case 16: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { - auto str = _internal_mutable_jpegthumbnail(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.ContextInfo contextInfo = 17; - case 17: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { - ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_LiveLocationMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.LiveLocationMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional double degreesLatitude = 1; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteDoubleToArray(1, this->_internal_degreeslatitude(), target); - } - - // optional double degreesLongitude = 2; - if (cached_has_bits & 0x00000010u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteDoubleToArray(2, this->_internal_degreeslongitude(), target); - } - - // optional uint32 accuracyInMeters = 3; - if (cached_has_bits & 0x00000020u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_accuracyinmeters(), target); - } - - // optional float speedInMps = 4; - if (cached_has_bits & 0x00000040u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteFloatToArray(4, this->_internal_speedinmps(), target); - } - - // optional uint32 degreesClockwiseFromMagneticNorth = 5; - if (cached_has_bits & 0x00000080u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_degreesclockwisefrommagneticnorth(), target); - } - - // optional string caption = 6; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_caption().data(), static_cast(this->_internal_caption().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.LiveLocationMessage.caption"); - target = stream->WriteStringMaybeAliased( - 6, this->_internal_caption(), target); - } - - // optional int64 sequenceNumber = 7; - if (cached_has_bits & 0x00000200u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(7, this->_internal_sequencenumber(), target); - } - - // optional uint32 timeOffset = 8; - if (cached_has_bits & 0x00000100u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(8, this->_internal_timeoffset(), target); - } - - // optional bytes jpegThumbnail = 16; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 16, this->_internal_jpegthumbnail(), target); - } - - // optional .proto.ContextInfo contextInfo = 17; - if (cached_has_bits & 0x00000004u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(17, _Internal::contextinfo(this), - _Internal::contextinfo(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.LiveLocationMessage) - return target; -} - -size_t Message_LiveLocationMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.LiveLocationMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional string caption = 6; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_caption()); - } - - // optional bytes jpegThumbnail = 16; - if (cached_has_bits & 0x00000002u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_jpegthumbnail()); - } - - // optional .proto.ContextInfo contextInfo = 17; - if (cached_has_bits & 0x00000004u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.contextinfo_); - } - - // optional double degreesLatitude = 1; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + 8; - } - - // optional double degreesLongitude = 2; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + 8; - } - - // optional uint32 accuracyInMeters = 3; - if (cached_has_bits & 0x00000020u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_accuracyinmeters()); - } - - // optional float speedInMps = 4; - if (cached_has_bits & 0x00000040u) { - total_size += 1 + 4; - } - - // optional uint32 degreesClockwiseFromMagneticNorth = 5; - if (cached_has_bits & 0x00000080u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_degreesclockwisefrommagneticnorth()); - } - - } - if (cached_has_bits & 0x00000300u) { - // optional uint32 timeOffset = 8; - if (cached_has_bits & 0x00000100u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_timeoffset()); - } - - // optional int64 sequenceNumber = 7; - if (cached_has_bits & 0x00000200u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_sequencenumber()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_LiveLocationMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_LiveLocationMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_LiveLocationMessage::GetClassData() const { return &_class_data_; } - - -void Message_LiveLocationMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.LiveLocationMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_caption(from._internal_caption()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( - from._internal_contextinfo()); - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.degreeslatitude_ = from._impl_.degreeslatitude_; - } - if (cached_has_bits & 0x00000010u) { - _this->_impl_.degreeslongitude_ = from._impl_.degreeslongitude_; - } - if (cached_has_bits & 0x00000020u) { - _this->_impl_.accuracyinmeters_ = from._impl_.accuracyinmeters_; - } - if (cached_has_bits & 0x00000040u) { - _this->_impl_.speedinmps_ = from._impl_.speedinmps_; - } - if (cached_has_bits & 0x00000080u) { - _this->_impl_.degreesclockwisefrommagneticnorth_ = from._impl_.degreesclockwisefrommagneticnorth_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - if (cached_has_bits & 0x00000300u) { - if (cached_has_bits & 0x00000100u) { - _this->_impl_.timeoffset_ = from._impl_.timeoffset_; - } - if (cached_has_bits & 0x00000200u) { - _this->_impl_.sequencenumber_ = from._impl_.sequencenumber_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_LiveLocationMessage::CopyFrom(const Message_LiveLocationMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.LiveLocationMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_LiveLocationMessage::IsInitialized() const { - return true; -} - -void Message_LiveLocationMessage::InternalSwap(Message_LiveLocationMessage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.caption_, lhs_arena, - &other->_impl_.caption_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.jpegthumbnail_, lhs_arena, - &other->_impl_.jpegthumbnail_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_LiveLocationMessage, _impl_.sequencenumber_) - + sizeof(Message_LiveLocationMessage::_impl_.sequencenumber_) - - PROTOBUF_FIELD_OFFSET(Message_LiveLocationMessage, _impl_.contextinfo_)>( - reinterpret_cast(&_impl_.contextinfo_), - reinterpret_cast(&other->_impl_.contextinfo_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_LiveLocationMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[108]); -} - -// =================================================================== - -class Message_LocationMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_degreeslatitude(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static void set_has_degreeslongitude(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } - static void set_has_name(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_address(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_url(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_islive(HasBits* has_bits) { - (*has_bits)[0] |= 256u; - } - static void set_has_accuracyinmeters(HasBits* has_bits) { - (*has_bits)[0] |= 512u; - } - static void set_has_speedinmps(HasBits* has_bits) { - (*has_bits)[0] |= 1024u; - } - static void set_has_degreesclockwisefrommagneticnorth(HasBits* has_bits) { - (*has_bits)[0] |= 2048u; - } - static void set_has_comment(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_jpegthumbnail(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static const ::proto::ContextInfo& contextinfo(const Message_LocationMessage* msg); - static void set_has_contextinfo(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } -}; - -const ::proto::ContextInfo& -Message_LocationMessage::_Internal::contextinfo(const Message_LocationMessage* msg) { - return *msg->_impl_.contextinfo_; -} -Message_LocationMessage::Message_LocationMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.LocationMessage) -} -Message_LocationMessage::Message_LocationMessage(const Message_LocationMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_LocationMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.name_){} - , decltype(_impl_.address_){} - , decltype(_impl_.url_){} - , decltype(_impl_.comment_){} - , decltype(_impl_.jpegthumbnail_){} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.degreeslatitude_){} - , decltype(_impl_.degreeslongitude_){} - , decltype(_impl_.islive_){} - , decltype(_impl_.accuracyinmeters_){} - , decltype(_impl_.speedinmps_){} - , decltype(_impl_.degreesclockwisefrommagneticnorth_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.name_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.name_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_name()) { - _this->_impl_.name_.Set(from._internal_name(), - _this->GetArenaForAllocation()); - } - _impl_.address_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.address_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_address()) { - _this->_impl_.address_.Set(from._internal_address(), - _this->GetArenaForAllocation()); - } - _impl_.url_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.url_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_url()) { - _this->_impl_.url_.Set(from._internal_url(), - _this->GetArenaForAllocation()); - } - _impl_.comment_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.comment_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_comment()) { - _this->_impl_.comment_.Set(from._internal_comment(), - _this->GetArenaForAllocation()); - } - _impl_.jpegthumbnail_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_jpegthumbnail()) { - _this->_impl_.jpegthumbnail_.Set(from._internal_jpegthumbnail(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_contextinfo()) { - _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); - } - ::memcpy(&_impl_.degreeslatitude_, &from._impl_.degreeslatitude_, - static_cast(reinterpret_cast(&_impl_.degreesclockwisefrommagneticnorth_) - - reinterpret_cast(&_impl_.degreeslatitude_)) + sizeof(_impl_.degreesclockwisefrommagneticnorth_)); - // @@protoc_insertion_point(copy_constructor:proto.Message.LocationMessage) -} - -inline void Message_LocationMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.name_){} - , decltype(_impl_.address_){} - , decltype(_impl_.url_){} - , decltype(_impl_.comment_){} - , decltype(_impl_.jpegthumbnail_){} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.degreeslatitude_){0} - , decltype(_impl_.degreeslongitude_){0} - , decltype(_impl_.islive_){false} - , decltype(_impl_.accuracyinmeters_){0u} - , decltype(_impl_.speedinmps_){0} - , decltype(_impl_.degreesclockwisefrommagneticnorth_){0u} - }; - _impl_.name_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.name_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.address_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.address_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.url_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.url_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.comment_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.comment_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.jpegthumbnail_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_LocationMessage::~Message_LocationMessage() { - // @@protoc_insertion_point(destructor:proto.Message.LocationMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_LocationMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.name_.Destroy(); - _impl_.address_.Destroy(); - _impl_.url_.Destroy(); - _impl_.comment_.Destroy(); - _impl_.jpegthumbnail_.Destroy(); - if (this != internal_default_instance()) delete _impl_.contextinfo_; -} - -void Message_LocationMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_LocationMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.LocationMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000003fu) { - if (cached_has_bits & 0x00000001u) { - _impl_.name_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.address_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.url_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000008u) { - _impl_.comment_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000010u) { - _impl_.jpegthumbnail_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000020u) { - GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); - _impl_.contextinfo_->Clear(); - } - } - if (cached_has_bits & 0x000000c0u) { - ::memset(&_impl_.degreeslatitude_, 0, static_cast( - reinterpret_cast(&_impl_.degreeslongitude_) - - reinterpret_cast(&_impl_.degreeslatitude_)) + sizeof(_impl_.degreeslongitude_)); - } - if (cached_has_bits & 0x00000f00u) { - ::memset(&_impl_.islive_, 0, static_cast( - reinterpret_cast(&_impl_.degreesclockwisefrommagneticnorth_) - - reinterpret_cast(&_impl_.islive_)) + sizeof(_impl_.degreesclockwisefrommagneticnorth_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_LocationMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional double degreesLatitude = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 9)) { - _Internal::set_has_degreeslatitude(&has_bits); - _impl_.degreeslatitude_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); - ptr += sizeof(double); - } else - goto handle_unusual; - continue; - // optional double degreesLongitude = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 17)) { - _Internal::set_has_degreeslongitude(&has_bits); - _impl_.degreeslongitude_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); - ptr += sizeof(double); - } else - goto handle_unusual; - continue; - // optional string name = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_name(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.LocationMessage.name"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string address = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - auto str = _internal_mutable_address(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.LocationMessage.address"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string url = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - auto str = _internal_mutable_url(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.LocationMessage.url"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bool isLive = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { - _Internal::set_has_islive(&has_bits); - _impl_.islive_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 accuracyInMeters = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { - _Internal::set_has_accuracyinmeters(&has_bits); - _impl_.accuracyinmeters_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional float speedInMps = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 69)) { - _Internal::set_has_speedinmps(&has_bits); - _impl_.speedinmps_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); - ptr += sizeof(float); - } else - goto handle_unusual; - continue; - // optional uint32 degreesClockwiseFromMagneticNorth = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { - _Internal::set_has_degreesclockwisefrommagneticnorth(&has_bits); - _impl_.degreesclockwisefrommagneticnorth_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string comment = 11; - case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { - auto str = _internal_mutable_comment(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.LocationMessage.comment"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bytes jpegThumbnail = 16; - case 16: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { - auto str = _internal_mutable_jpegthumbnail(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.ContextInfo contextInfo = 17; - case 17: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { - ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_LocationMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.LocationMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional double degreesLatitude = 1; - if (cached_has_bits & 0x00000040u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteDoubleToArray(1, this->_internal_degreeslatitude(), target); - } - - // optional double degreesLongitude = 2; - if (cached_has_bits & 0x00000080u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteDoubleToArray(2, this->_internal_degreeslongitude(), target); - } - - // optional string name = 3; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_name().data(), static_cast(this->_internal_name().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.LocationMessage.name"); - target = stream->WriteStringMaybeAliased( - 3, this->_internal_name(), target); - } - - // optional string address = 4; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_address().data(), static_cast(this->_internal_address().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.LocationMessage.address"); - target = stream->WriteStringMaybeAliased( - 4, this->_internal_address(), target); - } - - // optional string url = 5; - if (cached_has_bits & 0x00000004u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_url().data(), static_cast(this->_internal_url().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.LocationMessage.url"); - target = stream->WriteStringMaybeAliased( - 5, this->_internal_url(), target); - } - - // optional bool isLive = 6; - if (cached_has_bits & 0x00000100u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(6, this->_internal_islive(), target); - } - - // optional uint32 accuracyInMeters = 7; - if (cached_has_bits & 0x00000200u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(7, this->_internal_accuracyinmeters(), target); - } - - // optional float speedInMps = 8; - if (cached_has_bits & 0x00000400u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteFloatToArray(8, this->_internal_speedinmps(), target); - } - - // optional uint32 degreesClockwiseFromMagneticNorth = 9; - if (cached_has_bits & 0x00000800u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(9, this->_internal_degreesclockwisefrommagneticnorth(), target); - } - - // optional string comment = 11; - if (cached_has_bits & 0x00000008u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_comment().data(), static_cast(this->_internal_comment().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.LocationMessage.comment"); - target = stream->WriteStringMaybeAliased( - 11, this->_internal_comment(), target); - } - - // optional bytes jpegThumbnail = 16; - if (cached_has_bits & 0x00000010u) { - target = stream->WriteBytesMaybeAliased( - 16, this->_internal_jpegthumbnail(), target); - } - - // optional .proto.ContextInfo contextInfo = 17; - if (cached_has_bits & 0x00000020u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(17, _Internal::contextinfo(this), - _Internal::contextinfo(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.LocationMessage) - return target; -} - -size_t Message_LocationMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.LocationMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional string name = 3; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_name()); - } - - // optional string address = 4; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_address()); - } - - // optional string url = 5; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_url()); - } - - // optional string comment = 11; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_comment()); - } - - // optional bytes jpegThumbnail = 16; - if (cached_has_bits & 0x00000010u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_jpegthumbnail()); - } - - // optional .proto.ContextInfo contextInfo = 17; - if (cached_has_bits & 0x00000020u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.contextinfo_); - } - - // optional double degreesLatitude = 1; - if (cached_has_bits & 0x00000040u) { - total_size += 1 + 8; - } - - // optional double degreesLongitude = 2; - if (cached_has_bits & 0x00000080u) { - total_size += 1 + 8; - } - - } - if (cached_has_bits & 0x00000f00u) { - // optional bool isLive = 6; - if (cached_has_bits & 0x00000100u) { - total_size += 1 + 1; - } - - // optional uint32 accuracyInMeters = 7; - if (cached_has_bits & 0x00000200u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_accuracyinmeters()); - } - - // optional float speedInMps = 8; - if (cached_has_bits & 0x00000400u) { - total_size += 1 + 4; - } - - // optional uint32 degreesClockwiseFromMagneticNorth = 9; - if (cached_has_bits & 0x00000800u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_degreesclockwisefrommagneticnorth()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_LocationMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_LocationMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_LocationMessage::GetClassData() const { return &_class_data_; } - - -void Message_LocationMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.LocationMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_name(from._internal_name()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_address(from._internal_address()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_url(from._internal_url()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_set_comment(from._internal_comment()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail()); - } - if (cached_has_bits & 0x00000020u) { - _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( - from._internal_contextinfo()); - } - if (cached_has_bits & 0x00000040u) { - _this->_impl_.degreeslatitude_ = from._impl_.degreeslatitude_; - } - if (cached_has_bits & 0x00000080u) { - _this->_impl_.degreeslongitude_ = from._impl_.degreeslongitude_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - if (cached_has_bits & 0x00000f00u) { - if (cached_has_bits & 0x00000100u) { - _this->_impl_.islive_ = from._impl_.islive_; - } - if (cached_has_bits & 0x00000200u) { - _this->_impl_.accuracyinmeters_ = from._impl_.accuracyinmeters_; - } - if (cached_has_bits & 0x00000400u) { - _this->_impl_.speedinmps_ = from._impl_.speedinmps_; - } - if (cached_has_bits & 0x00000800u) { - _this->_impl_.degreesclockwisefrommagneticnorth_ = from._impl_.degreesclockwisefrommagneticnorth_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_LocationMessage::CopyFrom(const Message_LocationMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.LocationMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_LocationMessage::IsInitialized() const { - return true; -} - -void Message_LocationMessage::InternalSwap(Message_LocationMessage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.name_, lhs_arena, - &other->_impl_.name_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.address_, lhs_arena, - &other->_impl_.address_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.url_, lhs_arena, - &other->_impl_.url_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.comment_, lhs_arena, - &other->_impl_.comment_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.jpegthumbnail_, lhs_arena, - &other->_impl_.jpegthumbnail_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_LocationMessage, _impl_.degreesclockwisefrommagneticnorth_) - + sizeof(Message_LocationMessage::_impl_.degreesclockwisefrommagneticnorth_) - - PROTOBUF_FIELD_OFFSET(Message_LocationMessage, _impl_.contextinfo_)>( - reinterpret_cast(&_impl_.contextinfo_), - reinterpret_cast(&other->_impl_.contextinfo_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_LocationMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[109]); -} - -// =================================================================== - -class Message_OrderMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_orderid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_thumbnail(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_itemcount(HasBits* has_bits) { - (*has_bits)[0] |= 512u; - } - static void set_has_status(HasBits* has_bits) { - (*has_bits)[0] |= 1024u; - } - static void set_has_surface(HasBits* has_bits) { - (*has_bits)[0] |= 2048u; - } - static void set_has_message(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_ordertitle(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_sellerjid(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_token(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static void set_has_totalamount1000(HasBits* has_bits) { - (*has_bits)[0] |= 256u; - } - static void set_has_totalcurrencycode(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static const ::proto::ContextInfo& contextinfo(const Message_OrderMessage* msg); - static void set_has_contextinfo(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } -}; - -const ::proto::ContextInfo& -Message_OrderMessage::_Internal::contextinfo(const Message_OrderMessage* msg) { - return *msg->_impl_.contextinfo_; -} -Message_OrderMessage::Message_OrderMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.OrderMessage) -} -Message_OrderMessage::Message_OrderMessage(const Message_OrderMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_OrderMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.orderid_){} - , decltype(_impl_.thumbnail_){} - , decltype(_impl_.message_){} - , decltype(_impl_.ordertitle_){} - , decltype(_impl_.sellerjid_){} - , decltype(_impl_.token_){} - , decltype(_impl_.totalcurrencycode_){} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.totalamount1000_){} - , decltype(_impl_.itemcount_){} - , decltype(_impl_.status_){} - , decltype(_impl_.surface_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.orderid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.orderid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_orderid()) { - _this->_impl_.orderid_.Set(from._internal_orderid(), - _this->GetArenaForAllocation()); - } - _impl_.thumbnail_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnail_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_thumbnail()) { - _this->_impl_.thumbnail_.Set(from._internal_thumbnail(), - _this->GetArenaForAllocation()); - } - _impl_.message_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.message_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_message()) { - _this->_impl_.message_.Set(from._internal_message(), - _this->GetArenaForAllocation()); - } - _impl_.ordertitle_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.ordertitle_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_ordertitle()) { - _this->_impl_.ordertitle_.Set(from._internal_ordertitle(), - _this->GetArenaForAllocation()); - } - _impl_.sellerjid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.sellerjid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_sellerjid()) { - _this->_impl_.sellerjid_.Set(from._internal_sellerjid(), - _this->GetArenaForAllocation()); - } - _impl_.token_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.token_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_token()) { - _this->_impl_.token_.Set(from._internal_token(), - _this->GetArenaForAllocation()); - } - _impl_.totalcurrencycode_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.totalcurrencycode_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_totalcurrencycode()) { - _this->_impl_.totalcurrencycode_.Set(from._internal_totalcurrencycode(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_contextinfo()) { - _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); - } - ::memcpy(&_impl_.totalamount1000_, &from._impl_.totalamount1000_, - static_cast(reinterpret_cast(&_impl_.surface_) - - reinterpret_cast(&_impl_.totalamount1000_)) + sizeof(_impl_.surface_)); - // @@protoc_insertion_point(copy_constructor:proto.Message.OrderMessage) -} - -inline void Message_OrderMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.orderid_){} - , decltype(_impl_.thumbnail_){} - , decltype(_impl_.message_){} - , decltype(_impl_.ordertitle_){} - , decltype(_impl_.sellerjid_){} - , decltype(_impl_.token_){} - , decltype(_impl_.totalcurrencycode_){} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.totalamount1000_){int64_t{0}} - , decltype(_impl_.itemcount_){0} - , decltype(_impl_.status_){1} - , decltype(_impl_.surface_){1} - }; - _impl_.orderid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.orderid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnail_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnail_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.message_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.message_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.ordertitle_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.ordertitle_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.sellerjid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.sellerjid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.token_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.token_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.totalcurrencycode_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.totalcurrencycode_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_OrderMessage::~Message_OrderMessage() { - // @@protoc_insertion_point(destructor:proto.Message.OrderMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_OrderMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.orderid_.Destroy(); - _impl_.thumbnail_.Destroy(); - _impl_.message_.Destroy(); - _impl_.ordertitle_.Destroy(); - _impl_.sellerjid_.Destroy(); - _impl_.token_.Destroy(); - _impl_.totalcurrencycode_.Destroy(); - if (this != internal_default_instance()) delete _impl_.contextinfo_; -} - -void Message_OrderMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_OrderMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.OrderMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _impl_.orderid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.thumbnail_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.message_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000008u) { - _impl_.ordertitle_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000010u) { - _impl_.sellerjid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000020u) { - _impl_.token_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000040u) { - _impl_.totalcurrencycode_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000080u) { - GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); - _impl_.contextinfo_->Clear(); - } - } - if (cached_has_bits & 0x00000f00u) { - ::memset(&_impl_.totalamount1000_, 0, static_cast( - reinterpret_cast(&_impl_.itemcount_) - - reinterpret_cast(&_impl_.totalamount1000_)) + sizeof(_impl_.itemcount_)); - _impl_.status_ = 1; - _impl_.surface_ = 1; - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_OrderMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string orderId = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_orderid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.OrderMessage.orderId"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bytes thumbnail = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_thumbnail(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional int32 itemCount = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_itemcount(&has_bits); - _impl_.itemcount_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.OrderMessage.OrderStatus status = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::Message_OrderMessage_OrderStatus_IsValid(val))) { - _internal_set_status(static_cast<::proto::Message_OrderMessage_OrderStatus>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.Message.OrderMessage.OrderSurface surface = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::Message_OrderMessage_OrderSurface_IsValid(val))) { - _internal_set_surface(static_cast<::proto::Message_OrderMessage_OrderSurface>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional string message = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - auto str = _internal_mutable_message(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.OrderMessage.message"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string orderTitle = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - auto str = _internal_mutable_ordertitle(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.OrderMessage.orderTitle"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string sellerJid = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { - auto str = _internal_mutable_sellerjid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.OrderMessage.sellerJid"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string token = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { - auto str = _internal_mutable_token(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.OrderMessage.token"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional int64 totalAmount1000 = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { - _Internal::set_has_totalamount1000(&has_bits); - _impl_.totalamount1000_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string totalCurrencyCode = 11; - case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { - auto str = _internal_mutable_totalcurrencycode(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.OrderMessage.totalCurrencyCode"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.ContextInfo contextInfo = 17; - case 17: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { - ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_OrderMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.OrderMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string orderId = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_orderid().data(), static_cast(this->_internal_orderid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.OrderMessage.orderId"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_orderid(), target); - } - - // optional bytes thumbnail = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_thumbnail(), target); - } - - // optional int32 itemCount = 3; - if (cached_has_bits & 0x00000200u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_itemcount(), target); - } - - // optional .proto.Message.OrderMessage.OrderStatus status = 4; - if (cached_has_bits & 0x00000400u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 4, this->_internal_status(), target); - } - - // optional .proto.Message.OrderMessage.OrderSurface surface = 5; - if (cached_has_bits & 0x00000800u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 5, this->_internal_surface(), target); - } - - // optional string message = 6; - if (cached_has_bits & 0x00000004u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_message().data(), static_cast(this->_internal_message().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.OrderMessage.message"); - target = stream->WriteStringMaybeAliased( - 6, this->_internal_message(), target); - } - - // optional string orderTitle = 7; - if (cached_has_bits & 0x00000008u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_ordertitle().data(), static_cast(this->_internal_ordertitle().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.OrderMessage.orderTitle"); - target = stream->WriteStringMaybeAliased( - 7, this->_internal_ordertitle(), target); - } - - // optional string sellerJid = 8; - if (cached_has_bits & 0x00000010u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_sellerjid().data(), static_cast(this->_internal_sellerjid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.OrderMessage.sellerJid"); - target = stream->WriteStringMaybeAliased( - 8, this->_internal_sellerjid(), target); - } - - // optional string token = 9; - if (cached_has_bits & 0x00000020u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_token().data(), static_cast(this->_internal_token().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.OrderMessage.token"); - target = stream->WriteStringMaybeAliased( - 9, this->_internal_token(), target); - } - - // optional int64 totalAmount1000 = 10; - if (cached_has_bits & 0x00000100u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(10, this->_internal_totalamount1000(), target); - } - - // optional string totalCurrencyCode = 11; - if (cached_has_bits & 0x00000040u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_totalcurrencycode().data(), static_cast(this->_internal_totalcurrencycode().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.OrderMessage.totalCurrencyCode"); - target = stream->WriteStringMaybeAliased( - 11, this->_internal_totalcurrencycode(), target); - } - - // optional .proto.ContextInfo contextInfo = 17; - if (cached_has_bits & 0x00000080u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(17, _Internal::contextinfo(this), - _Internal::contextinfo(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.OrderMessage) - return target; -} - -size_t Message_OrderMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.OrderMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional string orderId = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_orderid()); - } - - // optional bytes thumbnail = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_thumbnail()); - } - - // optional string message = 6; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_message()); - } - - // optional string orderTitle = 7; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_ordertitle()); - } - - // optional string sellerJid = 8; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_sellerjid()); - } - - // optional string token = 9; - if (cached_has_bits & 0x00000020u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_token()); - } - - // optional string totalCurrencyCode = 11; - if (cached_has_bits & 0x00000040u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_totalcurrencycode()); - } - - // optional .proto.ContextInfo contextInfo = 17; - if (cached_has_bits & 0x00000080u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.contextinfo_); - } - - } - if (cached_has_bits & 0x00000f00u) { - // optional int64 totalAmount1000 = 10; - if (cached_has_bits & 0x00000100u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_totalamount1000()); - } - - // optional int32 itemCount = 3; - if (cached_has_bits & 0x00000200u) { - total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_itemcount()); - } - - // optional .proto.Message.OrderMessage.OrderStatus status = 4; - if (cached_has_bits & 0x00000400u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_status()); - } - - // optional .proto.Message.OrderMessage.OrderSurface surface = 5; - if (cached_has_bits & 0x00000800u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_surface()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_OrderMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_OrderMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_OrderMessage::GetClassData() const { return &_class_data_; } - - -void Message_OrderMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.OrderMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_orderid(from._internal_orderid()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_thumbnail(from._internal_thumbnail()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_message(from._internal_message()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_set_ordertitle(from._internal_ordertitle()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_set_sellerjid(from._internal_sellerjid()); - } - if (cached_has_bits & 0x00000020u) { - _this->_internal_set_token(from._internal_token()); - } - if (cached_has_bits & 0x00000040u) { - _this->_internal_set_totalcurrencycode(from._internal_totalcurrencycode()); - } - if (cached_has_bits & 0x00000080u) { - _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( - from._internal_contextinfo()); - } - } - if (cached_has_bits & 0x00000f00u) { - if (cached_has_bits & 0x00000100u) { - _this->_impl_.totalamount1000_ = from._impl_.totalamount1000_; - } - if (cached_has_bits & 0x00000200u) { - _this->_impl_.itemcount_ = from._impl_.itemcount_; - } - if (cached_has_bits & 0x00000400u) { - _this->_impl_.status_ = from._impl_.status_; - } - if (cached_has_bits & 0x00000800u) { - _this->_impl_.surface_ = from._impl_.surface_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_OrderMessage::CopyFrom(const Message_OrderMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.OrderMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_OrderMessage::IsInitialized() const { - return true; -} - -void Message_OrderMessage::InternalSwap(Message_OrderMessage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.orderid_, lhs_arena, - &other->_impl_.orderid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.thumbnail_, lhs_arena, - &other->_impl_.thumbnail_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.message_, lhs_arena, - &other->_impl_.message_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.ordertitle_, lhs_arena, - &other->_impl_.ordertitle_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.sellerjid_, lhs_arena, - &other->_impl_.sellerjid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.token_, lhs_arena, - &other->_impl_.token_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.totalcurrencycode_, lhs_arena, - &other->_impl_.totalcurrencycode_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_OrderMessage, _impl_.itemcount_) - + sizeof(Message_OrderMessage::_impl_.itemcount_) - - PROTOBUF_FIELD_OFFSET(Message_OrderMessage, _impl_.contextinfo_)>( - reinterpret_cast(&_impl_.contextinfo_), - reinterpret_cast(&other->_impl_.contextinfo_)); - swap(_impl_.status_, other->_impl_.status_); - swap(_impl_.surface_, other->_impl_.surface_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_OrderMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[110]); -} - -// =================================================================== - -class Message_PaymentInviteMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_servicetype(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_expirytimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -Message_PaymentInviteMessage::Message_PaymentInviteMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.PaymentInviteMessage) -} -Message_PaymentInviteMessage::Message_PaymentInviteMessage(const Message_PaymentInviteMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_PaymentInviteMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.expirytimestamp_){} - , decltype(_impl_.servicetype_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&_impl_.expirytimestamp_, &from._impl_.expirytimestamp_, - static_cast(reinterpret_cast(&_impl_.servicetype_) - - reinterpret_cast(&_impl_.expirytimestamp_)) + sizeof(_impl_.servicetype_)); - // @@protoc_insertion_point(copy_constructor:proto.Message.PaymentInviteMessage) -} - -inline void Message_PaymentInviteMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.expirytimestamp_){int64_t{0}} - , decltype(_impl_.servicetype_){0} - }; -} - -Message_PaymentInviteMessage::~Message_PaymentInviteMessage() { - // @@protoc_insertion_point(destructor:proto.Message.PaymentInviteMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_PaymentInviteMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Message_PaymentInviteMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_PaymentInviteMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.PaymentInviteMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - ::memset(&_impl_.expirytimestamp_, 0, static_cast( - reinterpret_cast(&_impl_.servicetype_) - - reinterpret_cast(&_impl_.expirytimestamp_)) + sizeof(_impl_.servicetype_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_PaymentInviteMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.Message.PaymentInviteMessage.ServiceType serviceType = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::Message_PaymentInviteMessage_ServiceType_IsValid(val))) { - _internal_set_servicetype(static_cast<::proto::Message_PaymentInviteMessage_ServiceType>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional int64 expiryTimestamp = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_expirytimestamp(&has_bits); - _impl_.expirytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_PaymentInviteMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.PaymentInviteMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.Message.PaymentInviteMessage.ServiceType serviceType = 1; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 1, this->_internal_servicetype(), target); - } - - // optional int64 expiryTimestamp = 2; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_expirytimestamp(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.PaymentInviteMessage) - return target; -} - -size_t Message_PaymentInviteMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.PaymentInviteMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional int64 expiryTimestamp = 2; - if (cached_has_bits & 0x00000001u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_expirytimestamp()); - } - - // optional .proto.Message.PaymentInviteMessage.ServiceType serviceType = 1; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_servicetype()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_PaymentInviteMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_PaymentInviteMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_PaymentInviteMessage::GetClassData() const { return &_class_data_; } - - -void Message_PaymentInviteMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.PaymentInviteMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_impl_.expirytimestamp_ = from._impl_.expirytimestamp_; - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.servicetype_ = from._impl_.servicetype_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_PaymentInviteMessage::CopyFrom(const Message_PaymentInviteMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.PaymentInviteMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_PaymentInviteMessage::IsInitialized() const { - return true; -} - -void Message_PaymentInviteMessage::InternalSwap(Message_PaymentInviteMessage* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_PaymentInviteMessage, _impl_.servicetype_) - + sizeof(Message_PaymentInviteMessage::_impl_.servicetype_) - - PROTOBUF_FIELD_OFFSET(Message_PaymentInviteMessage, _impl_.expirytimestamp_)>( - reinterpret_cast(&_impl_.expirytimestamp_), - reinterpret_cast(&other->_impl_.expirytimestamp_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_PaymentInviteMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[111]); -} - -// =================================================================== - -class Message_PollCreationMessage_Option::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_optionname(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -Message_PollCreationMessage_Option::Message_PollCreationMessage_Option(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.PollCreationMessage.Option) -} -Message_PollCreationMessage_Option::Message_PollCreationMessage_Option(const Message_PollCreationMessage_Option& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_PollCreationMessage_Option* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.optionname_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.optionname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.optionname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_optionname()) { - _this->_impl_.optionname_.Set(from._internal_optionname(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.Message.PollCreationMessage.Option) -} - -inline void Message_PollCreationMessage_Option::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.optionname_){} - }; - _impl_.optionname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.optionname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_PollCreationMessage_Option::~Message_PollCreationMessage_Option() { - // @@protoc_insertion_point(destructor:proto.Message.PollCreationMessage.Option) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_PollCreationMessage_Option::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.optionname_.Destroy(); -} - -void Message_PollCreationMessage_Option::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_PollCreationMessage_Option::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.PollCreationMessage.Option) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.optionname_.ClearNonDefaultToEmpty(); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_PollCreationMessage_Option::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string optionName = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_optionname(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.PollCreationMessage.Option.optionName"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_PollCreationMessage_Option::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.PollCreationMessage.Option) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string optionName = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_optionname().data(), static_cast(this->_internal_optionname().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.PollCreationMessage.Option.optionName"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_optionname(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.PollCreationMessage.Option) - return target; -} - -size_t Message_PollCreationMessage_Option::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.PollCreationMessage.Option) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional string optionName = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_optionname()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_PollCreationMessage_Option::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_PollCreationMessage_Option::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_PollCreationMessage_Option::GetClassData() const { return &_class_data_; } - - -void Message_PollCreationMessage_Option::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.PollCreationMessage.Option) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_optionname()) { - _this->_internal_set_optionname(from._internal_optionname()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_PollCreationMessage_Option::CopyFrom(const Message_PollCreationMessage_Option& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.PollCreationMessage.Option) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_PollCreationMessage_Option::IsInitialized() const { - return true; -} - -void Message_PollCreationMessage_Option::InternalSwap(Message_PollCreationMessage_Option* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.optionname_, lhs_arena, - &other->_impl_.optionname_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_PollCreationMessage_Option::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[112]); -} - -// =================================================================== - -class Message_PollCreationMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_enckey(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_name(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_selectableoptionscount(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static const ::proto::ContextInfo& contextinfo(const Message_PollCreationMessage* msg); - static void set_has_contextinfo(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } -}; - -const ::proto::ContextInfo& -Message_PollCreationMessage::_Internal::contextinfo(const Message_PollCreationMessage* msg) { - return *msg->_impl_.contextinfo_; -} -Message_PollCreationMessage::Message_PollCreationMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.PollCreationMessage) -} -Message_PollCreationMessage::Message_PollCreationMessage(const Message_PollCreationMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_PollCreationMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.options_){from._impl_.options_} - , decltype(_impl_.enckey_){} - , decltype(_impl_.name_){} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.selectableoptionscount_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.enckey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.enckey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_enckey()) { - _this->_impl_.enckey_.Set(from._internal_enckey(), - _this->GetArenaForAllocation()); - } - _impl_.name_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.name_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_name()) { - _this->_impl_.name_.Set(from._internal_name(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_contextinfo()) { - _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); - } - _this->_impl_.selectableoptionscount_ = from._impl_.selectableoptionscount_; - // @@protoc_insertion_point(copy_constructor:proto.Message.PollCreationMessage) -} - -inline void Message_PollCreationMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.options_){arena} - , decltype(_impl_.enckey_){} - , decltype(_impl_.name_){} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.selectableoptionscount_){0u} - }; - _impl_.enckey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.enckey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.name_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.name_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_PollCreationMessage::~Message_PollCreationMessage() { - // @@protoc_insertion_point(destructor:proto.Message.PollCreationMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_PollCreationMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.options_.~RepeatedPtrField(); - _impl_.enckey_.Destroy(); - _impl_.name_.Destroy(); - if (this != internal_default_instance()) delete _impl_.contextinfo_; -} - -void Message_PollCreationMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_PollCreationMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.PollCreationMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.options_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _impl_.enckey_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.name_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); - _impl_.contextinfo_->Clear(); - } - } - _impl_.selectableoptionscount_ = 0u; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_PollCreationMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bytes encKey = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_enckey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string name = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_name(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.PollCreationMessage.name"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // repeated .proto.Message.PollCreationMessage.Option options = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_options(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); - } else - goto handle_unusual; - continue; - // optional uint32 selectableOptionsCount = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - _Internal::set_has_selectableoptionscount(&has_bits); - _impl_.selectableoptionscount_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.ContextInfo contextInfo = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_PollCreationMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.PollCreationMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bytes encKey = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 1, this->_internal_enckey(), target); - } - - // optional string name = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_name().data(), static_cast(this->_internal_name().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.PollCreationMessage.name"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_name(), target); - } - - // repeated .proto.Message.PollCreationMessage.Option options = 3; - for (unsigned i = 0, - n = static_cast(this->_internal_options_size()); i < n; i++) { - const auto& repfield = this->_internal_options(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream); - } - - // optional uint32 selectableOptionsCount = 4; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_selectableoptionscount(), target); - } - - // optional .proto.ContextInfo contextInfo = 5; - if (cached_has_bits & 0x00000004u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(5, _Internal::contextinfo(this), - _Internal::contextinfo(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.PollCreationMessage) - return target; -} - -size_t Message_PollCreationMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.PollCreationMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.Message.PollCreationMessage.Option options = 3; - total_size += 1UL * this->_internal_options_size(); - for (const auto& msg : this->_impl_.options_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - // optional bytes encKey = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_enckey()); - } - - // optional string name = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_name()); - } - - // optional .proto.ContextInfo contextInfo = 5; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.contextinfo_); - } - - // optional uint32 selectableOptionsCount = 4; - if (cached_has_bits & 0x00000008u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_selectableoptionscount()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_PollCreationMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_PollCreationMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_PollCreationMessage::GetClassData() const { return &_class_data_; } - - -void Message_PollCreationMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.PollCreationMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.options_.MergeFrom(from._impl_.options_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_enckey(from._internal_enckey()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_name(from._internal_name()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( - from._internal_contextinfo()); - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.selectableoptionscount_ = from._impl_.selectableoptionscount_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_PollCreationMessage::CopyFrom(const Message_PollCreationMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.PollCreationMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_PollCreationMessage::IsInitialized() const { - return true; -} - -void Message_PollCreationMessage::InternalSwap(Message_PollCreationMessage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.options_.InternalSwap(&other->_impl_.options_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.enckey_, lhs_arena, - &other->_impl_.enckey_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.name_, lhs_arena, - &other->_impl_.name_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_PollCreationMessage, _impl_.selectableoptionscount_) - + sizeof(Message_PollCreationMessage::_impl_.selectableoptionscount_) - - PROTOBUF_FIELD_OFFSET(Message_PollCreationMessage, _impl_.contextinfo_)>( - reinterpret_cast(&_impl_.contextinfo_), - reinterpret_cast(&other->_impl_.contextinfo_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_PollCreationMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[113]); -} - -// =================================================================== - -class Message_PollEncValue::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_encpayload(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_enciv(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -Message_PollEncValue::Message_PollEncValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.PollEncValue) -} -Message_PollEncValue::Message_PollEncValue(const Message_PollEncValue& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_PollEncValue* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.encpayload_){} - , decltype(_impl_.enciv_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.encpayload_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.encpayload_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_encpayload()) { - _this->_impl_.encpayload_.Set(from._internal_encpayload(), - _this->GetArenaForAllocation()); - } - _impl_.enciv_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.enciv_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_enciv()) { - _this->_impl_.enciv_.Set(from._internal_enciv(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.Message.PollEncValue) -} - -inline void Message_PollEncValue::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.encpayload_){} - , decltype(_impl_.enciv_){} - }; - _impl_.encpayload_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.encpayload_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.enciv_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.enciv_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_PollEncValue::~Message_PollEncValue() { - // @@protoc_insertion_point(destructor:proto.Message.PollEncValue) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_PollEncValue::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.encpayload_.Destroy(); - _impl_.enciv_.Destroy(); -} - -void Message_PollEncValue::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_PollEncValue::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.PollEncValue) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.encpayload_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.enciv_.ClearNonDefaultToEmpty(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_PollEncValue::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bytes encPayload = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_encpayload(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes encIv = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_enciv(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_PollEncValue::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.PollEncValue) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bytes encPayload = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 1, this->_internal_encpayload(), target); - } - - // optional bytes encIv = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_enciv(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.PollEncValue) - return target; -} - -size_t Message_PollEncValue::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.PollEncValue) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional bytes encPayload = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_encpayload()); - } - - // optional bytes encIv = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_enciv()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_PollEncValue::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_PollEncValue::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_PollEncValue::GetClassData() const { return &_class_data_; } - - -void Message_PollEncValue::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.PollEncValue) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_encpayload(from._internal_encpayload()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_enciv(from._internal_enciv()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_PollEncValue::CopyFrom(const Message_PollEncValue& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.PollEncValue) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_PollEncValue::IsInitialized() const { - return true; -} - -void Message_PollEncValue::InternalSwap(Message_PollEncValue* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.encpayload_, lhs_arena, - &other->_impl_.encpayload_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.enciv_, lhs_arena, - &other->_impl_.enciv_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_PollEncValue::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[114]); -} - -// =================================================================== - -class Message_PollUpdateMessageMetadata::_Internal { - public: -}; - -Message_PollUpdateMessageMetadata::Message_PollUpdateMessageMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) { - // @@protoc_insertion_point(arena_constructor:proto.Message.PollUpdateMessageMetadata) -} -Message_PollUpdateMessageMetadata::Message_PollUpdateMessageMetadata(const Message_PollUpdateMessageMetadata& from) - : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() { - Message_PollUpdateMessageMetadata* const _this = this; (void)_this; - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:proto.Message.PollUpdateMessageMetadata) -} - - - - - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_PollUpdateMessageMetadata::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl, - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl, -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_PollUpdateMessageMetadata::GetClassData() const { return &_class_data_; } - - - - - - - -::PROTOBUF_NAMESPACE_ID::Metadata Message_PollUpdateMessageMetadata::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[115]); -} - -// =================================================================== - -class Message_PollUpdateMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::MessageKey& pollcreationmessagekey(const Message_PollUpdateMessage* msg); - static void set_has_pollcreationmessagekey(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::proto::Message_PollEncValue& vote(const Message_PollUpdateMessage* msg); - static void set_has_vote(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::proto::Message_PollUpdateMessageMetadata& metadata(const Message_PollUpdateMessage* msg); - static void set_has_metadata(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_sendertimestampms(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } -}; - -const ::proto::MessageKey& -Message_PollUpdateMessage::_Internal::pollcreationmessagekey(const Message_PollUpdateMessage* msg) { - return *msg->_impl_.pollcreationmessagekey_; -} -const ::proto::Message_PollEncValue& -Message_PollUpdateMessage::_Internal::vote(const Message_PollUpdateMessage* msg) { - return *msg->_impl_.vote_; -} -const ::proto::Message_PollUpdateMessageMetadata& -Message_PollUpdateMessage::_Internal::metadata(const Message_PollUpdateMessage* msg) { - return *msg->_impl_.metadata_; -} -Message_PollUpdateMessage::Message_PollUpdateMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.PollUpdateMessage) -} -Message_PollUpdateMessage::Message_PollUpdateMessage(const Message_PollUpdateMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_PollUpdateMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.pollcreationmessagekey_){nullptr} - , decltype(_impl_.vote_){nullptr} - , decltype(_impl_.metadata_){nullptr} - , decltype(_impl_.sendertimestampms_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_pollcreationmessagekey()) { - _this->_impl_.pollcreationmessagekey_ = new ::proto::MessageKey(*from._impl_.pollcreationmessagekey_); - } - if (from._internal_has_vote()) { - _this->_impl_.vote_ = new ::proto::Message_PollEncValue(*from._impl_.vote_); - } - if (from._internal_has_metadata()) { - _this->_impl_.metadata_ = new ::proto::Message_PollUpdateMessageMetadata(*from._impl_.metadata_); - } - _this->_impl_.sendertimestampms_ = from._impl_.sendertimestampms_; - // @@protoc_insertion_point(copy_constructor:proto.Message.PollUpdateMessage) -} - -inline void Message_PollUpdateMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.pollcreationmessagekey_){nullptr} - , decltype(_impl_.vote_){nullptr} - , decltype(_impl_.metadata_){nullptr} - , decltype(_impl_.sendertimestampms_){int64_t{0}} - }; -} - -Message_PollUpdateMessage::~Message_PollUpdateMessage() { - // @@protoc_insertion_point(destructor:proto.Message.PollUpdateMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_PollUpdateMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete _impl_.pollcreationmessagekey_; - if (this != internal_default_instance()) delete _impl_.vote_; - if (this != internal_default_instance()) delete _impl_.metadata_; -} - -void Message_PollUpdateMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_PollUpdateMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.PollUpdateMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.pollcreationmessagekey_ != nullptr); - _impl_.pollcreationmessagekey_->Clear(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.vote_ != nullptr); - _impl_.vote_->Clear(); - } - if (cached_has_bits & 0x00000004u) { - GOOGLE_DCHECK(_impl_.metadata_ != nullptr); - _impl_.metadata_->Clear(); - } - } - _impl_.sendertimestampms_ = int64_t{0}; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_PollUpdateMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.MessageKey pollCreationMessageKey = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_pollcreationmessagekey(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.PollEncValue vote = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_vote(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.PollUpdateMessageMetadata metadata = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_metadata(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional int64 senderTimestampMs = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - _Internal::set_has_sendertimestampms(&has_bits); - _impl_.sendertimestampms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_PollUpdateMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.PollUpdateMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.MessageKey pollCreationMessageKey = 1; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::pollcreationmessagekey(this), - _Internal::pollcreationmessagekey(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.PollEncValue vote = 2; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::vote(this), - _Internal::vote(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.PollUpdateMessageMetadata metadata = 3; - if (cached_has_bits & 0x00000004u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, _Internal::metadata(this), - _Internal::metadata(this).GetCachedSize(), target, stream); - } - - // optional int64 senderTimestampMs = 4; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_sendertimestampms(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.PollUpdateMessage) - return target; -} - -size_t Message_PollUpdateMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.PollUpdateMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - // optional .proto.MessageKey pollCreationMessageKey = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.pollcreationmessagekey_); - } - - // optional .proto.Message.PollEncValue vote = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.vote_); - } - - // optional .proto.Message.PollUpdateMessageMetadata metadata = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.metadata_); - } - - // optional int64 senderTimestampMs = 4; - if (cached_has_bits & 0x00000008u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_sendertimestampms()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_PollUpdateMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_PollUpdateMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_PollUpdateMessage::GetClassData() const { return &_class_data_; } - - -void Message_PollUpdateMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.PollUpdateMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_mutable_pollcreationmessagekey()->::proto::MessageKey::MergeFrom( - from._internal_pollcreationmessagekey()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_vote()->::proto::Message_PollEncValue::MergeFrom( - from._internal_vote()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_mutable_metadata()->::proto::Message_PollUpdateMessageMetadata::MergeFrom( - from._internal_metadata()); - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.sendertimestampms_ = from._impl_.sendertimestampms_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_PollUpdateMessage::CopyFrom(const Message_PollUpdateMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.PollUpdateMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_PollUpdateMessage::IsInitialized() const { - return true; -} - -void Message_PollUpdateMessage::InternalSwap(Message_PollUpdateMessage* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_PollUpdateMessage, _impl_.sendertimestampms_) - + sizeof(Message_PollUpdateMessage::_impl_.sendertimestampms_) - - PROTOBUF_FIELD_OFFSET(Message_PollUpdateMessage, _impl_.pollcreationmessagekey_)>( - reinterpret_cast(&_impl_.pollcreationmessagekey_), - reinterpret_cast(&other->_impl_.pollcreationmessagekey_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_PollUpdateMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[116]); -} - -// =================================================================== - -class Message_PollVoteMessage::_Internal { - public: -}; - -Message_PollVoteMessage::Message_PollVoteMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.PollVoteMessage) -} -Message_PollVoteMessage::Message_PollVoteMessage(const Message_PollVoteMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_PollVoteMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_.selectedoptions_){from._impl_.selectedoptions_} - , /*decltype(_impl_._cached_size_)*/{}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:proto.Message.PollVoteMessage) -} - -inline void Message_PollVoteMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_.selectedoptions_){arena} - , /*decltype(_impl_._cached_size_)*/{} - }; -} - -Message_PollVoteMessage::~Message_PollVoteMessage() { - // @@protoc_insertion_point(destructor:proto.Message.PollVoteMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_PollVoteMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.selectedoptions_.~RepeatedPtrField(); -} - -void Message_PollVoteMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_PollVoteMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.PollVoteMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.selectedoptions_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_PollVoteMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated bytes selectedOptions = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - auto str = _internal_add_selectedoptions(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_PollVoteMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.PollVoteMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated bytes selectedOptions = 1; - for (int i = 0, n = this->_internal_selectedoptions_size(); i < n; i++) { - const auto& s = this->_internal_selectedoptions(i); - target = stream->WriteBytes(1, s, target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.PollVoteMessage) - return target; -} - -size_t Message_PollVoteMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.PollVoteMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated bytes selectedOptions = 1; - total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.selectedoptions_.size()); - for (int i = 0, n = _impl_.selectedoptions_.size(); i < n; i++) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - _impl_.selectedoptions_.Get(i)); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_PollVoteMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_PollVoteMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_PollVoteMessage::GetClassData() const { return &_class_data_; } - - -void Message_PollVoteMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.PollVoteMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.selectedoptions_.MergeFrom(from._impl_.selectedoptions_); - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_PollVoteMessage::CopyFrom(const Message_PollVoteMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.PollVoteMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_PollVoteMessage::IsInitialized() const { - return true; -} - -void Message_PollVoteMessage::InternalSwap(Message_PollVoteMessage* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - _impl_.selectedoptions_.InternalSwap(&other->_impl_.selectedoptions_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_PollVoteMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[117]); -} - -// =================================================================== - -class Message_ProductMessage_CatalogSnapshot::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::Message_ImageMessage& catalogimage(const Message_ProductMessage_CatalogSnapshot* msg); - static void set_has_catalogimage(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_title(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_description(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -const ::proto::Message_ImageMessage& -Message_ProductMessage_CatalogSnapshot::_Internal::catalogimage(const Message_ProductMessage_CatalogSnapshot* msg) { - return *msg->_impl_.catalogimage_; -} -Message_ProductMessage_CatalogSnapshot::Message_ProductMessage_CatalogSnapshot(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.ProductMessage.CatalogSnapshot) -} -Message_ProductMessage_CatalogSnapshot::Message_ProductMessage_CatalogSnapshot(const Message_ProductMessage_CatalogSnapshot& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_ProductMessage_CatalogSnapshot* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.title_){} - , decltype(_impl_.description_){} - , decltype(_impl_.catalogimage_){nullptr}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.title_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.title_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_title()) { - _this->_impl_.title_.Set(from._internal_title(), - _this->GetArenaForAllocation()); - } - _impl_.description_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.description_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_description()) { - _this->_impl_.description_.Set(from._internal_description(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_catalogimage()) { - _this->_impl_.catalogimage_ = new ::proto::Message_ImageMessage(*from._impl_.catalogimage_); - } - // @@protoc_insertion_point(copy_constructor:proto.Message.ProductMessage.CatalogSnapshot) -} - -inline void Message_ProductMessage_CatalogSnapshot::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.title_){} - , decltype(_impl_.description_){} - , decltype(_impl_.catalogimage_){nullptr} - }; - _impl_.title_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.title_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.description_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.description_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_ProductMessage_CatalogSnapshot::~Message_ProductMessage_CatalogSnapshot() { - // @@protoc_insertion_point(destructor:proto.Message.ProductMessage.CatalogSnapshot) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_ProductMessage_CatalogSnapshot::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.title_.Destroy(); - _impl_.description_.Destroy(); - if (this != internal_default_instance()) delete _impl_.catalogimage_; -} - -void Message_ProductMessage_CatalogSnapshot::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_ProductMessage_CatalogSnapshot::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.ProductMessage.CatalogSnapshot) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _impl_.title_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.description_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - GOOGLE_DCHECK(_impl_.catalogimage_ != nullptr); - _impl_.catalogimage_->Clear(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_ProductMessage_CatalogSnapshot::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.Message.ImageMessage catalogImage = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_catalogimage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string title = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_title(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.CatalogSnapshot.title"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string description = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_description(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.CatalogSnapshot.description"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_ProductMessage_CatalogSnapshot::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ProductMessage.CatalogSnapshot) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.Message.ImageMessage catalogImage = 1; - if (cached_has_bits & 0x00000004u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::catalogimage(this), - _Internal::catalogimage(this).GetCachedSize(), target, stream); - } - - // optional string title = 2; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_title().data(), static_cast(this->_internal_title().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ProductMessage.CatalogSnapshot.title"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_title(), target); - } - - // optional string description = 3; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_description().data(), static_cast(this->_internal_description().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ProductMessage.CatalogSnapshot.description"); - target = stream->WriteStringMaybeAliased( - 3, this->_internal_description(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ProductMessage.CatalogSnapshot) - return target; -} - -size_t Message_ProductMessage_CatalogSnapshot::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.ProductMessage.CatalogSnapshot) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional string title = 2; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_title()); - } - - // optional string description = 3; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_description()); - } - - // optional .proto.Message.ImageMessage catalogImage = 1; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.catalogimage_); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ProductMessage_CatalogSnapshot::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_ProductMessage_CatalogSnapshot::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ProductMessage_CatalogSnapshot::GetClassData() const { return &_class_data_; } - - -void Message_ProductMessage_CatalogSnapshot::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ProductMessage.CatalogSnapshot) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_title(from._internal_title()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_description(from._internal_description()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_mutable_catalogimage()->::proto::Message_ImageMessage::MergeFrom( - from._internal_catalogimage()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_ProductMessage_CatalogSnapshot::CopyFrom(const Message_ProductMessage_CatalogSnapshot& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ProductMessage.CatalogSnapshot) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_ProductMessage_CatalogSnapshot::IsInitialized() const { - return true; -} - -void Message_ProductMessage_CatalogSnapshot::InternalSwap(Message_ProductMessage_CatalogSnapshot* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.title_, lhs_arena, - &other->_impl_.title_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.description_, lhs_arena, - &other->_impl_.description_, rhs_arena - ); - swap(_impl_.catalogimage_, other->_impl_.catalogimage_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_ProductMessage_CatalogSnapshot::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[118]); -} - -// =================================================================== - -class Message_ProductMessage_ProductSnapshot::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::Message_ImageMessage& productimage(const Message_ProductMessage_ProductSnapshot* msg); - static void set_has_productimage(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } - static void set_has_productid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_title(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_description(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_currencycode(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_priceamount1000(HasBits* has_bits) { - (*has_bits)[0] |= 256u; - } - static void set_has_retailerid(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_url(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static void set_has_productimagecount(HasBits* has_bits) { - (*has_bits)[0] |= 1024u; - } - static void set_has_firstimageid(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static void set_has_salepriceamount1000(HasBits* has_bits) { - (*has_bits)[0] |= 512u; - } -}; - -const ::proto::Message_ImageMessage& -Message_ProductMessage_ProductSnapshot::_Internal::productimage(const Message_ProductMessage_ProductSnapshot* msg) { - return *msg->_impl_.productimage_; -} -Message_ProductMessage_ProductSnapshot::Message_ProductMessage_ProductSnapshot(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.ProductMessage.ProductSnapshot) -} -Message_ProductMessage_ProductSnapshot::Message_ProductMessage_ProductSnapshot(const Message_ProductMessage_ProductSnapshot& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_ProductMessage_ProductSnapshot* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.productid_){} - , decltype(_impl_.title_){} - , decltype(_impl_.description_){} - , decltype(_impl_.currencycode_){} - , decltype(_impl_.retailerid_){} - , decltype(_impl_.url_){} - , decltype(_impl_.firstimageid_){} - , decltype(_impl_.productimage_){nullptr} - , decltype(_impl_.priceamount1000_){} - , decltype(_impl_.salepriceamount1000_){} - , decltype(_impl_.productimagecount_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.productid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.productid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_productid()) { - _this->_impl_.productid_.Set(from._internal_productid(), - _this->GetArenaForAllocation()); - } - _impl_.title_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.title_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_title()) { - _this->_impl_.title_.Set(from._internal_title(), - _this->GetArenaForAllocation()); - } - _impl_.description_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.description_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_description()) { - _this->_impl_.description_.Set(from._internal_description(), - _this->GetArenaForAllocation()); - } - _impl_.currencycode_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.currencycode_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_currencycode()) { - _this->_impl_.currencycode_.Set(from._internal_currencycode(), - _this->GetArenaForAllocation()); - } - _impl_.retailerid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.retailerid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_retailerid()) { - _this->_impl_.retailerid_.Set(from._internal_retailerid(), - _this->GetArenaForAllocation()); - } - _impl_.url_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.url_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_url()) { - _this->_impl_.url_.Set(from._internal_url(), - _this->GetArenaForAllocation()); - } - _impl_.firstimageid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.firstimageid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_firstimageid()) { - _this->_impl_.firstimageid_.Set(from._internal_firstimageid(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_productimage()) { - _this->_impl_.productimage_ = new ::proto::Message_ImageMessage(*from._impl_.productimage_); - } - ::memcpy(&_impl_.priceamount1000_, &from._impl_.priceamount1000_, - static_cast(reinterpret_cast(&_impl_.productimagecount_) - - reinterpret_cast(&_impl_.priceamount1000_)) + sizeof(_impl_.productimagecount_)); - // @@protoc_insertion_point(copy_constructor:proto.Message.ProductMessage.ProductSnapshot) -} - -inline void Message_ProductMessage_ProductSnapshot::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.productid_){} - , decltype(_impl_.title_){} - , decltype(_impl_.description_){} - , decltype(_impl_.currencycode_){} - , decltype(_impl_.retailerid_){} - , decltype(_impl_.url_){} - , decltype(_impl_.firstimageid_){} - , decltype(_impl_.productimage_){nullptr} - , decltype(_impl_.priceamount1000_){int64_t{0}} - , decltype(_impl_.salepriceamount1000_){int64_t{0}} - , decltype(_impl_.productimagecount_){0u} - }; - _impl_.productid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.productid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.title_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.title_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.description_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.description_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.currencycode_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.currencycode_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.retailerid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.retailerid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.url_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.url_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.firstimageid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.firstimageid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_ProductMessage_ProductSnapshot::~Message_ProductMessage_ProductSnapshot() { - // @@protoc_insertion_point(destructor:proto.Message.ProductMessage.ProductSnapshot) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_ProductMessage_ProductSnapshot::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.productid_.Destroy(); - _impl_.title_.Destroy(); - _impl_.description_.Destroy(); - _impl_.currencycode_.Destroy(); - _impl_.retailerid_.Destroy(); - _impl_.url_.Destroy(); - _impl_.firstimageid_.Destroy(); - if (this != internal_default_instance()) delete _impl_.productimage_; -} - -void Message_ProductMessage_ProductSnapshot::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_ProductMessage_ProductSnapshot::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.ProductMessage.ProductSnapshot) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _impl_.productid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.title_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.description_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000008u) { - _impl_.currencycode_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000010u) { - _impl_.retailerid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000020u) { - _impl_.url_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000040u) { - _impl_.firstimageid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000080u) { - GOOGLE_DCHECK(_impl_.productimage_ != nullptr); - _impl_.productimage_->Clear(); - } - } - if (cached_has_bits & 0x00000700u) { - ::memset(&_impl_.priceamount1000_, 0, static_cast( - reinterpret_cast(&_impl_.productimagecount_) - - reinterpret_cast(&_impl_.priceamount1000_)) + sizeof(_impl_.productimagecount_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_ProductMessage_ProductSnapshot::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.Message.ImageMessage productImage = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_productimage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string productId = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_productid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.ProductSnapshot.productId"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string title = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_title(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.ProductSnapshot.title"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string description = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - auto str = _internal_mutable_description(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.ProductSnapshot.description"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string currencyCode = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - auto str = _internal_mutable_currencycode(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.ProductSnapshot.currencyCode"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional int64 priceAmount1000 = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { - _Internal::set_has_priceamount1000(&has_bits); - _impl_.priceamount1000_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string retailerId = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - auto str = _internal_mutable_retailerid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.ProductSnapshot.retailerId"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string url = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { - auto str = _internal_mutable_url(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.ProductSnapshot.url"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional uint32 productImageCount = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { - _Internal::set_has_productimagecount(&has_bits); - _impl_.productimagecount_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string firstImageId = 11; - case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { - auto str = _internal_mutable_firstimageid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.ProductSnapshot.firstImageId"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional int64 salePriceAmount1000 = 12; - case 12: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { - _Internal::set_has_salepriceamount1000(&has_bits); - _impl_.salepriceamount1000_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_ProductMessage_ProductSnapshot::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ProductMessage.ProductSnapshot) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.Message.ImageMessage productImage = 1; - if (cached_has_bits & 0x00000080u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::productimage(this), - _Internal::productimage(this).GetCachedSize(), target, stream); - } - - // optional string productId = 2; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_productid().data(), static_cast(this->_internal_productid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ProductMessage.ProductSnapshot.productId"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_productid(), target); - } - - // optional string title = 3; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_title().data(), static_cast(this->_internal_title().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ProductMessage.ProductSnapshot.title"); - target = stream->WriteStringMaybeAliased( - 3, this->_internal_title(), target); - } - - // optional string description = 4; - if (cached_has_bits & 0x00000004u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_description().data(), static_cast(this->_internal_description().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ProductMessage.ProductSnapshot.description"); - target = stream->WriteStringMaybeAliased( - 4, this->_internal_description(), target); - } - - // optional string currencyCode = 5; - if (cached_has_bits & 0x00000008u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_currencycode().data(), static_cast(this->_internal_currencycode().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ProductMessage.ProductSnapshot.currencyCode"); - target = stream->WriteStringMaybeAliased( - 5, this->_internal_currencycode(), target); - } - - // optional int64 priceAmount1000 = 6; - if (cached_has_bits & 0x00000100u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(6, this->_internal_priceamount1000(), target); - } - - // optional string retailerId = 7; - if (cached_has_bits & 0x00000010u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_retailerid().data(), static_cast(this->_internal_retailerid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ProductMessage.ProductSnapshot.retailerId"); - target = stream->WriteStringMaybeAliased( - 7, this->_internal_retailerid(), target); - } - - // optional string url = 8; - if (cached_has_bits & 0x00000020u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_url().data(), static_cast(this->_internal_url().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ProductMessage.ProductSnapshot.url"); - target = stream->WriteStringMaybeAliased( - 8, this->_internal_url(), target); - } - - // optional uint32 productImageCount = 9; - if (cached_has_bits & 0x00000400u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(9, this->_internal_productimagecount(), target); - } - - // optional string firstImageId = 11; - if (cached_has_bits & 0x00000040u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_firstimageid().data(), static_cast(this->_internal_firstimageid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ProductMessage.ProductSnapshot.firstImageId"); - target = stream->WriteStringMaybeAliased( - 11, this->_internal_firstimageid(), target); - } - - // optional int64 salePriceAmount1000 = 12; - if (cached_has_bits & 0x00000200u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(12, this->_internal_salepriceamount1000(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ProductMessage.ProductSnapshot) - return target; -} - -size_t Message_ProductMessage_ProductSnapshot::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.ProductMessage.ProductSnapshot) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional string productId = 2; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_productid()); - } - - // optional string title = 3; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_title()); - } - - // optional string description = 4; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_description()); - } - - // optional string currencyCode = 5; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_currencycode()); - } - - // optional string retailerId = 7; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_retailerid()); - } - - // optional string url = 8; - if (cached_has_bits & 0x00000020u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_url()); - } - - // optional string firstImageId = 11; - if (cached_has_bits & 0x00000040u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_firstimageid()); - } - - // optional .proto.Message.ImageMessage productImage = 1; - if (cached_has_bits & 0x00000080u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.productimage_); - } - - } - if (cached_has_bits & 0x00000700u) { - // optional int64 priceAmount1000 = 6; - if (cached_has_bits & 0x00000100u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_priceamount1000()); - } - - // optional int64 salePriceAmount1000 = 12; - if (cached_has_bits & 0x00000200u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_salepriceamount1000()); - } - - // optional uint32 productImageCount = 9; - if (cached_has_bits & 0x00000400u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_productimagecount()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ProductMessage_ProductSnapshot::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_ProductMessage_ProductSnapshot::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ProductMessage_ProductSnapshot::GetClassData() const { return &_class_data_; } - - -void Message_ProductMessage_ProductSnapshot::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ProductMessage.ProductSnapshot) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_productid(from._internal_productid()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_title(from._internal_title()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_description(from._internal_description()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_set_currencycode(from._internal_currencycode()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_set_retailerid(from._internal_retailerid()); - } - if (cached_has_bits & 0x00000020u) { - _this->_internal_set_url(from._internal_url()); - } - if (cached_has_bits & 0x00000040u) { - _this->_internal_set_firstimageid(from._internal_firstimageid()); - } - if (cached_has_bits & 0x00000080u) { - _this->_internal_mutable_productimage()->::proto::Message_ImageMessage::MergeFrom( - from._internal_productimage()); - } - } - if (cached_has_bits & 0x00000700u) { - if (cached_has_bits & 0x00000100u) { - _this->_impl_.priceamount1000_ = from._impl_.priceamount1000_; - } - if (cached_has_bits & 0x00000200u) { - _this->_impl_.salepriceamount1000_ = from._impl_.salepriceamount1000_; - } - if (cached_has_bits & 0x00000400u) { - _this->_impl_.productimagecount_ = from._impl_.productimagecount_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_ProductMessage_ProductSnapshot::CopyFrom(const Message_ProductMessage_ProductSnapshot& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ProductMessage.ProductSnapshot) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_ProductMessage_ProductSnapshot::IsInitialized() const { - return true; -} - -void Message_ProductMessage_ProductSnapshot::InternalSwap(Message_ProductMessage_ProductSnapshot* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.productid_, lhs_arena, - &other->_impl_.productid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.title_, lhs_arena, - &other->_impl_.title_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.description_, lhs_arena, - &other->_impl_.description_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.currencycode_, lhs_arena, - &other->_impl_.currencycode_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.retailerid_, lhs_arena, - &other->_impl_.retailerid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.url_, lhs_arena, - &other->_impl_.url_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.firstimageid_, lhs_arena, - &other->_impl_.firstimageid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_ProductMessage_ProductSnapshot, _impl_.productimagecount_) - + sizeof(Message_ProductMessage_ProductSnapshot::_impl_.productimagecount_) - - PROTOBUF_FIELD_OFFSET(Message_ProductMessage_ProductSnapshot, _impl_.productimage_)>( - reinterpret_cast(&_impl_.productimage_), - reinterpret_cast(&other->_impl_.productimage_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_ProductMessage_ProductSnapshot::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[119]); -} - -// =================================================================== - -class Message_ProductMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::Message_ProductMessage_ProductSnapshot& product(const Message_ProductMessage* msg); - static void set_has_product(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_businessownerjid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::proto::Message_ProductMessage_CatalogSnapshot& catalog(const Message_ProductMessage* msg); - static void set_has_catalog(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_body(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_footer(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static const ::proto::ContextInfo& contextinfo(const Message_ProductMessage* msg); - static void set_has_contextinfo(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } -}; - -const ::proto::Message_ProductMessage_ProductSnapshot& -Message_ProductMessage::_Internal::product(const Message_ProductMessage* msg) { - return *msg->_impl_.product_; -} -const ::proto::Message_ProductMessage_CatalogSnapshot& -Message_ProductMessage::_Internal::catalog(const Message_ProductMessage* msg) { - return *msg->_impl_.catalog_; -} -const ::proto::ContextInfo& -Message_ProductMessage::_Internal::contextinfo(const Message_ProductMessage* msg) { - return *msg->_impl_.contextinfo_; -} -Message_ProductMessage::Message_ProductMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.ProductMessage) -} -Message_ProductMessage::Message_ProductMessage(const Message_ProductMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_ProductMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.businessownerjid_){} - , decltype(_impl_.body_){} - , decltype(_impl_.footer_){} - , decltype(_impl_.product_){nullptr} - , decltype(_impl_.catalog_){nullptr} - , decltype(_impl_.contextinfo_){nullptr}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.businessownerjid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.businessownerjid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_businessownerjid()) { - _this->_impl_.businessownerjid_.Set(from._internal_businessownerjid(), - _this->GetArenaForAllocation()); - } - _impl_.body_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.body_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_body()) { - _this->_impl_.body_.Set(from._internal_body(), - _this->GetArenaForAllocation()); - } - _impl_.footer_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.footer_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_footer()) { - _this->_impl_.footer_.Set(from._internal_footer(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_product()) { - _this->_impl_.product_ = new ::proto::Message_ProductMessage_ProductSnapshot(*from._impl_.product_); - } - if (from._internal_has_catalog()) { - _this->_impl_.catalog_ = new ::proto::Message_ProductMessage_CatalogSnapshot(*from._impl_.catalog_); - } - if (from._internal_has_contextinfo()) { - _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); - } - // @@protoc_insertion_point(copy_constructor:proto.Message.ProductMessage) -} - -inline void Message_ProductMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.businessownerjid_){} - , decltype(_impl_.body_){} - , decltype(_impl_.footer_){} - , decltype(_impl_.product_){nullptr} - , decltype(_impl_.catalog_){nullptr} - , decltype(_impl_.contextinfo_){nullptr} - }; - _impl_.businessownerjid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.businessownerjid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.body_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.body_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.footer_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.footer_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_ProductMessage::~Message_ProductMessage() { - // @@protoc_insertion_point(destructor:proto.Message.ProductMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_ProductMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.businessownerjid_.Destroy(); - _impl_.body_.Destroy(); - _impl_.footer_.Destroy(); - if (this != internal_default_instance()) delete _impl_.product_; - if (this != internal_default_instance()) delete _impl_.catalog_; - if (this != internal_default_instance()) delete _impl_.contextinfo_; -} - -void Message_ProductMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_ProductMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.ProductMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000003fu) { - if (cached_has_bits & 0x00000001u) { - _impl_.businessownerjid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.body_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.footer_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000008u) { - GOOGLE_DCHECK(_impl_.product_ != nullptr); - _impl_.product_->Clear(); - } - if (cached_has_bits & 0x00000010u) { - GOOGLE_DCHECK(_impl_.catalog_ != nullptr); - _impl_.catalog_->Clear(); - } - if (cached_has_bits & 0x00000020u) { - GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); - _impl_.contextinfo_->Clear(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_ProductMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.Message.ProductMessage.ProductSnapshot product = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_product(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string businessOwnerJid = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_businessownerjid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.businessOwnerJid"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.Message.ProductMessage.CatalogSnapshot catalog = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_catalog(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string body = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - auto str = _internal_mutable_body(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.body"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string footer = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - auto str = _internal_mutable_footer(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ProductMessage.footer"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.ContextInfo contextInfo = 17; - case 17: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { - ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_ProductMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ProductMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.Message.ProductMessage.ProductSnapshot product = 1; - if (cached_has_bits & 0x00000008u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::product(this), - _Internal::product(this).GetCachedSize(), target, stream); - } - - // optional string businessOwnerJid = 2; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_businessownerjid().data(), static_cast(this->_internal_businessownerjid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ProductMessage.businessOwnerJid"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_businessownerjid(), target); - } - - // optional .proto.Message.ProductMessage.CatalogSnapshot catalog = 4; - if (cached_has_bits & 0x00000010u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(4, _Internal::catalog(this), - _Internal::catalog(this).GetCachedSize(), target, stream); - } - - // optional string body = 5; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_body().data(), static_cast(this->_internal_body().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ProductMessage.body"); - target = stream->WriteStringMaybeAliased( - 5, this->_internal_body(), target); - } - - // optional string footer = 6; - if (cached_has_bits & 0x00000004u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_footer().data(), static_cast(this->_internal_footer().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ProductMessage.footer"); - target = stream->WriteStringMaybeAliased( - 6, this->_internal_footer(), target); - } - - // optional .proto.ContextInfo contextInfo = 17; - if (cached_has_bits & 0x00000020u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(17, _Internal::contextinfo(this), - _Internal::contextinfo(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ProductMessage) - return target; -} - -size_t Message_ProductMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.ProductMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000003fu) { - // optional string businessOwnerJid = 2; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_businessownerjid()); - } - - // optional string body = 5; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_body()); - } - - // optional string footer = 6; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_footer()); - } - - // optional .proto.Message.ProductMessage.ProductSnapshot product = 1; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.product_); - } - - // optional .proto.Message.ProductMessage.CatalogSnapshot catalog = 4; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.catalog_); - } - - // optional .proto.ContextInfo contextInfo = 17; - if (cached_has_bits & 0x00000020u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.contextinfo_); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ProductMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_ProductMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ProductMessage::GetClassData() const { return &_class_data_; } - - -void Message_ProductMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ProductMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000003fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_businessownerjid(from._internal_businessownerjid()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_body(from._internal_body()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_footer(from._internal_footer()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_mutable_product()->::proto::Message_ProductMessage_ProductSnapshot::MergeFrom( - from._internal_product()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_mutable_catalog()->::proto::Message_ProductMessage_CatalogSnapshot::MergeFrom( - from._internal_catalog()); - } - if (cached_has_bits & 0x00000020u) { - _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( - from._internal_contextinfo()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_ProductMessage::CopyFrom(const Message_ProductMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ProductMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_ProductMessage::IsInitialized() const { - return true; -} - -void Message_ProductMessage::InternalSwap(Message_ProductMessage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.businessownerjid_, lhs_arena, - &other->_impl_.businessownerjid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.body_, lhs_arena, - &other->_impl_.body_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.footer_, lhs_arena, - &other->_impl_.footer_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_ProductMessage, _impl_.contextinfo_) - + sizeof(Message_ProductMessage::_impl_.contextinfo_) - - PROTOBUF_FIELD_OFFSET(Message_ProductMessage, _impl_.product_)>( - reinterpret_cast(&_impl_.product_), - reinterpret_cast(&other->_impl_.product_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_ProductMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[120]); -} - -// =================================================================== - -class Message_ProtocolMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::MessageKey& key(const Message_ProtocolMessage* msg); - static void set_has_key(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_type(HasBits* has_bits) { - (*has_bits)[0] |= 512u; - } - static void set_has_ephemeralexpiration(HasBits* has_bits) { - (*has_bits)[0] |= 1024u; - } - static void set_has_ephemeralsettingtimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 2048u; - } - static const ::proto::Message_HistorySyncNotification& historysyncnotification(const Message_ProtocolMessage* msg); - static void set_has_historysyncnotification(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::proto::Message_AppStateSyncKeyShare& appstatesynckeyshare(const Message_ProtocolMessage* msg); - static void set_has_appstatesynckeyshare(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static const ::proto::Message_AppStateSyncKeyRequest& appstatesynckeyrequest(const Message_ProtocolMessage* msg); - static void set_has_appstatesynckeyrequest(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static const ::proto::Message_InitialSecurityNotificationSettingSync& initialsecuritynotificationsettingsync(const Message_ProtocolMessage* msg); - static void set_has_initialsecuritynotificationsettingsync(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static const ::proto::Message_AppStateFatalExceptionNotification& appstatefatalexceptionnotification(const Message_ProtocolMessage* msg); - static void set_has_appstatefatalexceptionnotification(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static const ::proto::DisappearingMode& disappearingmode(const Message_ProtocolMessage* msg); - static void set_has_disappearingmode(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static const ::proto::Message_RequestMediaUploadMessage& requestmediauploadmessage(const Message_ProtocolMessage* msg); - static void set_has_requestmediauploadmessage(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } - static const ::proto::Message_RequestMediaUploadResponseMessage& requestmediauploadresponsemessage(const Message_ProtocolMessage* msg); - static void set_has_requestmediauploadresponsemessage(HasBits* has_bits) { - (*has_bits)[0] |= 256u; - } -}; - -const ::proto::MessageKey& -Message_ProtocolMessage::_Internal::key(const Message_ProtocolMessage* msg) { - return *msg->_impl_.key_; -} -const ::proto::Message_HistorySyncNotification& -Message_ProtocolMessage::_Internal::historysyncnotification(const Message_ProtocolMessage* msg) { - return *msg->_impl_.historysyncnotification_; -} -const ::proto::Message_AppStateSyncKeyShare& -Message_ProtocolMessage::_Internal::appstatesynckeyshare(const Message_ProtocolMessage* msg) { - return *msg->_impl_.appstatesynckeyshare_; -} -const ::proto::Message_AppStateSyncKeyRequest& -Message_ProtocolMessage::_Internal::appstatesynckeyrequest(const Message_ProtocolMessage* msg) { - return *msg->_impl_.appstatesynckeyrequest_; -} -const ::proto::Message_InitialSecurityNotificationSettingSync& -Message_ProtocolMessage::_Internal::initialsecuritynotificationsettingsync(const Message_ProtocolMessage* msg) { - return *msg->_impl_.initialsecuritynotificationsettingsync_; -} -const ::proto::Message_AppStateFatalExceptionNotification& -Message_ProtocolMessage::_Internal::appstatefatalexceptionnotification(const Message_ProtocolMessage* msg) { - return *msg->_impl_.appstatefatalexceptionnotification_; -} -const ::proto::DisappearingMode& -Message_ProtocolMessage::_Internal::disappearingmode(const Message_ProtocolMessage* msg) { - return *msg->_impl_.disappearingmode_; -} -const ::proto::Message_RequestMediaUploadMessage& -Message_ProtocolMessage::_Internal::requestmediauploadmessage(const Message_ProtocolMessage* msg) { - return *msg->_impl_.requestmediauploadmessage_; -} -const ::proto::Message_RequestMediaUploadResponseMessage& -Message_ProtocolMessage::_Internal::requestmediauploadresponsemessage(const Message_ProtocolMessage* msg) { - return *msg->_impl_.requestmediauploadresponsemessage_; -} -Message_ProtocolMessage::Message_ProtocolMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.ProtocolMessage) -} -Message_ProtocolMessage::Message_ProtocolMessage(const Message_ProtocolMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_ProtocolMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.key_){nullptr} - , decltype(_impl_.historysyncnotification_){nullptr} - , decltype(_impl_.appstatesynckeyshare_){nullptr} - , decltype(_impl_.appstatesynckeyrequest_){nullptr} - , decltype(_impl_.initialsecuritynotificationsettingsync_){nullptr} - , decltype(_impl_.appstatefatalexceptionnotification_){nullptr} - , decltype(_impl_.disappearingmode_){nullptr} - , decltype(_impl_.requestmediauploadmessage_){nullptr} - , decltype(_impl_.requestmediauploadresponsemessage_){nullptr} - , decltype(_impl_.type_){} - , decltype(_impl_.ephemeralexpiration_){} - , decltype(_impl_.ephemeralsettingtimestamp_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_key()) { - _this->_impl_.key_ = new ::proto::MessageKey(*from._impl_.key_); - } - if (from._internal_has_historysyncnotification()) { - _this->_impl_.historysyncnotification_ = new ::proto::Message_HistorySyncNotification(*from._impl_.historysyncnotification_); - } - if (from._internal_has_appstatesynckeyshare()) { - _this->_impl_.appstatesynckeyshare_ = new ::proto::Message_AppStateSyncKeyShare(*from._impl_.appstatesynckeyshare_); - } - if (from._internal_has_appstatesynckeyrequest()) { - _this->_impl_.appstatesynckeyrequest_ = new ::proto::Message_AppStateSyncKeyRequest(*from._impl_.appstatesynckeyrequest_); - } - if (from._internal_has_initialsecuritynotificationsettingsync()) { - _this->_impl_.initialsecuritynotificationsettingsync_ = new ::proto::Message_InitialSecurityNotificationSettingSync(*from._impl_.initialsecuritynotificationsettingsync_); - } - if (from._internal_has_appstatefatalexceptionnotification()) { - _this->_impl_.appstatefatalexceptionnotification_ = new ::proto::Message_AppStateFatalExceptionNotification(*from._impl_.appstatefatalexceptionnotification_); - } - if (from._internal_has_disappearingmode()) { - _this->_impl_.disappearingmode_ = new ::proto::DisappearingMode(*from._impl_.disappearingmode_); - } - if (from._internal_has_requestmediauploadmessage()) { - _this->_impl_.requestmediauploadmessage_ = new ::proto::Message_RequestMediaUploadMessage(*from._impl_.requestmediauploadmessage_); - } - if (from._internal_has_requestmediauploadresponsemessage()) { - _this->_impl_.requestmediauploadresponsemessage_ = new ::proto::Message_RequestMediaUploadResponseMessage(*from._impl_.requestmediauploadresponsemessage_); - } - ::memcpy(&_impl_.type_, &from._impl_.type_, - static_cast(reinterpret_cast(&_impl_.ephemeralsettingtimestamp_) - - reinterpret_cast(&_impl_.type_)) + sizeof(_impl_.ephemeralsettingtimestamp_)); - // @@protoc_insertion_point(copy_constructor:proto.Message.ProtocolMessage) -} - -inline void Message_ProtocolMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.key_){nullptr} - , decltype(_impl_.historysyncnotification_){nullptr} - , decltype(_impl_.appstatesynckeyshare_){nullptr} - , decltype(_impl_.appstatesynckeyrequest_){nullptr} - , decltype(_impl_.initialsecuritynotificationsettingsync_){nullptr} - , decltype(_impl_.appstatefatalexceptionnotification_){nullptr} - , decltype(_impl_.disappearingmode_){nullptr} - , decltype(_impl_.requestmediauploadmessage_){nullptr} - , decltype(_impl_.requestmediauploadresponsemessage_){nullptr} - , decltype(_impl_.type_){0} - , decltype(_impl_.ephemeralexpiration_){0u} - , decltype(_impl_.ephemeralsettingtimestamp_){int64_t{0}} - }; -} - -Message_ProtocolMessage::~Message_ProtocolMessage() { - // @@protoc_insertion_point(destructor:proto.Message.ProtocolMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_ProtocolMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete _impl_.key_; - if (this != internal_default_instance()) delete _impl_.historysyncnotification_; - if (this != internal_default_instance()) delete _impl_.appstatesynckeyshare_; - if (this != internal_default_instance()) delete _impl_.appstatesynckeyrequest_; - if (this != internal_default_instance()) delete _impl_.initialsecuritynotificationsettingsync_; - if (this != internal_default_instance()) delete _impl_.appstatefatalexceptionnotification_; - if (this != internal_default_instance()) delete _impl_.disappearingmode_; - if (this != internal_default_instance()) delete _impl_.requestmediauploadmessage_; - if (this != internal_default_instance()) delete _impl_.requestmediauploadresponsemessage_; -} - -void Message_ProtocolMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_ProtocolMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.ProtocolMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.key_ != nullptr); - _impl_.key_->Clear(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.historysyncnotification_ != nullptr); - _impl_.historysyncnotification_->Clear(); - } - if (cached_has_bits & 0x00000004u) { - GOOGLE_DCHECK(_impl_.appstatesynckeyshare_ != nullptr); - _impl_.appstatesynckeyshare_->Clear(); - } - if (cached_has_bits & 0x00000008u) { - GOOGLE_DCHECK(_impl_.appstatesynckeyrequest_ != nullptr); - _impl_.appstatesynckeyrequest_->Clear(); - } - if (cached_has_bits & 0x00000010u) { - GOOGLE_DCHECK(_impl_.initialsecuritynotificationsettingsync_ != nullptr); - _impl_.initialsecuritynotificationsettingsync_->Clear(); - } - if (cached_has_bits & 0x00000020u) { - GOOGLE_DCHECK(_impl_.appstatefatalexceptionnotification_ != nullptr); - _impl_.appstatefatalexceptionnotification_->Clear(); - } - if (cached_has_bits & 0x00000040u) { - GOOGLE_DCHECK(_impl_.disappearingmode_ != nullptr); - _impl_.disappearingmode_->Clear(); - } - if (cached_has_bits & 0x00000080u) { - GOOGLE_DCHECK(_impl_.requestmediauploadmessage_ != nullptr); - _impl_.requestmediauploadmessage_->Clear(); - } - } - if (cached_has_bits & 0x00000100u) { - GOOGLE_DCHECK(_impl_.requestmediauploadresponsemessage_ != nullptr); - _impl_.requestmediauploadresponsemessage_->Clear(); - } - if (cached_has_bits & 0x00000e00u) { - ::memset(&_impl_.type_, 0, static_cast( - reinterpret_cast(&_impl_.ephemeralsettingtimestamp_) - - reinterpret_cast(&_impl_.type_)) + sizeof(_impl_.ephemeralsettingtimestamp_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_ProtocolMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.MessageKey key = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.ProtocolMessage.Type type = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::Message_ProtocolMessage_Type_IsValid(val))) { - _internal_set_type(static_cast<::proto::Message_ProtocolMessage_Type>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional uint32 ephemeralExpiration = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - _Internal::set_has_ephemeralexpiration(&has_bits); - _impl_.ephemeralexpiration_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional int64 ephemeralSettingTimestamp = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { - _Internal::set_has_ephemeralsettingtimestamp(&has_bits); - _impl_.ephemeralsettingtimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.HistorySyncNotification historySyncNotification = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - ptr = ctx->ParseMessage(_internal_mutable_historysyncnotification(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.AppStateSyncKeyShare appStateSyncKeyShare = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - ptr = ctx->ParseMessage(_internal_mutable_appstatesynckeyshare(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.AppStateSyncKeyRequest appStateSyncKeyRequest = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { - ptr = ctx->ParseMessage(_internal_mutable_appstatesynckeyrequest(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.InitialSecurityNotificationSettingSync initialSecurityNotificationSettingSync = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { - ptr = ctx->ParseMessage(_internal_mutable_initialsecuritynotificationsettingsync(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.AppStateFatalExceptionNotification appStateFatalExceptionNotification = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { - ptr = ctx->ParseMessage(_internal_mutable_appstatefatalexceptionnotification(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.DisappearingMode disappearingMode = 11; - case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { - ptr = ctx->ParseMessage(_internal_mutable_disappearingmode(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.RequestMediaUploadMessage requestMediaUploadMessage = 12; - case 12: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { - ptr = ctx->ParseMessage(_internal_mutable_requestmediauploadmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.RequestMediaUploadResponseMessage requestMediaUploadResponseMessage = 13; - case 13: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { - ptr = ctx->ParseMessage(_internal_mutable_requestmediauploadresponsemessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_ProtocolMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ProtocolMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.MessageKey key = 1; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::key(this), - _Internal::key(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.ProtocolMessage.Type type = 2; - if (cached_has_bits & 0x00000200u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 2, this->_internal_type(), target); - } - - // optional uint32 ephemeralExpiration = 4; - if (cached_has_bits & 0x00000400u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_ephemeralexpiration(), target); - } - - // optional int64 ephemeralSettingTimestamp = 5; - if (cached_has_bits & 0x00000800u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(5, this->_internal_ephemeralsettingtimestamp(), target); - } - - // optional .proto.Message.HistorySyncNotification historySyncNotification = 6; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(6, _Internal::historysyncnotification(this), - _Internal::historysyncnotification(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.AppStateSyncKeyShare appStateSyncKeyShare = 7; - if (cached_has_bits & 0x00000004u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(7, _Internal::appstatesynckeyshare(this), - _Internal::appstatesynckeyshare(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.AppStateSyncKeyRequest appStateSyncKeyRequest = 8; - if (cached_has_bits & 0x00000008u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(8, _Internal::appstatesynckeyrequest(this), - _Internal::appstatesynckeyrequest(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.InitialSecurityNotificationSettingSync initialSecurityNotificationSettingSync = 9; - if (cached_has_bits & 0x00000010u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(9, _Internal::initialsecuritynotificationsettingsync(this), - _Internal::initialsecuritynotificationsettingsync(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.AppStateFatalExceptionNotification appStateFatalExceptionNotification = 10; - if (cached_has_bits & 0x00000020u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(10, _Internal::appstatefatalexceptionnotification(this), - _Internal::appstatefatalexceptionnotification(this).GetCachedSize(), target, stream); - } - - // optional .proto.DisappearingMode disappearingMode = 11; - if (cached_has_bits & 0x00000040u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(11, _Internal::disappearingmode(this), - _Internal::disappearingmode(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.RequestMediaUploadMessage requestMediaUploadMessage = 12; - if (cached_has_bits & 0x00000080u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(12, _Internal::requestmediauploadmessage(this), - _Internal::requestmediauploadmessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.RequestMediaUploadResponseMessage requestMediaUploadResponseMessage = 13; - if (cached_has_bits & 0x00000100u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(13, _Internal::requestmediauploadresponsemessage(this), - _Internal::requestmediauploadresponsemessage(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ProtocolMessage) - return target; -} - -size_t Message_ProtocolMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.ProtocolMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional .proto.MessageKey key = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.key_); - } - - // optional .proto.Message.HistorySyncNotification historySyncNotification = 6; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.historysyncnotification_); - } - - // optional .proto.Message.AppStateSyncKeyShare appStateSyncKeyShare = 7; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.appstatesynckeyshare_); - } - - // optional .proto.Message.AppStateSyncKeyRequest appStateSyncKeyRequest = 8; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.appstatesynckeyrequest_); - } - - // optional .proto.Message.InitialSecurityNotificationSettingSync initialSecurityNotificationSettingSync = 9; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.initialsecuritynotificationsettingsync_); - } - - // optional .proto.Message.AppStateFatalExceptionNotification appStateFatalExceptionNotification = 10; - if (cached_has_bits & 0x00000020u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.appstatefatalexceptionnotification_); - } - - // optional .proto.DisappearingMode disappearingMode = 11; - if (cached_has_bits & 0x00000040u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.disappearingmode_); - } - - // optional .proto.Message.RequestMediaUploadMessage requestMediaUploadMessage = 12; - if (cached_has_bits & 0x00000080u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.requestmediauploadmessage_); - } - - } - if (cached_has_bits & 0x00000f00u) { - // optional .proto.Message.RequestMediaUploadResponseMessage requestMediaUploadResponseMessage = 13; - if (cached_has_bits & 0x00000100u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.requestmediauploadresponsemessage_); - } - - // optional .proto.Message.ProtocolMessage.Type type = 2; - if (cached_has_bits & 0x00000200u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_type()); - } - - // optional uint32 ephemeralExpiration = 4; - if (cached_has_bits & 0x00000400u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_ephemeralexpiration()); - } - - // optional int64 ephemeralSettingTimestamp = 5; - if (cached_has_bits & 0x00000800u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_ephemeralsettingtimestamp()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ProtocolMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_ProtocolMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ProtocolMessage::GetClassData() const { return &_class_data_; } - - -void Message_ProtocolMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ProtocolMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_mutable_key()->::proto::MessageKey::MergeFrom( - from._internal_key()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_historysyncnotification()->::proto::Message_HistorySyncNotification::MergeFrom( - from._internal_historysyncnotification()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_mutable_appstatesynckeyshare()->::proto::Message_AppStateSyncKeyShare::MergeFrom( - from._internal_appstatesynckeyshare()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_mutable_appstatesynckeyrequest()->::proto::Message_AppStateSyncKeyRequest::MergeFrom( - from._internal_appstatesynckeyrequest()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_mutable_initialsecuritynotificationsettingsync()->::proto::Message_InitialSecurityNotificationSettingSync::MergeFrom( - from._internal_initialsecuritynotificationsettingsync()); - } - if (cached_has_bits & 0x00000020u) { - _this->_internal_mutable_appstatefatalexceptionnotification()->::proto::Message_AppStateFatalExceptionNotification::MergeFrom( - from._internal_appstatefatalexceptionnotification()); - } - if (cached_has_bits & 0x00000040u) { - _this->_internal_mutable_disappearingmode()->::proto::DisappearingMode::MergeFrom( - from._internal_disappearingmode()); - } - if (cached_has_bits & 0x00000080u) { - _this->_internal_mutable_requestmediauploadmessage()->::proto::Message_RequestMediaUploadMessage::MergeFrom( - from._internal_requestmediauploadmessage()); - } - } - if (cached_has_bits & 0x00000f00u) { - if (cached_has_bits & 0x00000100u) { - _this->_internal_mutable_requestmediauploadresponsemessage()->::proto::Message_RequestMediaUploadResponseMessage::MergeFrom( - from._internal_requestmediauploadresponsemessage()); - } - if (cached_has_bits & 0x00000200u) { - _this->_impl_.type_ = from._impl_.type_; - } - if (cached_has_bits & 0x00000400u) { - _this->_impl_.ephemeralexpiration_ = from._impl_.ephemeralexpiration_; - } - if (cached_has_bits & 0x00000800u) { - _this->_impl_.ephemeralsettingtimestamp_ = from._impl_.ephemeralsettingtimestamp_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_ProtocolMessage::CopyFrom(const Message_ProtocolMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ProtocolMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_ProtocolMessage::IsInitialized() const { - return true; -} - -void Message_ProtocolMessage::InternalSwap(Message_ProtocolMessage* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_ProtocolMessage, _impl_.ephemeralsettingtimestamp_) - + sizeof(Message_ProtocolMessage::_impl_.ephemeralsettingtimestamp_) - - PROTOBUF_FIELD_OFFSET(Message_ProtocolMessage, _impl_.key_)>( - reinterpret_cast(&_impl_.key_), - reinterpret_cast(&other->_impl_.key_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_ProtocolMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[121]); -} - -// =================================================================== - -class Message_ReactionMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::MessageKey& key(const Message_ReactionMessage* msg); - static void set_has_key(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_text(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_groupingkey(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_sendertimestampms(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } -}; - -const ::proto::MessageKey& -Message_ReactionMessage::_Internal::key(const Message_ReactionMessage* msg) { - return *msg->_impl_.key_; -} -Message_ReactionMessage::Message_ReactionMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.ReactionMessage) -} -Message_ReactionMessage::Message_ReactionMessage(const Message_ReactionMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_ReactionMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.text_){} - , decltype(_impl_.groupingkey_){} - , decltype(_impl_.key_){nullptr} - , decltype(_impl_.sendertimestampms_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.text_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.text_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_text()) { - _this->_impl_.text_.Set(from._internal_text(), - _this->GetArenaForAllocation()); - } - _impl_.groupingkey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.groupingkey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_groupingkey()) { - _this->_impl_.groupingkey_.Set(from._internal_groupingkey(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_key()) { - _this->_impl_.key_ = new ::proto::MessageKey(*from._impl_.key_); - } - _this->_impl_.sendertimestampms_ = from._impl_.sendertimestampms_; - // @@protoc_insertion_point(copy_constructor:proto.Message.ReactionMessage) -} - -inline void Message_ReactionMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.text_){} - , decltype(_impl_.groupingkey_){} - , decltype(_impl_.key_){nullptr} - , decltype(_impl_.sendertimestampms_){int64_t{0}} - }; - _impl_.text_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.text_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.groupingkey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.groupingkey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_ReactionMessage::~Message_ReactionMessage() { - // @@protoc_insertion_point(destructor:proto.Message.ReactionMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_ReactionMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.text_.Destroy(); - _impl_.groupingkey_.Destroy(); - if (this != internal_default_instance()) delete _impl_.key_; -} - -void Message_ReactionMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_ReactionMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.ReactionMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _impl_.text_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.groupingkey_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - GOOGLE_DCHECK(_impl_.key_ != nullptr); - _impl_.key_->Clear(); - } - } - _impl_.sendertimestampms_ = int64_t{0}; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_ReactionMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.MessageKey key = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string text = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_text(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ReactionMessage.text"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string groupingKey = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_groupingkey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.ReactionMessage.groupingKey"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional int64 senderTimestampMs = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - _Internal::set_has_sendertimestampms(&has_bits); - _impl_.sendertimestampms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_ReactionMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.ReactionMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.MessageKey key = 1; - if (cached_has_bits & 0x00000004u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::key(this), - _Internal::key(this).GetCachedSize(), target, stream); - } - - // optional string text = 2; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_text().data(), static_cast(this->_internal_text().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ReactionMessage.text"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_text(), target); - } - - // optional string groupingKey = 3; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_groupingkey().data(), static_cast(this->_internal_groupingkey().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.ReactionMessage.groupingKey"); - target = stream->WriteStringMaybeAliased( - 3, this->_internal_groupingkey(), target); - } - - // optional int64 senderTimestampMs = 4; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_sendertimestampms(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.ReactionMessage) - return target; -} - -size_t Message_ReactionMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.ReactionMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - // optional string text = 2; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_text()); - } - - // optional string groupingKey = 3; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_groupingkey()); - } - - // optional .proto.MessageKey key = 1; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.key_); - } - - // optional int64 senderTimestampMs = 4; - if (cached_has_bits & 0x00000008u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_sendertimestampms()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_ReactionMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_ReactionMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_ReactionMessage::GetClassData() const { return &_class_data_; } - - -void Message_ReactionMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.ReactionMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_text(from._internal_text()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_groupingkey(from._internal_groupingkey()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_mutable_key()->::proto::MessageKey::MergeFrom( - from._internal_key()); - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.sendertimestampms_ = from._impl_.sendertimestampms_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_ReactionMessage::CopyFrom(const Message_ReactionMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.ReactionMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_ReactionMessage::IsInitialized() const { - return true; -} - -void Message_ReactionMessage::InternalSwap(Message_ReactionMessage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.text_, lhs_arena, - &other->_impl_.text_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.groupingkey_, lhs_arena, - &other->_impl_.groupingkey_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_ReactionMessage, _impl_.sendertimestampms_) - + sizeof(Message_ReactionMessage::_impl_.sendertimestampms_) - - PROTOBUF_FIELD_OFFSET(Message_ReactionMessage, _impl_.key_)>( - reinterpret_cast(&_impl_.key_), - reinterpret_cast(&other->_impl_.key_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_ReactionMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[122]); -} - -// =================================================================== - -class Message_RequestMediaUploadMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_rmrsource(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -Message_RequestMediaUploadMessage::Message_RequestMediaUploadMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.RequestMediaUploadMessage) -} -Message_RequestMediaUploadMessage::Message_RequestMediaUploadMessage(const Message_RequestMediaUploadMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_RequestMediaUploadMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.filesha256_){from._impl_.filesha256_} - , decltype(_impl_.rmrsource_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _this->_impl_.rmrsource_ = from._impl_.rmrsource_; - // @@protoc_insertion_point(copy_constructor:proto.Message.RequestMediaUploadMessage) -} - -inline void Message_RequestMediaUploadMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.filesha256_){arena} - , decltype(_impl_.rmrsource_){0} - }; -} - -Message_RequestMediaUploadMessage::~Message_RequestMediaUploadMessage() { - // @@protoc_insertion_point(destructor:proto.Message.RequestMediaUploadMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_RequestMediaUploadMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.filesha256_.~RepeatedPtrField(); -} - -void Message_RequestMediaUploadMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_RequestMediaUploadMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.RequestMediaUploadMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.filesha256_.Clear(); - _impl_.rmrsource_ = 0; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_RequestMediaUploadMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated string fileSha256 = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - auto str = _internal_add_filesha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.RequestMediaUploadMessage.fileSha256"); - #endif // !NDEBUG - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else - goto handle_unusual; - continue; - // optional .proto.Message.RmrSource rmrSource = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::Message_RmrSource_IsValid(val))) { - _internal_set_rmrsource(static_cast<::proto::Message_RmrSource>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_RequestMediaUploadMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.RequestMediaUploadMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated string fileSha256 = 1; - for (int i = 0, n = this->_internal_filesha256_size(); i < n; i++) { - const auto& s = this->_internal_filesha256(i); - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - s.data(), static_cast(s.length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.RequestMediaUploadMessage.fileSha256"); - target = stream->WriteString(1, s, target); - } - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.Message.RmrSource rmrSource = 2; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 2, this->_internal_rmrsource(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.RequestMediaUploadMessage) - return target; -} - -size_t Message_RequestMediaUploadMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.RequestMediaUploadMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated string fileSha256 = 1; - total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.filesha256_.size()); - for (int i = 0, n = _impl_.filesha256_.size(); i < n; i++) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - _impl_.filesha256_.Get(i)); - } - - // optional .proto.Message.RmrSource rmrSource = 2; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_rmrsource()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_RequestMediaUploadMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_RequestMediaUploadMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_RequestMediaUploadMessage::GetClassData() const { return &_class_data_; } - - -void Message_RequestMediaUploadMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.RequestMediaUploadMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.filesha256_.MergeFrom(from._impl_.filesha256_); - if (from._internal_has_rmrsource()) { - _this->_internal_set_rmrsource(from._internal_rmrsource()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_RequestMediaUploadMessage::CopyFrom(const Message_RequestMediaUploadMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.RequestMediaUploadMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_RequestMediaUploadMessage::IsInitialized() const { - return true; -} - -void Message_RequestMediaUploadMessage::InternalSwap(Message_RequestMediaUploadMessage* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.filesha256_.InternalSwap(&other->_impl_.filesha256_); - swap(_impl_.rmrsource_, other->_impl_.rmrsource_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_RequestMediaUploadMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[123]); -} - -// =================================================================== - -class Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_filesha256(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_mediauploadresult(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static const ::proto::Message_StickerMessage& stickermessage(const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* msg); - static void set_has_stickermessage(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -const ::proto::Message_StickerMessage& -Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_Internal::stickermessage(const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* msg) { - return *msg->_impl_.stickermessage_; -} -Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult) -} -Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult(const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.filesha256_){} - , decltype(_impl_.stickermessage_){nullptr} - , decltype(_impl_.mediauploadresult_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.filesha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filesha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_filesha256()) { - _this->_impl_.filesha256_.Set(from._internal_filesha256(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_stickermessage()) { - _this->_impl_.stickermessage_ = new ::proto::Message_StickerMessage(*from._impl_.stickermessage_); - } - _this->_impl_.mediauploadresult_ = from._impl_.mediauploadresult_; - // @@protoc_insertion_point(copy_constructor:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult) -} - -inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.filesha256_){} - , decltype(_impl_.stickermessage_){nullptr} - , decltype(_impl_.mediauploadresult_){0} - }; - _impl_.filesha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filesha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::~Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult() { - // @@protoc_insertion_point(destructor:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.filesha256_.Destroy(); - if (this != internal_default_instance()) delete _impl_.stickermessage_; -} - -void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.filesha256_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.stickermessage_ != nullptr); - _impl_.stickermessage_->Clear(); - } - } - _impl_.mediauploadresult_ = 0; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string fileSha256 = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_filesha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.fileSha256"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.MediaRetryNotification.ResultType mediaUploadResult = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::MediaRetryNotification_ResultType_IsValid(val))) { - _internal_set_mediauploadresult(static_cast<::proto::MediaRetryNotification_ResultType>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.Message.StickerMessage stickerMessage = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_stickermessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string fileSha256 = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_filesha256().data(), static_cast(this->_internal_filesha256().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.fileSha256"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_filesha256(), target); - } - - // optional .proto.MediaRetryNotification.ResultType mediaUploadResult = 2; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 2, this->_internal_mediauploadresult(), target); - } - - // optional .proto.Message.StickerMessage stickerMessage = 3; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, _Internal::stickermessage(this), - _Internal::stickermessage(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult) - return target; -} - -size_t Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional string fileSha256 = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_filesha256()); - } - - // optional .proto.Message.StickerMessage stickerMessage = 3; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.stickermessage_); - } - - // optional .proto.MediaRetryNotification.ResultType mediaUploadResult = 2; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_mediauploadresult()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::GetClassData() const { return &_class_data_; } - - -void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_filesha256(from._internal_filesha256()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_stickermessage()->::proto::Message_StickerMessage::MergeFrom( - from._internal_stickermessage()); - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.mediauploadresult_ = from._impl_.mediauploadresult_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::CopyFrom(const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::IsInitialized() const { - return true; -} - -void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::InternalSwap(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.filesha256_, lhs_arena, - &other->_impl_.filesha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult, _impl_.mediauploadresult_) - + sizeof(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_impl_.mediauploadresult_) - - PROTOBUF_FIELD_OFFSET(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult, _impl_.stickermessage_)>( - reinterpret_cast(&_impl_.stickermessage_), - reinterpret_cast(&other->_impl_.stickermessage_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[124]); -} - -// =================================================================== - -class Message_RequestMediaUploadResponseMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_rmrsource(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_stanzaid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -Message_RequestMediaUploadResponseMessage::Message_RequestMediaUploadResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.RequestMediaUploadResponseMessage) -} -Message_RequestMediaUploadResponseMessage::Message_RequestMediaUploadResponseMessage(const Message_RequestMediaUploadResponseMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_RequestMediaUploadResponseMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.reuploadresult_){from._impl_.reuploadresult_} - , decltype(_impl_.stanzaid_){} - , decltype(_impl_.rmrsource_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.stanzaid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.stanzaid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_stanzaid()) { - _this->_impl_.stanzaid_.Set(from._internal_stanzaid(), - _this->GetArenaForAllocation()); - } - _this->_impl_.rmrsource_ = from._impl_.rmrsource_; - // @@protoc_insertion_point(copy_constructor:proto.Message.RequestMediaUploadResponseMessage) -} - -inline void Message_RequestMediaUploadResponseMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.reuploadresult_){arena} - , decltype(_impl_.stanzaid_){} - , decltype(_impl_.rmrsource_){0} - }; - _impl_.stanzaid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.stanzaid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_RequestMediaUploadResponseMessage::~Message_RequestMediaUploadResponseMessage() { - // @@protoc_insertion_point(destructor:proto.Message.RequestMediaUploadResponseMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_RequestMediaUploadResponseMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.reuploadresult_.~RepeatedPtrField(); - _impl_.stanzaid_.Destroy(); -} - -void Message_RequestMediaUploadResponseMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_RequestMediaUploadResponseMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.RequestMediaUploadResponseMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.reuploadresult_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.stanzaid_.ClearNonDefaultToEmpty(); - } - _impl_.rmrsource_ = 0; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_RequestMediaUploadResponseMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.Message.RmrSource rmrSource = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::Message_RmrSource_IsValid(val))) { - _internal_set_rmrsource(static_cast<::proto::Message_RmrSource>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional string stanzaId = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_stanzaid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.RequestMediaUploadResponseMessage.stanzaId"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // repeated .proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult reuploadResult = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_reuploadresult(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_RequestMediaUploadResponseMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.RequestMediaUploadResponseMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.Message.RmrSource rmrSource = 1; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 1, this->_internal_rmrsource(), target); - } - - // optional string stanzaId = 2; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_stanzaid().data(), static_cast(this->_internal_stanzaid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.RequestMediaUploadResponseMessage.stanzaId"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_stanzaid(), target); - } - - // repeated .proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult reuploadResult = 3; - for (unsigned i = 0, - n = static_cast(this->_internal_reuploadresult_size()); i < n; i++) { - const auto& repfield = this->_internal_reuploadresult(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.RequestMediaUploadResponseMessage) - return target; -} - -size_t Message_RequestMediaUploadResponseMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.RequestMediaUploadResponseMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult reuploadResult = 3; - total_size += 1UL * this->_internal_reuploadresult_size(); - for (const auto& msg : this->_impl_.reuploadresult_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional string stanzaId = 2; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_stanzaid()); - } - - // optional .proto.Message.RmrSource rmrSource = 1; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_rmrsource()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_RequestMediaUploadResponseMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_RequestMediaUploadResponseMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_RequestMediaUploadResponseMessage::GetClassData() const { return &_class_data_; } - - -void Message_RequestMediaUploadResponseMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.RequestMediaUploadResponseMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.reuploadresult_.MergeFrom(from._impl_.reuploadresult_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_stanzaid(from._internal_stanzaid()); - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.rmrsource_ = from._impl_.rmrsource_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_RequestMediaUploadResponseMessage::CopyFrom(const Message_RequestMediaUploadResponseMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.RequestMediaUploadResponseMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_RequestMediaUploadResponseMessage::IsInitialized() const { - return true; -} - -void Message_RequestMediaUploadResponseMessage::InternalSwap(Message_RequestMediaUploadResponseMessage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.reuploadresult_.InternalSwap(&other->_impl_.reuploadresult_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.stanzaid_, lhs_arena, - &other->_impl_.stanzaid_, rhs_arena - ); - swap(_impl_.rmrsource_, other->_impl_.rmrsource_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_RequestMediaUploadResponseMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[125]); -} - -// =================================================================== - -class Message_RequestPaymentMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::Message& notemessage(const Message_RequestPaymentMessage* msg); - static void set_has_notemessage(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_currencycodeiso4217(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_amount1000(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static void set_has_requestfrom(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_expirytimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static const ::proto::Money& amount(const Message_RequestPaymentMessage* msg); - static void set_has_amount(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static const ::proto::PaymentBackground& background(const Message_RequestPaymentMessage* msg); - static void set_has_background(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } -}; - -const ::proto::Message& -Message_RequestPaymentMessage::_Internal::notemessage(const Message_RequestPaymentMessage* msg) { - return *msg->_impl_.notemessage_; -} -const ::proto::Money& -Message_RequestPaymentMessage::_Internal::amount(const Message_RequestPaymentMessage* msg) { - return *msg->_impl_.amount_; -} -const ::proto::PaymentBackground& -Message_RequestPaymentMessage::_Internal::background(const Message_RequestPaymentMessage* msg) { - return *msg->_impl_.background_; -} -Message_RequestPaymentMessage::Message_RequestPaymentMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.RequestPaymentMessage) -} -Message_RequestPaymentMessage::Message_RequestPaymentMessage(const Message_RequestPaymentMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_RequestPaymentMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.currencycodeiso4217_){} - , decltype(_impl_.requestfrom_){} - , decltype(_impl_.notemessage_){nullptr} - , decltype(_impl_.amount_){nullptr} - , decltype(_impl_.background_){nullptr} - , decltype(_impl_.amount1000_){} - , decltype(_impl_.expirytimestamp_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.currencycodeiso4217_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.currencycodeiso4217_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_currencycodeiso4217()) { - _this->_impl_.currencycodeiso4217_.Set(from._internal_currencycodeiso4217(), - _this->GetArenaForAllocation()); - } - _impl_.requestfrom_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.requestfrom_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_requestfrom()) { - _this->_impl_.requestfrom_.Set(from._internal_requestfrom(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_notemessage()) { - _this->_impl_.notemessage_ = new ::proto::Message(*from._impl_.notemessage_); - } - if (from._internal_has_amount()) { - _this->_impl_.amount_ = new ::proto::Money(*from._impl_.amount_); - } - if (from._internal_has_background()) { - _this->_impl_.background_ = new ::proto::PaymentBackground(*from._impl_.background_); - } - ::memcpy(&_impl_.amount1000_, &from._impl_.amount1000_, - static_cast(reinterpret_cast(&_impl_.expirytimestamp_) - - reinterpret_cast(&_impl_.amount1000_)) + sizeof(_impl_.expirytimestamp_)); - // @@protoc_insertion_point(copy_constructor:proto.Message.RequestPaymentMessage) -} - -inline void Message_RequestPaymentMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.currencycodeiso4217_){} - , decltype(_impl_.requestfrom_){} - , decltype(_impl_.notemessage_){nullptr} - , decltype(_impl_.amount_){nullptr} - , decltype(_impl_.background_){nullptr} - , decltype(_impl_.amount1000_){uint64_t{0u}} - , decltype(_impl_.expirytimestamp_){int64_t{0}} - }; - _impl_.currencycodeiso4217_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.currencycodeiso4217_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.requestfrom_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.requestfrom_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_RequestPaymentMessage::~Message_RequestPaymentMessage() { - // @@protoc_insertion_point(destructor:proto.Message.RequestPaymentMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_RequestPaymentMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.currencycodeiso4217_.Destroy(); - _impl_.requestfrom_.Destroy(); - if (this != internal_default_instance()) delete _impl_.notemessage_; - if (this != internal_default_instance()) delete _impl_.amount_; - if (this != internal_default_instance()) delete _impl_.background_; -} - -void Message_RequestPaymentMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_RequestPaymentMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.RequestPaymentMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { - if (cached_has_bits & 0x00000001u) { - _impl_.currencycodeiso4217_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.requestfrom_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - GOOGLE_DCHECK(_impl_.notemessage_ != nullptr); - _impl_.notemessage_->Clear(); - } - if (cached_has_bits & 0x00000008u) { - GOOGLE_DCHECK(_impl_.amount_ != nullptr); - _impl_.amount_->Clear(); - } - if (cached_has_bits & 0x00000010u) { - GOOGLE_DCHECK(_impl_.background_ != nullptr); - _impl_.background_->Clear(); - } - } - if (cached_has_bits & 0x00000060u) { - ::memset(&_impl_.amount1000_, 0, static_cast( - reinterpret_cast(&_impl_.expirytimestamp_) - - reinterpret_cast(&_impl_.amount1000_)) + sizeof(_impl_.expirytimestamp_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_RequestPaymentMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string currencyCodeIso4217 = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_currencycodeiso4217(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.RequestPaymentMessage.currencyCodeIso4217"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional uint64 amount1000 = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_amount1000(&has_bits); - _impl_.amount1000_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string requestFrom = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_requestfrom(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.RequestPaymentMessage.requestFrom"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.Message noteMessage = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_notemessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional int64 expiryTimestamp = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { - _Internal::set_has_expirytimestamp(&has_bits); - _impl_.expirytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Money amount = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - ptr = ctx->ParseMessage(_internal_mutable_amount(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.PaymentBackground background = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - ptr = ctx->ParseMessage(_internal_mutable_background(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_RequestPaymentMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.RequestPaymentMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string currencyCodeIso4217 = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_currencycodeiso4217().data(), static_cast(this->_internal_currencycodeiso4217().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.RequestPaymentMessage.currencyCodeIso4217"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_currencycodeiso4217(), target); - } - - // optional uint64 amount1000 = 2; - if (cached_has_bits & 0x00000020u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_amount1000(), target); - } - - // optional string requestFrom = 3; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_requestfrom().data(), static_cast(this->_internal_requestfrom().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.RequestPaymentMessage.requestFrom"); - target = stream->WriteStringMaybeAliased( - 3, this->_internal_requestfrom(), target); - } - - // optional .proto.Message noteMessage = 4; - if (cached_has_bits & 0x00000004u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(4, _Internal::notemessage(this), - _Internal::notemessage(this).GetCachedSize(), target, stream); - } - - // optional int64 expiryTimestamp = 5; - if (cached_has_bits & 0x00000040u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(5, this->_internal_expirytimestamp(), target); - } - - // optional .proto.Money amount = 6; - if (cached_has_bits & 0x00000008u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(6, _Internal::amount(this), - _Internal::amount(this).GetCachedSize(), target, stream); - } - - // optional .proto.PaymentBackground background = 7; - if (cached_has_bits & 0x00000010u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(7, _Internal::background(this), - _Internal::background(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.RequestPaymentMessage) - return target; -} - -size_t Message_RequestPaymentMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.RequestPaymentMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000007fu) { - // optional string currencyCodeIso4217 = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_currencycodeiso4217()); - } - - // optional string requestFrom = 3; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_requestfrom()); - } - - // optional .proto.Message noteMessage = 4; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.notemessage_); - } - - // optional .proto.Money amount = 6; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.amount_); - } - - // optional .proto.PaymentBackground background = 7; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.background_); - } - - // optional uint64 amount1000 = 2; - if (cached_has_bits & 0x00000020u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_amount1000()); - } - - // optional int64 expiryTimestamp = 5; - if (cached_has_bits & 0x00000040u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_expirytimestamp()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_RequestPaymentMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_RequestPaymentMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_RequestPaymentMessage::GetClassData() const { return &_class_data_; } - - -void Message_RequestPaymentMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.RequestPaymentMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000007fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_currencycodeiso4217(from._internal_currencycodeiso4217()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_requestfrom(from._internal_requestfrom()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_mutable_notemessage()->::proto::Message::MergeFrom( - from._internal_notemessage()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_mutable_amount()->::proto::Money::MergeFrom( - from._internal_amount()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_mutable_background()->::proto::PaymentBackground::MergeFrom( - from._internal_background()); - } - if (cached_has_bits & 0x00000020u) { - _this->_impl_.amount1000_ = from._impl_.amount1000_; - } - if (cached_has_bits & 0x00000040u) { - _this->_impl_.expirytimestamp_ = from._impl_.expirytimestamp_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_RequestPaymentMessage::CopyFrom(const Message_RequestPaymentMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.RequestPaymentMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_RequestPaymentMessage::IsInitialized() const { - return true; -} - -void Message_RequestPaymentMessage::InternalSwap(Message_RequestPaymentMessage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.currencycodeiso4217_, lhs_arena, - &other->_impl_.currencycodeiso4217_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.requestfrom_, lhs_arena, - &other->_impl_.requestfrom_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_RequestPaymentMessage, _impl_.expirytimestamp_) - + sizeof(Message_RequestPaymentMessage::_impl_.expirytimestamp_) - - PROTOBUF_FIELD_OFFSET(Message_RequestPaymentMessage, _impl_.notemessage_)>( - reinterpret_cast(&_impl_.notemessage_), - reinterpret_cast(&other->_impl_.notemessage_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_RequestPaymentMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[126]); -} - -// =================================================================== - -class Message_RequestPhoneNumberMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::ContextInfo& contextinfo(const Message_RequestPhoneNumberMessage* msg); - static void set_has_contextinfo(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -const ::proto::ContextInfo& -Message_RequestPhoneNumberMessage::_Internal::contextinfo(const Message_RequestPhoneNumberMessage* msg) { - return *msg->_impl_.contextinfo_; -} -Message_RequestPhoneNumberMessage::Message_RequestPhoneNumberMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.RequestPhoneNumberMessage) -} -Message_RequestPhoneNumberMessage::Message_RequestPhoneNumberMessage(const Message_RequestPhoneNumberMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_RequestPhoneNumberMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.contextinfo_){nullptr}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_contextinfo()) { - _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); - } - // @@protoc_insertion_point(copy_constructor:proto.Message.RequestPhoneNumberMessage) -} - -inline void Message_RequestPhoneNumberMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.contextinfo_){nullptr} - }; -} - -Message_RequestPhoneNumberMessage::~Message_RequestPhoneNumberMessage() { - // @@protoc_insertion_point(destructor:proto.Message.RequestPhoneNumberMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_RequestPhoneNumberMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete _impl_.contextinfo_; -} - -void Message_RequestPhoneNumberMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_RequestPhoneNumberMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.RequestPhoneNumberMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); - _impl_.contextinfo_->Clear(); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_RequestPhoneNumberMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.ContextInfo contextInfo = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_RequestPhoneNumberMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.RequestPhoneNumberMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.ContextInfo contextInfo = 1; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::contextinfo(this), - _Internal::contextinfo(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.RequestPhoneNumberMessage) - return target; -} - -size_t Message_RequestPhoneNumberMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.RequestPhoneNumberMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional .proto.ContextInfo contextInfo = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.contextinfo_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_RequestPhoneNumberMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_RequestPhoneNumberMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_RequestPhoneNumberMessage::GetClassData() const { return &_class_data_; } - - -void Message_RequestPhoneNumberMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.RequestPhoneNumberMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_contextinfo()) { - _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( - from._internal_contextinfo()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_RequestPhoneNumberMessage::CopyFrom(const Message_RequestPhoneNumberMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.RequestPhoneNumberMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_RequestPhoneNumberMessage::IsInitialized() const { - return true; -} - -void Message_RequestPhoneNumberMessage::InternalSwap(Message_RequestPhoneNumberMessage* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - swap(_impl_.contextinfo_, other->_impl_.contextinfo_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_RequestPhoneNumberMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[127]); -} - -// =================================================================== - -class Message_SendPaymentMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::Message& notemessage(const Message_SendPaymentMessage* msg); - static void set_has_notemessage(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::proto::MessageKey& requestmessagekey(const Message_SendPaymentMessage* msg); - static void set_has_requestmessagekey(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::proto::PaymentBackground& background(const Message_SendPaymentMessage* msg); - static void set_has_background(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } -}; - -const ::proto::Message& -Message_SendPaymentMessage::_Internal::notemessage(const Message_SendPaymentMessage* msg) { - return *msg->_impl_.notemessage_; -} -const ::proto::MessageKey& -Message_SendPaymentMessage::_Internal::requestmessagekey(const Message_SendPaymentMessage* msg) { - return *msg->_impl_.requestmessagekey_; -} -const ::proto::PaymentBackground& -Message_SendPaymentMessage::_Internal::background(const Message_SendPaymentMessage* msg) { - return *msg->_impl_.background_; -} -Message_SendPaymentMessage::Message_SendPaymentMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.SendPaymentMessage) -} -Message_SendPaymentMessage::Message_SendPaymentMessage(const Message_SendPaymentMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_SendPaymentMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.notemessage_){nullptr} - , decltype(_impl_.requestmessagekey_){nullptr} - , decltype(_impl_.background_){nullptr}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_notemessage()) { - _this->_impl_.notemessage_ = new ::proto::Message(*from._impl_.notemessage_); - } - if (from._internal_has_requestmessagekey()) { - _this->_impl_.requestmessagekey_ = new ::proto::MessageKey(*from._impl_.requestmessagekey_); - } - if (from._internal_has_background()) { - _this->_impl_.background_ = new ::proto::PaymentBackground(*from._impl_.background_); - } - // @@protoc_insertion_point(copy_constructor:proto.Message.SendPaymentMessage) -} - -inline void Message_SendPaymentMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.notemessage_){nullptr} - , decltype(_impl_.requestmessagekey_){nullptr} - , decltype(_impl_.background_){nullptr} - }; -} - -Message_SendPaymentMessage::~Message_SendPaymentMessage() { - // @@protoc_insertion_point(destructor:proto.Message.SendPaymentMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_SendPaymentMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete _impl_.notemessage_; - if (this != internal_default_instance()) delete _impl_.requestmessagekey_; - if (this != internal_default_instance()) delete _impl_.background_; -} - -void Message_SendPaymentMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_SendPaymentMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.SendPaymentMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.notemessage_ != nullptr); - _impl_.notemessage_->Clear(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.requestmessagekey_ != nullptr); - _impl_.requestmessagekey_->Clear(); - } - if (cached_has_bits & 0x00000004u) { - GOOGLE_DCHECK(_impl_.background_ != nullptr); - _impl_.background_->Clear(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_SendPaymentMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.Message noteMessage = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_notemessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.MessageKey requestMessageKey = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_requestmessagekey(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.PaymentBackground background = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_background(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_SendPaymentMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.SendPaymentMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.Message noteMessage = 2; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::notemessage(this), - _Internal::notemessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.MessageKey requestMessageKey = 3; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, _Internal::requestmessagekey(this), - _Internal::requestmessagekey(this).GetCachedSize(), target, stream); - } - - // optional .proto.PaymentBackground background = 4; - if (cached_has_bits & 0x00000004u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(4, _Internal::background(this), - _Internal::background(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.SendPaymentMessage) - return target; -} - -size_t Message_SendPaymentMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.SendPaymentMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional .proto.Message noteMessage = 2; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.notemessage_); - } - - // optional .proto.MessageKey requestMessageKey = 3; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.requestmessagekey_); - } - - // optional .proto.PaymentBackground background = 4; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.background_); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_SendPaymentMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_SendPaymentMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_SendPaymentMessage::GetClassData() const { return &_class_data_; } - - -void Message_SendPaymentMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.SendPaymentMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_mutable_notemessage()->::proto::Message::MergeFrom( - from._internal_notemessage()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_requestmessagekey()->::proto::MessageKey::MergeFrom( - from._internal_requestmessagekey()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_mutable_background()->::proto::PaymentBackground::MergeFrom( - from._internal_background()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_SendPaymentMessage::CopyFrom(const Message_SendPaymentMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.SendPaymentMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_SendPaymentMessage::IsInitialized() const { - return true; -} - -void Message_SendPaymentMessage::InternalSwap(Message_SendPaymentMessage* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_SendPaymentMessage, _impl_.background_) - + sizeof(Message_SendPaymentMessage::_impl_.background_) - - PROTOBUF_FIELD_OFFSET(Message_SendPaymentMessage, _impl_.notemessage_)>( - reinterpret_cast(&_impl_.notemessage_), - reinterpret_cast(&other->_impl_.notemessage_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_SendPaymentMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[128]); -} - -// =================================================================== - -class Message_SenderKeyDistributionMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_groupid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_axolotlsenderkeydistributionmessage(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -Message_SenderKeyDistributionMessage::Message_SenderKeyDistributionMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.SenderKeyDistributionMessage) -} -Message_SenderKeyDistributionMessage::Message_SenderKeyDistributionMessage(const Message_SenderKeyDistributionMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_SenderKeyDistributionMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.groupid_){} - , decltype(_impl_.axolotlsenderkeydistributionmessage_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.groupid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.groupid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_groupid()) { - _this->_impl_.groupid_.Set(from._internal_groupid(), - _this->GetArenaForAllocation()); - } - _impl_.axolotlsenderkeydistributionmessage_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.axolotlsenderkeydistributionmessage_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_axolotlsenderkeydistributionmessage()) { - _this->_impl_.axolotlsenderkeydistributionmessage_.Set(from._internal_axolotlsenderkeydistributionmessage(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.Message.SenderKeyDistributionMessage) -} - -inline void Message_SenderKeyDistributionMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.groupid_){} - , decltype(_impl_.axolotlsenderkeydistributionmessage_){} - }; - _impl_.groupid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.groupid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.axolotlsenderkeydistributionmessage_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.axolotlsenderkeydistributionmessage_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_SenderKeyDistributionMessage::~Message_SenderKeyDistributionMessage() { - // @@protoc_insertion_point(destructor:proto.Message.SenderKeyDistributionMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_SenderKeyDistributionMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.groupid_.Destroy(); - _impl_.axolotlsenderkeydistributionmessage_.Destroy(); -} - -void Message_SenderKeyDistributionMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_SenderKeyDistributionMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.SenderKeyDistributionMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.groupid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.axolotlsenderkeydistributionmessage_.ClearNonDefaultToEmpty(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_SenderKeyDistributionMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string groupId = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_groupid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.SenderKeyDistributionMessage.groupId"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bytes axolotlSenderKeyDistributionMessage = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_axolotlsenderkeydistributionmessage(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_SenderKeyDistributionMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.SenderKeyDistributionMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string groupId = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_groupid().data(), static_cast(this->_internal_groupid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.SenderKeyDistributionMessage.groupId"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_groupid(), target); - } - - // optional bytes axolotlSenderKeyDistributionMessage = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_axolotlsenderkeydistributionmessage(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.SenderKeyDistributionMessage) - return target; -} - -size_t Message_SenderKeyDistributionMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.SenderKeyDistributionMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional string groupId = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_groupid()); - } - - // optional bytes axolotlSenderKeyDistributionMessage = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_axolotlsenderkeydistributionmessage()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_SenderKeyDistributionMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_SenderKeyDistributionMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_SenderKeyDistributionMessage::GetClassData() const { return &_class_data_; } - - -void Message_SenderKeyDistributionMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.SenderKeyDistributionMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_groupid(from._internal_groupid()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_axolotlsenderkeydistributionmessage(from._internal_axolotlsenderkeydistributionmessage()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_SenderKeyDistributionMessage::CopyFrom(const Message_SenderKeyDistributionMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.SenderKeyDistributionMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_SenderKeyDistributionMessage::IsInitialized() const { - return true; -} - -void Message_SenderKeyDistributionMessage::InternalSwap(Message_SenderKeyDistributionMessage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.groupid_, lhs_arena, - &other->_impl_.groupid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.axolotlsenderkeydistributionmessage_, lhs_arena, - &other->_impl_.axolotlsenderkeydistributionmessage_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_SenderKeyDistributionMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[129]); -} - -// =================================================================== - -class Message_StickerMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_url(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_filesha256(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_fileencsha256(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_mediakey(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_mimetype(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_height(HasBits* has_bits) { - (*has_bits)[0] |= 512u; - } - static void set_has_width(HasBits* has_bits) { - (*has_bits)[0] |= 1024u; - } - static void set_has_directpath(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static void set_has_filelength(HasBits* has_bits) { - (*has_bits)[0] |= 2048u; - } - static void set_has_mediakeytimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 4096u; - } - static void set_has_firstframelength(HasBits* has_bits) { - (*has_bits)[0] |= 8192u; - } - static void set_has_firstframesidecar(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static void set_has_isanimated(HasBits* has_bits) { - (*has_bits)[0] |= 16384u; - } - static void set_has_pngthumbnail(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } - static const ::proto::ContextInfo& contextinfo(const Message_StickerMessage* msg); - static void set_has_contextinfo(HasBits* has_bits) { - (*has_bits)[0] |= 256u; - } -}; - -const ::proto::ContextInfo& -Message_StickerMessage::_Internal::contextinfo(const Message_StickerMessage* msg) { - return *msg->_impl_.contextinfo_; -} -Message_StickerMessage::Message_StickerMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.StickerMessage) -} -Message_StickerMessage::Message_StickerMessage(const Message_StickerMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_StickerMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.url_){} - , decltype(_impl_.filesha256_){} - , decltype(_impl_.fileencsha256_){} - , decltype(_impl_.mediakey_){} - , decltype(_impl_.mimetype_){} - , decltype(_impl_.directpath_){} - , decltype(_impl_.firstframesidecar_){} - , decltype(_impl_.pngthumbnail_){} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.height_){} - , decltype(_impl_.width_){} - , decltype(_impl_.filelength_){} - , decltype(_impl_.mediakeytimestamp_){} - , decltype(_impl_.firstframelength_){} - , decltype(_impl_.isanimated_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.url_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.url_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_url()) { - _this->_impl_.url_.Set(from._internal_url(), - _this->GetArenaForAllocation()); - } - _impl_.filesha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filesha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_filesha256()) { - _this->_impl_.filesha256_.Set(from._internal_filesha256(), - _this->GetArenaForAllocation()); - } - _impl_.fileencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_fileencsha256()) { - _this->_impl_.fileencsha256_.Set(from._internal_fileencsha256(), - _this->GetArenaForAllocation()); - } - _impl_.mediakey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediakey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_mediakey()) { - _this->_impl_.mediakey_.Set(from._internal_mediakey(), - _this->GetArenaForAllocation()); - } - _impl_.mimetype_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mimetype_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_mimetype()) { - _this->_impl_.mimetype_.Set(from._internal_mimetype(), - _this->GetArenaForAllocation()); - } - _impl_.directpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_directpath()) { - _this->_impl_.directpath_.Set(from._internal_directpath(), - _this->GetArenaForAllocation()); - } - _impl_.firstframesidecar_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.firstframesidecar_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_firstframesidecar()) { - _this->_impl_.firstframesidecar_.Set(from._internal_firstframesidecar(), - _this->GetArenaForAllocation()); - } - _impl_.pngthumbnail_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.pngthumbnail_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_pngthumbnail()) { - _this->_impl_.pngthumbnail_.Set(from._internal_pngthumbnail(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_contextinfo()) { - _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); - } - ::memcpy(&_impl_.height_, &from._impl_.height_, - static_cast(reinterpret_cast(&_impl_.isanimated_) - - reinterpret_cast(&_impl_.height_)) + sizeof(_impl_.isanimated_)); - // @@protoc_insertion_point(copy_constructor:proto.Message.StickerMessage) -} - -inline void Message_StickerMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.url_){} - , decltype(_impl_.filesha256_){} - , decltype(_impl_.fileencsha256_){} - , decltype(_impl_.mediakey_){} - , decltype(_impl_.mimetype_){} - , decltype(_impl_.directpath_){} - , decltype(_impl_.firstframesidecar_){} - , decltype(_impl_.pngthumbnail_){} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.height_){0u} - , decltype(_impl_.width_){0u} - , decltype(_impl_.filelength_){uint64_t{0u}} - , decltype(_impl_.mediakeytimestamp_){int64_t{0}} - , decltype(_impl_.firstframelength_){0u} - , decltype(_impl_.isanimated_){false} - }; - _impl_.url_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.url_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filesha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filesha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fileencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediakey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediakey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mimetype_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mimetype_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.firstframesidecar_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.firstframesidecar_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.pngthumbnail_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.pngthumbnail_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_StickerMessage::~Message_StickerMessage() { - // @@protoc_insertion_point(destructor:proto.Message.StickerMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_StickerMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.url_.Destroy(); - _impl_.filesha256_.Destroy(); - _impl_.fileencsha256_.Destroy(); - _impl_.mediakey_.Destroy(); - _impl_.mimetype_.Destroy(); - _impl_.directpath_.Destroy(); - _impl_.firstframesidecar_.Destroy(); - _impl_.pngthumbnail_.Destroy(); - if (this != internal_default_instance()) delete _impl_.contextinfo_; -} - -void Message_StickerMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_StickerMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.StickerMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _impl_.url_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.filesha256_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.fileencsha256_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000008u) { - _impl_.mediakey_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000010u) { - _impl_.mimetype_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000020u) { - _impl_.directpath_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000040u) { - _impl_.firstframesidecar_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000080u) { - _impl_.pngthumbnail_.ClearNonDefaultToEmpty(); - } - } - if (cached_has_bits & 0x00000100u) { - GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); - _impl_.contextinfo_->Clear(); - } - if (cached_has_bits & 0x00007e00u) { - ::memset(&_impl_.height_, 0, static_cast( - reinterpret_cast(&_impl_.isanimated_) - - reinterpret_cast(&_impl_.height_)) + sizeof(_impl_.isanimated_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_StickerMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string url = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_url(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.StickerMessage.url"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bytes fileSha256 = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_filesha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes fileEncSha256 = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_fileencsha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes mediaKey = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - auto str = _internal_mutable_mediakey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string mimetype = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - auto str = _internal_mutable_mimetype(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.StickerMessage.mimetype"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional uint32 height = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { - _Internal::set_has_height(&has_bits); - _impl_.height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 width = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { - _Internal::set_has_width(&has_bits); - _impl_.width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string directPath = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { - auto str = _internal_mutable_directpath(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.StickerMessage.directPath"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional uint64 fileLength = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { - _Internal::set_has_filelength(&has_bits); - _impl_.filelength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional int64 mediaKeyTimestamp = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { - _Internal::set_has_mediakeytimestamp(&has_bits); - _impl_.mediakeytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 firstFrameLength = 11; - case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { - _Internal::set_has_firstframelength(&has_bits); - _impl_.firstframelength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes firstFrameSidecar = 12; - case 12: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { - auto str = _internal_mutable_firstframesidecar(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool isAnimated = 13; - case 13: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 104)) { - _Internal::set_has_isanimated(&has_bits); - _impl_.isanimated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes pngThumbnail = 16; - case 16: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { - auto str = _internal_mutable_pngthumbnail(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.ContextInfo contextInfo = 17; - case 17: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { - ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_StickerMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.StickerMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string url = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_url().data(), static_cast(this->_internal_url().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.StickerMessage.url"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_url(), target); - } - - // optional bytes fileSha256 = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_filesha256(), target); - } - - // optional bytes fileEncSha256 = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->WriteBytesMaybeAliased( - 3, this->_internal_fileencsha256(), target); - } - - // optional bytes mediaKey = 4; - if (cached_has_bits & 0x00000008u) { - target = stream->WriteBytesMaybeAliased( - 4, this->_internal_mediakey(), target); - } - - // optional string mimetype = 5; - if (cached_has_bits & 0x00000010u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_mimetype().data(), static_cast(this->_internal_mimetype().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.StickerMessage.mimetype"); - target = stream->WriteStringMaybeAliased( - 5, this->_internal_mimetype(), target); - } - - // optional uint32 height = 6; - if (cached_has_bits & 0x00000200u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_height(), target); - } - - // optional uint32 width = 7; - if (cached_has_bits & 0x00000400u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(7, this->_internal_width(), target); - } - - // optional string directPath = 8; - if (cached_has_bits & 0x00000020u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_directpath().data(), static_cast(this->_internal_directpath().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.StickerMessage.directPath"); - target = stream->WriteStringMaybeAliased( - 8, this->_internal_directpath(), target); - } - - // optional uint64 fileLength = 9; - if (cached_has_bits & 0x00000800u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(9, this->_internal_filelength(), target); - } - - // optional int64 mediaKeyTimestamp = 10; - if (cached_has_bits & 0x00001000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(10, this->_internal_mediakeytimestamp(), target); - } - - // optional uint32 firstFrameLength = 11; - if (cached_has_bits & 0x00002000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(11, this->_internal_firstframelength(), target); - } - - // optional bytes firstFrameSidecar = 12; - if (cached_has_bits & 0x00000040u) { - target = stream->WriteBytesMaybeAliased( - 12, this->_internal_firstframesidecar(), target); - } - - // optional bool isAnimated = 13; - if (cached_has_bits & 0x00004000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(13, this->_internal_isanimated(), target); - } - - // optional bytes pngThumbnail = 16; - if (cached_has_bits & 0x00000080u) { - target = stream->WriteBytesMaybeAliased( - 16, this->_internal_pngthumbnail(), target); - } - - // optional .proto.ContextInfo contextInfo = 17; - if (cached_has_bits & 0x00000100u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(17, _Internal::contextinfo(this), - _Internal::contextinfo(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.StickerMessage) - return target; -} - -size_t Message_StickerMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.StickerMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional string url = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_url()); - } - - // optional bytes fileSha256 = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_filesha256()); - } - - // optional bytes fileEncSha256 = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_fileencsha256()); - } - - // optional bytes mediaKey = 4; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_mediakey()); - } - - // optional string mimetype = 5; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_mimetype()); - } - - // optional string directPath = 8; - if (cached_has_bits & 0x00000020u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_directpath()); - } - - // optional bytes firstFrameSidecar = 12; - if (cached_has_bits & 0x00000040u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_firstframesidecar()); - } - - // optional bytes pngThumbnail = 16; - if (cached_has_bits & 0x00000080u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_pngthumbnail()); - } - - } - if (cached_has_bits & 0x00007f00u) { - // optional .proto.ContextInfo contextInfo = 17; - if (cached_has_bits & 0x00000100u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.contextinfo_); - } - - // optional uint32 height = 6; - if (cached_has_bits & 0x00000200u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_height()); - } - - // optional uint32 width = 7; - if (cached_has_bits & 0x00000400u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_width()); - } - - // optional uint64 fileLength = 9; - if (cached_has_bits & 0x00000800u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_filelength()); - } - - // optional int64 mediaKeyTimestamp = 10; - if (cached_has_bits & 0x00001000u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_mediakeytimestamp()); - } - - // optional uint32 firstFrameLength = 11; - if (cached_has_bits & 0x00002000u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_firstframelength()); - } - - // optional bool isAnimated = 13; - if (cached_has_bits & 0x00004000u) { - total_size += 1 + 1; - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_StickerMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_StickerMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_StickerMessage::GetClassData() const { return &_class_data_; } - - -void Message_StickerMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.StickerMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_url(from._internal_url()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_filesha256(from._internal_filesha256()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_fileencsha256(from._internal_fileencsha256()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_set_mediakey(from._internal_mediakey()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_set_mimetype(from._internal_mimetype()); - } - if (cached_has_bits & 0x00000020u) { - _this->_internal_set_directpath(from._internal_directpath()); - } - if (cached_has_bits & 0x00000040u) { - _this->_internal_set_firstframesidecar(from._internal_firstframesidecar()); - } - if (cached_has_bits & 0x00000080u) { - _this->_internal_set_pngthumbnail(from._internal_pngthumbnail()); - } - } - if (cached_has_bits & 0x00007f00u) { - if (cached_has_bits & 0x00000100u) { - _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( - from._internal_contextinfo()); - } - if (cached_has_bits & 0x00000200u) { - _this->_impl_.height_ = from._impl_.height_; - } - if (cached_has_bits & 0x00000400u) { - _this->_impl_.width_ = from._impl_.width_; - } - if (cached_has_bits & 0x00000800u) { - _this->_impl_.filelength_ = from._impl_.filelength_; - } - if (cached_has_bits & 0x00001000u) { - _this->_impl_.mediakeytimestamp_ = from._impl_.mediakeytimestamp_; - } - if (cached_has_bits & 0x00002000u) { - _this->_impl_.firstframelength_ = from._impl_.firstframelength_; - } - if (cached_has_bits & 0x00004000u) { - _this->_impl_.isanimated_ = from._impl_.isanimated_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_StickerMessage::CopyFrom(const Message_StickerMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.StickerMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_StickerMessage::IsInitialized() const { - return true; -} - -void Message_StickerMessage::InternalSwap(Message_StickerMessage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.url_, lhs_arena, - &other->_impl_.url_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.filesha256_, lhs_arena, - &other->_impl_.filesha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.fileencsha256_, lhs_arena, - &other->_impl_.fileencsha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.mediakey_, lhs_arena, - &other->_impl_.mediakey_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.mimetype_, lhs_arena, - &other->_impl_.mimetype_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.directpath_, lhs_arena, - &other->_impl_.directpath_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.firstframesidecar_, lhs_arena, - &other->_impl_.firstframesidecar_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.pngthumbnail_, lhs_arena, - &other->_impl_.pngthumbnail_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_StickerMessage, _impl_.isanimated_) - + sizeof(Message_StickerMessage::_impl_.isanimated_) - - PROTOBUF_FIELD_OFFSET(Message_StickerMessage, _impl_.contextinfo_)>( - reinterpret_cast(&_impl_.contextinfo_), - reinterpret_cast(&other->_impl_.contextinfo_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_StickerMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[130]); -} - -// =================================================================== - -class Message_StickerSyncRMRMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_rmrsource(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_requesttimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -Message_StickerSyncRMRMessage::Message_StickerSyncRMRMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.StickerSyncRMRMessage) -} -Message_StickerSyncRMRMessage::Message_StickerSyncRMRMessage(const Message_StickerSyncRMRMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_StickerSyncRMRMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.filehash_){from._impl_.filehash_} - , decltype(_impl_.rmrsource_){} - , decltype(_impl_.requesttimestamp_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.rmrsource_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.rmrsource_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_rmrsource()) { - _this->_impl_.rmrsource_.Set(from._internal_rmrsource(), - _this->GetArenaForAllocation()); - } - _this->_impl_.requesttimestamp_ = from._impl_.requesttimestamp_; - // @@protoc_insertion_point(copy_constructor:proto.Message.StickerSyncRMRMessage) -} - -inline void Message_StickerSyncRMRMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.filehash_){arena} - , decltype(_impl_.rmrsource_){} - , decltype(_impl_.requesttimestamp_){int64_t{0}} - }; - _impl_.rmrsource_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.rmrsource_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_StickerSyncRMRMessage::~Message_StickerSyncRMRMessage() { - // @@protoc_insertion_point(destructor:proto.Message.StickerSyncRMRMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_StickerSyncRMRMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.filehash_.~RepeatedPtrField(); - _impl_.rmrsource_.Destroy(); -} - -void Message_StickerSyncRMRMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_StickerSyncRMRMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.StickerSyncRMRMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.filehash_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.rmrsource_.ClearNonDefaultToEmpty(); - } - _impl_.requesttimestamp_ = int64_t{0}; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_StickerSyncRMRMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated string filehash = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - auto str = _internal_add_filehash(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.StickerSyncRMRMessage.filehash"); - #endif // !NDEBUG - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else - goto handle_unusual; - continue; - // optional string rmrSource = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_rmrsource(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.StickerSyncRMRMessage.rmrSource"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional int64 requestTimestamp = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_requesttimestamp(&has_bits); - _impl_.requesttimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_StickerSyncRMRMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.StickerSyncRMRMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated string filehash = 1; - for (int i = 0, n = this->_internal_filehash_size(); i < n; i++) { - const auto& s = this->_internal_filehash(i); - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - s.data(), static_cast(s.length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.StickerSyncRMRMessage.filehash"); - target = stream->WriteString(1, s, target); - } - - cached_has_bits = _impl_._has_bits_[0]; - // optional string rmrSource = 2; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_rmrsource().data(), static_cast(this->_internal_rmrsource().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.StickerSyncRMRMessage.rmrSource"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_rmrsource(), target); - } - - // optional int64 requestTimestamp = 3; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_requesttimestamp(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.StickerSyncRMRMessage) - return target; -} - -size_t Message_StickerSyncRMRMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.StickerSyncRMRMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated string filehash = 1; - total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.filehash_.size()); - for (int i = 0, n = _impl_.filehash_.size(); i < n; i++) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - _impl_.filehash_.Get(i)); - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional string rmrSource = 2; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_rmrsource()); - } - - // optional int64 requestTimestamp = 3; - if (cached_has_bits & 0x00000002u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_requesttimestamp()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_StickerSyncRMRMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_StickerSyncRMRMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_StickerSyncRMRMessage::GetClassData() const { return &_class_data_; } - - -void Message_StickerSyncRMRMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.StickerSyncRMRMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.filehash_.MergeFrom(from._impl_.filehash_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_rmrsource(from._internal_rmrsource()); - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.requesttimestamp_ = from._impl_.requesttimestamp_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_StickerSyncRMRMessage::CopyFrom(const Message_StickerSyncRMRMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.StickerSyncRMRMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_StickerSyncRMRMessage::IsInitialized() const { - return true; -} - -void Message_StickerSyncRMRMessage::InternalSwap(Message_StickerSyncRMRMessage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.filehash_.InternalSwap(&other->_impl_.filehash_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.rmrsource_, lhs_arena, - &other->_impl_.rmrsource_, rhs_arena - ); - swap(_impl_.requesttimestamp_, other->_impl_.requesttimestamp_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_StickerSyncRMRMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[131]); -} - -// =================================================================== - -class Message_TemplateButtonReplyMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_selectedid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_selecteddisplaytext(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::proto::ContextInfo& contextinfo(const Message_TemplateButtonReplyMessage* msg); - static void set_has_contextinfo(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_selectedindex(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } -}; - -const ::proto::ContextInfo& -Message_TemplateButtonReplyMessage::_Internal::contextinfo(const Message_TemplateButtonReplyMessage* msg) { - return *msg->_impl_.contextinfo_; -} -Message_TemplateButtonReplyMessage::Message_TemplateButtonReplyMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.TemplateButtonReplyMessage) -} -Message_TemplateButtonReplyMessage::Message_TemplateButtonReplyMessage(const Message_TemplateButtonReplyMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_TemplateButtonReplyMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.selectedid_){} - , decltype(_impl_.selecteddisplaytext_){} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.selectedindex_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.selectedid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.selectedid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_selectedid()) { - _this->_impl_.selectedid_.Set(from._internal_selectedid(), - _this->GetArenaForAllocation()); - } - _impl_.selecteddisplaytext_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.selecteddisplaytext_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_selecteddisplaytext()) { - _this->_impl_.selecteddisplaytext_.Set(from._internal_selecteddisplaytext(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_contextinfo()) { - _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); - } - _this->_impl_.selectedindex_ = from._impl_.selectedindex_; - // @@protoc_insertion_point(copy_constructor:proto.Message.TemplateButtonReplyMessage) -} - -inline void Message_TemplateButtonReplyMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.selectedid_){} - , decltype(_impl_.selecteddisplaytext_){} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.selectedindex_){0u} - }; - _impl_.selectedid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.selectedid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.selecteddisplaytext_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.selecteddisplaytext_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_TemplateButtonReplyMessage::~Message_TemplateButtonReplyMessage() { - // @@protoc_insertion_point(destructor:proto.Message.TemplateButtonReplyMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_TemplateButtonReplyMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.selectedid_.Destroy(); - _impl_.selecteddisplaytext_.Destroy(); - if (this != internal_default_instance()) delete _impl_.contextinfo_; -} - -void Message_TemplateButtonReplyMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_TemplateButtonReplyMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.TemplateButtonReplyMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _impl_.selectedid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.selecteddisplaytext_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); - _impl_.contextinfo_->Clear(); - } - } - _impl_.selectedindex_ = 0u; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_TemplateButtonReplyMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string selectedId = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_selectedid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.TemplateButtonReplyMessage.selectedId"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string selectedDisplayText = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_selecteddisplaytext(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.TemplateButtonReplyMessage.selectedDisplayText"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.ContextInfo contextInfo = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 selectedIndex = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - _Internal::set_has_selectedindex(&has_bits); - _impl_.selectedindex_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_TemplateButtonReplyMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.TemplateButtonReplyMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string selectedId = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_selectedid().data(), static_cast(this->_internal_selectedid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.TemplateButtonReplyMessage.selectedId"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_selectedid(), target); - } - - // optional string selectedDisplayText = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_selecteddisplaytext().data(), static_cast(this->_internal_selecteddisplaytext().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.TemplateButtonReplyMessage.selectedDisplayText"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_selecteddisplaytext(), target); - } - - // optional .proto.ContextInfo contextInfo = 3; - if (cached_has_bits & 0x00000004u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, _Internal::contextinfo(this), - _Internal::contextinfo(this).GetCachedSize(), target, stream); - } - - // optional uint32 selectedIndex = 4; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_selectedindex(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.TemplateButtonReplyMessage) - return target; -} - -size_t Message_TemplateButtonReplyMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.TemplateButtonReplyMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - // optional string selectedId = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_selectedid()); - } - - // optional string selectedDisplayText = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_selecteddisplaytext()); - } - - // optional .proto.ContextInfo contextInfo = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.contextinfo_); - } - - // optional uint32 selectedIndex = 4; - if (cached_has_bits & 0x00000008u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_selectedindex()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_TemplateButtonReplyMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_TemplateButtonReplyMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_TemplateButtonReplyMessage::GetClassData() const { return &_class_data_; } - - -void Message_TemplateButtonReplyMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.TemplateButtonReplyMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_selectedid(from._internal_selectedid()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_selecteddisplaytext(from._internal_selecteddisplaytext()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( - from._internal_contextinfo()); - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.selectedindex_ = from._impl_.selectedindex_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_TemplateButtonReplyMessage::CopyFrom(const Message_TemplateButtonReplyMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.TemplateButtonReplyMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_TemplateButtonReplyMessage::IsInitialized() const { - return true; -} - -void Message_TemplateButtonReplyMessage::InternalSwap(Message_TemplateButtonReplyMessage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.selectedid_, lhs_arena, - &other->_impl_.selectedid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.selecteddisplaytext_, lhs_arena, - &other->_impl_.selecteddisplaytext_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_TemplateButtonReplyMessage, _impl_.selectedindex_) - + sizeof(Message_TemplateButtonReplyMessage::_impl_.selectedindex_) - - PROTOBUF_FIELD_OFFSET(Message_TemplateButtonReplyMessage, _impl_.contextinfo_)>( - reinterpret_cast(&_impl_.contextinfo_), - reinterpret_cast(&other->_impl_.contextinfo_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_TemplateButtonReplyMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[132]); -} - -// =================================================================== - -class Message_TemplateMessage_FourRowTemplate::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::Message_HighlyStructuredMessage& content(const Message_TemplateMessage_FourRowTemplate* msg); - static void set_has_content(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::proto::Message_HighlyStructuredMessage& footer(const Message_TemplateMessage_FourRowTemplate* msg); - static void set_has_footer(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::proto::Message_DocumentMessage& documentmessage(const Message_TemplateMessage_FourRowTemplate* msg); - static const ::proto::Message_HighlyStructuredMessage& highlystructuredmessage(const Message_TemplateMessage_FourRowTemplate* msg); - static const ::proto::Message_ImageMessage& imagemessage(const Message_TemplateMessage_FourRowTemplate* msg); - static const ::proto::Message_VideoMessage& videomessage(const Message_TemplateMessage_FourRowTemplate* msg); - static const ::proto::Message_LocationMessage& locationmessage(const Message_TemplateMessage_FourRowTemplate* msg); -}; - -const ::proto::Message_HighlyStructuredMessage& -Message_TemplateMessage_FourRowTemplate::_Internal::content(const Message_TemplateMessage_FourRowTemplate* msg) { - return *msg->_impl_.content_; -} -const ::proto::Message_HighlyStructuredMessage& -Message_TemplateMessage_FourRowTemplate::_Internal::footer(const Message_TemplateMessage_FourRowTemplate* msg) { - return *msg->_impl_.footer_; -} -const ::proto::Message_DocumentMessage& -Message_TemplateMessage_FourRowTemplate::_Internal::documentmessage(const Message_TemplateMessage_FourRowTemplate* msg) { - return *msg->_impl_.title_.documentmessage_; -} -const ::proto::Message_HighlyStructuredMessage& -Message_TemplateMessage_FourRowTemplate::_Internal::highlystructuredmessage(const Message_TemplateMessage_FourRowTemplate* msg) { - return *msg->_impl_.title_.highlystructuredmessage_; -} -const ::proto::Message_ImageMessage& -Message_TemplateMessage_FourRowTemplate::_Internal::imagemessage(const Message_TemplateMessage_FourRowTemplate* msg) { - return *msg->_impl_.title_.imagemessage_; -} -const ::proto::Message_VideoMessage& -Message_TemplateMessage_FourRowTemplate::_Internal::videomessage(const Message_TemplateMessage_FourRowTemplate* msg) { - return *msg->_impl_.title_.videomessage_; -} -const ::proto::Message_LocationMessage& -Message_TemplateMessage_FourRowTemplate::_Internal::locationmessage(const Message_TemplateMessage_FourRowTemplate* msg) { - return *msg->_impl_.title_.locationmessage_; -} -void Message_TemplateMessage_FourRowTemplate::set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_title(); - if (documentmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(documentmessage); - if (message_arena != submessage_arena) { - documentmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, documentmessage, submessage_arena); - } - set_has_documentmessage(); - _impl_.title_.documentmessage_ = documentmessage; - } - // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.documentMessage) -} -void Message_TemplateMessage_FourRowTemplate::set_allocated_highlystructuredmessage(::proto::Message_HighlyStructuredMessage* highlystructuredmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_title(); - if (highlystructuredmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(highlystructuredmessage); - if (message_arena != submessage_arena) { - highlystructuredmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, highlystructuredmessage, submessage_arena); - } - set_has_highlystructuredmessage(); - _impl_.title_.highlystructuredmessage_ = highlystructuredmessage; - } - // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.highlyStructuredMessage) -} -void Message_TemplateMessage_FourRowTemplate::set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_title(); - if (imagemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(imagemessage); - if (message_arena != submessage_arena) { - imagemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, imagemessage, submessage_arena); - } - set_has_imagemessage(); - _impl_.title_.imagemessage_ = imagemessage; - } - // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.imageMessage) -} -void Message_TemplateMessage_FourRowTemplate::set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_title(); - if (videomessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(videomessage); - if (message_arena != submessage_arena) { - videomessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, videomessage, submessage_arena); - } - set_has_videomessage(); - _impl_.title_.videomessage_ = videomessage; - } - // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.videoMessage) -} -void Message_TemplateMessage_FourRowTemplate::set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_title(); - if (locationmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(locationmessage); - if (message_arena != submessage_arena) { - locationmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, locationmessage, submessage_arena); - } - set_has_locationmessage(); - _impl_.title_.locationmessage_ = locationmessage; - } - // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.locationMessage) -} -Message_TemplateMessage_FourRowTemplate::Message_TemplateMessage_FourRowTemplate(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.TemplateMessage.FourRowTemplate) -} -Message_TemplateMessage_FourRowTemplate::Message_TemplateMessage_FourRowTemplate(const Message_TemplateMessage_FourRowTemplate& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_TemplateMessage_FourRowTemplate* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.buttons_){from._impl_.buttons_} - , decltype(_impl_.content_){nullptr} - , decltype(_impl_.footer_){nullptr} - , decltype(_impl_.title_){} - , /*decltype(_impl_._oneof_case_)*/{}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_content()) { - _this->_impl_.content_ = new ::proto::Message_HighlyStructuredMessage(*from._impl_.content_); - } - if (from._internal_has_footer()) { - _this->_impl_.footer_ = new ::proto::Message_HighlyStructuredMessage(*from._impl_.footer_); - } - clear_has_title(); - switch (from.title_case()) { - case kDocumentMessage: { - _this->_internal_mutable_documentmessage()->::proto::Message_DocumentMessage::MergeFrom( - from._internal_documentmessage()); - break; - } - case kHighlyStructuredMessage: { - _this->_internal_mutable_highlystructuredmessage()->::proto::Message_HighlyStructuredMessage::MergeFrom( - from._internal_highlystructuredmessage()); - break; - } - case kImageMessage: { - _this->_internal_mutable_imagemessage()->::proto::Message_ImageMessage::MergeFrom( - from._internal_imagemessage()); - break; - } - case kVideoMessage: { - _this->_internal_mutable_videomessage()->::proto::Message_VideoMessage::MergeFrom( - from._internal_videomessage()); - break; - } - case kLocationMessage: { - _this->_internal_mutable_locationmessage()->::proto::Message_LocationMessage::MergeFrom( - from._internal_locationmessage()); - break; - } - case TITLE_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:proto.Message.TemplateMessage.FourRowTemplate) -} - -inline void Message_TemplateMessage_FourRowTemplate::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.buttons_){arena} - , decltype(_impl_.content_){nullptr} - , decltype(_impl_.footer_){nullptr} - , decltype(_impl_.title_){} - , /*decltype(_impl_._oneof_case_)*/{} - }; - clear_has_title(); -} - -Message_TemplateMessage_FourRowTemplate::~Message_TemplateMessage_FourRowTemplate() { - // @@protoc_insertion_point(destructor:proto.Message.TemplateMessage.FourRowTemplate) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_TemplateMessage_FourRowTemplate::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.buttons_.~RepeatedPtrField(); - if (this != internal_default_instance()) delete _impl_.content_; - if (this != internal_default_instance()) delete _impl_.footer_; - if (has_title()) { - clear_title(); - } -} - -void Message_TemplateMessage_FourRowTemplate::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_TemplateMessage_FourRowTemplate::clear_title() { -// @@protoc_insertion_point(one_of_clear_start:proto.Message.TemplateMessage.FourRowTemplate) - switch (title_case()) { - case kDocumentMessage: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.title_.documentmessage_; - } - break; - } - case kHighlyStructuredMessage: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.title_.highlystructuredmessage_; - } - break; - } - case kImageMessage: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.title_.imagemessage_; - } - break; - } - case kVideoMessage: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.title_.videomessage_; - } - break; - } - case kLocationMessage: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.title_.locationmessage_; - } - break; - } - case TITLE_NOT_SET: { - break; - } - } - _impl_._oneof_case_[0] = TITLE_NOT_SET; -} - - -void Message_TemplateMessage_FourRowTemplate::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.TemplateMessage.FourRowTemplate) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.buttons_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.content_ != nullptr); - _impl_.content_->Clear(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.footer_ != nullptr); - _impl_.footer_->Clear(); - } - } - clear_title(); - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_TemplateMessage_FourRowTemplate::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .proto.Message.DocumentMessage documentMessage = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_documentmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .proto.Message.HighlyStructuredMessage highlyStructuredMessage = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_highlystructuredmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .proto.Message.ImageMessage imageMessage = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_imagemessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .proto.Message.VideoMessage videoMessage = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_videomessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .proto.Message.LocationMessage locationMessage = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - ptr = ctx->ParseMessage(_internal_mutable_locationmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.HighlyStructuredMessage content = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - ptr = ctx->ParseMessage(_internal_mutable_content(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.HighlyStructuredMessage footer = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - ptr = ctx->ParseMessage(_internal_mutable_footer(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated .proto.TemplateButton buttons = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_buttons(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(ptr)); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_TemplateMessage_FourRowTemplate::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.TemplateMessage.FourRowTemplate) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - switch (title_case()) { - case kDocumentMessage: { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::documentmessage(this), - _Internal::documentmessage(this).GetCachedSize(), target, stream); - break; - } - case kHighlyStructuredMessage: { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::highlystructuredmessage(this), - _Internal::highlystructuredmessage(this).GetCachedSize(), target, stream); - break; - } - case kImageMessage: { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, _Internal::imagemessage(this), - _Internal::imagemessage(this).GetCachedSize(), target, stream); - break; - } - case kVideoMessage: { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(4, _Internal::videomessage(this), - _Internal::videomessage(this).GetCachedSize(), target, stream); - break; - } - case kLocationMessage: { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(5, _Internal::locationmessage(this), - _Internal::locationmessage(this).GetCachedSize(), target, stream); - break; - } - default: ; - } - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.Message.HighlyStructuredMessage content = 6; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(6, _Internal::content(this), - _Internal::content(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.HighlyStructuredMessage footer = 7; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(7, _Internal::footer(this), - _Internal::footer(this).GetCachedSize(), target, stream); - } - - // repeated .proto.TemplateButton buttons = 8; - for (unsigned i = 0, - n = static_cast(this->_internal_buttons_size()); i < n; i++) { - const auto& repfield = this->_internal_buttons(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(8, repfield, repfield.GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.TemplateMessage.FourRowTemplate) - return target; -} - -size_t Message_TemplateMessage_FourRowTemplate::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.TemplateMessage.FourRowTemplate) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.TemplateButton buttons = 8; - total_size += 1UL * this->_internal_buttons_size(); - for (const auto& msg : this->_impl_.buttons_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional .proto.Message.HighlyStructuredMessage content = 6; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.content_); - } - - // optional .proto.Message.HighlyStructuredMessage footer = 7; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.footer_); - } - - } - switch (title_case()) { - // .proto.Message.DocumentMessage documentMessage = 1; - case kDocumentMessage: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.title_.documentmessage_); - break; - } - // .proto.Message.HighlyStructuredMessage highlyStructuredMessage = 2; - case kHighlyStructuredMessage: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.title_.highlystructuredmessage_); - break; - } - // .proto.Message.ImageMessage imageMessage = 3; - case kImageMessage: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.title_.imagemessage_); - break; - } - // .proto.Message.VideoMessage videoMessage = 4; - case kVideoMessage: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.title_.videomessage_); - break; - } - // .proto.Message.LocationMessage locationMessage = 5; - case kLocationMessage: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.title_.locationmessage_); - break; - } - case TITLE_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_TemplateMessage_FourRowTemplate::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_TemplateMessage_FourRowTemplate::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_TemplateMessage_FourRowTemplate::GetClassData() const { return &_class_data_; } - - -void Message_TemplateMessage_FourRowTemplate::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.TemplateMessage.FourRowTemplate) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.buttons_.MergeFrom(from._impl_.buttons_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_mutable_content()->::proto::Message_HighlyStructuredMessage::MergeFrom( - from._internal_content()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_footer()->::proto::Message_HighlyStructuredMessage::MergeFrom( - from._internal_footer()); - } - } - switch (from.title_case()) { - case kDocumentMessage: { - _this->_internal_mutable_documentmessage()->::proto::Message_DocumentMessage::MergeFrom( - from._internal_documentmessage()); - break; - } - case kHighlyStructuredMessage: { - _this->_internal_mutable_highlystructuredmessage()->::proto::Message_HighlyStructuredMessage::MergeFrom( - from._internal_highlystructuredmessage()); - break; - } - case kImageMessage: { - _this->_internal_mutable_imagemessage()->::proto::Message_ImageMessage::MergeFrom( - from._internal_imagemessage()); - break; - } - case kVideoMessage: { - _this->_internal_mutable_videomessage()->::proto::Message_VideoMessage::MergeFrom( - from._internal_videomessage()); - break; - } - case kLocationMessage: { - _this->_internal_mutable_locationmessage()->::proto::Message_LocationMessage::MergeFrom( - from._internal_locationmessage()); - break; - } - case TITLE_NOT_SET: { - break; - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_TemplateMessage_FourRowTemplate::CopyFrom(const Message_TemplateMessage_FourRowTemplate& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.TemplateMessage.FourRowTemplate) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_TemplateMessage_FourRowTemplate::IsInitialized() const { - return true; -} - -void Message_TemplateMessage_FourRowTemplate::InternalSwap(Message_TemplateMessage_FourRowTemplate* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.buttons_.InternalSwap(&other->_impl_.buttons_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_TemplateMessage_FourRowTemplate, _impl_.footer_) - + sizeof(Message_TemplateMessage_FourRowTemplate::_impl_.footer_) - - PROTOBUF_FIELD_OFFSET(Message_TemplateMessage_FourRowTemplate, _impl_.content_)>( - reinterpret_cast(&_impl_.content_), - reinterpret_cast(&other->_impl_.content_)); - swap(_impl_.title_, other->_impl_.title_); - swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_TemplateMessage_FourRowTemplate::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[133]); -} - -// =================================================================== - -class Message_TemplateMessage_HydratedFourRowTemplate::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_hydratedcontenttext(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_hydratedfootertext(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_templateid(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static const ::proto::Message_DocumentMessage& documentmessage(const Message_TemplateMessage_HydratedFourRowTemplate* msg); - static const ::proto::Message_ImageMessage& imagemessage(const Message_TemplateMessage_HydratedFourRowTemplate* msg); - static const ::proto::Message_VideoMessage& videomessage(const Message_TemplateMessage_HydratedFourRowTemplate* msg); - static const ::proto::Message_LocationMessage& locationmessage(const Message_TemplateMessage_HydratedFourRowTemplate* msg); -}; - -const ::proto::Message_DocumentMessage& -Message_TemplateMessage_HydratedFourRowTemplate::_Internal::documentmessage(const Message_TemplateMessage_HydratedFourRowTemplate* msg) { - return *msg->_impl_.title_.documentmessage_; -} -const ::proto::Message_ImageMessage& -Message_TemplateMessage_HydratedFourRowTemplate::_Internal::imagemessage(const Message_TemplateMessage_HydratedFourRowTemplate* msg) { - return *msg->_impl_.title_.imagemessage_; -} -const ::proto::Message_VideoMessage& -Message_TemplateMessage_HydratedFourRowTemplate::_Internal::videomessage(const Message_TemplateMessage_HydratedFourRowTemplate* msg) { - return *msg->_impl_.title_.videomessage_; -} -const ::proto::Message_LocationMessage& -Message_TemplateMessage_HydratedFourRowTemplate::_Internal::locationmessage(const Message_TemplateMessage_HydratedFourRowTemplate* msg) { - return *msg->_impl_.title_.locationmessage_; -} -void Message_TemplateMessage_HydratedFourRowTemplate::set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_title(); - if (documentmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(documentmessage); - if (message_arena != submessage_arena) { - documentmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, documentmessage, submessage_arena); - } - set_has_documentmessage(); - _impl_.title_.documentmessage_ = documentmessage; - } - // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.documentMessage) -} -void Message_TemplateMessage_HydratedFourRowTemplate::set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_title(); - if (imagemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(imagemessage); - if (message_arena != submessage_arena) { - imagemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, imagemessage, submessage_arena); - } - set_has_imagemessage(); - _impl_.title_.imagemessage_ = imagemessage; - } - // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.imageMessage) -} -void Message_TemplateMessage_HydratedFourRowTemplate::set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_title(); - if (videomessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(videomessage); - if (message_arena != submessage_arena) { - videomessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, videomessage, submessage_arena); - } - set_has_videomessage(); - _impl_.title_.videomessage_ = videomessage; - } - // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.videoMessage) -} -void Message_TemplateMessage_HydratedFourRowTemplate::set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_title(); - if (locationmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(locationmessage); - if (message_arena != submessage_arena) { - locationmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, locationmessage, submessage_arena); - } - set_has_locationmessage(); - _impl_.title_.locationmessage_ = locationmessage; - } - // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.locationMessage) -} -Message_TemplateMessage_HydratedFourRowTemplate::Message_TemplateMessage_HydratedFourRowTemplate(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.TemplateMessage.HydratedFourRowTemplate) -} -Message_TemplateMessage_HydratedFourRowTemplate::Message_TemplateMessage_HydratedFourRowTemplate(const Message_TemplateMessage_HydratedFourRowTemplate& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_TemplateMessage_HydratedFourRowTemplate* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.hydratedbuttons_){from._impl_.hydratedbuttons_} - , decltype(_impl_.hydratedcontenttext_){} - , decltype(_impl_.hydratedfootertext_){} - , decltype(_impl_.templateid_){} - , decltype(_impl_.title_){} - , /*decltype(_impl_._oneof_case_)*/{}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.hydratedcontenttext_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.hydratedcontenttext_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_hydratedcontenttext()) { - _this->_impl_.hydratedcontenttext_.Set(from._internal_hydratedcontenttext(), - _this->GetArenaForAllocation()); - } - _impl_.hydratedfootertext_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.hydratedfootertext_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_hydratedfootertext()) { - _this->_impl_.hydratedfootertext_.Set(from._internal_hydratedfootertext(), - _this->GetArenaForAllocation()); - } - _impl_.templateid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.templateid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_templateid()) { - _this->_impl_.templateid_.Set(from._internal_templateid(), - _this->GetArenaForAllocation()); - } - clear_has_title(); - switch (from.title_case()) { - case kDocumentMessage: { - _this->_internal_mutable_documentmessage()->::proto::Message_DocumentMessage::MergeFrom( - from._internal_documentmessage()); - break; - } - case kHydratedTitleText: { - _this->_internal_set_hydratedtitletext(from._internal_hydratedtitletext()); - break; - } - case kImageMessage: { - _this->_internal_mutable_imagemessage()->::proto::Message_ImageMessage::MergeFrom( - from._internal_imagemessage()); - break; - } - case kVideoMessage: { - _this->_internal_mutable_videomessage()->::proto::Message_VideoMessage::MergeFrom( - from._internal_videomessage()); - break; - } - case kLocationMessage: { - _this->_internal_mutable_locationmessage()->::proto::Message_LocationMessage::MergeFrom( - from._internal_locationmessage()); - break; - } - case TITLE_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:proto.Message.TemplateMessage.HydratedFourRowTemplate) -} - -inline void Message_TemplateMessage_HydratedFourRowTemplate::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.hydratedbuttons_){arena} - , decltype(_impl_.hydratedcontenttext_){} - , decltype(_impl_.hydratedfootertext_){} - , decltype(_impl_.templateid_){} - , decltype(_impl_.title_){} - , /*decltype(_impl_._oneof_case_)*/{} - }; - _impl_.hydratedcontenttext_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.hydratedcontenttext_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.hydratedfootertext_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.hydratedfootertext_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.templateid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.templateid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - clear_has_title(); -} - -Message_TemplateMessage_HydratedFourRowTemplate::~Message_TemplateMessage_HydratedFourRowTemplate() { - // @@protoc_insertion_point(destructor:proto.Message.TemplateMessage.HydratedFourRowTemplate) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_TemplateMessage_HydratedFourRowTemplate::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.hydratedbuttons_.~RepeatedPtrField(); - _impl_.hydratedcontenttext_.Destroy(); - _impl_.hydratedfootertext_.Destroy(); - _impl_.templateid_.Destroy(); - if (has_title()) { - clear_title(); - } -} - -void Message_TemplateMessage_HydratedFourRowTemplate::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_TemplateMessage_HydratedFourRowTemplate::clear_title() { -// @@protoc_insertion_point(one_of_clear_start:proto.Message.TemplateMessage.HydratedFourRowTemplate) - switch (title_case()) { - case kDocumentMessage: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.title_.documentmessage_; - } - break; - } - case kHydratedTitleText: { - _impl_.title_.hydratedtitletext_.Destroy(); - break; - } - case kImageMessage: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.title_.imagemessage_; - } - break; - } - case kVideoMessage: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.title_.videomessage_; - } - break; - } - case kLocationMessage: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.title_.locationmessage_; - } - break; - } - case TITLE_NOT_SET: { - break; - } - } - _impl_._oneof_case_[0] = TITLE_NOT_SET; -} - - -void Message_TemplateMessage_HydratedFourRowTemplate::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.TemplateMessage.HydratedFourRowTemplate) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.hydratedbuttons_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _impl_.hydratedcontenttext_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.hydratedfootertext_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.templateid_.ClearNonDefaultToEmpty(); - } - } - clear_title(); - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_TemplateMessage_HydratedFourRowTemplate::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .proto.Message.DocumentMessage documentMessage = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_documentmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // string hydratedTitleText = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_hydratedtitletext(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedTitleText"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // .proto.Message.ImageMessage imageMessage = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_imagemessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .proto.Message.VideoMessage videoMessage = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_videomessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .proto.Message.LocationMessage locationMessage = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - ptr = ctx->ParseMessage(_internal_mutable_locationmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string hydratedContentText = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - auto str = _internal_mutable_hydratedcontenttext(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedContentText"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string hydratedFooterText = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - auto str = _internal_mutable_hydratedfootertext(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedFooterText"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // repeated .proto.HydratedTemplateButton hydratedButtons = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_hydratedbuttons(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(ptr)); - } else - goto handle_unusual; - continue; - // optional string templateId = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { - auto str = _internal_mutable_templateid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.TemplateMessage.HydratedFourRowTemplate.templateId"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_TemplateMessage_HydratedFourRowTemplate::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.TemplateMessage.HydratedFourRowTemplate) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - switch (title_case()) { - case kDocumentMessage: { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::documentmessage(this), - _Internal::documentmessage(this).GetCachedSize(), target, stream); - break; - } - case kHydratedTitleText: { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_hydratedtitletext().data(), static_cast(this->_internal_hydratedtitletext().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedTitleText"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_hydratedtitletext(), target); - break; - } - case kImageMessage: { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, _Internal::imagemessage(this), - _Internal::imagemessage(this).GetCachedSize(), target, stream); - break; - } - case kVideoMessage: { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(4, _Internal::videomessage(this), - _Internal::videomessage(this).GetCachedSize(), target, stream); - break; - } - case kLocationMessage: { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(5, _Internal::locationmessage(this), - _Internal::locationmessage(this).GetCachedSize(), target, stream); - break; - } - default: ; - } - cached_has_bits = _impl_._has_bits_[0]; - // optional string hydratedContentText = 6; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_hydratedcontenttext().data(), static_cast(this->_internal_hydratedcontenttext().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedContentText"); - target = stream->WriteStringMaybeAliased( - 6, this->_internal_hydratedcontenttext(), target); - } - - // optional string hydratedFooterText = 7; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_hydratedfootertext().data(), static_cast(this->_internal_hydratedfootertext().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedFooterText"); - target = stream->WriteStringMaybeAliased( - 7, this->_internal_hydratedfootertext(), target); - } - - // repeated .proto.HydratedTemplateButton hydratedButtons = 8; - for (unsigned i = 0, - n = static_cast(this->_internal_hydratedbuttons_size()); i < n; i++) { - const auto& repfield = this->_internal_hydratedbuttons(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(8, repfield, repfield.GetCachedSize(), target, stream); - } - - // optional string templateId = 9; - if (cached_has_bits & 0x00000004u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_templateid().data(), static_cast(this->_internal_templateid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.TemplateMessage.HydratedFourRowTemplate.templateId"); - target = stream->WriteStringMaybeAliased( - 9, this->_internal_templateid(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.TemplateMessage.HydratedFourRowTemplate) - return target; -} - -size_t Message_TemplateMessage_HydratedFourRowTemplate::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.TemplateMessage.HydratedFourRowTemplate) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.HydratedTemplateButton hydratedButtons = 8; - total_size += 1UL * this->_internal_hydratedbuttons_size(); - for (const auto& msg : this->_impl_.hydratedbuttons_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional string hydratedContentText = 6; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_hydratedcontenttext()); - } - - // optional string hydratedFooterText = 7; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_hydratedfootertext()); - } - - // optional string templateId = 9; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_templateid()); - } - - } - switch (title_case()) { - // .proto.Message.DocumentMessage documentMessage = 1; - case kDocumentMessage: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.title_.documentmessage_); - break; - } - // string hydratedTitleText = 2; - case kHydratedTitleText: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_hydratedtitletext()); - break; - } - // .proto.Message.ImageMessage imageMessage = 3; - case kImageMessage: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.title_.imagemessage_); - break; - } - // .proto.Message.VideoMessage videoMessage = 4; - case kVideoMessage: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.title_.videomessage_); - break; - } - // .proto.Message.LocationMessage locationMessage = 5; - case kLocationMessage: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.title_.locationmessage_); - break; - } - case TITLE_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_TemplateMessage_HydratedFourRowTemplate::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_TemplateMessage_HydratedFourRowTemplate::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_TemplateMessage_HydratedFourRowTemplate::GetClassData() const { return &_class_data_; } - - -void Message_TemplateMessage_HydratedFourRowTemplate::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.TemplateMessage.HydratedFourRowTemplate) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.hydratedbuttons_.MergeFrom(from._impl_.hydratedbuttons_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_hydratedcontenttext(from._internal_hydratedcontenttext()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_hydratedfootertext(from._internal_hydratedfootertext()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_templateid(from._internal_templateid()); - } - } - switch (from.title_case()) { - case kDocumentMessage: { - _this->_internal_mutable_documentmessage()->::proto::Message_DocumentMessage::MergeFrom( - from._internal_documentmessage()); - break; - } - case kHydratedTitleText: { - _this->_internal_set_hydratedtitletext(from._internal_hydratedtitletext()); - break; - } - case kImageMessage: { - _this->_internal_mutable_imagemessage()->::proto::Message_ImageMessage::MergeFrom( - from._internal_imagemessage()); - break; - } - case kVideoMessage: { - _this->_internal_mutable_videomessage()->::proto::Message_VideoMessage::MergeFrom( - from._internal_videomessage()); - break; - } - case kLocationMessage: { - _this->_internal_mutable_locationmessage()->::proto::Message_LocationMessage::MergeFrom( - from._internal_locationmessage()); - break; - } - case TITLE_NOT_SET: { - break; - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_TemplateMessage_HydratedFourRowTemplate::CopyFrom(const Message_TemplateMessage_HydratedFourRowTemplate& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.TemplateMessage.HydratedFourRowTemplate) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_TemplateMessage_HydratedFourRowTemplate::IsInitialized() const { - return true; -} - -void Message_TemplateMessage_HydratedFourRowTemplate::InternalSwap(Message_TemplateMessage_HydratedFourRowTemplate* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.hydratedbuttons_.InternalSwap(&other->_impl_.hydratedbuttons_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.hydratedcontenttext_, lhs_arena, - &other->_impl_.hydratedcontenttext_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.hydratedfootertext_, lhs_arena, - &other->_impl_.hydratedfootertext_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.templateid_, lhs_arena, - &other->_impl_.templateid_, rhs_arena - ); - swap(_impl_.title_, other->_impl_.title_); - swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_TemplateMessage_HydratedFourRowTemplate::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[134]); -} - -// =================================================================== - -class Message_TemplateMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::ContextInfo& contextinfo(const Message_TemplateMessage* msg); - static void set_has_contextinfo(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& hydratedtemplate(const Message_TemplateMessage* msg); - static void set_has_hydratedtemplate(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::proto::Message_TemplateMessage_FourRowTemplate& fourrowtemplate(const Message_TemplateMessage* msg); - static const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& hydratedfourrowtemplate(const Message_TemplateMessage* msg); -}; - -const ::proto::ContextInfo& -Message_TemplateMessage::_Internal::contextinfo(const Message_TemplateMessage* msg) { - return *msg->_impl_.contextinfo_; -} -const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& -Message_TemplateMessage::_Internal::hydratedtemplate(const Message_TemplateMessage* msg) { - return *msg->_impl_.hydratedtemplate_; -} -const ::proto::Message_TemplateMessage_FourRowTemplate& -Message_TemplateMessage::_Internal::fourrowtemplate(const Message_TemplateMessage* msg) { - return *msg->_impl_.format_.fourrowtemplate_; -} -const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& -Message_TemplateMessage::_Internal::hydratedfourrowtemplate(const Message_TemplateMessage* msg) { - return *msg->_impl_.format_.hydratedfourrowtemplate_; -} -void Message_TemplateMessage::set_allocated_fourrowtemplate(::proto::Message_TemplateMessage_FourRowTemplate* fourrowtemplate) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_format(); - if (fourrowtemplate) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(fourrowtemplate); - if (message_arena != submessage_arena) { - fourrowtemplate = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, fourrowtemplate, submessage_arena); - } - set_has_fourrowtemplate(); - _impl_.format_.fourrowtemplate_ = fourrowtemplate; - } - // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.fourRowTemplate) -} -void Message_TemplateMessage::set_allocated_hydratedfourrowtemplate(::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedfourrowtemplate) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_format(); - if (hydratedfourrowtemplate) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(hydratedfourrowtemplate); - if (message_arena != submessage_arena) { - hydratedfourrowtemplate = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, hydratedfourrowtemplate, submessage_arena); - } - set_has_hydratedfourrowtemplate(); - _impl_.format_.hydratedfourrowtemplate_ = hydratedfourrowtemplate; - } - // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.hydratedFourRowTemplate) -} -Message_TemplateMessage::Message_TemplateMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.TemplateMessage) -} -Message_TemplateMessage::Message_TemplateMessage(const Message_TemplateMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_TemplateMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.hydratedtemplate_){nullptr} - , decltype(_impl_.format_){} - , /*decltype(_impl_._oneof_case_)*/{}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_contextinfo()) { - _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); - } - if (from._internal_has_hydratedtemplate()) { - _this->_impl_.hydratedtemplate_ = new ::proto::Message_TemplateMessage_HydratedFourRowTemplate(*from._impl_.hydratedtemplate_); - } - clear_has_format(); - switch (from.format_case()) { - case kFourRowTemplate: { - _this->_internal_mutable_fourrowtemplate()->::proto::Message_TemplateMessage_FourRowTemplate::MergeFrom( - from._internal_fourrowtemplate()); - break; - } - case kHydratedFourRowTemplate: { - _this->_internal_mutable_hydratedfourrowtemplate()->::proto::Message_TemplateMessage_HydratedFourRowTemplate::MergeFrom( - from._internal_hydratedfourrowtemplate()); - break; - } - case FORMAT_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:proto.Message.TemplateMessage) -} - -inline void Message_TemplateMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.hydratedtemplate_){nullptr} - , decltype(_impl_.format_){} - , /*decltype(_impl_._oneof_case_)*/{} - }; - clear_has_format(); -} - -Message_TemplateMessage::~Message_TemplateMessage() { - // @@protoc_insertion_point(destructor:proto.Message.TemplateMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_TemplateMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete _impl_.contextinfo_; - if (this != internal_default_instance()) delete _impl_.hydratedtemplate_; - if (has_format()) { - clear_format(); - } -} - -void Message_TemplateMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_TemplateMessage::clear_format() { -// @@protoc_insertion_point(one_of_clear_start:proto.Message.TemplateMessage) - switch (format_case()) { - case kFourRowTemplate: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.format_.fourrowtemplate_; - } - break; - } - case kHydratedFourRowTemplate: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.format_.hydratedfourrowtemplate_; - } - break; - } - case FORMAT_NOT_SET: { - break; - } - } - _impl_._oneof_case_[0] = FORMAT_NOT_SET; -} - - -void Message_TemplateMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.TemplateMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); - _impl_.contextinfo_->Clear(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.hydratedtemplate_ != nullptr); - _impl_.hydratedtemplate_->Clear(); - } - } - clear_format(); - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_TemplateMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .proto.Message.TemplateMessage.FourRowTemplate fourRowTemplate = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_fourrowtemplate(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .proto.Message.TemplateMessage.HydratedFourRowTemplate hydratedFourRowTemplate = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_hydratedfourrowtemplate(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.ContextInfo contextInfo = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.TemplateMessage.HydratedFourRowTemplate hydratedTemplate = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_hydratedtemplate(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_TemplateMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.TemplateMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - switch (format_case()) { - case kFourRowTemplate: { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::fourrowtemplate(this), - _Internal::fourrowtemplate(this).GetCachedSize(), target, stream); - break; - } - case kHydratedFourRowTemplate: { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::hydratedfourrowtemplate(this), - _Internal::hydratedfourrowtemplate(this).GetCachedSize(), target, stream); - break; - } - default: ; - } - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.ContextInfo contextInfo = 3; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, _Internal::contextinfo(this), - _Internal::contextinfo(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.TemplateMessage.HydratedFourRowTemplate hydratedTemplate = 4; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(4, _Internal::hydratedtemplate(this), - _Internal::hydratedtemplate(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.TemplateMessage) - return target; -} - -size_t Message_TemplateMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.TemplateMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional .proto.ContextInfo contextInfo = 3; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.contextinfo_); - } - - // optional .proto.Message.TemplateMessage.HydratedFourRowTemplate hydratedTemplate = 4; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.hydratedtemplate_); - } - - } - switch (format_case()) { - // .proto.Message.TemplateMessage.FourRowTemplate fourRowTemplate = 1; - case kFourRowTemplate: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.format_.fourrowtemplate_); - break; - } - // .proto.Message.TemplateMessage.HydratedFourRowTemplate hydratedFourRowTemplate = 2; - case kHydratedFourRowTemplate: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.format_.hydratedfourrowtemplate_); - break; - } - case FORMAT_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_TemplateMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_TemplateMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_TemplateMessage::GetClassData() const { return &_class_data_; } - - -void Message_TemplateMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.TemplateMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( - from._internal_contextinfo()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_hydratedtemplate()->::proto::Message_TemplateMessage_HydratedFourRowTemplate::MergeFrom( - from._internal_hydratedtemplate()); - } - } - switch (from.format_case()) { - case kFourRowTemplate: { - _this->_internal_mutable_fourrowtemplate()->::proto::Message_TemplateMessage_FourRowTemplate::MergeFrom( - from._internal_fourrowtemplate()); - break; - } - case kHydratedFourRowTemplate: { - _this->_internal_mutable_hydratedfourrowtemplate()->::proto::Message_TemplateMessage_HydratedFourRowTemplate::MergeFrom( - from._internal_hydratedfourrowtemplate()); - break; - } - case FORMAT_NOT_SET: { - break; - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_TemplateMessage::CopyFrom(const Message_TemplateMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.TemplateMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_TemplateMessage::IsInitialized() const { - return true; -} - -void Message_TemplateMessage::InternalSwap(Message_TemplateMessage* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_TemplateMessage, _impl_.hydratedtemplate_) - + sizeof(Message_TemplateMessage::_impl_.hydratedtemplate_) - - PROTOBUF_FIELD_OFFSET(Message_TemplateMessage, _impl_.contextinfo_)>( - reinterpret_cast(&_impl_.contextinfo_), - reinterpret_cast(&other->_impl_.contextinfo_)); - swap(_impl_.format_, other->_impl_.format_); - swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_TemplateMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[135]); -} - -// =================================================================== - -class Message_VideoMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_url(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_mimetype(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_filesha256(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_filelength(HasBits* has_bits) { - (*has_bits)[0] |= 16384u; - } - static void set_has_seconds(HasBits* has_bits) { - (*has_bits)[0] |= 32768u; - } - static void set_has_mediakey(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_caption(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_gifplayback(HasBits* has_bits) { - (*has_bits)[0] |= 262144u; - } - static void set_has_height(HasBits* has_bits) { - (*has_bits)[0] |= 65536u; - } - static void set_has_width(HasBits* has_bits) { - (*has_bits)[0] |= 131072u; - } - static void set_has_fileencsha256(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static void set_has_directpath(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static void set_has_mediakeytimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 1048576u; - } - static void set_has_jpegthumbnail(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } - static const ::proto::ContextInfo& contextinfo(const Message_VideoMessage* msg); - static void set_has_contextinfo(HasBits* has_bits) { - (*has_bits)[0] |= 8192u; - } - static void set_has_streamingsidecar(HasBits* has_bits) { - (*has_bits)[0] |= 256u; - } - static void set_has_gifattribution(HasBits* has_bits) { - (*has_bits)[0] |= 2097152u; - } - static void set_has_viewonce(HasBits* has_bits) { - (*has_bits)[0] |= 524288u; - } - static void set_has_thumbnaildirectpath(HasBits* has_bits) { - (*has_bits)[0] |= 512u; - } - static void set_has_thumbnailsha256(HasBits* has_bits) { - (*has_bits)[0] |= 1024u; - } - static void set_has_thumbnailencsha256(HasBits* has_bits) { - (*has_bits)[0] |= 2048u; - } - static void set_has_staticurl(HasBits* has_bits) { - (*has_bits)[0] |= 4096u; - } -}; - -const ::proto::ContextInfo& -Message_VideoMessage::_Internal::contextinfo(const Message_VideoMessage* msg) { - return *msg->_impl_.contextinfo_; -} -Message_VideoMessage::Message_VideoMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message.VideoMessage) -} -Message_VideoMessage::Message_VideoMessage(const Message_VideoMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message_VideoMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.interactiveannotations_){from._impl_.interactiveannotations_} - , decltype(_impl_.url_){} - , decltype(_impl_.mimetype_){} - , decltype(_impl_.filesha256_){} - , decltype(_impl_.mediakey_){} - , decltype(_impl_.caption_){} - , decltype(_impl_.fileencsha256_){} - , decltype(_impl_.directpath_){} - , decltype(_impl_.jpegthumbnail_){} - , decltype(_impl_.streamingsidecar_){} - , decltype(_impl_.thumbnaildirectpath_){} - , decltype(_impl_.thumbnailsha256_){} - , decltype(_impl_.thumbnailencsha256_){} - , decltype(_impl_.staticurl_){} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.filelength_){} - , decltype(_impl_.seconds_){} - , decltype(_impl_.height_){} - , decltype(_impl_.width_){} - , decltype(_impl_.gifplayback_){} - , decltype(_impl_.viewonce_){} - , decltype(_impl_.mediakeytimestamp_){} - , decltype(_impl_.gifattribution_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.url_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.url_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_url()) { - _this->_impl_.url_.Set(from._internal_url(), - _this->GetArenaForAllocation()); - } - _impl_.mimetype_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mimetype_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_mimetype()) { - _this->_impl_.mimetype_.Set(from._internal_mimetype(), - _this->GetArenaForAllocation()); - } - _impl_.filesha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filesha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_filesha256()) { - _this->_impl_.filesha256_.Set(from._internal_filesha256(), - _this->GetArenaForAllocation()); - } - _impl_.mediakey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediakey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_mediakey()) { - _this->_impl_.mediakey_.Set(from._internal_mediakey(), - _this->GetArenaForAllocation()); - } - _impl_.caption_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.caption_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_caption()) { - _this->_impl_.caption_.Set(from._internal_caption(), - _this->GetArenaForAllocation()); - } - _impl_.fileencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_fileencsha256()) { - _this->_impl_.fileencsha256_.Set(from._internal_fileencsha256(), - _this->GetArenaForAllocation()); - } - _impl_.directpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_directpath()) { - _this->_impl_.directpath_.Set(from._internal_directpath(), - _this->GetArenaForAllocation()); - } - _impl_.jpegthumbnail_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_jpegthumbnail()) { - _this->_impl_.jpegthumbnail_.Set(from._internal_jpegthumbnail(), - _this->GetArenaForAllocation()); - } - _impl_.streamingsidecar_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.streamingsidecar_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_streamingsidecar()) { - _this->_impl_.streamingsidecar_.Set(from._internal_streamingsidecar(), - _this->GetArenaForAllocation()); - } - _impl_.thumbnaildirectpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_thumbnaildirectpath()) { - _this->_impl_.thumbnaildirectpath_.Set(from._internal_thumbnaildirectpath(), - _this->GetArenaForAllocation()); - } - _impl_.thumbnailsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_thumbnailsha256()) { - _this->_impl_.thumbnailsha256_.Set(from._internal_thumbnailsha256(), - _this->GetArenaForAllocation()); - } - _impl_.thumbnailencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_thumbnailencsha256()) { - _this->_impl_.thumbnailencsha256_.Set(from._internal_thumbnailencsha256(), - _this->GetArenaForAllocation()); - } - _impl_.staticurl_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.staticurl_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_staticurl()) { - _this->_impl_.staticurl_.Set(from._internal_staticurl(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_contextinfo()) { - _this->_impl_.contextinfo_ = new ::proto::ContextInfo(*from._impl_.contextinfo_); - } - ::memcpy(&_impl_.filelength_, &from._impl_.filelength_, - static_cast(reinterpret_cast(&_impl_.gifattribution_) - - reinterpret_cast(&_impl_.filelength_)) + sizeof(_impl_.gifattribution_)); - // @@protoc_insertion_point(copy_constructor:proto.Message.VideoMessage) -} - -inline void Message_VideoMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.interactiveannotations_){arena} - , decltype(_impl_.url_){} - , decltype(_impl_.mimetype_){} - , decltype(_impl_.filesha256_){} - , decltype(_impl_.mediakey_){} - , decltype(_impl_.caption_){} - , decltype(_impl_.fileencsha256_){} - , decltype(_impl_.directpath_){} - , decltype(_impl_.jpegthumbnail_){} - , decltype(_impl_.streamingsidecar_){} - , decltype(_impl_.thumbnaildirectpath_){} - , decltype(_impl_.thumbnailsha256_){} - , decltype(_impl_.thumbnailencsha256_){} - , decltype(_impl_.staticurl_){} - , decltype(_impl_.contextinfo_){nullptr} - , decltype(_impl_.filelength_){uint64_t{0u}} - , decltype(_impl_.seconds_){0u} - , decltype(_impl_.height_){0u} - , decltype(_impl_.width_){0u} - , decltype(_impl_.gifplayback_){false} - , decltype(_impl_.viewonce_){false} - , decltype(_impl_.mediakeytimestamp_){int64_t{0}} - , decltype(_impl_.gifattribution_){0} - }; - _impl_.url_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.url_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mimetype_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mimetype_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filesha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filesha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediakey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediakey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.caption_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.caption_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fileencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.jpegthumbnail_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.streamingsidecar_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.streamingsidecar_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnaildirectpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnailsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnailencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.staticurl_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.staticurl_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message_VideoMessage::~Message_VideoMessage() { - // @@protoc_insertion_point(destructor:proto.Message.VideoMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message_VideoMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.interactiveannotations_.~RepeatedPtrField(); - _impl_.url_.Destroy(); - _impl_.mimetype_.Destroy(); - _impl_.filesha256_.Destroy(); - _impl_.mediakey_.Destroy(); - _impl_.caption_.Destroy(); - _impl_.fileencsha256_.Destroy(); - _impl_.directpath_.Destroy(); - _impl_.jpegthumbnail_.Destroy(); - _impl_.streamingsidecar_.Destroy(); - _impl_.thumbnaildirectpath_.Destroy(); - _impl_.thumbnailsha256_.Destroy(); - _impl_.thumbnailencsha256_.Destroy(); - _impl_.staticurl_.Destroy(); - if (this != internal_default_instance()) delete _impl_.contextinfo_; -} - -void Message_VideoMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message_VideoMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message.VideoMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.interactiveannotations_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _impl_.url_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.mimetype_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.filesha256_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000008u) { - _impl_.mediakey_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000010u) { - _impl_.caption_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000020u) { - _impl_.fileencsha256_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000040u) { - _impl_.directpath_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000080u) { - _impl_.jpegthumbnail_.ClearNonDefaultToEmpty(); - } - } - if (cached_has_bits & 0x00003f00u) { - if (cached_has_bits & 0x00000100u) { - _impl_.streamingsidecar_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000200u) { - _impl_.thumbnaildirectpath_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000400u) { - _impl_.thumbnailsha256_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000800u) { - _impl_.thumbnailencsha256_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00001000u) { - _impl_.staticurl_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00002000u) { - GOOGLE_DCHECK(_impl_.contextinfo_ != nullptr); - _impl_.contextinfo_->Clear(); - } - } - if (cached_has_bits & 0x0000c000u) { - ::memset(&_impl_.filelength_, 0, static_cast( - reinterpret_cast(&_impl_.seconds_) - - reinterpret_cast(&_impl_.filelength_)) + sizeof(_impl_.seconds_)); - } - if (cached_has_bits & 0x003f0000u) { - ::memset(&_impl_.height_, 0, static_cast( - reinterpret_cast(&_impl_.gifattribution_) - - reinterpret_cast(&_impl_.height_)) + sizeof(_impl_.gifattribution_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message_VideoMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string url = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_url(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.VideoMessage.url"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string mimetype = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_mimetype(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.VideoMessage.mimetype"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bytes fileSha256 = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_filesha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint64 fileLength = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - _Internal::set_has_filelength(&has_bits); - _impl_.filelength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 seconds = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { - _Internal::set_has_seconds(&has_bits); - _impl_.seconds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes mediaKey = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - auto str = _internal_mutable_mediakey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string caption = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - auto str = _internal_mutable_caption(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.VideoMessage.caption"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bool gifPlayback = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { - _Internal::set_has_gifplayback(&has_bits); - _impl_.gifplayback_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 height = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { - _Internal::set_has_height(&has_bits); - _impl_.height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 width = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { - _Internal::set_has_width(&has_bits); - _impl_.width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes fileEncSha256 = 11; - case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { - auto str = _internal_mutable_fileencsha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated .proto.InteractiveAnnotation interactiveAnnotations = 12; - case 12: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_interactiveannotations(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<98>(ptr)); - } else - goto handle_unusual; - continue; - // optional string directPath = 13; - case 13: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { - auto str = _internal_mutable_directpath(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.VideoMessage.directPath"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional int64 mediaKeyTimestamp = 14; - case 14: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 112)) { - _Internal::set_has_mediakeytimestamp(&has_bits); - _impl_.mediakeytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes jpegThumbnail = 16; - case 16: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { - auto str = _internal_mutable_jpegthumbnail(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.ContextInfo contextInfo = 17; - case 17: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { - ptr = ctx->ParseMessage(_internal_mutable_contextinfo(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes streamingSidecar = 18; - case 18: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { - auto str = _internal_mutable_streamingsidecar(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.VideoMessage.Attribution gifAttribution = 19; - case 19: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 152)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::Message_VideoMessage_Attribution_IsValid(val))) { - _internal_set_gifattribution(static_cast<::proto::Message_VideoMessage_Attribution>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(19, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional bool viewOnce = 20; - case 20: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 160)) { - _Internal::set_has_viewonce(&has_bits); - _impl_.viewonce_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string thumbnailDirectPath = 21; - case 21: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { - auto str = _internal_mutable_thumbnaildirectpath(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.VideoMessage.thumbnailDirectPath"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bytes thumbnailSha256 = 22; - case 22: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 178)) { - auto str = _internal_mutable_thumbnailsha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes thumbnailEncSha256 = 23; - case 23: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { - auto str = _internal_mutable_thumbnailencsha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string staticUrl = 24; - case 24: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 194)) { - auto str = _internal_mutable_staticurl(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.VideoMessage.staticUrl"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message_VideoMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message.VideoMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string url = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_url().data(), static_cast(this->_internal_url().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.VideoMessage.url"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_url(), target); - } - - // optional string mimetype = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_mimetype().data(), static_cast(this->_internal_mimetype().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.VideoMessage.mimetype"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_mimetype(), target); - } - - // optional bytes fileSha256 = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->WriteBytesMaybeAliased( - 3, this->_internal_filesha256(), target); - } - - // optional uint64 fileLength = 4; - if (cached_has_bits & 0x00004000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_filelength(), target); - } - - // optional uint32 seconds = 5; - if (cached_has_bits & 0x00008000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_seconds(), target); - } - - // optional bytes mediaKey = 6; - if (cached_has_bits & 0x00000008u) { - target = stream->WriteBytesMaybeAliased( - 6, this->_internal_mediakey(), target); - } - - // optional string caption = 7; - if (cached_has_bits & 0x00000010u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_caption().data(), static_cast(this->_internal_caption().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.VideoMessage.caption"); - target = stream->WriteStringMaybeAliased( - 7, this->_internal_caption(), target); - } - - // optional bool gifPlayback = 8; - if (cached_has_bits & 0x00040000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(8, this->_internal_gifplayback(), target); - } - - // optional uint32 height = 9; - if (cached_has_bits & 0x00010000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(9, this->_internal_height(), target); - } - - // optional uint32 width = 10; - if (cached_has_bits & 0x00020000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(10, this->_internal_width(), target); - } - - // optional bytes fileEncSha256 = 11; - if (cached_has_bits & 0x00000020u) { - target = stream->WriteBytesMaybeAliased( - 11, this->_internal_fileencsha256(), target); - } - - // repeated .proto.InteractiveAnnotation interactiveAnnotations = 12; - for (unsigned i = 0, - n = static_cast(this->_internal_interactiveannotations_size()); i < n; i++) { - const auto& repfield = this->_internal_interactiveannotations(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(12, repfield, repfield.GetCachedSize(), target, stream); - } - - // optional string directPath = 13; - if (cached_has_bits & 0x00000040u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_directpath().data(), static_cast(this->_internal_directpath().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.VideoMessage.directPath"); - target = stream->WriteStringMaybeAliased( - 13, this->_internal_directpath(), target); - } - - // optional int64 mediaKeyTimestamp = 14; - if (cached_has_bits & 0x00100000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(14, this->_internal_mediakeytimestamp(), target); - } - - // optional bytes jpegThumbnail = 16; - if (cached_has_bits & 0x00000080u) { - target = stream->WriteBytesMaybeAliased( - 16, this->_internal_jpegthumbnail(), target); - } - - // optional .proto.ContextInfo contextInfo = 17; - if (cached_has_bits & 0x00002000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(17, _Internal::contextinfo(this), - _Internal::contextinfo(this).GetCachedSize(), target, stream); - } - - // optional bytes streamingSidecar = 18; - if (cached_has_bits & 0x00000100u) { - target = stream->WriteBytesMaybeAliased( - 18, this->_internal_streamingsidecar(), target); - } - - // optional .proto.Message.VideoMessage.Attribution gifAttribution = 19; - if (cached_has_bits & 0x00200000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 19, this->_internal_gifattribution(), target); - } - - // optional bool viewOnce = 20; - if (cached_has_bits & 0x00080000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(20, this->_internal_viewonce(), target); - } - - // optional string thumbnailDirectPath = 21; - if (cached_has_bits & 0x00000200u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_thumbnaildirectpath().data(), static_cast(this->_internal_thumbnaildirectpath().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.VideoMessage.thumbnailDirectPath"); - target = stream->WriteStringMaybeAliased( - 21, this->_internal_thumbnaildirectpath(), target); - } - - // optional bytes thumbnailSha256 = 22; - if (cached_has_bits & 0x00000400u) { - target = stream->WriteBytesMaybeAliased( - 22, this->_internal_thumbnailsha256(), target); - } - - // optional bytes thumbnailEncSha256 = 23; - if (cached_has_bits & 0x00000800u) { - target = stream->WriteBytesMaybeAliased( - 23, this->_internal_thumbnailencsha256(), target); - } - - // optional string staticUrl = 24; - if (cached_has_bits & 0x00001000u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_staticurl().data(), static_cast(this->_internal_staticurl().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.VideoMessage.staticUrl"); - target = stream->WriteStringMaybeAliased( - 24, this->_internal_staticurl(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message.VideoMessage) - return target; -} - -size_t Message_VideoMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message.VideoMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.InteractiveAnnotation interactiveAnnotations = 12; - total_size += 1UL * this->_internal_interactiveannotations_size(); - for (const auto& msg : this->_impl_.interactiveannotations_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional string url = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_url()); - } - - // optional string mimetype = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_mimetype()); - } - - // optional bytes fileSha256 = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_filesha256()); - } - - // optional bytes mediaKey = 6; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_mediakey()); - } - - // optional string caption = 7; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_caption()); - } - - // optional bytes fileEncSha256 = 11; - if (cached_has_bits & 0x00000020u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_fileencsha256()); - } - - // optional string directPath = 13; - if (cached_has_bits & 0x00000040u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_directpath()); - } - - // optional bytes jpegThumbnail = 16; - if (cached_has_bits & 0x00000080u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_jpegthumbnail()); - } - - } - if (cached_has_bits & 0x0000ff00u) { - // optional bytes streamingSidecar = 18; - if (cached_has_bits & 0x00000100u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_streamingsidecar()); - } - - // optional string thumbnailDirectPath = 21; - if (cached_has_bits & 0x00000200u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_thumbnaildirectpath()); - } - - // optional bytes thumbnailSha256 = 22; - if (cached_has_bits & 0x00000400u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_thumbnailsha256()); - } - - // optional bytes thumbnailEncSha256 = 23; - if (cached_has_bits & 0x00000800u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_thumbnailencsha256()); - } - - // optional string staticUrl = 24; - if (cached_has_bits & 0x00001000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_staticurl()); - } - - // optional .proto.ContextInfo contextInfo = 17; - if (cached_has_bits & 0x00002000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.contextinfo_); - } - - // optional uint64 fileLength = 4; - if (cached_has_bits & 0x00004000u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_filelength()); - } - - // optional uint32 seconds = 5; - if (cached_has_bits & 0x00008000u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_seconds()); - } - - } - if (cached_has_bits & 0x003f0000u) { - // optional uint32 height = 9; - if (cached_has_bits & 0x00010000u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_height()); - } - - // optional uint32 width = 10; - if (cached_has_bits & 0x00020000u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_width()); - } - - // optional bool gifPlayback = 8; - if (cached_has_bits & 0x00040000u) { - total_size += 1 + 1; - } - - // optional bool viewOnce = 20; - if (cached_has_bits & 0x00080000u) { - total_size += 2 + 1; - } - - // optional int64 mediaKeyTimestamp = 14; - if (cached_has_bits & 0x00100000u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_mediakeytimestamp()); - } - - // optional .proto.Message.VideoMessage.Attribution gifAttribution = 19; - if (cached_has_bits & 0x00200000u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_gifattribution()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message_VideoMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message_VideoMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message_VideoMessage::GetClassData() const { return &_class_data_; } - - -void Message_VideoMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message.VideoMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.interactiveannotations_.MergeFrom(from._impl_.interactiveannotations_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_url(from._internal_url()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_mimetype(from._internal_mimetype()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_filesha256(from._internal_filesha256()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_set_mediakey(from._internal_mediakey()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_set_caption(from._internal_caption()); - } - if (cached_has_bits & 0x00000020u) { - _this->_internal_set_fileencsha256(from._internal_fileencsha256()); - } - if (cached_has_bits & 0x00000040u) { - _this->_internal_set_directpath(from._internal_directpath()); - } - if (cached_has_bits & 0x00000080u) { - _this->_internal_set_jpegthumbnail(from._internal_jpegthumbnail()); - } - } - if (cached_has_bits & 0x0000ff00u) { - if (cached_has_bits & 0x00000100u) { - _this->_internal_set_streamingsidecar(from._internal_streamingsidecar()); - } - if (cached_has_bits & 0x00000200u) { - _this->_internal_set_thumbnaildirectpath(from._internal_thumbnaildirectpath()); - } - if (cached_has_bits & 0x00000400u) { - _this->_internal_set_thumbnailsha256(from._internal_thumbnailsha256()); - } - if (cached_has_bits & 0x00000800u) { - _this->_internal_set_thumbnailencsha256(from._internal_thumbnailencsha256()); - } - if (cached_has_bits & 0x00001000u) { - _this->_internal_set_staticurl(from._internal_staticurl()); - } - if (cached_has_bits & 0x00002000u) { - _this->_internal_mutable_contextinfo()->::proto::ContextInfo::MergeFrom( - from._internal_contextinfo()); - } - if (cached_has_bits & 0x00004000u) { - _this->_impl_.filelength_ = from._impl_.filelength_; - } - if (cached_has_bits & 0x00008000u) { - _this->_impl_.seconds_ = from._impl_.seconds_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - if (cached_has_bits & 0x003f0000u) { - if (cached_has_bits & 0x00010000u) { - _this->_impl_.height_ = from._impl_.height_; - } - if (cached_has_bits & 0x00020000u) { - _this->_impl_.width_ = from._impl_.width_; - } - if (cached_has_bits & 0x00040000u) { - _this->_impl_.gifplayback_ = from._impl_.gifplayback_; - } - if (cached_has_bits & 0x00080000u) { - _this->_impl_.viewonce_ = from._impl_.viewonce_; - } - if (cached_has_bits & 0x00100000u) { - _this->_impl_.mediakeytimestamp_ = from._impl_.mediakeytimestamp_; - } - if (cached_has_bits & 0x00200000u) { - _this->_impl_.gifattribution_ = from._impl_.gifattribution_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message_VideoMessage::CopyFrom(const Message_VideoMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message.VideoMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message_VideoMessage::IsInitialized() const { - return true; -} - -void Message_VideoMessage::InternalSwap(Message_VideoMessage* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.interactiveannotations_.InternalSwap(&other->_impl_.interactiveannotations_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.url_, lhs_arena, - &other->_impl_.url_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.mimetype_, lhs_arena, - &other->_impl_.mimetype_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.filesha256_, lhs_arena, - &other->_impl_.filesha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.mediakey_, lhs_arena, - &other->_impl_.mediakey_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.caption_, lhs_arena, - &other->_impl_.caption_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.fileencsha256_, lhs_arena, - &other->_impl_.fileencsha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.directpath_, lhs_arena, - &other->_impl_.directpath_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.jpegthumbnail_, lhs_arena, - &other->_impl_.jpegthumbnail_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.streamingsidecar_, lhs_arena, - &other->_impl_.streamingsidecar_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.thumbnaildirectpath_, lhs_arena, - &other->_impl_.thumbnaildirectpath_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.thumbnailsha256_, lhs_arena, - &other->_impl_.thumbnailsha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.thumbnailencsha256_, lhs_arena, - &other->_impl_.thumbnailencsha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.staticurl_, lhs_arena, - &other->_impl_.staticurl_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message_VideoMessage, _impl_.gifattribution_) - + sizeof(Message_VideoMessage::_impl_.gifattribution_) - - PROTOBUF_FIELD_OFFSET(Message_VideoMessage, _impl_.contextinfo_)>( - reinterpret_cast(&_impl_.contextinfo_), - reinterpret_cast(&other->_impl_.contextinfo_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message_VideoMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[136]); -} - -// =================================================================== - -class Message::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_conversation(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::proto::Message_SenderKeyDistributionMessage& senderkeydistributionmessage(const Message* msg); - static void set_has_senderkeydistributionmessage(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::proto::Message_ImageMessage& imagemessage(const Message* msg); - static void set_has_imagemessage(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static const ::proto::Message_ContactMessage& contactmessage(const Message* msg); - static void set_has_contactmessage(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static const ::proto::Message_LocationMessage& locationmessage(const Message* msg); - static void set_has_locationmessage(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static const ::proto::Message_ExtendedTextMessage& extendedtextmessage(const Message* msg); - static void set_has_extendedtextmessage(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static const ::proto::Message_DocumentMessage& documentmessage(const Message* msg); - static void set_has_documentmessage(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static const ::proto::Message_AudioMessage& audiomessage(const Message* msg); - static void set_has_audiomessage(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } - static const ::proto::Message_VideoMessage& videomessage(const Message* msg); - static void set_has_videomessage(HasBits* has_bits) { - (*has_bits)[0] |= 256u; - } - static const ::proto::Message_Call& call(const Message* msg); - static void set_has_call(HasBits* has_bits) { - (*has_bits)[0] |= 512u; - } - static const ::proto::Message_Chat& chat(const Message* msg); - static void set_has_chat(HasBits* has_bits) { - (*has_bits)[0] |= 1024u; - } - static const ::proto::Message_ProtocolMessage& protocolmessage(const Message* msg); - static void set_has_protocolmessage(HasBits* has_bits) { - (*has_bits)[0] |= 2048u; - } - static const ::proto::Message_ContactsArrayMessage& contactsarraymessage(const Message* msg); - static void set_has_contactsarraymessage(HasBits* has_bits) { - (*has_bits)[0] |= 4096u; - } - static const ::proto::Message_HighlyStructuredMessage& highlystructuredmessage(const Message* msg); - static void set_has_highlystructuredmessage(HasBits* has_bits) { - (*has_bits)[0] |= 8192u; - } - static const ::proto::Message_SenderKeyDistributionMessage& fastratchetkeysenderkeydistributionmessage(const Message* msg); - static void set_has_fastratchetkeysenderkeydistributionmessage(HasBits* has_bits) { - (*has_bits)[0] |= 16384u; - } - static const ::proto::Message_SendPaymentMessage& sendpaymentmessage(const Message* msg); - static void set_has_sendpaymentmessage(HasBits* has_bits) { - (*has_bits)[0] |= 32768u; - } - static const ::proto::Message_LiveLocationMessage& livelocationmessage(const Message* msg); - static void set_has_livelocationmessage(HasBits* has_bits) { - (*has_bits)[0] |= 65536u; - } - static const ::proto::Message_RequestPaymentMessage& requestpaymentmessage(const Message* msg); - static void set_has_requestpaymentmessage(HasBits* has_bits) { - (*has_bits)[0] |= 131072u; - } - static const ::proto::Message_DeclinePaymentRequestMessage& declinepaymentrequestmessage(const Message* msg); - static void set_has_declinepaymentrequestmessage(HasBits* has_bits) { - (*has_bits)[0] |= 262144u; - } - static const ::proto::Message_CancelPaymentRequestMessage& cancelpaymentrequestmessage(const Message* msg); - static void set_has_cancelpaymentrequestmessage(HasBits* has_bits) { - (*has_bits)[0] |= 524288u; - } - static const ::proto::Message_TemplateMessage& templatemessage(const Message* msg); - static void set_has_templatemessage(HasBits* has_bits) { - (*has_bits)[0] |= 1048576u; - } - static const ::proto::Message_StickerMessage& stickermessage(const Message* msg); - static void set_has_stickermessage(HasBits* has_bits) { - (*has_bits)[0] |= 2097152u; - } - static const ::proto::Message_GroupInviteMessage& groupinvitemessage(const Message* msg); - static void set_has_groupinvitemessage(HasBits* has_bits) { - (*has_bits)[0] |= 4194304u; - } - static const ::proto::Message_TemplateButtonReplyMessage& templatebuttonreplymessage(const Message* msg); - static void set_has_templatebuttonreplymessage(HasBits* has_bits) { - (*has_bits)[0] |= 8388608u; - } - static const ::proto::Message_ProductMessage& productmessage(const Message* msg); - static void set_has_productmessage(HasBits* has_bits) { - (*has_bits)[0] |= 16777216u; - } - static const ::proto::Message_DeviceSentMessage& devicesentmessage(const Message* msg); - static void set_has_devicesentmessage(HasBits* has_bits) { - (*has_bits)[0] |= 33554432u; - } - static const ::proto::MessageContextInfo& messagecontextinfo(const Message* msg); - static void set_has_messagecontextinfo(HasBits* has_bits) { - (*has_bits)[0] |= 67108864u; - } - static const ::proto::Message_ListMessage& listmessage(const Message* msg); - static void set_has_listmessage(HasBits* has_bits) { - (*has_bits)[0] |= 134217728u; - } - static const ::proto::Message_FutureProofMessage& viewoncemessage(const Message* msg); - static void set_has_viewoncemessage(HasBits* has_bits) { - (*has_bits)[0] |= 268435456u; - } - static const ::proto::Message_OrderMessage& ordermessage(const Message* msg); - static void set_has_ordermessage(HasBits* has_bits) { - (*has_bits)[0] |= 536870912u; - } - static const ::proto::Message_ListResponseMessage& listresponsemessage(const Message* msg); - static void set_has_listresponsemessage(HasBits* has_bits) { - (*has_bits)[0] |= 1073741824u; - } - static const ::proto::Message_FutureProofMessage& ephemeralmessage(const Message* msg); - static void set_has_ephemeralmessage(HasBits* has_bits) { - (*has_bits)[0] |= 2147483648u; - } - static const ::proto::Message_InvoiceMessage& invoicemessage(const Message* msg); - static void set_has_invoicemessage(HasBits* has_bits) { - (*has_bits)[1] |= 1u; - } - static const ::proto::Message_ButtonsMessage& buttonsmessage(const Message* msg); - static void set_has_buttonsmessage(HasBits* has_bits) { - (*has_bits)[1] |= 2u; - } - static const ::proto::Message_ButtonsResponseMessage& buttonsresponsemessage(const Message* msg); - static void set_has_buttonsresponsemessage(HasBits* has_bits) { - (*has_bits)[1] |= 4u; - } - static const ::proto::Message_PaymentInviteMessage& paymentinvitemessage(const Message* msg); - static void set_has_paymentinvitemessage(HasBits* has_bits) { - (*has_bits)[1] |= 8u; - } - static const ::proto::Message_InteractiveMessage& interactivemessage(const Message* msg); - static void set_has_interactivemessage(HasBits* has_bits) { - (*has_bits)[1] |= 16u; - } - static const ::proto::Message_ReactionMessage& reactionmessage(const Message* msg); - static void set_has_reactionmessage(HasBits* has_bits) { - (*has_bits)[1] |= 32u; - } - static const ::proto::Message_StickerSyncRMRMessage& stickersyncrmrmessage(const Message* msg); - static void set_has_stickersyncrmrmessage(HasBits* has_bits) { - (*has_bits)[1] |= 64u; - } - static const ::proto::Message_InteractiveResponseMessage& interactiveresponsemessage(const Message* msg); - static void set_has_interactiveresponsemessage(HasBits* has_bits) { - (*has_bits)[1] |= 128u; - } - static const ::proto::Message_PollCreationMessage& pollcreationmessage(const Message* msg); - static void set_has_pollcreationmessage(HasBits* has_bits) { - (*has_bits)[1] |= 256u; - } - static const ::proto::Message_PollUpdateMessage& pollupdatemessage(const Message* msg); - static void set_has_pollupdatemessage(HasBits* has_bits) { - (*has_bits)[1] |= 512u; - } - static const ::proto::Message_KeepInChatMessage& keepinchatmessage(const Message* msg); - static void set_has_keepinchatmessage(HasBits* has_bits) { - (*has_bits)[1] |= 1024u; - } - static const ::proto::Message_FutureProofMessage& documentwithcaptionmessage(const Message* msg); - static void set_has_documentwithcaptionmessage(HasBits* has_bits) { - (*has_bits)[1] |= 2048u; - } - static const ::proto::Message_RequestPhoneNumberMessage& requestphonenumbermessage(const Message* msg); - static void set_has_requestphonenumbermessage(HasBits* has_bits) { - (*has_bits)[1] |= 4096u; - } - static const ::proto::Message_FutureProofMessage& viewoncemessagev2(const Message* msg); - static void set_has_viewoncemessagev2(HasBits* has_bits) { - (*has_bits)[1] |= 8192u; - } -}; - -const ::proto::Message_SenderKeyDistributionMessage& -Message::_Internal::senderkeydistributionmessage(const Message* msg) { - return *msg->_impl_.senderkeydistributionmessage_; -} -const ::proto::Message_ImageMessage& -Message::_Internal::imagemessage(const Message* msg) { - return *msg->_impl_.imagemessage_; -} -const ::proto::Message_ContactMessage& -Message::_Internal::contactmessage(const Message* msg) { - return *msg->_impl_.contactmessage_; -} -const ::proto::Message_LocationMessage& -Message::_Internal::locationmessage(const Message* msg) { - return *msg->_impl_.locationmessage_; -} -const ::proto::Message_ExtendedTextMessage& -Message::_Internal::extendedtextmessage(const Message* msg) { - return *msg->_impl_.extendedtextmessage_; -} -const ::proto::Message_DocumentMessage& -Message::_Internal::documentmessage(const Message* msg) { - return *msg->_impl_.documentmessage_; -} -const ::proto::Message_AudioMessage& -Message::_Internal::audiomessage(const Message* msg) { - return *msg->_impl_.audiomessage_; -} -const ::proto::Message_VideoMessage& -Message::_Internal::videomessage(const Message* msg) { - return *msg->_impl_.videomessage_; -} -const ::proto::Message_Call& -Message::_Internal::call(const Message* msg) { - return *msg->_impl_.call_; -} -const ::proto::Message_Chat& -Message::_Internal::chat(const Message* msg) { - return *msg->_impl_.chat_; -} -const ::proto::Message_ProtocolMessage& -Message::_Internal::protocolmessage(const Message* msg) { - return *msg->_impl_.protocolmessage_; -} -const ::proto::Message_ContactsArrayMessage& -Message::_Internal::contactsarraymessage(const Message* msg) { - return *msg->_impl_.contactsarraymessage_; -} -const ::proto::Message_HighlyStructuredMessage& -Message::_Internal::highlystructuredmessage(const Message* msg) { - return *msg->_impl_.highlystructuredmessage_; -} -const ::proto::Message_SenderKeyDistributionMessage& -Message::_Internal::fastratchetkeysenderkeydistributionmessage(const Message* msg) { - return *msg->_impl_.fastratchetkeysenderkeydistributionmessage_; -} -const ::proto::Message_SendPaymentMessage& -Message::_Internal::sendpaymentmessage(const Message* msg) { - return *msg->_impl_.sendpaymentmessage_; -} -const ::proto::Message_LiveLocationMessage& -Message::_Internal::livelocationmessage(const Message* msg) { - return *msg->_impl_.livelocationmessage_; -} -const ::proto::Message_RequestPaymentMessage& -Message::_Internal::requestpaymentmessage(const Message* msg) { - return *msg->_impl_.requestpaymentmessage_; -} -const ::proto::Message_DeclinePaymentRequestMessage& -Message::_Internal::declinepaymentrequestmessage(const Message* msg) { - return *msg->_impl_.declinepaymentrequestmessage_; -} -const ::proto::Message_CancelPaymentRequestMessage& -Message::_Internal::cancelpaymentrequestmessage(const Message* msg) { - return *msg->_impl_.cancelpaymentrequestmessage_; -} -const ::proto::Message_TemplateMessage& -Message::_Internal::templatemessage(const Message* msg) { - return *msg->_impl_.templatemessage_; -} -const ::proto::Message_StickerMessage& -Message::_Internal::stickermessage(const Message* msg) { - return *msg->_impl_.stickermessage_; -} -const ::proto::Message_GroupInviteMessage& -Message::_Internal::groupinvitemessage(const Message* msg) { - return *msg->_impl_.groupinvitemessage_; -} -const ::proto::Message_TemplateButtonReplyMessage& -Message::_Internal::templatebuttonreplymessage(const Message* msg) { - return *msg->_impl_.templatebuttonreplymessage_; -} -const ::proto::Message_ProductMessage& -Message::_Internal::productmessage(const Message* msg) { - return *msg->_impl_.productmessage_; -} -const ::proto::Message_DeviceSentMessage& -Message::_Internal::devicesentmessage(const Message* msg) { - return *msg->_impl_.devicesentmessage_; -} -const ::proto::MessageContextInfo& -Message::_Internal::messagecontextinfo(const Message* msg) { - return *msg->_impl_.messagecontextinfo_; -} -const ::proto::Message_ListMessage& -Message::_Internal::listmessage(const Message* msg) { - return *msg->_impl_.listmessage_; -} -const ::proto::Message_FutureProofMessage& -Message::_Internal::viewoncemessage(const Message* msg) { - return *msg->_impl_.viewoncemessage_; -} -const ::proto::Message_OrderMessage& -Message::_Internal::ordermessage(const Message* msg) { - return *msg->_impl_.ordermessage_; -} -const ::proto::Message_ListResponseMessage& -Message::_Internal::listresponsemessage(const Message* msg) { - return *msg->_impl_.listresponsemessage_; -} -const ::proto::Message_FutureProofMessage& -Message::_Internal::ephemeralmessage(const Message* msg) { - return *msg->_impl_.ephemeralmessage_; -} -const ::proto::Message_InvoiceMessage& -Message::_Internal::invoicemessage(const Message* msg) { - return *msg->_impl_.invoicemessage_; -} -const ::proto::Message_ButtonsMessage& -Message::_Internal::buttonsmessage(const Message* msg) { - return *msg->_impl_.buttonsmessage_; -} -const ::proto::Message_ButtonsResponseMessage& -Message::_Internal::buttonsresponsemessage(const Message* msg) { - return *msg->_impl_.buttonsresponsemessage_; -} -const ::proto::Message_PaymentInviteMessage& -Message::_Internal::paymentinvitemessage(const Message* msg) { - return *msg->_impl_.paymentinvitemessage_; -} -const ::proto::Message_InteractiveMessage& -Message::_Internal::interactivemessage(const Message* msg) { - return *msg->_impl_.interactivemessage_; -} -const ::proto::Message_ReactionMessage& -Message::_Internal::reactionmessage(const Message* msg) { - return *msg->_impl_.reactionmessage_; -} -const ::proto::Message_StickerSyncRMRMessage& -Message::_Internal::stickersyncrmrmessage(const Message* msg) { - return *msg->_impl_.stickersyncrmrmessage_; -} -const ::proto::Message_InteractiveResponseMessage& -Message::_Internal::interactiveresponsemessage(const Message* msg) { - return *msg->_impl_.interactiveresponsemessage_; -} -const ::proto::Message_PollCreationMessage& -Message::_Internal::pollcreationmessage(const Message* msg) { - return *msg->_impl_.pollcreationmessage_; -} -const ::proto::Message_PollUpdateMessage& -Message::_Internal::pollupdatemessage(const Message* msg) { - return *msg->_impl_.pollupdatemessage_; -} -const ::proto::Message_KeepInChatMessage& -Message::_Internal::keepinchatmessage(const Message* msg) { - return *msg->_impl_.keepinchatmessage_; -} -const ::proto::Message_FutureProofMessage& -Message::_Internal::documentwithcaptionmessage(const Message* msg) { - return *msg->_impl_.documentwithcaptionmessage_; -} -const ::proto::Message_RequestPhoneNumberMessage& -Message::_Internal::requestphonenumbermessage(const Message* msg) { - return *msg->_impl_.requestphonenumbermessage_; -} -const ::proto::Message_FutureProofMessage& -Message::_Internal::viewoncemessagev2(const Message* msg) { - return *msg->_impl_.viewoncemessagev2_; -} -Message::Message(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Message) -} -Message::Message(const Message& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Message* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.conversation_){} - , decltype(_impl_.senderkeydistributionmessage_){nullptr} - , decltype(_impl_.imagemessage_){nullptr} - , decltype(_impl_.contactmessage_){nullptr} - , decltype(_impl_.locationmessage_){nullptr} - , decltype(_impl_.extendedtextmessage_){nullptr} - , decltype(_impl_.documentmessage_){nullptr} - , decltype(_impl_.audiomessage_){nullptr} - , decltype(_impl_.videomessage_){nullptr} - , decltype(_impl_.call_){nullptr} - , decltype(_impl_.chat_){nullptr} - , decltype(_impl_.protocolmessage_){nullptr} - , decltype(_impl_.contactsarraymessage_){nullptr} - , decltype(_impl_.highlystructuredmessage_){nullptr} - , decltype(_impl_.fastratchetkeysenderkeydistributionmessage_){nullptr} - , decltype(_impl_.sendpaymentmessage_){nullptr} - , decltype(_impl_.livelocationmessage_){nullptr} - , decltype(_impl_.requestpaymentmessage_){nullptr} - , decltype(_impl_.declinepaymentrequestmessage_){nullptr} - , decltype(_impl_.cancelpaymentrequestmessage_){nullptr} - , decltype(_impl_.templatemessage_){nullptr} - , decltype(_impl_.stickermessage_){nullptr} - , decltype(_impl_.groupinvitemessage_){nullptr} - , decltype(_impl_.templatebuttonreplymessage_){nullptr} - , decltype(_impl_.productmessage_){nullptr} - , decltype(_impl_.devicesentmessage_){nullptr} - , decltype(_impl_.messagecontextinfo_){nullptr} - , decltype(_impl_.listmessage_){nullptr} - , decltype(_impl_.viewoncemessage_){nullptr} - , decltype(_impl_.ordermessage_){nullptr} - , decltype(_impl_.listresponsemessage_){nullptr} - , decltype(_impl_.ephemeralmessage_){nullptr} - , decltype(_impl_.invoicemessage_){nullptr} - , decltype(_impl_.buttonsmessage_){nullptr} - , decltype(_impl_.buttonsresponsemessage_){nullptr} - , decltype(_impl_.paymentinvitemessage_){nullptr} - , decltype(_impl_.interactivemessage_){nullptr} - , decltype(_impl_.reactionmessage_){nullptr} - , decltype(_impl_.stickersyncrmrmessage_){nullptr} - , decltype(_impl_.interactiveresponsemessage_){nullptr} - , decltype(_impl_.pollcreationmessage_){nullptr} - , decltype(_impl_.pollupdatemessage_){nullptr} - , decltype(_impl_.keepinchatmessage_){nullptr} - , decltype(_impl_.documentwithcaptionmessage_){nullptr} - , decltype(_impl_.requestphonenumbermessage_){nullptr} - , decltype(_impl_.viewoncemessagev2_){nullptr}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.conversation_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.conversation_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_conversation()) { - _this->_impl_.conversation_.Set(from._internal_conversation(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_senderkeydistributionmessage()) { - _this->_impl_.senderkeydistributionmessage_ = new ::proto::Message_SenderKeyDistributionMessage(*from._impl_.senderkeydistributionmessage_); - } - if (from._internal_has_imagemessage()) { - _this->_impl_.imagemessage_ = new ::proto::Message_ImageMessage(*from._impl_.imagemessage_); - } - if (from._internal_has_contactmessage()) { - _this->_impl_.contactmessage_ = new ::proto::Message_ContactMessage(*from._impl_.contactmessage_); - } - if (from._internal_has_locationmessage()) { - _this->_impl_.locationmessage_ = new ::proto::Message_LocationMessage(*from._impl_.locationmessage_); - } - if (from._internal_has_extendedtextmessage()) { - _this->_impl_.extendedtextmessage_ = new ::proto::Message_ExtendedTextMessage(*from._impl_.extendedtextmessage_); - } - if (from._internal_has_documentmessage()) { - _this->_impl_.documentmessage_ = new ::proto::Message_DocumentMessage(*from._impl_.documentmessage_); - } - if (from._internal_has_audiomessage()) { - _this->_impl_.audiomessage_ = new ::proto::Message_AudioMessage(*from._impl_.audiomessage_); - } - if (from._internal_has_videomessage()) { - _this->_impl_.videomessage_ = new ::proto::Message_VideoMessage(*from._impl_.videomessage_); - } - if (from._internal_has_call()) { - _this->_impl_.call_ = new ::proto::Message_Call(*from._impl_.call_); - } - if (from._internal_has_chat()) { - _this->_impl_.chat_ = new ::proto::Message_Chat(*from._impl_.chat_); - } - if (from._internal_has_protocolmessage()) { - _this->_impl_.protocolmessage_ = new ::proto::Message_ProtocolMessage(*from._impl_.protocolmessage_); - } - if (from._internal_has_contactsarraymessage()) { - _this->_impl_.contactsarraymessage_ = new ::proto::Message_ContactsArrayMessage(*from._impl_.contactsarraymessage_); - } - if (from._internal_has_highlystructuredmessage()) { - _this->_impl_.highlystructuredmessage_ = new ::proto::Message_HighlyStructuredMessage(*from._impl_.highlystructuredmessage_); - } - if (from._internal_has_fastratchetkeysenderkeydistributionmessage()) { - _this->_impl_.fastratchetkeysenderkeydistributionmessage_ = new ::proto::Message_SenderKeyDistributionMessage(*from._impl_.fastratchetkeysenderkeydistributionmessage_); - } - if (from._internal_has_sendpaymentmessage()) { - _this->_impl_.sendpaymentmessage_ = new ::proto::Message_SendPaymentMessage(*from._impl_.sendpaymentmessage_); - } - if (from._internal_has_livelocationmessage()) { - _this->_impl_.livelocationmessage_ = new ::proto::Message_LiveLocationMessage(*from._impl_.livelocationmessage_); - } - if (from._internal_has_requestpaymentmessage()) { - _this->_impl_.requestpaymentmessage_ = new ::proto::Message_RequestPaymentMessage(*from._impl_.requestpaymentmessage_); - } - if (from._internal_has_declinepaymentrequestmessage()) { - _this->_impl_.declinepaymentrequestmessage_ = new ::proto::Message_DeclinePaymentRequestMessage(*from._impl_.declinepaymentrequestmessage_); - } - if (from._internal_has_cancelpaymentrequestmessage()) { - _this->_impl_.cancelpaymentrequestmessage_ = new ::proto::Message_CancelPaymentRequestMessage(*from._impl_.cancelpaymentrequestmessage_); - } - if (from._internal_has_templatemessage()) { - _this->_impl_.templatemessage_ = new ::proto::Message_TemplateMessage(*from._impl_.templatemessage_); - } - if (from._internal_has_stickermessage()) { - _this->_impl_.stickermessage_ = new ::proto::Message_StickerMessage(*from._impl_.stickermessage_); - } - if (from._internal_has_groupinvitemessage()) { - _this->_impl_.groupinvitemessage_ = new ::proto::Message_GroupInviteMessage(*from._impl_.groupinvitemessage_); - } - if (from._internal_has_templatebuttonreplymessage()) { - _this->_impl_.templatebuttonreplymessage_ = new ::proto::Message_TemplateButtonReplyMessage(*from._impl_.templatebuttonreplymessage_); - } - if (from._internal_has_productmessage()) { - _this->_impl_.productmessage_ = new ::proto::Message_ProductMessage(*from._impl_.productmessage_); - } - if (from._internal_has_devicesentmessage()) { - _this->_impl_.devicesentmessage_ = new ::proto::Message_DeviceSentMessage(*from._impl_.devicesentmessage_); - } - if (from._internal_has_messagecontextinfo()) { - _this->_impl_.messagecontextinfo_ = new ::proto::MessageContextInfo(*from._impl_.messagecontextinfo_); - } - if (from._internal_has_listmessage()) { - _this->_impl_.listmessage_ = new ::proto::Message_ListMessage(*from._impl_.listmessage_); - } - if (from._internal_has_viewoncemessage()) { - _this->_impl_.viewoncemessage_ = new ::proto::Message_FutureProofMessage(*from._impl_.viewoncemessage_); - } - if (from._internal_has_ordermessage()) { - _this->_impl_.ordermessage_ = new ::proto::Message_OrderMessage(*from._impl_.ordermessage_); - } - if (from._internal_has_listresponsemessage()) { - _this->_impl_.listresponsemessage_ = new ::proto::Message_ListResponseMessage(*from._impl_.listresponsemessage_); - } - if (from._internal_has_ephemeralmessage()) { - _this->_impl_.ephemeralmessage_ = new ::proto::Message_FutureProofMessage(*from._impl_.ephemeralmessage_); - } - if (from._internal_has_invoicemessage()) { - _this->_impl_.invoicemessage_ = new ::proto::Message_InvoiceMessage(*from._impl_.invoicemessage_); - } - if (from._internal_has_buttonsmessage()) { - _this->_impl_.buttonsmessage_ = new ::proto::Message_ButtonsMessage(*from._impl_.buttonsmessage_); - } - if (from._internal_has_buttonsresponsemessage()) { - _this->_impl_.buttonsresponsemessage_ = new ::proto::Message_ButtonsResponseMessage(*from._impl_.buttonsresponsemessage_); - } - if (from._internal_has_paymentinvitemessage()) { - _this->_impl_.paymentinvitemessage_ = new ::proto::Message_PaymentInviteMessage(*from._impl_.paymentinvitemessage_); - } - if (from._internal_has_interactivemessage()) { - _this->_impl_.interactivemessage_ = new ::proto::Message_InteractiveMessage(*from._impl_.interactivemessage_); - } - if (from._internal_has_reactionmessage()) { - _this->_impl_.reactionmessage_ = new ::proto::Message_ReactionMessage(*from._impl_.reactionmessage_); - } - if (from._internal_has_stickersyncrmrmessage()) { - _this->_impl_.stickersyncrmrmessage_ = new ::proto::Message_StickerSyncRMRMessage(*from._impl_.stickersyncrmrmessage_); - } - if (from._internal_has_interactiveresponsemessage()) { - _this->_impl_.interactiveresponsemessage_ = new ::proto::Message_InteractiveResponseMessage(*from._impl_.interactiveresponsemessage_); - } - if (from._internal_has_pollcreationmessage()) { - _this->_impl_.pollcreationmessage_ = new ::proto::Message_PollCreationMessage(*from._impl_.pollcreationmessage_); - } - if (from._internal_has_pollupdatemessage()) { - _this->_impl_.pollupdatemessage_ = new ::proto::Message_PollUpdateMessage(*from._impl_.pollupdatemessage_); - } - if (from._internal_has_keepinchatmessage()) { - _this->_impl_.keepinchatmessage_ = new ::proto::Message_KeepInChatMessage(*from._impl_.keepinchatmessage_); - } - if (from._internal_has_documentwithcaptionmessage()) { - _this->_impl_.documentwithcaptionmessage_ = new ::proto::Message_FutureProofMessage(*from._impl_.documentwithcaptionmessage_); - } - if (from._internal_has_requestphonenumbermessage()) { - _this->_impl_.requestphonenumbermessage_ = new ::proto::Message_RequestPhoneNumberMessage(*from._impl_.requestphonenumbermessage_); - } - if (from._internal_has_viewoncemessagev2()) { - _this->_impl_.viewoncemessagev2_ = new ::proto::Message_FutureProofMessage(*from._impl_.viewoncemessagev2_); - } - // @@protoc_insertion_point(copy_constructor:proto.Message) -} - -inline void Message::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.conversation_){} - , decltype(_impl_.senderkeydistributionmessage_){nullptr} - , decltype(_impl_.imagemessage_){nullptr} - , decltype(_impl_.contactmessage_){nullptr} - , decltype(_impl_.locationmessage_){nullptr} - , decltype(_impl_.extendedtextmessage_){nullptr} - , decltype(_impl_.documentmessage_){nullptr} - , decltype(_impl_.audiomessage_){nullptr} - , decltype(_impl_.videomessage_){nullptr} - , decltype(_impl_.call_){nullptr} - , decltype(_impl_.chat_){nullptr} - , decltype(_impl_.protocolmessage_){nullptr} - , decltype(_impl_.contactsarraymessage_){nullptr} - , decltype(_impl_.highlystructuredmessage_){nullptr} - , decltype(_impl_.fastratchetkeysenderkeydistributionmessage_){nullptr} - , decltype(_impl_.sendpaymentmessage_){nullptr} - , decltype(_impl_.livelocationmessage_){nullptr} - , decltype(_impl_.requestpaymentmessage_){nullptr} - , decltype(_impl_.declinepaymentrequestmessage_){nullptr} - , decltype(_impl_.cancelpaymentrequestmessage_){nullptr} - , decltype(_impl_.templatemessage_){nullptr} - , decltype(_impl_.stickermessage_){nullptr} - , decltype(_impl_.groupinvitemessage_){nullptr} - , decltype(_impl_.templatebuttonreplymessage_){nullptr} - , decltype(_impl_.productmessage_){nullptr} - , decltype(_impl_.devicesentmessage_){nullptr} - , decltype(_impl_.messagecontextinfo_){nullptr} - , decltype(_impl_.listmessage_){nullptr} - , decltype(_impl_.viewoncemessage_){nullptr} - , decltype(_impl_.ordermessage_){nullptr} - , decltype(_impl_.listresponsemessage_){nullptr} - , decltype(_impl_.ephemeralmessage_){nullptr} - , decltype(_impl_.invoicemessage_){nullptr} - , decltype(_impl_.buttonsmessage_){nullptr} - , decltype(_impl_.buttonsresponsemessage_){nullptr} - , decltype(_impl_.paymentinvitemessage_){nullptr} - , decltype(_impl_.interactivemessage_){nullptr} - , decltype(_impl_.reactionmessage_){nullptr} - , decltype(_impl_.stickersyncrmrmessage_){nullptr} - , decltype(_impl_.interactiveresponsemessage_){nullptr} - , decltype(_impl_.pollcreationmessage_){nullptr} - , decltype(_impl_.pollupdatemessage_){nullptr} - , decltype(_impl_.keepinchatmessage_){nullptr} - , decltype(_impl_.documentwithcaptionmessage_){nullptr} - , decltype(_impl_.requestphonenumbermessage_){nullptr} - , decltype(_impl_.viewoncemessagev2_){nullptr} - }; - _impl_.conversation_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.conversation_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Message::~Message() { - // @@protoc_insertion_point(destructor:proto.Message) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Message::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.conversation_.Destroy(); - if (this != internal_default_instance()) delete _impl_.senderkeydistributionmessage_; - if (this != internal_default_instance()) delete _impl_.imagemessage_; - if (this != internal_default_instance()) delete _impl_.contactmessage_; - if (this != internal_default_instance()) delete _impl_.locationmessage_; - if (this != internal_default_instance()) delete _impl_.extendedtextmessage_; - if (this != internal_default_instance()) delete _impl_.documentmessage_; - if (this != internal_default_instance()) delete _impl_.audiomessage_; - if (this != internal_default_instance()) delete _impl_.videomessage_; - if (this != internal_default_instance()) delete _impl_.call_; - if (this != internal_default_instance()) delete _impl_.chat_; - if (this != internal_default_instance()) delete _impl_.protocolmessage_; - if (this != internal_default_instance()) delete _impl_.contactsarraymessage_; - if (this != internal_default_instance()) delete _impl_.highlystructuredmessage_; - if (this != internal_default_instance()) delete _impl_.fastratchetkeysenderkeydistributionmessage_; - if (this != internal_default_instance()) delete _impl_.sendpaymentmessage_; - if (this != internal_default_instance()) delete _impl_.livelocationmessage_; - if (this != internal_default_instance()) delete _impl_.requestpaymentmessage_; - if (this != internal_default_instance()) delete _impl_.declinepaymentrequestmessage_; - if (this != internal_default_instance()) delete _impl_.cancelpaymentrequestmessage_; - if (this != internal_default_instance()) delete _impl_.templatemessage_; - if (this != internal_default_instance()) delete _impl_.stickermessage_; - if (this != internal_default_instance()) delete _impl_.groupinvitemessage_; - if (this != internal_default_instance()) delete _impl_.templatebuttonreplymessage_; - if (this != internal_default_instance()) delete _impl_.productmessage_; - if (this != internal_default_instance()) delete _impl_.devicesentmessage_; - if (this != internal_default_instance()) delete _impl_.messagecontextinfo_; - if (this != internal_default_instance()) delete _impl_.listmessage_; - if (this != internal_default_instance()) delete _impl_.viewoncemessage_; - if (this != internal_default_instance()) delete _impl_.ordermessage_; - if (this != internal_default_instance()) delete _impl_.listresponsemessage_; - if (this != internal_default_instance()) delete _impl_.ephemeralmessage_; - if (this != internal_default_instance()) delete _impl_.invoicemessage_; - if (this != internal_default_instance()) delete _impl_.buttonsmessage_; - if (this != internal_default_instance()) delete _impl_.buttonsresponsemessage_; - if (this != internal_default_instance()) delete _impl_.paymentinvitemessage_; - if (this != internal_default_instance()) delete _impl_.interactivemessage_; - if (this != internal_default_instance()) delete _impl_.reactionmessage_; - if (this != internal_default_instance()) delete _impl_.stickersyncrmrmessage_; - if (this != internal_default_instance()) delete _impl_.interactiveresponsemessage_; - if (this != internal_default_instance()) delete _impl_.pollcreationmessage_; - if (this != internal_default_instance()) delete _impl_.pollupdatemessage_; - if (this != internal_default_instance()) delete _impl_.keepinchatmessage_; - if (this != internal_default_instance()) delete _impl_.documentwithcaptionmessage_; - if (this != internal_default_instance()) delete _impl_.requestphonenumbermessage_; - if (this != internal_default_instance()) delete _impl_.viewoncemessagev2_; -} - -void Message::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Message::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Message) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _impl_.conversation_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.senderkeydistributionmessage_ != nullptr); - _impl_.senderkeydistributionmessage_->Clear(); - } - if (cached_has_bits & 0x00000004u) { - GOOGLE_DCHECK(_impl_.imagemessage_ != nullptr); - _impl_.imagemessage_->Clear(); - } - if (cached_has_bits & 0x00000008u) { - GOOGLE_DCHECK(_impl_.contactmessage_ != nullptr); - _impl_.contactmessage_->Clear(); - } - if (cached_has_bits & 0x00000010u) { - GOOGLE_DCHECK(_impl_.locationmessage_ != nullptr); - _impl_.locationmessage_->Clear(); - } - if (cached_has_bits & 0x00000020u) { - GOOGLE_DCHECK(_impl_.extendedtextmessage_ != nullptr); - _impl_.extendedtextmessage_->Clear(); - } - if (cached_has_bits & 0x00000040u) { - GOOGLE_DCHECK(_impl_.documentmessage_ != nullptr); - _impl_.documentmessage_->Clear(); - } - if (cached_has_bits & 0x00000080u) { - GOOGLE_DCHECK(_impl_.audiomessage_ != nullptr); - _impl_.audiomessage_->Clear(); - } - } - if (cached_has_bits & 0x0000ff00u) { - if (cached_has_bits & 0x00000100u) { - GOOGLE_DCHECK(_impl_.videomessage_ != nullptr); - _impl_.videomessage_->Clear(); - } - if (cached_has_bits & 0x00000200u) { - GOOGLE_DCHECK(_impl_.call_ != nullptr); - _impl_.call_->Clear(); - } - if (cached_has_bits & 0x00000400u) { - GOOGLE_DCHECK(_impl_.chat_ != nullptr); - _impl_.chat_->Clear(); - } - if (cached_has_bits & 0x00000800u) { - GOOGLE_DCHECK(_impl_.protocolmessage_ != nullptr); - _impl_.protocolmessage_->Clear(); - } - if (cached_has_bits & 0x00001000u) { - GOOGLE_DCHECK(_impl_.contactsarraymessage_ != nullptr); - _impl_.contactsarraymessage_->Clear(); - } - if (cached_has_bits & 0x00002000u) { - GOOGLE_DCHECK(_impl_.highlystructuredmessage_ != nullptr); - _impl_.highlystructuredmessage_->Clear(); - } - if (cached_has_bits & 0x00004000u) { - GOOGLE_DCHECK(_impl_.fastratchetkeysenderkeydistributionmessage_ != nullptr); - _impl_.fastratchetkeysenderkeydistributionmessage_->Clear(); - } - if (cached_has_bits & 0x00008000u) { - GOOGLE_DCHECK(_impl_.sendpaymentmessage_ != nullptr); - _impl_.sendpaymentmessage_->Clear(); - } - } - if (cached_has_bits & 0x00ff0000u) { - if (cached_has_bits & 0x00010000u) { - GOOGLE_DCHECK(_impl_.livelocationmessage_ != nullptr); - _impl_.livelocationmessage_->Clear(); - } - if (cached_has_bits & 0x00020000u) { - GOOGLE_DCHECK(_impl_.requestpaymentmessage_ != nullptr); - _impl_.requestpaymentmessage_->Clear(); - } - if (cached_has_bits & 0x00040000u) { - GOOGLE_DCHECK(_impl_.declinepaymentrequestmessage_ != nullptr); - _impl_.declinepaymentrequestmessage_->Clear(); - } - if (cached_has_bits & 0x00080000u) { - GOOGLE_DCHECK(_impl_.cancelpaymentrequestmessage_ != nullptr); - _impl_.cancelpaymentrequestmessage_->Clear(); - } - if (cached_has_bits & 0x00100000u) { - GOOGLE_DCHECK(_impl_.templatemessage_ != nullptr); - _impl_.templatemessage_->Clear(); - } - if (cached_has_bits & 0x00200000u) { - GOOGLE_DCHECK(_impl_.stickermessage_ != nullptr); - _impl_.stickermessage_->Clear(); - } - if (cached_has_bits & 0x00400000u) { - GOOGLE_DCHECK(_impl_.groupinvitemessage_ != nullptr); - _impl_.groupinvitemessage_->Clear(); - } - if (cached_has_bits & 0x00800000u) { - GOOGLE_DCHECK(_impl_.templatebuttonreplymessage_ != nullptr); - _impl_.templatebuttonreplymessage_->Clear(); - } - } - if (cached_has_bits & 0xff000000u) { - if (cached_has_bits & 0x01000000u) { - GOOGLE_DCHECK(_impl_.productmessage_ != nullptr); - _impl_.productmessage_->Clear(); - } - if (cached_has_bits & 0x02000000u) { - GOOGLE_DCHECK(_impl_.devicesentmessage_ != nullptr); - _impl_.devicesentmessage_->Clear(); - } - if (cached_has_bits & 0x04000000u) { - GOOGLE_DCHECK(_impl_.messagecontextinfo_ != nullptr); - _impl_.messagecontextinfo_->Clear(); - } - if (cached_has_bits & 0x08000000u) { - GOOGLE_DCHECK(_impl_.listmessage_ != nullptr); - _impl_.listmessage_->Clear(); - } - if (cached_has_bits & 0x10000000u) { - GOOGLE_DCHECK(_impl_.viewoncemessage_ != nullptr); - _impl_.viewoncemessage_->Clear(); - } - if (cached_has_bits & 0x20000000u) { - GOOGLE_DCHECK(_impl_.ordermessage_ != nullptr); - _impl_.ordermessage_->Clear(); - } - if (cached_has_bits & 0x40000000u) { - GOOGLE_DCHECK(_impl_.listresponsemessage_ != nullptr); - _impl_.listresponsemessage_->Clear(); - } - if (cached_has_bits & 0x80000000u) { - GOOGLE_DCHECK(_impl_.ephemeralmessage_ != nullptr); - _impl_.ephemeralmessage_->Clear(); - } - } - cached_has_bits = _impl_._has_bits_[1]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.invoicemessage_ != nullptr); - _impl_.invoicemessage_->Clear(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.buttonsmessage_ != nullptr); - _impl_.buttonsmessage_->Clear(); - } - if (cached_has_bits & 0x00000004u) { - GOOGLE_DCHECK(_impl_.buttonsresponsemessage_ != nullptr); - _impl_.buttonsresponsemessage_->Clear(); - } - if (cached_has_bits & 0x00000008u) { - GOOGLE_DCHECK(_impl_.paymentinvitemessage_ != nullptr); - _impl_.paymentinvitemessage_->Clear(); - } - if (cached_has_bits & 0x00000010u) { - GOOGLE_DCHECK(_impl_.interactivemessage_ != nullptr); - _impl_.interactivemessage_->Clear(); - } - if (cached_has_bits & 0x00000020u) { - GOOGLE_DCHECK(_impl_.reactionmessage_ != nullptr); - _impl_.reactionmessage_->Clear(); - } - if (cached_has_bits & 0x00000040u) { - GOOGLE_DCHECK(_impl_.stickersyncrmrmessage_ != nullptr); - _impl_.stickersyncrmrmessage_->Clear(); - } - if (cached_has_bits & 0x00000080u) { - GOOGLE_DCHECK(_impl_.interactiveresponsemessage_ != nullptr); - _impl_.interactiveresponsemessage_->Clear(); - } - } - if (cached_has_bits & 0x00003f00u) { - if (cached_has_bits & 0x00000100u) { - GOOGLE_DCHECK(_impl_.pollcreationmessage_ != nullptr); - _impl_.pollcreationmessage_->Clear(); - } - if (cached_has_bits & 0x00000200u) { - GOOGLE_DCHECK(_impl_.pollupdatemessage_ != nullptr); - _impl_.pollupdatemessage_->Clear(); - } - if (cached_has_bits & 0x00000400u) { - GOOGLE_DCHECK(_impl_.keepinchatmessage_ != nullptr); - _impl_.keepinchatmessage_->Clear(); - } - if (cached_has_bits & 0x00000800u) { - GOOGLE_DCHECK(_impl_.documentwithcaptionmessage_ != nullptr); - _impl_.documentwithcaptionmessage_->Clear(); - } - if (cached_has_bits & 0x00001000u) { - GOOGLE_DCHECK(_impl_.requestphonenumbermessage_ != nullptr); - _impl_.requestphonenumbermessage_->Clear(); - } - if (cached_has_bits & 0x00002000u) { - GOOGLE_DCHECK(_impl_.viewoncemessagev2_ != nullptr); - _impl_.viewoncemessagev2_->Clear(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Message::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string conversation = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_conversation(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Message.conversation"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.Message.SenderKeyDistributionMessage senderKeyDistributionMessage = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_senderkeydistributionmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.ImageMessage imageMessage = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_imagemessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.ContactMessage contactMessage = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_contactmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.LocationMessage locationMessage = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - ptr = ctx->ParseMessage(_internal_mutable_locationmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.ExtendedTextMessage extendedTextMessage = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - ptr = ctx->ParseMessage(_internal_mutable_extendedtextmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.DocumentMessage documentMessage = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - ptr = ctx->ParseMessage(_internal_mutable_documentmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.AudioMessage audioMessage = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { - ptr = ctx->ParseMessage(_internal_mutable_audiomessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.VideoMessage videoMessage = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { - ptr = ctx->ParseMessage(_internal_mutable_videomessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.Call call = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { - ptr = ctx->ParseMessage(_internal_mutable_call(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.Chat chat = 11; - case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { - ptr = ctx->ParseMessage(_internal_mutable_chat(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.ProtocolMessage protocolMessage = 12; - case 12: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { - ptr = ctx->ParseMessage(_internal_mutable_protocolmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.ContactsArrayMessage contactsArrayMessage = 13; - case 13: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { - ptr = ctx->ParseMessage(_internal_mutable_contactsarraymessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.HighlyStructuredMessage highlyStructuredMessage = 14; - case 14: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) { - ptr = ctx->ParseMessage(_internal_mutable_highlystructuredmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.SenderKeyDistributionMessage fastRatchetKeySenderKeyDistributionMessage = 15; - case 15: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { - ptr = ctx->ParseMessage(_internal_mutable_fastratchetkeysenderkeydistributionmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.SendPaymentMessage sendPaymentMessage = 16; - case 16: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { - ptr = ctx->ParseMessage(_internal_mutable_sendpaymentmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.LiveLocationMessage liveLocationMessage = 18; - case 18: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { - ptr = ctx->ParseMessage(_internal_mutable_livelocationmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.RequestPaymentMessage requestPaymentMessage = 22; - case 22: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 178)) { - ptr = ctx->ParseMessage(_internal_mutable_requestpaymentmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.DeclinePaymentRequestMessage declinePaymentRequestMessage = 23; - case 23: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { - ptr = ctx->ParseMessage(_internal_mutable_declinepaymentrequestmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.CancelPaymentRequestMessage cancelPaymentRequestMessage = 24; - case 24: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 194)) { - ptr = ctx->ParseMessage(_internal_mutable_cancelpaymentrequestmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.TemplateMessage templateMessage = 25; - case 25: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 202)) { - ptr = ctx->ParseMessage(_internal_mutable_templatemessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.StickerMessage stickerMessage = 26; - case 26: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 210)) { - ptr = ctx->ParseMessage(_internal_mutable_stickermessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.GroupInviteMessage groupInviteMessage = 28; - case 28: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 226)) { - ptr = ctx->ParseMessage(_internal_mutable_groupinvitemessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.TemplateButtonReplyMessage templateButtonReplyMessage = 29; - case 29: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 234)) { - ptr = ctx->ParseMessage(_internal_mutable_templatebuttonreplymessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.ProductMessage productMessage = 30; - case 30: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 242)) { - ptr = ctx->ParseMessage(_internal_mutable_productmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.DeviceSentMessage deviceSentMessage = 31; - case 31: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 250)) { - ptr = ctx->ParseMessage(_internal_mutable_devicesentmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.MessageContextInfo messageContextInfo = 35; - case 35: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_messagecontextinfo(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.ListMessage listMessage = 36; - case 36: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_listmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.FutureProofMessage viewOnceMessage = 37; - case 37: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - ptr = ctx->ParseMessage(_internal_mutable_viewoncemessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.OrderMessage orderMessage = 38; - case 38: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - ptr = ctx->ParseMessage(_internal_mutable_ordermessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.ListResponseMessage listResponseMessage = 39; - case 39: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - ptr = ctx->ParseMessage(_internal_mutable_listresponsemessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.FutureProofMessage ephemeralMessage = 40; - case 40: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { - ptr = ctx->ParseMessage(_internal_mutable_ephemeralmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.InvoiceMessage invoiceMessage = 41; - case 41: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { - ptr = ctx->ParseMessage(_internal_mutable_invoicemessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.ButtonsMessage buttonsMessage = 42; - case 42: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { - ptr = ctx->ParseMessage(_internal_mutable_buttonsmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.ButtonsResponseMessage buttonsResponseMessage = 43; - case 43: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { - ptr = ctx->ParseMessage(_internal_mutable_buttonsresponsemessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.PaymentInviteMessage paymentInviteMessage = 44; - case 44: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { - ptr = ctx->ParseMessage(_internal_mutable_paymentinvitemessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.InteractiveMessage interactiveMessage = 45; - case 45: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { - ptr = ctx->ParseMessage(_internal_mutable_interactivemessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.ReactionMessage reactionMessage = 46; - case 46: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) { - ptr = ctx->ParseMessage(_internal_mutable_reactionmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.StickerSyncRMRMessage stickerSyncRmrMessage = 47; - case 47: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { - ptr = ctx->ParseMessage(_internal_mutable_stickersyncrmrmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.InteractiveResponseMessage interactiveResponseMessage = 48; - case 48: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { - ptr = ctx->ParseMessage(_internal_mutable_interactiveresponsemessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.PollCreationMessage pollCreationMessage = 49; - case 49: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { - ptr = ctx->ParseMessage(_internal_mutable_pollcreationmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.PollUpdateMessage pollUpdateMessage = 50; - case 50: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { - ptr = ctx->ParseMessage(_internal_mutable_pollupdatemessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.KeepInChatMessage keepInChatMessage = 51; - case 51: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) { - ptr = ctx->ParseMessage(_internal_mutable_keepinchatmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.FutureProofMessage documentWithCaptionMessage = 53; - case 53: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { - ptr = ctx->ParseMessage(_internal_mutable_documentwithcaptionmessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.RequestPhoneNumberMessage requestPhoneNumberMessage = 54; - case 54: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 178)) { - ptr = ctx->ParseMessage(_internal_mutable_requestphonenumbermessage(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.FutureProofMessage viewOnceMessageV2 = 55; - case 55: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { - ptr = ctx->ParseMessage(_internal_mutable_viewoncemessagev2(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Message::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Message) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string conversation = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_conversation().data(), static_cast(this->_internal_conversation().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Message.conversation"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_conversation(), target); - } - - // optional .proto.Message.SenderKeyDistributionMessage senderKeyDistributionMessage = 2; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::senderkeydistributionmessage(this), - _Internal::senderkeydistributionmessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.ImageMessage imageMessage = 3; - if (cached_has_bits & 0x00000004u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, _Internal::imagemessage(this), - _Internal::imagemessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.ContactMessage contactMessage = 4; - if (cached_has_bits & 0x00000008u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(4, _Internal::contactmessage(this), - _Internal::contactmessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.LocationMessage locationMessage = 5; - if (cached_has_bits & 0x00000010u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(5, _Internal::locationmessage(this), - _Internal::locationmessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.ExtendedTextMessage extendedTextMessage = 6; - if (cached_has_bits & 0x00000020u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(6, _Internal::extendedtextmessage(this), - _Internal::extendedtextmessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.DocumentMessage documentMessage = 7; - if (cached_has_bits & 0x00000040u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(7, _Internal::documentmessage(this), - _Internal::documentmessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.AudioMessage audioMessage = 8; - if (cached_has_bits & 0x00000080u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(8, _Internal::audiomessage(this), - _Internal::audiomessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.VideoMessage videoMessage = 9; - if (cached_has_bits & 0x00000100u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(9, _Internal::videomessage(this), - _Internal::videomessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.Call call = 10; - if (cached_has_bits & 0x00000200u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(10, _Internal::call(this), - _Internal::call(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.Chat chat = 11; - if (cached_has_bits & 0x00000400u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(11, _Internal::chat(this), - _Internal::chat(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.ProtocolMessage protocolMessage = 12; - if (cached_has_bits & 0x00000800u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(12, _Internal::protocolmessage(this), - _Internal::protocolmessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.ContactsArrayMessage contactsArrayMessage = 13; - if (cached_has_bits & 0x00001000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(13, _Internal::contactsarraymessage(this), - _Internal::contactsarraymessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.HighlyStructuredMessage highlyStructuredMessage = 14; - if (cached_has_bits & 0x00002000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(14, _Internal::highlystructuredmessage(this), - _Internal::highlystructuredmessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.SenderKeyDistributionMessage fastRatchetKeySenderKeyDistributionMessage = 15; - if (cached_has_bits & 0x00004000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(15, _Internal::fastratchetkeysenderkeydistributionmessage(this), - _Internal::fastratchetkeysenderkeydistributionmessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.SendPaymentMessage sendPaymentMessage = 16; - if (cached_has_bits & 0x00008000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(16, _Internal::sendpaymentmessage(this), - _Internal::sendpaymentmessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.LiveLocationMessage liveLocationMessage = 18; - if (cached_has_bits & 0x00010000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(18, _Internal::livelocationmessage(this), - _Internal::livelocationmessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.RequestPaymentMessage requestPaymentMessage = 22; - if (cached_has_bits & 0x00020000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(22, _Internal::requestpaymentmessage(this), - _Internal::requestpaymentmessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.DeclinePaymentRequestMessage declinePaymentRequestMessage = 23; - if (cached_has_bits & 0x00040000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(23, _Internal::declinepaymentrequestmessage(this), - _Internal::declinepaymentrequestmessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.CancelPaymentRequestMessage cancelPaymentRequestMessage = 24; - if (cached_has_bits & 0x00080000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(24, _Internal::cancelpaymentrequestmessage(this), - _Internal::cancelpaymentrequestmessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.TemplateMessage templateMessage = 25; - if (cached_has_bits & 0x00100000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(25, _Internal::templatemessage(this), - _Internal::templatemessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.StickerMessage stickerMessage = 26; - if (cached_has_bits & 0x00200000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(26, _Internal::stickermessage(this), - _Internal::stickermessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.GroupInviteMessage groupInviteMessage = 28; - if (cached_has_bits & 0x00400000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(28, _Internal::groupinvitemessage(this), - _Internal::groupinvitemessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.TemplateButtonReplyMessage templateButtonReplyMessage = 29; - if (cached_has_bits & 0x00800000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(29, _Internal::templatebuttonreplymessage(this), - _Internal::templatebuttonreplymessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.ProductMessage productMessage = 30; - if (cached_has_bits & 0x01000000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(30, _Internal::productmessage(this), - _Internal::productmessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.DeviceSentMessage deviceSentMessage = 31; - if (cached_has_bits & 0x02000000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(31, _Internal::devicesentmessage(this), - _Internal::devicesentmessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.MessageContextInfo messageContextInfo = 35; - if (cached_has_bits & 0x04000000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(35, _Internal::messagecontextinfo(this), - _Internal::messagecontextinfo(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.ListMessage listMessage = 36; - if (cached_has_bits & 0x08000000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(36, _Internal::listmessage(this), - _Internal::listmessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.FutureProofMessage viewOnceMessage = 37; - if (cached_has_bits & 0x10000000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(37, _Internal::viewoncemessage(this), - _Internal::viewoncemessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.OrderMessage orderMessage = 38; - if (cached_has_bits & 0x20000000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(38, _Internal::ordermessage(this), - _Internal::ordermessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.ListResponseMessage listResponseMessage = 39; - if (cached_has_bits & 0x40000000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(39, _Internal::listresponsemessage(this), - _Internal::listresponsemessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.FutureProofMessage ephemeralMessage = 40; - if (cached_has_bits & 0x80000000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(40, _Internal::ephemeralmessage(this), - _Internal::ephemeralmessage(this).GetCachedSize(), target, stream); - } - - cached_has_bits = _impl_._has_bits_[1]; - // optional .proto.Message.InvoiceMessage invoiceMessage = 41; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(41, _Internal::invoicemessage(this), - _Internal::invoicemessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.ButtonsMessage buttonsMessage = 42; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(42, _Internal::buttonsmessage(this), - _Internal::buttonsmessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.ButtonsResponseMessage buttonsResponseMessage = 43; - if (cached_has_bits & 0x00000004u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(43, _Internal::buttonsresponsemessage(this), - _Internal::buttonsresponsemessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.PaymentInviteMessage paymentInviteMessage = 44; - if (cached_has_bits & 0x00000008u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(44, _Internal::paymentinvitemessage(this), - _Internal::paymentinvitemessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.InteractiveMessage interactiveMessage = 45; - if (cached_has_bits & 0x00000010u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(45, _Internal::interactivemessage(this), - _Internal::interactivemessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.ReactionMessage reactionMessage = 46; - if (cached_has_bits & 0x00000020u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(46, _Internal::reactionmessage(this), - _Internal::reactionmessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.StickerSyncRMRMessage stickerSyncRmrMessage = 47; - if (cached_has_bits & 0x00000040u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(47, _Internal::stickersyncrmrmessage(this), - _Internal::stickersyncrmrmessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.InteractiveResponseMessage interactiveResponseMessage = 48; - if (cached_has_bits & 0x00000080u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(48, _Internal::interactiveresponsemessage(this), - _Internal::interactiveresponsemessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.PollCreationMessage pollCreationMessage = 49; - if (cached_has_bits & 0x00000100u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(49, _Internal::pollcreationmessage(this), - _Internal::pollcreationmessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.PollUpdateMessage pollUpdateMessage = 50; - if (cached_has_bits & 0x00000200u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(50, _Internal::pollupdatemessage(this), - _Internal::pollupdatemessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.KeepInChatMessage keepInChatMessage = 51; - if (cached_has_bits & 0x00000400u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(51, _Internal::keepinchatmessage(this), - _Internal::keepinchatmessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.FutureProofMessage documentWithCaptionMessage = 53; - if (cached_has_bits & 0x00000800u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(53, _Internal::documentwithcaptionmessage(this), - _Internal::documentwithcaptionmessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.RequestPhoneNumberMessage requestPhoneNumberMessage = 54; - if (cached_has_bits & 0x00001000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(54, _Internal::requestphonenumbermessage(this), - _Internal::requestphonenumbermessage(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.FutureProofMessage viewOnceMessageV2 = 55; - if (cached_has_bits & 0x00002000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(55, _Internal::viewoncemessagev2(this), - _Internal::viewoncemessagev2(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Message) - return target; -} - -size_t Message::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Message) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional string conversation = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_conversation()); - } - - // optional .proto.Message.SenderKeyDistributionMessage senderKeyDistributionMessage = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.senderkeydistributionmessage_); - } - - // optional .proto.Message.ImageMessage imageMessage = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.imagemessage_); - } - - // optional .proto.Message.ContactMessage contactMessage = 4; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.contactmessage_); - } - - // optional .proto.Message.LocationMessage locationMessage = 5; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.locationmessage_); - } - - // optional .proto.Message.ExtendedTextMessage extendedTextMessage = 6; - if (cached_has_bits & 0x00000020u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.extendedtextmessage_); - } - - // optional .proto.Message.DocumentMessage documentMessage = 7; - if (cached_has_bits & 0x00000040u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.documentmessage_); - } - - // optional .proto.Message.AudioMessage audioMessage = 8; - if (cached_has_bits & 0x00000080u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.audiomessage_); - } - - } - if (cached_has_bits & 0x0000ff00u) { - // optional .proto.Message.VideoMessage videoMessage = 9; - if (cached_has_bits & 0x00000100u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.videomessage_); - } - - // optional .proto.Message.Call call = 10; - if (cached_has_bits & 0x00000200u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.call_); - } - - // optional .proto.Message.Chat chat = 11; - if (cached_has_bits & 0x00000400u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.chat_); - } - - // optional .proto.Message.ProtocolMessage protocolMessage = 12; - if (cached_has_bits & 0x00000800u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.protocolmessage_); - } - - // optional .proto.Message.ContactsArrayMessage contactsArrayMessage = 13; - if (cached_has_bits & 0x00001000u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.contactsarraymessage_); - } - - // optional .proto.Message.HighlyStructuredMessage highlyStructuredMessage = 14; - if (cached_has_bits & 0x00002000u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.highlystructuredmessage_); - } - - // optional .proto.Message.SenderKeyDistributionMessage fastRatchetKeySenderKeyDistributionMessage = 15; - if (cached_has_bits & 0x00004000u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.fastratchetkeysenderkeydistributionmessage_); - } - - // optional .proto.Message.SendPaymentMessage sendPaymentMessage = 16; - if (cached_has_bits & 0x00008000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.sendpaymentmessage_); - } - - } - if (cached_has_bits & 0x00ff0000u) { - // optional .proto.Message.LiveLocationMessage liveLocationMessage = 18; - if (cached_has_bits & 0x00010000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.livelocationmessage_); - } - - // optional .proto.Message.RequestPaymentMessage requestPaymentMessage = 22; - if (cached_has_bits & 0x00020000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.requestpaymentmessage_); - } - - // optional .proto.Message.DeclinePaymentRequestMessage declinePaymentRequestMessage = 23; - if (cached_has_bits & 0x00040000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.declinepaymentrequestmessage_); - } - - // optional .proto.Message.CancelPaymentRequestMessage cancelPaymentRequestMessage = 24; - if (cached_has_bits & 0x00080000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.cancelpaymentrequestmessage_); - } - - // optional .proto.Message.TemplateMessage templateMessage = 25; - if (cached_has_bits & 0x00100000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.templatemessage_); - } - - // optional .proto.Message.StickerMessage stickerMessage = 26; - if (cached_has_bits & 0x00200000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.stickermessage_); - } - - // optional .proto.Message.GroupInviteMessage groupInviteMessage = 28; - if (cached_has_bits & 0x00400000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.groupinvitemessage_); - } - - // optional .proto.Message.TemplateButtonReplyMessage templateButtonReplyMessage = 29; - if (cached_has_bits & 0x00800000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.templatebuttonreplymessage_); - } - - } - if (cached_has_bits & 0xff000000u) { - // optional .proto.Message.ProductMessage productMessage = 30; - if (cached_has_bits & 0x01000000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.productmessage_); - } - - // optional .proto.Message.DeviceSentMessage deviceSentMessage = 31; - if (cached_has_bits & 0x02000000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.devicesentmessage_); - } - - // optional .proto.MessageContextInfo messageContextInfo = 35; - if (cached_has_bits & 0x04000000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.messagecontextinfo_); - } - - // optional .proto.Message.ListMessage listMessage = 36; - if (cached_has_bits & 0x08000000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.listmessage_); - } - - // optional .proto.Message.FutureProofMessage viewOnceMessage = 37; - if (cached_has_bits & 0x10000000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.viewoncemessage_); - } - - // optional .proto.Message.OrderMessage orderMessage = 38; - if (cached_has_bits & 0x20000000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.ordermessage_); - } - - // optional .proto.Message.ListResponseMessage listResponseMessage = 39; - if (cached_has_bits & 0x40000000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.listresponsemessage_); - } - - // optional .proto.Message.FutureProofMessage ephemeralMessage = 40; - if (cached_has_bits & 0x80000000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.ephemeralmessage_); - } - - } - cached_has_bits = _impl_._has_bits_[1]; - if (cached_has_bits & 0x000000ffu) { - // optional .proto.Message.InvoiceMessage invoiceMessage = 41; - if (cached_has_bits & 0x00000001u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.invoicemessage_); - } - - // optional .proto.Message.ButtonsMessage buttonsMessage = 42; - if (cached_has_bits & 0x00000002u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.buttonsmessage_); - } - - // optional .proto.Message.ButtonsResponseMessage buttonsResponseMessage = 43; - if (cached_has_bits & 0x00000004u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.buttonsresponsemessage_); - } - - // optional .proto.Message.PaymentInviteMessage paymentInviteMessage = 44; - if (cached_has_bits & 0x00000008u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.paymentinvitemessage_); - } - - // optional .proto.Message.InteractiveMessage interactiveMessage = 45; - if (cached_has_bits & 0x00000010u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.interactivemessage_); - } - - // optional .proto.Message.ReactionMessage reactionMessage = 46; - if (cached_has_bits & 0x00000020u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.reactionmessage_); - } - - // optional .proto.Message.StickerSyncRMRMessage stickerSyncRmrMessage = 47; - if (cached_has_bits & 0x00000040u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.stickersyncrmrmessage_); - } - - // optional .proto.Message.InteractiveResponseMessage interactiveResponseMessage = 48; - if (cached_has_bits & 0x00000080u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.interactiveresponsemessage_); - } - - } - if (cached_has_bits & 0x00003f00u) { - // optional .proto.Message.PollCreationMessage pollCreationMessage = 49; - if (cached_has_bits & 0x00000100u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.pollcreationmessage_); - } - - // optional .proto.Message.PollUpdateMessage pollUpdateMessage = 50; - if (cached_has_bits & 0x00000200u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.pollupdatemessage_); - } - - // optional .proto.Message.KeepInChatMessage keepInChatMessage = 51; - if (cached_has_bits & 0x00000400u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.keepinchatmessage_); - } - - // optional .proto.Message.FutureProofMessage documentWithCaptionMessage = 53; - if (cached_has_bits & 0x00000800u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.documentwithcaptionmessage_); - } - - // optional .proto.Message.RequestPhoneNumberMessage requestPhoneNumberMessage = 54; - if (cached_has_bits & 0x00001000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.requestphonenumbermessage_); - } - - // optional .proto.Message.FutureProofMessage viewOnceMessageV2 = 55; - if (cached_has_bits & 0x00002000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.viewoncemessagev2_); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Message::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Message::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Message::GetClassData() const { return &_class_data_; } - - -void Message::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Message) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_conversation(from._internal_conversation()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_senderkeydistributionmessage()->::proto::Message_SenderKeyDistributionMessage::MergeFrom( - from._internal_senderkeydistributionmessage()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_mutable_imagemessage()->::proto::Message_ImageMessage::MergeFrom( - from._internal_imagemessage()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_mutable_contactmessage()->::proto::Message_ContactMessage::MergeFrom( - from._internal_contactmessage()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_mutable_locationmessage()->::proto::Message_LocationMessage::MergeFrom( - from._internal_locationmessage()); - } - if (cached_has_bits & 0x00000020u) { - _this->_internal_mutable_extendedtextmessage()->::proto::Message_ExtendedTextMessage::MergeFrom( - from._internal_extendedtextmessage()); - } - if (cached_has_bits & 0x00000040u) { - _this->_internal_mutable_documentmessage()->::proto::Message_DocumentMessage::MergeFrom( - from._internal_documentmessage()); - } - if (cached_has_bits & 0x00000080u) { - _this->_internal_mutable_audiomessage()->::proto::Message_AudioMessage::MergeFrom( - from._internal_audiomessage()); - } - } - if (cached_has_bits & 0x0000ff00u) { - if (cached_has_bits & 0x00000100u) { - _this->_internal_mutable_videomessage()->::proto::Message_VideoMessage::MergeFrom( - from._internal_videomessage()); - } - if (cached_has_bits & 0x00000200u) { - _this->_internal_mutable_call()->::proto::Message_Call::MergeFrom( - from._internal_call()); - } - if (cached_has_bits & 0x00000400u) { - _this->_internal_mutable_chat()->::proto::Message_Chat::MergeFrom( - from._internal_chat()); - } - if (cached_has_bits & 0x00000800u) { - _this->_internal_mutable_protocolmessage()->::proto::Message_ProtocolMessage::MergeFrom( - from._internal_protocolmessage()); - } - if (cached_has_bits & 0x00001000u) { - _this->_internal_mutable_contactsarraymessage()->::proto::Message_ContactsArrayMessage::MergeFrom( - from._internal_contactsarraymessage()); - } - if (cached_has_bits & 0x00002000u) { - _this->_internal_mutable_highlystructuredmessage()->::proto::Message_HighlyStructuredMessage::MergeFrom( - from._internal_highlystructuredmessage()); - } - if (cached_has_bits & 0x00004000u) { - _this->_internal_mutable_fastratchetkeysenderkeydistributionmessage()->::proto::Message_SenderKeyDistributionMessage::MergeFrom( - from._internal_fastratchetkeysenderkeydistributionmessage()); - } - if (cached_has_bits & 0x00008000u) { - _this->_internal_mutable_sendpaymentmessage()->::proto::Message_SendPaymentMessage::MergeFrom( - from._internal_sendpaymentmessage()); - } - } - if (cached_has_bits & 0x00ff0000u) { - if (cached_has_bits & 0x00010000u) { - _this->_internal_mutable_livelocationmessage()->::proto::Message_LiveLocationMessage::MergeFrom( - from._internal_livelocationmessage()); - } - if (cached_has_bits & 0x00020000u) { - _this->_internal_mutable_requestpaymentmessage()->::proto::Message_RequestPaymentMessage::MergeFrom( - from._internal_requestpaymentmessage()); - } - if (cached_has_bits & 0x00040000u) { - _this->_internal_mutable_declinepaymentrequestmessage()->::proto::Message_DeclinePaymentRequestMessage::MergeFrom( - from._internal_declinepaymentrequestmessage()); - } - if (cached_has_bits & 0x00080000u) { - _this->_internal_mutable_cancelpaymentrequestmessage()->::proto::Message_CancelPaymentRequestMessage::MergeFrom( - from._internal_cancelpaymentrequestmessage()); - } - if (cached_has_bits & 0x00100000u) { - _this->_internal_mutable_templatemessage()->::proto::Message_TemplateMessage::MergeFrom( - from._internal_templatemessage()); - } - if (cached_has_bits & 0x00200000u) { - _this->_internal_mutable_stickermessage()->::proto::Message_StickerMessage::MergeFrom( - from._internal_stickermessage()); - } - if (cached_has_bits & 0x00400000u) { - _this->_internal_mutable_groupinvitemessage()->::proto::Message_GroupInviteMessage::MergeFrom( - from._internal_groupinvitemessage()); - } - if (cached_has_bits & 0x00800000u) { - _this->_internal_mutable_templatebuttonreplymessage()->::proto::Message_TemplateButtonReplyMessage::MergeFrom( - from._internal_templatebuttonreplymessage()); - } - } - if (cached_has_bits & 0xff000000u) { - if (cached_has_bits & 0x01000000u) { - _this->_internal_mutable_productmessage()->::proto::Message_ProductMessage::MergeFrom( - from._internal_productmessage()); - } - if (cached_has_bits & 0x02000000u) { - _this->_internal_mutable_devicesentmessage()->::proto::Message_DeviceSentMessage::MergeFrom( - from._internal_devicesentmessage()); - } - if (cached_has_bits & 0x04000000u) { - _this->_internal_mutable_messagecontextinfo()->::proto::MessageContextInfo::MergeFrom( - from._internal_messagecontextinfo()); - } - if (cached_has_bits & 0x08000000u) { - _this->_internal_mutable_listmessage()->::proto::Message_ListMessage::MergeFrom( - from._internal_listmessage()); - } - if (cached_has_bits & 0x10000000u) { - _this->_internal_mutable_viewoncemessage()->::proto::Message_FutureProofMessage::MergeFrom( - from._internal_viewoncemessage()); - } - if (cached_has_bits & 0x20000000u) { - _this->_internal_mutable_ordermessage()->::proto::Message_OrderMessage::MergeFrom( - from._internal_ordermessage()); - } - if (cached_has_bits & 0x40000000u) { - _this->_internal_mutable_listresponsemessage()->::proto::Message_ListResponseMessage::MergeFrom( - from._internal_listresponsemessage()); - } - if (cached_has_bits & 0x80000000u) { - _this->_internal_mutable_ephemeralmessage()->::proto::Message_FutureProofMessage::MergeFrom( - from._internal_ephemeralmessage()); - } - } - cached_has_bits = from._impl_._has_bits_[1]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_mutable_invoicemessage()->::proto::Message_InvoiceMessage::MergeFrom( - from._internal_invoicemessage()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_buttonsmessage()->::proto::Message_ButtonsMessage::MergeFrom( - from._internal_buttonsmessage()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_mutable_buttonsresponsemessage()->::proto::Message_ButtonsResponseMessage::MergeFrom( - from._internal_buttonsresponsemessage()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_mutable_paymentinvitemessage()->::proto::Message_PaymentInviteMessage::MergeFrom( - from._internal_paymentinvitemessage()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_mutable_interactivemessage()->::proto::Message_InteractiveMessage::MergeFrom( - from._internal_interactivemessage()); - } - if (cached_has_bits & 0x00000020u) { - _this->_internal_mutable_reactionmessage()->::proto::Message_ReactionMessage::MergeFrom( - from._internal_reactionmessage()); - } - if (cached_has_bits & 0x00000040u) { - _this->_internal_mutable_stickersyncrmrmessage()->::proto::Message_StickerSyncRMRMessage::MergeFrom( - from._internal_stickersyncrmrmessage()); - } - if (cached_has_bits & 0x00000080u) { - _this->_internal_mutable_interactiveresponsemessage()->::proto::Message_InteractiveResponseMessage::MergeFrom( - from._internal_interactiveresponsemessage()); - } - } - if (cached_has_bits & 0x00003f00u) { - if (cached_has_bits & 0x00000100u) { - _this->_internal_mutable_pollcreationmessage()->::proto::Message_PollCreationMessage::MergeFrom( - from._internal_pollcreationmessage()); - } - if (cached_has_bits & 0x00000200u) { - _this->_internal_mutable_pollupdatemessage()->::proto::Message_PollUpdateMessage::MergeFrom( - from._internal_pollupdatemessage()); - } - if (cached_has_bits & 0x00000400u) { - _this->_internal_mutable_keepinchatmessage()->::proto::Message_KeepInChatMessage::MergeFrom( - from._internal_keepinchatmessage()); - } - if (cached_has_bits & 0x00000800u) { - _this->_internal_mutable_documentwithcaptionmessage()->::proto::Message_FutureProofMessage::MergeFrom( - from._internal_documentwithcaptionmessage()); - } - if (cached_has_bits & 0x00001000u) { - _this->_internal_mutable_requestphonenumbermessage()->::proto::Message_RequestPhoneNumberMessage::MergeFrom( - from._internal_requestphonenumbermessage()); - } - if (cached_has_bits & 0x00002000u) { - _this->_internal_mutable_viewoncemessagev2()->::proto::Message_FutureProofMessage::MergeFrom( - from._internal_viewoncemessagev2()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Message::CopyFrom(const Message& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Message) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Message::IsInitialized() const { - return true; -} - -void Message::InternalSwap(Message* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - swap(_impl_._has_bits_[1], other->_impl_._has_bits_[1]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.conversation_, lhs_arena, - &other->_impl_.conversation_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Message, _impl_.viewoncemessagev2_) - + sizeof(Message::_impl_.viewoncemessagev2_) - - PROTOBUF_FIELD_OFFSET(Message, _impl_.senderkeydistributionmessage_)>( - reinterpret_cast(&_impl_.senderkeydistributionmessage_), - reinterpret_cast(&other->_impl_.senderkeydistributionmessage_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Message::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[137]); -} - -// =================================================================== - -class MessageContextInfo::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::DeviceListMetadata& devicelistmetadata(const MessageContextInfo* msg); - static void set_has_devicelistmetadata(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_devicelistmetadataversion(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_messagesecret(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_paddingbytes(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -const ::proto::DeviceListMetadata& -MessageContextInfo::_Internal::devicelistmetadata(const MessageContextInfo* msg) { - return *msg->_impl_.devicelistmetadata_; -} -MessageContextInfo::MessageContextInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.MessageContextInfo) -} -MessageContextInfo::MessageContextInfo(const MessageContextInfo& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - MessageContextInfo* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.messagesecret_){} - , decltype(_impl_.paddingbytes_){} - , decltype(_impl_.devicelistmetadata_){nullptr} - , decltype(_impl_.devicelistmetadataversion_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.messagesecret_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.messagesecret_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_messagesecret()) { - _this->_impl_.messagesecret_.Set(from._internal_messagesecret(), - _this->GetArenaForAllocation()); - } - _impl_.paddingbytes_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.paddingbytes_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_paddingbytes()) { - _this->_impl_.paddingbytes_.Set(from._internal_paddingbytes(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_devicelistmetadata()) { - _this->_impl_.devicelistmetadata_ = new ::proto::DeviceListMetadata(*from._impl_.devicelistmetadata_); - } - _this->_impl_.devicelistmetadataversion_ = from._impl_.devicelistmetadataversion_; - // @@protoc_insertion_point(copy_constructor:proto.MessageContextInfo) -} - -inline void MessageContextInfo::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.messagesecret_){} - , decltype(_impl_.paddingbytes_){} - , decltype(_impl_.devicelistmetadata_){nullptr} - , decltype(_impl_.devicelistmetadataversion_){0} - }; - _impl_.messagesecret_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.messagesecret_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.paddingbytes_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.paddingbytes_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -MessageContextInfo::~MessageContextInfo() { - // @@protoc_insertion_point(destructor:proto.MessageContextInfo) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void MessageContextInfo::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.messagesecret_.Destroy(); - _impl_.paddingbytes_.Destroy(); - if (this != internal_default_instance()) delete _impl_.devicelistmetadata_; -} - -void MessageContextInfo::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void MessageContextInfo::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.MessageContextInfo) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _impl_.messagesecret_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.paddingbytes_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - GOOGLE_DCHECK(_impl_.devicelistmetadata_ != nullptr); - _impl_.devicelistmetadata_->Clear(); - } - } - _impl_.devicelistmetadataversion_ = 0; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* MessageContextInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.DeviceListMetadata deviceListMetadata = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_devicelistmetadata(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional int32 deviceListMetadataVersion = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_devicelistmetadataversion(&has_bits); - _impl_.devicelistmetadataversion_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes messageSecret = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_messagesecret(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes paddingBytes = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - auto str = _internal_mutable_paddingbytes(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* MessageContextInfo::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.MessageContextInfo) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.DeviceListMetadata deviceListMetadata = 1; - if (cached_has_bits & 0x00000004u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::devicelistmetadata(this), - _Internal::devicelistmetadata(this).GetCachedSize(), target, stream); - } - - // optional int32 deviceListMetadataVersion = 2; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_devicelistmetadataversion(), target); - } - - // optional bytes messageSecret = 3; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 3, this->_internal_messagesecret(), target); - } - - // optional bytes paddingBytes = 4; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 4, this->_internal_paddingbytes(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.MessageContextInfo) - return target; -} - -size_t MessageContextInfo::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.MessageContextInfo) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - // optional bytes messageSecret = 3; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_messagesecret()); - } - - // optional bytes paddingBytes = 4; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_paddingbytes()); - } - - // optional .proto.DeviceListMetadata deviceListMetadata = 1; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.devicelistmetadata_); - } - - // optional int32 deviceListMetadataVersion = 2; - if (cached_has_bits & 0x00000008u) { - total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_devicelistmetadataversion()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MessageContextInfo::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - MessageContextInfo::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MessageContextInfo::GetClassData() const { return &_class_data_; } - - -void MessageContextInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.MessageContextInfo) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_messagesecret(from._internal_messagesecret()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_paddingbytes(from._internal_paddingbytes()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_mutable_devicelistmetadata()->::proto::DeviceListMetadata::MergeFrom( - from._internal_devicelistmetadata()); - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.devicelistmetadataversion_ = from._impl_.devicelistmetadataversion_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void MessageContextInfo::CopyFrom(const MessageContextInfo& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.MessageContextInfo) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool MessageContextInfo::IsInitialized() const { - return true; -} - -void MessageContextInfo::InternalSwap(MessageContextInfo* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.messagesecret_, lhs_arena, - &other->_impl_.messagesecret_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.paddingbytes_, lhs_arena, - &other->_impl_.paddingbytes_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(MessageContextInfo, _impl_.devicelistmetadataversion_) - + sizeof(MessageContextInfo::_impl_.devicelistmetadataversion_) - - PROTOBUF_FIELD_OFFSET(MessageContextInfo, _impl_.devicelistmetadata_)>( - reinterpret_cast(&_impl_.devicelistmetadata_), - reinterpret_cast(&other->_impl_.devicelistmetadata_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata MessageContextInfo::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[138]); -} - -// =================================================================== - -class MessageKey::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_remotejid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_fromme(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_id(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_participant(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } -}; - -MessageKey::MessageKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.MessageKey) -} -MessageKey::MessageKey(const MessageKey& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - MessageKey* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.remotejid_){} - , decltype(_impl_.id_){} - , decltype(_impl_.participant_){} - , decltype(_impl_.fromme_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.remotejid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.remotejid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_remotejid()) { - _this->_impl_.remotejid_.Set(from._internal_remotejid(), - _this->GetArenaForAllocation()); - } - _impl_.id_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.id_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_id()) { - _this->_impl_.id_.Set(from._internal_id(), - _this->GetArenaForAllocation()); - } - _impl_.participant_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.participant_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_participant()) { - _this->_impl_.participant_.Set(from._internal_participant(), - _this->GetArenaForAllocation()); - } - _this->_impl_.fromme_ = from._impl_.fromme_; - // @@protoc_insertion_point(copy_constructor:proto.MessageKey) -} - -inline void MessageKey::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.remotejid_){} - , decltype(_impl_.id_){} - , decltype(_impl_.participant_){} - , decltype(_impl_.fromme_){false} - }; - _impl_.remotejid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.remotejid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.id_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.id_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.participant_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.participant_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -MessageKey::~MessageKey() { - // @@protoc_insertion_point(destructor:proto.MessageKey) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void MessageKey::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.remotejid_.Destroy(); - _impl_.id_.Destroy(); - _impl_.participant_.Destroy(); -} - -void MessageKey::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void MessageKey::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.MessageKey) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _impl_.remotejid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.id_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.participant_.ClearNonDefaultToEmpty(); - } - } - _impl_.fromme_ = false; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* MessageKey::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string remoteJid = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_remotejid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.MessageKey.remoteJid"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bool fromMe = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_fromme(&has_bits); - _impl_.fromme_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string id = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_id(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.MessageKey.id"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string participant = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - auto str = _internal_mutable_participant(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.MessageKey.participant"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* MessageKey::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.MessageKey) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string remoteJid = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_remotejid().data(), static_cast(this->_internal_remotejid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.MessageKey.remoteJid"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_remotejid(), target); - } - - // optional bool fromMe = 2; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(2, this->_internal_fromme(), target); - } - - // optional string id = 3; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_id().data(), static_cast(this->_internal_id().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.MessageKey.id"); - target = stream->WriteStringMaybeAliased( - 3, this->_internal_id(), target); - } - - // optional string participant = 4; - if (cached_has_bits & 0x00000004u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_participant().data(), static_cast(this->_internal_participant().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.MessageKey.participant"); - target = stream->WriteStringMaybeAliased( - 4, this->_internal_participant(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.MessageKey) - return target; -} - -size_t MessageKey::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.MessageKey) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - // optional string remoteJid = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_remotejid()); - } - - // optional string id = 3; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_id()); - } - - // optional string participant = 4; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_participant()); - } - - // optional bool fromMe = 2; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + 1; - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MessageKey::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - MessageKey::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MessageKey::GetClassData() const { return &_class_data_; } - - -void MessageKey::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.MessageKey) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_remotejid(from._internal_remotejid()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_id(from._internal_id()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_participant(from._internal_participant()); - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.fromme_ = from._impl_.fromme_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void MessageKey::CopyFrom(const MessageKey& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.MessageKey) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool MessageKey::IsInitialized() const { - return true; -} - -void MessageKey::InternalSwap(MessageKey* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.remotejid_, lhs_arena, - &other->_impl_.remotejid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.id_, lhs_arena, - &other->_impl_.id_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.participant_, lhs_arena, - &other->_impl_.participant_, rhs_arena - ); - swap(_impl_.fromme_, other->_impl_.fromme_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata MessageKey::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[139]); -} - -// =================================================================== - -class Money::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_value(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_offset(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_currencycode(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -Money::Money(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Money) -} -Money::Money(const Money& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Money* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.currencycode_){} - , decltype(_impl_.value_){} - , decltype(_impl_.offset_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.currencycode_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.currencycode_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_currencycode()) { - _this->_impl_.currencycode_.Set(from._internal_currencycode(), - _this->GetArenaForAllocation()); - } - ::memcpy(&_impl_.value_, &from._impl_.value_, - static_cast(reinterpret_cast(&_impl_.offset_) - - reinterpret_cast(&_impl_.value_)) + sizeof(_impl_.offset_)); - // @@protoc_insertion_point(copy_constructor:proto.Money) -} - -inline void Money::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.currencycode_){} - , decltype(_impl_.value_){int64_t{0}} - , decltype(_impl_.offset_){0u} - }; - _impl_.currencycode_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.currencycode_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Money::~Money() { - // @@protoc_insertion_point(destructor:proto.Money) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Money::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.currencycode_.Destroy(); -} - -void Money::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Money::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Money) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.currencycode_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000006u) { - ::memset(&_impl_.value_, 0, static_cast( - reinterpret_cast(&_impl_.offset_) - - reinterpret_cast(&_impl_.value_)) + sizeof(_impl_.offset_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Money::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional int64 value = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_value(&has_bits); - _impl_.value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 offset = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_offset(&has_bits); - _impl_.offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string currencyCode = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_currencycode(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Money.currencyCode"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Money::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Money) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional int64 value = 1; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_value(), target); - } - - // optional uint32 offset = 2; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_offset(), target); - } - - // optional string currencyCode = 3; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_currencycode().data(), static_cast(this->_internal_currencycode().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Money.currencyCode"); - target = stream->WriteStringMaybeAliased( - 3, this->_internal_currencycode(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Money) - return target; -} - -size_t Money::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Money) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional string currencyCode = 3; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_currencycode()); - } - - // optional int64 value = 1; - if (cached_has_bits & 0x00000002u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_value()); - } - - // optional uint32 offset = 2; - if (cached_has_bits & 0x00000004u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_offset()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Money::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Money::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Money::GetClassData() const { return &_class_data_; } - - -void Money::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Money) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_currencycode(from._internal_currencycode()); - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.value_ = from._impl_.value_; - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.offset_ = from._impl_.offset_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Money::CopyFrom(const Money& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Money) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Money::IsInitialized() const { - return true; -} - -void Money::InternalSwap(Money* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.currencycode_, lhs_arena, - &other->_impl_.currencycode_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Money, _impl_.offset_) - + sizeof(Money::_impl_.offset_) - - PROTOBUF_FIELD_OFFSET(Money, _impl_.value_)>( - reinterpret_cast(&_impl_.value_), - reinterpret_cast(&other->_impl_.value_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Money::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[140]); -} - -// =================================================================== - -class MsgOpaqueData_PollOption::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_name(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -MsgOpaqueData_PollOption::MsgOpaqueData_PollOption(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.MsgOpaqueData.PollOption) -} -MsgOpaqueData_PollOption::MsgOpaqueData_PollOption(const MsgOpaqueData_PollOption& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - MsgOpaqueData_PollOption* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.name_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.name_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.name_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_name()) { - _this->_impl_.name_.Set(from._internal_name(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.MsgOpaqueData.PollOption) -} - -inline void MsgOpaqueData_PollOption::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.name_){} - }; - _impl_.name_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.name_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -MsgOpaqueData_PollOption::~MsgOpaqueData_PollOption() { - // @@protoc_insertion_point(destructor:proto.MsgOpaqueData.PollOption) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void MsgOpaqueData_PollOption::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.name_.Destroy(); -} - -void MsgOpaqueData_PollOption::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void MsgOpaqueData_PollOption::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.MsgOpaqueData.PollOption) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.name_.ClearNonDefaultToEmpty(); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* MsgOpaqueData_PollOption::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string name = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_name(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.PollOption.name"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* MsgOpaqueData_PollOption::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.MsgOpaqueData.PollOption) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string name = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_name().data(), static_cast(this->_internal_name().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.MsgOpaqueData.PollOption.name"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_name(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.MsgOpaqueData.PollOption) - return target; -} - -size_t MsgOpaqueData_PollOption::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.MsgOpaqueData.PollOption) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional string name = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_name()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MsgOpaqueData_PollOption::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - MsgOpaqueData_PollOption::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MsgOpaqueData_PollOption::GetClassData() const { return &_class_data_; } - - -void MsgOpaqueData_PollOption::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.MsgOpaqueData.PollOption) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_name()) { - _this->_internal_set_name(from._internal_name()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void MsgOpaqueData_PollOption::CopyFrom(const MsgOpaqueData_PollOption& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.MsgOpaqueData.PollOption) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool MsgOpaqueData_PollOption::IsInitialized() const { - return true; -} - -void MsgOpaqueData_PollOption::InternalSwap(MsgOpaqueData_PollOption* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.name_, lhs_arena, - &other->_impl_.name_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata MsgOpaqueData_PollOption::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[141]); -} - -// =================================================================== - -class MsgOpaqueData::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_body(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_caption(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_lng(HasBits* has_bits) { - (*has_bits)[0] |= 16384u; - } - static void set_has_islive(HasBits* has_bits) { - (*has_bits)[0] |= 65536u; - } - static void set_has_lat(HasBits* has_bits) { - (*has_bits)[0] |= 32768u; - } - static void set_has_paymentamount1000(HasBits* has_bits) { - (*has_bits)[0] |= 131072u; - } - static void set_has_paymentnotemsgbody(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_canonicalurl(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_matchedtext(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_title(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static void set_has_description(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static void set_has_futureproofbuffer(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } - static void set_has_clienturl(HasBits* has_bits) { - (*has_bits)[0] |= 256u; - } - static void set_has_loc(HasBits* has_bits) { - (*has_bits)[0] |= 512u; - } - static void set_has_pollname(HasBits* has_bits) { - (*has_bits)[0] |= 1024u; - } - static void set_has_pollselectableoptionscount(HasBits* has_bits) { - (*has_bits)[0] |= 524288u; - } - static void set_has_messagesecret(HasBits* has_bits) { - (*has_bits)[0] |= 2048u; - } - static void set_has_sendertimestampms(HasBits* has_bits) { - (*has_bits)[0] |= 262144u; - } - static void set_has_pollupdateparentkey(HasBits* has_bits) { - (*has_bits)[0] |= 4096u; - } - static const ::proto::PollEncValue& encpollvote(const MsgOpaqueData* msg); - static void set_has_encpollvote(HasBits* has_bits) { - (*has_bits)[0] |= 8192u; - } -}; - -const ::proto::PollEncValue& -MsgOpaqueData::_Internal::encpollvote(const MsgOpaqueData* msg) { - return *msg->_impl_.encpollvote_; -} -MsgOpaqueData::MsgOpaqueData(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.MsgOpaqueData) -} -MsgOpaqueData::MsgOpaqueData(const MsgOpaqueData& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - MsgOpaqueData* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.polloptions_){from._impl_.polloptions_} - , decltype(_impl_.body_){} - , decltype(_impl_.caption_){} - , decltype(_impl_.paymentnotemsgbody_){} - , decltype(_impl_.canonicalurl_){} - , decltype(_impl_.matchedtext_){} - , decltype(_impl_.title_){} - , decltype(_impl_.description_){} - , decltype(_impl_.futureproofbuffer_){} - , decltype(_impl_.clienturl_){} - , decltype(_impl_.loc_){} - , decltype(_impl_.pollname_){} - , decltype(_impl_.messagesecret_){} - , decltype(_impl_.pollupdateparentkey_){} - , decltype(_impl_.encpollvote_){nullptr} - , decltype(_impl_.lng_){} - , decltype(_impl_.lat_){} - , decltype(_impl_.islive_){} - , decltype(_impl_.paymentamount1000_){} - , decltype(_impl_.sendertimestampms_){} - , decltype(_impl_.pollselectableoptionscount_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.body_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.body_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_body()) { - _this->_impl_.body_.Set(from._internal_body(), - _this->GetArenaForAllocation()); - } - _impl_.caption_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.caption_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_caption()) { - _this->_impl_.caption_.Set(from._internal_caption(), - _this->GetArenaForAllocation()); - } - _impl_.paymentnotemsgbody_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.paymentnotemsgbody_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_paymentnotemsgbody()) { - _this->_impl_.paymentnotemsgbody_.Set(from._internal_paymentnotemsgbody(), - _this->GetArenaForAllocation()); - } - _impl_.canonicalurl_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.canonicalurl_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_canonicalurl()) { - _this->_impl_.canonicalurl_.Set(from._internal_canonicalurl(), - _this->GetArenaForAllocation()); - } - _impl_.matchedtext_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.matchedtext_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_matchedtext()) { - _this->_impl_.matchedtext_.Set(from._internal_matchedtext(), - _this->GetArenaForAllocation()); - } - _impl_.title_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.title_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_title()) { - _this->_impl_.title_.Set(from._internal_title(), - _this->GetArenaForAllocation()); - } - _impl_.description_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.description_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_description()) { - _this->_impl_.description_.Set(from._internal_description(), - _this->GetArenaForAllocation()); - } - _impl_.futureproofbuffer_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.futureproofbuffer_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_futureproofbuffer()) { - _this->_impl_.futureproofbuffer_.Set(from._internal_futureproofbuffer(), - _this->GetArenaForAllocation()); - } - _impl_.clienturl_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.clienturl_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_clienturl()) { - _this->_impl_.clienturl_.Set(from._internal_clienturl(), - _this->GetArenaForAllocation()); - } - _impl_.loc_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.loc_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_loc()) { - _this->_impl_.loc_.Set(from._internal_loc(), - _this->GetArenaForAllocation()); - } - _impl_.pollname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.pollname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_pollname()) { - _this->_impl_.pollname_.Set(from._internal_pollname(), - _this->GetArenaForAllocation()); - } - _impl_.messagesecret_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.messagesecret_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_messagesecret()) { - _this->_impl_.messagesecret_.Set(from._internal_messagesecret(), - _this->GetArenaForAllocation()); - } - _impl_.pollupdateparentkey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.pollupdateparentkey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_pollupdateparentkey()) { - _this->_impl_.pollupdateparentkey_.Set(from._internal_pollupdateparentkey(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_encpollvote()) { - _this->_impl_.encpollvote_ = new ::proto::PollEncValue(*from._impl_.encpollvote_); - } - ::memcpy(&_impl_.lng_, &from._impl_.lng_, - static_cast(reinterpret_cast(&_impl_.pollselectableoptionscount_) - - reinterpret_cast(&_impl_.lng_)) + sizeof(_impl_.pollselectableoptionscount_)); - // @@protoc_insertion_point(copy_constructor:proto.MsgOpaqueData) -} - -inline void MsgOpaqueData::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.polloptions_){arena} - , decltype(_impl_.body_){} - , decltype(_impl_.caption_){} - , decltype(_impl_.paymentnotemsgbody_){} - , decltype(_impl_.canonicalurl_){} - , decltype(_impl_.matchedtext_){} - , decltype(_impl_.title_){} - , decltype(_impl_.description_){} - , decltype(_impl_.futureproofbuffer_){} - , decltype(_impl_.clienturl_){} - , decltype(_impl_.loc_){} - , decltype(_impl_.pollname_){} - , decltype(_impl_.messagesecret_){} - , decltype(_impl_.pollupdateparentkey_){} - , decltype(_impl_.encpollvote_){nullptr} - , decltype(_impl_.lng_){0} - , decltype(_impl_.lat_){0} - , decltype(_impl_.islive_){false} - , decltype(_impl_.paymentamount1000_){0} - , decltype(_impl_.sendertimestampms_){int64_t{0}} - , decltype(_impl_.pollselectableoptionscount_){0u} - }; - _impl_.body_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.body_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.caption_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.caption_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.paymentnotemsgbody_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.paymentnotemsgbody_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.canonicalurl_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.canonicalurl_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.matchedtext_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.matchedtext_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.title_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.title_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.description_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.description_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.futureproofbuffer_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.futureproofbuffer_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.clienturl_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.clienturl_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.loc_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.loc_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.pollname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.pollname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.messagesecret_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.messagesecret_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.pollupdateparentkey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.pollupdateparentkey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -MsgOpaqueData::~MsgOpaqueData() { - // @@protoc_insertion_point(destructor:proto.MsgOpaqueData) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void MsgOpaqueData::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.polloptions_.~RepeatedPtrField(); - _impl_.body_.Destroy(); - _impl_.caption_.Destroy(); - _impl_.paymentnotemsgbody_.Destroy(); - _impl_.canonicalurl_.Destroy(); - _impl_.matchedtext_.Destroy(); - _impl_.title_.Destroy(); - _impl_.description_.Destroy(); - _impl_.futureproofbuffer_.Destroy(); - _impl_.clienturl_.Destroy(); - _impl_.loc_.Destroy(); - _impl_.pollname_.Destroy(); - _impl_.messagesecret_.Destroy(); - _impl_.pollupdateparentkey_.Destroy(); - if (this != internal_default_instance()) delete _impl_.encpollvote_; -} - -void MsgOpaqueData::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void MsgOpaqueData::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.MsgOpaqueData) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.polloptions_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _impl_.body_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.caption_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.paymentnotemsgbody_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000008u) { - _impl_.canonicalurl_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000010u) { - _impl_.matchedtext_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000020u) { - _impl_.title_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000040u) { - _impl_.description_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000080u) { - _impl_.futureproofbuffer_.ClearNonDefaultToEmpty(); - } - } - if (cached_has_bits & 0x00003f00u) { - if (cached_has_bits & 0x00000100u) { - _impl_.clienturl_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000200u) { - _impl_.loc_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000400u) { - _impl_.pollname_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000800u) { - _impl_.messagesecret_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00001000u) { - _impl_.pollupdateparentkey_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00002000u) { - GOOGLE_DCHECK(_impl_.encpollvote_ != nullptr); - _impl_.encpollvote_->Clear(); - } - } - if (cached_has_bits & 0x0000c000u) { - ::memset(&_impl_.lng_, 0, static_cast( - reinterpret_cast(&_impl_.lat_) - - reinterpret_cast(&_impl_.lng_)) + sizeof(_impl_.lat_)); - } - if (cached_has_bits & 0x000f0000u) { - ::memset(&_impl_.islive_, 0, static_cast( - reinterpret_cast(&_impl_.pollselectableoptionscount_) - - reinterpret_cast(&_impl_.islive_)) + sizeof(_impl_.pollselectableoptionscount_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* MsgOpaqueData::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string body = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_body(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.body"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string caption = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_caption(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.caption"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional double lng = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 41)) { - _Internal::set_has_lng(&has_bits); - _impl_.lng_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); - ptr += sizeof(double); - } else - goto handle_unusual; - continue; - // optional bool isLive = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { - _Internal::set_has_islive(&has_bits); - _impl_.islive_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional double lat = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 57)) { - _Internal::set_has_lat(&has_bits); - _impl_.lat_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); - ptr += sizeof(double); - } else - goto handle_unusual; - continue; - // optional int32 paymentAmount1000 = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { - _Internal::set_has_paymentamount1000(&has_bits); - _impl_.paymentamount1000_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string paymentNoteMsgBody = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { - auto str = _internal_mutable_paymentnotemsgbody(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.paymentNoteMsgBody"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string canonicalUrl = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { - auto str = _internal_mutable_canonicalurl(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.canonicalUrl"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string matchedText = 11; - case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { - auto str = _internal_mutable_matchedtext(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.matchedText"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string title = 12; - case 12: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { - auto str = _internal_mutable_title(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.title"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string description = 13; - case 13: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { - auto str = _internal_mutable_description(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.description"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bytes futureproofBuffer = 14; - case 14: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) { - auto str = _internal_mutable_futureproofbuffer(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string clientUrl = 15; - case 15: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { - auto str = _internal_mutable_clienturl(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.clientUrl"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string loc = 16; - case 16: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { - auto str = _internal_mutable_loc(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.loc"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string pollName = 17; - case 17: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { - auto str = _internal_mutable_pollname(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.pollName"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // repeated .proto.MsgOpaqueData.PollOption pollOptions = 18; - case 18: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { - ptr -= 2; - do { - ptr += 2; - ptr = ctx->ParseMessage(_internal_add_polloptions(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<146>(ptr)); - } else - goto handle_unusual; - continue; - // optional uint32 pollSelectableOptionsCount = 20; - case 20: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 160)) { - _Internal::set_has_pollselectableoptionscount(&has_bits); - _impl_.pollselectableoptionscount_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes messageSecret = 21; - case 21: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { - auto str = _internal_mutable_messagesecret(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional int64 senderTimestampMs = 22; - case 22: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 176)) { - _Internal::set_has_sendertimestampms(&has_bits); - _impl_.sendertimestampms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string pollUpdateParentKey = 23; - case 23: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { - auto str = _internal_mutable_pollupdateparentkey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.MsgOpaqueData.pollUpdateParentKey"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.PollEncValue encPollVote = 24; - case 24: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 194)) { - ptr = ctx->ParseMessage(_internal_mutable_encpollvote(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* MsgOpaqueData::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.MsgOpaqueData) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string body = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_body().data(), static_cast(this->_internal_body().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.MsgOpaqueData.body"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_body(), target); - } - - // optional string caption = 3; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_caption().data(), static_cast(this->_internal_caption().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.MsgOpaqueData.caption"); - target = stream->WriteStringMaybeAliased( - 3, this->_internal_caption(), target); - } - - // optional double lng = 5; - if (cached_has_bits & 0x00004000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteDoubleToArray(5, this->_internal_lng(), target); - } - - // optional bool isLive = 6; - if (cached_has_bits & 0x00010000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(6, this->_internal_islive(), target); - } - - // optional double lat = 7; - if (cached_has_bits & 0x00008000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteDoubleToArray(7, this->_internal_lat(), target); - } - - // optional int32 paymentAmount1000 = 8; - if (cached_has_bits & 0x00020000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt32ToArray(8, this->_internal_paymentamount1000(), target); - } - - // optional string paymentNoteMsgBody = 9; - if (cached_has_bits & 0x00000004u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_paymentnotemsgbody().data(), static_cast(this->_internal_paymentnotemsgbody().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.MsgOpaqueData.paymentNoteMsgBody"); - target = stream->WriteStringMaybeAliased( - 9, this->_internal_paymentnotemsgbody(), target); - } - - // optional string canonicalUrl = 10; - if (cached_has_bits & 0x00000008u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_canonicalurl().data(), static_cast(this->_internal_canonicalurl().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.MsgOpaqueData.canonicalUrl"); - target = stream->WriteStringMaybeAliased( - 10, this->_internal_canonicalurl(), target); - } - - // optional string matchedText = 11; - if (cached_has_bits & 0x00000010u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_matchedtext().data(), static_cast(this->_internal_matchedtext().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.MsgOpaqueData.matchedText"); - target = stream->WriteStringMaybeAliased( - 11, this->_internal_matchedtext(), target); - } - - // optional string title = 12; - if (cached_has_bits & 0x00000020u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_title().data(), static_cast(this->_internal_title().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.MsgOpaqueData.title"); - target = stream->WriteStringMaybeAliased( - 12, this->_internal_title(), target); - } - - // optional string description = 13; - if (cached_has_bits & 0x00000040u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_description().data(), static_cast(this->_internal_description().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.MsgOpaqueData.description"); - target = stream->WriteStringMaybeAliased( - 13, this->_internal_description(), target); - } - - // optional bytes futureproofBuffer = 14; - if (cached_has_bits & 0x00000080u) { - target = stream->WriteBytesMaybeAliased( - 14, this->_internal_futureproofbuffer(), target); - } - - // optional string clientUrl = 15; - if (cached_has_bits & 0x00000100u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_clienturl().data(), static_cast(this->_internal_clienturl().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.MsgOpaqueData.clientUrl"); - target = stream->WriteStringMaybeAliased( - 15, this->_internal_clienturl(), target); - } - - // optional string loc = 16; - if (cached_has_bits & 0x00000200u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_loc().data(), static_cast(this->_internal_loc().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.MsgOpaqueData.loc"); - target = stream->WriteStringMaybeAliased( - 16, this->_internal_loc(), target); - } - - // optional string pollName = 17; - if (cached_has_bits & 0x00000400u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_pollname().data(), static_cast(this->_internal_pollname().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.MsgOpaqueData.pollName"); - target = stream->WriteStringMaybeAliased( - 17, this->_internal_pollname(), target); - } - - // repeated .proto.MsgOpaqueData.PollOption pollOptions = 18; - for (unsigned i = 0, - n = static_cast(this->_internal_polloptions_size()); i < n; i++) { - const auto& repfield = this->_internal_polloptions(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(18, repfield, repfield.GetCachedSize(), target, stream); - } - - // optional uint32 pollSelectableOptionsCount = 20; - if (cached_has_bits & 0x00080000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(20, this->_internal_pollselectableoptionscount(), target); - } - - // optional bytes messageSecret = 21; - if (cached_has_bits & 0x00000800u) { - target = stream->WriteBytesMaybeAliased( - 21, this->_internal_messagesecret(), target); - } - - // optional int64 senderTimestampMs = 22; - if (cached_has_bits & 0x00040000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(22, this->_internal_sendertimestampms(), target); - } - - // optional string pollUpdateParentKey = 23; - if (cached_has_bits & 0x00001000u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_pollupdateparentkey().data(), static_cast(this->_internal_pollupdateparentkey().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.MsgOpaqueData.pollUpdateParentKey"); - target = stream->WriteStringMaybeAliased( - 23, this->_internal_pollupdateparentkey(), target); - } - - // optional .proto.PollEncValue encPollVote = 24; - if (cached_has_bits & 0x00002000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(24, _Internal::encpollvote(this), - _Internal::encpollvote(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.MsgOpaqueData) - return target; -} - -size_t MsgOpaqueData::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.MsgOpaqueData) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.MsgOpaqueData.PollOption pollOptions = 18; - total_size += 2UL * this->_internal_polloptions_size(); - for (const auto& msg : this->_impl_.polloptions_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional string body = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_body()); - } - - // optional string caption = 3; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_caption()); - } - - // optional string paymentNoteMsgBody = 9; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_paymentnotemsgbody()); - } - - // optional string canonicalUrl = 10; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_canonicalurl()); - } - - // optional string matchedText = 11; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_matchedtext()); - } - - // optional string title = 12; - if (cached_has_bits & 0x00000020u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_title()); - } - - // optional string description = 13; - if (cached_has_bits & 0x00000040u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_description()); - } - - // optional bytes futureproofBuffer = 14; - if (cached_has_bits & 0x00000080u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_futureproofbuffer()); - } - - } - if (cached_has_bits & 0x0000ff00u) { - // optional string clientUrl = 15; - if (cached_has_bits & 0x00000100u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_clienturl()); - } - - // optional string loc = 16; - if (cached_has_bits & 0x00000200u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_loc()); - } - - // optional string pollName = 17; - if (cached_has_bits & 0x00000400u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_pollname()); - } - - // optional bytes messageSecret = 21; - if (cached_has_bits & 0x00000800u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_messagesecret()); - } - - // optional string pollUpdateParentKey = 23; - if (cached_has_bits & 0x00001000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_pollupdateparentkey()); - } - - // optional .proto.PollEncValue encPollVote = 24; - if (cached_has_bits & 0x00002000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.encpollvote_); - } - - // optional double lng = 5; - if (cached_has_bits & 0x00004000u) { - total_size += 1 + 8; - } - - // optional double lat = 7; - if (cached_has_bits & 0x00008000u) { - total_size += 1 + 8; - } - - } - if (cached_has_bits & 0x000f0000u) { - // optional bool isLive = 6; - if (cached_has_bits & 0x00010000u) { - total_size += 1 + 1; - } - - // optional int32 paymentAmount1000 = 8; - if (cached_has_bits & 0x00020000u) { - total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_paymentamount1000()); - } - - // optional int64 senderTimestampMs = 22; - if (cached_has_bits & 0x00040000u) { - total_size += 2 + - ::_pbi::WireFormatLite::Int64Size( - this->_internal_sendertimestampms()); - } - - // optional uint32 pollSelectableOptionsCount = 20; - if (cached_has_bits & 0x00080000u) { - total_size += 2 + - ::_pbi::WireFormatLite::UInt32Size( - this->_internal_pollselectableoptionscount()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MsgOpaqueData::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - MsgOpaqueData::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MsgOpaqueData::GetClassData() const { return &_class_data_; } - - -void MsgOpaqueData::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.MsgOpaqueData) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.polloptions_.MergeFrom(from._impl_.polloptions_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_body(from._internal_body()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_caption(from._internal_caption()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_paymentnotemsgbody(from._internal_paymentnotemsgbody()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_set_canonicalurl(from._internal_canonicalurl()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_set_matchedtext(from._internal_matchedtext()); - } - if (cached_has_bits & 0x00000020u) { - _this->_internal_set_title(from._internal_title()); - } - if (cached_has_bits & 0x00000040u) { - _this->_internal_set_description(from._internal_description()); - } - if (cached_has_bits & 0x00000080u) { - _this->_internal_set_futureproofbuffer(from._internal_futureproofbuffer()); - } - } - if (cached_has_bits & 0x0000ff00u) { - if (cached_has_bits & 0x00000100u) { - _this->_internal_set_clienturl(from._internal_clienturl()); - } - if (cached_has_bits & 0x00000200u) { - _this->_internal_set_loc(from._internal_loc()); - } - if (cached_has_bits & 0x00000400u) { - _this->_internal_set_pollname(from._internal_pollname()); - } - if (cached_has_bits & 0x00000800u) { - _this->_internal_set_messagesecret(from._internal_messagesecret()); - } - if (cached_has_bits & 0x00001000u) { - _this->_internal_set_pollupdateparentkey(from._internal_pollupdateparentkey()); - } - if (cached_has_bits & 0x00002000u) { - _this->_internal_mutable_encpollvote()->::proto::PollEncValue::MergeFrom( - from._internal_encpollvote()); - } - if (cached_has_bits & 0x00004000u) { - _this->_impl_.lng_ = from._impl_.lng_; - } - if (cached_has_bits & 0x00008000u) { - _this->_impl_.lat_ = from._impl_.lat_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - if (cached_has_bits & 0x000f0000u) { - if (cached_has_bits & 0x00010000u) { - _this->_impl_.islive_ = from._impl_.islive_; - } - if (cached_has_bits & 0x00020000u) { - _this->_impl_.paymentamount1000_ = from._impl_.paymentamount1000_; - } - if (cached_has_bits & 0x00040000u) { - _this->_impl_.sendertimestampms_ = from._impl_.sendertimestampms_; - } - if (cached_has_bits & 0x00080000u) { - _this->_impl_.pollselectableoptionscount_ = from._impl_.pollselectableoptionscount_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void MsgOpaqueData::CopyFrom(const MsgOpaqueData& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.MsgOpaqueData) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool MsgOpaqueData::IsInitialized() const { - return true; -} - -void MsgOpaqueData::InternalSwap(MsgOpaqueData* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.polloptions_.InternalSwap(&other->_impl_.polloptions_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.body_, lhs_arena, - &other->_impl_.body_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.caption_, lhs_arena, - &other->_impl_.caption_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.paymentnotemsgbody_, lhs_arena, - &other->_impl_.paymentnotemsgbody_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.canonicalurl_, lhs_arena, - &other->_impl_.canonicalurl_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.matchedtext_, lhs_arena, - &other->_impl_.matchedtext_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.title_, lhs_arena, - &other->_impl_.title_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.description_, lhs_arena, - &other->_impl_.description_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.futureproofbuffer_, lhs_arena, - &other->_impl_.futureproofbuffer_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.clienturl_, lhs_arena, - &other->_impl_.clienturl_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.loc_, lhs_arena, - &other->_impl_.loc_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.pollname_, lhs_arena, - &other->_impl_.pollname_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.messagesecret_, lhs_arena, - &other->_impl_.messagesecret_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.pollupdateparentkey_, lhs_arena, - &other->_impl_.pollupdateparentkey_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(MsgOpaqueData, _impl_.pollselectableoptionscount_) - + sizeof(MsgOpaqueData::_impl_.pollselectableoptionscount_) - - PROTOBUF_FIELD_OFFSET(MsgOpaqueData, _impl_.encpollvote_)>( - reinterpret_cast(&_impl_.encpollvote_), - reinterpret_cast(&other->_impl_.encpollvote_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata MsgOpaqueData::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[142]); -} - -// =================================================================== - -class MsgRowOpaqueData::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::MsgOpaqueData& currentmsg(const MsgRowOpaqueData* msg); - static void set_has_currentmsg(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::proto::MsgOpaqueData& quotedmsg(const MsgRowOpaqueData* msg); - static void set_has_quotedmsg(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -const ::proto::MsgOpaqueData& -MsgRowOpaqueData::_Internal::currentmsg(const MsgRowOpaqueData* msg) { - return *msg->_impl_.currentmsg_; -} -const ::proto::MsgOpaqueData& -MsgRowOpaqueData::_Internal::quotedmsg(const MsgRowOpaqueData* msg) { - return *msg->_impl_.quotedmsg_; -} -MsgRowOpaqueData::MsgRowOpaqueData(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.MsgRowOpaqueData) -} -MsgRowOpaqueData::MsgRowOpaqueData(const MsgRowOpaqueData& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - MsgRowOpaqueData* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.currentmsg_){nullptr} - , decltype(_impl_.quotedmsg_){nullptr}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_currentmsg()) { - _this->_impl_.currentmsg_ = new ::proto::MsgOpaqueData(*from._impl_.currentmsg_); - } - if (from._internal_has_quotedmsg()) { - _this->_impl_.quotedmsg_ = new ::proto::MsgOpaqueData(*from._impl_.quotedmsg_); - } - // @@protoc_insertion_point(copy_constructor:proto.MsgRowOpaqueData) -} - -inline void MsgRowOpaqueData::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.currentmsg_){nullptr} - , decltype(_impl_.quotedmsg_){nullptr} - }; -} - -MsgRowOpaqueData::~MsgRowOpaqueData() { - // @@protoc_insertion_point(destructor:proto.MsgRowOpaqueData) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void MsgRowOpaqueData::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete _impl_.currentmsg_; - if (this != internal_default_instance()) delete _impl_.quotedmsg_; -} - -void MsgRowOpaqueData::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void MsgRowOpaqueData::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.MsgRowOpaqueData) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.currentmsg_ != nullptr); - _impl_.currentmsg_->Clear(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.quotedmsg_ != nullptr); - _impl_.quotedmsg_->Clear(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* MsgRowOpaqueData::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.MsgOpaqueData currentMsg = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_currentmsg(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.MsgOpaqueData quotedMsg = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_quotedmsg(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* MsgRowOpaqueData::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.MsgRowOpaqueData) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.MsgOpaqueData currentMsg = 1; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::currentmsg(this), - _Internal::currentmsg(this).GetCachedSize(), target, stream); - } - - // optional .proto.MsgOpaqueData quotedMsg = 2; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::quotedmsg(this), - _Internal::quotedmsg(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.MsgRowOpaqueData) - return target; -} - -size_t MsgRowOpaqueData::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.MsgRowOpaqueData) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional .proto.MsgOpaqueData currentMsg = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.currentmsg_); - } - - // optional .proto.MsgOpaqueData quotedMsg = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.quotedmsg_); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MsgRowOpaqueData::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - MsgRowOpaqueData::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MsgRowOpaqueData::GetClassData() const { return &_class_data_; } - - -void MsgRowOpaqueData::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.MsgRowOpaqueData) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_mutable_currentmsg()->::proto::MsgOpaqueData::MergeFrom( - from._internal_currentmsg()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_quotedmsg()->::proto::MsgOpaqueData::MergeFrom( - from._internal_quotedmsg()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void MsgRowOpaqueData::CopyFrom(const MsgRowOpaqueData& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.MsgRowOpaqueData) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool MsgRowOpaqueData::IsInitialized() const { - return true; -} - -void MsgRowOpaqueData::InternalSwap(MsgRowOpaqueData* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(MsgRowOpaqueData, _impl_.quotedmsg_) - + sizeof(MsgRowOpaqueData::_impl_.quotedmsg_) - - PROTOBUF_FIELD_OFFSET(MsgRowOpaqueData, _impl_.currentmsg_)>( - reinterpret_cast(&_impl_.currentmsg_), - reinterpret_cast(&other->_impl_.currentmsg_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata MsgRowOpaqueData::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[143]); -} - -// =================================================================== - -class NoiseCertificate_Details::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_serial(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_issuer(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_expires(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_subject(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_key(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } -}; - -NoiseCertificate_Details::NoiseCertificate_Details(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.NoiseCertificate.Details) -} -NoiseCertificate_Details::NoiseCertificate_Details(const NoiseCertificate_Details& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - NoiseCertificate_Details* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.issuer_){} - , decltype(_impl_.subject_){} - , decltype(_impl_.key_){} - , decltype(_impl_.expires_){} - , decltype(_impl_.serial_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.issuer_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.issuer_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_issuer()) { - _this->_impl_.issuer_.Set(from._internal_issuer(), - _this->GetArenaForAllocation()); - } - _impl_.subject_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.subject_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_subject()) { - _this->_impl_.subject_.Set(from._internal_subject(), - _this->GetArenaForAllocation()); - } - _impl_.key_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.key_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_key()) { - _this->_impl_.key_.Set(from._internal_key(), - _this->GetArenaForAllocation()); - } - ::memcpy(&_impl_.expires_, &from._impl_.expires_, - static_cast(reinterpret_cast(&_impl_.serial_) - - reinterpret_cast(&_impl_.expires_)) + sizeof(_impl_.serial_)); - // @@protoc_insertion_point(copy_constructor:proto.NoiseCertificate.Details) -} - -inline void NoiseCertificate_Details::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.issuer_){} - , decltype(_impl_.subject_){} - , decltype(_impl_.key_){} - , decltype(_impl_.expires_){uint64_t{0u}} - , decltype(_impl_.serial_){0u} - }; - _impl_.issuer_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.issuer_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.subject_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.subject_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.key_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.key_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -NoiseCertificate_Details::~NoiseCertificate_Details() { - // @@protoc_insertion_point(destructor:proto.NoiseCertificate.Details) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void NoiseCertificate_Details::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.issuer_.Destroy(); - _impl_.subject_.Destroy(); - _impl_.key_.Destroy(); -} - -void NoiseCertificate_Details::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void NoiseCertificate_Details::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.NoiseCertificate.Details) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _impl_.issuer_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.subject_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.key_.ClearNonDefaultToEmpty(); - } - } - if (cached_has_bits & 0x00000018u) { - ::memset(&_impl_.expires_, 0, static_cast( - reinterpret_cast(&_impl_.serial_) - - reinterpret_cast(&_impl_.expires_)) + sizeof(_impl_.serial_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* NoiseCertificate_Details::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional uint32 serial = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_serial(&has_bits); - _impl_.serial_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string issuer = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_issuer(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.NoiseCertificate.Details.issuer"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional uint64 expires = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_expires(&has_bits); - _impl_.expires_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string subject = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - auto str = _internal_mutable_subject(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.NoiseCertificate.Details.subject"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bytes key = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - auto str = _internal_mutable_key(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* NoiseCertificate_Details::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.NoiseCertificate.Details) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional uint32 serial = 1; - if (cached_has_bits & 0x00000010u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_serial(), target); - } - - // optional string issuer = 2; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_issuer().data(), static_cast(this->_internal_issuer().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.NoiseCertificate.Details.issuer"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_issuer(), target); - } - - // optional uint64 expires = 3; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_expires(), target); - } - - // optional string subject = 4; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_subject().data(), static_cast(this->_internal_subject().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.NoiseCertificate.Details.subject"); - target = stream->WriteStringMaybeAliased( - 4, this->_internal_subject(), target); - } - - // optional bytes key = 5; - if (cached_has_bits & 0x00000004u) { - target = stream->WriteBytesMaybeAliased( - 5, this->_internal_key(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.NoiseCertificate.Details) - return target; -} - -size_t NoiseCertificate_Details::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.NoiseCertificate.Details) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { - // optional string issuer = 2; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_issuer()); - } - - // optional string subject = 4; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_subject()); - } - - // optional bytes key = 5; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_key()); - } - - // optional uint64 expires = 3; - if (cached_has_bits & 0x00000008u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_expires()); - } - - // optional uint32 serial = 1; - if (cached_has_bits & 0x00000010u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_serial()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NoiseCertificate_Details::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - NoiseCertificate_Details::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NoiseCertificate_Details::GetClassData() const { return &_class_data_; } - - -void NoiseCertificate_Details::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.NoiseCertificate.Details) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_issuer(from._internal_issuer()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_subject(from._internal_subject()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_key(from._internal_key()); - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.expires_ = from._impl_.expires_; - } - if (cached_has_bits & 0x00000010u) { - _this->_impl_.serial_ = from._impl_.serial_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void NoiseCertificate_Details::CopyFrom(const NoiseCertificate_Details& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.NoiseCertificate.Details) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool NoiseCertificate_Details::IsInitialized() const { - return true; -} - -void NoiseCertificate_Details::InternalSwap(NoiseCertificate_Details* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.issuer_, lhs_arena, - &other->_impl_.issuer_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.subject_, lhs_arena, - &other->_impl_.subject_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.key_, lhs_arena, - &other->_impl_.key_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(NoiseCertificate_Details, _impl_.serial_) - + sizeof(NoiseCertificate_Details::_impl_.serial_) - - PROTOBUF_FIELD_OFFSET(NoiseCertificate_Details, _impl_.expires_)>( - reinterpret_cast(&_impl_.expires_), - reinterpret_cast(&other->_impl_.expires_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata NoiseCertificate_Details::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[144]); -} - -// =================================================================== - -class NoiseCertificate::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_details(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_signature(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -NoiseCertificate::NoiseCertificate(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.NoiseCertificate) -} -NoiseCertificate::NoiseCertificate(const NoiseCertificate& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - NoiseCertificate* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.details_){} - , decltype(_impl_.signature_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.details_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.details_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_details()) { - _this->_impl_.details_.Set(from._internal_details(), - _this->GetArenaForAllocation()); - } - _impl_.signature_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.signature_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_signature()) { - _this->_impl_.signature_.Set(from._internal_signature(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.NoiseCertificate) -} - -inline void NoiseCertificate::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.details_){} - , decltype(_impl_.signature_){} - }; - _impl_.details_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.details_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.signature_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.signature_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -NoiseCertificate::~NoiseCertificate() { - // @@protoc_insertion_point(destructor:proto.NoiseCertificate) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void NoiseCertificate::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.details_.Destroy(); - _impl_.signature_.Destroy(); -} - -void NoiseCertificate::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void NoiseCertificate::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.NoiseCertificate) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.details_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.signature_.ClearNonDefaultToEmpty(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* NoiseCertificate::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bytes details = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_details(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes signature = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_signature(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* NoiseCertificate::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.NoiseCertificate) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bytes details = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 1, this->_internal_details(), target); - } - - // optional bytes signature = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_signature(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.NoiseCertificate) - return target; -} - -size_t NoiseCertificate::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.NoiseCertificate) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional bytes details = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_details()); - } - - // optional bytes signature = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_signature()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NoiseCertificate::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - NoiseCertificate::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NoiseCertificate::GetClassData() const { return &_class_data_; } - - -void NoiseCertificate::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.NoiseCertificate) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_details(from._internal_details()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_signature(from._internal_signature()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void NoiseCertificate::CopyFrom(const NoiseCertificate& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.NoiseCertificate) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool NoiseCertificate::IsInitialized() const { - return true; -} - -void NoiseCertificate::InternalSwap(NoiseCertificate* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.details_, lhs_arena, - &other->_impl_.details_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.signature_, lhs_arena, - &other->_impl_.signature_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata NoiseCertificate::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[145]); -} - -// =================================================================== - -class NotificationMessageInfo::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::MessageKey& key(const NotificationMessageInfo* msg); - static void set_has_key(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::proto::Message& message(const NotificationMessageInfo* msg); - static void set_has_message(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_messagetimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_participant(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -const ::proto::MessageKey& -NotificationMessageInfo::_Internal::key(const NotificationMessageInfo* msg) { - return *msg->_impl_.key_; -} -const ::proto::Message& -NotificationMessageInfo::_Internal::message(const NotificationMessageInfo* msg) { - return *msg->_impl_.message_; -} -NotificationMessageInfo::NotificationMessageInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.NotificationMessageInfo) -} -NotificationMessageInfo::NotificationMessageInfo(const NotificationMessageInfo& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - NotificationMessageInfo* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.participant_){} - , decltype(_impl_.key_){nullptr} - , decltype(_impl_.message_){nullptr} - , decltype(_impl_.messagetimestamp_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.participant_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.participant_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_participant()) { - _this->_impl_.participant_.Set(from._internal_participant(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_key()) { - _this->_impl_.key_ = new ::proto::MessageKey(*from._impl_.key_); - } - if (from._internal_has_message()) { - _this->_impl_.message_ = new ::proto::Message(*from._impl_.message_); - } - _this->_impl_.messagetimestamp_ = from._impl_.messagetimestamp_; - // @@protoc_insertion_point(copy_constructor:proto.NotificationMessageInfo) -} - -inline void NotificationMessageInfo::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.participant_){} - , decltype(_impl_.key_){nullptr} - , decltype(_impl_.message_){nullptr} - , decltype(_impl_.messagetimestamp_){uint64_t{0u}} - }; - _impl_.participant_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.participant_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -NotificationMessageInfo::~NotificationMessageInfo() { - // @@protoc_insertion_point(destructor:proto.NotificationMessageInfo) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void NotificationMessageInfo::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.participant_.Destroy(); - if (this != internal_default_instance()) delete _impl_.key_; - if (this != internal_default_instance()) delete _impl_.message_; -} - -void NotificationMessageInfo::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void NotificationMessageInfo::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.NotificationMessageInfo) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _impl_.participant_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.key_ != nullptr); - _impl_.key_->Clear(); - } - if (cached_has_bits & 0x00000004u) { - GOOGLE_DCHECK(_impl_.message_ != nullptr); - _impl_.message_->Clear(); - } - } - _impl_.messagetimestamp_ = uint64_t{0u}; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* NotificationMessageInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.MessageKey key = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message message = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_message(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint64 messageTimestamp = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_messagetimestamp(&has_bits); - _impl_.messagetimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string participant = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - auto str = _internal_mutable_participant(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.NotificationMessageInfo.participant"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* NotificationMessageInfo::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.NotificationMessageInfo) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.MessageKey key = 1; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::key(this), - _Internal::key(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message message = 2; - if (cached_has_bits & 0x00000004u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::message(this), - _Internal::message(this).GetCachedSize(), target, stream); - } - - // optional uint64 messageTimestamp = 3; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_messagetimestamp(), target); - } - - // optional string participant = 4; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_participant().data(), static_cast(this->_internal_participant().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.NotificationMessageInfo.participant"); - target = stream->WriteStringMaybeAliased( - 4, this->_internal_participant(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.NotificationMessageInfo) - return target; -} - -size_t NotificationMessageInfo::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.NotificationMessageInfo) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - // optional string participant = 4; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_participant()); - } - - // optional .proto.MessageKey key = 1; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.key_); - } - - // optional .proto.Message message = 2; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.message_); - } - - // optional uint64 messageTimestamp = 3; - if (cached_has_bits & 0x00000008u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_messagetimestamp()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NotificationMessageInfo::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - NotificationMessageInfo::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NotificationMessageInfo::GetClassData() const { return &_class_data_; } - - -void NotificationMessageInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.NotificationMessageInfo) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_participant(from._internal_participant()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_key()->::proto::MessageKey::MergeFrom( - from._internal_key()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_mutable_message()->::proto::Message::MergeFrom( - from._internal_message()); - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.messagetimestamp_ = from._impl_.messagetimestamp_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void NotificationMessageInfo::CopyFrom(const NotificationMessageInfo& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.NotificationMessageInfo) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool NotificationMessageInfo::IsInitialized() const { - return true; -} - -void NotificationMessageInfo::InternalSwap(NotificationMessageInfo* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.participant_, lhs_arena, - &other->_impl_.participant_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(NotificationMessageInfo, _impl_.messagetimestamp_) - + sizeof(NotificationMessageInfo::_impl_.messagetimestamp_) - - PROTOBUF_FIELD_OFFSET(NotificationMessageInfo, _impl_.key_)>( - reinterpret_cast(&_impl_.key_), - reinterpret_cast(&other->_impl_.key_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata NotificationMessageInfo::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[146]); -} - -// =================================================================== - -class PastParticipant::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_userjid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_leavereason(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_leavets(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static bool MissingRequiredFields(const HasBits& has_bits) { - return ((has_bits[0] & 0x00000007) ^ 0x00000007) != 0; - } -}; - -PastParticipant::PastParticipant(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.PastParticipant) -} -PastParticipant::PastParticipant(const PastParticipant& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - PastParticipant* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.userjid_){} - , decltype(_impl_.leavets_){} - , decltype(_impl_.leavereason_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.userjid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.userjid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_userjid()) { - _this->_impl_.userjid_.Set(from._internal_userjid(), - _this->GetArenaForAllocation()); - } - ::memcpy(&_impl_.leavets_, &from._impl_.leavets_, - static_cast(reinterpret_cast(&_impl_.leavereason_) - - reinterpret_cast(&_impl_.leavets_)) + sizeof(_impl_.leavereason_)); - // @@protoc_insertion_point(copy_constructor:proto.PastParticipant) -} - -inline void PastParticipant::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.userjid_){} - , decltype(_impl_.leavets_){uint64_t{0u}} - , decltype(_impl_.leavereason_){0} - }; - _impl_.userjid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.userjid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -PastParticipant::~PastParticipant() { - // @@protoc_insertion_point(destructor:proto.PastParticipant) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void PastParticipant::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.userjid_.Destroy(); -} - -void PastParticipant::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void PastParticipant::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.PastParticipant) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.userjid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000006u) { - ::memset(&_impl_.leavets_, 0, static_cast( - reinterpret_cast(&_impl_.leavereason_) - - reinterpret_cast(&_impl_.leavets_)) + sizeof(_impl_.leavereason_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* PastParticipant::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // required string userJid = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_userjid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.PastParticipant.userJid"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // required .proto.PastParticipant.LeaveReason leaveReason = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::PastParticipant_LeaveReason_IsValid(val))) { - _internal_set_leavereason(static_cast<::proto::PastParticipant_LeaveReason>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // required uint64 leaveTs = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_leavets(&has_bits); - _impl_.leavets_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* PastParticipant::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.PastParticipant) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // required string userJid = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_userjid().data(), static_cast(this->_internal_userjid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.PastParticipant.userJid"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_userjid(), target); - } - - // required .proto.PastParticipant.LeaveReason leaveReason = 2; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 2, this->_internal_leavereason(), target); - } - - // required uint64 leaveTs = 3; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_leavets(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.PastParticipant) - return target; -} - -size_t PastParticipant::RequiredFieldsByteSizeFallback() const { -// @@protoc_insertion_point(required_fields_byte_size_fallback_start:proto.PastParticipant) - size_t total_size = 0; - - if (_internal_has_userjid()) { - // required string userJid = 1; - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_userjid()); - } - - if (_internal_has_leavets()) { - // required uint64 leaveTs = 3; - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_leavets()); - } - - if (_internal_has_leavereason()) { - // required .proto.PastParticipant.LeaveReason leaveReason = 2; - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_leavereason()); - } - - return total_size; -} -size_t PastParticipant::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.PastParticipant) - size_t total_size = 0; - - if (((_impl_._has_bits_[0] & 0x00000007) ^ 0x00000007) == 0) { // All required fields are present. - // required string userJid = 1; - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_userjid()); - - // required uint64 leaveTs = 3; - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_leavets()); - - // required .proto.PastParticipant.LeaveReason leaveReason = 2; - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_leavereason()); - - } else { - total_size += RequiredFieldsByteSizeFallback(); - } - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PastParticipant::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - PastParticipant::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PastParticipant::GetClassData() const { return &_class_data_; } - - -void PastParticipant::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.PastParticipant) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_userjid(from._internal_userjid()); - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.leavets_ = from._impl_.leavets_; - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.leavereason_ = from._impl_.leavereason_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void PastParticipant::CopyFrom(const PastParticipant& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.PastParticipant) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool PastParticipant::IsInitialized() const { - if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false; - return true; -} - -void PastParticipant::InternalSwap(PastParticipant* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.userjid_, lhs_arena, - &other->_impl_.userjid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(PastParticipant, _impl_.leavereason_) - + sizeof(PastParticipant::_impl_.leavereason_) - - PROTOBUF_FIELD_OFFSET(PastParticipant, _impl_.leavets_)>( - reinterpret_cast(&_impl_.leavets_), - reinterpret_cast(&other->_impl_.leavets_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata PastParticipant::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[147]); -} - -// =================================================================== - -class PastParticipants::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_groupjid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static bool MissingRequiredFields(const HasBits& has_bits) { - return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0; - } -}; - -PastParticipants::PastParticipants(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.PastParticipants) -} -PastParticipants::PastParticipants(const PastParticipants& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - PastParticipants* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.pastparticipants_){from._impl_.pastparticipants_} - , decltype(_impl_.groupjid_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.groupjid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.groupjid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_groupjid()) { - _this->_impl_.groupjid_.Set(from._internal_groupjid(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.PastParticipants) -} - -inline void PastParticipants::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.pastparticipants_){arena} - , decltype(_impl_.groupjid_){} - }; - _impl_.groupjid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.groupjid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -PastParticipants::~PastParticipants() { - // @@protoc_insertion_point(destructor:proto.PastParticipants) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void PastParticipants::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.pastparticipants_.~RepeatedPtrField(); - _impl_.groupjid_.Destroy(); -} - -void PastParticipants::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void PastParticipants::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.PastParticipants) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.pastparticipants_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.groupjid_.ClearNonDefaultToEmpty(); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* PastParticipants::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // required string groupJid = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_groupjid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.PastParticipants.groupJid"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // repeated .proto.PastParticipant pastParticipants = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_pastparticipants(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* PastParticipants::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.PastParticipants) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // required string groupJid = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_groupjid().data(), static_cast(this->_internal_groupjid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.PastParticipants.groupJid"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_groupjid(), target); - } - - // repeated .proto.PastParticipant pastParticipants = 2; - for (unsigned i = 0, - n = static_cast(this->_internal_pastparticipants_size()); i < n; i++) { - const auto& repfield = this->_internal_pastparticipants(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.PastParticipants) - return target; -} - -size_t PastParticipants::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.PastParticipants) - size_t total_size = 0; - - // required string groupJid = 1; - if (_internal_has_groupjid()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_groupjid()); - } - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.PastParticipant pastParticipants = 2; - total_size += 1UL * this->_internal_pastparticipants_size(); - for (const auto& msg : this->_impl_.pastparticipants_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PastParticipants::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - PastParticipants::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PastParticipants::GetClassData() const { return &_class_data_; } - - -void PastParticipants::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.PastParticipants) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.pastparticipants_.MergeFrom(from._impl_.pastparticipants_); - if (from._internal_has_groupjid()) { - _this->_internal_set_groupjid(from._internal_groupjid()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void PastParticipants::CopyFrom(const PastParticipants& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.PastParticipants) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool PastParticipants::IsInitialized() const { - if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false; - if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.pastparticipants_)) - return false; - return true; -} - -void PastParticipants::InternalSwap(PastParticipants* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.pastparticipants_.InternalSwap(&other->_impl_.pastparticipants_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.groupjid_, lhs_arena, - &other->_impl_.groupjid_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata PastParticipants::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[148]); -} - -// =================================================================== - -class PaymentBackground_MediaData::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_mediakey(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_mediakeytimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_filesha256(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_fileencsha256(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_directpath(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } -}; - -PaymentBackground_MediaData::PaymentBackground_MediaData(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.PaymentBackground.MediaData) -} -PaymentBackground_MediaData::PaymentBackground_MediaData(const PaymentBackground_MediaData& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - PaymentBackground_MediaData* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.mediakey_){} - , decltype(_impl_.filesha256_){} - , decltype(_impl_.fileencsha256_){} - , decltype(_impl_.directpath_){} - , decltype(_impl_.mediakeytimestamp_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.mediakey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediakey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_mediakey()) { - _this->_impl_.mediakey_.Set(from._internal_mediakey(), - _this->GetArenaForAllocation()); - } - _impl_.filesha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filesha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_filesha256()) { - _this->_impl_.filesha256_.Set(from._internal_filesha256(), - _this->GetArenaForAllocation()); - } - _impl_.fileencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_fileencsha256()) { - _this->_impl_.fileencsha256_.Set(from._internal_fileencsha256(), - _this->GetArenaForAllocation()); - } - _impl_.directpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_directpath()) { - _this->_impl_.directpath_.Set(from._internal_directpath(), - _this->GetArenaForAllocation()); - } - _this->_impl_.mediakeytimestamp_ = from._impl_.mediakeytimestamp_; - // @@protoc_insertion_point(copy_constructor:proto.PaymentBackground.MediaData) -} - -inline void PaymentBackground_MediaData::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.mediakey_){} - , decltype(_impl_.filesha256_){} - , decltype(_impl_.fileencsha256_){} - , decltype(_impl_.directpath_){} - , decltype(_impl_.mediakeytimestamp_){int64_t{0}} - }; - _impl_.mediakey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediakey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filesha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filesha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fileencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -PaymentBackground_MediaData::~PaymentBackground_MediaData() { - // @@protoc_insertion_point(destructor:proto.PaymentBackground.MediaData) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void PaymentBackground_MediaData::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.mediakey_.Destroy(); - _impl_.filesha256_.Destroy(); - _impl_.fileencsha256_.Destroy(); - _impl_.directpath_.Destroy(); -} - -void PaymentBackground_MediaData::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void PaymentBackground_MediaData::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.PaymentBackground.MediaData) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - if (cached_has_bits & 0x00000001u) { - _impl_.mediakey_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.filesha256_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.fileencsha256_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000008u) { - _impl_.directpath_.ClearNonDefaultToEmpty(); - } - } - _impl_.mediakeytimestamp_ = int64_t{0}; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* PaymentBackground_MediaData::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bytes mediaKey = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_mediakey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional int64 mediaKeyTimestamp = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_mediakeytimestamp(&has_bits); - _impl_.mediakeytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes fileSha256 = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_filesha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes fileEncSha256 = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - auto str = _internal_mutable_fileencsha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string directPath = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - auto str = _internal_mutable_directpath(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.PaymentBackground.MediaData.directPath"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* PaymentBackground_MediaData::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.PaymentBackground.MediaData) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bytes mediaKey = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 1, this->_internal_mediakey(), target); - } - - // optional int64 mediaKeyTimestamp = 2; - if (cached_has_bits & 0x00000010u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_mediakeytimestamp(), target); - } - - // optional bytes fileSha256 = 3; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 3, this->_internal_filesha256(), target); - } - - // optional bytes fileEncSha256 = 4; - if (cached_has_bits & 0x00000004u) { - target = stream->WriteBytesMaybeAliased( - 4, this->_internal_fileencsha256(), target); - } - - // optional string directPath = 5; - if (cached_has_bits & 0x00000008u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_directpath().data(), static_cast(this->_internal_directpath().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.PaymentBackground.MediaData.directPath"); - target = stream->WriteStringMaybeAliased( - 5, this->_internal_directpath(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.PaymentBackground.MediaData) - return target; -} - -size_t PaymentBackground_MediaData::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.PaymentBackground.MediaData) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { - // optional bytes mediaKey = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_mediakey()); - } - - // optional bytes fileSha256 = 3; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_filesha256()); - } - - // optional bytes fileEncSha256 = 4; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_fileencsha256()); - } - - // optional string directPath = 5; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_directpath()); - } - - // optional int64 mediaKeyTimestamp = 2; - if (cached_has_bits & 0x00000010u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_mediakeytimestamp()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PaymentBackground_MediaData::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - PaymentBackground_MediaData::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PaymentBackground_MediaData::GetClassData() const { return &_class_data_; } - - -void PaymentBackground_MediaData::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.PaymentBackground.MediaData) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_mediakey(from._internal_mediakey()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_filesha256(from._internal_filesha256()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_fileencsha256(from._internal_fileencsha256()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_set_directpath(from._internal_directpath()); - } - if (cached_has_bits & 0x00000010u) { - _this->_impl_.mediakeytimestamp_ = from._impl_.mediakeytimestamp_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void PaymentBackground_MediaData::CopyFrom(const PaymentBackground_MediaData& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.PaymentBackground.MediaData) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool PaymentBackground_MediaData::IsInitialized() const { - return true; -} - -void PaymentBackground_MediaData::InternalSwap(PaymentBackground_MediaData* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.mediakey_, lhs_arena, - &other->_impl_.mediakey_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.filesha256_, lhs_arena, - &other->_impl_.filesha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.fileencsha256_, lhs_arena, - &other->_impl_.fileencsha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.directpath_, lhs_arena, - &other->_impl_.directpath_, rhs_arena - ); - swap(_impl_.mediakeytimestamp_, other->_impl_.mediakeytimestamp_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata PaymentBackground_MediaData::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[149]); -} - -// =================================================================== - -class PaymentBackground::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_id(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_filelength(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_width(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_height(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static void set_has_mimetype(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_placeholderargb(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static void set_has_textargb(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } - static void set_has_subtextargb(HasBits* has_bits) { - (*has_bits)[0] |= 256u; - } - static const ::proto::PaymentBackground_MediaData& mediadata(const PaymentBackground* msg); - static void set_has_mediadata(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_type(HasBits* has_bits) { - (*has_bits)[0] |= 512u; - } -}; - -const ::proto::PaymentBackground_MediaData& -PaymentBackground::_Internal::mediadata(const PaymentBackground* msg) { - return *msg->_impl_.mediadata_; -} -PaymentBackground::PaymentBackground(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.PaymentBackground) -} -PaymentBackground::PaymentBackground(const PaymentBackground& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - PaymentBackground* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.id_){} - , decltype(_impl_.mimetype_){} - , decltype(_impl_.mediadata_){nullptr} - , decltype(_impl_.filelength_){} - , decltype(_impl_.width_){} - , decltype(_impl_.height_){} - , decltype(_impl_.placeholderargb_){} - , decltype(_impl_.textargb_){} - , decltype(_impl_.subtextargb_){} - , decltype(_impl_.type_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.id_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.id_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_id()) { - _this->_impl_.id_.Set(from._internal_id(), - _this->GetArenaForAllocation()); - } - _impl_.mimetype_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mimetype_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_mimetype()) { - _this->_impl_.mimetype_.Set(from._internal_mimetype(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_mediadata()) { - _this->_impl_.mediadata_ = new ::proto::PaymentBackground_MediaData(*from._impl_.mediadata_); - } - ::memcpy(&_impl_.filelength_, &from._impl_.filelength_, - static_cast(reinterpret_cast(&_impl_.type_) - - reinterpret_cast(&_impl_.filelength_)) + sizeof(_impl_.type_)); - // @@protoc_insertion_point(copy_constructor:proto.PaymentBackground) -} - -inline void PaymentBackground::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.id_){} - , decltype(_impl_.mimetype_){} - , decltype(_impl_.mediadata_){nullptr} - , decltype(_impl_.filelength_){uint64_t{0u}} - , decltype(_impl_.width_){0u} - , decltype(_impl_.height_){0u} - , decltype(_impl_.placeholderargb_){0u} - , decltype(_impl_.textargb_){0u} - , decltype(_impl_.subtextargb_){0u} - , decltype(_impl_.type_){0} - }; - _impl_.id_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.id_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mimetype_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mimetype_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -PaymentBackground::~PaymentBackground() { - // @@protoc_insertion_point(destructor:proto.PaymentBackground) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void PaymentBackground::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.id_.Destroy(); - _impl_.mimetype_.Destroy(); - if (this != internal_default_instance()) delete _impl_.mediadata_; -} - -void PaymentBackground::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void PaymentBackground::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.PaymentBackground) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _impl_.id_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.mimetype_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - GOOGLE_DCHECK(_impl_.mediadata_ != nullptr); - _impl_.mediadata_->Clear(); - } - } - if (cached_has_bits & 0x000000f8u) { - ::memset(&_impl_.filelength_, 0, static_cast( - reinterpret_cast(&_impl_.textargb_) - - reinterpret_cast(&_impl_.filelength_)) + sizeof(_impl_.textargb_)); - } - if (cached_has_bits & 0x00000300u) { - ::memset(&_impl_.subtextargb_, 0, static_cast( - reinterpret_cast(&_impl_.type_) - - reinterpret_cast(&_impl_.subtextargb_)) + sizeof(_impl_.type_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* PaymentBackground::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string id = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_id(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.PaymentBackground.id"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional uint64 fileLength = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_filelength(&has_bits); - _impl_.filelength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 width = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_width(&has_bits); - _impl_.width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 height = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - _Internal::set_has_height(&has_bits); - _impl_.height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string mimetype = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - auto str = _internal_mutable_mimetype(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.PaymentBackground.mimetype"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional fixed32 placeholderArgb = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 53)) { - _Internal::set_has_placeholderargb(&has_bits); - _impl_.placeholderargb_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); - ptr += sizeof(uint32_t); - } else - goto handle_unusual; - continue; - // optional fixed32 textArgb = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 61)) { - _Internal::set_has_textargb(&has_bits); - _impl_.textargb_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); - ptr += sizeof(uint32_t); - } else - goto handle_unusual; - continue; - // optional fixed32 subtextArgb = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 69)) { - _Internal::set_has_subtextargb(&has_bits); - _impl_.subtextargb_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); - ptr += sizeof(uint32_t); - } else - goto handle_unusual; - continue; - // optional .proto.PaymentBackground.MediaData mediaData = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { - ptr = ctx->ParseMessage(_internal_mutable_mediadata(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.PaymentBackground.Type type = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::PaymentBackground_Type_IsValid(val))) { - _internal_set_type(static_cast<::proto::PaymentBackground_Type>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(10, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* PaymentBackground::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.PaymentBackground) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string id = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_id().data(), static_cast(this->_internal_id().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.PaymentBackground.id"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_id(), target); - } - - // optional uint64 fileLength = 2; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_filelength(), target); - } - - // optional uint32 width = 3; - if (cached_has_bits & 0x00000010u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_width(), target); - } - - // optional uint32 height = 4; - if (cached_has_bits & 0x00000020u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_height(), target); - } - - // optional string mimetype = 5; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_mimetype().data(), static_cast(this->_internal_mimetype().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.PaymentBackground.mimetype"); - target = stream->WriteStringMaybeAliased( - 5, this->_internal_mimetype(), target); - } - - // optional fixed32 placeholderArgb = 6; - if (cached_has_bits & 0x00000040u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteFixed32ToArray(6, this->_internal_placeholderargb(), target); - } - - // optional fixed32 textArgb = 7; - if (cached_has_bits & 0x00000080u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteFixed32ToArray(7, this->_internal_textargb(), target); - } - - // optional fixed32 subtextArgb = 8; - if (cached_has_bits & 0x00000100u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteFixed32ToArray(8, this->_internal_subtextargb(), target); - } - - // optional .proto.PaymentBackground.MediaData mediaData = 9; - if (cached_has_bits & 0x00000004u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(9, _Internal::mediadata(this), - _Internal::mediadata(this).GetCachedSize(), target, stream); - } - - // optional .proto.PaymentBackground.Type type = 10; - if (cached_has_bits & 0x00000200u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 10, this->_internal_type(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.PaymentBackground) - return target; -} - -size_t PaymentBackground::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.PaymentBackground) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional string id = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_id()); - } - - // optional string mimetype = 5; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_mimetype()); - } - - // optional .proto.PaymentBackground.MediaData mediaData = 9; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.mediadata_); - } - - // optional uint64 fileLength = 2; - if (cached_has_bits & 0x00000008u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_filelength()); - } - - // optional uint32 width = 3; - if (cached_has_bits & 0x00000010u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_width()); - } - - // optional uint32 height = 4; - if (cached_has_bits & 0x00000020u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_height()); - } - - // optional fixed32 placeholderArgb = 6; - if (cached_has_bits & 0x00000040u) { - total_size += 1 + 4; - } - - // optional fixed32 textArgb = 7; - if (cached_has_bits & 0x00000080u) { - total_size += 1 + 4; - } - - } - if (cached_has_bits & 0x00000300u) { - // optional fixed32 subtextArgb = 8; - if (cached_has_bits & 0x00000100u) { - total_size += 1 + 4; - } - - // optional .proto.PaymentBackground.Type type = 10; - if (cached_has_bits & 0x00000200u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_type()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PaymentBackground::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - PaymentBackground::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PaymentBackground::GetClassData() const { return &_class_data_; } - - -void PaymentBackground::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.PaymentBackground) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_id(from._internal_id()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_mimetype(from._internal_mimetype()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_mutable_mediadata()->::proto::PaymentBackground_MediaData::MergeFrom( - from._internal_mediadata()); - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.filelength_ = from._impl_.filelength_; - } - if (cached_has_bits & 0x00000010u) { - _this->_impl_.width_ = from._impl_.width_; - } - if (cached_has_bits & 0x00000020u) { - _this->_impl_.height_ = from._impl_.height_; - } - if (cached_has_bits & 0x00000040u) { - _this->_impl_.placeholderargb_ = from._impl_.placeholderargb_; - } - if (cached_has_bits & 0x00000080u) { - _this->_impl_.textargb_ = from._impl_.textargb_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - if (cached_has_bits & 0x00000300u) { - if (cached_has_bits & 0x00000100u) { - _this->_impl_.subtextargb_ = from._impl_.subtextargb_; - } - if (cached_has_bits & 0x00000200u) { - _this->_impl_.type_ = from._impl_.type_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void PaymentBackground::CopyFrom(const PaymentBackground& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.PaymentBackground) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool PaymentBackground::IsInitialized() const { - return true; -} - -void PaymentBackground::InternalSwap(PaymentBackground* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.id_, lhs_arena, - &other->_impl_.id_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.mimetype_, lhs_arena, - &other->_impl_.mimetype_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(PaymentBackground, _impl_.type_) - + sizeof(PaymentBackground::_impl_.type_) - - PROTOBUF_FIELD_OFFSET(PaymentBackground, _impl_.mediadata_)>( - reinterpret_cast(&_impl_.mediadata_), - reinterpret_cast(&other->_impl_.mediadata_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata PaymentBackground::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[150]); -} - -// =================================================================== - -class PaymentInfo::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_currencydeprecated(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static void set_has_amount1000(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static void set_has_receiverjid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_status(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } - static void set_has_transactiontimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 256u; - } - static const ::proto::MessageKey& requestmessagekey(const PaymentInfo* msg); - static void set_has_requestmessagekey(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_expirytimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 512u; - } - static void set_has_futureproofed(HasBits* has_bits) { - (*has_bits)[0] |= 1024u; - } - static void set_has_currency(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_txnstatus(HasBits* has_bits) { - (*has_bits)[0] |= 4096u; - } - static void set_has_usenovifiatformat(HasBits* has_bits) { - (*has_bits)[0] |= 2048u; - } - static const ::proto::Money& primaryamount(const PaymentInfo* msg); - static void set_has_primaryamount(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static const ::proto::Money& exchangeamount(const PaymentInfo* msg); - static void set_has_exchangeamount(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } -}; - -const ::proto::MessageKey& -PaymentInfo::_Internal::requestmessagekey(const PaymentInfo* msg) { - return *msg->_impl_.requestmessagekey_; -} -const ::proto::Money& -PaymentInfo::_Internal::primaryamount(const PaymentInfo* msg) { - return *msg->_impl_.primaryamount_; -} -const ::proto::Money& -PaymentInfo::_Internal::exchangeamount(const PaymentInfo* msg) { - return *msg->_impl_.exchangeamount_; -} -PaymentInfo::PaymentInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.PaymentInfo) -} -PaymentInfo::PaymentInfo(const PaymentInfo& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - PaymentInfo* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.receiverjid_){} - , decltype(_impl_.currency_){} - , decltype(_impl_.requestmessagekey_){nullptr} - , decltype(_impl_.primaryamount_){nullptr} - , decltype(_impl_.exchangeamount_){nullptr} - , decltype(_impl_.amount1000_){} - , decltype(_impl_.currencydeprecated_){} - , decltype(_impl_.status_){} - , decltype(_impl_.transactiontimestamp_){} - , decltype(_impl_.expirytimestamp_){} - , decltype(_impl_.futureproofed_){} - , decltype(_impl_.usenovifiatformat_){} - , decltype(_impl_.txnstatus_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.receiverjid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.receiverjid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_receiverjid()) { - _this->_impl_.receiverjid_.Set(from._internal_receiverjid(), - _this->GetArenaForAllocation()); - } - _impl_.currency_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.currency_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_currency()) { - _this->_impl_.currency_.Set(from._internal_currency(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_requestmessagekey()) { - _this->_impl_.requestmessagekey_ = new ::proto::MessageKey(*from._impl_.requestmessagekey_); - } - if (from._internal_has_primaryamount()) { - _this->_impl_.primaryamount_ = new ::proto::Money(*from._impl_.primaryamount_); - } - if (from._internal_has_exchangeamount()) { - _this->_impl_.exchangeamount_ = new ::proto::Money(*from._impl_.exchangeamount_); - } - ::memcpy(&_impl_.amount1000_, &from._impl_.amount1000_, - static_cast(reinterpret_cast(&_impl_.txnstatus_) - - reinterpret_cast(&_impl_.amount1000_)) + sizeof(_impl_.txnstatus_)); - // @@protoc_insertion_point(copy_constructor:proto.PaymentInfo) -} - -inline void PaymentInfo::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.receiverjid_){} - , decltype(_impl_.currency_){} - , decltype(_impl_.requestmessagekey_){nullptr} - , decltype(_impl_.primaryamount_){nullptr} - , decltype(_impl_.exchangeamount_){nullptr} - , decltype(_impl_.amount1000_){uint64_t{0u}} - , decltype(_impl_.currencydeprecated_){0} - , decltype(_impl_.status_){0} - , decltype(_impl_.transactiontimestamp_){uint64_t{0u}} - , decltype(_impl_.expirytimestamp_){uint64_t{0u}} - , decltype(_impl_.futureproofed_){false} - , decltype(_impl_.usenovifiatformat_){false} - , decltype(_impl_.txnstatus_){0} - }; - _impl_.receiverjid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.receiverjid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.currency_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.currency_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -PaymentInfo::~PaymentInfo() { - // @@protoc_insertion_point(destructor:proto.PaymentInfo) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void PaymentInfo::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.receiverjid_.Destroy(); - _impl_.currency_.Destroy(); - if (this != internal_default_instance()) delete _impl_.requestmessagekey_; - if (this != internal_default_instance()) delete _impl_.primaryamount_; - if (this != internal_default_instance()) delete _impl_.exchangeamount_; -} - -void PaymentInfo::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void PaymentInfo::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.PaymentInfo) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { - if (cached_has_bits & 0x00000001u) { - _impl_.receiverjid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.currency_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - GOOGLE_DCHECK(_impl_.requestmessagekey_ != nullptr); - _impl_.requestmessagekey_->Clear(); - } - if (cached_has_bits & 0x00000008u) { - GOOGLE_DCHECK(_impl_.primaryamount_ != nullptr); - _impl_.primaryamount_->Clear(); - } - if (cached_has_bits & 0x00000010u) { - GOOGLE_DCHECK(_impl_.exchangeamount_ != nullptr); - _impl_.exchangeamount_->Clear(); - } - } - if (cached_has_bits & 0x000000e0u) { - ::memset(&_impl_.amount1000_, 0, static_cast( - reinterpret_cast(&_impl_.status_) - - reinterpret_cast(&_impl_.amount1000_)) + sizeof(_impl_.status_)); - } - if (cached_has_bits & 0x00001f00u) { - ::memset(&_impl_.transactiontimestamp_, 0, static_cast( - reinterpret_cast(&_impl_.txnstatus_) - - reinterpret_cast(&_impl_.transactiontimestamp_)) + sizeof(_impl_.txnstatus_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* PaymentInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.PaymentInfo.Currency currencyDeprecated = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::PaymentInfo_Currency_IsValid(val))) { - _internal_set_currencydeprecated(static_cast<::proto::PaymentInfo_Currency>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional uint64 amount1000 = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_amount1000(&has_bits); - _impl_.amount1000_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string receiverJid = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_receiverjid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.PaymentInfo.receiverJid"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.PaymentInfo.Status status = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::PaymentInfo_Status_IsValid(val))) { - _internal_set_status(static_cast<::proto::PaymentInfo_Status>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional uint64 transactionTimestamp = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { - _Internal::set_has_transactiontimestamp(&has_bits); - _impl_.transactiontimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.MessageKey requestMessageKey = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - ptr = ctx->ParseMessage(_internal_mutable_requestmessagekey(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint64 expiryTimestamp = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { - _Internal::set_has_expirytimestamp(&has_bits); - _impl_.expirytimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool futureproofed = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { - _Internal::set_has_futureproofed(&has_bits); - _impl_.futureproofed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string currency = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { - auto str = _internal_mutable_currency(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.PaymentInfo.currency"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.PaymentInfo.TxnStatus txnStatus = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::PaymentInfo_TxnStatus_IsValid(val))) { - _internal_set_txnstatus(static_cast<::proto::PaymentInfo_TxnStatus>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(10, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional bool useNoviFiatFormat = 11; - case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { - _Internal::set_has_usenovifiatformat(&has_bits); - _impl_.usenovifiatformat_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Money primaryAmount = 12; - case 12: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { - ptr = ctx->ParseMessage(_internal_mutable_primaryamount(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Money exchangeAmount = 13; - case 13: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { - ptr = ctx->ParseMessage(_internal_mutable_exchangeamount(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* PaymentInfo::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.PaymentInfo) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.PaymentInfo.Currency currencyDeprecated = 1; - if (cached_has_bits & 0x00000040u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 1, this->_internal_currencydeprecated(), target); - } - - // optional uint64 amount1000 = 2; - if (cached_has_bits & 0x00000020u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_amount1000(), target); - } - - // optional string receiverJid = 3; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_receiverjid().data(), static_cast(this->_internal_receiverjid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.PaymentInfo.receiverJid"); - target = stream->WriteStringMaybeAliased( - 3, this->_internal_receiverjid(), target); - } - - // optional .proto.PaymentInfo.Status status = 4; - if (cached_has_bits & 0x00000080u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 4, this->_internal_status(), target); - } - - // optional uint64 transactionTimestamp = 5; - if (cached_has_bits & 0x00000100u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_transactiontimestamp(), target); - } - - // optional .proto.MessageKey requestMessageKey = 6; - if (cached_has_bits & 0x00000004u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(6, _Internal::requestmessagekey(this), - _Internal::requestmessagekey(this).GetCachedSize(), target, stream); - } - - // optional uint64 expiryTimestamp = 7; - if (cached_has_bits & 0x00000200u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(7, this->_internal_expirytimestamp(), target); - } - - // optional bool futureproofed = 8; - if (cached_has_bits & 0x00000400u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(8, this->_internal_futureproofed(), target); - } - - // optional string currency = 9; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_currency().data(), static_cast(this->_internal_currency().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.PaymentInfo.currency"); - target = stream->WriteStringMaybeAliased( - 9, this->_internal_currency(), target); - } - - // optional .proto.PaymentInfo.TxnStatus txnStatus = 10; - if (cached_has_bits & 0x00001000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 10, this->_internal_txnstatus(), target); - } - - // optional bool useNoviFiatFormat = 11; - if (cached_has_bits & 0x00000800u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(11, this->_internal_usenovifiatformat(), target); - } - - // optional .proto.Money primaryAmount = 12; - if (cached_has_bits & 0x00000008u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(12, _Internal::primaryamount(this), - _Internal::primaryamount(this).GetCachedSize(), target, stream); - } - - // optional .proto.Money exchangeAmount = 13; - if (cached_has_bits & 0x00000010u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(13, _Internal::exchangeamount(this), - _Internal::exchangeamount(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.PaymentInfo) - return target; -} - -size_t PaymentInfo::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.PaymentInfo) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional string receiverJid = 3; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_receiverjid()); - } - - // optional string currency = 9; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_currency()); - } - - // optional .proto.MessageKey requestMessageKey = 6; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.requestmessagekey_); - } - - // optional .proto.Money primaryAmount = 12; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.primaryamount_); - } - - // optional .proto.Money exchangeAmount = 13; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.exchangeamount_); - } - - // optional uint64 amount1000 = 2; - if (cached_has_bits & 0x00000020u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_amount1000()); - } - - // optional .proto.PaymentInfo.Currency currencyDeprecated = 1; - if (cached_has_bits & 0x00000040u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_currencydeprecated()); - } - - // optional .proto.PaymentInfo.Status status = 4; - if (cached_has_bits & 0x00000080u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_status()); - } - - } - if (cached_has_bits & 0x00001f00u) { - // optional uint64 transactionTimestamp = 5; - if (cached_has_bits & 0x00000100u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_transactiontimestamp()); - } - - // optional uint64 expiryTimestamp = 7; - if (cached_has_bits & 0x00000200u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_expirytimestamp()); - } - - // optional bool futureproofed = 8; - if (cached_has_bits & 0x00000400u) { - total_size += 1 + 1; - } - - // optional bool useNoviFiatFormat = 11; - if (cached_has_bits & 0x00000800u) { - total_size += 1 + 1; - } - - // optional .proto.PaymentInfo.TxnStatus txnStatus = 10; - if (cached_has_bits & 0x00001000u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_txnstatus()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PaymentInfo::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - PaymentInfo::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PaymentInfo::GetClassData() const { return &_class_data_; } - - -void PaymentInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.PaymentInfo) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_receiverjid(from._internal_receiverjid()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_currency(from._internal_currency()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_mutable_requestmessagekey()->::proto::MessageKey::MergeFrom( - from._internal_requestmessagekey()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_mutable_primaryamount()->::proto::Money::MergeFrom( - from._internal_primaryamount()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_mutable_exchangeamount()->::proto::Money::MergeFrom( - from._internal_exchangeamount()); - } - if (cached_has_bits & 0x00000020u) { - _this->_impl_.amount1000_ = from._impl_.amount1000_; - } - if (cached_has_bits & 0x00000040u) { - _this->_impl_.currencydeprecated_ = from._impl_.currencydeprecated_; - } - if (cached_has_bits & 0x00000080u) { - _this->_impl_.status_ = from._impl_.status_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - if (cached_has_bits & 0x00001f00u) { - if (cached_has_bits & 0x00000100u) { - _this->_impl_.transactiontimestamp_ = from._impl_.transactiontimestamp_; - } - if (cached_has_bits & 0x00000200u) { - _this->_impl_.expirytimestamp_ = from._impl_.expirytimestamp_; - } - if (cached_has_bits & 0x00000400u) { - _this->_impl_.futureproofed_ = from._impl_.futureproofed_; - } - if (cached_has_bits & 0x00000800u) { - _this->_impl_.usenovifiatformat_ = from._impl_.usenovifiatformat_; - } - if (cached_has_bits & 0x00001000u) { - _this->_impl_.txnstatus_ = from._impl_.txnstatus_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void PaymentInfo::CopyFrom(const PaymentInfo& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.PaymentInfo) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool PaymentInfo::IsInitialized() const { - return true; -} - -void PaymentInfo::InternalSwap(PaymentInfo* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.receiverjid_, lhs_arena, - &other->_impl_.receiverjid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.currency_, lhs_arena, - &other->_impl_.currency_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(PaymentInfo, _impl_.txnstatus_) - + sizeof(PaymentInfo::_impl_.txnstatus_) - - PROTOBUF_FIELD_OFFSET(PaymentInfo, _impl_.requestmessagekey_)>( - reinterpret_cast(&_impl_.requestmessagekey_), - reinterpret_cast(&other->_impl_.requestmessagekey_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata PaymentInfo::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[151]); -} - -// =================================================================== - -class PendingKeyExchange::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_sequence(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static void set_has_localbasekey(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_localbasekeyprivate(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_localratchetkey(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_localratchetkeyprivate(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_localidentitykey(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_localidentitykeyprivate(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } -}; - -PendingKeyExchange::PendingKeyExchange(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.PendingKeyExchange) -} -PendingKeyExchange::PendingKeyExchange(const PendingKeyExchange& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - PendingKeyExchange* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.localbasekey_){} - , decltype(_impl_.localbasekeyprivate_){} - , decltype(_impl_.localratchetkey_){} - , decltype(_impl_.localratchetkeyprivate_){} - , decltype(_impl_.localidentitykey_){} - , decltype(_impl_.localidentitykeyprivate_){} - , decltype(_impl_.sequence_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.localbasekey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.localbasekey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_localbasekey()) { - _this->_impl_.localbasekey_.Set(from._internal_localbasekey(), - _this->GetArenaForAllocation()); - } - _impl_.localbasekeyprivate_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.localbasekeyprivate_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_localbasekeyprivate()) { - _this->_impl_.localbasekeyprivate_.Set(from._internal_localbasekeyprivate(), - _this->GetArenaForAllocation()); - } - _impl_.localratchetkey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.localratchetkey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_localratchetkey()) { - _this->_impl_.localratchetkey_.Set(from._internal_localratchetkey(), - _this->GetArenaForAllocation()); - } - _impl_.localratchetkeyprivate_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.localratchetkeyprivate_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_localratchetkeyprivate()) { - _this->_impl_.localratchetkeyprivate_.Set(from._internal_localratchetkeyprivate(), - _this->GetArenaForAllocation()); - } - _impl_.localidentitykey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.localidentitykey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_localidentitykey()) { - _this->_impl_.localidentitykey_.Set(from._internal_localidentitykey(), - _this->GetArenaForAllocation()); - } - _impl_.localidentitykeyprivate_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.localidentitykeyprivate_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_localidentitykeyprivate()) { - _this->_impl_.localidentitykeyprivate_.Set(from._internal_localidentitykeyprivate(), - _this->GetArenaForAllocation()); - } - _this->_impl_.sequence_ = from._impl_.sequence_; - // @@protoc_insertion_point(copy_constructor:proto.PendingKeyExchange) -} - -inline void PendingKeyExchange::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.localbasekey_){} - , decltype(_impl_.localbasekeyprivate_){} - , decltype(_impl_.localratchetkey_){} - , decltype(_impl_.localratchetkeyprivate_){} - , decltype(_impl_.localidentitykey_){} - , decltype(_impl_.localidentitykeyprivate_){} - , decltype(_impl_.sequence_){0u} - }; - _impl_.localbasekey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.localbasekey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.localbasekeyprivate_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.localbasekeyprivate_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.localratchetkey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.localratchetkey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.localratchetkeyprivate_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.localratchetkeyprivate_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.localidentitykey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.localidentitykey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.localidentitykeyprivate_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.localidentitykeyprivate_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -PendingKeyExchange::~PendingKeyExchange() { - // @@protoc_insertion_point(destructor:proto.PendingKeyExchange) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void PendingKeyExchange::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.localbasekey_.Destroy(); - _impl_.localbasekeyprivate_.Destroy(); - _impl_.localratchetkey_.Destroy(); - _impl_.localratchetkeyprivate_.Destroy(); - _impl_.localidentitykey_.Destroy(); - _impl_.localidentitykeyprivate_.Destroy(); -} - -void PendingKeyExchange::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void PendingKeyExchange::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.PendingKeyExchange) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000003fu) { - if (cached_has_bits & 0x00000001u) { - _impl_.localbasekey_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.localbasekeyprivate_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.localratchetkey_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000008u) { - _impl_.localratchetkeyprivate_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000010u) { - _impl_.localidentitykey_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000020u) { - _impl_.localidentitykeyprivate_.ClearNonDefaultToEmpty(); - } - } - _impl_.sequence_ = 0u; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* PendingKeyExchange::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional uint32 sequence = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_sequence(&has_bits); - _impl_.sequence_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes localBaseKey = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_localbasekey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes localBaseKeyPrivate = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_localbasekeyprivate(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes localRatchetKey = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - auto str = _internal_mutable_localratchetkey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes localRatchetKeyPrivate = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - auto str = _internal_mutable_localratchetkeyprivate(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes localIdentityKey = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - auto str = _internal_mutable_localidentitykey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes localIdentityKeyPrivate = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { - auto str = _internal_mutable_localidentitykeyprivate(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* PendingKeyExchange::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.PendingKeyExchange) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional uint32 sequence = 1; - if (cached_has_bits & 0x00000040u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_sequence(), target); - } - - // optional bytes localBaseKey = 2; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_localbasekey(), target); - } - - // optional bytes localBaseKeyPrivate = 3; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 3, this->_internal_localbasekeyprivate(), target); - } - - // optional bytes localRatchetKey = 4; - if (cached_has_bits & 0x00000004u) { - target = stream->WriteBytesMaybeAliased( - 4, this->_internal_localratchetkey(), target); - } - - // optional bytes localRatchetKeyPrivate = 5; - if (cached_has_bits & 0x00000008u) { - target = stream->WriteBytesMaybeAliased( - 5, this->_internal_localratchetkeyprivate(), target); - } - - // optional bytes localIdentityKey = 7; - if (cached_has_bits & 0x00000010u) { - target = stream->WriteBytesMaybeAliased( - 7, this->_internal_localidentitykey(), target); - } - - // optional bytes localIdentityKeyPrivate = 8; - if (cached_has_bits & 0x00000020u) { - target = stream->WriteBytesMaybeAliased( - 8, this->_internal_localidentitykeyprivate(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.PendingKeyExchange) - return target; -} - -size_t PendingKeyExchange::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.PendingKeyExchange) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000007fu) { - // optional bytes localBaseKey = 2; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_localbasekey()); - } - - // optional bytes localBaseKeyPrivate = 3; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_localbasekeyprivate()); - } - - // optional bytes localRatchetKey = 4; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_localratchetkey()); - } - - // optional bytes localRatchetKeyPrivate = 5; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_localratchetkeyprivate()); - } - - // optional bytes localIdentityKey = 7; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_localidentitykey()); - } - - // optional bytes localIdentityKeyPrivate = 8; - if (cached_has_bits & 0x00000020u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_localidentitykeyprivate()); - } - - // optional uint32 sequence = 1; - if (cached_has_bits & 0x00000040u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_sequence()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PendingKeyExchange::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - PendingKeyExchange::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PendingKeyExchange::GetClassData() const { return &_class_data_; } - - -void PendingKeyExchange::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.PendingKeyExchange) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000007fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_localbasekey(from._internal_localbasekey()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_localbasekeyprivate(from._internal_localbasekeyprivate()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_localratchetkey(from._internal_localratchetkey()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_set_localratchetkeyprivate(from._internal_localratchetkeyprivate()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_set_localidentitykey(from._internal_localidentitykey()); - } - if (cached_has_bits & 0x00000020u) { - _this->_internal_set_localidentitykeyprivate(from._internal_localidentitykeyprivate()); - } - if (cached_has_bits & 0x00000040u) { - _this->_impl_.sequence_ = from._impl_.sequence_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void PendingKeyExchange::CopyFrom(const PendingKeyExchange& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.PendingKeyExchange) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool PendingKeyExchange::IsInitialized() const { - return true; -} - -void PendingKeyExchange::InternalSwap(PendingKeyExchange* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.localbasekey_, lhs_arena, - &other->_impl_.localbasekey_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.localbasekeyprivate_, lhs_arena, - &other->_impl_.localbasekeyprivate_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.localratchetkey_, lhs_arena, - &other->_impl_.localratchetkey_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.localratchetkeyprivate_, lhs_arena, - &other->_impl_.localratchetkeyprivate_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.localidentitykey_, lhs_arena, - &other->_impl_.localidentitykey_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.localidentitykeyprivate_, lhs_arena, - &other->_impl_.localidentitykeyprivate_, rhs_arena - ); - swap(_impl_.sequence_, other->_impl_.sequence_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata PendingKeyExchange::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[152]); -} - -// =================================================================== - -class PendingPreKey::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_prekeyid(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_signedprekeyid(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_basekey(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -PendingPreKey::PendingPreKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.PendingPreKey) -} -PendingPreKey::PendingPreKey(const PendingPreKey& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - PendingPreKey* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.basekey_){} - , decltype(_impl_.prekeyid_){} - , decltype(_impl_.signedprekeyid_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.basekey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.basekey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_basekey()) { - _this->_impl_.basekey_.Set(from._internal_basekey(), - _this->GetArenaForAllocation()); - } - ::memcpy(&_impl_.prekeyid_, &from._impl_.prekeyid_, - static_cast(reinterpret_cast(&_impl_.signedprekeyid_) - - reinterpret_cast(&_impl_.prekeyid_)) + sizeof(_impl_.signedprekeyid_)); - // @@protoc_insertion_point(copy_constructor:proto.PendingPreKey) -} - -inline void PendingPreKey::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.basekey_){} - , decltype(_impl_.prekeyid_){0u} - , decltype(_impl_.signedprekeyid_){0} - }; - _impl_.basekey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.basekey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -PendingPreKey::~PendingPreKey() { - // @@protoc_insertion_point(destructor:proto.PendingPreKey) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void PendingPreKey::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.basekey_.Destroy(); -} - -void PendingPreKey::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void PendingPreKey::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.PendingPreKey) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.basekey_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000006u) { - ::memset(&_impl_.prekeyid_, 0, static_cast( - reinterpret_cast(&_impl_.signedprekeyid_) - - reinterpret_cast(&_impl_.prekeyid_)) + sizeof(_impl_.signedprekeyid_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* PendingPreKey::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional uint32 preKeyId = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_prekeyid(&has_bits); - _impl_.prekeyid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes baseKey = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_basekey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional int32 signedPreKeyId = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_signedprekeyid(&has_bits); - _impl_.signedprekeyid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* PendingPreKey::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.PendingPreKey) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional uint32 preKeyId = 1; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_prekeyid(), target); - } - - // optional bytes baseKey = 2; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_basekey(), target); - } - - // optional int32 signedPreKeyId = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_signedprekeyid(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.PendingPreKey) - return target; -} - -size_t PendingPreKey::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.PendingPreKey) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional bytes baseKey = 2; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_basekey()); - } - - // optional uint32 preKeyId = 1; - if (cached_has_bits & 0x00000002u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_prekeyid()); - } - - // optional int32 signedPreKeyId = 3; - if (cached_has_bits & 0x00000004u) { - total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_signedprekeyid()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PendingPreKey::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - PendingPreKey::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PendingPreKey::GetClassData() const { return &_class_data_; } - - -void PendingPreKey::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.PendingPreKey) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_basekey(from._internal_basekey()); - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.prekeyid_ = from._impl_.prekeyid_; - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.signedprekeyid_ = from._impl_.signedprekeyid_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void PendingPreKey::CopyFrom(const PendingPreKey& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.PendingPreKey) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool PendingPreKey::IsInitialized() const { - return true; -} - -void PendingPreKey::InternalSwap(PendingPreKey* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.basekey_, lhs_arena, - &other->_impl_.basekey_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(PendingPreKey, _impl_.signedprekeyid_) - + sizeof(PendingPreKey::_impl_.signedprekeyid_) - - PROTOBUF_FIELD_OFFSET(PendingPreKey, _impl_.prekeyid_)>( - reinterpret_cast(&_impl_.prekeyid_), - reinterpret_cast(&other->_impl_.prekeyid_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata PendingPreKey::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[153]); -} - -// =================================================================== - -class PhotoChange::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_oldphoto(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_newphoto(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_newphotoid(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } -}; - -PhotoChange::PhotoChange(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.PhotoChange) -} -PhotoChange::PhotoChange(const PhotoChange& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - PhotoChange* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.oldphoto_){} - , decltype(_impl_.newphoto_){} - , decltype(_impl_.newphotoid_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.oldphoto_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.oldphoto_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_oldphoto()) { - _this->_impl_.oldphoto_.Set(from._internal_oldphoto(), - _this->GetArenaForAllocation()); - } - _impl_.newphoto_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.newphoto_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_newphoto()) { - _this->_impl_.newphoto_.Set(from._internal_newphoto(), - _this->GetArenaForAllocation()); - } - _this->_impl_.newphotoid_ = from._impl_.newphotoid_; - // @@protoc_insertion_point(copy_constructor:proto.PhotoChange) -} - -inline void PhotoChange::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.oldphoto_){} - , decltype(_impl_.newphoto_){} - , decltype(_impl_.newphotoid_){0u} - }; - _impl_.oldphoto_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.oldphoto_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.newphoto_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.newphoto_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -PhotoChange::~PhotoChange() { - // @@protoc_insertion_point(destructor:proto.PhotoChange) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void PhotoChange::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.oldphoto_.Destroy(); - _impl_.newphoto_.Destroy(); -} - -void PhotoChange::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void PhotoChange::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.PhotoChange) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.oldphoto_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.newphoto_.ClearNonDefaultToEmpty(); - } - } - _impl_.newphotoid_ = 0u; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* PhotoChange::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bytes oldPhoto = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_oldphoto(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes newPhoto = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_newphoto(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 newPhotoId = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_newphotoid(&has_bits); - _impl_.newphotoid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* PhotoChange::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.PhotoChange) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bytes oldPhoto = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 1, this->_internal_oldphoto(), target); - } - - // optional bytes newPhoto = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_newphoto(), target); - } - - // optional uint32 newPhotoId = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_newphotoid(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.PhotoChange) - return target; -} - -size_t PhotoChange::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.PhotoChange) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional bytes oldPhoto = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_oldphoto()); - } - - // optional bytes newPhoto = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_newphoto()); - } - - // optional uint32 newPhotoId = 3; - if (cached_has_bits & 0x00000004u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_newphotoid()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PhotoChange::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - PhotoChange::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PhotoChange::GetClassData() const { return &_class_data_; } - - -void PhotoChange::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.PhotoChange) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_oldphoto(from._internal_oldphoto()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_newphoto(from._internal_newphoto()); - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.newphotoid_ = from._impl_.newphotoid_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void PhotoChange::CopyFrom(const PhotoChange& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.PhotoChange) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool PhotoChange::IsInitialized() const { - return true; -} - -void PhotoChange::InternalSwap(PhotoChange* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.oldphoto_, lhs_arena, - &other->_impl_.oldphoto_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.newphoto_, lhs_arena, - &other->_impl_.newphoto_, rhs_arena - ); - swap(_impl_.newphotoid_, other->_impl_.newphotoid_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata PhotoChange::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[154]); -} - -// =================================================================== - -class Point::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_xdeprecated(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_ydeprecated(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_x(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_y(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } -}; - -Point::Point(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Point) -} -Point::Point(const Point& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Point* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.xdeprecated_){} - , decltype(_impl_.ydeprecated_){} - , decltype(_impl_.x_){} - , decltype(_impl_.y_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&_impl_.xdeprecated_, &from._impl_.xdeprecated_, - static_cast(reinterpret_cast(&_impl_.y_) - - reinterpret_cast(&_impl_.xdeprecated_)) + sizeof(_impl_.y_)); - // @@protoc_insertion_point(copy_constructor:proto.Point) -} - -inline void Point::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.xdeprecated_){0} - , decltype(_impl_.ydeprecated_){0} - , decltype(_impl_.x_){0} - , decltype(_impl_.y_){0} - }; -} - -Point::~Point() { - // @@protoc_insertion_point(destructor:proto.Point) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Point::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Point::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Point::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Point) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - ::memset(&_impl_.xdeprecated_, 0, static_cast( - reinterpret_cast(&_impl_.y_) - - reinterpret_cast(&_impl_.xdeprecated_)) + sizeof(_impl_.y_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Point::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional int32 xDeprecated = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_xdeprecated(&has_bits); - _impl_.xdeprecated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional int32 yDeprecated = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_ydeprecated(&has_bits); - _impl_.ydeprecated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional double x = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 25)) { - _Internal::set_has_x(&has_bits); - _impl_.x_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); - ptr += sizeof(double); - } else - goto handle_unusual; - continue; - // optional double y = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 33)) { - _Internal::set_has_y(&has_bits); - _impl_.y_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); - ptr += sizeof(double); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Point::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Point) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional int32 xDeprecated = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_xdeprecated(), target); - } - - // optional int32 yDeprecated = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_ydeprecated(), target); - } - - // optional double x = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteDoubleToArray(3, this->_internal_x(), target); - } - - // optional double y = 4; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteDoubleToArray(4, this->_internal_y(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Point) - return target; -} - -size_t Point::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Point) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - // optional int32 xDeprecated = 1; - if (cached_has_bits & 0x00000001u) { - total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_xdeprecated()); - } - - // optional int32 yDeprecated = 2; - if (cached_has_bits & 0x00000002u) { - total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_ydeprecated()); - } - - // optional double x = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + 8; - } - - // optional double y = 4; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + 8; - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Point::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Point::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Point::GetClassData() const { return &_class_data_; } - - -void Point::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Point) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - if (cached_has_bits & 0x00000001u) { - _this->_impl_.xdeprecated_ = from._impl_.xdeprecated_; - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.ydeprecated_ = from._impl_.ydeprecated_; - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.x_ = from._impl_.x_; - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.y_ = from._impl_.y_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Point::CopyFrom(const Point& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Point) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Point::IsInitialized() const { - return true; -} - -void Point::InternalSwap(Point* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Point, _impl_.y_) - + sizeof(Point::_impl_.y_) - - PROTOBUF_FIELD_OFFSET(Point, _impl_.xdeprecated_)>( - reinterpret_cast(&_impl_.xdeprecated_), - reinterpret_cast(&other->_impl_.xdeprecated_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Point::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[155]); -} - -// =================================================================== - -class PollAdditionalMetadata::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_pollinvalidated(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -PollAdditionalMetadata::PollAdditionalMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.PollAdditionalMetadata) -} -PollAdditionalMetadata::PollAdditionalMetadata(const PollAdditionalMetadata& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - PollAdditionalMetadata* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.pollinvalidated_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _this->_impl_.pollinvalidated_ = from._impl_.pollinvalidated_; - // @@protoc_insertion_point(copy_constructor:proto.PollAdditionalMetadata) -} - -inline void PollAdditionalMetadata::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.pollinvalidated_){false} - }; -} - -PollAdditionalMetadata::~PollAdditionalMetadata() { - // @@protoc_insertion_point(destructor:proto.PollAdditionalMetadata) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void PollAdditionalMetadata::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void PollAdditionalMetadata::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void PollAdditionalMetadata::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.PollAdditionalMetadata) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.pollinvalidated_ = false; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* PollAdditionalMetadata::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bool pollInvalidated = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_pollinvalidated(&has_bits); - _impl_.pollinvalidated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* PollAdditionalMetadata::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.PollAdditionalMetadata) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bool pollInvalidated = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_pollinvalidated(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.PollAdditionalMetadata) - return target; -} - -size_t PollAdditionalMetadata::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.PollAdditionalMetadata) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional bool pollInvalidated = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + 1; - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PollAdditionalMetadata::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - PollAdditionalMetadata::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PollAdditionalMetadata::GetClassData() const { return &_class_data_; } - - -void PollAdditionalMetadata::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.PollAdditionalMetadata) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_pollinvalidated()) { - _this->_internal_set_pollinvalidated(from._internal_pollinvalidated()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void PollAdditionalMetadata::CopyFrom(const PollAdditionalMetadata& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.PollAdditionalMetadata) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool PollAdditionalMetadata::IsInitialized() const { - return true; -} - -void PollAdditionalMetadata::InternalSwap(PollAdditionalMetadata* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - swap(_impl_.pollinvalidated_, other->_impl_.pollinvalidated_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata PollAdditionalMetadata::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[156]); -} - -// =================================================================== - -class PollEncValue::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_encpayload(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_enciv(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -PollEncValue::PollEncValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.PollEncValue) -} -PollEncValue::PollEncValue(const PollEncValue& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - PollEncValue* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.encpayload_){} - , decltype(_impl_.enciv_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.encpayload_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.encpayload_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_encpayload()) { - _this->_impl_.encpayload_.Set(from._internal_encpayload(), - _this->GetArenaForAllocation()); - } - _impl_.enciv_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.enciv_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_enciv()) { - _this->_impl_.enciv_.Set(from._internal_enciv(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.PollEncValue) -} - -inline void PollEncValue::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.encpayload_){} - , decltype(_impl_.enciv_){} - }; - _impl_.encpayload_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.encpayload_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.enciv_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.enciv_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -PollEncValue::~PollEncValue() { - // @@protoc_insertion_point(destructor:proto.PollEncValue) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void PollEncValue::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.encpayload_.Destroy(); - _impl_.enciv_.Destroy(); -} - -void PollEncValue::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void PollEncValue::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.PollEncValue) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.encpayload_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.enciv_.ClearNonDefaultToEmpty(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* PollEncValue::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bytes encPayload = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_encpayload(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes encIv = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_enciv(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* PollEncValue::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.PollEncValue) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bytes encPayload = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 1, this->_internal_encpayload(), target); - } - - // optional bytes encIv = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_enciv(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.PollEncValue) - return target; -} - -size_t PollEncValue::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.PollEncValue) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional bytes encPayload = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_encpayload()); - } - - // optional bytes encIv = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_enciv()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PollEncValue::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - PollEncValue::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PollEncValue::GetClassData() const { return &_class_data_; } - - -void PollEncValue::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.PollEncValue) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_encpayload(from._internal_encpayload()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_enciv(from._internal_enciv()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void PollEncValue::CopyFrom(const PollEncValue& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.PollEncValue) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool PollEncValue::IsInitialized() const { - return true; -} - -void PollEncValue::InternalSwap(PollEncValue* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.encpayload_, lhs_arena, - &other->_impl_.encpayload_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.enciv_, lhs_arena, - &other->_impl_.enciv_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata PollEncValue::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[157]); -} - -// =================================================================== - -class PollUpdate::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::MessageKey& pollupdatemessagekey(const PollUpdate* msg); - static void set_has_pollupdatemessagekey(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::proto::Message_PollVoteMessage& vote(const PollUpdate* msg); - static void set_has_vote(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_sendertimestampms(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } -}; - -const ::proto::MessageKey& -PollUpdate::_Internal::pollupdatemessagekey(const PollUpdate* msg) { - return *msg->_impl_.pollupdatemessagekey_; -} -const ::proto::Message_PollVoteMessage& -PollUpdate::_Internal::vote(const PollUpdate* msg) { - return *msg->_impl_.vote_; -} -PollUpdate::PollUpdate(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.PollUpdate) -} -PollUpdate::PollUpdate(const PollUpdate& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - PollUpdate* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.pollupdatemessagekey_){nullptr} - , decltype(_impl_.vote_){nullptr} - , decltype(_impl_.sendertimestampms_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_pollupdatemessagekey()) { - _this->_impl_.pollupdatemessagekey_ = new ::proto::MessageKey(*from._impl_.pollupdatemessagekey_); - } - if (from._internal_has_vote()) { - _this->_impl_.vote_ = new ::proto::Message_PollVoteMessage(*from._impl_.vote_); - } - _this->_impl_.sendertimestampms_ = from._impl_.sendertimestampms_; - // @@protoc_insertion_point(copy_constructor:proto.PollUpdate) -} - -inline void PollUpdate::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.pollupdatemessagekey_){nullptr} - , decltype(_impl_.vote_){nullptr} - , decltype(_impl_.sendertimestampms_){int64_t{0}} - }; -} - -PollUpdate::~PollUpdate() { - // @@protoc_insertion_point(destructor:proto.PollUpdate) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void PollUpdate::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete _impl_.pollupdatemessagekey_; - if (this != internal_default_instance()) delete _impl_.vote_; -} - -void PollUpdate::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void PollUpdate::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.PollUpdate) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.pollupdatemessagekey_ != nullptr); - _impl_.pollupdatemessagekey_->Clear(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.vote_ != nullptr); - _impl_.vote_->Clear(); - } - } - _impl_.sendertimestampms_ = int64_t{0}; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* PollUpdate::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.MessageKey pollUpdateMessageKey = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_pollupdatemessagekey(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.PollVoteMessage vote = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_vote(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional int64 senderTimestampMs = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_sendertimestampms(&has_bits); - _impl_.sendertimestampms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* PollUpdate::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.PollUpdate) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.MessageKey pollUpdateMessageKey = 1; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::pollupdatemessagekey(this), - _Internal::pollupdatemessagekey(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.PollVoteMessage vote = 2; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::vote(this), - _Internal::vote(this).GetCachedSize(), target, stream); - } - - // optional int64 senderTimestampMs = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_sendertimestampms(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.PollUpdate) - return target; -} - -size_t PollUpdate::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.PollUpdate) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional .proto.MessageKey pollUpdateMessageKey = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.pollupdatemessagekey_); - } - - // optional .proto.Message.PollVoteMessage vote = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.vote_); - } - - // optional int64 senderTimestampMs = 3; - if (cached_has_bits & 0x00000004u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_sendertimestampms()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PollUpdate::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - PollUpdate::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PollUpdate::GetClassData() const { return &_class_data_; } - - -void PollUpdate::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.PollUpdate) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_mutable_pollupdatemessagekey()->::proto::MessageKey::MergeFrom( - from._internal_pollupdatemessagekey()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_vote()->::proto::Message_PollVoteMessage::MergeFrom( - from._internal_vote()); - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.sendertimestampms_ = from._impl_.sendertimestampms_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void PollUpdate::CopyFrom(const PollUpdate& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.PollUpdate) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool PollUpdate::IsInitialized() const { - return true; -} - -void PollUpdate::InternalSwap(PollUpdate* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(PollUpdate, _impl_.sendertimestampms_) - + sizeof(PollUpdate::_impl_.sendertimestampms_) - - PROTOBUF_FIELD_OFFSET(PollUpdate, _impl_.pollupdatemessagekey_)>( - reinterpret_cast(&_impl_.pollupdatemessagekey_), - reinterpret_cast(&other->_impl_.pollupdatemessagekey_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata PollUpdate::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[158]); -} - -// =================================================================== - -class PreKeyRecordStructure::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_id(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_publickey(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_privatekey(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -PreKeyRecordStructure::PreKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.PreKeyRecordStructure) -} -PreKeyRecordStructure::PreKeyRecordStructure(const PreKeyRecordStructure& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - PreKeyRecordStructure* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.publickey_){} - , decltype(_impl_.privatekey_){} - , decltype(_impl_.id_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.publickey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.publickey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_publickey()) { - _this->_impl_.publickey_.Set(from._internal_publickey(), - _this->GetArenaForAllocation()); - } - _impl_.privatekey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.privatekey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_privatekey()) { - _this->_impl_.privatekey_.Set(from._internal_privatekey(), - _this->GetArenaForAllocation()); - } - _this->_impl_.id_ = from._impl_.id_; - // @@protoc_insertion_point(copy_constructor:proto.PreKeyRecordStructure) -} - -inline void PreKeyRecordStructure::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.publickey_){} - , decltype(_impl_.privatekey_){} - , decltype(_impl_.id_){0u} - }; - _impl_.publickey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.publickey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.privatekey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.privatekey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -PreKeyRecordStructure::~PreKeyRecordStructure() { - // @@protoc_insertion_point(destructor:proto.PreKeyRecordStructure) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void PreKeyRecordStructure::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.publickey_.Destroy(); - _impl_.privatekey_.Destroy(); -} - -void PreKeyRecordStructure::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void PreKeyRecordStructure::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.PreKeyRecordStructure) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.publickey_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.privatekey_.ClearNonDefaultToEmpty(); - } - } - _impl_.id_ = 0u; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* PreKeyRecordStructure::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional uint32 id = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_id(&has_bits); - _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes publicKey = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_publickey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes privateKey = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_privatekey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* PreKeyRecordStructure::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.PreKeyRecordStructure) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional uint32 id = 1; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_id(), target); - } - - // optional bytes publicKey = 2; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_publickey(), target); - } - - // optional bytes privateKey = 3; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 3, this->_internal_privatekey(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.PreKeyRecordStructure) - return target; -} - -size_t PreKeyRecordStructure::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.PreKeyRecordStructure) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional bytes publicKey = 2; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_publickey()); - } - - // optional bytes privateKey = 3; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_privatekey()); - } - - // optional uint32 id = 1; - if (cached_has_bits & 0x00000004u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_id()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PreKeyRecordStructure::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - PreKeyRecordStructure::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PreKeyRecordStructure::GetClassData() const { return &_class_data_; } - - -void PreKeyRecordStructure::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.PreKeyRecordStructure) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_publickey(from._internal_publickey()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_privatekey(from._internal_privatekey()); - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.id_ = from._impl_.id_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void PreKeyRecordStructure::CopyFrom(const PreKeyRecordStructure& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.PreKeyRecordStructure) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool PreKeyRecordStructure::IsInitialized() const { - return true; -} - -void PreKeyRecordStructure::InternalSwap(PreKeyRecordStructure* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.publickey_, lhs_arena, - &other->_impl_.publickey_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.privatekey_, lhs_arena, - &other->_impl_.privatekey_, rhs_arena - ); - swap(_impl_.id_, other->_impl_.id_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata PreKeyRecordStructure::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[159]); -} - -// =================================================================== - -class Pushname::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_id(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_pushname(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -Pushname::Pushname(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Pushname) -} -Pushname::Pushname(const Pushname& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Pushname* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.id_){} - , decltype(_impl_.pushname_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.id_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.id_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_id()) { - _this->_impl_.id_.Set(from._internal_id(), - _this->GetArenaForAllocation()); - } - _impl_.pushname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.pushname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_pushname()) { - _this->_impl_.pushname_.Set(from._internal_pushname(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.Pushname) -} - -inline void Pushname::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.id_){} - , decltype(_impl_.pushname_){} - }; - _impl_.id_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.id_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.pushname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.pushname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Pushname::~Pushname() { - // @@protoc_insertion_point(destructor:proto.Pushname) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Pushname::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.id_.Destroy(); - _impl_.pushname_.Destroy(); -} - -void Pushname::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Pushname::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Pushname) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.id_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.pushname_.ClearNonDefaultToEmpty(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Pushname::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string id = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_id(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Pushname.id"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string pushname = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_pushname(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Pushname.pushname"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Pushname::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Pushname) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string id = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_id().data(), static_cast(this->_internal_id().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Pushname.id"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_id(), target); - } - - // optional string pushname = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_pushname().data(), static_cast(this->_internal_pushname().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Pushname.pushname"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_pushname(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Pushname) - return target; -} - -size_t Pushname::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Pushname) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional string id = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_id()); - } - - // optional string pushname = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_pushname()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Pushname::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Pushname::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Pushname::GetClassData() const { return &_class_data_; } - - -void Pushname::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Pushname) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_id(from._internal_id()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_pushname(from._internal_pushname()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Pushname::CopyFrom(const Pushname& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Pushname) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Pushname::IsInitialized() const { - return true; -} - -void Pushname::InternalSwap(Pushname* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.id_, lhs_arena, - &other->_impl_.id_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.pushname_, lhs_arena, - &other->_impl_.pushname_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Pushname::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[160]); -} - -// =================================================================== - -class Reaction::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::MessageKey& key(const Reaction* msg); - static void set_has_key(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_text(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_groupingkey(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_sendertimestampms(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_unread(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } -}; - -const ::proto::MessageKey& -Reaction::_Internal::key(const Reaction* msg) { - return *msg->_impl_.key_; -} -Reaction::Reaction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.Reaction) -} -Reaction::Reaction(const Reaction& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - Reaction* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.text_){} - , decltype(_impl_.groupingkey_){} - , decltype(_impl_.key_){nullptr} - , decltype(_impl_.sendertimestampms_){} - , decltype(_impl_.unread_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.text_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.text_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_text()) { - _this->_impl_.text_.Set(from._internal_text(), - _this->GetArenaForAllocation()); - } - _impl_.groupingkey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.groupingkey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_groupingkey()) { - _this->_impl_.groupingkey_.Set(from._internal_groupingkey(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_key()) { - _this->_impl_.key_ = new ::proto::MessageKey(*from._impl_.key_); - } - ::memcpy(&_impl_.sendertimestampms_, &from._impl_.sendertimestampms_, - static_cast(reinterpret_cast(&_impl_.unread_) - - reinterpret_cast(&_impl_.sendertimestampms_)) + sizeof(_impl_.unread_)); - // @@protoc_insertion_point(copy_constructor:proto.Reaction) -} - -inline void Reaction::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.text_){} - , decltype(_impl_.groupingkey_){} - , decltype(_impl_.key_){nullptr} - , decltype(_impl_.sendertimestampms_){int64_t{0}} - , decltype(_impl_.unread_){false} - }; - _impl_.text_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.text_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.groupingkey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.groupingkey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Reaction::~Reaction() { - // @@protoc_insertion_point(destructor:proto.Reaction) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void Reaction::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.text_.Destroy(); - _impl_.groupingkey_.Destroy(); - if (this != internal_default_instance()) delete _impl_.key_; -} - -void Reaction::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void Reaction::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.Reaction) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _impl_.text_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.groupingkey_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - GOOGLE_DCHECK(_impl_.key_ != nullptr); - _impl_.key_->Clear(); - } - } - if (cached_has_bits & 0x00000018u) { - ::memset(&_impl_.sendertimestampms_, 0, static_cast( - reinterpret_cast(&_impl_.unread_) - - reinterpret_cast(&_impl_.sendertimestampms_)) + sizeof(_impl_.unread_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Reaction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.MessageKey key = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string text = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_text(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Reaction.text"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string groupingKey = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_groupingkey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.Reaction.groupingKey"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional int64 senderTimestampMs = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - _Internal::set_has_sendertimestampms(&has_bits); - _impl_.sendertimestampms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool unread = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { - _Internal::set_has_unread(&has_bits); - _impl_.unread_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Reaction::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.Reaction) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.MessageKey key = 1; - if (cached_has_bits & 0x00000004u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::key(this), - _Internal::key(this).GetCachedSize(), target, stream); - } - - // optional string text = 2; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_text().data(), static_cast(this->_internal_text().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Reaction.text"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_text(), target); - } - - // optional string groupingKey = 3; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_groupingkey().data(), static_cast(this->_internal_groupingkey().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.Reaction.groupingKey"); - target = stream->WriteStringMaybeAliased( - 3, this->_internal_groupingkey(), target); - } - - // optional int64 senderTimestampMs = 4; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_sendertimestampms(), target); - } - - // optional bool unread = 5; - if (cached_has_bits & 0x00000010u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(5, this->_internal_unread(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.Reaction) - return target; -} - -size_t Reaction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.Reaction) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { - // optional string text = 2; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_text()); - } - - // optional string groupingKey = 3; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_groupingkey()); - } - - // optional .proto.MessageKey key = 1; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.key_); - } - - // optional int64 senderTimestampMs = 4; - if (cached_has_bits & 0x00000008u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_sendertimestampms()); - } - - // optional bool unread = 5; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + 1; - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Reaction::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - Reaction::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Reaction::GetClassData() const { return &_class_data_; } - - -void Reaction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.Reaction) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_text(from._internal_text()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_groupingkey(from._internal_groupingkey()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_mutable_key()->::proto::MessageKey::MergeFrom( - from._internal_key()); - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.sendertimestampms_ = from._impl_.sendertimestampms_; - } - if (cached_has_bits & 0x00000010u) { - _this->_impl_.unread_ = from._impl_.unread_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Reaction::CopyFrom(const Reaction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.Reaction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Reaction::IsInitialized() const { - return true; -} - -void Reaction::InternalSwap(Reaction* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.text_, lhs_arena, - &other->_impl_.text_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.groupingkey_, lhs_arena, - &other->_impl_.groupingkey_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Reaction, _impl_.unread_) - + sizeof(Reaction::_impl_.unread_) - - PROTOBUF_FIELD_OFFSET(Reaction, _impl_.key_)>( - reinterpret_cast(&_impl_.key_), - reinterpret_cast(&other->_impl_.key_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Reaction::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[161]); -} - -// =================================================================== - -class RecentEmojiWeight::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_emoji(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_weight(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -RecentEmojiWeight::RecentEmojiWeight(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.RecentEmojiWeight) -} -RecentEmojiWeight::RecentEmojiWeight(const RecentEmojiWeight& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - RecentEmojiWeight* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.emoji_){} - , decltype(_impl_.weight_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.emoji_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.emoji_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_emoji()) { - _this->_impl_.emoji_.Set(from._internal_emoji(), - _this->GetArenaForAllocation()); - } - _this->_impl_.weight_ = from._impl_.weight_; - // @@protoc_insertion_point(copy_constructor:proto.RecentEmojiWeight) -} - -inline void RecentEmojiWeight::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.emoji_){} - , decltype(_impl_.weight_){0} - }; - _impl_.emoji_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.emoji_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -RecentEmojiWeight::~RecentEmojiWeight() { - // @@protoc_insertion_point(destructor:proto.RecentEmojiWeight) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void RecentEmojiWeight::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.emoji_.Destroy(); -} - -void RecentEmojiWeight::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void RecentEmojiWeight::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.RecentEmojiWeight) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.emoji_.ClearNonDefaultToEmpty(); - } - _impl_.weight_ = 0; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* RecentEmojiWeight::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string emoji = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_emoji(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.RecentEmojiWeight.emoji"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional float weight = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 21)) { - _Internal::set_has_weight(&has_bits); - _impl_.weight_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); - ptr += sizeof(float); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* RecentEmojiWeight::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.RecentEmojiWeight) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string emoji = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_emoji().data(), static_cast(this->_internal_emoji().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.RecentEmojiWeight.emoji"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_emoji(), target); - } - - // optional float weight = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteFloatToArray(2, this->_internal_weight(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.RecentEmojiWeight) - return target; -} - -size_t RecentEmojiWeight::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.RecentEmojiWeight) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional string emoji = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_emoji()); - } - - // optional float weight = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + 4; - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RecentEmojiWeight::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - RecentEmojiWeight::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RecentEmojiWeight::GetClassData() const { return &_class_data_; } - - -void RecentEmojiWeight::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.RecentEmojiWeight) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_emoji(from._internal_emoji()); - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.weight_ = from._impl_.weight_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void RecentEmojiWeight::CopyFrom(const RecentEmojiWeight& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.RecentEmojiWeight) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool RecentEmojiWeight::IsInitialized() const { - return true; -} - -void RecentEmojiWeight::InternalSwap(RecentEmojiWeight* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.emoji_, lhs_arena, - &other->_impl_.emoji_, rhs_arena - ); - swap(_impl_.weight_, other->_impl_.weight_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata RecentEmojiWeight::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[162]); -} - -// =================================================================== - -class RecordStructure::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::SessionStructure& currentsession(const RecordStructure* msg); - static void set_has_currentsession(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -const ::proto::SessionStructure& -RecordStructure::_Internal::currentsession(const RecordStructure* msg) { - return *msg->_impl_.currentsession_; -} -RecordStructure::RecordStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.RecordStructure) -} -RecordStructure::RecordStructure(const RecordStructure& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - RecordStructure* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.previoussessions_){from._impl_.previoussessions_} - , decltype(_impl_.currentsession_){nullptr}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_currentsession()) { - _this->_impl_.currentsession_ = new ::proto::SessionStructure(*from._impl_.currentsession_); - } - // @@protoc_insertion_point(copy_constructor:proto.RecordStructure) -} - -inline void RecordStructure::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.previoussessions_){arena} - , decltype(_impl_.currentsession_){nullptr} - }; -} - -RecordStructure::~RecordStructure() { - // @@protoc_insertion_point(destructor:proto.RecordStructure) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void RecordStructure::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.previoussessions_.~RepeatedPtrField(); - if (this != internal_default_instance()) delete _impl_.currentsession_; -} - -void RecordStructure::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void RecordStructure::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.RecordStructure) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.previoussessions_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.currentsession_ != nullptr); - _impl_.currentsession_->Clear(); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* RecordStructure::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.SessionStructure currentSession = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_currentsession(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated .proto.SessionStructure previousSessions = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_previoussessions(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* RecordStructure::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.RecordStructure) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.SessionStructure currentSession = 1; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::currentsession(this), - _Internal::currentsession(this).GetCachedSize(), target, stream); - } - - // repeated .proto.SessionStructure previousSessions = 2; - for (unsigned i = 0, - n = static_cast(this->_internal_previoussessions_size()); i < n; i++) { - const auto& repfield = this->_internal_previoussessions(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.RecordStructure) - return target; -} - -size_t RecordStructure::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.RecordStructure) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.SessionStructure previousSessions = 2; - total_size += 1UL * this->_internal_previoussessions_size(); - for (const auto& msg : this->_impl_.previoussessions_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // optional .proto.SessionStructure currentSession = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.currentsession_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RecordStructure::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - RecordStructure::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RecordStructure::GetClassData() const { return &_class_data_; } - - -void RecordStructure::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.RecordStructure) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.previoussessions_.MergeFrom(from._impl_.previoussessions_); - if (from._internal_has_currentsession()) { - _this->_internal_mutable_currentsession()->::proto::SessionStructure::MergeFrom( - from._internal_currentsession()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void RecordStructure::CopyFrom(const RecordStructure& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.RecordStructure) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool RecordStructure::IsInitialized() const { - return true; -} - -void RecordStructure::InternalSwap(RecordStructure* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.previoussessions_.InternalSwap(&other->_impl_.previoussessions_); - swap(_impl_.currentsession_, other->_impl_.currentsession_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata RecordStructure::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[163]); -} - -// =================================================================== - -class SenderChainKey::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_iteration(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_seed(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -SenderChainKey::SenderChainKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SenderChainKey) -} -SenderChainKey::SenderChainKey(const SenderChainKey& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SenderChainKey* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.seed_){} - , decltype(_impl_.iteration_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.seed_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.seed_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_seed()) { - _this->_impl_.seed_.Set(from._internal_seed(), - _this->GetArenaForAllocation()); - } - _this->_impl_.iteration_ = from._impl_.iteration_; - // @@protoc_insertion_point(copy_constructor:proto.SenderChainKey) -} - -inline void SenderChainKey::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.seed_){} - , decltype(_impl_.iteration_){0u} - }; - _impl_.seed_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.seed_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -SenderChainKey::~SenderChainKey() { - // @@protoc_insertion_point(destructor:proto.SenderChainKey) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SenderChainKey::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.seed_.Destroy(); -} - -void SenderChainKey::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SenderChainKey::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SenderChainKey) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.seed_.ClearNonDefaultToEmpty(); - } - _impl_.iteration_ = 0u; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SenderChainKey::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional uint32 iteration = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_iteration(&has_bits); - _impl_.iteration_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes seed = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_seed(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SenderChainKey::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SenderChainKey) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional uint32 iteration = 1; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_iteration(), target); - } - - // optional bytes seed = 2; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_seed(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SenderChainKey) - return target; -} - -size_t SenderChainKey::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SenderChainKey) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional bytes seed = 2; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_seed()); - } - - // optional uint32 iteration = 1; - if (cached_has_bits & 0x00000002u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_iteration()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SenderChainKey::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SenderChainKey::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SenderChainKey::GetClassData() const { return &_class_data_; } - - -void SenderChainKey::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SenderChainKey) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_seed(from._internal_seed()); - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.iteration_ = from._impl_.iteration_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SenderChainKey::CopyFrom(const SenderChainKey& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SenderChainKey) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SenderChainKey::IsInitialized() const { - return true; -} - -void SenderChainKey::InternalSwap(SenderChainKey* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.seed_, lhs_arena, - &other->_impl_.seed_, rhs_arena - ); - swap(_impl_.iteration_, other->_impl_.iteration_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SenderChainKey::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[164]); -} - -// =================================================================== - -class SenderKeyRecordStructure::_Internal { - public: -}; - -SenderKeyRecordStructure::SenderKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SenderKeyRecordStructure) -} -SenderKeyRecordStructure::SenderKeyRecordStructure(const SenderKeyRecordStructure& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SenderKeyRecordStructure* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_.senderkeystates_){from._impl_.senderkeystates_} - , /*decltype(_impl_._cached_size_)*/{}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:proto.SenderKeyRecordStructure) -} - -inline void SenderKeyRecordStructure::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_.senderkeystates_){arena} - , /*decltype(_impl_._cached_size_)*/{} - }; -} - -SenderKeyRecordStructure::~SenderKeyRecordStructure() { - // @@protoc_insertion_point(destructor:proto.SenderKeyRecordStructure) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SenderKeyRecordStructure::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.senderkeystates_.~RepeatedPtrField(); -} - -void SenderKeyRecordStructure::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SenderKeyRecordStructure::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SenderKeyRecordStructure) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.senderkeystates_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SenderKeyRecordStructure::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated .proto.SenderKeyStateStructure senderKeyStates = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_senderkeystates(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SenderKeyRecordStructure::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SenderKeyRecordStructure) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .proto.SenderKeyStateStructure senderKeyStates = 1; - for (unsigned i = 0, - n = static_cast(this->_internal_senderkeystates_size()); i < n; i++) { - const auto& repfield = this->_internal_senderkeystates(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SenderKeyRecordStructure) - return target; -} - -size_t SenderKeyRecordStructure::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SenderKeyRecordStructure) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.SenderKeyStateStructure senderKeyStates = 1; - total_size += 1UL * this->_internal_senderkeystates_size(); - for (const auto& msg : this->_impl_.senderkeystates_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SenderKeyRecordStructure::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SenderKeyRecordStructure::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SenderKeyRecordStructure::GetClassData() const { return &_class_data_; } - - -void SenderKeyRecordStructure::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SenderKeyRecordStructure) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.senderkeystates_.MergeFrom(from._impl_.senderkeystates_); - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SenderKeyRecordStructure::CopyFrom(const SenderKeyRecordStructure& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SenderKeyRecordStructure) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SenderKeyRecordStructure::IsInitialized() const { - return true; -} - -void SenderKeyRecordStructure::InternalSwap(SenderKeyRecordStructure* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - _impl_.senderkeystates_.InternalSwap(&other->_impl_.senderkeystates_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SenderKeyRecordStructure::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[165]); -} - -// =================================================================== - -class SenderKeyStateStructure::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_senderkeyid(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static const ::proto::SenderChainKey& senderchainkey(const SenderKeyStateStructure* msg); - static void set_has_senderchainkey(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::proto::SenderSigningKey& sendersigningkey(const SenderKeyStateStructure* msg); - static void set_has_sendersigningkey(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -const ::proto::SenderChainKey& -SenderKeyStateStructure::_Internal::senderchainkey(const SenderKeyStateStructure* msg) { - return *msg->_impl_.senderchainkey_; -} -const ::proto::SenderSigningKey& -SenderKeyStateStructure::_Internal::sendersigningkey(const SenderKeyStateStructure* msg) { - return *msg->_impl_.sendersigningkey_; -} -SenderKeyStateStructure::SenderKeyStateStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SenderKeyStateStructure) -} -SenderKeyStateStructure::SenderKeyStateStructure(const SenderKeyStateStructure& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SenderKeyStateStructure* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.sendermessagekeys_){from._impl_.sendermessagekeys_} - , decltype(_impl_.senderchainkey_){nullptr} - , decltype(_impl_.sendersigningkey_){nullptr} - , decltype(_impl_.senderkeyid_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_senderchainkey()) { - _this->_impl_.senderchainkey_ = new ::proto::SenderChainKey(*from._impl_.senderchainkey_); - } - if (from._internal_has_sendersigningkey()) { - _this->_impl_.sendersigningkey_ = new ::proto::SenderSigningKey(*from._impl_.sendersigningkey_); - } - _this->_impl_.senderkeyid_ = from._impl_.senderkeyid_; - // @@protoc_insertion_point(copy_constructor:proto.SenderKeyStateStructure) -} - -inline void SenderKeyStateStructure::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.sendermessagekeys_){arena} - , decltype(_impl_.senderchainkey_){nullptr} - , decltype(_impl_.sendersigningkey_){nullptr} - , decltype(_impl_.senderkeyid_){0u} - }; -} - -SenderKeyStateStructure::~SenderKeyStateStructure() { - // @@protoc_insertion_point(destructor:proto.SenderKeyStateStructure) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SenderKeyStateStructure::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.sendermessagekeys_.~RepeatedPtrField(); - if (this != internal_default_instance()) delete _impl_.senderchainkey_; - if (this != internal_default_instance()) delete _impl_.sendersigningkey_; -} - -void SenderKeyStateStructure::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SenderKeyStateStructure::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SenderKeyStateStructure) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.sendermessagekeys_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.senderchainkey_ != nullptr); - _impl_.senderchainkey_->Clear(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.sendersigningkey_ != nullptr); - _impl_.sendersigningkey_->Clear(); - } - } - _impl_.senderkeyid_ = 0u; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SenderKeyStateStructure::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional uint32 senderKeyId = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_senderkeyid(&has_bits); - _impl_.senderkeyid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SenderChainKey senderChainKey = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_senderchainkey(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SenderSigningKey senderSigningKey = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_sendersigningkey(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated .proto.SenderMessageKey senderMessageKeys = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_sendermessagekeys(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SenderKeyStateStructure::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SenderKeyStateStructure) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional uint32 senderKeyId = 1; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_senderkeyid(), target); - } - - // optional .proto.SenderChainKey senderChainKey = 2; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::senderchainkey(this), - _Internal::senderchainkey(this).GetCachedSize(), target, stream); - } - - // optional .proto.SenderSigningKey senderSigningKey = 3; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, _Internal::sendersigningkey(this), - _Internal::sendersigningkey(this).GetCachedSize(), target, stream); - } - - // repeated .proto.SenderMessageKey senderMessageKeys = 4; - for (unsigned i = 0, - n = static_cast(this->_internal_sendermessagekeys_size()); i < n; i++) { - const auto& repfield = this->_internal_sendermessagekeys(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(4, repfield, repfield.GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SenderKeyStateStructure) - return target; -} - -size_t SenderKeyStateStructure::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SenderKeyStateStructure) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.SenderMessageKey senderMessageKeys = 4; - total_size += 1UL * this->_internal_sendermessagekeys_size(); - for (const auto& msg : this->_impl_.sendermessagekeys_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional .proto.SenderChainKey senderChainKey = 2; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.senderchainkey_); - } - - // optional .proto.SenderSigningKey senderSigningKey = 3; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.sendersigningkey_); - } - - // optional uint32 senderKeyId = 1; - if (cached_has_bits & 0x00000004u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_senderkeyid()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SenderKeyStateStructure::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SenderKeyStateStructure::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SenderKeyStateStructure::GetClassData() const { return &_class_data_; } - - -void SenderKeyStateStructure::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SenderKeyStateStructure) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.sendermessagekeys_.MergeFrom(from._impl_.sendermessagekeys_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_mutable_senderchainkey()->::proto::SenderChainKey::MergeFrom( - from._internal_senderchainkey()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_sendersigningkey()->::proto::SenderSigningKey::MergeFrom( - from._internal_sendersigningkey()); - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.senderkeyid_ = from._impl_.senderkeyid_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SenderKeyStateStructure::CopyFrom(const SenderKeyStateStructure& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SenderKeyStateStructure) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SenderKeyStateStructure::IsInitialized() const { - return true; -} - -void SenderKeyStateStructure::InternalSwap(SenderKeyStateStructure* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.sendermessagekeys_.InternalSwap(&other->_impl_.sendermessagekeys_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SenderKeyStateStructure, _impl_.senderkeyid_) - + sizeof(SenderKeyStateStructure::_impl_.senderkeyid_) - - PROTOBUF_FIELD_OFFSET(SenderKeyStateStructure, _impl_.senderchainkey_)>( - reinterpret_cast(&_impl_.senderchainkey_), - reinterpret_cast(&other->_impl_.senderchainkey_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SenderKeyStateStructure::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[166]); -} - -// =================================================================== - -class SenderMessageKey::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_iteration(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_seed(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -SenderMessageKey::SenderMessageKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SenderMessageKey) -} -SenderMessageKey::SenderMessageKey(const SenderMessageKey& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SenderMessageKey* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.seed_){} - , decltype(_impl_.iteration_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.seed_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.seed_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_seed()) { - _this->_impl_.seed_.Set(from._internal_seed(), - _this->GetArenaForAllocation()); - } - _this->_impl_.iteration_ = from._impl_.iteration_; - // @@protoc_insertion_point(copy_constructor:proto.SenderMessageKey) -} - -inline void SenderMessageKey::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.seed_){} - , decltype(_impl_.iteration_){0u} - }; - _impl_.seed_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.seed_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -SenderMessageKey::~SenderMessageKey() { - // @@protoc_insertion_point(destructor:proto.SenderMessageKey) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SenderMessageKey::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.seed_.Destroy(); -} - -void SenderMessageKey::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SenderMessageKey::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SenderMessageKey) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.seed_.ClearNonDefaultToEmpty(); - } - _impl_.iteration_ = 0u; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SenderMessageKey::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional uint32 iteration = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_iteration(&has_bits); - _impl_.iteration_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes seed = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_seed(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SenderMessageKey::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SenderMessageKey) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional uint32 iteration = 1; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_iteration(), target); - } - - // optional bytes seed = 2; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_seed(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SenderMessageKey) - return target; -} - -size_t SenderMessageKey::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SenderMessageKey) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional bytes seed = 2; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_seed()); - } - - // optional uint32 iteration = 1; - if (cached_has_bits & 0x00000002u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_iteration()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SenderMessageKey::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SenderMessageKey::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SenderMessageKey::GetClassData() const { return &_class_data_; } - - -void SenderMessageKey::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SenderMessageKey) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_seed(from._internal_seed()); - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.iteration_ = from._impl_.iteration_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SenderMessageKey::CopyFrom(const SenderMessageKey& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SenderMessageKey) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SenderMessageKey::IsInitialized() const { - return true; -} - -void SenderMessageKey::InternalSwap(SenderMessageKey* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.seed_, lhs_arena, - &other->_impl_.seed_, rhs_arena - ); - swap(_impl_.iteration_, other->_impl_.iteration_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SenderMessageKey::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[167]); -} - -// =================================================================== - -class SenderSigningKey::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_public_(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_private_(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -SenderSigningKey::SenderSigningKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SenderSigningKey) -} -SenderSigningKey::SenderSigningKey(const SenderSigningKey& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SenderSigningKey* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.public__){} - , decltype(_impl_.private__){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.public__.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.public__.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_public_()) { - _this->_impl_.public__.Set(from._internal_public_(), - _this->GetArenaForAllocation()); - } - _impl_.private__.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.private__.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_private_()) { - _this->_impl_.private__.Set(from._internal_private_(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.SenderSigningKey) -} - -inline void SenderSigningKey::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.public__){} - , decltype(_impl_.private__){} - }; - _impl_.public__.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.public__.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.private__.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.private__.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -SenderSigningKey::~SenderSigningKey() { - // @@protoc_insertion_point(destructor:proto.SenderSigningKey) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SenderSigningKey::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.public__.Destroy(); - _impl_.private__.Destroy(); -} - -void SenderSigningKey::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SenderSigningKey::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SenderSigningKey) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.public__.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.private__.ClearNonDefaultToEmpty(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SenderSigningKey::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bytes public = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_public_(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes private = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_private_(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SenderSigningKey::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SenderSigningKey) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bytes public = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 1, this->_internal_public_(), target); - } - - // optional bytes private = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_private_(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SenderSigningKey) - return target; -} - -size_t SenderSigningKey::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SenderSigningKey) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional bytes public = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_public_()); - } - - // optional bytes private = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_private_()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SenderSigningKey::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SenderSigningKey::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SenderSigningKey::GetClassData() const { return &_class_data_; } - - -void SenderSigningKey::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SenderSigningKey) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_public_(from._internal_public_()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_private_(from._internal_private_()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SenderSigningKey::CopyFrom(const SenderSigningKey& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SenderSigningKey) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SenderSigningKey::IsInitialized() const { - return true; -} - -void SenderSigningKey::InternalSwap(SenderSigningKey* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.public__, lhs_arena, - &other->_impl_.public__, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.private__, lhs_arena, - &other->_impl_.private__, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SenderSigningKey::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[168]); -} - -// =================================================================== - -class ServerErrorReceipt::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_stanzaid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -ServerErrorReceipt::ServerErrorReceipt(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.ServerErrorReceipt) -} -ServerErrorReceipt::ServerErrorReceipt(const ServerErrorReceipt& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - ServerErrorReceipt* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.stanzaid_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.stanzaid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.stanzaid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_stanzaid()) { - _this->_impl_.stanzaid_.Set(from._internal_stanzaid(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.ServerErrorReceipt) -} - -inline void ServerErrorReceipt::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.stanzaid_){} - }; - _impl_.stanzaid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.stanzaid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -ServerErrorReceipt::~ServerErrorReceipt() { - // @@protoc_insertion_point(destructor:proto.ServerErrorReceipt) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void ServerErrorReceipt::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.stanzaid_.Destroy(); -} - -void ServerErrorReceipt::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void ServerErrorReceipt::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.ServerErrorReceipt) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.stanzaid_.ClearNonDefaultToEmpty(); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ServerErrorReceipt::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string stanzaId = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_stanzaid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.ServerErrorReceipt.stanzaId"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ServerErrorReceipt::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.ServerErrorReceipt) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string stanzaId = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_stanzaid().data(), static_cast(this->_internal_stanzaid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.ServerErrorReceipt.stanzaId"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_stanzaid(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.ServerErrorReceipt) - return target; -} - -size_t ServerErrorReceipt::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.ServerErrorReceipt) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional string stanzaId = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_stanzaid()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ServerErrorReceipt::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - ServerErrorReceipt::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ServerErrorReceipt::GetClassData() const { return &_class_data_; } - - -void ServerErrorReceipt::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.ServerErrorReceipt) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_stanzaid()) { - _this->_internal_set_stanzaid(from._internal_stanzaid()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ServerErrorReceipt::CopyFrom(const ServerErrorReceipt& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.ServerErrorReceipt) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ServerErrorReceipt::IsInitialized() const { - return true; -} - -void ServerErrorReceipt::InternalSwap(ServerErrorReceipt* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.stanzaid_, lhs_arena, - &other->_impl_.stanzaid_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ServerErrorReceipt::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[169]); -} - -// =================================================================== - -class SessionStructure::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_sessionversion(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } - static void set_has_localidentitypublic(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_remoteidentitypublic(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_rootkey(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_previouscounter(HasBits* has_bits) { - (*has_bits)[0] |= 256u; - } - static const ::proto::Chain& senderchain(const SessionStructure* msg); - static void set_has_senderchain(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static const ::proto::PendingKeyExchange& pendingkeyexchange(const SessionStructure* msg); - static void set_has_pendingkeyexchange(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static const ::proto::PendingPreKey& pendingprekey(const SessionStructure* msg); - static void set_has_pendingprekey(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static void set_has_remoteregistrationid(HasBits* has_bits) { - (*has_bits)[0] |= 512u; - } - static void set_has_localregistrationid(HasBits* has_bits) { - (*has_bits)[0] |= 1024u; - } - static void set_has_needsrefresh(HasBits* has_bits) { - (*has_bits)[0] |= 2048u; - } - static void set_has_alicebasekey(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } -}; - -const ::proto::Chain& -SessionStructure::_Internal::senderchain(const SessionStructure* msg) { - return *msg->_impl_.senderchain_; -} -const ::proto::PendingKeyExchange& -SessionStructure::_Internal::pendingkeyexchange(const SessionStructure* msg) { - return *msg->_impl_.pendingkeyexchange_; -} -const ::proto::PendingPreKey& -SessionStructure::_Internal::pendingprekey(const SessionStructure* msg) { - return *msg->_impl_.pendingprekey_; -} -SessionStructure::SessionStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SessionStructure) -} -SessionStructure::SessionStructure(const SessionStructure& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SessionStructure* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.receiverchains_){from._impl_.receiverchains_} - , decltype(_impl_.localidentitypublic_){} - , decltype(_impl_.remoteidentitypublic_){} - , decltype(_impl_.rootkey_){} - , decltype(_impl_.alicebasekey_){} - , decltype(_impl_.senderchain_){nullptr} - , decltype(_impl_.pendingkeyexchange_){nullptr} - , decltype(_impl_.pendingprekey_){nullptr} - , decltype(_impl_.sessionversion_){} - , decltype(_impl_.previouscounter_){} - , decltype(_impl_.remoteregistrationid_){} - , decltype(_impl_.localregistrationid_){} - , decltype(_impl_.needsrefresh_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.localidentitypublic_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.localidentitypublic_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_localidentitypublic()) { - _this->_impl_.localidentitypublic_.Set(from._internal_localidentitypublic(), - _this->GetArenaForAllocation()); - } - _impl_.remoteidentitypublic_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.remoteidentitypublic_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_remoteidentitypublic()) { - _this->_impl_.remoteidentitypublic_.Set(from._internal_remoteidentitypublic(), - _this->GetArenaForAllocation()); - } - _impl_.rootkey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.rootkey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_rootkey()) { - _this->_impl_.rootkey_.Set(from._internal_rootkey(), - _this->GetArenaForAllocation()); - } - _impl_.alicebasekey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.alicebasekey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_alicebasekey()) { - _this->_impl_.alicebasekey_.Set(from._internal_alicebasekey(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_senderchain()) { - _this->_impl_.senderchain_ = new ::proto::Chain(*from._impl_.senderchain_); - } - if (from._internal_has_pendingkeyexchange()) { - _this->_impl_.pendingkeyexchange_ = new ::proto::PendingKeyExchange(*from._impl_.pendingkeyexchange_); - } - if (from._internal_has_pendingprekey()) { - _this->_impl_.pendingprekey_ = new ::proto::PendingPreKey(*from._impl_.pendingprekey_); - } - ::memcpy(&_impl_.sessionversion_, &from._impl_.sessionversion_, - static_cast(reinterpret_cast(&_impl_.needsrefresh_) - - reinterpret_cast(&_impl_.sessionversion_)) + sizeof(_impl_.needsrefresh_)); - // @@protoc_insertion_point(copy_constructor:proto.SessionStructure) -} - -inline void SessionStructure::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.receiverchains_){arena} - , decltype(_impl_.localidentitypublic_){} - , decltype(_impl_.remoteidentitypublic_){} - , decltype(_impl_.rootkey_){} - , decltype(_impl_.alicebasekey_){} - , decltype(_impl_.senderchain_){nullptr} - , decltype(_impl_.pendingkeyexchange_){nullptr} - , decltype(_impl_.pendingprekey_){nullptr} - , decltype(_impl_.sessionversion_){0u} - , decltype(_impl_.previouscounter_){0u} - , decltype(_impl_.remoteregistrationid_){0u} - , decltype(_impl_.localregistrationid_){0u} - , decltype(_impl_.needsrefresh_){false} - }; - _impl_.localidentitypublic_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.localidentitypublic_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.remoteidentitypublic_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.remoteidentitypublic_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.rootkey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.rootkey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.alicebasekey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.alicebasekey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -SessionStructure::~SessionStructure() { - // @@protoc_insertion_point(destructor:proto.SessionStructure) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SessionStructure::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.receiverchains_.~RepeatedPtrField(); - _impl_.localidentitypublic_.Destroy(); - _impl_.remoteidentitypublic_.Destroy(); - _impl_.rootkey_.Destroy(); - _impl_.alicebasekey_.Destroy(); - if (this != internal_default_instance()) delete _impl_.senderchain_; - if (this != internal_default_instance()) delete _impl_.pendingkeyexchange_; - if (this != internal_default_instance()) delete _impl_.pendingprekey_; -} - -void SessionStructure::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SessionStructure::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SessionStructure) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.receiverchains_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000007fu) { - if (cached_has_bits & 0x00000001u) { - _impl_.localidentitypublic_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.remoteidentitypublic_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.rootkey_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000008u) { - _impl_.alicebasekey_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000010u) { - GOOGLE_DCHECK(_impl_.senderchain_ != nullptr); - _impl_.senderchain_->Clear(); - } - if (cached_has_bits & 0x00000020u) { - GOOGLE_DCHECK(_impl_.pendingkeyexchange_ != nullptr); - _impl_.pendingkeyexchange_->Clear(); - } - if (cached_has_bits & 0x00000040u) { - GOOGLE_DCHECK(_impl_.pendingprekey_ != nullptr); - _impl_.pendingprekey_->Clear(); - } - } - _impl_.sessionversion_ = 0u; - if (cached_has_bits & 0x00000f00u) { - ::memset(&_impl_.previouscounter_, 0, static_cast( - reinterpret_cast(&_impl_.needsrefresh_) - - reinterpret_cast(&_impl_.previouscounter_)) + sizeof(_impl_.needsrefresh_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SessionStructure::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional uint32 sessionVersion = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_sessionversion(&has_bits); - _impl_.sessionversion_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes localIdentityPublic = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_localidentitypublic(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes remoteIdentityPublic = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_remoteidentitypublic(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes rootKey = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - auto str = _internal_mutable_rootkey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 previousCounter = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { - _Internal::set_has_previouscounter(&has_bits); - _impl_.previouscounter_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Chain senderChain = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - ptr = ctx->ParseMessage(_internal_mutable_senderchain(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated .proto.Chain receiverChains = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_receiverchains(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<58>(ptr)); - } else - goto handle_unusual; - continue; - // optional .proto.PendingKeyExchange pendingKeyExchange = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { - ptr = ctx->ParseMessage(_internal_mutable_pendingkeyexchange(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.PendingPreKey pendingPreKey = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { - ptr = ctx->ParseMessage(_internal_mutable_pendingprekey(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 remoteRegistrationId = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { - _Internal::set_has_remoteregistrationid(&has_bits); - _impl_.remoteregistrationid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 localRegistrationId = 11; - case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { - _Internal::set_has_localregistrationid(&has_bits); - _impl_.localregistrationid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool needsRefresh = 12; - case 12: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { - _Internal::set_has_needsrefresh(&has_bits); - _impl_.needsrefresh_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes aliceBaseKey = 13; - case 13: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { - auto str = _internal_mutable_alicebasekey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SessionStructure::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SessionStructure) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional uint32 sessionVersion = 1; - if (cached_has_bits & 0x00000080u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_sessionversion(), target); - } - - // optional bytes localIdentityPublic = 2; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_localidentitypublic(), target); - } - - // optional bytes remoteIdentityPublic = 3; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 3, this->_internal_remoteidentitypublic(), target); - } - - // optional bytes rootKey = 4; - if (cached_has_bits & 0x00000004u) { - target = stream->WriteBytesMaybeAliased( - 4, this->_internal_rootkey(), target); - } - - // optional uint32 previousCounter = 5; - if (cached_has_bits & 0x00000100u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_previouscounter(), target); - } - - // optional .proto.Chain senderChain = 6; - if (cached_has_bits & 0x00000010u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(6, _Internal::senderchain(this), - _Internal::senderchain(this).GetCachedSize(), target, stream); - } - - // repeated .proto.Chain receiverChains = 7; - for (unsigned i = 0, - n = static_cast(this->_internal_receiverchains_size()); i < n; i++) { - const auto& repfield = this->_internal_receiverchains(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(7, repfield, repfield.GetCachedSize(), target, stream); - } - - // optional .proto.PendingKeyExchange pendingKeyExchange = 8; - if (cached_has_bits & 0x00000020u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(8, _Internal::pendingkeyexchange(this), - _Internal::pendingkeyexchange(this).GetCachedSize(), target, stream); - } - - // optional .proto.PendingPreKey pendingPreKey = 9; - if (cached_has_bits & 0x00000040u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(9, _Internal::pendingprekey(this), - _Internal::pendingprekey(this).GetCachedSize(), target, stream); - } - - // optional uint32 remoteRegistrationId = 10; - if (cached_has_bits & 0x00000200u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(10, this->_internal_remoteregistrationid(), target); - } - - // optional uint32 localRegistrationId = 11; - if (cached_has_bits & 0x00000400u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(11, this->_internal_localregistrationid(), target); - } - - // optional bool needsRefresh = 12; - if (cached_has_bits & 0x00000800u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(12, this->_internal_needsrefresh(), target); - } - - // optional bytes aliceBaseKey = 13; - if (cached_has_bits & 0x00000008u) { - target = stream->WriteBytesMaybeAliased( - 13, this->_internal_alicebasekey(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SessionStructure) - return target; -} - -size_t SessionStructure::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SessionStructure) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.Chain receiverChains = 7; - total_size += 1UL * this->_internal_receiverchains_size(); - for (const auto& msg : this->_impl_.receiverchains_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional bytes localIdentityPublic = 2; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_localidentitypublic()); - } - - // optional bytes remoteIdentityPublic = 3; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_remoteidentitypublic()); - } - - // optional bytes rootKey = 4; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_rootkey()); - } - - // optional bytes aliceBaseKey = 13; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_alicebasekey()); - } - - // optional .proto.Chain senderChain = 6; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.senderchain_); - } - - // optional .proto.PendingKeyExchange pendingKeyExchange = 8; - if (cached_has_bits & 0x00000020u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.pendingkeyexchange_); - } - - // optional .proto.PendingPreKey pendingPreKey = 9; - if (cached_has_bits & 0x00000040u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.pendingprekey_); - } - - // optional uint32 sessionVersion = 1; - if (cached_has_bits & 0x00000080u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_sessionversion()); - } - - } - if (cached_has_bits & 0x00000f00u) { - // optional uint32 previousCounter = 5; - if (cached_has_bits & 0x00000100u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_previouscounter()); - } - - // optional uint32 remoteRegistrationId = 10; - if (cached_has_bits & 0x00000200u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_remoteregistrationid()); - } - - // optional uint32 localRegistrationId = 11; - if (cached_has_bits & 0x00000400u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_localregistrationid()); - } - - // optional bool needsRefresh = 12; - if (cached_has_bits & 0x00000800u) { - total_size += 1 + 1; - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SessionStructure::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SessionStructure::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SessionStructure::GetClassData() const { return &_class_data_; } - - -void SessionStructure::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SessionStructure) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.receiverchains_.MergeFrom(from._impl_.receiverchains_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_localidentitypublic(from._internal_localidentitypublic()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_remoteidentitypublic(from._internal_remoteidentitypublic()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_rootkey(from._internal_rootkey()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_set_alicebasekey(from._internal_alicebasekey()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_mutable_senderchain()->::proto::Chain::MergeFrom( - from._internal_senderchain()); - } - if (cached_has_bits & 0x00000020u) { - _this->_internal_mutable_pendingkeyexchange()->::proto::PendingKeyExchange::MergeFrom( - from._internal_pendingkeyexchange()); - } - if (cached_has_bits & 0x00000040u) { - _this->_internal_mutable_pendingprekey()->::proto::PendingPreKey::MergeFrom( - from._internal_pendingprekey()); - } - if (cached_has_bits & 0x00000080u) { - _this->_impl_.sessionversion_ = from._impl_.sessionversion_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - if (cached_has_bits & 0x00000f00u) { - if (cached_has_bits & 0x00000100u) { - _this->_impl_.previouscounter_ = from._impl_.previouscounter_; - } - if (cached_has_bits & 0x00000200u) { - _this->_impl_.remoteregistrationid_ = from._impl_.remoteregistrationid_; - } - if (cached_has_bits & 0x00000400u) { - _this->_impl_.localregistrationid_ = from._impl_.localregistrationid_; - } - if (cached_has_bits & 0x00000800u) { - _this->_impl_.needsrefresh_ = from._impl_.needsrefresh_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SessionStructure::CopyFrom(const SessionStructure& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SessionStructure) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SessionStructure::IsInitialized() const { - return true; -} - -void SessionStructure::InternalSwap(SessionStructure* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.receiverchains_.InternalSwap(&other->_impl_.receiverchains_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.localidentitypublic_, lhs_arena, - &other->_impl_.localidentitypublic_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.remoteidentitypublic_, lhs_arena, - &other->_impl_.remoteidentitypublic_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.rootkey_, lhs_arena, - &other->_impl_.rootkey_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.alicebasekey_, lhs_arena, - &other->_impl_.alicebasekey_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SessionStructure, _impl_.needsrefresh_) - + sizeof(SessionStructure::_impl_.needsrefresh_) - - PROTOBUF_FIELD_OFFSET(SessionStructure, _impl_.senderchain_)>( - reinterpret_cast(&_impl_.senderchain_), - reinterpret_cast(&other->_impl_.senderchain_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SessionStructure::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[170]); -} - -// =================================================================== - -class SignedPreKeyRecordStructure::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_id(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_publickey(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_privatekey(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_signature(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_timestamp(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } -}; - -SignedPreKeyRecordStructure::SignedPreKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SignedPreKeyRecordStructure) -} -SignedPreKeyRecordStructure::SignedPreKeyRecordStructure(const SignedPreKeyRecordStructure& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SignedPreKeyRecordStructure* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.publickey_){} - , decltype(_impl_.privatekey_){} - , decltype(_impl_.signature_){} - , decltype(_impl_.timestamp_){} - , decltype(_impl_.id_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.publickey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.publickey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_publickey()) { - _this->_impl_.publickey_.Set(from._internal_publickey(), - _this->GetArenaForAllocation()); - } - _impl_.privatekey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.privatekey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_privatekey()) { - _this->_impl_.privatekey_.Set(from._internal_privatekey(), - _this->GetArenaForAllocation()); - } - _impl_.signature_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.signature_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_signature()) { - _this->_impl_.signature_.Set(from._internal_signature(), - _this->GetArenaForAllocation()); - } - ::memcpy(&_impl_.timestamp_, &from._impl_.timestamp_, - static_cast(reinterpret_cast(&_impl_.id_) - - reinterpret_cast(&_impl_.timestamp_)) + sizeof(_impl_.id_)); - // @@protoc_insertion_point(copy_constructor:proto.SignedPreKeyRecordStructure) -} - -inline void SignedPreKeyRecordStructure::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.publickey_){} - , decltype(_impl_.privatekey_){} - , decltype(_impl_.signature_){} - , decltype(_impl_.timestamp_){uint64_t{0u}} - , decltype(_impl_.id_){0u} - }; - _impl_.publickey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.publickey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.privatekey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.privatekey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.signature_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.signature_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -SignedPreKeyRecordStructure::~SignedPreKeyRecordStructure() { - // @@protoc_insertion_point(destructor:proto.SignedPreKeyRecordStructure) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SignedPreKeyRecordStructure::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.publickey_.Destroy(); - _impl_.privatekey_.Destroy(); - _impl_.signature_.Destroy(); -} - -void SignedPreKeyRecordStructure::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SignedPreKeyRecordStructure::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SignedPreKeyRecordStructure) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _impl_.publickey_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.privatekey_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.signature_.ClearNonDefaultToEmpty(); - } - } - if (cached_has_bits & 0x00000018u) { - ::memset(&_impl_.timestamp_, 0, static_cast( - reinterpret_cast(&_impl_.id_) - - reinterpret_cast(&_impl_.timestamp_)) + sizeof(_impl_.id_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SignedPreKeyRecordStructure::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional uint32 id = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_id(&has_bits); - _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes publicKey = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_publickey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes privateKey = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_privatekey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes signature = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - auto str = _internal_mutable_signature(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional fixed64 timestamp = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 41)) { - _Internal::set_has_timestamp(&has_bits); - _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); - ptr += sizeof(uint64_t); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SignedPreKeyRecordStructure::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SignedPreKeyRecordStructure) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional uint32 id = 1; - if (cached_has_bits & 0x00000010u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_id(), target); - } - - // optional bytes publicKey = 2; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_publickey(), target); - } - - // optional bytes privateKey = 3; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 3, this->_internal_privatekey(), target); - } - - // optional bytes signature = 4; - if (cached_has_bits & 0x00000004u) { - target = stream->WriteBytesMaybeAliased( - 4, this->_internal_signature(), target); - } - - // optional fixed64 timestamp = 5; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteFixed64ToArray(5, this->_internal_timestamp(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SignedPreKeyRecordStructure) - return target; -} - -size_t SignedPreKeyRecordStructure::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SignedPreKeyRecordStructure) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { - // optional bytes publicKey = 2; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_publickey()); - } - - // optional bytes privateKey = 3; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_privatekey()); - } - - // optional bytes signature = 4; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_signature()); - } - - // optional fixed64 timestamp = 5; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + 8; - } - - // optional uint32 id = 1; - if (cached_has_bits & 0x00000010u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_id()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SignedPreKeyRecordStructure::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SignedPreKeyRecordStructure::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SignedPreKeyRecordStructure::GetClassData() const { return &_class_data_; } - - -void SignedPreKeyRecordStructure::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SignedPreKeyRecordStructure) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_publickey(from._internal_publickey()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_privatekey(from._internal_privatekey()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_signature(from._internal_signature()); - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.timestamp_ = from._impl_.timestamp_; - } - if (cached_has_bits & 0x00000010u) { - _this->_impl_.id_ = from._impl_.id_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SignedPreKeyRecordStructure::CopyFrom(const SignedPreKeyRecordStructure& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SignedPreKeyRecordStructure) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SignedPreKeyRecordStructure::IsInitialized() const { - return true; -} - -void SignedPreKeyRecordStructure::InternalSwap(SignedPreKeyRecordStructure* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.publickey_, lhs_arena, - &other->_impl_.publickey_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.privatekey_, lhs_arena, - &other->_impl_.privatekey_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.signature_, lhs_arena, - &other->_impl_.signature_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SignedPreKeyRecordStructure, _impl_.id_) - + sizeof(SignedPreKeyRecordStructure::_impl_.id_) - - PROTOBUF_FIELD_OFFSET(SignedPreKeyRecordStructure, _impl_.timestamp_)>( - reinterpret_cast(&_impl_.timestamp_), - reinterpret_cast(&other->_impl_.timestamp_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SignedPreKeyRecordStructure::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[171]); -} - -// =================================================================== - -class StatusPSA::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_campaignid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_campaignexpirationtimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static bool MissingRequiredFields(const HasBits& has_bits) { - return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0; - } -}; - -StatusPSA::StatusPSA(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.StatusPSA) -} -StatusPSA::StatusPSA(const StatusPSA& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - StatusPSA* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.campaignid_){} - , decltype(_impl_.campaignexpirationtimestamp_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&_impl_.campaignid_, &from._impl_.campaignid_, - static_cast(reinterpret_cast(&_impl_.campaignexpirationtimestamp_) - - reinterpret_cast(&_impl_.campaignid_)) + sizeof(_impl_.campaignexpirationtimestamp_)); - // @@protoc_insertion_point(copy_constructor:proto.StatusPSA) -} - -inline void StatusPSA::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.campaignid_){uint64_t{0u}} - , decltype(_impl_.campaignexpirationtimestamp_){uint64_t{0u}} - }; -} - -StatusPSA::~StatusPSA() { - // @@protoc_insertion_point(destructor:proto.StatusPSA) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void StatusPSA::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void StatusPSA::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void StatusPSA::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.StatusPSA) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - ::memset(&_impl_.campaignid_, 0, static_cast( - reinterpret_cast(&_impl_.campaignexpirationtimestamp_) - - reinterpret_cast(&_impl_.campaignid_)) + sizeof(_impl_.campaignexpirationtimestamp_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* StatusPSA::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // required uint64 campaignId = 44; - case 44: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { - _Internal::set_has_campaignid(&has_bits); - _impl_.campaignid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint64 campaignExpirationTimestamp = 45; - case 45: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 104)) { - _Internal::set_has_campaignexpirationtimestamp(&has_bits); - _impl_.campaignexpirationtimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* StatusPSA::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.StatusPSA) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // required uint64 campaignId = 44; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(44, this->_internal_campaignid(), target); - } - - // optional uint64 campaignExpirationTimestamp = 45; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(45, this->_internal_campaignexpirationtimestamp(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.StatusPSA) - return target; -} - -size_t StatusPSA::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.StatusPSA) - size_t total_size = 0; - - // required uint64 campaignId = 44; - if (_internal_has_campaignid()) { - total_size += 2 + - ::_pbi::WireFormatLite::UInt64Size( - this->_internal_campaignid()); - } - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional uint64 campaignExpirationTimestamp = 45; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000002u) { - total_size += 2 + - ::_pbi::WireFormatLite::UInt64Size( - this->_internal_campaignexpirationtimestamp()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData StatusPSA::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - StatusPSA::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*StatusPSA::GetClassData() const { return &_class_data_; } - - -void StatusPSA::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.StatusPSA) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_impl_.campaignid_ = from._impl_.campaignid_; - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.campaignexpirationtimestamp_ = from._impl_.campaignexpirationtimestamp_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void StatusPSA::CopyFrom(const StatusPSA& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.StatusPSA) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool StatusPSA::IsInitialized() const { - if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false; - return true; -} - -void StatusPSA::InternalSwap(StatusPSA* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(StatusPSA, _impl_.campaignexpirationtimestamp_) - + sizeof(StatusPSA::_impl_.campaignexpirationtimestamp_) - - PROTOBUF_FIELD_OFFSET(StatusPSA, _impl_.campaignid_)>( - reinterpret_cast(&_impl_.campaignid_), - reinterpret_cast(&other->_impl_.campaignid_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata StatusPSA::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[172]); -} - -// =================================================================== - -class StickerMetadata::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_url(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_filesha256(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_fileencsha256(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_mediakey(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_mimetype(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_height(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static void set_has_width(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } - static void set_has_directpath(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static void set_has_filelength(HasBits* has_bits) { - (*has_bits)[0] |= 256u; - } - static void set_has_weight(HasBits* has_bits) { - (*has_bits)[0] |= 512u; - } -}; - -StickerMetadata::StickerMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.StickerMetadata) -} -StickerMetadata::StickerMetadata(const StickerMetadata& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - StickerMetadata* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.url_){} - , decltype(_impl_.filesha256_){} - , decltype(_impl_.fileencsha256_){} - , decltype(_impl_.mediakey_){} - , decltype(_impl_.mimetype_){} - , decltype(_impl_.directpath_){} - , decltype(_impl_.height_){} - , decltype(_impl_.width_){} - , decltype(_impl_.filelength_){} - , decltype(_impl_.weight_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.url_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.url_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_url()) { - _this->_impl_.url_.Set(from._internal_url(), - _this->GetArenaForAllocation()); - } - _impl_.filesha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filesha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_filesha256()) { - _this->_impl_.filesha256_.Set(from._internal_filesha256(), - _this->GetArenaForAllocation()); - } - _impl_.fileencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_fileencsha256()) { - _this->_impl_.fileencsha256_.Set(from._internal_fileencsha256(), - _this->GetArenaForAllocation()); - } - _impl_.mediakey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediakey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_mediakey()) { - _this->_impl_.mediakey_.Set(from._internal_mediakey(), - _this->GetArenaForAllocation()); - } - _impl_.mimetype_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mimetype_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_mimetype()) { - _this->_impl_.mimetype_.Set(from._internal_mimetype(), - _this->GetArenaForAllocation()); - } - _impl_.directpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_directpath()) { - _this->_impl_.directpath_.Set(from._internal_directpath(), - _this->GetArenaForAllocation()); - } - ::memcpy(&_impl_.height_, &from._impl_.height_, - static_cast(reinterpret_cast(&_impl_.weight_) - - reinterpret_cast(&_impl_.height_)) + sizeof(_impl_.weight_)); - // @@protoc_insertion_point(copy_constructor:proto.StickerMetadata) -} - -inline void StickerMetadata::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.url_){} - , decltype(_impl_.filesha256_){} - , decltype(_impl_.fileencsha256_){} - , decltype(_impl_.mediakey_){} - , decltype(_impl_.mimetype_){} - , decltype(_impl_.directpath_){} - , decltype(_impl_.height_){0u} - , decltype(_impl_.width_){0u} - , decltype(_impl_.filelength_){uint64_t{0u}} - , decltype(_impl_.weight_){0} - }; - _impl_.url_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.url_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filesha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filesha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fileencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediakey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediakey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mimetype_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mimetype_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -StickerMetadata::~StickerMetadata() { - // @@protoc_insertion_point(destructor:proto.StickerMetadata) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void StickerMetadata::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.url_.Destroy(); - _impl_.filesha256_.Destroy(); - _impl_.fileencsha256_.Destroy(); - _impl_.mediakey_.Destroy(); - _impl_.mimetype_.Destroy(); - _impl_.directpath_.Destroy(); -} - -void StickerMetadata::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void StickerMetadata::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.StickerMetadata) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000003fu) { - if (cached_has_bits & 0x00000001u) { - _impl_.url_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.filesha256_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.fileencsha256_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000008u) { - _impl_.mediakey_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000010u) { - _impl_.mimetype_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000020u) { - _impl_.directpath_.ClearNonDefaultToEmpty(); - } - } - if (cached_has_bits & 0x000000c0u) { - ::memset(&_impl_.height_, 0, static_cast( - reinterpret_cast(&_impl_.width_) - - reinterpret_cast(&_impl_.height_)) + sizeof(_impl_.width_)); - } - if (cached_has_bits & 0x00000300u) { - ::memset(&_impl_.filelength_, 0, static_cast( - reinterpret_cast(&_impl_.weight_) - - reinterpret_cast(&_impl_.filelength_)) + sizeof(_impl_.weight_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* StickerMetadata::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string url = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_url(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.StickerMetadata.url"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bytes fileSha256 = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_filesha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes fileEncSha256 = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_fileencsha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes mediaKey = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - auto str = _internal_mutable_mediakey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string mimetype = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - auto str = _internal_mutable_mimetype(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.StickerMetadata.mimetype"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional uint32 height = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { - _Internal::set_has_height(&has_bits); - _impl_.height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 width = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { - _Internal::set_has_width(&has_bits); - _impl_.width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string directPath = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { - auto str = _internal_mutable_directpath(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.StickerMetadata.directPath"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional uint64 fileLength = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { - _Internal::set_has_filelength(&has_bits); - _impl_.filelength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional float weight = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 85)) { - _Internal::set_has_weight(&has_bits); - _impl_.weight_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); - ptr += sizeof(float); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* StickerMetadata::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.StickerMetadata) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string url = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_url().data(), static_cast(this->_internal_url().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.StickerMetadata.url"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_url(), target); - } - - // optional bytes fileSha256 = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_filesha256(), target); - } - - // optional bytes fileEncSha256 = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->WriteBytesMaybeAliased( - 3, this->_internal_fileencsha256(), target); - } - - // optional bytes mediaKey = 4; - if (cached_has_bits & 0x00000008u) { - target = stream->WriteBytesMaybeAliased( - 4, this->_internal_mediakey(), target); - } - - // optional string mimetype = 5; - if (cached_has_bits & 0x00000010u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_mimetype().data(), static_cast(this->_internal_mimetype().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.StickerMetadata.mimetype"); - target = stream->WriteStringMaybeAliased( - 5, this->_internal_mimetype(), target); - } - - // optional uint32 height = 6; - if (cached_has_bits & 0x00000040u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_height(), target); - } - - // optional uint32 width = 7; - if (cached_has_bits & 0x00000080u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(7, this->_internal_width(), target); - } - - // optional string directPath = 8; - if (cached_has_bits & 0x00000020u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_directpath().data(), static_cast(this->_internal_directpath().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.StickerMetadata.directPath"); - target = stream->WriteStringMaybeAliased( - 8, this->_internal_directpath(), target); - } - - // optional uint64 fileLength = 9; - if (cached_has_bits & 0x00000100u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(9, this->_internal_filelength(), target); - } - - // optional float weight = 10; - if (cached_has_bits & 0x00000200u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteFloatToArray(10, this->_internal_weight(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.StickerMetadata) - return target; -} - -size_t StickerMetadata::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.StickerMetadata) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional string url = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_url()); - } - - // optional bytes fileSha256 = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_filesha256()); - } - - // optional bytes fileEncSha256 = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_fileencsha256()); - } - - // optional bytes mediaKey = 4; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_mediakey()); - } - - // optional string mimetype = 5; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_mimetype()); - } - - // optional string directPath = 8; - if (cached_has_bits & 0x00000020u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_directpath()); - } - - // optional uint32 height = 6; - if (cached_has_bits & 0x00000040u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_height()); - } - - // optional uint32 width = 7; - if (cached_has_bits & 0x00000080u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_width()); - } - - } - if (cached_has_bits & 0x00000300u) { - // optional uint64 fileLength = 9; - if (cached_has_bits & 0x00000100u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_filelength()); - } - - // optional float weight = 10; - if (cached_has_bits & 0x00000200u) { - total_size += 1 + 4; - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData StickerMetadata::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - StickerMetadata::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*StickerMetadata::GetClassData() const { return &_class_data_; } - - -void StickerMetadata::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.StickerMetadata) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_url(from._internal_url()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_filesha256(from._internal_filesha256()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_fileencsha256(from._internal_fileencsha256()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_set_mediakey(from._internal_mediakey()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_set_mimetype(from._internal_mimetype()); - } - if (cached_has_bits & 0x00000020u) { - _this->_internal_set_directpath(from._internal_directpath()); - } - if (cached_has_bits & 0x00000040u) { - _this->_impl_.height_ = from._impl_.height_; - } - if (cached_has_bits & 0x00000080u) { - _this->_impl_.width_ = from._impl_.width_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - if (cached_has_bits & 0x00000300u) { - if (cached_has_bits & 0x00000100u) { - _this->_impl_.filelength_ = from._impl_.filelength_; - } - if (cached_has_bits & 0x00000200u) { - _this->_impl_.weight_ = from._impl_.weight_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void StickerMetadata::CopyFrom(const StickerMetadata& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.StickerMetadata) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool StickerMetadata::IsInitialized() const { - return true; -} - -void StickerMetadata::InternalSwap(StickerMetadata* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.url_, lhs_arena, - &other->_impl_.url_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.filesha256_, lhs_arena, - &other->_impl_.filesha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.fileencsha256_, lhs_arena, - &other->_impl_.fileencsha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.mediakey_, lhs_arena, - &other->_impl_.mediakey_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.mimetype_, lhs_arena, - &other->_impl_.mimetype_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.directpath_, lhs_arena, - &other->_impl_.directpath_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(StickerMetadata, _impl_.weight_) - + sizeof(StickerMetadata::_impl_.weight_) - - PROTOBUF_FIELD_OFFSET(StickerMetadata, _impl_.height_)>( - reinterpret_cast(&_impl_.height_), - reinterpret_cast(&other->_impl_.height_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata StickerMetadata::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[173]); -} - -// =================================================================== - -class SyncActionData::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_index(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::proto::SyncActionValue& value(const SyncActionData* msg); - static void set_has_value(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_padding(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_version(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } -}; - -const ::proto::SyncActionValue& -SyncActionData::_Internal::value(const SyncActionData* msg) { - return *msg->_impl_.value_; -} -SyncActionData::SyncActionData(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncActionData) -} -SyncActionData::SyncActionData(const SyncActionData& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncActionData* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.index_){} - , decltype(_impl_.padding_){} - , decltype(_impl_.value_){nullptr} - , decltype(_impl_.version_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.index_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.index_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_index()) { - _this->_impl_.index_.Set(from._internal_index(), - _this->GetArenaForAllocation()); - } - _impl_.padding_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.padding_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_padding()) { - _this->_impl_.padding_.Set(from._internal_padding(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_value()) { - _this->_impl_.value_ = new ::proto::SyncActionValue(*from._impl_.value_); - } - _this->_impl_.version_ = from._impl_.version_; - // @@protoc_insertion_point(copy_constructor:proto.SyncActionData) -} - -inline void SyncActionData::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.index_){} - , decltype(_impl_.padding_){} - , decltype(_impl_.value_){nullptr} - , decltype(_impl_.version_){0} - }; - _impl_.index_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.index_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.padding_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.padding_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -SyncActionData::~SyncActionData() { - // @@protoc_insertion_point(destructor:proto.SyncActionData) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncActionData::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.index_.Destroy(); - _impl_.padding_.Destroy(); - if (this != internal_default_instance()) delete _impl_.value_; -} - -void SyncActionData::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncActionData::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncActionData) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _impl_.index_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.padding_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - GOOGLE_DCHECK(_impl_.value_ != nullptr); - _impl_.value_->Clear(); - } - } - _impl_.version_ = 0; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncActionData::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bytes index = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_index(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SyncActionValue value = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_value(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes padding = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_padding(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional int32 version = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - _Internal::set_has_version(&has_bits); - _impl_.version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncActionData::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionData) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bytes index = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 1, this->_internal_index(), target); - } - - // optional .proto.SyncActionValue value = 2; - if (cached_has_bits & 0x00000004u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::value(this), - _Internal::value(this).GetCachedSize(), target, stream); - } - - // optional bytes padding = 3; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 3, this->_internal_padding(), target); - } - - // optional int32 version = 4; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_version(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionData) - return target; -} - -size_t SyncActionData::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionData) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - // optional bytes index = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_index()); - } - - // optional bytes padding = 3; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_padding()); - } - - // optional .proto.SyncActionValue value = 2; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.value_); - } - - // optional int32 version = 4; - if (cached_has_bits & 0x00000008u) { - total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_version()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionData::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncActionData::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionData::GetClassData() const { return &_class_data_; } - - -void SyncActionData::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionData) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_index(from._internal_index()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_padding(from._internal_padding()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_mutable_value()->::proto::SyncActionValue::MergeFrom( - from._internal_value()); - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.version_ = from._impl_.version_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncActionData::CopyFrom(const SyncActionData& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionData) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncActionData::IsInitialized() const { - return true; -} - -void SyncActionData::InternalSwap(SyncActionData* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.index_, lhs_arena, - &other->_impl_.index_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.padding_, lhs_arena, - &other->_impl_.padding_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SyncActionData, _impl_.version_) - + sizeof(SyncActionData::_impl_.version_) - - PROTOBUF_FIELD_OFFSET(SyncActionData, _impl_.value_)>( - reinterpret_cast(&_impl_.value_), - reinterpret_cast(&other->_impl_.value_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncActionData::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[174]); -} - -// =================================================================== - -class SyncActionValue_AgentAction::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_name(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_deviceid(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_isdeleted(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } -}; - -SyncActionValue_AgentAction::SyncActionValue_AgentAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.AgentAction) -} -SyncActionValue_AgentAction::SyncActionValue_AgentAction(const SyncActionValue_AgentAction& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncActionValue_AgentAction* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.name_){} - , decltype(_impl_.deviceid_){} - , decltype(_impl_.isdeleted_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.name_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.name_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_name()) { - _this->_impl_.name_.Set(from._internal_name(), - _this->GetArenaForAllocation()); - } - ::memcpy(&_impl_.deviceid_, &from._impl_.deviceid_, - static_cast(reinterpret_cast(&_impl_.isdeleted_) - - reinterpret_cast(&_impl_.deviceid_)) + sizeof(_impl_.isdeleted_)); - // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.AgentAction) -} - -inline void SyncActionValue_AgentAction::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.name_){} - , decltype(_impl_.deviceid_){0} - , decltype(_impl_.isdeleted_){false} - }; - _impl_.name_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.name_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -SyncActionValue_AgentAction::~SyncActionValue_AgentAction() { - // @@protoc_insertion_point(destructor:proto.SyncActionValue.AgentAction) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncActionValue_AgentAction::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.name_.Destroy(); -} - -void SyncActionValue_AgentAction::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncActionValue_AgentAction::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.AgentAction) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.name_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000006u) { - ::memset(&_impl_.deviceid_, 0, static_cast( - reinterpret_cast(&_impl_.isdeleted_) - - reinterpret_cast(&_impl_.deviceid_)) + sizeof(_impl_.isdeleted_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncActionValue_AgentAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string name = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_name(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.AgentAction.name"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional int32 deviceID = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_deviceid(&has_bits); - _impl_.deviceid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool isDeleted = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_isdeleted(&has_bits); - _impl_.isdeleted_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncActionValue_AgentAction::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.AgentAction) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string name = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_name().data(), static_cast(this->_internal_name().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.SyncActionValue.AgentAction.name"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_name(), target); - } - - // optional int32 deviceID = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_deviceid(), target); - } - - // optional bool isDeleted = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_isdeleted(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.AgentAction) - return target; -} - -size_t SyncActionValue_AgentAction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.AgentAction) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional string name = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_name()); - } - - // optional int32 deviceID = 2; - if (cached_has_bits & 0x00000002u) { - total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_deviceid()); - } - - // optional bool isDeleted = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + 1; - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_AgentAction::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncActionValue_AgentAction::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_AgentAction::GetClassData() const { return &_class_data_; } - - -void SyncActionValue_AgentAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.AgentAction) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_name(from._internal_name()); - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.deviceid_ = from._impl_.deviceid_; - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.isdeleted_ = from._impl_.isdeleted_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncActionValue_AgentAction::CopyFrom(const SyncActionValue_AgentAction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.AgentAction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncActionValue_AgentAction::IsInitialized() const { - return true; -} - -void SyncActionValue_AgentAction::InternalSwap(SyncActionValue_AgentAction* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.name_, lhs_arena, - &other->_impl_.name_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SyncActionValue_AgentAction, _impl_.isdeleted_) - + sizeof(SyncActionValue_AgentAction::_impl_.isdeleted_) - - PROTOBUF_FIELD_OFFSET(SyncActionValue_AgentAction, _impl_.deviceid_)>( - reinterpret_cast(&_impl_.deviceid_), - reinterpret_cast(&other->_impl_.deviceid_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_AgentAction::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[175]); -} - -// =================================================================== - -class SyncActionValue_AndroidUnsupportedActions::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_allowed(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -SyncActionValue_AndroidUnsupportedActions::SyncActionValue_AndroidUnsupportedActions(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.AndroidUnsupportedActions) -} -SyncActionValue_AndroidUnsupportedActions::SyncActionValue_AndroidUnsupportedActions(const SyncActionValue_AndroidUnsupportedActions& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncActionValue_AndroidUnsupportedActions* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.allowed_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _this->_impl_.allowed_ = from._impl_.allowed_; - // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.AndroidUnsupportedActions) -} - -inline void SyncActionValue_AndroidUnsupportedActions::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.allowed_){false} - }; -} - -SyncActionValue_AndroidUnsupportedActions::~SyncActionValue_AndroidUnsupportedActions() { - // @@protoc_insertion_point(destructor:proto.SyncActionValue.AndroidUnsupportedActions) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncActionValue_AndroidUnsupportedActions::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void SyncActionValue_AndroidUnsupportedActions::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncActionValue_AndroidUnsupportedActions::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.AndroidUnsupportedActions) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.allowed_ = false; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncActionValue_AndroidUnsupportedActions::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bool allowed = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_allowed(&has_bits); - _impl_.allowed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncActionValue_AndroidUnsupportedActions::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.AndroidUnsupportedActions) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bool allowed = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_allowed(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.AndroidUnsupportedActions) - return target; -} - -size_t SyncActionValue_AndroidUnsupportedActions::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.AndroidUnsupportedActions) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional bool allowed = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + 1; - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_AndroidUnsupportedActions::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncActionValue_AndroidUnsupportedActions::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_AndroidUnsupportedActions::GetClassData() const { return &_class_data_; } - - -void SyncActionValue_AndroidUnsupportedActions::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.AndroidUnsupportedActions) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_allowed()) { - _this->_internal_set_allowed(from._internal_allowed()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncActionValue_AndroidUnsupportedActions::CopyFrom(const SyncActionValue_AndroidUnsupportedActions& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.AndroidUnsupportedActions) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncActionValue_AndroidUnsupportedActions::IsInitialized() const { - return true; -} - -void SyncActionValue_AndroidUnsupportedActions::InternalSwap(SyncActionValue_AndroidUnsupportedActions* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - swap(_impl_.allowed_, other->_impl_.allowed_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_AndroidUnsupportedActions::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[176]); -} - -// =================================================================== - -class SyncActionValue_ArchiveChatAction::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_archived(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::proto::SyncActionValue_SyncActionMessageRange& messagerange(const SyncActionValue_ArchiveChatAction* msg); - static void set_has_messagerange(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -const ::proto::SyncActionValue_SyncActionMessageRange& -SyncActionValue_ArchiveChatAction::_Internal::messagerange(const SyncActionValue_ArchiveChatAction* msg) { - return *msg->_impl_.messagerange_; -} -SyncActionValue_ArchiveChatAction::SyncActionValue_ArchiveChatAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.ArchiveChatAction) -} -SyncActionValue_ArchiveChatAction::SyncActionValue_ArchiveChatAction(const SyncActionValue_ArchiveChatAction& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncActionValue_ArchiveChatAction* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.messagerange_){nullptr} - , decltype(_impl_.archived_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_messagerange()) { - _this->_impl_.messagerange_ = new ::proto::SyncActionValue_SyncActionMessageRange(*from._impl_.messagerange_); - } - _this->_impl_.archived_ = from._impl_.archived_; - // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.ArchiveChatAction) -} - -inline void SyncActionValue_ArchiveChatAction::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.messagerange_){nullptr} - , decltype(_impl_.archived_){false} - }; -} - -SyncActionValue_ArchiveChatAction::~SyncActionValue_ArchiveChatAction() { - // @@protoc_insertion_point(destructor:proto.SyncActionValue.ArchiveChatAction) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncActionValue_ArchiveChatAction::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete _impl_.messagerange_; -} - -void SyncActionValue_ArchiveChatAction::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncActionValue_ArchiveChatAction::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.ArchiveChatAction) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.messagerange_ != nullptr); - _impl_.messagerange_->Clear(); - } - _impl_.archived_ = false; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncActionValue_ArchiveChatAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bool archived = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_archived(&has_bits); - _impl_.archived_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_messagerange(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncActionValue_ArchiveChatAction::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.ArchiveChatAction) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bool archived = 1; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_archived(), target); - } - - // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::messagerange(this), - _Internal::messagerange(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.ArchiveChatAction) - return target; -} - -size_t SyncActionValue_ArchiveChatAction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.ArchiveChatAction) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.messagerange_); - } - - // optional bool archived = 1; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + 1; - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_ArchiveChatAction::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncActionValue_ArchiveChatAction::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_ArchiveChatAction::GetClassData() const { return &_class_data_; } - - -void SyncActionValue_ArchiveChatAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.ArchiveChatAction) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_mutable_messagerange()->::proto::SyncActionValue_SyncActionMessageRange::MergeFrom( - from._internal_messagerange()); - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.archived_ = from._impl_.archived_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncActionValue_ArchiveChatAction::CopyFrom(const SyncActionValue_ArchiveChatAction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.ArchiveChatAction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncActionValue_ArchiveChatAction::IsInitialized() const { - return true; -} - -void SyncActionValue_ArchiveChatAction::InternalSwap(SyncActionValue_ArchiveChatAction* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SyncActionValue_ArchiveChatAction, _impl_.archived_) - + sizeof(SyncActionValue_ArchiveChatAction::_impl_.archived_) - - PROTOBUF_FIELD_OFFSET(SyncActionValue_ArchiveChatAction, _impl_.messagerange_)>( - reinterpret_cast(&_impl_.messagerange_), - reinterpret_cast(&other->_impl_.messagerange_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_ArchiveChatAction::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[177]); -} - -// =================================================================== - -class SyncActionValue_ClearChatAction::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::SyncActionValue_SyncActionMessageRange& messagerange(const SyncActionValue_ClearChatAction* msg); - static void set_has_messagerange(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -const ::proto::SyncActionValue_SyncActionMessageRange& -SyncActionValue_ClearChatAction::_Internal::messagerange(const SyncActionValue_ClearChatAction* msg) { - return *msg->_impl_.messagerange_; -} -SyncActionValue_ClearChatAction::SyncActionValue_ClearChatAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.ClearChatAction) -} -SyncActionValue_ClearChatAction::SyncActionValue_ClearChatAction(const SyncActionValue_ClearChatAction& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncActionValue_ClearChatAction* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.messagerange_){nullptr}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_messagerange()) { - _this->_impl_.messagerange_ = new ::proto::SyncActionValue_SyncActionMessageRange(*from._impl_.messagerange_); - } - // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.ClearChatAction) -} - -inline void SyncActionValue_ClearChatAction::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.messagerange_){nullptr} - }; -} - -SyncActionValue_ClearChatAction::~SyncActionValue_ClearChatAction() { - // @@protoc_insertion_point(destructor:proto.SyncActionValue.ClearChatAction) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncActionValue_ClearChatAction::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete _impl_.messagerange_; -} - -void SyncActionValue_ClearChatAction::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncActionValue_ClearChatAction::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.ClearChatAction) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.messagerange_ != nullptr); - _impl_.messagerange_->Clear(); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncActionValue_ClearChatAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_messagerange(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncActionValue_ClearChatAction::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.ClearChatAction) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::messagerange(this), - _Internal::messagerange(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.ClearChatAction) - return target; -} - -size_t SyncActionValue_ClearChatAction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.ClearChatAction) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.messagerange_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_ClearChatAction::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncActionValue_ClearChatAction::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_ClearChatAction::GetClassData() const { return &_class_data_; } - - -void SyncActionValue_ClearChatAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.ClearChatAction) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_messagerange()) { - _this->_internal_mutable_messagerange()->::proto::SyncActionValue_SyncActionMessageRange::MergeFrom( - from._internal_messagerange()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncActionValue_ClearChatAction::CopyFrom(const SyncActionValue_ClearChatAction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.ClearChatAction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncActionValue_ClearChatAction::IsInitialized() const { - return true; -} - -void SyncActionValue_ClearChatAction::InternalSwap(SyncActionValue_ClearChatAction* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - swap(_impl_.messagerange_, other->_impl_.messagerange_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_ClearChatAction::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[178]); -} - -// =================================================================== - -class SyncActionValue_ContactAction::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_fullname(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_firstname(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -SyncActionValue_ContactAction::SyncActionValue_ContactAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.ContactAction) -} -SyncActionValue_ContactAction::SyncActionValue_ContactAction(const SyncActionValue_ContactAction& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncActionValue_ContactAction* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.fullname_){} - , decltype(_impl_.firstname_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.fullname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fullname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_fullname()) { - _this->_impl_.fullname_.Set(from._internal_fullname(), - _this->GetArenaForAllocation()); - } - _impl_.firstname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.firstname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_firstname()) { - _this->_impl_.firstname_.Set(from._internal_firstname(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.ContactAction) -} - -inline void SyncActionValue_ContactAction::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.fullname_){} - , decltype(_impl_.firstname_){} - }; - _impl_.fullname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fullname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.firstname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.firstname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -SyncActionValue_ContactAction::~SyncActionValue_ContactAction() { - // @@protoc_insertion_point(destructor:proto.SyncActionValue.ContactAction) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncActionValue_ContactAction::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.fullname_.Destroy(); - _impl_.firstname_.Destroy(); -} - -void SyncActionValue_ContactAction::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncActionValue_ContactAction::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.ContactAction) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.fullname_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.firstname_.ClearNonDefaultToEmpty(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncActionValue_ContactAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string fullName = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_fullname(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.ContactAction.fullName"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string firstName = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_firstname(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.ContactAction.firstName"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncActionValue_ContactAction::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.ContactAction) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string fullName = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_fullname().data(), static_cast(this->_internal_fullname().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.SyncActionValue.ContactAction.fullName"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_fullname(), target); - } - - // optional string firstName = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_firstname().data(), static_cast(this->_internal_firstname().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.SyncActionValue.ContactAction.firstName"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_firstname(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.ContactAction) - return target; -} - -size_t SyncActionValue_ContactAction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.ContactAction) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional string fullName = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_fullname()); - } - - // optional string firstName = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_firstname()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_ContactAction::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncActionValue_ContactAction::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_ContactAction::GetClassData() const { return &_class_data_; } - - -void SyncActionValue_ContactAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.ContactAction) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_fullname(from._internal_fullname()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_firstname(from._internal_firstname()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncActionValue_ContactAction::CopyFrom(const SyncActionValue_ContactAction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.ContactAction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncActionValue_ContactAction::IsInitialized() const { - return true; -} - -void SyncActionValue_ContactAction::InternalSwap(SyncActionValue_ContactAction* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.fullname_, lhs_arena, - &other->_impl_.fullname_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.firstname_, lhs_arena, - &other->_impl_.firstname_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_ContactAction::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[179]); -} - -// =================================================================== - -class SyncActionValue_DeleteChatAction::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::SyncActionValue_SyncActionMessageRange& messagerange(const SyncActionValue_DeleteChatAction* msg); - static void set_has_messagerange(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -const ::proto::SyncActionValue_SyncActionMessageRange& -SyncActionValue_DeleteChatAction::_Internal::messagerange(const SyncActionValue_DeleteChatAction* msg) { - return *msg->_impl_.messagerange_; -} -SyncActionValue_DeleteChatAction::SyncActionValue_DeleteChatAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.DeleteChatAction) -} -SyncActionValue_DeleteChatAction::SyncActionValue_DeleteChatAction(const SyncActionValue_DeleteChatAction& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncActionValue_DeleteChatAction* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.messagerange_){nullptr}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_messagerange()) { - _this->_impl_.messagerange_ = new ::proto::SyncActionValue_SyncActionMessageRange(*from._impl_.messagerange_); - } - // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.DeleteChatAction) -} - -inline void SyncActionValue_DeleteChatAction::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.messagerange_){nullptr} - }; -} - -SyncActionValue_DeleteChatAction::~SyncActionValue_DeleteChatAction() { - // @@protoc_insertion_point(destructor:proto.SyncActionValue.DeleteChatAction) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncActionValue_DeleteChatAction::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete _impl_.messagerange_; -} - -void SyncActionValue_DeleteChatAction::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncActionValue_DeleteChatAction::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.DeleteChatAction) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.messagerange_ != nullptr); - _impl_.messagerange_->Clear(); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncActionValue_DeleteChatAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_messagerange(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncActionValue_DeleteChatAction::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.DeleteChatAction) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::messagerange(this), - _Internal::messagerange(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.DeleteChatAction) - return target; -} - -size_t SyncActionValue_DeleteChatAction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.DeleteChatAction) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.messagerange_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_DeleteChatAction::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncActionValue_DeleteChatAction::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_DeleteChatAction::GetClassData() const { return &_class_data_; } - - -void SyncActionValue_DeleteChatAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.DeleteChatAction) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_messagerange()) { - _this->_internal_mutable_messagerange()->::proto::SyncActionValue_SyncActionMessageRange::MergeFrom( - from._internal_messagerange()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncActionValue_DeleteChatAction::CopyFrom(const SyncActionValue_DeleteChatAction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.DeleteChatAction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncActionValue_DeleteChatAction::IsInitialized() const { - return true; -} - -void SyncActionValue_DeleteChatAction::InternalSwap(SyncActionValue_DeleteChatAction* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - swap(_impl_.messagerange_, other->_impl_.messagerange_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_DeleteChatAction::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[180]); -} - -// =================================================================== - -class SyncActionValue_DeleteMessageForMeAction::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_deletemedia(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_messagetimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -SyncActionValue_DeleteMessageForMeAction::SyncActionValue_DeleteMessageForMeAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.DeleteMessageForMeAction) -} -SyncActionValue_DeleteMessageForMeAction::SyncActionValue_DeleteMessageForMeAction(const SyncActionValue_DeleteMessageForMeAction& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncActionValue_DeleteMessageForMeAction* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.messagetimestamp_){} - , decltype(_impl_.deletemedia_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&_impl_.messagetimestamp_, &from._impl_.messagetimestamp_, - static_cast(reinterpret_cast(&_impl_.deletemedia_) - - reinterpret_cast(&_impl_.messagetimestamp_)) + sizeof(_impl_.deletemedia_)); - // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.DeleteMessageForMeAction) -} - -inline void SyncActionValue_DeleteMessageForMeAction::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.messagetimestamp_){int64_t{0}} - , decltype(_impl_.deletemedia_){false} - }; -} - -SyncActionValue_DeleteMessageForMeAction::~SyncActionValue_DeleteMessageForMeAction() { - // @@protoc_insertion_point(destructor:proto.SyncActionValue.DeleteMessageForMeAction) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncActionValue_DeleteMessageForMeAction::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void SyncActionValue_DeleteMessageForMeAction::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncActionValue_DeleteMessageForMeAction::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.DeleteMessageForMeAction) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - ::memset(&_impl_.messagetimestamp_, 0, static_cast( - reinterpret_cast(&_impl_.deletemedia_) - - reinterpret_cast(&_impl_.messagetimestamp_)) + sizeof(_impl_.deletemedia_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncActionValue_DeleteMessageForMeAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bool deleteMedia = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_deletemedia(&has_bits); - _impl_.deletemedia_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional int64 messageTimestamp = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_messagetimestamp(&has_bits); - _impl_.messagetimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncActionValue_DeleteMessageForMeAction::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.DeleteMessageForMeAction) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bool deleteMedia = 1; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_deletemedia(), target); - } - - // optional int64 messageTimestamp = 2; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_messagetimestamp(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.DeleteMessageForMeAction) - return target; -} - -size_t SyncActionValue_DeleteMessageForMeAction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.DeleteMessageForMeAction) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional int64 messageTimestamp = 2; - if (cached_has_bits & 0x00000001u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_messagetimestamp()); - } - - // optional bool deleteMedia = 1; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + 1; - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_DeleteMessageForMeAction::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncActionValue_DeleteMessageForMeAction::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_DeleteMessageForMeAction::GetClassData() const { return &_class_data_; } - - -void SyncActionValue_DeleteMessageForMeAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.DeleteMessageForMeAction) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_impl_.messagetimestamp_ = from._impl_.messagetimestamp_; - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.deletemedia_ = from._impl_.deletemedia_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncActionValue_DeleteMessageForMeAction::CopyFrom(const SyncActionValue_DeleteMessageForMeAction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.DeleteMessageForMeAction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncActionValue_DeleteMessageForMeAction::IsInitialized() const { - return true; -} - -void SyncActionValue_DeleteMessageForMeAction::InternalSwap(SyncActionValue_DeleteMessageForMeAction* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SyncActionValue_DeleteMessageForMeAction, _impl_.deletemedia_) - + sizeof(SyncActionValue_DeleteMessageForMeAction::_impl_.deletemedia_) - - PROTOBUF_FIELD_OFFSET(SyncActionValue_DeleteMessageForMeAction, _impl_.messagetimestamp_)>( - reinterpret_cast(&_impl_.messagetimestamp_), - reinterpret_cast(&other->_impl_.messagetimestamp_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_DeleteMessageForMeAction::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[181]); -} - -// =================================================================== - -class SyncActionValue_KeyExpiration::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_expiredkeyepoch(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -SyncActionValue_KeyExpiration::SyncActionValue_KeyExpiration(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.KeyExpiration) -} -SyncActionValue_KeyExpiration::SyncActionValue_KeyExpiration(const SyncActionValue_KeyExpiration& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncActionValue_KeyExpiration* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.expiredkeyepoch_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _this->_impl_.expiredkeyepoch_ = from._impl_.expiredkeyepoch_; - // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.KeyExpiration) -} - -inline void SyncActionValue_KeyExpiration::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.expiredkeyepoch_){0} - }; -} - -SyncActionValue_KeyExpiration::~SyncActionValue_KeyExpiration() { - // @@protoc_insertion_point(destructor:proto.SyncActionValue.KeyExpiration) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncActionValue_KeyExpiration::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void SyncActionValue_KeyExpiration::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncActionValue_KeyExpiration::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.KeyExpiration) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.expiredkeyepoch_ = 0; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncActionValue_KeyExpiration::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional int32 expiredKeyEpoch = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_expiredkeyepoch(&has_bits); - _impl_.expiredkeyepoch_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncActionValue_KeyExpiration::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.KeyExpiration) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional int32 expiredKeyEpoch = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_expiredkeyepoch(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.KeyExpiration) - return target; -} - -size_t SyncActionValue_KeyExpiration::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.KeyExpiration) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional int32 expiredKeyEpoch = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_expiredkeyepoch()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_KeyExpiration::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncActionValue_KeyExpiration::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_KeyExpiration::GetClassData() const { return &_class_data_; } - - -void SyncActionValue_KeyExpiration::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.KeyExpiration) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_expiredkeyepoch()) { - _this->_internal_set_expiredkeyepoch(from._internal_expiredkeyepoch()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncActionValue_KeyExpiration::CopyFrom(const SyncActionValue_KeyExpiration& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.KeyExpiration) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncActionValue_KeyExpiration::IsInitialized() const { - return true; -} - -void SyncActionValue_KeyExpiration::InternalSwap(SyncActionValue_KeyExpiration* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - swap(_impl_.expiredkeyepoch_, other->_impl_.expiredkeyepoch_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_KeyExpiration::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[182]); -} - -// =================================================================== - -class SyncActionValue_LabelAssociationAction::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_labeled(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -SyncActionValue_LabelAssociationAction::SyncActionValue_LabelAssociationAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.LabelAssociationAction) -} -SyncActionValue_LabelAssociationAction::SyncActionValue_LabelAssociationAction(const SyncActionValue_LabelAssociationAction& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncActionValue_LabelAssociationAction* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.labeled_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _this->_impl_.labeled_ = from._impl_.labeled_; - // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.LabelAssociationAction) -} - -inline void SyncActionValue_LabelAssociationAction::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.labeled_){false} - }; -} - -SyncActionValue_LabelAssociationAction::~SyncActionValue_LabelAssociationAction() { - // @@protoc_insertion_point(destructor:proto.SyncActionValue.LabelAssociationAction) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncActionValue_LabelAssociationAction::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void SyncActionValue_LabelAssociationAction::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncActionValue_LabelAssociationAction::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.LabelAssociationAction) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.labeled_ = false; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncActionValue_LabelAssociationAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bool labeled = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_labeled(&has_bits); - _impl_.labeled_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncActionValue_LabelAssociationAction::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.LabelAssociationAction) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bool labeled = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_labeled(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.LabelAssociationAction) - return target; -} - -size_t SyncActionValue_LabelAssociationAction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.LabelAssociationAction) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional bool labeled = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + 1; - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_LabelAssociationAction::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncActionValue_LabelAssociationAction::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_LabelAssociationAction::GetClassData() const { return &_class_data_; } - - -void SyncActionValue_LabelAssociationAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.LabelAssociationAction) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_labeled()) { - _this->_internal_set_labeled(from._internal_labeled()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncActionValue_LabelAssociationAction::CopyFrom(const SyncActionValue_LabelAssociationAction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.LabelAssociationAction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncActionValue_LabelAssociationAction::IsInitialized() const { - return true; -} - -void SyncActionValue_LabelAssociationAction::InternalSwap(SyncActionValue_LabelAssociationAction* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - swap(_impl_.labeled_, other->_impl_.labeled_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_LabelAssociationAction::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[183]); -} - -// =================================================================== - -class SyncActionValue_LabelEditAction::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_name(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_color(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_predefinedid(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_deleted(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } -}; - -SyncActionValue_LabelEditAction::SyncActionValue_LabelEditAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.LabelEditAction) -} -SyncActionValue_LabelEditAction::SyncActionValue_LabelEditAction(const SyncActionValue_LabelEditAction& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncActionValue_LabelEditAction* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.name_){} - , decltype(_impl_.color_){} - , decltype(_impl_.predefinedid_){} - , decltype(_impl_.deleted_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.name_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.name_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_name()) { - _this->_impl_.name_.Set(from._internal_name(), - _this->GetArenaForAllocation()); - } - ::memcpy(&_impl_.color_, &from._impl_.color_, - static_cast(reinterpret_cast(&_impl_.deleted_) - - reinterpret_cast(&_impl_.color_)) + sizeof(_impl_.deleted_)); - // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.LabelEditAction) -} - -inline void SyncActionValue_LabelEditAction::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.name_){} - , decltype(_impl_.color_){0} - , decltype(_impl_.predefinedid_){0} - , decltype(_impl_.deleted_){false} - }; - _impl_.name_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.name_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -SyncActionValue_LabelEditAction::~SyncActionValue_LabelEditAction() { - // @@protoc_insertion_point(destructor:proto.SyncActionValue.LabelEditAction) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncActionValue_LabelEditAction::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.name_.Destroy(); -} - -void SyncActionValue_LabelEditAction::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncActionValue_LabelEditAction::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.LabelEditAction) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.name_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x0000000eu) { - ::memset(&_impl_.color_, 0, static_cast( - reinterpret_cast(&_impl_.deleted_) - - reinterpret_cast(&_impl_.color_)) + sizeof(_impl_.deleted_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncActionValue_LabelEditAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string name = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_name(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.LabelEditAction.name"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional int32 color = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_color(&has_bits); - _impl_.color_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional int32 predefinedId = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_predefinedid(&has_bits); - _impl_.predefinedid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool deleted = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - _Internal::set_has_deleted(&has_bits); - _impl_.deleted_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncActionValue_LabelEditAction::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.LabelEditAction) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string name = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_name().data(), static_cast(this->_internal_name().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.SyncActionValue.LabelEditAction.name"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_name(), target); - } - - // optional int32 color = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_color(), target); - } - - // optional int32 predefinedId = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_predefinedid(), target); - } - - // optional bool deleted = 4; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(4, this->_internal_deleted(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.LabelEditAction) - return target; -} - -size_t SyncActionValue_LabelEditAction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.LabelEditAction) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - // optional string name = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_name()); - } - - // optional int32 color = 2; - if (cached_has_bits & 0x00000002u) { - total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_color()); - } - - // optional int32 predefinedId = 3; - if (cached_has_bits & 0x00000004u) { - total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_predefinedid()); - } - - // optional bool deleted = 4; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + 1; - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_LabelEditAction::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncActionValue_LabelEditAction::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_LabelEditAction::GetClassData() const { return &_class_data_; } - - -void SyncActionValue_LabelEditAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.LabelEditAction) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_name(from._internal_name()); - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.color_ = from._impl_.color_; - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.predefinedid_ = from._impl_.predefinedid_; - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.deleted_ = from._impl_.deleted_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncActionValue_LabelEditAction::CopyFrom(const SyncActionValue_LabelEditAction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.LabelEditAction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncActionValue_LabelEditAction::IsInitialized() const { - return true; -} - -void SyncActionValue_LabelEditAction::InternalSwap(SyncActionValue_LabelEditAction* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.name_, lhs_arena, - &other->_impl_.name_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SyncActionValue_LabelEditAction, _impl_.deleted_) - + sizeof(SyncActionValue_LabelEditAction::_impl_.deleted_) - - PROTOBUF_FIELD_OFFSET(SyncActionValue_LabelEditAction, _impl_.color_)>( - reinterpret_cast(&_impl_.color_), - reinterpret_cast(&other->_impl_.color_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_LabelEditAction::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[184]); -} - -// =================================================================== - -class SyncActionValue_LocaleSetting::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_locale(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -SyncActionValue_LocaleSetting::SyncActionValue_LocaleSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.LocaleSetting) -} -SyncActionValue_LocaleSetting::SyncActionValue_LocaleSetting(const SyncActionValue_LocaleSetting& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncActionValue_LocaleSetting* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.locale_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.locale_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.locale_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_locale()) { - _this->_impl_.locale_.Set(from._internal_locale(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.LocaleSetting) -} - -inline void SyncActionValue_LocaleSetting::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.locale_){} - }; - _impl_.locale_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.locale_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -SyncActionValue_LocaleSetting::~SyncActionValue_LocaleSetting() { - // @@protoc_insertion_point(destructor:proto.SyncActionValue.LocaleSetting) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncActionValue_LocaleSetting::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.locale_.Destroy(); -} - -void SyncActionValue_LocaleSetting::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncActionValue_LocaleSetting::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.LocaleSetting) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.locale_.ClearNonDefaultToEmpty(); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncActionValue_LocaleSetting::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string locale = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_locale(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.LocaleSetting.locale"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncActionValue_LocaleSetting::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.LocaleSetting) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string locale = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_locale().data(), static_cast(this->_internal_locale().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.SyncActionValue.LocaleSetting.locale"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_locale(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.LocaleSetting) - return target; -} - -size_t SyncActionValue_LocaleSetting::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.LocaleSetting) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional string locale = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_locale()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_LocaleSetting::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncActionValue_LocaleSetting::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_LocaleSetting::GetClassData() const { return &_class_data_; } - - -void SyncActionValue_LocaleSetting::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.LocaleSetting) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_locale()) { - _this->_internal_set_locale(from._internal_locale()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncActionValue_LocaleSetting::CopyFrom(const SyncActionValue_LocaleSetting& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.LocaleSetting) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncActionValue_LocaleSetting::IsInitialized() const { - return true; -} - -void SyncActionValue_LocaleSetting::InternalSwap(SyncActionValue_LocaleSetting* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.locale_, lhs_arena, - &other->_impl_.locale_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_LocaleSetting::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[185]); -} - -// =================================================================== - -class SyncActionValue_MarkChatAsReadAction::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_read(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::proto::SyncActionValue_SyncActionMessageRange& messagerange(const SyncActionValue_MarkChatAsReadAction* msg); - static void set_has_messagerange(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -const ::proto::SyncActionValue_SyncActionMessageRange& -SyncActionValue_MarkChatAsReadAction::_Internal::messagerange(const SyncActionValue_MarkChatAsReadAction* msg) { - return *msg->_impl_.messagerange_; -} -SyncActionValue_MarkChatAsReadAction::SyncActionValue_MarkChatAsReadAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.MarkChatAsReadAction) -} -SyncActionValue_MarkChatAsReadAction::SyncActionValue_MarkChatAsReadAction(const SyncActionValue_MarkChatAsReadAction& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncActionValue_MarkChatAsReadAction* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.messagerange_){nullptr} - , decltype(_impl_.read_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_messagerange()) { - _this->_impl_.messagerange_ = new ::proto::SyncActionValue_SyncActionMessageRange(*from._impl_.messagerange_); - } - _this->_impl_.read_ = from._impl_.read_; - // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.MarkChatAsReadAction) -} - -inline void SyncActionValue_MarkChatAsReadAction::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.messagerange_){nullptr} - , decltype(_impl_.read_){false} - }; -} - -SyncActionValue_MarkChatAsReadAction::~SyncActionValue_MarkChatAsReadAction() { - // @@protoc_insertion_point(destructor:proto.SyncActionValue.MarkChatAsReadAction) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncActionValue_MarkChatAsReadAction::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete _impl_.messagerange_; -} - -void SyncActionValue_MarkChatAsReadAction::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncActionValue_MarkChatAsReadAction::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.MarkChatAsReadAction) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.messagerange_ != nullptr); - _impl_.messagerange_->Clear(); - } - _impl_.read_ = false; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncActionValue_MarkChatAsReadAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bool read = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_read(&has_bits); - _impl_.read_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_messagerange(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncActionValue_MarkChatAsReadAction::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.MarkChatAsReadAction) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bool read = 1; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_read(), target); - } - - // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::messagerange(this), - _Internal::messagerange(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.MarkChatAsReadAction) - return target; -} - -size_t SyncActionValue_MarkChatAsReadAction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.MarkChatAsReadAction) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.messagerange_); - } - - // optional bool read = 1; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + 1; - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_MarkChatAsReadAction::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncActionValue_MarkChatAsReadAction::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_MarkChatAsReadAction::GetClassData() const { return &_class_data_; } - - -void SyncActionValue_MarkChatAsReadAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.MarkChatAsReadAction) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_mutable_messagerange()->::proto::SyncActionValue_SyncActionMessageRange::MergeFrom( - from._internal_messagerange()); - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.read_ = from._impl_.read_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncActionValue_MarkChatAsReadAction::CopyFrom(const SyncActionValue_MarkChatAsReadAction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.MarkChatAsReadAction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncActionValue_MarkChatAsReadAction::IsInitialized() const { - return true; -} - -void SyncActionValue_MarkChatAsReadAction::InternalSwap(SyncActionValue_MarkChatAsReadAction* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SyncActionValue_MarkChatAsReadAction, _impl_.read_) - + sizeof(SyncActionValue_MarkChatAsReadAction::_impl_.read_) - - PROTOBUF_FIELD_OFFSET(SyncActionValue_MarkChatAsReadAction, _impl_.messagerange_)>( - reinterpret_cast(&_impl_.messagerange_), - reinterpret_cast(&other->_impl_.messagerange_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_MarkChatAsReadAction::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[186]); -} - -// =================================================================== - -class SyncActionValue_MuteAction::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_muted(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_muteendtimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -SyncActionValue_MuteAction::SyncActionValue_MuteAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.MuteAction) -} -SyncActionValue_MuteAction::SyncActionValue_MuteAction(const SyncActionValue_MuteAction& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncActionValue_MuteAction* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.muteendtimestamp_){} - , decltype(_impl_.muted_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&_impl_.muteendtimestamp_, &from._impl_.muteendtimestamp_, - static_cast(reinterpret_cast(&_impl_.muted_) - - reinterpret_cast(&_impl_.muteendtimestamp_)) + sizeof(_impl_.muted_)); - // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.MuteAction) -} - -inline void SyncActionValue_MuteAction::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.muteendtimestamp_){int64_t{0}} - , decltype(_impl_.muted_){false} - }; -} - -SyncActionValue_MuteAction::~SyncActionValue_MuteAction() { - // @@protoc_insertion_point(destructor:proto.SyncActionValue.MuteAction) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncActionValue_MuteAction::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void SyncActionValue_MuteAction::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncActionValue_MuteAction::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.MuteAction) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - ::memset(&_impl_.muteendtimestamp_, 0, static_cast( - reinterpret_cast(&_impl_.muted_) - - reinterpret_cast(&_impl_.muteendtimestamp_)) + sizeof(_impl_.muted_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncActionValue_MuteAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bool muted = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_muted(&has_bits); - _impl_.muted_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional int64 muteEndTimestamp = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_muteendtimestamp(&has_bits); - _impl_.muteendtimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncActionValue_MuteAction::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.MuteAction) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bool muted = 1; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_muted(), target); - } - - // optional int64 muteEndTimestamp = 2; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_muteendtimestamp(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.MuteAction) - return target; -} - -size_t SyncActionValue_MuteAction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.MuteAction) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional int64 muteEndTimestamp = 2; - if (cached_has_bits & 0x00000001u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_muteendtimestamp()); - } - - // optional bool muted = 1; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + 1; - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_MuteAction::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncActionValue_MuteAction::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_MuteAction::GetClassData() const { return &_class_data_; } - - -void SyncActionValue_MuteAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.MuteAction) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_impl_.muteendtimestamp_ = from._impl_.muteendtimestamp_; - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.muted_ = from._impl_.muted_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncActionValue_MuteAction::CopyFrom(const SyncActionValue_MuteAction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.MuteAction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncActionValue_MuteAction::IsInitialized() const { - return true; -} - -void SyncActionValue_MuteAction::InternalSwap(SyncActionValue_MuteAction* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SyncActionValue_MuteAction, _impl_.muted_) - + sizeof(SyncActionValue_MuteAction::_impl_.muted_) - - PROTOBUF_FIELD_OFFSET(SyncActionValue_MuteAction, _impl_.muteendtimestamp_)>( - reinterpret_cast(&_impl_.muteendtimestamp_), - reinterpret_cast(&other->_impl_.muteendtimestamp_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_MuteAction::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[187]); -} - -// =================================================================== - -class SyncActionValue_NuxAction::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_acknowledged(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -SyncActionValue_NuxAction::SyncActionValue_NuxAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.NuxAction) -} -SyncActionValue_NuxAction::SyncActionValue_NuxAction(const SyncActionValue_NuxAction& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncActionValue_NuxAction* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.acknowledged_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _this->_impl_.acknowledged_ = from._impl_.acknowledged_; - // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.NuxAction) -} - -inline void SyncActionValue_NuxAction::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.acknowledged_){false} - }; -} - -SyncActionValue_NuxAction::~SyncActionValue_NuxAction() { - // @@protoc_insertion_point(destructor:proto.SyncActionValue.NuxAction) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncActionValue_NuxAction::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void SyncActionValue_NuxAction::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncActionValue_NuxAction::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.NuxAction) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.acknowledged_ = false; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncActionValue_NuxAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bool acknowledged = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_acknowledged(&has_bits); - _impl_.acknowledged_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncActionValue_NuxAction::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.NuxAction) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bool acknowledged = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_acknowledged(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.NuxAction) - return target; -} - -size_t SyncActionValue_NuxAction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.NuxAction) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional bool acknowledged = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + 1; - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_NuxAction::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncActionValue_NuxAction::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_NuxAction::GetClassData() const { return &_class_data_; } - - -void SyncActionValue_NuxAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.NuxAction) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_acknowledged()) { - _this->_internal_set_acknowledged(from._internal_acknowledged()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncActionValue_NuxAction::CopyFrom(const SyncActionValue_NuxAction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.NuxAction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncActionValue_NuxAction::IsInitialized() const { - return true; -} - -void SyncActionValue_NuxAction::InternalSwap(SyncActionValue_NuxAction* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - swap(_impl_.acknowledged_, other->_impl_.acknowledged_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_NuxAction::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[188]); -} - -// =================================================================== - -class SyncActionValue_PinAction::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_pinned(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -SyncActionValue_PinAction::SyncActionValue_PinAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.PinAction) -} -SyncActionValue_PinAction::SyncActionValue_PinAction(const SyncActionValue_PinAction& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncActionValue_PinAction* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.pinned_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _this->_impl_.pinned_ = from._impl_.pinned_; - // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.PinAction) -} - -inline void SyncActionValue_PinAction::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.pinned_){false} - }; -} - -SyncActionValue_PinAction::~SyncActionValue_PinAction() { - // @@protoc_insertion_point(destructor:proto.SyncActionValue.PinAction) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncActionValue_PinAction::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void SyncActionValue_PinAction::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncActionValue_PinAction::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.PinAction) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.pinned_ = false; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncActionValue_PinAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bool pinned = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_pinned(&has_bits); - _impl_.pinned_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncActionValue_PinAction::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.PinAction) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bool pinned = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_pinned(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.PinAction) - return target; -} - -size_t SyncActionValue_PinAction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.PinAction) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional bool pinned = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + 1; - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_PinAction::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncActionValue_PinAction::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_PinAction::GetClassData() const { return &_class_data_; } - - -void SyncActionValue_PinAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.PinAction) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_pinned()) { - _this->_internal_set_pinned(from._internal_pinned()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncActionValue_PinAction::CopyFrom(const SyncActionValue_PinAction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.PinAction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncActionValue_PinAction::IsInitialized() const { - return true; -} - -void SyncActionValue_PinAction::InternalSwap(SyncActionValue_PinAction* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - swap(_impl_.pinned_, other->_impl_.pinned_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_PinAction::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[189]); -} - -// =================================================================== - -class SyncActionValue_PrimaryFeature::_Internal { - public: -}; - -SyncActionValue_PrimaryFeature::SyncActionValue_PrimaryFeature(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.PrimaryFeature) -} -SyncActionValue_PrimaryFeature::SyncActionValue_PrimaryFeature(const SyncActionValue_PrimaryFeature& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncActionValue_PrimaryFeature* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_.flags_){from._impl_.flags_} - , /*decltype(_impl_._cached_size_)*/{}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.PrimaryFeature) -} - -inline void SyncActionValue_PrimaryFeature::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_.flags_){arena} - , /*decltype(_impl_._cached_size_)*/{} - }; -} - -SyncActionValue_PrimaryFeature::~SyncActionValue_PrimaryFeature() { - // @@protoc_insertion_point(destructor:proto.SyncActionValue.PrimaryFeature) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncActionValue_PrimaryFeature::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.flags_.~RepeatedPtrField(); -} - -void SyncActionValue_PrimaryFeature::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncActionValue_PrimaryFeature::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.PrimaryFeature) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.flags_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncActionValue_PrimaryFeature::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated string flags = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - auto str = _internal_add_flags(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.PrimaryFeature.flags"); - #endif // !NDEBUG - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncActionValue_PrimaryFeature::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.PrimaryFeature) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated string flags = 1; - for (int i = 0, n = this->_internal_flags_size(); i < n; i++) { - const auto& s = this->_internal_flags(i); - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - s.data(), static_cast(s.length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.SyncActionValue.PrimaryFeature.flags"); - target = stream->WriteString(1, s, target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.PrimaryFeature) - return target; -} - -size_t SyncActionValue_PrimaryFeature::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.PrimaryFeature) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated string flags = 1; - total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.flags_.size()); - for (int i = 0, n = _impl_.flags_.size(); i < n; i++) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - _impl_.flags_.Get(i)); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_PrimaryFeature::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncActionValue_PrimaryFeature::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_PrimaryFeature::GetClassData() const { return &_class_data_; } - - -void SyncActionValue_PrimaryFeature::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.PrimaryFeature) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.flags_.MergeFrom(from._impl_.flags_); - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncActionValue_PrimaryFeature::CopyFrom(const SyncActionValue_PrimaryFeature& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.PrimaryFeature) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncActionValue_PrimaryFeature::IsInitialized() const { - return true; -} - -void SyncActionValue_PrimaryFeature::InternalSwap(SyncActionValue_PrimaryFeature* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - _impl_.flags_.InternalSwap(&other->_impl_.flags_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_PrimaryFeature::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[190]); -} - -// =================================================================== - -class SyncActionValue_PrimaryVersionAction::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_version(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -SyncActionValue_PrimaryVersionAction::SyncActionValue_PrimaryVersionAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.PrimaryVersionAction) -} -SyncActionValue_PrimaryVersionAction::SyncActionValue_PrimaryVersionAction(const SyncActionValue_PrimaryVersionAction& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncActionValue_PrimaryVersionAction* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.version_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.version_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.version_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_version()) { - _this->_impl_.version_.Set(from._internal_version(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.PrimaryVersionAction) -} - -inline void SyncActionValue_PrimaryVersionAction::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.version_){} - }; - _impl_.version_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.version_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -SyncActionValue_PrimaryVersionAction::~SyncActionValue_PrimaryVersionAction() { - // @@protoc_insertion_point(destructor:proto.SyncActionValue.PrimaryVersionAction) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncActionValue_PrimaryVersionAction::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.version_.Destroy(); -} - -void SyncActionValue_PrimaryVersionAction::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncActionValue_PrimaryVersionAction::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.PrimaryVersionAction) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.version_.ClearNonDefaultToEmpty(); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncActionValue_PrimaryVersionAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string version = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_version(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.PrimaryVersionAction.version"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncActionValue_PrimaryVersionAction::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.PrimaryVersionAction) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string version = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_version().data(), static_cast(this->_internal_version().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.SyncActionValue.PrimaryVersionAction.version"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_version(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.PrimaryVersionAction) - return target; -} - -size_t SyncActionValue_PrimaryVersionAction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.PrimaryVersionAction) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional string version = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_version()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_PrimaryVersionAction::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncActionValue_PrimaryVersionAction::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_PrimaryVersionAction::GetClassData() const { return &_class_data_; } - - -void SyncActionValue_PrimaryVersionAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.PrimaryVersionAction) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_version()) { - _this->_internal_set_version(from._internal_version()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncActionValue_PrimaryVersionAction::CopyFrom(const SyncActionValue_PrimaryVersionAction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.PrimaryVersionAction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncActionValue_PrimaryVersionAction::IsInitialized() const { - return true; -} - -void SyncActionValue_PrimaryVersionAction::InternalSwap(SyncActionValue_PrimaryVersionAction* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.version_, lhs_arena, - &other->_impl_.version_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_PrimaryVersionAction::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[191]); -} - -// =================================================================== - -class SyncActionValue_PushNameSetting::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_name(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -SyncActionValue_PushNameSetting::SyncActionValue_PushNameSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.PushNameSetting) -} -SyncActionValue_PushNameSetting::SyncActionValue_PushNameSetting(const SyncActionValue_PushNameSetting& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncActionValue_PushNameSetting* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.name_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.name_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.name_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_name()) { - _this->_impl_.name_.Set(from._internal_name(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.PushNameSetting) -} - -inline void SyncActionValue_PushNameSetting::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.name_){} - }; - _impl_.name_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.name_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -SyncActionValue_PushNameSetting::~SyncActionValue_PushNameSetting() { - // @@protoc_insertion_point(destructor:proto.SyncActionValue.PushNameSetting) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncActionValue_PushNameSetting::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.name_.Destroy(); -} - -void SyncActionValue_PushNameSetting::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncActionValue_PushNameSetting::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.PushNameSetting) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.name_.ClearNonDefaultToEmpty(); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncActionValue_PushNameSetting::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string name = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_name(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.PushNameSetting.name"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncActionValue_PushNameSetting::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.PushNameSetting) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string name = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_name().data(), static_cast(this->_internal_name().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.SyncActionValue.PushNameSetting.name"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_name(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.PushNameSetting) - return target; -} - -size_t SyncActionValue_PushNameSetting::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.PushNameSetting) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional string name = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_name()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_PushNameSetting::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncActionValue_PushNameSetting::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_PushNameSetting::GetClassData() const { return &_class_data_; } - - -void SyncActionValue_PushNameSetting::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.PushNameSetting) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_name()) { - _this->_internal_set_name(from._internal_name()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncActionValue_PushNameSetting::CopyFrom(const SyncActionValue_PushNameSetting& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.PushNameSetting) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncActionValue_PushNameSetting::IsInitialized() const { - return true; -} - -void SyncActionValue_PushNameSetting::InternalSwap(SyncActionValue_PushNameSetting* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.name_, lhs_arena, - &other->_impl_.name_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_PushNameSetting::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[192]); -} - -// =================================================================== - -class SyncActionValue_QuickReplyAction::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_shortcut(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_message(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_count(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_deleted(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } -}; - -SyncActionValue_QuickReplyAction::SyncActionValue_QuickReplyAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.QuickReplyAction) -} -SyncActionValue_QuickReplyAction::SyncActionValue_QuickReplyAction(const SyncActionValue_QuickReplyAction& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncActionValue_QuickReplyAction* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.keywords_){from._impl_.keywords_} - , decltype(_impl_.shortcut_){} - , decltype(_impl_.message_){} - , decltype(_impl_.count_){} - , decltype(_impl_.deleted_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.shortcut_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.shortcut_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_shortcut()) { - _this->_impl_.shortcut_.Set(from._internal_shortcut(), - _this->GetArenaForAllocation()); - } - _impl_.message_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.message_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_message()) { - _this->_impl_.message_.Set(from._internal_message(), - _this->GetArenaForAllocation()); - } - ::memcpy(&_impl_.count_, &from._impl_.count_, - static_cast(reinterpret_cast(&_impl_.deleted_) - - reinterpret_cast(&_impl_.count_)) + sizeof(_impl_.deleted_)); - // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.QuickReplyAction) -} - -inline void SyncActionValue_QuickReplyAction::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.keywords_){arena} - , decltype(_impl_.shortcut_){} - , decltype(_impl_.message_){} - , decltype(_impl_.count_){0} - , decltype(_impl_.deleted_){false} - }; - _impl_.shortcut_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.shortcut_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.message_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.message_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -SyncActionValue_QuickReplyAction::~SyncActionValue_QuickReplyAction() { - // @@protoc_insertion_point(destructor:proto.SyncActionValue.QuickReplyAction) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncActionValue_QuickReplyAction::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.keywords_.~RepeatedPtrField(); - _impl_.shortcut_.Destroy(); - _impl_.message_.Destroy(); -} - -void SyncActionValue_QuickReplyAction::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncActionValue_QuickReplyAction::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.QuickReplyAction) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.keywords_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.shortcut_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.message_.ClearNonDefaultToEmpty(); - } - } - if (cached_has_bits & 0x0000000cu) { - ::memset(&_impl_.count_, 0, static_cast( - reinterpret_cast(&_impl_.deleted_) - - reinterpret_cast(&_impl_.count_)) + sizeof(_impl_.deleted_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncActionValue_QuickReplyAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string shortcut = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_shortcut(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.QuickReplyAction.shortcut"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string message = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_message(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.QuickReplyAction.message"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // repeated string keywords = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr -= 1; - do { - ptr += 1; - auto str = _internal_add_keywords(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.QuickReplyAction.keywords"); - #endif // !NDEBUG - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); - } else - goto handle_unusual; - continue; - // optional int32 count = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - _Internal::set_has_count(&has_bits); - _impl_.count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool deleted = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { - _Internal::set_has_deleted(&has_bits); - _impl_.deleted_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncActionValue_QuickReplyAction::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.QuickReplyAction) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string shortcut = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_shortcut().data(), static_cast(this->_internal_shortcut().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.SyncActionValue.QuickReplyAction.shortcut"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_shortcut(), target); - } - - // optional string message = 2; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_message().data(), static_cast(this->_internal_message().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.SyncActionValue.QuickReplyAction.message"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_message(), target); - } - - // repeated string keywords = 3; - for (int i = 0, n = this->_internal_keywords_size(); i < n; i++) { - const auto& s = this->_internal_keywords(i); - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - s.data(), static_cast(s.length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.SyncActionValue.QuickReplyAction.keywords"); - target = stream->WriteString(3, s, target); - } - - // optional int32 count = 4; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_count(), target); - } - - // optional bool deleted = 5; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(5, this->_internal_deleted(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.QuickReplyAction) - return target; -} - -size_t SyncActionValue_QuickReplyAction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.QuickReplyAction) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated string keywords = 3; - total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.keywords_.size()); - for (int i = 0, n = _impl_.keywords_.size(); i < n; i++) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - _impl_.keywords_.Get(i)); - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - // optional string shortcut = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_shortcut()); - } - - // optional string message = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_message()); - } - - // optional int32 count = 4; - if (cached_has_bits & 0x00000004u) { - total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_count()); - } - - // optional bool deleted = 5; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + 1; - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_QuickReplyAction::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncActionValue_QuickReplyAction::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_QuickReplyAction::GetClassData() const { return &_class_data_; } - - -void SyncActionValue_QuickReplyAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.QuickReplyAction) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.keywords_.MergeFrom(from._impl_.keywords_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_shortcut(from._internal_shortcut()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_message(from._internal_message()); - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.count_ = from._impl_.count_; - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.deleted_ = from._impl_.deleted_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncActionValue_QuickReplyAction::CopyFrom(const SyncActionValue_QuickReplyAction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.QuickReplyAction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncActionValue_QuickReplyAction::IsInitialized() const { - return true; -} - -void SyncActionValue_QuickReplyAction::InternalSwap(SyncActionValue_QuickReplyAction* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.keywords_.InternalSwap(&other->_impl_.keywords_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.shortcut_, lhs_arena, - &other->_impl_.shortcut_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.message_, lhs_arena, - &other->_impl_.message_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SyncActionValue_QuickReplyAction, _impl_.deleted_) - + sizeof(SyncActionValue_QuickReplyAction::_impl_.deleted_) - - PROTOBUF_FIELD_OFFSET(SyncActionValue_QuickReplyAction, _impl_.count_)>( - reinterpret_cast(&_impl_.count_), - reinterpret_cast(&other->_impl_.count_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_QuickReplyAction::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[193]); -} - -// =================================================================== - -class SyncActionValue_RecentEmojiWeightsAction::_Internal { - public: -}; - -SyncActionValue_RecentEmojiWeightsAction::SyncActionValue_RecentEmojiWeightsAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.RecentEmojiWeightsAction) -} -SyncActionValue_RecentEmojiWeightsAction::SyncActionValue_RecentEmojiWeightsAction(const SyncActionValue_RecentEmojiWeightsAction& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncActionValue_RecentEmojiWeightsAction* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_.weights_){from._impl_.weights_} - , /*decltype(_impl_._cached_size_)*/{}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.RecentEmojiWeightsAction) -} - -inline void SyncActionValue_RecentEmojiWeightsAction::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_.weights_){arena} - , /*decltype(_impl_._cached_size_)*/{} - }; -} - -SyncActionValue_RecentEmojiWeightsAction::~SyncActionValue_RecentEmojiWeightsAction() { - // @@protoc_insertion_point(destructor:proto.SyncActionValue.RecentEmojiWeightsAction) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncActionValue_RecentEmojiWeightsAction::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.weights_.~RepeatedPtrField(); -} - -void SyncActionValue_RecentEmojiWeightsAction::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncActionValue_RecentEmojiWeightsAction::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.RecentEmojiWeightsAction) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.weights_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncActionValue_RecentEmojiWeightsAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated .proto.RecentEmojiWeight weights = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_weights(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncActionValue_RecentEmojiWeightsAction::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.RecentEmojiWeightsAction) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .proto.RecentEmojiWeight weights = 1; - for (unsigned i = 0, - n = static_cast(this->_internal_weights_size()); i < n; i++) { - const auto& repfield = this->_internal_weights(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.RecentEmojiWeightsAction) - return target; -} - -size_t SyncActionValue_RecentEmojiWeightsAction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.RecentEmojiWeightsAction) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.RecentEmojiWeight weights = 1; - total_size += 1UL * this->_internal_weights_size(); - for (const auto& msg : this->_impl_.weights_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_RecentEmojiWeightsAction::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncActionValue_RecentEmojiWeightsAction::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_RecentEmojiWeightsAction::GetClassData() const { return &_class_data_; } - - -void SyncActionValue_RecentEmojiWeightsAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.RecentEmojiWeightsAction) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.weights_.MergeFrom(from._impl_.weights_); - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncActionValue_RecentEmojiWeightsAction::CopyFrom(const SyncActionValue_RecentEmojiWeightsAction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.RecentEmojiWeightsAction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncActionValue_RecentEmojiWeightsAction::IsInitialized() const { - return true; -} - -void SyncActionValue_RecentEmojiWeightsAction::InternalSwap(SyncActionValue_RecentEmojiWeightsAction* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - _impl_.weights_.InternalSwap(&other->_impl_.weights_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_RecentEmojiWeightsAction::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[194]); -} - -// =================================================================== - -class SyncActionValue_SecurityNotificationSetting::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_shownotification(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -SyncActionValue_SecurityNotificationSetting::SyncActionValue_SecurityNotificationSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.SecurityNotificationSetting) -} -SyncActionValue_SecurityNotificationSetting::SyncActionValue_SecurityNotificationSetting(const SyncActionValue_SecurityNotificationSetting& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncActionValue_SecurityNotificationSetting* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.shownotification_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _this->_impl_.shownotification_ = from._impl_.shownotification_; - // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.SecurityNotificationSetting) -} - -inline void SyncActionValue_SecurityNotificationSetting::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.shownotification_){false} - }; -} - -SyncActionValue_SecurityNotificationSetting::~SyncActionValue_SecurityNotificationSetting() { - // @@protoc_insertion_point(destructor:proto.SyncActionValue.SecurityNotificationSetting) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncActionValue_SecurityNotificationSetting::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void SyncActionValue_SecurityNotificationSetting::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncActionValue_SecurityNotificationSetting::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.SecurityNotificationSetting) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.shownotification_ = false; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncActionValue_SecurityNotificationSetting::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bool showNotification = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_shownotification(&has_bits); - _impl_.shownotification_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncActionValue_SecurityNotificationSetting::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.SecurityNotificationSetting) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bool showNotification = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_shownotification(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.SecurityNotificationSetting) - return target; -} - -size_t SyncActionValue_SecurityNotificationSetting::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.SecurityNotificationSetting) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional bool showNotification = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + 1; - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_SecurityNotificationSetting::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncActionValue_SecurityNotificationSetting::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_SecurityNotificationSetting::GetClassData() const { return &_class_data_; } - - -void SyncActionValue_SecurityNotificationSetting::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.SecurityNotificationSetting) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_shownotification()) { - _this->_internal_set_shownotification(from._internal_shownotification()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncActionValue_SecurityNotificationSetting::CopyFrom(const SyncActionValue_SecurityNotificationSetting& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.SecurityNotificationSetting) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncActionValue_SecurityNotificationSetting::IsInitialized() const { - return true; -} - -void SyncActionValue_SecurityNotificationSetting::InternalSwap(SyncActionValue_SecurityNotificationSetting* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - swap(_impl_.shownotification_, other->_impl_.shownotification_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_SecurityNotificationSetting::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[195]); -} - -// =================================================================== - -class SyncActionValue_StarAction::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_starred(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -SyncActionValue_StarAction::SyncActionValue_StarAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.StarAction) -} -SyncActionValue_StarAction::SyncActionValue_StarAction(const SyncActionValue_StarAction& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncActionValue_StarAction* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.starred_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _this->_impl_.starred_ = from._impl_.starred_; - // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.StarAction) -} - -inline void SyncActionValue_StarAction::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.starred_){false} - }; -} - -SyncActionValue_StarAction::~SyncActionValue_StarAction() { - // @@protoc_insertion_point(destructor:proto.SyncActionValue.StarAction) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncActionValue_StarAction::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void SyncActionValue_StarAction::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncActionValue_StarAction::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.StarAction) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.starred_ = false; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncActionValue_StarAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bool starred = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_starred(&has_bits); - _impl_.starred_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncActionValue_StarAction::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.StarAction) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bool starred = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_starred(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.StarAction) - return target; -} - -size_t SyncActionValue_StarAction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.StarAction) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional bool starred = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + 1; - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_StarAction::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncActionValue_StarAction::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_StarAction::GetClassData() const { return &_class_data_; } - - -void SyncActionValue_StarAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.StarAction) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_starred()) { - _this->_internal_set_starred(from._internal_starred()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncActionValue_StarAction::CopyFrom(const SyncActionValue_StarAction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.StarAction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncActionValue_StarAction::IsInitialized() const { - return true; -} - -void SyncActionValue_StarAction::InternalSwap(SyncActionValue_StarAction* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - swap(_impl_.starred_, other->_impl_.starred_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_StarAction::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[196]); -} - -// =================================================================== - -class SyncActionValue_StickerAction::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_url(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_fileencsha256(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_mediakey(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_mimetype(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_height(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static void set_has_width(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static void set_has_directpath(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_filelength(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } - static void set_has_isfavorite(HasBits* has_bits) { - (*has_bits)[0] |= 256u; - } - static void set_has_deviceidhint(HasBits* has_bits) { - (*has_bits)[0] |= 512u; - } -}; - -SyncActionValue_StickerAction::SyncActionValue_StickerAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.StickerAction) -} -SyncActionValue_StickerAction::SyncActionValue_StickerAction(const SyncActionValue_StickerAction& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncActionValue_StickerAction* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.url_){} - , decltype(_impl_.fileencsha256_){} - , decltype(_impl_.mediakey_){} - , decltype(_impl_.mimetype_){} - , decltype(_impl_.directpath_){} - , decltype(_impl_.height_){} - , decltype(_impl_.width_){} - , decltype(_impl_.filelength_){} - , decltype(_impl_.isfavorite_){} - , decltype(_impl_.deviceidhint_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.url_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.url_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_url()) { - _this->_impl_.url_.Set(from._internal_url(), - _this->GetArenaForAllocation()); - } - _impl_.fileencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_fileencsha256()) { - _this->_impl_.fileencsha256_.Set(from._internal_fileencsha256(), - _this->GetArenaForAllocation()); - } - _impl_.mediakey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediakey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_mediakey()) { - _this->_impl_.mediakey_.Set(from._internal_mediakey(), - _this->GetArenaForAllocation()); - } - _impl_.mimetype_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mimetype_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_mimetype()) { - _this->_impl_.mimetype_.Set(from._internal_mimetype(), - _this->GetArenaForAllocation()); - } - _impl_.directpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_directpath()) { - _this->_impl_.directpath_.Set(from._internal_directpath(), - _this->GetArenaForAllocation()); - } - ::memcpy(&_impl_.height_, &from._impl_.height_, - static_cast(reinterpret_cast(&_impl_.deviceidhint_) - - reinterpret_cast(&_impl_.height_)) + sizeof(_impl_.deviceidhint_)); - // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.StickerAction) -} - -inline void SyncActionValue_StickerAction::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.url_){} - , decltype(_impl_.fileencsha256_){} - , decltype(_impl_.mediakey_){} - , decltype(_impl_.mimetype_){} - , decltype(_impl_.directpath_){} - , decltype(_impl_.height_){0u} - , decltype(_impl_.width_){0u} - , decltype(_impl_.filelength_){uint64_t{0u}} - , decltype(_impl_.isfavorite_){false} - , decltype(_impl_.deviceidhint_){0u} - }; - _impl_.url_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.url_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fileencsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediakey_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediakey_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mimetype_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mimetype_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.directpath_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -SyncActionValue_StickerAction::~SyncActionValue_StickerAction() { - // @@protoc_insertion_point(destructor:proto.SyncActionValue.StickerAction) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncActionValue_StickerAction::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.url_.Destroy(); - _impl_.fileencsha256_.Destroy(); - _impl_.mediakey_.Destroy(); - _impl_.mimetype_.Destroy(); - _impl_.directpath_.Destroy(); -} - -void SyncActionValue_StickerAction::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncActionValue_StickerAction::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.StickerAction) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { - if (cached_has_bits & 0x00000001u) { - _impl_.url_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.fileencsha256_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.mediakey_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000008u) { - _impl_.mimetype_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000010u) { - _impl_.directpath_.ClearNonDefaultToEmpty(); - } - } - if (cached_has_bits & 0x000000e0u) { - ::memset(&_impl_.height_, 0, static_cast( - reinterpret_cast(&_impl_.filelength_) - - reinterpret_cast(&_impl_.height_)) + sizeof(_impl_.filelength_)); - } - if (cached_has_bits & 0x00000300u) { - ::memset(&_impl_.isfavorite_, 0, static_cast( - reinterpret_cast(&_impl_.deviceidhint_) - - reinterpret_cast(&_impl_.isfavorite_)) + sizeof(_impl_.deviceidhint_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncActionValue_StickerAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string url = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_url(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.StickerAction.url"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bytes fileEncSha256 = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_fileencsha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes mediaKey = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_mediakey(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string mimetype = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - auto str = _internal_mutable_mimetype(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.StickerAction.mimetype"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional uint32 height = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { - _Internal::set_has_height(&has_bits); - _impl_.height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 width = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { - _Internal::set_has_width(&has_bits); - _impl_.width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string directPath = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - auto str = _internal_mutable_directpath(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.SyncActionValue.StickerAction.directPath"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional uint64 fileLength = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { - _Internal::set_has_filelength(&has_bits); - _impl_.filelength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool isFavorite = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { - _Internal::set_has_isfavorite(&has_bits); - _impl_.isfavorite_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 deviceIdHint = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { - _Internal::set_has_deviceidhint(&has_bits); - _impl_.deviceidhint_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncActionValue_StickerAction::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.StickerAction) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string url = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_url().data(), static_cast(this->_internal_url().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.SyncActionValue.StickerAction.url"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_url(), target); - } - - // optional bytes fileEncSha256 = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_fileencsha256(), target); - } - - // optional bytes mediaKey = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->WriteBytesMaybeAliased( - 3, this->_internal_mediakey(), target); - } - - // optional string mimetype = 4; - if (cached_has_bits & 0x00000008u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_mimetype().data(), static_cast(this->_internal_mimetype().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.SyncActionValue.StickerAction.mimetype"); - target = stream->WriteStringMaybeAliased( - 4, this->_internal_mimetype(), target); - } - - // optional uint32 height = 5; - if (cached_has_bits & 0x00000020u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_height(), target); - } - - // optional uint32 width = 6; - if (cached_has_bits & 0x00000040u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_width(), target); - } - - // optional string directPath = 7; - if (cached_has_bits & 0x00000010u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_directpath().data(), static_cast(this->_internal_directpath().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.SyncActionValue.StickerAction.directPath"); - target = stream->WriteStringMaybeAliased( - 7, this->_internal_directpath(), target); - } - - // optional uint64 fileLength = 8; - if (cached_has_bits & 0x00000080u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(8, this->_internal_filelength(), target); - } - - // optional bool isFavorite = 9; - if (cached_has_bits & 0x00000100u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(9, this->_internal_isfavorite(), target); - } - - // optional uint32 deviceIdHint = 10; - if (cached_has_bits & 0x00000200u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(10, this->_internal_deviceidhint(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.StickerAction) - return target; -} - -size_t SyncActionValue_StickerAction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.StickerAction) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional string url = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_url()); - } - - // optional bytes fileEncSha256 = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_fileencsha256()); - } - - // optional bytes mediaKey = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_mediakey()); - } - - // optional string mimetype = 4; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_mimetype()); - } - - // optional string directPath = 7; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_directpath()); - } - - // optional uint32 height = 5; - if (cached_has_bits & 0x00000020u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_height()); - } - - // optional uint32 width = 6; - if (cached_has_bits & 0x00000040u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_width()); - } - - // optional uint64 fileLength = 8; - if (cached_has_bits & 0x00000080u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_filelength()); - } - - } - if (cached_has_bits & 0x00000300u) { - // optional bool isFavorite = 9; - if (cached_has_bits & 0x00000100u) { - total_size += 1 + 1; - } - - // optional uint32 deviceIdHint = 10; - if (cached_has_bits & 0x00000200u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_deviceidhint()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_StickerAction::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncActionValue_StickerAction::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_StickerAction::GetClassData() const { return &_class_data_; } - - -void SyncActionValue_StickerAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.StickerAction) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_url(from._internal_url()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_fileencsha256(from._internal_fileencsha256()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_mediakey(from._internal_mediakey()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_set_mimetype(from._internal_mimetype()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_set_directpath(from._internal_directpath()); - } - if (cached_has_bits & 0x00000020u) { - _this->_impl_.height_ = from._impl_.height_; - } - if (cached_has_bits & 0x00000040u) { - _this->_impl_.width_ = from._impl_.width_; - } - if (cached_has_bits & 0x00000080u) { - _this->_impl_.filelength_ = from._impl_.filelength_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - if (cached_has_bits & 0x00000300u) { - if (cached_has_bits & 0x00000100u) { - _this->_impl_.isfavorite_ = from._impl_.isfavorite_; - } - if (cached_has_bits & 0x00000200u) { - _this->_impl_.deviceidhint_ = from._impl_.deviceidhint_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncActionValue_StickerAction::CopyFrom(const SyncActionValue_StickerAction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.StickerAction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncActionValue_StickerAction::IsInitialized() const { - return true; -} - -void SyncActionValue_StickerAction::InternalSwap(SyncActionValue_StickerAction* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.url_, lhs_arena, - &other->_impl_.url_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.fileencsha256_, lhs_arena, - &other->_impl_.fileencsha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.mediakey_, lhs_arena, - &other->_impl_.mediakey_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.mimetype_, lhs_arena, - &other->_impl_.mimetype_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.directpath_, lhs_arena, - &other->_impl_.directpath_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SyncActionValue_StickerAction, _impl_.deviceidhint_) - + sizeof(SyncActionValue_StickerAction::_impl_.deviceidhint_) - - PROTOBUF_FIELD_OFFSET(SyncActionValue_StickerAction, _impl_.height_)>( - reinterpret_cast(&_impl_.height_), - reinterpret_cast(&other->_impl_.height_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_StickerAction::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[197]); -} - -// =================================================================== - -class SyncActionValue_SubscriptionAction::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_isdeactivated(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_isautorenewing(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_expirationdate(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -SyncActionValue_SubscriptionAction::SyncActionValue_SubscriptionAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.SubscriptionAction) -} -SyncActionValue_SubscriptionAction::SyncActionValue_SubscriptionAction(const SyncActionValue_SubscriptionAction& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncActionValue_SubscriptionAction* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.expirationdate_){} - , decltype(_impl_.isdeactivated_){} - , decltype(_impl_.isautorenewing_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&_impl_.expirationdate_, &from._impl_.expirationdate_, - static_cast(reinterpret_cast(&_impl_.isautorenewing_) - - reinterpret_cast(&_impl_.expirationdate_)) + sizeof(_impl_.isautorenewing_)); - // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.SubscriptionAction) -} - -inline void SyncActionValue_SubscriptionAction::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.expirationdate_){int64_t{0}} - , decltype(_impl_.isdeactivated_){false} - , decltype(_impl_.isautorenewing_){false} - }; -} - -SyncActionValue_SubscriptionAction::~SyncActionValue_SubscriptionAction() { - // @@protoc_insertion_point(destructor:proto.SyncActionValue.SubscriptionAction) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncActionValue_SubscriptionAction::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void SyncActionValue_SubscriptionAction::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncActionValue_SubscriptionAction::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.SubscriptionAction) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - ::memset(&_impl_.expirationdate_, 0, static_cast( - reinterpret_cast(&_impl_.isautorenewing_) - - reinterpret_cast(&_impl_.expirationdate_)) + sizeof(_impl_.isautorenewing_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncActionValue_SubscriptionAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bool isDeactivated = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_isdeactivated(&has_bits); - _impl_.isdeactivated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool isAutoRenewing = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_isautorenewing(&has_bits); - _impl_.isautorenewing_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional int64 expirationDate = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_expirationdate(&has_bits); - _impl_.expirationdate_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncActionValue_SubscriptionAction::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.SubscriptionAction) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bool isDeactivated = 1; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_isdeactivated(), target); - } - - // optional bool isAutoRenewing = 2; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(2, this->_internal_isautorenewing(), target); - } - - // optional int64 expirationDate = 3; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_expirationdate(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.SubscriptionAction) - return target; -} - -size_t SyncActionValue_SubscriptionAction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.SubscriptionAction) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional int64 expirationDate = 3; - if (cached_has_bits & 0x00000001u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_expirationdate()); - } - - // optional bool isDeactivated = 1; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + 1; - } - - // optional bool isAutoRenewing = 2; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + 1; - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_SubscriptionAction::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncActionValue_SubscriptionAction::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_SubscriptionAction::GetClassData() const { return &_class_data_; } - - -void SyncActionValue_SubscriptionAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.SubscriptionAction) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_impl_.expirationdate_ = from._impl_.expirationdate_; - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.isdeactivated_ = from._impl_.isdeactivated_; - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.isautorenewing_ = from._impl_.isautorenewing_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncActionValue_SubscriptionAction::CopyFrom(const SyncActionValue_SubscriptionAction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.SubscriptionAction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncActionValue_SubscriptionAction::IsInitialized() const { - return true; -} - -void SyncActionValue_SubscriptionAction::InternalSwap(SyncActionValue_SubscriptionAction* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SyncActionValue_SubscriptionAction, _impl_.isautorenewing_) - + sizeof(SyncActionValue_SubscriptionAction::_impl_.isautorenewing_) - - PROTOBUF_FIELD_OFFSET(SyncActionValue_SubscriptionAction, _impl_.expirationdate_)>( - reinterpret_cast(&_impl_.expirationdate_), - reinterpret_cast(&other->_impl_.expirationdate_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_SubscriptionAction::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[198]); -} - -// =================================================================== - -class SyncActionValue_SyncActionMessageRange::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_lastmessagetimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_lastsystemmessagetimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -SyncActionValue_SyncActionMessageRange::SyncActionValue_SyncActionMessageRange(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.SyncActionMessageRange) -} -SyncActionValue_SyncActionMessageRange::SyncActionValue_SyncActionMessageRange(const SyncActionValue_SyncActionMessageRange& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncActionValue_SyncActionMessageRange* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.messages_){from._impl_.messages_} - , decltype(_impl_.lastmessagetimestamp_){} - , decltype(_impl_.lastsystemmessagetimestamp_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&_impl_.lastmessagetimestamp_, &from._impl_.lastmessagetimestamp_, - static_cast(reinterpret_cast(&_impl_.lastsystemmessagetimestamp_) - - reinterpret_cast(&_impl_.lastmessagetimestamp_)) + sizeof(_impl_.lastsystemmessagetimestamp_)); - // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.SyncActionMessageRange) -} - -inline void SyncActionValue_SyncActionMessageRange::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.messages_){arena} - , decltype(_impl_.lastmessagetimestamp_){int64_t{0}} - , decltype(_impl_.lastsystemmessagetimestamp_){int64_t{0}} - }; -} - -SyncActionValue_SyncActionMessageRange::~SyncActionValue_SyncActionMessageRange() { - // @@protoc_insertion_point(destructor:proto.SyncActionValue.SyncActionMessageRange) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncActionValue_SyncActionMessageRange::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.messages_.~RepeatedPtrField(); -} - -void SyncActionValue_SyncActionMessageRange::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncActionValue_SyncActionMessageRange::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.SyncActionMessageRange) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.messages_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - ::memset(&_impl_.lastmessagetimestamp_, 0, static_cast( - reinterpret_cast(&_impl_.lastsystemmessagetimestamp_) - - reinterpret_cast(&_impl_.lastmessagetimestamp_)) + sizeof(_impl_.lastsystemmessagetimestamp_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncActionValue_SyncActionMessageRange::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional int64 lastMessageTimestamp = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_lastmessagetimestamp(&has_bits); - _impl_.lastmessagetimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional int64 lastSystemMessageTimestamp = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_lastsystemmessagetimestamp(&has_bits); - _impl_.lastsystemmessagetimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated .proto.SyncActionValue.SyncActionMessage messages = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_messages(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncActionValue_SyncActionMessageRange::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.SyncActionMessageRange) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional int64 lastMessageTimestamp = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_lastmessagetimestamp(), target); - } - - // optional int64 lastSystemMessageTimestamp = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_lastsystemmessagetimestamp(), target); - } - - // repeated .proto.SyncActionValue.SyncActionMessage messages = 3; - for (unsigned i = 0, - n = static_cast(this->_internal_messages_size()); i < n; i++) { - const auto& repfield = this->_internal_messages(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.SyncActionMessageRange) - return target; -} - -size_t SyncActionValue_SyncActionMessageRange::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.SyncActionMessageRange) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.SyncActionValue.SyncActionMessage messages = 3; - total_size += 1UL * this->_internal_messages_size(); - for (const auto& msg : this->_impl_.messages_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional int64 lastMessageTimestamp = 1; - if (cached_has_bits & 0x00000001u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_lastmessagetimestamp()); - } - - // optional int64 lastSystemMessageTimestamp = 2; - if (cached_has_bits & 0x00000002u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_lastsystemmessagetimestamp()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_SyncActionMessageRange::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncActionValue_SyncActionMessageRange::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_SyncActionMessageRange::GetClassData() const { return &_class_data_; } - - -void SyncActionValue_SyncActionMessageRange::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.SyncActionMessageRange) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.messages_.MergeFrom(from._impl_.messages_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_impl_.lastmessagetimestamp_ = from._impl_.lastmessagetimestamp_; - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.lastsystemmessagetimestamp_ = from._impl_.lastsystemmessagetimestamp_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncActionValue_SyncActionMessageRange::CopyFrom(const SyncActionValue_SyncActionMessageRange& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.SyncActionMessageRange) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncActionValue_SyncActionMessageRange::IsInitialized() const { - return true; -} - -void SyncActionValue_SyncActionMessageRange::InternalSwap(SyncActionValue_SyncActionMessageRange* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.messages_.InternalSwap(&other->_impl_.messages_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SyncActionValue_SyncActionMessageRange, _impl_.lastsystemmessagetimestamp_) - + sizeof(SyncActionValue_SyncActionMessageRange::_impl_.lastsystemmessagetimestamp_) - - PROTOBUF_FIELD_OFFSET(SyncActionValue_SyncActionMessageRange, _impl_.lastmessagetimestamp_)>( - reinterpret_cast(&_impl_.lastmessagetimestamp_), - reinterpret_cast(&other->_impl_.lastmessagetimestamp_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_SyncActionMessageRange::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[199]); -} - -// =================================================================== - -class SyncActionValue_SyncActionMessage::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::MessageKey& key(const SyncActionValue_SyncActionMessage* msg); - static void set_has_key(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_timestamp(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -const ::proto::MessageKey& -SyncActionValue_SyncActionMessage::_Internal::key(const SyncActionValue_SyncActionMessage* msg) { - return *msg->_impl_.key_; -} -SyncActionValue_SyncActionMessage::SyncActionValue_SyncActionMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.SyncActionMessage) -} -SyncActionValue_SyncActionMessage::SyncActionValue_SyncActionMessage(const SyncActionValue_SyncActionMessage& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncActionValue_SyncActionMessage* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.key_){nullptr} - , decltype(_impl_.timestamp_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_key()) { - _this->_impl_.key_ = new ::proto::MessageKey(*from._impl_.key_); - } - _this->_impl_.timestamp_ = from._impl_.timestamp_; - // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.SyncActionMessage) -} - -inline void SyncActionValue_SyncActionMessage::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.key_){nullptr} - , decltype(_impl_.timestamp_){int64_t{0}} - }; -} - -SyncActionValue_SyncActionMessage::~SyncActionValue_SyncActionMessage() { - // @@protoc_insertion_point(destructor:proto.SyncActionValue.SyncActionMessage) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncActionValue_SyncActionMessage::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete _impl_.key_; -} - -void SyncActionValue_SyncActionMessage::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncActionValue_SyncActionMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.SyncActionMessage) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.key_ != nullptr); - _impl_.key_->Clear(); - } - _impl_.timestamp_ = int64_t{0}; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncActionValue_SyncActionMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.MessageKey key = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional int64 timestamp = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_timestamp(&has_bits); - _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncActionValue_SyncActionMessage::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.SyncActionMessage) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.MessageKey key = 1; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::key(this), - _Internal::key(this).GetCachedSize(), target, stream); - } - - // optional int64 timestamp = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_timestamp(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.SyncActionMessage) - return target; -} - -size_t SyncActionValue_SyncActionMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.SyncActionMessage) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional .proto.MessageKey key = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.key_); - } - - // optional int64 timestamp = 2; - if (cached_has_bits & 0x00000002u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_timestamp()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_SyncActionMessage::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncActionValue_SyncActionMessage::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_SyncActionMessage::GetClassData() const { return &_class_data_; } - - -void SyncActionValue_SyncActionMessage::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.SyncActionMessage) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_mutable_key()->::proto::MessageKey::MergeFrom( - from._internal_key()); - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.timestamp_ = from._impl_.timestamp_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncActionValue_SyncActionMessage::CopyFrom(const SyncActionValue_SyncActionMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.SyncActionMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncActionValue_SyncActionMessage::IsInitialized() const { - return true; -} - -void SyncActionValue_SyncActionMessage::InternalSwap(SyncActionValue_SyncActionMessage* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SyncActionValue_SyncActionMessage, _impl_.timestamp_) - + sizeof(SyncActionValue_SyncActionMessage::_impl_.timestamp_) - - PROTOBUF_FIELD_OFFSET(SyncActionValue_SyncActionMessage, _impl_.key_)>( - reinterpret_cast(&_impl_.key_), - reinterpret_cast(&other->_impl_.key_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_SyncActionMessage::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[200]); -} - -// =================================================================== - -class SyncActionValue_TimeFormatAction::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_istwentyfourhourformatenabled(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -SyncActionValue_TimeFormatAction::SyncActionValue_TimeFormatAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.TimeFormatAction) -} -SyncActionValue_TimeFormatAction::SyncActionValue_TimeFormatAction(const SyncActionValue_TimeFormatAction& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncActionValue_TimeFormatAction* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.istwentyfourhourformatenabled_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _this->_impl_.istwentyfourhourformatenabled_ = from._impl_.istwentyfourhourformatenabled_; - // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.TimeFormatAction) -} - -inline void SyncActionValue_TimeFormatAction::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.istwentyfourhourformatenabled_){false} - }; -} - -SyncActionValue_TimeFormatAction::~SyncActionValue_TimeFormatAction() { - // @@protoc_insertion_point(destructor:proto.SyncActionValue.TimeFormatAction) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncActionValue_TimeFormatAction::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void SyncActionValue_TimeFormatAction::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncActionValue_TimeFormatAction::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.TimeFormatAction) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.istwentyfourhourformatenabled_ = false; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncActionValue_TimeFormatAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bool isTwentyFourHourFormatEnabled = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_istwentyfourhourformatenabled(&has_bits); - _impl_.istwentyfourhourformatenabled_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncActionValue_TimeFormatAction::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.TimeFormatAction) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bool isTwentyFourHourFormatEnabled = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_istwentyfourhourformatenabled(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.TimeFormatAction) - return target; -} - -size_t SyncActionValue_TimeFormatAction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.TimeFormatAction) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional bool isTwentyFourHourFormatEnabled = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + 1; - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_TimeFormatAction::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncActionValue_TimeFormatAction::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_TimeFormatAction::GetClassData() const { return &_class_data_; } - - -void SyncActionValue_TimeFormatAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.TimeFormatAction) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_istwentyfourhourformatenabled()) { - _this->_internal_set_istwentyfourhourformatenabled(from._internal_istwentyfourhourformatenabled()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncActionValue_TimeFormatAction::CopyFrom(const SyncActionValue_TimeFormatAction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.TimeFormatAction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncActionValue_TimeFormatAction::IsInitialized() const { - return true; -} - -void SyncActionValue_TimeFormatAction::InternalSwap(SyncActionValue_TimeFormatAction* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - swap(_impl_.istwentyfourhourformatenabled_, other->_impl_.istwentyfourhourformatenabled_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_TimeFormatAction::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[201]); -} - -// =================================================================== - -class SyncActionValue_UnarchiveChatsSetting::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_unarchivechats(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -SyncActionValue_UnarchiveChatsSetting::SyncActionValue_UnarchiveChatsSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.UnarchiveChatsSetting) -} -SyncActionValue_UnarchiveChatsSetting::SyncActionValue_UnarchiveChatsSetting(const SyncActionValue_UnarchiveChatsSetting& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncActionValue_UnarchiveChatsSetting* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.unarchivechats_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _this->_impl_.unarchivechats_ = from._impl_.unarchivechats_; - // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.UnarchiveChatsSetting) -} - -inline void SyncActionValue_UnarchiveChatsSetting::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.unarchivechats_){false} - }; -} - -SyncActionValue_UnarchiveChatsSetting::~SyncActionValue_UnarchiveChatsSetting() { - // @@protoc_insertion_point(destructor:proto.SyncActionValue.UnarchiveChatsSetting) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncActionValue_UnarchiveChatsSetting::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void SyncActionValue_UnarchiveChatsSetting::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncActionValue_UnarchiveChatsSetting::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.UnarchiveChatsSetting) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.unarchivechats_ = false; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncActionValue_UnarchiveChatsSetting::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bool unarchiveChats = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_unarchivechats(&has_bits); - _impl_.unarchivechats_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncActionValue_UnarchiveChatsSetting::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.UnarchiveChatsSetting) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bool unarchiveChats = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_unarchivechats(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.UnarchiveChatsSetting) - return target; -} - -size_t SyncActionValue_UnarchiveChatsSetting::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.UnarchiveChatsSetting) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional bool unarchiveChats = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + 1; - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_UnarchiveChatsSetting::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncActionValue_UnarchiveChatsSetting::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_UnarchiveChatsSetting::GetClassData() const { return &_class_data_; } - - -void SyncActionValue_UnarchiveChatsSetting::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.UnarchiveChatsSetting) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_unarchivechats()) { - _this->_internal_set_unarchivechats(from._internal_unarchivechats()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncActionValue_UnarchiveChatsSetting::CopyFrom(const SyncActionValue_UnarchiveChatsSetting& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.UnarchiveChatsSetting) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncActionValue_UnarchiveChatsSetting::IsInitialized() const { - return true; -} - -void SyncActionValue_UnarchiveChatsSetting::InternalSwap(SyncActionValue_UnarchiveChatsSetting* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - swap(_impl_.unarchivechats_, other->_impl_.unarchivechats_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_UnarchiveChatsSetting::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[202]); -} - -// =================================================================== - -class SyncActionValue_UserStatusMuteAction::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_muted(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -SyncActionValue_UserStatusMuteAction::SyncActionValue_UserStatusMuteAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue.UserStatusMuteAction) -} -SyncActionValue_UserStatusMuteAction::SyncActionValue_UserStatusMuteAction(const SyncActionValue_UserStatusMuteAction& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncActionValue_UserStatusMuteAction* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.muted_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _this->_impl_.muted_ = from._impl_.muted_; - // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue.UserStatusMuteAction) -} - -inline void SyncActionValue_UserStatusMuteAction::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.muted_){false} - }; -} - -SyncActionValue_UserStatusMuteAction::~SyncActionValue_UserStatusMuteAction() { - // @@protoc_insertion_point(destructor:proto.SyncActionValue.UserStatusMuteAction) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncActionValue_UserStatusMuteAction::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void SyncActionValue_UserStatusMuteAction::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncActionValue_UserStatusMuteAction::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue.UserStatusMuteAction) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.muted_ = false; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncActionValue_UserStatusMuteAction::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bool muted = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_muted(&has_bits); - _impl_.muted_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncActionValue_UserStatusMuteAction::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue.UserStatusMuteAction) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bool muted = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_muted(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue.UserStatusMuteAction) - return target; -} - -size_t SyncActionValue_UserStatusMuteAction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue.UserStatusMuteAction) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional bool muted = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + 1; - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue_UserStatusMuteAction::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncActionValue_UserStatusMuteAction::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue_UserStatusMuteAction::GetClassData() const { return &_class_data_; } - - -void SyncActionValue_UserStatusMuteAction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue.UserStatusMuteAction) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_muted()) { - _this->_internal_set_muted(from._internal_muted()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncActionValue_UserStatusMuteAction::CopyFrom(const SyncActionValue_UserStatusMuteAction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue.UserStatusMuteAction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncActionValue_UserStatusMuteAction::IsInitialized() const { - return true; -} - -void SyncActionValue_UserStatusMuteAction::InternalSwap(SyncActionValue_UserStatusMuteAction* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - swap(_impl_.muted_, other->_impl_.muted_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue_UserStatusMuteAction::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[203]); -} - -// =================================================================== - -class SyncActionValue::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_timestamp(HasBits* has_bits) { - (*has_bits)[0] |= 134217728u; - } - static const ::proto::SyncActionValue_StarAction& staraction(const SyncActionValue* msg); - static void set_has_staraction(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::proto::SyncActionValue_ContactAction& contactaction(const SyncActionValue* msg); - static void set_has_contactaction(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::proto::SyncActionValue_MuteAction& muteaction(const SyncActionValue* msg); - static void set_has_muteaction(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static const ::proto::SyncActionValue_PinAction& pinaction(const SyncActionValue* msg); - static void set_has_pinaction(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static const ::proto::SyncActionValue_SecurityNotificationSetting& securitynotificationsetting(const SyncActionValue* msg); - static void set_has_securitynotificationsetting(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static const ::proto::SyncActionValue_PushNameSetting& pushnamesetting(const SyncActionValue* msg); - static void set_has_pushnamesetting(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static const ::proto::SyncActionValue_QuickReplyAction& quickreplyaction(const SyncActionValue* msg); - static void set_has_quickreplyaction(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static const ::proto::SyncActionValue_RecentEmojiWeightsAction& recentemojiweightsaction(const SyncActionValue* msg); - static void set_has_recentemojiweightsaction(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } - static const ::proto::SyncActionValue_LabelEditAction& labeleditaction(const SyncActionValue* msg); - static void set_has_labeleditaction(HasBits* has_bits) { - (*has_bits)[0] |= 256u; - } - static const ::proto::SyncActionValue_LabelAssociationAction& labelassociationaction(const SyncActionValue* msg); - static void set_has_labelassociationaction(HasBits* has_bits) { - (*has_bits)[0] |= 512u; - } - static const ::proto::SyncActionValue_LocaleSetting& localesetting(const SyncActionValue* msg); - static void set_has_localesetting(HasBits* has_bits) { - (*has_bits)[0] |= 1024u; - } - static const ::proto::SyncActionValue_ArchiveChatAction& archivechataction(const SyncActionValue* msg); - static void set_has_archivechataction(HasBits* has_bits) { - (*has_bits)[0] |= 2048u; - } - static const ::proto::SyncActionValue_DeleteMessageForMeAction& deletemessageformeaction(const SyncActionValue* msg); - static void set_has_deletemessageformeaction(HasBits* has_bits) { - (*has_bits)[0] |= 4096u; - } - static const ::proto::SyncActionValue_KeyExpiration& keyexpiration(const SyncActionValue* msg); - static void set_has_keyexpiration(HasBits* has_bits) { - (*has_bits)[0] |= 8192u; - } - static const ::proto::SyncActionValue_MarkChatAsReadAction& markchatasreadaction(const SyncActionValue* msg); - static void set_has_markchatasreadaction(HasBits* has_bits) { - (*has_bits)[0] |= 16384u; - } - static const ::proto::SyncActionValue_ClearChatAction& clearchataction(const SyncActionValue* msg); - static void set_has_clearchataction(HasBits* has_bits) { - (*has_bits)[0] |= 32768u; - } - static const ::proto::SyncActionValue_DeleteChatAction& deletechataction(const SyncActionValue* msg); - static void set_has_deletechataction(HasBits* has_bits) { - (*has_bits)[0] |= 65536u; - } - static const ::proto::SyncActionValue_UnarchiveChatsSetting& unarchivechatssetting(const SyncActionValue* msg); - static void set_has_unarchivechatssetting(HasBits* has_bits) { - (*has_bits)[0] |= 131072u; - } - static const ::proto::SyncActionValue_PrimaryFeature& primaryfeature(const SyncActionValue* msg); - static void set_has_primaryfeature(HasBits* has_bits) { - (*has_bits)[0] |= 262144u; - } - static const ::proto::SyncActionValue_AndroidUnsupportedActions& androidunsupportedactions(const SyncActionValue* msg); - static void set_has_androidunsupportedactions(HasBits* has_bits) { - (*has_bits)[0] |= 524288u; - } - static const ::proto::SyncActionValue_AgentAction& agentaction(const SyncActionValue* msg); - static void set_has_agentaction(HasBits* has_bits) { - (*has_bits)[0] |= 1048576u; - } - static const ::proto::SyncActionValue_SubscriptionAction& subscriptionaction(const SyncActionValue* msg); - static void set_has_subscriptionaction(HasBits* has_bits) { - (*has_bits)[0] |= 2097152u; - } - static const ::proto::SyncActionValue_UserStatusMuteAction& userstatusmuteaction(const SyncActionValue* msg); - static void set_has_userstatusmuteaction(HasBits* has_bits) { - (*has_bits)[0] |= 4194304u; - } - static const ::proto::SyncActionValue_TimeFormatAction& timeformataction(const SyncActionValue* msg); - static void set_has_timeformataction(HasBits* has_bits) { - (*has_bits)[0] |= 8388608u; - } - static const ::proto::SyncActionValue_NuxAction& nuxaction(const SyncActionValue* msg); - static void set_has_nuxaction(HasBits* has_bits) { - (*has_bits)[0] |= 16777216u; - } - static const ::proto::SyncActionValue_PrimaryVersionAction& primaryversionaction(const SyncActionValue* msg); - static void set_has_primaryversionaction(HasBits* has_bits) { - (*has_bits)[0] |= 33554432u; - } - static const ::proto::SyncActionValue_StickerAction& stickeraction(const SyncActionValue* msg); - static void set_has_stickeraction(HasBits* has_bits) { - (*has_bits)[0] |= 67108864u; - } -}; - -const ::proto::SyncActionValue_StarAction& -SyncActionValue::_Internal::staraction(const SyncActionValue* msg) { - return *msg->_impl_.staraction_; -} -const ::proto::SyncActionValue_ContactAction& -SyncActionValue::_Internal::contactaction(const SyncActionValue* msg) { - return *msg->_impl_.contactaction_; -} -const ::proto::SyncActionValue_MuteAction& -SyncActionValue::_Internal::muteaction(const SyncActionValue* msg) { - return *msg->_impl_.muteaction_; -} -const ::proto::SyncActionValue_PinAction& -SyncActionValue::_Internal::pinaction(const SyncActionValue* msg) { - return *msg->_impl_.pinaction_; -} -const ::proto::SyncActionValue_SecurityNotificationSetting& -SyncActionValue::_Internal::securitynotificationsetting(const SyncActionValue* msg) { - return *msg->_impl_.securitynotificationsetting_; -} -const ::proto::SyncActionValue_PushNameSetting& -SyncActionValue::_Internal::pushnamesetting(const SyncActionValue* msg) { - return *msg->_impl_.pushnamesetting_; -} -const ::proto::SyncActionValue_QuickReplyAction& -SyncActionValue::_Internal::quickreplyaction(const SyncActionValue* msg) { - return *msg->_impl_.quickreplyaction_; -} -const ::proto::SyncActionValue_RecentEmojiWeightsAction& -SyncActionValue::_Internal::recentemojiweightsaction(const SyncActionValue* msg) { - return *msg->_impl_.recentemojiweightsaction_; -} -const ::proto::SyncActionValue_LabelEditAction& -SyncActionValue::_Internal::labeleditaction(const SyncActionValue* msg) { - return *msg->_impl_.labeleditaction_; -} -const ::proto::SyncActionValue_LabelAssociationAction& -SyncActionValue::_Internal::labelassociationaction(const SyncActionValue* msg) { - return *msg->_impl_.labelassociationaction_; -} -const ::proto::SyncActionValue_LocaleSetting& -SyncActionValue::_Internal::localesetting(const SyncActionValue* msg) { - return *msg->_impl_.localesetting_; -} -const ::proto::SyncActionValue_ArchiveChatAction& -SyncActionValue::_Internal::archivechataction(const SyncActionValue* msg) { - return *msg->_impl_.archivechataction_; -} -const ::proto::SyncActionValue_DeleteMessageForMeAction& -SyncActionValue::_Internal::deletemessageformeaction(const SyncActionValue* msg) { - return *msg->_impl_.deletemessageformeaction_; -} -const ::proto::SyncActionValue_KeyExpiration& -SyncActionValue::_Internal::keyexpiration(const SyncActionValue* msg) { - return *msg->_impl_.keyexpiration_; -} -const ::proto::SyncActionValue_MarkChatAsReadAction& -SyncActionValue::_Internal::markchatasreadaction(const SyncActionValue* msg) { - return *msg->_impl_.markchatasreadaction_; -} -const ::proto::SyncActionValue_ClearChatAction& -SyncActionValue::_Internal::clearchataction(const SyncActionValue* msg) { - return *msg->_impl_.clearchataction_; -} -const ::proto::SyncActionValue_DeleteChatAction& -SyncActionValue::_Internal::deletechataction(const SyncActionValue* msg) { - return *msg->_impl_.deletechataction_; -} -const ::proto::SyncActionValue_UnarchiveChatsSetting& -SyncActionValue::_Internal::unarchivechatssetting(const SyncActionValue* msg) { - return *msg->_impl_.unarchivechatssetting_; -} -const ::proto::SyncActionValue_PrimaryFeature& -SyncActionValue::_Internal::primaryfeature(const SyncActionValue* msg) { - return *msg->_impl_.primaryfeature_; -} -const ::proto::SyncActionValue_AndroidUnsupportedActions& -SyncActionValue::_Internal::androidunsupportedactions(const SyncActionValue* msg) { - return *msg->_impl_.androidunsupportedactions_; -} -const ::proto::SyncActionValue_AgentAction& -SyncActionValue::_Internal::agentaction(const SyncActionValue* msg) { - return *msg->_impl_.agentaction_; -} -const ::proto::SyncActionValue_SubscriptionAction& -SyncActionValue::_Internal::subscriptionaction(const SyncActionValue* msg) { - return *msg->_impl_.subscriptionaction_; -} -const ::proto::SyncActionValue_UserStatusMuteAction& -SyncActionValue::_Internal::userstatusmuteaction(const SyncActionValue* msg) { - return *msg->_impl_.userstatusmuteaction_; -} -const ::proto::SyncActionValue_TimeFormatAction& -SyncActionValue::_Internal::timeformataction(const SyncActionValue* msg) { - return *msg->_impl_.timeformataction_; -} -const ::proto::SyncActionValue_NuxAction& -SyncActionValue::_Internal::nuxaction(const SyncActionValue* msg) { - return *msg->_impl_.nuxaction_; -} -const ::proto::SyncActionValue_PrimaryVersionAction& -SyncActionValue::_Internal::primaryversionaction(const SyncActionValue* msg) { - return *msg->_impl_.primaryversionaction_; -} -const ::proto::SyncActionValue_StickerAction& -SyncActionValue::_Internal::stickeraction(const SyncActionValue* msg) { - return *msg->_impl_.stickeraction_; -} -SyncActionValue::SyncActionValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncActionValue) -} -SyncActionValue::SyncActionValue(const SyncActionValue& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncActionValue* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.staraction_){nullptr} - , decltype(_impl_.contactaction_){nullptr} - , decltype(_impl_.muteaction_){nullptr} - , decltype(_impl_.pinaction_){nullptr} - , decltype(_impl_.securitynotificationsetting_){nullptr} - , decltype(_impl_.pushnamesetting_){nullptr} - , decltype(_impl_.quickreplyaction_){nullptr} - , decltype(_impl_.recentemojiweightsaction_){nullptr} - , decltype(_impl_.labeleditaction_){nullptr} - , decltype(_impl_.labelassociationaction_){nullptr} - , decltype(_impl_.localesetting_){nullptr} - , decltype(_impl_.archivechataction_){nullptr} - , decltype(_impl_.deletemessageformeaction_){nullptr} - , decltype(_impl_.keyexpiration_){nullptr} - , decltype(_impl_.markchatasreadaction_){nullptr} - , decltype(_impl_.clearchataction_){nullptr} - , decltype(_impl_.deletechataction_){nullptr} - , decltype(_impl_.unarchivechatssetting_){nullptr} - , decltype(_impl_.primaryfeature_){nullptr} - , decltype(_impl_.androidunsupportedactions_){nullptr} - , decltype(_impl_.agentaction_){nullptr} - , decltype(_impl_.subscriptionaction_){nullptr} - , decltype(_impl_.userstatusmuteaction_){nullptr} - , decltype(_impl_.timeformataction_){nullptr} - , decltype(_impl_.nuxaction_){nullptr} - , decltype(_impl_.primaryversionaction_){nullptr} - , decltype(_impl_.stickeraction_){nullptr} - , decltype(_impl_.timestamp_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_staraction()) { - _this->_impl_.staraction_ = new ::proto::SyncActionValue_StarAction(*from._impl_.staraction_); - } - if (from._internal_has_contactaction()) { - _this->_impl_.contactaction_ = new ::proto::SyncActionValue_ContactAction(*from._impl_.contactaction_); - } - if (from._internal_has_muteaction()) { - _this->_impl_.muteaction_ = new ::proto::SyncActionValue_MuteAction(*from._impl_.muteaction_); - } - if (from._internal_has_pinaction()) { - _this->_impl_.pinaction_ = new ::proto::SyncActionValue_PinAction(*from._impl_.pinaction_); - } - if (from._internal_has_securitynotificationsetting()) { - _this->_impl_.securitynotificationsetting_ = new ::proto::SyncActionValue_SecurityNotificationSetting(*from._impl_.securitynotificationsetting_); - } - if (from._internal_has_pushnamesetting()) { - _this->_impl_.pushnamesetting_ = new ::proto::SyncActionValue_PushNameSetting(*from._impl_.pushnamesetting_); - } - if (from._internal_has_quickreplyaction()) { - _this->_impl_.quickreplyaction_ = new ::proto::SyncActionValue_QuickReplyAction(*from._impl_.quickreplyaction_); - } - if (from._internal_has_recentemojiweightsaction()) { - _this->_impl_.recentemojiweightsaction_ = new ::proto::SyncActionValue_RecentEmojiWeightsAction(*from._impl_.recentemojiweightsaction_); - } - if (from._internal_has_labeleditaction()) { - _this->_impl_.labeleditaction_ = new ::proto::SyncActionValue_LabelEditAction(*from._impl_.labeleditaction_); - } - if (from._internal_has_labelassociationaction()) { - _this->_impl_.labelassociationaction_ = new ::proto::SyncActionValue_LabelAssociationAction(*from._impl_.labelassociationaction_); - } - if (from._internal_has_localesetting()) { - _this->_impl_.localesetting_ = new ::proto::SyncActionValue_LocaleSetting(*from._impl_.localesetting_); - } - if (from._internal_has_archivechataction()) { - _this->_impl_.archivechataction_ = new ::proto::SyncActionValue_ArchiveChatAction(*from._impl_.archivechataction_); - } - if (from._internal_has_deletemessageformeaction()) { - _this->_impl_.deletemessageformeaction_ = new ::proto::SyncActionValue_DeleteMessageForMeAction(*from._impl_.deletemessageformeaction_); - } - if (from._internal_has_keyexpiration()) { - _this->_impl_.keyexpiration_ = new ::proto::SyncActionValue_KeyExpiration(*from._impl_.keyexpiration_); - } - if (from._internal_has_markchatasreadaction()) { - _this->_impl_.markchatasreadaction_ = new ::proto::SyncActionValue_MarkChatAsReadAction(*from._impl_.markchatasreadaction_); - } - if (from._internal_has_clearchataction()) { - _this->_impl_.clearchataction_ = new ::proto::SyncActionValue_ClearChatAction(*from._impl_.clearchataction_); - } - if (from._internal_has_deletechataction()) { - _this->_impl_.deletechataction_ = new ::proto::SyncActionValue_DeleteChatAction(*from._impl_.deletechataction_); - } - if (from._internal_has_unarchivechatssetting()) { - _this->_impl_.unarchivechatssetting_ = new ::proto::SyncActionValue_UnarchiveChatsSetting(*from._impl_.unarchivechatssetting_); - } - if (from._internal_has_primaryfeature()) { - _this->_impl_.primaryfeature_ = new ::proto::SyncActionValue_PrimaryFeature(*from._impl_.primaryfeature_); - } - if (from._internal_has_androidunsupportedactions()) { - _this->_impl_.androidunsupportedactions_ = new ::proto::SyncActionValue_AndroidUnsupportedActions(*from._impl_.androidunsupportedactions_); - } - if (from._internal_has_agentaction()) { - _this->_impl_.agentaction_ = new ::proto::SyncActionValue_AgentAction(*from._impl_.agentaction_); - } - if (from._internal_has_subscriptionaction()) { - _this->_impl_.subscriptionaction_ = new ::proto::SyncActionValue_SubscriptionAction(*from._impl_.subscriptionaction_); - } - if (from._internal_has_userstatusmuteaction()) { - _this->_impl_.userstatusmuteaction_ = new ::proto::SyncActionValue_UserStatusMuteAction(*from._impl_.userstatusmuteaction_); - } - if (from._internal_has_timeformataction()) { - _this->_impl_.timeformataction_ = new ::proto::SyncActionValue_TimeFormatAction(*from._impl_.timeformataction_); - } - if (from._internal_has_nuxaction()) { - _this->_impl_.nuxaction_ = new ::proto::SyncActionValue_NuxAction(*from._impl_.nuxaction_); - } - if (from._internal_has_primaryversionaction()) { - _this->_impl_.primaryversionaction_ = new ::proto::SyncActionValue_PrimaryVersionAction(*from._impl_.primaryversionaction_); - } - if (from._internal_has_stickeraction()) { - _this->_impl_.stickeraction_ = new ::proto::SyncActionValue_StickerAction(*from._impl_.stickeraction_); - } - _this->_impl_.timestamp_ = from._impl_.timestamp_; - // @@protoc_insertion_point(copy_constructor:proto.SyncActionValue) -} - -inline void SyncActionValue::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.staraction_){nullptr} - , decltype(_impl_.contactaction_){nullptr} - , decltype(_impl_.muteaction_){nullptr} - , decltype(_impl_.pinaction_){nullptr} - , decltype(_impl_.securitynotificationsetting_){nullptr} - , decltype(_impl_.pushnamesetting_){nullptr} - , decltype(_impl_.quickreplyaction_){nullptr} - , decltype(_impl_.recentemojiweightsaction_){nullptr} - , decltype(_impl_.labeleditaction_){nullptr} - , decltype(_impl_.labelassociationaction_){nullptr} - , decltype(_impl_.localesetting_){nullptr} - , decltype(_impl_.archivechataction_){nullptr} - , decltype(_impl_.deletemessageformeaction_){nullptr} - , decltype(_impl_.keyexpiration_){nullptr} - , decltype(_impl_.markchatasreadaction_){nullptr} - , decltype(_impl_.clearchataction_){nullptr} - , decltype(_impl_.deletechataction_){nullptr} - , decltype(_impl_.unarchivechatssetting_){nullptr} - , decltype(_impl_.primaryfeature_){nullptr} - , decltype(_impl_.androidunsupportedactions_){nullptr} - , decltype(_impl_.agentaction_){nullptr} - , decltype(_impl_.subscriptionaction_){nullptr} - , decltype(_impl_.userstatusmuteaction_){nullptr} - , decltype(_impl_.timeformataction_){nullptr} - , decltype(_impl_.nuxaction_){nullptr} - , decltype(_impl_.primaryversionaction_){nullptr} - , decltype(_impl_.stickeraction_){nullptr} - , decltype(_impl_.timestamp_){int64_t{0}} - }; -} - -SyncActionValue::~SyncActionValue() { - // @@protoc_insertion_point(destructor:proto.SyncActionValue) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncActionValue::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete _impl_.staraction_; - if (this != internal_default_instance()) delete _impl_.contactaction_; - if (this != internal_default_instance()) delete _impl_.muteaction_; - if (this != internal_default_instance()) delete _impl_.pinaction_; - if (this != internal_default_instance()) delete _impl_.securitynotificationsetting_; - if (this != internal_default_instance()) delete _impl_.pushnamesetting_; - if (this != internal_default_instance()) delete _impl_.quickreplyaction_; - if (this != internal_default_instance()) delete _impl_.recentemojiweightsaction_; - if (this != internal_default_instance()) delete _impl_.labeleditaction_; - if (this != internal_default_instance()) delete _impl_.labelassociationaction_; - if (this != internal_default_instance()) delete _impl_.localesetting_; - if (this != internal_default_instance()) delete _impl_.archivechataction_; - if (this != internal_default_instance()) delete _impl_.deletemessageformeaction_; - if (this != internal_default_instance()) delete _impl_.keyexpiration_; - if (this != internal_default_instance()) delete _impl_.markchatasreadaction_; - if (this != internal_default_instance()) delete _impl_.clearchataction_; - if (this != internal_default_instance()) delete _impl_.deletechataction_; - if (this != internal_default_instance()) delete _impl_.unarchivechatssetting_; - if (this != internal_default_instance()) delete _impl_.primaryfeature_; - if (this != internal_default_instance()) delete _impl_.androidunsupportedactions_; - if (this != internal_default_instance()) delete _impl_.agentaction_; - if (this != internal_default_instance()) delete _impl_.subscriptionaction_; - if (this != internal_default_instance()) delete _impl_.userstatusmuteaction_; - if (this != internal_default_instance()) delete _impl_.timeformataction_; - if (this != internal_default_instance()) delete _impl_.nuxaction_; - if (this != internal_default_instance()) delete _impl_.primaryversionaction_; - if (this != internal_default_instance()) delete _impl_.stickeraction_; -} - -void SyncActionValue::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncActionValue::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncActionValue) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.staraction_ != nullptr); - _impl_.staraction_->Clear(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.contactaction_ != nullptr); - _impl_.contactaction_->Clear(); - } - if (cached_has_bits & 0x00000004u) { - GOOGLE_DCHECK(_impl_.muteaction_ != nullptr); - _impl_.muteaction_->Clear(); - } - if (cached_has_bits & 0x00000008u) { - GOOGLE_DCHECK(_impl_.pinaction_ != nullptr); - _impl_.pinaction_->Clear(); - } - if (cached_has_bits & 0x00000010u) { - GOOGLE_DCHECK(_impl_.securitynotificationsetting_ != nullptr); - _impl_.securitynotificationsetting_->Clear(); - } - if (cached_has_bits & 0x00000020u) { - GOOGLE_DCHECK(_impl_.pushnamesetting_ != nullptr); - _impl_.pushnamesetting_->Clear(); - } - if (cached_has_bits & 0x00000040u) { - GOOGLE_DCHECK(_impl_.quickreplyaction_ != nullptr); - _impl_.quickreplyaction_->Clear(); - } - if (cached_has_bits & 0x00000080u) { - GOOGLE_DCHECK(_impl_.recentemojiweightsaction_ != nullptr); - _impl_.recentemojiweightsaction_->Clear(); - } - } - if (cached_has_bits & 0x0000ff00u) { - if (cached_has_bits & 0x00000100u) { - GOOGLE_DCHECK(_impl_.labeleditaction_ != nullptr); - _impl_.labeleditaction_->Clear(); - } - if (cached_has_bits & 0x00000200u) { - GOOGLE_DCHECK(_impl_.labelassociationaction_ != nullptr); - _impl_.labelassociationaction_->Clear(); - } - if (cached_has_bits & 0x00000400u) { - GOOGLE_DCHECK(_impl_.localesetting_ != nullptr); - _impl_.localesetting_->Clear(); - } - if (cached_has_bits & 0x00000800u) { - GOOGLE_DCHECK(_impl_.archivechataction_ != nullptr); - _impl_.archivechataction_->Clear(); - } - if (cached_has_bits & 0x00001000u) { - GOOGLE_DCHECK(_impl_.deletemessageformeaction_ != nullptr); - _impl_.deletemessageformeaction_->Clear(); - } - if (cached_has_bits & 0x00002000u) { - GOOGLE_DCHECK(_impl_.keyexpiration_ != nullptr); - _impl_.keyexpiration_->Clear(); - } - if (cached_has_bits & 0x00004000u) { - GOOGLE_DCHECK(_impl_.markchatasreadaction_ != nullptr); - _impl_.markchatasreadaction_->Clear(); - } - if (cached_has_bits & 0x00008000u) { - GOOGLE_DCHECK(_impl_.clearchataction_ != nullptr); - _impl_.clearchataction_->Clear(); - } - } - if (cached_has_bits & 0x00ff0000u) { - if (cached_has_bits & 0x00010000u) { - GOOGLE_DCHECK(_impl_.deletechataction_ != nullptr); - _impl_.deletechataction_->Clear(); - } - if (cached_has_bits & 0x00020000u) { - GOOGLE_DCHECK(_impl_.unarchivechatssetting_ != nullptr); - _impl_.unarchivechatssetting_->Clear(); - } - if (cached_has_bits & 0x00040000u) { - GOOGLE_DCHECK(_impl_.primaryfeature_ != nullptr); - _impl_.primaryfeature_->Clear(); - } - if (cached_has_bits & 0x00080000u) { - GOOGLE_DCHECK(_impl_.androidunsupportedactions_ != nullptr); - _impl_.androidunsupportedactions_->Clear(); - } - if (cached_has_bits & 0x00100000u) { - GOOGLE_DCHECK(_impl_.agentaction_ != nullptr); - _impl_.agentaction_->Clear(); - } - if (cached_has_bits & 0x00200000u) { - GOOGLE_DCHECK(_impl_.subscriptionaction_ != nullptr); - _impl_.subscriptionaction_->Clear(); - } - if (cached_has_bits & 0x00400000u) { - GOOGLE_DCHECK(_impl_.userstatusmuteaction_ != nullptr); - _impl_.userstatusmuteaction_->Clear(); - } - if (cached_has_bits & 0x00800000u) { - GOOGLE_DCHECK(_impl_.timeformataction_ != nullptr); - _impl_.timeformataction_->Clear(); - } - } - if (cached_has_bits & 0x07000000u) { - if (cached_has_bits & 0x01000000u) { - GOOGLE_DCHECK(_impl_.nuxaction_ != nullptr); - _impl_.nuxaction_->Clear(); - } - if (cached_has_bits & 0x02000000u) { - GOOGLE_DCHECK(_impl_.primaryversionaction_ != nullptr); - _impl_.primaryversionaction_->Clear(); - } - if (cached_has_bits & 0x04000000u) { - GOOGLE_DCHECK(_impl_.stickeraction_ != nullptr); - _impl_.stickeraction_->Clear(); - } - } - _impl_.timestamp_ = int64_t{0}; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncActionValue::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional int64 timestamp = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_timestamp(&has_bits); - _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SyncActionValue.StarAction starAction = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_staraction(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SyncActionValue.ContactAction contactAction = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_contactaction(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SyncActionValue.MuteAction muteAction = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_muteaction(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SyncActionValue.PinAction pinAction = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - ptr = ctx->ParseMessage(_internal_mutable_pinaction(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SyncActionValue.SecurityNotificationSetting securityNotificationSetting = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - ptr = ctx->ParseMessage(_internal_mutable_securitynotificationsetting(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SyncActionValue.PushNameSetting pushNameSetting = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - ptr = ctx->ParseMessage(_internal_mutable_pushnamesetting(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SyncActionValue.QuickReplyAction quickReplyAction = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { - ptr = ctx->ParseMessage(_internal_mutable_quickreplyaction(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SyncActionValue.RecentEmojiWeightsAction recentEmojiWeightsAction = 11; - case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { - ptr = ctx->ParseMessage(_internal_mutable_recentemojiweightsaction(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SyncActionValue.LabelEditAction labelEditAction = 14; - case 14: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) { - ptr = ctx->ParseMessage(_internal_mutable_labeleditaction(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SyncActionValue.LabelAssociationAction labelAssociationAction = 15; - case 15: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { - ptr = ctx->ParseMessage(_internal_mutable_labelassociationaction(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SyncActionValue.LocaleSetting localeSetting = 16; - case 16: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { - ptr = ctx->ParseMessage(_internal_mutable_localesetting(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SyncActionValue.ArchiveChatAction archiveChatAction = 17; - case 17: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { - ptr = ctx->ParseMessage(_internal_mutable_archivechataction(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SyncActionValue.DeleteMessageForMeAction deleteMessageForMeAction = 18; - case 18: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { - ptr = ctx->ParseMessage(_internal_mutable_deletemessageformeaction(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SyncActionValue.KeyExpiration keyExpiration = 19; - case 19: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) { - ptr = ctx->ParseMessage(_internal_mutable_keyexpiration(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SyncActionValue.MarkChatAsReadAction markChatAsReadAction = 20; - case 20: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 162)) { - ptr = ctx->ParseMessage(_internal_mutable_markchatasreadaction(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SyncActionValue.ClearChatAction clearChatAction = 21; - case 21: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { - ptr = ctx->ParseMessage(_internal_mutable_clearchataction(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SyncActionValue.DeleteChatAction deleteChatAction = 22; - case 22: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 178)) { - ptr = ctx->ParseMessage(_internal_mutable_deletechataction(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SyncActionValue.UnarchiveChatsSetting unarchiveChatsSetting = 23; - case 23: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { - ptr = ctx->ParseMessage(_internal_mutable_unarchivechatssetting(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SyncActionValue.PrimaryFeature primaryFeature = 24; - case 24: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 194)) { - ptr = ctx->ParseMessage(_internal_mutable_primaryfeature(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SyncActionValue.AndroidUnsupportedActions androidUnsupportedActions = 26; - case 26: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 210)) { - ptr = ctx->ParseMessage(_internal_mutable_androidunsupportedactions(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SyncActionValue.AgentAction agentAction = 27; - case 27: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 218)) { - ptr = ctx->ParseMessage(_internal_mutable_agentaction(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SyncActionValue.SubscriptionAction subscriptionAction = 28; - case 28: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 226)) { - ptr = ctx->ParseMessage(_internal_mutable_subscriptionaction(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SyncActionValue.UserStatusMuteAction userStatusMuteAction = 29; - case 29: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 234)) { - ptr = ctx->ParseMessage(_internal_mutable_userstatusmuteaction(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SyncActionValue.TimeFormatAction timeFormatAction = 30; - case 30: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 242)) { - ptr = ctx->ParseMessage(_internal_mutable_timeformataction(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SyncActionValue.NuxAction nuxAction = 31; - case 31: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 250)) { - ptr = ctx->ParseMessage(_internal_mutable_nuxaction(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SyncActionValue.PrimaryVersionAction primaryVersionAction = 32; - case 32: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 2)) { - ptr = ctx->ParseMessage(_internal_mutable_primaryversionaction(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SyncActionValue.StickerAction stickerAction = 33; - case 33: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_stickeraction(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncActionValue::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncActionValue) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional int64 timestamp = 1; - if (cached_has_bits & 0x08000000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_timestamp(), target); - } - - // optional .proto.SyncActionValue.StarAction starAction = 2; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::staraction(this), - _Internal::staraction(this).GetCachedSize(), target, stream); - } - - // optional .proto.SyncActionValue.ContactAction contactAction = 3; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, _Internal::contactaction(this), - _Internal::contactaction(this).GetCachedSize(), target, stream); - } - - // optional .proto.SyncActionValue.MuteAction muteAction = 4; - if (cached_has_bits & 0x00000004u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(4, _Internal::muteaction(this), - _Internal::muteaction(this).GetCachedSize(), target, stream); - } - - // optional .proto.SyncActionValue.PinAction pinAction = 5; - if (cached_has_bits & 0x00000008u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(5, _Internal::pinaction(this), - _Internal::pinaction(this).GetCachedSize(), target, stream); - } - - // optional .proto.SyncActionValue.SecurityNotificationSetting securityNotificationSetting = 6; - if (cached_has_bits & 0x00000010u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(6, _Internal::securitynotificationsetting(this), - _Internal::securitynotificationsetting(this).GetCachedSize(), target, stream); - } - - // optional .proto.SyncActionValue.PushNameSetting pushNameSetting = 7; - if (cached_has_bits & 0x00000020u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(7, _Internal::pushnamesetting(this), - _Internal::pushnamesetting(this).GetCachedSize(), target, stream); - } - - // optional .proto.SyncActionValue.QuickReplyAction quickReplyAction = 8; - if (cached_has_bits & 0x00000040u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(8, _Internal::quickreplyaction(this), - _Internal::quickreplyaction(this).GetCachedSize(), target, stream); - } - - // optional .proto.SyncActionValue.RecentEmojiWeightsAction recentEmojiWeightsAction = 11; - if (cached_has_bits & 0x00000080u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(11, _Internal::recentemojiweightsaction(this), - _Internal::recentemojiweightsaction(this).GetCachedSize(), target, stream); - } - - // optional .proto.SyncActionValue.LabelEditAction labelEditAction = 14; - if (cached_has_bits & 0x00000100u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(14, _Internal::labeleditaction(this), - _Internal::labeleditaction(this).GetCachedSize(), target, stream); - } - - // optional .proto.SyncActionValue.LabelAssociationAction labelAssociationAction = 15; - if (cached_has_bits & 0x00000200u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(15, _Internal::labelassociationaction(this), - _Internal::labelassociationaction(this).GetCachedSize(), target, stream); - } - - // optional .proto.SyncActionValue.LocaleSetting localeSetting = 16; - if (cached_has_bits & 0x00000400u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(16, _Internal::localesetting(this), - _Internal::localesetting(this).GetCachedSize(), target, stream); - } - - // optional .proto.SyncActionValue.ArchiveChatAction archiveChatAction = 17; - if (cached_has_bits & 0x00000800u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(17, _Internal::archivechataction(this), - _Internal::archivechataction(this).GetCachedSize(), target, stream); - } - - // optional .proto.SyncActionValue.DeleteMessageForMeAction deleteMessageForMeAction = 18; - if (cached_has_bits & 0x00001000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(18, _Internal::deletemessageformeaction(this), - _Internal::deletemessageformeaction(this).GetCachedSize(), target, stream); - } - - // optional .proto.SyncActionValue.KeyExpiration keyExpiration = 19; - if (cached_has_bits & 0x00002000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(19, _Internal::keyexpiration(this), - _Internal::keyexpiration(this).GetCachedSize(), target, stream); - } - - // optional .proto.SyncActionValue.MarkChatAsReadAction markChatAsReadAction = 20; - if (cached_has_bits & 0x00004000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(20, _Internal::markchatasreadaction(this), - _Internal::markchatasreadaction(this).GetCachedSize(), target, stream); - } - - // optional .proto.SyncActionValue.ClearChatAction clearChatAction = 21; - if (cached_has_bits & 0x00008000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(21, _Internal::clearchataction(this), - _Internal::clearchataction(this).GetCachedSize(), target, stream); - } - - // optional .proto.SyncActionValue.DeleteChatAction deleteChatAction = 22; - if (cached_has_bits & 0x00010000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(22, _Internal::deletechataction(this), - _Internal::deletechataction(this).GetCachedSize(), target, stream); - } - - // optional .proto.SyncActionValue.UnarchiveChatsSetting unarchiveChatsSetting = 23; - if (cached_has_bits & 0x00020000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(23, _Internal::unarchivechatssetting(this), - _Internal::unarchivechatssetting(this).GetCachedSize(), target, stream); - } - - // optional .proto.SyncActionValue.PrimaryFeature primaryFeature = 24; - if (cached_has_bits & 0x00040000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(24, _Internal::primaryfeature(this), - _Internal::primaryfeature(this).GetCachedSize(), target, stream); - } - - // optional .proto.SyncActionValue.AndroidUnsupportedActions androidUnsupportedActions = 26; - if (cached_has_bits & 0x00080000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(26, _Internal::androidunsupportedactions(this), - _Internal::androidunsupportedactions(this).GetCachedSize(), target, stream); - } - - // optional .proto.SyncActionValue.AgentAction agentAction = 27; - if (cached_has_bits & 0x00100000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(27, _Internal::agentaction(this), - _Internal::agentaction(this).GetCachedSize(), target, stream); - } - - // optional .proto.SyncActionValue.SubscriptionAction subscriptionAction = 28; - if (cached_has_bits & 0x00200000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(28, _Internal::subscriptionaction(this), - _Internal::subscriptionaction(this).GetCachedSize(), target, stream); - } - - // optional .proto.SyncActionValue.UserStatusMuteAction userStatusMuteAction = 29; - if (cached_has_bits & 0x00400000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(29, _Internal::userstatusmuteaction(this), - _Internal::userstatusmuteaction(this).GetCachedSize(), target, stream); - } - - // optional .proto.SyncActionValue.TimeFormatAction timeFormatAction = 30; - if (cached_has_bits & 0x00800000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(30, _Internal::timeformataction(this), - _Internal::timeformataction(this).GetCachedSize(), target, stream); - } - - // optional .proto.SyncActionValue.NuxAction nuxAction = 31; - if (cached_has_bits & 0x01000000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(31, _Internal::nuxaction(this), - _Internal::nuxaction(this).GetCachedSize(), target, stream); - } - - // optional .proto.SyncActionValue.PrimaryVersionAction primaryVersionAction = 32; - if (cached_has_bits & 0x02000000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(32, _Internal::primaryversionaction(this), - _Internal::primaryversionaction(this).GetCachedSize(), target, stream); - } - - // optional .proto.SyncActionValue.StickerAction stickerAction = 33; - if (cached_has_bits & 0x04000000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(33, _Internal::stickeraction(this), - _Internal::stickeraction(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncActionValue) - return target; -} - -size_t SyncActionValue::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncActionValue) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional .proto.SyncActionValue.StarAction starAction = 2; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.staraction_); - } - - // optional .proto.SyncActionValue.ContactAction contactAction = 3; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.contactaction_); - } - - // optional .proto.SyncActionValue.MuteAction muteAction = 4; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.muteaction_); - } - - // optional .proto.SyncActionValue.PinAction pinAction = 5; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.pinaction_); - } - - // optional .proto.SyncActionValue.SecurityNotificationSetting securityNotificationSetting = 6; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.securitynotificationsetting_); - } - - // optional .proto.SyncActionValue.PushNameSetting pushNameSetting = 7; - if (cached_has_bits & 0x00000020u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.pushnamesetting_); - } - - // optional .proto.SyncActionValue.QuickReplyAction quickReplyAction = 8; - if (cached_has_bits & 0x00000040u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.quickreplyaction_); - } - - // optional .proto.SyncActionValue.RecentEmojiWeightsAction recentEmojiWeightsAction = 11; - if (cached_has_bits & 0x00000080u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.recentemojiweightsaction_); - } - - } - if (cached_has_bits & 0x0000ff00u) { - // optional .proto.SyncActionValue.LabelEditAction labelEditAction = 14; - if (cached_has_bits & 0x00000100u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.labeleditaction_); - } - - // optional .proto.SyncActionValue.LabelAssociationAction labelAssociationAction = 15; - if (cached_has_bits & 0x00000200u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.labelassociationaction_); - } - - // optional .proto.SyncActionValue.LocaleSetting localeSetting = 16; - if (cached_has_bits & 0x00000400u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.localesetting_); - } - - // optional .proto.SyncActionValue.ArchiveChatAction archiveChatAction = 17; - if (cached_has_bits & 0x00000800u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.archivechataction_); - } - - // optional .proto.SyncActionValue.DeleteMessageForMeAction deleteMessageForMeAction = 18; - if (cached_has_bits & 0x00001000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.deletemessageformeaction_); - } - - // optional .proto.SyncActionValue.KeyExpiration keyExpiration = 19; - if (cached_has_bits & 0x00002000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.keyexpiration_); - } - - // optional .proto.SyncActionValue.MarkChatAsReadAction markChatAsReadAction = 20; - if (cached_has_bits & 0x00004000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.markchatasreadaction_); - } - - // optional .proto.SyncActionValue.ClearChatAction clearChatAction = 21; - if (cached_has_bits & 0x00008000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.clearchataction_); - } - - } - if (cached_has_bits & 0x00ff0000u) { - // optional .proto.SyncActionValue.DeleteChatAction deleteChatAction = 22; - if (cached_has_bits & 0x00010000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.deletechataction_); - } - - // optional .proto.SyncActionValue.UnarchiveChatsSetting unarchiveChatsSetting = 23; - if (cached_has_bits & 0x00020000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.unarchivechatssetting_); - } - - // optional .proto.SyncActionValue.PrimaryFeature primaryFeature = 24; - if (cached_has_bits & 0x00040000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.primaryfeature_); - } - - // optional .proto.SyncActionValue.AndroidUnsupportedActions androidUnsupportedActions = 26; - if (cached_has_bits & 0x00080000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.androidunsupportedactions_); - } - - // optional .proto.SyncActionValue.AgentAction agentAction = 27; - if (cached_has_bits & 0x00100000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.agentaction_); - } - - // optional .proto.SyncActionValue.SubscriptionAction subscriptionAction = 28; - if (cached_has_bits & 0x00200000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.subscriptionaction_); - } - - // optional .proto.SyncActionValue.UserStatusMuteAction userStatusMuteAction = 29; - if (cached_has_bits & 0x00400000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.userstatusmuteaction_); - } - - // optional .proto.SyncActionValue.TimeFormatAction timeFormatAction = 30; - if (cached_has_bits & 0x00800000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.timeformataction_); - } - - } - if (cached_has_bits & 0x0f000000u) { - // optional .proto.SyncActionValue.NuxAction nuxAction = 31; - if (cached_has_bits & 0x01000000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.nuxaction_); - } - - // optional .proto.SyncActionValue.PrimaryVersionAction primaryVersionAction = 32; - if (cached_has_bits & 0x02000000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.primaryversionaction_); - } - - // optional .proto.SyncActionValue.StickerAction stickerAction = 33; - if (cached_has_bits & 0x04000000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.stickeraction_); - } - - // optional int64 timestamp = 1; - if (cached_has_bits & 0x08000000u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_timestamp()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncActionValue::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncActionValue::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncActionValue::GetClassData() const { return &_class_data_; } - - -void SyncActionValue::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncActionValue) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_mutable_staraction()->::proto::SyncActionValue_StarAction::MergeFrom( - from._internal_staraction()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_contactaction()->::proto::SyncActionValue_ContactAction::MergeFrom( - from._internal_contactaction()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_mutable_muteaction()->::proto::SyncActionValue_MuteAction::MergeFrom( - from._internal_muteaction()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_mutable_pinaction()->::proto::SyncActionValue_PinAction::MergeFrom( - from._internal_pinaction()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_mutable_securitynotificationsetting()->::proto::SyncActionValue_SecurityNotificationSetting::MergeFrom( - from._internal_securitynotificationsetting()); - } - if (cached_has_bits & 0x00000020u) { - _this->_internal_mutable_pushnamesetting()->::proto::SyncActionValue_PushNameSetting::MergeFrom( - from._internal_pushnamesetting()); - } - if (cached_has_bits & 0x00000040u) { - _this->_internal_mutable_quickreplyaction()->::proto::SyncActionValue_QuickReplyAction::MergeFrom( - from._internal_quickreplyaction()); - } - if (cached_has_bits & 0x00000080u) { - _this->_internal_mutable_recentemojiweightsaction()->::proto::SyncActionValue_RecentEmojiWeightsAction::MergeFrom( - from._internal_recentemojiweightsaction()); - } - } - if (cached_has_bits & 0x0000ff00u) { - if (cached_has_bits & 0x00000100u) { - _this->_internal_mutable_labeleditaction()->::proto::SyncActionValue_LabelEditAction::MergeFrom( - from._internal_labeleditaction()); - } - if (cached_has_bits & 0x00000200u) { - _this->_internal_mutable_labelassociationaction()->::proto::SyncActionValue_LabelAssociationAction::MergeFrom( - from._internal_labelassociationaction()); - } - if (cached_has_bits & 0x00000400u) { - _this->_internal_mutable_localesetting()->::proto::SyncActionValue_LocaleSetting::MergeFrom( - from._internal_localesetting()); - } - if (cached_has_bits & 0x00000800u) { - _this->_internal_mutable_archivechataction()->::proto::SyncActionValue_ArchiveChatAction::MergeFrom( - from._internal_archivechataction()); - } - if (cached_has_bits & 0x00001000u) { - _this->_internal_mutable_deletemessageformeaction()->::proto::SyncActionValue_DeleteMessageForMeAction::MergeFrom( - from._internal_deletemessageformeaction()); - } - if (cached_has_bits & 0x00002000u) { - _this->_internal_mutable_keyexpiration()->::proto::SyncActionValue_KeyExpiration::MergeFrom( - from._internal_keyexpiration()); - } - if (cached_has_bits & 0x00004000u) { - _this->_internal_mutable_markchatasreadaction()->::proto::SyncActionValue_MarkChatAsReadAction::MergeFrom( - from._internal_markchatasreadaction()); - } - if (cached_has_bits & 0x00008000u) { - _this->_internal_mutable_clearchataction()->::proto::SyncActionValue_ClearChatAction::MergeFrom( - from._internal_clearchataction()); - } - } - if (cached_has_bits & 0x00ff0000u) { - if (cached_has_bits & 0x00010000u) { - _this->_internal_mutable_deletechataction()->::proto::SyncActionValue_DeleteChatAction::MergeFrom( - from._internal_deletechataction()); - } - if (cached_has_bits & 0x00020000u) { - _this->_internal_mutable_unarchivechatssetting()->::proto::SyncActionValue_UnarchiveChatsSetting::MergeFrom( - from._internal_unarchivechatssetting()); - } - if (cached_has_bits & 0x00040000u) { - _this->_internal_mutable_primaryfeature()->::proto::SyncActionValue_PrimaryFeature::MergeFrom( - from._internal_primaryfeature()); - } - if (cached_has_bits & 0x00080000u) { - _this->_internal_mutable_androidunsupportedactions()->::proto::SyncActionValue_AndroidUnsupportedActions::MergeFrom( - from._internal_androidunsupportedactions()); - } - if (cached_has_bits & 0x00100000u) { - _this->_internal_mutable_agentaction()->::proto::SyncActionValue_AgentAction::MergeFrom( - from._internal_agentaction()); - } - if (cached_has_bits & 0x00200000u) { - _this->_internal_mutable_subscriptionaction()->::proto::SyncActionValue_SubscriptionAction::MergeFrom( - from._internal_subscriptionaction()); - } - if (cached_has_bits & 0x00400000u) { - _this->_internal_mutable_userstatusmuteaction()->::proto::SyncActionValue_UserStatusMuteAction::MergeFrom( - from._internal_userstatusmuteaction()); - } - if (cached_has_bits & 0x00800000u) { - _this->_internal_mutable_timeformataction()->::proto::SyncActionValue_TimeFormatAction::MergeFrom( - from._internal_timeformataction()); - } - } - if (cached_has_bits & 0x0f000000u) { - if (cached_has_bits & 0x01000000u) { - _this->_internal_mutable_nuxaction()->::proto::SyncActionValue_NuxAction::MergeFrom( - from._internal_nuxaction()); - } - if (cached_has_bits & 0x02000000u) { - _this->_internal_mutable_primaryversionaction()->::proto::SyncActionValue_PrimaryVersionAction::MergeFrom( - from._internal_primaryversionaction()); - } - if (cached_has_bits & 0x04000000u) { - _this->_internal_mutable_stickeraction()->::proto::SyncActionValue_StickerAction::MergeFrom( - from._internal_stickeraction()); - } - if (cached_has_bits & 0x08000000u) { - _this->_impl_.timestamp_ = from._impl_.timestamp_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncActionValue::CopyFrom(const SyncActionValue& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncActionValue) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncActionValue::IsInitialized() const { - return true; -} - -void SyncActionValue::InternalSwap(SyncActionValue* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SyncActionValue, _impl_.timestamp_) - + sizeof(SyncActionValue::_impl_.timestamp_) - - PROTOBUF_FIELD_OFFSET(SyncActionValue, _impl_.staraction_)>( - reinterpret_cast(&_impl_.staraction_), - reinterpret_cast(&other->_impl_.staraction_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncActionValue::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[204]); -} - -// =================================================================== - -class SyncdIndex::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_blob(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -SyncdIndex::SyncdIndex(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncdIndex) -} -SyncdIndex::SyncdIndex(const SyncdIndex& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncdIndex* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.blob_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.blob_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.blob_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_blob()) { - _this->_impl_.blob_.Set(from._internal_blob(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.SyncdIndex) -} - -inline void SyncdIndex::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.blob_){} - }; - _impl_.blob_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.blob_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -SyncdIndex::~SyncdIndex() { - // @@protoc_insertion_point(destructor:proto.SyncdIndex) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncdIndex::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.blob_.Destroy(); -} - -void SyncdIndex::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncdIndex::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncdIndex) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.blob_.ClearNonDefaultToEmpty(); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncdIndex::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bytes blob = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_blob(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncdIndex::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncdIndex) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bytes blob = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 1, this->_internal_blob(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncdIndex) - return target; -} - -size_t SyncdIndex::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncdIndex) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional bytes blob = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_blob()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncdIndex::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncdIndex::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncdIndex::GetClassData() const { return &_class_data_; } - - -void SyncdIndex::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncdIndex) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_blob()) { - _this->_internal_set_blob(from._internal_blob()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncdIndex::CopyFrom(const SyncdIndex& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncdIndex) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncdIndex::IsInitialized() const { - return true; -} - -void SyncdIndex::InternalSwap(SyncdIndex* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.blob_, lhs_arena, - &other->_impl_.blob_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncdIndex::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[205]); -} - -// =================================================================== - -class SyncdMutation::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_operation(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::proto::SyncdRecord& record(const SyncdMutation* msg); - static void set_has_record(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -const ::proto::SyncdRecord& -SyncdMutation::_Internal::record(const SyncdMutation* msg) { - return *msg->_impl_.record_; -} -SyncdMutation::SyncdMutation(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncdMutation) -} -SyncdMutation::SyncdMutation(const SyncdMutation& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncdMutation* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.record_){nullptr} - , decltype(_impl_.operation_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_record()) { - _this->_impl_.record_ = new ::proto::SyncdRecord(*from._impl_.record_); - } - _this->_impl_.operation_ = from._impl_.operation_; - // @@protoc_insertion_point(copy_constructor:proto.SyncdMutation) -} - -inline void SyncdMutation::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.record_){nullptr} - , decltype(_impl_.operation_){0} - }; -} - -SyncdMutation::~SyncdMutation() { - // @@protoc_insertion_point(destructor:proto.SyncdMutation) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncdMutation::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete _impl_.record_; -} - -void SyncdMutation::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncdMutation::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncdMutation) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.record_ != nullptr); - _impl_.record_->Clear(); - } - _impl_.operation_ = 0; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncdMutation::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.SyncdMutation.SyncdOperation operation = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::SyncdMutation_SyncdOperation_IsValid(val))) { - _internal_set_operation(static_cast<::proto::SyncdMutation_SyncdOperation>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.SyncdRecord record = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_record(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncdMutation::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncdMutation) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.SyncdMutation.SyncdOperation operation = 1; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 1, this->_internal_operation(), target); - } - - // optional .proto.SyncdRecord record = 2; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::record(this), - _Internal::record(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncdMutation) - return target; -} - -size_t SyncdMutation::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncdMutation) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional .proto.SyncdRecord record = 2; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.record_); - } - - // optional .proto.SyncdMutation.SyncdOperation operation = 1; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_operation()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncdMutation::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncdMutation::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncdMutation::GetClassData() const { return &_class_data_; } - - -void SyncdMutation::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncdMutation) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_mutable_record()->::proto::SyncdRecord::MergeFrom( - from._internal_record()); - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.operation_ = from._impl_.operation_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncdMutation::CopyFrom(const SyncdMutation& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncdMutation) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncdMutation::IsInitialized() const { - return true; -} - -void SyncdMutation::InternalSwap(SyncdMutation* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SyncdMutation, _impl_.operation_) - + sizeof(SyncdMutation::_impl_.operation_) - - PROTOBUF_FIELD_OFFSET(SyncdMutation, _impl_.record_)>( - reinterpret_cast(&_impl_.record_), - reinterpret_cast(&other->_impl_.record_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncdMutation::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[206]); -} - -// =================================================================== - -class SyncdMutations::_Internal { - public: -}; - -SyncdMutations::SyncdMutations(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncdMutations) -} -SyncdMutations::SyncdMutations(const SyncdMutations& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncdMutations* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_.mutations_){from._impl_.mutations_} - , /*decltype(_impl_._cached_size_)*/{}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:proto.SyncdMutations) -} - -inline void SyncdMutations::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_.mutations_){arena} - , /*decltype(_impl_._cached_size_)*/{} - }; -} - -SyncdMutations::~SyncdMutations() { - // @@protoc_insertion_point(destructor:proto.SyncdMutations) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncdMutations::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.mutations_.~RepeatedPtrField(); -} - -void SyncdMutations::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncdMutations::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncdMutations) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.mutations_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncdMutations::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated .proto.SyncdMutation mutations = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_mutations(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncdMutations::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncdMutations) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .proto.SyncdMutation mutations = 1; - for (unsigned i = 0, - n = static_cast(this->_internal_mutations_size()); i < n; i++) { - const auto& repfield = this->_internal_mutations(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncdMutations) - return target; -} - -size_t SyncdMutations::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncdMutations) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.SyncdMutation mutations = 1; - total_size += 1UL * this->_internal_mutations_size(); - for (const auto& msg : this->_impl_.mutations_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncdMutations::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncdMutations::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncdMutations::GetClassData() const { return &_class_data_; } - - -void SyncdMutations::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncdMutations) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.mutations_.MergeFrom(from._impl_.mutations_); - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncdMutations::CopyFrom(const SyncdMutations& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncdMutations) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncdMutations::IsInitialized() const { - return true; -} - -void SyncdMutations::InternalSwap(SyncdMutations* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - _impl_.mutations_.InternalSwap(&other->_impl_.mutations_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncdMutations::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[207]); -} - -// =================================================================== - -class SyncdPatch::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::SyncdVersion& version(const SyncdPatch* msg); - static void set_has_version(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static const ::proto::ExternalBlobReference& externalmutations(const SyncdPatch* msg); - static void set_has_externalmutations(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_snapshotmac(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_patchmac(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::proto::KeyId& keyid(const SyncdPatch* msg); - static void set_has_keyid(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static const ::proto::ExitCode& exitcode(const SyncdPatch* msg); - static void set_has_exitcode(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static void set_has_deviceindex(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } -}; - -const ::proto::SyncdVersion& -SyncdPatch::_Internal::version(const SyncdPatch* msg) { - return *msg->_impl_.version_; -} -const ::proto::ExternalBlobReference& -SyncdPatch::_Internal::externalmutations(const SyncdPatch* msg) { - return *msg->_impl_.externalmutations_; -} -const ::proto::KeyId& -SyncdPatch::_Internal::keyid(const SyncdPatch* msg) { - return *msg->_impl_.keyid_; -} -const ::proto::ExitCode& -SyncdPatch::_Internal::exitcode(const SyncdPatch* msg) { - return *msg->_impl_.exitcode_; -} -SyncdPatch::SyncdPatch(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncdPatch) -} -SyncdPatch::SyncdPatch(const SyncdPatch& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncdPatch* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.mutations_){from._impl_.mutations_} - , decltype(_impl_.snapshotmac_){} - , decltype(_impl_.patchmac_){} - , decltype(_impl_.version_){nullptr} - , decltype(_impl_.externalmutations_){nullptr} - , decltype(_impl_.keyid_){nullptr} - , decltype(_impl_.exitcode_){nullptr} - , decltype(_impl_.deviceindex_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.snapshotmac_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.snapshotmac_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_snapshotmac()) { - _this->_impl_.snapshotmac_.Set(from._internal_snapshotmac(), - _this->GetArenaForAllocation()); - } - _impl_.patchmac_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.patchmac_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_patchmac()) { - _this->_impl_.patchmac_.Set(from._internal_patchmac(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_version()) { - _this->_impl_.version_ = new ::proto::SyncdVersion(*from._impl_.version_); - } - if (from._internal_has_externalmutations()) { - _this->_impl_.externalmutations_ = new ::proto::ExternalBlobReference(*from._impl_.externalmutations_); - } - if (from._internal_has_keyid()) { - _this->_impl_.keyid_ = new ::proto::KeyId(*from._impl_.keyid_); - } - if (from._internal_has_exitcode()) { - _this->_impl_.exitcode_ = new ::proto::ExitCode(*from._impl_.exitcode_); - } - _this->_impl_.deviceindex_ = from._impl_.deviceindex_; - // @@protoc_insertion_point(copy_constructor:proto.SyncdPatch) -} - -inline void SyncdPatch::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.mutations_){arena} - , decltype(_impl_.snapshotmac_){} - , decltype(_impl_.patchmac_){} - , decltype(_impl_.version_){nullptr} - , decltype(_impl_.externalmutations_){nullptr} - , decltype(_impl_.keyid_){nullptr} - , decltype(_impl_.exitcode_){nullptr} - , decltype(_impl_.deviceindex_){0u} - }; - _impl_.snapshotmac_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.snapshotmac_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.patchmac_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.patchmac_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -SyncdPatch::~SyncdPatch() { - // @@protoc_insertion_point(destructor:proto.SyncdPatch) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncdPatch::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.mutations_.~RepeatedPtrField(); - _impl_.snapshotmac_.Destroy(); - _impl_.patchmac_.Destroy(); - if (this != internal_default_instance()) delete _impl_.version_; - if (this != internal_default_instance()) delete _impl_.externalmutations_; - if (this != internal_default_instance()) delete _impl_.keyid_; - if (this != internal_default_instance()) delete _impl_.exitcode_; -} - -void SyncdPatch::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncdPatch::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncdPatch) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.mutations_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000003fu) { - if (cached_has_bits & 0x00000001u) { - _impl_.snapshotmac_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.patchmac_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - GOOGLE_DCHECK(_impl_.version_ != nullptr); - _impl_.version_->Clear(); - } - if (cached_has_bits & 0x00000008u) { - GOOGLE_DCHECK(_impl_.externalmutations_ != nullptr); - _impl_.externalmutations_->Clear(); - } - if (cached_has_bits & 0x00000010u) { - GOOGLE_DCHECK(_impl_.keyid_ != nullptr); - _impl_.keyid_->Clear(); - } - if (cached_has_bits & 0x00000020u) { - GOOGLE_DCHECK(_impl_.exitcode_ != nullptr); - _impl_.exitcode_->Clear(); - } - } - _impl_.deviceindex_ = 0u; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncdPatch::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.SyncdVersion version = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_version(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated .proto.SyncdMutation mutations = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_mutations(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else - goto handle_unusual; - continue; - // optional .proto.ExternalBlobReference externalMutations = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_externalmutations(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes snapshotMac = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - auto str = _internal_mutable_snapshotmac(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes patchMac = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - auto str = _internal_mutable_patchmac(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.KeyId keyId = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - ptr = ctx->ParseMessage(_internal_mutable_keyid(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.ExitCode exitCode = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - ptr = ctx->ParseMessage(_internal_mutable_exitcode(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 deviceIndex = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { - _Internal::set_has_deviceindex(&has_bits); - _impl_.deviceindex_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncdPatch::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncdPatch) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.SyncdVersion version = 1; - if (cached_has_bits & 0x00000004u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::version(this), - _Internal::version(this).GetCachedSize(), target, stream); - } - - // repeated .proto.SyncdMutation mutations = 2; - for (unsigned i = 0, - n = static_cast(this->_internal_mutations_size()); i < n; i++) { - const auto& repfield = this->_internal_mutations(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream); - } - - // optional .proto.ExternalBlobReference externalMutations = 3; - if (cached_has_bits & 0x00000008u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, _Internal::externalmutations(this), - _Internal::externalmutations(this).GetCachedSize(), target, stream); - } - - // optional bytes snapshotMac = 4; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 4, this->_internal_snapshotmac(), target); - } - - // optional bytes patchMac = 5; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 5, this->_internal_patchmac(), target); - } - - // optional .proto.KeyId keyId = 6; - if (cached_has_bits & 0x00000010u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(6, _Internal::keyid(this), - _Internal::keyid(this).GetCachedSize(), target, stream); - } - - // optional .proto.ExitCode exitCode = 7; - if (cached_has_bits & 0x00000020u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(7, _Internal::exitcode(this), - _Internal::exitcode(this).GetCachedSize(), target, stream); - } - - // optional uint32 deviceIndex = 8; - if (cached_has_bits & 0x00000040u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(8, this->_internal_deviceindex(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncdPatch) - return target; -} - -size_t SyncdPatch::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncdPatch) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.SyncdMutation mutations = 2; - total_size += 1UL * this->_internal_mutations_size(); - for (const auto& msg : this->_impl_.mutations_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000007fu) { - // optional bytes snapshotMac = 4; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_snapshotmac()); - } - - // optional bytes patchMac = 5; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_patchmac()); - } - - // optional .proto.SyncdVersion version = 1; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.version_); - } - - // optional .proto.ExternalBlobReference externalMutations = 3; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.externalmutations_); - } - - // optional .proto.KeyId keyId = 6; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.keyid_); - } - - // optional .proto.ExitCode exitCode = 7; - if (cached_has_bits & 0x00000020u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.exitcode_); - } - - // optional uint32 deviceIndex = 8; - if (cached_has_bits & 0x00000040u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_deviceindex()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncdPatch::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncdPatch::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncdPatch::GetClassData() const { return &_class_data_; } - - -void SyncdPatch::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncdPatch) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.mutations_.MergeFrom(from._impl_.mutations_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000007fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_snapshotmac(from._internal_snapshotmac()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_patchmac(from._internal_patchmac()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_mutable_version()->::proto::SyncdVersion::MergeFrom( - from._internal_version()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_mutable_externalmutations()->::proto::ExternalBlobReference::MergeFrom( - from._internal_externalmutations()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_mutable_keyid()->::proto::KeyId::MergeFrom( - from._internal_keyid()); - } - if (cached_has_bits & 0x00000020u) { - _this->_internal_mutable_exitcode()->::proto::ExitCode::MergeFrom( - from._internal_exitcode()); - } - if (cached_has_bits & 0x00000040u) { - _this->_impl_.deviceindex_ = from._impl_.deviceindex_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncdPatch::CopyFrom(const SyncdPatch& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncdPatch) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncdPatch::IsInitialized() const { - return true; -} - -void SyncdPatch::InternalSwap(SyncdPatch* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.mutations_.InternalSwap(&other->_impl_.mutations_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.snapshotmac_, lhs_arena, - &other->_impl_.snapshotmac_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.patchmac_, lhs_arena, - &other->_impl_.patchmac_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SyncdPatch, _impl_.deviceindex_) - + sizeof(SyncdPatch::_impl_.deviceindex_) - - PROTOBUF_FIELD_OFFSET(SyncdPatch, _impl_.version_)>( - reinterpret_cast(&_impl_.version_), - reinterpret_cast(&other->_impl_.version_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncdPatch::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[208]); -} - -// =================================================================== - -class SyncdRecord::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::SyncdIndex& index(const SyncdRecord* msg); - static void set_has_index(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::proto::SyncdValue& value(const SyncdRecord* msg); - static void set_has_value(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static const ::proto::KeyId& keyid(const SyncdRecord* msg); - static void set_has_keyid(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } -}; - -const ::proto::SyncdIndex& -SyncdRecord::_Internal::index(const SyncdRecord* msg) { - return *msg->_impl_.index_; -} -const ::proto::SyncdValue& -SyncdRecord::_Internal::value(const SyncdRecord* msg) { - return *msg->_impl_.value_; -} -const ::proto::KeyId& -SyncdRecord::_Internal::keyid(const SyncdRecord* msg) { - return *msg->_impl_.keyid_; -} -SyncdRecord::SyncdRecord(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncdRecord) -} -SyncdRecord::SyncdRecord(const SyncdRecord& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncdRecord* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.index_){nullptr} - , decltype(_impl_.value_){nullptr} - , decltype(_impl_.keyid_){nullptr}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_index()) { - _this->_impl_.index_ = new ::proto::SyncdIndex(*from._impl_.index_); - } - if (from._internal_has_value()) { - _this->_impl_.value_ = new ::proto::SyncdValue(*from._impl_.value_); - } - if (from._internal_has_keyid()) { - _this->_impl_.keyid_ = new ::proto::KeyId(*from._impl_.keyid_); - } - // @@protoc_insertion_point(copy_constructor:proto.SyncdRecord) -} - -inline void SyncdRecord::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.index_){nullptr} - , decltype(_impl_.value_){nullptr} - , decltype(_impl_.keyid_){nullptr} - }; -} - -SyncdRecord::~SyncdRecord() { - // @@protoc_insertion_point(destructor:proto.SyncdRecord) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncdRecord::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete _impl_.index_; - if (this != internal_default_instance()) delete _impl_.value_; - if (this != internal_default_instance()) delete _impl_.keyid_; -} - -void SyncdRecord::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncdRecord::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncdRecord) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.index_ != nullptr); - _impl_.index_->Clear(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.value_ != nullptr); - _impl_.value_->Clear(); - } - if (cached_has_bits & 0x00000004u) { - GOOGLE_DCHECK(_impl_.keyid_ != nullptr); - _impl_.keyid_->Clear(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncdRecord::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.SyncdIndex index = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_index(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.SyncdValue value = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_value(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.KeyId keyId = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_keyid(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncdRecord::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncdRecord) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.SyncdIndex index = 1; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::index(this), - _Internal::index(this).GetCachedSize(), target, stream); - } - - // optional .proto.SyncdValue value = 2; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::value(this), - _Internal::value(this).GetCachedSize(), target, stream); - } - - // optional .proto.KeyId keyId = 3; - if (cached_has_bits & 0x00000004u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, _Internal::keyid(this), - _Internal::keyid(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncdRecord) - return target; -} - -size_t SyncdRecord::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncdRecord) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional .proto.SyncdIndex index = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.index_); - } - - // optional .proto.SyncdValue value = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.value_); - } - - // optional .proto.KeyId keyId = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.keyid_); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncdRecord::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncdRecord::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncdRecord::GetClassData() const { return &_class_data_; } - - -void SyncdRecord::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncdRecord) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_mutable_index()->::proto::SyncdIndex::MergeFrom( - from._internal_index()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_value()->::proto::SyncdValue::MergeFrom( - from._internal_value()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_mutable_keyid()->::proto::KeyId::MergeFrom( - from._internal_keyid()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncdRecord::CopyFrom(const SyncdRecord& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncdRecord) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncdRecord::IsInitialized() const { - return true; -} - -void SyncdRecord::InternalSwap(SyncdRecord* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SyncdRecord, _impl_.keyid_) - + sizeof(SyncdRecord::_impl_.keyid_) - - PROTOBUF_FIELD_OFFSET(SyncdRecord, _impl_.index_)>( - reinterpret_cast(&_impl_.index_), - reinterpret_cast(&other->_impl_.index_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncdRecord::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[209]); -} - -// =================================================================== - -class SyncdSnapshot::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::SyncdVersion& version(const SyncdSnapshot* msg); - static void set_has_version(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_mac(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::proto::KeyId& keyid(const SyncdSnapshot* msg); - static void set_has_keyid(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } -}; - -const ::proto::SyncdVersion& -SyncdSnapshot::_Internal::version(const SyncdSnapshot* msg) { - return *msg->_impl_.version_; -} -const ::proto::KeyId& -SyncdSnapshot::_Internal::keyid(const SyncdSnapshot* msg) { - return *msg->_impl_.keyid_; -} -SyncdSnapshot::SyncdSnapshot(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncdSnapshot) -} -SyncdSnapshot::SyncdSnapshot(const SyncdSnapshot& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncdSnapshot* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.records_){from._impl_.records_} - , decltype(_impl_.mac_){} - , decltype(_impl_.version_){nullptr} - , decltype(_impl_.keyid_){nullptr}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.mac_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mac_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_mac()) { - _this->_impl_.mac_.Set(from._internal_mac(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_version()) { - _this->_impl_.version_ = new ::proto::SyncdVersion(*from._impl_.version_); - } - if (from._internal_has_keyid()) { - _this->_impl_.keyid_ = new ::proto::KeyId(*from._impl_.keyid_); - } - // @@protoc_insertion_point(copy_constructor:proto.SyncdSnapshot) -} - -inline void SyncdSnapshot::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.records_){arena} - , decltype(_impl_.mac_){} - , decltype(_impl_.version_){nullptr} - , decltype(_impl_.keyid_){nullptr} - }; - _impl_.mac_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mac_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -SyncdSnapshot::~SyncdSnapshot() { - // @@protoc_insertion_point(destructor:proto.SyncdSnapshot) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncdSnapshot::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.records_.~RepeatedPtrField(); - _impl_.mac_.Destroy(); - if (this != internal_default_instance()) delete _impl_.version_; - if (this != internal_default_instance()) delete _impl_.keyid_; -} - -void SyncdSnapshot::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncdSnapshot::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncdSnapshot) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.records_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _impl_.mac_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.version_ != nullptr); - _impl_.version_->Clear(); - } - if (cached_has_bits & 0x00000004u) { - GOOGLE_DCHECK(_impl_.keyid_ != nullptr); - _impl_.keyid_->Clear(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncdSnapshot::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.SyncdVersion version = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_version(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated .proto.SyncdRecord records = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_records(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else - goto handle_unusual; - continue; - // optional bytes mac = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_mac(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.KeyId keyId = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_keyid(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncdSnapshot::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncdSnapshot) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.SyncdVersion version = 1; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::version(this), - _Internal::version(this).GetCachedSize(), target, stream); - } - - // repeated .proto.SyncdRecord records = 2; - for (unsigned i = 0, - n = static_cast(this->_internal_records_size()); i < n; i++) { - const auto& repfield = this->_internal_records(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream); - } - - // optional bytes mac = 3; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 3, this->_internal_mac(), target); - } - - // optional .proto.KeyId keyId = 4; - if (cached_has_bits & 0x00000004u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(4, _Internal::keyid(this), - _Internal::keyid(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncdSnapshot) - return target; -} - -size_t SyncdSnapshot::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncdSnapshot) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.SyncdRecord records = 2; - total_size += 1UL * this->_internal_records_size(); - for (const auto& msg : this->_impl_.records_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional bytes mac = 3; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_mac()); - } - - // optional .proto.SyncdVersion version = 1; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.version_); - } - - // optional .proto.KeyId keyId = 4; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.keyid_); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncdSnapshot::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncdSnapshot::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncdSnapshot::GetClassData() const { return &_class_data_; } - - -void SyncdSnapshot::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncdSnapshot) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.records_.MergeFrom(from._impl_.records_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_mac(from._internal_mac()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_version()->::proto::SyncdVersion::MergeFrom( - from._internal_version()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_mutable_keyid()->::proto::KeyId::MergeFrom( - from._internal_keyid()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncdSnapshot::CopyFrom(const SyncdSnapshot& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncdSnapshot) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncdSnapshot::IsInitialized() const { - return true; -} - -void SyncdSnapshot::InternalSwap(SyncdSnapshot* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.records_.InternalSwap(&other->_impl_.records_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.mac_, lhs_arena, - &other->_impl_.mac_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SyncdSnapshot, _impl_.keyid_) - + sizeof(SyncdSnapshot::_impl_.keyid_) - - PROTOBUF_FIELD_OFFSET(SyncdSnapshot, _impl_.version_)>( - reinterpret_cast(&_impl_.version_), - reinterpret_cast(&other->_impl_.version_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncdSnapshot::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[210]); -} - -// =================================================================== - -class SyncdValue::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_blob(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -SyncdValue::SyncdValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncdValue) -} -SyncdValue::SyncdValue(const SyncdValue& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncdValue* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.blob_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.blob_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.blob_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_blob()) { - _this->_impl_.blob_.Set(from._internal_blob(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.SyncdValue) -} - -inline void SyncdValue::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.blob_){} - }; - _impl_.blob_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.blob_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -SyncdValue::~SyncdValue() { - // @@protoc_insertion_point(destructor:proto.SyncdValue) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncdValue::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.blob_.Destroy(); -} - -void SyncdValue::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncdValue::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncdValue) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.blob_.ClearNonDefaultToEmpty(); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncdValue::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bytes blob = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_blob(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncdValue::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncdValue) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bytes blob = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 1, this->_internal_blob(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncdValue) - return target; -} - -size_t SyncdValue::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncdValue) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional bytes blob = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_blob()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncdValue::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncdValue::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncdValue::GetClassData() const { return &_class_data_; } - - -void SyncdValue::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncdValue) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_blob()) { - _this->_internal_set_blob(from._internal_blob()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncdValue::CopyFrom(const SyncdValue& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncdValue) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncdValue::IsInitialized() const { - return true; -} - -void SyncdValue::InternalSwap(SyncdValue* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.blob_, lhs_arena, - &other->_impl_.blob_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncdValue::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[211]); -} - -// =================================================================== - -class SyncdVersion::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_version(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -SyncdVersion::SyncdVersion(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.SyncdVersion) -} -SyncdVersion::SyncdVersion(const SyncdVersion& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - SyncdVersion* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.version_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _this->_impl_.version_ = from._impl_.version_; - // @@protoc_insertion_point(copy_constructor:proto.SyncdVersion) -} - -inline void SyncdVersion::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.version_){uint64_t{0u}} - }; -} - -SyncdVersion::~SyncdVersion() { - // @@protoc_insertion_point(destructor:proto.SyncdVersion) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void SyncdVersion::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void SyncdVersion::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void SyncdVersion::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.SyncdVersion) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.version_ = uint64_t{0u}; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SyncdVersion::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional uint64 version = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_version(&has_bits); - _impl_.version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SyncdVersion::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.SyncdVersion) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional uint64 version = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_version(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.SyncdVersion) - return target; -} - -size_t SyncdVersion::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.SyncdVersion) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional uint64 version = 1; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_version()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SyncdVersion::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - SyncdVersion::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SyncdVersion::GetClassData() const { return &_class_data_; } - - -void SyncdVersion::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.SyncdVersion) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_version()) { - _this->_internal_set_version(from._internal_version()); - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SyncdVersion::CopyFrom(const SyncdVersion& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.SyncdVersion) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SyncdVersion::IsInitialized() const { - return true; -} - -void SyncdVersion::InternalSwap(SyncdVersion* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - swap(_impl_.version_, other->_impl_.version_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SyncdVersion::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[212]); -} - -// =================================================================== - -class TemplateButton_CallButton::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::Message_HighlyStructuredMessage& displaytext(const TemplateButton_CallButton* msg); - static void set_has_displaytext(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::proto::Message_HighlyStructuredMessage& phonenumber(const TemplateButton_CallButton* msg); - static void set_has_phonenumber(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -const ::proto::Message_HighlyStructuredMessage& -TemplateButton_CallButton::_Internal::displaytext(const TemplateButton_CallButton* msg) { - return *msg->_impl_.displaytext_; -} -const ::proto::Message_HighlyStructuredMessage& -TemplateButton_CallButton::_Internal::phonenumber(const TemplateButton_CallButton* msg) { - return *msg->_impl_.phonenumber_; -} -TemplateButton_CallButton::TemplateButton_CallButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.TemplateButton.CallButton) -} -TemplateButton_CallButton::TemplateButton_CallButton(const TemplateButton_CallButton& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - TemplateButton_CallButton* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.displaytext_){nullptr} - , decltype(_impl_.phonenumber_){nullptr}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_displaytext()) { - _this->_impl_.displaytext_ = new ::proto::Message_HighlyStructuredMessage(*from._impl_.displaytext_); - } - if (from._internal_has_phonenumber()) { - _this->_impl_.phonenumber_ = new ::proto::Message_HighlyStructuredMessage(*from._impl_.phonenumber_); - } - // @@protoc_insertion_point(copy_constructor:proto.TemplateButton.CallButton) -} - -inline void TemplateButton_CallButton::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.displaytext_){nullptr} - , decltype(_impl_.phonenumber_){nullptr} - }; -} - -TemplateButton_CallButton::~TemplateButton_CallButton() { - // @@protoc_insertion_point(destructor:proto.TemplateButton.CallButton) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void TemplateButton_CallButton::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete _impl_.displaytext_; - if (this != internal_default_instance()) delete _impl_.phonenumber_; -} - -void TemplateButton_CallButton::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void TemplateButton_CallButton::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.TemplateButton.CallButton) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.displaytext_ != nullptr); - _impl_.displaytext_->Clear(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.phonenumber_ != nullptr); - _impl_.phonenumber_->Clear(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* TemplateButton_CallButton::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.Message.HighlyStructuredMessage displayText = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_displaytext(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.HighlyStructuredMessage phoneNumber = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_phonenumber(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* TemplateButton_CallButton::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.TemplateButton.CallButton) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.Message.HighlyStructuredMessage displayText = 1; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::displaytext(this), - _Internal::displaytext(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.HighlyStructuredMessage phoneNumber = 2; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::phonenumber(this), - _Internal::phonenumber(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.TemplateButton.CallButton) - return target; -} - -size_t TemplateButton_CallButton::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.TemplateButton.CallButton) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional .proto.Message.HighlyStructuredMessage displayText = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.displaytext_); - } - - // optional .proto.Message.HighlyStructuredMessage phoneNumber = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.phonenumber_); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TemplateButton_CallButton::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - TemplateButton_CallButton::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TemplateButton_CallButton::GetClassData() const { return &_class_data_; } - - -void TemplateButton_CallButton::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.TemplateButton.CallButton) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_mutable_displaytext()->::proto::Message_HighlyStructuredMessage::MergeFrom( - from._internal_displaytext()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_phonenumber()->::proto::Message_HighlyStructuredMessage::MergeFrom( - from._internal_phonenumber()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void TemplateButton_CallButton::CopyFrom(const TemplateButton_CallButton& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.TemplateButton.CallButton) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool TemplateButton_CallButton::IsInitialized() const { - return true; -} - -void TemplateButton_CallButton::InternalSwap(TemplateButton_CallButton* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(TemplateButton_CallButton, _impl_.phonenumber_) - + sizeof(TemplateButton_CallButton::_impl_.phonenumber_) - - PROTOBUF_FIELD_OFFSET(TemplateButton_CallButton, _impl_.displaytext_)>( - reinterpret_cast(&_impl_.displaytext_), - reinterpret_cast(&other->_impl_.displaytext_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata TemplateButton_CallButton::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[213]); -} - -// =================================================================== - -class TemplateButton_QuickReplyButton::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::Message_HighlyStructuredMessage& displaytext(const TemplateButton_QuickReplyButton* msg); - static void set_has_displaytext(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_id(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } -}; - -const ::proto::Message_HighlyStructuredMessage& -TemplateButton_QuickReplyButton::_Internal::displaytext(const TemplateButton_QuickReplyButton* msg) { - return *msg->_impl_.displaytext_; -} -TemplateButton_QuickReplyButton::TemplateButton_QuickReplyButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.TemplateButton.QuickReplyButton) -} -TemplateButton_QuickReplyButton::TemplateButton_QuickReplyButton(const TemplateButton_QuickReplyButton& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - TemplateButton_QuickReplyButton* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.id_){} - , decltype(_impl_.displaytext_){nullptr}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.id_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.id_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_id()) { - _this->_impl_.id_.Set(from._internal_id(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_displaytext()) { - _this->_impl_.displaytext_ = new ::proto::Message_HighlyStructuredMessage(*from._impl_.displaytext_); - } - // @@protoc_insertion_point(copy_constructor:proto.TemplateButton.QuickReplyButton) -} - -inline void TemplateButton_QuickReplyButton::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.id_){} - , decltype(_impl_.displaytext_){nullptr} - }; - _impl_.id_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.id_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -TemplateButton_QuickReplyButton::~TemplateButton_QuickReplyButton() { - // @@protoc_insertion_point(destructor:proto.TemplateButton.QuickReplyButton) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void TemplateButton_QuickReplyButton::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.id_.Destroy(); - if (this != internal_default_instance()) delete _impl_.displaytext_; -} - -void TemplateButton_QuickReplyButton::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void TemplateButton_QuickReplyButton::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.TemplateButton.QuickReplyButton) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.id_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.displaytext_ != nullptr); - _impl_.displaytext_->Clear(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* TemplateButton_QuickReplyButton::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.Message.HighlyStructuredMessage displayText = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_displaytext(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string id = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_id(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.TemplateButton.QuickReplyButton.id"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* TemplateButton_QuickReplyButton::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.TemplateButton.QuickReplyButton) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.Message.HighlyStructuredMessage displayText = 1; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::displaytext(this), - _Internal::displaytext(this).GetCachedSize(), target, stream); - } - - // optional string id = 2; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_id().data(), static_cast(this->_internal_id().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.TemplateButton.QuickReplyButton.id"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_id(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.TemplateButton.QuickReplyButton) - return target; -} - -size_t TemplateButton_QuickReplyButton::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.TemplateButton.QuickReplyButton) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional string id = 2; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_id()); - } - - // optional .proto.Message.HighlyStructuredMessage displayText = 1; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.displaytext_); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TemplateButton_QuickReplyButton::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - TemplateButton_QuickReplyButton::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TemplateButton_QuickReplyButton::GetClassData() const { return &_class_data_; } - - -void TemplateButton_QuickReplyButton::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.TemplateButton.QuickReplyButton) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_id(from._internal_id()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_displaytext()->::proto::Message_HighlyStructuredMessage::MergeFrom( - from._internal_displaytext()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void TemplateButton_QuickReplyButton::CopyFrom(const TemplateButton_QuickReplyButton& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.TemplateButton.QuickReplyButton) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool TemplateButton_QuickReplyButton::IsInitialized() const { - return true; -} - -void TemplateButton_QuickReplyButton::InternalSwap(TemplateButton_QuickReplyButton* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.id_, lhs_arena, - &other->_impl_.id_, rhs_arena - ); - swap(_impl_.displaytext_, other->_impl_.displaytext_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata TemplateButton_QuickReplyButton::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[214]); -} - -// =================================================================== - -class TemplateButton_URLButton::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::Message_HighlyStructuredMessage& displaytext(const TemplateButton_URLButton* msg); - static void set_has_displaytext(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::proto::Message_HighlyStructuredMessage& url(const TemplateButton_URLButton* msg); - static void set_has_url(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -const ::proto::Message_HighlyStructuredMessage& -TemplateButton_URLButton::_Internal::displaytext(const TemplateButton_URLButton* msg) { - return *msg->_impl_.displaytext_; -} -const ::proto::Message_HighlyStructuredMessage& -TemplateButton_URLButton::_Internal::url(const TemplateButton_URLButton* msg) { - return *msg->_impl_.url_; -} -TemplateButton_URLButton::TemplateButton_URLButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.TemplateButton.URLButton) -} -TemplateButton_URLButton::TemplateButton_URLButton(const TemplateButton_URLButton& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - TemplateButton_URLButton* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.displaytext_){nullptr} - , decltype(_impl_.url_){nullptr}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_displaytext()) { - _this->_impl_.displaytext_ = new ::proto::Message_HighlyStructuredMessage(*from._impl_.displaytext_); - } - if (from._internal_has_url()) { - _this->_impl_.url_ = new ::proto::Message_HighlyStructuredMessage(*from._impl_.url_); - } - // @@protoc_insertion_point(copy_constructor:proto.TemplateButton.URLButton) -} - -inline void TemplateButton_URLButton::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.displaytext_){nullptr} - , decltype(_impl_.url_){nullptr} - }; -} - -TemplateButton_URLButton::~TemplateButton_URLButton() { - // @@protoc_insertion_point(destructor:proto.TemplateButton.URLButton) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void TemplateButton_URLButton::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete _impl_.displaytext_; - if (this != internal_default_instance()) delete _impl_.url_; -} - -void TemplateButton_URLButton::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void TemplateButton_URLButton::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.TemplateButton.URLButton) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(_impl_.displaytext_ != nullptr); - _impl_.displaytext_->Clear(); - } - if (cached_has_bits & 0x00000002u) { - GOOGLE_DCHECK(_impl_.url_ != nullptr); - _impl_.url_->Clear(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* TemplateButton_URLButton::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.Message.HighlyStructuredMessage displayText = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_displaytext(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.HighlyStructuredMessage url = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_url(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* TemplateButton_URLButton::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.TemplateButton.URLButton) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.Message.HighlyStructuredMessage displayText = 1; - if (cached_has_bits & 0x00000001u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::displaytext(this), - _Internal::displaytext(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.HighlyStructuredMessage url = 2; - if (cached_has_bits & 0x00000002u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::url(this), - _Internal::url(this).GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.TemplateButton.URLButton) - return target; -} - -size_t TemplateButton_URLButton::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.TemplateButton.URLButton) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional .proto.Message.HighlyStructuredMessage displayText = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.displaytext_); - } - - // optional .proto.Message.HighlyStructuredMessage url = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.url_); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TemplateButton_URLButton::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - TemplateButton_URLButton::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TemplateButton_URLButton::GetClassData() const { return &_class_data_; } - - -void TemplateButton_URLButton::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.TemplateButton.URLButton) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_mutable_displaytext()->::proto::Message_HighlyStructuredMessage::MergeFrom( - from._internal_displaytext()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_mutable_url()->::proto::Message_HighlyStructuredMessage::MergeFrom( - from._internal_url()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void TemplateButton_URLButton::CopyFrom(const TemplateButton_URLButton& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.TemplateButton.URLButton) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool TemplateButton_URLButton::IsInitialized() const { - return true; -} - -void TemplateButton_URLButton::InternalSwap(TemplateButton_URLButton* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(TemplateButton_URLButton, _impl_.url_) - + sizeof(TemplateButton_URLButton::_impl_.url_) - - PROTOBUF_FIELD_OFFSET(TemplateButton_URLButton, _impl_.displaytext_)>( - reinterpret_cast(&_impl_.displaytext_), - reinterpret_cast(&other->_impl_.displaytext_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata TemplateButton_URLButton::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[215]); -} - -// =================================================================== - -class TemplateButton::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_index(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static const ::proto::TemplateButton_QuickReplyButton& quickreplybutton(const TemplateButton* msg); - static const ::proto::TemplateButton_URLButton& urlbutton(const TemplateButton* msg); - static const ::proto::TemplateButton_CallButton& callbutton(const TemplateButton* msg); -}; - -const ::proto::TemplateButton_QuickReplyButton& -TemplateButton::_Internal::quickreplybutton(const TemplateButton* msg) { - return *msg->_impl_.button_.quickreplybutton_; -} -const ::proto::TemplateButton_URLButton& -TemplateButton::_Internal::urlbutton(const TemplateButton* msg) { - return *msg->_impl_.button_.urlbutton_; -} -const ::proto::TemplateButton_CallButton& -TemplateButton::_Internal::callbutton(const TemplateButton* msg) { - return *msg->_impl_.button_.callbutton_; -} -void TemplateButton::set_allocated_quickreplybutton(::proto::TemplateButton_QuickReplyButton* quickreplybutton) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_button(); - if (quickreplybutton) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quickreplybutton); - if (message_arena != submessage_arena) { - quickreplybutton = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, quickreplybutton, submessage_arena); - } - set_has_quickreplybutton(); - _impl_.button_.quickreplybutton_ = quickreplybutton; - } - // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.quickReplyButton) -} -void TemplateButton::set_allocated_urlbutton(::proto::TemplateButton_URLButton* urlbutton) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_button(); - if (urlbutton) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(urlbutton); - if (message_arena != submessage_arena) { - urlbutton = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, urlbutton, submessage_arena); - } - set_has_urlbutton(); - _impl_.button_.urlbutton_ = urlbutton; - } - // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.urlButton) -} -void TemplateButton::set_allocated_callbutton(::proto::TemplateButton_CallButton* callbutton) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_button(); - if (callbutton) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(callbutton); - if (message_arena != submessage_arena) { - callbutton = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, callbutton, submessage_arena); - } - set_has_callbutton(); - _impl_.button_.callbutton_ = callbutton; - } - // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.callButton) -} -TemplateButton::TemplateButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.TemplateButton) -} -TemplateButton::TemplateButton(const TemplateButton& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - TemplateButton* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.index_){} - , decltype(_impl_.button_){} - , /*decltype(_impl_._oneof_case_)*/{}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _this->_impl_.index_ = from._impl_.index_; - clear_has_button(); - switch (from.button_case()) { - case kQuickReplyButton: { - _this->_internal_mutable_quickreplybutton()->::proto::TemplateButton_QuickReplyButton::MergeFrom( - from._internal_quickreplybutton()); - break; - } - case kUrlButton: { - _this->_internal_mutable_urlbutton()->::proto::TemplateButton_URLButton::MergeFrom( - from._internal_urlbutton()); - break; - } - case kCallButton: { - _this->_internal_mutable_callbutton()->::proto::TemplateButton_CallButton::MergeFrom( - from._internal_callbutton()); - break; - } - case BUTTON_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:proto.TemplateButton) -} - -inline void TemplateButton::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.index_){0u} - , decltype(_impl_.button_){} - , /*decltype(_impl_._oneof_case_)*/{} - }; - clear_has_button(); -} - -TemplateButton::~TemplateButton() { - // @@protoc_insertion_point(destructor:proto.TemplateButton) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void TemplateButton::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (has_button()) { - clear_button(); - } -} - -void TemplateButton::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void TemplateButton::clear_button() { -// @@protoc_insertion_point(one_of_clear_start:proto.TemplateButton) - switch (button_case()) { - case kQuickReplyButton: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.button_.quickreplybutton_; - } - break; - } - case kUrlButton: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.button_.urlbutton_; - } - break; - } - case kCallButton: { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.button_.callbutton_; - } - break; - } - case BUTTON_NOT_SET: { - break; - } - } - _impl_._oneof_case_[0] = BUTTON_NOT_SET; -} - - -void TemplateButton::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.TemplateButton) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.index_ = 0u; - clear_button(); - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* TemplateButton::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .proto.TemplateButton.QuickReplyButton quickReplyButton = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_quickreplybutton(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .proto.TemplateButton.URLButton urlButton = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_urlbutton(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .proto.TemplateButton.CallButton callButton = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_callbutton(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 index = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - _Internal::set_has_index(&has_bits); - _impl_.index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* TemplateButton::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.TemplateButton) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - switch (button_case()) { - case kQuickReplyButton: { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::quickreplybutton(this), - _Internal::quickreplybutton(this).GetCachedSize(), target, stream); - break; - } - case kUrlButton: { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::urlbutton(this), - _Internal::urlbutton(this).GetCachedSize(), target, stream); - break; - } - case kCallButton: { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, _Internal::callbutton(this), - _Internal::callbutton(this).GetCachedSize(), target, stream); - break; - } - default: ; - } - cached_has_bits = _impl_._has_bits_[0]; - // optional uint32 index = 4; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_index(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.TemplateButton) - return target; -} - -size_t TemplateButton::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.TemplateButton) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // optional uint32 index = 4; - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_index()); - } - - switch (button_case()) { - // .proto.TemplateButton.QuickReplyButton quickReplyButton = 1; - case kQuickReplyButton: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.button_.quickreplybutton_); - break; - } - // .proto.TemplateButton.URLButton urlButton = 2; - case kUrlButton: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.button_.urlbutton_); - break; - } - // .proto.TemplateButton.CallButton callButton = 3; - case kCallButton: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.button_.callbutton_); - break; - } - case BUTTON_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TemplateButton::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - TemplateButton::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TemplateButton::GetClassData() const { return &_class_data_; } - - -void TemplateButton::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.TemplateButton) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_index()) { - _this->_internal_set_index(from._internal_index()); - } - switch (from.button_case()) { - case kQuickReplyButton: { - _this->_internal_mutable_quickreplybutton()->::proto::TemplateButton_QuickReplyButton::MergeFrom( - from._internal_quickreplybutton()); - break; - } - case kUrlButton: { - _this->_internal_mutable_urlbutton()->::proto::TemplateButton_URLButton::MergeFrom( - from._internal_urlbutton()); - break; - } - case kCallButton: { - _this->_internal_mutable_callbutton()->::proto::TemplateButton_CallButton::MergeFrom( - from._internal_callbutton()); - break; - } - case BUTTON_NOT_SET: { - break; - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void TemplateButton::CopyFrom(const TemplateButton& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.TemplateButton) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool TemplateButton::IsInitialized() const { - return true; -} - -void TemplateButton::InternalSwap(TemplateButton* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - swap(_impl_.index_, other->_impl_.index_); - swap(_impl_.button_, other->_impl_.button_); - swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata TemplateButton::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[216]); -} - -// =================================================================== - -class UserReceipt::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_userjid(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_receipttimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_readtimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_playedtimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static bool MissingRequiredFields(const HasBits& has_bits) { - return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0; - } -}; - -UserReceipt::UserReceipt(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.UserReceipt) -} -UserReceipt::UserReceipt(const UserReceipt& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - UserReceipt* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.pendingdevicejid_){from._impl_.pendingdevicejid_} - , decltype(_impl_.delivereddevicejid_){from._impl_.delivereddevicejid_} - , decltype(_impl_.userjid_){} - , decltype(_impl_.receipttimestamp_){} - , decltype(_impl_.readtimestamp_){} - , decltype(_impl_.playedtimestamp_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.userjid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.userjid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_userjid()) { - _this->_impl_.userjid_.Set(from._internal_userjid(), - _this->GetArenaForAllocation()); - } - ::memcpy(&_impl_.receipttimestamp_, &from._impl_.receipttimestamp_, - static_cast(reinterpret_cast(&_impl_.playedtimestamp_) - - reinterpret_cast(&_impl_.receipttimestamp_)) + sizeof(_impl_.playedtimestamp_)); - // @@protoc_insertion_point(copy_constructor:proto.UserReceipt) -} - -inline void UserReceipt::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.pendingdevicejid_){arena} - , decltype(_impl_.delivereddevicejid_){arena} - , decltype(_impl_.userjid_){} - , decltype(_impl_.receipttimestamp_){int64_t{0}} - , decltype(_impl_.readtimestamp_){int64_t{0}} - , decltype(_impl_.playedtimestamp_){int64_t{0}} - }; - _impl_.userjid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.userjid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -UserReceipt::~UserReceipt() { - // @@protoc_insertion_point(destructor:proto.UserReceipt) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void UserReceipt::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.pendingdevicejid_.~RepeatedPtrField(); - _impl_.delivereddevicejid_.~RepeatedPtrField(); - _impl_.userjid_.Destroy(); -} - -void UserReceipt::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void UserReceipt::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.UserReceipt) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.pendingdevicejid_.Clear(); - _impl_.delivereddevicejid_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.userjid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x0000000eu) { - ::memset(&_impl_.receipttimestamp_, 0, static_cast( - reinterpret_cast(&_impl_.playedtimestamp_) - - reinterpret_cast(&_impl_.receipttimestamp_)) + sizeof(_impl_.playedtimestamp_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* UserReceipt::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // required string userJid = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_userjid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.UserReceipt.userJid"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional int64 receiptTimestamp = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_receipttimestamp(&has_bits); - _impl_.receipttimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional int64 readTimestamp = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_readtimestamp(&has_bits); - _impl_.readtimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional int64 playedTimestamp = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - _Internal::set_has_playedtimestamp(&has_bits); - _impl_.playedtimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated string pendingDeviceJid = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - ptr -= 1; - do { - ptr += 1; - auto str = _internal_add_pendingdevicejid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.UserReceipt.pendingDeviceJid"); - #endif // !NDEBUG - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr)); - } else - goto handle_unusual; - continue; - // repeated string deliveredDeviceJid = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - ptr -= 1; - do { - ptr += 1; - auto str = _internal_add_delivereddevicejid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.UserReceipt.deliveredDeviceJid"); - #endif // !NDEBUG - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr)); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* UserReceipt::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.UserReceipt) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // required string userJid = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_userjid().data(), static_cast(this->_internal_userjid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.UserReceipt.userJid"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_userjid(), target); - } - - // optional int64 receiptTimestamp = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_receipttimestamp(), target); - } - - // optional int64 readTimestamp = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_readtimestamp(), target); - } - - // optional int64 playedTimestamp = 4; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_playedtimestamp(), target); - } - - // repeated string pendingDeviceJid = 5; - for (int i = 0, n = this->_internal_pendingdevicejid_size(); i < n; i++) { - const auto& s = this->_internal_pendingdevicejid(i); - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - s.data(), static_cast(s.length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.UserReceipt.pendingDeviceJid"); - target = stream->WriteString(5, s, target); - } - - // repeated string deliveredDeviceJid = 6; - for (int i = 0, n = this->_internal_delivereddevicejid_size(); i < n; i++) { - const auto& s = this->_internal_delivereddevicejid(i); - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - s.data(), static_cast(s.length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.UserReceipt.deliveredDeviceJid"); - target = stream->WriteString(6, s, target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.UserReceipt) - return target; -} - -size_t UserReceipt::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.UserReceipt) - size_t total_size = 0; - - // required string userJid = 1; - if (_internal_has_userjid()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_userjid()); - } - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated string pendingDeviceJid = 5; - total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.pendingdevicejid_.size()); - for (int i = 0, n = _impl_.pendingdevicejid_.size(); i < n; i++) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - _impl_.pendingdevicejid_.Get(i)); - } - - // repeated string deliveredDeviceJid = 6; - total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.delivereddevicejid_.size()); - for (int i = 0, n = _impl_.delivereddevicejid_.size(); i < n; i++) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - _impl_.delivereddevicejid_.Get(i)); - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000eu) { - // optional int64 receiptTimestamp = 2; - if (cached_has_bits & 0x00000002u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_receipttimestamp()); - } - - // optional int64 readTimestamp = 3; - if (cached_has_bits & 0x00000004u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_readtimestamp()); - } - - // optional int64 playedTimestamp = 4; - if (cached_has_bits & 0x00000008u) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_playedtimestamp()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData UserReceipt::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - UserReceipt::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*UserReceipt::GetClassData() const { return &_class_data_; } - - -void UserReceipt::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.UserReceipt) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.pendingdevicejid_.MergeFrom(from._impl_.pendingdevicejid_); - _this->_impl_.delivereddevicejid_.MergeFrom(from._impl_.delivereddevicejid_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_userjid(from._internal_userjid()); - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.receipttimestamp_ = from._impl_.receipttimestamp_; - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.readtimestamp_ = from._impl_.readtimestamp_; - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.playedtimestamp_ = from._impl_.playedtimestamp_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void UserReceipt::CopyFrom(const UserReceipt& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.UserReceipt) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool UserReceipt::IsInitialized() const { - if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false; - return true; -} - -void UserReceipt::InternalSwap(UserReceipt* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.pendingdevicejid_.InternalSwap(&other->_impl_.pendingdevicejid_); - _impl_.delivereddevicejid_.InternalSwap(&other->_impl_.delivereddevicejid_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.userjid_, lhs_arena, - &other->_impl_.userjid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(UserReceipt, _impl_.playedtimestamp_) - + sizeof(UserReceipt::_impl_.playedtimestamp_) - - PROTOBUF_FIELD_OFFSET(UserReceipt, _impl_.receipttimestamp_)>( - reinterpret_cast(&_impl_.receipttimestamp_), - reinterpret_cast(&other->_impl_.receipttimestamp_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata UserReceipt::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[217]); -} - -// =================================================================== - -class VerifiedNameCertificate_Details::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_serial(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_issuer(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_verifiedname(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_issuetime(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } -}; - -VerifiedNameCertificate_Details::VerifiedNameCertificate_Details(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.VerifiedNameCertificate.Details) -} -VerifiedNameCertificate_Details::VerifiedNameCertificate_Details(const VerifiedNameCertificate_Details& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - VerifiedNameCertificate_Details* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.localizednames_){from._impl_.localizednames_} - , decltype(_impl_.issuer_){} - , decltype(_impl_.verifiedname_){} - , decltype(_impl_.serial_){} - , decltype(_impl_.issuetime_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.issuer_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.issuer_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_issuer()) { - _this->_impl_.issuer_.Set(from._internal_issuer(), - _this->GetArenaForAllocation()); - } - _impl_.verifiedname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.verifiedname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_verifiedname()) { - _this->_impl_.verifiedname_.Set(from._internal_verifiedname(), - _this->GetArenaForAllocation()); - } - ::memcpy(&_impl_.serial_, &from._impl_.serial_, - static_cast(reinterpret_cast(&_impl_.issuetime_) - - reinterpret_cast(&_impl_.serial_)) + sizeof(_impl_.issuetime_)); - // @@protoc_insertion_point(copy_constructor:proto.VerifiedNameCertificate.Details) -} - -inline void VerifiedNameCertificate_Details::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.localizednames_){arena} - , decltype(_impl_.issuer_){} - , decltype(_impl_.verifiedname_){} - , decltype(_impl_.serial_){uint64_t{0u}} - , decltype(_impl_.issuetime_){uint64_t{0u}} - }; - _impl_.issuer_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.issuer_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.verifiedname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.verifiedname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -VerifiedNameCertificate_Details::~VerifiedNameCertificate_Details() { - // @@protoc_insertion_point(destructor:proto.VerifiedNameCertificate.Details) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void VerifiedNameCertificate_Details::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.localizednames_.~RepeatedPtrField(); - _impl_.issuer_.Destroy(); - _impl_.verifiedname_.Destroy(); -} - -void VerifiedNameCertificate_Details::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void VerifiedNameCertificate_Details::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.VerifiedNameCertificate.Details) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.localizednames_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _impl_.issuer_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.verifiedname_.ClearNonDefaultToEmpty(); - } - } - if (cached_has_bits & 0x0000000cu) { - ::memset(&_impl_.serial_, 0, static_cast( - reinterpret_cast(&_impl_.issuetime_) - - reinterpret_cast(&_impl_.serial_)) + sizeof(_impl_.issuetime_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* VerifiedNameCertificate_Details::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional uint64 serial = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_serial(&has_bits); - _impl_.serial_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string issuer = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_issuer(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.VerifiedNameCertificate.Details.issuer"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional string verifiedName = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - auto str = _internal_mutable_verifiedname(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.VerifiedNameCertificate.Details.verifiedName"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // repeated .proto.LocalizedName localizedNames = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_localizednames(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(ptr)); - } else - goto handle_unusual; - continue; - // optional uint64 issueTime = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { - _Internal::set_has_issuetime(&has_bits); - _impl_.issuetime_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* VerifiedNameCertificate_Details::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.VerifiedNameCertificate.Details) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional uint64 serial = 1; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_serial(), target); - } - - // optional string issuer = 2; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_issuer().data(), static_cast(this->_internal_issuer().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.VerifiedNameCertificate.Details.issuer"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_issuer(), target); - } - - // optional string verifiedName = 4; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_verifiedname().data(), static_cast(this->_internal_verifiedname().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.VerifiedNameCertificate.Details.verifiedName"); - target = stream->WriteStringMaybeAliased( - 4, this->_internal_verifiedname(), target); - } - - // repeated .proto.LocalizedName localizedNames = 8; - for (unsigned i = 0, - n = static_cast(this->_internal_localizednames_size()); i < n; i++) { - const auto& repfield = this->_internal_localizednames(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(8, repfield, repfield.GetCachedSize(), target, stream); - } - - // optional uint64 issueTime = 10; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(10, this->_internal_issuetime(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.VerifiedNameCertificate.Details) - return target; -} - -size_t VerifiedNameCertificate_Details::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.VerifiedNameCertificate.Details) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.LocalizedName localizedNames = 8; - total_size += 1UL * this->_internal_localizednames_size(); - for (const auto& msg : this->_impl_.localizednames_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - // optional string issuer = 2; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_issuer()); - } - - // optional string verifiedName = 4; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_verifiedname()); - } - - // optional uint64 serial = 1; - if (cached_has_bits & 0x00000004u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_serial()); - } - - // optional uint64 issueTime = 10; - if (cached_has_bits & 0x00000008u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_issuetime()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData VerifiedNameCertificate_Details::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - VerifiedNameCertificate_Details::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*VerifiedNameCertificate_Details::GetClassData() const { return &_class_data_; } - - -void VerifiedNameCertificate_Details::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.VerifiedNameCertificate.Details) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.localizednames_.MergeFrom(from._impl_.localizednames_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_issuer(from._internal_issuer()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_verifiedname(from._internal_verifiedname()); - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.serial_ = from._impl_.serial_; - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.issuetime_ = from._impl_.issuetime_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void VerifiedNameCertificate_Details::CopyFrom(const VerifiedNameCertificate_Details& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.VerifiedNameCertificate.Details) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool VerifiedNameCertificate_Details::IsInitialized() const { - return true; -} - -void VerifiedNameCertificate_Details::InternalSwap(VerifiedNameCertificate_Details* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.localizednames_.InternalSwap(&other->_impl_.localizednames_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.issuer_, lhs_arena, - &other->_impl_.issuer_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.verifiedname_, lhs_arena, - &other->_impl_.verifiedname_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(VerifiedNameCertificate_Details, _impl_.issuetime_) - + sizeof(VerifiedNameCertificate_Details::_impl_.issuetime_) - - PROTOBUF_FIELD_OFFSET(VerifiedNameCertificate_Details, _impl_.serial_)>( - reinterpret_cast(&_impl_.serial_), - reinterpret_cast(&other->_impl_.serial_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata VerifiedNameCertificate_Details::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[218]); -} - -// =================================================================== - -class VerifiedNameCertificate::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_details(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_signature(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_serversignature(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } -}; - -VerifiedNameCertificate::VerifiedNameCertificate(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.VerifiedNameCertificate) -} -VerifiedNameCertificate::VerifiedNameCertificate(const VerifiedNameCertificate& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - VerifiedNameCertificate* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.details_){} - , decltype(_impl_.signature_){} - , decltype(_impl_.serversignature_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.details_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.details_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_details()) { - _this->_impl_.details_.Set(from._internal_details(), - _this->GetArenaForAllocation()); - } - _impl_.signature_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.signature_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_signature()) { - _this->_impl_.signature_.Set(from._internal_signature(), - _this->GetArenaForAllocation()); - } - _impl_.serversignature_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.serversignature_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_serversignature()) { - _this->_impl_.serversignature_.Set(from._internal_serversignature(), - _this->GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:proto.VerifiedNameCertificate) -} - -inline void VerifiedNameCertificate::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.details_){} - , decltype(_impl_.signature_){} - , decltype(_impl_.serversignature_){} - }; - _impl_.details_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.details_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.signature_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.signature_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.serversignature_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.serversignature_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -VerifiedNameCertificate::~VerifiedNameCertificate() { - // @@protoc_insertion_point(destructor:proto.VerifiedNameCertificate) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void VerifiedNameCertificate::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.details_.Destroy(); - _impl_.signature_.Destroy(); - _impl_.serversignature_.Destroy(); -} - -void VerifiedNameCertificate::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void VerifiedNameCertificate::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.VerifiedNameCertificate) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _impl_.details_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.signature_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.serversignature_.ClearNonDefaultToEmpty(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* VerifiedNameCertificate::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional bytes details = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_details(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes signature = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_signature(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes serverSignature = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_serversignature(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* VerifiedNameCertificate::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.VerifiedNameCertificate) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional bytes details = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->WriteBytesMaybeAliased( - 1, this->_internal_details(), target); - } - - // optional bytes signature = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_signature(), target); - } - - // optional bytes serverSignature = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->WriteBytesMaybeAliased( - 3, this->_internal_serversignature(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.VerifiedNameCertificate) - return target; -} - -size_t VerifiedNameCertificate::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.VerifiedNameCertificate) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional bytes details = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_details()); - } - - // optional bytes signature = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_signature()); - } - - // optional bytes serverSignature = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_serversignature()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData VerifiedNameCertificate::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - VerifiedNameCertificate::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*VerifiedNameCertificate::GetClassData() const { return &_class_data_; } - - -void VerifiedNameCertificate::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.VerifiedNameCertificate) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_details(from._internal_details()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_signature(from._internal_signature()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_serversignature(from._internal_serversignature()); - } - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void VerifiedNameCertificate::CopyFrom(const VerifiedNameCertificate& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.VerifiedNameCertificate) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool VerifiedNameCertificate::IsInitialized() const { - return true; -} - -void VerifiedNameCertificate::InternalSwap(VerifiedNameCertificate* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.details_, lhs_arena, - &other->_impl_.details_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.signature_, lhs_arena, - &other->_impl_.signature_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.serversignature_, lhs_arena, - &other->_impl_.serversignature_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata VerifiedNameCertificate::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[219]); -} - -// =================================================================== - -class WallpaperSettings::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_filename(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_opacity(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } -}; - -WallpaperSettings::WallpaperSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.WallpaperSettings) -} -WallpaperSettings::WallpaperSettings(const WallpaperSettings& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - WallpaperSettings* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.filename_){} - , decltype(_impl_.opacity_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.filename_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filename_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_filename()) { - _this->_impl_.filename_.Set(from._internal_filename(), - _this->GetArenaForAllocation()); - } - _this->_impl_.opacity_ = from._impl_.opacity_; - // @@protoc_insertion_point(copy_constructor:proto.WallpaperSettings) -} - -inline void WallpaperSettings::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.filename_){} - , decltype(_impl_.opacity_){0u} - }; - _impl_.filename_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.filename_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -WallpaperSettings::~WallpaperSettings() { - // @@protoc_insertion_point(destructor:proto.WallpaperSettings) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void WallpaperSettings::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.filename_.Destroy(); -} - -void WallpaperSettings::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void WallpaperSettings::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.WallpaperSettings) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - _impl_.filename_.ClearNonDefaultToEmpty(); - } - _impl_.opacity_ = 0u; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* WallpaperSettings::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional string filename = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_filename(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.WallpaperSettings.filename"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional uint32 opacity = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_opacity(&has_bits); - _impl_.opacity_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* WallpaperSettings::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.WallpaperSettings) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional string filename = 1; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_filename().data(), static_cast(this->_internal_filename().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.WallpaperSettings.filename"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_filename(), target); - } - - // optional uint32 opacity = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_opacity(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.WallpaperSettings) - return target; -} - -size_t WallpaperSettings::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.WallpaperSettings) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - // optional string filename = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_filename()); - } - - // optional uint32 opacity = 2; - if (cached_has_bits & 0x00000002u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_opacity()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData WallpaperSettings::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - WallpaperSettings::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*WallpaperSettings::GetClassData() const { return &_class_data_; } - - -void WallpaperSettings::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.WallpaperSettings) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_filename(from._internal_filename()); - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.opacity_ = from._impl_.opacity_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void WallpaperSettings::CopyFrom(const WallpaperSettings& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.WallpaperSettings) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool WallpaperSettings::IsInitialized() const { - return true; -} - -void WallpaperSettings::InternalSwap(WallpaperSettings* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.filename_, lhs_arena, - &other->_impl_.filename_, rhs_arena - ); - swap(_impl_.opacity_, other->_impl_.opacity_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata WallpaperSettings::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[220]); -} - -// =================================================================== - -class WebFeatures::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_labelsdisplay(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_voipindividualoutgoing(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_groupsv3(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_groupsv3create(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_changenumberv2(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static void set_has_querystatusv3thumbnail(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static void set_has_livelocations(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static void set_has_queryvname(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } - static void set_has_voipindividualincoming(HasBits* has_bits) { - (*has_bits)[0] |= 256u; - } - static void set_has_quickrepliesquery(HasBits* has_bits) { - (*has_bits)[0] |= 512u; - } - static void set_has_payments(HasBits* has_bits) { - (*has_bits)[0] |= 1024u; - } - static void set_has_stickerpackquery(HasBits* has_bits) { - (*has_bits)[0] |= 2048u; - } - static void set_has_livelocationsfinal(HasBits* has_bits) { - (*has_bits)[0] |= 4096u; - } - static void set_has_labelsedit(HasBits* has_bits) { - (*has_bits)[0] |= 8192u; - } - static void set_has_mediaupload(HasBits* has_bits) { - (*has_bits)[0] |= 16384u; - } - static void set_has_mediauploadrichquickreplies(HasBits* has_bits) { - (*has_bits)[0] |= 32768u; - } - static void set_has_vnamev2(HasBits* has_bits) { - (*has_bits)[0] |= 65536u; - } - static void set_has_videoplaybackurl(HasBits* has_bits) { - (*has_bits)[0] |= 131072u; - } - static void set_has_statusranking(HasBits* has_bits) { - (*has_bits)[0] |= 262144u; - } - static void set_has_voipindividualvideo(HasBits* has_bits) { - (*has_bits)[0] |= 524288u; - } - static void set_has_thirdpartystickers(HasBits* has_bits) { - (*has_bits)[0] |= 1048576u; - } - static void set_has_frequentlyforwardedsetting(HasBits* has_bits) { - (*has_bits)[0] |= 2097152u; - } - static void set_has_groupsv4joinpermission(HasBits* has_bits) { - (*has_bits)[0] |= 4194304u; - } - static void set_has_recentstickers(HasBits* has_bits) { - (*has_bits)[0] |= 8388608u; - } - static void set_has_catalog(HasBits* has_bits) { - (*has_bits)[0] |= 16777216u; - } - static void set_has_starredstickers(HasBits* has_bits) { - (*has_bits)[0] |= 33554432u; - } - static void set_has_voipgroupcall(HasBits* has_bits) { - (*has_bits)[0] |= 67108864u; - } - static void set_has_templatemessage(HasBits* has_bits) { - (*has_bits)[0] |= 134217728u; - } - static void set_has_templatemessageinteractivity(HasBits* has_bits) { - (*has_bits)[0] |= 268435456u; - } - static void set_has_ephemeralmessages(HasBits* has_bits) { - (*has_bits)[0] |= 536870912u; - } - static void set_has_e2enotificationsync(HasBits* has_bits) { - (*has_bits)[0] |= 1073741824u; - } - static void set_has_recentstickersv2(HasBits* has_bits) { - (*has_bits)[0] |= 2147483648u; - } - static void set_has_recentstickersv3(HasBits* has_bits) { - (*has_bits)[1] |= 1u; - } - static void set_has_usernotice(HasBits* has_bits) { - (*has_bits)[1] |= 2u; - } - static void set_has_support(HasBits* has_bits) { - (*has_bits)[1] |= 4u; - } - static void set_has_groupuiicleanup(HasBits* has_bits) { - (*has_bits)[1] |= 8u; - } - static void set_has_groupdogfoodinginternalonly(HasBits* has_bits) { - (*has_bits)[1] |= 16u; - } - static void set_has_settingssync(HasBits* has_bits) { - (*has_bits)[1] |= 32u; - } - static void set_has_archivev2(HasBits* has_bits) { - (*has_bits)[1] |= 64u; - } - static void set_has_ephemeralallowgroupmembers(HasBits* has_bits) { - (*has_bits)[1] |= 128u; - } - static void set_has_ephemeral24hduration(HasBits* has_bits) { - (*has_bits)[1] |= 256u; - } - static void set_has_mdforceupgrade(HasBits* has_bits) { - (*has_bits)[1] |= 512u; - } - static void set_has_disappearingmode(HasBits* has_bits) { - (*has_bits)[1] |= 1024u; - } - static void set_has_externalmdoptinavailable(HasBits* has_bits) { - (*has_bits)[1] |= 2048u; - } - static void set_has_nodeletemessagetimelimit(HasBits* has_bits) { - (*has_bits)[1] |= 4096u; - } -}; - -WebFeatures::WebFeatures(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.WebFeatures) -} -WebFeatures::WebFeatures(const WebFeatures& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - WebFeatures* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.labelsdisplay_){} - , decltype(_impl_.voipindividualoutgoing_){} - , decltype(_impl_.groupsv3_){} - , decltype(_impl_.groupsv3create_){} - , decltype(_impl_.changenumberv2_){} - , decltype(_impl_.querystatusv3thumbnail_){} - , decltype(_impl_.livelocations_){} - , decltype(_impl_.queryvname_){} - , decltype(_impl_.voipindividualincoming_){} - , decltype(_impl_.quickrepliesquery_){} - , decltype(_impl_.payments_){} - , decltype(_impl_.stickerpackquery_){} - , decltype(_impl_.livelocationsfinal_){} - , decltype(_impl_.labelsedit_){} - , decltype(_impl_.mediaupload_){} - , decltype(_impl_.mediauploadrichquickreplies_){} - , decltype(_impl_.vnamev2_){} - , decltype(_impl_.videoplaybackurl_){} - , decltype(_impl_.statusranking_){} - , decltype(_impl_.voipindividualvideo_){} - , decltype(_impl_.thirdpartystickers_){} - , decltype(_impl_.frequentlyforwardedsetting_){} - , decltype(_impl_.groupsv4joinpermission_){} - , decltype(_impl_.recentstickers_){} - , decltype(_impl_.catalog_){} - , decltype(_impl_.starredstickers_){} - , decltype(_impl_.voipgroupcall_){} - , decltype(_impl_.templatemessage_){} - , decltype(_impl_.templatemessageinteractivity_){} - , decltype(_impl_.ephemeralmessages_){} - , decltype(_impl_.e2enotificationsync_){} - , decltype(_impl_.recentstickersv2_){} - , decltype(_impl_.recentstickersv3_){} - , decltype(_impl_.usernotice_){} - , decltype(_impl_.support_){} - , decltype(_impl_.groupuiicleanup_){} - , decltype(_impl_.groupdogfoodinginternalonly_){} - , decltype(_impl_.settingssync_){} - , decltype(_impl_.archivev2_){} - , decltype(_impl_.ephemeralallowgroupmembers_){} - , decltype(_impl_.ephemeral24hduration_){} - , decltype(_impl_.mdforceupgrade_){} - , decltype(_impl_.disappearingmode_){} - , decltype(_impl_.externalmdoptinavailable_){} - , decltype(_impl_.nodeletemessagetimelimit_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&_impl_.labelsdisplay_, &from._impl_.labelsdisplay_, - static_cast(reinterpret_cast(&_impl_.nodeletemessagetimelimit_) - - reinterpret_cast(&_impl_.labelsdisplay_)) + sizeof(_impl_.nodeletemessagetimelimit_)); - // @@protoc_insertion_point(copy_constructor:proto.WebFeatures) -} - -inline void WebFeatures::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.labelsdisplay_){0} - , decltype(_impl_.voipindividualoutgoing_){0} - , decltype(_impl_.groupsv3_){0} - , decltype(_impl_.groupsv3create_){0} - , decltype(_impl_.changenumberv2_){0} - , decltype(_impl_.querystatusv3thumbnail_){0} - , decltype(_impl_.livelocations_){0} - , decltype(_impl_.queryvname_){0} - , decltype(_impl_.voipindividualincoming_){0} - , decltype(_impl_.quickrepliesquery_){0} - , decltype(_impl_.payments_){0} - , decltype(_impl_.stickerpackquery_){0} - , decltype(_impl_.livelocationsfinal_){0} - , decltype(_impl_.labelsedit_){0} - , decltype(_impl_.mediaupload_){0} - , decltype(_impl_.mediauploadrichquickreplies_){0} - , decltype(_impl_.vnamev2_){0} - , decltype(_impl_.videoplaybackurl_){0} - , decltype(_impl_.statusranking_){0} - , decltype(_impl_.voipindividualvideo_){0} - , decltype(_impl_.thirdpartystickers_){0} - , decltype(_impl_.frequentlyforwardedsetting_){0} - , decltype(_impl_.groupsv4joinpermission_){0} - , decltype(_impl_.recentstickers_){0} - , decltype(_impl_.catalog_){0} - , decltype(_impl_.starredstickers_){0} - , decltype(_impl_.voipgroupcall_){0} - , decltype(_impl_.templatemessage_){0} - , decltype(_impl_.templatemessageinteractivity_){0} - , decltype(_impl_.ephemeralmessages_){0} - , decltype(_impl_.e2enotificationsync_){0} - , decltype(_impl_.recentstickersv2_){0} - , decltype(_impl_.recentstickersv3_){0} - , decltype(_impl_.usernotice_){0} - , decltype(_impl_.support_){0} - , decltype(_impl_.groupuiicleanup_){0} - , decltype(_impl_.groupdogfoodinginternalonly_){0} - , decltype(_impl_.settingssync_){0} - , decltype(_impl_.archivev2_){0} - , decltype(_impl_.ephemeralallowgroupmembers_){0} - , decltype(_impl_.ephemeral24hduration_){0} - , decltype(_impl_.mdforceupgrade_){0} - , decltype(_impl_.disappearingmode_){0} - , decltype(_impl_.externalmdoptinavailable_){0} - , decltype(_impl_.nodeletemessagetimelimit_){0} - }; -} - -WebFeatures::~WebFeatures() { - // @@protoc_insertion_point(destructor:proto.WebFeatures) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void WebFeatures::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void WebFeatures::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void WebFeatures::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.WebFeatures) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - ::memset(&_impl_.labelsdisplay_, 0, static_cast( - reinterpret_cast(&_impl_.queryvname_) - - reinterpret_cast(&_impl_.labelsdisplay_)) + sizeof(_impl_.queryvname_)); - } - if (cached_has_bits & 0x0000ff00u) { - ::memset(&_impl_.voipindividualincoming_, 0, static_cast( - reinterpret_cast(&_impl_.mediauploadrichquickreplies_) - - reinterpret_cast(&_impl_.voipindividualincoming_)) + sizeof(_impl_.mediauploadrichquickreplies_)); - } - if (cached_has_bits & 0x00ff0000u) { - ::memset(&_impl_.vnamev2_, 0, static_cast( - reinterpret_cast(&_impl_.recentstickers_) - - reinterpret_cast(&_impl_.vnamev2_)) + sizeof(_impl_.recentstickers_)); - } - if (cached_has_bits & 0xff000000u) { - ::memset(&_impl_.catalog_, 0, static_cast( - reinterpret_cast(&_impl_.recentstickersv2_) - - reinterpret_cast(&_impl_.catalog_)) + sizeof(_impl_.recentstickersv2_)); - } - cached_has_bits = _impl_._has_bits_[1]; - if (cached_has_bits & 0x000000ffu) { - ::memset(&_impl_.recentstickersv3_, 0, static_cast( - reinterpret_cast(&_impl_.ephemeralallowgroupmembers_) - - reinterpret_cast(&_impl_.recentstickersv3_)) + sizeof(_impl_.ephemeralallowgroupmembers_)); - } - if (cached_has_bits & 0x00001f00u) { - ::memset(&_impl_.ephemeral24hduration_, 0, static_cast( - reinterpret_cast(&_impl_.nodeletemessagetimelimit_) - - reinterpret_cast(&_impl_.ephemeral24hduration_)) + sizeof(_impl_.nodeletemessagetimelimit_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* WebFeatures::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional .proto.WebFeatures.Flag labelsDisplay = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_labelsdisplay(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag voipIndividualOutgoing = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_voipindividualoutgoing(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag groupsV3 = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_groupsv3(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag groupsV3Create = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_groupsv3create(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag changeNumberV2 = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_changenumberv2(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag queryStatusV3Thumbnail = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_querystatusv3thumbnail(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(6, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag liveLocations = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_livelocations(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(7, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag queryVname = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_queryvname(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(8, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag voipIndividualIncoming = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_voipindividualincoming(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(9, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag quickRepliesQuery = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_quickrepliesquery(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(10, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag payments = 11; - case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_payments(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(11, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag stickerPackQuery = 12; - case 12: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_stickerpackquery(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(12, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag liveLocationsFinal = 13; - case 13: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 104)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_livelocationsfinal(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(13, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag labelsEdit = 14; - case 14: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 112)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_labelsedit(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(14, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag mediaUpload = 15; - case 15: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 120)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_mediaupload(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(15, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag mediaUploadRichQuickReplies = 18; - case 18: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 144)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_mediauploadrichquickreplies(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(18, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag vnameV2 = 19; - case 19: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 152)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_vnamev2(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(19, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag videoPlaybackUrl = 20; - case 20: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 160)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_videoplaybackurl(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(20, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag statusRanking = 21; - case 21: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 168)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_statusranking(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(21, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag voipIndividualVideo = 22; - case 22: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 176)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_voipindividualvideo(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(22, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag thirdPartyStickers = 23; - case 23: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 184)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_thirdpartystickers(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(23, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag frequentlyForwardedSetting = 24; - case 24: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 192)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_frequentlyforwardedsetting(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(24, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag groupsV4JoinPermission = 25; - case 25: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 200)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_groupsv4joinpermission(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(25, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag recentStickers = 26; - case 26: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 208)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_recentstickers(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(26, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag catalog = 27; - case 27: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 216)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_catalog(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(27, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag starredStickers = 28; - case 28: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 224)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_starredstickers(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(28, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag voipGroupCall = 29; - case 29: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 232)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_voipgroupcall(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(29, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag templateMessage = 30; - case 30: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 240)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_templatemessage(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(30, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag templateMessageInteractivity = 31; - case 31: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 248)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_templatemessageinteractivity(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(31, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag ephemeralMessages = 32; - case 32: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 0)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_ephemeralmessages(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(32, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag e2ENotificationSync = 33; - case 33: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_e2enotificationsync(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(33, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag recentStickersV2 = 34; - case 34: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_recentstickersv2(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(34, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag recentStickersV3 = 36; - case 36: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_recentstickersv3(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(36, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag userNotice = 37; - case 37: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_usernotice(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(37, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag support = 39; - case 39: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_support(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(39, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag groupUiiCleanup = 40; - case 40: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_groupuiicleanup(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(40, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag groupDogfoodingInternalOnly = 41; - case 41: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_groupdogfoodinginternalonly(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(41, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag settingsSync = 42; - case 42: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_settingssync(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(42, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag archiveV2 = 43; - case 43: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_archivev2(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(43, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag ephemeralAllowGroupMembers = 44; - case 44: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_ephemeralallowgroupmembers(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(44, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag ephemeral24HDuration = 45; - case 45: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 104)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_ephemeral24hduration(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(45, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag mdForceUpgrade = 46; - case 46: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 112)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_mdforceupgrade(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(46, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag disappearingMode = 47; - case 47: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 120)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_disappearingmode(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(47, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag externalMdOptInAvailable = 48; - case 48: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 128)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_externalmdoptinavailable(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(48, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional .proto.WebFeatures.Flag noDeleteMessageTimeLimit = 49; - case 49: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 136)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebFeatures_Flag_IsValid(val))) { - _internal_set_nodeletemessagetimelimit(static_cast<::proto::WebFeatures_Flag>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(49, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* WebFeatures::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.WebFeatures) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional .proto.WebFeatures.Flag labelsDisplay = 1; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 1, this->_internal_labelsdisplay(), target); - } - - // optional .proto.WebFeatures.Flag voipIndividualOutgoing = 2; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 2, this->_internal_voipindividualoutgoing(), target); - } - - // optional .proto.WebFeatures.Flag groupsV3 = 3; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 3, this->_internal_groupsv3(), target); - } - - // optional .proto.WebFeatures.Flag groupsV3Create = 4; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 4, this->_internal_groupsv3create(), target); - } - - // optional .proto.WebFeatures.Flag changeNumberV2 = 5; - if (cached_has_bits & 0x00000010u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 5, this->_internal_changenumberv2(), target); - } - - // optional .proto.WebFeatures.Flag queryStatusV3Thumbnail = 6; - if (cached_has_bits & 0x00000020u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 6, this->_internal_querystatusv3thumbnail(), target); - } - - // optional .proto.WebFeatures.Flag liveLocations = 7; - if (cached_has_bits & 0x00000040u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 7, this->_internal_livelocations(), target); - } - - // optional .proto.WebFeatures.Flag queryVname = 8; - if (cached_has_bits & 0x00000080u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 8, this->_internal_queryvname(), target); - } - - // optional .proto.WebFeatures.Flag voipIndividualIncoming = 9; - if (cached_has_bits & 0x00000100u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 9, this->_internal_voipindividualincoming(), target); - } - - // optional .proto.WebFeatures.Flag quickRepliesQuery = 10; - if (cached_has_bits & 0x00000200u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 10, this->_internal_quickrepliesquery(), target); - } - - // optional .proto.WebFeatures.Flag payments = 11; - if (cached_has_bits & 0x00000400u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 11, this->_internal_payments(), target); - } - - // optional .proto.WebFeatures.Flag stickerPackQuery = 12; - if (cached_has_bits & 0x00000800u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 12, this->_internal_stickerpackquery(), target); - } - - // optional .proto.WebFeatures.Flag liveLocationsFinal = 13; - if (cached_has_bits & 0x00001000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 13, this->_internal_livelocationsfinal(), target); - } - - // optional .proto.WebFeatures.Flag labelsEdit = 14; - if (cached_has_bits & 0x00002000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 14, this->_internal_labelsedit(), target); - } - - // optional .proto.WebFeatures.Flag mediaUpload = 15; - if (cached_has_bits & 0x00004000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 15, this->_internal_mediaupload(), target); - } - - // optional .proto.WebFeatures.Flag mediaUploadRichQuickReplies = 18; - if (cached_has_bits & 0x00008000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 18, this->_internal_mediauploadrichquickreplies(), target); - } - - // optional .proto.WebFeatures.Flag vnameV2 = 19; - if (cached_has_bits & 0x00010000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 19, this->_internal_vnamev2(), target); - } - - // optional .proto.WebFeatures.Flag videoPlaybackUrl = 20; - if (cached_has_bits & 0x00020000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 20, this->_internal_videoplaybackurl(), target); - } - - // optional .proto.WebFeatures.Flag statusRanking = 21; - if (cached_has_bits & 0x00040000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 21, this->_internal_statusranking(), target); - } - - // optional .proto.WebFeatures.Flag voipIndividualVideo = 22; - if (cached_has_bits & 0x00080000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 22, this->_internal_voipindividualvideo(), target); - } - - // optional .proto.WebFeatures.Flag thirdPartyStickers = 23; - if (cached_has_bits & 0x00100000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 23, this->_internal_thirdpartystickers(), target); - } - - // optional .proto.WebFeatures.Flag frequentlyForwardedSetting = 24; - if (cached_has_bits & 0x00200000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 24, this->_internal_frequentlyforwardedsetting(), target); - } - - // optional .proto.WebFeatures.Flag groupsV4JoinPermission = 25; - if (cached_has_bits & 0x00400000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 25, this->_internal_groupsv4joinpermission(), target); - } - - // optional .proto.WebFeatures.Flag recentStickers = 26; - if (cached_has_bits & 0x00800000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 26, this->_internal_recentstickers(), target); - } - - // optional .proto.WebFeatures.Flag catalog = 27; - if (cached_has_bits & 0x01000000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 27, this->_internal_catalog(), target); - } - - // optional .proto.WebFeatures.Flag starredStickers = 28; - if (cached_has_bits & 0x02000000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 28, this->_internal_starredstickers(), target); - } - - // optional .proto.WebFeatures.Flag voipGroupCall = 29; - if (cached_has_bits & 0x04000000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 29, this->_internal_voipgroupcall(), target); - } - - // optional .proto.WebFeatures.Flag templateMessage = 30; - if (cached_has_bits & 0x08000000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 30, this->_internal_templatemessage(), target); - } - - // optional .proto.WebFeatures.Flag templateMessageInteractivity = 31; - if (cached_has_bits & 0x10000000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 31, this->_internal_templatemessageinteractivity(), target); - } - - // optional .proto.WebFeatures.Flag ephemeralMessages = 32; - if (cached_has_bits & 0x20000000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 32, this->_internal_ephemeralmessages(), target); - } - - // optional .proto.WebFeatures.Flag e2ENotificationSync = 33; - if (cached_has_bits & 0x40000000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 33, this->_internal_e2enotificationsync(), target); - } - - // optional .proto.WebFeatures.Flag recentStickersV2 = 34; - if (cached_has_bits & 0x80000000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 34, this->_internal_recentstickersv2(), target); - } - - cached_has_bits = _impl_._has_bits_[1]; - // optional .proto.WebFeatures.Flag recentStickersV3 = 36; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 36, this->_internal_recentstickersv3(), target); - } - - // optional .proto.WebFeatures.Flag userNotice = 37; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 37, this->_internal_usernotice(), target); - } - - // optional .proto.WebFeatures.Flag support = 39; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 39, this->_internal_support(), target); - } - - // optional .proto.WebFeatures.Flag groupUiiCleanup = 40; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 40, this->_internal_groupuiicleanup(), target); - } - - // optional .proto.WebFeatures.Flag groupDogfoodingInternalOnly = 41; - if (cached_has_bits & 0x00000010u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 41, this->_internal_groupdogfoodinginternalonly(), target); - } - - // optional .proto.WebFeatures.Flag settingsSync = 42; - if (cached_has_bits & 0x00000020u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 42, this->_internal_settingssync(), target); - } - - // optional .proto.WebFeatures.Flag archiveV2 = 43; - if (cached_has_bits & 0x00000040u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 43, this->_internal_archivev2(), target); - } - - // optional .proto.WebFeatures.Flag ephemeralAllowGroupMembers = 44; - if (cached_has_bits & 0x00000080u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 44, this->_internal_ephemeralallowgroupmembers(), target); - } - - // optional .proto.WebFeatures.Flag ephemeral24HDuration = 45; - if (cached_has_bits & 0x00000100u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 45, this->_internal_ephemeral24hduration(), target); - } - - // optional .proto.WebFeatures.Flag mdForceUpgrade = 46; - if (cached_has_bits & 0x00000200u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 46, this->_internal_mdforceupgrade(), target); - } - - // optional .proto.WebFeatures.Flag disappearingMode = 47; - if (cached_has_bits & 0x00000400u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 47, this->_internal_disappearingmode(), target); - } - - // optional .proto.WebFeatures.Flag externalMdOptInAvailable = 48; - if (cached_has_bits & 0x00000800u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 48, this->_internal_externalmdoptinavailable(), target); - } - - // optional .proto.WebFeatures.Flag noDeleteMessageTimeLimit = 49; - if (cached_has_bits & 0x00001000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 49, this->_internal_nodeletemessagetimelimit(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.WebFeatures) - return target; -} - -size_t WebFeatures::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.WebFeatures) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional .proto.WebFeatures.Flag labelsDisplay = 1; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_labelsdisplay()); - } - - // optional .proto.WebFeatures.Flag voipIndividualOutgoing = 2; - if (cached_has_bits & 0x00000002u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_voipindividualoutgoing()); - } - - // optional .proto.WebFeatures.Flag groupsV3 = 3; - if (cached_has_bits & 0x00000004u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_groupsv3()); - } - - // optional .proto.WebFeatures.Flag groupsV3Create = 4; - if (cached_has_bits & 0x00000008u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_groupsv3create()); - } - - // optional .proto.WebFeatures.Flag changeNumberV2 = 5; - if (cached_has_bits & 0x00000010u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_changenumberv2()); - } - - // optional .proto.WebFeatures.Flag queryStatusV3Thumbnail = 6; - if (cached_has_bits & 0x00000020u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_querystatusv3thumbnail()); - } - - // optional .proto.WebFeatures.Flag liveLocations = 7; - if (cached_has_bits & 0x00000040u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_livelocations()); - } - - // optional .proto.WebFeatures.Flag queryVname = 8; - if (cached_has_bits & 0x00000080u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_queryvname()); - } - - } - if (cached_has_bits & 0x0000ff00u) { - // optional .proto.WebFeatures.Flag voipIndividualIncoming = 9; - if (cached_has_bits & 0x00000100u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_voipindividualincoming()); - } - - // optional .proto.WebFeatures.Flag quickRepliesQuery = 10; - if (cached_has_bits & 0x00000200u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_quickrepliesquery()); - } - - // optional .proto.WebFeatures.Flag payments = 11; - if (cached_has_bits & 0x00000400u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_payments()); - } - - // optional .proto.WebFeatures.Flag stickerPackQuery = 12; - if (cached_has_bits & 0x00000800u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_stickerpackquery()); - } - - // optional .proto.WebFeatures.Flag liveLocationsFinal = 13; - if (cached_has_bits & 0x00001000u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_livelocationsfinal()); - } - - // optional .proto.WebFeatures.Flag labelsEdit = 14; - if (cached_has_bits & 0x00002000u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_labelsedit()); - } - - // optional .proto.WebFeatures.Flag mediaUpload = 15; - if (cached_has_bits & 0x00004000u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_mediaupload()); - } - - // optional .proto.WebFeatures.Flag mediaUploadRichQuickReplies = 18; - if (cached_has_bits & 0x00008000u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_mediauploadrichquickreplies()); - } - - } - if (cached_has_bits & 0x00ff0000u) { - // optional .proto.WebFeatures.Flag vnameV2 = 19; - if (cached_has_bits & 0x00010000u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_vnamev2()); - } - - // optional .proto.WebFeatures.Flag videoPlaybackUrl = 20; - if (cached_has_bits & 0x00020000u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_videoplaybackurl()); - } - - // optional .proto.WebFeatures.Flag statusRanking = 21; - if (cached_has_bits & 0x00040000u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_statusranking()); - } - - // optional .proto.WebFeatures.Flag voipIndividualVideo = 22; - if (cached_has_bits & 0x00080000u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_voipindividualvideo()); - } - - // optional .proto.WebFeatures.Flag thirdPartyStickers = 23; - if (cached_has_bits & 0x00100000u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_thirdpartystickers()); - } - - // optional .proto.WebFeatures.Flag frequentlyForwardedSetting = 24; - if (cached_has_bits & 0x00200000u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_frequentlyforwardedsetting()); - } - - // optional .proto.WebFeatures.Flag groupsV4JoinPermission = 25; - if (cached_has_bits & 0x00400000u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_groupsv4joinpermission()); - } - - // optional .proto.WebFeatures.Flag recentStickers = 26; - if (cached_has_bits & 0x00800000u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_recentstickers()); - } - - } - if (cached_has_bits & 0xff000000u) { - // optional .proto.WebFeatures.Flag catalog = 27; - if (cached_has_bits & 0x01000000u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_catalog()); - } - - // optional .proto.WebFeatures.Flag starredStickers = 28; - if (cached_has_bits & 0x02000000u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_starredstickers()); - } - - // optional .proto.WebFeatures.Flag voipGroupCall = 29; - if (cached_has_bits & 0x04000000u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_voipgroupcall()); - } - - // optional .proto.WebFeatures.Flag templateMessage = 30; - if (cached_has_bits & 0x08000000u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_templatemessage()); - } - - // optional .proto.WebFeatures.Flag templateMessageInteractivity = 31; - if (cached_has_bits & 0x10000000u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_templatemessageinteractivity()); - } - - // optional .proto.WebFeatures.Flag ephemeralMessages = 32; - if (cached_has_bits & 0x20000000u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_ephemeralmessages()); - } - - // optional .proto.WebFeatures.Flag e2ENotificationSync = 33; - if (cached_has_bits & 0x40000000u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_e2enotificationsync()); - } - - // optional .proto.WebFeatures.Flag recentStickersV2 = 34; - if (cached_has_bits & 0x80000000u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_recentstickersv2()); - } - - } - cached_has_bits = _impl_._has_bits_[1]; - if (cached_has_bits & 0x000000ffu) { - // optional .proto.WebFeatures.Flag recentStickersV3 = 36; - if (cached_has_bits & 0x00000001u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_recentstickersv3()); - } - - // optional .proto.WebFeatures.Flag userNotice = 37; - if (cached_has_bits & 0x00000002u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_usernotice()); - } - - // optional .proto.WebFeatures.Flag support = 39; - if (cached_has_bits & 0x00000004u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_support()); - } - - // optional .proto.WebFeatures.Flag groupUiiCleanup = 40; - if (cached_has_bits & 0x00000008u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_groupuiicleanup()); - } - - // optional .proto.WebFeatures.Flag groupDogfoodingInternalOnly = 41; - if (cached_has_bits & 0x00000010u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_groupdogfoodinginternalonly()); - } - - // optional .proto.WebFeatures.Flag settingsSync = 42; - if (cached_has_bits & 0x00000020u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_settingssync()); - } - - // optional .proto.WebFeatures.Flag archiveV2 = 43; - if (cached_has_bits & 0x00000040u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_archivev2()); - } - - // optional .proto.WebFeatures.Flag ephemeralAllowGroupMembers = 44; - if (cached_has_bits & 0x00000080u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_ephemeralallowgroupmembers()); - } - - } - if (cached_has_bits & 0x00001f00u) { - // optional .proto.WebFeatures.Flag ephemeral24HDuration = 45; - if (cached_has_bits & 0x00000100u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_ephemeral24hduration()); - } - - // optional .proto.WebFeatures.Flag mdForceUpgrade = 46; - if (cached_has_bits & 0x00000200u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_mdforceupgrade()); - } - - // optional .proto.WebFeatures.Flag disappearingMode = 47; - if (cached_has_bits & 0x00000400u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_disappearingmode()); - } - - // optional .proto.WebFeatures.Flag externalMdOptInAvailable = 48; - if (cached_has_bits & 0x00000800u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_externalmdoptinavailable()); - } - - // optional .proto.WebFeatures.Flag noDeleteMessageTimeLimit = 49; - if (cached_has_bits & 0x00001000u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_nodeletemessagetimelimit()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData WebFeatures::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - WebFeatures::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*WebFeatures::GetClassData() const { return &_class_data_; } - - -void WebFeatures::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.WebFeatures) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_impl_.labelsdisplay_ = from._impl_.labelsdisplay_; - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.voipindividualoutgoing_ = from._impl_.voipindividualoutgoing_; - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.groupsv3_ = from._impl_.groupsv3_; - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.groupsv3create_ = from._impl_.groupsv3create_; - } - if (cached_has_bits & 0x00000010u) { - _this->_impl_.changenumberv2_ = from._impl_.changenumberv2_; - } - if (cached_has_bits & 0x00000020u) { - _this->_impl_.querystatusv3thumbnail_ = from._impl_.querystatusv3thumbnail_; - } - if (cached_has_bits & 0x00000040u) { - _this->_impl_.livelocations_ = from._impl_.livelocations_; - } - if (cached_has_bits & 0x00000080u) { - _this->_impl_.queryvname_ = from._impl_.queryvname_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - if (cached_has_bits & 0x0000ff00u) { - if (cached_has_bits & 0x00000100u) { - _this->_impl_.voipindividualincoming_ = from._impl_.voipindividualincoming_; - } - if (cached_has_bits & 0x00000200u) { - _this->_impl_.quickrepliesquery_ = from._impl_.quickrepliesquery_; - } - if (cached_has_bits & 0x00000400u) { - _this->_impl_.payments_ = from._impl_.payments_; - } - if (cached_has_bits & 0x00000800u) { - _this->_impl_.stickerpackquery_ = from._impl_.stickerpackquery_; - } - if (cached_has_bits & 0x00001000u) { - _this->_impl_.livelocationsfinal_ = from._impl_.livelocationsfinal_; - } - if (cached_has_bits & 0x00002000u) { - _this->_impl_.labelsedit_ = from._impl_.labelsedit_; - } - if (cached_has_bits & 0x00004000u) { - _this->_impl_.mediaupload_ = from._impl_.mediaupload_; - } - if (cached_has_bits & 0x00008000u) { - _this->_impl_.mediauploadrichquickreplies_ = from._impl_.mediauploadrichquickreplies_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - if (cached_has_bits & 0x00ff0000u) { - if (cached_has_bits & 0x00010000u) { - _this->_impl_.vnamev2_ = from._impl_.vnamev2_; - } - if (cached_has_bits & 0x00020000u) { - _this->_impl_.videoplaybackurl_ = from._impl_.videoplaybackurl_; - } - if (cached_has_bits & 0x00040000u) { - _this->_impl_.statusranking_ = from._impl_.statusranking_; - } - if (cached_has_bits & 0x00080000u) { - _this->_impl_.voipindividualvideo_ = from._impl_.voipindividualvideo_; - } - if (cached_has_bits & 0x00100000u) { - _this->_impl_.thirdpartystickers_ = from._impl_.thirdpartystickers_; - } - if (cached_has_bits & 0x00200000u) { - _this->_impl_.frequentlyforwardedsetting_ = from._impl_.frequentlyforwardedsetting_; - } - if (cached_has_bits & 0x00400000u) { - _this->_impl_.groupsv4joinpermission_ = from._impl_.groupsv4joinpermission_; - } - if (cached_has_bits & 0x00800000u) { - _this->_impl_.recentstickers_ = from._impl_.recentstickers_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - if (cached_has_bits & 0xff000000u) { - if (cached_has_bits & 0x01000000u) { - _this->_impl_.catalog_ = from._impl_.catalog_; - } - if (cached_has_bits & 0x02000000u) { - _this->_impl_.starredstickers_ = from._impl_.starredstickers_; - } - if (cached_has_bits & 0x04000000u) { - _this->_impl_.voipgroupcall_ = from._impl_.voipgroupcall_; - } - if (cached_has_bits & 0x08000000u) { - _this->_impl_.templatemessage_ = from._impl_.templatemessage_; - } - if (cached_has_bits & 0x10000000u) { - _this->_impl_.templatemessageinteractivity_ = from._impl_.templatemessageinteractivity_; - } - if (cached_has_bits & 0x20000000u) { - _this->_impl_.ephemeralmessages_ = from._impl_.ephemeralmessages_; - } - if (cached_has_bits & 0x40000000u) { - _this->_impl_.e2enotificationsync_ = from._impl_.e2enotificationsync_; - } - if (cached_has_bits & 0x80000000u) { - _this->_impl_.recentstickersv2_ = from._impl_.recentstickersv2_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - cached_has_bits = from._impl_._has_bits_[1]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_impl_.recentstickersv3_ = from._impl_.recentstickersv3_; - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.usernotice_ = from._impl_.usernotice_; - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.support_ = from._impl_.support_; - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.groupuiicleanup_ = from._impl_.groupuiicleanup_; - } - if (cached_has_bits & 0x00000010u) { - _this->_impl_.groupdogfoodinginternalonly_ = from._impl_.groupdogfoodinginternalonly_; - } - if (cached_has_bits & 0x00000020u) { - _this->_impl_.settingssync_ = from._impl_.settingssync_; - } - if (cached_has_bits & 0x00000040u) { - _this->_impl_.archivev2_ = from._impl_.archivev2_; - } - if (cached_has_bits & 0x00000080u) { - _this->_impl_.ephemeralallowgroupmembers_ = from._impl_.ephemeralallowgroupmembers_; - } - _this->_impl_._has_bits_[1] |= cached_has_bits; - } - if (cached_has_bits & 0x00001f00u) { - if (cached_has_bits & 0x00000100u) { - _this->_impl_.ephemeral24hduration_ = from._impl_.ephemeral24hduration_; - } - if (cached_has_bits & 0x00000200u) { - _this->_impl_.mdforceupgrade_ = from._impl_.mdforceupgrade_; - } - if (cached_has_bits & 0x00000400u) { - _this->_impl_.disappearingmode_ = from._impl_.disappearingmode_; - } - if (cached_has_bits & 0x00000800u) { - _this->_impl_.externalmdoptinavailable_ = from._impl_.externalmdoptinavailable_; - } - if (cached_has_bits & 0x00001000u) { - _this->_impl_.nodeletemessagetimelimit_ = from._impl_.nodeletemessagetimelimit_; - } - _this->_impl_._has_bits_[1] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void WebFeatures::CopyFrom(const WebFeatures& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.WebFeatures) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool WebFeatures::IsInitialized() const { - return true; -} - -void WebFeatures::InternalSwap(WebFeatures* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - swap(_impl_._has_bits_[1], other->_impl_._has_bits_[1]); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(WebFeatures, _impl_.nodeletemessagetimelimit_) - + sizeof(WebFeatures::_impl_.nodeletemessagetimelimit_) - - PROTOBUF_FIELD_OFFSET(WebFeatures, _impl_.labelsdisplay_)>( - reinterpret_cast(&_impl_.labelsdisplay_), - reinterpret_cast(&other->_impl_.labelsdisplay_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata WebFeatures::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[221]); -} - -// =================================================================== - -class WebMessageInfo::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static const ::proto::MessageKey& key(const WebMessageInfo* msg); - static void set_has_key(HasBits* has_bits) { - (*has_bits)[0] |= 256u; - } - static const ::proto::Message& message(const WebMessageInfo* msg); - static void set_has_message(HasBits* has_bits) { - (*has_bits)[0] |= 512u; - } - static void set_has_messagetimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 524288u; - } - static void set_has_status(HasBits* has_bits) { - (*has_bits)[0] |= 2097152u; - } - static void set_has_participant(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_messagec2stimestamp(HasBits* has_bits) { - (*has_bits)[0] |= 1048576u; - } - static void set_has_ignore(HasBits* has_bits) { - (*has_bits)[0] |= 4194304u; - } - static void set_has_starred(HasBits* has_bits) { - (*has_bits)[0] |= 8388608u; - } - static void set_has_broadcast(HasBits* has_bits) { - (*has_bits)[0] |= 16777216u; - } - static void set_has_pushname(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_mediaciphertextsha256(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_multicast(HasBits* has_bits) { - (*has_bits)[0] |= 33554432u; - } - static void set_has_urltext(HasBits* has_bits) { - (*has_bits)[0] |= 134217728u; - } - static void set_has_urlnumber(HasBits* has_bits) { - (*has_bits)[0] |= 268435456u; - } - static void set_has_messagestubtype(HasBits* has_bits) { - (*has_bits)[0] |= 67108864u; - } - static void set_has_clearmedia(HasBits* has_bits) { - (*has_bits)[0] |= 536870912u; - } - static void set_has_duration(HasBits* has_bits) { - (*has_bits)[0] |= 2147483648u; - } - static const ::proto::PaymentInfo& paymentinfo(const WebMessageInfo* msg); - static void set_has_paymentinfo(HasBits* has_bits) { - (*has_bits)[0] |= 1024u; - } - static const ::proto::Message_LiveLocationMessage& finallivelocation(const WebMessageInfo* msg); - static void set_has_finallivelocation(HasBits* has_bits) { - (*has_bits)[0] |= 2048u; - } - static const ::proto::PaymentInfo& quotedpaymentinfo(const WebMessageInfo* msg); - static void set_has_quotedpaymentinfo(HasBits* has_bits) { - (*has_bits)[0] |= 4096u; - } - static void set_has_ephemeralstarttimestamp(HasBits* has_bits) { - (*has_bits)[1] |= 2u; - } - static void set_has_ephemeralduration(HasBits* has_bits) { - (*has_bits)[1] |= 1u; - } - static void set_has_ephemeralofftoon(HasBits* has_bits) { - (*has_bits)[0] |= 1073741824u; - } - static void set_has_ephemeraloutofsync(HasBits* has_bits) { - (*has_bits)[1] |= 8u; - } - static void set_has_bizprivacystatus(HasBits* has_bits) { - (*has_bits)[1] |= 4u; - } - static void set_has_verifiedbizname(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static const ::proto::MediaData& mediadata(const WebMessageInfo* msg); - static void set_has_mediadata(HasBits* has_bits) { - (*has_bits)[0] |= 8192u; - } - static const ::proto::PhotoChange& photochange(const WebMessageInfo* msg); - static void set_has_photochange(HasBits* has_bits) { - (*has_bits)[0] |= 16384u; - } - static const ::proto::MediaData& quotedstickerdata(const WebMessageInfo* msg); - static void set_has_quotedstickerdata(HasBits* has_bits) { - (*has_bits)[0] |= 32768u; - } - static void set_has_futureproofdata(HasBits* has_bits) { - (*has_bits)[0] |= 16u; - } - static const ::proto::StatusPSA& statuspsa(const WebMessageInfo* msg); - static void set_has_statuspsa(HasBits* has_bits) { - (*has_bits)[0] |= 65536u; - } - static const ::proto::PollAdditionalMetadata& polladditionalmetadata(const WebMessageInfo* msg); - static void set_has_polladditionalmetadata(HasBits* has_bits) { - (*has_bits)[0] |= 131072u; - } - static void set_has_agentid(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static void set_has_statusalreadyviewed(HasBits* has_bits) { - (*has_bits)[1] |= 16u; - } - static void set_has_messagesecret(HasBits* has_bits) { - (*has_bits)[0] |= 64u; - } - static const ::proto::KeepInChat& keepinchat(const WebMessageInfo* msg); - static void set_has_keepinchat(HasBits* has_bits) { - (*has_bits)[0] |= 262144u; - } - static void set_has_originalselfauthoruserjidstring(HasBits* has_bits) { - (*has_bits)[0] |= 128u; - } - static void set_has_revokemessagetimestamp(HasBits* has_bits) { - (*has_bits)[1] |= 32u; - } - static bool MissingRequiredFields(const HasBits& has_bits) { - return ((has_bits[0] & 0x00000100) ^ 0x00000100) != 0; - } -}; - -const ::proto::MessageKey& -WebMessageInfo::_Internal::key(const WebMessageInfo* msg) { - return *msg->_impl_.key_; -} -const ::proto::Message& -WebMessageInfo::_Internal::message(const WebMessageInfo* msg) { - return *msg->_impl_.message_; -} -const ::proto::PaymentInfo& -WebMessageInfo::_Internal::paymentinfo(const WebMessageInfo* msg) { - return *msg->_impl_.paymentinfo_; -} -const ::proto::Message_LiveLocationMessage& -WebMessageInfo::_Internal::finallivelocation(const WebMessageInfo* msg) { - return *msg->_impl_.finallivelocation_; -} -const ::proto::PaymentInfo& -WebMessageInfo::_Internal::quotedpaymentinfo(const WebMessageInfo* msg) { - return *msg->_impl_.quotedpaymentinfo_; -} -const ::proto::MediaData& -WebMessageInfo::_Internal::mediadata(const WebMessageInfo* msg) { - return *msg->_impl_.mediadata_; -} -const ::proto::PhotoChange& -WebMessageInfo::_Internal::photochange(const WebMessageInfo* msg) { - return *msg->_impl_.photochange_; -} -const ::proto::MediaData& -WebMessageInfo::_Internal::quotedstickerdata(const WebMessageInfo* msg) { - return *msg->_impl_.quotedstickerdata_; -} -const ::proto::StatusPSA& -WebMessageInfo::_Internal::statuspsa(const WebMessageInfo* msg) { - return *msg->_impl_.statuspsa_; -} -const ::proto::PollAdditionalMetadata& -WebMessageInfo::_Internal::polladditionalmetadata(const WebMessageInfo* msg) { - return *msg->_impl_.polladditionalmetadata_; -} -const ::proto::KeepInChat& -WebMessageInfo::_Internal::keepinchat(const WebMessageInfo* msg) { - return *msg->_impl_.keepinchat_; -} -WebMessageInfo::WebMessageInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.WebMessageInfo) -} -WebMessageInfo::WebMessageInfo(const WebMessageInfo& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - WebMessageInfo* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.messagestubparameters_){from._impl_.messagestubparameters_} - , decltype(_impl_.labels_){from._impl_.labels_} - , decltype(_impl_.userreceipt_){from._impl_.userreceipt_} - , decltype(_impl_.reactions_){from._impl_.reactions_} - , decltype(_impl_.pollupdates_){from._impl_.pollupdates_} - , decltype(_impl_.participant_){} - , decltype(_impl_.pushname_){} - , decltype(_impl_.mediaciphertextsha256_){} - , decltype(_impl_.verifiedbizname_){} - , decltype(_impl_.futureproofdata_){} - , decltype(_impl_.agentid_){} - , decltype(_impl_.messagesecret_){} - , decltype(_impl_.originalselfauthoruserjidstring_){} - , decltype(_impl_.key_){nullptr} - , decltype(_impl_.message_){nullptr} - , decltype(_impl_.paymentinfo_){nullptr} - , decltype(_impl_.finallivelocation_){nullptr} - , decltype(_impl_.quotedpaymentinfo_){nullptr} - , decltype(_impl_.mediadata_){nullptr} - , decltype(_impl_.photochange_){nullptr} - , decltype(_impl_.quotedstickerdata_){nullptr} - , decltype(_impl_.statuspsa_){nullptr} - , decltype(_impl_.polladditionalmetadata_){nullptr} - , decltype(_impl_.keepinchat_){nullptr} - , decltype(_impl_.messagetimestamp_){} - , decltype(_impl_.messagec2stimestamp_){} - , decltype(_impl_.status_){} - , decltype(_impl_.ignore_){} - , decltype(_impl_.starred_){} - , decltype(_impl_.broadcast_){} - , decltype(_impl_.multicast_){} - , decltype(_impl_.messagestubtype_){} - , decltype(_impl_.urltext_){} - , decltype(_impl_.urlnumber_){} - , decltype(_impl_.clearmedia_){} - , decltype(_impl_.ephemeralofftoon_){} - , decltype(_impl_.duration_){} - , decltype(_impl_.ephemeralduration_){} - , decltype(_impl_.ephemeralstarttimestamp_){} - , decltype(_impl_.bizprivacystatus_){} - , decltype(_impl_.ephemeraloutofsync_){} - , decltype(_impl_.statusalreadyviewed_){} - , decltype(_impl_.revokemessagetimestamp_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - _impl_.participant_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.participant_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_participant()) { - _this->_impl_.participant_.Set(from._internal_participant(), - _this->GetArenaForAllocation()); - } - _impl_.pushname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.pushname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_pushname()) { - _this->_impl_.pushname_.Set(from._internal_pushname(), - _this->GetArenaForAllocation()); - } - _impl_.mediaciphertextsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediaciphertextsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_mediaciphertextsha256()) { - _this->_impl_.mediaciphertextsha256_.Set(from._internal_mediaciphertextsha256(), - _this->GetArenaForAllocation()); - } - _impl_.verifiedbizname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.verifiedbizname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_verifiedbizname()) { - _this->_impl_.verifiedbizname_.Set(from._internal_verifiedbizname(), - _this->GetArenaForAllocation()); - } - _impl_.futureproofdata_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.futureproofdata_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_futureproofdata()) { - _this->_impl_.futureproofdata_.Set(from._internal_futureproofdata(), - _this->GetArenaForAllocation()); - } - _impl_.agentid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.agentid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_agentid()) { - _this->_impl_.agentid_.Set(from._internal_agentid(), - _this->GetArenaForAllocation()); - } - _impl_.messagesecret_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.messagesecret_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_messagesecret()) { - _this->_impl_.messagesecret_.Set(from._internal_messagesecret(), - _this->GetArenaForAllocation()); - } - _impl_.originalselfauthoruserjidstring_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.originalselfauthoruserjidstring_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (from._internal_has_originalselfauthoruserjidstring()) { - _this->_impl_.originalselfauthoruserjidstring_.Set(from._internal_originalselfauthoruserjidstring(), - _this->GetArenaForAllocation()); - } - if (from._internal_has_key()) { - _this->_impl_.key_ = new ::proto::MessageKey(*from._impl_.key_); - } - if (from._internal_has_message()) { - _this->_impl_.message_ = new ::proto::Message(*from._impl_.message_); - } - if (from._internal_has_paymentinfo()) { - _this->_impl_.paymentinfo_ = new ::proto::PaymentInfo(*from._impl_.paymentinfo_); - } - if (from._internal_has_finallivelocation()) { - _this->_impl_.finallivelocation_ = new ::proto::Message_LiveLocationMessage(*from._impl_.finallivelocation_); - } - if (from._internal_has_quotedpaymentinfo()) { - _this->_impl_.quotedpaymentinfo_ = new ::proto::PaymentInfo(*from._impl_.quotedpaymentinfo_); - } - if (from._internal_has_mediadata()) { - _this->_impl_.mediadata_ = new ::proto::MediaData(*from._impl_.mediadata_); - } - if (from._internal_has_photochange()) { - _this->_impl_.photochange_ = new ::proto::PhotoChange(*from._impl_.photochange_); - } - if (from._internal_has_quotedstickerdata()) { - _this->_impl_.quotedstickerdata_ = new ::proto::MediaData(*from._impl_.quotedstickerdata_); - } - if (from._internal_has_statuspsa()) { - _this->_impl_.statuspsa_ = new ::proto::StatusPSA(*from._impl_.statuspsa_); - } - if (from._internal_has_polladditionalmetadata()) { - _this->_impl_.polladditionalmetadata_ = new ::proto::PollAdditionalMetadata(*from._impl_.polladditionalmetadata_); - } - if (from._internal_has_keepinchat()) { - _this->_impl_.keepinchat_ = new ::proto::KeepInChat(*from._impl_.keepinchat_); - } - ::memcpy(&_impl_.messagetimestamp_, &from._impl_.messagetimestamp_, - static_cast(reinterpret_cast(&_impl_.revokemessagetimestamp_) - - reinterpret_cast(&_impl_.messagetimestamp_)) + sizeof(_impl_.revokemessagetimestamp_)); - // @@protoc_insertion_point(copy_constructor:proto.WebMessageInfo) -} - -inline void WebMessageInfo::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.messagestubparameters_){arena} - , decltype(_impl_.labels_){arena} - , decltype(_impl_.userreceipt_){arena} - , decltype(_impl_.reactions_){arena} - , decltype(_impl_.pollupdates_){arena} - , decltype(_impl_.participant_){} - , decltype(_impl_.pushname_){} - , decltype(_impl_.mediaciphertextsha256_){} - , decltype(_impl_.verifiedbizname_){} - , decltype(_impl_.futureproofdata_){} - , decltype(_impl_.agentid_){} - , decltype(_impl_.messagesecret_){} - , decltype(_impl_.originalselfauthoruserjidstring_){} - , decltype(_impl_.key_){nullptr} - , decltype(_impl_.message_){nullptr} - , decltype(_impl_.paymentinfo_){nullptr} - , decltype(_impl_.finallivelocation_){nullptr} - , decltype(_impl_.quotedpaymentinfo_){nullptr} - , decltype(_impl_.mediadata_){nullptr} - , decltype(_impl_.photochange_){nullptr} - , decltype(_impl_.quotedstickerdata_){nullptr} - , decltype(_impl_.statuspsa_){nullptr} - , decltype(_impl_.polladditionalmetadata_){nullptr} - , decltype(_impl_.keepinchat_){nullptr} - , decltype(_impl_.messagetimestamp_){uint64_t{0u}} - , decltype(_impl_.messagec2stimestamp_){uint64_t{0u}} - , decltype(_impl_.status_){0} - , decltype(_impl_.ignore_){false} - , decltype(_impl_.starred_){false} - , decltype(_impl_.broadcast_){false} - , decltype(_impl_.multicast_){false} - , decltype(_impl_.messagestubtype_){0} - , decltype(_impl_.urltext_){false} - , decltype(_impl_.urlnumber_){false} - , decltype(_impl_.clearmedia_){false} - , decltype(_impl_.ephemeralofftoon_){false} - , decltype(_impl_.duration_){0u} - , decltype(_impl_.ephemeralduration_){0u} - , decltype(_impl_.ephemeralstarttimestamp_){uint64_t{0u}} - , decltype(_impl_.bizprivacystatus_){0} - , decltype(_impl_.ephemeraloutofsync_){false} - , decltype(_impl_.statusalreadyviewed_){false} - , decltype(_impl_.revokemessagetimestamp_){uint64_t{0u}} - }; - _impl_.participant_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.participant_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.pushname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.pushname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediaciphertextsha256_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.mediaciphertextsha256_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.verifiedbizname_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.verifiedbizname_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.futureproofdata_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.futureproofdata_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.agentid_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.agentid_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.messagesecret_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.messagesecret_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.originalselfauthoruserjidstring_.InitDefault(); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - _impl_.originalselfauthoruserjidstring_.Set("", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -WebMessageInfo::~WebMessageInfo() { - // @@protoc_insertion_point(destructor:proto.WebMessageInfo) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void WebMessageInfo::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.messagestubparameters_.~RepeatedPtrField(); - _impl_.labels_.~RepeatedPtrField(); - _impl_.userreceipt_.~RepeatedPtrField(); - _impl_.reactions_.~RepeatedPtrField(); - _impl_.pollupdates_.~RepeatedPtrField(); - _impl_.participant_.Destroy(); - _impl_.pushname_.Destroy(); - _impl_.mediaciphertextsha256_.Destroy(); - _impl_.verifiedbizname_.Destroy(); - _impl_.futureproofdata_.Destroy(); - _impl_.agentid_.Destroy(); - _impl_.messagesecret_.Destroy(); - _impl_.originalselfauthoruserjidstring_.Destroy(); - if (this != internal_default_instance()) delete _impl_.key_; - if (this != internal_default_instance()) delete _impl_.message_; - if (this != internal_default_instance()) delete _impl_.paymentinfo_; - if (this != internal_default_instance()) delete _impl_.finallivelocation_; - if (this != internal_default_instance()) delete _impl_.quotedpaymentinfo_; - if (this != internal_default_instance()) delete _impl_.mediadata_; - if (this != internal_default_instance()) delete _impl_.photochange_; - if (this != internal_default_instance()) delete _impl_.quotedstickerdata_; - if (this != internal_default_instance()) delete _impl_.statuspsa_; - if (this != internal_default_instance()) delete _impl_.polladditionalmetadata_; - if (this != internal_default_instance()) delete _impl_.keepinchat_; -} - -void WebMessageInfo::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void WebMessageInfo::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.WebMessageInfo) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.messagestubparameters_.Clear(); - _impl_.labels_.Clear(); - _impl_.userreceipt_.Clear(); - _impl_.reactions_.Clear(); - _impl_.pollupdates_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _impl_.participant_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000002u) { - _impl_.pushname_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000004u) { - _impl_.mediaciphertextsha256_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000008u) { - _impl_.verifiedbizname_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000010u) { - _impl_.futureproofdata_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000020u) { - _impl_.agentid_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000040u) { - _impl_.messagesecret_.ClearNonDefaultToEmpty(); - } - if (cached_has_bits & 0x00000080u) { - _impl_.originalselfauthoruserjidstring_.ClearNonDefaultToEmpty(); - } - } - if (cached_has_bits & 0x0000ff00u) { - if (cached_has_bits & 0x00000100u) { - GOOGLE_DCHECK(_impl_.key_ != nullptr); - _impl_.key_->Clear(); - } - if (cached_has_bits & 0x00000200u) { - GOOGLE_DCHECK(_impl_.message_ != nullptr); - _impl_.message_->Clear(); - } - if (cached_has_bits & 0x00000400u) { - GOOGLE_DCHECK(_impl_.paymentinfo_ != nullptr); - _impl_.paymentinfo_->Clear(); - } - if (cached_has_bits & 0x00000800u) { - GOOGLE_DCHECK(_impl_.finallivelocation_ != nullptr); - _impl_.finallivelocation_->Clear(); - } - if (cached_has_bits & 0x00001000u) { - GOOGLE_DCHECK(_impl_.quotedpaymentinfo_ != nullptr); - _impl_.quotedpaymentinfo_->Clear(); - } - if (cached_has_bits & 0x00002000u) { - GOOGLE_DCHECK(_impl_.mediadata_ != nullptr); - _impl_.mediadata_->Clear(); - } - if (cached_has_bits & 0x00004000u) { - GOOGLE_DCHECK(_impl_.photochange_ != nullptr); - _impl_.photochange_->Clear(); - } - if (cached_has_bits & 0x00008000u) { - GOOGLE_DCHECK(_impl_.quotedstickerdata_ != nullptr); - _impl_.quotedstickerdata_->Clear(); - } - } - if (cached_has_bits & 0x00070000u) { - if (cached_has_bits & 0x00010000u) { - GOOGLE_DCHECK(_impl_.statuspsa_ != nullptr); - _impl_.statuspsa_->Clear(); - } - if (cached_has_bits & 0x00020000u) { - GOOGLE_DCHECK(_impl_.polladditionalmetadata_ != nullptr); - _impl_.polladditionalmetadata_->Clear(); - } - if (cached_has_bits & 0x00040000u) { - GOOGLE_DCHECK(_impl_.keepinchat_ != nullptr); - _impl_.keepinchat_->Clear(); - } - } - if (cached_has_bits & 0x00f80000u) { - ::memset(&_impl_.messagetimestamp_, 0, static_cast( - reinterpret_cast(&_impl_.starred_) - - reinterpret_cast(&_impl_.messagetimestamp_)) + sizeof(_impl_.starred_)); - } - if (cached_has_bits & 0xff000000u) { - ::memset(&_impl_.broadcast_, 0, static_cast( - reinterpret_cast(&_impl_.duration_) - - reinterpret_cast(&_impl_.broadcast_)) + sizeof(_impl_.duration_)); - } - cached_has_bits = _impl_._has_bits_[1]; - if (cached_has_bits & 0x0000003fu) { - ::memset(&_impl_.ephemeralduration_, 0, static_cast( - reinterpret_cast(&_impl_.revokemessagetimestamp_) - - reinterpret_cast(&_impl_.ephemeralduration_)) + sizeof(_impl_.revokemessagetimestamp_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* WebMessageInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // required .proto.MessageKey key = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message message = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_message(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint64 messageTimestamp = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_messagetimestamp(&_impl_._has_bits_); - _impl_.messagetimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.WebMessageInfo.Status status = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebMessageInfo_Status_IsValid(val))) { - _internal_set_status(static_cast<::proto::WebMessageInfo_Status>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional string participant = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - auto str = _internal_mutable_participant(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.WebMessageInfo.participant"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional uint64 messageC2STimestamp = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { - _Internal::set_has_messagec2stimestamp(&_impl_._has_bits_); - _impl_.messagec2stimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool ignore = 16; - case 16: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 128)) { - _Internal::set_has_ignore(&_impl_._has_bits_); - _impl_.ignore_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool starred = 17; - case 17: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 136)) { - _Internal::set_has_starred(&_impl_._has_bits_); - _impl_.starred_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool broadcast = 18; - case 18: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 144)) { - _Internal::set_has_broadcast(&_impl_._has_bits_); - _impl_.broadcast_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string pushName = 19; - case 19: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) { - auto str = _internal_mutable_pushname(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.WebMessageInfo.pushName"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bytes mediaCiphertextSha256 = 20; - case 20: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 162)) { - auto str = _internal_mutable_mediaciphertextsha256(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool multicast = 21; - case 21: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 168)) { - _Internal::set_has_multicast(&_impl_._has_bits_); - _impl_.multicast_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool urlText = 22; - case 22: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 176)) { - _Internal::set_has_urltext(&_impl_._has_bits_); - _impl_.urltext_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool urlNumber = 23; - case 23: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 184)) { - _Internal::set_has_urlnumber(&_impl_._has_bits_); - _impl_.urlnumber_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.WebMessageInfo.StubType messageStubType = 24; - case 24: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 192)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebMessageInfo_StubType_IsValid(val))) { - _internal_set_messagestubtype(static_cast<::proto::WebMessageInfo_StubType>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(24, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional bool clearMedia = 25; - case 25: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 200)) { - _Internal::set_has_clearmedia(&_impl_._has_bits_); - _impl_.clearmedia_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated string messageStubParameters = 26; - case 26: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 210)) { - ptr -= 2; - do { - ptr += 2; - auto str = _internal_add_messagestubparameters(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.WebMessageInfo.messageStubParameters"); - #endif // !NDEBUG - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<210>(ptr)); - } else - goto handle_unusual; - continue; - // optional uint32 duration = 27; - case 27: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 216)) { - _Internal::set_has_duration(&_impl_._has_bits_); - _impl_.duration_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated string labels = 28; - case 28: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 226)) { - ptr -= 2; - do { - ptr += 2; - auto str = _internal_add_labels(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.WebMessageInfo.labels"); - #endif // !NDEBUG - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<226>(ptr)); - } else - goto handle_unusual; - continue; - // optional .proto.PaymentInfo paymentInfo = 29; - case 29: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 234)) { - ptr = ctx->ParseMessage(_internal_mutable_paymentinfo(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.Message.LiveLocationMessage finalLiveLocation = 30; - case 30: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 242)) { - ptr = ctx->ParseMessage(_internal_mutable_finallivelocation(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.PaymentInfo quotedPaymentInfo = 31; - case 31: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 250)) { - ptr = ctx->ParseMessage(_internal_mutable_quotedpaymentinfo(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint64 ephemeralStartTimestamp = 32; - case 32: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 0)) { - _Internal::set_has_ephemeralstarttimestamp(&_impl_._has_bits_); - _impl_.ephemeralstarttimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 ephemeralDuration = 33; - case 33: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _Internal::set_has_ephemeralduration(&_impl_._has_bits_); - _impl_.ephemeralduration_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool ephemeralOffToOn = 34; - case 34: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_ephemeralofftoon(&_impl_._has_bits_); - _impl_.ephemeralofftoon_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bool ephemeralOutOfSync = 35; - case 35: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_ephemeraloutofsync(&_impl_._has_bits_); - _impl_.ephemeraloutofsync_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.WebMessageInfo.BizPrivacyStatus bizPrivacyStatus = 36; - case 36: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - if (PROTOBUF_PREDICT_TRUE(::proto::WebMessageInfo_BizPrivacyStatus_IsValid(val))) { - _internal_set_bizprivacystatus(static_cast<::proto::WebMessageInfo_BizPrivacyStatus>(val)); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(36, val, mutable_unknown_fields()); - } - } else - goto handle_unusual; - continue; - // optional string verifiedBizName = 37; - case 37: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - auto str = _internal_mutable_verifiedbizname(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.WebMessageInfo.verifiedBizName"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional .proto.MediaData mediaData = 38; - case 38: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - ptr = ctx->ParseMessage(_internal_mutable_mediadata(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.PhotoChange photoChange = 39; - case 39: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - ptr = ctx->ParseMessage(_internal_mutable_photochange(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated .proto.UserReceipt userReceipt = 40; - case 40: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { - ptr -= 2; - do { - ptr += 2; - ptr = ctx->ParseMessage(_internal_add_userreceipt(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<322>(ptr)); - } else - goto handle_unusual; - continue; - // repeated .proto.Reaction reactions = 41; - case 41: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { - ptr -= 2; - do { - ptr += 2; - ptr = ctx->ParseMessage(_internal_add_reactions(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<330>(ptr)); - } else - goto handle_unusual; - continue; - // optional .proto.MediaData quotedStickerData = 42; - case 42: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { - ptr = ctx->ParseMessage(_internal_mutable_quotedstickerdata(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes futureproofData = 43; - case 43: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { - auto str = _internal_mutable_futureproofdata(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.StatusPSA statusPsa = 44; - case 44: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { - ptr = ctx->ParseMessage(_internal_mutable_statuspsa(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated .proto.PollUpdate pollUpdates = 45; - case 45: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { - ptr -= 2; - do { - ptr += 2; - ptr = ctx->ParseMessage(_internal_add_pollupdates(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<362>(ptr)); - } else - goto handle_unusual; - continue; - // optional .proto.PollAdditionalMetadata pollAdditionalMetadata = 46; - case 46: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) { - ptr = ctx->ParseMessage(_internal_mutable_polladditionalmetadata(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string agentId = 47; - case 47: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { - auto str = _internal_mutable_agentid(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.WebMessageInfo.agentId"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional bool statusAlreadyViewed = 48; - case 48: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 128)) { - _Internal::set_has_statusalreadyviewed(&_impl_._has_bits_); - _impl_.statusalreadyviewed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional bytes messageSecret = 49; - case 49: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { - auto str = _internal_mutable_messagesecret(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional .proto.KeepInChat keepInChat = 50; - case 50: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { - ptr = ctx->ParseMessage(_internal_mutable_keepinchat(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional string originalSelfAuthorUserJidString = 51; - case 51: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) { - auto str = _internal_mutable_originalselfauthoruserjidstring(); - ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - #ifndef NDEBUG - ::_pbi::VerifyUTF8(str, "proto.WebMessageInfo.originalSelfAuthorUserJidString"); - #endif // !NDEBUG - } else - goto handle_unusual; - continue; - // optional uint64 revokeMessageTimestamp = 52; - case 52: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 160)) { - _Internal::set_has_revokemessagetimestamp(&_impl_._has_bits_); - _impl_.revokemessagetimestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* WebMessageInfo::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.WebMessageInfo) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // required .proto.MessageKey key = 1; - if (cached_has_bits & 0x00000100u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::key(this), - _Internal::key(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message message = 2; - if (cached_has_bits & 0x00000200u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, _Internal::message(this), - _Internal::message(this).GetCachedSize(), target, stream); - } - - // optional uint64 messageTimestamp = 3; - if (cached_has_bits & 0x00080000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_messagetimestamp(), target); - } - - // optional .proto.WebMessageInfo.Status status = 4; - if (cached_has_bits & 0x00200000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 4, this->_internal_status(), target); - } - - // optional string participant = 5; - if (cached_has_bits & 0x00000001u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_participant().data(), static_cast(this->_internal_participant().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.WebMessageInfo.participant"); - target = stream->WriteStringMaybeAliased( - 5, this->_internal_participant(), target); - } - - // optional uint64 messageC2STimestamp = 6; - if (cached_has_bits & 0x00100000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(6, this->_internal_messagec2stimestamp(), target); - } - - // optional bool ignore = 16; - if (cached_has_bits & 0x00400000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(16, this->_internal_ignore(), target); - } - - // optional bool starred = 17; - if (cached_has_bits & 0x00800000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(17, this->_internal_starred(), target); - } - - // optional bool broadcast = 18; - if (cached_has_bits & 0x01000000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(18, this->_internal_broadcast(), target); - } - - // optional string pushName = 19; - if (cached_has_bits & 0x00000002u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_pushname().data(), static_cast(this->_internal_pushname().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.WebMessageInfo.pushName"); - target = stream->WriteStringMaybeAliased( - 19, this->_internal_pushname(), target); - } - - // optional bytes mediaCiphertextSha256 = 20; - if (cached_has_bits & 0x00000004u) { - target = stream->WriteBytesMaybeAliased( - 20, this->_internal_mediaciphertextsha256(), target); - } - - // optional bool multicast = 21; - if (cached_has_bits & 0x02000000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(21, this->_internal_multicast(), target); - } - - // optional bool urlText = 22; - if (cached_has_bits & 0x08000000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(22, this->_internal_urltext(), target); - } - - // optional bool urlNumber = 23; - if (cached_has_bits & 0x10000000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(23, this->_internal_urlnumber(), target); - } - - // optional .proto.WebMessageInfo.StubType messageStubType = 24; - if (cached_has_bits & 0x04000000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 24, this->_internal_messagestubtype(), target); - } - - // optional bool clearMedia = 25; - if (cached_has_bits & 0x20000000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(25, this->_internal_clearmedia(), target); - } - - // repeated string messageStubParameters = 26; - for (int i = 0, n = this->_internal_messagestubparameters_size(); i < n; i++) { - const auto& s = this->_internal_messagestubparameters(i); - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - s.data(), static_cast(s.length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.WebMessageInfo.messageStubParameters"); - target = stream->WriteString(26, s, target); - } - - // optional uint32 duration = 27; - if (cached_has_bits & 0x80000000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(27, this->_internal_duration(), target); - } - - // repeated string labels = 28; - for (int i = 0, n = this->_internal_labels_size(); i < n; i++) { - const auto& s = this->_internal_labels(i); - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - s.data(), static_cast(s.length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.WebMessageInfo.labels"); - target = stream->WriteString(28, s, target); - } - - // optional .proto.PaymentInfo paymentInfo = 29; - if (cached_has_bits & 0x00000400u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(29, _Internal::paymentinfo(this), - _Internal::paymentinfo(this).GetCachedSize(), target, stream); - } - - // optional .proto.Message.LiveLocationMessage finalLiveLocation = 30; - if (cached_has_bits & 0x00000800u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(30, _Internal::finallivelocation(this), - _Internal::finallivelocation(this).GetCachedSize(), target, stream); - } - - // optional .proto.PaymentInfo quotedPaymentInfo = 31; - if (cached_has_bits & 0x00001000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(31, _Internal::quotedpaymentinfo(this), - _Internal::quotedpaymentinfo(this).GetCachedSize(), target, stream); - } - - cached_has_bits = _impl_._has_bits_[1]; - // optional uint64 ephemeralStartTimestamp = 32; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(32, this->_internal_ephemeralstarttimestamp(), target); - } - - // optional uint32 ephemeralDuration = 33; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(33, this->_internal_ephemeralduration(), target); - } - - cached_has_bits = _impl_._has_bits_[0]; - // optional bool ephemeralOffToOn = 34; - if (cached_has_bits & 0x40000000u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(34, this->_internal_ephemeralofftoon(), target); - } - - cached_has_bits = _impl_._has_bits_[1]; - // optional bool ephemeralOutOfSync = 35; - if (cached_has_bits & 0x00000008u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(35, this->_internal_ephemeraloutofsync(), target); - } - - // optional .proto.WebMessageInfo.BizPrivacyStatus bizPrivacyStatus = 36; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 36, this->_internal_bizprivacystatus(), target); - } - - cached_has_bits = _impl_._has_bits_[0]; - // optional string verifiedBizName = 37; - if (cached_has_bits & 0x00000008u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_verifiedbizname().data(), static_cast(this->_internal_verifiedbizname().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.WebMessageInfo.verifiedBizName"); - target = stream->WriteStringMaybeAliased( - 37, this->_internal_verifiedbizname(), target); - } - - // optional .proto.MediaData mediaData = 38; - if (cached_has_bits & 0x00002000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(38, _Internal::mediadata(this), - _Internal::mediadata(this).GetCachedSize(), target, stream); - } - - // optional .proto.PhotoChange photoChange = 39; - if (cached_has_bits & 0x00004000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(39, _Internal::photochange(this), - _Internal::photochange(this).GetCachedSize(), target, stream); - } - - // repeated .proto.UserReceipt userReceipt = 40; - for (unsigned i = 0, - n = static_cast(this->_internal_userreceipt_size()); i < n; i++) { - const auto& repfield = this->_internal_userreceipt(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(40, repfield, repfield.GetCachedSize(), target, stream); - } - - // repeated .proto.Reaction reactions = 41; - for (unsigned i = 0, - n = static_cast(this->_internal_reactions_size()); i < n; i++) { - const auto& repfield = this->_internal_reactions(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(41, repfield, repfield.GetCachedSize(), target, stream); - } - - // optional .proto.MediaData quotedStickerData = 42; - if (cached_has_bits & 0x00008000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(42, _Internal::quotedstickerdata(this), - _Internal::quotedstickerdata(this).GetCachedSize(), target, stream); - } - - // optional bytes futureproofData = 43; - if (cached_has_bits & 0x00000010u) { - target = stream->WriteBytesMaybeAliased( - 43, this->_internal_futureproofdata(), target); - } - - // optional .proto.StatusPSA statusPsa = 44; - if (cached_has_bits & 0x00010000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(44, _Internal::statuspsa(this), - _Internal::statuspsa(this).GetCachedSize(), target, stream); - } - - // repeated .proto.PollUpdate pollUpdates = 45; - for (unsigned i = 0, - n = static_cast(this->_internal_pollupdates_size()); i < n; i++) { - const auto& repfield = this->_internal_pollupdates(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(45, repfield, repfield.GetCachedSize(), target, stream); - } - - // optional .proto.PollAdditionalMetadata pollAdditionalMetadata = 46; - if (cached_has_bits & 0x00020000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(46, _Internal::polladditionalmetadata(this), - _Internal::polladditionalmetadata(this).GetCachedSize(), target, stream); - } - - // optional string agentId = 47; - if (cached_has_bits & 0x00000020u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_agentid().data(), static_cast(this->_internal_agentid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.WebMessageInfo.agentId"); - target = stream->WriteStringMaybeAliased( - 47, this->_internal_agentid(), target); - } - - cached_has_bits = _impl_._has_bits_[1]; - // optional bool statusAlreadyViewed = 48; - if (cached_has_bits & 0x00000010u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray(48, this->_internal_statusalreadyviewed(), target); - } - - cached_has_bits = _impl_._has_bits_[0]; - // optional bytes messageSecret = 49; - if (cached_has_bits & 0x00000040u) { - target = stream->WriteBytesMaybeAliased( - 49, this->_internal_messagesecret(), target); - } - - // optional .proto.KeepInChat keepInChat = 50; - if (cached_has_bits & 0x00040000u) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(50, _Internal::keepinchat(this), - _Internal::keepinchat(this).GetCachedSize(), target, stream); - } - - // optional string originalSelfAuthorUserJidString = 51; - if (cached_has_bits & 0x00000080u) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( - this->_internal_originalselfauthoruserjidstring().data(), static_cast(this->_internal_originalselfauthoruserjidstring().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, - "proto.WebMessageInfo.originalSelfAuthorUserJidString"); - target = stream->WriteStringMaybeAliased( - 51, this->_internal_originalselfauthoruserjidstring(), target); - } - - cached_has_bits = _impl_._has_bits_[1]; - // optional uint64 revokeMessageTimestamp = 52; - if (cached_has_bits & 0x00000020u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(52, this->_internal_revokemessagetimestamp(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.WebMessageInfo) - return target; -} - -size_t WebMessageInfo::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.WebMessageInfo) - size_t total_size = 0; - - // required .proto.MessageKey key = 1; - if (_internal_has_key()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.key_); - } - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated string messageStubParameters = 26; - total_size += 2 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.messagestubparameters_.size()); - for (int i = 0, n = _impl_.messagestubparameters_.size(); i < n; i++) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - _impl_.messagestubparameters_.Get(i)); - } - - // repeated string labels = 28; - total_size += 2 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.labels_.size()); - for (int i = 0, n = _impl_.labels_.size(); i < n; i++) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - _impl_.labels_.Get(i)); - } - - // repeated .proto.UserReceipt userReceipt = 40; - total_size += 2UL * this->_internal_userreceipt_size(); - for (const auto& msg : this->_impl_.userreceipt_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // repeated .proto.Reaction reactions = 41; - total_size += 2UL * this->_internal_reactions_size(); - for (const auto& msg : this->_impl_.reactions_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // repeated .proto.PollUpdate pollUpdates = 45; - total_size += 2UL * this->_internal_pollupdates_size(); - for (const auto& msg : this->_impl_.pollupdates_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - // optional string participant = 5; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_participant()); - } - - // optional string pushName = 19; - if (cached_has_bits & 0x00000002u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_pushname()); - } - - // optional bytes mediaCiphertextSha256 = 20; - if (cached_has_bits & 0x00000004u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_mediaciphertextsha256()); - } - - // optional string verifiedBizName = 37; - if (cached_has_bits & 0x00000008u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_verifiedbizname()); - } - - // optional bytes futureproofData = 43; - if (cached_has_bits & 0x00000010u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_futureproofdata()); - } - - // optional string agentId = 47; - if (cached_has_bits & 0x00000020u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_agentid()); - } - - // optional bytes messageSecret = 49; - if (cached_has_bits & 0x00000040u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_messagesecret()); - } - - // optional string originalSelfAuthorUserJidString = 51; - if (cached_has_bits & 0x00000080u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_originalselfauthoruserjidstring()); - } - - } - if (cached_has_bits & 0x0000fe00u) { - // optional .proto.Message message = 2; - if (cached_has_bits & 0x00000200u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.message_); - } - - // optional .proto.PaymentInfo paymentInfo = 29; - if (cached_has_bits & 0x00000400u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.paymentinfo_); - } - - // optional .proto.Message.LiveLocationMessage finalLiveLocation = 30; - if (cached_has_bits & 0x00000800u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.finallivelocation_); - } - - // optional .proto.PaymentInfo quotedPaymentInfo = 31; - if (cached_has_bits & 0x00001000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.quotedpaymentinfo_); - } - - // optional .proto.MediaData mediaData = 38; - if (cached_has_bits & 0x00002000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.mediadata_); - } - - // optional .proto.PhotoChange photoChange = 39; - if (cached_has_bits & 0x00004000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.photochange_); - } - - // optional .proto.MediaData quotedStickerData = 42; - if (cached_has_bits & 0x00008000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.quotedstickerdata_); - } - - } - if (cached_has_bits & 0x00ff0000u) { - // optional .proto.StatusPSA statusPsa = 44; - if (cached_has_bits & 0x00010000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.statuspsa_); - } - - // optional .proto.PollAdditionalMetadata pollAdditionalMetadata = 46; - if (cached_has_bits & 0x00020000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.polladditionalmetadata_); - } - - // optional .proto.KeepInChat keepInChat = 50; - if (cached_has_bits & 0x00040000u) { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *_impl_.keepinchat_); - } - - // optional uint64 messageTimestamp = 3; - if (cached_has_bits & 0x00080000u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_messagetimestamp()); - } - - // optional uint64 messageC2STimestamp = 6; - if (cached_has_bits & 0x00100000u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_messagec2stimestamp()); - } - - // optional .proto.WebMessageInfo.Status status = 4; - if (cached_has_bits & 0x00200000u) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_status()); - } - - // optional bool ignore = 16; - if (cached_has_bits & 0x00400000u) { - total_size += 2 + 1; - } - - // optional bool starred = 17; - if (cached_has_bits & 0x00800000u) { - total_size += 2 + 1; - } - - } - if (cached_has_bits & 0xff000000u) { - // optional bool broadcast = 18; - if (cached_has_bits & 0x01000000u) { - total_size += 2 + 1; - } - - // optional bool multicast = 21; - if (cached_has_bits & 0x02000000u) { - total_size += 2 + 1; - } - - // optional .proto.WebMessageInfo.StubType messageStubType = 24; - if (cached_has_bits & 0x04000000u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_messagestubtype()); - } - - // optional bool urlText = 22; - if (cached_has_bits & 0x08000000u) { - total_size += 2 + 1; - } - - // optional bool urlNumber = 23; - if (cached_has_bits & 0x10000000u) { - total_size += 2 + 1; - } - - // optional bool clearMedia = 25; - if (cached_has_bits & 0x20000000u) { - total_size += 2 + 1; - } - - // optional bool ephemeralOffToOn = 34; - if (cached_has_bits & 0x40000000u) { - total_size += 2 + 1; - } - - // optional uint32 duration = 27; - if (cached_has_bits & 0x80000000u) { - total_size += 2 + - ::_pbi::WireFormatLite::UInt32Size( - this->_internal_duration()); - } - - } - cached_has_bits = _impl_._has_bits_[1]; - if (cached_has_bits & 0x0000003fu) { - // optional uint32 ephemeralDuration = 33; - if (cached_has_bits & 0x00000001u) { - total_size += 2 + - ::_pbi::WireFormatLite::UInt32Size( - this->_internal_ephemeralduration()); - } - - // optional uint64 ephemeralStartTimestamp = 32; - if (cached_has_bits & 0x00000002u) { - total_size += 2 + - ::_pbi::WireFormatLite::UInt64Size( - this->_internal_ephemeralstarttimestamp()); - } - - // optional .proto.WebMessageInfo.BizPrivacyStatus bizPrivacyStatus = 36; - if (cached_has_bits & 0x00000004u) { - total_size += 2 + - ::_pbi::WireFormatLite::EnumSize(this->_internal_bizprivacystatus()); - } - - // optional bool ephemeralOutOfSync = 35; - if (cached_has_bits & 0x00000008u) { - total_size += 2 + 1; - } - - // optional bool statusAlreadyViewed = 48; - if (cached_has_bits & 0x00000010u) { - total_size += 2 + 1; - } - - // optional uint64 revokeMessageTimestamp = 52; - if (cached_has_bits & 0x00000020u) { - total_size += 2 + - ::_pbi::WireFormatLite::UInt64Size( - this->_internal_revokemessagetimestamp()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData WebMessageInfo::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - WebMessageInfo::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*WebMessageInfo::GetClassData() const { return &_class_data_; } - - -void WebMessageInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.WebMessageInfo) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.messagestubparameters_.MergeFrom(from._impl_.messagestubparameters_); - _this->_impl_.labels_.MergeFrom(from._impl_.labels_); - _this->_impl_.userreceipt_.MergeFrom(from._impl_.userreceipt_); - _this->_impl_.reactions_.MergeFrom(from._impl_.reactions_); - _this->_impl_.pollupdates_.MergeFrom(from._impl_.pollupdates_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x000000ffu) { - if (cached_has_bits & 0x00000001u) { - _this->_internal_set_participant(from._internal_participant()); - } - if (cached_has_bits & 0x00000002u) { - _this->_internal_set_pushname(from._internal_pushname()); - } - if (cached_has_bits & 0x00000004u) { - _this->_internal_set_mediaciphertextsha256(from._internal_mediaciphertextsha256()); - } - if (cached_has_bits & 0x00000008u) { - _this->_internal_set_verifiedbizname(from._internal_verifiedbizname()); - } - if (cached_has_bits & 0x00000010u) { - _this->_internal_set_futureproofdata(from._internal_futureproofdata()); - } - if (cached_has_bits & 0x00000020u) { - _this->_internal_set_agentid(from._internal_agentid()); - } - if (cached_has_bits & 0x00000040u) { - _this->_internal_set_messagesecret(from._internal_messagesecret()); - } - if (cached_has_bits & 0x00000080u) { - _this->_internal_set_originalselfauthoruserjidstring(from._internal_originalselfauthoruserjidstring()); - } - } - if (cached_has_bits & 0x0000ff00u) { - if (cached_has_bits & 0x00000100u) { - _this->_internal_mutable_key()->::proto::MessageKey::MergeFrom( - from._internal_key()); - } - if (cached_has_bits & 0x00000200u) { - _this->_internal_mutable_message()->::proto::Message::MergeFrom( - from._internal_message()); - } - if (cached_has_bits & 0x00000400u) { - _this->_internal_mutable_paymentinfo()->::proto::PaymentInfo::MergeFrom( - from._internal_paymentinfo()); - } - if (cached_has_bits & 0x00000800u) { - _this->_internal_mutable_finallivelocation()->::proto::Message_LiveLocationMessage::MergeFrom( - from._internal_finallivelocation()); - } - if (cached_has_bits & 0x00001000u) { - _this->_internal_mutable_quotedpaymentinfo()->::proto::PaymentInfo::MergeFrom( - from._internal_quotedpaymentinfo()); - } - if (cached_has_bits & 0x00002000u) { - _this->_internal_mutable_mediadata()->::proto::MediaData::MergeFrom( - from._internal_mediadata()); - } - if (cached_has_bits & 0x00004000u) { - _this->_internal_mutable_photochange()->::proto::PhotoChange::MergeFrom( - from._internal_photochange()); - } - if (cached_has_bits & 0x00008000u) { - _this->_internal_mutable_quotedstickerdata()->::proto::MediaData::MergeFrom( - from._internal_quotedstickerdata()); - } - } - if (cached_has_bits & 0x00ff0000u) { - if (cached_has_bits & 0x00010000u) { - _this->_internal_mutable_statuspsa()->::proto::StatusPSA::MergeFrom( - from._internal_statuspsa()); - } - if (cached_has_bits & 0x00020000u) { - _this->_internal_mutable_polladditionalmetadata()->::proto::PollAdditionalMetadata::MergeFrom( - from._internal_polladditionalmetadata()); - } - if (cached_has_bits & 0x00040000u) { - _this->_internal_mutable_keepinchat()->::proto::KeepInChat::MergeFrom( - from._internal_keepinchat()); - } - if (cached_has_bits & 0x00080000u) { - _this->_impl_.messagetimestamp_ = from._impl_.messagetimestamp_; - } - if (cached_has_bits & 0x00100000u) { - _this->_impl_.messagec2stimestamp_ = from._impl_.messagec2stimestamp_; - } - if (cached_has_bits & 0x00200000u) { - _this->_impl_.status_ = from._impl_.status_; - } - if (cached_has_bits & 0x00400000u) { - _this->_impl_.ignore_ = from._impl_.ignore_; - } - if (cached_has_bits & 0x00800000u) { - _this->_impl_.starred_ = from._impl_.starred_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - if (cached_has_bits & 0xff000000u) { - if (cached_has_bits & 0x01000000u) { - _this->_impl_.broadcast_ = from._impl_.broadcast_; - } - if (cached_has_bits & 0x02000000u) { - _this->_impl_.multicast_ = from._impl_.multicast_; - } - if (cached_has_bits & 0x04000000u) { - _this->_impl_.messagestubtype_ = from._impl_.messagestubtype_; - } - if (cached_has_bits & 0x08000000u) { - _this->_impl_.urltext_ = from._impl_.urltext_; - } - if (cached_has_bits & 0x10000000u) { - _this->_impl_.urlnumber_ = from._impl_.urlnumber_; - } - if (cached_has_bits & 0x20000000u) { - _this->_impl_.clearmedia_ = from._impl_.clearmedia_; - } - if (cached_has_bits & 0x40000000u) { - _this->_impl_.ephemeralofftoon_ = from._impl_.ephemeralofftoon_; - } - if (cached_has_bits & 0x80000000u) { - _this->_impl_.duration_ = from._impl_.duration_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - cached_has_bits = from._impl_._has_bits_[1]; - if (cached_has_bits & 0x0000003fu) { - if (cached_has_bits & 0x00000001u) { - _this->_impl_.ephemeralduration_ = from._impl_.ephemeralduration_; - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.ephemeralstarttimestamp_ = from._impl_.ephemeralstarttimestamp_; - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.bizprivacystatus_ = from._impl_.bizprivacystatus_; - } - if (cached_has_bits & 0x00000008u) { - _this->_impl_.ephemeraloutofsync_ = from._impl_.ephemeraloutofsync_; - } - if (cached_has_bits & 0x00000010u) { - _this->_impl_.statusalreadyviewed_ = from._impl_.statusalreadyviewed_; - } - if (cached_has_bits & 0x00000020u) { - _this->_impl_.revokemessagetimestamp_ = from._impl_.revokemessagetimestamp_; - } - _this->_impl_._has_bits_[1] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void WebMessageInfo::CopyFrom(const WebMessageInfo& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.WebMessageInfo) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool WebMessageInfo::IsInitialized() const { - if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false; - if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.userreceipt_)) - return false; - if (_internal_has_statuspsa()) { - if (!_impl_.statuspsa_->IsInitialized()) return false; - } - return true; -} - -void WebMessageInfo::InternalSwap(WebMessageInfo* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - swap(_impl_._has_bits_[1], other->_impl_._has_bits_[1]); - _impl_.messagestubparameters_.InternalSwap(&other->_impl_.messagestubparameters_); - _impl_.labels_.InternalSwap(&other->_impl_.labels_); - _impl_.userreceipt_.InternalSwap(&other->_impl_.userreceipt_); - _impl_.reactions_.InternalSwap(&other->_impl_.reactions_); - _impl_.pollupdates_.InternalSwap(&other->_impl_.pollupdates_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.participant_, lhs_arena, - &other->_impl_.participant_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.pushname_, lhs_arena, - &other->_impl_.pushname_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.mediaciphertextsha256_, lhs_arena, - &other->_impl_.mediaciphertextsha256_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.verifiedbizname_, lhs_arena, - &other->_impl_.verifiedbizname_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.futureproofdata_, lhs_arena, - &other->_impl_.futureproofdata_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.agentid_, lhs_arena, - &other->_impl_.agentid_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.messagesecret_, lhs_arena, - &other->_impl_.messagesecret_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &_impl_.originalselfauthoruserjidstring_, lhs_arena, - &other->_impl_.originalselfauthoruserjidstring_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(WebMessageInfo, _impl_.revokemessagetimestamp_) - + sizeof(WebMessageInfo::_impl_.revokemessagetimestamp_) - - PROTOBUF_FIELD_OFFSET(WebMessageInfo, _impl_.key_)>( - reinterpret_cast(&_impl_.key_), - reinterpret_cast(&other->_impl_.key_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata WebMessageInfo::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[222]); -} - -// =================================================================== - -class WebNotificationsInfo::_Internal { - public: - using HasBits = decltype(std::declval()._impl_._has_bits_); - static void set_has_timestamp(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_unreadchats(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_notifymessagecount(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } -}; - -WebNotificationsInfo::WebNotificationsInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(arena, is_message_owned); - // @@protoc_insertion_point(arena_constructor:proto.WebNotificationsInfo) -} -WebNotificationsInfo::WebNotificationsInfo(const WebNotificationsInfo& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - WebNotificationsInfo* const _this = this; (void)_this; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){from._impl_._has_bits_} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.notifymessages_){from._impl_.notifymessages_} - , decltype(_impl_.timestamp_){} - , decltype(_impl_.unreadchats_){} - , decltype(_impl_.notifymessagecount_){}}; - - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&_impl_.timestamp_, &from._impl_.timestamp_, - static_cast(reinterpret_cast(&_impl_.notifymessagecount_) - - reinterpret_cast(&_impl_.timestamp_)) + sizeof(_impl_.notifymessagecount_)); - // @@protoc_insertion_point(copy_constructor:proto.WebNotificationsInfo) -} - -inline void WebNotificationsInfo::SharedCtor( - ::_pb::Arena* arena, bool is_message_owned) { - (void)arena; - (void)is_message_owned; - new (&_impl_) Impl_{ - decltype(_impl_._has_bits_){} - , /*decltype(_impl_._cached_size_)*/{} - , decltype(_impl_.notifymessages_){arena} - , decltype(_impl_.timestamp_){uint64_t{0u}} - , decltype(_impl_.unreadchats_){0u} - , decltype(_impl_.notifymessagecount_){0u} - }; -} - -WebNotificationsInfo::~WebNotificationsInfo() { - // @@protoc_insertion_point(destructor:proto.WebNotificationsInfo) - if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { - (void)arena; - return; - } - SharedDtor(); -} - -inline void WebNotificationsInfo::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - _impl_.notifymessages_.~RepeatedPtrField(); -} - -void WebNotificationsInfo::SetCachedSize(int size) const { - _impl_._cached_size_.Set(size); -} - -void WebNotificationsInfo::Clear() { -// @@protoc_insertion_point(message_clear_start:proto.WebNotificationsInfo) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.notifymessages_.Clear(); - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - ::memset(&_impl_.timestamp_, 0, static_cast( - reinterpret_cast(&_impl_.notifymessagecount_) - - reinterpret_cast(&_impl_.timestamp_)) + sizeof(_impl_.notifymessagecount_)); - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* WebNotificationsInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - _Internal::HasBits has_bits{}; - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::_pbi::ReadTag(ptr, &tag); - switch (tag >> 3) { - // optional uint64 timestamp = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _Internal::set_has_timestamp(&has_bits); - _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 unreadChats = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _Internal::set_has_unreadchats(&has_bits); - _impl_.unreadchats_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // optional uint32 notifyMessageCount = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - _Internal::set_has_notifymessagecount(&has_bits); - _impl_.notifymessagecount_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated .proto.WebMessageInfo notifyMessages = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_notifymessages(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr)); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - _impl_._has_bits_.Or(has_bits); - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* WebNotificationsInfo::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:proto.WebNotificationsInfo) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - // optional uint64 timestamp = 2; - if (cached_has_bits & 0x00000001u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_timestamp(), target); - } - - // optional uint32 unreadChats = 3; - if (cached_has_bits & 0x00000002u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_unreadchats(), target); - } - - // optional uint32 notifyMessageCount = 4; - if (cached_has_bits & 0x00000004u) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_notifymessagecount(), target); - } - - // repeated .proto.WebMessageInfo notifyMessages = 5; - for (unsigned i = 0, - n = static_cast(this->_internal_notifymessages_size()); i < n; i++) { - const auto& repfield = this->_internal_notifymessages(i); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(5, repfield, repfield.GetCachedSize(), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:proto.WebNotificationsInfo) - return target; -} - -size_t WebNotificationsInfo::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:proto.WebNotificationsInfo) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .proto.WebMessageInfo notifyMessages = 5; - total_size += 1UL * this->_internal_notifymessages_size(); - for (const auto& msg : this->_impl_.notifymessages_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - cached_has_bits = _impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - // optional uint64 timestamp = 2; - if (cached_has_bits & 0x00000001u) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_timestamp()); - } - - // optional uint32 unreadChats = 3; - if (cached_has_bits & 0x00000002u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_unreadchats()); - } - - // optional uint32 notifyMessageCount = 4; - if (cached_has_bits & 0x00000004u) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_notifymessagecount()); - } - - } - return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData WebNotificationsInfo::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, - WebNotificationsInfo::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*WebNotificationsInfo::GetClassData() const { return &_class_data_; } - - -void WebNotificationsInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:proto.WebNotificationsInfo) - GOOGLE_DCHECK_NE(&from, _this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_impl_.notifymessages_.MergeFrom(from._impl_.notifymessages_); - cached_has_bits = from._impl_._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { - if (cached_has_bits & 0x00000001u) { - _this->_impl_.timestamp_ = from._impl_.timestamp_; - } - if (cached_has_bits & 0x00000002u) { - _this->_impl_.unreadchats_ = from._impl_.unreadchats_; - } - if (cached_has_bits & 0x00000004u) { - _this->_impl_.notifymessagecount_ = from._impl_.notifymessagecount_; - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - } - _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void WebNotificationsInfo::CopyFrom(const WebNotificationsInfo& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:proto.WebNotificationsInfo) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool WebNotificationsInfo::IsInitialized() const { - if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.notifymessages_)) - return false; - return true; -} - -void WebNotificationsInfo::InternalSwap(WebNotificationsInfo* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.notifymessages_.InternalSwap(&other->_impl_.notifymessages_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(WebNotificationsInfo, _impl_.notifymessagecount_) - + sizeof(WebNotificationsInfo::_impl_.notifymessagecount_) - - PROTOBUF_FIELD_OFFSET(WebNotificationsInfo, _impl_.timestamp_)>( - reinterpret_cast(&_impl_.timestamp_), - reinterpret_cast(&other->_impl_.timestamp_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata WebNotificationsInfo::GetMetadata() const { - return ::_pbi::AssignDescriptors( - &descriptor_table_pmsg_2eproto_getter, &descriptor_table_pmsg_2eproto_once, - file_level_metadata_pmsg_2eproto[223]); -} - -// @@protoc_insertion_point(namespace_scope) -} // namespace proto -PROTOBUF_NAMESPACE_OPEN -template<> PROTOBUF_NOINLINE ::proto::ADVDeviceIdentity* -Arena::CreateMaybeMessage< ::proto::ADVDeviceIdentity >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::ADVDeviceIdentity >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::ADVKeyIndexList* -Arena::CreateMaybeMessage< ::proto::ADVKeyIndexList >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::ADVKeyIndexList >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::ADVSignedDeviceIdentity* -Arena::CreateMaybeMessage< ::proto::ADVSignedDeviceIdentity >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::ADVSignedDeviceIdentity >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::ADVSignedDeviceIdentityHMAC* -Arena::CreateMaybeMessage< ::proto::ADVSignedDeviceIdentityHMAC >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::ADVSignedDeviceIdentityHMAC >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::ADVSignedKeyIndexList* -Arena::CreateMaybeMessage< ::proto::ADVSignedKeyIndexList >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::ADVSignedKeyIndexList >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::ActionLink* -Arena::CreateMaybeMessage< ::proto::ActionLink >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::ActionLink >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::AutoDownloadSettings* -Arena::CreateMaybeMessage< ::proto::AutoDownloadSettings >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::AutoDownloadSettings >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::BizAccountLinkInfo* -Arena::CreateMaybeMessage< ::proto::BizAccountLinkInfo >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::BizAccountLinkInfo >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::BizAccountPayload* -Arena::CreateMaybeMessage< ::proto::BizAccountPayload >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::BizAccountPayload >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::BizIdentityInfo* -Arena::CreateMaybeMessage< ::proto::BizIdentityInfo >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::BizIdentityInfo >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::CertChain_NoiseCertificate_Details* -Arena::CreateMaybeMessage< ::proto::CertChain_NoiseCertificate_Details >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::CertChain_NoiseCertificate_Details >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::CertChain_NoiseCertificate* -Arena::CreateMaybeMessage< ::proto::CertChain_NoiseCertificate >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::CertChain_NoiseCertificate >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::CertChain* -Arena::CreateMaybeMessage< ::proto::CertChain >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::CertChain >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Chain* -Arena::CreateMaybeMessage< ::proto::Chain >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Chain >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::ChainKey* -Arena::CreateMaybeMessage< ::proto::ChainKey >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::ChainKey >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::ClientPayload_DNSSource* -Arena::CreateMaybeMessage< ::proto::ClientPayload_DNSSource >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::ClientPayload_DNSSource >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::ClientPayload_DevicePairingRegistrationData* -Arena::CreateMaybeMessage< ::proto::ClientPayload_DevicePairingRegistrationData >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::ClientPayload_DevicePairingRegistrationData >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::ClientPayload_UserAgent_AppVersion* -Arena::CreateMaybeMessage< ::proto::ClientPayload_UserAgent_AppVersion >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::ClientPayload_UserAgent_AppVersion >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::ClientPayload_UserAgent* -Arena::CreateMaybeMessage< ::proto::ClientPayload_UserAgent >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::ClientPayload_UserAgent >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::ClientPayload_WebInfo_WebdPayload* -Arena::CreateMaybeMessage< ::proto::ClientPayload_WebInfo_WebdPayload >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::ClientPayload_WebInfo_WebdPayload >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::ClientPayload_WebInfo* -Arena::CreateMaybeMessage< ::proto::ClientPayload_WebInfo >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::ClientPayload_WebInfo >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::ClientPayload* -Arena::CreateMaybeMessage< ::proto::ClientPayload >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::ClientPayload >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::ContextInfo_AdReplyInfo* -Arena::CreateMaybeMessage< ::proto::ContextInfo_AdReplyInfo >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::ContextInfo_AdReplyInfo >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::ContextInfo_ExternalAdReplyInfo* -Arena::CreateMaybeMessage< ::proto::ContextInfo_ExternalAdReplyInfo >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::ContextInfo_ExternalAdReplyInfo >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::ContextInfo* -Arena::CreateMaybeMessage< ::proto::ContextInfo >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::ContextInfo >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Conversation* -Arena::CreateMaybeMessage< ::proto::Conversation >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Conversation >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::DeviceListMetadata* -Arena::CreateMaybeMessage< ::proto::DeviceListMetadata >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::DeviceListMetadata >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::DeviceProps_AppVersion* -Arena::CreateMaybeMessage< ::proto::DeviceProps_AppVersion >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::DeviceProps_AppVersion >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::DeviceProps* -Arena::CreateMaybeMessage< ::proto::DeviceProps >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::DeviceProps >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::DisappearingMode* -Arena::CreateMaybeMessage< ::proto::DisappearingMode >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::DisappearingMode >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::EphemeralSetting* -Arena::CreateMaybeMessage< ::proto::EphemeralSetting >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::EphemeralSetting >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::ExitCode* -Arena::CreateMaybeMessage< ::proto::ExitCode >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::ExitCode >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::ExternalBlobReference* -Arena::CreateMaybeMessage< ::proto::ExternalBlobReference >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::ExternalBlobReference >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::GlobalSettings* -Arena::CreateMaybeMessage< ::proto::GlobalSettings >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::GlobalSettings >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::GroupParticipant* -Arena::CreateMaybeMessage< ::proto::GroupParticipant >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::GroupParticipant >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::HandshakeMessage_ClientFinish* -Arena::CreateMaybeMessage< ::proto::HandshakeMessage_ClientFinish >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::HandshakeMessage_ClientFinish >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::HandshakeMessage_ClientHello* -Arena::CreateMaybeMessage< ::proto::HandshakeMessage_ClientHello >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::HandshakeMessage_ClientHello >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::HandshakeMessage_ServerHello* -Arena::CreateMaybeMessage< ::proto::HandshakeMessage_ServerHello >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::HandshakeMessage_ServerHello >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::HandshakeMessage* -Arena::CreateMaybeMessage< ::proto::HandshakeMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::HandshakeMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::HistorySync* -Arena::CreateMaybeMessage< ::proto::HistorySync >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::HistorySync >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::HistorySyncMsg* -Arena::CreateMaybeMessage< ::proto::HistorySyncMsg >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::HistorySyncMsg >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::HydratedTemplateButton_HydratedCallButton* -Arena::CreateMaybeMessage< ::proto::HydratedTemplateButton_HydratedCallButton >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::HydratedTemplateButton_HydratedCallButton >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::HydratedTemplateButton_HydratedQuickReplyButton* -Arena::CreateMaybeMessage< ::proto::HydratedTemplateButton_HydratedQuickReplyButton >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::HydratedTemplateButton_HydratedQuickReplyButton >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::HydratedTemplateButton_HydratedURLButton* -Arena::CreateMaybeMessage< ::proto::HydratedTemplateButton_HydratedURLButton >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::HydratedTemplateButton_HydratedURLButton >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::HydratedTemplateButton* -Arena::CreateMaybeMessage< ::proto::HydratedTemplateButton >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::HydratedTemplateButton >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::IdentityKeyPairStructure* -Arena::CreateMaybeMessage< ::proto::IdentityKeyPairStructure >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::IdentityKeyPairStructure >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::InteractiveAnnotation* -Arena::CreateMaybeMessage< ::proto::InteractiveAnnotation >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::InteractiveAnnotation >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::KeepInChat* -Arena::CreateMaybeMessage< ::proto::KeepInChat >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::KeepInChat >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::KeyId* -Arena::CreateMaybeMessage< ::proto::KeyId >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::KeyId >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::LocalizedName* -Arena::CreateMaybeMessage< ::proto::LocalizedName >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::LocalizedName >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Location* -Arena::CreateMaybeMessage< ::proto::Location >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Location >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::MediaData* -Arena::CreateMaybeMessage< ::proto::MediaData >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::MediaData >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::MediaRetryNotification* -Arena::CreateMaybeMessage< ::proto::MediaRetryNotification >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::MediaRetryNotification >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_AppStateFatalExceptionNotification* -Arena::CreateMaybeMessage< ::proto::Message_AppStateFatalExceptionNotification >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_AppStateFatalExceptionNotification >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_AppStateSyncKeyData* -Arena::CreateMaybeMessage< ::proto::Message_AppStateSyncKeyData >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_AppStateSyncKeyData >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_AppStateSyncKeyFingerprint* -Arena::CreateMaybeMessage< ::proto::Message_AppStateSyncKeyFingerprint >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_AppStateSyncKeyFingerprint >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_AppStateSyncKeyId* -Arena::CreateMaybeMessage< ::proto::Message_AppStateSyncKeyId >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_AppStateSyncKeyId >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_AppStateSyncKeyRequest* -Arena::CreateMaybeMessage< ::proto::Message_AppStateSyncKeyRequest >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_AppStateSyncKeyRequest >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_AppStateSyncKeyShare* -Arena::CreateMaybeMessage< ::proto::Message_AppStateSyncKeyShare >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_AppStateSyncKeyShare >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_AppStateSyncKey* -Arena::CreateMaybeMessage< ::proto::Message_AppStateSyncKey >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_AppStateSyncKey >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_AudioMessage* -Arena::CreateMaybeMessage< ::proto::Message_AudioMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_AudioMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_ButtonsMessage_Button_ButtonText* -Arena::CreateMaybeMessage< ::proto::Message_ButtonsMessage_Button_ButtonText >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_ButtonsMessage_Button_ButtonText >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* -Arena::CreateMaybeMessage< ::proto::Message_ButtonsMessage_Button_NativeFlowInfo >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_ButtonsMessage_Button_NativeFlowInfo >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_ButtonsMessage_Button* -Arena::CreateMaybeMessage< ::proto::Message_ButtonsMessage_Button >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_ButtonsMessage_Button >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_ButtonsMessage* -Arena::CreateMaybeMessage< ::proto::Message_ButtonsMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_ButtonsMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_ButtonsResponseMessage* -Arena::CreateMaybeMessage< ::proto::Message_ButtonsResponseMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_ButtonsResponseMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_Call* -Arena::CreateMaybeMessage< ::proto::Message_Call >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_Call >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_CancelPaymentRequestMessage* -Arena::CreateMaybeMessage< ::proto::Message_CancelPaymentRequestMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_CancelPaymentRequestMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_Chat* -Arena::CreateMaybeMessage< ::proto::Message_Chat >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_Chat >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_ContactMessage* -Arena::CreateMaybeMessage< ::proto::Message_ContactMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_ContactMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_ContactsArrayMessage* -Arena::CreateMaybeMessage< ::proto::Message_ContactsArrayMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_ContactsArrayMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_DeclinePaymentRequestMessage* -Arena::CreateMaybeMessage< ::proto::Message_DeclinePaymentRequestMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_DeclinePaymentRequestMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_DeviceSentMessage* -Arena::CreateMaybeMessage< ::proto::Message_DeviceSentMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_DeviceSentMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_DocumentMessage* -Arena::CreateMaybeMessage< ::proto::Message_DocumentMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_DocumentMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_ExtendedTextMessage* -Arena::CreateMaybeMessage< ::proto::Message_ExtendedTextMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_ExtendedTextMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_FutureProofMessage* -Arena::CreateMaybeMessage< ::proto::Message_FutureProofMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_FutureProofMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_GroupInviteMessage* -Arena::CreateMaybeMessage< ::proto::Message_GroupInviteMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_GroupInviteMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* -Arena::CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* -Arena::CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* -Arena::CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* -Arena::CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* -Arena::CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_HighlyStructuredMessage* -Arena::CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_HighlyStructuredMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_HistorySyncNotification* -Arena::CreateMaybeMessage< ::proto::Message_HistorySyncNotification >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_HistorySyncNotification >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_ImageMessage* -Arena::CreateMaybeMessage< ::proto::Message_ImageMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_ImageMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_InitialSecurityNotificationSettingSync* -Arena::CreateMaybeMessage< ::proto::Message_InitialSecurityNotificationSettingSync >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_InitialSecurityNotificationSettingSync >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveMessage_Body* -Arena::CreateMaybeMessage< ::proto::Message_InteractiveMessage_Body >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_InteractiveMessage_Body >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveMessage_CollectionMessage* -Arena::CreateMaybeMessage< ::proto::Message_InteractiveMessage_CollectionMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_InteractiveMessage_CollectionMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveMessage_Footer* -Arena::CreateMaybeMessage< ::proto::Message_InteractiveMessage_Footer >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_InteractiveMessage_Footer >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveMessage_Header* -Arena::CreateMaybeMessage< ::proto::Message_InteractiveMessage_Header >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_InteractiveMessage_Header >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* -Arena::CreateMaybeMessage< ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveMessage_NativeFlowMessage* -Arena::CreateMaybeMessage< ::proto::Message_InteractiveMessage_NativeFlowMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_InteractiveMessage_NativeFlowMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveMessage_ShopMessage* -Arena::CreateMaybeMessage< ::proto::Message_InteractiveMessage_ShopMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_InteractiveMessage_ShopMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveMessage* -Arena::CreateMaybeMessage< ::proto::Message_InteractiveMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_InteractiveMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveResponseMessage_Body* -Arena::CreateMaybeMessage< ::proto::Message_InteractiveResponseMessage_Body >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_InteractiveResponseMessage_Body >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* -Arena::CreateMaybeMessage< ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_InteractiveResponseMessage* -Arena::CreateMaybeMessage< ::proto::Message_InteractiveResponseMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_InteractiveResponseMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_InvoiceMessage* -Arena::CreateMaybeMessage< ::proto::Message_InvoiceMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_InvoiceMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_KeepInChatMessage* -Arena::CreateMaybeMessage< ::proto::Message_KeepInChatMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_KeepInChatMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_ListMessage_ProductListHeaderImage* -Arena::CreateMaybeMessage< ::proto::Message_ListMessage_ProductListHeaderImage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_ListMessage_ProductListHeaderImage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_ListMessage_ProductListInfo* -Arena::CreateMaybeMessage< ::proto::Message_ListMessage_ProductListInfo >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_ListMessage_ProductListInfo >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_ListMessage_ProductSection* -Arena::CreateMaybeMessage< ::proto::Message_ListMessage_ProductSection >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_ListMessage_ProductSection >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_ListMessage_Product* -Arena::CreateMaybeMessage< ::proto::Message_ListMessage_Product >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_ListMessage_Product >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_ListMessage_Row* -Arena::CreateMaybeMessage< ::proto::Message_ListMessage_Row >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_ListMessage_Row >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_ListMessage_Section* -Arena::CreateMaybeMessage< ::proto::Message_ListMessage_Section >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_ListMessage_Section >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_ListMessage* -Arena::CreateMaybeMessage< ::proto::Message_ListMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_ListMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_ListResponseMessage_SingleSelectReply* -Arena::CreateMaybeMessage< ::proto::Message_ListResponseMessage_SingleSelectReply >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_ListResponseMessage_SingleSelectReply >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_ListResponseMessage* -Arena::CreateMaybeMessage< ::proto::Message_ListResponseMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_ListResponseMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_LiveLocationMessage* -Arena::CreateMaybeMessage< ::proto::Message_LiveLocationMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_LiveLocationMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_LocationMessage* -Arena::CreateMaybeMessage< ::proto::Message_LocationMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_LocationMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_OrderMessage* -Arena::CreateMaybeMessage< ::proto::Message_OrderMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_OrderMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_PaymentInviteMessage* -Arena::CreateMaybeMessage< ::proto::Message_PaymentInviteMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_PaymentInviteMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_PollCreationMessage_Option* -Arena::CreateMaybeMessage< ::proto::Message_PollCreationMessage_Option >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_PollCreationMessage_Option >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_PollCreationMessage* -Arena::CreateMaybeMessage< ::proto::Message_PollCreationMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_PollCreationMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_PollEncValue* -Arena::CreateMaybeMessage< ::proto::Message_PollEncValue >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_PollEncValue >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_PollUpdateMessageMetadata* -Arena::CreateMaybeMessage< ::proto::Message_PollUpdateMessageMetadata >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_PollUpdateMessageMetadata >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_PollUpdateMessage* -Arena::CreateMaybeMessage< ::proto::Message_PollUpdateMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_PollUpdateMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_PollVoteMessage* -Arena::CreateMaybeMessage< ::proto::Message_PollVoteMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_PollVoteMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_ProductMessage_CatalogSnapshot* -Arena::CreateMaybeMessage< ::proto::Message_ProductMessage_CatalogSnapshot >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_ProductMessage_CatalogSnapshot >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_ProductMessage_ProductSnapshot* -Arena::CreateMaybeMessage< ::proto::Message_ProductMessage_ProductSnapshot >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_ProductMessage_ProductSnapshot >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_ProductMessage* -Arena::CreateMaybeMessage< ::proto::Message_ProductMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_ProductMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_ProtocolMessage* -Arena::CreateMaybeMessage< ::proto::Message_ProtocolMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_ProtocolMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_ReactionMessage* -Arena::CreateMaybeMessage< ::proto::Message_ReactionMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_ReactionMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_RequestMediaUploadMessage* -Arena::CreateMaybeMessage< ::proto::Message_RequestMediaUploadMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_RequestMediaUploadMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* -Arena::CreateMaybeMessage< ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_RequestMediaUploadResponseMessage* -Arena::CreateMaybeMessage< ::proto::Message_RequestMediaUploadResponseMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_RequestMediaUploadResponseMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_RequestPaymentMessage* -Arena::CreateMaybeMessage< ::proto::Message_RequestPaymentMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_RequestPaymentMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_RequestPhoneNumberMessage* -Arena::CreateMaybeMessage< ::proto::Message_RequestPhoneNumberMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_RequestPhoneNumberMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_SendPaymentMessage* -Arena::CreateMaybeMessage< ::proto::Message_SendPaymentMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_SendPaymentMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_SenderKeyDistributionMessage* -Arena::CreateMaybeMessage< ::proto::Message_SenderKeyDistributionMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_SenderKeyDistributionMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_StickerMessage* -Arena::CreateMaybeMessage< ::proto::Message_StickerMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_StickerMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_StickerSyncRMRMessage* -Arena::CreateMaybeMessage< ::proto::Message_StickerSyncRMRMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_StickerSyncRMRMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_TemplateButtonReplyMessage* -Arena::CreateMaybeMessage< ::proto::Message_TemplateButtonReplyMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_TemplateButtonReplyMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_TemplateMessage_FourRowTemplate* -Arena::CreateMaybeMessage< ::proto::Message_TemplateMessage_FourRowTemplate >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_TemplateMessage_FourRowTemplate >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_TemplateMessage_HydratedFourRowTemplate* -Arena::CreateMaybeMessage< ::proto::Message_TemplateMessage_HydratedFourRowTemplate >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_TemplateMessage_HydratedFourRowTemplate >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_TemplateMessage* -Arena::CreateMaybeMessage< ::proto::Message_TemplateMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_TemplateMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message_VideoMessage* -Arena::CreateMaybeMessage< ::proto::Message_VideoMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message_VideoMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Message* -Arena::CreateMaybeMessage< ::proto::Message >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Message >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::MessageContextInfo* -Arena::CreateMaybeMessage< ::proto::MessageContextInfo >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::MessageContextInfo >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::MessageKey* -Arena::CreateMaybeMessage< ::proto::MessageKey >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::MessageKey >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Money* -Arena::CreateMaybeMessage< ::proto::Money >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Money >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::MsgOpaqueData_PollOption* -Arena::CreateMaybeMessage< ::proto::MsgOpaqueData_PollOption >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::MsgOpaqueData_PollOption >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::MsgOpaqueData* -Arena::CreateMaybeMessage< ::proto::MsgOpaqueData >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::MsgOpaqueData >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::MsgRowOpaqueData* -Arena::CreateMaybeMessage< ::proto::MsgRowOpaqueData >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::MsgRowOpaqueData >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::NoiseCertificate_Details* -Arena::CreateMaybeMessage< ::proto::NoiseCertificate_Details >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::NoiseCertificate_Details >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::NoiseCertificate* -Arena::CreateMaybeMessage< ::proto::NoiseCertificate >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::NoiseCertificate >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::NotificationMessageInfo* -Arena::CreateMaybeMessage< ::proto::NotificationMessageInfo >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::NotificationMessageInfo >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::PastParticipant* -Arena::CreateMaybeMessage< ::proto::PastParticipant >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::PastParticipant >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::PastParticipants* -Arena::CreateMaybeMessage< ::proto::PastParticipants >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::PastParticipants >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::PaymentBackground_MediaData* -Arena::CreateMaybeMessage< ::proto::PaymentBackground_MediaData >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::PaymentBackground_MediaData >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::PaymentBackground* -Arena::CreateMaybeMessage< ::proto::PaymentBackground >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::PaymentBackground >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::PaymentInfo* -Arena::CreateMaybeMessage< ::proto::PaymentInfo >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::PaymentInfo >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::PendingKeyExchange* -Arena::CreateMaybeMessage< ::proto::PendingKeyExchange >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::PendingKeyExchange >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::PendingPreKey* -Arena::CreateMaybeMessage< ::proto::PendingPreKey >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::PendingPreKey >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::PhotoChange* -Arena::CreateMaybeMessage< ::proto::PhotoChange >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::PhotoChange >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Point* -Arena::CreateMaybeMessage< ::proto::Point >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Point >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::PollAdditionalMetadata* -Arena::CreateMaybeMessage< ::proto::PollAdditionalMetadata >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::PollAdditionalMetadata >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::PollEncValue* -Arena::CreateMaybeMessage< ::proto::PollEncValue >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::PollEncValue >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::PollUpdate* -Arena::CreateMaybeMessage< ::proto::PollUpdate >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::PollUpdate >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::PreKeyRecordStructure* -Arena::CreateMaybeMessage< ::proto::PreKeyRecordStructure >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::PreKeyRecordStructure >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Pushname* -Arena::CreateMaybeMessage< ::proto::Pushname >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Pushname >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::Reaction* -Arena::CreateMaybeMessage< ::proto::Reaction >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::Reaction >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::RecentEmojiWeight* -Arena::CreateMaybeMessage< ::proto::RecentEmojiWeight >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::RecentEmojiWeight >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::RecordStructure* -Arena::CreateMaybeMessage< ::proto::RecordStructure >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::RecordStructure >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SenderChainKey* -Arena::CreateMaybeMessage< ::proto::SenderChainKey >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SenderChainKey >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SenderKeyRecordStructure* -Arena::CreateMaybeMessage< ::proto::SenderKeyRecordStructure >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SenderKeyRecordStructure >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SenderKeyStateStructure* -Arena::CreateMaybeMessage< ::proto::SenderKeyStateStructure >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SenderKeyStateStructure >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SenderMessageKey* -Arena::CreateMaybeMessage< ::proto::SenderMessageKey >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SenderMessageKey >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SenderSigningKey* -Arena::CreateMaybeMessage< ::proto::SenderSigningKey >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SenderSigningKey >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::ServerErrorReceipt* -Arena::CreateMaybeMessage< ::proto::ServerErrorReceipt >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::ServerErrorReceipt >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SessionStructure* -Arena::CreateMaybeMessage< ::proto::SessionStructure >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SessionStructure >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SignedPreKeyRecordStructure* -Arena::CreateMaybeMessage< ::proto::SignedPreKeyRecordStructure >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SignedPreKeyRecordStructure >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::StatusPSA* -Arena::CreateMaybeMessage< ::proto::StatusPSA >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::StatusPSA >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::StickerMetadata* -Arena::CreateMaybeMessage< ::proto::StickerMetadata >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::StickerMetadata >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncActionData* -Arena::CreateMaybeMessage< ::proto::SyncActionData >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncActionData >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_AgentAction* -Arena::CreateMaybeMessage< ::proto::SyncActionValue_AgentAction >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncActionValue_AgentAction >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_AndroidUnsupportedActions* -Arena::CreateMaybeMessage< ::proto::SyncActionValue_AndroidUnsupportedActions >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncActionValue_AndroidUnsupportedActions >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_ArchiveChatAction* -Arena::CreateMaybeMessage< ::proto::SyncActionValue_ArchiveChatAction >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncActionValue_ArchiveChatAction >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_ClearChatAction* -Arena::CreateMaybeMessage< ::proto::SyncActionValue_ClearChatAction >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncActionValue_ClearChatAction >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_ContactAction* -Arena::CreateMaybeMessage< ::proto::SyncActionValue_ContactAction >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncActionValue_ContactAction >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_DeleteChatAction* -Arena::CreateMaybeMessage< ::proto::SyncActionValue_DeleteChatAction >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncActionValue_DeleteChatAction >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_DeleteMessageForMeAction* -Arena::CreateMaybeMessage< ::proto::SyncActionValue_DeleteMessageForMeAction >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncActionValue_DeleteMessageForMeAction >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_KeyExpiration* -Arena::CreateMaybeMessage< ::proto::SyncActionValue_KeyExpiration >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncActionValue_KeyExpiration >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_LabelAssociationAction* -Arena::CreateMaybeMessage< ::proto::SyncActionValue_LabelAssociationAction >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncActionValue_LabelAssociationAction >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_LabelEditAction* -Arena::CreateMaybeMessage< ::proto::SyncActionValue_LabelEditAction >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncActionValue_LabelEditAction >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_LocaleSetting* -Arena::CreateMaybeMessage< ::proto::SyncActionValue_LocaleSetting >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncActionValue_LocaleSetting >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_MarkChatAsReadAction* -Arena::CreateMaybeMessage< ::proto::SyncActionValue_MarkChatAsReadAction >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncActionValue_MarkChatAsReadAction >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_MuteAction* -Arena::CreateMaybeMessage< ::proto::SyncActionValue_MuteAction >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncActionValue_MuteAction >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_NuxAction* -Arena::CreateMaybeMessage< ::proto::SyncActionValue_NuxAction >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncActionValue_NuxAction >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_PinAction* -Arena::CreateMaybeMessage< ::proto::SyncActionValue_PinAction >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncActionValue_PinAction >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_PrimaryFeature* -Arena::CreateMaybeMessage< ::proto::SyncActionValue_PrimaryFeature >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncActionValue_PrimaryFeature >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_PrimaryVersionAction* -Arena::CreateMaybeMessage< ::proto::SyncActionValue_PrimaryVersionAction >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncActionValue_PrimaryVersionAction >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_PushNameSetting* -Arena::CreateMaybeMessage< ::proto::SyncActionValue_PushNameSetting >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncActionValue_PushNameSetting >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_QuickReplyAction* -Arena::CreateMaybeMessage< ::proto::SyncActionValue_QuickReplyAction >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncActionValue_QuickReplyAction >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_RecentEmojiWeightsAction* -Arena::CreateMaybeMessage< ::proto::SyncActionValue_RecentEmojiWeightsAction >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncActionValue_RecentEmojiWeightsAction >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_SecurityNotificationSetting* -Arena::CreateMaybeMessage< ::proto::SyncActionValue_SecurityNotificationSetting >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncActionValue_SecurityNotificationSetting >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_StarAction* -Arena::CreateMaybeMessage< ::proto::SyncActionValue_StarAction >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncActionValue_StarAction >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_StickerAction* -Arena::CreateMaybeMessage< ::proto::SyncActionValue_StickerAction >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncActionValue_StickerAction >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_SubscriptionAction* -Arena::CreateMaybeMessage< ::proto::SyncActionValue_SubscriptionAction >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncActionValue_SubscriptionAction >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_SyncActionMessageRange* -Arena::CreateMaybeMessage< ::proto::SyncActionValue_SyncActionMessageRange >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncActionValue_SyncActionMessageRange >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_SyncActionMessage* -Arena::CreateMaybeMessage< ::proto::SyncActionValue_SyncActionMessage >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncActionValue_SyncActionMessage >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_TimeFormatAction* -Arena::CreateMaybeMessage< ::proto::SyncActionValue_TimeFormatAction >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncActionValue_TimeFormatAction >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_UnarchiveChatsSetting* -Arena::CreateMaybeMessage< ::proto::SyncActionValue_UnarchiveChatsSetting >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncActionValue_UnarchiveChatsSetting >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncActionValue_UserStatusMuteAction* -Arena::CreateMaybeMessage< ::proto::SyncActionValue_UserStatusMuteAction >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncActionValue_UserStatusMuteAction >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncActionValue* -Arena::CreateMaybeMessage< ::proto::SyncActionValue >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncActionValue >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncdIndex* -Arena::CreateMaybeMessage< ::proto::SyncdIndex >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncdIndex >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncdMutation* -Arena::CreateMaybeMessage< ::proto::SyncdMutation >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncdMutation >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncdMutations* -Arena::CreateMaybeMessage< ::proto::SyncdMutations >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncdMutations >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncdPatch* -Arena::CreateMaybeMessage< ::proto::SyncdPatch >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncdPatch >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncdRecord* -Arena::CreateMaybeMessage< ::proto::SyncdRecord >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncdRecord >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncdSnapshot* -Arena::CreateMaybeMessage< ::proto::SyncdSnapshot >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncdSnapshot >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncdValue* -Arena::CreateMaybeMessage< ::proto::SyncdValue >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncdValue >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::SyncdVersion* -Arena::CreateMaybeMessage< ::proto::SyncdVersion >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::SyncdVersion >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::TemplateButton_CallButton* -Arena::CreateMaybeMessage< ::proto::TemplateButton_CallButton >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::TemplateButton_CallButton >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::TemplateButton_QuickReplyButton* -Arena::CreateMaybeMessage< ::proto::TemplateButton_QuickReplyButton >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::TemplateButton_QuickReplyButton >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::TemplateButton_URLButton* -Arena::CreateMaybeMessage< ::proto::TemplateButton_URLButton >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::TemplateButton_URLButton >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::TemplateButton* -Arena::CreateMaybeMessage< ::proto::TemplateButton >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::TemplateButton >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::UserReceipt* -Arena::CreateMaybeMessage< ::proto::UserReceipt >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::UserReceipt >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::VerifiedNameCertificate_Details* -Arena::CreateMaybeMessage< ::proto::VerifiedNameCertificate_Details >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::VerifiedNameCertificate_Details >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::VerifiedNameCertificate* -Arena::CreateMaybeMessage< ::proto::VerifiedNameCertificate >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::VerifiedNameCertificate >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::WallpaperSettings* -Arena::CreateMaybeMessage< ::proto::WallpaperSettings >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::WallpaperSettings >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::WebFeatures* -Arena::CreateMaybeMessage< ::proto::WebFeatures >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::WebFeatures >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::WebMessageInfo* -Arena::CreateMaybeMessage< ::proto::WebMessageInfo >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::WebMessageInfo >(arena); -} -template<> PROTOBUF_NOINLINE ::proto::WebNotificationsInfo* -Arena::CreateMaybeMessage< ::proto::WebNotificationsInfo >(Arena* arena) { - return Arena::CreateMessageInternal< ::proto::WebNotificationsInfo >(arena); -} -PROTOBUF_NAMESPACE_CLOSE - -// @@protoc_insertion_point(global_scope) -#include diff --git a/protocols/WhatsAppWeb/src/pmsg.pb.h b/protocols/WhatsAppWeb/src/pmsg.pb.h deleted file mode 100644 index 5402ec1abf..0000000000 --- a/protocols/WhatsAppWeb/src/pmsg.pb.h +++ /dev/null @@ -1,125385 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: pmsg.proto - -#ifndef GOOGLE_PROTOBUF_INCLUDED_pmsg_2eproto -#define GOOGLE_PROTOBUF_INCLUDED_pmsg_2eproto - -#include -#include - -#include -#if PROTOBUF_VERSION < 3021000 -#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 3021004 < PROTOBUF_MIN_PROTOC_VERSION -#error This file was generated by an older version of protoc which is -#error incompatible with your Protocol Buffer headers. Please -#error regenerate this file with a newer version of protoc. -#endif - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include // IWYU pragma: export -#include // IWYU pragma: export -#include -#include -// @@protoc_insertion_point(includes) -#include -#define PROTOBUF_INTERNAL_EXPORT_pmsg_2eproto -PROTOBUF_NAMESPACE_OPEN -namespace internal { -class AnyMetadata; -} // namespace internal -PROTOBUF_NAMESPACE_CLOSE - -// Internal implementation detail -- do not use these members. -struct TableStruct_pmsg_2eproto { - static const uint32_t offsets[]; -}; -extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_pmsg_2eproto; -namespace proto { -class ADVDeviceIdentity; -struct ADVDeviceIdentityDefaultTypeInternal; -extern ADVDeviceIdentityDefaultTypeInternal _ADVDeviceIdentity_default_instance_; -class ADVKeyIndexList; -struct ADVKeyIndexListDefaultTypeInternal; -extern ADVKeyIndexListDefaultTypeInternal _ADVKeyIndexList_default_instance_; -class ADVSignedDeviceIdentity; -struct ADVSignedDeviceIdentityDefaultTypeInternal; -extern ADVSignedDeviceIdentityDefaultTypeInternal _ADVSignedDeviceIdentity_default_instance_; -class ADVSignedDeviceIdentityHMAC; -struct ADVSignedDeviceIdentityHMACDefaultTypeInternal; -extern ADVSignedDeviceIdentityHMACDefaultTypeInternal _ADVSignedDeviceIdentityHMAC_default_instance_; -class ADVSignedKeyIndexList; -struct ADVSignedKeyIndexListDefaultTypeInternal; -extern ADVSignedKeyIndexListDefaultTypeInternal _ADVSignedKeyIndexList_default_instance_; -class ActionLink; -struct ActionLinkDefaultTypeInternal; -extern ActionLinkDefaultTypeInternal _ActionLink_default_instance_; -class AutoDownloadSettings; -struct AutoDownloadSettingsDefaultTypeInternal; -extern AutoDownloadSettingsDefaultTypeInternal _AutoDownloadSettings_default_instance_; -class BizAccountLinkInfo; -struct BizAccountLinkInfoDefaultTypeInternal; -extern BizAccountLinkInfoDefaultTypeInternal _BizAccountLinkInfo_default_instance_; -class BizAccountPayload; -struct BizAccountPayloadDefaultTypeInternal; -extern BizAccountPayloadDefaultTypeInternal _BizAccountPayload_default_instance_; -class BizIdentityInfo; -struct BizIdentityInfoDefaultTypeInternal; -extern BizIdentityInfoDefaultTypeInternal _BizIdentityInfo_default_instance_; -class CertChain; -struct CertChainDefaultTypeInternal; -extern CertChainDefaultTypeInternal _CertChain_default_instance_; -class CertChain_NoiseCertificate; -struct CertChain_NoiseCertificateDefaultTypeInternal; -extern CertChain_NoiseCertificateDefaultTypeInternal _CertChain_NoiseCertificate_default_instance_; -class CertChain_NoiseCertificate_Details; -struct CertChain_NoiseCertificate_DetailsDefaultTypeInternal; -extern CertChain_NoiseCertificate_DetailsDefaultTypeInternal _CertChain_NoiseCertificate_Details_default_instance_; -class Chain; -struct ChainDefaultTypeInternal; -extern ChainDefaultTypeInternal _Chain_default_instance_; -class ChainKey; -struct ChainKeyDefaultTypeInternal; -extern ChainKeyDefaultTypeInternal _ChainKey_default_instance_; -class ClientPayload; -struct ClientPayloadDefaultTypeInternal; -extern ClientPayloadDefaultTypeInternal _ClientPayload_default_instance_; -class ClientPayload_DNSSource; -struct ClientPayload_DNSSourceDefaultTypeInternal; -extern ClientPayload_DNSSourceDefaultTypeInternal _ClientPayload_DNSSource_default_instance_; -class ClientPayload_DevicePairingRegistrationData; -struct ClientPayload_DevicePairingRegistrationDataDefaultTypeInternal; -extern ClientPayload_DevicePairingRegistrationDataDefaultTypeInternal _ClientPayload_DevicePairingRegistrationData_default_instance_; -class ClientPayload_UserAgent; -struct ClientPayload_UserAgentDefaultTypeInternal; -extern ClientPayload_UserAgentDefaultTypeInternal _ClientPayload_UserAgent_default_instance_; -class ClientPayload_UserAgent_AppVersion; -struct ClientPayload_UserAgent_AppVersionDefaultTypeInternal; -extern ClientPayload_UserAgent_AppVersionDefaultTypeInternal _ClientPayload_UserAgent_AppVersion_default_instance_; -class ClientPayload_WebInfo; -struct ClientPayload_WebInfoDefaultTypeInternal; -extern ClientPayload_WebInfoDefaultTypeInternal _ClientPayload_WebInfo_default_instance_; -class ClientPayload_WebInfo_WebdPayload; -struct ClientPayload_WebInfo_WebdPayloadDefaultTypeInternal; -extern ClientPayload_WebInfo_WebdPayloadDefaultTypeInternal _ClientPayload_WebInfo_WebdPayload_default_instance_; -class ContextInfo; -struct ContextInfoDefaultTypeInternal; -extern ContextInfoDefaultTypeInternal _ContextInfo_default_instance_; -class ContextInfo_AdReplyInfo; -struct ContextInfo_AdReplyInfoDefaultTypeInternal; -extern ContextInfo_AdReplyInfoDefaultTypeInternal _ContextInfo_AdReplyInfo_default_instance_; -class ContextInfo_ExternalAdReplyInfo; -struct ContextInfo_ExternalAdReplyInfoDefaultTypeInternal; -extern ContextInfo_ExternalAdReplyInfoDefaultTypeInternal _ContextInfo_ExternalAdReplyInfo_default_instance_; -class Conversation; -struct ConversationDefaultTypeInternal; -extern ConversationDefaultTypeInternal _Conversation_default_instance_; -class DeviceListMetadata; -struct DeviceListMetadataDefaultTypeInternal; -extern DeviceListMetadataDefaultTypeInternal _DeviceListMetadata_default_instance_; -class DeviceProps; -struct DevicePropsDefaultTypeInternal; -extern DevicePropsDefaultTypeInternal _DeviceProps_default_instance_; -class DeviceProps_AppVersion; -struct DeviceProps_AppVersionDefaultTypeInternal; -extern DeviceProps_AppVersionDefaultTypeInternal _DeviceProps_AppVersion_default_instance_; -class DisappearingMode; -struct DisappearingModeDefaultTypeInternal; -extern DisappearingModeDefaultTypeInternal _DisappearingMode_default_instance_; -class EphemeralSetting; -struct EphemeralSettingDefaultTypeInternal; -extern EphemeralSettingDefaultTypeInternal _EphemeralSetting_default_instance_; -class ExitCode; -struct ExitCodeDefaultTypeInternal; -extern ExitCodeDefaultTypeInternal _ExitCode_default_instance_; -class ExternalBlobReference; -struct ExternalBlobReferenceDefaultTypeInternal; -extern ExternalBlobReferenceDefaultTypeInternal _ExternalBlobReference_default_instance_; -class GlobalSettings; -struct GlobalSettingsDefaultTypeInternal; -extern GlobalSettingsDefaultTypeInternal _GlobalSettings_default_instance_; -class GroupParticipant; -struct GroupParticipantDefaultTypeInternal; -extern GroupParticipantDefaultTypeInternal _GroupParticipant_default_instance_; -class HandshakeMessage; -struct HandshakeMessageDefaultTypeInternal; -extern HandshakeMessageDefaultTypeInternal _HandshakeMessage_default_instance_; -class HandshakeMessage_ClientFinish; -struct HandshakeMessage_ClientFinishDefaultTypeInternal; -extern HandshakeMessage_ClientFinishDefaultTypeInternal _HandshakeMessage_ClientFinish_default_instance_; -class HandshakeMessage_ClientHello; -struct HandshakeMessage_ClientHelloDefaultTypeInternal; -extern HandshakeMessage_ClientHelloDefaultTypeInternal _HandshakeMessage_ClientHello_default_instance_; -class HandshakeMessage_ServerHello; -struct HandshakeMessage_ServerHelloDefaultTypeInternal; -extern HandshakeMessage_ServerHelloDefaultTypeInternal _HandshakeMessage_ServerHello_default_instance_; -class HistorySync; -struct HistorySyncDefaultTypeInternal; -extern HistorySyncDefaultTypeInternal _HistorySync_default_instance_; -class HistorySyncMsg; -struct HistorySyncMsgDefaultTypeInternal; -extern HistorySyncMsgDefaultTypeInternal _HistorySyncMsg_default_instance_; -class HydratedTemplateButton; -struct HydratedTemplateButtonDefaultTypeInternal; -extern HydratedTemplateButtonDefaultTypeInternal _HydratedTemplateButton_default_instance_; -class HydratedTemplateButton_HydratedCallButton; -struct HydratedTemplateButton_HydratedCallButtonDefaultTypeInternal; -extern HydratedTemplateButton_HydratedCallButtonDefaultTypeInternal _HydratedTemplateButton_HydratedCallButton_default_instance_; -class HydratedTemplateButton_HydratedQuickReplyButton; -struct HydratedTemplateButton_HydratedQuickReplyButtonDefaultTypeInternal; -extern HydratedTemplateButton_HydratedQuickReplyButtonDefaultTypeInternal _HydratedTemplateButton_HydratedQuickReplyButton_default_instance_; -class HydratedTemplateButton_HydratedURLButton; -struct HydratedTemplateButton_HydratedURLButtonDefaultTypeInternal; -extern HydratedTemplateButton_HydratedURLButtonDefaultTypeInternal _HydratedTemplateButton_HydratedURLButton_default_instance_; -class IdentityKeyPairStructure; -struct IdentityKeyPairStructureDefaultTypeInternal; -extern IdentityKeyPairStructureDefaultTypeInternal _IdentityKeyPairStructure_default_instance_; -class InteractiveAnnotation; -struct InteractiveAnnotationDefaultTypeInternal; -extern InteractiveAnnotationDefaultTypeInternal _InteractiveAnnotation_default_instance_; -class KeepInChat; -struct KeepInChatDefaultTypeInternal; -extern KeepInChatDefaultTypeInternal _KeepInChat_default_instance_; -class KeyId; -struct KeyIdDefaultTypeInternal; -extern KeyIdDefaultTypeInternal _KeyId_default_instance_; -class LocalizedName; -struct LocalizedNameDefaultTypeInternal; -extern LocalizedNameDefaultTypeInternal _LocalizedName_default_instance_; -class Location; -struct LocationDefaultTypeInternal; -extern LocationDefaultTypeInternal _Location_default_instance_; -class MediaData; -struct MediaDataDefaultTypeInternal; -extern MediaDataDefaultTypeInternal _MediaData_default_instance_; -class MediaRetryNotification; -struct MediaRetryNotificationDefaultTypeInternal; -extern MediaRetryNotificationDefaultTypeInternal _MediaRetryNotification_default_instance_; -class Message; -struct MessageDefaultTypeInternal; -extern MessageDefaultTypeInternal _Message_default_instance_; -class MessageContextInfo; -struct MessageContextInfoDefaultTypeInternal; -extern MessageContextInfoDefaultTypeInternal _MessageContextInfo_default_instance_; -class MessageKey; -struct MessageKeyDefaultTypeInternal; -extern MessageKeyDefaultTypeInternal _MessageKey_default_instance_; -class Message_AppStateFatalExceptionNotification; -struct Message_AppStateFatalExceptionNotificationDefaultTypeInternal; -extern Message_AppStateFatalExceptionNotificationDefaultTypeInternal _Message_AppStateFatalExceptionNotification_default_instance_; -class Message_AppStateSyncKey; -struct Message_AppStateSyncKeyDefaultTypeInternal; -extern Message_AppStateSyncKeyDefaultTypeInternal _Message_AppStateSyncKey_default_instance_; -class Message_AppStateSyncKeyData; -struct Message_AppStateSyncKeyDataDefaultTypeInternal; -extern Message_AppStateSyncKeyDataDefaultTypeInternal _Message_AppStateSyncKeyData_default_instance_; -class Message_AppStateSyncKeyFingerprint; -struct Message_AppStateSyncKeyFingerprintDefaultTypeInternal; -extern Message_AppStateSyncKeyFingerprintDefaultTypeInternal _Message_AppStateSyncKeyFingerprint_default_instance_; -class Message_AppStateSyncKeyId; -struct Message_AppStateSyncKeyIdDefaultTypeInternal; -extern Message_AppStateSyncKeyIdDefaultTypeInternal _Message_AppStateSyncKeyId_default_instance_; -class Message_AppStateSyncKeyRequest; -struct Message_AppStateSyncKeyRequestDefaultTypeInternal; -extern Message_AppStateSyncKeyRequestDefaultTypeInternal _Message_AppStateSyncKeyRequest_default_instance_; -class Message_AppStateSyncKeyShare; -struct Message_AppStateSyncKeyShareDefaultTypeInternal; -extern Message_AppStateSyncKeyShareDefaultTypeInternal _Message_AppStateSyncKeyShare_default_instance_; -class Message_AudioMessage; -struct Message_AudioMessageDefaultTypeInternal; -extern Message_AudioMessageDefaultTypeInternal _Message_AudioMessage_default_instance_; -class Message_ButtonsMessage; -struct Message_ButtonsMessageDefaultTypeInternal; -extern Message_ButtonsMessageDefaultTypeInternal _Message_ButtonsMessage_default_instance_; -class Message_ButtonsMessage_Button; -struct Message_ButtonsMessage_ButtonDefaultTypeInternal; -extern Message_ButtonsMessage_ButtonDefaultTypeInternal _Message_ButtonsMessage_Button_default_instance_; -class Message_ButtonsMessage_Button_ButtonText; -struct Message_ButtonsMessage_Button_ButtonTextDefaultTypeInternal; -extern Message_ButtonsMessage_Button_ButtonTextDefaultTypeInternal _Message_ButtonsMessage_Button_ButtonText_default_instance_; -class Message_ButtonsMessage_Button_NativeFlowInfo; -struct Message_ButtonsMessage_Button_NativeFlowInfoDefaultTypeInternal; -extern Message_ButtonsMessage_Button_NativeFlowInfoDefaultTypeInternal _Message_ButtonsMessage_Button_NativeFlowInfo_default_instance_; -class Message_ButtonsResponseMessage; -struct Message_ButtonsResponseMessageDefaultTypeInternal; -extern Message_ButtonsResponseMessageDefaultTypeInternal _Message_ButtonsResponseMessage_default_instance_; -class Message_Call; -struct Message_CallDefaultTypeInternal; -extern Message_CallDefaultTypeInternal _Message_Call_default_instance_; -class Message_CancelPaymentRequestMessage; -struct Message_CancelPaymentRequestMessageDefaultTypeInternal; -extern Message_CancelPaymentRequestMessageDefaultTypeInternal _Message_CancelPaymentRequestMessage_default_instance_; -class Message_Chat; -struct Message_ChatDefaultTypeInternal; -extern Message_ChatDefaultTypeInternal _Message_Chat_default_instance_; -class Message_ContactMessage; -struct Message_ContactMessageDefaultTypeInternal; -extern Message_ContactMessageDefaultTypeInternal _Message_ContactMessage_default_instance_; -class Message_ContactsArrayMessage; -struct Message_ContactsArrayMessageDefaultTypeInternal; -extern Message_ContactsArrayMessageDefaultTypeInternal _Message_ContactsArrayMessage_default_instance_; -class Message_DeclinePaymentRequestMessage; -struct Message_DeclinePaymentRequestMessageDefaultTypeInternal; -extern Message_DeclinePaymentRequestMessageDefaultTypeInternal _Message_DeclinePaymentRequestMessage_default_instance_; -class Message_DeviceSentMessage; -struct Message_DeviceSentMessageDefaultTypeInternal; -extern Message_DeviceSentMessageDefaultTypeInternal _Message_DeviceSentMessage_default_instance_; -class Message_DocumentMessage; -struct Message_DocumentMessageDefaultTypeInternal; -extern Message_DocumentMessageDefaultTypeInternal _Message_DocumentMessage_default_instance_; -class Message_ExtendedTextMessage; -struct Message_ExtendedTextMessageDefaultTypeInternal; -extern Message_ExtendedTextMessageDefaultTypeInternal _Message_ExtendedTextMessage_default_instance_; -class Message_FutureProofMessage; -struct Message_FutureProofMessageDefaultTypeInternal; -extern Message_FutureProofMessageDefaultTypeInternal _Message_FutureProofMessage_default_instance_; -class Message_GroupInviteMessage; -struct Message_GroupInviteMessageDefaultTypeInternal; -extern Message_GroupInviteMessageDefaultTypeInternal _Message_GroupInviteMessage_default_instance_; -class Message_HighlyStructuredMessage; -struct Message_HighlyStructuredMessageDefaultTypeInternal; -extern Message_HighlyStructuredMessageDefaultTypeInternal _Message_HighlyStructuredMessage_default_instance_; -class Message_HighlyStructuredMessage_HSMLocalizableParameter; -struct Message_HighlyStructuredMessage_HSMLocalizableParameterDefaultTypeInternal; -extern Message_HighlyStructuredMessage_HSMLocalizableParameterDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_default_instance_; -class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency; -struct Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrencyDefaultTypeInternal; -extern Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrencyDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency_default_instance_; -class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime; -struct Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTimeDefaultTypeInternal; -extern Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTimeDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_default_instance_; -class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent; -struct Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponentDefaultTypeInternal; -extern Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponentDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_default_instance_; -class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch; -struct Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpochDefaultTypeInternal; -extern Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpochDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch_default_instance_; -class Message_HistorySyncNotification; -struct Message_HistorySyncNotificationDefaultTypeInternal; -extern Message_HistorySyncNotificationDefaultTypeInternal _Message_HistorySyncNotification_default_instance_; -class Message_ImageMessage; -struct Message_ImageMessageDefaultTypeInternal; -extern Message_ImageMessageDefaultTypeInternal _Message_ImageMessage_default_instance_; -class Message_InitialSecurityNotificationSettingSync; -struct Message_InitialSecurityNotificationSettingSyncDefaultTypeInternal; -extern Message_InitialSecurityNotificationSettingSyncDefaultTypeInternal _Message_InitialSecurityNotificationSettingSync_default_instance_; -class Message_InteractiveMessage; -struct Message_InteractiveMessageDefaultTypeInternal; -extern Message_InteractiveMessageDefaultTypeInternal _Message_InteractiveMessage_default_instance_; -class Message_InteractiveMessage_Body; -struct Message_InteractiveMessage_BodyDefaultTypeInternal; -extern Message_InteractiveMessage_BodyDefaultTypeInternal _Message_InteractiveMessage_Body_default_instance_; -class Message_InteractiveMessage_CollectionMessage; -struct Message_InteractiveMessage_CollectionMessageDefaultTypeInternal; -extern Message_InteractiveMessage_CollectionMessageDefaultTypeInternal _Message_InteractiveMessage_CollectionMessage_default_instance_; -class Message_InteractiveMessage_Footer; -struct Message_InteractiveMessage_FooterDefaultTypeInternal; -extern Message_InteractiveMessage_FooterDefaultTypeInternal _Message_InteractiveMessage_Footer_default_instance_; -class Message_InteractiveMessage_Header; -struct Message_InteractiveMessage_HeaderDefaultTypeInternal; -extern Message_InteractiveMessage_HeaderDefaultTypeInternal _Message_InteractiveMessage_Header_default_instance_; -class Message_InteractiveMessage_NativeFlowMessage; -struct Message_InteractiveMessage_NativeFlowMessageDefaultTypeInternal; -extern Message_InteractiveMessage_NativeFlowMessageDefaultTypeInternal _Message_InteractiveMessage_NativeFlowMessage_default_instance_; -class Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton; -struct Message_InteractiveMessage_NativeFlowMessage_NativeFlowButtonDefaultTypeInternal; -extern Message_InteractiveMessage_NativeFlowMessage_NativeFlowButtonDefaultTypeInternal _Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton_default_instance_; -class Message_InteractiveMessage_ShopMessage; -struct Message_InteractiveMessage_ShopMessageDefaultTypeInternal; -extern Message_InteractiveMessage_ShopMessageDefaultTypeInternal _Message_InteractiveMessage_ShopMessage_default_instance_; -class Message_InteractiveResponseMessage; -struct Message_InteractiveResponseMessageDefaultTypeInternal; -extern Message_InteractiveResponseMessageDefaultTypeInternal _Message_InteractiveResponseMessage_default_instance_; -class Message_InteractiveResponseMessage_Body; -struct Message_InteractiveResponseMessage_BodyDefaultTypeInternal; -extern Message_InteractiveResponseMessage_BodyDefaultTypeInternal _Message_InteractiveResponseMessage_Body_default_instance_; -class Message_InteractiveResponseMessage_NativeFlowResponseMessage; -struct Message_InteractiveResponseMessage_NativeFlowResponseMessageDefaultTypeInternal; -extern Message_InteractiveResponseMessage_NativeFlowResponseMessageDefaultTypeInternal _Message_InteractiveResponseMessage_NativeFlowResponseMessage_default_instance_; -class Message_InvoiceMessage; -struct Message_InvoiceMessageDefaultTypeInternal; -extern Message_InvoiceMessageDefaultTypeInternal _Message_InvoiceMessage_default_instance_; -class Message_KeepInChatMessage; -struct Message_KeepInChatMessageDefaultTypeInternal; -extern Message_KeepInChatMessageDefaultTypeInternal _Message_KeepInChatMessage_default_instance_; -class Message_ListMessage; -struct Message_ListMessageDefaultTypeInternal; -extern Message_ListMessageDefaultTypeInternal _Message_ListMessage_default_instance_; -class Message_ListMessage_Product; -struct Message_ListMessage_ProductDefaultTypeInternal; -extern Message_ListMessage_ProductDefaultTypeInternal _Message_ListMessage_Product_default_instance_; -class Message_ListMessage_ProductListHeaderImage; -struct Message_ListMessage_ProductListHeaderImageDefaultTypeInternal; -extern Message_ListMessage_ProductListHeaderImageDefaultTypeInternal _Message_ListMessage_ProductListHeaderImage_default_instance_; -class Message_ListMessage_ProductListInfo; -struct Message_ListMessage_ProductListInfoDefaultTypeInternal; -extern Message_ListMessage_ProductListInfoDefaultTypeInternal _Message_ListMessage_ProductListInfo_default_instance_; -class Message_ListMessage_ProductSection; -struct Message_ListMessage_ProductSectionDefaultTypeInternal; -extern Message_ListMessage_ProductSectionDefaultTypeInternal _Message_ListMessage_ProductSection_default_instance_; -class Message_ListMessage_Row; -struct Message_ListMessage_RowDefaultTypeInternal; -extern Message_ListMessage_RowDefaultTypeInternal _Message_ListMessage_Row_default_instance_; -class Message_ListMessage_Section; -struct Message_ListMessage_SectionDefaultTypeInternal; -extern Message_ListMessage_SectionDefaultTypeInternal _Message_ListMessage_Section_default_instance_; -class Message_ListResponseMessage; -struct Message_ListResponseMessageDefaultTypeInternal; -extern Message_ListResponseMessageDefaultTypeInternal _Message_ListResponseMessage_default_instance_; -class Message_ListResponseMessage_SingleSelectReply; -struct Message_ListResponseMessage_SingleSelectReplyDefaultTypeInternal; -extern Message_ListResponseMessage_SingleSelectReplyDefaultTypeInternal _Message_ListResponseMessage_SingleSelectReply_default_instance_; -class Message_LiveLocationMessage; -struct Message_LiveLocationMessageDefaultTypeInternal; -extern Message_LiveLocationMessageDefaultTypeInternal _Message_LiveLocationMessage_default_instance_; -class Message_LocationMessage; -struct Message_LocationMessageDefaultTypeInternal; -extern Message_LocationMessageDefaultTypeInternal _Message_LocationMessage_default_instance_; -class Message_OrderMessage; -struct Message_OrderMessageDefaultTypeInternal; -extern Message_OrderMessageDefaultTypeInternal _Message_OrderMessage_default_instance_; -class Message_PaymentInviteMessage; -struct Message_PaymentInviteMessageDefaultTypeInternal; -extern Message_PaymentInviteMessageDefaultTypeInternal _Message_PaymentInviteMessage_default_instance_; -class Message_PollCreationMessage; -struct Message_PollCreationMessageDefaultTypeInternal; -extern Message_PollCreationMessageDefaultTypeInternal _Message_PollCreationMessage_default_instance_; -class Message_PollCreationMessage_Option; -struct Message_PollCreationMessage_OptionDefaultTypeInternal; -extern Message_PollCreationMessage_OptionDefaultTypeInternal _Message_PollCreationMessage_Option_default_instance_; -class Message_PollEncValue; -struct Message_PollEncValueDefaultTypeInternal; -extern Message_PollEncValueDefaultTypeInternal _Message_PollEncValue_default_instance_; -class Message_PollUpdateMessage; -struct Message_PollUpdateMessageDefaultTypeInternal; -extern Message_PollUpdateMessageDefaultTypeInternal _Message_PollUpdateMessage_default_instance_; -class Message_PollUpdateMessageMetadata; -struct Message_PollUpdateMessageMetadataDefaultTypeInternal; -extern Message_PollUpdateMessageMetadataDefaultTypeInternal _Message_PollUpdateMessageMetadata_default_instance_; -class Message_PollVoteMessage; -struct Message_PollVoteMessageDefaultTypeInternal; -extern Message_PollVoteMessageDefaultTypeInternal _Message_PollVoteMessage_default_instance_; -class Message_ProductMessage; -struct Message_ProductMessageDefaultTypeInternal; -extern Message_ProductMessageDefaultTypeInternal _Message_ProductMessage_default_instance_; -class Message_ProductMessage_CatalogSnapshot; -struct Message_ProductMessage_CatalogSnapshotDefaultTypeInternal; -extern Message_ProductMessage_CatalogSnapshotDefaultTypeInternal _Message_ProductMessage_CatalogSnapshot_default_instance_; -class Message_ProductMessage_ProductSnapshot; -struct Message_ProductMessage_ProductSnapshotDefaultTypeInternal; -extern Message_ProductMessage_ProductSnapshotDefaultTypeInternal _Message_ProductMessage_ProductSnapshot_default_instance_; -class Message_ProtocolMessage; -struct Message_ProtocolMessageDefaultTypeInternal; -extern Message_ProtocolMessageDefaultTypeInternal _Message_ProtocolMessage_default_instance_; -class Message_ReactionMessage; -struct Message_ReactionMessageDefaultTypeInternal; -extern Message_ReactionMessageDefaultTypeInternal _Message_ReactionMessage_default_instance_; -class Message_RequestMediaUploadMessage; -struct Message_RequestMediaUploadMessageDefaultTypeInternal; -extern Message_RequestMediaUploadMessageDefaultTypeInternal _Message_RequestMediaUploadMessage_default_instance_; -class Message_RequestMediaUploadResponseMessage; -struct Message_RequestMediaUploadResponseMessageDefaultTypeInternal; -extern Message_RequestMediaUploadResponseMessageDefaultTypeInternal _Message_RequestMediaUploadResponseMessage_default_instance_; -class Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult; -struct Message_RequestMediaUploadResponseMessage_RequestMediaUploadResultDefaultTypeInternal; -extern Message_RequestMediaUploadResponseMessage_RequestMediaUploadResultDefaultTypeInternal _Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult_default_instance_; -class Message_RequestPaymentMessage; -struct Message_RequestPaymentMessageDefaultTypeInternal; -extern Message_RequestPaymentMessageDefaultTypeInternal _Message_RequestPaymentMessage_default_instance_; -class Message_RequestPhoneNumberMessage; -struct Message_RequestPhoneNumberMessageDefaultTypeInternal; -extern Message_RequestPhoneNumberMessageDefaultTypeInternal _Message_RequestPhoneNumberMessage_default_instance_; -class Message_SendPaymentMessage; -struct Message_SendPaymentMessageDefaultTypeInternal; -extern Message_SendPaymentMessageDefaultTypeInternal _Message_SendPaymentMessage_default_instance_; -class Message_SenderKeyDistributionMessage; -struct Message_SenderKeyDistributionMessageDefaultTypeInternal; -extern Message_SenderKeyDistributionMessageDefaultTypeInternal _Message_SenderKeyDistributionMessage_default_instance_; -class Message_StickerMessage; -struct Message_StickerMessageDefaultTypeInternal; -extern Message_StickerMessageDefaultTypeInternal _Message_StickerMessage_default_instance_; -class Message_StickerSyncRMRMessage; -struct Message_StickerSyncRMRMessageDefaultTypeInternal; -extern Message_StickerSyncRMRMessageDefaultTypeInternal _Message_StickerSyncRMRMessage_default_instance_; -class Message_TemplateButtonReplyMessage; -struct Message_TemplateButtonReplyMessageDefaultTypeInternal; -extern Message_TemplateButtonReplyMessageDefaultTypeInternal _Message_TemplateButtonReplyMessage_default_instance_; -class Message_TemplateMessage; -struct Message_TemplateMessageDefaultTypeInternal; -extern Message_TemplateMessageDefaultTypeInternal _Message_TemplateMessage_default_instance_; -class Message_TemplateMessage_FourRowTemplate; -struct Message_TemplateMessage_FourRowTemplateDefaultTypeInternal; -extern Message_TemplateMessage_FourRowTemplateDefaultTypeInternal _Message_TemplateMessage_FourRowTemplate_default_instance_; -class Message_TemplateMessage_HydratedFourRowTemplate; -struct Message_TemplateMessage_HydratedFourRowTemplateDefaultTypeInternal; -extern Message_TemplateMessage_HydratedFourRowTemplateDefaultTypeInternal _Message_TemplateMessage_HydratedFourRowTemplate_default_instance_; -class Message_VideoMessage; -struct Message_VideoMessageDefaultTypeInternal; -extern Message_VideoMessageDefaultTypeInternal _Message_VideoMessage_default_instance_; -class Money; -struct MoneyDefaultTypeInternal; -extern MoneyDefaultTypeInternal _Money_default_instance_; -class MsgOpaqueData; -struct MsgOpaqueDataDefaultTypeInternal; -extern MsgOpaqueDataDefaultTypeInternal _MsgOpaqueData_default_instance_; -class MsgOpaqueData_PollOption; -struct MsgOpaqueData_PollOptionDefaultTypeInternal; -extern MsgOpaqueData_PollOptionDefaultTypeInternal _MsgOpaqueData_PollOption_default_instance_; -class MsgRowOpaqueData; -struct MsgRowOpaqueDataDefaultTypeInternal; -extern MsgRowOpaqueDataDefaultTypeInternal _MsgRowOpaqueData_default_instance_; -class NoiseCertificate; -struct NoiseCertificateDefaultTypeInternal; -extern NoiseCertificateDefaultTypeInternal _NoiseCertificate_default_instance_; -class NoiseCertificate_Details; -struct NoiseCertificate_DetailsDefaultTypeInternal; -extern NoiseCertificate_DetailsDefaultTypeInternal _NoiseCertificate_Details_default_instance_; -class NotificationMessageInfo; -struct NotificationMessageInfoDefaultTypeInternal; -extern NotificationMessageInfoDefaultTypeInternal _NotificationMessageInfo_default_instance_; -class PastParticipant; -struct PastParticipantDefaultTypeInternal; -extern PastParticipantDefaultTypeInternal _PastParticipant_default_instance_; -class PastParticipants; -struct PastParticipantsDefaultTypeInternal; -extern PastParticipantsDefaultTypeInternal _PastParticipants_default_instance_; -class PaymentBackground; -struct PaymentBackgroundDefaultTypeInternal; -extern PaymentBackgroundDefaultTypeInternal _PaymentBackground_default_instance_; -class PaymentBackground_MediaData; -struct PaymentBackground_MediaDataDefaultTypeInternal; -extern PaymentBackground_MediaDataDefaultTypeInternal _PaymentBackground_MediaData_default_instance_; -class PaymentInfo; -struct PaymentInfoDefaultTypeInternal; -extern PaymentInfoDefaultTypeInternal _PaymentInfo_default_instance_; -class PendingKeyExchange; -struct PendingKeyExchangeDefaultTypeInternal; -extern PendingKeyExchangeDefaultTypeInternal _PendingKeyExchange_default_instance_; -class PendingPreKey; -struct PendingPreKeyDefaultTypeInternal; -extern PendingPreKeyDefaultTypeInternal _PendingPreKey_default_instance_; -class PhotoChange; -struct PhotoChangeDefaultTypeInternal; -extern PhotoChangeDefaultTypeInternal _PhotoChange_default_instance_; -class Point; -struct PointDefaultTypeInternal; -extern PointDefaultTypeInternal _Point_default_instance_; -class PollAdditionalMetadata; -struct PollAdditionalMetadataDefaultTypeInternal; -extern PollAdditionalMetadataDefaultTypeInternal _PollAdditionalMetadata_default_instance_; -class PollEncValue; -struct PollEncValueDefaultTypeInternal; -extern PollEncValueDefaultTypeInternal _PollEncValue_default_instance_; -class PollUpdate; -struct PollUpdateDefaultTypeInternal; -extern PollUpdateDefaultTypeInternal _PollUpdate_default_instance_; -class PreKeyRecordStructure; -struct PreKeyRecordStructureDefaultTypeInternal; -extern PreKeyRecordStructureDefaultTypeInternal _PreKeyRecordStructure_default_instance_; -class Pushname; -struct PushnameDefaultTypeInternal; -extern PushnameDefaultTypeInternal _Pushname_default_instance_; -class Reaction; -struct ReactionDefaultTypeInternal; -extern ReactionDefaultTypeInternal _Reaction_default_instance_; -class RecentEmojiWeight; -struct RecentEmojiWeightDefaultTypeInternal; -extern RecentEmojiWeightDefaultTypeInternal _RecentEmojiWeight_default_instance_; -class RecordStructure; -struct RecordStructureDefaultTypeInternal; -extern RecordStructureDefaultTypeInternal _RecordStructure_default_instance_; -class SenderChainKey; -struct SenderChainKeyDefaultTypeInternal; -extern SenderChainKeyDefaultTypeInternal _SenderChainKey_default_instance_; -class SenderKeyRecordStructure; -struct SenderKeyRecordStructureDefaultTypeInternal; -extern SenderKeyRecordStructureDefaultTypeInternal _SenderKeyRecordStructure_default_instance_; -class SenderKeyStateStructure; -struct SenderKeyStateStructureDefaultTypeInternal; -extern SenderKeyStateStructureDefaultTypeInternal _SenderKeyStateStructure_default_instance_; -class SenderMessageKey; -struct SenderMessageKeyDefaultTypeInternal; -extern SenderMessageKeyDefaultTypeInternal _SenderMessageKey_default_instance_; -class SenderSigningKey; -struct SenderSigningKeyDefaultTypeInternal; -extern SenderSigningKeyDefaultTypeInternal _SenderSigningKey_default_instance_; -class ServerErrorReceipt; -struct ServerErrorReceiptDefaultTypeInternal; -extern ServerErrorReceiptDefaultTypeInternal _ServerErrorReceipt_default_instance_; -class SessionStructure; -struct SessionStructureDefaultTypeInternal; -extern SessionStructureDefaultTypeInternal _SessionStructure_default_instance_; -class SignedPreKeyRecordStructure; -struct SignedPreKeyRecordStructureDefaultTypeInternal; -extern SignedPreKeyRecordStructureDefaultTypeInternal _SignedPreKeyRecordStructure_default_instance_; -class StatusPSA; -struct StatusPSADefaultTypeInternal; -extern StatusPSADefaultTypeInternal _StatusPSA_default_instance_; -class StickerMetadata; -struct StickerMetadataDefaultTypeInternal; -extern StickerMetadataDefaultTypeInternal _StickerMetadata_default_instance_; -class SyncActionData; -struct SyncActionDataDefaultTypeInternal; -extern SyncActionDataDefaultTypeInternal _SyncActionData_default_instance_; -class SyncActionValue; -struct SyncActionValueDefaultTypeInternal; -extern SyncActionValueDefaultTypeInternal _SyncActionValue_default_instance_; -class SyncActionValue_AgentAction; -struct SyncActionValue_AgentActionDefaultTypeInternal; -extern SyncActionValue_AgentActionDefaultTypeInternal _SyncActionValue_AgentAction_default_instance_; -class SyncActionValue_AndroidUnsupportedActions; -struct SyncActionValue_AndroidUnsupportedActionsDefaultTypeInternal; -extern SyncActionValue_AndroidUnsupportedActionsDefaultTypeInternal _SyncActionValue_AndroidUnsupportedActions_default_instance_; -class SyncActionValue_ArchiveChatAction; -struct SyncActionValue_ArchiveChatActionDefaultTypeInternal; -extern SyncActionValue_ArchiveChatActionDefaultTypeInternal _SyncActionValue_ArchiveChatAction_default_instance_; -class SyncActionValue_ClearChatAction; -struct SyncActionValue_ClearChatActionDefaultTypeInternal; -extern SyncActionValue_ClearChatActionDefaultTypeInternal _SyncActionValue_ClearChatAction_default_instance_; -class SyncActionValue_ContactAction; -struct SyncActionValue_ContactActionDefaultTypeInternal; -extern SyncActionValue_ContactActionDefaultTypeInternal _SyncActionValue_ContactAction_default_instance_; -class SyncActionValue_DeleteChatAction; -struct SyncActionValue_DeleteChatActionDefaultTypeInternal; -extern SyncActionValue_DeleteChatActionDefaultTypeInternal _SyncActionValue_DeleteChatAction_default_instance_; -class SyncActionValue_DeleteMessageForMeAction; -struct SyncActionValue_DeleteMessageForMeActionDefaultTypeInternal; -extern SyncActionValue_DeleteMessageForMeActionDefaultTypeInternal _SyncActionValue_DeleteMessageForMeAction_default_instance_; -class SyncActionValue_KeyExpiration; -struct SyncActionValue_KeyExpirationDefaultTypeInternal; -extern SyncActionValue_KeyExpirationDefaultTypeInternal _SyncActionValue_KeyExpiration_default_instance_; -class SyncActionValue_LabelAssociationAction; -struct SyncActionValue_LabelAssociationActionDefaultTypeInternal; -extern SyncActionValue_LabelAssociationActionDefaultTypeInternal _SyncActionValue_LabelAssociationAction_default_instance_; -class SyncActionValue_LabelEditAction; -struct SyncActionValue_LabelEditActionDefaultTypeInternal; -extern SyncActionValue_LabelEditActionDefaultTypeInternal _SyncActionValue_LabelEditAction_default_instance_; -class SyncActionValue_LocaleSetting; -struct SyncActionValue_LocaleSettingDefaultTypeInternal; -extern SyncActionValue_LocaleSettingDefaultTypeInternal _SyncActionValue_LocaleSetting_default_instance_; -class SyncActionValue_MarkChatAsReadAction; -struct SyncActionValue_MarkChatAsReadActionDefaultTypeInternal; -extern SyncActionValue_MarkChatAsReadActionDefaultTypeInternal _SyncActionValue_MarkChatAsReadAction_default_instance_; -class SyncActionValue_MuteAction; -struct SyncActionValue_MuteActionDefaultTypeInternal; -extern SyncActionValue_MuteActionDefaultTypeInternal _SyncActionValue_MuteAction_default_instance_; -class SyncActionValue_NuxAction; -struct SyncActionValue_NuxActionDefaultTypeInternal; -extern SyncActionValue_NuxActionDefaultTypeInternal _SyncActionValue_NuxAction_default_instance_; -class SyncActionValue_PinAction; -struct SyncActionValue_PinActionDefaultTypeInternal; -extern SyncActionValue_PinActionDefaultTypeInternal _SyncActionValue_PinAction_default_instance_; -class SyncActionValue_PrimaryFeature; -struct SyncActionValue_PrimaryFeatureDefaultTypeInternal; -extern SyncActionValue_PrimaryFeatureDefaultTypeInternal _SyncActionValue_PrimaryFeature_default_instance_; -class SyncActionValue_PrimaryVersionAction; -struct SyncActionValue_PrimaryVersionActionDefaultTypeInternal; -extern SyncActionValue_PrimaryVersionActionDefaultTypeInternal _SyncActionValue_PrimaryVersionAction_default_instance_; -class SyncActionValue_PushNameSetting; -struct SyncActionValue_PushNameSettingDefaultTypeInternal; -extern SyncActionValue_PushNameSettingDefaultTypeInternal _SyncActionValue_PushNameSetting_default_instance_; -class SyncActionValue_QuickReplyAction; -struct SyncActionValue_QuickReplyActionDefaultTypeInternal; -extern SyncActionValue_QuickReplyActionDefaultTypeInternal _SyncActionValue_QuickReplyAction_default_instance_; -class SyncActionValue_RecentEmojiWeightsAction; -struct SyncActionValue_RecentEmojiWeightsActionDefaultTypeInternal; -extern SyncActionValue_RecentEmojiWeightsActionDefaultTypeInternal _SyncActionValue_RecentEmojiWeightsAction_default_instance_; -class SyncActionValue_SecurityNotificationSetting; -struct SyncActionValue_SecurityNotificationSettingDefaultTypeInternal; -extern SyncActionValue_SecurityNotificationSettingDefaultTypeInternal _SyncActionValue_SecurityNotificationSetting_default_instance_; -class SyncActionValue_StarAction; -struct SyncActionValue_StarActionDefaultTypeInternal; -extern SyncActionValue_StarActionDefaultTypeInternal _SyncActionValue_StarAction_default_instance_; -class SyncActionValue_StickerAction; -struct SyncActionValue_StickerActionDefaultTypeInternal; -extern SyncActionValue_StickerActionDefaultTypeInternal _SyncActionValue_StickerAction_default_instance_; -class SyncActionValue_SubscriptionAction; -struct SyncActionValue_SubscriptionActionDefaultTypeInternal; -extern SyncActionValue_SubscriptionActionDefaultTypeInternal _SyncActionValue_SubscriptionAction_default_instance_; -class SyncActionValue_SyncActionMessage; -struct SyncActionValue_SyncActionMessageDefaultTypeInternal; -extern SyncActionValue_SyncActionMessageDefaultTypeInternal _SyncActionValue_SyncActionMessage_default_instance_; -class SyncActionValue_SyncActionMessageRange; -struct SyncActionValue_SyncActionMessageRangeDefaultTypeInternal; -extern SyncActionValue_SyncActionMessageRangeDefaultTypeInternal _SyncActionValue_SyncActionMessageRange_default_instance_; -class SyncActionValue_TimeFormatAction; -struct SyncActionValue_TimeFormatActionDefaultTypeInternal; -extern SyncActionValue_TimeFormatActionDefaultTypeInternal _SyncActionValue_TimeFormatAction_default_instance_; -class SyncActionValue_UnarchiveChatsSetting; -struct SyncActionValue_UnarchiveChatsSettingDefaultTypeInternal; -extern SyncActionValue_UnarchiveChatsSettingDefaultTypeInternal _SyncActionValue_UnarchiveChatsSetting_default_instance_; -class SyncActionValue_UserStatusMuteAction; -struct SyncActionValue_UserStatusMuteActionDefaultTypeInternal; -extern SyncActionValue_UserStatusMuteActionDefaultTypeInternal _SyncActionValue_UserStatusMuteAction_default_instance_; -class SyncdIndex; -struct SyncdIndexDefaultTypeInternal; -extern SyncdIndexDefaultTypeInternal _SyncdIndex_default_instance_; -class SyncdMutation; -struct SyncdMutationDefaultTypeInternal; -extern SyncdMutationDefaultTypeInternal _SyncdMutation_default_instance_; -class SyncdMutations; -struct SyncdMutationsDefaultTypeInternal; -extern SyncdMutationsDefaultTypeInternal _SyncdMutations_default_instance_; -class SyncdPatch; -struct SyncdPatchDefaultTypeInternal; -extern SyncdPatchDefaultTypeInternal _SyncdPatch_default_instance_; -class SyncdRecord; -struct SyncdRecordDefaultTypeInternal; -extern SyncdRecordDefaultTypeInternal _SyncdRecord_default_instance_; -class SyncdSnapshot; -struct SyncdSnapshotDefaultTypeInternal; -extern SyncdSnapshotDefaultTypeInternal _SyncdSnapshot_default_instance_; -class SyncdValue; -struct SyncdValueDefaultTypeInternal; -extern SyncdValueDefaultTypeInternal _SyncdValue_default_instance_; -class SyncdVersion; -struct SyncdVersionDefaultTypeInternal; -extern SyncdVersionDefaultTypeInternal _SyncdVersion_default_instance_; -class TemplateButton; -struct TemplateButtonDefaultTypeInternal; -extern TemplateButtonDefaultTypeInternal _TemplateButton_default_instance_; -class TemplateButton_CallButton; -struct TemplateButton_CallButtonDefaultTypeInternal; -extern TemplateButton_CallButtonDefaultTypeInternal _TemplateButton_CallButton_default_instance_; -class TemplateButton_QuickReplyButton; -struct TemplateButton_QuickReplyButtonDefaultTypeInternal; -extern TemplateButton_QuickReplyButtonDefaultTypeInternal _TemplateButton_QuickReplyButton_default_instance_; -class TemplateButton_URLButton; -struct TemplateButton_URLButtonDefaultTypeInternal; -extern TemplateButton_URLButtonDefaultTypeInternal _TemplateButton_URLButton_default_instance_; -class UserReceipt; -struct UserReceiptDefaultTypeInternal; -extern UserReceiptDefaultTypeInternal _UserReceipt_default_instance_; -class VerifiedNameCertificate; -struct VerifiedNameCertificateDefaultTypeInternal; -extern VerifiedNameCertificateDefaultTypeInternal _VerifiedNameCertificate_default_instance_; -class VerifiedNameCertificate_Details; -struct VerifiedNameCertificate_DetailsDefaultTypeInternal; -extern VerifiedNameCertificate_DetailsDefaultTypeInternal _VerifiedNameCertificate_Details_default_instance_; -class WallpaperSettings; -struct WallpaperSettingsDefaultTypeInternal; -extern WallpaperSettingsDefaultTypeInternal _WallpaperSettings_default_instance_; -class WebFeatures; -struct WebFeaturesDefaultTypeInternal; -extern WebFeaturesDefaultTypeInternal _WebFeatures_default_instance_; -class WebMessageInfo; -struct WebMessageInfoDefaultTypeInternal; -extern WebMessageInfoDefaultTypeInternal _WebMessageInfo_default_instance_; -class WebNotificationsInfo; -struct WebNotificationsInfoDefaultTypeInternal; -extern WebNotificationsInfoDefaultTypeInternal _WebNotificationsInfo_default_instance_; -} // namespace proto -PROTOBUF_NAMESPACE_OPEN -template<> ::proto::ADVDeviceIdentity* Arena::CreateMaybeMessage<::proto::ADVDeviceIdentity>(Arena*); -template<> ::proto::ADVKeyIndexList* Arena::CreateMaybeMessage<::proto::ADVKeyIndexList>(Arena*); -template<> ::proto::ADVSignedDeviceIdentity* Arena::CreateMaybeMessage<::proto::ADVSignedDeviceIdentity>(Arena*); -template<> ::proto::ADVSignedDeviceIdentityHMAC* Arena::CreateMaybeMessage<::proto::ADVSignedDeviceIdentityHMAC>(Arena*); -template<> ::proto::ADVSignedKeyIndexList* Arena::CreateMaybeMessage<::proto::ADVSignedKeyIndexList>(Arena*); -template<> ::proto::ActionLink* Arena::CreateMaybeMessage<::proto::ActionLink>(Arena*); -template<> ::proto::AutoDownloadSettings* Arena::CreateMaybeMessage<::proto::AutoDownloadSettings>(Arena*); -template<> ::proto::BizAccountLinkInfo* Arena::CreateMaybeMessage<::proto::BizAccountLinkInfo>(Arena*); -template<> ::proto::BizAccountPayload* Arena::CreateMaybeMessage<::proto::BizAccountPayload>(Arena*); -template<> ::proto::BizIdentityInfo* Arena::CreateMaybeMessage<::proto::BizIdentityInfo>(Arena*); -template<> ::proto::CertChain* Arena::CreateMaybeMessage<::proto::CertChain>(Arena*); -template<> ::proto::CertChain_NoiseCertificate* Arena::CreateMaybeMessage<::proto::CertChain_NoiseCertificate>(Arena*); -template<> ::proto::CertChain_NoiseCertificate_Details* Arena::CreateMaybeMessage<::proto::CertChain_NoiseCertificate_Details>(Arena*); -template<> ::proto::Chain* Arena::CreateMaybeMessage<::proto::Chain>(Arena*); -template<> ::proto::ChainKey* Arena::CreateMaybeMessage<::proto::ChainKey>(Arena*); -template<> ::proto::ClientPayload* Arena::CreateMaybeMessage<::proto::ClientPayload>(Arena*); -template<> ::proto::ClientPayload_DNSSource* Arena::CreateMaybeMessage<::proto::ClientPayload_DNSSource>(Arena*); -template<> ::proto::ClientPayload_DevicePairingRegistrationData* Arena::CreateMaybeMessage<::proto::ClientPayload_DevicePairingRegistrationData>(Arena*); -template<> ::proto::ClientPayload_UserAgent* Arena::CreateMaybeMessage<::proto::ClientPayload_UserAgent>(Arena*); -template<> ::proto::ClientPayload_UserAgent_AppVersion* Arena::CreateMaybeMessage<::proto::ClientPayload_UserAgent_AppVersion>(Arena*); -template<> ::proto::ClientPayload_WebInfo* Arena::CreateMaybeMessage<::proto::ClientPayload_WebInfo>(Arena*); -template<> ::proto::ClientPayload_WebInfo_WebdPayload* Arena::CreateMaybeMessage<::proto::ClientPayload_WebInfo_WebdPayload>(Arena*); -template<> ::proto::ContextInfo* Arena::CreateMaybeMessage<::proto::ContextInfo>(Arena*); -template<> ::proto::ContextInfo_AdReplyInfo* Arena::CreateMaybeMessage<::proto::ContextInfo_AdReplyInfo>(Arena*); -template<> ::proto::ContextInfo_ExternalAdReplyInfo* Arena::CreateMaybeMessage<::proto::ContextInfo_ExternalAdReplyInfo>(Arena*); -template<> ::proto::Conversation* Arena::CreateMaybeMessage<::proto::Conversation>(Arena*); -template<> ::proto::DeviceListMetadata* Arena::CreateMaybeMessage<::proto::DeviceListMetadata>(Arena*); -template<> ::proto::DeviceProps* Arena::CreateMaybeMessage<::proto::DeviceProps>(Arena*); -template<> ::proto::DeviceProps_AppVersion* Arena::CreateMaybeMessage<::proto::DeviceProps_AppVersion>(Arena*); -template<> ::proto::DisappearingMode* Arena::CreateMaybeMessage<::proto::DisappearingMode>(Arena*); -template<> ::proto::EphemeralSetting* Arena::CreateMaybeMessage<::proto::EphemeralSetting>(Arena*); -template<> ::proto::ExitCode* Arena::CreateMaybeMessage<::proto::ExitCode>(Arena*); -template<> ::proto::ExternalBlobReference* Arena::CreateMaybeMessage<::proto::ExternalBlobReference>(Arena*); -template<> ::proto::GlobalSettings* Arena::CreateMaybeMessage<::proto::GlobalSettings>(Arena*); -template<> ::proto::GroupParticipant* Arena::CreateMaybeMessage<::proto::GroupParticipant>(Arena*); -template<> ::proto::HandshakeMessage* Arena::CreateMaybeMessage<::proto::HandshakeMessage>(Arena*); -template<> ::proto::HandshakeMessage_ClientFinish* Arena::CreateMaybeMessage<::proto::HandshakeMessage_ClientFinish>(Arena*); -template<> ::proto::HandshakeMessage_ClientHello* Arena::CreateMaybeMessage<::proto::HandshakeMessage_ClientHello>(Arena*); -template<> ::proto::HandshakeMessage_ServerHello* Arena::CreateMaybeMessage<::proto::HandshakeMessage_ServerHello>(Arena*); -template<> ::proto::HistorySync* Arena::CreateMaybeMessage<::proto::HistorySync>(Arena*); -template<> ::proto::HistorySyncMsg* Arena::CreateMaybeMessage<::proto::HistorySyncMsg>(Arena*); -template<> ::proto::HydratedTemplateButton* Arena::CreateMaybeMessage<::proto::HydratedTemplateButton>(Arena*); -template<> ::proto::HydratedTemplateButton_HydratedCallButton* Arena::CreateMaybeMessage<::proto::HydratedTemplateButton_HydratedCallButton>(Arena*); -template<> ::proto::HydratedTemplateButton_HydratedQuickReplyButton* Arena::CreateMaybeMessage<::proto::HydratedTemplateButton_HydratedQuickReplyButton>(Arena*); -template<> ::proto::HydratedTemplateButton_HydratedURLButton* Arena::CreateMaybeMessage<::proto::HydratedTemplateButton_HydratedURLButton>(Arena*); -template<> ::proto::IdentityKeyPairStructure* Arena::CreateMaybeMessage<::proto::IdentityKeyPairStructure>(Arena*); -template<> ::proto::InteractiveAnnotation* Arena::CreateMaybeMessage<::proto::InteractiveAnnotation>(Arena*); -template<> ::proto::KeepInChat* Arena::CreateMaybeMessage<::proto::KeepInChat>(Arena*); -template<> ::proto::KeyId* Arena::CreateMaybeMessage<::proto::KeyId>(Arena*); -template<> ::proto::LocalizedName* Arena::CreateMaybeMessage<::proto::LocalizedName>(Arena*); -template<> ::proto::Location* Arena::CreateMaybeMessage<::proto::Location>(Arena*); -template<> ::proto::MediaData* Arena::CreateMaybeMessage<::proto::MediaData>(Arena*); -template<> ::proto::MediaRetryNotification* Arena::CreateMaybeMessage<::proto::MediaRetryNotification>(Arena*); -template<> ::proto::Message* Arena::CreateMaybeMessage<::proto::Message>(Arena*); -template<> ::proto::MessageContextInfo* Arena::CreateMaybeMessage<::proto::MessageContextInfo>(Arena*); -template<> ::proto::MessageKey* Arena::CreateMaybeMessage<::proto::MessageKey>(Arena*); -template<> ::proto::Message_AppStateFatalExceptionNotification* Arena::CreateMaybeMessage<::proto::Message_AppStateFatalExceptionNotification>(Arena*); -template<> ::proto::Message_AppStateSyncKey* Arena::CreateMaybeMessage<::proto::Message_AppStateSyncKey>(Arena*); -template<> ::proto::Message_AppStateSyncKeyData* Arena::CreateMaybeMessage<::proto::Message_AppStateSyncKeyData>(Arena*); -template<> ::proto::Message_AppStateSyncKeyFingerprint* Arena::CreateMaybeMessage<::proto::Message_AppStateSyncKeyFingerprint>(Arena*); -template<> ::proto::Message_AppStateSyncKeyId* Arena::CreateMaybeMessage<::proto::Message_AppStateSyncKeyId>(Arena*); -template<> ::proto::Message_AppStateSyncKeyRequest* Arena::CreateMaybeMessage<::proto::Message_AppStateSyncKeyRequest>(Arena*); -template<> ::proto::Message_AppStateSyncKeyShare* Arena::CreateMaybeMessage<::proto::Message_AppStateSyncKeyShare>(Arena*); -template<> ::proto::Message_AudioMessage* Arena::CreateMaybeMessage<::proto::Message_AudioMessage>(Arena*); -template<> ::proto::Message_ButtonsMessage* Arena::CreateMaybeMessage<::proto::Message_ButtonsMessage>(Arena*); -template<> ::proto::Message_ButtonsMessage_Button* Arena::CreateMaybeMessage<::proto::Message_ButtonsMessage_Button>(Arena*); -template<> ::proto::Message_ButtonsMessage_Button_ButtonText* Arena::CreateMaybeMessage<::proto::Message_ButtonsMessage_Button_ButtonText>(Arena*); -template<> ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* Arena::CreateMaybeMessage<::proto::Message_ButtonsMessage_Button_NativeFlowInfo>(Arena*); -template<> ::proto::Message_ButtonsResponseMessage* Arena::CreateMaybeMessage<::proto::Message_ButtonsResponseMessage>(Arena*); -template<> ::proto::Message_Call* Arena::CreateMaybeMessage<::proto::Message_Call>(Arena*); -template<> ::proto::Message_CancelPaymentRequestMessage* Arena::CreateMaybeMessage<::proto::Message_CancelPaymentRequestMessage>(Arena*); -template<> ::proto::Message_Chat* Arena::CreateMaybeMessage<::proto::Message_Chat>(Arena*); -template<> ::proto::Message_ContactMessage* Arena::CreateMaybeMessage<::proto::Message_ContactMessage>(Arena*); -template<> ::proto::Message_ContactsArrayMessage* Arena::CreateMaybeMessage<::proto::Message_ContactsArrayMessage>(Arena*); -template<> ::proto::Message_DeclinePaymentRequestMessage* Arena::CreateMaybeMessage<::proto::Message_DeclinePaymentRequestMessage>(Arena*); -template<> ::proto::Message_DeviceSentMessage* Arena::CreateMaybeMessage<::proto::Message_DeviceSentMessage>(Arena*); -template<> ::proto::Message_DocumentMessage* Arena::CreateMaybeMessage<::proto::Message_DocumentMessage>(Arena*); -template<> ::proto::Message_ExtendedTextMessage* Arena::CreateMaybeMessage<::proto::Message_ExtendedTextMessage>(Arena*); -template<> ::proto::Message_FutureProofMessage* Arena::CreateMaybeMessage<::proto::Message_FutureProofMessage>(Arena*); -template<> ::proto::Message_GroupInviteMessage* Arena::CreateMaybeMessage<::proto::Message_GroupInviteMessage>(Arena*); -template<> ::proto::Message_HighlyStructuredMessage* Arena::CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(Arena*); -template<> ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* Arena::CreateMaybeMessage<::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter>(Arena*); -template<> ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* Arena::CreateMaybeMessage<::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency>(Arena*); -template<> ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* Arena::CreateMaybeMessage<::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime>(Arena*); -template<> ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* Arena::CreateMaybeMessage<::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent>(Arena*); -template<> ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* Arena::CreateMaybeMessage<::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch>(Arena*); -template<> ::proto::Message_HistorySyncNotification* Arena::CreateMaybeMessage<::proto::Message_HistorySyncNotification>(Arena*); -template<> ::proto::Message_ImageMessage* Arena::CreateMaybeMessage<::proto::Message_ImageMessage>(Arena*); -template<> ::proto::Message_InitialSecurityNotificationSettingSync* Arena::CreateMaybeMessage<::proto::Message_InitialSecurityNotificationSettingSync>(Arena*); -template<> ::proto::Message_InteractiveMessage* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage>(Arena*); -template<> ::proto::Message_InteractiveMessage_Body* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage_Body>(Arena*); -template<> ::proto::Message_InteractiveMessage_CollectionMessage* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage_CollectionMessage>(Arena*); -template<> ::proto::Message_InteractiveMessage_Footer* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage_Footer>(Arena*); -template<> ::proto::Message_InteractiveMessage_Header* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage_Header>(Arena*); -template<> ::proto::Message_InteractiveMessage_NativeFlowMessage* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage_NativeFlowMessage>(Arena*); -template<> ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton>(Arena*); -template<> ::proto::Message_InteractiveMessage_ShopMessage* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage_ShopMessage>(Arena*); -template<> ::proto::Message_InteractiveResponseMessage* Arena::CreateMaybeMessage<::proto::Message_InteractiveResponseMessage>(Arena*); -template<> ::proto::Message_InteractiveResponseMessage_Body* Arena::CreateMaybeMessage<::proto::Message_InteractiveResponseMessage_Body>(Arena*); -template<> ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* Arena::CreateMaybeMessage<::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage>(Arena*); -template<> ::proto::Message_InvoiceMessage* Arena::CreateMaybeMessage<::proto::Message_InvoiceMessage>(Arena*); -template<> ::proto::Message_KeepInChatMessage* Arena::CreateMaybeMessage<::proto::Message_KeepInChatMessage>(Arena*); -template<> ::proto::Message_ListMessage* Arena::CreateMaybeMessage<::proto::Message_ListMessage>(Arena*); -template<> ::proto::Message_ListMessage_Product* Arena::CreateMaybeMessage<::proto::Message_ListMessage_Product>(Arena*); -template<> ::proto::Message_ListMessage_ProductListHeaderImage* Arena::CreateMaybeMessage<::proto::Message_ListMessage_ProductListHeaderImage>(Arena*); -template<> ::proto::Message_ListMessage_ProductListInfo* Arena::CreateMaybeMessage<::proto::Message_ListMessage_ProductListInfo>(Arena*); -template<> ::proto::Message_ListMessage_ProductSection* Arena::CreateMaybeMessage<::proto::Message_ListMessage_ProductSection>(Arena*); -template<> ::proto::Message_ListMessage_Row* Arena::CreateMaybeMessage<::proto::Message_ListMessage_Row>(Arena*); -template<> ::proto::Message_ListMessage_Section* Arena::CreateMaybeMessage<::proto::Message_ListMessage_Section>(Arena*); -template<> ::proto::Message_ListResponseMessage* Arena::CreateMaybeMessage<::proto::Message_ListResponseMessage>(Arena*); -template<> ::proto::Message_ListResponseMessage_SingleSelectReply* Arena::CreateMaybeMessage<::proto::Message_ListResponseMessage_SingleSelectReply>(Arena*); -template<> ::proto::Message_LiveLocationMessage* Arena::CreateMaybeMessage<::proto::Message_LiveLocationMessage>(Arena*); -template<> ::proto::Message_LocationMessage* Arena::CreateMaybeMessage<::proto::Message_LocationMessage>(Arena*); -template<> ::proto::Message_OrderMessage* Arena::CreateMaybeMessage<::proto::Message_OrderMessage>(Arena*); -template<> ::proto::Message_PaymentInviteMessage* Arena::CreateMaybeMessage<::proto::Message_PaymentInviteMessage>(Arena*); -template<> ::proto::Message_PollCreationMessage* Arena::CreateMaybeMessage<::proto::Message_PollCreationMessage>(Arena*); -template<> ::proto::Message_PollCreationMessage_Option* Arena::CreateMaybeMessage<::proto::Message_PollCreationMessage_Option>(Arena*); -template<> ::proto::Message_PollEncValue* Arena::CreateMaybeMessage<::proto::Message_PollEncValue>(Arena*); -template<> ::proto::Message_PollUpdateMessage* Arena::CreateMaybeMessage<::proto::Message_PollUpdateMessage>(Arena*); -template<> ::proto::Message_PollUpdateMessageMetadata* Arena::CreateMaybeMessage<::proto::Message_PollUpdateMessageMetadata>(Arena*); -template<> ::proto::Message_PollVoteMessage* Arena::CreateMaybeMessage<::proto::Message_PollVoteMessage>(Arena*); -template<> ::proto::Message_ProductMessage* Arena::CreateMaybeMessage<::proto::Message_ProductMessage>(Arena*); -template<> ::proto::Message_ProductMessage_CatalogSnapshot* Arena::CreateMaybeMessage<::proto::Message_ProductMessage_CatalogSnapshot>(Arena*); -template<> ::proto::Message_ProductMessage_ProductSnapshot* Arena::CreateMaybeMessage<::proto::Message_ProductMessage_ProductSnapshot>(Arena*); -template<> ::proto::Message_ProtocolMessage* Arena::CreateMaybeMessage<::proto::Message_ProtocolMessage>(Arena*); -template<> ::proto::Message_ReactionMessage* Arena::CreateMaybeMessage<::proto::Message_ReactionMessage>(Arena*); -template<> ::proto::Message_RequestMediaUploadMessage* Arena::CreateMaybeMessage<::proto::Message_RequestMediaUploadMessage>(Arena*); -template<> ::proto::Message_RequestMediaUploadResponseMessage* Arena::CreateMaybeMessage<::proto::Message_RequestMediaUploadResponseMessage>(Arena*); -template<> ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* Arena::CreateMaybeMessage<::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult>(Arena*); -template<> ::proto::Message_RequestPaymentMessage* Arena::CreateMaybeMessage<::proto::Message_RequestPaymentMessage>(Arena*); -template<> ::proto::Message_RequestPhoneNumberMessage* Arena::CreateMaybeMessage<::proto::Message_RequestPhoneNumberMessage>(Arena*); -template<> ::proto::Message_SendPaymentMessage* Arena::CreateMaybeMessage<::proto::Message_SendPaymentMessage>(Arena*); -template<> ::proto::Message_SenderKeyDistributionMessage* Arena::CreateMaybeMessage<::proto::Message_SenderKeyDistributionMessage>(Arena*); -template<> ::proto::Message_StickerMessage* Arena::CreateMaybeMessage<::proto::Message_StickerMessage>(Arena*); -template<> ::proto::Message_StickerSyncRMRMessage* Arena::CreateMaybeMessage<::proto::Message_StickerSyncRMRMessage>(Arena*); -template<> ::proto::Message_TemplateButtonReplyMessage* Arena::CreateMaybeMessage<::proto::Message_TemplateButtonReplyMessage>(Arena*); -template<> ::proto::Message_TemplateMessage* Arena::CreateMaybeMessage<::proto::Message_TemplateMessage>(Arena*); -template<> ::proto::Message_TemplateMessage_FourRowTemplate* Arena::CreateMaybeMessage<::proto::Message_TemplateMessage_FourRowTemplate>(Arena*); -template<> ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Arena::CreateMaybeMessage<::proto::Message_TemplateMessage_HydratedFourRowTemplate>(Arena*); -template<> ::proto::Message_VideoMessage* Arena::CreateMaybeMessage<::proto::Message_VideoMessage>(Arena*); -template<> ::proto::Money* Arena::CreateMaybeMessage<::proto::Money>(Arena*); -template<> ::proto::MsgOpaqueData* Arena::CreateMaybeMessage<::proto::MsgOpaqueData>(Arena*); -template<> ::proto::MsgOpaqueData_PollOption* Arena::CreateMaybeMessage<::proto::MsgOpaqueData_PollOption>(Arena*); -template<> ::proto::MsgRowOpaqueData* Arena::CreateMaybeMessage<::proto::MsgRowOpaqueData>(Arena*); -template<> ::proto::NoiseCertificate* Arena::CreateMaybeMessage<::proto::NoiseCertificate>(Arena*); -template<> ::proto::NoiseCertificate_Details* Arena::CreateMaybeMessage<::proto::NoiseCertificate_Details>(Arena*); -template<> ::proto::NotificationMessageInfo* Arena::CreateMaybeMessage<::proto::NotificationMessageInfo>(Arena*); -template<> ::proto::PastParticipant* Arena::CreateMaybeMessage<::proto::PastParticipant>(Arena*); -template<> ::proto::PastParticipants* Arena::CreateMaybeMessage<::proto::PastParticipants>(Arena*); -template<> ::proto::PaymentBackground* Arena::CreateMaybeMessage<::proto::PaymentBackground>(Arena*); -template<> ::proto::PaymentBackground_MediaData* Arena::CreateMaybeMessage<::proto::PaymentBackground_MediaData>(Arena*); -template<> ::proto::PaymentInfo* Arena::CreateMaybeMessage<::proto::PaymentInfo>(Arena*); -template<> ::proto::PendingKeyExchange* Arena::CreateMaybeMessage<::proto::PendingKeyExchange>(Arena*); -template<> ::proto::PendingPreKey* Arena::CreateMaybeMessage<::proto::PendingPreKey>(Arena*); -template<> ::proto::PhotoChange* Arena::CreateMaybeMessage<::proto::PhotoChange>(Arena*); -template<> ::proto::Point* Arena::CreateMaybeMessage<::proto::Point>(Arena*); -template<> ::proto::PollAdditionalMetadata* Arena::CreateMaybeMessage<::proto::PollAdditionalMetadata>(Arena*); -template<> ::proto::PollEncValue* Arena::CreateMaybeMessage<::proto::PollEncValue>(Arena*); -template<> ::proto::PollUpdate* Arena::CreateMaybeMessage<::proto::PollUpdate>(Arena*); -template<> ::proto::PreKeyRecordStructure* Arena::CreateMaybeMessage<::proto::PreKeyRecordStructure>(Arena*); -template<> ::proto::Pushname* Arena::CreateMaybeMessage<::proto::Pushname>(Arena*); -template<> ::proto::Reaction* Arena::CreateMaybeMessage<::proto::Reaction>(Arena*); -template<> ::proto::RecentEmojiWeight* Arena::CreateMaybeMessage<::proto::RecentEmojiWeight>(Arena*); -template<> ::proto::RecordStructure* Arena::CreateMaybeMessage<::proto::RecordStructure>(Arena*); -template<> ::proto::SenderChainKey* Arena::CreateMaybeMessage<::proto::SenderChainKey>(Arena*); -template<> ::proto::SenderKeyRecordStructure* Arena::CreateMaybeMessage<::proto::SenderKeyRecordStructure>(Arena*); -template<> ::proto::SenderKeyStateStructure* Arena::CreateMaybeMessage<::proto::SenderKeyStateStructure>(Arena*); -template<> ::proto::SenderMessageKey* Arena::CreateMaybeMessage<::proto::SenderMessageKey>(Arena*); -template<> ::proto::SenderSigningKey* Arena::CreateMaybeMessage<::proto::SenderSigningKey>(Arena*); -template<> ::proto::ServerErrorReceipt* Arena::CreateMaybeMessage<::proto::ServerErrorReceipt>(Arena*); -template<> ::proto::SessionStructure* Arena::CreateMaybeMessage<::proto::SessionStructure>(Arena*); -template<> ::proto::SignedPreKeyRecordStructure* Arena::CreateMaybeMessage<::proto::SignedPreKeyRecordStructure>(Arena*); -template<> ::proto::StatusPSA* Arena::CreateMaybeMessage<::proto::StatusPSA>(Arena*); -template<> ::proto::StickerMetadata* Arena::CreateMaybeMessage<::proto::StickerMetadata>(Arena*); -template<> ::proto::SyncActionData* Arena::CreateMaybeMessage<::proto::SyncActionData>(Arena*); -template<> ::proto::SyncActionValue* Arena::CreateMaybeMessage<::proto::SyncActionValue>(Arena*); -template<> ::proto::SyncActionValue_AgentAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_AgentAction>(Arena*); -template<> ::proto::SyncActionValue_AndroidUnsupportedActions* Arena::CreateMaybeMessage<::proto::SyncActionValue_AndroidUnsupportedActions>(Arena*); -template<> ::proto::SyncActionValue_ArchiveChatAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_ArchiveChatAction>(Arena*); -template<> ::proto::SyncActionValue_ClearChatAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_ClearChatAction>(Arena*); -template<> ::proto::SyncActionValue_ContactAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_ContactAction>(Arena*); -template<> ::proto::SyncActionValue_DeleteChatAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_DeleteChatAction>(Arena*); -template<> ::proto::SyncActionValue_DeleteMessageForMeAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_DeleteMessageForMeAction>(Arena*); -template<> ::proto::SyncActionValue_KeyExpiration* Arena::CreateMaybeMessage<::proto::SyncActionValue_KeyExpiration>(Arena*); -template<> ::proto::SyncActionValue_LabelAssociationAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_LabelAssociationAction>(Arena*); -template<> ::proto::SyncActionValue_LabelEditAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_LabelEditAction>(Arena*); -template<> ::proto::SyncActionValue_LocaleSetting* Arena::CreateMaybeMessage<::proto::SyncActionValue_LocaleSetting>(Arena*); -template<> ::proto::SyncActionValue_MarkChatAsReadAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_MarkChatAsReadAction>(Arena*); -template<> ::proto::SyncActionValue_MuteAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_MuteAction>(Arena*); -template<> ::proto::SyncActionValue_NuxAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_NuxAction>(Arena*); -template<> ::proto::SyncActionValue_PinAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_PinAction>(Arena*); -template<> ::proto::SyncActionValue_PrimaryFeature* Arena::CreateMaybeMessage<::proto::SyncActionValue_PrimaryFeature>(Arena*); -template<> ::proto::SyncActionValue_PrimaryVersionAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_PrimaryVersionAction>(Arena*); -template<> ::proto::SyncActionValue_PushNameSetting* Arena::CreateMaybeMessage<::proto::SyncActionValue_PushNameSetting>(Arena*); -template<> ::proto::SyncActionValue_QuickReplyAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_QuickReplyAction>(Arena*); -template<> ::proto::SyncActionValue_RecentEmojiWeightsAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_RecentEmojiWeightsAction>(Arena*); -template<> ::proto::SyncActionValue_SecurityNotificationSetting* Arena::CreateMaybeMessage<::proto::SyncActionValue_SecurityNotificationSetting>(Arena*); -template<> ::proto::SyncActionValue_StarAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_StarAction>(Arena*); -template<> ::proto::SyncActionValue_StickerAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_StickerAction>(Arena*); -template<> ::proto::SyncActionValue_SubscriptionAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_SubscriptionAction>(Arena*); -template<> ::proto::SyncActionValue_SyncActionMessage* Arena::CreateMaybeMessage<::proto::SyncActionValue_SyncActionMessage>(Arena*); -template<> ::proto::SyncActionValue_SyncActionMessageRange* Arena::CreateMaybeMessage<::proto::SyncActionValue_SyncActionMessageRange>(Arena*); -template<> ::proto::SyncActionValue_TimeFormatAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_TimeFormatAction>(Arena*); -template<> ::proto::SyncActionValue_UnarchiveChatsSetting* Arena::CreateMaybeMessage<::proto::SyncActionValue_UnarchiveChatsSetting>(Arena*); -template<> ::proto::SyncActionValue_UserStatusMuteAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_UserStatusMuteAction>(Arena*); -template<> ::proto::SyncdIndex* Arena::CreateMaybeMessage<::proto::SyncdIndex>(Arena*); -template<> ::proto::SyncdMutation* Arena::CreateMaybeMessage<::proto::SyncdMutation>(Arena*); -template<> ::proto::SyncdMutations* Arena::CreateMaybeMessage<::proto::SyncdMutations>(Arena*); -template<> ::proto::SyncdPatch* Arena::CreateMaybeMessage<::proto::SyncdPatch>(Arena*); -template<> ::proto::SyncdRecord* Arena::CreateMaybeMessage<::proto::SyncdRecord>(Arena*); -template<> ::proto::SyncdSnapshot* Arena::CreateMaybeMessage<::proto::SyncdSnapshot>(Arena*); -template<> ::proto::SyncdValue* Arena::CreateMaybeMessage<::proto::SyncdValue>(Arena*); -template<> ::proto::SyncdVersion* Arena::CreateMaybeMessage<::proto::SyncdVersion>(Arena*); -template<> ::proto::TemplateButton* Arena::CreateMaybeMessage<::proto::TemplateButton>(Arena*); -template<> ::proto::TemplateButton_CallButton* Arena::CreateMaybeMessage<::proto::TemplateButton_CallButton>(Arena*); -template<> ::proto::TemplateButton_QuickReplyButton* Arena::CreateMaybeMessage<::proto::TemplateButton_QuickReplyButton>(Arena*); -template<> ::proto::TemplateButton_URLButton* Arena::CreateMaybeMessage<::proto::TemplateButton_URLButton>(Arena*); -template<> ::proto::UserReceipt* Arena::CreateMaybeMessage<::proto::UserReceipt>(Arena*); -template<> ::proto::VerifiedNameCertificate* Arena::CreateMaybeMessage<::proto::VerifiedNameCertificate>(Arena*); -template<> ::proto::VerifiedNameCertificate_Details* Arena::CreateMaybeMessage<::proto::VerifiedNameCertificate_Details>(Arena*); -template<> ::proto::WallpaperSettings* Arena::CreateMaybeMessage<::proto::WallpaperSettings>(Arena*); -template<> ::proto::WebFeatures* Arena::CreateMaybeMessage<::proto::WebFeatures>(Arena*); -template<> ::proto::WebMessageInfo* Arena::CreateMaybeMessage<::proto::WebMessageInfo>(Arena*); -template<> ::proto::WebNotificationsInfo* Arena::CreateMaybeMessage<::proto::WebNotificationsInfo>(Arena*); -PROTOBUF_NAMESPACE_CLOSE -namespace proto { - -enum BizAccountLinkInfo_AccountType : int { - BizAccountLinkInfo_AccountType_ENTERPRISE = 0 -}; -bool BizAccountLinkInfo_AccountType_IsValid(int value); -constexpr BizAccountLinkInfo_AccountType BizAccountLinkInfo_AccountType_AccountType_MIN = BizAccountLinkInfo_AccountType_ENTERPRISE; -constexpr BizAccountLinkInfo_AccountType BizAccountLinkInfo_AccountType_AccountType_MAX = BizAccountLinkInfo_AccountType_ENTERPRISE; -constexpr int BizAccountLinkInfo_AccountType_AccountType_ARRAYSIZE = BizAccountLinkInfo_AccountType_AccountType_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizAccountLinkInfo_AccountType_descriptor(); -template -inline const std::string& BizAccountLinkInfo_AccountType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function BizAccountLinkInfo_AccountType_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - BizAccountLinkInfo_AccountType_descriptor(), enum_t_value); -} -inline bool BizAccountLinkInfo_AccountType_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BizAccountLinkInfo_AccountType* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - BizAccountLinkInfo_AccountType_descriptor(), name, value); -} -enum BizAccountLinkInfo_HostStorageType : int { - BizAccountLinkInfo_HostStorageType_ON_PREMISE = 0, - BizAccountLinkInfo_HostStorageType_FACEBOOK = 1 -}; -bool BizAccountLinkInfo_HostStorageType_IsValid(int value); -constexpr BizAccountLinkInfo_HostStorageType BizAccountLinkInfo_HostStorageType_HostStorageType_MIN = BizAccountLinkInfo_HostStorageType_ON_PREMISE; -constexpr BizAccountLinkInfo_HostStorageType BizAccountLinkInfo_HostStorageType_HostStorageType_MAX = BizAccountLinkInfo_HostStorageType_FACEBOOK; -constexpr int BizAccountLinkInfo_HostStorageType_HostStorageType_ARRAYSIZE = BizAccountLinkInfo_HostStorageType_HostStorageType_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizAccountLinkInfo_HostStorageType_descriptor(); -template -inline const std::string& BizAccountLinkInfo_HostStorageType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function BizAccountLinkInfo_HostStorageType_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - BizAccountLinkInfo_HostStorageType_descriptor(), enum_t_value); -} -inline bool BizAccountLinkInfo_HostStorageType_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BizAccountLinkInfo_HostStorageType* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - BizAccountLinkInfo_HostStorageType_descriptor(), name, value); -} -enum BizIdentityInfo_ActualActorsType : int { - BizIdentityInfo_ActualActorsType_SELF = 0, - BizIdentityInfo_ActualActorsType_BSP = 1 -}; -bool BizIdentityInfo_ActualActorsType_IsValid(int value); -constexpr BizIdentityInfo_ActualActorsType BizIdentityInfo_ActualActorsType_ActualActorsType_MIN = BizIdentityInfo_ActualActorsType_SELF; -constexpr BizIdentityInfo_ActualActorsType BizIdentityInfo_ActualActorsType_ActualActorsType_MAX = BizIdentityInfo_ActualActorsType_BSP; -constexpr int BizIdentityInfo_ActualActorsType_ActualActorsType_ARRAYSIZE = BizIdentityInfo_ActualActorsType_ActualActorsType_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizIdentityInfo_ActualActorsType_descriptor(); -template -inline const std::string& BizIdentityInfo_ActualActorsType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function BizIdentityInfo_ActualActorsType_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - BizIdentityInfo_ActualActorsType_descriptor(), enum_t_value); -} -inline bool BizIdentityInfo_ActualActorsType_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BizIdentityInfo_ActualActorsType* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - BizIdentityInfo_ActualActorsType_descriptor(), name, value); -} -enum BizIdentityInfo_HostStorageType : int { - BizIdentityInfo_HostStorageType_ON_PREMISE = 0, - BizIdentityInfo_HostStorageType_FACEBOOK = 1 -}; -bool BizIdentityInfo_HostStorageType_IsValid(int value); -constexpr BizIdentityInfo_HostStorageType BizIdentityInfo_HostStorageType_HostStorageType_MIN = BizIdentityInfo_HostStorageType_ON_PREMISE; -constexpr BizIdentityInfo_HostStorageType BizIdentityInfo_HostStorageType_HostStorageType_MAX = BizIdentityInfo_HostStorageType_FACEBOOK; -constexpr int BizIdentityInfo_HostStorageType_HostStorageType_ARRAYSIZE = BizIdentityInfo_HostStorageType_HostStorageType_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizIdentityInfo_HostStorageType_descriptor(); -template -inline const std::string& BizIdentityInfo_HostStorageType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function BizIdentityInfo_HostStorageType_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - BizIdentityInfo_HostStorageType_descriptor(), enum_t_value); -} -inline bool BizIdentityInfo_HostStorageType_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BizIdentityInfo_HostStorageType* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - BizIdentityInfo_HostStorageType_descriptor(), name, value); -} -enum BizIdentityInfo_VerifiedLevelValue : int { - BizIdentityInfo_VerifiedLevelValue_UNKNOWN = 0, - BizIdentityInfo_VerifiedLevelValue_LOW = 1, - BizIdentityInfo_VerifiedLevelValue_HIGH = 2 -}; -bool BizIdentityInfo_VerifiedLevelValue_IsValid(int value); -constexpr BizIdentityInfo_VerifiedLevelValue BizIdentityInfo_VerifiedLevelValue_VerifiedLevelValue_MIN = BizIdentityInfo_VerifiedLevelValue_UNKNOWN; -constexpr BizIdentityInfo_VerifiedLevelValue BizIdentityInfo_VerifiedLevelValue_VerifiedLevelValue_MAX = BizIdentityInfo_VerifiedLevelValue_HIGH; -constexpr int BizIdentityInfo_VerifiedLevelValue_VerifiedLevelValue_ARRAYSIZE = BizIdentityInfo_VerifiedLevelValue_VerifiedLevelValue_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizIdentityInfo_VerifiedLevelValue_descriptor(); -template -inline const std::string& BizIdentityInfo_VerifiedLevelValue_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function BizIdentityInfo_VerifiedLevelValue_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - BizIdentityInfo_VerifiedLevelValue_descriptor(), enum_t_value); -} -inline bool BizIdentityInfo_VerifiedLevelValue_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BizIdentityInfo_VerifiedLevelValue* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - BizIdentityInfo_VerifiedLevelValue_descriptor(), name, value); -} -enum ClientPayload_DNSSource_DNSResolutionMethod : int { - ClientPayload_DNSSource_DNSResolutionMethod_SYSTEM = 0, - ClientPayload_DNSSource_DNSResolutionMethod_GOOGLE = 1, - ClientPayload_DNSSource_DNSResolutionMethod_HARDCODED = 2, - ClientPayload_DNSSource_DNSResolutionMethod_OVERRIDE = 3, - ClientPayload_DNSSource_DNSResolutionMethod_FALLBACK = 4 -}; -bool ClientPayload_DNSSource_DNSResolutionMethod_IsValid(int value); -constexpr ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource_DNSResolutionMethod_DNSResolutionMethod_MIN = ClientPayload_DNSSource_DNSResolutionMethod_SYSTEM; -constexpr ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource_DNSResolutionMethod_DNSResolutionMethod_MAX = ClientPayload_DNSSource_DNSResolutionMethod_FALLBACK; -constexpr int ClientPayload_DNSSource_DNSResolutionMethod_DNSResolutionMethod_ARRAYSIZE = ClientPayload_DNSSource_DNSResolutionMethod_DNSResolutionMethod_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_DNSSource_DNSResolutionMethod_descriptor(); -template -inline const std::string& ClientPayload_DNSSource_DNSResolutionMethod_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function ClientPayload_DNSSource_DNSResolutionMethod_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - ClientPayload_DNSSource_DNSResolutionMethod_descriptor(), enum_t_value); -} -inline bool ClientPayload_DNSSource_DNSResolutionMethod_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_DNSSource_DNSResolutionMethod* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - ClientPayload_DNSSource_DNSResolutionMethod_descriptor(), name, value); -} -enum ClientPayload_UserAgent_Platform : int { - ClientPayload_UserAgent_Platform_ANDROID = 0, - ClientPayload_UserAgent_Platform_IOS = 1, - ClientPayload_UserAgent_Platform_WINDOWS_PHONE = 2, - ClientPayload_UserAgent_Platform_BLACKBERRY = 3, - ClientPayload_UserAgent_Platform_BLACKBERRYX = 4, - ClientPayload_UserAgent_Platform_S40 = 5, - ClientPayload_UserAgent_Platform_S60 = 6, - ClientPayload_UserAgent_Platform_PYTHON_CLIENT = 7, - ClientPayload_UserAgent_Platform_TIZEN = 8, - ClientPayload_UserAgent_Platform_ENTERPRISE = 9, - ClientPayload_UserAgent_Platform_SMB_ANDROID = 10, - ClientPayload_UserAgent_Platform_KAIOS = 11, - ClientPayload_UserAgent_Platform_SMB_IOS = 12, - ClientPayload_UserAgent_Platform_WINDOWS = 13, - ClientPayload_UserAgent_Platform_WEB = 14, - ClientPayload_UserAgent_Platform_PORTAL = 15, - ClientPayload_UserAgent_Platform_GREEN_ANDROID = 16, - ClientPayload_UserAgent_Platform_GREEN_IPHONE = 17, - ClientPayload_UserAgent_Platform_BLUE_ANDROID = 18, - ClientPayload_UserAgent_Platform_BLUE_IPHONE = 19, - ClientPayload_UserAgent_Platform_FBLITE_ANDROID = 20, - ClientPayload_UserAgent_Platform_MLITE_ANDROID = 21, - ClientPayload_UserAgent_Platform_IGLITE_ANDROID = 22, - ClientPayload_UserAgent_Platform_PAGE = 23, - ClientPayload_UserAgent_Platform_MACOS = 24, - ClientPayload_UserAgent_Platform_OCULUS_MSG = 25, - ClientPayload_UserAgent_Platform_OCULUS_CALL = 26, - ClientPayload_UserAgent_Platform_MILAN = 27, - ClientPayload_UserAgent_Platform_CAPI = 28 -}; -bool ClientPayload_UserAgent_Platform_IsValid(int value); -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent_Platform_Platform_MIN = ClientPayload_UserAgent_Platform_ANDROID; -constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent_Platform_Platform_MAX = ClientPayload_UserAgent_Platform_CAPI; -constexpr int ClientPayload_UserAgent_Platform_Platform_ARRAYSIZE = ClientPayload_UserAgent_Platform_Platform_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_UserAgent_Platform_descriptor(); -template -inline const std::string& ClientPayload_UserAgent_Platform_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function ClientPayload_UserAgent_Platform_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - ClientPayload_UserAgent_Platform_descriptor(), enum_t_value); -} -inline bool ClientPayload_UserAgent_Platform_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_UserAgent_Platform* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - ClientPayload_UserAgent_Platform_descriptor(), name, value); -} -enum ClientPayload_UserAgent_ReleaseChannel : int { - ClientPayload_UserAgent_ReleaseChannel_RELEASE = 0, - ClientPayload_UserAgent_ReleaseChannel_BETA = 1, - ClientPayload_UserAgent_ReleaseChannel_ALPHA = 2, - ClientPayload_UserAgent_ReleaseChannel_DEBUG = 3 -}; -bool ClientPayload_UserAgent_ReleaseChannel_IsValid(int value); -constexpr ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent_ReleaseChannel_ReleaseChannel_MIN = ClientPayload_UserAgent_ReleaseChannel_RELEASE; -constexpr ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent_ReleaseChannel_ReleaseChannel_MAX = ClientPayload_UserAgent_ReleaseChannel_DEBUG; -constexpr int ClientPayload_UserAgent_ReleaseChannel_ReleaseChannel_ARRAYSIZE = ClientPayload_UserAgent_ReleaseChannel_ReleaseChannel_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_UserAgent_ReleaseChannel_descriptor(); -template -inline const std::string& ClientPayload_UserAgent_ReleaseChannel_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function ClientPayload_UserAgent_ReleaseChannel_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - ClientPayload_UserAgent_ReleaseChannel_descriptor(), enum_t_value); -} -inline bool ClientPayload_UserAgent_ReleaseChannel_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_UserAgent_ReleaseChannel* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - ClientPayload_UserAgent_ReleaseChannel_descriptor(), name, value); -} -enum ClientPayload_WebInfo_WebSubPlatform : int { - ClientPayload_WebInfo_WebSubPlatform_WEB_BROWSER = 0, - ClientPayload_WebInfo_WebSubPlatform_APP_STORE = 1, - ClientPayload_WebInfo_WebSubPlatform_WIN_STORE = 2, - ClientPayload_WebInfo_WebSubPlatform_DARWIN = 3, - ClientPayload_WebInfo_WebSubPlatform_WINDA = 4 -}; -bool ClientPayload_WebInfo_WebSubPlatform_IsValid(int value); -constexpr ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo_WebSubPlatform_WebSubPlatform_MIN = ClientPayload_WebInfo_WebSubPlatform_WEB_BROWSER; -constexpr ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo_WebSubPlatform_WebSubPlatform_MAX = ClientPayload_WebInfo_WebSubPlatform_WINDA; -constexpr int ClientPayload_WebInfo_WebSubPlatform_WebSubPlatform_ARRAYSIZE = ClientPayload_WebInfo_WebSubPlatform_WebSubPlatform_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_WebInfo_WebSubPlatform_descriptor(); -template -inline const std::string& ClientPayload_WebInfo_WebSubPlatform_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function ClientPayload_WebInfo_WebSubPlatform_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - ClientPayload_WebInfo_WebSubPlatform_descriptor(), enum_t_value); -} -inline bool ClientPayload_WebInfo_WebSubPlatform_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_WebInfo_WebSubPlatform* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - ClientPayload_WebInfo_WebSubPlatform_descriptor(), name, value); -} -enum ClientPayload_ConnectReason : int { - ClientPayload_ConnectReason_PUSH = 0, - ClientPayload_ConnectReason_USER_ACTIVATED = 1, - ClientPayload_ConnectReason_SCHEDULED = 2, - ClientPayload_ConnectReason_ERROR_RECONNECT = 3, - ClientPayload_ConnectReason_NETWORK_SWITCH = 4, - ClientPayload_ConnectReason_PING_RECONNECT = 5 -}; -bool ClientPayload_ConnectReason_IsValid(int value); -constexpr ClientPayload_ConnectReason ClientPayload_ConnectReason_ConnectReason_MIN = ClientPayload_ConnectReason_PUSH; -constexpr ClientPayload_ConnectReason ClientPayload_ConnectReason_ConnectReason_MAX = ClientPayload_ConnectReason_PING_RECONNECT; -constexpr int ClientPayload_ConnectReason_ConnectReason_ARRAYSIZE = ClientPayload_ConnectReason_ConnectReason_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_ConnectReason_descriptor(); -template -inline const std::string& ClientPayload_ConnectReason_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function ClientPayload_ConnectReason_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - ClientPayload_ConnectReason_descriptor(), enum_t_value); -} -inline bool ClientPayload_ConnectReason_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_ConnectReason* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - ClientPayload_ConnectReason_descriptor(), name, value); -} -enum ClientPayload_ConnectType : int { - ClientPayload_ConnectType_CELLULAR_UNKNOWN = 0, - ClientPayload_ConnectType_WIFI_UNKNOWN = 1, - ClientPayload_ConnectType_CELLULAR_EDGE = 100, - ClientPayload_ConnectType_CELLULAR_IDEN = 101, - ClientPayload_ConnectType_CELLULAR_UMTS = 102, - ClientPayload_ConnectType_CELLULAR_EVDO = 103, - ClientPayload_ConnectType_CELLULAR_GPRS = 104, - ClientPayload_ConnectType_CELLULAR_HSDPA = 105, - ClientPayload_ConnectType_CELLULAR_HSUPA = 106, - ClientPayload_ConnectType_CELLULAR_HSPA = 107, - ClientPayload_ConnectType_CELLULAR_CDMA = 108, - ClientPayload_ConnectType_CELLULAR_1XRTT = 109, - ClientPayload_ConnectType_CELLULAR_EHRPD = 110, - ClientPayload_ConnectType_CELLULAR_LTE = 111, - ClientPayload_ConnectType_CELLULAR_HSPAP = 112 -}; -bool ClientPayload_ConnectType_IsValid(int value); -constexpr ClientPayload_ConnectType ClientPayload_ConnectType_ConnectType_MIN = ClientPayload_ConnectType_CELLULAR_UNKNOWN; -constexpr ClientPayload_ConnectType ClientPayload_ConnectType_ConnectType_MAX = ClientPayload_ConnectType_CELLULAR_HSPAP; -constexpr int ClientPayload_ConnectType_ConnectType_ARRAYSIZE = ClientPayload_ConnectType_ConnectType_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_ConnectType_descriptor(); -template -inline const std::string& ClientPayload_ConnectType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function ClientPayload_ConnectType_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - ClientPayload_ConnectType_descriptor(), enum_t_value); -} -inline bool ClientPayload_ConnectType_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_ConnectType* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - ClientPayload_ConnectType_descriptor(), name, value); -} -enum ClientPayload_IOSAppExtension : int { - ClientPayload_IOSAppExtension_SHARE_EXTENSION = 0, - ClientPayload_IOSAppExtension_SERVICE_EXTENSION = 1, - ClientPayload_IOSAppExtension_INTENTS_EXTENSION = 2 -}; -bool ClientPayload_IOSAppExtension_IsValid(int value); -constexpr ClientPayload_IOSAppExtension ClientPayload_IOSAppExtension_IOSAppExtension_MIN = ClientPayload_IOSAppExtension_SHARE_EXTENSION; -constexpr ClientPayload_IOSAppExtension ClientPayload_IOSAppExtension_IOSAppExtension_MAX = ClientPayload_IOSAppExtension_INTENTS_EXTENSION; -constexpr int ClientPayload_IOSAppExtension_IOSAppExtension_ARRAYSIZE = ClientPayload_IOSAppExtension_IOSAppExtension_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_IOSAppExtension_descriptor(); -template -inline const std::string& ClientPayload_IOSAppExtension_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function ClientPayload_IOSAppExtension_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - ClientPayload_IOSAppExtension_descriptor(), enum_t_value); -} -inline bool ClientPayload_IOSAppExtension_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_IOSAppExtension* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - ClientPayload_IOSAppExtension_descriptor(), name, value); -} -enum ClientPayload_Product : int { - ClientPayload_Product_WHATSAPP = 0, - ClientPayload_Product_MESSENGER = 1 -}; -bool ClientPayload_Product_IsValid(int value); -constexpr ClientPayload_Product ClientPayload_Product_Product_MIN = ClientPayload_Product_WHATSAPP; -constexpr ClientPayload_Product ClientPayload_Product_Product_MAX = ClientPayload_Product_MESSENGER; -constexpr int ClientPayload_Product_Product_ARRAYSIZE = ClientPayload_Product_Product_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_Product_descriptor(); -template -inline const std::string& ClientPayload_Product_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function ClientPayload_Product_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - ClientPayload_Product_descriptor(), enum_t_value); -} -inline bool ClientPayload_Product_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_Product* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - ClientPayload_Product_descriptor(), name, value); -} -enum ContextInfo_AdReplyInfo_MediaType : int { - ContextInfo_AdReplyInfo_MediaType_NONE = 0, - ContextInfo_AdReplyInfo_MediaType_IMAGE = 1, - ContextInfo_AdReplyInfo_MediaType_VIDEO = 2 -}; -bool ContextInfo_AdReplyInfo_MediaType_IsValid(int value); -constexpr ContextInfo_AdReplyInfo_MediaType ContextInfo_AdReplyInfo_MediaType_MediaType_MIN = ContextInfo_AdReplyInfo_MediaType_NONE; -constexpr ContextInfo_AdReplyInfo_MediaType ContextInfo_AdReplyInfo_MediaType_MediaType_MAX = ContextInfo_AdReplyInfo_MediaType_VIDEO; -constexpr int ContextInfo_AdReplyInfo_MediaType_MediaType_ARRAYSIZE = ContextInfo_AdReplyInfo_MediaType_MediaType_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ContextInfo_AdReplyInfo_MediaType_descriptor(); -template -inline const std::string& ContextInfo_AdReplyInfo_MediaType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function ContextInfo_AdReplyInfo_MediaType_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - ContextInfo_AdReplyInfo_MediaType_descriptor(), enum_t_value); -} -inline bool ContextInfo_AdReplyInfo_MediaType_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ContextInfo_AdReplyInfo_MediaType* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - ContextInfo_AdReplyInfo_MediaType_descriptor(), name, value); -} -enum ContextInfo_ExternalAdReplyInfo_MediaType : int { - ContextInfo_ExternalAdReplyInfo_MediaType_NONE = 0, - ContextInfo_ExternalAdReplyInfo_MediaType_IMAGE = 1, - ContextInfo_ExternalAdReplyInfo_MediaType_VIDEO = 2 -}; -bool ContextInfo_ExternalAdReplyInfo_MediaType_IsValid(int value); -constexpr ContextInfo_ExternalAdReplyInfo_MediaType ContextInfo_ExternalAdReplyInfo_MediaType_MediaType_MIN = ContextInfo_ExternalAdReplyInfo_MediaType_NONE; -constexpr ContextInfo_ExternalAdReplyInfo_MediaType ContextInfo_ExternalAdReplyInfo_MediaType_MediaType_MAX = ContextInfo_ExternalAdReplyInfo_MediaType_VIDEO; -constexpr int ContextInfo_ExternalAdReplyInfo_MediaType_MediaType_ARRAYSIZE = ContextInfo_ExternalAdReplyInfo_MediaType_MediaType_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ContextInfo_ExternalAdReplyInfo_MediaType_descriptor(); -template -inline const std::string& ContextInfo_ExternalAdReplyInfo_MediaType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function ContextInfo_ExternalAdReplyInfo_MediaType_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - ContextInfo_ExternalAdReplyInfo_MediaType_descriptor(), enum_t_value); -} -inline bool ContextInfo_ExternalAdReplyInfo_MediaType_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ContextInfo_ExternalAdReplyInfo_MediaType* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - ContextInfo_ExternalAdReplyInfo_MediaType_descriptor(), name, value); -} -enum Conversation_EndOfHistoryTransferType : int { - Conversation_EndOfHistoryTransferType_COMPLETE_BUT_MORE_MESSAGES_REMAIN_ON_PRIMARY = 0, - Conversation_EndOfHistoryTransferType_COMPLETE_AND_NO_MORE_MESSAGE_REMAIN_ON_PRIMARY = 1 -}; -bool Conversation_EndOfHistoryTransferType_IsValid(int value); -constexpr Conversation_EndOfHistoryTransferType Conversation_EndOfHistoryTransferType_EndOfHistoryTransferType_MIN = Conversation_EndOfHistoryTransferType_COMPLETE_BUT_MORE_MESSAGES_REMAIN_ON_PRIMARY; -constexpr Conversation_EndOfHistoryTransferType Conversation_EndOfHistoryTransferType_EndOfHistoryTransferType_MAX = Conversation_EndOfHistoryTransferType_COMPLETE_AND_NO_MORE_MESSAGE_REMAIN_ON_PRIMARY; -constexpr int Conversation_EndOfHistoryTransferType_EndOfHistoryTransferType_ARRAYSIZE = Conversation_EndOfHistoryTransferType_EndOfHistoryTransferType_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Conversation_EndOfHistoryTransferType_descriptor(); -template -inline const std::string& Conversation_EndOfHistoryTransferType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Conversation_EndOfHistoryTransferType_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - Conversation_EndOfHistoryTransferType_descriptor(), enum_t_value); -} -inline bool Conversation_EndOfHistoryTransferType_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Conversation_EndOfHistoryTransferType* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - Conversation_EndOfHistoryTransferType_descriptor(), name, value); -} -enum DeviceProps_PlatformType : int { - DeviceProps_PlatformType_UNKNOWN = 0, - DeviceProps_PlatformType_CHROME = 1, - DeviceProps_PlatformType_FIREFOX = 2, - DeviceProps_PlatformType_IE = 3, - DeviceProps_PlatformType_OPERA = 4, - DeviceProps_PlatformType_SAFARI = 5, - DeviceProps_PlatformType_EDGE = 6, - DeviceProps_PlatformType_DESKTOP = 7, - DeviceProps_PlatformType_IPAD = 8, - DeviceProps_PlatformType_ANDROID_TABLET = 9, - DeviceProps_PlatformType_OHANA = 10, - DeviceProps_PlatformType_ALOHA = 11, - DeviceProps_PlatformType_CATALINA = 12, - DeviceProps_PlatformType_TCL_TV = 13 -}; -bool DeviceProps_PlatformType_IsValid(int value); -constexpr DeviceProps_PlatformType DeviceProps_PlatformType_PlatformType_MIN = DeviceProps_PlatformType_UNKNOWN; -constexpr DeviceProps_PlatformType DeviceProps_PlatformType_PlatformType_MAX = DeviceProps_PlatformType_TCL_TV; -constexpr int DeviceProps_PlatformType_PlatformType_ARRAYSIZE = DeviceProps_PlatformType_PlatformType_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceProps_PlatformType_descriptor(); -template -inline const std::string& DeviceProps_PlatformType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function DeviceProps_PlatformType_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - DeviceProps_PlatformType_descriptor(), enum_t_value); -} -inline bool DeviceProps_PlatformType_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceProps_PlatformType* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - DeviceProps_PlatformType_descriptor(), name, value); -} -enum DisappearingMode_Initiator : int { - DisappearingMode_Initiator_CHANGED_IN_CHAT = 0, - DisappearingMode_Initiator_INITIATED_BY_ME = 1, - DisappearingMode_Initiator_INITIATED_BY_OTHER = 2 -}; -bool DisappearingMode_Initiator_IsValid(int value); -constexpr DisappearingMode_Initiator DisappearingMode_Initiator_Initiator_MIN = DisappearingMode_Initiator_CHANGED_IN_CHAT; -constexpr DisappearingMode_Initiator DisappearingMode_Initiator_Initiator_MAX = DisappearingMode_Initiator_INITIATED_BY_OTHER; -constexpr int DisappearingMode_Initiator_Initiator_ARRAYSIZE = DisappearingMode_Initiator_Initiator_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DisappearingMode_Initiator_descriptor(); -template -inline const std::string& DisappearingMode_Initiator_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function DisappearingMode_Initiator_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - DisappearingMode_Initiator_descriptor(), enum_t_value); -} -inline bool DisappearingMode_Initiator_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DisappearingMode_Initiator* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - DisappearingMode_Initiator_descriptor(), name, value); -} -enum GroupParticipant_Rank : int { - GroupParticipant_Rank_REGULAR = 0, - GroupParticipant_Rank_ADMIN = 1, - GroupParticipant_Rank_SUPERADMIN = 2 -}; -bool GroupParticipant_Rank_IsValid(int value); -constexpr GroupParticipant_Rank GroupParticipant_Rank_Rank_MIN = GroupParticipant_Rank_REGULAR; -constexpr GroupParticipant_Rank GroupParticipant_Rank_Rank_MAX = GroupParticipant_Rank_SUPERADMIN; -constexpr int GroupParticipant_Rank_Rank_ARRAYSIZE = GroupParticipant_Rank_Rank_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* GroupParticipant_Rank_descriptor(); -template -inline const std::string& GroupParticipant_Rank_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function GroupParticipant_Rank_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - GroupParticipant_Rank_descriptor(), enum_t_value); -} -inline bool GroupParticipant_Rank_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, GroupParticipant_Rank* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - GroupParticipant_Rank_descriptor(), name, value); -} -enum HistorySync_HistorySyncType : int { - HistorySync_HistorySyncType_INITIAL_BOOTSTRAP = 0, - HistorySync_HistorySyncType_INITIAL_STATUS_V3 = 1, - HistorySync_HistorySyncType_FULL = 2, - HistorySync_HistorySyncType_RECENT = 3, - HistorySync_HistorySyncType_PUSH_NAME = 4, - HistorySync_HistorySyncType_UNBLOCKING_DATA = 5 -}; -bool HistorySync_HistorySyncType_IsValid(int value); -constexpr HistorySync_HistorySyncType HistorySync_HistorySyncType_HistorySyncType_MIN = HistorySync_HistorySyncType_INITIAL_BOOTSTRAP; -constexpr HistorySync_HistorySyncType HistorySync_HistorySyncType_HistorySyncType_MAX = HistorySync_HistorySyncType_UNBLOCKING_DATA; -constexpr int HistorySync_HistorySyncType_HistorySyncType_ARRAYSIZE = HistorySync_HistorySyncType_HistorySyncType_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HistorySync_HistorySyncType_descriptor(); -template -inline const std::string& HistorySync_HistorySyncType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function HistorySync_HistorySyncType_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - HistorySync_HistorySyncType_descriptor(), enum_t_value); -} -inline bool HistorySync_HistorySyncType_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, HistorySync_HistorySyncType* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - HistorySync_HistorySyncType_descriptor(), name, value); -} -enum MediaRetryNotification_ResultType : int { - MediaRetryNotification_ResultType_GENERAL_ERROR = 0, - MediaRetryNotification_ResultType_SUCCESS = 1, - MediaRetryNotification_ResultType_NOT_FOUND = 2, - MediaRetryNotification_ResultType_DECRYPTION_ERROR = 3 -}; -bool MediaRetryNotification_ResultType_IsValid(int value); -constexpr MediaRetryNotification_ResultType MediaRetryNotification_ResultType_ResultType_MIN = MediaRetryNotification_ResultType_GENERAL_ERROR; -constexpr MediaRetryNotification_ResultType MediaRetryNotification_ResultType_ResultType_MAX = MediaRetryNotification_ResultType_DECRYPTION_ERROR; -constexpr int MediaRetryNotification_ResultType_ResultType_ARRAYSIZE = MediaRetryNotification_ResultType_ResultType_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MediaRetryNotification_ResultType_descriptor(); -template -inline const std::string& MediaRetryNotification_ResultType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function MediaRetryNotification_ResultType_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - MediaRetryNotification_ResultType_descriptor(), enum_t_value); -} -inline bool MediaRetryNotification_ResultType_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MediaRetryNotification_ResultType* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - MediaRetryNotification_ResultType_descriptor(), name, value); -} -enum Message_ButtonsMessage_Button_Type : int { - Message_ButtonsMessage_Button_Type_UNKNOWN = 0, - Message_ButtonsMessage_Button_Type_RESPONSE = 1, - Message_ButtonsMessage_Button_Type_NATIVE_FLOW = 2 -}; -bool Message_ButtonsMessage_Button_Type_IsValid(int value); -constexpr Message_ButtonsMessage_Button_Type Message_ButtonsMessage_Button_Type_Type_MIN = Message_ButtonsMessage_Button_Type_UNKNOWN; -constexpr Message_ButtonsMessage_Button_Type Message_ButtonsMessage_Button_Type_Type_MAX = Message_ButtonsMessage_Button_Type_NATIVE_FLOW; -constexpr int Message_ButtonsMessage_Button_Type_Type_ARRAYSIZE = Message_ButtonsMessage_Button_Type_Type_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ButtonsMessage_Button_Type_descriptor(); -template -inline const std::string& Message_ButtonsMessage_Button_Type_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Message_ButtonsMessage_Button_Type_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - Message_ButtonsMessage_Button_Type_descriptor(), enum_t_value); -} -inline bool Message_ButtonsMessage_Button_Type_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ButtonsMessage_Button_Type* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - Message_ButtonsMessage_Button_Type_descriptor(), name, value); -} -enum Message_ButtonsMessage_HeaderType : int { - Message_ButtonsMessage_HeaderType_UNKNOWN = 0, - Message_ButtonsMessage_HeaderType_EMPTY = 1, - Message_ButtonsMessage_HeaderType_TEXT = 2, - Message_ButtonsMessage_HeaderType_DOCUMENT = 3, - Message_ButtonsMessage_HeaderType_IMAGE = 4, - Message_ButtonsMessage_HeaderType_VIDEO = 5, - Message_ButtonsMessage_HeaderType_LOCATION = 6 -}; -bool Message_ButtonsMessage_HeaderType_IsValid(int value); -constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage_HeaderType_HeaderType_MIN = Message_ButtonsMessage_HeaderType_UNKNOWN; -constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage_HeaderType_HeaderType_MAX = Message_ButtonsMessage_HeaderType_LOCATION; -constexpr int Message_ButtonsMessage_HeaderType_HeaderType_ARRAYSIZE = Message_ButtonsMessage_HeaderType_HeaderType_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ButtonsMessage_HeaderType_descriptor(); -template -inline const std::string& Message_ButtonsMessage_HeaderType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Message_ButtonsMessage_HeaderType_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - Message_ButtonsMessage_HeaderType_descriptor(), enum_t_value); -} -inline bool Message_ButtonsMessage_HeaderType_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ButtonsMessage_HeaderType* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - Message_ButtonsMessage_HeaderType_descriptor(), name, value); -} -enum Message_ButtonsResponseMessage_Type : int { - Message_ButtonsResponseMessage_Type_UNKNOWN = 0, - Message_ButtonsResponseMessage_Type_DISPLAY_TEXT = 1 -}; -bool Message_ButtonsResponseMessage_Type_IsValid(int value); -constexpr Message_ButtonsResponseMessage_Type Message_ButtonsResponseMessage_Type_Type_MIN = Message_ButtonsResponseMessage_Type_UNKNOWN; -constexpr Message_ButtonsResponseMessage_Type Message_ButtonsResponseMessage_Type_Type_MAX = Message_ButtonsResponseMessage_Type_DISPLAY_TEXT; -constexpr int Message_ButtonsResponseMessage_Type_Type_ARRAYSIZE = Message_ButtonsResponseMessage_Type_Type_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ButtonsResponseMessage_Type_descriptor(); -template -inline const std::string& Message_ButtonsResponseMessage_Type_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Message_ButtonsResponseMessage_Type_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - Message_ButtonsResponseMessage_Type_descriptor(), enum_t_value); -} -inline bool Message_ButtonsResponseMessage_Type_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ButtonsResponseMessage_Type* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - Message_ButtonsResponseMessage_Type_descriptor(), name, value); -} -enum Message_ExtendedTextMessage_FontType : int { - Message_ExtendedTextMessage_FontType_SANS_SERIF = 0, - Message_ExtendedTextMessage_FontType_SERIF = 1, - Message_ExtendedTextMessage_FontType_NORICAN_REGULAR = 2, - Message_ExtendedTextMessage_FontType_BRYNDAN_WRITE = 3, - Message_ExtendedTextMessage_FontType_BEBASNEUE_REGULAR = 4, - Message_ExtendedTextMessage_FontType_OSWALD_HEAVY = 5 -}; -bool Message_ExtendedTextMessage_FontType_IsValid(int value); -constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage_FontType_FontType_MIN = Message_ExtendedTextMessage_FontType_SANS_SERIF; -constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage_FontType_FontType_MAX = Message_ExtendedTextMessage_FontType_OSWALD_HEAVY; -constexpr int Message_ExtendedTextMessage_FontType_FontType_ARRAYSIZE = Message_ExtendedTextMessage_FontType_FontType_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ExtendedTextMessage_FontType_descriptor(); -template -inline const std::string& Message_ExtendedTextMessage_FontType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Message_ExtendedTextMessage_FontType_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - Message_ExtendedTextMessage_FontType_descriptor(), enum_t_value); -} -inline bool Message_ExtendedTextMessage_FontType_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ExtendedTextMessage_FontType* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - Message_ExtendedTextMessage_FontType_descriptor(), name, value); -} -enum Message_ExtendedTextMessage_InviteLinkGroupType : int { - Message_ExtendedTextMessage_InviteLinkGroupType_DEFAULT = 0, - Message_ExtendedTextMessage_InviteLinkGroupType_PARENT = 1, - Message_ExtendedTextMessage_InviteLinkGroupType_SUB = 2, - Message_ExtendedTextMessage_InviteLinkGroupType_DEFAULT_SUB = 3 -}; -bool Message_ExtendedTextMessage_InviteLinkGroupType_IsValid(int value); -constexpr Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage_InviteLinkGroupType_InviteLinkGroupType_MIN = Message_ExtendedTextMessage_InviteLinkGroupType_DEFAULT; -constexpr Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage_InviteLinkGroupType_InviteLinkGroupType_MAX = Message_ExtendedTextMessage_InviteLinkGroupType_DEFAULT_SUB; -constexpr int Message_ExtendedTextMessage_InviteLinkGroupType_InviteLinkGroupType_ARRAYSIZE = Message_ExtendedTextMessage_InviteLinkGroupType_InviteLinkGroupType_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ExtendedTextMessage_InviteLinkGroupType_descriptor(); -template -inline const std::string& Message_ExtendedTextMessage_InviteLinkGroupType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Message_ExtendedTextMessage_InviteLinkGroupType_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - Message_ExtendedTextMessage_InviteLinkGroupType_descriptor(), enum_t_value); -} -inline bool Message_ExtendedTextMessage_InviteLinkGroupType_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ExtendedTextMessage_InviteLinkGroupType* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - Message_ExtendedTextMessage_InviteLinkGroupType_descriptor(), name, value); -} -enum Message_ExtendedTextMessage_PreviewType : int { - Message_ExtendedTextMessage_PreviewType_NONE = 0, - Message_ExtendedTextMessage_PreviewType_VIDEO = 1 -}; -bool Message_ExtendedTextMessage_PreviewType_IsValid(int value); -constexpr Message_ExtendedTextMessage_PreviewType Message_ExtendedTextMessage_PreviewType_PreviewType_MIN = Message_ExtendedTextMessage_PreviewType_NONE; -constexpr Message_ExtendedTextMessage_PreviewType Message_ExtendedTextMessage_PreviewType_PreviewType_MAX = Message_ExtendedTextMessage_PreviewType_VIDEO; -constexpr int Message_ExtendedTextMessage_PreviewType_PreviewType_ARRAYSIZE = Message_ExtendedTextMessage_PreviewType_PreviewType_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ExtendedTextMessage_PreviewType_descriptor(); -template -inline const std::string& Message_ExtendedTextMessage_PreviewType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Message_ExtendedTextMessage_PreviewType_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - Message_ExtendedTextMessage_PreviewType_descriptor(), enum_t_value); -} -inline bool Message_ExtendedTextMessage_PreviewType_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ExtendedTextMessage_PreviewType* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - Message_ExtendedTextMessage_PreviewType_descriptor(), name, value); -} -enum Message_GroupInviteMessage_GroupType : int { - Message_GroupInviteMessage_GroupType_DEFAULT = 0, - Message_GroupInviteMessage_GroupType_PARENT = 1 -}; -bool Message_GroupInviteMessage_GroupType_IsValid(int value); -constexpr Message_GroupInviteMessage_GroupType Message_GroupInviteMessage_GroupType_GroupType_MIN = Message_GroupInviteMessage_GroupType_DEFAULT; -constexpr Message_GroupInviteMessage_GroupType Message_GroupInviteMessage_GroupType_GroupType_MAX = Message_GroupInviteMessage_GroupType_PARENT; -constexpr int Message_GroupInviteMessage_GroupType_GroupType_ARRAYSIZE = Message_GroupInviteMessage_GroupType_GroupType_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_GroupInviteMessage_GroupType_descriptor(); -template -inline const std::string& Message_GroupInviteMessage_GroupType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Message_GroupInviteMessage_GroupType_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - Message_GroupInviteMessage_GroupType_descriptor(), enum_t_value); -} -inline bool Message_GroupInviteMessage_GroupType_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_GroupInviteMessage_GroupType* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - Message_GroupInviteMessage_GroupType_descriptor(), name, value); -} -enum Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType : int { - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_GREGORIAN = 1, - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_SOLAR_HIJRI = 2 -}; -bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_IsValid(int value); -constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_CalendarType_MIN = Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_GREGORIAN; -constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_CalendarType_MAX = Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_SOLAR_HIJRI; -constexpr int Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_CalendarType_ARRAYSIZE = Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_CalendarType_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_descriptor(); -template -inline const std::string& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_descriptor(), enum_t_value); -} -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_descriptor(), name, value); -} -enum Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType : int { - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_MONDAY = 1, - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_TUESDAY = 2, - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_WEDNESDAY = 3, - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_THURSDAY = 4, - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_FRIDAY = 5, - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_SATURDAY = 6, - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_SUNDAY = 7 -}; -bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_IsValid(int value); -constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_DayOfWeekType_MIN = Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_MONDAY; -constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_DayOfWeekType_MAX = Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_SUNDAY; -constexpr int Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_DayOfWeekType_ARRAYSIZE = Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_DayOfWeekType_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_descriptor(); -template -inline const std::string& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_descriptor(), enum_t_value); -} -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_descriptor(), name, value); -} -enum Message_HistorySyncNotification_HistorySyncType : int { - Message_HistorySyncNotification_HistorySyncType_INITIAL_BOOTSTRAP = 0, - Message_HistorySyncNotification_HistorySyncType_INITIAL_STATUS_V3 = 1, - Message_HistorySyncNotification_HistorySyncType_FULL = 2, - Message_HistorySyncNotification_HistorySyncType_RECENT = 3, - Message_HistorySyncNotification_HistorySyncType_PUSH_NAME = 4 -}; -bool Message_HistorySyncNotification_HistorySyncType_IsValid(int value); -constexpr Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification_HistorySyncType_HistorySyncType_MIN = Message_HistorySyncNotification_HistorySyncType_INITIAL_BOOTSTRAP; -constexpr Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification_HistorySyncType_HistorySyncType_MAX = Message_HistorySyncNotification_HistorySyncType_PUSH_NAME; -constexpr int Message_HistorySyncNotification_HistorySyncType_HistorySyncType_ARRAYSIZE = Message_HistorySyncNotification_HistorySyncType_HistorySyncType_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_HistorySyncNotification_HistorySyncType_descriptor(); -template -inline const std::string& Message_HistorySyncNotification_HistorySyncType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Message_HistorySyncNotification_HistorySyncType_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - Message_HistorySyncNotification_HistorySyncType_descriptor(), enum_t_value); -} -inline bool Message_HistorySyncNotification_HistorySyncType_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_HistorySyncNotification_HistorySyncType* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - Message_HistorySyncNotification_HistorySyncType_descriptor(), name, value); -} -enum Message_InteractiveMessage_ShopMessage_Surface : int { - Message_InteractiveMessage_ShopMessage_Surface_UNKNOWN_SURFACE = 0, - Message_InteractiveMessage_ShopMessage_Surface_FB = 1, - Message_InteractiveMessage_ShopMessage_Surface_IG = 2, - Message_InteractiveMessage_ShopMessage_Surface_WA = 3 -}; -bool Message_InteractiveMessage_ShopMessage_Surface_IsValid(int value); -constexpr Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage_Surface_Surface_MIN = Message_InteractiveMessage_ShopMessage_Surface_UNKNOWN_SURFACE; -constexpr Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage_Surface_Surface_MAX = Message_InteractiveMessage_ShopMessage_Surface_WA; -constexpr int Message_InteractiveMessage_ShopMessage_Surface_Surface_ARRAYSIZE = Message_InteractiveMessage_ShopMessage_Surface_Surface_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_InteractiveMessage_ShopMessage_Surface_descriptor(); -template -inline const std::string& Message_InteractiveMessage_ShopMessage_Surface_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Message_InteractiveMessage_ShopMessage_Surface_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - Message_InteractiveMessage_ShopMessage_Surface_descriptor(), enum_t_value); -} -inline bool Message_InteractiveMessage_ShopMessage_Surface_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_InteractiveMessage_ShopMessage_Surface* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - Message_InteractiveMessage_ShopMessage_Surface_descriptor(), name, value); -} -enum Message_InvoiceMessage_AttachmentType : int { - Message_InvoiceMessage_AttachmentType_IMAGE = 0, - Message_InvoiceMessage_AttachmentType_PDF = 1 -}; -bool Message_InvoiceMessage_AttachmentType_IsValid(int value); -constexpr Message_InvoiceMessage_AttachmentType Message_InvoiceMessage_AttachmentType_AttachmentType_MIN = Message_InvoiceMessage_AttachmentType_IMAGE; -constexpr Message_InvoiceMessage_AttachmentType Message_InvoiceMessage_AttachmentType_AttachmentType_MAX = Message_InvoiceMessage_AttachmentType_PDF; -constexpr int Message_InvoiceMessage_AttachmentType_AttachmentType_ARRAYSIZE = Message_InvoiceMessage_AttachmentType_AttachmentType_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_InvoiceMessage_AttachmentType_descriptor(); -template -inline const std::string& Message_InvoiceMessage_AttachmentType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Message_InvoiceMessage_AttachmentType_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - Message_InvoiceMessage_AttachmentType_descriptor(), enum_t_value); -} -inline bool Message_InvoiceMessage_AttachmentType_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_InvoiceMessage_AttachmentType* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - Message_InvoiceMessage_AttachmentType_descriptor(), name, value); -} -enum Message_ListMessage_ListType : int { - Message_ListMessage_ListType_UNKNOWN = 0, - Message_ListMessage_ListType_SINGLE_SELECT = 1, - Message_ListMessage_ListType_PRODUCT_LIST = 2 -}; -bool Message_ListMessage_ListType_IsValid(int value); -constexpr Message_ListMessage_ListType Message_ListMessage_ListType_ListType_MIN = Message_ListMessage_ListType_UNKNOWN; -constexpr Message_ListMessage_ListType Message_ListMessage_ListType_ListType_MAX = Message_ListMessage_ListType_PRODUCT_LIST; -constexpr int Message_ListMessage_ListType_ListType_ARRAYSIZE = Message_ListMessage_ListType_ListType_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ListMessage_ListType_descriptor(); -template -inline const std::string& Message_ListMessage_ListType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Message_ListMessage_ListType_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - Message_ListMessage_ListType_descriptor(), enum_t_value); -} -inline bool Message_ListMessage_ListType_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ListMessage_ListType* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - Message_ListMessage_ListType_descriptor(), name, value); -} -enum Message_ListResponseMessage_ListType : int { - Message_ListResponseMessage_ListType_UNKNOWN = 0, - Message_ListResponseMessage_ListType_SINGLE_SELECT = 1 -}; -bool Message_ListResponseMessage_ListType_IsValid(int value); -constexpr Message_ListResponseMessage_ListType Message_ListResponseMessage_ListType_ListType_MIN = Message_ListResponseMessage_ListType_UNKNOWN; -constexpr Message_ListResponseMessage_ListType Message_ListResponseMessage_ListType_ListType_MAX = Message_ListResponseMessage_ListType_SINGLE_SELECT; -constexpr int Message_ListResponseMessage_ListType_ListType_ARRAYSIZE = Message_ListResponseMessage_ListType_ListType_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ListResponseMessage_ListType_descriptor(); -template -inline const std::string& Message_ListResponseMessage_ListType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Message_ListResponseMessage_ListType_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - Message_ListResponseMessage_ListType_descriptor(), enum_t_value); -} -inline bool Message_ListResponseMessage_ListType_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ListResponseMessage_ListType* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - Message_ListResponseMessage_ListType_descriptor(), name, value); -} -enum Message_OrderMessage_OrderStatus : int { - Message_OrderMessage_OrderStatus_INQUIRY = 1 -}; -bool Message_OrderMessage_OrderStatus_IsValid(int value); -constexpr Message_OrderMessage_OrderStatus Message_OrderMessage_OrderStatus_OrderStatus_MIN = Message_OrderMessage_OrderStatus_INQUIRY; -constexpr Message_OrderMessage_OrderStatus Message_OrderMessage_OrderStatus_OrderStatus_MAX = Message_OrderMessage_OrderStatus_INQUIRY; -constexpr int Message_OrderMessage_OrderStatus_OrderStatus_ARRAYSIZE = Message_OrderMessage_OrderStatus_OrderStatus_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_OrderMessage_OrderStatus_descriptor(); -template -inline const std::string& Message_OrderMessage_OrderStatus_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Message_OrderMessage_OrderStatus_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - Message_OrderMessage_OrderStatus_descriptor(), enum_t_value); -} -inline bool Message_OrderMessage_OrderStatus_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_OrderMessage_OrderStatus* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - Message_OrderMessage_OrderStatus_descriptor(), name, value); -} -enum Message_OrderMessage_OrderSurface : int { - Message_OrderMessage_OrderSurface_CATALOG = 1 -}; -bool Message_OrderMessage_OrderSurface_IsValid(int value); -constexpr Message_OrderMessage_OrderSurface Message_OrderMessage_OrderSurface_OrderSurface_MIN = Message_OrderMessage_OrderSurface_CATALOG; -constexpr Message_OrderMessage_OrderSurface Message_OrderMessage_OrderSurface_OrderSurface_MAX = Message_OrderMessage_OrderSurface_CATALOG; -constexpr int Message_OrderMessage_OrderSurface_OrderSurface_ARRAYSIZE = Message_OrderMessage_OrderSurface_OrderSurface_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_OrderMessage_OrderSurface_descriptor(); -template -inline const std::string& Message_OrderMessage_OrderSurface_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Message_OrderMessage_OrderSurface_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - Message_OrderMessage_OrderSurface_descriptor(), enum_t_value); -} -inline bool Message_OrderMessage_OrderSurface_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_OrderMessage_OrderSurface* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - Message_OrderMessage_OrderSurface_descriptor(), name, value); -} -enum Message_PaymentInviteMessage_ServiceType : int { - Message_PaymentInviteMessage_ServiceType_UNKNOWN = 0, - Message_PaymentInviteMessage_ServiceType_FBPAY = 1, - Message_PaymentInviteMessage_ServiceType_NOVI = 2, - Message_PaymentInviteMessage_ServiceType_UPI = 3 -}; -bool Message_PaymentInviteMessage_ServiceType_IsValid(int value); -constexpr Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage_ServiceType_ServiceType_MIN = Message_PaymentInviteMessage_ServiceType_UNKNOWN; -constexpr Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage_ServiceType_ServiceType_MAX = Message_PaymentInviteMessage_ServiceType_UPI; -constexpr int Message_PaymentInviteMessage_ServiceType_ServiceType_ARRAYSIZE = Message_PaymentInviteMessage_ServiceType_ServiceType_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_PaymentInviteMessage_ServiceType_descriptor(); -template -inline const std::string& Message_PaymentInviteMessage_ServiceType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Message_PaymentInviteMessage_ServiceType_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - Message_PaymentInviteMessage_ServiceType_descriptor(), enum_t_value); -} -inline bool Message_PaymentInviteMessage_ServiceType_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_PaymentInviteMessage_ServiceType* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - Message_PaymentInviteMessage_ServiceType_descriptor(), name, value); -} -enum Message_ProtocolMessage_Type : int { - Message_ProtocolMessage_Type_REVOKE = 0, - Message_ProtocolMessage_Type_EPHEMERAL_SETTING = 3, - Message_ProtocolMessage_Type_EPHEMERAL_SYNC_RESPONSE = 4, - Message_ProtocolMessage_Type_HISTORY_SYNC_NOTIFICATION = 5, - Message_ProtocolMessage_Type_APP_STATE_SYNC_KEY_SHARE = 6, - Message_ProtocolMessage_Type_APP_STATE_SYNC_KEY_REQUEST = 7, - Message_ProtocolMessage_Type_MSG_FANOUT_BACKFILL_REQUEST = 8, - Message_ProtocolMessage_Type_INITIAL_SECURITY_NOTIFICATION_SETTING_SYNC = 9, - Message_ProtocolMessage_Type_APP_STATE_FATAL_EXCEPTION_NOTIFICATION = 10, - Message_ProtocolMessage_Type_SHARE_PHONE_NUMBER = 11, - Message_ProtocolMessage_Type_REQUEST_MEDIA_UPLOAD_MESSAGE = 12, - Message_ProtocolMessage_Type_REQUEST_MEDIA_UPLOAD_RESPONSE_MESSAGE = 13 -}; -bool Message_ProtocolMessage_Type_IsValid(int value); -constexpr Message_ProtocolMessage_Type Message_ProtocolMessage_Type_Type_MIN = Message_ProtocolMessage_Type_REVOKE; -constexpr Message_ProtocolMessage_Type Message_ProtocolMessage_Type_Type_MAX = Message_ProtocolMessage_Type_REQUEST_MEDIA_UPLOAD_RESPONSE_MESSAGE; -constexpr int Message_ProtocolMessage_Type_Type_ARRAYSIZE = Message_ProtocolMessage_Type_Type_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ProtocolMessage_Type_descriptor(); -template -inline const std::string& Message_ProtocolMessage_Type_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Message_ProtocolMessage_Type_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - Message_ProtocolMessage_Type_descriptor(), enum_t_value); -} -inline bool Message_ProtocolMessage_Type_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ProtocolMessage_Type* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - Message_ProtocolMessage_Type_descriptor(), name, value); -} -enum Message_VideoMessage_Attribution : int { - Message_VideoMessage_Attribution_NONE = 0, - Message_VideoMessage_Attribution_GIPHY = 1, - Message_VideoMessage_Attribution_TENOR = 2 -}; -bool Message_VideoMessage_Attribution_IsValid(int value); -constexpr Message_VideoMessage_Attribution Message_VideoMessage_Attribution_Attribution_MIN = Message_VideoMessage_Attribution_NONE; -constexpr Message_VideoMessage_Attribution Message_VideoMessage_Attribution_Attribution_MAX = Message_VideoMessage_Attribution_TENOR; -constexpr int Message_VideoMessage_Attribution_Attribution_ARRAYSIZE = Message_VideoMessage_Attribution_Attribution_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_VideoMessage_Attribution_descriptor(); -template -inline const std::string& Message_VideoMessage_Attribution_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Message_VideoMessage_Attribution_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - Message_VideoMessage_Attribution_descriptor(), enum_t_value); -} -inline bool Message_VideoMessage_Attribution_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_VideoMessage_Attribution* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - Message_VideoMessage_Attribution_descriptor(), name, value); -} -enum Message_RmrSource : int { - Message_RmrSource_FAVORITE_STICKER = 0, - Message_RmrSource_RECENT_STICKER = 1 -}; -bool Message_RmrSource_IsValid(int value); -constexpr Message_RmrSource Message_RmrSource_RmrSource_MIN = Message_RmrSource_FAVORITE_STICKER; -constexpr Message_RmrSource Message_RmrSource_RmrSource_MAX = Message_RmrSource_RECENT_STICKER; -constexpr int Message_RmrSource_RmrSource_ARRAYSIZE = Message_RmrSource_RmrSource_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_RmrSource_descriptor(); -template -inline const std::string& Message_RmrSource_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Message_RmrSource_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - Message_RmrSource_descriptor(), enum_t_value); -} -inline bool Message_RmrSource_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_RmrSource* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - Message_RmrSource_descriptor(), name, value); -} -enum PastParticipant_LeaveReason : int { - PastParticipant_LeaveReason_LEFT = 0, - PastParticipant_LeaveReason_REMOVED = 1 -}; -bool PastParticipant_LeaveReason_IsValid(int value); -constexpr PastParticipant_LeaveReason PastParticipant_LeaveReason_LeaveReason_MIN = PastParticipant_LeaveReason_LEFT; -constexpr PastParticipant_LeaveReason PastParticipant_LeaveReason_LeaveReason_MAX = PastParticipant_LeaveReason_REMOVED; -constexpr int PastParticipant_LeaveReason_LeaveReason_ARRAYSIZE = PastParticipant_LeaveReason_LeaveReason_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PastParticipant_LeaveReason_descriptor(); -template -inline const std::string& PastParticipant_LeaveReason_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function PastParticipant_LeaveReason_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - PastParticipant_LeaveReason_descriptor(), enum_t_value); -} -inline bool PastParticipant_LeaveReason_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PastParticipant_LeaveReason* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - PastParticipant_LeaveReason_descriptor(), name, value); -} -enum PaymentBackground_Type : int { - PaymentBackground_Type_UNKNOWN = 0, - PaymentBackground_Type_DEFAULT = 1 -}; -bool PaymentBackground_Type_IsValid(int value); -constexpr PaymentBackground_Type PaymentBackground_Type_Type_MIN = PaymentBackground_Type_UNKNOWN; -constexpr PaymentBackground_Type PaymentBackground_Type_Type_MAX = PaymentBackground_Type_DEFAULT; -constexpr int PaymentBackground_Type_Type_ARRAYSIZE = PaymentBackground_Type_Type_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PaymentBackground_Type_descriptor(); -template -inline const std::string& PaymentBackground_Type_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function PaymentBackground_Type_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - PaymentBackground_Type_descriptor(), enum_t_value); -} -inline bool PaymentBackground_Type_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PaymentBackground_Type* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - PaymentBackground_Type_descriptor(), name, value); -} -enum PaymentInfo_Currency : int { - PaymentInfo_Currency_UNKNOWN_CURRENCY = 0, - PaymentInfo_Currency_INR = 1 -}; -bool PaymentInfo_Currency_IsValid(int value); -constexpr PaymentInfo_Currency PaymentInfo_Currency_Currency_MIN = PaymentInfo_Currency_UNKNOWN_CURRENCY; -constexpr PaymentInfo_Currency PaymentInfo_Currency_Currency_MAX = PaymentInfo_Currency_INR; -constexpr int PaymentInfo_Currency_Currency_ARRAYSIZE = PaymentInfo_Currency_Currency_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PaymentInfo_Currency_descriptor(); -template -inline const std::string& PaymentInfo_Currency_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function PaymentInfo_Currency_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - PaymentInfo_Currency_descriptor(), enum_t_value); -} -inline bool PaymentInfo_Currency_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PaymentInfo_Currency* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - PaymentInfo_Currency_descriptor(), name, value); -} -enum PaymentInfo_Status : int { - PaymentInfo_Status_UNKNOWN_STATUS = 0, - PaymentInfo_Status_PROCESSING = 1, - PaymentInfo_Status_SENT = 2, - PaymentInfo_Status_NEED_TO_ACCEPT = 3, - PaymentInfo_Status_COMPLETE = 4, - PaymentInfo_Status_COULD_NOT_COMPLETE = 5, - PaymentInfo_Status_REFUNDED = 6, - PaymentInfo_Status_EXPIRED = 7, - PaymentInfo_Status_REJECTED = 8, - PaymentInfo_Status_CANCELLED = 9, - PaymentInfo_Status_WAITING_FOR_PAYER = 10, - PaymentInfo_Status_WAITING = 11 -}; -bool PaymentInfo_Status_IsValid(int value); -constexpr PaymentInfo_Status PaymentInfo_Status_Status_MIN = PaymentInfo_Status_UNKNOWN_STATUS; -constexpr PaymentInfo_Status PaymentInfo_Status_Status_MAX = PaymentInfo_Status_WAITING; -constexpr int PaymentInfo_Status_Status_ARRAYSIZE = PaymentInfo_Status_Status_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PaymentInfo_Status_descriptor(); -template -inline const std::string& PaymentInfo_Status_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function PaymentInfo_Status_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - PaymentInfo_Status_descriptor(), enum_t_value); -} -inline bool PaymentInfo_Status_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PaymentInfo_Status* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - PaymentInfo_Status_descriptor(), name, value); -} -enum PaymentInfo_TxnStatus : int { - PaymentInfo_TxnStatus_UNKNOWN = 0, - PaymentInfo_TxnStatus_PENDING_SETUP = 1, - PaymentInfo_TxnStatus_PENDING_RECEIVER_SETUP = 2, - PaymentInfo_TxnStatus_INIT = 3, - PaymentInfo_TxnStatus_SUCCESS = 4, - PaymentInfo_TxnStatus_COMPLETED = 5, - PaymentInfo_TxnStatus_FAILED = 6, - PaymentInfo_TxnStatus_FAILED_RISK = 7, - PaymentInfo_TxnStatus_FAILED_PROCESSING = 8, - PaymentInfo_TxnStatus_FAILED_RECEIVER_PROCESSING = 9, - PaymentInfo_TxnStatus_FAILED_DA = 10, - PaymentInfo_TxnStatus_FAILED_DA_FINAL = 11, - PaymentInfo_TxnStatus_REFUNDED_TXN = 12, - PaymentInfo_TxnStatus_REFUND_FAILED = 13, - PaymentInfo_TxnStatus_REFUND_FAILED_PROCESSING = 14, - PaymentInfo_TxnStatus_REFUND_FAILED_DA = 15, - PaymentInfo_TxnStatus_EXPIRED_TXN = 16, - PaymentInfo_TxnStatus_AUTH_CANCELED = 17, - PaymentInfo_TxnStatus_AUTH_CANCEL_FAILED_PROCESSING = 18, - PaymentInfo_TxnStatus_AUTH_CANCEL_FAILED = 19, - PaymentInfo_TxnStatus_COLLECT_INIT = 20, - PaymentInfo_TxnStatus_COLLECT_SUCCESS = 21, - PaymentInfo_TxnStatus_COLLECT_FAILED = 22, - PaymentInfo_TxnStatus_COLLECT_FAILED_RISK = 23, - PaymentInfo_TxnStatus_COLLECT_REJECTED = 24, - PaymentInfo_TxnStatus_COLLECT_EXPIRED = 25, - PaymentInfo_TxnStatus_COLLECT_CANCELED = 26, - PaymentInfo_TxnStatus_COLLECT_CANCELLING = 27, - PaymentInfo_TxnStatus_IN_REVIEW = 28, - PaymentInfo_TxnStatus_REVERSAL_SUCCESS = 29, - PaymentInfo_TxnStatus_REVERSAL_PENDING = 30, - PaymentInfo_TxnStatus_REFUND_PENDING = 31 -}; -bool PaymentInfo_TxnStatus_IsValid(int value); -constexpr PaymentInfo_TxnStatus PaymentInfo_TxnStatus_TxnStatus_MIN = PaymentInfo_TxnStatus_UNKNOWN; -constexpr PaymentInfo_TxnStatus PaymentInfo_TxnStatus_TxnStatus_MAX = PaymentInfo_TxnStatus_REFUND_PENDING; -constexpr int PaymentInfo_TxnStatus_TxnStatus_ARRAYSIZE = PaymentInfo_TxnStatus_TxnStatus_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PaymentInfo_TxnStatus_descriptor(); -template -inline const std::string& PaymentInfo_TxnStatus_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function PaymentInfo_TxnStatus_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - PaymentInfo_TxnStatus_descriptor(), enum_t_value); -} -inline bool PaymentInfo_TxnStatus_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PaymentInfo_TxnStatus* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - PaymentInfo_TxnStatus_descriptor(), name, value); -} -enum SyncdMutation_SyncdOperation : int { - SyncdMutation_SyncdOperation_SET = 0, - SyncdMutation_SyncdOperation_REMOVE = 1 -}; -bool SyncdMutation_SyncdOperation_IsValid(int value); -constexpr SyncdMutation_SyncdOperation SyncdMutation_SyncdOperation_SyncdOperation_MIN = SyncdMutation_SyncdOperation_SET; -constexpr SyncdMutation_SyncdOperation SyncdMutation_SyncdOperation_SyncdOperation_MAX = SyncdMutation_SyncdOperation_REMOVE; -constexpr int SyncdMutation_SyncdOperation_SyncdOperation_ARRAYSIZE = SyncdMutation_SyncdOperation_SyncdOperation_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SyncdMutation_SyncdOperation_descriptor(); -template -inline const std::string& SyncdMutation_SyncdOperation_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function SyncdMutation_SyncdOperation_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - SyncdMutation_SyncdOperation_descriptor(), enum_t_value); -} -inline bool SyncdMutation_SyncdOperation_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SyncdMutation_SyncdOperation* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - SyncdMutation_SyncdOperation_descriptor(), name, value); -} -enum WebFeatures_Flag : int { - WebFeatures_Flag_NOT_STARTED = 0, - WebFeatures_Flag_FORCE_UPGRADE = 1, - WebFeatures_Flag_DEVELOPMENT = 2, - WebFeatures_Flag_PRODUCTION = 3 -}; -bool WebFeatures_Flag_IsValid(int value); -constexpr WebFeatures_Flag WebFeatures_Flag_Flag_MIN = WebFeatures_Flag_NOT_STARTED; -constexpr WebFeatures_Flag WebFeatures_Flag_Flag_MAX = WebFeatures_Flag_PRODUCTION; -constexpr int WebFeatures_Flag_Flag_ARRAYSIZE = WebFeatures_Flag_Flag_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WebFeatures_Flag_descriptor(); -template -inline const std::string& WebFeatures_Flag_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function WebFeatures_Flag_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - WebFeatures_Flag_descriptor(), enum_t_value); -} -inline bool WebFeatures_Flag_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WebFeatures_Flag* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - WebFeatures_Flag_descriptor(), name, value); -} -enum WebMessageInfo_BizPrivacyStatus : int { - WebMessageInfo_BizPrivacyStatus_E2EE = 0, - WebMessageInfo_BizPrivacyStatus_FB = 2, - WebMessageInfo_BizPrivacyStatus_BSP = 1, - WebMessageInfo_BizPrivacyStatus_BSP_AND_FB = 3 -}; -bool WebMessageInfo_BizPrivacyStatus_IsValid(int value); -constexpr WebMessageInfo_BizPrivacyStatus WebMessageInfo_BizPrivacyStatus_BizPrivacyStatus_MIN = WebMessageInfo_BizPrivacyStatus_E2EE; -constexpr WebMessageInfo_BizPrivacyStatus WebMessageInfo_BizPrivacyStatus_BizPrivacyStatus_MAX = WebMessageInfo_BizPrivacyStatus_BSP_AND_FB; -constexpr int WebMessageInfo_BizPrivacyStatus_BizPrivacyStatus_ARRAYSIZE = WebMessageInfo_BizPrivacyStatus_BizPrivacyStatus_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WebMessageInfo_BizPrivacyStatus_descriptor(); -template -inline const std::string& WebMessageInfo_BizPrivacyStatus_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function WebMessageInfo_BizPrivacyStatus_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - WebMessageInfo_BizPrivacyStatus_descriptor(), enum_t_value); -} -inline bool WebMessageInfo_BizPrivacyStatus_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WebMessageInfo_BizPrivacyStatus* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - WebMessageInfo_BizPrivacyStatus_descriptor(), name, value); -} -enum WebMessageInfo_Status : int { - WebMessageInfo_Status_ERROR = 0, - WebMessageInfo_Status_PENDING = 1, - WebMessageInfo_Status_SERVER_ACK = 2, - WebMessageInfo_Status_DELIVERY_ACK = 3, - WebMessageInfo_Status_READ = 4, - WebMessageInfo_Status_PLAYED = 5 -}; -bool WebMessageInfo_Status_IsValid(int value); -constexpr WebMessageInfo_Status WebMessageInfo_Status_Status_MIN = WebMessageInfo_Status_ERROR; -constexpr WebMessageInfo_Status WebMessageInfo_Status_Status_MAX = WebMessageInfo_Status_PLAYED; -constexpr int WebMessageInfo_Status_Status_ARRAYSIZE = WebMessageInfo_Status_Status_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WebMessageInfo_Status_descriptor(); -template -inline const std::string& WebMessageInfo_Status_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function WebMessageInfo_Status_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - WebMessageInfo_Status_descriptor(), enum_t_value); -} -inline bool WebMessageInfo_Status_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WebMessageInfo_Status* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - WebMessageInfo_Status_descriptor(), name, value); -} -enum WebMessageInfo_StubType : int { - WebMessageInfo_StubType_UNKNOWN = 0, - WebMessageInfo_StubType_REVOKE = 1, - WebMessageInfo_StubType_CIPHERTEXT = 2, - WebMessageInfo_StubType_FUTUREPROOF = 3, - WebMessageInfo_StubType_NON_VERIFIED_TRANSITION = 4, - WebMessageInfo_StubType_UNVERIFIED_TRANSITION = 5, - WebMessageInfo_StubType_VERIFIED_TRANSITION = 6, - WebMessageInfo_StubType_VERIFIED_LOW_UNKNOWN = 7, - WebMessageInfo_StubType_VERIFIED_HIGH = 8, - WebMessageInfo_StubType_VERIFIED_INITIAL_UNKNOWN = 9, - WebMessageInfo_StubType_VERIFIED_INITIAL_LOW = 10, - WebMessageInfo_StubType_VERIFIED_INITIAL_HIGH = 11, - WebMessageInfo_StubType_VERIFIED_TRANSITION_ANY_TO_NONE = 12, - WebMessageInfo_StubType_VERIFIED_TRANSITION_ANY_TO_HIGH = 13, - WebMessageInfo_StubType_VERIFIED_TRANSITION_HIGH_TO_LOW = 14, - WebMessageInfo_StubType_VERIFIED_TRANSITION_HIGH_TO_UNKNOWN = 15, - WebMessageInfo_StubType_VERIFIED_TRANSITION_UNKNOWN_TO_LOW = 16, - WebMessageInfo_StubType_VERIFIED_TRANSITION_LOW_TO_UNKNOWN = 17, - WebMessageInfo_StubType_VERIFIED_TRANSITION_NONE_TO_LOW = 18, - WebMessageInfo_StubType_VERIFIED_TRANSITION_NONE_TO_UNKNOWN = 19, - WebMessageInfo_StubType_GROUP_CREATE = 20, - WebMessageInfo_StubType_GROUP_CHANGE_SUBJECT = 21, - WebMessageInfo_StubType_GROUP_CHANGE_ICON = 22, - WebMessageInfo_StubType_GROUP_CHANGE_INVITE_LINK = 23, - WebMessageInfo_StubType_GROUP_CHANGE_DESCRIPTION = 24, - WebMessageInfo_StubType_GROUP_CHANGE_RESTRICT = 25, - WebMessageInfo_StubType_GROUP_CHANGE_ANNOUNCE = 26, - WebMessageInfo_StubType_GROUP_PARTICIPANT_ADD = 27, - WebMessageInfo_StubType_GROUP_PARTICIPANT_REMOVE = 28, - WebMessageInfo_StubType_GROUP_PARTICIPANT_PROMOTE = 29, - WebMessageInfo_StubType_GROUP_PARTICIPANT_DEMOTE = 30, - WebMessageInfo_StubType_GROUP_PARTICIPANT_INVITE = 31, - WebMessageInfo_StubType_GROUP_PARTICIPANT_LEAVE = 32, - WebMessageInfo_StubType_GROUP_PARTICIPANT_CHANGE_NUMBER = 33, - WebMessageInfo_StubType_BROADCAST_CREATE = 34, - WebMessageInfo_StubType_BROADCAST_ADD = 35, - WebMessageInfo_StubType_BROADCAST_REMOVE = 36, - WebMessageInfo_StubType_GENERIC_NOTIFICATION = 37, - WebMessageInfo_StubType_E2E_IDENTITY_CHANGED = 38, - WebMessageInfo_StubType_E2E_ENCRYPTED = 39, - WebMessageInfo_StubType_CALL_MISSED_VOICE = 40, - WebMessageInfo_StubType_CALL_MISSED_VIDEO = 41, - WebMessageInfo_StubType_INDIVIDUAL_CHANGE_NUMBER = 42, - WebMessageInfo_StubType_GROUP_DELETE = 43, - WebMessageInfo_StubType_GROUP_ANNOUNCE_MODE_MESSAGE_BOUNCE = 44, - WebMessageInfo_StubType_CALL_MISSED_GROUP_VOICE = 45, - WebMessageInfo_StubType_CALL_MISSED_GROUP_VIDEO = 46, - WebMessageInfo_StubType_PAYMENT_CIPHERTEXT = 47, - WebMessageInfo_StubType_PAYMENT_FUTUREPROOF = 48, - WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_UPDATE_FAILED = 49, - WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_UPDATE_REFUNDED = 50, - WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_UPDATE_REFUND_FAILED = 51, - WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_RECEIVER_PENDING_SETUP = 52, - WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_RECEIVER_SUCCESS_AFTER_HICCUP = 53, - WebMessageInfo_StubType_PAYMENT_ACTION_ACCOUNT_SETUP_REMINDER = 54, - WebMessageInfo_StubType_PAYMENT_ACTION_SEND_PAYMENT_REMINDER = 55, - WebMessageInfo_StubType_PAYMENT_ACTION_SEND_PAYMENT_INVITATION = 56, - WebMessageInfo_StubType_PAYMENT_ACTION_REQUEST_DECLINED = 57, - WebMessageInfo_StubType_PAYMENT_ACTION_REQUEST_EXPIRED = 58, - WebMessageInfo_StubType_PAYMENT_ACTION_REQUEST_CANCELLED = 59, - WebMessageInfo_StubType_BIZ_VERIFIED_TRANSITION_TOP_TO_BOTTOM = 60, - WebMessageInfo_StubType_BIZ_VERIFIED_TRANSITION_BOTTOM_TO_TOP = 61, - WebMessageInfo_StubType_BIZ_INTRO_TOP = 62, - WebMessageInfo_StubType_BIZ_INTRO_BOTTOM = 63, - WebMessageInfo_StubType_BIZ_NAME_CHANGE = 64, - WebMessageInfo_StubType_BIZ_MOVE_TO_CONSUMER_APP = 65, - WebMessageInfo_StubType_BIZ_TWO_TIER_MIGRATION_TOP = 66, - WebMessageInfo_StubType_BIZ_TWO_TIER_MIGRATION_BOTTOM = 67, - WebMessageInfo_StubType_OVERSIZED = 68, - WebMessageInfo_StubType_GROUP_CHANGE_NO_FREQUENTLY_FORWARDED = 69, - WebMessageInfo_StubType_GROUP_V4_ADD_INVITE_SENT = 70, - WebMessageInfo_StubType_GROUP_PARTICIPANT_ADD_REQUEST_JOIN = 71, - WebMessageInfo_StubType_CHANGE_EPHEMERAL_SETTING = 72, - WebMessageInfo_StubType_E2E_DEVICE_CHANGED = 73, - WebMessageInfo_StubType_VIEWED_ONCE = 74, - WebMessageInfo_StubType_E2E_ENCRYPTED_NOW = 75, - WebMessageInfo_StubType_BLUE_MSG_BSP_FB_TO_BSP_PREMISE = 76, - WebMessageInfo_StubType_BLUE_MSG_BSP_FB_TO_SELF_FB = 77, - WebMessageInfo_StubType_BLUE_MSG_BSP_FB_TO_SELF_PREMISE = 78, - WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED = 79, - WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED = 80, - WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED = 81, - WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED = 82, - WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_TO_SELF_PREMISE = 83, - WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_UNVERIFIED = 84, - WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_UNVERIFIED_TO_SELF_PREMISE_VERIFIED = 85, - WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_VERIFIED = 86, - WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_VERIFIED_TO_SELF_PREMISE_UNVERIFIED = 87, - WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_BSP_FB_UNVERIFIED = 88, - WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_BSP_PREMISE_UNVERIFIED = 89, - WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_SELF_FB_UNVERIFIED = 90, - WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_SELF_PREMISE_UNVERIFIED = 91, - WebMessageInfo_StubType_BLUE_MSG_SELF_FB_TO_BSP_PREMISE = 92, - WebMessageInfo_StubType_BLUE_MSG_SELF_FB_TO_SELF_PREMISE = 93, - WebMessageInfo_StubType_BLUE_MSG_SELF_FB_UNVERIFIED = 94, - WebMessageInfo_StubType_BLUE_MSG_SELF_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED = 95, - WebMessageInfo_StubType_BLUE_MSG_SELF_FB_VERIFIED = 96, - WebMessageInfo_StubType_BLUE_MSG_SELF_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED = 97, - WebMessageInfo_StubType_BLUE_MSG_SELF_PREMISE_TO_BSP_PREMISE = 98, - WebMessageInfo_StubType_BLUE_MSG_SELF_PREMISE_UNVERIFIED = 99, - WebMessageInfo_StubType_BLUE_MSG_SELF_PREMISE_VERIFIED = 100, - WebMessageInfo_StubType_BLUE_MSG_TO_BSP_FB = 101, - WebMessageInfo_StubType_BLUE_MSG_TO_CONSUMER = 102, - WebMessageInfo_StubType_BLUE_MSG_TO_SELF_FB = 103, - WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_BSP_FB_VERIFIED = 104, - WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_BSP_PREMISE_VERIFIED = 105, - WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_SELF_FB_VERIFIED = 106, - WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_VERIFIED = 107, - WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_BSP_FB_UNVERIFIED = 108, - WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_BSP_PREMISE_UNVERIFIED = 109, - WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_SELF_FB_UNVERIFIED = 110, - WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_UNVERIFIED = 111, - WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED = 112, - WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_FB_VERIFIED = 113, - WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED = 114, - WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_FB_UNVERIFIED = 115, - WebMessageInfo_StubType_BLUE_MSG_SELF_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED = 116, - WebMessageInfo_StubType_BLUE_MSG_SELF_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED = 117, - WebMessageInfo_StubType_E2E_IDENTITY_UNAVAILABLE = 118, - WebMessageInfo_StubType_GROUP_CREATING = 119, - WebMessageInfo_StubType_GROUP_CREATE_FAILED = 120, - WebMessageInfo_StubType_GROUP_BOUNCED = 121, - WebMessageInfo_StubType_BLOCK_CONTACT = 122, - WebMessageInfo_StubType_EPHEMERAL_SETTING_NOT_APPLIED = 123, - WebMessageInfo_StubType_SYNC_FAILED = 124, - WebMessageInfo_StubType_SYNCING = 125, - WebMessageInfo_StubType_BIZ_PRIVACY_MODE_INIT_FB = 126, - WebMessageInfo_StubType_BIZ_PRIVACY_MODE_INIT_BSP = 127, - WebMessageInfo_StubType_BIZ_PRIVACY_MODE_TO_FB = 128, - WebMessageInfo_StubType_BIZ_PRIVACY_MODE_TO_BSP = 129, - WebMessageInfo_StubType_DISAPPEARING_MODE = 130, - WebMessageInfo_StubType_E2E_DEVICE_FETCH_FAILED = 131, - WebMessageInfo_StubType_ADMIN_REVOKE = 132, - WebMessageInfo_StubType_GROUP_INVITE_LINK_GROWTH_LOCKED = 133, - WebMessageInfo_StubType_COMMUNITY_LINK_PARENT_GROUP = 134, - WebMessageInfo_StubType_COMMUNITY_LINK_SIBLING_GROUP = 135, - WebMessageInfo_StubType_COMMUNITY_LINK_SUB_GROUP = 136, - WebMessageInfo_StubType_COMMUNITY_UNLINK_PARENT_GROUP = 137, - WebMessageInfo_StubType_COMMUNITY_UNLINK_SIBLING_GROUP = 138, - WebMessageInfo_StubType_COMMUNITY_UNLINK_SUB_GROUP = 139, - WebMessageInfo_StubType_GROUP_PARTICIPANT_ACCEPT = 140, - WebMessageInfo_StubType_GROUP_PARTICIPANT_LINKED_GROUP_JOIN = 141, - WebMessageInfo_StubType_COMMUNITY_CREATE = 142, - WebMessageInfo_StubType_EPHEMERAL_KEEP_IN_CHAT = 143, - WebMessageInfo_StubType_GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST = 144, - WebMessageInfo_StubType_GROUP_MEMBERSHIP_JOIN_APPROVAL_MODE = 145, - WebMessageInfo_StubType_INTEGRITY_UNLINK_PARENT_GROUP = 146, - WebMessageInfo_StubType_COMMUNITY_PARTICIPANT_PROMOTE = 147, - WebMessageInfo_StubType_COMMUNITY_PARTICIPANT_DEMOTE = 148, - WebMessageInfo_StubType_COMMUNITY_PARENT_GROUP_DELETED = 149 -}; -bool WebMessageInfo_StubType_IsValid(int value); -constexpr WebMessageInfo_StubType WebMessageInfo_StubType_StubType_MIN = WebMessageInfo_StubType_UNKNOWN; -constexpr WebMessageInfo_StubType WebMessageInfo_StubType_StubType_MAX = WebMessageInfo_StubType_COMMUNITY_PARENT_GROUP_DELETED; -constexpr int WebMessageInfo_StubType_StubType_ARRAYSIZE = WebMessageInfo_StubType_StubType_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WebMessageInfo_StubType_descriptor(); -template -inline const std::string& WebMessageInfo_StubType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function WebMessageInfo_StubType_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - WebMessageInfo_StubType_descriptor(), enum_t_value); -} -inline bool WebMessageInfo_StubType_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WebMessageInfo_StubType* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - WebMessageInfo_StubType_descriptor(), name, value); -} -enum KeepType : int { - UNKNOWN = 0, - KEEP_FOR_ALL = 1, - UNDO_KEEP_FOR_ALL = 2 -}; -bool KeepType_IsValid(int value); -constexpr KeepType KeepType_MIN = UNKNOWN; -constexpr KeepType KeepType_MAX = UNDO_KEEP_FOR_ALL; -constexpr int KeepType_ARRAYSIZE = KeepType_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* KeepType_descriptor(); -template -inline const std::string& KeepType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function KeepType_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - KeepType_descriptor(), enum_t_value); -} -inline bool KeepType_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, KeepType* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - KeepType_descriptor(), name, value); -} -enum MediaVisibility : int { - DEFAULT = 0, - OFF = 1, - ON = 2 -}; -bool MediaVisibility_IsValid(int value); -constexpr MediaVisibility MediaVisibility_MIN = DEFAULT; -constexpr MediaVisibility MediaVisibility_MAX = ON; -constexpr int MediaVisibility_ARRAYSIZE = MediaVisibility_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MediaVisibility_descriptor(); -template -inline const std::string& MediaVisibility_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function MediaVisibility_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - MediaVisibility_descriptor(), enum_t_value); -} -inline bool MediaVisibility_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MediaVisibility* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - MediaVisibility_descriptor(), name, value); -} -// =================================================================== - -class ADVDeviceIdentity final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ADVDeviceIdentity) */ { - public: - inline ADVDeviceIdentity() : ADVDeviceIdentity(nullptr) {} - ~ADVDeviceIdentity() override; - explicit PROTOBUF_CONSTEXPR ADVDeviceIdentity(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ADVDeviceIdentity(const ADVDeviceIdentity& from); - ADVDeviceIdentity(ADVDeviceIdentity&& from) noexcept - : ADVDeviceIdentity() { - *this = ::std::move(from); - } - - inline ADVDeviceIdentity& operator=(const ADVDeviceIdentity& from) { - CopyFrom(from); - return *this; - } - inline ADVDeviceIdentity& operator=(ADVDeviceIdentity&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const ADVDeviceIdentity& default_instance() { - return *internal_default_instance(); - } - static inline const ADVDeviceIdentity* internal_default_instance() { - return reinterpret_cast( - &_ADVDeviceIdentity_default_instance_); - } - static constexpr int kIndexInFileMessages = - 0; - - friend void swap(ADVDeviceIdentity& a, ADVDeviceIdentity& b) { - a.Swap(&b); - } - inline void Swap(ADVDeviceIdentity* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ADVDeviceIdentity* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ADVDeviceIdentity* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ADVDeviceIdentity& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const ADVDeviceIdentity& from) { - ADVDeviceIdentity::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ADVDeviceIdentity* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.ADVDeviceIdentity"; - } - protected: - explicit ADVDeviceIdentity(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kTimestampFieldNumber = 2, - kRawIdFieldNumber = 1, - kKeyIndexFieldNumber = 3, - }; - // optional uint64 timestamp = 2; - bool has_timestamp() const; - private: - bool _internal_has_timestamp() const; - public: - void clear_timestamp(); - uint64_t timestamp() const; - void set_timestamp(uint64_t value); - private: - uint64_t _internal_timestamp() const; - void _internal_set_timestamp(uint64_t value); - public: - - // optional uint32 rawId = 1; - bool has_rawid() const; - private: - bool _internal_has_rawid() const; - public: - void clear_rawid(); - uint32_t rawid() const; - void set_rawid(uint32_t value); - private: - uint32_t _internal_rawid() const; - void _internal_set_rawid(uint32_t value); - public: - - // optional uint32 keyIndex = 3; - bool has_keyindex() const; - private: - bool _internal_has_keyindex() const; - public: - void clear_keyindex(); - uint32_t keyindex() const; - void set_keyindex(uint32_t value); - private: - uint32_t _internal_keyindex() const; - void _internal_set_keyindex(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.ADVDeviceIdentity) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint64_t timestamp_; - uint32_t rawid_; - uint32_t keyindex_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class ADVKeyIndexList final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ADVKeyIndexList) */ { - public: - inline ADVKeyIndexList() : ADVKeyIndexList(nullptr) {} - ~ADVKeyIndexList() override; - explicit PROTOBUF_CONSTEXPR ADVKeyIndexList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ADVKeyIndexList(const ADVKeyIndexList& from); - ADVKeyIndexList(ADVKeyIndexList&& from) noexcept - : ADVKeyIndexList() { - *this = ::std::move(from); - } - - inline ADVKeyIndexList& operator=(const ADVKeyIndexList& from) { - CopyFrom(from); - return *this; - } - inline ADVKeyIndexList& operator=(ADVKeyIndexList&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const ADVKeyIndexList& default_instance() { - return *internal_default_instance(); - } - static inline const ADVKeyIndexList* internal_default_instance() { - return reinterpret_cast( - &_ADVKeyIndexList_default_instance_); - } - static constexpr int kIndexInFileMessages = - 1; - - friend void swap(ADVKeyIndexList& a, ADVKeyIndexList& b) { - a.Swap(&b); - } - inline void Swap(ADVKeyIndexList* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ADVKeyIndexList* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ADVKeyIndexList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ADVKeyIndexList& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const ADVKeyIndexList& from) { - ADVKeyIndexList::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ADVKeyIndexList* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.ADVKeyIndexList"; - } - protected: - explicit ADVKeyIndexList(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kValidIndexesFieldNumber = 4, - kTimestampFieldNumber = 2, - kRawIdFieldNumber = 1, - kCurrentIndexFieldNumber = 3, - }; - // repeated uint32 validIndexes = 4 [packed = true]; - int validindexes_size() const; - private: - int _internal_validindexes_size() const; - public: - void clear_validindexes(); - private: - uint32_t _internal_validindexes(int index) const; - const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& - _internal_validindexes() const; - void _internal_add_validindexes(uint32_t value); - ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* - _internal_mutable_validindexes(); - public: - uint32_t validindexes(int index) const; - void set_validindexes(int index, uint32_t value); - void add_validindexes(uint32_t value); - const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& - validindexes() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* - mutable_validindexes(); - - // optional uint64 timestamp = 2; - bool has_timestamp() const; - private: - bool _internal_has_timestamp() const; - public: - void clear_timestamp(); - uint64_t timestamp() const; - void set_timestamp(uint64_t value); - private: - uint64_t _internal_timestamp() const; - void _internal_set_timestamp(uint64_t value); - public: - - // optional uint32 rawId = 1; - bool has_rawid() const; - private: - bool _internal_has_rawid() const; - public: - void clear_rawid(); - uint32_t rawid() const; - void set_rawid(uint32_t value); - private: - uint32_t _internal_rawid() const; - void _internal_set_rawid(uint32_t value); - public: - - // optional uint32 currentIndex = 3; - bool has_currentindex() const; - private: - bool _internal_has_currentindex() const; - public: - void clear_currentindex(); - uint32_t currentindex() const; - void set_currentindex(uint32_t value); - private: - uint32_t _internal_currentindex() const; - void _internal_set_currentindex(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.ADVKeyIndexList) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > validindexes_; - mutable std::atomic _validindexes_cached_byte_size_; - uint64_t timestamp_; - uint32_t rawid_; - uint32_t currentindex_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class ADVSignedDeviceIdentity final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ADVSignedDeviceIdentity) */ { - public: - inline ADVSignedDeviceIdentity() : ADVSignedDeviceIdentity(nullptr) {} - ~ADVSignedDeviceIdentity() override; - explicit PROTOBUF_CONSTEXPR ADVSignedDeviceIdentity(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ADVSignedDeviceIdentity(const ADVSignedDeviceIdentity& from); - ADVSignedDeviceIdentity(ADVSignedDeviceIdentity&& from) noexcept - : ADVSignedDeviceIdentity() { - *this = ::std::move(from); - } - - inline ADVSignedDeviceIdentity& operator=(const ADVSignedDeviceIdentity& from) { - CopyFrom(from); - return *this; - } - inline ADVSignedDeviceIdentity& operator=(ADVSignedDeviceIdentity&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const ADVSignedDeviceIdentity& default_instance() { - return *internal_default_instance(); - } - static inline const ADVSignedDeviceIdentity* internal_default_instance() { - return reinterpret_cast( - &_ADVSignedDeviceIdentity_default_instance_); - } - static constexpr int kIndexInFileMessages = - 2; - - friend void swap(ADVSignedDeviceIdentity& a, ADVSignedDeviceIdentity& b) { - a.Swap(&b); - } - inline void Swap(ADVSignedDeviceIdentity* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ADVSignedDeviceIdentity* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ADVSignedDeviceIdentity* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ADVSignedDeviceIdentity& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const ADVSignedDeviceIdentity& from) { - ADVSignedDeviceIdentity::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ADVSignedDeviceIdentity* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.ADVSignedDeviceIdentity"; - } - protected: - explicit ADVSignedDeviceIdentity(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kDetailsFieldNumber = 1, - kAccountSignatureKeyFieldNumber = 2, - kAccountSignatureFieldNumber = 3, - kDeviceSignatureFieldNumber = 4, - }; - // optional bytes details = 1; - bool has_details() const; - private: - bool _internal_has_details() const; - public: - void clear_details(); - const std::string& details() const; - template - void set_details(ArgT0&& arg0, ArgT... args); - std::string* mutable_details(); - PROTOBUF_NODISCARD std::string* release_details(); - void set_allocated_details(std::string* details); - private: - const std::string& _internal_details() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_details(const std::string& value); - std::string* _internal_mutable_details(); - public: - - // optional bytes accountSignatureKey = 2; - bool has_accountsignaturekey() const; - private: - bool _internal_has_accountsignaturekey() const; - public: - void clear_accountsignaturekey(); - const std::string& accountsignaturekey() const; - template - void set_accountsignaturekey(ArgT0&& arg0, ArgT... args); - std::string* mutable_accountsignaturekey(); - PROTOBUF_NODISCARD std::string* release_accountsignaturekey(); - void set_allocated_accountsignaturekey(std::string* accountsignaturekey); - private: - const std::string& _internal_accountsignaturekey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_accountsignaturekey(const std::string& value); - std::string* _internal_mutable_accountsignaturekey(); - public: - - // optional bytes accountSignature = 3; - bool has_accountsignature() const; - private: - bool _internal_has_accountsignature() const; - public: - void clear_accountsignature(); - const std::string& accountsignature() const; - template - void set_accountsignature(ArgT0&& arg0, ArgT... args); - std::string* mutable_accountsignature(); - PROTOBUF_NODISCARD std::string* release_accountsignature(); - void set_allocated_accountsignature(std::string* accountsignature); - private: - const std::string& _internal_accountsignature() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_accountsignature(const std::string& value); - std::string* _internal_mutable_accountsignature(); - public: - - // optional bytes deviceSignature = 4; - bool has_devicesignature() const; - private: - bool _internal_has_devicesignature() const; - public: - void clear_devicesignature(); - const std::string& devicesignature() const; - template - void set_devicesignature(ArgT0&& arg0, ArgT... args); - std::string* mutable_devicesignature(); - PROTOBUF_NODISCARD std::string* release_devicesignature(); - void set_allocated_devicesignature(std::string* devicesignature); - private: - const std::string& _internal_devicesignature() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_devicesignature(const std::string& value); - std::string* _internal_mutable_devicesignature(); - public: - - // @@protoc_insertion_point(class_scope:proto.ADVSignedDeviceIdentity) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr details_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr accountsignaturekey_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr accountsignature_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr devicesignature_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class ADVSignedDeviceIdentityHMAC final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ADVSignedDeviceIdentityHMAC) */ { - public: - inline ADVSignedDeviceIdentityHMAC() : ADVSignedDeviceIdentityHMAC(nullptr) {} - ~ADVSignedDeviceIdentityHMAC() override; - explicit PROTOBUF_CONSTEXPR ADVSignedDeviceIdentityHMAC(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ADVSignedDeviceIdentityHMAC(const ADVSignedDeviceIdentityHMAC& from); - ADVSignedDeviceIdentityHMAC(ADVSignedDeviceIdentityHMAC&& from) noexcept - : ADVSignedDeviceIdentityHMAC() { - *this = ::std::move(from); - } - - inline ADVSignedDeviceIdentityHMAC& operator=(const ADVSignedDeviceIdentityHMAC& from) { - CopyFrom(from); - return *this; - } - inline ADVSignedDeviceIdentityHMAC& operator=(ADVSignedDeviceIdentityHMAC&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const ADVSignedDeviceIdentityHMAC& default_instance() { - return *internal_default_instance(); - } - static inline const ADVSignedDeviceIdentityHMAC* internal_default_instance() { - return reinterpret_cast( - &_ADVSignedDeviceIdentityHMAC_default_instance_); - } - static constexpr int kIndexInFileMessages = - 3; - - friend void swap(ADVSignedDeviceIdentityHMAC& a, ADVSignedDeviceIdentityHMAC& b) { - a.Swap(&b); - } - inline void Swap(ADVSignedDeviceIdentityHMAC* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ADVSignedDeviceIdentityHMAC* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ADVSignedDeviceIdentityHMAC* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ADVSignedDeviceIdentityHMAC& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const ADVSignedDeviceIdentityHMAC& from) { - ADVSignedDeviceIdentityHMAC::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ADVSignedDeviceIdentityHMAC* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.ADVSignedDeviceIdentityHMAC"; - } - protected: - explicit ADVSignedDeviceIdentityHMAC(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kDetailsFieldNumber = 1, - kHmacFieldNumber = 2, - }; - // optional bytes details = 1; - bool has_details() const; - private: - bool _internal_has_details() const; - public: - void clear_details(); - const std::string& details() const; - template - void set_details(ArgT0&& arg0, ArgT... args); - std::string* mutable_details(); - PROTOBUF_NODISCARD std::string* release_details(); - void set_allocated_details(std::string* details); - private: - const std::string& _internal_details() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_details(const std::string& value); - std::string* _internal_mutable_details(); - public: - - // optional bytes hmac = 2; - bool has_hmac() const; - private: - bool _internal_has_hmac() const; - public: - void clear_hmac(); - const std::string& hmac() const; - template - void set_hmac(ArgT0&& arg0, ArgT... args); - std::string* mutable_hmac(); - PROTOBUF_NODISCARD std::string* release_hmac(); - void set_allocated_hmac(std::string* hmac); - private: - const std::string& _internal_hmac() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_hmac(const std::string& value); - std::string* _internal_mutable_hmac(); - public: - - // @@protoc_insertion_point(class_scope:proto.ADVSignedDeviceIdentityHMAC) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr details_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hmac_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class ADVSignedKeyIndexList final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ADVSignedKeyIndexList) */ { - public: - inline ADVSignedKeyIndexList() : ADVSignedKeyIndexList(nullptr) {} - ~ADVSignedKeyIndexList() override; - explicit PROTOBUF_CONSTEXPR ADVSignedKeyIndexList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ADVSignedKeyIndexList(const ADVSignedKeyIndexList& from); - ADVSignedKeyIndexList(ADVSignedKeyIndexList&& from) noexcept - : ADVSignedKeyIndexList() { - *this = ::std::move(from); - } - - inline ADVSignedKeyIndexList& operator=(const ADVSignedKeyIndexList& from) { - CopyFrom(from); - return *this; - } - inline ADVSignedKeyIndexList& operator=(ADVSignedKeyIndexList&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const ADVSignedKeyIndexList& default_instance() { - return *internal_default_instance(); - } - static inline const ADVSignedKeyIndexList* internal_default_instance() { - return reinterpret_cast( - &_ADVSignedKeyIndexList_default_instance_); - } - static constexpr int kIndexInFileMessages = - 4; - - friend void swap(ADVSignedKeyIndexList& a, ADVSignedKeyIndexList& b) { - a.Swap(&b); - } - inline void Swap(ADVSignedKeyIndexList* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ADVSignedKeyIndexList* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ADVSignedKeyIndexList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ADVSignedKeyIndexList& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const ADVSignedKeyIndexList& from) { - ADVSignedKeyIndexList::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ADVSignedKeyIndexList* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.ADVSignedKeyIndexList"; - } - protected: - explicit ADVSignedKeyIndexList(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kDetailsFieldNumber = 1, - kAccountSignatureFieldNumber = 2, - }; - // optional bytes details = 1; - bool has_details() const; - private: - bool _internal_has_details() const; - public: - void clear_details(); - const std::string& details() const; - template - void set_details(ArgT0&& arg0, ArgT... args); - std::string* mutable_details(); - PROTOBUF_NODISCARD std::string* release_details(); - void set_allocated_details(std::string* details); - private: - const std::string& _internal_details() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_details(const std::string& value); - std::string* _internal_mutable_details(); - public: - - // optional bytes accountSignature = 2; - bool has_accountsignature() const; - private: - bool _internal_has_accountsignature() const; - public: - void clear_accountsignature(); - const std::string& accountsignature() const; - template - void set_accountsignature(ArgT0&& arg0, ArgT... args); - std::string* mutable_accountsignature(); - PROTOBUF_NODISCARD std::string* release_accountsignature(); - void set_allocated_accountsignature(std::string* accountsignature); - private: - const std::string& _internal_accountsignature() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_accountsignature(const std::string& value); - std::string* _internal_mutable_accountsignature(); - public: - - // @@protoc_insertion_point(class_scope:proto.ADVSignedKeyIndexList) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr details_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr accountsignature_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class ActionLink final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ActionLink) */ { - public: - inline ActionLink() : ActionLink(nullptr) {} - ~ActionLink() override; - explicit PROTOBUF_CONSTEXPR ActionLink(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ActionLink(const ActionLink& from); - ActionLink(ActionLink&& from) noexcept - : ActionLink() { - *this = ::std::move(from); - } - - inline ActionLink& operator=(const ActionLink& from) { - CopyFrom(from); - return *this; - } - inline ActionLink& operator=(ActionLink&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const ActionLink& default_instance() { - return *internal_default_instance(); - } - static inline const ActionLink* internal_default_instance() { - return reinterpret_cast( - &_ActionLink_default_instance_); - } - static constexpr int kIndexInFileMessages = - 5; - - friend void swap(ActionLink& a, ActionLink& b) { - a.Swap(&b); - } - inline void Swap(ActionLink* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ActionLink* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ActionLink* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ActionLink& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const ActionLink& from) { - ActionLink::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ActionLink* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.ActionLink"; - } - protected: - explicit ActionLink(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kUrlFieldNumber = 1, - kButtonTitleFieldNumber = 2, - }; - // optional string url = 1; - bool has_url() const; - private: - bool _internal_has_url() const; - public: - void clear_url(); - const std::string& url() const; - template - void set_url(ArgT0&& arg0, ArgT... args); - std::string* mutable_url(); - PROTOBUF_NODISCARD std::string* release_url(); - void set_allocated_url(std::string* url); - private: - const std::string& _internal_url() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value); - std::string* _internal_mutable_url(); - public: - - // optional string buttonTitle = 2; - bool has_buttontitle() const; - private: - bool _internal_has_buttontitle() const; - public: - void clear_buttontitle(); - const std::string& buttontitle() const; - template - void set_buttontitle(ArgT0&& arg0, ArgT... args); - std::string* mutable_buttontitle(); - PROTOBUF_NODISCARD std::string* release_buttontitle(); - void set_allocated_buttontitle(std::string* buttontitle); - private: - const std::string& _internal_buttontitle() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_buttontitle(const std::string& value); - std::string* _internal_mutable_buttontitle(); - public: - - // @@protoc_insertion_point(class_scope:proto.ActionLink) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr buttontitle_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class AutoDownloadSettings final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.AutoDownloadSettings) */ { - public: - inline AutoDownloadSettings() : AutoDownloadSettings(nullptr) {} - ~AutoDownloadSettings() override; - explicit PROTOBUF_CONSTEXPR AutoDownloadSettings(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - AutoDownloadSettings(const AutoDownloadSettings& from); - AutoDownloadSettings(AutoDownloadSettings&& from) noexcept - : AutoDownloadSettings() { - *this = ::std::move(from); - } - - inline AutoDownloadSettings& operator=(const AutoDownloadSettings& from) { - CopyFrom(from); - return *this; - } - inline AutoDownloadSettings& operator=(AutoDownloadSettings&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const AutoDownloadSettings& default_instance() { - return *internal_default_instance(); - } - static inline const AutoDownloadSettings* internal_default_instance() { - return reinterpret_cast( - &_AutoDownloadSettings_default_instance_); - } - static constexpr int kIndexInFileMessages = - 6; - - friend void swap(AutoDownloadSettings& a, AutoDownloadSettings& b) { - a.Swap(&b); - } - inline void Swap(AutoDownloadSettings* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(AutoDownloadSettings* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - AutoDownloadSettings* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const AutoDownloadSettings& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const AutoDownloadSettings& from) { - AutoDownloadSettings::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(AutoDownloadSettings* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.AutoDownloadSettings"; - } - protected: - explicit AutoDownloadSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kDownloadImagesFieldNumber = 1, - kDownloadAudioFieldNumber = 2, - kDownloadVideoFieldNumber = 3, - kDownloadDocumentsFieldNumber = 4, - }; - // optional bool downloadImages = 1; - bool has_downloadimages() const; - private: - bool _internal_has_downloadimages() const; - public: - void clear_downloadimages(); - bool downloadimages() const; - void set_downloadimages(bool value); - private: - bool _internal_downloadimages() const; - void _internal_set_downloadimages(bool value); - public: - - // optional bool downloadAudio = 2; - bool has_downloadaudio() const; - private: - bool _internal_has_downloadaudio() const; - public: - void clear_downloadaudio(); - bool downloadaudio() const; - void set_downloadaudio(bool value); - private: - bool _internal_downloadaudio() const; - void _internal_set_downloadaudio(bool value); - public: - - // optional bool downloadVideo = 3; - bool has_downloadvideo() const; - private: - bool _internal_has_downloadvideo() const; - public: - void clear_downloadvideo(); - bool downloadvideo() const; - void set_downloadvideo(bool value); - private: - bool _internal_downloadvideo() const; - void _internal_set_downloadvideo(bool value); - public: - - // optional bool downloadDocuments = 4; - bool has_downloaddocuments() const; - private: - bool _internal_has_downloaddocuments() const; - public: - void clear_downloaddocuments(); - bool downloaddocuments() const; - void set_downloaddocuments(bool value); - private: - bool _internal_downloaddocuments() const; - void _internal_set_downloaddocuments(bool value); - public: - - // @@protoc_insertion_point(class_scope:proto.AutoDownloadSettings) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - bool downloadimages_; - bool downloadaudio_; - bool downloadvideo_; - bool downloaddocuments_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class BizAccountLinkInfo final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.BizAccountLinkInfo) */ { - public: - inline BizAccountLinkInfo() : BizAccountLinkInfo(nullptr) {} - ~BizAccountLinkInfo() override; - explicit PROTOBUF_CONSTEXPR BizAccountLinkInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - BizAccountLinkInfo(const BizAccountLinkInfo& from); - BizAccountLinkInfo(BizAccountLinkInfo&& from) noexcept - : BizAccountLinkInfo() { - *this = ::std::move(from); - } - - inline BizAccountLinkInfo& operator=(const BizAccountLinkInfo& from) { - CopyFrom(from); - return *this; - } - inline BizAccountLinkInfo& operator=(BizAccountLinkInfo&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const BizAccountLinkInfo& default_instance() { - return *internal_default_instance(); - } - static inline const BizAccountLinkInfo* internal_default_instance() { - return reinterpret_cast( - &_BizAccountLinkInfo_default_instance_); - } - static constexpr int kIndexInFileMessages = - 7; - - friend void swap(BizAccountLinkInfo& a, BizAccountLinkInfo& b) { - a.Swap(&b); - } - inline void Swap(BizAccountLinkInfo* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(BizAccountLinkInfo* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - BizAccountLinkInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const BizAccountLinkInfo& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const BizAccountLinkInfo& from) { - BizAccountLinkInfo::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(BizAccountLinkInfo* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.BizAccountLinkInfo"; - } - protected: - explicit BizAccountLinkInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef BizAccountLinkInfo_AccountType AccountType; - static constexpr AccountType ENTERPRISE = - BizAccountLinkInfo_AccountType_ENTERPRISE; - static inline bool AccountType_IsValid(int value) { - return BizAccountLinkInfo_AccountType_IsValid(value); - } - static constexpr AccountType AccountType_MIN = - BizAccountLinkInfo_AccountType_AccountType_MIN; - static constexpr AccountType AccountType_MAX = - BizAccountLinkInfo_AccountType_AccountType_MAX; - static constexpr int AccountType_ARRAYSIZE = - BizAccountLinkInfo_AccountType_AccountType_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - AccountType_descriptor() { - return BizAccountLinkInfo_AccountType_descriptor(); - } - template - static inline const std::string& AccountType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function AccountType_Name."); - return BizAccountLinkInfo_AccountType_Name(enum_t_value); - } - static inline bool AccountType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - AccountType* value) { - return BizAccountLinkInfo_AccountType_Parse(name, value); - } - - typedef BizAccountLinkInfo_HostStorageType HostStorageType; - static constexpr HostStorageType ON_PREMISE = - BizAccountLinkInfo_HostStorageType_ON_PREMISE; - static constexpr HostStorageType FACEBOOK = - BizAccountLinkInfo_HostStorageType_FACEBOOK; - static inline bool HostStorageType_IsValid(int value) { - return BizAccountLinkInfo_HostStorageType_IsValid(value); - } - static constexpr HostStorageType HostStorageType_MIN = - BizAccountLinkInfo_HostStorageType_HostStorageType_MIN; - static constexpr HostStorageType HostStorageType_MAX = - BizAccountLinkInfo_HostStorageType_HostStorageType_MAX; - static constexpr int HostStorageType_ARRAYSIZE = - BizAccountLinkInfo_HostStorageType_HostStorageType_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - HostStorageType_descriptor() { - return BizAccountLinkInfo_HostStorageType_descriptor(); - } - template - static inline const std::string& HostStorageType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function HostStorageType_Name."); - return BizAccountLinkInfo_HostStorageType_Name(enum_t_value); - } - static inline bool HostStorageType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - HostStorageType* value) { - return BizAccountLinkInfo_HostStorageType_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kWhatsappAcctNumberFieldNumber = 2, - kWhatsappBizAcctFbidFieldNumber = 1, - kIssueTimeFieldNumber = 3, - kHostStorageFieldNumber = 4, - kAccountTypeFieldNumber = 5, - }; - // optional string whatsappAcctNumber = 2; - bool has_whatsappacctnumber() const; - private: - bool _internal_has_whatsappacctnumber() const; - public: - void clear_whatsappacctnumber(); - const std::string& whatsappacctnumber() const; - template - void set_whatsappacctnumber(ArgT0&& arg0, ArgT... args); - std::string* mutable_whatsappacctnumber(); - PROTOBUF_NODISCARD std::string* release_whatsappacctnumber(); - void set_allocated_whatsappacctnumber(std::string* whatsappacctnumber); - private: - const std::string& _internal_whatsappacctnumber() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_whatsappacctnumber(const std::string& value); - std::string* _internal_mutable_whatsappacctnumber(); - public: - - // optional uint64 whatsappBizAcctFbid = 1; - bool has_whatsappbizacctfbid() const; - private: - bool _internal_has_whatsappbizacctfbid() const; - public: - void clear_whatsappbizacctfbid(); - uint64_t whatsappbizacctfbid() const; - void set_whatsappbizacctfbid(uint64_t value); - private: - uint64_t _internal_whatsappbizacctfbid() const; - void _internal_set_whatsappbizacctfbid(uint64_t value); - public: - - // optional uint64 issueTime = 3; - bool has_issuetime() const; - private: - bool _internal_has_issuetime() const; - public: - void clear_issuetime(); - uint64_t issuetime() const; - void set_issuetime(uint64_t value); - private: - uint64_t _internal_issuetime() const; - void _internal_set_issuetime(uint64_t value); - public: - - // optional .proto.BizAccountLinkInfo.HostStorageType hostStorage = 4; - bool has_hoststorage() const; - private: - bool _internal_has_hoststorage() const; - public: - void clear_hoststorage(); - ::proto::BizAccountLinkInfo_HostStorageType hoststorage() const; - void set_hoststorage(::proto::BizAccountLinkInfo_HostStorageType value); - private: - ::proto::BizAccountLinkInfo_HostStorageType _internal_hoststorage() const; - void _internal_set_hoststorage(::proto::BizAccountLinkInfo_HostStorageType value); - public: - - // optional .proto.BizAccountLinkInfo.AccountType accountType = 5; - bool has_accounttype() const; - private: - bool _internal_has_accounttype() const; - public: - void clear_accounttype(); - ::proto::BizAccountLinkInfo_AccountType accounttype() const; - void set_accounttype(::proto::BizAccountLinkInfo_AccountType value); - private: - ::proto::BizAccountLinkInfo_AccountType _internal_accounttype() const; - void _internal_set_accounttype(::proto::BizAccountLinkInfo_AccountType value); - public: - - // @@protoc_insertion_point(class_scope:proto.BizAccountLinkInfo) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr whatsappacctnumber_; - uint64_t whatsappbizacctfbid_; - uint64_t issuetime_; - int hoststorage_; - int accounttype_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class BizAccountPayload final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.BizAccountPayload) */ { - public: - inline BizAccountPayload() : BizAccountPayload(nullptr) {} - ~BizAccountPayload() override; - explicit PROTOBUF_CONSTEXPR BizAccountPayload(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - BizAccountPayload(const BizAccountPayload& from); - BizAccountPayload(BizAccountPayload&& from) noexcept - : BizAccountPayload() { - *this = ::std::move(from); - } - - inline BizAccountPayload& operator=(const BizAccountPayload& from) { - CopyFrom(from); - return *this; - } - inline BizAccountPayload& operator=(BizAccountPayload&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const BizAccountPayload& default_instance() { - return *internal_default_instance(); - } - static inline const BizAccountPayload* internal_default_instance() { - return reinterpret_cast( - &_BizAccountPayload_default_instance_); - } - static constexpr int kIndexInFileMessages = - 8; - - friend void swap(BizAccountPayload& a, BizAccountPayload& b) { - a.Swap(&b); - } - inline void Swap(BizAccountPayload* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(BizAccountPayload* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - BizAccountPayload* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const BizAccountPayload& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const BizAccountPayload& from) { - BizAccountPayload::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(BizAccountPayload* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.BizAccountPayload"; - } - protected: - explicit BizAccountPayload(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kBizAcctLinkInfoFieldNumber = 2, - kVnameCertFieldNumber = 1, - }; - // optional bytes bizAcctLinkInfo = 2; - bool has_bizacctlinkinfo() const; - private: - bool _internal_has_bizacctlinkinfo() const; - public: - void clear_bizacctlinkinfo(); - const std::string& bizacctlinkinfo() const; - template - void set_bizacctlinkinfo(ArgT0&& arg0, ArgT... args); - std::string* mutable_bizacctlinkinfo(); - PROTOBUF_NODISCARD std::string* release_bizacctlinkinfo(); - void set_allocated_bizacctlinkinfo(std::string* bizacctlinkinfo); - private: - const std::string& _internal_bizacctlinkinfo() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_bizacctlinkinfo(const std::string& value); - std::string* _internal_mutable_bizacctlinkinfo(); - public: - - // optional .proto.VerifiedNameCertificate vnameCert = 1; - bool has_vnamecert() const; - private: - bool _internal_has_vnamecert() const; - public: - void clear_vnamecert(); - const ::proto::VerifiedNameCertificate& vnamecert() const; - PROTOBUF_NODISCARD ::proto::VerifiedNameCertificate* release_vnamecert(); - ::proto::VerifiedNameCertificate* mutable_vnamecert(); - void set_allocated_vnamecert(::proto::VerifiedNameCertificate* vnamecert); - private: - const ::proto::VerifiedNameCertificate& _internal_vnamecert() const; - ::proto::VerifiedNameCertificate* _internal_mutable_vnamecert(); - public: - void unsafe_arena_set_allocated_vnamecert( - ::proto::VerifiedNameCertificate* vnamecert); - ::proto::VerifiedNameCertificate* unsafe_arena_release_vnamecert(); - - // @@protoc_insertion_point(class_scope:proto.BizAccountPayload) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bizacctlinkinfo_; - ::proto::VerifiedNameCertificate* vnamecert_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class BizIdentityInfo final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.BizIdentityInfo) */ { - public: - inline BizIdentityInfo() : BizIdentityInfo(nullptr) {} - ~BizIdentityInfo() override; - explicit PROTOBUF_CONSTEXPR BizIdentityInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - BizIdentityInfo(const BizIdentityInfo& from); - BizIdentityInfo(BizIdentityInfo&& from) noexcept - : BizIdentityInfo() { - *this = ::std::move(from); - } - - inline BizIdentityInfo& operator=(const BizIdentityInfo& from) { - CopyFrom(from); - return *this; - } - inline BizIdentityInfo& operator=(BizIdentityInfo&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const BizIdentityInfo& default_instance() { - return *internal_default_instance(); - } - static inline const BizIdentityInfo* internal_default_instance() { - return reinterpret_cast( - &_BizIdentityInfo_default_instance_); - } - static constexpr int kIndexInFileMessages = - 9; - - friend void swap(BizIdentityInfo& a, BizIdentityInfo& b) { - a.Swap(&b); - } - inline void Swap(BizIdentityInfo* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(BizIdentityInfo* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - BizIdentityInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const BizIdentityInfo& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const BizIdentityInfo& from) { - BizIdentityInfo::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(BizIdentityInfo* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.BizIdentityInfo"; - } - protected: - explicit BizIdentityInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef BizIdentityInfo_ActualActorsType ActualActorsType; - static constexpr ActualActorsType SELF = - BizIdentityInfo_ActualActorsType_SELF; - static constexpr ActualActorsType BSP = - BizIdentityInfo_ActualActorsType_BSP; - static inline bool ActualActorsType_IsValid(int value) { - return BizIdentityInfo_ActualActorsType_IsValid(value); - } - static constexpr ActualActorsType ActualActorsType_MIN = - BizIdentityInfo_ActualActorsType_ActualActorsType_MIN; - static constexpr ActualActorsType ActualActorsType_MAX = - BizIdentityInfo_ActualActorsType_ActualActorsType_MAX; - static constexpr int ActualActorsType_ARRAYSIZE = - BizIdentityInfo_ActualActorsType_ActualActorsType_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - ActualActorsType_descriptor() { - return BizIdentityInfo_ActualActorsType_descriptor(); - } - template - static inline const std::string& ActualActorsType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function ActualActorsType_Name."); - return BizIdentityInfo_ActualActorsType_Name(enum_t_value); - } - static inline bool ActualActorsType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - ActualActorsType* value) { - return BizIdentityInfo_ActualActorsType_Parse(name, value); - } - - typedef BizIdentityInfo_HostStorageType HostStorageType; - static constexpr HostStorageType ON_PREMISE = - BizIdentityInfo_HostStorageType_ON_PREMISE; - static constexpr HostStorageType FACEBOOK = - BizIdentityInfo_HostStorageType_FACEBOOK; - static inline bool HostStorageType_IsValid(int value) { - return BizIdentityInfo_HostStorageType_IsValid(value); - } - static constexpr HostStorageType HostStorageType_MIN = - BizIdentityInfo_HostStorageType_HostStorageType_MIN; - static constexpr HostStorageType HostStorageType_MAX = - BizIdentityInfo_HostStorageType_HostStorageType_MAX; - static constexpr int HostStorageType_ARRAYSIZE = - BizIdentityInfo_HostStorageType_HostStorageType_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - HostStorageType_descriptor() { - return BizIdentityInfo_HostStorageType_descriptor(); - } - template - static inline const std::string& HostStorageType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function HostStorageType_Name."); - return BizIdentityInfo_HostStorageType_Name(enum_t_value); - } - static inline bool HostStorageType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - HostStorageType* value) { - return BizIdentityInfo_HostStorageType_Parse(name, value); - } - - typedef BizIdentityInfo_VerifiedLevelValue VerifiedLevelValue; - static constexpr VerifiedLevelValue UNKNOWN = - BizIdentityInfo_VerifiedLevelValue_UNKNOWN; - static constexpr VerifiedLevelValue LOW = - BizIdentityInfo_VerifiedLevelValue_LOW; - static constexpr VerifiedLevelValue HIGH = - BizIdentityInfo_VerifiedLevelValue_HIGH; - static inline bool VerifiedLevelValue_IsValid(int value) { - return BizIdentityInfo_VerifiedLevelValue_IsValid(value); - } - static constexpr VerifiedLevelValue VerifiedLevelValue_MIN = - BizIdentityInfo_VerifiedLevelValue_VerifiedLevelValue_MIN; - static constexpr VerifiedLevelValue VerifiedLevelValue_MAX = - BizIdentityInfo_VerifiedLevelValue_VerifiedLevelValue_MAX; - static constexpr int VerifiedLevelValue_ARRAYSIZE = - BizIdentityInfo_VerifiedLevelValue_VerifiedLevelValue_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - VerifiedLevelValue_descriptor() { - return BizIdentityInfo_VerifiedLevelValue_descriptor(); - } - template - static inline const std::string& VerifiedLevelValue_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function VerifiedLevelValue_Name."); - return BizIdentityInfo_VerifiedLevelValue_Name(enum_t_value); - } - static inline bool VerifiedLevelValue_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - VerifiedLevelValue* value) { - return BizIdentityInfo_VerifiedLevelValue_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kVnameCertFieldNumber = 2, - kVlevelFieldNumber = 1, - kSignedFieldNumber = 3, - kRevokedFieldNumber = 4, - kHostStorageFieldNumber = 5, - kActualActorsFieldNumber = 6, - kPrivacyModeTsFieldNumber = 7, - kFeatureControlsFieldNumber = 8, - }; - // optional .proto.VerifiedNameCertificate vnameCert = 2; - bool has_vnamecert() const; - private: - bool _internal_has_vnamecert() const; - public: - void clear_vnamecert(); - const ::proto::VerifiedNameCertificate& vnamecert() const; - PROTOBUF_NODISCARD ::proto::VerifiedNameCertificate* release_vnamecert(); - ::proto::VerifiedNameCertificate* mutable_vnamecert(); - void set_allocated_vnamecert(::proto::VerifiedNameCertificate* vnamecert); - private: - const ::proto::VerifiedNameCertificate& _internal_vnamecert() const; - ::proto::VerifiedNameCertificate* _internal_mutable_vnamecert(); - public: - void unsafe_arena_set_allocated_vnamecert( - ::proto::VerifiedNameCertificate* vnamecert); - ::proto::VerifiedNameCertificate* unsafe_arena_release_vnamecert(); - - // optional .proto.BizIdentityInfo.VerifiedLevelValue vlevel = 1; - bool has_vlevel() const; - private: - bool _internal_has_vlevel() const; - public: - void clear_vlevel(); - ::proto::BizIdentityInfo_VerifiedLevelValue vlevel() const; - void set_vlevel(::proto::BizIdentityInfo_VerifiedLevelValue value); - private: - ::proto::BizIdentityInfo_VerifiedLevelValue _internal_vlevel() const; - void _internal_set_vlevel(::proto::BizIdentityInfo_VerifiedLevelValue value); - public: - - // optional bool signed = 3; - bool has_signed_() const; - private: - bool _internal_has_signed_() const; - public: - void clear_signed_(); - bool signed_() const; - void set_signed_(bool value); - private: - bool _internal_signed_() const; - void _internal_set_signed_(bool value); - public: - - // optional bool revoked = 4; - bool has_revoked() const; - private: - bool _internal_has_revoked() const; - public: - void clear_revoked(); - bool revoked() const; - void set_revoked(bool value); - private: - bool _internal_revoked() const; - void _internal_set_revoked(bool value); - public: - - // optional .proto.BizIdentityInfo.HostStorageType hostStorage = 5; - bool has_hoststorage() const; - private: - bool _internal_has_hoststorage() const; - public: - void clear_hoststorage(); - ::proto::BizIdentityInfo_HostStorageType hoststorage() const; - void set_hoststorage(::proto::BizIdentityInfo_HostStorageType value); - private: - ::proto::BizIdentityInfo_HostStorageType _internal_hoststorage() const; - void _internal_set_hoststorage(::proto::BizIdentityInfo_HostStorageType value); - public: - - // optional .proto.BizIdentityInfo.ActualActorsType actualActors = 6; - bool has_actualactors() const; - private: - bool _internal_has_actualactors() const; - public: - void clear_actualactors(); - ::proto::BizIdentityInfo_ActualActorsType actualactors() const; - void set_actualactors(::proto::BizIdentityInfo_ActualActorsType value); - private: - ::proto::BizIdentityInfo_ActualActorsType _internal_actualactors() const; - void _internal_set_actualactors(::proto::BizIdentityInfo_ActualActorsType value); - public: - - // optional uint64 privacyModeTs = 7; - bool has_privacymodets() const; - private: - bool _internal_has_privacymodets() const; - public: - void clear_privacymodets(); - uint64_t privacymodets() const; - void set_privacymodets(uint64_t value); - private: - uint64_t _internal_privacymodets() const; - void _internal_set_privacymodets(uint64_t value); - public: - - // optional uint64 featureControls = 8; - bool has_featurecontrols() const; - private: - bool _internal_has_featurecontrols() const; - public: - void clear_featurecontrols(); - uint64_t featurecontrols() const; - void set_featurecontrols(uint64_t value); - private: - uint64_t _internal_featurecontrols() const; - void _internal_set_featurecontrols(uint64_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.BizIdentityInfo) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::proto::VerifiedNameCertificate* vnamecert_; - int vlevel_; - bool signed__; - bool revoked_; - int hoststorage_; - int actualactors_; - uint64_t privacymodets_; - uint64_t featurecontrols_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class CertChain_NoiseCertificate_Details final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.CertChain.NoiseCertificate.Details) */ { - public: - inline CertChain_NoiseCertificate_Details() : CertChain_NoiseCertificate_Details(nullptr) {} - ~CertChain_NoiseCertificate_Details() override; - explicit PROTOBUF_CONSTEXPR CertChain_NoiseCertificate_Details(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - CertChain_NoiseCertificate_Details(const CertChain_NoiseCertificate_Details& from); - CertChain_NoiseCertificate_Details(CertChain_NoiseCertificate_Details&& from) noexcept - : CertChain_NoiseCertificate_Details() { - *this = ::std::move(from); - } - - inline CertChain_NoiseCertificate_Details& operator=(const CertChain_NoiseCertificate_Details& from) { - CopyFrom(from); - return *this; - } - inline CertChain_NoiseCertificate_Details& operator=(CertChain_NoiseCertificate_Details&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const CertChain_NoiseCertificate_Details& default_instance() { - return *internal_default_instance(); - } - static inline const CertChain_NoiseCertificate_Details* internal_default_instance() { - return reinterpret_cast( - &_CertChain_NoiseCertificate_Details_default_instance_); - } - static constexpr int kIndexInFileMessages = - 10; - - friend void swap(CertChain_NoiseCertificate_Details& a, CertChain_NoiseCertificate_Details& b) { - a.Swap(&b); - } - inline void Swap(CertChain_NoiseCertificate_Details* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(CertChain_NoiseCertificate_Details* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - CertChain_NoiseCertificate_Details* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const CertChain_NoiseCertificate_Details& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const CertChain_NoiseCertificate_Details& from) { - CertChain_NoiseCertificate_Details::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(CertChain_NoiseCertificate_Details* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.CertChain.NoiseCertificate.Details"; - } - protected: - explicit CertChain_NoiseCertificate_Details(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kKeyFieldNumber = 3, - kSerialFieldNumber = 1, - kIssuerSerialFieldNumber = 2, - kNotBeforeFieldNumber = 4, - kNotAfterFieldNumber = 5, - }; - // optional bytes key = 3; - bool has_key() const; - private: - bool _internal_has_key() const; - public: - void clear_key(); - const std::string& key() const; - template - void set_key(ArgT0&& arg0, ArgT... args); - std::string* mutable_key(); - PROTOBUF_NODISCARD std::string* release_key(); - void set_allocated_key(std::string* key); - private: - const std::string& _internal_key() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value); - std::string* _internal_mutable_key(); - public: - - // optional uint32 serial = 1; - bool has_serial() const; - private: - bool _internal_has_serial() const; - public: - void clear_serial(); - uint32_t serial() const; - void set_serial(uint32_t value); - private: - uint32_t _internal_serial() const; - void _internal_set_serial(uint32_t value); - public: - - // optional uint32 issuerSerial = 2; - bool has_issuerserial() const; - private: - bool _internal_has_issuerserial() const; - public: - void clear_issuerserial(); - uint32_t issuerserial() const; - void set_issuerserial(uint32_t value); - private: - uint32_t _internal_issuerserial() const; - void _internal_set_issuerserial(uint32_t value); - public: - - // optional uint64 notBefore = 4; - bool has_notbefore() const; - private: - bool _internal_has_notbefore() const; - public: - void clear_notbefore(); - uint64_t notbefore() const; - void set_notbefore(uint64_t value); - private: - uint64_t _internal_notbefore() const; - void _internal_set_notbefore(uint64_t value); - public: - - // optional uint64 notAfter = 5; - bool has_notafter() const; - private: - bool _internal_has_notafter() const; - public: - void clear_notafter(); - uint64_t notafter() const; - void set_notafter(uint64_t value); - private: - uint64_t _internal_notafter() const; - void _internal_set_notafter(uint64_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.CertChain.NoiseCertificate.Details) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_; - uint32_t serial_; - uint32_t issuerserial_; - uint64_t notbefore_; - uint64_t notafter_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class CertChain_NoiseCertificate final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.CertChain.NoiseCertificate) */ { - public: - inline CertChain_NoiseCertificate() : CertChain_NoiseCertificate(nullptr) {} - ~CertChain_NoiseCertificate() override; - explicit PROTOBUF_CONSTEXPR CertChain_NoiseCertificate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - CertChain_NoiseCertificate(const CertChain_NoiseCertificate& from); - CertChain_NoiseCertificate(CertChain_NoiseCertificate&& from) noexcept - : CertChain_NoiseCertificate() { - *this = ::std::move(from); - } - - inline CertChain_NoiseCertificate& operator=(const CertChain_NoiseCertificate& from) { - CopyFrom(from); - return *this; - } - inline CertChain_NoiseCertificate& operator=(CertChain_NoiseCertificate&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const CertChain_NoiseCertificate& default_instance() { - return *internal_default_instance(); - } - static inline const CertChain_NoiseCertificate* internal_default_instance() { - return reinterpret_cast( - &_CertChain_NoiseCertificate_default_instance_); - } - static constexpr int kIndexInFileMessages = - 11; - - friend void swap(CertChain_NoiseCertificate& a, CertChain_NoiseCertificate& b) { - a.Swap(&b); - } - inline void Swap(CertChain_NoiseCertificate* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(CertChain_NoiseCertificate* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - CertChain_NoiseCertificate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const CertChain_NoiseCertificate& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const CertChain_NoiseCertificate& from) { - CertChain_NoiseCertificate::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(CertChain_NoiseCertificate* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.CertChain.NoiseCertificate"; - } - protected: - explicit CertChain_NoiseCertificate(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef CertChain_NoiseCertificate_Details Details; - - // accessors ------------------------------------------------------- - - enum : int { - kDetailsFieldNumber = 1, - kSignatureFieldNumber = 2, - }; - // optional bytes details = 1; - bool has_details() const; - private: - bool _internal_has_details() const; - public: - void clear_details(); - const std::string& details() const; - template - void set_details(ArgT0&& arg0, ArgT... args); - std::string* mutable_details(); - PROTOBUF_NODISCARD std::string* release_details(); - void set_allocated_details(std::string* details); - private: - const std::string& _internal_details() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_details(const std::string& value); - std::string* _internal_mutable_details(); - public: - - // optional bytes signature = 2; - bool has_signature() const; - private: - bool _internal_has_signature() const; - public: - void clear_signature(); - const std::string& signature() const; - template - void set_signature(ArgT0&& arg0, ArgT... args); - std::string* mutable_signature(); - PROTOBUF_NODISCARD std::string* release_signature(); - void set_allocated_signature(std::string* signature); - private: - const std::string& _internal_signature() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value); - std::string* _internal_mutable_signature(); - public: - - // @@protoc_insertion_point(class_scope:proto.CertChain.NoiseCertificate) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr details_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class CertChain final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.CertChain) */ { - public: - inline CertChain() : CertChain(nullptr) {} - ~CertChain() override; - explicit PROTOBUF_CONSTEXPR CertChain(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - CertChain(const CertChain& from); - CertChain(CertChain&& from) noexcept - : CertChain() { - *this = ::std::move(from); - } - - inline CertChain& operator=(const CertChain& from) { - CopyFrom(from); - return *this; - } - inline CertChain& operator=(CertChain&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const CertChain& default_instance() { - return *internal_default_instance(); - } - static inline const CertChain* internal_default_instance() { - return reinterpret_cast( - &_CertChain_default_instance_); - } - static constexpr int kIndexInFileMessages = - 12; - - friend void swap(CertChain& a, CertChain& b) { - a.Swap(&b); - } - inline void Swap(CertChain* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(CertChain* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - CertChain* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const CertChain& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const CertChain& from) { - CertChain::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(CertChain* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.CertChain"; - } - protected: - explicit CertChain(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef CertChain_NoiseCertificate NoiseCertificate; - - // accessors ------------------------------------------------------- - - enum : int { - kLeafFieldNumber = 1, - kIntermediateFieldNumber = 2, - }; - // optional .proto.CertChain.NoiseCertificate leaf = 1; - bool has_leaf() const; - private: - bool _internal_has_leaf() const; - public: - void clear_leaf(); - const ::proto::CertChain_NoiseCertificate& leaf() const; - PROTOBUF_NODISCARD ::proto::CertChain_NoiseCertificate* release_leaf(); - ::proto::CertChain_NoiseCertificate* mutable_leaf(); - void set_allocated_leaf(::proto::CertChain_NoiseCertificate* leaf); - private: - const ::proto::CertChain_NoiseCertificate& _internal_leaf() const; - ::proto::CertChain_NoiseCertificate* _internal_mutable_leaf(); - public: - void unsafe_arena_set_allocated_leaf( - ::proto::CertChain_NoiseCertificate* leaf); - ::proto::CertChain_NoiseCertificate* unsafe_arena_release_leaf(); - - // optional .proto.CertChain.NoiseCertificate intermediate = 2; - bool has_intermediate() const; - private: - bool _internal_has_intermediate() const; - public: - void clear_intermediate(); - const ::proto::CertChain_NoiseCertificate& intermediate() const; - PROTOBUF_NODISCARD ::proto::CertChain_NoiseCertificate* release_intermediate(); - ::proto::CertChain_NoiseCertificate* mutable_intermediate(); - void set_allocated_intermediate(::proto::CertChain_NoiseCertificate* intermediate); - private: - const ::proto::CertChain_NoiseCertificate& _internal_intermediate() const; - ::proto::CertChain_NoiseCertificate* _internal_mutable_intermediate(); - public: - void unsafe_arena_set_allocated_intermediate( - ::proto::CertChain_NoiseCertificate* intermediate); - ::proto::CertChain_NoiseCertificate* unsafe_arena_release_intermediate(); - - // @@protoc_insertion_point(class_scope:proto.CertChain) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::proto::CertChain_NoiseCertificate* leaf_; - ::proto::CertChain_NoiseCertificate* intermediate_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Chain final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Chain) */ { - public: - inline Chain() : Chain(nullptr) {} - ~Chain() override; - explicit PROTOBUF_CONSTEXPR Chain(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Chain(const Chain& from); - Chain(Chain&& from) noexcept - : Chain() { - *this = ::std::move(from); - } - - inline Chain& operator=(const Chain& from) { - CopyFrom(from); - return *this; - } - inline Chain& operator=(Chain&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Chain& default_instance() { - return *internal_default_instance(); - } - static inline const Chain* internal_default_instance() { - return reinterpret_cast( - &_Chain_default_instance_); - } - static constexpr int kIndexInFileMessages = - 13; - - friend void swap(Chain& a, Chain& b) { - a.Swap(&b); - } - inline void Swap(Chain* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Chain* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Chain* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Chain& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Chain& from) { - Chain::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Chain* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Chain"; - } - protected: - explicit Chain(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kMessageKeysFieldNumber = 4, - kSenderRatchetKeyFieldNumber = 1, - kSenderRatchetKeyPrivateFieldNumber = 2, - kChainKeyFieldNumber = 3, - }; - // repeated .proto.MessageKey messageKeys = 4; - int messagekeys_size() const; - private: - int _internal_messagekeys_size() const; - public: - void clear_messagekeys(); - ::proto::MessageKey* mutable_messagekeys(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MessageKey >* - mutable_messagekeys(); - private: - const ::proto::MessageKey& _internal_messagekeys(int index) const; - ::proto::MessageKey* _internal_add_messagekeys(); - public: - const ::proto::MessageKey& messagekeys(int index) const; - ::proto::MessageKey* add_messagekeys(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MessageKey >& - messagekeys() const; - - // optional bytes senderRatchetKey = 1; - bool has_senderratchetkey() const; - private: - bool _internal_has_senderratchetkey() const; - public: - void clear_senderratchetkey(); - const std::string& senderratchetkey() const; - template - void set_senderratchetkey(ArgT0&& arg0, ArgT... args); - std::string* mutable_senderratchetkey(); - PROTOBUF_NODISCARD std::string* release_senderratchetkey(); - void set_allocated_senderratchetkey(std::string* senderratchetkey); - private: - const std::string& _internal_senderratchetkey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_senderratchetkey(const std::string& value); - std::string* _internal_mutable_senderratchetkey(); - public: - - // optional bytes senderRatchetKeyPrivate = 2; - bool has_senderratchetkeyprivate() const; - private: - bool _internal_has_senderratchetkeyprivate() const; - public: - void clear_senderratchetkeyprivate(); - const std::string& senderratchetkeyprivate() const; - template - void set_senderratchetkeyprivate(ArgT0&& arg0, ArgT... args); - std::string* mutable_senderratchetkeyprivate(); - PROTOBUF_NODISCARD std::string* release_senderratchetkeyprivate(); - void set_allocated_senderratchetkeyprivate(std::string* senderratchetkeyprivate); - private: - const std::string& _internal_senderratchetkeyprivate() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_senderratchetkeyprivate(const std::string& value); - std::string* _internal_mutable_senderratchetkeyprivate(); - public: - - // optional .proto.ChainKey chainKey = 3; - bool has_chainkey() const; - private: - bool _internal_has_chainkey() const; - public: - void clear_chainkey(); - const ::proto::ChainKey& chainkey() const; - PROTOBUF_NODISCARD ::proto::ChainKey* release_chainkey(); - ::proto::ChainKey* mutable_chainkey(); - void set_allocated_chainkey(::proto::ChainKey* chainkey); - private: - const ::proto::ChainKey& _internal_chainkey() const; - ::proto::ChainKey* _internal_mutable_chainkey(); - public: - void unsafe_arena_set_allocated_chainkey( - ::proto::ChainKey* chainkey); - ::proto::ChainKey* unsafe_arena_release_chainkey(); - - // @@protoc_insertion_point(class_scope:proto.Chain) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MessageKey > messagekeys_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr senderratchetkey_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr senderratchetkeyprivate_; - ::proto::ChainKey* chainkey_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class ChainKey final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ChainKey) */ { - public: - inline ChainKey() : ChainKey(nullptr) {} - ~ChainKey() override; - explicit PROTOBUF_CONSTEXPR ChainKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ChainKey(const ChainKey& from); - ChainKey(ChainKey&& from) noexcept - : ChainKey() { - *this = ::std::move(from); - } - - inline ChainKey& operator=(const ChainKey& from) { - CopyFrom(from); - return *this; - } - inline ChainKey& operator=(ChainKey&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const ChainKey& default_instance() { - return *internal_default_instance(); - } - static inline const ChainKey* internal_default_instance() { - return reinterpret_cast( - &_ChainKey_default_instance_); - } - static constexpr int kIndexInFileMessages = - 14; - - friend void swap(ChainKey& a, ChainKey& b) { - a.Swap(&b); - } - inline void Swap(ChainKey* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ChainKey* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ChainKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ChainKey& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const ChainKey& from) { - ChainKey::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ChainKey* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.ChainKey"; - } - protected: - explicit ChainKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kKeyFieldNumber = 2, - kIndexFieldNumber = 1, - }; - // optional bytes key = 2; - bool has_key() const; - private: - bool _internal_has_key() const; - public: - void clear_key(); - const std::string& key() const; - template - void set_key(ArgT0&& arg0, ArgT... args); - std::string* mutable_key(); - PROTOBUF_NODISCARD std::string* release_key(); - void set_allocated_key(std::string* key); - private: - const std::string& _internal_key() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value); - std::string* _internal_mutable_key(); - public: - - // optional uint32 index = 1; - bool has_index() const; - private: - bool _internal_has_index() const; - public: - void clear_index(); - uint32_t index() const; - void set_index(uint32_t value); - private: - uint32_t _internal_index() const; - void _internal_set_index(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.ChainKey) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_; - uint32_t index_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class ClientPayload_DNSSource final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ClientPayload.DNSSource) */ { - public: - inline ClientPayload_DNSSource() : ClientPayload_DNSSource(nullptr) {} - ~ClientPayload_DNSSource() override; - explicit PROTOBUF_CONSTEXPR ClientPayload_DNSSource(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ClientPayload_DNSSource(const ClientPayload_DNSSource& from); - ClientPayload_DNSSource(ClientPayload_DNSSource&& from) noexcept - : ClientPayload_DNSSource() { - *this = ::std::move(from); - } - - inline ClientPayload_DNSSource& operator=(const ClientPayload_DNSSource& from) { - CopyFrom(from); - return *this; - } - inline ClientPayload_DNSSource& operator=(ClientPayload_DNSSource&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const ClientPayload_DNSSource& default_instance() { - return *internal_default_instance(); - } - static inline const ClientPayload_DNSSource* internal_default_instance() { - return reinterpret_cast( - &_ClientPayload_DNSSource_default_instance_); - } - static constexpr int kIndexInFileMessages = - 15; - - friend void swap(ClientPayload_DNSSource& a, ClientPayload_DNSSource& b) { - a.Swap(&b); - } - inline void Swap(ClientPayload_DNSSource* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ClientPayload_DNSSource* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ClientPayload_DNSSource* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ClientPayload_DNSSource& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const ClientPayload_DNSSource& from) { - ClientPayload_DNSSource::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ClientPayload_DNSSource* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.ClientPayload.DNSSource"; - } - protected: - explicit ClientPayload_DNSSource(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef ClientPayload_DNSSource_DNSResolutionMethod DNSResolutionMethod; - static constexpr DNSResolutionMethod SYSTEM = - ClientPayload_DNSSource_DNSResolutionMethod_SYSTEM; - static constexpr DNSResolutionMethod GOOGLE = - ClientPayload_DNSSource_DNSResolutionMethod_GOOGLE; - static constexpr DNSResolutionMethod HARDCODED = - ClientPayload_DNSSource_DNSResolutionMethod_HARDCODED; - static constexpr DNSResolutionMethod OVERRIDE = - ClientPayload_DNSSource_DNSResolutionMethod_OVERRIDE; - static constexpr DNSResolutionMethod FALLBACK = - ClientPayload_DNSSource_DNSResolutionMethod_FALLBACK; - static inline bool DNSResolutionMethod_IsValid(int value) { - return ClientPayload_DNSSource_DNSResolutionMethod_IsValid(value); - } - static constexpr DNSResolutionMethod DNSResolutionMethod_MIN = - ClientPayload_DNSSource_DNSResolutionMethod_DNSResolutionMethod_MIN; - static constexpr DNSResolutionMethod DNSResolutionMethod_MAX = - ClientPayload_DNSSource_DNSResolutionMethod_DNSResolutionMethod_MAX; - static constexpr int DNSResolutionMethod_ARRAYSIZE = - ClientPayload_DNSSource_DNSResolutionMethod_DNSResolutionMethod_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - DNSResolutionMethod_descriptor() { - return ClientPayload_DNSSource_DNSResolutionMethod_descriptor(); - } - template - static inline const std::string& DNSResolutionMethod_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function DNSResolutionMethod_Name."); - return ClientPayload_DNSSource_DNSResolutionMethod_Name(enum_t_value); - } - static inline bool DNSResolutionMethod_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - DNSResolutionMethod* value) { - return ClientPayload_DNSSource_DNSResolutionMethod_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kDnsMethodFieldNumber = 15, - kAppCachedFieldNumber = 16, - }; - // optional .proto.ClientPayload.DNSSource.DNSResolutionMethod dnsMethod = 15; - bool has_dnsmethod() const; - private: - bool _internal_has_dnsmethod() const; - public: - void clear_dnsmethod(); - ::proto::ClientPayload_DNSSource_DNSResolutionMethod dnsmethod() const; - void set_dnsmethod(::proto::ClientPayload_DNSSource_DNSResolutionMethod value); - private: - ::proto::ClientPayload_DNSSource_DNSResolutionMethod _internal_dnsmethod() const; - void _internal_set_dnsmethod(::proto::ClientPayload_DNSSource_DNSResolutionMethod value); - public: - - // optional bool appCached = 16; - bool has_appcached() const; - private: - bool _internal_has_appcached() const; - public: - void clear_appcached(); - bool appcached() const; - void set_appcached(bool value); - private: - bool _internal_appcached() const; - void _internal_set_appcached(bool value); - public: - - // @@protoc_insertion_point(class_scope:proto.ClientPayload.DNSSource) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - int dnsmethod_; - bool appcached_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class ClientPayload_DevicePairingRegistrationData final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ClientPayload.DevicePairingRegistrationData) */ { - public: - inline ClientPayload_DevicePairingRegistrationData() : ClientPayload_DevicePairingRegistrationData(nullptr) {} - ~ClientPayload_DevicePairingRegistrationData() override; - explicit PROTOBUF_CONSTEXPR ClientPayload_DevicePairingRegistrationData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ClientPayload_DevicePairingRegistrationData(const ClientPayload_DevicePairingRegistrationData& from); - ClientPayload_DevicePairingRegistrationData(ClientPayload_DevicePairingRegistrationData&& from) noexcept - : ClientPayload_DevicePairingRegistrationData() { - *this = ::std::move(from); - } - - inline ClientPayload_DevicePairingRegistrationData& operator=(const ClientPayload_DevicePairingRegistrationData& from) { - CopyFrom(from); - return *this; - } - inline ClientPayload_DevicePairingRegistrationData& operator=(ClientPayload_DevicePairingRegistrationData&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const ClientPayload_DevicePairingRegistrationData& default_instance() { - return *internal_default_instance(); - } - static inline const ClientPayload_DevicePairingRegistrationData* internal_default_instance() { - return reinterpret_cast( - &_ClientPayload_DevicePairingRegistrationData_default_instance_); - } - static constexpr int kIndexInFileMessages = - 16; - - friend void swap(ClientPayload_DevicePairingRegistrationData& a, ClientPayload_DevicePairingRegistrationData& b) { - a.Swap(&b); - } - inline void Swap(ClientPayload_DevicePairingRegistrationData* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ClientPayload_DevicePairingRegistrationData* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ClientPayload_DevicePairingRegistrationData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ClientPayload_DevicePairingRegistrationData& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const ClientPayload_DevicePairingRegistrationData& from) { - ClientPayload_DevicePairingRegistrationData::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ClientPayload_DevicePairingRegistrationData* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.ClientPayload.DevicePairingRegistrationData"; - } - protected: - explicit ClientPayload_DevicePairingRegistrationData(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kERegidFieldNumber = 1, - kEKeytypeFieldNumber = 2, - kEIdentFieldNumber = 3, - kESkeyIdFieldNumber = 4, - kESkeyValFieldNumber = 5, - kESkeySigFieldNumber = 6, - kBuildHashFieldNumber = 7, - kDevicePropsFieldNumber = 8, - }; - // optional bytes eRegid = 1; - bool has_eregid() const; - private: - bool _internal_has_eregid() const; - public: - void clear_eregid(); - const std::string& eregid() const; - template - void set_eregid(ArgT0&& arg0, ArgT... args); - std::string* mutable_eregid(); - PROTOBUF_NODISCARD std::string* release_eregid(); - void set_allocated_eregid(std::string* eregid); - private: - const std::string& _internal_eregid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_eregid(const std::string& value); - std::string* _internal_mutable_eregid(); - public: - - // optional bytes eKeytype = 2; - bool has_ekeytype() const; - private: - bool _internal_has_ekeytype() const; - public: - void clear_ekeytype(); - const std::string& ekeytype() const; - template - void set_ekeytype(ArgT0&& arg0, ArgT... args); - std::string* mutable_ekeytype(); - PROTOBUF_NODISCARD std::string* release_ekeytype(); - void set_allocated_ekeytype(std::string* ekeytype); - private: - const std::string& _internal_ekeytype() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_ekeytype(const std::string& value); - std::string* _internal_mutable_ekeytype(); - public: - - // optional bytes eIdent = 3; - bool has_eident() const; - private: - bool _internal_has_eident() const; - public: - void clear_eident(); - const std::string& eident() const; - template - void set_eident(ArgT0&& arg0, ArgT... args); - std::string* mutable_eident(); - PROTOBUF_NODISCARD std::string* release_eident(); - void set_allocated_eident(std::string* eident); - private: - const std::string& _internal_eident() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_eident(const std::string& value); - std::string* _internal_mutable_eident(); - public: - - // optional bytes eSkeyId = 4; - bool has_eskeyid() const; - private: - bool _internal_has_eskeyid() const; - public: - void clear_eskeyid(); - const std::string& eskeyid() const; - template - void set_eskeyid(ArgT0&& arg0, ArgT... args); - std::string* mutable_eskeyid(); - PROTOBUF_NODISCARD std::string* release_eskeyid(); - void set_allocated_eskeyid(std::string* eskeyid); - private: - const std::string& _internal_eskeyid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_eskeyid(const std::string& value); - std::string* _internal_mutable_eskeyid(); - public: - - // optional bytes eSkeyVal = 5; - bool has_eskeyval() const; - private: - bool _internal_has_eskeyval() const; - public: - void clear_eskeyval(); - const std::string& eskeyval() const; - template - void set_eskeyval(ArgT0&& arg0, ArgT... args); - std::string* mutable_eskeyval(); - PROTOBUF_NODISCARD std::string* release_eskeyval(); - void set_allocated_eskeyval(std::string* eskeyval); - private: - const std::string& _internal_eskeyval() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_eskeyval(const std::string& value); - std::string* _internal_mutable_eskeyval(); - public: - - // optional bytes eSkeySig = 6; - bool has_eskeysig() const; - private: - bool _internal_has_eskeysig() const; - public: - void clear_eskeysig(); - const std::string& eskeysig() const; - template - void set_eskeysig(ArgT0&& arg0, ArgT... args); - std::string* mutable_eskeysig(); - PROTOBUF_NODISCARD std::string* release_eskeysig(); - void set_allocated_eskeysig(std::string* eskeysig); - private: - const std::string& _internal_eskeysig() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_eskeysig(const std::string& value); - std::string* _internal_mutable_eskeysig(); - public: - - // optional bytes buildHash = 7; - bool has_buildhash() const; - private: - bool _internal_has_buildhash() const; - public: - void clear_buildhash(); - const std::string& buildhash() const; - template - void set_buildhash(ArgT0&& arg0, ArgT... args); - std::string* mutable_buildhash(); - PROTOBUF_NODISCARD std::string* release_buildhash(); - void set_allocated_buildhash(std::string* buildhash); - private: - const std::string& _internal_buildhash() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_buildhash(const std::string& value); - std::string* _internal_mutable_buildhash(); - public: - - // optional bytes deviceProps = 8; - bool has_deviceprops() const; - private: - bool _internal_has_deviceprops() const; - public: - void clear_deviceprops(); - const std::string& deviceprops() const; - template - void set_deviceprops(ArgT0&& arg0, ArgT... args); - std::string* mutable_deviceprops(); - PROTOBUF_NODISCARD std::string* release_deviceprops(); - void set_allocated_deviceprops(std::string* deviceprops); - private: - const std::string& _internal_deviceprops() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_deviceprops(const std::string& value); - std::string* _internal_mutable_deviceprops(); - public: - - // @@protoc_insertion_point(class_scope:proto.ClientPayload.DevicePairingRegistrationData) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr eregid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ekeytype_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr eident_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr eskeyid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr eskeyval_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr eskeysig_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr buildhash_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr deviceprops_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class ClientPayload_UserAgent_AppVersion final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ClientPayload.UserAgent.AppVersion) */ { - public: - inline ClientPayload_UserAgent_AppVersion() : ClientPayload_UserAgent_AppVersion(nullptr) {} - ~ClientPayload_UserAgent_AppVersion() override; - explicit PROTOBUF_CONSTEXPR ClientPayload_UserAgent_AppVersion(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ClientPayload_UserAgent_AppVersion(const ClientPayload_UserAgent_AppVersion& from); - ClientPayload_UserAgent_AppVersion(ClientPayload_UserAgent_AppVersion&& from) noexcept - : ClientPayload_UserAgent_AppVersion() { - *this = ::std::move(from); - } - - inline ClientPayload_UserAgent_AppVersion& operator=(const ClientPayload_UserAgent_AppVersion& from) { - CopyFrom(from); - return *this; - } - inline ClientPayload_UserAgent_AppVersion& operator=(ClientPayload_UserAgent_AppVersion&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const ClientPayload_UserAgent_AppVersion& default_instance() { - return *internal_default_instance(); - } - static inline const ClientPayload_UserAgent_AppVersion* internal_default_instance() { - return reinterpret_cast( - &_ClientPayload_UserAgent_AppVersion_default_instance_); - } - static constexpr int kIndexInFileMessages = - 17; - - friend void swap(ClientPayload_UserAgent_AppVersion& a, ClientPayload_UserAgent_AppVersion& b) { - a.Swap(&b); - } - inline void Swap(ClientPayload_UserAgent_AppVersion* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ClientPayload_UserAgent_AppVersion* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ClientPayload_UserAgent_AppVersion* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ClientPayload_UserAgent_AppVersion& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const ClientPayload_UserAgent_AppVersion& from) { - ClientPayload_UserAgent_AppVersion::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ClientPayload_UserAgent_AppVersion* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.ClientPayload.UserAgent.AppVersion"; - } - protected: - explicit ClientPayload_UserAgent_AppVersion(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kPrimaryFieldNumber = 1, - kSecondaryFieldNumber = 2, - kTertiaryFieldNumber = 3, - kQuaternaryFieldNumber = 4, - kQuinaryFieldNumber = 5, - }; - // optional uint32 primary = 1; - bool has_primary() const; - private: - bool _internal_has_primary() const; - public: - void clear_primary(); - uint32_t primary() const; - void set_primary(uint32_t value); - private: - uint32_t _internal_primary() const; - void _internal_set_primary(uint32_t value); - public: - - // optional uint32 secondary = 2; - bool has_secondary() const; - private: - bool _internal_has_secondary() const; - public: - void clear_secondary(); - uint32_t secondary() const; - void set_secondary(uint32_t value); - private: - uint32_t _internal_secondary() const; - void _internal_set_secondary(uint32_t value); - public: - - // optional uint32 tertiary = 3; - bool has_tertiary() const; - private: - bool _internal_has_tertiary() const; - public: - void clear_tertiary(); - uint32_t tertiary() const; - void set_tertiary(uint32_t value); - private: - uint32_t _internal_tertiary() const; - void _internal_set_tertiary(uint32_t value); - public: - - // optional uint32 quaternary = 4; - bool has_quaternary() const; - private: - bool _internal_has_quaternary() const; - public: - void clear_quaternary(); - uint32_t quaternary() const; - void set_quaternary(uint32_t value); - private: - uint32_t _internal_quaternary() const; - void _internal_set_quaternary(uint32_t value); - public: - - // optional uint32 quinary = 5; - bool has_quinary() const; - private: - bool _internal_has_quinary() const; - public: - void clear_quinary(); - uint32_t quinary() const; - void set_quinary(uint32_t value); - private: - uint32_t _internal_quinary() const; - void _internal_set_quinary(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.ClientPayload.UserAgent.AppVersion) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t primary_; - uint32_t secondary_; - uint32_t tertiary_; - uint32_t quaternary_; - uint32_t quinary_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class ClientPayload_UserAgent final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ClientPayload.UserAgent) */ { - public: - inline ClientPayload_UserAgent() : ClientPayload_UserAgent(nullptr) {} - ~ClientPayload_UserAgent() override; - explicit PROTOBUF_CONSTEXPR ClientPayload_UserAgent(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ClientPayload_UserAgent(const ClientPayload_UserAgent& from); - ClientPayload_UserAgent(ClientPayload_UserAgent&& from) noexcept - : ClientPayload_UserAgent() { - *this = ::std::move(from); - } - - inline ClientPayload_UserAgent& operator=(const ClientPayload_UserAgent& from) { - CopyFrom(from); - return *this; - } - inline ClientPayload_UserAgent& operator=(ClientPayload_UserAgent&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const ClientPayload_UserAgent& default_instance() { - return *internal_default_instance(); - } - static inline const ClientPayload_UserAgent* internal_default_instance() { - return reinterpret_cast( - &_ClientPayload_UserAgent_default_instance_); - } - static constexpr int kIndexInFileMessages = - 18; - - friend void swap(ClientPayload_UserAgent& a, ClientPayload_UserAgent& b) { - a.Swap(&b); - } - inline void Swap(ClientPayload_UserAgent* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ClientPayload_UserAgent* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ClientPayload_UserAgent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ClientPayload_UserAgent& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const ClientPayload_UserAgent& from) { - ClientPayload_UserAgent::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ClientPayload_UserAgent* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.ClientPayload.UserAgent"; - } - protected: - explicit ClientPayload_UserAgent(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef ClientPayload_UserAgent_AppVersion AppVersion; - - typedef ClientPayload_UserAgent_Platform Platform; - static constexpr Platform ANDROID = - ClientPayload_UserAgent_Platform_ANDROID; - static constexpr Platform IOS = - ClientPayload_UserAgent_Platform_IOS; - static constexpr Platform WINDOWS_PHONE = - ClientPayload_UserAgent_Platform_WINDOWS_PHONE; - static constexpr Platform BLACKBERRY = - ClientPayload_UserAgent_Platform_BLACKBERRY; - static constexpr Platform BLACKBERRYX = - ClientPayload_UserAgent_Platform_BLACKBERRYX; - static constexpr Platform S40 = - ClientPayload_UserAgent_Platform_S40; - static constexpr Platform S60 = - ClientPayload_UserAgent_Platform_S60; - static constexpr Platform PYTHON_CLIENT = - ClientPayload_UserAgent_Platform_PYTHON_CLIENT; - static constexpr Platform TIZEN = - ClientPayload_UserAgent_Platform_TIZEN; - static constexpr Platform ENTERPRISE = - ClientPayload_UserAgent_Platform_ENTERPRISE; - static constexpr Platform SMB_ANDROID = - ClientPayload_UserAgent_Platform_SMB_ANDROID; - static constexpr Platform KAIOS = - ClientPayload_UserAgent_Platform_KAIOS; - static constexpr Platform SMB_IOS = - ClientPayload_UserAgent_Platform_SMB_IOS; - static constexpr Platform WINDA = - ClientPayload_UserAgent_Platform_WINDOWS; - static constexpr Platform WEB = - ClientPayload_UserAgent_Platform_WEB; - static constexpr Platform PORTAL = - ClientPayload_UserAgent_Platform_PORTAL; - static constexpr Platform GREEN_ANDROID = - ClientPayload_UserAgent_Platform_GREEN_ANDROID; - static constexpr Platform GREEN_IPHONE = - ClientPayload_UserAgent_Platform_GREEN_IPHONE; - static constexpr Platform BLUE_ANDROID = - ClientPayload_UserAgent_Platform_BLUE_ANDROID; - static constexpr Platform BLUE_IPHONE = - ClientPayload_UserAgent_Platform_BLUE_IPHONE; - static constexpr Platform FBLITE_ANDROID = - ClientPayload_UserAgent_Platform_FBLITE_ANDROID; - static constexpr Platform MLITE_ANDROID = - ClientPayload_UserAgent_Platform_MLITE_ANDROID; - static constexpr Platform IGLITE_ANDROID = - ClientPayload_UserAgent_Platform_IGLITE_ANDROID; - static constexpr Platform PAGE = - ClientPayload_UserAgent_Platform_PAGE; - static constexpr Platform MACOS = - ClientPayload_UserAgent_Platform_MACOS; - static constexpr Platform OCULUS_MSG = - ClientPayload_UserAgent_Platform_OCULUS_MSG; - static constexpr Platform OCULUS_CALL = - ClientPayload_UserAgent_Platform_OCULUS_CALL; - static constexpr Platform MILAN = - ClientPayload_UserAgent_Platform_MILAN; - static constexpr Platform CAPI = - ClientPayload_UserAgent_Platform_CAPI; - static inline bool Platform_IsValid(int value) { - return ClientPayload_UserAgent_Platform_IsValid(value); - } - static constexpr Platform Platform_MIN = - ClientPayload_UserAgent_Platform_Platform_MIN; - static constexpr Platform Platform_MAX = - ClientPayload_UserAgent_Platform_Platform_MAX; - static constexpr int Platform_ARRAYSIZE = - ClientPayload_UserAgent_Platform_Platform_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - Platform_descriptor() { - return ClientPayload_UserAgent_Platform_descriptor(); - } - template - static inline const std::string& Platform_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Platform_Name."); - return ClientPayload_UserAgent_Platform_Name(enum_t_value); - } - static inline bool Platform_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - Platform* value) { - return ClientPayload_UserAgent_Platform_Parse(name, value); - } - - typedef ClientPayload_UserAgent_ReleaseChannel ReleaseChannel; - static constexpr ReleaseChannel RELEASE = - ClientPayload_UserAgent_ReleaseChannel_RELEASE; - static constexpr ReleaseChannel BETA = - ClientPayload_UserAgent_ReleaseChannel_BETA; - static constexpr ReleaseChannel ALPHA = - ClientPayload_UserAgent_ReleaseChannel_ALPHA; - static constexpr ReleaseChannel DEBUG = - ClientPayload_UserAgent_ReleaseChannel_DEBUG; - static inline bool ReleaseChannel_IsValid(int value) { - return ClientPayload_UserAgent_ReleaseChannel_IsValid(value); - } - static constexpr ReleaseChannel ReleaseChannel_MIN = - ClientPayload_UserAgent_ReleaseChannel_ReleaseChannel_MIN; - static constexpr ReleaseChannel ReleaseChannel_MAX = - ClientPayload_UserAgent_ReleaseChannel_ReleaseChannel_MAX; - static constexpr int ReleaseChannel_ARRAYSIZE = - ClientPayload_UserAgent_ReleaseChannel_ReleaseChannel_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - ReleaseChannel_descriptor() { - return ClientPayload_UserAgent_ReleaseChannel_descriptor(); - } - template - static inline const std::string& ReleaseChannel_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function ReleaseChannel_Name."); - return ClientPayload_UserAgent_ReleaseChannel_Name(enum_t_value); - } - static inline bool ReleaseChannel_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - ReleaseChannel* value) { - return ClientPayload_UserAgent_ReleaseChannel_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kMccFieldNumber = 3, - kMncFieldNumber = 4, - kOsVersionFieldNumber = 5, - kManufacturerFieldNumber = 6, - kDeviceFieldNumber = 7, - kOsBuildNumberFieldNumber = 8, - kPhoneIdFieldNumber = 9, - kLocaleLanguageIso6391FieldNumber = 11, - kLocaleCountryIso31661Alpha2FieldNumber = 12, - kDeviceBoardFieldNumber = 13, - kAppVersionFieldNumber = 2, - kPlatformFieldNumber = 1, - kReleaseChannelFieldNumber = 10, - }; - // optional string mcc = 3; - bool has_mcc() const; - private: - bool _internal_has_mcc() const; - public: - void clear_mcc(); - const std::string& mcc() const; - template - void set_mcc(ArgT0&& arg0, ArgT... args); - std::string* mutable_mcc(); - PROTOBUF_NODISCARD std::string* release_mcc(); - void set_allocated_mcc(std::string* mcc); - private: - const std::string& _internal_mcc() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_mcc(const std::string& value); - std::string* _internal_mutable_mcc(); - public: - - // optional string mnc = 4; - bool has_mnc() const; - private: - bool _internal_has_mnc() const; - public: - void clear_mnc(); - const std::string& mnc() const; - template - void set_mnc(ArgT0&& arg0, ArgT... args); - std::string* mutable_mnc(); - PROTOBUF_NODISCARD std::string* release_mnc(); - void set_allocated_mnc(std::string* mnc); - private: - const std::string& _internal_mnc() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_mnc(const std::string& value); - std::string* _internal_mutable_mnc(); - public: - - // optional string osVersion = 5; - bool has_osversion() const; - private: - bool _internal_has_osversion() const; - public: - void clear_osversion(); - const std::string& osversion() const; - template - void set_osversion(ArgT0&& arg0, ArgT... args); - std::string* mutable_osversion(); - PROTOBUF_NODISCARD std::string* release_osversion(); - void set_allocated_osversion(std::string* osversion); - private: - const std::string& _internal_osversion() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_osversion(const std::string& value); - std::string* _internal_mutable_osversion(); - public: - - // optional string manufacturer = 6; - bool has_manufacturer() const; - private: - bool _internal_has_manufacturer() const; - public: - void clear_manufacturer(); - const std::string& manufacturer() const; - template - void set_manufacturer(ArgT0&& arg0, ArgT... args); - std::string* mutable_manufacturer(); - PROTOBUF_NODISCARD std::string* release_manufacturer(); - void set_allocated_manufacturer(std::string* manufacturer); - private: - const std::string& _internal_manufacturer() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_manufacturer(const std::string& value); - std::string* _internal_mutable_manufacturer(); - public: - - // optional string device = 7; - bool has_device() const; - private: - bool _internal_has_device() const; - public: - void clear_device(); - const std::string& device() const; - template - void set_device(ArgT0&& arg0, ArgT... args); - std::string* mutable_device(); - PROTOBUF_NODISCARD std::string* release_device(); - void set_allocated_device(std::string* device); - private: - const std::string& _internal_device() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_device(const std::string& value); - std::string* _internal_mutable_device(); - public: - - // optional string osBuildNumber = 8; - bool has_osbuildnumber() const; - private: - bool _internal_has_osbuildnumber() const; - public: - void clear_osbuildnumber(); - const std::string& osbuildnumber() const; - template - void set_osbuildnumber(ArgT0&& arg0, ArgT... args); - std::string* mutable_osbuildnumber(); - PROTOBUF_NODISCARD std::string* release_osbuildnumber(); - void set_allocated_osbuildnumber(std::string* osbuildnumber); - private: - const std::string& _internal_osbuildnumber() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_osbuildnumber(const std::string& value); - std::string* _internal_mutable_osbuildnumber(); - public: - - // optional string phoneId = 9; - bool has_phoneid() const; - private: - bool _internal_has_phoneid() const; - public: - void clear_phoneid(); - const std::string& phoneid() const; - template - void set_phoneid(ArgT0&& arg0, ArgT... args); - std::string* mutable_phoneid(); - PROTOBUF_NODISCARD std::string* release_phoneid(); - void set_allocated_phoneid(std::string* phoneid); - private: - const std::string& _internal_phoneid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_phoneid(const std::string& value); - std::string* _internal_mutable_phoneid(); - public: - - // optional string localeLanguageIso6391 = 11; - bool has_localelanguageiso6391() const; - private: - bool _internal_has_localelanguageiso6391() const; - public: - void clear_localelanguageiso6391(); - const std::string& localelanguageiso6391() const; - template - void set_localelanguageiso6391(ArgT0&& arg0, ArgT... args); - std::string* mutable_localelanguageiso6391(); - PROTOBUF_NODISCARD std::string* release_localelanguageiso6391(); - void set_allocated_localelanguageiso6391(std::string* localelanguageiso6391); - private: - const std::string& _internal_localelanguageiso6391() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_localelanguageiso6391(const std::string& value); - std::string* _internal_mutable_localelanguageiso6391(); - public: - - // optional string localeCountryIso31661Alpha2 = 12; - bool has_localecountryiso31661alpha2() const; - private: - bool _internal_has_localecountryiso31661alpha2() const; - public: - void clear_localecountryiso31661alpha2(); - const std::string& localecountryiso31661alpha2() const; - template - void set_localecountryiso31661alpha2(ArgT0&& arg0, ArgT... args); - std::string* mutable_localecountryiso31661alpha2(); - PROTOBUF_NODISCARD std::string* release_localecountryiso31661alpha2(); - void set_allocated_localecountryiso31661alpha2(std::string* localecountryiso31661alpha2); - private: - const std::string& _internal_localecountryiso31661alpha2() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_localecountryiso31661alpha2(const std::string& value); - std::string* _internal_mutable_localecountryiso31661alpha2(); - public: - - // optional string deviceBoard = 13; - bool has_deviceboard() const; - private: - bool _internal_has_deviceboard() const; - public: - void clear_deviceboard(); - const std::string& deviceboard() const; - template - void set_deviceboard(ArgT0&& arg0, ArgT... args); - std::string* mutable_deviceboard(); - PROTOBUF_NODISCARD std::string* release_deviceboard(); - void set_allocated_deviceboard(std::string* deviceboard); - private: - const std::string& _internal_deviceboard() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_deviceboard(const std::string& value); - std::string* _internal_mutable_deviceboard(); - public: - - // optional .proto.ClientPayload.UserAgent.AppVersion appVersion = 2; - bool has_appversion() const; - private: - bool _internal_has_appversion() const; - public: - void clear_appversion(); - const ::proto::ClientPayload_UserAgent_AppVersion& appversion() const; - PROTOBUF_NODISCARD ::proto::ClientPayload_UserAgent_AppVersion* release_appversion(); - ::proto::ClientPayload_UserAgent_AppVersion* mutable_appversion(); - void set_allocated_appversion(::proto::ClientPayload_UserAgent_AppVersion* appversion); - private: - const ::proto::ClientPayload_UserAgent_AppVersion& _internal_appversion() const; - ::proto::ClientPayload_UserAgent_AppVersion* _internal_mutable_appversion(); - public: - void unsafe_arena_set_allocated_appversion( - ::proto::ClientPayload_UserAgent_AppVersion* appversion); - ::proto::ClientPayload_UserAgent_AppVersion* unsafe_arena_release_appversion(); - - // optional .proto.ClientPayload.UserAgent.Platform platform = 1; - bool has_platform() const; - private: - bool _internal_has_platform() const; - public: - void clear_platform(); - ::proto::ClientPayload_UserAgent_Platform platform() const; - void set_platform(::proto::ClientPayload_UserAgent_Platform value); - private: - ::proto::ClientPayload_UserAgent_Platform _internal_platform() const; - void _internal_set_platform(::proto::ClientPayload_UserAgent_Platform value); - public: - - // optional .proto.ClientPayload.UserAgent.ReleaseChannel releaseChannel = 10; - bool has_releasechannel() const; - private: - bool _internal_has_releasechannel() const; - public: - void clear_releasechannel(); - ::proto::ClientPayload_UserAgent_ReleaseChannel releasechannel() const; - void set_releasechannel(::proto::ClientPayload_UserAgent_ReleaseChannel value); - private: - ::proto::ClientPayload_UserAgent_ReleaseChannel _internal_releasechannel() const; - void _internal_set_releasechannel(::proto::ClientPayload_UserAgent_ReleaseChannel value); - public: - - // @@protoc_insertion_point(class_scope:proto.ClientPayload.UserAgent) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mcc_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mnc_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr osversion_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr manufacturer_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr osbuildnumber_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr phoneid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localelanguageiso6391_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localecountryiso31661alpha2_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr deviceboard_; - ::proto::ClientPayload_UserAgent_AppVersion* appversion_; - int platform_; - int releasechannel_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class ClientPayload_WebInfo_WebdPayload final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ClientPayload.WebInfo.WebdPayload) */ { - public: - inline ClientPayload_WebInfo_WebdPayload() : ClientPayload_WebInfo_WebdPayload(nullptr) {} - ~ClientPayload_WebInfo_WebdPayload() override; - explicit PROTOBUF_CONSTEXPR ClientPayload_WebInfo_WebdPayload(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ClientPayload_WebInfo_WebdPayload(const ClientPayload_WebInfo_WebdPayload& from); - ClientPayload_WebInfo_WebdPayload(ClientPayload_WebInfo_WebdPayload&& from) noexcept - : ClientPayload_WebInfo_WebdPayload() { - *this = ::std::move(from); - } - - inline ClientPayload_WebInfo_WebdPayload& operator=(const ClientPayload_WebInfo_WebdPayload& from) { - CopyFrom(from); - return *this; - } - inline ClientPayload_WebInfo_WebdPayload& operator=(ClientPayload_WebInfo_WebdPayload&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const ClientPayload_WebInfo_WebdPayload& default_instance() { - return *internal_default_instance(); - } - static inline const ClientPayload_WebInfo_WebdPayload* internal_default_instance() { - return reinterpret_cast( - &_ClientPayload_WebInfo_WebdPayload_default_instance_); - } - static constexpr int kIndexInFileMessages = - 19; - - friend void swap(ClientPayload_WebInfo_WebdPayload& a, ClientPayload_WebInfo_WebdPayload& b) { - a.Swap(&b); - } - inline void Swap(ClientPayload_WebInfo_WebdPayload* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ClientPayload_WebInfo_WebdPayload* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ClientPayload_WebInfo_WebdPayload* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ClientPayload_WebInfo_WebdPayload& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const ClientPayload_WebInfo_WebdPayload& from) { - ClientPayload_WebInfo_WebdPayload::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ClientPayload_WebInfo_WebdPayload* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.ClientPayload.WebInfo.WebdPayload"; - } - protected: - explicit ClientPayload_WebInfo_WebdPayload(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kDocumentTypesFieldNumber = 10, - kFeaturesFieldNumber = 11, - kUsesParticipantInKeyFieldNumber = 1, - kSupportsStarredMessagesFieldNumber = 2, - kSupportsDocumentMessagesFieldNumber = 3, - kSupportsUrlMessagesFieldNumber = 4, - kSupportsMediaRetryFieldNumber = 5, - kSupportsE2EImageFieldNumber = 6, - kSupportsE2EVideoFieldNumber = 7, - kSupportsE2EAudioFieldNumber = 8, - kSupportsE2EDocumentFieldNumber = 9, - }; - // optional string documentTypes = 10; - bool has_documenttypes() const; - private: - bool _internal_has_documenttypes() const; - public: - void clear_documenttypes(); - const std::string& documenttypes() const; - template - void set_documenttypes(ArgT0&& arg0, ArgT... args); - std::string* mutable_documenttypes(); - PROTOBUF_NODISCARD std::string* release_documenttypes(); - void set_allocated_documenttypes(std::string* documenttypes); - private: - const std::string& _internal_documenttypes() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_documenttypes(const std::string& value); - std::string* _internal_mutable_documenttypes(); - public: - - // optional bytes features = 11; - bool has_features() const; - private: - bool _internal_has_features() const; - public: - void clear_features(); - const std::string& features() const; - template - void set_features(ArgT0&& arg0, ArgT... args); - std::string* mutable_features(); - PROTOBUF_NODISCARD std::string* release_features(); - void set_allocated_features(std::string* features); - private: - const std::string& _internal_features() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_features(const std::string& value); - std::string* _internal_mutable_features(); - public: - - // optional bool usesParticipantInKey = 1; - bool has_usesparticipantinkey() const; - private: - bool _internal_has_usesparticipantinkey() const; - public: - void clear_usesparticipantinkey(); - bool usesparticipantinkey() const; - void set_usesparticipantinkey(bool value); - private: - bool _internal_usesparticipantinkey() const; - void _internal_set_usesparticipantinkey(bool value); - public: - - // optional bool supportsStarredMessages = 2; - bool has_supportsstarredmessages() const; - private: - bool _internal_has_supportsstarredmessages() const; - public: - void clear_supportsstarredmessages(); - bool supportsstarredmessages() const; - void set_supportsstarredmessages(bool value); - private: - bool _internal_supportsstarredmessages() const; - void _internal_set_supportsstarredmessages(bool value); - public: - - // optional bool supportsDocumentMessages = 3; - bool has_supportsdocumentmessages() const; - private: - bool _internal_has_supportsdocumentmessages() const; - public: - void clear_supportsdocumentmessages(); - bool supportsdocumentmessages() const; - void set_supportsdocumentmessages(bool value); - private: - bool _internal_supportsdocumentmessages() const; - void _internal_set_supportsdocumentmessages(bool value); - public: - - // optional bool supportsUrlMessages = 4; - bool has_supportsurlmessages() const; - private: - bool _internal_has_supportsurlmessages() const; - public: - void clear_supportsurlmessages(); - bool supportsurlmessages() const; - void set_supportsurlmessages(bool value); - private: - bool _internal_supportsurlmessages() const; - void _internal_set_supportsurlmessages(bool value); - public: - - // optional bool supportsMediaRetry = 5; - bool has_supportsmediaretry() const; - private: - bool _internal_has_supportsmediaretry() const; - public: - void clear_supportsmediaretry(); - bool supportsmediaretry() const; - void set_supportsmediaretry(bool value); - private: - bool _internal_supportsmediaretry() const; - void _internal_set_supportsmediaretry(bool value); - public: - - // optional bool supportsE2EImage = 6; - bool has_supportse2eimage() const; - private: - bool _internal_has_supportse2eimage() const; - public: - void clear_supportse2eimage(); - bool supportse2eimage() const; - void set_supportse2eimage(bool value); - private: - bool _internal_supportse2eimage() const; - void _internal_set_supportse2eimage(bool value); - public: - - // optional bool supportsE2EVideo = 7; - bool has_supportse2evideo() const; - private: - bool _internal_has_supportse2evideo() const; - public: - void clear_supportse2evideo(); - bool supportse2evideo() const; - void set_supportse2evideo(bool value); - private: - bool _internal_supportse2evideo() const; - void _internal_set_supportse2evideo(bool value); - public: - - // optional bool supportsE2EAudio = 8; - bool has_supportse2eaudio() const; - private: - bool _internal_has_supportse2eaudio() const; - public: - void clear_supportse2eaudio(); - bool supportse2eaudio() const; - void set_supportse2eaudio(bool value); - private: - bool _internal_supportse2eaudio() const; - void _internal_set_supportse2eaudio(bool value); - public: - - // optional bool supportsE2EDocument = 9; - bool has_supportse2edocument() const; - private: - bool _internal_has_supportse2edocument() const; - public: - void clear_supportse2edocument(); - bool supportse2edocument() const; - void set_supportse2edocument(bool value); - private: - bool _internal_supportse2edocument() const; - void _internal_set_supportse2edocument(bool value); - public: - - // @@protoc_insertion_point(class_scope:proto.ClientPayload.WebInfo.WebdPayload) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr documenttypes_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr features_; - bool usesparticipantinkey_; - bool supportsstarredmessages_; - bool supportsdocumentmessages_; - bool supportsurlmessages_; - bool supportsmediaretry_; - bool supportse2eimage_; - bool supportse2evideo_; - bool supportse2eaudio_; - bool supportse2edocument_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class ClientPayload_WebInfo final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ClientPayload.WebInfo) */ { - public: - inline ClientPayload_WebInfo() : ClientPayload_WebInfo(nullptr) {} - ~ClientPayload_WebInfo() override; - explicit PROTOBUF_CONSTEXPR ClientPayload_WebInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ClientPayload_WebInfo(const ClientPayload_WebInfo& from); - ClientPayload_WebInfo(ClientPayload_WebInfo&& from) noexcept - : ClientPayload_WebInfo() { - *this = ::std::move(from); - } - - inline ClientPayload_WebInfo& operator=(const ClientPayload_WebInfo& from) { - CopyFrom(from); - return *this; - } - inline ClientPayload_WebInfo& operator=(ClientPayload_WebInfo&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const ClientPayload_WebInfo& default_instance() { - return *internal_default_instance(); - } - static inline const ClientPayload_WebInfo* internal_default_instance() { - return reinterpret_cast( - &_ClientPayload_WebInfo_default_instance_); - } - static constexpr int kIndexInFileMessages = - 20; - - friend void swap(ClientPayload_WebInfo& a, ClientPayload_WebInfo& b) { - a.Swap(&b); - } - inline void Swap(ClientPayload_WebInfo* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ClientPayload_WebInfo* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ClientPayload_WebInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ClientPayload_WebInfo& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const ClientPayload_WebInfo& from) { - ClientPayload_WebInfo::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ClientPayload_WebInfo* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.ClientPayload.WebInfo"; - } - protected: - explicit ClientPayload_WebInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef ClientPayload_WebInfo_WebdPayload WebdPayload; - - typedef ClientPayload_WebInfo_WebSubPlatform WebSubPlatform; - static constexpr WebSubPlatform WEB_BROWSER = - ClientPayload_WebInfo_WebSubPlatform_WEB_BROWSER; - static constexpr WebSubPlatform APP_STORE = - ClientPayload_WebInfo_WebSubPlatform_APP_STORE; - static constexpr WebSubPlatform WIN_STORE = - ClientPayload_WebInfo_WebSubPlatform_WIN_STORE; - static constexpr WebSubPlatform DARWIN = - ClientPayload_WebInfo_WebSubPlatform_DARWIN; - static constexpr WebSubPlatform WINDA = - ClientPayload_WebInfo_WebSubPlatform_WINDA; - static inline bool WebSubPlatform_IsValid(int value) { - return ClientPayload_WebInfo_WebSubPlatform_IsValid(value); - } - static constexpr WebSubPlatform WebSubPlatform_MIN = - ClientPayload_WebInfo_WebSubPlatform_WebSubPlatform_MIN; - static constexpr WebSubPlatform WebSubPlatform_MAX = - ClientPayload_WebInfo_WebSubPlatform_WebSubPlatform_MAX; - static constexpr int WebSubPlatform_ARRAYSIZE = - ClientPayload_WebInfo_WebSubPlatform_WebSubPlatform_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - WebSubPlatform_descriptor() { - return ClientPayload_WebInfo_WebSubPlatform_descriptor(); - } - template - static inline const std::string& WebSubPlatform_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function WebSubPlatform_Name."); - return ClientPayload_WebInfo_WebSubPlatform_Name(enum_t_value); - } - static inline bool WebSubPlatform_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - WebSubPlatform* value) { - return ClientPayload_WebInfo_WebSubPlatform_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kRefTokenFieldNumber = 1, - kVersionFieldNumber = 2, - kWebdPayloadFieldNumber = 3, - kWebSubPlatformFieldNumber = 4, - }; - // optional string refToken = 1; - bool has_reftoken() const; - private: - bool _internal_has_reftoken() const; - public: - void clear_reftoken(); - const std::string& reftoken() const; - template - void set_reftoken(ArgT0&& arg0, ArgT... args); - std::string* mutable_reftoken(); - PROTOBUF_NODISCARD std::string* release_reftoken(); - void set_allocated_reftoken(std::string* reftoken); - private: - const std::string& _internal_reftoken() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_reftoken(const std::string& value); - std::string* _internal_mutable_reftoken(); - public: - - // optional string version = 2; - bool has_version() const; - private: - bool _internal_has_version() const; - public: - void clear_version(); - const std::string& version() const; - template - void set_version(ArgT0&& arg0, ArgT... args); - std::string* mutable_version(); - PROTOBUF_NODISCARD std::string* release_version(); - void set_allocated_version(std::string* version); - private: - const std::string& _internal_version() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(const std::string& value); - std::string* _internal_mutable_version(); - public: - - // optional .proto.ClientPayload.WebInfo.WebdPayload webdPayload = 3; - bool has_webdpayload() const; - private: - bool _internal_has_webdpayload() const; - public: - void clear_webdpayload(); - const ::proto::ClientPayload_WebInfo_WebdPayload& webdpayload() const; - PROTOBUF_NODISCARD ::proto::ClientPayload_WebInfo_WebdPayload* release_webdpayload(); - ::proto::ClientPayload_WebInfo_WebdPayload* mutable_webdpayload(); - void set_allocated_webdpayload(::proto::ClientPayload_WebInfo_WebdPayload* webdpayload); - private: - const ::proto::ClientPayload_WebInfo_WebdPayload& _internal_webdpayload() const; - ::proto::ClientPayload_WebInfo_WebdPayload* _internal_mutable_webdpayload(); - public: - void unsafe_arena_set_allocated_webdpayload( - ::proto::ClientPayload_WebInfo_WebdPayload* webdpayload); - ::proto::ClientPayload_WebInfo_WebdPayload* unsafe_arena_release_webdpayload(); - - // optional .proto.ClientPayload.WebInfo.WebSubPlatform webSubPlatform = 4; - bool has_websubplatform() const; - private: - bool _internal_has_websubplatform() const; - public: - void clear_websubplatform(); - ::proto::ClientPayload_WebInfo_WebSubPlatform websubplatform() const; - void set_websubplatform(::proto::ClientPayload_WebInfo_WebSubPlatform value); - private: - ::proto::ClientPayload_WebInfo_WebSubPlatform _internal_websubplatform() const; - void _internal_set_websubplatform(::proto::ClientPayload_WebInfo_WebSubPlatform value); - public: - - // @@protoc_insertion_point(class_scope:proto.ClientPayload.WebInfo) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr reftoken_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_; - ::proto::ClientPayload_WebInfo_WebdPayload* webdpayload_; - int websubplatform_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class ClientPayload final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ClientPayload) */ { - public: - inline ClientPayload() : ClientPayload(nullptr) {} - ~ClientPayload() override; - explicit PROTOBUF_CONSTEXPR ClientPayload(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ClientPayload(const ClientPayload& from); - ClientPayload(ClientPayload&& from) noexcept - : ClientPayload() { - *this = ::std::move(from); - } - - inline ClientPayload& operator=(const ClientPayload& from) { - CopyFrom(from); - return *this; - } - inline ClientPayload& operator=(ClientPayload&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const ClientPayload& default_instance() { - return *internal_default_instance(); - } - static inline const ClientPayload* internal_default_instance() { - return reinterpret_cast( - &_ClientPayload_default_instance_); - } - static constexpr int kIndexInFileMessages = - 21; - - friend void swap(ClientPayload& a, ClientPayload& b) { - a.Swap(&b); - } - inline void Swap(ClientPayload* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ClientPayload* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ClientPayload* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ClientPayload& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const ClientPayload& from) { - ClientPayload::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ClientPayload* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.ClientPayload"; - } - protected: - explicit ClientPayload(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef ClientPayload_DNSSource DNSSource; - typedef ClientPayload_DevicePairingRegistrationData DevicePairingRegistrationData; - typedef ClientPayload_UserAgent UserAgent; - typedef ClientPayload_WebInfo WebInfo; - - typedef ClientPayload_ConnectReason ConnectReason; - static constexpr ConnectReason PUSH = - ClientPayload_ConnectReason_PUSH; - static constexpr ConnectReason USER_ACTIVATED = - ClientPayload_ConnectReason_USER_ACTIVATED; - static constexpr ConnectReason SCHEDULED = - ClientPayload_ConnectReason_SCHEDULED; - static constexpr ConnectReason ERROR_RECONNECT = - ClientPayload_ConnectReason_ERROR_RECONNECT; - static constexpr ConnectReason NETWORK_SWITCH = - ClientPayload_ConnectReason_NETWORK_SWITCH; - static constexpr ConnectReason PING_RECONNECT = - ClientPayload_ConnectReason_PING_RECONNECT; - static inline bool ConnectReason_IsValid(int value) { - return ClientPayload_ConnectReason_IsValid(value); - } - static constexpr ConnectReason ConnectReason_MIN = - ClientPayload_ConnectReason_ConnectReason_MIN; - static constexpr ConnectReason ConnectReason_MAX = - ClientPayload_ConnectReason_ConnectReason_MAX; - static constexpr int ConnectReason_ARRAYSIZE = - ClientPayload_ConnectReason_ConnectReason_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - ConnectReason_descriptor() { - return ClientPayload_ConnectReason_descriptor(); - } - template - static inline const std::string& ConnectReason_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function ConnectReason_Name."); - return ClientPayload_ConnectReason_Name(enum_t_value); - } - static inline bool ConnectReason_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - ConnectReason* value) { - return ClientPayload_ConnectReason_Parse(name, value); - } - - typedef ClientPayload_ConnectType ConnectType; - static constexpr ConnectType CELLULAR_UNKNOWN = - ClientPayload_ConnectType_CELLULAR_UNKNOWN; - static constexpr ConnectType WIFI_UNKNOWN = - ClientPayload_ConnectType_WIFI_UNKNOWN; - static constexpr ConnectType CELLULAR_EDGE = - ClientPayload_ConnectType_CELLULAR_EDGE; - static constexpr ConnectType CELLULAR_IDEN = - ClientPayload_ConnectType_CELLULAR_IDEN; - static constexpr ConnectType CELLULAR_UMTS = - ClientPayload_ConnectType_CELLULAR_UMTS; - static constexpr ConnectType CELLULAR_EVDO = - ClientPayload_ConnectType_CELLULAR_EVDO; - static constexpr ConnectType CELLULAR_GPRS = - ClientPayload_ConnectType_CELLULAR_GPRS; - static constexpr ConnectType CELLULAR_HSDPA = - ClientPayload_ConnectType_CELLULAR_HSDPA; - static constexpr ConnectType CELLULAR_HSUPA = - ClientPayload_ConnectType_CELLULAR_HSUPA; - static constexpr ConnectType CELLULAR_HSPA = - ClientPayload_ConnectType_CELLULAR_HSPA; - static constexpr ConnectType CELLULAR_CDMA = - ClientPayload_ConnectType_CELLULAR_CDMA; - static constexpr ConnectType CELLULAR_1XRTT = - ClientPayload_ConnectType_CELLULAR_1XRTT; - static constexpr ConnectType CELLULAR_EHRPD = - ClientPayload_ConnectType_CELLULAR_EHRPD; - static constexpr ConnectType CELLULAR_LTE = - ClientPayload_ConnectType_CELLULAR_LTE; - static constexpr ConnectType CELLULAR_HSPAP = - ClientPayload_ConnectType_CELLULAR_HSPAP; - static inline bool ConnectType_IsValid(int value) { - return ClientPayload_ConnectType_IsValid(value); - } - static constexpr ConnectType ConnectType_MIN = - ClientPayload_ConnectType_ConnectType_MIN; - static constexpr ConnectType ConnectType_MAX = - ClientPayload_ConnectType_ConnectType_MAX; - static constexpr int ConnectType_ARRAYSIZE = - ClientPayload_ConnectType_ConnectType_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - ConnectType_descriptor() { - return ClientPayload_ConnectType_descriptor(); - } - template - static inline const std::string& ConnectType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function ConnectType_Name."); - return ClientPayload_ConnectType_Name(enum_t_value); - } - static inline bool ConnectType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - ConnectType* value) { - return ClientPayload_ConnectType_Parse(name, value); - } - - typedef ClientPayload_IOSAppExtension IOSAppExtension; - static constexpr IOSAppExtension SHARE_EXTENSION = - ClientPayload_IOSAppExtension_SHARE_EXTENSION; - static constexpr IOSAppExtension SERVICE_EXTENSION = - ClientPayload_IOSAppExtension_SERVICE_EXTENSION; - static constexpr IOSAppExtension INTENTS_EXTENSION = - ClientPayload_IOSAppExtension_INTENTS_EXTENSION; - static inline bool IOSAppExtension_IsValid(int value) { - return ClientPayload_IOSAppExtension_IsValid(value); - } - static constexpr IOSAppExtension IOSAppExtension_MIN = - ClientPayload_IOSAppExtension_IOSAppExtension_MIN; - static constexpr IOSAppExtension IOSAppExtension_MAX = - ClientPayload_IOSAppExtension_IOSAppExtension_MAX; - static constexpr int IOSAppExtension_ARRAYSIZE = - ClientPayload_IOSAppExtension_IOSAppExtension_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - IOSAppExtension_descriptor() { - return ClientPayload_IOSAppExtension_descriptor(); - } - template - static inline const std::string& IOSAppExtension_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function IOSAppExtension_Name."); - return ClientPayload_IOSAppExtension_Name(enum_t_value); - } - static inline bool IOSAppExtension_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - IOSAppExtension* value) { - return ClientPayload_IOSAppExtension_Parse(name, value); - } - - typedef ClientPayload_Product Product; - static constexpr Product WHATSAPP = - ClientPayload_Product_WHATSAPP; - static constexpr Product MESSENGER = - ClientPayload_Product_MESSENGER; - static inline bool Product_IsValid(int value) { - return ClientPayload_Product_IsValid(value); - } - static constexpr Product Product_MIN = - ClientPayload_Product_Product_MIN; - static constexpr Product Product_MAX = - ClientPayload_Product_Product_MAX; - static constexpr int Product_ARRAYSIZE = - ClientPayload_Product_Product_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - Product_descriptor() { - return ClientPayload_Product_descriptor(); - } - template - static inline const std::string& Product_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Product_Name."); - return ClientPayload_Product_Name(enum_t_value); - } - static inline bool Product_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - Product* value) { - return ClientPayload_Product_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kShardsFieldNumber = 14, - kPushNameFieldNumber = 7, - kFbCatFieldNumber = 21, - kFbUserAgentFieldNumber = 22, - kFbDeviceIdFieldNumber = 32, - kPaddingBytesFieldNumber = 34, - kUserAgentFieldNumber = 5, - kWebInfoFieldNumber = 6, - kDnsSourceFieldNumber = 15, - kDevicePairingDataFieldNumber = 19, - kUsernameFieldNumber = 1, - kSessionIdFieldNumber = 9, - kConnectTypeFieldNumber = 12, - kConnectReasonFieldNumber = 13, - kConnectAttemptCountFieldNumber = 16, - kPassiveFieldNumber = 3, - kShortConnectFieldNumber = 10, - kOcFieldNumber = 23, - kPullFieldNumber = 33, - kDeviceFieldNumber = 18, - kProductFieldNumber = 20, - kLcFieldNumber = 24, - kFbAppIdFieldNumber = 31, - kIosAppExtensionFieldNumber = 30, - }; - // repeated int32 shards = 14; - int shards_size() const; - private: - int _internal_shards_size() const; - public: - void clear_shards(); - private: - int32_t _internal_shards(int index) const; - const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& - _internal_shards() const; - void _internal_add_shards(int32_t value); - ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* - _internal_mutable_shards(); - public: - int32_t shards(int index) const; - void set_shards(int index, int32_t value); - void add_shards(int32_t value); - const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& - shards() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* - mutable_shards(); - - // optional string pushName = 7; - bool has_pushname() const; - private: - bool _internal_has_pushname() const; - public: - void clear_pushname(); - const std::string& pushname() const; - template - void set_pushname(ArgT0&& arg0, ArgT... args); - std::string* mutable_pushname(); - PROTOBUF_NODISCARD std::string* release_pushname(); - void set_allocated_pushname(std::string* pushname); - private: - const std::string& _internal_pushname() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_pushname(const std::string& value); - std::string* _internal_mutable_pushname(); - public: - - // optional bytes fbCat = 21; - bool has_fbcat() const; - private: - bool _internal_has_fbcat() const; - public: - void clear_fbcat(); - const std::string& fbcat() const; - template - void set_fbcat(ArgT0&& arg0, ArgT... args); - std::string* mutable_fbcat(); - PROTOBUF_NODISCARD std::string* release_fbcat(); - void set_allocated_fbcat(std::string* fbcat); - private: - const std::string& _internal_fbcat() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_fbcat(const std::string& value); - std::string* _internal_mutable_fbcat(); - public: - - // optional bytes fbUserAgent = 22; - bool has_fbuseragent() const; - private: - bool _internal_has_fbuseragent() const; - public: - void clear_fbuseragent(); - const std::string& fbuseragent() const; - template - void set_fbuseragent(ArgT0&& arg0, ArgT... args); - std::string* mutable_fbuseragent(); - PROTOBUF_NODISCARD std::string* release_fbuseragent(); - void set_allocated_fbuseragent(std::string* fbuseragent); - private: - const std::string& _internal_fbuseragent() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_fbuseragent(const std::string& value); - std::string* _internal_mutable_fbuseragent(); - public: - - // optional bytes fbDeviceId = 32; - bool has_fbdeviceid() const; - private: - bool _internal_has_fbdeviceid() const; - public: - void clear_fbdeviceid(); - const std::string& fbdeviceid() const; - template - void set_fbdeviceid(ArgT0&& arg0, ArgT... args); - std::string* mutable_fbdeviceid(); - PROTOBUF_NODISCARD std::string* release_fbdeviceid(); - void set_allocated_fbdeviceid(std::string* fbdeviceid); - private: - const std::string& _internal_fbdeviceid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_fbdeviceid(const std::string& value); - std::string* _internal_mutable_fbdeviceid(); - public: - - // optional bytes paddingBytes = 34; - bool has_paddingbytes() const; - private: - bool _internal_has_paddingbytes() const; - public: - void clear_paddingbytes(); - const std::string& paddingbytes() const; - template - void set_paddingbytes(ArgT0&& arg0, ArgT... args); - std::string* mutable_paddingbytes(); - PROTOBUF_NODISCARD std::string* release_paddingbytes(); - void set_allocated_paddingbytes(std::string* paddingbytes); - private: - const std::string& _internal_paddingbytes() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_paddingbytes(const std::string& value); - std::string* _internal_mutable_paddingbytes(); - public: - - // optional .proto.ClientPayload.UserAgent userAgent = 5; - bool has_useragent() const; - private: - bool _internal_has_useragent() const; - public: - void clear_useragent(); - const ::proto::ClientPayload_UserAgent& useragent() const; - PROTOBUF_NODISCARD ::proto::ClientPayload_UserAgent* release_useragent(); - ::proto::ClientPayload_UserAgent* mutable_useragent(); - void set_allocated_useragent(::proto::ClientPayload_UserAgent* useragent); - private: - const ::proto::ClientPayload_UserAgent& _internal_useragent() const; - ::proto::ClientPayload_UserAgent* _internal_mutable_useragent(); - public: - void unsafe_arena_set_allocated_useragent( - ::proto::ClientPayload_UserAgent* useragent); - ::proto::ClientPayload_UserAgent* unsafe_arena_release_useragent(); - - // optional .proto.ClientPayload.WebInfo webInfo = 6; - bool has_webinfo() const; - private: - bool _internal_has_webinfo() const; - public: - void clear_webinfo(); - const ::proto::ClientPayload_WebInfo& webinfo() const; - PROTOBUF_NODISCARD ::proto::ClientPayload_WebInfo* release_webinfo(); - ::proto::ClientPayload_WebInfo* mutable_webinfo(); - void set_allocated_webinfo(::proto::ClientPayload_WebInfo* webinfo); - private: - const ::proto::ClientPayload_WebInfo& _internal_webinfo() const; - ::proto::ClientPayload_WebInfo* _internal_mutable_webinfo(); - public: - void unsafe_arena_set_allocated_webinfo( - ::proto::ClientPayload_WebInfo* webinfo); - ::proto::ClientPayload_WebInfo* unsafe_arena_release_webinfo(); - - // optional .proto.ClientPayload.DNSSource dnsSource = 15; - bool has_dnssource() const; - private: - bool _internal_has_dnssource() const; - public: - void clear_dnssource(); - const ::proto::ClientPayload_DNSSource& dnssource() const; - PROTOBUF_NODISCARD ::proto::ClientPayload_DNSSource* release_dnssource(); - ::proto::ClientPayload_DNSSource* mutable_dnssource(); - void set_allocated_dnssource(::proto::ClientPayload_DNSSource* dnssource); - private: - const ::proto::ClientPayload_DNSSource& _internal_dnssource() const; - ::proto::ClientPayload_DNSSource* _internal_mutable_dnssource(); - public: - void unsafe_arena_set_allocated_dnssource( - ::proto::ClientPayload_DNSSource* dnssource); - ::proto::ClientPayload_DNSSource* unsafe_arena_release_dnssource(); - - // optional .proto.ClientPayload.DevicePairingRegistrationData devicePairingData = 19; - bool has_devicepairingdata() const; - private: - bool _internal_has_devicepairingdata() const; - public: - void clear_devicepairingdata(); - const ::proto::ClientPayload_DevicePairingRegistrationData& devicepairingdata() const; - PROTOBUF_NODISCARD ::proto::ClientPayload_DevicePairingRegistrationData* release_devicepairingdata(); - ::proto::ClientPayload_DevicePairingRegistrationData* mutable_devicepairingdata(); - void set_allocated_devicepairingdata(::proto::ClientPayload_DevicePairingRegistrationData* devicepairingdata); - private: - const ::proto::ClientPayload_DevicePairingRegistrationData& _internal_devicepairingdata() const; - ::proto::ClientPayload_DevicePairingRegistrationData* _internal_mutable_devicepairingdata(); - public: - void unsafe_arena_set_allocated_devicepairingdata( - ::proto::ClientPayload_DevicePairingRegistrationData* devicepairingdata); - ::proto::ClientPayload_DevicePairingRegistrationData* unsafe_arena_release_devicepairingdata(); - - // optional uint64 username = 1; - bool has_username() const; - private: - bool _internal_has_username() const; - public: - void clear_username(); - uint64_t username() const; - void set_username(uint64_t value); - private: - uint64_t _internal_username() const; - void _internal_set_username(uint64_t value); - public: - - // optional sfixed32 sessionId = 9; - bool has_sessionid() const; - private: - bool _internal_has_sessionid() const; - public: - void clear_sessionid(); - int32_t sessionid() const; - void set_sessionid(int32_t value); - private: - int32_t _internal_sessionid() const; - void _internal_set_sessionid(int32_t value); - public: - - // optional .proto.ClientPayload.ConnectType connectType = 12; - bool has_connecttype() const; - private: - bool _internal_has_connecttype() const; - public: - void clear_connecttype(); - ::proto::ClientPayload_ConnectType connecttype() const; - void set_connecttype(::proto::ClientPayload_ConnectType value); - private: - ::proto::ClientPayload_ConnectType _internal_connecttype() const; - void _internal_set_connecttype(::proto::ClientPayload_ConnectType value); - public: - - // optional .proto.ClientPayload.ConnectReason connectReason = 13; - bool has_connectreason() const; - private: - bool _internal_has_connectreason() const; - public: - void clear_connectreason(); - ::proto::ClientPayload_ConnectReason connectreason() const; - void set_connectreason(::proto::ClientPayload_ConnectReason value); - private: - ::proto::ClientPayload_ConnectReason _internal_connectreason() const; - void _internal_set_connectreason(::proto::ClientPayload_ConnectReason value); - public: - - // optional uint32 connectAttemptCount = 16; - bool has_connectattemptcount() const; - private: - bool _internal_has_connectattemptcount() const; - public: - void clear_connectattemptcount(); - uint32_t connectattemptcount() const; - void set_connectattemptcount(uint32_t value); - private: - uint32_t _internal_connectattemptcount() const; - void _internal_set_connectattemptcount(uint32_t value); - public: - - // optional bool passive = 3; - bool has_passive() const; - private: - bool _internal_has_passive() const; - public: - void clear_passive(); - bool passive() const; - void set_passive(bool value); - private: - bool _internal_passive() const; - void _internal_set_passive(bool value); - public: - - // optional bool shortConnect = 10; - bool has_shortconnect() const; - private: - bool _internal_has_shortconnect() const; - public: - void clear_shortconnect(); - bool shortconnect() const; - void set_shortconnect(bool value); - private: - bool _internal_shortconnect() const; - void _internal_set_shortconnect(bool value); - public: - - // optional bool oc = 23; - bool has_oc() const; - private: - bool _internal_has_oc() const; - public: - void clear_oc(); - bool oc() const; - void set_oc(bool value); - private: - bool _internal_oc() const; - void _internal_set_oc(bool value); - public: - - // optional bool pull = 33; - bool has_pull() const; - private: - bool _internal_has_pull() const; - public: - void clear_pull(); - bool pull() const; - void set_pull(bool value); - private: - bool _internal_pull() const; - void _internal_set_pull(bool value); - public: - - // optional uint32 device = 18; - bool has_device() const; - private: - bool _internal_has_device() const; - public: - void clear_device(); - uint32_t device() const; - void set_device(uint32_t value); - private: - uint32_t _internal_device() const; - void _internal_set_device(uint32_t value); - public: - - // optional .proto.ClientPayload.Product product = 20; - bool has_product() const; - private: - bool _internal_has_product() const; - public: - void clear_product(); - ::proto::ClientPayload_Product product() const; - void set_product(::proto::ClientPayload_Product value); - private: - ::proto::ClientPayload_Product _internal_product() const; - void _internal_set_product(::proto::ClientPayload_Product value); - public: - - // optional int32 lc = 24; - bool has_lc() const; - private: - bool _internal_has_lc() const; - public: - void clear_lc(); - int32_t lc() const; - void set_lc(int32_t value); - private: - int32_t _internal_lc() const; - void _internal_set_lc(int32_t value); - public: - - // optional uint64 fbAppId = 31; - bool has_fbappid() const; - private: - bool _internal_has_fbappid() const; - public: - void clear_fbappid(); - uint64_t fbappid() const; - void set_fbappid(uint64_t value); - private: - uint64_t _internal_fbappid() const; - void _internal_set_fbappid(uint64_t value); - public: - - // optional .proto.ClientPayload.IOSAppExtension iosAppExtension = 30; - bool has_iosappextension() const; - private: - bool _internal_has_iosappextension() const; - public: - void clear_iosappextension(); - ::proto::ClientPayload_IOSAppExtension iosappextension() const; - void set_iosappextension(::proto::ClientPayload_IOSAppExtension value); - private: - ::proto::ClientPayload_IOSAppExtension _internal_iosappextension() const; - void _internal_set_iosappextension(::proto::ClientPayload_IOSAppExtension value); - public: - - // @@protoc_insertion_point(class_scope:proto.ClientPayload) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > shards_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pushname_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fbcat_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fbuseragent_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fbdeviceid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr paddingbytes_; - ::proto::ClientPayload_UserAgent* useragent_; - ::proto::ClientPayload_WebInfo* webinfo_; - ::proto::ClientPayload_DNSSource* dnssource_; - ::proto::ClientPayload_DevicePairingRegistrationData* devicepairingdata_; - uint64_t username_; - int32_t sessionid_; - int connecttype_; - int connectreason_; - uint32_t connectattemptcount_; - bool passive_; - bool shortconnect_; - bool oc_; - bool pull_; - uint32_t device_; - int product_; - int32_t lc_; - uint64_t fbappid_; - int iosappextension_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class ContextInfo_AdReplyInfo final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ContextInfo.AdReplyInfo) */ { - public: - inline ContextInfo_AdReplyInfo() : ContextInfo_AdReplyInfo(nullptr) {} - ~ContextInfo_AdReplyInfo() override; - explicit PROTOBUF_CONSTEXPR ContextInfo_AdReplyInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ContextInfo_AdReplyInfo(const ContextInfo_AdReplyInfo& from); - ContextInfo_AdReplyInfo(ContextInfo_AdReplyInfo&& from) noexcept - : ContextInfo_AdReplyInfo() { - *this = ::std::move(from); - } - - inline ContextInfo_AdReplyInfo& operator=(const ContextInfo_AdReplyInfo& from) { - CopyFrom(from); - return *this; - } - inline ContextInfo_AdReplyInfo& operator=(ContextInfo_AdReplyInfo&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const ContextInfo_AdReplyInfo& default_instance() { - return *internal_default_instance(); - } - static inline const ContextInfo_AdReplyInfo* internal_default_instance() { - return reinterpret_cast( - &_ContextInfo_AdReplyInfo_default_instance_); - } - static constexpr int kIndexInFileMessages = - 22; - - friend void swap(ContextInfo_AdReplyInfo& a, ContextInfo_AdReplyInfo& b) { - a.Swap(&b); - } - inline void Swap(ContextInfo_AdReplyInfo* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ContextInfo_AdReplyInfo* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ContextInfo_AdReplyInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ContextInfo_AdReplyInfo& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const ContextInfo_AdReplyInfo& from) { - ContextInfo_AdReplyInfo::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ContextInfo_AdReplyInfo* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.ContextInfo.AdReplyInfo"; - } - protected: - explicit ContextInfo_AdReplyInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef ContextInfo_AdReplyInfo_MediaType MediaType; - static constexpr MediaType NONE = - ContextInfo_AdReplyInfo_MediaType_NONE; - static constexpr MediaType IMAGE = - ContextInfo_AdReplyInfo_MediaType_IMAGE; - static constexpr MediaType VIDEO = - ContextInfo_AdReplyInfo_MediaType_VIDEO; - static inline bool MediaType_IsValid(int value) { - return ContextInfo_AdReplyInfo_MediaType_IsValid(value); - } - static constexpr MediaType MediaType_MIN = - ContextInfo_AdReplyInfo_MediaType_MediaType_MIN; - static constexpr MediaType MediaType_MAX = - ContextInfo_AdReplyInfo_MediaType_MediaType_MAX; - static constexpr int MediaType_ARRAYSIZE = - ContextInfo_AdReplyInfo_MediaType_MediaType_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - MediaType_descriptor() { - return ContextInfo_AdReplyInfo_MediaType_descriptor(); - } - template - static inline const std::string& MediaType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function MediaType_Name."); - return ContextInfo_AdReplyInfo_MediaType_Name(enum_t_value); - } - static inline bool MediaType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - MediaType* value) { - return ContextInfo_AdReplyInfo_MediaType_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kAdvertiserNameFieldNumber = 1, - kJpegThumbnailFieldNumber = 16, - kCaptionFieldNumber = 17, - kMediaTypeFieldNumber = 2, - }; - // optional string advertiserName = 1; - bool has_advertisername() const; - private: - bool _internal_has_advertisername() const; - public: - void clear_advertisername(); - const std::string& advertisername() const; - template - void set_advertisername(ArgT0&& arg0, ArgT... args); - std::string* mutable_advertisername(); - PROTOBUF_NODISCARD std::string* release_advertisername(); - void set_allocated_advertisername(std::string* advertisername); - private: - const std::string& _internal_advertisername() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_advertisername(const std::string& value); - std::string* _internal_mutable_advertisername(); - public: - - // optional bytes jpegThumbnail = 16; - bool has_jpegthumbnail() const; - private: - bool _internal_has_jpegthumbnail() const; - public: - void clear_jpegthumbnail(); - const std::string& jpegthumbnail() const; - template - void set_jpegthumbnail(ArgT0&& arg0, ArgT... args); - std::string* mutable_jpegthumbnail(); - PROTOBUF_NODISCARD std::string* release_jpegthumbnail(); - void set_allocated_jpegthumbnail(std::string* jpegthumbnail); - private: - const std::string& _internal_jpegthumbnail() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value); - std::string* _internal_mutable_jpegthumbnail(); - public: - - // optional string caption = 17; - bool has_caption() const; - private: - bool _internal_has_caption() const; - public: - void clear_caption(); - const std::string& caption() const; - template - void set_caption(ArgT0&& arg0, ArgT... args); - std::string* mutable_caption(); - PROTOBUF_NODISCARD std::string* release_caption(); - void set_allocated_caption(std::string* caption); - private: - const std::string& _internal_caption() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_caption(const std::string& value); - std::string* _internal_mutable_caption(); - public: - - // optional .proto.ContextInfo.AdReplyInfo.MediaType mediaType = 2; - bool has_mediatype() const; - private: - bool _internal_has_mediatype() const; - public: - void clear_mediatype(); - ::proto::ContextInfo_AdReplyInfo_MediaType mediatype() const; - void set_mediatype(::proto::ContextInfo_AdReplyInfo_MediaType value); - private: - ::proto::ContextInfo_AdReplyInfo_MediaType _internal_mediatype() const; - void _internal_set_mediatype(::proto::ContextInfo_AdReplyInfo_MediaType value); - public: - - // @@protoc_insertion_point(class_scope:proto.ContextInfo.AdReplyInfo) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr advertisername_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr caption_; - int mediatype_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class ContextInfo_ExternalAdReplyInfo final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ContextInfo.ExternalAdReplyInfo) */ { - public: - inline ContextInfo_ExternalAdReplyInfo() : ContextInfo_ExternalAdReplyInfo(nullptr) {} - ~ContextInfo_ExternalAdReplyInfo() override; - explicit PROTOBUF_CONSTEXPR ContextInfo_ExternalAdReplyInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ContextInfo_ExternalAdReplyInfo(const ContextInfo_ExternalAdReplyInfo& from); - ContextInfo_ExternalAdReplyInfo(ContextInfo_ExternalAdReplyInfo&& from) noexcept - : ContextInfo_ExternalAdReplyInfo() { - *this = ::std::move(from); - } - - inline ContextInfo_ExternalAdReplyInfo& operator=(const ContextInfo_ExternalAdReplyInfo& from) { - CopyFrom(from); - return *this; - } - inline ContextInfo_ExternalAdReplyInfo& operator=(ContextInfo_ExternalAdReplyInfo&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const ContextInfo_ExternalAdReplyInfo& default_instance() { - return *internal_default_instance(); - } - static inline const ContextInfo_ExternalAdReplyInfo* internal_default_instance() { - return reinterpret_cast( - &_ContextInfo_ExternalAdReplyInfo_default_instance_); - } - static constexpr int kIndexInFileMessages = - 23; - - friend void swap(ContextInfo_ExternalAdReplyInfo& a, ContextInfo_ExternalAdReplyInfo& b) { - a.Swap(&b); - } - inline void Swap(ContextInfo_ExternalAdReplyInfo* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ContextInfo_ExternalAdReplyInfo* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ContextInfo_ExternalAdReplyInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ContextInfo_ExternalAdReplyInfo& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const ContextInfo_ExternalAdReplyInfo& from) { - ContextInfo_ExternalAdReplyInfo::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ContextInfo_ExternalAdReplyInfo* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.ContextInfo.ExternalAdReplyInfo"; - } - protected: - explicit ContextInfo_ExternalAdReplyInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef ContextInfo_ExternalAdReplyInfo_MediaType MediaType; - static constexpr MediaType NONE = - ContextInfo_ExternalAdReplyInfo_MediaType_NONE; - static constexpr MediaType IMAGE = - ContextInfo_ExternalAdReplyInfo_MediaType_IMAGE; - static constexpr MediaType VIDEO = - ContextInfo_ExternalAdReplyInfo_MediaType_VIDEO; - static inline bool MediaType_IsValid(int value) { - return ContextInfo_ExternalAdReplyInfo_MediaType_IsValid(value); - } - static constexpr MediaType MediaType_MIN = - ContextInfo_ExternalAdReplyInfo_MediaType_MediaType_MIN; - static constexpr MediaType MediaType_MAX = - ContextInfo_ExternalAdReplyInfo_MediaType_MediaType_MAX; - static constexpr int MediaType_ARRAYSIZE = - ContextInfo_ExternalAdReplyInfo_MediaType_MediaType_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - MediaType_descriptor() { - return ContextInfo_ExternalAdReplyInfo_MediaType_descriptor(); - } - template - static inline const std::string& MediaType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function MediaType_Name."); - return ContextInfo_ExternalAdReplyInfo_MediaType_Name(enum_t_value); - } - static inline bool MediaType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - MediaType* value) { - return ContextInfo_ExternalAdReplyInfo_MediaType_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kTitleFieldNumber = 1, - kBodyFieldNumber = 2, - kThumbnailUrlFieldNumber = 4, - kMediaUrlFieldNumber = 5, - kThumbnailFieldNumber = 6, - kSourceTypeFieldNumber = 7, - kSourceIdFieldNumber = 8, - kSourceUrlFieldNumber = 9, - kMediaTypeFieldNumber = 3, - kContainsAutoReplyFieldNumber = 10, - kRenderLargerThumbnailFieldNumber = 11, - kShowAdAttributionFieldNumber = 12, - }; - // optional string title = 1; - bool has_title() const; - private: - bool _internal_has_title() const; - public: - void clear_title(); - const std::string& title() const; - template - void set_title(ArgT0&& arg0, ArgT... args); - std::string* mutable_title(); - PROTOBUF_NODISCARD std::string* release_title(); - void set_allocated_title(std::string* title); - private: - const std::string& _internal_title() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value); - std::string* _internal_mutable_title(); - public: - - // optional string body = 2; - bool has_body() const; - private: - bool _internal_has_body() const; - public: - void clear_body(); - const std::string& body() const; - template - void set_body(ArgT0&& arg0, ArgT... args); - std::string* mutable_body(); - PROTOBUF_NODISCARD std::string* release_body(); - void set_allocated_body(std::string* body); - private: - const std::string& _internal_body() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_body(const std::string& value); - std::string* _internal_mutable_body(); - public: - - // optional string thumbnailUrl = 4; - bool has_thumbnailurl() const; - private: - bool _internal_has_thumbnailurl() const; - public: - void clear_thumbnailurl(); - const std::string& thumbnailurl() const; - template - void set_thumbnailurl(ArgT0&& arg0, ArgT... args); - std::string* mutable_thumbnailurl(); - PROTOBUF_NODISCARD std::string* release_thumbnailurl(); - void set_allocated_thumbnailurl(std::string* thumbnailurl); - private: - const std::string& _internal_thumbnailurl() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailurl(const std::string& value); - std::string* _internal_mutable_thumbnailurl(); - public: - - // optional string mediaUrl = 5; - bool has_mediaurl() const; - private: - bool _internal_has_mediaurl() const; - public: - void clear_mediaurl(); - const std::string& mediaurl() const; - template - void set_mediaurl(ArgT0&& arg0, ArgT... args); - std::string* mutable_mediaurl(); - PROTOBUF_NODISCARD std::string* release_mediaurl(); - void set_allocated_mediaurl(std::string* mediaurl); - private: - const std::string& _internal_mediaurl() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediaurl(const std::string& value); - std::string* _internal_mutable_mediaurl(); - public: - - // optional bytes thumbnail = 6; - bool has_thumbnail() const; - private: - bool _internal_has_thumbnail() const; - public: - void clear_thumbnail(); - const std::string& thumbnail() const; - template - void set_thumbnail(ArgT0&& arg0, ArgT... args); - std::string* mutable_thumbnail(); - PROTOBUF_NODISCARD std::string* release_thumbnail(); - void set_allocated_thumbnail(std::string* thumbnail); - private: - const std::string& _internal_thumbnail() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnail(const std::string& value); - std::string* _internal_mutable_thumbnail(); - public: - - // optional string sourceType = 7; - bool has_sourcetype() const; - private: - bool _internal_has_sourcetype() const; - public: - void clear_sourcetype(); - const std::string& sourcetype() const; - template - void set_sourcetype(ArgT0&& arg0, ArgT... args); - std::string* mutable_sourcetype(); - PROTOBUF_NODISCARD std::string* release_sourcetype(); - void set_allocated_sourcetype(std::string* sourcetype); - private: - const std::string& _internal_sourcetype() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_sourcetype(const std::string& value); - std::string* _internal_mutable_sourcetype(); - public: - - // optional string sourceId = 8; - bool has_sourceid() const; - private: - bool _internal_has_sourceid() const; - public: - void clear_sourceid(); - const std::string& sourceid() const; - template - void set_sourceid(ArgT0&& arg0, ArgT... args); - std::string* mutable_sourceid(); - PROTOBUF_NODISCARD std::string* release_sourceid(); - void set_allocated_sourceid(std::string* sourceid); - private: - const std::string& _internal_sourceid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_sourceid(const std::string& value); - std::string* _internal_mutable_sourceid(); - public: - - // optional string sourceUrl = 9; - bool has_sourceurl() const; - private: - bool _internal_has_sourceurl() const; - public: - void clear_sourceurl(); - const std::string& sourceurl() const; - template - void set_sourceurl(ArgT0&& arg0, ArgT... args); - std::string* mutable_sourceurl(); - PROTOBUF_NODISCARD std::string* release_sourceurl(); - void set_allocated_sourceurl(std::string* sourceurl); - private: - const std::string& _internal_sourceurl() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_sourceurl(const std::string& value); - std::string* _internal_mutable_sourceurl(); - public: - - // optional .proto.ContextInfo.ExternalAdReplyInfo.MediaType mediaType = 3; - bool has_mediatype() const; - private: - bool _internal_has_mediatype() const; - public: - void clear_mediatype(); - ::proto::ContextInfo_ExternalAdReplyInfo_MediaType mediatype() const; - void set_mediatype(::proto::ContextInfo_ExternalAdReplyInfo_MediaType value); - private: - ::proto::ContextInfo_ExternalAdReplyInfo_MediaType _internal_mediatype() const; - void _internal_set_mediatype(::proto::ContextInfo_ExternalAdReplyInfo_MediaType value); - public: - - // optional bool containsAutoReply = 10; - bool has_containsautoreply() const; - private: - bool _internal_has_containsautoreply() const; - public: - void clear_containsautoreply(); - bool containsautoreply() const; - void set_containsautoreply(bool value); - private: - bool _internal_containsautoreply() const; - void _internal_set_containsautoreply(bool value); - public: - - // optional bool renderLargerThumbnail = 11; - bool has_renderlargerthumbnail() const; - private: - bool _internal_has_renderlargerthumbnail() const; - public: - void clear_renderlargerthumbnail(); - bool renderlargerthumbnail() const; - void set_renderlargerthumbnail(bool value); - private: - bool _internal_renderlargerthumbnail() const; - void _internal_set_renderlargerthumbnail(bool value); - public: - - // optional bool showAdAttribution = 12; - bool has_showadattribution() const; - private: - bool _internal_has_showadattribution() const; - public: - void clear_showadattribution(); - bool showadattribution() const; - void set_showadattribution(bool value); - private: - bool _internal_showadattribution() const; - void _internal_set_showadattribution(bool value); - public: - - // @@protoc_insertion_point(class_scope:proto.ContextInfo.ExternalAdReplyInfo) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr body_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailurl_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediaurl_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnail_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sourcetype_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sourceid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sourceurl_; - int mediatype_; - bool containsautoreply_; - bool renderlargerthumbnail_; - bool showadattribution_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class ContextInfo final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ContextInfo) */ { - public: - inline ContextInfo() : ContextInfo(nullptr) {} - ~ContextInfo() override; - explicit PROTOBUF_CONSTEXPR ContextInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ContextInfo(const ContextInfo& from); - ContextInfo(ContextInfo&& from) noexcept - : ContextInfo() { - *this = ::std::move(from); - } - - inline ContextInfo& operator=(const ContextInfo& from) { - CopyFrom(from); - return *this; - } - inline ContextInfo& operator=(ContextInfo&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const ContextInfo& default_instance() { - return *internal_default_instance(); - } - static inline const ContextInfo* internal_default_instance() { - return reinterpret_cast( - &_ContextInfo_default_instance_); - } - static constexpr int kIndexInFileMessages = - 24; - - friend void swap(ContextInfo& a, ContextInfo& b) { - a.Swap(&b); - } - inline void Swap(ContextInfo* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ContextInfo* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ContextInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ContextInfo& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const ContextInfo& from) { - ContextInfo::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ContextInfo* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.ContextInfo"; - } - protected: - explicit ContextInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef ContextInfo_AdReplyInfo AdReplyInfo; - typedef ContextInfo_ExternalAdReplyInfo ExternalAdReplyInfo; - - // accessors ------------------------------------------------------- - - enum : int { - kMentionedJidFieldNumber = 15, - kStanzaIdFieldNumber = 1, - kParticipantFieldNumber = 2, - kRemoteJidFieldNumber = 4, - kConversionSourceFieldNumber = 18, - kConversionDataFieldNumber = 19, - kEphemeralSharedSecretFieldNumber = 27, - kEntryPointConversionSourceFieldNumber = 29, - kEntryPointConversionAppFieldNumber = 30, - kGroupSubjectFieldNumber = 34, - kParentGroupJidFieldNumber = 35, - kQuotedMessageFieldNumber = 3, - kQuotedAdFieldNumber = 23, - kPlaceholderKeyFieldNumber = 24, - kExternalAdReplyFieldNumber = 28, - kDisappearingModeFieldNumber = 32, - kActionLinkFieldNumber = 33, - kConversionDelaySecondsFieldNumber = 20, - kForwardingScoreFieldNumber = 21, - kIsForwardedFieldNumber = 22, - kExpirationFieldNumber = 25, - kEphemeralSettingTimestampFieldNumber = 26, - kEntryPointConversionDelaySecondsFieldNumber = 31, - }; - // repeated string mentionedJid = 15; - int mentionedjid_size() const; - private: - int _internal_mentionedjid_size() const; - public: - void clear_mentionedjid(); - const std::string& mentionedjid(int index) const; - std::string* mutable_mentionedjid(int index); - void set_mentionedjid(int index, const std::string& value); - void set_mentionedjid(int index, std::string&& value); - void set_mentionedjid(int index, const char* value); - void set_mentionedjid(int index, const char* value, size_t size); - std::string* add_mentionedjid(); - void add_mentionedjid(const std::string& value); - void add_mentionedjid(std::string&& value); - void add_mentionedjid(const char* value); - void add_mentionedjid(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& mentionedjid() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_mentionedjid(); - private: - const std::string& _internal_mentionedjid(int index) const; - std::string* _internal_add_mentionedjid(); - public: - - // optional string stanzaId = 1; - bool has_stanzaid() const; - private: - bool _internal_has_stanzaid() const; - public: - void clear_stanzaid(); - const std::string& stanzaid() const; - template - void set_stanzaid(ArgT0&& arg0, ArgT... args); - std::string* mutable_stanzaid(); - PROTOBUF_NODISCARD std::string* release_stanzaid(); - void set_allocated_stanzaid(std::string* stanzaid); - private: - const std::string& _internal_stanzaid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_stanzaid(const std::string& value); - std::string* _internal_mutable_stanzaid(); - public: - - // optional string participant = 2; - bool has_participant() const; - private: - bool _internal_has_participant() const; - public: - void clear_participant(); - const std::string& participant() const; - template - void set_participant(ArgT0&& arg0, ArgT... args); - std::string* mutable_participant(); - PROTOBUF_NODISCARD std::string* release_participant(); - void set_allocated_participant(std::string* participant); - private: - const std::string& _internal_participant() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_participant(const std::string& value); - std::string* _internal_mutable_participant(); - public: - - // optional string remoteJid = 4; - bool has_remotejid() const; - private: - bool _internal_has_remotejid() const; - public: - void clear_remotejid(); - const std::string& remotejid() const; - template - void set_remotejid(ArgT0&& arg0, ArgT... args); - std::string* mutable_remotejid(); - PROTOBUF_NODISCARD std::string* release_remotejid(); - void set_allocated_remotejid(std::string* remotejid); - private: - const std::string& _internal_remotejid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_remotejid(const std::string& value); - std::string* _internal_mutable_remotejid(); - public: - - // optional string conversionSource = 18; - bool has_conversionsource() const; - private: - bool _internal_has_conversionsource() const; - public: - void clear_conversionsource(); - const std::string& conversionsource() const; - template - void set_conversionsource(ArgT0&& arg0, ArgT... args); - std::string* mutable_conversionsource(); - PROTOBUF_NODISCARD std::string* release_conversionsource(); - void set_allocated_conversionsource(std::string* conversionsource); - private: - const std::string& _internal_conversionsource() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_conversionsource(const std::string& value); - std::string* _internal_mutable_conversionsource(); - public: - - // optional bytes conversionData = 19; - bool has_conversiondata() const; - private: - bool _internal_has_conversiondata() const; - public: - void clear_conversiondata(); - const std::string& conversiondata() const; - template - void set_conversiondata(ArgT0&& arg0, ArgT... args); - std::string* mutable_conversiondata(); - PROTOBUF_NODISCARD std::string* release_conversiondata(); - void set_allocated_conversiondata(std::string* conversiondata); - private: - const std::string& _internal_conversiondata() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_conversiondata(const std::string& value); - std::string* _internal_mutable_conversiondata(); - public: - - // optional bytes ephemeralSharedSecret = 27; - bool has_ephemeralsharedsecret() const; - private: - bool _internal_has_ephemeralsharedsecret() const; - public: - void clear_ephemeralsharedsecret(); - const std::string& ephemeralsharedsecret() const; - template - void set_ephemeralsharedsecret(ArgT0&& arg0, ArgT... args); - std::string* mutable_ephemeralsharedsecret(); - PROTOBUF_NODISCARD std::string* release_ephemeralsharedsecret(); - void set_allocated_ephemeralsharedsecret(std::string* ephemeralsharedsecret); - private: - const std::string& _internal_ephemeralsharedsecret() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_ephemeralsharedsecret(const std::string& value); - std::string* _internal_mutable_ephemeralsharedsecret(); - public: - - // optional string entryPointConversionSource = 29; - bool has_entrypointconversionsource() const; - private: - bool _internal_has_entrypointconversionsource() const; - public: - void clear_entrypointconversionsource(); - const std::string& entrypointconversionsource() const; - template - void set_entrypointconversionsource(ArgT0&& arg0, ArgT... args); - std::string* mutable_entrypointconversionsource(); - PROTOBUF_NODISCARD std::string* release_entrypointconversionsource(); - void set_allocated_entrypointconversionsource(std::string* entrypointconversionsource); - private: - const std::string& _internal_entrypointconversionsource() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_entrypointconversionsource(const std::string& value); - std::string* _internal_mutable_entrypointconversionsource(); - public: - - // optional string entryPointConversionApp = 30; - bool has_entrypointconversionapp() const; - private: - bool _internal_has_entrypointconversionapp() const; - public: - void clear_entrypointconversionapp(); - const std::string& entrypointconversionapp() const; - template - void set_entrypointconversionapp(ArgT0&& arg0, ArgT... args); - std::string* mutable_entrypointconversionapp(); - PROTOBUF_NODISCARD std::string* release_entrypointconversionapp(); - void set_allocated_entrypointconversionapp(std::string* entrypointconversionapp); - private: - const std::string& _internal_entrypointconversionapp() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_entrypointconversionapp(const std::string& value); - std::string* _internal_mutable_entrypointconversionapp(); - public: - - // optional string groupSubject = 34; - bool has_groupsubject() const; - private: - bool _internal_has_groupsubject() const; - public: - void clear_groupsubject(); - const std::string& groupsubject() const; - template - void set_groupsubject(ArgT0&& arg0, ArgT... args); - std::string* mutable_groupsubject(); - PROTOBUF_NODISCARD std::string* release_groupsubject(); - void set_allocated_groupsubject(std::string* groupsubject); - private: - const std::string& _internal_groupsubject() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_groupsubject(const std::string& value); - std::string* _internal_mutable_groupsubject(); - public: - - // optional string parentGroupJid = 35; - bool has_parentgroupjid() const; - private: - bool _internal_has_parentgroupjid() const; - public: - void clear_parentgroupjid(); - const std::string& parentgroupjid() const; - template - void set_parentgroupjid(ArgT0&& arg0, ArgT... args); - std::string* mutable_parentgroupjid(); - PROTOBUF_NODISCARD std::string* release_parentgroupjid(); - void set_allocated_parentgroupjid(std::string* parentgroupjid); - private: - const std::string& _internal_parentgroupjid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_parentgroupjid(const std::string& value); - std::string* _internal_mutable_parentgroupjid(); - public: - - // optional .proto.Message quotedMessage = 3; - bool has_quotedmessage() const; - private: - bool _internal_has_quotedmessage() const; - public: - void clear_quotedmessage(); - const ::proto::Message& quotedmessage() const; - PROTOBUF_NODISCARD ::proto::Message* release_quotedmessage(); - ::proto::Message* mutable_quotedmessage(); - void set_allocated_quotedmessage(::proto::Message* quotedmessage); - private: - const ::proto::Message& _internal_quotedmessage() const; - ::proto::Message* _internal_mutable_quotedmessage(); - public: - void unsafe_arena_set_allocated_quotedmessage( - ::proto::Message* quotedmessage); - ::proto::Message* unsafe_arena_release_quotedmessage(); - - // optional .proto.ContextInfo.AdReplyInfo quotedAd = 23; - bool has_quotedad() const; - private: - bool _internal_has_quotedad() const; - public: - void clear_quotedad(); - const ::proto::ContextInfo_AdReplyInfo& quotedad() const; - PROTOBUF_NODISCARD ::proto::ContextInfo_AdReplyInfo* release_quotedad(); - ::proto::ContextInfo_AdReplyInfo* mutable_quotedad(); - void set_allocated_quotedad(::proto::ContextInfo_AdReplyInfo* quotedad); - private: - const ::proto::ContextInfo_AdReplyInfo& _internal_quotedad() const; - ::proto::ContextInfo_AdReplyInfo* _internal_mutable_quotedad(); - public: - void unsafe_arena_set_allocated_quotedad( - ::proto::ContextInfo_AdReplyInfo* quotedad); - ::proto::ContextInfo_AdReplyInfo* unsafe_arena_release_quotedad(); - - // optional .proto.MessageKey placeholderKey = 24; - bool has_placeholderkey() const; - private: - bool _internal_has_placeholderkey() const; - public: - void clear_placeholderkey(); - const ::proto::MessageKey& placeholderkey() const; - PROTOBUF_NODISCARD ::proto::MessageKey* release_placeholderkey(); - ::proto::MessageKey* mutable_placeholderkey(); - void set_allocated_placeholderkey(::proto::MessageKey* placeholderkey); - private: - const ::proto::MessageKey& _internal_placeholderkey() const; - ::proto::MessageKey* _internal_mutable_placeholderkey(); - public: - void unsafe_arena_set_allocated_placeholderkey( - ::proto::MessageKey* placeholderkey); - ::proto::MessageKey* unsafe_arena_release_placeholderkey(); - - // optional .proto.ContextInfo.ExternalAdReplyInfo externalAdReply = 28; - bool has_externaladreply() const; - private: - bool _internal_has_externaladreply() const; - public: - void clear_externaladreply(); - const ::proto::ContextInfo_ExternalAdReplyInfo& externaladreply() const; - PROTOBUF_NODISCARD ::proto::ContextInfo_ExternalAdReplyInfo* release_externaladreply(); - ::proto::ContextInfo_ExternalAdReplyInfo* mutable_externaladreply(); - void set_allocated_externaladreply(::proto::ContextInfo_ExternalAdReplyInfo* externaladreply); - private: - const ::proto::ContextInfo_ExternalAdReplyInfo& _internal_externaladreply() const; - ::proto::ContextInfo_ExternalAdReplyInfo* _internal_mutable_externaladreply(); - public: - void unsafe_arena_set_allocated_externaladreply( - ::proto::ContextInfo_ExternalAdReplyInfo* externaladreply); - ::proto::ContextInfo_ExternalAdReplyInfo* unsafe_arena_release_externaladreply(); - - // optional .proto.DisappearingMode disappearingMode = 32; - bool has_disappearingmode() const; - private: - bool _internal_has_disappearingmode() const; - public: - void clear_disappearingmode(); - const ::proto::DisappearingMode& disappearingmode() const; - PROTOBUF_NODISCARD ::proto::DisappearingMode* release_disappearingmode(); - ::proto::DisappearingMode* mutable_disappearingmode(); - void set_allocated_disappearingmode(::proto::DisappearingMode* disappearingmode); - private: - const ::proto::DisappearingMode& _internal_disappearingmode() const; - ::proto::DisappearingMode* _internal_mutable_disappearingmode(); - public: - void unsafe_arena_set_allocated_disappearingmode( - ::proto::DisappearingMode* disappearingmode); - ::proto::DisappearingMode* unsafe_arena_release_disappearingmode(); - - // optional .proto.ActionLink actionLink = 33; - bool has_actionlink() const; - private: - bool _internal_has_actionlink() const; - public: - void clear_actionlink(); - const ::proto::ActionLink& actionlink() const; - PROTOBUF_NODISCARD ::proto::ActionLink* release_actionlink(); - ::proto::ActionLink* mutable_actionlink(); - void set_allocated_actionlink(::proto::ActionLink* actionlink); - private: - const ::proto::ActionLink& _internal_actionlink() const; - ::proto::ActionLink* _internal_mutable_actionlink(); - public: - void unsafe_arena_set_allocated_actionlink( - ::proto::ActionLink* actionlink); - ::proto::ActionLink* unsafe_arena_release_actionlink(); - - // optional uint32 conversionDelaySeconds = 20; - bool has_conversiondelayseconds() const; - private: - bool _internal_has_conversiondelayseconds() const; - public: - void clear_conversiondelayseconds(); - uint32_t conversiondelayseconds() const; - void set_conversiondelayseconds(uint32_t value); - private: - uint32_t _internal_conversiondelayseconds() const; - void _internal_set_conversiondelayseconds(uint32_t value); - public: - - // optional uint32 forwardingScore = 21; - bool has_forwardingscore() const; - private: - bool _internal_has_forwardingscore() const; - public: - void clear_forwardingscore(); - uint32_t forwardingscore() const; - void set_forwardingscore(uint32_t value); - private: - uint32_t _internal_forwardingscore() const; - void _internal_set_forwardingscore(uint32_t value); - public: - - // optional bool isForwarded = 22; - bool has_isforwarded() const; - private: - bool _internal_has_isforwarded() const; - public: - void clear_isforwarded(); - bool isforwarded() const; - void set_isforwarded(bool value); - private: - bool _internal_isforwarded() const; - void _internal_set_isforwarded(bool value); - public: - - // optional uint32 expiration = 25; - bool has_expiration() const; - private: - bool _internal_has_expiration() const; - public: - void clear_expiration(); - uint32_t expiration() const; - void set_expiration(uint32_t value); - private: - uint32_t _internal_expiration() const; - void _internal_set_expiration(uint32_t value); - public: - - // optional int64 ephemeralSettingTimestamp = 26; - bool has_ephemeralsettingtimestamp() const; - private: - bool _internal_has_ephemeralsettingtimestamp() const; - public: - void clear_ephemeralsettingtimestamp(); - int64_t ephemeralsettingtimestamp() const; - void set_ephemeralsettingtimestamp(int64_t value); - private: - int64_t _internal_ephemeralsettingtimestamp() const; - void _internal_set_ephemeralsettingtimestamp(int64_t value); - public: - - // optional uint32 entryPointConversionDelaySeconds = 31; - bool has_entrypointconversiondelayseconds() const; - private: - bool _internal_has_entrypointconversiondelayseconds() const; - public: - void clear_entrypointconversiondelayseconds(); - uint32_t entrypointconversiondelayseconds() const; - void set_entrypointconversiondelayseconds(uint32_t value); - private: - uint32_t _internal_entrypointconversiondelayseconds() const; - void _internal_set_entrypointconversiondelayseconds(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.ContextInfo) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField mentionedjid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr stanzaid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr participant_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr remotejid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conversionsource_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conversiondata_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ephemeralsharedsecret_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr entrypointconversionsource_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr entrypointconversionapp_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr groupsubject_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr parentgroupjid_; - ::proto::Message* quotedmessage_; - ::proto::ContextInfo_AdReplyInfo* quotedad_; - ::proto::MessageKey* placeholderkey_; - ::proto::ContextInfo_ExternalAdReplyInfo* externaladreply_; - ::proto::DisappearingMode* disappearingmode_; - ::proto::ActionLink* actionlink_; - uint32_t conversiondelayseconds_; - uint32_t forwardingscore_; - bool isforwarded_; - uint32_t expiration_; - int64_t ephemeralsettingtimestamp_; - uint32_t entrypointconversiondelayseconds_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Conversation final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Conversation) */ { - public: - inline Conversation() : Conversation(nullptr) {} - ~Conversation() override; - explicit PROTOBUF_CONSTEXPR Conversation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Conversation(const Conversation& from); - Conversation(Conversation&& from) noexcept - : Conversation() { - *this = ::std::move(from); - } - - inline Conversation& operator=(const Conversation& from) { - CopyFrom(from); - return *this; - } - inline Conversation& operator=(Conversation&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Conversation& default_instance() { - return *internal_default_instance(); - } - static inline const Conversation* internal_default_instance() { - return reinterpret_cast( - &_Conversation_default_instance_); - } - static constexpr int kIndexInFileMessages = - 25; - - friend void swap(Conversation& a, Conversation& b) { - a.Swap(&b); - } - inline void Swap(Conversation* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Conversation* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Conversation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Conversation& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Conversation& from) { - Conversation::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Conversation* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Conversation"; - } - protected: - explicit Conversation(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Conversation_EndOfHistoryTransferType EndOfHistoryTransferType; - static constexpr EndOfHistoryTransferType COMPLETE_BUT_MORE_MESSAGES_REMAIN_ON_PRIMARY = - Conversation_EndOfHistoryTransferType_COMPLETE_BUT_MORE_MESSAGES_REMAIN_ON_PRIMARY; - static constexpr EndOfHistoryTransferType COMPLETE_AND_NO_MORE_MESSAGE_REMAIN_ON_PRIMARY = - Conversation_EndOfHistoryTransferType_COMPLETE_AND_NO_MORE_MESSAGE_REMAIN_ON_PRIMARY; - static inline bool EndOfHistoryTransferType_IsValid(int value) { - return Conversation_EndOfHistoryTransferType_IsValid(value); - } - static constexpr EndOfHistoryTransferType EndOfHistoryTransferType_MIN = - Conversation_EndOfHistoryTransferType_EndOfHistoryTransferType_MIN; - static constexpr EndOfHistoryTransferType EndOfHistoryTransferType_MAX = - Conversation_EndOfHistoryTransferType_EndOfHistoryTransferType_MAX; - static constexpr int EndOfHistoryTransferType_ARRAYSIZE = - Conversation_EndOfHistoryTransferType_EndOfHistoryTransferType_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - EndOfHistoryTransferType_descriptor() { - return Conversation_EndOfHistoryTransferType_descriptor(); - } - template - static inline const std::string& EndOfHistoryTransferType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function EndOfHistoryTransferType_Name."); - return Conversation_EndOfHistoryTransferType_Name(enum_t_value); - } - static inline bool EndOfHistoryTransferType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - EndOfHistoryTransferType* value) { - return Conversation_EndOfHistoryTransferType_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kMessagesFieldNumber = 2, - kParticipantFieldNumber = 20, - kIdFieldNumber = 1, - kNewJidFieldNumber = 3, - kOldJidFieldNumber = 4, - kNameFieldNumber = 13, - kPHashFieldNumber = 14, - kTcTokenFieldNumber = 21, - kContactPrimaryIdentityKeyFieldNumber = 23, - kCreatedByFieldNumber = 32, - kDescriptionFieldNumber = 33, - kParentGroupIdFieldNumber = 37, - kDisplayNameFieldNumber = 38, - kPnJidFieldNumber = 39, - kDisappearingModeFieldNumber = 17, - kWallpaperFieldNumber = 26, - kLastMsgTimestampFieldNumber = 5, - kUnreadCountFieldNumber = 6, - kEphemeralExpirationFieldNumber = 9, - kEphemeralSettingTimestampFieldNumber = 10, - kEndOfHistoryTransferTypeFieldNumber = 11, - kReadOnlyFieldNumber = 7, - kEndOfHistoryTransferFieldNumber = 8, - kNotSpamFieldNumber = 15, - kArchivedFieldNumber = 16, - kConversationTimestampFieldNumber = 12, - kUnreadMentionCountFieldNumber = 18, - kPinnedFieldNumber = 24, - kTcTokenTimestampFieldNumber = 22, - kMuteEndTimeFieldNumber = 25, - kMediaVisibilityFieldNumber = 27, - kMarkedAsUnreadFieldNumber = 19, - kSuspendedFieldNumber = 29, - kTerminatedFieldNumber = 30, - kSupportFieldNumber = 34, - kTcTokenSenderTimestampFieldNumber = 28, - kCreatedAtFieldNumber = 31, - kIsParentGroupFieldNumber = 35, - kIsDefaultSubgroupFieldNumber = 36, - kSelfPnExposedFieldNumber = 40, - }; - // repeated .proto.HistorySyncMsg messages = 2; - int messages_size() const; - private: - int _internal_messages_size() const; - public: - void clear_messages(); - ::proto::HistorySyncMsg* mutable_messages(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HistorySyncMsg >* - mutable_messages(); - private: - const ::proto::HistorySyncMsg& _internal_messages(int index) const; - ::proto::HistorySyncMsg* _internal_add_messages(); - public: - const ::proto::HistorySyncMsg& messages(int index) const; - ::proto::HistorySyncMsg* add_messages(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HistorySyncMsg >& - messages() const; - - // repeated .proto.GroupParticipant participant = 20; - int participant_size() const; - private: - int _internal_participant_size() const; - public: - void clear_participant(); - ::proto::GroupParticipant* mutable_participant(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::GroupParticipant >* - mutable_participant(); - private: - const ::proto::GroupParticipant& _internal_participant(int index) const; - ::proto::GroupParticipant* _internal_add_participant(); - public: - const ::proto::GroupParticipant& participant(int index) const; - ::proto::GroupParticipant* add_participant(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::GroupParticipant >& - participant() const; - - // required string id = 1; - bool has_id() const; - private: - bool _internal_has_id() const; - public: - void clear_id(); - const std::string& id() const; - template - void set_id(ArgT0&& arg0, ArgT... args); - std::string* mutable_id(); - PROTOBUF_NODISCARD std::string* release_id(); - void set_allocated_id(std::string* id); - private: - const std::string& _internal_id() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value); - std::string* _internal_mutable_id(); - public: - - // optional string newJid = 3; - bool has_newjid() const; - private: - bool _internal_has_newjid() const; - public: - void clear_newjid(); - const std::string& newjid() const; - template - void set_newjid(ArgT0&& arg0, ArgT... args); - std::string* mutable_newjid(); - PROTOBUF_NODISCARD std::string* release_newjid(); - void set_allocated_newjid(std::string* newjid); - private: - const std::string& _internal_newjid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_newjid(const std::string& value); - std::string* _internal_mutable_newjid(); - public: - - // optional string oldJid = 4; - bool has_oldjid() const; - private: - bool _internal_has_oldjid() const; - public: - void clear_oldjid(); - const std::string& oldjid() const; - template - void set_oldjid(ArgT0&& arg0, ArgT... args); - std::string* mutable_oldjid(); - PROTOBUF_NODISCARD std::string* release_oldjid(); - void set_allocated_oldjid(std::string* oldjid); - private: - const std::string& _internal_oldjid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_oldjid(const std::string& value); - std::string* _internal_mutable_oldjid(); - public: - - // optional string name = 13; - bool has_name() const; - private: - bool _internal_has_name() const; - public: - void clear_name(); - const std::string& name() const; - template - void set_name(ArgT0&& arg0, ArgT... args); - std::string* mutable_name(); - PROTOBUF_NODISCARD std::string* release_name(); - void set_allocated_name(std::string* name); - private: - const std::string& _internal_name() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); - std::string* _internal_mutable_name(); - public: - - // optional string pHash = 14; - bool has_phash() const; - private: - bool _internal_has_phash() const; - public: - void clear_phash(); - const std::string& phash() const; - template - void set_phash(ArgT0&& arg0, ArgT... args); - std::string* mutable_phash(); - PROTOBUF_NODISCARD std::string* release_phash(); - void set_allocated_phash(std::string* phash); - private: - const std::string& _internal_phash() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_phash(const std::string& value); - std::string* _internal_mutable_phash(); - public: - - // optional bytes tcToken = 21; - bool has_tctoken() const; - private: - bool _internal_has_tctoken() const; - public: - void clear_tctoken(); - const std::string& tctoken() const; - template - void set_tctoken(ArgT0&& arg0, ArgT... args); - std::string* mutable_tctoken(); - PROTOBUF_NODISCARD std::string* release_tctoken(); - void set_allocated_tctoken(std::string* tctoken); - private: - const std::string& _internal_tctoken() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_tctoken(const std::string& value); - std::string* _internal_mutable_tctoken(); - public: - - // optional bytes contactPrimaryIdentityKey = 23; - bool has_contactprimaryidentitykey() const; - private: - bool _internal_has_contactprimaryidentitykey() const; - public: - void clear_contactprimaryidentitykey(); - const std::string& contactprimaryidentitykey() const; - template - void set_contactprimaryidentitykey(ArgT0&& arg0, ArgT... args); - std::string* mutable_contactprimaryidentitykey(); - PROTOBUF_NODISCARD std::string* release_contactprimaryidentitykey(); - void set_allocated_contactprimaryidentitykey(std::string* contactprimaryidentitykey); - private: - const std::string& _internal_contactprimaryidentitykey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_contactprimaryidentitykey(const std::string& value); - std::string* _internal_mutable_contactprimaryidentitykey(); - public: - - // optional string createdBy = 32; - bool has_createdby() const; - private: - bool _internal_has_createdby() const; - public: - void clear_createdby(); - const std::string& createdby() const; - template - void set_createdby(ArgT0&& arg0, ArgT... args); - std::string* mutable_createdby(); - PROTOBUF_NODISCARD std::string* release_createdby(); - void set_allocated_createdby(std::string* createdby); - private: - const std::string& _internal_createdby() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_createdby(const std::string& value); - std::string* _internal_mutable_createdby(); - public: - - // optional string description = 33; - bool has_description() const; - private: - bool _internal_has_description() const; - public: - void clear_description(); - const std::string& description() const; - template - void set_description(ArgT0&& arg0, ArgT... args); - std::string* mutable_description(); - PROTOBUF_NODISCARD std::string* release_description(); - void set_allocated_description(std::string* description); - private: - const std::string& _internal_description() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value); - std::string* _internal_mutable_description(); - public: - - // optional string parentGroupId = 37; - bool has_parentgroupid() const; - private: - bool _internal_has_parentgroupid() const; - public: - void clear_parentgroupid(); - const std::string& parentgroupid() const; - template - void set_parentgroupid(ArgT0&& arg0, ArgT... args); - std::string* mutable_parentgroupid(); - PROTOBUF_NODISCARD std::string* release_parentgroupid(); - void set_allocated_parentgroupid(std::string* parentgroupid); - private: - const std::string& _internal_parentgroupid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_parentgroupid(const std::string& value); - std::string* _internal_mutable_parentgroupid(); - public: - - // optional string displayName = 38; - bool has_displayname() const; - private: - bool _internal_has_displayname() const; - public: - void clear_displayname(); - const std::string& displayname() const; - template - void set_displayname(ArgT0&& arg0, ArgT... args); - std::string* mutable_displayname(); - PROTOBUF_NODISCARD std::string* release_displayname(); - void set_allocated_displayname(std::string* displayname); - private: - const std::string& _internal_displayname() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_displayname(const std::string& value); - std::string* _internal_mutable_displayname(); - public: - - // optional string pnJid = 39; - bool has_pnjid() const; - private: - bool _internal_has_pnjid() const; - public: - void clear_pnjid(); - const std::string& pnjid() const; - template - void set_pnjid(ArgT0&& arg0, ArgT... args); - std::string* mutable_pnjid(); - PROTOBUF_NODISCARD std::string* release_pnjid(); - void set_allocated_pnjid(std::string* pnjid); - private: - const std::string& _internal_pnjid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_pnjid(const std::string& value); - std::string* _internal_mutable_pnjid(); - public: - - // optional .proto.DisappearingMode disappearingMode = 17; - bool has_disappearingmode() const; - private: - bool _internal_has_disappearingmode() const; - public: - void clear_disappearingmode(); - const ::proto::DisappearingMode& disappearingmode() const; - PROTOBUF_NODISCARD ::proto::DisappearingMode* release_disappearingmode(); - ::proto::DisappearingMode* mutable_disappearingmode(); - void set_allocated_disappearingmode(::proto::DisappearingMode* disappearingmode); - private: - const ::proto::DisappearingMode& _internal_disappearingmode() const; - ::proto::DisappearingMode* _internal_mutable_disappearingmode(); - public: - void unsafe_arena_set_allocated_disappearingmode( - ::proto::DisappearingMode* disappearingmode); - ::proto::DisappearingMode* unsafe_arena_release_disappearingmode(); - - // optional .proto.WallpaperSettings wallpaper = 26; - bool has_wallpaper() const; - private: - bool _internal_has_wallpaper() const; - public: - void clear_wallpaper(); - const ::proto::WallpaperSettings& wallpaper() const; - PROTOBUF_NODISCARD ::proto::WallpaperSettings* release_wallpaper(); - ::proto::WallpaperSettings* mutable_wallpaper(); - void set_allocated_wallpaper(::proto::WallpaperSettings* wallpaper); - private: - const ::proto::WallpaperSettings& _internal_wallpaper() const; - ::proto::WallpaperSettings* _internal_mutable_wallpaper(); - public: - void unsafe_arena_set_allocated_wallpaper( - ::proto::WallpaperSettings* wallpaper); - ::proto::WallpaperSettings* unsafe_arena_release_wallpaper(); - - // optional uint64 lastMsgTimestamp = 5; - bool has_lastmsgtimestamp() const; - private: - bool _internal_has_lastmsgtimestamp() const; - public: - void clear_lastmsgtimestamp(); - uint64_t lastmsgtimestamp() const; - void set_lastmsgtimestamp(uint64_t value); - private: - uint64_t _internal_lastmsgtimestamp() const; - void _internal_set_lastmsgtimestamp(uint64_t value); - public: - - // optional uint32 unreadCount = 6; - bool has_unreadcount() const; - private: - bool _internal_has_unreadcount() const; - public: - void clear_unreadcount(); - uint32_t unreadcount() const; - void set_unreadcount(uint32_t value); - private: - uint32_t _internal_unreadcount() const; - void _internal_set_unreadcount(uint32_t value); - public: - - // optional uint32 ephemeralExpiration = 9; - bool has_ephemeralexpiration() const; - private: - bool _internal_has_ephemeralexpiration() const; - public: - void clear_ephemeralexpiration(); - uint32_t ephemeralexpiration() const; - void set_ephemeralexpiration(uint32_t value); - private: - uint32_t _internal_ephemeralexpiration() const; - void _internal_set_ephemeralexpiration(uint32_t value); - public: - - // optional int64 ephemeralSettingTimestamp = 10; - bool has_ephemeralsettingtimestamp() const; - private: - bool _internal_has_ephemeralsettingtimestamp() const; - public: - void clear_ephemeralsettingtimestamp(); - int64_t ephemeralsettingtimestamp() const; - void set_ephemeralsettingtimestamp(int64_t value); - private: - int64_t _internal_ephemeralsettingtimestamp() const; - void _internal_set_ephemeralsettingtimestamp(int64_t value); - public: - - // optional .proto.Conversation.EndOfHistoryTransferType endOfHistoryTransferType = 11; - bool has_endofhistorytransfertype() const; - private: - bool _internal_has_endofhistorytransfertype() const; - public: - void clear_endofhistorytransfertype(); - ::proto::Conversation_EndOfHistoryTransferType endofhistorytransfertype() const; - void set_endofhistorytransfertype(::proto::Conversation_EndOfHistoryTransferType value); - private: - ::proto::Conversation_EndOfHistoryTransferType _internal_endofhistorytransfertype() const; - void _internal_set_endofhistorytransfertype(::proto::Conversation_EndOfHistoryTransferType value); - public: - - // optional bool readOnly = 7; - bool has_readonly() const; - private: - bool _internal_has_readonly() const; - public: - void clear_readonly(); - bool readonly() const; - void set_readonly(bool value); - private: - bool _internal_readonly() const; - void _internal_set_readonly(bool value); - public: - - // optional bool endOfHistoryTransfer = 8; - bool has_endofhistorytransfer() const; - private: - bool _internal_has_endofhistorytransfer() const; - public: - void clear_endofhistorytransfer(); - bool endofhistorytransfer() const; - void set_endofhistorytransfer(bool value); - private: - bool _internal_endofhistorytransfer() const; - void _internal_set_endofhistorytransfer(bool value); - public: - - // optional bool notSpam = 15; - bool has_notspam() const; - private: - bool _internal_has_notspam() const; - public: - void clear_notspam(); - bool notspam() const; - void set_notspam(bool value); - private: - bool _internal_notspam() const; - void _internal_set_notspam(bool value); - public: - - // optional bool archived = 16; - bool has_archived() const; - private: - bool _internal_has_archived() const; - public: - void clear_archived(); - bool archived() const; - void set_archived(bool value); - private: - bool _internal_archived() const; - void _internal_set_archived(bool value); - public: - - // optional uint64 conversationTimestamp = 12; - bool has_conversationtimestamp() const; - private: - bool _internal_has_conversationtimestamp() const; - public: - void clear_conversationtimestamp(); - uint64_t conversationtimestamp() const; - void set_conversationtimestamp(uint64_t value); - private: - uint64_t _internal_conversationtimestamp() const; - void _internal_set_conversationtimestamp(uint64_t value); - public: - - // optional uint32 unreadMentionCount = 18; - bool has_unreadmentioncount() const; - private: - bool _internal_has_unreadmentioncount() const; - public: - void clear_unreadmentioncount(); - uint32_t unreadmentioncount() const; - void set_unreadmentioncount(uint32_t value); - private: - uint32_t _internal_unreadmentioncount() const; - void _internal_set_unreadmentioncount(uint32_t value); - public: - - // optional uint32 pinned = 24; - bool has_pinned() const; - private: - bool _internal_has_pinned() const; - public: - void clear_pinned(); - uint32_t pinned() const; - void set_pinned(uint32_t value); - private: - uint32_t _internal_pinned() const; - void _internal_set_pinned(uint32_t value); - public: - - // optional uint64 tcTokenTimestamp = 22; - bool has_tctokentimestamp() const; - private: - bool _internal_has_tctokentimestamp() const; - public: - void clear_tctokentimestamp(); - uint64_t tctokentimestamp() const; - void set_tctokentimestamp(uint64_t value); - private: - uint64_t _internal_tctokentimestamp() const; - void _internal_set_tctokentimestamp(uint64_t value); - public: - - // optional uint64 muteEndTime = 25; - bool has_muteendtime() const; - private: - bool _internal_has_muteendtime() const; - public: - void clear_muteendtime(); - uint64_t muteendtime() const; - void set_muteendtime(uint64_t value); - private: - uint64_t _internal_muteendtime() const; - void _internal_set_muteendtime(uint64_t value); - public: - - // optional .proto.MediaVisibility mediaVisibility = 27; - bool has_mediavisibility() const; - private: - bool _internal_has_mediavisibility() const; - public: - void clear_mediavisibility(); - ::proto::MediaVisibility mediavisibility() const; - void set_mediavisibility(::proto::MediaVisibility value); - private: - ::proto::MediaVisibility _internal_mediavisibility() const; - void _internal_set_mediavisibility(::proto::MediaVisibility value); - public: - - // optional bool markedAsUnread = 19; - bool has_markedasunread() const; - private: - bool _internal_has_markedasunread() const; - public: - void clear_markedasunread(); - bool markedasunread() const; - void set_markedasunread(bool value); - private: - bool _internal_markedasunread() const; - void _internal_set_markedasunread(bool value); - public: - - // optional bool suspended = 29; - bool has_suspended() const; - private: - bool _internal_has_suspended() const; - public: - void clear_suspended(); - bool suspended() const; - void set_suspended(bool value); - private: - bool _internal_suspended() const; - void _internal_set_suspended(bool value); - public: - - // optional bool terminated = 30; - bool has_terminated() const; - private: - bool _internal_has_terminated() const; - public: - void clear_terminated(); - bool terminated() const; - void set_terminated(bool value); - private: - bool _internal_terminated() const; - void _internal_set_terminated(bool value); - public: - - // optional bool support = 34; - bool has_support() const; - private: - bool _internal_has_support() const; - public: - void clear_support(); - bool support() const; - void set_support(bool value); - private: - bool _internal_support() const; - void _internal_set_support(bool value); - public: - - // optional uint64 tcTokenSenderTimestamp = 28; - bool has_tctokensendertimestamp() const; - private: - bool _internal_has_tctokensendertimestamp() const; - public: - void clear_tctokensendertimestamp(); - uint64_t tctokensendertimestamp() const; - void set_tctokensendertimestamp(uint64_t value); - private: - uint64_t _internal_tctokensendertimestamp() const; - void _internal_set_tctokensendertimestamp(uint64_t value); - public: - - // optional uint64 createdAt = 31; - bool has_createdat() const; - private: - bool _internal_has_createdat() const; - public: - void clear_createdat(); - uint64_t createdat() const; - void set_createdat(uint64_t value); - private: - uint64_t _internal_createdat() const; - void _internal_set_createdat(uint64_t value); - public: - - // optional bool isParentGroup = 35; - bool has_isparentgroup() const; - private: - bool _internal_has_isparentgroup() const; - public: - void clear_isparentgroup(); - bool isparentgroup() const; - void set_isparentgroup(bool value); - private: - bool _internal_isparentgroup() const; - void _internal_set_isparentgroup(bool value); - public: - - // optional bool isDefaultSubgroup = 36; - bool has_isdefaultsubgroup() const; - private: - bool _internal_has_isdefaultsubgroup() const; - public: - void clear_isdefaultsubgroup(); - bool isdefaultsubgroup() const; - void set_isdefaultsubgroup(bool value); - private: - bool _internal_isdefaultsubgroup() const; - void _internal_set_isdefaultsubgroup(bool value); - public: - - // optional bool selfPnExposed = 40; - bool has_selfpnexposed() const; - private: - bool _internal_has_selfpnexposed() const; - public: - void clear_selfpnexposed(); - bool selfpnexposed() const; - void set_selfpnexposed(bool value); - private: - bool _internal_selfpnexposed() const; - void _internal_set_selfpnexposed(bool value); - public: - - // @@protoc_insertion_point(class_scope:proto.Conversation) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<2> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HistorySyncMsg > messages_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::GroupParticipant > participant_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr newjid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr oldjid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr phash_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tctoken_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr contactprimaryidentitykey_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr createdby_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr parentgroupid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr displayname_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pnjid_; - ::proto::DisappearingMode* disappearingmode_; - ::proto::WallpaperSettings* wallpaper_; - uint64_t lastmsgtimestamp_; - uint32_t unreadcount_; - uint32_t ephemeralexpiration_; - int64_t ephemeralsettingtimestamp_; - int endofhistorytransfertype_; - bool readonly_; - bool endofhistorytransfer_; - bool notspam_; - bool archived_; - uint64_t conversationtimestamp_; - uint32_t unreadmentioncount_; - uint32_t pinned_; - uint64_t tctokentimestamp_; - uint64_t muteendtime_; - int mediavisibility_; - bool markedasunread_; - bool suspended_; - bool terminated_; - bool support_; - uint64_t tctokensendertimestamp_; - uint64_t createdat_; - bool isparentgroup_; - bool isdefaultsubgroup_; - bool selfpnexposed_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class DeviceListMetadata final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.DeviceListMetadata) */ { - public: - inline DeviceListMetadata() : DeviceListMetadata(nullptr) {} - ~DeviceListMetadata() override; - explicit PROTOBUF_CONSTEXPR DeviceListMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - DeviceListMetadata(const DeviceListMetadata& from); - DeviceListMetadata(DeviceListMetadata&& from) noexcept - : DeviceListMetadata() { - *this = ::std::move(from); - } - - inline DeviceListMetadata& operator=(const DeviceListMetadata& from) { - CopyFrom(from); - return *this; - } - inline DeviceListMetadata& operator=(DeviceListMetadata&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const DeviceListMetadata& default_instance() { - return *internal_default_instance(); - } - static inline const DeviceListMetadata* internal_default_instance() { - return reinterpret_cast( - &_DeviceListMetadata_default_instance_); - } - static constexpr int kIndexInFileMessages = - 26; - - friend void swap(DeviceListMetadata& a, DeviceListMetadata& b) { - a.Swap(&b); - } - inline void Swap(DeviceListMetadata* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(DeviceListMetadata* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - DeviceListMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const DeviceListMetadata& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const DeviceListMetadata& from) { - DeviceListMetadata::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(DeviceListMetadata* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.DeviceListMetadata"; - } - protected: - explicit DeviceListMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kSenderKeyIndexesFieldNumber = 3, - kRecipientKeyIndexesFieldNumber = 10, - kSenderKeyHashFieldNumber = 1, - kRecipientKeyHashFieldNumber = 8, - kSenderTimestampFieldNumber = 2, - kRecipientTimestampFieldNumber = 9, - }; - // repeated uint32 senderKeyIndexes = 3 [packed = true]; - int senderkeyindexes_size() const; - private: - int _internal_senderkeyindexes_size() const; - public: - void clear_senderkeyindexes(); - private: - uint32_t _internal_senderkeyindexes(int index) const; - const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& - _internal_senderkeyindexes() const; - void _internal_add_senderkeyindexes(uint32_t value); - ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* - _internal_mutable_senderkeyindexes(); - public: - uint32_t senderkeyindexes(int index) const; - void set_senderkeyindexes(int index, uint32_t value); - void add_senderkeyindexes(uint32_t value); - const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& - senderkeyindexes() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* - mutable_senderkeyindexes(); - - // repeated uint32 recipientKeyIndexes = 10 [packed = true]; - int recipientkeyindexes_size() const; - private: - int _internal_recipientkeyindexes_size() const; - public: - void clear_recipientkeyindexes(); - private: - uint32_t _internal_recipientkeyindexes(int index) const; - const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& - _internal_recipientkeyindexes() const; - void _internal_add_recipientkeyindexes(uint32_t value); - ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* - _internal_mutable_recipientkeyindexes(); - public: - uint32_t recipientkeyindexes(int index) const; - void set_recipientkeyindexes(int index, uint32_t value); - void add_recipientkeyindexes(uint32_t value); - const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& - recipientkeyindexes() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* - mutable_recipientkeyindexes(); - - // optional bytes senderKeyHash = 1; - bool has_senderkeyhash() const; - private: - bool _internal_has_senderkeyhash() const; - public: - void clear_senderkeyhash(); - const std::string& senderkeyhash() const; - template - void set_senderkeyhash(ArgT0&& arg0, ArgT... args); - std::string* mutable_senderkeyhash(); - PROTOBUF_NODISCARD std::string* release_senderkeyhash(); - void set_allocated_senderkeyhash(std::string* senderkeyhash); - private: - const std::string& _internal_senderkeyhash() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_senderkeyhash(const std::string& value); - std::string* _internal_mutable_senderkeyhash(); - public: - - // optional bytes recipientKeyHash = 8; - bool has_recipientkeyhash() const; - private: - bool _internal_has_recipientkeyhash() const; - public: - void clear_recipientkeyhash(); - const std::string& recipientkeyhash() const; - template - void set_recipientkeyhash(ArgT0&& arg0, ArgT... args); - std::string* mutable_recipientkeyhash(); - PROTOBUF_NODISCARD std::string* release_recipientkeyhash(); - void set_allocated_recipientkeyhash(std::string* recipientkeyhash); - private: - const std::string& _internal_recipientkeyhash() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_recipientkeyhash(const std::string& value); - std::string* _internal_mutable_recipientkeyhash(); - public: - - // optional uint64 senderTimestamp = 2; - bool has_sendertimestamp() const; - private: - bool _internal_has_sendertimestamp() const; - public: - void clear_sendertimestamp(); - uint64_t sendertimestamp() const; - void set_sendertimestamp(uint64_t value); - private: - uint64_t _internal_sendertimestamp() const; - void _internal_set_sendertimestamp(uint64_t value); - public: - - // optional uint64 recipientTimestamp = 9; - bool has_recipienttimestamp() const; - private: - bool _internal_has_recipienttimestamp() const; - public: - void clear_recipienttimestamp(); - uint64_t recipienttimestamp() const; - void set_recipienttimestamp(uint64_t value); - private: - uint64_t _internal_recipienttimestamp() const; - void _internal_set_recipienttimestamp(uint64_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.DeviceListMetadata) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > senderkeyindexes_; - mutable std::atomic _senderkeyindexes_cached_byte_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > recipientkeyindexes_; - mutable std::atomic _recipientkeyindexes_cached_byte_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr senderkeyhash_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr recipientkeyhash_; - uint64_t sendertimestamp_; - uint64_t recipienttimestamp_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class DeviceProps_AppVersion final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.DeviceProps.AppVersion) */ { - public: - inline DeviceProps_AppVersion() : DeviceProps_AppVersion(nullptr) {} - ~DeviceProps_AppVersion() override; - explicit PROTOBUF_CONSTEXPR DeviceProps_AppVersion(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - DeviceProps_AppVersion(const DeviceProps_AppVersion& from); - DeviceProps_AppVersion(DeviceProps_AppVersion&& from) noexcept - : DeviceProps_AppVersion() { - *this = ::std::move(from); - } - - inline DeviceProps_AppVersion& operator=(const DeviceProps_AppVersion& from) { - CopyFrom(from); - return *this; - } - inline DeviceProps_AppVersion& operator=(DeviceProps_AppVersion&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const DeviceProps_AppVersion& default_instance() { - return *internal_default_instance(); - } - static inline const DeviceProps_AppVersion* internal_default_instance() { - return reinterpret_cast( - &_DeviceProps_AppVersion_default_instance_); - } - static constexpr int kIndexInFileMessages = - 27; - - friend void swap(DeviceProps_AppVersion& a, DeviceProps_AppVersion& b) { - a.Swap(&b); - } - inline void Swap(DeviceProps_AppVersion* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(DeviceProps_AppVersion* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - DeviceProps_AppVersion* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const DeviceProps_AppVersion& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const DeviceProps_AppVersion& from) { - DeviceProps_AppVersion::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(DeviceProps_AppVersion* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.DeviceProps.AppVersion"; - } - protected: - explicit DeviceProps_AppVersion(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kPrimaryFieldNumber = 1, - kSecondaryFieldNumber = 2, - kTertiaryFieldNumber = 3, - kQuaternaryFieldNumber = 4, - kQuinaryFieldNumber = 5, - }; - // optional uint32 primary = 1; - bool has_primary() const; - private: - bool _internal_has_primary() const; - public: - void clear_primary(); - uint32_t primary() const; - void set_primary(uint32_t value); - private: - uint32_t _internal_primary() const; - void _internal_set_primary(uint32_t value); - public: - - // optional uint32 secondary = 2; - bool has_secondary() const; - private: - bool _internal_has_secondary() const; - public: - void clear_secondary(); - uint32_t secondary() const; - void set_secondary(uint32_t value); - private: - uint32_t _internal_secondary() const; - void _internal_set_secondary(uint32_t value); - public: - - // optional uint32 tertiary = 3; - bool has_tertiary() const; - private: - bool _internal_has_tertiary() const; - public: - void clear_tertiary(); - uint32_t tertiary() const; - void set_tertiary(uint32_t value); - private: - uint32_t _internal_tertiary() const; - void _internal_set_tertiary(uint32_t value); - public: - - // optional uint32 quaternary = 4; - bool has_quaternary() const; - private: - bool _internal_has_quaternary() const; - public: - void clear_quaternary(); - uint32_t quaternary() const; - void set_quaternary(uint32_t value); - private: - uint32_t _internal_quaternary() const; - void _internal_set_quaternary(uint32_t value); - public: - - // optional uint32 quinary = 5; - bool has_quinary() const; - private: - bool _internal_has_quinary() const; - public: - void clear_quinary(); - uint32_t quinary() const; - void set_quinary(uint32_t value); - private: - uint32_t _internal_quinary() const; - void _internal_set_quinary(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.DeviceProps.AppVersion) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t primary_; - uint32_t secondary_; - uint32_t tertiary_; - uint32_t quaternary_; - uint32_t quinary_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class DeviceProps final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.DeviceProps) */ { - public: - inline DeviceProps() : DeviceProps(nullptr) {} - ~DeviceProps() override; - explicit PROTOBUF_CONSTEXPR DeviceProps(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - DeviceProps(const DeviceProps& from); - DeviceProps(DeviceProps&& from) noexcept - : DeviceProps() { - *this = ::std::move(from); - } - - inline DeviceProps& operator=(const DeviceProps& from) { - CopyFrom(from); - return *this; - } - inline DeviceProps& operator=(DeviceProps&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const DeviceProps& default_instance() { - return *internal_default_instance(); - } - static inline const DeviceProps* internal_default_instance() { - return reinterpret_cast( - &_DeviceProps_default_instance_); - } - static constexpr int kIndexInFileMessages = - 28; - - friend void swap(DeviceProps& a, DeviceProps& b) { - a.Swap(&b); - } - inline void Swap(DeviceProps* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(DeviceProps* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - DeviceProps* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const DeviceProps& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const DeviceProps& from) { - DeviceProps::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(DeviceProps* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.DeviceProps"; - } - protected: - explicit DeviceProps(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef DeviceProps_AppVersion AppVersion; - - typedef DeviceProps_PlatformType PlatformType; - static constexpr PlatformType UNKNOWN = - DeviceProps_PlatformType_UNKNOWN; - static constexpr PlatformType CHROME = - DeviceProps_PlatformType_CHROME; - static constexpr PlatformType FIREFOX = - DeviceProps_PlatformType_FIREFOX; - static constexpr PlatformType IE = - DeviceProps_PlatformType_IE; - static constexpr PlatformType OPERA = - DeviceProps_PlatformType_OPERA; - static constexpr PlatformType SAFARI = - DeviceProps_PlatformType_SAFARI; - static constexpr PlatformType EDGE = - DeviceProps_PlatformType_EDGE; - static constexpr PlatformType DESKTOP = - DeviceProps_PlatformType_DESKTOP; - static constexpr PlatformType IPAD = - DeviceProps_PlatformType_IPAD; - static constexpr PlatformType ANDROID_TABLET = - DeviceProps_PlatformType_ANDROID_TABLET; - static constexpr PlatformType OHANA = - DeviceProps_PlatformType_OHANA; - static constexpr PlatformType ALOHA = - DeviceProps_PlatformType_ALOHA; - static constexpr PlatformType CATALINA = - DeviceProps_PlatformType_CATALINA; - static constexpr PlatformType TCL_TV = - DeviceProps_PlatformType_TCL_TV; - static inline bool PlatformType_IsValid(int value) { - return DeviceProps_PlatformType_IsValid(value); - } - static constexpr PlatformType PlatformType_MIN = - DeviceProps_PlatformType_PlatformType_MIN; - static constexpr PlatformType PlatformType_MAX = - DeviceProps_PlatformType_PlatformType_MAX; - static constexpr int PlatformType_ARRAYSIZE = - DeviceProps_PlatformType_PlatformType_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - PlatformType_descriptor() { - return DeviceProps_PlatformType_descriptor(); - } - template - static inline const std::string& PlatformType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function PlatformType_Name."); - return DeviceProps_PlatformType_Name(enum_t_value); - } - static inline bool PlatformType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - PlatformType* value) { - return DeviceProps_PlatformType_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kOsFieldNumber = 1, - kVersionFieldNumber = 2, - kPlatformTypeFieldNumber = 3, - kRequireFullSyncFieldNumber = 4, - }; - // optional string os = 1; - bool has_os() const; - private: - bool _internal_has_os() const; - public: - void clear_os(); - const std::string& os() const; - template - void set_os(ArgT0&& arg0, ArgT... args); - std::string* mutable_os(); - PROTOBUF_NODISCARD std::string* release_os(); - void set_allocated_os(std::string* os); - private: - const std::string& _internal_os() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_os(const std::string& value); - std::string* _internal_mutable_os(); - public: - - // optional .proto.DeviceProps.AppVersion version = 2; - bool has_version() const; - private: - bool _internal_has_version() const; - public: - void clear_version(); - const ::proto::DeviceProps_AppVersion& version() const; - PROTOBUF_NODISCARD ::proto::DeviceProps_AppVersion* release_version(); - ::proto::DeviceProps_AppVersion* mutable_version(); - void set_allocated_version(::proto::DeviceProps_AppVersion* version); - private: - const ::proto::DeviceProps_AppVersion& _internal_version() const; - ::proto::DeviceProps_AppVersion* _internal_mutable_version(); - public: - void unsafe_arena_set_allocated_version( - ::proto::DeviceProps_AppVersion* version); - ::proto::DeviceProps_AppVersion* unsafe_arena_release_version(); - - // optional .proto.DeviceProps.PlatformType platformType = 3; - bool has_platformtype() const; - private: - bool _internal_has_platformtype() const; - public: - void clear_platformtype(); - ::proto::DeviceProps_PlatformType platformtype() const; - void set_platformtype(::proto::DeviceProps_PlatformType value); - private: - ::proto::DeviceProps_PlatformType _internal_platformtype() const; - void _internal_set_platformtype(::proto::DeviceProps_PlatformType value); - public: - - // optional bool requireFullSync = 4; - bool has_requirefullsync() const; - private: - bool _internal_has_requirefullsync() const; - public: - void clear_requirefullsync(); - bool requirefullsync() const; - void set_requirefullsync(bool value); - private: - bool _internal_requirefullsync() const; - void _internal_set_requirefullsync(bool value); - public: - - // @@protoc_insertion_point(class_scope:proto.DeviceProps) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr os_; - ::proto::DeviceProps_AppVersion* version_; - int platformtype_; - bool requirefullsync_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class DisappearingMode final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.DisappearingMode) */ { - public: - inline DisappearingMode() : DisappearingMode(nullptr) {} - ~DisappearingMode() override; - explicit PROTOBUF_CONSTEXPR DisappearingMode(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - DisappearingMode(const DisappearingMode& from); - DisappearingMode(DisappearingMode&& from) noexcept - : DisappearingMode() { - *this = ::std::move(from); - } - - inline DisappearingMode& operator=(const DisappearingMode& from) { - CopyFrom(from); - return *this; - } - inline DisappearingMode& operator=(DisappearingMode&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const DisappearingMode& default_instance() { - return *internal_default_instance(); - } - static inline const DisappearingMode* internal_default_instance() { - return reinterpret_cast( - &_DisappearingMode_default_instance_); - } - static constexpr int kIndexInFileMessages = - 29; - - friend void swap(DisappearingMode& a, DisappearingMode& b) { - a.Swap(&b); - } - inline void Swap(DisappearingMode* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(DisappearingMode* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - DisappearingMode* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const DisappearingMode& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const DisappearingMode& from) { - DisappearingMode::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(DisappearingMode* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.DisappearingMode"; - } - protected: - explicit DisappearingMode(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef DisappearingMode_Initiator Initiator; - static constexpr Initiator CHANGED_IN_CHAT = - DisappearingMode_Initiator_CHANGED_IN_CHAT; - static constexpr Initiator INITIATED_BY_ME = - DisappearingMode_Initiator_INITIATED_BY_ME; - static constexpr Initiator INITIATED_BY_OTHER = - DisappearingMode_Initiator_INITIATED_BY_OTHER; - static inline bool Initiator_IsValid(int value) { - return DisappearingMode_Initiator_IsValid(value); - } - static constexpr Initiator Initiator_MIN = - DisappearingMode_Initiator_Initiator_MIN; - static constexpr Initiator Initiator_MAX = - DisappearingMode_Initiator_Initiator_MAX; - static constexpr int Initiator_ARRAYSIZE = - DisappearingMode_Initiator_Initiator_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - Initiator_descriptor() { - return DisappearingMode_Initiator_descriptor(); - } - template - static inline const std::string& Initiator_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Initiator_Name."); - return DisappearingMode_Initiator_Name(enum_t_value); - } - static inline bool Initiator_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - Initiator* value) { - return DisappearingMode_Initiator_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kInitiatorFieldNumber = 1, - }; - // optional .proto.DisappearingMode.Initiator initiator = 1; - bool has_initiator() const; - private: - bool _internal_has_initiator() const; - public: - void clear_initiator(); - ::proto::DisappearingMode_Initiator initiator() const; - void set_initiator(::proto::DisappearingMode_Initiator value); - private: - ::proto::DisappearingMode_Initiator _internal_initiator() const; - void _internal_set_initiator(::proto::DisappearingMode_Initiator value); - public: - - // @@protoc_insertion_point(class_scope:proto.DisappearingMode) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - int initiator_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class EphemeralSetting final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.EphemeralSetting) */ { - public: - inline EphemeralSetting() : EphemeralSetting(nullptr) {} - ~EphemeralSetting() override; - explicit PROTOBUF_CONSTEXPR EphemeralSetting(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - EphemeralSetting(const EphemeralSetting& from); - EphemeralSetting(EphemeralSetting&& from) noexcept - : EphemeralSetting() { - *this = ::std::move(from); - } - - inline EphemeralSetting& operator=(const EphemeralSetting& from) { - CopyFrom(from); - return *this; - } - inline EphemeralSetting& operator=(EphemeralSetting&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const EphemeralSetting& default_instance() { - return *internal_default_instance(); - } - static inline const EphemeralSetting* internal_default_instance() { - return reinterpret_cast( - &_EphemeralSetting_default_instance_); - } - static constexpr int kIndexInFileMessages = - 30; - - friend void swap(EphemeralSetting& a, EphemeralSetting& b) { - a.Swap(&b); - } - inline void Swap(EphemeralSetting* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(EphemeralSetting* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - EphemeralSetting* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const EphemeralSetting& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const EphemeralSetting& from) { - EphemeralSetting::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(EphemeralSetting* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.EphemeralSetting"; - } - protected: - explicit EphemeralSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kTimestampFieldNumber = 2, - kDurationFieldNumber = 1, - }; - // optional sfixed64 timestamp = 2; - bool has_timestamp() const; - private: - bool _internal_has_timestamp() const; - public: - void clear_timestamp(); - int64_t timestamp() const; - void set_timestamp(int64_t value); - private: - int64_t _internal_timestamp() const; - void _internal_set_timestamp(int64_t value); - public: - - // optional sfixed32 duration = 1; - bool has_duration() const; - private: - bool _internal_has_duration() const; - public: - void clear_duration(); - int32_t duration() const; - void set_duration(int32_t value); - private: - int32_t _internal_duration() const; - void _internal_set_duration(int32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.EphemeralSetting) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - int64_t timestamp_; - int32_t duration_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class ExitCode final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ExitCode) */ { - public: - inline ExitCode() : ExitCode(nullptr) {} - ~ExitCode() override; - explicit PROTOBUF_CONSTEXPR ExitCode(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ExitCode(const ExitCode& from); - ExitCode(ExitCode&& from) noexcept - : ExitCode() { - *this = ::std::move(from); - } - - inline ExitCode& operator=(const ExitCode& from) { - CopyFrom(from); - return *this; - } - inline ExitCode& operator=(ExitCode&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const ExitCode& default_instance() { - return *internal_default_instance(); - } - static inline const ExitCode* internal_default_instance() { - return reinterpret_cast( - &_ExitCode_default_instance_); - } - static constexpr int kIndexInFileMessages = - 31; - - friend void swap(ExitCode& a, ExitCode& b) { - a.Swap(&b); - } - inline void Swap(ExitCode* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ExitCode* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ExitCode* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ExitCode& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const ExitCode& from) { - ExitCode::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ExitCode* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.ExitCode"; - } - protected: - explicit ExitCode(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kTextFieldNumber = 2, - kCodeFieldNumber = 1, - }; - // optional string text = 2; - bool has_text() const; - private: - bool _internal_has_text() const; - public: - void clear_text(); - const std::string& text() const; - template - void set_text(ArgT0&& arg0, ArgT... args); - std::string* mutable_text(); - PROTOBUF_NODISCARD std::string* release_text(); - void set_allocated_text(std::string* text); - private: - const std::string& _internal_text() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value); - std::string* _internal_mutable_text(); - public: - - // optional uint64 code = 1; - bool has_code() const; - private: - bool _internal_has_code() const; - public: - void clear_code(); - uint64_t code() const; - void set_code(uint64_t value); - private: - uint64_t _internal_code() const; - void _internal_set_code(uint64_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.ExitCode) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_; - uint64_t code_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class ExternalBlobReference final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ExternalBlobReference) */ { - public: - inline ExternalBlobReference() : ExternalBlobReference(nullptr) {} - ~ExternalBlobReference() override; - explicit PROTOBUF_CONSTEXPR ExternalBlobReference(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ExternalBlobReference(const ExternalBlobReference& from); - ExternalBlobReference(ExternalBlobReference&& from) noexcept - : ExternalBlobReference() { - *this = ::std::move(from); - } - - inline ExternalBlobReference& operator=(const ExternalBlobReference& from) { - CopyFrom(from); - return *this; - } - inline ExternalBlobReference& operator=(ExternalBlobReference&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const ExternalBlobReference& default_instance() { - return *internal_default_instance(); - } - static inline const ExternalBlobReference* internal_default_instance() { - return reinterpret_cast( - &_ExternalBlobReference_default_instance_); - } - static constexpr int kIndexInFileMessages = - 32; - - friend void swap(ExternalBlobReference& a, ExternalBlobReference& b) { - a.Swap(&b); - } - inline void Swap(ExternalBlobReference* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ExternalBlobReference* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ExternalBlobReference* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ExternalBlobReference& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const ExternalBlobReference& from) { - ExternalBlobReference::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ExternalBlobReference* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.ExternalBlobReference"; - } - protected: - explicit ExternalBlobReference(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kMediaKeyFieldNumber = 1, - kDirectPathFieldNumber = 2, - kHandleFieldNumber = 3, - kFileSha256FieldNumber = 5, - kFileEncSha256FieldNumber = 6, - kFileSizeBytesFieldNumber = 4, - }; - // optional bytes mediaKey = 1; - bool has_mediakey() const; - private: - bool _internal_has_mediakey() const; - public: - void clear_mediakey(); - const std::string& mediakey() const; - template - void set_mediakey(ArgT0&& arg0, ArgT... args); - std::string* mutable_mediakey(); - PROTOBUF_NODISCARD std::string* release_mediakey(); - void set_allocated_mediakey(std::string* mediakey); - private: - const std::string& _internal_mediakey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value); - std::string* _internal_mutable_mediakey(); - public: - - // optional string directPath = 2; - bool has_directpath() const; - private: - bool _internal_has_directpath() const; - public: - void clear_directpath(); - const std::string& directpath() const; - template - void set_directpath(ArgT0&& arg0, ArgT... args); - std::string* mutable_directpath(); - PROTOBUF_NODISCARD std::string* release_directpath(); - void set_allocated_directpath(std::string* directpath); - private: - const std::string& _internal_directpath() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value); - std::string* _internal_mutable_directpath(); - public: - - // optional string handle = 3; - bool has_handle() const; - private: - bool _internal_has_handle() const; - public: - void clear_handle(); - const std::string& handle() const; - template - void set_handle(ArgT0&& arg0, ArgT... args); - std::string* mutable_handle(); - PROTOBUF_NODISCARD std::string* release_handle(); - void set_allocated_handle(std::string* handle); - private: - const std::string& _internal_handle() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_handle(const std::string& value); - std::string* _internal_mutable_handle(); - public: - - // optional bytes fileSha256 = 5; - bool has_filesha256() const; - private: - bool _internal_has_filesha256() const; - public: - void clear_filesha256(); - const std::string& filesha256() const; - template - void set_filesha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_filesha256(); - PROTOBUF_NODISCARD std::string* release_filesha256(); - void set_allocated_filesha256(std::string* filesha256); - private: - const std::string& _internal_filesha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value); - std::string* _internal_mutable_filesha256(); - public: - - // optional bytes fileEncSha256 = 6; - bool has_fileencsha256() const; - private: - bool _internal_has_fileencsha256() const; - public: - void clear_fileencsha256(); - const std::string& fileencsha256() const; - template - void set_fileencsha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_fileencsha256(); - PROTOBUF_NODISCARD std::string* release_fileencsha256(); - void set_allocated_fileencsha256(std::string* fileencsha256); - private: - const std::string& _internal_fileencsha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value); - std::string* _internal_mutable_fileencsha256(); - public: - - // optional uint64 fileSizeBytes = 4; - bool has_filesizebytes() const; - private: - bool _internal_has_filesizebytes() const; - public: - void clear_filesizebytes(); - uint64_t filesizebytes() const; - void set_filesizebytes(uint64_t value); - private: - uint64_t _internal_filesizebytes() const; - void _internal_set_filesizebytes(uint64_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.ExternalBlobReference) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr handle_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_; - uint64_t filesizebytes_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class GlobalSettings final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.GlobalSettings) */ { - public: - inline GlobalSettings() : GlobalSettings(nullptr) {} - ~GlobalSettings() override; - explicit PROTOBUF_CONSTEXPR GlobalSettings(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - GlobalSettings(const GlobalSettings& from); - GlobalSettings(GlobalSettings&& from) noexcept - : GlobalSettings() { - *this = ::std::move(from); - } - - inline GlobalSettings& operator=(const GlobalSettings& from) { - CopyFrom(from); - return *this; - } - inline GlobalSettings& operator=(GlobalSettings&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const GlobalSettings& default_instance() { - return *internal_default_instance(); - } - static inline const GlobalSettings* internal_default_instance() { - return reinterpret_cast( - &_GlobalSettings_default_instance_); - } - static constexpr int kIndexInFileMessages = - 33; - - friend void swap(GlobalSettings& a, GlobalSettings& b) { - a.Swap(&b); - } - inline void Swap(GlobalSettings* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(GlobalSettings* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - GlobalSettings* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const GlobalSettings& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const GlobalSettings& from) { - GlobalSettings::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(GlobalSettings* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.GlobalSettings"; - } - protected: - explicit GlobalSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kLightThemeWallpaperFieldNumber = 1, - kDarkThemeWallpaperFieldNumber = 3, - kAutoDownloadWiFiFieldNumber = 4, - kAutoDownloadCellularFieldNumber = 5, - kAutoDownloadRoamingFieldNumber = 6, - kMediaVisibilityFieldNumber = 2, - kShowIndividualNotificationsPreviewFieldNumber = 7, - kShowGroupNotificationsPreviewFieldNumber = 8, - kDisappearingModeTimestampFieldNumber = 10, - kDisappearingModeDurationFieldNumber = 9, - }; - // optional .proto.WallpaperSettings lightThemeWallpaper = 1; - bool has_lightthemewallpaper() const; - private: - bool _internal_has_lightthemewallpaper() const; - public: - void clear_lightthemewallpaper(); - const ::proto::WallpaperSettings& lightthemewallpaper() const; - PROTOBUF_NODISCARD ::proto::WallpaperSettings* release_lightthemewallpaper(); - ::proto::WallpaperSettings* mutable_lightthemewallpaper(); - void set_allocated_lightthemewallpaper(::proto::WallpaperSettings* lightthemewallpaper); - private: - const ::proto::WallpaperSettings& _internal_lightthemewallpaper() const; - ::proto::WallpaperSettings* _internal_mutable_lightthemewallpaper(); - public: - void unsafe_arena_set_allocated_lightthemewallpaper( - ::proto::WallpaperSettings* lightthemewallpaper); - ::proto::WallpaperSettings* unsafe_arena_release_lightthemewallpaper(); - - // optional .proto.WallpaperSettings darkThemeWallpaper = 3; - bool has_darkthemewallpaper() const; - private: - bool _internal_has_darkthemewallpaper() const; - public: - void clear_darkthemewallpaper(); - const ::proto::WallpaperSettings& darkthemewallpaper() const; - PROTOBUF_NODISCARD ::proto::WallpaperSettings* release_darkthemewallpaper(); - ::proto::WallpaperSettings* mutable_darkthemewallpaper(); - void set_allocated_darkthemewallpaper(::proto::WallpaperSettings* darkthemewallpaper); - private: - const ::proto::WallpaperSettings& _internal_darkthemewallpaper() const; - ::proto::WallpaperSettings* _internal_mutable_darkthemewallpaper(); - public: - void unsafe_arena_set_allocated_darkthemewallpaper( - ::proto::WallpaperSettings* darkthemewallpaper); - ::proto::WallpaperSettings* unsafe_arena_release_darkthemewallpaper(); - - // optional .proto.AutoDownloadSettings autoDownloadWiFi = 4; - bool has_autodownloadwifi() const; - private: - bool _internal_has_autodownloadwifi() const; - public: - void clear_autodownloadwifi(); - const ::proto::AutoDownloadSettings& autodownloadwifi() const; - PROTOBUF_NODISCARD ::proto::AutoDownloadSettings* release_autodownloadwifi(); - ::proto::AutoDownloadSettings* mutable_autodownloadwifi(); - void set_allocated_autodownloadwifi(::proto::AutoDownloadSettings* autodownloadwifi); - private: - const ::proto::AutoDownloadSettings& _internal_autodownloadwifi() const; - ::proto::AutoDownloadSettings* _internal_mutable_autodownloadwifi(); - public: - void unsafe_arena_set_allocated_autodownloadwifi( - ::proto::AutoDownloadSettings* autodownloadwifi); - ::proto::AutoDownloadSettings* unsafe_arena_release_autodownloadwifi(); - - // optional .proto.AutoDownloadSettings autoDownloadCellular = 5; - bool has_autodownloadcellular() const; - private: - bool _internal_has_autodownloadcellular() const; - public: - void clear_autodownloadcellular(); - const ::proto::AutoDownloadSettings& autodownloadcellular() const; - PROTOBUF_NODISCARD ::proto::AutoDownloadSettings* release_autodownloadcellular(); - ::proto::AutoDownloadSettings* mutable_autodownloadcellular(); - void set_allocated_autodownloadcellular(::proto::AutoDownloadSettings* autodownloadcellular); - private: - const ::proto::AutoDownloadSettings& _internal_autodownloadcellular() const; - ::proto::AutoDownloadSettings* _internal_mutable_autodownloadcellular(); - public: - void unsafe_arena_set_allocated_autodownloadcellular( - ::proto::AutoDownloadSettings* autodownloadcellular); - ::proto::AutoDownloadSettings* unsafe_arena_release_autodownloadcellular(); - - // optional .proto.AutoDownloadSettings autoDownloadRoaming = 6; - bool has_autodownloadroaming() const; - private: - bool _internal_has_autodownloadroaming() const; - public: - void clear_autodownloadroaming(); - const ::proto::AutoDownloadSettings& autodownloadroaming() const; - PROTOBUF_NODISCARD ::proto::AutoDownloadSettings* release_autodownloadroaming(); - ::proto::AutoDownloadSettings* mutable_autodownloadroaming(); - void set_allocated_autodownloadroaming(::proto::AutoDownloadSettings* autodownloadroaming); - private: - const ::proto::AutoDownloadSettings& _internal_autodownloadroaming() const; - ::proto::AutoDownloadSettings* _internal_mutable_autodownloadroaming(); - public: - void unsafe_arena_set_allocated_autodownloadroaming( - ::proto::AutoDownloadSettings* autodownloadroaming); - ::proto::AutoDownloadSettings* unsafe_arena_release_autodownloadroaming(); - - // optional .proto.MediaVisibility mediaVisibility = 2; - bool has_mediavisibility() const; - private: - bool _internal_has_mediavisibility() const; - public: - void clear_mediavisibility(); - ::proto::MediaVisibility mediavisibility() const; - void set_mediavisibility(::proto::MediaVisibility value); - private: - ::proto::MediaVisibility _internal_mediavisibility() const; - void _internal_set_mediavisibility(::proto::MediaVisibility value); - public: - - // optional bool showIndividualNotificationsPreview = 7; - bool has_showindividualnotificationspreview() const; - private: - bool _internal_has_showindividualnotificationspreview() const; - public: - void clear_showindividualnotificationspreview(); - bool showindividualnotificationspreview() const; - void set_showindividualnotificationspreview(bool value); - private: - bool _internal_showindividualnotificationspreview() const; - void _internal_set_showindividualnotificationspreview(bool value); - public: - - // optional bool showGroupNotificationsPreview = 8; - bool has_showgroupnotificationspreview() const; - private: - bool _internal_has_showgroupnotificationspreview() const; - public: - void clear_showgroupnotificationspreview(); - bool showgroupnotificationspreview() const; - void set_showgroupnotificationspreview(bool value); - private: - bool _internal_showgroupnotificationspreview() const; - void _internal_set_showgroupnotificationspreview(bool value); - public: - - // optional int64 disappearingModeTimestamp = 10; - bool has_disappearingmodetimestamp() const; - private: - bool _internal_has_disappearingmodetimestamp() const; - public: - void clear_disappearingmodetimestamp(); - int64_t disappearingmodetimestamp() const; - void set_disappearingmodetimestamp(int64_t value); - private: - int64_t _internal_disappearingmodetimestamp() const; - void _internal_set_disappearingmodetimestamp(int64_t value); - public: - - // optional int32 disappearingModeDuration = 9; - bool has_disappearingmodeduration() const; - private: - bool _internal_has_disappearingmodeduration() const; - public: - void clear_disappearingmodeduration(); - int32_t disappearingmodeduration() const; - void set_disappearingmodeduration(int32_t value); - private: - int32_t _internal_disappearingmodeduration() const; - void _internal_set_disappearingmodeduration(int32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.GlobalSettings) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::proto::WallpaperSettings* lightthemewallpaper_; - ::proto::WallpaperSettings* darkthemewallpaper_; - ::proto::AutoDownloadSettings* autodownloadwifi_; - ::proto::AutoDownloadSettings* autodownloadcellular_; - ::proto::AutoDownloadSettings* autodownloadroaming_; - int mediavisibility_; - bool showindividualnotificationspreview_; - bool showgroupnotificationspreview_; - int64_t disappearingmodetimestamp_; - int32_t disappearingmodeduration_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class GroupParticipant final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.GroupParticipant) */ { - public: - inline GroupParticipant() : GroupParticipant(nullptr) {} - ~GroupParticipant() override; - explicit PROTOBUF_CONSTEXPR GroupParticipant(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - GroupParticipant(const GroupParticipant& from); - GroupParticipant(GroupParticipant&& from) noexcept - : GroupParticipant() { - *this = ::std::move(from); - } - - inline GroupParticipant& operator=(const GroupParticipant& from) { - CopyFrom(from); - return *this; - } - inline GroupParticipant& operator=(GroupParticipant&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const GroupParticipant& default_instance() { - return *internal_default_instance(); - } - static inline const GroupParticipant* internal_default_instance() { - return reinterpret_cast( - &_GroupParticipant_default_instance_); - } - static constexpr int kIndexInFileMessages = - 34; - - friend void swap(GroupParticipant& a, GroupParticipant& b) { - a.Swap(&b); - } - inline void Swap(GroupParticipant* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(GroupParticipant* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - GroupParticipant* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const GroupParticipant& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const GroupParticipant& from) { - GroupParticipant::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(GroupParticipant* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.GroupParticipant"; - } - protected: - explicit GroupParticipant(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef GroupParticipant_Rank Rank; - static constexpr Rank REGULAR = - GroupParticipant_Rank_REGULAR; - static constexpr Rank ADMIN = - GroupParticipant_Rank_ADMIN; - static constexpr Rank SUPERADMIN = - GroupParticipant_Rank_SUPERADMIN; - static inline bool Rank_IsValid(int value) { - return GroupParticipant_Rank_IsValid(value); - } - static constexpr Rank Rank_MIN = - GroupParticipant_Rank_Rank_MIN; - static constexpr Rank Rank_MAX = - GroupParticipant_Rank_Rank_MAX; - static constexpr int Rank_ARRAYSIZE = - GroupParticipant_Rank_Rank_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - Rank_descriptor() { - return GroupParticipant_Rank_descriptor(); - } - template - static inline const std::string& Rank_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Rank_Name."); - return GroupParticipant_Rank_Name(enum_t_value); - } - static inline bool Rank_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - Rank* value) { - return GroupParticipant_Rank_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kUserJidFieldNumber = 1, - kRankFieldNumber = 2, - }; - // required string userJid = 1; - bool has_userjid() const; - private: - bool _internal_has_userjid() const; - public: - void clear_userjid(); - const std::string& userjid() const; - template - void set_userjid(ArgT0&& arg0, ArgT... args); - std::string* mutable_userjid(); - PROTOBUF_NODISCARD std::string* release_userjid(); - void set_allocated_userjid(std::string* userjid); - private: - const std::string& _internal_userjid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_userjid(const std::string& value); - std::string* _internal_mutable_userjid(); - public: - - // optional .proto.GroupParticipant.Rank rank = 2; - bool has_rank() const; - private: - bool _internal_has_rank() const; - public: - void clear_rank(); - ::proto::GroupParticipant_Rank rank() const; - void set_rank(::proto::GroupParticipant_Rank value); - private: - ::proto::GroupParticipant_Rank _internal_rank() const; - void _internal_set_rank(::proto::GroupParticipant_Rank value); - public: - - // @@protoc_insertion_point(class_scope:proto.GroupParticipant) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userjid_; - int rank_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class HandshakeMessage_ClientFinish final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HandshakeMessage.ClientFinish) */ { - public: - inline HandshakeMessage_ClientFinish() : HandshakeMessage_ClientFinish(nullptr) {} - ~HandshakeMessage_ClientFinish() override; - explicit PROTOBUF_CONSTEXPR HandshakeMessage_ClientFinish(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - HandshakeMessage_ClientFinish(const HandshakeMessage_ClientFinish& from); - HandshakeMessage_ClientFinish(HandshakeMessage_ClientFinish&& from) noexcept - : HandshakeMessage_ClientFinish() { - *this = ::std::move(from); - } - - inline HandshakeMessage_ClientFinish& operator=(const HandshakeMessage_ClientFinish& from) { - CopyFrom(from); - return *this; - } - inline HandshakeMessage_ClientFinish& operator=(HandshakeMessage_ClientFinish&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const HandshakeMessage_ClientFinish& default_instance() { - return *internal_default_instance(); - } - static inline const HandshakeMessage_ClientFinish* internal_default_instance() { - return reinterpret_cast( - &_HandshakeMessage_ClientFinish_default_instance_); - } - static constexpr int kIndexInFileMessages = - 35; - - friend void swap(HandshakeMessage_ClientFinish& a, HandshakeMessage_ClientFinish& b) { - a.Swap(&b); - } - inline void Swap(HandshakeMessage_ClientFinish* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(HandshakeMessage_ClientFinish* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - HandshakeMessage_ClientFinish* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const HandshakeMessage_ClientFinish& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const HandshakeMessage_ClientFinish& from) { - HandshakeMessage_ClientFinish::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(HandshakeMessage_ClientFinish* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.HandshakeMessage.ClientFinish"; - } - protected: - explicit HandshakeMessage_ClientFinish(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kStaticFieldNumber = 1, - kPayloadFieldNumber = 2, - }; - // optional bytes static = 1; - bool has_static_() const; - private: - bool _internal_has_static_() const; - public: - void clear_static_(); - const std::string& static_() const; - template - void set_static_(ArgT0&& arg0, ArgT... args); - std::string* mutable_static_(); - PROTOBUF_NODISCARD std::string* release_static_(); - void set_allocated_static_(std::string* static_); - private: - const std::string& _internal_static_() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_static_(const std::string& value); - std::string* _internal_mutable_static_(); - public: - - // optional bytes payload = 2; - bool has_payload() const; - private: - bool _internal_has_payload() const; - public: - void clear_payload(); - const std::string& payload() const; - template - void set_payload(ArgT0&& arg0, ArgT... args); - std::string* mutable_payload(); - PROTOBUF_NODISCARD std::string* release_payload(); - void set_allocated_payload(std::string* payload); - private: - const std::string& _internal_payload() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_payload(const std::string& value); - std::string* _internal_mutable_payload(); - public: - - // @@protoc_insertion_point(class_scope:proto.HandshakeMessage.ClientFinish) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr static__; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class HandshakeMessage_ClientHello final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HandshakeMessage.ClientHello) */ { - public: - inline HandshakeMessage_ClientHello() : HandshakeMessage_ClientHello(nullptr) {} - ~HandshakeMessage_ClientHello() override; - explicit PROTOBUF_CONSTEXPR HandshakeMessage_ClientHello(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - HandshakeMessage_ClientHello(const HandshakeMessage_ClientHello& from); - HandshakeMessage_ClientHello(HandshakeMessage_ClientHello&& from) noexcept - : HandshakeMessage_ClientHello() { - *this = ::std::move(from); - } - - inline HandshakeMessage_ClientHello& operator=(const HandshakeMessage_ClientHello& from) { - CopyFrom(from); - return *this; - } - inline HandshakeMessage_ClientHello& operator=(HandshakeMessage_ClientHello&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const HandshakeMessage_ClientHello& default_instance() { - return *internal_default_instance(); - } - static inline const HandshakeMessage_ClientHello* internal_default_instance() { - return reinterpret_cast( - &_HandshakeMessage_ClientHello_default_instance_); - } - static constexpr int kIndexInFileMessages = - 36; - - friend void swap(HandshakeMessage_ClientHello& a, HandshakeMessage_ClientHello& b) { - a.Swap(&b); - } - inline void Swap(HandshakeMessage_ClientHello* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(HandshakeMessage_ClientHello* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - HandshakeMessage_ClientHello* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const HandshakeMessage_ClientHello& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const HandshakeMessage_ClientHello& from) { - HandshakeMessage_ClientHello::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(HandshakeMessage_ClientHello* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.HandshakeMessage.ClientHello"; - } - protected: - explicit HandshakeMessage_ClientHello(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kEphemeralFieldNumber = 1, - kStaticFieldNumber = 2, - kPayloadFieldNumber = 3, - }; - // optional bytes ephemeral = 1; - bool has_ephemeral() const; - private: - bool _internal_has_ephemeral() const; - public: - void clear_ephemeral(); - const std::string& ephemeral() const; - template - void set_ephemeral(ArgT0&& arg0, ArgT... args); - std::string* mutable_ephemeral(); - PROTOBUF_NODISCARD std::string* release_ephemeral(); - void set_allocated_ephemeral(std::string* ephemeral); - private: - const std::string& _internal_ephemeral() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_ephemeral(const std::string& value); - std::string* _internal_mutable_ephemeral(); - public: - - // optional bytes static = 2; - bool has_static_() const; - private: - bool _internal_has_static_() const; - public: - void clear_static_(); - const std::string& static_() const; - template - void set_static_(ArgT0&& arg0, ArgT... args); - std::string* mutable_static_(); - PROTOBUF_NODISCARD std::string* release_static_(); - void set_allocated_static_(std::string* static_); - private: - const std::string& _internal_static_() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_static_(const std::string& value); - std::string* _internal_mutable_static_(); - public: - - // optional bytes payload = 3; - bool has_payload() const; - private: - bool _internal_has_payload() const; - public: - void clear_payload(); - const std::string& payload() const; - template - void set_payload(ArgT0&& arg0, ArgT... args); - std::string* mutable_payload(); - PROTOBUF_NODISCARD std::string* release_payload(); - void set_allocated_payload(std::string* payload); - private: - const std::string& _internal_payload() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_payload(const std::string& value); - std::string* _internal_mutable_payload(); - public: - - // @@protoc_insertion_point(class_scope:proto.HandshakeMessage.ClientHello) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ephemeral_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr static__; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class HandshakeMessage_ServerHello final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HandshakeMessage.ServerHello) */ { - public: - inline HandshakeMessage_ServerHello() : HandshakeMessage_ServerHello(nullptr) {} - ~HandshakeMessage_ServerHello() override; - explicit PROTOBUF_CONSTEXPR HandshakeMessage_ServerHello(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - HandshakeMessage_ServerHello(const HandshakeMessage_ServerHello& from); - HandshakeMessage_ServerHello(HandshakeMessage_ServerHello&& from) noexcept - : HandshakeMessage_ServerHello() { - *this = ::std::move(from); - } - - inline HandshakeMessage_ServerHello& operator=(const HandshakeMessage_ServerHello& from) { - CopyFrom(from); - return *this; - } - inline HandshakeMessage_ServerHello& operator=(HandshakeMessage_ServerHello&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const HandshakeMessage_ServerHello& default_instance() { - return *internal_default_instance(); - } - static inline const HandshakeMessage_ServerHello* internal_default_instance() { - return reinterpret_cast( - &_HandshakeMessage_ServerHello_default_instance_); - } - static constexpr int kIndexInFileMessages = - 37; - - friend void swap(HandshakeMessage_ServerHello& a, HandshakeMessage_ServerHello& b) { - a.Swap(&b); - } - inline void Swap(HandshakeMessage_ServerHello* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(HandshakeMessage_ServerHello* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - HandshakeMessage_ServerHello* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const HandshakeMessage_ServerHello& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const HandshakeMessage_ServerHello& from) { - HandshakeMessage_ServerHello::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(HandshakeMessage_ServerHello* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.HandshakeMessage.ServerHello"; - } - protected: - explicit HandshakeMessage_ServerHello(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kEphemeralFieldNumber = 1, - kStaticFieldNumber = 2, - kPayloadFieldNumber = 3, - }; - // optional bytes ephemeral = 1; - bool has_ephemeral() const; - private: - bool _internal_has_ephemeral() const; - public: - void clear_ephemeral(); - const std::string& ephemeral() const; - template - void set_ephemeral(ArgT0&& arg0, ArgT... args); - std::string* mutable_ephemeral(); - PROTOBUF_NODISCARD std::string* release_ephemeral(); - void set_allocated_ephemeral(std::string* ephemeral); - private: - const std::string& _internal_ephemeral() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_ephemeral(const std::string& value); - std::string* _internal_mutable_ephemeral(); - public: - - // optional bytes static = 2; - bool has_static_() const; - private: - bool _internal_has_static_() const; - public: - void clear_static_(); - const std::string& static_() const; - template - void set_static_(ArgT0&& arg0, ArgT... args); - std::string* mutable_static_(); - PROTOBUF_NODISCARD std::string* release_static_(); - void set_allocated_static_(std::string* static_); - private: - const std::string& _internal_static_() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_static_(const std::string& value); - std::string* _internal_mutable_static_(); - public: - - // optional bytes payload = 3; - bool has_payload() const; - private: - bool _internal_has_payload() const; - public: - void clear_payload(); - const std::string& payload() const; - template - void set_payload(ArgT0&& arg0, ArgT... args); - std::string* mutable_payload(); - PROTOBUF_NODISCARD std::string* release_payload(); - void set_allocated_payload(std::string* payload); - private: - const std::string& _internal_payload() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_payload(const std::string& value); - std::string* _internal_mutable_payload(); - public: - - // @@protoc_insertion_point(class_scope:proto.HandshakeMessage.ServerHello) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ephemeral_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr static__; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class HandshakeMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HandshakeMessage) */ { - public: - inline HandshakeMessage() : HandshakeMessage(nullptr) {} - ~HandshakeMessage() override; - explicit PROTOBUF_CONSTEXPR HandshakeMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - HandshakeMessage(const HandshakeMessage& from); - HandshakeMessage(HandshakeMessage&& from) noexcept - : HandshakeMessage() { - *this = ::std::move(from); - } - - inline HandshakeMessage& operator=(const HandshakeMessage& from) { - CopyFrom(from); - return *this; - } - inline HandshakeMessage& operator=(HandshakeMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const HandshakeMessage& default_instance() { - return *internal_default_instance(); - } - static inline const HandshakeMessage* internal_default_instance() { - return reinterpret_cast( - &_HandshakeMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 38; - - friend void swap(HandshakeMessage& a, HandshakeMessage& b) { - a.Swap(&b); - } - inline void Swap(HandshakeMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(HandshakeMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - HandshakeMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const HandshakeMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const HandshakeMessage& from) { - HandshakeMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(HandshakeMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.HandshakeMessage"; - } - protected: - explicit HandshakeMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef HandshakeMessage_ClientFinish ClientFinish; - typedef HandshakeMessage_ClientHello ClientHello; - typedef HandshakeMessage_ServerHello ServerHello; - - // accessors ------------------------------------------------------- - - enum : int { - kClientHelloFieldNumber = 2, - kServerHelloFieldNumber = 3, - kClientFinishFieldNumber = 4, - }; - // optional .proto.HandshakeMessage.ClientHello clientHello = 2; - bool has_clienthello() const; - private: - bool _internal_has_clienthello() const; - public: - void clear_clienthello(); - const ::proto::HandshakeMessage_ClientHello& clienthello() const; - PROTOBUF_NODISCARD ::proto::HandshakeMessage_ClientHello* release_clienthello(); - ::proto::HandshakeMessage_ClientHello* mutable_clienthello(); - void set_allocated_clienthello(::proto::HandshakeMessage_ClientHello* clienthello); - private: - const ::proto::HandshakeMessage_ClientHello& _internal_clienthello() const; - ::proto::HandshakeMessage_ClientHello* _internal_mutable_clienthello(); - public: - void unsafe_arena_set_allocated_clienthello( - ::proto::HandshakeMessage_ClientHello* clienthello); - ::proto::HandshakeMessage_ClientHello* unsafe_arena_release_clienthello(); - - // optional .proto.HandshakeMessage.ServerHello serverHello = 3; - bool has_serverhello() const; - private: - bool _internal_has_serverhello() const; - public: - void clear_serverhello(); - const ::proto::HandshakeMessage_ServerHello& serverhello() const; - PROTOBUF_NODISCARD ::proto::HandshakeMessage_ServerHello* release_serverhello(); - ::proto::HandshakeMessage_ServerHello* mutable_serverhello(); - void set_allocated_serverhello(::proto::HandshakeMessage_ServerHello* serverhello); - private: - const ::proto::HandshakeMessage_ServerHello& _internal_serverhello() const; - ::proto::HandshakeMessage_ServerHello* _internal_mutable_serverhello(); - public: - void unsafe_arena_set_allocated_serverhello( - ::proto::HandshakeMessage_ServerHello* serverhello); - ::proto::HandshakeMessage_ServerHello* unsafe_arena_release_serverhello(); - - // optional .proto.HandshakeMessage.ClientFinish clientFinish = 4; - bool has_clientfinish() const; - private: - bool _internal_has_clientfinish() const; - public: - void clear_clientfinish(); - const ::proto::HandshakeMessage_ClientFinish& clientfinish() const; - PROTOBUF_NODISCARD ::proto::HandshakeMessage_ClientFinish* release_clientfinish(); - ::proto::HandshakeMessage_ClientFinish* mutable_clientfinish(); - void set_allocated_clientfinish(::proto::HandshakeMessage_ClientFinish* clientfinish); - private: - const ::proto::HandshakeMessage_ClientFinish& _internal_clientfinish() const; - ::proto::HandshakeMessage_ClientFinish* _internal_mutable_clientfinish(); - public: - void unsafe_arena_set_allocated_clientfinish( - ::proto::HandshakeMessage_ClientFinish* clientfinish); - ::proto::HandshakeMessage_ClientFinish* unsafe_arena_release_clientfinish(); - - // @@protoc_insertion_point(class_scope:proto.HandshakeMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::proto::HandshakeMessage_ClientHello* clienthello_; - ::proto::HandshakeMessage_ServerHello* serverhello_; - ::proto::HandshakeMessage_ClientFinish* clientfinish_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class HistorySync final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HistorySync) */ { - public: - inline HistorySync() : HistorySync(nullptr) {} - ~HistorySync() override; - explicit PROTOBUF_CONSTEXPR HistorySync(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - HistorySync(const HistorySync& from); - HistorySync(HistorySync&& from) noexcept - : HistorySync() { - *this = ::std::move(from); - } - - inline HistorySync& operator=(const HistorySync& from) { - CopyFrom(from); - return *this; - } - inline HistorySync& operator=(HistorySync&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const HistorySync& default_instance() { - return *internal_default_instance(); - } - static inline const HistorySync* internal_default_instance() { - return reinterpret_cast( - &_HistorySync_default_instance_); - } - static constexpr int kIndexInFileMessages = - 39; - - friend void swap(HistorySync& a, HistorySync& b) { - a.Swap(&b); - } - inline void Swap(HistorySync* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(HistorySync* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - HistorySync* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const HistorySync& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const HistorySync& from) { - HistorySync::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(HistorySync* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.HistorySync"; - } - protected: - explicit HistorySync(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef HistorySync_HistorySyncType HistorySyncType; - static constexpr HistorySyncType INITIAL_BOOTSTRAP = - HistorySync_HistorySyncType_INITIAL_BOOTSTRAP; - static constexpr HistorySyncType INITIAL_STATUS_V3 = - HistorySync_HistorySyncType_INITIAL_STATUS_V3; - static constexpr HistorySyncType FULL = - HistorySync_HistorySyncType_FULL; - static constexpr HistorySyncType RECENT = - HistorySync_HistorySyncType_RECENT; - static constexpr HistorySyncType PUSH_NAME = - HistorySync_HistorySyncType_PUSH_NAME; - static constexpr HistorySyncType UNBLOCKING_DATA = - HistorySync_HistorySyncType_UNBLOCKING_DATA; - static inline bool HistorySyncType_IsValid(int value) { - return HistorySync_HistorySyncType_IsValid(value); - } - static constexpr HistorySyncType HistorySyncType_MIN = - HistorySync_HistorySyncType_HistorySyncType_MIN; - static constexpr HistorySyncType HistorySyncType_MAX = - HistorySync_HistorySyncType_HistorySyncType_MAX; - static constexpr int HistorySyncType_ARRAYSIZE = - HistorySync_HistorySyncType_HistorySyncType_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - HistorySyncType_descriptor() { - return HistorySync_HistorySyncType_descriptor(); - } - template - static inline const std::string& HistorySyncType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function HistorySyncType_Name."); - return HistorySync_HistorySyncType_Name(enum_t_value); - } - static inline bool HistorySyncType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - HistorySyncType* value) { - return HistorySync_HistorySyncType_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kConversationsFieldNumber = 2, - kStatusV3MessagesFieldNumber = 3, - kPushnamesFieldNumber = 7, - kRecentStickersFieldNumber = 11, - kPastParticipantsFieldNumber = 12, - kThreadIdUserSecretFieldNumber = 9, - kGlobalSettingsFieldNumber = 8, - kSyncTypeFieldNumber = 1, - kChunkOrderFieldNumber = 5, - kProgressFieldNumber = 6, - kThreadDsTimeframeOffsetFieldNumber = 10, - }; - // repeated .proto.Conversation conversations = 2; - int conversations_size() const; - private: - int _internal_conversations_size() const; - public: - void clear_conversations(); - ::proto::Conversation* mutable_conversations(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Conversation >* - mutable_conversations(); - private: - const ::proto::Conversation& _internal_conversations(int index) const; - ::proto::Conversation* _internal_add_conversations(); - public: - const ::proto::Conversation& conversations(int index) const; - ::proto::Conversation* add_conversations(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Conversation >& - conversations() const; - - // repeated .proto.WebMessageInfo statusV3Messages = 3; - int statusv3messages_size() const; - private: - int _internal_statusv3messages_size() const; - public: - void clear_statusv3messages(); - ::proto::WebMessageInfo* mutable_statusv3messages(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >* - mutable_statusv3messages(); - private: - const ::proto::WebMessageInfo& _internal_statusv3messages(int index) const; - ::proto::WebMessageInfo* _internal_add_statusv3messages(); - public: - const ::proto::WebMessageInfo& statusv3messages(int index) const; - ::proto::WebMessageInfo* add_statusv3messages(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >& - statusv3messages() const; - - // repeated .proto.Pushname pushnames = 7; - int pushnames_size() const; - private: - int _internal_pushnames_size() const; - public: - void clear_pushnames(); - ::proto::Pushname* mutable_pushnames(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Pushname >* - mutable_pushnames(); - private: - const ::proto::Pushname& _internal_pushnames(int index) const; - ::proto::Pushname* _internal_add_pushnames(); - public: - const ::proto::Pushname& pushnames(int index) const; - ::proto::Pushname* add_pushnames(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Pushname >& - pushnames() const; - - // repeated .proto.StickerMetadata recentStickers = 11; - int recentstickers_size() const; - private: - int _internal_recentstickers_size() const; - public: - void clear_recentstickers(); - ::proto::StickerMetadata* mutable_recentstickers(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::StickerMetadata >* - mutable_recentstickers(); - private: - const ::proto::StickerMetadata& _internal_recentstickers(int index) const; - ::proto::StickerMetadata* _internal_add_recentstickers(); - public: - const ::proto::StickerMetadata& recentstickers(int index) const; - ::proto::StickerMetadata* add_recentstickers(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::StickerMetadata >& - recentstickers() const; - - // repeated .proto.PastParticipants pastParticipants = 12; - int pastparticipants_size() const; - private: - int _internal_pastparticipants_size() const; - public: - void clear_pastparticipants(); - ::proto::PastParticipants* mutable_pastparticipants(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipants >* - mutable_pastparticipants(); - private: - const ::proto::PastParticipants& _internal_pastparticipants(int index) const; - ::proto::PastParticipants* _internal_add_pastparticipants(); - public: - const ::proto::PastParticipants& pastparticipants(int index) const; - ::proto::PastParticipants* add_pastparticipants(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipants >& - pastparticipants() const; - - // optional bytes threadIdUserSecret = 9; - bool has_threadidusersecret() const; - private: - bool _internal_has_threadidusersecret() const; - public: - void clear_threadidusersecret(); - const std::string& threadidusersecret() const; - template - void set_threadidusersecret(ArgT0&& arg0, ArgT... args); - std::string* mutable_threadidusersecret(); - PROTOBUF_NODISCARD std::string* release_threadidusersecret(); - void set_allocated_threadidusersecret(std::string* threadidusersecret); - private: - const std::string& _internal_threadidusersecret() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_threadidusersecret(const std::string& value); - std::string* _internal_mutable_threadidusersecret(); - public: - - // optional .proto.GlobalSettings globalSettings = 8; - bool has_globalsettings() const; - private: - bool _internal_has_globalsettings() const; - public: - void clear_globalsettings(); - const ::proto::GlobalSettings& globalsettings() const; - PROTOBUF_NODISCARD ::proto::GlobalSettings* release_globalsettings(); - ::proto::GlobalSettings* mutable_globalsettings(); - void set_allocated_globalsettings(::proto::GlobalSettings* globalsettings); - private: - const ::proto::GlobalSettings& _internal_globalsettings() const; - ::proto::GlobalSettings* _internal_mutable_globalsettings(); - public: - void unsafe_arena_set_allocated_globalsettings( - ::proto::GlobalSettings* globalsettings); - ::proto::GlobalSettings* unsafe_arena_release_globalsettings(); - - // required .proto.HistorySync.HistorySyncType syncType = 1; - bool has_synctype() const; - private: - bool _internal_has_synctype() const; - public: - void clear_synctype(); - ::proto::HistorySync_HistorySyncType synctype() const; - void set_synctype(::proto::HistorySync_HistorySyncType value); - private: - ::proto::HistorySync_HistorySyncType _internal_synctype() const; - void _internal_set_synctype(::proto::HistorySync_HistorySyncType value); - public: - - // optional uint32 chunkOrder = 5; - bool has_chunkorder() const; - private: - bool _internal_has_chunkorder() const; - public: - void clear_chunkorder(); - uint32_t chunkorder() const; - void set_chunkorder(uint32_t value); - private: - uint32_t _internal_chunkorder() const; - void _internal_set_chunkorder(uint32_t value); - public: - - // optional uint32 progress = 6; - bool has_progress() const; - private: - bool _internal_has_progress() const; - public: - void clear_progress(); - uint32_t progress() const; - void set_progress(uint32_t value); - private: - uint32_t _internal_progress() const; - void _internal_set_progress(uint32_t value); - public: - - // optional uint32 threadDsTimeframeOffset = 10; - bool has_threaddstimeframeoffset() const; - private: - bool _internal_has_threaddstimeframeoffset() const; - public: - void clear_threaddstimeframeoffset(); - uint32_t threaddstimeframeoffset() const; - void set_threaddstimeframeoffset(uint32_t value); - private: - uint32_t _internal_threaddstimeframeoffset() const; - void _internal_set_threaddstimeframeoffset(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.HistorySync) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Conversation > conversations_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo > statusv3messages_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Pushname > pushnames_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::StickerMetadata > recentstickers_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipants > pastparticipants_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr threadidusersecret_; - ::proto::GlobalSettings* globalsettings_; - int synctype_; - uint32_t chunkorder_; - uint32_t progress_; - uint32_t threaddstimeframeoffset_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class HistorySyncMsg final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HistorySyncMsg) */ { - public: - inline HistorySyncMsg() : HistorySyncMsg(nullptr) {} - ~HistorySyncMsg() override; - explicit PROTOBUF_CONSTEXPR HistorySyncMsg(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - HistorySyncMsg(const HistorySyncMsg& from); - HistorySyncMsg(HistorySyncMsg&& from) noexcept - : HistorySyncMsg() { - *this = ::std::move(from); - } - - inline HistorySyncMsg& operator=(const HistorySyncMsg& from) { - CopyFrom(from); - return *this; - } - inline HistorySyncMsg& operator=(HistorySyncMsg&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const HistorySyncMsg& default_instance() { - return *internal_default_instance(); - } - static inline const HistorySyncMsg* internal_default_instance() { - return reinterpret_cast( - &_HistorySyncMsg_default_instance_); - } - static constexpr int kIndexInFileMessages = - 40; - - friend void swap(HistorySyncMsg& a, HistorySyncMsg& b) { - a.Swap(&b); - } - inline void Swap(HistorySyncMsg* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(HistorySyncMsg* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - HistorySyncMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const HistorySyncMsg& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const HistorySyncMsg& from) { - HistorySyncMsg::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(HistorySyncMsg* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.HistorySyncMsg"; - } - protected: - explicit HistorySyncMsg(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kMessageFieldNumber = 1, - kMsgOrderIdFieldNumber = 2, - }; - // optional .proto.WebMessageInfo message = 1; - bool has_message() const; - private: - bool _internal_has_message() const; - public: - void clear_message(); - const ::proto::WebMessageInfo& message() const; - PROTOBUF_NODISCARD ::proto::WebMessageInfo* release_message(); - ::proto::WebMessageInfo* mutable_message(); - void set_allocated_message(::proto::WebMessageInfo* message); - private: - const ::proto::WebMessageInfo& _internal_message() const; - ::proto::WebMessageInfo* _internal_mutable_message(); - public: - void unsafe_arena_set_allocated_message( - ::proto::WebMessageInfo* message); - ::proto::WebMessageInfo* unsafe_arena_release_message(); - - // optional uint64 msgOrderId = 2; - bool has_msgorderid() const; - private: - bool _internal_has_msgorderid() const; - public: - void clear_msgorderid(); - uint64_t msgorderid() const; - void set_msgorderid(uint64_t value); - private: - uint64_t _internal_msgorderid() const; - void _internal_set_msgorderid(uint64_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.HistorySyncMsg) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::proto::WebMessageInfo* message_; - uint64_t msgorderid_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class HydratedTemplateButton_HydratedCallButton final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HydratedTemplateButton.HydratedCallButton) */ { - public: - inline HydratedTemplateButton_HydratedCallButton() : HydratedTemplateButton_HydratedCallButton(nullptr) {} - ~HydratedTemplateButton_HydratedCallButton() override; - explicit PROTOBUF_CONSTEXPR HydratedTemplateButton_HydratedCallButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - HydratedTemplateButton_HydratedCallButton(const HydratedTemplateButton_HydratedCallButton& from); - HydratedTemplateButton_HydratedCallButton(HydratedTemplateButton_HydratedCallButton&& from) noexcept - : HydratedTemplateButton_HydratedCallButton() { - *this = ::std::move(from); - } - - inline HydratedTemplateButton_HydratedCallButton& operator=(const HydratedTemplateButton_HydratedCallButton& from) { - CopyFrom(from); - return *this; - } - inline HydratedTemplateButton_HydratedCallButton& operator=(HydratedTemplateButton_HydratedCallButton&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const HydratedTemplateButton_HydratedCallButton& default_instance() { - return *internal_default_instance(); - } - static inline const HydratedTemplateButton_HydratedCallButton* internal_default_instance() { - return reinterpret_cast( - &_HydratedTemplateButton_HydratedCallButton_default_instance_); - } - static constexpr int kIndexInFileMessages = - 41; - - friend void swap(HydratedTemplateButton_HydratedCallButton& a, HydratedTemplateButton_HydratedCallButton& b) { - a.Swap(&b); - } - inline void Swap(HydratedTemplateButton_HydratedCallButton* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(HydratedTemplateButton_HydratedCallButton* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - HydratedTemplateButton_HydratedCallButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const HydratedTemplateButton_HydratedCallButton& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const HydratedTemplateButton_HydratedCallButton& from) { - HydratedTemplateButton_HydratedCallButton::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(HydratedTemplateButton_HydratedCallButton* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.HydratedTemplateButton.HydratedCallButton"; - } - protected: - explicit HydratedTemplateButton_HydratedCallButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kDisplayTextFieldNumber = 1, - kPhoneNumberFieldNumber = 2, - }; - // optional string displayText = 1; - bool has_displaytext() const; - private: - bool _internal_has_displaytext() const; - public: - void clear_displaytext(); - const std::string& displaytext() const; - template - void set_displaytext(ArgT0&& arg0, ArgT... args); - std::string* mutable_displaytext(); - PROTOBUF_NODISCARD std::string* release_displaytext(); - void set_allocated_displaytext(std::string* displaytext); - private: - const std::string& _internal_displaytext() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_displaytext(const std::string& value); - std::string* _internal_mutable_displaytext(); - public: - - // optional string phoneNumber = 2; - bool has_phonenumber() const; - private: - bool _internal_has_phonenumber() const; - public: - void clear_phonenumber(); - const std::string& phonenumber() const; - template - void set_phonenumber(ArgT0&& arg0, ArgT... args); - std::string* mutable_phonenumber(); - PROTOBUF_NODISCARD std::string* release_phonenumber(); - void set_allocated_phonenumber(std::string* phonenumber); - private: - const std::string& _internal_phonenumber() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_phonenumber(const std::string& value); - std::string* _internal_mutable_phonenumber(); - public: - - // @@protoc_insertion_point(class_scope:proto.HydratedTemplateButton.HydratedCallButton) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr displaytext_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr phonenumber_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class HydratedTemplateButton_HydratedQuickReplyButton final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HydratedTemplateButton.HydratedQuickReplyButton) */ { - public: - inline HydratedTemplateButton_HydratedQuickReplyButton() : HydratedTemplateButton_HydratedQuickReplyButton(nullptr) {} - ~HydratedTemplateButton_HydratedQuickReplyButton() override; - explicit PROTOBUF_CONSTEXPR HydratedTemplateButton_HydratedQuickReplyButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - HydratedTemplateButton_HydratedQuickReplyButton(const HydratedTemplateButton_HydratedQuickReplyButton& from); - HydratedTemplateButton_HydratedQuickReplyButton(HydratedTemplateButton_HydratedQuickReplyButton&& from) noexcept - : HydratedTemplateButton_HydratedQuickReplyButton() { - *this = ::std::move(from); - } - - inline HydratedTemplateButton_HydratedQuickReplyButton& operator=(const HydratedTemplateButton_HydratedQuickReplyButton& from) { - CopyFrom(from); - return *this; - } - inline HydratedTemplateButton_HydratedQuickReplyButton& operator=(HydratedTemplateButton_HydratedQuickReplyButton&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const HydratedTemplateButton_HydratedQuickReplyButton& default_instance() { - return *internal_default_instance(); - } - static inline const HydratedTemplateButton_HydratedQuickReplyButton* internal_default_instance() { - return reinterpret_cast( - &_HydratedTemplateButton_HydratedQuickReplyButton_default_instance_); - } - static constexpr int kIndexInFileMessages = - 42; - - friend void swap(HydratedTemplateButton_HydratedQuickReplyButton& a, HydratedTemplateButton_HydratedQuickReplyButton& b) { - a.Swap(&b); - } - inline void Swap(HydratedTemplateButton_HydratedQuickReplyButton* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(HydratedTemplateButton_HydratedQuickReplyButton* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - HydratedTemplateButton_HydratedQuickReplyButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const HydratedTemplateButton_HydratedQuickReplyButton& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const HydratedTemplateButton_HydratedQuickReplyButton& from) { - HydratedTemplateButton_HydratedQuickReplyButton::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(HydratedTemplateButton_HydratedQuickReplyButton* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.HydratedTemplateButton.HydratedQuickReplyButton"; - } - protected: - explicit HydratedTemplateButton_HydratedQuickReplyButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kDisplayTextFieldNumber = 1, - kIdFieldNumber = 2, - }; - // optional string displayText = 1; - bool has_displaytext() const; - private: - bool _internal_has_displaytext() const; - public: - void clear_displaytext(); - const std::string& displaytext() const; - template - void set_displaytext(ArgT0&& arg0, ArgT... args); - std::string* mutable_displaytext(); - PROTOBUF_NODISCARD std::string* release_displaytext(); - void set_allocated_displaytext(std::string* displaytext); - private: - const std::string& _internal_displaytext() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_displaytext(const std::string& value); - std::string* _internal_mutable_displaytext(); - public: - - // optional string id = 2; - bool has_id() const; - private: - bool _internal_has_id() const; - public: - void clear_id(); - const std::string& id() const; - template - void set_id(ArgT0&& arg0, ArgT... args); - std::string* mutable_id(); - PROTOBUF_NODISCARD std::string* release_id(); - void set_allocated_id(std::string* id); - private: - const std::string& _internal_id() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value); - std::string* _internal_mutable_id(); - public: - - // @@protoc_insertion_point(class_scope:proto.HydratedTemplateButton.HydratedQuickReplyButton) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr displaytext_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class HydratedTemplateButton_HydratedURLButton final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HydratedTemplateButton.HydratedURLButton) */ { - public: - inline HydratedTemplateButton_HydratedURLButton() : HydratedTemplateButton_HydratedURLButton(nullptr) {} - ~HydratedTemplateButton_HydratedURLButton() override; - explicit PROTOBUF_CONSTEXPR HydratedTemplateButton_HydratedURLButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - HydratedTemplateButton_HydratedURLButton(const HydratedTemplateButton_HydratedURLButton& from); - HydratedTemplateButton_HydratedURLButton(HydratedTemplateButton_HydratedURLButton&& from) noexcept - : HydratedTemplateButton_HydratedURLButton() { - *this = ::std::move(from); - } - - inline HydratedTemplateButton_HydratedURLButton& operator=(const HydratedTemplateButton_HydratedURLButton& from) { - CopyFrom(from); - return *this; - } - inline HydratedTemplateButton_HydratedURLButton& operator=(HydratedTemplateButton_HydratedURLButton&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const HydratedTemplateButton_HydratedURLButton& default_instance() { - return *internal_default_instance(); - } - static inline const HydratedTemplateButton_HydratedURLButton* internal_default_instance() { - return reinterpret_cast( - &_HydratedTemplateButton_HydratedURLButton_default_instance_); - } - static constexpr int kIndexInFileMessages = - 43; - - friend void swap(HydratedTemplateButton_HydratedURLButton& a, HydratedTemplateButton_HydratedURLButton& b) { - a.Swap(&b); - } - inline void Swap(HydratedTemplateButton_HydratedURLButton* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(HydratedTemplateButton_HydratedURLButton* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - HydratedTemplateButton_HydratedURLButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const HydratedTemplateButton_HydratedURLButton& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const HydratedTemplateButton_HydratedURLButton& from) { - HydratedTemplateButton_HydratedURLButton::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(HydratedTemplateButton_HydratedURLButton* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.HydratedTemplateButton.HydratedURLButton"; - } - protected: - explicit HydratedTemplateButton_HydratedURLButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kDisplayTextFieldNumber = 1, - kUrlFieldNumber = 2, - }; - // optional string displayText = 1; - bool has_displaytext() const; - private: - bool _internal_has_displaytext() const; - public: - void clear_displaytext(); - const std::string& displaytext() const; - template - void set_displaytext(ArgT0&& arg0, ArgT... args); - std::string* mutable_displaytext(); - PROTOBUF_NODISCARD std::string* release_displaytext(); - void set_allocated_displaytext(std::string* displaytext); - private: - const std::string& _internal_displaytext() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_displaytext(const std::string& value); - std::string* _internal_mutable_displaytext(); - public: - - // optional string url = 2; - bool has_url() const; - private: - bool _internal_has_url() const; - public: - void clear_url(); - const std::string& url() const; - template - void set_url(ArgT0&& arg0, ArgT... args); - std::string* mutable_url(); - PROTOBUF_NODISCARD std::string* release_url(); - void set_allocated_url(std::string* url); - private: - const std::string& _internal_url() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value); - std::string* _internal_mutable_url(); - public: - - // @@protoc_insertion_point(class_scope:proto.HydratedTemplateButton.HydratedURLButton) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr displaytext_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class HydratedTemplateButton final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HydratedTemplateButton) */ { - public: - inline HydratedTemplateButton() : HydratedTemplateButton(nullptr) {} - ~HydratedTemplateButton() override; - explicit PROTOBUF_CONSTEXPR HydratedTemplateButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - HydratedTemplateButton(const HydratedTemplateButton& from); - HydratedTemplateButton(HydratedTemplateButton&& from) noexcept - : HydratedTemplateButton() { - *this = ::std::move(from); - } - - inline HydratedTemplateButton& operator=(const HydratedTemplateButton& from) { - CopyFrom(from); - return *this; - } - inline HydratedTemplateButton& operator=(HydratedTemplateButton&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const HydratedTemplateButton& default_instance() { - return *internal_default_instance(); - } - enum HydratedButtonCase { - kQuickReplyButton = 1, - kUrlButton = 2, - kCallButton = 3, - HYDRATEDBUTTON_NOT_SET = 0, - }; - - static inline const HydratedTemplateButton* internal_default_instance() { - return reinterpret_cast( - &_HydratedTemplateButton_default_instance_); - } - static constexpr int kIndexInFileMessages = - 44; - - friend void swap(HydratedTemplateButton& a, HydratedTemplateButton& b) { - a.Swap(&b); - } - inline void Swap(HydratedTemplateButton* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(HydratedTemplateButton* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - HydratedTemplateButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const HydratedTemplateButton& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const HydratedTemplateButton& from) { - HydratedTemplateButton::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(HydratedTemplateButton* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.HydratedTemplateButton"; - } - protected: - explicit HydratedTemplateButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef HydratedTemplateButton_HydratedCallButton HydratedCallButton; - typedef HydratedTemplateButton_HydratedQuickReplyButton HydratedQuickReplyButton; - typedef HydratedTemplateButton_HydratedURLButton HydratedURLButton; - - // accessors ------------------------------------------------------- - - enum : int { - kIndexFieldNumber = 4, - kQuickReplyButtonFieldNumber = 1, - kUrlButtonFieldNumber = 2, - kCallButtonFieldNumber = 3, - }; - // optional uint32 index = 4; - bool has_index() const; - private: - bool _internal_has_index() const; - public: - void clear_index(); - uint32_t index() const; - void set_index(uint32_t value); - private: - uint32_t _internal_index() const; - void _internal_set_index(uint32_t value); - public: - - // .proto.HydratedTemplateButton.HydratedQuickReplyButton quickReplyButton = 1; - bool has_quickreplybutton() const; - private: - bool _internal_has_quickreplybutton() const; - public: - void clear_quickreplybutton(); - const ::proto::HydratedTemplateButton_HydratedQuickReplyButton& quickreplybutton() const; - PROTOBUF_NODISCARD ::proto::HydratedTemplateButton_HydratedQuickReplyButton* release_quickreplybutton(); - ::proto::HydratedTemplateButton_HydratedQuickReplyButton* mutable_quickreplybutton(); - void set_allocated_quickreplybutton(::proto::HydratedTemplateButton_HydratedQuickReplyButton* quickreplybutton); - private: - const ::proto::HydratedTemplateButton_HydratedQuickReplyButton& _internal_quickreplybutton() const; - ::proto::HydratedTemplateButton_HydratedQuickReplyButton* _internal_mutable_quickreplybutton(); - public: - void unsafe_arena_set_allocated_quickreplybutton( - ::proto::HydratedTemplateButton_HydratedQuickReplyButton* quickreplybutton); - ::proto::HydratedTemplateButton_HydratedQuickReplyButton* unsafe_arena_release_quickreplybutton(); - - // .proto.HydratedTemplateButton.HydratedURLButton urlButton = 2; - bool has_urlbutton() const; - private: - bool _internal_has_urlbutton() const; - public: - void clear_urlbutton(); - const ::proto::HydratedTemplateButton_HydratedURLButton& urlbutton() const; - PROTOBUF_NODISCARD ::proto::HydratedTemplateButton_HydratedURLButton* release_urlbutton(); - ::proto::HydratedTemplateButton_HydratedURLButton* mutable_urlbutton(); - void set_allocated_urlbutton(::proto::HydratedTemplateButton_HydratedURLButton* urlbutton); - private: - const ::proto::HydratedTemplateButton_HydratedURLButton& _internal_urlbutton() const; - ::proto::HydratedTemplateButton_HydratedURLButton* _internal_mutable_urlbutton(); - public: - void unsafe_arena_set_allocated_urlbutton( - ::proto::HydratedTemplateButton_HydratedURLButton* urlbutton); - ::proto::HydratedTemplateButton_HydratedURLButton* unsafe_arena_release_urlbutton(); - - // .proto.HydratedTemplateButton.HydratedCallButton callButton = 3; - bool has_callbutton() const; - private: - bool _internal_has_callbutton() const; - public: - void clear_callbutton(); - const ::proto::HydratedTemplateButton_HydratedCallButton& callbutton() const; - PROTOBUF_NODISCARD ::proto::HydratedTemplateButton_HydratedCallButton* release_callbutton(); - ::proto::HydratedTemplateButton_HydratedCallButton* mutable_callbutton(); - void set_allocated_callbutton(::proto::HydratedTemplateButton_HydratedCallButton* callbutton); - private: - const ::proto::HydratedTemplateButton_HydratedCallButton& _internal_callbutton() const; - ::proto::HydratedTemplateButton_HydratedCallButton* _internal_mutable_callbutton(); - public: - void unsafe_arena_set_allocated_callbutton( - ::proto::HydratedTemplateButton_HydratedCallButton* callbutton); - ::proto::HydratedTemplateButton_HydratedCallButton* unsafe_arena_release_callbutton(); - - void clear_hydratedButton(); - HydratedButtonCase hydratedButton_case() const; - // @@protoc_insertion_point(class_scope:proto.HydratedTemplateButton) - private: - class _Internal; - void set_has_quickreplybutton(); - void set_has_urlbutton(); - void set_has_callbutton(); - - inline bool has_hydratedButton() const; - inline void clear_has_hydratedButton(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t index_; - union HydratedButtonUnion { - constexpr HydratedButtonUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::proto::HydratedTemplateButton_HydratedQuickReplyButton* quickreplybutton_; - ::proto::HydratedTemplateButton_HydratedURLButton* urlbutton_; - ::proto::HydratedTemplateButton_HydratedCallButton* callbutton_; - } hydratedButton_; - uint32_t _oneof_case_[1]; - - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class IdentityKeyPairStructure final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.IdentityKeyPairStructure) */ { - public: - inline IdentityKeyPairStructure() : IdentityKeyPairStructure(nullptr) {} - ~IdentityKeyPairStructure() override; - explicit PROTOBUF_CONSTEXPR IdentityKeyPairStructure(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - IdentityKeyPairStructure(const IdentityKeyPairStructure& from); - IdentityKeyPairStructure(IdentityKeyPairStructure&& from) noexcept - : IdentityKeyPairStructure() { - *this = ::std::move(from); - } - - inline IdentityKeyPairStructure& operator=(const IdentityKeyPairStructure& from) { - CopyFrom(from); - return *this; - } - inline IdentityKeyPairStructure& operator=(IdentityKeyPairStructure&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const IdentityKeyPairStructure& default_instance() { - return *internal_default_instance(); - } - static inline const IdentityKeyPairStructure* internal_default_instance() { - return reinterpret_cast( - &_IdentityKeyPairStructure_default_instance_); - } - static constexpr int kIndexInFileMessages = - 45; - - friend void swap(IdentityKeyPairStructure& a, IdentityKeyPairStructure& b) { - a.Swap(&b); - } - inline void Swap(IdentityKeyPairStructure* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(IdentityKeyPairStructure* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - IdentityKeyPairStructure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const IdentityKeyPairStructure& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const IdentityKeyPairStructure& from) { - IdentityKeyPairStructure::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(IdentityKeyPairStructure* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.IdentityKeyPairStructure"; - } - protected: - explicit IdentityKeyPairStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kPublicKeyFieldNumber = 1, - kPrivateKeyFieldNumber = 2, - }; - // optional bytes publicKey = 1; - bool has_publickey() const; - private: - bool _internal_has_publickey() const; - public: - void clear_publickey(); - const std::string& publickey() const; - template - void set_publickey(ArgT0&& arg0, ArgT... args); - std::string* mutable_publickey(); - PROTOBUF_NODISCARD std::string* release_publickey(); - void set_allocated_publickey(std::string* publickey); - private: - const std::string& _internal_publickey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_publickey(const std::string& value); - std::string* _internal_mutable_publickey(); - public: - - // optional bytes privateKey = 2; - bool has_privatekey() const; - private: - bool _internal_has_privatekey() const; - public: - void clear_privatekey(); - const std::string& privatekey() const; - template - void set_privatekey(ArgT0&& arg0, ArgT... args); - std::string* mutable_privatekey(); - PROTOBUF_NODISCARD std::string* release_privatekey(); - void set_allocated_privatekey(std::string* privatekey); - private: - const std::string& _internal_privatekey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_privatekey(const std::string& value); - std::string* _internal_mutable_privatekey(); - public: - - // @@protoc_insertion_point(class_scope:proto.IdentityKeyPairStructure) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr publickey_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr privatekey_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class InteractiveAnnotation final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.InteractiveAnnotation) */ { - public: - inline InteractiveAnnotation() : InteractiveAnnotation(nullptr) {} - ~InteractiveAnnotation() override; - explicit PROTOBUF_CONSTEXPR InteractiveAnnotation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - InteractiveAnnotation(const InteractiveAnnotation& from); - InteractiveAnnotation(InteractiveAnnotation&& from) noexcept - : InteractiveAnnotation() { - *this = ::std::move(from); - } - - inline InteractiveAnnotation& operator=(const InteractiveAnnotation& from) { - CopyFrom(from); - return *this; - } - inline InteractiveAnnotation& operator=(InteractiveAnnotation&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const InteractiveAnnotation& default_instance() { - return *internal_default_instance(); - } - enum ActionCase { - kLocation = 2, - ACTION_NOT_SET = 0, - }; - - static inline const InteractiveAnnotation* internal_default_instance() { - return reinterpret_cast( - &_InteractiveAnnotation_default_instance_); - } - static constexpr int kIndexInFileMessages = - 46; - - friend void swap(InteractiveAnnotation& a, InteractiveAnnotation& b) { - a.Swap(&b); - } - inline void Swap(InteractiveAnnotation* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(InteractiveAnnotation* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - InteractiveAnnotation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const InteractiveAnnotation& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const InteractiveAnnotation& from) { - InteractiveAnnotation::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(InteractiveAnnotation* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.InteractiveAnnotation"; - } - protected: - explicit InteractiveAnnotation(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kPolygonVerticesFieldNumber = 1, - kLocationFieldNumber = 2, - }; - // repeated .proto.Point polygonVertices = 1; - int polygonvertices_size() const; - private: - int _internal_polygonvertices_size() const; - public: - void clear_polygonvertices(); - ::proto::Point* mutable_polygonvertices(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Point >* - mutable_polygonvertices(); - private: - const ::proto::Point& _internal_polygonvertices(int index) const; - ::proto::Point* _internal_add_polygonvertices(); - public: - const ::proto::Point& polygonvertices(int index) const; - ::proto::Point* add_polygonvertices(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Point >& - polygonvertices() const; - - // .proto.Location location = 2; - bool has_location() const; - private: - bool _internal_has_location() const; - public: - void clear_location(); - const ::proto::Location& location() const; - PROTOBUF_NODISCARD ::proto::Location* release_location(); - ::proto::Location* mutable_location(); - void set_allocated_location(::proto::Location* location); - private: - const ::proto::Location& _internal_location() const; - ::proto::Location* _internal_mutable_location(); - public: - void unsafe_arena_set_allocated_location( - ::proto::Location* location); - ::proto::Location* unsafe_arena_release_location(); - - void clear_action(); - ActionCase action_case() const; - // @@protoc_insertion_point(class_scope:proto.InteractiveAnnotation) - private: - class _Internal; - void set_has_location(); - - inline bool has_action() const; - inline void clear_has_action(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Point > polygonvertices_; - union ActionUnion { - constexpr ActionUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::proto::Location* location_; - } action_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t _oneof_case_[1]; - - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class KeepInChat final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.KeepInChat) */ { - public: - inline KeepInChat() : KeepInChat(nullptr) {} - ~KeepInChat() override; - explicit PROTOBUF_CONSTEXPR KeepInChat(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - KeepInChat(const KeepInChat& from); - KeepInChat(KeepInChat&& from) noexcept - : KeepInChat() { - *this = ::std::move(from); - } - - inline KeepInChat& operator=(const KeepInChat& from) { - CopyFrom(from); - return *this; - } - inline KeepInChat& operator=(KeepInChat&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const KeepInChat& default_instance() { - return *internal_default_instance(); - } - static inline const KeepInChat* internal_default_instance() { - return reinterpret_cast( - &_KeepInChat_default_instance_); - } - static constexpr int kIndexInFileMessages = - 47; - - friend void swap(KeepInChat& a, KeepInChat& b) { - a.Swap(&b); - } - inline void Swap(KeepInChat* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(KeepInChat* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - KeepInChat* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const KeepInChat& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const KeepInChat& from) { - KeepInChat::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(KeepInChat* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.KeepInChat"; - } - protected: - explicit KeepInChat(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kDeviceJidFieldNumber = 4, - kKeyFieldNumber = 3, - kServerTimestampFieldNumber = 2, - kKeepTypeFieldNumber = 1, - }; - // optional string deviceJid = 4; - bool has_devicejid() const; - private: - bool _internal_has_devicejid() const; - public: - void clear_devicejid(); - const std::string& devicejid() const; - template - void set_devicejid(ArgT0&& arg0, ArgT... args); - std::string* mutable_devicejid(); - PROTOBUF_NODISCARD std::string* release_devicejid(); - void set_allocated_devicejid(std::string* devicejid); - private: - const std::string& _internal_devicejid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_devicejid(const std::string& value); - std::string* _internal_mutable_devicejid(); - public: - - // optional .proto.MessageKey key = 3; - bool has_key() const; - private: - bool _internal_has_key() const; - public: - void clear_key(); - const ::proto::MessageKey& key() const; - PROTOBUF_NODISCARD ::proto::MessageKey* release_key(); - ::proto::MessageKey* mutable_key(); - void set_allocated_key(::proto::MessageKey* key); - private: - const ::proto::MessageKey& _internal_key() const; - ::proto::MessageKey* _internal_mutable_key(); - public: - void unsafe_arena_set_allocated_key( - ::proto::MessageKey* key); - ::proto::MessageKey* unsafe_arena_release_key(); - - // optional int64 serverTimestamp = 2; - bool has_servertimestamp() const; - private: - bool _internal_has_servertimestamp() const; - public: - void clear_servertimestamp(); - int64_t servertimestamp() const; - void set_servertimestamp(int64_t value); - private: - int64_t _internal_servertimestamp() const; - void _internal_set_servertimestamp(int64_t value); - public: - - // optional .proto.KeepType keepType = 1; - bool has_keeptype() const; - private: - bool _internal_has_keeptype() const; - public: - void clear_keeptype(); - ::proto::KeepType keeptype() const; - void set_keeptype(::proto::KeepType value); - private: - ::proto::KeepType _internal_keeptype() const; - void _internal_set_keeptype(::proto::KeepType value); - public: - - // @@protoc_insertion_point(class_scope:proto.KeepInChat) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr devicejid_; - ::proto::MessageKey* key_; - int64_t servertimestamp_; - int keeptype_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class KeyId final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.KeyId) */ { - public: - inline KeyId() : KeyId(nullptr) {} - ~KeyId() override; - explicit PROTOBUF_CONSTEXPR KeyId(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - KeyId(const KeyId& from); - KeyId(KeyId&& from) noexcept - : KeyId() { - *this = ::std::move(from); - } - - inline KeyId& operator=(const KeyId& from) { - CopyFrom(from); - return *this; - } - inline KeyId& operator=(KeyId&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const KeyId& default_instance() { - return *internal_default_instance(); - } - static inline const KeyId* internal_default_instance() { - return reinterpret_cast( - &_KeyId_default_instance_); - } - static constexpr int kIndexInFileMessages = - 48; - - friend void swap(KeyId& a, KeyId& b) { - a.Swap(&b); - } - inline void Swap(KeyId* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(KeyId* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - KeyId* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const KeyId& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const KeyId& from) { - KeyId::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(KeyId* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.KeyId"; - } - protected: - explicit KeyId(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kIdFieldNumber = 1, - }; - // optional bytes id = 1; - bool has_id() const; - private: - bool _internal_has_id() const; - public: - void clear_id(); - const std::string& id() const; - template - void set_id(ArgT0&& arg0, ArgT... args); - std::string* mutable_id(); - PROTOBUF_NODISCARD std::string* release_id(); - void set_allocated_id(std::string* id); - private: - const std::string& _internal_id() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value); - std::string* _internal_mutable_id(); - public: - - // @@protoc_insertion_point(class_scope:proto.KeyId) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class LocalizedName final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.LocalizedName) */ { - public: - inline LocalizedName() : LocalizedName(nullptr) {} - ~LocalizedName() override; - explicit PROTOBUF_CONSTEXPR LocalizedName(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - LocalizedName(const LocalizedName& from); - LocalizedName(LocalizedName&& from) noexcept - : LocalizedName() { - *this = ::std::move(from); - } - - inline LocalizedName& operator=(const LocalizedName& from) { - CopyFrom(from); - return *this; - } - inline LocalizedName& operator=(LocalizedName&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const LocalizedName& default_instance() { - return *internal_default_instance(); - } - static inline const LocalizedName* internal_default_instance() { - return reinterpret_cast( - &_LocalizedName_default_instance_); - } - static constexpr int kIndexInFileMessages = - 49; - - friend void swap(LocalizedName& a, LocalizedName& b) { - a.Swap(&b); - } - inline void Swap(LocalizedName* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(LocalizedName* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - LocalizedName* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const LocalizedName& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const LocalizedName& from) { - LocalizedName::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(LocalizedName* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.LocalizedName"; - } - protected: - explicit LocalizedName(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kLgFieldNumber = 1, - kLcFieldNumber = 2, - kVerifiedNameFieldNumber = 3, - }; - // optional string lg = 1; - bool has_lg() const; - private: - bool _internal_has_lg() const; - public: - void clear_lg(); - const std::string& lg() const; - template - void set_lg(ArgT0&& arg0, ArgT... args); - std::string* mutable_lg(); - PROTOBUF_NODISCARD std::string* release_lg(); - void set_allocated_lg(std::string* lg); - private: - const std::string& _internal_lg() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_lg(const std::string& value); - std::string* _internal_mutable_lg(); - public: - - // optional string lc = 2; - bool has_lc() const; - private: - bool _internal_has_lc() const; - public: - void clear_lc(); - const std::string& lc() const; - template - void set_lc(ArgT0&& arg0, ArgT... args); - std::string* mutable_lc(); - PROTOBUF_NODISCARD std::string* release_lc(); - void set_allocated_lc(std::string* lc); - private: - const std::string& _internal_lc() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_lc(const std::string& value); - std::string* _internal_mutable_lc(); - public: - - // optional string verifiedName = 3; - bool has_verifiedname() const; - private: - bool _internal_has_verifiedname() const; - public: - void clear_verifiedname(); - const std::string& verifiedname() const; - template - void set_verifiedname(ArgT0&& arg0, ArgT... args); - std::string* mutable_verifiedname(); - PROTOBUF_NODISCARD std::string* release_verifiedname(); - void set_allocated_verifiedname(std::string* verifiedname); - private: - const std::string& _internal_verifiedname() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_verifiedname(const std::string& value); - std::string* _internal_mutable_verifiedname(); - public: - - // @@protoc_insertion_point(class_scope:proto.LocalizedName) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr lg_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr lc_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr verifiedname_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Location final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Location) */ { - public: - inline Location() : Location(nullptr) {} - ~Location() override; - explicit PROTOBUF_CONSTEXPR Location(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Location(const Location& from); - Location(Location&& from) noexcept - : Location() { - *this = ::std::move(from); - } - - inline Location& operator=(const Location& from) { - CopyFrom(from); - return *this; - } - inline Location& operator=(Location&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Location& default_instance() { - return *internal_default_instance(); - } - static inline const Location* internal_default_instance() { - return reinterpret_cast( - &_Location_default_instance_); - } - static constexpr int kIndexInFileMessages = - 50; - - friend void swap(Location& a, Location& b) { - a.Swap(&b); - } - inline void Swap(Location* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Location* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Location* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Location& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Location& from) { - Location::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Location* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Location"; - } - protected: - explicit Location(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kNameFieldNumber = 3, - kDegreesLatitudeFieldNumber = 1, - kDegreesLongitudeFieldNumber = 2, - }; - // optional string name = 3; - bool has_name() const; - private: - bool _internal_has_name() const; - public: - void clear_name(); - const std::string& name() const; - template - void set_name(ArgT0&& arg0, ArgT... args); - std::string* mutable_name(); - PROTOBUF_NODISCARD std::string* release_name(); - void set_allocated_name(std::string* name); - private: - const std::string& _internal_name() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); - std::string* _internal_mutable_name(); - public: - - // optional double degreesLatitude = 1; - bool has_degreeslatitude() const; - private: - bool _internal_has_degreeslatitude() const; - public: - void clear_degreeslatitude(); - double degreeslatitude() const; - void set_degreeslatitude(double value); - private: - double _internal_degreeslatitude() const; - void _internal_set_degreeslatitude(double value); - public: - - // optional double degreesLongitude = 2; - bool has_degreeslongitude() const; - private: - bool _internal_has_degreeslongitude() const; - public: - void clear_degreeslongitude(); - double degreeslongitude() const; - void set_degreeslongitude(double value); - private: - double _internal_degreeslongitude() const; - void _internal_set_degreeslongitude(double value); - public: - - // @@protoc_insertion_point(class_scope:proto.Location) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - double degreeslatitude_; - double degreeslongitude_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class MediaData final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.MediaData) */ { - public: - inline MediaData() : MediaData(nullptr) {} - ~MediaData() override; - explicit PROTOBUF_CONSTEXPR MediaData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - MediaData(const MediaData& from); - MediaData(MediaData&& from) noexcept - : MediaData() { - *this = ::std::move(from); - } - - inline MediaData& operator=(const MediaData& from) { - CopyFrom(from); - return *this; - } - inline MediaData& operator=(MediaData&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const MediaData& default_instance() { - return *internal_default_instance(); - } - static inline const MediaData* internal_default_instance() { - return reinterpret_cast( - &_MediaData_default_instance_); - } - static constexpr int kIndexInFileMessages = - 51; - - friend void swap(MediaData& a, MediaData& b) { - a.Swap(&b); - } - inline void Swap(MediaData* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(MediaData* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - MediaData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const MediaData& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const MediaData& from) { - MediaData::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(MediaData* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.MediaData"; - } - protected: - explicit MediaData(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kLocalPathFieldNumber = 1, - }; - // optional string localPath = 1; - bool has_localpath() const; - private: - bool _internal_has_localpath() const; - public: - void clear_localpath(); - const std::string& localpath() const; - template - void set_localpath(ArgT0&& arg0, ArgT... args); - std::string* mutable_localpath(); - PROTOBUF_NODISCARD std::string* release_localpath(); - void set_allocated_localpath(std::string* localpath); - private: - const std::string& _internal_localpath() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_localpath(const std::string& value); - std::string* _internal_mutable_localpath(); - public: - - // @@protoc_insertion_point(class_scope:proto.MediaData) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localpath_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class MediaRetryNotification final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.MediaRetryNotification) */ { - public: - inline MediaRetryNotification() : MediaRetryNotification(nullptr) {} - ~MediaRetryNotification() override; - explicit PROTOBUF_CONSTEXPR MediaRetryNotification(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - MediaRetryNotification(const MediaRetryNotification& from); - MediaRetryNotification(MediaRetryNotification&& from) noexcept - : MediaRetryNotification() { - *this = ::std::move(from); - } - - inline MediaRetryNotification& operator=(const MediaRetryNotification& from) { - CopyFrom(from); - return *this; - } - inline MediaRetryNotification& operator=(MediaRetryNotification&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const MediaRetryNotification& default_instance() { - return *internal_default_instance(); - } - static inline const MediaRetryNotification* internal_default_instance() { - return reinterpret_cast( - &_MediaRetryNotification_default_instance_); - } - static constexpr int kIndexInFileMessages = - 52; - - friend void swap(MediaRetryNotification& a, MediaRetryNotification& b) { - a.Swap(&b); - } - inline void Swap(MediaRetryNotification* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(MediaRetryNotification* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - MediaRetryNotification* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const MediaRetryNotification& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const MediaRetryNotification& from) { - MediaRetryNotification::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(MediaRetryNotification* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.MediaRetryNotification"; - } - protected: - explicit MediaRetryNotification(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef MediaRetryNotification_ResultType ResultType; - static constexpr ResultType GENERAL_ERROR = - MediaRetryNotification_ResultType_GENERAL_ERROR; - static constexpr ResultType SUCCESS = - MediaRetryNotification_ResultType_SUCCESS; - static constexpr ResultType NOT_FOUND = - MediaRetryNotification_ResultType_NOT_FOUND; - static constexpr ResultType DECRYPTION_ERROR = - MediaRetryNotification_ResultType_DECRYPTION_ERROR; - static inline bool ResultType_IsValid(int value) { - return MediaRetryNotification_ResultType_IsValid(value); - } - static constexpr ResultType ResultType_MIN = - MediaRetryNotification_ResultType_ResultType_MIN; - static constexpr ResultType ResultType_MAX = - MediaRetryNotification_ResultType_ResultType_MAX; - static constexpr int ResultType_ARRAYSIZE = - MediaRetryNotification_ResultType_ResultType_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - ResultType_descriptor() { - return MediaRetryNotification_ResultType_descriptor(); - } - template - static inline const std::string& ResultType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function ResultType_Name."); - return MediaRetryNotification_ResultType_Name(enum_t_value); - } - static inline bool ResultType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - ResultType* value) { - return MediaRetryNotification_ResultType_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kStanzaIdFieldNumber = 1, - kDirectPathFieldNumber = 2, - kResultFieldNumber = 3, - }; - // optional string stanzaId = 1; - bool has_stanzaid() const; - private: - bool _internal_has_stanzaid() const; - public: - void clear_stanzaid(); - const std::string& stanzaid() const; - template - void set_stanzaid(ArgT0&& arg0, ArgT... args); - std::string* mutable_stanzaid(); - PROTOBUF_NODISCARD std::string* release_stanzaid(); - void set_allocated_stanzaid(std::string* stanzaid); - private: - const std::string& _internal_stanzaid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_stanzaid(const std::string& value); - std::string* _internal_mutable_stanzaid(); - public: - - // optional string directPath = 2; - bool has_directpath() const; - private: - bool _internal_has_directpath() const; - public: - void clear_directpath(); - const std::string& directpath() const; - template - void set_directpath(ArgT0&& arg0, ArgT... args); - std::string* mutable_directpath(); - PROTOBUF_NODISCARD std::string* release_directpath(); - void set_allocated_directpath(std::string* directpath); - private: - const std::string& _internal_directpath() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value); - std::string* _internal_mutable_directpath(); - public: - - // optional .proto.MediaRetryNotification.ResultType result = 3; - bool has_result() const; - private: - bool _internal_has_result() const; - public: - void clear_result(); - ::proto::MediaRetryNotification_ResultType result() const; - void set_result(::proto::MediaRetryNotification_ResultType value); - private: - ::proto::MediaRetryNotification_ResultType _internal_result() const; - void _internal_set_result(::proto::MediaRetryNotification_ResultType value); - public: - - // @@protoc_insertion_point(class_scope:proto.MediaRetryNotification) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr stanzaid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_; - int result_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_AppStateFatalExceptionNotification final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AppStateFatalExceptionNotification) */ { - public: - inline Message_AppStateFatalExceptionNotification() : Message_AppStateFatalExceptionNotification(nullptr) {} - ~Message_AppStateFatalExceptionNotification() override; - explicit PROTOBUF_CONSTEXPR Message_AppStateFatalExceptionNotification(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_AppStateFatalExceptionNotification(const Message_AppStateFatalExceptionNotification& from); - Message_AppStateFatalExceptionNotification(Message_AppStateFatalExceptionNotification&& from) noexcept - : Message_AppStateFatalExceptionNotification() { - *this = ::std::move(from); - } - - inline Message_AppStateFatalExceptionNotification& operator=(const Message_AppStateFatalExceptionNotification& from) { - CopyFrom(from); - return *this; - } - inline Message_AppStateFatalExceptionNotification& operator=(Message_AppStateFatalExceptionNotification&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_AppStateFatalExceptionNotification& default_instance() { - return *internal_default_instance(); - } - static inline const Message_AppStateFatalExceptionNotification* internal_default_instance() { - return reinterpret_cast( - &_Message_AppStateFatalExceptionNotification_default_instance_); - } - static constexpr int kIndexInFileMessages = - 53; - - friend void swap(Message_AppStateFatalExceptionNotification& a, Message_AppStateFatalExceptionNotification& b) { - a.Swap(&b); - } - inline void Swap(Message_AppStateFatalExceptionNotification* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_AppStateFatalExceptionNotification* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_AppStateFatalExceptionNotification* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_AppStateFatalExceptionNotification& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_AppStateFatalExceptionNotification& from) { - Message_AppStateFatalExceptionNotification::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_AppStateFatalExceptionNotification* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.AppStateFatalExceptionNotification"; - } - protected: - explicit Message_AppStateFatalExceptionNotification(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kCollectionNamesFieldNumber = 1, - kTimestampFieldNumber = 2, - }; - // repeated string collectionNames = 1; - int collectionnames_size() const; - private: - int _internal_collectionnames_size() const; - public: - void clear_collectionnames(); - const std::string& collectionnames(int index) const; - std::string* mutable_collectionnames(int index); - void set_collectionnames(int index, const std::string& value); - void set_collectionnames(int index, std::string&& value); - void set_collectionnames(int index, const char* value); - void set_collectionnames(int index, const char* value, size_t size); - std::string* add_collectionnames(); - void add_collectionnames(const std::string& value); - void add_collectionnames(std::string&& value); - void add_collectionnames(const char* value); - void add_collectionnames(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& collectionnames() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_collectionnames(); - private: - const std::string& _internal_collectionnames(int index) const; - std::string* _internal_add_collectionnames(); - public: - - // optional int64 timestamp = 2; - bool has_timestamp() const; - private: - bool _internal_has_timestamp() const; - public: - void clear_timestamp(); - int64_t timestamp() const; - void set_timestamp(int64_t value); - private: - int64_t _internal_timestamp() const; - void _internal_set_timestamp(int64_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.AppStateFatalExceptionNotification) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField collectionnames_; - int64_t timestamp_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_AppStateSyncKeyData final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AppStateSyncKeyData) */ { - public: - inline Message_AppStateSyncKeyData() : Message_AppStateSyncKeyData(nullptr) {} - ~Message_AppStateSyncKeyData() override; - explicit PROTOBUF_CONSTEXPR Message_AppStateSyncKeyData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_AppStateSyncKeyData(const Message_AppStateSyncKeyData& from); - Message_AppStateSyncKeyData(Message_AppStateSyncKeyData&& from) noexcept - : Message_AppStateSyncKeyData() { - *this = ::std::move(from); - } - - inline Message_AppStateSyncKeyData& operator=(const Message_AppStateSyncKeyData& from) { - CopyFrom(from); - return *this; - } - inline Message_AppStateSyncKeyData& operator=(Message_AppStateSyncKeyData&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_AppStateSyncKeyData& default_instance() { - return *internal_default_instance(); - } - static inline const Message_AppStateSyncKeyData* internal_default_instance() { - return reinterpret_cast( - &_Message_AppStateSyncKeyData_default_instance_); - } - static constexpr int kIndexInFileMessages = - 54; - - friend void swap(Message_AppStateSyncKeyData& a, Message_AppStateSyncKeyData& b) { - a.Swap(&b); - } - inline void Swap(Message_AppStateSyncKeyData* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_AppStateSyncKeyData* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_AppStateSyncKeyData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_AppStateSyncKeyData& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_AppStateSyncKeyData& from) { - Message_AppStateSyncKeyData::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_AppStateSyncKeyData* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.AppStateSyncKeyData"; - } - protected: - explicit Message_AppStateSyncKeyData(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kKeyDataFieldNumber = 1, - kFingerprintFieldNumber = 2, - kTimestampFieldNumber = 3, - }; - // optional bytes keyData = 1; - bool has_keydata() const; - private: - bool _internal_has_keydata() const; - public: - void clear_keydata(); - const std::string& keydata() const; - template - void set_keydata(ArgT0&& arg0, ArgT... args); - std::string* mutable_keydata(); - PROTOBUF_NODISCARD std::string* release_keydata(); - void set_allocated_keydata(std::string* keydata); - private: - const std::string& _internal_keydata() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_keydata(const std::string& value); - std::string* _internal_mutable_keydata(); - public: - - // optional .proto.Message.AppStateSyncKeyFingerprint fingerprint = 2; - bool has_fingerprint() const; - private: - bool _internal_has_fingerprint() const; - public: - void clear_fingerprint(); - const ::proto::Message_AppStateSyncKeyFingerprint& fingerprint() const; - PROTOBUF_NODISCARD ::proto::Message_AppStateSyncKeyFingerprint* release_fingerprint(); - ::proto::Message_AppStateSyncKeyFingerprint* mutable_fingerprint(); - void set_allocated_fingerprint(::proto::Message_AppStateSyncKeyFingerprint* fingerprint); - private: - const ::proto::Message_AppStateSyncKeyFingerprint& _internal_fingerprint() const; - ::proto::Message_AppStateSyncKeyFingerprint* _internal_mutable_fingerprint(); - public: - void unsafe_arena_set_allocated_fingerprint( - ::proto::Message_AppStateSyncKeyFingerprint* fingerprint); - ::proto::Message_AppStateSyncKeyFingerprint* unsafe_arena_release_fingerprint(); - - // optional int64 timestamp = 3; - bool has_timestamp() const; - private: - bool _internal_has_timestamp() const; - public: - void clear_timestamp(); - int64_t timestamp() const; - void set_timestamp(int64_t value); - private: - int64_t _internal_timestamp() const; - void _internal_set_timestamp(int64_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.AppStateSyncKeyData) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr keydata_; - ::proto::Message_AppStateSyncKeyFingerprint* fingerprint_; - int64_t timestamp_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_AppStateSyncKeyFingerprint final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AppStateSyncKeyFingerprint) */ { - public: - inline Message_AppStateSyncKeyFingerprint() : Message_AppStateSyncKeyFingerprint(nullptr) {} - ~Message_AppStateSyncKeyFingerprint() override; - explicit PROTOBUF_CONSTEXPR Message_AppStateSyncKeyFingerprint(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_AppStateSyncKeyFingerprint(const Message_AppStateSyncKeyFingerprint& from); - Message_AppStateSyncKeyFingerprint(Message_AppStateSyncKeyFingerprint&& from) noexcept - : Message_AppStateSyncKeyFingerprint() { - *this = ::std::move(from); - } - - inline Message_AppStateSyncKeyFingerprint& operator=(const Message_AppStateSyncKeyFingerprint& from) { - CopyFrom(from); - return *this; - } - inline Message_AppStateSyncKeyFingerprint& operator=(Message_AppStateSyncKeyFingerprint&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_AppStateSyncKeyFingerprint& default_instance() { - return *internal_default_instance(); - } - static inline const Message_AppStateSyncKeyFingerprint* internal_default_instance() { - return reinterpret_cast( - &_Message_AppStateSyncKeyFingerprint_default_instance_); - } - static constexpr int kIndexInFileMessages = - 55; - - friend void swap(Message_AppStateSyncKeyFingerprint& a, Message_AppStateSyncKeyFingerprint& b) { - a.Swap(&b); - } - inline void Swap(Message_AppStateSyncKeyFingerprint* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_AppStateSyncKeyFingerprint* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_AppStateSyncKeyFingerprint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_AppStateSyncKeyFingerprint& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_AppStateSyncKeyFingerprint& from) { - Message_AppStateSyncKeyFingerprint::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_AppStateSyncKeyFingerprint* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.AppStateSyncKeyFingerprint"; - } - protected: - explicit Message_AppStateSyncKeyFingerprint(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kDeviceIndexesFieldNumber = 3, - kRawIdFieldNumber = 1, - kCurrentIndexFieldNumber = 2, - }; - // repeated uint32 deviceIndexes = 3 [packed = true]; - int deviceindexes_size() const; - private: - int _internal_deviceindexes_size() const; - public: - void clear_deviceindexes(); - private: - uint32_t _internal_deviceindexes(int index) const; - const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& - _internal_deviceindexes() const; - void _internal_add_deviceindexes(uint32_t value); - ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* - _internal_mutable_deviceindexes(); - public: - uint32_t deviceindexes(int index) const; - void set_deviceindexes(int index, uint32_t value); - void add_deviceindexes(uint32_t value); - const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& - deviceindexes() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* - mutable_deviceindexes(); - - // optional uint32 rawId = 1; - bool has_rawid() const; - private: - bool _internal_has_rawid() const; - public: - void clear_rawid(); - uint32_t rawid() const; - void set_rawid(uint32_t value); - private: - uint32_t _internal_rawid() const; - void _internal_set_rawid(uint32_t value); - public: - - // optional uint32 currentIndex = 2; - bool has_currentindex() const; - private: - bool _internal_has_currentindex() const; - public: - void clear_currentindex(); - uint32_t currentindex() const; - void set_currentindex(uint32_t value); - private: - uint32_t _internal_currentindex() const; - void _internal_set_currentindex(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.AppStateSyncKeyFingerprint) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > deviceindexes_; - mutable std::atomic _deviceindexes_cached_byte_size_; - uint32_t rawid_; - uint32_t currentindex_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_AppStateSyncKeyId final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AppStateSyncKeyId) */ { - public: - inline Message_AppStateSyncKeyId() : Message_AppStateSyncKeyId(nullptr) {} - ~Message_AppStateSyncKeyId() override; - explicit PROTOBUF_CONSTEXPR Message_AppStateSyncKeyId(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_AppStateSyncKeyId(const Message_AppStateSyncKeyId& from); - Message_AppStateSyncKeyId(Message_AppStateSyncKeyId&& from) noexcept - : Message_AppStateSyncKeyId() { - *this = ::std::move(from); - } - - inline Message_AppStateSyncKeyId& operator=(const Message_AppStateSyncKeyId& from) { - CopyFrom(from); - return *this; - } - inline Message_AppStateSyncKeyId& operator=(Message_AppStateSyncKeyId&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_AppStateSyncKeyId& default_instance() { - return *internal_default_instance(); - } - static inline const Message_AppStateSyncKeyId* internal_default_instance() { - return reinterpret_cast( - &_Message_AppStateSyncKeyId_default_instance_); - } - static constexpr int kIndexInFileMessages = - 56; - - friend void swap(Message_AppStateSyncKeyId& a, Message_AppStateSyncKeyId& b) { - a.Swap(&b); - } - inline void Swap(Message_AppStateSyncKeyId* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_AppStateSyncKeyId* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_AppStateSyncKeyId* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_AppStateSyncKeyId& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_AppStateSyncKeyId& from) { - Message_AppStateSyncKeyId::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_AppStateSyncKeyId* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.AppStateSyncKeyId"; - } - protected: - explicit Message_AppStateSyncKeyId(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kKeyIdFieldNumber = 1, - }; - // optional bytes keyId = 1; - bool has_keyid() const; - private: - bool _internal_has_keyid() const; - public: - void clear_keyid(); - const std::string& keyid() const; - template - void set_keyid(ArgT0&& arg0, ArgT... args); - std::string* mutable_keyid(); - PROTOBUF_NODISCARD std::string* release_keyid(); - void set_allocated_keyid(std::string* keyid); - private: - const std::string& _internal_keyid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_keyid(const std::string& value); - std::string* _internal_mutable_keyid(); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.AppStateSyncKeyId) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr keyid_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_AppStateSyncKeyRequest final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AppStateSyncKeyRequest) */ { - public: - inline Message_AppStateSyncKeyRequest() : Message_AppStateSyncKeyRequest(nullptr) {} - ~Message_AppStateSyncKeyRequest() override; - explicit PROTOBUF_CONSTEXPR Message_AppStateSyncKeyRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_AppStateSyncKeyRequest(const Message_AppStateSyncKeyRequest& from); - Message_AppStateSyncKeyRequest(Message_AppStateSyncKeyRequest&& from) noexcept - : Message_AppStateSyncKeyRequest() { - *this = ::std::move(from); - } - - inline Message_AppStateSyncKeyRequest& operator=(const Message_AppStateSyncKeyRequest& from) { - CopyFrom(from); - return *this; - } - inline Message_AppStateSyncKeyRequest& operator=(Message_AppStateSyncKeyRequest&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_AppStateSyncKeyRequest& default_instance() { - return *internal_default_instance(); - } - static inline const Message_AppStateSyncKeyRequest* internal_default_instance() { - return reinterpret_cast( - &_Message_AppStateSyncKeyRequest_default_instance_); - } - static constexpr int kIndexInFileMessages = - 57; - - friend void swap(Message_AppStateSyncKeyRequest& a, Message_AppStateSyncKeyRequest& b) { - a.Swap(&b); - } - inline void Swap(Message_AppStateSyncKeyRequest* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_AppStateSyncKeyRequest* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_AppStateSyncKeyRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_AppStateSyncKeyRequest& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_AppStateSyncKeyRequest& from) { - Message_AppStateSyncKeyRequest::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_AppStateSyncKeyRequest* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.AppStateSyncKeyRequest"; - } - protected: - explicit Message_AppStateSyncKeyRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kKeyIdsFieldNumber = 1, - }; - // repeated .proto.Message.AppStateSyncKeyId keyIds = 1; - int keyids_size() const; - private: - int _internal_keyids_size() const; - public: - void clear_keyids(); - ::proto::Message_AppStateSyncKeyId* mutable_keyids(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKeyId >* - mutable_keyids(); - private: - const ::proto::Message_AppStateSyncKeyId& _internal_keyids(int index) const; - ::proto::Message_AppStateSyncKeyId* _internal_add_keyids(); - public: - const ::proto::Message_AppStateSyncKeyId& keyids(int index) const; - ::proto::Message_AppStateSyncKeyId* add_keyids(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKeyId >& - keyids() const; - - // @@protoc_insertion_point(class_scope:proto.Message.AppStateSyncKeyRequest) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKeyId > keyids_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_AppStateSyncKeyShare final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AppStateSyncKeyShare) */ { - public: - inline Message_AppStateSyncKeyShare() : Message_AppStateSyncKeyShare(nullptr) {} - ~Message_AppStateSyncKeyShare() override; - explicit PROTOBUF_CONSTEXPR Message_AppStateSyncKeyShare(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_AppStateSyncKeyShare(const Message_AppStateSyncKeyShare& from); - Message_AppStateSyncKeyShare(Message_AppStateSyncKeyShare&& from) noexcept - : Message_AppStateSyncKeyShare() { - *this = ::std::move(from); - } - - inline Message_AppStateSyncKeyShare& operator=(const Message_AppStateSyncKeyShare& from) { - CopyFrom(from); - return *this; - } - inline Message_AppStateSyncKeyShare& operator=(Message_AppStateSyncKeyShare&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_AppStateSyncKeyShare& default_instance() { - return *internal_default_instance(); - } - static inline const Message_AppStateSyncKeyShare* internal_default_instance() { - return reinterpret_cast( - &_Message_AppStateSyncKeyShare_default_instance_); - } - static constexpr int kIndexInFileMessages = - 58; - - friend void swap(Message_AppStateSyncKeyShare& a, Message_AppStateSyncKeyShare& b) { - a.Swap(&b); - } - inline void Swap(Message_AppStateSyncKeyShare* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_AppStateSyncKeyShare* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_AppStateSyncKeyShare* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_AppStateSyncKeyShare& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_AppStateSyncKeyShare& from) { - Message_AppStateSyncKeyShare::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_AppStateSyncKeyShare* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.AppStateSyncKeyShare"; - } - protected: - explicit Message_AppStateSyncKeyShare(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kKeysFieldNumber = 1, - }; - // repeated .proto.Message.AppStateSyncKey keys = 1; - int keys_size() const; - private: - int _internal_keys_size() const; - public: - void clear_keys(); - ::proto::Message_AppStateSyncKey* mutable_keys(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKey >* - mutable_keys(); - private: - const ::proto::Message_AppStateSyncKey& _internal_keys(int index) const; - ::proto::Message_AppStateSyncKey* _internal_add_keys(); - public: - const ::proto::Message_AppStateSyncKey& keys(int index) const; - ::proto::Message_AppStateSyncKey* add_keys(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKey >& - keys() const; - - // @@protoc_insertion_point(class_scope:proto.Message.AppStateSyncKeyShare) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKey > keys_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_AppStateSyncKey final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AppStateSyncKey) */ { - public: - inline Message_AppStateSyncKey() : Message_AppStateSyncKey(nullptr) {} - ~Message_AppStateSyncKey() override; - explicit PROTOBUF_CONSTEXPR Message_AppStateSyncKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_AppStateSyncKey(const Message_AppStateSyncKey& from); - Message_AppStateSyncKey(Message_AppStateSyncKey&& from) noexcept - : Message_AppStateSyncKey() { - *this = ::std::move(from); - } - - inline Message_AppStateSyncKey& operator=(const Message_AppStateSyncKey& from) { - CopyFrom(from); - return *this; - } - inline Message_AppStateSyncKey& operator=(Message_AppStateSyncKey&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_AppStateSyncKey& default_instance() { - return *internal_default_instance(); - } - static inline const Message_AppStateSyncKey* internal_default_instance() { - return reinterpret_cast( - &_Message_AppStateSyncKey_default_instance_); - } - static constexpr int kIndexInFileMessages = - 59; - - friend void swap(Message_AppStateSyncKey& a, Message_AppStateSyncKey& b) { - a.Swap(&b); - } - inline void Swap(Message_AppStateSyncKey* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_AppStateSyncKey* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_AppStateSyncKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_AppStateSyncKey& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_AppStateSyncKey& from) { - Message_AppStateSyncKey::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_AppStateSyncKey* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.AppStateSyncKey"; - } - protected: - explicit Message_AppStateSyncKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kKeyIdFieldNumber = 1, - kKeyDataFieldNumber = 2, - }; - // optional .proto.Message.AppStateSyncKeyId keyId = 1; - bool has_keyid() const; - private: - bool _internal_has_keyid() const; - public: - void clear_keyid(); - const ::proto::Message_AppStateSyncKeyId& keyid() const; - PROTOBUF_NODISCARD ::proto::Message_AppStateSyncKeyId* release_keyid(); - ::proto::Message_AppStateSyncKeyId* mutable_keyid(); - void set_allocated_keyid(::proto::Message_AppStateSyncKeyId* keyid); - private: - const ::proto::Message_AppStateSyncKeyId& _internal_keyid() const; - ::proto::Message_AppStateSyncKeyId* _internal_mutable_keyid(); - public: - void unsafe_arena_set_allocated_keyid( - ::proto::Message_AppStateSyncKeyId* keyid); - ::proto::Message_AppStateSyncKeyId* unsafe_arena_release_keyid(); - - // optional .proto.Message.AppStateSyncKeyData keyData = 2; - bool has_keydata() const; - private: - bool _internal_has_keydata() const; - public: - void clear_keydata(); - const ::proto::Message_AppStateSyncKeyData& keydata() const; - PROTOBUF_NODISCARD ::proto::Message_AppStateSyncKeyData* release_keydata(); - ::proto::Message_AppStateSyncKeyData* mutable_keydata(); - void set_allocated_keydata(::proto::Message_AppStateSyncKeyData* keydata); - private: - const ::proto::Message_AppStateSyncKeyData& _internal_keydata() const; - ::proto::Message_AppStateSyncKeyData* _internal_mutable_keydata(); - public: - void unsafe_arena_set_allocated_keydata( - ::proto::Message_AppStateSyncKeyData* keydata); - ::proto::Message_AppStateSyncKeyData* unsafe_arena_release_keydata(); - - // @@protoc_insertion_point(class_scope:proto.Message.AppStateSyncKey) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::proto::Message_AppStateSyncKeyId* keyid_; - ::proto::Message_AppStateSyncKeyData* keydata_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_AudioMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AudioMessage) */ { - public: - inline Message_AudioMessage() : Message_AudioMessage(nullptr) {} - ~Message_AudioMessage() override; - explicit PROTOBUF_CONSTEXPR Message_AudioMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_AudioMessage(const Message_AudioMessage& from); - Message_AudioMessage(Message_AudioMessage&& from) noexcept - : Message_AudioMessage() { - *this = ::std::move(from); - } - - inline Message_AudioMessage& operator=(const Message_AudioMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_AudioMessage& operator=(Message_AudioMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_AudioMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_AudioMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_AudioMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 60; - - friend void swap(Message_AudioMessage& a, Message_AudioMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_AudioMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_AudioMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_AudioMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_AudioMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_AudioMessage& from) { - Message_AudioMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_AudioMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.AudioMessage"; - } - protected: - explicit Message_AudioMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kUrlFieldNumber = 1, - kMimetypeFieldNumber = 2, - kFileSha256FieldNumber = 3, - kMediaKeyFieldNumber = 7, - kFileEncSha256FieldNumber = 8, - kDirectPathFieldNumber = 9, - kStreamingSidecarFieldNumber = 18, - kWaveformFieldNumber = 19, - kContextInfoFieldNumber = 17, - kFileLengthFieldNumber = 4, - kSecondsFieldNumber = 5, - kPttFieldNumber = 6, - kMediaKeyTimestampFieldNumber = 10, - }; - // optional string url = 1; - bool has_url() const; - private: - bool _internal_has_url() const; - public: - void clear_url(); - const std::string& url() const; - template - void set_url(ArgT0&& arg0, ArgT... args); - std::string* mutable_url(); - PROTOBUF_NODISCARD std::string* release_url(); - void set_allocated_url(std::string* url); - private: - const std::string& _internal_url() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value); - std::string* _internal_mutable_url(); - public: - - // optional string mimetype = 2; - bool has_mimetype() const; - private: - bool _internal_has_mimetype() const; - public: - void clear_mimetype(); - const std::string& mimetype() const; - template - void set_mimetype(ArgT0&& arg0, ArgT... args); - std::string* mutable_mimetype(); - PROTOBUF_NODISCARD std::string* release_mimetype(); - void set_allocated_mimetype(std::string* mimetype); - private: - const std::string& _internal_mimetype() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value); - std::string* _internal_mutable_mimetype(); - public: - - // optional bytes fileSha256 = 3; - bool has_filesha256() const; - private: - bool _internal_has_filesha256() const; - public: - void clear_filesha256(); - const std::string& filesha256() const; - template - void set_filesha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_filesha256(); - PROTOBUF_NODISCARD std::string* release_filesha256(); - void set_allocated_filesha256(std::string* filesha256); - private: - const std::string& _internal_filesha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value); - std::string* _internal_mutable_filesha256(); - public: - - // optional bytes mediaKey = 7; - bool has_mediakey() const; - private: - bool _internal_has_mediakey() const; - public: - void clear_mediakey(); - const std::string& mediakey() const; - template - void set_mediakey(ArgT0&& arg0, ArgT... args); - std::string* mutable_mediakey(); - PROTOBUF_NODISCARD std::string* release_mediakey(); - void set_allocated_mediakey(std::string* mediakey); - private: - const std::string& _internal_mediakey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value); - std::string* _internal_mutable_mediakey(); - public: - - // optional bytes fileEncSha256 = 8; - bool has_fileencsha256() const; - private: - bool _internal_has_fileencsha256() const; - public: - void clear_fileencsha256(); - const std::string& fileencsha256() const; - template - void set_fileencsha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_fileencsha256(); - PROTOBUF_NODISCARD std::string* release_fileencsha256(); - void set_allocated_fileencsha256(std::string* fileencsha256); - private: - const std::string& _internal_fileencsha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value); - std::string* _internal_mutable_fileencsha256(); - public: - - // optional string directPath = 9; - bool has_directpath() const; - private: - bool _internal_has_directpath() const; - public: - void clear_directpath(); - const std::string& directpath() const; - template - void set_directpath(ArgT0&& arg0, ArgT... args); - std::string* mutable_directpath(); - PROTOBUF_NODISCARD std::string* release_directpath(); - void set_allocated_directpath(std::string* directpath); - private: - const std::string& _internal_directpath() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value); - std::string* _internal_mutable_directpath(); - public: - - // optional bytes streamingSidecar = 18; - bool has_streamingsidecar() const; - private: - bool _internal_has_streamingsidecar() const; - public: - void clear_streamingsidecar(); - const std::string& streamingsidecar() const; - template - void set_streamingsidecar(ArgT0&& arg0, ArgT... args); - std::string* mutable_streamingsidecar(); - PROTOBUF_NODISCARD std::string* release_streamingsidecar(); - void set_allocated_streamingsidecar(std::string* streamingsidecar); - private: - const std::string& _internal_streamingsidecar() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_streamingsidecar(const std::string& value); - std::string* _internal_mutable_streamingsidecar(); - public: - - // optional bytes waveform = 19; - bool has_waveform() const; - private: - bool _internal_has_waveform() const; - public: - void clear_waveform(); - const std::string& waveform() const; - template - void set_waveform(ArgT0&& arg0, ArgT... args); - std::string* mutable_waveform(); - PROTOBUF_NODISCARD std::string* release_waveform(); - void set_allocated_waveform(std::string* waveform); - private: - const std::string& _internal_waveform() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_waveform(const std::string& value); - std::string* _internal_mutable_waveform(); - public: - - // optional .proto.ContextInfo contextInfo = 17; - bool has_contextinfo() const; - private: - bool _internal_has_contextinfo() const; - public: - void clear_contextinfo(); - const ::proto::ContextInfo& contextinfo() const; - PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); - ::proto::ContextInfo* mutable_contextinfo(); - void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); - private: - const ::proto::ContextInfo& _internal_contextinfo() const; - ::proto::ContextInfo* _internal_mutable_contextinfo(); - public: - void unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo); - ::proto::ContextInfo* unsafe_arena_release_contextinfo(); - - // optional uint64 fileLength = 4; - bool has_filelength() const; - private: - bool _internal_has_filelength() const; - public: - void clear_filelength(); - uint64_t filelength() const; - void set_filelength(uint64_t value); - private: - uint64_t _internal_filelength() const; - void _internal_set_filelength(uint64_t value); - public: - - // optional uint32 seconds = 5; - bool has_seconds() const; - private: - bool _internal_has_seconds() const; - public: - void clear_seconds(); - uint32_t seconds() const; - void set_seconds(uint32_t value); - private: - uint32_t _internal_seconds() const; - void _internal_set_seconds(uint32_t value); - public: - - // optional bool ptt = 6; - bool has_ptt() const; - private: - bool _internal_has_ptt() const; - public: - void clear_ptt(); - bool ptt() const; - void set_ptt(bool value); - private: - bool _internal_ptt() const; - void _internal_set_ptt(bool value); - public: - - // optional int64 mediaKeyTimestamp = 10; - bool has_mediakeytimestamp() const; - private: - bool _internal_has_mediakeytimestamp() const; - public: - void clear_mediakeytimestamp(); - int64_t mediakeytimestamp() const; - void set_mediakeytimestamp(int64_t value); - private: - int64_t _internal_mediakeytimestamp() const; - void _internal_set_mediakeytimestamp(int64_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.AudioMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mimetype_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr streamingsidecar_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr waveform_; - ::proto::ContextInfo* contextinfo_; - uint64_t filelength_; - uint32_t seconds_; - bool ptt_; - int64_t mediakeytimestamp_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_ButtonsMessage_Button_ButtonText final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ButtonsMessage.Button.ButtonText) */ { - public: - inline Message_ButtonsMessage_Button_ButtonText() : Message_ButtonsMessage_Button_ButtonText(nullptr) {} - ~Message_ButtonsMessage_Button_ButtonText() override; - explicit PROTOBUF_CONSTEXPR Message_ButtonsMessage_Button_ButtonText(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_ButtonsMessage_Button_ButtonText(const Message_ButtonsMessage_Button_ButtonText& from); - Message_ButtonsMessage_Button_ButtonText(Message_ButtonsMessage_Button_ButtonText&& from) noexcept - : Message_ButtonsMessage_Button_ButtonText() { - *this = ::std::move(from); - } - - inline Message_ButtonsMessage_Button_ButtonText& operator=(const Message_ButtonsMessage_Button_ButtonText& from) { - CopyFrom(from); - return *this; - } - inline Message_ButtonsMessage_Button_ButtonText& operator=(Message_ButtonsMessage_Button_ButtonText&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_ButtonsMessage_Button_ButtonText& default_instance() { - return *internal_default_instance(); - } - static inline const Message_ButtonsMessage_Button_ButtonText* internal_default_instance() { - return reinterpret_cast( - &_Message_ButtonsMessage_Button_ButtonText_default_instance_); - } - static constexpr int kIndexInFileMessages = - 61; - - friend void swap(Message_ButtonsMessage_Button_ButtonText& a, Message_ButtonsMessage_Button_ButtonText& b) { - a.Swap(&b); - } - inline void Swap(Message_ButtonsMessage_Button_ButtonText* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_ButtonsMessage_Button_ButtonText* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_ButtonsMessage_Button_ButtonText* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_ButtonsMessage_Button_ButtonText& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_ButtonsMessage_Button_ButtonText& from) { - Message_ButtonsMessage_Button_ButtonText::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_ButtonsMessage_Button_ButtonText* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.ButtonsMessage.Button.ButtonText"; - } - protected: - explicit Message_ButtonsMessage_Button_ButtonText(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kDisplayTextFieldNumber = 1, - }; - // optional string displayText = 1; - bool has_displaytext() const; - private: - bool _internal_has_displaytext() const; - public: - void clear_displaytext(); - const std::string& displaytext() const; - template - void set_displaytext(ArgT0&& arg0, ArgT... args); - std::string* mutable_displaytext(); - PROTOBUF_NODISCARD std::string* release_displaytext(); - void set_allocated_displaytext(std::string* displaytext); - private: - const std::string& _internal_displaytext() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_displaytext(const std::string& value); - std::string* _internal_mutable_displaytext(); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.ButtonsMessage.Button.ButtonText) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr displaytext_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_ButtonsMessage_Button_NativeFlowInfo final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ButtonsMessage.Button.NativeFlowInfo) */ { - public: - inline Message_ButtonsMessage_Button_NativeFlowInfo() : Message_ButtonsMessage_Button_NativeFlowInfo(nullptr) {} - ~Message_ButtonsMessage_Button_NativeFlowInfo() override; - explicit PROTOBUF_CONSTEXPR Message_ButtonsMessage_Button_NativeFlowInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_ButtonsMessage_Button_NativeFlowInfo(const Message_ButtonsMessage_Button_NativeFlowInfo& from); - Message_ButtonsMessage_Button_NativeFlowInfo(Message_ButtonsMessage_Button_NativeFlowInfo&& from) noexcept - : Message_ButtonsMessage_Button_NativeFlowInfo() { - *this = ::std::move(from); - } - - inline Message_ButtonsMessage_Button_NativeFlowInfo& operator=(const Message_ButtonsMessage_Button_NativeFlowInfo& from) { - CopyFrom(from); - return *this; - } - inline Message_ButtonsMessage_Button_NativeFlowInfo& operator=(Message_ButtonsMessage_Button_NativeFlowInfo&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_ButtonsMessage_Button_NativeFlowInfo& default_instance() { - return *internal_default_instance(); - } - static inline const Message_ButtonsMessage_Button_NativeFlowInfo* internal_default_instance() { - return reinterpret_cast( - &_Message_ButtonsMessage_Button_NativeFlowInfo_default_instance_); - } - static constexpr int kIndexInFileMessages = - 62; - - friend void swap(Message_ButtonsMessage_Button_NativeFlowInfo& a, Message_ButtonsMessage_Button_NativeFlowInfo& b) { - a.Swap(&b); - } - inline void Swap(Message_ButtonsMessage_Button_NativeFlowInfo* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_ButtonsMessage_Button_NativeFlowInfo* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_ButtonsMessage_Button_NativeFlowInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_ButtonsMessage_Button_NativeFlowInfo& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_ButtonsMessage_Button_NativeFlowInfo& from) { - Message_ButtonsMessage_Button_NativeFlowInfo::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_ButtonsMessage_Button_NativeFlowInfo* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.ButtonsMessage.Button.NativeFlowInfo"; - } - protected: - explicit Message_ButtonsMessage_Button_NativeFlowInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kNameFieldNumber = 1, - kParamsJsonFieldNumber = 2, - }; - // optional string name = 1; - bool has_name() const; - private: - bool _internal_has_name() const; - public: - void clear_name(); - const std::string& name() const; - template - void set_name(ArgT0&& arg0, ArgT... args); - std::string* mutable_name(); - PROTOBUF_NODISCARD std::string* release_name(); - void set_allocated_name(std::string* name); - private: - const std::string& _internal_name() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); - std::string* _internal_mutable_name(); - public: - - // optional string paramsJson = 2; - bool has_paramsjson() const; - private: - bool _internal_has_paramsjson() const; - public: - void clear_paramsjson(); - const std::string& paramsjson() const; - template - void set_paramsjson(ArgT0&& arg0, ArgT... args); - std::string* mutable_paramsjson(); - PROTOBUF_NODISCARD std::string* release_paramsjson(); - void set_allocated_paramsjson(std::string* paramsjson); - private: - const std::string& _internal_paramsjson() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_paramsjson(const std::string& value); - std::string* _internal_mutable_paramsjson(); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.ButtonsMessage.Button.NativeFlowInfo) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr paramsjson_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_ButtonsMessage_Button final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ButtonsMessage.Button) */ { - public: - inline Message_ButtonsMessage_Button() : Message_ButtonsMessage_Button(nullptr) {} - ~Message_ButtonsMessage_Button() override; - explicit PROTOBUF_CONSTEXPR Message_ButtonsMessage_Button(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_ButtonsMessage_Button(const Message_ButtonsMessage_Button& from); - Message_ButtonsMessage_Button(Message_ButtonsMessage_Button&& from) noexcept - : Message_ButtonsMessage_Button() { - *this = ::std::move(from); - } - - inline Message_ButtonsMessage_Button& operator=(const Message_ButtonsMessage_Button& from) { - CopyFrom(from); - return *this; - } - inline Message_ButtonsMessage_Button& operator=(Message_ButtonsMessage_Button&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_ButtonsMessage_Button& default_instance() { - return *internal_default_instance(); - } - static inline const Message_ButtonsMessage_Button* internal_default_instance() { - return reinterpret_cast( - &_Message_ButtonsMessage_Button_default_instance_); - } - static constexpr int kIndexInFileMessages = - 63; - - friend void swap(Message_ButtonsMessage_Button& a, Message_ButtonsMessage_Button& b) { - a.Swap(&b); - } - inline void Swap(Message_ButtonsMessage_Button* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_ButtonsMessage_Button* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_ButtonsMessage_Button* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_ButtonsMessage_Button& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_ButtonsMessage_Button& from) { - Message_ButtonsMessage_Button::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_ButtonsMessage_Button* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.ButtonsMessage.Button"; - } - protected: - explicit Message_ButtonsMessage_Button(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Message_ButtonsMessage_Button_ButtonText ButtonText; - typedef Message_ButtonsMessage_Button_NativeFlowInfo NativeFlowInfo; - - typedef Message_ButtonsMessage_Button_Type Type; - static constexpr Type UNKNOWN = - Message_ButtonsMessage_Button_Type_UNKNOWN; - static constexpr Type RESPONSE = - Message_ButtonsMessage_Button_Type_RESPONSE; - static constexpr Type NATIVE_FLOW = - Message_ButtonsMessage_Button_Type_NATIVE_FLOW; - static inline bool Type_IsValid(int value) { - return Message_ButtonsMessage_Button_Type_IsValid(value); - } - static constexpr Type Type_MIN = - Message_ButtonsMessage_Button_Type_Type_MIN; - static constexpr Type Type_MAX = - Message_ButtonsMessage_Button_Type_Type_MAX; - static constexpr int Type_ARRAYSIZE = - Message_ButtonsMessage_Button_Type_Type_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - Type_descriptor() { - return Message_ButtonsMessage_Button_Type_descriptor(); - } - template - static inline const std::string& Type_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Type_Name."); - return Message_ButtonsMessage_Button_Type_Name(enum_t_value); - } - static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - Type* value) { - return Message_ButtonsMessage_Button_Type_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kButtonIdFieldNumber = 1, - kButtonTextFieldNumber = 2, - kNativeFlowInfoFieldNumber = 4, - kTypeFieldNumber = 3, - }; - // optional string buttonId = 1; - bool has_buttonid() const; - private: - bool _internal_has_buttonid() const; - public: - void clear_buttonid(); - const std::string& buttonid() const; - template - void set_buttonid(ArgT0&& arg0, ArgT... args); - std::string* mutable_buttonid(); - PROTOBUF_NODISCARD std::string* release_buttonid(); - void set_allocated_buttonid(std::string* buttonid); - private: - const std::string& _internal_buttonid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_buttonid(const std::string& value); - std::string* _internal_mutable_buttonid(); - public: - - // optional .proto.Message.ButtonsMessage.Button.ButtonText buttonText = 2; - bool has_buttontext() const; - private: - bool _internal_has_buttontext() const; - public: - void clear_buttontext(); - const ::proto::Message_ButtonsMessage_Button_ButtonText& buttontext() const; - PROTOBUF_NODISCARD ::proto::Message_ButtonsMessage_Button_ButtonText* release_buttontext(); - ::proto::Message_ButtonsMessage_Button_ButtonText* mutable_buttontext(); - void set_allocated_buttontext(::proto::Message_ButtonsMessage_Button_ButtonText* buttontext); - private: - const ::proto::Message_ButtonsMessage_Button_ButtonText& _internal_buttontext() const; - ::proto::Message_ButtonsMessage_Button_ButtonText* _internal_mutable_buttontext(); - public: - void unsafe_arena_set_allocated_buttontext( - ::proto::Message_ButtonsMessage_Button_ButtonText* buttontext); - ::proto::Message_ButtonsMessage_Button_ButtonText* unsafe_arena_release_buttontext(); - - // optional .proto.Message.ButtonsMessage.Button.NativeFlowInfo nativeFlowInfo = 4; - bool has_nativeflowinfo() const; - private: - bool _internal_has_nativeflowinfo() const; - public: - void clear_nativeflowinfo(); - const ::proto::Message_ButtonsMessage_Button_NativeFlowInfo& nativeflowinfo() const; - PROTOBUF_NODISCARD ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* release_nativeflowinfo(); - ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* mutable_nativeflowinfo(); - void set_allocated_nativeflowinfo(::proto::Message_ButtonsMessage_Button_NativeFlowInfo* nativeflowinfo); - private: - const ::proto::Message_ButtonsMessage_Button_NativeFlowInfo& _internal_nativeflowinfo() const; - ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* _internal_mutable_nativeflowinfo(); - public: - void unsafe_arena_set_allocated_nativeflowinfo( - ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* nativeflowinfo); - ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* unsafe_arena_release_nativeflowinfo(); - - // optional .proto.Message.ButtonsMessage.Button.Type type = 3; - bool has_type() const; - private: - bool _internal_has_type() const; - public: - void clear_type(); - ::proto::Message_ButtonsMessage_Button_Type type() const; - void set_type(::proto::Message_ButtonsMessage_Button_Type value); - private: - ::proto::Message_ButtonsMessage_Button_Type _internal_type() const; - void _internal_set_type(::proto::Message_ButtonsMessage_Button_Type value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.ButtonsMessage.Button) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr buttonid_; - ::proto::Message_ButtonsMessage_Button_ButtonText* buttontext_; - ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* nativeflowinfo_; - int type_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_ButtonsMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ButtonsMessage) */ { - public: - inline Message_ButtonsMessage() : Message_ButtonsMessage(nullptr) {} - ~Message_ButtonsMessage() override; - explicit PROTOBUF_CONSTEXPR Message_ButtonsMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_ButtonsMessage(const Message_ButtonsMessage& from); - Message_ButtonsMessage(Message_ButtonsMessage&& from) noexcept - : Message_ButtonsMessage() { - *this = ::std::move(from); - } - - inline Message_ButtonsMessage& operator=(const Message_ButtonsMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_ButtonsMessage& operator=(Message_ButtonsMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_ButtonsMessage& default_instance() { - return *internal_default_instance(); - } - enum HeaderCase { - kText = 1, - kDocumentMessage = 2, - kImageMessage = 3, - kVideoMessage = 4, - kLocationMessage = 5, - HEADER_NOT_SET = 0, - }; - - static inline const Message_ButtonsMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_ButtonsMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 64; - - friend void swap(Message_ButtonsMessage& a, Message_ButtonsMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_ButtonsMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_ButtonsMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_ButtonsMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_ButtonsMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_ButtonsMessage& from) { - Message_ButtonsMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_ButtonsMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.ButtonsMessage"; - } - protected: - explicit Message_ButtonsMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Message_ButtonsMessage_Button Button; - - typedef Message_ButtonsMessage_HeaderType HeaderType; - static constexpr HeaderType UNKNOWN = - Message_ButtonsMessage_HeaderType_UNKNOWN; - static constexpr HeaderType EMPTY = - Message_ButtonsMessage_HeaderType_EMPTY; - static constexpr HeaderType TEXT = - Message_ButtonsMessage_HeaderType_TEXT; - static constexpr HeaderType DOCUMENT = - Message_ButtonsMessage_HeaderType_DOCUMENT; - static constexpr HeaderType IMAGE = - Message_ButtonsMessage_HeaderType_IMAGE; - static constexpr HeaderType VIDEO = - Message_ButtonsMessage_HeaderType_VIDEO; - static constexpr HeaderType LOCATION = - Message_ButtonsMessage_HeaderType_LOCATION; - static inline bool HeaderType_IsValid(int value) { - return Message_ButtonsMessage_HeaderType_IsValid(value); - } - static constexpr HeaderType HeaderType_MIN = - Message_ButtonsMessage_HeaderType_HeaderType_MIN; - static constexpr HeaderType HeaderType_MAX = - Message_ButtonsMessage_HeaderType_HeaderType_MAX; - static constexpr int HeaderType_ARRAYSIZE = - Message_ButtonsMessage_HeaderType_HeaderType_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - HeaderType_descriptor() { - return Message_ButtonsMessage_HeaderType_descriptor(); - } - template - static inline const std::string& HeaderType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function HeaderType_Name."); - return Message_ButtonsMessage_HeaderType_Name(enum_t_value); - } - static inline bool HeaderType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - HeaderType* value) { - return Message_ButtonsMessage_HeaderType_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kButtonsFieldNumber = 9, - kContentTextFieldNumber = 6, - kFooterTextFieldNumber = 7, - kContextInfoFieldNumber = 8, - kHeaderTypeFieldNumber = 10, - kTextFieldNumber = 1, - kDocumentMessageFieldNumber = 2, - kImageMessageFieldNumber = 3, - kVideoMessageFieldNumber = 4, - kLocationMessageFieldNumber = 5, - }; - // repeated .proto.Message.ButtonsMessage.Button buttons = 9; - int buttons_size() const; - private: - int _internal_buttons_size() const; - public: - void clear_buttons(); - ::proto::Message_ButtonsMessage_Button* mutable_buttons(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ButtonsMessage_Button >* - mutable_buttons(); - private: - const ::proto::Message_ButtonsMessage_Button& _internal_buttons(int index) const; - ::proto::Message_ButtonsMessage_Button* _internal_add_buttons(); - public: - const ::proto::Message_ButtonsMessage_Button& buttons(int index) const; - ::proto::Message_ButtonsMessage_Button* add_buttons(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ButtonsMessage_Button >& - buttons() const; - - // optional string contentText = 6; - bool has_contenttext() const; - private: - bool _internal_has_contenttext() const; - public: - void clear_contenttext(); - const std::string& contenttext() const; - template - void set_contenttext(ArgT0&& arg0, ArgT... args); - std::string* mutable_contenttext(); - PROTOBUF_NODISCARD std::string* release_contenttext(); - void set_allocated_contenttext(std::string* contenttext); - private: - const std::string& _internal_contenttext() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_contenttext(const std::string& value); - std::string* _internal_mutable_contenttext(); - public: - - // optional string footerText = 7; - bool has_footertext() const; - private: - bool _internal_has_footertext() const; - public: - void clear_footertext(); - const std::string& footertext() const; - template - void set_footertext(ArgT0&& arg0, ArgT... args); - std::string* mutable_footertext(); - PROTOBUF_NODISCARD std::string* release_footertext(); - void set_allocated_footertext(std::string* footertext); - private: - const std::string& _internal_footertext() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_footertext(const std::string& value); - std::string* _internal_mutable_footertext(); - public: - - // optional .proto.ContextInfo contextInfo = 8; - bool has_contextinfo() const; - private: - bool _internal_has_contextinfo() const; - public: - void clear_contextinfo(); - const ::proto::ContextInfo& contextinfo() const; - PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); - ::proto::ContextInfo* mutable_contextinfo(); - void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); - private: - const ::proto::ContextInfo& _internal_contextinfo() const; - ::proto::ContextInfo* _internal_mutable_contextinfo(); - public: - void unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo); - ::proto::ContextInfo* unsafe_arena_release_contextinfo(); - - // optional .proto.Message.ButtonsMessage.HeaderType headerType = 10; - bool has_headertype() const; - private: - bool _internal_has_headertype() const; - public: - void clear_headertype(); - ::proto::Message_ButtonsMessage_HeaderType headertype() const; - void set_headertype(::proto::Message_ButtonsMessage_HeaderType value); - private: - ::proto::Message_ButtonsMessage_HeaderType _internal_headertype() const; - void _internal_set_headertype(::proto::Message_ButtonsMessage_HeaderType value); - public: - - // string text = 1; - bool has_text() const; - private: - bool _internal_has_text() const; - public: - void clear_text(); - const std::string& text() const; - template - void set_text(ArgT0&& arg0, ArgT... args); - std::string* mutable_text(); - PROTOBUF_NODISCARD std::string* release_text(); - void set_allocated_text(std::string* text); - private: - const std::string& _internal_text() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value); - std::string* _internal_mutable_text(); - public: - - // .proto.Message.DocumentMessage documentMessage = 2; - bool has_documentmessage() const; - private: - bool _internal_has_documentmessage() const; - public: - void clear_documentmessage(); - const ::proto::Message_DocumentMessage& documentmessage() const; - PROTOBUF_NODISCARD ::proto::Message_DocumentMessage* release_documentmessage(); - ::proto::Message_DocumentMessage* mutable_documentmessage(); - void set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage); - private: - const ::proto::Message_DocumentMessage& _internal_documentmessage() const; - ::proto::Message_DocumentMessage* _internal_mutable_documentmessage(); - public: - void unsafe_arena_set_allocated_documentmessage( - ::proto::Message_DocumentMessage* documentmessage); - ::proto::Message_DocumentMessage* unsafe_arena_release_documentmessage(); - - // .proto.Message.ImageMessage imageMessage = 3; - bool has_imagemessage() const; - private: - bool _internal_has_imagemessage() const; - public: - void clear_imagemessage(); - const ::proto::Message_ImageMessage& imagemessage() const; - PROTOBUF_NODISCARD ::proto::Message_ImageMessage* release_imagemessage(); - ::proto::Message_ImageMessage* mutable_imagemessage(); - void set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage); - private: - const ::proto::Message_ImageMessage& _internal_imagemessage() const; - ::proto::Message_ImageMessage* _internal_mutable_imagemessage(); - public: - void unsafe_arena_set_allocated_imagemessage( - ::proto::Message_ImageMessage* imagemessage); - ::proto::Message_ImageMessage* unsafe_arena_release_imagemessage(); - - // .proto.Message.VideoMessage videoMessage = 4; - bool has_videomessage() const; - private: - bool _internal_has_videomessage() const; - public: - void clear_videomessage(); - const ::proto::Message_VideoMessage& videomessage() const; - PROTOBUF_NODISCARD ::proto::Message_VideoMessage* release_videomessage(); - ::proto::Message_VideoMessage* mutable_videomessage(); - void set_allocated_videomessage(::proto::Message_VideoMessage* videomessage); - private: - const ::proto::Message_VideoMessage& _internal_videomessage() const; - ::proto::Message_VideoMessage* _internal_mutable_videomessage(); - public: - void unsafe_arena_set_allocated_videomessage( - ::proto::Message_VideoMessage* videomessage); - ::proto::Message_VideoMessage* unsafe_arena_release_videomessage(); - - // .proto.Message.LocationMessage locationMessage = 5; - bool has_locationmessage() const; - private: - bool _internal_has_locationmessage() const; - public: - void clear_locationmessage(); - const ::proto::Message_LocationMessage& locationmessage() const; - PROTOBUF_NODISCARD ::proto::Message_LocationMessage* release_locationmessage(); - ::proto::Message_LocationMessage* mutable_locationmessage(); - void set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage); - private: - const ::proto::Message_LocationMessage& _internal_locationmessage() const; - ::proto::Message_LocationMessage* _internal_mutable_locationmessage(); - public: - void unsafe_arena_set_allocated_locationmessage( - ::proto::Message_LocationMessage* locationmessage); - ::proto::Message_LocationMessage* unsafe_arena_release_locationmessage(); - - void clear_header(); - HeaderCase header_case() const; - // @@protoc_insertion_point(class_scope:proto.Message.ButtonsMessage) - private: - class _Internal; - void set_has_text(); - void set_has_documentmessage(); - void set_has_imagemessage(); - void set_has_videomessage(); - void set_has_locationmessage(); - - inline bool has_header() const; - inline void clear_has_header(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ButtonsMessage_Button > buttons_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr contenttext_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr footertext_; - ::proto::ContextInfo* contextinfo_; - int headertype_; - union HeaderUnion { - constexpr HeaderUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_; - ::proto::Message_DocumentMessage* documentmessage_; - ::proto::Message_ImageMessage* imagemessage_; - ::proto::Message_VideoMessage* videomessage_; - ::proto::Message_LocationMessage* locationmessage_; - } header_; - uint32_t _oneof_case_[1]; - - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_ButtonsResponseMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ButtonsResponseMessage) */ { - public: - inline Message_ButtonsResponseMessage() : Message_ButtonsResponseMessage(nullptr) {} - ~Message_ButtonsResponseMessage() override; - explicit PROTOBUF_CONSTEXPR Message_ButtonsResponseMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_ButtonsResponseMessage(const Message_ButtonsResponseMessage& from); - Message_ButtonsResponseMessage(Message_ButtonsResponseMessage&& from) noexcept - : Message_ButtonsResponseMessage() { - *this = ::std::move(from); - } - - inline Message_ButtonsResponseMessage& operator=(const Message_ButtonsResponseMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_ButtonsResponseMessage& operator=(Message_ButtonsResponseMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_ButtonsResponseMessage& default_instance() { - return *internal_default_instance(); - } - enum ResponseCase { - kSelectedDisplayText = 2, - RESPONSE_NOT_SET = 0, - }; - - static inline const Message_ButtonsResponseMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_ButtonsResponseMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 65; - - friend void swap(Message_ButtonsResponseMessage& a, Message_ButtonsResponseMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_ButtonsResponseMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_ButtonsResponseMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_ButtonsResponseMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_ButtonsResponseMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_ButtonsResponseMessage& from) { - Message_ButtonsResponseMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_ButtonsResponseMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.ButtonsResponseMessage"; - } - protected: - explicit Message_ButtonsResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Message_ButtonsResponseMessage_Type Type; - static constexpr Type UNKNOWN = - Message_ButtonsResponseMessage_Type_UNKNOWN; - static constexpr Type DISPLAY_TEXT = - Message_ButtonsResponseMessage_Type_DISPLAY_TEXT; - static inline bool Type_IsValid(int value) { - return Message_ButtonsResponseMessage_Type_IsValid(value); - } - static constexpr Type Type_MIN = - Message_ButtonsResponseMessage_Type_Type_MIN; - static constexpr Type Type_MAX = - Message_ButtonsResponseMessage_Type_Type_MAX; - static constexpr int Type_ARRAYSIZE = - Message_ButtonsResponseMessage_Type_Type_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - Type_descriptor() { - return Message_ButtonsResponseMessage_Type_descriptor(); - } - template - static inline const std::string& Type_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Type_Name."); - return Message_ButtonsResponseMessage_Type_Name(enum_t_value); - } - static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - Type* value) { - return Message_ButtonsResponseMessage_Type_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kSelectedButtonIdFieldNumber = 1, - kContextInfoFieldNumber = 3, - kTypeFieldNumber = 4, - kSelectedDisplayTextFieldNumber = 2, - }; - // optional string selectedButtonId = 1; - bool has_selectedbuttonid() const; - private: - bool _internal_has_selectedbuttonid() const; - public: - void clear_selectedbuttonid(); - const std::string& selectedbuttonid() const; - template - void set_selectedbuttonid(ArgT0&& arg0, ArgT... args); - std::string* mutable_selectedbuttonid(); - PROTOBUF_NODISCARD std::string* release_selectedbuttonid(); - void set_allocated_selectedbuttonid(std::string* selectedbuttonid); - private: - const std::string& _internal_selectedbuttonid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_selectedbuttonid(const std::string& value); - std::string* _internal_mutable_selectedbuttonid(); - public: - - // optional .proto.ContextInfo contextInfo = 3; - bool has_contextinfo() const; - private: - bool _internal_has_contextinfo() const; - public: - void clear_contextinfo(); - const ::proto::ContextInfo& contextinfo() const; - PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); - ::proto::ContextInfo* mutable_contextinfo(); - void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); - private: - const ::proto::ContextInfo& _internal_contextinfo() const; - ::proto::ContextInfo* _internal_mutable_contextinfo(); - public: - void unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo); - ::proto::ContextInfo* unsafe_arena_release_contextinfo(); - - // optional .proto.Message.ButtonsResponseMessage.Type type = 4; - bool has_type() const; - private: - bool _internal_has_type() const; - public: - void clear_type(); - ::proto::Message_ButtonsResponseMessage_Type type() const; - void set_type(::proto::Message_ButtonsResponseMessage_Type value); - private: - ::proto::Message_ButtonsResponseMessage_Type _internal_type() const; - void _internal_set_type(::proto::Message_ButtonsResponseMessage_Type value); - public: - - // string selectedDisplayText = 2; - bool has_selecteddisplaytext() const; - private: - bool _internal_has_selecteddisplaytext() const; - public: - void clear_selecteddisplaytext(); - const std::string& selecteddisplaytext() const; - template - void set_selecteddisplaytext(ArgT0&& arg0, ArgT... args); - std::string* mutable_selecteddisplaytext(); - PROTOBUF_NODISCARD std::string* release_selecteddisplaytext(); - void set_allocated_selecteddisplaytext(std::string* selecteddisplaytext); - private: - const std::string& _internal_selecteddisplaytext() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_selecteddisplaytext(const std::string& value); - std::string* _internal_mutable_selecteddisplaytext(); - public: - - void clear_response(); - ResponseCase response_case() const; - // @@protoc_insertion_point(class_scope:proto.Message.ButtonsResponseMessage) - private: - class _Internal; - void set_has_selecteddisplaytext(); - - inline bool has_response() const; - inline void clear_has_response(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr selectedbuttonid_; - ::proto::ContextInfo* contextinfo_; - int type_; - union ResponseUnion { - constexpr ResponseUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr selecteddisplaytext_; - } response_; - uint32_t _oneof_case_[1]; - - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_Call final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.Call) */ { - public: - inline Message_Call() : Message_Call(nullptr) {} - ~Message_Call() override; - explicit PROTOBUF_CONSTEXPR Message_Call(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_Call(const Message_Call& from); - Message_Call(Message_Call&& from) noexcept - : Message_Call() { - *this = ::std::move(from); - } - - inline Message_Call& operator=(const Message_Call& from) { - CopyFrom(from); - return *this; - } - inline Message_Call& operator=(Message_Call&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_Call& default_instance() { - return *internal_default_instance(); - } - static inline const Message_Call* internal_default_instance() { - return reinterpret_cast( - &_Message_Call_default_instance_); - } - static constexpr int kIndexInFileMessages = - 66; - - friend void swap(Message_Call& a, Message_Call& b) { - a.Swap(&b); - } - inline void Swap(Message_Call* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_Call* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_Call* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_Call& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_Call& from) { - Message_Call::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_Call* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.Call"; - } - protected: - explicit Message_Call(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kCallKeyFieldNumber = 1, - kConversionSourceFieldNumber = 2, - kConversionDataFieldNumber = 3, - kConversionDelaySecondsFieldNumber = 4, - }; - // optional bytes callKey = 1; - bool has_callkey() const; - private: - bool _internal_has_callkey() const; - public: - void clear_callkey(); - const std::string& callkey() const; - template - void set_callkey(ArgT0&& arg0, ArgT... args); - std::string* mutable_callkey(); - PROTOBUF_NODISCARD std::string* release_callkey(); - void set_allocated_callkey(std::string* callkey); - private: - const std::string& _internal_callkey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_callkey(const std::string& value); - std::string* _internal_mutable_callkey(); - public: - - // optional string conversionSource = 2; - bool has_conversionsource() const; - private: - bool _internal_has_conversionsource() const; - public: - void clear_conversionsource(); - const std::string& conversionsource() const; - template - void set_conversionsource(ArgT0&& arg0, ArgT... args); - std::string* mutable_conversionsource(); - PROTOBUF_NODISCARD std::string* release_conversionsource(); - void set_allocated_conversionsource(std::string* conversionsource); - private: - const std::string& _internal_conversionsource() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_conversionsource(const std::string& value); - std::string* _internal_mutable_conversionsource(); - public: - - // optional bytes conversionData = 3; - bool has_conversiondata() const; - private: - bool _internal_has_conversiondata() const; - public: - void clear_conversiondata(); - const std::string& conversiondata() const; - template - void set_conversiondata(ArgT0&& arg0, ArgT... args); - std::string* mutable_conversiondata(); - PROTOBUF_NODISCARD std::string* release_conversiondata(); - void set_allocated_conversiondata(std::string* conversiondata); - private: - const std::string& _internal_conversiondata() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_conversiondata(const std::string& value); - std::string* _internal_mutable_conversiondata(); - public: - - // optional uint32 conversionDelaySeconds = 4; - bool has_conversiondelayseconds() const; - private: - bool _internal_has_conversiondelayseconds() const; - public: - void clear_conversiondelayseconds(); - uint32_t conversiondelayseconds() const; - void set_conversiondelayseconds(uint32_t value); - private: - uint32_t _internal_conversiondelayseconds() const; - void _internal_set_conversiondelayseconds(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.Call) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr callkey_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conversionsource_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conversiondata_; - uint32_t conversiondelayseconds_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_CancelPaymentRequestMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.CancelPaymentRequestMessage) */ { - public: - inline Message_CancelPaymentRequestMessage() : Message_CancelPaymentRequestMessage(nullptr) {} - ~Message_CancelPaymentRequestMessage() override; - explicit PROTOBUF_CONSTEXPR Message_CancelPaymentRequestMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_CancelPaymentRequestMessage(const Message_CancelPaymentRequestMessage& from); - Message_CancelPaymentRequestMessage(Message_CancelPaymentRequestMessage&& from) noexcept - : Message_CancelPaymentRequestMessage() { - *this = ::std::move(from); - } - - inline Message_CancelPaymentRequestMessage& operator=(const Message_CancelPaymentRequestMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_CancelPaymentRequestMessage& operator=(Message_CancelPaymentRequestMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_CancelPaymentRequestMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_CancelPaymentRequestMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_CancelPaymentRequestMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 67; - - friend void swap(Message_CancelPaymentRequestMessage& a, Message_CancelPaymentRequestMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_CancelPaymentRequestMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_CancelPaymentRequestMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_CancelPaymentRequestMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_CancelPaymentRequestMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_CancelPaymentRequestMessage& from) { - Message_CancelPaymentRequestMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_CancelPaymentRequestMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.CancelPaymentRequestMessage"; - } - protected: - explicit Message_CancelPaymentRequestMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kKeyFieldNumber = 1, - }; - // optional .proto.MessageKey key = 1; - bool has_key() const; - private: - bool _internal_has_key() const; - public: - void clear_key(); - const ::proto::MessageKey& key() const; - PROTOBUF_NODISCARD ::proto::MessageKey* release_key(); - ::proto::MessageKey* mutable_key(); - void set_allocated_key(::proto::MessageKey* key); - private: - const ::proto::MessageKey& _internal_key() const; - ::proto::MessageKey* _internal_mutable_key(); - public: - void unsafe_arena_set_allocated_key( - ::proto::MessageKey* key); - ::proto::MessageKey* unsafe_arena_release_key(); - - // @@protoc_insertion_point(class_scope:proto.Message.CancelPaymentRequestMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::proto::MessageKey* key_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_Chat final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.Chat) */ { - public: - inline Message_Chat() : Message_Chat(nullptr) {} - ~Message_Chat() override; - explicit PROTOBUF_CONSTEXPR Message_Chat(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_Chat(const Message_Chat& from); - Message_Chat(Message_Chat&& from) noexcept - : Message_Chat() { - *this = ::std::move(from); - } - - inline Message_Chat& operator=(const Message_Chat& from) { - CopyFrom(from); - return *this; - } - inline Message_Chat& operator=(Message_Chat&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_Chat& default_instance() { - return *internal_default_instance(); - } - static inline const Message_Chat* internal_default_instance() { - return reinterpret_cast( - &_Message_Chat_default_instance_); - } - static constexpr int kIndexInFileMessages = - 68; - - friend void swap(Message_Chat& a, Message_Chat& b) { - a.Swap(&b); - } - inline void Swap(Message_Chat* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_Chat* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_Chat* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_Chat& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_Chat& from) { - Message_Chat::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_Chat* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.Chat"; - } - protected: - explicit Message_Chat(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kDisplayNameFieldNumber = 1, - kIdFieldNumber = 2, - }; - // optional string displayName = 1; - bool has_displayname() const; - private: - bool _internal_has_displayname() const; - public: - void clear_displayname(); - const std::string& displayname() const; - template - void set_displayname(ArgT0&& arg0, ArgT... args); - std::string* mutable_displayname(); - PROTOBUF_NODISCARD std::string* release_displayname(); - void set_allocated_displayname(std::string* displayname); - private: - const std::string& _internal_displayname() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_displayname(const std::string& value); - std::string* _internal_mutable_displayname(); - public: - - // optional string id = 2; - bool has_id() const; - private: - bool _internal_has_id() const; - public: - void clear_id(); - const std::string& id() const; - template - void set_id(ArgT0&& arg0, ArgT... args); - std::string* mutable_id(); - PROTOBUF_NODISCARD std::string* release_id(); - void set_allocated_id(std::string* id); - private: - const std::string& _internal_id() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value); - std::string* _internal_mutable_id(); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.Chat) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr displayname_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_ContactMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ContactMessage) */ { - public: - inline Message_ContactMessage() : Message_ContactMessage(nullptr) {} - ~Message_ContactMessage() override; - explicit PROTOBUF_CONSTEXPR Message_ContactMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_ContactMessage(const Message_ContactMessage& from); - Message_ContactMessage(Message_ContactMessage&& from) noexcept - : Message_ContactMessage() { - *this = ::std::move(from); - } - - inline Message_ContactMessage& operator=(const Message_ContactMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_ContactMessage& operator=(Message_ContactMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_ContactMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_ContactMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_ContactMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 69; - - friend void swap(Message_ContactMessage& a, Message_ContactMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_ContactMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_ContactMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_ContactMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_ContactMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_ContactMessage& from) { - Message_ContactMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_ContactMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.ContactMessage"; - } - protected: - explicit Message_ContactMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kDisplayNameFieldNumber = 1, - kVcardFieldNumber = 16, - kContextInfoFieldNumber = 17, - }; - // optional string displayName = 1; - bool has_displayname() const; - private: - bool _internal_has_displayname() const; - public: - void clear_displayname(); - const std::string& displayname() const; - template - void set_displayname(ArgT0&& arg0, ArgT... args); - std::string* mutable_displayname(); - PROTOBUF_NODISCARD std::string* release_displayname(); - void set_allocated_displayname(std::string* displayname); - private: - const std::string& _internal_displayname() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_displayname(const std::string& value); - std::string* _internal_mutable_displayname(); - public: - - // optional string vcard = 16; - bool has_vcard() const; - private: - bool _internal_has_vcard() const; - public: - void clear_vcard(); - const std::string& vcard() const; - template - void set_vcard(ArgT0&& arg0, ArgT... args); - std::string* mutable_vcard(); - PROTOBUF_NODISCARD std::string* release_vcard(); - void set_allocated_vcard(std::string* vcard); - private: - const std::string& _internal_vcard() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_vcard(const std::string& value); - std::string* _internal_mutable_vcard(); - public: - - // optional .proto.ContextInfo contextInfo = 17; - bool has_contextinfo() const; - private: - bool _internal_has_contextinfo() const; - public: - void clear_contextinfo(); - const ::proto::ContextInfo& contextinfo() const; - PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); - ::proto::ContextInfo* mutable_contextinfo(); - void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); - private: - const ::proto::ContextInfo& _internal_contextinfo() const; - ::proto::ContextInfo* _internal_mutable_contextinfo(); - public: - void unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo); - ::proto::ContextInfo* unsafe_arena_release_contextinfo(); - - // @@protoc_insertion_point(class_scope:proto.Message.ContactMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr displayname_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr vcard_; - ::proto::ContextInfo* contextinfo_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_ContactsArrayMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ContactsArrayMessage) */ { - public: - inline Message_ContactsArrayMessage() : Message_ContactsArrayMessage(nullptr) {} - ~Message_ContactsArrayMessage() override; - explicit PROTOBUF_CONSTEXPR Message_ContactsArrayMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_ContactsArrayMessage(const Message_ContactsArrayMessage& from); - Message_ContactsArrayMessage(Message_ContactsArrayMessage&& from) noexcept - : Message_ContactsArrayMessage() { - *this = ::std::move(from); - } - - inline Message_ContactsArrayMessage& operator=(const Message_ContactsArrayMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_ContactsArrayMessage& operator=(Message_ContactsArrayMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_ContactsArrayMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_ContactsArrayMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_ContactsArrayMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 70; - - friend void swap(Message_ContactsArrayMessage& a, Message_ContactsArrayMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_ContactsArrayMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_ContactsArrayMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_ContactsArrayMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_ContactsArrayMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_ContactsArrayMessage& from) { - Message_ContactsArrayMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_ContactsArrayMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.ContactsArrayMessage"; - } - protected: - explicit Message_ContactsArrayMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kContactsFieldNumber = 2, - kDisplayNameFieldNumber = 1, - kContextInfoFieldNumber = 17, - }; - // repeated .proto.Message.ContactMessage contacts = 2; - int contacts_size() const; - private: - int _internal_contacts_size() const; - public: - void clear_contacts(); - ::proto::Message_ContactMessage* mutable_contacts(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ContactMessage >* - mutable_contacts(); - private: - const ::proto::Message_ContactMessage& _internal_contacts(int index) const; - ::proto::Message_ContactMessage* _internal_add_contacts(); - public: - const ::proto::Message_ContactMessage& contacts(int index) const; - ::proto::Message_ContactMessage* add_contacts(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ContactMessage >& - contacts() const; - - // optional string displayName = 1; - bool has_displayname() const; - private: - bool _internal_has_displayname() const; - public: - void clear_displayname(); - const std::string& displayname() const; - template - void set_displayname(ArgT0&& arg0, ArgT... args); - std::string* mutable_displayname(); - PROTOBUF_NODISCARD std::string* release_displayname(); - void set_allocated_displayname(std::string* displayname); - private: - const std::string& _internal_displayname() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_displayname(const std::string& value); - std::string* _internal_mutable_displayname(); - public: - - // optional .proto.ContextInfo contextInfo = 17; - bool has_contextinfo() const; - private: - bool _internal_has_contextinfo() const; - public: - void clear_contextinfo(); - const ::proto::ContextInfo& contextinfo() const; - PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); - ::proto::ContextInfo* mutable_contextinfo(); - void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); - private: - const ::proto::ContextInfo& _internal_contextinfo() const; - ::proto::ContextInfo* _internal_mutable_contextinfo(); - public: - void unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo); - ::proto::ContextInfo* unsafe_arena_release_contextinfo(); - - // @@protoc_insertion_point(class_scope:proto.Message.ContactsArrayMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ContactMessage > contacts_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr displayname_; - ::proto::ContextInfo* contextinfo_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_DeclinePaymentRequestMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.DeclinePaymentRequestMessage) */ { - public: - inline Message_DeclinePaymentRequestMessage() : Message_DeclinePaymentRequestMessage(nullptr) {} - ~Message_DeclinePaymentRequestMessage() override; - explicit PROTOBUF_CONSTEXPR Message_DeclinePaymentRequestMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_DeclinePaymentRequestMessage(const Message_DeclinePaymentRequestMessage& from); - Message_DeclinePaymentRequestMessage(Message_DeclinePaymentRequestMessage&& from) noexcept - : Message_DeclinePaymentRequestMessage() { - *this = ::std::move(from); - } - - inline Message_DeclinePaymentRequestMessage& operator=(const Message_DeclinePaymentRequestMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_DeclinePaymentRequestMessage& operator=(Message_DeclinePaymentRequestMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_DeclinePaymentRequestMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_DeclinePaymentRequestMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_DeclinePaymentRequestMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 71; - - friend void swap(Message_DeclinePaymentRequestMessage& a, Message_DeclinePaymentRequestMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_DeclinePaymentRequestMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_DeclinePaymentRequestMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_DeclinePaymentRequestMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_DeclinePaymentRequestMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_DeclinePaymentRequestMessage& from) { - Message_DeclinePaymentRequestMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_DeclinePaymentRequestMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.DeclinePaymentRequestMessage"; - } - protected: - explicit Message_DeclinePaymentRequestMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kKeyFieldNumber = 1, - }; - // optional .proto.MessageKey key = 1; - bool has_key() const; - private: - bool _internal_has_key() const; - public: - void clear_key(); - const ::proto::MessageKey& key() const; - PROTOBUF_NODISCARD ::proto::MessageKey* release_key(); - ::proto::MessageKey* mutable_key(); - void set_allocated_key(::proto::MessageKey* key); - private: - const ::proto::MessageKey& _internal_key() const; - ::proto::MessageKey* _internal_mutable_key(); - public: - void unsafe_arena_set_allocated_key( - ::proto::MessageKey* key); - ::proto::MessageKey* unsafe_arena_release_key(); - - // @@protoc_insertion_point(class_scope:proto.Message.DeclinePaymentRequestMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::proto::MessageKey* key_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_DeviceSentMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.DeviceSentMessage) */ { - public: - inline Message_DeviceSentMessage() : Message_DeviceSentMessage(nullptr) {} - ~Message_DeviceSentMessage() override; - explicit PROTOBUF_CONSTEXPR Message_DeviceSentMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_DeviceSentMessage(const Message_DeviceSentMessage& from); - Message_DeviceSentMessage(Message_DeviceSentMessage&& from) noexcept - : Message_DeviceSentMessage() { - *this = ::std::move(from); - } - - inline Message_DeviceSentMessage& operator=(const Message_DeviceSentMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_DeviceSentMessage& operator=(Message_DeviceSentMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_DeviceSentMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_DeviceSentMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_DeviceSentMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 72; - - friend void swap(Message_DeviceSentMessage& a, Message_DeviceSentMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_DeviceSentMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_DeviceSentMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_DeviceSentMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_DeviceSentMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_DeviceSentMessage& from) { - Message_DeviceSentMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_DeviceSentMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.DeviceSentMessage"; - } - protected: - explicit Message_DeviceSentMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kDestinationJidFieldNumber = 1, - kPhashFieldNumber = 3, - kMessageFieldNumber = 2, - }; - // optional string destinationJid = 1; - bool has_destinationjid() const; - private: - bool _internal_has_destinationjid() const; - public: - void clear_destinationjid(); - const std::string& destinationjid() const; - template - void set_destinationjid(ArgT0&& arg0, ArgT... args); - std::string* mutable_destinationjid(); - PROTOBUF_NODISCARD std::string* release_destinationjid(); - void set_allocated_destinationjid(std::string* destinationjid); - private: - const std::string& _internal_destinationjid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_destinationjid(const std::string& value); - std::string* _internal_mutable_destinationjid(); - public: - - // optional string phash = 3; - bool has_phash() const; - private: - bool _internal_has_phash() const; - public: - void clear_phash(); - const std::string& phash() const; - template - void set_phash(ArgT0&& arg0, ArgT... args); - std::string* mutable_phash(); - PROTOBUF_NODISCARD std::string* release_phash(); - void set_allocated_phash(std::string* phash); - private: - const std::string& _internal_phash() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_phash(const std::string& value); - std::string* _internal_mutable_phash(); - public: - - // optional .proto.Message message = 2; - bool has_message() const; - private: - bool _internal_has_message() const; - public: - void clear_message(); - const ::proto::Message& message() const; - PROTOBUF_NODISCARD ::proto::Message* release_message(); - ::proto::Message* mutable_message(); - void set_allocated_message(::proto::Message* message); - private: - const ::proto::Message& _internal_message() const; - ::proto::Message* _internal_mutable_message(); - public: - void unsafe_arena_set_allocated_message( - ::proto::Message* message); - ::proto::Message* unsafe_arena_release_message(); - - // @@protoc_insertion_point(class_scope:proto.Message.DeviceSentMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr destinationjid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr phash_; - ::proto::Message* message_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_DocumentMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.DocumentMessage) */ { - public: - inline Message_DocumentMessage() : Message_DocumentMessage(nullptr) {} - ~Message_DocumentMessage() override; - explicit PROTOBUF_CONSTEXPR Message_DocumentMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_DocumentMessage(const Message_DocumentMessage& from); - Message_DocumentMessage(Message_DocumentMessage&& from) noexcept - : Message_DocumentMessage() { - *this = ::std::move(from); - } - - inline Message_DocumentMessage& operator=(const Message_DocumentMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_DocumentMessage& operator=(Message_DocumentMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_DocumentMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_DocumentMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_DocumentMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 73; - - friend void swap(Message_DocumentMessage& a, Message_DocumentMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_DocumentMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_DocumentMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_DocumentMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_DocumentMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_DocumentMessage& from) { - Message_DocumentMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_DocumentMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.DocumentMessage"; - } - protected: - explicit Message_DocumentMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kUrlFieldNumber = 1, - kMimetypeFieldNumber = 2, - kTitleFieldNumber = 3, - kFileSha256FieldNumber = 4, - kMediaKeyFieldNumber = 7, - kFileNameFieldNumber = 8, - kFileEncSha256FieldNumber = 9, - kDirectPathFieldNumber = 10, - kThumbnailDirectPathFieldNumber = 13, - kThumbnailSha256FieldNumber = 14, - kThumbnailEncSha256FieldNumber = 15, - kJpegThumbnailFieldNumber = 16, - kCaptionFieldNumber = 20, - kContextInfoFieldNumber = 17, - kFileLengthFieldNumber = 5, - kPageCountFieldNumber = 6, - kContactVcardFieldNumber = 12, - kMediaKeyTimestampFieldNumber = 11, - kThumbnailHeightFieldNumber = 18, - kThumbnailWidthFieldNumber = 19, - }; - // optional string url = 1; - bool has_url() const; - private: - bool _internal_has_url() const; - public: - void clear_url(); - const std::string& url() const; - template - void set_url(ArgT0&& arg0, ArgT... args); - std::string* mutable_url(); - PROTOBUF_NODISCARD std::string* release_url(); - void set_allocated_url(std::string* url); - private: - const std::string& _internal_url() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value); - std::string* _internal_mutable_url(); - public: - - // optional string mimetype = 2; - bool has_mimetype() const; - private: - bool _internal_has_mimetype() const; - public: - void clear_mimetype(); - const std::string& mimetype() const; - template - void set_mimetype(ArgT0&& arg0, ArgT... args); - std::string* mutable_mimetype(); - PROTOBUF_NODISCARD std::string* release_mimetype(); - void set_allocated_mimetype(std::string* mimetype); - private: - const std::string& _internal_mimetype() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value); - std::string* _internal_mutable_mimetype(); - public: - - // optional string title = 3; - bool has_title() const; - private: - bool _internal_has_title() const; - public: - void clear_title(); - const std::string& title() const; - template - void set_title(ArgT0&& arg0, ArgT... args); - std::string* mutable_title(); - PROTOBUF_NODISCARD std::string* release_title(); - void set_allocated_title(std::string* title); - private: - const std::string& _internal_title() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value); - std::string* _internal_mutable_title(); - public: - - // optional bytes fileSha256 = 4; - bool has_filesha256() const; - private: - bool _internal_has_filesha256() const; - public: - void clear_filesha256(); - const std::string& filesha256() const; - template - void set_filesha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_filesha256(); - PROTOBUF_NODISCARD std::string* release_filesha256(); - void set_allocated_filesha256(std::string* filesha256); - private: - const std::string& _internal_filesha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value); - std::string* _internal_mutable_filesha256(); - public: - - // optional bytes mediaKey = 7; - bool has_mediakey() const; - private: - bool _internal_has_mediakey() const; - public: - void clear_mediakey(); - const std::string& mediakey() const; - template - void set_mediakey(ArgT0&& arg0, ArgT... args); - std::string* mutable_mediakey(); - PROTOBUF_NODISCARD std::string* release_mediakey(); - void set_allocated_mediakey(std::string* mediakey); - private: - const std::string& _internal_mediakey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value); - std::string* _internal_mutable_mediakey(); - public: - - // optional string fileName = 8; - bool has_filename() const; - private: - bool _internal_has_filename() const; - public: - void clear_filename(); - const std::string& filename() const; - template - void set_filename(ArgT0&& arg0, ArgT... args); - std::string* mutable_filename(); - PROTOBUF_NODISCARD std::string* release_filename(); - void set_allocated_filename(std::string* filename); - private: - const std::string& _internal_filename() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_filename(const std::string& value); - std::string* _internal_mutable_filename(); - public: - - // optional bytes fileEncSha256 = 9; - bool has_fileencsha256() const; - private: - bool _internal_has_fileencsha256() const; - public: - void clear_fileencsha256(); - const std::string& fileencsha256() const; - template - void set_fileencsha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_fileencsha256(); - PROTOBUF_NODISCARD std::string* release_fileencsha256(); - void set_allocated_fileencsha256(std::string* fileencsha256); - private: - const std::string& _internal_fileencsha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value); - std::string* _internal_mutable_fileencsha256(); - public: - - // optional string directPath = 10; - bool has_directpath() const; - private: - bool _internal_has_directpath() const; - public: - void clear_directpath(); - const std::string& directpath() const; - template - void set_directpath(ArgT0&& arg0, ArgT... args); - std::string* mutable_directpath(); - PROTOBUF_NODISCARD std::string* release_directpath(); - void set_allocated_directpath(std::string* directpath); - private: - const std::string& _internal_directpath() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value); - std::string* _internal_mutable_directpath(); - public: - - // optional string thumbnailDirectPath = 13; - bool has_thumbnaildirectpath() const; - private: - bool _internal_has_thumbnaildirectpath() const; - public: - void clear_thumbnaildirectpath(); - const std::string& thumbnaildirectpath() const; - template - void set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args); - std::string* mutable_thumbnaildirectpath(); - PROTOBUF_NODISCARD std::string* release_thumbnaildirectpath(); - void set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath); - private: - const std::string& _internal_thumbnaildirectpath() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnaildirectpath(const std::string& value); - std::string* _internal_mutable_thumbnaildirectpath(); - public: - - // optional bytes thumbnailSha256 = 14; - bool has_thumbnailsha256() const; - private: - bool _internal_has_thumbnailsha256() const; - public: - void clear_thumbnailsha256(); - const std::string& thumbnailsha256() const; - template - void set_thumbnailsha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_thumbnailsha256(); - PROTOBUF_NODISCARD std::string* release_thumbnailsha256(); - void set_allocated_thumbnailsha256(std::string* thumbnailsha256); - private: - const std::string& _internal_thumbnailsha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailsha256(const std::string& value); - std::string* _internal_mutable_thumbnailsha256(); - public: - - // optional bytes thumbnailEncSha256 = 15; - bool has_thumbnailencsha256() const; - private: - bool _internal_has_thumbnailencsha256() const; - public: - void clear_thumbnailencsha256(); - const std::string& thumbnailencsha256() const; - template - void set_thumbnailencsha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_thumbnailencsha256(); - PROTOBUF_NODISCARD std::string* release_thumbnailencsha256(); - void set_allocated_thumbnailencsha256(std::string* thumbnailencsha256); - private: - const std::string& _internal_thumbnailencsha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailencsha256(const std::string& value); - std::string* _internal_mutable_thumbnailencsha256(); - public: - - // optional bytes jpegThumbnail = 16; - bool has_jpegthumbnail() const; - private: - bool _internal_has_jpegthumbnail() const; - public: - void clear_jpegthumbnail(); - const std::string& jpegthumbnail() const; - template - void set_jpegthumbnail(ArgT0&& arg0, ArgT... args); - std::string* mutable_jpegthumbnail(); - PROTOBUF_NODISCARD std::string* release_jpegthumbnail(); - void set_allocated_jpegthumbnail(std::string* jpegthumbnail); - private: - const std::string& _internal_jpegthumbnail() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value); - std::string* _internal_mutable_jpegthumbnail(); - public: - - // optional string caption = 20; - bool has_caption() const; - private: - bool _internal_has_caption() const; - public: - void clear_caption(); - const std::string& caption() const; - template - void set_caption(ArgT0&& arg0, ArgT... args); - std::string* mutable_caption(); - PROTOBUF_NODISCARD std::string* release_caption(); - void set_allocated_caption(std::string* caption); - private: - const std::string& _internal_caption() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_caption(const std::string& value); - std::string* _internal_mutable_caption(); - public: - - // optional .proto.ContextInfo contextInfo = 17; - bool has_contextinfo() const; - private: - bool _internal_has_contextinfo() const; - public: - void clear_contextinfo(); - const ::proto::ContextInfo& contextinfo() const; - PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); - ::proto::ContextInfo* mutable_contextinfo(); - void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); - private: - const ::proto::ContextInfo& _internal_contextinfo() const; - ::proto::ContextInfo* _internal_mutable_contextinfo(); - public: - void unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo); - ::proto::ContextInfo* unsafe_arena_release_contextinfo(); - - // optional uint64 fileLength = 5; - bool has_filelength() const; - private: - bool _internal_has_filelength() const; - public: - void clear_filelength(); - uint64_t filelength() const; - void set_filelength(uint64_t value); - private: - uint64_t _internal_filelength() const; - void _internal_set_filelength(uint64_t value); - public: - - // optional uint32 pageCount = 6; - bool has_pagecount() const; - private: - bool _internal_has_pagecount() const; - public: - void clear_pagecount(); - uint32_t pagecount() const; - void set_pagecount(uint32_t value); - private: - uint32_t _internal_pagecount() const; - void _internal_set_pagecount(uint32_t value); - public: - - // optional bool contactVcard = 12; - bool has_contactvcard() const; - private: - bool _internal_has_contactvcard() const; - public: - void clear_contactvcard(); - bool contactvcard() const; - void set_contactvcard(bool value); - private: - bool _internal_contactvcard() const; - void _internal_set_contactvcard(bool value); - public: - - // optional int64 mediaKeyTimestamp = 11; - bool has_mediakeytimestamp() const; - private: - bool _internal_has_mediakeytimestamp() const; - public: - void clear_mediakeytimestamp(); - int64_t mediakeytimestamp() const; - void set_mediakeytimestamp(int64_t value); - private: - int64_t _internal_mediakeytimestamp() const; - void _internal_set_mediakeytimestamp(int64_t value); - public: - - // optional uint32 thumbnailHeight = 18; - bool has_thumbnailheight() const; - private: - bool _internal_has_thumbnailheight() const; - public: - void clear_thumbnailheight(); - uint32_t thumbnailheight() const; - void set_thumbnailheight(uint32_t value); - private: - uint32_t _internal_thumbnailheight() const; - void _internal_set_thumbnailheight(uint32_t value); - public: - - // optional uint32 thumbnailWidth = 19; - bool has_thumbnailwidth() const; - private: - bool _internal_has_thumbnailwidth() const; - public: - void clear_thumbnailwidth(); - uint32_t thumbnailwidth() const; - void set_thumbnailwidth(uint32_t value); - private: - uint32_t _internal_thumbnailwidth() const; - void _internal_set_thumbnailwidth(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.DocumentMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mimetype_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filename_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnaildirectpath_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailsha256_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailencsha256_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr caption_; - ::proto::ContextInfo* contextinfo_; - uint64_t filelength_; - uint32_t pagecount_; - bool contactvcard_; - int64_t mediakeytimestamp_; - uint32_t thumbnailheight_; - uint32_t thumbnailwidth_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_ExtendedTextMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ExtendedTextMessage) */ { - public: - inline Message_ExtendedTextMessage() : Message_ExtendedTextMessage(nullptr) {} - ~Message_ExtendedTextMessage() override; - explicit PROTOBUF_CONSTEXPR Message_ExtendedTextMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_ExtendedTextMessage(const Message_ExtendedTextMessage& from); - Message_ExtendedTextMessage(Message_ExtendedTextMessage&& from) noexcept - : Message_ExtendedTextMessage() { - *this = ::std::move(from); - } - - inline Message_ExtendedTextMessage& operator=(const Message_ExtendedTextMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_ExtendedTextMessage& operator=(Message_ExtendedTextMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_ExtendedTextMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_ExtendedTextMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_ExtendedTextMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 74; - - friend void swap(Message_ExtendedTextMessage& a, Message_ExtendedTextMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_ExtendedTextMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_ExtendedTextMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_ExtendedTextMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_ExtendedTextMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_ExtendedTextMessage& from) { - Message_ExtendedTextMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_ExtendedTextMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.ExtendedTextMessage"; - } - protected: - explicit Message_ExtendedTextMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Message_ExtendedTextMessage_FontType FontType; - static constexpr FontType SANS_SERIF = - Message_ExtendedTextMessage_FontType_SANS_SERIF; - static constexpr FontType SERIF = - Message_ExtendedTextMessage_FontType_SERIF; - static constexpr FontType NORICAN_REGULAR = - Message_ExtendedTextMessage_FontType_NORICAN_REGULAR; - static constexpr FontType BRYNDAN_WRITE = - Message_ExtendedTextMessage_FontType_BRYNDAN_WRITE; - static constexpr FontType BEBASNEUE_REGULAR = - Message_ExtendedTextMessage_FontType_BEBASNEUE_REGULAR; - static constexpr FontType OSWALD_HEAVY = - Message_ExtendedTextMessage_FontType_OSWALD_HEAVY; - static inline bool FontType_IsValid(int value) { - return Message_ExtendedTextMessage_FontType_IsValid(value); - } - static constexpr FontType FontType_MIN = - Message_ExtendedTextMessage_FontType_FontType_MIN; - static constexpr FontType FontType_MAX = - Message_ExtendedTextMessage_FontType_FontType_MAX; - static constexpr int FontType_ARRAYSIZE = - Message_ExtendedTextMessage_FontType_FontType_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - FontType_descriptor() { - return Message_ExtendedTextMessage_FontType_descriptor(); - } - template - static inline const std::string& FontType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function FontType_Name."); - return Message_ExtendedTextMessage_FontType_Name(enum_t_value); - } - static inline bool FontType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - FontType* value) { - return Message_ExtendedTextMessage_FontType_Parse(name, value); - } - - typedef Message_ExtendedTextMessage_InviteLinkGroupType InviteLinkGroupType; - static constexpr InviteLinkGroupType DEFAULT = - Message_ExtendedTextMessage_InviteLinkGroupType_DEFAULT; - static constexpr InviteLinkGroupType PARENT = - Message_ExtendedTextMessage_InviteLinkGroupType_PARENT; - static constexpr InviteLinkGroupType SUB = - Message_ExtendedTextMessage_InviteLinkGroupType_SUB; - static constexpr InviteLinkGroupType DEFAULT_SUB = - Message_ExtendedTextMessage_InviteLinkGroupType_DEFAULT_SUB; - static inline bool InviteLinkGroupType_IsValid(int value) { - return Message_ExtendedTextMessage_InviteLinkGroupType_IsValid(value); - } - static constexpr InviteLinkGroupType InviteLinkGroupType_MIN = - Message_ExtendedTextMessage_InviteLinkGroupType_InviteLinkGroupType_MIN; - static constexpr InviteLinkGroupType InviteLinkGroupType_MAX = - Message_ExtendedTextMessage_InviteLinkGroupType_InviteLinkGroupType_MAX; - static constexpr int InviteLinkGroupType_ARRAYSIZE = - Message_ExtendedTextMessage_InviteLinkGroupType_InviteLinkGroupType_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - InviteLinkGroupType_descriptor() { - return Message_ExtendedTextMessage_InviteLinkGroupType_descriptor(); - } - template - static inline const std::string& InviteLinkGroupType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function InviteLinkGroupType_Name."); - return Message_ExtendedTextMessage_InviteLinkGroupType_Name(enum_t_value); - } - static inline bool InviteLinkGroupType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - InviteLinkGroupType* value) { - return Message_ExtendedTextMessage_InviteLinkGroupType_Parse(name, value); - } - - typedef Message_ExtendedTextMessage_PreviewType PreviewType; - static constexpr PreviewType NONE = - Message_ExtendedTextMessage_PreviewType_NONE; - static constexpr PreviewType VIDEO = - Message_ExtendedTextMessage_PreviewType_VIDEO; - static inline bool PreviewType_IsValid(int value) { - return Message_ExtendedTextMessage_PreviewType_IsValid(value); - } - static constexpr PreviewType PreviewType_MIN = - Message_ExtendedTextMessage_PreviewType_PreviewType_MIN; - static constexpr PreviewType PreviewType_MAX = - Message_ExtendedTextMessage_PreviewType_PreviewType_MAX; - static constexpr int PreviewType_ARRAYSIZE = - Message_ExtendedTextMessage_PreviewType_PreviewType_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - PreviewType_descriptor() { - return Message_ExtendedTextMessage_PreviewType_descriptor(); - } - template - static inline const std::string& PreviewType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function PreviewType_Name."); - return Message_ExtendedTextMessage_PreviewType_Name(enum_t_value); - } - static inline bool PreviewType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - PreviewType* value) { - return Message_ExtendedTextMessage_PreviewType_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kTextFieldNumber = 1, - kMatchedTextFieldNumber = 2, - kCanonicalUrlFieldNumber = 4, - kDescriptionFieldNumber = 5, - kTitleFieldNumber = 6, - kJpegThumbnailFieldNumber = 16, - kThumbnailDirectPathFieldNumber = 19, - kThumbnailSha256FieldNumber = 20, - kThumbnailEncSha256FieldNumber = 21, - kMediaKeyFieldNumber = 22, - kInviteLinkParentGroupSubjectV2FieldNumber = 27, - kInviteLinkParentGroupThumbnailV2FieldNumber = 28, - kContextInfoFieldNumber = 17, - kTextArgbFieldNumber = 7, - kBackgroundArgbFieldNumber = 8, - kFontFieldNumber = 9, - kPreviewTypeFieldNumber = 10, - kDoNotPlayInlineFieldNumber = 18, - kThumbnailHeightFieldNumber = 24, - kMediaKeyTimestampFieldNumber = 23, - kThumbnailWidthFieldNumber = 25, - kInviteLinkGroupTypeFieldNumber = 26, - kInviteLinkGroupTypeV2FieldNumber = 29, - }; - // optional string text = 1; - bool has_text() const; - private: - bool _internal_has_text() const; - public: - void clear_text(); - const std::string& text() const; - template - void set_text(ArgT0&& arg0, ArgT... args); - std::string* mutable_text(); - PROTOBUF_NODISCARD std::string* release_text(); - void set_allocated_text(std::string* text); - private: - const std::string& _internal_text() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value); - std::string* _internal_mutable_text(); - public: - - // optional string matchedText = 2; - bool has_matchedtext() const; - private: - bool _internal_has_matchedtext() const; - public: - void clear_matchedtext(); - const std::string& matchedtext() const; - template - void set_matchedtext(ArgT0&& arg0, ArgT... args); - std::string* mutable_matchedtext(); - PROTOBUF_NODISCARD std::string* release_matchedtext(); - void set_allocated_matchedtext(std::string* matchedtext); - private: - const std::string& _internal_matchedtext() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_matchedtext(const std::string& value); - std::string* _internal_mutable_matchedtext(); - public: - - // optional string canonicalUrl = 4; - bool has_canonicalurl() const; - private: - bool _internal_has_canonicalurl() const; - public: - void clear_canonicalurl(); - const std::string& canonicalurl() const; - template - void set_canonicalurl(ArgT0&& arg0, ArgT... args); - std::string* mutable_canonicalurl(); - PROTOBUF_NODISCARD std::string* release_canonicalurl(); - void set_allocated_canonicalurl(std::string* canonicalurl); - private: - const std::string& _internal_canonicalurl() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_canonicalurl(const std::string& value); - std::string* _internal_mutable_canonicalurl(); - public: - - // optional string description = 5; - bool has_description() const; - private: - bool _internal_has_description() const; - public: - void clear_description(); - const std::string& description() const; - template - void set_description(ArgT0&& arg0, ArgT... args); - std::string* mutable_description(); - PROTOBUF_NODISCARD std::string* release_description(); - void set_allocated_description(std::string* description); - private: - const std::string& _internal_description() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value); - std::string* _internal_mutable_description(); - public: - - // optional string title = 6; - bool has_title() const; - private: - bool _internal_has_title() const; - public: - void clear_title(); - const std::string& title() const; - template - void set_title(ArgT0&& arg0, ArgT... args); - std::string* mutable_title(); - PROTOBUF_NODISCARD std::string* release_title(); - void set_allocated_title(std::string* title); - private: - const std::string& _internal_title() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value); - std::string* _internal_mutable_title(); - public: - - // optional bytes jpegThumbnail = 16; - bool has_jpegthumbnail() const; - private: - bool _internal_has_jpegthumbnail() const; - public: - void clear_jpegthumbnail(); - const std::string& jpegthumbnail() const; - template - void set_jpegthumbnail(ArgT0&& arg0, ArgT... args); - std::string* mutable_jpegthumbnail(); - PROTOBUF_NODISCARD std::string* release_jpegthumbnail(); - void set_allocated_jpegthumbnail(std::string* jpegthumbnail); - private: - const std::string& _internal_jpegthumbnail() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value); - std::string* _internal_mutable_jpegthumbnail(); - public: - - // optional string thumbnailDirectPath = 19; - bool has_thumbnaildirectpath() const; - private: - bool _internal_has_thumbnaildirectpath() const; - public: - void clear_thumbnaildirectpath(); - const std::string& thumbnaildirectpath() const; - template - void set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args); - std::string* mutable_thumbnaildirectpath(); - PROTOBUF_NODISCARD std::string* release_thumbnaildirectpath(); - void set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath); - private: - const std::string& _internal_thumbnaildirectpath() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnaildirectpath(const std::string& value); - std::string* _internal_mutable_thumbnaildirectpath(); - public: - - // optional bytes thumbnailSha256 = 20; - bool has_thumbnailsha256() const; - private: - bool _internal_has_thumbnailsha256() const; - public: - void clear_thumbnailsha256(); - const std::string& thumbnailsha256() const; - template - void set_thumbnailsha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_thumbnailsha256(); - PROTOBUF_NODISCARD std::string* release_thumbnailsha256(); - void set_allocated_thumbnailsha256(std::string* thumbnailsha256); - private: - const std::string& _internal_thumbnailsha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailsha256(const std::string& value); - std::string* _internal_mutable_thumbnailsha256(); - public: - - // optional bytes thumbnailEncSha256 = 21; - bool has_thumbnailencsha256() const; - private: - bool _internal_has_thumbnailencsha256() const; - public: - void clear_thumbnailencsha256(); - const std::string& thumbnailencsha256() const; - template - void set_thumbnailencsha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_thumbnailencsha256(); - PROTOBUF_NODISCARD std::string* release_thumbnailencsha256(); - void set_allocated_thumbnailencsha256(std::string* thumbnailencsha256); - private: - const std::string& _internal_thumbnailencsha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailencsha256(const std::string& value); - std::string* _internal_mutable_thumbnailencsha256(); - public: - - // optional bytes mediaKey = 22; - bool has_mediakey() const; - private: - bool _internal_has_mediakey() const; - public: - void clear_mediakey(); - const std::string& mediakey() const; - template - void set_mediakey(ArgT0&& arg0, ArgT... args); - std::string* mutable_mediakey(); - PROTOBUF_NODISCARD std::string* release_mediakey(); - void set_allocated_mediakey(std::string* mediakey); - private: - const std::string& _internal_mediakey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value); - std::string* _internal_mutable_mediakey(); - public: - - // optional string inviteLinkParentGroupSubjectV2 = 27; - bool has_invitelinkparentgroupsubjectv2() const; - private: - bool _internal_has_invitelinkparentgroupsubjectv2() const; - public: - void clear_invitelinkparentgroupsubjectv2(); - const std::string& invitelinkparentgroupsubjectv2() const; - template - void set_invitelinkparentgroupsubjectv2(ArgT0&& arg0, ArgT... args); - std::string* mutable_invitelinkparentgroupsubjectv2(); - PROTOBUF_NODISCARD std::string* release_invitelinkparentgroupsubjectv2(); - void set_allocated_invitelinkparentgroupsubjectv2(std::string* invitelinkparentgroupsubjectv2); - private: - const std::string& _internal_invitelinkparentgroupsubjectv2() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_invitelinkparentgroupsubjectv2(const std::string& value); - std::string* _internal_mutable_invitelinkparentgroupsubjectv2(); - public: - - // optional bytes inviteLinkParentGroupThumbnailV2 = 28; - bool has_invitelinkparentgroupthumbnailv2() const; - private: - bool _internal_has_invitelinkparentgroupthumbnailv2() const; - public: - void clear_invitelinkparentgroupthumbnailv2(); - const std::string& invitelinkparentgroupthumbnailv2() const; - template - void set_invitelinkparentgroupthumbnailv2(ArgT0&& arg0, ArgT... args); - std::string* mutable_invitelinkparentgroupthumbnailv2(); - PROTOBUF_NODISCARD std::string* release_invitelinkparentgroupthumbnailv2(); - void set_allocated_invitelinkparentgroupthumbnailv2(std::string* invitelinkparentgroupthumbnailv2); - private: - const std::string& _internal_invitelinkparentgroupthumbnailv2() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_invitelinkparentgroupthumbnailv2(const std::string& value); - std::string* _internal_mutable_invitelinkparentgroupthumbnailv2(); - public: - - // optional .proto.ContextInfo contextInfo = 17; - bool has_contextinfo() const; - private: - bool _internal_has_contextinfo() const; - public: - void clear_contextinfo(); - const ::proto::ContextInfo& contextinfo() const; - PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); - ::proto::ContextInfo* mutable_contextinfo(); - void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); - private: - const ::proto::ContextInfo& _internal_contextinfo() const; - ::proto::ContextInfo* _internal_mutable_contextinfo(); - public: - void unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo); - ::proto::ContextInfo* unsafe_arena_release_contextinfo(); - - // optional fixed32 textArgb = 7; - bool has_textargb() const; - private: - bool _internal_has_textargb() const; - public: - void clear_textargb(); - uint32_t textargb() const; - void set_textargb(uint32_t value); - private: - uint32_t _internal_textargb() const; - void _internal_set_textargb(uint32_t value); - public: - - // optional fixed32 backgroundArgb = 8; - bool has_backgroundargb() const; - private: - bool _internal_has_backgroundargb() const; - public: - void clear_backgroundargb(); - uint32_t backgroundargb() const; - void set_backgroundargb(uint32_t value); - private: - uint32_t _internal_backgroundargb() const; - void _internal_set_backgroundargb(uint32_t value); - public: - - // optional .proto.Message.ExtendedTextMessage.FontType font = 9; - bool has_font() const; - private: - bool _internal_has_font() const; - public: - void clear_font(); - ::proto::Message_ExtendedTextMessage_FontType font() const; - void set_font(::proto::Message_ExtendedTextMessage_FontType value); - private: - ::proto::Message_ExtendedTextMessage_FontType _internal_font() const; - void _internal_set_font(::proto::Message_ExtendedTextMessage_FontType value); - public: - - // optional .proto.Message.ExtendedTextMessage.PreviewType previewType = 10; - bool has_previewtype() const; - private: - bool _internal_has_previewtype() const; - public: - void clear_previewtype(); - ::proto::Message_ExtendedTextMessage_PreviewType previewtype() const; - void set_previewtype(::proto::Message_ExtendedTextMessage_PreviewType value); - private: - ::proto::Message_ExtendedTextMessage_PreviewType _internal_previewtype() const; - void _internal_set_previewtype(::proto::Message_ExtendedTextMessage_PreviewType value); - public: - - // optional bool doNotPlayInline = 18; - bool has_donotplayinline() const; - private: - bool _internal_has_donotplayinline() const; - public: - void clear_donotplayinline(); - bool donotplayinline() const; - void set_donotplayinline(bool value); - private: - bool _internal_donotplayinline() const; - void _internal_set_donotplayinline(bool value); - public: - - // optional uint32 thumbnailHeight = 24; - bool has_thumbnailheight() const; - private: - bool _internal_has_thumbnailheight() const; - public: - void clear_thumbnailheight(); - uint32_t thumbnailheight() const; - void set_thumbnailheight(uint32_t value); - private: - uint32_t _internal_thumbnailheight() const; - void _internal_set_thumbnailheight(uint32_t value); - public: - - // optional int64 mediaKeyTimestamp = 23; - bool has_mediakeytimestamp() const; - private: - bool _internal_has_mediakeytimestamp() const; - public: - void clear_mediakeytimestamp(); - int64_t mediakeytimestamp() const; - void set_mediakeytimestamp(int64_t value); - private: - int64_t _internal_mediakeytimestamp() const; - void _internal_set_mediakeytimestamp(int64_t value); - public: - - // optional uint32 thumbnailWidth = 25; - bool has_thumbnailwidth() const; - private: - bool _internal_has_thumbnailwidth() const; - public: - void clear_thumbnailwidth(); - uint32_t thumbnailwidth() const; - void set_thumbnailwidth(uint32_t value); - private: - uint32_t _internal_thumbnailwidth() const; - void _internal_set_thumbnailwidth(uint32_t value); - public: - - // optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupType = 26; - bool has_invitelinkgrouptype() const; - private: - bool _internal_has_invitelinkgrouptype() const; - public: - void clear_invitelinkgrouptype(); - ::proto::Message_ExtendedTextMessage_InviteLinkGroupType invitelinkgrouptype() const; - void set_invitelinkgrouptype(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value); - private: - ::proto::Message_ExtendedTextMessage_InviteLinkGroupType _internal_invitelinkgrouptype() const; - void _internal_set_invitelinkgrouptype(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value); - public: - - // optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupTypeV2 = 29; - bool has_invitelinkgrouptypev2() const; - private: - bool _internal_has_invitelinkgrouptypev2() const; - public: - void clear_invitelinkgrouptypev2(); - ::proto::Message_ExtendedTextMessage_InviteLinkGroupType invitelinkgrouptypev2() const; - void set_invitelinkgrouptypev2(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value); - private: - ::proto::Message_ExtendedTextMessage_InviteLinkGroupType _internal_invitelinkgrouptypev2() const; - void _internal_set_invitelinkgrouptypev2(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.ExtendedTextMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr matchedtext_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr canonicalurl_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnaildirectpath_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailsha256_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailencsha256_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr invitelinkparentgroupsubjectv2_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr invitelinkparentgroupthumbnailv2_; - ::proto::ContextInfo* contextinfo_; - uint32_t textargb_; - uint32_t backgroundargb_; - int font_; - int previewtype_; - bool donotplayinline_; - uint32_t thumbnailheight_; - int64_t mediakeytimestamp_; - uint32_t thumbnailwidth_; - int invitelinkgrouptype_; - int invitelinkgrouptypev2_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_FutureProofMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.FutureProofMessage) */ { - public: - inline Message_FutureProofMessage() : Message_FutureProofMessage(nullptr) {} - ~Message_FutureProofMessage() override; - explicit PROTOBUF_CONSTEXPR Message_FutureProofMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_FutureProofMessage(const Message_FutureProofMessage& from); - Message_FutureProofMessage(Message_FutureProofMessage&& from) noexcept - : Message_FutureProofMessage() { - *this = ::std::move(from); - } - - inline Message_FutureProofMessage& operator=(const Message_FutureProofMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_FutureProofMessage& operator=(Message_FutureProofMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_FutureProofMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_FutureProofMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_FutureProofMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 75; - - friend void swap(Message_FutureProofMessage& a, Message_FutureProofMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_FutureProofMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_FutureProofMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_FutureProofMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_FutureProofMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_FutureProofMessage& from) { - Message_FutureProofMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_FutureProofMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.FutureProofMessage"; - } - protected: - explicit Message_FutureProofMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kMessageFieldNumber = 1, - }; - // optional .proto.Message message = 1; - bool has_message() const; - private: - bool _internal_has_message() const; - public: - void clear_message(); - const ::proto::Message& message() const; - PROTOBUF_NODISCARD ::proto::Message* release_message(); - ::proto::Message* mutable_message(); - void set_allocated_message(::proto::Message* message); - private: - const ::proto::Message& _internal_message() const; - ::proto::Message* _internal_mutable_message(); - public: - void unsafe_arena_set_allocated_message( - ::proto::Message* message); - ::proto::Message* unsafe_arena_release_message(); - - // @@protoc_insertion_point(class_scope:proto.Message.FutureProofMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::proto::Message* message_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_GroupInviteMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.GroupInviteMessage) */ { - public: - inline Message_GroupInviteMessage() : Message_GroupInviteMessage(nullptr) {} - ~Message_GroupInviteMessage() override; - explicit PROTOBUF_CONSTEXPR Message_GroupInviteMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_GroupInviteMessage(const Message_GroupInviteMessage& from); - Message_GroupInviteMessage(Message_GroupInviteMessage&& from) noexcept - : Message_GroupInviteMessage() { - *this = ::std::move(from); - } - - inline Message_GroupInviteMessage& operator=(const Message_GroupInviteMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_GroupInviteMessage& operator=(Message_GroupInviteMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_GroupInviteMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_GroupInviteMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_GroupInviteMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 76; - - friend void swap(Message_GroupInviteMessage& a, Message_GroupInviteMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_GroupInviteMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_GroupInviteMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_GroupInviteMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_GroupInviteMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_GroupInviteMessage& from) { - Message_GroupInviteMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_GroupInviteMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.GroupInviteMessage"; - } - protected: - explicit Message_GroupInviteMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Message_GroupInviteMessage_GroupType GroupType; - static constexpr GroupType DEFAULT = - Message_GroupInviteMessage_GroupType_DEFAULT; - static constexpr GroupType PARENT = - Message_GroupInviteMessage_GroupType_PARENT; - static inline bool GroupType_IsValid(int value) { - return Message_GroupInviteMessage_GroupType_IsValid(value); - } - static constexpr GroupType GroupType_MIN = - Message_GroupInviteMessage_GroupType_GroupType_MIN; - static constexpr GroupType GroupType_MAX = - Message_GroupInviteMessage_GroupType_GroupType_MAX; - static constexpr int GroupType_ARRAYSIZE = - Message_GroupInviteMessage_GroupType_GroupType_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - GroupType_descriptor() { - return Message_GroupInviteMessage_GroupType_descriptor(); - } - template - static inline const std::string& GroupType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function GroupType_Name."); - return Message_GroupInviteMessage_GroupType_Name(enum_t_value); - } - static inline bool GroupType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - GroupType* value) { - return Message_GroupInviteMessage_GroupType_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kGroupJidFieldNumber = 1, - kInviteCodeFieldNumber = 2, - kGroupNameFieldNumber = 4, - kJpegThumbnailFieldNumber = 5, - kCaptionFieldNumber = 6, - kContextInfoFieldNumber = 7, - kInviteExpirationFieldNumber = 3, - kGroupTypeFieldNumber = 8, - }; - // optional string groupJid = 1; - bool has_groupjid() const; - private: - bool _internal_has_groupjid() const; - public: - void clear_groupjid(); - const std::string& groupjid() const; - template - void set_groupjid(ArgT0&& arg0, ArgT... args); - std::string* mutable_groupjid(); - PROTOBUF_NODISCARD std::string* release_groupjid(); - void set_allocated_groupjid(std::string* groupjid); - private: - const std::string& _internal_groupjid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_groupjid(const std::string& value); - std::string* _internal_mutable_groupjid(); - public: - - // optional string inviteCode = 2; - bool has_invitecode() const; - private: - bool _internal_has_invitecode() const; - public: - void clear_invitecode(); - const std::string& invitecode() const; - template - void set_invitecode(ArgT0&& arg0, ArgT... args); - std::string* mutable_invitecode(); - PROTOBUF_NODISCARD std::string* release_invitecode(); - void set_allocated_invitecode(std::string* invitecode); - private: - const std::string& _internal_invitecode() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_invitecode(const std::string& value); - std::string* _internal_mutable_invitecode(); - public: - - // optional string groupName = 4; - bool has_groupname() const; - private: - bool _internal_has_groupname() const; - public: - void clear_groupname(); - const std::string& groupname() const; - template - void set_groupname(ArgT0&& arg0, ArgT... args); - std::string* mutable_groupname(); - PROTOBUF_NODISCARD std::string* release_groupname(); - void set_allocated_groupname(std::string* groupname); - private: - const std::string& _internal_groupname() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_groupname(const std::string& value); - std::string* _internal_mutable_groupname(); - public: - - // optional bytes jpegThumbnail = 5; - bool has_jpegthumbnail() const; - private: - bool _internal_has_jpegthumbnail() const; - public: - void clear_jpegthumbnail(); - const std::string& jpegthumbnail() const; - template - void set_jpegthumbnail(ArgT0&& arg0, ArgT... args); - std::string* mutable_jpegthumbnail(); - PROTOBUF_NODISCARD std::string* release_jpegthumbnail(); - void set_allocated_jpegthumbnail(std::string* jpegthumbnail); - private: - const std::string& _internal_jpegthumbnail() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value); - std::string* _internal_mutable_jpegthumbnail(); - public: - - // optional string caption = 6; - bool has_caption() const; - private: - bool _internal_has_caption() const; - public: - void clear_caption(); - const std::string& caption() const; - template - void set_caption(ArgT0&& arg0, ArgT... args); - std::string* mutable_caption(); - PROTOBUF_NODISCARD std::string* release_caption(); - void set_allocated_caption(std::string* caption); - private: - const std::string& _internal_caption() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_caption(const std::string& value); - std::string* _internal_mutable_caption(); - public: - - // optional .proto.ContextInfo contextInfo = 7; - bool has_contextinfo() const; - private: - bool _internal_has_contextinfo() const; - public: - void clear_contextinfo(); - const ::proto::ContextInfo& contextinfo() const; - PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); - ::proto::ContextInfo* mutable_contextinfo(); - void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); - private: - const ::proto::ContextInfo& _internal_contextinfo() const; - ::proto::ContextInfo* _internal_mutable_contextinfo(); - public: - void unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo); - ::proto::ContextInfo* unsafe_arena_release_contextinfo(); - - // optional int64 inviteExpiration = 3; - bool has_inviteexpiration() const; - private: - bool _internal_has_inviteexpiration() const; - public: - void clear_inviteexpiration(); - int64_t inviteexpiration() const; - void set_inviteexpiration(int64_t value); - private: - int64_t _internal_inviteexpiration() const; - void _internal_set_inviteexpiration(int64_t value); - public: - - // optional .proto.Message.GroupInviteMessage.GroupType groupType = 8; - bool has_grouptype() const; - private: - bool _internal_has_grouptype() const; - public: - void clear_grouptype(); - ::proto::Message_GroupInviteMessage_GroupType grouptype() const; - void set_grouptype(::proto::Message_GroupInviteMessage_GroupType value); - private: - ::proto::Message_GroupInviteMessage_GroupType _internal_grouptype() const; - void _internal_set_grouptype(::proto::Message_GroupInviteMessage_GroupType value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.GroupInviteMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr groupjid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr invitecode_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr groupname_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr caption_; - ::proto::ContextInfo* contextinfo_; - int64_t inviteexpiration_; - int grouptype_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency) */ { - public: - inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency() : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency(nullptr) {} - ~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency() override; - explicit PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& from); - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency&& from) noexcept - : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency() { - *this = ::std::move(from); - } - - inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& operator=(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& from) { - CopyFrom(from); - return *this; - } - inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& operator=(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& default_instance() { - return *internal_default_instance(); - } - static inline const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* internal_default_instance() { - return reinterpret_cast( - &_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency_default_instance_); - } - static constexpr int kIndexInFileMessages = - 77; - - friend void swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& a, Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& b) { - a.Swap(&b); - } - inline void Swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& from) { - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency"; - } - protected: - explicit Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kCurrencyCodeFieldNumber = 1, - kAmount1000FieldNumber = 2, - }; - // optional string currencyCode = 1; - bool has_currencycode() const; - private: - bool _internal_has_currencycode() const; - public: - void clear_currencycode(); - const std::string& currencycode() const; - template - void set_currencycode(ArgT0&& arg0, ArgT... args); - std::string* mutable_currencycode(); - PROTOBUF_NODISCARD std::string* release_currencycode(); - void set_allocated_currencycode(std::string* currencycode); - private: - const std::string& _internal_currencycode() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_currencycode(const std::string& value); - std::string* _internal_mutable_currencycode(); - public: - - // optional int64 amount1000 = 2; - bool has_amount1000() const; - private: - bool _internal_has_amount1000() const; - public: - void clear_amount1000(); - int64_t amount1000() const; - void set_amount1000(int64_t value); - private: - int64_t _internal_amount1000() const; - void _internal_set_amount1000(int64_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr currencycode_; - int64_t amount1000_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent) */ { - public: - inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent() : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent(nullptr) {} - ~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent() override; - explicit PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& from); - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent&& from) noexcept - : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent() { - *this = ::std::move(from); - } - - inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& operator=(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& from) { - CopyFrom(from); - return *this; - } - inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& operator=(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& default_instance() { - return *internal_default_instance(); - } - static inline const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* internal_default_instance() { - return reinterpret_cast( - &_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_default_instance_); - } - static constexpr int kIndexInFileMessages = - 78; - - friend void swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& a, Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& b) { - a.Swap(&b); - } - inline void Swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& from) { - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent"; - } - protected: - explicit Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType CalendarType; - static constexpr CalendarType GREGORIAN = - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_GREGORIAN; - static constexpr CalendarType SOLAR_HIJRI = - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_SOLAR_HIJRI; - static inline bool CalendarType_IsValid(int value) { - return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_IsValid(value); - } - static constexpr CalendarType CalendarType_MIN = - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_CalendarType_MIN; - static constexpr CalendarType CalendarType_MAX = - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_CalendarType_MAX; - static constexpr int CalendarType_ARRAYSIZE = - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_CalendarType_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - CalendarType_descriptor() { - return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_descriptor(); - } - template - static inline const std::string& CalendarType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function CalendarType_Name."); - return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_Name(enum_t_value); - } - static inline bool CalendarType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - CalendarType* value) { - return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_Parse(name, value); - } - - typedef Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType DayOfWeekType; - static constexpr DayOfWeekType MONDAY = - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_MONDAY; - static constexpr DayOfWeekType TUESDAY = - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_TUESDAY; - static constexpr DayOfWeekType WEDNESDAY = - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_WEDNESDAY; - static constexpr DayOfWeekType THURSDAY = - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_THURSDAY; - static constexpr DayOfWeekType FRIDAY = - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_FRIDAY; - static constexpr DayOfWeekType SATURDAY = - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_SATURDAY; - static constexpr DayOfWeekType SUNDAY = - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_SUNDAY; - static inline bool DayOfWeekType_IsValid(int value) { - return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_IsValid(value); - } - static constexpr DayOfWeekType DayOfWeekType_MIN = - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_DayOfWeekType_MIN; - static constexpr DayOfWeekType DayOfWeekType_MAX = - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_DayOfWeekType_MAX; - static constexpr int DayOfWeekType_ARRAYSIZE = - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_DayOfWeekType_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - DayOfWeekType_descriptor() { - return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_descriptor(); - } - template - static inline const std::string& DayOfWeekType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function DayOfWeekType_Name."); - return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_Name(enum_t_value); - } - static inline bool DayOfWeekType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - DayOfWeekType* value) { - return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kYearFieldNumber = 2, - kMonthFieldNumber = 3, - kDayOfMonthFieldNumber = 4, - kHourFieldNumber = 5, - kMinuteFieldNumber = 6, - kDayOfWeekFieldNumber = 1, - kCalendarFieldNumber = 7, - }; - // optional uint32 year = 2; - bool has_year() const; - private: - bool _internal_has_year() const; - public: - void clear_year(); - uint32_t year() const; - void set_year(uint32_t value); - private: - uint32_t _internal_year() const; - void _internal_set_year(uint32_t value); - public: - - // optional uint32 month = 3; - bool has_month() const; - private: - bool _internal_has_month() const; - public: - void clear_month(); - uint32_t month() const; - void set_month(uint32_t value); - private: - uint32_t _internal_month() const; - void _internal_set_month(uint32_t value); - public: - - // optional uint32 dayOfMonth = 4; - bool has_dayofmonth() const; - private: - bool _internal_has_dayofmonth() const; - public: - void clear_dayofmonth(); - uint32_t dayofmonth() const; - void set_dayofmonth(uint32_t value); - private: - uint32_t _internal_dayofmonth() const; - void _internal_set_dayofmonth(uint32_t value); - public: - - // optional uint32 hour = 5; - bool has_hour() const; - private: - bool _internal_has_hour() const; - public: - void clear_hour(); - uint32_t hour() const; - void set_hour(uint32_t value); - private: - uint32_t _internal_hour() const; - void _internal_set_hour(uint32_t value); - public: - - // optional uint32 minute = 6; - bool has_minute() const; - private: - bool _internal_has_minute() const; - public: - void clear_minute(); - uint32_t minute() const; - void set_minute(uint32_t value); - private: - uint32_t _internal_minute() const; - void _internal_set_minute(uint32_t value); - public: - - // optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.DayOfWeekType dayOfWeek = 1; - bool has_dayofweek() const; - private: - bool _internal_has_dayofweek() const; - public: - void clear_dayofweek(); - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType dayofweek() const; - void set_dayofweek(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType value); - private: - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType _internal_dayofweek() const; - void _internal_set_dayofweek(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType value); - public: - - // optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.CalendarType calendar = 7; - bool has_calendar() const; - private: - bool _internal_has_calendar() const; - public: - void clear_calendar(); - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType calendar() const; - void set_calendar(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType value); - private: - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType _internal_calendar() const; - void _internal_set_calendar(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t year_; - uint32_t month_; - uint32_t dayofmonth_; - uint32_t hour_; - uint32_t minute_; - int dayofweek_; - int calendar_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch) */ { - public: - inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch() : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch(nullptr) {} - ~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch() override; - explicit PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& from); - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch&& from) noexcept - : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch() { - *this = ::std::move(from); - } - - inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& operator=(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& from) { - CopyFrom(from); - return *this; - } - inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& operator=(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& default_instance() { - return *internal_default_instance(); - } - static inline const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* internal_default_instance() { - return reinterpret_cast( - &_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch_default_instance_); - } - static constexpr int kIndexInFileMessages = - 79; - - friend void swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& a, Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& b) { - a.Swap(&b); - } - inline void Swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& from) { - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch"; - } - protected: - explicit Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kTimestampFieldNumber = 1, - }; - // optional int64 timestamp = 1; - bool has_timestamp() const; - private: - bool _internal_has_timestamp() const; - public: - void clear_timestamp(); - int64_t timestamp() const; - void set_timestamp(int64_t value); - private: - int64_t _internal_timestamp() const; - void _internal_set_timestamp(int64_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - int64_t timestamp_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime) */ { - public: - inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime() : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime(nullptr) {} - ~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime() override; - explicit PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& from); - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime&& from) noexcept - : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime() { - *this = ::std::move(from); - } - - inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& operator=(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& from) { - CopyFrom(from); - return *this; - } - inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& operator=(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& default_instance() { - return *internal_default_instance(); - } - enum DatetimeOneofCase { - kComponent = 1, - kUnixEpoch = 2, - DATETIMEONEOF_NOT_SET = 0, - }; - - static inline const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* internal_default_instance() { - return reinterpret_cast( - &_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_default_instance_); - } - static constexpr int kIndexInFileMessages = - 80; - - friend void swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& a, Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& b) { - a.Swap(&b); - } - inline void Swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& from) { - Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime"; - } - protected: - explicit Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent HSMDateTimeComponent; - typedef Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch HSMDateTimeUnixEpoch; - - // accessors ------------------------------------------------------- - - enum : int { - kComponentFieldNumber = 1, - kUnixEpochFieldNumber = 2, - }; - // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent component = 1; - bool has_component() const; - private: - bool _internal_has_component() const; - public: - void clear_component(); - const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& component() const; - PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* release_component(); - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* mutable_component(); - void set_allocated_component(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* component); - private: - const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& _internal_component() const; - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* _internal_mutable_component(); - public: - void unsafe_arena_set_allocated_component( - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* component); - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* unsafe_arena_release_component(); - - // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch unixEpoch = 2; - bool has_unixepoch() const; - private: - bool _internal_has_unixepoch() const; - public: - void clear_unixepoch(); - const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& unixepoch() const; - PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* release_unixepoch(); - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* mutable_unixepoch(); - void set_allocated_unixepoch(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* unixepoch); - private: - const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& _internal_unixepoch() const; - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* _internal_mutable_unixepoch(); - public: - void unsafe_arena_set_allocated_unixepoch( - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* unixepoch); - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* unsafe_arena_release_unixepoch(); - - void clear_datetimeOneof(); - DatetimeOneofCase datetimeOneof_case() const; - // @@protoc_insertion_point(class_scope:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime) - private: - class _Internal; - void set_has_component(); - void set_has_unixepoch(); - - inline bool has_datetimeOneof() const; - inline void clear_has_datetimeOneof(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - union DatetimeOneofUnion { - constexpr DatetimeOneofUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* component_; - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* unixepoch_; - } datetimeOneof_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t _oneof_case_[1]; - - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_HighlyStructuredMessage_HSMLocalizableParameter final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter) */ { - public: - inline Message_HighlyStructuredMessage_HSMLocalizableParameter() : Message_HighlyStructuredMessage_HSMLocalizableParameter(nullptr) {} - ~Message_HighlyStructuredMessage_HSMLocalizableParameter() override; - explicit PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_HighlyStructuredMessage_HSMLocalizableParameter(const Message_HighlyStructuredMessage_HSMLocalizableParameter& from); - Message_HighlyStructuredMessage_HSMLocalizableParameter(Message_HighlyStructuredMessage_HSMLocalizableParameter&& from) noexcept - : Message_HighlyStructuredMessage_HSMLocalizableParameter() { - *this = ::std::move(from); - } - - inline Message_HighlyStructuredMessage_HSMLocalizableParameter& operator=(const Message_HighlyStructuredMessage_HSMLocalizableParameter& from) { - CopyFrom(from); - return *this; - } - inline Message_HighlyStructuredMessage_HSMLocalizableParameter& operator=(Message_HighlyStructuredMessage_HSMLocalizableParameter&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_HighlyStructuredMessage_HSMLocalizableParameter& default_instance() { - return *internal_default_instance(); - } - enum ParamOneofCase { - kCurrency = 2, - kDateTime = 3, - PARAMONEOF_NOT_SET = 0, - }; - - static inline const Message_HighlyStructuredMessage_HSMLocalizableParameter* internal_default_instance() { - return reinterpret_cast( - &_Message_HighlyStructuredMessage_HSMLocalizableParameter_default_instance_); - } - static constexpr int kIndexInFileMessages = - 81; - - friend void swap(Message_HighlyStructuredMessage_HSMLocalizableParameter& a, Message_HighlyStructuredMessage_HSMLocalizableParameter& b) { - a.Swap(&b); - } - inline void Swap(Message_HighlyStructuredMessage_HSMLocalizableParameter* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_HighlyStructuredMessage_HSMLocalizableParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_HighlyStructuredMessage_HSMLocalizableParameter& from) { - Message_HighlyStructuredMessage_HSMLocalizableParameter::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter"; - } - protected: - explicit Message_HighlyStructuredMessage_HSMLocalizableParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency HSMCurrency; - typedef Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime HSMDateTime; - - // accessors ------------------------------------------------------- - - enum : int { - kDefaultFieldNumber = 1, - kCurrencyFieldNumber = 2, - kDateTimeFieldNumber = 3, - }; - // optional string default = 1; - bool has_default_() const; - private: - bool _internal_has_default_() const; - public: - void clear_default_(); - const std::string& default_() const; - template - void set_default_(ArgT0&& arg0, ArgT... args); - std::string* mutable_default_(); - PROTOBUF_NODISCARD std::string* release_default_(); - void set_allocated_default_(std::string* default_); - private: - const std::string& _internal_default_() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_default_(const std::string& value); - std::string* _internal_mutable_default_(); - public: - - // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency currency = 2; - bool has_currency() const; - private: - bool _internal_has_currency() const; - public: - void clear_currency(); - const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& currency() const; - PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* release_currency(); - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* mutable_currency(); - void set_allocated_currency(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* currency); - private: - const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& _internal_currency() const; - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* _internal_mutable_currency(); - public: - void unsafe_arena_set_allocated_currency( - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* currency); - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* unsafe_arena_release_currency(); - - // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime dateTime = 3; - bool has_datetime() const; - private: - bool _internal_has_datetime() const; - public: - void clear_datetime(); - const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& datetime() const; - PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* release_datetime(); - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* mutable_datetime(); - void set_allocated_datetime(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* datetime); - private: - const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& _internal_datetime() const; - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* _internal_mutable_datetime(); - public: - void unsafe_arena_set_allocated_datetime( - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* datetime); - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* unsafe_arena_release_datetime(); - - void clear_paramOneof(); - ParamOneofCase paramOneof_case() const; - // @@protoc_insertion_point(class_scope:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter) - private: - class _Internal; - void set_has_currency(); - void set_has_datetime(); - - inline bool has_paramOneof() const; - inline void clear_has_paramOneof(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr default__; - union ParamOneofUnion { - constexpr ParamOneofUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* currency_; - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* datetime_; - } paramOneof_; - uint32_t _oneof_case_[1]; - - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_HighlyStructuredMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.HighlyStructuredMessage) */ { - public: - inline Message_HighlyStructuredMessage() : Message_HighlyStructuredMessage(nullptr) {} - ~Message_HighlyStructuredMessage() override; - explicit PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_HighlyStructuredMessage(const Message_HighlyStructuredMessage& from); - Message_HighlyStructuredMessage(Message_HighlyStructuredMessage&& from) noexcept - : Message_HighlyStructuredMessage() { - *this = ::std::move(from); - } - - inline Message_HighlyStructuredMessage& operator=(const Message_HighlyStructuredMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_HighlyStructuredMessage& operator=(Message_HighlyStructuredMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_HighlyStructuredMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_HighlyStructuredMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_HighlyStructuredMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 82; - - friend void swap(Message_HighlyStructuredMessage& a, Message_HighlyStructuredMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_HighlyStructuredMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_HighlyStructuredMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_HighlyStructuredMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_HighlyStructuredMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_HighlyStructuredMessage& from) { - Message_HighlyStructuredMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_HighlyStructuredMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.HighlyStructuredMessage"; - } - protected: - explicit Message_HighlyStructuredMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Message_HighlyStructuredMessage_HSMLocalizableParameter HSMLocalizableParameter; - - // accessors ------------------------------------------------------- - - enum : int { - kParamsFieldNumber = 3, - kLocalizableParamsFieldNumber = 6, - kNamespaceFieldNumber = 1, - kElementNameFieldNumber = 2, - kFallbackLgFieldNumber = 4, - kFallbackLcFieldNumber = 5, - kDeterministicLgFieldNumber = 7, - kDeterministicLcFieldNumber = 8, - kHydratedHsmFieldNumber = 9, - }; - // repeated string params = 3; - int params_size() const; - private: - int _internal_params_size() const; - public: - void clear_params(); - const std::string& params(int index) const; - std::string* mutable_params(int index); - void set_params(int index, const std::string& value); - void set_params(int index, std::string&& value); - void set_params(int index, const char* value); - void set_params(int index, const char* value, size_t size); - std::string* add_params(); - void add_params(const std::string& value); - void add_params(std::string&& value); - void add_params(const char* value); - void add_params(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& params() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_params(); - private: - const std::string& _internal_params(int index) const; - std::string* _internal_add_params(); - public: - - // repeated .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter localizableParams = 6; - int localizableparams_size() const; - private: - int _internal_localizableparams_size() const; - public: - void clear_localizableparams(); - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* mutable_localizableparams(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter >* - mutable_localizableparams(); - private: - const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter& _internal_localizableparams(int index) const; - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* _internal_add_localizableparams(); - public: - const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter& localizableparams(int index) const; - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* add_localizableparams(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter >& - localizableparams() const; - - // optional string namespace = 1; - bool has_namespace_() const; - private: - bool _internal_has_namespace_() const; - public: - void clear_namespace_(); - const std::string& namespace_() const; - template - void set_namespace_(ArgT0&& arg0, ArgT... args); - std::string* mutable_namespace_(); - PROTOBUF_NODISCARD std::string* release_namespace_(); - void set_allocated_namespace_(std::string* namespace_); - private: - const std::string& _internal_namespace_() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_namespace_(const std::string& value); - std::string* _internal_mutable_namespace_(); - public: - - // optional string elementName = 2; - bool has_elementname() const; - private: - bool _internal_has_elementname() const; - public: - void clear_elementname(); - const std::string& elementname() const; - template - void set_elementname(ArgT0&& arg0, ArgT... args); - std::string* mutable_elementname(); - PROTOBUF_NODISCARD std::string* release_elementname(); - void set_allocated_elementname(std::string* elementname); - private: - const std::string& _internal_elementname() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_elementname(const std::string& value); - std::string* _internal_mutable_elementname(); - public: - - // optional string fallbackLg = 4; - bool has_fallbacklg() const; - private: - bool _internal_has_fallbacklg() const; - public: - void clear_fallbacklg(); - const std::string& fallbacklg() const; - template - void set_fallbacklg(ArgT0&& arg0, ArgT... args); - std::string* mutable_fallbacklg(); - PROTOBUF_NODISCARD std::string* release_fallbacklg(); - void set_allocated_fallbacklg(std::string* fallbacklg); - private: - const std::string& _internal_fallbacklg() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_fallbacklg(const std::string& value); - std::string* _internal_mutable_fallbacklg(); - public: - - // optional string fallbackLc = 5; - bool has_fallbacklc() const; - private: - bool _internal_has_fallbacklc() const; - public: - void clear_fallbacklc(); - const std::string& fallbacklc() const; - template - void set_fallbacklc(ArgT0&& arg0, ArgT... args); - std::string* mutable_fallbacklc(); - PROTOBUF_NODISCARD std::string* release_fallbacklc(); - void set_allocated_fallbacklc(std::string* fallbacklc); - private: - const std::string& _internal_fallbacklc() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_fallbacklc(const std::string& value); - std::string* _internal_mutable_fallbacklc(); - public: - - // optional string deterministicLg = 7; - bool has_deterministiclg() const; - private: - bool _internal_has_deterministiclg() const; - public: - void clear_deterministiclg(); - const std::string& deterministiclg() const; - template - void set_deterministiclg(ArgT0&& arg0, ArgT... args); - std::string* mutable_deterministiclg(); - PROTOBUF_NODISCARD std::string* release_deterministiclg(); - void set_allocated_deterministiclg(std::string* deterministiclg); - private: - const std::string& _internal_deterministiclg() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_deterministiclg(const std::string& value); - std::string* _internal_mutable_deterministiclg(); - public: - - // optional string deterministicLc = 8; - bool has_deterministiclc() const; - private: - bool _internal_has_deterministiclc() const; - public: - void clear_deterministiclc(); - const std::string& deterministiclc() const; - template - void set_deterministiclc(ArgT0&& arg0, ArgT... args); - std::string* mutable_deterministiclc(); - PROTOBUF_NODISCARD std::string* release_deterministiclc(); - void set_allocated_deterministiclc(std::string* deterministiclc); - private: - const std::string& _internal_deterministiclc() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_deterministiclc(const std::string& value); - std::string* _internal_mutable_deterministiclc(); - public: - - // optional .proto.Message.TemplateMessage hydratedHsm = 9; - bool has_hydratedhsm() const; - private: - bool _internal_has_hydratedhsm() const; - public: - void clear_hydratedhsm(); - const ::proto::Message_TemplateMessage& hydratedhsm() const; - PROTOBUF_NODISCARD ::proto::Message_TemplateMessage* release_hydratedhsm(); - ::proto::Message_TemplateMessage* mutable_hydratedhsm(); - void set_allocated_hydratedhsm(::proto::Message_TemplateMessage* hydratedhsm); - private: - const ::proto::Message_TemplateMessage& _internal_hydratedhsm() const; - ::proto::Message_TemplateMessage* _internal_mutable_hydratedhsm(); - public: - void unsafe_arena_set_allocated_hydratedhsm( - ::proto::Message_TemplateMessage* hydratedhsm); - ::proto::Message_TemplateMessage* unsafe_arena_release_hydratedhsm(); - - // @@protoc_insertion_point(class_scope:proto.Message.HighlyStructuredMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField params_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter > localizableparams_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr namespace__; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr elementname_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fallbacklg_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fallbacklc_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr deterministiclg_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr deterministiclc_; - ::proto::Message_TemplateMessage* hydratedhsm_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_HistorySyncNotification final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.HistorySyncNotification) */ { - public: - inline Message_HistorySyncNotification() : Message_HistorySyncNotification(nullptr) {} - ~Message_HistorySyncNotification() override; - explicit PROTOBUF_CONSTEXPR Message_HistorySyncNotification(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_HistorySyncNotification(const Message_HistorySyncNotification& from); - Message_HistorySyncNotification(Message_HistorySyncNotification&& from) noexcept - : Message_HistorySyncNotification() { - *this = ::std::move(from); - } - - inline Message_HistorySyncNotification& operator=(const Message_HistorySyncNotification& from) { - CopyFrom(from); - return *this; - } - inline Message_HistorySyncNotification& operator=(Message_HistorySyncNotification&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_HistorySyncNotification& default_instance() { - return *internal_default_instance(); - } - static inline const Message_HistorySyncNotification* internal_default_instance() { - return reinterpret_cast( - &_Message_HistorySyncNotification_default_instance_); - } - static constexpr int kIndexInFileMessages = - 83; - - friend void swap(Message_HistorySyncNotification& a, Message_HistorySyncNotification& b) { - a.Swap(&b); - } - inline void Swap(Message_HistorySyncNotification* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_HistorySyncNotification* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_HistorySyncNotification* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_HistorySyncNotification& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_HistorySyncNotification& from) { - Message_HistorySyncNotification::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_HistorySyncNotification* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.HistorySyncNotification"; - } - protected: - explicit Message_HistorySyncNotification(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Message_HistorySyncNotification_HistorySyncType HistorySyncType; - static constexpr HistorySyncType INITIAL_BOOTSTRAP = - Message_HistorySyncNotification_HistorySyncType_INITIAL_BOOTSTRAP; - static constexpr HistorySyncType INITIAL_STATUS_V3 = - Message_HistorySyncNotification_HistorySyncType_INITIAL_STATUS_V3; - static constexpr HistorySyncType FULL = - Message_HistorySyncNotification_HistorySyncType_FULL; - static constexpr HistorySyncType RECENT = - Message_HistorySyncNotification_HistorySyncType_RECENT; - static constexpr HistorySyncType PUSH_NAME = - Message_HistorySyncNotification_HistorySyncType_PUSH_NAME; - static inline bool HistorySyncType_IsValid(int value) { - return Message_HistorySyncNotification_HistorySyncType_IsValid(value); - } - static constexpr HistorySyncType HistorySyncType_MIN = - Message_HistorySyncNotification_HistorySyncType_HistorySyncType_MIN; - static constexpr HistorySyncType HistorySyncType_MAX = - Message_HistorySyncNotification_HistorySyncType_HistorySyncType_MAX; - static constexpr int HistorySyncType_ARRAYSIZE = - Message_HistorySyncNotification_HistorySyncType_HistorySyncType_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - HistorySyncType_descriptor() { - return Message_HistorySyncNotification_HistorySyncType_descriptor(); - } - template - static inline const std::string& HistorySyncType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function HistorySyncType_Name."); - return Message_HistorySyncNotification_HistorySyncType_Name(enum_t_value); - } - static inline bool HistorySyncType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - HistorySyncType* value) { - return Message_HistorySyncNotification_HistorySyncType_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kFileSha256FieldNumber = 1, - kMediaKeyFieldNumber = 3, - kFileEncSha256FieldNumber = 4, - kDirectPathFieldNumber = 5, - kOriginalMessageIdFieldNumber = 8, - kFileLengthFieldNumber = 2, - kSyncTypeFieldNumber = 6, - kChunkOrderFieldNumber = 7, - kProgressFieldNumber = 9, - }; - // optional bytes fileSha256 = 1; - bool has_filesha256() const; - private: - bool _internal_has_filesha256() const; - public: - void clear_filesha256(); - const std::string& filesha256() const; - template - void set_filesha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_filesha256(); - PROTOBUF_NODISCARD std::string* release_filesha256(); - void set_allocated_filesha256(std::string* filesha256); - private: - const std::string& _internal_filesha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value); - std::string* _internal_mutable_filesha256(); - public: - - // optional bytes mediaKey = 3; - bool has_mediakey() const; - private: - bool _internal_has_mediakey() const; - public: - void clear_mediakey(); - const std::string& mediakey() const; - template - void set_mediakey(ArgT0&& arg0, ArgT... args); - std::string* mutable_mediakey(); - PROTOBUF_NODISCARD std::string* release_mediakey(); - void set_allocated_mediakey(std::string* mediakey); - private: - const std::string& _internal_mediakey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value); - std::string* _internal_mutable_mediakey(); - public: - - // optional bytes fileEncSha256 = 4; - bool has_fileencsha256() const; - private: - bool _internal_has_fileencsha256() const; - public: - void clear_fileencsha256(); - const std::string& fileencsha256() const; - template - void set_fileencsha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_fileencsha256(); - PROTOBUF_NODISCARD std::string* release_fileencsha256(); - void set_allocated_fileencsha256(std::string* fileencsha256); - private: - const std::string& _internal_fileencsha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value); - std::string* _internal_mutable_fileencsha256(); - public: - - // optional string directPath = 5; - bool has_directpath() const; - private: - bool _internal_has_directpath() const; - public: - void clear_directpath(); - const std::string& directpath() const; - template - void set_directpath(ArgT0&& arg0, ArgT... args); - std::string* mutable_directpath(); - PROTOBUF_NODISCARD std::string* release_directpath(); - void set_allocated_directpath(std::string* directpath); - private: - const std::string& _internal_directpath() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value); - std::string* _internal_mutable_directpath(); - public: - - // optional string originalMessageId = 8; - bool has_originalmessageid() const; - private: - bool _internal_has_originalmessageid() const; - public: - void clear_originalmessageid(); - const std::string& originalmessageid() const; - template - void set_originalmessageid(ArgT0&& arg0, ArgT... args); - std::string* mutable_originalmessageid(); - PROTOBUF_NODISCARD std::string* release_originalmessageid(); - void set_allocated_originalmessageid(std::string* originalmessageid); - private: - const std::string& _internal_originalmessageid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_originalmessageid(const std::string& value); - std::string* _internal_mutable_originalmessageid(); - public: - - // optional uint64 fileLength = 2; - bool has_filelength() const; - private: - bool _internal_has_filelength() const; - public: - void clear_filelength(); - uint64_t filelength() const; - void set_filelength(uint64_t value); - private: - uint64_t _internal_filelength() const; - void _internal_set_filelength(uint64_t value); - public: - - // optional .proto.Message.HistorySyncNotification.HistorySyncType syncType = 6; - bool has_synctype() const; - private: - bool _internal_has_synctype() const; - public: - void clear_synctype(); - ::proto::Message_HistorySyncNotification_HistorySyncType synctype() const; - void set_synctype(::proto::Message_HistorySyncNotification_HistorySyncType value); - private: - ::proto::Message_HistorySyncNotification_HistorySyncType _internal_synctype() const; - void _internal_set_synctype(::proto::Message_HistorySyncNotification_HistorySyncType value); - public: - - // optional uint32 chunkOrder = 7; - bool has_chunkorder() const; - private: - bool _internal_has_chunkorder() const; - public: - void clear_chunkorder(); - uint32_t chunkorder() const; - void set_chunkorder(uint32_t value); - private: - uint32_t _internal_chunkorder() const; - void _internal_set_chunkorder(uint32_t value); - public: - - // optional uint32 progress = 9; - bool has_progress() const; - private: - bool _internal_has_progress() const; - public: - void clear_progress(); - uint32_t progress() const; - void set_progress(uint32_t value); - private: - uint32_t _internal_progress() const; - void _internal_set_progress(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.HistorySyncNotification) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr originalmessageid_; - uint64_t filelength_; - int synctype_; - uint32_t chunkorder_; - uint32_t progress_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_ImageMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ImageMessage) */ { - public: - inline Message_ImageMessage() : Message_ImageMessage(nullptr) {} - ~Message_ImageMessage() override; - explicit PROTOBUF_CONSTEXPR Message_ImageMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_ImageMessage(const Message_ImageMessage& from); - Message_ImageMessage(Message_ImageMessage&& from) noexcept - : Message_ImageMessage() { - *this = ::std::move(from); - } - - inline Message_ImageMessage& operator=(const Message_ImageMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_ImageMessage& operator=(Message_ImageMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_ImageMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_ImageMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_ImageMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 84; - - friend void swap(Message_ImageMessage& a, Message_ImageMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_ImageMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_ImageMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_ImageMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_ImageMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_ImageMessage& from) { - Message_ImageMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_ImageMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.ImageMessage"; - } - protected: - explicit Message_ImageMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kInteractiveAnnotationsFieldNumber = 10, - kScanLengthsFieldNumber = 22, - kUrlFieldNumber = 1, - kMimetypeFieldNumber = 2, - kCaptionFieldNumber = 3, - kFileSha256FieldNumber = 4, - kMediaKeyFieldNumber = 8, - kFileEncSha256FieldNumber = 9, - kDirectPathFieldNumber = 11, - kJpegThumbnailFieldNumber = 16, - kFirstScanSidecarFieldNumber = 18, - kScansSidecarFieldNumber = 21, - kMidQualityFileSha256FieldNumber = 23, - kMidQualityFileEncSha256FieldNumber = 24, - kThumbnailDirectPathFieldNumber = 26, - kThumbnailSha256FieldNumber = 27, - kThumbnailEncSha256FieldNumber = 28, - kStaticUrlFieldNumber = 29, - kContextInfoFieldNumber = 17, - kFileLengthFieldNumber = 5, - kHeightFieldNumber = 6, - kWidthFieldNumber = 7, - kMediaKeyTimestampFieldNumber = 12, - kFirstScanLengthFieldNumber = 19, - kExperimentGroupIdFieldNumber = 20, - kViewOnceFieldNumber = 25, - }; - // repeated .proto.InteractiveAnnotation interactiveAnnotations = 10; - int interactiveannotations_size() const; - private: - int _internal_interactiveannotations_size() const; - public: - void clear_interactiveannotations(); - ::proto::InteractiveAnnotation* mutable_interactiveannotations(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >* - mutable_interactiveannotations(); - private: - const ::proto::InteractiveAnnotation& _internal_interactiveannotations(int index) const; - ::proto::InteractiveAnnotation* _internal_add_interactiveannotations(); - public: - const ::proto::InteractiveAnnotation& interactiveannotations(int index) const; - ::proto::InteractiveAnnotation* add_interactiveannotations(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >& - interactiveannotations() const; - - // repeated uint32 scanLengths = 22; - int scanlengths_size() const; - private: - int _internal_scanlengths_size() const; - public: - void clear_scanlengths(); - private: - uint32_t _internal_scanlengths(int index) const; - const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& - _internal_scanlengths() const; - void _internal_add_scanlengths(uint32_t value); - ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* - _internal_mutable_scanlengths(); - public: - uint32_t scanlengths(int index) const; - void set_scanlengths(int index, uint32_t value); - void add_scanlengths(uint32_t value); - const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& - scanlengths() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* - mutable_scanlengths(); - - // optional string url = 1; - bool has_url() const; - private: - bool _internal_has_url() const; - public: - void clear_url(); - const std::string& url() const; - template - void set_url(ArgT0&& arg0, ArgT... args); - std::string* mutable_url(); - PROTOBUF_NODISCARD std::string* release_url(); - void set_allocated_url(std::string* url); - private: - const std::string& _internal_url() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value); - std::string* _internal_mutable_url(); - public: - - // optional string mimetype = 2; - bool has_mimetype() const; - private: - bool _internal_has_mimetype() const; - public: - void clear_mimetype(); - const std::string& mimetype() const; - template - void set_mimetype(ArgT0&& arg0, ArgT... args); - std::string* mutable_mimetype(); - PROTOBUF_NODISCARD std::string* release_mimetype(); - void set_allocated_mimetype(std::string* mimetype); - private: - const std::string& _internal_mimetype() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value); - std::string* _internal_mutable_mimetype(); - public: - - // optional string caption = 3; - bool has_caption() const; - private: - bool _internal_has_caption() const; - public: - void clear_caption(); - const std::string& caption() const; - template - void set_caption(ArgT0&& arg0, ArgT... args); - std::string* mutable_caption(); - PROTOBUF_NODISCARD std::string* release_caption(); - void set_allocated_caption(std::string* caption); - private: - const std::string& _internal_caption() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_caption(const std::string& value); - std::string* _internal_mutable_caption(); - public: - - // optional bytes fileSha256 = 4; - bool has_filesha256() const; - private: - bool _internal_has_filesha256() const; - public: - void clear_filesha256(); - const std::string& filesha256() const; - template - void set_filesha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_filesha256(); - PROTOBUF_NODISCARD std::string* release_filesha256(); - void set_allocated_filesha256(std::string* filesha256); - private: - const std::string& _internal_filesha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value); - std::string* _internal_mutable_filesha256(); - public: - - // optional bytes mediaKey = 8; - bool has_mediakey() const; - private: - bool _internal_has_mediakey() const; - public: - void clear_mediakey(); - const std::string& mediakey() const; - template - void set_mediakey(ArgT0&& arg0, ArgT... args); - std::string* mutable_mediakey(); - PROTOBUF_NODISCARD std::string* release_mediakey(); - void set_allocated_mediakey(std::string* mediakey); - private: - const std::string& _internal_mediakey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value); - std::string* _internal_mutable_mediakey(); - public: - - // optional bytes fileEncSha256 = 9; - bool has_fileencsha256() const; - private: - bool _internal_has_fileencsha256() const; - public: - void clear_fileencsha256(); - const std::string& fileencsha256() const; - template - void set_fileencsha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_fileencsha256(); - PROTOBUF_NODISCARD std::string* release_fileencsha256(); - void set_allocated_fileencsha256(std::string* fileencsha256); - private: - const std::string& _internal_fileencsha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value); - std::string* _internal_mutable_fileencsha256(); - public: - - // optional string directPath = 11; - bool has_directpath() const; - private: - bool _internal_has_directpath() const; - public: - void clear_directpath(); - const std::string& directpath() const; - template - void set_directpath(ArgT0&& arg0, ArgT... args); - std::string* mutable_directpath(); - PROTOBUF_NODISCARD std::string* release_directpath(); - void set_allocated_directpath(std::string* directpath); - private: - const std::string& _internal_directpath() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value); - std::string* _internal_mutable_directpath(); - public: - - // optional bytes jpegThumbnail = 16; - bool has_jpegthumbnail() const; - private: - bool _internal_has_jpegthumbnail() const; - public: - void clear_jpegthumbnail(); - const std::string& jpegthumbnail() const; - template - void set_jpegthumbnail(ArgT0&& arg0, ArgT... args); - std::string* mutable_jpegthumbnail(); - PROTOBUF_NODISCARD std::string* release_jpegthumbnail(); - void set_allocated_jpegthumbnail(std::string* jpegthumbnail); - private: - const std::string& _internal_jpegthumbnail() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value); - std::string* _internal_mutable_jpegthumbnail(); - public: - - // optional bytes firstScanSidecar = 18; - bool has_firstscansidecar() const; - private: - bool _internal_has_firstscansidecar() const; - public: - void clear_firstscansidecar(); - const std::string& firstscansidecar() const; - template - void set_firstscansidecar(ArgT0&& arg0, ArgT... args); - std::string* mutable_firstscansidecar(); - PROTOBUF_NODISCARD std::string* release_firstscansidecar(); - void set_allocated_firstscansidecar(std::string* firstscansidecar); - private: - const std::string& _internal_firstscansidecar() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_firstscansidecar(const std::string& value); - std::string* _internal_mutable_firstscansidecar(); - public: - - // optional bytes scansSidecar = 21; - bool has_scanssidecar() const; - private: - bool _internal_has_scanssidecar() const; - public: - void clear_scanssidecar(); - const std::string& scanssidecar() const; - template - void set_scanssidecar(ArgT0&& arg0, ArgT... args); - std::string* mutable_scanssidecar(); - PROTOBUF_NODISCARD std::string* release_scanssidecar(); - void set_allocated_scanssidecar(std::string* scanssidecar); - private: - const std::string& _internal_scanssidecar() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_scanssidecar(const std::string& value); - std::string* _internal_mutable_scanssidecar(); - public: - - // optional bytes midQualityFileSha256 = 23; - bool has_midqualityfilesha256() const; - private: - bool _internal_has_midqualityfilesha256() const; - public: - void clear_midqualityfilesha256(); - const std::string& midqualityfilesha256() const; - template - void set_midqualityfilesha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_midqualityfilesha256(); - PROTOBUF_NODISCARD std::string* release_midqualityfilesha256(); - void set_allocated_midqualityfilesha256(std::string* midqualityfilesha256); - private: - const std::string& _internal_midqualityfilesha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_midqualityfilesha256(const std::string& value); - std::string* _internal_mutable_midqualityfilesha256(); - public: - - // optional bytes midQualityFileEncSha256 = 24; - bool has_midqualityfileencsha256() const; - private: - bool _internal_has_midqualityfileencsha256() const; - public: - void clear_midqualityfileencsha256(); - const std::string& midqualityfileencsha256() const; - template - void set_midqualityfileencsha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_midqualityfileencsha256(); - PROTOBUF_NODISCARD std::string* release_midqualityfileencsha256(); - void set_allocated_midqualityfileencsha256(std::string* midqualityfileencsha256); - private: - const std::string& _internal_midqualityfileencsha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_midqualityfileencsha256(const std::string& value); - std::string* _internal_mutable_midqualityfileencsha256(); - public: - - // optional string thumbnailDirectPath = 26; - bool has_thumbnaildirectpath() const; - private: - bool _internal_has_thumbnaildirectpath() const; - public: - void clear_thumbnaildirectpath(); - const std::string& thumbnaildirectpath() const; - template - void set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args); - std::string* mutable_thumbnaildirectpath(); - PROTOBUF_NODISCARD std::string* release_thumbnaildirectpath(); - void set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath); - private: - const std::string& _internal_thumbnaildirectpath() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnaildirectpath(const std::string& value); - std::string* _internal_mutable_thumbnaildirectpath(); - public: - - // optional bytes thumbnailSha256 = 27; - bool has_thumbnailsha256() const; - private: - bool _internal_has_thumbnailsha256() const; - public: - void clear_thumbnailsha256(); - const std::string& thumbnailsha256() const; - template - void set_thumbnailsha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_thumbnailsha256(); - PROTOBUF_NODISCARD std::string* release_thumbnailsha256(); - void set_allocated_thumbnailsha256(std::string* thumbnailsha256); - private: - const std::string& _internal_thumbnailsha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailsha256(const std::string& value); - std::string* _internal_mutable_thumbnailsha256(); - public: - - // optional bytes thumbnailEncSha256 = 28; - bool has_thumbnailencsha256() const; - private: - bool _internal_has_thumbnailencsha256() const; - public: - void clear_thumbnailencsha256(); - const std::string& thumbnailencsha256() const; - template - void set_thumbnailencsha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_thumbnailencsha256(); - PROTOBUF_NODISCARD std::string* release_thumbnailencsha256(); - void set_allocated_thumbnailencsha256(std::string* thumbnailencsha256); - private: - const std::string& _internal_thumbnailencsha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailencsha256(const std::string& value); - std::string* _internal_mutable_thumbnailencsha256(); - public: - - // optional string staticUrl = 29; - bool has_staticurl() const; - private: - bool _internal_has_staticurl() const; - public: - void clear_staticurl(); - const std::string& staticurl() const; - template - void set_staticurl(ArgT0&& arg0, ArgT... args); - std::string* mutable_staticurl(); - PROTOBUF_NODISCARD std::string* release_staticurl(); - void set_allocated_staticurl(std::string* staticurl); - private: - const std::string& _internal_staticurl() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_staticurl(const std::string& value); - std::string* _internal_mutable_staticurl(); - public: - - // optional .proto.ContextInfo contextInfo = 17; - bool has_contextinfo() const; - private: - bool _internal_has_contextinfo() const; - public: - void clear_contextinfo(); - const ::proto::ContextInfo& contextinfo() const; - PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); - ::proto::ContextInfo* mutable_contextinfo(); - void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); - private: - const ::proto::ContextInfo& _internal_contextinfo() const; - ::proto::ContextInfo* _internal_mutable_contextinfo(); - public: - void unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo); - ::proto::ContextInfo* unsafe_arena_release_contextinfo(); - - // optional uint64 fileLength = 5; - bool has_filelength() const; - private: - bool _internal_has_filelength() const; - public: - void clear_filelength(); - uint64_t filelength() const; - void set_filelength(uint64_t value); - private: - uint64_t _internal_filelength() const; - void _internal_set_filelength(uint64_t value); - public: - - // optional uint32 height = 6; - bool has_height() const; - private: - bool _internal_has_height() const; - public: - void clear_height(); - uint32_t height() const; - void set_height(uint32_t value); - private: - uint32_t _internal_height() const; - void _internal_set_height(uint32_t value); - public: - - // optional uint32 width = 7; - bool has_width() const; - private: - bool _internal_has_width() const; - public: - void clear_width(); - uint32_t width() const; - void set_width(uint32_t value); - private: - uint32_t _internal_width() const; - void _internal_set_width(uint32_t value); - public: - - // optional int64 mediaKeyTimestamp = 12; - bool has_mediakeytimestamp() const; - private: - bool _internal_has_mediakeytimestamp() const; - public: - void clear_mediakeytimestamp(); - int64_t mediakeytimestamp() const; - void set_mediakeytimestamp(int64_t value); - private: - int64_t _internal_mediakeytimestamp() const; - void _internal_set_mediakeytimestamp(int64_t value); - public: - - // optional uint32 firstScanLength = 19; - bool has_firstscanlength() const; - private: - bool _internal_has_firstscanlength() const; - public: - void clear_firstscanlength(); - uint32_t firstscanlength() const; - void set_firstscanlength(uint32_t value); - private: - uint32_t _internal_firstscanlength() const; - void _internal_set_firstscanlength(uint32_t value); - public: - - // optional uint32 experimentGroupId = 20; - bool has_experimentgroupid() const; - private: - bool _internal_has_experimentgroupid() const; - public: - void clear_experimentgroupid(); - uint32_t experimentgroupid() const; - void set_experimentgroupid(uint32_t value); - private: - uint32_t _internal_experimentgroupid() const; - void _internal_set_experimentgroupid(uint32_t value); - public: - - // optional bool viewOnce = 25; - bool has_viewonce() const; - private: - bool _internal_has_viewonce() const; - public: - void clear_viewonce(); - bool viewonce() const; - void set_viewonce(bool value); - private: - bool _internal_viewonce() const; - void _internal_set_viewonce(bool value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.ImageMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation > interactiveannotations_; - ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > scanlengths_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mimetype_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr caption_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr firstscansidecar_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr scanssidecar_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr midqualityfilesha256_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr midqualityfileencsha256_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnaildirectpath_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailsha256_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailencsha256_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr staticurl_; - ::proto::ContextInfo* contextinfo_; - uint64_t filelength_; - uint32_t height_; - uint32_t width_; - int64_t mediakeytimestamp_; - uint32_t firstscanlength_; - uint32_t experimentgroupid_; - bool viewonce_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_InitialSecurityNotificationSettingSync final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InitialSecurityNotificationSettingSync) */ { - public: - inline Message_InitialSecurityNotificationSettingSync() : Message_InitialSecurityNotificationSettingSync(nullptr) {} - ~Message_InitialSecurityNotificationSettingSync() override; - explicit PROTOBUF_CONSTEXPR Message_InitialSecurityNotificationSettingSync(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_InitialSecurityNotificationSettingSync(const Message_InitialSecurityNotificationSettingSync& from); - Message_InitialSecurityNotificationSettingSync(Message_InitialSecurityNotificationSettingSync&& from) noexcept - : Message_InitialSecurityNotificationSettingSync() { - *this = ::std::move(from); - } - - inline Message_InitialSecurityNotificationSettingSync& operator=(const Message_InitialSecurityNotificationSettingSync& from) { - CopyFrom(from); - return *this; - } - inline Message_InitialSecurityNotificationSettingSync& operator=(Message_InitialSecurityNotificationSettingSync&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_InitialSecurityNotificationSettingSync& default_instance() { - return *internal_default_instance(); - } - static inline const Message_InitialSecurityNotificationSettingSync* internal_default_instance() { - return reinterpret_cast( - &_Message_InitialSecurityNotificationSettingSync_default_instance_); - } - static constexpr int kIndexInFileMessages = - 85; - - friend void swap(Message_InitialSecurityNotificationSettingSync& a, Message_InitialSecurityNotificationSettingSync& b) { - a.Swap(&b); - } - inline void Swap(Message_InitialSecurityNotificationSettingSync* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_InitialSecurityNotificationSettingSync* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_InitialSecurityNotificationSettingSync* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_InitialSecurityNotificationSettingSync& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_InitialSecurityNotificationSettingSync& from) { - Message_InitialSecurityNotificationSettingSync::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_InitialSecurityNotificationSettingSync* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.InitialSecurityNotificationSettingSync"; - } - protected: - explicit Message_InitialSecurityNotificationSettingSync(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kSecurityNotificationEnabledFieldNumber = 1, - }; - // optional bool securityNotificationEnabled = 1; - bool has_securitynotificationenabled() const; - private: - bool _internal_has_securitynotificationenabled() const; - public: - void clear_securitynotificationenabled(); - bool securitynotificationenabled() const; - void set_securitynotificationenabled(bool value); - private: - bool _internal_securitynotificationenabled() const; - void _internal_set_securitynotificationenabled(bool value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.InitialSecurityNotificationSettingSync) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - bool securitynotificationenabled_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_InteractiveMessage_Body final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage.Body) */ { - public: - inline Message_InteractiveMessage_Body() : Message_InteractiveMessage_Body(nullptr) {} - ~Message_InteractiveMessage_Body() override; - explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage_Body(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_InteractiveMessage_Body(const Message_InteractiveMessage_Body& from); - Message_InteractiveMessage_Body(Message_InteractiveMessage_Body&& from) noexcept - : Message_InteractiveMessage_Body() { - *this = ::std::move(from); - } - - inline Message_InteractiveMessage_Body& operator=(const Message_InteractiveMessage_Body& from) { - CopyFrom(from); - return *this; - } - inline Message_InteractiveMessage_Body& operator=(Message_InteractiveMessage_Body&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_InteractiveMessage_Body& default_instance() { - return *internal_default_instance(); - } - static inline const Message_InteractiveMessage_Body* internal_default_instance() { - return reinterpret_cast( - &_Message_InteractiveMessage_Body_default_instance_); - } - static constexpr int kIndexInFileMessages = - 86; - - friend void swap(Message_InteractiveMessage_Body& a, Message_InteractiveMessage_Body& b) { - a.Swap(&b); - } - inline void Swap(Message_InteractiveMessage_Body* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_InteractiveMessage_Body* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_InteractiveMessage_Body* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_InteractiveMessage_Body& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_InteractiveMessage_Body& from) { - Message_InteractiveMessage_Body::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_InteractiveMessage_Body* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.InteractiveMessage.Body"; - } - protected: - explicit Message_InteractiveMessage_Body(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kTextFieldNumber = 1, - }; - // optional string text = 1; - bool has_text() const; - private: - bool _internal_has_text() const; - public: - void clear_text(); - const std::string& text() const; - template - void set_text(ArgT0&& arg0, ArgT... args); - std::string* mutable_text(); - PROTOBUF_NODISCARD std::string* release_text(); - void set_allocated_text(std::string* text); - private: - const std::string& _internal_text() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value); - std::string* _internal_mutable_text(); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage.Body) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_InteractiveMessage_CollectionMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage.CollectionMessage) */ { - public: - inline Message_InteractiveMessage_CollectionMessage() : Message_InteractiveMessage_CollectionMessage(nullptr) {} - ~Message_InteractiveMessage_CollectionMessage() override; - explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage_CollectionMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_InteractiveMessage_CollectionMessage(const Message_InteractiveMessage_CollectionMessage& from); - Message_InteractiveMessage_CollectionMessage(Message_InteractiveMessage_CollectionMessage&& from) noexcept - : Message_InteractiveMessage_CollectionMessage() { - *this = ::std::move(from); - } - - inline Message_InteractiveMessage_CollectionMessage& operator=(const Message_InteractiveMessage_CollectionMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_InteractiveMessage_CollectionMessage& operator=(Message_InteractiveMessage_CollectionMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_InteractiveMessage_CollectionMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_InteractiveMessage_CollectionMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_InteractiveMessage_CollectionMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 87; - - friend void swap(Message_InteractiveMessage_CollectionMessage& a, Message_InteractiveMessage_CollectionMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_InteractiveMessage_CollectionMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_InteractiveMessage_CollectionMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_InteractiveMessage_CollectionMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_InteractiveMessage_CollectionMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_InteractiveMessage_CollectionMessage& from) { - Message_InteractiveMessage_CollectionMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_InteractiveMessage_CollectionMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.InteractiveMessage.CollectionMessage"; - } - protected: - explicit Message_InteractiveMessage_CollectionMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kBizJidFieldNumber = 1, - kIdFieldNumber = 2, - kMessageVersionFieldNumber = 3, - }; - // optional string bizJid = 1; - bool has_bizjid() const; - private: - bool _internal_has_bizjid() const; - public: - void clear_bizjid(); - const std::string& bizjid() const; - template - void set_bizjid(ArgT0&& arg0, ArgT... args); - std::string* mutable_bizjid(); - PROTOBUF_NODISCARD std::string* release_bizjid(); - void set_allocated_bizjid(std::string* bizjid); - private: - const std::string& _internal_bizjid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_bizjid(const std::string& value); - std::string* _internal_mutable_bizjid(); - public: - - // optional string id = 2; - bool has_id() const; - private: - bool _internal_has_id() const; - public: - void clear_id(); - const std::string& id() const; - template - void set_id(ArgT0&& arg0, ArgT... args); - std::string* mutable_id(); - PROTOBUF_NODISCARD std::string* release_id(); - void set_allocated_id(std::string* id); - private: - const std::string& _internal_id() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value); - std::string* _internal_mutable_id(); - public: - - // optional int32 messageVersion = 3; - bool has_messageversion() const; - private: - bool _internal_has_messageversion() const; - public: - void clear_messageversion(); - int32_t messageversion() const; - void set_messageversion(int32_t value); - private: - int32_t _internal_messageversion() const; - void _internal_set_messageversion(int32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage.CollectionMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bizjid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_; - int32_t messageversion_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_InteractiveMessage_Footer final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage.Footer) */ { - public: - inline Message_InteractiveMessage_Footer() : Message_InteractiveMessage_Footer(nullptr) {} - ~Message_InteractiveMessage_Footer() override; - explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage_Footer(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_InteractiveMessage_Footer(const Message_InteractiveMessage_Footer& from); - Message_InteractiveMessage_Footer(Message_InteractiveMessage_Footer&& from) noexcept - : Message_InteractiveMessage_Footer() { - *this = ::std::move(from); - } - - inline Message_InteractiveMessage_Footer& operator=(const Message_InteractiveMessage_Footer& from) { - CopyFrom(from); - return *this; - } - inline Message_InteractiveMessage_Footer& operator=(Message_InteractiveMessage_Footer&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_InteractiveMessage_Footer& default_instance() { - return *internal_default_instance(); - } - static inline const Message_InteractiveMessage_Footer* internal_default_instance() { - return reinterpret_cast( - &_Message_InteractiveMessage_Footer_default_instance_); - } - static constexpr int kIndexInFileMessages = - 88; - - friend void swap(Message_InteractiveMessage_Footer& a, Message_InteractiveMessage_Footer& b) { - a.Swap(&b); - } - inline void Swap(Message_InteractiveMessage_Footer* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_InteractiveMessage_Footer* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_InteractiveMessage_Footer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_InteractiveMessage_Footer& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_InteractiveMessage_Footer& from) { - Message_InteractiveMessage_Footer::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_InteractiveMessage_Footer* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.InteractiveMessage.Footer"; - } - protected: - explicit Message_InteractiveMessage_Footer(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kTextFieldNumber = 1, - }; - // optional string text = 1; - bool has_text() const; - private: - bool _internal_has_text() const; - public: - void clear_text(); - const std::string& text() const; - template - void set_text(ArgT0&& arg0, ArgT... args); - std::string* mutable_text(); - PROTOBUF_NODISCARD std::string* release_text(); - void set_allocated_text(std::string* text); - private: - const std::string& _internal_text() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value); - std::string* _internal_mutable_text(); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage.Footer) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_InteractiveMessage_Header final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage.Header) */ { - public: - inline Message_InteractiveMessage_Header() : Message_InteractiveMessage_Header(nullptr) {} - ~Message_InteractiveMessage_Header() override; - explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage_Header(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_InteractiveMessage_Header(const Message_InteractiveMessage_Header& from); - Message_InteractiveMessage_Header(Message_InteractiveMessage_Header&& from) noexcept - : Message_InteractiveMessage_Header() { - *this = ::std::move(from); - } - - inline Message_InteractiveMessage_Header& operator=(const Message_InteractiveMessage_Header& from) { - CopyFrom(from); - return *this; - } - inline Message_InteractiveMessage_Header& operator=(Message_InteractiveMessage_Header&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_InteractiveMessage_Header& default_instance() { - return *internal_default_instance(); - } - enum MediaCase { - kDocumentMessage = 3, - kImageMessage = 4, - kJpegThumbnail = 6, - kVideoMessage = 7, - MEDIA_NOT_SET = 0, - }; - - static inline const Message_InteractiveMessage_Header* internal_default_instance() { - return reinterpret_cast( - &_Message_InteractiveMessage_Header_default_instance_); - } - static constexpr int kIndexInFileMessages = - 89; - - friend void swap(Message_InteractiveMessage_Header& a, Message_InteractiveMessage_Header& b) { - a.Swap(&b); - } - inline void Swap(Message_InteractiveMessage_Header* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_InteractiveMessage_Header* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_InteractiveMessage_Header* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_InteractiveMessage_Header& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_InteractiveMessage_Header& from) { - Message_InteractiveMessage_Header::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_InteractiveMessage_Header* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.InteractiveMessage.Header"; - } - protected: - explicit Message_InteractiveMessage_Header(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kTitleFieldNumber = 1, - kSubtitleFieldNumber = 2, - kHasMediaAttachmentFieldNumber = 5, - kDocumentMessageFieldNumber = 3, - kImageMessageFieldNumber = 4, - kJpegThumbnailFieldNumber = 6, - kVideoMessageFieldNumber = 7, - }; - // optional string title = 1; - bool has_title() const; - private: - bool _internal_has_title() const; - public: - void clear_title(); - const std::string& title() const; - template - void set_title(ArgT0&& arg0, ArgT... args); - std::string* mutable_title(); - PROTOBUF_NODISCARD std::string* release_title(); - void set_allocated_title(std::string* title); - private: - const std::string& _internal_title() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value); - std::string* _internal_mutable_title(); - public: - - // optional string subtitle = 2; - bool has_subtitle() const; - private: - bool _internal_has_subtitle() const; - public: - void clear_subtitle(); - const std::string& subtitle() const; - template - void set_subtitle(ArgT0&& arg0, ArgT... args); - std::string* mutable_subtitle(); - PROTOBUF_NODISCARD std::string* release_subtitle(); - void set_allocated_subtitle(std::string* subtitle); - private: - const std::string& _internal_subtitle() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_subtitle(const std::string& value); - std::string* _internal_mutable_subtitle(); - public: - - // optional bool hasMediaAttachment = 5; - bool has_hasmediaattachment() const; - private: - bool _internal_has_hasmediaattachment() const; - public: - void clear_hasmediaattachment(); - bool hasmediaattachment() const; - void set_hasmediaattachment(bool value); - private: - bool _internal_hasmediaattachment() const; - void _internal_set_hasmediaattachment(bool value); - public: - - // .proto.Message.DocumentMessage documentMessage = 3; - bool has_documentmessage() const; - private: - bool _internal_has_documentmessage() const; - public: - void clear_documentmessage(); - const ::proto::Message_DocumentMessage& documentmessage() const; - PROTOBUF_NODISCARD ::proto::Message_DocumentMessage* release_documentmessage(); - ::proto::Message_DocumentMessage* mutable_documentmessage(); - void set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage); - private: - const ::proto::Message_DocumentMessage& _internal_documentmessage() const; - ::proto::Message_DocumentMessage* _internal_mutable_documentmessage(); - public: - void unsafe_arena_set_allocated_documentmessage( - ::proto::Message_DocumentMessage* documentmessage); - ::proto::Message_DocumentMessage* unsafe_arena_release_documentmessage(); - - // .proto.Message.ImageMessage imageMessage = 4; - bool has_imagemessage() const; - private: - bool _internal_has_imagemessage() const; - public: - void clear_imagemessage(); - const ::proto::Message_ImageMessage& imagemessage() const; - PROTOBUF_NODISCARD ::proto::Message_ImageMessage* release_imagemessage(); - ::proto::Message_ImageMessage* mutable_imagemessage(); - void set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage); - private: - const ::proto::Message_ImageMessage& _internal_imagemessage() const; - ::proto::Message_ImageMessage* _internal_mutable_imagemessage(); - public: - void unsafe_arena_set_allocated_imagemessage( - ::proto::Message_ImageMessage* imagemessage); - ::proto::Message_ImageMessage* unsafe_arena_release_imagemessage(); - - // bytes jpegThumbnail = 6; - bool has_jpegthumbnail() const; - private: - bool _internal_has_jpegthumbnail() const; - public: - void clear_jpegthumbnail(); - const std::string& jpegthumbnail() const; - template - void set_jpegthumbnail(ArgT0&& arg0, ArgT... args); - std::string* mutable_jpegthumbnail(); - PROTOBUF_NODISCARD std::string* release_jpegthumbnail(); - void set_allocated_jpegthumbnail(std::string* jpegthumbnail); - private: - const std::string& _internal_jpegthumbnail() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value); - std::string* _internal_mutable_jpegthumbnail(); - public: - - // .proto.Message.VideoMessage videoMessage = 7; - bool has_videomessage() const; - private: - bool _internal_has_videomessage() const; - public: - void clear_videomessage(); - const ::proto::Message_VideoMessage& videomessage() const; - PROTOBUF_NODISCARD ::proto::Message_VideoMessage* release_videomessage(); - ::proto::Message_VideoMessage* mutable_videomessage(); - void set_allocated_videomessage(::proto::Message_VideoMessage* videomessage); - private: - const ::proto::Message_VideoMessage& _internal_videomessage() const; - ::proto::Message_VideoMessage* _internal_mutable_videomessage(); - public: - void unsafe_arena_set_allocated_videomessage( - ::proto::Message_VideoMessage* videomessage); - ::proto::Message_VideoMessage* unsafe_arena_release_videomessage(); - - void clear_media(); - MediaCase media_case() const; - // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage.Header) - private: - class _Internal; - void set_has_documentmessage(); - void set_has_imagemessage(); - void set_has_jpegthumbnail(); - void set_has_videomessage(); - - inline bool has_media() const; - inline void clear_has_media(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr subtitle_; - bool hasmediaattachment_; - union MediaUnion { - constexpr MediaUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::proto::Message_DocumentMessage* documentmessage_; - ::proto::Message_ImageMessage* imagemessage_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_; - ::proto::Message_VideoMessage* videomessage_; - } media_; - uint32_t _oneof_case_[1]; - - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton) */ { - public: - inline Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton() : Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton(nullptr) {} - ~Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton() override; - explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton(const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& from); - Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton(Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton&& from) noexcept - : Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton() { - *this = ::std::move(from); - } - - inline Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& operator=(const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& from) { - CopyFrom(from); - return *this; - } - inline Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& operator=(Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& default_instance() { - return *internal_default_instance(); - } - static inline const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* internal_default_instance() { - return reinterpret_cast( - &_Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton_default_instance_); - } - static constexpr int kIndexInFileMessages = - 90; - - friend void swap(Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& a, Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& b) { - a.Swap(&b); - } - inline void Swap(Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& from) { - Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton"; - } - protected: - explicit Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kNameFieldNumber = 1, - kButtonParamsJsonFieldNumber = 2, - }; - // optional string name = 1; - bool has_name() const; - private: - bool _internal_has_name() const; - public: - void clear_name(); - const std::string& name() const; - template - void set_name(ArgT0&& arg0, ArgT... args); - std::string* mutable_name(); - PROTOBUF_NODISCARD std::string* release_name(); - void set_allocated_name(std::string* name); - private: - const std::string& _internal_name() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); - std::string* _internal_mutable_name(); - public: - - // optional string buttonParamsJson = 2; - bool has_buttonparamsjson() const; - private: - bool _internal_has_buttonparamsjson() const; - public: - void clear_buttonparamsjson(); - const std::string& buttonparamsjson() const; - template - void set_buttonparamsjson(ArgT0&& arg0, ArgT... args); - std::string* mutable_buttonparamsjson(); - PROTOBUF_NODISCARD std::string* release_buttonparamsjson(); - void set_allocated_buttonparamsjson(std::string* buttonparamsjson); - private: - const std::string& _internal_buttonparamsjson() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_buttonparamsjson(const std::string& value); - std::string* _internal_mutable_buttonparamsjson(); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr buttonparamsjson_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_InteractiveMessage_NativeFlowMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage.NativeFlowMessage) */ { - public: - inline Message_InteractiveMessage_NativeFlowMessage() : Message_InteractiveMessage_NativeFlowMessage(nullptr) {} - ~Message_InteractiveMessage_NativeFlowMessage() override; - explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage_NativeFlowMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_InteractiveMessage_NativeFlowMessage(const Message_InteractiveMessage_NativeFlowMessage& from); - Message_InteractiveMessage_NativeFlowMessage(Message_InteractiveMessage_NativeFlowMessage&& from) noexcept - : Message_InteractiveMessage_NativeFlowMessage() { - *this = ::std::move(from); - } - - inline Message_InteractiveMessage_NativeFlowMessage& operator=(const Message_InteractiveMessage_NativeFlowMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_InteractiveMessage_NativeFlowMessage& operator=(Message_InteractiveMessage_NativeFlowMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_InteractiveMessage_NativeFlowMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_InteractiveMessage_NativeFlowMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_InteractiveMessage_NativeFlowMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 91; - - friend void swap(Message_InteractiveMessage_NativeFlowMessage& a, Message_InteractiveMessage_NativeFlowMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_InteractiveMessage_NativeFlowMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_InteractiveMessage_NativeFlowMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_InteractiveMessage_NativeFlowMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_InteractiveMessage_NativeFlowMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_InteractiveMessage_NativeFlowMessage& from) { - Message_InteractiveMessage_NativeFlowMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_InteractiveMessage_NativeFlowMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.InteractiveMessage.NativeFlowMessage"; - } - protected: - explicit Message_InteractiveMessage_NativeFlowMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton NativeFlowButton; - - // accessors ------------------------------------------------------- - - enum : int { - kButtonsFieldNumber = 1, - kMessageParamsJsonFieldNumber = 2, - kMessageVersionFieldNumber = 3, - }; - // repeated .proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton buttons = 1; - int buttons_size() const; - private: - int _internal_buttons_size() const; - public: - void clear_buttons(); - ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* mutable_buttons(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton >* - mutable_buttons(); - private: - const ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& _internal_buttons(int index) const; - ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* _internal_add_buttons(); - public: - const ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& buttons(int index) const; - ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* add_buttons(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton >& - buttons() const; - - // optional string messageParamsJson = 2; - bool has_messageparamsjson() const; - private: - bool _internal_has_messageparamsjson() const; - public: - void clear_messageparamsjson(); - const std::string& messageparamsjson() const; - template - void set_messageparamsjson(ArgT0&& arg0, ArgT... args); - std::string* mutable_messageparamsjson(); - PROTOBUF_NODISCARD std::string* release_messageparamsjson(); - void set_allocated_messageparamsjson(std::string* messageparamsjson); - private: - const std::string& _internal_messageparamsjson() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_messageparamsjson(const std::string& value); - std::string* _internal_mutable_messageparamsjson(); - public: - - // optional int32 messageVersion = 3; - bool has_messageversion() const; - private: - bool _internal_has_messageversion() const; - public: - void clear_messageversion(); - int32_t messageversion() const; - void set_messageversion(int32_t value); - private: - int32_t _internal_messageversion() const; - void _internal_set_messageversion(int32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage.NativeFlowMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton > buttons_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr messageparamsjson_; - int32_t messageversion_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_InteractiveMessage_ShopMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage.ShopMessage) */ { - public: - inline Message_InteractiveMessage_ShopMessage() : Message_InteractiveMessage_ShopMessage(nullptr) {} - ~Message_InteractiveMessage_ShopMessage() override; - explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage_ShopMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_InteractiveMessage_ShopMessage(const Message_InteractiveMessage_ShopMessage& from); - Message_InteractiveMessage_ShopMessage(Message_InteractiveMessage_ShopMessage&& from) noexcept - : Message_InteractiveMessage_ShopMessage() { - *this = ::std::move(from); - } - - inline Message_InteractiveMessage_ShopMessage& operator=(const Message_InteractiveMessage_ShopMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_InteractiveMessage_ShopMessage& operator=(Message_InteractiveMessage_ShopMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_InteractiveMessage_ShopMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_InteractiveMessage_ShopMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_InteractiveMessage_ShopMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 92; - - friend void swap(Message_InteractiveMessage_ShopMessage& a, Message_InteractiveMessage_ShopMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_InteractiveMessage_ShopMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_InteractiveMessage_ShopMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_InteractiveMessage_ShopMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_InteractiveMessage_ShopMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_InteractiveMessage_ShopMessage& from) { - Message_InteractiveMessage_ShopMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_InteractiveMessage_ShopMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.InteractiveMessage.ShopMessage"; - } - protected: - explicit Message_InteractiveMessage_ShopMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Message_InteractiveMessage_ShopMessage_Surface Surface; - static constexpr Surface UNKNOWN_SURFACE = - Message_InteractiveMessage_ShopMessage_Surface_UNKNOWN_SURFACE; - static constexpr Surface FB = - Message_InteractiveMessage_ShopMessage_Surface_FB; - static constexpr Surface IG = - Message_InteractiveMessage_ShopMessage_Surface_IG; - static constexpr Surface WA = - Message_InteractiveMessage_ShopMessage_Surface_WA; - static inline bool Surface_IsValid(int value) { - return Message_InteractiveMessage_ShopMessage_Surface_IsValid(value); - } - static constexpr Surface Surface_MIN = - Message_InteractiveMessage_ShopMessage_Surface_Surface_MIN; - static constexpr Surface Surface_MAX = - Message_InteractiveMessage_ShopMessage_Surface_Surface_MAX; - static constexpr int Surface_ARRAYSIZE = - Message_InteractiveMessage_ShopMessage_Surface_Surface_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - Surface_descriptor() { - return Message_InteractiveMessage_ShopMessage_Surface_descriptor(); - } - template - static inline const std::string& Surface_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Surface_Name."); - return Message_InteractiveMessage_ShopMessage_Surface_Name(enum_t_value); - } - static inline bool Surface_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - Surface* value) { - return Message_InteractiveMessage_ShopMessage_Surface_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kIdFieldNumber = 1, - kSurfaceFieldNumber = 2, - kMessageVersionFieldNumber = 3, - }; - // optional string id = 1; - bool has_id() const; - private: - bool _internal_has_id() const; - public: - void clear_id(); - const std::string& id() const; - template - void set_id(ArgT0&& arg0, ArgT... args); - std::string* mutable_id(); - PROTOBUF_NODISCARD std::string* release_id(); - void set_allocated_id(std::string* id); - private: - const std::string& _internal_id() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value); - std::string* _internal_mutable_id(); - public: - - // optional .proto.Message.InteractiveMessage.ShopMessage.Surface surface = 2; - bool has_surface() const; - private: - bool _internal_has_surface() const; - public: - void clear_surface(); - ::proto::Message_InteractiveMessage_ShopMessage_Surface surface() const; - void set_surface(::proto::Message_InteractiveMessage_ShopMessage_Surface value); - private: - ::proto::Message_InteractiveMessage_ShopMessage_Surface _internal_surface() const; - void _internal_set_surface(::proto::Message_InteractiveMessage_ShopMessage_Surface value); - public: - - // optional int32 messageVersion = 3; - bool has_messageversion() const; - private: - bool _internal_has_messageversion() const; - public: - void clear_messageversion(); - int32_t messageversion() const; - void set_messageversion(int32_t value); - private: - int32_t _internal_messageversion() const; - void _internal_set_messageversion(int32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage.ShopMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_; - int surface_; - int32_t messageversion_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_InteractiveMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage) */ { - public: - inline Message_InteractiveMessage() : Message_InteractiveMessage(nullptr) {} - ~Message_InteractiveMessage() override; - explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_InteractiveMessage(const Message_InteractiveMessage& from); - Message_InteractiveMessage(Message_InteractiveMessage&& from) noexcept - : Message_InteractiveMessage() { - *this = ::std::move(from); - } - - inline Message_InteractiveMessage& operator=(const Message_InteractiveMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_InteractiveMessage& operator=(Message_InteractiveMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_InteractiveMessage& default_instance() { - return *internal_default_instance(); - } - enum InteractiveMessageCase { - kShopStorefrontMessage = 4, - kCollectionMessage = 5, - kNativeFlowMessage = 6, - INTERACTIVEMESSAGE_NOT_SET = 0, - }; - - static inline const Message_InteractiveMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_InteractiveMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 93; - - friend void swap(Message_InteractiveMessage& a, Message_InteractiveMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_InteractiveMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_InteractiveMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_InteractiveMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_InteractiveMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_InteractiveMessage& from) { - Message_InteractiveMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_InteractiveMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.InteractiveMessage"; - } - protected: - explicit Message_InteractiveMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Message_InteractiveMessage_Body Body; - typedef Message_InteractiveMessage_CollectionMessage CollectionMessage; - typedef Message_InteractiveMessage_Footer Footer; - typedef Message_InteractiveMessage_Header Header; - typedef Message_InteractiveMessage_NativeFlowMessage NativeFlowMessage; - typedef Message_InteractiveMessage_ShopMessage ShopMessage; - - // accessors ------------------------------------------------------- - - enum : int { - kHeaderFieldNumber = 1, - kBodyFieldNumber = 2, - kFooterFieldNumber = 3, - kContextInfoFieldNumber = 15, - kShopStorefrontMessageFieldNumber = 4, - kCollectionMessageFieldNumber = 5, - kNativeFlowMessageFieldNumber = 6, - }; - // optional .proto.Message.InteractiveMessage.Header header = 1; - bool has_header() const; - private: - bool _internal_has_header() const; - public: - void clear_header(); - const ::proto::Message_InteractiveMessage_Header& header() const; - PROTOBUF_NODISCARD ::proto::Message_InteractiveMessage_Header* release_header(); - ::proto::Message_InteractiveMessage_Header* mutable_header(); - void set_allocated_header(::proto::Message_InteractiveMessage_Header* header); - private: - const ::proto::Message_InteractiveMessage_Header& _internal_header() const; - ::proto::Message_InteractiveMessage_Header* _internal_mutable_header(); - public: - void unsafe_arena_set_allocated_header( - ::proto::Message_InteractiveMessage_Header* header); - ::proto::Message_InteractiveMessage_Header* unsafe_arena_release_header(); - - // optional .proto.Message.InteractiveMessage.Body body = 2; - bool has_body() const; - private: - bool _internal_has_body() const; - public: - void clear_body(); - const ::proto::Message_InteractiveMessage_Body& body() const; - PROTOBUF_NODISCARD ::proto::Message_InteractiveMessage_Body* release_body(); - ::proto::Message_InteractiveMessage_Body* mutable_body(); - void set_allocated_body(::proto::Message_InteractiveMessage_Body* body); - private: - const ::proto::Message_InteractiveMessage_Body& _internal_body() const; - ::proto::Message_InteractiveMessage_Body* _internal_mutable_body(); - public: - void unsafe_arena_set_allocated_body( - ::proto::Message_InteractiveMessage_Body* body); - ::proto::Message_InteractiveMessage_Body* unsafe_arena_release_body(); - - // optional .proto.Message.InteractiveMessage.Footer footer = 3; - bool has_footer() const; - private: - bool _internal_has_footer() const; - public: - void clear_footer(); - const ::proto::Message_InteractiveMessage_Footer& footer() const; - PROTOBUF_NODISCARD ::proto::Message_InteractiveMessage_Footer* release_footer(); - ::proto::Message_InteractiveMessage_Footer* mutable_footer(); - void set_allocated_footer(::proto::Message_InteractiveMessage_Footer* footer); - private: - const ::proto::Message_InteractiveMessage_Footer& _internal_footer() const; - ::proto::Message_InteractiveMessage_Footer* _internal_mutable_footer(); - public: - void unsafe_arena_set_allocated_footer( - ::proto::Message_InteractiveMessage_Footer* footer); - ::proto::Message_InteractiveMessage_Footer* unsafe_arena_release_footer(); - - // optional .proto.ContextInfo contextInfo = 15; - bool has_contextinfo() const; - private: - bool _internal_has_contextinfo() const; - public: - void clear_contextinfo(); - const ::proto::ContextInfo& contextinfo() const; - PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); - ::proto::ContextInfo* mutable_contextinfo(); - void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); - private: - const ::proto::ContextInfo& _internal_contextinfo() const; - ::proto::ContextInfo* _internal_mutable_contextinfo(); - public: - void unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo); - ::proto::ContextInfo* unsafe_arena_release_contextinfo(); - - // .proto.Message.InteractiveMessage.ShopMessage shopStorefrontMessage = 4; - bool has_shopstorefrontmessage() const; - private: - bool _internal_has_shopstorefrontmessage() const; - public: - void clear_shopstorefrontmessage(); - const ::proto::Message_InteractiveMessage_ShopMessage& shopstorefrontmessage() const; - PROTOBUF_NODISCARD ::proto::Message_InteractiveMessage_ShopMessage* release_shopstorefrontmessage(); - ::proto::Message_InteractiveMessage_ShopMessage* mutable_shopstorefrontmessage(); - void set_allocated_shopstorefrontmessage(::proto::Message_InteractiveMessage_ShopMessage* shopstorefrontmessage); - private: - const ::proto::Message_InteractiveMessage_ShopMessage& _internal_shopstorefrontmessage() const; - ::proto::Message_InteractiveMessage_ShopMessage* _internal_mutable_shopstorefrontmessage(); - public: - void unsafe_arena_set_allocated_shopstorefrontmessage( - ::proto::Message_InteractiveMessage_ShopMessage* shopstorefrontmessage); - ::proto::Message_InteractiveMessage_ShopMessage* unsafe_arena_release_shopstorefrontmessage(); - - // .proto.Message.InteractiveMessage.CollectionMessage collectionMessage = 5; - bool has_collectionmessage() const; - private: - bool _internal_has_collectionmessage() const; - public: - void clear_collectionmessage(); - const ::proto::Message_InteractiveMessage_CollectionMessage& collectionmessage() const; - PROTOBUF_NODISCARD ::proto::Message_InteractiveMessage_CollectionMessage* release_collectionmessage(); - ::proto::Message_InteractiveMessage_CollectionMessage* mutable_collectionmessage(); - void set_allocated_collectionmessage(::proto::Message_InteractiveMessage_CollectionMessage* collectionmessage); - private: - const ::proto::Message_InteractiveMessage_CollectionMessage& _internal_collectionmessage() const; - ::proto::Message_InteractiveMessage_CollectionMessage* _internal_mutable_collectionmessage(); - public: - void unsafe_arena_set_allocated_collectionmessage( - ::proto::Message_InteractiveMessage_CollectionMessage* collectionmessage); - ::proto::Message_InteractiveMessage_CollectionMessage* unsafe_arena_release_collectionmessage(); - - // .proto.Message.InteractiveMessage.NativeFlowMessage nativeFlowMessage = 6; - bool has_nativeflowmessage() const; - private: - bool _internal_has_nativeflowmessage() const; - public: - void clear_nativeflowmessage(); - const ::proto::Message_InteractiveMessage_NativeFlowMessage& nativeflowmessage() const; - PROTOBUF_NODISCARD ::proto::Message_InteractiveMessage_NativeFlowMessage* release_nativeflowmessage(); - ::proto::Message_InteractiveMessage_NativeFlowMessage* mutable_nativeflowmessage(); - void set_allocated_nativeflowmessage(::proto::Message_InteractiveMessage_NativeFlowMessage* nativeflowmessage); - private: - const ::proto::Message_InteractiveMessage_NativeFlowMessage& _internal_nativeflowmessage() const; - ::proto::Message_InteractiveMessage_NativeFlowMessage* _internal_mutable_nativeflowmessage(); - public: - void unsafe_arena_set_allocated_nativeflowmessage( - ::proto::Message_InteractiveMessage_NativeFlowMessage* nativeflowmessage); - ::proto::Message_InteractiveMessage_NativeFlowMessage* unsafe_arena_release_nativeflowmessage(); - - void clear_interactiveMessage(); - InteractiveMessageCase interactiveMessage_case() const; - // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage) - private: - class _Internal; - void set_has_shopstorefrontmessage(); - void set_has_collectionmessage(); - void set_has_nativeflowmessage(); - - inline bool has_interactiveMessage() const; - inline void clear_has_interactiveMessage(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::proto::Message_InteractiveMessage_Header* header_; - ::proto::Message_InteractiveMessage_Body* body_; - ::proto::Message_InteractiveMessage_Footer* footer_; - ::proto::ContextInfo* contextinfo_; - union InteractiveMessageUnion { - constexpr InteractiveMessageUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::proto::Message_InteractiveMessage_ShopMessage* shopstorefrontmessage_; - ::proto::Message_InteractiveMessage_CollectionMessage* collectionmessage_; - ::proto::Message_InteractiveMessage_NativeFlowMessage* nativeflowmessage_; - } interactiveMessage_; - uint32_t _oneof_case_[1]; - - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_InteractiveResponseMessage_Body final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveResponseMessage.Body) */ { - public: - inline Message_InteractiveResponseMessage_Body() : Message_InteractiveResponseMessage_Body(nullptr) {} - ~Message_InteractiveResponseMessage_Body() override; - explicit PROTOBUF_CONSTEXPR Message_InteractiveResponseMessage_Body(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_InteractiveResponseMessage_Body(const Message_InteractiveResponseMessage_Body& from); - Message_InteractiveResponseMessage_Body(Message_InteractiveResponseMessage_Body&& from) noexcept - : Message_InteractiveResponseMessage_Body() { - *this = ::std::move(from); - } - - inline Message_InteractiveResponseMessage_Body& operator=(const Message_InteractiveResponseMessage_Body& from) { - CopyFrom(from); - return *this; - } - inline Message_InteractiveResponseMessage_Body& operator=(Message_InteractiveResponseMessage_Body&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_InteractiveResponseMessage_Body& default_instance() { - return *internal_default_instance(); - } - static inline const Message_InteractiveResponseMessage_Body* internal_default_instance() { - return reinterpret_cast( - &_Message_InteractiveResponseMessage_Body_default_instance_); - } - static constexpr int kIndexInFileMessages = - 94; - - friend void swap(Message_InteractiveResponseMessage_Body& a, Message_InteractiveResponseMessage_Body& b) { - a.Swap(&b); - } - inline void Swap(Message_InteractiveResponseMessage_Body* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_InteractiveResponseMessage_Body* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_InteractiveResponseMessage_Body* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_InteractiveResponseMessage_Body& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_InteractiveResponseMessage_Body& from) { - Message_InteractiveResponseMessage_Body::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_InteractiveResponseMessage_Body* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.InteractiveResponseMessage.Body"; - } - protected: - explicit Message_InteractiveResponseMessage_Body(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kTextFieldNumber = 1, - }; - // optional string text = 1; - bool has_text() const; - private: - bool _internal_has_text() const; - public: - void clear_text(); - const std::string& text() const; - template - void set_text(ArgT0&& arg0, ArgT... args); - std::string* mutable_text(); - PROTOBUF_NODISCARD std::string* release_text(); - void set_allocated_text(std::string* text); - private: - const std::string& _internal_text() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value); - std::string* _internal_mutable_text(); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.InteractiveResponseMessage.Body) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_InteractiveResponseMessage_NativeFlowResponseMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage) */ { - public: - inline Message_InteractiveResponseMessage_NativeFlowResponseMessage() : Message_InteractiveResponseMessage_NativeFlowResponseMessage(nullptr) {} - ~Message_InteractiveResponseMessage_NativeFlowResponseMessage() override; - explicit PROTOBUF_CONSTEXPR Message_InteractiveResponseMessage_NativeFlowResponseMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_InteractiveResponseMessage_NativeFlowResponseMessage(const Message_InteractiveResponseMessage_NativeFlowResponseMessage& from); - Message_InteractiveResponseMessage_NativeFlowResponseMessage(Message_InteractiveResponseMessage_NativeFlowResponseMessage&& from) noexcept - : Message_InteractiveResponseMessage_NativeFlowResponseMessage() { - *this = ::std::move(from); - } - - inline Message_InteractiveResponseMessage_NativeFlowResponseMessage& operator=(const Message_InteractiveResponseMessage_NativeFlowResponseMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_InteractiveResponseMessage_NativeFlowResponseMessage& operator=(Message_InteractiveResponseMessage_NativeFlowResponseMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_InteractiveResponseMessage_NativeFlowResponseMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_InteractiveResponseMessage_NativeFlowResponseMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_InteractiveResponseMessage_NativeFlowResponseMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 95; - - friend void swap(Message_InteractiveResponseMessage_NativeFlowResponseMessage& a, Message_InteractiveResponseMessage_NativeFlowResponseMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_InteractiveResponseMessage_NativeFlowResponseMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_InteractiveResponseMessage_NativeFlowResponseMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_InteractiveResponseMessage_NativeFlowResponseMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_InteractiveResponseMessage_NativeFlowResponseMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_InteractiveResponseMessage_NativeFlowResponseMessage& from) { - Message_InteractiveResponseMessage_NativeFlowResponseMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_InteractiveResponseMessage_NativeFlowResponseMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage"; - } - protected: - explicit Message_InteractiveResponseMessage_NativeFlowResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kNameFieldNumber = 1, - kParamsJsonFieldNumber = 2, - kVersionFieldNumber = 3, - }; - // optional string name = 1; - bool has_name() const; - private: - bool _internal_has_name() const; - public: - void clear_name(); - const std::string& name() const; - template - void set_name(ArgT0&& arg0, ArgT... args); - std::string* mutable_name(); - PROTOBUF_NODISCARD std::string* release_name(); - void set_allocated_name(std::string* name); - private: - const std::string& _internal_name() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); - std::string* _internal_mutable_name(); - public: - - // optional string paramsJson = 2; - bool has_paramsjson() const; - private: - bool _internal_has_paramsjson() const; - public: - void clear_paramsjson(); - const std::string& paramsjson() const; - template - void set_paramsjson(ArgT0&& arg0, ArgT... args); - std::string* mutable_paramsjson(); - PROTOBUF_NODISCARD std::string* release_paramsjson(); - void set_allocated_paramsjson(std::string* paramsjson); - private: - const std::string& _internal_paramsjson() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_paramsjson(const std::string& value); - std::string* _internal_mutable_paramsjson(); - public: - - // optional int32 version = 3; - bool has_version() const; - private: - bool _internal_has_version() const; - public: - void clear_version(); - int32_t version() const; - void set_version(int32_t value); - private: - int32_t _internal_version() const; - void _internal_set_version(int32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr paramsjson_; - int32_t version_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_InteractiveResponseMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveResponseMessage) */ { - public: - inline Message_InteractiveResponseMessage() : Message_InteractiveResponseMessage(nullptr) {} - ~Message_InteractiveResponseMessage() override; - explicit PROTOBUF_CONSTEXPR Message_InteractiveResponseMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_InteractiveResponseMessage(const Message_InteractiveResponseMessage& from); - Message_InteractiveResponseMessage(Message_InteractiveResponseMessage&& from) noexcept - : Message_InteractiveResponseMessage() { - *this = ::std::move(from); - } - - inline Message_InteractiveResponseMessage& operator=(const Message_InteractiveResponseMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_InteractiveResponseMessage& operator=(Message_InteractiveResponseMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_InteractiveResponseMessage& default_instance() { - return *internal_default_instance(); - } - enum InteractiveResponseMessageCase { - kNativeFlowResponseMessage = 2, - INTERACTIVERESPONSEMESSAGE_NOT_SET = 0, - }; - - static inline const Message_InteractiveResponseMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_InteractiveResponseMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 96; - - friend void swap(Message_InteractiveResponseMessage& a, Message_InteractiveResponseMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_InteractiveResponseMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_InteractiveResponseMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_InteractiveResponseMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_InteractiveResponseMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_InteractiveResponseMessage& from) { - Message_InteractiveResponseMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_InteractiveResponseMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.InteractiveResponseMessage"; - } - protected: - explicit Message_InteractiveResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Message_InteractiveResponseMessage_Body Body; - typedef Message_InteractiveResponseMessage_NativeFlowResponseMessage NativeFlowResponseMessage; - - // accessors ------------------------------------------------------- - - enum : int { - kBodyFieldNumber = 1, - kContextInfoFieldNumber = 15, - kNativeFlowResponseMessageFieldNumber = 2, - }; - // optional .proto.Message.InteractiveResponseMessage.Body body = 1; - bool has_body() const; - private: - bool _internal_has_body() const; - public: - void clear_body(); - const ::proto::Message_InteractiveResponseMessage_Body& body() const; - PROTOBUF_NODISCARD ::proto::Message_InteractiveResponseMessage_Body* release_body(); - ::proto::Message_InteractiveResponseMessage_Body* mutable_body(); - void set_allocated_body(::proto::Message_InteractiveResponseMessage_Body* body); - private: - const ::proto::Message_InteractiveResponseMessage_Body& _internal_body() const; - ::proto::Message_InteractiveResponseMessage_Body* _internal_mutable_body(); - public: - void unsafe_arena_set_allocated_body( - ::proto::Message_InteractiveResponseMessage_Body* body); - ::proto::Message_InteractiveResponseMessage_Body* unsafe_arena_release_body(); - - // optional .proto.ContextInfo contextInfo = 15; - bool has_contextinfo() const; - private: - bool _internal_has_contextinfo() const; - public: - void clear_contextinfo(); - const ::proto::ContextInfo& contextinfo() const; - PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); - ::proto::ContextInfo* mutable_contextinfo(); - void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); - private: - const ::proto::ContextInfo& _internal_contextinfo() const; - ::proto::ContextInfo* _internal_mutable_contextinfo(); - public: - void unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo); - ::proto::ContextInfo* unsafe_arena_release_contextinfo(); - - // .proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage nativeFlowResponseMessage = 2; - bool has_nativeflowresponsemessage() const; - private: - bool _internal_has_nativeflowresponsemessage() const; - public: - void clear_nativeflowresponsemessage(); - const ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage& nativeflowresponsemessage() const; - PROTOBUF_NODISCARD ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* release_nativeflowresponsemessage(); - ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* mutable_nativeflowresponsemessage(); - void set_allocated_nativeflowresponsemessage(::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* nativeflowresponsemessage); - private: - const ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage& _internal_nativeflowresponsemessage() const; - ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* _internal_mutable_nativeflowresponsemessage(); - public: - void unsafe_arena_set_allocated_nativeflowresponsemessage( - ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* nativeflowresponsemessage); - ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* unsafe_arena_release_nativeflowresponsemessage(); - - void clear_interactiveResponseMessage(); - InteractiveResponseMessageCase interactiveResponseMessage_case() const; - // @@protoc_insertion_point(class_scope:proto.Message.InteractiveResponseMessage) - private: - class _Internal; - void set_has_nativeflowresponsemessage(); - - inline bool has_interactiveResponseMessage() const; - inline void clear_has_interactiveResponseMessage(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::proto::Message_InteractiveResponseMessage_Body* body_; - ::proto::ContextInfo* contextinfo_; - union InteractiveResponseMessageUnion { - constexpr InteractiveResponseMessageUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* nativeflowresponsemessage_; - } interactiveResponseMessage_; - uint32_t _oneof_case_[1]; - - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_InvoiceMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InvoiceMessage) */ { - public: - inline Message_InvoiceMessage() : Message_InvoiceMessage(nullptr) {} - ~Message_InvoiceMessage() override; - explicit PROTOBUF_CONSTEXPR Message_InvoiceMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_InvoiceMessage(const Message_InvoiceMessage& from); - Message_InvoiceMessage(Message_InvoiceMessage&& from) noexcept - : Message_InvoiceMessage() { - *this = ::std::move(from); - } - - inline Message_InvoiceMessage& operator=(const Message_InvoiceMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_InvoiceMessage& operator=(Message_InvoiceMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_InvoiceMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_InvoiceMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_InvoiceMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 97; - - friend void swap(Message_InvoiceMessage& a, Message_InvoiceMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_InvoiceMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_InvoiceMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_InvoiceMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_InvoiceMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_InvoiceMessage& from) { - Message_InvoiceMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_InvoiceMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.InvoiceMessage"; - } - protected: - explicit Message_InvoiceMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Message_InvoiceMessage_AttachmentType AttachmentType; - static constexpr AttachmentType IMAGE = - Message_InvoiceMessage_AttachmentType_IMAGE; - static constexpr AttachmentType PDF = - Message_InvoiceMessage_AttachmentType_PDF; - static inline bool AttachmentType_IsValid(int value) { - return Message_InvoiceMessage_AttachmentType_IsValid(value); - } - static constexpr AttachmentType AttachmentType_MIN = - Message_InvoiceMessage_AttachmentType_AttachmentType_MIN; - static constexpr AttachmentType AttachmentType_MAX = - Message_InvoiceMessage_AttachmentType_AttachmentType_MAX; - static constexpr int AttachmentType_ARRAYSIZE = - Message_InvoiceMessage_AttachmentType_AttachmentType_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - AttachmentType_descriptor() { - return Message_InvoiceMessage_AttachmentType_descriptor(); - } - template - static inline const std::string& AttachmentType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function AttachmentType_Name."); - return Message_InvoiceMessage_AttachmentType_Name(enum_t_value); - } - static inline bool AttachmentType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - AttachmentType* value) { - return Message_InvoiceMessage_AttachmentType_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kNoteFieldNumber = 1, - kTokenFieldNumber = 2, - kAttachmentMimetypeFieldNumber = 4, - kAttachmentMediaKeyFieldNumber = 5, - kAttachmentFileSha256FieldNumber = 7, - kAttachmentFileEncSha256FieldNumber = 8, - kAttachmentDirectPathFieldNumber = 9, - kAttachmentJpegThumbnailFieldNumber = 10, - kAttachmentMediaKeyTimestampFieldNumber = 6, - kAttachmentTypeFieldNumber = 3, - }; - // optional string note = 1; - bool has_note() const; - private: - bool _internal_has_note() const; - public: - void clear_note(); - const std::string& note() const; - template - void set_note(ArgT0&& arg0, ArgT... args); - std::string* mutable_note(); - PROTOBUF_NODISCARD std::string* release_note(); - void set_allocated_note(std::string* note); - private: - const std::string& _internal_note() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_note(const std::string& value); - std::string* _internal_mutable_note(); - public: - - // optional string token = 2; - bool has_token() const; - private: - bool _internal_has_token() const; - public: - void clear_token(); - const std::string& token() const; - template - void set_token(ArgT0&& arg0, ArgT... args); - std::string* mutable_token(); - PROTOBUF_NODISCARD std::string* release_token(); - void set_allocated_token(std::string* token); - private: - const std::string& _internal_token() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_token(const std::string& value); - std::string* _internal_mutable_token(); - public: - - // optional string attachmentMimetype = 4; - bool has_attachmentmimetype() const; - private: - bool _internal_has_attachmentmimetype() const; - public: - void clear_attachmentmimetype(); - const std::string& attachmentmimetype() const; - template - void set_attachmentmimetype(ArgT0&& arg0, ArgT... args); - std::string* mutable_attachmentmimetype(); - PROTOBUF_NODISCARD std::string* release_attachmentmimetype(); - void set_allocated_attachmentmimetype(std::string* attachmentmimetype); - private: - const std::string& _internal_attachmentmimetype() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_attachmentmimetype(const std::string& value); - std::string* _internal_mutable_attachmentmimetype(); - public: - - // optional bytes attachmentMediaKey = 5; - bool has_attachmentmediakey() const; - private: - bool _internal_has_attachmentmediakey() const; - public: - void clear_attachmentmediakey(); - const std::string& attachmentmediakey() const; - template - void set_attachmentmediakey(ArgT0&& arg0, ArgT... args); - std::string* mutable_attachmentmediakey(); - PROTOBUF_NODISCARD std::string* release_attachmentmediakey(); - void set_allocated_attachmentmediakey(std::string* attachmentmediakey); - private: - const std::string& _internal_attachmentmediakey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_attachmentmediakey(const std::string& value); - std::string* _internal_mutable_attachmentmediakey(); - public: - - // optional bytes attachmentFileSha256 = 7; - bool has_attachmentfilesha256() const; - private: - bool _internal_has_attachmentfilesha256() const; - public: - void clear_attachmentfilesha256(); - const std::string& attachmentfilesha256() const; - template - void set_attachmentfilesha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_attachmentfilesha256(); - PROTOBUF_NODISCARD std::string* release_attachmentfilesha256(); - void set_allocated_attachmentfilesha256(std::string* attachmentfilesha256); - private: - const std::string& _internal_attachmentfilesha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_attachmentfilesha256(const std::string& value); - std::string* _internal_mutable_attachmentfilesha256(); - public: - - // optional bytes attachmentFileEncSha256 = 8; - bool has_attachmentfileencsha256() const; - private: - bool _internal_has_attachmentfileencsha256() const; - public: - void clear_attachmentfileencsha256(); - const std::string& attachmentfileencsha256() const; - template - void set_attachmentfileencsha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_attachmentfileencsha256(); - PROTOBUF_NODISCARD std::string* release_attachmentfileencsha256(); - void set_allocated_attachmentfileencsha256(std::string* attachmentfileencsha256); - private: - const std::string& _internal_attachmentfileencsha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_attachmentfileencsha256(const std::string& value); - std::string* _internal_mutable_attachmentfileencsha256(); - public: - - // optional string attachmentDirectPath = 9; - bool has_attachmentdirectpath() const; - private: - bool _internal_has_attachmentdirectpath() const; - public: - void clear_attachmentdirectpath(); - const std::string& attachmentdirectpath() const; - template - void set_attachmentdirectpath(ArgT0&& arg0, ArgT... args); - std::string* mutable_attachmentdirectpath(); - PROTOBUF_NODISCARD std::string* release_attachmentdirectpath(); - void set_allocated_attachmentdirectpath(std::string* attachmentdirectpath); - private: - const std::string& _internal_attachmentdirectpath() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_attachmentdirectpath(const std::string& value); - std::string* _internal_mutable_attachmentdirectpath(); - public: - - // optional bytes attachmentJpegThumbnail = 10; - bool has_attachmentjpegthumbnail() const; - private: - bool _internal_has_attachmentjpegthumbnail() const; - public: - void clear_attachmentjpegthumbnail(); - const std::string& attachmentjpegthumbnail() const; - template - void set_attachmentjpegthumbnail(ArgT0&& arg0, ArgT... args); - std::string* mutable_attachmentjpegthumbnail(); - PROTOBUF_NODISCARD std::string* release_attachmentjpegthumbnail(); - void set_allocated_attachmentjpegthumbnail(std::string* attachmentjpegthumbnail); - private: - const std::string& _internal_attachmentjpegthumbnail() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_attachmentjpegthumbnail(const std::string& value); - std::string* _internal_mutable_attachmentjpegthumbnail(); - public: - - // optional int64 attachmentMediaKeyTimestamp = 6; - bool has_attachmentmediakeytimestamp() const; - private: - bool _internal_has_attachmentmediakeytimestamp() const; - public: - void clear_attachmentmediakeytimestamp(); - int64_t attachmentmediakeytimestamp() const; - void set_attachmentmediakeytimestamp(int64_t value); - private: - int64_t _internal_attachmentmediakeytimestamp() const; - void _internal_set_attachmentmediakeytimestamp(int64_t value); - public: - - // optional .proto.Message.InvoiceMessage.AttachmentType attachmentType = 3; - bool has_attachmenttype() const; - private: - bool _internal_has_attachmenttype() const; - public: - void clear_attachmenttype(); - ::proto::Message_InvoiceMessage_AttachmentType attachmenttype() const; - void set_attachmenttype(::proto::Message_InvoiceMessage_AttachmentType value); - private: - ::proto::Message_InvoiceMessage_AttachmentType _internal_attachmenttype() const; - void _internal_set_attachmenttype(::proto::Message_InvoiceMessage_AttachmentType value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.InvoiceMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr note_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr token_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr attachmentmimetype_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr attachmentmediakey_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr attachmentfilesha256_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr attachmentfileencsha256_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr attachmentdirectpath_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr attachmentjpegthumbnail_; - int64_t attachmentmediakeytimestamp_; - int attachmenttype_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_KeepInChatMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.KeepInChatMessage) */ { - public: - inline Message_KeepInChatMessage() : Message_KeepInChatMessage(nullptr) {} - ~Message_KeepInChatMessage() override; - explicit PROTOBUF_CONSTEXPR Message_KeepInChatMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_KeepInChatMessage(const Message_KeepInChatMessage& from); - Message_KeepInChatMessage(Message_KeepInChatMessage&& from) noexcept - : Message_KeepInChatMessage() { - *this = ::std::move(from); - } - - inline Message_KeepInChatMessage& operator=(const Message_KeepInChatMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_KeepInChatMessage& operator=(Message_KeepInChatMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_KeepInChatMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_KeepInChatMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_KeepInChatMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 98; - - friend void swap(Message_KeepInChatMessage& a, Message_KeepInChatMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_KeepInChatMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_KeepInChatMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_KeepInChatMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_KeepInChatMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_KeepInChatMessage& from) { - Message_KeepInChatMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_KeepInChatMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.KeepInChatMessage"; - } - protected: - explicit Message_KeepInChatMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kKeyFieldNumber = 1, - kTimestampMsFieldNumber = 3, - kKeepTypeFieldNumber = 2, - }; - // optional .proto.MessageKey key = 1; - bool has_key() const; - private: - bool _internal_has_key() const; - public: - void clear_key(); - const ::proto::MessageKey& key() const; - PROTOBUF_NODISCARD ::proto::MessageKey* release_key(); - ::proto::MessageKey* mutable_key(); - void set_allocated_key(::proto::MessageKey* key); - private: - const ::proto::MessageKey& _internal_key() const; - ::proto::MessageKey* _internal_mutable_key(); - public: - void unsafe_arena_set_allocated_key( - ::proto::MessageKey* key); - ::proto::MessageKey* unsafe_arena_release_key(); - - // optional int64 timestampMs = 3; - bool has_timestampms() const; - private: - bool _internal_has_timestampms() const; - public: - void clear_timestampms(); - int64_t timestampms() const; - void set_timestampms(int64_t value); - private: - int64_t _internal_timestampms() const; - void _internal_set_timestampms(int64_t value); - public: - - // optional .proto.KeepType keepType = 2; - bool has_keeptype() const; - private: - bool _internal_has_keeptype() const; - public: - void clear_keeptype(); - ::proto::KeepType keeptype() const; - void set_keeptype(::proto::KeepType value); - private: - ::proto::KeepType _internal_keeptype() const; - void _internal_set_keeptype(::proto::KeepType value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.KeepInChatMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::proto::MessageKey* key_; - int64_t timestampms_; - int keeptype_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_ListMessage_ProductListHeaderImage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListMessage.ProductListHeaderImage) */ { - public: - inline Message_ListMessage_ProductListHeaderImage() : Message_ListMessage_ProductListHeaderImage(nullptr) {} - ~Message_ListMessage_ProductListHeaderImage() override; - explicit PROTOBUF_CONSTEXPR Message_ListMessage_ProductListHeaderImage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_ListMessage_ProductListHeaderImage(const Message_ListMessage_ProductListHeaderImage& from); - Message_ListMessage_ProductListHeaderImage(Message_ListMessage_ProductListHeaderImage&& from) noexcept - : Message_ListMessage_ProductListHeaderImage() { - *this = ::std::move(from); - } - - inline Message_ListMessage_ProductListHeaderImage& operator=(const Message_ListMessage_ProductListHeaderImage& from) { - CopyFrom(from); - return *this; - } - inline Message_ListMessage_ProductListHeaderImage& operator=(Message_ListMessage_ProductListHeaderImage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_ListMessage_ProductListHeaderImage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_ListMessage_ProductListHeaderImage* internal_default_instance() { - return reinterpret_cast( - &_Message_ListMessage_ProductListHeaderImage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 99; - - friend void swap(Message_ListMessage_ProductListHeaderImage& a, Message_ListMessage_ProductListHeaderImage& b) { - a.Swap(&b); - } - inline void Swap(Message_ListMessage_ProductListHeaderImage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_ListMessage_ProductListHeaderImage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_ListMessage_ProductListHeaderImage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_ListMessage_ProductListHeaderImage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_ListMessage_ProductListHeaderImage& from) { - Message_ListMessage_ProductListHeaderImage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_ListMessage_ProductListHeaderImage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.ListMessage.ProductListHeaderImage"; - } - protected: - explicit Message_ListMessage_ProductListHeaderImage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kProductIdFieldNumber = 1, - kJpegThumbnailFieldNumber = 2, - }; - // optional string productId = 1; - bool has_productid() const; - private: - bool _internal_has_productid() const; - public: - void clear_productid(); - const std::string& productid() const; - template - void set_productid(ArgT0&& arg0, ArgT... args); - std::string* mutable_productid(); - PROTOBUF_NODISCARD std::string* release_productid(); - void set_allocated_productid(std::string* productid); - private: - const std::string& _internal_productid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_productid(const std::string& value); - std::string* _internal_mutable_productid(); - public: - - // optional bytes jpegThumbnail = 2; - bool has_jpegthumbnail() const; - private: - bool _internal_has_jpegthumbnail() const; - public: - void clear_jpegthumbnail(); - const std::string& jpegthumbnail() const; - template - void set_jpegthumbnail(ArgT0&& arg0, ArgT... args); - std::string* mutable_jpegthumbnail(); - PROTOBUF_NODISCARD std::string* release_jpegthumbnail(); - void set_allocated_jpegthumbnail(std::string* jpegthumbnail); - private: - const std::string& _internal_jpegthumbnail() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value); - std::string* _internal_mutable_jpegthumbnail(); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.ListMessage.ProductListHeaderImage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr productid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_ListMessage_ProductListInfo final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListMessage.ProductListInfo) */ { - public: - inline Message_ListMessage_ProductListInfo() : Message_ListMessage_ProductListInfo(nullptr) {} - ~Message_ListMessage_ProductListInfo() override; - explicit PROTOBUF_CONSTEXPR Message_ListMessage_ProductListInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_ListMessage_ProductListInfo(const Message_ListMessage_ProductListInfo& from); - Message_ListMessage_ProductListInfo(Message_ListMessage_ProductListInfo&& from) noexcept - : Message_ListMessage_ProductListInfo() { - *this = ::std::move(from); - } - - inline Message_ListMessage_ProductListInfo& operator=(const Message_ListMessage_ProductListInfo& from) { - CopyFrom(from); - return *this; - } - inline Message_ListMessage_ProductListInfo& operator=(Message_ListMessage_ProductListInfo&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_ListMessage_ProductListInfo& default_instance() { - return *internal_default_instance(); - } - static inline const Message_ListMessage_ProductListInfo* internal_default_instance() { - return reinterpret_cast( - &_Message_ListMessage_ProductListInfo_default_instance_); - } - static constexpr int kIndexInFileMessages = - 100; - - friend void swap(Message_ListMessage_ProductListInfo& a, Message_ListMessage_ProductListInfo& b) { - a.Swap(&b); - } - inline void Swap(Message_ListMessage_ProductListInfo* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_ListMessage_ProductListInfo* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_ListMessage_ProductListInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_ListMessage_ProductListInfo& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_ListMessage_ProductListInfo& from) { - Message_ListMessage_ProductListInfo::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_ListMessage_ProductListInfo* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.ListMessage.ProductListInfo"; - } - protected: - explicit Message_ListMessage_ProductListInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kProductSectionsFieldNumber = 1, - kBusinessOwnerJidFieldNumber = 3, - kHeaderImageFieldNumber = 2, - }; - // repeated .proto.Message.ListMessage.ProductSection productSections = 1; - int productsections_size() const; - private: - int _internal_productsections_size() const; - public: - void clear_productsections(); - ::proto::Message_ListMessage_ProductSection* mutable_productsections(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_ProductSection >* - mutable_productsections(); - private: - const ::proto::Message_ListMessage_ProductSection& _internal_productsections(int index) const; - ::proto::Message_ListMessage_ProductSection* _internal_add_productsections(); - public: - const ::proto::Message_ListMessage_ProductSection& productsections(int index) const; - ::proto::Message_ListMessage_ProductSection* add_productsections(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_ProductSection >& - productsections() const; - - // optional string businessOwnerJid = 3; - bool has_businessownerjid() const; - private: - bool _internal_has_businessownerjid() const; - public: - void clear_businessownerjid(); - const std::string& businessownerjid() const; - template - void set_businessownerjid(ArgT0&& arg0, ArgT... args); - std::string* mutable_businessownerjid(); - PROTOBUF_NODISCARD std::string* release_businessownerjid(); - void set_allocated_businessownerjid(std::string* businessownerjid); - private: - const std::string& _internal_businessownerjid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_businessownerjid(const std::string& value); - std::string* _internal_mutable_businessownerjid(); - public: - - // optional .proto.Message.ListMessage.ProductListHeaderImage headerImage = 2; - bool has_headerimage() const; - private: - bool _internal_has_headerimage() const; - public: - void clear_headerimage(); - const ::proto::Message_ListMessage_ProductListHeaderImage& headerimage() const; - PROTOBUF_NODISCARD ::proto::Message_ListMessage_ProductListHeaderImage* release_headerimage(); - ::proto::Message_ListMessage_ProductListHeaderImage* mutable_headerimage(); - void set_allocated_headerimage(::proto::Message_ListMessage_ProductListHeaderImage* headerimage); - private: - const ::proto::Message_ListMessage_ProductListHeaderImage& _internal_headerimage() const; - ::proto::Message_ListMessage_ProductListHeaderImage* _internal_mutable_headerimage(); - public: - void unsafe_arena_set_allocated_headerimage( - ::proto::Message_ListMessage_ProductListHeaderImage* headerimage); - ::proto::Message_ListMessage_ProductListHeaderImage* unsafe_arena_release_headerimage(); - - // @@protoc_insertion_point(class_scope:proto.Message.ListMessage.ProductListInfo) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_ProductSection > productsections_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr businessownerjid_; - ::proto::Message_ListMessage_ProductListHeaderImage* headerimage_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_ListMessage_ProductSection final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListMessage.ProductSection) */ { - public: - inline Message_ListMessage_ProductSection() : Message_ListMessage_ProductSection(nullptr) {} - ~Message_ListMessage_ProductSection() override; - explicit PROTOBUF_CONSTEXPR Message_ListMessage_ProductSection(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_ListMessage_ProductSection(const Message_ListMessage_ProductSection& from); - Message_ListMessage_ProductSection(Message_ListMessage_ProductSection&& from) noexcept - : Message_ListMessage_ProductSection() { - *this = ::std::move(from); - } - - inline Message_ListMessage_ProductSection& operator=(const Message_ListMessage_ProductSection& from) { - CopyFrom(from); - return *this; - } - inline Message_ListMessage_ProductSection& operator=(Message_ListMessage_ProductSection&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_ListMessage_ProductSection& default_instance() { - return *internal_default_instance(); - } - static inline const Message_ListMessage_ProductSection* internal_default_instance() { - return reinterpret_cast( - &_Message_ListMessage_ProductSection_default_instance_); - } - static constexpr int kIndexInFileMessages = - 101; - - friend void swap(Message_ListMessage_ProductSection& a, Message_ListMessage_ProductSection& b) { - a.Swap(&b); - } - inline void Swap(Message_ListMessage_ProductSection* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_ListMessage_ProductSection* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_ListMessage_ProductSection* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_ListMessage_ProductSection& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_ListMessage_ProductSection& from) { - Message_ListMessage_ProductSection::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_ListMessage_ProductSection* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.ListMessage.ProductSection"; - } - protected: - explicit Message_ListMessage_ProductSection(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kProductsFieldNumber = 2, - kTitleFieldNumber = 1, - }; - // repeated .proto.Message.ListMessage.Product products = 2; - int products_size() const; - private: - int _internal_products_size() const; - public: - void clear_products(); - ::proto::Message_ListMessage_Product* mutable_products(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Product >* - mutable_products(); - private: - const ::proto::Message_ListMessage_Product& _internal_products(int index) const; - ::proto::Message_ListMessage_Product* _internal_add_products(); - public: - const ::proto::Message_ListMessage_Product& products(int index) const; - ::proto::Message_ListMessage_Product* add_products(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Product >& - products() const; - - // optional string title = 1; - bool has_title() const; - private: - bool _internal_has_title() const; - public: - void clear_title(); - const std::string& title() const; - template - void set_title(ArgT0&& arg0, ArgT... args); - std::string* mutable_title(); - PROTOBUF_NODISCARD std::string* release_title(); - void set_allocated_title(std::string* title); - private: - const std::string& _internal_title() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value); - std::string* _internal_mutable_title(); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.ListMessage.ProductSection) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Product > products_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_ListMessage_Product final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListMessage.Product) */ { - public: - inline Message_ListMessage_Product() : Message_ListMessage_Product(nullptr) {} - ~Message_ListMessage_Product() override; - explicit PROTOBUF_CONSTEXPR Message_ListMessage_Product(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_ListMessage_Product(const Message_ListMessage_Product& from); - Message_ListMessage_Product(Message_ListMessage_Product&& from) noexcept - : Message_ListMessage_Product() { - *this = ::std::move(from); - } - - inline Message_ListMessage_Product& operator=(const Message_ListMessage_Product& from) { - CopyFrom(from); - return *this; - } - inline Message_ListMessage_Product& operator=(Message_ListMessage_Product&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_ListMessage_Product& default_instance() { - return *internal_default_instance(); - } - static inline const Message_ListMessage_Product* internal_default_instance() { - return reinterpret_cast( - &_Message_ListMessage_Product_default_instance_); - } - static constexpr int kIndexInFileMessages = - 102; - - friend void swap(Message_ListMessage_Product& a, Message_ListMessage_Product& b) { - a.Swap(&b); - } - inline void Swap(Message_ListMessage_Product* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_ListMessage_Product* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_ListMessage_Product* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_ListMessage_Product& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_ListMessage_Product& from) { - Message_ListMessage_Product::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_ListMessage_Product* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.ListMessage.Product"; - } - protected: - explicit Message_ListMessage_Product(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kProductIdFieldNumber = 1, - }; - // optional string productId = 1; - bool has_productid() const; - private: - bool _internal_has_productid() const; - public: - void clear_productid(); - const std::string& productid() const; - template - void set_productid(ArgT0&& arg0, ArgT... args); - std::string* mutable_productid(); - PROTOBUF_NODISCARD std::string* release_productid(); - void set_allocated_productid(std::string* productid); - private: - const std::string& _internal_productid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_productid(const std::string& value); - std::string* _internal_mutable_productid(); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.ListMessage.Product) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr productid_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_ListMessage_Row final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListMessage.Row) */ { - public: - inline Message_ListMessage_Row() : Message_ListMessage_Row(nullptr) {} - ~Message_ListMessage_Row() override; - explicit PROTOBUF_CONSTEXPR Message_ListMessage_Row(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_ListMessage_Row(const Message_ListMessage_Row& from); - Message_ListMessage_Row(Message_ListMessage_Row&& from) noexcept - : Message_ListMessage_Row() { - *this = ::std::move(from); - } - - inline Message_ListMessage_Row& operator=(const Message_ListMessage_Row& from) { - CopyFrom(from); - return *this; - } - inline Message_ListMessage_Row& operator=(Message_ListMessage_Row&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_ListMessage_Row& default_instance() { - return *internal_default_instance(); - } - static inline const Message_ListMessage_Row* internal_default_instance() { - return reinterpret_cast( - &_Message_ListMessage_Row_default_instance_); - } - static constexpr int kIndexInFileMessages = - 103; - - friend void swap(Message_ListMessage_Row& a, Message_ListMessage_Row& b) { - a.Swap(&b); - } - inline void Swap(Message_ListMessage_Row* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_ListMessage_Row* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_ListMessage_Row* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_ListMessage_Row& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_ListMessage_Row& from) { - Message_ListMessage_Row::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_ListMessage_Row* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.ListMessage.Row"; - } - protected: - explicit Message_ListMessage_Row(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kTitleFieldNumber = 1, - kDescriptionFieldNumber = 2, - kRowIdFieldNumber = 3, - }; - // optional string title = 1; - bool has_title() const; - private: - bool _internal_has_title() const; - public: - void clear_title(); - const std::string& title() const; - template - void set_title(ArgT0&& arg0, ArgT... args); - std::string* mutable_title(); - PROTOBUF_NODISCARD std::string* release_title(); - void set_allocated_title(std::string* title); - private: - const std::string& _internal_title() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value); - std::string* _internal_mutable_title(); - public: - - // optional string description = 2; - bool has_description() const; - private: - bool _internal_has_description() const; - public: - void clear_description(); - const std::string& description() const; - template - void set_description(ArgT0&& arg0, ArgT... args); - std::string* mutable_description(); - PROTOBUF_NODISCARD std::string* release_description(); - void set_allocated_description(std::string* description); - private: - const std::string& _internal_description() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value); - std::string* _internal_mutable_description(); - public: - - // optional string rowId = 3; - bool has_rowid() const; - private: - bool _internal_has_rowid() const; - public: - void clear_rowid(); - const std::string& rowid() const; - template - void set_rowid(ArgT0&& arg0, ArgT... args); - std::string* mutable_rowid(); - PROTOBUF_NODISCARD std::string* release_rowid(); - void set_allocated_rowid(std::string* rowid); - private: - const std::string& _internal_rowid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_rowid(const std::string& value); - std::string* _internal_mutable_rowid(); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.ListMessage.Row) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rowid_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_ListMessage_Section final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListMessage.Section) */ { - public: - inline Message_ListMessage_Section() : Message_ListMessage_Section(nullptr) {} - ~Message_ListMessage_Section() override; - explicit PROTOBUF_CONSTEXPR Message_ListMessage_Section(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_ListMessage_Section(const Message_ListMessage_Section& from); - Message_ListMessage_Section(Message_ListMessage_Section&& from) noexcept - : Message_ListMessage_Section() { - *this = ::std::move(from); - } - - inline Message_ListMessage_Section& operator=(const Message_ListMessage_Section& from) { - CopyFrom(from); - return *this; - } - inline Message_ListMessage_Section& operator=(Message_ListMessage_Section&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_ListMessage_Section& default_instance() { - return *internal_default_instance(); - } - static inline const Message_ListMessage_Section* internal_default_instance() { - return reinterpret_cast( - &_Message_ListMessage_Section_default_instance_); - } - static constexpr int kIndexInFileMessages = - 104; - - friend void swap(Message_ListMessage_Section& a, Message_ListMessage_Section& b) { - a.Swap(&b); - } - inline void Swap(Message_ListMessage_Section* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_ListMessage_Section* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_ListMessage_Section* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_ListMessage_Section& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_ListMessage_Section& from) { - Message_ListMessage_Section::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_ListMessage_Section* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.ListMessage.Section"; - } - protected: - explicit Message_ListMessage_Section(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kRowsFieldNumber = 2, - kTitleFieldNumber = 1, - }; - // repeated .proto.Message.ListMessage.Row rows = 2; - int rows_size() const; - private: - int _internal_rows_size() const; - public: - void clear_rows(); - ::proto::Message_ListMessage_Row* mutable_rows(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Row >* - mutable_rows(); - private: - const ::proto::Message_ListMessage_Row& _internal_rows(int index) const; - ::proto::Message_ListMessage_Row* _internal_add_rows(); - public: - const ::proto::Message_ListMessage_Row& rows(int index) const; - ::proto::Message_ListMessage_Row* add_rows(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Row >& - rows() const; - - // optional string title = 1; - bool has_title() const; - private: - bool _internal_has_title() const; - public: - void clear_title(); - const std::string& title() const; - template - void set_title(ArgT0&& arg0, ArgT... args); - std::string* mutable_title(); - PROTOBUF_NODISCARD std::string* release_title(); - void set_allocated_title(std::string* title); - private: - const std::string& _internal_title() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value); - std::string* _internal_mutable_title(); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.ListMessage.Section) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Row > rows_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_ListMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListMessage) */ { - public: - inline Message_ListMessage() : Message_ListMessage(nullptr) {} - ~Message_ListMessage() override; - explicit PROTOBUF_CONSTEXPR Message_ListMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_ListMessage(const Message_ListMessage& from); - Message_ListMessage(Message_ListMessage&& from) noexcept - : Message_ListMessage() { - *this = ::std::move(from); - } - - inline Message_ListMessage& operator=(const Message_ListMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_ListMessage& operator=(Message_ListMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_ListMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_ListMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_ListMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 105; - - friend void swap(Message_ListMessage& a, Message_ListMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_ListMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_ListMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_ListMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_ListMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_ListMessage& from) { - Message_ListMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_ListMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.ListMessage"; - } - protected: - explicit Message_ListMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Message_ListMessage_ProductListHeaderImage ProductListHeaderImage; - typedef Message_ListMessage_ProductListInfo ProductListInfo; - typedef Message_ListMessage_ProductSection ProductSection; - typedef Message_ListMessage_Product Product; - typedef Message_ListMessage_Row Row; - typedef Message_ListMessage_Section Section; - - typedef Message_ListMessage_ListType ListType; - static constexpr ListType UNKNOWN = - Message_ListMessage_ListType_UNKNOWN; - static constexpr ListType SINGLE_SELECT = - Message_ListMessage_ListType_SINGLE_SELECT; - static constexpr ListType PRODUCT_LIST = - Message_ListMessage_ListType_PRODUCT_LIST; - static inline bool ListType_IsValid(int value) { - return Message_ListMessage_ListType_IsValid(value); - } - static constexpr ListType ListType_MIN = - Message_ListMessage_ListType_ListType_MIN; - static constexpr ListType ListType_MAX = - Message_ListMessage_ListType_ListType_MAX; - static constexpr int ListType_ARRAYSIZE = - Message_ListMessage_ListType_ListType_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - ListType_descriptor() { - return Message_ListMessage_ListType_descriptor(); - } - template - static inline const std::string& ListType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function ListType_Name."); - return Message_ListMessage_ListType_Name(enum_t_value); - } - static inline bool ListType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - ListType* value) { - return Message_ListMessage_ListType_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kSectionsFieldNumber = 5, - kTitleFieldNumber = 1, - kDescriptionFieldNumber = 2, - kButtonTextFieldNumber = 3, - kFooterTextFieldNumber = 7, - kProductListInfoFieldNumber = 6, - kContextInfoFieldNumber = 8, - kListTypeFieldNumber = 4, - }; - // repeated .proto.Message.ListMessage.Section sections = 5; - int sections_size() const; - private: - int _internal_sections_size() const; - public: - void clear_sections(); - ::proto::Message_ListMessage_Section* mutable_sections(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Section >* - mutable_sections(); - private: - const ::proto::Message_ListMessage_Section& _internal_sections(int index) const; - ::proto::Message_ListMessage_Section* _internal_add_sections(); - public: - const ::proto::Message_ListMessage_Section& sections(int index) const; - ::proto::Message_ListMessage_Section* add_sections(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Section >& - sections() const; - - // optional string title = 1; - bool has_title() const; - private: - bool _internal_has_title() const; - public: - void clear_title(); - const std::string& title() const; - template - void set_title(ArgT0&& arg0, ArgT... args); - std::string* mutable_title(); - PROTOBUF_NODISCARD std::string* release_title(); - void set_allocated_title(std::string* title); - private: - const std::string& _internal_title() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value); - std::string* _internal_mutable_title(); - public: - - // optional string description = 2; - bool has_description() const; - private: - bool _internal_has_description() const; - public: - void clear_description(); - const std::string& description() const; - template - void set_description(ArgT0&& arg0, ArgT... args); - std::string* mutable_description(); - PROTOBUF_NODISCARD std::string* release_description(); - void set_allocated_description(std::string* description); - private: - const std::string& _internal_description() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value); - std::string* _internal_mutable_description(); - public: - - // optional string buttonText = 3; - bool has_buttontext() const; - private: - bool _internal_has_buttontext() const; - public: - void clear_buttontext(); - const std::string& buttontext() const; - template - void set_buttontext(ArgT0&& arg0, ArgT... args); - std::string* mutable_buttontext(); - PROTOBUF_NODISCARD std::string* release_buttontext(); - void set_allocated_buttontext(std::string* buttontext); - private: - const std::string& _internal_buttontext() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_buttontext(const std::string& value); - std::string* _internal_mutable_buttontext(); - public: - - // optional string footerText = 7; - bool has_footertext() const; - private: - bool _internal_has_footertext() const; - public: - void clear_footertext(); - const std::string& footertext() const; - template - void set_footertext(ArgT0&& arg0, ArgT... args); - std::string* mutable_footertext(); - PROTOBUF_NODISCARD std::string* release_footertext(); - void set_allocated_footertext(std::string* footertext); - private: - const std::string& _internal_footertext() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_footertext(const std::string& value); - std::string* _internal_mutable_footertext(); - public: - - // optional .proto.Message.ListMessage.ProductListInfo productListInfo = 6; - bool has_productlistinfo() const; - private: - bool _internal_has_productlistinfo() const; - public: - void clear_productlistinfo(); - const ::proto::Message_ListMessage_ProductListInfo& productlistinfo() const; - PROTOBUF_NODISCARD ::proto::Message_ListMessage_ProductListInfo* release_productlistinfo(); - ::proto::Message_ListMessage_ProductListInfo* mutable_productlistinfo(); - void set_allocated_productlistinfo(::proto::Message_ListMessage_ProductListInfo* productlistinfo); - private: - const ::proto::Message_ListMessage_ProductListInfo& _internal_productlistinfo() const; - ::proto::Message_ListMessage_ProductListInfo* _internal_mutable_productlistinfo(); - public: - void unsafe_arena_set_allocated_productlistinfo( - ::proto::Message_ListMessage_ProductListInfo* productlistinfo); - ::proto::Message_ListMessage_ProductListInfo* unsafe_arena_release_productlistinfo(); - - // optional .proto.ContextInfo contextInfo = 8; - bool has_contextinfo() const; - private: - bool _internal_has_contextinfo() const; - public: - void clear_contextinfo(); - const ::proto::ContextInfo& contextinfo() const; - PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); - ::proto::ContextInfo* mutable_contextinfo(); - void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); - private: - const ::proto::ContextInfo& _internal_contextinfo() const; - ::proto::ContextInfo* _internal_mutable_contextinfo(); - public: - void unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo); - ::proto::ContextInfo* unsafe_arena_release_contextinfo(); - - // optional .proto.Message.ListMessage.ListType listType = 4; - bool has_listtype() const; - private: - bool _internal_has_listtype() const; - public: - void clear_listtype(); - ::proto::Message_ListMessage_ListType listtype() const; - void set_listtype(::proto::Message_ListMessage_ListType value); - private: - ::proto::Message_ListMessage_ListType _internal_listtype() const; - void _internal_set_listtype(::proto::Message_ListMessage_ListType value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.ListMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Section > sections_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr buttontext_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr footertext_; - ::proto::Message_ListMessage_ProductListInfo* productlistinfo_; - ::proto::ContextInfo* contextinfo_; - int listtype_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_ListResponseMessage_SingleSelectReply final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListResponseMessage.SingleSelectReply) */ { - public: - inline Message_ListResponseMessage_SingleSelectReply() : Message_ListResponseMessage_SingleSelectReply(nullptr) {} - ~Message_ListResponseMessage_SingleSelectReply() override; - explicit PROTOBUF_CONSTEXPR Message_ListResponseMessage_SingleSelectReply(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_ListResponseMessage_SingleSelectReply(const Message_ListResponseMessage_SingleSelectReply& from); - Message_ListResponseMessage_SingleSelectReply(Message_ListResponseMessage_SingleSelectReply&& from) noexcept - : Message_ListResponseMessage_SingleSelectReply() { - *this = ::std::move(from); - } - - inline Message_ListResponseMessage_SingleSelectReply& operator=(const Message_ListResponseMessage_SingleSelectReply& from) { - CopyFrom(from); - return *this; - } - inline Message_ListResponseMessage_SingleSelectReply& operator=(Message_ListResponseMessage_SingleSelectReply&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_ListResponseMessage_SingleSelectReply& default_instance() { - return *internal_default_instance(); - } - static inline const Message_ListResponseMessage_SingleSelectReply* internal_default_instance() { - return reinterpret_cast( - &_Message_ListResponseMessage_SingleSelectReply_default_instance_); - } - static constexpr int kIndexInFileMessages = - 106; - - friend void swap(Message_ListResponseMessage_SingleSelectReply& a, Message_ListResponseMessage_SingleSelectReply& b) { - a.Swap(&b); - } - inline void Swap(Message_ListResponseMessage_SingleSelectReply* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_ListResponseMessage_SingleSelectReply* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_ListResponseMessage_SingleSelectReply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_ListResponseMessage_SingleSelectReply& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_ListResponseMessage_SingleSelectReply& from) { - Message_ListResponseMessage_SingleSelectReply::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_ListResponseMessage_SingleSelectReply* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.ListResponseMessage.SingleSelectReply"; - } - protected: - explicit Message_ListResponseMessage_SingleSelectReply(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kSelectedRowIdFieldNumber = 1, - }; - // optional string selectedRowId = 1; - bool has_selectedrowid() const; - private: - bool _internal_has_selectedrowid() const; - public: - void clear_selectedrowid(); - const std::string& selectedrowid() const; - template - void set_selectedrowid(ArgT0&& arg0, ArgT... args); - std::string* mutable_selectedrowid(); - PROTOBUF_NODISCARD std::string* release_selectedrowid(); - void set_allocated_selectedrowid(std::string* selectedrowid); - private: - const std::string& _internal_selectedrowid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_selectedrowid(const std::string& value); - std::string* _internal_mutable_selectedrowid(); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.ListResponseMessage.SingleSelectReply) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr selectedrowid_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_ListResponseMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListResponseMessage) */ { - public: - inline Message_ListResponseMessage() : Message_ListResponseMessage(nullptr) {} - ~Message_ListResponseMessage() override; - explicit PROTOBUF_CONSTEXPR Message_ListResponseMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_ListResponseMessage(const Message_ListResponseMessage& from); - Message_ListResponseMessage(Message_ListResponseMessage&& from) noexcept - : Message_ListResponseMessage() { - *this = ::std::move(from); - } - - inline Message_ListResponseMessage& operator=(const Message_ListResponseMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_ListResponseMessage& operator=(Message_ListResponseMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_ListResponseMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_ListResponseMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_ListResponseMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 107; - - friend void swap(Message_ListResponseMessage& a, Message_ListResponseMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_ListResponseMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_ListResponseMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_ListResponseMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_ListResponseMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_ListResponseMessage& from) { - Message_ListResponseMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_ListResponseMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.ListResponseMessage"; - } - protected: - explicit Message_ListResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Message_ListResponseMessage_SingleSelectReply SingleSelectReply; - - typedef Message_ListResponseMessage_ListType ListType; - static constexpr ListType UNKNOWN = - Message_ListResponseMessage_ListType_UNKNOWN; - static constexpr ListType SINGLE_SELECT = - Message_ListResponseMessage_ListType_SINGLE_SELECT; - static inline bool ListType_IsValid(int value) { - return Message_ListResponseMessage_ListType_IsValid(value); - } - static constexpr ListType ListType_MIN = - Message_ListResponseMessage_ListType_ListType_MIN; - static constexpr ListType ListType_MAX = - Message_ListResponseMessage_ListType_ListType_MAX; - static constexpr int ListType_ARRAYSIZE = - Message_ListResponseMessage_ListType_ListType_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - ListType_descriptor() { - return Message_ListResponseMessage_ListType_descriptor(); - } - template - static inline const std::string& ListType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function ListType_Name."); - return Message_ListResponseMessage_ListType_Name(enum_t_value); - } - static inline bool ListType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - ListType* value) { - return Message_ListResponseMessage_ListType_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kTitleFieldNumber = 1, - kDescriptionFieldNumber = 5, - kSingleSelectReplyFieldNumber = 3, - kContextInfoFieldNumber = 4, - kListTypeFieldNumber = 2, - }; - // optional string title = 1; - bool has_title() const; - private: - bool _internal_has_title() const; - public: - void clear_title(); - const std::string& title() const; - template - void set_title(ArgT0&& arg0, ArgT... args); - std::string* mutable_title(); - PROTOBUF_NODISCARD std::string* release_title(); - void set_allocated_title(std::string* title); - private: - const std::string& _internal_title() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value); - std::string* _internal_mutable_title(); - public: - - // optional string description = 5; - bool has_description() const; - private: - bool _internal_has_description() const; - public: - void clear_description(); - const std::string& description() const; - template - void set_description(ArgT0&& arg0, ArgT... args); - std::string* mutable_description(); - PROTOBUF_NODISCARD std::string* release_description(); - void set_allocated_description(std::string* description); - private: - const std::string& _internal_description() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value); - std::string* _internal_mutable_description(); - public: - - // optional .proto.Message.ListResponseMessage.SingleSelectReply singleSelectReply = 3; - bool has_singleselectreply() const; - private: - bool _internal_has_singleselectreply() const; - public: - void clear_singleselectreply(); - const ::proto::Message_ListResponseMessage_SingleSelectReply& singleselectreply() const; - PROTOBUF_NODISCARD ::proto::Message_ListResponseMessage_SingleSelectReply* release_singleselectreply(); - ::proto::Message_ListResponseMessage_SingleSelectReply* mutable_singleselectreply(); - void set_allocated_singleselectreply(::proto::Message_ListResponseMessage_SingleSelectReply* singleselectreply); - private: - const ::proto::Message_ListResponseMessage_SingleSelectReply& _internal_singleselectreply() const; - ::proto::Message_ListResponseMessage_SingleSelectReply* _internal_mutable_singleselectreply(); - public: - void unsafe_arena_set_allocated_singleselectreply( - ::proto::Message_ListResponseMessage_SingleSelectReply* singleselectreply); - ::proto::Message_ListResponseMessage_SingleSelectReply* unsafe_arena_release_singleselectreply(); - - // optional .proto.ContextInfo contextInfo = 4; - bool has_contextinfo() const; - private: - bool _internal_has_contextinfo() const; - public: - void clear_contextinfo(); - const ::proto::ContextInfo& contextinfo() const; - PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); - ::proto::ContextInfo* mutable_contextinfo(); - void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); - private: - const ::proto::ContextInfo& _internal_contextinfo() const; - ::proto::ContextInfo* _internal_mutable_contextinfo(); - public: - void unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo); - ::proto::ContextInfo* unsafe_arena_release_contextinfo(); - - // optional .proto.Message.ListResponseMessage.ListType listType = 2; - bool has_listtype() const; - private: - bool _internal_has_listtype() const; - public: - void clear_listtype(); - ::proto::Message_ListResponseMessage_ListType listtype() const; - void set_listtype(::proto::Message_ListResponseMessage_ListType value); - private: - ::proto::Message_ListResponseMessage_ListType _internal_listtype() const; - void _internal_set_listtype(::proto::Message_ListResponseMessage_ListType value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.ListResponseMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_; - ::proto::Message_ListResponseMessage_SingleSelectReply* singleselectreply_; - ::proto::ContextInfo* contextinfo_; - int listtype_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_LiveLocationMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.LiveLocationMessage) */ { - public: - inline Message_LiveLocationMessage() : Message_LiveLocationMessage(nullptr) {} - ~Message_LiveLocationMessage() override; - explicit PROTOBUF_CONSTEXPR Message_LiveLocationMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_LiveLocationMessage(const Message_LiveLocationMessage& from); - Message_LiveLocationMessage(Message_LiveLocationMessage&& from) noexcept - : Message_LiveLocationMessage() { - *this = ::std::move(from); - } - - inline Message_LiveLocationMessage& operator=(const Message_LiveLocationMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_LiveLocationMessage& operator=(Message_LiveLocationMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_LiveLocationMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_LiveLocationMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_LiveLocationMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 108; - - friend void swap(Message_LiveLocationMessage& a, Message_LiveLocationMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_LiveLocationMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_LiveLocationMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_LiveLocationMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_LiveLocationMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_LiveLocationMessage& from) { - Message_LiveLocationMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_LiveLocationMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.LiveLocationMessage"; - } - protected: - explicit Message_LiveLocationMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kCaptionFieldNumber = 6, - kJpegThumbnailFieldNumber = 16, - kContextInfoFieldNumber = 17, - kDegreesLatitudeFieldNumber = 1, - kDegreesLongitudeFieldNumber = 2, - kAccuracyInMetersFieldNumber = 3, - kSpeedInMpsFieldNumber = 4, - kDegreesClockwiseFromMagneticNorthFieldNumber = 5, - kTimeOffsetFieldNumber = 8, - kSequenceNumberFieldNumber = 7, - }; - // optional string caption = 6; - bool has_caption() const; - private: - bool _internal_has_caption() const; - public: - void clear_caption(); - const std::string& caption() const; - template - void set_caption(ArgT0&& arg0, ArgT... args); - std::string* mutable_caption(); - PROTOBUF_NODISCARD std::string* release_caption(); - void set_allocated_caption(std::string* caption); - private: - const std::string& _internal_caption() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_caption(const std::string& value); - std::string* _internal_mutable_caption(); - public: - - // optional bytes jpegThumbnail = 16; - bool has_jpegthumbnail() const; - private: - bool _internal_has_jpegthumbnail() const; - public: - void clear_jpegthumbnail(); - const std::string& jpegthumbnail() const; - template - void set_jpegthumbnail(ArgT0&& arg0, ArgT... args); - std::string* mutable_jpegthumbnail(); - PROTOBUF_NODISCARD std::string* release_jpegthumbnail(); - void set_allocated_jpegthumbnail(std::string* jpegthumbnail); - private: - const std::string& _internal_jpegthumbnail() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value); - std::string* _internal_mutable_jpegthumbnail(); - public: - - // optional .proto.ContextInfo contextInfo = 17; - bool has_contextinfo() const; - private: - bool _internal_has_contextinfo() const; - public: - void clear_contextinfo(); - const ::proto::ContextInfo& contextinfo() const; - PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); - ::proto::ContextInfo* mutable_contextinfo(); - void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); - private: - const ::proto::ContextInfo& _internal_contextinfo() const; - ::proto::ContextInfo* _internal_mutable_contextinfo(); - public: - void unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo); - ::proto::ContextInfo* unsafe_arena_release_contextinfo(); - - // optional double degreesLatitude = 1; - bool has_degreeslatitude() const; - private: - bool _internal_has_degreeslatitude() const; - public: - void clear_degreeslatitude(); - double degreeslatitude() const; - void set_degreeslatitude(double value); - private: - double _internal_degreeslatitude() const; - void _internal_set_degreeslatitude(double value); - public: - - // optional double degreesLongitude = 2; - bool has_degreeslongitude() const; - private: - bool _internal_has_degreeslongitude() const; - public: - void clear_degreeslongitude(); - double degreeslongitude() const; - void set_degreeslongitude(double value); - private: - double _internal_degreeslongitude() const; - void _internal_set_degreeslongitude(double value); - public: - - // optional uint32 accuracyInMeters = 3; - bool has_accuracyinmeters() const; - private: - bool _internal_has_accuracyinmeters() const; - public: - void clear_accuracyinmeters(); - uint32_t accuracyinmeters() const; - void set_accuracyinmeters(uint32_t value); - private: - uint32_t _internal_accuracyinmeters() const; - void _internal_set_accuracyinmeters(uint32_t value); - public: - - // optional float speedInMps = 4; - bool has_speedinmps() const; - private: - bool _internal_has_speedinmps() const; - public: - void clear_speedinmps(); - float speedinmps() const; - void set_speedinmps(float value); - private: - float _internal_speedinmps() const; - void _internal_set_speedinmps(float value); - public: - - // optional uint32 degreesClockwiseFromMagneticNorth = 5; - bool has_degreesclockwisefrommagneticnorth() const; - private: - bool _internal_has_degreesclockwisefrommagneticnorth() const; - public: - void clear_degreesclockwisefrommagneticnorth(); - uint32_t degreesclockwisefrommagneticnorth() const; - void set_degreesclockwisefrommagneticnorth(uint32_t value); - private: - uint32_t _internal_degreesclockwisefrommagneticnorth() const; - void _internal_set_degreesclockwisefrommagneticnorth(uint32_t value); - public: - - // optional uint32 timeOffset = 8; - bool has_timeoffset() const; - private: - bool _internal_has_timeoffset() const; - public: - void clear_timeoffset(); - uint32_t timeoffset() const; - void set_timeoffset(uint32_t value); - private: - uint32_t _internal_timeoffset() const; - void _internal_set_timeoffset(uint32_t value); - public: - - // optional int64 sequenceNumber = 7; - bool has_sequencenumber() const; - private: - bool _internal_has_sequencenumber() const; - public: - void clear_sequencenumber(); - int64_t sequencenumber() const; - void set_sequencenumber(int64_t value); - private: - int64_t _internal_sequencenumber() const; - void _internal_set_sequencenumber(int64_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.LiveLocationMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr caption_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_; - ::proto::ContextInfo* contextinfo_; - double degreeslatitude_; - double degreeslongitude_; - uint32_t accuracyinmeters_; - float speedinmps_; - uint32_t degreesclockwisefrommagneticnorth_; - uint32_t timeoffset_; - int64_t sequencenumber_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_LocationMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.LocationMessage) */ { - public: - inline Message_LocationMessage() : Message_LocationMessage(nullptr) {} - ~Message_LocationMessage() override; - explicit PROTOBUF_CONSTEXPR Message_LocationMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_LocationMessage(const Message_LocationMessage& from); - Message_LocationMessage(Message_LocationMessage&& from) noexcept - : Message_LocationMessage() { - *this = ::std::move(from); - } - - inline Message_LocationMessage& operator=(const Message_LocationMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_LocationMessage& operator=(Message_LocationMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_LocationMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_LocationMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_LocationMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 109; - - friend void swap(Message_LocationMessage& a, Message_LocationMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_LocationMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_LocationMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_LocationMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_LocationMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_LocationMessage& from) { - Message_LocationMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_LocationMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.LocationMessage"; - } - protected: - explicit Message_LocationMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kNameFieldNumber = 3, - kAddressFieldNumber = 4, - kUrlFieldNumber = 5, - kCommentFieldNumber = 11, - kJpegThumbnailFieldNumber = 16, - kContextInfoFieldNumber = 17, - kDegreesLatitudeFieldNumber = 1, - kDegreesLongitudeFieldNumber = 2, - kIsLiveFieldNumber = 6, - kAccuracyInMetersFieldNumber = 7, - kSpeedInMpsFieldNumber = 8, - kDegreesClockwiseFromMagneticNorthFieldNumber = 9, - }; - // optional string name = 3; - bool has_name() const; - private: - bool _internal_has_name() const; - public: - void clear_name(); - const std::string& name() const; - template - void set_name(ArgT0&& arg0, ArgT... args); - std::string* mutable_name(); - PROTOBUF_NODISCARD std::string* release_name(); - void set_allocated_name(std::string* name); - private: - const std::string& _internal_name() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); - std::string* _internal_mutable_name(); - public: - - // optional string address = 4; - bool has_address() const; - private: - bool _internal_has_address() const; - public: - void clear_address(); - const std::string& address() const; - template - void set_address(ArgT0&& arg0, ArgT... args); - std::string* mutable_address(); - PROTOBUF_NODISCARD std::string* release_address(); - void set_allocated_address(std::string* address); - private: - const std::string& _internal_address() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_address(const std::string& value); - std::string* _internal_mutable_address(); - public: - - // optional string url = 5; - bool has_url() const; - private: - bool _internal_has_url() const; - public: - void clear_url(); - const std::string& url() const; - template - void set_url(ArgT0&& arg0, ArgT... args); - std::string* mutable_url(); - PROTOBUF_NODISCARD std::string* release_url(); - void set_allocated_url(std::string* url); - private: - const std::string& _internal_url() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value); - std::string* _internal_mutable_url(); - public: - - // optional string comment = 11; - bool has_comment() const; - private: - bool _internal_has_comment() const; - public: - void clear_comment(); - const std::string& comment() const; - template - void set_comment(ArgT0&& arg0, ArgT... args); - std::string* mutable_comment(); - PROTOBUF_NODISCARD std::string* release_comment(); - void set_allocated_comment(std::string* comment); - private: - const std::string& _internal_comment() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_comment(const std::string& value); - std::string* _internal_mutable_comment(); - public: - - // optional bytes jpegThumbnail = 16; - bool has_jpegthumbnail() const; - private: - bool _internal_has_jpegthumbnail() const; - public: - void clear_jpegthumbnail(); - const std::string& jpegthumbnail() const; - template - void set_jpegthumbnail(ArgT0&& arg0, ArgT... args); - std::string* mutable_jpegthumbnail(); - PROTOBUF_NODISCARD std::string* release_jpegthumbnail(); - void set_allocated_jpegthumbnail(std::string* jpegthumbnail); - private: - const std::string& _internal_jpegthumbnail() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value); - std::string* _internal_mutable_jpegthumbnail(); - public: - - // optional .proto.ContextInfo contextInfo = 17; - bool has_contextinfo() const; - private: - bool _internal_has_contextinfo() const; - public: - void clear_contextinfo(); - const ::proto::ContextInfo& contextinfo() const; - PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); - ::proto::ContextInfo* mutable_contextinfo(); - void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); - private: - const ::proto::ContextInfo& _internal_contextinfo() const; - ::proto::ContextInfo* _internal_mutable_contextinfo(); - public: - void unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo); - ::proto::ContextInfo* unsafe_arena_release_contextinfo(); - - // optional double degreesLatitude = 1; - bool has_degreeslatitude() const; - private: - bool _internal_has_degreeslatitude() const; - public: - void clear_degreeslatitude(); - double degreeslatitude() const; - void set_degreeslatitude(double value); - private: - double _internal_degreeslatitude() const; - void _internal_set_degreeslatitude(double value); - public: - - // optional double degreesLongitude = 2; - bool has_degreeslongitude() const; - private: - bool _internal_has_degreeslongitude() const; - public: - void clear_degreeslongitude(); - double degreeslongitude() const; - void set_degreeslongitude(double value); - private: - double _internal_degreeslongitude() const; - void _internal_set_degreeslongitude(double value); - public: - - // optional bool isLive = 6; - bool has_islive() const; - private: - bool _internal_has_islive() const; - public: - void clear_islive(); - bool islive() const; - void set_islive(bool value); - private: - bool _internal_islive() const; - void _internal_set_islive(bool value); - public: - - // optional uint32 accuracyInMeters = 7; - bool has_accuracyinmeters() const; - private: - bool _internal_has_accuracyinmeters() const; - public: - void clear_accuracyinmeters(); - uint32_t accuracyinmeters() const; - void set_accuracyinmeters(uint32_t value); - private: - uint32_t _internal_accuracyinmeters() const; - void _internal_set_accuracyinmeters(uint32_t value); - public: - - // optional float speedInMps = 8; - bool has_speedinmps() const; - private: - bool _internal_has_speedinmps() const; - public: - void clear_speedinmps(); - float speedinmps() const; - void set_speedinmps(float value); - private: - float _internal_speedinmps() const; - void _internal_set_speedinmps(float value); - public: - - // optional uint32 degreesClockwiseFromMagneticNorth = 9; - bool has_degreesclockwisefrommagneticnorth() const; - private: - bool _internal_has_degreesclockwisefrommagneticnorth() const; - public: - void clear_degreesclockwisefrommagneticnorth(); - uint32_t degreesclockwisefrommagneticnorth() const; - void set_degreesclockwisefrommagneticnorth(uint32_t value); - private: - uint32_t _internal_degreesclockwisefrommagneticnorth() const; - void _internal_set_degreesclockwisefrommagneticnorth(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.LocationMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr address_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr comment_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_; - ::proto::ContextInfo* contextinfo_; - double degreeslatitude_; - double degreeslongitude_; - bool islive_; - uint32_t accuracyinmeters_; - float speedinmps_; - uint32_t degreesclockwisefrommagneticnorth_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_OrderMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.OrderMessage) */ { - public: - inline Message_OrderMessage() : Message_OrderMessage(nullptr) {} - ~Message_OrderMessage() override; - explicit PROTOBUF_CONSTEXPR Message_OrderMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_OrderMessage(const Message_OrderMessage& from); - Message_OrderMessage(Message_OrderMessage&& from) noexcept - : Message_OrderMessage() { - *this = ::std::move(from); - } - - inline Message_OrderMessage& operator=(const Message_OrderMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_OrderMessage& operator=(Message_OrderMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_OrderMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_OrderMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_OrderMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 110; - - friend void swap(Message_OrderMessage& a, Message_OrderMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_OrderMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_OrderMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_OrderMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_OrderMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_OrderMessage& from) { - Message_OrderMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_OrderMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.OrderMessage"; - } - protected: - explicit Message_OrderMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Message_OrderMessage_OrderStatus OrderStatus; - static constexpr OrderStatus INQUIRY = - Message_OrderMessage_OrderStatus_INQUIRY; - static inline bool OrderStatus_IsValid(int value) { - return Message_OrderMessage_OrderStatus_IsValid(value); - } - static constexpr OrderStatus OrderStatus_MIN = - Message_OrderMessage_OrderStatus_OrderStatus_MIN; - static constexpr OrderStatus OrderStatus_MAX = - Message_OrderMessage_OrderStatus_OrderStatus_MAX; - static constexpr int OrderStatus_ARRAYSIZE = - Message_OrderMessage_OrderStatus_OrderStatus_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - OrderStatus_descriptor() { - return Message_OrderMessage_OrderStatus_descriptor(); - } - template - static inline const std::string& OrderStatus_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function OrderStatus_Name."); - return Message_OrderMessage_OrderStatus_Name(enum_t_value); - } - static inline bool OrderStatus_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - OrderStatus* value) { - return Message_OrderMessage_OrderStatus_Parse(name, value); - } - - typedef Message_OrderMessage_OrderSurface OrderSurface; - static constexpr OrderSurface CATALOG = - Message_OrderMessage_OrderSurface_CATALOG; - static inline bool OrderSurface_IsValid(int value) { - return Message_OrderMessage_OrderSurface_IsValid(value); - } - static constexpr OrderSurface OrderSurface_MIN = - Message_OrderMessage_OrderSurface_OrderSurface_MIN; - static constexpr OrderSurface OrderSurface_MAX = - Message_OrderMessage_OrderSurface_OrderSurface_MAX; - static constexpr int OrderSurface_ARRAYSIZE = - Message_OrderMessage_OrderSurface_OrderSurface_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - OrderSurface_descriptor() { - return Message_OrderMessage_OrderSurface_descriptor(); - } - template - static inline const std::string& OrderSurface_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function OrderSurface_Name."); - return Message_OrderMessage_OrderSurface_Name(enum_t_value); - } - static inline bool OrderSurface_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - OrderSurface* value) { - return Message_OrderMessage_OrderSurface_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kOrderIdFieldNumber = 1, - kThumbnailFieldNumber = 2, - kMessageFieldNumber = 6, - kOrderTitleFieldNumber = 7, - kSellerJidFieldNumber = 8, - kTokenFieldNumber = 9, - kTotalCurrencyCodeFieldNumber = 11, - kContextInfoFieldNumber = 17, - kTotalAmount1000FieldNumber = 10, - kItemCountFieldNumber = 3, - kStatusFieldNumber = 4, - kSurfaceFieldNumber = 5, - }; - // optional string orderId = 1; - bool has_orderid() const; - private: - bool _internal_has_orderid() const; - public: - void clear_orderid(); - const std::string& orderid() const; - template - void set_orderid(ArgT0&& arg0, ArgT... args); - std::string* mutable_orderid(); - PROTOBUF_NODISCARD std::string* release_orderid(); - void set_allocated_orderid(std::string* orderid); - private: - const std::string& _internal_orderid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_orderid(const std::string& value); - std::string* _internal_mutable_orderid(); - public: - - // optional bytes thumbnail = 2; - bool has_thumbnail() const; - private: - bool _internal_has_thumbnail() const; - public: - void clear_thumbnail(); - const std::string& thumbnail() const; - template - void set_thumbnail(ArgT0&& arg0, ArgT... args); - std::string* mutable_thumbnail(); - PROTOBUF_NODISCARD std::string* release_thumbnail(); - void set_allocated_thumbnail(std::string* thumbnail); - private: - const std::string& _internal_thumbnail() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnail(const std::string& value); - std::string* _internal_mutable_thumbnail(); - public: - - // optional string message = 6; - bool has_message() const; - private: - bool _internal_has_message() const; - public: - void clear_message(); - const std::string& message() const; - template - void set_message(ArgT0&& arg0, ArgT... args); - std::string* mutable_message(); - PROTOBUF_NODISCARD std::string* release_message(); - void set_allocated_message(std::string* message); - private: - const std::string& _internal_message() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_message(const std::string& value); - std::string* _internal_mutable_message(); - public: - - // optional string orderTitle = 7; - bool has_ordertitle() const; - private: - bool _internal_has_ordertitle() const; - public: - void clear_ordertitle(); - const std::string& ordertitle() const; - template - void set_ordertitle(ArgT0&& arg0, ArgT... args); - std::string* mutable_ordertitle(); - PROTOBUF_NODISCARD std::string* release_ordertitle(); - void set_allocated_ordertitle(std::string* ordertitle); - private: - const std::string& _internal_ordertitle() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_ordertitle(const std::string& value); - std::string* _internal_mutable_ordertitle(); - public: - - // optional string sellerJid = 8; - bool has_sellerjid() const; - private: - bool _internal_has_sellerjid() const; - public: - void clear_sellerjid(); - const std::string& sellerjid() const; - template - void set_sellerjid(ArgT0&& arg0, ArgT... args); - std::string* mutable_sellerjid(); - PROTOBUF_NODISCARD std::string* release_sellerjid(); - void set_allocated_sellerjid(std::string* sellerjid); - private: - const std::string& _internal_sellerjid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_sellerjid(const std::string& value); - std::string* _internal_mutable_sellerjid(); - public: - - // optional string token = 9; - bool has_token() const; - private: - bool _internal_has_token() const; - public: - void clear_token(); - const std::string& token() const; - template - void set_token(ArgT0&& arg0, ArgT... args); - std::string* mutable_token(); - PROTOBUF_NODISCARD std::string* release_token(); - void set_allocated_token(std::string* token); - private: - const std::string& _internal_token() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_token(const std::string& value); - std::string* _internal_mutable_token(); - public: - - // optional string totalCurrencyCode = 11; - bool has_totalcurrencycode() const; - private: - bool _internal_has_totalcurrencycode() const; - public: - void clear_totalcurrencycode(); - const std::string& totalcurrencycode() const; - template - void set_totalcurrencycode(ArgT0&& arg0, ArgT... args); - std::string* mutable_totalcurrencycode(); - PROTOBUF_NODISCARD std::string* release_totalcurrencycode(); - void set_allocated_totalcurrencycode(std::string* totalcurrencycode); - private: - const std::string& _internal_totalcurrencycode() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_totalcurrencycode(const std::string& value); - std::string* _internal_mutable_totalcurrencycode(); - public: - - // optional .proto.ContextInfo contextInfo = 17; - bool has_contextinfo() const; - private: - bool _internal_has_contextinfo() const; - public: - void clear_contextinfo(); - const ::proto::ContextInfo& contextinfo() const; - PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); - ::proto::ContextInfo* mutable_contextinfo(); - void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); - private: - const ::proto::ContextInfo& _internal_contextinfo() const; - ::proto::ContextInfo* _internal_mutable_contextinfo(); - public: - void unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo); - ::proto::ContextInfo* unsafe_arena_release_contextinfo(); - - // optional int64 totalAmount1000 = 10; - bool has_totalamount1000() const; - private: - bool _internal_has_totalamount1000() const; - public: - void clear_totalamount1000(); - int64_t totalamount1000() const; - void set_totalamount1000(int64_t value); - private: - int64_t _internal_totalamount1000() const; - void _internal_set_totalamount1000(int64_t value); - public: - - // optional int32 itemCount = 3; - bool has_itemcount() const; - private: - bool _internal_has_itemcount() const; - public: - void clear_itemcount(); - int32_t itemcount() const; - void set_itemcount(int32_t value); - private: - int32_t _internal_itemcount() const; - void _internal_set_itemcount(int32_t value); - public: - - // optional .proto.Message.OrderMessage.OrderStatus status = 4; - bool has_status() const; - private: - bool _internal_has_status() const; - public: - void clear_status(); - ::proto::Message_OrderMessage_OrderStatus status() const; - void set_status(::proto::Message_OrderMessage_OrderStatus value); - private: - ::proto::Message_OrderMessage_OrderStatus _internal_status() const; - void _internal_set_status(::proto::Message_OrderMessage_OrderStatus value); - public: - - // optional .proto.Message.OrderMessage.OrderSurface surface = 5; - bool has_surface() const; - private: - bool _internal_has_surface() const; - public: - void clear_surface(); - ::proto::Message_OrderMessage_OrderSurface surface() const; - void set_surface(::proto::Message_OrderMessage_OrderSurface value); - private: - ::proto::Message_OrderMessage_OrderSurface _internal_surface() const; - void _internal_set_surface(::proto::Message_OrderMessage_OrderSurface value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.OrderMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr orderid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnail_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ordertitle_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sellerjid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr token_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr totalcurrencycode_; - ::proto::ContextInfo* contextinfo_; - int64_t totalamount1000_; - int32_t itemcount_; - int status_; - int surface_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_PaymentInviteMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.PaymentInviteMessage) */ { - public: - inline Message_PaymentInviteMessage() : Message_PaymentInviteMessage(nullptr) {} - ~Message_PaymentInviteMessage() override; - explicit PROTOBUF_CONSTEXPR Message_PaymentInviteMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_PaymentInviteMessage(const Message_PaymentInviteMessage& from); - Message_PaymentInviteMessage(Message_PaymentInviteMessage&& from) noexcept - : Message_PaymentInviteMessage() { - *this = ::std::move(from); - } - - inline Message_PaymentInviteMessage& operator=(const Message_PaymentInviteMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_PaymentInviteMessage& operator=(Message_PaymentInviteMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_PaymentInviteMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_PaymentInviteMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_PaymentInviteMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 111; - - friend void swap(Message_PaymentInviteMessage& a, Message_PaymentInviteMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_PaymentInviteMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_PaymentInviteMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_PaymentInviteMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_PaymentInviteMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_PaymentInviteMessage& from) { - Message_PaymentInviteMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_PaymentInviteMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.PaymentInviteMessage"; - } - protected: - explicit Message_PaymentInviteMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Message_PaymentInviteMessage_ServiceType ServiceType; - static constexpr ServiceType UNKNOWN = - Message_PaymentInviteMessage_ServiceType_UNKNOWN; - static constexpr ServiceType FBPAY = - Message_PaymentInviteMessage_ServiceType_FBPAY; - static constexpr ServiceType NOVI = - Message_PaymentInviteMessage_ServiceType_NOVI; - static constexpr ServiceType UPI = - Message_PaymentInviteMessage_ServiceType_UPI; - static inline bool ServiceType_IsValid(int value) { - return Message_PaymentInviteMessage_ServiceType_IsValid(value); - } - static constexpr ServiceType ServiceType_MIN = - Message_PaymentInviteMessage_ServiceType_ServiceType_MIN; - static constexpr ServiceType ServiceType_MAX = - Message_PaymentInviteMessage_ServiceType_ServiceType_MAX; - static constexpr int ServiceType_ARRAYSIZE = - Message_PaymentInviteMessage_ServiceType_ServiceType_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - ServiceType_descriptor() { - return Message_PaymentInviteMessage_ServiceType_descriptor(); - } - template - static inline const std::string& ServiceType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function ServiceType_Name."); - return Message_PaymentInviteMessage_ServiceType_Name(enum_t_value); - } - static inline bool ServiceType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - ServiceType* value) { - return Message_PaymentInviteMessage_ServiceType_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kExpiryTimestampFieldNumber = 2, - kServiceTypeFieldNumber = 1, - }; - // optional int64 expiryTimestamp = 2; - bool has_expirytimestamp() const; - private: - bool _internal_has_expirytimestamp() const; - public: - void clear_expirytimestamp(); - int64_t expirytimestamp() const; - void set_expirytimestamp(int64_t value); - private: - int64_t _internal_expirytimestamp() const; - void _internal_set_expirytimestamp(int64_t value); - public: - - // optional .proto.Message.PaymentInviteMessage.ServiceType serviceType = 1; - bool has_servicetype() const; - private: - bool _internal_has_servicetype() const; - public: - void clear_servicetype(); - ::proto::Message_PaymentInviteMessage_ServiceType servicetype() const; - void set_servicetype(::proto::Message_PaymentInviteMessage_ServiceType value); - private: - ::proto::Message_PaymentInviteMessage_ServiceType _internal_servicetype() const; - void _internal_set_servicetype(::proto::Message_PaymentInviteMessage_ServiceType value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.PaymentInviteMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - int64_t expirytimestamp_; - int servicetype_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_PollCreationMessage_Option final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.PollCreationMessage.Option) */ { - public: - inline Message_PollCreationMessage_Option() : Message_PollCreationMessage_Option(nullptr) {} - ~Message_PollCreationMessage_Option() override; - explicit PROTOBUF_CONSTEXPR Message_PollCreationMessage_Option(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_PollCreationMessage_Option(const Message_PollCreationMessage_Option& from); - Message_PollCreationMessage_Option(Message_PollCreationMessage_Option&& from) noexcept - : Message_PollCreationMessage_Option() { - *this = ::std::move(from); - } - - inline Message_PollCreationMessage_Option& operator=(const Message_PollCreationMessage_Option& from) { - CopyFrom(from); - return *this; - } - inline Message_PollCreationMessage_Option& operator=(Message_PollCreationMessage_Option&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_PollCreationMessage_Option& default_instance() { - return *internal_default_instance(); - } - static inline const Message_PollCreationMessage_Option* internal_default_instance() { - return reinterpret_cast( - &_Message_PollCreationMessage_Option_default_instance_); - } - static constexpr int kIndexInFileMessages = - 112; - - friend void swap(Message_PollCreationMessage_Option& a, Message_PollCreationMessage_Option& b) { - a.Swap(&b); - } - inline void Swap(Message_PollCreationMessage_Option* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_PollCreationMessage_Option* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_PollCreationMessage_Option* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_PollCreationMessage_Option& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_PollCreationMessage_Option& from) { - Message_PollCreationMessage_Option::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_PollCreationMessage_Option* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.PollCreationMessage.Option"; - } - protected: - explicit Message_PollCreationMessage_Option(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kOptionNameFieldNumber = 1, - }; - // optional string optionName = 1; - bool has_optionname() const; - private: - bool _internal_has_optionname() const; - public: - void clear_optionname(); - const std::string& optionname() const; - template - void set_optionname(ArgT0&& arg0, ArgT... args); - std::string* mutable_optionname(); - PROTOBUF_NODISCARD std::string* release_optionname(); - void set_allocated_optionname(std::string* optionname); - private: - const std::string& _internal_optionname() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_optionname(const std::string& value); - std::string* _internal_mutable_optionname(); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.PollCreationMessage.Option) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr optionname_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_PollCreationMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.PollCreationMessage) */ { - public: - inline Message_PollCreationMessage() : Message_PollCreationMessage(nullptr) {} - ~Message_PollCreationMessage() override; - explicit PROTOBUF_CONSTEXPR Message_PollCreationMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_PollCreationMessage(const Message_PollCreationMessage& from); - Message_PollCreationMessage(Message_PollCreationMessage&& from) noexcept - : Message_PollCreationMessage() { - *this = ::std::move(from); - } - - inline Message_PollCreationMessage& operator=(const Message_PollCreationMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_PollCreationMessage& operator=(Message_PollCreationMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_PollCreationMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_PollCreationMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_PollCreationMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 113; - - friend void swap(Message_PollCreationMessage& a, Message_PollCreationMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_PollCreationMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_PollCreationMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_PollCreationMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_PollCreationMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_PollCreationMessage& from) { - Message_PollCreationMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_PollCreationMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.PollCreationMessage"; - } - protected: - explicit Message_PollCreationMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Message_PollCreationMessage_Option Option; - - // accessors ------------------------------------------------------- - - enum : int { - kOptionsFieldNumber = 3, - kEncKeyFieldNumber = 1, - kNameFieldNumber = 2, - kContextInfoFieldNumber = 5, - kSelectableOptionsCountFieldNumber = 4, - }; - // repeated .proto.Message.PollCreationMessage.Option options = 3; - int options_size() const; - private: - int _internal_options_size() const; - public: - void clear_options(); - ::proto::Message_PollCreationMessage_Option* mutable_options(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_PollCreationMessage_Option >* - mutable_options(); - private: - const ::proto::Message_PollCreationMessage_Option& _internal_options(int index) const; - ::proto::Message_PollCreationMessage_Option* _internal_add_options(); - public: - const ::proto::Message_PollCreationMessage_Option& options(int index) const; - ::proto::Message_PollCreationMessage_Option* add_options(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_PollCreationMessage_Option >& - options() const; - - // optional bytes encKey = 1; - bool has_enckey() const; - private: - bool _internal_has_enckey() const; - public: - void clear_enckey(); - const std::string& enckey() const; - template - void set_enckey(ArgT0&& arg0, ArgT... args); - std::string* mutable_enckey(); - PROTOBUF_NODISCARD std::string* release_enckey(); - void set_allocated_enckey(std::string* enckey); - private: - const std::string& _internal_enckey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_enckey(const std::string& value); - std::string* _internal_mutable_enckey(); - public: - - // optional string name = 2; - bool has_name() const; - private: - bool _internal_has_name() const; - public: - void clear_name(); - const std::string& name() const; - template - void set_name(ArgT0&& arg0, ArgT... args); - std::string* mutable_name(); - PROTOBUF_NODISCARD std::string* release_name(); - void set_allocated_name(std::string* name); - private: - const std::string& _internal_name() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); - std::string* _internal_mutable_name(); - public: - - // optional .proto.ContextInfo contextInfo = 5; - bool has_contextinfo() const; - private: - bool _internal_has_contextinfo() const; - public: - void clear_contextinfo(); - const ::proto::ContextInfo& contextinfo() const; - PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); - ::proto::ContextInfo* mutable_contextinfo(); - void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); - private: - const ::proto::ContextInfo& _internal_contextinfo() const; - ::proto::ContextInfo* _internal_mutable_contextinfo(); - public: - void unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo); - ::proto::ContextInfo* unsafe_arena_release_contextinfo(); - - // optional uint32 selectableOptionsCount = 4; - bool has_selectableoptionscount() const; - private: - bool _internal_has_selectableoptionscount() const; - public: - void clear_selectableoptionscount(); - uint32_t selectableoptionscount() const; - void set_selectableoptionscount(uint32_t value); - private: - uint32_t _internal_selectableoptionscount() const; - void _internal_set_selectableoptionscount(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.PollCreationMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_PollCreationMessage_Option > options_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr enckey_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - ::proto::ContextInfo* contextinfo_; - uint32_t selectableoptionscount_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_PollEncValue final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.PollEncValue) */ { - public: - inline Message_PollEncValue() : Message_PollEncValue(nullptr) {} - ~Message_PollEncValue() override; - explicit PROTOBUF_CONSTEXPR Message_PollEncValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_PollEncValue(const Message_PollEncValue& from); - Message_PollEncValue(Message_PollEncValue&& from) noexcept - : Message_PollEncValue() { - *this = ::std::move(from); - } - - inline Message_PollEncValue& operator=(const Message_PollEncValue& from) { - CopyFrom(from); - return *this; - } - inline Message_PollEncValue& operator=(Message_PollEncValue&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_PollEncValue& default_instance() { - return *internal_default_instance(); - } - static inline const Message_PollEncValue* internal_default_instance() { - return reinterpret_cast( - &_Message_PollEncValue_default_instance_); - } - static constexpr int kIndexInFileMessages = - 114; - - friend void swap(Message_PollEncValue& a, Message_PollEncValue& b) { - a.Swap(&b); - } - inline void Swap(Message_PollEncValue* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_PollEncValue* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_PollEncValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_PollEncValue& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_PollEncValue& from) { - Message_PollEncValue::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_PollEncValue* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.PollEncValue"; - } - protected: - explicit Message_PollEncValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kEncPayloadFieldNumber = 1, - kEncIvFieldNumber = 2, - }; - // optional bytes encPayload = 1; - bool has_encpayload() const; - private: - bool _internal_has_encpayload() const; - public: - void clear_encpayload(); - const std::string& encpayload() const; - template - void set_encpayload(ArgT0&& arg0, ArgT... args); - std::string* mutable_encpayload(); - PROTOBUF_NODISCARD std::string* release_encpayload(); - void set_allocated_encpayload(std::string* encpayload); - private: - const std::string& _internal_encpayload() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_encpayload(const std::string& value); - std::string* _internal_mutable_encpayload(); - public: - - // optional bytes encIv = 2; - bool has_enciv() const; - private: - bool _internal_has_enciv() const; - public: - void clear_enciv(); - const std::string& enciv() const; - template - void set_enciv(ArgT0&& arg0, ArgT... args); - std::string* mutable_enciv(); - PROTOBUF_NODISCARD std::string* release_enciv(); - void set_allocated_enciv(std::string* enciv); - private: - const std::string& _internal_enciv() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_enciv(const std::string& value); - std::string* _internal_mutable_enciv(); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.PollEncValue) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encpayload_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr enciv_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_PollUpdateMessageMetadata final : - public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:proto.Message.PollUpdateMessageMetadata) */ { - public: - inline Message_PollUpdateMessageMetadata() : Message_PollUpdateMessageMetadata(nullptr) {} - explicit PROTOBUF_CONSTEXPR Message_PollUpdateMessageMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_PollUpdateMessageMetadata(const Message_PollUpdateMessageMetadata& from); - Message_PollUpdateMessageMetadata(Message_PollUpdateMessageMetadata&& from) noexcept - : Message_PollUpdateMessageMetadata() { - *this = ::std::move(from); - } - - inline Message_PollUpdateMessageMetadata& operator=(const Message_PollUpdateMessageMetadata& from) { - CopyFrom(from); - return *this; - } - inline Message_PollUpdateMessageMetadata& operator=(Message_PollUpdateMessageMetadata&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_PollUpdateMessageMetadata& default_instance() { - return *internal_default_instance(); - } - static inline const Message_PollUpdateMessageMetadata* internal_default_instance() { - return reinterpret_cast( - &_Message_PollUpdateMessageMetadata_default_instance_); - } - static constexpr int kIndexInFileMessages = - 115; - - friend void swap(Message_PollUpdateMessageMetadata& a, Message_PollUpdateMessageMetadata& b) { - a.Swap(&b); - } - inline void Swap(Message_PollUpdateMessageMetadata* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_PollUpdateMessageMetadata* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_PollUpdateMessageMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom; - inline void CopyFrom(const Message_PollUpdateMessageMetadata& from) { - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from); - } - using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom; - void MergeFrom(const Message_PollUpdateMessageMetadata& from) { - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from); - } - public: - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.PollUpdateMessageMetadata"; - } - protected: - explicit Message_PollUpdateMessageMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - // @@protoc_insertion_point(class_scope:proto.Message.PollUpdateMessageMetadata) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_PollUpdateMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.PollUpdateMessage) */ { - public: - inline Message_PollUpdateMessage() : Message_PollUpdateMessage(nullptr) {} - ~Message_PollUpdateMessage() override; - explicit PROTOBUF_CONSTEXPR Message_PollUpdateMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_PollUpdateMessage(const Message_PollUpdateMessage& from); - Message_PollUpdateMessage(Message_PollUpdateMessage&& from) noexcept - : Message_PollUpdateMessage() { - *this = ::std::move(from); - } - - inline Message_PollUpdateMessage& operator=(const Message_PollUpdateMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_PollUpdateMessage& operator=(Message_PollUpdateMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_PollUpdateMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_PollUpdateMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_PollUpdateMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 116; - - friend void swap(Message_PollUpdateMessage& a, Message_PollUpdateMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_PollUpdateMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_PollUpdateMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_PollUpdateMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_PollUpdateMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_PollUpdateMessage& from) { - Message_PollUpdateMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_PollUpdateMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.PollUpdateMessage"; - } - protected: - explicit Message_PollUpdateMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kPollCreationMessageKeyFieldNumber = 1, - kVoteFieldNumber = 2, - kMetadataFieldNumber = 3, - kSenderTimestampMsFieldNumber = 4, - }; - // optional .proto.MessageKey pollCreationMessageKey = 1; - bool has_pollcreationmessagekey() const; - private: - bool _internal_has_pollcreationmessagekey() const; - public: - void clear_pollcreationmessagekey(); - const ::proto::MessageKey& pollcreationmessagekey() const; - PROTOBUF_NODISCARD ::proto::MessageKey* release_pollcreationmessagekey(); - ::proto::MessageKey* mutable_pollcreationmessagekey(); - void set_allocated_pollcreationmessagekey(::proto::MessageKey* pollcreationmessagekey); - private: - const ::proto::MessageKey& _internal_pollcreationmessagekey() const; - ::proto::MessageKey* _internal_mutable_pollcreationmessagekey(); - public: - void unsafe_arena_set_allocated_pollcreationmessagekey( - ::proto::MessageKey* pollcreationmessagekey); - ::proto::MessageKey* unsafe_arena_release_pollcreationmessagekey(); - - // optional .proto.Message.PollEncValue vote = 2; - bool has_vote() const; - private: - bool _internal_has_vote() const; - public: - void clear_vote(); - const ::proto::Message_PollEncValue& vote() const; - PROTOBUF_NODISCARD ::proto::Message_PollEncValue* release_vote(); - ::proto::Message_PollEncValue* mutable_vote(); - void set_allocated_vote(::proto::Message_PollEncValue* vote); - private: - const ::proto::Message_PollEncValue& _internal_vote() const; - ::proto::Message_PollEncValue* _internal_mutable_vote(); - public: - void unsafe_arena_set_allocated_vote( - ::proto::Message_PollEncValue* vote); - ::proto::Message_PollEncValue* unsafe_arena_release_vote(); - - // optional .proto.Message.PollUpdateMessageMetadata metadata = 3; - bool has_metadata() const; - private: - bool _internal_has_metadata() const; - public: - void clear_metadata(); - const ::proto::Message_PollUpdateMessageMetadata& metadata() const; - PROTOBUF_NODISCARD ::proto::Message_PollUpdateMessageMetadata* release_metadata(); - ::proto::Message_PollUpdateMessageMetadata* mutable_metadata(); - void set_allocated_metadata(::proto::Message_PollUpdateMessageMetadata* metadata); - private: - const ::proto::Message_PollUpdateMessageMetadata& _internal_metadata() const; - ::proto::Message_PollUpdateMessageMetadata* _internal_mutable_metadata(); - public: - void unsafe_arena_set_allocated_metadata( - ::proto::Message_PollUpdateMessageMetadata* metadata); - ::proto::Message_PollUpdateMessageMetadata* unsafe_arena_release_metadata(); - - // optional int64 senderTimestampMs = 4; - bool has_sendertimestampms() const; - private: - bool _internal_has_sendertimestampms() const; - public: - void clear_sendertimestampms(); - int64_t sendertimestampms() const; - void set_sendertimestampms(int64_t value); - private: - int64_t _internal_sendertimestampms() const; - void _internal_set_sendertimestampms(int64_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.PollUpdateMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::proto::MessageKey* pollcreationmessagekey_; - ::proto::Message_PollEncValue* vote_; - ::proto::Message_PollUpdateMessageMetadata* metadata_; - int64_t sendertimestampms_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_PollVoteMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.PollVoteMessage) */ { - public: - inline Message_PollVoteMessage() : Message_PollVoteMessage(nullptr) {} - ~Message_PollVoteMessage() override; - explicit PROTOBUF_CONSTEXPR Message_PollVoteMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_PollVoteMessage(const Message_PollVoteMessage& from); - Message_PollVoteMessage(Message_PollVoteMessage&& from) noexcept - : Message_PollVoteMessage() { - *this = ::std::move(from); - } - - inline Message_PollVoteMessage& operator=(const Message_PollVoteMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_PollVoteMessage& operator=(Message_PollVoteMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_PollVoteMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_PollVoteMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_PollVoteMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 117; - - friend void swap(Message_PollVoteMessage& a, Message_PollVoteMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_PollVoteMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_PollVoteMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_PollVoteMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_PollVoteMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_PollVoteMessage& from) { - Message_PollVoteMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_PollVoteMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.PollVoteMessage"; - } - protected: - explicit Message_PollVoteMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kSelectedOptionsFieldNumber = 1, - }; - // repeated bytes selectedOptions = 1; - int selectedoptions_size() const; - private: - int _internal_selectedoptions_size() const; - public: - void clear_selectedoptions(); - const std::string& selectedoptions(int index) const; - std::string* mutable_selectedoptions(int index); - void set_selectedoptions(int index, const std::string& value); - void set_selectedoptions(int index, std::string&& value); - void set_selectedoptions(int index, const char* value); - void set_selectedoptions(int index, const void* value, size_t size); - std::string* add_selectedoptions(); - void add_selectedoptions(const std::string& value); - void add_selectedoptions(std::string&& value); - void add_selectedoptions(const char* value); - void add_selectedoptions(const void* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& selectedoptions() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_selectedoptions(); - private: - const std::string& _internal_selectedoptions(int index) const; - std::string* _internal_add_selectedoptions(); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.PollVoteMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField selectedoptions_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_ProductMessage_CatalogSnapshot final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ProductMessage.CatalogSnapshot) */ { - public: - inline Message_ProductMessage_CatalogSnapshot() : Message_ProductMessage_CatalogSnapshot(nullptr) {} - ~Message_ProductMessage_CatalogSnapshot() override; - explicit PROTOBUF_CONSTEXPR Message_ProductMessage_CatalogSnapshot(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_ProductMessage_CatalogSnapshot(const Message_ProductMessage_CatalogSnapshot& from); - Message_ProductMessage_CatalogSnapshot(Message_ProductMessage_CatalogSnapshot&& from) noexcept - : Message_ProductMessage_CatalogSnapshot() { - *this = ::std::move(from); - } - - inline Message_ProductMessage_CatalogSnapshot& operator=(const Message_ProductMessage_CatalogSnapshot& from) { - CopyFrom(from); - return *this; - } - inline Message_ProductMessage_CatalogSnapshot& operator=(Message_ProductMessage_CatalogSnapshot&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_ProductMessage_CatalogSnapshot& default_instance() { - return *internal_default_instance(); - } - static inline const Message_ProductMessage_CatalogSnapshot* internal_default_instance() { - return reinterpret_cast( - &_Message_ProductMessage_CatalogSnapshot_default_instance_); - } - static constexpr int kIndexInFileMessages = - 118; - - friend void swap(Message_ProductMessage_CatalogSnapshot& a, Message_ProductMessage_CatalogSnapshot& b) { - a.Swap(&b); - } - inline void Swap(Message_ProductMessage_CatalogSnapshot* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_ProductMessage_CatalogSnapshot* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_ProductMessage_CatalogSnapshot* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_ProductMessage_CatalogSnapshot& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_ProductMessage_CatalogSnapshot& from) { - Message_ProductMessage_CatalogSnapshot::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_ProductMessage_CatalogSnapshot* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.ProductMessage.CatalogSnapshot"; - } - protected: - explicit Message_ProductMessage_CatalogSnapshot(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kTitleFieldNumber = 2, - kDescriptionFieldNumber = 3, - kCatalogImageFieldNumber = 1, - }; - // optional string title = 2; - bool has_title() const; - private: - bool _internal_has_title() const; - public: - void clear_title(); - const std::string& title() const; - template - void set_title(ArgT0&& arg0, ArgT... args); - std::string* mutable_title(); - PROTOBUF_NODISCARD std::string* release_title(); - void set_allocated_title(std::string* title); - private: - const std::string& _internal_title() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value); - std::string* _internal_mutable_title(); - public: - - // optional string description = 3; - bool has_description() const; - private: - bool _internal_has_description() const; - public: - void clear_description(); - const std::string& description() const; - template - void set_description(ArgT0&& arg0, ArgT... args); - std::string* mutable_description(); - PROTOBUF_NODISCARD std::string* release_description(); - void set_allocated_description(std::string* description); - private: - const std::string& _internal_description() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value); - std::string* _internal_mutable_description(); - public: - - // optional .proto.Message.ImageMessage catalogImage = 1; - bool has_catalogimage() const; - private: - bool _internal_has_catalogimage() const; - public: - void clear_catalogimage(); - const ::proto::Message_ImageMessage& catalogimage() const; - PROTOBUF_NODISCARD ::proto::Message_ImageMessage* release_catalogimage(); - ::proto::Message_ImageMessage* mutable_catalogimage(); - void set_allocated_catalogimage(::proto::Message_ImageMessage* catalogimage); - private: - const ::proto::Message_ImageMessage& _internal_catalogimage() const; - ::proto::Message_ImageMessage* _internal_mutable_catalogimage(); - public: - void unsafe_arena_set_allocated_catalogimage( - ::proto::Message_ImageMessage* catalogimage); - ::proto::Message_ImageMessage* unsafe_arena_release_catalogimage(); - - // @@protoc_insertion_point(class_scope:proto.Message.ProductMessage.CatalogSnapshot) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_; - ::proto::Message_ImageMessage* catalogimage_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_ProductMessage_ProductSnapshot final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ProductMessage.ProductSnapshot) */ { - public: - inline Message_ProductMessage_ProductSnapshot() : Message_ProductMessage_ProductSnapshot(nullptr) {} - ~Message_ProductMessage_ProductSnapshot() override; - explicit PROTOBUF_CONSTEXPR Message_ProductMessage_ProductSnapshot(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_ProductMessage_ProductSnapshot(const Message_ProductMessage_ProductSnapshot& from); - Message_ProductMessage_ProductSnapshot(Message_ProductMessage_ProductSnapshot&& from) noexcept - : Message_ProductMessage_ProductSnapshot() { - *this = ::std::move(from); - } - - inline Message_ProductMessage_ProductSnapshot& operator=(const Message_ProductMessage_ProductSnapshot& from) { - CopyFrom(from); - return *this; - } - inline Message_ProductMessage_ProductSnapshot& operator=(Message_ProductMessage_ProductSnapshot&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_ProductMessage_ProductSnapshot& default_instance() { - return *internal_default_instance(); - } - static inline const Message_ProductMessage_ProductSnapshot* internal_default_instance() { - return reinterpret_cast( - &_Message_ProductMessage_ProductSnapshot_default_instance_); - } - static constexpr int kIndexInFileMessages = - 119; - - friend void swap(Message_ProductMessage_ProductSnapshot& a, Message_ProductMessage_ProductSnapshot& b) { - a.Swap(&b); - } - inline void Swap(Message_ProductMessage_ProductSnapshot* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_ProductMessage_ProductSnapshot* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_ProductMessage_ProductSnapshot* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_ProductMessage_ProductSnapshot& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_ProductMessage_ProductSnapshot& from) { - Message_ProductMessage_ProductSnapshot::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_ProductMessage_ProductSnapshot* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.ProductMessage.ProductSnapshot"; - } - protected: - explicit Message_ProductMessage_ProductSnapshot(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kProductIdFieldNumber = 2, - kTitleFieldNumber = 3, - kDescriptionFieldNumber = 4, - kCurrencyCodeFieldNumber = 5, - kRetailerIdFieldNumber = 7, - kUrlFieldNumber = 8, - kFirstImageIdFieldNumber = 11, - kProductImageFieldNumber = 1, - kPriceAmount1000FieldNumber = 6, - kSalePriceAmount1000FieldNumber = 12, - kProductImageCountFieldNumber = 9, - }; - // optional string productId = 2; - bool has_productid() const; - private: - bool _internal_has_productid() const; - public: - void clear_productid(); - const std::string& productid() const; - template - void set_productid(ArgT0&& arg0, ArgT... args); - std::string* mutable_productid(); - PROTOBUF_NODISCARD std::string* release_productid(); - void set_allocated_productid(std::string* productid); - private: - const std::string& _internal_productid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_productid(const std::string& value); - std::string* _internal_mutable_productid(); - public: - - // optional string title = 3; - bool has_title() const; - private: - bool _internal_has_title() const; - public: - void clear_title(); - const std::string& title() const; - template - void set_title(ArgT0&& arg0, ArgT... args); - std::string* mutable_title(); - PROTOBUF_NODISCARD std::string* release_title(); - void set_allocated_title(std::string* title); - private: - const std::string& _internal_title() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value); - std::string* _internal_mutable_title(); - public: - - // optional string description = 4; - bool has_description() const; - private: - bool _internal_has_description() const; - public: - void clear_description(); - const std::string& description() const; - template - void set_description(ArgT0&& arg0, ArgT... args); - std::string* mutable_description(); - PROTOBUF_NODISCARD std::string* release_description(); - void set_allocated_description(std::string* description); - private: - const std::string& _internal_description() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value); - std::string* _internal_mutable_description(); - public: - - // optional string currencyCode = 5; - bool has_currencycode() const; - private: - bool _internal_has_currencycode() const; - public: - void clear_currencycode(); - const std::string& currencycode() const; - template - void set_currencycode(ArgT0&& arg0, ArgT... args); - std::string* mutable_currencycode(); - PROTOBUF_NODISCARD std::string* release_currencycode(); - void set_allocated_currencycode(std::string* currencycode); - private: - const std::string& _internal_currencycode() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_currencycode(const std::string& value); - std::string* _internal_mutable_currencycode(); - public: - - // optional string retailerId = 7; - bool has_retailerid() const; - private: - bool _internal_has_retailerid() const; - public: - void clear_retailerid(); - const std::string& retailerid() const; - template - void set_retailerid(ArgT0&& arg0, ArgT... args); - std::string* mutable_retailerid(); - PROTOBUF_NODISCARD std::string* release_retailerid(); - void set_allocated_retailerid(std::string* retailerid); - private: - const std::string& _internal_retailerid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_retailerid(const std::string& value); - std::string* _internal_mutable_retailerid(); - public: - - // optional string url = 8; - bool has_url() const; - private: - bool _internal_has_url() const; - public: - void clear_url(); - const std::string& url() const; - template - void set_url(ArgT0&& arg0, ArgT... args); - std::string* mutable_url(); - PROTOBUF_NODISCARD std::string* release_url(); - void set_allocated_url(std::string* url); - private: - const std::string& _internal_url() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value); - std::string* _internal_mutable_url(); - public: - - // optional string firstImageId = 11; - bool has_firstimageid() const; - private: - bool _internal_has_firstimageid() const; - public: - void clear_firstimageid(); - const std::string& firstimageid() const; - template - void set_firstimageid(ArgT0&& arg0, ArgT... args); - std::string* mutable_firstimageid(); - PROTOBUF_NODISCARD std::string* release_firstimageid(); - void set_allocated_firstimageid(std::string* firstimageid); - private: - const std::string& _internal_firstimageid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_firstimageid(const std::string& value); - std::string* _internal_mutable_firstimageid(); - public: - - // optional .proto.Message.ImageMessage productImage = 1; - bool has_productimage() const; - private: - bool _internal_has_productimage() const; - public: - void clear_productimage(); - const ::proto::Message_ImageMessage& productimage() const; - PROTOBUF_NODISCARD ::proto::Message_ImageMessage* release_productimage(); - ::proto::Message_ImageMessage* mutable_productimage(); - void set_allocated_productimage(::proto::Message_ImageMessage* productimage); - private: - const ::proto::Message_ImageMessage& _internal_productimage() const; - ::proto::Message_ImageMessage* _internal_mutable_productimage(); - public: - void unsafe_arena_set_allocated_productimage( - ::proto::Message_ImageMessage* productimage); - ::proto::Message_ImageMessage* unsafe_arena_release_productimage(); - - // optional int64 priceAmount1000 = 6; - bool has_priceamount1000() const; - private: - bool _internal_has_priceamount1000() const; - public: - void clear_priceamount1000(); - int64_t priceamount1000() const; - void set_priceamount1000(int64_t value); - private: - int64_t _internal_priceamount1000() const; - void _internal_set_priceamount1000(int64_t value); - public: - - // optional int64 salePriceAmount1000 = 12; - bool has_salepriceamount1000() const; - private: - bool _internal_has_salepriceamount1000() const; - public: - void clear_salepriceamount1000(); - int64_t salepriceamount1000() const; - void set_salepriceamount1000(int64_t value); - private: - int64_t _internal_salepriceamount1000() const; - void _internal_set_salepriceamount1000(int64_t value); - public: - - // optional uint32 productImageCount = 9; - bool has_productimagecount() const; - private: - bool _internal_has_productimagecount() const; - public: - void clear_productimagecount(); - uint32_t productimagecount() const; - void set_productimagecount(uint32_t value); - private: - uint32_t _internal_productimagecount() const; - void _internal_set_productimagecount(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.ProductMessage.ProductSnapshot) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr productid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr currencycode_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr retailerid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr firstimageid_; - ::proto::Message_ImageMessage* productimage_; - int64_t priceamount1000_; - int64_t salepriceamount1000_; - uint32_t productimagecount_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_ProductMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ProductMessage) */ { - public: - inline Message_ProductMessage() : Message_ProductMessage(nullptr) {} - ~Message_ProductMessage() override; - explicit PROTOBUF_CONSTEXPR Message_ProductMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_ProductMessage(const Message_ProductMessage& from); - Message_ProductMessage(Message_ProductMessage&& from) noexcept - : Message_ProductMessage() { - *this = ::std::move(from); - } - - inline Message_ProductMessage& operator=(const Message_ProductMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_ProductMessage& operator=(Message_ProductMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_ProductMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_ProductMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_ProductMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 120; - - friend void swap(Message_ProductMessage& a, Message_ProductMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_ProductMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_ProductMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_ProductMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_ProductMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_ProductMessage& from) { - Message_ProductMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_ProductMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.ProductMessage"; - } - protected: - explicit Message_ProductMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Message_ProductMessage_CatalogSnapshot CatalogSnapshot; - typedef Message_ProductMessage_ProductSnapshot ProductSnapshot; - - // accessors ------------------------------------------------------- - - enum : int { - kBusinessOwnerJidFieldNumber = 2, - kBodyFieldNumber = 5, - kFooterFieldNumber = 6, - kProductFieldNumber = 1, - kCatalogFieldNumber = 4, - kContextInfoFieldNumber = 17, - }; - // optional string businessOwnerJid = 2; - bool has_businessownerjid() const; - private: - bool _internal_has_businessownerjid() const; - public: - void clear_businessownerjid(); - const std::string& businessownerjid() const; - template - void set_businessownerjid(ArgT0&& arg0, ArgT... args); - std::string* mutable_businessownerjid(); - PROTOBUF_NODISCARD std::string* release_businessownerjid(); - void set_allocated_businessownerjid(std::string* businessownerjid); - private: - const std::string& _internal_businessownerjid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_businessownerjid(const std::string& value); - std::string* _internal_mutable_businessownerjid(); - public: - - // optional string body = 5; - bool has_body() const; - private: - bool _internal_has_body() const; - public: - void clear_body(); - const std::string& body() const; - template - void set_body(ArgT0&& arg0, ArgT... args); - std::string* mutable_body(); - PROTOBUF_NODISCARD std::string* release_body(); - void set_allocated_body(std::string* body); - private: - const std::string& _internal_body() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_body(const std::string& value); - std::string* _internal_mutable_body(); - public: - - // optional string footer = 6; - bool has_footer() const; - private: - bool _internal_has_footer() const; - public: - void clear_footer(); - const std::string& footer() const; - template - void set_footer(ArgT0&& arg0, ArgT... args); - std::string* mutable_footer(); - PROTOBUF_NODISCARD std::string* release_footer(); - void set_allocated_footer(std::string* footer); - private: - const std::string& _internal_footer() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_footer(const std::string& value); - std::string* _internal_mutable_footer(); - public: - - // optional .proto.Message.ProductMessage.ProductSnapshot product = 1; - bool has_product() const; - private: - bool _internal_has_product() const; - public: - void clear_product(); - const ::proto::Message_ProductMessage_ProductSnapshot& product() const; - PROTOBUF_NODISCARD ::proto::Message_ProductMessage_ProductSnapshot* release_product(); - ::proto::Message_ProductMessage_ProductSnapshot* mutable_product(); - void set_allocated_product(::proto::Message_ProductMessage_ProductSnapshot* product); - private: - const ::proto::Message_ProductMessage_ProductSnapshot& _internal_product() const; - ::proto::Message_ProductMessage_ProductSnapshot* _internal_mutable_product(); - public: - void unsafe_arena_set_allocated_product( - ::proto::Message_ProductMessage_ProductSnapshot* product); - ::proto::Message_ProductMessage_ProductSnapshot* unsafe_arena_release_product(); - - // optional .proto.Message.ProductMessage.CatalogSnapshot catalog = 4; - bool has_catalog() const; - private: - bool _internal_has_catalog() const; - public: - void clear_catalog(); - const ::proto::Message_ProductMessage_CatalogSnapshot& catalog() const; - PROTOBUF_NODISCARD ::proto::Message_ProductMessage_CatalogSnapshot* release_catalog(); - ::proto::Message_ProductMessage_CatalogSnapshot* mutable_catalog(); - void set_allocated_catalog(::proto::Message_ProductMessage_CatalogSnapshot* catalog); - private: - const ::proto::Message_ProductMessage_CatalogSnapshot& _internal_catalog() const; - ::proto::Message_ProductMessage_CatalogSnapshot* _internal_mutable_catalog(); - public: - void unsafe_arena_set_allocated_catalog( - ::proto::Message_ProductMessage_CatalogSnapshot* catalog); - ::proto::Message_ProductMessage_CatalogSnapshot* unsafe_arena_release_catalog(); - - // optional .proto.ContextInfo contextInfo = 17; - bool has_contextinfo() const; - private: - bool _internal_has_contextinfo() const; - public: - void clear_contextinfo(); - const ::proto::ContextInfo& contextinfo() const; - PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); - ::proto::ContextInfo* mutable_contextinfo(); - void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); - private: - const ::proto::ContextInfo& _internal_contextinfo() const; - ::proto::ContextInfo* _internal_mutable_contextinfo(); - public: - void unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo); - ::proto::ContextInfo* unsafe_arena_release_contextinfo(); - - // @@protoc_insertion_point(class_scope:proto.Message.ProductMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr businessownerjid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr body_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr footer_; - ::proto::Message_ProductMessage_ProductSnapshot* product_; - ::proto::Message_ProductMessage_CatalogSnapshot* catalog_; - ::proto::ContextInfo* contextinfo_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_ProtocolMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ProtocolMessage) */ { - public: - inline Message_ProtocolMessage() : Message_ProtocolMessage(nullptr) {} - ~Message_ProtocolMessage() override; - explicit PROTOBUF_CONSTEXPR Message_ProtocolMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_ProtocolMessage(const Message_ProtocolMessage& from); - Message_ProtocolMessage(Message_ProtocolMessage&& from) noexcept - : Message_ProtocolMessage() { - *this = ::std::move(from); - } - - inline Message_ProtocolMessage& operator=(const Message_ProtocolMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_ProtocolMessage& operator=(Message_ProtocolMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_ProtocolMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_ProtocolMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_ProtocolMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 121; - - friend void swap(Message_ProtocolMessage& a, Message_ProtocolMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_ProtocolMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_ProtocolMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_ProtocolMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_ProtocolMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_ProtocolMessage& from) { - Message_ProtocolMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_ProtocolMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.ProtocolMessage"; - } - protected: - explicit Message_ProtocolMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Message_ProtocolMessage_Type Type; - static constexpr Type REVOKE = - Message_ProtocolMessage_Type_REVOKE; - static constexpr Type EPHEMERAL_SETTING = - Message_ProtocolMessage_Type_EPHEMERAL_SETTING; - static constexpr Type EPHEMERAL_SYNC_RESPONSE = - Message_ProtocolMessage_Type_EPHEMERAL_SYNC_RESPONSE; - static constexpr Type HISTORY_SYNC_NOTIFICATION = - Message_ProtocolMessage_Type_HISTORY_SYNC_NOTIFICATION; - static constexpr Type APP_STATE_SYNC_KEY_SHARE = - Message_ProtocolMessage_Type_APP_STATE_SYNC_KEY_SHARE; - static constexpr Type APP_STATE_SYNC_KEY_REQUEST = - Message_ProtocolMessage_Type_APP_STATE_SYNC_KEY_REQUEST; - static constexpr Type MSG_FANOUT_BACKFILL_REQUEST = - Message_ProtocolMessage_Type_MSG_FANOUT_BACKFILL_REQUEST; - static constexpr Type INITIAL_SECURITY_NOTIFICATION_SETTING_SYNC = - Message_ProtocolMessage_Type_INITIAL_SECURITY_NOTIFICATION_SETTING_SYNC; - static constexpr Type APP_STATE_FATAL_EXCEPTION_NOTIFICATION = - Message_ProtocolMessage_Type_APP_STATE_FATAL_EXCEPTION_NOTIFICATION; - static constexpr Type SHARE_PHONE_NUMBER = - Message_ProtocolMessage_Type_SHARE_PHONE_NUMBER; - static constexpr Type REQUEST_MEDIA_UPLOAD_MESSAGE = - Message_ProtocolMessage_Type_REQUEST_MEDIA_UPLOAD_MESSAGE; - static constexpr Type REQUEST_MEDIA_UPLOAD_RESPONSE_MESSAGE = - Message_ProtocolMessage_Type_REQUEST_MEDIA_UPLOAD_RESPONSE_MESSAGE; - static inline bool Type_IsValid(int value) { - return Message_ProtocolMessage_Type_IsValid(value); - } - static constexpr Type Type_MIN = - Message_ProtocolMessage_Type_Type_MIN; - static constexpr Type Type_MAX = - Message_ProtocolMessage_Type_Type_MAX; - static constexpr int Type_ARRAYSIZE = - Message_ProtocolMessage_Type_Type_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - Type_descriptor() { - return Message_ProtocolMessage_Type_descriptor(); - } - template - static inline const std::string& Type_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Type_Name."); - return Message_ProtocolMessage_Type_Name(enum_t_value); - } - static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - Type* value) { - return Message_ProtocolMessage_Type_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kKeyFieldNumber = 1, - kHistorySyncNotificationFieldNumber = 6, - kAppStateSyncKeyShareFieldNumber = 7, - kAppStateSyncKeyRequestFieldNumber = 8, - kInitialSecurityNotificationSettingSyncFieldNumber = 9, - kAppStateFatalExceptionNotificationFieldNumber = 10, - kDisappearingModeFieldNumber = 11, - kRequestMediaUploadMessageFieldNumber = 12, - kRequestMediaUploadResponseMessageFieldNumber = 13, - kTypeFieldNumber = 2, - kEphemeralExpirationFieldNumber = 4, - kEphemeralSettingTimestampFieldNumber = 5, - }; - // optional .proto.MessageKey key = 1; - bool has_key() const; - private: - bool _internal_has_key() const; - public: - void clear_key(); - const ::proto::MessageKey& key() const; - PROTOBUF_NODISCARD ::proto::MessageKey* release_key(); - ::proto::MessageKey* mutable_key(); - void set_allocated_key(::proto::MessageKey* key); - private: - const ::proto::MessageKey& _internal_key() const; - ::proto::MessageKey* _internal_mutable_key(); - public: - void unsafe_arena_set_allocated_key( - ::proto::MessageKey* key); - ::proto::MessageKey* unsafe_arena_release_key(); - - // optional .proto.Message.HistorySyncNotification historySyncNotification = 6; - bool has_historysyncnotification() const; - private: - bool _internal_has_historysyncnotification() const; - public: - void clear_historysyncnotification(); - const ::proto::Message_HistorySyncNotification& historysyncnotification() const; - PROTOBUF_NODISCARD ::proto::Message_HistorySyncNotification* release_historysyncnotification(); - ::proto::Message_HistorySyncNotification* mutable_historysyncnotification(); - void set_allocated_historysyncnotification(::proto::Message_HistorySyncNotification* historysyncnotification); - private: - const ::proto::Message_HistorySyncNotification& _internal_historysyncnotification() const; - ::proto::Message_HistorySyncNotification* _internal_mutable_historysyncnotification(); - public: - void unsafe_arena_set_allocated_historysyncnotification( - ::proto::Message_HistorySyncNotification* historysyncnotification); - ::proto::Message_HistorySyncNotification* unsafe_arena_release_historysyncnotification(); - - // optional .proto.Message.AppStateSyncKeyShare appStateSyncKeyShare = 7; - bool has_appstatesynckeyshare() const; - private: - bool _internal_has_appstatesynckeyshare() const; - public: - void clear_appstatesynckeyshare(); - const ::proto::Message_AppStateSyncKeyShare& appstatesynckeyshare() const; - PROTOBUF_NODISCARD ::proto::Message_AppStateSyncKeyShare* release_appstatesynckeyshare(); - ::proto::Message_AppStateSyncKeyShare* mutable_appstatesynckeyshare(); - void set_allocated_appstatesynckeyshare(::proto::Message_AppStateSyncKeyShare* appstatesynckeyshare); - private: - const ::proto::Message_AppStateSyncKeyShare& _internal_appstatesynckeyshare() const; - ::proto::Message_AppStateSyncKeyShare* _internal_mutable_appstatesynckeyshare(); - public: - void unsafe_arena_set_allocated_appstatesynckeyshare( - ::proto::Message_AppStateSyncKeyShare* appstatesynckeyshare); - ::proto::Message_AppStateSyncKeyShare* unsafe_arena_release_appstatesynckeyshare(); - - // optional .proto.Message.AppStateSyncKeyRequest appStateSyncKeyRequest = 8; - bool has_appstatesynckeyrequest() const; - private: - bool _internal_has_appstatesynckeyrequest() const; - public: - void clear_appstatesynckeyrequest(); - const ::proto::Message_AppStateSyncKeyRequest& appstatesynckeyrequest() const; - PROTOBUF_NODISCARD ::proto::Message_AppStateSyncKeyRequest* release_appstatesynckeyrequest(); - ::proto::Message_AppStateSyncKeyRequest* mutable_appstatesynckeyrequest(); - void set_allocated_appstatesynckeyrequest(::proto::Message_AppStateSyncKeyRequest* appstatesynckeyrequest); - private: - const ::proto::Message_AppStateSyncKeyRequest& _internal_appstatesynckeyrequest() const; - ::proto::Message_AppStateSyncKeyRequest* _internal_mutable_appstatesynckeyrequest(); - public: - void unsafe_arena_set_allocated_appstatesynckeyrequest( - ::proto::Message_AppStateSyncKeyRequest* appstatesynckeyrequest); - ::proto::Message_AppStateSyncKeyRequest* unsafe_arena_release_appstatesynckeyrequest(); - - // optional .proto.Message.InitialSecurityNotificationSettingSync initialSecurityNotificationSettingSync = 9; - bool has_initialsecuritynotificationsettingsync() const; - private: - bool _internal_has_initialsecuritynotificationsettingsync() const; - public: - void clear_initialsecuritynotificationsettingsync(); - const ::proto::Message_InitialSecurityNotificationSettingSync& initialsecuritynotificationsettingsync() const; - PROTOBUF_NODISCARD ::proto::Message_InitialSecurityNotificationSettingSync* release_initialsecuritynotificationsettingsync(); - ::proto::Message_InitialSecurityNotificationSettingSync* mutable_initialsecuritynotificationsettingsync(); - void set_allocated_initialsecuritynotificationsettingsync(::proto::Message_InitialSecurityNotificationSettingSync* initialsecuritynotificationsettingsync); - private: - const ::proto::Message_InitialSecurityNotificationSettingSync& _internal_initialsecuritynotificationsettingsync() const; - ::proto::Message_InitialSecurityNotificationSettingSync* _internal_mutable_initialsecuritynotificationsettingsync(); - public: - void unsafe_arena_set_allocated_initialsecuritynotificationsettingsync( - ::proto::Message_InitialSecurityNotificationSettingSync* initialsecuritynotificationsettingsync); - ::proto::Message_InitialSecurityNotificationSettingSync* unsafe_arena_release_initialsecuritynotificationsettingsync(); - - // optional .proto.Message.AppStateFatalExceptionNotification appStateFatalExceptionNotification = 10; - bool has_appstatefatalexceptionnotification() const; - private: - bool _internal_has_appstatefatalexceptionnotification() const; - public: - void clear_appstatefatalexceptionnotification(); - const ::proto::Message_AppStateFatalExceptionNotification& appstatefatalexceptionnotification() const; - PROTOBUF_NODISCARD ::proto::Message_AppStateFatalExceptionNotification* release_appstatefatalexceptionnotification(); - ::proto::Message_AppStateFatalExceptionNotification* mutable_appstatefatalexceptionnotification(); - void set_allocated_appstatefatalexceptionnotification(::proto::Message_AppStateFatalExceptionNotification* appstatefatalexceptionnotification); - private: - const ::proto::Message_AppStateFatalExceptionNotification& _internal_appstatefatalexceptionnotification() const; - ::proto::Message_AppStateFatalExceptionNotification* _internal_mutable_appstatefatalexceptionnotification(); - public: - void unsafe_arena_set_allocated_appstatefatalexceptionnotification( - ::proto::Message_AppStateFatalExceptionNotification* appstatefatalexceptionnotification); - ::proto::Message_AppStateFatalExceptionNotification* unsafe_arena_release_appstatefatalexceptionnotification(); - - // optional .proto.DisappearingMode disappearingMode = 11; - bool has_disappearingmode() const; - private: - bool _internal_has_disappearingmode() const; - public: - void clear_disappearingmode(); - const ::proto::DisappearingMode& disappearingmode() const; - PROTOBUF_NODISCARD ::proto::DisappearingMode* release_disappearingmode(); - ::proto::DisappearingMode* mutable_disappearingmode(); - void set_allocated_disappearingmode(::proto::DisappearingMode* disappearingmode); - private: - const ::proto::DisappearingMode& _internal_disappearingmode() const; - ::proto::DisappearingMode* _internal_mutable_disappearingmode(); - public: - void unsafe_arena_set_allocated_disappearingmode( - ::proto::DisappearingMode* disappearingmode); - ::proto::DisappearingMode* unsafe_arena_release_disappearingmode(); - - // optional .proto.Message.RequestMediaUploadMessage requestMediaUploadMessage = 12; - bool has_requestmediauploadmessage() const; - private: - bool _internal_has_requestmediauploadmessage() const; - public: - void clear_requestmediauploadmessage(); - const ::proto::Message_RequestMediaUploadMessage& requestmediauploadmessage() const; - PROTOBUF_NODISCARD ::proto::Message_RequestMediaUploadMessage* release_requestmediauploadmessage(); - ::proto::Message_RequestMediaUploadMessage* mutable_requestmediauploadmessage(); - void set_allocated_requestmediauploadmessage(::proto::Message_RequestMediaUploadMessage* requestmediauploadmessage); - private: - const ::proto::Message_RequestMediaUploadMessage& _internal_requestmediauploadmessage() const; - ::proto::Message_RequestMediaUploadMessage* _internal_mutable_requestmediauploadmessage(); - public: - void unsafe_arena_set_allocated_requestmediauploadmessage( - ::proto::Message_RequestMediaUploadMessage* requestmediauploadmessage); - ::proto::Message_RequestMediaUploadMessage* unsafe_arena_release_requestmediauploadmessage(); - - // optional .proto.Message.RequestMediaUploadResponseMessage requestMediaUploadResponseMessage = 13; - bool has_requestmediauploadresponsemessage() const; - private: - bool _internal_has_requestmediauploadresponsemessage() const; - public: - void clear_requestmediauploadresponsemessage(); - const ::proto::Message_RequestMediaUploadResponseMessage& requestmediauploadresponsemessage() const; - PROTOBUF_NODISCARD ::proto::Message_RequestMediaUploadResponseMessage* release_requestmediauploadresponsemessage(); - ::proto::Message_RequestMediaUploadResponseMessage* mutable_requestmediauploadresponsemessage(); - void set_allocated_requestmediauploadresponsemessage(::proto::Message_RequestMediaUploadResponseMessage* requestmediauploadresponsemessage); - private: - const ::proto::Message_RequestMediaUploadResponseMessage& _internal_requestmediauploadresponsemessage() const; - ::proto::Message_RequestMediaUploadResponseMessage* _internal_mutable_requestmediauploadresponsemessage(); - public: - void unsafe_arena_set_allocated_requestmediauploadresponsemessage( - ::proto::Message_RequestMediaUploadResponseMessage* requestmediauploadresponsemessage); - ::proto::Message_RequestMediaUploadResponseMessage* unsafe_arena_release_requestmediauploadresponsemessage(); - - // optional .proto.Message.ProtocolMessage.Type type = 2; - bool has_type() const; - private: - bool _internal_has_type() const; - public: - void clear_type(); - ::proto::Message_ProtocolMessage_Type type() const; - void set_type(::proto::Message_ProtocolMessage_Type value); - private: - ::proto::Message_ProtocolMessage_Type _internal_type() const; - void _internal_set_type(::proto::Message_ProtocolMessage_Type value); - public: - - // optional uint32 ephemeralExpiration = 4; - bool has_ephemeralexpiration() const; - private: - bool _internal_has_ephemeralexpiration() const; - public: - void clear_ephemeralexpiration(); - uint32_t ephemeralexpiration() const; - void set_ephemeralexpiration(uint32_t value); - private: - uint32_t _internal_ephemeralexpiration() const; - void _internal_set_ephemeralexpiration(uint32_t value); - public: - - // optional int64 ephemeralSettingTimestamp = 5; - bool has_ephemeralsettingtimestamp() const; - private: - bool _internal_has_ephemeralsettingtimestamp() const; - public: - void clear_ephemeralsettingtimestamp(); - int64_t ephemeralsettingtimestamp() const; - void set_ephemeralsettingtimestamp(int64_t value); - private: - int64_t _internal_ephemeralsettingtimestamp() const; - void _internal_set_ephemeralsettingtimestamp(int64_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.ProtocolMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::proto::MessageKey* key_; - ::proto::Message_HistorySyncNotification* historysyncnotification_; - ::proto::Message_AppStateSyncKeyShare* appstatesynckeyshare_; - ::proto::Message_AppStateSyncKeyRequest* appstatesynckeyrequest_; - ::proto::Message_InitialSecurityNotificationSettingSync* initialsecuritynotificationsettingsync_; - ::proto::Message_AppStateFatalExceptionNotification* appstatefatalexceptionnotification_; - ::proto::DisappearingMode* disappearingmode_; - ::proto::Message_RequestMediaUploadMessage* requestmediauploadmessage_; - ::proto::Message_RequestMediaUploadResponseMessage* requestmediauploadresponsemessage_; - int type_; - uint32_t ephemeralexpiration_; - int64_t ephemeralsettingtimestamp_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_ReactionMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ReactionMessage) */ { - public: - inline Message_ReactionMessage() : Message_ReactionMessage(nullptr) {} - ~Message_ReactionMessage() override; - explicit PROTOBUF_CONSTEXPR Message_ReactionMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_ReactionMessage(const Message_ReactionMessage& from); - Message_ReactionMessage(Message_ReactionMessage&& from) noexcept - : Message_ReactionMessage() { - *this = ::std::move(from); - } - - inline Message_ReactionMessage& operator=(const Message_ReactionMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_ReactionMessage& operator=(Message_ReactionMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_ReactionMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_ReactionMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_ReactionMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 122; - - friend void swap(Message_ReactionMessage& a, Message_ReactionMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_ReactionMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_ReactionMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_ReactionMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_ReactionMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_ReactionMessage& from) { - Message_ReactionMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_ReactionMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.ReactionMessage"; - } - protected: - explicit Message_ReactionMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kTextFieldNumber = 2, - kGroupingKeyFieldNumber = 3, - kKeyFieldNumber = 1, - kSenderTimestampMsFieldNumber = 4, - }; - // optional string text = 2; - bool has_text() const; - private: - bool _internal_has_text() const; - public: - void clear_text(); - const std::string& text() const; - template - void set_text(ArgT0&& arg0, ArgT... args); - std::string* mutable_text(); - PROTOBUF_NODISCARD std::string* release_text(); - void set_allocated_text(std::string* text); - private: - const std::string& _internal_text() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value); - std::string* _internal_mutable_text(); - public: - - // optional string groupingKey = 3; - bool has_groupingkey() const; - private: - bool _internal_has_groupingkey() const; - public: - void clear_groupingkey(); - const std::string& groupingkey() const; - template - void set_groupingkey(ArgT0&& arg0, ArgT... args); - std::string* mutable_groupingkey(); - PROTOBUF_NODISCARD std::string* release_groupingkey(); - void set_allocated_groupingkey(std::string* groupingkey); - private: - const std::string& _internal_groupingkey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_groupingkey(const std::string& value); - std::string* _internal_mutable_groupingkey(); - public: - - // optional .proto.MessageKey key = 1; - bool has_key() const; - private: - bool _internal_has_key() const; - public: - void clear_key(); - const ::proto::MessageKey& key() const; - PROTOBUF_NODISCARD ::proto::MessageKey* release_key(); - ::proto::MessageKey* mutable_key(); - void set_allocated_key(::proto::MessageKey* key); - private: - const ::proto::MessageKey& _internal_key() const; - ::proto::MessageKey* _internal_mutable_key(); - public: - void unsafe_arena_set_allocated_key( - ::proto::MessageKey* key); - ::proto::MessageKey* unsafe_arena_release_key(); - - // optional int64 senderTimestampMs = 4; - bool has_sendertimestampms() const; - private: - bool _internal_has_sendertimestampms() const; - public: - void clear_sendertimestampms(); - int64_t sendertimestampms() const; - void set_sendertimestampms(int64_t value); - private: - int64_t _internal_sendertimestampms() const; - void _internal_set_sendertimestampms(int64_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.ReactionMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr groupingkey_; - ::proto::MessageKey* key_; - int64_t sendertimestampms_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_RequestMediaUploadMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.RequestMediaUploadMessage) */ { - public: - inline Message_RequestMediaUploadMessage() : Message_RequestMediaUploadMessage(nullptr) {} - ~Message_RequestMediaUploadMessage() override; - explicit PROTOBUF_CONSTEXPR Message_RequestMediaUploadMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_RequestMediaUploadMessage(const Message_RequestMediaUploadMessage& from); - Message_RequestMediaUploadMessage(Message_RequestMediaUploadMessage&& from) noexcept - : Message_RequestMediaUploadMessage() { - *this = ::std::move(from); - } - - inline Message_RequestMediaUploadMessage& operator=(const Message_RequestMediaUploadMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_RequestMediaUploadMessage& operator=(Message_RequestMediaUploadMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_RequestMediaUploadMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_RequestMediaUploadMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_RequestMediaUploadMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 123; - - friend void swap(Message_RequestMediaUploadMessage& a, Message_RequestMediaUploadMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_RequestMediaUploadMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_RequestMediaUploadMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_RequestMediaUploadMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_RequestMediaUploadMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_RequestMediaUploadMessage& from) { - Message_RequestMediaUploadMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_RequestMediaUploadMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.RequestMediaUploadMessage"; - } - protected: - explicit Message_RequestMediaUploadMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kFileSha256FieldNumber = 1, - kRmrSourceFieldNumber = 2, - }; - // repeated string fileSha256 = 1; - int filesha256_size() const; - private: - int _internal_filesha256_size() const; - public: - void clear_filesha256(); - const std::string& filesha256(int index) const; - std::string* mutable_filesha256(int index); - void set_filesha256(int index, const std::string& value); - void set_filesha256(int index, std::string&& value); - void set_filesha256(int index, const char* value); - void set_filesha256(int index, const char* value, size_t size); - std::string* add_filesha256(); - void add_filesha256(const std::string& value); - void add_filesha256(std::string&& value); - void add_filesha256(const char* value); - void add_filesha256(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& filesha256() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_filesha256(); - private: - const std::string& _internal_filesha256(int index) const; - std::string* _internal_add_filesha256(); - public: - - // optional .proto.Message.RmrSource rmrSource = 2; - bool has_rmrsource() const; - private: - bool _internal_has_rmrsource() const; - public: - void clear_rmrsource(); - ::proto::Message_RmrSource rmrsource() const; - void set_rmrsource(::proto::Message_RmrSource value); - private: - ::proto::Message_RmrSource _internal_rmrsource() const; - void _internal_set_rmrsource(::proto::Message_RmrSource value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.RequestMediaUploadMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField filesha256_; - int rmrsource_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult) */ { - public: - inline Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult() : Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult(nullptr) {} - ~Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult() override; - explicit PROTOBUF_CONSTEXPR Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult(const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& from); - Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult&& from) noexcept - : Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult() { - *this = ::std::move(from); - } - - inline Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& operator=(const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& from) { - CopyFrom(from); - return *this; - } - inline Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& operator=(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& default_instance() { - return *internal_default_instance(); - } - static inline const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* internal_default_instance() { - return reinterpret_cast( - &_Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult_default_instance_); - } - static constexpr int kIndexInFileMessages = - 124; - - friend void swap(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& a, Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& b) { - a.Swap(&b); - } - inline void Swap(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& from) { - Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult"; - } - protected: - explicit Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kFileSha256FieldNumber = 1, - kStickerMessageFieldNumber = 3, - kMediaUploadResultFieldNumber = 2, - }; - // optional string fileSha256 = 1; - bool has_filesha256() const; - private: - bool _internal_has_filesha256() const; - public: - void clear_filesha256(); - const std::string& filesha256() const; - template - void set_filesha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_filesha256(); - PROTOBUF_NODISCARD std::string* release_filesha256(); - void set_allocated_filesha256(std::string* filesha256); - private: - const std::string& _internal_filesha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value); - std::string* _internal_mutable_filesha256(); - public: - - // optional .proto.Message.StickerMessage stickerMessage = 3; - bool has_stickermessage() const; - private: - bool _internal_has_stickermessage() const; - public: - void clear_stickermessage(); - const ::proto::Message_StickerMessage& stickermessage() const; - PROTOBUF_NODISCARD ::proto::Message_StickerMessage* release_stickermessage(); - ::proto::Message_StickerMessage* mutable_stickermessage(); - void set_allocated_stickermessage(::proto::Message_StickerMessage* stickermessage); - private: - const ::proto::Message_StickerMessage& _internal_stickermessage() const; - ::proto::Message_StickerMessage* _internal_mutable_stickermessage(); - public: - void unsafe_arena_set_allocated_stickermessage( - ::proto::Message_StickerMessage* stickermessage); - ::proto::Message_StickerMessage* unsafe_arena_release_stickermessage(); - - // optional .proto.MediaRetryNotification.ResultType mediaUploadResult = 2; - bool has_mediauploadresult() const; - private: - bool _internal_has_mediauploadresult() const; - public: - void clear_mediauploadresult(); - ::proto::MediaRetryNotification_ResultType mediauploadresult() const; - void set_mediauploadresult(::proto::MediaRetryNotification_ResultType value); - private: - ::proto::MediaRetryNotification_ResultType _internal_mediauploadresult() const; - void _internal_set_mediauploadresult(::proto::MediaRetryNotification_ResultType value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_; - ::proto::Message_StickerMessage* stickermessage_; - int mediauploadresult_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_RequestMediaUploadResponseMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.RequestMediaUploadResponseMessage) */ { - public: - inline Message_RequestMediaUploadResponseMessage() : Message_RequestMediaUploadResponseMessage(nullptr) {} - ~Message_RequestMediaUploadResponseMessage() override; - explicit PROTOBUF_CONSTEXPR Message_RequestMediaUploadResponseMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_RequestMediaUploadResponseMessage(const Message_RequestMediaUploadResponseMessage& from); - Message_RequestMediaUploadResponseMessage(Message_RequestMediaUploadResponseMessage&& from) noexcept - : Message_RequestMediaUploadResponseMessage() { - *this = ::std::move(from); - } - - inline Message_RequestMediaUploadResponseMessage& operator=(const Message_RequestMediaUploadResponseMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_RequestMediaUploadResponseMessage& operator=(Message_RequestMediaUploadResponseMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_RequestMediaUploadResponseMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_RequestMediaUploadResponseMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_RequestMediaUploadResponseMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 125; - - friend void swap(Message_RequestMediaUploadResponseMessage& a, Message_RequestMediaUploadResponseMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_RequestMediaUploadResponseMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_RequestMediaUploadResponseMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_RequestMediaUploadResponseMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_RequestMediaUploadResponseMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_RequestMediaUploadResponseMessage& from) { - Message_RequestMediaUploadResponseMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_RequestMediaUploadResponseMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.RequestMediaUploadResponseMessage"; - } - protected: - explicit Message_RequestMediaUploadResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult RequestMediaUploadResult; - - // accessors ------------------------------------------------------- - - enum : int { - kReuploadResultFieldNumber = 3, - kStanzaIdFieldNumber = 2, - kRmrSourceFieldNumber = 1, - }; - // repeated .proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult reuploadResult = 3; - int reuploadresult_size() const; - private: - int _internal_reuploadresult_size() const; - public: - void clear_reuploadresult(); - ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* mutable_reuploadresult(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult >* - mutable_reuploadresult(); - private: - const ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& _internal_reuploadresult(int index) const; - ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* _internal_add_reuploadresult(); - public: - const ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& reuploadresult(int index) const; - ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* add_reuploadresult(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult >& - reuploadresult() const; - - // optional string stanzaId = 2; - bool has_stanzaid() const; - private: - bool _internal_has_stanzaid() const; - public: - void clear_stanzaid(); - const std::string& stanzaid() const; - template - void set_stanzaid(ArgT0&& arg0, ArgT... args); - std::string* mutable_stanzaid(); - PROTOBUF_NODISCARD std::string* release_stanzaid(); - void set_allocated_stanzaid(std::string* stanzaid); - private: - const std::string& _internal_stanzaid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_stanzaid(const std::string& value); - std::string* _internal_mutable_stanzaid(); - public: - - // optional .proto.Message.RmrSource rmrSource = 1; - bool has_rmrsource() const; - private: - bool _internal_has_rmrsource() const; - public: - void clear_rmrsource(); - ::proto::Message_RmrSource rmrsource() const; - void set_rmrsource(::proto::Message_RmrSource value); - private: - ::proto::Message_RmrSource _internal_rmrsource() const; - void _internal_set_rmrsource(::proto::Message_RmrSource value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.RequestMediaUploadResponseMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult > reuploadresult_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr stanzaid_; - int rmrsource_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_RequestPaymentMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.RequestPaymentMessage) */ { - public: - inline Message_RequestPaymentMessage() : Message_RequestPaymentMessage(nullptr) {} - ~Message_RequestPaymentMessage() override; - explicit PROTOBUF_CONSTEXPR Message_RequestPaymentMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_RequestPaymentMessage(const Message_RequestPaymentMessage& from); - Message_RequestPaymentMessage(Message_RequestPaymentMessage&& from) noexcept - : Message_RequestPaymentMessage() { - *this = ::std::move(from); - } - - inline Message_RequestPaymentMessage& operator=(const Message_RequestPaymentMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_RequestPaymentMessage& operator=(Message_RequestPaymentMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_RequestPaymentMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_RequestPaymentMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_RequestPaymentMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 126; - - friend void swap(Message_RequestPaymentMessage& a, Message_RequestPaymentMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_RequestPaymentMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_RequestPaymentMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_RequestPaymentMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_RequestPaymentMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_RequestPaymentMessage& from) { - Message_RequestPaymentMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_RequestPaymentMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.RequestPaymentMessage"; - } - protected: - explicit Message_RequestPaymentMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kCurrencyCodeIso4217FieldNumber = 1, - kRequestFromFieldNumber = 3, - kNoteMessageFieldNumber = 4, - kAmountFieldNumber = 6, - kBackgroundFieldNumber = 7, - kAmount1000FieldNumber = 2, - kExpiryTimestampFieldNumber = 5, - }; - // optional string currencyCodeIso4217 = 1; - bool has_currencycodeiso4217() const; - private: - bool _internal_has_currencycodeiso4217() const; - public: - void clear_currencycodeiso4217(); - const std::string& currencycodeiso4217() const; - template - void set_currencycodeiso4217(ArgT0&& arg0, ArgT... args); - std::string* mutable_currencycodeiso4217(); - PROTOBUF_NODISCARD std::string* release_currencycodeiso4217(); - void set_allocated_currencycodeiso4217(std::string* currencycodeiso4217); - private: - const std::string& _internal_currencycodeiso4217() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_currencycodeiso4217(const std::string& value); - std::string* _internal_mutable_currencycodeiso4217(); - public: - - // optional string requestFrom = 3; - bool has_requestfrom() const; - private: - bool _internal_has_requestfrom() const; - public: - void clear_requestfrom(); - const std::string& requestfrom() const; - template - void set_requestfrom(ArgT0&& arg0, ArgT... args); - std::string* mutable_requestfrom(); - PROTOBUF_NODISCARD std::string* release_requestfrom(); - void set_allocated_requestfrom(std::string* requestfrom); - private: - const std::string& _internal_requestfrom() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestfrom(const std::string& value); - std::string* _internal_mutable_requestfrom(); - public: - - // optional .proto.Message noteMessage = 4; - bool has_notemessage() const; - private: - bool _internal_has_notemessage() const; - public: - void clear_notemessage(); - const ::proto::Message& notemessage() const; - PROTOBUF_NODISCARD ::proto::Message* release_notemessage(); - ::proto::Message* mutable_notemessage(); - void set_allocated_notemessage(::proto::Message* notemessage); - private: - const ::proto::Message& _internal_notemessage() const; - ::proto::Message* _internal_mutable_notemessage(); - public: - void unsafe_arena_set_allocated_notemessage( - ::proto::Message* notemessage); - ::proto::Message* unsafe_arena_release_notemessage(); - - // optional .proto.Money amount = 6; - bool has_amount() const; - private: - bool _internal_has_amount() const; - public: - void clear_amount(); - const ::proto::Money& amount() const; - PROTOBUF_NODISCARD ::proto::Money* release_amount(); - ::proto::Money* mutable_amount(); - void set_allocated_amount(::proto::Money* amount); - private: - const ::proto::Money& _internal_amount() const; - ::proto::Money* _internal_mutable_amount(); - public: - void unsafe_arena_set_allocated_amount( - ::proto::Money* amount); - ::proto::Money* unsafe_arena_release_amount(); - - // optional .proto.PaymentBackground background = 7; - bool has_background() const; - private: - bool _internal_has_background() const; - public: - void clear_background(); - const ::proto::PaymentBackground& background() const; - PROTOBUF_NODISCARD ::proto::PaymentBackground* release_background(); - ::proto::PaymentBackground* mutable_background(); - void set_allocated_background(::proto::PaymentBackground* background); - private: - const ::proto::PaymentBackground& _internal_background() const; - ::proto::PaymentBackground* _internal_mutable_background(); - public: - void unsafe_arena_set_allocated_background( - ::proto::PaymentBackground* background); - ::proto::PaymentBackground* unsafe_arena_release_background(); - - // optional uint64 amount1000 = 2; - bool has_amount1000() const; - private: - bool _internal_has_amount1000() const; - public: - void clear_amount1000(); - uint64_t amount1000() const; - void set_amount1000(uint64_t value); - private: - uint64_t _internal_amount1000() const; - void _internal_set_amount1000(uint64_t value); - public: - - // optional int64 expiryTimestamp = 5; - bool has_expirytimestamp() const; - private: - bool _internal_has_expirytimestamp() const; - public: - void clear_expirytimestamp(); - int64_t expirytimestamp() const; - void set_expirytimestamp(int64_t value); - private: - int64_t _internal_expirytimestamp() const; - void _internal_set_expirytimestamp(int64_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.RequestPaymentMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr currencycodeiso4217_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr requestfrom_; - ::proto::Message* notemessage_; - ::proto::Money* amount_; - ::proto::PaymentBackground* background_; - uint64_t amount1000_; - int64_t expirytimestamp_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_RequestPhoneNumberMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.RequestPhoneNumberMessage) */ { - public: - inline Message_RequestPhoneNumberMessage() : Message_RequestPhoneNumberMessage(nullptr) {} - ~Message_RequestPhoneNumberMessage() override; - explicit PROTOBUF_CONSTEXPR Message_RequestPhoneNumberMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_RequestPhoneNumberMessage(const Message_RequestPhoneNumberMessage& from); - Message_RequestPhoneNumberMessage(Message_RequestPhoneNumberMessage&& from) noexcept - : Message_RequestPhoneNumberMessage() { - *this = ::std::move(from); - } - - inline Message_RequestPhoneNumberMessage& operator=(const Message_RequestPhoneNumberMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_RequestPhoneNumberMessage& operator=(Message_RequestPhoneNumberMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_RequestPhoneNumberMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_RequestPhoneNumberMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_RequestPhoneNumberMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 127; - - friend void swap(Message_RequestPhoneNumberMessage& a, Message_RequestPhoneNumberMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_RequestPhoneNumberMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_RequestPhoneNumberMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_RequestPhoneNumberMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_RequestPhoneNumberMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_RequestPhoneNumberMessage& from) { - Message_RequestPhoneNumberMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_RequestPhoneNumberMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.RequestPhoneNumberMessage"; - } - protected: - explicit Message_RequestPhoneNumberMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kContextInfoFieldNumber = 1, - }; - // optional .proto.ContextInfo contextInfo = 1; - bool has_contextinfo() const; - private: - bool _internal_has_contextinfo() const; - public: - void clear_contextinfo(); - const ::proto::ContextInfo& contextinfo() const; - PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); - ::proto::ContextInfo* mutable_contextinfo(); - void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); - private: - const ::proto::ContextInfo& _internal_contextinfo() const; - ::proto::ContextInfo* _internal_mutable_contextinfo(); - public: - void unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo); - ::proto::ContextInfo* unsafe_arena_release_contextinfo(); - - // @@protoc_insertion_point(class_scope:proto.Message.RequestPhoneNumberMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::proto::ContextInfo* contextinfo_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_SendPaymentMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.SendPaymentMessage) */ { - public: - inline Message_SendPaymentMessage() : Message_SendPaymentMessage(nullptr) {} - ~Message_SendPaymentMessage() override; - explicit PROTOBUF_CONSTEXPR Message_SendPaymentMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_SendPaymentMessage(const Message_SendPaymentMessage& from); - Message_SendPaymentMessage(Message_SendPaymentMessage&& from) noexcept - : Message_SendPaymentMessage() { - *this = ::std::move(from); - } - - inline Message_SendPaymentMessage& operator=(const Message_SendPaymentMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_SendPaymentMessage& operator=(Message_SendPaymentMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_SendPaymentMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_SendPaymentMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_SendPaymentMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 128; - - friend void swap(Message_SendPaymentMessage& a, Message_SendPaymentMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_SendPaymentMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_SendPaymentMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_SendPaymentMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_SendPaymentMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_SendPaymentMessage& from) { - Message_SendPaymentMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_SendPaymentMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.SendPaymentMessage"; - } - protected: - explicit Message_SendPaymentMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kNoteMessageFieldNumber = 2, - kRequestMessageKeyFieldNumber = 3, - kBackgroundFieldNumber = 4, - }; - // optional .proto.Message noteMessage = 2; - bool has_notemessage() const; - private: - bool _internal_has_notemessage() const; - public: - void clear_notemessage(); - const ::proto::Message& notemessage() const; - PROTOBUF_NODISCARD ::proto::Message* release_notemessage(); - ::proto::Message* mutable_notemessage(); - void set_allocated_notemessage(::proto::Message* notemessage); - private: - const ::proto::Message& _internal_notemessage() const; - ::proto::Message* _internal_mutable_notemessage(); - public: - void unsafe_arena_set_allocated_notemessage( - ::proto::Message* notemessage); - ::proto::Message* unsafe_arena_release_notemessage(); - - // optional .proto.MessageKey requestMessageKey = 3; - bool has_requestmessagekey() const; - private: - bool _internal_has_requestmessagekey() const; - public: - void clear_requestmessagekey(); - const ::proto::MessageKey& requestmessagekey() const; - PROTOBUF_NODISCARD ::proto::MessageKey* release_requestmessagekey(); - ::proto::MessageKey* mutable_requestmessagekey(); - void set_allocated_requestmessagekey(::proto::MessageKey* requestmessagekey); - private: - const ::proto::MessageKey& _internal_requestmessagekey() const; - ::proto::MessageKey* _internal_mutable_requestmessagekey(); - public: - void unsafe_arena_set_allocated_requestmessagekey( - ::proto::MessageKey* requestmessagekey); - ::proto::MessageKey* unsafe_arena_release_requestmessagekey(); - - // optional .proto.PaymentBackground background = 4; - bool has_background() const; - private: - bool _internal_has_background() const; - public: - void clear_background(); - const ::proto::PaymentBackground& background() const; - PROTOBUF_NODISCARD ::proto::PaymentBackground* release_background(); - ::proto::PaymentBackground* mutable_background(); - void set_allocated_background(::proto::PaymentBackground* background); - private: - const ::proto::PaymentBackground& _internal_background() const; - ::proto::PaymentBackground* _internal_mutable_background(); - public: - void unsafe_arena_set_allocated_background( - ::proto::PaymentBackground* background); - ::proto::PaymentBackground* unsafe_arena_release_background(); - - // @@protoc_insertion_point(class_scope:proto.Message.SendPaymentMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::proto::Message* notemessage_; - ::proto::MessageKey* requestmessagekey_; - ::proto::PaymentBackground* background_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_SenderKeyDistributionMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.SenderKeyDistributionMessage) */ { - public: - inline Message_SenderKeyDistributionMessage() : Message_SenderKeyDistributionMessage(nullptr) {} - ~Message_SenderKeyDistributionMessage() override; - explicit PROTOBUF_CONSTEXPR Message_SenderKeyDistributionMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_SenderKeyDistributionMessage(const Message_SenderKeyDistributionMessage& from); - Message_SenderKeyDistributionMessage(Message_SenderKeyDistributionMessage&& from) noexcept - : Message_SenderKeyDistributionMessage() { - *this = ::std::move(from); - } - - inline Message_SenderKeyDistributionMessage& operator=(const Message_SenderKeyDistributionMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_SenderKeyDistributionMessage& operator=(Message_SenderKeyDistributionMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_SenderKeyDistributionMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_SenderKeyDistributionMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_SenderKeyDistributionMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 129; - - friend void swap(Message_SenderKeyDistributionMessage& a, Message_SenderKeyDistributionMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_SenderKeyDistributionMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_SenderKeyDistributionMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_SenderKeyDistributionMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_SenderKeyDistributionMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_SenderKeyDistributionMessage& from) { - Message_SenderKeyDistributionMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_SenderKeyDistributionMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.SenderKeyDistributionMessage"; - } - protected: - explicit Message_SenderKeyDistributionMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kGroupIdFieldNumber = 1, - kAxolotlSenderKeyDistributionMessageFieldNumber = 2, - }; - // optional string groupId = 1; - bool has_groupid() const; - private: - bool _internal_has_groupid() const; - public: - void clear_groupid(); - const std::string& groupid() const; - template - void set_groupid(ArgT0&& arg0, ArgT... args); - std::string* mutable_groupid(); - PROTOBUF_NODISCARD std::string* release_groupid(); - void set_allocated_groupid(std::string* groupid); - private: - const std::string& _internal_groupid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_groupid(const std::string& value); - std::string* _internal_mutable_groupid(); - public: - - // optional bytes axolotlSenderKeyDistributionMessage = 2; - bool has_axolotlsenderkeydistributionmessage() const; - private: - bool _internal_has_axolotlsenderkeydistributionmessage() const; - public: - void clear_axolotlsenderkeydistributionmessage(); - const std::string& axolotlsenderkeydistributionmessage() const; - template - void set_axolotlsenderkeydistributionmessage(ArgT0&& arg0, ArgT... args); - std::string* mutable_axolotlsenderkeydistributionmessage(); - PROTOBUF_NODISCARD std::string* release_axolotlsenderkeydistributionmessage(); - void set_allocated_axolotlsenderkeydistributionmessage(std::string* axolotlsenderkeydistributionmessage); - private: - const std::string& _internal_axolotlsenderkeydistributionmessage() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_axolotlsenderkeydistributionmessage(const std::string& value); - std::string* _internal_mutable_axolotlsenderkeydistributionmessage(); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.SenderKeyDistributionMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr groupid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr axolotlsenderkeydistributionmessage_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_StickerMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.StickerMessage) */ { - public: - inline Message_StickerMessage() : Message_StickerMessage(nullptr) {} - ~Message_StickerMessage() override; - explicit PROTOBUF_CONSTEXPR Message_StickerMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_StickerMessage(const Message_StickerMessage& from); - Message_StickerMessage(Message_StickerMessage&& from) noexcept - : Message_StickerMessage() { - *this = ::std::move(from); - } - - inline Message_StickerMessage& operator=(const Message_StickerMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_StickerMessage& operator=(Message_StickerMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_StickerMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_StickerMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_StickerMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 130; - - friend void swap(Message_StickerMessage& a, Message_StickerMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_StickerMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_StickerMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_StickerMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_StickerMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_StickerMessage& from) { - Message_StickerMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_StickerMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.StickerMessage"; - } - protected: - explicit Message_StickerMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kUrlFieldNumber = 1, - kFileSha256FieldNumber = 2, - kFileEncSha256FieldNumber = 3, - kMediaKeyFieldNumber = 4, - kMimetypeFieldNumber = 5, - kDirectPathFieldNumber = 8, - kFirstFrameSidecarFieldNumber = 12, - kPngThumbnailFieldNumber = 16, - kContextInfoFieldNumber = 17, - kHeightFieldNumber = 6, - kWidthFieldNumber = 7, - kFileLengthFieldNumber = 9, - kMediaKeyTimestampFieldNumber = 10, - kFirstFrameLengthFieldNumber = 11, - kIsAnimatedFieldNumber = 13, - }; - // optional string url = 1; - bool has_url() const; - private: - bool _internal_has_url() const; - public: - void clear_url(); - const std::string& url() const; - template - void set_url(ArgT0&& arg0, ArgT... args); - std::string* mutable_url(); - PROTOBUF_NODISCARD std::string* release_url(); - void set_allocated_url(std::string* url); - private: - const std::string& _internal_url() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value); - std::string* _internal_mutable_url(); - public: - - // optional bytes fileSha256 = 2; - bool has_filesha256() const; - private: - bool _internal_has_filesha256() const; - public: - void clear_filesha256(); - const std::string& filesha256() const; - template - void set_filesha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_filesha256(); - PROTOBUF_NODISCARD std::string* release_filesha256(); - void set_allocated_filesha256(std::string* filesha256); - private: - const std::string& _internal_filesha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value); - std::string* _internal_mutable_filesha256(); - public: - - // optional bytes fileEncSha256 = 3; - bool has_fileencsha256() const; - private: - bool _internal_has_fileencsha256() const; - public: - void clear_fileencsha256(); - const std::string& fileencsha256() const; - template - void set_fileencsha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_fileencsha256(); - PROTOBUF_NODISCARD std::string* release_fileencsha256(); - void set_allocated_fileencsha256(std::string* fileencsha256); - private: - const std::string& _internal_fileencsha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value); - std::string* _internal_mutable_fileencsha256(); - public: - - // optional bytes mediaKey = 4; - bool has_mediakey() const; - private: - bool _internal_has_mediakey() const; - public: - void clear_mediakey(); - const std::string& mediakey() const; - template - void set_mediakey(ArgT0&& arg0, ArgT... args); - std::string* mutable_mediakey(); - PROTOBUF_NODISCARD std::string* release_mediakey(); - void set_allocated_mediakey(std::string* mediakey); - private: - const std::string& _internal_mediakey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value); - std::string* _internal_mutable_mediakey(); - public: - - // optional string mimetype = 5; - bool has_mimetype() const; - private: - bool _internal_has_mimetype() const; - public: - void clear_mimetype(); - const std::string& mimetype() const; - template - void set_mimetype(ArgT0&& arg0, ArgT... args); - std::string* mutable_mimetype(); - PROTOBUF_NODISCARD std::string* release_mimetype(); - void set_allocated_mimetype(std::string* mimetype); - private: - const std::string& _internal_mimetype() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value); - std::string* _internal_mutable_mimetype(); - public: - - // optional string directPath = 8; - bool has_directpath() const; - private: - bool _internal_has_directpath() const; - public: - void clear_directpath(); - const std::string& directpath() const; - template - void set_directpath(ArgT0&& arg0, ArgT... args); - std::string* mutable_directpath(); - PROTOBUF_NODISCARD std::string* release_directpath(); - void set_allocated_directpath(std::string* directpath); - private: - const std::string& _internal_directpath() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value); - std::string* _internal_mutable_directpath(); - public: - - // optional bytes firstFrameSidecar = 12; - bool has_firstframesidecar() const; - private: - bool _internal_has_firstframesidecar() const; - public: - void clear_firstframesidecar(); - const std::string& firstframesidecar() const; - template - void set_firstframesidecar(ArgT0&& arg0, ArgT... args); - std::string* mutable_firstframesidecar(); - PROTOBUF_NODISCARD std::string* release_firstframesidecar(); - void set_allocated_firstframesidecar(std::string* firstframesidecar); - private: - const std::string& _internal_firstframesidecar() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_firstframesidecar(const std::string& value); - std::string* _internal_mutable_firstframesidecar(); - public: - - // optional bytes pngThumbnail = 16; - bool has_pngthumbnail() const; - private: - bool _internal_has_pngthumbnail() const; - public: - void clear_pngthumbnail(); - const std::string& pngthumbnail() const; - template - void set_pngthumbnail(ArgT0&& arg0, ArgT... args); - std::string* mutable_pngthumbnail(); - PROTOBUF_NODISCARD std::string* release_pngthumbnail(); - void set_allocated_pngthumbnail(std::string* pngthumbnail); - private: - const std::string& _internal_pngthumbnail() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_pngthumbnail(const std::string& value); - std::string* _internal_mutable_pngthumbnail(); - public: - - // optional .proto.ContextInfo contextInfo = 17; - bool has_contextinfo() const; - private: - bool _internal_has_contextinfo() const; - public: - void clear_contextinfo(); - const ::proto::ContextInfo& contextinfo() const; - PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); - ::proto::ContextInfo* mutable_contextinfo(); - void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); - private: - const ::proto::ContextInfo& _internal_contextinfo() const; - ::proto::ContextInfo* _internal_mutable_contextinfo(); - public: - void unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo); - ::proto::ContextInfo* unsafe_arena_release_contextinfo(); - - // optional uint32 height = 6; - bool has_height() const; - private: - bool _internal_has_height() const; - public: - void clear_height(); - uint32_t height() const; - void set_height(uint32_t value); - private: - uint32_t _internal_height() const; - void _internal_set_height(uint32_t value); - public: - - // optional uint32 width = 7; - bool has_width() const; - private: - bool _internal_has_width() const; - public: - void clear_width(); - uint32_t width() const; - void set_width(uint32_t value); - private: - uint32_t _internal_width() const; - void _internal_set_width(uint32_t value); - public: - - // optional uint64 fileLength = 9; - bool has_filelength() const; - private: - bool _internal_has_filelength() const; - public: - void clear_filelength(); - uint64_t filelength() const; - void set_filelength(uint64_t value); - private: - uint64_t _internal_filelength() const; - void _internal_set_filelength(uint64_t value); - public: - - // optional int64 mediaKeyTimestamp = 10; - bool has_mediakeytimestamp() const; - private: - bool _internal_has_mediakeytimestamp() const; - public: - void clear_mediakeytimestamp(); - int64_t mediakeytimestamp() const; - void set_mediakeytimestamp(int64_t value); - private: - int64_t _internal_mediakeytimestamp() const; - void _internal_set_mediakeytimestamp(int64_t value); - public: - - // optional uint32 firstFrameLength = 11; - bool has_firstframelength() const; - private: - bool _internal_has_firstframelength() const; - public: - void clear_firstframelength(); - uint32_t firstframelength() const; - void set_firstframelength(uint32_t value); - private: - uint32_t _internal_firstframelength() const; - void _internal_set_firstframelength(uint32_t value); - public: - - // optional bool isAnimated = 13; - bool has_isanimated() const; - private: - bool _internal_has_isanimated() const; - public: - void clear_isanimated(); - bool isanimated() const; - void set_isanimated(bool value); - private: - bool _internal_isanimated() const; - void _internal_set_isanimated(bool value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.StickerMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mimetype_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr firstframesidecar_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pngthumbnail_; - ::proto::ContextInfo* contextinfo_; - uint32_t height_; - uint32_t width_; - uint64_t filelength_; - int64_t mediakeytimestamp_; - uint32_t firstframelength_; - bool isanimated_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_StickerSyncRMRMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.StickerSyncRMRMessage) */ { - public: - inline Message_StickerSyncRMRMessage() : Message_StickerSyncRMRMessage(nullptr) {} - ~Message_StickerSyncRMRMessage() override; - explicit PROTOBUF_CONSTEXPR Message_StickerSyncRMRMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_StickerSyncRMRMessage(const Message_StickerSyncRMRMessage& from); - Message_StickerSyncRMRMessage(Message_StickerSyncRMRMessage&& from) noexcept - : Message_StickerSyncRMRMessage() { - *this = ::std::move(from); - } - - inline Message_StickerSyncRMRMessage& operator=(const Message_StickerSyncRMRMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_StickerSyncRMRMessage& operator=(Message_StickerSyncRMRMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_StickerSyncRMRMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_StickerSyncRMRMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_StickerSyncRMRMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 131; - - friend void swap(Message_StickerSyncRMRMessage& a, Message_StickerSyncRMRMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_StickerSyncRMRMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_StickerSyncRMRMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_StickerSyncRMRMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_StickerSyncRMRMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_StickerSyncRMRMessage& from) { - Message_StickerSyncRMRMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_StickerSyncRMRMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.StickerSyncRMRMessage"; - } - protected: - explicit Message_StickerSyncRMRMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kFilehashFieldNumber = 1, - kRmrSourceFieldNumber = 2, - kRequestTimestampFieldNumber = 3, - }; - // repeated string filehash = 1; - int filehash_size() const; - private: - int _internal_filehash_size() const; - public: - void clear_filehash(); - const std::string& filehash(int index) const; - std::string* mutable_filehash(int index); - void set_filehash(int index, const std::string& value); - void set_filehash(int index, std::string&& value); - void set_filehash(int index, const char* value); - void set_filehash(int index, const char* value, size_t size); - std::string* add_filehash(); - void add_filehash(const std::string& value); - void add_filehash(std::string&& value); - void add_filehash(const char* value); - void add_filehash(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& filehash() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_filehash(); - private: - const std::string& _internal_filehash(int index) const; - std::string* _internal_add_filehash(); - public: - - // optional string rmrSource = 2; - bool has_rmrsource() const; - private: - bool _internal_has_rmrsource() const; - public: - void clear_rmrsource(); - const std::string& rmrsource() const; - template - void set_rmrsource(ArgT0&& arg0, ArgT... args); - std::string* mutable_rmrsource(); - PROTOBUF_NODISCARD std::string* release_rmrsource(); - void set_allocated_rmrsource(std::string* rmrsource); - private: - const std::string& _internal_rmrsource() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_rmrsource(const std::string& value); - std::string* _internal_mutable_rmrsource(); - public: - - // optional int64 requestTimestamp = 3; - bool has_requesttimestamp() const; - private: - bool _internal_has_requesttimestamp() const; - public: - void clear_requesttimestamp(); - int64_t requesttimestamp() const; - void set_requesttimestamp(int64_t value); - private: - int64_t _internal_requesttimestamp() const; - void _internal_set_requesttimestamp(int64_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.StickerSyncRMRMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField filehash_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rmrsource_; - int64_t requesttimestamp_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_TemplateButtonReplyMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.TemplateButtonReplyMessage) */ { - public: - inline Message_TemplateButtonReplyMessage() : Message_TemplateButtonReplyMessage(nullptr) {} - ~Message_TemplateButtonReplyMessage() override; - explicit PROTOBUF_CONSTEXPR Message_TemplateButtonReplyMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_TemplateButtonReplyMessage(const Message_TemplateButtonReplyMessage& from); - Message_TemplateButtonReplyMessage(Message_TemplateButtonReplyMessage&& from) noexcept - : Message_TemplateButtonReplyMessage() { - *this = ::std::move(from); - } - - inline Message_TemplateButtonReplyMessage& operator=(const Message_TemplateButtonReplyMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_TemplateButtonReplyMessage& operator=(Message_TemplateButtonReplyMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_TemplateButtonReplyMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_TemplateButtonReplyMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_TemplateButtonReplyMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 132; - - friend void swap(Message_TemplateButtonReplyMessage& a, Message_TemplateButtonReplyMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_TemplateButtonReplyMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_TemplateButtonReplyMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_TemplateButtonReplyMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_TemplateButtonReplyMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_TemplateButtonReplyMessage& from) { - Message_TemplateButtonReplyMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_TemplateButtonReplyMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.TemplateButtonReplyMessage"; - } - protected: - explicit Message_TemplateButtonReplyMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kSelectedIdFieldNumber = 1, - kSelectedDisplayTextFieldNumber = 2, - kContextInfoFieldNumber = 3, - kSelectedIndexFieldNumber = 4, - }; - // optional string selectedId = 1; - bool has_selectedid() const; - private: - bool _internal_has_selectedid() const; - public: - void clear_selectedid(); - const std::string& selectedid() const; - template - void set_selectedid(ArgT0&& arg0, ArgT... args); - std::string* mutable_selectedid(); - PROTOBUF_NODISCARD std::string* release_selectedid(); - void set_allocated_selectedid(std::string* selectedid); - private: - const std::string& _internal_selectedid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_selectedid(const std::string& value); - std::string* _internal_mutable_selectedid(); - public: - - // optional string selectedDisplayText = 2; - bool has_selecteddisplaytext() const; - private: - bool _internal_has_selecteddisplaytext() const; - public: - void clear_selecteddisplaytext(); - const std::string& selecteddisplaytext() const; - template - void set_selecteddisplaytext(ArgT0&& arg0, ArgT... args); - std::string* mutable_selecteddisplaytext(); - PROTOBUF_NODISCARD std::string* release_selecteddisplaytext(); - void set_allocated_selecteddisplaytext(std::string* selecteddisplaytext); - private: - const std::string& _internal_selecteddisplaytext() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_selecteddisplaytext(const std::string& value); - std::string* _internal_mutable_selecteddisplaytext(); - public: - - // optional .proto.ContextInfo contextInfo = 3; - bool has_contextinfo() const; - private: - bool _internal_has_contextinfo() const; - public: - void clear_contextinfo(); - const ::proto::ContextInfo& contextinfo() const; - PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); - ::proto::ContextInfo* mutable_contextinfo(); - void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); - private: - const ::proto::ContextInfo& _internal_contextinfo() const; - ::proto::ContextInfo* _internal_mutable_contextinfo(); - public: - void unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo); - ::proto::ContextInfo* unsafe_arena_release_contextinfo(); - - // optional uint32 selectedIndex = 4; - bool has_selectedindex() const; - private: - bool _internal_has_selectedindex() const; - public: - void clear_selectedindex(); - uint32_t selectedindex() const; - void set_selectedindex(uint32_t value); - private: - uint32_t _internal_selectedindex() const; - void _internal_set_selectedindex(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.TemplateButtonReplyMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr selectedid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr selecteddisplaytext_; - ::proto::ContextInfo* contextinfo_; - uint32_t selectedindex_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_TemplateMessage_FourRowTemplate final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.TemplateMessage.FourRowTemplate) */ { - public: - inline Message_TemplateMessage_FourRowTemplate() : Message_TemplateMessage_FourRowTemplate(nullptr) {} - ~Message_TemplateMessage_FourRowTemplate() override; - explicit PROTOBUF_CONSTEXPR Message_TemplateMessage_FourRowTemplate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_TemplateMessage_FourRowTemplate(const Message_TemplateMessage_FourRowTemplate& from); - Message_TemplateMessage_FourRowTemplate(Message_TemplateMessage_FourRowTemplate&& from) noexcept - : Message_TemplateMessage_FourRowTemplate() { - *this = ::std::move(from); - } - - inline Message_TemplateMessage_FourRowTemplate& operator=(const Message_TemplateMessage_FourRowTemplate& from) { - CopyFrom(from); - return *this; - } - inline Message_TemplateMessage_FourRowTemplate& operator=(Message_TemplateMessage_FourRowTemplate&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_TemplateMessage_FourRowTemplate& default_instance() { - return *internal_default_instance(); - } - enum TitleCase { - kDocumentMessage = 1, - kHighlyStructuredMessage = 2, - kImageMessage = 3, - kVideoMessage = 4, - kLocationMessage = 5, - TITLE_NOT_SET = 0, - }; - - static inline const Message_TemplateMessage_FourRowTemplate* internal_default_instance() { - return reinterpret_cast( - &_Message_TemplateMessage_FourRowTemplate_default_instance_); - } - static constexpr int kIndexInFileMessages = - 133; - - friend void swap(Message_TemplateMessage_FourRowTemplate& a, Message_TemplateMessage_FourRowTemplate& b) { - a.Swap(&b); - } - inline void Swap(Message_TemplateMessage_FourRowTemplate* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_TemplateMessage_FourRowTemplate* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_TemplateMessage_FourRowTemplate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_TemplateMessage_FourRowTemplate& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_TemplateMessage_FourRowTemplate& from) { - Message_TemplateMessage_FourRowTemplate::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_TemplateMessage_FourRowTemplate* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.TemplateMessage.FourRowTemplate"; - } - protected: - explicit Message_TemplateMessage_FourRowTemplate(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kButtonsFieldNumber = 8, - kContentFieldNumber = 6, - kFooterFieldNumber = 7, - kDocumentMessageFieldNumber = 1, - kHighlyStructuredMessageFieldNumber = 2, - kImageMessageFieldNumber = 3, - kVideoMessageFieldNumber = 4, - kLocationMessageFieldNumber = 5, - }; - // repeated .proto.TemplateButton buttons = 8; - int buttons_size() const; - private: - int _internal_buttons_size() const; - public: - void clear_buttons(); - ::proto::TemplateButton* mutable_buttons(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::TemplateButton >* - mutable_buttons(); - private: - const ::proto::TemplateButton& _internal_buttons(int index) const; - ::proto::TemplateButton* _internal_add_buttons(); - public: - const ::proto::TemplateButton& buttons(int index) const; - ::proto::TemplateButton* add_buttons(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::TemplateButton >& - buttons() const; - - // optional .proto.Message.HighlyStructuredMessage content = 6; - bool has_content() const; - private: - bool _internal_has_content() const; - public: - void clear_content(); - const ::proto::Message_HighlyStructuredMessage& content() const; - PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_content(); - ::proto::Message_HighlyStructuredMessage* mutable_content(); - void set_allocated_content(::proto::Message_HighlyStructuredMessage* content); - private: - const ::proto::Message_HighlyStructuredMessage& _internal_content() const; - ::proto::Message_HighlyStructuredMessage* _internal_mutable_content(); - public: - void unsafe_arena_set_allocated_content( - ::proto::Message_HighlyStructuredMessage* content); - ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_content(); - - // optional .proto.Message.HighlyStructuredMessage footer = 7; - bool has_footer() const; - private: - bool _internal_has_footer() const; - public: - void clear_footer(); - const ::proto::Message_HighlyStructuredMessage& footer() const; - PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_footer(); - ::proto::Message_HighlyStructuredMessage* mutable_footer(); - void set_allocated_footer(::proto::Message_HighlyStructuredMessage* footer); - private: - const ::proto::Message_HighlyStructuredMessage& _internal_footer() const; - ::proto::Message_HighlyStructuredMessage* _internal_mutable_footer(); - public: - void unsafe_arena_set_allocated_footer( - ::proto::Message_HighlyStructuredMessage* footer); - ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_footer(); - - // .proto.Message.DocumentMessage documentMessage = 1; - bool has_documentmessage() const; - private: - bool _internal_has_documentmessage() const; - public: - void clear_documentmessage(); - const ::proto::Message_DocumentMessage& documentmessage() const; - PROTOBUF_NODISCARD ::proto::Message_DocumentMessage* release_documentmessage(); - ::proto::Message_DocumentMessage* mutable_documentmessage(); - void set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage); - private: - const ::proto::Message_DocumentMessage& _internal_documentmessage() const; - ::proto::Message_DocumentMessage* _internal_mutable_documentmessage(); - public: - void unsafe_arena_set_allocated_documentmessage( - ::proto::Message_DocumentMessage* documentmessage); - ::proto::Message_DocumentMessage* unsafe_arena_release_documentmessage(); - - // .proto.Message.HighlyStructuredMessage highlyStructuredMessage = 2; - bool has_highlystructuredmessage() const; - private: - bool _internal_has_highlystructuredmessage() const; - public: - void clear_highlystructuredmessage(); - const ::proto::Message_HighlyStructuredMessage& highlystructuredmessage() const; - PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_highlystructuredmessage(); - ::proto::Message_HighlyStructuredMessage* mutable_highlystructuredmessage(); - void set_allocated_highlystructuredmessage(::proto::Message_HighlyStructuredMessage* highlystructuredmessage); - private: - const ::proto::Message_HighlyStructuredMessage& _internal_highlystructuredmessage() const; - ::proto::Message_HighlyStructuredMessage* _internal_mutable_highlystructuredmessage(); - public: - void unsafe_arena_set_allocated_highlystructuredmessage( - ::proto::Message_HighlyStructuredMessage* highlystructuredmessage); - ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_highlystructuredmessage(); - - // .proto.Message.ImageMessage imageMessage = 3; - bool has_imagemessage() const; - private: - bool _internal_has_imagemessage() const; - public: - void clear_imagemessage(); - const ::proto::Message_ImageMessage& imagemessage() const; - PROTOBUF_NODISCARD ::proto::Message_ImageMessage* release_imagemessage(); - ::proto::Message_ImageMessage* mutable_imagemessage(); - void set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage); - private: - const ::proto::Message_ImageMessage& _internal_imagemessage() const; - ::proto::Message_ImageMessage* _internal_mutable_imagemessage(); - public: - void unsafe_arena_set_allocated_imagemessage( - ::proto::Message_ImageMessage* imagemessage); - ::proto::Message_ImageMessage* unsafe_arena_release_imagemessage(); - - // .proto.Message.VideoMessage videoMessage = 4; - bool has_videomessage() const; - private: - bool _internal_has_videomessage() const; - public: - void clear_videomessage(); - const ::proto::Message_VideoMessage& videomessage() const; - PROTOBUF_NODISCARD ::proto::Message_VideoMessage* release_videomessage(); - ::proto::Message_VideoMessage* mutable_videomessage(); - void set_allocated_videomessage(::proto::Message_VideoMessage* videomessage); - private: - const ::proto::Message_VideoMessage& _internal_videomessage() const; - ::proto::Message_VideoMessage* _internal_mutable_videomessage(); - public: - void unsafe_arena_set_allocated_videomessage( - ::proto::Message_VideoMessage* videomessage); - ::proto::Message_VideoMessage* unsafe_arena_release_videomessage(); - - // .proto.Message.LocationMessage locationMessage = 5; - bool has_locationmessage() const; - private: - bool _internal_has_locationmessage() const; - public: - void clear_locationmessage(); - const ::proto::Message_LocationMessage& locationmessage() const; - PROTOBUF_NODISCARD ::proto::Message_LocationMessage* release_locationmessage(); - ::proto::Message_LocationMessage* mutable_locationmessage(); - void set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage); - private: - const ::proto::Message_LocationMessage& _internal_locationmessage() const; - ::proto::Message_LocationMessage* _internal_mutable_locationmessage(); - public: - void unsafe_arena_set_allocated_locationmessage( - ::proto::Message_LocationMessage* locationmessage); - ::proto::Message_LocationMessage* unsafe_arena_release_locationmessage(); - - void clear_title(); - TitleCase title_case() const; - // @@protoc_insertion_point(class_scope:proto.Message.TemplateMessage.FourRowTemplate) - private: - class _Internal; - void set_has_documentmessage(); - void set_has_highlystructuredmessage(); - void set_has_imagemessage(); - void set_has_videomessage(); - void set_has_locationmessage(); - - inline bool has_title() const; - inline void clear_has_title(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::TemplateButton > buttons_; - ::proto::Message_HighlyStructuredMessage* content_; - ::proto::Message_HighlyStructuredMessage* footer_; - union TitleUnion { - constexpr TitleUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::proto::Message_DocumentMessage* documentmessage_; - ::proto::Message_HighlyStructuredMessage* highlystructuredmessage_; - ::proto::Message_ImageMessage* imagemessage_; - ::proto::Message_VideoMessage* videomessage_; - ::proto::Message_LocationMessage* locationmessage_; - } title_; - uint32_t _oneof_case_[1]; - - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_TemplateMessage_HydratedFourRowTemplate final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.TemplateMessage.HydratedFourRowTemplate) */ { - public: - inline Message_TemplateMessage_HydratedFourRowTemplate() : Message_TemplateMessage_HydratedFourRowTemplate(nullptr) {} - ~Message_TemplateMessage_HydratedFourRowTemplate() override; - explicit PROTOBUF_CONSTEXPR Message_TemplateMessage_HydratedFourRowTemplate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_TemplateMessage_HydratedFourRowTemplate(const Message_TemplateMessage_HydratedFourRowTemplate& from); - Message_TemplateMessage_HydratedFourRowTemplate(Message_TemplateMessage_HydratedFourRowTemplate&& from) noexcept - : Message_TemplateMessage_HydratedFourRowTemplate() { - *this = ::std::move(from); - } - - inline Message_TemplateMessage_HydratedFourRowTemplate& operator=(const Message_TemplateMessage_HydratedFourRowTemplate& from) { - CopyFrom(from); - return *this; - } - inline Message_TemplateMessage_HydratedFourRowTemplate& operator=(Message_TemplateMessage_HydratedFourRowTemplate&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_TemplateMessage_HydratedFourRowTemplate& default_instance() { - return *internal_default_instance(); - } - enum TitleCase { - kDocumentMessage = 1, - kHydratedTitleText = 2, - kImageMessage = 3, - kVideoMessage = 4, - kLocationMessage = 5, - TITLE_NOT_SET = 0, - }; - - static inline const Message_TemplateMessage_HydratedFourRowTemplate* internal_default_instance() { - return reinterpret_cast( - &_Message_TemplateMessage_HydratedFourRowTemplate_default_instance_); - } - static constexpr int kIndexInFileMessages = - 134; - - friend void swap(Message_TemplateMessage_HydratedFourRowTemplate& a, Message_TemplateMessage_HydratedFourRowTemplate& b) { - a.Swap(&b); - } - inline void Swap(Message_TemplateMessage_HydratedFourRowTemplate* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_TemplateMessage_HydratedFourRowTemplate* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_TemplateMessage_HydratedFourRowTemplate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_TemplateMessage_HydratedFourRowTemplate& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_TemplateMessage_HydratedFourRowTemplate& from) { - Message_TemplateMessage_HydratedFourRowTemplate::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_TemplateMessage_HydratedFourRowTemplate* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.TemplateMessage.HydratedFourRowTemplate"; - } - protected: - explicit Message_TemplateMessage_HydratedFourRowTemplate(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kHydratedButtonsFieldNumber = 8, - kHydratedContentTextFieldNumber = 6, - kHydratedFooterTextFieldNumber = 7, - kTemplateIdFieldNumber = 9, - kDocumentMessageFieldNumber = 1, - kHydratedTitleTextFieldNumber = 2, - kImageMessageFieldNumber = 3, - kVideoMessageFieldNumber = 4, - kLocationMessageFieldNumber = 5, - }; - // repeated .proto.HydratedTemplateButton hydratedButtons = 8; - int hydratedbuttons_size() const; - private: - int _internal_hydratedbuttons_size() const; - public: - void clear_hydratedbuttons(); - ::proto::HydratedTemplateButton* mutable_hydratedbuttons(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HydratedTemplateButton >* - mutable_hydratedbuttons(); - private: - const ::proto::HydratedTemplateButton& _internal_hydratedbuttons(int index) const; - ::proto::HydratedTemplateButton* _internal_add_hydratedbuttons(); - public: - const ::proto::HydratedTemplateButton& hydratedbuttons(int index) const; - ::proto::HydratedTemplateButton* add_hydratedbuttons(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HydratedTemplateButton >& - hydratedbuttons() const; - - // optional string hydratedContentText = 6; - bool has_hydratedcontenttext() const; - private: - bool _internal_has_hydratedcontenttext() const; - public: - void clear_hydratedcontenttext(); - const std::string& hydratedcontenttext() const; - template - void set_hydratedcontenttext(ArgT0&& arg0, ArgT... args); - std::string* mutable_hydratedcontenttext(); - PROTOBUF_NODISCARD std::string* release_hydratedcontenttext(); - void set_allocated_hydratedcontenttext(std::string* hydratedcontenttext); - private: - const std::string& _internal_hydratedcontenttext() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_hydratedcontenttext(const std::string& value); - std::string* _internal_mutable_hydratedcontenttext(); - public: - - // optional string hydratedFooterText = 7; - bool has_hydratedfootertext() const; - private: - bool _internal_has_hydratedfootertext() const; - public: - void clear_hydratedfootertext(); - const std::string& hydratedfootertext() const; - template - void set_hydratedfootertext(ArgT0&& arg0, ArgT... args); - std::string* mutable_hydratedfootertext(); - PROTOBUF_NODISCARD std::string* release_hydratedfootertext(); - void set_allocated_hydratedfootertext(std::string* hydratedfootertext); - private: - const std::string& _internal_hydratedfootertext() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_hydratedfootertext(const std::string& value); - std::string* _internal_mutable_hydratedfootertext(); - public: - - // optional string templateId = 9; - bool has_templateid() const; - private: - bool _internal_has_templateid() const; - public: - void clear_templateid(); - const std::string& templateid() const; - template - void set_templateid(ArgT0&& arg0, ArgT... args); - std::string* mutable_templateid(); - PROTOBUF_NODISCARD std::string* release_templateid(); - void set_allocated_templateid(std::string* templateid); - private: - const std::string& _internal_templateid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_templateid(const std::string& value); - std::string* _internal_mutable_templateid(); - public: - - // .proto.Message.DocumentMessage documentMessage = 1; - bool has_documentmessage() const; - private: - bool _internal_has_documentmessage() const; - public: - void clear_documentmessage(); - const ::proto::Message_DocumentMessage& documentmessage() const; - PROTOBUF_NODISCARD ::proto::Message_DocumentMessage* release_documentmessage(); - ::proto::Message_DocumentMessage* mutable_documentmessage(); - void set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage); - private: - const ::proto::Message_DocumentMessage& _internal_documentmessage() const; - ::proto::Message_DocumentMessage* _internal_mutable_documentmessage(); - public: - void unsafe_arena_set_allocated_documentmessage( - ::proto::Message_DocumentMessage* documentmessage); - ::proto::Message_DocumentMessage* unsafe_arena_release_documentmessage(); - - // string hydratedTitleText = 2; - bool has_hydratedtitletext() const; - private: - bool _internal_has_hydratedtitletext() const; - public: - void clear_hydratedtitletext(); - const std::string& hydratedtitletext() const; - template - void set_hydratedtitletext(ArgT0&& arg0, ArgT... args); - std::string* mutable_hydratedtitletext(); - PROTOBUF_NODISCARD std::string* release_hydratedtitletext(); - void set_allocated_hydratedtitletext(std::string* hydratedtitletext); - private: - const std::string& _internal_hydratedtitletext() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_hydratedtitletext(const std::string& value); - std::string* _internal_mutable_hydratedtitletext(); - public: - - // .proto.Message.ImageMessage imageMessage = 3; - bool has_imagemessage() const; - private: - bool _internal_has_imagemessage() const; - public: - void clear_imagemessage(); - const ::proto::Message_ImageMessage& imagemessage() const; - PROTOBUF_NODISCARD ::proto::Message_ImageMessage* release_imagemessage(); - ::proto::Message_ImageMessage* mutable_imagemessage(); - void set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage); - private: - const ::proto::Message_ImageMessage& _internal_imagemessage() const; - ::proto::Message_ImageMessage* _internal_mutable_imagemessage(); - public: - void unsafe_arena_set_allocated_imagemessage( - ::proto::Message_ImageMessage* imagemessage); - ::proto::Message_ImageMessage* unsafe_arena_release_imagemessage(); - - // .proto.Message.VideoMessage videoMessage = 4; - bool has_videomessage() const; - private: - bool _internal_has_videomessage() const; - public: - void clear_videomessage(); - const ::proto::Message_VideoMessage& videomessage() const; - PROTOBUF_NODISCARD ::proto::Message_VideoMessage* release_videomessage(); - ::proto::Message_VideoMessage* mutable_videomessage(); - void set_allocated_videomessage(::proto::Message_VideoMessage* videomessage); - private: - const ::proto::Message_VideoMessage& _internal_videomessage() const; - ::proto::Message_VideoMessage* _internal_mutable_videomessage(); - public: - void unsafe_arena_set_allocated_videomessage( - ::proto::Message_VideoMessage* videomessage); - ::proto::Message_VideoMessage* unsafe_arena_release_videomessage(); - - // .proto.Message.LocationMessage locationMessage = 5; - bool has_locationmessage() const; - private: - bool _internal_has_locationmessage() const; - public: - void clear_locationmessage(); - const ::proto::Message_LocationMessage& locationmessage() const; - PROTOBUF_NODISCARD ::proto::Message_LocationMessage* release_locationmessage(); - ::proto::Message_LocationMessage* mutable_locationmessage(); - void set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage); - private: - const ::proto::Message_LocationMessage& _internal_locationmessage() const; - ::proto::Message_LocationMessage* _internal_mutable_locationmessage(); - public: - void unsafe_arena_set_allocated_locationmessage( - ::proto::Message_LocationMessage* locationmessage); - ::proto::Message_LocationMessage* unsafe_arena_release_locationmessage(); - - void clear_title(); - TitleCase title_case() const; - // @@protoc_insertion_point(class_scope:proto.Message.TemplateMessage.HydratedFourRowTemplate) - private: - class _Internal; - void set_has_documentmessage(); - void set_has_hydratedtitletext(); - void set_has_imagemessage(); - void set_has_videomessage(); - void set_has_locationmessage(); - - inline bool has_title() const; - inline void clear_has_title(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HydratedTemplateButton > hydratedbuttons_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hydratedcontenttext_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hydratedfootertext_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr templateid_; - union TitleUnion { - constexpr TitleUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::proto::Message_DocumentMessage* documentmessage_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hydratedtitletext_; - ::proto::Message_ImageMessage* imagemessage_; - ::proto::Message_VideoMessage* videomessage_; - ::proto::Message_LocationMessage* locationmessage_; - } title_; - uint32_t _oneof_case_[1]; - - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_TemplateMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.TemplateMessage) */ { - public: - inline Message_TemplateMessage() : Message_TemplateMessage(nullptr) {} - ~Message_TemplateMessage() override; - explicit PROTOBUF_CONSTEXPR Message_TemplateMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_TemplateMessage(const Message_TemplateMessage& from); - Message_TemplateMessage(Message_TemplateMessage&& from) noexcept - : Message_TemplateMessage() { - *this = ::std::move(from); - } - - inline Message_TemplateMessage& operator=(const Message_TemplateMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_TemplateMessage& operator=(Message_TemplateMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_TemplateMessage& default_instance() { - return *internal_default_instance(); - } - enum FormatCase { - kFourRowTemplate = 1, - kHydratedFourRowTemplate = 2, - FORMAT_NOT_SET = 0, - }; - - static inline const Message_TemplateMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_TemplateMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 135; - - friend void swap(Message_TemplateMessage& a, Message_TemplateMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_TemplateMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_TemplateMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_TemplateMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_TemplateMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_TemplateMessage& from) { - Message_TemplateMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_TemplateMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.TemplateMessage"; - } - protected: - explicit Message_TemplateMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Message_TemplateMessage_FourRowTemplate FourRowTemplate; - typedef Message_TemplateMessage_HydratedFourRowTemplate HydratedFourRowTemplate; - - // accessors ------------------------------------------------------- - - enum : int { - kContextInfoFieldNumber = 3, - kHydratedTemplateFieldNumber = 4, - kFourRowTemplateFieldNumber = 1, - kHydratedFourRowTemplateFieldNumber = 2, - }; - // optional .proto.ContextInfo contextInfo = 3; - bool has_contextinfo() const; - private: - bool _internal_has_contextinfo() const; - public: - void clear_contextinfo(); - const ::proto::ContextInfo& contextinfo() const; - PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); - ::proto::ContextInfo* mutable_contextinfo(); - void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); - private: - const ::proto::ContextInfo& _internal_contextinfo() const; - ::proto::ContextInfo* _internal_mutable_contextinfo(); - public: - void unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo); - ::proto::ContextInfo* unsafe_arena_release_contextinfo(); - - // optional .proto.Message.TemplateMessage.HydratedFourRowTemplate hydratedTemplate = 4; - bool has_hydratedtemplate() const; - private: - bool _internal_has_hydratedtemplate() const; - public: - void clear_hydratedtemplate(); - const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& hydratedtemplate() const; - PROTOBUF_NODISCARD ::proto::Message_TemplateMessage_HydratedFourRowTemplate* release_hydratedtemplate(); - ::proto::Message_TemplateMessage_HydratedFourRowTemplate* mutable_hydratedtemplate(); - void set_allocated_hydratedtemplate(::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedtemplate); - private: - const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& _internal_hydratedtemplate() const; - ::proto::Message_TemplateMessage_HydratedFourRowTemplate* _internal_mutable_hydratedtemplate(); - public: - void unsafe_arena_set_allocated_hydratedtemplate( - ::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedtemplate); - ::proto::Message_TemplateMessage_HydratedFourRowTemplate* unsafe_arena_release_hydratedtemplate(); - - // .proto.Message.TemplateMessage.FourRowTemplate fourRowTemplate = 1; - bool has_fourrowtemplate() const; - private: - bool _internal_has_fourrowtemplate() const; - public: - void clear_fourrowtemplate(); - const ::proto::Message_TemplateMessage_FourRowTemplate& fourrowtemplate() const; - PROTOBUF_NODISCARD ::proto::Message_TemplateMessage_FourRowTemplate* release_fourrowtemplate(); - ::proto::Message_TemplateMessage_FourRowTemplate* mutable_fourrowtemplate(); - void set_allocated_fourrowtemplate(::proto::Message_TemplateMessage_FourRowTemplate* fourrowtemplate); - private: - const ::proto::Message_TemplateMessage_FourRowTemplate& _internal_fourrowtemplate() const; - ::proto::Message_TemplateMessage_FourRowTemplate* _internal_mutable_fourrowtemplate(); - public: - void unsafe_arena_set_allocated_fourrowtemplate( - ::proto::Message_TemplateMessage_FourRowTemplate* fourrowtemplate); - ::proto::Message_TemplateMessage_FourRowTemplate* unsafe_arena_release_fourrowtemplate(); - - // .proto.Message.TemplateMessage.HydratedFourRowTemplate hydratedFourRowTemplate = 2; - bool has_hydratedfourrowtemplate() const; - private: - bool _internal_has_hydratedfourrowtemplate() const; - public: - void clear_hydratedfourrowtemplate(); - const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& hydratedfourrowtemplate() const; - PROTOBUF_NODISCARD ::proto::Message_TemplateMessage_HydratedFourRowTemplate* release_hydratedfourrowtemplate(); - ::proto::Message_TemplateMessage_HydratedFourRowTemplate* mutable_hydratedfourrowtemplate(); - void set_allocated_hydratedfourrowtemplate(::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedfourrowtemplate); - private: - const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& _internal_hydratedfourrowtemplate() const; - ::proto::Message_TemplateMessage_HydratedFourRowTemplate* _internal_mutable_hydratedfourrowtemplate(); - public: - void unsafe_arena_set_allocated_hydratedfourrowtemplate( - ::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedfourrowtemplate); - ::proto::Message_TemplateMessage_HydratedFourRowTemplate* unsafe_arena_release_hydratedfourrowtemplate(); - - void clear_format(); - FormatCase format_case() const; - // @@protoc_insertion_point(class_scope:proto.Message.TemplateMessage) - private: - class _Internal; - void set_has_fourrowtemplate(); - void set_has_hydratedfourrowtemplate(); - - inline bool has_format() const; - inline void clear_has_format(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::proto::ContextInfo* contextinfo_; - ::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedtemplate_; - union FormatUnion { - constexpr FormatUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::proto::Message_TemplateMessage_FourRowTemplate* fourrowtemplate_; - ::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedfourrowtemplate_; - } format_; - uint32_t _oneof_case_[1]; - - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message_VideoMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.VideoMessage) */ { - public: - inline Message_VideoMessage() : Message_VideoMessage(nullptr) {} - ~Message_VideoMessage() override; - explicit PROTOBUF_CONSTEXPR Message_VideoMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message_VideoMessage(const Message_VideoMessage& from); - Message_VideoMessage(Message_VideoMessage&& from) noexcept - : Message_VideoMessage() { - *this = ::std::move(from); - } - - inline Message_VideoMessage& operator=(const Message_VideoMessage& from) { - CopyFrom(from); - return *this; - } - inline Message_VideoMessage& operator=(Message_VideoMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message_VideoMessage& default_instance() { - return *internal_default_instance(); - } - static inline const Message_VideoMessage* internal_default_instance() { - return reinterpret_cast( - &_Message_VideoMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 136; - - friend void swap(Message_VideoMessage& a, Message_VideoMessage& b) { - a.Swap(&b); - } - inline void Swap(Message_VideoMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message_VideoMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message_VideoMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message_VideoMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message_VideoMessage& from) { - Message_VideoMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message_VideoMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message.VideoMessage"; - } - protected: - explicit Message_VideoMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Message_VideoMessage_Attribution Attribution; - static constexpr Attribution NONE = - Message_VideoMessage_Attribution_NONE; - static constexpr Attribution GIPHY = - Message_VideoMessage_Attribution_GIPHY; - static constexpr Attribution TENOR = - Message_VideoMessage_Attribution_TENOR; - static inline bool Attribution_IsValid(int value) { - return Message_VideoMessage_Attribution_IsValid(value); - } - static constexpr Attribution Attribution_MIN = - Message_VideoMessage_Attribution_Attribution_MIN; - static constexpr Attribution Attribution_MAX = - Message_VideoMessage_Attribution_Attribution_MAX; - static constexpr int Attribution_ARRAYSIZE = - Message_VideoMessage_Attribution_Attribution_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - Attribution_descriptor() { - return Message_VideoMessage_Attribution_descriptor(); - } - template - static inline const std::string& Attribution_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Attribution_Name."); - return Message_VideoMessage_Attribution_Name(enum_t_value); - } - static inline bool Attribution_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - Attribution* value) { - return Message_VideoMessage_Attribution_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kInteractiveAnnotationsFieldNumber = 12, - kUrlFieldNumber = 1, - kMimetypeFieldNumber = 2, - kFileSha256FieldNumber = 3, - kMediaKeyFieldNumber = 6, - kCaptionFieldNumber = 7, - kFileEncSha256FieldNumber = 11, - kDirectPathFieldNumber = 13, - kJpegThumbnailFieldNumber = 16, - kStreamingSidecarFieldNumber = 18, - kThumbnailDirectPathFieldNumber = 21, - kThumbnailSha256FieldNumber = 22, - kThumbnailEncSha256FieldNumber = 23, - kStaticUrlFieldNumber = 24, - kContextInfoFieldNumber = 17, - kFileLengthFieldNumber = 4, - kSecondsFieldNumber = 5, - kHeightFieldNumber = 9, - kWidthFieldNumber = 10, - kGifPlaybackFieldNumber = 8, - kViewOnceFieldNumber = 20, - kMediaKeyTimestampFieldNumber = 14, - kGifAttributionFieldNumber = 19, - }; - // repeated .proto.InteractiveAnnotation interactiveAnnotations = 12; - int interactiveannotations_size() const; - private: - int _internal_interactiveannotations_size() const; - public: - void clear_interactiveannotations(); - ::proto::InteractiveAnnotation* mutable_interactiveannotations(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >* - mutable_interactiveannotations(); - private: - const ::proto::InteractiveAnnotation& _internal_interactiveannotations(int index) const; - ::proto::InteractiveAnnotation* _internal_add_interactiveannotations(); - public: - const ::proto::InteractiveAnnotation& interactiveannotations(int index) const; - ::proto::InteractiveAnnotation* add_interactiveannotations(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >& - interactiveannotations() const; - - // optional string url = 1; - bool has_url() const; - private: - bool _internal_has_url() const; - public: - void clear_url(); - const std::string& url() const; - template - void set_url(ArgT0&& arg0, ArgT... args); - std::string* mutable_url(); - PROTOBUF_NODISCARD std::string* release_url(); - void set_allocated_url(std::string* url); - private: - const std::string& _internal_url() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value); - std::string* _internal_mutable_url(); - public: - - // optional string mimetype = 2; - bool has_mimetype() const; - private: - bool _internal_has_mimetype() const; - public: - void clear_mimetype(); - const std::string& mimetype() const; - template - void set_mimetype(ArgT0&& arg0, ArgT... args); - std::string* mutable_mimetype(); - PROTOBUF_NODISCARD std::string* release_mimetype(); - void set_allocated_mimetype(std::string* mimetype); - private: - const std::string& _internal_mimetype() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value); - std::string* _internal_mutable_mimetype(); - public: - - // optional bytes fileSha256 = 3; - bool has_filesha256() const; - private: - bool _internal_has_filesha256() const; - public: - void clear_filesha256(); - const std::string& filesha256() const; - template - void set_filesha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_filesha256(); - PROTOBUF_NODISCARD std::string* release_filesha256(); - void set_allocated_filesha256(std::string* filesha256); - private: - const std::string& _internal_filesha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value); - std::string* _internal_mutable_filesha256(); - public: - - // optional bytes mediaKey = 6; - bool has_mediakey() const; - private: - bool _internal_has_mediakey() const; - public: - void clear_mediakey(); - const std::string& mediakey() const; - template - void set_mediakey(ArgT0&& arg0, ArgT... args); - std::string* mutable_mediakey(); - PROTOBUF_NODISCARD std::string* release_mediakey(); - void set_allocated_mediakey(std::string* mediakey); - private: - const std::string& _internal_mediakey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value); - std::string* _internal_mutable_mediakey(); - public: - - // optional string caption = 7; - bool has_caption() const; - private: - bool _internal_has_caption() const; - public: - void clear_caption(); - const std::string& caption() const; - template - void set_caption(ArgT0&& arg0, ArgT... args); - std::string* mutable_caption(); - PROTOBUF_NODISCARD std::string* release_caption(); - void set_allocated_caption(std::string* caption); - private: - const std::string& _internal_caption() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_caption(const std::string& value); - std::string* _internal_mutable_caption(); - public: - - // optional bytes fileEncSha256 = 11; - bool has_fileencsha256() const; - private: - bool _internal_has_fileencsha256() const; - public: - void clear_fileencsha256(); - const std::string& fileencsha256() const; - template - void set_fileencsha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_fileencsha256(); - PROTOBUF_NODISCARD std::string* release_fileencsha256(); - void set_allocated_fileencsha256(std::string* fileencsha256); - private: - const std::string& _internal_fileencsha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value); - std::string* _internal_mutable_fileencsha256(); - public: - - // optional string directPath = 13; - bool has_directpath() const; - private: - bool _internal_has_directpath() const; - public: - void clear_directpath(); - const std::string& directpath() const; - template - void set_directpath(ArgT0&& arg0, ArgT... args); - std::string* mutable_directpath(); - PROTOBUF_NODISCARD std::string* release_directpath(); - void set_allocated_directpath(std::string* directpath); - private: - const std::string& _internal_directpath() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value); - std::string* _internal_mutable_directpath(); - public: - - // optional bytes jpegThumbnail = 16; - bool has_jpegthumbnail() const; - private: - bool _internal_has_jpegthumbnail() const; - public: - void clear_jpegthumbnail(); - const std::string& jpegthumbnail() const; - template - void set_jpegthumbnail(ArgT0&& arg0, ArgT... args); - std::string* mutable_jpegthumbnail(); - PROTOBUF_NODISCARD std::string* release_jpegthumbnail(); - void set_allocated_jpegthumbnail(std::string* jpegthumbnail); - private: - const std::string& _internal_jpegthumbnail() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value); - std::string* _internal_mutable_jpegthumbnail(); - public: - - // optional bytes streamingSidecar = 18; - bool has_streamingsidecar() const; - private: - bool _internal_has_streamingsidecar() const; - public: - void clear_streamingsidecar(); - const std::string& streamingsidecar() const; - template - void set_streamingsidecar(ArgT0&& arg0, ArgT... args); - std::string* mutable_streamingsidecar(); - PROTOBUF_NODISCARD std::string* release_streamingsidecar(); - void set_allocated_streamingsidecar(std::string* streamingsidecar); - private: - const std::string& _internal_streamingsidecar() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_streamingsidecar(const std::string& value); - std::string* _internal_mutable_streamingsidecar(); - public: - - // optional string thumbnailDirectPath = 21; - bool has_thumbnaildirectpath() const; - private: - bool _internal_has_thumbnaildirectpath() const; - public: - void clear_thumbnaildirectpath(); - const std::string& thumbnaildirectpath() const; - template - void set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args); - std::string* mutable_thumbnaildirectpath(); - PROTOBUF_NODISCARD std::string* release_thumbnaildirectpath(); - void set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath); - private: - const std::string& _internal_thumbnaildirectpath() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnaildirectpath(const std::string& value); - std::string* _internal_mutable_thumbnaildirectpath(); - public: - - // optional bytes thumbnailSha256 = 22; - bool has_thumbnailsha256() const; - private: - bool _internal_has_thumbnailsha256() const; - public: - void clear_thumbnailsha256(); - const std::string& thumbnailsha256() const; - template - void set_thumbnailsha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_thumbnailsha256(); - PROTOBUF_NODISCARD std::string* release_thumbnailsha256(); - void set_allocated_thumbnailsha256(std::string* thumbnailsha256); - private: - const std::string& _internal_thumbnailsha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailsha256(const std::string& value); - std::string* _internal_mutable_thumbnailsha256(); - public: - - // optional bytes thumbnailEncSha256 = 23; - bool has_thumbnailencsha256() const; - private: - bool _internal_has_thumbnailencsha256() const; - public: - void clear_thumbnailencsha256(); - const std::string& thumbnailencsha256() const; - template - void set_thumbnailencsha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_thumbnailencsha256(); - PROTOBUF_NODISCARD std::string* release_thumbnailencsha256(); - void set_allocated_thumbnailencsha256(std::string* thumbnailencsha256); - private: - const std::string& _internal_thumbnailencsha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailencsha256(const std::string& value); - std::string* _internal_mutable_thumbnailencsha256(); - public: - - // optional string staticUrl = 24; - bool has_staticurl() const; - private: - bool _internal_has_staticurl() const; - public: - void clear_staticurl(); - const std::string& staticurl() const; - template - void set_staticurl(ArgT0&& arg0, ArgT... args); - std::string* mutable_staticurl(); - PROTOBUF_NODISCARD std::string* release_staticurl(); - void set_allocated_staticurl(std::string* staticurl); - private: - const std::string& _internal_staticurl() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_staticurl(const std::string& value); - std::string* _internal_mutable_staticurl(); - public: - - // optional .proto.ContextInfo contextInfo = 17; - bool has_contextinfo() const; - private: - bool _internal_has_contextinfo() const; - public: - void clear_contextinfo(); - const ::proto::ContextInfo& contextinfo() const; - PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo(); - ::proto::ContextInfo* mutable_contextinfo(); - void set_allocated_contextinfo(::proto::ContextInfo* contextinfo); - private: - const ::proto::ContextInfo& _internal_contextinfo() const; - ::proto::ContextInfo* _internal_mutable_contextinfo(); - public: - void unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo); - ::proto::ContextInfo* unsafe_arena_release_contextinfo(); - - // optional uint64 fileLength = 4; - bool has_filelength() const; - private: - bool _internal_has_filelength() const; - public: - void clear_filelength(); - uint64_t filelength() const; - void set_filelength(uint64_t value); - private: - uint64_t _internal_filelength() const; - void _internal_set_filelength(uint64_t value); - public: - - // optional uint32 seconds = 5; - bool has_seconds() const; - private: - bool _internal_has_seconds() const; - public: - void clear_seconds(); - uint32_t seconds() const; - void set_seconds(uint32_t value); - private: - uint32_t _internal_seconds() const; - void _internal_set_seconds(uint32_t value); - public: - - // optional uint32 height = 9; - bool has_height() const; - private: - bool _internal_has_height() const; - public: - void clear_height(); - uint32_t height() const; - void set_height(uint32_t value); - private: - uint32_t _internal_height() const; - void _internal_set_height(uint32_t value); - public: - - // optional uint32 width = 10; - bool has_width() const; - private: - bool _internal_has_width() const; - public: - void clear_width(); - uint32_t width() const; - void set_width(uint32_t value); - private: - uint32_t _internal_width() const; - void _internal_set_width(uint32_t value); - public: - - // optional bool gifPlayback = 8; - bool has_gifplayback() const; - private: - bool _internal_has_gifplayback() const; - public: - void clear_gifplayback(); - bool gifplayback() const; - void set_gifplayback(bool value); - private: - bool _internal_gifplayback() const; - void _internal_set_gifplayback(bool value); - public: - - // optional bool viewOnce = 20; - bool has_viewonce() const; - private: - bool _internal_has_viewonce() const; - public: - void clear_viewonce(); - bool viewonce() const; - void set_viewonce(bool value); - private: - bool _internal_viewonce() const; - void _internal_set_viewonce(bool value); - public: - - // optional int64 mediaKeyTimestamp = 14; - bool has_mediakeytimestamp() const; - private: - bool _internal_has_mediakeytimestamp() const; - public: - void clear_mediakeytimestamp(); - int64_t mediakeytimestamp() const; - void set_mediakeytimestamp(int64_t value); - private: - int64_t _internal_mediakeytimestamp() const; - void _internal_set_mediakeytimestamp(int64_t value); - public: - - // optional .proto.Message.VideoMessage.Attribution gifAttribution = 19; - bool has_gifattribution() const; - private: - bool _internal_has_gifattribution() const; - public: - void clear_gifattribution(); - ::proto::Message_VideoMessage_Attribution gifattribution() const; - void set_gifattribution(::proto::Message_VideoMessage_Attribution value); - private: - ::proto::Message_VideoMessage_Attribution _internal_gifattribution() const; - void _internal_set_gifattribution(::proto::Message_VideoMessage_Attribution value); - public: - - // @@protoc_insertion_point(class_scope:proto.Message.VideoMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation > interactiveannotations_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mimetype_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr caption_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr streamingsidecar_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnaildirectpath_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailsha256_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailencsha256_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr staticurl_; - ::proto::ContextInfo* contextinfo_; - uint64_t filelength_; - uint32_t seconds_; - uint32_t height_; - uint32_t width_; - bool gifplayback_; - bool viewonce_; - int64_t mediakeytimestamp_; - int gifattribution_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Message final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message) */ { - public: - inline Message() : Message(nullptr) {} - ~Message() override; - explicit PROTOBUF_CONSTEXPR Message(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Message(const Message& from); - Message(Message&& from) noexcept - : Message() { - *this = ::std::move(from); - } - - inline Message& operator=(const Message& from) { - CopyFrom(from); - return *this; - } - inline Message& operator=(Message&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Message& default_instance() { - return *internal_default_instance(); - } - static inline const Message* internal_default_instance() { - return reinterpret_cast( - &_Message_default_instance_); - } - static constexpr int kIndexInFileMessages = - 137; - - friend void swap(Message& a, Message& b) { - a.Swap(&b); - } - inline void Swap(Message* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Message& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Message& from) { - Message::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Message* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Message"; - } - protected: - explicit Message(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Message_AppStateFatalExceptionNotification AppStateFatalExceptionNotification; - typedef Message_AppStateSyncKeyData AppStateSyncKeyData; - typedef Message_AppStateSyncKeyFingerprint AppStateSyncKeyFingerprint; - typedef Message_AppStateSyncKeyId AppStateSyncKeyId; - typedef Message_AppStateSyncKeyRequest AppStateSyncKeyRequest; - typedef Message_AppStateSyncKeyShare AppStateSyncKeyShare; - typedef Message_AppStateSyncKey AppStateSyncKey; - typedef Message_AudioMessage AudioMessage; - typedef Message_ButtonsMessage ButtonsMessage; - typedef Message_ButtonsResponseMessage ButtonsResponseMessage; - typedef Message_Call Call; - typedef Message_CancelPaymentRequestMessage CancelPaymentRequestMessage; - typedef Message_Chat Chat; - typedef Message_ContactMessage ContactMessage; - typedef Message_ContactsArrayMessage ContactsArrayMessage; - typedef Message_DeclinePaymentRequestMessage DeclinePaymentRequestMessage; - typedef Message_DeviceSentMessage DeviceSentMessage; - typedef Message_DocumentMessage DocumentMessage; - typedef Message_ExtendedTextMessage ExtendedTextMessage; - typedef Message_FutureProofMessage FutureProofMessage; - typedef Message_GroupInviteMessage GroupInviteMessage; - typedef Message_HighlyStructuredMessage HighlyStructuredMessage; - typedef Message_HistorySyncNotification HistorySyncNotification; - typedef Message_ImageMessage ImageMessage; - typedef Message_InitialSecurityNotificationSettingSync InitialSecurityNotificationSettingSync; - typedef Message_InteractiveMessage InteractiveMessage; - typedef Message_InteractiveResponseMessage InteractiveResponseMessage; - typedef Message_InvoiceMessage InvoiceMessage; - typedef Message_KeepInChatMessage KeepInChatMessage; - typedef Message_ListMessage ListMessage; - typedef Message_ListResponseMessage ListResponseMessage; - typedef Message_LiveLocationMessage LiveLocationMessage; - typedef Message_LocationMessage LocationMessage; - typedef Message_OrderMessage OrderMessage; - typedef Message_PaymentInviteMessage PaymentInviteMessage; - typedef Message_PollCreationMessage PollCreationMessage; - typedef Message_PollEncValue PollEncValue; - typedef Message_PollUpdateMessageMetadata PollUpdateMessageMetadata; - typedef Message_PollUpdateMessage PollUpdateMessage; - typedef Message_PollVoteMessage PollVoteMessage; - typedef Message_ProductMessage ProductMessage; - typedef Message_ProtocolMessage ProtocolMessage; - typedef Message_ReactionMessage ReactionMessage; - typedef Message_RequestMediaUploadMessage RequestMediaUploadMessage; - typedef Message_RequestMediaUploadResponseMessage RequestMediaUploadResponseMessage; - typedef Message_RequestPaymentMessage RequestPaymentMessage; - typedef Message_RequestPhoneNumberMessage RequestPhoneNumberMessage; - typedef Message_SendPaymentMessage SendPaymentMessage; - typedef Message_SenderKeyDistributionMessage SenderKeyDistributionMessage; - typedef Message_StickerMessage StickerMessage; - typedef Message_StickerSyncRMRMessage StickerSyncRMRMessage; - typedef Message_TemplateButtonReplyMessage TemplateButtonReplyMessage; - typedef Message_TemplateMessage TemplateMessage; - typedef Message_VideoMessage VideoMessage; - - typedef Message_RmrSource RmrSource; - static constexpr RmrSource FAVORITE_STICKER = - Message_RmrSource_FAVORITE_STICKER; - static constexpr RmrSource RECENT_STICKER = - Message_RmrSource_RECENT_STICKER; - static inline bool RmrSource_IsValid(int value) { - return Message_RmrSource_IsValid(value); - } - static constexpr RmrSource RmrSource_MIN = - Message_RmrSource_RmrSource_MIN; - static constexpr RmrSource RmrSource_MAX = - Message_RmrSource_RmrSource_MAX; - static constexpr int RmrSource_ARRAYSIZE = - Message_RmrSource_RmrSource_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - RmrSource_descriptor() { - return Message_RmrSource_descriptor(); - } - template - static inline const std::string& RmrSource_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function RmrSource_Name."); - return Message_RmrSource_Name(enum_t_value); - } - static inline bool RmrSource_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - RmrSource* value) { - return Message_RmrSource_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kConversationFieldNumber = 1, - kSenderKeyDistributionMessageFieldNumber = 2, - kImageMessageFieldNumber = 3, - kContactMessageFieldNumber = 4, - kLocationMessageFieldNumber = 5, - kExtendedTextMessageFieldNumber = 6, - kDocumentMessageFieldNumber = 7, - kAudioMessageFieldNumber = 8, - kVideoMessageFieldNumber = 9, - kCallFieldNumber = 10, - kChatFieldNumber = 11, - kProtocolMessageFieldNumber = 12, - kContactsArrayMessageFieldNumber = 13, - kHighlyStructuredMessageFieldNumber = 14, - kFastRatchetKeySenderKeyDistributionMessageFieldNumber = 15, - kSendPaymentMessageFieldNumber = 16, - kLiveLocationMessageFieldNumber = 18, - kRequestPaymentMessageFieldNumber = 22, - kDeclinePaymentRequestMessageFieldNumber = 23, - kCancelPaymentRequestMessageFieldNumber = 24, - kTemplateMessageFieldNumber = 25, - kStickerMessageFieldNumber = 26, - kGroupInviteMessageFieldNumber = 28, - kTemplateButtonReplyMessageFieldNumber = 29, - kProductMessageFieldNumber = 30, - kDeviceSentMessageFieldNumber = 31, - kMessageContextInfoFieldNumber = 35, - kListMessageFieldNumber = 36, - kViewOnceMessageFieldNumber = 37, - kOrderMessageFieldNumber = 38, - kListResponseMessageFieldNumber = 39, - kEphemeralMessageFieldNumber = 40, - kInvoiceMessageFieldNumber = 41, - kButtonsMessageFieldNumber = 42, - kButtonsResponseMessageFieldNumber = 43, - kPaymentInviteMessageFieldNumber = 44, - kInteractiveMessageFieldNumber = 45, - kReactionMessageFieldNumber = 46, - kStickerSyncRmrMessageFieldNumber = 47, - kInteractiveResponseMessageFieldNumber = 48, - kPollCreationMessageFieldNumber = 49, - kPollUpdateMessageFieldNumber = 50, - kKeepInChatMessageFieldNumber = 51, - kDocumentWithCaptionMessageFieldNumber = 53, - kRequestPhoneNumberMessageFieldNumber = 54, - kViewOnceMessageV2FieldNumber = 55, - }; - // optional string conversation = 1; - bool has_conversation() const; - private: - bool _internal_has_conversation() const; - public: - void clear_conversation(); - const std::string& conversation() const; - template - void set_conversation(ArgT0&& arg0, ArgT... args); - std::string* mutable_conversation(); - PROTOBUF_NODISCARD std::string* release_conversation(); - void set_allocated_conversation(std::string* conversation); - private: - const std::string& _internal_conversation() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_conversation(const std::string& value); - std::string* _internal_mutable_conversation(); - public: - - // optional .proto.Message.SenderKeyDistributionMessage senderKeyDistributionMessage = 2; - bool has_senderkeydistributionmessage() const; - private: - bool _internal_has_senderkeydistributionmessage() const; - public: - void clear_senderkeydistributionmessage(); - const ::proto::Message_SenderKeyDistributionMessage& senderkeydistributionmessage() const; - PROTOBUF_NODISCARD ::proto::Message_SenderKeyDistributionMessage* release_senderkeydistributionmessage(); - ::proto::Message_SenderKeyDistributionMessage* mutable_senderkeydistributionmessage(); - void set_allocated_senderkeydistributionmessage(::proto::Message_SenderKeyDistributionMessage* senderkeydistributionmessage); - private: - const ::proto::Message_SenderKeyDistributionMessage& _internal_senderkeydistributionmessage() const; - ::proto::Message_SenderKeyDistributionMessage* _internal_mutable_senderkeydistributionmessage(); - public: - void unsafe_arena_set_allocated_senderkeydistributionmessage( - ::proto::Message_SenderKeyDistributionMessage* senderkeydistributionmessage); - ::proto::Message_SenderKeyDistributionMessage* unsafe_arena_release_senderkeydistributionmessage(); - - // optional .proto.Message.ImageMessage imageMessage = 3; - bool has_imagemessage() const; - private: - bool _internal_has_imagemessage() const; - public: - void clear_imagemessage(); - const ::proto::Message_ImageMessage& imagemessage() const; - PROTOBUF_NODISCARD ::proto::Message_ImageMessage* release_imagemessage(); - ::proto::Message_ImageMessage* mutable_imagemessage(); - void set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage); - private: - const ::proto::Message_ImageMessage& _internal_imagemessage() const; - ::proto::Message_ImageMessage* _internal_mutable_imagemessage(); - public: - void unsafe_arena_set_allocated_imagemessage( - ::proto::Message_ImageMessage* imagemessage); - ::proto::Message_ImageMessage* unsafe_arena_release_imagemessage(); - - // optional .proto.Message.ContactMessage contactMessage = 4; - bool has_contactmessage() const; - private: - bool _internal_has_contactmessage() const; - public: - void clear_contactmessage(); - const ::proto::Message_ContactMessage& contactmessage() const; - PROTOBUF_NODISCARD ::proto::Message_ContactMessage* release_contactmessage(); - ::proto::Message_ContactMessage* mutable_contactmessage(); - void set_allocated_contactmessage(::proto::Message_ContactMessage* contactmessage); - private: - const ::proto::Message_ContactMessage& _internal_contactmessage() const; - ::proto::Message_ContactMessage* _internal_mutable_contactmessage(); - public: - void unsafe_arena_set_allocated_contactmessage( - ::proto::Message_ContactMessage* contactmessage); - ::proto::Message_ContactMessage* unsafe_arena_release_contactmessage(); - - // optional .proto.Message.LocationMessage locationMessage = 5; - bool has_locationmessage() const; - private: - bool _internal_has_locationmessage() const; - public: - void clear_locationmessage(); - const ::proto::Message_LocationMessage& locationmessage() const; - PROTOBUF_NODISCARD ::proto::Message_LocationMessage* release_locationmessage(); - ::proto::Message_LocationMessage* mutable_locationmessage(); - void set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage); - private: - const ::proto::Message_LocationMessage& _internal_locationmessage() const; - ::proto::Message_LocationMessage* _internal_mutable_locationmessage(); - public: - void unsafe_arena_set_allocated_locationmessage( - ::proto::Message_LocationMessage* locationmessage); - ::proto::Message_LocationMessage* unsafe_arena_release_locationmessage(); - - // optional .proto.Message.ExtendedTextMessage extendedTextMessage = 6; - bool has_extendedtextmessage() const; - private: - bool _internal_has_extendedtextmessage() const; - public: - void clear_extendedtextmessage(); - const ::proto::Message_ExtendedTextMessage& extendedtextmessage() const; - PROTOBUF_NODISCARD ::proto::Message_ExtendedTextMessage* release_extendedtextmessage(); - ::proto::Message_ExtendedTextMessage* mutable_extendedtextmessage(); - void set_allocated_extendedtextmessage(::proto::Message_ExtendedTextMessage* extendedtextmessage); - private: - const ::proto::Message_ExtendedTextMessage& _internal_extendedtextmessage() const; - ::proto::Message_ExtendedTextMessage* _internal_mutable_extendedtextmessage(); - public: - void unsafe_arena_set_allocated_extendedtextmessage( - ::proto::Message_ExtendedTextMessage* extendedtextmessage); - ::proto::Message_ExtendedTextMessage* unsafe_arena_release_extendedtextmessage(); - - // optional .proto.Message.DocumentMessage documentMessage = 7; - bool has_documentmessage() const; - private: - bool _internal_has_documentmessage() const; - public: - void clear_documentmessage(); - const ::proto::Message_DocumentMessage& documentmessage() const; - PROTOBUF_NODISCARD ::proto::Message_DocumentMessage* release_documentmessage(); - ::proto::Message_DocumentMessage* mutable_documentmessage(); - void set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage); - private: - const ::proto::Message_DocumentMessage& _internal_documentmessage() const; - ::proto::Message_DocumentMessage* _internal_mutable_documentmessage(); - public: - void unsafe_arena_set_allocated_documentmessage( - ::proto::Message_DocumentMessage* documentmessage); - ::proto::Message_DocumentMessage* unsafe_arena_release_documentmessage(); - - // optional .proto.Message.AudioMessage audioMessage = 8; - bool has_audiomessage() const; - private: - bool _internal_has_audiomessage() const; - public: - void clear_audiomessage(); - const ::proto::Message_AudioMessage& audiomessage() const; - PROTOBUF_NODISCARD ::proto::Message_AudioMessage* release_audiomessage(); - ::proto::Message_AudioMessage* mutable_audiomessage(); - void set_allocated_audiomessage(::proto::Message_AudioMessage* audiomessage); - private: - const ::proto::Message_AudioMessage& _internal_audiomessage() const; - ::proto::Message_AudioMessage* _internal_mutable_audiomessage(); - public: - void unsafe_arena_set_allocated_audiomessage( - ::proto::Message_AudioMessage* audiomessage); - ::proto::Message_AudioMessage* unsafe_arena_release_audiomessage(); - - // optional .proto.Message.VideoMessage videoMessage = 9; - bool has_videomessage() const; - private: - bool _internal_has_videomessage() const; - public: - void clear_videomessage(); - const ::proto::Message_VideoMessage& videomessage() const; - PROTOBUF_NODISCARD ::proto::Message_VideoMessage* release_videomessage(); - ::proto::Message_VideoMessage* mutable_videomessage(); - void set_allocated_videomessage(::proto::Message_VideoMessage* videomessage); - private: - const ::proto::Message_VideoMessage& _internal_videomessage() const; - ::proto::Message_VideoMessage* _internal_mutable_videomessage(); - public: - void unsafe_arena_set_allocated_videomessage( - ::proto::Message_VideoMessage* videomessage); - ::proto::Message_VideoMessage* unsafe_arena_release_videomessage(); - - // optional .proto.Message.Call call = 10; - bool has_call() const; - private: - bool _internal_has_call() const; - public: - void clear_call(); - const ::proto::Message_Call& call() const; - PROTOBUF_NODISCARD ::proto::Message_Call* release_call(); - ::proto::Message_Call* mutable_call(); - void set_allocated_call(::proto::Message_Call* call); - private: - const ::proto::Message_Call& _internal_call() const; - ::proto::Message_Call* _internal_mutable_call(); - public: - void unsafe_arena_set_allocated_call( - ::proto::Message_Call* call); - ::proto::Message_Call* unsafe_arena_release_call(); - - // optional .proto.Message.Chat chat = 11; - bool has_chat() const; - private: - bool _internal_has_chat() const; - public: - void clear_chat(); - const ::proto::Message_Chat& chat() const; - PROTOBUF_NODISCARD ::proto::Message_Chat* release_chat(); - ::proto::Message_Chat* mutable_chat(); - void set_allocated_chat(::proto::Message_Chat* chat); - private: - const ::proto::Message_Chat& _internal_chat() const; - ::proto::Message_Chat* _internal_mutable_chat(); - public: - void unsafe_arena_set_allocated_chat( - ::proto::Message_Chat* chat); - ::proto::Message_Chat* unsafe_arena_release_chat(); - - // optional .proto.Message.ProtocolMessage protocolMessage = 12; - bool has_protocolmessage() const; - private: - bool _internal_has_protocolmessage() const; - public: - void clear_protocolmessage(); - const ::proto::Message_ProtocolMessage& protocolmessage() const; - PROTOBUF_NODISCARD ::proto::Message_ProtocolMessage* release_protocolmessage(); - ::proto::Message_ProtocolMessage* mutable_protocolmessage(); - void set_allocated_protocolmessage(::proto::Message_ProtocolMessage* protocolmessage); - private: - const ::proto::Message_ProtocolMessage& _internal_protocolmessage() const; - ::proto::Message_ProtocolMessage* _internal_mutable_protocolmessage(); - public: - void unsafe_arena_set_allocated_protocolmessage( - ::proto::Message_ProtocolMessage* protocolmessage); - ::proto::Message_ProtocolMessage* unsafe_arena_release_protocolmessage(); - - // optional .proto.Message.ContactsArrayMessage contactsArrayMessage = 13; - bool has_contactsarraymessage() const; - private: - bool _internal_has_contactsarraymessage() const; - public: - void clear_contactsarraymessage(); - const ::proto::Message_ContactsArrayMessage& contactsarraymessage() const; - PROTOBUF_NODISCARD ::proto::Message_ContactsArrayMessage* release_contactsarraymessage(); - ::proto::Message_ContactsArrayMessage* mutable_contactsarraymessage(); - void set_allocated_contactsarraymessage(::proto::Message_ContactsArrayMessage* contactsarraymessage); - private: - const ::proto::Message_ContactsArrayMessage& _internal_contactsarraymessage() const; - ::proto::Message_ContactsArrayMessage* _internal_mutable_contactsarraymessage(); - public: - void unsafe_arena_set_allocated_contactsarraymessage( - ::proto::Message_ContactsArrayMessage* contactsarraymessage); - ::proto::Message_ContactsArrayMessage* unsafe_arena_release_contactsarraymessage(); - - // optional .proto.Message.HighlyStructuredMessage highlyStructuredMessage = 14; - bool has_highlystructuredmessage() const; - private: - bool _internal_has_highlystructuredmessage() const; - public: - void clear_highlystructuredmessage(); - const ::proto::Message_HighlyStructuredMessage& highlystructuredmessage() const; - PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_highlystructuredmessage(); - ::proto::Message_HighlyStructuredMessage* mutable_highlystructuredmessage(); - void set_allocated_highlystructuredmessage(::proto::Message_HighlyStructuredMessage* highlystructuredmessage); - private: - const ::proto::Message_HighlyStructuredMessage& _internal_highlystructuredmessage() const; - ::proto::Message_HighlyStructuredMessage* _internal_mutable_highlystructuredmessage(); - public: - void unsafe_arena_set_allocated_highlystructuredmessage( - ::proto::Message_HighlyStructuredMessage* highlystructuredmessage); - ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_highlystructuredmessage(); - - // optional .proto.Message.SenderKeyDistributionMessage fastRatchetKeySenderKeyDistributionMessage = 15; - bool has_fastratchetkeysenderkeydistributionmessage() const; - private: - bool _internal_has_fastratchetkeysenderkeydistributionmessage() const; - public: - void clear_fastratchetkeysenderkeydistributionmessage(); - const ::proto::Message_SenderKeyDistributionMessage& fastratchetkeysenderkeydistributionmessage() const; - PROTOBUF_NODISCARD ::proto::Message_SenderKeyDistributionMessage* release_fastratchetkeysenderkeydistributionmessage(); - ::proto::Message_SenderKeyDistributionMessage* mutable_fastratchetkeysenderkeydistributionmessage(); - void set_allocated_fastratchetkeysenderkeydistributionmessage(::proto::Message_SenderKeyDistributionMessage* fastratchetkeysenderkeydistributionmessage); - private: - const ::proto::Message_SenderKeyDistributionMessage& _internal_fastratchetkeysenderkeydistributionmessage() const; - ::proto::Message_SenderKeyDistributionMessage* _internal_mutable_fastratchetkeysenderkeydistributionmessage(); - public: - void unsafe_arena_set_allocated_fastratchetkeysenderkeydistributionmessage( - ::proto::Message_SenderKeyDistributionMessage* fastratchetkeysenderkeydistributionmessage); - ::proto::Message_SenderKeyDistributionMessage* unsafe_arena_release_fastratchetkeysenderkeydistributionmessage(); - - // optional .proto.Message.SendPaymentMessage sendPaymentMessage = 16; - bool has_sendpaymentmessage() const; - private: - bool _internal_has_sendpaymentmessage() const; - public: - void clear_sendpaymentmessage(); - const ::proto::Message_SendPaymentMessage& sendpaymentmessage() const; - PROTOBUF_NODISCARD ::proto::Message_SendPaymentMessage* release_sendpaymentmessage(); - ::proto::Message_SendPaymentMessage* mutable_sendpaymentmessage(); - void set_allocated_sendpaymentmessage(::proto::Message_SendPaymentMessage* sendpaymentmessage); - private: - const ::proto::Message_SendPaymentMessage& _internal_sendpaymentmessage() const; - ::proto::Message_SendPaymentMessage* _internal_mutable_sendpaymentmessage(); - public: - void unsafe_arena_set_allocated_sendpaymentmessage( - ::proto::Message_SendPaymentMessage* sendpaymentmessage); - ::proto::Message_SendPaymentMessage* unsafe_arena_release_sendpaymentmessage(); - - // optional .proto.Message.LiveLocationMessage liveLocationMessage = 18; - bool has_livelocationmessage() const; - private: - bool _internal_has_livelocationmessage() const; - public: - void clear_livelocationmessage(); - const ::proto::Message_LiveLocationMessage& livelocationmessage() const; - PROTOBUF_NODISCARD ::proto::Message_LiveLocationMessage* release_livelocationmessage(); - ::proto::Message_LiveLocationMessage* mutable_livelocationmessage(); - void set_allocated_livelocationmessage(::proto::Message_LiveLocationMessage* livelocationmessage); - private: - const ::proto::Message_LiveLocationMessage& _internal_livelocationmessage() const; - ::proto::Message_LiveLocationMessage* _internal_mutable_livelocationmessage(); - public: - void unsafe_arena_set_allocated_livelocationmessage( - ::proto::Message_LiveLocationMessage* livelocationmessage); - ::proto::Message_LiveLocationMessage* unsafe_arena_release_livelocationmessage(); - - // optional .proto.Message.RequestPaymentMessage requestPaymentMessage = 22; - bool has_requestpaymentmessage() const; - private: - bool _internal_has_requestpaymentmessage() const; - public: - void clear_requestpaymentmessage(); - const ::proto::Message_RequestPaymentMessage& requestpaymentmessage() const; - PROTOBUF_NODISCARD ::proto::Message_RequestPaymentMessage* release_requestpaymentmessage(); - ::proto::Message_RequestPaymentMessage* mutable_requestpaymentmessage(); - void set_allocated_requestpaymentmessage(::proto::Message_RequestPaymentMessage* requestpaymentmessage); - private: - const ::proto::Message_RequestPaymentMessage& _internal_requestpaymentmessage() const; - ::proto::Message_RequestPaymentMessage* _internal_mutable_requestpaymentmessage(); - public: - void unsafe_arena_set_allocated_requestpaymentmessage( - ::proto::Message_RequestPaymentMessage* requestpaymentmessage); - ::proto::Message_RequestPaymentMessage* unsafe_arena_release_requestpaymentmessage(); - - // optional .proto.Message.DeclinePaymentRequestMessage declinePaymentRequestMessage = 23; - bool has_declinepaymentrequestmessage() const; - private: - bool _internal_has_declinepaymentrequestmessage() const; - public: - void clear_declinepaymentrequestmessage(); - const ::proto::Message_DeclinePaymentRequestMessage& declinepaymentrequestmessage() const; - PROTOBUF_NODISCARD ::proto::Message_DeclinePaymentRequestMessage* release_declinepaymentrequestmessage(); - ::proto::Message_DeclinePaymentRequestMessage* mutable_declinepaymentrequestmessage(); - void set_allocated_declinepaymentrequestmessage(::proto::Message_DeclinePaymentRequestMessage* declinepaymentrequestmessage); - private: - const ::proto::Message_DeclinePaymentRequestMessage& _internal_declinepaymentrequestmessage() const; - ::proto::Message_DeclinePaymentRequestMessage* _internal_mutable_declinepaymentrequestmessage(); - public: - void unsafe_arena_set_allocated_declinepaymentrequestmessage( - ::proto::Message_DeclinePaymentRequestMessage* declinepaymentrequestmessage); - ::proto::Message_DeclinePaymentRequestMessage* unsafe_arena_release_declinepaymentrequestmessage(); - - // optional .proto.Message.CancelPaymentRequestMessage cancelPaymentRequestMessage = 24; - bool has_cancelpaymentrequestmessage() const; - private: - bool _internal_has_cancelpaymentrequestmessage() const; - public: - void clear_cancelpaymentrequestmessage(); - const ::proto::Message_CancelPaymentRequestMessage& cancelpaymentrequestmessage() const; - PROTOBUF_NODISCARD ::proto::Message_CancelPaymentRequestMessage* release_cancelpaymentrequestmessage(); - ::proto::Message_CancelPaymentRequestMessage* mutable_cancelpaymentrequestmessage(); - void set_allocated_cancelpaymentrequestmessage(::proto::Message_CancelPaymentRequestMessage* cancelpaymentrequestmessage); - private: - const ::proto::Message_CancelPaymentRequestMessage& _internal_cancelpaymentrequestmessage() const; - ::proto::Message_CancelPaymentRequestMessage* _internal_mutable_cancelpaymentrequestmessage(); - public: - void unsafe_arena_set_allocated_cancelpaymentrequestmessage( - ::proto::Message_CancelPaymentRequestMessage* cancelpaymentrequestmessage); - ::proto::Message_CancelPaymentRequestMessage* unsafe_arena_release_cancelpaymentrequestmessage(); - - // optional .proto.Message.TemplateMessage templateMessage = 25; - bool has_templatemessage() const; - private: - bool _internal_has_templatemessage() const; - public: - void clear_templatemessage(); - const ::proto::Message_TemplateMessage& templatemessage() const; - PROTOBUF_NODISCARD ::proto::Message_TemplateMessage* release_templatemessage(); - ::proto::Message_TemplateMessage* mutable_templatemessage(); - void set_allocated_templatemessage(::proto::Message_TemplateMessage* templatemessage); - private: - const ::proto::Message_TemplateMessage& _internal_templatemessage() const; - ::proto::Message_TemplateMessage* _internal_mutable_templatemessage(); - public: - void unsafe_arena_set_allocated_templatemessage( - ::proto::Message_TemplateMessage* templatemessage); - ::proto::Message_TemplateMessage* unsafe_arena_release_templatemessage(); - - // optional .proto.Message.StickerMessage stickerMessage = 26; - bool has_stickermessage() const; - private: - bool _internal_has_stickermessage() const; - public: - void clear_stickermessage(); - const ::proto::Message_StickerMessage& stickermessage() const; - PROTOBUF_NODISCARD ::proto::Message_StickerMessage* release_stickermessage(); - ::proto::Message_StickerMessage* mutable_stickermessage(); - void set_allocated_stickermessage(::proto::Message_StickerMessage* stickermessage); - private: - const ::proto::Message_StickerMessage& _internal_stickermessage() const; - ::proto::Message_StickerMessage* _internal_mutable_stickermessage(); - public: - void unsafe_arena_set_allocated_stickermessage( - ::proto::Message_StickerMessage* stickermessage); - ::proto::Message_StickerMessage* unsafe_arena_release_stickermessage(); - - // optional .proto.Message.GroupInviteMessage groupInviteMessage = 28; - bool has_groupinvitemessage() const; - private: - bool _internal_has_groupinvitemessage() const; - public: - void clear_groupinvitemessage(); - const ::proto::Message_GroupInviteMessage& groupinvitemessage() const; - PROTOBUF_NODISCARD ::proto::Message_GroupInviteMessage* release_groupinvitemessage(); - ::proto::Message_GroupInviteMessage* mutable_groupinvitemessage(); - void set_allocated_groupinvitemessage(::proto::Message_GroupInviteMessage* groupinvitemessage); - private: - const ::proto::Message_GroupInviteMessage& _internal_groupinvitemessage() const; - ::proto::Message_GroupInviteMessage* _internal_mutable_groupinvitemessage(); - public: - void unsafe_arena_set_allocated_groupinvitemessage( - ::proto::Message_GroupInviteMessage* groupinvitemessage); - ::proto::Message_GroupInviteMessage* unsafe_arena_release_groupinvitemessage(); - - // optional .proto.Message.TemplateButtonReplyMessage templateButtonReplyMessage = 29; - bool has_templatebuttonreplymessage() const; - private: - bool _internal_has_templatebuttonreplymessage() const; - public: - void clear_templatebuttonreplymessage(); - const ::proto::Message_TemplateButtonReplyMessage& templatebuttonreplymessage() const; - PROTOBUF_NODISCARD ::proto::Message_TemplateButtonReplyMessage* release_templatebuttonreplymessage(); - ::proto::Message_TemplateButtonReplyMessage* mutable_templatebuttonreplymessage(); - void set_allocated_templatebuttonreplymessage(::proto::Message_TemplateButtonReplyMessage* templatebuttonreplymessage); - private: - const ::proto::Message_TemplateButtonReplyMessage& _internal_templatebuttonreplymessage() const; - ::proto::Message_TemplateButtonReplyMessage* _internal_mutable_templatebuttonreplymessage(); - public: - void unsafe_arena_set_allocated_templatebuttonreplymessage( - ::proto::Message_TemplateButtonReplyMessage* templatebuttonreplymessage); - ::proto::Message_TemplateButtonReplyMessage* unsafe_arena_release_templatebuttonreplymessage(); - - // optional .proto.Message.ProductMessage productMessage = 30; - bool has_productmessage() const; - private: - bool _internal_has_productmessage() const; - public: - void clear_productmessage(); - const ::proto::Message_ProductMessage& productmessage() const; - PROTOBUF_NODISCARD ::proto::Message_ProductMessage* release_productmessage(); - ::proto::Message_ProductMessage* mutable_productmessage(); - void set_allocated_productmessage(::proto::Message_ProductMessage* productmessage); - private: - const ::proto::Message_ProductMessage& _internal_productmessage() const; - ::proto::Message_ProductMessage* _internal_mutable_productmessage(); - public: - void unsafe_arena_set_allocated_productmessage( - ::proto::Message_ProductMessage* productmessage); - ::proto::Message_ProductMessage* unsafe_arena_release_productmessage(); - - // optional .proto.Message.DeviceSentMessage deviceSentMessage = 31; - bool has_devicesentmessage() const; - private: - bool _internal_has_devicesentmessage() const; - public: - void clear_devicesentmessage(); - const ::proto::Message_DeviceSentMessage& devicesentmessage() const; - PROTOBUF_NODISCARD ::proto::Message_DeviceSentMessage* release_devicesentmessage(); - ::proto::Message_DeviceSentMessage* mutable_devicesentmessage(); - void set_allocated_devicesentmessage(::proto::Message_DeviceSentMessage* devicesentmessage); - private: - const ::proto::Message_DeviceSentMessage& _internal_devicesentmessage() const; - ::proto::Message_DeviceSentMessage* _internal_mutable_devicesentmessage(); - public: - void unsafe_arena_set_allocated_devicesentmessage( - ::proto::Message_DeviceSentMessage* devicesentmessage); - ::proto::Message_DeviceSentMessage* unsafe_arena_release_devicesentmessage(); - - // optional .proto.MessageContextInfo messageContextInfo = 35; - bool has_messagecontextinfo() const; - private: - bool _internal_has_messagecontextinfo() const; - public: - void clear_messagecontextinfo(); - const ::proto::MessageContextInfo& messagecontextinfo() const; - PROTOBUF_NODISCARD ::proto::MessageContextInfo* release_messagecontextinfo(); - ::proto::MessageContextInfo* mutable_messagecontextinfo(); - void set_allocated_messagecontextinfo(::proto::MessageContextInfo* messagecontextinfo); - private: - const ::proto::MessageContextInfo& _internal_messagecontextinfo() const; - ::proto::MessageContextInfo* _internal_mutable_messagecontextinfo(); - public: - void unsafe_arena_set_allocated_messagecontextinfo( - ::proto::MessageContextInfo* messagecontextinfo); - ::proto::MessageContextInfo* unsafe_arena_release_messagecontextinfo(); - - // optional .proto.Message.ListMessage listMessage = 36; - bool has_listmessage() const; - private: - bool _internal_has_listmessage() const; - public: - void clear_listmessage(); - const ::proto::Message_ListMessage& listmessage() const; - PROTOBUF_NODISCARD ::proto::Message_ListMessage* release_listmessage(); - ::proto::Message_ListMessage* mutable_listmessage(); - void set_allocated_listmessage(::proto::Message_ListMessage* listmessage); - private: - const ::proto::Message_ListMessage& _internal_listmessage() const; - ::proto::Message_ListMessage* _internal_mutable_listmessage(); - public: - void unsafe_arena_set_allocated_listmessage( - ::proto::Message_ListMessage* listmessage); - ::proto::Message_ListMessage* unsafe_arena_release_listmessage(); - - // optional .proto.Message.FutureProofMessage viewOnceMessage = 37; - bool has_viewoncemessage() const; - private: - bool _internal_has_viewoncemessage() const; - public: - void clear_viewoncemessage(); - const ::proto::Message_FutureProofMessage& viewoncemessage() const; - PROTOBUF_NODISCARD ::proto::Message_FutureProofMessage* release_viewoncemessage(); - ::proto::Message_FutureProofMessage* mutable_viewoncemessage(); - void set_allocated_viewoncemessage(::proto::Message_FutureProofMessage* viewoncemessage); - private: - const ::proto::Message_FutureProofMessage& _internal_viewoncemessage() const; - ::proto::Message_FutureProofMessage* _internal_mutable_viewoncemessage(); - public: - void unsafe_arena_set_allocated_viewoncemessage( - ::proto::Message_FutureProofMessage* viewoncemessage); - ::proto::Message_FutureProofMessage* unsafe_arena_release_viewoncemessage(); - - // optional .proto.Message.OrderMessage orderMessage = 38; - bool has_ordermessage() const; - private: - bool _internal_has_ordermessage() const; - public: - void clear_ordermessage(); - const ::proto::Message_OrderMessage& ordermessage() const; - PROTOBUF_NODISCARD ::proto::Message_OrderMessage* release_ordermessage(); - ::proto::Message_OrderMessage* mutable_ordermessage(); - void set_allocated_ordermessage(::proto::Message_OrderMessage* ordermessage); - private: - const ::proto::Message_OrderMessage& _internal_ordermessage() const; - ::proto::Message_OrderMessage* _internal_mutable_ordermessage(); - public: - void unsafe_arena_set_allocated_ordermessage( - ::proto::Message_OrderMessage* ordermessage); - ::proto::Message_OrderMessage* unsafe_arena_release_ordermessage(); - - // optional .proto.Message.ListResponseMessage listResponseMessage = 39; - bool has_listresponsemessage() const; - private: - bool _internal_has_listresponsemessage() const; - public: - void clear_listresponsemessage(); - const ::proto::Message_ListResponseMessage& listresponsemessage() const; - PROTOBUF_NODISCARD ::proto::Message_ListResponseMessage* release_listresponsemessage(); - ::proto::Message_ListResponseMessage* mutable_listresponsemessage(); - void set_allocated_listresponsemessage(::proto::Message_ListResponseMessage* listresponsemessage); - private: - const ::proto::Message_ListResponseMessage& _internal_listresponsemessage() const; - ::proto::Message_ListResponseMessage* _internal_mutable_listresponsemessage(); - public: - void unsafe_arena_set_allocated_listresponsemessage( - ::proto::Message_ListResponseMessage* listresponsemessage); - ::proto::Message_ListResponseMessage* unsafe_arena_release_listresponsemessage(); - - // optional .proto.Message.FutureProofMessage ephemeralMessage = 40; - bool has_ephemeralmessage() const; - private: - bool _internal_has_ephemeralmessage() const; - public: - void clear_ephemeralmessage(); - const ::proto::Message_FutureProofMessage& ephemeralmessage() const; - PROTOBUF_NODISCARD ::proto::Message_FutureProofMessage* release_ephemeralmessage(); - ::proto::Message_FutureProofMessage* mutable_ephemeralmessage(); - void set_allocated_ephemeralmessage(::proto::Message_FutureProofMessage* ephemeralmessage); - private: - const ::proto::Message_FutureProofMessage& _internal_ephemeralmessage() const; - ::proto::Message_FutureProofMessage* _internal_mutable_ephemeralmessage(); - public: - void unsafe_arena_set_allocated_ephemeralmessage( - ::proto::Message_FutureProofMessage* ephemeralmessage); - ::proto::Message_FutureProofMessage* unsafe_arena_release_ephemeralmessage(); - - // optional .proto.Message.InvoiceMessage invoiceMessage = 41; - bool has_invoicemessage() const; - private: - bool _internal_has_invoicemessage() const; - public: - void clear_invoicemessage(); - const ::proto::Message_InvoiceMessage& invoicemessage() const; - PROTOBUF_NODISCARD ::proto::Message_InvoiceMessage* release_invoicemessage(); - ::proto::Message_InvoiceMessage* mutable_invoicemessage(); - void set_allocated_invoicemessage(::proto::Message_InvoiceMessage* invoicemessage); - private: - const ::proto::Message_InvoiceMessage& _internal_invoicemessage() const; - ::proto::Message_InvoiceMessage* _internal_mutable_invoicemessage(); - public: - void unsafe_arena_set_allocated_invoicemessage( - ::proto::Message_InvoiceMessage* invoicemessage); - ::proto::Message_InvoiceMessage* unsafe_arena_release_invoicemessage(); - - // optional .proto.Message.ButtonsMessage buttonsMessage = 42; - bool has_buttonsmessage() const; - private: - bool _internal_has_buttonsmessage() const; - public: - void clear_buttonsmessage(); - const ::proto::Message_ButtonsMessage& buttonsmessage() const; - PROTOBUF_NODISCARD ::proto::Message_ButtonsMessage* release_buttonsmessage(); - ::proto::Message_ButtonsMessage* mutable_buttonsmessage(); - void set_allocated_buttonsmessage(::proto::Message_ButtonsMessage* buttonsmessage); - private: - const ::proto::Message_ButtonsMessage& _internal_buttonsmessage() const; - ::proto::Message_ButtonsMessage* _internal_mutable_buttonsmessage(); - public: - void unsafe_arena_set_allocated_buttonsmessage( - ::proto::Message_ButtonsMessage* buttonsmessage); - ::proto::Message_ButtonsMessage* unsafe_arena_release_buttonsmessage(); - - // optional .proto.Message.ButtonsResponseMessage buttonsResponseMessage = 43; - bool has_buttonsresponsemessage() const; - private: - bool _internal_has_buttonsresponsemessage() const; - public: - void clear_buttonsresponsemessage(); - const ::proto::Message_ButtonsResponseMessage& buttonsresponsemessage() const; - PROTOBUF_NODISCARD ::proto::Message_ButtonsResponseMessage* release_buttonsresponsemessage(); - ::proto::Message_ButtonsResponseMessage* mutable_buttonsresponsemessage(); - void set_allocated_buttonsresponsemessage(::proto::Message_ButtonsResponseMessage* buttonsresponsemessage); - private: - const ::proto::Message_ButtonsResponseMessage& _internal_buttonsresponsemessage() const; - ::proto::Message_ButtonsResponseMessage* _internal_mutable_buttonsresponsemessage(); - public: - void unsafe_arena_set_allocated_buttonsresponsemessage( - ::proto::Message_ButtonsResponseMessage* buttonsresponsemessage); - ::proto::Message_ButtonsResponseMessage* unsafe_arena_release_buttonsresponsemessage(); - - // optional .proto.Message.PaymentInviteMessage paymentInviteMessage = 44; - bool has_paymentinvitemessage() const; - private: - bool _internal_has_paymentinvitemessage() const; - public: - void clear_paymentinvitemessage(); - const ::proto::Message_PaymentInviteMessage& paymentinvitemessage() const; - PROTOBUF_NODISCARD ::proto::Message_PaymentInviteMessage* release_paymentinvitemessage(); - ::proto::Message_PaymentInviteMessage* mutable_paymentinvitemessage(); - void set_allocated_paymentinvitemessage(::proto::Message_PaymentInviteMessage* paymentinvitemessage); - private: - const ::proto::Message_PaymentInviteMessage& _internal_paymentinvitemessage() const; - ::proto::Message_PaymentInviteMessage* _internal_mutable_paymentinvitemessage(); - public: - void unsafe_arena_set_allocated_paymentinvitemessage( - ::proto::Message_PaymentInviteMessage* paymentinvitemessage); - ::proto::Message_PaymentInviteMessage* unsafe_arena_release_paymentinvitemessage(); - - // optional .proto.Message.InteractiveMessage interactiveMessage = 45; - bool has_interactivemessage() const; - private: - bool _internal_has_interactivemessage() const; - public: - void clear_interactivemessage(); - const ::proto::Message_InteractiveMessage& interactivemessage() const; - PROTOBUF_NODISCARD ::proto::Message_InteractiveMessage* release_interactivemessage(); - ::proto::Message_InteractiveMessage* mutable_interactivemessage(); - void set_allocated_interactivemessage(::proto::Message_InteractiveMessage* interactivemessage); - private: - const ::proto::Message_InteractiveMessage& _internal_interactivemessage() const; - ::proto::Message_InteractiveMessage* _internal_mutable_interactivemessage(); - public: - void unsafe_arena_set_allocated_interactivemessage( - ::proto::Message_InteractiveMessage* interactivemessage); - ::proto::Message_InteractiveMessage* unsafe_arena_release_interactivemessage(); - - // optional .proto.Message.ReactionMessage reactionMessage = 46; - bool has_reactionmessage() const; - private: - bool _internal_has_reactionmessage() const; - public: - void clear_reactionmessage(); - const ::proto::Message_ReactionMessage& reactionmessage() const; - PROTOBUF_NODISCARD ::proto::Message_ReactionMessage* release_reactionmessage(); - ::proto::Message_ReactionMessage* mutable_reactionmessage(); - void set_allocated_reactionmessage(::proto::Message_ReactionMessage* reactionmessage); - private: - const ::proto::Message_ReactionMessage& _internal_reactionmessage() const; - ::proto::Message_ReactionMessage* _internal_mutable_reactionmessage(); - public: - void unsafe_arena_set_allocated_reactionmessage( - ::proto::Message_ReactionMessage* reactionmessage); - ::proto::Message_ReactionMessage* unsafe_arena_release_reactionmessage(); - - // optional .proto.Message.StickerSyncRMRMessage stickerSyncRmrMessage = 47; - bool has_stickersyncrmrmessage() const; - private: - bool _internal_has_stickersyncrmrmessage() const; - public: - void clear_stickersyncrmrmessage(); - const ::proto::Message_StickerSyncRMRMessage& stickersyncrmrmessage() const; - PROTOBUF_NODISCARD ::proto::Message_StickerSyncRMRMessage* release_stickersyncrmrmessage(); - ::proto::Message_StickerSyncRMRMessage* mutable_stickersyncrmrmessage(); - void set_allocated_stickersyncrmrmessage(::proto::Message_StickerSyncRMRMessage* stickersyncrmrmessage); - private: - const ::proto::Message_StickerSyncRMRMessage& _internal_stickersyncrmrmessage() const; - ::proto::Message_StickerSyncRMRMessage* _internal_mutable_stickersyncrmrmessage(); - public: - void unsafe_arena_set_allocated_stickersyncrmrmessage( - ::proto::Message_StickerSyncRMRMessage* stickersyncrmrmessage); - ::proto::Message_StickerSyncRMRMessage* unsafe_arena_release_stickersyncrmrmessage(); - - // optional .proto.Message.InteractiveResponseMessage interactiveResponseMessage = 48; - bool has_interactiveresponsemessage() const; - private: - bool _internal_has_interactiveresponsemessage() const; - public: - void clear_interactiveresponsemessage(); - const ::proto::Message_InteractiveResponseMessage& interactiveresponsemessage() const; - PROTOBUF_NODISCARD ::proto::Message_InteractiveResponseMessage* release_interactiveresponsemessage(); - ::proto::Message_InteractiveResponseMessage* mutable_interactiveresponsemessage(); - void set_allocated_interactiveresponsemessage(::proto::Message_InteractiveResponseMessage* interactiveresponsemessage); - private: - const ::proto::Message_InteractiveResponseMessage& _internal_interactiveresponsemessage() const; - ::proto::Message_InteractiveResponseMessage* _internal_mutable_interactiveresponsemessage(); - public: - void unsafe_arena_set_allocated_interactiveresponsemessage( - ::proto::Message_InteractiveResponseMessage* interactiveresponsemessage); - ::proto::Message_InteractiveResponseMessage* unsafe_arena_release_interactiveresponsemessage(); - - // optional .proto.Message.PollCreationMessage pollCreationMessage = 49; - bool has_pollcreationmessage() const; - private: - bool _internal_has_pollcreationmessage() const; - public: - void clear_pollcreationmessage(); - const ::proto::Message_PollCreationMessage& pollcreationmessage() const; - PROTOBUF_NODISCARD ::proto::Message_PollCreationMessage* release_pollcreationmessage(); - ::proto::Message_PollCreationMessage* mutable_pollcreationmessage(); - void set_allocated_pollcreationmessage(::proto::Message_PollCreationMessage* pollcreationmessage); - private: - const ::proto::Message_PollCreationMessage& _internal_pollcreationmessage() const; - ::proto::Message_PollCreationMessage* _internal_mutable_pollcreationmessage(); - public: - void unsafe_arena_set_allocated_pollcreationmessage( - ::proto::Message_PollCreationMessage* pollcreationmessage); - ::proto::Message_PollCreationMessage* unsafe_arena_release_pollcreationmessage(); - - // optional .proto.Message.PollUpdateMessage pollUpdateMessage = 50; - bool has_pollupdatemessage() const; - private: - bool _internal_has_pollupdatemessage() const; - public: - void clear_pollupdatemessage(); - const ::proto::Message_PollUpdateMessage& pollupdatemessage() const; - PROTOBUF_NODISCARD ::proto::Message_PollUpdateMessage* release_pollupdatemessage(); - ::proto::Message_PollUpdateMessage* mutable_pollupdatemessage(); - void set_allocated_pollupdatemessage(::proto::Message_PollUpdateMessage* pollupdatemessage); - private: - const ::proto::Message_PollUpdateMessage& _internal_pollupdatemessage() const; - ::proto::Message_PollUpdateMessage* _internal_mutable_pollupdatemessage(); - public: - void unsafe_arena_set_allocated_pollupdatemessage( - ::proto::Message_PollUpdateMessage* pollupdatemessage); - ::proto::Message_PollUpdateMessage* unsafe_arena_release_pollupdatemessage(); - - // optional .proto.Message.KeepInChatMessage keepInChatMessage = 51; - bool has_keepinchatmessage() const; - private: - bool _internal_has_keepinchatmessage() const; - public: - void clear_keepinchatmessage(); - const ::proto::Message_KeepInChatMessage& keepinchatmessage() const; - PROTOBUF_NODISCARD ::proto::Message_KeepInChatMessage* release_keepinchatmessage(); - ::proto::Message_KeepInChatMessage* mutable_keepinchatmessage(); - void set_allocated_keepinchatmessage(::proto::Message_KeepInChatMessage* keepinchatmessage); - private: - const ::proto::Message_KeepInChatMessage& _internal_keepinchatmessage() const; - ::proto::Message_KeepInChatMessage* _internal_mutable_keepinchatmessage(); - public: - void unsafe_arena_set_allocated_keepinchatmessage( - ::proto::Message_KeepInChatMessage* keepinchatmessage); - ::proto::Message_KeepInChatMessage* unsafe_arena_release_keepinchatmessage(); - - // optional .proto.Message.FutureProofMessage documentWithCaptionMessage = 53; - bool has_documentwithcaptionmessage() const; - private: - bool _internal_has_documentwithcaptionmessage() const; - public: - void clear_documentwithcaptionmessage(); - const ::proto::Message_FutureProofMessage& documentwithcaptionmessage() const; - PROTOBUF_NODISCARD ::proto::Message_FutureProofMessage* release_documentwithcaptionmessage(); - ::proto::Message_FutureProofMessage* mutable_documentwithcaptionmessage(); - void set_allocated_documentwithcaptionmessage(::proto::Message_FutureProofMessage* documentwithcaptionmessage); - private: - const ::proto::Message_FutureProofMessage& _internal_documentwithcaptionmessage() const; - ::proto::Message_FutureProofMessage* _internal_mutable_documentwithcaptionmessage(); - public: - void unsafe_arena_set_allocated_documentwithcaptionmessage( - ::proto::Message_FutureProofMessage* documentwithcaptionmessage); - ::proto::Message_FutureProofMessage* unsafe_arena_release_documentwithcaptionmessage(); - - // optional .proto.Message.RequestPhoneNumberMessage requestPhoneNumberMessage = 54; - bool has_requestphonenumbermessage() const; - private: - bool _internal_has_requestphonenumbermessage() const; - public: - void clear_requestphonenumbermessage(); - const ::proto::Message_RequestPhoneNumberMessage& requestphonenumbermessage() const; - PROTOBUF_NODISCARD ::proto::Message_RequestPhoneNumberMessage* release_requestphonenumbermessage(); - ::proto::Message_RequestPhoneNumberMessage* mutable_requestphonenumbermessage(); - void set_allocated_requestphonenumbermessage(::proto::Message_RequestPhoneNumberMessage* requestphonenumbermessage); - private: - const ::proto::Message_RequestPhoneNumberMessage& _internal_requestphonenumbermessage() const; - ::proto::Message_RequestPhoneNumberMessage* _internal_mutable_requestphonenumbermessage(); - public: - void unsafe_arena_set_allocated_requestphonenumbermessage( - ::proto::Message_RequestPhoneNumberMessage* requestphonenumbermessage); - ::proto::Message_RequestPhoneNumberMessage* unsafe_arena_release_requestphonenumbermessage(); - - // optional .proto.Message.FutureProofMessage viewOnceMessageV2 = 55; - bool has_viewoncemessagev2() const; - private: - bool _internal_has_viewoncemessagev2() const; - public: - void clear_viewoncemessagev2(); - const ::proto::Message_FutureProofMessage& viewoncemessagev2() const; - PROTOBUF_NODISCARD ::proto::Message_FutureProofMessage* release_viewoncemessagev2(); - ::proto::Message_FutureProofMessage* mutable_viewoncemessagev2(); - void set_allocated_viewoncemessagev2(::proto::Message_FutureProofMessage* viewoncemessagev2); - private: - const ::proto::Message_FutureProofMessage& _internal_viewoncemessagev2() const; - ::proto::Message_FutureProofMessage* _internal_mutable_viewoncemessagev2(); - public: - void unsafe_arena_set_allocated_viewoncemessagev2( - ::proto::Message_FutureProofMessage* viewoncemessagev2); - ::proto::Message_FutureProofMessage* unsafe_arena_release_viewoncemessagev2(); - - // @@protoc_insertion_point(class_scope:proto.Message) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<2> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conversation_; - ::proto::Message_SenderKeyDistributionMessage* senderkeydistributionmessage_; - ::proto::Message_ImageMessage* imagemessage_; - ::proto::Message_ContactMessage* contactmessage_; - ::proto::Message_LocationMessage* locationmessage_; - ::proto::Message_ExtendedTextMessage* extendedtextmessage_; - ::proto::Message_DocumentMessage* documentmessage_; - ::proto::Message_AudioMessage* audiomessage_; - ::proto::Message_VideoMessage* videomessage_; - ::proto::Message_Call* call_; - ::proto::Message_Chat* chat_; - ::proto::Message_ProtocolMessage* protocolmessage_; - ::proto::Message_ContactsArrayMessage* contactsarraymessage_; - ::proto::Message_HighlyStructuredMessage* highlystructuredmessage_; - ::proto::Message_SenderKeyDistributionMessage* fastratchetkeysenderkeydistributionmessage_; - ::proto::Message_SendPaymentMessage* sendpaymentmessage_; - ::proto::Message_LiveLocationMessage* livelocationmessage_; - ::proto::Message_RequestPaymentMessage* requestpaymentmessage_; - ::proto::Message_DeclinePaymentRequestMessage* declinepaymentrequestmessage_; - ::proto::Message_CancelPaymentRequestMessage* cancelpaymentrequestmessage_; - ::proto::Message_TemplateMessage* templatemessage_; - ::proto::Message_StickerMessage* stickermessage_; - ::proto::Message_GroupInviteMessage* groupinvitemessage_; - ::proto::Message_TemplateButtonReplyMessage* templatebuttonreplymessage_; - ::proto::Message_ProductMessage* productmessage_; - ::proto::Message_DeviceSentMessage* devicesentmessage_; - ::proto::MessageContextInfo* messagecontextinfo_; - ::proto::Message_ListMessage* listmessage_; - ::proto::Message_FutureProofMessage* viewoncemessage_; - ::proto::Message_OrderMessage* ordermessage_; - ::proto::Message_ListResponseMessage* listresponsemessage_; - ::proto::Message_FutureProofMessage* ephemeralmessage_; - ::proto::Message_InvoiceMessage* invoicemessage_; - ::proto::Message_ButtonsMessage* buttonsmessage_; - ::proto::Message_ButtonsResponseMessage* buttonsresponsemessage_; - ::proto::Message_PaymentInviteMessage* paymentinvitemessage_; - ::proto::Message_InteractiveMessage* interactivemessage_; - ::proto::Message_ReactionMessage* reactionmessage_; - ::proto::Message_StickerSyncRMRMessage* stickersyncrmrmessage_; - ::proto::Message_InteractiveResponseMessage* interactiveresponsemessage_; - ::proto::Message_PollCreationMessage* pollcreationmessage_; - ::proto::Message_PollUpdateMessage* pollupdatemessage_; - ::proto::Message_KeepInChatMessage* keepinchatmessage_; - ::proto::Message_FutureProofMessage* documentwithcaptionmessage_; - ::proto::Message_RequestPhoneNumberMessage* requestphonenumbermessage_; - ::proto::Message_FutureProofMessage* viewoncemessagev2_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class MessageContextInfo final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.MessageContextInfo) */ { - public: - inline MessageContextInfo() : MessageContextInfo(nullptr) {} - ~MessageContextInfo() override; - explicit PROTOBUF_CONSTEXPR MessageContextInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - MessageContextInfo(const MessageContextInfo& from); - MessageContextInfo(MessageContextInfo&& from) noexcept - : MessageContextInfo() { - *this = ::std::move(from); - } - - inline MessageContextInfo& operator=(const MessageContextInfo& from) { - CopyFrom(from); - return *this; - } - inline MessageContextInfo& operator=(MessageContextInfo&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const MessageContextInfo& default_instance() { - return *internal_default_instance(); - } - static inline const MessageContextInfo* internal_default_instance() { - return reinterpret_cast( - &_MessageContextInfo_default_instance_); - } - static constexpr int kIndexInFileMessages = - 138; - - friend void swap(MessageContextInfo& a, MessageContextInfo& b) { - a.Swap(&b); - } - inline void Swap(MessageContextInfo* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(MessageContextInfo* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - MessageContextInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const MessageContextInfo& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const MessageContextInfo& from) { - MessageContextInfo::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(MessageContextInfo* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.MessageContextInfo"; - } - protected: - explicit MessageContextInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kMessageSecretFieldNumber = 3, - kPaddingBytesFieldNumber = 4, - kDeviceListMetadataFieldNumber = 1, - kDeviceListMetadataVersionFieldNumber = 2, - }; - // optional bytes messageSecret = 3; - bool has_messagesecret() const; - private: - bool _internal_has_messagesecret() const; - public: - void clear_messagesecret(); - const std::string& messagesecret() const; - template - void set_messagesecret(ArgT0&& arg0, ArgT... args); - std::string* mutable_messagesecret(); - PROTOBUF_NODISCARD std::string* release_messagesecret(); - void set_allocated_messagesecret(std::string* messagesecret); - private: - const std::string& _internal_messagesecret() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_messagesecret(const std::string& value); - std::string* _internal_mutable_messagesecret(); - public: - - // optional bytes paddingBytes = 4; - bool has_paddingbytes() const; - private: - bool _internal_has_paddingbytes() const; - public: - void clear_paddingbytes(); - const std::string& paddingbytes() const; - template - void set_paddingbytes(ArgT0&& arg0, ArgT... args); - std::string* mutable_paddingbytes(); - PROTOBUF_NODISCARD std::string* release_paddingbytes(); - void set_allocated_paddingbytes(std::string* paddingbytes); - private: - const std::string& _internal_paddingbytes() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_paddingbytes(const std::string& value); - std::string* _internal_mutable_paddingbytes(); - public: - - // optional .proto.DeviceListMetadata deviceListMetadata = 1; - bool has_devicelistmetadata() const; - private: - bool _internal_has_devicelistmetadata() const; - public: - void clear_devicelistmetadata(); - const ::proto::DeviceListMetadata& devicelistmetadata() const; - PROTOBUF_NODISCARD ::proto::DeviceListMetadata* release_devicelistmetadata(); - ::proto::DeviceListMetadata* mutable_devicelistmetadata(); - void set_allocated_devicelistmetadata(::proto::DeviceListMetadata* devicelistmetadata); - private: - const ::proto::DeviceListMetadata& _internal_devicelistmetadata() const; - ::proto::DeviceListMetadata* _internal_mutable_devicelistmetadata(); - public: - void unsafe_arena_set_allocated_devicelistmetadata( - ::proto::DeviceListMetadata* devicelistmetadata); - ::proto::DeviceListMetadata* unsafe_arena_release_devicelistmetadata(); - - // optional int32 deviceListMetadataVersion = 2; - bool has_devicelistmetadataversion() const; - private: - bool _internal_has_devicelistmetadataversion() const; - public: - void clear_devicelistmetadataversion(); - int32_t devicelistmetadataversion() const; - void set_devicelistmetadataversion(int32_t value); - private: - int32_t _internal_devicelistmetadataversion() const; - void _internal_set_devicelistmetadataversion(int32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.MessageContextInfo) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr messagesecret_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr paddingbytes_; - ::proto::DeviceListMetadata* devicelistmetadata_; - int32_t devicelistmetadataversion_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class MessageKey final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.MessageKey) */ { - public: - inline MessageKey() : MessageKey(nullptr) {} - ~MessageKey() override; - explicit PROTOBUF_CONSTEXPR MessageKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - MessageKey(const MessageKey& from); - MessageKey(MessageKey&& from) noexcept - : MessageKey() { - *this = ::std::move(from); - } - - inline MessageKey& operator=(const MessageKey& from) { - CopyFrom(from); - return *this; - } - inline MessageKey& operator=(MessageKey&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const MessageKey& default_instance() { - return *internal_default_instance(); - } - static inline const MessageKey* internal_default_instance() { - return reinterpret_cast( - &_MessageKey_default_instance_); - } - static constexpr int kIndexInFileMessages = - 139; - - friend void swap(MessageKey& a, MessageKey& b) { - a.Swap(&b); - } - inline void Swap(MessageKey* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(MessageKey* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - MessageKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const MessageKey& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const MessageKey& from) { - MessageKey::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(MessageKey* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.MessageKey"; - } - protected: - explicit MessageKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kRemoteJidFieldNumber = 1, - kIdFieldNumber = 3, - kParticipantFieldNumber = 4, - kFromMeFieldNumber = 2, - }; - // optional string remoteJid = 1; - bool has_remotejid() const; - private: - bool _internal_has_remotejid() const; - public: - void clear_remotejid(); - const std::string& remotejid() const; - template - void set_remotejid(ArgT0&& arg0, ArgT... args); - std::string* mutable_remotejid(); - PROTOBUF_NODISCARD std::string* release_remotejid(); - void set_allocated_remotejid(std::string* remotejid); - private: - const std::string& _internal_remotejid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_remotejid(const std::string& value); - std::string* _internal_mutable_remotejid(); - public: - - // optional string id = 3; - bool has_id() const; - private: - bool _internal_has_id() const; - public: - void clear_id(); - const std::string& id() const; - template - void set_id(ArgT0&& arg0, ArgT... args); - std::string* mutable_id(); - PROTOBUF_NODISCARD std::string* release_id(); - void set_allocated_id(std::string* id); - private: - const std::string& _internal_id() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value); - std::string* _internal_mutable_id(); - public: - - // optional string participant = 4; - bool has_participant() const; - private: - bool _internal_has_participant() const; - public: - void clear_participant(); - const std::string& participant() const; - template - void set_participant(ArgT0&& arg0, ArgT... args); - std::string* mutable_participant(); - PROTOBUF_NODISCARD std::string* release_participant(); - void set_allocated_participant(std::string* participant); - private: - const std::string& _internal_participant() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_participant(const std::string& value); - std::string* _internal_mutable_participant(); - public: - - // optional bool fromMe = 2; - bool has_fromme() const; - private: - bool _internal_has_fromme() const; - public: - void clear_fromme(); - bool fromme() const; - void set_fromme(bool value); - private: - bool _internal_fromme() const; - void _internal_set_fromme(bool value); - public: - - // @@protoc_insertion_point(class_scope:proto.MessageKey) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr remotejid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr participant_; - bool fromme_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Money final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Money) */ { - public: - inline Money() : Money(nullptr) {} - ~Money() override; - explicit PROTOBUF_CONSTEXPR Money(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Money(const Money& from); - Money(Money&& from) noexcept - : Money() { - *this = ::std::move(from); - } - - inline Money& operator=(const Money& from) { - CopyFrom(from); - return *this; - } - inline Money& operator=(Money&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Money& default_instance() { - return *internal_default_instance(); - } - static inline const Money* internal_default_instance() { - return reinterpret_cast( - &_Money_default_instance_); - } - static constexpr int kIndexInFileMessages = - 140; - - friend void swap(Money& a, Money& b) { - a.Swap(&b); - } - inline void Swap(Money* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Money* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Money* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Money& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Money& from) { - Money::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Money* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Money"; - } - protected: - explicit Money(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kCurrencyCodeFieldNumber = 3, - kValueFieldNumber = 1, - kOffsetFieldNumber = 2, - }; - // optional string currencyCode = 3; - bool has_currencycode() const; - private: - bool _internal_has_currencycode() const; - public: - void clear_currencycode(); - const std::string& currencycode() const; - template - void set_currencycode(ArgT0&& arg0, ArgT... args); - std::string* mutable_currencycode(); - PROTOBUF_NODISCARD std::string* release_currencycode(); - void set_allocated_currencycode(std::string* currencycode); - private: - const std::string& _internal_currencycode() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_currencycode(const std::string& value); - std::string* _internal_mutable_currencycode(); - public: - - // optional int64 value = 1; - bool has_value() const; - private: - bool _internal_has_value() const; - public: - void clear_value(); - int64_t value() const; - void set_value(int64_t value); - private: - int64_t _internal_value() const; - void _internal_set_value(int64_t value); - public: - - // optional uint32 offset = 2; - bool has_offset() const; - private: - bool _internal_has_offset() const; - public: - void clear_offset(); - uint32_t offset() const; - void set_offset(uint32_t value); - private: - uint32_t _internal_offset() const; - void _internal_set_offset(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.Money) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr currencycode_; - int64_t value_; - uint32_t offset_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class MsgOpaqueData_PollOption final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.MsgOpaqueData.PollOption) */ { - public: - inline MsgOpaqueData_PollOption() : MsgOpaqueData_PollOption(nullptr) {} - ~MsgOpaqueData_PollOption() override; - explicit PROTOBUF_CONSTEXPR MsgOpaqueData_PollOption(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - MsgOpaqueData_PollOption(const MsgOpaqueData_PollOption& from); - MsgOpaqueData_PollOption(MsgOpaqueData_PollOption&& from) noexcept - : MsgOpaqueData_PollOption() { - *this = ::std::move(from); - } - - inline MsgOpaqueData_PollOption& operator=(const MsgOpaqueData_PollOption& from) { - CopyFrom(from); - return *this; - } - inline MsgOpaqueData_PollOption& operator=(MsgOpaqueData_PollOption&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const MsgOpaqueData_PollOption& default_instance() { - return *internal_default_instance(); - } - static inline const MsgOpaqueData_PollOption* internal_default_instance() { - return reinterpret_cast( - &_MsgOpaqueData_PollOption_default_instance_); - } - static constexpr int kIndexInFileMessages = - 141; - - friend void swap(MsgOpaqueData_PollOption& a, MsgOpaqueData_PollOption& b) { - a.Swap(&b); - } - inline void Swap(MsgOpaqueData_PollOption* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(MsgOpaqueData_PollOption* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - MsgOpaqueData_PollOption* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const MsgOpaqueData_PollOption& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const MsgOpaqueData_PollOption& from) { - MsgOpaqueData_PollOption::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(MsgOpaqueData_PollOption* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.MsgOpaqueData.PollOption"; - } - protected: - explicit MsgOpaqueData_PollOption(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kNameFieldNumber = 1, - }; - // optional string name = 1; - bool has_name() const; - private: - bool _internal_has_name() const; - public: - void clear_name(); - const std::string& name() const; - template - void set_name(ArgT0&& arg0, ArgT... args); - std::string* mutable_name(); - PROTOBUF_NODISCARD std::string* release_name(); - void set_allocated_name(std::string* name); - private: - const std::string& _internal_name() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); - std::string* _internal_mutable_name(); - public: - - // @@protoc_insertion_point(class_scope:proto.MsgOpaqueData.PollOption) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class MsgOpaqueData final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.MsgOpaqueData) */ { - public: - inline MsgOpaqueData() : MsgOpaqueData(nullptr) {} - ~MsgOpaqueData() override; - explicit PROTOBUF_CONSTEXPR MsgOpaqueData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - MsgOpaqueData(const MsgOpaqueData& from); - MsgOpaqueData(MsgOpaqueData&& from) noexcept - : MsgOpaqueData() { - *this = ::std::move(from); - } - - inline MsgOpaqueData& operator=(const MsgOpaqueData& from) { - CopyFrom(from); - return *this; - } - inline MsgOpaqueData& operator=(MsgOpaqueData&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const MsgOpaqueData& default_instance() { - return *internal_default_instance(); - } - static inline const MsgOpaqueData* internal_default_instance() { - return reinterpret_cast( - &_MsgOpaqueData_default_instance_); - } - static constexpr int kIndexInFileMessages = - 142; - - friend void swap(MsgOpaqueData& a, MsgOpaqueData& b) { - a.Swap(&b); - } - inline void Swap(MsgOpaqueData* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(MsgOpaqueData* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - MsgOpaqueData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const MsgOpaqueData& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const MsgOpaqueData& from) { - MsgOpaqueData::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(MsgOpaqueData* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.MsgOpaqueData"; - } - protected: - explicit MsgOpaqueData(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef MsgOpaqueData_PollOption PollOption; - - // accessors ------------------------------------------------------- - - enum : int { - kPollOptionsFieldNumber = 18, - kBodyFieldNumber = 1, - kCaptionFieldNumber = 3, - kPaymentNoteMsgBodyFieldNumber = 9, - kCanonicalUrlFieldNumber = 10, - kMatchedTextFieldNumber = 11, - kTitleFieldNumber = 12, - kDescriptionFieldNumber = 13, - kFutureproofBufferFieldNumber = 14, - kClientUrlFieldNumber = 15, - kLocFieldNumber = 16, - kPollNameFieldNumber = 17, - kMessageSecretFieldNumber = 21, - kPollUpdateParentKeyFieldNumber = 23, - kEncPollVoteFieldNumber = 24, - kLngFieldNumber = 5, - kLatFieldNumber = 7, - kIsLiveFieldNumber = 6, - kPaymentAmount1000FieldNumber = 8, - kSenderTimestampMsFieldNumber = 22, - kPollSelectableOptionsCountFieldNumber = 20, - }; - // repeated .proto.MsgOpaqueData.PollOption pollOptions = 18; - int polloptions_size() const; - private: - int _internal_polloptions_size() const; - public: - void clear_polloptions(); - ::proto::MsgOpaqueData_PollOption* mutable_polloptions(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MsgOpaqueData_PollOption >* - mutable_polloptions(); - private: - const ::proto::MsgOpaqueData_PollOption& _internal_polloptions(int index) const; - ::proto::MsgOpaqueData_PollOption* _internal_add_polloptions(); - public: - const ::proto::MsgOpaqueData_PollOption& polloptions(int index) const; - ::proto::MsgOpaqueData_PollOption* add_polloptions(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MsgOpaqueData_PollOption >& - polloptions() const; - - // optional string body = 1; - bool has_body() const; - private: - bool _internal_has_body() const; - public: - void clear_body(); - const std::string& body() const; - template - void set_body(ArgT0&& arg0, ArgT... args); - std::string* mutable_body(); - PROTOBUF_NODISCARD std::string* release_body(); - void set_allocated_body(std::string* body); - private: - const std::string& _internal_body() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_body(const std::string& value); - std::string* _internal_mutable_body(); - public: - - // optional string caption = 3; - bool has_caption() const; - private: - bool _internal_has_caption() const; - public: - void clear_caption(); - const std::string& caption() const; - template - void set_caption(ArgT0&& arg0, ArgT... args); - std::string* mutable_caption(); - PROTOBUF_NODISCARD std::string* release_caption(); - void set_allocated_caption(std::string* caption); - private: - const std::string& _internal_caption() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_caption(const std::string& value); - std::string* _internal_mutable_caption(); - public: - - // optional string paymentNoteMsgBody = 9; - bool has_paymentnotemsgbody() const; - private: - bool _internal_has_paymentnotemsgbody() const; - public: - void clear_paymentnotemsgbody(); - const std::string& paymentnotemsgbody() const; - template - void set_paymentnotemsgbody(ArgT0&& arg0, ArgT... args); - std::string* mutable_paymentnotemsgbody(); - PROTOBUF_NODISCARD std::string* release_paymentnotemsgbody(); - void set_allocated_paymentnotemsgbody(std::string* paymentnotemsgbody); - private: - const std::string& _internal_paymentnotemsgbody() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_paymentnotemsgbody(const std::string& value); - std::string* _internal_mutable_paymentnotemsgbody(); - public: - - // optional string canonicalUrl = 10; - bool has_canonicalurl() const; - private: - bool _internal_has_canonicalurl() const; - public: - void clear_canonicalurl(); - const std::string& canonicalurl() const; - template - void set_canonicalurl(ArgT0&& arg0, ArgT... args); - std::string* mutable_canonicalurl(); - PROTOBUF_NODISCARD std::string* release_canonicalurl(); - void set_allocated_canonicalurl(std::string* canonicalurl); - private: - const std::string& _internal_canonicalurl() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_canonicalurl(const std::string& value); - std::string* _internal_mutable_canonicalurl(); - public: - - // optional string matchedText = 11; - bool has_matchedtext() const; - private: - bool _internal_has_matchedtext() const; - public: - void clear_matchedtext(); - const std::string& matchedtext() const; - template - void set_matchedtext(ArgT0&& arg0, ArgT... args); - std::string* mutable_matchedtext(); - PROTOBUF_NODISCARD std::string* release_matchedtext(); - void set_allocated_matchedtext(std::string* matchedtext); - private: - const std::string& _internal_matchedtext() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_matchedtext(const std::string& value); - std::string* _internal_mutable_matchedtext(); - public: - - // optional string title = 12; - bool has_title() const; - private: - bool _internal_has_title() const; - public: - void clear_title(); - const std::string& title() const; - template - void set_title(ArgT0&& arg0, ArgT... args); - std::string* mutable_title(); - PROTOBUF_NODISCARD std::string* release_title(); - void set_allocated_title(std::string* title); - private: - const std::string& _internal_title() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(const std::string& value); - std::string* _internal_mutable_title(); - public: - - // optional string description = 13; - bool has_description() const; - private: - bool _internal_has_description() const; - public: - void clear_description(); - const std::string& description() const; - template - void set_description(ArgT0&& arg0, ArgT... args); - std::string* mutable_description(); - PROTOBUF_NODISCARD std::string* release_description(); - void set_allocated_description(std::string* description); - private: - const std::string& _internal_description() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value); - std::string* _internal_mutable_description(); - public: - - // optional bytes futureproofBuffer = 14; - bool has_futureproofbuffer() const; - private: - bool _internal_has_futureproofbuffer() const; - public: - void clear_futureproofbuffer(); - const std::string& futureproofbuffer() const; - template - void set_futureproofbuffer(ArgT0&& arg0, ArgT... args); - std::string* mutable_futureproofbuffer(); - PROTOBUF_NODISCARD std::string* release_futureproofbuffer(); - void set_allocated_futureproofbuffer(std::string* futureproofbuffer); - private: - const std::string& _internal_futureproofbuffer() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_futureproofbuffer(const std::string& value); - std::string* _internal_mutable_futureproofbuffer(); - public: - - // optional string clientUrl = 15; - bool has_clienturl() const; - private: - bool _internal_has_clienturl() const; - public: - void clear_clienturl(); - const std::string& clienturl() const; - template - void set_clienturl(ArgT0&& arg0, ArgT... args); - std::string* mutable_clienturl(); - PROTOBUF_NODISCARD std::string* release_clienturl(); - void set_allocated_clienturl(std::string* clienturl); - private: - const std::string& _internal_clienturl() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_clienturl(const std::string& value); - std::string* _internal_mutable_clienturl(); - public: - - // optional string loc = 16; - bool has_loc() const; - private: - bool _internal_has_loc() const; - public: - void clear_loc(); - const std::string& loc() const; - template - void set_loc(ArgT0&& arg0, ArgT... args); - std::string* mutable_loc(); - PROTOBUF_NODISCARD std::string* release_loc(); - void set_allocated_loc(std::string* loc); - private: - const std::string& _internal_loc() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_loc(const std::string& value); - std::string* _internal_mutable_loc(); - public: - - // optional string pollName = 17; - bool has_pollname() const; - private: - bool _internal_has_pollname() const; - public: - void clear_pollname(); - const std::string& pollname() const; - template - void set_pollname(ArgT0&& arg0, ArgT... args); - std::string* mutable_pollname(); - PROTOBUF_NODISCARD std::string* release_pollname(); - void set_allocated_pollname(std::string* pollname); - private: - const std::string& _internal_pollname() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_pollname(const std::string& value); - std::string* _internal_mutable_pollname(); - public: - - // optional bytes messageSecret = 21; - bool has_messagesecret() const; - private: - bool _internal_has_messagesecret() const; - public: - void clear_messagesecret(); - const std::string& messagesecret() const; - template - void set_messagesecret(ArgT0&& arg0, ArgT... args); - std::string* mutable_messagesecret(); - PROTOBUF_NODISCARD std::string* release_messagesecret(); - void set_allocated_messagesecret(std::string* messagesecret); - private: - const std::string& _internal_messagesecret() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_messagesecret(const std::string& value); - std::string* _internal_mutable_messagesecret(); - public: - - // optional string pollUpdateParentKey = 23; - bool has_pollupdateparentkey() const; - private: - bool _internal_has_pollupdateparentkey() const; - public: - void clear_pollupdateparentkey(); - const std::string& pollupdateparentkey() const; - template - void set_pollupdateparentkey(ArgT0&& arg0, ArgT... args); - std::string* mutable_pollupdateparentkey(); - PROTOBUF_NODISCARD std::string* release_pollupdateparentkey(); - void set_allocated_pollupdateparentkey(std::string* pollupdateparentkey); - private: - const std::string& _internal_pollupdateparentkey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_pollupdateparentkey(const std::string& value); - std::string* _internal_mutable_pollupdateparentkey(); - public: - - // optional .proto.PollEncValue encPollVote = 24; - bool has_encpollvote() const; - private: - bool _internal_has_encpollvote() const; - public: - void clear_encpollvote(); - const ::proto::PollEncValue& encpollvote() const; - PROTOBUF_NODISCARD ::proto::PollEncValue* release_encpollvote(); - ::proto::PollEncValue* mutable_encpollvote(); - void set_allocated_encpollvote(::proto::PollEncValue* encpollvote); - private: - const ::proto::PollEncValue& _internal_encpollvote() const; - ::proto::PollEncValue* _internal_mutable_encpollvote(); - public: - void unsafe_arena_set_allocated_encpollvote( - ::proto::PollEncValue* encpollvote); - ::proto::PollEncValue* unsafe_arena_release_encpollvote(); - - // optional double lng = 5; - bool has_lng() const; - private: - bool _internal_has_lng() const; - public: - void clear_lng(); - double lng() const; - void set_lng(double value); - private: - double _internal_lng() const; - void _internal_set_lng(double value); - public: - - // optional double lat = 7; - bool has_lat() const; - private: - bool _internal_has_lat() const; - public: - void clear_lat(); - double lat() const; - void set_lat(double value); - private: - double _internal_lat() const; - void _internal_set_lat(double value); - public: - - // optional bool isLive = 6; - bool has_islive() const; - private: - bool _internal_has_islive() const; - public: - void clear_islive(); - bool islive() const; - void set_islive(bool value); - private: - bool _internal_islive() const; - void _internal_set_islive(bool value); - public: - - // optional int32 paymentAmount1000 = 8; - bool has_paymentamount1000() const; - private: - bool _internal_has_paymentamount1000() const; - public: - void clear_paymentamount1000(); - int32_t paymentamount1000() const; - void set_paymentamount1000(int32_t value); - private: - int32_t _internal_paymentamount1000() const; - void _internal_set_paymentamount1000(int32_t value); - public: - - // optional int64 senderTimestampMs = 22; - bool has_sendertimestampms() const; - private: - bool _internal_has_sendertimestampms() const; - public: - void clear_sendertimestampms(); - int64_t sendertimestampms() const; - void set_sendertimestampms(int64_t value); - private: - int64_t _internal_sendertimestampms() const; - void _internal_set_sendertimestampms(int64_t value); - public: - - // optional uint32 pollSelectableOptionsCount = 20; - bool has_pollselectableoptionscount() const; - private: - bool _internal_has_pollselectableoptionscount() const; - public: - void clear_pollselectableoptionscount(); - uint32_t pollselectableoptionscount() const; - void set_pollselectableoptionscount(uint32_t value); - private: - uint32_t _internal_pollselectableoptionscount() const; - void _internal_set_pollselectableoptionscount(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.MsgOpaqueData) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MsgOpaqueData_PollOption > polloptions_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr body_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr caption_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr paymentnotemsgbody_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr canonicalurl_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr matchedtext_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr futureproofbuffer_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr clienturl_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr loc_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pollname_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr messagesecret_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pollupdateparentkey_; - ::proto::PollEncValue* encpollvote_; - double lng_; - double lat_; - bool islive_; - int32_t paymentamount1000_; - int64_t sendertimestampms_; - uint32_t pollselectableoptionscount_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class MsgRowOpaqueData final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.MsgRowOpaqueData) */ { - public: - inline MsgRowOpaqueData() : MsgRowOpaqueData(nullptr) {} - ~MsgRowOpaqueData() override; - explicit PROTOBUF_CONSTEXPR MsgRowOpaqueData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - MsgRowOpaqueData(const MsgRowOpaqueData& from); - MsgRowOpaqueData(MsgRowOpaqueData&& from) noexcept - : MsgRowOpaqueData() { - *this = ::std::move(from); - } - - inline MsgRowOpaqueData& operator=(const MsgRowOpaqueData& from) { - CopyFrom(from); - return *this; - } - inline MsgRowOpaqueData& operator=(MsgRowOpaqueData&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const MsgRowOpaqueData& default_instance() { - return *internal_default_instance(); - } - static inline const MsgRowOpaqueData* internal_default_instance() { - return reinterpret_cast( - &_MsgRowOpaqueData_default_instance_); - } - static constexpr int kIndexInFileMessages = - 143; - - friend void swap(MsgRowOpaqueData& a, MsgRowOpaqueData& b) { - a.Swap(&b); - } - inline void Swap(MsgRowOpaqueData* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(MsgRowOpaqueData* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - MsgRowOpaqueData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const MsgRowOpaqueData& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const MsgRowOpaqueData& from) { - MsgRowOpaqueData::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(MsgRowOpaqueData* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.MsgRowOpaqueData"; - } - protected: - explicit MsgRowOpaqueData(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kCurrentMsgFieldNumber = 1, - kQuotedMsgFieldNumber = 2, - }; - // optional .proto.MsgOpaqueData currentMsg = 1; - bool has_currentmsg() const; - private: - bool _internal_has_currentmsg() const; - public: - void clear_currentmsg(); - const ::proto::MsgOpaqueData& currentmsg() const; - PROTOBUF_NODISCARD ::proto::MsgOpaqueData* release_currentmsg(); - ::proto::MsgOpaqueData* mutable_currentmsg(); - void set_allocated_currentmsg(::proto::MsgOpaqueData* currentmsg); - private: - const ::proto::MsgOpaqueData& _internal_currentmsg() const; - ::proto::MsgOpaqueData* _internal_mutable_currentmsg(); - public: - void unsafe_arena_set_allocated_currentmsg( - ::proto::MsgOpaqueData* currentmsg); - ::proto::MsgOpaqueData* unsafe_arena_release_currentmsg(); - - // optional .proto.MsgOpaqueData quotedMsg = 2; - bool has_quotedmsg() const; - private: - bool _internal_has_quotedmsg() const; - public: - void clear_quotedmsg(); - const ::proto::MsgOpaqueData& quotedmsg() const; - PROTOBUF_NODISCARD ::proto::MsgOpaqueData* release_quotedmsg(); - ::proto::MsgOpaqueData* mutable_quotedmsg(); - void set_allocated_quotedmsg(::proto::MsgOpaqueData* quotedmsg); - private: - const ::proto::MsgOpaqueData& _internal_quotedmsg() const; - ::proto::MsgOpaqueData* _internal_mutable_quotedmsg(); - public: - void unsafe_arena_set_allocated_quotedmsg( - ::proto::MsgOpaqueData* quotedmsg); - ::proto::MsgOpaqueData* unsafe_arena_release_quotedmsg(); - - // @@protoc_insertion_point(class_scope:proto.MsgRowOpaqueData) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::proto::MsgOpaqueData* currentmsg_; - ::proto::MsgOpaqueData* quotedmsg_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class NoiseCertificate_Details final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.NoiseCertificate.Details) */ { - public: - inline NoiseCertificate_Details() : NoiseCertificate_Details(nullptr) {} - ~NoiseCertificate_Details() override; - explicit PROTOBUF_CONSTEXPR NoiseCertificate_Details(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - NoiseCertificate_Details(const NoiseCertificate_Details& from); - NoiseCertificate_Details(NoiseCertificate_Details&& from) noexcept - : NoiseCertificate_Details() { - *this = ::std::move(from); - } - - inline NoiseCertificate_Details& operator=(const NoiseCertificate_Details& from) { - CopyFrom(from); - return *this; - } - inline NoiseCertificate_Details& operator=(NoiseCertificate_Details&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const NoiseCertificate_Details& default_instance() { - return *internal_default_instance(); - } - static inline const NoiseCertificate_Details* internal_default_instance() { - return reinterpret_cast( - &_NoiseCertificate_Details_default_instance_); - } - static constexpr int kIndexInFileMessages = - 144; - - friend void swap(NoiseCertificate_Details& a, NoiseCertificate_Details& b) { - a.Swap(&b); - } - inline void Swap(NoiseCertificate_Details* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(NoiseCertificate_Details* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - NoiseCertificate_Details* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const NoiseCertificate_Details& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const NoiseCertificate_Details& from) { - NoiseCertificate_Details::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(NoiseCertificate_Details* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.NoiseCertificate.Details"; - } - protected: - explicit NoiseCertificate_Details(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kIssuerFieldNumber = 2, - kSubjectFieldNumber = 4, - kKeyFieldNumber = 5, - kExpiresFieldNumber = 3, - kSerialFieldNumber = 1, - }; - // optional string issuer = 2; - bool has_issuer() const; - private: - bool _internal_has_issuer() const; - public: - void clear_issuer(); - const std::string& issuer() const; - template - void set_issuer(ArgT0&& arg0, ArgT... args); - std::string* mutable_issuer(); - PROTOBUF_NODISCARD std::string* release_issuer(); - void set_allocated_issuer(std::string* issuer); - private: - const std::string& _internal_issuer() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_issuer(const std::string& value); - std::string* _internal_mutable_issuer(); - public: - - // optional string subject = 4; - bool has_subject() const; - private: - bool _internal_has_subject() const; - public: - void clear_subject(); - const std::string& subject() const; - template - void set_subject(ArgT0&& arg0, ArgT... args); - std::string* mutable_subject(); - PROTOBUF_NODISCARD std::string* release_subject(); - void set_allocated_subject(std::string* subject); - private: - const std::string& _internal_subject() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_subject(const std::string& value); - std::string* _internal_mutable_subject(); - public: - - // optional bytes key = 5; - bool has_key() const; - private: - bool _internal_has_key() const; - public: - void clear_key(); - const std::string& key() const; - template - void set_key(ArgT0&& arg0, ArgT... args); - std::string* mutable_key(); - PROTOBUF_NODISCARD std::string* release_key(); - void set_allocated_key(std::string* key); - private: - const std::string& _internal_key() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value); - std::string* _internal_mutable_key(); - public: - - // optional uint64 expires = 3; - bool has_expires() const; - private: - bool _internal_has_expires() const; - public: - void clear_expires(); - uint64_t expires() const; - void set_expires(uint64_t value); - private: - uint64_t _internal_expires() const; - void _internal_set_expires(uint64_t value); - public: - - // optional uint32 serial = 1; - bool has_serial() const; - private: - bool _internal_has_serial() const; - public: - void clear_serial(); - uint32_t serial() const; - void set_serial(uint32_t value); - private: - uint32_t _internal_serial() const; - void _internal_set_serial(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.NoiseCertificate.Details) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr issuer_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr subject_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_; - uint64_t expires_; - uint32_t serial_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class NoiseCertificate final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.NoiseCertificate) */ { - public: - inline NoiseCertificate() : NoiseCertificate(nullptr) {} - ~NoiseCertificate() override; - explicit PROTOBUF_CONSTEXPR NoiseCertificate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - NoiseCertificate(const NoiseCertificate& from); - NoiseCertificate(NoiseCertificate&& from) noexcept - : NoiseCertificate() { - *this = ::std::move(from); - } - - inline NoiseCertificate& operator=(const NoiseCertificate& from) { - CopyFrom(from); - return *this; - } - inline NoiseCertificate& operator=(NoiseCertificate&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const NoiseCertificate& default_instance() { - return *internal_default_instance(); - } - static inline const NoiseCertificate* internal_default_instance() { - return reinterpret_cast( - &_NoiseCertificate_default_instance_); - } - static constexpr int kIndexInFileMessages = - 145; - - friend void swap(NoiseCertificate& a, NoiseCertificate& b) { - a.Swap(&b); - } - inline void Swap(NoiseCertificate* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(NoiseCertificate* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - NoiseCertificate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const NoiseCertificate& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const NoiseCertificate& from) { - NoiseCertificate::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(NoiseCertificate* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.NoiseCertificate"; - } - protected: - explicit NoiseCertificate(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef NoiseCertificate_Details Details; - - // accessors ------------------------------------------------------- - - enum : int { - kDetailsFieldNumber = 1, - kSignatureFieldNumber = 2, - }; - // optional bytes details = 1; - bool has_details() const; - private: - bool _internal_has_details() const; - public: - void clear_details(); - const std::string& details() const; - template - void set_details(ArgT0&& arg0, ArgT... args); - std::string* mutable_details(); - PROTOBUF_NODISCARD std::string* release_details(); - void set_allocated_details(std::string* details); - private: - const std::string& _internal_details() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_details(const std::string& value); - std::string* _internal_mutable_details(); - public: - - // optional bytes signature = 2; - bool has_signature() const; - private: - bool _internal_has_signature() const; - public: - void clear_signature(); - const std::string& signature() const; - template - void set_signature(ArgT0&& arg0, ArgT... args); - std::string* mutable_signature(); - PROTOBUF_NODISCARD std::string* release_signature(); - void set_allocated_signature(std::string* signature); - private: - const std::string& _internal_signature() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value); - std::string* _internal_mutable_signature(); - public: - - // @@protoc_insertion_point(class_scope:proto.NoiseCertificate) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr details_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class NotificationMessageInfo final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.NotificationMessageInfo) */ { - public: - inline NotificationMessageInfo() : NotificationMessageInfo(nullptr) {} - ~NotificationMessageInfo() override; - explicit PROTOBUF_CONSTEXPR NotificationMessageInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - NotificationMessageInfo(const NotificationMessageInfo& from); - NotificationMessageInfo(NotificationMessageInfo&& from) noexcept - : NotificationMessageInfo() { - *this = ::std::move(from); - } - - inline NotificationMessageInfo& operator=(const NotificationMessageInfo& from) { - CopyFrom(from); - return *this; - } - inline NotificationMessageInfo& operator=(NotificationMessageInfo&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const NotificationMessageInfo& default_instance() { - return *internal_default_instance(); - } - static inline const NotificationMessageInfo* internal_default_instance() { - return reinterpret_cast( - &_NotificationMessageInfo_default_instance_); - } - static constexpr int kIndexInFileMessages = - 146; - - friend void swap(NotificationMessageInfo& a, NotificationMessageInfo& b) { - a.Swap(&b); - } - inline void Swap(NotificationMessageInfo* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(NotificationMessageInfo* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - NotificationMessageInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const NotificationMessageInfo& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const NotificationMessageInfo& from) { - NotificationMessageInfo::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(NotificationMessageInfo* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.NotificationMessageInfo"; - } - protected: - explicit NotificationMessageInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kParticipantFieldNumber = 4, - kKeyFieldNumber = 1, - kMessageFieldNumber = 2, - kMessageTimestampFieldNumber = 3, - }; - // optional string participant = 4; - bool has_participant() const; - private: - bool _internal_has_participant() const; - public: - void clear_participant(); - const std::string& participant() const; - template - void set_participant(ArgT0&& arg0, ArgT... args); - std::string* mutable_participant(); - PROTOBUF_NODISCARD std::string* release_participant(); - void set_allocated_participant(std::string* participant); - private: - const std::string& _internal_participant() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_participant(const std::string& value); - std::string* _internal_mutable_participant(); - public: - - // optional .proto.MessageKey key = 1; - bool has_key() const; - private: - bool _internal_has_key() const; - public: - void clear_key(); - const ::proto::MessageKey& key() const; - PROTOBUF_NODISCARD ::proto::MessageKey* release_key(); - ::proto::MessageKey* mutable_key(); - void set_allocated_key(::proto::MessageKey* key); - private: - const ::proto::MessageKey& _internal_key() const; - ::proto::MessageKey* _internal_mutable_key(); - public: - void unsafe_arena_set_allocated_key( - ::proto::MessageKey* key); - ::proto::MessageKey* unsafe_arena_release_key(); - - // optional .proto.Message message = 2; - bool has_message() const; - private: - bool _internal_has_message() const; - public: - void clear_message(); - const ::proto::Message& message() const; - PROTOBUF_NODISCARD ::proto::Message* release_message(); - ::proto::Message* mutable_message(); - void set_allocated_message(::proto::Message* message); - private: - const ::proto::Message& _internal_message() const; - ::proto::Message* _internal_mutable_message(); - public: - void unsafe_arena_set_allocated_message( - ::proto::Message* message); - ::proto::Message* unsafe_arena_release_message(); - - // optional uint64 messageTimestamp = 3; - bool has_messagetimestamp() const; - private: - bool _internal_has_messagetimestamp() const; - public: - void clear_messagetimestamp(); - uint64_t messagetimestamp() const; - void set_messagetimestamp(uint64_t value); - private: - uint64_t _internal_messagetimestamp() const; - void _internal_set_messagetimestamp(uint64_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.NotificationMessageInfo) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr participant_; - ::proto::MessageKey* key_; - ::proto::Message* message_; - uint64_t messagetimestamp_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class PastParticipant final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PastParticipant) */ { - public: - inline PastParticipant() : PastParticipant(nullptr) {} - ~PastParticipant() override; - explicit PROTOBUF_CONSTEXPR PastParticipant(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - PastParticipant(const PastParticipant& from); - PastParticipant(PastParticipant&& from) noexcept - : PastParticipant() { - *this = ::std::move(from); - } - - inline PastParticipant& operator=(const PastParticipant& from) { - CopyFrom(from); - return *this; - } - inline PastParticipant& operator=(PastParticipant&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const PastParticipant& default_instance() { - return *internal_default_instance(); - } - static inline const PastParticipant* internal_default_instance() { - return reinterpret_cast( - &_PastParticipant_default_instance_); - } - static constexpr int kIndexInFileMessages = - 147; - - friend void swap(PastParticipant& a, PastParticipant& b) { - a.Swap(&b); - } - inline void Swap(PastParticipant* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(PastParticipant* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - PastParticipant* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const PastParticipant& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const PastParticipant& from) { - PastParticipant::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(PastParticipant* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.PastParticipant"; - } - protected: - explicit PastParticipant(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef PastParticipant_LeaveReason LeaveReason; - static constexpr LeaveReason LEFT = - PastParticipant_LeaveReason_LEFT; - static constexpr LeaveReason REMOVED = - PastParticipant_LeaveReason_REMOVED; - static inline bool LeaveReason_IsValid(int value) { - return PastParticipant_LeaveReason_IsValid(value); - } - static constexpr LeaveReason LeaveReason_MIN = - PastParticipant_LeaveReason_LeaveReason_MIN; - static constexpr LeaveReason LeaveReason_MAX = - PastParticipant_LeaveReason_LeaveReason_MAX; - static constexpr int LeaveReason_ARRAYSIZE = - PastParticipant_LeaveReason_LeaveReason_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - LeaveReason_descriptor() { - return PastParticipant_LeaveReason_descriptor(); - } - template - static inline const std::string& LeaveReason_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function LeaveReason_Name."); - return PastParticipant_LeaveReason_Name(enum_t_value); - } - static inline bool LeaveReason_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - LeaveReason* value) { - return PastParticipant_LeaveReason_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kUserJidFieldNumber = 1, - kLeaveTsFieldNumber = 3, - kLeaveReasonFieldNumber = 2, - }; - // required string userJid = 1; - bool has_userjid() const; - private: - bool _internal_has_userjid() const; - public: - void clear_userjid(); - const std::string& userjid() const; - template - void set_userjid(ArgT0&& arg0, ArgT... args); - std::string* mutable_userjid(); - PROTOBUF_NODISCARD std::string* release_userjid(); - void set_allocated_userjid(std::string* userjid); - private: - const std::string& _internal_userjid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_userjid(const std::string& value); - std::string* _internal_mutable_userjid(); - public: - - // required uint64 leaveTs = 3; - bool has_leavets() const; - private: - bool _internal_has_leavets() const; - public: - void clear_leavets(); - uint64_t leavets() const; - void set_leavets(uint64_t value); - private: - uint64_t _internal_leavets() const; - void _internal_set_leavets(uint64_t value); - public: - - // required .proto.PastParticipant.LeaveReason leaveReason = 2; - bool has_leavereason() const; - private: - bool _internal_has_leavereason() const; - public: - void clear_leavereason(); - ::proto::PastParticipant_LeaveReason leavereason() const; - void set_leavereason(::proto::PastParticipant_LeaveReason value); - private: - ::proto::PastParticipant_LeaveReason _internal_leavereason() const; - void _internal_set_leavereason(::proto::PastParticipant_LeaveReason value); - public: - - // @@protoc_insertion_point(class_scope:proto.PastParticipant) - private: - class _Internal; - - // helper for ByteSizeLong() - size_t RequiredFieldsByteSizeFallback() const; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userjid_; - uint64_t leavets_; - int leavereason_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class PastParticipants final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PastParticipants) */ { - public: - inline PastParticipants() : PastParticipants(nullptr) {} - ~PastParticipants() override; - explicit PROTOBUF_CONSTEXPR PastParticipants(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - PastParticipants(const PastParticipants& from); - PastParticipants(PastParticipants&& from) noexcept - : PastParticipants() { - *this = ::std::move(from); - } - - inline PastParticipants& operator=(const PastParticipants& from) { - CopyFrom(from); - return *this; - } - inline PastParticipants& operator=(PastParticipants&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const PastParticipants& default_instance() { - return *internal_default_instance(); - } - static inline const PastParticipants* internal_default_instance() { - return reinterpret_cast( - &_PastParticipants_default_instance_); - } - static constexpr int kIndexInFileMessages = - 148; - - friend void swap(PastParticipants& a, PastParticipants& b) { - a.Swap(&b); - } - inline void Swap(PastParticipants* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(PastParticipants* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - PastParticipants* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const PastParticipants& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const PastParticipants& from) { - PastParticipants::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(PastParticipants* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.PastParticipants"; - } - protected: - explicit PastParticipants(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kPastParticipantsFieldNumber = 2, - kGroupJidFieldNumber = 1, - }; - // repeated .proto.PastParticipant pastParticipants = 2; - int pastparticipants_size() const; - private: - int _internal_pastparticipants_size() const; - public: - void clear_pastparticipants(); - ::proto::PastParticipant* mutable_pastparticipants(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipant >* - mutable_pastparticipants(); - private: - const ::proto::PastParticipant& _internal_pastparticipants(int index) const; - ::proto::PastParticipant* _internal_add_pastparticipants(); - public: - const ::proto::PastParticipant& pastparticipants(int index) const; - ::proto::PastParticipant* add_pastparticipants(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipant >& - pastparticipants() const; - - // required string groupJid = 1; - bool has_groupjid() const; - private: - bool _internal_has_groupjid() const; - public: - void clear_groupjid(); - const std::string& groupjid() const; - template - void set_groupjid(ArgT0&& arg0, ArgT... args); - std::string* mutable_groupjid(); - PROTOBUF_NODISCARD std::string* release_groupjid(); - void set_allocated_groupjid(std::string* groupjid); - private: - const std::string& _internal_groupjid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_groupjid(const std::string& value); - std::string* _internal_mutable_groupjid(); - public: - - // @@protoc_insertion_point(class_scope:proto.PastParticipants) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipant > pastparticipants_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr groupjid_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class PaymentBackground_MediaData final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PaymentBackground.MediaData) */ { - public: - inline PaymentBackground_MediaData() : PaymentBackground_MediaData(nullptr) {} - ~PaymentBackground_MediaData() override; - explicit PROTOBUF_CONSTEXPR PaymentBackground_MediaData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - PaymentBackground_MediaData(const PaymentBackground_MediaData& from); - PaymentBackground_MediaData(PaymentBackground_MediaData&& from) noexcept - : PaymentBackground_MediaData() { - *this = ::std::move(from); - } - - inline PaymentBackground_MediaData& operator=(const PaymentBackground_MediaData& from) { - CopyFrom(from); - return *this; - } - inline PaymentBackground_MediaData& operator=(PaymentBackground_MediaData&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const PaymentBackground_MediaData& default_instance() { - return *internal_default_instance(); - } - static inline const PaymentBackground_MediaData* internal_default_instance() { - return reinterpret_cast( - &_PaymentBackground_MediaData_default_instance_); - } - static constexpr int kIndexInFileMessages = - 149; - - friend void swap(PaymentBackground_MediaData& a, PaymentBackground_MediaData& b) { - a.Swap(&b); - } - inline void Swap(PaymentBackground_MediaData* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(PaymentBackground_MediaData* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - PaymentBackground_MediaData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const PaymentBackground_MediaData& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const PaymentBackground_MediaData& from) { - PaymentBackground_MediaData::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(PaymentBackground_MediaData* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.PaymentBackground.MediaData"; - } - protected: - explicit PaymentBackground_MediaData(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kMediaKeyFieldNumber = 1, - kFileSha256FieldNumber = 3, - kFileEncSha256FieldNumber = 4, - kDirectPathFieldNumber = 5, - kMediaKeyTimestampFieldNumber = 2, - }; - // optional bytes mediaKey = 1; - bool has_mediakey() const; - private: - bool _internal_has_mediakey() const; - public: - void clear_mediakey(); - const std::string& mediakey() const; - template - void set_mediakey(ArgT0&& arg0, ArgT... args); - std::string* mutable_mediakey(); - PROTOBUF_NODISCARD std::string* release_mediakey(); - void set_allocated_mediakey(std::string* mediakey); - private: - const std::string& _internal_mediakey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value); - std::string* _internal_mutable_mediakey(); - public: - - // optional bytes fileSha256 = 3; - bool has_filesha256() const; - private: - bool _internal_has_filesha256() const; - public: - void clear_filesha256(); - const std::string& filesha256() const; - template - void set_filesha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_filesha256(); - PROTOBUF_NODISCARD std::string* release_filesha256(); - void set_allocated_filesha256(std::string* filesha256); - private: - const std::string& _internal_filesha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value); - std::string* _internal_mutable_filesha256(); - public: - - // optional bytes fileEncSha256 = 4; - bool has_fileencsha256() const; - private: - bool _internal_has_fileencsha256() const; - public: - void clear_fileencsha256(); - const std::string& fileencsha256() const; - template - void set_fileencsha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_fileencsha256(); - PROTOBUF_NODISCARD std::string* release_fileencsha256(); - void set_allocated_fileencsha256(std::string* fileencsha256); - private: - const std::string& _internal_fileencsha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value); - std::string* _internal_mutable_fileencsha256(); - public: - - // optional string directPath = 5; - bool has_directpath() const; - private: - bool _internal_has_directpath() const; - public: - void clear_directpath(); - const std::string& directpath() const; - template - void set_directpath(ArgT0&& arg0, ArgT... args); - std::string* mutable_directpath(); - PROTOBUF_NODISCARD std::string* release_directpath(); - void set_allocated_directpath(std::string* directpath); - private: - const std::string& _internal_directpath() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value); - std::string* _internal_mutable_directpath(); - public: - - // optional int64 mediaKeyTimestamp = 2; - bool has_mediakeytimestamp() const; - private: - bool _internal_has_mediakeytimestamp() const; - public: - void clear_mediakeytimestamp(); - int64_t mediakeytimestamp() const; - void set_mediakeytimestamp(int64_t value); - private: - int64_t _internal_mediakeytimestamp() const; - void _internal_set_mediakeytimestamp(int64_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.PaymentBackground.MediaData) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_; - int64_t mediakeytimestamp_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class PaymentBackground final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PaymentBackground) */ { - public: - inline PaymentBackground() : PaymentBackground(nullptr) {} - ~PaymentBackground() override; - explicit PROTOBUF_CONSTEXPR PaymentBackground(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - PaymentBackground(const PaymentBackground& from); - PaymentBackground(PaymentBackground&& from) noexcept - : PaymentBackground() { - *this = ::std::move(from); - } - - inline PaymentBackground& operator=(const PaymentBackground& from) { - CopyFrom(from); - return *this; - } - inline PaymentBackground& operator=(PaymentBackground&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const PaymentBackground& default_instance() { - return *internal_default_instance(); - } - static inline const PaymentBackground* internal_default_instance() { - return reinterpret_cast( - &_PaymentBackground_default_instance_); - } - static constexpr int kIndexInFileMessages = - 150; - - friend void swap(PaymentBackground& a, PaymentBackground& b) { - a.Swap(&b); - } - inline void Swap(PaymentBackground* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(PaymentBackground* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - PaymentBackground* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const PaymentBackground& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const PaymentBackground& from) { - PaymentBackground::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(PaymentBackground* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.PaymentBackground"; - } - protected: - explicit PaymentBackground(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef PaymentBackground_MediaData MediaData; - - typedef PaymentBackground_Type Type; - static constexpr Type UNKNOWN = - PaymentBackground_Type_UNKNOWN; - static constexpr Type DEFAULT = - PaymentBackground_Type_DEFAULT; - static inline bool Type_IsValid(int value) { - return PaymentBackground_Type_IsValid(value); - } - static constexpr Type Type_MIN = - PaymentBackground_Type_Type_MIN; - static constexpr Type Type_MAX = - PaymentBackground_Type_Type_MAX; - static constexpr int Type_ARRAYSIZE = - PaymentBackground_Type_Type_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - Type_descriptor() { - return PaymentBackground_Type_descriptor(); - } - template - static inline const std::string& Type_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Type_Name."); - return PaymentBackground_Type_Name(enum_t_value); - } - static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - Type* value) { - return PaymentBackground_Type_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kIdFieldNumber = 1, - kMimetypeFieldNumber = 5, - kMediaDataFieldNumber = 9, - kFileLengthFieldNumber = 2, - kWidthFieldNumber = 3, - kHeightFieldNumber = 4, - kPlaceholderArgbFieldNumber = 6, - kTextArgbFieldNumber = 7, - kSubtextArgbFieldNumber = 8, - kTypeFieldNumber = 10, - }; - // optional string id = 1; - bool has_id() const; - private: - bool _internal_has_id() const; - public: - void clear_id(); - const std::string& id() const; - template - void set_id(ArgT0&& arg0, ArgT... args); - std::string* mutable_id(); - PROTOBUF_NODISCARD std::string* release_id(); - void set_allocated_id(std::string* id); - private: - const std::string& _internal_id() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value); - std::string* _internal_mutable_id(); - public: - - // optional string mimetype = 5; - bool has_mimetype() const; - private: - bool _internal_has_mimetype() const; - public: - void clear_mimetype(); - const std::string& mimetype() const; - template - void set_mimetype(ArgT0&& arg0, ArgT... args); - std::string* mutable_mimetype(); - PROTOBUF_NODISCARD std::string* release_mimetype(); - void set_allocated_mimetype(std::string* mimetype); - private: - const std::string& _internal_mimetype() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value); - std::string* _internal_mutable_mimetype(); - public: - - // optional .proto.PaymentBackground.MediaData mediaData = 9; - bool has_mediadata() const; - private: - bool _internal_has_mediadata() const; - public: - void clear_mediadata(); - const ::proto::PaymentBackground_MediaData& mediadata() const; - PROTOBUF_NODISCARD ::proto::PaymentBackground_MediaData* release_mediadata(); - ::proto::PaymentBackground_MediaData* mutable_mediadata(); - void set_allocated_mediadata(::proto::PaymentBackground_MediaData* mediadata); - private: - const ::proto::PaymentBackground_MediaData& _internal_mediadata() const; - ::proto::PaymentBackground_MediaData* _internal_mutable_mediadata(); - public: - void unsafe_arena_set_allocated_mediadata( - ::proto::PaymentBackground_MediaData* mediadata); - ::proto::PaymentBackground_MediaData* unsafe_arena_release_mediadata(); - - // optional uint64 fileLength = 2; - bool has_filelength() const; - private: - bool _internal_has_filelength() const; - public: - void clear_filelength(); - uint64_t filelength() const; - void set_filelength(uint64_t value); - private: - uint64_t _internal_filelength() const; - void _internal_set_filelength(uint64_t value); - public: - - // optional uint32 width = 3; - bool has_width() const; - private: - bool _internal_has_width() const; - public: - void clear_width(); - uint32_t width() const; - void set_width(uint32_t value); - private: - uint32_t _internal_width() const; - void _internal_set_width(uint32_t value); - public: - - // optional uint32 height = 4; - bool has_height() const; - private: - bool _internal_has_height() const; - public: - void clear_height(); - uint32_t height() const; - void set_height(uint32_t value); - private: - uint32_t _internal_height() const; - void _internal_set_height(uint32_t value); - public: - - // optional fixed32 placeholderArgb = 6; - bool has_placeholderargb() const; - private: - bool _internal_has_placeholderargb() const; - public: - void clear_placeholderargb(); - uint32_t placeholderargb() const; - void set_placeholderargb(uint32_t value); - private: - uint32_t _internal_placeholderargb() const; - void _internal_set_placeholderargb(uint32_t value); - public: - - // optional fixed32 textArgb = 7; - bool has_textargb() const; - private: - bool _internal_has_textargb() const; - public: - void clear_textargb(); - uint32_t textargb() const; - void set_textargb(uint32_t value); - private: - uint32_t _internal_textargb() const; - void _internal_set_textargb(uint32_t value); - public: - - // optional fixed32 subtextArgb = 8; - bool has_subtextargb() const; - private: - bool _internal_has_subtextargb() const; - public: - void clear_subtextargb(); - uint32_t subtextargb() const; - void set_subtextargb(uint32_t value); - private: - uint32_t _internal_subtextargb() const; - void _internal_set_subtextargb(uint32_t value); - public: - - // optional .proto.PaymentBackground.Type type = 10; - bool has_type() const; - private: - bool _internal_has_type() const; - public: - void clear_type(); - ::proto::PaymentBackground_Type type() const; - void set_type(::proto::PaymentBackground_Type value); - private: - ::proto::PaymentBackground_Type _internal_type() const; - void _internal_set_type(::proto::PaymentBackground_Type value); - public: - - // @@protoc_insertion_point(class_scope:proto.PaymentBackground) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mimetype_; - ::proto::PaymentBackground_MediaData* mediadata_; - uint64_t filelength_; - uint32_t width_; - uint32_t height_; - uint32_t placeholderargb_; - uint32_t textargb_; - uint32_t subtextargb_; - int type_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class PaymentInfo final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PaymentInfo) */ { - public: - inline PaymentInfo() : PaymentInfo(nullptr) {} - ~PaymentInfo() override; - explicit PROTOBUF_CONSTEXPR PaymentInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - PaymentInfo(const PaymentInfo& from); - PaymentInfo(PaymentInfo&& from) noexcept - : PaymentInfo() { - *this = ::std::move(from); - } - - inline PaymentInfo& operator=(const PaymentInfo& from) { - CopyFrom(from); - return *this; - } - inline PaymentInfo& operator=(PaymentInfo&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const PaymentInfo& default_instance() { - return *internal_default_instance(); - } - static inline const PaymentInfo* internal_default_instance() { - return reinterpret_cast( - &_PaymentInfo_default_instance_); - } - static constexpr int kIndexInFileMessages = - 151; - - friend void swap(PaymentInfo& a, PaymentInfo& b) { - a.Swap(&b); - } - inline void Swap(PaymentInfo* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(PaymentInfo* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - PaymentInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const PaymentInfo& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const PaymentInfo& from) { - PaymentInfo::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(PaymentInfo* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.PaymentInfo"; - } - protected: - explicit PaymentInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef PaymentInfo_Currency Currency; - static constexpr Currency UNKNOWN_CURRENCY = - PaymentInfo_Currency_UNKNOWN_CURRENCY; - static constexpr Currency INR = - PaymentInfo_Currency_INR; - static inline bool Currency_IsValid(int value) { - return PaymentInfo_Currency_IsValid(value); - } - static constexpr Currency Currency_MIN = - PaymentInfo_Currency_Currency_MIN; - static constexpr Currency Currency_MAX = - PaymentInfo_Currency_Currency_MAX; - static constexpr int Currency_ARRAYSIZE = - PaymentInfo_Currency_Currency_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - Currency_descriptor() { - return PaymentInfo_Currency_descriptor(); - } - template - static inline const std::string& Currency_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Currency_Name."); - return PaymentInfo_Currency_Name(enum_t_value); - } - static inline bool Currency_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - Currency* value) { - return PaymentInfo_Currency_Parse(name, value); - } - - typedef PaymentInfo_Status Status; - static constexpr Status UNKNOWN_STATUS = - PaymentInfo_Status_UNKNOWN_STATUS; - static constexpr Status PROCESSING = - PaymentInfo_Status_PROCESSING; - static constexpr Status SENT = - PaymentInfo_Status_SENT; - static constexpr Status NEED_TO_ACCEPT = - PaymentInfo_Status_NEED_TO_ACCEPT; - static constexpr Status COMPLETE = - PaymentInfo_Status_COMPLETE; - static constexpr Status COULD_NOT_COMPLETE = - PaymentInfo_Status_COULD_NOT_COMPLETE; - static constexpr Status REFUNDED = - PaymentInfo_Status_REFUNDED; - static constexpr Status EXPIRED = - PaymentInfo_Status_EXPIRED; - static constexpr Status REJECTED = - PaymentInfo_Status_REJECTED; - static constexpr Status CANCELLED = - PaymentInfo_Status_CANCELLED; - static constexpr Status WAITING_FOR_PAYER = - PaymentInfo_Status_WAITING_FOR_PAYER; - static constexpr Status WAITING = - PaymentInfo_Status_WAITING; - static inline bool Status_IsValid(int value) { - return PaymentInfo_Status_IsValid(value); - } - static constexpr Status Status_MIN = - PaymentInfo_Status_Status_MIN; - static constexpr Status Status_MAX = - PaymentInfo_Status_Status_MAX; - static constexpr int Status_ARRAYSIZE = - PaymentInfo_Status_Status_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - Status_descriptor() { - return PaymentInfo_Status_descriptor(); - } - template - static inline const std::string& Status_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Status_Name."); - return PaymentInfo_Status_Name(enum_t_value); - } - static inline bool Status_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - Status* value) { - return PaymentInfo_Status_Parse(name, value); - } - - typedef PaymentInfo_TxnStatus TxnStatus; - static constexpr TxnStatus UNKNOWN = - PaymentInfo_TxnStatus_UNKNOWN; - static constexpr TxnStatus PENDING_SETUP = - PaymentInfo_TxnStatus_PENDING_SETUP; - static constexpr TxnStatus PENDING_RECEIVER_SETUP = - PaymentInfo_TxnStatus_PENDING_RECEIVER_SETUP; - static constexpr TxnStatus INIT = - PaymentInfo_TxnStatus_INIT; - static constexpr TxnStatus SUCCESS = - PaymentInfo_TxnStatus_SUCCESS; - static constexpr TxnStatus COMPLETED = - PaymentInfo_TxnStatus_COMPLETED; - static constexpr TxnStatus FAILED = - PaymentInfo_TxnStatus_FAILED; - static constexpr TxnStatus FAILED_RISK = - PaymentInfo_TxnStatus_FAILED_RISK; - static constexpr TxnStatus FAILED_PROCESSING = - PaymentInfo_TxnStatus_FAILED_PROCESSING; - static constexpr TxnStatus FAILED_RECEIVER_PROCESSING = - PaymentInfo_TxnStatus_FAILED_RECEIVER_PROCESSING; - static constexpr TxnStatus FAILED_DA = - PaymentInfo_TxnStatus_FAILED_DA; - static constexpr TxnStatus FAILED_DA_FINAL = - PaymentInfo_TxnStatus_FAILED_DA_FINAL; - static constexpr TxnStatus REFUNDED_TXN = - PaymentInfo_TxnStatus_REFUNDED_TXN; - static constexpr TxnStatus REFUND_FAILED = - PaymentInfo_TxnStatus_REFUND_FAILED; - static constexpr TxnStatus REFUND_FAILED_PROCESSING = - PaymentInfo_TxnStatus_REFUND_FAILED_PROCESSING; - static constexpr TxnStatus REFUND_FAILED_DA = - PaymentInfo_TxnStatus_REFUND_FAILED_DA; - static constexpr TxnStatus EXPIRED_TXN = - PaymentInfo_TxnStatus_EXPIRED_TXN; - static constexpr TxnStatus AUTH_CANCELED = - PaymentInfo_TxnStatus_AUTH_CANCELED; - static constexpr TxnStatus AUTH_CANCEL_FAILED_PROCESSING = - PaymentInfo_TxnStatus_AUTH_CANCEL_FAILED_PROCESSING; - static constexpr TxnStatus AUTH_CANCEL_FAILED = - PaymentInfo_TxnStatus_AUTH_CANCEL_FAILED; - static constexpr TxnStatus COLLECT_INIT = - PaymentInfo_TxnStatus_COLLECT_INIT; - static constexpr TxnStatus COLLECT_SUCCESS = - PaymentInfo_TxnStatus_COLLECT_SUCCESS; - static constexpr TxnStatus COLLECT_FAILED = - PaymentInfo_TxnStatus_COLLECT_FAILED; - static constexpr TxnStatus COLLECT_FAILED_RISK = - PaymentInfo_TxnStatus_COLLECT_FAILED_RISK; - static constexpr TxnStatus COLLECT_REJECTED = - PaymentInfo_TxnStatus_COLLECT_REJECTED; - static constexpr TxnStatus COLLECT_EXPIRED = - PaymentInfo_TxnStatus_COLLECT_EXPIRED; - static constexpr TxnStatus COLLECT_CANCELED = - PaymentInfo_TxnStatus_COLLECT_CANCELED; - static constexpr TxnStatus COLLECT_CANCELLING = - PaymentInfo_TxnStatus_COLLECT_CANCELLING; - static constexpr TxnStatus IN_REVIEW = - PaymentInfo_TxnStatus_IN_REVIEW; - static constexpr TxnStatus REVERSAL_SUCCESS = - PaymentInfo_TxnStatus_REVERSAL_SUCCESS; - static constexpr TxnStatus REVERSAL_PENDING = - PaymentInfo_TxnStatus_REVERSAL_PENDING; - static constexpr TxnStatus REFUND_PENDING = - PaymentInfo_TxnStatus_REFUND_PENDING; - static inline bool TxnStatus_IsValid(int value) { - return PaymentInfo_TxnStatus_IsValid(value); - } - static constexpr TxnStatus TxnStatus_MIN = - PaymentInfo_TxnStatus_TxnStatus_MIN; - static constexpr TxnStatus TxnStatus_MAX = - PaymentInfo_TxnStatus_TxnStatus_MAX; - static constexpr int TxnStatus_ARRAYSIZE = - PaymentInfo_TxnStatus_TxnStatus_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - TxnStatus_descriptor() { - return PaymentInfo_TxnStatus_descriptor(); - } - template - static inline const std::string& TxnStatus_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function TxnStatus_Name."); - return PaymentInfo_TxnStatus_Name(enum_t_value); - } - static inline bool TxnStatus_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - TxnStatus* value) { - return PaymentInfo_TxnStatus_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kReceiverJidFieldNumber = 3, - kCurrencyFieldNumber = 9, - kRequestMessageKeyFieldNumber = 6, - kPrimaryAmountFieldNumber = 12, - kExchangeAmountFieldNumber = 13, - kAmount1000FieldNumber = 2, - kCurrencyDeprecatedFieldNumber = 1, - kStatusFieldNumber = 4, - kTransactionTimestampFieldNumber = 5, - kExpiryTimestampFieldNumber = 7, - kFutureproofedFieldNumber = 8, - kUseNoviFiatFormatFieldNumber = 11, - kTxnStatusFieldNumber = 10, - }; - // optional string receiverJid = 3; - bool has_receiverjid() const; - private: - bool _internal_has_receiverjid() const; - public: - void clear_receiverjid(); - const std::string& receiverjid() const; - template - void set_receiverjid(ArgT0&& arg0, ArgT... args); - std::string* mutable_receiverjid(); - PROTOBUF_NODISCARD std::string* release_receiverjid(); - void set_allocated_receiverjid(std::string* receiverjid); - private: - const std::string& _internal_receiverjid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_receiverjid(const std::string& value); - std::string* _internal_mutable_receiverjid(); - public: - - // optional string currency = 9; - bool has_currency() const; - private: - bool _internal_has_currency() const; - public: - void clear_currency(); - const std::string& currency() const; - template - void set_currency(ArgT0&& arg0, ArgT... args); - std::string* mutable_currency(); - PROTOBUF_NODISCARD std::string* release_currency(); - void set_allocated_currency(std::string* currency); - private: - const std::string& _internal_currency() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_currency(const std::string& value); - std::string* _internal_mutable_currency(); - public: - - // optional .proto.MessageKey requestMessageKey = 6; - bool has_requestmessagekey() const; - private: - bool _internal_has_requestmessagekey() const; - public: - void clear_requestmessagekey(); - const ::proto::MessageKey& requestmessagekey() const; - PROTOBUF_NODISCARD ::proto::MessageKey* release_requestmessagekey(); - ::proto::MessageKey* mutable_requestmessagekey(); - void set_allocated_requestmessagekey(::proto::MessageKey* requestmessagekey); - private: - const ::proto::MessageKey& _internal_requestmessagekey() const; - ::proto::MessageKey* _internal_mutable_requestmessagekey(); - public: - void unsafe_arena_set_allocated_requestmessagekey( - ::proto::MessageKey* requestmessagekey); - ::proto::MessageKey* unsafe_arena_release_requestmessagekey(); - - // optional .proto.Money primaryAmount = 12; - bool has_primaryamount() const; - private: - bool _internal_has_primaryamount() const; - public: - void clear_primaryamount(); - const ::proto::Money& primaryamount() const; - PROTOBUF_NODISCARD ::proto::Money* release_primaryamount(); - ::proto::Money* mutable_primaryamount(); - void set_allocated_primaryamount(::proto::Money* primaryamount); - private: - const ::proto::Money& _internal_primaryamount() const; - ::proto::Money* _internal_mutable_primaryamount(); - public: - void unsafe_arena_set_allocated_primaryamount( - ::proto::Money* primaryamount); - ::proto::Money* unsafe_arena_release_primaryamount(); - - // optional .proto.Money exchangeAmount = 13; - bool has_exchangeamount() const; - private: - bool _internal_has_exchangeamount() const; - public: - void clear_exchangeamount(); - const ::proto::Money& exchangeamount() const; - PROTOBUF_NODISCARD ::proto::Money* release_exchangeamount(); - ::proto::Money* mutable_exchangeamount(); - void set_allocated_exchangeamount(::proto::Money* exchangeamount); - private: - const ::proto::Money& _internal_exchangeamount() const; - ::proto::Money* _internal_mutable_exchangeamount(); - public: - void unsafe_arena_set_allocated_exchangeamount( - ::proto::Money* exchangeamount); - ::proto::Money* unsafe_arena_release_exchangeamount(); - - // optional uint64 amount1000 = 2; - bool has_amount1000() const; - private: - bool _internal_has_amount1000() const; - public: - void clear_amount1000(); - uint64_t amount1000() const; - void set_amount1000(uint64_t value); - private: - uint64_t _internal_amount1000() const; - void _internal_set_amount1000(uint64_t value); - public: - - // optional .proto.PaymentInfo.Currency currencyDeprecated = 1; - bool has_currencydeprecated() const; - private: - bool _internal_has_currencydeprecated() const; - public: - void clear_currencydeprecated(); - ::proto::PaymentInfo_Currency currencydeprecated() const; - void set_currencydeprecated(::proto::PaymentInfo_Currency value); - private: - ::proto::PaymentInfo_Currency _internal_currencydeprecated() const; - void _internal_set_currencydeprecated(::proto::PaymentInfo_Currency value); - public: - - // optional .proto.PaymentInfo.Status status = 4; - bool has_status() const; - private: - bool _internal_has_status() const; - public: - void clear_status(); - ::proto::PaymentInfo_Status status() const; - void set_status(::proto::PaymentInfo_Status value); - private: - ::proto::PaymentInfo_Status _internal_status() const; - void _internal_set_status(::proto::PaymentInfo_Status value); - public: - - // optional uint64 transactionTimestamp = 5; - bool has_transactiontimestamp() const; - private: - bool _internal_has_transactiontimestamp() const; - public: - void clear_transactiontimestamp(); - uint64_t transactiontimestamp() const; - void set_transactiontimestamp(uint64_t value); - private: - uint64_t _internal_transactiontimestamp() const; - void _internal_set_transactiontimestamp(uint64_t value); - public: - - // optional uint64 expiryTimestamp = 7; - bool has_expirytimestamp() const; - private: - bool _internal_has_expirytimestamp() const; - public: - void clear_expirytimestamp(); - uint64_t expirytimestamp() const; - void set_expirytimestamp(uint64_t value); - private: - uint64_t _internal_expirytimestamp() const; - void _internal_set_expirytimestamp(uint64_t value); - public: - - // optional bool futureproofed = 8; - bool has_futureproofed() const; - private: - bool _internal_has_futureproofed() const; - public: - void clear_futureproofed(); - bool futureproofed() const; - void set_futureproofed(bool value); - private: - bool _internal_futureproofed() const; - void _internal_set_futureproofed(bool value); - public: - - // optional bool useNoviFiatFormat = 11; - bool has_usenovifiatformat() const; - private: - bool _internal_has_usenovifiatformat() const; - public: - void clear_usenovifiatformat(); - bool usenovifiatformat() const; - void set_usenovifiatformat(bool value); - private: - bool _internal_usenovifiatformat() const; - void _internal_set_usenovifiatformat(bool value); - public: - - // optional .proto.PaymentInfo.TxnStatus txnStatus = 10; - bool has_txnstatus() const; - private: - bool _internal_has_txnstatus() const; - public: - void clear_txnstatus(); - ::proto::PaymentInfo_TxnStatus txnstatus() const; - void set_txnstatus(::proto::PaymentInfo_TxnStatus value); - private: - ::proto::PaymentInfo_TxnStatus _internal_txnstatus() const; - void _internal_set_txnstatus(::proto::PaymentInfo_TxnStatus value); - public: - - // @@protoc_insertion_point(class_scope:proto.PaymentInfo) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr receiverjid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr currency_; - ::proto::MessageKey* requestmessagekey_; - ::proto::Money* primaryamount_; - ::proto::Money* exchangeamount_; - uint64_t amount1000_; - int currencydeprecated_; - int status_; - uint64_t transactiontimestamp_; - uint64_t expirytimestamp_; - bool futureproofed_; - bool usenovifiatformat_; - int txnstatus_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class PendingKeyExchange final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PendingKeyExchange) */ { - public: - inline PendingKeyExchange() : PendingKeyExchange(nullptr) {} - ~PendingKeyExchange() override; - explicit PROTOBUF_CONSTEXPR PendingKeyExchange(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - PendingKeyExchange(const PendingKeyExchange& from); - PendingKeyExchange(PendingKeyExchange&& from) noexcept - : PendingKeyExchange() { - *this = ::std::move(from); - } - - inline PendingKeyExchange& operator=(const PendingKeyExchange& from) { - CopyFrom(from); - return *this; - } - inline PendingKeyExchange& operator=(PendingKeyExchange&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const PendingKeyExchange& default_instance() { - return *internal_default_instance(); - } - static inline const PendingKeyExchange* internal_default_instance() { - return reinterpret_cast( - &_PendingKeyExchange_default_instance_); - } - static constexpr int kIndexInFileMessages = - 152; - - friend void swap(PendingKeyExchange& a, PendingKeyExchange& b) { - a.Swap(&b); - } - inline void Swap(PendingKeyExchange* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(PendingKeyExchange* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - PendingKeyExchange* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const PendingKeyExchange& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const PendingKeyExchange& from) { - PendingKeyExchange::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(PendingKeyExchange* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.PendingKeyExchange"; - } - protected: - explicit PendingKeyExchange(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kLocalBaseKeyFieldNumber = 2, - kLocalBaseKeyPrivateFieldNumber = 3, - kLocalRatchetKeyFieldNumber = 4, - kLocalRatchetKeyPrivateFieldNumber = 5, - kLocalIdentityKeyFieldNumber = 7, - kLocalIdentityKeyPrivateFieldNumber = 8, - kSequenceFieldNumber = 1, - }; - // optional bytes localBaseKey = 2; - bool has_localbasekey() const; - private: - bool _internal_has_localbasekey() const; - public: - void clear_localbasekey(); - const std::string& localbasekey() const; - template - void set_localbasekey(ArgT0&& arg0, ArgT... args); - std::string* mutable_localbasekey(); - PROTOBUF_NODISCARD std::string* release_localbasekey(); - void set_allocated_localbasekey(std::string* localbasekey); - private: - const std::string& _internal_localbasekey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_localbasekey(const std::string& value); - std::string* _internal_mutable_localbasekey(); - public: - - // optional bytes localBaseKeyPrivate = 3; - bool has_localbasekeyprivate() const; - private: - bool _internal_has_localbasekeyprivate() const; - public: - void clear_localbasekeyprivate(); - const std::string& localbasekeyprivate() const; - template - void set_localbasekeyprivate(ArgT0&& arg0, ArgT... args); - std::string* mutable_localbasekeyprivate(); - PROTOBUF_NODISCARD std::string* release_localbasekeyprivate(); - void set_allocated_localbasekeyprivate(std::string* localbasekeyprivate); - private: - const std::string& _internal_localbasekeyprivate() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_localbasekeyprivate(const std::string& value); - std::string* _internal_mutable_localbasekeyprivate(); - public: - - // optional bytes localRatchetKey = 4; - bool has_localratchetkey() const; - private: - bool _internal_has_localratchetkey() const; - public: - void clear_localratchetkey(); - const std::string& localratchetkey() const; - template - void set_localratchetkey(ArgT0&& arg0, ArgT... args); - std::string* mutable_localratchetkey(); - PROTOBUF_NODISCARD std::string* release_localratchetkey(); - void set_allocated_localratchetkey(std::string* localratchetkey); - private: - const std::string& _internal_localratchetkey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_localratchetkey(const std::string& value); - std::string* _internal_mutable_localratchetkey(); - public: - - // optional bytes localRatchetKeyPrivate = 5; - bool has_localratchetkeyprivate() const; - private: - bool _internal_has_localratchetkeyprivate() const; - public: - void clear_localratchetkeyprivate(); - const std::string& localratchetkeyprivate() const; - template - void set_localratchetkeyprivate(ArgT0&& arg0, ArgT... args); - std::string* mutable_localratchetkeyprivate(); - PROTOBUF_NODISCARD std::string* release_localratchetkeyprivate(); - void set_allocated_localratchetkeyprivate(std::string* localratchetkeyprivate); - private: - const std::string& _internal_localratchetkeyprivate() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_localratchetkeyprivate(const std::string& value); - std::string* _internal_mutable_localratchetkeyprivate(); - public: - - // optional bytes localIdentityKey = 7; - bool has_localidentitykey() const; - private: - bool _internal_has_localidentitykey() const; - public: - void clear_localidentitykey(); - const std::string& localidentitykey() const; - template - void set_localidentitykey(ArgT0&& arg0, ArgT... args); - std::string* mutable_localidentitykey(); - PROTOBUF_NODISCARD std::string* release_localidentitykey(); - void set_allocated_localidentitykey(std::string* localidentitykey); - private: - const std::string& _internal_localidentitykey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_localidentitykey(const std::string& value); - std::string* _internal_mutable_localidentitykey(); - public: - - // optional bytes localIdentityKeyPrivate = 8; - bool has_localidentitykeyprivate() const; - private: - bool _internal_has_localidentitykeyprivate() const; - public: - void clear_localidentitykeyprivate(); - const std::string& localidentitykeyprivate() const; - template - void set_localidentitykeyprivate(ArgT0&& arg0, ArgT... args); - std::string* mutable_localidentitykeyprivate(); - PROTOBUF_NODISCARD std::string* release_localidentitykeyprivate(); - void set_allocated_localidentitykeyprivate(std::string* localidentitykeyprivate); - private: - const std::string& _internal_localidentitykeyprivate() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_localidentitykeyprivate(const std::string& value); - std::string* _internal_mutable_localidentitykeyprivate(); - public: - - // optional uint32 sequence = 1; - bool has_sequence() const; - private: - bool _internal_has_sequence() const; - public: - void clear_sequence(); - uint32_t sequence() const; - void set_sequence(uint32_t value); - private: - uint32_t _internal_sequence() const; - void _internal_set_sequence(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.PendingKeyExchange) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localbasekey_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localbasekeyprivate_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localratchetkey_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localratchetkeyprivate_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localidentitykey_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localidentitykeyprivate_; - uint32_t sequence_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class PendingPreKey final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PendingPreKey) */ { - public: - inline PendingPreKey() : PendingPreKey(nullptr) {} - ~PendingPreKey() override; - explicit PROTOBUF_CONSTEXPR PendingPreKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - PendingPreKey(const PendingPreKey& from); - PendingPreKey(PendingPreKey&& from) noexcept - : PendingPreKey() { - *this = ::std::move(from); - } - - inline PendingPreKey& operator=(const PendingPreKey& from) { - CopyFrom(from); - return *this; - } - inline PendingPreKey& operator=(PendingPreKey&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const PendingPreKey& default_instance() { - return *internal_default_instance(); - } - static inline const PendingPreKey* internal_default_instance() { - return reinterpret_cast( - &_PendingPreKey_default_instance_); - } - static constexpr int kIndexInFileMessages = - 153; - - friend void swap(PendingPreKey& a, PendingPreKey& b) { - a.Swap(&b); - } - inline void Swap(PendingPreKey* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(PendingPreKey* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - PendingPreKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const PendingPreKey& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const PendingPreKey& from) { - PendingPreKey::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(PendingPreKey* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.PendingPreKey"; - } - protected: - explicit PendingPreKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kBaseKeyFieldNumber = 2, - kPreKeyIdFieldNumber = 1, - kSignedPreKeyIdFieldNumber = 3, - }; - // optional bytes baseKey = 2; - bool has_basekey() const; - private: - bool _internal_has_basekey() const; - public: - void clear_basekey(); - const std::string& basekey() const; - template - void set_basekey(ArgT0&& arg0, ArgT... args); - std::string* mutable_basekey(); - PROTOBUF_NODISCARD std::string* release_basekey(); - void set_allocated_basekey(std::string* basekey); - private: - const std::string& _internal_basekey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_basekey(const std::string& value); - std::string* _internal_mutable_basekey(); - public: - - // optional uint32 preKeyId = 1; - bool has_prekeyid() const; - private: - bool _internal_has_prekeyid() const; - public: - void clear_prekeyid(); - uint32_t prekeyid() const; - void set_prekeyid(uint32_t value); - private: - uint32_t _internal_prekeyid() const; - void _internal_set_prekeyid(uint32_t value); - public: - - // optional int32 signedPreKeyId = 3; - bool has_signedprekeyid() const; - private: - bool _internal_has_signedprekeyid() const; - public: - void clear_signedprekeyid(); - int32_t signedprekeyid() const; - void set_signedprekeyid(int32_t value); - private: - int32_t _internal_signedprekeyid() const; - void _internal_set_signedprekeyid(int32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.PendingPreKey) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr basekey_; - uint32_t prekeyid_; - int32_t signedprekeyid_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class PhotoChange final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PhotoChange) */ { - public: - inline PhotoChange() : PhotoChange(nullptr) {} - ~PhotoChange() override; - explicit PROTOBUF_CONSTEXPR PhotoChange(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - PhotoChange(const PhotoChange& from); - PhotoChange(PhotoChange&& from) noexcept - : PhotoChange() { - *this = ::std::move(from); - } - - inline PhotoChange& operator=(const PhotoChange& from) { - CopyFrom(from); - return *this; - } - inline PhotoChange& operator=(PhotoChange&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const PhotoChange& default_instance() { - return *internal_default_instance(); - } - static inline const PhotoChange* internal_default_instance() { - return reinterpret_cast( - &_PhotoChange_default_instance_); - } - static constexpr int kIndexInFileMessages = - 154; - - friend void swap(PhotoChange& a, PhotoChange& b) { - a.Swap(&b); - } - inline void Swap(PhotoChange* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(PhotoChange* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - PhotoChange* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const PhotoChange& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const PhotoChange& from) { - PhotoChange::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(PhotoChange* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.PhotoChange"; - } - protected: - explicit PhotoChange(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kOldPhotoFieldNumber = 1, - kNewPhotoFieldNumber = 2, - kNewPhotoIdFieldNumber = 3, - }; - // optional bytes oldPhoto = 1; - bool has_oldphoto() const; - private: - bool _internal_has_oldphoto() const; - public: - void clear_oldphoto(); - const std::string& oldphoto() const; - template - void set_oldphoto(ArgT0&& arg0, ArgT... args); - std::string* mutable_oldphoto(); - PROTOBUF_NODISCARD std::string* release_oldphoto(); - void set_allocated_oldphoto(std::string* oldphoto); - private: - const std::string& _internal_oldphoto() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_oldphoto(const std::string& value); - std::string* _internal_mutable_oldphoto(); - public: - - // optional bytes newPhoto = 2; - bool has_newphoto() const; - private: - bool _internal_has_newphoto() const; - public: - void clear_newphoto(); - const std::string& newphoto() const; - template - void set_newphoto(ArgT0&& arg0, ArgT... args); - std::string* mutable_newphoto(); - PROTOBUF_NODISCARD std::string* release_newphoto(); - void set_allocated_newphoto(std::string* newphoto); - private: - const std::string& _internal_newphoto() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_newphoto(const std::string& value); - std::string* _internal_mutable_newphoto(); - public: - - // optional uint32 newPhotoId = 3; - bool has_newphotoid() const; - private: - bool _internal_has_newphotoid() const; - public: - void clear_newphotoid(); - uint32_t newphotoid() const; - void set_newphotoid(uint32_t value); - private: - uint32_t _internal_newphotoid() const; - void _internal_set_newphotoid(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.PhotoChange) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr oldphoto_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr newphoto_; - uint32_t newphotoid_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Point final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Point) */ { - public: - inline Point() : Point(nullptr) {} - ~Point() override; - explicit PROTOBUF_CONSTEXPR Point(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Point(const Point& from); - Point(Point&& from) noexcept - : Point() { - *this = ::std::move(from); - } - - inline Point& operator=(const Point& from) { - CopyFrom(from); - return *this; - } - inline Point& operator=(Point&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Point& default_instance() { - return *internal_default_instance(); - } - static inline const Point* internal_default_instance() { - return reinterpret_cast( - &_Point_default_instance_); - } - static constexpr int kIndexInFileMessages = - 155; - - friend void swap(Point& a, Point& b) { - a.Swap(&b); - } - inline void Swap(Point* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Point* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Point* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Point& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Point& from) { - Point::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Point* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Point"; - } - protected: - explicit Point(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kXDeprecatedFieldNumber = 1, - kYDeprecatedFieldNumber = 2, - kXFieldNumber = 3, - kYFieldNumber = 4, - }; - // optional int32 xDeprecated = 1; - bool has_xdeprecated() const; - private: - bool _internal_has_xdeprecated() const; - public: - void clear_xdeprecated(); - int32_t xdeprecated() const; - void set_xdeprecated(int32_t value); - private: - int32_t _internal_xdeprecated() const; - void _internal_set_xdeprecated(int32_t value); - public: - - // optional int32 yDeprecated = 2; - bool has_ydeprecated() const; - private: - bool _internal_has_ydeprecated() const; - public: - void clear_ydeprecated(); - int32_t ydeprecated() const; - void set_ydeprecated(int32_t value); - private: - int32_t _internal_ydeprecated() const; - void _internal_set_ydeprecated(int32_t value); - public: - - // optional double x = 3; - bool has_x() const; - private: - bool _internal_has_x() const; - public: - void clear_x(); - double x() const; - void set_x(double value); - private: - double _internal_x() const; - void _internal_set_x(double value); - public: - - // optional double y = 4; - bool has_y() const; - private: - bool _internal_has_y() const; - public: - void clear_y(); - double y() const; - void set_y(double value); - private: - double _internal_y() const; - void _internal_set_y(double value); - public: - - // @@protoc_insertion_point(class_scope:proto.Point) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - int32_t xdeprecated_; - int32_t ydeprecated_; - double x_; - double y_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class PollAdditionalMetadata final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PollAdditionalMetadata) */ { - public: - inline PollAdditionalMetadata() : PollAdditionalMetadata(nullptr) {} - ~PollAdditionalMetadata() override; - explicit PROTOBUF_CONSTEXPR PollAdditionalMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - PollAdditionalMetadata(const PollAdditionalMetadata& from); - PollAdditionalMetadata(PollAdditionalMetadata&& from) noexcept - : PollAdditionalMetadata() { - *this = ::std::move(from); - } - - inline PollAdditionalMetadata& operator=(const PollAdditionalMetadata& from) { - CopyFrom(from); - return *this; - } - inline PollAdditionalMetadata& operator=(PollAdditionalMetadata&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const PollAdditionalMetadata& default_instance() { - return *internal_default_instance(); - } - static inline const PollAdditionalMetadata* internal_default_instance() { - return reinterpret_cast( - &_PollAdditionalMetadata_default_instance_); - } - static constexpr int kIndexInFileMessages = - 156; - - friend void swap(PollAdditionalMetadata& a, PollAdditionalMetadata& b) { - a.Swap(&b); - } - inline void Swap(PollAdditionalMetadata* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(PollAdditionalMetadata* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - PollAdditionalMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const PollAdditionalMetadata& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const PollAdditionalMetadata& from) { - PollAdditionalMetadata::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(PollAdditionalMetadata* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.PollAdditionalMetadata"; - } - protected: - explicit PollAdditionalMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kPollInvalidatedFieldNumber = 1, - }; - // optional bool pollInvalidated = 1; - bool has_pollinvalidated() const; - private: - bool _internal_has_pollinvalidated() const; - public: - void clear_pollinvalidated(); - bool pollinvalidated() const; - void set_pollinvalidated(bool value); - private: - bool _internal_pollinvalidated() const; - void _internal_set_pollinvalidated(bool value); - public: - - // @@protoc_insertion_point(class_scope:proto.PollAdditionalMetadata) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - bool pollinvalidated_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class PollEncValue final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PollEncValue) */ { - public: - inline PollEncValue() : PollEncValue(nullptr) {} - ~PollEncValue() override; - explicit PROTOBUF_CONSTEXPR PollEncValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - PollEncValue(const PollEncValue& from); - PollEncValue(PollEncValue&& from) noexcept - : PollEncValue() { - *this = ::std::move(from); - } - - inline PollEncValue& operator=(const PollEncValue& from) { - CopyFrom(from); - return *this; - } - inline PollEncValue& operator=(PollEncValue&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const PollEncValue& default_instance() { - return *internal_default_instance(); - } - static inline const PollEncValue* internal_default_instance() { - return reinterpret_cast( - &_PollEncValue_default_instance_); - } - static constexpr int kIndexInFileMessages = - 157; - - friend void swap(PollEncValue& a, PollEncValue& b) { - a.Swap(&b); - } - inline void Swap(PollEncValue* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(PollEncValue* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - PollEncValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const PollEncValue& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const PollEncValue& from) { - PollEncValue::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(PollEncValue* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.PollEncValue"; - } - protected: - explicit PollEncValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kEncPayloadFieldNumber = 1, - kEncIvFieldNumber = 2, - }; - // optional bytes encPayload = 1; - bool has_encpayload() const; - private: - bool _internal_has_encpayload() const; - public: - void clear_encpayload(); - const std::string& encpayload() const; - template - void set_encpayload(ArgT0&& arg0, ArgT... args); - std::string* mutable_encpayload(); - PROTOBUF_NODISCARD std::string* release_encpayload(); - void set_allocated_encpayload(std::string* encpayload); - private: - const std::string& _internal_encpayload() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_encpayload(const std::string& value); - std::string* _internal_mutable_encpayload(); - public: - - // optional bytes encIv = 2; - bool has_enciv() const; - private: - bool _internal_has_enciv() const; - public: - void clear_enciv(); - const std::string& enciv() const; - template - void set_enciv(ArgT0&& arg0, ArgT... args); - std::string* mutable_enciv(); - PROTOBUF_NODISCARD std::string* release_enciv(); - void set_allocated_enciv(std::string* enciv); - private: - const std::string& _internal_enciv() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_enciv(const std::string& value); - std::string* _internal_mutable_enciv(); - public: - - // @@protoc_insertion_point(class_scope:proto.PollEncValue) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encpayload_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr enciv_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class PollUpdate final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PollUpdate) */ { - public: - inline PollUpdate() : PollUpdate(nullptr) {} - ~PollUpdate() override; - explicit PROTOBUF_CONSTEXPR PollUpdate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - PollUpdate(const PollUpdate& from); - PollUpdate(PollUpdate&& from) noexcept - : PollUpdate() { - *this = ::std::move(from); - } - - inline PollUpdate& operator=(const PollUpdate& from) { - CopyFrom(from); - return *this; - } - inline PollUpdate& operator=(PollUpdate&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const PollUpdate& default_instance() { - return *internal_default_instance(); - } - static inline const PollUpdate* internal_default_instance() { - return reinterpret_cast( - &_PollUpdate_default_instance_); - } - static constexpr int kIndexInFileMessages = - 158; - - friend void swap(PollUpdate& a, PollUpdate& b) { - a.Swap(&b); - } - inline void Swap(PollUpdate* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(PollUpdate* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - PollUpdate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const PollUpdate& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const PollUpdate& from) { - PollUpdate::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(PollUpdate* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.PollUpdate"; - } - protected: - explicit PollUpdate(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kPollUpdateMessageKeyFieldNumber = 1, - kVoteFieldNumber = 2, - kSenderTimestampMsFieldNumber = 3, - }; - // optional .proto.MessageKey pollUpdateMessageKey = 1; - bool has_pollupdatemessagekey() const; - private: - bool _internal_has_pollupdatemessagekey() const; - public: - void clear_pollupdatemessagekey(); - const ::proto::MessageKey& pollupdatemessagekey() const; - PROTOBUF_NODISCARD ::proto::MessageKey* release_pollupdatemessagekey(); - ::proto::MessageKey* mutable_pollupdatemessagekey(); - void set_allocated_pollupdatemessagekey(::proto::MessageKey* pollupdatemessagekey); - private: - const ::proto::MessageKey& _internal_pollupdatemessagekey() const; - ::proto::MessageKey* _internal_mutable_pollupdatemessagekey(); - public: - void unsafe_arena_set_allocated_pollupdatemessagekey( - ::proto::MessageKey* pollupdatemessagekey); - ::proto::MessageKey* unsafe_arena_release_pollupdatemessagekey(); - - // optional .proto.Message.PollVoteMessage vote = 2; - bool has_vote() const; - private: - bool _internal_has_vote() const; - public: - void clear_vote(); - const ::proto::Message_PollVoteMessage& vote() const; - PROTOBUF_NODISCARD ::proto::Message_PollVoteMessage* release_vote(); - ::proto::Message_PollVoteMessage* mutable_vote(); - void set_allocated_vote(::proto::Message_PollVoteMessage* vote); - private: - const ::proto::Message_PollVoteMessage& _internal_vote() const; - ::proto::Message_PollVoteMessage* _internal_mutable_vote(); - public: - void unsafe_arena_set_allocated_vote( - ::proto::Message_PollVoteMessage* vote); - ::proto::Message_PollVoteMessage* unsafe_arena_release_vote(); - - // optional int64 senderTimestampMs = 3; - bool has_sendertimestampms() const; - private: - bool _internal_has_sendertimestampms() const; - public: - void clear_sendertimestampms(); - int64_t sendertimestampms() const; - void set_sendertimestampms(int64_t value); - private: - int64_t _internal_sendertimestampms() const; - void _internal_set_sendertimestampms(int64_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.PollUpdate) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::proto::MessageKey* pollupdatemessagekey_; - ::proto::Message_PollVoteMessage* vote_; - int64_t sendertimestampms_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class PreKeyRecordStructure final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PreKeyRecordStructure) */ { - public: - inline PreKeyRecordStructure() : PreKeyRecordStructure(nullptr) {} - ~PreKeyRecordStructure() override; - explicit PROTOBUF_CONSTEXPR PreKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - PreKeyRecordStructure(const PreKeyRecordStructure& from); - PreKeyRecordStructure(PreKeyRecordStructure&& from) noexcept - : PreKeyRecordStructure() { - *this = ::std::move(from); - } - - inline PreKeyRecordStructure& operator=(const PreKeyRecordStructure& from) { - CopyFrom(from); - return *this; - } - inline PreKeyRecordStructure& operator=(PreKeyRecordStructure&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const PreKeyRecordStructure& default_instance() { - return *internal_default_instance(); - } - static inline const PreKeyRecordStructure* internal_default_instance() { - return reinterpret_cast( - &_PreKeyRecordStructure_default_instance_); - } - static constexpr int kIndexInFileMessages = - 159; - - friend void swap(PreKeyRecordStructure& a, PreKeyRecordStructure& b) { - a.Swap(&b); - } - inline void Swap(PreKeyRecordStructure* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(PreKeyRecordStructure* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - PreKeyRecordStructure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const PreKeyRecordStructure& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const PreKeyRecordStructure& from) { - PreKeyRecordStructure::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(PreKeyRecordStructure* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.PreKeyRecordStructure"; - } - protected: - explicit PreKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kPublicKeyFieldNumber = 2, - kPrivateKeyFieldNumber = 3, - kIdFieldNumber = 1, - }; - // optional bytes publicKey = 2; - bool has_publickey() const; - private: - bool _internal_has_publickey() const; - public: - void clear_publickey(); - const std::string& publickey() const; - template - void set_publickey(ArgT0&& arg0, ArgT... args); - std::string* mutable_publickey(); - PROTOBUF_NODISCARD std::string* release_publickey(); - void set_allocated_publickey(std::string* publickey); - private: - const std::string& _internal_publickey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_publickey(const std::string& value); - std::string* _internal_mutable_publickey(); - public: - - // optional bytes privateKey = 3; - bool has_privatekey() const; - private: - bool _internal_has_privatekey() const; - public: - void clear_privatekey(); - const std::string& privatekey() const; - template - void set_privatekey(ArgT0&& arg0, ArgT... args); - std::string* mutable_privatekey(); - PROTOBUF_NODISCARD std::string* release_privatekey(); - void set_allocated_privatekey(std::string* privatekey); - private: - const std::string& _internal_privatekey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_privatekey(const std::string& value); - std::string* _internal_mutable_privatekey(); - public: - - // optional uint32 id = 1; - bool has_id() const; - private: - bool _internal_has_id() const; - public: - void clear_id(); - uint32_t id() const; - void set_id(uint32_t value); - private: - uint32_t _internal_id() const; - void _internal_set_id(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.PreKeyRecordStructure) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr publickey_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr privatekey_; - uint32_t id_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Pushname final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Pushname) */ { - public: - inline Pushname() : Pushname(nullptr) {} - ~Pushname() override; - explicit PROTOBUF_CONSTEXPR Pushname(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Pushname(const Pushname& from); - Pushname(Pushname&& from) noexcept - : Pushname() { - *this = ::std::move(from); - } - - inline Pushname& operator=(const Pushname& from) { - CopyFrom(from); - return *this; - } - inline Pushname& operator=(Pushname&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Pushname& default_instance() { - return *internal_default_instance(); - } - static inline const Pushname* internal_default_instance() { - return reinterpret_cast( - &_Pushname_default_instance_); - } - static constexpr int kIndexInFileMessages = - 160; - - friend void swap(Pushname& a, Pushname& b) { - a.Swap(&b); - } - inline void Swap(Pushname* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Pushname* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Pushname* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Pushname& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Pushname& from) { - Pushname::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Pushname* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Pushname"; - } - protected: - explicit Pushname(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kIdFieldNumber = 1, - kPushnameFieldNumber = 2, - }; - // optional string id = 1; - bool has_id() const; - private: - bool _internal_has_id() const; - public: - void clear_id(); - const std::string& id() const; - template - void set_id(ArgT0&& arg0, ArgT... args); - std::string* mutable_id(); - PROTOBUF_NODISCARD std::string* release_id(); - void set_allocated_id(std::string* id); - private: - const std::string& _internal_id() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value); - std::string* _internal_mutable_id(); - public: - - // optional string pushname = 2; - bool has_pushname() const; - private: - bool _internal_has_pushname() const; - public: - void clear_pushname(); - const std::string& pushname() const; - template - void set_pushname(ArgT0&& arg0, ArgT... args); - std::string* mutable_pushname(); - PROTOBUF_NODISCARD std::string* release_pushname(); - void set_allocated_pushname(std::string* pushname); - private: - const std::string& _internal_pushname() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_pushname(const std::string& value); - std::string* _internal_mutable_pushname(); - public: - - // @@protoc_insertion_point(class_scope:proto.Pushname) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pushname_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class Reaction final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Reaction) */ { - public: - inline Reaction() : Reaction(nullptr) {} - ~Reaction() override; - explicit PROTOBUF_CONSTEXPR Reaction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Reaction(const Reaction& from); - Reaction(Reaction&& from) noexcept - : Reaction() { - *this = ::std::move(from); - } - - inline Reaction& operator=(const Reaction& from) { - CopyFrom(from); - return *this; - } - inline Reaction& operator=(Reaction&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const Reaction& default_instance() { - return *internal_default_instance(); - } - static inline const Reaction* internal_default_instance() { - return reinterpret_cast( - &_Reaction_default_instance_); - } - static constexpr int kIndexInFileMessages = - 161; - - friend void swap(Reaction& a, Reaction& b) { - a.Swap(&b); - } - inline void Swap(Reaction* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Reaction* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Reaction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Reaction& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const Reaction& from) { - Reaction::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Reaction* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.Reaction"; - } - protected: - explicit Reaction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kTextFieldNumber = 2, - kGroupingKeyFieldNumber = 3, - kKeyFieldNumber = 1, - kSenderTimestampMsFieldNumber = 4, - kUnreadFieldNumber = 5, - }; - // optional string text = 2; - bool has_text() const; - private: - bool _internal_has_text() const; - public: - void clear_text(); - const std::string& text() const; - template - void set_text(ArgT0&& arg0, ArgT... args); - std::string* mutable_text(); - PROTOBUF_NODISCARD std::string* release_text(); - void set_allocated_text(std::string* text); - private: - const std::string& _internal_text() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value); - std::string* _internal_mutable_text(); - public: - - // optional string groupingKey = 3; - bool has_groupingkey() const; - private: - bool _internal_has_groupingkey() const; - public: - void clear_groupingkey(); - const std::string& groupingkey() const; - template - void set_groupingkey(ArgT0&& arg0, ArgT... args); - std::string* mutable_groupingkey(); - PROTOBUF_NODISCARD std::string* release_groupingkey(); - void set_allocated_groupingkey(std::string* groupingkey); - private: - const std::string& _internal_groupingkey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_groupingkey(const std::string& value); - std::string* _internal_mutable_groupingkey(); - public: - - // optional .proto.MessageKey key = 1; - bool has_key() const; - private: - bool _internal_has_key() const; - public: - void clear_key(); - const ::proto::MessageKey& key() const; - PROTOBUF_NODISCARD ::proto::MessageKey* release_key(); - ::proto::MessageKey* mutable_key(); - void set_allocated_key(::proto::MessageKey* key); - private: - const ::proto::MessageKey& _internal_key() const; - ::proto::MessageKey* _internal_mutable_key(); - public: - void unsafe_arena_set_allocated_key( - ::proto::MessageKey* key); - ::proto::MessageKey* unsafe_arena_release_key(); - - // optional int64 senderTimestampMs = 4; - bool has_sendertimestampms() const; - private: - bool _internal_has_sendertimestampms() const; - public: - void clear_sendertimestampms(); - int64_t sendertimestampms() const; - void set_sendertimestampms(int64_t value); - private: - int64_t _internal_sendertimestampms() const; - void _internal_set_sendertimestampms(int64_t value); - public: - - // optional bool unread = 5; - bool has_unread() const; - private: - bool _internal_has_unread() const; - public: - void clear_unread(); - bool unread() const; - void set_unread(bool value); - private: - bool _internal_unread() const; - void _internal_set_unread(bool value); - public: - - // @@protoc_insertion_point(class_scope:proto.Reaction) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr groupingkey_; - ::proto::MessageKey* key_; - int64_t sendertimestampms_; - bool unread_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class RecentEmojiWeight final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.RecentEmojiWeight) */ { - public: - inline RecentEmojiWeight() : RecentEmojiWeight(nullptr) {} - ~RecentEmojiWeight() override; - explicit PROTOBUF_CONSTEXPR RecentEmojiWeight(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - RecentEmojiWeight(const RecentEmojiWeight& from); - RecentEmojiWeight(RecentEmojiWeight&& from) noexcept - : RecentEmojiWeight() { - *this = ::std::move(from); - } - - inline RecentEmojiWeight& operator=(const RecentEmojiWeight& from) { - CopyFrom(from); - return *this; - } - inline RecentEmojiWeight& operator=(RecentEmojiWeight&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const RecentEmojiWeight& default_instance() { - return *internal_default_instance(); - } - static inline const RecentEmojiWeight* internal_default_instance() { - return reinterpret_cast( - &_RecentEmojiWeight_default_instance_); - } - static constexpr int kIndexInFileMessages = - 162; - - friend void swap(RecentEmojiWeight& a, RecentEmojiWeight& b) { - a.Swap(&b); - } - inline void Swap(RecentEmojiWeight* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(RecentEmojiWeight* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - RecentEmojiWeight* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const RecentEmojiWeight& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const RecentEmojiWeight& from) { - RecentEmojiWeight::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(RecentEmojiWeight* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.RecentEmojiWeight"; - } - protected: - explicit RecentEmojiWeight(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kEmojiFieldNumber = 1, - kWeightFieldNumber = 2, - }; - // optional string emoji = 1; - bool has_emoji() const; - private: - bool _internal_has_emoji() const; - public: - void clear_emoji(); - const std::string& emoji() const; - template - void set_emoji(ArgT0&& arg0, ArgT... args); - std::string* mutable_emoji(); - PROTOBUF_NODISCARD std::string* release_emoji(); - void set_allocated_emoji(std::string* emoji); - private: - const std::string& _internal_emoji() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_emoji(const std::string& value); - std::string* _internal_mutable_emoji(); - public: - - // optional float weight = 2; - bool has_weight() const; - private: - bool _internal_has_weight() const; - public: - void clear_weight(); - float weight() const; - void set_weight(float value); - private: - float _internal_weight() const; - void _internal_set_weight(float value); - public: - - // @@protoc_insertion_point(class_scope:proto.RecentEmojiWeight) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr emoji_; - float weight_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class RecordStructure final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.RecordStructure) */ { - public: - inline RecordStructure() : RecordStructure(nullptr) {} - ~RecordStructure() override; - explicit PROTOBUF_CONSTEXPR RecordStructure(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - RecordStructure(const RecordStructure& from); - RecordStructure(RecordStructure&& from) noexcept - : RecordStructure() { - *this = ::std::move(from); - } - - inline RecordStructure& operator=(const RecordStructure& from) { - CopyFrom(from); - return *this; - } - inline RecordStructure& operator=(RecordStructure&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const RecordStructure& default_instance() { - return *internal_default_instance(); - } - static inline const RecordStructure* internal_default_instance() { - return reinterpret_cast( - &_RecordStructure_default_instance_); - } - static constexpr int kIndexInFileMessages = - 163; - - friend void swap(RecordStructure& a, RecordStructure& b) { - a.Swap(&b); - } - inline void Swap(RecordStructure* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(RecordStructure* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - RecordStructure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const RecordStructure& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const RecordStructure& from) { - RecordStructure::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(RecordStructure* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.RecordStructure"; - } - protected: - explicit RecordStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kPreviousSessionsFieldNumber = 2, - kCurrentSessionFieldNumber = 1, - }; - // repeated .proto.SessionStructure previousSessions = 2; - int previoussessions_size() const; - private: - int _internal_previoussessions_size() const; - public: - void clear_previoussessions(); - ::proto::SessionStructure* mutable_previoussessions(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SessionStructure >* - mutable_previoussessions(); - private: - const ::proto::SessionStructure& _internal_previoussessions(int index) const; - ::proto::SessionStructure* _internal_add_previoussessions(); - public: - const ::proto::SessionStructure& previoussessions(int index) const; - ::proto::SessionStructure* add_previoussessions(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SessionStructure >& - previoussessions() const; - - // optional .proto.SessionStructure currentSession = 1; - bool has_currentsession() const; - private: - bool _internal_has_currentsession() const; - public: - void clear_currentsession(); - const ::proto::SessionStructure& currentsession() const; - PROTOBUF_NODISCARD ::proto::SessionStructure* release_currentsession(); - ::proto::SessionStructure* mutable_currentsession(); - void set_allocated_currentsession(::proto::SessionStructure* currentsession); - private: - const ::proto::SessionStructure& _internal_currentsession() const; - ::proto::SessionStructure* _internal_mutable_currentsession(); - public: - void unsafe_arena_set_allocated_currentsession( - ::proto::SessionStructure* currentsession); - ::proto::SessionStructure* unsafe_arena_release_currentsession(); - - // @@protoc_insertion_point(class_scope:proto.RecordStructure) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SessionStructure > previoussessions_; - ::proto::SessionStructure* currentsession_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SenderChainKey final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SenderChainKey) */ { - public: - inline SenderChainKey() : SenderChainKey(nullptr) {} - ~SenderChainKey() override; - explicit PROTOBUF_CONSTEXPR SenderChainKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SenderChainKey(const SenderChainKey& from); - SenderChainKey(SenderChainKey&& from) noexcept - : SenderChainKey() { - *this = ::std::move(from); - } - - inline SenderChainKey& operator=(const SenderChainKey& from) { - CopyFrom(from); - return *this; - } - inline SenderChainKey& operator=(SenderChainKey&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SenderChainKey& default_instance() { - return *internal_default_instance(); - } - static inline const SenderChainKey* internal_default_instance() { - return reinterpret_cast( - &_SenderChainKey_default_instance_); - } - static constexpr int kIndexInFileMessages = - 164; - - friend void swap(SenderChainKey& a, SenderChainKey& b) { - a.Swap(&b); - } - inline void Swap(SenderChainKey* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SenderChainKey* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SenderChainKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SenderChainKey& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SenderChainKey& from) { - SenderChainKey::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SenderChainKey* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SenderChainKey"; - } - protected: - explicit SenderChainKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kSeedFieldNumber = 2, - kIterationFieldNumber = 1, - }; - // optional bytes seed = 2; - bool has_seed() const; - private: - bool _internal_has_seed() const; - public: - void clear_seed(); - const std::string& seed() const; - template - void set_seed(ArgT0&& arg0, ArgT... args); - std::string* mutable_seed(); - PROTOBUF_NODISCARD std::string* release_seed(); - void set_allocated_seed(std::string* seed); - private: - const std::string& _internal_seed() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_seed(const std::string& value); - std::string* _internal_mutable_seed(); - public: - - // optional uint32 iteration = 1; - bool has_iteration() const; - private: - bool _internal_has_iteration() const; - public: - void clear_iteration(); - uint32_t iteration() const; - void set_iteration(uint32_t value); - private: - uint32_t _internal_iteration() const; - void _internal_set_iteration(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.SenderChainKey) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr seed_; - uint32_t iteration_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SenderKeyRecordStructure final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SenderKeyRecordStructure) */ { - public: - inline SenderKeyRecordStructure() : SenderKeyRecordStructure(nullptr) {} - ~SenderKeyRecordStructure() override; - explicit PROTOBUF_CONSTEXPR SenderKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SenderKeyRecordStructure(const SenderKeyRecordStructure& from); - SenderKeyRecordStructure(SenderKeyRecordStructure&& from) noexcept - : SenderKeyRecordStructure() { - *this = ::std::move(from); - } - - inline SenderKeyRecordStructure& operator=(const SenderKeyRecordStructure& from) { - CopyFrom(from); - return *this; - } - inline SenderKeyRecordStructure& operator=(SenderKeyRecordStructure&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SenderKeyRecordStructure& default_instance() { - return *internal_default_instance(); - } - static inline const SenderKeyRecordStructure* internal_default_instance() { - return reinterpret_cast( - &_SenderKeyRecordStructure_default_instance_); - } - static constexpr int kIndexInFileMessages = - 165; - - friend void swap(SenderKeyRecordStructure& a, SenderKeyRecordStructure& b) { - a.Swap(&b); - } - inline void Swap(SenderKeyRecordStructure* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SenderKeyRecordStructure* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SenderKeyRecordStructure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SenderKeyRecordStructure& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SenderKeyRecordStructure& from) { - SenderKeyRecordStructure::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SenderKeyRecordStructure* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SenderKeyRecordStructure"; - } - protected: - explicit SenderKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kSenderKeyStatesFieldNumber = 1, - }; - // repeated .proto.SenderKeyStateStructure senderKeyStates = 1; - int senderkeystates_size() const; - private: - int _internal_senderkeystates_size() const; - public: - void clear_senderkeystates(); - ::proto::SenderKeyStateStructure* mutable_senderkeystates(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderKeyStateStructure >* - mutable_senderkeystates(); - private: - const ::proto::SenderKeyStateStructure& _internal_senderkeystates(int index) const; - ::proto::SenderKeyStateStructure* _internal_add_senderkeystates(); - public: - const ::proto::SenderKeyStateStructure& senderkeystates(int index) const; - ::proto::SenderKeyStateStructure* add_senderkeystates(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderKeyStateStructure >& - senderkeystates() const; - - // @@protoc_insertion_point(class_scope:proto.SenderKeyRecordStructure) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderKeyStateStructure > senderkeystates_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SenderKeyStateStructure final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SenderKeyStateStructure) */ { - public: - inline SenderKeyStateStructure() : SenderKeyStateStructure(nullptr) {} - ~SenderKeyStateStructure() override; - explicit PROTOBUF_CONSTEXPR SenderKeyStateStructure(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SenderKeyStateStructure(const SenderKeyStateStructure& from); - SenderKeyStateStructure(SenderKeyStateStructure&& from) noexcept - : SenderKeyStateStructure() { - *this = ::std::move(from); - } - - inline SenderKeyStateStructure& operator=(const SenderKeyStateStructure& from) { - CopyFrom(from); - return *this; - } - inline SenderKeyStateStructure& operator=(SenderKeyStateStructure&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SenderKeyStateStructure& default_instance() { - return *internal_default_instance(); - } - static inline const SenderKeyStateStructure* internal_default_instance() { - return reinterpret_cast( - &_SenderKeyStateStructure_default_instance_); - } - static constexpr int kIndexInFileMessages = - 166; - - friend void swap(SenderKeyStateStructure& a, SenderKeyStateStructure& b) { - a.Swap(&b); - } - inline void Swap(SenderKeyStateStructure* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SenderKeyStateStructure* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SenderKeyStateStructure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SenderKeyStateStructure& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SenderKeyStateStructure& from) { - SenderKeyStateStructure::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SenderKeyStateStructure* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SenderKeyStateStructure"; - } - protected: - explicit SenderKeyStateStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kSenderMessageKeysFieldNumber = 4, - kSenderChainKeyFieldNumber = 2, - kSenderSigningKeyFieldNumber = 3, - kSenderKeyIdFieldNumber = 1, - }; - // repeated .proto.SenderMessageKey senderMessageKeys = 4; - int sendermessagekeys_size() const; - private: - int _internal_sendermessagekeys_size() const; - public: - void clear_sendermessagekeys(); - ::proto::SenderMessageKey* mutable_sendermessagekeys(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderMessageKey >* - mutable_sendermessagekeys(); - private: - const ::proto::SenderMessageKey& _internal_sendermessagekeys(int index) const; - ::proto::SenderMessageKey* _internal_add_sendermessagekeys(); - public: - const ::proto::SenderMessageKey& sendermessagekeys(int index) const; - ::proto::SenderMessageKey* add_sendermessagekeys(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderMessageKey >& - sendermessagekeys() const; - - // optional .proto.SenderChainKey senderChainKey = 2; - bool has_senderchainkey() const; - private: - bool _internal_has_senderchainkey() const; - public: - void clear_senderchainkey(); - const ::proto::SenderChainKey& senderchainkey() const; - PROTOBUF_NODISCARD ::proto::SenderChainKey* release_senderchainkey(); - ::proto::SenderChainKey* mutable_senderchainkey(); - void set_allocated_senderchainkey(::proto::SenderChainKey* senderchainkey); - private: - const ::proto::SenderChainKey& _internal_senderchainkey() const; - ::proto::SenderChainKey* _internal_mutable_senderchainkey(); - public: - void unsafe_arena_set_allocated_senderchainkey( - ::proto::SenderChainKey* senderchainkey); - ::proto::SenderChainKey* unsafe_arena_release_senderchainkey(); - - // optional .proto.SenderSigningKey senderSigningKey = 3; - bool has_sendersigningkey() const; - private: - bool _internal_has_sendersigningkey() const; - public: - void clear_sendersigningkey(); - const ::proto::SenderSigningKey& sendersigningkey() const; - PROTOBUF_NODISCARD ::proto::SenderSigningKey* release_sendersigningkey(); - ::proto::SenderSigningKey* mutable_sendersigningkey(); - void set_allocated_sendersigningkey(::proto::SenderSigningKey* sendersigningkey); - private: - const ::proto::SenderSigningKey& _internal_sendersigningkey() const; - ::proto::SenderSigningKey* _internal_mutable_sendersigningkey(); - public: - void unsafe_arena_set_allocated_sendersigningkey( - ::proto::SenderSigningKey* sendersigningkey); - ::proto::SenderSigningKey* unsafe_arena_release_sendersigningkey(); - - // optional uint32 senderKeyId = 1; - bool has_senderkeyid() const; - private: - bool _internal_has_senderkeyid() const; - public: - void clear_senderkeyid(); - uint32_t senderkeyid() const; - void set_senderkeyid(uint32_t value); - private: - uint32_t _internal_senderkeyid() const; - void _internal_set_senderkeyid(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.SenderKeyStateStructure) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderMessageKey > sendermessagekeys_; - ::proto::SenderChainKey* senderchainkey_; - ::proto::SenderSigningKey* sendersigningkey_; - uint32_t senderkeyid_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SenderMessageKey final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SenderMessageKey) */ { - public: - inline SenderMessageKey() : SenderMessageKey(nullptr) {} - ~SenderMessageKey() override; - explicit PROTOBUF_CONSTEXPR SenderMessageKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SenderMessageKey(const SenderMessageKey& from); - SenderMessageKey(SenderMessageKey&& from) noexcept - : SenderMessageKey() { - *this = ::std::move(from); - } - - inline SenderMessageKey& operator=(const SenderMessageKey& from) { - CopyFrom(from); - return *this; - } - inline SenderMessageKey& operator=(SenderMessageKey&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SenderMessageKey& default_instance() { - return *internal_default_instance(); - } - static inline const SenderMessageKey* internal_default_instance() { - return reinterpret_cast( - &_SenderMessageKey_default_instance_); - } - static constexpr int kIndexInFileMessages = - 167; - - friend void swap(SenderMessageKey& a, SenderMessageKey& b) { - a.Swap(&b); - } - inline void Swap(SenderMessageKey* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SenderMessageKey* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SenderMessageKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SenderMessageKey& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SenderMessageKey& from) { - SenderMessageKey::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SenderMessageKey* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SenderMessageKey"; - } - protected: - explicit SenderMessageKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kSeedFieldNumber = 2, - kIterationFieldNumber = 1, - }; - // optional bytes seed = 2; - bool has_seed() const; - private: - bool _internal_has_seed() const; - public: - void clear_seed(); - const std::string& seed() const; - template - void set_seed(ArgT0&& arg0, ArgT... args); - std::string* mutable_seed(); - PROTOBUF_NODISCARD std::string* release_seed(); - void set_allocated_seed(std::string* seed); - private: - const std::string& _internal_seed() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_seed(const std::string& value); - std::string* _internal_mutable_seed(); - public: - - // optional uint32 iteration = 1; - bool has_iteration() const; - private: - bool _internal_has_iteration() const; - public: - void clear_iteration(); - uint32_t iteration() const; - void set_iteration(uint32_t value); - private: - uint32_t _internal_iteration() const; - void _internal_set_iteration(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.SenderMessageKey) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr seed_; - uint32_t iteration_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SenderSigningKey final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SenderSigningKey) */ { - public: - inline SenderSigningKey() : SenderSigningKey(nullptr) {} - ~SenderSigningKey() override; - explicit PROTOBUF_CONSTEXPR SenderSigningKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SenderSigningKey(const SenderSigningKey& from); - SenderSigningKey(SenderSigningKey&& from) noexcept - : SenderSigningKey() { - *this = ::std::move(from); - } - - inline SenderSigningKey& operator=(const SenderSigningKey& from) { - CopyFrom(from); - return *this; - } - inline SenderSigningKey& operator=(SenderSigningKey&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SenderSigningKey& default_instance() { - return *internal_default_instance(); - } - static inline const SenderSigningKey* internal_default_instance() { - return reinterpret_cast( - &_SenderSigningKey_default_instance_); - } - static constexpr int kIndexInFileMessages = - 168; - - friend void swap(SenderSigningKey& a, SenderSigningKey& b) { - a.Swap(&b); - } - inline void Swap(SenderSigningKey* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SenderSigningKey* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SenderSigningKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SenderSigningKey& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SenderSigningKey& from) { - SenderSigningKey::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SenderSigningKey* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SenderSigningKey"; - } - protected: - explicit SenderSigningKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kPublicFieldNumber = 1, - kPrivateFieldNumber = 2, - }; - // optional bytes public = 1; - bool has_public_() const; - private: - bool _internal_has_public_() const; - public: - void clear_public_(); - const std::string& public_() const; - template - void set_public_(ArgT0&& arg0, ArgT... args); - std::string* mutable_public_(); - PROTOBUF_NODISCARD std::string* release_public_(); - void set_allocated_public_(std::string* public_); - private: - const std::string& _internal_public_() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_public_(const std::string& value); - std::string* _internal_mutable_public_(); - public: - - // optional bytes private = 2; - bool has_private_() const; - private: - bool _internal_has_private_() const; - public: - void clear_private_(); - const std::string& private_() const; - template - void set_private_(ArgT0&& arg0, ArgT... args); - std::string* mutable_private_(); - PROTOBUF_NODISCARD std::string* release_private_(); - void set_allocated_private_(std::string* private_); - private: - const std::string& _internal_private_() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_private_(const std::string& value); - std::string* _internal_mutable_private_(); - public: - - // @@protoc_insertion_point(class_scope:proto.SenderSigningKey) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr public__; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr private__; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class ServerErrorReceipt final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ServerErrorReceipt) */ { - public: - inline ServerErrorReceipt() : ServerErrorReceipt(nullptr) {} - ~ServerErrorReceipt() override; - explicit PROTOBUF_CONSTEXPR ServerErrorReceipt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ServerErrorReceipt(const ServerErrorReceipt& from); - ServerErrorReceipt(ServerErrorReceipt&& from) noexcept - : ServerErrorReceipt() { - *this = ::std::move(from); - } - - inline ServerErrorReceipt& operator=(const ServerErrorReceipt& from) { - CopyFrom(from); - return *this; - } - inline ServerErrorReceipt& operator=(ServerErrorReceipt&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const ServerErrorReceipt& default_instance() { - return *internal_default_instance(); - } - static inline const ServerErrorReceipt* internal_default_instance() { - return reinterpret_cast( - &_ServerErrorReceipt_default_instance_); - } - static constexpr int kIndexInFileMessages = - 169; - - friend void swap(ServerErrorReceipt& a, ServerErrorReceipt& b) { - a.Swap(&b); - } - inline void Swap(ServerErrorReceipt* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ServerErrorReceipt* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ServerErrorReceipt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ServerErrorReceipt& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const ServerErrorReceipt& from) { - ServerErrorReceipt::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ServerErrorReceipt* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.ServerErrorReceipt"; - } - protected: - explicit ServerErrorReceipt(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kStanzaIdFieldNumber = 1, - }; - // optional string stanzaId = 1; - bool has_stanzaid() const; - private: - bool _internal_has_stanzaid() const; - public: - void clear_stanzaid(); - const std::string& stanzaid() const; - template - void set_stanzaid(ArgT0&& arg0, ArgT... args); - std::string* mutable_stanzaid(); - PROTOBUF_NODISCARD std::string* release_stanzaid(); - void set_allocated_stanzaid(std::string* stanzaid); - private: - const std::string& _internal_stanzaid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_stanzaid(const std::string& value); - std::string* _internal_mutable_stanzaid(); - public: - - // @@protoc_insertion_point(class_scope:proto.ServerErrorReceipt) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr stanzaid_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SessionStructure final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SessionStructure) */ { - public: - inline SessionStructure() : SessionStructure(nullptr) {} - ~SessionStructure() override; - explicit PROTOBUF_CONSTEXPR SessionStructure(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SessionStructure(const SessionStructure& from); - SessionStructure(SessionStructure&& from) noexcept - : SessionStructure() { - *this = ::std::move(from); - } - - inline SessionStructure& operator=(const SessionStructure& from) { - CopyFrom(from); - return *this; - } - inline SessionStructure& operator=(SessionStructure&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SessionStructure& default_instance() { - return *internal_default_instance(); - } - static inline const SessionStructure* internal_default_instance() { - return reinterpret_cast( - &_SessionStructure_default_instance_); - } - static constexpr int kIndexInFileMessages = - 170; - - friend void swap(SessionStructure& a, SessionStructure& b) { - a.Swap(&b); - } - inline void Swap(SessionStructure* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SessionStructure* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SessionStructure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SessionStructure& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SessionStructure& from) { - SessionStructure::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SessionStructure* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SessionStructure"; - } - protected: - explicit SessionStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kReceiverChainsFieldNumber = 7, - kLocalIdentityPublicFieldNumber = 2, - kRemoteIdentityPublicFieldNumber = 3, - kRootKeyFieldNumber = 4, - kAliceBaseKeyFieldNumber = 13, - kSenderChainFieldNumber = 6, - kPendingKeyExchangeFieldNumber = 8, - kPendingPreKeyFieldNumber = 9, - kSessionVersionFieldNumber = 1, - kPreviousCounterFieldNumber = 5, - kRemoteRegistrationIdFieldNumber = 10, - kLocalRegistrationIdFieldNumber = 11, - kNeedsRefreshFieldNumber = 12, - }; - // repeated .proto.Chain receiverChains = 7; - int receiverchains_size() const; - private: - int _internal_receiverchains_size() const; - public: - void clear_receiverchains(); - ::proto::Chain* mutable_receiverchains(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Chain >* - mutable_receiverchains(); - private: - const ::proto::Chain& _internal_receiverchains(int index) const; - ::proto::Chain* _internal_add_receiverchains(); - public: - const ::proto::Chain& receiverchains(int index) const; - ::proto::Chain* add_receiverchains(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Chain >& - receiverchains() const; - - // optional bytes localIdentityPublic = 2; - bool has_localidentitypublic() const; - private: - bool _internal_has_localidentitypublic() const; - public: - void clear_localidentitypublic(); - const std::string& localidentitypublic() const; - template - void set_localidentitypublic(ArgT0&& arg0, ArgT... args); - std::string* mutable_localidentitypublic(); - PROTOBUF_NODISCARD std::string* release_localidentitypublic(); - void set_allocated_localidentitypublic(std::string* localidentitypublic); - private: - const std::string& _internal_localidentitypublic() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_localidentitypublic(const std::string& value); - std::string* _internal_mutable_localidentitypublic(); - public: - - // optional bytes remoteIdentityPublic = 3; - bool has_remoteidentitypublic() const; - private: - bool _internal_has_remoteidentitypublic() const; - public: - void clear_remoteidentitypublic(); - const std::string& remoteidentitypublic() const; - template - void set_remoteidentitypublic(ArgT0&& arg0, ArgT... args); - std::string* mutable_remoteidentitypublic(); - PROTOBUF_NODISCARD std::string* release_remoteidentitypublic(); - void set_allocated_remoteidentitypublic(std::string* remoteidentitypublic); - private: - const std::string& _internal_remoteidentitypublic() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_remoteidentitypublic(const std::string& value); - std::string* _internal_mutable_remoteidentitypublic(); - public: - - // optional bytes rootKey = 4; - bool has_rootkey() const; - private: - bool _internal_has_rootkey() const; - public: - void clear_rootkey(); - const std::string& rootkey() const; - template - void set_rootkey(ArgT0&& arg0, ArgT... args); - std::string* mutable_rootkey(); - PROTOBUF_NODISCARD std::string* release_rootkey(); - void set_allocated_rootkey(std::string* rootkey); - private: - const std::string& _internal_rootkey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_rootkey(const std::string& value); - std::string* _internal_mutable_rootkey(); - public: - - // optional bytes aliceBaseKey = 13; - bool has_alicebasekey() const; - private: - bool _internal_has_alicebasekey() const; - public: - void clear_alicebasekey(); - const std::string& alicebasekey() const; - template - void set_alicebasekey(ArgT0&& arg0, ArgT... args); - std::string* mutable_alicebasekey(); - PROTOBUF_NODISCARD std::string* release_alicebasekey(); - void set_allocated_alicebasekey(std::string* alicebasekey); - private: - const std::string& _internal_alicebasekey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_alicebasekey(const std::string& value); - std::string* _internal_mutable_alicebasekey(); - public: - - // optional .proto.Chain senderChain = 6; - bool has_senderchain() const; - private: - bool _internal_has_senderchain() const; - public: - void clear_senderchain(); - const ::proto::Chain& senderchain() const; - PROTOBUF_NODISCARD ::proto::Chain* release_senderchain(); - ::proto::Chain* mutable_senderchain(); - void set_allocated_senderchain(::proto::Chain* senderchain); - private: - const ::proto::Chain& _internal_senderchain() const; - ::proto::Chain* _internal_mutable_senderchain(); - public: - void unsafe_arena_set_allocated_senderchain( - ::proto::Chain* senderchain); - ::proto::Chain* unsafe_arena_release_senderchain(); - - // optional .proto.PendingKeyExchange pendingKeyExchange = 8; - bool has_pendingkeyexchange() const; - private: - bool _internal_has_pendingkeyexchange() const; - public: - void clear_pendingkeyexchange(); - const ::proto::PendingKeyExchange& pendingkeyexchange() const; - PROTOBUF_NODISCARD ::proto::PendingKeyExchange* release_pendingkeyexchange(); - ::proto::PendingKeyExchange* mutable_pendingkeyexchange(); - void set_allocated_pendingkeyexchange(::proto::PendingKeyExchange* pendingkeyexchange); - private: - const ::proto::PendingKeyExchange& _internal_pendingkeyexchange() const; - ::proto::PendingKeyExchange* _internal_mutable_pendingkeyexchange(); - public: - void unsafe_arena_set_allocated_pendingkeyexchange( - ::proto::PendingKeyExchange* pendingkeyexchange); - ::proto::PendingKeyExchange* unsafe_arena_release_pendingkeyexchange(); - - // optional .proto.PendingPreKey pendingPreKey = 9; - bool has_pendingprekey() const; - private: - bool _internal_has_pendingprekey() const; - public: - void clear_pendingprekey(); - const ::proto::PendingPreKey& pendingprekey() const; - PROTOBUF_NODISCARD ::proto::PendingPreKey* release_pendingprekey(); - ::proto::PendingPreKey* mutable_pendingprekey(); - void set_allocated_pendingprekey(::proto::PendingPreKey* pendingprekey); - private: - const ::proto::PendingPreKey& _internal_pendingprekey() const; - ::proto::PendingPreKey* _internal_mutable_pendingprekey(); - public: - void unsafe_arena_set_allocated_pendingprekey( - ::proto::PendingPreKey* pendingprekey); - ::proto::PendingPreKey* unsafe_arena_release_pendingprekey(); - - // optional uint32 sessionVersion = 1; - bool has_sessionversion() const; - private: - bool _internal_has_sessionversion() const; - public: - void clear_sessionversion(); - uint32_t sessionversion() const; - void set_sessionversion(uint32_t value); - private: - uint32_t _internal_sessionversion() const; - void _internal_set_sessionversion(uint32_t value); - public: - - // optional uint32 previousCounter = 5; - bool has_previouscounter() const; - private: - bool _internal_has_previouscounter() const; - public: - void clear_previouscounter(); - uint32_t previouscounter() const; - void set_previouscounter(uint32_t value); - private: - uint32_t _internal_previouscounter() const; - void _internal_set_previouscounter(uint32_t value); - public: - - // optional uint32 remoteRegistrationId = 10; - bool has_remoteregistrationid() const; - private: - bool _internal_has_remoteregistrationid() const; - public: - void clear_remoteregistrationid(); - uint32_t remoteregistrationid() const; - void set_remoteregistrationid(uint32_t value); - private: - uint32_t _internal_remoteregistrationid() const; - void _internal_set_remoteregistrationid(uint32_t value); - public: - - // optional uint32 localRegistrationId = 11; - bool has_localregistrationid() const; - private: - bool _internal_has_localregistrationid() const; - public: - void clear_localregistrationid(); - uint32_t localregistrationid() const; - void set_localregistrationid(uint32_t value); - private: - uint32_t _internal_localregistrationid() const; - void _internal_set_localregistrationid(uint32_t value); - public: - - // optional bool needsRefresh = 12; - bool has_needsrefresh() const; - private: - bool _internal_has_needsrefresh() const; - public: - void clear_needsrefresh(); - bool needsrefresh() const; - void set_needsrefresh(bool value); - private: - bool _internal_needsrefresh() const; - void _internal_set_needsrefresh(bool value); - public: - - // @@protoc_insertion_point(class_scope:proto.SessionStructure) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Chain > receiverchains_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localidentitypublic_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr remoteidentitypublic_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rootkey_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr alicebasekey_; - ::proto::Chain* senderchain_; - ::proto::PendingKeyExchange* pendingkeyexchange_; - ::proto::PendingPreKey* pendingprekey_; - uint32_t sessionversion_; - uint32_t previouscounter_; - uint32_t remoteregistrationid_; - uint32_t localregistrationid_; - bool needsrefresh_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SignedPreKeyRecordStructure final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SignedPreKeyRecordStructure) */ { - public: - inline SignedPreKeyRecordStructure() : SignedPreKeyRecordStructure(nullptr) {} - ~SignedPreKeyRecordStructure() override; - explicit PROTOBUF_CONSTEXPR SignedPreKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SignedPreKeyRecordStructure(const SignedPreKeyRecordStructure& from); - SignedPreKeyRecordStructure(SignedPreKeyRecordStructure&& from) noexcept - : SignedPreKeyRecordStructure() { - *this = ::std::move(from); - } - - inline SignedPreKeyRecordStructure& operator=(const SignedPreKeyRecordStructure& from) { - CopyFrom(from); - return *this; - } - inline SignedPreKeyRecordStructure& operator=(SignedPreKeyRecordStructure&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SignedPreKeyRecordStructure& default_instance() { - return *internal_default_instance(); - } - static inline const SignedPreKeyRecordStructure* internal_default_instance() { - return reinterpret_cast( - &_SignedPreKeyRecordStructure_default_instance_); - } - static constexpr int kIndexInFileMessages = - 171; - - friend void swap(SignedPreKeyRecordStructure& a, SignedPreKeyRecordStructure& b) { - a.Swap(&b); - } - inline void Swap(SignedPreKeyRecordStructure* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SignedPreKeyRecordStructure* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SignedPreKeyRecordStructure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SignedPreKeyRecordStructure& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SignedPreKeyRecordStructure& from) { - SignedPreKeyRecordStructure::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SignedPreKeyRecordStructure* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SignedPreKeyRecordStructure"; - } - protected: - explicit SignedPreKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kPublicKeyFieldNumber = 2, - kPrivateKeyFieldNumber = 3, - kSignatureFieldNumber = 4, - kTimestampFieldNumber = 5, - kIdFieldNumber = 1, - }; - // optional bytes publicKey = 2; - bool has_publickey() const; - private: - bool _internal_has_publickey() const; - public: - void clear_publickey(); - const std::string& publickey() const; - template - void set_publickey(ArgT0&& arg0, ArgT... args); - std::string* mutable_publickey(); - PROTOBUF_NODISCARD std::string* release_publickey(); - void set_allocated_publickey(std::string* publickey); - private: - const std::string& _internal_publickey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_publickey(const std::string& value); - std::string* _internal_mutable_publickey(); - public: - - // optional bytes privateKey = 3; - bool has_privatekey() const; - private: - bool _internal_has_privatekey() const; - public: - void clear_privatekey(); - const std::string& privatekey() const; - template - void set_privatekey(ArgT0&& arg0, ArgT... args); - std::string* mutable_privatekey(); - PROTOBUF_NODISCARD std::string* release_privatekey(); - void set_allocated_privatekey(std::string* privatekey); - private: - const std::string& _internal_privatekey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_privatekey(const std::string& value); - std::string* _internal_mutable_privatekey(); - public: - - // optional bytes signature = 4; - bool has_signature() const; - private: - bool _internal_has_signature() const; - public: - void clear_signature(); - const std::string& signature() const; - template - void set_signature(ArgT0&& arg0, ArgT... args); - std::string* mutable_signature(); - PROTOBUF_NODISCARD std::string* release_signature(); - void set_allocated_signature(std::string* signature); - private: - const std::string& _internal_signature() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value); - std::string* _internal_mutable_signature(); - public: - - // optional fixed64 timestamp = 5; - bool has_timestamp() const; - private: - bool _internal_has_timestamp() const; - public: - void clear_timestamp(); - uint64_t timestamp() const; - void set_timestamp(uint64_t value); - private: - uint64_t _internal_timestamp() const; - void _internal_set_timestamp(uint64_t value); - public: - - // optional uint32 id = 1; - bool has_id() const; - private: - bool _internal_has_id() const; - public: - void clear_id(); - uint32_t id() const; - void set_id(uint32_t value); - private: - uint32_t _internal_id() const; - void _internal_set_id(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.SignedPreKeyRecordStructure) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr publickey_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr privatekey_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_; - uint64_t timestamp_; - uint32_t id_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class StatusPSA final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.StatusPSA) */ { - public: - inline StatusPSA() : StatusPSA(nullptr) {} - ~StatusPSA() override; - explicit PROTOBUF_CONSTEXPR StatusPSA(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - StatusPSA(const StatusPSA& from); - StatusPSA(StatusPSA&& from) noexcept - : StatusPSA() { - *this = ::std::move(from); - } - - inline StatusPSA& operator=(const StatusPSA& from) { - CopyFrom(from); - return *this; - } - inline StatusPSA& operator=(StatusPSA&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const StatusPSA& default_instance() { - return *internal_default_instance(); - } - static inline const StatusPSA* internal_default_instance() { - return reinterpret_cast( - &_StatusPSA_default_instance_); - } - static constexpr int kIndexInFileMessages = - 172; - - friend void swap(StatusPSA& a, StatusPSA& b) { - a.Swap(&b); - } - inline void Swap(StatusPSA* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(StatusPSA* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - StatusPSA* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const StatusPSA& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const StatusPSA& from) { - StatusPSA::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(StatusPSA* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.StatusPSA"; - } - protected: - explicit StatusPSA(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kCampaignIdFieldNumber = 44, - kCampaignExpirationTimestampFieldNumber = 45, - }; - // required uint64 campaignId = 44; - bool has_campaignid() const; - private: - bool _internal_has_campaignid() const; - public: - void clear_campaignid(); - uint64_t campaignid() const; - void set_campaignid(uint64_t value); - private: - uint64_t _internal_campaignid() const; - void _internal_set_campaignid(uint64_t value); - public: - - // optional uint64 campaignExpirationTimestamp = 45; - bool has_campaignexpirationtimestamp() const; - private: - bool _internal_has_campaignexpirationtimestamp() const; - public: - void clear_campaignexpirationtimestamp(); - uint64_t campaignexpirationtimestamp() const; - void set_campaignexpirationtimestamp(uint64_t value); - private: - uint64_t _internal_campaignexpirationtimestamp() const; - void _internal_set_campaignexpirationtimestamp(uint64_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.StatusPSA) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint64_t campaignid_; - uint64_t campaignexpirationtimestamp_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class StickerMetadata final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.StickerMetadata) */ { - public: - inline StickerMetadata() : StickerMetadata(nullptr) {} - ~StickerMetadata() override; - explicit PROTOBUF_CONSTEXPR StickerMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - StickerMetadata(const StickerMetadata& from); - StickerMetadata(StickerMetadata&& from) noexcept - : StickerMetadata() { - *this = ::std::move(from); - } - - inline StickerMetadata& operator=(const StickerMetadata& from) { - CopyFrom(from); - return *this; - } - inline StickerMetadata& operator=(StickerMetadata&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const StickerMetadata& default_instance() { - return *internal_default_instance(); - } - static inline const StickerMetadata* internal_default_instance() { - return reinterpret_cast( - &_StickerMetadata_default_instance_); - } - static constexpr int kIndexInFileMessages = - 173; - - friend void swap(StickerMetadata& a, StickerMetadata& b) { - a.Swap(&b); - } - inline void Swap(StickerMetadata* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(StickerMetadata* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - StickerMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const StickerMetadata& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const StickerMetadata& from) { - StickerMetadata::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(StickerMetadata* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.StickerMetadata"; - } - protected: - explicit StickerMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kUrlFieldNumber = 1, - kFileSha256FieldNumber = 2, - kFileEncSha256FieldNumber = 3, - kMediaKeyFieldNumber = 4, - kMimetypeFieldNumber = 5, - kDirectPathFieldNumber = 8, - kHeightFieldNumber = 6, - kWidthFieldNumber = 7, - kFileLengthFieldNumber = 9, - kWeightFieldNumber = 10, - }; - // optional string url = 1; - bool has_url() const; - private: - bool _internal_has_url() const; - public: - void clear_url(); - const std::string& url() const; - template - void set_url(ArgT0&& arg0, ArgT... args); - std::string* mutable_url(); - PROTOBUF_NODISCARD std::string* release_url(); - void set_allocated_url(std::string* url); - private: - const std::string& _internal_url() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value); - std::string* _internal_mutable_url(); - public: - - // optional bytes fileSha256 = 2; - bool has_filesha256() const; - private: - bool _internal_has_filesha256() const; - public: - void clear_filesha256(); - const std::string& filesha256() const; - template - void set_filesha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_filesha256(); - PROTOBUF_NODISCARD std::string* release_filesha256(); - void set_allocated_filesha256(std::string* filesha256); - private: - const std::string& _internal_filesha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value); - std::string* _internal_mutable_filesha256(); - public: - - // optional bytes fileEncSha256 = 3; - bool has_fileencsha256() const; - private: - bool _internal_has_fileencsha256() const; - public: - void clear_fileencsha256(); - const std::string& fileencsha256() const; - template - void set_fileencsha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_fileencsha256(); - PROTOBUF_NODISCARD std::string* release_fileencsha256(); - void set_allocated_fileencsha256(std::string* fileencsha256); - private: - const std::string& _internal_fileencsha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value); - std::string* _internal_mutable_fileencsha256(); - public: - - // optional bytes mediaKey = 4; - bool has_mediakey() const; - private: - bool _internal_has_mediakey() const; - public: - void clear_mediakey(); - const std::string& mediakey() const; - template - void set_mediakey(ArgT0&& arg0, ArgT... args); - std::string* mutable_mediakey(); - PROTOBUF_NODISCARD std::string* release_mediakey(); - void set_allocated_mediakey(std::string* mediakey); - private: - const std::string& _internal_mediakey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value); - std::string* _internal_mutable_mediakey(); - public: - - // optional string mimetype = 5; - bool has_mimetype() const; - private: - bool _internal_has_mimetype() const; - public: - void clear_mimetype(); - const std::string& mimetype() const; - template - void set_mimetype(ArgT0&& arg0, ArgT... args); - std::string* mutable_mimetype(); - PROTOBUF_NODISCARD std::string* release_mimetype(); - void set_allocated_mimetype(std::string* mimetype); - private: - const std::string& _internal_mimetype() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value); - std::string* _internal_mutable_mimetype(); - public: - - // optional string directPath = 8; - bool has_directpath() const; - private: - bool _internal_has_directpath() const; - public: - void clear_directpath(); - const std::string& directpath() const; - template - void set_directpath(ArgT0&& arg0, ArgT... args); - std::string* mutable_directpath(); - PROTOBUF_NODISCARD std::string* release_directpath(); - void set_allocated_directpath(std::string* directpath); - private: - const std::string& _internal_directpath() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value); - std::string* _internal_mutable_directpath(); - public: - - // optional uint32 height = 6; - bool has_height() const; - private: - bool _internal_has_height() const; - public: - void clear_height(); - uint32_t height() const; - void set_height(uint32_t value); - private: - uint32_t _internal_height() const; - void _internal_set_height(uint32_t value); - public: - - // optional uint32 width = 7; - bool has_width() const; - private: - bool _internal_has_width() const; - public: - void clear_width(); - uint32_t width() const; - void set_width(uint32_t value); - private: - uint32_t _internal_width() const; - void _internal_set_width(uint32_t value); - public: - - // optional uint64 fileLength = 9; - bool has_filelength() const; - private: - bool _internal_has_filelength() const; - public: - void clear_filelength(); - uint64_t filelength() const; - void set_filelength(uint64_t value); - private: - uint64_t _internal_filelength() const; - void _internal_set_filelength(uint64_t value); - public: - - // optional float weight = 10; - bool has_weight() const; - private: - bool _internal_has_weight() const; - public: - void clear_weight(); - float weight() const; - void set_weight(float value); - private: - float _internal_weight() const; - void _internal_set_weight(float value); - public: - - // @@protoc_insertion_point(class_scope:proto.StickerMetadata) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mimetype_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_; - uint32_t height_; - uint32_t width_; - uint64_t filelength_; - float weight_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncActionData final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionData) */ { - public: - inline SyncActionData() : SyncActionData(nullptr) {} - ~SyncActionData() override; - explicit PROTOBUF_CONSTEXPR SyncActionData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncActionData(const SyncActionData& from); - SyncActionData(SyncActionData&& from) noexcept - : SyncActionData() { - *this = ::std::move(from); - } - - inline SyncActionData& operator=(const SyncActionData& from) { - CopyFrom(from); - return *this; - } - inline SyncActionData& operator=(SyncActionData&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncActionData& default_instance() { - return *internal_default_instance(); - } - static inline const SyncActionData* internal_default_instance() { - return reinterpret_cast( - &_SyncActionData_default_instance_); - } - static constexpr int kIndexInFileMessages = - 174; - - friend void swap(SyncActionData& a, SyncActionData& b) { - a.Swap(&b); - } - inline void Swap(SyncActionData* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncActionData* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncActionData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncActionData& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncActionData& from) { - SyncActionData::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncActionData* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncActionData"; - } - protected: - explicit SyncActionData(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kIndexFieldNumber = 1, - kPaddingFieldNumber = 3, - kValueFieldNumber = 2, - kVersionFieldNumber = 4, - }; - // optional bytes index = 1; - bool has_index() const; - private: - bool _internal_has_index() const; - public: - void clear_index(); - const std::string& index() const; - template - void set_index(ArgT0&& arg0, ArgT... args); - std::string* mutable_index(); - PROTOBUF_NODISCARD std::string* release_index(); - void set_allocated_index(std::string* index); - private: - const std::string& _internal_index() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_index(const std::string& value); - std::string* _internal_mutable_index(); - public: - - // optional bytes padding = 3; - bool has_padding() const; - private: - bool _internal_has_padding() const; - public: - void clear_padding(); - const std::string& padding() const; - template - void set_padding(ArgT0&& arg0, ArgT... args); - std::string* mutable_padding(); - PROTOBUF_NODISCARD std::string* release_padding(); - void set_allocated_padding(std::string* padding); - private: - const std::string& _internal_padding() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_padding(const std::string& value); - std::string* _internal_mutable_padding(); - public: - - // optional .proto.SyncActionValue value = 2; - bool has_value() const; - private: - bool _internal_has_value() const; - public: - void clear_value(); - const ::proto::SyncActionValue& value() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue* release_value(); - ::proto::SyncActionValue* mutable_value(); - void set_allocated_value(::proto::SyncActionValue* value); - private: - const ::proto::SyncActionValue& _internal_value() const; - ::proto::SyncActionValue* _internal_mutable_value(); - public: - void unsafe_arena_set_allocated_value( - ::proto::SyncActionValue* value); - ::proto::SyncActionValue* unsafe_arena_release_value(); - - // optional int32 version = 4; - bool has_version() const; - private: - bool _internal_has_version() const; - public: - void clear_version(); - int32_t version() const; - void set_version(int32_t value); - private: - int32_t _internal_version() const; - void _internal_set_version(int32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncActionData) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr index_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr padding_; - ::proto::SyncActionValue* value_; - int32_t version_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncActionValue_AgentAction final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.AgentAction) */ { - public: - inline SyncActionValue_AgentAction() : SyncActionValue_AgentAction(nullptr) {} - ~SyncActionValue_AgentAction() override; - explicit PROTOBUF_CONSTEXPR SyncActionValue_AgentAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncActionValue_AgentAction(const SyncActionValue_AgentAction& from); - SyncActionValue_AgentAction(SyncActionValue_AgentAction&& from) noexcept - : SyncActionValue_AgentAction() { - *this = ::std::move(from); - } - - inline SyncActionValue_AgentAction& operator=(const SyncActionValue_AgentAction& from) { - CopyFrom(from); - return *this; - } - inline SyncActionValue_AgentAction& operator=(SyncActionValue_AgentAction&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncActionValue_AgentAction& default_instance() { - return *internal_default_instance(); - } - static inline const SyncActionValue_AgentAction* internal_default_instance() { - return reinterpret_cast( - &_SyncActionValue_AgentAction_default_instance_); - } - static constexpr int kIndexInFileMessages = - 175; - - friend void swap(SyncActionValue_AgentAction& a, SyncActionValue_AgentAction& b) { - a.Swap(&b); - } - inline void Swap(SyncActionValue_AgentAction* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncActionValue_AgentAction* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncActionValue_AgentAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncActionValue_AgentAction& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncActionValue_AgentAction& from) { - SyncActionValue_AgentAction::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncActionValue_AgentAction* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncActionValue.AgentAction"; - } - protected: - explicit SyncActionValue_AgentAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kNameFieldNumber = 1, - kDeviceIDFieldNumber = 2, - kIsDeletedFieldNumber = 3, - }; - // optional string name = 1; - bool has_name() const; - private: - bool _internal_has_name() const; - public: - void clear_name(); - const std::string& name() const; - template - void set_name(ArgT0&& arg0, ArgT... args); - std::string* mutable_name(); - PROTOBUF_NODISCARD std::string* release_name(); - void set_allocated_name(std::string* name); - private: - const std::string& _internal_name() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); - std::string* _internal_mutable_name(); - public: - - // optional int32 deviceID = 2; - bool has_deviceid() const; - private: - bool _internal_has_deviceid() const; - public: - void clear_deviceid(); - int32_t deviceid() const; - void set_deviceid(int32_t value); - private: - int32_t _internal_deviceid() const; - void _internal_set_deviceid(int32_t value); - public: - - // optional bool isDeleted = 3; - bool has_isdeleted() const; - private: - bool _internal_has_isdeleted() const; - public: - void clear_isdeleted(); - bool isdeleted() const; - void set_isdeleted(bool value); - private: - bool _internal_isdeleted() const; - void _internal_set_isdeleted(bool value); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncActionValue.AgentAction) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - int32_t deviceid_; - bool isdeleted_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncActionValue_AndroidUnsupportedActions final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.AndroidUnsupportedActions) */ { - public: - inline SyncActionValue_AndroidUnsupportedActions() : SyncActionValue_AndroidUnsupportedActions(nullptr) {} - ~SyncActionValue_AndroidUnsupportedActions() override; - explicit PROTOBUF_CONSTEXPR SyncActionValue_AndroidUnsupportedActions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncActionValue_AndroidUnsupportedActions(const SyncActionValue_AndroidUnsupportedActions& from); - SyncActionValue_AndroidUnsupportedActions(SyncActionValue_AndroidUnsupportedActions&& from) noexcept - : SyncActionValue_AndroidUnsupportedActions() { - *this = ::std::move(from); - } - - inline SyncActionValue_AndroidUnsupportedActions& operator=(const SyncActionValue_AndroidUnsupportedActions& from) { - CopyFrom(from); - return *this; - } - inline SyncActionValue_AndroidUnsupportedActions& operator=(SyncActionValue_AndroidUnsupportedActions&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncActionValue_AndroidUnsupportedActions& default_instance() { - return *internal_default_instance(); - } - static inline const SyncActionValue_AndroidUnsupportedActions* internal_default_instance() { - return reinterpret_cast( - &_SyncActionValue_AndroidUnsupportedActions_default_instance_); - } - static constexpr int kIndexInFileMessages = - 176; - - friend void swap(SyncActionValue_AndroidUnsupportedActions& a, SyncActionValue_AndroidUnsupportedActions& b) { - a.Swap(&b); - } - inline void Swap(SyncActionValue_AndroidUnsupportedActions* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncActionValue_AndroidUnsupportedActions* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncActionValue_AndroidUnsupportedActions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncActionValue_AndroidUnsupportedActions& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncActionValue_AndroidUnsupportedActions& from) { - SyncActionValue_AndroidUnsupportedActions::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncActionValue_AndroidUnsupportedActions* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncActionValue.AndroidUnsupportedActions"; - } - protected: - explicit SyncActionValue_AndroidUnsupportedActions(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kAllowedFieldNumber = 1, - }; - // optional bool allowed = 1; - bool has_allowed() const; - private: - bool _internal_has_allowed() const; - public: - void clear_allowed(); - bool allowed() const; - void set_allowed(bool value); - private: - bool _internal_allowed() const; - void _internal_set_allowed(bool value); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncActionValue.AndroidUnsupportedActions) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - bool allowed_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncActionValue_ArchiveChatAction final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.ArchiveChatAction) */ { - public: - inline SyncActionValue_ArchiveChatAction() : SyncActionValue_ArchiveChatAction(nullptr) {} - ~SyncActionValue_ArchiveChatAction() override; - explicit PROTOBUF_CONSTEXPR SyncActionValue_ArchiveChatAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncActionValue_ArchiveChatAction(const SyncActionValue_ArchiveChatAction& from); - SyncActionValue_ArchiveChatAction(SyncActionValue_ArchiveChatAction&& from) noexcept - : SyncActionValue_ArchiveChatAction() { - *this = ::std::move(from); - } - - inline SyncActionValue_ArchiveChatAction& operator=(const SyncActionValue_ArchiveChatAction& from) { - CopyFrom(from); - return *this; - } - inline SyncActionValue_ArchiveChatAction& operator=(SyncActionValue_ArchiveChatAction&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncActionValue_ArchiveChatAction& default_instance() { - return *internal_default_instance(); - } - static inline const SyncActionValue_ArchiveChatAction* internal_default_instance() { - return reinterpret_cast( - &_SyncActionValue_ArchiveChatAction_default_instance_); - } - static constexpr int kIndexInFileMessages = - 177; - - friend void swap(SyncActionValue_ArchiveChatAction& a, SyncActionValue_ArchiveChatAction& b) { - a.Swap(&b); - } - inline void Swap(SyncActionValue_ArchiveChatAction* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncActionValue_ArchiveChatAction* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncActionValue_ArchiveChatAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncActionValue_ArchiveChatAction& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncActionValue_ArchiveChatAction& from) { - SyncActionValue_ArchiveChatAction::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncActionValue_ArchiveChatAction* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncActionValue.ArchiveChatAction"; - } - protected: - explicit SyncActionValue_ArchiveChatAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kMessageRangeFieldNumber = 2, - kArchivedFieldNumber = 1, - }; - // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2; - bool has_messagerange() const; - private: - bool _internal_has_messagerange() const; - public: - void clear_messagerange(); - const ::proto::SyncActionValue_SyncActionMessageRange& messagerange() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue_SyncActionMessageRange* release_messagerange(); - ::proto::SyncActionValue_SyncActionMessageRange* mutable_messagerange(); - void set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange); - private: - const ::proto::SyncActionValue_SyncActionMessageRange& _internal_messagerange() const; - ::proto::SyncActionValue_SyncActionMessageRange* _internal_mutable_messagerange(); - public: - void unsafe_arena_set_allocated_messagerange( - ::proto::SyncActionValue_SyncActionMessageRange* messagerange); - ::proto::SyncActionValue_SyncActionMessageRange* unsafe_arena_release_messagerange(); - - // optional bool archived = 1; - bool has_archived() const; - private: - bool _internal_has_archived() const; - public: - void clear_archived(); - bool archived() const; - void set_archived(bool value); - private: - bool _internal_archived() const; - void _internal_set_archived(bool value); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncActionValue.ArchiveChatAction) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::proto::SyncActionValue_SyncActionMessageRange* messagerange_; - bool archived_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncActionValue_ClearChatAction final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.ClearChatAction) */ { - public: - inline SyncActionValue_ClearChatAction() : SyncActionValue_ClearChatAction(nullptr) {} - ~SyncActionValue_ClearChatAction() override; - explicit PROTOBUF_CONSTEXPR SyncActionValue_ClearChatAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncActionValue_ClearChatAction(const SyncActionValue_ClearChatAction& from); - SyncActionValue_ClearChatAction(SyncActionValue_ClearChatAction&& from) noexcept - : SyncActionValue_ClearChatAction() { - *this = ::std::move(from); - } - - inline SyncActionValue_ClearChatAction& operator=(const SyncActionValue_ClearChatAction& from) { - CopyFrom(from); - return *this; - } - inline SyncActionValue_ClearChatAction& operator=(SyncActionValue_ClearChatAction&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncActionValue_ClearChatAction& default_instance() { - return *internal_default_instance(); - } - static inline const SyncActionValue_ClearChatAction* internal_default_instance() { - return reinterpret_cast( - &_SyncActionValue_ClearChatAction_default_instance_); - } - static constexpr int kIndexInFileMessages = - 178; - - friend void swap(SyncActionValue_ClearChatAction& a, SyncActionValue_ClearChatAction& b) { - a.Swap(&b); - } - inline void Swap(SyncActionValue_ClearChatAction* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncActionValue_ClearChatAction* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncActionValue_ClearChatAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncActionValue_ClearChatAction& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncActionValue_ClearChatAction& from) { - SyncActionValue_ClearChatAction::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncActionValue_ClearChatAction* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncActionValue.ClearChatAction"; - } - protected: - explicit SyncActionValue_ClearChatAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kMessageRangeFieldNumber = 1, - }; - // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1; - bool has_messagerange() const; - private: - bool _internal_has_messagerange() const; - public: - void clear_messagerange(); - const ::proto::SyncActionValue_SyncActionMessageRange& messagerange() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue_SyncActionMessageRange* release_messagerange(); - ::proto::SyncActionValue_SyncActionMessageRange* mutable_messagerange(); - void set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange); - private: - const ::proto::SyncActionValue_SyncActionMessageRange& _internal_messagerange() const; - ::proto::SyncActionValue_SyncActionMessageRange* _internal_mutable_messagerange(); - public: - void unsafe_arena_set_allocated_messagerange( - ::proto::SyncActionValue_SyncActionMessageRange* messagerange); - ::proto::SyncActionValue_SyncActionMessageRange* unsafe_arena_release_messagerange(); - - // @@protoc_insertion_point(class_scope:proto.SyncActionValue.ClearChatAction) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::proto::SyncActionValue_SyncActionMessageRange* messagerange_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncActionValue_ContactAction final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.ContactAction) */ { - public: - inline SyncActionValue_ContactAction() : SyncActionValue_ContactAction(nullptr) {} - ~SyncActionValue_ContactAction() override; - explicit PROTOBUF_CONSTEXPR SyncActionValue_ContactAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncActionValue_ContactAction(const SyncActionValue_ContactAction& from); - SyncActionValue_ContactAction(SyncActionValue_ContactAction&& from) noexcept - : SyncActionValue_ContactAction() { - *this = ::std::move(from); - } - - inline SyncActionValue_ContactAction& operator=(const SyncActionValue_ContactAction& from) { - CopyFrom(from); - return *this; - } - inline SyncActionValue_ContactAction& operator=(SyncActionValue_ContactAction&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncActionValue_ContactAction& default_instance() { - return *internal_default_instance(); - } - static inline const SyncActionValue_ContactAction* internal_default_instance() { - return reinterpret_cast( - &_SyncActionValue_ContactAction_default_instance_); - } - static constexpr int kIndexInFileMessages = - 179; - - friend void swap(SyncActionValue_ContactAction& a, SyncActionValue_ContactAction& b) { - a.Swap(&b); - } - inline void Swap(SyncActionValue_ContactAction* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncActionValue_ContactAction* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncActionValue_ContactAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncActionValue_ContactAction& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncActionValue_ContactAction& from) { - SyncActionValue_ContactAction::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncActionValue_ContactAction* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncActionValue.ContactAction"; - } - protected: - explicit SyncActionValue_ContactAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kFullNameFieldNumber = 1, - kFirstNameFieldNumber = 2, - }; - // optional string fullName = 1; - bool has_fullname() const; - private: - bool _internal_has_fullname() const; - public: - void clear_fullname(); - const std::string& fullname() const; - template - void set_fullname(ArgT0&& arg0, ArgT... args); - std::string* mutable_fullname(); - PROTOBUF_NODISCARD std::string* release_fullname(); - void set_allocated_fullname(std::string* fullname); - private: - const std::string& _internal_fullname() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_fullname(const std::string& value); - std::string* _internal_mutable_fullname(); - public: - - // optional string firstName = 2; - bool has_firstname() const; - private: - bool _internal_has_firstname() const; - public: - void clear_firstname(); - const std::string& firstname() const; - template - void set_firstname(ArgT0&& arg0, ArgT... args); - std::string* mutable_firstname(); - PROTOBUF_NODISCARD std::string* release_firstname(); - void set_allocated_firstname(std::string* firstname); - private: - const std::string& _internal_firstname() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_firstname(const std::string& value); - std::string* _internal_mutable_firstname(); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncActionValue.ContactAction) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fullname_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr firstname_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncActionValue_DeleteChatAction final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.DeleteChatAction) */ { - public: - inline SyncActionValue_DeleteChatAction() : SyncActionValue_DeleteChatAction(nullptr) {} - ~SyncActionValue_DeleteChatAction() override; - explicit PROTOBUF_CONSTEXPR SyncActionValue_DeleteChatAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncActionValue_DeleteChatAction(const SyncActionValue_DeleteChatAction& from); - SyncActionValue_DeleteChatAction(SyncActionValue_DeleteChatAction&& from) noexcept - : SyncActionValue_DeleteChatAction() { - *this = ::std::move(from); - } - - inline SyncActionValue_DeleteChatAction& operator=(const SyncActionValue_DeleteChatAction& from) { - CopyFrom(from); - return *this; - } - inline SyncActionValue_DeleteChatAction& operator=(SyncActionValue_DeleteChatAction&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncActionValue_DeleteChatAction& default_instance() { - return *internal_default_instance(); - } - static inline const SyncActionValue_DeleteChatAction* internal_default_instance() { - return reinterpret_cast( - &_SyncActionValue_DeleteChatAction_default_instance_); - } - static constexpr int kIndexInFileMessages = - 180; - - friend void swap(SyncActionValue_DeleteChatAction& a, SyncActionValue_DeleteChatAction& b) { - a.Swap(&b); - } - inline void Swap(SyncActionValue_DeleteChatAction* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncActionValue_DeleteChatAction* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncActionValue_DeleteChatAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncActionValue_DeleteChatAction& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncActionValue_DeleteChatAction& from) { - SyncActionValue_DeleteChatAction::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncActionValue_DeleteChatAction* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncActionValue.DeleteChatAction"; - } - protected: - explicit SyncActionValue_DeleteChatAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kMessageRangeFieldNumber = 1, - }; - // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1; - bool has_messagerange() const; - private: - bool _internal_has_messagerange() const; - public: - void clear_messagerange(); - const ::proto::SyncActionValue_SyncActionMessageRange& messagerange() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue_SyncActionMessageRange* release_messagerange(); - ::proto::SyncActionValue_SyncActionMessageRange* mutable_messagerange(); - void set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange); - private: - const ::proto::SyncActionValue_SyncActionMessageRange& _internal_messagerange() const; - ::proto::SyncActionValue_SyncActionMessageRange* _internal_mutable_messagerange(); - public: - void unsafe_arena_set_allocated_messagerange( - ::proto::SyncActionValue_SyncActionMessageRange* messagerange); - ::proto::SyncActionValue_SyncActionMessageRange* unsafe_arena_release_messagerange(); - - // @@protoc_insertion_point(class_scope:proto.SyncActionValue.DeleteChatAction) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::proto::SyncActionValue_SyncActionMessageRange* messagerange_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncActionValue_DeleteMessageForMeAction final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.DeleteMessageForMeAction) */ { - public: - inline SyncActionValue_DeleteMessageForMeAction() : SyncActionValue_DeleteMessageForMeAction(nullptr) {} - ~SyncActionValue_DeleteMessageForMeAction() override; - explicit PROTOBUF_CONSTEXPR SyncActionValue_DeleteMessageForMeAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncActionValue_DeleteMessageForMeAction(const SyncActionValue_DeleteMessageForMeAction& from); - SyncActionValue_DeleteMessageForMeAction(SyncActionValue_DeleteMessageForMeAction&& from) noexcept - : SyncActionValue_DeleteMessageForMeAction() { - *this = ::std::move(from); - } - - inline SyncActionValue_DeleteMessageForMeAction& operator=(const SyncActionValue_DeleteMessageForMeAction& from) { - CopyFrom(from); - return *this; - } - inline SyncActionValue_DeleteMessageForMeAction& operator=(SyncActionValue_DeleteMessageForMeAction&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncActionValue_DeleteMessageForMeAction& default_instance() { - return *internal_default_instance(); - } - static inline const SyncActionValue_DeleteMessageForMeAction* internal_default_instance() { - return reinterpret_cast( - &_SyncActionValue_DeleteMessageForMeAction_default_instance_); - } - static constexpr int kIndexInFileMessages = - 181; - - friend void swap(SyncActionValue_DeleteMessageForMeAction& a, SyncActionValue_DeleteMessageForMeAction& b) { - a.Swap(&b); - } - inline void Swap(SyncActionValue_DeleteMessageForMeAction* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncActionValue_DeleteMessageForMeAction* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncActionValue_DeleteMessageForMeAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncActionValue_DeleteMessageForMeAction& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncActionValue_DeleteMessageForMeAction& from) { - SyncActionValue_DeleteMessageForMeAction::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncActionValue_DeleteMessageForMeAction* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncActionValue.DeleteMessageForMeAction"; - } - protected: - explicit SyncActionValue_DeleteMessageForMeAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kMessageTimestampFieldNumber = 2, - kDeleteMediaFieldNumber = 1, - }; - // optional int64 messageTimestamp = 2; - bool has_messagetimestamp() const; - private: - bool _internal_has_messagetimestamp() const; - public: - void clear_messagetimestamp(); - int64_t messagetimestamp() const; - void set_messagetimestamp(int64_t value); - private: - int64_t _internal_messagetimestamp() const; - void _internal_set_messagetimestamp(int64_t value); - public: - - // optional bool deleteMedia = 1; - bool has_deletemedia() const; - private: - bool _internal_has_deletemedia() const; - public: - void clear_deletemedia(); - bool deletemedia() const; - void set_deletemedia(bool value); - private: - bool _internal_deletemedia() const; - void _internal_set_deletemedia(bool value); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncActionValue.DeleteMessageForMeAction) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - int64_t messagetimestamp_; - bool deletemedia_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncActionValue_KeyExpiration final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.KeyExpiration) */ { - public: - inline SyncActionValue_KeyExpiration() : SyncActionValue_KeyExpiration(nullptr) {} - ~SyncActionValue_KeyExpiration() override; - explicit PROTOBUF_CONSTEXPR SyncActionValue_KeyExpiration(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncActionValue_KeyExpiration(const SyncActionValue_KeyExpiration& from); - SyncActionValue_KeyExpiration(SyncActionValue_KeyExpiration&& from) noexcept - : SyncActionValue_KeyExpiration() { - *this = ::std::move(from); - } - - inline SyncActionValue_KeyExpiration& operator=(const SyncActionValue_KeyExpiration& from) { - CopyFrom(from); - return *this; - } - inline SyncActionValue_KeyExpiration& operator=(SyncActionValue_KeyExpiration&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncActionValue_KeyExpiration& default_instance() { - return *internal_default_instance(); - } - static inline const SyncActionValue_KeyExpiration* internal_default_instance() { - return reinterpret_cast( - &_SyncActionValue_KeyExpiration_default_instance_); - } - static constexpr int kIndexInFileMessages = - 182; - - friend void swap(SyncActionValue_KeyExpiration& a, SyncActionValue_KeyExpiration& b) { - a.Swap(&b); - } - inline void Swap(SyncActionValue_KeyExpiration* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncActionValue_KeyExpiration* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncActionValue_KeyExpiration* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncActionValue_KeyExpiration& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncActionValue_KeyExpiration& from) { - SyncActionValue_KeyExpiration::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncActionValue_KeyExpiration* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncActionValue.KeyExpiration"; - } - protected: - explicit SyncActionValue_KeyExpiration(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kExpiredKeyEpochFieldNumber = 1, - }; - // optional int32 expiredKeyEpoch = 1; - bool has_expiredkeyepoch() const; - private: - bool _internal_has_expiredkeyepoch() const; - public: - void clear_expiredkeyepoch(); - int32_t expiredkeyepoch() const; - void set_expiredkeyepoch(int32_t value); - private: - int32_t _internal_expiredkeyepoch() const; - void _internal_set_expiredkeyepoch(int32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncActionValue.KeyExpiration) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - int32_t expiredkeyepoch_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncActionValue_LabelAssociationAction final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.LabelAssociationAction) */ { - public: - inline SyncActionValue_LabelAssociationAction() : SyncActionValue_LabelAssociationAction(nullptr) {} - ~SyncActionValue_LabelAssociationAction() override; - explicit PROTOBUF_CONSTEXPR SyncActionValue_LabelAssociationAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncActionValue_LabelAssociationAction(const SyncActionValue_LabelAssociationAction& from); - SyncActionValue_LabelAssociationAction(SyncActionValue_LabelAssociationAction&& from) noexcept - : SyncActionValue_LabelAssociationAction() { - *this = ::std::move(from); - } - - inline SyncActionValue_LabelAssociationAction& operator=(const SyncActionValue_LabelAssociationAction& from) { - CopyFrom(from); - return *this; - } - inline SyncActionValue_LabelAssociationAction& operator=(SyncActionValue_LabelAssociationAction&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncActionValue_LabelAssociationAction& default_instance() { - return *internal_default_instance(); - } - static inline const SyncActionValue_LabelAssociationAction* internal_default_instance() { - return reinterpret_cast( - &_SyncActionValue_LabelAssociationAction_default_instance_); - } - static constexpr int kIndexInFileMessages = - 183; - - friend void swap(SyncActionValue_LabelAssociationAction& a, SyncActionValue_LabelAssociationAction& b) { - a.Swap(&b); - } - inline void Swap(SyncActionValue_LabelAssociationAction* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncActionValue_LabelAssociationAction* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncActionValue_LabelAssociationAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncActionValue_LabelAssociationAction& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncActionValue_LabelAssociationAction& from) { - SyncActionValue_LabelAssociationAction::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncActionValue_LabelAssociationAction* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncActionValue.LabelAssociationAction"; - } - protected: - explicit SyncActionValue_LabelAssociationAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kLabeledFieldNumber = 1, - }; - // optional bool labeled = 1; - bool has_labeled() const; - private: - bool _internal_has_labeled() const; - public: - void clear_labeled(); - bool labeled() const; - void set_labeled(bool value); - private: - bool _internal_labeled() const; - void _internal_set_labeled(bool value); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncActionValue.LabelAssociationAction) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - bool labeled_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncActionValue_LabelEditAction final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.LabelEditAction) */ { - public: - inline SyncActionValue_LabelEditAction() : SyncActionValue_LabelEditAction(nullptr) {} - ~SyncActionValue_LabelEditAction() override; - explicit PROTOBUF_CONSTEXPR SyncActionValue_LabelEditAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncActionValue_LabelEditAction(const SyncActionValue_LabelEditAction& from); - SyncActionValue_LabelEditAction(SyncActionValue_LabelEditAction&& from) noexcept - : SyncActionValue_LabelEditAction() { - *this = ::std::move(from); - } - - inline SyncActionValue_LabelEditAction& operator=(const SyncActionValue_LabelEditAction& from) { - CopyFrom(from); - return *this; - } - inline SyncActionValue_LabelEditAction& operator=(SyncActionValue_LabelEditAction&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncActionValue_LabelEditAction& default_instance() { - return *internal_default_instance(); - } - static inline const SyncActionValue_LabelEditAction* internal_default_instance() { - return reinterpret_cast( - &_SyncActionValue_LabelEditAction_default_instance_); - } - static constexpr int kIndexInFileMessages = - 184; - - friend void swap(SyncActionValue_LabelEditAction& a, SyncActionValue_LabelEditAction& b) { - a.Swap(&b); - } - inline void Swap(SyncActionValue_LabelEditAction* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncActionValue_LabelEditAction* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncActionValue_LabelEditAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncActionValue_LabelEditAction& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncActionValue_LabelEditAction& from) { - SyncActionValue_LabelEditAction::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncActionValue_LabelEditAction* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncActionValue.LabelEditAction"; - } - protected: - explicit SyncActionValue_LabelEditAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kNameFieldNumber = 1, - kColorFieldNumber = 2, - kPredefinedIdFieldNumber = 3, - kDeletedFieldNumber = 4, - }; - // optional string name = 1; - bool has_name() const; - private: - bool _internal_has_name() const; - public: - void clear_name(); - const std::string& name() const; - template - void set_name(ArgT0&& arg0, ArgT... args); - std::string* mutable_name(); - PROTOBUF_NODISCARD std::string* release_name(); - void set_allocated_name(std::string* name); - private: - const std::string& _internal_name() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); - std::string* _internal_mutable_name(); - public: - - // optional int32 color = 2; - bool has_color() const; - private: - bool _internal_has_color() const; - public: - void clear_color(); - int32_t color() const; - void set_color(int32_t value); - private: - int32_t _internal_color() const; - void _internal_set_color(int32_t value); - public: - - // optional int32 predefinedId = 3; - bool has_predefinedid() const; - private: - bool _internal_has_predefinedid() const; - public: - void clear_predefinedid(); - int32_t predefinedid() const; - void set_predefinedid(int32_t value); - private: - int32_t _internal_predefinedid() const; - void _internal_set_predefinedid(int32_t value); - public: - - // optional bool deleted = 4; - bool has_deleted() const; - private: - bool _internal_has_deleted() const; - public: - void clear_deleted(); - bool deleted() const; - void set_deleted(bool value); - private: - bool _internal_deleted() const; - void _internal_set_deleted(bool value); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncActionValue.LabelEditAction) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - int32_t color_; - int32_t predefinedid_; - bool deleted_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncActionValue_LocaleSetting final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.LocaleSetting) */ { - public: - inline SyncActionValue_LocaleSetting() : SyncActionValue_LocaleSetting(nullptr) {} - ~SyncActionValue_LocaleSetting() override; - explicit PROTOBUF_CONSTEXPR SyncActionValue_LocaleSetting(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncActionValue_LocaleSetting(const SyncActionValue_LocaleSetting& from); - SyncActionValue_LocaleSetting(SyncActionValue_LocaleSetting&& from) noexcept - : SyncActionValue_LocaleSetting() { - *this = ::std::move(from); - } - - inline SyncActionValue_LocaleSetting& operator=(const SyncActionValue_LocaleSetting& from) { - CopyFrom(from); - return *this; - } - inline SyncActionValue_LocaleSetting& operator=(SyncActionValue_LocaleSetting&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncActionValue_LocaleSetting& default_instance() { - return *internal_default_instance(); - } - static inline const SyncActionValue_LocaleSetting* internal_default_instance() { - return reinterpret_cast( - &_SyncActionValue_LocaleSetting_default_instance_); - } - static constexpr int kIndexInFileMessages = - 185; - - friend void swap(SyncActionValue_LocaleSetting& a, SyncActionValue_LocaleSetting& b) { - a.Swap(&b); - } - inline void Swap(SyncActionValue_LocaleSetting* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncActionValue_LocaleSetting* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncActionValue_LocaleSetting* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncActionValue_LocaleSetting& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncActionValue_LocaleSetting& from) { - SyncActionValue_LocaleSetting::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncActionValue_LocaleSetting* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncActionValue.LocaleSetting"; - } - protected: - explicit SyncActionValue_LocaleSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kLocaleFieldNumber = 1, - }; - // optional string locale = 1; - bool has_locale() const; - private: - bool _internal_has_locale() const; - public: - void clear_locale(); - const std::string& locale() const; - template - void set_locale(ArgT0&& arg0, ArgT... args); - std::string* mutable_locale(); - PROTOBUF_NODISCARD std::string* release_locale(); - void set_allocated_locale(std::string* locale); - private: - const std::string& _internal_locale() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_locale(const std::string& value); - std::string* _internal_mutable_locale(); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncActionValue.LocaleSetting) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr locale_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncActionValue_MarkChatAsReadAction final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.MarkChatAsReadAction) */ { - public: - inline SyncActionValue_MarkChatAsReadAction() : SyncActionValue_MarkChatAsReadAction(nullptr) {} - ~SyncActionValue_MarkChatAsReadAction() override; - explicit PROTOBUF_CONSTEXPR SyncActionValue_MarkChatAsReadAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncActionValue_MarkChatAsReadAction(const SyncActionValue_MarkChatAsReadAction& from); - SyncActionValue_MarkChatAsReadAction(SyncActionValue_MarkChatAsReadAction&& from) noexcept - : SyncActionValue_MarkChatAsReadAction() { - *this = ::std::move(from); - } - - inline SyncActionValue_MarkChatAsReadAction& operator=(const SyncActionValue_MarkChatAsReadAction& from) { - CopyFrom(from); - return *this; - } - inline SyncActionValue_MarkChatAsReadAction& operator=(SyncActionValue_MarkChatAsReadAction&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncActionValue_MarkChatAsReadAction& default_instance() { - return *internal_default_instance(); - } - static inline const SyncActionValue_MarkChatAsReadAction* internal_default_instance() { - return reinterpret_cast( - &_SyncActionValue_MarkChatAsReadAction_default_instance_); - } - static constexpr int kIndexInFileMessages = - 186; - - friend void swap(SyncActionValue_MarkChatAsReadAction& a, SyncActionValue_MarkChatAsReadAction& b) { - a.Swap(&b); - } - inline void Swap(SyncActionValue_MarkChatAsReadAction* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncActionValue_MarkChatAsReadAction* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncActionValue_MarkChatAsReadAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncActionValue_MarkChatAsReadAction& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncActionValue_MarkChatAsReadAction& from) { - SyncActionValue_MarkChatAsReadAction::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncActionValue_MarkChatAsReadAction* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncActionValue.MarkChatAsReadAction"; - } - protected: - explicit SyncActionValue_MarkChatAsReadAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kMessageRangeFieldNumber = 2, - kReadFieldNumber = 1, - }; - // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2; - bool has_messagerange() const; - private: - bool _internal_has_messagerange() const; - public: - void clear_messagerange(); - const ::proto::SyncActionValue_SyncActionMessageRange& messagerange() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue_SyncActionMessageRange* release_messagerange(); - ::proto::SyncActionValue_SyncActionMessageRange* mutable_messagerange(); - void set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange); - private: - const ::proto::SyncActionValue_SyncActionMessageRange& _internal_messagerange() const; - ::proto::SyncActionValue_SyncActionMessageRange* _internal_mutable_messagerange(); - public: - void unsafe_arena_set_allocated_messagerange( - ::proto::SyncActionValue_SyncActionMessageRange* messagerange); - ::proto::SyncActionValue_SyncActionMessageRange* unsafe_arena_release_messagerange(); - - // optional bool read = 1; - bool has_read() const; - private: - bool _internal_has_read() const; - public: - void clear_read(); - bool read() const; - void set_read(bool value); - private: - bool _internal_read() const; - void _internal_set_read(bool value); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncActionValue.MarkChatAsReadAction) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::proto::SyncActionValue_SyncActionMessageRange* messagerange_; - bool read_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncActionValue_MuteAction final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.MuteAction) */ { - public: - inline SyncActionValue_MuteAction() : SyncActionValue_MuteAction(nullptr) {} - ~SyncActionValue_MuteAction() override; - explicit PROTOBUF_CONSTEXPR SyncActionValue_MuteAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncActionValue_MuteAction(const SyncActionValue_MuteAction& from); - SyncActionValue_MuteAction(SyncActionValue_MuteAction&& from) noexcept - : SyncActionValue_MuteAction() { - *this = ::std::move(from); - } - - inline SyncActionValue_MuteAction& operator=(const SyncActionValue_MuteAction& from) { - CopyFrom(from); - return *this; - } - inline SyncActionValue_MuteAction& operator=(SyncActionValue_MuteAction&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncActionValue_MuteAction& default_instance() { - return *internal_default_instance(); - } - static inline const SyncActionValue_MuteAction* internal_default_instance() { - return reinterpret_cast( - &_SyncActionValue_MuteAction_default_instance_); - } - static constexpr int kIndexInFileMessages = - 187; - - friend void swap(SyncActionValue_MuteAction& a, SyncActionValue_MuteAction& b) { - a.Swap(&b); - } - inline void Swap(SyncActionValue_MuteAction* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncActionValue_MuteAction* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncActionValue_MuteAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncActionValue_MuteAction& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncActionValue_MuteAction& from) { - SyncActionValue_MuteAction::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncActionValue_MuteAction* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncActionValue.MuteAction"; - } - protected: - explicit SyncActionValue_MuteAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kMuteEndTimestampFieldNumber = 2, - kMutedFieldNumber = 1, - }; - // optional int64 muteEndTimestamp = 2; - bool has_muteendtimestamp() const; - private: - bool _internal_has_muteendtimestamp() const; - public: - void clear_muteendtimestamp(); - int64_t muteendtimestamp() const; - void set_muteendtimestamp(int64_t value); - private: - int64_t _internal_muteendtimestamp() const; - void _internal_set_muteendtimestamp(int64_t value); - public: - - // optional bool muted = 1; - bool has_muted() const; - private: - bool _internal_has_muted() const; - public: - void clear_muted(); - bool muted() const; - void set_muted(bool value); - private: - bool _internal_muted() const; - void _internal_set_muted(bool value); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncActionValue.MuteAction) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - int64_t muteendtimestamp_; - bool muted_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncActionValue_NuxAction final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.NuxAction) */ { - public: - inline SyncActionValue_NuxAction() : SyncActionValue_NuxAction(nullptr) {} - ~SyncActionValue_NuxAction() override; - explicit PROTOBUF_CONSTEXPR SyncActionValue_NuxAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncActionValue_NuxAction(const SyncActionValue_NuxAction& from); - SyncActionValue_NuxAction(SyncActionValue_NuxAction&& from) noexcept - : SyncActionValue_NuxAction() { - *this = ::std::move(from); - } - - inline SyncActionValue_NuxAction& operator=(const SyncActionValue_NuxAction& from) { - CopyFrom(from); - return *this; - } - inline SyncActionValue_NuxAction& operator=(SyncActionValue_NuxAction&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncActionValue_NuxAction& default_instance() { - return *internal_default_instance(); - } - static inline const SyncActionValue_NuxAction* internal_default_instance() { - return reinterpret_cast( - &_SyncActionValue_NuxAction_default_instance_); - } - static constexpr int kIndexInFileMessages = - 188; - - friend void swap(SyncActionValue_NuxAction& a, SyncActionValue_NuxAction& b) { - a.Swap(&b); - } - inline void Swap(SyncActionValue_NuxAction* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncActionValue_NuxAction* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncActionValue_NuxAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncActionValue_NuxAction& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncActionValue_NuxAction& from) { - SyncActionValue_NuxAction::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncActionValue_NuxAction* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncActionValue.NuxAction"; - } - protected: - explicit SyncActionValue_NuxAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kAcknowledgedFieldNumber = 1, - }; - // optional bool acknowledged = 1; - bool has_acknowledged() const; - private: - bool _internal_has_acknowledged() const; - public: - void clear_acknowledged(); - bool acknowledged() const; - void set_acknowledged(bool value); - private: - bool _internal_acknowledged() const; - void _internal_set_acknowledged(bool value); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncActionValue.NuxAction) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - bool acknowledged_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncActionValue_PinAction final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.PinAction) */ { - public: - inline SyncActionValue_PinAction() : SyncActionValue_PinAction(nullptr) {} - ~SyncActionValue_PinAction() override; - explicit PROTOBUF_CONSTEXPR SyncActionValue_PinAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncActionValue_PinAction(const SyncActionValue_PinAction& from); - SyncActionValue_PinAction(SyncActionValue_PinAction&& from) noexcept - : SyncActionValue_PinAction() { - *this = ::std::move(from); - } - - inline SyncActionValue_PinAction& operator=(const SyncActionValue_PinAction& from) { - CopyFrom(from); - return *this; - } - inline SyncActionValue_PinAction& operator=(SyncActionValue_PinAction&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncActionValue_PinAction& default_instance() { - return *internal_default_instance(); - } - static inline const SyncActionValue_PinAction* internal_default_instance() { - return reinterpret_cast( - &_SyncActionValue_PinAction_default_instance_); - } - static constexpr int kIndexInFileMessages = - 189; - - friend void swap(SyncActionValue_PinAction& a, SyncActionValue_PinAction& b) { - a.Swap(&b); - } - inline void Swap(SyncActionValue_PinAction* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncActionValue_PinAction* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncActionValue_PinAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncActionValue_PinAction& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncActionValue_PinAction& from) { - SyncActionValue_PinAction::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncActionValue_PinAction* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncActionValue.PinAction"; - } - protected: - explicit SyncActionValue_PinAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kPinnedFieldNumber = 1, - }; - // optional bool pinned = 1; - bool has_pinned() const; - private: - bool _internal_has_pinned() const; - public: - void clear_pinned(); - bool pinned() const; - void set_pinned(bool value); - private: - bool _internal_pinned() const; - void _internal_set_pinned(bool value); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncActionValue.PinAction) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - bool pinned_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncActionValue_PrimaryFeature final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.PrimaryFeature) */ { - public: - inline SyncActionValue_PrimaryFeature() : SyncActionValue_PrimaryFeature(nullptr) {} - ~SyncActionValue_PrimaryFeature() override; - explicit PROTOBUF_CONSTEXPR SyncActionValue_PrimaryFeature(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncActionValue_PrimaryFeature(const SyncActionValue_PrimaryFeature& from); - SyncActionValue_PrimaryFeature(SyncActionValue_PrimaryFeature&& from) noexcept - : SyncActionValue_PrimaryFeature() { - *this = ::std::move(from); - } - - inline SyncActionValue_PrimaryFeature& operator=(const SyncActionValue_PrimaryFeature& from) { - CopyFrom(from); - return *this; - } - inline SyncActionValue_PrimaryFeature& operator=(SyncActionValue_PrimaryFeature&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncActionValue_PrimaryFeature& default_instance() { - return *internal_default_instance(); - } - static inline const SyncActionValue_PrimaryFeature* internal_default_instance() { - return reinterpret_cast( - &_SyncActionValue_PrimaryFeature_default_instance_); - } - static constexpr int kIndexInFileMessages = - 190; - - friend void swap(SyncActionValue_PrimaryFeature& a, SyncActionValue_PrimaryFeature& b) { - a.Swap(&b); - } - inline void Swap(SyncActionValue_PrimaryFeature* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncActionValue_PrimaryFeature* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncActionValue_PrimaryFeature* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncActionValue_PrimaryFeature& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncActionValue_PrimaryFeature& from) { - SyncActionValue_PrimaryFeature::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncActionValue_PrimaryFeature* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncActionValue.PrimaryFeature"; - } - protected: - explicit SyncActionValue_PrimaryFeature(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kFlagsFieldNumber = 1, - }; - // repeated string flags = 1; - int flags_size() const; - private: - int _internal_flags_size() const; - public: - void clear_flags(); - const std::string& flags(int index) const; - std::string* mutable_flags(int index); - void set_flags(int index, const std::string& value); - void set_flags(int index, std::string&& value); - void set_flags(int index, const char* value); - void set_flags(int index, const char* value, size_t size); - std::string* add_flags(); - void add_flags(const std::string& value); - void add_flags(std::string&& value); - void add_flags(const char* value); - void add_flags(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& flags() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_flags(); - private: - const std::string& _internal_flags(int index) const; - std::string* _internal_add_flags(); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncActionValue.PrimaryFeature) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField flags_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncActionValue_PrimaryVersionAction final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.PrimaryVersionAction) */ { - public: - inline SyncActionValue_PrimaryVersionAction() : SyncActionValue_PrimaryVersionAction(nullptr) {} - ~SyncActionValue_PrimaryVersionAction() override; - explicit PROTOBUF_CONSTEXPR SyncActionValue_PrimaryVersionAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncActionValue_PrimaryVersionAction(const SyncActionValue_PrimaryVersionAction& from); - SyncActionValue_PrimaryVersionAction(SyncActionValue_PrimaryVersionAction&& from) noexcept - : SyncActionValue_PrimaryVersionAction() { - *this = ::std::move(from); - } - - inline SyncActionValue_PrimaryVersionAction& operator=(const SyncActionValue_PrimaryVersionAction& from) { - CopyFrom(from); - return *this; - } - inline SyncActionValue_PrimaryVersionAction& operator=(SyncActionValue_PrimaryVersionAction&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncActionValue_PrimaryVersionAction& default_instance() { - return *internal_default_instance(); - } - static inline const SyncActionValue_PrimaryVersionAction* internal_default_instance() { - return reinterpret_cast( - &_SyncActionValue_PrimaryVersionAction_default_instance_); - } - static constexpr int kIndexInFileMessages = - 191; - - friend void swap(SyncActionValue_PrimaryVersionAction& a, SyncActionValue_PrimaryVersionAction& b) { - a.Swap(&b); - } - inline void Swap(SyncActionValue_PrimaryVersionAction* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncActionValue_PrimaryVersionAction* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncActionValue_PrimaryVersionAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncActionValue_PrimaryVersionAction& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncActionValue_PrimaryVersionAction& from) { - SyncActionValue_PrimaryVersionAction::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncActionValue_PrimaryVersionAction* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncActionValue.PrimaryVersionAction"; - } - protected: - explicit SyncActionValue_PrimaryVersionAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kVersionFieldNumber = 1, - }; - // optional string version = 1; - bool has_version() const; - private: - bool _internal_has_version() const; - public: - void clear_version(); - const std::string& version() const; - template - void set_version(ArgT0&& arg0, ArgT... args); - std::string* mutable_version(); - PROTOBUF_NODISCARD std::string* release_version(); - void set_allocated_version(std::string* version); - private: - const std::string& _internal_version() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(const std::string& value); - std::string* _internal_mutable_version(); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncActionValue.PrimaryVersionAction) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncActionValue_PushNameSetting final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.PushNameSetting) */ { - public: - inline SyncActionValue_PushNameSetting() : SyncActionValue_PushNameSetting(nullptr) {} - ~SyncActionValue_PushNameSetting() override; - explicit PROTOBUF_CONSTEXPR SyncActionValue_PushNameSetting(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncActionValue_PushNameSetting(const SyncActionValue_PushNameSetting& from); - SyncActionValue_PushNameSetting(SyncActionValue_PushNameSetting&& from) noexcept - : SyncActionValue_PushNameSetting() { - *this = ::std::move(from); - } - - inline SyncActionValue_PushNameSetting& operator=(const SyncActionValue_PushNameSetting& from) { - CopyFrom(from); - return *this; - } - inline SyncActionValue_PushNameSetting& operator=(SyncActionValue_PushNameSetting&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncActionValue_PushNameSetting& default_instance() { - return *internal_default_instance(); - } - static inline const SyncActionValue_PushNameSetting* internal_default_instance() { - return reinterpret_cast( - &_SyncActionValue_PushNameSetting_default_instance_); - } - static constexpr int kIndexInFileMessages = - 192; - - friend void swap(SyncActionValue_PushNameSetting& a, SyncActionValue_PushNameSetting& b) { - a.Swap(&b); - } - inline void Swap(SyncActionValue_PushNameSetting* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncActionValue_PushNameSetting* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncActionValue_PushNameSetting* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncActionValue_PushNameSetting& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncActionValue_PushNameSetting& from) { - SyncActionValue_PushNameSetting::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncActionValue_PushNameSetting* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncActionValue.PushNameSetting"; - } - protected: - explicit SyncActionValue_PushNameSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kNameFieldNumber = 1, - }; - // optional string name = 1; - bool has_name() const; - private: - bool _internal_has_name() const; - public: - void clear_name(); - const std::string& name() const; - template - void set_name(ArgT0&& arg0, ArgT... args); - std::string* mutable_name(); - PROTOBUF_NODISCARD std::string* release_name(); - void set_allocated_name(std::string* name); - private: - const std::string& _internal_name() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); - std::string* _internal_mutable_name(); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncActionValue.PushNameSetting) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncActionValue_QuickReplyAction final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.QuickReplyAction) */ { - public: - inline SyncActionValue_QuickReplyAction() : SyncActionValue_QuickReplyAction(nullptr) {} - ~SyncActionValue_QuickReplyAction() override; - explicit PROTOBUF_CONSTEXPR SyncActionValue_QuickReplyAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncActionValue_QuickReplyAction(const SyncActionValue_QuickReplyAction& from); - SyncActionValue_QuickReplyAction(SyncActionValue_QuickReplyAction&& from) noexcept - : SyncActionValue_QuickReplyAction() { - *this = ::std::move(from); - } - - inline SyncActionValue_QuickReplyAction& operator=(const SyncActionValue_QuickReplyAction& from) { - CopyFrom(from); - return *this; - } - inline SyncActionValue_QuickReplyAction& operator=(SyncActionValue_QuickReplyAction&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncActionValue_QuickReplyAction& default_instance() { - return *internal_default_instance(); - } - static inline const SyncActionValue_QuickReplyAction* internal_default_instance() { - return reinterpret_cast( - &_SyncActionValue_QuickReplyAction_default_instance_); - } - static constexpr int kIndexInFileMessages = - 193; - - friend void swap(SyncActionValue_QuickReplyAction& a, SyncActionValue_QuickReplyAction& b) { - a.Swap(&b); - } - inline void Swap(SyncActionValue_QuickReplyAction* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncActionValue_QuickReplyAction* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncActionValue_QuickReplyAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncActionValue_QuickReplyAction& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncActionValue_QuickReplyAction& from) { - SyncActionValue_QuickReplyAction::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncActionValue_QuickReplyAction* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncActionValue.QuickReplyAction"; - } - protected: - explicit SyncActionValue_QuickReplyAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kKeywordsFieldNumber = 3, - kShortcutFieldNumber = 1, - kMessageFieldNumber = 2, - kCountFieldNumber = 4, - kDeletedFieldNumber = 5, - }; - // repeated string keywords = 3; - int keywords_size() const; - private: - int _internal_keywords_size() const; - public: - void clear_keywords(); - const std::string& keywords(int index) const; - std::string* mutable_keywords(int index); - void set_keywords(int index, const std::string& value); - void set_keywords(int index, std::string&& value); - void set_keywords(int index, const char* value); - void set_keywords(int index, const char* value, size_t size); - std::string* add_keywords(); - void add_keywords(const std::string& value); - void add_keywords(std::string&& value); - void add_keywords(const char* value); - void add_keywords(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& keywords() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_keywords(); - private: - const std::string& _internal_keywords(int index) const; - std::string* _internal_add_keywords(); - public: - - // optional string shortcut = 1; - bool has_shortcut() const; - private: - bool _internal_has_shortcut() const; - public: - void clear_shortcut(); - const std::string& shortcut() const; - template - void set_shortcut(ArgT0&& arg0, ArgT... args); - std::string* mutable_shortcut(); - PROTOBUF_NODISCARD std::string* release_shortcut(); - void set_allocated_shortcut(std::string* shortcut); - private: - const std::string& _internal_shortcut() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_shortcut(const std::string& value); - std::string* _internal_mutable_shortcut(); - public: - - // optional string message = 2; - bool has_message() const; - private: - bool _internal_has_message() const; - public: - void clear_message(); - const std::string& message() const; - template - void set_message(ArgT0&& arg0, ArgT... args); - std::string* mutable_message(); - PROTOBUF_NODISCARD std::string* release_message(); - void set_allocated_message(std::string* message); - private: - const std::string& _internal_message() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_message(const std::string& value); - std::string* _internal_mutable_message(); - public: - - // optional int32 count = 4; - bool has_count() const; - private: - bool _internal_has_count() const; - public: - void clear_count(); - int32_t count() const; - void set_count(int32_t value); - private: - int32_t _internal_count() const; - void _internal_set_count(int32_t value); - public: - - // optional bool deleted = 5; - bool has_deleted() const; - private: - bool _internal_has_deleted() const; - public: - void clear_deleted(); - bool deleted() const; - void set_deleted(bool value); - private: - bool _internal_deleted() const; - void _internal_set_deleted(bool value); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncActionValue.QuickReplyAction) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField keywords_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr shortcut_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_; - int32_t count_; - bool deleted_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncActionValue_RecentEmojiWeightsAction final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.RecentEmojiWeightsAction) */ { - public: - inline SyncActionValue_RecentEmojiWeightsAction() : SyncActionValue_RecentEmojiWeightsAction(nullptr) {} - ~SyncActionValue_RecentEmojiWeightsAction() override; - explicit PROTOBUF_CONSTEXPR SyncActionValue_RecentEmojiWeightsAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncActionValue_RecentEmojiWeightsAction(const SyncActionValue_RecentEmojiWeightsAction& from); - SyncActionValue_RecentEmojiWeightsAction(SyncActionValue_RecentEmojiWeightsAction&& from) noexcept - : SyncActionValue_RecentEmojiWeightsAction() { - *this = ::std::move(from); - } - - inline SyncActionValue_RecentEmojiWeightsAction& operator=(const SyncActionValue_RecentEmojiWeightsAction& from) { - CopyFrom(from); - return *this; - } - inline SyncActionValue_RecentEmojiWeightsAction& operator=(SyncActionValue_RecentEmojiWeightsAction&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncActionValue_RecentEmojiWeightsAction& default_instance() { - return *internal_default_instance(); - } - static inline const SyncActionValue_RecentEmojiWeightsAction* internal_default_instance() { - return reinterpret_cast( - &_SyncActionValue_RecentEmojiWeightsAction_default_instance_); - } - static constexpr int kIndexInFileMessages = - 194; - - friend void swap(SyncActionValue_RecentEmojiWeightsAction& a, SyncActionValue_RecentEmojiWeightsAction& b) { - a.Swap(&b); - } - inline void Swap(SyncActionValue_RecentEmojiWeightsAction* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncActionValue_RecentEmojiWeightsAction* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncActionValue_RecentEmojiWeightsAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncActionValue_RecentEmojiWeightsAction& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncActionValue_RecentEmojiWeightsAction& from) { - SyncActionValue_RecentEmojiWeightsAction::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncActionValue_RecentEmojiWeightsAction* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncActionValue.RecentEmojiWeightsAction"; - } - protected: - explicit SyncActionValue_RecentEmojiWeightsAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kWeightsFieldNumber = 1, - }; - // repeated .proto.RecentEmojiWeight weights = 1; - int weights_size() const; - private: - int _internal_weights_size() const; - public: - void clear_weights(); - ::proto::RecentEmojiWeight* mutable_weights(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::RecentEmojiWeight >* - mutable_weights(); - private: - const ::proto::RecentEmojiWeight& _internal_weights(int index) const; - ::proto::RecentEmojiWeight* _internal_add_weights(); - public: - const ::proto::RecentEmojiWeight& weights(int index) const; - ::proto::RecentEmojiWeight* add_weights(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::RecentEmojiWeight >& - weights() const; - - // @@protoc_insertion_point(class_scope:proto.SyncActionValue.RecentEmojiWeightsAction) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::RecentEmojiWeight > weights_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncActionValue_SecurityNotificationSetting final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.SecurityNotificationSetting) */ { - public: - inline SyncActionValue_SecurityNotificationSetting() : SyncActionValue_SecurityNotificationSetting(nullptr) {} - ~SyncActionValue_SecurityNotificationSetting() override; - explicit PROTOBUF_CONSTEXPR SyncActionValue_SecurityNotificationSetting(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncActionValue_SecurityNotificationSetting(const SyncActionValue_SecurityNotificationSetting& from); - SyncActionValue_SecurityNotificationSetting(SyncActionValue_SecurityNotificationSetting&& from) noexcept - : SyncActionValue_SecurityNotificationSetting() { - *this = ::std::move(from); - } - - inline SyncActionValue_SecurityNotificationSetting& operator=(const SyncActionValue_SecurityNotificationSetting& from) { - CopyFrom(from); - return *this; - } - inline SyncActionValue_SecurityNotificationSetting& operator=(SyncActionValue_SecurityNotificationSetting&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncActionValue_SecurityNotificationSetting& default_instance() { - return *internal_default_instance(); - } - static inline const SyncActionValue_SecurityNotificationSetting* internal_default_instance() { - return reinterpret_cast( - &_SyncActionValue_SecurityNotificationSetting_default_instance_); - } - static constexpr int kIndexInFileMessages = - 195; - - friend void swap(SyncActionValue_SecurityNotificationSetting& a, SyncActionValue_SecurityNotificationSetting& b) { - a.Swap(&b); - } - inline void Swap(SyncActionValue_SecurityNotificationSetting* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncActionValue_SecurityNotificationSetting* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncActionValue_SecurityNotificationSetting* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncActionValue_SecurityNotificationSetting& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncActionValue_SecurityNotificationSetting& from) { - SyncActionValue_SecurityNotificationSetting::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncActionValue_SecurityNotificationSetting* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncActionValue.SecurityNotificationSetting"; - } - protected: - explicit SyncActionValue_SecurityNotificationSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kShowNotificationFieldNumber = 1, - }; - // optional bool showNotification = 1; - bool has_shownotification() const; - private: - bool _internal_has_shownotification() const; - public: - void clear_shownotification(); - bool shownotification() const; - void set_shownotification(bool value); - private: - bool _internal_shownotification() const; - void _internal_set_shownotification(bool value); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncActionValue.SecurityNotificationSetting) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - bool shownotification_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncActionValue_StarAction final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.StarAction) */ { - public: - inline SyncActionValue_StarAction() : SyncActionValue_StarAction(nullptr) {} - ~SyncActionValue_StarAction() override; - explicit PROTOBUF_CONSTEXPR SyncActionValue_StarAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncActionValue_StarAction(const SyncActionValue_StarAction& from); - SyncActionValue_StarAction(SyncActionValue_StarAction&& from) noexcept - : SyncActionValue_StarAction() { - *this = ::std::move(from); - } - - inline SyncActionValue_StarAction& operator=(const SyncActionValue_StarAction& from) { - CopyFrom(from); - return *this; - } - inline SyncActionValue_StarAction& operator=(SyncActionValue_StarAction&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncActionValue_StarAction& default_instance() { - return *internal_default_instance(); - } - static inline const SyncActionValue_StarAction* internal_default_instance() { - return reinterpret_cast( - &_SyncActionValue_StarAction_default_instance_); - } - static constexpr int kIndexInFileMessages = - 196; - - friend void swap(SyncActionValue_StarAction& a, SyncActionValue_StarAction& b) { - a.Swap(&b); - } - inline void Swap(SyncActionValue_StarAction* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncActionValue_StarAction* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncActionValue_StarAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncActionValue_StarAction& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncActionValue_StarAction& from) { - SyncActionValue_StarAction::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncActionValue_StarAction* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncActionValue.StarAction"; - } - protected: - explicit SyncActionValue_StarAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kStarredFieldNumber = 1, - }; - // optional bool starred = 1; - bool has_starred() const; - private: - bool _internal_has_starred() const; - public: - void clear_starred(); - bool starred() const; - void set_starred(bool value); - private: - bool _internal_starred() const; - void _internal_set_starred(bool value); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncActionValue.StarAction) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - bool starred_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncActionValue_StickerAction final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.StickerAction) */ { - public: - inline SyncActionValue_StickerAction() : SyncActionValue_StickerAction(nullptr) {} - ~SyncActionValue_StickerAction() override; - explicit PROTOBUF_CONSTEXPR SyncActionValue_StickerAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncActionValue_StickerAction(const SyncActionValue_StickerAction& from); - SyncActionValue_StickerAction(SyncActionValue_StickerAction&& from) noexcept - : SyncActionValue_StickerAction() { - *this = ::std::move(from); - } - - inline SyncActionValue_StickerAction& operator=(const SyncActionValue_StickerAction& from) { - CopyFrom(from); - return *this; - } - inline SyncActionValue_StickerAction& operator=(SyncActionValue_StickerAction&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncActionValue_StickerAction& default_instance() { - return *internal_default_instance(); - } - static inline const SyncActionValue_StickerAction* internal_default_instance() { - return reinterpret_cast( - &_SyncActionValue_StickerAction_default_instance_); - } - static constexpr int kIndexInFileMessages = - 197; - - friend void swap(SyncActionValue_StickerAction& a, SyncActionValue_StickerAction& b) { - a.Swap(&b); - } - inline void Swap(SyncActionValue_StickerAction* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncActionValue_StickerAction* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncActionValue_StickerAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncActionValue_StickerAction& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncActionValue_StickerAction& from) { - SyncActionValue_StickerAction::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncActionValue_StickerAction* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncActionValue.StickerAction"; - } - protected: - explicit SyncActionValue_StickerAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kUrlFieldNumber = 1, - kFileEncSha256FieldNumber = 2, - kMediaKeyFieldNumber = 3, - kMimetypeFieldNumber = 4, - kDirectPathFieldNumber = 7, - kHeightFieldNumber = 5, - kWidthFieldNumber = 6, - kFileLengthFieldNumber = 8, - kIsFavoriteFieldNumber = 9, - kDeviceIdHintFieldNumber = 10, - }; - // optional string url = 1; - bool has_url() const; - private: - bool _internal_has_url() const; - public: - void clear_url(); - const std::string& url() const; - template - void set_url(ArgT0&& arg0, ArgT... args); - std::string* mutable_url(); - PROTOBUF_NODISCARD std::string* release_url(); - void set_allocated_url(std::string* url); - private: - const std::string& _internal_url() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value); - std::string* _internal_mutable_url(); - public: - - // optional bytes fileEncSha256 = 2; - bool has_fileencsha256() const; - private: - bool _internal_has_fileencsha256() const; - public: - void clear_fileencsha256(); - const std::string& fileencsha256() const; - template - void set_fileencsha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_fileencsha256(); - PROTOBUF_NODISCARD std::string* release_fileencsha256(); - void set_allocated_fileencsha256(std::string* fileencsha256); - private: - const std::string& _internal_fileencsha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value); - std::string* _internal_mutable_fileencsha256(); - public: - - // optional bytes mediaKey = 3; - bool has_mediakey() const; - private: - bool _internal_has_mediakey() const; - public: - void clear_mediakey(); - const std::string& mediakey() const; - template - void set_mediakey(ArgT0&& arg0, ArgT... args); - std::string* mutable_mediakey(); - PROTOBUF_NODISCARD std::string* release_mediakey(); - void set_allocated_mediakey(std::string* mediakey); - private: - const std::string& _internal_mediakey() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value); - std::string* _internal_mutable_mediakey(); - public: - - // optional string mimetype = 4; - bool has_mimetype() const; - private: - bool _internal_has_mimetype() const; - public: - void clear_mimetype(); - const std::string& mimetype() const; - template - void set_mimetype(ArgT0&& arg0, ArgT... args); - std::string* mutable_mimetype(); - PROTOBUF_NODISCARD std::string* release_mimetype(); - void set_allocated_mimetype(std::string* mimetype); - private: - const std::string& _internal_mimetype() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value); - std::string* _internal_mutable_mimetype(); - public: - - // optional string directPath = 7; - bool has_directpath() const; - private: - bool _internal_has_directpath() const; - public: - void clear_directpath(); - const std::string& directpath() const; - template - void set_directpath(ArgT0&& arg0, ArgT... args); - std::string* mutable_directpath(); - PROTOBUF_NODISCARD std::string* release_directpath(); - void set_allocated_directpath(std::string* directpath); - private: - const std::string& _internal_directpath() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value); - std::string* _internal_mutable_directpath(); - public: - - // optional uint32 height = 5; - bool has_height() const; - private: - bool _internal_has_height() const; - public: - void clear_height(); - uint32_t height() const; - void set_height(uint32_t value); - private: - uint32_t _internal_height() const; - void _internal_set_height(uint32_t value); - public: - - // optional uint32 width = 6; - bool has_width() const; - private: - bool _internal_has_width() const; - public: - void clear_width(); - uint32_t width() const; - void set_width(uint32_t value); - private: - uint32_t _internal_width() const; - void _internal_set_width(uint32_t value); - public: - - // optional uint64 fileLength = 8; - bool has_filelength() const; - private: - bool _internal_has_filelength() const; - public: - void clear_filelength(); - uint64_t filelength() const; - void set_filelength(uint64_t value); - private: - uint64_t _internal_filelength() const; - void _internal_set_filelength(uint64_t value); - public: - - // optional bool isFavorite = 9; - bool has_isfavorite() const; - private: - bool _internal_has_isfavorite() const; - public: - void clear_isfavorite(); - bool isfavorite() const; - void set_isfavorite(bool value); - private: - bool _internal_isfavorite() const; - void _internal_set_isfavorite(bool value); - public: - - // optional uint32 deviceIdHint = 10; - bool has_deviceidhint() const; - private: - bool _internal_has_deviceidhint() const; - public: - void clear_deviceidhint(); - uint32_t deviceidhint() const; - void set_deviceidhint(uint32_t value); - private: - uint32_t _internal_deviceidhint() const; - void _internal_set_deviceidhint(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncActionValue.StickerAction) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mimetype_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_; - uint32_t height_; - uint32_t width_; - uint64_t filelength_; - bool isfavorite_; - uint32_t deviceidhint_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncActionValue_SubscriptionAction final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.SubscriptionAction) */ { - public: - inline SyncActionValue_SubscriptionAction() : SyncActionValue_SubscriptionAction(nullptr) {} - ~SyncActionValue_SubscriptionAction() override; - explicit PROTOBUF_CONSTEXPR SyncActionValue_SubscriptionAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncActionValue_SubscriptionAction(const SyncActionValue_SubscriptionAction& from); - SyncActionValue_SubscriptionAction(SyncActionValue_SubscriptionAction&& from) noexcept - : SyncActionValue_SubscriptionAction() { - *this = ::std::move(from); - } - - inline SyncActionValue_SubscriptionAction& operator=(const SyncActionValue_SubscriptionAction& from) { - CopyFrom(from); - return *this; - } - inline SyncActionValue_SubscriptionAction& operator=(SyncActionValue_SubscriptionAction&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncActionValue_SubscriptionAction& default_instance() { - return *internal_default_instance(); - } - static inline const SyncActionValue_SubscriptionAction* internal_default_instance() { - return reinterpret_cast( - &_SyncActionValue_SubscriptionAction_default_instance_); - } - static constexpr int kIndexInFileMessages = - 198; - - friend void swap(SyncActionValue_SubscriptionAction& a, SyncActionValue_SubscriptionAction& b) { - a.Swap(&b); - } - inline void Swap(SyncActionValue_SubscriptionAction* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncActionValue_SubscriptionAction* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncActionValue_SubscriptionAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncActionValue_SubscriptionAction& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncActionValue_SubscriptionAction& from) { - SyncActionValue_SubscriptionAction::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncActionValue_SubscriptionAction* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncActionValue.SubscriptionAction"; - } - protected: - explicit SyncActionValue_SubscriptionAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kExpirationDateFieldNumber = 3, - kIsDeactivatedFieldNumber = 1, - kIsAutoRenewingFieldNumber = 2, - }; - // optional int64 expirationDate = 3; - bool has_expirationdate() const; - private: - bool _internal_has_expirationdate() const; - public: - void clear_expirationdate(); - int64_t expirationdate() const; - void set_expirationdate(int64_t value); - private: - int64_t _internal_expirationdate() const; - void _internal_set_expirationdate(int64_t value); - public: - - // optional bool isDeactivated = 1; - bool has_isdeactivated() const; - private: - bool _internal_has_isdeactivated() const; - public: - void clear_isdeactivated(); - bool isdeactivated() const; - void set_isdeactivated(bool value); - private: - bool _internal_isdeactivated() const; - void _internal_set_isdeactivated(bool value); - public: - - // optional bool isAutoRenewing = 2; - bool has_isautorenewing() const; - private: - bool _internal_has_isautorenewing() const; - public: - void clear_isautorenewing(); - bool isautorenewing() const; - void set_isautorenewing(bool value); - private: - bool _internal_isautorenewing() const; - void _internal_set_isautorenewing(bool value); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncActionValue.SubscriptionAction) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - int64_t expirationdate_; - bool isdeactivated_; - bool isautorenewing_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncActionValue_SyncActionMessageRange final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.SyncActionMessageRange) */ { - public: - inline SyncActionValue_SyncActionMessageRange() : SyncActionValue_SyncActionMessageRange(nullptr) {} - ~SyncActionValue_SyncActionMessageRange() override; - explicit PROTOBUF_CONSTEXPR SyncActionValue_SyncActionMessageRange(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncActionValue_SyncActionMessageRange(const SyncActionValue_SyncActionMessageRange& from); - SyncActionValue_SyncActionMessageRange(SyncActionValue_SyncActionMessageRange&& from) noexcept - : SyncActionValue_SyncActionMessageRange() { - *this = ::std::move(from); - } - - inline SyncActionValue_SyncActionMessageRange& operator=(const SyncActionValue_SyncActionMessageRange& from) { - CopyFrom(from); - return *this; - } - inline SyncActionValue_SyncActionMessageRange& operator=(SyncActionValue_SyncActionMessageRange&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncActionValue_SyncActionMessageRange& default_instance() { - return *internal_default_instance(); - } - static inline const SyncActionValue_SyncActionMessageRange* internal_default_instance() { - return reinterpret_cast( - &_SyncActionValue_SyncActionMessageRange_default_instance_); - } - static constexpr int kIndexInFileMessages = - 199; - - friend void swap(SyncActionValue_SyncActionMessageRange& a, SyncActionValue_SyncActionMessageRange& b) { - a.Swap(&b); - } - inline void Swap(SyncActionValue_SyncActionMessageRange* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncActionValue_SyncActionMessageRange* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncActionValue_SyncActionMessageRange* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncActionValue_SyncActionMessageRange& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncActionValue_SyncActionMessageRange& from) { - SyncActionValue_SyncActionMessageRange::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncActionValue_SyncActionMessageRange* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncActionValue.SyncActionMessageRange"; - } - protected: - explicit SyncActionValue_SyncActionMessageRange(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kMessagesFieldNumber = 3, - kLastMessageTimestampFieldNumber = 1, - kLastSystemMessageTimestampFieldNumber = 2, - }; - // repeated .proto.SyncActionValue.SyncActionMessage messages = 3; - int messages_size() const; - private: - int _internal_messages_size() const; - public: - void clear_messages(); - ::proto::SyncActionValue_SyncActionMessage* mutable_messages(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncActionValue_SyncActionMessage >* - mutable_messages(); - private: - const ::proto::SyncActionValue_SyncActionMessage& _internal_messages(int index) const; - ::proto::SyncActionValue_SyncActionMessage* _internal_add_messages(); - public: - const ::proto::SyncActionValue_SyncActionMessage& messages(int index) const; - ::proto::SyncActionValue_SyncActionMessage* add_messages(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncActionValue_SyncActionMessage >& - messages() const; - - // optional int64 lastMessageTimestamp = 1; - bool has_lastmessagetimestamp() const; - private: - bool _internal_has_lastmessagetimestamp() const; - public: - void clear_lastmessagetimestamp(); - int64_t lastmessagetimestamp() const; - void set_lastmessagetimestamp(int64_t value); - private: - int64_t _internal_lastmessagetimestamp() const; - void _internal_set_lastmessagetimestamp(int64_t value); - public: - - // optional int64 lastSystemMessageTimestamp = 2; - bool has_lastsystemmessagetimestamp() const; - private: - bool _internal_has_lastsystemmessagetimestamp() const; - public: - void clear_lastsystemmessagetimestamp(); - int64_t lastsystemmessagetimestamp() const; - void set_lastsystemmessagetimestamp(int64_t value); - private: - int64_t _internal_lastsystemmessagetimestamp() const; - void _internal_set_lastsystemmessagetimestamp(int64_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncActionValue.SyncActionMessageRange) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncActionValue_SyncActionMessage > messages_; - int64_t lastmessagetimestamp_; - int64_t lastsystemmessagetimestamp_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncActionValue_SyncActionMessage final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.SyncActionMessage) */ { - public: - inline SyncActionValue_SyncActionMessage() : SyncActionValue_SyncActionMessage(nullptr) {} - ~SyncActionValue_SyncActionMessage() override; - explicit PROTOBUF_CONSTEXPR SyncActionValue_SyncActionMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncActionValue_SyncActionMessage(const SyncActionValue_SyncActionMessage& from); - SyncActionValue_SyncActionMessage(SyncActionValue_SyncActionMessage&& from) noexcept - : SyncActionValue_SyncActionMessage() { - *this = ::std::move(from); - } - - inline SyncActionValue_SyncActionMessage& operator=(const SyncActionValue_SyncActionMessage& from) { - CopyFrom(from); - return *this; - } - inline SyncActionValue_SyncActionMessage& operator=(SyncActionValue_SyncActionMessage&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncActionValue_SyncActionMessage& default_instance() { - return *internal_default_instance(); - } - static inline const SyncActionValue_SyncActionMessage* internal_default_instance() { - return reinterpret_cast( - &_SyncActionValue_SyncActionMessage_default_instance_); - } - static constexpr int kIndexInFileMessages = - 200; - - friend void swap(SyncActionValue_SyncActionMessage& a, SyncActionValue_SyncActionMessage& b) { - a.Swap(&b); - } - inline void Swap(SyncActionValue_SyncActionMessage* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncActionValue_SyncActionMessage* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncActionValue_SyncActionMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncActionValue_SyncActionMessage& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncActionValue_SyncActionMessage& from) { - SyncActionValue_SyncActionMessage::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncActionValue_SyncActionMessage* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncActionValue.SyncActionMessage"; - } - protected: - explicit SyncActionValue_SyncActionMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kKeyFieldNumber = 1, - kTimestampFieldNumber = 2, - }; - // optional .proto.MessageKey key = 1; - bool has_key() const; - private: - bool _internal_has_key() const; - public: - void clear_key(); - const ::proto::MessageKey& key() const; - PROTOBUF_NODISCARD ::proto::MessageKey* release_key(); - ::proto::MessageKey* mutable_key(); - void set_allocated_key(::proto::MessageKey* key); - private: - const ::proto::MessageKey& _internal_key() const; - ::proto::MessageKey* _internal_mutable_key(); - public: - void unsafe_arena_set_allocated_key( - ::proto::MessageKey* key); - ::proto::MessageKey* unsafe_arena_release_key(); - - // optional int64 timestamp = 2; - bool has_timestamp() const; - private: - bool _internal_has_timestamp() const; - public: - void clear_timestamp(); - int64_t timestamp() const; - void set_timestamp(int64_t value); - private: - int64_t _internal_timestamp() const; - void _internal_set_timestamp(int64_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncActionValue.SyncActionMessage) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::proto::MessageKey* key_; - int64_t timestamp_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncActionValue_TimeFormatAction final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.TimeFormatAction) */ { - public: - inline SyncActionValue_TimeFormatAction() : SyncActionValue_TimeFormatAction(nullptr) {} - ~SyncActionValue_TimeFormatAction() override; - explicit PROTOBUF_CONSTEXPR SyncActionValue_TimeFormatAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncActionValue_TimeFormatAction(const SyncActionValue_TimeFormatAction& from); - SyncActionValue_TimeFormatAction(SyncActionValue_TimeFormatAction&& from) noexcept - : SyncActionValue_TimeFormatAction() { - *this = ::std::move(from); - } - - inline SyncActionValue_TimeFormatAction& operator=(const SyncActionValue_TimeFormatAction& from) { - CopyFrom(from); - return *this; - } - inline SyncActionValue_TimeFormatAction& operator=(SyncActionValue_TimeFormatAction&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncActionValue_TimeFormatAction& default_instance() { - return *internal_default_instance(); - } - static inline const SyncActionValue_TimeFormatAction* internal_default_instance() { - return reinterpret_cast( - &_SyncActionValue_TimeFormatAction_default_instance_); - } - static constexpr int kIndexInFileMessages = - 201; - - friend void swap(SyncActionValue_TimeFormatAction& a, SyncActionValue_TimeFormatAction& b) { - a.Swap(&b); - } - inline void Swap(SyncActionValue_TimeFormatAction* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncActionValue_TimeFormatAction* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncActionValue_TimeFormatAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncActionValue_TimeFormatAction& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncActionValue_TimeFormatAction& from) { - SyncActionValue_TimeFormatAction::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncActionValue_TimeFormatAction* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncActionValue.TimeFormatAction"; - } - protected: - explicit SyncActionValue_TimeFormatAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kIsTwentyFourHourFormatEnabledFieldNumber = 1, - }; - // optional bool isTwentyFourHourFormatEnabled = 1; - bool has_istwentyfourhourformatenabled() const; - private: - bool _internal_has_istwentyfourhourformatenabled() const; - public: - void clear_istwentyfourhourformatenabled(); - bool istwentyfourhourformatenabled() const; - void set_istwentyfourhourformatenabled(bool value); - private: - bool _internal_istwentyfourhourformatenabled() const; - void _internal_set_istwentyfourhourformatenabled(bool value); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncActionValue.TimeFormatAction) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - bool istwentyfourhourformatenabled_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncActionValue_UnarchiveChatsSetting final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.UnarchiveChatsSetting) */ { - public: - inline SyncActionValue_UnarchiveChatsSetting() : SyncActionValue_UnarchiveChatsSetting(nullptr) {} - ~SyncActionValue_UnarchiveChatsSetting() override; - explicit PROTOBUF_CONSTEXPR SyncActionValue_UnarchiveChatsSetting(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncActionValue_UnarchiveChatsSetting(const SyncActionValue_UnarchiveChatsSetting& from); - SyncActionValue_UnarchiveChatsSetting(SyncActionValue_UnarchiveChatsSetting&& from) noexcept - : SyncActionValue_UnarchiveChatsSetting() { - *this = ::std::move(from); - } - - inline SyncActionValue_UnarchiveChatsSetting& operator=(const SyncActionValue_UnarchiveChatsSetting& from) { - CopyFrom(from); - return *this; - } - inline SyncActionValue_UnarchiveChatsSetting& operator=(SyncActionValue_UnarchiveChatsSetting&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncActionValue_UnarchiveChatsSetting& default_instance() { - return *internal_default_instance(); - } - static inline const SyncActionValue_UnarchiveChatsSetting* internal_default_instance() { - return reinterpret_cast( - &_SyncActionValue_UnarchiveChatsSetting_default_instance_); - } - static constexpr int kIndexInFileMessages = - 202; - - friend void swap(SyncActionValue_UnarchiveChatsSetting& a, SyncActionValue_UnarchiveChatsSetting& b) { - a.Swap(&b); - } - inline void Swap(SyncActionValue_UnarchiveChatsSetting* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncActionValue_UnarchiveChatsSetting* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncActionValue_UnarchiveChatsSetting* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncActionValue_UnarchiveChatsSetting& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncActionValue_UnarchiveChatsSetting& from) { - SyncActionValue_UnarchiveChatsSetting::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncActionValue_UnarchiveChatsSetting* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncActionValue.UnarchiveChatsSetting"; - } - protected: - explicit SyncActionValue_UnarchiveChatsSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kUnarchiveChatsFieldNumber = 1, - }; - // optional bool unarchiveChats = 1; - bool has_unarchivechats() const; - private: - bool _internal_has_unarchivechats() const; - public: - void clear_unarchivechats(); - bool unarchivechats() const; - void set_unarchivechats(bool value); - private: - bool _internal_unarchivechats() const; - void _internal_set_unarchivechats(bool value); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncActionValue.UnarchiveChatsSetting) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - bool unarchivechats_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncActionValue_UserStatusMuteAction final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.UserStatusMuteAction) */ { - public: - inline SyncActionValue_UserStatusMuteAction() : SyncActionValue_UserStatusMuteAction(nullptr) {} - ~SyncActionValue_UserStatusMuteAction() override; - explicit PROTOBUF_CONSTEXPR SyncActionValue_UserStatusMuteAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncActionValue_UserStatusMuteAction(const SyncActionValue_UserStatusMuteAction& from); - SyncActionValue_UserStatusMuteAction(SyncActionValue_UserStatusMuteAction&& from) noexcept - : SyncActionValue_UserStatusMuteAction() { - *this = ::std::move(from); - } - - inline SyncActionValue_UserStatusMuteAction& operator=(const SyncActionValue_UserStatusMuteAction& from) { - CopyFrom(from); - return *this; - } - inline SyncActionValue_UserStatusMuteAction& operator=(SyncActionValue_UserStatusMuteAction&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncActionValue_UserStatusMuteAction& default_instance() { - return *internal_default_instance(); - } - static inline const SyncActionValue_UserStatusMuteAction* internal_default_instance() { - return reinterpret_cast( - &_SyncActionValue_UserStatusMuteAction_default_instance_); - } - static constexpr int kIndexInFileMessages = - 203; - - friend void swap(SyncActionValue_UserStatusMuteAction& a, SyncActionValue_UserStatusMuteAction& b) { - a.Swap(&b); - } - inline void Swap(SyncActionValue_UserStatusMuteAction* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncActionValue_UserStatusMuteAction* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncActionValue_UserStatusMuteAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncActionValue_UserStatusMuteAction& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncActionValue_UserStatusMuteAction& from) { - SyncActionValue_UserStatusMuteAction::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncActionValue_UserStatusMuteAction* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncActionValue.UserStatusMuteAction"; - } - protected: - explicit SyncActionValue_UserStatusMuteAction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kMutedFieldNumber = 1, - }; - // optional bool muted = 1; - bool has_muted() const; - private: - bool _internal_has_muted() const; - public: - void clear_muted(); - bool muted() const; - void set_muted(bool value); - private: - bool _internal_muted() const; - void _internal_set_muted(bool value); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncActionValue.UserStatusMuteAction) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - bool muted_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncActionValue final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue) */ { - public: - inline SyncActionValue() : SyncActionValue(nullptr) {} - ~SyncActionValue() override; - explicit PROTOBUF_CONSTEXPR SyncActionValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncActionValue(const SyncActionValue& from); - SyncActionValue(SyncActionValue&& from) noexcept - : SyncActionValue() { - *this = ::std::move(from); - } - - inline SyncActionValue& operator=(const SyncActionValue& from) { - CopyFrom(from); - return *this; - } - inline SyncActionValue& operator=(SyncActionValue&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncActionValue& default_instance() { - return *internal_default_instance(); - } - static inline const SyncActionValue* internal_default_instance() { - return reinterpret_cast( - &_SyncActionValue_default_instance_); - } - static constexpr int kIndexInFileMessages = - 204; - - friend void swap(SyncActionValue& a, SyncActionValue& b) { - a.Swap(&b); - } - inline void Swap(SyncActionValue* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncActionValue* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncActionValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncActionValue& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncActionValue& from) { - SyncActionValue::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncActionValue* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncActionValue"; - } - protected: - explicit SyncActionValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef SyncActionValue_AgentAction AgentAction; - typedef SyncActionValue_AndroidUnsupportedActions AndroidUnsupportedActions; - typedef SyncActionValue_ArchiveChatAction ArchiveChatAction; - typedef SyncActionValue_ClearChatAction ClearChatAction; - typedef SyncActionValue_ContactAction ContactAction; - typedef SyncActionValue_DeleteChatAction DeleteChatAction; - typedef SyncActionValue_DeleteMessageForMeAction DeleteMessageForMeAction; - typedef SyncActionValue_KeyExpiration KeyExpiration; - typedef SyncActionValue_LabelAssociationAction LabelAssociationAction; - typedef SyncActionValue_LabelEditAction LabelEditAction; - typedef SyncActionValue_LocaleSetting LocaleSetting; - typedef SyncActionValue_MarkChatAsReadAction MarkChatAsReadAction; - typedef SyncActionValue_MuteAction MuteAction; - typedef SyncActionValue_NuxAction NuxAction; - typedef SyncActionValue_PinAction PinAction; - typedef SyncActionValue_PrimaryFeature PrimaryFeature; - typedef SyncActionValue_PrimaryVersionAction PrimaryVersionAction; - typedef SyncActionValue_PushNameSetting PushNameSetting; - typedef SyncActionValue_QuickReplyAction QuickReplyAction; - typedef SyncActionValue_RecentEmojiWeightsAction RecentEmojiWeightsAction; - typedef SyncActionValue_SecurityNotificationSetting SecurityNotificationSetting; - typedef SyncActionValue_StarAction StarAction; - typedef SyncActionValue_StickerAction StickerAction; - typedef SyncActionValue_SubscriptionAction SubscriptionAction; - typedef SyncActionValue_SyncActionMessageRange SyncActionMessageRange; - typedef SyncActionValue_SyncActionMessage SyncActionMessage; - typedef SyncActionValue_TimeFormatAction TimeFormatAction; - typedef SyncActionValue_UnarchiveChatsSetting UnarchiveChatsSetting; - typedef SyncActionValue_UserStatusMuteAction UserStatusMuteAction; - - // accessors ------------------------------------------------------- - - enum : int { - kStarActionFieldNumber = 2, - kContactActionFieldNumber = 3, - kMuteActionFieldNumber = 4, - kPinActionFieldNumber = 5, - kSecurityNotificationSettingFieldNumber = 6, - kPushNameSettingFieldNumber = 7, - kQuickReplyActionFieldNumber = 8, - kRecentEmojiWeightsActionFieldNumber = 11, - kLabelEditActionFieldNumber = 14, - kLabelAssociationActionFieldNumber = 15, - kLocaleSettingFieldNumber = 16, - kArchiveChatActionFieldNumber = 17, - kDeleteMessageForMeActionFieldNumber = 18, - kKeyExpirationFieldNumber = 19, - kMarkChatAsReadActionFieldNumber = 20, - kClearChatActionFieldNumber = 21, - kDeleteChatActionFieldNumber = 22, - kUnarchiveChatsSettingFieldNumber = 23, - kPrimaryFeatureFieldNumber = 24, - kAndroidUnsupportedActionsFieldNumber = 26, - kAgentActionFieldNumber = 27, - kSubscriptionActionFieldNumber = 28, - kUserStatusMuteActionFieldNumber = 29, - kTimeFormatActionFieldNumber = 30, - kNuxActionFieldNumber = 31, - kPrimaryVersionActionFieldNumber = 32, - kStickerActionFieldNumber = 33, - kTimestampFieldNumber = 1, - }; - // optional .proto.SyncActionValue.StarAction starAction = 2; - bool has_staraction() const; - private: - bool _internal_has_staraction() const; - public: - void clear_staraction(); - const ::proto::SyncActionValue_StarAction& staraction() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue_StarAction* release_staraction(); - ::proto::SyncActionValue_StarAction* mutable_staraction(); - void set_allocated_staraction(::proto::SyncActionValue_StarAction* staraction); - private: - const ::proto::SyncActionValue_StarAction& _internal_staraction() const; - ::proto::SyncActionValue_StarAction* _internal_mutable_staraction(); - public: - void unsafe_arena_set_allocated_staraction( - ::proto::SyncActionValue_StarAction* staraction); - ::proto::SyncActionValue_StarAction* unsafe_arena_release_staraction(); - - // optional .proto.SyncActionValue.ContactAction contactAction = 3; - bool has_contactaction() const; - private: - bool _internal_has_contactaction() const; - public: - void clear_contactaction(); - const ::proto::SyncActionValue_ContactAction& contactaction() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue_ContactAction* release_contactaction(); - ::proto::SyncActionValue_ContactAction* mutable_contactaction(); - void set_allocated_contactaction(::proto::SyncActionValue_ContactAction* contactaction); - private: - const ::proto::SyncActionValue_ContactAction& _internal_contactaction() const; - ::proto::SyncActionValue_ContactAction* _internal_mutable_contactaction(); - public: - void unsafe_arena_set_allocated_contactaction( - ::proto::SyncActionValue_ContactAction* contactaction); - ::proto::SyncActionValue_ContactAction* unsafe_arena_release_contactaction(); - - // optional .proto.SyncActionValue.MuteAction muteAction = 4; - bool has_muteaction() const; - private: - bool _internal_has_muteaction() const; - public: - void clear_muteaction(); - const ::proto::SyncActionValue_MuteAction& muteaction() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue_MuteAction* release_muteaction(); - ::proto::SyncActionValue_MuteAction* mutable_muteaction(); - void set_allocated_muteaction(::proto::SyncActionValue_MuteAction* muteaction); - private: - const ::proto::SyncActionValue_MuteAction& _internal_muteaction() const; - ::proto::SyncActionValue_MuteAction* _internal_mutable_muteaction(); - public: - void unsafe_arena_set_allocated_muteaction( - ::proto::SyncActionValue_MuteAction* muteaction); - ::proto::SyncActionValue_MuteAction* unsafe_arena_release_muteaction(); - - // optional .proto.SyncActionValue.PinAction pinAction = 5; - bool has_pinaction() const; - private: - bool _internal_has_pinaction() const; - public: - void clear_pinaction(); - const ::proto::SyncActionValue_PinAction& pinaction() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue_PinAction* release_pinaction(); - ::proto::SyncActionValue_PinAction* mutable_pinaction(); - void set_allocated_pinaction(::proto::SyncActionValue_PinAction* pinaction); - private: - const ::proto::SyncActionValue_PinAction& _internal_pinaction() const; - ::proto::SyncActionValue_PinAction* _internal_mutable_pinaction(); - public: - void unsafe_arena_set_allocated_pinaction( - ::proto::SyncActionValue_PinAction* pinaction); - ::proto::SyncActionValue_PinAction* unsafe_arena_release_pinaction(); - - // optional .proto.SyncActionValue.SecurityNotificationSetting securityNotificationSetting = 6; - bool has_securitynotificationsetting() const; - private: - bool _internal_has_securitynotificationsetting() const; - public: - void clear_securitynotificationsetting(); - const ::proto::SyncActionValue_SecurityNotificationSetting& securitynotificationsetting() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue_SecurityNotificationSetting* release_securitynotificationsetting(); - ::proto::SyncActionValue_SecurityNotificationSetting* mutable_securitynotificationsetting(); - void set_allocated_securitynotificationsetting(::proto::SyncActionValue_SecurityNotificationSetting* securitynotificationsetting); - private: - const ::proto::SyncActionValue_SecurityNotificationSetting& _internal_securitynotificationsetting() const; - ::proto::SyncActionValue_SecurityNotificationSetting* _internal_mutable_securitynotificationsetting(); - public: - void unsafe_arena_set_allocated_securitynotificationsetting( - ::proto::SyncActionValue_SecurityNotificationSetting* securitynotificationsetting); - ::proto::SyncActionValue_SecurityNotificationSetting* unsafe_arena_release_securitynotificationsetting(); - - // optional .proto.SyncActionValue.PushNameSetting pushNameSetting = 7; - bool has_pushnamesetting() const; - private: - bool _internal_has_pushnamesetting() const; - public: - void clear_pushnamesetting(); - const ::proto::SyncActionValue_PushNameSetting& pushnamesetting() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue_PushNameSetting* release_pushnamesetting(); - ::proto::SyncActionValue_PushNameSetting* mutable_pushnamesetting(); - void set_allocated_pushnamesetting(::proto::SyncActionValue_PushNameSetting* pushnamesetting); - private: - const ::proto::SyncActionValue_PushNameSetting& _internal_pushnamesetting() const; - ::proto::SyncActionValue_PushNameSetting* _internal_mutable_pushnamesetting(); - public: - void unsafe_arena_set_allocated_pushnamesetting( - ::proto::SyncActionValue_PushNameSetting* pushnamesetting); - ::proto::SyncActionValue_PushNameSetting* unsafe_arena_release_pushnamesetting(); - - // optional .proto.SyncActionValue.QuickReplyAction quickReplyAction = 8; - bool has_quickreplyaction() const; - private: - bool _internal_has_quickreplyaction() const; - public: - void clear_quickreplyaction(); - const ::proto::SyncActionValue_QuickReplyAction& quickreplyaction() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue_QuickReplyAction* release_quickreplyaction(); - ::proto::SyncActionValue_QuickReplyAction* mutable_quickreplyaction(); - void set_allocated_quickreplyaction(::proto::SyncActionValue_QuickReplyAction* quickreplyaction); - private: - const ::proto::SyncActionValue_QuickReplyAction& _internal_quickreplyaction() const; - ::proto::SyncActionValue_QuickReplyAction* _internal_mutable_quickreplyaction(); - public: - void unsafe_arena_set_allocated_quickreplyaction( - ::proto::SyncActionValue_QuickReplyAction* quickreplyaction); - ::proto::SyncActionValue_QuickReplyAction* unsafe_arena_release_quickreplyaction(); - - // optional .proto.SyncActionValue.RecentEmojiWeightsAction recentEmojiWeightsAction = 11; - bool has_recentemojiweightsaction() const; - private: - bool _internal_has_recentemojiweightsaction() const; - public: - void clear_recentemojiweightsaction(); - const ::proto::SyncActionValue_RecentEmojiWeightsAction& recentemojiweightsaction() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue_RecentEmojiWeightsAction* release_recentemojiweightsaction(); - ::proto::SyncActionValue_RecentEmojiWeightsAction* mutable_recentemojiweightsaction(); - void set_allocated_recentemojiweightsaction(::proto::SyncActionValue_RecentEmojiWeightsAction* recentemojiweightsaction); - private: - const ::proto::SyncActionValue_RecentEmojiWeightsAction& _internal_recentemojiweightsaction() const; - ::proto::SyncActionValue_RecentEmojiWeightsAction* _internal_mutable_recentemojiweightsaction(); - public: - void unsafe_arena_set_allocated_recentemojiweightsaction( - ::proto::SyncActionValue_RecentEmojiWeightsAction* recentemojiweightsaction); - ::proto::SyncActionValue_RecentEmojiWeightsAction* unsafe_arena_release_recentemojiweightsaction(); - - // optional .proto.SyncActionValue.LabelEditAction labelEditAction = 14; - bool has_labeleditaction() const; - private: - bool _internal_has_labeleditaction() const; - public: - void clear_labeleditaction(); - const ::proto::SyncActionValue_LabelEditAction& labeleditaction() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue_LabelEditAction* release_labeleditaction(); - ::proto::SyncActionValue_LabelEditAction* mutable_labeleditaction(); - void set_allocated_labeleditaction(::proto::SyncActionValue_LabelEditAction* labeleditaction); - private: - const ::proto::SyncActionValue_LabelEditAction& _internal_labeleditaction() const; - ::proto::SyncActionValue_LabelEditAction* _internal_mutable_labeleditaction(); - public: - void unsafe_arena_set_allocated_labeleditaction( - ::proto::SyncActionValue_LabelEditAction* labeleditaction); - ::proto::SyncActionValue_LabelEditAction* unsafe_arena_release_labeleditaction(); - - // optional .proto.SyncActionValue.LabelAssociationAction labelAssociationAction = 15; - bool has_labelassociationaction() const; - private: - bool _internal_has_labelassociationaction() const; - public: - void clear_labelassociationaction(); - const ::proto::SyncActionValue_LabelAssociationAction& labelassociationaction() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue_LabelAssociationAction* release_labelassociationaction(); - ::proto::SyncActionValue_LabelAssociationAction* mutable_labelassociationaction(); - void set_allocated_labelassociationaction(::proto::SyncActionValue_LabelAssociationAction* labelassociationaction); - private: - const ::proto::SyncActionValue_LabelAssociationAction& _internal_labelassociationaction() const; - ::proto::SyncActionValue_LabelAssociationAction* _internal_mutable_labelassociationaction(); - public: - void unsafe_arena_set_allocated_labelassociationaction( - ::proto::SyncActionValue_LabelAssociationAction* labelassociationaction); - ::proto::SyncActionValue_LabelAssociationAction* unsafe_arena_release_labelassociationaction(); - - // optional .proto.SyncActionValue.LocaleSetting localeSetting = 16; - bool has_localesetting() const; - private: - bool _internal_has_localesetting() const; - public: - void clear_localesetting(); - const ::proto::SyncActionValue_LocaleSetting& localesetting() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue_LocaleSetting* release_localesetting(); - ::proto::SyncActionValue_LocaleSetting* mutable_localesetting(); - void set_allocated_localesetting(::proto::SyncActionValue_LocaleSetting* localesetting); - private: - const ::proto::SyncActionValue_LocaleSetting& _internal_localesetting() const; - ::proto::SyncActionValue_LocaleSetting* _internal_mutable_localesetting(); - public: - void unsafe_arena_set_allocated_localesetting( - ::proto::SyncActionValue_LocaleSetting* localesetting); - ::proto::SyncActionValue_LocaleSetting* unsafe_arena_release_localesetting(); - - // optional .proto.SyncActionValue.ArchiveChatAction archiveChatAction = 17; - bool has_archivechataction() const; - private: - bool _internal_has_archivechataction() const; - public: - void clear_archivechataction(); - const ::proto::SyncActionValue_ArchiveChatAction& archivechataction() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue_ArchiveChatAction* release_archivechataction(); - ::proto::SyncActionValue_ArchiveChatAction* mutable_archivechataction(); - void set_allocated_archivechataction(::proto::SyncActionValue_ArchiveChatAction* archivechataction); - private: - const ::proto::SyncActionValue_ArchiveChatAction& _internal_archivechataction() const; - ::proto::SyncActionValue_ArchiveChatAction* _internal_mutable_archivechataction(); - public: - void unsafe_arena_set_allocated_archivechataction( - ::proto::SyncActionValue_ArchiveChatAction* archivechataction); - ::proto::SyncActionValue_ArchiveChatAction* unsafe_arena_release_archivechataction(); - - // optional .proto.SyncActionValue.DeleteMessageForMeAction deleteMessageForMeAction = 18; - bool has_deletemessageformeaction() const; - private: - bool _internal_has_deletemessageformeaction() const; - public: - void clear_deletemessageformeaction(); - const ::proto::SyncActionValue_DeleteMessageForMeAction& deletemessageformeaction() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue_DeleteMessageForMeAction* release_deletemessageformeaction(); - ::proto::SyncActionValue_DeleteMessageForMeAction* mutable_deletemessageformeaction(); - void set_allocated_deletemessageformeaction(::proto::SyncActionValue_DeleteMessageForMeAction* deletemessageformeaction); - private: - const ::proto::SyncActionValue_DeleteMessageForMeAction& _internal_deletemessageformeaction() const; - ::proto::SyncActionValue_DeleteMessageForMeAction* _internal_mutable_deletemessageformeaction(); - public: - void unsafe_arena_set_allocated_deletemessageformeaction( - ::proto::SyncActionValue_DeleteMessageForMeAction* deletemessageformeaction); - ::proto::SyncActionValue_DeleteMessageForMeAction* unsafe_arena_release_deletemessageformeaction(); - - // optional .proto.SyncActionValue.KeyExpiration keyExpiration = 19; - bool has_keyexpiration() const; - private: - bool _internal_has_keyexpiration() const; - public: - void clear_keyexpiration(); - const ::proto::SyncActionValue_KeyExpiration& keyexpiration() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue_KeyExpiration* release_keyexpiration(); - ::proto::SyncActionValue_KeyExpiration* mutable_keyexpiration(); - void set_allocated_keyexpiration(::proto::SyncActionValue_KeyExpiration* keyexpiration); - private: - const ::proto::SyncActionValue_KeyExpiration& _internal_keyexpiration() const; - ::proto::SyncActionValue_KeyExpiration* _internal_mutable_keyexpiration(); - public: - void unsafe_arena_set_allocated_keyexpiration( - ::proto::SyncActionValue_KeyExpiration* keyexpiration); - ::proto::SyncActionValue_KeyExpiration* unsafe_arena_release_keyexpiration(); - - // optional .proto.SyncActionValue.MarkChatAsReadAction markChatAsReadAction = 20; - bool has_markchatasreadaction() const; - private: - bool _internal_has_markchatasreadaction() const; - public: - void clear_markchatasreadaction(); - const ::proto::SyncActionValue_MarkChatAsReadAction& markchatasreadaction() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue_MarkChatAsReadAction* release_markchatasreadaction(); - ::proto::SyncActionValue_MarkChatAsReadAction* mutable_markchatasreadaction(); - void set_allocated_markchatasreadaction(::proto::SyncActionValue_MarkChatAsReadAction* markchatasreadaction); - private: - const ::proto::SyncActionValue_MarkChatAsReadAction& _internal_markchatasreadaction() const; - ::proto::SyncActionValue_MarkChatAsReadAction* _internal_mutable_markchatasreadaction(); - public: - void unsafe_arena_set_allocated_markchatasreadaction( - ::proto::SyncActionValue_MarkChatAsReadAction* markchatasreadaction); - ::proto::SyncActionValue_MarkChatAsReadAction* unsafe_arena_release_markchatasreadaction(); - - // optional .proto.SyncActionValue.ClearChatAction clearChatAction = 21; - bool has_clearchataction() const; - private: - bool _internal_has_clearchataction() const; - public: - void clear_clearchataction(); - const ::proto::SyncActionValue_ClearChatAction& clearchataction() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue_ClearChatAction* release_clearchataction(); - ::proto::SyncActionValue_ClearChatAction* mutable_clearchataction(); - void set_allocated_clearchataction(::proto::SyncActionValue_ClearChatAction* clearchataction); - private: - const ::proto::SyncActionValue_ClearChatAction& _internal_clearchataction() const; - ::proto::SyncActionValue_ClearChatAction* _internal_mutable_clearchataction(); - public: - void unsafe_arena_set_allocated_clearchataction( - ::proto::SyncActionValue_ClearChatAction* clearchataction); - ::proto::SyncActionValue_ClearChatAction* unsafe_arena_release_clearchataction(); - - // optional .proto.SyncActionValue.DeleteChatAction deleteChatAction = 22; - bool has_deletechataction() const; - private: - bool _internal_has_deletechataction() const; - public: - void clear_deletechataction(); - const ::proto::SyncActionValue_DeleteChatAction& deletechataction() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue_DeleteChatAction* release_deletechataction(); - ::proto::SyncActionValue_DeleteChatAction* mutable_deletechataction(); - void set_allocated_deletechataction(::proto::SyncActionValue_DeleteChatAction* deletechataction); - private: - const ::proto::SyncActionValue_DeleteChatAction& _internal_deletechataction() const; - ::proto::SyncActionValue_DeleteChatAction* _internal_mutable_deletechataction(); - public: - void unsafe_arena_set_allocated_deletechataction( - ::proto::SyncActionValue_DeleteChatAction* deletechataction); - ::proto::SyncActionValue_DeleteChatAction* unsafe_arena_release_deletechataction(); - - // optional .proto.SyncActionValue.UnarchiveChatsSetting unarchiveChatsSetting = 23; - bool has_unarchivechatssetting() const; - private: - bool _internal_has_unarchivechatssetting() const; - public: - void clear_unarchivechatssetting(); - const ::proto::SyncActionValue_UnarchiveChatsSetting& unarchivechatssetting() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue_UnarchiveChatsSetting* release_unarchivechatssetting(); - ::proto::SyncActionValue_UnarchiveChatsSetting* mutable_unarchivechatssetting(); - void set_allocated_unarchivechatssetting(::proto::SyncActionValue_UnarchiveChatsSetting* unarchivechatssetting); - private: - const ::proto::SyncActionValue_UnarchiveChatsSetting& _internal_unarchivechatssetting() const; - ::proto::SyncActionValue_UnarchiveChatsSetting* _internal_mutable_unarchivechatssetting(); - public: - void unsafe_arena_set_allocated_unarchivechatssetting( - ::proto::SyncActionValue_UnarchiveChatsSetting* unarchivechatssetting); - ::proto::SyncActionValue_UnarchiveChatsSetting* unsafe_arena_release_unarchivechatssetting(); - - // optional .proto.SyncActionValue.PrimaryFeature primaryFeature = 24; - bool has_primaryfeature() const; - private: - bool _internal_has_primaryfeature() const; - public: - void clear_primaryfeature(); - const ::proto::SyncActionValue_PrimaryFeature& primaryfeature() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue_PrimaryFeature* release_primaryfeature(); - ::proto::SyncActionValue_PrimaryFeature* mutable_primaryfeature(); - void set_allocated_primaryfeature(::proto::SyncActionValue_PrimaryFeature* primaryfeature); - private: - const ::proto::SyncActionValue_PrimaryFeature& _internal_primaryfeature() const; - ::proto::SyncActionValue_PrimaryFeature* _internal_mutable_primaryfeature(); - public: - void unsafe_arena_set_allocated_primaryfeature( - ::proto::SyncActionValue_PrimaryFeature* primaryfeature); - ::proto::SyncActionValue_PrimaryFeature* unsafe_arena_release_primaryfeature(); - - // optional .proto.SyncActionValue.AndroidUnsupportedActions androidUnsupportedActions = 26; - bool has_androidunsupportedactions() const; - private: - bool _internal_has_androidunsupportedactions() const; - public: - void clear_androidunsupportedactions(); - const ::proto::SyncActionValue_AndroidUnsupportedActions& androidunsupportedactions() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue_AndroidUnsupportedActions* release_androidunsupportedactions(); - ::proto::SyncActionValue_AndroidUnsupportedActions* mutable_androidunsupportedactions(); - void set_allocated_androidunsupportedactions(::proto::SyncActionValue_AndroidUnsupportedActions* androidunsupportedactions); - private: - const ::proto::SyncActionValue_AndroidUnsupportedActions& _internal_androidunsupportedactions() const; - ::proto::SyncActionValue_AndroidUnsupportedActions* _internal_mutable_androidunsupportedactions(); - public: - void unsafe_arena_set_allocated_androidunsupportedactions( - ::proto::SyncActionValue_AndroidUnsupportedActions* androidunsupportedactions); - ::proto::SyncActionValue_AndroidUnsupportedActions* unsafe_arena_release_androidunsupportedactions(); - - // optional .proto.SyncActionValue.AgentAction agentAction = 27; - bool has_agentaction() const; - private: - bool _internal_has_agentaction() const; - public: - void clear_agentaction(); - const ::proto::SyncActionValue_AgentAction& agentaction() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue_AgentAction* release_agentaction(); - ::proto::SyncActionValue_AgentAction* mutable_agentaction(); - void set_allocated_agentaction(::proto::SyncActionValue_AgentAction* agentaction); - private: - const ::proto::SyncActionValue_AgentAction& _internal_agentaction() const; - ::proto::SyncActionValue_AgentAction* _internal_mutable_agentaction(); - public: - void unsafe_arena_set_allocated_agentaction( - ::proto::SyncActionValue_AgentAction* agentaction); - ::proto::SyncActionValue_AgentAction* unsafe_arena_release_agentaction(); - - // optional .proto.SyncActionValue.SubscriptionAction subscriptionAction = 28; - bool has_subscriptionaction() const; - private: - bool _internal_has_subscriptionaction() const; - public: - void clear_subscriptionaction(); - const ::proto::SyncActionValue_SubscriptionAction& subscriptionaction() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue_SubscriptionAction* release_subscriptionaction(); - ::proto::SyncActionValue_SubscriptionAction* mutable_subscriptionaction(); - void set_allocated_subscriptionaction(::proto::SyncActionValue_SubscriptionAction* subscriptionaction); - private: - const ::proto::SyncActionValue_SubscriptionAction& _internal_subscriptionaction() const; - ::proto::SyncActionValue_SubscriptionAction* _internal_mutable_subscriptionaction(); - public: - void unsafe_arena_set_allocated_subscriptionaction( - ::proto::SyncActionValue_SubscriptionAction* subscriptionaction); - ::proto::SyncActionValue_SubscriptionAction* unsafe_arena_release_subscriptionaction(); - - // optional .proto.SyncActionValue.UserStatusMuteAction userStatusMuteAction = 29; - bool has_userstatusmuteaction() const; - private: - bool _internal_has_userstatusmuteaction() const; - public: - void clear_userstatusmuteaction(); - const ::proto::SyncActionValue_UserStatusMuteAction& userstatusmuteaction() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue_UserStatusMuteAction* release_userstatusmuteaction(); - ::proto::SyncActionValue_UserStatusMuteAction* mutable_userstatusmuteaction(); - void set_allocated_userstatusmuteaction(::proto::SyncActionValue_UserStatusMuteAction* userstatusmuteaction); - private: - const ::proto::SyncActionValue_UserStatusMuteAction& _internal_userstatusmuteaction() const; - ::proto::SyncActionValue_UserStatusMuteAction* _internal_mutable_userstatusmuteaction(); - public: - void unsafe_arena_set_allocated_userstatusmuteaction( - ::proto::SyncActionValue_UserStatusMuteAction* userstatusmuteaction); - ::proto::SyncActionValue_UserStatusMuteAction* unsafe_arena_release_userstatusmuteaction(); - - // optional .proto.SyncActionValue.TimeFormatAction timeFormatAction = 30; - bool has_timeformataction() const; - private: - bool _internal_has_timeformataction() const; - public: - void clear_timeformataction(); - const ::proto::SyncActionValue_TimeFormatAction& timeformataction() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue_TimeFormatAction* release_timeformataction(); - ::proto::SyncActionValue_TimeFormatAction* mutable_timeformataction(); - void set_allocated_timeformataction(::proto::SyncActionValue_TimeFormatAction* timeformataction); - private: - const ::proto::SyncActionValue_TimeFormatAction& _internal_timeformataction() const; - ::proto::SyncActionValue_TimeFormatAction* _internal_mutable_timeformataction(); - public: - void unsafe_arena_set_allocated_timeformataction( - ::proto::SyncActionValue_TimeFormatAction* timeformataction); - ::proto::SyncActionValue_TimeFormatAction* unsafe_arena_release_timeformataction(); - - // optional .proto.SyncActionValue.NuxAction nuxAction = 31; - bool has_nuxaction() const; - private: - bool _internal_has_nuxaction() const; - public: - void clear_nuxaction(); - const ::proto::SyncActionValue_NuxAction& nuxaction() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue_NuxAction* release_nuxaction(); - ::proto::SyncActionValue_NuxAction* mutable_nuxaction(); - void set_allocated_nuxaction(::proto::SyncActionValue_NuxAction* nuxaction); - private: - const ::proto::SyncActionValue_NuxAction& _internal_nuxaction() const; - ::proto::SyncActionValue_NuxAction* _internal_mutable_nuxaction(); - public: - void unsafe_arena_set_allocated_nuxaction( - ::proto::SyncActionValue_NuxAction* nuxaction); - ::proto::SyncActionValue_NuxAction* unsafe_arena_release_nuxaction(); - - // optional .proto.SyncActionValue.PrimaryVersionAction primaryVersionAction = 32; - bool has_primaryversionaction() const; - private: - bool _internal_has_primaryversionaction() const; - public: - void clear_primaryversionaction(); - const ::proto::SyncActionValue_PrimaryVersionAction& primaryversionaction() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue_PrimaryVersionAction* release_primaryversionaction(); - ::proto::SyncActionValue_PrimaryVersionAction* mutable_primaryversionaction(); - void set_allocated_primaryversionaction(::proto::SyncActionValue_PrimaryVersionAction* primaryversionaction); - private: - const ::proto::SyncActionValue_PrimaryVersionAction& _internal_primaryversionaction() const; - ::proto::SyncActionValue_PrimaryVersionAction* _internal_mutable_primaryversionaction(); - public: - void unsafe_arena_set_allocated_primaryversionaction( - ::proto::SyncActionValue_PrimaryVersionAction* primaryversionaction); - ::proto::SyncActionValue_PrimaryVersionAction* unsafe_arena_release_primaryversionaction(); - - // optional .proto.SyncActionValue.StickerAction stickerAction = 33; - bool has_stickeraction() const; - private: - bool _internal_has_stickeraction() const; - public: - void clear_stickeraction(); - const ::proto::SyncActionValue_StickerAction& stickeraction() const; - PROTOBUF_NODISCARD ::proto::SyncActionValue_StickerAction* release_stickeraction(); - ::proto::SyncActionValue_StickerAction* mutable_stickeraction(); - void set_allocated_stickeraction(::proto::SyncActionValue_StickerAction* stickeraction); - private: - const ::proto::SyncActionValue_StickerAction& _internal_stickeraction() const; - ::proto::SyncActionValue_StickerAction* _internal_mutable_stickeraction(); - public: - void unsafe_arena_set_allocated_stickeraction( - ::proto::SyncActionValue_StickerAction* stickeraction); - ::proto::SyncActionValue_StickerAction* unsafe_arena_release_stickeraction(); - - // optional int64 timestamp = 1; - bool has_timestamp() const; - private: - bool _internal_has_timestamp() const; - public: - void clear_timestamp(); - int64_t timestamp() const; - void set_timestamp(int64_t value); - private: - int64_t _internal_timestamp() const; - void _internal_set_timestamp(int64_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncActionValue) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::proto::SyncActionValue_StarAction* staraction_; - ::proto::SyncActionValue_ContactAction* contactaction_; - ::proto::SyncActionValue_MuteAction* muteaction_; - ::proto::SyncActionValue_PinAction* pinaction_; - ::proto::SyncActionValue_SecurityNotificationSetting* securitynotificationsetting_; - ::proto::SyncActionValue_PushNameSetting* pushnamesetting_; - ::proto::SyncActionValue_QuickReplyAction* quickreplyaction_; - ::proto::SyncActionValue_RecentEmojiWeightsAction* recentemojiweightsaction_; - ::proto::SyncActionValue_LabelEditAction* labeleditaction_; - ::proto::SyncActionValue_LabelAssociationAction* labelassociationaction_; - ::proto::SyncActionValue_LocaleSetting* localesetting_; - ::proto::SyncActionValue_ArchiveChatAction* archivechataction_; - ::proto::SyncActionValue_DeleteMessageForMeAction* deletemessageformeaction_; - ::proto::SyncActionValue_KeyExpiration* keyexpiration_; - ::proto::SyncActionValue_MarkChatAsReadAction* markchatasreadaction_; - ::proto::SyncActionValue_ClearChatAction* clearchataction_; - ::proto::SyncActionValue_DeleteChatAction* deletechataction_; - ::proto::SyncActionValue_UnarchiveChatsSetting* unarchivechatssetting_; - ::proto::SyncActionValue_PrimaryFeature* primaryfeature_; - ::proto::SyncActionValue_AndroidUnsupportedActions* androidunsupportedactions_; - ::proto::SyncActionValue_AgentAction* agentaction_; - ::proto::SyncActionValue_SubscriptionAction* subscriptionaction_; - ::proto::SyncActionValue_UserStatusMuteAction* userstatusmuteaction_; - ::proto::SyncActionValue_TimeFormatAction* timeformataction_; - ::proto::SyncActionValue_NuxAction* nuxaction_; - ::proto::SyncActionValue_PrimaryVersionAction* primaryversionaction_; - ::proto::SyncActionValue_StickerAction* stickeraction_; - int64_t timestamp_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncdIndex final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdIndex) */ { - public: - inline SyncdIndex() : SyncdIndex(nullptr) {} - ~SyncdIndex() override; - explicit PROTOBUF_CONSTEXPR SyncdIndex(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncdIndex(const SyncdIndex& from); - SyncdIndex(SyncdIndex&& from) noexcept - : SyncdIndex() { - *this = ::std::move(from); - } - - inline SyncdIndex& operator=(const SyncdIndex& from) { - CopyFrom(from); - return *this; - } - inline SyncdIndex& operator=(SyncdIndex&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncdIndex& default_instance() { - return *internal_default_instance(); - } - static inline const SyncdIndex* internal_default_instance() { - return reinterpret_cast( - &_SyncdIndex_default_instance_); - } - static constexpr int kIndexInFileMessages = - 205; - - friend void swap(SyncdIndex& a, SyncdIndex& b) { - a.Swap(&b); - } - inline void Swap(SyncdIndex* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncdIndex* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncdIndex* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncdIndex& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncdIndex& from) { - SyncdIndex::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncdIndex* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncdIndex"; - } - protected: - explicit SyncdIndex(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kBlobFieldNumber = 1, - }; - // optional bytes blob = 1; - bool has_blob() const; - private: - bool _internal_has_blob() const; - public: - void clear_blob(); - const std::string& blob() const; - template - void set_blob(ArgT0&& arg0, ArgT... args); - std::string* mutable_blob(); - PROTOBUF_NODISCARD std::string* release_blob(); - void set_allocated_blob(std::string* blob); - private: - const std::string& _internal_blob() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_blob(const std::string& value); - std::string* _internal_mutable_blob(); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncdIndex) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr blob_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncdMutation final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdMutation) */ { - public: - inline SyncdMutation() : SyncdMutation(nullptr) {} - ~SyncdMutation() override; - explicit PROTOBUF_CONSTEXPR SyncdMutation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncdMutation(const SyncdMutation& from); - SyncdMutation(SyncdMutation&& from) noexcept - : SyncdMutation() { - *this = ::std::move(from); - } - - inline SyncdMutation& operator=(const SyncdMutation& from) { - CopyFrom(from); - return *this; - } - inline SyncdMutation& operator=(SyncdMutation&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncdMutation& default_instance() { - return *internal_default_instance(); - } - static inline const SyncdMutation* internal_default_instance() { - return reinterpret_cast( - &_SyncdMutation_default_instance_); - } - static constexpr int kIndexInFileMessages = - 206; - - friend void swap(SyncdMutation& a, SyncdMutation& b) { - a.Swap(&b); - } - inline void Swap(SyncdMutation* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncdMutation* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncdMutation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncdMutation& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncdMutation& from) { - SyncdMutation::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncdMutation* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncdMutation"; - } - protected: - explicit SyncdMutation(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef SyncdMutation_SyncdOperation SyncdOperation; - static constexpr SyncdOperation SET = - SyncdMutation_SyncdOperation_SET; - static constexpr SyncdOperation REMOVE = - SyncdMutation_SyncdOperation_REMOVE; - static inline bool SyncdOperation_IsValid(int value) { - return SyncdMutation_SyncdOperation_IsValid(value); - } - static constexpr SyncdOperation SyncdOperation_MIN = - SyncdMutation_SyncdOperation_SyncdOperation_MIN; - static constexpr SyncdOperation SyncdOperation_MAX = - SyncdMutation_SyncdOperation_SyncdOperation_MAX; - static constexpr int SyncdOperation_ARRAYSIZE = - SyncdMutation_SyncdOperation_SyncdOperation_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - SyncdOperation_descriptor() { - return SyncdMutation_SyncdOperation_descriptor(); - } - template - static inline const std::string& SyncdOperation_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function SyncdOperation_Name."); - return SyncdMutation_SyncdOperation_Name(enum_t_value); - } - static inline bool SyncdOperation_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - SyncdOperation* value) { - return SyncdMutation_SyncdOperation_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kRecordFieldNumber = 2, - kOperationFieldNumber = 1, - }; - // optional .proto.SyncdRecord record = 2; - bool has_record() const; - private: - bool _internal_has_record() const; - public: - void clear_record(); - const ::proto::SyncdRecord& record() const; - PROTOBUF_NODISCARD ::proto::SyncdRecord* release_record(); - ::proto::SyncdRecord* mutable_record(); - void set_allocated_record(::proto::SyncdRecord* record); - private: - const ::proto::SyncdRecord& _internal_record() const; - ::proto::SyncdRecord* _internal_mutable_record(); - public: - void unsafe_arena_set_allocated_record( - ::proto::SyncdRecord* record); - ::proto::SyncdRecord* unsafe_arena_release_record(); - - // optional .proto.SyncdMutation.SyncdOperation operation = 1; - bool has_operation() const; - private: - bool _internal_has_operation() const; - public: - void clear_operation(); - ::proto::SyncdMutation_SyncdOperation operation() const; - void set_operation(::proto::SyncdMutation_SyncdOperation value); - private: - ::proto::SyncdMutation_SyncdOperation _internal_operation() const; - void _internal_set_operation(::proto::SyncdMutation_SyncdOperation value); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncdMutation) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::proto::SyncdRecord* record_; - int operation_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncdMutations final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdMutations) */ { - public: - inline SyncdMutations() : SyncdMutations(nullptr) {} - ~SyncdMutations() override; - explicit PROTOBUF_CONSTEXPR SyncdMutations(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncdMutations(const SyncdMutations& from); - SyncdMutations(SyncdMutations&& from) noexcept - : SyncdMutations() { - *this = ::std::move(from); - } - - inline SyncdMutations& operator=(const SyncdMutations& from) { - CopyFrom(from); - return *this; - } - inline SyncdMutations& operator=(SyncdMutations&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncdMutations& default_instance() { - return *internal_default_instance(); - } - static inline const SyncdMutations* internal_default_instance() { - return reinterpret_cast( - &_SyncdMutations_default_instance_); - } - static constexpr int kIndexInFileMessages = - 207; - - friend void swap(SyncdMutations& a, SyncdMutations& b) { - a.Swap(&b); - } - inline void Swap(SyncdMutations* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncdMutations* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncdMutations* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncdMutations& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncdMutations& from) { - SyncdMutations::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncdMutations* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncdMutations"; - } - protected: - explicit SyncdMutations(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kMutationsFieldNumber = 1, - }; - // repeated .proto.SyncdMutation mutations = 1; - int mutations_size() const; - private: - int _internal_mutations_size() const; - public: - void clear_mutations(); - ::proto::SyncdMutation* mutable_mutations(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >* - mutable_mutations(); - private: - const ::proto::SyncdMutation& _internal_mutations(int index) const; - ::proto::SyncdMutation* _internal_add_mutations(); - public: - const ::proto::SyncdMutation& mutations(int index) const; - ::proto::SyncdMutation* add_mutations(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >& - mutations() const; - - // @@protoc_insertion_point(class_scope:proto.SyncdMutations) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation > mutations_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncdPatch final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdPatch) */ { - public: - inline SyncdPatch() : SyncdPatch(nullptr) {} - ~SyncdPatch() override; - explicit PROTOBUF_CONSTEXPR SyncdPatch(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncdPatch(const SyncdPatch& from); - SyncdPatch(SyncdPatch&& from) noexcept - : SyncdPatch() { - *this = ::std::move(from); - } - - inline SyncdPatch& operator=(const SyncdPatch& from) { - CopyFrom(from); - return *this; - } - inline SyncdPatch& operator=(SyncdPatch&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncdPatch& default_instance() { - return *internal_default_instance(); - } - static inline const SyncdPatch* internal_default_instance() { - return reinterpret_cast( - &_SyncdPatch_default_instance_); - } - static constexpr int kIndexInFileMessages = - 208; - - friend void swap(SyncdPatch& a, SyncdPatch& b) { - a.Swap(&b); - } - inline void Swap(SyncdPatch* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncdPatch* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncdPatch* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncdPatch& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncdPatch& from) { - SyncdPatch::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncdPatch* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncdPatch"; - } - protected: - explicit SyncdPatch(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kMutationsFieldNumber = 2, - kSnapshotMacFieldNumber = 4, - kPatchMacFieldNumber = 5, - kVersionFieldNumber = 1, - kExternalMutationsFieldNumber = 3, - kKeyIdFieldNumber = 6, - kExitCodeFieldNumber = 7, - kDeviceIndexFieldNumber = 8, - }; - // repeated .proto.SyncdMutation mutations = 2; - int mutations_size() const; - private: - int _internal_mutations_size() const; - public: - void clear_mutations(); - ::proto::SyncdMutation* mutable_mutations(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >* - mutable_mutations(); - private: - const ::proto::SyncdMutation& _internal_mutations(int index) const; - ::proto::SyncdMutation* _internal_add_mutations(); - public: - const ::proto::SyncdMutation& mutations(int index) const; - ::proto::SyncdMutation* add_mutations(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >& - mutations() const; - - // optional bytes snapshotMac = 4; - bool has_snapshotmac() const; - private: - bool _internal_has_snapshotmac() const; - public: - void clear_snapshotmac(); - const std::string& snapshotmac() const; - template - void set_snapshotmac(ArgT0&& arg0, ArgT... args); - std::string* mutable_snapshotmac(); - PROTOBUF_NODISCARD std::string* release_snapshotmac(); - void set_allocated_snapshotmac(std::string* snapshotmac); - private: - const std::string& _internal_snapshotmac() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_snapshotmac(const std::string& value); - std::string* _internal_mutable_snapshotmac(); - public: - - // optional bytes patchMac = 5; - bool has_patchmac() const; - private: - bool _internal_has_patchmac() const; - public: - void clear_patchmac(); - const std::string& patchmac() const; - template - void set_patchmac(ArgT0&& arg0, ArgT... args); - std::string* mutable_patchmac(); - PROTOBUF_NODISCARD std::string* release_patchmac(); - void set_allocated_patchmac(std::string* patchmac); - private: - const std::string& _internal_patchmac() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_patchmac(const std::string& value); - std::string* _internal_mutable_patchmac(); - public: - - // optional .proto.SyncdVersion version = 1; - bool has_version() const; - private: - bool _internal_has_version() const; - public: - void clear_version(); - const ::proto::SyncdVersion& version() const; - PROTOBUF_NODISCARD ::proto::SyncdVersion* release_version(); - ::proto::SyncdVersion* mutable_version(); - void set_allocated_version(::proto::SyncdVersion* version); - private: - const ::proto::SyncdVersion& _internal_version() const; - ::proto::SyncdVersion* _internal_mutable_version(); - public: - void unsafe_arena_set_allocated_version( - ::proto::SyncdVersion* version); - ::proto::SyncdVersion* unsafe_arena_release_version(); - - // optional .proto.ExternalBlobReference externalMutations = 3; - bool has_externalmutations() const; - private: - bool _internal_has_externalmutations() const; - public: - void clear_externalmutations(); - const ::proto::ExternalBlobReference& externalmutations() const; - PROTOBUF_NODISCARD ::proto::ExternalBlobReference* release_externalmutations(); - ::proto::ExternalBlobReference* mutable_externalmutations(); - void set_allocated_externalmutations(::proto::ExternalBlobReference* externalmutations); - private: - const ::proto::ExternalBlobReference& _internal_externalmutations() const; - ::proto::ExternalBlobReference* _internal_mutable_externalmutations(); - public: - void unsafe_arena_set_allocated_externalmutations( - ::proto::ExternalBlobReference* externalmutations); - ::proto::ExternalBlobReference* unsafe_arena_release_externalmutations(); - - // optional .proto.KeyId keyId = 6; - bool has_keyid() const; - private: - bool _internal_has_keyid() const; - public: - void clear_keyid(); - const ::proto::KeyId& keyid() const; - PROTOBUF_NODISCARD ::proto::KeyId* release_keyid(); - ::proto::KeyId* mutable_keyid(); - void set_allocated_keyid(::proto::KeyId* keyid); - private: - const ::proto::KeyId& _internal_keyid() const; - ::proto::KeyId* _internal_mutable_keyid(); - public: - void unsafe_arena_set_allocated_keyid( - ::proto::KeyId* keyid); - ::proto::KeyId* unsafe_arena_release_keyid(); - - // optional .proto.ExitCode exitCode = 7; - bool has_exitcode() const; - private: - bool _internal_has_exitcode() const; - public: - void clear_exitcode(); - const ::proto::ExitCode& exitcode() const; - PROTOBUF_NODISCARD ::proto::ExitCode* release_exitcode(); - ::proto::ExitCode* mutable_exitcode(); - void set_allocated_exitcode(::proto::ExitCode* exitcode); - private: - const ::proto::ExitCode& _internal_exitcode() const; - ::proto::ExitCode* _internal_mutable_exitcode(); - public: - void unsafe_arena_set_allocated_exitcode( - ::proto::ExitCode* exitcode); - ::proto::ExitCode* unsafe_arena_release_exitcode(); - - // optional uint32 deviceIndex = 8; - bool has_deviceindex() const; - private: - bool _internal_has_deviceindex() const; - public: - void clear_deviceindex(); - uint32_t deviceindex() const; - void set_deviceindex(uint32_t value); - private: - uint32_t _internal_deviceindex() const; - void _internal_set_deviceindex(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncdPatch) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation > mutations_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr snapshotmac_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr patchmac_; - ::proto::SyncdVersion* version_; - ::proto::ExternalBlobReference* externalmutations_; - ::proto::KeyId* keyid_; - ::proto::ExitCode* exitcode_; - uint32_t deviceindex_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncdRecord final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdRecord) */ { - public: - inline SyncdRecord() : SyncdRecord(nullptr) {} - ~SyncdRecord() override; - explicit PROTOBUF_CONSTEXPR SyncdRecord(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncdRecord(const SyncdRecord& from); - SyncdRecord(SyncdRecord&& from) noexcept - : SyncdRecord() { - *this = ::std::move(from); - } - - inline SyncdRecord& operator=(const SyncdRecord& from) { - CopyFrom(from); - return *this; - } - inline SyncdRecord& operator=(SyncdRecord&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncdRecord& default_instance() { - return *internal_default_instance(); - } - static inline const SyncdRecord* internal_default_instance() { - return reinterpret_cast( - &_SyncdRecord_default_instance_); - } - static constexpr int kIndexInFileMessages = - 209; - - friend void swap(SyncdRecord& a, SyncdRecord& b) { - a.Swap(&b); - } - inline void Swap(SyncdRecord* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncdRecord* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncdRecord* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncdRecord& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncdRecord& from) { - SyncdRecord::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncdRecord* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncdRecord"; - } - protected: - explicit SyncdRecord(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kIndexFieldNumber = 1, - kValueFieldNumber = 2, - kKeyIdFieldNumber = 3, - }; - // optional .proto.SyncdIndex index = 1; - bool has_index() const; - private: - bool _internal_has_index() const; - public: - void clear_index(); - const ::proto::SyncdIndex& index() const; - PROTOBUF_NODISCARD ::proto::SyncdIndex* release_index(); - ::proto::SyncdIndex* mutable_index(); - void set_allocated_index(::proto::SyncdIndex* index); - private: - const ::proto::SyncdIndex& _internal_index() const; - ::proto::SyncdIndex* _internal_mutable_index(); - public: - void unsafe_arena_set_allocated_index( - ::proto::SyncdIndex* index); - ::proto::SyncdIndex* unsafe_arena_release_index(); - - // optional .proto.SyncdValue value = 2; - bool has_value() const; - private: - bool _internal_has_value() const; - public: - void clear_value(); - const ::proto::SyncdValue& value() const; - PROTOBUF_NODISCARD ::proto::SyncdValue* release_value(); - ::proto::SyncdValue* mutable_value(); - void set_allocated_value(::proto::SyncdValue* value); - private: - const ::proto::SyncdValue& _internal_value() const; - ::proto::SyncdValue* _internal_mutable_value(); - public: - void unsafe_arena_set_allocated_value( - ::proto::SyncdValue* value); - ::proto::SyncdValue* unsafe_arena_release_value(); - - // optional .proto.KeyId keyId = 3; - bool has_keyid() const; - private: - bool _internal_has_keyid() const; - public: - void clear_keyid(); - const ::proto::KeyId& keyid() const; - PROTOBUF_NODISCARD ::proto::KeyId* release_keyid(); - ::proto::KeyId* mutable_keyid(); - void set_allocated_keyid(::proto::KeyId* keyid); - private: - const ::proto::KeyId& _internal_keyid() const; - ::proto::KeyId* _internal_mutable_keyid(); - public: - void unsafe_arena_set_allocated_keyid( - ::proto::KeyId* keyid); - ::proto::KeyId* unsafe_arena_release_keyid(); - - // @@protoc_insertion_point(class_scope:proto.SyncdRecord) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::proto::SyncdIndex* index_; - ::proto::SyncdValue* value_; - ::proto::KeyId* keyid_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncdSnapshot final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdSnapshot) */ { - public: - inline SyncdSnapshot() : SyncdSnapshot(nullptr) {} - ~SyncdSnapshot() override; - explicit PROTOBUF_CONSTEXPR SyncdSnapshot(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncdSnapshot(const SyncdSnapshot& from); - SyncdSnapshot(SyncdSnapshot&& from) noexcept - : SyncdSnapshot() { - *this = ::std::move(from); - } - - inline SyncdSnapshot& operator=(const SyncdSnapshot& from) { - CopyFrom(from); - return *this; - } - inline SyncdSnapshot& operator=(SyncdSnapshot&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncdSnapshot& default_instance() { - return *internal_default_instance(); - } - static inline const SyncdSnapshot* internal_default_instance() { - return reinterpret_cast( - &_SyncdSnapshot_default_instance_); - } - static constexpr int kIndexInFileMessages = - 210; - - friend void swap(SyncdSnapshot& a, SyncdSnapshot& b) { - a.Swap(&b); - } - inline void Swap(SyncdSnapshot* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncdSnapshot* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncdSnapshot* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncdSnapshot& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncdSnapshot& from) { - SyncdSnapshot::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncdSnapshot* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncdSnapshot"; - } - protected: - explicit SyncdSnapshot(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kRecordsFieldNumber = 2, - kMacFieldNumber = 3, - kVersionFieldNumber = 1, - kKeyIdFieldNumber = 4, - }; - // repeated .proto.SyncdRecord records = 2; - int records_size() const; - private: - int _internal_records_size() const; - public: - void clear_records(); - ::proto::SyncdRecord* mutable_records(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdRecord >* - mutable_records(); - private: - const ::proto::SyncdRecord& _internal_records(int index) const; - ::proto::SyncdRecord* _internal_add_records(); - public: - const ::proto::SyncdRecord& records(int index) const; - ::proto::SyncdRecord* add_records(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdRecord >& - records() const; - - // optional bytes mac = 3; - bool has_mac() const; - private: - bool _internal_has_mac() const; - public: - void clear_mac(); - const std::string& mac() const; - template - void set_mac(ArgT0&& arg0, ArgT... args); - std::string* mutable_mac(); - PROTOBUF_NODISCARD std::string* release_mac(); - void set_allocated_mac(std::string* mac); - private: - const std::string& _internal_mac() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_mac(const std::string& value); - std::string* _internal_mutable_mac(); - public: - - // optional .proto.SyncdVersion version = 1; - bool has_version() const; - private: - bool _internal_has_version() const; - public: - void clear_version(); - const ::proto::SyncdVersion& version() const; - PROTOBUF_NODISCARD ::proto::SyncdVersion* release_version(); - ::proto::SyncdVersion* mutable_version(); - void set_allocated_version(::proto::SyncdVersion* version); - private: - const ::proto::SyncdVersion& _internal_version() const; - ::proto::SyncdVersion* _internal_mutable_version(); - public: - void unsafe_arena_set_allocated_version( - ::proto::SyncdVersion* version); - ::proto::SyncdVersion* unsafe_arena_release_version(); - - // optional .proto.KeyId keyId = 4; - bool has_keyid() const; - private: - bool _internal_has_keyid() const; - public: - void clear_keyid(); - const ::proto::KeyId& keyid() const; - PROTOBUF_NODISCARD ::proto::KeyId* release_keyid(); - ::proto::KeyId* mutable_keyid(); - void set_allocated_keyid(::proto::KeyId* keyid); - private: - const ::proto::KeyId& _internal_keyid() const; - ::proto::KeyId* _internal_mutable_keyid(); - public: - void unsafe_arena_set_allocated_keyid( - ::proto::KeyId* keyid); - ::proto::KeyId* unsafe_arena_release_keyid(); - - // @@protoc_insertion_point(class_scope:proto.SyncdSnapshot) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdRecord > records_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mac_; - ::proto::SyncdVersion* version_; - ::proto::KeyId* keyid_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncdValue final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdValue) */ { - public: - inline SyncdValue() : SyncdValue(nullptr) {} - ~SyncdValue() override; - explicit PROTOBUF_CONSTEXPR SyncdValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncdValue(const SyncdValue& from); - SyncdValue(SyncdValue&& from) noexcept - : SyncdValue() { - *this = ::std::move(from); - } - - inline SyncdValue& operator=(const SyncdValue& from) { - CopyFrom(from); - return *this; - } - inline SyncdValue& operator=(SyncdValue&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncdValue& default_instance() { - return *internal_default_instance(); - } - static inline const SyncdValue* internal_default_instance() { - return reinterpret_cast( - &_SyncdValue_default_instance_); - } - static constexpr int kIndexInFileMessages = - 211; - - friend void swap(SyncdValue& a, SyncdValue& b) { - a.Swap(&b); - } - inline void Swap(SyncdValue* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncdValue* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncdValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncdValue& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncdValue& from) { - SyncdValue::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncdValue* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncdValue"; - } - protected: - explicit SyncdValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kBlobFieldNumber = 1, - }; - // optional bytes blob = 1; - bool has_blob() const; - private: - bool _internal_has_blob() const; - public: - void clear_blob(); - const std::string& blob() const; - template - void set_blob(ArgT0&& arg0, ArgT... args); - std::string* mutable_blob(); - PROTOBUF_NODISCARD std::string* release_blob(); - void set_allocated_blob(std::string* blob); - private: - const std::string& _internal_blob() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_blob(const std::string& value); - std::string* _internal_mutable_blob(); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncdValue) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr blob_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class SyncdVersion final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdVersion) */ { - public: - inline SyncdVersion() : SyncdVersion(nullptr) {} - ~SyncdVersion() override; - explicit PROTOBUF_CONSTEXPR SyncdVersion(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SyncdVersion(const SyncdVersion& from); - SyncdVersion(SyncdVersion&& from) noexcept - : SyncdVersion() { - *this = ::std::move(from); - } - - inline SyncdVersion& operator=(const SyncdVersion& from) { - CopyFrom(from); - return *this; - } - inline SyncdVersion& operator=(SyncdVersion&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const SyncdVersion& default_instance() { - return *internal_default_instance(); - } - static inline const SyncdVersion* internal_default_instance() { - return reinterpret_cast( - &_SyncdVersion_default_instance_); - } - static constexpr int kIndexInFileMessages = - 212; - - friend void swap(SyncdVersion& a, SyncdVersion& b) { - a.Swap(&b); - } - inline void Swap(SyncdVersion* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SyncdVersion* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SyncdVersion* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SyncdVersion& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const SyncdVersion& from) { - SyncdVersion::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SyncdVersion* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.SyncdVersion"; - } - protected: - explicit SyncdVersion(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kVersionFieldNumber = 1, - }; - // optional uint64 version = 1; - bool has_version() const; - private: - bool _internal_has_version() const; - public: - void clear_version(); - uint64_t version() const; - void set_version(uint64_t value); - private: - uint64_t _internal_version() const; - void _internal_set_version(uint64_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.SyncdVersion) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint64_t version_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class TemplateButton_CallButton final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.TemplateButton.CallButton) */ { - public: - inline TemplateButton_CallButton() : TemplateButton_CallButton(nullptr) {} - ~TemplateButton_CallButton() override; - explicit PROTOBUF_CONSTEXPR TemplateButton_CallButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - TemplateButton_CallButton(const TemplateButton_CallButton& from); - TemplateButton_CallButton(TemplateButton_CallButton&& from) noexcept - : TemplateButton_CallButton() { - *this = ::std::move(from); - } - - inline TemplateButton_CallButton& operator=(const TemplateButton_CallButton& from) { - CopyFrom(from); - return *this; - } - inline TemplateButton_CallButton& operator=(TemplateButton_CallButton&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const TemplateButton_CallButton& default_instance() { - return *internal_default_instance(); - } - static inline const TemplateButton_CallButton* internal_default_instance() { - return reinterpret_cast( - &_TemplateButton_CallButton_default_instance_); - } - static constexpr int kIndexInFileMessages = - 213; - - friend void swap(TemplateButton_CallButton& a, TemplateButton_CallButton& b) { - a.Swap(&b); - } - inline void Swap(TemplateButton_CallButton* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(TemplateButton_CallButton* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - TemplateButton_CallButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const TemplateButton_CallButton& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const TemplateButton_CallButton& from) { - TemplateButton_CallButton::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(TemplateButton_CallButton* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.TemplateButton.CallButton"; - } - protected: - explicit TemplateButton_CallButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kDisplayTextFieldNumber = 1, - kPhoneNumberFieldNumber = 2, - }; - // optional .proto.Message.HighlyStructuredMessage displayText = 1; - bool has_displaytext() const; - private: - bool _internal_has_displaytext() const; - public: - void clear_displaytext(); - const ::proto::Message_HighlyStructuredMessage& displaytext() const; - PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_displaytext(); - ::proto::Message_HighlyStructuredMessage* mutable_displaytext(); - void set_allocated_displaytext(::proto::Message_HighlyStructuredMessage* displaytext); - private: - const ::proto::Message_HighlyStructuredMessage& _internal_displaytext() const; - ::proto::Message_HighlyStructuredMessage* _internal_mutable_displaytext(); - public: - void unsafe_arena_set_allocated_displaytext( - ::proto::Message_HighlyStructuredMessage* displaytext); - ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_displaytext(); - - // optional .proto.Message.HighlyStructuredMessage phoneNumber = 2; - bool has_phonenumber() const; - private: - bool _internal_has_phonenumber() const; - public: - void clear_phonenumber(); - const ::proto::Message_HighlyStructuredMessage& phonenumber() const; - PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_phonenumber(); - ::proto::Message_HighlyStructuredMessage* mutable_phonenumber(); - void set_allocated_phonenumber(::proto::Message_HighlyStructuredMessage* phonenumber); - private: - const ::proto::Message_HighlyStructuredMessage& _internal_phonenumber() const; - ::proto::Message_HighlyStructuredMessage* _internal_mutable_phonenumber(); - public: - void unsafe_arena_set_allocated_phonenumber( - ::proto::Message_HighlyStructuredMessage* phonenumber); - ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_phonenumber(); - - // @@protoc_insertion_point(class_scope:proto.TemplateButton.CallButton) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::proto::Message_HighlyStructuredMessage* displaytext_; - ::proto::Message_HighlyStructuredMessage* phonenumber_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class TemplateButton_QuickReplyButton final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.TemplateButton.QuickReplyButton) */ { - public: - inline TemplateButton_QuickReplyButton() : TemplateButton_QuickReplyButton(nullptr) {} - ~TemplateButton_QuickReplyButton() override; - explicit PROTOBUF_CONSTEXPR TemplateButton_QuickReplyButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - TemplateButton_QuickReplyButton(const TemplateButton_QuickReplyButton& from); - TemplateButton_QuickReplyButton(TemplateButton_QuickReplyButton&& from) noexcept - : TemplateButton_QuickReplyButton() { - *this = ::std::move(from); - } - - inline TemplateButton_QuickReplyButton& operator=(const TemplateButton_QuickReplyButton& from) { - CopyFrom(from); - return *this; - } - inline TemplateButton_QuickReplyButton& operator=(TemplateButton_QuickReplyButton&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const TemplateButton_QuickReplyButton& default_instance() { - return *internal_default_instance(); - } - static inline const TemplateButton_QuickReplyButton* internal_default_instance() { - return reinterpret_cast( - &_TemplateButton_QuickReplyButton_default_instance_); - } - static constexpr int kIndexInFileMessages = - 214; - - friend void swap(TemplateButton_QuickReplyButton& a, TemplateButton_QuickReplyButton& b) { - a.Swap(&b); - } - inline void Swap(TemplateButton_QuickReplyButton* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(TemplateButton_QuickReplyButton* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - TemplateButton_QuickReplyButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const TemplateButton_QuickReplyButton& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const TemplateButton_QuickReplyButton& from) { - TemplateButton_QuickReplyButton::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(TemplateButton_QuickReplyButton* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.TemplateButton.QuickReplyButton"; - } - protected: - explicit TemplateButton_QuickReplyButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kIdFieldNumber = 2, - kDisplayTextFieldNumber = 1, - }; - // optional string id = 2; - bool has_id() const; - private: - bool _internal_has_id() const; - public: - void clear_id(); - const std::string& id() const; - template - void set_id(ArgT0&& arg0, ArgT... args); - std::string* mutable_id(); - PROTOBUF_NODISCARD std::string* release_id(); - void set_allocated_id(std::string* id); - private: - const std::string& _internal_id() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value); - std::string* _internal_mutable_id(); - public: - - // optional .proto.Message.HighlyStructuredMessage displayText = 1; - bool has_displaytext() const; - private: - bool _internal_has_displaytext() const; - public: - void clear_displaytext(); - const ::proto::Message_HighlyStructuredMessage& displaytext() const; - PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_displaytext(); - ::proto::Message_HighlyStructuredMessage* mutable_displaytext(); - void set_allocated_displaytext(::proto::Message_HighlyStructuredMessage* displaytext); - private: - const ::proto::Message_HighlyStructuredMessage& _internal_displaytext() const; - ::proto::Message_HighlyStructuredMessage* _internal_mutable_displaytext(); - public: - void unsafe_arena_set_allocated_displaytext( - ::proto::Message_HighlyStructuredMessage* displaytext); - ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_displaytext(); - - // @@protoc_insertion_point(class_scope:proto.TemplateButton.QuickReplyButton) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_; - ::proto::Message_HighlyStructuredMessage* displaytext_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class TemplateButton_URLButton final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.TemplateButton.URLButton) */ { - public: - inline TemplateButton_URLButton() : TemplateButton_URLButton(nullptr) {} - ~TemplateButton_URLButton() override; - explicit PROTOBUF_CONSTEXPR TemplateButton_URLButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - TemplateButton_URLButton(const TemplateButton_URLButton& from); - TemplateButton_URLButton(TemplateButton_URLButton&& from) noexcept - : TemplateButton_URLButton() { - *this = ::std::move(from); - } - - inline TemplateButton_URLButton& operator=(const TemplateButton_URLButton& from) { - CopyFrom(from); - return *this; - } - inline TemplateButton_URLButton& operator=(TemplateButton_URLButton&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const TemplateButton_URLButton& default_instance() { - return *internal_default_instance(); - } - static inline const TemplateButton_URLButton* internal_default_instance() { - return reinterpret_cast( - &_TemplateButton_URLButton_default_instance_); - } - static constexpr int kIndexInFileMessages = - 215; - - friend void swap(TemplateButton_URLButton& a, TemplateButton_URLButton& b) { - a.Swap(&b); - } - inline void Swap(TemplateButton_URLButton* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(TemplateButton_URLButton* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - TemplateButton_URLButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const TemplateButton_URLButton& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const TemplateButton_URLButton& from) { - TemplateButton_URLButton::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(TemplateButton_URLButton* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.TemplateButton.URLButton"; - } - protected: - explicit TemplateButton_URLButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kDisplayTextFieldNumber = 1, - kUrlFieldNumber = 2, - }; - // optional .proto.Message.HighlyStructuredMessage displayText = 1; - bool has_displaytext() const; - private: - bool _internal_has_displaytext() const; - public: - void clear_displaytext(); - const ::proto::Message_HighlyStructuredMessage& displaytext() const; - PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_displaytext(); - ::proto::Message_HighlyStructuredMessage* mutable_displaytext(); - void set_allocated_displaytext(::proto::Message_HighlyStructuredMessage* displaytext); - private: - const ::proto::Message_HighlyStructuredMessage& _internal_displaytext() const; - ::proto::Message_HighlyStructuredMessage* _internal_mutable_displaytext(); - public: - void unsafe_arena_set_allocated_displaytext( - ::proto::Message_HighlyStructuredMessage* displaytext); - ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_displaytext(); - - // optional .proto.Message.HighlyStructuredMessage url = 2; - bool has_url() const; - private: - bool _internal_has_url() const; - public: - void clear_url(); - const ::proto::Message_HighlyStructuredMessage& url() const; - PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_url(); - ::proto::Message_HighlyStructuredMessage* mutable_url(); - void set_allocated_url(::proto::Message_HighlyStructuredMessage* url); - private: - const ::proto::Message_HighlyStructuredMessage& _internal_url() const; - ::proto::Message_HighlyStructuredMessage* _internal_mutable_url(); - public: - void unsafe_arena_set_allocated_url( - ::proto::Message_HighlyStructuredMessage* url); - ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_url(); - - // @@protoc_insertion_point(class_scope:proto.TemplateButton.URLButton) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::proto::Message_HighlyStructuredMessage* displaytext_; - ::proto::Message_HighlyStructuredMessage* url_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class TemplateButton final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.TemplateButton) */ { - public: - inline TemplateButton() : TemplateButton(nullptr) {} - ~TemplateButton() override; - explicit PROTOBUF_CONSTEXPR TemplateButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - TemplateButton(const TemplateButton& from); - TemplateButton(TemplateButton&& from) noexcept - : TemplateButton() { - *this = ::std::move(from); - } - - inline TemplateButton& operator=(const TemplateButton& from) { - CopyFrom(from); - return *this; - } - inline TemplateButton& operator=(TemplateButton&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const TemplateButton& default_instance() { - return *internal_default_instance(); - } - enum ButtonCase { - kQuickReplyButton = 1, - kUrlButton = 2, - kCallButton = 3, - BUTTON_NOT_SET = 0, - }; - - static inline const TemplateButton* internal_default_instance() { - return reinterpret_cast( - &_TemplateButton_default_instance_); - } - static constexpr int kIndexInFileMessages = - 216; - - friend void swap(TemplateButton& a, TemplateButton& b) { - a.Swap(&b); - } - inline void Swap(TemplateButton* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(TemplateButton* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - TemplateButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const TemplateButton& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const TemplateButton& from) { - TemplateButton::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(TemplateButton* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.TemplateButton"; - } - protected: - explicit TemplateButton(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef TemplateButton_CallButton CallButton; - typedef TemplateButton_QuickReplyButton QuickReplyButton; - typedef TemplateButton_URLButton URLButton; - - // accessors ------------------------------------------------------- - - enum : int { - kIndexFieldNumber = 4, - kQuickReplyButtonFieldNumber = 1, - kUrlButtonFieldNumber = 2, - kCallButtonFieldNumber = 3, - }; - // optional uint32 index = 4; - bool has_index() const; - private: - bool _internal_has_index() const; - public: - void clear_index(); - uint32_t index() const; - void set_index(uint32_t value); - private: - uint32_t _internal_index() const; - void _internal_set_index(uint32_t value); - public: - - // .proto.TemplateButton.QuickReplyButton quickReplyButton = 1; - bool has_quickreplybutton() const; - private: - bool _internal_has_quickreplybutton() const; - public: - void clear_quickreplybutton(); - const ::proto::TemplateButton_QuickReplyButton& quickreplybutton() const; - PROTOBUF_NODISCARD ::proto::TemplateButton_QuickReplyButton* release_quickreplybutton(); - ::proto::TemplateButton_QuickReplyButton* mutable_quickreplybutton(); - void set_allocated_quickreplybutton(::proto::TemplateButton_QuickReplyButton* quickreplybutton); - private: - const ::proto::TemplateButton_QuickReplyButton& _internal_quickreplybutton() const; - ::proto::TemplateButton_QuickReplyButton* _internal_mutable_quickreplybutton(); - public: - void unsafe_arena_set_allocated_quickreplybutton( - ::proto::TemplateButton_QuickReplyButton* quickreplybutton); - ::proto::TemplateButton_QuickReplyButton* unsafe_arena_release_quickreplybutton(); - - // .proto.TemplateButton.URLButton urlButton = 2; - bool has_urlbutton() const; - private: - bool _internal_has_urlbutton() const; - public: - void clear_urlbutton(); - const ::proto::TemplateButton_URLButton& urlbutton() const; - PROTOBUF_NODISCARD ::proto::TemplateButton_URLButton* release_urlbutton(); - ::proto::TemplateButton_URLButton* mutable_urlbutton(); - void set_allocated_urlbutton(::proto::TemplateButton_URLButton* urlbutton); - private: - const ::proto::TemplateButton_URLButton& _internal_urlbutton() const; - ::proto::TemplateButton_URLButton* _internal_mutable_urlbutton(); - public: - void unsafe_arena_set_allocated_urlbutton( - ::proto::TemplateButton_URLButton* urlbutton); - ::proto::TemplateButton_URLButton* unsafe_arena_release_urlbutton(); - - // .proto.TemplateButton.CallButton callButton = 3; - bool has_callbutton() const; - private: - bool _internal_has_callbutton() const; - public: - void clear_callbutton(); - const ::proto::TemplateButton_CallButton& callbutton() const; - PROTOBUF_NODISCARD ::proto::TemplateButton_CallButton* release_callbutton(); - ::proto::TemplateButton_CallButton* mutable_callbutton(); - void set_allocated_callbutton(::proto::TemplateButton_CallButton* callbutton); - private: - const ::proto::TemplateButton_CallButton& _internal_callbutton() const; - ::proto::TemplateButton_CallButton* _internal_mutable_callbutton(); - public: - void unsafe_arena_set_allocated_callbutton( - ::proto::TemplateButton_CallButton* callbutton); - ::proto::TemplateButton_CallButton* unsafe_arena_release_callbutton(); - - void clear_button(); - ButtonCase button_case() const; - // @@protoc_insertion_point(class_scope:proto.TemplateButton) - private: - class _Internal; - void set_has_quickreplybutton(); - void set_has_urlbutton(); - void set_has_callbutton(); - - inline bool has_button() const; - inline void clear_has_button(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t index_; - union ButtonUnion { - constexpr ButtonUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::proto::TemplateButton_QuickReplyButton* quickreplybutton_; - ::proto::TemplateButton_URLButton* urlbutton_; - ::proto::TemplateButton_CallButton* callbutton_; - } button_; - uint32_t _oneof_case_[1]; - - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class UserReceipt final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.UserReceipt) */ { - public: - inline UserReceipt() : UserReceipt(nullptr) {} - ~UserReceipt() override; - explicit PROTOBUF_CONSTEXPR UserReceipt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - UserReceipt(const UserReceipt& from); - UserReceipt(UserReceipt&& from) noexcept - : UserReceipt() { - *this = ::std::move(from); - } - - inline UserReceipt& operator=(const UserReceipt& from) { - CopyFrom(from); - return *this; - } - inline UserReceipt& operator=(UserReceipt&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const UserReceipt& default_instance() { - return *internal_default_instance(); - } - static inline const UserReceipt* internal_default_instance() { - return reinterpret_cast( - &_UserReceipt_default_instance_); - } - static constexpr int kIndexInFileMessages = - 217; - - friend void swap(UserReceipt& a, UserReceipt& b) { - a.Swap(&b); - } - inline void Swap(UserReceipt* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(UserReceipt* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - UserReceipt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const UserReceipt& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const UserReceipt& from) { - UserReceipt::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(UserReceipt* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.UserReceipt"; - } - protected: - explicit UserReceipt(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kPendingDeviceJidFieldNumber = 5, - kDeliveredDeviceJidFieldNumber = 6, - kUserJidFieldNumber = 1, - kReceiptTimestampFieldNumber = 2, - kReadTimestampFieldNumber = 3, - kPlayedTimestampFieldNumber = 4, - }; - // repeated string pendingDeviceJid = 5; - int pendingdevicejid_size() const; - private: - int _internal_pendingdevicejid_size() const; - public: - void clear_pendingdevicejid(); - const std::string& pendingdevicejid(int index) const; - std::string* mutable_pendingdevicejid(int index); - void set_pendingdevicejid(int index, const std::string& value); - void set_pendingdevicejid(int index, std::string&& value); - void set_pendingdevicejid(int index, const char* value); - void set_pendingdevicejid(int index, const char* value, size_t size); - std::string* add_pendingdevicejid(); - void add_pendingdevicejid(const std::string& value); - void add_pendingdevicejid(std::string&& value); - void add_pendingdevicejid(const char* value); - void add_pendingdevicejid(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& pendingdevicejid() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_pendingdevicejid(); - private: - const std::string& _internal_pendingdevicejid(int index) const; - std::string* _internal_add_pendingdevicejid(); - public: - - // repeated string deliveredDeviceJid = 6; - int delivereddevicejid_size() const; - private: - int _internal_delivereddevicejid_size() const; - public: - void clear_delivereddevicejid(); - const std::string& delivereddevicejid(int index) const; - std::string* mutable_delivereddevicejid(int index); - void set_delivereddevicejid(int index, const std::string& value); - void set_delivereddevicejid(int index, std::string&& value); - void set_delivereddevicejid(int index, const char* value); - void set_delivereddevicejid(int index, const char* value, size_t size); - std::string* add_delivereddevicejid(); - void add_delivereddevicejid(const std::string& value); - void add_delivereddevicejid(std::string&& value); - void add_delivereddevicejid(const char* value); - void add_delivereddevicejid(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& delivereddevicejid() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_delivereddevicejid(); - private: - const std::string& _internal_delivereddevicejid(int index) const; - std::string* _internal_add_delivereddevicejid(); - public: - - // required string userJid = 1; - bool has_userjid() const; - private: - bool _internal_has_userjid() const; - public: - void clear_userjid(); - const std::string& userjid() const; - template - void set_userjid(ArgT0&& arg0, ArgT... args); - std::string* mutable_userjid(); - PROTOBUF_NODISCARD std::string* release_userjid(); - void set_allocated_userjid(std::string* userjid); - private: - const std::string& _internal_userjid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_userjid(const std::string& value); - std::string* _internal_mutable_userjid(); - public: - - // optional int64 receiptTimestamp = 2; - bool has_receipttimestamp() const; - private: - bool _internal_has_receipttimestamp() const; - public: - void clear_receipttimestamp(); - int64_t receipttimestamp() const; - void set_receipttimestamp(int64_t value); - private: - int64_t _internal_receipttimestamp() const; - void _internal_set_receipttimestamp(int64_t value); - public: - - // optional int64 readTimestamp = 3; - bool has_readtimestamp() const; - private: - bool _internal_has_readtimestamp() const; - public: - void clear_readtimestamp(); - int64_t readtimestamp() const; - void set_readtimestamp(int64_t value); - private: - int64_t _internal_readtimestamp() const; - void _internal_set_readtimestamp(int64_t value); - public: - - // optional int64 playedTimestamp = 4; - bool has_playedtimestamp() const; - private: - bool _internal_has_playedtimestamp() const; - public: - void clear_playedtimestamp(); - int64_t playedtimestamp() const; - void set_playedtimestamp(int64_t value); - private: - int64_t _internal_playedtimestamp() const; - void _internal_set_playedtimestamp(int64_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.UserReceipt) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField pendingdevicejid_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField delivereddevicejid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userjid_; - int64_t receipttimestamp_; - int64_t readtimestamp_; - int64_t playedtimestamp_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class VerifiedNameCertificate_Details final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.VerifiedNameCertificate.Details) */ { - public: - inline VerifiedNameCertificate_Details() : VerifiedNameCertificate_Details(nullptr) {} - ~VerifiedNameCertificate_Details() override; - explicit PROTOBUF_CONSTEXPR VerifiedNameCertificate_Details(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - VerifiedNameCertificate_Details(const VerifiedNameCertificate_Details& from); - VerifiedNameCertificate_Details(VerifiedNameCertificate_Details&& from) noexcept - : VerifiedNameCertificate_Details() { - *this = ::std::move(from); - } - - inline VerifiedNameCertificate_Details& operator=(const VerifiedNameCertificate_Details& from) { - CopyFrom(from); - return *this; - } - inline VerifiedNameCertificate_Details& operator=(VerifiedNameCertificate_Details&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const VerifiedNameCertificate_Details& default_instance() { - return *internal_default_instance(); - } - static inline const VerifiedNameCertificate_Details* internal_default_instance() { - return reinterpret_cast( - &_VerifiedNameCertificate_Details_default_instance_); - } - static constexpr int kIndexInFileMessages = - 218; - - friend void swap(VerifiedNameCertificate_Details& a, VerifiedNameCertificate_Details& b) { - a.Swap(&b); - } - inline void Swap(VerifiedNameCertificate_Details* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(VerifiedNameCertificate_Details* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - VerifiedNameCertificate_Details* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const VerifiedNameCertificate_Details& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const VerifiedNameCertificate_Details& from) { - VerifiedNameCertificate_Details::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(VerifiedNameCertificate_Details* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.VerifiedNameCertificate.Details"; - } - protected: - explicit VerifiedNameCertificate_Details(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kLocalizedNamesFieldNumber = 8, - kIssuerFieldNumber = 2, - kVerifiedNameFieldNumber = 4, - kSerialFieldNumber = 1, - kIssueTimeFieldNumber = 10, - }; - // repeated .proto.LocalizedName localizedNames = 8; - int localizednames_size() const; - private: - int _internal_localizednames_size() const; - public: - void clear_localizednames(); - ::proto::LocalizedName* mutable_localizednames(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::LocalizedName >* - mutable_localizednames(); - private: - const ::proto::LocalizedName& _internal_localizednames(int index) const; - ::proto::LocalizedName* _internal_add_localizednames(); - public: - const ::proto::LocalizedName& localizednames(int index) const; - ::proto::LocalizedName* add_localizednames(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::LocalizedName >& - localizednames() const; - - // optional string issuer = 2; - bool has_issuer() const; - private: - bool _internal_has_issuer() const; - public: - void clear_issuer(); - const std::string& issuer() const; - template - void set_issuer(ArgT0&& arg0, ArgT... args); - std::string* mutable_issuer(); - PROTOBUF_NODISCARD std::string* release_issuer(); - void set_allocated_issuer(std::string* issuer); - private: - const std::string& _internal_issuer() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_issuer(const std::string& value); - std::string* _internal_mutable_issuer(); - public: - - // optional string verifiedName = 4; - bool has_verifiedname() const; - private: - bool _internal_has_verifiedname() const; - public: - void clear_verifiedname(); - const std::string& verifiedname() const; - template - void set_verifiedname(ArgT0&& arg0, ArgT... args); - std::string* mutable_verifiedname(); - PROTOBUF_NODISCARD std::string* release_verifiedname(); - void set_allocated_verifiedname(std::string* verifiedname); - private: - const std::string& _internal_verifiedname() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_verifiedname(const std::string& value); - std::string* _internal_mutable_verifiedname(); - public: - - // optional uint64 serial = 1; - bool has_serial() const; - private: - bool _internal_has_serial() const; - public: - void clear_serial(); - uint64_t serial() const; - void set_serial(uint64_t value); - private: - uint64_t _internal_serial() const; - void _internal_set_serial(uint64_t value); - public: - - // optional uint64 issueTime = 10; - bool has_issuetime() const; - private: - bool _internal_has_issuetime() const; - public: - void clear_issuetime(); - uint64_t issuetime() const; - void set_issuetime(uint64_t value); - private: - uint64_t _internal_issuetime() const; - void _internal_set_issuetime(uint64_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.VerifiedNameCertificate.Details) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::LocalizedName > localizednames_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr issuer_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr verifiedname_; - uint64_t serial_; - uint64_t issuetime_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class VerifiedNameCertificate final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.VerifiedNameCertificate) */ { - public: - inline VerifiedNameCertificate() : VerifiedNameCertificate(nullptr) {} - ~VerifiedNameCertificate() override; - explicit PROTOBUF_CONSTEXPR VerifiedNameCertificate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - VerifiedNameCertificate(const VerifiedNameCertificate& from); - VerifiedNameCertificate(VerifiedNameCertificate&& from) noexcept - : VerifiedNameCertificate() { - *this = ::std::move(from); - } - - inline VerifiedNameCertificate& operator=(const VerifiedNameCertificate& from) { - CopyFrom(from); - return *this; - } - inline VerifiedNameCertificate& operator=(VerifiedNameCertificate&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const VerifiedNameCertificate& default_instance() { - return *internal_default_instance(); - } - static inline const VerifiedNameCertificate* internal_default_instance() { - return reinterpret_cast( - &_VerifiedNameCertificate_default_instance_); - } - static constexpr int kIndexInFileMessages = - 219; - - friend void swap(VerifiedNameCertificate& a, VerifiedNameCertificate& b) { - a.Swap(&b); - } - inline void Swap(VerifiedNameCertificate* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(VerifiedNameCertificate* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - VerifiedNameCertificate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const VerifiedNameCertificate& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const VerifiedNameCertificate& from) { - VerifiedNameCertificate::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(VerifiedNameCertificate* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.VerifiedNameCertificate"; - } - protected: - explicit VerifiedNameCertificate(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef VerifiedNameCertificate_Details Details; - - // accessors ------------------------------------------------------- - - enum : int { - kDetailsFieldNumber = 1, - kSignatureFieldNumber = 2, - kServerSignatureFieldNumber = 3, - }; - // optional bytes details = 1; - bool has_details() const; - private: - bool _internal_has_details() const; - public: - void clear_details(); - const std::string& details() const; - template - void set_details(ArgT0&& arg0, ArgT... args); - std::string* mutable_details(); - PROTOBUF_NODISCARD std::string* release_details(); - void set_allocated_details(std::string* details); - private: - const std::string& _internal_details() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_details(const std::string& value); - std::string* _internal_mutable_details(); - public: - - // optional bytes signature = 2; - bool has_signature() const; - private: - bool _internal_has_signature() const; - public: - void clear_signature(); - const std::string& signature() const; - template - void set_signature(ArgT0&& arg0, ArgT... args); - std::string* mutable_signature(); - PROTOBUF_NODISCARD std::string* release_signature(); - void set_allocated_signature(std::string* signature); - private: - const std::string& _internal_signature() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value); - std::string* _internal_mutable_signature(); - public: - - // optional bytes serverSignature = 3; - bool has_serversignature() const; - private: - bool _internal_has_serversignature() const; - public: - void clear_serversignature(); - const std::string& serversignature() const; - template - void set_serversignature(ArgT0&& arg0, ArgT... args); - std::string* mutable_serversignature(); - PROTOBUF_NODISCARD std::string* release_serversignature(); - void set_allocated_serversignature(std::string* serversignature); - private: - const std::string& _internal_serversignature() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_serversignature(const std::string& value); - std::string* _internal_mutable_serversignature(); - public: - - // @@protoc_insertion_point(class_scope:proto.VerifiedNameCertificate) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr details_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr serversignature_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class WallpaperSettings final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.WallpaperSettings) */ { - public: - inline WallpaperSettings() : WallpaperSettings(nullptr) {} - ~WallpaperSettings() override; - explicit PROTOBUF_CONSTEXPR WallpaperSettings(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - WallpaperSettings(const WallpaperSettings& from); - WallpaperSettings(WallpaperSettings&& from) noexcept - : WallpaperSettings() { - *this = ::std::move(from); - } - - inline WallpaperSettings& operator=(const WallpaperSettings& from) { - CopyFrom(from); - return *this; - } - inline WallpaperSettings& operator=(WallpaperSettings&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const WallpaperSettings& default_instance() { - return *internal_default_instance(); - } - static inline const WallpaperSettings* internal_default_instance() { - return reinterpret_cast( - &_WallpaperSettings_default_instance_); - } - static constexpr int kIndexInFileMessages = - 220; - - friend void swap(WallpaperSettings& a, WallpaperSettings& b) { - a.Swap(&b); - } - inline void Swap(WallpaperSettings* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(WallpaperSettings* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - WallpaperSettings* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const WallpaperSettings& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const WallpaperSettings& from) { - WallpaperSettings::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(WallpaperSettings* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.WallpaperSettings"; - } - protected: - explicit WallpaperSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kFilenameFieldNumber = 1, - kOpacityFieldNumber = 2, - }; - // optional string filename = 1; - bool has_filename() const; - private: - bool _internal_has_filename() const; - public: - void clear_filename(); - const std::string& filename() const; - template - void set_filename(ArgT0&& arg0, ArgT... args); - std::string* mutable_filename(); - PROTOBUF_NODISCARD std::string* release_filename(); - void set_allocated_filename(std::string* filename); - private: - const std::string& _internal_filename() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_filename(const std::string& value); - std::string* _internal_mutable_filename(); - public: - - // optional uint32 opacity = 2; - bool has_opacity() const; - private: - bool _internal_has_opacity() const; - public: - void clear_opacity(); - uint32_t opacity() const; - void set_opacity(uint32_t value); - private: - uint32_t _internal_opacity() const; - void _internal_set_opacity(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.WallpaperSettings) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filename_; - uint32_t opacity_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class WebFeatures final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.WebFeatures) */ { - public: - inline WebFeatures() : WebFeatures(nullptr) {} - ~WebFeatures() override; - explicit PROTOBUF_CONSTEXPR WebFeatures(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - WebFeatures(const WebFeatures& from); - WebFeatures(WebFeatures&& from) noexcept - : WebFeatures() { - *this = ::std::move(from); - } - - inline WebFeatures& operator=(const WebFeatures& from) { - CopyFrom(from); - return *this; - } - inline WebFeatures& operator=(WebFeatures&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const WebFeatures& default_instance() { - return *internal_default_instance(); - } - static inline const WebFeatures* internal_default_instance() { - return reinterpret_cast( - &_WebFeatures_default_instance_); - } - static constexpr int kIndexInFileMessages = - 221; - - friend void swap(WebFeatures& a, WebFeatures& b) { - a.Swap(&b); - } - inline void Swap(WebFeatures* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(WebFeatures* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - WebFeatures* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const WebFeatures& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const WebFeatures& from) { - WebFeatures::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(WebFeatures* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.WebFeatures"; - } - protected: - explicit WebFeatures(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef WebFeatures_Flag Flag; - static constexpr Flag NOT_STARTED = - WebFeatures_Flag_NOT_STARTED; - static constexpr Flag FORCE_UPGRADE = - WebFeatures_Flag_FORCE_UPGRADE; - static constexpr Flag DEVELOPMENT = - WebFeatures_Flag_DEVELOPMENT; - static constexpr Flag PRODUCTION = - WebFeatures_Flag_PRODUCTION; - static inline bool Flag_IsValid(int value) { - return WebFeatures_Flag_IsValid(value); - } - static constexpr Flag Flag_MIN = - WebFeatures_Flag_Flag_MIN; - static constexpr Flag Flag_MAX = - WebFeatures_Flag_Flag_MAX; - static constexpr int Flag_ARRAYSIZE = - WebFeatures_Flag_Flag_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - Flag_descriptor() { - return WebFeatures_Flag_descriptor(); - } - template - static inline const std::string& Flag_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Flag_Name."); - return WebFeatures_Flag_Name(enum_t_value); - } - static inline bool Flag_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - Flag* value) { - return WebFeatures_Flag_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kLabelsDisplayFieldNumber = 1, - kVoipIndividualOutgoingFieldNumber = 2, - kGroupsV3FieldNumber = 3, - kGroupsV3CreateFieldNumber = 4, - kChangeNumberV2FieldNumber = 5, - kQueryStatusV3ThumbnailFieldNumber = 6, - kLiveLocationsFieldNumber = 7, - kQueryVnameFieldNumber = 8, - kVoipIndividualIncomingFieldNumber = 9, - kQuickRepliesQueryFieldNumber = 10, - kPaymentsFieldNumber = 11, - kStickerPackQueryFieldNumber = 12, - kLiveLocationsFinalFieldNumber = 13, - kLabelsEditFieldNumber = 14, - kMediaUploadFieldNumber = 15, - kMediaUploadRichQuickRepliesFieldNumber = 18, - kVnameV2FieldNumber = 19, - kVideoPlaybackUrlFieldNumber = 20, - kStatusRankingFieldNumber = 21, - kVoipIndividualVideoFieldNumber = 22, - kThirdPartyStickersFieldNumber = 23, - kFrequentlyForwardedSettingFieldNumber = 24, - kGroupsV4JoinPermissionFieldNumber = 25, - kRecentStickersFieldNumber = 26, - kCatalogFieldNumber = 27, - kStarredStickersFieldNumber = 28, - kVoipGroupCallFieldNumber = 29, - kTemplateMessageFieldNumber = 30, - kTemplateMessageInteractivityFieldNumber = 31, - kEphemeralMessagesFieldNumber = 32, - kE2ENotificationSyncFieldNumber = 33, - kRecentStickersV2FieldNumber = 34, - kRecentStickersV3FieldNumber = 36, - kUserNoticeFieldNumber = 37, - kSupportFieldNumber = 39, - kGroupUiiCleanupFieldNumber = 40, - kGroupDogfoodingInternalOnlyFieldNumber = 41, - kSettingsSyncFieldNumber = 42, - kArchiveV2FieldNumber = 43, - kEphemeralAllowGroupMembersFieldNumber = 44, - kEphemeral24HDurationFieldNumber = 45, - kMdForceUpgradeFieldNumber = 46, - kDisappearingModeFieldNumber = 47, - kExternalMdOptInAvailableFieldNumber = 48, - kNoDeleteMessageTimeLimitFieldNumber = 49, - }; - // optional .proto.WebFeatures.Flag labelsDisplay = 1; - bool has_labelsdisplay() const; - private: - bool _internal_has_labelsdisplay() const; - public: - void clear_labelsdisplay(); - ::proto::WebFeatures_Flag labelsdisplay() const; - void set_labelsdisplay(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_labelsdisplay() const; - void _internal_set_labelsdisplay(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag voipIndividualOutgoing = 2; - bool has_voipindividualoutgoing() const; - private: - bool _internal_has_voipindividualoutgoing() const; - public: - void clear_voipindividualoutgoing(); - ::proto::WebFeatures_Flag voipindividualoutgoing() const; - void set_voipindividualoutgoing(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_voipindividualoutgoing() const; - void _internal_set_voipindividualoutgoing(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag groupsV3 = 3; - bool has_groupsv3() const; - private: - bool _internal_has_groupsv3() const; - public: - void clear_groupsv3(); - ::proto::WebFeatures_Flag groupsv3() const; - void set_groupsv3(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_groupsv3() const; - void _internal_set_groupsv3(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag groupsV3Create = 4; - bool has_groupsv3create() const; - private: - bool _internal_has_groupsv3create() const; - public: - void clear_groupsv3create(); - ::proto::WebFeatures_Flag groupsv3create() const; - void set_groupsv3create(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_groupsv3create() const; - void _internal_set_groupsv3create(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag changeNumberV2 = 5; - bool has_changenumberv2() const; - private: - bool _internal_has_changenumberv2() const; - public: - void clear_changenumberv2(); - ::proto::WebFeatures_Flag changenumberv2() const; - void set_changenumberv2(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_changenumberv2() const; - void _internal_set_changenumberv2(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag queryStatusV3Thumbnail = 6; - bool has_querystatusv3thumbnail() const; - private: - bool _internal_has_querystatusv3thumbnail() const; - public: - void clear_querystatusv3thumbnail(); - ::proto::WebFeatures_Flag querystatusv3thumbnail() const; - void set_querystatusv3thumbnail(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_querystatusv3thumbnail() const; - void _internal_set_querystatusv3thumbnail(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag liveLocations = 7; - bool has_livelocations() const; - private: - bool _internal_has_livelocations() const; - public: - void clear_livelocations(); - ::proto::WebFeatures_Flag livelocations() const; - void set_livelocations(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_livelocations() const; - void _internal_set_livelocations(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag queryVname = 8; - bool has_queryvname() const; - private: - bool _internal_has_queryvname() const; - public: - void clear_queryvname(); - ::proto::WebFeatures_Flag queryvname() const; - void set_queryvname(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_queryvname() const; - void _internal_set_queryvname(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag voipIndividualIncoming = 9; - bool has_voipindividualincoming() const; - private: - bool _internal_has_voipindividualincoming() const; - public: - void clear_voipindividualincoming(); - ::proto::WebFeatures_Flag voipindividualincoming() const; - void set_voipindividualincoming(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_voipindividualincoming() const; - void _internal_set_voipindividualincoming(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag quickRepliesQuery = 10; - bool has_quickrepliesquery() const; - private: - bool _internal_has_quickrepliesquery() const; - public: - void clear_quickrepliesquery(); - ::proto::WebFeatures_Flag quickrepliesquery() const; - void set_quickrepliesquery(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_quickrepliesquery() const; - void _internal_set_quickrepliesquery(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag payments = 11; - bool has_payments() const; - private: - bool _internal_has_payments() const; - public: - void clear_payments(); - ::proto::WebFeatures_Flag payments() const; - void set_payments(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_payments() const; - void _internal_set_payments(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag stickerPackQuery = 12; - bool has_stickerpackquery() const; - private: - bool _internal_has_stickerpackquery() const; - public: - void clear_stickerpackquery(); - ::proto::WebFeatures_Flag stickerpackquery() const; - void set_stickerpackquery(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_stickerpackquery() const; - void _internal_set_stickerpackquery(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag liveLocationsFinal = 13; - bool has_livelocationsfinal() const; - private: - bool _internal_has_livelocationsfinal() const; - public: - void clear_livelocationsfinal(); - ::proto::WebFeatures_Flag livelocationsfinal() const; - void set_livelocationsfinal(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_livelocationsfinal() const; - void _internal_set_livelocationsfinal(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag labelsEdit = 14; - bool has_labelsedit() const; - private: - bool _internal_has_labelsedit() const; - public: - void clear_labelsedit(); - ::proto::WebFeatures_Flag labelsedit() const; - void set_labelsedit(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_labelsedit() const; - void _internal_set_labelsedit(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag mediaUpload = 15; - bool has_mediaupload() const; - private: - bool _internal_has_mediaupload() const; - public: - void clear_mediaupload(); - ::proto::WebFeatures_Flag mediaupload() const; - void set_mediaupload(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_mediaupload() const; - void _internal_set_mediaupload(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag mediaUploadRichQuickReplies = 18; - bool has_mediauploadrichquickreplies() const; - private: - bool _internal_has_mediauploadrichquickreplies() const; - public: - void clear_mediauploadrichquickreplies(); - ::proto::WebFeatures_Flag mediauploadrichquickreplies() const; - void set_mediauploadrichquickreplies(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_mediauploadrichquickreplies() const; - void _internal_set_mediauploadrichquickreplies(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag vnameV2 = 19; - bool has_vnamev2() const; - private: - bool _internal_has_vnamev2() const; - public: - void clear_vnamev2(); - ::proto::WebFeatures_Flag vnamev2() const; - void set_vnamev2(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_vnamev2() const; - void _internal_set_vnamev2(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag videoPlaybackUrl = 20; - bool has_videoplaybackurl() const; - private: - bool _internal_has_videoplaybackurl() const; - public: - void clear_videoplaybackurl(); - ::proto::WebFeatures_Flag videoplaybackurl() const; - void set_videoplaybackurl(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_videoplaybackurl() const; - void _internal_set_videoplaybackurl(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag statusRanking = 21; - bool has_statusranking() const; - private: - bool _internal_has_statusranking() const; - public: - void clear_statusranking(); - ::proto::WebFeatures_Flag statusranking() const; - void set_statusranking(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_statusranking() const; - void _internal_set_statusranking(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag voipIndividualVideo = 22; - bool has_voipindividualvideo() const; - private: - bool _internal_has_voipindividualvideo() const; - public: - void clear_voipindividualvideo(); - ::proto::WebFeatures_Flag voipindividualvideo() const; - void set_voipindividualvideo(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_voipindividualvideo() const; - void _internal_set_voipindividualvideo(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag thirdPartyStickers = 23; - bool has_thirdpartystickers() const; - private: - bool _internal_has_thirdpartystickers() const; - public: - void clear_thirdpartystickers(); - ::proto::WebFeatures_Flag thirdpartystickers() const; - void set_thirdpartystickers(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_thirdpartystickers() const; - void _internal_set_thirdpartystickers(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag frequentlyForwardedSetting = 24; - bool has_frequentlyforwardedsetting() const; - private: - bool _internal_has_frequentlyforwardedsetting() const; - public: - void clear_frequentlyforwardedsetting(); - ::proto::WebFeatures_Flag frequentlyforwardedsetting() const; - void set_frequentlyforwardedsetting(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_frequentlyforwardedsetting() const; - void _internal_set_frequentlyforwardedsetting(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag groupsV4JoinPermission = 25; - bool has_groupsv4joinpermission() const; - private: - bool _internal_has_groupsv4joinpermission() const; - public: - void clear_groupsv4joinpermission(); - ::proto::WebFeatures_Flag groupsv4joinpermission() const; - void set_groupsv4joinpermission(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_groupsv4joinpermission() const; - void _internal_set_groupsv4joinpermission(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag recentStickers = 26; - bool has_recentstickers() const; - private: - bool _internal_has_recentstickers() const; - public: - void clear_recentstickers(); - ::proto::WebFeatures_Flag recentstickers() const; - void set_recentstickers(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_recentstickers() const; - void _internal_set_recentstickers(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag catalog = 27; - bool has_catalog() const; - private: - bool _internal_has_catalog() const; - public: - void clear_catalog(); - ::proto::WebFeatures_Flag catalog() const; - void set_catalog(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_catalog() const; - void _internal_set_catalog(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag starredStickers = 28; - bool has_starredstickers() const; - private: - bool _internal_has_starredstickers() const; - public: - void clear_starredstickers(); - ::proto::WebFeatures_Flag starredstickers() const; - void set_starredstickers(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_starredstickers() const; - void _internal_set_starredstickers(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag voipGroupCall = 29; - bool has_voipgroupcall() const; - private: - bool _internal_has_voipgroupcall() const; - public: - void clear_voipgroupcall(); - ::proto::WebFeatures_Flag voipgroupcall() const; - void set_voipgroupcall(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_voipgroupcall() const; - void _internal_set_voipgroupcall(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag templateMessage = 30; - bool has_templatemessage() const; - private: - bool _internal_has_templatemessage() const; - public: - void clear_templatemessage(); - ::proto::WebFeatures_Flag templatemessage() const; - void set_templatemessage(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_templatemessage() const; - void _internal_set_templatemessage(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag templateMessageInteractivity = 31; - bool has_templatemessageinteractivity() const; - private: - bool _internal_has_templatemessageinteractivity() const; - public: - void clear_templatemessageinteractivity(); - ::proto::WebFeatures_Flag templatemessageinteractivity() const; - void set_templatemessageinteractivity(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_templatemessageinteractivity() const; - void _internal_set_templatemessageinteractivity(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag ephemeralMessages = 32; - bool has_ephemeralmessages() const; - private: - bool _internal_has_ephemeralmessages() const; - public: - void clear_ephemeralmessages(); - ::proto::WebFeatures_Flag ephemeralmessages() const; - void set_ephemeralmessages(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_ephemeralmessages() const; - void _internal_set_ephemeralmessages(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag e2ENotificationSync = 33; - bool has_e2enotificationsync() const; - private: - bool _internal_has_e2enotificationsync() const; - public: - void clear_e2enotificationsync(); - ::proto::WebFeatures_Flag e2enotificationsync() const; - void set_e2enotificationsync(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_e2enotificationsync() const; - void _internal_set_e2enotificationsync(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag recentStickersV2 = 34; - bool has_recentstickersv2() const; - private: - bool _internal_has_recentstickersv2() const; - public: - void clear_recentstickersv2(); - ::proto::WebFeatures_Flag recentstickersv2() const; - void set_recentstickersv2(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_recentstickersv2() const; - void _internal_set_recentstickersv2(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag recentStickersV3 = 36; - bool has_recentstickersv3() const; - private: - bool _internal_has_recentstickersv3() const; - public: - void clear_recentstickersv3(); - ::proto::WebFeatures_Flag recentstickersv3() const; - void set_recentstickersv3(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_recentstickersv3() const; - void _internal_set_recentstickersv3(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag userNotice = 37; - bool has_usernotice() const; - private: - bool _internal_has_usernotice() const; - public: - void clear_usernotice(); - ::proto::WebFeatures_Flag usernotice() const; - void set_usernotice(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_usernotice() const; - void _internal_set_usernotice(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag support = 39; - bool has_support() const; - private: - bool _internal_has_support() const; - public: - void clear_support(); - ::proto::WebFeatures_Flag support() const; - void set_support(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_support() const; - void _internal_set_support(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag groupUiiCleanup = 40; - bool has_groupuiicleanup() const; - private: - bool _internal_has_groupuiicleanup() const; - public: - void clear_groupuiicleanup(); - ::proto::WebFeatures_Flag groupuiicleanup() const; - void set_groupuiicleanup(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_groupuiicleanup() const; - void _internal_set_groupuiicleanup(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag groupDogfoodingInternalOnly = 41; - bool has_groupdogfoodinginternalonly() const; - private: - bool _internal_has_groupdogfoodinginternalonly() const; - public: - void clear_groupdogfoodinginternalonly(); - ::proto::WebFeatures_Flag groupdogfoodinginternalonly() const; - void set_groupdogfoodinginternalonly(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_groupdogfoodinginternalonly() const; - void _internal_set_groupdogfoodinginternalonly(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag settingsSync = 42; - bool has_settingssync() const; - private: - bool _internal_has_settingssync() const; - public: - void clear_settingssync(); - ::proto::WebFeatures_Flag settingssync() const; - void set_settingssync(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_settingssync() const; - void _internal_set_settingssync(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag archiveV2 = 43; - bool has_archivev2() const; - private: - bool _internal_has_archivev2() const; - public: - void clear_archivev2(); - ::proto::WebFeatures_Flag archivev2() const; - void set_archivev2(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_archivev2() const; - void _internal_set_archivev2(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag ephemeralAllowGroupMembers = 44; - bool has_ephemeralallowgroupmembers() const; - private: - bool _internal_has_ephemeralallowgroupmembers() const; - public: - void clear_ephemeralallowgroupmembers(); - ::proto::WebFeatures_Flag ephemeralallowgroupmembers() const; - void set_ephemeralallowgroupmembers(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_ephemeralallowgroupmembers() const; - void _internal_set_ephemeralallowgroupmembers(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag ephemeral24HDuration = 45; - bool has_ephemeral24hduration() const; - private: - bool _internal_has_ephemeral24hduration() const; - public: - void clear_ephemeral24hduration(); - ::proto::WebFeatures_Flag ephemeral24hduration() const; - void set_ephemeral24hduration(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_ephemeral24hduration() const; - void _internal_set_ephemeral24hduration(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag mdForceUpgrade = 46; - bool has_mdforceupgrade() const; - private: - bool _internal_has_mdforceupgrade() const; - public: - void clear_mdforceupgrade(); - ::proto::WebFeatures_Flag mdforceupgrade() const; - void set_mdforceupgrade(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_mdforceupgrade() const; - void _internal_set_mdforceupgrade(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag disappearingMode = 47; - bool has_disappearingmode() const; - private: - bool _internal_has_disappearingmode() const; - public: - void clear_disappearingmode(); - ::proto::WebFeatures_Flag disappearingmode() const; - void set_disappearingmode(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_disappearingmode() const; - void _internal_set_disappearingmode(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag externalMdOptInAvailable = 48; - bool has_externalmdoptinavailable() const; - private: - bool _internal_has_externalmdoptinavailable() const; - public: - void clear_externalmdoptinavailable(); - ::proto::WebFeatures_Flag externalmdoptinavailable() const; - void set_externalmdoptinavailable(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_externalmdoptinavailable() const; - void _internal_set_externalmdoptinavailable(::proto::WebFeatures_Flag value); - public: - - // optional .proto.WebFeatures.Flag noDeleteMessageTimeLimit = 49; - bool has_nodeletemessagetimelimit() const; - private: - bool _internal_has_nodeletemessagetimelimit() const; - public: - void clear_nodeletemessagetimelimit(); - ::proto::WebFeatures_Flag nodeletemessagetimelimit() const; - void set_nodeletemessagetimelimit(::proto::WebFeatures_Flag value); - private: - ::proto::WebFeatures_Flag _internal_nodeletemessagetimelimit() const; - void _internal_set_nodeletemessagetimelimit(::proto::WebFeatures_Flag value); - public: - - // @@protoc_insertion_point(class_scope:proto.WebFeatures) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<2> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - int labelsdisplay_; - int voipindividualoutgoing_; - int groupsv3_; - int groupsv3create_; - int changenumberv2_; - int querystatusv3thumbnail_; - int livelocations_; - int queryvname_; - int voipindividualincoming_; - int quickrepliesquery_; - int payments_; - int stickerpackquery_; - int livelocationsfinal_; - int labelsedit_; - int mediaupload_; - int mediauploadrichquickreplies_; - int vnamev2_; - int videoplaybackurl_; - int statusranking_; - int voipindividualvideo_; - int thirdpartystickers_; - int frequentlyforwardedsetting_; - int groupsv4joinpermission_; - int recentstickers_; - int catalog_; - int starredstickers_; - int voipgroupcall_; - int templatemessage_; - int templatemessageinteractivity_; - int ephemeralmessages_; - int e2enotificationsync_; - int recentstickersv2_; - int recentstickersv3_; - int usernotice_; - int support_; - int groupuiicleanup_; - int groupdogfoodinginternalonly_; - int settingssync_; - int archivev2_; - int ephemeralallowgroupmembers_; - int ephemeral24hduration_; - int mdforceupgrade_; - int disappearingmode_; - int externalmdoptinavailable_; - int nodeletemessagetimelimit_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class WebMessageInfo final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.WebMessageInfo) */ { - public: - inline WebMessageInfo() : WebMessageInfo(nullptr) {} - ~WebMessageInfo() override; - explicit PROTOBUF_CONSTEXPR WebMessageInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - WebMessageInfo(const WebMessageInfo& from); - WebMessageInfo(WebMessageInfo&& from) noexcept - : WebMessageInfo() { - *this = ::std::move(from); - } - - inline WebMessageInfo& operator=(const WebMessageInfo& from) { - CopyFrom(from); - return *this; - } - inline WebMessageInfo& operator=(WebMessageInfo&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const WebMessageInfo& default_instance() { - return *internal_default_instance(); - } - static inline const WebMessageInfo* internal_default_instance() { - return reinterpret_cast( - &_WebMessageInfo_default_instance_); - } - static constexpr int kIndexInFileMessages = - 222; - - friend void swap(WebMessageInfo& a, WebMessageInfo& b) { - a.Swap(&b); - } - inline void Swap(WebMessageInfo* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(WebMessageInfo* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - WebMessageInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const WebMessageInfo& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const WebMessageInfo& from) { - WebMessageInfo::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(WebMessageInfo* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.WebMessageInfo"; - } - protected: - explicit WebMessageInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef WebMessageInfo_BizPrivacyStatus BizPrivacyStatus; - static constexpr BizPrivacyStatus E2EE = - WebMessageInfo_BizPrivacyStatus_E2EE; - static constexpr BizPrivacyStatus FB = - WebMessageInfo_BizPrivacyStatus_FB; - static constexpr BizPrivacyStatus BSP = - WebMessageInfo_BizPrivacyStatus_BSP; - static constexpr BizPrivacyStatus BSP_AND_FB = - WebMessageInfo_BizPrivacyStatus_BSP_AND_FB; - static inline bool BizPrivacyStatus_IsValid(int value) { - return WebMessageInfo_BizPrivacyStatus_IsValid(value); - } - static constexpr BizPrivacyStatus BizPrivacyStatus_MIN = - WebMessageInfo_BizPrivacyStatus_BizPrivacyStatus_MIN; - static constexpr BizPrivacyStatus BizPrivacyStatus_MAX = - WebMessageInfo_BizPrivacyStatus_BizPrivacyStatus_MAX; - static constexpr int BizPrivacyStatus_ARRAYSIZE = - WebMessageInfo_BizPrivacyStatus_BizPrivacyStatus_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - BizPrivacyStatus_descriptor() { - return WebMessageInfo_BizPrivacyStatus_descriptor(); - } - template - static inline const std::string& BizPrivacyStatus_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function BizPrivacyStatus_Name."); - return WebMessageInfo_BizPrivacyStatus_Name(enum_t_value); - } - static inline bool BizPrivacyStatus_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - BizPrivacyStatus* value) { - return WebMessageInfo_BizPrivacyStatus_Parse(name, value); - } - - typedef WebMessageInfo_Status Status; - static constexpr Status ERROR = - WebMessageInfo_Status_ERROR; - static constexpr Status PENDING = - WebMessageInfo_Status_PENDING; - static constexpr Status SERVER_ACK = - WebMessageInfo_Status_SERVER_ACK; - static constexpr Status DELIVERY_ACK = - WebMessageInfo_Status_DELIVERY_ACK; - static constexpr Status READ = - WebMessageInfo_Status_READ; - static constexpr Status PLAYED = - WebMessageInfo_Status_PLAYED; - static inline bool Status_IsValid(int value) { - return WebMessageInfo_Status_IsValid(value); - } - static constexpr Status Status_MIN = - WebMessageInfo_Status_Status_MIN; - static constexpr Status Status_MAX = - WebMessageInfo_Status_Status_MAX; - static constexpr int Status_ARRAYSIZE = - WebMessageInfo_Status_Status_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - Status_descriptor() { - return WebMessageInfo_Status_descriptor(); - } - template - static inline const std::string& Status_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Status_Name."); - return WebMessageInfo_Status_Name(enum_t_value); - } - static inline bool Status_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - Status* value) { - return WebMessageInfo_Status_Parse(name, value); - } - - typedef WebMessageInfo_StubType StubType; - static constexpr StubType UNKNOWN = - WebMessageInfo_StubType_UNKNOWN; - static constexpr StubType REVOKE = - WebMessageInfo_StubType_REVOKE; - static constexpr StubType CIPHERTEXT = - WebMessageInfo_StubType_CIPHERTEXT; - static constexpr StubType FUTUREPROOF = - WebMessageInfo_StubType_FUTUREPROOF; - static constexpr StubType NON_VERIFIED_TRANSITION = - WebMessageInfo_StubType_NON_VERIFIED_TRANSITION; - static constexpr StubType UNVERIFIED_TRANSITION = - WebMessageInfo_StubType_UNVERIFIED_TRANSITION; - static constexpr StubType VERIFIED_TRANSITION = - WebMessageInfo_StubType_VERIFIED_TRANSITION; - static constexpr StubType VERIFIED_LOW_UNKNOWN = - WebMessageInfo_StubType_VERIFIED_LOW_UNKNOWN; - static constexpr StubType VERIFIED_HIGH = - WebMessageInfo_StubType_VERIFIED_HIGH; - static constexpr StubType VERIFIED_INITIAL_UNKNOWN = - WebMessageInfo_StubType_VERIFIED_INITIAL_UNKNOWN; - static constexpr StubType VERIFIED_INITIAL_LOW = - WebMessageInfo_StubType_VERIFIED_INITIAL_LOW; - static constexpr StubType VERIFIED_INITIAL_HIGH = - WebMessageInfo_StubType_VERIFIED_INITIAL_HIGH; - static constexpr StubType VERIFIED_TRANSITION_ANY_TO_NONE = - WebMessageInfo_StubType_VERIFIED_TRANSITION_ANY_TO_NONE; - static constexpr StubType VERIFIED_TRANSITION_ANY_TO_HIGH = - WebMessageInfo_StubType_VERIFIED_TRANSITION_ANY_TO_HIGH; - static constexpr StubType VERIFIED_TRANSITION_HIGH_TO_LOW = - WebMessageInfo_StubType_VERIFIED_TRANSITION_HIGH_TO_LOW; - static constexpr StubType VERIFIED_TRANSITION_HIGH_TO_UNKNOWN = - WebMessageInfo_StubType_VERIFIED_TRANSITION_HIGH_TO_UNKNOWN; - static constexpr StubType VERIFIED_TRANSITION_UNKNOWN_TO_LOW = - WebMessageInfo_StubType_VERIFIED_TRANSITION_UNKNOWN_TO_LOW; - static constexpr StubType VERIFIED_TRANSITION_LOW_TO_UNKNOWN = - WebMessageInfo_StubType_VERIFIED_TRANSITION_LOW_TO_UNKNOWN; - static constexpr StubType VERIFIED_TRANSITION_NONE_TO_LOW = - WebMessageInfo_StubType_VERIFIED_TRANSITION_NONE_TO_LOW; - static constexpr StubType VERIFIED_TRANSITION_NONE_TO_UNKNOWN = - WebMessageInfo_StubType_VERIFIED_TRANSITION_NONE_TO_UNKNOWN; - static constexpr StubType GROUP_CREATE = - WebMessageInfo_StubType_GROUP_CREATE; - static constexpr StubType GROUP_CHANGE_SUBJECT = - WebMessageInfo_StubType_GROUP_CHANGE_SUBJECT; - static constexpr StubType GROUP_CHANGE_ICON = - WebMessageInfo_StubType_GROUP_CHANGE_ICON; - static constexpr StubType GROUP_CHANGE_INVITE_LINK = - WebMessageInfo_StubType_GROUP_CHANGE_INVITE_LINK; - static constexpr StubType GROUP_CHANGE_DESCRIPTION = - WebMessageInfo_StubType_GROUP_CHANGE_DESCRIPTION; - static constexpr StubType GROUP_CHANGE_RESTRICT = - WebMessageInfo_StubType_GROUP_CHANGE_RESTRICT; - static constexpr StubType GROUP_CHANGE_ANNOUNCE = - WebMessageInfo_StubType_GROUP_CHANGE_ANNOUNCE; - static constexpr StubType GROUP_PARTICIPANT_ADD = - WebMessageInfo_StubType_GROUP_PARTICIPANT_ADD; - static constexpr StubType GROUP_PARTICIPANT_REMOVE = - WebMessageInfo_StubType_GROUP_PARTICIPANT_REMOVE; - static constexpr StubType GROUP_PARTICIPANT_PROMOTE = - WebMessageInfo_StubType_GROUP_PARTICIPANT_PROMOTE; - static constexpr StubType GROUP_PARTICIPANT_DEMOTE = - WebMessageInfo_StubType_GROUP_PARTICIPANT_DEMOTE; - static constexpr StubType GROUP_PARTICIPANT_INVITE = - WebMessageInfo_StubType_GROUP_PARTICIPANT_INVITE; - static constexpr StubType GROUP_PARTICIPANT_LEAVE = - WebMessageInfo_StubType_GROUP_PARTICIPANT_LEAVE; - static constexpr StubType GROUP_PARTICIPANT_CHANGE_NUMBER = - WebMessageInfo_StubType_GROUP_PARTICIPANT_CHANGE_NUMBER; - static constexpr StubType BROADCAST_CREATE = - WebMessageInfo_StubType_BROADCAST_CREATE; - static constexpr StubType BROADCAST_ADD = - WebMessageInfo_StubType_BROADCAST_ADD; - static constexpr StubType BROADCAST_REMOVE = - WebMessageInfo_StubType_BROADCAST_REMOVE; - static constexpr StubType GENERIC_NOTIFICATION = - WebMessageInfo_StubType_GENERIC_NOTIFICATION; - static constexpr StubType E2E_IDENTITY_CHANGED = - WebMessageInfo_StubType_E2E_IDENTITY_CHANGED; - static constexpr StubType E2E_ENCRYPTED = - WebMessageInfo_StubType_E2E_ENCRYPTED; - static constexpr StubType CALL_MISSED_VOICE = - WebMessageInfo_StubType_CALL_MISSED_VOICE; - static constexpr StubType CALL_MISSED_VIDEO = - WebMessageInfo_StubType_CALL_MISSED_VIDEO; - static constexpr StubType INDIVIDUAL_CHANGE_NUMBER = - WebMessageInfo_StubType_INDIVIDUAL_CHANGE_NUMBER; - static constexpr StubType GROUP_DELETE = - WebMessageInfo_StubType_GROUP_DELETE; - static constexpr StubType GROUP_ANNOUNCE_MODE_MESSAGE_BOUNCE = - WebMessageInfo_StubType_GROUP_ANNOUNCE_MODE_MESSAGE_BOUNCE; - static constexpr StubType CALL_MISSED_GROUP_VOICE = - WebMessageInfo_StubType_CALL_MISSED_GROUP_VOICE; - static constexpr StubType CALL_MISSED_GROUP_VIDEO = - WebMessageInfo_StubType_CALL_MISSED_GROUP_VIDEO; - static constexpr StubType PAYMENT_CIPHERTEXT = - WebMessageInfo_StubType_PAYMENT_CIPHERTEXT; - static constexpr StubType PAYMENT_FUTUREPROOF = - WebMessageInfo_StubType_PAYMENT_FUTUREPROOF; - static constexpr StubType PAYMENT_TRANSACTION_STATUS_UPDATE_FAILED = - WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_UPDATE_FAILED; - static constexpr StubType PAYMENT_TRANSACTION_STATUS_UPDATE_REFUNDED = - WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_UPDATE_REFUNDED; - static constexpr StubType PAYMENT_TRANSACTION_STATUS_UPDATE_REFUND_FAILED = - WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_UPDATE_REFUND_FAILED; - static constexpr StubType PAYMENT_TRANSACTION_STATUS_RECEIVER_PENDING_SETUP = - WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_RECEIVER_PENDING_SETUP; - static constexpr StubType PAYMENT_TRANSACTION_STATUS_RECEIVER_SUCCESS_AFTER_HICCUP = - WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_RECEIVER_SUCCESS_AFTER_HICCUP; - static constexpr StubType PAYMENT_ACTION_ACCOUNT_SETUP_REMINDER = - WebMessageInfo_StubType_PAYMENT_ACTION_ACCOUNT_SETUP_REMINDER; - static constexpr StubType PAYMENT_ACTION_SEND_PAYMENT_REMINDER = - WebMessageInfo_StubType_PAYMENT_ACTION_SEND_PAYMENT_REMINDER; - static constexpr StubType PAYMENT_ACTION_SEND_PAYMENT_INVITATION = - WebMessageInfo_StubType_PAYMENT_ACTION_SEND_PAYMENT_INVITATION; - static constexpr StubType PAYMENT_ACTION_REQUEST_DECLINED = - WebMessageInfo_StubType_PAYMENT_ACTION_REQUEST_DECLINED; - static constexpr StubType PAYMENT_ACTION_REQUEST_EXPIRED = - WebMessageInfo_StubType_PAYMENT_ACTION_REQUEST_EXPIRED; - static constexpr StubType PAYMENT_ACTION_REQUEST_CANCELLED = - WebMessageInfo_StubType_PAYMENT_ACTION_REQUEST_CANCELLED; - static constexpr StubType BIZ_VERIFIED_TRANSITION_TOP_TO_BOTTOM = - WebMessageInfo_StubType_BIZ_VERIFIED_TRANSITION_TOP_TO_BOTTOM; - static constexpr StubType BIZ_VERIFIED_TRANSITION_BOTTOM_TO_TOP = - WebMessageInfo_StubType_BIZ_VERIFIED_TRANSITION_BOTTOM_TO_TOP; - static constexpr StubType BIZ_INTRO_TOP = - WebMessageInfo_StubType_BIZ_INTRO_TOP; - static constexpr StubType BIZ_INTRO_BOTTOM = - WebMessageInfo_StubType_BIZ_INTRO_BOTTOM; - static constexpr StubType BIZ_NAME_CHANGE = - WebMessageInfo_StubType_BIZ_NAME_CHANGE; - static constexpr StubType BIZ_MOVE_TO_CONSUMER_APP = - WebMessageInfo_StubType_BIZ_MOVE_TO_CONSUMER_APP; - static constexpr StubType BIZ_TWO_TIER_MIGRATION_TOP = - WebMessageInfo_StubType_BIZ_TWO_TIER_MIGRATION_TOP; - static constexpr StubType BIZ_TWO_TIER_MIGRATION_BOTTOM = - WebMessageInfo_StubType_BIZ_TWO_TIER_MIGRATION_BOTTOM; - static constexpr StubType OVERSIZED = - WebMessageInfo_StubType_OVERSIZED; - static constexpr StubType GROUP_CHANGE_NO_FREQUENTLY_FORWARDED = - WebMessageInfo_StubType_GROUP_CHANGE_NO_FREQUENTLY_FORWARDED; - static constexpr StubType GROUP_V4_ADD_INVITE_SENT = - WebMessageInfo_StubType_GROUP_V4_ADD_INVITE_SENT; - static constexpr StubType GROUP_PARTICIPANT_ADD_REQUEST_JOIN = - WebMessageInfo_StubType_GROUP_PARTICIPANT_ADD_REQUEST_JOIN; - static constexpr StubType CHANGE_EPHEMERAL_SETTING = - WebMessageInfo_StubType_CHANGE_EPHEMERAL_SETTING; - static constexpr StubType E2E_DEVICE_CHANGED = - WebMessageInfo_StubType_E2E_DEVICE_CHANGED; - static constexpr StubType VIEWED_ONCE = - WebMessageInfo_StubType_VIEWED_ONCE; - static constexpr StubType E2E_ENCRYPTED_NOW = - WebMessageInfo_StubType_E2E_ENCRYPTED_NOW; - static constexpr StubType BLUE_MSG_BSP_FB_TO_BSP_PREMISE = - WebMessageInfo_StubType_BLUE_MSG_BSP_FB_TO_BSP_PREMISE; - static constexpr StubType BLUE_MSG_BSP_FB_TO_SELF_FB = - WebMessageInfo_StubType_BLUE_MSG_BSP_FB_TO_SELF_FB; - static constexpr StubType BLUE_MSG_BSP_FB_TO_SELF_PREMISE = - WebMessageInfo_StubType_BLUE_MSG_BSP_FB_TO_SELF_PREMISE; - static constexpr StubType BLUE_MSG_BSP_FB_UNVERIFIED = - WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED; - static constexpr StubType BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED = - WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED; - static constexpr StubType BLUE_MSG_BSP_FB_VERIFIED = - WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED; - static constexpr StubType BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED = - WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED; - static constexpr StubType BLUE_MSG_BSP_PREMISE_TO_SELF_PREMISE = - WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_TO_SELF_PREMISE; - static constexpr StubType BLUE_MSG_BSP_PREMISE_UNVERIFIED = - WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_UNVERIFIED; - static constexpr StubType BLUE_MSG_BSP_PREMISE_UNVERIFIED_TO_SELF_PREMISE_VERIFIED = - WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_UNVERIFIED_TO_SELF_PREMISE_VERIFIED; - static constexpr StubType BLUE_MSG_BSP_PREMISE_VERIFIED = - WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_VERIFIED; - static constexpr StubType BLUE_MSG_BSP_PREMISE_VERIFIED_TO_SELF_PREMISE_UNVERIFIED = - WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_VERIFIED_TO_SELF_PREMISE_UNVERIFIED; - static constexpr StubType BLUE_MSG_CONSUMER_TO_BSP_FB_UNVERIFIED = - WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_BSP_FB_UNVERIFIED; - static constexpr StubType BLUE_MSG_CONSUMER_TO_BSP_PREMISE_UNVERIFIED = - WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_BSP_PREMISE_UNVERIFIED; - static constexpr StubType BLUE_MSG_CONSUMER_TO_SELF_FB_UNVERIFIED = - WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_SELF_FB_UNVERIFIED; - static constexpr StubType BLUE_MSG_CONSUMER_TO_SELF_PREMISE_UNVERIFIED = - WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_SELF_PREMISE_UNVERIFIED; - static constexpr StubType BLUE_MSG_SELF_FB_TO_BSP_PREMISE = - WebMessageInfo_StubType_BLUE_MSG_SELF_FB_TO_BSP_PREMISE; - static constexpr StubType BLUE_MSG_SELF_FB_TO_SELF_PREMISE = - WebMessageInfo_StubType_BLUE_MSG_SELF_FB_TO_SELF_PREMISE; - static constexpr StubType BLUE_MSG_SELF_FB_UNVERIFIED = - WebMessageInfo_StubType_BLUE_MSG_SELF_FB_UNVERIFIED; - static constexpr StubType BLUE_MSG_SELF_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED = - WebMessageInfo_StubType_BLUE_MSG_SELF_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED; - static constexpr StubType BLUE_MSG_SELF_FB_VERIFIED = - WebMessageInfo_StubType_BLUE_MSG_SELF_FB_VERIFIED; - static constexpr StubType BLUE_MSG_SELF_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED = - WebMessageInfo_StubType_BLUE_MSG_SELF_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED; - static constexpr StubType BLUE_MSG_SELF_PREMISE_TO_BSP_PREMISE = - WebMessageInfo_StubType_BLUE_MSG_SELF_PREMISE_TO_BSP_PREMISE; - static constexpr StubType BLUE_MSG_SELF_PREMISE_UNVERIFIED = - WebMessageInfo_StubType_BLUE_MSG_SELF_PREMISE_UNVERIFIED; - static constexpr StubType BLUE_MSG_SELF_PREMISE_VERIFIED = - WebMessageInfo_StubType_BLUE_MSG_SELF_PREMISE_VERIFIED; - static constexpr StubType BLUE_MSG_TO_BSP_FB = - WebMessageInfo_StubType_BLUE_MSG_TO_BSP_FB; - static constexpr StubType BLUE_MSG_TO_CONSUMER = - WebMessageInfo_StubType_BLUE_MSG_TO_CONSUMER; - static constexpr StubType BLUE_MSG_TO_SELF_FB = - WebMessageInfo_StubType_BLUE_MSG_TO_SELF_FB; - static constexpr StubType BLUE_MSG_UNVERIFIED_TO_BSP_FB_VERIFIED = - WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_BSP_FB_VERIFIED; - static constexpr StubType BLUE_MSG_UNVERIFIED_TO_BSP_PREMISE_VERIFIED = - WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_BSP_PREMISE_VERIFIED; - static constexpr StubType BLUE_MSG_UNVERIFIED_TO_SELF_FB_VERIFIED = - WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_SELF_FB_VERIFIED; - static constexpr StubType BLUE_MSG_UNVERIFIED_TO_VERIFIED = - WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_VERIFIED; - static constexpr StubType BLUE_MSG_VERIFIED_TO_BSP_FB_UNVERIFIED = - WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_BSP_FB_UNVERIFIED; - static constexpr StubType BLUE_MSG_VERIFIED_TO_BSP_PREMISE_UNVERIFIED = - WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_BSP_PREMISE_UNVERIFIED; - static constexpr StubType BLUE_MSG_VERIFIED_TO_SELF_FB_UNVERIFIED = - WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_SELF_FB_UNVERIFIED; - static constexpr StubType BLUE_MSG_VERIFIED_TO_UNVERIFIED = - WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_UNVERIFIED; - static constexpr StubType BLUE_MSG_BSP_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED = - WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED; - static constexpr StubType BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_FB_VERIFIED = - WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_FB_VERIFIED; - static constexpr StubType BLUE_MSG_BSP_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED = - WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED; - static constexpr StubType BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_FB_UNVERIFIED = - WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_FB_UNVERIFIED; - static constexpr StubType BLUE_MSG_SELF_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED = - WebMessageInfo_StubType_BLUE_MSG_SELF_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED; - static constexpr StubType BLUE_MSG_SELF_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED = - WebMessageInfo_StubType_BLUE_MSG_SELF_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED; - static constexpr StubType E2E_IDENTITY_UNAVAILABLE = - WebMessageInfo_StubType_E2E_IDENTITY_UNAVAILABLE; - static constexpr StubType GROUP_CREATING = - WebMessageInfo_StubType_GROUP_CREATING; - static constexpr StubType GROUP_CREATE_FAILED = - WebMessageInfo_StubType_GROUP_CREATE_FAILED; - static constexpr StubType GROUP_BOUNCED = - WebMessageInfo_StubType_GROUP_BOUNCED; - static constexpr StubType BLOCK_CONTACT = - WebMessageInfo_StubType_BLOCK_CONTACT; - static constexpr StubType EPHEMERAL_SETTING_NOT_APPLIED = - WebMessageInfo_StubType_EPHEMERAL_SETTING_NOT_APPLIED; - static constexpr StubType SYNC_FAILED = - WebMessageInfo_StubType_SYNC_FAILED; - static constexpr StubType SYNCING = - WebMessageInfo_StubType_SYNCING; - static constexpr StubType BIZ_PRIVACY_MODE_INIT_FB = - WebMessageInfo_StubType_BIZ_PRIVACY_MODE_INIT_FB; - static constexpr StubType BIZ_PRIVACY_MODE_INIT_BSP = - WebMessageInfo_StubType_BIZ_PRIVACY_MODE_INIT_BSP; - static constexpr StubType BIZ_PRIVACY_MODE_TO_FB = - WebMessageInfo_StubType_BIZ_PRIVACY_MODE_TO_FB; - static constexpr StubType BIZ_PRIVACY_MODE_TO_BSP = - WebMessageInfo_StubType_BIZ_PRIVACY_MODE_TO_BSP; - static constexpr StubType DISAPPEARING_MODE = - WebMessageInfo_StubType_DISAPPEARING_MODE; - static constexpr StubType E2E_DEVICE_FETCH_FAILED = - WebMessageInfo_StubType_E2E_DEVICE_FETCH_FAILED; - static constexpr StubType ADMIN_REVOKE = - WebMessageInfo_StubType_ADMIN_REVOKE; - static constexpr StubType GROUP_INVITE_LINK_GROWTH_LOCKED = - WebMessageInfo_StubType_GROUP_INVITE_LINK_GROWTH_LOCKED; - static constexpr StubType COMMUNITY_LINK_PARENT_GROUP = - WebMessageInfo_StubType_COMMUNITY_LINK_PARENT_GROUP; - static constexpr StubType COMMUNITY_LINK_SIBLING_GROUP = - WebMessageInfo_StubType_COMMUNITY_LINK_SIBLING_GROUP; - static constexpr StubType COMMUNITY_LINK_SUB_GROUP = - WebMessageInfo_StubType_COMMUNITY_LINK_SUB_GROUP; - static constexpr StubType COMMUNITY_UNLINK_PARENT_GROUP = - WebMessageInfo_StubType_COMMUNITY_UNLINK_PARENT_GROUP; - static constexpr StubType COMMUNITY_UNLINK_SIBLING_GROUP = - WebMessageInfo_StubType_COMMUNITY_UNLINK_SIBLING_GROUP; - static constexpr StubType COMMUNITY_UNLINK_SUB_GROUP = - WebMessageInfo_StubType_COMMUNITY_UNLINK_SUB_GROUP; - static constexpr StubType GROUP_PARTICIPANT_ACCEPT = - WebMessageInfo_StubType_GROUP_PARTICIPANT_ACCEPT; - static constexpr StubType GROUP_PARTICIPANT_LINKED_GROUP_JOIN = - WebMessageInfo_StubType_GROUP_PARTICIPANT_LINKED_GROUP_JOIN; - static constexpr StubType COMMUNITY_CREATE = - WebMessageInfo_StubType_COMMUNITY_CREATE; - static constexpr StubType EPHEMERAL_KEEP_IN_CHAT = - WebMessageInfo_StubType_EPHEMERAL_KEEP_IN_CHAT; - static constexpr StubType GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST = - WebMessageInfo_StubType_GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST; - static constexpr StubType GROUP_MEMBERSHIP_JOIN_APPROVAL_MODE = - WebMessageInfo_StubType_GROUP_MEMBERSHIP_JOIN_APPROVAL_MODE; - static constexpr StubType INTEGRITY_UNLINK_PARENT_GROUP = - WebMessageInfo_StubType_INTEGRITY_UNLINK_PARENT_GROUP; - static constexpr StubType COMMUNITY_PARTICIPANT_PROMOTE = - WebMessageInfo_StubType_COMMUNITY_PARTICIPANT_PROMOTE; - static constexpr StubType COMMUNITY_PARTICIPANT_DEMOTE = - WebMessageInfo_StubType_COMMUNITY_PARTICIPANT_DEMOTE; - static constexpr StubType COMMUNITY_PARENT_GROUP_DELETED = - WebMessageInfo_StubType_COMMUNITY_PARENT_GROUP_DELETED; - static inline bool StubType_IsValid(int value) { - return WebMessageInfo_StubType_IsValid(value); - } - static constexpr StubType StubType_MIN = - WebMessageInfo_StubType_StubType_MIN; - static constexpr StubType StubType_MAX = - WebMessageInfo_StubType_StubType_MAX; - static constexpr int StubType_ARRAYSIZE = - WebMessageInfo_StubType_StubType_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - StubType_descriptor() { - return WebMessageInfo_StubType_descriptor(); - } - template - static inline const std::string& StubType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function StubType_Name."); - return WebMessageInfo_StubType_Name(enum_t_value); - } - static inline bool StubType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - StubType* value) { - return WebMessageInfo_StubType_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kMessageStubParametersFieldNumber = 26, - kLabelsFieldNumber = 28, - kUserReceiptFieldNumber = 40, - kReactionsFieldNumber = 41, - kPollUpdatesFieldNumber = 45, - kParticipantFieldNumber = 5, - kPushNameFieldNumber = 19, - kMediaCiphertextSha256FieldNumber = 20, - kVerifiedBizNameFieldNumber = 37, - kFutureproofDataFieldNumber = 43, - kAgentIdFieldNumber = 47, - kMessageSecretFieldNumber = 49, - kOriginalSelfAuthorUserJidStringFieldNumber = 51, - kKeyFieldNumber = 1, - kMessageFieldNumber = 2, - kPaymentInfoFieldNumber = 29, - kFinalLiveLocationFieldNumber = 30, - kQuotedPaymentInfoFieldNumber = 31, - kMediaDataFieldNumber = 38, - kPhotoChangeFieldNumber = 39, - kQuotedStickerDataFieldNumber = 42, - kStatusPsaFieldNumber = 44, - kPollAdditionalMetadataFieldNumber = 46, - kKeepInChatFieldNumber = 50, - kMessageTimestampFieldNumber = 3, - kMessageC2STimestampFieldNumber = 6, - kStatusFieldNumber = 4, - kIgnoreFieldNumber = 16, - kStarredFieldNumber = 17, - kBroadcastFieldNumber = 18, - kMulticastFieldNumber = 21, - kMessageStubTypeFieldNumber = 24, - kUrlTextFieldNumber = 22, - kUrlNumberFieldNumber = 23, - kClearMediaFieldNumber = 25, - kEphemeralOffToOnFieldNumber = 34, - kDurationFieldNumber = 27, - kEphemeralDurationFieldNumber = 33, - kEphemeralStartTimestampFieldNumber = 32, - kBizPrivacyStatusFieldNumber = 36, - kEphemeralOutOfSyncFieldNumber = 35, - kStatusAlreadyViewedFieldNumber = 48, - kRevokeMessageTimestampFieldNumber = 52, - }; - // repeated string messageStubParameters = 26; - int messagestubparameters_size() const; - private: - int _internal_messagestubparameters_size() const; - public: - void clear_messagestubparameters(); - const std::string& messagestubparameters(int index) const; - std::string* mutable_messagestubparameters(int index); - void set_messagestubparameters(int index, const std::string& value); - void set_messagestubparameters(int index, std::string&& value); - void set_messagestubparameters(int index, const char* value); - void set_messagestubparameters(int index, const char* value, size_t size); - std::string* add_messagestubparameters(); - void add_messagestubparameters(const std::string& value); - void add_messagestubparameters(std::string&& value); - void add_messagestubparameters(const char* value); - void add_messagestubparameters(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& messagestubparameters() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_messagestubparameters(); - private: - const std::string& _internal_messagestubparameters(int index) const; - std::string* _internal_add_messagestubparameters(); - public: - - // repeated string labels = 28; - int labels_size() const; - private: - int _internal_labels_size() const; - public: - void clear_labels(); - const std::string& labels(int index) const; - std::string* mutable_labels(int index); - void set_labels(int index, const std::string& value); - void set_labels(int index, std::string&& value); - void set_labels(int index, const char* value); - void set_labels(int index, const char* value, size_t size); - std::string* add_labels(); - void add_labels(const std::string& value); - void add_labels(std::string&& value); - void add_labels(const char* value); - void add_labels(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& labels() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_labels(); - private: - const std::string& _internal_labels(int index) const; - std::string* _internal_add_labels(); - public: - - // repeated .proto.UserReceipt userReceipt = 40; - int userreceipt_size() const; - private: - int _internal_userreceipt_size() const; - public: - void clear_userreceipt(); - ::proto::UserReceipt* mutable_userreceipt(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::UserReceipt >* - mutable_userreceipt(); - private: - const ::proto::UserReceipt& _internal_userreceipt(int index) const; - ::proto::UserReceipt* _internal_add_userreceipt(); - public: - const ::proto::UserReceipt& userreceipt(int index) const; - ::proto::UserReceipt* add_userreceipt(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::UserReceipt >& - userreceipt() const; - - // repeated .proto.Reaction reactions = 41; - int reactions_size() const; - private: - int _internal_reactions_size() const; - public: - void clear_reactions(); - ::proto::Reaction* mutable_reactions(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Reaction >* - mutable_reactions(); - private: - const ::proto::Reaction& _internal_reactions(int index) const; - ::proto::Reaction* _internal_add_reactions(); - public: - const ::proto::Reaction& reactions(int index) const; - ::proto::Reaction* add_reactions(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Reaction >& - reactions() const; - - // repeated .proto.PollUpdate pollUpdates = 45; - int pollupdates_size() const; - private: - int _internal_pollupdates_size() const; - public: - void clear_pollupdates(); - ::proto::PollUpdate* mutable_pollupdates(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PollUpdate >* - mutable_pollupdates(); - private: - const ::proto::PollUpdate& _internal_pollupdates(int index) const; - ::proto::PollUpdate* _internal_add_pollupdates(); - public: - const ::proto::PollUpdate& pollupdates(int index) const; - ::proto::PollUpdate* add_pollupdates(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PollUpdate >& - pollupdates() const; - - // optional string participant = 5; - bool has_participant() const; - private: - bool _internal_has_participant() const; - public: - void clear_participant(); - const std::string& participant() const; - template - void set_participant(ArgT0&& arg0, ArgT... args); - std::string* mutable_participant(); - PROTOBUF_NODISCARD std::string* release_participant(); - void set_allocated_participant(std::string* participant); - private: - const std::string& _internal_participant() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_participant(const std::string& value); - std::string* _internal_mutable_participant(); - public: - - // optional string pushName = 19; - bool has_pushname() const; - private: - bool _internal_has_pushname() const; - public: - void clear_pushname(); - const std::string& pushname() const; - template - void set_pushname(ArgT0&& arg0, ArgT... args); - std::string* mutable_pushname(); - PROTOBUF_NODISCARD std::string* release_pushname(); - void set_allocated_pushname(std::string* pushname); - private: - const std::string& _internal_pushname() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_pushname(const std::string& value); - std::string* _internal_mutable_pushname(); - public: - - // optional bytes mediaCiphertextSha256 = 20; - bool has_mediaciphertextsha256() const; - private: - bool _internal_has_mediaciphertextsha256() const; - public: - void clear_mediaciphertextsha256(); - const std::string& mediaciphertextsha256() const; - template - void set_mediaciphertextsha256(ArgT0&& arg0, ArgT... args); - std::string* mutable_mediaciphertextsha256(); - PROTOBUF_NODISCARD std::string* release_mediaciphertextsha256(); - void set_allocated_mediaciphertextsha256(std::string* mediaciphertextsha256); - private: - const std::string& _internal_mediaciphertextsha256() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediaciphertextsha256(const std::string& value); - std::string* _internal_mutable_mediaciphertextsha256(); - public: - - // optional string verifiedBizName = 37; - bool has_verifiedbizname() const; - private: - bool _internal_has_verifiedbizname() const; - public: - void clear_verifiedbizname(); - const std::string& verifiedbizname() const; - template - void set_verifiedbizname(ArgT0&& arg0, ArgT... args); - std::string* mutable_verifiedbizname(); - PROTOBUF_NODISCARD std::string* release_verifiedbizname(); - void set_allocated_verifiedbizname(std::string* verifiedbizname); - private: - const std::string& _internal_verifiedbizname() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_verifiedbizname(const std::string& value); - std::string* _internal_mutable_verifiedbizname(); - public: - - // optional bytes futureproofData = 43; - bool has_futureproofdata() const; - private: - bool _internal_has_futureproofdata() const; - public: - void clear_futureproofdata(); - const std::string& futureproofdata() const; - template - void set_futureproofdata(ArgT0&& arg0, ArgT... args); - std::string* mutable_futureproofdata(); - PROTOBUF_NODISCARD std::string* release_futureproofdata(); - void set_allocated_futureproofdata(std::string* futureproofdata); - private: - const std::string& _internal_futureproofdata() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_futureproofdata(const std::string& value); - std::string* _internal_mutable_futureproofdata(); - public: - - // optional string agentId = 47; - bool has_agentid() const; - private: - bool _internal_has_agentid() const; - public: - void clear_agentid(); - const std::string& agentid() const; - template - void set_agentid(ArgT0&& arg0, ArgT... args); - std::string* mutable_agentid(); - PROTOBUF_NODISCARD std::string* release_agentid(); - void set_allocated_agentid(std::string* agentid); - private: - const std::string& _internal_agentid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_agentid(const std::string& value); - std::string* _internal_mutable_agentid(); - public: - - // optional bytes messageSecret = 49; - bool has_messagesecret() const; - private: - bool _internal_has_messagesecret() const; - public: - void clear_messagesecret(); - const std::string& messagesecret() const; - template - void set_messagesecret(ArgT0&& arg0, ArgT... args); - std::string* mutable_messagesecret(); - PROTOBUF_NODISCARD std::string* release_messagesecret(); - void set_allocated_messagesecret(std::string* messagesecret); - private: - const std::string& _internal_messagesecret() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_messagesecret(const std::string& value); - std::string* _internal_mutable_messagesecret(); - public: - - // optional string originalSelfAuthorUserJidString = 51; - bool has_originalselfauthoruserjidstring() const; - private: - bool _internal_has_originalselfauthoruserjidstring() const; - public: - void clear_originalselfauthoruserjidstring(); - const std::string& originalselfauthoruserjidstring() const; - template - void set_originalselfauthoruserjidstring(ArgT0&& arg0, ArgT... args); - std::string* mutable_originalselfauthoruserjidstring(); - PROTOBUF_NODISCARD std::string* release_originalselfauthoruserjidstring(); - void set_allocated_originalselfauthoruserjidstring(std::string* originalselfauthoruserjidstring); - private: - const std::string& _internal_originalselfauthoruserjidstring() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_originalselfauthoruserjidstring(const std::string& value); - std::string* _internal_mutable_originalselfauthoruserjidstring(); - public: - - // required .proto.MessageKey key = 1; - bool has_key() const; - private: - bool _internal_has_key() const; - public: - void clear_key(); - const ::proto::MessageKey& key() const; - PROTOBUF_NODISCARD ::proto::MessageKey* release_key(); - ::proto::MessageKey* mutable_key(); - void set_allocated_key(::proto::MessageKey* key); - private: - const ::proto::MessageKey& _internal_key() const; - ::proto::MessageKey* _internal_mutable_key(); - public: - void unsafe_arena_set_allocated_key( - ::proto::MessageKey* key); - ::proto::MessageKey* unsafe_arena_release_key(); - - // optional .proto.Message message = 2; - bool has_message() const; - private: - bool _internal_has_message() const; - public: - void clear_message(); - const ::proto::Message& message() const; - PROTOBUF_NODISCARD ::proto::Message* release_message(); - ::proto::Message* mutable_message(); - void set_allocated_message(::proto::Message* message); - private: - const ::proto::Message& _internal_message() const; - ::proto::Message* _internal_mutable_message(); - public: - void unsafe_arena_set_allocated_message( - ::proto::Message* message); - ::proto::Message* unsafe_arena_release_message(); - - // optional .proto.PaymentInfo paymentInfo = 29; - bool has_paymentinfo() const; - private: - bool _internal_has_paymentinfo() const; - public: - void clear_paymentinfo(); - const ::proto::PaymentInfo& paymentinfo() const; - PROTOBUF_NODISCARD ::proto::PaymentInfo* release_paymentinfo(); - ::proto::PaymentInfo* mutable_paymentinfo(); - void set_allocated_paymentinfo(::proto::PaymentInfo* paymentinfo); - private: - const ::proto::PaymentInfo& _internal_paymentinfo() const; - ::proto::PaymentInfo* _internal_mutable_paymentinfo(); - public: - void unsafe_arena_set_allocated_paymentinfo( - ::proto::PaymentInfo* paymentinfo); - ::proto::PaymentInfo* unsafe_arena_release_paymentinfo(); - - // optional .proto.Message.LiveLocationMessage finalLiveLocation = 30; - bool has_finallivelocation() const; - private: - bool _internal_has_finallivelocation() const; - public: - void clear_finallivelocation(); - const ::proto::Message_LiveLocationMessage& finallivelocation() const; - PROTOBUF_NODISCARD ::proto::Message_LiveLocationMessage* release_finallivelocation(); - ::proto::Message_LiveLocationMessage* mutable_finallivelocation(); - void set_allocated_finallivelocation(::proto::Message_LiveLocationMessage* finallivelocation); - private: - const ::proto::Message_LiveLocationMessage& _internal_finallivelocation() const; - ::proto::Message_LiveLocationMessage* _internal_mutable_finallivelocation(); - public: - void unsafe_arena_set_allocated_finallivelocation( - ::proto::Message_LiveLocationMessage* finallivelocation); - ::proto::Message_LiveLocationMessage* unsafe_arena_release_finallivelocation(); - - // optional .proto.PaymentInfo quotedPaymentInfo = 31; - bool has_quotedpaymentinfo() const; - private: - bool _internal_has_quotedpaymentinfo() const; - public: - void clear_quotedpaymentinfo(); - const ::proto::PaymentInfo& quotedpaymentinfo() const; - PROTOBUF_NODISCARD ::proto::PaymentInfo* release_quotedpaymentinfo(); - ::proto::PaymentInfo* mutable_quotedpaymentinfo(); - void set_allocated_quotedpaymentinfo(::proto::PaymentInfo* quotedpaymentinfo); - private: - const ::proto::PaymentInfo& _internal_quotedpaymentinfo() const; - ::proto::PaymentInfo* _internal_mutable_quotedpaymentinfo(); - public: - void unsafe_arena_set_allocated_quotedpaymentinfo( - ::proto::PaymentInfo* quotedpaymentinfo); - ::proto::PaymentInfo* unsafe_arena_release_quotedpaymentinfo(); - - // optional .proto.MediaData mediaData = 38; - bool has_mediadata() const; - private: - bool _internal_has_mediadata() const; - public: - void clear_mediadata(); - const ::proto::MediaData& mediadata() const; - PROTOBUF_NODISCARD ::proto::MediaData* release_mediadata(); - ::proto::MediaData* mutable_mediadata(); - void set_allocated_mediadata(::proto::MediaData* mediadata); - private: - const ::proto::MediaData& _internal_mediadata() const; - ::proto::MediaData* _internal_mutable_mediadata(); - public: - void unsafe_arena_set_allocated_mediadata( - ::proto::MediaData* mediadata); - ::proto::MediaData* unsafe_arena_release_mediadata(); - - // optional .proto.PhotoChange photoChange = 39; - bool has_photochange() const; - private: - bool _internal_has_photochange() const; - public: - void clear_photochange(); - const ::proto::PhotoChange& photochange() const; - PROTOBUF_NODISCARD ::proto::PhotoChange* release_photochange(); - ::proto::PhotoChange* mutable_photochange(); - void set_allocated_photochange(::proto::PhotoChange* photochange); - private: - const ::proto::PhotoChange& _internal_photochange() const; - ::proto::PhotoChange* _internal_mutable_photochange(); - public: - void unsafe_arena_set_allocated_photochange( - ::proto::PhotoChange* photochange); - ::proto::PhotoChange* unsafe_arena_release_photochange(); - - // optional .proto.MediaData quotedStickerData = 42; - bool has_quotedstickerdata() const; - private: - bool _internal_has_quotedstickerdata() const; - public: - void clear_quotedstickerdata(); - const ::proto::MediaData& quotedstickerdata() const; - PROTOBUF_NODISCARD ::proto::MediaData* release_quotedstickerdata(); - ::proto::MediaData* mutable_quotedstickerdata(); - void set_allocated_quotedstickerdata(::proto::MediaData* quotedstickerdata); - private: - const ::proto::MediaData& _internal_quotedstickerdata() const; - ::proto::MediaData* _internal_mutable_quotedstickerdata(); - public: - void unsafe_arena_set_allocated_quotedstickerdata( - ::proto::MediaData* quotedstickerdata); - ::proto::MediaData* unsafe_arena_release_quotedstickerdata(); - - // optional .proto.StatusPSA statusPsa = 44; - bool has_statuspsa() const; - private: - bool _internal_has_statuspsa() const; - public: - void clear_statuspsa(); - const ::proto::StatusPSA& statuspsa() const; - PROTOBUF_NODISCARD ::proto::StatusPSA* release_statuspsa(); - ::proto::StatusPSA* mutable_statuspsa(); - void set_allocated_statuspsa(::proto::StatusPSA* statuspsa); - private: - const ::proto::StatusPSA& _internal_statuspsa() const; - ::proto::StatusPSA* _internal_mutable_statuspsa(); - public: - void unsafe_arena_set_allocated_statuspsa( - ::proto::StatusPSA* statuspsa); - ::proto::StatusPSA* unsafe_arena_release_statuspsa(); - - // optional .proto.PollAdditionalMetadata pollAdditionalMetadata = 46; - bool has_polladditionalmetadata() const; - private: - bool _internal_has_polladditionalmetadata() const; - public: - void clear_polladditionalmetadata(); - const ::proto::PollAdditionalMetadata& polladditionalmetadata() const; - PROTOBUF_NODISCARD ::proto::PollAdditionalMetadata* release_polladditionalmetadata(); - ::proto::PollAdditionalMetadata* mutable_polladditionalmetadata(); - void set_allocated_polladditionalmetadata(::proto::PollAdditionalMetadata* polladditionalmetadata); - private: - const ::proto::PollAdditionalMetadata& _internal_polladditionalmetadata() const; - ::proto::PollAdditionalMetadata* _internal_mutable_polladditionalmetadata(); - public: - void unsafe_arena_set_allocated_polladditionalmetadata( - ::proto::PollAdditionalMetadata* polladditionalmetadata); - ::proto::PollAdditionalMetadata* unsafe_arena_release_polladditionalmetadata(); - - // optional .proto.KeepInChat keepInChat = 50; - bool has_keepinchat() const; - private: - bool _internal_has_keepinchat() const; - public: - void clear_keepinchat(); - const ::proto::KeepInChat& keepinchat() const; - PROTOBUF_NODISCARD ::proto::KeepInChat* release_keepinchat(); - ::proto::KeepInChat* mutable_keepinchat(); - void set_allocated_keepinchat(::proto::KeepInChat* keepinchat); - private: - const ::proto::KeepInChat& _internal_keepinchat() const; - ::proto::KeepInChat* _internal_mutable_keepinchat(); - public: - void unsafe_arena_set_allocated_keepinchat( - ::proto::KeepInChat* keepinchat); - ::proto::KeepInChat* unsafe_arena_release_keepinchat(); - - // optional uint64 messageTimestamp = 3; - bool has_messagetimestamp() const; - private: - bool _internal_has_messagetimestamp() const; - public: - void clear_messagetimestamp(); - uint64_t messagetimestamp() const; - void set_messagetimestamp(uint64_t value); - private: - uint64_t _internal_messagetimestamp() const; - void _internal_set_messagetimestamp(uint64_t value); - public: - - // optional uint64 messageC2STimestamp = 6; - bool has_messagec2stimestamp() const; - private: - bool _internal_has_messagec2stimestamp() const; - public: - void clear_messagec2stimestamp(); - uint64_t messagec2stimestamp() const; - void set_messagec2stimestamp(uint64_t value); - private: - uint64_t _internal_messagec2stimestamp() const; - void _internal_set_messagec2stimestamp(uint64_t value); - public: - - // optional .proto.WebMessageInfo.Status status = 4; - bool has_status() const; - private: - bool _internal_has_status() const; - public: - void clear_status(); - ::proto::WebMessageInfo_Status status() const; - void set_status(::proto::WebMessageInfo_Status value); - private: - ::proto::WebMessageInfo_Status _internal_status() const; - void _internal_set_status(::proto::WebMessageInfo_Status value); - public: - - // optional bool ignore = 16; - bool has_ignore() const; - private: - bool _internal_has_ignore() const; - public: - void clear_ignore(); - bool ignore() const; - void set_ignore(bool value); - private: - bool _internal_ignore() const; - void _internal_set_ignore(bool value); - public: - - // optional bool starred = 17; - bool has_starred() const; - private: - bool _internal_has_starred() const; - public: - void clear_starred(); - bool starred() const; - void set_starred(bool value); - private: - bool _internal_starred() const; - void _internal_set_starred(bool value); - public: - - // optional bool broadcast = 18; - bool has_broadcast() const; - private: - bool _internal_has_broadcast() const; - public: - void clear_broadcast(); - bool broadcast() const; - void set_broadcast(bool value); - private: - bool _internal_broadcast() const; - void _internal_set_broadcast(bool value); - public: - - // optional bool multicast = 21; - bool has_multicast() const; - private: - bool _internal_has_multicast() const; - public: - void clear_multicast(); - bool multicast() const; - void set_multicast(bool value); - private: - bool _internal_multicast() const; - void _internal_set_multicast(bool value); - public: - - // optional .proto.WebMessageInfo.StubType messageStubType = 24; - bool has_messagestubtype() const; - private: - bool _internal_has_messagestubtype() const; - public: - void clear_messagestubtype(); - ::proto::WebMessageInfo_StubType messagestubtype() const; - void set_messagestubtype(::proto::WebMessageInfo_StubType value); - private: - ::proto::WebMessageInfo_StubType _internal_messagestubtype() const; - void _internal_set_messagestubtype(::proto::WebMessageInfo_StubType value); - public: - - // optional bool urlText = 22; - bool has_urltext() const; - private: - bool _internal_has_urltext() const; - public: - void clear_urltext(); - bool urltext() const; - void set_urltext(bool value); - private: - bool _internal_urltext() const; - void _internal_set_urltext(bool value); - public: - - // optional bool urlNumber = 23; - bool has_urlnumber() const; - private: - bool _internal_has_urlnumber() const; - public: - void clear_urlnumber(); - bool urlnumber() const; - void set_urlnumber(bool value); - private: - bool _internal_urlnumber() const; - void _internal_set_urlnumber(bool value); - public: - - // optional bool clearMedia = 25; - bool has_clearmedia() const; - private: - bool _internal_has_clearmedia() const; - public: - void clear_clearmedia(); - bool clearmedia() const; - void set_clearmedia(bool value); - private: - bool _internal_clearmedia() const; - void _internal_set_clearmedia(bool value); - public: - - // optional bool ephemeralOffToOn = 34; - bool has_ephemeralofftoon() const; - private: - bool _internal_has_ephemeralofftoon() const; - public: - void clear_ephemeralofftoon(); - bool ephemeralofftoon() const; - void set_ephemeralofftoon(bool value); - private: - bool _internal_ephemeralofftoon() const; - void _internal_set_ephemeralofftoon(bool value); - public: - - // optional uint32 duration = 27; - bool has_duration() const; - private: - bool _internal_has_duration() const; - public: - void clear_duration(); - uint32_t duration() const; - void set_duration(uint32_t value); - private: - uint32_t _internal_duration() const; - void _internal_set_duration(uint32_t value); - public: - - // optional uint32 ephemeralDuration = 33; - bool has_ephemeralduration() const; - private: - bool _internal_has_ephemeralduration() const; - public: - void clear_ephemeralduration(); - uint32_t ephemeralduration() const; - void set_ephemeralduration(uint32_t value); - private: - uint32_t _internal_ephemeralduration() const; - void _internal_set_ephemeralduration(uint32_t value); - public: - - // optional uint64 ephemeralStartTimestamp = 32; - bool has_ephemeralstarttimestamp() const; - private: - bool _internal_has_ephemeralstarttimestamp() const; - public: - void clear_ephemeralstarttimestamp(); - uint64_t ephemeralstarttimestamp() const; - void set_ephemeralstarttimestamp(uint64_t value); - private: - uint64_t _internal_ephemeralstarttimestamp() const; - void _internal_set_ephemeralstarttimestamp(uint64_t value); - public: - - // optional .proto.WebMessageInfo.BizPrivacyStatus bizPrivacyStatus = 36; - bool has_bizprivacystatus() const; - private: - bool _internal_has_bizprivacystatus() const; - public: - void clear_bizprivacystatus(); - ::proto::WebMessageInfo_BizPrivacyStatus bizprivacystatus() const; - void set_bizprivacystatus(::proto::WebMessageInfo_BizPrivacyStatus value); - private: - ::proto::WebMessageInfo_BizPrivacyStatus _internal_bizprivacystatus() const; - void _internal_set_bizprivacystatus(::proto::WebMessageInfo_BizPrivacyStatus value); - public: - - // optional bool ephemeralOutOfSync = 35; - bool has_ephemeraloutofsync() const; - private: - bool _internal_has_ephemeraloutofsync() const; - public: - void clear_ephemeraloutofsync(); - bool ephemeraloutofsync() const; - void set_ephemeraloutofsync(bool value); - private: - bool _internal_ephemeraloutofsync() const; - void _internal_set_ephemeraloutofsync(bool value); - public: - - // optional bool statusAlreadyViewed = 48; - bool has_statusalreadyviewed() const; - private: - bool _internal_has_statusalreadyviewed() const; - public: - void clear_statusalreadyviewed(); - bool statusalreadyviewed() const; - void set_statusalreadyviewed(bool value); - private: - bool _internal_statusalreadyviewed() const; - void _internal_set_statusalreadyviewed(bool value); - public: - - // optional uint64 revokeMessageTimestamp = 52; - bool has_revokemessagetimestamp() const; - private: - bool _internal_has_revokemessagetimestamp() const; - public: - void clear_revokemessagetimestamp(); - uint64_t revokemessagetimestamp() const; - void set_revokemessagetimestamp(uint64_t value); - private: - uint64_t _internal_revokemessagetimestamp() const; - void _internal_set_revokemessagetimestamp(uint64_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.WebMessageInfo) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<2> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField messagestubparameters_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField labels_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::UserReceipt > userreceipt_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Reaction > reactions_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PollUpdate > pollupdates_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr participant_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pushname_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediaciphertextsha256_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr verifiedbizname_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr futureproofdata_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr agentid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr messagesecret_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr originalselfauthoruserjidstring_; - ::proto::MessageKey* key_; - ::proto::Message* message_; - ::proto::PaymentInfo* paymentinfo_; - ::proto::Message_LiveLocationMessage* finallivelocation_; - ::proto::PaymentInfo* quotedpaymentinfo_; - ::proto::MediaData* mediadata_; - ::proto::PhotoChange* photochange_; - ::proto::MediaData* quotedstickerdata_; - ::proto::StatusPSA* statuspsa_; - ::proto::PollAdditionalMetadata* polladditionalmetadata_; - ::proto::KeepInChat* keepinchat_; - uint64_t messagetimestamp_; - uint64_t messagec2stimestamp_; - int status_; - bool ignore_; - bool starred_; - bool broadcast_; - bool multicast_; - int messagestubtype_; - bool urltext_; - bool urlnumber_; - bool clearmedia_; - bool ephemeralofftoon_; - uint32_t duration_; - uint32_t ephemeralduration_; - uint64_t ephemeralstarttimestamp_; - int bizprivacystatus_; - bool ephemeraloutofsync_; - bool statusalreadyviewed_; - uint64_t revokemessagetimestamp_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// ------------------------------------------------------------------- - -class WebNotificationsInfo final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.WebNotificationsInfo) */ { - public: - inline WebNotificationsInfo() : WebNotificationsInfo(nullptr) {} - ~WebNotificationsInfo() override; - explicit PROTOBUF_CONSTEXPR WebNotificationsInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - WebNotificationsInfo(const WebNotificationsInfo& from); - WebNotificationsInfo(WebNotificationsInfo&& from) noexcept - : WebNotificationsInfo() { - *this = ::std::move(from); - } - - inline WebNotificationsInfo& operator=(const WebNotificationsInfo& from) { - CopyFrom(from); - return *this; - } - inline WebNotificationsInfo& operator=(WebNotificationsInfo&& from) noexcept { - if (this == &from) return *this; - if (GetOwningArena() == from.GetOwningArena() - #ifdef PROTOBUF_FORCE_COPY_IN_MOVE - && GetOwningArena() != nullptr - #endif // !PROTOBUF_FORCE_COPY_IN_MOVE - ) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { - return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); - } - inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { - return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); - } - - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { - return GetDescriptor(); - } - static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const WebNotificationsInfo& default_instance() { - return *internal_default_instance(); - } - static inline const WebNotificationsInfo* internal_default_instance() { - return reinterpret_cast( - &_WebNotificationsInfo_default_instance_); - } - static constexpr int kIndexInFileMessages = - 223; - - friend void swap(WebNotificationsInfo& a, WebNotificationsInfo& b) { - a.Swap(&b); - } - inline void Swap(WebNotificationsInfo* other) { - if (other == this) return; - #ifdef PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() != nullptr && - GetOwningArena() == other->GetOwningArena()) { - #else // PROTOBUF_FORCE_COPY_IN_SWAP - if (GetOwningArena() == other->GetOwningArena()) { - #endif // !PROTOBUF_FORCE_COPY_IN_SWAP - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(WebNotificationsInfo* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - WebNotificationsInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const WebNotificationsInfo& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom( const WebNotificationsInfo& from) { - WebNotificationsInfo::MergeImpl(*this, from); - } - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); - public: - PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; - bool IsInitialized() const final; - - size_t ByteSizeLong() const final; - const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; - uint8_t* _InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(WebNotificationsInfo* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "proto.WebNotificationsInfo"; - } - protected: - explicit WebNotificationsInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kNotifyMessagesFieldNumber = 5, - kTimestampFieldNumber = 2, - kUnreadChatsFieldNumber = 3, - kNotifyMessageCountFieldNumber = 4, - }; - // repeated .proto.WebMessageInfo notifyMessages = 5; - int notifymessages_size() const; - private: - int _internal_notifymessages_size() const; - public: - void clear_notifymessages(); - ::proto::WebMessageInfo* mutable_notifymessages(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >* - mutable_notifymessages(); - private: - const ::proto::WebMessageInfo& _internal_notifymessages(int index) const; - ::proto::WebMessageInfo* _internal_add_notifymessages(); - public: - const ::proto::WebMessageInfo& notifymessages(int index) const; - ::proto::WebMessageInfo* add_notifymessages(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >& - notifymessages() const; - - // optional uint64 timestamp = 2; - bool has_timestamp() const; - private: - bool _internal_has_timestamp() const; - public: - void clear_timestamp(); - uint64_t timestamp() const; - void set_timestamp(uint64_t value); - private: - uint64_t _internal_timestamp() const; - void _internal_set_timestamp(uint64_t value); - public: - - // optional uint32 unreadChats = 3; - bool has_unreadchats() const; - private: - bool _internal_has_unreadchats() const; - public: - void clear_unreadchats(); - uint32_t unreadchats() const; - void set_unreadchats(uint32_t value); - private: - uint32_t _internal_unreadchats() const; - void _internal_set_unreadchats(uint32_t value); - public: - - // optional uint32 notifyMessageCount = 4; - bool has_notifymessagecount() const; - private: - bool _internal_has_notifymessagecount() const; - public: - void clear_notifymessagecount(); - uint32_t notifymessagecount() const; - void set_notifymessagecount(uint32_t value); - private: - uint32_t _internal_notifymessagecount() const; - void _internal_set_notifymessagecount(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:proto.WebNotificationsInfo) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - struct Impl_ { - ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo > notifymessages_; - uint64_t timestamp_; - uint32_t unreadchats_; - uint32_t notifymessagecount_; - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_pmsg_2eproto; -}; -// =================================================================== - - -// =================================================================== - -#ifdef __GNUC__ - #pragma GCC diagnostic push - #pragma GCC diagnostic ignored "-Wstrict-aliasing" -#endif // __GNUC__ -// ADVDeviceIdentity - -// optional uint32 rawId = 1; -inline bool ADVDeviceIdentity::_internal_has_rawid() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool ADVDeviceIdentity::has_rawid() const { - return _internal_has_rawid(); -} -inline void ADVDeviceIdentity::clear_rawid() { - _impl_.rawid_ = 0u; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline uint32_t ADVDeviceIdentity::_internal_rawid() const { - return _impl_.rawid_; -} -inline uint32_t ADVDeviceIdentity::rawid() const { - // @@protoc_insertion_point(field_get:proto.ADVDeviceIdentity.rawId) - return _internal_rawid(); -} -inline void ADVDeviceIdentity::_internal_set_rawid(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.rawid_ = value; -} -inline void ADVDeviceIdentity::set_rawid(uint32_t value) { - _internal_set_rawid(value); - // @@protoc_insertion_point(field_set:proto.ADVDeviceIdentity.rawId) -} - -// optional uint64 timestamp = 2; -inline bool ADVDeviceIdentity::_internal_has_timestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool ADVDeviceIdentity::has_timestamp() const { - return _internal_has_timestamp(); -} -inline void ADVDeviceIdentity::clear_timestamp() { - _impl_.timestamp_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline uint64_t ADVDeviceIdentity::_internal_timestamp() const { - return _impl_.timestamp_; -} -inline uint64_t ADVDeviceIdentity::timestamp() const { - // @@protoc_insertion_point(field_get:proto.ADVDeviceIdentity.timestamp) - return _internal_timestamp(); -} -inline void ADVDeviceIdentity::_internal_set_timestamp(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.timestamp_ = value; -} -inline void ADVDeviceIdentity::set_timestamp(uint64_t value) { - _internal_set_timestamp(value); - // @@protoc_insertion_point(field_set:proto.ADVDeviceIdentity.timestamp) -} - -// optional uint32 keyIndex = 3; -inline bool ADVDeviceIdentity::_internal_has_keyindex() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool ADVDeviceIdentity::has_keyindex() const { - return _internal_has_keyindex(); -} -inline void ADVDeviceIdentity::clear_keyindex() { - _impl_.keyindex_ = 0u; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline uint32_t ADVDeviceIdentity::_internal_keyindex() const { - return _impl_.keyindex_; -} -inline uint32_t ADVDeviceIdentity::keyindex() const { - // @@protoc_insertion_point(field_get:proto.ADVDeviceIdentity.keyIndex) - return _internal_keyindex(); -} -inline void ADVDeviceIdentity::_internal_set_keyindex(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.keyindex_ = value; -} -inline void ADVDeviceIdentity::set_keyindex(uint32_t value) { - _internal_set_keyindex(value); - // @@protoc_insertion_point(field_set:proto.ADVDeviceIdentity.keyIndex) -} - -// ------------------------------------------------------------------- - -// ADVKeyIndexList - -// optional uint32 rawId = 1; -inline bool ADVKeyIndexList::_internal_has_rawid() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool ADVKeyIndexList::has_rawid() const { - return _internal_has_rawid(); -} -inline void ADVKeyIndexList::clear_rawid() { - _impl_.rawid_ = 0u; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline uint32_t ADVKeyIndexList::_internal_rawid() const { - return _impl_.rawid_; -} -inline uint32_t ADVKeyIndexList::rawid() const { - // @@protoc_insertion_point(field_get:proto.ADVKeyIndexList.rawId) - return _internal_rawid(); -} -inline void ADVKeyIndexList::_internal_set_rawid(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.rawid_ = value; -} -inline void ADVKeyIndexList::set_rawid(uint32_t value) { - _internal_set_rawid(value); - // @@protoc_insertion_point(field_set:proto.ADVKeyIndexList.rawId) -} - -// optional uint64 timestamp = 2; -inline bool ADVKeyIndexList::_internal_has_timestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool ADVKeyIndexList::has_timestamp() const { - return _internal_has_timestamp(); -} -inline void ADVKeyIndexList::clear_timestamp() { - _impl_.timestamp_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline uint64_t ADVKeyIndexList::_internal_timestamp() const { - return _impl_.timestamp_; -} -inline uint64_t ADVKeyIndexList::timestamp() const { - // @@protoc_insertion_point(field_get:proto.ADVKeyIndexList.timestamp) - return _internal_timestamp(); -} -inline void ADVKeyIndexList::_internal_set_timestamp(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.timestamp_ = value; -} -inline void ADVKeyIndexList::set_timestamp(uint64_t value) { - _internal_set_timestamp(value); - // @@protoc_insertion_point(field_set:proto.ADVKeyIndexList.timestamp) -} - -// optional uint32 currentIndex = 3; -inline bool ADVKeyIndexList::_internal_has_currentindex() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool ADVKeyIndexList::has_currentindex() const { - return _internal_has_currentindex(); -} -inline void ADVKeyIndexList::clear_currentindex() { - _impl_.currentindex_ = 0u; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline uint32_t ADVKeyIndexList::_internal_currentindex() const { - return _impl_.currentindex_; -} -inline uint32_t ADVKeyIndexList::currentindex() const { - // @@protoc_insertion_point(field_get:proto.ADVKeyIndexList.currentIndex) - return _internal_currentindex(); -} -inline void ADVKeyIndexList::_internal_set_currentindex(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.currentindex_ = value; -} -inline void ADVKeyIndexList::set_currentindex(uint32_t value) { - _internal_set_currentindex(value); - // @@protoc_insertion_point(field_set:proto.ADVKeyIndexList.currentIndex) -} - -// repeated uint32 validIndexes = 4 [packed = true]; -inline int ADVKeyIndexList::_internal_validindexes_size() const { - return _impl_.validindexes_.size(); -} -inline int ADVKeyIndexList::validindexes_size() const { - return _internal_validindexes_size(); -} -inline void ADVKeyIndexList::clear_validindexes() { - _impl_.validindexes_.Clear(); -} -inline uint32_t ADVKeyIndexList::_internal_validindexes(int index) const { - return _impl_.validindexes_.Get(index); -} -inline uint32_t ADVKeyIndexList::validindexes(int index) const { - // @@protoc_insertion_point(field_get:proto.ADVKeyIndexList.validIndexes) - return _internal_validindexes(index); -} -inline void ADVKeyIndexList::set_validindexes(int index, uint32_t value) { - _impl_.validindexes_.Set(index, value); - // @@protoc_insertion_point(field_set:proto.ADVKeyIndexList.validIndexes) -} -inline void ADVKeyIndexList::_internal_add_validindexes(uint32_t value) { - _impl_.validindexes_.Add(value); -} -inline void ADVKeyIndexList::add_validindexes(uint32_t value) { - _internal_add_validindexes(value); - // @@protoc_insertion_point(field_add:proto.ADVKeyIndexList.validIndexes) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& -ADVKeyIndexList::_internal_validindexes() const { - return _impl_.validindexes_; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& -ADVKeyIndexList::validindexes() const { - // @@protoc_insertion_point(field_list:proto.ADVKeyIndexList.validIndexes) - return _internal_validindexes(); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* -ADVKeyIndexList::_internal_mutable_validindexes() { - return &_impl_.validindexes_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* -ADVKeyIndexList::mutable_validindexes() { - // @@protoc_insertion_point(field_mutable_list:proto.ADVKeyIndexList.validIndexes) - return _internal_mutable_validindexes(); -} - -// ------------------------------------------------------------------- - -// ADVSignedDeviceIdentity - -// optional bytes details = 1; -inline bool ADVSignedDeviceIdentity::_internal_has_details() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool ADVSignedDeviceIdentity::has_details() const { - return _internal_has_details(); -} -inline void ADVSignedDeviceIdentity::clear_details() { - _impl_.details_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& ADVSignedDeviceIdentity::details() const { - // @@protoc_insertion_point(field_get:proto.ADVSignedDeviceIdentity.details) - return _internal_details(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ADVSignedDeviceIdentity::set_details(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.details_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ADVSignedDeviceIdentity.details) -} -inline std::string* ADVSignedDeviceIdentity::mutable_details() { - std::string* _s = _internal_mutable_details(); - // @@protoc_insertion_point(field_mutable:proto.ADVSignedDeviceIdentity.details) - return _s; -} -inline const std::string& ADVSignedDeviceIdentity::_internal_details() const { - return _impl_.details_.Get(); -} -inline void ADVSignedDeviceIdentity::_internal_set_details(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.details_.Set(value, GetArenaForAllocation()); -} -inline std::string* ADVSignedDeviceIdentity::_internal_mutable_details() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.details_.Mutable(GetArenaForAllocation()); -} -inline std::string* ADVSignedDeviceIdentity::release_details() { - // @@protoc_insertion_point(field_release:proto.ADVSignedDeviceIdentity.details) - if (!_internal_has_details()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.details_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.details_.IsDefault()) { - _impl_.details_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ADVSignedDeviceIdentity::set_allocated_details(std::string* details) { - if (details != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.details_.SetAllocated(details, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.details_.IsDefault()) { - _impl_.details_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedDeviceIdentity.details) -} - -// optional bytes accountSignatureKey = 2; -inline bool ADVSignedDeviceIdentity::_internal_has_accountsignaturekey() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool ADVSignedDeviceIdentity::has_accountsignaturekey() const { - return _internal_has_accountsignaturekey(); -} -inline void ADVSignedDeviceIdentity::clear_accountsignaturekey() { - _impl_.accountsignaturekey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& ADVSignedDeviceIdentity::accountsignaturekey() const { - // @@protoc_insertion_point(field_get:proto.ADVSignedDeviceIdentity.accountSignatureKey) - return _internal_accountsignaturekey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ADVSignedDeviceIdentity::set_accountsignaturekey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.accountsignaturekey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ADVSignedDeviceIdentity.accountSignatureKey) -} -inline std::string* ADVSignedDeviceIdentity::mutable_accountsignaturekey() { - std::string* _s = _internal_mutable_accountsignaturekey(); - // @@protoc_insertion_point(field_mutable:proto.ADVSignedDeviceIdentity.accountSignatureKey) - return _s; -} -inline const std::string& ADVSignedDeviceIdentity::_internal_accountsignaturekey() const { - return _impl_.accountsignaturekey_.Get(); -} -inline void ADVSignedDeviceIdentity::_internal_set_accountsignaturekey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.accountsignaturekey_.Set(value, GetArenaForAllocation()); -} -inline std::string* ADVSignedDeviceIdentity::_internal_mutable_accountsignaturekey() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.accountsignaturekey_.Mutable(GetArenaForAllocation()); -} -inline std::string* ADVSignedDeviceIdentity::release_accountsignaturekey() { - // @@protoc_insertion_point(field_release:proto.ADVSignedDeviceIdentity.accountSignatureKey) - if (!_internal_has_accountsignaturekey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.accountsignaturekey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.accountsignaturekey_.IsDefault()) { - _impl_.accountsignaturekey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ADVSignedDeviceIdentity::set_allocated_accountsignaturekey(std::string* accountsignaturekey) { - if (accountsignaturekey != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.accountsignaturekey_.SetAllocated(accountsignaturekey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.accountsignaturekey_.IsDefault()) { - _impl_.accountsignaturekey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedDeviceIdentity.accountSignatureKey) -} - -// optional bytes accountSignature = 3; -inline bool ADVSignedDeviceIdentity::_internal_has_accountsignature() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool ADVSignedDeviceIdentity::has_accountsignature() const { - return _internal_has_accountsignature(); -} -inline void ADVSignedDeviceIdentity::clear_accountsignature() { - _impl_.accountsignature_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& ADVSignedDeviceIdentity::accountsignature() const { - // @@protoc_insertion_point(field_get:proto.ADVSignedDeviceIdentity.accountSignature) - return _internal_accountsignature(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ADVSignedDeviceIdentity::set_accountsignature(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.accountsignature_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ADVSignedDeviceIdentity.accountSignature) -} -inline std::string* ADVSignedDeviceIdentity::mutable_accountsignature() { - std::string* _s = _internal_mutable_accountsignature(); - // @@protoc_insertion_point(field_mutable:proto.ADVSignedDeviceIdentity.accountSignature) - return _s; -} -inline const std::string& ADVSignedDeviceIdentity::_internal_accountsignature() const { - return _impl_.accountsignature_.Get(); -} -inline void ADVSignedDeviceIdentity::_internal_set_accountsignature(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.accountsignature_.Set(value, GetArenaForAllocation()); -} -inline std::string* ADVSignedDeviceIdentity::_internal_mutable_accountsignature() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.accountsignature_.Mutable(GetArenaForAllocation()); -} -inline std::string* ADVSignedDeviceIdentity::release_accountsignature() { - // @@protoc_insertion_point(field_release:proto.ADVSignedDeviceIdentity.accountSignature) - if (!_internal_has_accountsignature()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.accountsignature_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.accountsignature_.IsDefault()) { - _impl_.accountsignature_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ADVSignedDeviceIdentity::set_allocated_accountsignature(std::string* accountsignature) { - if (accountsignature != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.accountsignature_.SetAllocated(accountsignature, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.accountsignature_.IsDefault()) { - _impl_.accountsignature_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedDeviceIdentity.accountSignature) -} - -// optional bytes deviceSignature = 4; -inline bool ADVSignedDeviceIdentity::_internal_has_devicesignature() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool ADVSignedDeviceIdentity::has_devicesignature() const { - return _internal_has_devicesignature(); -} -inline void ADVSignedDeviceIdentity::clear_devicesignature() { - _impl_.devicesignature_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const std::string& ADVSignedDeviceIdentity::devicesignature() const { - // @@protoc_insertion_point(field_get:proto.ADVSignedDeviceIdentity.deviceSignature) - return _internal_devicesignature(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ADVSignedDeviceIdentity::set_devicesignature(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.devicesignature_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ADVSignedDeviceIdentity.deviceSignature) -} -inline std::string* ADVSignedDeviceIdentity::mutable_devicesignature() { - std::string* _s = _internal_mutable_devicesignature(); - // @@protoc_insertion_point(field_mutable:proto.ADVSignedDeviceIdentity.deviceSignature) - return _s; -} -inline const std::string& ADVSignedDeviceIdentity::_internal_devicesignature() const { - return _impl_.devicesignature_.Get(); -} -inline void ADVSignedDeviceIdentity::_internal_set_devicesignature(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.devicesignature_.Set(value, GetArenaForAllocation()); -} -inline std::string* ADVSignedDeviceIdentity::_internal_mutable_devicesignature() { - _impl_._has_bits_[0] |= 0x00000008u; - return _impl_.devicesignature_.Mutable(GetArenaForAllocation()); -} -inline std::string* ADVSignedDeviceIdentity::release_devicesignature() { - // @@protoc_insertion_point(field_release:proto.ADVSignedDeviceIdentity.deviceSignature) - if (!_internal_has_devicesignature()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000008u; - auto* p = _impl_.devicesignature_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.devicesignature_.IsDefault()) { - _impl_.devicesignature_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ADVSignedDeviceIdentity::set_allocated_devicesignature(std::string* devicesignature) { - if (devicesignature != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.devicesignature_.SetAllocated(devicesignature, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.devicesignature_.IsDefault()) { - _impl_.devicesignature_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedDeviceIdentity.deviceSignature) -} - -// ------------------------------------------------------------------- - -// ADVSignedDeviceIdentityHMAC - -// optional bytes details = 1; -inline bool ADVSignedDeviceIdentityHMAC::_internal_has_details() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool ADVSignedDeviceIdentityHMAC::has_details() const { - return _internal_has_details(); -} -inline void ADVSignedDeviceIdentityHMAC::clear_details() { - _impl_.details_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& ADVSignedDeviceIdentityHMAC::details() const { - // @@protoc_insertion_point(field_get:proto.ADVSignedDeviceIdentityHMAC.details) - return _internal_details(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ADVSignedDeviceIdentityHMAC::set_details(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.details_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ADVSignedDeviceIdentityHMAC.details) -} -inline std::string* ADVSignedDeviceIdentityHMAC::mutable_details() { - std::string* _s = _internal_mutable_details(); - // @@protoc_insertion_point(field_mutable:proto.ADVSignedDeviceIdentityHMAC.details) - return _s; -} -inline const std::string& ADVSignedDeviceIdentityHMAC::_internal_details() const { - return _impl_.details_.Get(); -} -inline void ADVSignedDeviceIdentityHMAC::_internal_set_details(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.details_.Set(value, GetArenaForAllocation()); -} -inline std::string* ADVSignedDeviceIdentityHMAC::_internal_mutable_details() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.details_.Mutable(GetArenaForAllocation()); -} -inline std::string* ADVSignedDeviceIdentityHMAC::release_details() { - // @@protoc_insertion_point(field_release:proto.ADVSignedDeviceIdentityHMAC.details) - if (!_internal_has_details()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.details_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.details_.IsDefault()) { - _impl_.details_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ADVSignedDeviceIdentityHMAC::set_allocated_details(std::string* details) { - if (details != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.details_.SetAllocated(details, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.details_.IsDefault()) { - _impl_.details_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedDeviceIdentityHMAC.details) -} - -// optional bytes hmac = 2; -inline bool ADVSignedDeviceIdentityHMAC::_internal_has_hmac() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool ADVSignedDeviceIdentityHMAC::has_hmac() const { - return _internal_has_hmac(); -} -inline void ADVSignedDeviceIdentityHMAC::clear_hmac() { - _impl_.hmac_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& ADVSignedDeviceIdentityHMAC::hmac() const { - // @@protoc_insertion_point(field_get:proto.ADVSignedDeviceIdentityHMAC.hmac) - return _internal_hmac(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ADVSignedDeviceIdentityHMAC::set_hmac(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.hmac_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ADVSignedDeviceIdentityHMAC.hmac) -} -inline std::string* ADVSignedDeviceIdentityHMAC::mutable_hmac() { - std::string* _s = _internal_mutable_hmac(); - // @@protoc_insertion_point(field_mutable:proto.ADVSignedDeviceIdentityHMAC.hmac) - return _s; -} -inline const std::string& ADVSignedDeviceIdentityHMAC::_internal_hmac() const { - return _impl_.hmac_.Get(); -} -inline void ADVSignedDeviceIdentityHMAC::_internal_set_hmac(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.hmac_.Set(value, GetArenaForAllocation()); -} -inline std::string* ADVSignedDeviceIdentityHMAC::_internal_mutable_hmac() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.hmac_.Mutable(GetArenaForAllocation()); -} -inline std::string* ADVSignedDeviceIdentityHMAC::release_hmac() { - // @@protoc_insertion_point(field_release:proto.ADVSignedDeviceIdentityHMAC.hmac) - if (!_internal_has_hmac()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.hmac_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.hmac_.IsDefault()) { - _impl_.hmac_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ADVSignedDeviceIdentityHMAC::set_allocated_hmac(std::string* hmac) { - if (hmac != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.hmac_.SetAllocated(hmac, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.hmac_.IsDefault()) { - _impl_.hmac_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedDeviceIdentityHMAC.hmac) -} - -// ------------------------------------------------------------------- - -// ADVSignedKeyIndexList - -// optional bytes details = 1; -inline bool ADVSignedKeyIndexList::_internal_has_details() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool ADVSignedKeyIndexList::has_details() const { - return _internal_has_details(); -} -inline void ADVSignedKeyIndexList::clear_details() { - _impl_.details_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& ADVSignedKeyIndexList::details() const { - // @@protoc_insertion_point(field_get:proto.ADVSignedKeyIndexList.details) - return _internal_details(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ADVSignedKeyIndexList::set_details(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.details_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ADVSignedKeyIndexList.details) -} -inline std::string* ADVSignedKeyIndexList::mutable_details() { - std::string* _s = _internal_mutable_details(); - // @@protoc_insertion_point(field_mutable:proto.ADVSignedKeyIndexList.details) - return _s; -} -inline const std::string& ADVSignedKeyIndexList::_internal_details() const { - return _impl_.details_.Get(); -} -inline void ADVSignedKeyIndexList::_internal_set_details(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.details_.Set(value, GetArenaForAllocation()); -} -inline std::string* ADVSignedKeyIndexList::_internal_mutable_details() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.details_.Mutable(GetArenaForAllocation()); -} -inline std::string* ADVSignedKeyIndexList::release_details() { - // @@protoc_insertion_point(field_release:proto.ADVSignedKeyIndexList.details) - if (!_internal_has_details()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.details_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.details_.IsDefault()) { - _impl_.details_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ADVSignedKeyIndexList::set_allocated_details(std::string* details) { - if (details != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.details_.SetAllocated(details, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.details_.IsDefault()) { - _impl_.details_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedKeyIndexList.details) -} - -// optional bytes accountSignature = 2; -inline bool ADVSignedKeyIndexList::_internal_has_accountsignature() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool ADVSignedKeyIndexList::has_accountsignature() const { - return _internal_has_accountsignature(); -} -inline void ADVSignedKeyIndexList::clear_accountsignature() { - _impl_.accountsignature_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& ADVSignedKeyIndexList::accountsignature() const { - // @@protoc_insertion_point(field_get:proto.ADVSignedKeyIndexList.accountSignature) - return _internal_accountsignature(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ADVSignedKeyIndexList::set_accountsignature(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.accountsignature_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ADVSignedKeyIndexList.accountSignature) -} -inline std::string* ADVSignedKeyIndexList::mutable_accountsignature() { - std::string* _s = _internal_mutable_accountsignature(); - // @@protoc_insertion_point(field_mutable:proto.ADVSignedKeyIndexList.accountSignature) - return _s; -} -inline const std::string& ADVSignedKeyIndexList::_internal_accountsignature() const { - return _impl_.accountsignature_.Get(); -} -inline void ADVSignedKeyIndexList::_internal_set_accountsignature(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.accountsignature_.Set(value, GetArenaForAllocation()); -} -inline std::string* ADVSignedKeyIndexList::_internal_mutable_accountsignature() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.accountsignature_.Mutable(GetArenaForAllocation()); -} -inline std::string* ADVSignedKeyIndexList::release_accountsignature() { - // @@protoc_insertion_point(field_release:proto.ADVSignedKeyIndexList.accountSignature) - if (!_internal_has_accountsignature()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.accountsignature_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.accountsignature_.IsDefault()) { - _impl_.accountsignature_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ADVSignedKeyIndexList::set_allocated_accountsignature(std::string* accountsignature) { - if (accountsignature != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.accountsignature_.SetAllocated(accountsignature, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.accountsignature_.IsDefault()) { - _impl_.accountsignature_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedKeyIndexList.accountSignature) -} - -// ------------------------------------------------------------------- - -// ActionLink - -// optional string url = 1; -inline bool ActionLink::_internal_has_url() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool ActionLink::has_url() const { - return _internal_has_url(); -} -inline void ActionLink::clear_url() { - _impl_.url_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& ActionLink::url() const { - // @@protoc_insertion_point(field_get:proto.ActionLink.url) - return _internal_url(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ActionLink::set_url(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.url_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ActionLink.url) -} -inline std::string* ActionLink::mutable_url() { - std::string* _s = _internal_mutable_url(); - // @@protoc_insertion_point(field_mutable:proto.ActionLink.url) - return _s; -} -inline const std::string& ActionLink::_internal_url() const { - return _impl_.url_.Get(); -} -inline void ActionLink::_internal_set_url(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.url_.Set(value, GetArenaForAllocation()); -} -inline std::string* ActionLink::_internal_mutable_url() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.url_.Mutable(GetArenaForAllocation()); -} -inline std::string* ActionLink::release_url() { - // @@protoc_insertion_point(field_release:proto.ActionLink.url) - if (!_internal_has_url()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.url_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.url_.IsDefault()) { - _impl_.url_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ActionLink::set_allocated_url(std::string* url) { - if (url != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.url_.SetAllocated(url, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.url_.IsDefault()) { - _impl_.url_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ActionLink.url) -} - -// optional string buttonTitle = 2; -inline bool ActionLink::_internal_has_buttontitle() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool ActionLink::has_buttontitle() const { - return _internal_has_buttontitle(); -} -inline void ActionLink::clear_buttontitle() { - _impl_.buttontitle_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& ActionLink::buttontitle() const { - // @@protoc_insertion_point(field_get:proto.ActionLink.buttonTitle) - return _internal_buttontitle(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ActionLink::set_buttontitle(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.buttontitle_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ActionLink.buttonTitle) -} -inline std::string* ActionLink::mutable_buttontitle() { - std::string* _s = _internal_mutable_buttontitle(); - // @@protoc_insertion_point(field_mutable:proto.ActionLink.buttonTitle) - return _s; -} -inline const std::string& ActionLink::_internal_buttontitle() const { - return _impl_.buttontitle_.Get(); -} -inline void ActionLink::_internal_set_buttontitle(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.buttontitle_.Set(value, GetArenaForAllocation()); -} -inline std::string* ActionLink::_internal_mutable_buttontitle() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.buttontitle_.Mutable(GetArenaForAllocation()); -} -inline std::string* ActionLink::release_buttontitle() { - // @@protoc_insertion_point(field_release:proto.ActionLink.buttonTitle) - if (!_internal_has_buttontitle()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.buttontitle_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.buttontitle_.IsDefault()) { - _impl_.buttontitle_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ActionLink::set_allocated_buttontitle(std::string* buttontitle) { - if (buttontitle != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.buttontitle_.SetAllocated(buttontitle, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.buttontitle_.IsDefault()) { - _impl_.buttontitle_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ActionLink.buttonTitle) -} - -// ------------------------------------------------------------------- - -// AutoDownloadSettings - -// optional bool downloadImages = 1; -inline bool AutoDownloadSettings::_internal_has_downloadimages() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool AutoDownloadSettings::has_downloadimages() const { - return _internal_has_downloadimages(); -} -inline void AutoDownloadSettings::clear_downloadimages() { - _impl_.downloadimages_ = false; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline bool AutoDownloadSettings::_internal_downloadimages() const { - return _impl_.downloadimages_; -} -inline bool AutoDownloadSettings::downloadimages() const { - // @@protoc_insertion_point(field_get:proto.AutoDownloadSettings.downloadImages) - return _internal_downloadimages(); -} -inline void AutoDownloadSettings::_internal_set_downloadimages(bool value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.downloadimages_ = value; -} -inline void AutoDownloadSettings::set_downloadimages(bool value) { - _internal_set_downloadimages(value); - // @@protoc_insertion_point(field_set:proto.AutoDownloadSettings.downloadImages) -} - -// optional bool downloadAudio = 2; -inline bool AutoDownloadSettings::_internal_has_downloadaudio() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool AutoDownloadSettings::has_downloadaudio() const { - return _internal_has_downloadaudio(); -} -inline void AutoDownloadSettings::clear_downloadaudio() { - _impl_.downloadaudio_ = false; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline bool AutoDownloadSettings::_internal_downloadaudio() const { - return _impl_.downloadaudio_; -} -inline bool AutoDownloadSettings::downloadaudio() const { - // @@protoc_insertion_point(field_get:proto.AutoDownloadSettings.downloadAudio) - return _internal_downloadaudio(); -} -inline void AutoDownloadSettings::_internal_set_downloadaudio(bool value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.downloadaudio_ = value; -} -inline void AutoDownloadSettings::set_downloadaudio(bool value) { - _internal_set_downloadaudio(value); - // @@protoc_insertion_point(field_set:proto.AutoDownloadSettings.downloadAudio) -} - -// optional bool downloadVideo = 3; -inline bool AutoDownloadSettings::_internal_has_downloadvideo() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool AutoDownloadSettings::has_downloadvideo() const { - return _internal_has_downloadvideo(); -} -inline void AutoDownloadSettings::clear_downloadvideo() { - _impl_.downloadvideo_ = false; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline bool AutoDownloadSettings::_internal_downloadvideo() const { - return _impl_.downloadvideo_; -} -inline bool AutoDownloadSettings::downloadvideo() const { - // @@protoc_insertion_point(field_get:proto.AutoDownloadSettings.downloadVideo) - return _internal_downloadvideo(); -} -inline void AutoDownloadSettings::_internal_set_downloadvideo(bool value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.downloadvideo_ = value; -} -inline void AutoDownloadSettings::set_downloadvideo(bool value) { - _internal_set_downloadvideo(value); - // @@protoc_insertion_point(field_set:proto.AutoDownloadSettings.downloadVideo) -} - -// optional bool downloadDocuments = 4; -inline bool AutoDownloadSettings::_internal_has_downloaddocuments() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool AutoDownloadSettings::has_downloaddocuments() const { - return _internal_has_downloaddocuments(); -} -inline void AutoDownloadSettings::clear_downloaddocuments() { - _impl_.downloaddocuments_ = false; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline bool AutoDownloadSettings::_internal_downloaddocuments() const { - return _impl_.downloaddocuments_; -} -inline bool AutoDownloadSettings::downloaddocuments() const { - // @@protoc_insertion_point(field_get:proto.AutoDownloadSettings.downloadDocuments) - return _internal_downloaddocuments(); -} -inline void AutoDownloadSettings::_internal_set_downloaddocuments(bool value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.downloaddocuments_ = value; -} -inline void AutoDownloadSettings::set_downloaddocuments(bool value) { - _internal_set_downloaddocuments(value); - // @@protoc_insertion_point(field_set:proto.AutoDownloadSettings.downloadDocuments) -} - -// ------------------------------------------------------------------- - -// BizAccountLinkInfo - -// optional uint64 whatsappBizAcctFbid = 1; -inline bool BizAccountLinkInfo::_internal_has_whatsappbizacctfbid() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool BizAccountLinkInfo::has_whatsappbizacctfbid() const { - return _internal_has_whatsappbizacctfbid(); -} -inline void BizAccountLinkInfo::clear_whatsappbizacctfbid() { - _impl_.whatsappbizacctfbid_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline uint64_t BizAccountLinkInfo::_internal_whatsappbizacctfbid() const { - return _impl_.whatsappbizacctfbid_; -} -inline uint64_t BizAccountLinkInfo::whatsappbizacctfbid() const { - // @@protoc_insertion_point(field_get:proto.BizAccountLinkInfo.whatsappBizAcctFbid) - return _internal_whatsappbizacctfbid(); -} -inline void BizAccountLinkInfo::_internal_set_whatsappbizacctfbid(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.whatsappbizacctfbid_ = value; -} -inline void BizAccountLinkInfo::set_whatsappbizacctfbid(uint64_t value) { - _internal_set_whatsappbizacctfbid(value); - // @@protoc_insertion_point(field_set:proto.BizAccountLinkInfo.whatsappBizAcctFbid) -} - -// optional string whatsappAcctNumber = 2; -inline bool BizAccountLinkInfo::_internal_has_whatsappacctnumber() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool BizAccountLinkInfo::has_whatsappacctnumber() const { - return _internal_has_whatsappacctnumber(); -} -inline void BizAccountLinkInfo::clear_whatsappacctnumber() { - _impl_.whatsappacctnumber_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& BizAccountLinkInfo::whatsappacctnumber() const { - // @@protoc_insertion_point(field_get:proto.BizAccountLinkInfo.whatsappAcctNumber) - return _internal_whatsappacctnumber(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void BizAccountLinkInfo::set_whatsappacctnumber(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.whatsappacctnumber_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.BizAccountLinkInfo.whatsappAcctNumber) -} -inline std::string* BizAccountLinkInfo::mutable_whatsappacctnumber() { - std::string* _s = _internal_mutable_whatsappacctnumber(); - // @@protoc_insertion_point(field_mutable:proto.BizAccountLinkInfo.whatsappAcctNumber) - return _s; -} -inline const std::string& BizAccountLinkInfo::_internal_whatsappacctnumber() const { - return _impl_.whatsappacctnumber_.Get(); -} -inline void BizAccountLinkInfo::_internal_set_whatsappacctnumber(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.whatsappacctnumber_.Set(value, GetArenaForAllocation()); -} -inline std::string* BizAccountLinkInfo::_internal_mutable_whatsappacctnumber() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.whatsappacctnumber_.Mutable(GetArenaForAllocation()); -} -inline std::string* BizAccountLinkInfo::release_whatsappacctnumber() { - // @@protoc_insertion_point(field_release:proto.BizAccountLinkInfo.whatsappAcctNumber) - if (!_internal_has_whatsappacctnumber()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.whatsappacctnumber_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.whatsappacctnumber_.IsDefault()) { - _impl_.whatsappacctnumber_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void BizAccountLinkInfo::set_allocated_whatsappacctnumber(std::string* whatsappacctnumber) { - if (whatsappacctnumber != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.whatsappacctnumber_.SetAllocated(whatsappacctnumber, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.whatsappacctnumber_.IsDefault()) { - _impl_.whatsappacctnumber_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.BizAccountLinkInfo.whatsappAcctNumber) -} - -// optional uint64 issueTime = 3; -inline bool BizAccountLinkInfo::_internal_has_issuetime() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool BizAccountLinkInfo::has_issuetime() const { - return _internal_has_issuetime(); -} -inline void BizAccountLinkInfo::clear_issuetime() { - _impl_.issuetime_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline uint64_t BizAccountLinkInfo::_internal_issuetime() const { - return _impl_.issuetime_; -} -inline uint64_t BizAccountLinkInfo::issuetime() const { - // @@protoc_insertion_point(field_get:proto.BizAccountLinkInfo.issueTime) - return _internal_issuetime(); -} -inline void BizAccountLinkInfo::_internal_set_issuetime(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.issuetime_ = value; -} -inline void BizAccountLinkInfo::set_issuetime(uint64_t value) { - _internal_set_issuetime(value); - // @@protoc_insertion_point(field_set:proto.BizAccountLinkInfo.issueTime) -} - -// optional .proto.BizAccountLinkInfo.HostStorageType hostStorage = 4; -inline bool BizAccountLinkInfo::_internal_has_hoststorage() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool BizAccountLinkInfo::has_hoststorage() const { - return _internal_has_hoststorage(); -} -inline void BizAccountLinkInfo::clear_hoststorage() { - _impl_.hoststorage_ = 0; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline ::proto::BizAccountLinkInfo_HostStorageType BizAccountLinkInfo::_internal_hoststorage() const { - return static_cast< ::proto::BizAccountLinkInfo_HostStorageType >(_impl_.hoststorage_); -} -inline ::proto::BizAccountLinkInfo_HostStorageType BizAccountLinkInfo::hoststorage() const { - // @@protoc_insertion_point(field_get:proto.BizAccountLinkInfo.hostStorage) - return _internal_hoststorage(); -} -inline void BizAccountLinkInfo::_internal_set_hoststorage(::proto::BizAccountLinkInfo_HostStorageType value) { - assert(::proto::BizAccountLinkInfo_HostStorageType_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.hoststorage_ = value; -} -inline void BizAccountLinkInfo::set_hoststorage(::proto::BizAccountLinkInfo_HostStorageType value) { - _internal_set_hoststorage(value); - // @@protoc_insertion_point(field_set:proto.BizAccountLinkInfo.hostStorage) -} - -// optional .proto.BizAccountLinkInfo.AccountType accountType = 5; -inline bool BizAccountLinkInfo::_internal_has_accounttype() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool BizAccountLinkInfo::has_accounttype() const { - return _internal_has_accounttype(); -} -inline void BizAccountLinkInfo::clear_accounttype() { - _impl_.accounttype_ = 0; - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline ::proto::BizAccountLinkInfo_AccountType BizAccountLinkInfo::_internal_accounttype() const { - return static_cast< ::proto::BizAccountLinkInfo_AccountType >(_impl_.accounttype_); -} -inline ::proto::BizAccountLinkInfo_AccountType BizAccountLinkInfo::accounttype() const { - // @@protoc_insertion_point(field_get:proto.BizAccountLinkInfo.accountType) - return _internal_accounttype(); -} -inline void BizAccountLinkInfo::_internal_set_accounttype(::proto::BizAccountLinkInfo_AccountType value) { - assert(::proto::BizAccountLinkInfo_AccountType_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.accounttype_ = value; -} -inline void BizAccountLinkInfo::set_accounttype(::proto::BizAccountLinkInfo_AccountType value) { - _internal_set_accounttype(value); - // @@protoc_insertion_point(field_set:proto.BizAccountLinkInfo.accountType) -} - -// ------------------------------------------------------------------- - -// BizAccountPayload - -// optional .proto.VerifiedNameCertificate vnameCert = 1; -inline bool BizAccountPayload::_internal_has_vnamecert() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.vnamecert_ != nullptr); - return value; -} -inline bool BizAccountPayload::has_vnamecert() const { - return _internal_has_vnamecert(); -} -inline void BizAccountPayload::clear_vnamecert() { - if (_impl_.vnamecert_ != nullptr) _impl_.vnamecert_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::VerifiedNameCertificate& BizAccountPayload::_internal_vnamecert() const { - const ::proto::VerifiedNameCertificate* p = _impl_.vnamecert_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_VerifiedNameCertificate_default_instance_); -} -inline const ::proto::VerifiedNameCertificate& BizAccountPayload::vnamecert() const { - // @@protoc_insertion_point(field_get:proto.BizAccountPayload.vnameCert) - return _internal_vnamecert(); -} -inline void BizAccountPayload::unsafe_arena_set_allocated_vnamecert( - ::proto::VerifiedNameCertificate* vnamecert) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.vnamecert_); - } - _impl_.vnamecert_ = vnamecert; - if (vnamecert) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.BizAccountPayload.vnameCert) -} -inline ::proto::VerifiedNameCertificate* BizAccountPayload::release_vnamecert() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::VerifiedNameCertificate* temp = _impl_.vnamecert_; - _impl_.vnamecert_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::VerifiedNameCertificate* BizAccountPayload::unsafe_arena_release_vnamecert() { - // @@protoc_insertion_point(field_release:proto.BizAccountPayload.vnameCert) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::VerifiedNameCertificate* temp = _impl_.vnamecert_; - _impl_.vnamecert_ = nullptr; - return temp; -} -inline ::proto::VerifiedNameCertificate* BizAccountPayload::_internal_mutable_vnamecert() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.vnamecert_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::VerifiedNameCertificate>(GetArenaForAllocation()); - _impl_.vnamecert_ = p; - } - return _impl_.vnamecert_; -} -inline ::proto::VerifiedNameCertificate* BizAccountPayload::mutable_vnamecert() { - ::proto::VerifiedNameCertificate* _msg = _internal_mutable_vnamecert(); - // @@protoc_insertion_point(field_mutable:proto.BizAccountPayload.vnameCert) - return _msg; -} -inline void BizAccountPayload::set_allocated_vnamecert(::proto::VerifiedNameCertificate* vnamecert) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.vnamecert_; - } - if (vnamecert) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(vnamecert); - if (message_arena != submessage_arena) { - vnamecert = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, vnamecert, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.vnamecert_ = vnamecert; - // @@protoc_insertion_point(field_set_allocated:proto.BizAccountPayload.vnameCert) -} - -// optional bytes bizAcctLinkInfo = 2; -inline bool BizAccountPayload::_internal_has_bizacctlinkinfo() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool BizAccountPayload::has_bizacctlinkinfo() const { - return _internal_has_bizacctlinkinfo(); -} -inline void BizAccountPayload::clear_bizacctlinkinfo() { - _impl_.bizacctlinkinfo_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& BizAccountPayload::bizacctlinkinfo() const { - // @@protoc_insertion_point(field_get:proto.BizAccountPayload.bizAcctLinkInfo) - return _internal_bizacctlinkinfo(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void BizAccountPayload::set_bizacctlinkinfo(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.bizacctlinkinfo_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.BizAccountPayload.bizAcctLinkInfo) -} -inline std::string* BizAccountPayload::mutable_bizacctlinkinfo() { - std::string* _s = _internal_mutable_bizacctlinkinfo(); - // @@protoc_insertion_point(field_mutable:proto.BizAccountPayload.bizAcctLinkInfo) - return _s; -} -inline const std::string& BizAccountPayload::_internal_bizacctlinkinfo() const { - return _impl_.bizacctlinkinfo_.Get(); -} -inline void BizAccountPayload::_internal_set_bizacctlinkinfo(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.bizacctlinkinfo_.Set(value, GetArenaForAllocation()); -} -inline std::string* BizAccountPayload::_internal_mutable_bizacctlinkinfo() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.bizacctlinkinfo_.Mutable(GetArenaForAllocation()); -} -inline std::string* BizAccountPayload::release_bizacctlinkinfo() { - // @@protoc_insertion_point(field_release:proto.BizAccountPayload.bizAcctLinkInfo) - if (!_internal_has_bizacctlinkinfo()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.bizacctlinkinfo_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.bizacctlinkinfo_.IsDefault()) { - _impl_.bizacctlinkinfo_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void BizAccountPayload::set_allocated_bizacctlinkinfo(std::string* bizacctlinkinfo) { - if (bizacctlinkinfo != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.bizacctlinkinfo_.SetAllocated(bizacctlinkinfo, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.bizacctlinkinfo_.IsDefault()) { - _impl_.bizacctlinkinfo_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.BizAccountPayload.bizAcctLinkInfo) -} - -// ------------------------------------------------------------------- - -// BizIdentityInfo - -// optional .proto.BizIdentityInfo.VerifiedLevelValue vlevel = 1; -inline bool BizIdentityInfo::_internal_has_vlevel() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool BizIdentityInfo::has_vlevel() const { - return _internal_has_vlevel(); -} -inline void BizIdentityInfo::clear_vlevel() { - _impl_.vlevel_ = 0; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline ::proto::BizIdentityInfo_VerifiedLevelValue BizIdentityInfo::_internal_vlevel() const { - return static_cast< ::proto::BizIdentityInfo_VerifiedLevelValue >(_impl_.vlevel_); -} -inline ::proto::BizIdentityInfo_VerifiedLevelValue BizIdentityInfo::vlevel() const { - // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.vlevel) - return _internal_vlevel(); -} -inline void BizIdentityInfo::_internal_set_vlevel(::proto::BizIdentityInfo_VerifiedLevelValue value) { - assert(::proto::BizIdentityInfo_VerifiedLevelValue_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.vlevel_ = value; -} -inline void BizIdentityInfo::set_vlevel(::proto::BizIdentityInfo_VerifiedLevelValue value) { - _internal_set_vlevel(value); - // @@protoc_insertion_point(field_set:proto.BizIdentityInfo.vlevel) -} - -// optional .proto.VerifiedNameCertificate vnameCert = 2; -inline bool BizIdentityInfo::_internal_has_vnamecert() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.vnamecert_ != nullptr); - return value; -} -inline bool BizIdentityInfo::has_vnamecert() const { - return _internal_has_vnamecert(); -} -inline void BizIdentityInfo::clear_vnamecert() { - if (_impl_.vnamecert_ != nullptr) _impl_.vnamecert_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::VerifiedNameCertificate& BizIdentityInfo::_internal_vnamecert() const { - const ::proto::VerifiedNameCertificate* p = _impl_.vnamecert_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_VerifiedNameCertificate_default_instance_); -} -inline const ::proto::VerifiedNameCertificate& BizIdentityInfo::vnamecert() const { - // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.vnameCert) - return _internal_vnamecert(); -} -inline void BizIdentityInfo::unsafe_arena_set_allocated_vnamecert( - ::proto::VerifiedNameCertificate* vnamecert) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.vnamecert_); - } - _impl_.vnamecert_ = vnamecert; - if (vnamecert) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.BizIdentityInfo.vnameCert) -} -inline ::proto::VerifiedNameCertificate* BizIdentityInfo::release_vnamecert() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::VerifiedNameCertificate* temp = _impl_.vnamecert_; - _impl_.vnamecert_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::VerifiedNameCertificate* BizIdentityInfo::unsafe_arena_release_vnamecert() { - // @@protoc_insertion_point(field_release:proto.BizIdentityInfo.vnameCert) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::VerifiedNameCertificate* temp = _impl_.vnamecert_; - _impl_.vnamecert_ = nullptr; - return temp; -} -inline ::proto::VerifiedNameCertificate* BizIdentityInfo::_internal_mutable_vnamecert() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.vnamecert_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::VerifiedNameCertificate>(GetArenaForAllocation()); - _impl_.vnamecert_ = p; - } - return _impl_.vnamecert_; -} -inline ::proto::VerifiedNameCertificate* BizIdentityInfo::mutable_vnamecert() { - ::proto::VerifiedNameCertificate* _msg = _internal_mutable_vnamecert(); - // @@protoc_insertion_point(field_mutable:proto.BizIdentityInfo.vnameCert) - return _msg; -} -inline void BizIdentityInfo::set_allocated_vnamecert(::proto::VerifiedNameCertificate* vnamecert) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.vnamecert_; - } - if (vnamecert) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(vnamecert); - if (message_arena != submessage_arena) { - vnamecert = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, vnamecert, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.vnamecert_ = vnamecert; - // @@protoc_insertion_point(field_set_allocated:proto.BizIdentityInfo.vnameCert) -} - -// optional bool signed = 3; -inline bool BizIdentityInfo::_internal_has_signed_() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool BizIdentityInfo::has_signed_() const { - return _internal_has_signed_(); -} -inline void BizIdentityInfo::clear_signed_() { - _impl_.signed__ = false; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline bool BizIdentityInfo::_internal_signed_() const { - return _impl_.signed__; -} -inline bool BizIdentityInfo::signed_() const { - // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.signed) - return _internal_signed_(); -} -inline void BizIdentityInfo::_internal_set_signed_(bool value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.signed__ = value; -} -inline void BizIdentityInfo::set_signed_(bool value) { - _internal_set_signed_(value); - // @@protoc_insertion_point(field_set:proto.BizIdentityInfo.signed) -} - -// optional bool revoked = 4; -inline bool BizIdentityInfo::_internal_has_revoked() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool BizIdentityInfo::has_revoked() const { - return _internal_has_revoked(); -} -inline void BizIdentityInfo::clear_revoked() { - _impl_.revoked_ = false; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline bool BizIdentityInfo::_internal_revoked() const { - return _impl_.revoked_; -} -inline bool BizIdentityInfo::revoked() const { - // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.revoked) - return _internal_revoked(); -} -inline void BizIdentityInfo::_internal_set_revoked(bool value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.revoked_ = value; -} -inline void BizIdentityInfo::set_revoked(bool value) { - _internal_set_revoked(value); - // @@protoc_insertion_point(field_set:proto.BizIdentityInfo.revoked) -} - -// optional .proto.BizIdentityInfo.HostStorageType hostStorage = 5; -inline bool BizIdentityInfo::_internal_has_hoststorage() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool BizIdentityInfo::has_hoststorage() const { - return _internal_has_hoststorage(); -} -inline void BizIdentityInfo::clear_hoststorage() { - _impl_.hoststorage_ = 0; - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline ::proto::BizIdentityInfo_HostStorageType BizIdentityInfo::_internal_hoststorage() const { - return static_cast< ::proto::BizIdentityInfo_HostStorageType >(_impl_.hoststorage_); -} -inline ::proto::BizIdentityInfo_HostStorageType BizIdentityInfo::hoststorage() const { - // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.hostStorage) - return _internal_hoststorage(); -} -inline void BizIdentityInfo::_internal_set_hoststorage(::proto::BizIdentityInfo_HostStorageType value) { - assert(::proto::BizIdentityInfo_HostStorageType_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.hoststorage_ = value; -} -inline void BizIdentityInfo::set_hoststorage(::proto::BizIdentityInfo_HostStorageType value) { - _internal_set_hoststorage(value); - // @@protoc_insertion_point(field_set:proto.BizIdentityInfo.hostStorage) -} - -// optional .proto.BizIdentityInfo.ActualActorsType actualActors = 6; -inline bool BizIdentityInfo::_internal_has_actualactors() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool BizIdentityInfo::has_actualactors() const { - return _internal_has_actualactors(); -} -inline void BizIdentityInfo::clear_actualactors() { - _impl_.actualactors_ = 0; - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline ::proto::BizIdentityInfo_ActualActorsType BizIdentityInfo::_internal_actualactors() const { - return static_cast< ::proto::BizIdentityInfo_ActualActorsType >(_impl_.actualactors_); -} -inline ::proto::BizIdentityInfo_ActualActorsType BizIdentityInfo::actualactors() const { - // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.actualActors) - return _internal_actualactors(); -} -inline void BizIdentityInfo::_internal_set_actualactors(::proto::BizIdentityInfo_ActualActorsType value) { - assert(::proto::BizIdentityInfo_ActualActorsType_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.actualactors_ = value; -} -inline void BizIdentityInfo::set_actualactors(::proto::BizIdentityInfo_ActualActorsType value) { - _internal_set_actualactors(value); - // @@protoc_insertion_point(field_set:proto.BizIdentityInfo.actualActors) -} - -// optional uint64 privacyModeTs = 7; -inline bool BizIdentityInfo::_internal_has_privacymodets() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool BizIdentityInfo::has_privacymodets() const { - return _internal_has_privacymodets(); -} -inline void BizIdentityInfo::clear_privacymodets() { - _impl_.privacymodets_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline uint64_t BizIdentityInfo::_internal_privacymodets() const { - return _impl_.privacymodets_; -} -inline uint64_t BizIdentityInfo::privacymodets() const { - // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.privacyModeTs) - return _internal_privacymodets(); -} -inline void BizIdentityInfo::_internal_set_privacymodets(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.privacymodets_ = value; -} -inline void BizIdentityInfo::set_privacymodets(uint64_t value) { - _internal_set_privacymodets(value); - // @@protoc_insertion_point(field_set:proto.BizIdentityInfo.privacyModeTs) -} - -// optional uint64 featureControls = 8; -inline bool BizIdentityInfo::_internal_has_featurecontrols() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - return value; -} -inline bool BizIdentityInfo::has_featurecontrols() const { - return _internal_has_featurecontrols(); -} -inline void BizIdentityInfo::clear_featurecontrols() { - _impl_.featurecontrols_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline uint64_t BizIdentityInfo::_internal_featurecontrols() const { - return _impl_.featurecontrols_; -} -inline uint64_t BizIdentityInfo::featurecontrols() const { - // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.featureControls) - return _internal_featurecontrols(); -} -inline void BizIdentityInfo::_internal_set_featurecontrols(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.featurecontrols_ = value; -} -inline void BizIdentityInfo::set_featurecontrols(uint64_t value) { - _internal_set_featurecontrols(value); - // @@protoc_insertion_point(field_set:proto.BizIdentityInfo.featureControls) -} - -// ------------------------------------------------------------------- - -// CertChain_NoiseCertificate_Details - -// optional uint32 serial = 1; -inline bool CertChain_NoiseCertificate_Details::_internal_has_serial() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool CertChain_NoiseCertificate_Details::has_serial() const { - return _internal_has_serial(); -} -inline void CertChain_NoiseCertificate_Details::clear_serial() { - _impl_.serial_ = 0u; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline uint32_t CertChain_NoiseCertificate_Details::_internal_serial() const { - return _impl_.serial_; -} -inline uint32_t CertChain_NoiseCertificate_Details::serial() const { - // @@protoc_insertion_point(field_get:proto.CertChain.NoiseCertificate.Details.serial) - return _internal_serial(); -} -inline void CertChain_NoiseCertificate_Details::_internal_set_serial(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.serial_ = value; -} -inline void CertChain_NoiseCertificate_Details::set_serial(uint32_t value) { - _internal_set_serial(value); - // @@protoc_insertion_point(field_set:proto.CertChain.NoiseCertificate.Details.serial) -} - -// optional uint32 issuerSerial = 2; -inline bool CertChain_NoiseCertificate_Details::_internal_has_issuerserial() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool CertChain_NoiseCertificate_Details::has_issuerserial() const { - return _internal_has_issuerserial(); -} -inline void CertChain_NoiseCertificate_Details::clear_issuerserial() { - _impl_.issuerserial_ = 0u; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline uint32_t CertChain_NoiseCertificate_Details::_internal_issuerserial() const { - return _impl_.issuerserial_; -} -inline uint32_t CertChain_NoiseCertificate_Details::issuerserial() const { - // @@protoc_insertion_point(field_get:proto.CertChain.NoiseCertificate.Details.issuerSerial) - return _internal_issuerserial(); -} -inline void CertChain_NoiseCertificate_Details::_internal_set_issuerserial(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.issuerserial_ = value; -} -inline void CertChain_NoiseCertificate_Details::set_issuerserial(uint32_t value) { - _internal_set_issuerserial(value); - // @@protoc_insertion_point(field_set:proto.CertChain.NoiseCertificate.Details.issuerSerial) -} - -// optional bytes key = 3; -inline bool CertChain_NoiseCertificate_Details::_internal_has_key() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool CertChain_NoiseCertificate_Details::has_key() const { - return _internal_has_key(); -} -inline void CertChain_NoiseCertificate_Details::clear_key() { - _impl_.key_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& CertChain_NoiseCertificate_Details::key() const { - // @@protoc_insertion_point(field_get:proto.CertChain.NoiseCertificate.Details.key) - return _internal_key(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void CertChain_NoiseCertificate_Details::set_key(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.key_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.CertChain.NoiseCertificate.Details.key) -} -inline std::string* CertChain_NoiseCertificate_Details::mutable_key() { - std::string* _s = _internal_mutable_key(); - // @@protoc_insertion_point(field_mutable:proto.CertChain.NoiseCertificate.Details.key) - return _s; -} -inline const std::string& CertChain_NoiseCertificate_Details::_internal_key() const { - return _impl_.key_.Get(); -} -inline void CertChain_NoiseCertificate_Details::_internal_set_key(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.key_.Set(value, GetArenaForAllocation()); -} -inline std::string* CertChain_NoiseCertificate_Details::_internal_mutable_key() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.key_.Mutable(GetArenaForAllocation()); -} -inline std::string* CertChain_NoiseCertificate_Details::release_key() { - // @@protoc_insertion_point(field_release:proto.CertChain.NoiseCertificate.Details.key) - if (!_internal_has_key()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.key_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.key_.IsDefault()) { - _impl_.key_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void CertChain_NoiseCertificate_Details::set_allocated_key(std::string* key) { - if (key != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.key_.SetAllocated(key, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.key_.IsDefault()) { - _impl_.key_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.CertChain.NoiseCertificate.Details.key) -} - -// optional uint64 notBefore = 4; -inline bool CertChain_NoiseCertificate_Details::_internal_has_notbefore() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool CertChain_NoiseCertificate_Details::has_notbefore() const { - return _internal_has_notbefore(); -} -inline void CertChain_NoiseCertificate_Details::clear_notbefore() { - _impl_.notbefore_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline uint64_t CertChain_NoiseCertificate_Details::_internal_notbefore() const { - return _impl_.notbefore_; -} -inline uint64_t CertChain_NoiseCertificate_Details::notbefore() const { - // @@protoc_insertion_point(field_get:proto.CertChain.NoiseCertificate.Details.notBefore) - return _internal_notbefore(); -} -inline void CertChain_NoiseCertificate_Details::_internal_set_notbefore(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.notbefore_ = value; -} -inline void CertChain_NoiseCertificate_Details::set_notbefore(uint64_t value) { - _internal_set_notbefore(value); - // @@protoc_insertion_point(field_set:proto.CertChain.NoiseCertificate.Details.notBefore) -} - -// optional uint64 notAfter = 5; -inline bool CertChain_NoiseCertificate_Details::_internal_has_notafter() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool CertChain_NoiseCertificate_Details::has_notafter() const { - return _internal_has_notafter(); -} -inline void CertChain_NoiseCertificate_Details::clear_notafter() { - _impl_.notafter_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline uint64_t CertChain_NoiseCertificate_Details::_internal_notafter() const { - return _impl_.notafter_; -} -inline uint64_t CertChain_NoiseCertificate_Details::notafter() const { - // @@protoc_insertion_point(field_get:proto.CertChain.NoiseCertificate.Details.notAfter) - return _internal_notafter(); -} -inline void CertChain_NoiseCertificate_Details::_internal_set_notafter(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.notafter_ = value; -} -inline void CertChain_NoiseCertificate_Details::set_notafter(uint64_t value) { - _internal_set_notafter(value); - // @@protoc_insertion_point(field_set:proto.CertChain.NoiseCertificate.Details.notAfter) -} - -// ------------------------------------------------------------------- - -// CertChain_NoiseCertificate - -// optional bytes details = 1; -inline bool CertChain_NoiseCertificate::_internal_has_details() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool CertChain_NoiseCertificate::has_details() const { - return _internal_has_details(); -} -inline void CertChain_NoiseCertificate::clear_details() { - _impl_.details_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& CertChain_NoiseCertificate::details() const { - // @@protoc_insertion_point(field_get:proto.CertChain.NoiseCertificate.details) - return _internal_details(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void CertChain_NoiseCertificate::set_details(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.details_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.CertChain.NoiseCertificate.details) -} -inline std::string* CertChain_NoiseCertificate::mutable_details() { - std::string* _s = _internal_mutable_details(); - // @@protoc_insertion_point(field_mutable:proto.CertChain.NoiseCertificate.details) - return _s; -} -inline const std::string& CertChain_NoiseCertificate::_internal_details() const { - return _impl_.details_.Get(); -} -inline void CertChain_NoiseCertificate::_internal_set_details(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.details_.Set(value, GetArenaForAllocation()); -} -inline std::string* CertChain_NoiseCertificate::_internal_mutable_details() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.details_.Mutable(GetArenaForAllocation()); -} -inline std::string* CertChain_NoiseCertificate::release_details() { - // @@protoc_insertion_point(field_release:proto.CertChain.NoiseCertificate.details) - if (!_internal_has_details()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.details_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.details_.IsDefault()) { - _impl_.details_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void CertChain_NoiseCertificate::set_allocated_details(std::string* details) { - if (details != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.details_.SetAllocated(details, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.details_.IsDefault()) { - _impl_.details_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.CertChain.NoiseCertificate.details) -} - -// optional bytes signature = 2; -inline bool CertChain_NoiseCertificate::_internal_has_signature() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool CertChain_NoiseCertificate::has_signature() const { - return _internal_has_signature(); -} -inline void CertChain_NoiseCertificate::clear_signature() { - _impl_.signature_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& CertChain_NoiseCertificate::signature() const { - // @@protoc_insertion_point(field_get:proto.CertChain.NoiseCertificate.signature) - return _internal_signature(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void CertChain_NoiseCertificate::set_signature(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.signature_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.CertChain.NoiseCertificate.signature) -} -inline std::string* CertChain_NoiseCertificate::mutable_signature() { - std::string* _s = _internal_mutable_signature(); - // @@protoc_insertion_point(field_mutable:proto.CertChain.NoiseCertificate.signature) - return _s; -} -inline const std::string& CertChain_NoiseCertificate::_internal_signature() const { - return _impl_.signature_.Get(); -} -inline void CertChain_NoiseCertificate::_internal_set_signature(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.signature_.Set(value, GetArenaForAllocation()); -} -inline std::string* CertChain_NoiseCertificate::_internal_mutable_signature() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.signature_.Mutable(GetArenaForAllocation()); -} -inline std::string* CertChain_NoiseCertificate::release_signature() { - // @@protoc_insertion_point(field_release:proto.CertChain.NoiseCertificate.signature) - if (!_internal_has_signature()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.signature_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.signature_.IsDefault()) { - _impl_.signature_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void CertChain_NoiseCertificate::set_allocated_signature(std::string* signature) { - if (signature != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.signature_.SetAllocated(signature, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.signature_.IsDefault()) { - _impl_.signature_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.CertChain.NoiseCertificate.signature) -} - -// ------------------------------------------------------------------- - -// CertChain - -// optional .proto.CertChain.NoiseCertificate leaf = 1; -inline bool CertChain::_internal_has_leaf() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.leaf_ != nullptr); - return value; -} -inline bool CertChain::has_leaf() const { - return _internal_has_leaf(); -} -inline void CertChain::clear_leaf() { - if (_impl_.leaf_ != nullptr) _impl_.leaf_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::CertChain_NoiseCertificate& CertChain::_internal_leaf() const { - const ::proto::CertChain_NoiseCertificate* p = _impl_.leaf_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_CertChain_NoiseCertificate_default_instance_); -} -inline const ::proto::CertChain_NoiseCertificate& CertChain::leaf() const { - // @@protoc_insertion_point(field_get:proto.CertChain.leaf) - return _internal_leaf(); -} -inline void CertChain::unsafe_arena_set_allocated_leaf( - ::proto::CertChain_NoiseCertificate* leaf) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.leaf_); - } - _impl_.leaf_ = leaf; - if (leaf) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.CertChain.leaf) -} -inline ::proto::CertChain_NoiseCertificate* CertChain::release_leaf() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::CertChain_NoiseCertificate* temp = _impl_.leaf_; - _impl_.leaf_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::CertChain_NoiseCertificate* CertChain::unsafe_arena_release_leaf() { - // @@protoc_insertion_point(field_release:proto.CertChain.leaf) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::CertChain_NoiseCertificate* temp = _impl_.leaf_; - _impl_.leaf_ = nullptr; - return temp; -} -inline ::proto::CertChain_NoiseCertificate* CertChain::_internal_mutable_leaf() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.leaf_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::CertChain_NoiseCertificate>(GetArenaForAllocation()); - _impl_.leaf_ = p; - } - return _impl_.leaf_; -} -inline ::proto::CertChain_NoiseCertificate* CertChain::mutable_leaf() { - ::proto::CertChain_NoiseCertificate* _msg = _internal_mutable_leaf(); - // @@protoc_insertion_point(field_mutable:proto.CertChain.leaf) - return _msg; -} -inline void CertChain::set_allocated_leaf(::proto::CertChain_NoiseCertificate* leaf) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.leaf_; - } - if (leaf) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(leaf); - if (message_arena != submessage_arena) { - leaf = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, leaf, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.leaf_ = leaf; - // @@protoc_insertion_point(field_set_allocated:proto.CertChain.leaf) -} - -// optional .proto.CertChain.NoiseCertificate intermediate = 2; -inline bool CertChain::_internal_has_intermediate() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.intermediate_ != nullptr); - return value; -} -inline bool CertChain::has_intermediate() const { - return _internal_has_intermediate(); -} -inline void CertChain::clear_intermediate() { - if (_impl_.intermediate_ != nullptr) _impl_.intermediate_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::CertChain_NoiseCertificate& CertChain::_internal_intermediate() const { - const ::proto::CertChain_NoiseCertificate* p = _impl_.intermediate_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_CertChain_NoiseCertificate_default_instance_); -} -inline const ::proto::CertChain_NoiseCertificate& CertChain::intermediate() const { - // @@protoc_insertion_point(field_get:proto.CertChain.intermediate) - return _internal_intermediate(); -} -inline void CertChain::unsafe_arena_set_allocated_intermediate( - ::proto::CertChain_NoiseCertificate* intermediate) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.intermediate_); - } - _impl_.intermediate_ = intermediate; - if (intermediate) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.CertChain.intermediate) -} -inline ::proto::CertChain_NoiseCertificate* CertChain::release_intermediate() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::CertChain_NoiseCertificate* temp = _impl_.intermediate_; - _impl_.intermediate_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::CertChain_NoiseCertificate* CertChain::unsafe_arena_release_intermediate() { - // @@protoc_insertion_point(field_release:proto.CertChain.intermediate) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::CertChain_NoiseCertificate* temp = _impl_.intermediate_; - _impl_.intermediate_ = nullptr; - return temp; -} -inline ::proto::CertChain_NoiseCertificate* CertChain::_internal_mutable_intermediate() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.intermediate_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::CertChain_NoiseCertificate>(GetArenaForAllocation()); - _impl_.intermediate_ = p; - } - return _impl_.intermediate_; -} -inline ::proto::CertChain_NoiseCertificate* CertChain::mutable_intermediate() { - ::proto::CertChain_NoiseCertificate* _msg = _internal_mutable_intermediate(); - // @@protoc_insertion_point(field_mutable:proto.CertChain.intermediate) - return _msg; -} -inline void CertChain::set_allocated_intermediate(::proto::CertChain_NoiseCertificate* intermediate) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.intermediate_; - } - if (intermediate) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(intermediate); - if (message_arena != submessage_arena) { - intermediate = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, intermediate, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.intermediate_ = intermediate; - // @@protoc_insertion_point(field_set_allocated:proto.CertChain.intermediate) -} - -// ------------------------------------------------------------------- - -// Chain - -// optional bytes senderRatchetKey = 1; -inline bool Chain::_internal_has_senderratchetkey() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Chain::has_senderratchetkey() const { - return _internal_has_senderratchetkey(); -} -inline void Chain::clear_senderratchetkey() { - _impl_.senderratchetkey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Chain::senderratchetkey() const { - // @@protoc_insertion_point(field_get:proto.Chain.senderRatchetKey) - return _internal_senderratchetkey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Chain::set_senderratchetkey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.senderratchetkey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Chain.senderRatchetKey) -} -inline std::string* Chain::mutable_senderratchetkey() { - std::string* _s = _internal_mutable_senderratchetkey(); - // @@protoc_insertion_point(field_mutable:proto.Chain.senderRatchetKey) - return _s; -} -inline const std::string& Chain::_internal_senderratchetkey() const { - return _impl_.senderratchetkey_.Get(); -} -inline void Chain::_internal_set_senderratchetkey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.senderratchetkey_.Set(value, GetArenaForAllocation()); -} -inline std::string* Chain::_internal_mutable_senderratchetkey() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.senderratchetkey_.Mutable(GetArenaForAllocation()); -} -inline std::string* Chain::release_senderratchetkey() { - // @@protoc_insertion_point(field_release:proto.Chain.senderRatchetKey) - if (!_internal_has_senderratchetkey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.senderratchetkey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.senderratchetkey_.IsDefault()) { - _impl_.senderratchetkey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Chain::set_allocated_senderratchetkey(std::string* senderratchetkey) { - if (senderratchetkey != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.senderratchetkey_.SetAllocated(senderratchetkey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.senderratchetkey_.IsDefault()) { - _impl_.senderratchetkey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Chain.senderRatchetKey) -} - -// optional bytes senderRatchetKeyPrivate = 2; -inline bool Chain::_internal_has_senderratchetkeyprivate() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Chain::has_senderratchetkeyprivate() const { - return _internal_has_senderratchetkeyprivate(); -} -inline void Chain::clear_senderratchetkeyprivate() { - _impl_.senderratchetkeyprivate_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Chain::senderratchetkeyprivate() const { - // @@protoc_insertion_point(field_get:proto.Chain.senderRatchetKeyPrivate) - return _internal_senderratchetkeyprivate(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Chain::set_senderratchetkeyprivate(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.senderratchetkeyprivate_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Chain.senderRatchetKeyPrivate) -} -inline std::string* Chain::mutable_senderratchetkeyprivate() { - std::string* _s = _internal_mutable_senderratchetkeyprivate(); - // @@protoc_insertion_point(field_mutable:proto.Chain.senderRatchetKeyPrivate) - return _s; -} -inline const std::string& Chain::_internal_senderratchetkeyprivate() const { - return _impl_.senderratchetkeyprivate_.Get(); -} -inline void Chain::_internal_set_senderratchetkeyprivate(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.senderratchetkeyprivate_.Set(value, GetArenaForAllocation()); -} -inline std::string* Chain::_internal_mutable_senderratchetkeyprivate() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.senderratchetkeyprivate_.Mutable(GetArenaForAllocation()); -} -inline std::string* Chain::release_senderratchetkeyprivate() { - // @@protoc_insertion_point(field_release:proto.Chain.senderRatchetKeyPrivate) - if (!_internal_has_senderratchetkeyprivate()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.senderratchetkeyprivate_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.senderratchetkeyprivate_.IsDefault()) { - _impl_.senderratchetkeyprivate_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Chain::set_allocated_senderratchetkeyprivate(std::string* senderratchetkeyprivate) { - if (senderratchetkeyprivate != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.senderratchetkeyprivate_.SetAllocated(senderratchetkeyprivate, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.senderratchetkeyprivate_.IsDefault()) { - _impl_.senderratchetkeyprivate_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Chain.senderRatchetKeyPrivate) -} - -// optional .proto.ChainKey chainKey = 3; -inline bool Chain::_internal_has_chainkey() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - PROTOBUF_ASSUME(!value || _impl_.chainkey_ != nullptr); - return value; -} -inline bool Chain::has_chainkey() const { - return _internal_has_chainkey(); -} -inline void Chain::clear_chainkey() { - if (_impl_.chainkey_ != nullptr) _impl_.chainkey_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const ::proto::ChainKey& Chain::_internal_chainkey() const { - const ::proto::ChainKey* p = _impl_.chainkey_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ChainKey_default_instance_); -} -inline const ::proto::ChainKey& Chain::chainkey() const { - // @@protoc_insertion_point(field_get:proto.Chain.chainKey) - return _internal_chainkey(); -} -inline void Chain::unsafe_arena_set_allocated_chainkey( - ::proto::ChainKey* chainkey) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.chainkey_); - } - _impl_.chainkey_ = chainkey; - if (chainkey) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Chain.chainKey) -} -inline ::proto::ChainKey* Chain::release_chainkey() { - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::ChainKey* temp = _impl_.chainkey_; - _impl_.chainkey_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ChainKey* Chain::unsafe_arena_release_chainkey() { - // @@protoc_insertion_point(field_release:proto.Chain.chainKey) - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::ChainKey* temp = _impl_.chainkey_; - _impl_.chainkey_ = nullptr; - return temp; -} -inline ::proto::ChainKey* Chain::_internal_mutable_chainkey() { - _impl_._has_bits_[0] |= 0x00000004u; - if (_impl_.chainkey_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ChainKey>(GetArenaForAllocation()); - _impl_.chainkey_ = p; - } - return _impl_.chainkey_; -} -inline ::proto::ChainKey* Chain::mutable_chainkey() { - ::proto::ChainKey* _msg = _internal_mutable_chainkey(); - // @@protoc_insertion_point(field_mutable:proto.Chain.chainKey) - return _msg; -} -inline void Chain::set_allocated_chainkey(::proto::ChainKey* chainkey) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.chainkey_; - } - if (chainkey) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(chainkey); - if (message_arena != submessage_arena) { - chainkey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, chainkey, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.chainkey_ = chainkey; - // @@protoc_insertion_point(field_set_allocated:proto.Chain.chainKey) -} - -// repeated .proto.MessageKey messageKeys = 4; -inline int Chain::_internal_messagekeys_size() const { - return _impl_.messagekeys_.size(); -} -inline int Chain::messagekeys_size() const { - return _internal_messagekeys_size(); -} -inline void Chain::clear_messagekeys() { - _impl_.messagekeys_.Clear(); -} -inline ::proto::MessageKey* Chain::mutable_messagekeys(int index) { - // @@protoc_insertion_point(field_mutable:proto.Chain.messageKeys) - return _impl_.messagekeys_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MessageKey >* -Chain::mutable_messagekeys() { - // @@protoc_insertion_point(field_mutable_list:proto.Chain.messageKeys) - return &_impl_.messagekeys_; -} -inline const ::proto::MessageKey& Chain::_internal_messagekeys(int index) const { - return _impl_.messagekeys_.Get(index); -} -inline const ::proto::MessageKey& Chain::messagekeys(int index) const { - // @@protoc_insertion_point(field_get:proto.Chain.messageKeys) - return _internal_messagekeys(index); -} -inline ::proto::MessageKey* Chain::_internal_add_messagekeys() { - return _impl_.messagekeys_.Add(); -} -inline ::proto::MessageKey* Chain::add_messagekeys() { - ::proto::MessageKey* _add = _internal_add_messagekeys(); - // @@protoc_insertion_point(field_add:proto.Chain.messageKeys) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MessageKey >& -Chain::messagekeys() const { - // @@protoc_insertion_point(field_list:proto.Chain.messageKeys) - return _impl_.messagekeys_; -} - -// ------------------------------------------------------------------- - -// ChainKey - -// optional uint32 index = 1; -inline bool ChainKey::_internal_has_index() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool ChainKey::has_index() const { - return _internal_has_index(); -} -inline void ChainKey::clear_index() { - _impl_.index_ = 0u; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline uint32_t ChainKey::_internal_index() const { - return _impl_.index_; -} -inline uint32_t ChainKey::index() const { - // @@protoc_insertion_point(field_get:proto.ChainKey.index) - return _internal_index(); -} -inline void ChainKey::_internal_set_index(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.index_ = value; -} -inline void ChainKey::set_index(uint32_t value) { - _internal_set_index(value); - // @@protoc_insertion_point(field_set:proto.ChainKey.index) -} - -// optional bytes key = 2; -inline bool ChainKey::_internal_has_key() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool ChainKey::has_key() const { - return _internal_has_key(); -} -inline void ChainKey::clear_key() { - _impl_.key_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& ChainKey::key() const { - // @@protoc_insertion_point(field_get:proto.ChainKey.key) - return _internal_key(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ChainKey::set_key(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.key_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ChainKey.key) -} -inline std::string* ChainKey::mutable_key() { - std::string* _s = _internal_mutable_key(); - // @@protoc_insertion_point(field_mutable:proto.ChainKey.key) - return _s; -} -inline const std::string& ChainKey::_internal_key() const { - return _impl_.key_.Get(); -} -inline void ChainKey::_internal_set_key(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.key_.Set(value, GetArenaForAllocation()); -} -inline std::string* ChainKey::_internal_mutable_key() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.key_.Mutable(GetArenaForAllocation()); -} -inline std::string* ChainKey::release_key() { - // @@protoc_insertion_point(field_release:proto.ChainKey.key) - if (!_internal_has_key()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.key_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.key_.IsDefault()) { - _impl_.key_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ChainKey::set_allocated_key(std::string* key) { - if (key != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.key_.SetAllocated(key, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.key_.IsDefault()) { - _impl_.key_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ChainKey.key) -} - -// ------------------------------------------------------------------- - -// ClientPayload_DNSSource - -// optional .proto.ClientPayload.DNSSource.DNSResolutionMethod dnsMethod = 15; -inline bool ClientPayload_DNSSource::_internal_has_dnsmethod() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool ClientPayload_DNSSource::has_dnsmethod() const { - return _internal_has_dnsmethod(); -} -inline void ClientPayload_DNSSource::clear_dnsmethod() { - _impl_.dnsmethod_ = 0; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline ::proto::ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource::_internal_dnsmethod() const { - return static_cast< ::proto::ClientPayload_DNSSource_DNSResolutionMethod >(_impl_.dnsmethod_); -} -inline ::proto::ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource::dnsmethod() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.DNSSource.dnsMethod) - return _internal_dnsmethod(); -} -inline void ClientPayload_DNSSource::_internal_set_dnsmethod(::proto::ClientPayload_DNSSource_DNSResolutionMethod value) { - assert(::proto::ClientPayload_DNSSource_DNSResolutionMethod_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.dnsmethod_ = value; -} -inline void ClientPayload_DNSSource::set_dnsmethod(::proto::ClientPayload_DNSSource_DNSResolutionMethod value) { - _internal_set_dnsmethod(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.DNSSource.dnsMethod) -} - -// optional bool appCached = 16; -inline bool ClientPayload_DNSSource::_internal_has_appcached() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool ClientPayload_DNSSource::has_appcached() const { - return _internal_has_appcached(); -} -inline void ClientPayload_DNSSource::clear_appcached() { - _impl_.appcached_ = false; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline bool ClientPayload_DNSSource::_internal_appcached() const { - return _impl_.appcached_; -} -inline bool ClientPayload_DNSSource::appcached() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.DNSSource.appCached) - return _internal_appcached(); -} -inline void ClientPayload_DNSSource::_internal_set_appcached(bool value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.appcached_ = value; -} -inline void ClientPayload_DNSSource::set_appcached(bool value) { - _internal_set_appcached(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.DNSSource.appCached) -} - -// ------------------------------------------------------------------- - -// ClientPayload_DevicePairingRegistrationData - -// optional bytes eRegid = 1; -inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_eregid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool ClientPayload_DevicePairingRegistrationData::has_eregid() const { - return _internal_has_eregid(); -} -inline void ClientPayload_DevicePairingRegistrationData::clear_eregid() { - _impl_.eregid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& ClientPayload_DevicePairingRegistrationData::eregid() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.eRegid) - return _internal_eregid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ClientPayload_DevicePairingRegistrationData::set_eregid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.eregid_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.eRegid) -} -inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_eregid() { - std::string* _s = _internal_mutable_eregid(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.eRegid) - return _s; -} -inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_eregid() const { - return _impl_.eregid_.Get(); -} -inline void ClientPayload_DevicePairingRegistrationData::_internal_set_eregid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.eregid_.Set(value, GetArenaForAllocation()); -} -inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_eregid() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.eregid_.Mutable(GetArenaForAllocation()); -} -inline std::string* ClientPayload_DevicePairingRegistrationData::release_eregid() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.eRegid) - if (!_internal_has_eregid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.eregid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.eregid_.IsDefault()) { - _impl_.eregid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ClientPayload_DevicePairingRegistrationData::set_allocated_eregid(std::string* eregid) { - if (eregid != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.eregid_.SetAllocated(eregid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.eregid_.IsDefault()) { - _impl_.eregid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.eRegid) -} - -// optional bytes eKeytype = 2; -inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_ekeytype() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool ClientPayload_DevicePairingRegistrationData::has_ekeytype() const { - return _internal_has_ekeytype(); -} -inline void ClientPayload_DevicePairingRegistrationData::clear_ekeytype() { - _impl_.ekeytype_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& ClientPayload_DevicePairingRegistrationData::ekeytype() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.eKeytype) - return _internal_ekeytype(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ClientPayload_DevicePairingRegistrationData::set_ekeytype(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.ekeytype_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.eKeytype) -} -inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_ekeytype() { - std::string* _s = _internal_mutable_ekeytype(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.eKeytype) - return _s; -} -inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_ekeytype() const { - return _impl_.ekeytype_.Get(); -} -inline void ClientPayload_DevicePairingRegistrationData::_internal_set_ekeytype(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.ekeytype_.Set(value, GetArenaForAllocation()); -} -inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_ekeytype() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.ekeytype_.Mutable(GetArenaForAllocation()); -} -inline std::string* ClientPayload_DevicePairingRegistrationData::release_ekeytype() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.eKeytype) - if (!_internal_has_ekeytype()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.ekeytype_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.ekeytype_.IsDefault()) { - _impl_.ekeytype_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ClientPayload_DevicePairingRegistrationData::set_allocated_ekeytype(std::string* ekeytype) { - if (ekeytype != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.ekeytype_.SetAllocated(ekeytype, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.ekeytype_.IsDefault()) { - _impl_.ekeytype_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.eKeytype) -} - -// optional bytes eIdent = 3; -inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_eident() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool ClientPayload_DevicePairingRegistrationData::has_eident() const { - return _internal_has_eident(); -} -inline void ClientPayload_DevicePairingRegistrationData::clear_eident() { - _impl_.eident_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& ClientPayload_DevicePairingRegistrationData::eident() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.eIdent) - return _internal_eident(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ClientPayload_DevicePairingRegistrationData::set_eident(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.eident_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.eIdent) -} -inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_eident() { - std::string* _s = _internal_mutable_eident(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.eIdent) - return _s; -} -inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_eident() const { - return _impl_.eident_.Get(); -} -inline void ClientPayload_DevicePairingRegistrationData::_internal_set_eident(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.eident_.Set(value, GetArenaForAllocation()); -} -inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_eident() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.eident_.Mutable(GetArenaForAllocation()); -} -inline std::string* ClientPayload_DevicePairingRegistrationData::release_eident() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.eIdent) - if (!_internal_has_eident()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.eident_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.eident_.IsDefault()) { - _impl_.eident_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ClientPayload_DevicePairingRegistrationData::set_allocated_eident(std::string* eident) { - if (eident != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.eident_.SetAllocated(eident, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.eident_.IsDefault()) { - _impl_.eident_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.eIdent) -} - -// optional bytes eSkeyId = 4; -inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_eskeyid() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool ClientPayload_DevicePairingRegistrationData::has_eskeyid() const { - return _internal_has_eskeyid(); -} -inline void ClientPayload_DevicePairingRegistrationData::clear_eskeyid() { - _impl_.eskeyid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const std::string& ClientPayload_DevicePairingRegistrationData::eskeyid() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.eSkeyId) - return _internal_eskeyid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ClientPayload_DevicePairingRegistrationData::set_eskeyid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.eskeyid_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.eSkeyId) -} -inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_eskeyid() { - std::string* _s = _internal_mutable_eskeyid(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.eSkeyId) - return _s; -} -inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_eskeyid() const { - return _impl_.eskeyid_.Get(); -} -inline void ClientPayload_DevicePairingRegistrationData::_internal_set_eskeyid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.eskeyid_.Set(value, GetArenaForAllocation()); -} -inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_eskeyid() { - _impl_._has_bits_[0] |= 0x00000008u; - return _impl_.eskeyid_.Mutable(GetArenaForAllocation()); -} -inline std::string* ClientPayload_DevicePairingRegistrationData::release_eskeyid() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.eSkeyId) - if (!_internal_has_eskeyid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000008u; - auto* p = _impl_.eskeyid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.eskeyid_.IsDefault()) { - _impl_.eskeyid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ClientPayload_DevicePairingRegistrationData::set_allocated_eskeyid(std::string* eskeyid) { - if (eskeyid != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.eskeyid_.SetAllocated(eskeyid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.eskeyid_.IsDefault()) { - _impl_.eskeyid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.eSkeyId) -} - -// optional bytes eSkeyVal = 5; -inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_eskeyval() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool ClientPayload_DevicePairingRegistrationData::has_eskeyval() const { - return _internal_has_eskeyval(); -} -inline void ClientPayload_DevicePairingRegistrationData::clear_eskeyval() { - _impl_.eskeyval_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const std::string& ClientPayload_DevicePairingRegistrationData::eskeyval() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.eSkeyVal) - return _internal_eskeyval(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ClientPayload_DevicePairingRegistrationData::set_eskeyval(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.eskeyval_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.eSkeyVal) -} -inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_eskeyval() { - std::string* _s = _internal_mutable_eskeyval(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.eSkeyVal) - return _s; -} -inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_eskeyval() const { - return _impl_.eskeyval_.Get(); -} -inline void ClientPayload_DevicePairingRegistrationData::_internal_set_eskeyval(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.eskeyval_.Set(value, GetArenaForAllocation()); -} -inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_eskeyval() { - _impl_._has_bits_[0] |= 0x00000010u; - return _impl_.eskeyval_.Mutable(GetArenaForAllocation()); -} -inline std::string* ClientPayload_DevicePairingRegistrationData::release_eskeyval() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.eSkeyVal) - if (!_internal_has_eskeyval()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000010u; - auto* p = _impl_.eskeyval_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.eskeyval_.IsDefault()) { - _impl_.eskeyval_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ClientPayload_DevicePairingRegistrationData::set_allocated_eskeyval(std::string* eskeyval) { - if (eskeyval != nullptr) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.eskeyval_.SetAllocated(eskeyval, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.eskeyval_.IsDefault()) { - _impl_.eskeyval_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.eSkeyVal) -} - -// optional bytes eSkeySig = 6; -inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_eskeysig() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool ClientPayload_DevicePairingRegistrationData::has_eskeysig() const { - return _internal_has_eskeysig(); -} -inline void ClientPayload_DevicePairingRegistrationData::clear_eskeysig() { - _impl_.eskeysig_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline const std::string& ClientPayload_DevicePairingRegistrationData::eskeysig() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.eSkeySig) - return _internal_eskeysig(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ClientPayload_DevicePairingRegistrationData::set_eskeysig(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.eskeysig_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.eSkeySig) -} -inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_eskeysig() { - std::string* _s = _internal_mutable_eskeysig(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.eSkeySig) - return _s; -} -inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_eskeysig() const { - return _impl_.eskeysig_.Get(); -} -inline void ClientPayload_DevicePairingRegistrationData::_internal_set_eskeysig(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.eskeysig_.Set(value, GetArenaForAllocation()); -} -inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_eskeysig() { - _impl_._has_bits_[0] |= 0x00000020u; - return _impl_.eskeysig_.Mutable(GetArenaForAllocation()); -} -inline std::string* ClientPayload_DevicePairingRegistrationData::release_eskeysig() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.eSkeySig) - if (!_internal_has_eskeysig()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000020u; - auto* p = _impl_.eskeysig_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.eskeysig_.IsDefault()) { - _impl_.eskeysig_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ClientPayload_DevicePairingRegistrationData::set_allocated_eskeysig(std::string* eskeysig) { - if (eskeysig != nullptr) { - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - _impl_.eskeysig_.SetAllocated(eskeysig, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.eskeysig_.IsDefault()) { - _impl_.eskeysig_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.eSkeySig) -} - -// optional bytes buildHash = 7; -inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_buildhash() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool ClientPayload_DevicePairingRegistrationData::has_buildhash() const { - return _internal_has_buildhash(); -} -inline void ClientPayload_DevicePairingRegistrationData::clear_buildhash() { - _impl_.buildhash_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline const std::string& ClientPayload_DevicePairingRegistrationData::buildhash() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.buildHash) - return _internal_buildhash(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ClientPayload_DevicePairingRegistrationData::set_buildhash(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.buildhash_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.buildHash) -} -inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_buildhash() { - std::string* _s = _internal_mutable_buildhash(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.buildHash) - return _s; -} -inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_buildhash() const { - return _impl_.buildhash_.Get(); -} -inline void ClientPayload_DevicePairingRegistrationData::_internal_set_buildhash(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.buildhash_.Set(value, GetArenaForAllocation()); -} -inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_buildhash() { - _impl_._has_bits_[0] |= 0x00000040u; - return _impl_.buildhash_.Mutable(GetArenaForAllocation()); -} -inline std::string* ClientPayload_DevicePairingRegistrationData::release_buildhash() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.buildHash) - if (!_internal_has_buildhash()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000040u; - auto* p = _impl_.buildhash_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.buildhash_.IsDefault()) { - _impl_.buildhash_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ClientPayload_DevicePairingRegistrationData::set_allocated_buildhash(std::string* buildhash) { - if (buildhash != nullptr) { - _impl_._has_bits_[0] |= 0x00000040u; - } else { - _impl_._has_bits_[0] &= ~0x00000040u; - } - _impl_.buildhash_.SetAllocated(buildhash, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.buildhash_.IsDefault()) { - _impl_.buildhash_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.buildHash) -} - -// optional bytes deviceProps = 8; -inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_deviceprops() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - return value; -} -inline bool ClientPayload_DevicePairingRegistrationData::has_deviceprops() const { - return _internal_has_deviceprops(); -} -inline void ClientPayload_DevicePairingRegistrationData::clear_deviceprops() { - _impl_.deviceprops_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline const std::string& ClientPayload_DevicePairingRegistrationData::deviceprops() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.deviceProps) - return _internal_deviceprops(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ClientPayload_DevicePairingRegistrationData::set_deviceprops(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.deviceprops_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.deviceProps) -} -inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_deviceprops() { - std::string* _s = _internal_mutable_deviceprops(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.deviceProps) - return _s; -} -inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_deviceprops() const { - return _impl_.deviceprops_.Get(); -} -inline void ClientPayload_DevicePairingRegistrationData::_internal_set_deviceprops(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.deviceprops_.Set(value, GetArenaForAllocation()); -} -inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_deviceprops() { - _impl_._has_bits_[0] |= 0x00000080u; - return _impl_.deviceprops_.Mutable(GetArenaForAllocation()); -} -inline std::string* ClientPayload_DevicePairingRegistrationData::release_deviceprops() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.deviceProps) - if (!_internal_has_deviceprops()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000080u; - auto* p = _impl_.deviceprops_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.deviceprops_.IsDefault()) { - _impl_.deviceprops_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ClientPayload_DevicePairingRegistrationData::set_allocated_deviceprops(std::string* deviceprops) { - if (deviceprops != nullptr) { - _impl_._has_bits_[0] |= 0x00000080u; - } else { - _impl_._has_bits_[0] &= ~0x00000080u; - } - _impl_.deviceprops_.SetAllocated(deviceprops, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.deviceprops_.IsDefault()) { - _impl_.deviceprops_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.deviceProps) -} - -// ------------------------------------------------------------------- - -// ClientPayload_UserAgent_AppVersion - -// optional uint32 primary = 1; -inline bool ClientPayload_UserAgent_AppVersion::_internal_has_primary() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool ClientPayload_UserAgent_AppVersion::has_primary() const { - return _internal_has_primary(); -} -inline void ClientPayload_UserAgent_AppVersion::clear_primary() { - _impl_.primary_ = 0u; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline uint32_t ClientPayload_UserAgent_AppVersion::_internal_primary() const { - return _impl_.primary_; -} -inline uint32_t ClientPayload_UserAgent_AppVersion::primary() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.AppVersion.primary) - return _internal_primary(); -} -inline void ClientPayload_UserAgent_AppVersion::_internal_set_primary(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.primary_ = value; -} -inline void ClientPayload_UserAgent_AppVersion::set_primary(uint32_t value) { - _internal_set_primary(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.AppVersion.primary) -} - -// optional uint32 secondary = 2; -inline bool ClientPayload_UserAgent_AppVersion::_internal_has_secondary() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool ClientPayload_UserAgent_AppVersion::has_secondary() const { - return _internal_has_secondary(); -} -inline void ClientPayload_UserAgent_AppVersion::clear_secondary() { - _impl_.secondary_ = 0u; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline uint32_t ClientPayload_UserAgent_AppVersion::_internal_secondary() const { - return _impl_.secondary_; -} -inline uint32_t ClientPayload_UserAgent_AppVersion::secondary() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.AppVersion.secondary) - return _internal_secondary(); -} -inline void ClientPayload_UserAgent_AppVersion::_internal_set_secondary(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.secondary_ = value; -} -inline void ClientPayload_UserAgent_AppVersion::set_secondary(uint32_t value) { - _internal_set_secondary(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.AppVersion.secondary) -} - -// optional uint32 tertiary = 3; -inline bool ClientPayload_UserAgent_AppVersion::_internal_has_tertiary() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool ClientPayload_UserAgent_AppVersion::has_tertiary() const { - return _internal_has_tertiary(); -} -inline void ClientPayload_UserAgent_AppVersion::clear_tertiary() { - _impl_.tertiary_ = 0u; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline uint32_t ClientPayload_UserAgent_AppVersion::_internal_tertiary() const { - return _impl_.tertiary_; -} -inline uint32_t ClientPayload_UserAgent_AppVersion::tertiary() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.AppVersion.tertiary) - return _internal_tertiary(); -} -inline void ClientPayload_UserAgent_AppVersion::_internal_set_tertiary(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.tertiary_ = value; -} -inline void ClientPayload_UserAgent_AppVersion::set_tertiary(uint32_t value) { - _internal_set_tertiary(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.AppVersion.tertiary) -} - -// optional uint32 quaternary = 4; -inline bool ClientPayload_UserAgent_AppVersion::_internal_has_quaternary() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool ClientPayload_UserAgent_AppVersion::has_quaternary() const { - return _internal_has_quaternary(); -} -inline void ClientPayload_UserAgent_AppVersion::clear_quaternary() { - _impl_.quaternary_ = 0u; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline uint32_t ClientPayload_UserAgent_AppVersion::_internal_quaternary() const { - return _impl_.quaternary_; -} -inline uint32_t ClientPayload_UserAgent_AppVersion::quaternary() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.AppVersion.quaternary) - return _internal_quaternary(); -} -inline void ClientPayload_UserAgent_AppVersion::_internal_set_quaternary(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.quaternary_ = value; -} -inline void ClientPayload_UserAgent_AppVersion::set_quaternary(uint32_t value) { - _internal_set_quaternary(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.AppVersion.quaternary) -} - -// optional uint32 quinary = 5; -inline bool ClientPayload_UserAgent_AppVersion::_internal_has_quinary() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool ClientPayload_UserAgent_AppVersion::has_quinary() const { - return _internal_has_quinary(); -} -inline void ClientPayload_UserAgent_AppVersion::clear_quinary() { - _impl_.quinary_ = 0u; - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline uint32_t ClientPayload_UserAgent_AppVersion::_internal_quinary() const { - return _impl_.quinary_; -} -inline uint32_t ClientPayload_UserAgent_AppVersion::quinary() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.AppVersion.quinary) - return _internal_quinary(); -} -inline void ClientPayload_UserAgent_AppVersion::_internal_set_quinary(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.quinary_ = value; -} -inline void ClientPayload_UserAgent_AppVersion::set_quinary(uint32_t value) { - _internal_set_quinary(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.AppVersion.quinary) -} - -// ------------------------------------------------------------------- - -// ClientPayload_UserAgent - -// optional .proto.ClientPayload.UserAgent.Platform platform = 1; -inline bool ClientPayload_UserAgent::_internal_has_platform() const { - bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; - return value; -} -inline bool ClientPayload_UserAgent::has_platform() const { - return _internal_has_platform(); -} -inline void ClientPayload_UserAgent::clear_platform() { - _impl_.platform_ = 0; - _impl_._has_bits_[0] &= ~0x00000800u; -} -inline ::proto::ClientPayload_UserAgent_Platform ClientPayload_UserAgent::_internal_platform() const { - return static_cast< ::proto::ClientPayload_UserAgent_Platform >(_impl_.platform_); -} -inline ::proto::ClientPayload_UserAgent_Platform ClientPayload_UserAgent::platform() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.platform) - return _internal_platform(); -} -inline void ClientPayload_UserAgent::_internal_set_platform(::proto::ClientPayload_UserAgent_Platform value) { - assert(::proto::ClientPayload_UserAgent_Platform_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000800u; - _impl_.platform_ = value; -} -inline void ClientPayload_UserAgent::set_platform(::proto::ClientPayload_UserAgent_Platform value) { - _internal_set_platform(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.platform) -} - -// optional .proto.ClientPayload.UserAgent.AppVersion appVersion = 2; -inline bool ClientPayload_UserAgent::_internal_has_appversion() const { - bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; - PROTOBUF_ASSUME(!value || _impl_.appversion_ != nullptr); - return value; -} -inline bool ClientPayload_UserAgent::has_appversion() const { - return _internal_has_appversion(); -} -inline void ClientPayload_UserAgent::clear_appversion() { - if (_impl_.appversion_ != nullptr) _impl_.appversion_->Clear(); - _impl_._has_bits_[0] &= ~0x00000400u; -} -inline const ::proto::ClientPayload_UserAgent_AppVersion& ClientPayload_UserAgent::_internal_appversion() const { - const ::proto::ClientPayload_UserAgent_AppVersion* p = _impl_.appversion_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ClientPayload_UserAgent_AppVersion_default_instance_); -} -inline const ::proto::ClientPayload_UserAgent_AppVersion& ClientPayload_UserAgent::appversion() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.appVersion) - return _internal_appversion(); -} -inline void ClientPayload_UserAgent::unsafe_arena_set_allocated_appversion( - ::proto::ClientPayload_UserAgent_AppVersion* appversion) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.appversion_); - } - _impl_.appversion_ = appversion; - if (appversion) { - _impl_._has_bits_[0] |= 0x00000400u; - } else { - _impl_._has_bits_[0] &= ~0x00000400u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ClientPayload.UserAgent.appVersion) -} -inline ::proto::ClientPayload_UserAgent_AppVersion* ClientPayload_UserAgent::release_appversion() { - _impl_._has_bits_[0] &= ~0x00000400u; - ::proto::ClientPayload_UserAgent_AppVersion* temp = _impl_.appversion_; - _impl_.appversion_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ClientPayload_UserAgent_AppVersion* ClientPayload_UserAgent::unsafe_arena_release_appversion() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.appVersion) - _impl_._has_bits_[0] &= ~0x00000400u; - ::proto::ClientPayload_UserAgent_AppVersion* temp = _impl_.appversion_; - _impl_.appversion_ = nullptr; - return temp; -} -inline ::proto::ClientPayload_UserAgent_AppVersion* ClientPayload_UserAgent::_internal_mutable_appversion() { - _impl_._has_bits_[0] |= 0x00000400u; - if (_impl_.appversion_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ClientPayload_UserAgent_AppVersion>(GetArenaForAllocation()); - _impl_.appversion_ = p; - } - return _impl_.appversion_; -} -inline ::proto::ClientPayload_UserAgent_AppVersion* ClientPayload_UserAgent::mutable_appversion() { - ::proto::ClientPayload_UserAgent_AppVersion* _msg = _internal_mutable_appversion(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.appVersion) - return _msg; -} -inline void ClientPayload_UserAgent::set_allocated_appversion(::proto::ClientPayload_UserAgent_AppVersion* appversion) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.appversion_; - } - if (appversion) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(appversion); - if (message_arena != submessage_arena) { - appversion = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, appversion, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000400u; - } else { - _impl_._has_bits_[0] &= ~0x00000400u; - } - _impl_.appversion_ = appversion; - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.appVersion) -} - -// optional string mcc = 3; -inline bool ClientPayload_UserAgent::_internal_has_mcc() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool ClientPayload_UserAgent::has_mcc() const { - return _internal_has_mcc(); -} -inline void ClientPayload_UserAgent::clear_mcc() { - _impl_.mcc_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& ClientPayload_UserAgent::mcc() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.mcc) - return _internal_mcc(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ClientPayload_UserAgent::set_mcc(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.mcc_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.mcc) -} -inline std::string* ClientPayload_UserAgent::mutable_mcc() { - std::string* _s = _internal_mutable_mcc(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.mcc) - return _s; -} -inline const std::string& ClientPayload_UserAgent::_internal_mcc() const { - return _impl_.mcc_.Get(); -} -inline void ClientPayload_UserAgent::_internal_set_mcc(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.mcc_.Set(value, GetArenaForAllocation()); -} -inline std::string* ClientPayload_UserAgent::_internal_mutable_mcc() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.mcc_.Mutable(GetArenaForAllocation()); -} -inline std::string* ClientPayload_UserAgent::release_mcc() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.mcc) - if (!_internal_has_mcc()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.mcc_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mcc_.IsDefault()) { - _impl_.mcc_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ClientPayload_UserAgent::set_allocated_mcc(std::string* mcc) { - if (mcc != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.mcc_.SetAllocated(mcc, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mcc_.IsDefault()) { - _impl_.mcc_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.mcc) -} - -// optional string mnc = 4; -inline bool ClientPayload_UserAgent::_internal_has_mnc() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool ClientPayload_UserAgent::has_mnc() const { - return _internal_has_mnc(); -} -inline void ClientPayload_UserAgent::clear_mnc() { - _impl_.mnc_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& ClientPayload_UserAgent::mnc() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.mnc) - return _internal_mnc(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ClientPayload_UserAgent::set_mnc(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.mnc_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.mnc) -} -inline std::string* ClientPayload_UserAgent::mutable_mnc() { - std::string* _s = _internal_mutable_mnc(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.mnc) - return _s; -} -inline const std::string& ClientPayload_UserAgent::_internal_mnc() const { - return _impl_.mnc_.Get(); -} -inline void ClientPayload_UserAgent::_internal_set_mnc(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.mnc_.Set(value, GetArenaForAllocation()); -} -inline std::string* ClientPayload_UserAgent::_internal_mutable_mnc() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.mnc_.Mutable(GetArenaForAllocation()); -} -inline std::string* ClientPayload_UserAgent::release_mnc() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.mnc) - if (!_internal_has_mnc()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.mnc_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mnc_.IsDefault()) { - _impl_.mnc_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ClientPayload_UserAgent::set_allocated_mnc(std::string* mnc) { - if (mnc != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.mnc_.SetAllocated(mnc, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mnc_.IsDefault()) { - _impl_.mnc_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.mnc) -} - -// optional string osVersion = 5; -inline bool ClientPayload_UserAgent::_internal_has_osversion() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool ClientPayload_UserAgent::has_osversion() const { - return _internal_has_osversion(); -} -inline void ClientPayload_UserAgent::clear_osversion() { - _impl_.osversion_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& ClientPayload_UserAgent::osversion() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.osVersion) - return _internal_osversion(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ClientPayload_UserAgent::set_osversion(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.osversion_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.osVersion) -} -inline std::string* ClientPayload_UserAgent::mutable_osversion() { - std::string* _s = _internal_mutable_osversion(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.osVersion) - return _s; -} -inline const std::string& ClientPayload_UserAgent::_internal_osversion() const { - return _impl_.osversion_.Get(); -} -inline void ClientPayload_UserAgent::_internal_set_osversion(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.osversion_.Set(value, GetArenaForAllocation()); -} -inline std::string* ClientPayload_UserAgent::_internal_mutable_osversion() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.osversion_.Mutable(GetArenaForAllocation()); -} -inline std::string* ClientPayload_UserAgent::release_osversion() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.osVersion) - if (!_internal_has_osversion()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.osversion_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.osversion_.IsDefault()) { - _impl_.osversion_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ClientPayload_UserAgent::set_allocated_osversion(std::string* osversion) { - if (osversion != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.osversion_.SetAllocated(osversion, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.osversion_.IsDefault()) { - _impl_.osversion_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.osVersion) -} - -// optional string manufacturer = 6; -inline bool ClientPayload_UserAgent::_internal_has_manufacturer() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool ClientPayload_UserAgent::has_manufacturer() const { - return _internal_has_manufacturer(); -} -inline void ClientPayload_UserAgent::clear_manufacturer() { - _impl_.manufacturer_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const std::string& ClientPayload_UserAgent::manufacturer() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.manufacturer) - return _internal_manufacturer(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ClientPayload_UserAgent::set_manufacturer(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.manufacturer_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.manufacturer) -} -inline std::string* ClientPayload_UserAgent::mutable_manufacturer() { - std::string* _s = _internal_mutable_manufacturer(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.manufacturer) - return _s; -} -inline const std::string& ClientPayload_UserAgent::_internal_manufacturer() const { - return _impl_.manufacturer_.Get(); -} -inline void ClientPayload_UserAgent::_internal_set_manufacturer(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.manufacturer_.Set(value, GetArenaForAllocation()); -} -inline std::string* ClientPayload_UserAgent::_internal_mutable_manufacturer() { - _impl_._has_bits_[0] |= 0x00000008u; - return _impl_.manufacturer_.Mutable(GetArenaForAllocation()); -} -inline std::string* ClientPayload_UserAgent::release_manufacturer() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.manufacturer) - if (!_internal_has_manufacturer()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000008u; - auto* p = _impl_.manufacturer_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.manufacturer_.IsDefault()) { - _impl_.manufacturer_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ClientPayload_UserAgent::set_allocated_manufacturer(std::string* manufacturer) { - if (manufacturer != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.manufacturer_.SetAllocated(manufacturer, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.manufacturer_.IsDefault()) { - _impl_.manufacturer_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.manufacturer) -} - -// optional string device = 7; -inline bool ClientPayload_UserAgent::_internal_has_device() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool ClientPayload_UserAgent::has_device() const { - return _internal_has_device(); -} -inline void ClientPayload_UserAgent::clear_device() { - _impl_.device_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const std::string& ClientPayload_UserAgent::device() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.device) - return _internal_device(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ClientPayload_UserAgent::set_device(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.device_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.device) -} -inline std::string* ClientPayload_UserAgent::mutable_device() { - std::string* _s = _internal_mutable_device(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.device) - return _s; -} -inline const std::string& ClientPayload_UserAgent::_internal_device() const { - return _impl_.device_.Get(); -} -inline void ClientPayload_UserAgent::_internal_set_device(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.device_.Set(value, GetArenaForAllocation()); -} -inline std::string* ClientPayload_UserAgent::_internal_mutable_device() { - _impl_._has_bits_[0] |= 0x00000010u; - return _impl_.device_.Mutable(GetArenaForAllocation()); -} -inline std::string* ClientPayload_UserAgent::release_device() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.device) - if (!_internal_has_device()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000010u; - auto* p = _impl_.device_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.device_.IsDefault()) { - _impl_.device_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ClientPayload_UserAgent::set_allocated_device(std::string* device) { - if (device != nullptr) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.device_.SetAllocated(device, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.device_.IsDefault()) { - _impl_.device_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.device) -} - -// optional string osBuildNumber = 8; -inline bool ClientPayload_UserAgent::_internal_has_osbuildnumber() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool ClientPayload_UserAgent::has_osbuildnumber() const { - return _internal_has_osbuildnumber(); -} -inline void ClientPayload_UserAgent::clear_osbuildnumber() { - _impl_.osbuildnumber_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline const std::string& ClientPayload_UserAgent::osbuildnumber() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.osBuildNumber) - return _internal_osbuildnumber(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ClientPayload_UserAgent::set_osbuildnumber(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.osbuildnumber_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.osBuildNumber) -} -inline std::string* ClientPayload_UserAgent::mutable_osbuildnumber() { - std::string* _s = _internal_mutable_osbuildnumber(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.osBuildNumber) - return _s; -} -inline const std::string& ClientPayload_UserAgent::_internal_osbuildnumber() const { - return _impl_.osbuildnumber_.Get(); -} -inline void ClientPayload_UserAgent::_internal_set_osbuildnumber(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.osbuildnumber_.Set(value, GetArenaForAllocation()); -} -inline std::string* ClientPayload_UserAgent::_internal_mutable_osbuildnumber() { - _impl_._has_bits_[0] |= 0x00000020u; - return _impl_.osbuildnumber_.Mutable(GetArenaForAllocation()); -} -inline std::string* ClientPayload_UserAgent::release_osbuildnumber() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.osBuildNumber) - if (!_internal_has_osbuildnumber()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000020u; - auto* p = _impl_.osbuildnumber_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.osbuildnumber_.IsDefault()) { - _impl_.osbuildnumber_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ClientPayload_UserAgent::set_allocated_osbuildnumber(std::string* osbuildnumber) { - if (osbuildnumber != nullptr) { - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - _impl_.osbuildnumber_.SetAllocated(osbuildnumber, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.osbuildnumber_.IsDefault()) { - _impl_.osbuildnumber_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.osBuildNumber) -} - -// optional string phoneId = 9; -inline bool ClientPayload_UserAgent::_internal_has_phoneid() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool ClientPayload_UserAgent::has_phoneid() const { - return _internal_has_phoneid(); -} -inline void ClientPayload_UserAgent::clear_phoneid() { - _impl_.phoneid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline const std::string& ClientPayload_UserAgent::phoneid() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.phoneId) - return _internal_phoneid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ClientPayload_UserAgent::set_phoneid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.phoneid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.phoneId) -} -inline std::string* ClientPayload_UserAgent::mutable_phoneid() { - std::string* _s = _internal_mutable_phoneid(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.phoneId) - return _s; -} -inline const std::string& ClientPayload_UserAgent::_internal_phoneid() const { - return _impl_.phoneid_.Get(); -} -inline void ClientPayload_UserAgent::_internal_set_phoneid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.phoneid_.Set(value, GetArenaForAllocation()); -} -inline std::string* ClientPayload_UserAgent::_internal_mutable_phoneid() { - _impl_._has_bits_[0] |= 0x00000040u; - return _impl_.phoneid_.Mutable(GetArenaForAllocation()); -} -inline std::string* ClientPayload_UserAgent::release_phoneid() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.phoneId) - if (!_internal_has_phoneid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000040u; - auto* p = _impl_.phoneid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.phoneid_.IsDefault()) { - _impl_.phoneid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ClientPayload_UserAgent::set_allocated_phoneid(std::string* phoneid) { - if (phoneid != nullptr) { - _impl_._has_bits_[0] |= 0x00000040u; - } else { - _impl_._has_bits_[0] &= ~0x00000040u; - } - _impl_.phoneid_.SetAllocated(phoneid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.phoneid_.IsDefault()) { - _impl_.phoneid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.phoneId) -} - -// optional .proto.ClientPayload.UserAgent.ReleaseChannel releaseChannel = 10; -inline bool ClientPayload_UserAgent::_internal_has_releasechannel() const { - bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; - return value; -} -inline bool ClientPayload_UserAgent::has_releasechannel() const { - return _internal_has_releasechannel(); -} -inline void ClientPayload_UserAgent::clear_releasechannel() { - _impl_.releasechannel_ = 0; - _impl_._has_bits_[0] &= ~0x00001000u; -} -inline ::proto::ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent::_internal_releasechannel() const { - return static_cast< ::proto::ClientPayload_UserAgent_ReleaseChannel >(_impl_.releasechannel_); -} -inline ::proto::ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent::releasechannel() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.releaseChannel) - return _internal_releasechannel(); -} -inline void ClientPayload_UserAgent::_internal_set_releasechannel(::proto::ClientPayload_UserAgent_ReleaseChannel value) { - assert(::proto::ClientPayload_UserAgent_ReleaseChannel_IsValid(value)); - _impl_._has_bits_[0] |= 0x00001000u; - _impl_.releasechannel_ = value; -} -inline void ClientPayload_UserAgent::set_releasechannel(::proto::ClientPayload_UserAgent_ReleaseChannel value) { - _internal_set_releasechannel(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.releaseChannel) -} - -// optional string localeLanguageIso6391 = 11; -inline bool ClientPayload_UserAgent::_internal_has_localelanguageiso6391() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - return value; -} -inline bool ClientPayload_UserAgent::has_localelanguageiso6391() const { - return _internal_has_localelanguageiso6391(); -} -inline void ClientPayload_UserAgent::clear_localelanguageiso6391() { - _impl_.localelanguageiso6391_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline const std::string& ClientPayload_UserAgent::localelanguageiso6391() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.localeLanguageIso6391) - return _internal_localelanguageiso6391(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ClientPayload_UserAgent::set_localelanguageiso6391(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.localelanguageiso6391_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.localeLanguageIso6391) -} -inline std::string* ClientPayload_UserAgent::mutable_localelanguageiso6391() { - std::string* _s = _internal_mutable_localelanguageiso6391(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.localeLanguageIso6391) - return _s; -} -inline const std::string& ClientPayload_UserAgent::_internal_localelanguageiso6391() const { - return _impl_.localelanguageiso6391_.Get(); -} -inline void ClientPayload_UserAgent::_internal_set_localelanguageiso6391(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.localelanguageiso6391_.Set(value, GetArenaForAllocation()); -} -inline std::string* ClientPayload_UserAgent::_internal_mutable_localelanguageiso6391() { - _impl_._has_bits_[0] |= 0x00000080u; - return _impl_.localelanguageiso6391_.Mutable(GetArenaForAllocation()); -} -inline std::string* ClientPayload_UserAgent::release_localelanguageiso6391() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.localeLanguageIso6391) - if (!_internal_has_localelanguageiso6391()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000080u; - auto* p = _impl_.localelanguageiso6391_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.localelanguageiso6391_.IsDefault()) { - _impl_.localelanguageiso6391_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ClientPayload_UserAgent::set_allocated_localelanguageiso6391(std::string* localelanguageiso6391) { - if (localelanguageiso6391 != nullptr) { - _impl_._has_bits_[0] |= 0x00000080u; - } else { - _impl_._has_bits_[0] &= ~0x00000080u; - } - _impl_.localelanguageiso6391_.SetAllocated(localelanguageiso6391, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.localelanguageiso6391_.IsDefault()) { - _impl_.localelanguageiso6391_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.localeLanguageIso6391) -} - -// optional string localeCountryIso31661Alpha2 = 12; -inline bool ClientPayload_UserAgent::_internal_has_localecountryiso31661alpha2() const { - bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; - return value; -} -inline bool ClientPayload_UserAgent::has_localecountryiso31661alpha2() const { - return _internal_has_localecountryiso31661alpha2(); -} -inline void ClientPayload_UserAgent::clear_localecountryiso31661alpha2() { - _impl_.localecountryiso31661alpha2_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000100u; -} -inline const std::string& ClientPayload_UserAgent::localecountryiso31661alpha2() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.localeCountryIso31661Alpha2) - return _internal_localecountryiso31661alpha2(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ClientPayload_UserAgent::set_localecountryiso31661alpha2(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000100u; - _impl_.localecountryiso31661alpha2_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.localeCountryIso31661Alpha2) -} -inline std::string* ClientPayload_UserAgent::mutable_localecountryiso31661alpha2() { - std::string* _s = _internal_mutable_localecountryiso31661alpha2(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.localeCountryIso31661Alpha2) - return _s; -} -inline const std::string& ClientPayload_UserAgent::_internal_localecountryiso31661alpha2() const { - return _impl_.localecountryiso31661alpha2_.Get(); -} -inline void ClientPayload_UserAgent::_internal_set_localecountryiso31661alpha2(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000100u; - _impl_.localecountryiso31661alpha2_.Set(value, GetArenaForAllocation()); -} -inline std::string* ClientPayload_UserAgent::_internal_mutable_localecountryiso31661alpha2() { - _impl_._has_bits_[0] |= 0x00000100u; - return _impl_.localecountryiso31661alpha2_.Mutable(GetArenaForAllocation()); -} -inline std::string* ClientPayload_UserAgent::release_localecountryiso31661alpha2() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.localeCountryIso31661Alpha2) - if (!_internal_has_localecountryiso31661alpha2()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000100u; - auto* p = _impl_.localecountryiso31661alpha2_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.localecountryiso31661alpha2_.IsDefault()) { - _impl_.localecountryiso31661alpha2_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ClientPayload_UserAgent::set_allocated_localecountryiso31661alpha2(std::string* localecountryiso31661alpha2) { - if (localecountryiso31661alpha2 != nullptr) { - _impl_._has_bits_[0] |= 0x00000100u; - } else { - _impl_._has_bits_[0] &= ~0x00000100u; - } - _impl_.localecountryiso31661alpha2_.SetAllocated(localecountryiso31661alpha2, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.localecountryiso31661alpha2_.IsDefault()) { - _impl_.localecountryiso31661alpha2_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.localeCountryIso31661Alpha2) -} - -// optional string deviceBoard = 13; -inline bool ClientPayload_UserAgent::_internal_has_deviceboard() const { - bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; - return value; -} -inline bool ClientPayload_UserAgent::has_deviceboard() const { - return _internal_has_deviceboard(); -} -inline void ClientPayload_UserAgent::clear_deviceboard() { - _impl_.deviceboard_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000200u; -} -inline const std::string& ClientPayload_UserAgent::deviceboard() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.deviceBoard) - return _internal_deviceboard(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ClientPayload_UserAgent::set_deviceboard(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.deviceboard_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.deviceBoard) -} -inline std::string* ClientPayload_UserAgent::mutable_deviceboard() { - std::string* _s = _internal_mutable_deviceboard(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.deviceBoard) - return _s; -} -inline const std::string& ClientPayload_UserAgent::_internal_deviceboard() const { - return _impl_.deviceboard_.Get(); -} -inline void ClientPayload_UserAgent::_internal_set_deviceboard(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.deviceboard_.Set(value, GetArenaForAllocation()); -} -inline std::string* ClientPayload_UserAgent::_internal_mutable_deviceboard() { - _impl_._has_bits_[0] |= 0x00000200u; - return _impl_.deviceboard_.Mutable(GetArenaForAllocation()); -} -inline std::string* ClientPayload_UserAgent::release_deviceboard() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.deviceBoard) - if (!_internal_has_deviceboard()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000200u; - auto* p = _impl_.deviceboard_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.deviceboard_.IsDefault()) { - _impl_.deviceboard_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ClientPayload_UserAgent::set_allocated_deviceboard(std::string* deviceboard) { - if (deviceboard != nullptr) { - _impl_._has_bits_[0] |= 0x00000200u; - } else { - _impl_._has_bits_[0] &= ~0x00000200u; - } - _impl_.deviceboard_.SetAllocated(deviceboard, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.deviceboard_.IsDefault()) { - _impl_.deviceboard_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.deviceBoard) -} - -// ------------------------------------------------------------------- - -// ClientPayload_WebInfo_WebdPayload - -// optional bool usesParticipantInKey = 1; -inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_usesparticipantinkey() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool ClientPayload_WebInfo_WebdPayload::has_usesparticipantinkey() const { - return _internal_has_usesparticipantinkey(); -} -inline void ClientPayload_WebInfo_WebdPayload::clear_usesparticipantinkey() { - _impl_.usesparticipantinkey_ = false; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline bool ClientPayload_WebInfo_WebdPayload::_internal_usesparticipantinkey() const { - return _impl_.usesparticipantinkey_; -} -inline bool ClientPayload_WebInfo_WebdPayload::usesparticipantinkey() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.usesParticipantInKey) - return _internal_usesparticipantinkey(); -} -inline void ClientPayload_WebInfo_WebdPayload::_internal_set_usesparticipantinkey(bool value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.usesparticipantinkey_ = value; -} -inline void ClientPayload_WebInfo_WebdPayload::set_usesparticipantinkey(bool value) { - _internal_set_usesparticipantinkey(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.usesParticipantInKey) -} - -// optional bool supportsStarredMessages = 2; -inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportsstarredmessages() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool ClientPayload_WebInfo_WebdPayload::has_supportsstarredmessages() const { - return _internal_has_supportsstarredmessages(); -} -inline void ClientPayload_WebInfo_WebdPayload::clear_supportsstarredmessages() { - _impl_.supportsstarredmessages_ = false; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportsstarredmessages() const { - return _impl_.supportsstarredmessages_; -} -inline bool ClientPayload_WebInfo_WebdPayload::supportsstarredmessages() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsStarredMessages) - return _internal_supportsstarredmessages(); -} -inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportsstarredmessages(bool value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.supportsstarredmessages_ = value; -} -inline void ClientPayload_WebInfo_WebdPayload::set_supportsstarredmessages(bool value) { - _internal_set_supportsstarredmessages(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsStarredMessages) -} - -// optional bool supportsDocumentMessages = 3; -inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportsdocumentmessages() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool ClientPayload_WebInfo_WebdPayload::has_supportsdocumentmessages() const { - return _internal_has_supportsdocumentmessages(); -} -inline void ClientPayload_WebInfo_WebdPayload::clear_supportsdocumentmessages() { - _impl_.supportsdocumentmessages_ = false; - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportsdocumentmessages() const { - return _impl_.supportsdocumentmessages_; -} -inline bool ClientPayload_WebInfo_WebdPayload::supportsdocumentmessages() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsDocumentMessages) - return _internal_supportsdocumentmessages(); -} -inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportsdocumentmessages(bool value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.supportsdocumentmessages_ = value; -} -inline void ClientPayload_WebInfo_WebdPayload::set_supportsdocumentmessages(bool value) { - _internal_set_supportsdocumentmessages(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsDocumentMessages) -} - -// optional bool supportsUrlMessages = 4; -inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportsurlmessages() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool ClientPayload_WebInfo_WebdPayload::has_supportsurlmessages() const { - return _internal_has_supportsurlmessages(); -} -inline void ClientPayload_WebInfo_WebdPayload::clear_supportsurlmessages() { - _impl_.supportsurlmessages_ = false; - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportsurlmessages() const { - return _impl_.supportsurlmessages_; -} -inline bool ClientPayload_WebInfo_WebdPayload::supportsurlmessages() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsUrlMessages) - return _internal_supportsurlmessages(); -} -inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportsurlmessages(bool value) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.supportsurlmessages_ = value; -} -inline void ClientPayload_WebInfo_WebdPayload::set_supportsurlmessages(bool value) { - _internal_set_supportsurlmessages(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsUrlMessages) -} - -// optional bool supportsMediaRetry = 5; -inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportsmediaretry() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool ClientPayload_WebInfo_WebdPayload::has_supportsmediaretry() const { - return _internal_has_supportsmediaretry(); -} -inline void ClientPayload_WebInfo_WebdPayload::clear_supportsmediaretry() { - _impl_.supportsmediaretry_ = false; - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportsmediaretry() const { - return _impl_.supportsmediaretry_; -} -inline bool ClientPayload_WebInfo_WebdPayload::supportsmediaretry() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsMediaRetry) - return _internal_supportsmediaretry(); -} -inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportsmediaretry(bool value) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.supportsmediaretry_ = value; -} -inline void ClientPayload_WebInfo_WebdPayload::set_supportsmediaretry(bool value) { - _internal_set_supportsmediaretry(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsMediaRetry) -} - -// optional bool supportsE2EImage = 6; -inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportse2eimage() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - return value; -} -inline bool ClientPayload_WebInfo_WebdPayload::has_supportse2eimage() const { - return _internal_has_supportse2eimage(); -} -inline void ClientPayload_WebInfo_WebdPayload::clear_supportse2eimage() { - _impl_.supportse2eimage_ = false; - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportse2eimage() const { - return _impl_.supportse2eimage_; -} -inline bool ClientPayload_WebInfo_WebdPayload::supportse2eimage() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EImage) - return _internal_supportse2eimage(); -} -inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportse2eimage(bool value) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.supportse2eimage_ = value; -} -inline void ClientPayload_WebInfo_WebdPayload::set_supportse2eimage(bool value) { - _internal_set_supportse2eimage(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EImage) -} - -// optional bool supportsE2EVideo = 7; -inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportse2evideo() const { - bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; - return value; -} -inline bool ClientPayload_WebInfo_WebdPayload::has_supportse2evideo() const { - return _internal_has_supportse2evideo(); -} -inline void ClientPayload_WebInfo_WebdPayload::clear_supportse2evideo() { - _impl_.supportse2evideo_ = false; - _impl_._has_bits_[0] &= ~0x00000100u; -} -inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportse2evideo() const { - return _impl_.supportse2evideo_; -} -inline bool ClientPayload_WebInfo_WebdPayload::supportse2evideo() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EVideo) - return _internal_supportse2evideo(); -} -inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportse2evideo(bool value) { - _impl_._has_bits_[0] |= 0x00000100u; - _impl_.supportse2evideo_ = value; -} -inline void ClientPayload_WebInfo_WebdPayload::set_supportse2evideo(bool value) { - _internal_set_supportse2evideo(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EVideo) -} - -// optional bool supportsE2EAudio = 8; -inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportse2eaudio() const { - bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; - return value; -} -inline bool ClientPayload_WebInfo_WebdPayload::has_supportse2eaudio() const { - return _internal_has_supportse2eaudio(); -} -inline void ClientPayload_WebInfo_WebdPayload::clear_supportse2eaudio() { - _impl_.supportse2eaudio_ = false; - _impl_._has_bits_[0] &= ~0x00000200u; -} -inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportse2eaudio() const { - return _impl_.supportse2eaudio_; -} -inline bool ClientPayload_WebInfo_WebdPayload::supportse2eaudio() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EAudio) - return _internal_supportse2eaudio(); -} -inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportse2eaudio(bool value) { - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.supportse2eaudio_ = value; -} -inline void ClientPayload_WebInfo_WebdPayload::set_supportse2eaudio(bool value) { - _internal_set_supportse2eaudio(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EAudio) -} - -// optional bool supportsE2EDocument = 9; -inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportse2edocument() const { - bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; - return value; -} -inline bool ClientPayload_WebInfo_WebdPayload::has_supportse2edocument() const { - return _internal_has_supportse2edocument(); -} -inline void ClientPayload_WebInfo_WebdPayload::clear_supportse2edocument() { - _impl_.supportse2edocument_ = false; - _impl_._has_bits_[0] &= ~0x00000400u; -} -inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportse2edocument() const { - return _impl_.supportse2edocument_; -} -inline bool ClientPayload_WebInfo_WebdPayload::supportse2edocument() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EDocument) - return _internal_supportse2edocument(); -} -inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportse2edocument(bool value) { - _impl_._has_bits_[0] |= 0x00000400u; - _impl_.supportse2edocument_ = value; -} -inline void ClientPayload_WebInfo_WebdPayload::set_supportse2edocument(bool value) { - _internal_set_supportse2edocument(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EDocument) -} - -// optional string documentTypes = 10; -inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_documenttypes() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool ClientPayload_WebInfo_WebdPayload::has_documenttypes() const { - return _internal_has_documenttypes(); -} -inline void ClientPayload_WebInfo_WebdPayload::clear_documenttypes() { - _impl_.documenttypes_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& ClientPayload_WebInfo_WebdPayload::documenttypes() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.documentTypes) - return _internal_documenttypes(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ClientPayload_WebInfo_WebdPayload::set_documenttypes(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.documenttypes_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.documentTypes) -} -inline std::string* ClientPayload_WebInfo_WebdPayload::mutable_documenttypes() { - std::string* _s = _internal_mutable_documenttypes(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.WebInfo.WebdPayload.documentTypes) - return _s; -} -inline const std::string& ClientPayload_WebInfo_WebdPayload::_internal_documenttypes() const { - return _impl_.documenttypes_.Get(); -} -inline void ClientPayload_WebInfo_WebdPayload::_internal_set_documenttypes(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.documenttypes_.Set(value, GetArenaForAllocation()); -} -inline std::string* ClientPayload_WebInfo_WebdPayload::_internal_mutable_documenttypes() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.documenttypes_.Mutable(GetArenaForAllocation()); -} -inline std::string* ClientPayload_WebInfo_WebdPayload::release_documenttypes() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.WebInfo.WebdPayload.documentTypes) - if (!_internal_has_documenttypes()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.documenttypes_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.documenttypes_.IsDefault()) { - _impl_.documenttypes_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ClientPayload_WebInfo_WebdPayload::set_allocated_documenttypes(std::string* documenttypes) { - if (documenttypes != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.documenttypes_.SetAllocated(documenttypes, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.documenttypes_.IsDefault()) { - _impl_.documenttypes_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.WebInfo.WebdPayload.documentTypes) -} - -// optional bytes features = 11; -inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_features() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool ClientPayload_WebInfo_WebdPayload::has_features() const { - return _internal_has_features(); -} -inline void ClientPayload_WebInfo_WebdPayload::clear_features() { - _impl_.features_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& ClientPayload_WebInfo_WebdPayload::features() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.features) - return _internal_features(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ClientPayload_WebInfo_WebdPayload::set_features(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.features_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.features) -} -inline std::string* ClientPayload_WebInfo_WebdPayload::mutable_features() { - std::string* _s = _internal_mutable_features(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.WebInfo.WebdPayload.features) - return _s; -} -inline const std::string& ClientPayload_WebInfo_WebdPayload::_internal_features() const { - return _impl_.features_.Get(); -} -inline void ClientPayload_WebInfo_WebdPayload::_internal_set_features(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.features_.Set(value, GetArenaForAllocation()); -} -inline std::string* ClientPayload_WebInfo_WebdPayload::_internal_mutable_features() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.features_.Mutable(GetArenaForAllocation()); -} -inline std::string* ClientPayload_WebInfo_WebdPayload::release_features() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.WebInfo.WebdPayload.features) - if (!_internal_has_features()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.features_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.features_.IsDefault()) { - _impl_.features_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ClientPayload_WebInfo_WebdPayload::set_allocated_features(std::string* features) { - if (features != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.features_.SetAllocated(features, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.features_.IsDefault()) { - _impl_.features_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.WebInfo.WebdPayload.features) -} - -// ------------------------------------------------------------------- - -// ClientPayload_WebInfo - -// optional string refToken = 1; -inline bool ClientPayload_WebInfo::_internal_has_reftoken() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool ClientPayload_WebInfo::has_reftoken() const { - return _internal_has_reftoken(); -} -inline void ClientPayload_WebInfo::clear_reftoken() { - _impl_.reftoken_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& ClientPayload_WebInfo::reftoken() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.refToken) - return _internal_reftoken(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ClientPayload_WebInfo::set_reftoken(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.reftoken_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.refToken) -} -inline std::string* ClientPayload_WebInfo::mutable_reftoken() { - std::string* _s = _internal_mutable_reftoken(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.WebInfo.refToken) - return _s; -} -inline const std::string& ClientPayload_WebInfo::_internal_reftoken() const { - return _impl_.reftoken_.Get(); -} -inline void ClientPayload_WebInfo::_internal_set_reftoken(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.reftoken_.Set(value, GetArenaForAllocation()); -} -inline std::string* ClientPayload_WebInfo::_internal_mutable_reftoken() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.reftoken_.Mutable(GetArenaForAllocation()); -} -inline std::string* ClientPayload_WebInfo::release_reftoken() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.WebInfo.refToken) - if (!_internal_has_reftoken()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.reftoken_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.reftoken_.IsDefault()) { - _impl_.reftoken_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ClientPayload_WebInfo::set_allocated_reftoken(std::string* reftoken) { - if (reftoken != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.reftoken_.SetAllocated(reftoken, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.reftoken_.IsDefault()) { - _impl_.reftoken_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.WebInfo.refToken) -} - -// optional string version = 2; -inline bool ClientPayload_WebInfo::_internal_has_version() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool ClientPayload_WebInfo::has_version() const { - return _internal_has_version(); -} -inline void ClientPayload_WebInfo::clear_version() { - _impl_.version_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& ClientPayload_WebInfo::version() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.version) - return _internal_version(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ClientPayload_WebInfo::set_version(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.version_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.version) -} -inline std::string* ClientPayload_WebInfo::mutable_version() { - std::string* _s = _internal_mutable_version(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.WebInfo.version) - return _s; -} -inline const std::string& ClientPayload_WebInfo::_internal_version() const { - return _impl_.version_.Get(); -} -inline void ClientPayload_WebInfo::_internal_set_version(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.version_.Set(value, GetArenaForAllocation()); -} -inline std::string* ClientPayload_WebInfo::_internal_mutable_version() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.version_.Mutable(GetArenaForAllocation()); -} -inline std::string* ClientPayload_WebInfo::release_version() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.WebInfo.version) - if (!_internal_has_version()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.version_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.version_.IsDefault()) { - _impl_.version_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ClientPayload_WebInfo::set_allocated_version(std::string* version) { - if (version != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.version_.SetAllocated(version, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.version_.IsDefault()) { - _impl_.version_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.WebInfo.version) -} - -// optional .proto.ClientPayload.WebInfo.WebdPayload webdPayload = 3; -inline bool ClientPayload_WebInfo::_internal_has_webdpayload() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - PROTOBUF_ASSUME(!value || _impl_.webdpayload_ != nullptr); - return value; -} -inline bool ClientPayload_WebInfo::has_webdpayload() const { - return _internal_has_webdpayload(); -} -inline void ClientPayload_WebInfo::clear_webdpayload() { - if (_impl_.webdpayload_ != nullptr) _impl_.webdpayload_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const ::proto::ClientPayload_WebInfo_WebdPayload& ClientPayload_WebInfo::_internal_webdpayload() const { - const ::proto::ClientPayload_WebInfo_WebdPayload* p = _impl_.webdpayload_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ClientPayload_WebInfo_WebdPayload_default_instance_); -} -inline const ::proto::ClientPayload_WebInfo_WebdPayload& ClientPayload_WebInfo::webdpayload() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.webdPayload) - return _internal_webdpayload(); -} -inline void ClientPayload_WebInfo::unsafe_arena_set_allocated_webdpayload( - ::proto::ClientPayload_WebInfo_WebdPayload* webdpayload) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.webdpayload_); - } - _impl_.webdpayload_ = webdpayload; - if (webdpayload) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ClientPayload.WebInfo.webdPayload) -} -inline ::proto::ClientPayload_WebInfo_WebdPayload* ClientPayload_WebInfo::release_webdpayload() { - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::ClientPayload_WebInfo_WebdPayload* temp = _impl_.webdpayload_; - _impl_.webdpayload_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ClientPayload_WebInfo_WebdPayload* ClientPayload_WebInfo::unsafe_arena_release_webdpayload() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.WebInfo.webdPayload) - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::ClientPayload_WebInfo_WebdPayload* temp = _impl_.webdpayload_; - _impl_.webdpayload_ = nullptr; - return temp; -} -inline ::proto::ClientPayload_WebInfo_WebdPayload* ClientPayload_WebInfo::_internal_mutable_webdpayload() { - _impl_._has_bits_[0] |= 0x00000004u; - if (_impl_.webdpayload_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ClientPayload_WebInfo_WebdPayload>(GetArenaForAllocation()); - _impl_.webdpayload_ = p; - } - return _impl_.webdpayload_; -} -inline ::proto::ClientPayload_WebInfo_WebdPayload* ClientPayload_WebInfo::mutable_webdpayload() { - ::proto::ClientPayload_WebInfo_WebdPayload* _msg = _internal_mutable_webdpayload(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.WebInfo.webdPayload) - return _msg; -} -inline void ClientPayload_WebInfo::set_allocated_webdpayload(::proto::ClientPayload_WebInfo_WebdPayload* webdpayload) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.webdpayload_; - } - if (webdpayload) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(webdpayload); - if (message_arena != submessage_arena) { - webdpayload = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, webdpayload, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.webdpayload_ = webdpayload; - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.WebInfo.webdPayload) -} - -// optional .proto.ClientPayload.WebInfo.WebSubPlatform webSubPlatform = 4; -inline bool ClientPayload_WebInfo::_internal_has_websubplatform() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool ClientPayload_WebInfo::has_websubplatform() const { - return _internal_has_websubplatform(); -} -inline void ClientPayload_WebInfo::clear_websubplatform() { - _impl_.websubplatform_ = 0; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline ::proto::ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo::_internal_websubplatform() const { - return static_cast< ::proto::ClientPayload_WebInfo_WebSubPlatform >(_impl_.websubplatform_); -} -inline ::proto::ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo::websubplatform() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.webSubPlatform) - return _internal_websubplatform(); -} -inline void ClientPayload_WebInfo::_internal_set_websubplatform(::proto::ClientPayload_WebInfo_WebSubPlatform value) { - assert(::proto::ClientPayload_WebInfo_WebSubPlatform_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.websubplatform_ = value; -} -inline void ClientPayload_WebInfo::set_websubplatform(::proto::ClientPayload_WebInfo_WebSubPlatform value) { - _internal_set_websubplatform(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.webSubPlatform) -} - -// ------------------------------------------------------------------- - -// ClientPayload - -// optional uint64 username = 1; -inline bool ClientPayload::_internal_has_username() const { - bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; - return value; -} -inline bool ClientPayload::has_username() const { - return _internal_has_username(); -} -inline void ClientPayload::clear_username() { - _impl_.username_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000200u; -} -inline uint64_t ClientPayload::_internal_username() const { - return _impl_.username_; -} -inline uint64_t ClientPayload::username() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.username) - return _internal_username(); -} -inline void ClientPayload::_internal_set_username(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.username_ = value; -} -inline void ClientPayload::set_username(uint64_t value) { - _internal_set_username(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.username) -} - -// optional bool passive = 3; -inline bool ClientPayload::_internal_has_passive() const { - bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0; - return value; -} -inline bool ClientPayload::has_passive() const { - return _internal_has_passive(); -} -inline void ClientPayload::clear_passive() { - _impl_.passive_ = false; - _impl_._has_bits_[0] &= ~0x00004000u; -} -inline bool ClientPayload::_internal_passive() const { - return _impl_.passive_; -} -inline bool ClientPayload::passive() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.passive) - return _internal_passive(); -} -inline void ClientPayload::_internal_set_passive(bool value) { - _impl_._has_bits_[0] |= 0x00004000u; - _impl_.passive_ = value; -} -inline void ClientPayload::set_passive(bool value) { - _internal_set_passive(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.passive) -} - -// optional .proto.ClientPayload.UserAgent userAgent = 5; -inline bool ClientPayload::_internal_has_useragent() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - PROTOBUF_ASSUME(!value || _impl_.useragent_ != nullptr); - return value; -} -inline bool ClientPayload::has_useragent() const { - return _internal_has_useragent(); -} -inline void ClientPayload::clear_useragent() { - if (_impl_.useragent_ != nullptr) _impl_.useragent_->Clear(); - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline const ::proto::ClientPayload_UserAgent& ClientPayload::_internal_useragent() const { - const ::proto::ClientPayload_UserAgent* p = _impl_.useragent_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ClientPayload_UserAgent_default_instance_); -} -inline const ::proto::ClientPayload_UserAgent& ClientPayload::useragent() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.userAgent) - return _internal_useragent(); -} -inline void ClientPayload::unsafe_arena_set_allocated_useragent( - ::proto::ClientPayload_UserAgent* useragent) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.useragent_); - } - _impl_.useragent_ = useragent; - if (useragent) { - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ClientPayload.userAgent) -} -inline ::proto::ClientPayload_UserAgent* ClientPayload::release_useragent() { - _impl_._has_bits_[0] &= ~0x00000020u; - ::proto::ClientPayload_UserAgent* temp = _impl_.useragent_; - _impl_.useragent_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ClientPayload_UserAgent* ClientPayload::unsafe_arena_release_useragent() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.userAgent) - _impl_._has_bits_[0] &= ~0x00000020u; - ::proto::ClientPayload_UserAgent* temp = _impl_.useragent_; - _impl_.useragent_ = nullptr; - return temp; -} -inline ::proto::ClientPayload_UserAgent* ClientPayload::_internal_mutable_useragent() { - _impl_._has_bits_[0] |= 0x00000020u; - if (_impl_.useragent_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ClientPayload_UserAgent>(GetArenaForAllocation()); - _impl_.useragent_ = p; - } - return _impl_.useragent_; -} -inline ::proto::ClientPayload_UserAgent* ClientPayload::mutable_useragent() { - ::proto::ClientPayload_UserAgent* _msg = _internal_mutable_useragent(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.userAgent) - return _msg; -} -inline void ClientPayload::set_allocated_useragent(::proto::ClientPayload_UserAgent* useragent) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.useragent_; - } - if (useragent) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(useragent); - if (message_arena != submessage_arena) { - useragent = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, useragent, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - _impl_.useragent_ = useragent; - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.userAgent) -} - -// optional .proto.ClientPayload.WebInfo webInfo = 6; -inline bool ClientPayload::_internal_has_webinfo() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - PROTOBUF_ASSUME(!value || _impl_.webinfo_ != nullptr); - return value; -} -inline bool ClientPayload::has_webinfo() const { - return _internal_has_webinfo(); -} -inline void ClientPayload::clear_webinfo() { - if (_impl_.webinfo_ != nullptr) _impl_.webinfo_->Clear(); - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline const ::proto::ClientPayload_WebInfo& ClientPayload::_internal_webinfo() const { - const ::proto::ClientPayload_WebInfo* p = _impl_.webinfo_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ClientPayload_WebInfo_default_instance_); -} -inline const ::proto::ClientPayload_WebInfo& ClientPayload::webinfo() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.webInfo) - return _internal_webinfo(); -} -inline void ClientPayload::unsafe_arena_set_allocated_webinfo( - ::proto::ClientPayload_WebInfo* webinfo) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.webinfo_); - } - _impl_.webinfo_ = webinfo; - if (webinfo) { - _impl_._has_bits_[0] |= 0x00000040u; - } else { - _impl_._has_bits_[0] &= ~0x00000040u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ClientPayload.webInfo) -} -inline ::proto::ClientPayload_WebInfo* ClientPayload::release_webinfo() { - _impl_._has_bits_[0] &= ~0x00000040u; - ::proto::ClientPayload_WebInfo* temp = _impl_.webinfo_; - _impl_.webinfo_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ClientPayload_WebInfo* ClientPayload::unsafe_arena_release_webinfo() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.webInfo) - _impl_._has_bits_[0] &= ~0x00000040u; - ::proto::ClientPayload_WebInfo* temp = _impl_.webinfo_; - _impl_.webinfo_ = nullptr; - return temp; -} -inline ::proto::ClientPayload_WebInfo* ClientPayload::_internal_mutable_webinfo() { - _impl_._has_bits_[0] |= 0x00000040u; - if (_impl_.webinfo_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ClientPayload_WebInfo>(GetArenaForAllocation()); - _impl_.webinfo_ = p; - } - return _impl_.webinfo_; -} -inline ::proto::ClientPayload_WebInfo* ClientPayload::mutable_webinfo() { - ::proto::ClientPayload_WebInfo* _msg = _internal_mutable_webinfo(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.webInfo) - return _msg; -} -inline void ClientPayload::set_allocated_webinfo(::proto::ClientPayload_WebInfo* webinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.webinfo_; - } - if (webinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(webinfo); - if (message_arena != submessage_arena) { - webinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, webinfo, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000040u; - } else { - _impl_._has_bits_[0] &= ~0x00000040u; - } - _impl_.webinfo_ = webinfo; - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.webInfo) -} - -// optional string pushName = 7; -inline bool ClientPayload::_internal_has_pushname() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool ClientPayload::has_pushname() const { - return _internal_has_pushname(); -} -inline void ClientPayload::clear_pushname() { - _impl_.pushname_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& ClientPayload::pushname() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.pushName) - return _internal_pushname(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ClientPayload::set_pushname(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.pushname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ClientPayload.pushName) -} -inline std::string* ClientPayload::mutable_pushname() { - std::string* _s = _internal_mutable_pushname(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.pushName) - return _s; -} -inline const std::string& ClientPayload::_internal_pushname() const { - return _impl_.pushname_.Get(); -} -inline void ClientPayload::_internal_set_pushname(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.pushname_.Set(value, GetArenaForAllocation()); -} -inline std::string* ClientPayload::_internal_mutable_pushname() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.pushname_.Mutable(GetArenaForAllocation()); -} -inline std::string* ClientPayload::release_pushname() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.pushName) - if (!_internal_has_pushname()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.pushname_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.pushname_.IsDefault()) { - _impl_.pushname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ClientPayload::set_allocated_pushname(std::string* pushname) { - if (pushname != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.pushname_.SetAllocated(pushname, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.pushname_.IsDefault()) { - _impl_.pushname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.pushName) -} - -// optional sfixed32 sessionId = 9; -inline bool ClientPayload::_internal_has_sessionid() const { - bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; - return value; -} -inline bool ClientPayload::has_sessionid() const { - return _internal_has_sessionid(); -} -inline void ClientPayload::clear_sessionid() { - _impl_.sessionid_ = 0; - _impl_._has_bits_[0] &= ~0x00000400u; -} -inline int32_t ClientPayload::_internal_sessionid() const { - return _impl_.sessionid_; -} -inline int32_t ClientPayload::sessionid() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.sessionId) - return _internal_sessionid(); -} -inline void ClientPayload::_internal_set_sessionid(int32_t value) { - _impl_._has_bits_[0] |= 0x00000400u; - _impl_.sessionid_ = value; -} -inline void ClientPayload::set_sessionid(int32_t value) { - _internal_set_sessionid(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.sessionId) -} - -// optional bool shortConnect = 10; -inline bool ClientPayload::_internal_has_shortconnect() const { - bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0; - return value; -} -inline bool ClientPayload::has_shortconnect() const { - return _internal_has_shortconnect(); -} -inline void ClientPayload::clear_shortconnect() { - _impl_.shortconnect_ = false; - _impl_._has_bits_[0] &= ~0x00008000u; -} -inline bool ClientPayload::_internal_shortconnect() const { - return _impl_.shortconnect_; -} -inline bool ClientPayload::shortconnect() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.shortConnect) - return _internal_shortconnect(); -} -inline void ClientPayload::_internal_set_shortconnect(bool value) { - _impl_._has_bits_[0] |= 0x00008000u; - _impl_.shortconnect_ = value; -} -inline void ClientPayload::set_shortconnect(bool value) { - _internal_set_shortconnect(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.shortConnect) -} - -// optional .proto.ClientPayload.ConnectType connectType = 12; -inline bool ClientPayload::_internal_has_connecttype() const { - bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; - return value; -} -inline bool ClientPayload::has_connecttype() const { - return _internal_has_connecttype(); -} -inline void ClientPayload::clear_connecttype() { - _impl_.connecttype_ = 0; - _impl_._has_bits_[0] &= ~0x00000800u; -} -inline ::proto::ClientPayload_ConnectType ClientPayload::_internal_connecttype() const { - return static_cast< ::proto::ClientPayload_ConnectType >(_impl_.connecttype_); -} -inline ::proto::ClientPayload_ConnectType ClientPayload::connecttype() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.connectType) - return _internal_connecttype(); -} -inline void ClientPayload::_internal_set_connecttype(::proto::ClientPayload_ConnectType value) { - assert(::proto::ClientPayload_ConnectType_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000800u; - _impl_.connecttype_ = value; -} -inline void ClientPayload::set_connecttype(::proto::ClientPayload_ConnectType value) { - _internal_set_connecttype(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.connectType) -} - -// optional .proto.ClientPayload.ConnectReason connectReason = 13; -inline bool ClientPayload::_internal_has_connectreason() const { - bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; - return value; -} -inline bool ClientPayload::has_connectreason() const { - return _internal_has_connectreason(); -} -inline void ClientPayload::clear_connectreason() { - _impl_.connectreason_ = 0; - _impl_._has_bits_[0] &= ~0x00001000u; -} -inline ::proto::ClientPayload_ConnectReason ClientPayload::_internal_connectreason() const { - return static_cast< ::proto::ClientPayload_ConnectReason >(_impl_.connectreason_); -} -inline ::proto::ClientPayload_ConnectReason ClientPayload::connectreason() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.connectReason) - return _internal_connectreason(); -} -inline void ClientPayload::_internal_set_connectreason(::proto::ClientPayload_ConnectReason value) { - assert(::proto::ClientPayload_ConnectReason_IsValid(value)); - _impl_._has_bits_[0] |= 0x00001000u; - _impl_.connectreason_ = value; -} -inline void ClientPayload::set_connectreason(::proto::ClientPayload_ConnectReason value) { - _internal_set_connectreason(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.connectReason) -} - -// repeated int32 shards = 14; -inline int ClientPayload::_internal_shards_size() const { - return _impl_.shards_.size(); -} -inline int ClientPayload::shards_size() const { - return _internal_shards_size(); -} -inline void ClientPayload::clear_shards() { - _impl_.shards_.Clear(); -} -inline int32_t ClientPayload::_internal_shards(int index) const { - return _impl_.shards_.Get(index); -} -inline int32_t ClientPayload::shards(int index) const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.shards) - return _internal_shards(index); -} -inline void ClientPayload::set_shards(int index, int32_t value) { - _impl_.shards_.Set(index, value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.shards) -} -inline void ClientPayload::_internal_add_shards(int32_t value) { - _impl_.shards_.Add(value); -} -inline void ClientPayload::add_shards(int32_t value) { - _internal_add_shards(value); - // @@protoc_insertion_point(field_add:proto.ClientPayload.shards) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& -ClientPayload::_internal_shards() const { - return _impl_.shards_; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& -ClientPayload::shards() const { - // @@protoc_insertion_point(field_list:proto.ClientPayload.shards) - return _internal_shards(); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* -ClientPayload::_internal_mutable_shards() { - return &_impl_.shards_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* -ClientPayload::mutable_shards() { - // @@protoc_insertion_point(field_mutable_list:proto.ClientPayload.shards) - return _internal_mutable_shards(); -} - -// optional .proto.ClientPayload.DNSSource dnsSource = 15; -inline bool ClientPayload::_internal_has_dnssource() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - PROTOBUF_ASSUME(!value || _impl_.dnssource_ != nullptr); - return value; -} -inline bool ClientPayload::has_dnssource() const { - return _internal_has_dnssource(); -} -inline void ClientPayload::clear_dnssource() { - if (_impl_.dnssource_ != nullptr) _impl_.dnssource_->Clear(); - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline const ::proto::ClientPayload_DNSSource& ClientPayload::_internal_dnssource() const { - const ::proto::ClientPayload_DNSSource* p = _impl_.dnssource_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ClientPayload_DNSSource_default_instance_); -} -inline const ::proto::ClientPayload_DNSSource& ClientPayload::dnssource() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.dnsSource) - return _internal_dnssource(); -} -inline void ClientPayload::unsafe_arena_set_allocated_dnssource( - ::proto::ClientPayload_DNSSource* dnssource) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.dnssource_); - } - _impl_.dnssource_ = dnssource; - if (dnssource) { - _impl_._has_bits_[0] |= 0x00000080u; - } else { - _impl_._has_bits_[0] &= ~0x00000080u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ClientPayload.dnsSource) -} -inline ::proto::ClientPayload_DNSSource* ClientPayload::release_dnssource() { - _impl_._has_bits_[0] &= ~0x00000080u; - ::proto::ClientPayload_DNSSource* temp = _impl_.dnssource_; - _impl_.dnssource_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ClientPayload_DNSSource* ClientPayload::unsafe_arena_release_dnssource() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.dnsSource) - _impl_._has_bits_[0] &= ~0x00000080u; - ::proto::ClientPayload_DNSSource* temp = _impl_.dnssource_; - _impl_.dnssource_ = nullptr; - return temp; -} -inline ::proto::ClientPayload_DNSSource* ClientPayload::_internal_mutable_dnssource() { - _impl_._has_bits_[0] |= 0x00000080u; - if (_impl_.dnssource_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ClientPayload_DNSSource>(GetArenaForAllocation()); - _impl_.dnssource_ = p; - } - return _impl_.dnssource_; -} -inline ::proto::ClientPayload_DNSSource* ClientPayload::mutable_dnssource() { - ::proto::ClientPayload_DNSSource* _msg = _internal_mutable_dnssource(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.dnsSource) - return _msg; -} -inline void ClientPayload::set_allocated_dnssource(::proto::ClientPayload_DNSSource* dnssource) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.dnssource_; - } - if (dnssource) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(dnssource); - if (message_arena != submessage_arena) { - dnssource = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, dnssource, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000080u; - } else { - _impl_._has_bits_[0] &= ~0x00000080u; - } - _impl_.dnssource_ = dnssource; - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.dnsSource) -} - -// optional uint32 connectAttemptCount = 16; -inline bool ClientPayload::_internal_has_connectattemptcount() const { - bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0; - return value; -} -inline bool ClientPayload::has_connectattemptcount() const { - return _internal_has_connectattemptcount(); -} -inline void ClientPayload::clear_connectattemptcount() { - _impl_.connectattemptcount_ = 0u; - _impl_._has_bits_[0] &= ~0x00002000u; -} -inline uint32_t ClientPayload::_internal_connectattemptcount() const { - return _impl_.connectattemptcount_; -} -inline uint32_t ClientPayload::connectattemptcount() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.connectAttemptCount) - return _internal_connectattemptcount(); -} -inline void ClientPayload::_internal_set_connectattemptcount(uint32_t value) { - _impl_._has_bits_[0] |= 0x00002000u; - _impl_.connectattemptcount_ = value; -} -inline void ClientPayload::set_connectattemptcount(uint32_t value) { - _internal_set_connectattemptcount(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.connectAttemptCount) -} - -// optional uint32 device = 18; -inline bool ClientPayload::_internal_has_device() const { - bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0; - return value; -} -inline bool ClientPayload::has_device() const { - return _internal_has_device(); -} -inline void ClientPayload::clear_device() { - _impl_.device_ = 0u; - _impl_._has_bits_[0] &= ~0x00040000u; -} -inline uint32_t ClientPayload::_internal_device() const { - return _impl_.device_; -} -inline uint32_t ClientPayload::device() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.device) - return _internal_device(); -} -inline void ClientPayload::_internal_set_device(uint32_t value) { - _impl_._has_bits_[0] |= 0x00040000u; - _impl_.device_ = value; -} -inline void ClientPayload::set_device(uint32_t value) { - _internal_set_device(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.device) -} - -// optional .proto.ClientPayload.DevicePairingRegistrationData devicePairingData = 19; -inline bool ClientPayload::_internal_has_devicepairingdata() const { - bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; - PROTOBUF_ASSUME(!value || _impl_.devicepairingdata_ != nullptr); - return value; -} -inline bool ClientPayload::has_devicepairingdata() const { - return _internal_has_devicepairingdata(); -} -inline void ClientPayload::clear_devicepairingdata() { - if (_impl_.devicepairingdata_ != nullptr) _impl_.devicepairingdata_->Clear(); - _impl_._has_bits_[0] &= ~0x00000100u; -} -inline const ::proto::ClientPayload_DevicePairingRegistrationData& ClientPayload::_internal_devicepairingdata() const { - const ::proto::ClientPayload_DevicePairingRegistrationData* p = _impl_.devicepairingdata_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ClientPayload_DevicePairingRegistrationData_default_instance_); -} -inline const ::proto::ClientPayload_DevicePairingRegistrationData& ClientPayload::devicepairingdata() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.devicePairingData) - return _internal_devicepairingdata(); -} -inline void ClientPayload::unsafe_arena_set_allocated_devicepairingdata( - ::proto::ClientPayload_DevicePairingRegistrationData* devicepairingdata) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.devicepairingdata_); - } - _impl_.devicepairingdata_ = devicepairingdata; - if (devicepairingdata) { - _impl_._has_bits_[0] |= 0x00000100u; - } else { - _impl_._has_bits_[0] &= ~0x00000100u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ClientPayload.devicePairingData) -} -inline ::proto::ClientPayload_DevicePairingRegistrationData* ClientPayload::release_devicepairingdata() { - _impl_._has_bits_[0] &= ~0x00000100u; - ::proto::ClientPayload_DevicePairingRegistrationData* temp = _impl_.devicepairingdata_; - _impl_.devicepairingdata_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ClientPayload_DevicePairingRegistrationData* ClientPayload::unsafe_arena_release_devicepairingdata() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.devicePairingData) - _impl_._has_bits_[0] &= ~0x00000100u; - ::proto::ClientPayload_DevicePairingRegistrationData* temp = _impl_.devicepairingdata_; - _impl_.devicepairingdata_ = nullptr; - return temp; -} -inline ::proto::ClientPayload_DevicePairingRegistrationData* ClientPayload::_internal_mutable_devicepairingdata() { - _impl_._has_bits_[0] |= 0x00000100u; - if (_impl_.devicepairingdata_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ClientPayload_DevicePairingRegistrationData>(GetArenaForAllocation()); - _impl_.devicepairingdata_ = p; - } - return _impl_.devicepairingdata_; -} -inline ::proto::ClientPayload_DevicePairingRegistrationData* ClientPayload::mutable_devicepairingdata() { - ::proto::ClientPayload_DevicePairingRegistrationData* _msg = _internal_mutable_devicepairingdata(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.devicePairingData) - return _msg; -} -inline void ClientPayload::set_allocated_devicepairingdata(::proto::ClientPayload_DevicePairingRegistrationData* devicepairingdata) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.devicepairingdata_; - } - if (devicepairingdata) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(devicepairingdata); - if (message_arena != submessage_arena) { - devicepairingdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, devicepairingdata, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000100u; - } else { - _impl_._has_bits_[0] &= ~0x00000100u; - } - _impl_.devicepairingdata_ = devicepairingdata; - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.devicePairingData) -} - -// optional .proto.ClientPayload.Product product = 20; -inline bool ClientPayload::_internal_has_product() const { - bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0; - return value; -} -inline bool ClientPayload::has_product() const { - return _internal_has_product(); -} -inline void ClientPayload::clear_product() { - _impl_.product_ = 0; - _impl_._has_bits_[0] &= ~0x00080000u; -} -inline ::proto::ClientPayload_Product ClientPayload::_internal_product() const { - return static_cast< ::proto::ClientPayload_Product >(_impl_.product_); -} -inline ::proto::ClientPayload_Product ClientPayload::product() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.product) - return _internal_product(); -} -inline void ClientPayload::_internal_set_product(::proto::ClientPayload_Product value) { - assert(::proto::ClientPayload_Product_IsValid(value)); - _impl_._has_bits_[0] |= 0x00080000u; - _impl_.product_ = value; -} -inline void ClientPayload::set_product(::proto::ClientPayload_Product value) { - _internal_set_product(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.product) -} - -// optional bytes fbCat = 21; -inline bool ClientPayload::_internal_has_fbcat() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool ClientPayload::has_fbcat() const { - return _internal_has_fbcat(); -} -inline void ClientPayload::clear_fbcat() { - _impl_.fbcat_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& ClientPayload::fbcat() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.fbCat) - return _internal_fbcat(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ClientPayload::set_fbcat(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.fbcat_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ClientPayload.fbCat) -} -inline std::string* ClientPayload::mutable_fbcat() { - std::string* _s = _internal_mutable_fbcat(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.fbCat) - return _s; -} -inline const std::string& ClientPayload::_internal_fbcat() const { - return _impl_.fbcat_.Get(); -} -inline void ClientPayload::_internal_set_fbcat(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.fbcat_.Set(value, GetArenaForAllocation()); -} -inline std::string* ClientPayload::_internal_mutable_fbcat() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.fbcat_.Mutable(GetArenaForAllocation()); -} -inline std::string* ClientPayload::release_fbcat() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.fbCat) - if (!_internal_has_fbcat()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.fbcat_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fbcat_.IsDefault()) { - _impl_.fbcat_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ClientPayload::set_allocated_fbcat(std::string* fbcat) { - if (fbcat != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.fbcat_.SetAllocated(fbcat, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fbcat_.IsDefault()) { - _impl_.fbcat_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.fbCat) -} - -// optional bytes fbUserAgent = 22; -inline bool ClientPayload::_internal_has_fbuseragent() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool ClientPayload::has_fbuseragent() const { - return _internal_has_fbuseragent(); -} -inline void ClientPayload::clear_fbuseragent() { - _impl_.fbuseragent_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& ClientPayload::fbuseragent() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.fbUserAgent) - return _internal_fbuseragent(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ClientPayload::set_fbuseragent(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.fbuseragent_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ClientPayload.fbUserAgent) -} -inline std::string* ClientPayload::mutable_fbuseragent() { - std::string* _s = _internal_mutable_fbuseragent(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.fbUserAgent) - return _s; -} -inline const std::string& ClientPayload::_internal_fbuseragent() const { - return _impl_.fbuseragent_.Get(); -} -inline void ClientPayload::_internal_set_fbuseragent(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.fbuseragent_.Set(value, GetArenaForAllocation()); -} -inline std::string* ClientPayload::_internal_mutable_fbuseragent() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.fbuseragent_.Mutable(GetArenaForAllocation()); -} -inline std::string* ClientPayload::release_fbuseragent() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.fbUserAgent) - if (!_internal_has_fbuseragent()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.fbuseragent_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fbuseragent_.IsDefault()) { - _impl_.fbuseragent_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ClientPayload::set_allocated_fbuseragent(std::string* fbuseragent) { - if (fbuseragent != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.fbuseragent_.SetAllocated(fbuseragent, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fbuseragent_.IsDefault()) { - _impl_.fbuseragent_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.fbUserAgent) -} - -// optional bool oc = 23; -inline bool ClientPayload::_internal_has_oc() const { - bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0; - return value; -} -inline bool ClientPayload::has_oc() const { - return _internal_has_oc(); -} -inline void ClientPayload::clear_oc() { - _impl_.oc_ = false; - _impl_._has_bits_[0] &= ~0x00010000u; -} -inline bool ClientPayload::_internal_oc() const { - return _impl_.oc_; -} -inline bool ClientPayload::oc() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.oc) - return _internal_oc(); -} -inline void ClientPayload::_internal_set_oc(bool value) { - _impl_._has_bits_[0] |= 0x00010000u; - _impl_.oc_ = value; -} -inline void ClientPayload::set_oc(bool value) { - _internal_set_oc(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.oc) -} - -// optional int32 lc = 24; -inline bool ClientPayload::_internal_has_lc() const { - bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0; - return value; -} -inline bool ClientPayload::has_lc() const { - return _internal_has_lc(); -} -inline void ClientPayload::clear_lc() { - _impl_.lc_ = 0; - _impl_._has_bits_[0] &= ~0x00100000u; -} -inline int32_t ClientPayload::_internal_lc() const { - return _impl_.lc_; -} -inline int32_t ClientPayload::lc() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.lc) - return _internal_lc(); -} -inline void ClientPayload::_internal_set_lc(int32_t value) { - _impl_._has_bits_[0] |= 0x00100000u; - _impl_.lc_ = value; -} -inline void ClientPayload::set_lc(int32_t value) { - _internal_set_lc(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.lc) -} - -// optional .proto.ClientPayload.IOSAppExtension iosAppExtension = 30; -inline bool ClientPayload::_internal_has_iosappextension() const { - bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0; - return value; -} -inline bool ClientPayload::has_iosappextension() const { - return _internal_has_iosappextension(); -} -inline void ClientPayload::clear_iosappextension() { - _impl_.iosappextension_ = 0; - _impl_._has_bits_[0] &= ~0x00400000u; -} -inline ::proto::ClientPayload_IOSAppExtension ClientPayload::_internal_iosappextension() const { - return static_cast< ::proto::ClientPayload_IOSAppExtension >(_impl_.iosappextension_); -} -inline ::proto::ClientPayload_IOSAppExtension ClientPayload::iosappextension() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.iosAppExtension) - return _internal_iosappextension(); -} -inline void ClientPayload::_internal_set_iosappextension(::proto::ClientPayload_IOSAppExtension value) { - assert(::proto::ClientPayload_IOSAppExtension_IsValid(value)); - _impl_._has_bits_[0] |= 0x00400000u; - _impl_.iosappextension_ = value; -} -inline void ClientPayload::set_iosappextension(::proto::ClientPayload_IOSAppExtension value) { - _internal_set_iosappextension(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.iosAppExtension) -} - -// optional uint64 fbAppId = 31; -inline bool ClientPayload::_internal_has_fbappid() const { - bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0; - return value; -} -inline bool ClientPayload::has_fbappid() const { - return _internal_has_fbappid(); -} -inline void ClientPayload::clear_fbappid() { - _impl_.fbappid_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00200000u; -} -inline uint64_t ClientPayload::_internal_fbappid() const { - return _impl_.fbappid_; -} -inline uint64_t ClientPayload::fbappid() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.fbAppId) - return _internal_fbappid(); -} -inline void ClientPayload::_internal_set_fbappid(uint64_t value) { - _impl_._has_bits_[0] |= 0x00200000u; - _impl_.fbappid_ = value; -} -inline void ClientPayload::set_fbappid(uint64_t value) { - _internal_set_fbappid(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.fbAppId) -} - -// optional bytes fbDeviceId = 32; -inline bool ClientPayload::_internal_has_fbdeviceid() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool ClientPayload::has_fbdeviceid() const { - return _internal_has_fbdeviceid(); -} -inline void ClientPayload::clear_fbdeviceid() { - _impl_.fbdeviceid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const std::string& ClientPayload::fbdeviceid() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.fbDeviceId) - return _internal_fbdeviceid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ClientPayload::set_fbdeviceid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.fbdeviceid_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ClientPayload.fbDeviceId) -} -inline std::string* ClientPayload::mutable_fbdeviceid() { - std::string* _s = _internal_mutable_fbdeviceid(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.fbDeviceId) - return _s; -} -inline const std::string& ClientPayload::_internal_fbdeviceid() const { - return _impl_.fbdeviceid_.Get(); -} -inline void ClientPayload::_internal_set_fbdeviceid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.fbdeviceid_.Set(value, GetArenaForAllocation()); -} -inline std::string* ClientPayload::_internal_mutable_fbdeviceid() { - _impl_._has_bits_[0] |= 0x00000008u; - return _impl_.fbdeviceid_.Mutable(GetArenaForAllocation()); -} -inline std::string* ClientPayload::release_fbdeviceid() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.fbDeviceId) - if (!_internal_has_fbdeviceid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000008u; - auto* p = _impl_.fbdeviceid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fbdeviceid_.IsDefault()) { - _impl_.fbdeviceid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ClientPayload::set_allocated_fbdeviceid(std::string* fbdeviceid) { - if (fbdeviceid != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.fbdeviceid_.SetAllocated(fbdeviceid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fbdeviceid_.IsDefault()) { - _impl_.fbdeviceid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.fbDeviceId) -} - -// optional bool pull = 33; -inline bool ClientPayload::_internal_has_pull() const { - bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0; - return value; -} -inline bool ClientPayload::has_pull() const { - return _internal_has_pull(); -} -inline void ClientPayload::clear_pull() { - _impl_.pull_ = false; - _impl_._has_bits_[0] &= ~0x00020000u; -} -inline bool ClientPayload::_internal_pull() const { - return _impl_.pull_; -} -inline bool ClientPayload::pull() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.pull) - return _internal_pull(); -} -inline void ClientPayload::_internal_set_pull(bool value) { - _impl_._has_bits_[0] |= 0x00020000u; - _impl_.pull_ = value; -} -inline void ClientPayload::set_pull(bool value) { - _internal_set_pull(value); - // @@protoc_insertion_point(field_set:proto.ClientPayload.pull) -} - -// optional bytes paddingBytes = 34; -inline bool ClientPayload::_internal_has_paddingbytes() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool ClientPayload::has_paddingbytes() const { - return _internal_has_paddingbytes(); -} -inline void ClientPayload::clear_paddingbytes() { - _impl_.paddingbytes_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const std::string& ClientPayload::paddingbytes() const { - // @@protoc_insertion_point(field_get:proto.ClientPayload.paddingBytes) - return _internal_paddingbytes(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ClientPayload::set_paddingbytes(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.paddingbytes_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ClientPayload.paddingBytes) -} -inline std::string* ClientPayload::mutable_paddingbytes() { - std::string* _s = _internal_mutable_paddingbytes(); - // @@protoc_insertion_point(field_mutable:proto.ClientPayload.paddingBytes) - return _s; -} -inline const std::string& ClientPayload::_internal_paddingbytes() const { - return _impl_.paddingbytes_.Get(); -} -inline void ClientPayload::_internal_set_paddingbytes(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.paddingbytes_.Set(value, GetArenaForAllocation()); -} -inline std::string* ClientPayload::_internal_mutable_paddingbytes() { - _impl_._has_bits_[0] |= 0x00000010u; - return _impl_.paddingbytes_.Mutable(GetArenaForAllocation()); -} -inline std::string* ClientPayload::release_paddingbytes() { - // @@protoc_insertion_point(field_release:proto.ClientPayload.paddingBytes) - if (!_internal_has_paddingbytes()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000010u; - auto* p = _impl_.paddingbytes_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.paddingbytes_.IsDefault()) { - _impl_.paddingbytes_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ClientPayload::set_allocated_paddingbytes(std::string* paddingbytes) { - if (paddingbytes != nullptr) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.paddingbytes_.SetAllocated(paddingbytes, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.paddingbytes_.IsDefault()) { - _impl_.paddingbytes_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.paddingBytes) -} - -// ------------------------------------------------------------------- - -// ContextInfo_AdReplyInfo - -// optional string advertiserName = 1; -inline bool ContextInfo_AdReplyInfo::_internal_has_advertisername() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool ContextInfo_AdReplyInfo::has_advertisername() const { - return _internal_has_advertisername(); -} -inline void ContextInfo_AdReplyInfo::clear_advertisername() { - _impl_.advertisername_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& ContextInfo_AdReplyInfo::advertisername() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.AdReplyInfo.advertiserName) - return _internal_advertisername(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ContextInfo_AdReplyInfo::set_advertisername(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.advertisername_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ContextInfo.AdReplyInfo.advertiserName) -} -inline std::string* ContextInfo_AdReplyInfo::mutable_advertisername() { - std::string* _s = _internal_mutable_advertisername(); - // @@protoc_insertion_point(field_mutable:proto.ContextInfo.AdReplyInfo.advertiserName) - return _s; -} -inline const std::string& ContextInfo_AdReplyInfo::_internal_advertisername() const { - return _impl_.advertisername_.Get(); -} -inline void ContextInfo_AdReplyInfo::_internal_set_advertisername(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.advertisername_.Set(value, GetArenaForAllocation()); -} -inline std::string* ContextInfo_AdReplyInfo::_internal_mutable_advertisername() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.advertisername_.Mutable(GetArenaForAllocation()); -} -inline std::string* ContextInfo_AdReplyInfo::release_advertisername() { - // @@protoc_insertion_point(field_release:proto.ContextInfo.AdReplyInfo.advertiserName) - if (!_internal_has_advertisername()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.advertisername_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.advertisername_.IsDefault()) { - _impl_.advertisername_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ContextInfo_AdReplyInfo::set_allocated_advertisername(std::string* advertisername) { - if (advertisername != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.advertisername_.SetAllocated(advertisername, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.advertisername_.IsDefault()) { - _impl_.advertisername_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.AdReplyInfo.advertiserName) -} - -// optional .proto.ContextInfo.AdReplyInfo.MediaType mediaType = 2; -inline bool ContextInfo_AdReplyInfo::_internal_has_mediatype() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool ContextInfo_AdReplyInfo::has_mediatype() const { - return _internal_has_mediatype(); -} -inline void ContextInfo_AdReplyInfo::clear_mediatype() { - _impl_.mediatype_ = 0; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline ::proto::ContextInfo_AdReplyInfo_MediaType ContextInfo_AdReplyInfo::_internal_mediatype() const { - return static_cast< ::proto::ContextInfo_AdReplyInfo_MediaType >(_impl_.mediatype_); -} -inline ::proto::ContextInfo_AdReplyInfo_MediaType ContextInfo_AdReplyInfo::mediatype() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.AdReplyInfo.mediaType) - return _internal_mediatype(); -} -inline void ContextInfo_AdReplyInfo::_internal_set_mediatype(::proto::ContextInfo_AdReplyInfo_MediaType value) { - assert(::proto::ContextInfo_AdReplyInfo_MediaType_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.mediatype_ = value; -} -inline void ContextInfo_AdReplyInfo::set_mediatype(::proto::ContextInfo_AdReplyInfo_MediaType value) { - _internal_set_mediatype(value); - // @@protoc_insertion_point(field_set:proto.ContextInfo.AdReplyInfo.mediaType) -} - -// optional bytes jpegThumbnail = 16; -inline bool ContextInfo_AdReplyInfo::_internal_has_jpegthumbnail() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool ContextInfo_AdReplyInfo::has_jpegthumbnail() const { - return _internal_has_jpegthumbnail(); -} -inline void ContextInfo_AdReplyInfo::clear_jpegthumbnail() { - _impl_.jpegthumbnail_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& ContextInfo_AdReplyInfo::jpegthumbnail() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.AdReplyInfo.jpegThumbnail) - return _internal_jpegthumbnail(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ContextInfo_AdReplyInfo::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.jpegthumbnail_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ContextInfo.AdReplyInfo.jpegThumbnail) -} -inline std::string* ContextInfo_AdReplyInfo::mutable_jpegthumbnail() { - std::string* _s = _internal_mutable_jpegthumbnail(); - // @@protoc_insertion_point(field_mutable:proto.ContextInfo.AdReplyInfo.jpegThumbnail) - return _s; -} -inline const std::string& ContextInfo_AdReplyInfo::_internal_jpegthumbnail() const { - return _impl_.jpegthumbnail_.Get(); -} -inline void ContextInfo_AdReplyInfo::_internal_set_jpegthumbnail(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation()); -} -inline std::string* ContextInfo_AdReplyInfo::_internal_mutable_jpegthumbnail() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation()); -} -inline std::string* ContextInfo_AdReplyInfo::release_jpegthumbnail() { - // @@protoc_insertion_point(field_release:proto.ContextInfo.AdReplyInfo.jpegThumbnail) - if (!_internal_has_jpegthumbnail()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.jpegthumbnail_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.jpegthumbnail_.IsDefault()) { - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ContextInfo_AdReplyInfo::set_allocated_jpegthumbnail(std::string* jpegthumbnail) { - if (jpegthumbnail != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.jpegthumbnail_.IsDefault()) { - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.AdReplyInfo.jpegThumbnail) -} - -// optional string caption = 17; -inline bool ContextInfo_AdReplyInfo::_internal_has_caption() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool ContextInfo_AdReplyInfo::has_caption() const { - return _internal_has_caption(); -} -inline void ContextInfo_AdReplyInfo::clear_caption() { - _impl_.caption_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& ContextInfo_AdReplyInfo::caption() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.AdReplyInfo.caption) - return _internal_caption(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ContextInfo_AdReplyInfo::set_caption(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.caption_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ContextInfo.AdReplyInfo.caption) -} -inline std::string* ContextInfo_AdReplyInfo::mutable_caption() { - std::string* _s = _internal_mutable_caption(); - // @@protoc_insertion_point(field_mutable:proto.ContextInfo.AdReplyInfo.caption) - return _s; -} -inline const std::string& ContextInfo_AdReplyInfo::_internal_caption() const { - return _impl_.caption_.Get(); -} -inline void ContextInfo_AdReplyInfo::_internal_set_caption(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.caption_.Set(value, GetArenaForAllocation()); -} -inline std::string* ContextInfo_AdReplyInfo::_internal_mutable_caption() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.caption_.Mutable(GetArenaForAllocation()); -} -inline std::string* ContextInfo_AdReplyInfo::release_caption() { - // @@protoc_insertion_point(field_release:proto.ContextInfo.AdReplyInfo.caption) - if (!_internal_has_caption()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.caption_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.caption_.IsDefault()) { - _impl_.caption_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ContextInfo_AdReplyInfo::set_allocated_caption(std::string* caption) { - if (caption != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.caption_.SetAllocated(caption, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.caption_.IsDefault()) { - _impl_.caption_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.AdReplyInfo.caption) -} - -// ------------------------------------------------------------------- - -// ContextInfo_ExternalAdReplyInfo - -// optional string title = 1; -inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_title() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool ContextInfo_ExternalAdReplyInfo::has_title() const { - return _internal_has_title(); -} -inline void ContextInfo_ExternalAdReplyInfo::clear_title() { - _impl_.title_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& ContextInfo_ExternalAdReplyInfo::title() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.title) - return _internal_title(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ContextInfo_ExternalAdReplyInfo::set_title(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.title_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.title) -} -inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_title() { - std::string* _s = _internal_mutable_title(); - // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.title) - return _s; -} -inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_title() const { - return _impl_.title_.Get(); -} -inline void ContextInfo_ExternalAdReplyInfo::_internal_set_title(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.title_.Set(value, GetArenaForAllocation()); -} -inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_title() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.title_.Mutable(GetArenaForAllocation()); -} -inline std::string* ContextInfo_ExternalAdReplyInfo::release_title() { - // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.title) - if (!_internal_has_title()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.title_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.title_.IsDefault()) { - _impl_.title_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ContextInfo_ExternalAdReplyInfo::set_allocated_title(std::string* title) { - if (title != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.title_.SetAllocated(title, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.title_.IsDefault()) { - _impl_.title_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ExternalAdReplyInfo.title) -} - -// optional string body = 2; -inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_body() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool ContextInfo_ExternalAdReplyInfo::has_body() const { - return _internal_has_body(); -} -inline void ContextInfo_ExternalAdReplyInfo::clear_body() { - _impl_.body_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& ContextInfo_ExternalAdReplyInfo::body() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.body) - return _internal_body(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ContextInfo_ExternalAdReplyInfo::set_body(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.body_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.body) -} -inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_body() { - std::string* _s = _internal_mutable_body(); - // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.body) - return _s; -} -inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_body() const { - return _impl_.body_.Get(); -} -inline void ContextInfo_ExternalAdReplyInfo::_internal_set_body(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.body_.Set(value, GetArenaForAllocation()); -} -inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_body() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.body_.Mutable(GetArenaForAllocation()); -} -inline std::string* ContextInfo_ExternalAdReplyInfo::release_body() { - // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.body) - if (!_internal_has_body()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.body_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.body_.IsDefault()) { - _impl_.body_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ContextInfo_ExternalAdReplyInfo::set_allocated_body(std::string* body) { - if (body != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.body_.SetAllocated(body, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.body_.IsDefault()) { - _impl_.body_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ExternalAdReplyInfo.body) -} - -// optional .proto.ContextInfo.ExternalAdReplyInfo.MediaType mediaType = 3; -inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_mediatype() const { - bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; - return value; -} -inline bool ContextInfo_ExternalAdReplyInfo::has_mediatype() const { - return _internal_has_mediatype(); -} -inline void ContextInfo_ExternalAdReplyInfo::clear_mediatype() { - _impl_.mediatype_ = 0; - _impl_._has_bits_[0] &= ~0x00000100u; -} -inline ::proto::ContextInfo_ExternalAdReplyInfo_MediaType ContextInfo_ExternalAdReplyInfo::_internal_mediatype() const { - return static_cast< ::proto::ContextInfo_ExternalAdReplyInfo_MediaType >(_impl_.mediatype_); -} -inline ::proto::ContextInfo_ExternalAdReplyInfo_MediaType ContextInfo_ExternalAdReplyInfo::mediatype() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.mediaType) - return _internal_mediatype(); -} -inline void ContextInfo_ExternalAdReplyInfo::_internal_set_mediatype(::proto::ContextInfo_ExternalAdReplyInfo_MediaType value) { - assert(::proto::ContextInfo_ExternalAdReplyInfo_MediaType_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000100u; - _impl_.mediatype_ = value; -} -inline void ContextInfo_ExternalAdReplyInfo::set_mediatype(::proto::ContextInfo_ExternalAdReplyInfo_MediaType value) { - _internal_set_mediatype(value); - // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.mediaType) -} - -// optional string thumbnailUrl = 4; -inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_thumbnailurl() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool ContextInfo_ExternalAdReplyInfo::has_thumbnailurl() const { - return _internal_has_thumbnailurl(); -} -inline void ContextInfo_ExternalAdReplyInfo::clear_thumbnailurl() { - _impl_.thumbnailurl_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& ContextInfo_ExternalAdReplyInfo::thumbnailurl() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.thumbnailUrl) - return _internal_thumbnailurl(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ContextInfo_ExternalAdReplyInfo::set_thumbnailurl(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.thumbnailurl_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.thumbnailUrl) -} -inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_thumbnailurl() { - std::string* _s = _internal_mutable_thumbnailurl(); - // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.thumbnailUrl) - return _s; -} -inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_thumbnailurl() const { - return _impl_.thumbnailurl_.Get(); -} -inline void ContextInfo_ExternalAdReplyInfo::_internal_set_thumbnailurl(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.thumbnailurl_.Set(value, GetArenaForAllocation()); -} -inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_thumbnailurl() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.thumbnailurl_.Mutable(GetArenaForAllocation()); -} -inline std::string* ContextInfo_ExternalAdReplyInfo::release_thumbnailurl() { - // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.thumbnailUrl) - if (!_internal_has_thumbnailurl()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.thumbnailurl_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.thumbnailurl_.IsDefault()) { - _impl_.thumbnailurl_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ContextInfo_ExternalAdReplyInfo::set_allocated_thumbnailurl(std::string* thumbnailurl) { - if (thumbnailurl != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.thumbnailurl_.SetAllocated(thumbnailurl, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.thumbnailurl_.IsDefault()) { - _impl_.thumbnailurl_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ExternalAdReplyInfo.thumbnailUrl) -} - -// optional string mediaUrl = 5; -inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_mediaurl() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool ContextInfo_ExternalAdReplyInfo::has_mediaurl() const { - return _internal_has_mediaurl(); -} -inline void ContextInfo_ExternalAdReplyInfo::clear_mediaurl() { - _impl_.mediaurl_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const std::string& ContextInfo_ExternalAdReplyInfo::mediaurl() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.mediaUrl) - return _internal_mediaurl(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ContextInfo_ExternalAdReplyInfo::set_mediaurl(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.mediaurl_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.mediaUrl) -} -inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_mediaurl() { - std::string* _s = _internal_mutable_mediaurl(); - // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.mediaUrl) - return _s; -} -inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_mediaurl() const { - return _impl_.mediaurl_.Get(); -} -inline void ContextInfo_ExternalAdReplyInfo::_internal_set_mediaurl(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.mediaurl_.Set(value, GetArenaForAllocation()); -} -inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_mediaurl() { - _impl_._has_bits_[0] |= 0x00000008u; - return _impl_.mediaurl_.Mutable(GetArenaForAllocation()); -} -inline std::string* ContextInfo_ExternalAdReplyInfo::release_mediaurl() { - // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.mediaUrl) - if (!_internal_has_mediaurl()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000008u; - auto* p = _impl_.mediaurl_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mediaurl_.IsDefault()) { - _impl_.mediaurl_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ContextInfo_ExternalAdReplyInfo::set_allocated_mediaurl(std::string* mediaurl) { - if (mediaurl != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.mediaurl_.SetAllocated(mediaurl, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mediaurl_.IsDefault()) { - _impl_.mediaurl_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ExternalAdReplyInfo.mediaUrl) -} - -// optional bytes thumbnail = 6; -inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_thumbnail() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool ContextInfo_ExternalAdReplyInfo::has_thumbnail() const { - return _internal_has_thumbnail(); -} -inline void ContextInfo_ExternalAdReplyInfo::clear_thumbnail() { - _impl_.thumbnail_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const std::string& ContextInfo_ExternalAdReplyInfo::thumbnail() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.thumbnail) - return _internal_thumbnail(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ContextInfo_ExternalAdReplyInfo::set_thumbnail(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.thumbnail_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.thumbnail) -} -inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_thumbnail() { - std::string* _s = _internal_mutable_thumbnail(); - // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.thumbnail) - return _s; -} -inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_thumbnail() const { - return _impl_.thumbnail_.Get(); -} -inline void ContextInfo_ExternalAdReplyInfo::_internal_set_thumbnail(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.thumbnail_.Set(value, GetArenaForAllocation()); -} -inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_thumbnail() { - _impl_._has_bits_[0] |= 0x00000010u; - return _impl_.thumbnail_.Mutable(GetArenaForAllocation()); -} -inline std::string* ContextInfo_ExternalAdReplyInfo::release_thumbnail() { - // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.thumbnail) - if (!_internal_has_thumbnail()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000010u; - auto* p = _impl_.thumbnail_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.thumbnail_.IsDefault()) { - _impl_.thumbnail_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ContextInfo_ExternalAdReplyInfo::set_allocated_thumbnail(std::string* thumbnail) { - if (thumbnail != nullptr) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.thumbnail_.SetAllocated(thumbnail, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.thumbnail_.IsDefault()) { - _impl_.thumbnail_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ExternalAdReplyInfo.thumbnail) -} - -// optional string sourceType = 7; -inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_sourcetype() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool ContextInfo_ExternalAdReplyInfo::has_sourcetype() const { - return _internal_has_sourcetype(); -} -inline void ContextInfo_ExternalAdReplyInfo::clear_sourcetype() { - _impl_.sourcetype_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline const std::string& ContextInfo_ExternalAdReplyInfo::sourcetype() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.sourceType) - return _internal_sourcetype(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ContextInfo_ExternalAdReplyInfo::set_sourcetype(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.sourcetype_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.sourceType) -} -inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_sourcetype() { - std::string* _s = _internal_mutable_sourcetype(); - // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.sourceType) - return _s; -} -inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_sourcetype() const { - return _impl_.sourcetype_.Get(); -} -inline void ContextInfo_ExternalAdReplyInfo::_internal_set_sourcetype(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.sourcetype_.Set(value, GetArenaForAllocation()); -} -inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_sourcetype() { - _impl_._has_bits_[0] |= 0x00000020u; - return _impl_.sourcetype_.Mutable(GetArenaForAllocation()); -} -inline std::string* ContextInfo_ExternalAdReplyInfo::release_sourcetype() { - // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.sourceType) - if (!_internal_has_sourcetype()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000020u; - auto* p = _impl_.sourcetype_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.sourcetype_.IsDefault()) { - _impl_.sourcetype_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ContextInfo_ExternalAdReplyInfo::set_allocated_sourcetype(std::string* sourcetype) { - if (sourcetype != nullptr) { - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - _impl_.sourcetype_.SetAllocated(sourcetype, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.sourcetype_.IsDefault()) { - _impl_.sourcetype_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ExternalAdReplyInfo.sourceType) -} - -// optional string sourceId = 8; -inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_sourceid() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool ContextInfo_ExternalAdReplyInfo::has_sourceid() const { - return _internal_has_sourceid(); -} -inline void ContextInfo_ExternalAdReplyInfo::clear_sourceid() { - _impl_.sourceid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline const std::string& ContextInfo_ExternalAdReplyInfo::sourceid() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.sourceId) - return _internal_sourceid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ContextInfo_ExternalAdReplyInfo::set_sourceid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.sourceid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.sourceId) -} -inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_sourceid() { - std::string* _s = _internal_mutable_sourceid(); - // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.sourceId) - return _s; -} -inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_sourceid() const { - return _impl_.sourceid_.Get(); -} -inline void ContextInfo_ExternalAdReplyInfo::_internal_set_sourceid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.sourceid_.Set(value, GetArenaForAllocation()); -} -inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_sourceid() { - _impl_._has_bits_[0] |= 0x00000040u; - return _impl_.sourceid_.Mutable(GetArenaForAllocation()); -} -inline std::string* ContextInfo_ExternalAdReplyInfo::release_sourceid() { - // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.sourceId) - if (!_internal_has_sourceid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000040u; - auto* p = _impl_.sourceid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.sourceid_.IsDefault()) { - _impl_.sourceid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ContextInfo_ExternalAdReplyInfo::set_allocated_sourceid(std::string* sourceid) { - if (sourceid != nullptr) { - _impl_._has_bits_[0] |= 0x00000040u; - } else { - _impl_._has_bits_[0] &= ~0x00000040u; - } - _impl_.sourceid_.SetAllocated(sourceid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.sourceid_.IsDefault()) { - _impl_.sourceid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ExternalAdReplyInfo.sourceId) -} - -// optional string sourceUrl = 9; -inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_sourceurl() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - return value; -} -inline bool ContextInfo_ExternalAdReplyInfo::has_sourceurl() const { - return _internal_has_sourceurl(); -} -inline void ContextInfo_ExternalAdReplyInfo::clear_sourceurl() { - _impl_.sourceurl_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline const std::string& ContextInfo_ExternalAdReplyInfo::sourceurl() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.sourceUrl) - return _internal_sourceurl(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ContextInfo_ExternalAdReplyInfo::set_sourceurl(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.sourceurl_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.sourceUrl) -} -inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_sourceurl() { - std::string* _s = _internal_mutable_sourceurl(); - // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.sourceUrl) - return _s; -} -inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_sourceurl() const { - return _impl_.sourceurl_.Get(); -} -inline void ContextInfo_ExternalAdReplyInfo::_internal_set_sourceurl(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.sourceurl_.Set(value, GetArenaForAllocation()); -} -inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_sourceurl() { - _impl_._has_bits_[0] |= 0x00000080u; - return _impl_.sourceurl_.Mutable(GetArenaForAllocation()); -} -inline std::string* ContextInfo_ExternalAdReplyInfo::release_sourceurl() { - // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.sourceUrl) - if (!_internal_has_sourceurl()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000080u; - auto* p = _impl_.sourceurl_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.sourceurl_.IsDefault()) { - _impl_.sourceurl_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ContextInfo_ExternalAdReplyInfo::set_allocated_sourceurl(std::string* sourceurl) { - if (sourceurl != nullptr) { - _impl_._has_bits_[0] |= 0x00000080u; - } else { - _impl_._has_bits_[0] &= ~0x00000080u; - } - _impl_.sourceurl_.SetAllocated(sourceurl, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.sourceurl_.IsDefault()) { - _impl_.sourceurl_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ExternalAdReplyInfo.sourceUrl) -} - -// optional bool containsAutoReply = 10; -inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_containsautoreply() const { - bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; - return value; -} -inline bool ContextInfo_ExternalAdReplyInfo::has_containsautoreply() const { - return _internal_has_containsautoreply(); -} -inline void ContextInfo_ExternalAdReplyInfo::clear_containsautoreply() { - _impl_.containsautoreply_ = false; - _impl_._has_bits_[0] &= ~0x00000200u; -} -inline bool ContextInfo_ExternalAdReplyInfo::_internal_containsautoreply() const { - return _impl_.containsautoreply_; -} -inline bool ContextInfo_ExternalAdReplyInfo::containsautoreply() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.containsAutoReply) - return _internal_containsautoreply(); -} -inline void ContextInfo_ExternalAdReplyInfo::_internal_set_containsautoreply(bool value) { - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.containsautoreply_ = value; -} -inline void ContextInfo_ExternalAdReplyInfo::set_containsautoreply(bool value) { - _internal_set_containsautoreply(value); - // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.containsAutoReply) -} - -// optional bool renderLargerThumbnail = 11; -inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_renderlargerthumbnail() const { - bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; - return value; -} -inline bool ContextInfo_ExternalAdReplyInfo::has_renderlargerthumbnail() const { - return _internal_has_renderlargerthumbnail(); -} -inline void ContextInfo_ExternalAdReplyInfo::clear_renderlargerthumbnail() { - _impl_.renderlargerthumbnail_ = false; - _impl_._has_bits_[0] &= ~0x00000400u; -} -inline bool ContextInfo_ExternalAdReplyInfo::_internal_renderlargerthumbnail() const { - return _impl_.renderlargerthumbnail_; -} -inline bool ContextInfo_ExternalAdReplyInfo::renderlargerthumbnail() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.renderLargerThumbnail) - return _internal_renderlargerthumbnail(); -} -inline void ContextInfo_ExternalAdReplyInfo::_internal_set_renderlargerthumbnail(bool value) { - _impl_._has_bits_[0] |= 0x00000400u; - _impl_.renderlargerthumbnail_ = value; -} -inline void ContextInfo_ExternalAdReplyInfo::set_renderlargerthumbnail(bool value) { - _internal_set_renderlargerthumbnail(value); - // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.renderLargerThumbnail) -} - -// optional bool showAdAttribution = 12; -inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_showadattribution() const { - bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; - return value; -} -inline bool ContextInfo_ExternalAdReplyInfo::has_showadattribution() const { - return _internal_has_showadattribution(); -} -inline void ContextInfo_ExternalAdReplyInfo::clear_showadattribution() { - _impl_.showadattribution_ = false; - _impl_._has_bits_[0] &= ~0x00000800u; -} -inline bool ContextInfo_ExternalAdReplyInfo::_internal_showadattribution() const { - return _impl_.showadattribution_; -} -inline bool ContextInfo_ExternalAdReplyInfo::showadattribution() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.showAdAttribution) - return _internal_showadattribution(); -} -inline void ContextInfo_ExternalAdReplyInfo::_internal_set_showadattribution(bool value) { - _impl_._has_bits_[0] |= 0x00000800u; - _impl_.showadattribution_ = value; -} -inline void ContextInfo_ExternalAdReplyInfo::set_showadattribution(bool value) { - _internal_set_showadattribution(value); - // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.showAdAttribution) -} - -// ------------------------------------------------------------------- - -// ContextInfo - -// optional string stanzaId = 1; -inline bool ContextInfo::_internal_has_stanzaid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool ContextInfo::has_stanzaid() const { - return _internal_has_stanzaid(); -} -inline void ContextInfo::clear_stanzaid() { - _impl_.stanzaid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& ContextInfo::stanzaid() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.stanzaId) - return _internal_stanzaid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ContextInfo::set_stanzaid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.stanzaid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ContextInfo.stanzaId) -} -inline std::string* ContextInfo::mutable_stanzaid() { - std::string* _s = _internal_mutable_stanzaid(); - // @@protoc_insertion_point(field_mutable:proto.ContextInfo.stanzaId) - return _s; -} -inline const std::string& ContextInfo::_internal_stanzaid() const { - return _impl_.stanzaid_.Get(); -} -inline void ContextInfo::_internal_set_stanzaid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.stanzaid_.Set(value, GetArenaForAllocation()); -} -inline std::string* ContextInfo::_internal_mutable_stanzaid() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.stanzaid_.Mutable(GetArenaForAllocation()); -} -inline std::string* ContextInfo::release_stanzaid() { - // @@protoc_insertion_point(field_release:proto.ContextInfo.stanzaId) - if (!_internal_has_stanzaid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.stanzaid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.stanzaid_.IsDefault()) { - _impl_.stanzaid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ContextInfo::set_allocated_stanzaid(std::string* stanzaid) { - if (stanzaid != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.stanzaid_.SetAllocated(stanzaid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.stanzaid_.IsDefault()) { - _impl_.stanzaid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.stanzaId) -} - -// optional string participant = 2; -inline bool ContextInfo::_internal_has_participant() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool ContextInfo::has_participant() const { - return _internal_has_participant(); -} -inline void ContextInfo::clear_participant() { - _impl_.participant_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& ContextInfo::participant() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.participant) - return _internal_participant(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ContextInfo::set_participant(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.participant_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ContextInfo.participant) -} -inline std::string* ContextInfo::mutable_participant() { - std::string* _s = _internal_mutable_participant(); - // @@protoc_insertion_point(field_mutable:proto.ContextInfo.participant) - return _s; -} -inline const std::string& ContextInfo::_internal_participant() const { - return _impl_.participant_.Get(); -} -inline void ContextInfo::_internal_set_participant(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.participant_.Set(value, GetArenaForAllocation()); -} -inline std::string* ContextInfo::_internal_mutable_participant() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.participant_.Mutable(GetArenaForAllocation()); -} -inline std::string* ContextInfo::release_participant() { - // @@protoc_insertion_point(field_release:proto.ContextInfo.participant) - if (!_internal_has_participant()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.participant_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.participant_.IsDefault()) { - _impl_.participant_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ContextInfo::set_allocated_participant(std::string* participant) { - if (participant != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.participant_.SetAllocated(participant, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.participant_.IsDefault()) { - _impl_.participant_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.participant) -} - -// optional .proto.Message quotedMessage = 3; -inline bool ContextInfo::_internal_has_quotedmessage() const { - bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; - PROTOBUF_ASSUME(!value || _impl_.quotedmessage_ != nullptr); - return value; -} -inline bool ContextInfo::has_quotedmessage() const { - return _internal_has_quotedmessage(); -} -inline void ContextInfo::clear_quotedmessage() { - if (_impl_.quotedmessage_ != nullptr) _impl_.quotedmessage_->Clear(); - _impl_._has_bits_[0] &= ~0x00000400u; -} -inline const ::proto::Message& ContextInfo::_internal_quotedmessage() const { - const ::proto::Message* p = _impl_.quotedmessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_default_instance_); -} -inline const ::proto::Message& ContextInfo::quotedmessage() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.quotedMessage) - return _internal_quotedmessage(); -} -inline void ContextInfo::unsafe_arena_set_allocated_quotedmessage( - ::proto::Message* quotedmessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quotedmessage_); - } - _impl_.quotedmessage_ = quotedmessage; - if (quotedmessage) { - _impl_._has_bits_[0] |= 0x00000400u; - } else { - _impl_._has_bits_[0] &= ~0x00000400u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ContextInfo.quotedMessage) -} -inline ::proto::Message* ContextInfo::release_quotedmessage() { - _impl_._has_bits_[0] &= ~0x00000400u; - ::proto::Message* temp = _impl_.quotedmessage_; - _impl_.quotedmessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message* ContextInfo::unsafe_arena_release_quotedmessage() { - // @@protoc_insertion_point(field_release:proto.ContextInfo.quotedMessage) - _impl_._has_bits_[0] &= ~0x00000400u; - ::proto::Message* temp = _impl_.quotedmessage_; - _impl_.quotedmessage_ = nullptr; - return temp; -} -inline ::proto::Message* ContextInfo::_internal_mutable_quotedmessage() { - _impl_._has_bits_[0] |= 0x00000400u; - if (_impl_.quotedmessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message>(GetArenaForAllocation()); - _impl_.quotedmessage_ = p; - } - return _impl_.quotedmessage_; -} -inline ::proto::Message* ContextInfo::mutable_quotedmessage() { - ::proto::Message* _msg = _internal_mutable_quotedmessage(); - // @@protoc_insertion_point(field_mutable:proto.ContextInfo.quotedMessage) - return _msg; -} -inline void ContextInfo::set_allocated_quotedmessage(::proto::Message* quotedmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.quotedmessage_; - } - if (quotedmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quotedmessage); - if (message_arena != submessage_arena) { - quotedmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, quotedmessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000400u; - } else { - _impl_._has_bits_[0] &= ~0x00000400u; - } - _impl_.quotedmessage_ = quotedmessage; - // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.quotedMessage) -} - -// optional string remoteJid = 4; -inline bool ContextInfo::_internal_has_remotejid() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool ContextInfo::has_remotejid() const { - return _internal_has_remotejid(); -} -inline void ContextInfo::clear_remotejid() { - _impl_.remotejid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& ContextInfo::remotejid() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.remoteJid) - return _internal_remotejid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ContextInfo::set_remotejid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.remotejid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ContextInfo.remoteJid) -} -inline std::string* ContextInfo::mutable_remotejid() { - std::string* _s = _internal_mutable_remotejid(); - // @@protoc_insertion_point(field_mutable:proto.ContextInfo.remoteJid) - return _s; -} -inline const std::string& ContextInfo::_internal_remotejid() const { - return _impl_.remotejid_.Get(); -} -inline void ContextInfo::_internal_set_remotejid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.remotejid_.Set(value, GetArenaForAllocation()); -} -inline std::string* ContextInfo::_internal_mutable_remotejid() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.remotejid_.Mutable(GetArenaForAllocation()); -} -inline std::string* ContextInfo::release_remotejid() { - // @@protoc_insertion_point(field_release:proto.ContextInfo.remoteJid) - if (!_internal_has_remotejid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.remotejid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.remotejid_.IsDefault()) { - _impl_.remotejid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ContextInfo::set_allocated_remotejid(std::string* remotejid) { - if (remotejid != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.remotejid_.SetAllocated(remotejid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.remotejid_.IsDefault()) { - _impl_.remotejid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.remoteJid) -} - -// repeated string mentionedJid = 15; -inline int ContextInfo::_internal_mentionedjid_size() const { - return _impl_.mentionedjid_.size(); -} -inline int ContextInfo::mentionedjid_size() const { - return _internal_mentionedjid_size(); -} -inline void ContextInfo::clear_mentionedjid() { - _impl_.mentionedjid_.Clear(); -} -inline std::string* ContextInfo::add_mentionedjid() { - std::string* _s = _internal_add_mentionedjid(); - // @@protoc_insertion_point(field_add_mutable:proto.ContextInfo.mentionedJid) - return _s; -} -inline const std::string& ContextInfo::_internal_mentionedjid(int index) const { - return _impl_.mentionedjid_.Get(index); -} -inline const std::string& ContextInfo::mentionedjid(int index) const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.mentionedJid) - return _internal_mentionedjid(index); -} -inline std::string* ContextInfo::mutable_mentionedjid(int index) { - // @@protoc_insertion_point(field_mutable:proto.ContextInfo.mentionedJid) - return _impl_.mentionedjid_.Mutable(index); -} -inline void ContextInfo::set_mentionedjid(int index, const std::string& value) { - _impl_.mentionedjid_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:proto.ContextInfo.mentionedJid) -} -inline void ContextInfo::set_mentionedjid(int index, std::string&& value) { - _impl_.mentionedjid_.Mutable(index)->assign(std::move(value)); - // @@protoc_insertion_point(field_set:proto.ContextInfo.mentionedJid) -} -inline void ContextInfo::set_mentionedjid(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - _impl_.mentionedjid_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:proto.ContextInfo.mentionedJid) -} -inline void ContextInfo::set_mentionedjid(int index, const char* value, size_t size) { - _impl_.mentionedjid_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:proto.ContextInfo.mentionedJid) -} -inline std::string* ContextInfo::_internal_add_mentionedjid() { - return _impl_.mentionedjid_.Add(); -} -inline void ContextInfo::add_mentionedjid(const std::string& value) { - _impl_.mentionedjid_.Add()->assign(value); - // @@protoc_insertion_point(field_add:proto.ContextInfo.mentionedJid) -} -inline void ContextInfo::add_mentionedjid(std::string&& value) { - _impl_.mentionedjid_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:proto.ContextInfo.mentionedJid) -} -inline void ContextInfo::add_mentionedjid(const char* value) { - GOOGLE_DCHECK(value != nullptr); - _impl_.mentionedjid_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:proto.ContextInfo.mentionedJid) -} -inline void ContextInfo::add_mentionedjid(const char* value, size_t size) { - _impl_.mentionedjid_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:proto.ContextInfo.mentionedJid) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -ContextInfo::mentionedjid() const { - // @@protoc_insertion_point(field_list:proto.ContextInfo.mentionedJid) - return _impl_.mentionedjid_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -ContextInfo::mutable_mentionedjid() { - // @@protoc_insertion_point(field_mutable_list:proto.ContextInfo.mentionedJid) - return &_impl_.mentionedjid_; -} - -// optional string conversionSource = 18; -inline bool ContextInfo::_internal_has_conversionsource() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool ContextInfo::has_conversionsource() const { - return _internal_has_conversionsource(); -} -inline void ContextInfo::clear_conversionsource() { - _impl_.conversionsource_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const std::string& ContextInfo::conversionsource() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.conversionSource) - return _internal_conversionsource(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ContextInfo::set_conversionsource(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.conversionsource_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ContextInfo.conversionSource) -} -inline std::string* ContextInfo::mutable_conversionsource() { - std::string* _s = _internal_mutable_conversionsource(); - // @@protoc_insertion_point(field_mutable:proto.ContextInfo.conversionSource) - return _s; -} -inline const std::string& ContextInfo::_internal_conversionsource() const { - return _impl_.conversionsource_.Get(); -} -inline void ContextInfo::_internal_set_conversionsource(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.conversionsource_.Set(value, GetArenaForAllocation()); -} -inline std::string* ContextInfo::_internal_mutable_conversionsource() { - _impl_._has_bits_[0] |= 0x00000008u; - return _impl_.conversionsource_.Mutable(GetArenaForAllocation()); -} -inline std::string* ContextInfo::release_conversionsource() { - // @@protoc_insertion_point(field_release:proto.ContextInfo.conversionSource) - if (!_internal_has_conversionsource()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000008u; - auto* p = _impl_.conversionsource_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.conversionsource_.IsDefault()) { - _impl_.conversionsource_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ContextInfo::set_allocated_conversionsource(std::string* conversionsource) { - if (conversionsource != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.conversionsource_.SetAllocated(conversionsource, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.conversionsource_.IsDefault()) { - _impl_.conversionsource_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.conversionSource) -} - -// optional bytes conversionData = 19; -inline bool ContextInfo::_internal_has_conversiondata() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool ContextInfo::has_conversiondata() const { - return _internal_has_conversiondata(); -} -inline void ContextInfo::clear_conversiondata() { - _impl_.conversiondata_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const std::string& ContextInfo::conversiondata() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.conversionData) - return _internal_conversiondata(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ContextInfo::set_conversiondata(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.conversiondata_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ContextInfo.conversionData) -} -inline std::string* ContextInfo::mutable_conversiondata() { - std::string* _s = _internal_mutable_conversiondata(); - // @@protoc_insertion_point(field_mutable:proto.ContextInfo.conversionData) - return _s; -} -inline const std::string& ContextInfo::_internal_conversiondata() const { - return _impl_.conversiondata_.Get(); -} -inline void ContextInfo::_internal_set_conversiondata(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.conversiondata_.Set(value, GetArenaForAllocation()); -} -inline std::string* ContextInfo::_internal_mutable_conversiondata() { - _impl_._has_bits_[0] |= 0x00000010u; - return _impl_.conversiondata_.Mutable(GetArenaForAllocation()); -} -inline std::string* ContextInfo::release_conversiondata() { - // @@protoc_insertion_point(field_release:proto.ContextInfo.conversionData) - if (!_internal_has_conversiondata()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000010u; - auto* p = _impl_.conversiondata_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.conversiondata_.IsDefault()) { - _impl_.conversiondata_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ContextInfo::set_allocated_conversiondata(std::string* conversiondata) { - if (conversiondata != nullptr) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.conversiondata_.SetAllocated(conversiondata, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.conversiondata_.IsDefault()) { - _impl_.conversiondata_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.conversionData) -} - -// optional uint32 conversionDelaySeconds = 20; -inline bool ContextInfo::_internal_has_conversiondelayseconds() const { - bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0; - return value; -} -inline bool ContextInfo::has_conversiondelayseconds() const { - return _internal_has_conversiondelayseconds(); -} -inline void ContextInfo::clear_conversiondelayseconds() { - _impl_.conversiondelayseconds_ = 0u; - _impl_._has_bits_[0] &= ~0x00010000u; -} -inline uint32_t ContextInfo::_internal_conversiondelayseconds() const { - return _impl_.conversiondelayseconds_; -} -inline uint32_t ContextInfo::conversiondelayseconds() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.conversionDelaySeconds) - return _internal_conversiondelayseconds(); -} -inline void ContextInfo::_internal_set_conversiondelayseconds(uint32_t value) { - _impl_._has_bits_[0] |= 0x00010000u; - _impl_.conversiondelayseconds_ = value; -} -inline void ContextInfo::set_conversiondelayseconds(uint32_t value) { - _internal_set_conversiondelayseconds(value); - // @@protoc_insertion_point(field_set:proto.ContextInfo.conversionDelaySeconds) -} - -// optional uint32 forwardingScore = 21; -inline bool ContextInfo::_internal_has_forwardingscore() const { - bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0; - return value; -} -inline bool ContextInfo::has_forwardingscore() const { - return _internal_has_forwardingscore(); -} -inline void ContextInfo::clear_forwardingscore() { - _impl_.forwardingscore_ = 0u; - _impl_._has_bits_[0] &= ~0x00020000u; -} -inline uint32_t ContextInfo::_internal_forwardingscore() const { - return _impl_.forwardingscore_; -} -inline uint32_t ContextInfo::forwardingscore() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.forwardingScore) - return _internal_forwardingscore(); -} -inline void ContextInfo::_internal_set_forwardingscore(uint32_t value) { - _impl_._has_bits_[0] |= 0x00020000u; - _impl_.forwardingscore_ = value; -} -inline void ContextInfo::set_forwardingscore(uint32_t value) { - _internal_set_forwardingscore(value); - // @@protoc_insertion_point(field_set:proto.ContextInfo.forwardingScore) -} - -// optional bool isForwarded = 22; -inline bool ContextInfo::_internal_has_isforwarded() const { - bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0; - return value; -} -inline bool ContextInfo::has_isforwarded() const { - return _internal_has_isforwarded(); -} -inline void ContextInfo::clear_isforwarded() { - _impl_.isforwarded_ = false; - _impl_._has_bits_[0] &= ~0x00040000u; -} -inline bool ContextInfo::_internal_isforwarded() const { - return _impl_.isforwarded_; -} -inline bool ContextInfo::isforwarded() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.isForwarded) - return _internal_isforwarded(); -} -inline void ContextInfo::_internal_set_isforwarded(bool value) { - _impl_._has_bits_[0] |= 0x00040000u; - _impl_.isforwarded_ = value; -} -inline void ContextInfo::set_isforwarded(bool value) { - _internal_set_isforwarded(value); - // @@protoc_insertion_point(field_set:proto.ContextInfo.isForwarded) -} - -// optional .proto.ContextInfo.AdReplyInfo quotedAd = 23; -inline bool ContextInfo::_internal_has_quotedad() const { - bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; - PROTOBUF_ASSUME(!value || _impl_.quotedad_ != nullptr); - return value; -} -inline bool ContextInfo::has_quotedad() const { - return _internal_has_quotedad(); -} -inline void ContextInfo::clear_quotedad() { - if (_impl_.quotedad_ != nullptr) _impl_.quotedad_->Clear(); - _impl_._has_bits_[0] &= ~0x00000800u; -} -inline const ::proto::ContextInfo_AdReplyInfo& ContextInfo::_internal_quotedad() const { - const ::proto::ContextInfo_AdReplyInfo* p = _impl_.quotedad_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ContextInfo_AdReplyInfo_default_instance_); -} -inline const ::proto::ContextInfo_AdReplyInfo& ContextInfo::quotedad() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.quotedAd) - return _internal_quotedad(); -} -inline void ContextInfo::unsafe_arena_set_allocated_quotedad( - ::proto::ContextInfo_AdReplyInfo* quotedad) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quotedad_); - } - _impl_.quotedad_ = quotedad; - if (quotedad) { - _impl_._has_bits_[0] |= 0x00000800u; - } else { - _impl_._has_bits_[0] &= ~0x00000800u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ContextInfo.quotedAd) -} -inline ::proto::ContextInfo_AdReplyInfo* ContextInfo::release_quotedad() { - _impl_._has_bits_[0] &= ~0x00000800u; - ::proto::ContextInfo_AdReplyInfo* temp = _impl_.quotedad_; - _impl_.quotedad_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ContextInfo_AdReplyInfo* ContextInfo::unsafe_arena_release_quotedad() { - // @@protoc_insertion_point(field_release:proto.ContextInfo.quotedAd) - _impl_._has_bits_[0] &= ~0x00000800u; - ::proto::ContextInfo_AdReplyInfo* temp = _impl_.quotedad_; - _impl_.quotedad_ = nullptr; - return temp; -} -inline ::proto::ContextInfo_AdReplyInfo* ContextInfo::_internal_mutable_quotedad() { - _impl_._has_bits_[0] |= 0x00000800u; - if (_impl_.quotedad_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ContextInfo_AdReplyInfo>(GetArenaForAllocation()); - _impl_.quotedad_ = p; - } - return _impl_.quotedad_; -} -inline ::proto::ContextInfo_AdReplyInfo* ContextInfo::mutable_quotedad() { - ::proto::ContextInfo_AdReplyInfo* _msg = _internal_mutable_quotedad(); - // @@protoc_insertion_point(field_mutable:proto.ContextInfo.quotedAd) - return _msg; -} -inline void ContextInfo::set_allocated_quotedad(::proto::ContextInfo_AdReplyInfo* quotedad) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.quotedad_; - } - if (quotedad) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quotedad); - if (message_arena != submessage_arena) { - quotedad = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, quotedad, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000800u; - } else { - _impl_._has_bits_[0] &= ~0x00000800u; - } - _impl_.quotedad_ = quotedad; - // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.quotedAd) -} - -// optional .proto.MessageKey placeholderKey = 24; -inline bool ContextInfo::_internal_has_placeholderkey() const { - bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.placeholderkey_ != nullptr); - return value; -} -inline bool ContextInfo::has_placeholderkey() const { - return _internal_has_placeholderkey(); -} -inline void ContextInfo::clear_placeholderkey() { - if (_impl_.placeholderkey_ != nullptr) _impl_.placeholderkey_->Clear(); - _impl_._has_bits_[0] &= ~0x00001000u; -} -inline const ::proto::MessageKey& ContextInfo::_internal_placeholderkey() const { - const ::proto::MessageKey* p = _impl_.placeholderkey_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_MessageKey_default_instance_); -} -inline const ::proto::MessageKey& ContextInfo::placeholderkey() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.placeholderKey) - return _internal_placeholderkey(); -} -inline void ContextInfo::unsafe_arena_set_allocated_placeholderkey( - ::proto::MessageKey* placeholderkey) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.placeholderkey_); - } - _impl_.placeholderkey_ = placeholderkey; - if (placeholderkey) { - _impl_._has_bits_[0] |= 0x00001000u; - } else { - _impl_._has_bits_[0] &= ~0x00001000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ContextInfo.placeholderKey) -} -inline ::proto::MessageKey* ContextInfo::release_placeholderkey() { - _impl_._has_bits_[0] &= ~0x00001000u; - ::proto::MessageKey* temp = _impl_.placeholderkey_; - _impl_.placeholderkey_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::MessageKey* ContextInfo::unsafe_arena_release_placeholderkey() { - // @@protoc_insertion_point(field_release:proto.ContextInfo.placeholderKey) - _impl_._has_bits_[0] &= ~0x00001000u; - ::proto::MessageKey* temp = _impl_.placeholderkey_; - _impl_.placeholderkey_ = nullptr; - return temp; -} -inline ::proto::MessageKey* ContextInfo::_internal_mutable_placeholderkey() { - _impl_._has_bits_[0] |= 0x00001000u; - if (_impl_.placeholderkey_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation()); - _impl_.placeholderkey_ = p; - } - return _impl_.placeholderkey_; -} -inline ::proto::MessageKey* ContextInfo::mutable_placeholderkey() { - ::proto::MessageKey* _msg = _internal_mutable_placeholderkey(); - // @@protoc_insertion_point(field_mutable:proto.ContextInfo.placeholderKey) - return _msg; -} -inline void ContextInfo::set_allocated_placeholderkey(::proto::MessageKey* placeholderkey) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.placeholderkey_; - } - if (placeholderkey) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(placeholderkey); - if (message_arena != submessage_arena) { - placeholderkey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, placeholderkey, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00001000u; - } else { - _impl_._has_bits_[0] &= ~0x00001000u; - } - _impl_.placeholderkey_ = placeholderkey; - // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.placeholderKey) -} - -// optional uint32 expiration = 25; -inline bool ContextInfo::_internal_has_expiration() const { - bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0; - return value; -} -inline bool ContextInfo::has_expiration() const { - return _internal_has_expiration(); -} -inline void ContextInfo::clear_expiration() { - _impl_.expiration_ = 0u; - _impl_._has_bits_[0] &= ~0x00080000u; -} -inline uint32_t ContextInfo::_internal_expiration() const { - return _impl_.expiration_; -} -inline uint32_t ContextInfo::expiration() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.expiration) - return _internal_expiration(); -} -inline void ContextInfo::_internal_set_expiration(uint32_t value) { - _impl_._has_bits_[0] |= 0x00080000u; - _impl_.expiration_ = value; -} -inline void ContextInfo::set_expiration(uint32_t value) { - _internal_set_expiration(value); - // @@protoc_insertion_point(field_set:proto.ContextInfo.expiration) -} - -// optional int64 ephemeralSettingTimestamp = 26; -inline bool ContextInfo::_internal_has_ephemeralsettingtimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0; - return value; -} -inline bool ContextInfo::has_ephemeralsettingtimestamp() const { - return _internal_has_ephemeralsettingtimestamp(); -} -inline void ContextInfo::clear_ephemeralsettingtimestamp() { - _impl_.ephemeralsettingtimestamp_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00100000u; -} -inline int64_t ContextInfo::_internal_ephemeralsettingtimestamp() const { - return _impl_.ephemeralsettingtimestamp_; -} -inline int64_t ContextInfo::ephemeralsettingtimestamp() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.ephemeralSettingTimestamp) - return _internal_ephemeralsettingtimestamp(); -} -inline void ContextInfo::_internal_set_ephemeralsettingtimestamp(int64_t value) { - _impl_._has_bits_[0] |= 0x00100000u; - _impl_.ephemeralsettingtimestamp_ = value; -} -inline void ContextInfo::set_ephemeralsettingtimestamp(int64_t value) { - _internal_set_ephemeralsettingtimestamp(value); - // @@protoc_insertion_point(field_set:proto.ContextInfo.ephemeralSettingTimestamp) -} - -// optional bytes ephemeralSharedSecret = 27; -inline bool ContextInfo::_internal_has_ephemeralsharedsecret() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool ContextInfo::has_ephemeralsharedsecret() const { - return _internal_has_ephemeralsharedsecret(); -} -inline void ContextInfo::clear_ephemeralsharedsecret() { - _impl_.ephemeralsharedsecret_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline const std::string& ContextInfo::ephemeralsharedsecret() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.ephemeralSharedSecret) - return _internal_ephemeralsharedsecret(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ContextInfo::set_ephemeralsharedsecret(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.ephemeralsharedsecret_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ContextInfo.ephemeralSharedSecret) -} -inline std::string* ContextInfo::mutable_ephemeralsharedsecret() { - std::string* _s = _internal_mutable_ephemeralsharedsecret(); - // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ephemeralSharedSecret) - return _s; -} -inline const std::string& ContextInfo::_internal_ephemeralsharedsecret() const { - return _impl_.ephemeralsharedsecret_.Get(); -} -inline void ContextInfo::_internal_set_ephemeralsharedsecret(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.ephemeralsharedsecret_.Set(value, GetArenaForAllocation()); -} -inline std::string* ContextInfo::_internal_mutable_ephemeralsharedsecret() { - _impl_._has_bits_[0] |= 0x00000020u; - return _impl_.ephemeralsharedsecret_.Mutable(GetArenaForAllocation()); -} -inline std::string* ContextInfo::release_ephemeralsharedsecret() { - // @@protoc_insertion_point(field_release:proto.ContextInfo.ephemeralSharedSecret) - if (!_internal_has_ephemeralsharedsecret()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000020u; - auto* p = _impl_.ephemeralsharedsecret_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.ephemeralsharedsecret_.IsDefault()) { - _impl_.ephemeralsharedsecret_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ContextInfo::set_allocated_ephemeralsharedsecret(std::string* ephemeralsharedsecret) { - if (ephemeralsharedsecret != nullptr) { - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - _impl_.ephemeralsharedsecret_.SetAllocated(ephemeralsharedsecret, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.ephemeralsharedsecret_.IsDefault()) { - _impl_.ephemeralsharedsecret_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ephemeralSharedSecret) -} - -// optional .proto.ContextInfo.ExternalAdReplyInfo externalAdReply = 28; -inline bool ContextInfo::_internal_has_externaladreply() const { - bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.externaladreply_ != nullptr); - return value; -} -inline bool ContextInfo::has_externaladreply() const { - return _internal_has_externaladreply(); -} -inline void ContextInfo::clear_externaladreply() { - if (_impl_.externaladreply_ != nullptr) _impl_.externaladreply_->Clear(); - _impl_._has_bits_[0] &= ~0x00002000u; -} -inline const ::proto::ContextInfo_ExternalAdReplyInfo& ContextInfo::_internal_externaladreply() const { - const ::proto::ContextInfo_ExternalAdReplyInfo* p = _impl_.externaladreply_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ContextInfo_ExternalAdReplyInfo_default_instance_); -} -inline const ::proto::ContextInfo_ExternalAdReplyInfo& ContextInfo::externaladreply() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.externalAdReply) - return _internal_externaladreply(); -} -inline void ContextInfo::unsafe_arena_set_allocated_externaladreply( - ::proto::ContextInfo_ExternalAdReplyInfo* externaladreply) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.externaladreply_); - } - _impl_.externaladreply_ = externaladreply; - if (externaladreply) { - _impl_._has_bits_[0] |= 0x00002000u; - } else { - _impl_._has_bits_[0] &= ~0x00002000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ContextInfo.externalAdReply) -} -inline ::proto::ContextInfo_ExternalAdReplyInfo* ContextInfo::release_externaladreply() { - _impl_._has_bits_[0] &= ~0x00002000u; - ::proto::ContextInfo_ExternalAdReplyInfo* temp = _impl_.externaladreply_; - _impl_.externaladreply_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ContextInfo_ExternalAdReplyInfo* ContextInfo::unsafe_arena_release_externaladreply() { - // @@protoc_insertion_point(field_release:proto.ContextInfo.externalAdReply) - _impl_._has_bits_[0] &= ~0x00002000u; - ::proto::ContextInfo_ExternalAdReplyInfo* temp = _impl_.externaladreply_; - _impl_.externaladreply_ = nullptr; - return temp; -} -inline ::proto::ContextInfo_ExternalAdReplyInfo* ContextInfo::_internal_mutable_externaladreply() { - _impl_._has_bits_[0] |= 0x00002000u; - if (_impl_.externaladreply_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ContextInfo_ExternalAdReplyInfo>(GetArenaForAllocation()); - _impl_.externaladreply_ = p; - } - return _impl_.externaladreply_; -} -inline ::proto::ContextInfo_ExternalAdReplyInfo* ContextInfo::mutable_externaladreply() { - ::proto::ContextInfo_ExternalAdReplyInfo* _msg = _internal_mutable_externaladreply(); - // @@protoc_insertion_point(field_mutable:proto.ContextInfo.externalAdReply) - return _msg; -} -inline void ContextInfo::set_allocated_externaladreply(::proto::ContextInfo_ExternalAdReplyInfo* externaladreply) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.externaladreply_; - } - if (externaladreply) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(externaladreply); - if (message_arena != submessage_arena) { - externaladreply = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, externaladreply, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00002000u; - } else { - _impl_._has_bits_[0] &= ~0x00002000u; - } - _impl_.externaladreply_ = externaladreply; - // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.externalAdReply) -} - -// optional string entryPointConversionSource = 29; -inline bool ContextInfo::_internal_has_entrypointconversionsource() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool ContextInfo::has_entrypointconversionsource() const { - return _internal_has_entrypointconversionsource(); -} -inline void ContextInfo::clear_entrypointconversionsource() { - _impl_.entrypointconversionsource_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline const std::string& ContextInfo::entrypointconversionsource() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.entryPointConversionSource) - return _internal_entrypointconversionsource(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ContextInfo::set_entrypointconversionsource(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.entrypointconversionsource_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ContextInfo.entryPointConversionSource) -} -inline std::string* ContextInfo::mutable_entrypointconversionsource() { - std::string* _s = _internal_mutable_entrypointconversionsource(); - // @@protoc_insertion_point(field_mutable:proto.ContextInfo.entryPointConversionSource) - return _s; -} -inline const std::string& ContextInfo::_internal_entrypointconversionsource() const { - return _impl_.entrypointconversionsource_.Get(); -} -inline void ContextInfo::_internal_set_entrypointconversionsource(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.entrypointconversionsource_.Set(value, GetArenaForAllocation()); -} -inline std::string* ContextInfo::_internal_mutable_entrypointconversionsource() { - _impl_._has_bits_[0] |= 0x00000040u; - return _impl_.entrypointconversionsource_.Mutable(GetArenaForAllocation()); -} -inline std::string* ContextInfo::release_entrypointconversionsource() { - // @@protoc_insertion_point(field_release:proto.ContextInfo.entryPointConversionSource) - if (!_internal_has_entrypointconversionsource()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000040u; - auto* p = _impl_.entrypointconversionsource_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.entrypointconversionsource_.IsDefault()) { - _impl_.entrypointconversionsource_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ContextInfo::set_allocated_entrypointconversionsource(std::string* entrypointconversionsource) { - if (entrypointconversionsource != nullptr) { - _impl_._has_bits_[0] |= 0x00000040u; - } else { - _impl_._has_bits_[0] &= ~0x00000040u; - } - _impl_.entrypointconversionsource_.SetAllocated(entrypointconversionsource, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.entrypointconversionsource_.IsDefault()) { - _impl_.entrypointconversionsource_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.entryPointConversionSource) -} - -// optional string entryPointConversionApp = 30; -inline bool ContextInfo::_internal_has_entrypointconversionapp() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - return value; -} -inline bool ContextInfo::has_entrypointconversionapp() const { - return _internal_has_entrypointconversionapp(); -} -inline void ContextInfo::clear_entrypointconversionapp() { - _impl_.entrypointconversionapp_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline const std::string& ContextInfo::entrypointconversionapp() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.entryPointConversionApp) - return _internal_entrypointconversionapp(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ContextInfo::set_entrypointconversionapp(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.entrypointconversionapp_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ContextInfo.entryPointConversionApp) -} -inline std::string* ContextInfo::mutable_entrypointconversionapp() { - std::string* _s = _internal_mutable_entrypointconversionapp(); - // @@protoc_insertion_point(field_mutable:proto.ContextInfo.entryPointConversionApp) - return _s; -} -inline const std::string& ContextInfo::_internal_entrypointconversionapp() const { - return _impl_.entrypointconversionapp_.Get(); -} -inline void ContextInfo::_internal_set_entrypointconversionapp(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.entrypointconversionapp_.Set(value, GetArenaForAllocation()); -} -inline std::string* ContextInfo::_internal_mutable_entrypointconversionapp() { - _impl_._has_bits_[0] |= 0x00000080u; - return _impl_.entrypointconversionapp_.Mutable(GetArenaForAllocation()); -} -inline std::string* ContextInfo::release_entrypointconversionapp() { - // @@protoc_insertion_point(field_release:proto.ContextInfo.entryPointConversionApp) - if (!_internal_has_entrypointconversionapp()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000080u; - auto* p = _impl_.entrypointconversionapp_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.entrypointconversionapp_.IsDefault()) { - _impl_.entrypointconversionapp_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ContextInfo::set_allocated_entrypointconversionapp(std::string* entrypointconversionapp) { - if (entrypointconversionapp != nullptr) { - _impl_._has_bits_[0] |= 0x00000080u; - } else { - _impl_._has_bits_[0] &= ~0x00000080u; - } - _impl_.entrypointconversionapp_.SetAllocated(entrypointconversionapp, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.entrypointconversionapp_.IsDefault()) { - _impl_.entrypointconversionapp_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.entryPointConversionApp) -} - -// optional uint32 entryPointConversionDelaySeconds = 31; -inline bool ContextInfo::_internal_has_entrypointconversiondelayseconds() const { - bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0; - return value; -} -inline bool ContextInfo::has_entrypointconversiondelayseconds() const { - return _internal_has_entrypointconversiondelayseconds(); -} -inline void ContextInfo::clear_entrypointconversiondelayseconds() { - _impl_.entrypointconversiondelayseconds_ = 0u; - _impl_._has_bits_[0] &= ~0x00200000u; -} -inline uint32_t ContextInfo::_internal_entrypointconversiondelayseconds() const { - return _impl_.entrypointconversiondelayseconds_; -} -inline uint32_t ContextInfo::entrypointconversiondelayseconds() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.entryPointConversionDelaySeconds) - return _internal_entrypointconversiondelayseconds(); -} -inline void ContextInfo::_internal_set_entrypointconversiondelayseconds(uint32_t value) { - _impl_._has_bits_[0] |= 0x00200000u; - _impl_.entrypointconversiondelayseconds_ = value; -} -inline void ContextInfo::set_entrypointconversiondelayseconds(uint32_t value) { - _internal_set_entrypointconversiondelayseconds(value); - // @@protoc_insertion_point(field_set:proto.ContextInfo.entryPointConversionDelaySeconds) -} - -// optional .proto.DisappearingMode disappearingMode = 32; -inline bool ContextInfo::_internal_has_disappearingmode() const { - bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.disappearingmode_ != nullptr); - return value; -} -inline bool ContextInfo::has_disappearingmode() const { - return _internal_has_disappearingmode(); -} -inline void ContextInfo::clear_disappearingmode() { - if (_impl_.disappearingmode_ != nullptr) _impl_.disappearingmode_->Clear(); - _impl_._has_bits_[0] &= ~0x00004000u; -} -inline const ::proto::DisappearingMode& ContextInfo::_internal_disappearingmode() const { - const ::proto::DisappearingMode* p = _impl_.disappearingmode_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_DisappearingMode_default_instance_); -} -inline const ::proto::DisappearingMode& ContextInfo::disappearingmode() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.disappearingMode) - return _internal_disappearingmode(); -} -inline void ContextInfo::unsafe_arena_set_allocated_disappearingmode( - ::proto::DisappearingMode* disappearingmode) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.disappearingmode_); - } - _impl_.disappearingmode_ = disappearingmode; - if (disappearingmode) { - _impl_._has_bits_[0] |= 0x00004000u; - } else { - _impl_._has_bits_[0] &= ~0x00004000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ContextInfo.disappearingMode) -} -inline ::proto::DisappearingMode* ContextInfo::release_disappearingmode() { - _impl_._has_bits_[0] &= ~0x00004000u; - ::proto::DisappearingMode* temp = _impl_.disappearingmode_; - _impl_.disappearingmode_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::DisappearingMode* ContextInfo::unsafe_arena_release_disappearingmode() { - // @@protoc_insertion_point(field_release:proto.ContextInfo.disappearingMode) - _impl_._has_bits_[0] &= ~0x00004000u; - ::proto::DisappearingMode* temp = _impl_.disappearingmode_; - _impl_.disappearingmode_ = nullptr; - return temp; -} -inline ::proto::DisappearingMode* ContextInfo::_internal_mutable_disappearingmode() { - _impl_._has_bits_[0] |= 0x00004000u; - if (_impl_.disappearingmode_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::DisappearingMode>(GetArenaForAllocation()); - _impl_.disappearingmode_ = p; - } - return _impl_.disappearingmode_; -} -inline ::proto::DisappearingMode* ContextInfo::mutable_disappearingmode() { - ::proto::DisappearingMode* _msg = _internal_mutable_disappearingmode(); - // @@protoc_insertion_point(field_mutable:proto.ContextInfo.disappearingMode) - return _msg; -} -inline void ContextInfo::set_allocated_disappearingmode(::proto::DisappearingMode* disappearingmode) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.disappearingmode_; - } - if (disappearingmode) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(disappearingmode); - if (message_arena != submessage_arena) { - disappearingmode = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, disappearingmode, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00004000u; - } else { - _impl_._has_bits_[0] &= ~0x00004000u; - } - _impl_.disappearingmode_ = disappearingmode; - // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.disappearingMode) -} - -// optional .proto.ActionLink actionLink = 33; -inline bool ContextInfo::_internal_has_actionlink() const { - bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.actionlink_ != nullptr); - return value; -} -inline bool ContextInfo::has_actionlink() const { - return _internal_has_actionlink(); -} -inline void ContextInfo::clear_actionlink() { - if (_impl_.actionlink_ != nullptr) _impl_.actionlink_->Clear(); - _impl_._has_bits_[0] &= ~0x00008000u; -} -inline const ::proto::ActionLink& ContextInfo::_internal_actionlink() const { - const ::proto::ActionLink* p = _impl_.actionlink_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ActionLink_default_instance_); -} -inline const ::proto::ActionLink& ContextInfo::actionlink() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.actionLink) - return _internal_actionlink(); -} -inline void ContextInfo::unsafe_arena_set_allocated_actionlink( - ::proto::ActionLink* actionlink) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.actionlink_); - } - _impl_.actionlink_ = actionlink; - if (actionlink) { - _impl_._has_bits_[0] |= 0x00008000u; - } else { - _impl_._has_bits_[0] &= ~0x00008000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ContextInfo.actionLink) -} -inline ::proto::ActionLink* ContextInfo::release_actionlink() { - _impl_._has_bits_[0] &= ~0x00008000u; - ::proto::ActionLink* temp = _impl_.actionlink_; - _impl_.actionlink_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ActionLink* ContextInfo::unsafe_arena_release_actionlink() { - // @@protoc_insertion_point(field_release:proto.ContextInfo.actionLink) - _impl_._has_bits_[0] &= ~0x00008000u; - ::proto::ActionLink* temp = _impl_.actionlink_; - _impl_.actionlink_ = nullptr; - return temp; -} -inline ::proto::ActionLink* ContextInfo::_internal_mutable_actionlink() { - _impl_._has_bits_[0] |= 0x00008000u; - if (_impl_.actionlink_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ActionLink>(GetArenaForAllocation()); - _impl_.actionlink_ = p; - } - return _impl_.actionlink_; -} -inline ::proto::ActionLink* ContextInfo::mutable_actionlink() { - ::proto::ActionLink* _msg = _internal_mutable_actionlink(); - // @@protoc_insertion_point(field_mutable:proto.ContextInfo.actionLink) - return _msg; -} -inline void ContextInfo::set_allocated_actionlink(::proto::ActionLink* actionlink) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.actionlink_; - } - if (actionlink) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(actionlink); - if (message_arena != submessage_arena) { - actionlink = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, actionlink, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00008000u; - } else { - _impl_._has_bits_[0] &= ~0x00008000u; - } - _impl_.actionlink_ = actionlink; - // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.actionLink) -} - -// optional string groupSubject = 34; -inline bool ContextInfo::_internal_has_groupsubject() const { - bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; - return value; -} -inline bool ContextInfo::has_groupsubject() const { - return _internal_has_groupsubject(); -} -inline void ContextInfo::clear_groupsubject() { - _impl_.groupsubject_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000100u; -} -inline const std::string& ContextInfo::groupsubject() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.groupSubject) - return _internal_groupsubject(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ContextInfo::set_groupsubject(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000100u; - _impl_.groupsubject_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ContextInfo.groupSubject) -} -inline std::string* ContextInfo::mutable_groupsubject() { - std::string* _s = _internal_mutable_groupsubject(); - // @@protoc_insertion_point(field_mutable:proto.ContextInfo.groupSubject) - return _s; -} -inline const std::string& ContextInfo::_internal_groupsubject() const { - return _impl_.groupsubject_.Get(); -} -inline void ContextInfo::_internal_set_groupsubject(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000100u; - _impl_.groupsubject_.Set(value, GetArenaForAllocation()); -} -inline std::string* ContextInfo::_internal_mutable_groupsubject() { - _impl_._has_bits_[0] |= 0x00000100u; - return _impl_.groupsubject_.Mutable(GetArenaForAllocation()); -} -inline std::string* ContextInfo::release_groupsubject() { - // @@protoc_insertion_point(field_release:proto.ContextInfo.groupSubject) - if (!_internal_has_groupsubject()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000100u; - auto* p = _impl_.groupsubject_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.groupsubject_.IsDefault()) { - _impl_.groupsubject_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ContextInfo::set_allocated_groupsubject(std::string* groupsubject) { - if (groupsubject != nullptr) { - _impl_._has_bits_[0] |= 0x00000100u; - } else { - _impl_._has_bits_[0] &= ~0x00000100u; - } - _impl_.groupsubject_.SetAllocated(groupsubject, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.groupsubject_.IsDefault()) { - _impl_.groupsubject_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.groupSubject) -} - -// optional string parentGroupJid = 35; -inline bool ContextInfo::_internal_has_parentgroupjid() const { - bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; - return value; -} -inline bool ContextInfo::has_parentgroupjid() const { - return _internal_has_parentgroupjid(); -} -inline void ContextInfo::clear_parentgroupjid() { - _impl_.parentgroupjid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000200u; -} -inline const std::string& ContextInfo::parentgroupjid() const { - // @@protoc_insertion_point(field_get:proto.ContextInfo.parentGroupJid) - return _internal_parentgroupjid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ContextInfo::set_parentgroupjid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.parentgroupjid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ContextInfo.parentGroupJid) -} -inline std::string* ContextInfo::mutable_parentgroupjid() { - std::string* _s = _internal_mutable_parentgroupjid(); - // @@protoc_insertion_point(field_mutable:proto.ContextInfo.parentGroupJid) - return _s; -} -inline const std::string& ContextInfo::_internal_parentgroupjid() const { - return _impl_.parentgroupjid_.Get(); -} -inline void ContextInfo::_internal_set_parentgroupjid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.parentgroupjid_.Set(value, GetArenaForAllocation()); -} -inline std::string* ContextInfo::_internal_mutable_parentgroupjid() { - _impl_._has_bits_[0] |= 0x00000200u; - return _impl_.parentgroupjid_.Mutable(GetArenaForAllocation()); -} -inline std::string* ContextInfo::release_parentgroupjid() { - // @@protoc_insertion_point(field_release:proto.ContextInfo.parentGroupJid) - if (!_internal_has_parentgroupjid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000200u; - auto* p = _impl_.parentgroupjid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.parentgroupjid_.IsDefault()) { - _impl_.parentgroupjid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ContextInfo::set_allocated_parentgroupjid(std::string* parentgroupjid) { - if (parentgroupjid != nullptr) { - _impl_._has_bits_[0] |= 0x00000200u; - } else { - _impl_._has_bits_[0] &= ~0x00000200u; - } - _impl_.parentgroupjid_.SetAllocated(parentgroupjid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.parentgroupjid_.IsDefault()) { - _impl_.parentgroupjid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.parentGroupJid) -} - -// ------------------------------------------------------------------- - -// Conversation - -// required string id = 1; -inline bool Conversation::_internal_has_id() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Conversation::has_id() const { - return _internal_has_id(); -} -inline void Conversation::clear_id() { - _impl_.id_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Conversation::id() const { - // @@protoc_insertion_point(field_get:proto.Conversation.id) - return _internal_id(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Conversation::set_id(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.id_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Conversation.id) -} -inline std::string* Conversation::mutable_id() { - std::string* _s = _internal_mutable_id(); - // @@protoc_insertion_point(field_mutable:proto.Conversation.id) - return _s; -} -inline const std::string& Conversation::_internal_id() const { - return _impl_.id_.Get(); -} -inline void Conversation::_internal_set_id(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.id_.Set(value, GetArenaForAllocation()); -} -inline std::string* Conversation::_internal_mutable_id() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.id_.Mutable(GetArenaForAllocation()); -} -inline std::string* Conversation::release_id() { - // @@protoc_insertion_point(field_release:proto.Conversation.id) - if (!_internal_has_id()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.id_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.id_.IsDefault()) { - _impl_.id_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Conversation::set_allocated_id(std::string* id) { - if (id != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.id_.SetAllocated(id, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.id_.IsDefault()) { - _impl_.id_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Conversation.id) -} - -// repeated .proto.HistorySyncMsg messages = 2; -inline int Conversation::_internal_messages_size() const { - return _impl_.messages_.size(); -} -inline int Conversation::messages_size() const { - return _internal_messages_size(); -} -inline void Conversation::clear_messages() { - _impl_.messages_.Clear(); -} -inline ::proto::HistorySyncMsg* Conversation::mutable_messages(int index) { - // @@protoc_insertion_point(field_mutable:proto.Conversation.messages) - return _impl_.messages_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HistorySyncMsg >* -Conversation::mutable_messages() { - // @@protoc_insertion_point(field_mutable_list:proto.Conversation.messages) - return &_impl_.messages_; -} -inline const ::proto::HistorySyncMsg& Conversation::_internal_messages(int index) const { - return _impl_.messages_.Get(index); -} -inline const ::proto::HistorySyncMsg& Conversation::messages(int index) const { - // @@protoc_insertion_point(field_get:proto.Conversation.messages) - return _internal_messages(index); -} -inline ::proto::HistorySyncMsg* Conversation::_internal_add_messages() { - return _impl_.messages_.Add(); -} -inline ::proto::HistorySyncMsg* Conversation::add_messages() { - ::proto::HistorySyncMsg* _add = _internal_add_messages(); - // @@protoc_insertion_point(field_add:proto.Conversation.messages) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HistorySyncMsg >& -Conversation::messages() const { - // @@protoc_insertion_point(field_list:proto.Conversation.messages) - return _impl_.messages_; -} - -// optional string newJid = 3; -inline bool Conversation::_internal_has_newjid() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Conversation::has_newjid() const { - return _internal_has_newjid(); -} -inline void Conversation::clear_newjid() { - _impl_.newjid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Conversation::newjid() const { - // @@protoc_insertion_point(field_get:proto.Conversation.newJid) - return _internal_newjid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Conversation::set_newjid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.newjid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Conversation.newJid) -} -inline std::string* Conversation::mutable_newjid() { - std::string* _s = _internal_mutable_newjid(); - // @@protoc_insertion_point(field_mutable:proto.Conversation.newJid) - return _s; -} -inline const std::string& Conversation::_internal_newjid() const { - return _impl_.newjid_.Get(); -} -inline void Conversation::_internal_set_newjid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.newjid_.Set(value, GetArenaForAllocation()); -} -inline std::string* Conversation::_internal_mutable_newjid() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.newjid_.Mutable(GetArenaForAllocation()); -} -inline std::string* Conversation::release_newjid() { - // @@protoc_insertion_point(field_release:proto.Conversation.newJid) - if (!_internal_has_newjid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.newjid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.newjid_.IsDefault()) { - _impl_.newjid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Conversation::set_allocated_newjid(std::string* newjid) { - if (newjid != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.newjid_.SetAllocated(newjid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.newjid_.IsDefault()) { - _impl_.newjid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Conversation.newJid) -} - -// optional string oldJid = 4; -inline bool Conversation::_internal_has_oldjid() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool Conversation::has_oldjid() const { - return _internal_has_oldjid(); -} -inline void Conversation::clear_oldjid() { - _impl_.oldjid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& Conversation::oldjid() const { - // @@protoc_insertion_point(field_get:proto.Conversation.oldJid) - return _internal_oldjid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Conversation::set_oldjid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.oldjid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Conversation.oldJid) -} -inline std::string* Conversation::mutable_oldjid() { - std::string* _s = _internal_mutable_oldjid(); - // @@protoc_insertion_point(field_mutable:proto.Conversation.oldJid) - return _s; -} -inline const std::string& Conversation::_internal_oldjid() const { - return _impl_.oldjid_.Get(); -} -inline void Conversation::_internal_set_oldjid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.oldjid_.Set(value, GetArenaForAllocation()); -} -inline std::string* Conversation::_internal_mutable_oldjid() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.oldjid_.Mutable(GetArenaForAllocation()); -} -inline std::string* Conversation::release_oldjid() { - // @@protoc_insertion_point(field_release:proto.Conversation.oldJid) - if (!_internal_has_oldjid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.oldjid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.oldjid_.IsDefault()) { - _impl_.oldjid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Conversation::set_allocated_oldjid(std::string* oldjid) { - if (oldjid != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.oldjid_.SetAllocated(oldjid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.oldjid_.IsDefault()) { - _impl_.oldjid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Conversation.oldJid) -} - -// optional uint64 lastMsgTimestamp = 5; -inline bool Conversation::_internal_has_lastmsgtimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0; - return value; -} -inline bool Conversation::has_lastmsgtimestamp() const { - return _internal_has_lastmsgtimestamp(); -} -inline void Conversation::clear_lastmsgtimestamp() { - _impl_.lastmsgtimestamp_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00004000u; -} -inline uint64_t Conversation::_internal_lastmsgtimestamp() const { - return _impl_.lastmsgtimestamp_; -} -inline uint64_t Conversation::lastmsgtimestamp() const { - // @@protoc_insertion_point(field_get:proto.Conversation.lastMsgTimestamp) - return _internal_lastmsgtimestamp(); -} -inline void Conversation::_internal_set_lastmsgtimestamp(uint64_t value) { - _impl_._has_bits_[0] |= 0x00004000u; - _impl_.lastmsgtimestamp_ = value; -} -inline void Conversation::set_lastmsgtimestamp(uint64_t value) { - _internal_set_lastmsgtimestamp(value); - // @@protoc_insertion_point(field_set:proto.Conversation.lastMsgTimestamp) -} - -// optional uint32 unreadCount = 6; -inline bool Conversation::_internal_has_unreadcount() const { - bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0; - return value; -} -inline bool Conversation::has_unreadcount() const { - return _internal_has_unreadcount(); -} -inline void Conversation::clear_unreadcount() { - _impl_.unreadcount_ = 0u; - _impl_._has_bits_[0] &= ~0x00008000u; -} -inline uint32_t Conversation::_internal_unreadcount() const { - return _impl_.unreadcount_; -} -inline uint32_t Conversation::unreadcount() const { - // @@protoc_insertion_point(field_get:proto.Conversation.unreadCount) - return _internal_unreadcount(); -} -inline void Conversation::_internal_set_unreadcount(uint32_t value) { - _impl_._has_bits_[0] |= 0x00008000u; - _impl_.unreadcount_ = value; -} -inline void Conversation::set_unreadcount(uint32_t value) { - _internal_set_unreadcount(value); - // @@protoc_insertion_point(field_set:proto.Conversation.unreadCount) -} - -// optional bool readOnly = 7; -inline bool Conversation::_internal_has_readonly() const { - bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0; - return value; -} -inline bool Conversation::has_readonly() const { - return _internal_has_readonly(); -} -inline void Conversation::clear_readonly() { - _impl_.readonly_ = false; - _impl_._has_bits_[0] &= ~0x00080000u; -} -inline bool Conversation::_internal_readonly() const { - return _impl_.readonly_; -} -inline bool Conversation::readonly() const { - // @@protoc_insertion_point(field_get:proto.Conversation.readOnly) - return _internal_readonly(); -} -inline void Conversation::_internal_set_readonly(bool value) { - _impl_._has_bits_[0] |= 0x00080000u; - _impl_.readonly_ = value; -} -inline void Conversation::set_readonly(bool value) { - _internal_set_readonly(value); - // @@protoc_insertion_point(field_set:proto.Conversation.readOnly) -} - -// optional bool endOfHistoryTransfer = 8; -inline bool Conversation::_internal_has_endofhistorytransfer() const { - bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0; - return value; -} -inline bool Conversation::has_endofhistorytransfer() const { - return _internal_has_endofhistorytransfer(); -} -inline void Conversation::clear_endofhistorytransfer() { - _impl_.endofhistorytransfer_ = false; - _impl_._has_bits_[0] &= ~0x00100000u; -} -inline bool Conversation::_internal_endofhistorytransfer() const { - return _impl_.endofhistorytransfer_; -} -inline bool Conversation::endofhistorytransfer() const { - // @@protoc_insertion_point(field_get:proto.Conversation.endOfHistoryTransfer) - return _internal_endofhistorytransfer(); -} -inline void Conversation::_internal_set_endofhistorytransfer(bool value) { - _impl_._has_bits_[0] |= 0x00100000u; - _impl_.endofhistorytransfer_ = value; -} -inline void Conversation::set_endofhistorytransfer(bool value) { - _internal_set_endofhistorytransfer(value); - // @@protoc_insertion_point(field_set:proto.Conversation.endOfHistoryTransfer) -} - -// optional uint32 ephemeralExpiration = 9; -inline bool Conversation::_internal_has_ephemeralexpiration() const { - bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0; - return value; -} -inline bool Conversation::has_ephemeralexpiration() const { - return _internal_has_ephemeralexpiration(); -} -inline void Conversation::clear_ephemeralexpiration() { - _impl_.ephemeralexpiration_ = 0u; - _impl_._has_bits_[0] &= ~0x00010000u; -} -inline uint32_t Conversation::_internal_ephemeralexpiration() const { - return _impl_.ephemeralexpiration_; -} -inline uint32_t Conversation::ephemeralexpiration() const { - // @@protoc_insertion_point(field_get:proto.Conversation.ephemeralExpiration) - return _internal_ephemeralexpiration(); -} -inline void Conversation::_internal_set_ephemeralexpiration(uint32_t value) { - _impl_._has_bits_[0] |= 0x00010000u; - _impl_.ephemeralexpiration_ = value; -} -inline void Conversation::set_ephemeralexpiration(uint32_t value) { - _internal_set_ephemeralexpiration(value); - // @@protoc_insertion_point(field_set:proto.Conversation.ephemeralExpiration) -} - -// optional int64 ephemeralSettingTimestamp = 10; -inline bool Conversation::_internal_has_ephemeralsettingtimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0; - return value; -} -inline bool Conversation::has_ephemeralsettingtimestamp() const { - return _internal_has_ephemeralsettingtimestamp(); -} -inline void Conversation::clear_ephemeralsettingtimestamp() { - _impl_.ephemeralsettingtimestamp_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00020000u; -} -inline int64_t Conversation::_internal_ephemeralsettingtimestamp() const { - return _impl_.ephemeralsettingtimestamp_; -} -inline int64_t Conversation::ephemeralsettingtimestamp() const { - // @@protoc_insertion_point(field_get:proto.Conversation.ephemeralSettingTimestamp) - return _internal_ephemeralsettingtimestamp(); -} -inline void Conversation::_internal_set_ephemeralsettingtimestamp(int64_t value) { - _impl_._has_bits_[0] |= 0x00020000u; - _impl_.ephemeralsettingtimestamp_ = value; -} -inline void Conversation::set_ephemeralsettingtimestamp(int64_t value) { - _internal_set_ephemeralsettingtimestamp(value); - // @@protoc_insertion_point(field_set:proto.Conversation.ephemeralSettingTimestamp) -} - -// optional .proto.Conversation.EndOfHistoryTransferType endOfHistoryTransferType = 11; -inline bool Conversation::_internal_has_endofhistorytransfertype() const { - bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0; - return value; -} -inline bool Conversation::has_endofhistorytransfertype() const { - return _internal_has_endofhistorytransfertype(); -} -inline void Conversation::clear_endofhistorytransfertype() { - _impl_.endofhistorytransfertype_ = 0; - _impl_._has_bits_[0] &= ~0x00040000u; -} -inline ::proto::Conversation_EndOfHistoryTransferType Conversation::_internal_endofhistorytransfertype() const { - return static_cast< ::proto::Conversation_EndOfHistoryTransferType >(_impl_.endofhistorytransfertype_); -} -inline ::proto::Conversation_EndOfHistoryTransferType Conversation::endofhistorytransfertype() const { - // @@protoc_insertion_point(field_get:proto.Conversation.endOfHistoryTransferType) - return _internal_endofhistorytransfertype(); -} -inline void Conversation::_internal_set_endofhistorytransfertype(::proto::Conversation_EndOfHistoryTransferType value) { - assert(::proto::Conversation_EndOfHistoryTransferType_IsValid(value)); - _impl_._has_bits_[0] |= 0x00040000u; - _impl_.endofhistorytransfertype_ = value; -} -inline void Conversation::set_endofhistorytransfertype(::proto::Conversation_EndOfHistoryTransferType value) { - _internal_set_endofhistorytransfertype(value); - // @@protoc_insertion_point(field_set:proto.Conversation.endOfHistoryTransferType) -} - -// optional uint64 conversationTimestamp = 12; -inline bool Conversation::_internal_has_conversationtimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0; - return value; -} -inline bool Conversation::has_conversationtimestamp() const { - return _internal_has_conversationtimestamp(); -} -inline void Conversation::clear_conversationtimestamp() { - _impl_.conversationtimestamp_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00800000u; -} -inline uint64_t Conversation::_internal_conversationtimestamp() const { - return _impl_.conversationtimestamp_; -} -inline uint64_t Conversation::conversationtimestamp() const { - // @@protoc_insertion_point(field_get:proto.Conversation.conversationTimestamp) - return _internal_conversationtimestamp(); -} -inline void Conversation::_internal_set_conversationtimestamp(uint64_t value) { - _impl_._has_bits_[0] |= 0x00800000u; - _impl_.conversationtimestamp_ = value; -} -inline void Conversation::set_conversationtimestamp(uint64_t value) { - _internal_set_conversationtimestamp(value); - // @@protoc_insertion_point(field_set:proto.Conversation.conversationTimestamp) -} - -// optional string name = 13; -inline bool Conversation::_internal_has_name() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool Conversation::has_name() const { - return _internal_has_name(); -} -inline void Conversation::clear_name() { - _impl_.name_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const std::string& Conversation::name() const { - // @@protoc_insertion_point(field_get:proto.Conversation.name) - return _internal_name(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Conversation::set_name(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Conversation.name) -} -inline std::string* Conversation::mutable_name() { - std::string* _s = _internal_mutable_name(); - // @@protoc_insertion_point(field_mutable:proto.Conversation.name) - return _s; -} -inline const std::string& Conversation::_internal_name() const { - return _impl_.name_.Get(); -} -inline void Conversation::_internal_set_name(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.name_.Set(value, GetArenaForAllocation()); -} -inline std::string* Conversation::_internal_mutable_name() { - _impl_._has_bits_[0] |= 0x00000008u; - return _impl_.name_.Mutable(GetArenaForAllocation()); -} -inline std::string* Conversation::release_name() { - // @@protoc_insertion_point(field_release:proto.Conversation.name) - if (!_internal_has_name()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000008u; - auto* p = _impl_.name_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.name_.IsDefault()) { - _impl_.name_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Conversation::set_allocated_name(std::string* name) { - if (name != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.name_.SetAllocated(name, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.name_.IsDefault()) { - _impl_.name_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Conversation.name) -} - -// optional string pHash = 14; -inline bool Conversation::_internal_has_phash() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool Conversation::has_phash() const { - return _internal_has_phash(); -} -inline void Conversation::clear_phash() { - _impl_.phash_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const std::string& Conversation::phash() const { - // @@protoc_insertion_point(field_get:proto.Conversation.pHash) - return _internal_phash(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Conversation::set_phash(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.phash_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Conversation.pHash) -} -inline std::string* Conversation::mutable_phash() { - std::string* _s = _internal_mutable_phash(); - // @@protoc_insertion_point(field_mutable:proto.Conversation.pHash) - return _s; -} -inline const std::string& Conversation::_internal_phash() const { - return _impl_.phash_.Get(); -} -inline void Conversation::_internal_set_phash(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.phash_.Set(value, GetArenaForAllocation()); -} -inline std::string* Conversation::_internal_mutable_phash() { - _impl_._has_bits_[0] |= 0x00000010u; - return _impl_.phash_.Mutable(GetArenaForAllocation()); -} -inline std::string* Conversation::release_phash() { - // @@protoc_insertion_point(field_release:proto.Conversation.pHash) - if (!_internal_has_phash()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000010u; - auto* p = _impl_.phash_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.phash_.IsDefault()) { - _impl_.phash_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Conversation::set_allocated_phash(std::string* phash) { - if (phash != nullptr) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.phash_.SetAllocated(phash, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.phash_.IsDefault()) { - _impl_.phash_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Conversation.pHash) -} - -// optional bool notSpam = 15; -inline bool Conversation::_internal_has_notspam() const { - bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0; - return value; -} -inline bool Conversation::has_notspam() const { - return _internal_has_notspam(); -} -inline void Conversation::clear_notspam() { - _impl_.notspam_ = false; - _impl_._has_bits_[0] &= ~0x00200000u; -} -inline bool Conversation::_internal_notspam() const { - return _impl_.notspam_; -} -inline bool Conversation::notspam() const { - // @@protoc_insertion_point(field_get:proto.Conversation.notSpam) - return _internal_notspam(); -} -inline void Conversation::_internal_set_notspam(bool value) { - _impl_._has_bits_[0] |= 0x00200000u; - _impl_.notspam_ = value; -} -inline void Conversation::set_notspam(bool value) { - _internal_set_notspam(value); - // @@protoc_insertion_point(field_set:proto.Conversation.notSpam) -} - -// optional bool archived = 16; -inline bool Conversation::_internal_has_archived() const { - bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0; - return value; -} -inline bool Conversation::has_archived() const { - return _internal_has_archived(); -} -inline void Conversation::clear_archived() { - _impl_.archived_ = false; - _impl_._has_bits_[0] &= ~0x00400000u; -} -inline bool Conversation::_internal_archived() const { - return _impl_.archived_; -} -inline bool Conversation::archived() const { - // @@protoc_insertion_point(field_get:proto.Conversation.archived) - return _internal_archived(); -} -inline void Conversation::_internal_set_archived(bool value) { - _impl_._has_bits_[0] |= 0x00400000u; - _impl_.archived_ = value; -} -inline void Conversation::set_archived(bool value) { - _internal_set_archived(value); - // @@protoc_insertion_point(field_set:proto.Conversation.archived) -} - -// optional .proto.DisappearingMode disappearingMode = 17; -inline bool Conversation::_internal_has_disappearingmode() const { - bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.disappearingmode_ != nullptr); - return value; -} -inline bool Conversation::has_disappearingmode() const { - return _internal_has_disappearingmode(); -} -inline void Conversation::clear_disappearingmode() { - if (_impl_.disappearingmode_ != nullptr) _impl_.disappearingmode_->Clear(); - _impl_._has_bits_[0] &= ~0x00001000u; -} -inline const ::proto::DisappearingMode& Conversation::_internal_disappearingmode() const { - const ::proto::DisappearingMode* p = _impl_.disappearingmode_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_DisappearingMode_default_instance_); -} -inline const ::proto::DisappearingMode& Conversation::disappearingmode() const { - // @@protoc_insertion_point(field_get:proto.Conversation.disappearingMode) - return _internal_disappearingmode(); -} -inline void Conversation::unsafe_arena_set_allocated_disappearingmode( - ::proto::DisappearingMode* disappearingmode) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.disappearingmode_); - } - _impl_.disappearingmode_ = disappearingmode; - if (disappearingmode) { - _impl_._has_bits_[0] |= 0x00001000u; - } else { - _impl_._has_bits_[0] &= ~0x00001000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Conversation.disappearingMode) -} -inline ::proto::DisappearingMode* Conversation::release_disappearingmode() { - _impl_._has_bits_[0] &= ~0x00001000u; - ::proto::DisappearingMode* temp = _impl_.disappearingmode_; - _impl_.disappearingmode_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::DisappearingMode* Conversation::unsafe_arena_release_disappearingmode() { - // @@protoc_insertion_point(field_release:proto.Conversation.disappearingMode) - _impl_._has_bits_[0] &= ~0x00001000u; - ::proto::DisappearingMode* temp = _impl_.disappearingmode_; - _impl_.disappearingmode_ = nullptr; - return temp; -} -inline ::proto::DisappearingMode* Conversation::_internal_mutable_disappearingmode() { - _impl_._has_bits_[0] |= 0x00001000u; - if (_impl_.disappearingmode_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::DisappearingMode>(GetArenaForAllocation()); - _impl_.disappearingmode_ = p; - } - return _impl_.disappearingmode_; -} -inline ::proto::DisappearingMode* Conversation::mutable_disappearingmode() { - ::proto::DisappearingMode* _msg = _internal_mutable_disappearingmode(); - // @@protoc_insertion_point(field_mutable:proto.Conversation.disappearingMode) - return _msg; -} -inline void Conversation::set_allocated_disappearingmode(::proto::DisappearingMode* disappearingmode) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.disappearingmode_; - } - if (disappearingmode) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(disappearingmode); - if (message_arena != submessage_arena) { - disappearingmode = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, disappearingmode, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00001000u; - } else { - _impl_._has_bits_[0] &= ~0x00001000u; - } - _impl_.disappearingmode_ = disappearingmode; - // @@protoc_insertion_point(field_set_allocated:proto.Conversation.disappearingMode) -} - -// optional uint32 unreadMentionCount = 18; -inline bool Conversation::_internal_has_unreadmentioncount() const { - bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0; - return value; -} -inline bool Conversation::has_unreadmentioncount() const { - return _internal_has_unreadmentioncount(); -} -inline void Conversation::clear_unreadmentioncount() { - _impl_.unreadmentioncount_ = 0u; - _impl_._has_bits_[0] &= ~0x01000000u; -} -inline uint32_t Conversation::_internal_unreadmentioncount() const { - return _impl_.unreadmentioncount_; -} -inline uint32_t Conversation::unreadmentioncount() const { - // @@protoc_insertion_point(field_get:proto.Conversation.unreadMentionCount) - return _internal_unreadmentioncount(); -} -inline void Conversation::_internal_set_unreadmentioncount(uint32_t value) { - _impl_._has_bits_[0] |= 0x01000000u; - _impl_.unreadmentioncount_ = value; -} -inline void Conversation::set_unreadmentioncount(uint32_t value) { - _internal_set_unreadmentioncount(value); - // @@protoc_insertion_point(field_set:proto.Conversation.unreadMentionCount) -} - -// optional bool markedAsUnread = 19; -inline bool Conversation::_internal_has_markedasunread() const { - bool value = (_impl_._has_bits_[0] & 0x20000000u) != 0; - return value; -} -inline bool Conversation::has_markedasunread() const { - return _internal_has_markedasunread(); -} -inline void Conversation::clear_markedasunread() { - _impl_.markedasunread_ = false; - _impl_._has_bits_[0] &= ~0x20000000u; -} -inline bool Conversation::_internal_markedasunread() const { - return _impl_.markedasunread_; -} -inline bool Conversation::markedasunread() const { - // @@protoc_insertion_point(field_get:proto.Conversation.markedAsUnread) - return _internal_markedasunread(); -} -inline void Conversation::_internal_set_markedasunread(bool value) { - _impl_._has_bits_[0] |= 0x20000000u; - _impl_.markedasunread_ = value; -} -inline void Conversation::set_markedasunread(bool value) { - _internal_set_markedasunread(value); - // @@protoc_insertion_point(field_set:proto.Conversation.markedAsUnread) -} - -// repeated .proto.GroupParticipant participant = 20; -inline int Conversation::_internal_participant_size() const { - return _impl_.participant_.size(); -} -inline int Conversation::participant_size() const { - return _internal_participant_size(); -} -inline void Conversation::clear_participant() { - _impl_.participant_.Clear(); -} -inline ::proto::GroupParticipant* Conversation::mutable_participant(int index) { - // @@protoc_insertion_point(field_mutable:proto.Conversation.participant) - return _impl_.participant_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::GroupParticipant >* -Conversation::mutable_participant() { - // @@protoc_insertion_point(field_mutable_list:proto.Conversation.participant) - return &_impl_.participant_; -} -inline const ::proto::GroupParticipant& Conversation::_internal_participant(int index) const { - return _impl_.participant_.Get(index); -} -inline const ::proto::GroupParticipant& Conversation::participant(int index) const { - // @@protoc_insertion_point(field_get:proto.Conversation.participant) - return _internal_participant(index); -} -inline ::proto::GroupParticipant* Conversation::_internal_add_participant() { - return _impl_.participant_.Add(); -} -inline ::proto::GroupParticipant* Conversation::add_participant() { - ::proto::GroupParticipant* _add = _internal_add_participant(); - // @@protoc_insertion_point(field_add:proto.Conversation.participant) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::GroupParticipant >& -Conversation::participant() const { - // @@protoc_insertion_point(field_list:proto.Conversation.participant) - return _impl_.participant_; -} - -// optional bytes tcToken = 21; -inline bool Conversation::_internal_has_tctoken() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool Conversation::has_tctoken() const { - return _internal_has_tctoken(); -} -inline void Conversation::clear_tctoken() { - _impl_.tctoken_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline const std::string& Conversation::tctoken() const { - // @@protoc_insertion_point(field_get:proto.Conversation.tcToken) - return _internal_tctoken(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Conversation::set_tctoken(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.tctoken_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Conversation.tcToken) -} -inline std::string* Conversation::mutable_tctoken() { - std::string* _s = _internal_mutable_tctoken(); - // @@protoc_insertion_point(field_mutable:proto.Conversation.tcToken) - return _s; -} -inline const std::string& Conversation::_internal_tctoken() const { - return _impl_.tctoken_.Get(); -} -inline void Conversation::_internal_set_tctoken(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.tctoken_.Set(value, GetArenaForAllocation()); -} -inline std::string* Conversation::_internal_mutable_tctoken() { - _impl_._has_bits_[0] |= 0x00000020u; - return _impl_.tctoken_.Mutable(GetArenaForAllocation()); -} -inline std::string* Conversation::release_tctoken() { - // @@protoc_insertion_point(field_release:proto.Conversation.tcToken) - if (!_internal_has_tctoken()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000020u; - auto* p = _impl_.tctoken_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.tctoken_.IsDefault()) { - _impl_.tctoken_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Conversation::set_allocated_tctoken(std::string* tctoken) { - if (tctoken != nullptr) { - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - _impl_.tctoken_.SetAllocated(tctoken, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.tctoken_.IsDefault()) { - _impl_.tctoken_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Conversation.tcToken) -} - -// optional uint64 tcTokenTimestamp = 22; -inline bool Conversation::_internal_has_tctokentimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0; - return value; -} -inline bool Conversation::has_tctokentimestamp() const { - return _internal_has_tctokentimestamp(); -} -inline void Conversation::clear_tctokentimestamp() { - _impl_.tctokentimestamp_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x04000000u; -} -inline uint64_t Conversation::_internal_tctokentimestamp() const { - return _impl_.tctokentimestamp_; -} -inline uint64_t Conversation::tctokentimestamp() const { - // @@protoc_insertion_point(field_get:proto.Conversation.tcTokenTimestamp) - return _internal_tctokentimestamp(); -} -inline void Conversation::_internal_set_tctokentimestamp(uint64_t value) { - _impl_._has_bits_[0] |= 0x04000000u; - _impl_.tctokentimestamp_ = value; -} -inline void Conversation::set_tctokentimestamp(uint64_t value) { - _internal_set_tctokentimestamp(value); - // @@protoc_insertion_point(field_set:proto.Conversation.tcTokenTimestamp) -} - -// optional bytes contactPrimaryIdentityKey = 23; -inline bool Conversation::_internal_has_contactprimaryidentitykey() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool Conversation::has_contactprimaryidentitykey() const { - return _internal_has_contactprimaryidentitykey(); -} -inline void Conversation::clear_contactprimaryidentitykey() { - _impl_.contactprimaryidentitykey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline const std::string& Conversation::contactprimaryidentitykey() const { - // @@protoc_insertion_point(field_get:proto.Conversation.contactPrimaryIdentityKey) - return _internal_contactprimaryidentitykey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Conversation::set_contactprimaryidentitykey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.contactprimaryidentitykey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Conversation.contactPrimaryIdentityKey) -} -inline std::string* Conversation::mutable_contactprimaryidentitykey() { - std::string* _s = _internal_mutable_contactprimaryidentitykey(); - // @@protoc_insertion_point(field_mutable:proto.Conversation.contactPrimaryIdentityKey) - return _s; -} -inline const std::string& Conversation::_internal_contactprimaryidentitykey() const { - return _impl_.contactprimaryidentitykey_.Get(); -} -inline void Conversation::_internal_set_contactprimaryidentitykey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.contactprimaryidentitykey_.Set(value, GetArenaForAllocation()); -} -inline std::string* Conversation::_internal_mutable_contactprimaryidentitykey() { - _impl_._has_bits_[0] |= 0x00000040u; - return _impl_.contactprimaryidentitykey_.Mutable(GetArenaForAllocation()); -} -inline std::string* Conversation::release_contactprimaryidentitykey() { - // @@protoc_insertion_point(field_release:proto.Conversation.contactPrimaryIdentityKey) - if (!_internal_has_contactprimaryidentitykey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000040u; - auto* p = _impl_.contactprimaryidentitykey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.contactprimaryidentitykey_.IsDefault()) { - _impl_.contactprimaryidentitykey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Conversation::set_allocated_contactprimaryidentitykey(std::string* contactprimaryidentitykey) { - if (contactprimaryidentitykey != nullptr) { - _impl_._has_bits_[0] |= 0x00000040u; - } else { - _impl_._has_bits_[0] &= ~0x00000040u; - } - _impl_.contactprimaryidentitykey_.SetAllocated(contactprimaryidentitykey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.contactprimaryidentitykey_.IsDefault()) { - _impl_.contactprimaryidentitykey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Conversation.contactPrimaryIdentityKey) -} - -// optional uint32 pinned = 24; -inline bool Conversation::_internal_has_pinned() const { - bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0; - return value; -} -inline bool Conversation::has_pinned() const { - return _internal_has_pinned(); -} -inline void Conversation::clear_pinned() { - _impl_.pinned_ = 0u; - _impl_._has_bits_[0] &= ~0x02000000u; -} -inline uint32_t Conversation::_internal_pinned() const { - return _impl_.pinned_; -} -inline uint32_t Conversation::pinned() const { - // @@protoc_insertion_point(field_get:proto.Conversation.pinned) - return _internal_pinned(); -} -inline void Conversation::_internal_set_pinned(uint32_t value) { - _impl_._has_bits_[0] |= 0x02000000u; - _impl_.pinned_ = value; -} -inline void Conversation::set_pinned(uint32_t value) { - _internal_set_pinned(value); - // @@protoc_insertion_point(field_set:proto.Conversation.pinned) -} - -// optional uint64 muteEndTime = 25; -inline bool Conversation::_internal_has_muteendtime() const { - bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0; - return value; -} -inline bool Conversation::has_muteendtime() const { - return _internal_has_muteendtime(); -} -inline void Conversation::clear_muteendtime() { - _impl_.muteendtime_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x08000000u; -} -inline uint64_t Conversation::_internal_muteendtime() const { - return _impl_.muteendtime_; -} -inline uint64_t Conversation::muteendtime() const { - // @@protoc_insertion_point(field_get:proto.Conversation.muteEndTime) - return _internal_muteendtime(); -} -inline void Conversation::_internal_set_muteendtime(uint64_t value) { - _impl_._has_bits_[0] |= 0x08000000u; - _impl_.muteendtime_ = value; -} -inline void Conversation::set_muteendtime(uint64_t value) { - _internal_set_muteendtime(value); - // @@protoc_insertion_point(field_set:proto.Conversation.muteEndTime) -} - -// optional .proto.WallpaperSettings wallpaper = 26; -inline bool Conversation::_internal_has_wallpaper() const { - bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.wallpaper_ != nullptr); - return value; -} -inline bool Conversation::has_wallpaper() const { - return _internal_has_wallpaper(); -} -inline void Conversation::clear_wallpaper() { - if (_impl_.wallpaper_ != nullptr) _impl_.wallpaper_->Clear(); - _impl_._has_bits_[0] &= ~0x00002000u; -} -inline const ::proto::WallpaperSettings& Conversation::_internal_wallpaper() const { - const ::proto::WallpaperSettings* p = _impl_.wallpaper_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_WallpaperSettings_default_instance_); -} -inline const ::proto::WallpaperSettings& Conversation::wallpaper() const { - // @@protoc_insertion_point(field_get:proto.Conversation.wallpaper) - return _internal_wallpaper(); -} -inline void Conversation::unsafe_arena_set_allocated_wallpaper( - ::proto::WallpaperSettings* wallpaper) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.wallpaper_); - } - _impl_.wallpaper_ = wallpaper; - if (wallpaper) { - _impl_._has_bits_[0] |= 0x00002000u; - } else { - _impl_._has_bits_[0] &= ~0x00002000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Conversation.wallpaper) -} -inline ::proto::WallpaperSettings* Conversation::release_wallpaper() { - _impl_._has_bits_[0] &= ~0x00002000u; - ::proto::WallpaperSettings* temp = _impl_.wallpaper_; - _impl_.wallpaper_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::WallpaperSettings* Conversation::unsafe_arena_release_wallpaper() { - // @@protoc_insertion_point(field_release:proto.Conversation.wallpaper) - _impl_._has_bits_[0] &= ~0x00002000u; - ::proto::WallpaperSettings* temp = _impl_.wallpaper_; - _impl_.wallpaper_ = nullptr; - return temp; -} -inline ::proto::WallpaperSettings* Conversation::_internal_mutable_wallpaper() { - _impl_._has_bits_[0] |= 0x00002000u; - if (_impl_.wallpaper_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::WallpaperSettings>(GetArenaForAllocation()); - _impl_.wallpaper_ = p; - } - return _impl_.wallpaper_; -} -inline ::proto::WallpaperSettings* Conversation::mutable_wallpaper() { - ::proto::WallpaperSettings* _msg = _internal_mutable_wallpaper(); - // @@protoc_insertion_point(field_mutable:proto.Conversation.wallpaper) - return _msg; -} -inline void Conversation::set_allocated_wallpaper(::proto::WallpaperSettings* wallpaper) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.wallpaper_; - } - if (wallpaper) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(wallpaper); - if (message_arena != submessage_arena) { - wallpaper = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, wallpaper, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00002000u; - } else { - _impl_._has_bits_[0] &= ~0x00002000u; - } - _impl_.wallpaper_ = wallpaper; - // @@protoc_insertion_point(field_set_allocated:proto.Conversation.wallpaper) -} - -// optional .proto.MediaVisibility mediaVisibility = 27; -inline bool Conversation::_internal_has_mediavisibility() const { - bool value = (_impl_._has_bits_[0] & 0x10000000u) != 0; - return value; -} -inline bool Conversation::has_mediavisibility() const { - return _internal_has_mediavisibility(); -} -inline void Conversation::clear_mediavisibility() { - _impl_.mediavisibility_ = 0; - _impl_._has_bits_[0] &= ~0x10000000u; -} -inline ::proto::MediaVisibility Conversation::_internal_mediavisibility() const { - return static_cast< ::proto::MediaVisibility >(_impl_.mediavisibility_); -} -inline ::proto::MediaVisibility Conversation::mediavisibility() const { - // @@protoc_insertion_point(field_get:proto.Conversation.mediaVisibility) - return _internal_mediavisibility(); -} -inline void Conversation::_internal_set_mediavisibility(::proto::MediaVisibility value) { - assert(::proto::MediaVisibility_IsValid(value)); - _impl_._has_bits_[0] |= 0x10000000u; - _impl_.mediavisibility_ = value; -} -inline void Conversation::set_mediavisibility(::proto::MediaVisibility value) { - _internal_set_mediavisibility(value); - // @@protoc_insertion_point(field_set:proto.Conversation.mediaVisibility) -} - -// optional uint64 tcTokenSenderTimestamp = 28; -inline bool Conversation::_internal_has_tctokensendertimestamp() const { - bool value = (_impl_._has_bits_[1] & 0x00000002u) != 0; - return value; -} -inline bool Conversation::has_tctokensendertimestamp() const { - return _internal_has_tctokensendertimestamp(); -} -inline void Conversation::clear_tctokensendertimestamp() { - _impl_.tctokensendertimestamp_ = uint64_t{0u}; - _impl_._has_bits_[1] &= ~0x00000002u; -} -inline uint64_t Conversation::_internal_tctokensendertimestamp() const { - return _impl_.tctokensendertimestamp_; -} -inline uint64_t Conversation::tctokensendertimestamp() const { - // @@protoc_insertion_point(field_get:proto.Conversation.tcTokenSenderTimestamp) - return _internal_tctokensendertimestamp(); -} -inline void Conversation::_internal_set_tctokensendertimestamp(uint64_t value) { - _impl_._has_bits_[1] |= 0x00000002u; - _impl_.tctokensendertimestamp_ = value; -} -inline void Conversation::set_tctokensendertimestamp(uint64_t value) { - _internal_set_tctokensendertimestamp(value); - // @@protoc_insertion_point(field_set:proto.Conversation.tcTokenSenderTimestamp) -} - -// optional bool suspended = 29; -inline bool Conversation::_internal_has_suspended() const { - bool value = (_impl_._has_bits_[0] & 0x40000000u) != 0; - return value; -} -inline bool Conversation::has_suspended() const { - return _internal_has_suspended(); -} -inline void Conversation::clear_suspended() { - _impl_.suspended_ = false; - _impl_._has_bits_[0] &= ~0x40000000u; -} -inline bool Conversation::_internal_suspended() const { - return _impl_.suspended_; -} -inline bool Conversation::suspended() const { - // @@protoc_insertion_point(field_get:proto.Conversation.suspended) - return _internal_suspended(); -} -inline void Conversation::_internal_set_suspended(bool value) { - _impl_._has_bits_[0] |= 0x40000000u; - _impl_.suspended_ = value; -} -inline void Conversation::set_suspended(bool value) { - _internal_set_suspended(value); - // @@protoc_insertion_point(field_set:proto.Conversation.suspended) -} - -// optional bool terminated = 30; -inline bool Conversation::_internal_has_terminated() const { - bool value = (_impl_._has_bits_[0] & 0x80000000u) != 0; - return value; -} -inline bool Conversation::has_terminated() const { - return _internal_has_terminated(); -} -inline void Conversation::clear_terminated() { - _impl_.terminated_ = false; - _impl_._has_bits_[0] &= ~0x80000000u; -} -inline bool Conversation::_internal_terminated() const { - return _impl_.terminated_; -} -inline bool Conversation::terminated() const { - // @@protoc_insertion_point(field_get:proto.Conversation.terminated) - return _internal_terminated(); -} -inline void Conversation::_internal_set_terminated(bool value) { - _impl_._has_bits_[0] |= 0x80000000u; - _impl_.terminated_ = value; -} -inline void Conversation::set_terminated(bool value) { - _internal_set_terminated(value); - // @@protoc_insertion_point(field_set:proto.Conversation.terminated) -} - -// optional uint64 createdAt = 31; -inline bool Conversation::_internal_has_createdat() const { - bool value = (_impl_._has_bits_[1] & 0x00000004u) != 0; - return value; -} -inline bool Conversation::has_createdat() const { - return _internal_has_createdat(); -} -inline void Conversation::clear_createdat() { - _impl_.createdat_ = uint64_t{0u}; - _impl_._has_bits_[1] &= ~0x00000004u; -} -inline uint64_t Conversation::_internal_createdat() const { - return _impl_.createdat_; -} -inline uint64_t Conversation::createdat() const { - // @@protoc_insertion_point(field_get:proto.Conversation.createdAt) - return _internal_createdat(); -} -inline void Conversation::_internal_set_createdat(uint64_t value) { - _impl_._has_bits_[1] |= 0x00000004u; - _impl_.createdat_ = value; -} -inline void Conversation::set_createdat(uint64_t value) { - _internal_set_createdat(value); - // @@protoc_insertion_point(field_set:proto.Conversation.createdAt) -} - -// optional string createdBy = 32; -inline bool Conversation::_internal_has_createdby() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - return value; -} -inline bool Conversation::has_createdby() const { - return _internal_has_createdby(); -} -inline void Conversation::clear_createdby() { - _impl_.createdby_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline const std::string& Conversation::createdby() const { - // @@protoc_insertion_point(field_get:proto.Conversation.createdBy) - return _internal_createdby(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Conversation::set_createdby(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.createdby_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Conversation.createdBy) -} -inline std::string* Conversation::mutable_createdby() { - std::string* _s = _internal_mutable_createdby(); - // @@protoc_insertion_point(field_mutable:proto.Conversation.createdBy) - return _s; -} -inline const std::string& Conversation::_internal_createdby() const { - return _impl_.createdby_.Get(); -} -inline void Conversation::_internal_set_createdby(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.createdby_.Set(value, GetArenaForAllocation()); -} -inline std::string* Conversation::_internal_mutable_createdby() { - _impl_._has_bits_[0] |= 0x00000080u; - return _impl_.createdby_.Mutable(GetArenaForAllocation()); -} -inline std::string* Conversation::release_createdby() { - // @@protoc_insertion_point(field_release:proto.Conversation.createdBy) - if (!_internal_has_createdby()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000080u; - auto* p = _impl_.createdby_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.createdby_.IsDefault()) { - _impl_.createdby_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Conversation::set_allocated_createdby(std::string* createdby) { - if (createdby != nullptr) { - _impl_._has_bits_[0] |= 0x00000080u; - } else { - _impl_._has_bits_[0] &= ~0x00000080u; - } - _impl_.createdby_.SetAllocated(createdby, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.createdby_.IsDefault()) { - _impl_.createdby_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Conversation.createdBy) -} - -// optional string description = 33; -inline bool Conversation::_internal_has_description() const { - bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; - return value; -} -inline bool Conversation::has_description() const { - return _internal_has_description(); -} -inline void Conversation::clear_description() { - _impl_.description_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000100u; -} -inline const std::string& Conversation::description() const { - // @@protoc_insertion_point(field_get:proto.Conversation.description) - return _internal_description(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Conversation::set_description(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000100u; - _impl_.description_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Conversation.description) -} -inline std::string* Conversation::mutable_description() { - std::string* _s = _internal_mutable_description(); - // @@protoc_insertion_point(field_mutable:proto.Conversation.description) - return _s; -} -inline const std::string& Conversation::_internal_description() const { - return _impl_.description_.Get(); -} -inline void Conversation::_internal_set_description(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000100u; - _impl_.description_.Set(value, GetArenaForAllocation()); -} -inline std::string* Conversation::_internal_mutable_description() { - _impl_._has_bits_[0] |= 0x00000100u; - return _impl_.description_.Mutable(GetArenaForAllocation()); -} -inline std::string* Conversation::release_description() { - // @@protoc_insertion_point(field_release:proto.Conversation.description) - if (!_internal_has_description()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000100u; - auto* p = _impl_.description_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.description_.IsDefault()) { - _impl_.description_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Conversation::set_allocated_description(std::string* description) { - if (description != nullptr) { - _impl_._has_bits_[0] |= 0x00000100u; - } else { - _impl_._has_bits_[0] &= ~0x00000100u; - } - _impl_.description_.SetAllocated(description, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.description_.IsDefault()) { - _impl_.description_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Conversation.description) -} - -// optional bool support = 34; -inline bool Conversation::_internal_has_support() const { - bool value = (_impl_._has_bits_[1] & 0x00000001u) != 0; - return value; -} -inline bool Conversation::has_support() const { - return _internal_has_support(); -} -inline void Conversation::clear_support() { - _impl_.support_ = false; - _impl_._has_bits_[1] &= ~0x00000001u; -} -inline bool Conversation::_internal_support() const { - return _impl_.support_; -} -inline bool Conversation::support() const { - // @@protoc_insertion_point(field_get:proto.Conversation.support) - return _internal_support(); -} -inline void Conversation::_internal_set_support(bool value) { - _impl_._has_bits_[1] |= 0x00000001u; - _impl_.support_ = value; -} -inline void Conversation::set_support(bool value) { - _internal_set_support(value); - // @@protoc_insertion_point(field_set:proto.Conversation.support) -} - -// optional bool isParentGroup = 35; -inline bool Conversation::_internal_has_isparentgroup() const { - bool value = (_impl_._has_bits_[1] & 0x00000008u) != 0; - return value; -} -inline bool Conversation::has_isparentgroup() const { - return _internal_has_isparentgroup(); -} -inline void Conversation::clear_isparentgroup() { - _impl_.isparentgroup_ = false; - _impl_._has_bits_[1] &= ~0x00000008u; -} -inline bool Conversation::_internal_isparentgroup() const { - return _impl_.isparentgroup_; -} -inline bool Conversation::isparentgroup() const { - // @@protoc_insertion_point(field_get:proto.Conversation.isParentGroup) - return _internal_isparentgroup(); -} -inline void Conversation::_internal_set_isparentgroup(bool value) { - _impl_._has_bits_[1] |= 0x00000008u; - _impl_.isparentgroup_ = value; -} -inline void Conversation::set_isparentgroup(bool value) { - _internal_set_isparentgroup(value); - // @@protoc_insertion_point(field_set:proto.Conversation.isParentGroup) -} - -// optional bool isDefaultSubgroup = 36; -inline bool Conversation::_internal_has_isdefaultsubgroup() const { - bool value = (_impl_._has_bits_[1] & 0x00000010u) != 0; - return value; -} -inline bool Conversation::has_isdefaultsubgroup() const { - return _internal_has_isdefaultsubgroup(); -} -inline void Conversation::clear_isdefaultsubgroup() { - _impl_.isdefaultsubgroup_ = false; - _impl_._has_bits_[1] &= ~0x00000010u; -} -inline bool Conversation::_internal_isdefaultsubgroup() const { - return _impl_.isdefaultsubgroup_; -} -inline bool Conversation::isdefaultsubgroup() const { - // @@protoc_insertion_point(field_get:proto.Conversation.isDefaultSubgroup) - return _internal_isdefaultsubgroup(); -} -inline void Conversation::_internal_set_isdefaultsubgroup(bool value) { - _impl_._has_bits_[1] |= 0x00000010u; - _impl_.isdefaultsubgroup_ = value; -} -inline void Conversation::set_isdefaultsubgroup(bool value) { - _internal_set_isdefaultsubgroup(value); - // @@protoc_insertion_point(field_set:proto.Conversation.isDefaultSubgroup) -} - -// optional string parentGroupId = 37; -inline bool Conversation::_internal_has_parentgroupid() const { - bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; - return value; -} -inline bool Conversation::has_parentgroupid() const { - return _internal_has_parentgroupid(); -} -inline void Conversation::clear_parentgroupid() { - _impl_.parentgroupid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000200u; -} -inline const std::string& Conversation::parentgroupid() const { - // @@protoc_insertion_point(field_get:proto.Conversation.parentGroupId) - return _internal_parentgroupid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Conversation::set_parentgroupid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.parentgroupid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Conversation.parentGroupId) -} -inline std::string* Conversation::mutable_parentgroupid() { - std::string* _s = _internal_mutable_parentgroupid(); - // @@protoc_insertion_point(field_mutable:proto.Conversation.parentGroupId) - return _s; -} -inline const std::string& Conversation::_internal_parentgroupid() const { - return _impl_.parentgroupid_.Get(); -} -inline void Conversation::_internal_set_parentgroupid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.parentgroupid_.Set(value, GetArenaForAllocation()); -} -inline std::string* Conversation::_internal_mutable_parentgroupid() { - _impl_._has_bits_[0] |= 0x00000200u; - return _impl_.parentgroupid_.Mutable(GetArenaForAllocation()); -} -inline std::string* Conversation::release_parentgroupid() { - // @@protoc_insertion_point(field_release:proto.Conversation.parentGroupId) - if (!_internal_has_parentgroupid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000200u; - auto* p = _impl_.parentgroupid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.parentgroupid_.IsDefault()) { - _impl_.parentgroupid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Conversation::set_allocated_parentgroupid(std::string* parentgroupid) { - if (parentgroupid != nullptr) { - _impl_._has_bits_[0] |= 0x00000200u; - } else { - _impl_._has_bits_[0] &= ~0x00000200u; - } - _impl_.parentgroupid_.SetAllocated(parentgroupid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.parentgroupid_.IsDefault()) { - _impl_.parentgroupid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Conversation.parentGroupId) -} - -// optional string displayName = 38; -inline bool Conversation::_internal_has_displayname() const { - bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; - return value; -} -inline bool Conversation::has_displayname() const { - return _internal_has_displayname(); -} -inline void Conversation::clear_displayname() { - _impl_.displayname_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000400u; -} -inline const std::string& Conversation::displayname() const { - // @@protoc_insertion_point(field_get:proto.Conversation.displayName) - return _internal_displayname(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Conversation::set_displayname(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000400u; - _impl_.displayname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Conversation.displayName) -} -inline std::string* Conversation::mutable_displayname() { - std::string* _s = _internal_mutable_displayname(); - // @@protoc_insertion_point(field_mutable:proto.Conversation.displayName) - return _s; -} -inline const std::string& Conversation::_internal_displayname() const { - return _impl_.displayname_.Get(); -} -inline void Conversation::_internal_set_displayname(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000400u; - _impl_.displayname_.Set(value, GetArenaForAllocation()); -} -inline std::string* Conversation::_internal_mutable_displayname() { - _impl_._has_bits_[0] |= 0x00000400u; - return _impl_.displayname_.Mutable(GetArenaForAllocation()); -} -inline std::string* Conversation::release_displayname() { - // @@protoc_insertion_point(field_release:proto.Conversation.displayName) - if (!_internal_has_displayname()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000400u; - auto* p = _impl_.displayname_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.displayname_.IsDefault()) { - _impl_.displayname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Conversation::set_allocated_displayname(std::string* displayname) { - if (displayname != nullptr) { - _impl_._has_bits_[0] |= 0x00000400u; - } else { - _impl_._has_bits_[0] &= ~0x00000400u; - } - _impl_.displayname_.SetAllocated(displayname, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.displayname_.IsDefault()) { - _impl_.displayname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Conversation.displayName) -} - -// optional string pnJid = 39; -inline bool Conversation::_internal_has_pnjid() const { - bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; - return value; -} -inline bool Conversation::has_pnjid() const { - return _internal_has_pnjid(); -} -inline void Conversation::clear_pnjid() { - _impl_.pnjid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000800u; -} -inline const std::string& Conversation::pnjid() const { - // @@protoc_insertion_point(field_get:proto.Conversation.pnJid) - return _internal_pnjid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Conversation::set_pnjid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000800u; - _impl_.pnjid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Conversation.pnJid) -} -inline std::string* Conversation::mutable_pnjid() { - std::string* _s = _internal_mutable_pnjid(); - // @@protoc_insertion_point(field_mutable:proto.Conversation.pnJid) - return _s; -} -inline const std::string& Conversation::_internal_pnjid() const { - return _impl_.pnjid_.Get(); -} -inline void Conversation::_internal_set_pnjid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000800u; - _impl_.pnjid_.Set(value, GetArenaForAllocation()); -} -inline std::string* Conversation::_internal_mutable_pnjid() { - _impl_._has_bits_[0] |= 0x00000800u; - return _impl_.pnjid_.Mutable(GetArenaForAllocation()); -} -inline std::string* Conversation::release_pnjid() { - // @@protoc_insertion_point(field_release:proto.Conversation.pnJid) - if (!_internal_has_pnjid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000800u; - auto* p = _impl_.pnjid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.pnjid_.IsDefault()) { - _impl_.pnjid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Conversation::set_allocated_pnjid(std::string* pnjid) { - if (pnjid != nullptr) { - _impl_._has_bits_[0] |= 0x00000800u; - } else { - _impl_._has_bits_[0] &= ~0x00000800u; - } - _impl_.pnjid_.SetAllocated(pnjid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.pnjid_.IsDefault()) { - _impl_.pnjid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Conversation.pnJid) -} - -// optional bool selfPnExposed = 40; -inline bool Conversation::_internal_has_selfpnexposed() const { - bool value = (_impl_._has_bits_[1] & 0x00000020u) != 0; - return value; -} -inline bool Conversation::has_selfpnexposed() const { - return _internal_has_selfpnexposed(); -} -inline void Conversation::clear_selfpnexposed() { - _impl_.selfpnexposed_ = false; - _impl_._has_bits_[1] &= ~0x00000020u; -} -inline bool Conversation::_internal_selfpnexposed() const { - return _impl_.selfpnexposed_; -} -inline bool Conversation::selfpnexposed() const { - // @@protoc_insertion_point(field_get:proto.Conversation.selfPnExposed) - return _internal_selfpnexposed(); -} -inline void Conversation::_internal_set_selfpnexposed(bool value) { - _impl_._has_bits_[1] |= 0x00000020u; - _impl_.selfpnexposed_ = value; -} -inline void Conversation::set_selfpnexposed(bool value) { - _internal_set_selfpnexposed(value); - // @@protoc_insertion_point(field_set:proto.Conversation.selfPnExposed) -} - -// ------------------------------------------------------------------- - -// DeviceListMetadata - -// optional bytes senderKeyHash = 1; -inline bool DeviceListMetadata::_internal_has_senderkeyhash() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool DeviceListMetadata::has_senderkeyhash() const { - return _internal_has_senderkeyhash(); -} -inline void DeviceListMetadata::clear_senderkeyhash() { - _impl_.senderkeyhash_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& DeviceListMetadata::senderkeyhash() const { - // @@protoc_insertion_point(field_get:proto.DeviceListMetadata.senderKeyHash) - return _internal_senderkeyhash(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void DeviceListMetadata::set_senderkeyhash(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.senderkeyhash_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.DeviceListMetadata.senderKeyHash) -} -inline std::string* DeviceListMetadata::mutable_senderkeyhash() { - std::string* _s = _internal_mutable_senderkeyhash(); - // @@protoc_insertion_point(field_mutable:proto.DeviceListMetadata.senderKeyHash) - return _s; -} -inline const std::string& DeviceListMetadata::_internal_senderkeyhash() const { - return _impl_.senderkeyhash_.Get(); -} -inline void DeviceListMetadata::_internal_set_senderkeyhash(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.senderkeyhash_.Set(value, GetArenaForAllocation()); -} -inline std::string* DeviceListMetadata::_internal_mutable_senderkeyhash() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.senderkeyhash_.Mutable(GetArenaForAllocation()); -} -inline std::string* DeviceListMetadata::release_senderkeyhash() { - // @@protoc_insertion_point(field_release:proto.DeviceListMetadata.senderKeyHash) - if (!_internal_has_senderkeyhash()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.senderkeyhash_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.senderkeyhash_.IsDefault()) { - _impl_.senderkeyhash_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void DeviceListMetadata::set_allocated_senderkeyhash(std::string* senderkeyhash) { - if (senderkeyhash != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.senderkeyhash_.SetAllocated(senderkeyhash, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.senderkeyhash_.IsDefault()) { - _impl_.senderkeyhash_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.DeviceListMetadata.senderKeyHash) -} - -// optional uint64 senderTimestamp = 2; -inline bool DeviceListMetadata::_internal_has_sendertimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool DeviceListMetadata::has_sendertimestamp() const { - return _internal_has_sendertimestamp(); -} -inline void DeviceListMetadata::clear_sendertimestamp() { - _impl_.sendertimestamp_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline uint64_t DeviceListMetadata::_internal_sendertimestamp() const { - return _impl_.sendertimestamp_; -} -inline uint64_t DeviceListMetadata::sendertimestamp() const { - // @@protoc_insertion_point(field_get:proto.DeviceListMetadata.senderTimestamp) - return _internal_sendertimestamp(); -} -inline void DeviceListMetadata::_internal_set_sendertimestamp(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.sendertimestamp_ = value; -} -inline void DeviceListMetadata::set_sendertimestamp(uint64_t value) { - _internal_set_sendertimestamp(value); - // @@protoc_insertion_point(field_set:proto.DeviceListMetadata.senderTimestamp) -} - -// repeated uint32 senderKeyIndexes = 3 [packed = true]; -inline int DeviceListMetadata::_internal_senderkeyindexes_size() const { - return _impl_.senderkeyindexes_.size(); -} -inline int DeviceListMetadata::senderkeyindexes_size() const { - return _internal_senderkeyindexes_size(); -} -inline void DeviceListMetadata::clear_senderkeyindexes() { - _impl_.senderkeyindexes_.Clear(); -} -inline uint32_t DeviceListMetadata::_internal_senderkeyindexes(int index) const { - return _impl_.senderkeyindexes_.Get(index); -} -inline uint32_t DeviceListMetadata::senderkeyindexes(int index) const { - // @@protoc_insertion_point(field_get:proto.DeviceListMetadata.senderKeyIndexes) - return _internal_senderkeyindexes(index); -} -inline void DeviceListMetadata::set_senderkeyindexes(int index, uint32_t value) { - _impl_.senderkeyindexes_.Set(index, value); - // @@protoc_insertion_point(field_set:proto.DeviceListMetadata.senderKeyIndexes) -} -inline void DeviceListMetadata::_internal_add_senderkeyindexes(uint32_t value) { - _impl_.senderkeyindexes_.Add(value); -} -inline void DeviceListMetadata::add_senderkeyindexes(uint32_t value) { - _internal_add_senderkeyindexes(value); - // @@protoc_insertion_point(field_add:proto.DeviceListMetadata.senderKeyIndexes) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& -DeviceListMetadata::_internal_senderkeyindexes() const { - return _impl_.senderkeyindexes_; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& -DeviceListMetadata::senderkeyindexes() const { - // @@protoc_insertion_point(field_list:proto.DeviceListMetadata.senderKeyIndexes) - return _internal_senderkeyindexes(); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* -DeviceListMetadata::_internal_mutable_senderkeyindexes() { - return &_impl_.senderkeyindexes_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* -DeviceListMetadata::mutable_senderkeyindexes() { - // @@protoc_insertion_point(field_mutable_list:proto.DeviceListMetadata.senderKeyIndexes) - return _internal_mutable_senderkeyindexes(); -} - -// optional bytes recipientKeyHash = 8; -inline bool DeviceListMetadata::_internal_has_recipientkeyhash() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool DeviceListMetadata::has_recipientkeyhash() const { - return _internal_has_recipientkeyhash(); -} -inline void DeviceListMetadata::clear_recipientkeyhash() { - _impl_.recipientkeyhash_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& DeviceListMetadata::recipientkeyhash() const { - // @@protoc_insertion_point(field_get:proto.DeviceListMetadata.recipientKeyHash) - return _internal_recipientkeyhash(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void DeviceListMetadata::set_recipientkeyhash(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.recipientkeyhash_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.DeviceListMetadata.recipientKeyHash) -} -inline std::string* DeviceListMetadata::mutable_recipientkeyhash() { - std::string* _s = _internal_mutable_recipientkeyhash(); - // @@protoc_insertion_point(field_mutable:proto.DeviceListMetadata.recipientKeyHash) - return _s; -} -inline const std::string& DeviceListMetadata::_internal_recipientkeyhash() const { - return _impl_.recipientkeyhash_.Get(); -} -inline void DeviceListMetadata::_internal_set_recipientkeyhash(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.recipientkeyhash_.Set(value, GetArenaForAllocation()); -} -inline std::string* DeviceListMetadata::_internal_mutable_recipientkeyhash() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.recipientkeyhash_.Mutable(GetArenaForAllocation()); -} -inline std::string* DeviceListMetadata::release_recipientkeyhash() { - // @@protoc_insertion_point(field_release:proto.DeviceListMetadata.recipientKeyHash) - if (!_internal_has_recipientkeyhash()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.recipientkeyhash_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.recipientkeyhash_.IsDefault()) { - _impl_.recipientkeyhash_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void DeviceListMetadata::set_allocated_recipientkeyhash(std::string* recipientkeyhash) { - if (recipientkeyhash != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.recipientkeyhash_.SetAllocated(recipientkeyhash, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.recipientkeyhash_.IsDefault()) { - _impl_.recipientkeyhash_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.DeviceListMetadata.recipientKeyHash) -} - -// optional uint64 recipientTimestamp = 9; -inline bool DeviceListMetadata::_internal_has_recipienttimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool DeviceListMetadata::has_recipienttimestamp() const { - return _internal_has_recipienttimestamp(); -} -inline void DeviceListMetadata::clear_recipienttimestamp() { - _impl_.recipienttimestamp_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline uint64_t DeviceListMetadata::_internal_recipienttimestamp() const { - return _impl_.recipienttimestamp_; -} -inline uint64_t DeviceListMetadata::recipienttimestamp() const { - // @@protoc_insertion_point(field_get:proto.DeviceListMetadata.recipientTimestamp) - return _internal_recipienttimestamp(); -} -inline void DeviceListMetadata::_internal_set_recipienttimestamp(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.recipienttimestamp_ = value; -} -inline void DeviceListMetadata::set_recipienttimestamp(uint64_t value) { - _internal_set_recipienttimestamp(value); - // @@protoc_insertion_point(field_set:proto.DeviceListMetadata.recipientTimestamp) -} - -// repeated uint32 recipientKeyIndexes = 10 [packed = true]; -inline int DeviceListMetadata::_internal_recipientkeyindexes_size() const { - return _impl_.recipientkeyindexes_.size(); -} -inline int DeviceListMetadata::recipientkeyindexes_size() const { - return _internal_recipientkeyindexes_size(); -} -inline void DeviceListMetadata::clear_recipientkeyindexes() { - _impl_.recipientkeyindexes_.Clear(); -} -inline uint32_t DeviceListMetadata::_internal_recipientkeyindexes(int index) const { - return _impl_.recipientkeyindexes_.Get(index); -} -inline uint32_t DeviceListMetadata::recipientkeyindexes(int index) const { - // @@protoc_insertion_point(field_get:proto.DeviceListMetadata.recipientKeyIndexes) - return _internal_recipientkeyindexes(index); -} -inline void DeviceListMetadata::set_recipientkeyindexes(int index, uint32_t value) { - _impl_.recipientkeyindexes_.Set(index, value); - // @@protoc_insertion_point(field_set:proto.DeviceListMetadata.recipientKeyIndexes) -} -inline void DeviceListMetadata::_internal_add_recipientkeyindexes(uint32_t value) { - _impl_.recipientkeyindexes_.Add(value); -} -inline void DeviceListMetadata::add_recipientkeyindexes(uint32_t value) { - _internal_add_recipientkeyindexes(value); - // @@protoc_insertion_point(field_add:proto.DeviceListMetadata.recipientKeyIndexes) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& -DeviceListMetadata::_internal_recipientkeyindexes() const { - return _impl_.recipientkeyindexes_; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& -DeviceListMetadata::recipientkeyindexes() const { - // @@protoc_insertion_point(field_list:proto.DeviceListMetadata.recipientKeyIndexes) - return _internal_recipientkeyindexes(); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* -DeviceListMetadata::_internal_mutable_recipientkeyindexes() { - return &_impl_.recipientkeyindexes_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* -DeviceListMetadata::mutable_recipientkeyindexes() { - // @@protoc_insertion_point(field_mutable_list:proto.DeviceListMetadata.recipientKeyIndexes) - return _internal_mutable_recipientkeyindexes(); -} - -// ------------------------------------------------------------------- - -// DeviceProps_AppVersion - -// optional uint32 primary = 1; -inline bool DeviceProps_AppVersion::_internal_has_primary() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool DeviceProps_AppVersion::has_primary() const { - return _internal_has_primary(); -} -inline void DeviceProps_AppVersion::clear_primary() { - _impl_.primary_ = 0u; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline uint32_t DeviceProps_AppVersion::_internal_primary() const { - return _impl_.primary_; -} -inline uint32_t DeviceProps_AppVersion::primary() const { - // @@protoc_insertion_point(field_get:proto.DeviceProps.AppVersion.primary) - return _internal_primary(); -} -inline void DeviceProps_AppVersion::_internal_set_primary(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.primary_ = value; -} -inline void DeviceProps_AppVersion::set_primary(uint32_t value) { - _internal_set_primary(value); - // @@protoc_insertion_point(field_set:proto.DeviceProps.AppVersion.primary) -} - -// optional uint32 secondary = 2; -inline bool DeviceProps_AppVersion::_internal_has_secondary() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool DeviceProps_AppVersion::has_secondary() const { - return _internal_has_secondary(); -} -inline void DeviceProps_AppVersion::clear_secondary() { - _impl_.secondary_ = 0u; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline uint32_t DeviceProps_AppVersion::_internal_secondary() const { - return _impl_.secondary_; -} -inline uint32_t DeviceProps_AppVersion::secondary() const { - // @@protoc_insertion_point(field_get:proto.DeviceProps.AppVersion.secondary) - return _internal_secondary(); -} -inline void DeviceProps_AppVersion::_internal_set_secondary(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.secondary_ = value; -} -inline void DeviceProps_AppVersion::set_secondary(uint32_t value) { - _internal_set_secondary(value); - // @@protoc_insertion_point(field_set:proto.DeviceProps.AppVersion.secondary) -} - -// optional uint32 tertiary = 3; -inline bool DeviceProps_AppVersion::_internal_has_tertiary() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool DeviceProps_AppVersion::has_tertiary() const { - return _internal_has_tertiary(); -} -inline void DeviceProps_AppVersion::clear_tertiary() { - _impl_.tertiary_ = 0u; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline uint32_t DeviceProps_AppVersion::_internal_tertiary() const { - return _impl_.tertiary_; -} -inline uint32_t DeviceProps_AppVersion::tertiary() const { - // @@protoc_insertion_point(field_get:proto.DeviceProps.AppVersion.tertiary) - return _internal_tertiary(); -} -inline void DeviceProps_AppVersion::_internal_set_tertiary(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.tertiary_ = value; -} -inline void DeviceProps_AppVersion::set_tertiary(uint32_t value) { - _internal_set_tertiary(value); - // @@protoc_insertion_point(field_set:proto.DeviceProps.AppVersion.tertiary) -} - -// optional uint32 quaternary = 4; -inline bool DeviceProps_AppVersion::_internal_has_quaternary() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool DeviceProps_AppVersion::has_quaternary() const { - return _internal_has_quaternary(); -} -inline void DeviceProps_AppVersion::clear_quaternary() { - _impl_.quaternary_ = 0u; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline uint32_t DeviceProps_AppVersion::_internal_quaternary() const { - return _impl_.quaternary_; -} -inline uint32_t DeviceProps_AppVersion::quaternary() const { - // @@protoc_insertion_point(field_get:proto.DeviceProps.AppVersion.quaternary) - return _internal_quaternary(); -} -inline void DeviceProps_AppVersion::_internal_set_quaternary(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.quaternary_ = value; -} -inline void DeviceProps_AppVersion::set_quaternary(uint32_t value) { - _internal_set_quaternary(value); - // @@protoc_insertion_point(field_set:proto.DeviceProps.AppVersion.quaternary) -} - -// optional uint32 quinary = 5; -inline bool DeviceProps_AppVersion::_internal_has_quinary() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool DeviceProps_AppVersion::has_quinary() const { - return _internal_has_quinary(); -} -inline void DeviceProps_AppVersion::clear_quinary() { - _impl_.quinary_ = 0u; - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline uint32_t DeviceProps_AppVersion::_internal_quinary() const { - return _impl_.quinary_; -} -inline uint32_t DeviceProps_AppVersion::quinary() const { - // @@protoc_insertion_point(field_get:proto.DeviceProps.AppVersion.quinary) - return _internal_quinary(); -} -inline void DeviceProps_AppVersion::_internal_set_quinary(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.quinary_ = value; -} -inline void DeviceProps_AppVersion::set_quinary(uint32_t value) { - _internal_set_quinary(value); - // @@protoc_insertion_point(field_set:proto.DeviceProps.AppVersion.quinary) -} - -// ------------------------------------------------------------------- - -// DeviceProps - -// optional string os = 1; -inline bool DeviceProps::_internal_has_os() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool DeviceProps::has_os() const { - return _internal_has_os(); -} -inline void DeviceProps::clear_os() { - _impl_.os_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& DeviceProps::os() const { - // @@protoc_insertion_point(field_get:proto.DeviceProps.os) - return _internal_os(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void DeviceProps::set_os(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.os_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.DeviceProps.os) -} -inline std::string* DeviceProps::mutable_os() { - std::string* _s = _internal_mutable_os(); - // @@protoc_insertion_point(field_mutable:proto.DeviceProps.os) - return _s; -} -inline const std::string& DeviceProps::_internal_os() const { - return _impl_.os_.Get(); -} -inline void DeviceProps::_internal_set_os(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.os_.Set(value, GetArenaForAllocation()); -} -inline std::string* DeviceProps::_internal_mutable_os() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.os_.Mutable(GetArenaForAllocation()); -} -inline std::string* DeviceProps::release_os() { - // @@protoc_insertion_point(field_release:proto.DeviceProps.os) - if (!_internal_has_os()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.os_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.os_.IsDefault()) { - _impl_.os_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void DeviceProps::set_allocated_os(std::string* os) { - if (os != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.os_.SetAllocated(os, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.os_.IsDefault()) { - _impl_.os_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.DeviceProps.os) -} - -// optional .proto.DeviceProps.AppVersion version = 2; -inline bool DeviceProps::_internal_has_version() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.version_ != nullptr); - return value; -} -inline bool DeviceProps::has_version() const { - return _internal_has_version(); -} -inline void DeviceProps::clear_version() { - if (_impl_.version_ != nullptr) _impl_.version_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::DeviceProps_AppVersion& DeviceProps::_internal_version() const { - const ::proto::DeviceProps_AppVersion* p = _impl_.version_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_DeviceProps_AppVersion_default_instance_); -} -inline const ::proto::DeviceProps_AppVersion& DeviceProps::version() const { - // @@protoc_insertion_point(field_get:proto.DeviceProps.version) - return _internal_version(); -} -inline void DeviceProps::unsafe_arena_set_allocated_version( - ::proto::DeviceProps_AppVersion* version) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.version_); - } - _impl_.version_ = version; - if (version) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.DeviceProps.version) -} -inline ::proto::DeviceProps_AppVersion* DeviceProps::release_version() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::DeviceProps_AppVersion* temp = _impl_.version_; - _impl_.version_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::DeviceProps_AppVersion* DeviceProps::unsafe_arena_release_version() { - // @@protoc_insertion_point(field_release:proto.DeviceProps.version) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::DeviceProps_AppVersion* temp = _impl_.version_; - _impl_.version_ = nullptr; - return temp; -} -inline ::proto::DeviceProps_AppVersion* DeviceProps::_internal_mutable_version() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.version_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::DeviceProps_AppVersion>(GetArenaForAllocation()); - _impl_.version_ = p; - } - return _impl_.version_; -} -inline ::proto::DeviceProps_AppVersion* DeviceProps::mutable_version() { - ::proto::DeviceProps_AppVersion* _msg = _internal_mutable_version(); - // @@protoc_insertion_point(field_mutable:proto.DeviceProps.version) - return _msg; -} -inline void DeviceProps::set_allocated_version(::proto::DeviceProps_AppVersion* version) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.version_; - } - if (version) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(version); - if (message_arena != submessage_arena) { - version = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, version, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.version_ = version; - // @@protoc_insertion_point(field_set_allocated:proto.DeviceProps.version) -} - -// optional .proto.DeviceProps.PlatformType platformType = 3; -inline bool DeviceProps::_internal_has_platformtype() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool DeviceProps::has_platformtype() const { - return _internal_has_platformtype(); -} -inline void DeviceProps::clear_platformtype() { - _impl_.platformtype_ = 0; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline ::proto::DeviceProps_PlatformType DeviceProps::_internal_platformtype() const { - return static_cast< ::proto::DeviceProps_PlatformType >(_impl_.platformtype_); -} -inline ::proto::DeviceProps_PlatformType DeviceProps::platformtype() const { - // @@protoc_insertion_point(field_get:proto.DeviceProps.platformType) - return _internal_platformtype(); -} -inline void DeviceProps::_internal_set_platformtype(::proto::DeviceProps_PlatformType value) { - assert(::proto::DeviceProps_PlatformType_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.platformtype_ = value; -} -inline void DeviceProps::set_platformtype(::proto::DeviceProps_PlatformType value) { - _internal_set_platformtype(value); - // @@protoc_insertion_point(field_set:proto.DeviceProps.platformType) -} - -// optional bool requireFullSync = 4; -inline bool DeviceProps::_internal_has_requirefullsync() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool DeviceProps::has_requirefullsync() const { - return _internal_has_requirefullsync(); -} -inline void DeviceProps::clear_requirefullsync() { - _impl_.requirefullsync_ = false; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline bool DeviceProps::_internal_requirefullsync() const { - return _impl_.requirefullsync_; -} -inline bool DeviceProps::requirefullsync() const { - // @@protoc_insertion_point(field_get:proto.DeviceProps.requireFullSync) - return _internal_requirefullsync(); -} -inline void DeviceProps::_internal_set_requirefullsync(bool value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.requirefullsync_ = value; -} -inline void DeviceProps::set_requirefullsync(bool value) { - _internal_set_requirefullsync(value); - // @@protoc_insertion_point(field_set:proto.DeviceProps.requireFullSync) -} - -// ------------------------------------------------------------------- - -// DisappearingMode - -// optional .proto.DisappearingMode.Initiator initiator = 1; -inline bool DisappearingMode::_internal_has_initiator() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool DisappearingMode::has_initiator() const { - return _internal_has_initiator(); -} -inline void DisappearingMode::clear_initiator() { - _impl_.initiator_ = 0; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline ::proto::DisappearingMode_Initiator DisappearingMode::_internal_initiator() const { - return static_cast< ::proto::DisappearingMode_Initiator >(_impl_.initiator_); -} -inline ::proto::DisappearingMode_Initiator DisappearingMode::initiator() const { - // @@protoc_insertion_point(field_get:proto.DisappearingMode.initiator) - return _internal_initiator(); -} -inline void DisappearingMode::_internal_set_initiator(::proto::DisappearingMode_Initiator value) { - assert(::proto::DisappearingMode_Initiator_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.initiator_ = value; -} -inline void DisappearingMode::set_initiator(::proto::DisappearingMode_Initiator value) { - _internal_set_initiator(value); - // @@protoc_insertion_point(field_set:proto.DisappearingMode.initiator) -} - -// ------------------------------------------------------------------- - -// EphemeralSetting - -// optional sfixed32 duration = 1; -inline bool EphemeralSetting::_internal_has_duration() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool EphemeralSetting::has_duration() const { - return _internal_has_duration(); -} -inline void EphemeralSetting::clear_duration() { - _impl_.duration_ = 0; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline int32_t EphemeralSetting::_internal_duration() const { - return _impl_.duration_; -} -inline int32_t EphemeralSetting::duration() const { - // @@protoc_insertion_point(field_get:proto.EphemeralSetting.duration) - return _internal_duration(); -} -inline void EphemeralSetting::_internal_set_duration(int32_t value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.duration_ = value; -} -inline void EphemeralSetting::set_duration(int32_t value) { - _internal_set_duration(value); - // @@protoc_insertion_point(field_set:proto.EphemeralSetting.duration) -} - -// optional sfixed64 timestamp = 2; -inline bool EphemeralSetting::_internal_has_timestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool EphemeralSetting::has_timestamp() const { - return _internal_has_timestamp(); -} -inline void EphemeralSetting::clear_timestamp() { - _impl_.timestamp_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline int64_t EphemeralSetting::_internal_timestamp() const { - return _impl_.timestamp_; -} -inline int64_t EphemeralSetting::timestamp() const { - // @@protoc_insertion_point(field_get:proto.EphemeralSetting.timestamp) - return _internal_timestamp(); -} -inline void EphemeralSetting::_internal_set_timestamp(int64_t value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.timestamp_ = value; -} -inline void EphemeralSetting::set_timestamp(int64_t value) { - _internal_set_timestamp(value); - // @@protoc_insertion_point(field_set:proto.EphemeralSetting.timestamp) -} - -// ------------------------------------------------------------------- - -// ExitCode - -// optional uint64 code = 1; -inline bool ExitCode::_internal_has_code() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool ExitCode::has_code() const { - return _internal_has_code(); -} -inline void ExitCode::clear_code() { - _impl_.code_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline uint64_t ExitCode::_internal_code() const { - return _impl_.code_; -} -inline uint64_t ExitCode::code() const { - // @@protoc_insertion_point(field_get:proto.ExitCode.code) - return _internal_code(); -} -inline void ExitCode::_internal_set_code(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.code_ = value; -} -inline void ExitCode::set_code(uint64_t value) { - _internal_set_code(value); - // @@protoc_insertion_point(field_set:proto.ExitCode.code) -} - -// optional string text = 2; -inline bool ExitCode::_internal_has_text() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool ExitCode::has_text() const { - return _internal_has_text(); -} -inline void ExitCode::clear_text() { - _impl_.text_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& ExitCode::text() const { - // @@protoc_insertion_point(field_get:proto.ExitCode.text) - return _internal_text(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ExitCode::set_text(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.text_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ExitCode.text) -} -inline std::string* ExitCode::mutable_text() { - std::string* _s = _internal_mutable_text(); - // @@protoc_insertion_point(field_mutable:proto.ExitCode.text) - return _s; -} -inline const std::string& ExitCode::_internal_text() const { - return _impl_.text_.Get(); -} -inline void ExitCode::_internal_set_text(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.text_.Set(value, GetArenaForAllocation()); -} -inline std::string* ExitCode::_internal_mutable_text() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.text_.Mutable(GetArenaForAllocation()); -} -inline std::string* ExitCode::release_text() { - // @@protoc_insertion_point(field_release:proto.ExitCode.text) - if (!_internal_has_text()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.text_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.text_.IsDefault()) { - _impl_.text_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ExitCode::set_allocated_text(std::string* text) { - if (text != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.text_.SetAllocated(text, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.text_.IsDefault()) { - _impl_.text_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ExitCode.text) -} - -// ------------------------------------------------------------------- - -// ExternalBlobReference - -// optional bytes mediaKey = 1; -inline bool ExternalBlobReference::_internal_has_mediakey() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool ExternalBlobReference::has_mediakey() const { - return _internal_has_mediakey(); -} -inline void ExternalBlobReference::clear_mediakey() { - _impl_.mediakey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& ExternalBlobReference::mediakey() const { - // @@protoc_insertion_point(field_get:proto.ExternalBlobReference.mediaKey) - return _internal_mediakey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ExternalBlobReference::set_mediakey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.mediakey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ExternalBlobReference.mediaKey) -} -inline std::string* ExternalBlobReference::mutable_mediakey() { - std::string* _s = _internal_mutable_mediakey(); - // @@protoc_insertion_point(field_mutable:proto.ExternalBlobReference.mediaKey) - return _s; -} -inline const std::string& ExternalBlobReference::_internal_mediakey() const { - return _impl_.mediakey_.Get(); -} -inline void ExternalBlobReference::_internal_set_mediakey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.mediakey_.Set(value, GetArenaForAllocation()); -} -inline std::string* ExternalBlobReference::_internal_mutable_mediakey() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.mediakey_.Mutable(GetArenaForAllocation()); -} -inline std::string* ExternalBlobReference::release_mediakey() { - // @@protoc_insertion_point(field_release:proto.ExternalBlobReference.mediaKey) - if (!_internal_has_mediakey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.mediakey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mediakey_.IsDefault()) { - _impl_.mediakey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ExternalBlobReference::set_allocated_mediakey(std::string* mediakey) { - if (mediakey != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mediakey_.IsDefault()) { - _impl_.mediakey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ExternalBlobReference.mediaKey) -} - -// optional string directPath = 2; -inline bool ExternalBlobReference::_internal_has_directpath() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool ExternalBlobReference::has_directpath() const { - return _internal_has_directpath(); -} -inline void ExternalBlobReference::clear_directpath() { - _impl_.directpath_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& ExternalBlobReference::directpath() const { - // @@protoc_insertion_point(field_get:proto.ExternalBlobReference.directPath) - return _internal_directpath(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ExternalBlobReference::set_directpath(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.directpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ExternalBlobReference.directPath) -} -inline std::string* ExternalBlobReference::mutable_directpath() { - std::string* _s = _internal_mutable_directpath(); - // @@protoc_insertion_point(field_mutable:proto.ExternalBlobReference.directPath) - return _s; -} -inline const std::string& ExternalBlobReference::_internal_directpath() const { - return _impl_.directpath_.Get(); -} -inline void ExternalBlobReference::_internal_set_directpath(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.directpath_.Set(value, GetArenaForAllocation()); -} -inline std::string* ExternalBlobReference::_internal_mutable_directpath() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.directpath_.Mutable(GetArenaForAllocation()); -} -inline std::string* ExternalBlobReference::release_directpath() { - // @@protoc_insertion_point(field_release:proto.ExternalBlobReference.directPath) - if (!_internal_has_directpath()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.directpath_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.directpath_.IsDefault()) { - _impl_.directpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ExternalBlobReference::set_allocated_directpath(std::string* directpath) { - if (directpath != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.directpath_.IsDefault()) { - _impl_.directpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ExternalBlobReference.directPath) -} - -// optional string handle = 3; -inline bool ExternalBlobReference::_internal_has_handle() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool ExternalBlobReference::has_handle() const { - return _internal_has_handle(); -} -inline void ExternalBlobReference::clear_handle() { - _impl_.handle_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& ExternalBlobReference::handle() const { - // @@protoc_insertion_point(field_get:proto.ExternalBlobReference.handle) - return _internal_handle(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ExternalBlobReference::set_handle(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.handle_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ExternalBlobReference.handle) -} -inline std::string* ExternalBlobReference::mutable_handle() { - std::string* _s = _internal_mutable_handle(); - // @@protoc_insertion_point(field_mutable:proto.ExternalBlobReference.handle) - return _s; -} -inline const std::string& ExternalBlobReference::_internal_handle() const { - return _impl_.handle_.Get(); -} -inline void ExternalBlobReference::_internal_set_handle(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.handle_.Set(value, GetArenaForAllocation()); -} -inline std::string* ExternalBlobReference::_internal_mutable_handle() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.handle_.Mutable(GetArenaForAllocation()); -} -inline std::string* ExternalBlobReference::release_handle() { - // @@protoc_insertion_point(field_release:proto.ExternalBlobReference.handle) - if (!_internal_has_handle()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.handle_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.handle_.IsDefault()) { - _impl_.handle_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ExternalBlobReference::set_allocated_handle(std::string* handle) { - if (handle != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.handle_.SetAllocated(handle, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.handle_.IsDefault()) { - _impl_.handle_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ExternalBlobReference.handle) -} - -// optional uint64 fileSizeBytes = 4; -inline bool ExternalBlobReference::_internal_has_filesizebytes() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool ExternalBlobReference::has_filesizebytes() const { - return _internal_has_filesizebytes(); -} -inline void ExternalBlobReference::clear_filesizebytes() { - _impl_.filesizebytes_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline uint64_t ExternalBlobReference::_internal_filesizebytes() const { - return _impl_.filesizebytes_; -} -inline uint64_t ExternalBlobReference::filesizebytes() const { - // @@protoc_insertion_point(field_get:proto.ExternalBlobReference.fileSizeBytes) - return _internal_filesizebytes(); -} -inline void ExternalBlobReference::_internal_set_filesizebytes(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.filesizebytes_ = value; -} -inline void ExternalBlobReference::set_filesizebytes(uint64_t value) { - _internal_set_filesizebytes(value); - // @@protoc_insertion_point(field_set:proto.ExternalBlobReference.fileSizeBytes) -} - -// optional bytes fileSha256 = 5; -inline bool ExternalBlobReference::_internal_has_filesha256() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool ExternalBlobReference::has_filesha256() const { - return _internal_has_filesha256(); -} -inline void ExternalBlobReference::clear_filesha256() { - _impl_.filesha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const std::string& ExternalBlobReference::filesha256() const { - // @@protoc_insertion_point(field_get:proto.ExternalBlobReference.fileSha256) - return _internal_filesha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ExternalBlobReference::set_filesha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.filesha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ExternalBlobReference.fileSha256) -} -inline std::string* ExternalBlobReference::mutable_filesha256() { - std::string* _s = _internal_mutable_filesha256(); - // @@protoc_insertion_point(field_mutable:proto.ExternalBlobReference.fileSha256) - return _s; -} -inline const std::string& ExternalBlobReference::_internal_filesha256() const { - return _impl_.filesha256_.Get(); -} -inline void ExternalBlobReference::_internal_set_filesha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.filesha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* ExternalBlobReference::_internal_mutable_filesha256() { - _impl_._has_bits_[0] |= 0x00000008u; - return _impl_.filesha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* ExternalBlobReference::release_filesha256() { - // @@protoc_insertion_point(field_release:proto.ExternalBlobReference.fileSha256) - if (!_internal_has_filesha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000008u; - auto* p = _impl_.filesha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.filesha256_.IsDefault()) { - _impl_.filesha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ExternalBlobReference::set_allocated_filesha256(std::string* filesha256) { - if (filesha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.filesha256_.IsDefault()) { - _impl_.filesha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ExternalBlobReference.fileSha256) -} - -// optional bytes fileEncSha256 = 6; -inline bool ExternalBlobReference::_internal_has_fileencsha256() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool ExternalBlobReference::has_fileencsha256() const { - return _internal_has_fileencsha256(); -} -inline void ExternalBlobReference::clear_fileencsha256() { - _impl_.fileencsha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const std::string& ExternalBlobReference::fileencsha256() const { - // @@protoc_insertion_point(field_get:proto.ExternalBlobReference.fileEncSha256) - return _internal_fileencsha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ExternalBlobReference::set_fileencsha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.fileencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ExternalBlobReference.fileEncSha256) -} -inline std::string* ExternalBlobReference::mutable_fileencsha256() { - std::string* _s = _internal_mutable_fileencsha256(); - // @@protoc_insertion_point(field_mutable:proto.ExternalBlobReference.fileEncSha256) - return _s; -} -inline const std::string& ExternalBlobReference::_internal_fileencsha256() const { - return _impl_.fileencsha256_.Get(); -} -inline void ExternalBlobReference::_internal_set_fileencsha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.fileencsha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* ExternalBlobReference::_internal_mutable_fileencsha256() { - _impl_._has_bits_[0] |= 0x00000010u; - return _impl_.fileencsha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* ExternalBlobReference::release_fileencsha256() { - // @@protoc_insertion_point(field_release:proto.ExternalBlobReference.fileEncSha256) - if (!_internal_has_fileencsha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000010u; - auto* p = _impl_.fileencsha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fileencsha256_.IsDefault()) { - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ExternalBlobReference::set_allocated_fileencsha256(std::string* fileencsha256) { - if (fileencsha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fileencsha256_.IsDefault()) { - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ExternalBlobReference.fileEncSha256) -} - -// ------------------------------------------------------------------- - -// GlobalSettings - -// optional .proto.WallpaperSettings lightThemeWallpaper = 1; -inline bool GlobalSettings::_internal_has_lightthemewallpaper() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.lightthemewallpaper_ != nullptr); - return value; -} -inline bool GlobalSettings::has_lightthemewallpaper() const { - return _internal_has_lightthemewallpaper(); -} -inline void GlobalSettings::clear_lightthemewallpaper() { - if (_impl_.lightthemewallpaper_ != nullptr) _impl_.lightthemewallpaper_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::WallpaperSettings& GlobalSettings::_internal_lightthemewallpaper() const { - const ::proto::WallpaperSettings* p = _impl_.lightthemewallpaper_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_WallpaperSettings_default_instance_); -} -inline const ::proto::WallpaperSettings& GlobalSettings::lightthemewallpaper() const { - // @@protoc_insertion_point(field_get:proto.GlobalSettings.lightThemeWallpaper) - return _internal_lightthemewallpaper(); -} -inline void GlobalSettings::unsafe_arena_set_allocated_lightthemewallpaper( - ::proto::WallpaperSettings* lightthemewallpaper) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.lightthemewallpaper_); - } - _impl_.lightthemewallpaper_ = lightthemewallpaper; - if (lightthemewallpaper) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.GlobalSettings.lightThemeWallpaper) -} -inline ::proto::WallpaperSettings* GlobalSettings::release_lightthemewallpaper() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::WallpaperSettings* temp = _impl_.lightthemewallpaper_; - _impl_.lightthemewallpaper_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::WallpaperSettings* GlobalSettings::unsafe_arena_release_lightthemewallpaper() { - // @@protoc_insertion_point(field_release:proto.GlobalSettings.lightThemeWallpaper) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::WallpaperSettings* temp = _impl_.lightthemewallpaper_; - _impl_.lightthemewallpaper_ = nullptr; - return temp; -} -inline ::proto::WallpaperSettings* GlobalSettings::_internal_mutable_lightthemewallpaper() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.lightthemewallpaper_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::WallpaperSettings>(GetArenaForAllocation()); - _impl_.lightthemewallpaper_ = p; - } - return _impl_.lightthemewallpaper_; -} -inline ::proto::WallpaperSettings* GlobalSettings::mutable_lightthemewallpaper() { - ::proto::WallpaperSettings* _msg = _internal_mutable_lightthemewallpaper(); - // @@protoc_insertion_point(field_mutable:proto.GlobalSettings.lightThemeWallpaper) - return _msg; -} -inline void GlobalSettings::set_allocated_lightthemewallpaper(::proto::WallpaperSettings* lightthemewallpaper) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.lightthemewallpaper_; - } - if (lightthemewallpaper) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(lightthemewallpaper); - if (message_arena != submessage_arena) { - lightthemewallpaper = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, lightthemewallpaper, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.lightthemewallpaper_ = lightthemewallpaper; - // @@protoc_insertion_point(field_set_allocated:proto.GlobalSettings.lightThemeWallpaper) -} - -// optional .proto.MediaVisibility mediaVisibility = 2; -inline bool GlobalSettings::_internal_has_mediavisibility() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool GlobalSettings::has_mediavisibility() const { - return _internal_has_mediavisibility(); -} -inline void GlobalSettings::clear_mediavisibility() { - _impl_.mediavisibility_ = 0; - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline ::proto::MediaVisibility GlobalSettings::_internal_mediavisibility() const { - return static_cast< ::proto::MediaVisibility >(_impl_.mediavisibility_); -} -inline ::proto::MediaVisibility GlobalSettings::mediavisibility() const { - // @@protoc_insertion_point(field_get:proto.GlobalSettings.mediaVisibility) - return _internal_mediavisibility(); -} -inline void GlobalSettings::_internal_set_mediavisibility(::proto::MediaVisibility value) { - assert(::proto::MediaVisibility_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.mediavisibility_ = value; -} -inline void GlobalSettings::set_mediavisibility(::proto::MediaVisibility value) { - _internal_set_mediavisibility(value); - // @@protoc_insertion_point(field_set:proto.GlobalSettings.mediaVisibility) -} - -// optional .proto.WallpaperSettings darkThemeWallpaper = 3; -inline bool GlobalSettings::_internal_has_darkthemewallpaper() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.darkthemewallpaper_ != nullptr); - return value; -} -inline bool GlobalSettings::has_darkthemewallpaper() const { - return _internal_has_darkthemewallpaper(); -} -inline void GlobalSettings::clear_darkthemewallpaper() { - if (_impl_.darkthemewallpaper_ != nullptr) _impl_.darkthemewallpaper_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::WallpaperSettings& GlobalSettings::_internal_darkthemewallpaper() const { - const ::proto::WallpaperSettings* p = _impl_.darkthemewallpaper_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_WallpaperSettings_default_instance_); -} -inline const ::proto::WallpaperSettings& GlobalSettings::darkthemewallpaper() const { - // @@protoc_insertion_point(field_get:proto.GlobalSettings.darkThemeWallpaper) - return _internal_darkthemewallpaper(); -} -inline void GlobalSettings::unsafe_arena_set_allocated_darkthemewallpaper( - ::proto::WallpaperSettings* darkthemewallpaper) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.darkthemewallpaper_); - } - _impl_.darkthemewallpaper_ = darkthemewallpaper; - if (darkthemewallpaper) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.GlobalSettings.darkThemeWallpaper) -} -inline ::proto::WallpaperSettings* GlobalSettings::release_darkthemewallpaper() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::WallpaperSettings* temp = _impl_.darkthemewallpaper_; - _impl_.darkthemewallpaper_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::WallpaperSettings* GlobalSettings::unsafe_arena_release_darkthemewallpaper() { - // @@protoc_insertion_point(field_release:proto.GlobalSettings.darkThemeWallpaper) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::WallpaperSettings* temp = _impl_.darkthemewallpaper_; - _impl_.darkthemewallpaper_ = nullptr; - return temp; -} -inline ::proto::WallpaperSettings* GlobalSettings::_internal_mutable_darkthemewallpaper() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.darkthemewallpaper_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::WallpaperSettings>(GetArenaForAllocation()); - _impl_.darkthemewallpaper_ = p; - } - return _impl_.darkthemewallpaper_; -} -inline ::proto::WallpaperSettings* GlobalSettings::mutable_darkthemewallpaper() { - ::proto::WallpaperSettings* _msg = _internal_mutable_darkthemewallpaper(); - // @@protoc_insertion_point(field_mutable:proto.GlobalSettings.darkThemeWallpaper) - return _msg; -} -inline void GlobalSettings::set_allocated_darkthemewallpaper(::proto::WallpaperSettings* darkthemewallpaper) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.darkthemewallpaper_; - } - if (darkthemewallpaper) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(darkthemewallpaper); - if (message_arena != submessage_arena) { - darkthemewallpaper = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, darkthemewallpaper, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.darkthemewallpaper_ = darkthemewallpaper; - // @@protoc_insertion_point(field_set_allocated:proto.GlobalSettings.darkThemeWallpaper) -} - -// optional .proto.AutoDownloadSettings autoDownloadWiFi = 4; -inline bool GlobalSettings::_internal_has_autodownloadwifi() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - PROTOBUF_ASSUME(!value || _impl_.autodownloadwifi_ != nullptr); - return value; -} -inline bool GlobalSettings::has_autodownloadwifi() const { - return _internal_has_autodownloadwifi(); -} -inline void GlobalSettings::clear_autodownloadwifi() { - if (_impl_.autodownloadwifi_ != nullptr) _impl_.autodownloadwifi_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const ::proto::AutoDownloadSettings& GlobalSettings::_internal_autodownloadwifi() const { - const ::proto::AutoDownloadSettings* p = _impl_.autodownloadwifi_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_AutoDownloadSettings_default_instance_); -} -inline const ::proto::AutoDownloadSettings& GlobalSettings::autodownloadwifi() const { - // @@protoc_insertion_point(field_get:proto.GlobalSettings.autoDownloadWiFi) - return _internal_autodownloadwifi(); -} -inline void GlobalSettings::unsafe_arena_set_allocated_autodownloadwifi( - ::proto::AutoDownloadSettings* autodownloadwifi) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.autodownloadwifi_); - } - _impl_.autodownloadwifi_ = autodownloadwifi; - if (autodownloadwifi) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.GlobalSettings.autoDownloadWiFi) -} -inline ::proto::AutoDownloadSettings* GlobalSettings::release_autodownloadwifi() { - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::AutoDownloadSettings* temp = _impl_.autodownloadwifi_; - _impl_.autodownloadwifi_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::AutoDownloadSettings* GlobalSettings::unsafe_arena_release_autodownloadwifi() { - // @@protoc_insertion_point(field_release:proto.GlobalSettings.autoDownloadWiFi) - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::AutoDownloadSettings* temp = _impl_.autodownloadwifi_; - _impl_.autodownloadwifi_ = nullptr; - return temp; -} -inline ::proto::AutoDownloadSettings* GlobalSettings::_internal_mutable_autodownloadwifi() { - _impl_._has_bits_[0] |= 0x00000004u; - if (_impl_.autodownloadwifi_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::AutoDownloadSettings>(GetArenaForAllocation()); - _impl_.autodownloadwifi_ = p; - } - return _impl_.autodownloadwifi_; -} -inline ::proto::AutoDownloadSettings* GlobalSettings::mutable_autodownloadwifi() { - ::proto::AutoDownloadSettings* _msg = _internal_mutable_autodownloadwifi(); - // @@protoc_insertion_point(field_mutable:proto.GlobalSettings.autoDownloadWiFi) - return _msg; -} -inline void GlobalSettings::set_allocated_autodownloadwifi(::proto::AutoDownloadSettings* autodownloadwifi) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.autodownloadwifi_; - } - if (autodownloadwifi) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(autodownloadwifi); - if (message_arena != submessage_arena) { - autodownloadwifi = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, autodownloadwifi, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.autodownloadwifi_ = autodownloadwifi; - // @@protoc_insertion_point(field_set_allocated:proto.GlobalSettings.autoDownloadWiFi) -} - -// optional .proto.AutoDownloadSettings autoDownloadCellular = 5; -inline bool GlobalSettings::_internal_has_autodownloadcellular() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - PROTOBUF_ASSUME(!value || _impl_.autodownloadcellular_ != nullptr); - return value; -} -inline bool GlobalSettings::has_autodownloadcellular() const { - return _internal_has_autodownloadcellular(); -} -inline void GlobalSettings::clear_autodownloadcellular() { - if (_impl_.autodownloadcellular_ != nullptr) _impl_.autodownloadcellular_->Clear(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const ::proto::AutoDownloadSettings& GlobalSettings::_internal_autodownloadcellular() const { - const ::proto::AutoDownloadSettings* p = _impl_.autodownloadcellular_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_AutoDownloadSettings_default_instance_); -} -inline const ::proto::AutoDownloadSettings& GlobalSettings::autodownloadcellular() const { - // @@protoc_insertion_point(field_get:proto.GlobalSettings.autoDownloadCellular) - return _internal_autodownloadcellular(); -} -inline void GlobalSettings::unsafe_arena_set_allocated_autodownloadcellular( - ::proto::AutoDownloadSettings* autodownloadcellular) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.autodownloadcellular_); - } - _impl_.autodownloadcellular_ = autodownloadcellular; - if (autodownloadcellular) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.GlobalSettings.autoDownloadCellular) -} -inline ::proto::AutoDownloadSettings* GlobalSettings::release_autodownloadcellular() { - _impl_._has_bits_[0] &= ~0x00000008u; - ::proto::AutoDownloadSettings* temp = _impl_.autodownloadcellular_; - _impl_.autodownloadcellular_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::AutoDownloadSettings* GlobalSettings::unsafe_arena_release_autodownloadcellular() { - // @@protoc_insertion_point(field_release:proto.GlobalSettings.autoDownloadCellular) - _impl_._has_bits_[0] &= ~0x00000008u; - ::proto::AutoDownloadSettings* temp = _impl_.autodownloadcellular_; - _impl_.autodownloadcellular_ = nullptr; - return temp; -} -inline ::proto::AutoDownloadSettings* GlobalSettings::_internal_mutable_autodownloadcellular() { - _impl_._has_bits_[0] |= 0x00000008u; - if (_impl_.autodownloadcellular_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::AutoDownloadSettings>(GetArenaForAllocation()); - _impl_.autodownloadcellular_ = p; - } - return _impl_.autodownloadcellular_; -} -inline ::proto::AutoDownloadSettings* GlobalSettings::mutable_autodownloadcellular() { - ::proto::AutoDownloadSettings* _msg = _internal_mutable_autodownloadcellular(); - // @@protoc_insertion_point(field_mutable:proto.GlobalSettings.autoDownloadCellular) - return _msg; -} -inline void GlobalSettings::set_allocated_autodownloadcellular(::proto::AutoDownloadSettings* autodownloadcellular) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.autodownloadcellular_; - } - if (autodownloadcellular) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(autodownloadcellular); - if (message_arena != submessage_arena) { - autodownloadcellular = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, autodownloadcellular, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.autodownloadcellular_ = autodownloadcellular; - // @@protoc_insertion_point(field_set_allocated:proto.GlobalSettings.autoDownloadCellular) -} - -// optional .proto.AutoDownloadSettings autoDownloadRoaming = 6; -inline bool GlobalSettings::_internal_has_autodownloadroaming() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - PROTOBUF_ASSUME(!value || _impl_.autodownloadroaming_ != nullptr); - return value; -} -inline bool GlobalSettings::has_autodownloadroaming() const { - return _internal_has_autodownloadroaming(); -} -inline void GlobalSettings::clear_autodownloadroaming() { - if (_impl_.autodownloadroaming_ != nullptr) _impl_.autodownloadroaming_->Clear(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const ::proto::AutoDownloadSettings& GlobalSettings::_internal_autodownloadroaming() const { - const ::proto::AutoDownloadSettings* p = _impl_.autodownloadroaming_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_AutoDownloadSettings_default_instance_); -} -inline const ::proto::AutoDownloadSettings& GlobalSettings::autodownloadroaming() const { - // @@protoc_insertion_point(field_get:proto.GlobalSettings.autoDownloadRoaming) - return _internal_autodownloadroaming(); -} -inline void GlobalSettings::unsafe_arena_set_allocated_autodownloadroaming( - ::proto::AutoDownloadSettings* autodownloadroaming) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.autodownloadroaming_); - } - _impl_.autodownloadroaming_ = autodownloadroaming; - if (autodownloadroaming) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.GlobalSettings.autoDownloadRoaming) -} -inline ::proto::AutoDownloadSettings* GlobalSettings::release_autodownloadroaming() { - _impl_._has_bits_[0] &= ~0x00000010u; - ::proto::AutoDownloadSettings* temp = _impl_.autodownloadroaming_; - _impl_.autodownloadroaming_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::AutoDownloadSettings* GlobalSettings::unsafe_arena_release_autodownloadroaming() { - // @@protoc_insertion_point(field_release:proto.GlobalSettings.autoDownloadRoaming) - _impl_._has_bits_[0] &= ~0x00000010u; - ::proto::AutoDownloadSettings* temp = _impl_.autodownloadroaming_; - _impl_.autodownloadroaming_ = nullptr; - return temp; -} -inline ::proto::AutoDownloadSettings* GlobalSettings::_internal_mutable_autodownloadroaming() { - _impl_._has_bits_[0] |= 0x00000010u; - if (_impl_.autodownloadroaming_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::AutoDownloadSettings>(GetArenaForAllocation()); - _impl_.autodownloadroaming_ = p; - } - return _impl_.autodownloadroaming_; -} -inline ::proto::AutoDownloadSettings* GlobalSettings::mutable_autodownloadroaming() { - ::proto::AutoDownloadSettings* _msg = _internal_mutable_autodownloadroaming(); - // @@protoc_insertion_point(field_mutable:proto.GlobalSettings.autoDownloadRoaming) - return _msg; -} -inline void GlobalSettings::set_allocated_autodownloadroaming(::proto::AutoDownloadSettings* autodownloadroaming) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.autodownloadroaming_; - } - if (autodownloadroaming) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(autodownloadroaming); - if (message_arena != submessage_arena) { - autodownloadroaming = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, autodownloadroaming, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.autodownloadroaming_ = autodownloadroaming; - // @@protoc_insertion_point(field_set_allocated:proto.GlobalSettings.autoDownloadRoaming) -} - -// optional bool showIndividualNotificationsPreview = 7; -inline bool GlobalSettings::_internal_has_showindividualnotificationspreview() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool GlobalSettings::has_showindividualnotificationspreview() const { - return _internal_has_showindividualnotificationspreview(); -} -inline void GlobalSettings::clear_showindividualnotificationspreview() { - _impl_.showindividualnotificationspreview_ = false; - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline bool GlobalSettings::_internal_showindividualnotificationspreview() const { - return _impl_.showindividualnotificationspreview_; -} -inline bool GlobalSettings::showindividualnotificationspreview() const { - // @@protoc_insertion_point(field_get:proto.GlobalSettings.showIndividualNotificationsPreview) - return _internal_showindividualnotificationspreview(); -} -inline void GlobalSettings::_internal_set_showindividualnotificationspreview(bool value) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.showindividualnotificationspreview_ = value; -} -inline void GlobalSettings::set_showindividualnotificationspreview(bool value) { - _internal_set_showindividualnotificationspreview(value); - // @@protoc_insertion_point(field_set:proto.GlobalSettings.showIndividualNotificationsPreview) -} - -// optional bool showGroupNotificationsPreview = 8; -inline bool GlobalSettings::_internal_has_showgroupnotificationspreview() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - return value; -} -inline bool GlobalSettings::has_showgroupnotificationspreview() const { - return _internal_has_showgroupnotificationspreview(); -} -inline void GlobalSettings::clear_showgroupnotificationspreview() { - _impl_.showgroupnotificationspreview_ = false; - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline bool GlobalSettings::_internal_showgroupnotificationspreview() const { - return _impl_.showgroupnotificationspreview_; -} -inline bool GlobalSettings::showgroupnotificationspreview() const { - // @@protoc_insertion_point(field_get:proto.GlobalSettings.showGroupNotificationsPreview) - return _internal_showgroupnotificationspreview(); -} -inline void GlobalSettings::_internal_set_showgroupnotificationspreview(bool value) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.showgroupnotificationspreview_ = value; -} -inline void GlobalSettings::set_showgroupnotificationspreview(bool value) { - _internal_set_showgroupnotificationspreview(value); - // @@protoc_insertion_point(field_set:proto.GlobalSettings.showGroupNotificationsPreview) -} - -// optional int32 disappearingModeDuration = 9; -inline bool GlobalSettings::_internal_has_disappearingmodeduration() const { - bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; - return value; -} -inline bool GlobalSettings::has_disappearingmodeduration() const { - return _internal_has_disappearingmodeduration(); -} -inline void GlobalSettings::clear_disappearingmodeduration() { - _impl_.disappearingmodeduration_ = 0; - _impl_._has_bits_[0] &= ~0x00000200u; -} -inline int32_t GlobalSettings::_internal_disappearingmodeduration() const { - return _impl_.disappearingmodeduration_; -} -inline int32_t GlobalSettings::disappearingmodeduration() const { - // @@protoc_insertion_point(field_get:proto.GlobalSettings.disappearingModeDuration) - return _internal_disappearingmodeduration(); -} -inline void GlobalSettings::_internal_set_disappearingmodeduration(int32_t value) { - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.disappearingmodeduration_ = value; -} -inline void GlobalSettings::set_disappearingmodeduration(int32_t value) { - _internal_set_disappearingmodeduration(value); - // @@protoc_insertion_point(field_set:proto.GlobalSettings.disappearingModeDuration) -} - -// optional int64 disappearingModeTimestamp = 10; -inline bool GlobalSettings::_internal_has_disappearingmodetimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; - return value; -} -inline bool GlobalSettings::has_disappearingmodetimestamp() const { - return _internal_has_disappearingmodetimestamp(); -} -inline void GlobalSettings::clear_disappearingmodetimestamp() { - _impl_.disappearingmodetimestamp_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000100u; -} -inline int64_t GlobalSettings::_internal_disappearingmodetimestamp() const { - return _impl_.disappearingmodetimestamp_; -} -inline int64_t GlobalSettings::disappearingmodetimestamp() const { - // @@protoc_insertion_point(field_get:proto.GlobalSettings.disappearingModeTimestamp) - return _internal_disappearingmodetimestamp(); -} -inline void GlobalSettings::_internal_set_disappearingmodetimestamp(int64_t value) { - _impl_._has_bits_[0] |= 0x00000100u; - _impl_.disappearingmodetimestamp_ = value; -} -inline void GlobalSettings::set_disappearingmodetimestamp(int64_t value) { - _internal_set_disappearingmodetimestamp(value); - // @@protoc_insertion_point(field_set:proto.GlobalSettings.disappearingModeTimestamp) -} - -// ------------------------------------------------------------------- - -// GroupParticipant - -// required string userJid = 1; -inline bool GroupParticipant::_internal_has_userjid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool GroupParticipant::has_userjid() const { - return _internal_has_userjid(); -} -inline void GroupParticipant::clear_userjid() { - _impl_.userjid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& GroupParticipant::userjid() const { - // @@protoc_insertion_point(field_get:proto.GroupParticipant.userJid) - return _internal_userjid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void GroupParticipant::set_userjid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.userjid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.GroupParticipant.userJid) -} -inline std::string* GroupParticipant::mutable_userjid() { - std::string* _s = _internal_mutable_userjid(); - // @@protoc_insertion_point(field_mutable:proto.GroupParticipant.userJid) - return _s; -} -inline const std::string& GroupParticipant::_internal_userjid() const { - return _impl_.userjid_.Get(); -} -inline void GroupParticipant::_internal_set_userjid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.userjid_.Set(value, GetArenaForAllocation()); -} -inline std::string* GroupParticipant::_internal_mutable_userjid() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.userjid_.Mutable(GetArenaForAllocation()); -} -inline std::string* GroupParticipant::release_userjid() { - // @@protoc_insertion_point(field_release:proto.GroupParticipant.userJid) - if (!_internal_has_userjid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.userjid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.userjid_.IsDefault()) { - _impl_.userjid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void GroupParticipant::set_allocated_userjid(std::string* userjid) { - if (userjid != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.userjid_.SetAllocated(userjid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.userjid_.IsDefault()) { - _impl_.userjid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.GroupParticipant.userJid) -} - -// optional .proto.GroupParticipant.Rank rank = 2; -inline bool GroupParticipant::_internal_has_rank() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool GroupParticipant::has_rank() const { - return _internal_has_rank(); -} -inline void GroupParticipant::clear_rank() { - _impl_.rank_ = 0; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline ::proto::GroupParticipant_Rank GroupParticipant::_internal_rank() const { - return static_cast< ::proto::GroupParticipant_Rank >(_impl_.rank_); -} -inline ::proto::GroupParticipant_Rank GroupParticipant::rank() const { - // @@protoc_insertion_point(field_get:proto.GroupParticipant.rank) - return _internal_rank(); -} -inline void GroupParticipant::_internal_set_rank(::proto::GroupParticipant_Rank value) { - assert(::proto::GroupParticipant_Rank_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.rank_ = value; -} -inline void GroupParticipant::set_rank(::proto::GroupParticipant_Rank value) { - _internal_set_rank(value); - // @@protoc_insertion_point(field_set:proto.GroupParticipant.rank) -} - -// ------------------------------------------------------------------- - -// HandshakeMessage_ClientFinish - -// optional bytes static = 1; -inline bool HandshakeMessage_ClientFinish::_internal_has_static_() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool HandshakeMessage_ClientFinish::has_static_() const { - return _internal_has_static_(); -} -inline void HandshakeMessage_ClientFinish::clear_static_() { - _impl_.static__.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& HandshakeMessage_ClientFinish::static_() const { - // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ClientFinish.static) - return _internal_static_(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void HandshakeMessage_ClientFinish::set_static_(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.static__.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ClientFinish.static) -} -inline std::string* HandshakeMessage_ClientFinish::mutable_static_() { - std::string* _s = _internal_mutable_static_(); - // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ClientFinish.static) - return _s; -} -inline const std::string& HandshakeMessage_ClientFinish::_internal_static_() const { - return _impl_.static__.Get(); -} -inline void HandshakeMessage_ClientFinish::_internal_set_static_(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.static__.Set(value, GetArenaForAllocation()); -} -inline std::string* HandshakeMessage_ClientFinish::_internal_mutable_static_() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.static__.Mutable(GetArenaForAllocation()); -} -inline std::string* HandshakeMessage_ClientFinish::release_static_() { - // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ClientFinish.static) - if (!_internal_has_static_()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.static__.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.static__.IsDefault()) { - _impl_.static__.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void HandshakeMessage_ClientFinish::set_allocated_static_(std::string* static_) { - if (static_ != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.static__.SetAllocated(static_, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.static__.IsDefault()) { - _impl_.static__.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ClientFinish.static) -} - -// optional bytes payload = 2; -inline bool HandshakeMessage_ClientFinish::_internal_has_payload() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool HandshakeMessage_ClientFinish::has_payload() const { - return _internal_has_payload(); -} -inline void HandshakeMessage_ClientFinish::clear_payload() { - _impl_.payload_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& HandshakeMessage_ClientFinish::payload() const { - // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ClientFinish.payload) - return _internal_payload(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void HandshakeMessage_ClientFinish::set_payload(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.payload_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ClientFinish.payload) -} -inline std::string* HandshakeMessage_ClientFinish::mutable_payload() { - std::string* _s = _internal_mutable_payload(); - // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ClientFinish.payload) - return _s; -} -inline const std::string& HandshakeMessage_ClientFinish::_internal_payload() const { - return _impl_.payload_.Get(); -} -inline void HandshakeMessage_ClientFinish::_internal_set_payload(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.payload_.Set(value, GetArenaForAllocation()); -} -inline std::string* HandshakeMessage_ClientFinish::_internal_mutable_payload() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.payload_.Mutable(GetArenaForAllocation()); -} -inline std::string* HandshakeMessage_ClientFinish::release_payload() { - // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ClientFinish.payload) - if (!_internal_has_payload()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.payload_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.payload_.IsDefault()) { - _impl_.payload_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void HandshakeMessage_ClientFinish::set_allocated_payload(std::string* payload) { - if (payload != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.payload_.SetAllocated(payload, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.payload_.IsDefault()) { - _impl_.payload_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ClientFinish.payload) -} - -// ------------------------------------------------------------------- - -// HandshakeMessage_ClientHello - -// optional bytes ephemeral = 1; -inline bool HandshakeMessage_ClientHello::_internal_has_ephemeral() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool HandshakeMessage_ClientHello::has_ephemeral() const { - return _internal_has_ephemeral(); -} -inline void HandshakeMessage_ClientHello::clear_ephemeral() { - _impl_.ephemeral_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& HandshakeMessage_ClientHello::ephemeral() const { - // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ClientHello.ephemeral) - return _internal_ephemeral(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void HandshakeMessage_ClientHello::set_ephemeral(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.ephemeral_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ClientHello.ephemeral) -} -inline std::string* HandshakeMessage_ClientHello::mutable_ephemeral() { - std::string* _s = _internal_mutable_ephemeral(); - // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ClientHello.ephemeral) - return _s; -} -inline const std::string& HandshakeMessage_ClientHello::_internal_ephemeral() const { - return _impl_.ephemeral_.Get(); -} -inline void HandshakeMessage_ClientHello::_internal_set_ephemeral(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.ephemeral_.Set(value, GetArenaForAllocation()); -} -inline std::string* HandshakeMessage_ClientHello::_internal_mutable_ephemeral() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.ephemeral_.Mutable(GetArenaForAllocation()); -} -inline std::string* HandshakeMessage_ClientHello::release_ephemeral() { - // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ClientHello.ephemeral) - if (!_internal_has_ephemeral()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.ephemeral_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.ephemeral_.IsDefault()) { - _impl_.ephemeral_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void HandshakeMessage_ClientHello::set_allocated_ephemeral(std::string* ephemeral) { - if (ephemeral != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.ephemeral_.SetAllocated(ephemeral, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.ephemeral_.IsDefault()) { - _impl_.ephemeral_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ClientHello.ephemeral) -} - -// optional bytes static = 2; -inline bool HandshakeMessage_ClientHello::_internal_has_static_() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool HandshakeMessage_ClientHello::has_static_() const { - return _internal_has_static_(); -} -inline void HandshakeMessage_ClientHello::clear_static_() { - _impl_.static__.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& HandshakeMessage_ClientHello::static_() const { - // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ClientHello.static) - return _internal_static_(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void HandshakeMessage_ClientHello::set_static_(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.static__.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ClientHello.static) -} -inline std::string* HandshakeMessage_ClientHello::mutable_static_() { - std::string* _s = _internal_mutable_static_(); - // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ClientHello.static) - return _s; -} -inline const std::string& HandshakeMessage_ClientHello::_internal_static_() const { - return _impl_.static__.Get(); -} -inline void HandshakeMessage_ClientHello::_internal_set_static_(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.static__.Set(value, GetArenaForAllocation()); -} -inline std::string* HandshakeMessage_ClientHello::_internal_mutable_static_() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.static__.Mutable(GetArenaForAllocation()); -} -inline std::string* HandshakeMessage_ClientHello::release_static_() { - // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ClientHello.static) - if (!_internal_has_static_()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.static__.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.static__.IsDefault()) { - _impl_.static__.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void HandshakeMessage_ClientHello::set_allocated_static_(std::string* static_) { - if (static_ != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.static__.SetAllocated(static_, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.static__.IsDefault()) { - _impl_.static__.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ClientHello.static) -} - -// optional bytes payload = 3; -inline bool HandshakeMessage_ClientHello::_internal_has_payload() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool HandshakeMessage_ClientHello::has_payload() const { - return _internal_has_payload(); -} -inline void HandshakeMessage_ClientHello::clear_payload() { - _impl_.payload_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& HandshakeMessage_ClientHello::payload() const { - // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ClientHello.payload) - return _internal_payload(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void HandshakeMessage_ClientHello::set_payload(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.payload_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ClientHello.payload) -} -inline std::string* HandshakeMessage_ClientHello::mutable_payload() { - std::string* _s = _internal_mutable_payload(); - // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ClientHello.payload) - return _s; -} -inline const std::string& HandshakeMessage_ClientHello::_internal_payload() const { - return _impl_.payload_.Get(); -} -inline void HandshakeMessage_ClientHello::_internal_set_payload(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.payload_.Set(value, GetArenaForAllocation()); -} -inline std::string* HandshakeMessage_ClientHello::_internal_mutable_payload() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.payload_.Mutable(GetArenaForAllocation()); -} -inline std::string* HandshakeMessage_ClientHello::release_payload() { - // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ClientHello.payload) - if (!_internal_has_payload()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.payload_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.payload_.IsDefault()) { - _impl_.payload_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void HandshakeMessage_ClientHello::set_allocated_payload(std::string* payload) { - if (payload != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.payload_.SetAllocated(payload, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.payload_.IsDefault()) { - _impl_.payload_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ClientHello.payload) -} - -// ------------------------------------------------------------------- - -// HandshakeMessage_ServerHello - -// optional bytes ephemeral = 1; -inline bool HandshakeMessage_ServerHello::_internal_has_ephemeral() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool HandshakeMessage_ServerHello::has_ephemeral() const { - return _internal_has_ephemeral(); -} -inline void HandshakeMessage_ServerHello::clear_ephemeral() { - _impl_.ephemeral_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& HandshakeMessage_ServerHello::ephemeral() const { - // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ServerHello.ephemeral) - return _internal_ephemeral(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void HandshakeMessage_ServerHello::set_ephemeral(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.ephemeral_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ServerHello.ephemeral) -} -inline std::string* HandshakeMessage_ServerHello::mutable_ephemeral() { - std::string* _s = _internal_mutable_ephemeral(); - // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ServerHello.ephemeral) - return _s; -} -inline const std::string& HandshakeMessage_ServerHello::_internal_ephemeral() const { - return _impl_.ephemeral_.Get(); -} -inline void HandshakeMessage_ServerHello::_internal_set_ephemeral(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.ephemeral_.Set(value, GetArenaForAllocation()); -} -inline std::string* HandshakeMessage_ServerHello::_internal_mutable_ephemeral() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.ephemeral_.Mutable(GetArenaForAllocation()); -} -inline std::string* HandshakeMessage_ServerHello::release_ephemeral() { - // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ServerHello.ephemeral) - if (!_internal_has_ephemeral()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.ephemeral_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.ephemeral_.IsDefault()) { - _impl_.ephemeral_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void HandshakeMessage_ServerHello::set_allocated_ephemeral(std::string* ephemeral) { - if (ephemeral != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.ephemeral_.SetAllocated(ephemeral, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.ephemeral_.IsDefault()) { - _impl_.ephemeral_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ServerHello.ephemeral) -} - -// optional bytes static = 2; -inline bool HandshakeMessage_ServerHello::_internal_has_static_() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool HandshakeMessage_ServerHello::has_static_() const { - return _internal_has_static_(); -} -inline void HandshakeMessage_ServerHello::clear_static_() { - _impl_.static__.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& HandshakeMessage_ServerHello::static_() const { - // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ServerHello.static) - return _internal_static_(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void HandshakeMessage_ServerHello::set_static_(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.static__.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ServerHello.static) -} -inline std::string* HandshakeMessage_ServerHello::mutable_static_() { - std::string* _s = _internal_mutable_static_(); - // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ServerHello.static) - return _s; -} -inline const std::string& HandshakeMessage_ServerHello::_internal_static_() const { - return _impl_.static__.Get(); -} -inline void HandshakeMessage_ServerHello::_internal_set_static_(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.static__.Set(value, GetArenaForAllocation()); -} -inline std::string* HandshakeMessage_ServerHello::_internal_mutable_static_() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.static__.Mutable(GetArenaForAllocation()); -} -inline std::string* HandshakeMessage_ServerHello::release_static_() { - // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ServerHello.static) - if (!_internal_has_static_()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.static__.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.static__.IsDefault()) { - _impl_.static__.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void HandshakeMessage_ServerHello::set_allocated_static_(std::string* static_) { - if (static_ != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.static__.SetAllocated(static_, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.static__.IsDefault()) { - _impl_.static__.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ServerHello.static) -} - -// optional bytes payload = 3; -inline bool HandshakeMessage_ServerHello::_internal_has_payload() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool HandshakeMessage_ServerHello::has_payload() const { - return _internal_has_payload(); -} -inline void HandshakeMessage_ServerHello::clear_payload() { - _impl_.payload_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& HandshakeMessage_ServerHello::payload() const { - // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ServerHello.payload) - return _internal_payload(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void HandshakeMessage_ServerHello::set_payload(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.payload_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ServerHello.payload) -} -inline std::string* HandshakeMessage_ServerHello::mutable_payload() { - std::string* _s = _internal_mutable_payload(); - // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ServerHello.payload) - return _s; -} -inline const std::string& HandshakeMessage_ServerHello::_internal_payload() const { - return _impl_.payload_.Get(); -} -inline void HandshakeMessage_ServerHello::_internal_set_payload(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.payload_.Set(value, GetArenaForAllocation()); -} -inline std::string* HandshakeMessage_ServerHello::_internal_mutable_payload() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.payload_.Mutable(GetArenaForAllocation()); -} -inline std::string* HandshakeMessage_ServerHello::release_payload() { - // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ServerHello.payload) - if (!_internal_has_payload()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.payload_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.payload_.IsDefault()) { - _impl_.payload_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void HandshakeMessage_ServerHello::set_allocated_payload(std::string* payload) { - if (payload != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.payload_.SetAllocated(payload, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.payload_.IsDefault()) { - _impl_.payload_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ServerHello.payload) -} - -// ------------------------------------------------------------------- - -// HandshakeMessage - -// optional .proto.HandshakeMessage.ClientHello clientHello = 2; -inline bool HandshakeMessage::_internal_has_clienthello() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.clienthello_ != nullptr); - return value; -} -inline bool HandshakeMessage::has_clienthello() const { - return _internal_has_clienthello(); -} -inline void HandshakeMessage::clear_clienthello() { - if (_impl_.clienthello_ != nullptr) _impl_.clienthello_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::HandshakeMessage_ClientHello& HandshakeMessage::_internal_clienthello() const { - const ::proto::HandshakeMessage_ClientHello* p = _impl_.clienthello_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_HandshakeMessage_ClientHello_default_instance_); -} -inline const ::proto::HandshakeMessage_ClientHello& HandshakeMessage::clienthello() const { - // @@protoc_insertion_point(field_get:proto.HandshakeMessage.clientHello) - return _internal_clienthello(); -} -inline void HandshakeMessage::unsafe_arena_set_allocated_clienthello( - ::proto::HandshakeMessage_ClientHello* clienthello) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.clienthello_); - } - _impl_.clienthello_ = clienthello; - if (clienthello) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HandshakeMessage.clientHello) -} -inline ::proto::HandshakeMessage_ClientHello* HandshakeMessage::release_clienthello() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::HandshakeMessage_ClientHello* temp = _impl_.clienthello_; - _impl_.clienthello_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::HandshakeMessage_ClientHello* HandshakeMessage::unsafe_arena_release_clienthello() { - // @@protoc_insertion_point(field_release:proto.HandshakeMessage.clientHello) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::HandshakeMessage_ClientHello* temp = _impl_.clienthello_; - _impl_.clienthello_ = nullptr; - return temp; -} -inline ::proto::HandshakeMessage_ClientHello* HandshakeMessage::_internal_mutable_clienthello() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.clienthello_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::HandshakeMessage_ClientHello>(GetArenaForAllocation()); - _impl_.clienthello_ = p; - } - return _impl_.clienthello_; -} -inline ::proto::HandshakeMessage_ClientHello* HandshakeMessage::mutable_clienthello() { - ::proto::HandshakeMessage_ClientHello* _msg = _internal_mutable_clienthello(); - // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.clientHello) - return _msg; -} -inline void HandshakeMessage::set_allocated_clienthello(::proto::HandshakeMessage_ClientHello* clienthello) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.clienthello_; - } - if (clienthello) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(clienthello); - if (message_arena != submessage_arena) { - clienthello = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, clienthello, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.clienthello_ = clienthello; - // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.clientHello) -} - -// optional .proto.HandshakeMessage.ServerHello serverHello = 3; -inline bool HandshakeMessage::_internal_has_serverhello() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.serverhello_ != nullptr); - return value; -} -inline bool HandshakeMessage::has_serverhello() const { - return _internal_has_serverhello(); -} -inline void HandshakeMessage::clear_serverhello() { - if (_impl_.serverhello_ != nullptr) _impl_.serverhello_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::HandshakeMessage_ServerHello& HandshakeMessage::_internal_serverhello() const { - const ::proto::HandshakeMessage_ServerHello* p = _impl_.serverhello_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_HandshakeMessage_ServerHello_default_instance_); -} -inline const ::proto::HandshakeMessage_ServerHello& HandshakeMessage::serverhello() const { - // @@protoc_insertion_point(field_get:proto.HandshakeMessage.serverHello) - return _internal_serverhello(); -} -inline void HandshakeMessage::unsafe_arena_set_allocated_serverhello( - ::proto::HandshakeMessage_ServerHello* serverhello) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.serverhello_); - } - _impl_.serverhello_ = serverhello; - if (serverhello) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HandshakeMessage.serverHello) -} -inline ::proto::HandshakeMessage_ServerHello* HandshakeMessage::release_serverhello() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::HandshakeMessage_ServerHello* temp = _impl_.serverhello_; - _impl_.serverhello_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::HandshakeMessage_ServerHello* HandshakeMessage::unsafe_arena_release_serverhello() { - // @@protoc_insertion_point(field_release:proto.HandshakeMessage.serverHello) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::HandshakeMessage_ServerHello* temp = _impl_.serverhello_; - _impl_.serverhello_ = nullptr; - return temp; -} -inline ::proto::HandshakeMessage_ServerHello* HandshakeMessage::_internal_mutable_serverhello() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.serverhello_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::HandshakeMessage_ServerHello>(GetArenaForAllocation()); - _impl_.serverhello_ = p; - } - return _impl_.serverhello_; -} -inline ::proto::HandshakeMessage_ServerHello* HandshakeMessage::mutable_serverhello() { - ::proto::HandshakeMessage_ServerHello* _msg = _internal_mutable_serverhello(); - // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.serverHello) - return _msg; -} -inline void HandshakeMessage::set_allocated_serverhello(::proto::HandshakeMessage_ServerHello* serverhello) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.serverhello_; - } - if (serverhello) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(serverhello); - if (message_arena != submessage_arena) { - serverhello = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, serverhello, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.serverhello_ = serverhello; - // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.serverHello) -} - -// optional .proto.HandshakeMessage.ClientFinish clientFinish = 4; -inline bool HandshakeMessage::_internal_has_clientfinish() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - PROTOBUF_ASSUME(!value || _impl_.clientfinish_ != nullptr); - return value; -} -inline bool HandshakeMessage::has_clientfinish() const { - return _internal_has_clientfinish(); -} -inline void HandshakeMessage::clear_clientfinish() { - if (_impl_.clientfinish_ != nullptr) _impl_.clientfinish_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const ::proto::HandshakeMessage_ClientFinish& HandshakeMessage::_internal_clientfinish() const { - const ::proto::HandshakeMessage_ClientFinish* p = _impl_.clientfinish_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_HandshakeMessage_ClientFinish_default_instance_); -} -inline const ::proto::HandshakeMessage_ClientFinish& HandshakeMessage::clientfinish() const { - // @@protoc_insertion_point(field_get:proto.HandshakeMessage.clientFinish) - return _internal_clientfinish(); -} -inline void HandshakeMessage::unsafe_arena_set_allocated_clientfinish( - ::proto::HandshakeMessage_ClientFinish* clientfinish) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.clientfinish_); - } - _impl_.clientfinish_ = clientfinish; - if (clientfinish) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HandshakeMessage.clientFinish) -} -inline ::proto::HandshakeMessage_ClientFinish* HandshakeMessage::release_clientfinish() { - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::HandshakeMessage_ClientFinish* temp = _impl_.clientfinish_; - _impl_.clientfinish_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::HandshakeMessage_ClientFinish* HandshakeMessage::unsafe_arena_release_clientfinish() { - // @@protoc_insertion_point(field_release:proto.HandshakeMessage.clientFinish) - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::HandshakeMessage_ClientFinish* temp = _impl_.clientfinish_; - _impl_.clientfinish_ = nullptr; - return temp; -} -inline ::proto::HandshakeMessage_ClientFinish* HandshakeMessage::_internal_mutable_clientfinish() { - _impl_._has_bits_[0] |= 0x00000004u; - if (_impl_.clientfinish_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::HandshakeMessage_ClientFinish>(GetArenaForAllocation()); - _impl_.clientfinish_ = p; - } - return _impl_.clientfinish_; -} -inline ::proto::HandshakeMessage_ClientFinish* HandshakeMessage::mutable_clientfinish() { - ::proto::HandshakeMessage_ClientFinish* _msg = _internal_mutable_clientfinish(); - // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.clientFinish) - return _msg; -} -inline void HandshakeMessage::set_allocated_clientfinish(::proto::HandshakeMessage_ClientFinish* clientfinish) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.clientfinish_; - } - if (clientfinish) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(clientfinish); - if (message_arena != submessage_arena) { - clientfinish = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, clientfinish, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.clientfinish_ = clientfinish; - // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.clientFinish) -} - -// ------------------------------------------------------------------- - -// HistorySync - -// required .proto.HistorySync.HistorySyncType syncType = 1; -inline bool HistorySync::_internal_has_synctype() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool HistorySync::has_synctype() const { - return _internal_has_synctype(); -} -inline void HistorySync::clear_synctype() { - _impl_.synctype_ = 0; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline ::proto::HistorySync_HistorySyncType HistorySync::_internal_synctype() const { - return static_cast< ::proto::HistorySync_HistorySyncType >(_impl_.synctype_); -} -inline ::proto::HistorySync_HistorySyncType HistorySync::synctype() const { - // @@protoc_insertion_point(field_get:proto.HistorySync.syncType) - return _internal_synctype(); -} -inline void HistorySync::_internal_set_synctype(::proto::HistorySync_HistorySyncType value) { - assert(::proto::HistorySync_HistorySyncType_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.synctype_ = value; -} -inline void HistorySync::set_synctype(::proto::HistorySync_HistorySyncType value) { - _internal_set_synctype(value); - // @@protoc_insertion_point(field_set:proto.HistorySync.syncType) -} - -// repeated .proto.Conversation conversations = 2; -inline int HistorySync::_internal_conversations_size() const { - return _impl_.conversations_.size(); -} -inline int HistorySync::conversations_size() const { - return _internal_conversations_size(); -} -inline void HistorySync::clear_conversations() { - _impl_.conversations_.Clear(); -} -inline ::proto::Conversation* HistorySync::mutable_conversations(int index) { - // @@protoc_insertion_point(field_mutable:proto.HistorySync.conversations) - return _impl_.conversations_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Conversation >* -HistorySync::mutable_conversations() { - // @@protoc_insertion_point(field_mutable_list:proto.HistorySync.conversations) - return &_impl_.conversations_; -} -inline const ::proto::Conversation& HistorySync::_internal_conversations(int index) const { - return _impl_.conversations_.Get(index); -} -inline const ::proto::Conversation& HistorySync::conversations(int index) const { - // @@protoc_insertion_point(field_get:proto.HistorySync.conversations) - return _internal_conversations(index); -} -inline ::proto::Conversation* HistorySync::_internal_add_conversations() { - return _impl_.conversations_.Add(); -} -inline ::proto::Conversation* HistorySync::add_conversations() { - ::proto::Conversation* _add = _internal_add_conversations(); - // @@protoc_insertion_point(field_add:proto.HistorySync.conversations) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Conversation >& -HistorySync::conversations() const { - // @@protoc_insertion_point(field_list:proto.HistorySync.conversations) - return _impl_.conversations_; -} - -// repeated .proto.WebMessageInfo statusV3Messages = 3; -inline int HistorySync::_internal_statusv3messages_size() const { - return _impl_.statusv3messages_.size(); -} -inline int HistorySync::statusv3messages_size() const { - return _internal_statusv3messages_size(); -} -inline void HistorySync::clear_statusv3messages() { - _impl_.statusv3messages_.Clear(); -} -inline ::proto::WebMessageInfo* HistorySync::mutable_statusv3messages(int index) { - // @@protoc_insertion_point(field_mutable:proto.HistorySync.statusV3Messages) - return _impl_.statusv3messages_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >* -HistorySync::mutable_statusv3messages() { - // @@protoc_insertion_point(field_mutable_list:proto.HistorySync.statusV3Messages) - return &_impl_.statusv3messages_; -} -inline const ::proto::WebMessageInfo& HistorySync::_internal_statusv3messages(int index) const { - return _impl_.statusv3messages_.Get(index); -} -inline const ::proto::WebMessageInfo& HistorySync::statusv3messages(int index) const { - // @@protoc_insertion_point(field_get:proto.HistorySync.statusV3Messages) - return _internal_statusv3messages(index); -} -inline ::proto::WebMessageInfo* HistorySync::_internal_add_statusv3messages() { - return _impl_.statusv3messages_.Add(); -} -inline ::proto::WebMessageInfo* HistorySync::add_statusv3messages() { - ::proto::WebMessageInfo* _add = _internal_add_statusv3messages(); - // @@protoc_insertion_point(field_add:proto.HistorySync.statusV3Messages) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >& -HistorySync::statusv3messages() const { - // @@protoc_insertion_point(field_list:proto.HistorySync.statusV3Messages) - return _impl_.statusv3messages_; -} - -// optional uint32 chunkOrder = 5; -inline bool HistorySync::_internal_has_chunkorder() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool HistorySync::has_chunkorder() const { - return _internal_has_chunkorder(); -} -inline void HistorySync::clear_chunkorder() { - _impl_.chunkorder_ = 0u; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline uint32_t HistorySync::_internal_chunkorder() const { - return _impl_.chunkorder_; -} -inline uint32_t HistorySync::chunkorder() const { - // @@protoc_insertion_point(field_get:proto.HistorySync.chunkOrder) - return _internal_chunkorder(); -} -inline void HistorySync::_internal_set_chunkorder(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.chunkorder_ = value; -} -inline void HistorySync::set_chunkorder(uint32_t value) { - _internal_set_chunkorder(value); - // @@protoc_insertion_point(field_set:proto.HistorySync.chunkOrder) -} - -// optional uint32 progress = 6; -inline bool HistorySync::_internal_has_progress() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool HistorySync::has_progress() const { - return _internal_has_progress(); -} -inline void HistorySync::clear_progress() { - _impl_.progress_ = 0u; - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline uint32_t HistorySync::_internal_progress() const { - return _impl_.progress_; -} -inline uint32_t HistorySync::progress() const { - // @@protoc_insertion_point(field_get:proto.HistorySync.progress) - return _internal_progress(); -} -inline void HistorySync::_internal_set_progress(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.progress_ = value; -} -inline void HistorySync::set_progress(uint32_t value) { - _internal_set_progress(value); - // @@protoc_insertion_point(field_set:proto.HistorySync.progress) -} - -// repeated .proto.Pushname pushnames = 7; -inline int HistorySync::_internal_pushnames_size() const { - return _impl_.pushnames_.size(); -} -inline int HistorySync::pushnames_size() const { - return _internal_pushnames_size(); -} -inline void HistorySync::clear_pushnames() { - _impl_.pushnames_.Clear(); -} -inline ::proto::Pushname* HistorySync::mutable_pushnames(int index) { - // @@protoc_insertion_point(field_mutable:proto.HistorySync.pushnames) - return _impl_.pushnames_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Pushname >* -HistorySync::mutable_pushnames() { - // @@protoc_insertion_point(field_mutable_list:proto.HistorySync.pushnames) - return &_impl_.pushnames_; -} -inline const ::proto::Pushname& HistorySync::_internal_pushnames(int index) const { - return _impl_.pushnames_.Get(index); -} -inline const ::proto::Pushname& HistorySync::pushnames(int index) const { - // @@protoc_insertion_point(field_get:proto.HistorySync.pushnames) - return _internal_pushnames(index); -} -inline ::proto::Pushname* HistorySync::_internal_add_pushnames() { - return _impl_.pushnames_.Add(); -} -inline ::proto::Pushname* HistorySync::add_pushnames() { - ::proto::Pushname* _add = _internal_add_pushnames(); - // @@protoc_insertion_point(field_add:proto.HistorySync.pushnames) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Pushname >& -HistorySync::pushnames() const { - // @@protoc_insertion_point(field_list:proto.HistorySync.pushnames) - return _impl_.pushnames_; -} - -// optional .proto.GlobalSettings globalSettings = 8; -inline bool HistorySync::_internal_has_globalsettings() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.globalsettings_ != nullptr); - return value; -} -inline bool HistorySync::has_globalsettings() const { - return _internal_has_globalsettings(); -} -inline void HistorySync::clear_globalsettings() { - if (_impl_.globalsettings_ != nullptr) _impl_.globalsettings_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::GlobalSettings& HistorySync::_internal_globalsettings() const { - const ::proto::GlobalSettings* p = _impl_.globalsettings_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_GlobalSettings_default_instance_); -} -inline const ::proto::GlobalSettings& HistorySync::globalsettings() const { - // @@protoc_insertion_point(field_get:proto.HistorySync.globalSettings) - return _internal_globalsettings(); -} -inline void HistorySync::unsafe_arena_set_allocated_globalsettings( - ::proto::GlobalSettings* globalsettings) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.globalsettings_); - } - _impl_.globalsettings_ = globalsettings; - if (globalsettings) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HistorySync.globalSettings) -} -inline ::proto::GlobalSettings* HistorySync::release_globalsettings() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::GlobalSettings* temp = _impl_.globalsettings_; - _impl_.globalsettings_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::GlobalSettings* HistorySync::unsafe_arena_release_globalsettings() { - // @@protoc_insertion_point(field_release:proto.HistorySync.globalSettings) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::GlobalSettings* temp = _impl_.globalsettings_; - _impl_.globalsettings_ = nullptr; - return temp; -} -inline ::proto::GlobalSettings* HistorySync::_internal_mutable_globalsettings() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.globalsettings_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::GlobalSettings>(GetArenaForAllocation()); - _impl_.globalsettings_ = p; - } - return _impl_.globalsettings_; -} -inline ::proto::GlobalSettings* HistorySync::mutable_globalsettings() { - ::proto::GlobalSettings* _msg = _internal_mutable_globalsettings(); - // @@protoc_insertion_point(field_mutable:proto.HistorySync.globalSettings) - return _msg; -} -inline void HistorySync::set_allocated_globalsettings(::proto::GlobalSettings* globalsettings) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.globalsettings_; - } - if (globalsettings) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(globalsettings); - if (message_arena != submessage_arena) { - globalsettings = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, globalsettings, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.globalsettings_ = globalsettings; - // @@protoc_insertion_point(field_set_allocated:proto.HistorySync.globalSettings) -} - -// optional bytes threadIdUserSecret = 9; -inline bool HistorySync::_internal_has_threadidusersecret() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool HistorySync::has_threadidusersecret() const { - return _internal_has_threadidusersecret(); -} -inline void HistorySync::clear_threadidusersecret() { - _impl_.threadidusersecret_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& HistorySync::threadidusersecret() const { - // @@protoc_insertion_point(field_get:proto.HistorySync.threadIdUserSecret) - return _internal_threadidusersecret(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void HistorySync::set_threadidusersecret(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.threadidusersecret_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.HistorySync.threadIdUserSecret) -} -inline std::string* HistorySync::mutable_threadidusersecret() { - std::string* _s = _internal_mutable_threadidusersecret(); - // @@protoc_insertion_point(field_mutable:proto.HistorySync.threadIdUserSecret) - return _s; -} -inline const std::string& HistorySync::_internal_threadidusersecret() const { - return _impl_.threadidusersecret_.Get(); -} -inline void HistorySync::_internal_set_threadidusersecret(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.threadidusersecret_.Set(value, GetArenaForAllocation()); -} -inline std::string* HistorySync::_internal_mutable_threadidusersecret() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.threadidusersecret_.Mutable(GetArenaForAllocation()); -} -inline std::string* HistorySync::release_threadidusersecret() { - // @@protoc_insertion_point(field_release:proto.HistorySync.threadIdUserSecret) - if (!_internal_has_threadidusersecret()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.threadidusersecret_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.threadidusersecret_.IsDefault()) { - _impl_.threadidusersecret_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void HistorySync::set_allocated_threadidusersecret(std::string* threadidusersecret) { - if (threadidusersecret != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.threadidusersecret_.SetAllocated(threadidusersecret, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.threadidusersecret_.IsDefault()) { - _impl_.threadidusersecret_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.HistorySync.threadIdUserSecret) -} - -// optional uint32 threadDsTimeframeOffset = 10; -inline bool HistorySync::_internal_has_threaddstimeframeoffset() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool HistorySync::has_threaddstimeframeoffset() const { - return _internal_has_threaddstimeframeoffset(); -} -inline void HistorySync::clear_threaddstimeframeoffset() { - _impl_.threaddstimeframeoffset_ = 0u; - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline uint32_t HistorySync::_internal_threaddstimeframeoffset() const { - return _impl_.threaddstimeframeoffset_; -} -inline uint32_t HistorySync::threaddstimeframeoffset() const { - // @@protoc_insertion_point(field_get:proto.HistorySync.threadDsTimeframeOffset) - return _internal_threaddstimeframeoffset(); -} -inline void HistorySync::_internal_set_threaddstimeframeoffset(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.threaddstimeframeoffset_ = value; -} -inline void HistorySync::set_threaddstimeframeoffset(uint32_t value) { - _internal_set_threaddstimeframeoffset(value); - // @@protoc_insertion_point(field_set:proto.HistorySync.threadDsTimeframeOffset) -} - -// repeated .proto.StickerMetadata recentStickers = 11; -inline int HistorySync::_internal_recentstickers_size() const { - return _impl_.recentstickers_.size(); -} -inline int HistorySync::recentstickers_size() const { - return _internal_recentstickers_size(); -} -inline void HistorySync::clear_recentstickers() { - _impl_.recentstickers_.Clear(); -} -inline ::proto::StickerMetadata* HistorySync::mutable_recentstickers(int index) { - // @@protoc_insertion_point(field_mutable:proto.HistorySync.recentStickers) - return _impl_.recentstickers_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::StickerMetadata >* -HistorySync::mutable_recentstickers() { - // @@protoc_insertion_point(field_mutable_list:proto.HistorySync.recentStickers) - return &_impl_.recentstickers_; -} -inline const ::proto::StickerMetadata& HistorySync::_internal_recentstickers(int index) const { - return _impl_.recentstickers_.Get(index); -} -inline const ::proto::StickerMetadata& HistorySync::recentstickers(int index) const { - // @@protoc_insertion_point(field_get:proto.HistorySync.recentStickers) - return _internal_recentstickers(index); -} -inline ::proto::StickerMetadata* HistorySync::_internal_add_recentstickers() { - return _impl_.recentstickers_.Add(); -} -inline ::proto::StickerMetadata* HistorySync::add_recentstickers() { - ::proto::StickerMetadata* _add = _internal_add_recentstickers(); - // @@protoc_insertion_point(field_add:proto.HistorySync.recentStickers) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::StickerMetadata >& -HistorySync::recentstickers() const { - // @@protoc_insertion_point(field_list:proto.HistorySync.recentStickers) - return _impl_.recentstickers_; -} - -// repeated .proto.PastParticipants pastParticipants = 12; -inline int HistorySync::_internal_pastparticipants_size() const { - return _impl_.pastparticipants_.size(); -} -inline int HistorySync::pastparticipants_size() const { - return _internal_pastparticipants_size(); -} -inline void HistorySync::clear_pastparticipants() { - _impl_.pastparticipants_.Clear(); -} -inline ::proto::PastParticipants* HistorySync::mutable_pastparticipants(int index) { - // @@protoc_insertion_point(field_mutable:proto.HistorySync.pastParticipants) - return _impl_.pastparticipants_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipants >* -HistorySync::mutable_pastparticipants() { - // @@protoc_insertion_point(field_mutable_list:proto.HistorySync.pastParticipants) - return &_impl_.pastparticipants_; -} -inline const ::proto::PastParticipants& HistorySync::_internal_pastparticipants(int index) const { - return _impl_.pastparticipants_.Get(index); -} -inline const ::proto::PastParticipants& HistorySync::pastparticipants(int index) const { - // @@protoc_insertion_point(field_get:proto.HistorySync.pastParticipants) - return _internal_pastparticipants(index); -} -inline ::proto::PastParticipants* HistorySync::_internal_add_pastparticipants() { - return _impl_.pastparticipants_.Add(); -} -inline ::proto::PastParticipants* HistorySync::add_pastparticipants() { - ::proto::PastParticipants* _add = _internal_add_pastparticipants(); - // @@protoc_insertion_point(field_add:proto.HistorySync.pastParticipants) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipants >& -HistorySync::pastparticipants() const { - // @@protoc_insertion_point(field_list:proto.HistorySync.pastParticipants) - return _impl_.pastparticipants_; -} - -// ------------------------------------------------------------------- - -// HistorySyncMsg - -// optional .proto.WebMessageInfo message = 1; -inline bool HistorySyncMsg::_internal_has_message() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.message_ != nullptr); - return value; -} -inline bool HistorySyncMsg::has_message() const { - return _internal_has_message(); -} -inline void HistorySyncMsg::clear_message() { - if (_impl_.message_ != nullptr) _impl_.message_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::WebMessageInfo& HistorySyncMsg::_internal_message() const { - const ::proto::WebMessageInfo* p = _impl_.message_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_WebMessageInfo_default_instance_); -} -inline const ::proto::WebMessageInfo& HistorySyncMsg::message() const { - // @@protoc_insertion_point(field_get:proto.HistorySyncMsg.message) - return _internal_message(); -} -inline void HistorySyncMsg::unsafe_arena_set_allocated_message( - ::proto::WebMessageInfo* message) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.message_); - } - _impl_.message_ = message; - if (message) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HistorySyncMsg.message) -} -inline ::proto::WebMessageInfo* HistorySyncMsg::release_message() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::WebMessageInfo* temp = _impl_.message_; - _impl_.message_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::WebMessageInfo* HistorySyncMsg::unsafe_arena_release_message() { - // @@protoc_insertion_point(field_release:proto.HistorySyncMsg.message) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::WebMessageInfo* temp = _impl_.message_; - _impl_.message_ = nullptr; - return temp; -} -inline ::proto::WebMessageInfo* HistorySyncMsg::_internal_mutable_message() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.message_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::WebMessageInfo>(GetArenaForAllocation()); - _impl_.message_ = p; - } - return _impl_.message_; -} -inline ::proto::WebMessageInfo* HistorySyncMsg::mutable_message() { - ::proto::WebMessageInfo* _msg = _internal_mutable_message(); - // @@protoc_insertion_point(field_mutable:proto.HistorySyncMsg.message) - return _msg; -} -inline void HistorySyncMsg::set_allocated_message(::proto::WebMessageInfo* message) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.message_; - } - if (message) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(message); - if (message_arena != submessage_arena) { - message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, message, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.message_ = message; - // @@protoc_insertion_point(field_set_allocated:proto.HistorySyncMsg.message) -} - -// optional uint64 msgOrderId = 2; -inline bool HistorySyncMsg::_internal_has_msgorderid() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool HistorySyncMsg::has_msgorderid() const { - return _internal_has_msgorderid(); -} -inline void HistorySyncMsg::clear_msgorderid() { - _impl_.msgorderid_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline uint64_t HistorySyncMsg::_internal_msgorderid() const { - return _impl_.msgorderid_; -} -inline uint64_t HistorySyncMsg::msgorderid() const { - // @@protoc_insertion_point(field_get:proto.HistorySyncMsg.msgOrderId) - return _internal_msgorderid(); -} -inline void HistorySyncMsg::_internal_set_msgorderid(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.msgorderid_ = value; -} -inline void HistorySyncMsg::set_msgorderid(uint64_t value) { - _internal_set_msgorderid(value); - // @@protoc_insertion_point(field_set:proto.HistorySyncMsg.msgOrderId) -} - -// ------------------------------------------------------------------- - -// HydratedTemplateButton_HydratedCallButton - -// optional string displayText = 1; -inline bool HydratedTemplateButton_HydratedCallButton::_internal_has_displaytext() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool HydratedTemplateButton_HydratedCallButton::has_displaytext() const { - return _internal_has_displaytext(); -} -inline void HydratedTemplateButton_HydratedCallButton::clear_displaytext() { - _impl_.displaytext_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& HydratedTemplateButton_HydratedCallButton::displaytext() const { - // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.HydratedCallButton.displayText) - return _internal_displaytext(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void HydratedTemplateButton_HydratedCallButton::set_displaytext(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.displaytext_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.HydratedTemplateButton.HydratedCallButton.displayText) -} -inline std::string* HydratedTemplateButton_HydratedCallButton::mutable_displaytext() { - std::string* _s = _internal_mutable_displaytext(); - // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.HydratedCallButton.displayText) - return _s; -} -inline const std::string& HydratedTemplateButton_HydratedCallButton::_internal_displaytext() const { - return _impl_.displaytext_.Get(); -} -inline void HydratedTemplateButton_HydratedCallButton::_internal_set_displaytext(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.displaytext_.Set(value, GetArenaForAllocation()); -} -inline std::string* HydratedTemplateButton_HydratedCallButton::_internal_mutable_displaytext() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.displaytext_.Mutable(GetArenaForAllocation()); -} -inline std::string* HydratedTemplateButton_HydratedCallButton::release_displaytext() { - // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.HydratedCallButton.displayText) - if (!_internal_has_displaytext()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.displaytext_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.displaytext_.IsDefault()) { - _impl_.displaytext_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void HydratedTemplateButton_HydratedCallButton::set_allocated_displaytext(std::string* displaytext) { - if (displaytext != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.displaytext_.SetAllocated(displaytext, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.displaytext_.IsDefault()) { - _impl_.displaytext_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.HydratedCallButton.displayText) -} - -// optional string phoneNumber = 2; -inline bool HydratedTemplateButton_HydratedCallButton::_internal_has_phonenumber() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool HydratedTemplateButton_HydratedCallButton::has_phonenumber() const { - return _internal_has_phonenumber(); -} -inline void HydratedTemplateButton_HydratedCallButton::clear_phonenumber() { - _impl_.phonenumber_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& HydratedTemplateButton_HydratedCallButton::phonenumber() const { - // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.HydratedCallButton.phoneNumber) - return _internal_phonenumber(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void HydratedTemplateButton_HydratedCallButton::set_phonenumber(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.phonenumber_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.HydratedTemplateButton.HydratedCallButton.phoneNumber) -} -inline std::string* HydratedTemplateButton_HydratedCallButton::mutable_phonenumber() { - std::string* _s = _internal_mutable_phonenumber(); - // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.HydratedCallButton.phoneNumber) - return _s; -} -inline const std::string& HydratedTemplateButton_HydratedCallButton::_internal_phonenumber() const { - return _impl_.phonenumber_.Get(); -} -inline void HydratedTemplateButton_HydratedCallButton::_internal_set_phonenumber(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.phonenumber_.Set(value, GetArenaForAllocation()); -} -inline std::string* HydratedTemplateButton_HydratedCallButton::_internal_mutable_phonenumber() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.phonenumber_.Mutable(GetArenaForAllocation()); -} -inline std::string* HydratedTemplateButton_HydratedCallButton::release_phonenumber() { - // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.HydratedCallButton.phoneNumber) - if (!_internal_has_phonenumber()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.phonenumber_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.phonenumber_.IsDefault()) { - _impl_.phonenumber_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void HydratedTemplateButton_HydratedCallButton::set_allocated_phonenumber(std::string* phonenumber) { - if (phonenumber != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.phonenumber_.SetAllocated(phonenumber, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.phonenumber_.IsDefault()) { - _impl_.phonenumber_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.HydratedCallButton.phoneNumber) -} - -// ------------------------------------------------------------------- - -// HydratedTemplateButton_HydratedQuickReplyButton - -// optional string displayText = 1; -inline bool HydratedTemplateButton_HydratedQuickReplyButton::_internal_has_displaytext() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool HydratedTemplateButton_HydratedQuickReplyButton::has_displaytext() const { - return _internal_has_displaytext(); -} -inline void HydratedTemplateButton_HydratedQuickReplyButton::clear_displaytext() { - _impl_.displaytext_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& HydratedTemplateButton_HydratedQuickReplyButton::displaytext() const { - // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.HydratedQuickReplyButton.displayText) - return _internal_displaytext(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void HydratedTemplateButton_HydratedQuickReplyButton::set_displaytext(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.displaytext_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.HydratedTemplateButton.HydratedQuickReplyButton.displayText) -} -inline std::string* HydratedTemplateButton_HydratedQuickReplyButton::mutable_displaytext() { - std::string* _s = _internal_mutable_displaytext(); - // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.HydratedQuickReplyButton.displayText) - return _s; -} -inline const std::string& HydratedTemplateButton_HydratedQuickReplyButton::_internal_displaytext() const { - return _impl_.displaytext_.Get(); -} -inline void HydratedTemplateButton_HydratedQuickReplyButton::_internal_set_displaytext(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.displaytext_.Set(value, GetArenaForAllocation()); -} -inline std::string* HydratedTemplateButton_HydratedQuickReplyButton::_internal_mutable_displaytext() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.displaytext_.Mutable(GetArenaForAllocation()); -} -inline std::string* HydratedTemplateButton_HydratedQuickReplyButton::release_displaytext() { - // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.HydratedQuickReplyButton.displayText) - if (!_internal_has_displaytext()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.displaytext_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.displaytext_.IsDefault()) { - _impl_.displaytext_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void HydratedTemplateButton_HydratedQuickReplyButton::set_allocated_displaytext(std::string* displaytext) { - if (displaytext != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.displaytext_.SetAllocated(displaytext, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.displaytext_.IsDefault()) { - _impl_.displaytext_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.HydratedQuickReplyButton.displayText) -} - -// optional string id = 2; -inline bool HydratedTemplateButton_HydratedQuickReplyButton::_internal_has_id() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool HydratedTemplateButton_HydratedQuickReplyButton::has_id() const { - return _internal_has_id(); -} -inline void HydratedTemplateButton_HydratedQuickReplyButton::clear_id() { - _impl_.id_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& HydratedTemplateButton_HydratedQuickReplyButton::id() const { - // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.HydratedQuickReplyButton.id) - return _internal_id(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void HydratedTemplateButton_HydratedQuickReplyButton::set_id(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.id_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.HydratedTemplateButton.HydratedQuickReplyButton.id) -} -inline std::string* HydratedTemplateButton_HydratedQuickReplyButton::mutable_id() { - std::string* _s = _internal_mutable_id(); - // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.HydratedQuickReplyButton.id) - return _s; -} -inline const std::string& HydratedTemplateButton_HydratedQuickReplyButton::_internal_id() const { - return _impl_.id_.Get(); -} -inline void HydratedTemplateButton_HydratedQuickReplyButton::_internal_set_id(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.id_.Set(value, GetArenaForAllocation()); -} -inline std::string* HydratedTemplateButton_HydratedQuickReplyButton::_internal_mutable_id() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.id_.Mutable(GetArenaForAllocation()); -} -inline std::string* HydratedTemplateButton_HydratedQuickReplyButton::release_id() { - // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.HydratedQuickReplyButton.id) - if (!_internal_has_id()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.id_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.id_.IsDefault()) { - _impl_.id_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void HydratedTemplateButton_HydratedQuickReplyButton::set_allocated_id(std::string* id) { - if (id != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.id_.SetAllocated(id, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.id_.IsDefault()) { - _impl_.id_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.HydratedQuickReplyButton.id) -} - -// ------------------------------------------------------------------- - -// HydratedTemplateButton_HydratedURLButton - -// optional string displayText = 1; -inline bool HydratedTemplateButton_HydratedURLButton::_internal_has_displaytext() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool HydratedTemplateButton_HydratedURLButton::has_displaytext() const { - return _internal_has_displaytext(); -} -inline void HydratedTemplateButton_HydratedURLButton::clear_displaytext() { - _impl_.displaytext_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& HydratedTemplateButton_HydratedURLButton::displaytext() const { - // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.HydratedURLButton.displayText) - return _internal_displaytext(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void HydratedTemplateButton_HydratedURLButton::set_displaytext(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.displaytext_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.HydratedTemplateButton.HydratedURLButton.displayText) -} -inline std::string* HydratedTemplateButton_HydratedURLButton::mutable_displaytext() { - std::string* _s = _internal_mutable_displaytext(); - // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.HydratedURLButton.displayText) - return _s; -} -inline const std::string& HydratedTemplateButton_HydratedURLButton::_internal_displaytext() const { - return _impl_.displaytext_.Get(); -} -inline void HydratedTemplateButton_HydratedURLButton::_internal_set_displaytext(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.displaytext_.Set(value, GetArenaForAllocation()); -} -inline std::string* HydratedTemplateButton_HydratedURLButton::_internal_mutable_displaytext() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.displaytext_.Mutable(GetArenaForAllocation()); -} -inline std::string* HydratedTemplateButton_HydratedURLButton::release_displaytext() { - // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.HydratedURLButton.displayText) - if (!_internal_has_displaytext()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.displaytext_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.displaytext_.IsDefault()) { - _impl_.displaytext_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void HydratedTemplateButton_HydratedURLButton::set_allocated_displaytext(std::string* displaytext) { - if (displaytext != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.displaytext_.SetAllocated(displaytext, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.displaytext_.IsDefault()) { - _impl_.displaytext_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.HydratedURLButton.displayText) -} - -// optional string url = 2; -inline bool HydratedTemplateButton_HydratedURLButton::_internal_has_url() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool HydratedTemplateButton_HydratedURLButton::has_url() const { - return _internal_has_url(); -} -inline void HydratedTemplateButton_HydratedURLButton::clear_url() { - _impl_.url_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& HydratedTemplateButton_HydratedURLButton::url() const { - // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.HydratedURLButton.url) - return _internal_url(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void HydratedTemplateButton_HydratedURLButton::set_url(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.url_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.HydratedTemplateButton.HydratedURLButton.url) -} -inline std::string* HydratedTemplateButton_HydratedURLButton::mutable_url() { - std::string* _s = _internal_mutable_url(); - // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.HydratedURLButton.url) - return _s; -} -inline const std::string& HydratedTemplateButton_HydratedURLButton::_internal_url() const { - return _impl_.url_.Get(); -} -inline void HydratedTemplateButton_HydratedURLButton::_internal_set_url(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.url_.Set(value, GetArenaForAllocation()); -} -inline std::string* HydratedTemplateButton_HydratedURLButton::_internal_mutable_url() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.url_.Mutable(GetArenaForAllocation()); -} -inline std::string* HydratedTemplateButton_HydratedURLButton::release_url() { - // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.HydratedURLButton.url) - if (!_internal_has_url()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.url_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.url_.IsDefault()) { - _impl_.url_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void HydratedTemplateButton_HydratedURLButton::set_allocated_url(std::string* url) { - if (url != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.url_.SetAllocated(url, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.url_.IsDefault()) { - _impl_.url_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.HydratedURLButton.url) -} - -// ------------------------------------------------------------------- - -// HydratedTemplateButton - -// optional uint32 index = 4; -inline bool HydratedTemplateButton::_internal_has_index() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool HydratedTemplateButton::has_index() const { - return _internal_has_index(); -} -inline void HydratedTemplateButton::clear_index() { - _impl_.index_ = 0u; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline uint32_t HydratedTemplateButton::_internal_index() const { - return _impl_.index_; -} -inline uint32_t HydratedTemplateButton::index() const { - // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.index) - return _internal_index(); -} -inline void HydratedTemplateButton::_internal_set_index(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.index_ = value; -} -inline void HydratedTemplateButton::set_index(uint32_t value) { - _internal_set_index(value); - // @@protoc_insertion_point(field_set:proto.HydratedTemplateButton.index) -} - -// .proto.HydratedTemplateButton.HydratedQuickReplyButton quickReplyButton = 1; -inline bool HydratedTemplateButton::_internal_has_quickreplybutton() const { - return hydratedButton_case() == kQuickReplyButton; -} -inline bool HydratedTemplateButton::has_quickreplybutton() const { - return _internal_has_quickreplybutton(); -} -inline void HydratedTemplateButton::set_has_quickreplybutton() { - _impl_._oneof_case_[0] = kQuickReplyButton; -} -inline void HydratedTemplateButton::clear_quickreplybutton() { - if (_internal_has_quickreplybutton()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.hydratedButton_.quickreplybutton_; - } - clear_has_hydratedButton(); - } -} -inline ::proto::HydratedTemplateButton_HydratedQuickReplyButton* HydratedTemplateButton::release_quickreplybutton() { - // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.quickReplyButton) - if (_internal_has_quickreplybutton()) { - clear_has_hydratedButton(); - ::proto::HydratedTemplateButton_HydratedQuickReplyButton* temp = _impl_.hydratedButton_.quickreplybutton_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.hydratedButton_.quickreplybutton_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::HydratedTemplateButton_HydratedQuickReplyButton& HydratedTemplateButton::_internal_quickreplybutton() const { - return _internal_has_quickreplybutton() - ? *_impl_.hydratedButton_.quickreplybutton_ - : reinterpret_cast< ::proto::HydratedTemplateButton_HydratedQuickReplyButton&>(::proto::_HydratedTemplateButton_HydratedQuickReplyButton_default_instance_); -} -inline const ::proto::HydratedTemplateButton_HydratedQuickReplyButton& HydratedTemplateButton::quickreplybutton() const { - // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.quickReplyButton) - return _internal_quickreplybutton(); -} -inline ::proto::HydratedTemplateButton_HydratedQuickReplyButton* HydratedTemplateButton::unsafe_arena_release_quickreplybutton() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.HydratedTemplateButton.quickReplyButton) - if (_internal_has_quickreplybutton()) { - clear_has_hydratedButton(); - ::proto::HydratedTemplateButton_HydratedQuickReplyButton* temp = _impl_.hydratedButton_.quickreplybutton_; - _impl_.hydratedButton_.quickreplybutton_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void HydratedTemplateButton::unsafe_arena_set_allocated_quickreplybutton(::proto::HydratedTemplateButton_HydratedQuickReplyButton* quickreplybutton) { - clear_hydratedButton(); - if (quickreplybutton) { - set_has_quickreplybutton(); - _impl_.hydratedButton_.quickreplybutton_ = quickreplybutton; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HydratedTemplateButton.quickReplyButton) -} -inline ::proto::HydratedTemplateButton_HydratedQuickReplyButton* HydratedTemplateButton::_internal_mutable_quickreplybutton() { - if (!_internal_has_quickreplybutton()) { - clear_hydratedButton(); - set_has_quickreplybutton(); - _impl_.hydratedButton_.quickreplybutton_ = CreateMaybeMessage< ::proto::HydratedTemplateButton_HydratedQuickReplyButton >(GetArenaForAllocation()); - } - return _impl_.hydratedButton_.quickreplybutton_; -} -inline ::proto::HydratedTemplateButton_HydratedQuickReplyButton* HydratedTemplateButton::mutable_quickreplybutton() { - ::proto::HydratedTemplateButton_HydratedQuickReplyButton* _msg = _internal_mutable_quickreplybutton(); - // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.quickReplyButton) - return _msg; -} - -// .proto.HydratedTemplateButton.HydratedURLButton urlButton = 2; -inline bool HydratedTemplateButton::_internal_has_urlbutton() const { - return hydratedButton_case() == kUrlButton; -} -inline bool HydratedTemplateButton::has_urlbutton() const { - return _internal_has_urlbutton(); -} -inline void HydratedTemplateButton::set_has_urlbutton() { - _impl_._oneof_case_[0] = kUrlButton; -} -inline void HydratedTemplateButton::clear_urlbutton() { - if (_internal_has_urlbutton()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.hydratedButton_.urlbutton_; - } - clear_has_hydratedButton(); - } -} -inline ::proto::HydratedTemplateButton_HydratedURLButton* HydratedTemplateButton::release_urlbutton() { - // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.urlButton) - if (_internal_has_urlbutton()) { - clear_has_hydratedButton(); - ::proto::HydratedTemplateButton_HydratedURLButton* temp = _impl_.hydratedButton_.urlbutton_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.hydratedButton_.urlbutton_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::HydratedTemplateButton_HydratedURLButton& HydratedTemplateButton::_internal_urlbutton() const { - return _internal_has_urlbutton() - ? *_impl_.hydratedButton_.urlbutton_ - : reinterpret_cast< ::proto::HydratedTemplateButton_HydratedURLButton&>(::proto::_HydratedTemplateButton_HydratedURLButton_default_instance_); -} -inline const ::proto::HydratedTemplateButton_HydratedURLButton& HydratedTemplateButton::urlbutton() const { - // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.urlButton) - return _internal_urlbutton(); -} -inline ::proto::HydratedTemplateButton_HydratedURLButton* HydratedTemplateButton::unsafe_arena_release_urlbutton() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.HydratedTemplateButton.urlButton) - if (_internal_has_urlbutton()) { - clear_has_hydratedButton(); - ::proto::HydratedTemplateButton_HydratedURLButton* temp = _impl_.hydratedButton_.urlbutton_; - _impl_.hydratedButton_.urlbutton_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void HydratedTemplateButton::unsafe_arena_set_allocated_urlbutton(::proto::HydratedTemplateButton_HydratedURLButton* urlbutton) { - clear_hydratedButton(); - if (urlbutton) { - set_has_urlbutton(); - _impl_.hydratedButton_.urlbutton_ = urlbutton; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HydratedTemplateButton.urlButton) -} -inline ::proto::HydratedTemplateButton_HydratedURLButton* HydratedTemplateButton::_internal_mutable_urlbutton() { - if (!_internal_has_urlbutton()) { - clear_hydratedButton(); - set_has_urlbutton(); - _impl_.hydratedButton_.urlbutton_ = CreateMaybeMessage< ::proto::HydratedTemplateButton_HydratedURLButton >(GetArenaForAllocation()); - } - return _impl_.hydratedButton_.urlbutton_; -} -inline ::proto::HydratedTemplateButton_HydratedURLButton* HydratedTemplateButton::mutable_urlbutton() { - ::proto::HydratedTemplateButton_HydratedURLButton* _msg = _internal_mutable_urlbutton(); - // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.urlButton) - return _msg; -} - -// .proto.HydratedTemplateButton.HydratedCallButton callButton = 3; -inline bool HydratedTemplateButton::_internal_has_callbutton() const { - return hydratedButton_case() == kCallButton; -} -inline bool HydratedTemplateButton::has_callbutton() const { - return _internal_has_callbutton(); -} -inline void HydratedTemplateButton::set_has_callbutton() { - _impl_._oneof_case_[0] = kCallButton; -} -inline void HydratedTemplateButton::clear_callbutton() { - if (_internal_has_callbutton()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.hydratedButton_.callbutton_; - } - clear_has_hydratedButton(); - } -} -inline ::proto::HydratedTemplateButton_HydratedCallButton* HydratedTemplateButton::release_callbutton() { - // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.callButton) - if (_internal_has_callbutton()) { - clear_has_hydratedButton(); - ::proto::HydratedTemplateButton_HydratedCallButton* temp = _impl_.hydratedButton_.callbutton_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.hydratedButton_.callbutton_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::HydratedTemplateButton_HydratedCallButton& HydratedTemplateButton::_internal_callbutton() const { - return _internal_has_callbutton() - ? *_impl_.hydratedButton_.callbutton_ - : reinterpret_cast< ::proto::HydratedTemplateButton_HydratedCallButton&>(::proto::_HydratedTemplateButton_HydratedCallButton_default_instance_); -} -inline const ::proto::HydratedTemplateButton_HydratedCallButton& HydratedTemplateButton::callbutton() const { - // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.callButton) - return _internal_callbutton(); -} -inline ::proto::HydratedTemplateButton_HydratedCallButton* HydratedTemplateButton::unsafe_arena_release_callbutton() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.HydratedTemplateButton.callButton) - if (_internal_has_callbutton()) { - clear_has_hydratedButton(); - ::proto::HydratedTemplateButton_HydratedCallButton* temp = _impl_.hydratedButton_.callbutton_; - _impl_.hydratedButton_.callbutton_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void HydratedTemplateButton::unsafe_arena_set_allocated_callbutton(::proto::HydratedTemplateButton_HydratedCallButton* callbutton) { - clear_hydratedButton(); - if (callbutton) { - set_has_callbutton(); - _impl_.hydratedButton_.callbutton_ = callbutton; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HydratedTemplateButton.callButton) -} -inline ::proto::HydratedTemplateButton_HydratedCallButton* HydratedTemplateButton::_internal_mutable_callbutton() { - if (!_internal_has_callbutton()) { - clear_hydratedButton(); - set_has_callbutton(); - _impl_.hydratedButton_.callbutton_ = CreateMaybeMessage< ::proto::HydratedTemplateButton_HydratedCallButton >(GetArenaForAllocation()); - } - return _impl_.hydratedButton_.callbutton_; -} -inline ::proto::HydratedTemplateButton_HydratedCallButton* HydratedTemplateButton::mutable_callbutton() { - ::proto::HydratedTemplateButton_HydratedCallButton* _msg = _internal_mutable_callbutton(); - // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.callButton) - return _msg; -} - -inline bool HydratedTemplateButton::has_hydratedButton() const { - return hydratedButton_case() != HYDRATEDBUTTON_NOT_SET; -} -inline void HydratedTemplateButton::clear_has_hydratedButton() { - _impl_._oneof_case_[0] = HYDRATEDBUTTON_NOT_SET; -} -inline HydratedTemplateButton::HydratedButtonCase HydratedTemplateButton::hydratedButton_case() const { - return HydratedTemplateButton::HydratedButtonCase(_impl_._oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// IdentityKeyPairStructure - -// optional bytes publicKey = 1; -inline bool IdentityKeyPairStructure::_internal_has_publickey() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool IdentityKeyPairStructure::has_publickey() const { - return _internal_has_publickey(); -} -inline void IdentityKeyPairStructure::clear_publickey() { - _impl_.publickey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& IdentityKeyPairStructure::publickey() const { - // @@protoc_insertion_point(field_get:proto.IdentityKeyPairStructure.publicKey) - return _internal_publickey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void IdentityKeyPairStructure::set_publickey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.publickey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.IdentityKeyPairStructure.publicKey) -} -inline std::string* IdentityKeyPairStructure::mutable_publickey() { - std::string* _s = _internal_mutable_publickey(); - // @@protoc_insertion_point(field_mutable:proto.IdentityKeyPairStructure.publicKey) - return _s; -} -inline const std::string& IdentityKeyPairStructure::_internal_publickey() const { - return _impl_.publickey_.Get(); -} -inline void IdentityKeyPairStructure::_internal_set_publickey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.publickey_.Set(value, GetArenaForAllocation()); -} -inline std::string* IdentityKeyPairStructure::_internal_mutable_publickey() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.publickey_.Mutable(GetArenaForAllocation()); -} -inline std::string* IdentityKeyPairStructure::release_publickey() { - // @@protoc_insertion_point(field_release:proto.IdentityKeyPairStructure.publicKey) - if (!_internal_has_publickey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.publickey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.publickey_.IsDefault()) { - _impl_.publickey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void IdentityKeyPairStructure::set_allocated_publickey(std::string* publickey) { - if (publickey != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.publickey_.SetAllocated(publickey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.publickey_.IsDefault()) { - _impl_.publickey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.IdentityKeyPairStructure.publicKey) -} - -// optional bytes privateKey = 2; -inline bool IdentityKeyPairStructure::_internal_has_privatekey() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool IdentityKeyPairStructure::has_privatekey() const { - return _internal_has_privatekey(); -} -inline void IdentityKeyPairStructure::clear_privatekey() { - _impl_.privatekey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& IdentityKeyPairStructure::privatekey() const { - // @@protoc_insertion_point(field_get:proto.IdentityKeyPairStructure.privateKey) - return _internal_privatekey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void IdentityKeyPairStructure::set_privatekey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.privatekey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.IdentityKeyPairStructure.privateKey) -} -inline std::string* IdentityKeyPairStructure::mutable_privatekey() { - std::string* _s = _internal_mutable_privatekey(); - // @@protoc_insertion_point(field_mutable:proto.IdentityKeyPairStructure.privateKey) - return _s; -} -inline const std::string& IdentityKeyPairStructure::_internal_privatekey() const { - return _impl_.privatekey_.Get(); -} -inline void IdentityKeyPairStructure::_internal_set_privatekey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.privatekey_.Set(value, GetArenaForAllocation()); -} -inline std::string* IdentityKeyPairStructure::_internal_mutable_privatekey() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.privatekey_.Mutable(GetArenaForAllocation()); -} -inline std::string* IdentityKeyPairStructure::release_privatekey() { - // @@protoc_insertion_point(field_release:proto.IdentityKeyPairStructure.privateKey) - if (!_internal_has_privatekey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.privatekey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.privatekey_.IsDefault()) { - _impl_.privatekey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void IdentityKeyPairStructure::set_allocated_privatekey(std::string* privatekey) { - if (privatekey != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.privatekey_.SetAllocated(privatekey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.privatekey_.IsDefault()) { - _impl_.privatekey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.IdentityKeyPairStructure.privateKey) -} - -// ------------------------------------------------------------------- - -// InteractiveAnnotation - -// repeated .proto.Point polygonVertices = 1; -inline int InteractiveAnnotation::_internal_polygonvertices_size() const { - return _impl_.polygonvertices_.size(); -} -inline int InteractiveAnnotation::polygonvertices_size() const { - return _internal_polygonvertices_size(); -} -inline void InteractiveAnnotation::clear_polygonvertices() { - _impl_.polygonvertices_.Clear(); -} -inline ::proto::Point* InteractiveAnnotation::mutable_polygonvertices(int index) { - // @@protoc_insertion_point(field_mutable:proto.InteractiveAnnotation.polygonVertices) - return _impl_.polygonvertices_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Point >* -InteractiveAnnotation::mutable_polygonvertices() { - // @@protoc_insertion_point(field_mutable_list:proto.InteractiveAnnotation.polygonVertices) - return &_impl_.polygonvertices_; -} -inline const ::proto::Point& InteractiveAnnotation::_internal_polygonvertices(int index) const { - return _impl_.polygonvertices_.Get(index); -} -inline const ::proto::Point& InteractiveAnnotation::polygonvertices(int index) const { - // @@protoc_insertion_point(field_get:proto.InteractiveAnnotation.polygonVertices) - return _internal_polygonvertices(index); -} -inline ::proto::Point* InteractiveAnnotation::_internal_add_polygonvertices() { - return _impl_.polygonvertices_.Add(); -} -inline ::proto::Point* InteractiveAnnotation::add_polygonvertices() { - ::proto::Point* _add = _internal_add_polygonvertices(); - // @@protoc_insertion_point(field_add:proto.InteractiveAnnotation.polygonVertices) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Point >& -InteractiveAnnotation::polygonvertices() const { - // @@protoc_insertion_point(field_list:proto.InteractiveAnnotation.polygonVertices) - return _impl_.polygonvertices_; -} - -// .proto.Location location = 2; -inline bool InteractiveAnnotation::_internal_has_location() const { - return action_case() == kLocation; -} -inline bool InteractiveAnnotation::has_location() const { - return _internal_has_location(); -} -inline void InteractiveAnnotation::set_has_location() { - _impl_._oneof_case_[0] = kLocation; -} -inline void InteractiveAnnotation::clear_location() { - if (_internal_has_location()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.action_.location_; - } - clear_has_action(); - } -} -inline ::proto::Location* InteractiveAnnotation::release_location() { - // @@protoc_insertion_point(field_release:proto.InteractiveAnnotation.location) - if (_internal_has_location()) { - clear_has_action(); - ::proto::Location* temp = _impl_.action_.location_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.action_.location_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::Location& InteractiveAnnotation::_internal_location() const { - return _internal_has_location() - ? *_impl_.action_.location_ - : reinterpret_cast< ::proto::Location&>(::proto::_Location_default_instance_); -} -inline const ::proto::Location& InteractiveAnnotation::location() const { - // @@protoc_insertion_point(field_get:proto.InteractiveAnnotation.location) - return _internal_location(); -} -inline ::proto::Location* InteractiveAnnotation::unsafe_arena_release_location() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.InteractiveAnnotation.location) - if (_internal_has_location()) { - clear_has_action(); - ::proto::Location* temp = _impl_.action_.location_; - _impl_.action_.location_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void InteractiveAnnotation::unsafe_arena_set_allocated_location(::proto::Location* location) { - clear_action(); - if (location) { - set_has_location(); - _impl_.action_.location_ = location; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.InteractiveAnnotation.location) -} -inline ::proto::Location* InteractiveAnnotation::_internal_mutable_location() { - if (!_internal_has_location()) { - clear_action(); - set_has_location(); - _impl_.action_.location_ = CreateMaybeMessage< ::proto::Location >(GetArenaForAllocation()); - } - return _impl_.action_.location_; -} -inline ::proto::Location* InteractiveAnnotation::mutable_location() { - ::proto::Location* _msg = _internal_mutable_location(); - // @@protoc_insertion_point(field_mutable:proto.InteractiveAnnotation.location) - return _msg; -} - -inline bool InteractiveAnnotation::has_action() const { - return action_case() != ACTION_NOT_SET; -} -inline void InteractiveAnnotation::clear_has_action() { - _impl_._oneof_case_[0] = ACTION_NOT_SET; -} -inline InteractiveAnnotation::ActionCase InteractiveAnnotation::action_case() const { - return InteractiveAnnotation::ActionCase(_impl_._oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// KeepInChat - -// optional .proto.KeepType keepType = 1; -inline bool KeepInChat::_internal_has_keeptype() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool KeepInChat::has_keeptype() const { - return _internal_has_keeptype(); -} -inline void KeepInChat::clear_keeptype() { - _impl_.keeptype_ = 0; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline ::proto::KeepType KeepInChat::_internal_keeptype() const { - return static_cast< ::proto::KeepType >(_impl_.keeptype_); -} -inline ::proto::KeepType KeepInChat::keeptype() const { - // @@protoc_insertion_point(field_get:proto.KeepInChat.keepType) - return _internal_keeptype(); -} -inline void KeepInChat::_internal_set_keeptype(::proto::KeepType value) { - assert(::proto::KeepType_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.keeptype_ = value; -} -inline void KeepInChat::set_keeptype(::proto::KeepType value) { - _internal_set_keeptype(value); - // @@protoc_insertion_point(field_set:proto.KeepInChat.keepType) -} - -// optional int64 serverTimestamp = 2; -inline bool KeepInChat::_internal_has_servertimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool KeepInChat::has_servertimestamp() const { - return _internal_has_servertimestamp(); -} -inline void KeepInChat::clear_servertimestamp() { - _impl_.servertimestamp_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline int64_t KeepInChat::_internal_servertimestamp() const { - return _impl_.servertimestamp_; -} -inline int64_t KeepInChat::servertimestamp() const { - // @@protoc_insertion_point(field_get:proto.KeepInChat.serverTimestamp) - return _internal_servertimestamp(); -} -inline void KeepInChat::_internal_set_servertimestamp(int64_t value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.servertimestamp_ = value; -} -inline void KeepInChat::set_servertimestamp(int64_t value) { - _internal_set_servertimestamp(value); - // @@protoc_insertion_point(field_set:proto.KeepInChat.serverTimestamp) -} - -// optional .proto.MessageKey key = 3; -inline bool KeepInChat::_internal_has_key() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr); - return value; -} -inline bool KeepInChat::has_key() const { - return _internal_has_key(); -} -inline void KeepInChat::clear_key() { - if (_impl_.key_ != nullptr) _impl_.key_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::MessageKey& KeepInChat::_internal_key() const { - const ::proto::MessageKey* p = _impl_.key_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_MessageKey_default_instance_); -} -inline const ::proto::MessageKey& KeepInChat::key() const { - // @@protoc_insertion_point(field_get:proto.KeepInChat.key) - return _internal_key(); -} -inline void KeepInChat::unsafe_arena_set_allocated_key( - ::proto::MessageKey* key) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_); - } - _impl_.key_ = key; - if (key) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.KeepInChat.key) -} -inline ::proto::MessageKey* KeepInChat::release_key() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::MessageKey* temp = _impl_.key_; - _impl_.key_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::MessageKey* KeepInChat::unsafe_arena_release_key() { - // @@protoc_insertion_point(field_release:proto.KeepInChat.key) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::MessageKey* temp = _impl_.key_; - _impl_.key_ = nullptr; - return temp; -} -inline ::proto::MessageKey* KeepInChat::_internal_mutable_key() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.key_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation()); - _impl_.key_ = p; - } - return _impl_.key_; -} -inline ::proto::MessageKey* KeepInChat::mutable_key() { - ::proto::MessageKey* _msg = _internal_mutable_key(); - // @@protoc_insertion_point(field_mutable:proto.KeepInChat.key) - return _msg; -} -inline void KeepInChat::set_allocated_key(::proto::MessageKey* key) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.key_; - } - if (key) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key); - if (message_arena != submessage_arena) { - key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, key, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.key_ = key; - // @@protoc_insertion_point(field_set_allocated:proto.KeepInChat.key) -} - -// optional string deviceJid = 4; -inline bool KeepInChat::_internal_has_devicejid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool KeepInChat::has_devicejid() const { - return _internal_has_devicejid(); -} -inline void KeepInChat::clear_devicejid() { - _impl_.devicejid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& KeepInChat::devicejid() const { - // @@protoc_insertion_point(field_get:proto.KeepInChat.deviceJid) - return _internal_devicejid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void KeepInChat::set_devicejid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.devicejid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.KeepInChat.deviceJid) -} -inline std::string* KeepInChat::mutable_devicejid() { - std::string* _s = _internal_mutable_devicejid(); - // @@protoc_insertion_point(field_mutable:proto.KeepInChat.deviceJid) - return _s; -} -inline const std::string& KeepInChat::_internal_devicejid() const { - return _impl_.devicejid_.Get(); -} -inline void KeepInChat::_internal_set_devicejid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.devicejid_.Set(value, GetArenaForAllocation()); -} -inline std::string* KeepInChat::_internal_mutable_devicejid() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.devicejid_.Mutable(GetArenaForAllocation()); -} -inline std::string* KeepInChat::release_devicejid() { - // @@protoc_insertion_point(field_release:proto.KeepInChat.deviceJid) - if (!_internal_has_devicejid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.devicejid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.devicejid_.IsDefault()) { - _impl_.devicejid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void KeepInChat::set_allocated_devicejid(std::string* devicejid) { - if (devicejid != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.devicejid_.SetAllocated(devicejid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.devicejid_.IsDefault()) { - _impl_.devicejid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.KeepInChat.deviceJid) -} - -// ------------------------------------------------------------------- - -// KeyId - -// optional bytes id = 1; -inline bool KeyId::_internal_has_id() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool KeyId::has_id() const { - return _internal_has_id(); -} -inline void KeyId::clear_id() { - _impl_.id_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& KeyId::id() const { - // @@protoc_insertion_point(field_get:proto.KeyId.id) - return _internal_id(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void KeyId::set_id(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.id_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.KeyId.id) -} -inline std::string* KeyId::mutable_id() { - std::string* _s = _internal_mutable_id(); - // @@protoc_insertion_point(field_mutable:proto.KeyId.id) - return _s; -} -inline const std::string& KeyId::_internal_id() const { - return _impl_.id_.Get(); -} -inline void KeyId::_internal_set_id(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.id_.Set(value, GetArenaForAllocation()); -} -inline std::string* KeyId::_internal_mutable_id() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.id_.Mutable(GetArenaForAllocation()); -} -inline std::string* KeyId::release_id() { - // @@protoc_insertion_point(field_release:proto.KeyId.id) - if (!_internal_has_id()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.id_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.id_.IsDefault()) { - _impl_.id_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void KeyId::set_allocated_id(std::string* id) { - if (id != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.id_.SetAllocated(id, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.id_.IsDefault()) { - _impl_.id_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.KeyId.id) -} - -// ------------------------------------------------------------------- - -// LocalizedName - -// optional string lg = 1; -inline bool LocalizedName::_internal_has_lg() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool LocalizedName::has_lg() const { - return _internal_has_lg(); -} -inline void LocalizedName::clear_lg() { - _impl_.lg_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& LocalizedName::lg() const { - // @@protoc_insertion_point(field_get:proto.LocalizedName.lg) - return _internal_lg(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void LocalizedName::set_lg(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.lg_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.LocalizedName.lg) -} -inline std::string* LocalizedName::mutable_lg() { - std::string* _s = _internal_mutable_lg(); - // @@protoc_insertion_point(field_mutable:proto.LocalizedName.lg) - return _s; -} -inline const std::string& LocalizedName::_internal_lg() const { - return _impl_.lg_.Get(); -} -inline void LocalizedName::_internal_set_lg(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.lg_.Set(value, GetArenaForAllocation()); -} -inline std::string* LocalizedName::_internal_mutable_lg() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.lg_.Mutable(GetArenaForAllocation()); -} -inline std::string* LocalizedName::release_lg() { - // @@protoc_insertion_point(field_release:proto.LocalizedName.lg) - if (!_internal_has_lg()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.lg_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.lg_.IsDefault()) { - _impl_.lg_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void LocalizedName::set_allocated_lg(std::string* lg) { - if (lg != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.lg_.SetAllocated(lg, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.lg_.IsDefault()) { - _impl_.lg_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.LocalizedName.lg) -} - -// optional string lc = 2; -inline bool LocalizedName::_internal_has_lc() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool LocalizedName::has_lc() const { - return _internal_has_lc(); -} -inline void LocalizedName::clear_lc() { - _impl_.lc_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& LocalizedName::lc() const { - // @@protoc_insertion_point(field_get:proto.LocalizedName.lc) - return _internal_lc(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void LocalizedName::set_lc(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.lc_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.LocalizedName.lc) -} -inline std::string* LocalizedName::mutable_lc() { - std::string* _s = _internal_mutable_lc(); - // @@protoc_insertion_point(field_mutable:proto.LocalizedName.lc) - return _s; -} -inline const std::string& LocalizedName::_internal_lc() const { - return _impl_.lc_.Get(); -} -inline void LocalizedName::_internal_set_lc(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.lc_.Set(value, GetArenaForAllocation()); -} -inline std::string* LocalizedName::_internal_mutable_lc() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.lc_.Mutable(GetArenaForAllocation()); -} -inline std::string* LocalizedName::release_lc() { - // @@protoc_insertion_point(field_release:proto.LocalizedName.lc) - if (!_internal_has_lc()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.lc_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.lc_.IsDefault()) { - _impl_.lc_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void LocalizedName::set_allocated_lc(std::string* lc) { - if (lc != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.lc_.SetAllocated(lc, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.lc_.IsDefault()) { - _impl_.lc_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.LocalizedName.lc) -} - -// optional string verifiedName = 3; -inline bool LocalizedName::_internal_has_verifiedname() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool LocalizedName::has_verifiedname() const { - return _internal_has_verifiedname(); -} -inline void LocalizedName::clear_verifiedname() { - _impl_.verifiedname_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& LocalizedName::verifiedname() const { - // @@protoc_insertion_point(field_get:proto.LocalizedName.verifiedName) - return _internal_verifiedname(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void LocalizedName::set_verifiedname(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.verifiedname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.LocalizedName.verifiedName) -} -inline std::string* LocalizedName::mutable_verifiedname() { - std::string* _s = _internal_mutable_verifiedname(); - // @@protoc_insertion_point(field_mutable:proto.LocalizedName.verifiedName) - return _s; -} -inline const std::string& LocalizedName::_internal_verifiedname() const { - return _impl_.verifiedname_.Get(); -} -inline void LocalizedName::_internal_set_verifiedname(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.verifiedname_.Set(value, GetArenaForAllocation()); -} -inline std::string* LocalizedName::_internal_mutable_verifiedname() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.verifiedname_.Mutable(GetArenaForAllocation()); -} -inline std::string* LocalizedName::release_verifiedname() { - // @@protoc_insertion_point(field_release:proto.LocalizedName.verifiedName) - if (!_internal_has_verifiedname()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.verifiedname_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.verifiedname_.IsDefault()) { - _impl_.verifiedname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void LocalizedName::set_allocated_verifiedname(std::string* verifiedname) { - if (verifiedname != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.verifiedname_.SetAllocated(verifiedname, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.verifiedname_.IsDefault()) { - _impl_.verifiedname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.LocalizedName.verifiedName) -} - -// ------------------------------------------------------------------- - -// Location - -// optional double degreesLatitude = 1; -inline bool Location::_internal_has_degreeslatitude() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Location::has_degreeslatitude() const { - return _internal_has_degreeslatitude(); -} -inline void Location::clear_degreeslatitude() { - _impl_.degreeslatitude_ = 0; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline double Location::_internal_degreeslatitude() const { - return _impl_.degreeslatitude_; -} -inline double Location::degreeslatitude() const { - // @@protoc_insertion_point(field_get:proto.Location.degreesLatitude) - return _internal_degreeslatitude(); -} -inline void Location::_internal_set_degreeslatitude(double value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.degreeslatitude_ = value; -} -inline void Location::set_degreeslatitude(double value) { - _internal_set_degreeslatitude(value); - // @@protoc_insertion_point(field_set:proto.Location.degreesLatitude) -} - -// optional double degreesLongitude = 2; -inline bool Location::_internal_has_degreeslongitude() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool Location::has_degreeslongitude() const { - return _internal_has_degreeslongitude(); -} -inline void Location::clear_degreeslongitude() { - _impl_.degreeslongitude_ = 0; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline double Location::_internal_degreeslongitude() const { - return _impl_.degreeslongitude_; -} -inline double Location::degreeslongitude() const { - // @@protoc_insertion_point(field_get:proto.Location.degreesLongitude) - return _internal_degreeslongitude(); -} -inline void Location::_internal_set_degreeslongitude(double value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.degreeslongitude_ = value; -} -inline void Location::set_degreeslongitude(double value) { - _internal_set_degreeslongitude(value); - // @@protoc_insertion_point(field_set:proto.Location.degreesLongitude) -} - -// optional string name = 3; -inline bool Location::_internal_has_name() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Location::has_name() const { - return _internal_has_name(); -} -inline void Location::clear_name() { - _impl_.name_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Location::name() const { - // @@protoc_insertion_point(field_get:proto.Location.name) - return _internal_name(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Location::set_name(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Location.name) -} -inline std::string* Location::mutable_name() { - std::string* _s = _internal_mutable_name(); - // @@protoc_insertion_point(field_mutable:proto.Location.name) - return _s; -} -inline const std::string& Location::_internal_name() const { - return _impl_.name_.Get(); -} -inline void Location::_internal_set_name(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.name_.Set(value, GetArenaForAllocation()); -} -inline std::string* Location::_internal_mutable_name() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.name_.Mutable(GetArenaForAllocation()); -} -inline std::string* Location::release_name() { - // @@protoc_insertion_point(field_release:proto.Location.name) - if (!_internal_has_name()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.name_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.name_.IsDefault()) { - _impl_.name_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Location::set_allocated_name(std::string* name) { - if (name != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.name_.SetAllocated(name, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.name_.IsDefault()) { - _impl_.name_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Location.name) -} - -// ------------------------------------------------------------------- - -// MediaData - -// optional string localPath = 1; -inline bool MediaData::_internal_has_localpath() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool MediaData::has_localpath() const { - return _internal_has_localpath(); -} -inline void MediaData::clear_localpath() { - _impl_.localpath_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& MediaData::localpath() const { - // @@protoc_insertion_point(field_get:proto.MediaData.localPath) - return _internal_localpath(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void MediaData::set_localpath(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.localpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.MediaData.localPath) -} -inline std::string* MediaData::mutable_localpath() { - std::string* _s = _internal_mutable_localpath(); - // @@protoc_insertion_point(field_mutable:proto.MediaData.localPath) - return _s; -} -inline const std::string& MediaData::_internal_localpath() const { - return _impl_.localpath_.Get(); -} -inline void MediaData::_internal_set_localpath(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.localpath_.Set(value, GetArenaForAllocation()); -} -inline std::string* MediaData::_internal_mutable_localpath() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.localpath_.Mutable(GetArenaForAllocation()); -} -inline std::string* MediaData::release_localpath() { - // @@protoc_insertion_point(field_release:proto.MediaData.localPath) - if (!_internal_has_localpath()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.localpath_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.localpath_.IsDefault()) { - _impl_.localpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void MediaData::set_allocated_localpath(std::string* localpath) { - if (localpath != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.localpath_.SetAllocated(localpath, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.localpath_.IsDefault()) { - _impl_.localpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.MediaData.localPath) -} - -// ------------------------------------------------------------------- - -// MediaRetryNotification - -// optional string stanzaId = 1; -inline bool MediaRetryNotification::_internal_has_stanzaid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool MediaRetryNotification::has_stanzaid() const { - return _internal_has_stanzaid(); -} -inline void MediaRetryNotification::clear_stanzaid() { - _impl_.stanzaid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& MediaRetryNotification::stanzaid() const { - // @@protoc_insertion_point(field_get:proto.MediaRetryNotification.stanzaId) - return _internal_stanzaid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void MediaRetryNotification::set_stanzaid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.stanzaid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.MediaRetryNotification.stanzaId) -} -inline std::string* MediaRetryNotification::mutable_stanzaid() { - std::string* _s = _internal_mutable_stanzaid(); - // @@protoc_insertion_point(field_mutable:proto.MediaRetryNotification.stanzaId) - return _s; -} -inline const std::string& MediaRetryNotification::_internal_stanzaid() const { - return _impl_.stanzaid_.Get(); -} -inline void MediaRetryNotification::_internal_set_stanzaid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.stanzaid_.Set(value, GetArenaForAllocation()); -} -inline std::string* MediaRetryNotification::_internal_mutable_stanzaid() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.stanzaid_.Mutable(GetArenaForAllocation()); -} -inline std::string* MediaRetryNotification::release_stanzaid() { - // @@protoc_insertion_point(field_release:proto.MediaRetryNotification.stanzaId) - if (!_internal_has_stanzaid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.stanzaid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.stanzaid_.IsDefault()) { - _impl_.stanzaid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void MediaRetryNotification::set_allocated_stanzaid(std::string* stanzaid) { - if (stanzaid != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.stanzaid_.SetAllocated(stanzaid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.stanzaid_.IsDefault()) { - _impl_.stanzaid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.MediaRetryNotification.stanzaId) -} - -// optional string directPath = 2; -inline bool MediaRetryNotification::_internal_has_directpath() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool MediaRetryNotification::has_directpath() const { - return _internal_has_directpath(); -} -inline void MediaRetryNotification::clear_directpath() { - _impl_.directpath_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& MediaRetryNotification::directpath() const { - // @@protoc_insertion_point(field_get:proto.MediaRetryNotification.directPath) - return _internal_directpath(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void MediaRetryNotification::set_directpath(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.directpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.MediaRetryNotification.directPath) -} -inline std::string* MediaRetryNotification::mutable_directpath() { - std::string* _s = _internal_mutable_directpath(); - // @@protoc_insertion_point(field_mutable:proto.MediaRetryNotification.directPath) - return _s; -} -inline const std::string& MediaRetryNotification::_internal_directpath() const { - return _impl_.directpath_.Get(); -} -inline void MediaRetryNotification::_internal_set_directpath(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.directpath_.Set(value, GetArenaForAllocation()); -} -inline std::string* MediaRetryNotification::_internal_mutable_directpath() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.directpath_.Mutable(GetArenaForAllocation()); -} -inline std::string* MediaRetryNotification::release_directpath() { - // @@protoc_insertion_point(field_release:proto.MediaRetryNotification.directPath) - if (!_internal_has_directpath()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.directpath_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.directpath_.IsDefault()) { - _impl_.directpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void MediaRetryNotification::set_allocated_directpath(std::string* directpath) { - if (directpath != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.directpath_.IsDefault()) { - _impl_.directpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.MediaRetryNotification.directPath) -} - -// optional .proto.MediaRetryNotification.ResultType result = 3; -inline bool MediaRetryNotification::_internal_has_result() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool MediaRetryNotification::has_result() const { - return _internal_has_result(); -} -inline void MediaRetryNotification::clear_result() { - _impl_.result_ = 0; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline ::proto::MediaRetryNotification_ResultType MediaRetryNotification::_internal_result() const { - return static_cast< ::proto::MediaRetryNotification_ResultType >(_impl_.result_); -} -inline ::proto::MediaRetryNotification_ResultType MediaRetryNotification::result() const { - // @@protoc_insertion_point(field_get:proto.MediaRetryNotification.result) - return _internal_result(); -} -inline void MediaRetryNotification::_internal_set_result(::proto::MediaRetryNotification_ResultType value) { - assert(::proto::MediaRetryNotification_ResultType_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.result_ = value; -} -inline void MediaRetryNotification::set_result(::proto::MediaRetryNotification_ResultType value) { - _internal_set_result(value); - // @@protoc_insertion_point(field_set:proto.MediaRetryNotification.result) -} - -// ------------------------------------------------------------------- - -// Message_AppStateFatalExceptionNotification - -// repeated string collectionNames = 1; -inline int Message_AppStateFatalExceptionNotification::_internal_collectionnames_size() const { - return _impl_.collectionnames_.size(); -} -inline int Message_AppStateFatalExceptionNotification::collectionnames_size() const { - return _internal_collectionnames_size(); -} -inline void Message_AppStateFatalExceptionNotification::clear_collectionnames() { - _impl_.collectionnames_.Clear(); -} -inline std::string* Message_AppStateFatalExceptionNotification::add_collectionnames() { - std::string* _s = _internal_add_collectionnames(); - // @@protoc_insertion_point(field_add_mutable:proto.Message.AppStateFatalExceptionNotification.collectionNames) - return _s; -} -inline const std::string& Message_AppStateFatalExceptionNotification::_internal_collectionnames(int index) const { - return _impl_.collectionnames_.Get(index); -} -inline const std::string& Message_AppStateFatalExceptionNotification::collectionnames(int index) const { - // @@protoc_insertion_point(field_get:proto.Message.AppStateFatalExceptionNotification.collectionNames) - return _internal_collectionnames(index); -} -inline std::string* Message_AppStateFatalExceptionNotification::mutable_collectionnames(int index) { - // @@protoc_insertion_point(field_mutable:proto.Message.AppStateFatalExceptionNotification.collectionNames) - return _impl_.collectionnames_.Mutable(index); -} -inline void Message_AppStateFatalExceptionNotification::set_collectionnames(int index, const std::string& value) { - _impl_.collectionnames_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:proto.Message.AppStateFatalExceptionNotification.collectionNames) -} -inline void Message_AppStateFatalExceptionNotification::set_collectionnames(int index, std::string&& value) { - _impl_.collectionnames_.Mutable(index)->assign(std::move(value)); - // @@protoc_insertion_point(field_set:proto.Message.AppStateFatalExceptionNotification.collectionNames) -} -inline void Message_AppStateFatalExceptionNotification::set_collectionnames(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - _impl_.collectionnames_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:proto.Message.AppStateFatalExceptionNotification.collectionNames) -} -inline void Message_AppStateFatalExceptionNotification::set_collectionnames(int index, const char* value, size_t size) { - _impl_.collectionnames_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:proto.Message.AppStateFatalExceptionNotification.collectionNames) -} -inline std::string* Message_AppStateFatalExceptionNotification::_internal_add_collectionnames() { - return _impl_.collectionnames_.Add(); -} -inline void Message_AppStateFatalExceptionNotification::add_collectionnames(const std::string& value) { - _impl_.collectionnames_.Add()->assign(value); - // @@protoc_insertion_point(field_add:proto.Message.AppStateFatalExceptionNotification.collectionNames) -} -inline void Message_AppStateFatalExceptionNotification::add_collectionnames(std::string&& value) { - _impl_.collectionnames_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:proto.Message.AppStateFatalExceptionNotification.collectionNames) -} -inline void Message_AppStateFatalExceptionNotification::add_collectionnames(const char* value) { - GOOGLE_DCHECK(value != nullptr); - _impl_.collectionnames_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:proto.Message.AppStateFatalExceptionNotification.collectionNames) -} -inline void Message_AppStateFatalExceptionNotification::add_collectionnames(const char* value, size_t size) { - _impl_.collectionnames_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:proto.Message.AppStateFatalExceptionNotification.collectionNames) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -Message_AppStateFatalExceptionNotification::collectionnames() const { - // @@protoc_insertion_point(field_list:proto.Message.AppStateFatalExceptionNotification.collectionNames) - return _impl_.collectionnames_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -Message_AppStateFatalExceptionNotification::mutable_collectionnames() { - // @@protoc_insertion_point(field_mutable_list:proto.Message.AppStateFatalExceptionNotification.collectionNames) - return &_impl_.collectionnames_; -} - -// optional int64 timestamp = 2; -inline bool Message_AppStateFatalExceptionNotification::_internal_has_timestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_AppStateFatalExceptionNotification::has_timestamp() const { - return _internal_has_timestamp(); -} -inline void Message_AppStateFatalExceptionNotification::clear_timestamp() { - _impl_.timestamp_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline int64_t Message_AppStateFatalExceptionNotification::_internal_timestamp() const { - return _impl_.timestamp_; -} -inline int64_t Message_AppStateFatalExceptionNotification::timestamp() const { - // @@protoc_insertion_point(field_get:proto.Message.AppStateFatalExceptionNotification.timestamp) - return _internal_timestamp(); -} -inline void Message_AppStateFatalExceptionNotification::_internal_set_timestamp(int64_t value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.timestamp_ = value; -} -inline void Message_AppStateFatalExceptionNotification::set_timestamp(int64_t value) { - _internal_set_timestamp(value); - // @@protoc_insertion_point(field_set:proto.Message.AppStateFatalExceptionNotification.timestamp) -} - -// ------------------------------------------------------------------- - -// Message_AppStateSyncKeyData - -// optional bytes keyData = 1; -inline bool Message_AppStateSyncKeyData::_internal_has_keydata() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_AppStateSyncKeyData::has_keydata() const { - return _internal_has_keydata(); -} -inline void Message_AppStateSyncKeyData::clear_keydata() { - _impl_.keydata_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_AppStateSyncKeyData::keydata() const { - // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyData.keyData) - return _internal_keydata(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_AppStateSyncKeyData::set_keydata(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.keydata_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.AppStateSyncKeyData.keyData) -} -inline std::string* Message_AppStateSyncKeyData::mutable_keydata() { - std::string* _s = _internal_mutable_keydata(); - // @@protoc_insertion_point(field_mutable:proto.Message.AppStateSyncKeyData.keyData) - return _s; -} -inline const std::string& Message_AppStateSyncKeyData::_internal_keydata() const { - return _impl_.keydata_.Get(); -} -inline void Message_AppStateSyncKeyData::_internal_set_keydata(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.keydata_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_AppStateSyncKeyData::_internal_mutable_keydata() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.keydata_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_AppStateSyncKeyData::release_keydata() { - // @@protoc_insertion_point(field_release:proto.Message.AppStateSyncKeyData.keyData) - if (!_internal_has_keydata()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.keydata_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.keydata_.IsDefault()) { - _impl_.keydata_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_AppStateSyncKeyData::set_allocated_keydata(std::string* keydata) { - if (keydata != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.keydata_.SetAllocated(keydata, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.keydata_.IsDefault()) { - _impl_.keydata_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.AppStateSyncKeyData.keyData) -} - -// optional .proto.Message.AppStateSyncKeyFingerprint fingerprint = 2; -inline bool Message_AppStateSyncKeyData::_internal_has_fingerprint() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.fingerprint_ != nullptr); - return value; -} -inline bool Message_AppStateSyncKeyData::has_fingerprint() const { - return _internal_has_fingerprint(); -} -inline void Message_AppStateSyncKeyData::clear_fingerprint() { - if (_impl_.fingerprint_ != nullptr) _impl_.fingerprint_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::Message_AppStateSyncKeyFingerprint& Message_AppStateSyncKeyData::_internal_fingerprint() const { - const ::proto::Message_AppStateSyncKeyFingerprint* p = _impl_.fingerprint_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_AppStateSyncKeyFingerprint_default_instance_); -} -inline const ::proto::Message_AppStateSyncKeyFingerprint& Message_AppStateSyncKeyData::fingerprint() const { - // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyData.fingerprint) - return _internal_fingerprint(); -} -inline void Message_AppStateSyncKeyData::unsafe_arena_set_allocated_fingerprint( - ::proto::Message_AppStateSyncKeyFingerprint* fingerprint) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.fingerprint_); - } - _impl_.fingerprint_ = fingerprint; - if (fingerprint) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.AppStateSyncKeyData.fingerprint) -} -inline ::proto::Message_AppStateSyncKeyFingerprint* Message_AppStateSyncKeyData::release_fingerprint() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::Message_AppStateSyncKeyFingerprint* temp = _impl_.fingerprint_; - _impl_.fingerprint_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_AppStateSyncKeyFingerprint* Message_AppStateSyncKeyData::unsafe_arena_release_fingerprint() { - // @@protoc_insertion_point(field_release:proto.Message.AppStateSyncKeyData.fingerprint) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::Message_AppStateSyncKeyFingerprint* temp = _impl_.fingerprint_; - _impl_.fingerprint_ = nullptr; - return temp; -} -inline ::proto::Message_AppStateSyncKeyFingerprint* Message_AppStateSyncKeyData::_internal_mutable_fingerprint() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.fingerprint_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_AppStateSyncKeyFingerprint>(GetArenaForAllocation()); - _impl_.fingerprint_ = p; - } - return _impl_.fingerprint_; -} -inline ::proto::Message_AppStateSyncKeyFingerprint* Message_AppStateSyncKeyData::mutable_fingerprint() { - ::proto::Message_AppStateSyncKeyFingerprint* _msg = _internal_mutable_fingerprint(); - // @@protoc_insertion_point(field_mutable:proto.Message.AppStateSyncKeyData.fingerprint) - return _msg; -} -inline void Message_AppStateSyncKeyData::set_allocated_fingerprint(::proto::Message_AppStateSyncKeyFingerprint* fingerprint) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.fingerprint_; - } - if (fingerprint) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(fingerprint); - if (message_arena != submessage_arena) { - fingerprint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, fingerprint, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.fingerprint_ = fingerprint; - // @@protoc_insertion_point(field_set_allocated:proto.Message.AppStateSyncKeyData.fingerprint) -} - -// optional int64 timestamp = 3; -inline bool Message_AppStateSyncKeyData::_internal_has_timestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool Message_AppStateSyncKeyData::has_timestamp() const { - return _internal_has_timestamp(); -} -inline void Message_AppStateSyncKeyData::clear_timestamp() { - _impl_.timestamp_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline int64_t Message_AppStateSyncKeyData::_internal_timestamp() const { - return _impl_.timestamp_; -} -inline int64_t Message_AppStateSyncKeyData::timestamp() const { - // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyData.timestamp) - return _internal_timestamp(); -} -inline void Message_AppStateSyncKeyData::_internal_set_timestamp(int64_t value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.timestamp_ = value; -} -inline void Message_AppStateSyncKeyData::set_timestamp(int64_t value) { - _internal_set_timestamp(value); - // @@protoc_insertion_point(field_set:proto.Message.AppStateSyncKeyData.timestamp) -} - -// ------------------------------------------------------------------- - -// Message_AppStateSyncKeyFingerprint - -// optional uint32 rawId = 1; -inline bool Message_AppStateSyncKeyFingerprint::_internal_has_rawid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_AppStateSyncKeyFingerprint::has_rawid() const { - return _internal_has_rawid(); -} -inline void Message_AppStateSyncKeyFingerprint::clear_rawid() { - _impl_.rawid_ = 0u; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline uint32_t Message_AppStateSyncKeyFingerprint::_internal_rawid() const { - return _impl_.rawid_; -} -inline uint32_t Message_AppStateSyncKeyFingerprint::rawid() const { - // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyFingerprint.rawId) - return _internal_rawid(); -} -inline void Message_AppStateSyncKeyFingerprint::_internal_set_rawid(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.rawid_ = value; -} -inline void Message_AppStateSyncKeyFingerprint::set_rawid(uint32_t value) { - _internal_set_rawid(value); - // @@protoc_insertion_point(field_set:proto.Message.AppStateSyncKeyFingerprint.rawId) -} - -// optional uint32 currentIndex = 2; -inline bool Message_AppStateSyncKeyFingerprint::_internal_has_currentindex() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_AppStateSyncKeyFingerprint::has_currentindex() const { - return _internal_has_currentindex(); -} -inline void Message_AppStateSyncKeyFingerprint::clear_currentindex() { - _impl_.currentindex_ = 0u; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline uint32_t Message_AppStateSyncKeyFingerprint::_internal_currentindex() const { - return _impl_.currentindex_; -} -inline uint32_t Message_AppStateSyncKeyFingerprint::currentindex() const { - // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyFingerprint.currentIndex) - return _internal_currentindex(); -} -inline void Message_AppStateSyncKeyFingerprint::_internal_set_currentindex(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.currentindex_ = value; -} -inline void Message_AppStateSyncKeyFingerprint::set_currentindex(uint32_t value) { - _internal_set_currentindex(value); - // @@protoc_insertion_point(field_set:proto.Message.AppStateSyncKeyFingerprint.currentIndex) -} - -// repeated uint32 deviceIndexes = 3 [packed = true]; -inline int Message_AppStateSyncKeyFingerprint::_internal_deviceindexes_size() const { - return _impl_.deviceindexes_.size(); -} -inline int Message_AppStateSyncKeyFingerprint::deviceindexes_size() const { - return _internal_deviceindexes_size(); -} -inline void Message_AppStateSyncKeyFingerprint::clear_deviceindexes() { - _impl_.deviceindexes_.Clear(); -} -inline uint32_t Message_AppStateSyncKeyFingerprint::_internal_deviceindexes(int index) const { - return _impl_.deviceindexes_.Get(index); -} -inline uint32_t Message_AppStateSyncKeyFingerprint::deviceindexes(int index) const { - // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyFingerprint.deviceIndexes) - return _internal_deviceindexes(index); -} -inline void Message_AppStateSyncKeyFingerprint::set_deviceindexes(int index, uint32_t value) { - _impl_.deviceindexes_.Set(index, value); - // @@protoc_insertion_point(field_set:proto.Message.AppStateSyncKeyFingerprint.deviceIndexes) -} -inline void Message_AppStateSyncKeyFingerprint::_internal_add_deviceindexes(uint32_t value) { - _impl_.deviceindexes_.Add(value); -} -inline void Message_AppStateSyncKeyFingerprint::add_deviceindexes(uint32_t value) { - _internal_add_deviceindexes(value); - // @@protoc_insertion_point(field_add:proto.Message.AppStateSyncKeyFingerprint.deviceIndexes) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& -Message_AppStateSyncKeyFingerprint::_internal_deviceindexes() const { - return _impl_.deviceindexes_; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& -Message_AppStateSyncKeyFingerprint::deviceindexes() const { - // @@protoc_insertion_point(field_list:proto.Message.AppStateSyncKeyFingerprint.deviceIndexes) - return _internal_deviceindexes(); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* -Message_AppStateSyncKeyFingerprint::_internal_mutable_deviceindexes() { - return &_impl_.deviceindexes_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* -Message_AppStateSyncKeyFingerprint::mutable_deviceindexes() { - // @@protoc_insertion_point(field_mutable_list:proto.Message.AppStateSyncKeyFingerprint.deviceIndexes) - return _internal_mutable_deviceindexes(); -} - -// ------------------------------------------------------------------- - -// Message_AppStateSyncKeyId - -// optional bytes keyId = 1; -inline bool Message_AppStateSyncKeyId::_internal_has_keyid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_AppStateSyncKeyId::has_keyid() const { - return _internal_has_keyid(); -} -inline void Message_AppStateSyncKeyId::clear_keyid() { - _impl_.keyid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_AppStateSyncKeyId::keyid() const { - // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyId.keyId) - return _internal_keyid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_AppStateSyncKeyId::set_keyid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.keyid_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.AppStateSyncKeyId.keyId) -} -inline std::string* Message_AppStateSyncKeyId::mutable_keyid() { - std::string* _s = _internal_mutable_keyid(); - // @@protoc_insertion_point(field_mutable:proto.Message.AppStateSyncKeyId.keyId) - return _s; -} -inline const std::string& Message_AppStateSyncKeyId::_internal_keyid() const { - return _impl_.keyid_.Get(); -} -inline void Message_AppStateSyncKeyId::_internal_set_keyid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.keyid_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_AppStateSyncKeyId::_internal_mutable_keyid() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.keyid_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_AppStateSyncKeyId::release_keyid() { - // @@protoc_insertion_point(field_release:proto.Message.AppStateSyncKeyId.keyId) - if (!_internal_has_keyid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.keyid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.keyid_.IsDefault()) { - _impl_.keyid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_AppStateSyncKeyId::set_allocated_keyid(std::string* keyid) { - if (keyid != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.keyid_.SetAllocated(keyid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.keyid_.IsDefault()) { - _impl_.keyid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.AppStateSyncKeyId.keyId) -} - -// ------------------------------------------------------------------- - -// Message_AppStateSyncKeyRequest - -// repeated .proto.Message.AppStateSyncKeyId keyIds = 1; -inline int Message_AppStateSyncKeyRequest::_internal_keyids_size() const { - return _impl_.keyids_.size(); -} -inline int Message_AppStateSyncKeyRequest::keyids_size() const { - return _internal_keyids_size(); -} -inline void Message_AppStateSyncKeyRequest::clear_keyids() { - _impl_.keyids_.Clear(); -} -inline ::proto::Message_AppStateSyncKeyId* Message_AppStateSyncKeyRequest::mutable_keyids(int index) { - // @@protoc_insertion_point(field_mutable:proto.Message.AppStateSyncKeyRequest.keyIds) - return _impl_.keyids_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKeyId >* -Message_AppStateSyncKeyRequest::mutable_keyids() { - // @@protoc_insertion_point(field_mutable_list:proto.Message.AppStateSyncKeyRequest.keyIds) - return &_impl_.keyids_; -} -inline const ::proto::Message_AppStateSyncKeyId& Message_AppStateSyncKeyRequest::_internal_keyids(int index) const { - return _impl_.keyids_.Get(index); -} -inline const ::proto::Message_AppStateSyncKeyId& Message_AppStateSyncKeyRequest::keyids(int index) const { - // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyRequest.keyIds) - return _internal_keyids(index); -} -inline ::proto::Message_AppStateSyncKeyId* Message_AppStateSyncKeyRequest::_internal_add_keyids() { - return _impl_.keyids_.Add(); -} -inline ::proto::Message_AppStateSyncKeyId* Message_AppStateSyncKeyRequest::add_keyids() { - ::proto::Message_AppStateSyncKeyId* _add = _internal_add_keyids(); - // @@protoc_insertion_point(field_add:proto.Message.AppStateSyncKeyRequest.keyIds) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKeyId >& -Message_AppStateSyncKeyRequest::keyids() const { - // @@protoc_insertion_point(field_list:proto.Message.AppStateSyncKeyRequest.keyIds) - return _impl_.keyids_; -} - -// ------------------------------------------------------------------- - -// Message_AppStateSyncKeyShare - -// repeated .proto.Message.AppStateSyncKey keys = 1; -inline int Message_AppStateSyncKeyShare::_internal_keys_size() const { - return _impl_.keys_.size(); -} -inline int Message_AppStateSyncKeyShare::keys_size() const { - return _internal_keys_size(); -} -inline void Message_AppStateSyncKeyShare::clear_keys() { - _impl_.keys_.Clear(); -} -inline ::proto::Message_AppStateSyncKey* Message_AppStateSyncKeyShare::mutable_keys(int index) { - // @@protoc_insertion_point(field_mutable:proto.Message.AppStateSyncKeyShare.keys) - return _impl_.keys_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKey >* -Message_AppStateSyncKeyShare::mutable_keys() { - // @@protoc_insertion_point(field_mutable_list:proto.Message.AppStateSyncKeyShare.keys) - return &_impl_.keys_; -} -inline const ::proto::Message_AppStateSyncKey& Message_AppStateSyncKeyShare::_internal_keys(int index) const { - return _impl_.keys_.Get(index); -} -inline const ::proto::Message_AppStateSyncKey& Message_AppStateSyncKeyShare::keys(int index) const { - // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyShare.keys) - return _internal_keys(index); -} -inline ::proto::Message_AppStateSyncKey* Message_AppStateSyncKeyShare::_internal_add_keys() { - return _impl_.keys_.Add(); -} -inline ::proto::Message_AppStateSyncKey* Message_AppStateSyncKeyShare::add_keys() { - ::proto::Message_AppStateSyncKey* _add = _internal_add_keys(); - // @@protoc_insertion_point(field_add:proto.Message.AppStateSyncKeyShare.keys) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKey >& -Message_AppStateSyncKeyShare::keys() const { - // @@protoc_insertion_point(field_list:proto.Message.AppStateSyncKeyShare.keys) - return _impl_.keys_; -} - -// ------------------------------------------------------------------- - -// Message_AppStateSyncKey - -// optional .proto.Message.AppStateSyncKeyId keyId = 1; -inline bool Message_AppStateSyncKey::_internal_has_keyid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.keyid_ != nullptr); - return value; -} -inline bool Message_AppStateSyncKey::has_keyid() const { - return _internal_has_keyid(); -} -inline void Message_AppStateSyncKey::clear_keyid() { - if (_impl_.keyid_ != nullptr) _impl_.keyid_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::Message_AppStateSyncKeyId& Message_AppStateSyncKey::_internal_keyid() const { - const ::proto::Message_AppStateSyncKeyId* p = _impl_.keyid_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_AppStateSyncKeyId_default_instance_); -} -inline const ::proto::Message_AppStateSyncKeyId& Message_AppStateSyncKey::keyid() const { - // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKey.keyId) - return _internal_keyid(); -} -inline void Message_AppStateSyncKey::unsafe_arena_set_allocated_keyid( - ::proto::Message_AppStateSyncKeyId* keyid) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keyid_); - } - _impl_.keyid_ = keyid; - if (keyid) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.AppStateSyncKey.keyId) -} -inline ::proto::Message_AppStateSyncKeyId* Message_AppStateSyncKey::release_keyid() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::Message_AppStateSyncKeyId* temp = _impl_.keyid_; - _impl_.keyid_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_AppStateSyncKeyId* Message_AppStateSyncKey::unsafe_arena_release_keyid() { - // @@protoc_insertion_point(field_release:proto.Message.AppStateSyncKey.keyId) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::Message_AppStateSyncKeyId* temp = _impl_.keyid_; - _impl_.keyid_ = nullptr; - return temp; -} -inline ::proto::Message_AppStateSyncKeyId* Message_AppStateSyncKey::_internal_mutable_keyid() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.keyid_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_AppStateSyncKeyId>(GetArenaForAllocation()); - _impl_.keyid_ = p; - } - return _impl_.keyid_; -} -inline ::proto::Message_AppStateSyncKeyId* Message_AppStateSyncKey::mutable_keyid() { - ::proto::Message_AppStateSyncKeyId* _msg = _internal_mutable_keyid(); - // @@protoc_insertion_point(field_mutable:proto.Message.AppStateSyncKey.keyId) - return _msg; -} -inline void Message_AppStateSyncKey::set_allocated_keyid(::proto::Message_AppStateSyncKeyId* keyid) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.keyid_; - } - if (keyid) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keyid); - if (message_arena != submessage_arena) { - keyid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, keyid, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.keyid_ = keyid; - // @@protoc_insertion_point(field_set_allocated:proto.Message.AppStateSyncKey.keyId) -} - -// optional .proto.Message.AppStateSyncKeyData keyData = 2; -inline bool Message_AppStateSyncKey::_internal_has_keydata() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.keydata_ != nullptr); - return value; -} -inline bool Message_AppStateSyncKey::has_keydata() const { - return _internal_has_keydata(); -} -inline void Message_AppStateSyncKey::clear_keydata() { - if (_impl_.keydata_ != nullptr) _impl_.keydata_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::Message_AppStateSyncKeyData& Message_AppStateSyncKey::_internal_keydata() const { - const ::proto::Message_AppStateSyncKeyData* p = _impl_.keydata_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_AppStateSyncKeyData_default_instance_); -} -inline const ::proto::Message_AppStateSyncKeyData& Message_AppStateSyncKey::keydata() const { - // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKey.keyData) - return _internal_keydata(); -} -inline void Message_AppStateSyncKey::unsafe_arena_set_allocated_keydata( - ::proto::Message_AppStateSyncKeyData* keydata) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keydata_); - } - _impl_.keydata_ = keydata; - if (keydata) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.AppStateSyncKey.keyData) -} -inline ::proto::Message_AppStateSyncKeyData* Message_AppStateSyncKey::release_keydata() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::Message_AppStateSyncKeyData* temp = _impl_.keydata_; - _impl_.keydata_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_AppStateSyncKeyData* Message_AppStateSyncKey::unsafe_arena_release_keydata() { - // @@protoc_insertion_point(field_release:proto.Message.AppStateSyncKey.keyData) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::Message_AppStateSyncKeyData* temp = _impl_.keydata_; - _impl_.keydata_ = nullptr; - return temp; -} -inline ::proto::Message_AppStateSyncKeyData* Message_AppStateSyncKey::_internal_mutable_keydata() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.keydata_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_AppStateSyncKeyData>(GetArenaForAllocation()); - _impl_.keydata_ = p; - } - return _impl_.keydata_; -} -inline ::proto::Message_AppStateSyncKeyData* Message_AppStateSyncKey::mutable_keydata() { - ::proto::Message_AppStateSyncKeyData* _msg = _internal_mutable_keydata(); - // @@protoc_insertion_point(field_mutable:proto.Message.AppStateSyncKey.keyData) - return _msg; -} -inline void Message_AppStateSyncKey::set_allocated_keydata(::proto::Message_AppStateSyncKeyData* keydata) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.keydata_; - } - if (keydata) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keydata); - if (message_arena != submessage_arena) { - keydata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, keydata, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.keydata_ = keydata; - // @@protoc_insertion_point(field_set_allocated:proto.Message.AppStateSyncKey.keyData) -} - -// ------------------------------------------------------------------- - -// Message_AudioMessage - -// optional string url = 1; -inline bool Message_AudioMessage::_internal_has_url() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_AudioMessage::has_url() const { - return _internal_has_url(); -} -inline void Message_AudioMessage::clear_url() { - _impl_.url_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_AudioMessage::url() const { - // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.url) - return _internal_url(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_AudioMessage::set_url(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.url_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.url) -} -inline std::string* Message_AudioMessage::mutable_url() { - std::string* _s = _internal_mutable_url(); - // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.url) - return _s; -} -inline const std::string& Message_AudioMessage::_internal_url() const { - return _impl_.url_.Get(); -} -inline void Message_AudioMessage::_internal_set_url(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.url_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_AudioMessage::_internal_mutable_url() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.url_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_AudioMessage::release_url() { - // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.url) - if (!_internal_has_url()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.url_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.url_.IsDefault()) { - _impl_.url_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_AudioMessage::set_allocated_url(std::string* url) { - if (url != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.url_.SetAllocated(url, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.url_.IsDefault()) { - _impl_.url_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.url) -} - -// optional string mimetype = 2; -inline bool Message_AudioMessage::_internal_has_mimetype() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_AudioMessage::has_mimetype() const { - return _internal_has_mimetype(); -} -inline void Message_AudioMessage::clear_mimetype() { - _impl_.mimetype_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_AudioMessage::mimetype() const { - // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.mimetype) - return _internal_mimetype(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_AudioMessage::set_mimetype(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.mimetype_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.mimetype) -} -inline std::string* Message_AudioMessage::mutable_mimetype() { - std::string* _s = _internal_mutable_mimetype(); - // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.mimetype) - return _s; -} -inline const std::string& Message_AudioMessage::_internal_mimetype() const { - return _impl_.mimetype_.Get(); -} -inline void Message_AudioMessage::_internal_set_mimetype(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.mimetype_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_AudioMessage::_internal_mutable_mimetype() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.mimetype_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_AudioMessage::release_mimetype() { - // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.mimetype) - if (!_internal_has_mimetype()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.mimetype_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mimetype_.IsDefault()) { - _impl_.mimetype_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_AudioMessage::set_allocated_mimetype(std::string* mimetype) { - if (mimetype != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mimetype_.IsDefault()) { - _impl_.mimetype_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.mimetype) -} - -// optional bytes fileSha256 = 3; -inline bool Message_AudioMessage::_internal_has_filesha256() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool Message_AudioMessage::has_filesha256() const { - return _internal_has_filesha256(); -} -inline void Message_AudioMessage::clear_filesha256() { - _impl_.filesha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& Message_AudioMessage::filesha256() const { - // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.fileSha256) - return _internal_filesha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_AudioMessage::set_filesha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.filesha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.fileSha256) -} -inline std::string* Message_AudioMessage::mutable_filesha256() { - std::string* _s = _internal_mutable_filesha256(); - // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.fileSha256) - return _s; -} -inline const std::string& Message_AudioMessage::_internal_filesha256() const { - return _impl_.filesha256_.Get(); -} -inline void Message_AudioMessage::_internal_set_filesha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.filesha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_AudioMessage::_internal_mutable_filesha256() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.filesha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_AudioMessage::release_filesha256() { - // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.fileSha256) - if (!_internal_has_filesha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.filesha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.filesha256_.IsDefault()) { - _impl_.filesha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_AudioMessage::set_allocated_filesha256(std::string* filesha256) { - if (filesha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.filesha256_.IsDefault()) { - _impl_.filesha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.fileSha256) -} - -// optional uint64 fileLength = 4; -inline bool Message_AudioMessage::_internal_has_filelength() const { - bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; - return value; -} -inline bool Message_AudioMessage::has_filelength() const { - return _internal_has_filelength(); -} -inline void Message_AudioMessage::clear_filelength() { - _impl_.filelength_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000200u; -} -inline uint64_t Message_AudioMessage::_internal_filelength() const { - return _impl_.filelength_; -} -inline uint64_t Message_AudioMessage::filelength() const { - // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.fileLength) - return _internal_filelength(); -} -inline void Message_AudioMessage::_internal_set_filelength(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.filelength_ = value; -} -inline void Message_AudioMessage::set_filelength(uint64_t value) { - _internal_set_filelength(value); - // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.fileLength) -} - -// optional uint32 seconds = 5; -inline bool Message_AudioMessage::_internal_has_seconds() const { - bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; - return value; -} -inline bool Message_AudioMessage::has_seconds() const { - return _internal_has_seconds(); -} -inline void Message_AudioMessage::clear_seconds() { - _impl_.seconds_ = 0u; - _impl_._has_bits_[0] &= ~0x00000400u; -} -inline uint32_t Message_AudioMessage::_internal_seconds() const { - return _impl_.seconds_; -} -inline uint32_t Message_AudioMessage::seconds() const { - // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.seconds) - return _internal_seconds(); -} -inline void Message_AudioMessage::_internal_set_seconds(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000400u; - _impl_.seconds_ = value; -} -inline void Message_AudioMessage::set_seconds(uint32_t value) { - _internal_set_seconds(value); - // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.seconds) -} - -// optional bool ptt = 6; -inline bool Message_AudioMessage::_internal_has_ptt() const { - bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; - return value; -} -inline bool Message_AudioMessage::has_ptt() const { - return _internal_has_ptt(); -} -inline void Message_AudioMessage::clear_ptt() { - _impl_.ptt_ = false; - _impl_._has_bits_[0] &= ~0x00000800u; -} -inline bool Message_AudioMessage::_internal_ptt() const { - return _impl_.ptt_; -} -inline bool Message_AudioMessage::ptt() const { - // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.ptt) - return _internal_ptt(); -} -inline void Message_AudioMessage::_internal_set_ptt(bool value) { - _impl_._has_bits_[0] |= 0x00000800u; - _impl_.ptt_ = value; -} -inline void Message_AudioMessage::set_ptt(bool value) { - _internal_set_ptt(value); - // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.ptt) -} - -// optional bytes mediaKey = 7; -inline bool Message_AudioMessage::_internal_has_mediakey() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool Message_AudioMessage::has_mediakey() const { - return _internal_has_mediakey(); -} -inline void Message_AudioMessage::clear_mediakey() { - _impl_.mediakey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const std::string& Message_AudioMessage::mediakey() const { - // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.mediaKey) - return _internal_mediakey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_AudioMessage::set_mediakey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.mediakey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.mediaKey) -} -inline std::string* Message_AudioMessage::mutable_mediakey() { - std::string* _s = _internal_mutable_mediakey(); - // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.mediaKey) - return _s; -} -inline const std::string& Message_AudioMessage::_internal_mediakey() const { - return _impl_.mediakey_.Get(); -} -inline void Message_AudioMessage::_internal_set_mediakey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.mediakey_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_AudioMessage::_internal_mutable_mediakey() { - _impl_._has_bits_[0] |= 0x00000008u; - return _impl_.mediakey_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_AudioMessage::release_mediakey() { - // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.mediaKey) - if (!_internal_has_mediakey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000008u; - auto* p = _impl_.mediakey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mediakey_.IsDefault()) { - _impl_.mediakey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_AudioMessage::set_allocated_mediakey(std::string* mediakey) { - if (mediakey != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mediakey_.IsDefault()) { - _impl_.mediakey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.mediaKey) -} - -// optional bytes fileEncSha256 = 8; -inline bool Message_AudioMessage::_internal_has_fileencsha256() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool Message_AudioMessage::has_fileencsha256() const { - return _internal_has_fileencsha256(); -} -inline void Message_AudioMessage::clear_fileencsha256() { - _impl_.fileencsha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const std::string& Message_AudioMessage::fileencsha256() const { - // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.fileEncSha256) - return _internal_fileencsha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_AudioMessage::set_fileencsha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.fileencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.fileEncSha256) -} -inline std::string* Message_AudioMessage::mutable_fileencsha256() { - std::string* _s = _internal_mutable_fileencsha256(); - // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.fileEncSha256) - return _s; -} -inline const std::string& Message_AudioMessage::_internal_fileencsha256() const { - return _impl_.fileencsha256_.Get(); -} -inline void Message_AudioMessage::_internal_set_fileencsha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.fileencsha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_AudioMessage::_internal_mutable_fileencsha256() { - _impl_._has_bits_[0] |= 0x00000010u; - return _impl_.fileencsha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_AudioMessage::release_fileencsha256() { - // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.fileEncSha256) - if (!_internal_has_fileencsha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000010u; - auto* p = _impl_.fileencsha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fileencsha256_.IsDefault()) { - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_AudioMessage::set_allocated_fileencsha256(std::string* fileencsha256) { - if (fileencsha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fileencsha256_.IsDefault()) { - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.fileEncSha256) -} - -// optional string directPath = 9; -inline bool Message_AudioMessage::_internal_has_directpath() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool Message_AudioMessage::has_directpath() const { - return _internal_has_directpath(); -} -inline void Message_AudioMessage::clear_directpath() { - _impl_.directpath_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline const std::string& Message_AudioMessage::directpath() const { - // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.directPath) - return _internal_directpath(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_AudioMessage::set_directpath(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.directpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.directPath) -} -inline std::string* Message_AudioMessage::mutable_directpath() { - std::string* _s = _internal_mutable_directpath(); - // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.directPath) - return _s; -} -inline const std::string& Message_AudioMessage::_internal_directpath() const { - return _impl_.directpath_.Get(); -} -inline void Message_AudioMessage::_internal_set_directpath(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.directpath_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_AudioMessage::_internal_mutable_directpath() { - _impl_._has_bits_[0] |= 0x00000020u; - return _impl_.directpath_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_AudioMessage::release_directpath() { - // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.directPath) - if (!_internal_has_directpath()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000020u; - auto* p = _impl_.directpath_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.directpath_.IsDefault()) { - _impl_.directpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_AudioMessage::set_allocated_directpath(std::string* directpath) { - if (directpath != nullptr) { - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.directpath_.IsDefault()) { - _impl_.directpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.directPath) -} - -// optional int64 mediaKeyTimestamp = 10; -inline bool Message_AudioMessage::_internal_has_mediakeytimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; - return value; -} -inline bool Message_AudioMessage::has_mediakeytimestamp() const { - return _internal_has_mediakeytimestamp(); -} -inline void Message_AudioMessage::clear_mediakeytimestamp() { - _impl_.mediakeytimestamp_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00001000u; -} -inline int64_t Message_AudioMessage::_internal_mediakeytimestamp() const { - return _impl_.mediakeytimestamp_; -} -inline int64_t Message_AudioMessage::mediakeytimestamp() const { - // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.mediaKeyTimestamp) - return _internal_mediakeytimestamp(); -} -inline void Message_AudioMessage::_internal_set_mediakeytimestamp(int64_t value) { - _impl_._has_bits_[0] |= 0x00001000u; - _impl_.mediakeytimestamp_ = value; -} -inline void Message_AudioMessage::set_mediakeytimestamp(int64_t value) { - _internal_set_mediakeytimestamp(value); - // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.mediaKeyTimestamp) -} - -// optional .proto.ContextInfo contextInfo = 17; -inline bool Message_AudioMessage::_internal_has_contextinfo() const { - bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; - PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); - return value; -} -inline bool Message_AudioMessage::has_contextinfo() const { - return _internal_has_contextinfo(); -} -inline void Message_AudioMessage::clear_contextinfo() { - if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); - _impl_._has_bits_[0] &= ~0x00000100u; -} -inline const ::proto::ContextInfo& Message_AudioMessage::_internal_contextinfo() const { - const ::proto::ContextInfo* p = _impl_.contextinfo_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ContextInfo_default_instance_); -} -inline const ::proto::ContextInfo& Message_AudioMessage::contextinfo() const { - // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.contextInfo) - return _internal_contextinfo(); -} -inline void Message_AudioMessage::unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); - } - _impl_.contextinfo_ = contextinfo; - if (contextinfo) { - _impl_._has_bits_[0] |= 0x00000100u; - } else { - _impl_._has_bits_[0] &= ~0x00000100u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.AudioMessage.contextInfo) -} -inline ::proto::ContextInfo* Message_AudioMessage::release_contextinfo() { - _impl_._has_bits_[0] &= ~0x00000100u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ContextInfo* Message_AudioMessage::unsafe_arena_release_contextinfo() { - // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.contextInfo) - _impl_._has_bits_[0] &= ~0x00000100u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; - return temp; -} -inline ::proto::ContextInfo* Message_AudioMessage::_internal_mutable_contextinfo() { - _impl_._has_bits_[0] |= 0x00000100u; - if (_impl_.contextinfo_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); - _impl_.contextinfo_ = p; - } - return _impl_.contextinfo_; -} -inline ::proto::ContextInfo* Message_AudioMessage::mutable_contextinfo() { - ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); - // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.contextInfo) - return _msg; -} -inline void Message_AudioMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.contextinfo_; - } - if (contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); - if (message_arena != submessage_arena) { - contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, contextinfo, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000100u; - } else { - _impl_._has_bits_[0] &= ~0x00000100u; - } - _impl_.contextinfo_ = contextinfo; - // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.contextInfo) -} - -// optional bytes streamingSidecar = 18; -inline bool Message_AudioMessage::_internal_has_streamingsidecar() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool Message_AudioMessage::has_streamingsidecar() const { - return _internal_has_streamingsidecar(); -} -inline void Message_AudioMessage::clear_streamingsidecar() { - _impl_.streamingsidecar_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline const std::string& Message_AudioMessage::streamingsidecar() const { - // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.streamingSidecar) - return _internal_streamingsidecar(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_AudioMessage::set_streamingsidecar(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.streamingsidecar_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.streamingSidecar) -} -inline std::string* Message_AudioMessage::mutable_streamingsidecar() { - std::string* _s = _internal_mutable_streamingsidecar(); - // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.streamingSidecar) - return _s; -} -inline const std::string& Message_AudioMessage::_internal_streamingsidecar() const { - return _impl_.streamingsidecar_.Get(); -} -inline void Message_AudioMessage::_internal_set_streamingsidecar(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.streamingsidecar_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_AudioMessage::_internal_mutable_streamingsidecar() { - _impl_._has_bits_[0] |= 0x00000040u; - return _impl_.streamingsidecar_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_AudioMessage::release_streamingsidecar() { - // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.streamingSidecar) - if (!_internal_has_streamingsidecar()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000040u; - auto* p = _impl_.streamingsidecar_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.streamingsidecar_.IsDefault()) { - _impl_.streamingsidecar_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_AudioMessage::set_allocated_streamingsidecar(std::string* streamingsidecar) { - if (streamingsidecar != nullptr) { - _impl_._has_bits_[0] |= 0x00000040u; - } else { - _impl_._has_bits_[0] &= ~0x00000040u; - } - _impl_.streamingsidecar_.SetAllocated(streamingsidecar, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.streamingsidecar_.IsDefault()) { - _impl_.streamingsidecar_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.streamingSidecar) -} - -// optional bytes waveform = 19; -inline bool Message_AudioMessage::_internal_has_waveform() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - return value; -} -inline bool Message_AudioMessage::has_waveform() const { - return _internal_has_waveform(); -} -inline void Message_AudioMessage::clear_waveform() { - _impl_.waveform_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline const std::string& Message_AudioMessage::waveform() const { - // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.waveform) - return _internal_waveform(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_AudioMessage::set_waveform(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.waveform_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.waveform) -} -inline std::string* Message_AudioMessage::mutable_waveform() { - std::string* _s = _internal_mutable_waveform(); - // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.waveform) - return _s; -} -inline const std::string& Message_AudioMessage::_internal_waveform() const { - return _impl_.waveform_.Get(); -} -inline void Message_AudioMessage::_internal_set_waveform(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.waveform_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_AudioMessage::_internal_mutable_waveform() { - _impl_._has_bits_[0] |= 0x00000080u; - return _impl_.waveform_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_AudioMessage::release_waveform() { - // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.waveform) - if (!_internal_has_waveform()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000080u; - auto* p = _impl_.waveform_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.waveform_.IsDefault()) { - _impl_.waveform_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_AudioMessage::set_allocated_waveform(std::string* waveform) { - if (waveform != nullptr) { - _impl_._has_bits_[0] |= 0x00000080u; - } else { - _impl_._has_bits_[0] &= ~0x00000080u; - } - _impl_.waveform_.SetAllocated(waveform, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.waveform_.IsDefault()) { - _impl_.waveform_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.waveform) -} - -// ------------------------------------------------------------------- - -// Message_ButtonsMessage_Button_ButtonText - -// optional string displayText = 1; -inline bool Message_ButtonsMessage_Button_ButtonText::_internal_has_displaytext() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_ButtonsMessage_Button_ButtonText::has_displaytext() const { - return _internal_has_displaytext(); -} -inline void Message_ButtonsMessage_Button_ButtonText::clear_displaytext() { - _impl_.displaytext_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_ButtonsMessage_Button_ButtonText::displaytext() const { - // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.Button.ButtonText.displayText) - return _internal_displaytext(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ButtonsMessage_Button_ButtonText::set_displaytext(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.displaytext_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.Button.ButtonText.displayText) -} -inline std::string* Message_ButtonsMessage_Button_ButtonText::mutable_displaytext() { - std::string* _s = _internal_mutable_displaytext(); - // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.Button.ButtonText.displayText) - return _s; -} -inline const std::string& Message_ButtonsMessage_Button_ButtonText::_internal_displaytext() const { - return _impl_.displaytext_.Get(); -} -inline void Message_ButtonsMessage_Button_ButtonText::_internal_set_displaytext(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.displaytext_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ButtonsMessage_Button_ButtonText::_internal_mutable_displaytext() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.displaytext_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ButtonsMessage_Button_ButtonText::release_displaytext() { - // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.Button.ButtonText.displayText) - if (!_internal_has_displaytext()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.displaytext_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.displaytext_.IsDefault()) { - _impl_.displaytext_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ButtonsMessage_Button_ButtonText::set_allocated_displaytext(std::string* displaytext) { - if (displaytext != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.displaytext_.SetAllocated(displaytext, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.displaytext_.IsDefault()) { - _impl_.displaytext_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.Button.ButtonText.displayText) -} - -// ------------------------------------------------------------------- - -// Message_ButtonsMessage_Button_NativeFlowInfo - -// optional string name = 1; -inline bool Message_ButtonsMessage_Button_NativeFlowInfo::_internal_has_name() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_ButtonsMessage_Button_NativeFlowInfo::has_name() const { - return _internal_has_name(); -} -inline void Message_ButtonsMessage_Button_NativeFlowInfo::clear_name() { - _impl_.name_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_ButtonsMessage_Button_NativeFlowInfo::name() const { - // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.Button.NativeFlowInfo.name) - return _internal_name(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ButtonsMessage_Button_NativeFlowInfo::set_name(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.Button.NativeFlowInfo.name) -} -inline std::string* Message_ButtonsMessage_Button_NativeFlowInfo::mutable_name() { - std::string* _s = _internal_mutable_name(); - // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.Button.NativeFlowInfo.name) - return _s; -} -inline const std::string& Message_ButtonsMessage_Button_NativeFlowInfo::_internal_name() const { - return _impl_.name_.Get(); -} -inline void Message_ButtonsMessage_Button_NativeFlowInfo::_internal_set_name(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.name_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ButtonsMessage_Button_NativeFlowInfo::_internal_mutable_name() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.name_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ButtonsMessage_Button_NativeFlowInfo::release_name() { - // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.Button.NativeFlowInfo.name) - if (!_internal_has_name()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.name_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.name_.IsDefault()) { - _impl_.name_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ButtonsMessage_Button_NativeFlowInfo::set_allocated_name(std::string* name) { - if (name != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.name_.SetAllocated(name, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.name_.IsDefault()) { - _impl_.name_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.Button.NativeFlowInfo.name) -} - -// optional string paramsJson = 2; -inline bool Message_ButtonsMessage_Button_NativeFlowInfo::_internal_has_paramsjson() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_ButtonsMessage_Button_NativeFlowInfo::has_paramsjson() const { - return _internal_has_paramsjson(); -} -inline void Message_ButtonsMessage_Button_NativeFlowInfo::clear_paramsjson() { - _impl_.paramsjson_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_ButtonsMessage_Button_NativeFlowInfo::paramsjson() const { - // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.Button.NativeFlowInfo.paramsJson) - return _internal_paramsjson(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ButtonsMessage_Button_NativeFlowInfo::set_paramsjson(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.paramsjson_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.Button.NativeFlowInfo.paramsJson) -} -inline std::string* Message_ButtonsMessage_Button_NativeFlowInfo::mutable_paramsjson() { - std::string* _s = _internal_mutable_paramsjson(); - // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.Button.NativeFlowInfo.paramsJson) - return _s; -} -inline const std::string& Message_ButtonsMessage_Button_NativeFlowInfo::_internal_paramsjson() const { - return _impl_.paramsjson_.Get(); -} -inline void Message_ButtonsMessage_Button_NativeFlowInfo::_internal_set_paramsjson(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.paramsjson_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ButtonsMessage_Button_NativeFlowInfo::_internal_mutable_paramsjson() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.paramsjson_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ButtonsMessage_Button_NativeFlowInfo::release_paramsjson() { - // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.Button.NativeFlowInfo.paramsJson) - if (!_internal_has_paramsjson()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.paramsjson_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.paramsjson_.IsDefault()) { - _impl_.paramsjson_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ButtonsMessage_Button_NativeFlowInfo::set_allocated_paramsjson(std::string* paramsjson) { - if (paramsjson != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.paramsjson_.SetAllocated(paramsjson, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.paramsjson_.IsDefault()) { - _impl_.paramsjson_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.Button.NativeFlowInfo.paramsJson) -} - -// ------------------------------------------------------------------- - -// Message_ButtonsMessage_Button - -// optional string buttonId = 1; -inline bool Message_ButtonsMessage_Button::_internal_has_buttonid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_ButtonsMessage_Button::has_buttonid() const { - return _internal_has_buttonid(); -} -inline void Message_ButtonsMessage_Button::clear_buttonid() { - _impl_.buttonid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_ButtonsMessage_Button::buttonid() const { - // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.Button.buttonId) - return _internal_buttonid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ButtonsMessage_Button::set_buttonid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.buttonid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.Button.buttonId) -} -inline std::string* Message_ButtonsMessage_Button::mutable_buttonid() { - std::string* _s = _internal_mutable_buttonid(); - // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.Button.buttonId) - return _s; -} -inline const std::string& Message_ButtonsMessage_Button::_internal_buttonid() const { - return _impl_.buttonid_.Get(); -} -inline void Message_ButtonsMessage_Button::_internal_set_buttonid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.buttonid_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ButtonsMessage_Button::_internal_mutable_buttonid() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.buttonid_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ButtonsMessage_Button::release_buttonid() { - // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.Button.buttonId) - if (!_internal_has_buttonid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.buttonid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.buttonid_.IsDefault()) { - _impl_.buttonid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ButtonsMessage_Button::set_allocated_buttonid(std::string* buttonid) { - if (buttonid != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.buttonid_.SetAllocated(buttonid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.buttonid_.IsDefault()) { - _impl_.buttonid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.Button.buttonId) -} - -// optional .proto.Message.ButtonsMessage.Button.ButtonText buttonText = 2; -inline bool Message_ButtonsMessage_Button::_internal_has_buttontext() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.buttontext_ != nullptr); - return value; -} -inline bool Message_ButtonsMessage_Button::has_buttontext() const { - return _internal_has_buttontext(); -} -inline void Message_ButtonsMessage_Button::clear_buttontext() { - if (_impl_.buttontext_ != nullptr) _impl_.buttontext_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::Message_ButtonsMessage_Button_ButtonText& Message_ButtonsMessage_Button::_internal_buttontext() const { - const ::proto::Message_ButtonsMessage_Button_ButtonText* p = _impl_.buttontext_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_ButtonsMessage_Button_ButtonText_default_instance_); -} -inline const ::proto::Message_ButtonsMessage_Button_ButtonText& Message_ButtonsMessage_Button::buttontext() const { - // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.Button.buttonText) - return _internal_buttontext(); -} -inline void Message_ButtonsMessage_Button::unsafe_arena_set_allocated_buttontext( - ::proto::Message_ButtonsMessage_Button_ButtonText* buttontext) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.buttontext_); - } - _impl_.buttontext_ = buttontext; - if (buttontext) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsMessage.Button.buttonText) -} -inline ::proto::Message_ButtonsMessage_Button_ButtonText* Message_ButtonsMessage_Button::release_buttontext() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::Message_ButtonsMessage_Button_ButtonText* temp = _impl_.buttontext_; - _impl_.buttontext_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_ButtonsMessage_Button_ButtonText* Message_ButtonsMessage_Button::unsafe_arena_release_buttontext() { - // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.Button.buttonText) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::Message_ButtonsMessage_Button_ButtonText* temp = _impl_.buttontext_; - _impl_.buttontext_ = nullptr; - return temp; -} -inline ::proto::Message_ButtonsMessage_Button_ButtonText* Message_ButtonsMessage_Button::_internal_mutable_buttontext() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.buttontext_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_ButtonsMessage_Button_ButtonText>(GetArenaForAllocation()); - _impl_.buttontext_ = p; - } - return _impl_.buttontext_; -} -inline ::proto::Message_ButtonsMessage_Button_ButtonText* Message_ButtonsMessage_Button::mutable_buttontext() { - ::proto::Message_ButtonsMessage_Button_ButtonText* _msg = _internal_mutable_buttontext(); - // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.Button.buttonText) - return _msg; -} -inline void Message_ButtonsMessage_Button::set_allocated_buttontext(::proto::Message_ButtonsMessage_Button_ButtonText* buttontext) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.buttontext_; - } - if (buttontext) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(buttontext); - if (message_arena != submessage_arena) { - buttontext = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, buttontext, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.buttontext_ = buttontext; - // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.Button.buttonText) -} - -// optional .proto.Message.ButtonsMessage.Button.Type type = 3; -inline bool Message_ButtonsMessage_Button::_internal_has_type() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool Message_ButtonsMessage_Button::has_type() const { - return _internal_has_type(); -} -inline void Message_ButtonsMessage_Button::clear_type() { - _impl_.type_ = 0; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline ::proto::Message_ButtonsMessage_Button_Type Message_ButtonsMessage_Button::_internal_type() const { - return static_cast< ::proto::Message_ButtonsMessage_Button_Type >(_impl_.type_); -} -inline ::proto::Message_ButtonsMessage_Button_Type Message_ButtonsMessage_Button::type() const { - // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.Button.type) - return _internal_type(); -} -inline void Message_ButtonsMessage_Button::_internal_set_type(::proto::Message_ButtonsMessage_Button_Type value) { - assert(::proto::Message_ButtonsMessage_Button_Type_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.type_ = value; -} -inline void Message_ButtonsMessage_Button::set_type(::proto::Message_ButtonsMessage_Button_Type value) { - _internal_set_type(value); - // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.Button.type) -} - -// optional .proto.Message.ButtonsMessage.Button.NativeFlowInfo nativeFlowInfo = 4; -inline bool Message_ButtonsMessage_Button::_internal_has_nativeflowinfo() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - PROTOBUF_ASSUME(!value || _impl_.nativeflowinfo_ != nullptr); - return value; -} -inline bool Message_ButtonsMessage_Button::has_nativeflowinfo() const { - return _internal_has_nativeflowinfo(); -} -inline void Message_ButtonsMessage_Button::clear_nativeflowinfo() { - if (_impl_.nativeflowinfo_ != nullptr) _impl_.nativeflowinfo_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const ::proto::Message_ButtonsMessage_Button_NativeFlowInfo& Message_ButtonsMessage_Button::_internal_nativeflowinfo() const { - const ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* p = _impl_.nativeflowinfo_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_ButtonsMessage_Button_NativeFlowInfo_default_instance_); -} -inline const ::proto::Message_ButtonsMessage_Button_NativeFlowInfo& Message_ButtonsMessage_Button::nativeflowinfo() const { - // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.Button.nativeFlowInfo) - return _internal_nativeflowinfo(); -} -inline void Message_ButtonsMessage_Button::unsafe_arena_set_allocated_nativeflowinfo( - ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* nativeflowinfo) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.nativeflowinfo_); - } - _impl_.nativeflowinfo_ = nativeflowinfo; - if (nativeflowinfo) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsMessage.Button.nativeFlowInfo) -} -inline ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* Message_ButtonsMessage_Button::release_nativeflowinfo() { - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* temp = _impl_.nativeflowinfo_; - _impl_.nativeflowinfo_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* Message_ButtonsMessage_Button::unsafe_arena_release_nativeflowinfo() { - // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.Button.nativeFlowInfo) - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* temp = _impl_.nativeflowinfo_; - _impl_.nativeflowinfo_ = nullptr; - return temp; -} -inline ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* Message_ButtonsMessage_Button::_internal_mutable_nativeflowinfo() { - _impl_._has_bits_[0] |= 0x00000004u; - if (_impl_.nativeflowinfo_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_ButtonsMessage_Button_NativeFlowInfo>(GetArenaForAllocation()); - _impl_.nativeflowinfo_ = p; - } - return _impl_.nativeflowinfo_; -} -inline ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* Message_ButtonsMessage_Button::mutable_nativeflowinfo() { - ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* _msg = _internal_mutable_nativeflowinfo(); - // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.Button.nativeFlowInfo) - return _msg; -} -inline void Message_ButtonsMessage_Button::set_allocated_nativeflowinfo(::proto::Message_ButtonsMessage_Button_NativeFlowInfo* nativeflowinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.nativeflowinfo_; - } - if (nativeflowinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(nativeflowinfo); - if (message_arena != submessage_arena) { - nativeflowinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, nativeflowinfo, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.nativeflowinfo_ = nativeflowinfo; - // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.Button.nativeFlowInfo) -} - -// ------------------------------------------------------------------- - -// Message_ButtonsMessage - -// optional string contentText = 6; -inline bool Message_ButtonsMessage::_internal_has_contenttext() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_ButtonsMessage::has_contenttext() const { - return _internal_has_contenttext(); -} -inline void Message_ButtonsMessage::clear_contenttext() { - _impl_.contenttext_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_ButtonsMessage::contenttext() const { - // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.contentText) - return _internal_contenttext(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ButtonsMessage::set_contenttext(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.contenttext_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.contentText) -} -inline std::string* Message_ButtonsMessage::mutable_contenttext() { - std::string* _s = _internal_mutable_contenttext(); - // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.contentText) - return _s; -} -inline const std::string& Message_ButtonsMessage::_internal_contenttext() const { - return _impl_.contenttext_.Get(); -} -inline void Message_ButtonsMessage::_internal_set_contenttext(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.contenttext_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ButtonsMessage::_internal_mutable_contenttext() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.contenttext_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ButtonsMessage::release_contenttext() { - // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.contentText) - if (!_internal_has_contenttext()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.contenttext_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.contenttext_.IsDefault()) { - _impl_.contenttext_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ButtonsMessage::set_allocated_contenttext(std::string* contenttext) { - if (contenttext != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.contenttext_.SetAllocated(contenttext, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.contenttext_.IsDefault()) { - _impl_.contenttext_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.contentText) -} - -// optional string footerText = 7; -inline bool Message_ButtonsMessage::_internal_has_footertext() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_ButtonsMessage::has_footertext() const { - return _internal_has_footertext(); -} -inline void Message_ButtonsMessage::clear_footertext() { - _impl_.footertext_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_ButtonsMessage::footertext() const { - // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.footerText) - return _internal_footertext(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ButtonsMessage::set_footertext(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.footertext_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.footerText) -} -inline std::string* Message_ButtonsMessage::mutable_footertext() { - std::string* _s = _internal_mutable_footertext(); - // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.footerText) - return _s; -} -inline const std::string& Message_ButtonsMessage::_internal_footertext() const { - return _impl_.footertext_.Get(); -} -inline void Message_ButtonsMessage::_internal_set_footertext(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.footertext_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ButtonsMessage::_internal_mutable_footertext() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.footertext_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ButtonsMessage::release_footertext() { - // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.footerText) - if (!_internal_has_footertext()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.footertext_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.footertext_.IsDefault()) { - _impl_.footertext_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ButtonsMessage::set_allocated_footertext(std::string* footertext) { - if (footertext != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.footertext_.SetAllocated(footertext, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.footertext_.IsDefault()) { - _impl_.footertext_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.footerText) -} - -// optional .proto.ContextInfo contextInfo = 8; -inline bool Message_ButtonsMessage::_internal_has_contextinfo() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); - return value; -} -inline bool Message_ButtonsMessage::has_contextinfo() const { - return _internal_has_contextinfo(); -} -inline void Message_ButtonsMessage::clear_contextinfo() { - if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const ::proto::ContextInfo& Message_ButtonsMessage::_internal_contextinfo() const { - const ::proto::ContextInfo* p = _impl_.contextinfo_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ContextInfo_default_instance_); -} -inline const ::proto::ContextInfo& Message_ButtonsMessage::contextinfo() const { - // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.contextInfo) - return _internal_contextinfo(); -} -inline void Message_ButtonsMessage::unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); - } - _impl_.contextinfo_ = contextinfo; - if (contextinfo) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsMessage.contextInfo) -} -inline ::proto::ContextInfo* Message_ButtonsMessage::release_contextinfo() { - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ContextInfo* Message_ButtonsMessage::unsafe_arena_release_contextinfo() { - // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.contextInfo) - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; - return temp; -} -inline ::proto::ContextInfo* Message_ButtonsMessage::_internal_mutable_contextinfo() { - _impl_._has_bits_[0] |= 0x00000004u; - if (_impl_.contextinfo_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); - _impl_.contextinfo_ = p; - } - return _impl_.contextinfo_; -} -inline ::proto::ContextInfo* Message_ButtonsMessage::mutable_contextinfo() { - ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); - // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.contextInfo) - return _msg; -} -inline void Message_ButtonsMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.contextinfo_; - } - if (contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); - if (message_arena != submessage_arena) { - contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, contextinfo, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.contextinfo_ = contextinfo; - // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.contextInfo) -} - -// repeated .proto.Message.ButtonsMessage.Button buttons = 9; -inline int Message_ButtonsMessage::_internal_buttons_size() const { - return _impl_.buttons_.size(); -} -inline int Message_ButtonsMessage::buttons_size() const { - return _internal_buttons_size(); -} -inline void Message_ButtonsMessage::clear_buttons() { - _impl_.buttons_.Clear(); -} -inline ::proto::Message_ButtonsMessage_Button* Message_ButtonsMessage::mutable_buttons(int index) { - // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.buttons) - return _impl_.buttons_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ButtonsMessage_Button >* -Message_ButtonsMessage::mutable_buttons() { - // @@protoc_insertion_point(field_mutable_list:proto.Message.ButtonsMessage.buttons) - return &_impl_.buttons_; -} -inline const ::proto::Message_ButtonsMessage_Button& Message_ButtonsMessage::_internal_buttons(int index) const { - return _impl_.buttons_.Get(index); -} -inline const ::proto::Message_ButtonsMessage_Button& Message_ButtonsMessage::buttons(int index) const { - // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.buttons) - return _internal_buttons(index); -} -inline ::proto::Message_ButtonsMessage_Button* Message_ButtonsMessage::_internal_add_buttons() { - return _impl_.buttons_.Add(); -} -inline ::proto::Message_ButtonsMessage_Button* Message_ButtonsMessage::add_buttons() { - ::proto::Message_ButtonsMessage_Button* _add = _internal_add_buttons(); - // @@protoc_insertion_point(field_add:proto.Message.ButtonsMessage.buttons) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ButtonsMessage_Button >& -Message_ButtonsMessage::buttons() const { - // @@protoc_insertion_point(field_list:proto.Message.ButtonsMessage.buttons) - return _impl_.buttons_; -} - -// optional .proto.Message.ButtonsMessage.HeaderType headerType = 10; -inline bool Message_ButtonsMessage::_internal_has_headertype() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool Message_ButtonsMessage::has_headertype() const { - return _internal_has_headertype(); -} -inline void Message_ButtonsMessage::clear_headertype() { - _impl_.headertype_ = 0; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline ::proto::Message_ButtonsMessage_HeaderType Message_ButtonsMessage::_internal_headertype() const { - return static_cast< ::proto::Message_ButtonsMessage_HeaderType >(_impl_.headertype_); -} -inline ::proto::Message_ButtonsMessage_HeaderType Message_ButtonsMessage::headertype() const { - // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.headerType) - return _internal_headertype(); -} -inline void Message_ButtonsMessage::_internal_set_headertype(::proto::Message_ButtonsMessage_HeaderType value) { - assert(::proto::Message_ButtonsMessage_HeaderType_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.headertype_ = value; -} -inline void Message_ButtonsMessage::set_headertype(::proto::Message_ButtonsMessage_HeaderType value) { - _internal_set_headertype(value); - // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.headerType) -} - -// string text = 1; -inline bool Message_ButtonsMessage::_internal_has_text() const { - return header_case() == kText; -} -inline bool Message_ButtonsMessage::has_text() const { - return _internal_has_text(); -} -inline void Message_ButtonsMessage::set_has_text() { - _impl_._oneof_case_[0] = kText; -} -inline void Message_ButtonsMessage::clear_text() { - if (_internal_has_text()) { - _impl_.header_.text_.Destroy(); - clear_has_header(); - } -} -inline const std::string& Message_ButtonsMessage::text() const { - // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.text) - return _internal_text(); -} -template -inline void Message_ButtonsMessage::set_text(ArgT0&& arg0, ArgT... args) { - if (!_internal_has_text()) { - clear_header(); - set_has_text(); - _impl_.header_.text_.InitDefault(); - } - _impl_.header_.text_.Set( static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.text) -} -inline std::string* Message_ButtonsMessage::mutable_text() { - std::string* _s = _internal_mutable_text(); - // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.text) - return _s; -} -inline const std::string& Message_ButtonsMessage::_internal_text() const { - if (_internal_has_text()) { - return _impl_.header_.text_.Get(); - } - return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); -} -inline void Message_ButtonsMessage::_internal_set_text(const std::string& value) { - if (!_internal_has_text()) { - clear_header(); - set_has_text(); - _impl_.header_.text_.InitDefault(); - } - _impl_.header_.text_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ButtonsMessage::_internal_mutable_text() { - if (!_internal_has_text()) { - clear_header(); - set_has_text(); - _impl_.header_.text_.InitDefault(); - } - return _impl_.header_.text_.Mutable( GetArenaForAllocation()); -} -inline std::string* Message_ButtonsMessage::release_text() { - // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.text) - if (_internal_has_text()) { - clear_has_header(); - return _impl_.header_.text_.Release(); - } else { - return nullptr; - } -} -inline void Message_ButtonsMessage::set_allocated_text(std::string* text) { - if (has_header()) { - clear_header(); - } - if (text != nullptr) { - set_has_text(); - _impl_.header_.text_.InitAllocated(text, GetArenaForAllocation()); - } - // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.text) -} - -// .proto.Message.DocumentMessage documentMessage = 2; -inline bool Message_ButtonsMessage::_internal_has_documentmessage() const { - return header_case() == kDocumentMessage; -} -inline bool Message_ButtonsMessage::has_documentmessage() const { - return _internal_has_documentmessage(); -} -inline void Message_ButtonsMessage::set_has_documentmessage() { - _impl_._oneof_case_[0] = kDocumentMessage; -} -inline void Message_ButtonsMessage::clear_documentmessage() { - if (_internal_has_documentmessage()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.header_.documentmessage_; - } - clear_has_header(); - } -} -inline ::proto::Message_DocumentMessage* Message_ButtonsMessage::release_documentmessage() { - // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.documentMessage) - if (_internal_has_documentmessage()) { - clear_has_header(); - ::proto::Message_DocumentMessage* temp = _impl_.header_.documentmessage_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.header_.documentmessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::Message_DocumentMessage& Message_ButtonsMessage::_internal_documentmessage() const { - return _internal_has_documentmessage() - ? *_impl_.header_.documentmessage_ - : reinterpret_cast< ::proto::Message_DocumentMessage&>(::proto::_Message_DocumentMessage_default_instance_); -} -inline const ::proto::Message_DocumentMessage& Message_ButtonsMessage::documentmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.documentMessage) - return _internal_documentmessage(); -} -inline ::proto::Message_DocumentMessage* Message_ButtonsMessage::unsafe_arena_release_documentmessage() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.ButtonsMessage.documentMessage) - if (_internal_has_documentmessage()) { - clear_has_header(); - ::proto::Message_DocumentMessage* temp = _impl_.header_.documentmessage_; - _impl_.header_.documentmessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Message_ButtonsMessage::unsafe_arena_set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) { - clear_header(); - if (documentmessage) { - set_has_documentmessage(); - _impl_.header_.documentmessage_ = documentmessage; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsMessage.documentMessage) -} -inline ::proto::Message_DocumentMessage* Message_ButtonsMessage::_internal_mutable_documentmessage() { - if (!_internal_has_documentmessage()) { - clear_header(); - set_has_documentmessage(); - _impl_.header_.documentmessage_ = CreateMaybeMessage< ::proto::Message_DocumentMessage >(GetArenaForAllocation()); - } - return _impl_.header_.documentmessage_; -} -inline ::proto::Message_DocumentMessage* Message_ButtonsMessage::mutable_documentmessage() { - ::proto::Message_DocumentMessage* _msg = _internal_mutable_documentmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.documentMessage) - return _msg; -} - -// .proto.Message.ImageMessage imageMessage = 3; -inline bool Message_ButtonsMessage::_internal_has_imagemessage() const { - return header_case() == kImageMessage; -} -inline bool Message_ButtonsMessage::has_imagemessage() const { - return _internal_has_imagemessage(); -} -inline void Message_ButtonsMessage::set_has_imagemessage() { - _impl_._oneof_case_[0] = kImageMessage; -} -inline void Message_ButtonsMessage::clear_imagemessage() { - if (_internal_has_imagemessage()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.header_.imagemessage_; - } - clear_has_header(); - } -} -inline ::proto::Message_ImageMessage* Message_ButtonsMessage::release_imagemessage() { - // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.imageMessage) - if (_internal_has_imagemessage()) { - clear_has_header(); - ::proto::Message_ImageMessage* temp = _impl_.header_.imagemessage_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.header_.imagemessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::Message_ImageMessage& Message_ButtonsMessage::_internal_imagemessage() const { - return _internal_has_imagemessage() - ? *_impl_.header_.imagemessage_ - : reinterpret_cast< ::proto::Message_ImageMessage&>(::proto::_Message_ImageMessage_default_instance_); -} -inline const ::proto::Message_ImageMessage& Message_ButtonsMessage::imagemessage() const { - // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.imageMessage) - return _internal_imagemessage(); -} -inline ::proto::Message_ImageMessage* Message_ButtonsMessage::unsafe_arena_release_imagemessage() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.ButtonsMessage.imageMessage) - if (_internal_has_imagemessage()) { - clear_has_header(); - ::proto::Message_ImageMessage* temp = _impl_.header_.imagemessage_; - _impl_.header_.imagemessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Message_ButtonsMessage::unsafe_arena_set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) { - clear_header(); - if (imagemessage) { - set_has_imagemessage(); - _impl_.header_.imagemessage_ = imagemessage; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsMessage.imageMessage) -} -inline ::proto::Message_ImageMessage* Message_ButtonsMessage::_internal_mutable_imagemessage() { - if (!_internal_has_imagemessage()) { - clear_header(); - set_has_imagemessage(); - _impl_.header_.imagemessage_ = CreateMaybeMessage< ::proto::Message_ImageMessage >(GetArenaForAllocation()); - } - return _impl_.header_.imagemessage_; -} -inline ::proto::Message_ImageMessage* Message_ButtonsMessage::mutable_imagemessage() { - ::proto::Message_ImageMessage* _msg = _internal_mutable_imagemessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.imageMessage) - return _msg; -} - -// .proto.Message.VideoMessage videoMessage = 4; -inline bool Message_ButtonsMessage::_internal_has_videomessage() const { - return header_case() == kVideoMessage; -} -inline bool Message_ButtonsMessage::has_videomessage() const { - return _internal_has_videomessage(); -} -inline void Message_ButtonsMessage::set_has_videomessage() { - _impl_._oneof_case_[0] = kVideoMessage; -} -inline void Message_ButtonsMessage::clear_videomessage() { - if (_internal_has_videomessage()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.header_.videomessage_; - } - clear_has_header(); - } -} -inline ::proto::Message_VideoMessage* Message_ButtonsMessage::release_videomessage() { - // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.videoMessage) - if (_internal_has_videomessage()) { - clear_has_header(); - ::proto::Message_VideoMessage* temp = _impl_.header_.videomessage_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.header_.videomessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::Message_VideoMessage& Message_ButtonsMessage::_internal_videomessage() const { - return _internal_has_videomessage() - ? *_impl_.header_.videomessage_ - : reinterpret_cast< ::proto::Message_VideoMessage&>(::proto::_Message_VideoMessage_default_instance_); -} -inline const ::proto::Message_VideoMessage& Message_ButtonsMessage::videomessage() const { - // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.videoMessage) - return _internal_videomessage(); -} -inline ::proto::Message_VideoMessage* Message_ButtonsMessage::unsafe_arena_release_videomessage() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.ButtonsMessage.videoMessage) - if (_internal_has_videomessage()) { - clear_has_header(); - ::proto::Message_VideoMessage* temp = _impl_.header_.videomessage_; - _impl_.header_.videomessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Message_ButtonsMessage::unsafe_arena_set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) { - clear_header(); - if (videomessage) { - set_has_videomessage(); - _impl_.header_.videomessage_ = videomessage; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsMessage.videoMessage) -} -inline ::proto::Message_VideoMessage* Message_ButtonsMessage::_internal_mutable_videomessage() { - if (!_internal_has_videomessage()) { - clear_header(); - set_has_videomessage(); - _impl_.header_.videomessage_ = CreateMaybeMessage< ::proto::Message_VideoMessage >(GetArenaForAllocation()); - } - return _impl_.header_.videomessage_; -} -inline ::proto::Message_VideoMessage* Message_ButtonsMessage::mutable_videomessage() { - ::proto::Message_VideoMessage* _msg = _internal_mutable_videomessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.videoMessage) - return _msg; -} - -// .proto.Message.LocationMessage locationMessage = 5; -inline bool Message_ButtonsMessage::_internal_has_locationmessage() const { - return header_case() == kLocationMessage; -} -inline bool Message_ButtonsMessage::has_locationmessage() const { - return _internal_has_locationmessage(); -} -inline void Message_ButtonsMessage::set_has_locationmessage() { - _impl_._oneof_case_[0] = kLocationMessage; -} -inline void Message_ButtonsMessage::clear_locationmessage() { - if (_internal_has_locationmessage()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.header_.locationmessage_; - } - clear_has_header(); - } -} -inline ::proto::Message_LocationMessage* Message_ButtonsMessage::release_locationmessage() { - // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.locationMessage) - if (_internal_has_locationmessage()) { - clear_has_header(); - ::proto::Message_LocationMessage* temp = _impl_.header_.locationmessage_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.header_.locationmessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::Message_LocationMessage& Message_ButtonsMessage::_internal_locationmessage() const { - return _internal_has_locationmessage() - ? *_impl_.header_.locationmessage_ - : reinterpret_cast< ::proto::Message_LocationMessage&>(::proto::_Message_LocationMessage_default_instance_); -} -inline const ::proto::Message_LocationMessage& Message_ButtonsMessage::locationmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.locationMessage) - return _internal_locationmessage(); -} -inline ::proto::Message_LocationMessage* Message_ButtonsMessage::unsafe_arena_release_locationmessage() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.ButtonsMessage.locationMessage) - if (_internal_has_locationmessage()) { - clear_has_header(); - ::proto::Message_LocationMessage* temp = _impl_.header_.locationmessage_; - _impl_.header_.locationmessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Message_ButtonsMessage::unsafe_arena_set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage) { - clear_header(); - if (locationmessage) { - set_has_locationmessage(); - _impl_.header_.locationmessage_ = locationmessage; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsMessage.locationMessage) -} -inline ::proto::Message_LocationMessage* Message_ButtonsMessage::_internal_mutable_locationmessage() { - if (!_internal_has_locationmessage()) { - clear_header(); - set_has_locationmessage(); - _impl_.header_.locationmessage_ = CreateMaybeMessage< ::proto::Message_LocationMessage >(GetArenaForAllocation()); - } - return _impl_.header_.locationmessage_; -} -inline ::proto::Message_LocationMessage* Message_ButtonsMessage::mutable_locationmessage() { - ::proto::Message_LocationMessage* _msg = _internal_mutable_locationmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.locationMessage) - return _msg; -} - -inline bool Message_ButtonsMessage::has_header() const { - return header_case() != HEADER_NOT_SET; -} -inline void Message_ButtonsMessage::clear_has_header() { - _impl_._oneof_case_[0] = HEADER_NOT_SET; -} -inline Message_ButtonsMessage::HeaderCase Message_ButtonsMessage::header_case() const { - return Message_ButtonsMessage::HeaderCase(_impl_._oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// Message_ButtonsResponseMessage - -// optional string selectedButtonId = 1; -inline bool Message_ButtonsResponseMessage::_internal_has_selectedbuttonid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_ButtonsResponseMessage::has_selectedbuttonid() const { - return _internal_has_selectedbuttonid(); -} -inline void Message_ButtonsResponseMessage::clear_selectedbuttonid() { - _impl_.selectedbuttonid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_ButtonsResponseMessage::selectedbuttonid() const { - // @@protoc_insertion_point(field_get:proto.Message.ButtonsResponseMessage.selectedButtonId) - return _internal_selectedbuttonid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ButtonsResponseMessage::set_selectedbuttonid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.selectedbuttonid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ButtonsResponseMessage.selectedButtonId) -} -inline std::string* Message_ButtonsResponseMessage::mutable_selectedbuttonid() { - std::string* _s = _internal_mutable_selectedbuttonid(); - // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsResponseMessage.selectedButtonId) - return _s; -} -inline const std::string& Message_ButtonsResponseMessage::_internal_selectedbuttonid() const { - return _impl_.selectedbuttonid_.Get(); -} -inline void Message_ButtonsResponseMessage::_internal_set_selectedbuttonid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.selectedbuttonid_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ButtonsResponseMessage::_internal_mutable_selectedbuttonid() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.selectedbuttonid_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ButtonsResponseMessage::release_selectedbuttonid() { - // @@protoc_insertion_point(field_release:proto.Message.ButtonsResponseMessage.selectedButtonId) - if (!_internal_has_selectedbuttonid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.selectedbuttonid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.selectedbuttonid_.IsDefault()) { - _impl_.selectedbuttonid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ButtonsResponseMessage::set_allocated_selectedbuttonid(std::string* selectedbuttonid) { - if (selectedbuttonid != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.selectedbuttonid_.SetAllocated(selectedbuttonid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.selectedbuttonid_.IsDefault()) { - _impl_.selectedbuttonid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsResponseMessage.selectedButtonId) -} - -// optional .proto.ContextInfo contextInfo = 3; -inline bool Message_ButtonsResponseMessage::_internal_has_contextinfo() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); - return value; -} -inline bool Message_ButtonsResponseMessage::has_contextinfo() const { - return _internal_has_contextinfo(); -} -inline void Message_ButtonsResponseMessage::clear_contextinfo() { - if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::ContextInfo& Message_ButtonsResponseMessage::_internal_contextinfo() const { - const ::proto::ContextInfo* p = _impl_.contextinfo_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ContextInfo_default_instance_); -} -inline const ::proto::ContextInfo& Message_ButtonsResponseMessage::contextinfo() const { - // @@protoc_insertion_point(field_get:proto.Message.ButtonsResponseMessage.contextInfo) - return _internal_contextinfo(); -} -inline void Message_ButtonsResponseMessage::unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); - } - _impl_.contextinfo_ = contextinfo; - if (contextinfo) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsResponseMessage.contextInfo) -} -inline ::proto::ContextInfo* Message_ButtonsResponseMessage::release_contextinfo() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ContextInfo* Message_ButtonsResponseMessage::unsafe_arena_release_contextinfo() { - // @@protoc_insertion_point(field_release:proto.Message.ButtonsResponseMessage.contextInfo) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; - return temp; -} -inline ::proto::ContextInfo* Message_ButtonsResponseMessage::_internal_mutable_contextinfo() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.contextinfo_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); - _impl_.contextinfo_ = p; - } - return _impl_.contextinfo_; -} -inline ::proto::ContextInfo* Message_ButtonsResponseMessage::mutable_contextinfo() { - ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); - // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsResponseMessage.contextInfo) - return _msg; -} -inline void Message_ButtonsResponseMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.contextinfo_; - } - if (contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); - if (message_arena != submessage_arena) { - contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, contextinfo, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.contextinfo_ = contextinfo; - // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsResponseMessage.contextInfo) -} - -// optional .proto.Message.ButtonsResponseMessage.Type type = 4; -inline bool Message_ButtonsResponseMessage::_internal_has_type() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool Message_ButtonsResponseMessage::has_type() const { - return _internal_has_type(); -} -inline void Message_ButtonsResponseMessage::clear_type() { - _impl_.type_ = 0; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline ::proto::Message_ButtonsResponseMessage_Type Message_ButtonsResponseMessage::_internal_type() const { - return static_cast< ::proto::Message_ButtonsResponseMessage_Type >(_impl_.type_); -} -inline ::proto::Message_ButtonsResponseMessage_Type Message_ButtonsResponseMessage::type() const { - // @@protoc_insertion_point(field_get:proto.Message.ButtonsResponseMessage.type) - return _internal_type(); -} -inline void Message_ButtonsResponseMessage::_internal_set_type(::proto::Message_ButtonsResponseMessage_Type value) { - assert(::proto::Message_ButtonsResponseMessage_Type_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.type_ = value; -} -inline void Message_ButtonsResponseMessage::set_type(::proto::Message_ButtonsResponseMessage_Type value) { - _internal_set_type(value); - // @@protoc_insertion_point(field_set:proto.Message.ButtonsResponseMessage.type) -} - -// string selectedDisplayText = 2; -inline bool Message_ButtonsResponseMessage::_internal_has_selecteddisplaytext() const { - return response_case() == kSelectedDisplayText; -} -inline bool Message_ButtonsResponseMessage::has_selecteddisplaytext() const { - return _internal_has_selecteddisplaytext(); -} -inline void Message_ButtonsResponseMessage::set_has_selecteddisplaytext() { - _impl_._oneof_case_[0] = kSelectedDisplayText; -} -inline void Message_ButtonsResponseMessage::clear_selecteddisplaytext() { - if (_internal_has_selecteddisplaytext()) { - _impl_.response_.selecteddisplaytext_.Destroy(); - clear_has_response(); - } -} -inline const std::string& Message_ButtonsResponseMessage::selecteddisplaytext() const { - // @@protoc_insertion_point(field_get:proto.Message.ButtonsResponseMessage.selectedDisplayText) - return _internal_selecteddisplaytext(); -} -template -inline void Message_ButtonsResponseMessage::set_selecteddisplaytext(ArgT0&& arg0, ArgT... args) { - if (!_internal_has_selecteddisplaytext()) { - clear_response(); - set_has_selecteddisplaytext(); - _impl_.response_.selecteddisplaytext_.InitDefault(); - } - _impl_.response_.selecteddisplaytext_.Set( static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ButtonsResponseMessage.selectedDisplayText) -} -inline std::string* Message_ButtonsResponseMessage::mutable_selecteddisplaytext() { - std::string* _s = _internal_mutable_selecteddisplaytext(); - // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsResponseMessage.selectedDisplayText) - return _s; -} -inline const std::string& Message_ButtonsResponseMessage::_internal_selecteddisplaytext() const { - if (_internal_has_selecteddisplaytext()) { - return _impl_.response_.selecteddisplaytext_.Get(); - } - return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); -} -inline void Message_ButtonsResponseMessage::_internal_set_selecteddisplaytext(const std::string& value) { - if (!_internal_has_selecteddisplaytext()) { - clear_response(); - set_has_selecteddisplaytext(); - _impl_.response_.selecteddisplaytext_.InitDefault(); - } - _impl_.response_.selecteddisplaytext_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ButtonsResponseMessage::_internal_mutable_selecteddisplaytext() { - if (!_internal_has_selecteddisplaytext()) { - clear_response(); - set_has_selecteddisplaytext(); - _impl_.response_.selecteddisplaytext_.InitDefault(); - } - return _impl_.response_.selecteddisplaytext_.Mutable( GetArenaForAllocation()); -} -inline std::string* Message_ButtonsResponseMessage::release_selecteddisplaytext() { - // @@protoc_insertion_point(field_release:proto.Message.ButtonsResponseMessage.selectedDisplayText) - if (_internal_has_selecteddisplaytext()) { - clear_has_response(); - return _impl_.response_.selecteddisplaytext_.Release(); - } else { - return nullptr; - } -} -inline void Message_ButtonsResponseMessage::set_allocated_selecteddisplaytext(std::string* selecteddisplaytext) { - if (has_response()) { - clear_response(); - } - if (selecteddisplaytext != nullptr) { - set_has_selecteddisplaytext(); - _impl_.response_.selecteddisplaytext_.InitAllocated(selecteddisplaytext, GetArenaForAllocation()); - } - // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsResponseMessage.selectedDisplayText) -} - -inline bool Message_ButtonsResponseMessage::has_response() const { - return response_case() != RESPONSE_NOT_SET; -} -inline void Message_ButtonsResponseMessage::clear_has_response() { - _impl_._oneof_case_[0] = RESPONSE_NOT_SET; -} -inline Message_ButtonsResponseMessage::ResponseCase Message_ButtonsResponseMessage::response_case() const { - return Message_ButtonsResponseMessage::ResponseCase(_impl_._oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// Message_Call - -// optional bytes callKey = 1; -inline bool Message_Call::_internal_has_callkey() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_Call::has_callkey() const { - return _internal_has_callkey(); -} -inline void Message_Call::clear_callkey() { - _impl_.callkey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_Call::callkey() const { - // @@protoc_insertion_point(field_get:proto.Message.Call.callKey) - return _internal_callkey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_Call::set_callkey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.callkey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.Call.callKey) -} -inline std::string* Message_Call::mutable_callkey() { - std::string* _s = _internal_mutable_callkey(); - // @@protoc_insertion_point(field_mutable:proto.Message.Call.callKey) - return _s; -} -inline const std::string& Message_Call::_internal_callkey() const { - return _impl_.callkey_.Get(); -} -inline void Message_Call::_internal_set_callkey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.callkey_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_Call::_internal_mutable_callkey() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.callkey_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_Call::release_callkey() { - // @@protoc_insertion_point(field_release:proto.Message.Call.callKey) - if (!_internal_has_callkey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.callkey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.callkey_.IsDefault()) { - _impl_.callkey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_Call::set_allocated_callkey(std::string* callkey) { - if (callkey != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.callkey_.SetAllocated(callkey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.callkey_.IsDefault()) { - _impl_.callkey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.Call.callKey) -} - -// optional string conversionSource = 2; -inline bool Message_Call::_internal_has_conversionsource() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_Call::has_conversionsource() const { - return _internal_has_conversionsource(); -} -inline void Message_Call::clear_conversionsource() { - _impl_.conversionsource_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_Call::conversionsource() const { - // @@protoc_insertion_point(field_get:proto.Message.Call.conversionSource) - return _internal_conversionsource(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_Call::set_conversionsource(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.conversionsource_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.Call.conversionSource) -} -inline std::string* Message_Call::mutable_conversionsource() { - std::string* _s = _internal_mutable_conversionsource(); - // @@protoc_insertion_point(field_mutable:proto.Message.Call.conversionSource) - return _s; -} -inline const std::string& Message_Call::_internal_conversionsource() const { - return _impl_.conversionsource_.Get(); -} -inline void Message_Call::_internal_set_conversionsource(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.conversionsource_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_Call::_internal_mutable_conversionsource() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.conversionsource_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_Call::release_conversionsource() { - // @@protoc_insertion_point(field_release:proto.Message.Call.conversionSource) - if (!_internal_has_conversionsource()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.conversionsource_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.conversionsource_.IsDefault()) { - _impl_.conversionsource_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_Call::set_allocated_conversionsource(std::string* conversionsource) { - if (conversionsource != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.conversionsource_.SetAllocated(conversionsource, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.conversionsource_.IsDefault()) { - _impl_.conversionsource_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.Call.conversionSource) -} - -// optional bytes conversionData = 3; -inline bool Message_Call::_internal_has_conversiondata() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool Message_Call::has_conversiondata() const { - return _internal_has_conversiondata(); -} -inline void Message_Call::clear_conversiondata() { - _impl_.conversiondata_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& Message_Call::conversiondata() const { - // @@protoc_insertion_point(field_get:proto.Message.Call.conversionData) - return _internal_conversiondata(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_Call::set_conversiondata(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.conversiondata_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.Call.conversionData) -} -inline std::string* Message_Call::mutable_conversiondata() { - std::string* _s = _internal_mutable_conversiondata(); - // @@protoc_insertion_point(field_mutable:proto.Message.Call.conversionData) - return _s; -} -inline const std::string& Message_Call::_internal_conversiondata() const { - return _impl_.conversiondata_.Get(); -} -inline void Message_Call::_internal_set_conversiondata(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.conversiondata_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_Call::_internal_mutable_conversiondata() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.conversiondata_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_Call::release_conversiondata() { - // @@protoc_insertion_point(field_release:proto.Message.Call.conversionData) - if (!_internal_has_conversiondata()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.conversiondata_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.conversiondata_.IsDefault()) { - _impl_.conversiondata_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_Call::set_allocated_conversiondata(std::string* conversiondata) { - if (conversiondata != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.conversiondata_.SetAllocated(conversiondata, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.conversiondata_.IsDefault()) { - _impl_.conversiondata_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.Call.conversionData) -} - -// optional uint32 conversionDelaySeconds = 4; -inline bool Message_Call::_internal_has_conversiondelayseconds() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool Message_Call::has_conversiondelayseconds() const { - return _internal_has_conversiondelayseconds(); -} -inline void Message_Call::clear_conversiondelayseconds() { - _impl_.conversiondelayseconds_ = 0u; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline uint32_t Message_Call::_internal_conversiondelayseconds() const { - return _impl_.conversiondelayseconds_; -} -inline uint32_t Message_Call::conversiondelayseconds() const { - // @@protoc_insertion_point(field_get:proto.Message.Call.conversionDelaySeconds) - return _internal_conversiondelayseconds(); -} -inline void Message_Call::_internal_set_conversiondelayseconds(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.conversiondelayseconds_ = value; -} -inline void Message_Call::set_conversiondelayseconds(uint32_t value) { - _internal_set_conversiondelayseconds(value); - // @@protoc_insertion_point(field_set:proto.Message.Call.conversionDelaySeconds) -} - -// ------------------------------------------------------------------- - -// Message_CancelPaymentRequestMessage - -// optional .proto.MessageKey key = 1; -inline bool Message_CancelPaymentRequestMessage::_internal_has_key() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr); - return value; -} -inline bool Message_CancelPaymentRequestMessage::has_key() const { - return _internal_has_key(); -} -inline void Message_CancelPaymentRequestMessage::clear_key() { - if (_impl_.key_ != nullptr) _impl_.key_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::MessageKey& Message_CancelPaymentRequestMessage::_internal_key() const { - const ::proto::MessageKey* p = _impl_.key_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_MessageKey_default_instance_); -} -inline const ::proto::MessageKey& Message_CancelPaymentRequestMessage::key() const { - // @@protoc_insertion_point(field_get:proto.Message.CancelPaymentRequestMessage.key) - return _internal_key(); -} -inline void Message_CancelPaymentRequestMessage::unsafe_arena_set_allocated_key( - ::proto::MessageKey* key) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_); - } - _impl_.key_ = key; - if (key) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.CancelPaymentRequestMessage.key) -} -inline ::proto::MessageKey* Message_CancelPaymentRequestMessage::release_key() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::MessageKey* temp = _impl_.key_; - _impl_.key_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::MessageKey* Message_CancelPaymentRequestMessage::unsafe_arena_release_key() { - // @@protoc_insertion_point(field_release:proto.Message.CancelPaymentRequestMessage.key) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::MessageKey* temp = _impl_.key_; - _impl_.key_ = nullptr; - return temp; -} -inline ::proto::MessageKey* Message_CancelPaymentRequestMessage::_internal_mutable_key() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.key_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation()); - _impl_.key_ = p; - } - return _impl_.key_; -} -inline ::proto::MessageKey* Message_CancelPaymentRequestMessage::mutable_key() { - ::proto::MessageKey* _msg = _internal_mutable_key(); - // @@protoc_insertion_point(field_mutable:proto.Message.CancelPaymentRequestMessage.key) - return _msg; -} -inline void Message_CancelPaymentRequestMessage::set_allocated_key(::proto::MessageKey* key) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.key_; - } - if (key) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key); - if (message_arena != submessage_arena) { - key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, key, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.key_ = key; - // @@protoc_insertion_point(field_set_allocated:proto.Message.CancelPaymentRequestMessage.key) -} - -// ------------------------------------------------------------------- - -// Message_Chat - -// optional string displayName = 1; -inline bool Message_Chat::_internal_has_displayname() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_Chat::has_displayname() const { - return _internal_has_displayname(); -} -inline void Message_Chat::clear_displayname() { - _impl_.displayname_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_Chat::displayname() const { - // @@protoc_insertion_point(field_get:proto.Message.Chat.displayName) - return _internal_displayname(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_Chat::set_displayname(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.displayname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.Chat.displayName) -} -inline std::string* Message_Chat::mutable_displayname() { - std::string* _s = _internal_mutable_displayname(); - // @@protoc_insertion_point(field_mutable:proto.Message.Chat.displayName) - return _s; -} -inline const std::string& Message_Chat::_internal_displayname() const { - return _impl_.displayname_.Get(); -} -inline void Message_Chat::_internal_set_displayname(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.displayname_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_Chat::_internal_mutable_displayname() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.displayname_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_Chat::release_displayname() { - // @@protoc_insertion_point(field_release:proto.Message.Chat.displayName) - if (!_internal_has_displayname()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.displayname_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.displayname_.IsDefault()) { - _impl_.displayname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_Chat::set_allocated_displayname(std::string* displayname) { - if (displayname != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.displayname_.SetAllocated(displayname, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.displayname_.IsDefault()) { - _impl_.displayname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.Chat.displayName) -} - -// optional string id = 2; -inline bool Message_Chat::_internal_has_id() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_Chat::has_id() const { - return _internal_has_id(); -} -inline void Message_Chat::clear_id() { - _impl_.id_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_Chat::id() const { - // @@protoc_insertion_point(field_get:proto.Message.Chat.id) - return _internal_id(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_Chat::set_id(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.id_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.Chat.id) -} -inline std::string* Message_Chat::mutable_id() { - std::string* _s = _internal_mutable_id(); - // @@protoc_insertion_point(field_mutable:proto.Message.Chat.id) - return _s; -} -inline const std::string& Message_Chat::_internal_id() const { - return _impl_.id_.Get(); -} -inline void Message_Chat::_internal_set_id(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.id_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_Chat::_internal_mutable_id() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.id_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_Chat::release_id() { - // @@protoc_insertion_point(field_release:proto.Message.Chat.id) - if (!_internal_has_id()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.id_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.id_.IsDefault()) { - _impl_.id_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_Chat::set_allocated_id(std::string* id) { - if (id != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.id_.SetAllocated(id, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.id_.IsDefault()) { - _impl_.id_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.Chat.id) -} - -// ------------------------------------------------------------------- - -// Message_ContactMessage - -// optional string displayName = 1; -inline bool Message_ContactMessage::_internal_has_displayname() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_ContactMessage::has_displayname() const { - return _internal_has_displayname(); -} -inline void Message_ContactMessage::clear_displayname() { - _impl_.displayname_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_ContactMessage::displayname() const { - // @@protoc_insertion_point(field_get:proto.Message.ContactMessage.displayName) - return _internal_displayname(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ContactMessage::set_displayname(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.displayname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ContactMessage.displayName) -} -inline std::string* Message_ContactMessage::mutable_displayname() { - std::string* _s = _internal_mutable_displayname(); - // @@protoc_insertion_point(field_mutable:proto.Message.ContactMessage.displayName) - return _s; -} -inline const std::string& Message_ContactMessage::_internal_displayname() const { - return _impl_.displayname_.Get(); -} -inline void Message_ContactMessage::_internal_set_displayname(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.displayname_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ContactMessage::_internal_mutable_displayname() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.displayname_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ContactMessage::release_displayname() { - // @@protoc_insertion_point(field_release:proto.Message.ContactMessage.displayName) - if (!_internal_has_displayname()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.displayname_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.displayname_.IsDefault()) { - _impl_.displayname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ContactMessage::set_allocated_displayname(std::string* displayname) { - if (displayname != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.displayname_.SetAllocated(displayname, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.displayname_.IsDefault()) { - _impl_.displayname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ContactMessage.displayName) -} - -// optional string vcard = 16; -inline bool Message_ContactMessage::_internal_has_vcard() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_ContactMessage::has_vcard() const { - return _internal_has_vcard(); -} -inline void Message_ContactMessage::clear_vcard() { - _impl_.vcard_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_ContactMessage::vcard() const { - // @@protoc_insertion_point(field_get:proto.Message.ContactMessage.vcard) - return _internal_vcard(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ContactMessage::set_vcard(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.vcard_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ContactMessage.vcard) -} -inline std::string* Message_ContactMessage::mutable_vcard() { - std::string* _s = _internal_mutable_vcard(); - // @@protoc_insertion_point(field_mutable:proto.Message.ContactMessage.vcard) - return _s; -} -inline const std::string& Message_ContactMessage::_internal_vcard() const { - return _impl_.vcard_.Get(); -} -inline void Message_ContactMessage::_internal_set_vcard(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.vcard_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ContactMessage::_internal_mutable_vcard() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.vcard_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ContactMessage::release_vcard() { - // @@protoc_insertion_point(field_release:proto.Message.ContactMessage.vcard) - if (!_internal_has_vcard()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.vcard_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.vcard_.IsDefault()) { - _impl_.vcard_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ContactMessage::set_allocated_vcard(std::string* vcard) { - if (vcard != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.vcard_.SetAllocated(vcard, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.vcard_.IsDefault()) { - _impl_.vcard_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ContactMessage.vcard) -} - -// optional .proto.ContextInfo contextInfo = 17; -inline bool Message_ContactMessage::_internal_has_contextinfo() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); - return value; -} -inline bool Message_ContactMessage::has_contextinfo() const { - return _internal_has_contextinfo(); -} -inline void Message_ContactMessage::clear_contextinfo() { - if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const ::proto::ContextInfo& Message_ContactMessage::_internal_contextinfo() const { - const ::proto::ContextInfo* p = _impl_.contextinfo_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ContextInfo_default_instance_); -} -inline const ::proto::ContextInfo& Message_ContactMessage::contextinfo() const { - // @@protoc_insertion_point(field_get:proto.Message.ContactMessage.contextInfo) - return _internal_contextinfo(); -} -inline void Message_ContactMessage::unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); - } - _impl_.contextinfo_ = contextinfo; - if (contextinfo) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ContactMessage.contextInfo) -} -inline ::proto::ContextInfo* Message_ContactMessage::release_contextinfo() { - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ContextInfo* Message_ContactMessage::unsafe_arena_release_contextinfo() { - // @@protoc_insertion_point(field_release:proto.Message.ContactMessage.contextInfo) - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; - return temp; -} -inline ::proto::ContextInfo* Message_ContactMessage::_internal_mutable_contextinfo() { - _impl_._has_bits_[0] |= 0x00000004u; - if (_impl_.contextinfo_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); - _impl_.contextinfo_ = p; - } - return _impl_.contextinfo_; -} -inline ::proto::ContextInfo* Message_ContactMessage::mutable_contextinfo() { - ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); - // @@protoc_insertion_point(field_mutable:proto.Message.ContactMessage.contextInfo) - return _msg; -} -inline void Message_ContactMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.contextinfo_; - } - if (contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); - if (message_arena != submessage_arena) { - contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, contextinfo, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.contextinfo_ = contextinfo; - // @@protoc_insertion_point(field_set_allocated:proto.Message.ContactMessage.contextInfo) -} - -// ------------------------------------------------------------------- - -// Message_ContactsArrayMessage - -// optional string displayName = 1; -inline bool Message_ContactsArrayMessage::_internal_has_displayname() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_ContactsArrayMessage::has_displayname() const { - return _internal_has_displayname(); -} -inline void Message_ContactsArrayMessage::clear_displayname() { - _impl_.displayname_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_ContactsArrayMessage::displayname() const { - // @@protoc_insertion_point(field_get:proto.Message.ContactsArrayMessage.displayName) - return _internal_displayname(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ContactsArrayMessage::set_displayname(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.displayname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ContactsArrayMessage.displayName) -} -inline std::string* Message_ContactsArrayMessage::mutable_displayname() { - std::string* _s = _internal_mutable_displayname(); - // @@protoc_insertion_point(field_mutable:proto.Message.ContactsArrayMessage.displayName) - return _s; -} -inline const std::string& Message_ContactsArrayMessage::_internal_displayname() const { - return _impl_.displayname_.Get(); -} -inline void Message_ContactsArrayMessage::_internal_set_displayname(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.displayname_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ContactsArrayMessage::_internal_mutable_displayname() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.displayname_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ContactsArrayMessage::release_displayname() { - // @@protoc_insertion_point(field_release:proto.Message.ContactsArrayMessage.displayName) - if (!_internal_has_displayname()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.displayname_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.displayname_.IsDefault()) { - _impl_.displayname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ContactsArrayMessage::set_allocated_displayname(std::string* displayname) { - if (displayname != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.displayname_.SetAllocated(displayname, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.displayname_.IsDefault()) { - _impl_.displayname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ContactsArrayMessage.displayName) -} - -// repeated .proto.Message.ContactMessage contacts = 2; -inline int Message_ContactsArrayMessage::_internal_contacts_size() const { - return _impl_.contacts_.size(); -} -inline int Message_ContactsArrayMessage::contacts_size() const { - return _internal_contacts_size(); -} -inline void Message_ContactsArrayMessage::clear_contacts() { - _impl_.contacts_.Clear(); -} -inline ::proto::Message_ContactMessage* Message_ContactsArrayMessage::mutable_contacts(int index) { - // @@protoc_insertion_point(field_mutable:proto.Message.ContactsArrayMessage.contacts) - return _impl_.contacts_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ContactMessage >* -Message_ContactsArrayMessage::mutable_contacts() { - // @@protoc_insertion_point(field_mutable_list:proto.Message.ContactsArrayMessage.contacts) - return &_impl_.contacts_; -} -inline const ::proto::Message_ContactMessage& Message_ContactsArrayMessage::_internal_contacts(int index) const { - return _impl_.contacts_.Get(index); -} -inline const ::proto::Message_ContactMessage& Message_ContactsArrayMessage::contacts(int index) const { - // @@protoc_insertion_point(field_get:proto.Message.ContactsArrayMessage.contacts) - return _internal_contacts(index); -} -inline ::proto::Message_ContactMessage* Message_ContactsArrayMessage::_internal_add_contacts() { - return _impl_.contacts_.Add(); -} -inline ::proto::Message_ContactMessage* Message_ContactsArrayMessage::add_contacts() { - ::proto::Message_ContactMessage* _add = _internal_add_contacts(); - // @@protoc_insertion_point(field_add:proto.Message.ContactsArrayMessage.contacts) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ContactMessage >& -Message_ContactsArrayMessage::contacts() const { - // @@protoc_insertion_point(field_list:proto.Message.ContactsArrayMessage.contacts) - return _impl_.contacts_; -} - -// optional .proto.ContextInfo contextInfo = 17; -inline bool Message_ContactsArrayMessage::_internal_has_contextinfo() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); - return value; -} -inline bool Message_ContactsArrayMessage::has_contextinfo() const { - return _internal_has_contextinfo(); -} -inline void Message_ContactsArrayMessage::clear_contextinfo() { - if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::ContextInfo& Message_ContactsArrayMessage::_internal_contextinfo() const { - const ::proto::ContextInfo* p = _impl_.contextinfo_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ContextInfo_default_instance_); -} -inline const ::proto::ContextInfo& Message_ContactsArrayMessage::contextinfo() const { - // @@protoc_insertion_point(field_get:proto.Message.ContactsArrayMessage.contextInfo) - return _internal_contextinfo(); -} -inline void Message_ContactsArrayMessage::unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); - } - _impl_.contextinfo_ = contextinfo; - if (contextinfo) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ContactsArrayMessage.contextInfo) -} -inline ::proto::ContextInfo* Message_ContactsArrayMessage::release_contextinfo() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ContextInfo* Message_ContactsArrayMessage::unsafe_arena_release_contextinfo() { - // @@protoc_insertion_point(field_release:proto.Message.ContactsArrayMessage.contextInfo) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; - return temp; -} -inline ::proto::ContextInfo* Message_ContactsArrayMessage::_internal_mutable_contextinfo() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.contextinfo_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); - _impl_.contextinfo_ = p; - } - return _impl_.contextinfo_; -} -inline ::proto::ContextInfo* Message_ContactsArrayMessage::mutable_contextinfo() { - ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); - // @@protoc_insertion_point(field_mutable:proto.Message.ContactsArrayMessage.contextInfo) - return _msg; -} -inline void Message_ContactsArrayMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.contextinfo_; - } - if (contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); - if (message_arena != submessage_arena) { - contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, contextinfo, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.contextinfo_ = contextinfo; - // @@protoc_insertion_point(field_set_allocated:proto.Message.ContactsArrayMessage.contextInfo) -} - -// ------------------------------------------------------------------- - -// Message_DeclinePaymentRequestMessage - -// optional .proto.MessageKey key = 1; -inline bool Message_DeclinePaymentRequestMessage::_internal_has_key() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr); - return value; -} -inline bool Message_DeclinePaymentRequestMessage::has_key() const { - return _internal_has_key(); -} -inline void Message_DeclinePaymentRequestMessage::clear_key() { - if (_impl_.key_ != nullptr) _impl_.key_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::MessageKey& Message_DeclinePaymentRequestMessage::_internal_key() const { - const ::proto::MessageKey* p = _impl_.key_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_MessageKey_default_instance_); -} -inline const ::proto::MessageKey& Message_DeclinePaymentRequestMessage::key() const { - // @@protoc_insertion_point(field_get:proto.Message.DeclinePaymentRequestMessage.key) - return _internal_key(); -} -inline void Message_DeclinePaymentRequestMessage::unsafe_arena_set_allocated_key( - ::proto::MessageKey* key) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_); - } - _impl_.key_ = key; - if (key) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.DeclinePaymentRequestMessage.key) -} -inline ::proto::MessageKey* Message_DeclinePaymentRequestMessage::release_key() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::MessageKey* temp = _impl_.key_; - _impl_.key_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::MessageKey* Message_DeclinePaymentRequestMessage::unsafe_arena_release_key() { - // @@protoc_insertion_point(field_release:proto.Message.DeclinePaymentRequestMessage.key) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::MessageKey* temp = _impl_.key_; - _impl_.key_ = nullptr; - return temp; -} -inline ::proto::MessageKey* Message_DeclinePaymentRequestMessage::_internal_mutable_key() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.key_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation()); - _impl_.key_ = p; - } - return _impl_.key_; -} -inline ::proto::MessageKey* Message_DeclinePaymentRequestMessage::mutable_key() { - ::proto::MessageKey* _msg = _internal_mutable_key(); - // @@protoc_insertion_point(field_mutable:proto.Message.DeclinePaymentRequestMessage.key) - return _msg; -} -inline void Message_DeclinePaymentRequestMessage::set_allocated_key(::proto::MessageKey* key) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.key_; - } - if (key) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key); - if (message_arena != submessage_arena) { - key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, key, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.key_ = key; - // @@protoc_insertion_point(field_set_allocated:proto.Message.DeclinePaymentRequestMessage.key) -} - -// ------------------------------------------------------------------- - -// Message_DeviceSentMessage - -// optional string destinationJid = 1; -inline bool Message_DeviceSentMessage::_internal_has_destinationjid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_DeviceSentMessage::has_destinationjid() const { - return _internal_has_destinationjid(); -} -inline void Message_DeviceSentMessage::clear_destinationjid() { - _impl_.destinationjid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_DeviceSentMessage::destinationjid() const { - // @@protoc_insertion_point(field_get:proto.Message.DeviceSentMessage.destinationJid) - return _internal_destinationjid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_DeviceSentMessage::set_destinationjid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.destinationjid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.DeviceSentMessage.destinationJid) -} -inline std::string* Message_DeviceSentMessage::mutable_destinationjid() { - std::string* _s = _internal_mutable_destinationjid(); - // @@protoc_insertion_point(field_mutable:proto.Message.DeviceSentMessage.destinationJid) - return _s; -} -inline const std::string& Message_DeviceSentMessage::_internal_destinationjid() const { - return _impl_.destinationjid_.Get(); -} -inline void Message_DeviceSentMessage::_internal_set_destinationjid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.destinationjid_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_DeviceSentMessage::_internal_mutable_destinationjid() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.destinationjid_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_DeviceSentMessage::release_destinationjid() { - // @@protoc_insertion_point(field_release:proto.Message.DeviceSentMessage.destinationJid) - if (!_internal_has_destinationjid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.destinationjid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.destinationjid_.IsDefault()) { - _impl_.destinationjid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_DeviceSentMessage::set_allocated_destinationjid(std::string* destinationjid) { - if (destinationjid != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.destinationjid_.SetAllocated(destinationjid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.destinationjid_.IsDefault()) { - _impl_.destinationjid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.DeviceSentMessage.destinationJid) -} - -// optional .proto.Message message = 2; -inline bool Message_DeviceSentMessage::_internal_has_message() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - PROTOBUF_ASSUME(!value || _impl_.message_ != nullptr); - return value; -} -inline bool Message_DeviceSentMessage::has_message() const { - return _internal_has_message(); -} -inline void Message_DeviceSentMessage::clear_message() { - if (_impl_.message_ != nullptr) _impl_.message_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const ::proto::Message& Message_DeviceSentMessage::_internal_message() const { - const ::proto::Message* p = _impl_.message_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_default_instance_); -} -inline const ::proto::Message& Message_DeviceSentMessage::message() const { - // @@protoc_insertion_point(field_get:proto.Message.DeviceSentMessage.message) - return _internal_message(); -} -inline void Message_DeviceSentMessage::unsafe_arena_set_allocated_message( - ::proto::Message* message) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.message_); - } - _impl_.message_ = message; - if (message) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.DeviceSentMessage.message) -} -inline ::proto::Message* Message_DeviceSentMessage::release_message() { - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::Message* temp = _impl_.message_; - _impl_.message_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message* Message_DeviceSentMessage::unsafe_arena_release_message() { - // @@protoc_insertion_point(field_release:proto.Message.DeviceSentMessage.message) - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::Message* temp = _impl_.message_; - _impl_.message_ = nullptr; - return temp; -} -inline ::proto::Message* Message_DeviceSentMessage::_internal_mutable_message() { - _impl_._has_bits_[0] |= 0x00000004u; - if (_impl_.message_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message>(GetArenaForAllocation()); - _impl_.message_ = p; - } - return _impl_.message_; -} -inline ::proto::Message* Message_DeviceSentMessage::mutable_message() { - ::proto::Message* _msg = _internal_mutable_message(); - // @@protoc_insertion_point(field_mutable:proto.Message.DeviceSentMessage.message) - return _msg; -} -inline void Message_DeviceSentMessage::set_allocated_message(::proto::Message* message) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.message_; - } - if (message) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(message); - if (message_arena != submessage_arena) { - message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, message, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.message_ = message; - // @@protoc_insertion_point(field_set_allocated:proto.Message.DeviceSentMessage.message) -} - -// optional string phash = 3; -inline bool Message_DeviceSentMessage::_internal_has_phash() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_DeviceSentMessage::has_phash() const { - return _internal_has_phash(); -} -inline void Message_DeviceSentMessage::clear_phash() { - _impl_.phash_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_DeviceSentMessage::phash() const { - // @@protoc_insertion_point(field_get:proto.Message.DeviceSentMessage.phash) - return _internal_phash(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_DeviceSentMessage::set_phash(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.phash_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.DeviceSentMessage.phash) -} -inline std::string* Message_DeviceSentMessage::mutable_phash() { - std::string* _s = _internal_mutable_phash(); - // @@protoc_insertion_point(field_mutable:proto.Message.DeviceSentMessage.phash) - return _s; -} -inline const std::string& Message_DeviceSentMessage::_internal_phash() const { - return _impl_.phash_.Get(); -} -inline void Message_DeviceSentMessage::_internal_set_phash(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.phash_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_DeviceSentMessage::_internal_mutable_phash() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.phash_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_DeviceSentMessage::release_phash() { - // @@protoc_insertion_point(field_release:proto.Message.DeviceSentMessage.phash) - if (!_internal_has_phash()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.phash_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.phash_.IsDefault()) { - _impl_.phash_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_DeviceSentMessage::set_allocated_phash(std::string* phash) { - if (phash != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.phash_.SetAllocated(phash, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.phash_.IsDefault()) { - _impl_.phash_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.DeviceSentMessage.phash) -} - -// ------------------------------------------------------------------- - -// Message_DocumentMessage - -// optional string url = 1; -inline bool Message_DocumentMessage::_internal_has_url() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_DocumentMessage::has_url() const { - return _internal_has_url(); -} -inline void Message_DocumentMessage::clear_url() { - _impl_.url_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_DocumentMessage::url() const { - // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.url) - return _internal_url(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_DocumentMessage::set_url(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.url_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.url) -} -inline std::string* Message_DocumentMessage::mutable_url() { - std::string* _s = _internal_mutable_url(); - // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.url) - return _s; -} -inline const std::string& Message_DocumentMessage::_internal_url() const { - return _impl_.url_.Get(); -} -inline void Message_DocumentMessage::_internal_set_url(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.url_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_DocumentMessage::_internal_mutable_url() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.url_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_DocumentMessage::release_url() { - // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.url) - if (!_internal_has_url()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.url_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.url_.IsDefault()) { - _impl_.url_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_DocumentMessage::set_allocated_url(std::string* url) { - if (url != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.url_.SetAllocated(url, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.url_.IsDefault()) { - _impl_.url_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.url) -} - -// optional string mimetype = 2; -inline bool Message_DocumentMessage::_internal_has_mimetype() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_DocumentMessage::has_mimetype() const { - return _internal_has_mimetype(); -} -inline void Message_DocumentMessage::clear_mimetype() { - _impl_.mimetype_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_DocumentMessage::mimetype() const { - // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.mimetype) - return _internal_mimetype(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_DocumentMessage::set_mimetype(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.mimetype_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.mimetype) -} -inline std::string* Message_DocumentMessage::mutable_mimetype() { - std::string* _s = _internal_mutable_mimetype(); - // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.mimetype) - return _s; -} -inline const std::string& Message_DocumentMessage::_internal_mimetype() const { - return _impl_.mimetype_.Get(); -} -inline void Message_DocumentMessage::_internal_set_mimetype(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.mimetype_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_DocumentMessage::_internal_mutable_mimetype() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.mimetype_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_DocumentMessage::release_mimetype() { - // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.mimetype) - if (!_internal_has_mimetype()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.mimetype_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mimetype_.IsDefault()) { - _impl_.mimetype_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_DocumentMessage::set_allocated_mimetype(std::string* mimetype) { - if (mimetype != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mimetype_.IsDefault()) { - _impl_.mimetype_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.mimetype) -} - -// optional string title = 3; -inline bool Message_DocumentMessage::_internal_has_title() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool Message_DocumentMessage::has_title() const { - return _internal_has_title(); -} -inline void Message_DocumentMessage::clear_title() { - _impl_.title_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& Message_DocumentMessage::title() const { - // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.title) - return _internal_title(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_DocumentMessage::set_title(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.title_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.title) -} -inline std::string* Message_DocumentMessage::mutable_title() { - std::string* _s = _internal_mutable_title(); - // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.title) - return _s; -} -inline const std::string& Message_DocumentMessage::_internal_title() const { - return _impl_.title_.Get(); -} -inline void Message_DocumentMessage::_internal_set_title(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.title_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_DocumentMessage::_internal_mutable_title() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.title_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_DocumentMessage::release_title() { - // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.title) - if (!_internal_has_title()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.title_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.title_.IsDefault()) { - _impl_.title_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_DocumentMessage::set_allocated_title(std::string* title) { - if (title != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.title_.SetAllocated(title, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.title_.IsDefault()) { - _impl_.title_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.title) -} - -// optional bytes fileSha256 = 4; -inline bool Message_DocumentMessage::_internal_has_filesha256() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool Message_DocumentMessage::has_filesha256() const { - return _internal_has_filesha256(); -} -inline void Message_DocumentMessage::clear_filesha256() { - _impl_.filesha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const std::string& Message_DocumentMessage::filesha256() const { - // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.fileSha256) - return _internal_filesha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_DocumentMessage::set_filesha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.filesha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.fileSha256) -} -inline std::string* Message_DocumentMessage::mutable_filesha256() { - std::string* _s = _internal_mutable_filesha256(); - // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.fileSha256) - return _s; -} -inline const std::string& Message_DocumentMessage::_internal_filesha256() const { - return _impl_.filesha256_.Get(); -} -inline void Message_DocumentMessage::_internal_set_filesha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.filesha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_DocumentMessage::_internal_mutable_filesha256() { - _impl_._has_bits_[0] |= 0x00000008u; - return _impl_.filesha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_DocumentMessage::release_filesha256() { - // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.fileSha256) - if (!_internal_has_filesha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000008u; - auto* p = _impl_.filesha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.filesha256_.IsDefault()) { - _impl_.filesha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_DocumentMessage::set_allocated_filesha256(std::string* filesha256) { - if (filesha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.filesha256_.IsDefault()) { - _impl_.filesha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.fileSha256) -} - -// optional uint64 fileLength = 5; -inline bool Message_DocumentMessage::_internal_has_filelength() const { - bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0; - return value; -} -inline bool Message_DocumentMessage::has_filelength() const { - return _internal_has_filelength(); -} -inline void Message_DocumentMessage::clear_filelength() { - _impl_.filelength_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00004000u; -} -inline uint64_t Message_DocumentMessage::_internal_filelength() const { - return _impl_.filelength_; -} -inline uint64_t Message_DocumentMessage::filelength() const { - // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.fileLength) - return _internal_filelength(); -} -inline void Message_DocumentMessage::_internal_set_filelength(uint64_t value) { - _impl_._has_bits_[0] |= 0x00004000u; - _impl_.filelength_ = value; -} -inline void Message_DocumentMessage::set_filelength(uint64_t value) { - _internal_set_filelength(value); - // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.fileLength) -} - -// optional uint32 pageCount = 6; -inline bool Message_DocumentMessage::_internal_has_pagecount() const { - bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0; - return value; -} -inline bool Message_DocumentMessage::has_pagecount() const { - return _internal_has_pagecount(); -} -inline void Message_DocumentMessage::clear_pagecount() { - _impl_.pagecount_ = 0u; - _impl_._has_bits_[0] &= ~0x00008000u; -} -inline uint32_t Message_DocumentMessage::_internal_pagecount() const { - return _impl_.pagecount_; -} -inline uint32_t Message_DocumentMessage::pagecount() const { - // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.pageCount) - return _internal_pagecount(); -} -inline void Message_DocumentMessage::_internal_set_pagecount(uint32_t value) { - _impl_._has_bits_[0] |= 0x00008000u; - _impl_.pagecount_ = value; -} -inline void Message_DocumentMessage::set_pagecount(uint32_t value) { - _internal_set_pagecount(value); - // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.pageCount) -} - -// optional bytes mediaKey = 7; -inline bool Message_DocumentMessage::_internal_has_mediakey() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool Message_DocumentMessage::has_mediakey() const { - return _internal_has_mediakey(); -} -inline void Message_DocumentMessage::clear_mediakey() { - _impl_.mediakey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const std::string& Message_DocumentMessage::mediakey() const { - // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.mediaKey) - return _internal_mediakey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_DocumentMessage::set_mediakey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.mediakey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.mediaKey) -} -inline std::string* Message_DocumentMessage::mutable_mediakey() { - std::string* _s = _internal_mutable_mediakey(); - // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.mediaKey) - return _s; -} -inline const std::string& Message_DocumentMessage::_internal_mediakey() const { - return _impl_.mediakey_.Get(); -} -inline void Message_DocumentMessage::_internal_set_mediakey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.mediakey_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_DocumentMessage::_internal_mutable_mediakey() { - _impl_._has_bits_[0] |= 0x00000010u; - return _impl_.mediakey_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_DocumentMessage::release_mediakey() { - // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.mediaKey) - if (!_internal_has_mediakey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000010u; - auto* p = _impl_.mediakey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mediakey_.IsDefault()) { - _impl_.mediakey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_DocumentMessage::set_allocated_mediakey(std::string* mediakey) { - if (mediakey != nullptr) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mediakey_.IsDefault()) { - _impl_.mediakey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.mediaKey) -} - -// optional string fileName = 8; -inline bool Message_DocumentMessage::_internal_has_filename() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool Message_DocumentMessage::has_filename() const { - return _internal_has_filename(); -} -inline void Message_DocumentMessage::clear_filename() { - _impl_.filename_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline const std::string& Message_DocumentMessage::filename() const { - // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.fileName) - return _internal_filename(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_DocumentMessage::set_filename(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.filename_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.fileName) -} -inline std::string* Message_DocumentMessage::mutable_filename() { - std::string* _s = _internal_mutable_filename(); - // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.fileName) - return _s; -} -inline const std::string& Message_DocumentMessage::_internal_filename() const { - return _impl_.filename_.Get(); -} -inline void Message_DocumentMessage::_internal_set_filename(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.filename_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_DocumentMessage::_internal_mutable_filename() { - _impl_._has_bits_[0] |= 0x00000020u; - return _impl_.filename_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_DocumentMessage::release_filename() { - // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.fileName) - if (!_internal_has_filename()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000020u; - auto* p = _impl_.filename_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.filename_.IsDefault()) { - _impl_.filename_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_DocumentMessage::set_allocated_filename(std::string* filename) { - if (filename != nullptr) { - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - _impl_.filename_.SetAllocated(filename, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.filename_.IsDefault()) { - _impl_.filename_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.fileName) -} - -// optional bytes fileEncSha256 = 9; -inline bool Message_DocumentMessage::_internal_has_fileencsha256() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool Message_DocumentMessage::has_fileencsha256() const { - return _internal_has_fileencsha256(); -} -inline void Message_DocumentMessage::clear_fileencsha256() { - _impl_.fileencsha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline const std::string& Message_DocumentMessage::fileencsha256() const { - // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.fileEncSha256) - return _internal_fileencsha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_DocumentMessage::set_fileencsha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.fileencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.fileEncSha256) -} -inline std::string* Message_DocumentMessage::mutable_fileencsha256() { - std::string* _s = _internal_mutable_fileencsha256(); - // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.fileEncSha256) - return _s; -} -inline const std::string& Message_DocumentMessage::_internal_fileencsha256() const { - return _impl_.fileencsha256_.Get(); -} -inline void Message_DocumentMessage::_internal_set_fileencsha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.fileencsha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_DocumentMessage::_internal_mutable_fileencsha256() { - _impl_._has_bits_[0] |= 0x00000040u; - return _impl_.fileencsha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_DocumentMessage::release_fileencsha256() { - // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.fileEncSha256) - if (!_internal_has_fileencsha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000040u; - auto* p = _impl_.fileencsha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fileencsha256_.IsDefault()) { - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_DocumentMessage::set_allocated_fileencsha256(std::string* fileencsha256) { - if (fileencsha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00000040u; - } else { - _impl_._has_bits_[0] &= ~0x00000040u; - } - _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fileencsha256_.IsDefault()) { - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.fileEncSha256) -} - -// optional string directPath = 10; -inline bool Message_DocumentMessage::_internal_has_directpath() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - return value; -} -inline bool Message_DocumentMessage::has_directpath() const { - return _internal_has_directpath(); -} -inline void Message_DocumentMessage::clear_directpath() { - _impl_.directpath_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline const std::string& Message_DocumentMessage::directpath() const { - // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.directPath) - return _internal_directpath(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_DocumentMessage::set_directpath(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.directpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.directPath) -} -inline std::string* Message_DocumentMessage::mutable_directpath() { - std::string* _s = _internal_mutable_directpath(); - // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.directPath) - return _s; -} -inline const std::string& Message_DocumentMessage::_internal_directpath() const { - return _impl_.directpath_.Get(); -} -inline void Message_DocumentMessage::_internal_set_directpath(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.directpath_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_DocumentMessage::_internal_mutable_directpath() { - _impl_._has_bits_[0] |= 0x00000080u; - return _impl_.directpath_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_DocumentMessage::release_directpath() { - // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.directPath) - if (!_internal_has_directpath()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000080u; - auto* p = _impl_.directpath_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.directpath_.IsDefault()) { - _impl_.directpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_DocumentMessage::set_allocated_directpath(std::string* directpath) { - if (directpath != nullptr) { - _impl_._has_bits_[0] |= 0x00000080u; - } else { - _impl_._has_bits_[0] &= ~0x00000080u; - } - _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.directpath_.IsDefault()) { - _impl_.directpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.directPath) -} - -// optional int64 mediaKeyTimestamp = 11; -inline bool Message_DocumentMessage::_internal_has_mediakeytimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0; - return value; -} -inline bool Message_DocumentMessage::has_mediakeytimestamp() const { - return _internal_has_mediakeytimestamp(); -} -inline void Message_DocumentMessage::clear_mediakeytimestamp() { - _impl_.mediakeytimestamp_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00020000u; -} -inline int64_t Message_DocumentMessage::_internal_mediakeytimestamp() const { - return _impl_.mediakeytimestamp_; -} -inline int64_t Message_DocumentMessage::mediakeytimestamp() const { - // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.mediaKeyTimestamp) - return _internal_mediakeytimestamp(); -} -inline void Message_DocumentMessage::_internal_set_mediakeytimestamp(int64_t value) { - _impl_._has_bits_[0] |= 0x00020000u; - _impl_.mediakeytimestamp_ = value; -} -inline void Message_DocumentMessage::set_mediakeytimestamp(int64_t value) { - _internal_set_mediakeytimestamp(value); - // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.mediaKeyTimestamp) -} - -// optional bool contactVcard = 12; -inline bool Message_DocumentMessage::_internal_has_contactvcard() const { - bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0; - return value; -} -inline bool Message_DocumentMessage::has_contactvcard() const { - return _internal_has_contactvcard(); -} -inline void Message_DocumentMessage::clear_contactvcard() { - _impl_.contactvcard_ = false; - _impl_._has_bits_[0] &= ~0x00010000u; -} -inline bool Message_DocumentMessage::_internal_contactvcard() const { - return _impl_.contactvcard_; -} -inline bool Message_DocumentMessage::contactvcard() const { - // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.contactVcard) - return _internal_contactvcard(); -} -inline void Message_DocumentMessage::_internal_set_contactvcard(bool value) { - _impl_._has_bits_[0] |= 0x00010000u; - _impl_.contactvcard_ = value; -} -inline void Message_DocumentMessage::set_contactvcard(bool value) { - _internal_set_contactvcard(value); - // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.contactVcard) -} - -// optional string thumbnailDirectPath = 13; -inline bool Message_DocumentMessage::_internal_has_thumbnaildirectpath() const { - bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; - return value; -} -inline bool Message_DocumentMessage::has_thumbnaildirectpath() const { - return _internal_has_thumbnaildirectpath(); -} -inline void Message_DocumentMessage::clear_thumbnaildirectpath() { - _impl_.thumbnaildirectpath_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000100u; -} -inline const std::string& Message_DocumentMessage::thumbnaildirectpath() const { - // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.thumbnailDirectPath) - return _internal_thumbnaildirectpath(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_DocumentMessage::set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000100u; - _impl_.thumbnaildirectpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.thumbnailDirectPath) -} -inline std::string* Message_DocumentMessage::mutable_thumbnaildirectpath() { - std::string* _s = _internal_mutable_thumbnaildirectpath(); - // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.thumbnailDirectPath) - return _s; -} -inline const std::string& Message_DocumentMessage::_internal_thumbnaildirectpath() const { - return _impl_.thumbnaildirectpath_.Get(); -} -inline void Message_DocumentMessage::_internal_set_thumbnaildirectpath(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000100u; - _impl_.thumbnaildirectpath_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_DocumentMessage::_internal_mutable_thumbnaildirectpath() { - _impl_._has_bits_[0] |= 0x00000100u; - return _impl_.thumbnaildirectpath_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_DocumentMessage::release_thumbnaildirectpath() { - // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.thumbnailDirectPath) - if (!_internal_has_thumbnaildirectpath()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000100u; - auto* p = _impl_.thumbnaildirectpath_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.thumbnaildirectpath_.IsDefault()) { - _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_DocumentMessage::set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath) { - if (thumbnaildirectpath != nullptr) { - _impl_._has_bits_[0] |= 0x00000100u; - } else { - _impl_._has_bits_[0] &= ~0x00000100u; - } - _impl_.thumbnaildirectpath_.SetAllocated(thumbnaildirectpath, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.thumbnaildirectpath_.IsDefault()) { - _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.thumbnailDirectPath) -} - -// optional bytes thumbnailSha256 = 14; -inline bool Message_DocumentMessage::_internal_has_thumbnailsha256() const { - bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; - return value; -} -inline bool Message_DocumentMessage::has_thumbnailsha256() const { - return _internal_has_thumbnailsha256(); -} -inline void Message_DocumentMessage::clear_thumbnailsha256() { - _impl_.thumbnailsha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000200u; -} -inline const std::string& Message_DocumentMessage::thumbnailsha256() const { - // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.thumbnailSha256) - return _internal_thumbnailsha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_DocumentMessage::set_thumbnailsha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.thumbnailsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.thumbnailSha256) -} -inline std::string* Message_DocumentMessage::mutable_thumbnailsha256() { - std::string* _s = _internal_mutable_thumbnailsha256(); - // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.thumbnailSha256) - return _s; -} -inline const std::string& Message_DocumentMessage::_internal_thumbnailsha256() const { - return _impl_.thumbnailsha256_.Get(); -} -inline void Message_DocumentMessage::_internal_set_thumbnailsha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.thumbnailsha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_DocumentMessage::_internal_mutable_thumbnailsha256() { - _impl_._has_bits_[0] |= 0x00000200u; - return _impl_.thumbnailsha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_DocumentMessage::release_thumbnailsha256() { - // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.thumbnailSha256) - if (!_internal_has_thumbnailsha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000200u; - auto* p = _impl_.thumbnailsha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.thumbnailsha256_.IsDefault()) { - _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_DocumentMessage::set_allocated_thumbnailsha256(std::string* thumbnailsha256) { - if (thumbnailsha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00000200u; - } else { - _impl_._has_bits_[0] &= ~0x00000200u; - } - _impl_.thumbnailsha256_.SetAllocated(thumbnailsha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.thumbnailsha256_.IsDefault()) { - _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.thumbnailSha256) -} - -// optional bytes thumbnailEncSha256 = 15; -inline bool Message_DocumentMessage::_internal_has_thumbnailencsha256() const { - bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; - return value; -} -inline bool Message_DocumentMessage::has_thumbnailencsha256() const { - return _internal_has_thumbnailencsha256(); -} -inline void Message_DocumentMessage::clear_thumbnailencsha256() { - _impl_.thumbnailencsha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000400u; -} -inline const std::string& Message_DocumentMessage::thumbnailencsha256() const { - // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.thumbnailEncSha256) - return _internal_thumbnailencsha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_DocumentMessage::set_thumbnailencsha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000400u; - _impl_.thumbnailencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.thumbnailEncSha256) -} -inline std::string* Message_DocumentMessage::mutable_thumbnailencsha256() { - std::string* _s = _internal_mutable_thumbnailencsha256(); - // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.thumbnailEncSha256) - return _s; -} -inline const std::string& Message_DocumentMessage::_internal_thumbnailencsha256() const { - return _impl_.thumbnailencsha256_.Get(); -} -inline void Message_DocumentMessage::_internal_set_thumbnailencsha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000400u; - _impl_.thumbnailencsha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_DocumentMessage::_internal_mutable_thumbnailencsha256() { - _impl_._has_bits_[0] |= 0x00000400u; - return _impl_.thumbnailencsha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_DocumentMessage::release_thumbnailencsha256() { - // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.thumbnailEncSha256) - if (!_internal_has_thumbnailencsha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000400u; - auto* p = _impl_.thumbnailencsha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.thumbnailencsha256_.IsDefault()) { - _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_DocumentMessage::set_allocated_thumbnailencsha256(std::string* thumbnailencsha256) { - if (thumbnailencsha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00000400u; - } else { - _impl_._has_bits_[0] &= ~0x00000400u; - } - _impl_.thumbnailencsha256_.SetAllocated(thumbnailencsha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.thumbnailencsha256_.IsDefault()) { - _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.thumbnailEncSha256) -} - -// optional bytes jpegThumbnail = 16; -inline bool Message_DocumentMessage::_internal_has_jpegthumbnail() const { - bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; - return value; -} -inline bool Message_DocumentMessage::has_jpegthumbnail() const { - return _internal_has_jpegthumbnail(); -} -inline void Message_DocumentMessage::clear_jpegthumbnail() { - _impl_.jpegthumbnail_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000800u; -} -inline const std::string& Message_DocumentMessage::jpegthumbnail() const { - // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.jpegThumbnail) - return _internal_jpegthumbnail(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_DocumentMessage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000800u; - _impl_.jpegthumbnail_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.jpegThumbnail) -} -inline std::string* Message_DocumentMessage::mutable_jpegthumbnail() { - std::string* _s = _internal_mutable_jpegthumbnail(); - // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.jpegThumbnail) - return _s; -} -inline const std::string& Message_DocumentMessage::_internal_jpegthumbnail() const { - return _impl_.jpegthumbnail_.Get(); -} -inline void Message_DocumentMessage::_internal_set_jpegthumbnail(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000800u; - _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_DocumentMessage::_internal_mutable_jpegthumbnail() { - _impl_._has_bits_[0] |= 0x00000800u; - return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_DocumentMessage::release_jpegthumbnail() { - // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.jpegThumbnail) - if (!_internal_has_jpegthumbnail()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000800u; - auto* p = _impl_.jpegthumbnail_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.jpegthumbnail_.IsDefault()) { - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_DocumentMessage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) { - if (jpegthumbnail != nullptr) { - _impl_._has_bits_[0] |= 0x00000800u; - } else { - _impl_._has_bits_[0] &= ~0x00000800u; - } - _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.jpegthumbnail_.IsDefault()) { - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.jpegThumbnail) -} - -// optional .proto.ContextInfo contextInfo = 17; -inline bool Message_DocumentMessage::_internal_has_contextinfo() const { - bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); - return value; -} -inline bool Message_DocumentMessage::has_contextinfo() const { - return _internal_has_contextinfo(); -} -inline void Message_DocumentMessage::clear_contextinfo() { - if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); - _impl_._has_bits_[0] &= ~0x00002000u; -} -inline const ::proto::ContextInfo& Message_DocumentMessage::_internal_contextinfo() const { - const ::proto::ContextInfo* p = _impl_.contextinfo_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ContextInfo_default_instance_); -} -inline const ::proto::ContextInfo& Message_DocumentMessage::contextinfo() const { - // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.contextInfo) - return _internal_contextinfo(); -} -inline void Message_DocumentMessage::unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); - } - _impl_.contextinfo_ = contextinfo; - if (contextinfo) { - _impl_._has_bits_[0] |= 0x00002000u; - } else { - _impl_._has_bits_[0] &= ~0x00002000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.DocumentMessage.contextInfo) -} -inline ::proto::ContextInfo* Message_DocumentMessage::release_contextinfo() { - _impl_._has_bits_[0] &= ~0x00002000u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ContextInfo* Message_DocumentMessage::unsafe_arena_release_contextinfo() { - // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.contextInfo) - _impl_._has_bits_[0] &= ~0x00002000u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; - return temp; -} -inline ::proto::ContextInfo* Message_DocumentMessage::_internal_mutable_contextinfo() { - _impl_._has_bits_[0] |= 0x00002000u; - if (_impl_.contextinfo_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); - _impl_.contextinfo_ = p; - } - return _impl_.contextinfo_; -} -inline ::proto::ContextInfo* Message_DocumentMessage::mutable_contextinfo() { - ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); - // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.contextInfo) - return _msg; -} -inline void Message_DocumentMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.contextinfo_; - } - if (contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); - if (message_arena != submessage_arena) { - contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, contextinfo, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00002000u; - } else { - _impl_._has_bits_[0] &= ~0x00002000u; - } - _impl_.contextinfo_ = contextinfo; - // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.contextInfo) -} - -// optional uint32 thumbnailHeight = 18; -inline bool Message_DocumentMessage::_internal_has_thumbnailheight() const { - bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0; - return value; -} -inline bool Message_DocumentMessage::has_thumbnailheight() const { - return _internal_has_thumbnailheight(); -} -inline void Message_DocumentMessage::clear_thumbnailheight() { - _impl_.thumbnailheight_ = 0u; - _impl_._has_bits_[0] &= ~0x00040000u; -} -inline uint32_t Message_DocumentMessage::_internal_thumbnailheight() const { - return _impl_.thumbnailheight_; -} -inline uint32_t Message_DocumentMessage::thumbnailheight() const { - // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.thumbnailHeight) - return _internal_thumbnailheight(); -} -inline void Message_DocumentMessage::_internal_set_thumbnailheight(uint32_t value) { - _impl_._has_bits_[0] |= 0x00040000u; - _impl_.thumbnailheight_ = value; -} -inline void Message_DocumentMessage::set_thumbnailheight(uint32_t value) { - _internal_set_thumbnailheight(value); - // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.thumbnailHeight) -} - -// optional uint32 thumbnailWidth = 19; -inline bool Message_DocumentMessage::_internal_has_thumbnailwidth() const { - bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0; - return value; -} -inline bool Message_DocumentMessage::has_thumbnailwidth() const { - return _internal_has_thumbnailwidth(); -} -inline void Message_DocumentMessage::clear_thumbnailwidth() { - _impl_.thumbnailwidth_ = 0u; - _impl_._has_bits_[0] &= ~0x00080000u; -} -inline uint32_t Message_DocumentMessage::_internal_thumbnailwidth() const { - return _impl_.thumbnailwidth_; -} -inline uint32_t Message_DocumentMessage::thumbnailwidth() const { - // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.thumbnailWidth) - return _internal_thumbnailwidth(); -} -inline void Message_DocumentMessage::_internal_set_thumbnailwidth(uint32_t value) { - _impl_._has_bits_[0] |= 0x00080000u; - _impl_.thumbnailwidth_ = value; -} -inline void Message_DocumentMessage::set_thumbnailwidth(uint32_t value) { - _internal_set_thumbnailwidth(value); - // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.thumbnailWidth) -} - -// optional string caption = 20; -inline bool Message_DocumentMessage::_internal_has_caption() const { - bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; - return value; -} -inline bool Message_DocumentMessage::has_caption() const { - return _internal_has_caption(); -} -inline void Message_DocumentMessage::clear_caption() { - _impl_.caption_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00001000u; -} -inline const std::string& Message_DocumentMessage::caption() const { - // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.caption) - return _internal_caption(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_DocumentMessage::set_caption(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00001000u; - _impl_.caption_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.caption) -} -inline std::string* Message_DocumentMessage::mutable_caption() { - std::string* _s = _internal_mutable_caption(); - // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.caption) - return _s; -} -inline const std::string& Message_DocumentMessage::_internal_caption() const { - return _impl_.caption_.Get(); -} -inline void Message_DocumentMessage::_internal_set_caption(const std::string& value) { - _impl_._has_bits_[0] |= 0x00001000u; - _impl_.caption_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_DocumentMessage::_internal_mutable_caption() { - _impl_._has_bits_[0] |= 0x00001000u; - return _impl_.caption_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_DocumentMessage::release_caption() { - // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.caption) - if (!_internal_has_caption()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00001000u; - auto* p = _impl_.caption_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.caption_.IsDefault()) { - _impl_.caption_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_DocumentMessage::set_allocated_caption(std::string* caption) { - if (caption != nullptr) { - _impl_._has_bits_[0] |= 0x00001000u; - } else { - _impl_._has_bits_[0] &= ~0x00001000u; - } - _impl_.caption_.SetAllocated(caption, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.caption_.IsDefault()) { - _impl_.caption_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.caption) -} - -// ------------------------------------------------------------------- - -// Message_ExtendedTextMessage - -// optional string text = 1; -inline bool Message_ExtendedTextMessage::_internal_has_text() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_ExtendedTextMessage::has_text() const { - return _internal_has_text(); -} -inline void Message_ExtendedTextMessage::clear_text() { - _impl_.text_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_ExtendedTextMessage::text() const { - // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.text) - return _internal_text(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ExtendedTextMessage::set_text(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.text_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.text) -} -inline std::string* Message_ExtendedTextMessage::mutable_text() { - std::string* _s = _internal_mutable_text(); - // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.text) - return _s; -} -inline const std::string& Message_ExtendedTextMessage::_internal_text() const { - return _impl_.text_.Get(); -} -inline void Message_ExtendedTextMessage::_internal_set_text(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.text_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ExtendedTextMessage::_internal_mutable_text() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.text_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ExtendedTextMessage::release_text() { - // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.text) - if (!_internal_has_text()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.text_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.text_.IsDefault()) { - _impl_.text_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ExtendedTextMessage::set_allocated_text(std::string* text) { - if (text != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.text_.SetAllocated(text, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.text_.IsDefault()) { - _impl_.text_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.text) -} - -// optional string matchedText = 2; -inline bool Message_ExtendedTextMessage::_internal_has_matchedtext() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_ExtendedTextMessage::has_matchedtext() const { - return _internal_has_matchedtext(); -} -inline void Message_ExtendedTextMessage::clear_matchedtext() { - _impl_.matchedtext_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_ExtendedTextMessage::matchedtext() const { - // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.matchedText) - return _internal_matchedtext(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ExtendedTextMessage::set_matchedtext(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.matchedtext_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.matchedText) -} -inline std::string* Message_ExtendedTextMessage::mutable_matchedtext() { - std::string* _s = _internal_mutable_matchedtext(); - // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.matchedText) - return _s; -} -inline const std::string& Message_ExtendedTextMessage::_internal_matchedtext() const { - return _impl_.matchedtext_.Get(); -} -inline void Message_ExtendedTextMessage::_internal_set_matchedtext(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.matchedtext_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ExtendedTextMessage::_internal_mutable_matchedtext() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.matchedtext_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ExtendedTextMessage::release_matchedtext() { - // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.matchedText) - if (!_internal_has_matchedtext()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.matchedtext_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.matchedtext_.IsDefault()) { - _impl_.matchedtext_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ExtendedTextMessage::set_allocated_matchedtext(std::string* matchedtext) { - if (matchedtext != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.matchedtext_.SetAllocated(matchedtext, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.matchedtext_.IsDefault()) { - _impl_.matchedtext_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.matchedText) -} - -// optional string canonicalUrl = 4; -inline bool Message_ExtendedTextMessage::_internal_has_canonicalurl() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool Message_ExtendedTextMessage::has_canonicalurl() const { - return _internal_has_canonicalurl(); -} -inline void Message_ExtendedTextMessage::clear_canonicalurl() { - _impl_.canonicalurl_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& Message_ExtendedTextMessage::canonicalurl() const { - // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.canonicalUrl) - return _internal_canonicalurl(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ExtendedTextMessage::set_canonicalurl(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.canonicalurl_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.canonicalUrl) -} -inline std::string* Message_ExtendedTextMessage::mutable_canonicalurl() { - std::string* _s = _internal_mutable_canonicalurl(); - // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.canonicalUrl) - return _s; -} -inline const std::string& Message_ExtendedTextMessage::_internal_canonicalurl() const { - return _impl_.canonicalurl_.Get(); -} -inline void Message_ExtendedTextMessage::_internal_set_canonicalurl(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.canonicalurl_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ExtendedTextMessage::_internal_mutable_canonicalurl() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.canonicalurl_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ExtendedTextMessage::release_canonicalurl() { - // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.canonicalUrl) - if (!_internal_has_canonicalurl()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.canonicalurl_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.canonicalurl_.IsDefault()) { - _impl_.canonicalurl_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ExtendedTextMessage::set_allocated_canonicalurl(std::string* canonicalurl) { - if (canonicalurl != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.canonicalurl_.SetAllocated(canonicalurl, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.canonicalurl_.IsDefault()) { - _impl_.canonicalurl_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.canonicalUrl) -} - -// optional string description = 5; -inline bool Message_ExtendedTextMessage::_internal_has_description() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool Message_ExtendedTextMessage::has_description() const { - return _internal_has_description(); -} -inline void Message_ExtendedTextMessage::clear_description() { - _impl_.description_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const std::string& Message_ExtendedTextMessage::description() const { - // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.description) - return _internal_description(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ExtendedTextMessage::set_description(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.description_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.description) -} -inline std::string* Message_ExtendedTextMessage::mutable_description() { - std::string* _s = _internal_mutable_description(); - // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.description) - return _s; -} -inline const std::string& Message_ExtendedTextMessage::_internal_description() const { - return _impl_.description_.Get(); -} -inline void Message_ExtendedTextMessage::_internal_set_description(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.description_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ExtendedTextMessage::_internal_mutable_description() { - _impl_._has_bits_[0] |= 0x00000008u; - return _impl_.description_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ExtendedTextMessage::release_description() { - // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.description) - if (!_internal_has_description()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000008u; - auto* p = _impl_.description_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.description_.IsDefault()) { - _impl_.description_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ExtendedTextMessage::set_allocated_description(std::string* description) { - if (description != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.description_.SetAllocated(description, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.description_.IsDefault()) { - _impl_.description_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.description) -} - -// optional string title = 6; -inline bool Message_ExtendedTextMessage::_internal_has_title() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool Message_ExtendedTextMessage::has_title() const { - return _internal_has_title(); -} -inline void Message_ExtendedTextMessage::clear_title() { - _impl_.title_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const std::string& Message_ExtendedTextMessage::title() const { - // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.title) - return _internal_title(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ExtendedTextMessage::set_title(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.title_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.title) -} -inline std::string* Message_ExtendedTextMessage::mutable_title() { - std::string* _s = _internal_mutable_title(); - // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.title) - return _s; -} -inline const std::string& Message_ExtendedTextMessage::_internal_title() const { - return _impl_.title_.Get(); -} -inline void Message_ExtendedTextMessage::_internal_set_title(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.title_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ExtendedTextMessage::_internal_mutable_title() { - _impl_._has_bits_[0] |= 0x00000010u; - return _impl_.title_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ExtendedTextMessage::release_title() { - // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.title) - if (!_internal_has_title()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000010u; - auto* p = _impl_.title_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.title_.IsDefault()) { - _impl_.title_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ExtendedTextMessage::set_allocated_title(std::string* title) { - if (title != nullptr) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.title_.SetAllocated(title, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.title_.IsDefault()) { - _impl_.title_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.title) -} - -// optional fixed32 textArgb = 7; -inline bool Message_ExtendedTextMessage::_internal_has_textargb() const { - bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0; - return value; -} -inline bool Message_ExtendedTextMessage::has_textargb() const { - return _internal_has_textargb(); -} -inline void Message_ExtendedTextMessage::clear_textargb() { - _impl_.textargb_ = 0u; - _impl_._has_bits_[0] &= ~0x00002000u; -} -inline uint32_t Message_ExtendedTextMessage::_internal_textargb() const { - return _impl_.textargb_; -} -inline uint32_t Message_ExtendedTextMessage::textargb() const { - // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.textArgb) - return _internal_textargb(); -} -inline void Message_ExtendedTextMessage::_internal_set_textargb(uint32_t value) { - _impl_._has_bits_[0] |= 0x00002000u; - _impl_.textargb_ = value; -} -inline void Message_ExtendedTextMessage::set_textargb(uint32_t value) { - _internal_set_textargb(value); - // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.textArgb) -} - -// optional fixed32 backgroundArgb = 8; -inline bool Message_ExtendedTextMessage::_internal_has_backgroundargb() const { - bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0; - return value; -} -inline bool Message_ExtendedTextMessage::has_backgroundargb() const { - return _internal_has_backgroundargb(); -} -inline void Message_ExtendedTextMessage::clear_backgroundargb() { - _impl_.backgroundargb_ = 0u; - _impl_._has_bits_[0] &= ~0x00004000u; -} -inline uint32_t Message_ExtendedTextMessage::_internal_backgroundargb() const { - return _impl_.backgroundargb_; -} -inline uint32_t Message_ExtendedTextMessage::backgroundargb() const { - // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.backgroundArgb) - return _internal_backgroundargb(); -} -inline void Message_ExtendedTextMessage::_internal_set_backgroundargb(uint32_t value) { - _impl_._has_bits_[0] |= 0x00004000u; - _impl_.backgroundargb_ = value; -} -inline void Message_ExtendedTextMessage::set_backgroundargb(uint32_t value) { - _internal_set_backgroundargb(value); - // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.backgroundArgb) -} - -// optional .proto.Message.ExtendedTextMessage.FontType font = 9; -inline bool Message_ExtendedTextMessage::_internal_has_font() const { - bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0; - return value; -} -inline bool Message_ExtendedTextMessage::has_font() const { - return _internal_has_font(); -} -inline void Message_ExtendedTextMessage::clear_font() { - _impl_.font_ = 0; - _impl_._has_bits_[0] &= ~0x00008000u; -} -inline ::proto::Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::_internal_font() const { - return static_cast< ::proto::Message_ExtendedTextMessage_FontType >(_impl_.font_); -} -inline ::proto::Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::font() const { - // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.font) - return _internal_font(); -} -inline void Message_ExtendedTextMessage::_internal_set_font(::proto::Message_ExtendedTextMessage_FontType value) { - assert(::proto::Message_ExtendedTextMessage_FontType_IsValid(value)); - _impl_._has_bits_[0] |= 0x00008000u; - _impl_.font_ = value; -} -inline void Message_ExtendedTextMessage::set_font(::proto::Message_ExtendedTextMessage_FontType value) { - _internal_set_font(value); - // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.font) -} - -// optional .proto.Message.ExtendedTextMessage.PreviewType previewType = 10; -inline bool Message_ExtendedTextMessage::_internal_has_previewtype() const { - bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0; - return value; -} -inline bool Message_ExtendedTextMessage::has_previewtype() const { - return _internal_has_previewtype(); -} -inline void Message_ExtendedTextMessage::clear_previewtype() { - _impl_.previewtype_ = 0; - _impl_._has_bits_[0] &= ~0x00010000u; -} -inline ::proto::Message_ExtendedTextMessage_PreviewType Message_ExtendedTextMessage::_internal_previewtype() const { - return static_cast< ::proto::Message_ExtendedTextMessage_PreviewType >(_impl_.previewtype_); -} -inline ::proto::Message_ExtendedTextMessage_PreviewType Message_ExtendedTextMessage::previewtype() const { - // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.previewType) - return _internal_previewtype(); -} -inline void Message_ExtendedTextMessage::_internal_set_previewtype(::proto::Message_ExtendedTextMessage_PreviewType value) { - assert(::proto::Message_ExtendedTextMessage_PreviewType_IsValid(value)); - _impl_._has_bits_[0] |= 0x00010000u; - _impl_.previewtype_ = value; -} -inline void Message_ExtendedTextMessage::set_previewtype(::proto::Message_ExtendedTextMessage_PreviewType value) { - _internal_set_previewtype(value); - // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.previewType) -} - -// optional bytes jpegThumbnail = 16; -inline bool Message_ExtendedTextMessage::_internal_has_jpegthumbnail() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool Message_ExtendedTextMessage::has_jpegthumbnail() const { - return _internal_has_jpegthumbnail(); -} -inline void Message_ExtendedTextMessage::clear_jpegthumbnail() { - _impl_.jpegthumbnail_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline const std::string& Message_ExtendedTextMessage::jpegthumbnail() const { - // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.jpegThumbnail) - return _internal_jpegthumbnail(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ExtendedTextMessage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.jpegthumbnail_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.jpegThumbnail) -} -inline std::string* Message_ExtendedTextMessage::mutable_jpegthumbnail() { - std::string* _s = _internal_mutable_jpegthumbnail(); - // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.jpegThumbnail) - return _s; -} -inline const std::string& Message_ExtendedTextMessage::_internal_jpegthumbnail() const { - return _impl_.jpegthumbnail_.Get(); -} -inline void Message_ExtendedTextMessage::_internal_set_jpegthumbnail(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ExtendedTextMessage::_internal_mutable_jpegthumbnail() { - _impl_._has_bits_[0] |= 0x00000020u; - return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ExtendedTextMessage::release_jpegthumbnail() { - // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.jpegThumbnail) - if (!_internal_has_jpegthumbnail()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000020u; - auto* p = _impl_.jpegthumbnail_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.jpegthumbnail_.IsDefault()) { - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ExtendedTextMessage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) { - if (jpegthumbnail != nullptr) { - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.jpegthumbnail_.IsDefault()) { - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.jpegThumbnail) -} - -// optional .proto.ContextInfo contextInfo = 17; -inline bool Message_ExtendedTextMessage::_internal_has_contextinfo() const { - bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); - return value; -} -inline bool Message_ExtendedTextMessage::has_contextinfo() const { - return _internal_has_contextinfo(); -} -inline void Message_ExtendedTextMessage::clear_contextinfo() { - if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); - _impl_._has_bits_[0] &= ~0x00001000u; -} -inline const ::proto::ContextInfo& Message_ExtendedTextMessage::_internal_contextinfo() const { - const ::proto::ContextInfo* p = _impl_.contextinfo_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ContextInfo_default_instance_); -} -inline const ::proto::ContextInfo& Message_ExtendedTextMessage::contextinfo() const { - // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.contextInfo) - return _internal_contextinfo(); -} -inline void Message_ExtendedTextMessage::unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); - } - _impl_.contextinfo_ = contextinfo; - if (contextinfo) { - _impl_._has_bits_[0] |= 0x00001000u; - } else { - _impl_._has_bits_[0] &= ~0x00001000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ExtendedTextMessage.contextInfo) -} -inline ::proto::ContextInfo* Message_ExtendedTextMessage::release_contextinfo() { - _impl_._has_bits_[0] &= ~0x00001000u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ContextInfo* Message_ExtendedTextMessage::unsafe_arena_release_contextinfo() { - // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.contextInfo) - _impl_._has_bits_[0] &= ~0x00001000u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; - return temp; -} -inline ::proto::ContextInfo* Message_ExtendedTextMessage::_internal_mutable_contextinfo() { - _impl_._has_bits_[0] |= 0x00001000u; - if (_impl_.contextinfo_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); - _impl_.contextinfo_ = p; - } - return _impl_.contextinfo_; -} -inline ::proto::ContextInfo* Message_ExtendedTextMessage::mutable_contextinfo() { - ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); - // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.contextInfo) - return _msg; -} -inline void Message_ExtendedTextMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.contextinfo_; - } - if (contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); - if (message_arena != submessage_arena) { - contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, contextinfo, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00001000u; - } else { - _impl_._has_bits_[0] &= ~0x00001000u; - } - _impl_.contextinfo_ = contextinfo; - // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.contextInfo) -} - -// optional bool doNotPlayInline = 18; -inline bool Message_ExtendedTextMessage::_internal_has_donotplayinline() const { - bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0; - return value; -} -inline bool Message_ExtendedTextMessage::has_donotplayinline() const { - return _internal_has_donotplayinline(); -} -inline void Message_ExtendedTextMessage::clear_donotplayinline() { - _impl_.donotplayinline_ = false; - _impl_._has_bits_[0] &= ~0x00020000u; -} -inline bool Message_ExtendedTextMessage::_internal_donotplayinline() const { - return _impl_.donotplayinline_; -} -inline bool Message_ExtendedTextMessage::donotplayinline() const { - // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.doNotPlayInline) - return _internal_donotplayinline(); -} -inline void Message_ExtendedTextMessage::_internal_set_donotplayinline(bool value) { - _impl_._has_bits_[0] |= 0x00020000u; - _impl_.donotplayinline_ = value; -} -inline void Message_ExtendedTextMessage::set_donotplayinline(bool value) { - _internal_set_donotplayinline(value); - // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.doNotPlayInline) -} - -// optional string thumbnailDirectPath = 19; -inline bool Message_ExtendedTextMessage::_internal_has_thumbnaildirectpath() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool Message_ExtendedTextMessage::has_thumbnaildirectpath() const { - return _internal_has_thumbnaildirectpath(); -} -inline void Message_ExtendedTextMessage::clear_thumbnaildirectpath() { - _impl_.thumbnaildirectpath_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline const std::string& Message_ExtendedTextMessage::thumbnaildirectpath() const { - // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.thumbnailDirectPath) - return _internal_thumbnaildirectpath(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ExtendedTextMessage::set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.thumbnaildirectpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.thumbnailDirectPath) -} -inline std::string* Message_ExtendedTextMessage::mutable_thumbnaildirectpath() { - std::string* _s = _internal_mutable_thumbnaildirectpath(); - // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.thumbnailDirectPath) - return _s; -} -inline const std::string& Message_ExtendedTextMessage::_internal_thumbnaildirectpath() const { - return _impl_.thumbnaildirectpath_.Get(); -} -inline void Message_ExtendedTextMessage::_internal_set_thumbnaildirectpath(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.thumbnaildirectpath_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ExtendedTextMessage::_internal_mutable_thumbnaildirectpath() { - _impl_._has_bits_[0] |= 0x00000040u; - return _impl_.thumbnaildirectpath_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ExtendedTextMessage::release_thumbnaildirectpath() { - // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.thumbnailDirectPath) - if (!_internal_has_thumbnaildirectpath()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000040u; - auto* p = _impl_.thumbnaildirectpath_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.thumbnaildirectpath_.IsDefault()) { - _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ExtendedTextMessage::set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath) { - if (thumbnaildirectpath != nullptr) { - _impl_._has_bits_[0] |= 0x00000040u; - } else { - _impl_._has_bits_[0] &= ~0x00000040u; - } - _impl_.thumbnaildirectpath_.SetAllocated(thumbnaildirectpath, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.thumbnaildirectpath_.IsDefault()) { - _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.thumbnailDirectPath) -} - -// optional bytes thumbnailSha256 = 20; -inline bool Message_ExtendedTextMessage::_internal_has_thumbnailsha256() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - return value; -} -inline bool Message_ExtendedTextMessage::has_thumbnailsha256() const { - return _internal_has_thumbnailsha256(); -} -inline void Message_ExtendedTextMessage::clear_thumbnailsha256() { - _impl_.thumbnailsha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline const std::string& Message_ExtendedTextMessage::thumbnailsha256() const { - // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.thumbnailSha256) - return _internal_thumbnailsha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ExtendedTextMessage::set_thumbnailsha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.thumbnailsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.thumbnailSha256) -} -inline std::string* Message_ExtendedTextMessage::mutable_thumbnailsha256() { - std::string* _s = _internal_mutable_thumbnailsha256(); - // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.thumbnailSha256) - return _s; -} -inline const std::string& Message_ExtendedTextMessage::_internal_thumbnailsha256() const { - return _impl_.thumbnailsha256_.Get(); -} -inline void Message_ExtendedTextMessage::_internal_set_thumbnailsha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.thumbnailsha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ExtendedTextMessage::_internal_mutable_thumbnailsha256() { - _impl_._has_bits_[0] |= 0x00000080u; - return _impl_.thumbnailsha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ExtendedTextMessage::release_thumbnailsha256() { - // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.thumbnailSha256) - if (!_internal_has_thumbnailsha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000080u; - auto* p = _impl_.thumbnailsha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.thumbnailsha256_.IsDefault()) { - _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ExtendedTextMessage::set_allocated_thumbnailsha256(std::string* thumbnailsha256) { - if (thumbnailsha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00000080u; - } else { - _impl_._has_bits_[0] &= ~0x00000080u; - } - _impl_.thumbnailsha256_.SetAllocated(thumbnailsha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.thumbnailsha256_.IsDefault()) { - _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.thumbnailSha256) -} - -// optional bytes thumbnailEncSha256 = 21; -inline bool Message_ExtendedTextMessage::_internal_has_thumbnailencsha256() const { - bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; - return value; -} -inline bool Message_ExtendedTextMessage::has_thumbnailencsha256() const { - return _internal_has_thumbnailencsha256(); -} -inline void Message_ExtendedTextMessage::clear_thumbnailencsha256() { - _impl_.thumbnailencsha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000100u; -} -inline const std::string& Message_ExtendedTextMessage::thumbnailencsha256() const { - // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.thumbnailEncSha256) - return _internal_thumbnailencsha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ExtendedTextMessage::set_thumbnailencsha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000100u; - _impl_.thumbnailencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.thumbnailEncSha256) -} -inline std::string* Message_ExtendedTextMessage::mutable_thumbnailencsha256() { - std::string* _s = _internal_mutable_thumbnailencsha256(); - // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.thumbnailEncSha256) - return _s; -} -inline const std::string& Message_ExtendedTextMessage::_internal_thumbnailencsha256() const { - return _impl_.thumbnailencsha256_.Get(); -} -inline void Message_ExtendedTextMessage::_internal_set_thumbnailencsha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000100u; - _impl_.thumbnailencsha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ExtendedTextMessage::_internal_mutable_thumbnailencsha256() { - _impl_._has_bits_[0] |= 0x00000100u; - return _impl_.thumbnailencsha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ExtendedTextMessage::release_thumbnailencsha256() { - // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.thumbnailEncSha256) - if (!_internal_has_thumbnailencsha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000100u; - auto* p = _impl_.thumbnailencsha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.thumbnailencsha256_.IsDefault()) { - _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ExtendedTextMessage::set_allocated_thumbnailencsha256(std::string* thumbnailencsha256) { - if (thumbnailencsha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00000100u; - } else { - _impl_._has_bits_[0] &= ~0x00000100u; - } - _impl_.thumbnailencsha256_.SetAllocated(thumbnailencsha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.thumbnailencsha256_.IsDefault()) { - _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.thumbnailEncSha256) -} - -// optional bytes mediaKey = 22; -inline bool Message_ExtendedTextMessage::_internal_has_mediakey() const { - bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; - return value; -} -inline bool Message_ExtendedTextMessage::has_mediakey() const { - return _internal_has_mediakey(); -} -inline void Message_ExtendedTextMessage::clear_mediakey() { - _impl_.mediakey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000200u; -} -inline const std::string& Message_ExtendedTextMessage::mediakey() const { - // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.mediaKey) - return _internal_mediakey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ExtendedTextMessage::set_mediakey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.mediakey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.mediaKey) -} -inline std::string* Message_ExtendedTextMessage::mutable_mediakey() { - std::string* _s = _internal_mutable_mediakey(); - // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.mediaKey) - return _s; -} -inline const std::string& Message_ExtendedTextMessage::_internal_mediakey() const { - return _impl_.mediakey_.Get(); -} -inline void Message_ExtendedTextMessage::_internal_set_mediakey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.mediakey_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ExtendedTextMessage::_internal_mutable_mediakey() { - _impl_._has_bits_[0] |= 0x00000200u; - return _impl_.mediakey_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ExtendedTextMessage::release_mediakey() { - // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.mediaKey) - if (!_internal_has_mediakey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000200u; - auto* p = _impl_.mediakey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mediakey_.IsDefault()) { - _impl_.mediakey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ExtendedTextMessage::set_allocated_mediakey(std::string* mediakey) { - if (mediakey != nullptr) { - _impl_._has_bits_[0] |= 0x00000200u; - } else { - _impl_._has_bits_[0] &= ~0x00000200u; - } - _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mediakey_.IsDefault()) { - _impl_.mediakey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.mediaKey) -} - -// optional int64 mediaKeyTimestamp = 23; -inline bool Message_ExtendedTextMessage::_internal_has_mediakeytimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0; - return value; -} -inline bool Message_ExtendedTextMessage::has_mediakeytimestamp() const { - return _internal_has_mediakeytimestamp(); -} -inline void Message_ExtendedTextMessage::clear_mediakeytimestamp() { - _impl_.mediakeytimestamp_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00080000u; -} -inline int64_t Message_ExtendedTextMessage::_internal_mediakeytimestamp() const { - return _impl_.mediakeytimestamp_; -} -inline int64_t Message_ExtendedTextMessage::mediakeytimestamp() const { - // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.mediaKeyTimestamp) - return _internal_mediakeytimestamp(); -} -inline void Message_ExtendedTextMessage::_internal_set_mediakeytimestamp(int64_t value) { - _impl_._has_bits_[0] |= 0x00080000u; - _impl_.mediakeytimestamp_ = value; -} -inline void Message_ExtendedTextMessage::set_mediakeytimestamp(int64_t value) { - _internal_set_mediakeytimestamp(value); - // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.mediaKeyTimestamp) -} - -// optional uint32 thumbnailHeight = 24; -inline bool Message_ExtendedTextMessage::_internal_has_thumbnailheight() const { - bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0; - return value; -} -inline bool Message_ExtendedTextMessage::has_thumbnailheight() const { - return _internal_has_thumbnailheight(); -} -inline void Message_ExtendedTextMessage::clear_thumbnailheight() { - _impl_.thumbnailheight_ = 0u; - _impl_._has_bits_[0] &= ~0x00040000u; -} -inline uint32_t Message_ExtendedTextMessage::_internal_thumbnailheight() const { - return _impl_.thumbnailheight_; -} -inline uint32_t Message_ExtendedTextMessage::thumbnailheight() const { - // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.thumbnailHeight) - return _internal_thumbnailheight(); -} -inline void Message_ExtendedTextMessage::_internal_set_thumbnailheight(uint32_t value) { - _impl_._has_bits_[0] |= 0x00040000u; - _impl_.thumbnailheight_ = value; -} -inline void Message_ExtendedTextMessage::set_thumbnailheight(uint32_t value) { - _internal_set_thumbnailheight(value); - // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.thumbnailHeight) -} - -// optional uint32 thumbnailWidth = 25; -inline bool Message_ExtendedTextMessage::_internal_has_thumbnailwidth() const { - bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0; - return value; -} -inline bool Message_ExtendedTextMessage::has_thumbnailwidth() const { - return _internal_has_thumbnailwidth(); -} -inline void Message_ExtendedTextMessage::clear_thumbnailwidth() { - _impl_.thumbnailwidth_ = 0u; - _impl_._has_bits_[0] &= ~0x00100000u; -} -inline uint32_t Message_ExtendedTextMessage::_internal_thumbnailwidth() const { - return _impl_.thumbnailwidth_; -} -inline uint32_t Message_ExtendedTextMessage::thumbnailwidth() const { - // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.thumbnailWidth) - return _internal_thumbnailwidth(); -} -inline void Message_ExtendedTextMessage::_internal_set_thumbnailwidth(uint32_t value) { - _impl_._has_bits_[0] |= 0x00100000u; - _impl_.thumbnailwidth_ = value; -} -inline void Message_ExtendedTextMessage::set_thumbnailwidth(uint32_t value) { - _internal_set_thumbnailwidth(value); - // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.thumbnailWidth) -} - -// optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupType = 26; -inline bool Message_ExtendedTextMessage::_internal_has_invitelinkgrouptype() const { - bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0; - return value; -} -inline bool Message_ExtendedTextMessage::has_invitelinkgrouptype() const { - return _internal_has_invitelinkgrouptype(); -} -inline void Message_ExtendedTextMessage::clear_invitelinkgrouptype() { - _impl_.invitelinkgrouptype_ = 0; - _impl_._has_bits_[0] &= ~0x00200000u; -} -inline ::proto::Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::_internal_invitelinkgrouptype() const { - return static_cast< ::proto::Message_ExtendedTextMessage_InviteLinkGroupType >(_impl_.invitelinkgrouptype_); -} -inline ::proto::Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::invitelinkgrouptype() const { - // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.inviteLinkGroupType) - return _internal_invitelinkgrouptype(); -} -inline void Message_ExtendedTextMessage::_internal_set_invitelinkgrouptype(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value) { - assert(::proto::Message_ExtendedTextMessage_InviteLinkGroupType_IsValid(value)); - _impl_._has_bits_[0] |= 0x00200000u; - _impl_.invitelinkgrouptype_ = value; -} -inline void Message_ExtendedTextMessage::set_invitelinkgrouptype(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value) { - _internal_set_invitelinkgrouptype(value); - // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.inviteLinkGroupType) -} - -// optional string inviteLinkParentGroupSubjectV2 = 27; -inline bool Message_ExtendedTextMessage::_internal_has_invitelinkparentgroupsubjectv2() const { - bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; - return value; -} -inline bool Message_ExtendedTextMessage::has_invitelinkparentgroupsubjectv2() const { - return _internal_has_invitelinkparentgroupsubjectv2(); -} -inline void Message_ExtendedTextMessage::clear_invitelinkparentgroupsubjectv2() { - _impl_.invitelinkparentgroupsubjectv2_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000400u; -} -inline const std::string& Message_ExtendedTextMessage::invitelinkparentgroupsubjectv2() const { - // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.inviteLinkParentGroupSubjectV2) - return _internal_invitelinkparentgroupsubjectv2(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ExtendedTextMessage::set_invitelinkparentgroupsubjectv2(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000400u; - _impl_.invitelinkparentgroupsubjectv2_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.inviteLinkParentGroupSubjectV2) -} -inline std::string* Message_ExtendedTextMessage::mutable_invitelinkparentgroupsubjectv2() { - std::string* _s = _internal_mutable_invitelinkparentgroupsubjectv2(); - // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.inviteLinkParentGroupSubjectV2) - return _s; -} -inline const std::string& Message_ExtendedTextMessage::_internal_invitelinkparentgroupsubjectv2() const { - return _impl_.invitelinkparentgroupsubjectv2_.Get(); -} -inline void Message_ExtendedTextMessage::_internal_set_invitelinkparentgroupsubjectv2(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000400u; - _impl_.invitelinkparentgroupsubjectv2_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ExtendedTextMessage::_internal_mutable_invitelinkparentgroupsubjectv2() { - _impl_._has_bits_[0] |= 0x00000400u; - return _impl_.invitelinkparentgroupsubjectv2_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ExtendedTextMessage::release_invitelinkparentgroupsubjectv2() { - // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.inviteLinkParentGroupSubjectV2) - if (!_internal_has_invitelinkparentgroupsubjectv2()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000400u; - auto* p = _impl_.invitelinkparentgroupsubjectv2_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.invitelinkparentgroupsubjectv2_.IsDefault()) { - _impl_.invitelinkparentgroupsubjectv2_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ExtendedTextMessage::set_allocated_invitelinkparentgroupsubjectv2(std::string* invitelinkparentgroupsubjectv2) { - if (invitelinkparentgroupsubjectv2 != nullptr) { - _impl_._has_bits_[0] |= 0x00000400u; - } else { - _impl_._has_bits_[0] &= ~0x00000400u; - } - _impl_.invitelinkparentgroupsubjectv2_.SetAllocated(invitelinkparentgroupsubjectv2, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.invitelinkparentgroupsubjectv2_.IsDefault()) { - _impl_.invitelinkparentgroupsubjectv2_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.inviteLinkParentGroupSubjectV2) -} - -// optional bytes inviteLinkParentGroupThumbnailV2 = 28; -inline bool Message_ExtendedTextMessage::_internal_has_invitelinkparentgroupthumbnailv2() const { - bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; - return value; -} -inline bool Message_ExtendedTextMessage::has_invitelinkparentgroupthumbnailv2() const { - return _internal_has_invitelinkparentgroupthumbnailv2(); -} -inline void Message_ExtendedTextMessage::clear_invitelinkparentgroupthumbnailv2() { - _impl_.invitelinkparentgroupthumbnailv2_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000800u; -} -inline const std::string& Message_ExtendedTextMessage::invitelinkparentgroupthumbnailv2() const { - // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.inviteLinkParentGroupThumbnailV2) - return _internal_invitelinkparentgroupthumbnailv2(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ExtendedTextMessage::set_invitelinkparentgroupthumbnailv2(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000800u; - _impl_.invitelinkparentgroupthumbnailv2_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.inviteLinkParentGroupThumbnailV2) -} -inline std::string* Message_ExtendedTextMessage::mutable_invitelinkparentgroupthumbnailv2() { - std::string* _s = _internal_mutable_invitelinkparentgroupthumbnailv2(); - // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.inviteLinkParentGroupThumbnailV2) - return _s; -} -inline const std::string& Message_ExtendedTextMessage::_internal_invitelinkparentgroupthumbnailv2() const { - return _impl_.invitelinkparentgroupthumbnailv2_.Get(); -} -inline void Message_ExtendedTextMessage::_internal_set_invitelinkparentgroupthumbnailv2(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000800u; - _impl_.invitelinkparentgroupthumbnailv2_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ExtendedTextMessage::_internal_mutable_invitelinkparentgroupthumbnailv2() { - _impl_._has_bits_[0] |= 0x00000800u; - return _impl_.invitelinkparentgroupthumbnailv2_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ExtendedTextMessage::release_invitelinkparentgroupthumbnailv2() { - // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.inviteLinkParentGroupThumbnailV2) - if (!_internal_has_invitelinkparentgroupthumbnailv2()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000800u; - auto* p = _impl_.invitelinkparentgroupthumbnailv2_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.invitelinkparentgroupthumbnailv2_.IsDefault()) { - _impl_.invitelinkparentgroupthumbnailv2_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ExtendedTextMessage::set_allocated_invitelinkparentgroupthumbnailv2(std::string* invitelinkparentgroupthumbnailv2) { - if (invitelinkparentgroupthumbnailv2 != nullptr) { - _impl_._has_bits_[0] |= 0x00000800u; - } else { - _impl_._has_bits_[0] &= ~0x00000800u; - } - _impl_.invitelinkparentgroupthumbnailv2_.SetAllocated(invitelinkparentgroupthumbnailv2, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.invitelinkparentgroupthumbnailv2_.IsDefault()) { - _impl_.invitelinkparentgroupthumbnailv2_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.inviteLinkParentGroupThumbnailV2) -} - -// optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupTypeV2 = 29; -inline bool Message_ExtendedTextMessage::_internal_has_invitelinkgrouptypev2() const { - bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0; - return value; -} -inline bool Message_ExtendedTextMessage::has_invitelinkgrouptypev2() const { - return _internal_has_invitelinkgrouptypev2(); -} -inline void Message_ExtendedTextMessage::clear_invitelinkgrouptypev2() { - _impl_.invitelinkgrouptypev2_ = 0; - _impl_._has_bits_[0] &= ~0x00400000u; -} -inline ::proto::Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::_internal_invitelinkgrouptypev2() const { - return static_cast< ::proto::Message_ExtendedTextMessage_InviteLinkGroupType >(_impl_.invitelinkgrouptypev2_); -} -inline ::proto::Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::invitelinkgrouptypev2() const { - // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.inviteLinkGroupTypeV2) - return _internal_invitelinkgrouptypev2(); -} -inline void Message_ExtendedTextMessage::_internal_set_invitelinkgrouptypev2(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value) { - assert(::proto::Message_ExtendedTextMessage_InviteLinkGroupType_IsValid(value)); - _impl_._has_bits_[0] |= 0x00400000u; - _impl_.invitelinkgrouptypev2_ = value; -} -inline void Message_ExtendedTextMessage::set_invitelinkgrouptypev2(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value) { - _internal_set_invitelinkgrouptypev2(value); - // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.inviteLinkGroupTypeV2) -} - -// ------------------------------------------------------------------- - -// Message_FutureProofMessage - -// optional .proto.Message message = 1; -inline bool Message_FutureProofMessage::_internal_has_message() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.message_ != nullptr); - return value; -} -inline bool Message_FutureProofMessage::has_message() const { - return _internal_has_message(); -} -inline void Message_FutureProofMessage::clear_message() { - if (_impl_.message_ != nullptr) _impl_.message_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::Message& Message_FutureProofMessage::_internal_message() const { - const ::proto::Message* p = _impl_.message_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_default_instance_); -} -inline const ::proto::Message& Message_FutureProofMessage::message() const { - // @@protoc_insertion_point(field_get:proto.Message.FutureProofMessage.message) - return _internal_message(); -} -inline void Message_FutureProofMessage::unsafe_arena_set_allocated_message( - ::proto::Message* message) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.message_); - } - _impl_.message_ = message; - if (message) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.FutureProofMessage.message) -} -inline ::proto::Message* Message_FutureProofMessage::release_message() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::Message* temp = _impl_.message_; - _impl_.message_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message* Message_FutureProofMessage::unsafe_arena_release_message() { - // @@protoc_insertion_point(field_release:proto.Message.FutureProofMessage.message) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::Message* temp = _impl_.message_; - _impl_.message_ = nullptr; - return temp; -} -inline ::proto::Message* Message_FutureProofMessage::_internal_mutable_message() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.message_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message>(GetArenaForAllocation()); - _impl_.message_ = p; - } - return _impl_.message_; -} -inline ::proto::Message* Message_FutureProofMessage::mutable_message() { - ::proto::Message* _msg = _internal_mutable_message(); - // @@protoc_insertion_point(field_mutable:proto.Message.FutureProofMessage.message) - return _msg; -} -inline void Message_FutureProofMessage::set_allocated_message(::proto::Message* message) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.message_; - } - if (message) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(message); - if (message_arena != submessage_arena) { - message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, message, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.message_ = message; - // @@protoc_insertion_point(field_set_allocated:proto.Message.FutureProofMessage.message) -} - -// ------------------------------------------------------------------- - -// Message_GroupInviteMessage - -// optional string groupJid = 1; -inline bool Message_GroupInviteMessage::_internal_has_groupjid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_GroupInviteMessage::has_groupjid() const { - return _internal_has_groupjid(); -} -inline void Message_GroupInviteMessage::clear_groupjid() { - _impl_.groupjid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_GroupInviteMessage::groupjid() const { - // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.groupJid) - return _internal_groupjid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_GroupInviteMessage::set_groupjid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.groupjid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.GroupInviteMessage.groupJid) -} -inline std::string* Message_GroupInviteMessage::mutable_groupjid() { - std::string* _s = _internal_mutable_groupjid(); - // @@protoc_insertion_point(field_mutable:proto.Message.GroupInviteMessage.groupJid) - return _s; -} -inline const std::string& Message_GroupInviteMessage::_internal_groupjid() const { - return _impl_.groupjid_.Get(); -} -inline void Message_GroupInviteMessage::_internal_set_groupjid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.groupjid_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_GroupInviteMessage::_internal_mutable_groupjid() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.groupjid_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_GroupInviteMessage::release_groupjid() { - // @@protoc_insertion_point(field_release:proto.Message.GroupInviteMessage.groupJid) - if (!_internal_has_groupjid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.groupjid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.groupjid_.IsDefault()) { - _impl_.groupjid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_GroupInviteMessage::set_allocated_groupjid(std::string* groupjid) { - if (groupjid != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.groupjid_.SetAllocated(groupjid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.groupjid_.IsDefault()) { - _impl_.groupjid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.GroupInviteMessage.groupJid) -} - -// optional string inviteCode = 2; -inline bool Message_GroupInviteMessage::_internal_has_invitecode() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_GroupInviteMessage::has_invitecode() const { - return _internal_has_invitecode(); -} -inline void Message_GroupInviteMessage::clear_invitecode() { - _impl_.invitecode_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_GroupInviteMessage::invitecode() const { - // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.inviteCode) - return _internal_invitecode(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_GroupInviteMessage::set_invitecode(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.invitecode_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.GroupInviteMessage.inviteCode) -} -inline std::string* Message_GroupInviteMessage::mutable_invitecode() { - std::string* _s = _internal_mutable_invitecode(); - // @@protoc_insertion_point(field_mutable:proto.Message.GroupInviteMessage.inviteCode) - return _s; -} -inline const std::string& Message_GroupInviteMessage::_internal_invitecode() const { - return _impl_.invitecode_.Get(); -} -inline void Message_GroupInviteMessage::_internal_set_invitecode(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.invitecode_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_GroupInviteMessage::_internal_mutable_invitecode() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.invitecode_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_GroupInviteMessage::release_invitecode() { - // @@protoc_insertion_point(field_release:proto.Message.GroupInviteMessage.inviteCode) - if (!_internal_has_invitecode()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.invitecode_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.invitecode_.IsDefault()) { - _impl_.invitecode_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_GroupInviteMessage::set_allocated_invitecode(std::string* invitecode) { - if (invitecode != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.invitecode_.SetAllocated(invitecode, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.invitecode_.IsDefault()) { - _impl_.invitecode_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.GroupInviteMessage.inviteCode) -} - -// optional int64 inviteExpiration = 3; -inline bool Message_GroupInviteMessage::_internal_has_inviteexpiration() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool Message_GroupInviteMessage::has_inviteexpiration() const { - return _internal_has_inviteexpiration(); -} -inline void Message_GroupInviteMessage::clear_inviteexpiration() { - _impl_.inviteexpiration_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline int64_t Message_GroupInviteMessage::_internal_inviteexpiration() const { - return _impl_.inviteexpiration_; -} -inline int64_t Message_GroupInviteMessage::inviteexpiration() const { - // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.inviteExpiration) - return _internal_inviteexpiration(); -} -inline void Message_GroupInviteMessage::_internal_set_inviteexpiration(int64_t value) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.inviteexpiration_ = value; -} -inline void Message_GroupInviteMessage::set_inviteexpiration(int64_t value) { - _internal_set_inviteexpiration(value); - // @@protoc_insertion_point(field_set:proto.Message.GroupInviteMessage.inviteExpiration) -} - -// optional string groupName = 4; -inline bool Message_GroupInviteMessage::_internal_has_groupname() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool Message_GroupInviteMessage::has_groupname() const { - return _internal_has_groupname(); -} -inline void Message_GroupInviteMessage::clear_groupname() { - _impl_.groupname_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& Message_GroupInviteMessage::groupname() const { - // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.groupName) - return _internal_groupname(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_GroupInviteMessage::set_groupname(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.groupname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.GroupInviteMessage.groupName) -} -inline std::string* Message_GroupInviteMessage::mutable_groupname() { - std::string* _s = _internal_mutable_groupname(); - // @@protoc_insertion_point(field_mutable:proto.Message.GroupInviteMessage.groupName) - return _s; -} -inline const std::string& Message_GroupInviteMessage::_internal_groupname() const { - return _impl_.groupname_.Get(); -} -inline void Message_GroupInviteMessage::_internal_set_groupname(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.groupname_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_GroupInviteMessage::_internal_mutable_groupname() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.groupname_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_GroupInviteMessage::release_groupname() { - // @@protoc_insertion_point(field_release:proto.Message.GroupInviteMessage.groupName) - if (!_internal_has_groupname()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.groupname_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.groupname_.IsDefault()) { - _impl_.groupname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_GroupInviteMessage::set_allocated_groupname(std::string* groupname) { - if (groupname != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.groupname_.SetAllocated(groupname, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.groupname_.IsDefault()) { - _impl_.groupname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.GroupInviteMessage.groupName) -} - -// optional bytes jpegThumbnail = 5; -inline bool Message_GroupInviteMessage::_internal_has_jpegthumbnail() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool Message_GroupInviteMessage::has_jpegthumbnail() const { - return _internal_has_jpegthumbnail(); -} -inline void Message_GroupInviteMessage::clear_jpegthumbnail() { - _impl_.jpegthumbnail_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const std::string& Message_GroupInviteMessage::jpegthumbnail() const { - // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.jpegThumbnail) - return _internal_jpegthumbnail(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_GroupInviteMessage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.jpegthumbnail_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.GroupInviteMessage.jpegThumbnail) -} -inline std::string* Message_GroupInviteMessage::mutable_jpegthumbnail() { - std::string* _s = _internal_mutable_jpegthumbnail(); - // @@protoc_insertion_point(field_mutable:proto.Message.GroupInviteMessage.jpegThumbnail) - return _s; -} -inline const std::string& Message_GroupInviteMessage::_internal_jpegthumbnail() const { - return _impl_.jpegthumbnail_.Get(); -} -inline void Message_GroupInviteMessage::_internal_set_jpegthumbnail(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_GroupInviteMessage::_internal_mutable_jpegthumbnail() { - _impl_._has_bits_[0] |= 0x00000008u; - return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_GroupInviteMessage::release_jpegthumbnail() { - // @@protoc_insertion_point(field_release:proto.Message.GroupInviteMessage.jpegThumbnail) - if (!_internal_has_jpegthumbnail()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000008u; - auto* p = _impl_.jpegthumbnail_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.jpegthumbnail_.IsDefault()) { - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_GroupInviteMessage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) { - if (jpegthumbnail != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.jpegthumbnail_.IsDefault()) { - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.GroupInviteMessage.jpegThumbnail) -} - -// optional string caption = 6; -inline bool Message_GroupInviteMessage::_internal_has_caption() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool Message_GroupInviteMessage::has_caption() const { - return _internal_has_caption(); -} -inline void Message_GroupInviteMessage::clear_caption() { - _impl_.caption_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const std::string& Message_GroupInviteMessage::caption() const { - // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.caption) - return _internal_caption(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_GroupInviteMessage::set_caption(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.caption_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.GroupInviteMessage.caption) -} -inline std::string* Message_GroupInviteMessage::mutable_caption() { - std::string* _s = _internal_mutable_caption(); - // @@protoc_insertion_point(field_mutable:proto.Message.GroupInviteMessage.caption) - return _s; -} -inline const std::string& Message_GroupInviteMessage::_internal_caption() const { - return _impl_.caption_.Get(); -} -inline void Message_GroupInviteMessage::_internal_set_caption(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.caption_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_GroupInviteMessage::_internal_mutable_caption() { - _impl_._has_bits_[0] |= 0x00000010u; - return _impl_.caption_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_GroupInviteMessage::release_caption() { - // @@protoc_insertion_point(field_release:proto.Message.GroupInviteMessage.caption) - if (!_internal_has_caption()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000010u; - auto* p = _impl_.caption_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.caption_.IsDefault()) { - _impl_.caption_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_GroupInviteMessage::set_allocated_caption(std::string* caption) { - if (caption != nullptr) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.caption_.SetAllocated(caption, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.caption_.IsDefault()) { - _impl_.caption_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.GroupInviteMessage.caption) -} - -// optional .proto.ContextInfo contextInfo = 7; -inline bool Message_GroupInviteMessage::_internal_has_contextinfo() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); - return value; -} -inline bool Message_GroupInviteMessage::has_contextinfo() const { - return _internal_has_contextinfo(); -} -inline void Message_GroupInviteMessage::clear_contextinfo() { - if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline const ::proto::ContextInfo& Message_GroupInviteMessage::_internal_contextinfo() const { - const ::proto::ContextInfo* p = _impl_.contextinfo_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ContextInfo_default_instance_); -} -inline const ::proto::ContextInfo& Message_GroupInviteMessage::contextinfo() const { - // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.contextInfo) - return _internal_contextinfo(); -} -inline void Message_GroupInviteMessage::unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); - } - _impl_.contextinfo_ = contextinfo; - if (contextinfo) { - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.GroupInviteMessage.contextInfo) -} -inline ::proto::ContextInfo* Message_GroupInviteMessage::release_contextinfo() { - _impl_._has_bits_[0] &= ~0x00000020u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ContextInfo* Message_GroupInviteMessage::unsafe_arena_release_contextinfo() { - // @@protoc_insertion_point(field_release:proto.Message.GroupInviteMessage.contextInfo) - _impl_._has_bits_[0] &= ~0x00000020u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; - return temp; -} -inline ::proto::ContextInfo* Message_GroupInviteMessage::_internal_mutable_contextinfo() { - _impl_._has_bits_[0] |= 0x00000020u; - if (_impl_.contextinfo_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); - _impl_.contextinfo_ = p; - } - return _impl_.contextinfo_; -} -inline ::proto::ContextInfo* Message_GroupInviteMessage::mutable_contextinfo() { - ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); - // @@protoc_insertion_point(field_mutable:proto.Message.GroupInviteMessage.contextInfo) - return _msg; -} -inline void Message_GroupInviteMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.contextinfo_; - } - if (contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); - if (message_arena != submessage_arena) { - contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, contextinfo, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - _impl_.contextinfo_ = contextinfo; - // @@protoc_insertion_point(field_set_allocated:proto.Message.GroupInviteMessage.contextInfo) -} - -// optional .proto.Message.GroupInviteMessage.GroupType groupType = 8; -inline bool Message_GroupInviteMessage::_internal_has_grouptype() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - return value; -} -inline bool Message_GroupInviteMessage::has_grouptype() const { - return _internal_has_grouptype(); -} -inline void Message_GroupInviteMessage::clear_grouptype() { - _impl_.grouptype_ = 0; - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline ::proto::Message_GroupInviteMessage_GroupType Message_GroupInviteMessage::_internal_grouptype() const { - return static_cast< ::proto::Message_GroupInviteMessage_GroupType >(_impl_.grouptype_); -} -inline ::proto::Message_GroupInviteMessage_GroupType Message_GroupInviteMessage::grouptype() const { - // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.groupType) - return _internal_grouptype(); -} -inline void Message_GroupInviteMessage::_internal_set_grouptype(::proto::Message_GroupInviteMessage_GroupType value) { - assert(::proto::Message_GroupInviteMessage_GroupType_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.grouptype_ = value; -} -inline void Message_GroupInviteMessage::set_grouptype(::proto::Message_GroupInviteMessage_GroupType value) { - _internal_set_grouptype(value); - // @@protoc_insertion_point(field_set:proto.Message.GroupInviteMessage.groupType) -} - -// ------------------------------------------------------------------- - -// Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency - -// optional string currencyCode = 1; -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_internal_has_currencycode() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::has_currencycode() const { - return _internal_has_currencycode(); -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::clear_currencycode() { - _impl_.currencycode_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::currencycode() const { - // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.currencyCode) - return _internal_currencycode(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::set_currencycode(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.currencycode_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.currencyCode) -} -inline std::string* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::mutable_currencycode() { - std::string* _s = _internal_mutable_currencycode(); - // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.currencyCode) - return _s; -} -inline const std::string& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_internal_currencycode() const { - return _impl_.currencycode_.Get(); -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_internal_set_currencycode(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.currencycode_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_internal_mutable_currencycode() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.currencycode_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::release_currencycode() { - // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.currencyCode) - if (!_internal_has_currencycode()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.currencycode_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.currencycode_.IsDefault()) { - _impl_.currencycode_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::set_allocated_currencycode(std::string* currencycode) { - if (currencycode != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.currencycode_.SetAllocated(currencycode, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.currencycode_.IsDefault()) { - _impl_.currencycode_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.currencyCode) -} - -// optional int64 amount1000 = 2; -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_internal_has_amount1000() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::has_amount1000() const { - return _internal_has_amount1000(); -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::clear_amount1000() { - _impl_.amount1000_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline int64_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_internal_amount1000() const { - return _impl_.amount1000_; -} -inline int64_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::amount1000() const { - // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.amount1000) - return _internal_amount1000(); -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_internal_set_amount1000(int64_t value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.amount1000_ = value; -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::set_amount1000(int64_t value) { - _internal_set_amount1000(value); - // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.amount1000) -} - -// ------------------------------------------------------------------- - -// Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent - -// optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.DayOfWeekType dayOfWeek = 1; -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_has_dayofweek() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::has_dayofweek() const { - return _internal_has_dayofweek(); -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::clear_dayofweek() { - _impl_.dayofweek_ = 1; - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_dayofweek() const { - return static_cast< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType >(_impl_.dayofweek_); -} -inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::dayofweek() const { - // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.dayOfWeek) - return _internal_dayofweek(); -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_set_dayofweek(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType value) { - assert(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.dayofweek_ = value; -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::set_dayofweek(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType value) { - _internal_set_dayofweek(value); - // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.dayOfWeek) -} - -// optional uint32 year = 2; -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_has_year() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::has_year() const { - return _internal_has_year(); -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::clear_year() { - _impl_.year_ = 0u; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_year() const { - return _impl_.year_; -} -inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::year() const { - // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.year) - return _internal_year(); -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_set_year(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.year_ = value; -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::set_year(uint32_t value) { - _internal_set_year(value); - // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.year) -} - -// optional uint32 month = 3; -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_has_month() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::has_month() const { - return _internal_has_month(); -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::clear_month() { - _impl_.month_ = 0u; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_month() const { - return _impl_.month_; -} -inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::month() const { - // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.month) - return _internal_month(); -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_set_month(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.month_ = value; -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::set_month(uint32_t value) { - _internal_set_month(value); - // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.month) -} - -// optional uint32 dayOfMonth = 4; -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_has_dayofmonth() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::has_dayofmonth() const { - return _internal_has_dayofmonth(); -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::clear_dayofmonth() { - _impl_.dayofmonth_ = 0u; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_dayofmonth() const { - return _impl_.dayofmonth_; -} -inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::dayofmonth() const { - // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.dayOfMonth) - return _internal_dayofmonth(); -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_set_dayofmonth(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.dayofmonth_ = value; -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::set_dayofmonth(uint32_t value) { - _internal_set_dayofmonth(value); - // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.dayOfMonth) -} - -// optional uint32 hour = 5; -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_has_hour() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::has_hour() const { - return _internal_has_hour(); -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::clear_hour() { - _impl_.hour_ = 0u; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_hour() const { - return _impl_.hour_; -} -inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::hour() const { - // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.hour) - return _internal_hour(); -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_set_hour(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.hour_ = value; -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::set_hour(uint32_t value) { - _internal_set_hour(value); - // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.hour) -} - -// optional uint32 minute = 6; -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_has_minute() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::has_minute() const { - return _internal_has_minute(); -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::clear_minute() { - _impl_.minute_ = 0u; - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_minute() const { - return _impl_.minute_; -} -inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::minute() const { - // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.minute) - return _internal_minute(); -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_set_minute(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.minute_ = value; -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::set_minute(uint32_t value) { - _internal_set_minute(value); - // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.minute) -} - -// optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.CalendarType calendar = 7; -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_has_calendar() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::has_calendar() const { - return _internal_has_calendar(); -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::clear_calendar() { - _impl_.calendar_ = 1; - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_calendar() const { - return static_cast< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType >(_impl_.calendar_); -} -inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::calendar() const { - // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.calendar) - return _internal_calendar(); -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_set_calendar(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType value) { - assert(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.calendar_ = value; -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::set_calendar(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType value) { - _internal_set_calendar(value); - // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.calendar) -} - -// ------------------------------------------------------------------- - -// Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch - -// optional int64 timestamp = 1; -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::_internal_has_timestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::has_timestamp() const { - return _internal_has_timestamp(); -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::clear_timestamp() { - _impl_.timestamp_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline int64_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::_internal_timestamp() const { - return _impl_.timestamp_; -} -inline int64_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::timestamp() const { - // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch.timestamp) - return _internal_timestamp(); -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::_internal_set_timestamp(int64_t value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.timestamp_ = value; -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::set_timestamp(int64_t value) { - _internal_set_timestamp(value); - // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch.timestamp) -} - -// ------------------------------------------------------------------- - -// Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime - -// .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent component = 1; -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_internal_has_component() const { - return datetimeOneof_case() == kComponent; -} -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::has_component() const { - return _internal_has_component(); -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::set_has_component() { - _impl_._oneof_case_[0] = kComponent; -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::clear_component() { - if (_internal_has_component()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.datetimeOneof_.component_; - } - clear_has_datetimeOneof(); - } -} -inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::release_component() { - // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.component) - if (_internal_has_component()) { - clear_has_datetimeOneof(); - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* temp = _impl_.datetimeOneof_.component_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.datetimeOneof_.component_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_internal_component() const { - return _internal_has_component() - ? *_impl_.datetimeOneof_.component_ - : reinterpret_cast< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent&>(::proto::_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_default_instance_); -} -inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::component() const { - // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.component) - return _internal_component(); -} -inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::unsafe_arena_release_component() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.component) - if (_internal_has_component()) { - clear_has_datetimeOneof(); - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* temp = _impl_.datetimeOneof_.component_; - _impl_.datetimeOneof_.component_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::unsafe_arena_set_allocated_component(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* component) { - clear_datetimeOneof(); - if (component) { - set_has_component(); - _impl_.datetimeOneof_.component_ = component; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.component) -} -inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_internal_mutable_component() { - if (!_internal_has_component()) { - clear_datetimeOneof(); - set_has_component(); - _impl_.datetimeOneof_.component_ = CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent >(GetArenaForAllocation()); - } - return _impl_.datetimeOneof_.component_; -} -inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::mutable_component() { - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* _msg = _internal_mutable_component(); - // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.component) - return _msg; -} - -// .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch unixEpoch = 2; -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_internal_has_unixepoch() const { - return datetimeOneof_case() == kUnixEpoch; -} -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::has_unixepoch() const { - return _internal_has_unixepoch(); -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::set_has_unixepoch() { - _impl_._oneof_case_[0] = kUnixEpoch; -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::clear_unixepoch() { - if (_internal_has_unixepoch()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.datetimeOneof_.unixepoch_; - } - clear_has_datetimeOneof(); - } -} -inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::release_unixepoch() { - // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.unixEpoch) - if (_internal_has_unixepoch()) { - clear_has_datetimeOneof(); - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* temp = _impl_.datetimeOneof_.unixepoch_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.datetimeOneof_.unixepoch_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_internal_unixepoch() const { - return _internal_has_unixepoch() - ? *_impl_.datetimeOneof_.unixepoch_ - : reinterpret_cast< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch&>(::proto::_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch_default_instance_); -} -inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::unixepoch() const { - // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.unixEpoch) - return _internal_unixepoch(); -} -inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::unsafe_arena_release_unixepoch() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.unixEpoch) - if (_internal_has_unixepoch()) { - clear_has_datetimeOneof(); - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* temp = _impl_.datetimeOneof_.unixepoch_; - _impl_.datetimeOneof_.unixepoch_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::unsafe_arena_set_allocated_unixepoch(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* unixepoch) { - clear_datetimeOneof(); - if (unixepoch) { - set_has_unixepoch(); - _impl_.datetimeOneof_.unixepoch_ = unixepoch; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.unixEpoch) -} -inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_internal_mutable_unixepoch() { - if (!_internal_has_unixepoch()) { - clear_datetimeOneof(); - set_has_unixepoch(); - _impl_.datetimeOneof_.unixepoch_ = CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch >(GetArenaForAllocation()); - } - return _impl_.datetimeOneof_.unixepoch_; -} -inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::mutable_unixepoch() { - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* _msg = _internal_mutable_unixepoch(); - // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.unixEpoch) - return _msg; -} - -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::has_datetimeOneof() const { - return datetimeOneof_case() != DATETIMEONEOF_NOT_SET; -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::clear_has_datetimeOneof() { - _impl_._oneof_case_[0] = DATETIMEONEOF_NOT_SET; -} -inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::DatetimeOneofCase Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::datetimeOneof_case() const { - return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::DatetimeOneofCase(_impl_._oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// Message_HighlyStructuredMessage_HSMLocalizableParameter - -// optional string default = 1; -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_has_default_() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter::has_default_() const { - return _internal_has_default_(); -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::clear_default_() { - _impl_.default__.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_HighlyStructuredMessage_HSMLocalizableParameter::default_() const { - // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.default) - return _internal_default_(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_HighlyStructuredMessage_HSMLocalizableParameter::set_default_(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.default__.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.default) -} -inline std::string* Message_HighlyStructuredMessage_HSMLocalizableParameter::mutable_default_() { - std::string* _s = _internal_mutable_default_(); - // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.default) - return _s; -} -inline const std::string& Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_default_() const { - return _impl_.default__.Get(); -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_set_default_(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.default__.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_mutable_default_() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.default__.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_HighlyStructuredMessage_HSMLocalizableParameter::release_default_() { - // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.default) - if (!_internal_has_default_()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.default__.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.default__.IsDefault()) { - _impl_.default__.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::set_allocated_default_(std::string* default_) { - if (default_ != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.default__.SetAllocated(default_, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.default__.IsDefault()) { - _impl_.default__.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.default) -} - -// .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency currency = 2; -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_has_currency() const { - return paramOneof_case() == kCurrency; -} -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter::has_currency() const { - return _internal_has_currency(); -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::set_has_currency() { - _impl_._oneof_case_[0] = kCurrency; -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::clear_currency() { - if (_internal_has_currency()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.paramOneof_.currency_; - } - clear_has_paramOneof(); - } -} -inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* Message_HighlyStructuredMessage_HSMLocalizableParameter::release_currency() { - // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.currency) - if (_internal_has_currency()) { - clear_has_paramOneof(); - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* temp = _impl_.paramOneof_.currency_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.paramOneof_.currency_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_currency() const { - return _internal_has_currency() - ? *_impl_.paramOneof_.currency_ - : reinterpret_cast< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency&>(::proto::_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency_default_instance_); -} -inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& Message_HighlyStructuredMessage_HSMLocalizableParameter::currency() const { - // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.currency) - return _internal_currency(); -} -inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* Message_HighlyStructuredMessage_HSMLocalizableParameter::unsafe_arena_release_currency() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.currency) - if (_internal_has_currency()) { - clear_has_paramOneof(); - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* temp = _impl_.paramOneof_.currency_; - _impl_.paramOneof_.currency_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::unsafe_arena_set_allocated_currency(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* currency) { - clear_paramOneof(); - if (currency) { - set_has_currency(); - _impl_.paramOneof_.currency_ = currency; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.currency) -} -inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_mutable_currency() { - if (!_internal_has_currency()) { - clear_paramOneof(); - set_has_currency(); - _impl_.paramOneof_.currency_ = CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency >(GetArenaForAllocation()); - } - return _impl_.paramOneof_.currency_; -} -inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* Message_HighlyStructuredMessage_HSMLocalizableParameter::mutable_currency() { - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* _msg = _internal_mutable_currency(); - // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.currency) - return _msg; -} - -// .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime dateTime = 3; -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_has_datetime() const { - return paramOneof_case() == kDateTime; -} -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter::has_datetime() const { - return _internal_has_datetime(); -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::set_has_datetime() { - _impl_._oneof_case_[0] = kDateTime; -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::clear_datetime() { - if (_internal_has_datetime()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.paramOneof_.datetime_; - } - clear_has_paramOneof(); - } -} -inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* Message_HighlyStructuredMessage_HSMLocalizableParameter::release_datetime() { - // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.dateTime) - if (_internal_has_datetime()) { - clear_has_paramOneof(); - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* temp = _impl_.paramOneof_.datetime_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.paramOneof_.datetime_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_datetime() const { - return _internal_has_datetime() - ? *_impl_.paramOneof_.datetime_ - : reinterpret_cast< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime&>(::proto::_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_default_instance_); -} -inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& Message_HighlyStructuredMessage_HSMLocalizableParameter::datetime() const { - // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.dateTime) - return _internal_datetime(); -} -inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* Message_HighlyStructuredMessage_HSMLocalizableParameter::unsafe_arena_release_datetime() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.dateTime) - if (_internal_has_datetime()) { - clear_has_paramOneof(); - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* temp = _impl_.paramOneof_.datetime_; - _impl_.paramOneof_.datetime_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::unsafe_arena_set_allocated_datetime(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* datetime) { - clear_paramOneof(); - if (datetime) { - set_has_datetime(); - _impl_.paramOneof_.datetime_ = datetime; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.dateTime) -} -inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_mutable_datetime() { - if (!_internal_has_datetime()) { - clear_paramOneof(); - set_has_datetime(); - _impl_.paramOneof_.datetime_ = CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime >(GetArenaForAllocation()); - } - return _impl_.paramOneof_.datetime_; -} -inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* Message_HighlyStructuredMessage_HSMLocalizableParameter::mutable_datetime() { - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* _msg = _internal_mutable_datetime(); - // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.dateTime) - return _msg; -} - -inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter::has_paramOneof() const { - return paramOneof_case() != PARAMONEOF_NOT_SET; -} -inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::clear_has_paramOneof() { - _impl_._oneof_case_[0] = PARAMONEOF_NOT_SET; -} -inline Message_HighlyStructuredMessage_HSMLocalizableParameter::ParamOneofCase Message_HighlyStructuredMessage_HSMLocalizableParameter::paramOneof_case() const { - return Message_HighlyStructuredMessage_HSMLocalizableParameter::ParamOneofCase(_impl_._oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// Message_HighlyStructuredMessage - -// optional string namespace = 1; -inline bool Message_HighlyStructuredMessage::_internal_has_namespace_() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_HighlyStructuredMessage::has_namespace_() const { - return _internal_has_namespace_(); -} -inline void Message_HighlyStructuredMessage::clear_namespace_() { - _impl_.namespace__.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_HighlyStructuredMessage::namespace_() const { - // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.namespace) - return _internal_namespace_(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_HighlyStructuredMessage::set_namespace_(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.namespace__.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.namespace) -} -inline std::string* Message_HighlyStructuredMessage::mutable_namespace_() { - std::string* _s = _internal_mutable_namespace_(); - // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.namespace) - return _s; -} -inline const std::string& Message_HighlyStructuredMessage::_internal_namespace_() const { - return _impl_.namespace__.Get(); -} -inline void Message_HighlyStructuredMessage::_internal_set_namespace_(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.namespace__.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_HighlyStructuredMessage::_internal_mutable_namespace_() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.namespace__.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_HighlyStructuredMessage::release_namespace_() { - // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.namespace) - if (!_internal_has_namespace_()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.namespace__.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.namespace__.IsDefault()) { - _impl_.namespace__.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_HighlyStructuredMessage::set_allocated_namespace_(std::string* namespace_) { - if (namespace_ != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.namespace__.SetAllocated(namespace_, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.namespace__.IsDefault()) { - _impl_.namespace__.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.namespace) -} - -// optional string elementName = 2; -inline bool Message_HighlyStructuredMessage::_internal_has_elementname() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_HighlyStructuredMessage::has_elementname() const { - return _internal_has_elementname(); -} -inline void Message_HighlyStructuredMessage::clear_elementname() { - _impl_.elementname_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_HighlyStructuredMessage::elementname() const { - // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.elementName) - return _internal_elementname(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_HighlyStructuredMessage::set_elementname(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.elementname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.elementName) -} -inline std::string* Message_HighlyStructuredMessage::mutable_elementname() { - std::string* _s = _internal_mutable_elementname(); - // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.elementName) - return _s; -} -inline const std::string& Message_HighlyStructuredMessage::_internal_elementname() const { - return _impl_.elementname_.Get(); -} -inline void Message_HighlyStructuredMessage::_internal_set_elementname(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.elementname_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_HighlyStructuredMessage::_internal_mutable_elementname() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.elementname_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_HighlyStructuredMessage::release_elementname() { - // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.elementName) - if (!_internal_has_elementname()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.elementname_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.elementname_.IsDefault()) { - _impl_.elementname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_HighlyStructuredMessage::set_allocated_elementname(std::string* elementname) { - if (elementname != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.elementname_.SetAllocated(elementname, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.elementname_.IsDefault()) { - _impl_.elementname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.elementName) -} - -// repeated string params = 3; -inline int Message_HighlyStructuredMessage::_internal_params_size() const { - return _impl_.params_.size(); -} -inline int Message_HighlyStructuredMessage::params_size() const { - return _internal_params_size(); -} -inline void Message_HighlyStructuredMessage::clear_params() { - _impl_.params_.Clear(); -} -inline std::string* Message_HighlyStructuredMessage::add_params() { - std::string* _s = _internal_add_params(); - // @@protoc_insertion_point(field_add_mutable:proto.Message.HighlyStructuredMessage.params) - return _s; -} -inline const std::string& Message_HighlyStructuredMessage::_internal_params(int index) const { - return _impl_.params_.Get(index); -} -inline const std::string& Message_HighlyStructuredMessage::params(int index) const { - // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.params) - return _internal_params(index); -} -inline std::string* Message_HighlyStructuredMessage::mutable_params(int index) { - // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.params) - return _impl_.params_.Mutable(index); -} -inline void Message_HighlyStructuredMessage::set_params(int index, const std::string& value) { - _impl_.params_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.params) -} -inline void Message_HighlyStructuredMessage::set_params(int index, std::string&& value) { - _impl_.params_.Mutable(index)->assign(std::move(value)); - // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.params) -} -inline void Message_HighlyStructuredMessage::set_params(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - _impl_.params_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:proto.Message.HighlyStructuredMessage.params) -} -inline void Message_HighlyStructuredMessage::set_params(int index, const char* value, size_t size) { - _impl_.params_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:proto.Message.HighlyStructuredMessage.params) -} -inline std::string* Message_HighlyStructuredMessage::_internal_add_params() { - return _impl_.params_.Add(); -} -inline void Message_HighlyStructuredMessage::add_params(const std::string& value) { - _impl_.params_.Add()->assign(value); - // @@protoc_insertion_point(field_add:proto.Message.HighlyStructuredMessage.params) -} -inline void Message_HighlyStructuredMessage::add_params(std::string&& value) { - _impl_.params_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:proto.Message.HighlyStructuredMessage.params) -} -inline void Message_HighlyStructuredMessage::add_params(const char* value) { - GOOGLE_DCHECK(value != nullptr); - _impl_.params_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:proto.Message.HighlyStructuredMessage.params) -} -inline void Message_HighlyStructuredMessage::add_params(const char* value, size_t size) { - _impl_.params_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:proto.Message.HighlyStructuredMessage.params) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -Message_HighlyStructuredMessage::params() const { - // @@protoc_insertion_point(field_list:proto.Message.HighlyStructuredMessage.params) - return _impl_.params_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -Message_HighlyStructuredMessage::mutable_params() { - // @@protoc_insertion_point(field_mutable_list:proto.Message.HighlyStructuredMessage.params) - return &_impl_.params_; -} - -// optional string fallbackLg = 4; -inline bool Message_HighlyStructuredMessage::_internal_has_fallbacklg() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool Message_HighlyStructuredMessage::has_fallbacklg() const { - return _internal_has_fallbacklg(); -} -inline void Message_HighlyStructuredMessage::clear_fallbacklg() { - _impl_.fallbacklg_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& Message_HighlyStructuredMessage::fallbacklg() const { - // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.fallbackLg) - return _internal_fallbacklg(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_HighlyStructuredMessage::set_fallbacklg(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.fallbacklg_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.fallbackLg) -} -inline std::string* Message_HighlyStructuredMessage::mutable_fallbacklg() { - std::string* _s = _internal_mutable_fallbacklg(); - // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.fallbackLg) - return _s; -} -inline const std::string& Message_HighlyStructuredMessage::_internal_fallbacklg() const { - return _impl_.fallbacklg_.Get(); -} -inline void Message_HighlyStructuredMessage::_internal_set_fallbacklg(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.fallbacklg_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_HighlyStructuredMessage::_internal_mutable_fallbacklg() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.fallbacklg_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_HighlyStructuredMessage::release_fallbacklg() { - // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.fallbackLg) - if (!_internal_has_fallbacklg()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.fallbacklg_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fallbacklg_.IsDefault()) { - _impl_.fallbacklg_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_HighlyStructuredMessage::set_allocated_fallbacklg(std::string* fallbacklg) { - if (fallbacklg != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.fallbacklg_.SetAllocated(fallbacklg, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fallbacklg_.IsDefault()) { - _impl_.fallbacklg_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.fallbackLg) -} - -// optional string fallbackLc = 5; -inline bool Message_HighlyStructuredMessage::_internal_has_fallbacklc() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool Message_HighlyStructuredMessage::has_fallbacklc() const { - return _internal_has_fallbacklc(); -} -inline void Message_HighlyStructuredMessage::clear_fallbacklc() { - _impl_.fallbacklc_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const std::string& Message_HighlyStructuredMessage::fallbacklc() const { - // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.fallbackLc) - return _internal_fallbacklc(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_HighlyStructuredMessage::set_fallbacklc(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.fallbacklc_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.fallbackLc) -} -inline std::string* Message_HighlyStructuredMessage::mutable_fallbacklc() { - std::string* _s = _internal_mutable_fallbacklc(); - // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.fallbackLc) - return _s; -} -inline const std::string& Message_HighlyStructuredMessage::_internal_fallbacklc() const { - return _impl_.fallbacklc_.Get(); -} -inline void Message_HighlyStructuredMessage::_internal_set_fallbacklc(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.fallbacklc_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_HighlyStructuredMessage::_internal_mutable_fallbacklc() { - _impl_._has_bits_[0] |= 0x00000008u; - return _impl_.fallbacklc_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_HighlyStructuredMessage::release_fallbacklc() { - // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.fallbackLc) - if (!_internal_has_fallbacklc()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000008u; - auto* p = _impl_.fallbacklc_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fallbacklc_.IsDefault()) { - _impl_.fallbacklc_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_HighlyStructuredMessage::set_allocated_fallbacklc(std::string* fallbacklc) { - if (fallbacklc != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.fallbacklc_.SetAllocated(fallbacklc, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fallbacklc_.IsDefault()) { - _impl_.fallbacklc_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.fallbackLc) -} - -// repeated .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter localizableParams = 6; -inline int Message_HighlyStructuredMessage::_internal_localizableparams_size() const { - return _impl_.localizableparams_.size(); -} -inline int Message_HighlyStructuredMessage::localizableparams_size() const { - return _internal_localizableparams_size(); -} -inline void Message_HighlyStructuredMessage::clear_localizableparams() { - _impl_.localizableparams_.Clear(); -} -inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* Message_HighlyStructuredMessage::mutable_localizableparams(int index) { - // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.localizableParams) - return _impl_.localizableparams_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter >* -Message_HighlyStructuredMessage::mutable_localizableparams() { - // @@protoc_insertion_point(field_mutable_list:proto.Message.HighlyStructuredMessage.localizableParams) - return &_impl_.localizableparams_; -} -inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter& Message_HighlyStructuredMessage::_internal_localizableparams(int index) const { - return _impl_.localizableparams_.Get(index); -} -inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter& Message_HighlyStructuredMessage::localizableparams(int index) const { - // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.localizableParams) - return _internal_localizableparams(index); -} -inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* Message_HighlyStructuredMessage::_internal_add_localizableparams() { - return _impl_.localizableparams_.Add(); -} -inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* Message_HighlyStructuredMessage::add_localizableparams() { - ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* _add = _internal_add_localizableparams(); - // @@protoc_insertion_point(field_add:proto.Message.HighlyStructuredMessage.localizableParams) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter >& -Message_HighlyStructuredMessage::localizableparams() const { - // @@protoc_insertion_point(field_list:proto.Message.HighlyStructuredMessage.localizableParams) - return _impl_.localizableparams_; -} - -// optional string deterministicLg = 7; -inline bool Message_HighlyStructuredMessage::_internal_has_deterministiclg() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool Message_HighlyStructuredMessage::has_deterministiclg() const { - return _internal_has_deterministiclg(); -} -inline void Message_HighlyStructuredMessage::clear_deterministiclg() { - _impl_.deterministiclg_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const std::string& Message_HighlyStructuredMessage::deterministiclg() const { - // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.deterministicLg) - return _internal_deterministiclg(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_HighlyStructuredMessage::set_deterministiclg(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.deterministiclg_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.deterministicLg) -} -inline std::string* Message_HighlyStructuredMessage::mutable_deterministiclg() { - std::string* _s = _internal_mutable_deterministiclg(); - // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.deterministicLg) - return _s; -} -inline const std::string& Message_HighlyStructuredMessage::_internal_deterministiclg() const { - return _impl_.deterministiclg_.Get(); -} -inline void Message_HighlyStructuredMessage::_internal_set_deterministiclg(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.deterministiclg_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_HighlyStructuredMessage::_internal_mutable_deterministiclg() { - _impl_._has_bits_[0] |= 0x00000010u; - return _impl_.deterministiclg_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_HighlyStructuredMessage::release_deterministiclg() { - // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.deterministicLg) - if (!_internal_has_deterministiclg()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000010u; - auto* p = _impl_.deterministiclg_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.deterministiclg_.IsDefault()) { - _impl_.deterministiclg_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_HighlyStructuredMessage::set_allocated_deterministiclg(std::string* deterministiclg) { - if (deterministiclg != nullptr) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.deterministiclg_.SetAllocated(deterministiclg, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.deterministiclg_.IsDefault()) { - _impl_.deterministiclg_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.deterministicLg) -} - -// optional string deterministicLc = 8; -inline bool Message_HighlyStructuredMessage::_internal_has_deterministiclc() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool Message_HighlyStructuredMessage::has_deterministiclc() const { - return _internal_has_deterministiclc(); -} -inline void Message_HighlyStructuredMessage::clear_deterministiclc() { - _impl_.deterministiclc_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline const std::string& Message_HighlyStructuredMessage::deterministiclc() const { - // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.deterministicLc) - return _internal_deterministiclc(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_HighlyStructuredMessage::set_deterministiclc(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.deterministiclc_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.deterministicLc) -} -inline std::string* Message_HighlyStructuredMessage::mutable_deterministiclc() { - std::string* _s = _internal_mutable_deterministiclc(); - // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.deterministicLc) - return _s; -} -inline const std::string& Message_HighlyStructuredMessage::_internal_deterministiclc() const { - return _impl_.deterministiclc_.Get(); -} -inline void Message_HighlyStructuredMessage::_internal_set_deterministiclc(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.deterministiclc_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_HighlyStructuredMessage::_internal_mutable_deterministiclc() { - _impl_._has_bits_[0] |= 0x00000020u; - return _impl_.deterministiclc_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_HighlyStructuredMessage::release_deterministiclc() { - // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.deterministicLc) - if (!_internal_has_deterministiclc()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000020u; - auto* p = _impl_.deterministiclc_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.deterministiclc_.IsDefault()) { - _impl_.deterministiclc_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_HighlyStructuredMessage::set_allocated_deterministiclc(std::string* deterministiclc) { - if (deterministiclc != nullptr) { - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - _impl_.deterministiclc_.SetAllocated(deterministiclc, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.deterministiclc_.IsDefault()) { - _impl_.deterministiclc_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.deterministicLc) -} - -// optional .proto.Message.TemplateMessage hydratedHsm = 9; -inline bool Message_HighlyStructuredMessage::_internal_has_hydratedhsm() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - PROTOBUF_ASSUME(!value || _impl_.hydratedhsm_ != nullptr); - return value; -} -inline bool Message_HighlyStructuredMessage::has_hydratedhsm() const { - return _internal_has_hydratedhsm(); -} -inline void Message_HighlyStructuredMessage::clear_hydratedhsm() { - if (_impl_.hydratedhsm_ != nullptr) _impl_.hydratedhsm_->Clear(); - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline const ::proto::Message_TemplateMessage& Message_HighlyStructuredMessage::_internal_hydratedhsm() const { - const ::proto::Message_TemplateMessage* p = _impl_.hydratedhsm_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_TemplateMessage_default_instance_); -} -inline const ::proto::Message_TemplateMessage& Message_HighlyStructuredMessage::hydratedhsm() const { - // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.hydratedHsm) - return _internal_hydratedhsm(); -} -inline void Message_HighlyStructuredMessage::unsafe_arena_set_allocated_hydratedhsm( - ::proto::Message_TemplateMessage* hydratedhsm) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.hydratedhsm_); - } - _impl_.hydratedhsm_ = hydratedhsm; - if (hydratedhsm) { - _impl_._has_bits_[0] |= 0x00000040u; - } else { - _impl_._has_bits_[0] &= ~0x00000040u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.HighlyStructuredMessage.hydratedHsm) -} -inline ::proto::Message_TemplateMessage* Message_HighlyStructuredMessage::release_hydratedhsm() { - _impl_._has_bits_[0] &= ~0x00000040u; - ::proto::Message_TemplateMessage* temp = _impl_.hydratedhsm_; - _impl_.hydratedhsm_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_TemplateMessage* Message_HighlyStructuredMessage::unsafe_arena_release_hydratedhsm() { - // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.hydratedHsm) - _impl_._has_bits_[0] &= ~0x00000040u; - ::proto::Message_TemplateMessage* temp = _impl_.hydratedhsm_; - _impl_.hydratedhsm_ = nullptr; - return temp; -} -inline ::proto::Message_TemplateMessage* Message_HighlyStructuredMessage::_internal_mutable_hydratedhsm() { - _impl_._has_bits_[0] |= 0x00000040u; - if (_impl_.hydratedhsm_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_TemplateMessage>(GetArenaForAllocation()); - _impl_.hydratedhsm_ = p; - } - return _impl_.hydratedhsm_; -} -inline ::proto::Message_TemplateMessage* Message_HighlyStructuredMessage::mutable_hydratedhsm() { - ::proto::Message_TemplateMessage* _msg = _internal_mutable_hydratedhsm(); - // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.hydratedHsm) - return _msg; -} -inline void Message_HighlyStructuredMessage::set_allocated_hydratedhsm(::proto::Message_TemplateMessage* hydratedhsm) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.hydratedhsm_; - } - if (hydratedhsm) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(hydratedhsm); - if (message_arena != submessage_arena) { - hydratedhsm = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, hydratedhsm, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000040u; - } else { - _impl_._has_bits_[0] &= ~0x00000040u; - } - _impl_.hydratedhsm_ = hydratedhsm; - // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.hydratedHsm) -} - -// ------------------------------------------------------------------- - -// Message_HistorySyncNotification - -// optional bytes fileSha256 = 1; -inline bool Message_HistorySyncNotification::_internal_has_filesha256() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_HistorySyncNotification::has_filesha256() const { - return _internal_has_filesha256(); -} -inline void Message_HistorySyncNotification::clear_filesha256() { - _impl_.filesha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_HistorySyncNotification::filesha256() const { - // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.fileSha256) - return _internal_filesha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_HistorySyncNotification::set_filesha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.filesha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.fileSha256) -} -inline std::string* Message_HistorySyncNotification::mutable_filesha256() { - std::string* _s = _internal_mutable_filesha256(); - // @@protoc_insertion_point(field_mutable:proto.Message.HistorySyncNotification.fileSha256) - return _s; -} -inline const std::string& Message_HistorySyncNotification::_internal_filesha256() const { - return _impl_.filesha256_.Get(); -} -inline void Message_HistorySyncNotification::_internal_set_filesha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.filesha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_HistorySyncNotification::_internal_mutable_filesha256() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.filesha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_HistorySyncNotification::release_filesha256() { - // @@protoc_insertion_point(field_release:proto.Message.HistorySyncNotification.fileSha256) - if (!_internal_has_filesha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.filesha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.filesha256_.IsDefault()) { - _impl_.filesha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_HistorySyncNotification::set_allocated_filesha256(std::string* filesha256) { - if (filesha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.filesha256_.IsDefault()) { - _impl_.filesha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.HistorySyncNotification.fileSha256) -} - -// optional uint64 fileLength = 2; -inline bool Message_HistorySyncNotification::_internal_has_filelength() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool Message_HistorySyncNotification::has_filelength() const { - return _internal_has_filelength(); -} -inline void Message_HistorySyncNotification::clear_filelength() { - _impl_.filelength_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline uint64_t Message_HistorySyncNotification::_internal_filelength() const { - return _impl_.filelength_; -} -inline uint64_t Message_HistorySyncNotification::filelength() const { - // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.fileLength) - return _internal_filelength(); -} -inline void Message_HistorySyncNotification::_internal_set_filelength(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.filelength_ = value; -} -inline void Message_HistorySyncNotification::set_filelength(uint64_t value) { - _internal_set_filelength(value); - // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.fileLength) -} - -// optional bytes mediaKey = 3; -inline bool Message_HistorySyncNotification::_internal_has_mediakey() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_HistorySyncNotification::has_mediakey() const { - return _internal_has_mediakey(); -} -inline void Message_HistorySyncNotification::clear_mediakey() { - _impl_.mediakey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_HistorySyncNotification::mediakey() const { - // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.mediaKey) - return _internal_mediakey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_HistorySyncNotification::set_mediakey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.mediakey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.mediaKey) -} -inline std::string* Message_HistorySyncNotification::mutable_mediakey() { - std::string* _s = _internal_mutable_mediakey(); - // @@protoc_insertion_point(field_mutable:proto.Message.HistorySyncNotification.mediaKey) - return _s; -} -inline const std::string& Message_HistorySyncNotification::_internal_mediakey() const { - return _impl_.mediakey_.Get(); -} -inline void Message_HistorySyncNotification::_internal_set_mediakey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.mediakey_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_HistorySyncNotification::_internal_mutable_mediakey() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.mediakey_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_HistorySyncNotification::release_mediakey() { - // @@protoc_insertion_point(field_release:proto.Message.HistorySyncNotification.mediaKey) - if (!_internal_has_mediakey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.mediakey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mediakey_.IsDefault()) { - _impl_.mediakey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_HistorySyncNotification::set_allocated_mediakey(std::string* mediakey) { - if (mediakey != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mediakey_.IsDefault()) { - _impl_.mediakey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.HistorySyncNotification.mediaKey) -} - -// optional bytes fileEncSha256 = 4; -inline bool Message_HistorySyncNotification::_internal_has_fileencsha256() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool Message_HistorySyncNotification::has_fileencsha256() const { - return _internal_has_fileencsha256(); -} -inline void Message_HistorySyncNotification::clear_fileencsha256() { - _impl_.fileencsha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& Message_HistorySyncNotification::fileencsha256() const { - // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.fileEncSha256) - return _internal_fileencsha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_HistorySyncNotification::set_fileencsha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.fileencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.fileEncSha256) -} -inline std::string* Message_HistorySyncNotification::mutable_fileencsha256() { - std::string* _s = _internal_mutable_fileencsha256(); - // @@protoc_insertion_point(field_mutable:proto.Message.HistorySyncNotification.fileEncSha256) - return _s; -} -inline const std::string& Message_HistorySyncNotification::_internal_fileencsha256() const { - return _impl_.fileencsha256_.Get(); -} -inline void Message_HistorySyncNotification::_internal_set_fileencsha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.fileencsha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_HistorySyncNotification::_internal_mutable_fileencsha256() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.fileencsha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_HistorySyncNotification::release_fileencsha256() { - // @@protoc_insertion_point(field_release:proto.Message.HistorySyncNotification.fileEncSha256) - if (!_internal_has_fileencsha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.fileencsha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fileencsha256_.IsDefault()) { - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_HistorySyncNotification::set_allocated_fileencsha256(std::string* fileencsha256) { - if (fileencsha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fileencsha256_.IsDefault()) { - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.HistorySyncNotification.fileEncSha256) -} - -// optional string directPath = 5; -inline bool Message_HistorySyncNotification::_internal_has_directpath() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool Message_HistorySyncNotification::has_directpath() const { - return _internal_has_directpath(); -} -inline void Message_HistorySyncNotification::clear_directpath() { - _impl_.directpath_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const std::string& Message_HistorySyncNotification::directpath() const { - // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.directPath) - return _internal_directpath(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_HistorySyncNotification::set_directpath(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.directpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.directPath) -} -inline std::string* Message_HistorySyncNotification::mutable_directpath() { - std::string* _s = _internal_mutable_directpath(); - // @@protoc_insertion_point(field_mutable:proto.Message.HistorySyncNotification.directPath) - return _s; -} -inline const std::string& Message_HistorySyncNotification::_internal_directpath() const { - return _impl_.directpath_.Get(); -} -inline void Message_HistorySyncNotification::_internal_set_directpath(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.directpath_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_HistorySyncNotification::_internal_mutable_directpath() { - _impl_._has_bits_[0] |= 0x00000008u; - return _impl_.directpath_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_HistorySyncNotification::release_directpath() { - // @@protoc_insertion_point(field_release:proto.Message.HistorySyncNotification.directPath) - if (!_internal_has_directpath()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000008u; - auto* p = _impl_.directpath_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.directpath_.IsDefault()) { - _impl_.directpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_HistorySyncNotification::set_allocated_directpath(std::string* directpath) { - if (directpath != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.directpath_.IsDefault()) { - _impl_.directpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.HistorySyncNotification.directPath) -} - -// optional .proto.Message.HistorySyncNotification.HistorySyncType syncType = 6; -inline bool Message_HistorySyncNotification::_internal_has_synctype() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool Message_HistorySyncNotification::has_synctype() const { - return _internal_has_synctype(); -} -inline void Message_HistorySyncNotification::clear_synctype() { - _impl_.synctype_ = 0; - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline ::proto::Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification::_internal_synctype() const { - return static_cast< ::proto::Message_HistorySyncNotification_HistorySyncType >(_impl_.synctype_); -} -inline ::proto::Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification::synctype() const { - // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.syncType) - return _internal_synctype(); -} -inline void Message_HistorySyncNotification::_internal_set_synctype(::proto::Message_HistorySyncNotification_HistorySyncType value) { - assert(::proto::Message_HistorySyncNotification_HistorySyncType_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.synctype_ = value; -} -inline void Message_HistorySyncNotification::set_synctype(::proto::Message_HistorySyncNotification_HistorySyncType value) { - _internal_set_synctype(value); - // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.syncType) -} - -// optional uint32 chunkOrder = 7; -inline bool Message_HistorySyncNotification::_internal_has_chunkorder() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - return value; -} -inline bool Message_HistorySyncNotification::has_chunkorder() const { - return _internal_has_chunkorder(); -} -inline void Message_HistorySyncNotification::clear_chunkorder() { - _impl_.chunkorder_ = 0u; - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline uint32_t Message_HistorySyncNotification::_internal_chunkorder() const { - return _impl_.chunkorder_; -} -inline uint32_t Message_HistorySyncNotification::chunkorder() const { - // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.chunkOrder) - return _internal_chunkorder(); -} -inline void Message_HistorySyncNotification::_internal_set_chunkorder(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.chunkorder_ = value; -} -inline void Message_HistorySyncNotification::set_chunkorder(uint32_t value) { - _internal_set_chunkorder(value); - // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.chunkOrder) -} - -// optional string originalMessageId = 8; -inline bool Message_HistorySyncNotification::_internal_has_originalmessageid() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool Message_HistorySyncNotification::has_originalmessageid() const { - return _internal_has_originalmessageid(); -} -inline void Message_HistorySyncNotification::clear_originalmessageid() { - _impl_.originalmessageid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const std::string& Message_HistorySyncNotification::originalmessageid() const { - // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.originalMessageId) - return _internal_originalmessageid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_HistorySyncNotification::set_originalmessageid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.originalmessageid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.originalMessageId) -} -inline std::string* Message_HistorySyncNotification::mutable_originalmessageid() { - std::string* _s = _internal_mutable_originalmessageid(); - // @@protoc_insertion_point(field_mutable:proto.Message.HistorySyncNotification.originalMessageId) - return _s; -} -inline const std::string& Message_HistorySyncNotification::_internal_originalmessageid() const { - return _impl_.originalmessageid_.Get(); -} -inline void Message_HistorySyncNotification::_internal_set_originalmessageid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.originalmessageid_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_HistorySyncNotification::_internal_mutable_originalmessageid() { - _impl_._has_bits_[0] |= 0x00000010u; - return _impl_.originalmessageid_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_HistorySyncNotification::release_originalmessageid() { - // @@protoc_insertion_point(field_release:proto.Message.HistorySyncNotification.originalMessageId) - if (!_internal_has_originalmessageid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000010u; - auto* p = _impl_.originalmessageid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.originalmessageid_.IsDefault()) { - _impl_.originalmessageid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_HistorySyncNotification::set_allocated_originalmessageid(std::string* originalmessageid) { - if (originalmessageid != nullptr) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.originalmessageid_.SetAllocated(originalmessageid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.originalmessageid_.IsDefault()) { - _impl_.originalmessageid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.HistorySyncNotification.originalMessageId) -} - -// optional uint32 progress = 9; -inline bool Message_HistorySyncNotification::_internal_has_progress() const { - bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; - return value; -} -inline bool Message_HistorySyncNotification::has_progress() const { - return _internal_has_progress(); -} -inline void Message_HistorySyncNotification::clear_progress() { - _impl_.progress_ = 0u; - _impl_._has_bits_[0] &= ~0x00000100u; -} -inline uint32_t Message_HistorySyncNotification::_internal_progress() const { - return _impl_.progress_; -} -inline uint32_t Message_HistorySyncNotification::progress() const { - // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.progress) - return _internal_progress(); -} -inline void Message_HistorySyncNotification::_internal_set_progress(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000100u; - _impl_.progress_ = value; -} -inline void Message_HistorySyncNotification::set_progress(uint32_t value) { - _internal_set_progress(value); - // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.progress) -} - -// ------------------------------------------------------------------- - -// Message_ImageMessage - -// optional string url = 1; -inline bool Message_ImageMessage::_internal_has_url() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_ImageMessage::has_url() const { - return _internal_has_url(); -} -inline void Message_ImageMessage::clear_url() { - _impl_.url_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_ImageMessage::url() const { - // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.url) - return _internal_url(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ImageMessage::set_url(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.url_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.url) -} -inline std::string* Message_ImageMessage::mutable_url() { - std::string* _s = _internal_mutable_url(); - // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.url) - return _s; -} -inline const std::string& Message_ImageMessage::_internal_url() const { - return _impl_.url_.Get(); -} -inline void Message_ImageMessage::_internal_set_url(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.url_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::_internal_mutable_url() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.url_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::release_url() { - // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.url) - if (!_internal_has_url()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.url_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.url_.IsDefault()) { - _impl_.url_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ImageMessage::set_allocated_url(std::string* url) { - if (url != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.url_.SetAllocated(url, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.url_.IsDefault()) { - _impl_.url_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.url) -} - -// optional string mimetype = 2; -inline bool Message_ImageMessage::_internal_has_mimetype() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_ImageMessage::has_mimetype() const { - return _internal_has_mimetype(); -} -inline void Message_ImageMessage::clear_mimetype() { - _impl_.mimetype_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_ImageMessage::mimetype() const { - // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.mimetype) - return _internal_mimetype(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ImageMessage::set_mimetype(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.mimetype_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.mimetype) -} -inline std::string* Message_ImageMessage::mutable_mimetype() { - std::string* _s = _internal_mutable_mimetype(); - // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.mimetype) - return _s; -} -inline const std::string& Message_ImageMessage::_internal_mimetype() const { - return _impl_.mimetype_.Get(); -} -inline void Message_ImageMessage::_internal_set_mimetype(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.mimetype_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::_internal_mutable_mimetype() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.mimetype_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::release_mimetype() { - // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.mimetype) - if (!_internal_has_mimetype()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.mimetype_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mimetype_.IsDefault()) { - _impl_.mimetype_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ImageMessage::set_allocated_mimetype(std::string* mimetype) { - if (mimetype != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mimetype_.IsDefault()) { - _impl_.mimetype_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.mimetype) -} - -// optional string caption = 3; -inline bool Message_ImageMessage::_internal_has_caption() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool Message_ImageMessage::has_caption() const { - return _internal_has_caption(); -} -inline void Message_ImageMessage::clear_caption() { - _impl_.caption_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& Message_ImageMessage::caption() const { - // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.caption) - return _internal_caption(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ImageMessage::set_caption(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.caption_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.caption) -} -inline std::string* Message_ImageMessage::mutable_caption() { - std::string* _s = _internal_mutable_caption(); - // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.caption) - return _s; -} -inline const std::string& Message_ImageMessage::_internal_caption() const { - return _impl_.caption_.Get(); -} -inline void Message_ImageMessage::_internal_set_caption(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.caption_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::_internal_mutable_caption() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.caption_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::release_caption() { - // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.caption) - if (!_internal_has_caption()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.caption_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.caption_.IsDefault()) { - _impl_.caption_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ImageMessage::set_allocated_caption(std::string* caption) { - if (caption != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.caption_.SetAllocated(caption, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.caption_.IsDefault()) { - _impl_.caption_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.caption) -} - -// optional bytes fileSha256 = 4; -inline bool Message_ImageMessage::_internal_has_filesha256() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool Message_ImageMessage::has_filesha256() const { - return _internal_has_filesha256(); -} -inline void Message_ImageMessage::clear_filesha256() { - _impl_.filesha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const std::string& Message_ImageMessage::filesha256() const { - // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.fileSha256) - return _internal_filesha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ImageMessage::set_filesha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.filesha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.fileSha256) -} -inline std::string* Message_ImageMessage::mutable_filesha256() { - std::string* _s = _internal_mutable_filesha256(); - // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.fileSha256) - return _s; -} -inline const std::string& Message_ImageMessage::_internal_filesha256() const { - return _impl_.filesha256_.Get(); -} -inline void Message_ImageMessage::_internal_set_filesha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.filesha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::_internal_mutable_filesha256() { - _impl_._has_bits_[0] |= 0x00000008u; - return _impl_.filesha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::release_filesha256() { - // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.fileSha256) - if (!_internal_has_filesha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000008u; - auto* p = _impl_.filesha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.filesha256_.IsDefault()) { - _impl_.filesha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ImageMessage::set_allocated_filesha256(std::string* filesha256) { - if (filesha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.filesha256_.IsDefault()) { - _impl_.filesha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.fileSha256) -} - -// optional uint64 fileLength = 5; -inline bool Message_ImageMessage::_internal_has_filelength() const { - bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0; - return value; -} -inline bool Message_ImageMessage::has_filelength() const { - return _internal_has_filelength(); -} -inline void Message_ImageMessage::clear_filelength() { - _impl_.filelength_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00020000u; -} -inline uint64_t Message_ImageMessage::_internal_filelength() const { - return _impl_.filelength_; -} -inline uint64_t Message_ImageMessage::filelength() const { - // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.fileLength) - return _internal_filelength(); -} -inline void Message_ImageMessage::_internal_set_filelength(uint64_t value) { - _impl_._has_bits_[0] |= 0x00020000u; - _impl_.filelength_ = value; -} -inline void Message_ImageMessage::set_filelength(uint64_t value) { - _internal_set_filelength(value); - // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.fileLength) -} - -// optional uint32 height = 6; -inline bool Message_ImageMessage::_internal_has_height() const { - bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0; - return value; -} -inline bool Message_ImageMessage::has_height() const { - return _internal_has_height(); -} -inline void Message_ImageMessage::clear_height() { - _impl_.height_ = 0u; - _impl_._has_bits_[0] &= ~0x00040000u; -} -inline uint32_t Message_ImageMessage::_internal_height() const { - return _impl_.height_; -} -inline uint32_t Message_ImageMessage::height() const { - // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.height) - return _internal_height(); -} -inline void Message_ImageMessage::_internal_set_height(uint32_t value) { - _impl_._has_bits_[0] |= 0x00040000u; - _impl_.height_ = value; -} -inline void Message_ImageMessage::set_height(uint32_t value) { - _internal_set_height(value); - // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.height) -} - -// optional uint32 width = 7; -inline bool Message_ImageMessage::_internal_has_width() const { - bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0; - return value; -} -inline bool Message_ImageMessage::has_width() const { - return _internal_has_width(); -} -inline void Message_ImageMessage::clear_width() { - _impl_.width_ = 0u; - _impl_._has_bits_[0] &= ~0x00080000u; -} -inline uint32_t Message_ImageMessage::_internal_width() const { - return _impl_.width_; -} -inline uint32_t Message_ImageMessage::width() const { - // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.width) - return _internal_width(); -} -inline void Message_ImageMessage::_internal_set_width(uint32_t value) { - _impl_._has_bits_[0] |= 0x00080000u; - _impl_.width_ = value; -} -inline void Message_ImageMessage::set_width(uint32_t value) { - _internal_set_width(value); - // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.width) -} - -// optional bytes mediaKey = 8; -inline bool Message_ImageMessage::_internal_has_mediakey() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool Message_ImageMessage::has_mediakey() const { - return _internal_has_mediakey(); -} -inline void Message_ImageMessage::clear_mediakey() { - _impl_.mediakey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const std::string& Message_ImageMessage::mediakey() const { - // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.mediaKey) - return _internal_mediakey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ImageMessage::set_mediakey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.mediakey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.mediaKey) -} -inline std::string* Message_ImageMessage::mutable_mediakey() { - std::string* _s = _internal_mutable_mediakey(); - // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.mediaKey) - return _s; -} -inline const std::string& Message_ImageMessage::_internal_mediakey() const { - return _impl_.mediakey_.Get(); -} -inline void Message_ImageMessage::_internal_set_mediakey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.mediakey_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::_internal_mutable_mediakey() { - _impl_._has_bits_[0] |= 0x00000010u; - return _impl_.mediakey_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::release_mediakey() { - // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.mediaKey) - if (!_internal_has_mediakey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000010u; - auto* p = _impl_.mediakey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mediakey_.IsDefault()) { - _impl_.mediakey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ImageMessage::set_allocated_mediakey(std::string* mediakey) { - if (mediakey != nullptr) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mediakey_.IsDefault()) { - _impl_.mediakey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.mediaKey) -} - -// optional bytes fileEncSha256 = 9; -inline bool Message_ImageMessage::_internal_has_fileencsha256() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool Message_ImageMessage::has_fileencsha256() const { - return _internal_has_fileencsha256(); -} -inline void Message_ImageMessage::clear_fileencsha256() { - _impl_.fileencsha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline const std::string& Message_ImageMessage::fileencsha256() const { - // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.fileEncSha256) - return _internal_fileencsha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ImageMessage::set_fileencsha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.fileencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.fileEncSha256) -} -inline std::string* Message_ImageMessage::mutable_fileencsha256() { - std::string* _s = _internal_mutable_fileencsha256(); - // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.fileEncSha256) - return _s; -} -inline const std::string& Message_ImageMessage::_internal_fileencsha256() const { - return _impl_.fileencsha256_.Get(); -} -inline void Message_ImageMessage::_internal_set_fileencsha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.fileencsha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::_internal_mutable_fileencsha256() { - _impl_._has_bits_[0] |= 0x00000020u; - return _impl_.fileencsha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::release_fileencsha256() { - // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.fileEncSha256) - if (!_internal_has_fileencsha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000020u; - auto* p = _impl_.fileencsha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fileencsha256_.IsDefault()) { - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ImageMessage::set_allocated_fileencsha256(std::string* fileencsha256) { - if (fileencsha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fileencsha256_.IsDefault()) { - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.fileEncSha256) -} - -// repeated .proto.InteractiveAnnotation interactiveAnnotations = 10; -inline int Message_ImageMessage::_internal_interactiveannotations_size() const { - return _impl_.interactiveannotations_.size(); -} -inline int Message_ImageMessage::interactiveannotations_size() const { - return _internal_interactiveannotations_size(); -} -inline void Message_ImageMessage::clear_interactiveannotations() { - _impl_.interactiveannotations_.Clear(); -} -inline ::proto::InteractiveAnnotation* Message_ImageMessage::mutable_interactiveannotations(int index) { - // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.interactiveAnnotations) - return _impl_.interactiveannotations_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >* -Message_ImageMessage::mutable_interactiveannotations() { - // @@protoc_insertion_point(field_mutable_list:proto.Message.ImageMessage.interactiveAnnotations) - return &_impl_.interactiveannotations_; -} -inline const ::proto::InteractiveAnnotation& Message_ImageMessage::_internal_interactiveannotations(int index) const { - return _impl_.interactiveannotations_.Get(index); -} -inline const ::proto::InteractiveAnnotation& Message_ImageMessage::interactiveannotations(int index) const { - // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.interactiveAnnotations) - return _internal_interactiveannotations(index); -} -inline ::proto::InteractiveAnnotation* Message_ImageMessage::_internal_add_interactiveannotations() { - return _impl_.interactiveannotations_.Add(); -} -inline ::proto::InteractiveAnnotation* Message_ImageMessage::add_interactiveannotations() { - ::proto::InteractiveAnnotation* _add = _internal_add_interactiveannotations(); - // @@protoc_insertion_point(field_add:proto.Message.ImageMessage.interactiveAnnotations) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >& -Message_ImageMessage::interactiveannotations() const { - // @@protoc_insertion_point(field_list:proto.Message.ImageMessage.interactiveAnnotations) - return _impl_.interactiveannotations_; -} - -// optional string directPath = 11; -inline bool Message_ImageMessage::_internal_has_directpath() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool Message_ImageMessage::has_directpath() const { - return _internal_has_directpath(); -} -inline void Message_ImageMessage::clear_directpath() { - _impl_.directpath_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline const std::string& Message_ImageMessage::directpath() const { - // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.directPath) - return _internal_directpath(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ImageMessage::set_directpath(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.directpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.directPath) -} -inline std::string* Message_ImageMessage::mutable_directpath() { - std::string* _s = _internal_mutable_directpath(); - // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.directPath) - return _s; -} -inline const std::string& Message_ImageMessage::_internal_directpath() const { - return _impl_.directpath_.Get(); -} -inline void Message_ImageMessage::_internal_set_directpath(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.directpath_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::_internal_mutable_directpath() { - _impl_._has_bits_[0] |= 0x00000040u; - return _impl_.directpath_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::release_directpath() { - // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.directPath) - if (!_internal_has_directpath()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000040u; - auto* p = _impl_.directpath_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.directpath_.IsDefault()) { - _impl_.directpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ImageMessage::set_allocated_directpath(std::string* directpath) { - if (directpath != nullptr) { - _impl_._has_bits_[0] |= 0x00000040u; - } else { - _impl_._has_bits_[0] &= ~0x00000040u; - } - _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.directpath_.IsDefault()) { - _impl_.directpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.directPath) -} - -// optional int64 mediaKeyTimestamp = 12; -inline bool Message_ImageMessage::_internal_has_mediakeytimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0; - return value; -} -inline bool Message_ImageMessage::has_mediakeytimestamp() const { - return _internal_has_mediakeytimestamp(); -} -inline void Message_ImageMessage::clear_mediakeytimestamp() { - _impl_.mediakeytimestamp_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00100000u; -} -inline int64_t Message_ImageMessage::_internal_mediakeytimestamp() const { - return _impl_.mediakeytimestamp_; -} -inline int64_t Message_ImageMessage::mediakeytimestamp() const { - // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.mediaKeyTimestamp) - return _internal_mediakeytimestamp(); -} -inline void Message_ImageMessage::_internal_set_mediakeytimestamp(int64_t value) { - _impl_._has_bits_[0] |= 0x00100000u; - _impl_.mediakeytimestamp_ = value; -} -inline void Message_ImageMessage::set_mediakeytimestamp(int64_t value) { - _internal_set_mediakeytimestamp(value); - // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.mediaKeyTimestamp) -} - -// optional bytes jpegThumbnail = 16; -inline bool Message_ImageMessage::_internal_has_jpegthumbnail() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - return value; -} -inline bool Message_ImageMessage::has_jpegthumbnail() const { - return _internal_has_jpegthumbnail(); -} -inline void Message_ImageMessage::clear_jpegthumbnail() { - _impl_.jpegthumbnail_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline const std::string& Message_ImageMessage::jpegthumbnail() const { - // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.jpegThumbnail) - return _internal_jpegthumbnail(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ImageMessage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.jpegthumbnail_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.jpegThumbnail) -} -inline std::string* Message_ImageMessage::mutable_jpegthumbnail() { - std::string* _s = _internal_mutable_jpegthumbnail(); - // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.jpegThumbnail) - return _s; -} -inline const std::string& Message_ImageMessage::_internal_jpegthumbnail() const { - return _impl_.jpegthumbnail_.Get(); -} -inline void Message_ImageMessage::_internal_set_jpegthumbnail(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::_internal_mutable_jpegthumbnail() { - _impl_._has_bits_[0] |= 0x00000080u; - return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::release_jpegthumbnail() { - // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.jpegThumbnail) - if (!_internal_has_jpegthumbnail()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000080u; - auto* p = _impl_.jpegthumbnail_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.jpegthumbnail_.IsDefault()) { - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ImageMessage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) { - if (jpegthumbnail != nullptr) { - _impl_._has_bits_[0] |= 0x00000080u; - } else { - _impl_._has_bits_[0] &= ~0x00000080u; - } - _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.jpegthumbnail_.IsDefault()) { - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.jpegThumbnail) -} - -// optional .proto.ContextInfo contextInfo = 17; -inline bool Message_ImageMessage::_internal_has_contextinfo() const { - bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); - return value; -} -inline bool Message_ImageMessage::has_contextinfo() const { - return _internal_has_contextinfo(); -} -inline void Message_ImageMessage::clear_contextinfo() { - if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); - _impl_._has_bits_[0] &= ~0x00010000u; -} -inline const ::proto::ContextInfo& Message_ImageMessage::_internal_contextinfo() const { - const ::proto::ContextInfo* p = _impl_.contextinfo_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ContextInfo_default_instance_); -} -inline const ::proto::ContextInfo& Message_ImageMessage::contextinfo() const { - // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.contextInfo) - return _internal_contextinfo(); -} -inline void Message_ImageMessage::unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); - } - _impl_.contextinfo_ = contextinfo; - if (contextinfo) { - _impl_._has_bits_[0] |= 0x00010000u; - } else { - _impl_._has_bits_[0] &= ~0x00010000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ImageMessage.contextInfo) -} -inline ::proto::ContextInfo* Message_ImageMessage::release_contextinfo() { - _impl_._has_bits_[0] &= ~0x00010000u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ContextInfo* Message_ImageMessage::unsafe_arena_release_contextinfo() { - // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.contextInfo) - _impl_._has_bits_[0] &= ~0x00010000u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; - return temp; -} -inline ::proto::ContextInfo* Message_ImageMessage::_internal_mutable_contextinfo() { - _impl_._has_bits_[0] |= 0x00010000u; - if (_impl_.contextinfo_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); - _impl_.contextinfo_ = p; - } - return _impl_.contextinfo_; -} -inline ::proto::ContextInfo* Message_ImageMessage::mutable_contextinfo() { - ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); - // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.contextInfo) - return _msg; -} -inline void Message_ImageMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.contextinfo_; - } - if (contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); - if (message_arena != submessage_arena) { - contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, contextinfo, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00010000u; - } else { - _impl_._has_bits_[0] &= ~0x00010000u; - } - _impl_.contextinfo_ = contextinfo; - // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.contextInfo) -} - -// optional bytes firstScanSidecar = 18; -inline bool Message_ImageMessage::_internal_has_firstscansidecar() const { - bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; - return value; -} -inline bool Message_ImageMessage::has_firstscansidecar() const { - return _internal_has_firstscansidecar(); -} -inline void Message_ImageMessage::clear_firstscansidecar() { - _impl_.firstscansidecar_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000100u; -} -inline const std::string& Message_ImageMessage::firstscansidecar() const { - // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.firstScanSidecar) - return _internal_firstscansidecar(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ImageMessage::set_firstscansidecar(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000100u; - _impl_.firstscansidecar_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.firstScanSidecar) -} -inline std::string* Message_ImageMessage::mutable_firstscansidecar() { - std::string* _s = _internal_mutable_firstscansidecar(); - // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.firstScanSidecar) - return _s; -} -inline const std::string& Message_ImageMessage::_internal_firstscansidecar() const { - return _impl_.firstscansidecar_.Get(); -} -inline void Message_ImageMessage::_internal_set_firstscansidecar(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000100u; - _impl_.firstscansidecar_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::_internal_mutable_firstscansidecar() { - _impl_._has_bits_[0] |= 0x00000100u; - return _impl_.firstscansidecar_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::release_firstscansidecar() { - // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.firstScanSidecar) - if (!_internal_has_firstscansidecar()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000100u; - auto* p = _impl_.firstscansidecar_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.firstscansidecar_.IsDefault()) { - _impl_.firstscansidecar_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ImageMessage::set_allocated_firstscansidecar(std::string* firstscansidecar) { - if (firstscansidecar != nullptr) { - _impl_._has_bits_[0] |= 0x00000100u; - } else { - _impl_._has_bits_[0] &= ~0x00000100u; - } - _impl_.firstscansidecar_.SetAllocated(firstscansidecar, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.firstscansidecar_.IsDefault()) { - _impl_.firstscansidecar_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.firstScanSidecar) -} - -// optional uint32 firstScanLength = 19; -inline bool Message_ImageMessage::_internal_has_firstscanlength() const { - bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0; - return value; -} -inline bool Message_ImageMessage::has_firstscanlength() const { - return _internal_has_firstscanlength(); -} -inline void Message_ImageMessage::clear_firstscanlength() { - _impl_.firstscanlength_ = 0u; - _impl_._has_bits_[0] &= ~0x00200000u; -} -inline uint32_t Message_ImageMessage::_internal_firstscanlength() const { - return _impl_.firstscanlength_; -} -inline uint32_t Message_ImageMessage::firstscanlength() const { - // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.firstScanLength) - return _internal_firstscanlength(); -} -inline void Message_ImageMessage::_internal_set_firstscanlength(uint32_t value) { - _impl_._has_bits_[0] |= 0x00200000u; - _impl_.firstscanlength_ = value; -} -inline void Message_ImageMessage::set_firstscanlength(uint32_t value) { - _internal_set_firstscanlength(value); - // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.firstScanLength) -} - -// optional uint32 experimentGroupId = 20; -inline bool Message_ImageMessage::_internal_has_experimentgroupid() const { - bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0; - return value; -} -inline bool Message_ImageMessage::has_experimentgroupid() const { - return _internal_has_experimentgroupid(); -} -inline void Message_ImageMessage::clear_experimentgroupid() { - _impl_.experimentgroupid_ = 0u; - _impl_._has_bits_[0] &= ~0x00400000u; -} -inline uint32_t Message_ImageMessage::_internal_experimentgroupid() const { - return _impl_.experimentgroupid_; -} -inline uint32_t Message_ImageMessage::experimentgroupid() const { - // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.experimentGroupId) - return _internal_experimentgroupid(); -} -inline void Message_ImageMessage::_internal_set_experimentgroupid(uint32_t value) { - _impl_._has_bits_[0] |= 0x00400000u; - _impl_.experimentgroupid_ = value; -} -inline void Message_ImageMessage::set_experimentgroupid(uint32_t value) { - _internal_set_experimentgroupid(value); - // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.experimentGroupId) -} - -// optional bytes scansSidecar = 21; -inline bool Message_ImageMessage::_internal_has_scanssidecar() const { - bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; - return value; -} -inline bool Message_ImageMessage::has_scanssidecar() const { - return _internal_has_scanssidecar(); -} -inline void Message_ImageMessage::clear_scanssidecar() { - _impl_.scanssidecar_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000200u; -} -inline const std::string& Message_ImageMessage::scanssidecar() const { - // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.scansSidecar) - return _internal_scanssidecar(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ImageMessage::set_scanssidecar(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.scanssidecar_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.scansSidecar) -} -inline std::string* Message_ImageMessage::mutable_scanssidecar() { - std::string* _s = _internal_mutable_scanssidecar(); - // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.scansSidecar) - return _s; -} -inline const std::string& Message_ImageMessage::_internal_scanssidecar() const { - return _impl_.scanssidecar_.Get(); -} -inline void Message_ImageMessage::_internal_set_scanssidecar(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.scanssidecar_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::_internal_mutable_scanssidecar() { - _impl_._has_bits_[0] |= 0x00000200u; - return _impl_.scanssidecar_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::release_scanssidecar() { - // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.scansSidecar) - if (!_internal_has_scanssidecar()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000200u; - auto* p = _impl_.scanssidecar_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.scanssidecar_.IsDefault()) { - _impl_.scanssidecar_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ImageMessage::set_allocated_scanssidecar(std::string* scanssidecar) { - if (scanssidecar != nullptr) { - _impl_._has_bits_[0] |= 0x00000200u; - } else { - _impl_._has_bits_[0] &= ~0x00000200u; - } - _impl_.scanssidecar_.SetAllocated(scanssidecar, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.scanssidecar_.IsDefault()) { - _impl_.scanssidecar_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.scansSidecar) -} - -// repeated uint32 scanLengths = 22; -inline int Message_ImageMessage::_internal_scanlengths_size() const { - return _impl_.scanlengths_.size(); -} -inline int Message_ImageMessage::scanlengths_size() const { - return _internal_scanlengths_size(); -} -inline void Message_ImageMessage::clear_scanlengths() { - _impl_.scanlengths_.Clear(); -} -inline uint32_t Message_ImageMessage::_internal_scanlengths(int index) const { - return _impl_.scanlengths_.Get(index); -} -inline uint32_t Message_ImageMessage::scanlengths(int index) const { - // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.scanLengths) - return _internal_scanlengths(index); -} -inline void Message_ImageMessage::set_scanlengths(int index, uint32_t value) { - _impl_.scanlengths_.Set(index, value); - // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.scanLengths) -} -inline void Message_ImageMessage::_internal_add_scanlengths(uint32_t value) { - _impl_.scanlengths_.Add(value); -} -inline void Message_ImageMessage::add_scanlengths(uint32_t value) { - _internal_add_scanlengths(value); - // @@protoc_insertion_point(field_add:proto.Message.ImageMessage.scanLengths) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& -Message_ImageMessage::_internal_scanlengths() const { - return _impl_.scanlengths_; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >& -Message_ImageMessage::scanlengths() const { - // @@protoc_insertion_point(field_list:proto.Message.ImageMessage.scanLengths) - return _internal_scanlengths(); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* -Message_ImageMessage::_internal_mutable_scanlengths() { - return &_impl_.scanlengths_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >* -Message_ImageMessage::mutable_scanlengths() { - // @@protoc_insertion_point(field_mutable_list:proto.Message.ImageMessage.scanLengths) - return _internal_mutable_scanlengths(); -} - -// optional bytes midQualityFileSha256 = 23; -inline bool Message_ImageMessage::_internal_has_midqualityfilesha256() const { - bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; - return value; -} -inline bool Message_ImageMessage::has_midqualityfilesha256() const { - return _internal_has_midqualityfilesha256(); -} -inline void Message_ImageMessage::clear_midqualityfilesha256() { - _impl_.midqualityfilesha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000400u; -} -inline const std::string& Message_ImageMessage::midqualityfilesha256() const { - // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.midQualityFileSha256) - return _internal_midqualityfilesha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ImageMessage::set_midqualityfilesha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000400u; - _impl_.midqualityfilesha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.midQualityFileSha256) -} -inline std::string* Message_ImageMessage::mutable_midqualityfilesha256() { - std::string* _s = _internal_mutable_midqualityfilesha256(); - // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.midQualityFileSha256) - return _s; -} -inline const std::string& Message_ImageMessage::_internal_midqualityfilesha256() const { - return _impl_.midqualityfilesha256_.Get(); -} -inline void Message_ImageMessage::_internal_set_midqualityfilesha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000400u; - _impl_.midqualityfilesha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::_internal_mutable_midqualityfilesha256() { - _impl_._has_bits_[0] |= 0x00000400u; - return _impl_.midqualityfilesha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::release_midqualityfilesha256() { - // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.midQualityFileSha256) - if (!_internal_has_midqualityfilesha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000400u; - auto* p = _impl_.midqualityfilesha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.midqualityfilesha256_.IsDefault()) { - _impl_.midqualityfilesha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ImageMessage::set_allocated_midqualityfilesha256(std::string* midqualityfilesha256) { - if (midqualityfilesha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00000400u; - } else { - _impl_._has_bits_[0] &= ~0x00000400u; - } - _impl_.midqualityfilesha256_.SetAllocated(midqualityfilesha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.midqualityfilesha256_.IsDefault()) { - _impl_.midqualityfilesha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.midQualityFileSha256) -} - -// optional bytes midQualityFileEncSha256 = 24; -inline bool Message_ImageMessage::_internal_has_midqualityfileencsha256() const { - bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; - return value; -} -inline bool Message_ImageMessage::has_midqualityfileencsha256() const { - return _internal_has_midqualityfileencsha256(); -} -inline void Message_ImageMessage::clear_midqualityfileencsha256() { - _impl_.midqualityfileencsha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000800u; -} -inline const std::string& Message_ImageMessage::midqualityfileencsha256() const { - // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.midQualityFileEncSha256) - return _internal_midqualityfileencsha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ImageMessage::set_midqualityfileencsha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000800u; - _impl_.midqualityfileencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.midQualityFileEncSha256) -} -inline std::string* Message_ImageMessage::mutable_midqualityfileencsha256() { - std::string* _s = _internal_mutable_midqualityfileencsha256(); - // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.midQualityFileEncSha256) - return _s; -} -inline const std::string& Message_ImageMessage::_internal_midqualityfileencsha256() const { - return _impl_.midqualityfileencsha256_.Get(); -} -inline void Message_ImageMessage::_internal_set_midqualityfileencsha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000800u; - _impl_.midqualityfileencsha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::_internal_mutable_midqualityfileencsha256() { - _impl_._has_bits_[0] |= 0x00000800u; - return _impl_.midqualityfileencsha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::release_midqualityfileencsha256() { - // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.midQualityFileEncSha256) - if (!_internal_has_midqualityfileencsha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000800u; - auto* p = _impl_.midqualityfileencsha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.midqualityfileencsha256_.IsDefault()) { - _impl_.midqualityfileencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ImageMessage::set_allocated_midqualityfileencsha256(std::string* midqualityfileencsha256) { - if (midqualityfileencsha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00000800u; - } else { - _impl_._has_bits_[0] &= ~0x00000800u; - } - _impl_.midqualityfileencsha256_.SetAllocated(midqualityfileencsha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.midqualityfileencsha256_.IsDefault()) { - _impl_.midqualityfileencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.midQualityFileEncSha256) -} - -// optional bool viewOnce = 25; -inline bool Message_ImageMessage::_internal_has_viewonce() const { - bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0; - return value; -} -inline bool Message_ImageMessage::has_viewonce() const { - return _internal_has_viewonce(); -} -inline void Message_ImageMessage::clear_viewonce() { - _impl_.viewonce_ = false; - _impl_._has_bits_[0] &= ~0x00800000u; -} -inline bool Message_ImageMessage::_internal_viewonce() const { - return _impl_.viewonce_; -} -inline bool Message_ImageMessage::viewonce() const { - // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.viewOnce) - return _internal_viewonce(); -} -inline void Message_ImageMessage::_internal_set_viewonce(bool value) { - _impl_._has_bits_[0] |= 0x00800000u; - _impl_.viewonce_ = value; -} -inline void Message_ImageMessage::set_viewonce(bool value) { - _internal_set_viewonce(value); - // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.viewOnce) -} - -// optional string thumbnailDirectPath = 26; -inline bool Message_ImageMessage::_internal_has_thumbnaildirectpath() const { - bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; - return value; -} -inline bool Message_ImageMessage::has_thumbnaildirectpath() const { - return _internal_has_thumbnaildirectpath(); -} -inline void Message_ImageMessage::clear_thumbnaildirectpath() { - _impl_.thumbnaildirectpath_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00001000u; -} -inline const std::string& Message_ImageMessage::thumbnaildirectpath() const { - // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.thumbnailDirectPath) - return _internal_thumbnaildirectpath(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ImageMessage::set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00001000u; - _impl_.thumbnaildirectpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.thumbnailDirectPath) -} -inline std::string* Message_ImageMessage::mutable_thumbnaildirectpath() { - std::string* _s = _internal_mutable_thumbnaildirectpath(); - // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.thumbnailDirectPath) - return _s; -} -inline const std::string& Message_ImageMessage::_internal_thumbnaildirectpath() const { - return _impl_.thumbnaildirectpath_.Get(); -} -inline void Message_ImageMessage::_internal_set_thumbnaildirectpath(const std::string& value) { - _impl_._has_bits_[0] |= 0x00001000u; - _impl_.thumbnaildirectpath_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::_internal_mutable_thumbnaildirectpath() { - _impl_._has_bits_[0] |= 0x00001000u; - return _impl_.thumbnaildirectpath_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::release_thumbnaildirectpath() { - // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.thumbnailDirectPath) - if (!_internal_has_thumbnaildirectpath()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00001000u; - auto* p = _impl_.thumbnaildirectpath_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.thumbnaildirectpath_.IsDefault()) { - _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ImageMessage::set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath) { - if (thumbnaildirectpath != nullptr) { - _impl_._has_bits_[0] |= 0x00001000u; - } else { - _impl_._has_bits_[0] &= ~0x00001000u; - } - _impl_.thumbnaildirectpath_.SetAllocated(thumbnaildirectpath, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.thumbnaildirectpath_.IsDefault()) { - _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.thumbnailDirectPath) -} - -// optional bytes thumbnailSha256 = 27; -inline bool Message_ImageMessage::_internal_has_thumbnailsha256() const { - bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0; - return value; -} -inline bool Message_ImageMessage::has_thumbnailsha256() const { - return _internal_has_thumbnailsha256(); -} -inline void Message_ImageMessage::clear_thumbnailsha256() { - _impl_.thumbnailsha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00002000u; -} -inline const std::string& Message_ImageMessage::thumbnailsha256() const { - // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.thumbnailSha256) - return _internal_thumbnailsha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ImageMessage::set_thumbnailsha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00002000u; - _impl_.thumbnailsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.thumbnailSha256) -} -inline std::string* Message_ImageMessage::mutable_thumbnailsha256() { - std::string* _s = _internal_mutable_thumbnailsha256(); - // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.thumbnailSha256) - return _s; -} -inline const std::string& Message_ImageMessage::_internal_thumbnailsha256() const { - return _impl_.thumbnailsha256_.Get(); -} -inline void Message_ImageMessage::_internal_set_thumbnailsha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00002000u; - _impl_.thumbnailsha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::_internal_mutable_thumbnailsha256() { - _impl_._has_bits_[0] |= 0x00002000u; - return _impl_.thumbnailsha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::release_thumbnailsha256() { - // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.thumbnailSha256) - if (!_internal_has_thumbnailsha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00002000u; - auto* p = _impl_.thumbnailsha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.thumbnailsha256_.IsDefault()) { - _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ImageMessage::set_allocated_thumbnailsha256(std::string* thumbnailsha256) { - if (thumbnailsha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00002000u; - } else { - _impl_._has_bits_[0] &= ~0x00002000u; - } - _impl_.thumbnailsha256_.SetAllocated(thumbnailsha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.thumbnailsha256_.IsDefault()) { - _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.thumbnailSha256) -} - -// optional bytes thumbnailEncSha256 = 28; -inline bool Message_ImageMessage::_internal_has_thumbnailencsha256() const { - bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0; - return value; -} -inline bool Message_ImageMessage::has_thumbnailencsha256() const { - return _internal_has_thumbnailencsha256(); -} -inline void Message_ImageMessage::clear_thumbnailencsha256() { - _impl_.thumbnailencsha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00004000u; -} -inline const std::string& Message_ImageMessage::thumbnailencsha256() const { - // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.thumbnailEncSha256) - return _internal_thumbnailencsha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ImageMessage::set_thumbnailencsha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00004000u; - _impl_.thumbnailencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.thumbnailEncSha256) -} -inline std::string* Message_ImageMessage::mutable_thumbnailencsha256() { - std::string* _s = _internal_mutable_thumbnailencsha256(); - // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.thumbnailEncSha256) - return _s; -} -inline const std::string& Message_ImageMessage::_internal_thumbnailencsha256() const { - return _impl_.thumbnailencsha256_.Get(); -} -inline void Message_ImageMessage::_internal_set_thumbnailencsha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00004000u; - _impl_.thumbnailencsha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::_internal_mutable_thumbnailencsha256() { - _impl_._has_bits_[0] |= 0x00004000u; - return _impl_.thumbnailencsha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::release_thumbnailencsha256() { - // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.thumbnailEncSha256) - if (!_internal_has_thumbnailencsha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00004000u; - auto* p = _impl_.thumbnailencsha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.thumbnailencsha256_.IsDefault()) { - _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ImageMessage::set_allocated_thumbnailencsha256(std::string* thumbnailencsha256) { - if (thumbnailencsha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00004000u; - } else { - _impl_._has_bits_[0] &= ~0x00004000u; - } - _impl_.thumbnailencsha256_.SetAllocated(thumbnailencsha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.thumbnailencsha256_.IsDefault()) { - _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.thumbnailEncSha256) -} - -// optional string staticUrl = 29; -inline bool Message_ImageMessage::_internal_has_staticurl() const { - bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0; - return value; -} -inline bool Message_ImageMessage::has_staticurl() const { - return _internal_has_staticurl(); -} -inline void Message_ImageMessage::clear_staticurl() { - _impl_.staticurl_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00008000u; -} -inline const std::string& Message_ImageMessage::staticurl() const { - // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.staticUrl) - return _internal_staticurl(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ImageMessage::set_staticurl(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00008000u; - _impl_.staticurl_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.staticUrl) -} -inline std::string* Message_ImageMessage::mutable_staticurl() { - std::string* _s = _internal_mutable_staticurl(); - // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.staticUrl) - return _s; -} -inline const std::string& Message_ImageMessage::_internal_staticurl() const { - return _impl_.staticurl_.Get(); -} -inline void Message_ImageMessage::_internal_set_staticurl(const std::string& value) { - _impl_._has_bits_[0] |= 0x00008000u; - _impl_.staticurl_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::_internal_mutable_staticurl() { - _impl_._has_bits_[0] |= 0x00008000u; - return _impl_.staticurl_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ImageMessage::release_staticurl() { - // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.staticUrl) - if (!_internal_has_staticurl()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00008000u; - auto* p = _impl_.staticurl_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.staticurl_.IsDefault()) { - _impl_.staticurl_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ImageMessage::set_allocated_staticurl(std::string* staticurl) { - if (staticurl != nullptr) { - _impl_._has_bits_[0] |= 0x00008000u; - } else { - _impl_._has_bits_[0] &= ~0x00008000u; - } - _impl_.staticurl_.SetAllocated(staticurl, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.staticurl_.IsDefault()) { - _impl_.staticurl_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.staticUrl) -} - -// ------------------------------------------------------------------- - -// Message_InitialSecurityNotificationSettingSync - -// optional bool securityNotificationEnabled = 1; -inline bool Message_InitialSecurityNotificationSettingSync::_internal_has_securitynotificationenabled() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_InitialSecurityNotificationSettingSync::has_securitynotificationenabled() const { - return _internal_has_securitynotificationenabled(); -} -inline void Message_InitialSecurityNotificationSettingSync::clear_securitynotificationenabled() { - _impl_.securitynotificationenabled_ = false; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline bool Message_InitialSecurityNotificationSettingSync::_internal_securitynotificationenabled() const { - return _impl_.securitynotificationenabled_; -} -inline bool Message_InitialSecurityNotificationSettingSync::securitynotificationenabled() const { - // @@protoc_insertion_point(field_get:proto.Message.InitialSecurityNotificationSettingSync.securityNotificationEnabled) - return _internal_securitynotificationenabled(); -} -inline void Message_InitialSecurityNotificationSettingSync::_internal_set_securitynotificationenabled(bool value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.securitynotificationenabled_ = value; -} -inline void Message_InitialSecurityNotificationSettingSync::set_securitynotificationenabled(bool value) { - _internal_set_securitynotificationenabled(value); - // @@protoc_insertion_point(field_set:proto.Message.InitialSecurityNotificationSettingSync.securityNotificationEnabled) -} - -// ------------------------------------------------------------------- - -// Message_InteractiveMessage_Body - -// optional string text = 1; -inline bool Message_InteractiveMessage_Body::_internal_has_text() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_InteractiveMessage_Body::has_text() const { - return _internal_has_text(); -} -inline void Message_InteractiveMessage_Body::clear_text() { - _impl_.text_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_InteractiveMessage_Body::text() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Body.text) - return _internal_text(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_InteractiveMessage_Body::set_text(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.text_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.Body.text) -} -inline std::string* Message_InteractiveMessage_Body::mutable_text() { - std::string* _s = _internal_mutable_text(); - // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Body.text) - return _s; -} -inline const std::string& Message_InteractiveMessage_Body::_internal_text() const { - return _impl_.text_.Get(); -} -inline void Message_InteractiveMessage_Body::_internal_set_text(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.text_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_InteractiveMessage_Body::_internal_mutable_text() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.text_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_InteractiveMessage_Body::release_text() { - // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Body.text) - if (!_internal_has_text()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.text_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.text_.IsDefault()) { - _impl_.text_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_InteractiveMessage_Body::set_allocated_text(std::string* text) { - if (text != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.text_.SetAllocated(text, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.text_.IsDefault()) { - _impl_.text_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.Body.text) -} - -// ------------------------------------------------------------------- - -// Message_InteractiveMessage_CollectionMessage - -// optional string bizJid = 1; -inline bool Message_InteractiveMessage_CollectionMessage::_internal_has_bizjid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_InteractiveMessage_CollectionMessage::has_bizjid() const { - return _internal_has_bizjid(); -} -inline void Message_InteractiveMessage_CollectionMessage::clear_bizjid() { - _impl_.bizjid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_InteractiveMessage_CollectionMessage::bizjid() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.CollectionMessage.bizJid) - return _internal_bizjid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_InteractiveMessage_CollectionMessage::set_bizjid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.bizjid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.CollectionMessage.bizJid) -} -inline std::string* Message_InteractiveMessage_CollectionMessage::mutable_bizjid() { - std::string* _s = _internal_mutable_bizjid(); - // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.CollectionMessage.bizJid) - return _s; -} -inline const std::string& Message_InteractiveMessage_CollectionMessage::_internal_bizjid() const { - return _impl_.bizjid_.Get(); -} -inline void Message_InteractiveMessage_CollectionMessage::_internal_set_bizjid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.bizjid_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_InteractiveMessage_CollectionMessage::_internal_mutable_bizjid() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.bizjid_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_InteractiveMessage_CollectionMessage::release_bizjid() { - // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.CollectionMessage.bizJid) - if (!_internal_has_bizjid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.bizjid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.bizjid_.IsDefault()) { - _impl_.bizjid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_InteractiveMessage_CollectionMessage::set_allocated_bizjid(std::string* bizjid) { - if (bizjid != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.bizjid_.SetAllocated(bizjid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.bizjid_.IsDefault()) { - _impl_.bizjid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.CollectionMessage.bizJid) -} - -// optional string id = 2; -inline bool Message_InteractiveMessage_CollectionMessage::_internal_has_id() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_InteractiveMessage_CollectionMessage::has_id() const { - return _internal_has_id(); -} -inline void Message_InteractiveMessage_CollectionMessage::clear_id() { - _impl_.id_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_InteractiveMessage_CollectionMessage::id() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.CollectionMessage.id) - return _internal_id(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_InteractiveMessage_CollectionMessage::set_id(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.id_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.CollectionMessage.id) -} -inline std::string* Message_InteractiveMessage_CollectionMessage::mutable_id() { - std::string* _s = _internal_mutable_id(); - // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.CollectionMessage.id) - return _s; -} -inline const std::string& Message_InteractiveMessage_CollectionMessage::_internal_id() const { - return _impl_.id_.Get(); -} -inline void Message_InteractiveMessage_CollectionMessage::_internal_set_id(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.id_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_InteractiveMessage_CollectionMessage::_internal_mutable_id() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.id_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_InteractiveMessage_CollectionMessage::release_id() { - // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.CollectionMessage.id) - if (!_internal_has_id()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.id_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.id_.IsDefault()) { - _impl_.id_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_InteractiveMessage_CollectionMessage::set_allocated_id(std::string* id) { - if (id != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.id_.SetAllocated(id, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.id_.IsDefault()) { - _impl_.id_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.CollectionMessage.id) -} - -// optional int32 messageVersion = 3; -inline bool Message_InteractiveMessage_CollectionMessage::_internal_has_messageversion() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool Message_InteractiveMessage_CollectionMessage::has_messageversion() const { - return _internal_has_messageversion(); -} -inline void Message_InteractiveMessage_CollectionMessage::clear_messageversion() { - _impl_.messageversion_ = 0; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline int32_t Message_InteractiveMessage_CollectionMessage::_internal_messageversion() const { - return _impl_.messageversion_; -} -inline int32_t Message_InteractiveMessage_CollectionMessage::messageversion() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.CollectionMessage.messageVersion) - return _internal_messageversion(); -} -inline void Message_InteractiveMessage_CollectionMessage::_internal_set_messageversion(int32_t value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.messageversion_ = value; -} -inline void Message_InteractiveMessage_CollectionMessage::set_messageversion(int32_t value) { - _internal_set_messageversion(value); - // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.CollectionMessage.messageVersion) -} - -// ------------------------------------------------------------------- - -// Message_InteractiveMessage_Footer - -// optional string text = 1; -inline bool Message_InteractiveMessage_Footer::_internal_has_text() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_InteractiveMessage_Footer::has_text() const { - return _internal_has_text(); -} -inline void Message_InteractiveMessage_Footer::clear_text() { - _impl_.text_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_InteractiveMessage_Footer::text() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Footer.text) - return _internal_text(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_InteractiveMessage_Footer::set_text(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.text_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.Footer.text) -} -inline std::string* Message_InteractiveMessage_Footer::mutable_text() { - std::string* _s = _internal_mutable_text(); - // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Footer.text) - return _s; -} -inline const std::string& Message_InteractiveMessage_Footer::_internal_text() const { - return _impl_.text_.Get(); -} -inline void Message_InteractiveMessage_Footer::_internal_set_text(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.text_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_InteractiveMessage_Footer::_internal_mutable_text() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.text_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_InteractiveMessage_Footer::release_text() { - // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Footer.text) - if (!_internal_has_text()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.text_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.text_.IsDefault()) { - _impl_.text_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_InteractiveMessage_Footer::set_allocated_text(std::string* text) { - if (text != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.text_.SetAllocated(text, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.text_.IsDefault()) { - _impl_.text_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.Footer.text) -} - -// ------------------------------------------------------------------- - -// Message_InteractiveMessage_Header - -// optional string title = 1; -inline bool Message_InteractiveMessage_Header::_internal_has_title() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_InteractiveMessage_Header::has_title() const { - return _internal_has_title(); -} -inline void Message_InteractiveMessage_Header::clear_title() { - _impl_.title_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_InteractiveMessage_Header::title() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Header.title) - return _internal_title(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_InteractiveMessage_Header::set_title(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.title_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.Header.title) -} -inline std::string* Message_InteractiveMessage_Header::mutable_title() { - std::string* _s = _internal_mutable_title(); - // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Header.title) - return _s; -} -inline const std::string& Message_InteractiveMessage_Header::_internal_title() const { - return _impl_.title_.Get(); -} -inline void Message_InteractiveMessage_Header::_internal_set_title(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.title_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_InteractiveMessage_Header::_internal_mutable_title() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.title_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_InteractiveMessage_Header::release_title() { - // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Header.title) - if (!_internal_has_title()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.title_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.title_.IsDefault()) { - _impl_.title_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_InteractiveMessage_Header::set_allocated_title(std::string* title) { - if (title != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.title_.SetAllocated(title, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.title_.IsDefault()) { - _impl_.title_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.Header.title) -} - -// optional string subtitle = 2; -inline bool Message_InteractiveMessage_Header::_internal_has_subtitle() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_InteractiveMessage_Header::has_subtitle() const { - return _internal_has_subtitle(); -} -inline void Message_InteractiveMessage_Header::clear_subtitle() { - _impl_.subtitle_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_InteractiveMessage_Header::subtitle() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Header.subtitle) - return _internal_subtitle(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_InteractiveMessage_Header::set_subtitle(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.subtitle_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.Header.subtitle) -} -inline std::string* Message_InteractiveMessage_Header::mutable_subtitle() { - std::string* _s = _internal_mutable_subtitle(); - // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Header.subtitle) - return _s; -} -inline const std::string& Message_InteractiveMessage_Header::_internal_subtitle() const { - return _impl_.subtitle_.Get(); -} -inline void Message_InteractiveMessage_Header::_internal_set_subtitle(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.subtitle_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_InteractiveMessage_Header::_internal_mutable_subtitle() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.subtitle_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_InteractiveMessage_Header::release_subtitle() { - // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Header.subtitle) - if (!_internal_has_subtitle()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.subtitle_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.subtitle_.IsDefault()) { - _impl_.subtitle_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_InteractiveMessage_Header::set_allocated_subtitle(std::string* subtitle) { - if (subtitle != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.subtitle_.SetAllocated(subtitle, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.subtitle_.IsDefault()) { - _impl_.subtitle_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.Header.subtitle) -} - -// optional bool hasMediaAttachment = 5; -inline bool Message_InteractiveMessage_Header::_internal_has_hasmediaattachment() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool Message_InteractiveMessage_Header::has_hasmediaattachment() const { - return _internal_has_hasmediaattachment(); -} -inline void Message_InteractiveMessage_Header::clear_hasmediaattachment() { - _impl_.hasmediaattachment_ = false; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline bool Message_InteractiveMessage_Header::_internal_hasmediaattachment() const { - return _impl_.hasmediaattachment_; -} -inline bool Message_InteractiveMessage_Header::hasmediaattachment() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Header.hasMediaAttachment) - return _internal_hasmediaattachment(); -} -inline void Message_InteractiveMessage_Header::_internal_set_hasmediaattachment(bool value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.hasmediaattachment_ = value; -} -inline void Message_InteractiveMessage_Header::set_hasmediaattachment(bool value) { - _internal_set_hasmediaattachment(value); - // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.Header.hasMediaAttachment) -} - -// .proto.Message.DocumentMessage documentMessage = 3; -inline bool Message_InteractiveMessage_Header::_internal_has_documentmessage() const { - return media_case() == kDocumentMessage; -} -inline bool Message_InteractiveMessage_Header::has_documentmessage() const { - return _internal_has_documentmessage(); -} -inline void Message_InteractiveMessage_Header::set_has_documentmessage() { - _impl_._oneof_case_[0] = kDocumentMessage; -} -inline void Message_InteractiveMessage_Header::clear_documentmessage() { - if (_internal_has_documentmessage()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.media_.documentmessage_; - } - clear_has_media(); - } -} -inline ::proto::Message_DocumentMessage* Message_InteractiveMessage_Header::release_documentmessage() { - // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Header.documentMessage) - if (_internal_has_documentmessage()) { - clear_has_media(); - ::proto::Message_DocumentMessage* temp = _impl_.media_.documentmessage_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.media_.documentmessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::Message_DocumentMessage& Message_InteractiveMessage_Header::_internal_documentmessage() const { - return _internal_has_documentmessage() - ? *_impl_.media_.documentmessage_ - : reinterpret_cast< ::proto::Message_DocumentMessage&>(::proto::_Message_DocumentMessage_default_instance_); -} -inline const ::proto::Message_DocumentMessage& Message_InteractiveMessage_Header::documentmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Header.documentMessage) - return _internal_documentmessage(); -} -inline ::proto::Message_DocumentMessage* Message_InteractiveMessage_Header::unsafe_arena_release_documentmessage() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.InteractiveMessage.Header.documentMessage) - if (_internal_has_documentmessage()) { - clear_has_media(); - ::proto::Message_DocumentMessage* temp = _impl_.media_.documentmessage_; - _impl_.media_.documentmessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Message_InteractiveMessage_Header::unsafe_arena_set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) { - clear_media(); - if (documentmessage) { - set_has_documentmessage(); - _impl_.media_.documentmessage_ = documentmessage; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.Header.documentMessage) -} -inline ::proto::Message_DocumentMessage* Message_InteractiveMessage_Header::_internal_mutable_documentmessage() { - if (!_internal_has_documentmessage()) { - clear_media(); - set_has_documentmessage(); - _impl_.media_.documentmessage_ = CreateMaybeMessage< ::proto::Message_DocumentMessage >(GetArenaForAllocation()); - } - return _impl_.media_.documentmessage_; -} -inline ::proto::Message_DocumentMessage* Message_InteractiveMessage_Header::mutable_documentmessage() { - ::proto::Message_DocumentMessage* _msg = _internal_mutable_documentmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Header.documentMessage) - return _msg; -} - -// .proto.Message.ImageMessage imageMessage = 4; -inline bool Message_InteractiveMessage_Header::_internal_has_imagemessage() const { - return media_case() == kImageMessage; -} -inline bool Message_InteractiveMessage_Header::has_imagemessage() const { - return _internal_has_imagemessage(); -} -inline void Message_InteractiveMessage_Header::set_has_imagemessage() { - _impl_._oneof_case_[0] = kImageMessage; -} -inline void Message_InteractiveMessage_Header::clear_imagemessage() { - if (_internal_has_imagemessage()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.media_.imagemessage_; - } - clear_has_media(); - } -} -inline ::proto::Message_ImageMessage* Message_InteractiveMessage_Header::release_imagemessage() { - // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Header.imageMessage) - if (_internal_has_imagemessage()) { - clear_has_media(); - ::proto::Message_ImageMessage* temp = _impl_.media_.imagemessage_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.media_.imagemessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::Message_ImageMessage& Message_InteractiveMessage_Header::_internal_imagemessage() const { - return _internal_has_imagemessage() - ? *_impl_.media_.imagemessage_ - : reinterpret_cast< ::proto::Message_ImageMessage&>(::proto::_Message_ImageMessage_default_instance_); -} -inline const ::proto::Message_ImageMessage& Message_InteractiveMessage_Header::imagemessage() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Header.imageMessage) - return _internal_imagemessage(); -} -inline ::proto::Message_ImageMessage* Message_InteractiveMessage_Header::unsafe_arena_release_imagemessage() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.InteractiveMessage.Header.imageMessage) - if (_internal_has_imagemessage()) { - clear_has_media(); - ::proto::Message_ImageMessage* temp = _impl_.media_.imagemessage_; - _impl_.media_.imagemessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Message_InteractiveMessage_Header::unsafe_arena_set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) { - clear_media(); - if (imagemessage) { - set_has_imagemessage(); - _impl_.media_.imagemessage_ = imagemessage; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.Header.imageMessage) -} -inline ::proto::Message_ImageMessage* Message_InteractiveMessage_Header::_internal_mutable_imagemessage() { - if (!_internal_has_imagemessage()) { - clear_media(); - set_has_imagemessage(); - _impl_.media_.imagemessage_ = CreateMaybeMessage< ::proto::Message_ImageMessage >(GetArenaForAllocation()); - } - return _impl_.media_.imagemessage_; -} -inline ::proto::Message_ImageMessage* Message_InteractiveMessage_Header::mutable_imagemessage() { - ::proto::Message_ImageMessage* _msg = _internal_mutable_imagemessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Header.imageMessage) - return _msg; -} - -// bytes jpegThumbnail = 6; -inline bool Message_InteractiveMessage_Header::_internal_has_jpegthumbnail() const { - return media_case() == kJpegThumbnail; -} -inline bool Message_InteractiveMessage_Header::has_jpegthumbnail() const { - return _internal_has_jpegthumbnail(); -} -inline void Message_InteractiveMessage_Header::set_has_jpegthumbnail() { - _impl_._oneof_case_[0] = kJpegThumbnail; -} -inline void Message_InteractiveMessage_Header::clear_jpegthumbnail() { - if (_internal_has_jpegthumbnail()) { - _impl_.media_.jpegthumbnail_.Destroy(); - clear_has_media(); - } -} -inline const std::string& Message_InteractiveMessage_Header::jpegthumbnail() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Header.jpegThumbnail) - return _internal_jpegthumbnail(); -} -template -inline void Message_InteractiveMessage_Header::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) { - if (!_internal_has_jpegthumbnail()) { - clear_media(); - set_has_jpegthumbnail(); - _impl_.media_.jpegthumbnail_.InitDefault(); - } - _impl_.media_.jpegthumbnail_.SetBytes( static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.Header.jpegThumbnail) -} -inline std::string* Message_InteractiveMessage_Header::mutable_jpegthumbnail() { - std::string* _s = _internal_mutable_jpegthumbnail(); - // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Header.jpegThumbnail) - return _s; -} -inline const std::string& Message_InteractiveMessage_Header::_internal_jpegthumbnail() const { - if (_internal_has_jpegthumbnail()) { - return _impl_.media_.jpegthumbnail_.Get(); - } - return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); -} -inline void Message_InteractiveMessage_Header::_internal_set_jpegthumbnail(const std::string& value) { - if (!_internal_has_jpegthumbnail()) { - clear_media(); - set_has_jpegthumbnail(); - _impl_.media_.jpegthumbnail_.InitDefault(); - } - _impl_.media_.jpegthumbnail_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_InteractiveMessage_Header::_internal_mutable_jpegthumbnail() { - if (!_internal_has_jpegthumbnail()) { - clear_media(); - set_has_jpegthumbnail(); - _impl_.media_.jpegthumbnail_.InitDefault(); - } - return _impl_.media_.jpegthumbnail_.Mutable( GetArenaForAllocation()); -} -inline std::string* Message_InteractiveMessage_Header::release_jpegthumbnail() { - // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Header.jpegThumbnail) - if (_internal_has_jpegthumbnail()) { - clear_has_media(); - return _impl_.media_.jpegthumbnail_.Release(); - } else { - return nullptr; - } -} -inline void Message_InteractiveMessage_Header::set_allocated_jpegthumbnail(std::string* jpegthumbnail) { - if (has_media()) { - clear_media(); - } - if (jpegthumbnail != nullptr) { - set_has_jpegthumbnail(); - _impl_.media_.jpegthumbnail_.InitAllocated(jpegthumbnail, GetArenaForAllocation()); - } - // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.Header.jpegThumbnail) -} - -// .proto.Message.VideoMessage videoMessage = 7; -inline bool Message_InteractiveMessage_Header::_internal_has_videomessage() const { - return media_case() == kVideoMessage; -} -inline bool Message_InteractiveMessage_Header::has_videomessage() const { - return _internal_has_videomessage(); -} -inline void Message_InteractiveMessage_Header::set_has_videomessage() { - _impl_._oneof_case_[0] = kVideoMessage; -} -inline void Message_InteractiveMessage_Header::clear_videomessage() { - if (_internal_has_videomessage()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.media_.videomessage_; - } - clear_has_media(); - } -} -inline ::proto::Message_VideoMessage* Message_InteractiveMessage_Header::release_videomessage() { - // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Header.videoMessage) - if (_internal_has_videomessage()) { - clear_has_media(); - ::proto::Message_VideoMessage* temp = _impl_.media_.videomessage_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.media_.videomessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::Message_VideoMessage& Message_InteractiveMessage_Header::_internal_videomessage() const { - return _internal_has_videomessage() - ? *_impl_.media_.videomessage_ - : reinterpret_cast< ::proto::Message_VideoMessage&>(::proto::_Message_VideoMessage_default_instance_); -} -inline const ::proto::Message_VideoMessage& Message_InteractiveMessage_Header::videomessage() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Header.videoMessage) - return _internal_videomessage(); -} -inline ::proto::Message_VideoMessage* Message_InteractiveMessage_Header::unsafe_arena_release_videomessage() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.InteractiveMessage.Header.videoMessage) - if (_internal_has_videomessage()) { - clear_has_media(); - ::proto::Message_VideoMessage* temp = _impl_.media_.videomessage_; - _impl_.media_.videomessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Message_InteractiveMessage_Header::unsafe_arena_set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) { - clear_media(); - if (videomessage) { - set_has_videomessage(); - _impl_.media_.videomessage_ = videomessage; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.Header.videoMessage) -} -inline ::proto::Message_VideoMessage* Message_InteractiveMessage_Header::_internal_mutable_videomessage() { - if (!_internal_has_videomessage()) { - clear_media(); - set_has_videomessage(); - _impl_.media_.videomessage_ = CreateMaybeMessage< ::proto::Message_VideoMessage >(GetArenaForAllocation()); - } - return _impl_.media_.videomessage_; -} -inline ::proto::Message_VideoMessage* Message_InteractiveMessage_Header::mutable_videomessage() { - ::proto::Message_VideoMessage* _msg = _internal_mutable_videomessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Header.videoMessage) - return _msg; -} - -inline bool Message_InteractiveMessage_Header::has_media() const { - return media_case() != MEDIA_NOT_SET; -} -inline void Message_InteractiveMessage_Header::clear_has_media() { - _impl_._oneof_case_[0] = MEDIA_NOT_SET; -} -inline Message_InteractiveMessage_Header::MediaCase Message_InteractiveMessage_Header::media_case() const { - return Message_InteractiveMessage_Header::MediaCase(_impl_._oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton - -// optional string name = 1; -inline bool Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_has_name() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::has_name() const { - return _internal_has_name(); -} -inline void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::clear_name() { - _impl_.name_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::name() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.name) - return _internal_name(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::set_name(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.name) -} -inline std::string* Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::mutable_name() { - std::string* _s = _internal_mutable_name(); - // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.name) - return _s; -} -inline const std::string& Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_name() const { - return _impl_.name_.Get(); -} -inline void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_set_name(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.name_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_mutable_name() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.name_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::release_name() { - // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.name) - if (!_internal_has_name()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.name_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.name_.IsDefault()) { - _impl_.name_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::set_allocated_name(std::string* name) { - if (name != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.name_.SetAllocated(name, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.name_.IsDefault()) { - _impl_.name_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.name) -} - -// optional string buttonParamsJson = 2; -inline bool Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_has_buttonparamsjson() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::has_buttonparamsjson() const { - return _internal_has_buttonparamsjson(); -} -inline void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::clear_buttonparamsjson() { - _impl_.buttonparamsjson_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::buttonparamsjson() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.buttonParamsJson) - return _internal_buttonparamsjson(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::set_buttonparamsjson(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.buttonparamsjson_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.buttonParamsJson) -} -inline std::string* Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::mutable_buttonparamsjson() { - std::string* _s = _internal_mutable_buttonparamsjson(); - // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.buttonParamsJson) - return _s; -} -inline const std::string& Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_buttonparamsjson() const { - return _impl_.buttonparamsjson_.Get(); -} -inline void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_set_buttonparamsjson(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.buttonparamsjson_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_mutable_buttonparamsjson() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.buttonparamsjson_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::release_buttonparamsjson() { - // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.buttonParamsJson) - if (!_internal_has_buttonparamsjson()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.buttonparamsjson_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.buttonparamsjson_.IsDefault()) { - _impl_.buttonparamsjson_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::set_allocated_buttonparamsjson(std::string* buttonparamsjson) { - if (buttonparamsjson != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.buttonparamsjson_.SetAllocated(buttonparamsjson, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.buttonparamsjson_.IsDefault()) { - _impl_.buttonparamsjson_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.buttonParamsJson) -} - -// ------------------------------------------------------------------- - -// Message_InteractiveMessage_NativeFlowMessage - -// repeated .proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton buttons = 1; -inline int Message_InteractiveMessage_NativeFlowMessage::_internal_buttons_size() const { - return _impl_.buttons_.size(); -} -inline int Message_InteractiveMessage_NativeFlowMessage::buttons_size() const { - return _internal_buttons_size(); -} -inline void Message_InteractiveMessage_NativeFlowMessage::clear_buttons() { - _impl_.buttons_.Clear(); -} -inline ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* Message_InteractiveMessage_NativeFlowMessage::mutable_buttons(int index) { - // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.NativeFlowMessage.buttons) - return _impl_.buttons_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton >* -Message_InteractiveMessage_NativeFlowMessage::mutable_buttons() { - // @@protoc_insertion_point(field_mutable_list:proto.Message.InteractiveMessage.NativeFlowMessage.buttons) - return &_impl_.buttons_; -} -inline const ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& Message_InteractiveMessage_NativeFlowMessage::_internal_buttons(int index) const { - return _impl_.buttons_.Get(index); -} -inline const ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& Message_InteractiveMessage_NativeFlowMessage::buttons(int index) const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.NativeFlowMessage.buttons) - return _internal_buttons(index); -} -inline ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* Message_InteractiveMessage_NativeFlowMessage::_internal_add_buttons() { - return _impl_.buttons_.Add(); -} -inline ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* Message_InteractiveMessage_NativeFlowMessage::add_buttons() { - ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* _add = _internal_add_buttons(); - // @@protoc_insertion_point(field_add:proto.Message.InteractiveMessage.NativeFlowMessage.buttons) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton >& -Message_InteractiveMessage_NativeFlowMessage::buttons() const { - // @@protoc_insertion_point(field_list:proto.Message.InteractiveMessage.NativeFlowMessage.buttons) - return _impl_.buttons_; -} - -// optional string messageParamsJson = 2; -inline bool Message_InteractiveMessage_NativeFlowMessage::_internal_has_messageparamsjson() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_InteractiveMessage_NativeFlowMessage::has_messageparamsjson() const { - return _internal_has_messageparamsjson(); -} -inline void Message_InteractiveMessage_NativeFlowMessage::clear_messageparamsjson() { - _impl_.messageparamsjson_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_InteractiveMessage_NativeFlowMessage::messageparamsjson() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.NativeFlowMessage.messageParamsJson) - return _internal_messageparamsjson(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_InteractiveMessage_NativeFlowMessage::set_messageparamsjson(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.messageparamsjson_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.NativeFlowMessage.messageParamsJson) -} -inline std::string* Message_InteractiveMessage_NativeFlowMessage::mutable_messageparamsjson() { - std::string* _s = _internal_mutable_messageparamsjson(); - // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.NativeFlowMessage.messageParamsJson) - return _s; -} -inline const std::string& Message_InteractiveMessage_NativeFlowMessage::_internal_messageparamsjson() const { - return _impl_.messageparamsjson_.Get(); -} -inline void Message_InteractiveMessage_NativeFlowMessage::_internal_set_messageparamsjson(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.messageparamsjson_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_InteractiveMessage_NativeFlowMessage::_internal_mutable_messageparamsjson() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.messageparamsjson_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_InteractiveMessage_NativeFlowMessage::release_messageparamsjson() { - // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.NativeFlowMessage.messageParamsJson) - if (!_internal_has_messageparamsjson()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.messageparamsjson_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.messageparamsjson_.IsDefault()) { - _impl_.messageparamsjson_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_InteractiveMessage_NativeFlowMessage::set_allocated_messageparamsjson(std::string* messageparamsjson) { - if (messageparamsjson != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.messageparamsjson_.SetAllocated(messageparamsjson, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.messageparamsjson_.IsDefault()) { - _impl_.messageparamsjson_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.NativeFlowMessage.messageParamsJson) -} - -// optional int32 messageVersion = 3; -inline bool Message_InteractiveMessage_NativeFlowMessage::_internal_has_messageversion() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_InteractiveMessage_NativeFlowMessage::has_messageversion() const { - return _internal_has_messageversion(); -} -inline void Message_InteractiveMessage_NativeFlowMessage::clear_messageversion() { - _impl_.messageversion_ = 0; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline int32_t Message_InteractiveMessage_NativeFlowMessage::_internal_messageversion() const { - return _impl_.messageversion_; -} -inline int32_t Message_InteractiveMessage_NativeFlowMessage::messageversion() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.NativeFlowMessage.messageVersion) - return _internal_messageversion(); -} -inline void Message_InteractiveMessage_NativeFlowMessage::_internal_set_messageversion(int32_t value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.messageversion_ = value; -} -inline void Message_InteractiveMessage_NativeFlowMessage::set_messageversion(int32_t value) { - _internal_set_messageversion(value); - // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.NativeFlowMessage.messageVersion) -} - -// ------------------------------------------------------------------- - -// Message_InteractiveMessage_ShopMessage - -// optional string id = 1; -inline bool Message_InteractiveMessage_ShopMessage::_internal_has_id() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_InteractiveMessage_ShopMessage::has_id() const { - return _internal_has_id(); -} -inline void Message_InteractiveMessage_ShopMessage::clear_id() { - _impl_.id_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_InteractiveMessage_ShopMessage::id() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.ShopMessage.id) - return _internal_id(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_InteractiveMessage_ShopMessage::set_id(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.id_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.ShopMessage.id) -} -inline std::string* Message_InteractiveMessage_ShopMessage::mutable_id() { - std::string* _s = _internal_mutable_id(); - // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.ShopMessage.id) - return _s; -} -inline const std::string& Message_InteractiveMessage_ShopMessage::_internal_id() const { - return _impl_.id_.Get(); -} -inline void Message_InteractiveMessage_ShopMessage::_internal_set_id(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.id_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_InteractiveMessage_ShopMessage::_internal_mutable_id() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.id_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_InteractiveMessage_ShopMessage::release_id() { - // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.ShopMessage.id) - if (!_internal_has_id()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.id_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.id_.IsDefault()) { - _impl_.id_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_InteractiveMessage_ShopMessage::set_allocated_id(std::string* id) { - if (id != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.id_.SetAllocated(id, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.id_.IsDefault()) { - _impl_.id_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.ShopMessage.id) -} - -// optional .proto.Message.InteractiveMessage.ShopMessage.Surface surface = 2; -inline bool Message_InteractiveMessage_ShopMessage::_internal_has_surface() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_InteractiveMessage_ShopMessage::has_surface() const { - return _internal_has_surface(); -} -inline void Message_InteractiveMessage_ShopMessage::clear_surface() { - _impl_.surface_ = 0; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline ::proto::Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage::_internal_surface() const { - return static_cast< ::proto::Message_InteractiveMessage_ShopMessage_Surface >(_impl_.surface_); -} -inline ::proto::Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage::surface() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.ShopMessage.surface) - return _internal_surface(); -} -inline void Message_InteractiveMessage_ShopMessage::_internal_set_surface(::proto::Message_InteractiveMessage_ShopMessage_Surface value) { - assert(::proto::Message_InteractiveMessage_ShopMessage_Surface_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.surface_ = value; -} -inline void Message_InteractiveMessage_ShopMessage::set_surface(::proto::Message_InteractiveMessage_ShopMessage_Surface value) { - _internal_set_surface(value); - // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.ShopMessage.surface) -} - -// optional int32 messageVersion = 3; -inline bool Message_InteractiveMessage_ShopMessage::_internal_has_messageversion() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool Message_InteractiveMessage_ShopMessage::has_messageversion() const { - return _internal_has_messageversion(); -} -inline void Message_InteractiveMessage_ShopMessage::clear_messageversion() { - _impl_.messageversion_ = 0; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline int32_t Message_InteractiveMessage_ShopMessage::_internal_messageversion() const { - return _impl_.messageversion_; -} -inline int32_t Message_InteractiveMessage_ShopMessage::messageversion() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.ShopMessage.messageVersion) - return _internal_messageversion(); -} -inline void Message_InteractiveMessage_ShopMessage::_internal_set_messageversion(int32_t value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.messageversion_ = value; -} -inline void Message_InteractiveMessage_ShopMessage::set_messageversion(int32_t value) { - _internal_set_messageversion(value); - // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.ShopMessage.messageVersion) -} - -// ------------------------------------------------------------------- - -// Message_InteractiveMessage - -// optional .proto.Message.InteractiveMessage.Header header = 1; -inline bool Message_InteractiveMessage::_internal_has_header() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.header_ != nullptr); - return value; -} -inline bool Message_InteractiveMessage::has_header() const { - return _internal_has_header(); -} -inline void Message_InteractiveMessage::clear_header() { - if (_impl_.header_ != nullptr) _impl_.header_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::Message_InteractiveMessage_Header& Message_InteractiveMessage::_internal_header() const { - const ::proto::Message_InteractiveMessage_Header* p = _impl_.header_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_InteractiveMessage_Header_default_instance_); -} -inline const ::proto::Message_InteractiveMessage_Header& Message_InteractiveMessage::header() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.header) - return _internal_header(); -} -inline void Message_InteractiveMessage::unsafe_arena_set_allocated_header( - ::proto::Message_InteractiveMessage_Header* header) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.header_); - } - _impl_.header_ = header; - if (header) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.header) -} -inline ::proto::Message_InteractiveMessage_Header* Message_InteractiveMessage::release_header() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::Message_InteractiveMessage_Header* temp = _impl_.header_; - _impl_.header_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_InteractiveMessage_Header* Message_InteractiveMessage::unsafe_arena_release_header() { - // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.header) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::Message_InteractiveMessage_Header* temp = _impl_.header_; - _impl_.header_ = nullptr; - return temp; -} -inline ::proto::Message_InteractiveMessage_Header* Message_InteractiveMessage::_internal_mutable_header() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.header_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_InteractiveMessage_Header>(GetArenaForAllocation()); - _impl_.header_ = p; - } - return _impl_.header_; -} -inline ::proto::Message_InteractiveMessage_Header* Message_InteractiveMessage::mutable_header() { - ::proto::Message_InteractiveMessage_Header* _msg = _internal_mutable_header(); - // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.header) - return _msg; -} -inline void Message_InteractiveMessage::set_allocated_header(::proto::Message_InteractiveMessage_Header* header) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.header_; - } - if (header) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(header); - if (message_arena != submessage_arena) { - header = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, header, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.header_ = header; - // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.header) -} - -// optional .proto.Message.InteractiveMessage.Body body = 2; -inline bool Message_InteractiveMessage::_internal_has_body() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.body_ != nullptr); - return value; -} -inline bool Message_InteractiveMessage::has_body() const { - return _internal_has_body(); -} -inline void Message_InteractiveMessage::clear_body() { - if (_impl_.body_ != nullptr) _impl_.body_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::Message_InteractiveMessage_Body& Message_InteractiveMessage::_internal_body() const { - const ::proto::Message_InteractiveMessage_Body* p = _impl_.body_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_InteractiveMessage_Body_default_instance_); -} -inline const ::proto::Message_InteractiveMessage_Body& Message_InteractiveMessage::body() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.body) - return _internal_body(); -} -inline void Message_InteractiveMessage::unsafe_arena_set_allocated_body( - ::proto::Message_InteractiveMessage_Body* body) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.body_); - } - _impl_.body_ = body; - if (body) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.body) -} -inline ::proto::Message_InteractiveMessage_Body* Message_InteractiveMessage::release_body() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::Message_InteractiveMessage_Body* temp = _impl_.body_; - _impl_.body_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_InteractiveMessage_Body* Message_InteractiveMessage::unsafe_arena_release_body() { - // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.body) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::Message_InteractiveMessage_Body* temp = _impl_.body_; - _impl_.body_ = nullptr; - return temp; -} -inline ::proto::Message_InteractiveMessage_Body* Message_InteractiveMessage::_internal_mutable_body() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.body_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_InteractiveMessage_Body>(GetArenaForAllocation()); - _impl_.body_ = p; - } - return _impl_.body_; -} -inline ::proto::Message_InteractiveMessage_Body* Message_InteractiveMessage::mutable_body() { - ::proto::Message_InteractiveMessage_Body* _msg = _internal_mutable_body(); - // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.body) - return _msg; -} -inline void Message_InteractiveMessage::set_allocated_body(::proto::Message_InteractiveMessage_Body* body) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.body_; - } - if (body) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(body); - if (message_arena != submessage_arena) { - body = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, body, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.body_ = body; - // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.body) -} - -// optional .proto.Message.InteractiveMessage.Footer footer = 3; -inline bool Message_InteractiveMessage::_internal_has_footer() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - PROTOBUF_ASSUME(!value || _impl_.footer_ != nullptr); - return value; -} -inline bool Message_InteractiveMessage::has_footer() const { - return _internal_has_footer(); -} -inline void Message_InteractiveMessage::clear_footer() { - if (_impl_.footer_ != nullptr) _impl_.footer_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const ::proto::Message_InteractiveMessage_Footer& Message_InteractiveMessage::_internal_footer() const { - const ::proto::Message_InteractiveMessage_Footer* p = _impl_.footer_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_InteractiveMessage_Footer_default_instance_); -} -inline const ::proto::Message_InteractiveMessage_Footer& Message_InteractiveMessage::footer() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.footer) - return _internal_footer(); -} -inline void Message_InteractiveMessage::unsafe_arena_set_allocated_footer( - ::proto::Message_InteractiveMessage_Footer* footer) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.footer_); - } - _impl_.footer_ = footer; - if (footer) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.footer) -} -inline ::proto::Message_InteractiveMessage_Footer* Message_InteractiveMessage::release_footer() { - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::Message_InteractiveMessage_Footer* temp = _impl_.footer_; - _impl_.footer_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_InteractiveMessage_Footer* Message_InteractiveMessage::unsafe_arena_release_footer() { - // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.footer) - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::Message_InteractiveMessage_Footer* temp = _impl_.footer_; - _impl_.footer_ = nullptr; - return temp; -} -inline ::proto::Message_InteractiveMessage_Footer* Message_InteractiveMessage::_internal_mutable_footer() { - _impl_._has_bits_[0] |= 0x00000004u; - if (_impl_.footer_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_InteractiveMessage_Footer>(GetArenaForAllocation()); - _impl_.footer_ = p; - } - return _impl_.footer_; -} -inline ::proto::Message_InteractiveMessage_Footer* Message_InteractiveMessage::mutable_footer() { - ::proto::Message_InteractiveMessage_Footer* _msg = _internal_mutable_footer(); - // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.footer) - return _msg; -} -inline void Message_InteractiveMessage::set_allocated_footer(::proto::Message_InteractiveMessage_Footer* footer) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.footer_; - } - if (footer) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(footer); - if (message_arena != submessage_arena) { - footer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, footer, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.footer_ = footer; - // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.footer) -} - -// optional .proto.ContextInfo contextInfo = 15; -inline bool Message_InteractiveMessage::_internal_has_contextinfo() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); - return value; -} -inline bool Message_InteractiveMessage::has_contextinfo() const { - return _internal_has_contextinfo(); -} -inline void Message_InteractiveMessage::clear_contextinfo() { - if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const ::proto::ContextInfo& Message_InteractiveMessage::_internal_contextinfo() const { - const ::proto::ContextInfo* p = _impl_.contextinfo_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ContextInfo_default_instance_); -} -inline const ::proto::ContextInfo& Message_InteractiveMessage::contextinfo() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.contextInfo) - return _internal_contextinfo(); -} -inline void Message_InteractiveMessage::unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); - } - _impl_.contextinfo_ = contextinfo; - if (contextinfo) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.contextInfo) -} -inline ::proto::ContextInfo* Message_InteractiveMessage::release_contextinfo() { - _impl_._has_bits_[0] &= ~0x00000008u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ContextInfo* Message_InteractiveMessage::unsafe_arena_release_contextinfo() { - // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.contextInfo) - _impl_._has_bits_[0] &= ~0x00000008u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; - return temp; -} -inline ::proto::ContextInfo* Message_InteractiveMessage::_internal_mutable_contextinfo() { - _impl_._has_bits_[0] |= 0x00000008u; - if (_impl_.contextinfo_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); - _impl_.contextinfo_ = p; - } - return _impl_.contextinfo_; -} -inline ::proto::ContextInfo* Message_InteractiveMessage::mutable_contextinfo() { - ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); - // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.contextInfo) - return _msg; -} -inline void Message_InteractiveMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.contextinfo_; - } - if (contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); - if (message_arena != submessage_arena) { - contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, contextinfo, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.contextinfo_ = contextinfo; - // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.contextInfo) -} - -// .proto.Message.InteractiveMessage.ShopMessage shopStorefrontMessage = 4; -inline bool Message_InteractiveMessage::_internal_has_shopstorefrontmessage() const { - return interactiveMessage_case() == kShopStorefrontMessage; -} -inline bool Message_InteractiveMessage::has_shopstorefrontmessage() const { - return _internal_has_shopstorefrontmessage(); -} -inline void Message_InteractiveMessage::set_has_shopstorefrontmessage() { - _impl_._oneof_case_[0] = kShopStorefrontMessage; -} -inline void Message_InteractiveMessage::clear_shopstorefrontmessage() { - if (_internal_has_shopstorefrontmessage()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.interactiveMessage_.shopstorefrontmessage_; - } - clear_has_interactiveMessage(); - } -} -inline ::proto::Message_InteractiveMessage_ShopMessage* Message_InteractiveMessage::release_shopstorefrontmessage() { - // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.shopStorefrontMessage) - if (_internal_has_shopstorefrontmessage()) { - clear_has_interactiveMessage(); - ::proto::Message_InteractiveMessage_ShopMessage* temp = _impl_.interactiveMessage_.shopstorefrontmessage_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.interactiveMessage_.shopstorefrontmessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::Message_InteractiveMessage_ShopMessage& Message_InteractiveMessage::_internal_shopstorefrontmessage() const { - return _internal_has_shopstorefrontmessage() - ? *_impl_.interactiveMessage_.shopstorefrontmessage_ - : reinterpret_cast< ::proto::Message_InteractiveMessage_ShopMessage&>(::proto::_Message_InteractiveMessage_ShopMessage_default_instance_); -} -inline const ::proto::Message_InteractiveMessage_ShopMessage& Message_InteractiveMessage::shopstorefrontmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.shopStorefrontMessage) - return _internal_shopstorefrontmessage(); -} -inline ::proto::Message_InteractiveMessage_ShopMessage* Message_InteractiveMessage::unsafe_arena_release_shopstorefrontmessage() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.InteractiveMessage.shopStorefrontMessage) - if (_internal_has_shopstorefrontmessage()) { - clear_has_interactiveMessage(); - ::proto::Message_InteractiveMessage_ShopMessage* temp = _impl_.interactiveMessage_.shopstorefrontmessage_; - _impl_.interactiveMessage_.shopstorefrontmessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Message_InteractiveMessage::unsafe_arena_set_allocated_shopstorefrontmessage(::proto::Message_InteractiveMessage_ShopMessage* shopstorefrontmessage) { - clear_interactiveMessage(); - if (shopstorefrontmessage) { - set_has_shopstorefrontmessage(); - _impl_.interactiveMessage_.shopstorefrontmessage_ = shopstorefrontmessage; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.shopStorefrontMessage) -} -inline ::proto::Message_InteractiveMessage_ShopMessage* Message_InteractiveMessage::_internal_mutable_shopstorefrontmessage() { - if (!_internal_has_shopstorefrontmessage()) { - clear_interactiveMessage(); - set_has_shopstorefrontmessage(); - _impl_.interactiveMessage_.shopstorefrontmessage_ = CreateMaybeMessage< ::proto::Message_InteractiveMessage_ShopMessage >(GetArenaForAllocation()); - } - return _impl_.interactiveMessage_.shopstorefrontmessage_; -} -inline ::proto::Message_InteractiveMessage_ShopMessage* Message_InteractiveMessage::mutable_shopstorefrontmessage() { - ::proto::Message_InteractiveMessage_ShopMessage* _msg = _internal_mutable_shopstorefrontmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.shopStorefrontMessage) - return _msg; -} - -// .proto.Message.InteractiveMessage.CollectionMessage collectionMessage = 5; -inline bool Message_InteractiveMessage::_internal_has_collectionmessage() const { - return interactiveMessage_case() == kCollectionMessage; -} -inline bool Message_InteractiveMessage::has_collectionmessage() const { - return _internal_has_collectionmessage(); -} -inline void Message_InteractiveMessage::set_has_collectionmessage() { - _impl_._oneof_case_[0] = kCollectionMessage; -} -inline void Message_InteractiveMessage::clear_collectionmessage() { - if (_internal_has_collectionmessage()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.interactiveMessage_.collectionmessage_; - } - clear_has_interactiveMessage(); - } -} -inline ::proto::Message_InteractiveMessage_CollectionMessage* Message_InteractiveMessage::release_collectionmessage() { - // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.collectionMessage) - if (_internal_has_collectionmessage()) { - clear_has_interactiveMessage(); - ::proto::Message_InteractiveMessage_CollectionMessage* temp = _impl_.interactiveMessage_.collectionmessage_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.interactiveMessage_.collectionmessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::Message_InteractiveMessage_CollectionMessage& Message_InteractiveMessage::_internal_collectionmessage() const { - return _internal_has_collectionmessage() - ? *_impl_.interactiveMessage_.collectionmessage_ - : reinterpret_cast< ::proto::Message_InteractiveMessage_CollectionMessage&>(::proto::_Message_InteractiveMessage_CollectionMessage_default_instance_); -} -inline const ::proto::Message_InteractiveMessage_CollectionMessage& Message_InteractiveMessage::collectionmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.collectionMessage) - return _internal_collectionmessage(); -} -inline ::proto::Message_InteractiveMessage_CollectionMessage* Message_InteractiveMessage::unsafe_arena_release_collectionmessage() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.InteractiveMessage.collectionMessage) - if (_internal_has_collectionmessage()) { - clear_has_interactiveMessage(); - ::proto::Message_InteractiveMessage_CollectionMessage* temp = _impl_.interactiveMessage_.collectionmessage_; - _impl_.interactiveMessage_.collectionmessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Message_InteractiveMessage::unsafe_arena_set_allocated_collectionmessage(::proto::Message_InteractiveMessage_CollectionMessage* collectionmessage) { - clear_interactiveMessage(); - if (collectionmessage) { - set_has_collectionmessage(); - _impl_.interactiveMessage_.collectionmessage_ = collectionmessage; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.collectionMessage) -} -inline ::proto::Message_InteractiveMessage_CollectionMessage* Message_InteractiveMessage::_internal_mutable_collectionmessage() { - if (!_internal_has_collectionmessage()) { - clear_interactiveMessage(); - set_has_collectionmessage(); - _impl_.interactiveMessage_.collectionmessage_ = CreateMaybeMessage< ::proto::Message_InteractiveMessage_CollectionMessage >(GetArenaForAllocation()); - } - return _impl_.interactiveMessage_.collectionmessage_; -} -inline ::proto::Message_InteractiveMessage_CollectionMessage* Message_InteractiveMessage::mutable_collectionmessage() { - ::proto::Message_InteractiveMessage_CollectionMessage* _msg = _internal_mutable_collectionmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.collectionMessage) - return _msg; -} - -// .proto.Message.InteractiveMessage.NativeFlowMessage nativeFlowMessage = 6; -inline bool Message_InteractiveMessage::_internal_has_nativeflowmessage() const { - return interactiveMessage_case() == kNativeFlowMessage; -} -inline bool Message_InteractiveMessage::has_nativeflowmessage() const { - return _internal_has_nativeflowmessage(); -} -inline void Message_InteractiveMessage::set_has_nativeflowmessage() { - _impl_._oneof_case_[0] = kNativeFlowMessage; -} -inline void Message_InteractiveMessage::clear_nativeflowmessage() { - if (_internal_has_nativeflowmessage()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.interactiveMessage_.nativeflowmessage_; - } - clear_has_interactiveMessage(); - } -} -inline ::proto::Message_InteractiveMessage_NativeFlowMessage* Message_InteractiveMessage::release_nativeflowmessage() { - // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.nativeFlowMessage) - if (_internal_has_nativeflowmessage()) { - clear_has_interactiveMessage(); - ::proto::Message_InteractiveMessage_NativeFlowMessage* temp = _impl_.interactiveMessage_.nativeflowmessage_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.interactiveMessage_.nativeflowmessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::Message_InteractiveMessage_NativeFlowMessage& Message_InteractiveMessage::_internal_nativeflowmessage() const { - return _internal_has_nativeflowmessage() - ? *_impl_.interactiveMessage_.nativeflowmessage_ - : reinterpret_cast< ::proto::Message_InteractiveMessage_NativeFlowMessage&>(::proto::_Message_InteractiveMessage_NativeFlowMessage_default_instance_); -} -inline const ::proto::Message_InteractiveMessage_NativeFlowMessage& Message_InteractiveMessage::nativeflowmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.nativeFlowMessage) - return _internal_nativeflowmessage(); -} -inline ::proto::Message_InteractiveMessage_NativeFlowMessage* Message_InteractiveMessage::unsafe_arena_release_nativeflowmessage() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.InteractiveMessage.nativeFlowMessage) - if (_internal_has_nativeflowmessage()) { - clear_has_interactiveMessage(); - ::proto::Message_InteractiveMessage_NativeFlowMessage* temp = _impl_.interactiveMessage_.nativeflowmessage_; - _impl_.interactiveMessage_.nativeflowmessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Message_InteractiveMessage::unsafe_arena_set_allocated_nativeflowmessage(::proto::Message_InteractiveMessage_NativeFlowMessage* nativeflowmessage) { - clear_interactiveMessage(); - if (nativeflowmessage) { - set_has_nativeflowmessage(); - _impl_.interactiveMessage_.nativeflowmessage_ = nativeflowmessage; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.nativeFlowMessage) -} -inline ::proto::Message_InteractiveMessage_NativeFlowMessage* Message_InteractiveMessage::_internal_mutable_nativeflowmessage() { - if (!_internal_has_nativeflowmessage()) { - clear_interactiveMessage(); - set_has_nativeflowmessage(); - _impl_.interactiveMessage_.nativeflowmessage_ = CreateMaybeMessage< ::proto::Message_InteractiveMessage_NativeFlowMessage >(GetArenaForAllocation()); - } - return _impl_.interactiveMessage_.nativeflowmessage_; -} -inline ::proto::Message_InteractiveMessage_NativeFlowMessage* Message_InteractiveMessage::mutable_nativeflowmessage() { - ::proto::Message_InteractiveMessage_NativeFlowMessage* _msg = _internal_mutable_nativeflowmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.nativeFlowMessage) - return _msg; -} - -inline bool Message_InteractiveMessage::has_interactiveMessage() const { - return interactiveMessage_case() != INTERACTIVEMESSAGE_NOT_SET; -} -inline void Message_InteractiveMessage::clear_has_interactiveMessage() { - _impl_._oneof_case_[0] = INTERACTIVEMESSAGE_NOT_SET; -} -inline Message_InteractiveMessage::InteractiveMessageCase Message_InteractiveMessage::interactiveMessage_case() const { - return Message_InteractiveMessage::InteractiveMessageCase(_impl_._oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// Message_InteractiveResponseMessage_Body - -// optional string text = 1; -inline bool Message_InteractiveResponseMessage_Body::_internal_has_text() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_InteractiveResponseMessage_Body::has_text() const { - return _internal_has_text(); -} -inline void Message_InteractiveResponseMessage_Body::clear_text() { - _impl_.text_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_InteractiveResponseMessage_Body::text() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveResponseMessage.Body.text) - return _internal_text(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_InteractiveResponseMessage_Body::set_text(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.text_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.InteractiveResponseMessage.Body.text) -} -inline std::string* Message_InteractiveResponseMessage_Body::mutable_text() { - std::string* _s = _internal_mutable_text(); - // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveResponseMessage.Body.text) - return _s; -} -inline const std::string& Message_InteractiveResponseMessage_Body::_internal_text() const { - return _impl_.text_.Get(); -} -inline void Message_InteractiveResponseMessage_Body::_internal_set_text(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.text_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_InteractiveResponseMessage_Body::_internal_mutable_text() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.text_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_InteractiveResponseMessage_Body::release_text() { - // @@protoc_insertion_point(field_release:proto.Message.InteractiveResponseMessage.Body.text) - if (!_internal_has_text()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.text_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.text_.IsDefault()) { - _impl_.text_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_InteractiveResponseMessage_Body::set_allocated_text(std::string* text) { - if (text != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.text_.SetAllocated(text, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.text_.IsDefault()) { - _impl_.text_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveResponseMessage.Body.text) -} - -// ------------------------------------------------------------------- - -// Message_InteractiveResponseMessage_NativeFlowResponseMessage - -// optional string name = 1; -inline bool Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_has_name() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_InteractiveResponseMessage_NativeFlowResponseMessage::has_name() const { - return _internal_has_name(); -} -inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::clear_name() { - _impl_.name_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_InteractiveResponseMessage_NativeFlowResponseMessage::name() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.name) - return _internal_name(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_InteractiveResponseMessage_NativeFlowResponseMessage::set_name(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.name) -} -inline std::string* Message_InteractiveResponseMessage_NativeFlowResponseMessage::mutable_name() { - std::string* _s = _internal_mutable_name(); - // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.name) - return _s; -} -inline const std::string& Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_name() const { - return _impl_.name_.Get(); -} -inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_set_name(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.name_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_mutable_name() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.name_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_InteractiveResponseMessage_NativeFlowResponseMessage::release_name() { - // @@protoc_insertion_point(field_release:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.name) - if (!_internal_has_name()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.name_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.name_.IsDefault()) { - _impl_.name_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::set_allocated_name(std::string* name) { - if (name != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.name_.SetAllocated(name, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.name_.IsDefault()) { - _impl_.name_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.name) -} - -// optional string paramsJson = 2; -inline bool Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_has_paramsjson() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_InteractiveResponseMessage_NativeFlowResponseMessage::has_paramsjson() const { - return _internal_has_paramsjson(); -} -inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::clear_paramsjson() { - _impl_.paramsjson_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_InteractiveResponseMessage_NativeFlowResponseMessage::paramsjson() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.paramsJson) - return _internal_paramsjson(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_InteractiveResponseMessage_NativeFlowResponseMessage::set_paramsjson(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.paramsjson_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.paramsJson) -} -inline std::string* Message_InteractiveResponseMessage_NativeFlowResponseMessage::mutable_paramsjson() { - std::string* _s = _internal_mutable_paramsjson(); - // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.paramsJson) - return _s; -} -inline const std::string& Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_paramsjson() const { - return _impl_.paramsjson_.Get(); -} -inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_set_paramsjson(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.paramsjson_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_mutable_paramsjson() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.paramsjson_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_InteractiveResponseMessage_NativeFlowResponseMessage::release_paramsjson() { - // @@protoc_insertion_point(field_release:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.paramsJson) - if (!_internal_has_paramsjson()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.paramsjson_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.paramsjson_.IsDefault()) { - _impl_.paramsjson_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::set_allocated_paramsjson(std::string* paramsjson) { - if (paramsjson != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.paramsjson_.SetAllocated(paramsjson, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.paramsjson_.IsDefault()) { - _impl_.paramsjson_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.paramsJson) -} - -// optional int32 version = 3; -inline bool Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_has_version() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool Message_InteractiveResponseMessage_NativeFlowResponseMessage::has_version() const { - return _internal_has_version(); -} -inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::clear_version() { - _impl_.version_ = 0; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline int32_t Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_version() const { - return _impl_.version_; -} -inline int32_t Message_InteractiveResponseMessage_NativeFlowResponseMessage::version() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.version) - return _internal_version(); -} -inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_set_version(int32_t value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.version_ = value; -} -inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::set_version(int32_t value) { - _internal_set_version(value); - // @@protoc_insertion_point(field_set:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.version) -} - -// ------------------------------------------------------------------- - -// Message_InteractiveResponseMessage - -// optional .proto.Message.InteractiveResponseMessage.Body body = 1; -inline bool Message_InteractiveResponseMessage::_internal_has_body() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.body_ != nullptr); - return value; -} -inline bool Message_InteractiveResponseMessage::has_body() const { - return _internal_has_body(); -} -inline void Message_InteractiveResponseMessage::clear_body() { - if (_impl_.body_ != nullptr) _impl_.body_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::Message_InteractiveResponseMessage_Body& Message_InteractiveResponseMessage::_internal_body() const { - const ::proto::Message_InteractiveResponseMessage_Body* p = _impl_.body_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_InteractiveResponseMessage_Body_default_instance_); -} -inline const ::proto::Message_InteractiveResponseMessage_Body& Message_InteractiveResponseMessage::body() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveResponseMessage.body) - return _internal_body(); -} -inline void Message_InteractiveResponseMessage::unsafe_arena_set_allocated_body( - ::proto::Message_InteractiveResponseMessage_Body* body) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.body_); - } - _impl_.body_ = body; - if (body) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveResponseMessage.body) -} -inline ::proto::Message_InteractiveResponseMessage_Body* Message_InteractiveResponseMessage::release_body() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::Message_InteractiveResponseMessage_Body* temp = _impl_.body_; - _impl_.body_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_InteractiveResponseMessage_Body* Message_InteractiveResponseMessage::unsafe_arena_release_body() { - // @@protoc_insertion_point(field_release:proto.Message.InteractiveResponseMessage.body) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::Message_InteractiveResponseMessage_Body* temp = _impl_.body_; - _impl_.body_ = nullptr; - return temp; -} -inline ::proto::Message_InteractiveResponseMessage_Body* Message_InteractiveResponseMessage::_internal_mutable_body() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.body_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_InteractiveResponseMessage_Body>(GetArenaForAllocation()); - _impl_.body_ = p; - } - return _impl_.body_; -} -inline ::proto::Message_InteractiveResponseMessage_Body* Message_InteractiveResponseMessage::mutable_body() { - ::proto::Message_InteractiveResponseMessage_Body* _msg = _internal_mutable_body(); - // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveResponseMessage.body) - return _msg; -} -inline void Message_InteractiveResponseMessage::set_allocated_body(::proto::Message_InteractiveResponseMessage_Body* body) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.body_; - } - if (body) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(body); - if (message_arena != submessage_arena) { - body = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, body, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.body_ = body; - // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveResponseMessage.body) -} - -// optional .proto.ContextInfo contextInfo = 15; -inline bool Message_InteractiveResponseMessage::_internal_has_contextinfo() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); - return value; -} -inline bool Message_InteractiveResponseMessage::has_contextinfo() const { - return _internal_has_contextinfo(); -} -inline void Message_InteractiveResponseMessage::clear_contextinfo() { - if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::ContextInfo& Message_InteractiveResponseMessage::_internal_contextinfo() const { - const ::proto::ContextInfo* p = _impl_.contextinfo_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ContextInfo_default_instance_); -} -inline const ::proto::ContextInfo& Message_InteractiveResponseMessage::contextinfo() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveResponseMessage.contextInfo) - return _internal_contextinfo(); -} -inline void Message_InteractiveResponseMessage::unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); - } - _impl_.contextinfo_ = contextinfo; - if (contextinfo) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveResponseMessage.contextInfo) -} -inline ::proto::ContextInfo* Message_InteractiveResponseMessage::release_contextinfo() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ContextInfo* Message_InteractiveResponseMessage::unsafe_arena_release_contextinfo() { - // @@protoc_insertion_point(field_release:proto.Message.InteractiveResponseMessage.contextInfo) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; - return temp; -} -inline ::proto::ContextInfo* Message_InteractiveResponseMessage::_internal_mutable_contextinfo() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.contextinfo_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); - _impl_.contextinfo_ = p; - } - return _impl_.contextinfo_; -} -inline ::proto::ContextInfo* Message_InteractiveResponseMessage::mutable_contextinfo() { - ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); - // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveResponseMessage.contextInfo) - return _msg; -} -inline void Message_InteractiveResponseMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.contextinfo_; - } - if (contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); - if (message_arena != submessage_arena) { - contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, contextinfo, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.contextinfo_ = contextinfo; - // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveResponseMessage.contextInfo) -} - -// .proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage nativeFlowResponseMessage = 2; -inline bool Message_InteractiveResponseMessage::_internal_has_nativeflowresponsemessage() const { - return interactiveResponseMessage_case() == kNativeFlowResponseMessage; -} -inline bool Message_InteractiveResponseMessage::has_nativeflowresponsemessage() const { - return _internal_has_nativeflowresponsemessage(); -} -inline void Message_InteractiveResponseMessage::set_has_nativeflowresponsemessage() { - _impl_._oneof_case_[0] = kNativeFlowResponseMessage; -} -inline void Message_InteractiveResponseMessage::clear_nativeflowresponsemessage() { - if (_internal_has_nativeflowresponsemessage()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.interactiveResponseMessage_.nativeflowresponsemessage_; - } - clear_has_interactiveResponseMessage(); - } -} -inline ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* Message_InteractiveResponseMessage::release_nativeflowresponsemessage() { - // @@protoc_insertion_point(field_release:proto.Message.InteractiveResponseMessage.nativeFlowResponseMessage) - if (_internal_has_nativeflowresponsemessage()) { - clear_has_interactiveResponseMessage(); - ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* temp = _impl_.interactiveResponseMessage_.nativeflowresponsemessage_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.interactiveResponseMessage_.nativeflowresponsemessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage& Message_InteractiveResponseMessage::_internal_nativeflowresponsemessage() const { - return _internal_has_nativeflowresponsemessage() - ? *_impl_.interactiveResponseMessage_.nativeflowresponsemessage_ - : reinterpret_cast< ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage&>(::proto::_Message_InteractiveResponseMessage_NativeFlowResponseMessage_default_instance_); -} -inline const ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage& Message_InteractiveResponseMessage::nativeflowresponsemessage() const { - // @@protoc_insertion_point(field_get:proto.Message.InteractiveResponseMessage.nativeFlowResponseMessage) - return _internal_nativeflowresponsemessage(); -} -inline ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* Message_InteractiveResponseMessage::unsafe_arena_release_nativeflowresponsemessage() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.InteractiveResponseMessage.nativeFlowResponseMessage) - if (_internal_has_nativeflowresponsemessage()) { - clear_has_interactiveResponseMessage(); - ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* temp = _impl_.interactiveResponseMessage_.nativeflowresponsemessage_; - _impl_.interactiveResponseMessage_.nativeflowresponsemessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Message_InteractiveResponseMessage::unsafe_arena_set_allocated_nativeflowresponsemessage(::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* nativeflowresponsemessage) { - clear_interactiveResponseMessage(); - if (nativeflowresponsemessage) { - set_has_nativeflowresponsemessage(); - _impl_.interactiveResponseMessage_.nativeflowresponsemessage_ = nativeflowresponsemessage; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveResponseMessage.nativeFlowResponseMessage) -} -inline ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* Message_InteractiveResponseMessage::_internal_mutable_nativeflowresponsemessage() { - if (!_internal_has_nativeflowresponsemessage()) { - clear_interactiveResponseMessage(); - set_has_nativeflowresponsemessage(); - _impl_.interactiveResponseMessage_.nativeflowresponsemessage_ = CreateMaybeMessage< ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage >(GetArenaForAllocation()); - } - return _impl_.interactiveResponseMessage_.nativeflowresponsemessage_; -} -inline ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* Message_InteractiveResponseMessage::mutable_nativeflowresponsemessage() { - ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* _msg = _internal_mutable_nativeflowresponsemessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveResponseMessage.nativeFlowResponseMessage) - return _msg; -} - -inline bool Message_InteractiveResponseMessage::has_interactiveResponseMessage() const { - return interactiveResponseMessage_case() != INTERACTIVERESPONSEMESSAGE_NOT_SET; -} -inline void Message_InteractiveResponseMessage::clear_has_interactiveResponseMessage() { - _impl_._oneof_case_[0] = INTERACTIVERESPONSEMESSAGE_NOT_SET; -} -inline Message_InteractiveResponseMessage::InteractiveResponseMessageCase Message_InteractiveResponseMessage::interactiveResponseMessage_case() const { - return Message_InteractiveResponseMessage::InteractiveResponseMessageCase(_impl_._oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// Message_InvoiceMessage - -// optional string note = 1; -inline bool Message_InvoiceMessage::_internal_has_note() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_InvoiceMessage::has_note() const { - return _internal_has_note(); -} -inline void Message_InvoiceMessage::clear_note() { - _impl_.note_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_InvoiceMessage::note() const { - // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.note) - return _internal_note(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_InvoiceMessage::set_note(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.note_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.note) -} -inline std::string* Message_InvoiceMessage::mutable_note() { - std::string* _s = _internal_mutable_note(); - // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.note) - return _s; -} -inline const std::string& Message_InvoiceMessage::_internal_note() const { - return _impl_.note_.Get(); -} -inline void Message_InvoiceMessage::_internal_set_note(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.note_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_InvoiceMessage::_internal_mutable_note() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.note_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_InvoiceMessage::release_note() { - // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.note) - if (!_internal_has_note()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.note_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.note_.IsDefault()) { - _impl_.note_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_InvoiceMessage::set_allocated_note(std::string* note) { - if (note != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.note_.SetAllocated(note, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.note_.IsDefault()) { - _impl_.note_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.note) -} - -// optional string token = 2; -inline bool Message_InvoiceMessage::_internal_has_token() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_InvoiceMessage::has_token() const { - return _internal_has_token(); -} -inline void Message_InvoiceMessage::clear_token() { - _impl_.token_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_InvoiceMessage::token() const { - // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.token) - return _internal_token(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_InvoiceMessage::set_token(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.token_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.token) -} -inline std::string* Message_InvoiceMessage::mutable_token() { - std::string* _s = _internal_mutable_token(); - // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.token) - return _s; -} -inline const std::string& Message_InvoiceMessage::_internal_token() const { - return _impl_.token_.Get(); -} -inline void Message_InvoiceMessage::_internal_set_token(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.token_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_InvoiceMessage::_internal_mutable_token() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.token_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_InvoiceMessage::release_token() { - // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.token) - if (!_internal_has_token()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.token_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.token_.IsDefault()) { - _impl_.token_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_InvoiceMessage::set_allocated_token(std::string* token) { - if (token != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.token_.SetAllocated(token, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.token_.IsDefault()) { - _impl_.token_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.token) -} - -// optional .proto.Message.InvoiceMessage.AttachmentType attachmentType = 3; -inline bool Message_InvoiceMessage::_internal_has_attachmenttype() const { - bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; - return value; -} -inline bool Message_InvoiceMessage::has_attachmenttype() const { - return _internal_has_attachmenttype(); -} -inline void Message_InvoiceMessage::clear_attachmenttype() { - _impl_.attachmenttype_ = 0; - _impl_._has_bits_[0] &= ~0x00000200u; -} -inline ::proto::Message_InvoiceMessage_AttachmentType Message_InvoiceMessage::_internal_attachmenttype() const { - return static_cast< ::proto::Message_InvoiceMessage_AttachmentType >(_impl_.attachmenttype_); -} -inline ::proto::Message_InvoiceMessage_AttachmentType Message_InvoiceMessage::attachmenttype() const { - // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentType) - return _internal_attachmenttype(); -} -inline void Message_InvoiceMessage::_internal_set_attachmenttype(::proto::Message_InvoiceMessage_AttachmentType value) { - assert(::proto::Message_InvoiceMessage_AttachmentType_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.attachmenttype_ = value; -} -inline void Message_InvoiceMessage::set_attachmenttype(::proto::Message_InvoiceMessage_AttachmentType value) { - _internal_set_attachmenttype(value); - // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentType) -} - -// optional string attachmentMimetype = 4; -inline bool Message_InvoiceMessage::_internal_has_attachmentmimetype() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool Message_InvoiceMessage::has_attachmentmimetype() const { - return _internal_has_attachmentmimetype(); -} -inline void Message_InvoiceMessage::clear_attachmentmimetype() { - _impl_.attachmentmimetype_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& Message_InvoiceMessage::attachmentmimetype() const { - // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentMimetype) - return _internal_attachmentmimetype(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_InvoiceMessage::set_attachmentmimetype(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.attachmentmimetype_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentMimetype) -} -inline std::string* Message_InvoiceMessage::mutable_attachmentmimetype() { - std::string* _s = _internal_mutable_attachmentmimetype(); - // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.attachmentMimetype) - return _s; -} -inline const std::string& Message_InvoiceMessage::_internal_attachmentmimetype() const { - return _impl_.attachmentmimetype_.Get(); -} -inline void Message_InvoiceMessage::_internal_set_attachmentmimetype(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.attachmentmimetype_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_InvoiceMessage::_internal_mutable_attachmentmimetype() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.attachmentmimetype_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_InvoiceMessage::release_attachmentmimetype() { - // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.attachmentMimetype) - if (!_internal_has_attachmentmimetype()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.attachmentmimetype_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.attachmentmimetype_.IsDefault()) { - _impl_.attachmentmimetype_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_InvoiceMessage::set_allocated_attachmentmimetype(std::string* attachmentmimetype) { - if (attachmentmimetype != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.attachmentmimetype_.SetAllocated(attachmentmimetype, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.attachmentmimetype_.IsDefault()) { - _impl_.attachmentmimetype_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.attachmentMimetype) -} - -// optional bytes attachmentMediaKey = 5; -inline bool Message_InvoiceMessage::_internal_has_attachmentmediakey() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool Message_InvoiceMessage::has_attachmentmediakey() const { - return _internal_has_attachmentmediakey(); -} -inline void Message_InvoiceMessage::clear_attachmentmediakey() { - _impl_.attachmentmediakey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const std::string& Message_InvoiceMessage::attachmentmediakey() const { - // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentMediaKey) - return _internal_attachmentmediakey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_InvoiceMessage::set_attachmentmediakey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.attachmentmediakey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentMediaKey) -} -inline std::string* Message_InvoiceMessage::mutable_attachmentmediakey() { - std::string* _s = _internal_mutable_attachmentmediakey(); - // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.attachmentMediaKey) - return _s; -} -inline const std::string& Message_InvoiceMessage::_internal_attachmentmediakey() const { - return _impl_.attachmentmediakey_.Get(); -} -inline void Message_InvoiceMessage::_internal_set_attachmentmediakey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.attachmentmediakey_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_InvoiceMessage::_internal_mutable_attachmentmediakey() { - _impl_._has_bits_[0] |= 0x00000008u; - return _impl_.attachmentmediakey_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_InvoiceMessage::release_attachmentmediakey() { - // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.attachmentMediaKey) - if (!_internal_has_attachmentmediakey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000008u; - auto* p = _impl_.attachmentmediakey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.attachmentmediakey_.IsDefault()) { - _impl_.attachmentmediakey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_InvoiceMessage::set_allocated_attachmentmediakey(std::string* attachmentmediakey) { - if (attachmentmediakey != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.attachmentmediakey_.SetAllocated(attachmentmediakey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.attachmentmediakey_.IsDefault()) { - _impl_.attachmentmediakey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.attachmentMediaKey) -} - -// optional int64 attachmentMediaKeyTimestamp = 6; -inline bool Message_InvoiceMessage::_internal_has_attachmentmediakeytimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; - return value; -} -inline bool Message_InvoiceMessage::has_attachmentmediakeytimestamp() const { - return _internal_has_attachmentmediakeytimestamp(); -} -inline void Message_InvoiceMessage::clear_attachmentmediakeytimestamp() { - _impl_.attachmentmediakeytimestamp_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000100u; -} -inline int64_t Message_InvoiceMessage::_internal_attachmentmediakeytimestamp() const { - return _impl_.attachmentmediakeytimestamp_; -} -inline int64_t Message_InvoiceMessage::attachmentmediakeytimestamp() const { - // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentMediaKeyTimestamp) - return _internal_attachmentmediakeytimestamp(); -} -inline void Message_InvoiceMessage::_internal_set_attachmentmediakeytimestamp(int64_t value) { - _impl_._has_bits_[0] |= 0x00000100u; - _impl_.attachmentmediakeytimestamp_ = value; -} -inline void Message_InvoiceMessage::set_attachmentmediakeytimestamp(int64_t value) { - _internal_set_attachmentmediakeytimestamp(value); - // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentMediaKeyTimestamp) -} - -// optional bytes attachmentFileSha256 = 7; -inline bool Message_InvoiceMessage::_internal_has_attachmentfilesha256() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool Message_InvoiceMessage::has_attachmentfilesha256() const { - return _internal_has_attachmentfilesha256(); -} -inline void Message_InvoiceMessage::clear_attachmentfilesha256() { - _impl_.attachmentfilesha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const std::string& Message_InvoiceMessage::attachmentfilesha256() const { - // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentFileSha256) - return _internal_attachmentfilesha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_InvoiceMessage::set_attachmentfilesha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.attachmentfilesha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentFileSha256) -} -inline std::string* Message_InvoiceMessage::mutable_attachmentfilesha256() { - std::string* _s = _internal_mutable_attachmentfilesha256(); - // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.attachmentFileSha256) - return _s; -} -inline const std::string& Message_InvoiceMessage::_internal_attachmentfilesha256() const { - return _impl_.attachmentfilesha256_.Get(); -} -inline void Message_InvoiceMessage::_internal_set_attachmentfilesha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.attachmentfilesha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_InvoiceMessage::_internal_mutable_attachmentfilesha256() { - _impl_._has_bits_[0] |= 0x00000010u; - return _impl_.attachmentfilesha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_InvoiceMessage::release_attachmentfilesha256() { - // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.attachmentFileSha256) - if (!_internal_has_attachmentfilesha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000010u; - auto* p = _impl_.attachmentfilesha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.attachmentfilesha256_.IsDefault()) { - _impl_.attachmentfilesha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_InvoiceMessage::set_allocated_attachmentfilesha256(std::string* attachmentfilesha256) { - if (attachmentfilesha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.attachmentfilesha256_.SetAllocated(attachmentfilesha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.attachmentfilesha256_.IsDefault()) { - _impl_.attachmentfilesha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.attachmentFileSha256) -} - -// optional bytes attachmentFileEncSha256 = 8; -inline bool Message_InvoiceMessage::_internal_has_attachmentfileencsha256() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool Message_InvoiceMessage::has_attachmentfileencsha256() const { - return _internal_has_attachmentfileencsha256(); -} -inline void Message_InvoiceMessage::clear_attachmentfileencsha256() { - _impl_.attachmentfileencsha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline const std::string& Message_InvoiceMessage::attachmentfileencsha256() const { - // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentFileEncSha256) - return _internal_attachmentfileencsha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_InvoiceMessage::set_attachmentfileencsha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.attachmentfileencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentFileEncSha256) -} -inline std::string* Message_InvoiceMessage::mutable_attachmentfileencsha256() { - std::string* _s = _internal_mutable_attachmentfileencsha256(); - // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.attachmentFileEncSha256) - return _s; -} -inline const std::string& Message_InvoiceMessage::_internal_attachmentfileencsha256() const { - return _impl_.attachmentfileencsha256_.Get(); -} -inline void Message_InvoiceMessage::_internal_set_attachmentfileencsha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.attachmentfileencsha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_InvoiceMessage::_internal_mutable_attachmentfileencsha256() { - _impl_._has_bits_[0] |= 0x00000020u; - return _impl_.attachmentfileencsha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_InvoiceMessage::release_attachmentfileencsha256() { - // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.attachmentFileEncSha256) - if (!_internal_has_attachmentfileencsha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000020u; - auto* p = _impl_.attachmentfileencsha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.attachmentfileencsha256_.IsDefault()) { - _impl_.attachmentfileencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_InvoiceMessage::set_allocated_attachmentfileencsha256(std::string* attachmentfileencsha256) { - if (attachmentfileencsha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - _impl_.attachmentfileencsha256_.SetAllocated(attachmentfileencsha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.attachmentfileencsha256_.IsDefault()) { - _impl_.attachmentfileencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.attachmentFileEncSha256) -} - -// optional string attachmentDirectPath = 9; -inline bool Message_InvoiceMessage::_internal_has_attachmentdirectpath() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool Message_InvoiceMessage::has_attachmentdirectpath() const { - return _internal_has_attachmentdirectpath(); -} -inline void Message_InvoiceMessage::clear_attachmentdirectpath() { - _impl_.attachmentdirectpath_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline const std::string& Message_InvoiceMessage::attachmentdirectpath() const { - // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentDirectPath) - return _internal_attachmentdirectpath(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_InvoiceMessage::set_attachmentdirectpath(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.attachmentdirectpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentDirectPath) -} -inline std::string* Message_InvoiceMessage::mutable_attachmentdirectpath() { - std::string* _s = _internal_mutable_attachmentdirectpath(); - // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.attachmentDirectPath) - return _s; -} -inline const std::string& Message_InvoiceMessage::_internal_attachmentdirectpath() const { - return _impl_.attachmentdirectpath_.Get(); -} -inline void Message_InvoiceMessage::_internal_set_attachmentdirectpath(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.attachmentdirectpath_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_InvoiceMessage::_internal_mutable_attachmentdirectpath() { - _impl_._has_bits_[0] |= 0x00000040u; - return _impl_.attachmentdirectpath_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_InvoiceMessage::release_attachmentdirectpath() { - // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.attachmentDirectPath) - if (!_internal_has_attachmentdirectpath()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000040u; - auto* p = _impl_.attachmentdirectpath_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.attachmentdirectpath_.IsDefault()) { - _impl_.attachmentdirectpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_InvoiceMessage::set_allocated_attachmentdirectpath(std::string* attachmentdirectpath) { - if (attachmentdirectpath != nullptr) { - _impl_._has_bits_[0] |= 0x00000040u; - } else { - _impl_._has_bits_[0] &= ~0x00000040u; - } - _impl_.attachmentdirectpath_.SetAllocated(attachmentdirectpath, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.attachmentdirectpath_.IsDefault()) { - _impl_.attachmentdirectpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.attachmentDirectPath) -} - -// optional bytes attachmentJpegThumbnail = 10; -inline bool Message_InvoiceMessage::_internal_has_attachmentjpegthumbnail() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - return value; -} -inline bool Message_InvoiceMessage::has_attachmentjpegthumbnail() const { - return _internal_has_attachmentjpegthumbnail(); -} -inline void Message_InvoiceMessage::clear_attachmentjpegthumbnail() { - _impl_.attachmentjpegthumbnail_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline const std::string& Message_InvoiceMessage::attachmentjpegthumbnail() const { - // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentJpegThumbnail) - return _internal_attachmentjpegthumbnail(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_InvoiceMessage::set_attachmentjpegthumbnail(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.attachmentjpegthumbnail_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentJpegThumbnail) -} -inline std::string* Message_InvoiceMessage::mutable_attachmentjpegthumbnail() { - std::string* _s = _internal_mutable_attachmentjpegthumbnail(); - // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.attachmentJpegThumbnail) - return _s; -} -inline const std::string& Message_InvoiceMessage::_internal_attachmentjpegthumbnail() const { - return _impl_.attachmentjpegthumbnail_.Get(); -} -inline void Message_InvoiceMessage::_internal_set_attachmentjpegthumbnail(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.attachmentjpegthumbnail_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_InvoiceMessage::_internal_mutable_attachmentjpegthumbnail() { - _impl_._has_bits_[0] |= 0x00000080u; - return _impl_.attachmentjpegthumbnail_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_InvoiceMessage::release_attachmentjpegthumbnail() { - // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.attachmentJpegThumbnail) - if (!_internal_has_attachmentjpegthumbnail()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000080u; - auto* p = _impl_.attachmentjpegthumbnail_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.attachmentjpegthumbnail_.IsDefault()) { - _impl_.attachmentjpegthumbnail_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_InvoiceMessage::set_allocated_attachmentjpegthumbnail(std::string* attachmentjpegthumbnail) { - if (attachmentjpegthumbnail != nullptr) { - _impl_._has_bits_[0] |= 0x00000080u; - } else { - _impl_._has_bits_[0] &= ~0x00000080u; - } - _impl_.attachmentjpegthumbnail_.SetAllocated(attachmentjpegthumbnail, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.attachmentjpegthumbnail_.IsDefault()) { - _impl_.attachmentjpegthumbnail_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.attachmentJpegThumbnail) -} - -// ------------------------------------------------------------------- - -// Message_KeepInChatMessage - -// optional .proto.MessageKey key = 1; -inline bool Message_KeepInChatMessage::_internal_has_key() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr); - return value; -} -inline bool Message_KeepInChatMessage::has_key() const { - return _internal_has_key(); -} -inline void Message_KeepInChatMessage::clear_key() { - if (_impl_.key_ != nullptr) _impl_.key_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::MessageKey& Message_KeepInChatMessage::_internal_key() const { - const ::proto::MessageKey* p = _impl_.key_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_MessageKey_default_instance_); -} -inline const ::proto::MessageKey& Message_KeepInChatMessage::key() const { - // @@protoc_insertion_point(field_get:proto.Message.KeepInChatMessage.key) - return _internal_key(); -} -inline void Message_KeepInChatMessage::unsafe_arena_set_allocated_key( - ::proto::MessageKey* key) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_); - } - _impl_.key_ = key; - if (key) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.KeepInChatMessage.key) -} -inline ::proto::MessageKey* Message_KeepInChatMessage::release_key() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::MessageKey* temp = _impl_.key_; - _impl_.key_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::MessageKey* Message_KeepInChatMessage::unsafe_arena_release_key() { - // @@protoc_insertion_point(field_release:proto.Message.KeepInChatMessage.key) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::MessageKey* temp = _impl_.key_; - _impl_.key_ = nullptr; - return temp; -} -inline ::proto::MessageKey* Message_KeepInChatMessage::_internal_mutable_key() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.key_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation()); - _impl_.key_ = p; - } - return _impl_.key_; -} -inline ::proto::MessageKey* Message_KeepInChatMessage::mutable_key() { - ::proto::MessageKey* _msg = _internal_mutable_key(); - // @@protoc_insertion_point(field_mutable:proto.Message.KeepInChatMessage.key) - return _msg; -} -inline void Message_KeepInChatMessage::set_allocated_key(::proto::MessageKey* key) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.key_; - } - if (key) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key); - if (message_arena != submessage_arena) { - key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, key, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.key_ = key; - // @@protoc_insertion_point(field_set_allocated:proto.Message.KeepInChatMessage.key) -} - -// optional .proto.KeepType keepType = 2; -inline bool Message_KeepInChatMessage::_internal_has_keeptype() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool Message_KeepInChatMessage::has_keeptype() const { - return _internal_has_keeptype(); -} -inline void Message_KeepInChatMessage::clear_keeptype() { - _impl_.keeptype_ = 0; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline ::proto::KeepType Message_KeepInChatMessage::_internal_keeptype() const { - return static_cast< ::proto::KeepType >(_impl_.keeptype_); -} -inline ::proto::KeepType Message_KeepInChatMessage::keeptype() const { - // @@protoc_insertion_point(field_get:proto.Message.KeepInChatMessage.keepType) - return _internal_keeptype(); -} -inline void Message_KeepInChatMessage::_internal_set_keeptype(::proto::KeepType value) { - assert(::proto::KeepType_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.keeptype_ = value; -} -inline void Message_KeepInChatMessage::set_keeptype(::proto::KeepType value) { - _internal_set_keeptype(value); - // @@protoc_insertion_point(field_set:proto.Message.KeepInChatMessage.keepType) -} - -// optional int64 timestampMs = 3; -inline bool Message_KeepInChatMessage::_internal_has_timestampms() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_KeepInChatMessage::has_timestampms() const { - return _internal_has_timestampms(); -} -inline void Message_KeepInChatMessage::clear_timestampms() { - _impl_.timestampms_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline int64_t Message_KeepInChatMessage::_internal_timestampms() const { - return _impl_.timestampms_; -} -inline int64_t Message_KeepInChatMessage::timestampms() const { - // @@protoc_insertion_point(field_get:proto.Message.KeepInChatMessage.timestampMs) - return _internal_timestampms(); -} -inline void Message_KeepInChatMessage::_internal_set_timestampms(int64_t value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.timestampms_ = value; -} -inline void Message_KeepInChatMessage::set_timestampms(int64_t value) { - _internal_set_timestampms(value); - // @@protoc_insertion_point(field_set:proto.Message.KeepInChatMessage.timestampMs) -} - -// ------------------------------------------------------------------- - -// Message_ListMessage_ProductListHeaderImage - -// optional string productId = 1; -inline bool Message_ListMessage_ProductListHeaderImage::_internal_has_productid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_ListMessage_ProductListHeaderImage::has_productid() const { - return _internal_has_productid(); -} -inline void Message_ListMessage_ProductListHeaderImage::clear_productid() { - _impl_.productid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_ListMessage_ProductListHeaderImage::productid() const { - // @@protoc_insertion_point(field_get:proto.Message.ListMessage.ProductListHeaderImage.productId) - return _internal_productid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ListMessage_ProductListHeaderImage::set_productid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.productid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ListMessage.ProductListHeaderImage.productId) -} -inline std::string* Message_ListMessage_ProductListHeaderImage::mutable_productid() { - std::string* _s = _internal_mutable_productid(); - // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.ProductListHeaderImage.productId) - return _s; -} -inline const std::string& Message_ListMessage_ProductListHeaderImage::_internal_productid() const { - return _impl_.productid_.Get(); -} -inline void Message_ListMessage_ProductListHeaderImage::_internal_set_productid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.productid_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ListMessage_ProductListHeaderImage::_internal_mutable_productid() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.productid_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ListMessage_ProductListHeaderImage::release_productid() { - // @@protoc_insertion_point(field_release:proto.Message.ListMessage.ProductListHeaderImage.productId) - if (!_internal_has_productid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.productid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.productid_.IsDefault()) { - _impl_.productid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ListMessage_ProductListHeaderImage::set_allocated_productid(std::string* productid) { - if (productid != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.productid_.SetAllocated(productid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.productid_.IsDefault()) { - _impl_.productid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.ProductListHeaderImage.productId) -} - -// optional bytes jpegThumbnail = 2; -inline bool Message_ListMessage_ProductListHeaderImage::_internal_has_jpegthumbnail() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_ListMessage_ProductListHeaderImage::has_jpegthumbnail() const { - return _internal_has_jpegthumbnail(); -} -inline void Message_ListMessage_ProductListHeaderImage::clear_jpegthumbnail() { - _impl_.jpegthumbnail_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_ListMessage_ProductListHeaderImage::jpegthumbnail() const { - // @@protoc_insertion_point(field_get:proto.Message.ListMessage.ProductListHeaderImage.jpegThumbnail) - return _internal_jpegthumbnail(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ListMessage_ProductListHeaderImage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.jpegthumbnail_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ListMessage.ProductListHeaderImage.jpegThumbnail) -} -inline std::string* Message_ListMessage_ProductListHeaderImage::mutable_jpegthumbnail() { - std::string* _s = _internal_mutable_jpegthumbnail(); - // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.ProductListHeaderImage.jpegThumbnail) - return _s; -} -inline const std::string& Message_ListMessage_ProductListHeaderImage::_internal_jpegthumbnail() const { - return _impl_.jpegthumbnail_.Get(); -} -inline void Message_ListMessage_ProductListHeaderImage::_internal_set_jpegthumbnail(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ListMessage_ProductListHeaderImage::_internal_mutable_jpegthumbnail() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ListMessage_ProductListHeaderImage::release_jpegthumbnail() { - // @@protoc_insertion_point(field_release:proto.Message.ListMessage.ProductListHeaderImage.jpegThumbnail) - if (!_internal_has_jpegthumbnail()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.jpegthumbnail_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.jpegthumbnail_.IsDefault()) { - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ListMessage_ProductListHeaderImage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) { - if (jpegthumbnail != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.jpegthumbnail_.IsDefault()) { - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.ProductListHeaderImage.jpegThumbnail) -} - -// ------------------------------------------------------------------- - -// Message_ListMessage_ProductListInfo - -// repeated .proto.Message.ListMessage.ProductSection productSections = 1; -inline int Message_ListMessage_ProductListInfo::_internal_productsections_size() const { - return _impl_.productsections_.size(); -} -inline int Message_ListMessage_ProductListInfo::productsections_size() const { - return _internal_productsections_size(); -} -inline void Message_ListMessage_ProductListInfo::clear_productsections() { - _impl_.productsections_.Clear(); -} -inline ::proto::Message_ListMessage_ProductSection* Message_ListMessage_ProductListInfo::mutable_productsections(int index) { - // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.ProductListInfo.productSections) - return _impl_.productsections_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_ProductSection >* -Message_ListMessage_ProductListInfo::mutable_productsections() { - // @@protoc_insertion_point(field_mutable_list:proto.Message.ListMessage.ProductListInfo.productSections) - return &_impl_.productsections_; -} -inline const ::proto::Message_ListMessage_ProductSection& Message_ListMessage_ProductListInfo::_internal_productsections(int index) const { - return _impl_.productsections_.Get(index); -} -inline const ::proto::Message_ListMessage_ProductSection& Message_ListMessage_ProductListInfo::productsections(int index) const { - // @@protoc_insertion_point(field_get:proto.Message.ListMessage.ProductListInfo.productSections) - return _internal_productsections(index); -} -inline ::proto::Message_ListMessage_ProductSection* Message_ListMessage_ProductListInfo::_internal_add_productsections() { - return _impl_.productsections_.Add(); -} -inline ::proto::Message_ListMessage_ProductSection* Message_ListMessage_ProductListInfo::add_productsections() { - ::proto::Message_ListMessage_ProductSection* _add = _internal_add_productsections(); - // @@protoc_insertion_point(field_add:proto.Message.ListMessage.ProductListInfo.productSections) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_ProductSection >& -Message_ListMessage_ProductListInfo::productsections() const { - // @@protoc_insertion_point(field_list:proto.Message.ListMessage.ProductListInfo.productSections) - return _impl_.productsections_; -} - -// optional .proto.Message.ListMessage.ProductListHeaderImage headerImage = 2; -inline bool Message_ListMessage_ProductListInfo::_internal_has_headerimage() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.headerimage_ != nullptr); - return value; -} -inline bool Message_ListMessage_ProductListInfo::has_headerimage() const { - return _internal_has_headerimage(); -} -inline void Message_ListMessage_ProductListInfo::clear_headerimage() { - if (_impl_.headerimage_ != nullptr) _impl_.headerimage_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::Message_ListMessage_ProductListHeaderImage& Message_ListMessage_ProductListInfo::_internal_headerimage() const { - const ::proto::Message_ListMessage_ProductListHeaderImage* p = _impl_.headerimage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_ListMessage_ProductListHeaderImage_default_instance_); -} -inline const ::proto::Message_ListMessage_ProductListHeaderImage& Message_ListMessage_ProductListInfo::headerimage() const { - // @@protoc_insertion_point(field_get:proto.Message.ListMessage.ProductListInfo.headerImage) - return _internal_headerimage(); -} -inline void Message_ListMessage_ProductListInfo::unsafe_arena_set_allocated_headerimage( - ::proto::Message_ListMessage_ProductListHeaderImage* headerimage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.headerimage_); - } - _impl_.headerimage_ = headerimage; - if (headerimage) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ListMessage.ProductListInfo.headerImage) -} -inline ::proto::Message_ListMessage_ProductListHeaderImage* Message_ListMessage_ProductListInfo::release_headerimage() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::Message_ListMessage_ProductListHeaderImage* temp = _impl_.headerimage_; - _impl_.headerimage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_ListMessage_ProductListHeaderImage* Message_ListMessage_ProductListInfo::unsafe_arena_release_headerimage() { - // @@protoc_insertion_point(field_release:proto.Message.ListMessage.ProductListInfo.headerImage) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::Message_ListMessage_ProductListHeaderImage* temp = _impl_.headerimage_; - _impl_.headerimage_ = nullptr; - return temp; -} -inline ::proto::Message_ListMessage_ProductListHeaderImage* Message_ListMessage_ProductListInfo::_internal_mutable_headerimage() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.headerimage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_ListMessage_ProductListHeaderImage>(GetArenaForAllocation()); - _impl_.headerimage_ = p; - } - return _impl_.headerimage_; -} -inline ::proto::Message_ListMessage_ProductListHeaderImage* Message_ListMessage_ProductListInfo::mutable_headerimage() { - ::proto::Message_ListMessage_ProductListHeaderImage* _msg = _internal_mutable_headerimage(); - // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.ProductListInfo.headerImage) - return _msg; -} -inline void Message_ListMessage_ProductListInfo::set_allocated_headerimage(::proto::Message_ListMessage_ProductListHeaderImage* headerimage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.headerimage_; - } - if (headerimage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(headerimage); - if (message_arena != submessage_arena) { - headerimage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, headerimage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.headerimage_ = headerimage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.ProductListInfo.headerImage) -} - -// optional string businessOwnerJid = 3; -inline bool Message_ListMessage_ProductListInfo::_internal_has_businessownerjid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_ListMessage_ProductListInfo::has_businessownerjid() const { - return _internal_has_businessownerjid(); -} -inline void Message_ListMessage_ProductListInfo::clear_businessownerjid() { - _impl_.businessownerjid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_ListMessage_ProductListInfo::businessownerjid() const { - // @@protoc_insertion_point(field_get:proto.Message.ListMessage.ProductListInfo.businessOwnerJid) - return _internal_businessownerjid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ListMessage_ProductListInfo::set_businessownerjid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.businessownerjid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ListMessage.ProductListInfo.businessOwnerJid) -} -inline std::string* Message_ListMessage_ProductListInfo::mutable_businessownerjid() { - std::string* _s = _internal_mutable_businessownerjid(); - // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.ProductListInfo.businessOwnerJid) - return _s; -} -inline const std::string& Message_ListMessage_ProductListInfo::_internal_businessownerjid() const { - return _impl_.businessownerjid_.Get(); -} -inline void Message_ListMessage_ProductListInfo::_internal_set_businessownerjid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.businessownerjid_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ListMessage_ProductListInfo::_internal_mutable_businessownerjid() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.businessownerjid_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ListMessage_ProductListInfo::release_businessownerjid() { - // @@protoc_insertion_point(field_release:proto.Message.ListMessage.ProductListInfo.businessOwnerJid) - if (!_internal_has_businessownerjid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.businessownerjid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.businessownerjid_.IsDefault()) { - _impl_.businessownerjid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ListMessage_ProductListInfo::set_allocated_businessownerjid(std::string* businessownerjid) { - if (businessownerjid != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.businessownerjid_.SetAllocated(businessownerjid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.businessownerjid_.IsDefault()) { - _impl_.businessownerjid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.ProductListInfo.businessOwnerJid) -} - -// ------------------------------------------------------------------- - -// Message_ListMessage_ProductSection - -// optional string title = 1; -inline bool Message_ListMessage_ProductSection::_internal_has_title() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_ListMessage_ProductSection::has_title() const { - return _internal_has_title(); -} -inline void Message_ListMessage_ProductSection::clear_title() { - _impl_.title_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_ListMessage_ProductSection::title() const { - // @@protoc_insertion_point(field_get:proto.Message.ListMessage.ProductSection.title) - return _internal_title(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ListMessage_ProductSection::set_title(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.title_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ListMessage.ProductSection.title) -} -inline std::string* Message_ListMessage_ProductSection::mutable_title() { - std::string* _s = _internal_mutable_title(); - // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.ProductSection.title) - return _s; -} -inline const std::string& Message_ListMessage_ProductSection::_internal_title() const { - return _impl_.title_.Get(); -} -inline void Message_ListMessage_ProductSection::_internal_set_title(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.title_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ListMessage_ProductSection::_internal_mutable_title() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.title_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ListMessage_ProductSection::release_title() { - // @@protoc_insertion_point(field_release:proto.Message.ListMessage.ProductSection.title) - if (!_internal_has_title()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.title_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.title_.IsDefault()) { - _impl_.title_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ListMessage_ProductSection::set_allocated_title(std::string* title) { - if (title != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.title_.SetAllocated(title, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.title_.IsDefault()) { - _impl_.title_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.ProductSection.title) -} - -// repeated .proto.Message.ListMessage.Product products = 2; -inline int Message_ListMessage_ProductSection::_internal_products_size() const { - return _impl_.products_.size(); -} -inline int Message_ListMessage_ProductSection::products_size() const { - return _internal_products_size(); -} -inline void Message_ListMessage_ProductSection::clear_products() { - _impl_.products_.Clear(); -} -inline ::proto::Message_ListMessage_Product* Message_ListMessage_ProductSection::mutable_products(int index) { - // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.ProductSection.products) - return _impl_.products_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Product >* -Message_ListMessage_ProductSection::mutable_products() { - // @@protoc_insertion_point(field_mutable_list:proto.Message.ListMessage.ProductSection.products) - return &_impl_.products_; -} -inline const ::proto::Message_ListMessage_Product& Message_ListMessage_ProductSection::_internal_products(int index) const { - return _impl_.products_.Get(index); -} -inline const ::proto::Message_ListMessage_Product& Message_ListMessage_ProductSection::products(int index) const { - // @@protoc_insertion_point(field_get:proto.Message.ListMessage.ProductSection.products) - return _internal_products(index); -} -inline ::proto::Message_ListMessage_Product* Message_ListMessage_ProductSection::_internal_add_products() { - return _impl_.products_.Add(); -} -inline ::proto::Message_ListMessage_Product* Message_ListMessage_ProductSection::add_products() { - ::proto::Message_ListMessage_Product* _add = _internal_add_products(); - // @@protoc_insertion_point(field_add:proto.Message.ListMessage.ProductSection.products) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Product >& -Message_ListMessage_ProductSection::products() const { - // @@protoc_insertion_point(field_list:proto.Message.ListMessage.ProductSection.products) - return _impl_.products_; -} - -// ------------------------------------------------------------------- - -// Message_ListMessage_Product - -// optional string productId = 1; -inline bool Message_ListMessage_Product::_internal_has_productid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_ListMessage_Product::has_productid() const { - return _internal_has_productid(); -} -inline void Message_ListMessage_Product::clear_productid() { - _impl_.productid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_ListMessage_Product::productid() const { - // @@protoc_insertion_point(field_get:proto.Message.ListMessage.Product.productId) - return _internal_productid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ListMessage_Product::set_productid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.productid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ListMessage.Product.productId) -} -inline std::string* Message_ListMessage_Product::mutable_productid() { - std::string* _s = _internal_mutable_productid(); - // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.Product.productId) - return _s; -} -inline const std::string& Message_ListMessage_Product::_internal_productid() const { - return _impl_.productid_.Get(); -} -inline void Message_ListMessage_Product::_internal_set_productid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.productid_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ListMessage_Product::_internal_mutable_productid() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.productid_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ListMessage_Product::release_productid() { - // @@protoc_insertion_point(field_release:proto.Message.ListMessage.Product.productId) - if (!_internal_has_productid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.productid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.productid_.IsDefault()) { - _impl_.productid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ListMessage_Product::set_allocated_productid(std::string* productid) { - if (productid != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.productid_.SetAllocated(productid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.productid_.IsDefault()) { - _impl_.productid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.Product.productId) -} - -// ------------------------------------------------------------------- - -// Message_ListMessage_Row - -// optional string title = 1; -inline bool Message_ListMessage_Row::_internal_has_title() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_ListMessage_Row::has_title() const { - return _internal_has_title(); -} -inline void Message_ListMessage_Row::clear_title() { - _impl_.title_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_ListMessage_Row::title() const { - // @@protoc_insertion_point(field_get:proto.Message.ListMessage.Row.title) - return _internal_title(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ListMessage_Row::set_title(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.title_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ListMessage.Row.title) -} -inline std::string* Message_ListMessage_Row::mutable_title() { - std::string* _s = _internal_mutable_title(); - // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.Row.title) - return _s; -} -inline const std::string& Message_ListMessage_Row::_internal_title() const { - return _impl_.title_.Get(); -} -inline void Message_ListMessage_Row::_internal_set_title(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.title_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ListMessage_Row::_internal_mutable_title() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.title_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ListMessage_Row::release_title() { - // @@protoc_insertion_point(field_release:proto.Message.ListMessage.Row.title) - if (!_internal_has_title()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.title_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.title_.IsDefault()) { - _impl_.title_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ListMessage_Row::set_allocated_title(std::string* title) { - if (title != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.title_.SetAllocated(title, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.title_.IsDefault()) { - _impl_.title_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.Row.title) -} - -// optional string description = 2; -inline bool Message_ListMessage_Row::_internal_has_description() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_ListMessage_Row::has_description() const { - return _internal_has_description(); -} -inline void Message_ListMessage_Row::clear_description() { - _impl_.description_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_ListMessage_Row::description() const { - // @@protoc_insertion_point(field_get:proto.Message.ListMessage.Row.description) - return _internal_description(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ListMessage_Row::set_description(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.description_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ListMessage.Row.description) -} -inline std::string* Message_ListMessage_Row::mutable_description() { - std::string* _s = _internal_mutable_description(); - // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.Row.description) - return _s; -} -inline const std::string& Message_ListMessage_Row::_internal_description() const { - return _impl_.description_.Get(); -} -inline void Message_ListMessage_Row::_internal_set_description(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.description_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ListMessage_Row::_internal_mutable_description() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.description_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ListMessage_Row::release_description() { - // @@protoc_insertion_point(field_release:proto.Message.ListMessage.Row.description) - if (!_internal_has_description()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.description_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.description_.IsDefault()) { - _impl_.description_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ListMessage_Row::set_allocated_description(std::string* description) { - if (description != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.description_.SetAllocated(description, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.description_.IsDefault()) { - _impl_.description_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.Row.description) -} - -// optional string rowId = 3; -inline bool Message_ListMessage_Row::_internal_has_rowid() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool Message_ListMessage_Row::has_rowid() const { - return _internal_has_rowid(); -} -inline void Message_ListMessage_Row::clear_rowid() { - _impl_.rowid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& Message_ListMessage_Row::rowid() const { - // @@protoc_insertion_point(field_get:proto.Message.ListMessage.Row.rowId) - return _internal_rowid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ListMessage_Row::set_rowid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.rowid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ListMessage.Row.rowId) -} -inline std::string* Message_ListMessage_Row::mutable_rowid() { - std::string* _s = _internal_mutable_rowid(); - // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.Row.rowId) - return _s; -} -inline const std::string& Message_ListMessage_Row::_internal_rowid() const { - return _impl_.rowid_.Get(); -} -inline void Message_ListMessage_Row::_internal_set_rowid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.rowid_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ListMessage_Row::_internal_mutable_rowid() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.rowid_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ListMessage_Row::release_rowid() { - // @@protoc_insertion_point(field_release:proto.Message.ListMessage.Row.rowId) - if (!_internal_has_rowid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.rowid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.rowid_.IsDefault()) { - _impl_.rowid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ListMessage_Row::set_allocated_rowid(std::string* rowid) { - if (rowid != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.rowid_.SetAllocated(rowid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.rowid_.IsDefault()) { - _impl_.rowid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.Row.rowId) -} - -// ------------------------------------------------------------------- - -// Message_ListMessage_Section - -// optional string title = 1; -inline bool Message_ListMessage_Section::_internal_has_title() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_ListMessage_Section::has_title() const { - return _internal_has_title(); -} -inline void Message_ListMessage_Section::clear_title() { - _impl_.title_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_ListMessage_Section::title() const { - // @@protoc_insertion_point(field_get:proto.Message.ListMessage.Section.title) - return _internal_title(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ListMessage_Section::set_title(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.title_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ListMessage.Section.title) -} -inline std::string* Message_ListMessage_Section::mutable_title() { - std::string* _s = _internal_mutable_title(); - // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.Section.title) - return _s; -} -inline const std::string& Message_ListMessage_Section::_internal_title() const { - return _impl_.title_.Get(); -} -inline void Message_ListMessage_Section::_internal_set_title(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.title_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ListMessage_Section::_internal_mutable_title() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.title_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ListMessage_Section::release_title() { - // @@protoc_insertion_point(field_release:proto.Message.ListMessage.Section.title) - if (!_internal_has_title()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.title_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.title_.IsDefault()) { - _impl_.title_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ListMessage_Section::set_allocated_title(std::string* title) { - if (title != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.title_.SetAllocated(title, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.title_.IsDefault()) { - _impl_.title_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.Section.title) -} - -// repeated .proto.Message.ListMessage.Row rows = 2; -inline int Message_ListMessage_Section::_internal_rows_size() const { - return _impl_.rows_.size(); -} -inline int Message_ListMessage_Section::rows_size() const { - return _internal_rows_size(); -} -inline void Message_ListMessage_Section::clear_rows() { - _impl_.rows_.Clear(); -} -inline ::proto::Message_ListMessage_Row* Message_ListMessage_Section::mutable_rows(int index) { - // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.Section.rows) - return _impl_.rows_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Row >* -Message_ListMessage_Section::mutable_rows() { - // @@protoc_insertion_point(field_mutable_list:proto.Message.ListMessage.Section.rows) - return &_impl_.rows_; -} -inline const ::proto::Message_ListMessage_Row& Message_ListMessage_Section::_internal_rows(int index) const { - return _impl_.rows_.Get(index); -} -inline const ::proto::Message_ListMessage_Row& Message_ListMessage_Section::rows(int index) const { - // @@protoc_insertion_point(field_get:proto.Message.ListMessage.Section.rows) - return _internal_rows(index); -} -inline ::proto::Message_ListMessage_Row* Message_ListMessage_Section::_internal_add_rows() { - return _impl_.rows_.Add(); -} -inline ::proto::Message_ListMessage_Row* Message_ListMessage_Section::add_rows() { - ::proto::Message_ListMessage_Row* _add = _internal_add_rows(); - // @@protoc_insertion_point(field_add:proto.Message.ListMessage.Section.rows) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Row >& -Message_ListMessage_Section::rows() const { - // @@protoc_insertion_point(field_list:proto.Message.ListMessage.Section.rows) - return _impl_.rows_; -} - -// ------------------------------------------------------------------- - -// Message_ListMessage - -// optional string title = 1; -inline bool Message_ListMessage::_internal_has_title() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_ListMessage::has_title() const { - return _internal_has_title(); -} -inline void Message_ListMessage::clear_title() { - _impl_.title_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_ListMessage::title() const { - // @@protoc_insertion_point(field_get:proto.Message.ListMessage.title) - return _internal_title(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ListMessage::set_title(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.title_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ListMessage.title) -} -inline std::string* Message_ListMessage::mutable_title() { - std::string* _s = _internal_mutable_title(); - // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.title) - return _s; -} -inline const std::string& Message_ListMessage::_internal_title() const { - return _impl_.title_.Get(); -} -inline void Message_ListMessage::_internal_set_title(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.title_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ListMessage::_internal_mutable_title() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.title_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ListMessage::release_title() { - // @@protoc_insertion_point(field_release:proto.Message.ListMessage.title) - if (!_internal_has_title()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.title_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.title_.IsDefault()) { - _impl_.title_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ListMessage::set_allocated_title(std::string* title) { - if (title != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.title_.SetAllocated(title, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.title_.IsDefault()) { - _impl_.title_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.title) -} - -// optional string description = 2; -inline bool Message_ListMessage::_internal_has_description() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_ListMessage::has_description() const { - return _internal_has_description(); -} -inline void Message_ListMessage::clear_description() { - _impl_.description_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_ListMessage::description() const { - // @@protoc_insertion_point(field_get:proto.Message.ListMessage.description) - return _internal_description(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ListMessage::set_description(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.description_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ListMessage.description) -} -inline std::string* Message_ListMessage::mutable_description() { - std::string* _s = _internal_mutable_description(); - // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.description) - return _s; -} -inline const std::string& Message_ListMessage::_internal_description() const { - return _impl_.description_.Get(); -} -inline void Message_ListMessage::_internal_set_description(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.description_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ListMessage::_internal_mutable_description() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.description_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ListMessage::release_description() { - // @@protoc_insertion_point(field_release:proto.Message.ListMessage.description) - if (!_internal_has_description()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.description_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.description_.IsDefault()) { - _impl_.description_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ListMessage::set_allocated_description(std::string* description) { - if (description != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.description_.SetAllocated(description, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.description_.IsDefault()) { - _impl_.description_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.description) -} - -// optional string buttonText = 3; -inline bool Message_ListMessage::_internal_has_buttontext() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool Message_ListMessage::has_buttontext() const { - return _internal_has_buttontext(); -} -inline void Message_ListMessage::clear_buttontext() { - _impl_.buttontext_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& Message_ListMessage::buttontext() const { - // @@protoc_insertion_point(field_get:proto.Message.ListMessage.buttonText) - return _internal_buttontext(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ListMessage::set_buttontext(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.buttontext_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ListMessage.buttonText) -} -inline std::string* Message_ListMessage::mutable_buttontext() { - std::string* _s = _internal_mutable_buttontext(); - // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.buttonText) - return _s; -} -inline const std::string& Message_ListMessage::_internal_buttontext() const { - return _impl_.buttontext_.Get(); -} -inline void Message_ListMessage::_internal_set_buttontext(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.buttontext_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ListMessage::_internal_mutable_buttontext() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.buttontext_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ListMessage::release_buttontext() { - // @@protoc_insertion_point(field_release:proto.Message.ListMessage.buttonText) - if (!_internal_has_buttontext()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.buttontext_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.buttontext_.IsDefault()) { - _impl_.buttontext_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ListMessage::set_allocated_buttontext(std::string* buttontext) { - if (buttontext != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.buttontext_.SetAllocated(buttontext, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.buttontext_.IsDefault()) { - _impl_.buttontext_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.buttonText) -} - -// optional .proto.Message.ListMessage.ListType listType = 4; -inline bool Message_ListMessage::_internal_has_listtype() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool Message_ListMessage::has_listtype() const { - return _internal_has_listtype(); -} -inline void Message_ListMessage::clear_listtype() { - _impl_.listtype_ = 0; - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline ::proto::Message_ListMessage_ListType Message_ListMessage::_internal_listtype() const { - return static_cast< ::proto::Message_ListMessage_ListType >(_impl_.listtype_); -} -inline ::proto::Message_ListMessage_ListType Message_ListMessage::listtype() const { - // @@protoc_insertion_point(field_get:proto.Message.ListMessage.listType) - return _internal_listtype(); -} -inline void Message_ListMessage::_internal_set_listtype(::proto::Message_ListMessage_ListType value) { - assert(::proto::Message_ListMessage_ListType_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.listtype_ = value; -} -inline void Message_ListMessage::set_listtype(::proto::Message_ListMessage_ListType value) { - _internal_set_listtype(value); - // @@protoc_insertion_point(field_set:proto.Message.ListMessage.listType) -} - -// repeated .proto.Message.ListMessage.Section sections = 5; -inline int Message_ListMessage::_internal_sections_size() const { - return _impl_.sections_.size(); -} -inline int Message_ListMessage::sections_size() const { - return _internal_sections_size(); -} -inline void Message_ListMessage::clear_sections() { - _impl_.sections_.Clear(); -} -inline ::proto::Message_ListMessage_Section* Message_ListMessage::mutable_sections(int index) { - // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.sections) - return _impl_.sections_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Section >* -Message_ListMessage::mutable_sections() { - // @@protoc_insertion_point(field_mutable_list:proto.Message.ListMessage.sections) - return &_impl_.sections_; -} -inline const ::proto::Message_ListMessage_Section& Message_ListMessage::_internal_sections(int index) const { - return _impl_.sections_.Get(index); -} -inline const ::proto::Message_ListMessage_Section& Message_ListMessage::sections(int index) const { - // @@protoc_insertion_point(field_get:proto.Message.ListMessage.sections) - return _internal_sections(index); -} -inline ::proto::Message_ListMessage_Section* Message_ListMessage::_internal_add_sections() { - return _impl_.sections_.Add(); -} -inline ::proto::Message_ListMessage_Section* Message_ListMessage::add_sections() { - ::proto::Message_ListMessage_Section* _add = _internal_add_sections(); - // @@protoc_insertion_point(field_add:proto.Message.ListMessage.sections) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Section >& -Message_ListMessage::sections() const { - // @@protoc_insertion_point(field_list:proto.Message.ListMessage.sections) - return _impl_.sections_; -} - -// optional .proto.Message.ListMessage.ProductListInfo productListInfo = 6; -inline bool Message_ListMessage::_internal_has_productlistinfo() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - PROTOBUF_ASSUME(!value || _impl_.productlistinfo_ != nullptr); - return value; -} -inline bool Message_ListMessage::has_productlistinfo() const { - return _internal_has_productlistinfo(); -} -inline void Message_ListMessage::clear_productlistinfo() { - if (_impl_.productlistinfo_ != nullptr) _impl_.productlistinfo_->Clear(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const ::proto::Message_ListMessage_ProductListInfo& Message_ListMessage::_internal_productlistinfo() const { - const ::proto::Message_ListMessage_ProductListInfo* p = _impl_.productlistinfo_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_ListMessage_ProductListInfo_default_instance_); -} -inline const ::proto::Message_ListMessage_ProductListInfo& Message_ListMessage::productlistinfo() const { - // @@protoc_insertion_point(field_get:proto.Message.ListMessage.productListInfo) - return _internal_productlistinfo(); -} -inline void Message_ListMessage::unsafe_arena_set_allocated_productlistinfo( - ::proto::Message_ListMessage_ProductListInfo* productlistinfo) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.productlistinfo_); - } - _impl_.productlistinfo_ = productlistinfo; - if (productlistinfo) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ListMessage.productListInfo) -} -inline ::proto::Message_ListMessage_ProductListInfo* Message_ListMessage::release_productlistinfo() { - _impl_._has_bits_[0] &= ~0x00000010u; - ::proto::Message_ListMessage_ProductListInfo* temp = _impl_.productlistinfo_; - _impl_.productlistinfo_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_ListMessage_ProductListInfo* Message_ListMessage::unsafe_arena_release_productlistinfo() { - // @@protoc_insertion_point(field_release:proto.Message.ListMessage.productListInfo) - _impl_._has_bits_[0] &= ~0x00000010u; - ::proto::Message_ListMessage_ProductListInfo* temp = _impl_.productlistinfo_; - _impl_.productlistinfo_ = nullptr; - return temp; -} -inline ::proto::Message_ListMessage_ProductListInfo* Message_ListMessage::_internal_mutable_productlistinfo() { - _impl_._has_bits_[0] |= 0x00000010u; - if (_impl_.productlistinfo_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_ListMessage_ProductListInfo>(GetArenaForAllocation()); - _impl_.productlistinfo_ = p; - } - return _impl_.productlistinfo_; -} -inline ::proto::Message_ListMessage_ProductListInfo* Message_ListMessage::mutable_productlistinfo() { - ::proto::Message_ListMessage_ProductListInfo* _msg = _internal_mutable_productlistinfo(); - // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.productListInfo) - return _msg; -} -inline void Message_ListMessage::set_allocated_productlistinfo(::proto::Message_ListMessage_ProductListInfo* productlistinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.productlistinfo_; - } - if (productlistinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(productlistinfo); - if (message_arena != submessage_arena) { - productlistinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, productlistinfo, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.productlistinfo_ = productlistinfo; - // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.productListInfo) -} - -// optional string footerText = 7; -inline bool Message_ListMessage::_internal_has_footertext() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool Message_ListMessage::has_footertext() const { - return _internal_has_footertext(); -} -inline void Message_ListMessage::clear_footertext() { - _impl_.footertext_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const std::string& Message_ListMessage::footertext() const { - // @@protoc_insertion_point(field_get:proto.Message.ListMessage.footerText) - return _internal_footertext(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ListMessage::set_footertext(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.footertext_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ListMessage.footerText) -} -inline std::string* Message_ListMessage::mutable_footertext() { - std::string* _s = _internal_mutable_footertext(); - // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.footerText) - return _s; -} -inline const std::string& Message_ListMessage::_internal_footertext() const { - return _impl_.footertext_.Get(); -} -inline void Message_ListMessage::_internal_set_footertext(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.footertext_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ListMessage::_internal_mutable_footertext() { - _impl_._has_bits_[0] |= 0x00000008u; - return _impl_.footertext_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ListMessage::release_footertext() { - // @@protoc_insertion_point(field_release:proto.Message.ListMessage.footerText) - if (!_internal_has_footertext()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000008u; - auto* p = _impl_.footertext_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.footertext_.IsDefault()) { - _impl_.footertext_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ListMessage::set_allocated_footertext(std::string* footertext) { - if (footertext != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.footertext_.SetAllocated(footertext, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.footertext_.IsDefault()) { - _impl_.footertext_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.footerText) -} - -// optional .proto.ContextInfo contextInfo = 8; -inline bool Message_ListMessage::_internal_has_contextinfo() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); - return value; -} -inline bool Message_ListMessage::has_contextinfo() const { - return _internal_has_contextinfo(); -} -inline void Message_ListMessage::clear_contextinfo() { - if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline const ::proto::ContextInfo& Message_ListMessage::_internal_contextinfo() const { - const ::proto::ContextInfo* p = _impl_.contextinfo_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ContextInfo_default_instance_); -} -inline const ::proto::ContextInfo& Message_ListMessage::contextinfo() const { - // @@protoc_insertion_point(field_get:proto.Message.ListMessage.contextInfo) - return _internal_contextinfo(); -} -inline void Message_ListMessage::unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); - } - _impl_.contextinfo_ = contextinfo; - if (contextinfo) { - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ListMessage.contextInfo) -} -inline ::proto::ContextInfo* Message_ListMessage::release_contextinfo() { - _impl_._has_bits_[0] &= ~0x00000020u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ContextInfo* Message_ListMessage::unsafe_arena_release_contextinfo() { - // @@protoc_insertion_point(field_release:proto.Message.ListMessage.contextInfo) - _impl_._has_bits_[0] &= ~0x00000020u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; - return temp; -} -inline ::proto::ContextInfo* Message_ListMessage::_internal_mutable_contextinfo() { - _impl_._has_bits_[0] |= 0x00000020u; - if (_impl_.contextinfo_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); - _impl_.contextinfo_ = p; - } - return _impl_.contextinfo_; -} -inline ::proto::ContextInfo* Message_ListMessage::mutable_contextinfo() { - ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); - // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.contextInfo) - return _msg; -} -inline void Message_ListMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.contextinfo_; - } - if (contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); - if (message_arena != submessage_arena) { - contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, contextinfo, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - _impl_.contextinfo_ = contextinfo; - // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.contextInfo) -} - -// ------------------------------------------------------------------- - -// Message_ListResponseMessage_SingleSelectReply - -// optional string selectedRowId = 1; -inline bool Message_ListResponseMessage_SingleSelectReply::_internal_has_selectedrowid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_ListResponseMessage_SingleSelectReply::has_selectedrowid() const { - return _internal_has_selectedrowid(); -} -inline void Message_ListResponseMessage_SingleSelectReply::clear_selectedrowid() { - _impl_.selectedrowid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_ListResponseMessage_SingleSelectReply::selectedrowid() const { - // @@protoc_insertion_point(field_get:proto.Message.ListResponseMessage.SingleSelectReply.selectedRowId) - return _internal_selectedrowid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ListResponseMessage_SingleSelectReply::set_selectedrowid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.selectedrowid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ListResponseMessage.SingleSelectReply.selectedRowId) -} -inline std::string* Message_ListResponseMessage_SingleSelectReply::mutable_selectedrowid() { - std::string* _s = _internal_mutable_selectedrowid(); - // @@protoc_insertion_point(field_mutable:proto.Message.ListResponseMessage.SingleSelectReply.selectedRowId) - return _s; -} -inline const std::string& Message_ListResponseMessage_SingleSelectReply::_internal_selectedrowid() const { - return _impl_.selectedrowid_.Get(); -} -inline void Message_ListResponseMessage_SingleSelectReply::_internal_set_selectedrowid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.selectedrowid_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ListResponseMessage_SingleSelectReply::_internal_mutable_selectedrowid() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.selectedrowid_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ListResponseMessage_SingleSelectReply::release_selectedrowid() { - // @@protoc_insertion_point(field_release:proto.Message.ListResponseMessage.SingleSelectReply.selectedRowId) - if (!_internal_has_selectedrowid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.selectedrowid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.selectedrowid_.IsDefault()) { - _impl_.selectedrowid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ListResponseMessage_SingleSelectReply::set_allocated_selectedrowid(std::string* selectedrowid) { - if (selectedrowid != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.selectedrowid_.SetAllocated(selectedrowid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.selectedrowid_.IsDefault()) { - _impl_.selectedrowid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ListResponseMessage.SingleSelectReply.selectedRowId) -} - -// ------------------------------------------------------------------- - -// Message_ListResponseMessage - -// optional string title = 1; -inline bool Message_ListResponseMessage::_internal_has_title() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_ListResponseMessage::has_title() const { - return _internal_has_title(); -} -inline void Message_ListResponseMessage::clear_title() { - _impl_.title_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_ListResponseMessage::title() const { - // @@protoc_insertion_point(field_get:proto.Message.ListResponseMessage.title) - return _internal_title(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ListResponseMessage::set_title(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.title_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ListResponseMessage.title) -} -inline std::string* Message_ListResponseMessage::mutable_title() { - std::string* _s = _internal_mutable_title(); - // @@protoc_insertion_point(field_mutable:proto.Message.ListResponseMessage.title) - return _s; -} -inline const std::string& Message_ListResponseMessage::_internal_title() const { - return _impl_.title_.Get(); -} -inline void Message_ListResponseMessage::_internal_set_title(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.title_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ListResponseMessage::_internal_mutable_title() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.title_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ListResponseMessage::release_title() { - // @@protoc_insertion_point(field_release:proto.Message.ListResponseMessage.title) - if (!_internal_has_title()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.title_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.title_.IsDefault()) { - _impl_.title_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ListResponseMessage::set_allocated_title(std::string* title) { - if (title != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.title_.SetAllocated(title, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.title_.IsDefault()) { - _impl_.title_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ListResponseMessage.title) -} - -// optional .proto.Message.ListResponseMessage.ListType listType = 2; -inline bool Message_ListResponseMessage::_internal_has_listtype() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool Message_ListResponseMessage::has_listtype() const { - return _internal_has_listtype(); -} -inline void Message_ListResponseMessage::clear_listtype() { - _impl_.listtype_ = 0; - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline ::proto::Message_ListResponseMessage_ListType Message_ListResponseMessage::_internal_listtype() const { - return static_cast< ::proto::Message_ListResponseMessage_ListType >(_impl_.listtype_); -} -inline ::proto::Message_ListResponseMessage_ListType Message_ListResponseMessage::listtype() const { - // @@protoc_insertion_point(field_get:proto.Message.ListResponseMessage.listType) - return _internal_listtype(); -} -inline void Message_ListResponseMessage::_internal_set_listtype(::proto::Message_ListResponseMessage_ListType value) { - assert(::proto::Message_ListResponseMessage_ListType_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.listtype_ = value; -} -inline void Message_ListResponseMessage::set_listtype(::proto::Message_ListResponseMessage_ListType value) { - _internal_set_listtype(value); - // @@protoc_insertion_point(field_set:proto.Message.ListResponseMessage.listType) -} - -// optional .proto.Message.ListResponseMessage.SingleSelectReply singleSelectReply = 3; -inline bool Message_ListResponseMessage::_internal_has_singleselectreply() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - PROTOBUF_ASSUME(!value || _impl_.singleselectreply_ != nullptr); - return value; -} -inline bool Message_ListResponseMessage::has_singleselectreply() const { - return _internal_has_singleselectreply(); -} -inline void Message_ListResponseMessage::clear_singleselectreply() { - if (_impl_.singleselectreply_ != nullptr) _impl_.singleselectreply_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const ::proto::Message_ListResponseMessage_SingleSelectReply& Message_ListResponseMessage::_internal_singleselectreply() const { - const ::proto::Message_ListResponseMessage_SingleSelectReply* p = _impl_.singleselectreply_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_ListResponseMessage_SingleSelectReply_default_instance_); -} -inline const ::proto::Message_ListResponseMessage_SingleSelectReply& Message_ListResponseMessage::singleselectreply() const { - // @@protoc_insertion_point(field_get:proto.Message.ListResponseMessage.singleSelectReply) - return _internal_singleselectreply(); -} -inline void Message_ListResponseMessage::unsafe_arena_set_allocated_singleselectreply( - ::proto::Message_ListResponseMessage_SingleSelectReply* singleselectreply) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.singleselectreply_); - } - _impl_.singleselectreply_ = singleselectreply; - if (singleselectreply) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ListResponseMessage.singleSelectReply) -} -inline ::proto::Message_ListResponseMessage_SingleSelectReply* Message_ListResponseMessage::release_singleselectreply() { - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::Message_ListResponseMessage_SingleSelectReply* temp = _impl_.singleselectreply_; - _impl_.singleselectreply_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_ListResponseMessage_SingleSelectReply* Message_ListResponseMessage::unsafe_arena_release_singleselectreply() { - // @@protoc_insertion_point(field_release:proto.Message.ListResponseMessage.singleSelectReply) - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::Message_ListResponseMessage_SingleSelectReply* temp = _impl_.singleselectreply_; - _impl_.singleselectreply_ = nullptr; - return temp; -} -inline ::proto::Message_ListResponseMessage_SingleSelectReply* Message_ListResponseMessage::_internal_mutable_singleselectreply() { - _impl_._has_bits_[0] |= 0x00000004u; - if (_impl_.singleselectreply_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_ListResponseMessage_SingleSelectReply>(GetArenaForAllocation()); - _impl_.singleselectreply_ = p; - } - return _impl_.singleselectreply_; -} -inline ::proto::Message_ListResponseMessage_SingleSelectReply* Message_ListResponseMessage::mutable_singleselectreply() { - ::proto::Message_ListResponseMessage_SingleSelectReply* _msg = _internal_mutable_singleselectreply(); - // @@protoc_insertion_point(field_mutable:proto.Message.ListResponseMessage.singleSelectReply) - return _msg; -} -inline void Message_ListResponseMessage::set_allocated_singleselectreply(::proto::Message_ListResponseMessage_SingleSelectReply* singleselectreply) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.singleselectreply_; - } - if (singleselectreply) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(singleselectreply); - if (message_arena != submessage_arena) { - singleselectreply = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, singleselectreply, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.singleselectreply_ = singleselectreply; - // @@protoc_insertion_point(field_set_allocated:proto.Message.ListResponseMessage.singleSelectReply) -} - -// optional .proto.ContextInfo contextInfo = 4; -inline bool Message_ListResponseMessage::_internal_has_contextinfo() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); - return value; -} -inline bool Message_ListResponseMessage::has_contextinfo() const { - return _internal_has_contextinfo(); -} -inline void Message_ListResponseMessage::clear_contextinfo() { - if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const ::proto::ContextInfo& Message_ListResponseMessage::_internal_contextinfo() const { - const ::proto::ContextInfo* p = _impl_.contextinfo_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ContextInfo_default_instance_); -} -inline const ::proto::ContextInfo& Message_ListResponseMessage::contextinfo() const { - // @@protoc_insertion_point(field_get:proto.Message.ListResponseMessage.contextInfo) - return _internal_contextinfo(); -} -inline void Message_ListResponseMessage::unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); - } - _impl_.contextinfo_ = contextinfo; - if (contextinfo) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ListResponseMessage.contextInfo) -} -inline ::proto::ContextInfo* Message_ListResponseMessage::release_contextinfo() { - _impl_._has_bits_[0] &= ~0x00000008u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ContextInfo* Message_ListResponseMessage::unsafe_arena_release_contextinfo() { - // @@protoc_insertion_point(field_release:proto.Message.ListResponseMessage.contextInfo) - _impl_._has_bits_[0] &= ~0x00000008u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; - return temp; -} -inline ::proto::ContextInfo* Message_ListResponseMessage::_internal_mutable_contextinfo() { - _impl_._has_bits_[0] |= 0x00000008u; - if (_impl_.contextinfo_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); - _impl_.contextinfo_ = p; - } - return _impl_.contextinfo_; -} -inline ::proto::ContextInfo* Message_ListResponseMessage::mutable_contextinfo() { - ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); - // @@protoc_insertion_point(field_mutable:proto.Message.ListResponseMessage.contextInfo) - return _msg; -} -inline void Message_ListResponseMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.contextinfo_; - } - if (contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); - if (message_arena != submessage_arena) { - contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, contextinfo, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.contextinfo_ = contextinfo; - // @@protoc_insertion_point(field_set_allocated:proto.Message.ListResponseMessage.contextInfo) -} - -// optional string description = 5; -inline bool Message_ListResponseMessage::_internal_has_description() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_ListResponseMessage::has_description() const { - return _internal_has_description(); -} -inline void Message_ListResponseMessage::clear_description() { - _impl_.description_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_ListResponseMessage::description() const { - // @@protoc_insertion_point(field_get:proto.Message.ListResponseMessage.description) - return _internal_description(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ListResponseMessage::set_description(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.description_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ListResponseMessage.description) -} -inline std::string* Message_ListResponseMessage::mutable_description() { - std::string* _s = _internal_mutable_description(); - // @@protoc_insertion_point(field_mutable:proto.Message.ListResponseMessage.description) - return _s; -} -inline const std::string& Message_ListResponseMessage::_internal_description() const { - return _impl_.description_.Get(); -} -inline void Message_ListResponseMessage::_internal_set_description(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.description_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ListResponseMessage::_internal_mutable_description() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.description_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ListResponseMessage::release_description() { - // @@protoc_insertion_point(field_release:proto.Message.ListResponseMessage.description) - if (!_internal_has_description()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.description_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.description_.IsDefault()) { - _impl_.description_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ListResponseMessage::set_allocated_description(std::string* description) { - if (description != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.description_.SetAllocated(description, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.description_.IsDefault()) { - _impl_.description_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ListResponseMessage.description) -} - -// ------------------------------------------------------------------- - -// Message_LiveLocationMessage - -// optional double degreesLatitude = 1; -inline bool Message_LiveLocationMessage::_internal_has_degreeslatitude() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool Message_LiveLocationMessage::has_degreeslatitude() const { - return _internal_has_degreeslatitude(); -} -inline void Message_LiveLocationMessage::clear_degreeslatitude() { - _impl_.degreeslatitude_ = 0; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline double Message_LiveLocationMessage::_internal_degreeslatitude() const { - return _impl_.degreeslatitude_; -} -inline double Message_LiveLocationMessage::degreeslatitude() const { - // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.degreesLatitude) - return _internal_degreeslatitude(); -} -inline void Message_LiveLocationMessage::_internal_set_degreeslatitude(double value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.degreeslatitude_ = value; -} -inline void Message_LiveLocationMessage::set_degreeslatitude(double value) { - _internal_set_degreeslatitude(value); - // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.degreesLatitude) -} - -// optional double degreesLongitude = 2; -inline bool Message_LiveLocationMessage::_internal_has_degreeslongitude() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool Message_LiveLocationMessage::has_degreeslongitude() const { - return _internal_has_degreeslongitude(); -} -inline void Message_LiveLocationMessage::clear_degreeslongitude() { - _impl_.degreeslongitude_ = 0; - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline double Message_LiveLocationMessage::_internal_degreeslongitude() const { - return _impl_.degreeslongitude_; -} -inline double Message_LiveLocationMessage::degreeslongitude() const { - // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.degreesLongitude) - return _internal_degreeslongitude(); -} -inline void Message_LiveLocationMessage::_internal_set_degreeslongitude(double value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.degreeslongitude_ = value; -} -inline void Message_LiveLocationMessage::set_degreeslongitude(double value) { - _internal_set_degreeslongitude(value); - // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.degreesLongitude) -} - -// optional uint32 accuracyInMeters = 3; -inline bool Message_LiveLocationMessage::_internal_has_accuracyinmeters() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool Message_LiveLocationMessage::has_accuracyinmeters() const { - return _internal_has_accuracyinmeters(); -} -inline void Message_LiveLocationMessage::clear_accuracyinmeters() { - _impl_.accuracyinmeters_ = 0u; - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline uint32_t Message_LiveLocationMessage::_internal_accuracyinmeters() const { - return _impl_.accuracyinmeters_; -} -inline uint32_t Message_LiveLocationMessage::accuracyinmeters() const { - // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.accuracyInMeters) - return _internal_accuracyinmeters(); -} -inline void Message_LiveLocationMessage::_internal_set_accuracyinmeters(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.accuracyinmeters_ = value; -} -inline void Message_LiveLocationMessage::set_accuracyinmeters(uint32_t value) { - _internal_set_accuracyinmeters(value); - // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.accuracyInMeters) -} - -// optional float speedInMps = 4; -inline bool Message_LiveLocationMessage::_internal_has_speedinmps() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool Message_LiveLocationMessage::has_speedinmps() const { - return _internal_has_speedinmps(); -} -inline void Message_LiveLocationMessage::clear_speedinmps() { - _impl_.speedinmps_ = 0; - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline float Message_LiveLocationMessage::_internal_speedinmps() const { - return _impl_.speedinmps_; -} -inline float Message_LiveLocationMessage::speedinmps() const { - // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.speedInMps) - return _internal_speedinmps(); -} -inline void Message_LiveLocationMessage::_internal_set_speedinmps(float value) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.speedinmps_ = value; -} -inline void Message_LiveLocationMessage::set_speedinmps(float value) { - _internal_set_speedinmps(value); - // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.speedInMps) -} - -// optional uint32 degreesClockwiseFromMagneticNorth = 5; -inline bool Message_LiveLocationMessage::_internal_has_degreesclockwisefrommagneticnorth() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - return value; -} -inline bool Message_LiveLocationMessage::has_degreesclockwisefrommagneticnorth() const { - return _internal_has_degreesclockwisefrommagneticnorth(); -} -inline void Message_LiveLocationMessage::clear_degreesclockwisefrommagneticnorth() { - _impl_.degreesclockwisefrommagneticnorth_ = 0u; - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline uint32_t Message_LiveLocationMessage::_internal_degreesclockwisefrommagneticnorth() const { - return _impl_.degreesclockwisefrommagneticnorth_; -} -inline uint32_t Message_LiveLocationMessage::degreesclockwisefrommagneticnorth() const { - // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.degreesClockwiseFromMagneticNorth) - return _internal_degreesclockwisefrommagneticnorth(); -} -inline void Message_LiveLocationMessage::_internal_set_degreesclockwisefrommagneticnorth(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.degreesclockwisefrommagneticnorth_ = value; -} -inline void Message_LiveLocationMessage::set_degreesclockwisefrommagneticnorth(uint32_t value) { - _internal_set_degreesclockwisefrommagneticnorth(value); - // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.degreesClockwiseFromMagneticNorth) -} - -// optional string caption = 6; -inline bool Message_LiveLocationMessage::_internal_has_caption() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_LiveLocationMessage::has_caption() const { - return _internal_has_caption(); -} -inline void Message_LiveLocationMessage::clear_caption() { - _impl_.caption_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_LiveLocationMessage::caption() const { - // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.caption) - return _internal_caption(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_LiveLocationMessage::set_caption(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.caption_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.caption) -} -inline std::string* Message_LiveLocationMessage::mutable_caption() { - std::string* _s = _internal_mutable_caption(); - // @@protoc_insertion_point(field_mutable:proto.Message.LiveLocationMessage.caption) - return _s; -} -inline const std::string& Message_LiveLocationMessage::_internal_caption() const { - return _impl_.caption_.Get(); -} -inline void Message_LiveLocationMessage::_internal_set_caption(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.caption_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_LiveLocationMessage::_internal_mutable_caption() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.caption_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_LiveLocationMessage::release_caption() { - // @@protoc_insertion_point(field_release:proto.Message.LiveLocationMessage.caption) - if (!_internal_has_caption()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.caption_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.caption_.IsDefault()) { - _impl_.caption_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_LiveLocationMessage::set_allocated_caption(std::string* caption) { - if (caption != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.caption_.SetAllocated(caption, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.caption_.IsDefault()) { - _impl_.caption_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.LiveLocationMessage.caption) -} - -// optional int64 sequenceNumber = 7; -inline bool Message_LiveLocationMessage::_internal_has_sequencenumber() const { - bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; - return value; -} -inline bool Message_LiveLocationMessage::has_sequencenumber() const { - return _internal_has_sequencenumber(); -} -inline void Message_LiveLocationMessage::clear_sequencenumber() { - _impl_.sequencenumber_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000200u; -} -inline int64_t Message_LiveLocationMessage::_internal_sequencenumber() const { - return _impl_.sequencenumber_; -} -inline int64_t Message_LiveLocationMessage::sequencenumber() const { - // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.sequenceNumber) - return _internal_sequencenumber(); -} -inline void Message_LiveLocationMessage::_internal_set_sequencenumber(int64_t value) { - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.sequencenumber_ = value; -} -inline void Message_LiveLocationMessage::set_sequencenumber(int64_t value) { - _internal_set_sequencenumber(value); - // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.sequenceNumber) -} - -// optional uint32 timeOffset = 8; -inline bool Message_LiveLocationMessage::_internal_has_timeoffset() const { - bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; - return value; -} -inline bool Message_LiveLocationMessage::has_timeoffset() const { - return _internal_has_timeoffset(); -} -inline void Message_LiveLocationMessage::clear_timeoffset() { - _impl_.timeoffset_ = 0u; - _impl_._has_bits_[0] &= ~0x00000100u; -} -inline uint32_t Message_LiveLocationMessage::_internal_timeoffset() const { - return _impl_.timeoffset_; -} -inline uint32_t Message_LiveLocationMessage::timeoffset() const { - // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.timeOffset) - return _internal_timeoffset(); -} -inline void Message_LiveLocationMessage::_internal_set_timeoffset(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000100u; - _impl_.timeoffset_ = value; -} -inline void Message_LiveLocationMessage::set_timeoffset(uint32_t value) { - _internal_set_timeoffset(value); - // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.timeOffset) -} - -// optional bytes jpegThumbnail = 16; -inline bool Message_LiveLocationMessage::_internal_has_jpegthumbnail() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_LiveLocationMessage::has_jpegthumbnail() const { - return _internal_has_jpegthumbnail(); -} -inline void Message_LiveLocationMessage::clear_jpegthumbnail() { - _impl_.jpegthumbnail_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_LiveLocationMessage::jpegthumbnail() const { - // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.jpegThumbnail) - return _internal_jpegthumbnail(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_LiveLocationMessage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.jpegthumbnail_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.jpegThumbnail) -} -inline std::string* Message_LiveLocationMessage::mutable_jpegthumbnail() { - std::string* _s = _internal_mutable_jpegthumbnail(); - // @@protoc_insertion_point(field_mutable:proto.Message.LiveLocationMessage.jpegThumbnail) - return _s; -} -inline const std::string& Message_LiveLocationMessage::_internal_jpegthumbnail() const { - return _impl_.jpegthumbnail_.Get(); -} -inline void Message_LiveLocationMessage::_internal_set_jpegthumbnail(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_LiveLocationMessage::_internal_mutable_jpegthumbnail() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_LiveLocationMessage::release_jpegthumbnail() { - // @@protoc_insertion_point(field_release:proto.Message.LiveLocationMessage.jpegThumbnail) - if (!_internal_has_jpegthumbnail()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.jpegthumbnail_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.jpegthumbnail_.IsDefault()) { - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_LiveLocationMessage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) { - if (jpegthumbnail != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.jpegthumbnail_.IsDefault()) { - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.LiveLocationMessage.jpegThumbnail) -} - -// optional .proto.ContextInfo contextInfo = 17; -inline bool Message_LiveLocationMessage::_internal_has_contextinfo() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); - return value; -} -inline bool Message_LiveLocationMessage::has_contextinfo() const { - return _internal_has_contextinfo(); -} -inline void Message_LiveLocationMessage::clear_contextinfo() { - if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const ::proto::ContextInfo& Message_LiveLocationMessage::_internal_contextinfo() const { - const ::proto::ContextInfo* p = _impl_.contextinfo_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ContextInfo_default_instance_); -} -inline const ::proto::ContextInfo& Message_LiveLocationMessage::contextinfo() const { - // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.contextInfo) - return _internal_contextinfo(); -} -inline void Message_LiveLocationMessage::unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); - } - _impl_.contextinfo_ = contextinfo; - if (contextinfo) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.LiveLocationMessage.contextInfo) -} -inline ::proto::ContextInfo* Message_LiveLocationMessage::release_contextinfo() { - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ContextInfo* Message_LiveLocationMessage::unsafe_arena_release_contextinfo() { - // @@protoc_insertion_point(field_release:proto.Message.LiveLocationMessage.contextInfo) - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; - return temp; -} -inline ::proto::ContextInfo* Message_LiveLocationMessage::_internal_mutable_contextinfo() { - _impl_._has_bits_[0] |= 0x00000004u; - if (_impl_.contextinfo_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); - _impl_.contextinfo_ = p; - } - return _impl_.contextinfo_; -} -inline ::proto::ContextInfo* Message_LiveLocationMessage::mutable_contextinfo() { - ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); - // @@protoc_insertion_point(field_mutable:proto.Message.LiveLocationMessage.contextInfo) - return _msg; -} -inline void Message_LiveLocationMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.contextinfo_; - } - if (contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); - if (message_arena != submessage_arena) { - contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, contextinfo, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.contextinfo_ = contextinfo; - // @@protoc_insertion_point(field_set_allocated:proto.Message.LiveLocationMessage.contextInfo) -} - -// ------------------------------------------------------------------- - -// Message_LocationMessage - -// optional double degreesLatitude = 1; -inline bool Message_LocationMessage::_internal_has_degreeslatitude() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool Message_LocationMessage::has_degreeslatitude() const { - return _internal_has_degreeslatitude(); -} -inline void Message_LocationMessage::clear_degreeslatitude() { - _impl_.degreeslatitude_ = 0; - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline double Message_LocationMessage::_internal_degreeslatitude() const { - return _impl_.degreeslatitude_; -} -inline double Message_LocationMessage::degreeslatitude() const { - // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.degreesLatitude) - return _internal_degreeslatitude(); -} -inline void Message_LocationMessage::_internal_set_degreeslatitude(double value) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.degreeslatitude_ = value; -} -inline void Message_LocationMessage::set_degreeslatitude(double value) { - _internal_set_degreeslatitude(value); - // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.degreesLatitude) -} - -// optional double degreesLongitude = 2; -inline bool Message_LocationMessage::_internal_has_degreeslongitude() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - return value; -} -inline bool Message_LocationMessage::has_degreeslongitude() const { - return _internal_has_degreeslongitude(); -} -inline void Message_LocationMessage::clear_degreeslongitude() { - _impl_.degreeslongitude_ = 0; - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline double Message_LocationMessage::_internal_degreeslongitude() const { - return _impl_.degreeslongitude_; -} -inline double Message_LocationMessage::degreeslongitude() const { - // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.degreesLongitude) - return _internal_degreeslongitude(); -} -inline void Message_LocationMessage::_internal_set_degreeslongitude(double value) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.degreeslongitude_ = value; -} -inline void Message_LocationMessage::set_degreeslongitude(double value) { - _internal_set_degreeslongitude(value); - // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.degreesLongitude) -} - -// optional string name = 3; -inline bool Message_LocationMessage::_internal_has_name() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_LocationMessage::has_name() const { - return _internal_has_name(); -} -inline void Message_LocationMessage::clear_name() { - _impl_.name_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_LocationMessage::name() const { - // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.name) - return _internal_name(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_LocationMessage::set_name(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.name) -} -inline std::string* Message_LocationMessage::mutable_name() { - std::string* _s = _internal_mutable_name(); - // @@protoc_insertion_point(field_mutable:proto.Message.LocationMessage.name) - return _s; -} -inline const std::string& Message_LocationMessage::_internal_name() const { - return _impl_.name_.Get(); -} -inline void Message_LocationMessage::_internal_set_name(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.name_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_LocationMessage::_internal_mutable_name() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.name_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_LocationMessage::release_name() { - // @@protoc_insertion_point(field_release:proto.Message.LocationMessage.name) - if (!_internal_has_name()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.name_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.name_.IsDefault()) { - _impl_.name_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_LocationMessage::set_allocated_name(std::string* name) { - if (name != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.name_.SetAllocated(name, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.name_.IsDefault()) { - _impl_.name_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.LocationMessage.name) -} - -// optional string address = 4; -inline bool Message_LocationMessage::_internal_has_address() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_LocationMessage::has_address() const { - return _internal_has_address(); -} -inline void Message_LocationMessage::clear_address() { - _impl_.address_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_LocationMessage::address() const { - // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.address) - return _internal_address(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_LocationMessage::set_address(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.address_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.address) -} -inline std::string* Message_LocationMessage::mutable_address() { - std::string* _s = _internal_mutable_address(); - // @@protoc_insertion_point(field_mutable:proto.Message.LocationMessage.address) - return _s; -} -inline const std::string& Message_LocationMessage::_internal_address() const { - return _impl_.address_.Get(); -} -inline void Message_LocationMessage::_internal_set_address(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.address_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_LocationMessage::_internal_mutable_address() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.address_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_LocationMessage::release_address() { - // @@protoc_insertion_point(field_release:proto.Message.LocationMessage.address) - if (!_internal_has_address()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.address_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.address_.IsDefault()) { - _impl_.address_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_LocationMessage::set_allocated_address(std::string* address) { - if (address != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.address_.SetAllocated(address, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.address_.IsDefault()) { - _impl_.address_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.LocationMessage.address) -} - -// optional string url = 5; -inline bool Message_LocationMessage::_internal_has_url() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool Message_LocationMessage::has_url() const { - return _internal_has_url(); -} -inline void Message_LocationMessage::clear_url() { - _impl_.url_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& Message_LocationMessage::url() const { - // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.url) - return _internal_url(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_LocationMessage::set_url(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.url_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.url) -} -inline std::string* Message_LocationMessage::mutable_url() { - std::string* _s = _internal_mutable_url(); - // @@protoc_insertion_point(field_mutable:proto.Message.LocationMessage.url) - return _s; -} -inline const std::string& Message_LocationMessage::_internal_url() const { - return _impl_.url_.Get(); -} -inline void Message_LocationMessage::_internal_set_url(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.url_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_LocationMessage::_internal_mutable_url() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.url_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_LocationMessage::release_url() { - // @@protoc_insertion_point(field_release:proto.Message.LocationMessage.url) - if (!_internal_has_url()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.url_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.url_.IsDefault()) { - _impl_.url_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_LocationMessage::set_allocated_url(std::string* url) { - if (url != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.url_.SetAllocated(url, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.url_.IsDefault()) { - _impl_.url_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.LocationMessage.url) -} - -// optional bool isLive = 6; -inline bool Message_LocationMessage::_internal_has_islive() const { - bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; - return value; -} -inline bool Message_LocationMessage::has_islive() const { - return _internal_has_islive(); -} -inline void Message_LocationMessage::clear_islive() { - _impl_.islive_ = false; - _impl_._has_bits_[0] &= ~0x00000100u; -} -inline bool Message_LocationMessage::_internal_islive() const { - return _impl_.islive_; -} -inline bool Message_LocationMessage::islive() const { - // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.isLive) - return _internal_islive(); -} -inline void Message_LocationMessage::_internal_set_islive(bool value) { - _impl_._has_bits_[0] |= 0x00000100u; - _impl_.islive_ = value; -} -inline void Message_LocationMessage::set_islive(bool value) { - _internal_set_islive(value); - // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.isLive) -} - -// optional uint32 accuracyInMeters = 7; -inline bool Message_LocationMessage::_internal_has_accuracyinmeters() const { - bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; - return value; -} -inline bool Message_LocationMessage::has_accuracyinmeters() const { - return _internal_has_accuracyinmeters(); -} -inline void Message_LocationMessage::clear_accuracyinmeters() { - _impl_.accuracyinmeters_ = 0u; - _impl_._has_bits_[0] &= ~0x00000200u; -} -inline uint32_t Message_LocationMessage::_internal_accuracyinmeters() const { - return _impl_.accuracyinmeters_; -} -inline uint32_t Message_LocationMessage::accuracyinmeters() const { - // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.accuracyInMeters) - return _internal_accuracyinmeters(); -} -inline void Message_LocationMessage::_internal_set_accuracyinmeters(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.accuracyinmeters_ = value; -} -inline void Message_LocationMessage::set_accuracyinmeters(uint32_t value) { - _internal_set_accuracyinmeters(value); - // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.accuracyInMeters) -} - -// optional float speedInMps = 8; -inline bool Message_LocationMessage::_internal_has_speedinmps() const { - bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; - return value; -} -inline bool Message_LocationMessage::has_speedinmps() const { - return _internal_has_speedinmps(); -} -inline void Message_LocationMessage::clear_speedinmps() { - _impl_.speedinmps_ = 0; - _impl_._has_bits_[0] &= ~0x00000400u; -} -inline float Message_LocationMessage::_internal_speedinmps() const { - return _impl_.speedinmps_; -} -inline float Message_LocationMessage::speedinmps() const { - // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.speedInMps) - return _internal_speedinmps(); -} -inline void Message_LocationMessage::_internal_set_speedinmps(float value) { - _impl_._has_bits_[0] |= 0x00000400u; - _impl_.speedinmps_ = value; -} -inline void Message_LocationMessage::set_speedinmps(float value) { - _internal_set_speedinmps(value); - // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.speedInMps) -} - -// optional uint32 degreesClockwiseFromMagneticNorth = 9; -inline bool Message_LocationMessage::_internal_has_degreesclockwisefrommagneticnorth() const { - bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; - return value; -} -inline bool Message_LocationMessage::has_degreesclockwisefrommagneticnorth() const { - return _internal_has_degreesclockwisefrommagneticnorth(); -} -inline void Message_LocationMessage::clear_degreesclockwisefrommagneticnorth() { - _impl_.degreesclockwisefrommagneticnorth_ = 0u; - _impl_._has_bits_[0] &= ~0x00000800u; -} -inline uint32_t Message_LocationMessage::_internal_degreesclockwisefrommagneticnorth() const { - return _impl_.degreesclockwisefrommagneticnorth_; -} -inline uint32_t Message_LocationMessage::degreesclockwisefrommagneticnorth() const { - // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.degreesClockwiseFromMagneticNorth) - return _internal_degreesclockwisefrommagneticnorth(); -} -inline void Message_LocationMessage::_internal_set_degreesclockwisefrommagneticnorth(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000800u; - _impl_.degreesclockwisefrommagneticnorth_ = value; -} -inline void Message_LocationMessage::set_degreesclockwisefrommagneticnorth(uint32_t value) { - _internal_set_degreesclockwisefrommagneticnorth(value); - // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.degreesClockwiseFromMagneticNorth) -} - -// optional string comment = 11; -inline bool Message_LocationMessage::_internal_has_comment() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool Message_LocationMessage::has_comment() const { - return _internal_has_comment(); -} -inline void Message_LocationMessage::clear_comment() { - _impl_.comment_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const std::string& Message_LocationMessage::comment() const { - // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.comment) - return _internal_comment(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_LocationMessage::set_comment(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.comment_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.comment) -} -inline std::string* Message_LocationMessage::mutable_comment() { - std::string* _s = _internal_mutable_comment(); - // @@protoc_insertion_point(field_mutable:proto.Message.LocationMessage.comment) - return _s; -} -inline const std::string& Message_LocationMessage::_internal_comment() const { - return _impl_.comment_.Get(); -} -inline void Message_LocationMessage::_internal_set_comment(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.comment_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_LocationMessage::_internal_mutable_comment() { - _impl_._has_bits_[0] |= 0x00000008u; - return _impl_.comment_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_LocationMessage::release_comment() { - // @@protoc_insertion_point(field_release:proto.Message.LocationMessage.comment) - if (!_internal_has_comment()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000008u; - auto* p = _impl_.comment_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.comment_.IsDefault()) { - _impl_.comment_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_LocationMessage::set_allocated_comment(std::string* comment) { - if (comment != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.comment_.SetAllocated(comment, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.comment_.IsDefault()) { - _impl_.comment_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.LocationMessage.comment) -} - -// optional bytes jpegThumbnail = 16; -inline bool Message_LocationMessage::_internal_has_jpegthumbnail() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool Message_LocationMessage::has_jpegthumbnail() const { - return _internal_has_jpegthumbnail(); -} -inline void Message_LocationMessage::clear_jpegthumbnail() { - _impl_.jpegthumbnail_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const std::string& Message_LocationMessage::jpegthumbnail() const { - // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.jpegThumbnail) - return _internal_jpegthumbnail(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_LocationMessage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.jpegthumbnail_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.jpegThumbnail) -} -inline std::string* Message_LocationMessage::mutable_jpegthumbnail() { - std::string* _s = _internal_mutable_jpegthumbnail(); - // @@protoc_insertion_point(field_mutable:proto.Message.LocationMessage.jpegThumbnail) - return _s; -} -inline const std::string& Message_LocationMessage::_internal_jpegthumbnail() const { - return _impl_.jpegthumbnail_.Get(); -} -inline void Message_LocationMessage::_internal_set_jpegthumbnail(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_LocationMessage::_internal_mutable_jpegthumbnail() { - _impl_._has_bits_[0] |= 0x00000010u; - return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_LocationMessage::release_jpegthumbnail() { - // @@protoc_insertion_point(field_release:proto.Message.LocationMessage.jpegThumbnail) - if (!_internal_has_jpegthumbnail()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000010u; - auto* p = _impl_.jpegthumbnail_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.jpegthumbnail_.IsDefault()) { - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_LocationMessage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) { - if (jpegthumbnail != nullptr) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.jpegthumbnail_.IsDefault()) { - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.LocationMessage.jpegThumbnail) -} - -// optional .proto.ContextInfo contextInfo = 17; -inline bool Message_LocationMessage::_internal_has_contextinfo() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); - return value; -} -inline bool Message_LocationMessage::has_contextinfo() const { - return _internal_has_contextinfo(); -} -inline void Message_LocationMessage::clear_contextinfo() { - if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline const ::proto::ContextInfo& Message_LocationMessage::_internal_contextinfo() const { - const ::proto::ContextInfo* p = _impl_.contextinfo_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ContextInfo_default_instance_); -} -inline const ::proto::ContextInfo& Message_LocationMessage::contextinfo() const { - // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.contextInfo) - return _internal_contextinfo(); -} -inline void Message_LocationMessage::unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); - } - _impl_.contextinfo_ = contextinfo; - if (contextinfo) { - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.LocationMessage.contextInfo) -} -inline ::proto::ContextInfo* Message_LocationMessage::release_contextinfo() { - _impl_._has_bits_[0] &= ~0x00000020u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ContextInfo* Message_LocationMessage::unsafe_arena_release_contextinfo() { - // @@protoc_insertion_point(field_release:proto.Message.LocationMessage.contextInfo) - _impl_._has_bits_[0] &= ~0x00000020u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; - return temp; -} -inline ::proto::ContextInfo* Message_LocationMessage::_internal_mutable_contextinfo() { - _impl_._has_bits_[0] |= 0x00000020u; - if (_impl_.contextinfo_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); - _impl_.contextinfo_ = p; - } - return _impl_.contextinfo_; -} -inline ::proto::ContextInfo* Message_LocationMessage::mutable_contextinfo() { - ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); - // @@protoc_insertion_point(field_mutable:proto.Message.LocationMessage.contextInfo) - return _msg; -} -inline void Message_LocationMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.contextinfo_; - } - if (contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); - if (message_arena != submessage_arena) { - contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, contextinfo, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - _impl_.contextinfo_ = contextinfo; - // @@protoc_insertion_point(field_set_allocated:proto.Message.LocationMessage.contextInfo) -} - -// ------------------------------------------------------------------- - -// Message_OrderMessage - -// optional string orderId = 1; -inline bool Message_OrderMessage::_internal_has_orderid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_OrderMessage::has_orderid() const { - return _internal_has_orderid(); -} -inline void Message_OrderMessage::clear_orderid() { - _impl_.orderid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_OrderMessage::orderid() const { - // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.orderId) - return _internal_orderid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_OrderMessage::set_orderid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.orderid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.orderId) -} -inline std::string* Message_OrderMessage::mutable_orderid() { - std::string* _s = _internal_mutable_orderid(); - // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.orderId) - return _s; -} -inline const std::string& Message_OrderMessage::_internal_orderid() const { - return _impl_.orderid_.Get(); -} -inline void Message_OrderMessage::_internal_set_orderid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.orderid_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_OrderMessage::_internal_mutable_orderid() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.orderid_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_OrderMessage::release_orderid() { - // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.orderId) - if (!_internal_has_orderid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.orderid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.orderid_.IsDefault()) { - _impl_.orderid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_OrderMessage::set_allocated_orderid(std::string* orderid) { - if (orderid != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.orderid_.SetAllocated(orderid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.orderid_.IsDefault()) { - _impl_.orderid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.OrderMessage.orderId) -} - -// optional bytes thumbnail = 2; -inline bool Message_OrderMessage::_internal_has_thumbnail() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_OrderMessage::has_thumbnail() const { - return _internal_has_thumbnail(); -} -inline void Message_OrderMessage::clear_thumbnail() { - _impl_.thumbnail_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_OrderMessage::thumbnail() const { - // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.thumbnail) - return _internal_thumbnail(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_OrderMessage::set_thumbnail(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.thumbnail_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.thumbnail) -} -inline std::string* Message_OrderMessage::mutable_thumbnail() { - std::string* _s = _internal_mutable_thumbnail(); - // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.thumbnail) - return _s; -} -inline const std::string& Message_OrderMessage::_internal_thumbnail() const { - return _impl_.thumbnail_.Get(); -} -inline void Message_OrderMessage::_internal_set_thumbnail(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.thumbnail_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_OrderMessage::_internal_mutable_thumbnail() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.thumbnail_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_OrderMessage::release_thumbnail() { - // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.thumbnail) - if (!_internal_has_thumbnail()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.thumbnail_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.thumbnail_.IsDefault()) { - _impl_.thumbnail_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_OrderMessage::set_allocated_thumbnail(std::string* thumbnail) { - if (thumbnail != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.thumbnail_.SetAllocated(thumbnail, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.thumbnail_.IsDefault()) { - _impl_.thumbnail_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.OrderMessage.thumbnail) -} - -// optional int32 itemCount = 3; -inline bool Message_OrderMessage::_internal_has_itemcount() const { - bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; - return value; -} -inline bool Message_OrderMessage::has_itemcount() const { - return _internal_has_itemcount(); -} -inline void Message_OrderMessage::clear_itemcount() { - _impl_.itemcount_ = 0; - _impl_._has_bits_[0] &= ~0x00000200u; -} -inline int32_t Message_OrderMessage::_internal_itemcount() const { - return _impl_.itemcount_; -} -inline int32_t Message_OrderMessage::itemcount() const { - // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.itemCount) - return _internal_itemcount(); -} -inline void Message_OrderMessage::_internal_set_itemcount(int32_t value) { - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.itemcount_ = value; -} -inline void Message_OrderMessage::set_itemcount(int32_t value) { - _internal_set_itemcount(value); - // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.itemCount) -} - -// optional .proto.Message.OrderMessage.OrderStatus status = 4; -inline bool Message_OrderMessage::_internal_has_status() const { - bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; - return value; -} -inline bool Message_OrderMessage::has_status() const { - return _internal_has_status(); -} -inline void Message_OrderMessage::clear_status() { - _impl_.status_ = 1; - _impl_._has_bits_[0] &= ~0x00000400u; -} -inline ::proto::Message_OrderMessage_OrderStatus Message_OrderMessage::_internal_status() const { - return static_cast< ::proto::Message_OrderMessage_OrderStatus >(_impl_.status_); -} -inline ::proto::Message_OrderMessage_OrderStatus Message_OrderMessage::status() const { - // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.status) - return _internal_status(); -} -inline void Message_OrderMessage::_internal_set_status(::proto::Message_OrderMessage_OrderStatus value) { - assert(::proto::Message_OrderMessage_OrderStatus_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000400u; - _impl_.status_ = value; -} -inline void Message_OrderMessage::set_status(::proto::Message_OrderMessage_OrderStatus value) { - _internal_set_status(value); - // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.status) -} - -// optional .proto.Message.OrderMessage.OrderSurface surface = 5; -inline bool Message_OrderMessage::_internal_has_surface() const { - bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; - return value; -} -inline bool Message_OrderMessage::has_surface() const { - return _internal_has_surface(); -} -inline void Message_OrderMessage::clear_surface() { - _impl_.surface_ = 1; - _impl_._has_bits_[0] &= ~0x00000800u; -} -inline ::proto::Message_OrderMessage_OrderSurface Message_OrderMessage::_internal_surface() const { - return static_cast< ::proto::Message_OrderMessage_OrderSurface >(_impl_.surface_); -} -inline ::proto::Message_OrderMessage_OrderSurface Message_OrderMessage::surface() const { - // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.surface) - return _internal_surface(); -} -inline void Message_OrderMessage::_internal_set_surface(::proto::Message_OrderMessage_OrderSurface value) { - assert(::proto::Message_OrderMessage_OrderSurface_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000800u; - _impl_.surface_ = value; -} -inline void Message_OrderMessage::set_surface(::proto::Message_OrderMessage_OrderSurface value) { - _internal_set_surface(value); - // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.surface) -} - -// optional string message = 6; -inline bool Message_OrderMessage::_internal_has_message() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool Message_OrderMessage::has_message() const { - return _internal_has_message(); -} -inline void Message_OrderMessage::clear_message() { - _impl_.message_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& Message_OrderMessage::message() const { - // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.message) - return _internal_message(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_OrderMessage::set_message(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.message_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.message) -} -inline std::string* Message_OrderMessage::mutable_message() { - std::string* _s = _internal_mutable_message(); - // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.message) - return _s; -} -inline const std::string& Message_OrderMessage::_internal_message() const { - return _impl_.message_.Get(); -} -inline void Message_OrderMessage::_internal_set_message(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.message_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_OrderMessage::_internal_mutable_message() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.message_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_OrderMessage::release_message() { - // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.message) - if (!_internal_has_message()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.message_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.message_.IsDefault()) { - _impl_.message_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_OrderMessage::set_allocated_message(std::string* message) { - if (message != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.message_.SetAllocated(message, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.message_.IsDefault()) { - _impl_.message_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.OrderMessage.message) -} - -// optional string orderTitle = 7; -inline bool Message_OrderMessage::_internal_has_ordertitle() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool Message_OrderMessage::has_ordertitle() const { - return _internal_has_ordertitle(); -} -inline void Message_OrderMessage::clear_ordertitle() { - _impl_.ordertitle_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const std::string& Message_OrderMessage::ordertitle() const { - // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.orderTitle) - return _internal_ordertitle(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_OrderMessage::set_ordertitle(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.ordertitle_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.orderTitle) -} -inline std::string* Message_OrderMessage::mutable_ordertitle() { - std::string* _s = _internal_mutable_ordertitle(); - // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.orderTitle) - return _s; -} -inline const std::string& Message_OrderMessage::_internal_ordertitle() const { - return _impl_.ordertitle_.Get(); -} -inline void Message_OrderMessage::_internal_set_ordertitle(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.ordertitle_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_OrderMessage::_internal_mutable_ordertitle() { - _impl_._has_bits_[0] |= 0x00000008u; - return _impl_.ordertitle_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_OrderMessage::release_ordertitle() { - // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.orderTitle) - if (!_internal_has_ordertitle()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000008u; - auto* p = _impl_.ordertitle_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.ordertitle_.IsDefault()) { - _impl_.ordertitle_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_OrderMessage::set_allocated_ordertitle(std::string* ordertitle) { - if (ordertitle != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.ordertitle_.SetAllocated(ordertitle, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.ordertitle_.IsDefault()) { - _impl_.ordertitle_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.OrderMessage.orderTitle) -} - -// optional string sellerJid = 8; -inline bool Message_OrderMessage::_internal_has_sellerjid() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool Message_OrderMessage::has_sellerjid() const { - return _internal_has_sellerjid(); -} -inline void Message_OrderMessage::clear_sellerjid() { - _impl_.sellerjid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const std::string& Message_OrderMessage::sellerjid() const { - // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.sellerJid) - return _internal_sellerjid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_OrderMessage::set_sellerjid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.sellerjid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.sellerJid) -} -inline std::string* Message_OrderMessage::mutable_sellerjid() { - std::string* _s = _internal_mutable_sellerjid(); - // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.sellerJid) - return _s; -} -inline const std::string& Message_OrderMessage::_internal_sellerjid() const { - return _impl_.sellerjid_.Get(); -} -inline void Message_OrderMessage::_internal_set_sellerjid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.sellerjid_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_OrderMessage::_internal_mutable_sellerjid() { - _impl_._has_bits_[0] |= 0x00000010u; - return _impl_.sellerjid_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_OrderMessage::release_sellerjid() { - // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.sellerJid) - if (!_internal_has_sellerjid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000010u; - auto* p = _impl_.sellerjid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.sellerjid_.IsDefault()) { - _impl_.sellerjid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_OrderMessage::set_allocated_sellerjid(std::string* sellerjid) { - if (sellerjid != nullptr) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.sellerjid_.SetAllocated(sellerjid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.sellerjid_.IsDefault()) { - _impl_.sellerjid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.OrderMessage.sellerJid) -} - -// optional string token = 9; -inline bool Message_OrderMessage::_internal_has_token() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool Message_OrderMessage::has_token() const { - return _internal_has_token(); -} -inline void Message_OrderMessage::clear_token() { - _impl_.token_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline const std::string& Message_OrderMessage::token() const { - // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.token) - return _internal_token(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_OrderMessage::set_token(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.token_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.token) -} -inline std::string* Message_OrderMessage::mutable_token() { - std::string* _s = _internal_mutable_token(); - // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.token) - return _s; -} -inline const std::string& Message_OrderMessage::_internal_token() const { - return _impl_.token_.Get(); -} -inline void Message_OrderMessage::_internal_set_token(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.token_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_OrderMessage::_internal_mutable_token() { - _impl_._has_bits_[0] |= 0x00000020u; - return _impl_.token_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_OrderMessage::release_token() { - // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.token) - if (!_internal_has_token()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000020u; - auto* p = _impl_.token_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.token_.IsDefault()) { - _impl_.token_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_OrderMessage::set_allocated_token(std::string* token) { - if (token != nullptr) { - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - _impl_.token_.SetAllocated(token, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.token_.IsDefault()) { - _impl_.token_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.OrderMessage.token) -} - -// optional int64 totalAmount1000 = 10; -inline bool Message_OrderMessage::_internal_has_totalamount1000() const { - bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; - return value; -} -inline bool Message_OrderMessage::has_totalamount1000() const { - return _internal_has_totalamount1000(); -} -inline void Message_OrderMessage::clear_totalamount1000() { - _impl_.totalamount1000_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000100u; -} -inline int64_t Message_OrderMessage::_internal_totalamount1000() const { - return _impl_.totalamount1000_; -} -inline int64_t Message_OrderMessage::totalamount1000() const { - // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.totalAmount1000) - return _internal_totalamount1000(); -} -inline void Message_OrderMessage::_internal_set_totalamount1000(int64_t value) { - _impl_._has_bits_[0] |= 0x00000100u; - _impl_.totalamount1000_ = value; -} -inline void Message_OrderMessage::set_totalamount1000(int64_t value) { - _internal_set_totalamount1000(value); - // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.totalAmount1000) -} - -// optional string totalCurrencyCode = 11; -inline bool Message_OrderMessage::_internal_has_totalcurrencycode() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool Message_OrderMessage::has_totalcurrencycode() const { - return _internal_has_totalcurrencycode(); -} -inline void Message_OrderMessage::clear_totalcurrencycode() { - _impl_.totalcurrencycode_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline const std::string& Message_OrderMessage::totalcurrencycode() const { - // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.totalCurrencyCode) - return _internal_totalcurrencycode(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_OrderMessage::set_totalcurrencycode(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.totalcurrencycode_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.totalCurrencyCode) -} -inline std::string* Message_OrderMessage::mutable_totalcurrencycode() { - std::string* _s = _internal_mutable_totalcurrencycode(); - // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.totalCurrencyCode) - return _s; -} -inline const std::string& Message_OrderMessage::_internal_totalcurrencycode() const { - return _impl_.totalcurrencycode_.Get(); -} -inline void Message_OrderMessage::_internal_set_totalcurrencycode(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.totalcurrencycode_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_OrderMessage::_internal_mutable_totalcurrencycode() { - _impl_._has_bits_[0] |= 0x00000040u; - return _impl_.totalcurrencycode_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_OrderMessage::release_totalcurrencycode() { - // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.totalCurrencyCode) - if (!_internal_has_totalcurrencycode()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000040u; - auto* p = _impl_.totalcurrencycode_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.totalcurrencycode_.IsDefault()) { - _impl_.totalcurrencycode_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_OrderMessage::set_allocated_totalcurrencycode(std::string* totalcurrencycode) { - if (totalcurrencycode != nullptr) { - _impl_._has_bits_[0] |= 0x00000040u; - } else { - _impl_._has_bits_[0] &= ~0x00000040u; - } - _impl_.totalcurrencycode_.SetAllocated(totalcurrencycode, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.totalcurrencycode_.IsDefault()) { - _impl_.totalcurrencycode_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.OrderMessage.totalCurrencyCode) -} - -// optional .proto.ContextInfo contextInfo = 17; -inline bool Message_OrderMessage::_internal_has_contextinfo() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); - return value; -} -inline bool Message_OrderMessage::has_contextinfo() const { - return _internal_has_contextinfo(); -} -inline void Message_OrderMessage::clear_contextinfo() { - if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline const ::proto::ContextInfo& Message_OrderMessage::_internal_contextinfo() const { - const ::proto::ContextInfo* p = _impl_.contextinfo_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ContextInfo_default_instance_); -} -inline const ::proto::ContextInfo& Message_OrderMessage::contextinfo() const { - // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.contextInfo) - return _internal_contextinfo(); -} -inline void Message_OrderMessage::unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); - } - _impl_.contextinfo_ = contextinfo; - if (contextinfo) { - _impl_._has_bits_[0] |= 0x00000080u; - } else { - _impl_._has_bits_[0] &= ~0x00000080u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.OrderMessage.contextInfo) -} -inline ::proto::ContextInfo* Message_OrderMessage::release_contextinfo() { - _impl_._has_bits_[0] &= ~0x00000080u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ContextInfo* Message_OrderMessage::unsafe_arena_release_contextinfo() { - // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.contextInfo) - _impl_._has_bits_[0] &= ~0x00000080u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; - return temp; -} -inline ::proto::ContextInfo* Message_OrderMessage::_internal_mutable_contextinfo() { - _impl_._has_bits_[0] |= 0x00000080u; - if (_impl_.contextinfo_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); - _impl_.contextinfo_ = p; - } - return _impl_.contextinfo_; -} -inline ::proto::ContextInfo* Message_OrderMessage::mutable_contextinfo() { - ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); - // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.contextInfo) - return _msg; -} -inline void Message_OrderMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.contextinfo_; - } - if (contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); - if (message_arena != submessage_arena) { - contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, contextinfo, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000080u; - } else { - _impl_._has_bits_[0] &= ~0x00000080u; - } - _impl_.contextinfo_ = contextinfo; - // @@protoc_insertion_point(field_set_allocated:proto.Message.OrderMessage.contextInfo) -} - -// ------------------------------------------------------------------- - -// Message_PaymentInviteMessage - -// optional .proto.Message.PaymentInviteMessage.ServiceType serviceType = 1; -inline bool Message_PaymentInviteMessage::_internal_has_servicetype() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_PaymentInviteMessage::has_servicetype() const { - return _internal_has_servicetype(); -} -inline void Message_PaymentInviteMessage::clear_servicetype() { - _impl_.servicetype_ = 0; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline ::proto::Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage::_internal_servicetype() const { - return static_cast< ::proto::Message_PaymentInviteMessage_ServiceType >(_impl_.servicetype_); -} -inline ::proto::Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage::servicetype() const { - // @@protoc_insertion_point(field_get:proto.Message.PaymentInviteMessage.serviceType) - return _internal_servicetype(); -} -inline void Message_PaymentInviteMessage::_internal_set_servicetype(::proto::Message_PaymentInviteMessage_ServiceType value) { - assert(::proto::Message_PaymentInviteMessage_ServiceType_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.servicetype_ = value; -} -inline void Message_PaymentInviteMessage::set_servicetype(::proto::Message_PaymentInviteMessage_ServiceType value) { - _internal_set_servicetype(value); - // @@protoc_insertion_point(field_set:proto.Message.PaymentInviteMessage.serviceType) -} - -// optional int64 expiryTimestamp = 2; -inline bool Message_PaymentInviteMessage::_internal_has_expirytimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_PaymentInviteMessage::has_expirytimestamp() const { - return _internal_has_expirytimestamp(); -} -inline void Message_PaymentInviteMessage::clear_expirytimestamp() { - _impl_.expirytimestamp_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline int64_t Message_PaymentInviteMessage::_internal_expirytimestamp() const { - return _impl_.expirytimestamp_; -} -inline int64_t Message_PaymentInviteMessage::expirytimestamp() const { - // @@protoc_insertion_point(field_get:proto.Message.PaymentInviteMessage.expiryTimestamp) - return _internal_expirytimestamp(); -} -inline void Message_PaymentInviteMessage::_internal_set_expirytimestamp(int64_t value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.expirytimestamp_ = value; -} -inline void Message_PaymentInviteMessage::set_expirytimestamp(int64_t value) { - _internal_set_expirytimestamp(value); - // @@protoc_insertion_point(field_set:proto.Message.PaymentInviteMessage.expiryTimestamp) -} - -// ------------------------------------------------------------------- - -// Message_PollCreationMessage_Option - -// optional string optionName = 1; -inline bool Message_PollCreationMessage_Option::_internal_has_optionname() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_PollCreationMessage_Option::has_optionname() const { - return _internal_has_optionname(); -} -inline void Message_PollCreationMessage_Option::clear_optionname() { - _impl_.optionname_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_PollCreationMessage_Option::optionname() const { - // @@protoc_insertion_point(field_get:proto.Message.PollCreationMessage.Option.optionName) - return _internal_optionname(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_PollCreationMessage_Option::set_optionname(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.optionname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.PollCreationMessage.Option.optionName) -} -inline std::string* Message_PollCreationMessage_Option::mutable_optionname() { - std::string* _s = _internal_mutable_optionname(); - // @@protoc_insertion_point(field_mutable:proto.Message.PollCreationMessage.Option.optionName) - return _s; -} -inline const std::string& Message_PollCreationMessage_Option::_internal_optionname() const { - return _impl_.optionname_.Get(); -} -inline void Message_PollCreationMessage_Option::_internal_set_optionname(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.optionname_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_PollCreationMessage_Option::_internal_mutable_optionname() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.optionname_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_PollCreationMessage_Option::release_optionname() { - // @@protoc_insertion_point(field_release:proto.Message.PollCreationMessage.Option.optionName) - if (!_internal_has_optionname()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.optionname_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.optionname_.IsDefault()) { - _impl_.optionname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_PollCreationMessage_Option::set_allocated_optionname(std::string* optionname) { - if (optionname != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.optionname_.SetAllocated(optionname, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.optionname_.IsDefault()) { - _impl_.optionname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.PollCreationMessage.Option.optionName) -} - -// ------------------------------------------------------------------- - -// Message_PollCreationMessage - -// optional bytes encKey = 1; -inline bool Message_PollCreationMessage::_internal_has_enckey() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_PollCreationMessage::has_enckey() const { - return _internal_has_enckey(); -} -inline void Message_PollCreationMessage::clear_enckey() { - _impl_.enckey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_PollCreationMessage::enckey() const { - // @@protoc_insertion_point(field_get:proto.Message.PollCreationMessage.encKey) - return _internal_enckey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_PollCreationMessage::set_enckey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.enckey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.PollCreationMessage.encKey) -} -inline std::string* Message_PollCreationMessage::mutable_enckey() { - std::string* _s = _internal_mutable_enckey(); - // @@protoc_insertion_point(field_mutable:proto.Message.PollCreationMessage.encKey) - return _s; -} -inline const std::string& Message_PollCreationMessage::_internal_enckey() const { - return _impl_.enckey_.Get(); -} -inline void Message_PollCreationMessage::_internal_set_enckey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.enckey_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_PollCreationMessage::_internal_mutable_enckey() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.enckey_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_PollCreationMessage::release_enckey() { - // @@protoc_insertion_point(field_release:proto.Message.PollCreationMessage.encKey) - if (!_internal_has_enckey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.enckey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.enckey_.IsDefault()) { - _impl_.enckey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_PollCreationMessage::set_allocated_enckey(std::string* enckey) { - if (enckey != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.enckey_.SetAllocated(enckey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.enckey_.IsDefault()) { - _impl_.enckey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.PollCreationMessage.encKey) -} - -// optional string name = 2; -inline bool Message_PollCreationMessage::_internal_has_name() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_PollCreationMessage::has_name() const { - return _internal_has_name(); -} -inline void Message_PollCreationMessage::clear_name() { - _impl_.name_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_PollCreationMessage::name() const { - // @@protoc_insertion_point(field_get:proto.Message.PollCreationMessage.name) - return _internal_name(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_PollCreationMessage::set_name(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.PollCreationMessage.name) -} -inline std::string* Message_PollCreationMessage::mutable_name() { - std::string* _s = _internal_mutable_name(); - // @@protoc_insertion_point(field_mutable:proto.Message.PollCreationMessage.name) - return _s; -} -inline const std::string& Message_PollCreationMessage::_internal_name() const { - return _impl_.name_.Get(); -} -inline void Message_PollCreationMessage::_internal_set_name(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.name_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_PollCreationMessage::_internal_mutable_name() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.name_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_PollCreationMessage::release_name() { - // @@protoc_insertion_point(field_release:proto.Message.PollCreationMessage.name) - if (!_internal_has_name()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.name_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.name_.IsDefault()) { - _impl_.name_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_PollCreationMessage::set_allocated_name(std::string* name) { - if (name != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.name_.SetAllocated(name, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.name_.IsDefault()) { - _impl_.name_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.PollCreationMessage.name) -} - -// repeated .proto.Message.PollCreationMessage.Option options = 3; -inline int Message_PollCreationMessage::_internal_options_size() const { - return _impl_.options_.size(); -} -inline int Message_PollCreationMessage::options_size() const { - return _internal_options_size(); -} -inline void Message_PollCreationMessage::clear_options() { - _impl_.options_.Clear(); -} -inline ::proto::Message_PollCreationMessage_Option* Message_PollCreationMessage::mutable_options(int index) { - // @@protoc_insertion_point(field_mutable:proto.Message.PollCreationMessage.options) - return _impl_.options_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_PollCreationMessage_Option >* -Message_PollCreationMessage::mutable_options() { - // @@protoc_insertion_point(field_mutable_list:proto.Message.PollCreationMessage.options) - return &_impl_.options_; -} -inline const ::proto::Message_PollCreationMessage_Option& Message_PollCreationMessage::_internal_options(int index) const { - return _impl_.options_.Get(index); -} -inline const ::proto::Message_PollCreationMessage_Option& Message_PollCreationMessage::options(int index) const { - // @@protoc_insertion_point(field_get:proto.Message.PollCreationMessage.options) - return _internal_options(index); -} -inline ::proto::Message_PollCreationMessage_Option* Message_PollCreationMessage::_internal_add_options() { - return _impl_.options_.Add(); -} -inline ::proto::Message_PollCreationMessage_Option* Message_PollCreationMessage::add_options() { - ::proto::Message_PollCreationMessage_Option* _add = _internal_add_options(); - // @@protoc_insertion_point(field_add:proto.Message.PollCreationMessage.options) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_PollCreationMessage_Option >& -Message_PollCreationMessage::options() const { - // @@protoc_insertion_point(field_list:proto.Message.PollCreationMessage.options) - return _impl_.options_; -} - -// optional uint32 selectableOptionsCount = 4; -inline bool Message_PollCreationMessage::_internal_has_selectableoptionscount() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool Message_PollCreationMessage::has_selectableoptionscount() const { - return _internal_has_selectableoptionscount(); -} -inline void Message_PollCreationMessage::clear_selectableoptionscount() { - _impl_.selectableoptionscount_ = 0u; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline uint32_t Message_PollCreationMessage::_internal_selectableoptionscount() const { - return _impl_.selectableoptionscount_; -} -inline uint32_t Message_PollCreationMessage::selectableoptionscount() const { - // @@protoc_insertion_point(field_get:proto.Message.PollCreationMessage.selectableOptionsCount) - return _internal_selectableoptionscount(); -} -inline void Message_PollCreationMessage::_internal_set_selectableoptionscount(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.selectableoptionscount_ = value; -} -inline void Message_PollCreationMessage::set_selectableoptionscount(uint32_t value) { - _internal_set_selectableoptionscount(value); - // @@protoc_insertion_point(field_set:proto.Message.PollCreationMessage.selectableOptionsCount) -} - -// optional .proto.ContextInfo contextInfo = 5; -inline bool Message_PollCreationMessage::_internal_has_contextinfo() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); - return value; -} -inline bool Message_PollCreationMessage::has_contextinfo() const { - return _internal_has_contextinfo(); -} -inline void Message_PollCreationMessage::clear_contextinfo() { - if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const ::proto::ContextInfo& Message_PollCreationMessage::_internal_contextinfo() const { - const ::proto::ContextInfo* p = _impl_.contextinfo_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ContextInfo_default_instance_); -} -inline const ::proto::ContextInfo& Message_PollCreationMessage::contextinfo() const { - // @@protoc_insertion_point(field_get:proto.Message.PollCreationMessage.contextInfo) - return _internal_contextinfo(); -} -inline void Message_PollCreationMessage::unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); - } - _impl_.contextinfo_ = contextinfo; - if (contextinfo) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.PollCreationMessage.contextInfo) -} -inline ::proto::ContextInfo* Message_PollCreationMessage::release_contextinfo() { - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ContextInfo* Message_PollCreationMessage::unsafe_arena_release_contextinfo() { - // @@protoc_insertion_point(field_release:proto.Message.PollCreationMessage.contextInfo) - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; - return temp; -} -inline ::proto::ContextInfo* Message_PollCreationMessage::_internal_mutable_contextinfo() { - _impl_._has_bits_[0] |= 0x00000004u; - if (_impl_.contextinfo_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); - _impl_.contextinfo_ = p; - } - return _impl_.contextinfo_; -} -inline ::proto::ContextInfo* Message_PollCreationMessage::mutable_contextinfo() { - ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); - // @@protoc_insertion_point(field_mutable:proto.Message.PollCreationMessage.contextInfo) - return _msg; -} -inline void Message_PollCreationMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.contextinfo_; - } - if (contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); - if (message_arena != submessage_arena) { - contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, contextinfo, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.contextinfo_ = contextinfo; - // @@protoc_insertion_point(field_set_allocated:proto.Message.PollCreationMessage.contextInfo) -} - -// ------------------------------------------------------------------- - -// Message_PollEncValue - -// optional bytes encPayload = 1; -inline bool Message_PollEncValue::_internal_has_encpayload() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_PollEncValue::has_encpayload() const { - return _internal_has_encpayload(); -} -inline void Message_PollEncValue::clear_encpayload() { - _impl_.encpayload_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_PollEncValue::encpayload() const { - // @@protoc_insertion_point(field_get:proto.Message.PollEncValue.encPayload) - return _internal_encpayload(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_PollEncValue::set_encpayload(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.encpayload_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.PollEncValue.encPayload) -} -inline std::string* Message_PollEncValue::mutable_encpayload() { - std::string* _s = _internal_mutable_encpayload(); - // @@protoc_insertion_point(field_mutable:proto.Message.PollEncValue.encPayload) - return _s; -} -inline const std::string& Message_PollEncValue::_internal_encpayload() const { - return _impl_.encpayload_.Get(); -} -inline void Message_PollEncValue::_internal_set_encpayload(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.encpayload_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_PollEncValue::_internal_mutable_encpayload() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.encpayload_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_PollEncValue::release_encpayload() { - // @@protoc_insertion_point(field_release:proto.Message.PollEncValue.encPayload) - if (!_internal_has_encpayload()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.encpayload_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.encpayload_.IsDefault()) { - _impl_.encpayload_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_PollEncValue::set_allocated_encpayload(std::string* encpayload) { - if (encpayload != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.encpayload_.SetAllocated(encpayload, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.encpayload_.IsDefault()) { - _impl_.encpayload_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.PollEncValue.encPayload) -} - -// optional bytes encIv = 2; -inline bool Message_PollEncValue::_internal_has_enciv() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_PollEncValue::has_enciv() const { - return _internal_has_enciv(); -} -inline void Message_PollEncValue::clear_enciv() { - _impl_.enciv_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_PollEncValue::enciv() const { - // @@protoc_insertion_point(field_get:proto.Message.PollEncValue.encIv) - return _internal_enciv(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_PollEncValue::set_enciv(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.enciv_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.PollEncValue.encIv) -} -inline std::string* Message_PollEncValue::mutable_enciv() { - std::string* _s = _internal_mutable_enciv(); - // @@protoc_insertion_point(field_mutable:proto.Message.PollEncValue.encIv) - return _s; -} -inline const std::string& Message_PollEncValue::_internal_enciv() const { - return _impl_.enciv_.Get(); -} -inline void Message_PollEncValue::_internal_set_enciv(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.enciv_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_PollEncValue::_internal_mutable_enciv() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.enciv_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_PollEncValue::release_enciv() { - // @@protoc_insertion_point(field_release:proto.Message.PollEncValue.encIv) - if (!_internal_has_enciv()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.enciv_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.enciv_.IsDefault()) { - _impl_.enciv_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_PollEncValue::set_allocated_enciv(std::string* enciv) { - if (enciv != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.enciv_.SetAllocated(enciv, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.enciv_.IsDefault()) { - _impl_.enciv_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.PollEncValue.encIv) -} - -// ------------------------------------------------------------------- - -// Message_PollUpdateMessageMetadata - -// ------------------------------------------------------------------- - -// Message_PollUpdateMessage - -// optional .proto.MessageKey pollCreationMessageKey = 1; -inline bool Message_PollUpdateMessage::_internal_has_pollcreationmessagekey() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.pollcreationmessagekey_ != nullptr); - return value; -} -inline bool Message_PollUpdateMessage::has_pollcreationmessagekey() const { - return _internal_has_pollcreationmessagekey(); -} -inline void Message_PollUpdateMessage::clear_pollcreationmessagekey() { - if (_impl_.pollcreationmessagekey_ != nullptr) _impl_.pollcreationmessagekey_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::MessageKey& Message_PollUpdateMessage::_internal_pollcreationmessagekey() const { - const ::proto::MessageKey* p = _impl_.pollcreationmessagekey_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_MessageKey_default_instance_); -} -inline const ::proto::MessageKey& Message_PollUpdateMessage::pollcreationmessagekey() const { - // @@protoc_insertion_point(field_get:proto.Message.PollUpdateMessage.pollCreationMessageKey) - return _internal_pollcreationmessagekey(); -} -inline void Message_PollUpdateMessage::unsafe_arena_set_allocated_pollcreationmessagekey( - ::proto::MessageKey* pollcreationmessagekey) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pollcreationmessagekey_); - } - _impl_.pollcreationmessagekey_ = pollcreationmessagekey; - if (pollcreationmessagekey) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.PollUpdateMessage.pollCreationMessageKey) -} -inline ::proto::MessageKey* Message_PollUpdateMessage::release_pollcreationmessagekey() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::MessageKey* temp = _impl_.pollcreationmessagekey_; - _impl_.pollcreationmessagekey_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::MessageKey* Message_PollUpdateMessage::unsafe_arena_release_pollcreationmessagekey() { - // @@protoc_insertion_point(field_release:proto.Message.PollUpdateMessage.pollCreationMessageKey) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::MessageKey* temp = _impl_.pollcreationmessagekey_; - _impl_.pollcreationmessagekey_ = nullptr; - return temp; -} -inline ::proto::MessageKey* Message_PollUpdateMessage::_internal_mutable_pollcreationmessagekey() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.pollcreationmessagekey_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation()); - _impl_.pollcreationmessagekey_ = p; - } - return _impl_.pollcreationmessagekey_; -} -inline ::proto::MessageKey* Message_PollUpdateMessage::mutable_pollcreationmessagekey() { - ::proto::MessageKey* _msg = _internal_mutable_pollcreationmessagekey(); - // @@protoc_insertion_point(field_mutable:proto.Message.PollUpdateMessage.pollCreationMessageKey) - return _msg; -} -inline void Message_PollUpdateMessage::set_allocated_pollcreationmessagekey(::proto::MessageKey* pollcreationmessagekey) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.pollcreationmessagekey_; - } - if (pollcreationmessagekey) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pollcreationmessagekey); - if (message_arena != submessage_arena) { - pollcreationmessagekey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, pollcreationmessagekey, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.pollcreationmessagekey_ = pollcreationmessagekey; - // @@protoc_insertion_point(field_set_allocated:proto.Message.PollUpdateMessage.pollCreationMessageKey) -} - -// optional .proto.Message.PollEncValue vote = 2; -inline bool Message_PollUpdateMessage::_internal_has_vote() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.vote_ != nullptr); - return value; -} -inline bool Message_PollUpdateMessage::has_vote() const { - return _internal_has_vote(); -} -inline void Message_PollUpdateMessage::clear_vote() { - if (_impl_.vote_ != nullptr) _impl_.vote_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::Message_PollEncValue& Message_PollUpdateMessage::_internal_vote() const { - const ::proto::Message_PollEncValue* p = _impl_.vote_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_PollEncValue_default_instance_); -} -inline const ::proto::Message_PollEncValue& Message_PollUpdateMessage::vote() const { - // @@protoc_insertion_point(field_get:proto.Message.PollUpdateMessage.vote) - return _internal_vote(); -} -inline void Message_PollUpdateMessage::unsafe_arena_set_allocated_vote( - ::proto::Message_PollEncValue* vote) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.vote_); - } - _impl_.vote_ = vote; - if (vote) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.PollUpdateMessage.vote) -} -inline ::proto::Message_PollEncValue* Message_PollUpdateMessage::release_vote() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::Message_PollEncValue* temp = _impl_.vote_; - _impl_.vote_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_PollEncValue* Message_PollUpdateMessage::unsafe_arena_release_vote() { - // @@protoc_insertion_point(field_release:proto.Message.PollUpdateMessage.vote) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::Message_PollEncValue* temp = _impl_.vote_; - _impl_.vote_ = nullptr; - return temp; -} -inline ::proto::Message_PollEncValue* Message_PollUpdateMessage::_internal_mutable_vote() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.vote_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_PollEncValue>(GetArenaForAllocation()); - _impl_.vote_ = p; - } - return _impl_.vote_; -} -inline ::proto::Message_PollEncValue* Message_PollUpdateMessage::mutable_vote() { - ::proto::Message_PollEncValue* _msg = _internal_mutable_vote(); - // @@protoc_insertion_point(field_mutable:proto.Message.PollUpdateMessage.vote) - return _msg; -} -inline void Message_PollUpdateMessage::set_allocated_vote(::proto::Message_PollEncValue* vote) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.vote_; - } - if (vote) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(vote); - if (message_arena != submessage_arena) { - vote = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, vote, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.vote_ = vote; - // @@protoc_insertion_point(field_set_allocated:proto.Message.PollUpdateMessage.vote) -} - -// optional .proto.Message.PollUpdateMessageMetadata metadata = 3; -inline bool Message_PollUpdateMessage::_internal_has_metadata() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - PROTOBUF_ASSUME(!value || _impl_.metadata_ != nullptr); - return value; -} -inline bool Message_PollUpdateMessage::has_metadata() const { - return _internal_has_metadata(); -} -inline void Message_PollUpdateMessage::clear_metadata() { - if (_impl_.metadata_ != nullptr) _impl_.metadata_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const ::proto::Message_PollUpdateMessageMetadata& Message_PollUpdateMessage::_internal_metadata() const { - const ::proto::Message_PollUpdateMessageMetadata* p = _impl_.metadata_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_PollUpdateMessageMetadata_default_instance_); -} -inline const ::proto::Message_PollUpdateMessageMetadata& Message_PollUpdateMessage::metadata() const { - // @@protoc_insertion_point(field_get:proto.Message.PollUpdateMessage.metadata) - return _internal_metadata(); -} -inline void Message_PollUpdateMessage::unsafe_arena_set_allocated_metadata( - ::proto::Message_PollUpdateMessageMetadata* metadata) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.metadata_); - } - _impl_.metadata_ = metadata; - if (metadata) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.PollUpdateMessage.metadata) -} -inline ::proto::Message_PollUpdateMessageMetadata* Message_PollUpdateMessage::release_metadata() { - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::Message_PollUpdateMessageMetadata* temp = _impl_.metadata_; - _impl_.metadata_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_PollUpdateMessageMetadata* Message_PollUpdateMessage::unsafe_arena_release_metadata() { - // @@protoc_insertion_point(field_release:proto.Message.PollUpdateMessage.metadata) - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::Message_PollUpdateMessageMetadata* temp = _impl_.metadata_; - _impl_.metadata_ = nullptr; - return temp; -} -inline ::proto::Message_PollUpdateMessageMetadata* Message_PollUpdateMessage::_internal_mutable_metadata() { - _impl_._has_bits_[0] |= 0x00000004u; - if (_impl_.metadata_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_PollUpdateMessageMetadata>(GetArenaForAllocation()); - _impl_.metadata_ = p; - } - return _impl_.metadata_; -} -inline ::proto::Message_PollUpdateMessageMetadata* Message_PollUpdateMessage::mutable_metadata() { - ::proto::Message_PollUpdateMessageMetadata* _msg = _internal_mutable_metadata(); - // @@protoc_insertion_point(field_mutable:proto.Message.PollUpdateMessage.metadata) - return _msg; -} -inline void Message_PollUpdateMessage::set_allocated_metadata(::proto::Message_PollUpdateMessageMetadata* metadata) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.metadata_; - } - if (metadata) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(metadata); - if (message_arena != submessage_arena) { - metadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, metadata, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.metadata_ = metadata; - // @@protoc_insertion_point(field_set_allocated:proto.Message.PollUpdateMessage.metadata) -} - -// optional int64 senderTimestampMs = 4; -inline bool Message_PollUpdateMessage::_internal_has_sendertimestampms() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool Message_PollUpdateMessage::has_sendertimestampms() const { - return _internal_has_sendertimestampms(); -} -inline void Message_PollUpdateMessage::clear_sendertimestampms() { - _impl_.sendertimestampms_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline int64_t Message_PollUpdateMessage::_internal_sendertimestampms() const { - return _impl_.sendertimestampms_; -} -inline int64_t Message_PollUpdateMessage::sendertimestampms() const { - // @@protoc_insertion_point(field_get:proto.Message.PollUpdateMessage.senderTimestampMs) - return _internal_sendertimestampms(); -} -inline void Message_PollUpdateMessage::_internal_set_sendertimestampms(int64_t value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.sendertimestampms_ = value; -} -inline void Message_PollUpdateMessage::set_sendertimestampms(int64_t value) { - _internal_set_sendertimestampms(value); - // @@protoc_insertion_point(field_set:proto.Message.PollUpdateMessage.senderTimestampMs) -} - -// ------------------------------------------------------------------- - -// Message_PollVoteMessage - -// repeated bytes selectedOptions = 1; -inline int Message_PollVoteMessage::_internal_selectedoptions_size() const { - return _impl_.selectedoptions_.size(); -} -inline int Message_PollVoteMessage::selectedoptions_size() const { - return _internal_selectedoptions_size(); -} -inline void Message_PollVoteMessage::clear_selectedoptions() { - _impl_.selectedoptions_.Clear(); -} -inline std::string* Message_PollVoteMessage::add_selectedoptions() { - std::string* _s = _internal_add_selectedoptions(); - // @@protoc_insertion_point(field_add_mutable:proto.Message.PollVoteMessage.selectedOptions) - return _s; -} -inline const std::string& Message_PollVoteMessage::_internal_selectedoptions(int index) const { - return _impl_.selectedoptions_.Get(index); -} -inline const std::string& Message_PollVoteMessage::selectedoptions(int index) const { - // @@protoc_insertion_point(field_get:proto.Message.PollVoteMessage.selectedOptions) - return _internal_selectedoptions(index); -} -inline std::string* Message_PollVoteMessage::mutable_selectedoptions(int index) { - // @@protoc_insertion_point(field_mutable:proto.Message.PollVoteMessage.selectedOptions) - return _impl_.selectedoptions_.Mutable(index); -} -inline void Message_PollVoteMessage::set_selectedoptions(int index, const std::string& value) { - _impl_.selectedoptions_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:proto.Message.PollVoteMessage.selectedOptions) -} -inline void Message_PollVoteMessage::set_selectedoptions(int index, std::string&& value) { - _impl_.selectedoptions_.Mutable(index)->assign(std::move(value)); - // @@protoc_insertion_point(field_set:proto.Message.PollVoteMessage.selectedOptions) -} -inline void Message_PollVoteMessage::set_selectedoptions(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - _impl_.selectedoptions_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:proto.Message.PollVoteMessage.selectedOptions) -} -inline void Message_PollVoteMessage::set_selectedoptions(int index, const void* value, size_t size) { - _impl_.selectedoptions_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:proto.Message.PollVoteMessage.selectedOptions) -} -inline std::string* Message_PollVoteMessage::_internal_add_selectedoptions() { - return _impl_.selectedoptions_.Add(); -} -inline void Message_PollVoteMessage::add_selectedoptions(const std::string& value) { - _impl_.selectedoptions_.Add()->assign(value); - // @@protoc_insertion_point(field_add:proto.Message.PollVoteMessage.selectedOptions) -} -inline void Message_PollVoteMessage::add_selectedoptions(std::string&& value) { - _impl_.selectedoptions_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:proto.Message.PollVoteMessage.selectedOptions) -} -inline void Message_PollVoteMessage::add_selectedoptions(const char* value) { - GOOGLE_DCHECK(value != nullptr); - _impl_.selectedoptions_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:proto.Message.PollVoteMessage.selectedOptions) -} -inline void Message_PollVoteMessage::add_selectedoptions(const void* value, size_t size) { - _impl_.selectedoptions_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:proto.Message.PollVoteMessage.selectedOptions) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -Message_PollVoteMessage::selectedoptions() const { - // @@protoc_insertion_point(field_list:proto.Message.PollVoteMessage.selectedOptions) - return _impl_.selectedoptions_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -Message_PollVoteMessage::mutable_selectedoptions() { - // @@protoc_insertion_point(field_mutable_list:proto.Message.PollVoteMessage.selectedOptions) - return &_impl_.selectedoptions_; -} - -// ------------------------------------------------------------------- - -// Message_ProductMessage_CatalogSnapshot - -// optional .proto.Message.ImageMessage catalogImage = 1; -inline bool Message_ProductMessage_CatalogSnapshot::_internal_has_catalogimage() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - PROTOBUF_ASSUME(!value || _impl_.catalogimage_ != nullptr); - return value; -} -inline bool Message_ProductMessage_CatalogSnapshot::has_catalogimage() const { - return _internal_has_catalogimage(); -} -inline void Message_ProductMessage_CatalogSnapshot::clear_catalogimage() { - if (_impl_.catalogimage_ != nullptr) _impl_.catalogimage_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const ::proto::Message_ImageMessage& Message_ProductMessage_CatalogSnapshot::_internal_catalogimage() const { - const ::proto::Message_ImageMessage* p = _impl_.catalogimage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_ImageMessage_default_instance_); -} -inline const ::proto::Message_ImageMessage& Message_ProductMessage_CatalogSnapshot::catalogimage() const { - // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.CatalogSnapshot.catalogImage) - return _internal_catalogimage(); -} -inline void Message_ProductMessage_CatalogSnapshot::unsafe_arena_set_allocated_catalogimage( - ::proto::Message_ImageMessage* catalogimage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.catalogimage_); - } - _impl_.catalogimage_ = catalogimage; - if (catalogimage) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProductMessage.CatalogSnapshot.catalogImage) -} -inline ::proto::Message_ImageMessage* Message_ProductMessage_CatalogSnapshot::release_catalogimage() { - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::Message_ImageMessage* temp = _impl_.catalogimage_; - _impl_.catalogimage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_ImageMessage* Message_ProductMessage_CatalogSnapshot::unsafe_arena_release_catalogimage() { - // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.CatalogSnapshot.catalogImage) - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::Message_ImageMessage* temp = _impl_.catalogimage_; - _impl_.catalogimage_ = nullptr; - return temp; -} -inline ::proto::Message_ImageMessage* Message_ProductMessage_CatalogSnapshot::_internal_mutable_catalogimage() { - _impl_._has_bits_[0] |= 0x00000004u; - if (_impl_.catalogimage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_ImageMessage>(GetArenaForAllocation()); - _impl_.catalogimage_ = p; - } - return _impl_.catalogimage_; -} -inline ::proto::Message_ImageMessage* Message_ProductMessage_CatalogSnapshot::mutable_catalogimage() { - ::proto::Message_ImageMessage* _msg = _internal_mutable_catalogimage(); - // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.CatalogSnapshot.catalogImage) - return _msg; -} -inline void Message_ProductMessage_CatalogSnapshot::set_allocated_catalogimage(::proto::Message_ImageMessage* catalogimage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.catalogimage_; - } - if (catalogimage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(catalogimage); - if (message_arena != submessage_arena) { - catalogimage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, catalogimage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.catalogimage_ = catalogimage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.CatalogSnapshot.catalogImage) -} - -// optional string title = 2; -inline bool Message_ProductMessage_CatalogSnapshot::_internal_has_title() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_ProductMessage_CatalogSnapshot::has_title() const { - return _internal_has_title(); -} -inline void Message_ProductMessage_CatalogSnapshot::clear_title() { - _impl_.title_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_ProductMessage_CatalogSnapshot::title() const { - // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.CatalogSnapshot.title) - return _internal_title(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ProductMessage_CatalogSnapshot::set_title(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.title_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.CatalogSnapshot.title) -} -inline std::string* Message_ProductMessage_CatalogSnapshot::mutable_title() { - std::string* _s = _internal_mutable_title(); - // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.CatalogSnapshot.title) - return _s; -} -inline const std::string& Message_ProductMessage_CatalogSnapshot::_internal_title() const { - return _impl_.title_.Get(); -} -inline void Message_ProductMessage_CatalogSnapshot::_internal_set_title(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.title_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ProductMessage_CatalogSnapshot::_internal_mutable_title() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.title_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ProductMessage_CatalogSnapshot::release_title() { - // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.CatalogSnapshot.title) - if (!_internal_has_title()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.title_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.title_.IsDefault()) { - _impl_.title_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ProductMessage_CatalogSnapshot::set_allocated_title(std::string* title) { - if (title != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.title_.SetAllocated(title, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.title_.IsDefault()) { - _impl_.title_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.CatalogSnapshot.title) -} - -// optional string description = 3; -inline bool Message_ProductMessage_CatalogSnapshot::_internal_has_description() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_ProductMessage_CatalogSnapshot::has_description() const { - return _internal_has_description(); -} -inline void Message_ProductMessage_CatalogSnapshot::clear_description() { - _impl_.description_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_ProductMessage_CatalogSnapshot::description() const { - // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.CatalogSnapshot.description) - return _internal_description(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ProductMessage_CatalogSnapshot::set_description(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.description_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.CatalogSnapshot.description) -} -inline std::string* Message_ProductMessage_CatalogSnapshot::mutable_description() { - std::string* _s = _internal_mutable_description(); - // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.CatalogSnapshot.description) - return _s; -} -inline const std::string& Message_ProductMessage_CatalogSnapshot::_internal_description() const { - return _impl_.description_.Get(); -} -inline void Message_ProductMessage_CatalogSnapshot::_internal_set_description(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.description_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ProductMessage_CatalogSnapshot::_internal_mutable_description() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.description_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ProductMessage_CatalogSnapshot::release_description() { - // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.CatalogSnapshot.description) - if (!_internal_has_description()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.description_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.description_.IsDefault()) { - _impl_.description_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ProductMessage_CatalogSnapshot::set_allocated_description(std::string* description) { - if (description != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.description_.SetAllocated(description, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.description_.IsDefault()) { - _impl_.description_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.CatalogSnapshot.description) -} - -// ------------------------------------------------------------------- - -// Message_ProductMessage_ProductSnapshot - -// optional .proto.Message.ImageMessage productImage = 1; -inline bool Message_ProductMessage_ProductSnapshot::_internal_has_productimage() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - PROTOBUF_ASSUME(!value || _impl_.productimage_ != nullptr); - return value; -} -inline bool Message_ProductMessage_ProductSnapshot::has_productimage() const { - return _internal_has_productimage(); -} -inline void Message_ProductMessage_ProductSnapshot::clear_productimage() { - if (_impl_.productimage_ != nullptr) _impl_.productimage_->Clear(); - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline const ::proto::Message_ImageMessage& Message_ProductMessage_ProductSnapshot::_internal_productimage() const { - const ::proto::Message_ImageMessage* p = _impl_.productimage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_ImageMessage_default_instance_); -} -inline const ::proto::Message_ImageMessage& Message_ProductMessage_ProductSnapshot::productimage() const { - // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.productImage) - return _internal_productimage(); -} -inline void Message_ProductMessage_ProductSnapshot::unsafe_arena_set_allocated_productimage( - ::proto::Message_ImageMessage* productimage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.productimage_); - } - _impl_.productimage_ = productimage; - if (productimage) { - _impl_._has_bits_[0] |= 0x00000080u; - } else { - _impl_._has_bits_[0] &= ~0x00000080u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProductMessage.ProductSnapshot.productImage) -} -inline ::proto::Message_ImageMessage* Message_ProductMessage_ProductSnapshot::release_productimage() { - _impl_._has_bits_[0] &= ~0x00000080u; - ::proto::Message_ImageMessage* temp = _impl_.productimage_; - _impl_.productimage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_ImageMessage* Message_ProductMessage_ProductSnapshot::unsafe_arena_release_productimage() { - // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.productImage) - _impl_._has_bits_[0] &= ~0x00000080u; - ::proto::Message_ImageMessage* temp = _impl_.productimage_; - _impl_.productimage_ = nullptr; - return temp; -} -inline ::proto::Message_ImageMessage* Message_ProductMessage_ProductSnapshot::_internal_mutable_productimage() { - _impl_._has_bits_[0] |= 0x00000080u; - if (_impl_.productimage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_ImageMessage>(GetArenaForAllocation()); - _impl_.productimage_ = p; - } - return _impl_.productimage_; -} -inline ::proto::Message_ImageMessage* Message_ProductMessage_ProductSnapshot::mutable_productimage() { - ::proto::Message_ImageMessage* _msg = _internal_mutable_productimage(); - // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.productImage) - return _msg; -} -inline void Message_ProductMessage_ProductSnapshot::set_allocated_productimage(::proto::Message_ImageMessage* productimage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.productimage_; - } - if (productimage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(productimage); - if (message_arena != submessage_arena) { - productimage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, productimage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000080u; - } else { - _impl_._has_bits_[0] &= ~0x00000080u; - } - _impl_.productimage_ = productimage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.ProductSnapshot.productImage) -} - -// optional string productId = 2; -inline bool Message_ProductMessage_ProductSnapshot::_internal_has_productid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_ProductMessage_ProductSnapshot::has_productid() const { - return _internal_has_productid(); -} -inline void Message_ProductMessage_ProductSnapshot::clear_productid() { - _impl_.productid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_ProductMessage_ProductSnapshot::productid() const { - // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.productId) - return _internal_productid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ProductMessage_ProductSnapshot::set_productid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.productid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.productId) -} -inline std::string* Message_ProductMessage_ProductSnapshot::mutable_productid() { - std::string* _s = _internal_mutable_productid(); - // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.productId) - return _s; -} -inline const std::string& Message_ProductMessage_ProductSnapshot::_internal_productid() const { - return _impl_.productid_.Get(); -} -inline void Message_ProductMessage_ProductSnapshot::_internal_set_productid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.productid_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ProductMessage_ProductSnapshot::_internal_mutable_productid() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.productid_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ProductMessage_ProductSnapshot::release_productid() { - // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.productId) - if (!_internal_has_productid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.productid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.productid_.IsDefault()) { - _impl_.productid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ProductMessage_ProductSnapshot::set_allocated_productid(std::string* productid) { - if (productid != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.productid_.SetAllocated(productid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.productid_.IsDefault()) { - _impl_.productid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.ProductSnapshot.productId) -} - -// optional string title = 3; -inline bool Message_ProductMessage_ProductSnapshot::_internal_has_title() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_ProductMessage_ProductSnapshot::has_title() const { - return _internal_has_title(); -} -inline void Message_ProductMessage_ProductSnapshot::clear_title() { - _impl_.title_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_ProductMessage_ProductSnapshot::title() const { - // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.title) - return _internal_title(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ProductMessage_ProductSnapshot::set_title(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.title_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.title) -} -inline std::string* Message_ProductMessage_ProductSnapshot::mutable_title() { - std::string* _s = _internal_mutable_title(); - // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.title) - return _s; -} -inline const std::string& Message_ProductMessage_ProductSnapshot::_internal_title() const { - return _impl_.title_.Get(); -} -inline void Message_ProductMessage_ProductSnapshot::_internal_set_title(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.title_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ProductMessage_ProductSnapshot::_internal_mutable_title() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.title_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ProductMessage_ProductSnapshot::release_title() { - // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.title) - if (!_internal_has_title()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.title_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.title_.IsDefault()) { - _impl_.title_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ProductMessage_ProductSnapshot::set_allocated_title(std::string* title) { - if (title != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.title_.SetAllocated(title, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.title_.IsDefault()) { - _impl_.title_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.ProductSnapshot.title) -} - -// optional string description = 4; -inline bool Message_ProductMessage_ProductSnapshot::_internal_has_description() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool Message_ProductMessage_ProductSnapshot::has_description() const { - return _internal_has_description(); -} -inline void Message_ProductMessage_ProductSnapshot::clear_description() { - _impl_.description_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& Message_ProductMessage_ProductSnapshot::description() const { - // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.description) - return _internal_description(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ProductMessage_ProductSnapshot::set_description(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.description_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.description) -} -inline std::string* Message_ProductMessage_ProductSnapshot::mutable_description() { - std::string* _s = _internal_mutable_description(); - // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.description) - return _s; -} -inline const std::string& Message_ProductMessage_ProductSnapshot::_internal_description() const { - return _impl_.description_.Get(); -} -inline void Message_ProductMessage_ProductSnapshot::_internal_set_description(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.description_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ProductMessage_ProductSnapshot::_internal_mutable_description() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.description_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ProductMessage_ProductSnapshot::release_description() { - // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.description) - if (!_internal_has_description()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.description_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.description_.IsDefault()) { - _impl_.description_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ProductMessage_ProductSnapshot::set_allocated_description(std::string* description) { - if (description != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.description_.SetAllocated(description, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.description_.IsDefault()) { - _impl_.description_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.ProductSnapshot.description) -} - -// optional string currencyCode = 5; -inline bool Message_ProductMessage_ProductSnapshot::_internal_has_currencycode() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool Message_ProductMessage_ProductSnapshot::has_currencycode() const { - return _internal_has_currencycode(); -} -inline void Message_ProductMessage_ProductSnapshot::clear_currencycode() { - _impl_.currencycode_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const std::string& Message_ProductMessage_ProductSnapshot::currencycode() const { - // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.currencyCode) - return _internal_currencycode(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ProductMessage_ProductSnapshot::set_currencycode(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.currencycode_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.currencyCode) -} -inline std::string* Message_ProductMessage_ProductSnapshot::mutable_currencycode() { - std::string* _s = _internal_mutable_currencycode(); - // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.currencyCode) - return _s; -} -inline const std::string& Message_ProductMessage_ProductSnapshot::_internal_currencycode() const { - return _impl_.currencycode_.Get(); -} -inline void Message_ProductMessage_ProductSnapshot::_internal_set_currencycode(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.currencycode_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ProductMessage_ProductSnapshot::_internal_mutable_currencycode() { - _impl_._has_bits_[0] |= 0x00000008u; - return _impl_.currencycode_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ProductMessage_ProductSnapshot::release_currencycode() { - // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.currencyCode) - if (!_internal_has_currencycode()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000008u; - auto* p = _impl_.currencycode_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.currencycode_.IsDefault()) { - _impl_.currencycode_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ProductMessage_ProductSnapshot::set_allocated_currencycode(std::string* currencycode) { - if (currencycode != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.currencycode_.SetAllocated(currencycode, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.currencycode_.IsDefault()) { - _impl_.currencycode_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.ProductSnapshot.currencyCode) -} - -// optional int64 priceAmount1000 = 6; -inline bool Message_ProductMessage_ProductSnapshot::_internal_has_priceamount1000() const { - bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; - return value; -} -inline bool Message_ProductMessage_ProductSnapshot::has_priceamount1000() const { - return _internal_has_priceamount1000(); -} -inline void Message_ProductMessage_ProductSnapshot::clear_priceamount1000() { - _impl_.priceamount1000_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000100u; -} -inline int64_t Message_ProductMessage_ProductSnapshot::_internal_priceamount1000() const { - return _impl_.priceamount1000_; -} -inline int64_t Message_ProductMessage_ProductSnapshot::priceamount1000() const { - // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.priceAmount1000) - return _internal_priceamount1000(); -} -inline void Message_ProductMessage_ProductSnapshot::_internal_set_priceamount1000(int64_t value) { - _impl_._has_bits_[0] |= 0x00000100u; - _impl_.priceamount1000_ = value; -} -inline void Message_ProductMessage_ProductSnapshot::set_priceamount1000(int64_t value) { - _internal_set_priceamount1000(value); - // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.priceAmount1000) -} - -// optional string retailerId = 7; -inline bool Message_ProductMessage_ProductSnapshot::_internal_has_retailerid() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool Message_ProductMessage_ProductSnapshot::has_retailerid() const { - return _internal_has_retailerid(); -} -inline void Message_ProductMessage_ProductSnapshot::clear_retailerid() { - _impl_.retailerid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const std::string& Message_ProductMessage_ProductSnapshot::retailerid() const { - // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.retailerId) - return _internal_retailerid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ProductMessage_ProductSnapshot::set_retailerid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.retailerid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.retailerId) -} -inline std::string* Message_ProductMessage_ProductSnapshot::mutable_retailerid() { - std::string* _s = _internal_mutable_retailerid(); - // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.retailerId) - return _s; -} -inline const std::string& Message_ProductMessage_ProductSnapshot::_internal_retailerid() const { - return _impl_.retailerid_.Get(); -} -inline void Message_ProductMessage_ProductSnapshot::_internal_set_retailerid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.retailerid_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ProductMessage_ProductSnapshot::_internal_mutable_retailerid() { - _impl_._has_bits_[0] |= 0x00000010u; - return _impl_.retailerid_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ProductMessage_ProductSnapshot::release_retailerid() { - // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.retailerId) - if (!_internal_has_retailerid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000010u; - auto* p = _impl_.retailerid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.retailerid_.IsDefault()) { - _impl_.retailerid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ProductMessage_ProductSnapshot::set_allocated_retailerid(std::string* retailerid) { - if (retailerid != nullptr) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.retailerid_.SetAllocated(retailerid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.retailerid_.IsDefault()) { - _impl_.retailerid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.ProductSnapshot.retailerId) -} - -// optional string url = 8; -inline bool Message_ProductMessage_ProductSnapshot::_internal_has_url() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool Message_ProductMessage_ProductSnapshot::has_url() const { - return _internal_has_url(); -} -inline void Message_ProductMessage_ProductSnapshot::clear_url() { - _impl_.url_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline const std::string& Message_ProductMessage_ProductSnapshot::url() const { - // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.url) - return _internal_url(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ProductMessage_ProductSnapshot::set_url(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.url_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.url) -} -inline std::string* Message_ProductMessage_ProductSnapshot::mutable_url() { - std::string* _s = _internal_mutable_url(); - // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.url) - return _s; -} -inline const std::string& Message_ProductMessage_ProductSnapshot::_internal_url() const { - return _impl_.url_.Get(); -} -inline void Message_ProductMessage_ProductSnapshot::_internal_set_url(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.url_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ProductMessage_ProductSnapshot::_internal_mutable_url() { - _impl_._has_bits_[0] |= 0x00000020u; - return _impl_.url_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ProductMessage_ProductSnapshot::release_url() { - // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.url) - if (!_internal_has_url()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000020u; - auto* p = _impl_.url_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.url_.IsDefault()) { - _impl_.url_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ProductMessage_ProductSnapshot::set_allocated_url(std::string* url) { - if (url != nullptr) { - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - _impl_.url_.SetAllocated(url, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.url_.IsDefault()) { - _impl_.url_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.ProductSnapshot.url) -} - -// optional uint32 productImageCount = 9; -inline bool Message_ProductMessage_ProductSnapshot::_internal_has_productimagecount() const { - bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; - return value; -} -inline bool Message_ProductMessage_ProductSnapshot::has_productimagecount() const { - return _internal_has_productimagecount(); -} -inline void Message_ProductMessage_ProductSnapshot::clear_productimagecount() { - _impl_.productimagecount_ = 0u; - _impl_._has_bits_[0] &= ~0x00000400u; -} -inline uint32_t Message_ProductMessage_ProductSnapshot::_internal_productimagecount() const { - return _impl_.productimagecount_; -} -inline uint32_t Message_ProductMessage_ProductSnapshot::productimagecount() const { - // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.productImageCount) - return _internal_productimagecount(); -} -inline void Message_ProductMessage_ProductSnapshot::_internal_set_productimagecount(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000400u; - _impl_.productimagecount_ = value; -} -inline void Message_ProductMessage_ProductSnapshot::set_productimagecount(uint32_t value) { - _internal_set_productimagecount(value); - // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.productImageCount) -} - -// optional string firstImageId = 11; -inline bool Message_ProductMessage_ProductSnapshot::_internal_has_firstimageid() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool Message_ProductMessage_ProductSnapshot::has_firstimageid() const { - return _internal_has_firstimageid(); -} -inline void Message_ProductMessage_ProductSnapshot::clear_firstimageid() { - _impl_.firstimageid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline const std::string& Message_ProductMessage_ProductSnapshot::firstimageid() const { - // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.firstImageId) - return _internal_firstimageid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ProductMessage_ProductSnapshot::set_firstimageid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.firstimageid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.firstImageId) -} -inline std::string* Message_ProductMessage_ProductSnapshot::mutable_firstimageid() { - std::string* _s = _internal_mutable_firstimageid(); - // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.firstImageId) - return _s; -} -inline const std::string& Message_ProductMessage_ProductSnapshot::_internal_firstimageid() const { - return _impl_.firstimageid_.Get(); -} -inline void Message_ProductMessage_ProductSnapshot::_internal_set_firstimageid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.firstimageid_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ProductMessage_ProductSnapshot::_internal_mutable_firstimageid() { - _impl_._has_bits_[0] |= 0x00000040u; - return _impl_.firstimageid_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ProductMessage_ProductSnapshot::release_firstimageid() { - // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.firstImageId) - if (!_internal_has_firstimageid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000040u; - auto* p = _impl_.firstimageid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.firstimageid_.IsDefault()) { - _impl_.firstimageid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ProductMessage_ProductSnapshot::set_allocated_firstimageid(std::string* firstimageid) { - if (firstimageid != nullptr) { - _impl_._has_bits_[0] |= 0x00000040u; - } else { - _impl_._has_bits_[0] &= ~0x00000040u; - } - _impl_.firstimageid_.SetAllocated(firstimageid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.firstimageid_.IsDefault()) { - _impl_.firstimageid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.ProductSnapshot.firstImageId) -} - -// optional int64 salePriceAmount1000 = 12; -inline bool Message_ProductMessage_ProductSnapshot::_internal_has_salepriceamount1000() const { - bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; - return value; -} -inline bool Message_ProductMessage_ProductSnapshot::has_salepriceamount1000() const { - return _internal_has_salepriceamount1000(); -} -inline void Message_ProductMessage_ProductSnapshot::clear_salepriceamount1000() { - _impl_.salepriceamount1000_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000200u; -} -inline int64_t Message_ProductMessage_ProductSnapshot::_internal_salepriceamount1000() const { - return _impl_.salepriceamount1000_; -} -inline int64_t Message_ProductMessage_ProductSnapshot::salepriceamount1000() const { - // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.salePriceAmount1000) - return _internal_salepriceamount1000(); -} -inline void Message_ProductMessage_ProductSnapshot::_internal_set_salepriceamount1000(int64_t value) { - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.salepriceamount1000_ = value; -} -inline void Message_ProductMessage_ProductSnapshot::set_salepriceamount1000(int64_t value) { - _internal_set_salepriceamount1000(value); - // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.salePriceAmount1000) -} - -// ------------------------------------------------------------------- - -// Message_ProductMessage - -// optional .proto.Message.ProductMessage.ProductSnapshot product = 1; -inline bool Message_ProductMessage::_internal_has_product() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - PROTOBUF_ASSUME(!value || _impl_.product_ != nullptr); - return value; -} -inline bool Message_ProductMessage::has_product() const { - return _internal_has_product(); -} -inline void Message_ProductMessage::clear_product() { - if (_impl_.product_ != nullptr) _impl_.product_->Clear(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const ::proto::Message_ProductMessage_ProductSnapshot& Message_ProductMessage::_internal_product() const { - const ::proto::Message_ProductMessage_ProductSnapshot* p = _impl_.product_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_ProductMessage_ProductSnapshot_default_instance_); -} -inline const ::proto::Message_ProductMessage_ProductSnapshot& Message_ProductMessage::product() const { - // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.product) - return _internal_product(); -} -inline void Message_ProductMessage::unsafe_arena_set_allocated_product( - ::proto::Message_ProductMessage_ProductSnapshot* product) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.product_); - } - _impl_.product_ = product; - if (product) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProductMessage.product) -} -inline ::proto::Message_ProductMessage_ProductSnapshot* Message_ProductMessage::release_product() { - _impl_._has_bits_[0] &= ~0x00000008u; - ::proto::Message_ProductMessage_ProductSnapshot* temp = _impl_.product_; - _impl_.product_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_ProductMessage_ProductSnapshot* Message_ProductMessage::unsafe_arena_release_product() { - // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.product) - _impl_._has_bits_[0] &= ~0x00000008u; - ::proto::Message_ProductMessage_ProductSnapshot* temp = _impl_.product_; - _impl_.product_ = nullptr; - return temp; -} -inline ::proto::Message_ProductMessage_ProductSnapshot* Message_ProductMessage::_internal_mutable_product() { - _impl_._has_bits_[0] |= 0x00000008u; - if (_impl_.product_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_ProductMessage_ProductSnapshot>(GetArenaForAllocation()); - _impl_.product_ = p; - } - return _impl_.product_; -} -inline ::proto::Message_ProductMessage_ProductSnapshot* Message_ProductMessage::mutable_product() { - ::proto::Message_ProductMessage_ProductSnapshot* _msg = _internal_mutable_product(); - // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.product) - return _msg; -} -inline void Message_ProductMessage::set_allocated_product(::proto::Message_ProductMessage_ProductSnapshot* product) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.product_; - } - if (product) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(product); - if (message_arena != submessage_arena) { - product = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, product, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.product_ = product; - // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.product) -} - -// optional string businessOwnerJid = 2; -inline bool Message_ProductMessage::_internal_has_businessownerjid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_ProductMessage::has_businessownerjid() const { - return _internal_has_businessownerjid(); -} -inline void Message_ProductMessage::clear_businessownerjid() { - _impl_.businessownerjid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_ProductMessage::businessownerjid() const { - // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.businessOwnerJid) - return _internal_businessownerjid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ProductMessage::set_businessownerjid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.businessownerjid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.businessOwnerJid) -} -inline std::string* Message_ProductMessage::mutable_businessownerjid() { - std::string* _s = _internal_mutable_businessownerjid(); - // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.businessOwnerJid) - return _s; -} -inline const std::string& Message_ProductMessage::_internal_businessownerjid() const { - return _impl_.businessownerjid_.Get(); -} -inline void Message_ProductMessage::_internal_set_businessownerjid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.businessownerjid_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ProductMessage::_internal_mutable_businessownerjid() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.businessownerjid_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ProductMessage::release_businessownerjid() { - // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.businessOwnerJid) - if (!_internal_has_businessownerjid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.businessownerjid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.businessownerjid_.IsDefault()) { - _impl_.businessownerjid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ProductMessage::set_allocated_businessownerjid(std::string* businessownerjid) { - if (businessownerjid != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.businessownerjid_.SetAllocated(businessownerjid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.businessownerjid_.IsDefault()) { - _impl_.businessownerjid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.businessOwnerJid) -} - -// optional .proto.Message.ProductMessage.CatalogSnapshot catalog = 4; -inline bool Message_ProductMessage::_internal_has_catalog() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - PROTOBUF_ASSUME(!value || _impl_.catalog_ != nullptr); - return value; -} -inline bool Message_ProductMessage::has_catalog() const { - return _internal_has_catalog(); -} -inline void Message_ProductMessage::clear_catalog() { - if (_impl_.catalog_ != nullptr) _impl_.catalog_->Clear(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const ::proto::Message_ProductMessage_CatalogSnapshot& Message_ProductMessage::_internal_catalog() const { - const ::proto::Message_ProductMessage_CatalogSnapshot* p = _impl_.catalog_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_ProductMessage_CatalogSnapshot_default_instance_); -} -inline const ::proto::Message_ProductMessage_CatalogSnapshot& Message_ProductMessage::catalog() const { - // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.catalog) - return _internal_catalog(); -} -inline void Message_ProductMessage::unsafe_arena_set_allocated_catalog( - ::proto::Message_ProductMessage_CatalogSnapshot* catalog) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.catalog_); - } - _impl_.catalog_ = catalog; - if (catalog) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProductMessage.catalog) -} -inline ::proto::Message_ProductMessage_CatalogSnapshot* Message_ProductMessage::release_catalog() { - _impl_._has_bits_[0] &= ~0x00000010u; - ::proto::Message_ProductMessage_CatalogSnapshot* temp = _impl_.catalog_; - _impl_.catalog_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_ProductMessage_CatalogSnapshot* Message_ProductMessage::unsafe_arena_release_catalog() { - // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.catalog) - _impl_._has_bits_[0] &= ~0x00000010u; - ::proto::Message_ProductMessage_CatalogSnapshot* temp = _impl_.catalog_; - _impl_.catalog_ = nullptr; - return temp; -} -inline ::proto::Message_ProductMessage_CatalogSnapshot* Message_ProductMessage::_internal_mutable_catalog() { - _impl_._has_bits_[0] |= 0x00000010u; - if (_impl_.catalog_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_ProductMessage_CatalogSnapshot>(GetArenaForAllocation()); - _impl_.catalog_ = p; - } - return _impl_.catalog_; -} -inline ::proto::Message_ProductMessage_CatalogSnapshot* Message_ProductMessage::mutable_catalog() { - ::proto::Message_ProductMessage_CatalogSnapshot* _msg = _internal_mutable_catalog(); - // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.catalog) - return _msg; -} -inline void Message_ProductMessage::set_allocated_catalog(::proto::Message_ProductMessage_CatalogSnapshot* catalog) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.catalog_; - } - if (catalog) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(catalog); - if (message_arena != submessage_arena) { - catalog = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, catalog, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.catalog_ = catalog; - // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.catalog) -} - -// optional string body = 5; -inline bool Message_ProductMessage::_internal_has_body() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_ProductMessage::has_body() const { - return _internal_has_body(); -} -inline void Message_ProductMessage::clear_body() { - _impl_.body_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_ProductMessage::body() const { - // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.body) - return _internal_body(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ProductMessage::set_body(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.body_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.body) -} -inline std::string* Message_ProductMessage::mutable_body() { - std::string* _s = _internal_mutable_body(); - // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.body) - return _s; -} -inline const std::string& Message_ProductMessage::_internal_body() const { - return _impl_.body_.Get(); -} -inline void Message_ProductMessage::_internal_set_body(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.body_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ProductMessage::_internal_mutable_body() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.body_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ProductMessage::release_body() { - // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.body) - if (!_internal_has_body()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.body_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.body_.IsDefault()) { - _impl_.body_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ProductMessage::set_allocated_body(std::string* body) { - if (body != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.body_.SetAllocated(body, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.body_.IsDefault()) { - _impl_.body_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.body) -} - -// optional string footer = 6; -inline bool Message_ProductMessage::_internal_has_footer() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool Message_ProductMessage::has_footer() const { - return _internal_has_footer(); -} -inline void Message_ProductMessage::clear_footer() { - _impl_.footer_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& Message_ProductMessage::footer() const { - // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.footer) - return _internal_footer(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ProductMessage::set_footer(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.footer_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.footer) -} -inline std::string* Message_ProductMessage::mutable_footer() { - std::string* _s = _internal_mutable_footer(); - // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.footer) - return _s; -} -inline const std::string& Message_ProductMessage::_internal_footer() const { - return _impl_.footer_.Get(); -} -inline void Message_ProductMessage::_internal_set_footer(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.footer_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ProductMessage::_internal_mutable_footer() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.footer_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ProductMessage::release_footer() { - // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.footer) - if (!_internal_has_footer()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.footer_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.footer_.IsDefault()) { - _impl_.footer_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ProductMessage::set_allocated_footer(std::string* footer) { - if (footer != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.footer_.SetAllocated(footer, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.footer_.IsDefault()) { - _impl_.footer_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.footer) -} - -// optional .proto.ContextInfo contextInfo = 17; -inline bool Message_ProductMessage::_internal_has_contextinfo() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); - return value; -} -inline bool Message_ProductMessage::has_contextinfo() const { - return _internal_has_contextinfo(); -} -inline void Message_ProductMessage::clear_contextinfo() { - if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline const ::proto::ContextInfo& Message_ProductMessage::_internal_contextinfo() const { - const ::proto::ContextInfo* p = _impl_.contextinfo_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ContextInfo_default_instance_); -} -inline const ::proto::ContextInfo& Message_ProductMessage::contextinfo() const { - // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.contextInfo) - return _internal_contextinfo(); -} -inline void Message_ProductMessage::unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); - } - _impl_.contextinfo_ = contextinfo; - if (contextinfo) { - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProductMessage.contextInfo) -} -inline ::proto::ContextInfo* Message_ProductMessage::release_contextinfo() { - _impl_._has_bits_[0] &= ~0x00000020u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ContextInfo* Message_ProductMessage::unsafe_arena_release_contextinfo() { - // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.contextInfo) - _impl_._has_bits_[0] &= ~0x00000020u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; - return temp; -} -inline ::proto::ContextInfo* Message_ProductMessage::_internal_mutable_contextinfo() { - _impl_._has_bits_[0] |= 0x00000020u; - if (_impl_.contextinfo_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); - _impl_.contextinfo_ = p; - } - return _impl_.contextinfo_; -} -inline ::proto::ContextInfo* Message_ProductMessage::mutable_contextinfo() { - ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); - // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.contextInfo) - return _msg; -} -inline void Message_ProductMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.contextinfo_; - } - if (contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); - if (message_arena != submessage_arena) { - contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, contextinfo, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - _impl_.contextinfo_ = contextinfo; - // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.contextInfo) -} - -// ------------------------------------------------------------------- - -// Message_ProtocolMessage - -// optional .proto.MessageKey key = 1; -inline bool Message_ProtocolMessage::_internal_has_key() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr); - return value; -} -inline bool Message_ProtocolMessage::has_key() const { - return _internal_has_key(); -} -inline void Message_ProtocolMessage::clear_key() { - if (_impl_.key_ != nullptr) _impl_.key_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::MessageKey& Message_ProtocolMessage::_internal_key() const { - const ::proto::MessageKey* p = _impl_.key_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_MessageKey_default_instance_); -} -inline const ::proto::MessageKey& Message_ProtocolMessage::key() const { - // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.key) - return _internal_key(); -} -inline void Message_ProtocolMessage::unsafe_arena_set_allocated_key( - ::proto::MessageKey* key) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_); - } - _impl_.key_ = key; - if (key) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.key) -} -inline ::proto::MessageKey* Message_ProtocolMessage::release_key() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::MessageKey* temp = _impl_.key_; - _impl_.key_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::MessageKey* Message_ProtocolMessage::unsafe_arena_release_key() { - // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.key) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::MessageKey* temp = _impl_.key_; - _impl_.key_ = nullptr; - return temp; -} -inline ::proto::MessageKey* Message_ProtocolMessage::_internal_mutable_key() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.key_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation()); - _impl_.key_ = p; - } - return _impl_.key_; -} -inline ::proto::MessageKey* Message_ProtocolMessage::mutable_key() { - ::proto::MessageKey* _msg = _internal_mutable_key(); - // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.key) - return _msg; -} -inline void Message_ProtocolMessage::set_allocated_key(::proto::MessageKey* key) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.key_; - } - if (key) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key); - if (message_arena != submessage_arena) { - key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, key, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.key_ = key; - // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.key) -} - -// optional .proto.Message.ProtocolMessage.Type type = 2; -inline bool Message_ProtocolMessage::_internal_has_type() const { - bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; - return value; -} -inline bool Message_ProtocolMessage::has_type() const { - return _internal_has_type(); -} -inline void Message_ProtocolMessage::clear_type() { - _impl_.type_ = 0; - _impl_._has_bits_[0] &= ~0x00000200u; -} -inline ::proto::Message_ProtocolMessage_Type Message_ProtocolMessage::_internal_type() const { - return static_cast< ::proto::Message_ProtocolMessage_Type >(_impl_.type_); -} -inline ::proto::Message_ProtocolMessage_Type Message_ProtocolMessage::type() const { - // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.type) - return _internal_type(); -} -inline void Message_ProtocolMessage::_internal_set_type(::proto::Message_ProtocolMessage_Type value) { - assert(::proto::Message_ProtocolMessage_Type_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.type_ = value; -} -inline void Message_ProtocolMessage::set_type(::proto::Message_ProtocolMessage_Type value) { - _internal_set_type(value); - // @@protoc_insertion_point(field_set:proto.Message.ProtocolMessage.type) -} - -// optional uint32 ephemeralExpiration = 4; -inline bool Message_ProtocolMessage::_internal_has_ephemeralexpiration() const { - bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; - return value; -} -inline bool Message_ProtocolMessage::has_ephemeralexpiration() const { - return _internal_has_ephemeralexpiration(); -} -inline void Message_ProtocolMessage::clear_ephemeralexpiration() { - _impl_.ephemeralexpiration_ = 0u; - _impl_._has_bits_[0] &= ~0x00000400u; -} -inline uint32_t Message_ProtocolMessage::_internal_ephemeralexpiration() const { - return _impl_.ephemeralexpiration_; -} -inline uint32_t Message_ProtocolMessage::ephemeralexpiration() const { - // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.ephemeralExpiration) - return _internal_ephemeralexpiration(); -} -inline void Message_ProtocolMessage::_internal_set_ephemeralexpiration(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000400u; - _impl_.ephemeralexpiration_ = value; -} -inline void Message_ProtocolMessage::set_ephemeralexpiration(uint32_t value) { - _internal_set_ephemeralexpiration(value); - // @@protoc_insertion_point(field_set:proto.Message.ProtocolMessage.ephemeralExpiration) -} - -// optional int64 ephemeralSettingTimestamp = 5; -inline bool Message_ProtocolMessage::_internal_has_ephemeralsettingtimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; - return value; -} -inline bool Message_ProtocolMessage::has_ephemeralsettingtimestamp() const { - return _internal_has_ephemeralsettingtimestamp(); -} -inline void Message_ProtocolMessage::clear_ephemeralsettingtimestamp() { - _impl_.ephemeralsettingtimestamp_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000800u; -} -inline int64_t Message_ProtocolMessage::_internal_ephemeralsettingtimestamp() const { - return _impl_.ephemeralsettingtimestamp_; -} -inline int64_t Message_ProtocolMessage::ephemeralsettingtimestamp() const { - // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.ephemeralSettingTimestamp) - return _internal_ephemeralsettingtimestamp(); -} -inline void Message_ProtocolMessage::_internal_set_ephemeralsettingtimestamp(int64_t value) { - _impl_._has_bits_[0] |= 0x00000800u; - _impl_.ephemeralsettingtimestamp_ = value; -} -inline void Message_ProtocolMessage::set_ephemeralsettingtimestamp(int64_t value) { - _internal_set_ephemeralsettingtimestamp(value); - // @@protoc_insertion_point(field_set:proto.Message.ProtocolMessage.ephemeralSettingTimestamp) -} - -// optional .proto.Message.HistorySyncNotification historySyncNotification = 6; -inline bool Message_ProtocolMessage::_internal_has_historysyncnotification() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.historysyncnotification_ != nullptr); - return value; -} -inline bool Message_ProtocolMessage::has_historysyncnotification() const { - return _internal_has_historysyncnotification(); -} -inline void Message_ProtocolMessage::clear_historysyncnotification() { - if (_impl_.historysyncnotification_ != nullptr) _impl_.historysyncnotification_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::Message_HistorySyncNotification& Message_ProtocolMessage::_internal_historysyncnotification() const { - const ::proto::Message_HistorySyncNotification* p = _impl_.historysyncnotification_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_HistorySyncNotification_default_instance_); -} -inline const ::proto::Message_HistorySyncNotification& Message_ProtocolMessage::historysyncnotification() const { - // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.historySyncNotification) - return _internal_historysyncnotification(); -} -inline void Message_ProtocolMessage::unsafe_arena_set_allocated_historysyncnotification( - ::proto::Message_HistorySyncNotification* historysyncnotification) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.historysyncnotification_); - } - _impl_.historysyncnotification_ = historysyncnotification; - if (historysyncnotification) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.historySyncNotification) -} -inline ::proto::Message_HistorySyncNotification* Message_ProtocolMessage::release_historysyncnotification() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::Message_HistorySyncNotification* temp = _impl_.historysyncnotification_; - _impl_.historysyncnotification_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_HistorySyncNotification* Message_ProtocolMessage::unsafe_arena_release_historysyncnotification() { - // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.historySyncNotification) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::Message_HistorySyncNotification* temp = _impl_.historysyncnotification_; - _impl_.historysyncnotification_ = nullptr; - return temp; -} -inline ::proto::Message_HistorySyncNotification* Message_ProtocolMessage::_internal_mutable_historysyncnotification() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.historysyncnotification_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_HistorySyncNotification>(GetArenaForAllocation()); - _impl_.historysyncnotification_ = p; - } - return _impl_.historysyncnotification_; -} -inline ::proto::Message_HistorySyncNotification* Message_ProtocolMessage::mutable_historysyncnotification() { - ::proto::Message_HistorySyncNotification* _msg = _internal_mutable_historysyncnotification(); - // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.historySyncNotification) - return _msg; -} -inline void Message_ProtocolMessage::set_allocated_historysyncnotification(::proto::Message_HistorySyncNotification* historysyncnotification) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.historysyncnotification_; - } - if (historysyncnotification) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(historysyncnotification); - if (message_arena != submessage_arena) { - historysyncnotification = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, historysyncnotification, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.historysyncnotification_ = historysyncnotification; - // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.historySyncNotification) -} - -// optional .proto.Message.AppStateSyncKeyShare appStateSyncKeyShare = 7; -inline bool Message_ProtocolMessage::_internal_has_appstatesynckeyshare() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - PROTOBUF_ASSUME(!value || _impl_.appstatesynckeyshare_ != nullptr); - return value; -} -inline bool Message_ProtocolMessage::has_appstatesynckeyshare() const { - return _internal_has_appstatesynckeyshare(); -} -inline void Message_ProtocolMessage::clear_appstatesynckeyshare() { - if (_impl_.appstatesynckeyshare_ != nullptr) _impl_.appstatesynckeyshare_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const ::proto::Message_AppStateSyncKeyShare& Message_ProtocolMessage::_internal_appstatesynckeyshare() const { - const ::proto::Message_AppStateSyncKeyShare* p = _impl_.appstatesynckeyshare_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_AppStateSyncKeyShare_default_instance_); -} -inline const ::proto::Message_AppStateSyncKeyShare& Message_ProtocolMessage::appstatesynckeyshare() const { - // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.appStateSyncKeyShare) - return _internal_appstatesynckeyshare(); -} -inline void Message_ProtocolMessage::unsafe_arena_set_allocated_appstatesynckeyshare( - ::proto::Message_AppStateSyncKeyShare* appstatesynckeyshare) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.appstatesynckeyshare_); - } - _impl_.appstatesynckeyshare_ = appstatesynckeyshare; - if (appstatesynckeyshare) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.appStateSyncKeyShare) -} -inline ::proto::Message_AppStateSyncKeyShare* Message_ProtocolMessage::release_appstatesynckeyshare() { - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::Message_AppStateSyncKeyShare* temp = _impl_.appstatesynckeyshare_; - _impl_.appstatesynckeyshare_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_AppStateSyncKeyShare* Message_ProtocolMessage::unsafe_arena_release_appstatesynckeyshare() { - // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.appStateSyncKeyShare) - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::Message_AppStateSyncKeyShare* temp = _impl_.appstatesynckeyshare_; - _impl_.appstatesynckeyshare_ = nullptr; - return temp; -} -inline ::proto::Message_AppStateSyncKeyShare* Message_ProtocolMessage::_internal_mutable_appstatesynckeyshare() { - _impl_._has_bits_[0] |= 0x00000004u; - if (_impl_.appstatesynckeyshare_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_AppStateSyncKeyShare>(GetArenaForAllocation()); - _impl_.appstatesynckeyshare_ = p; - } - return _impl_.appstatesynckeyshare_; -} -inline ::proto::Message_AppStateSyncKeyShare* Message_ProtocolMessage::mutable_appstatesynckeyshare() { - ::proto::Message_AppStateSyncKeyShare* _msg = _internal_mutable_appstatesynckeyshare(); - // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.appStateSyncKeyShare) - return _msg; -} -inline void Message_ProtocolMessage::set_allocated_appstatesynckeyshare(::proto::Message_AppStateSyncKeyShare* appstatesynckeyshare) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.appstatesynckeyshare_; - } - if (appstatesynckeyshare) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(appstatesynckeyshare); - if (message_arena != submessage_arena) { - appstatesynckeyshare = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, appstatesynckeyshare, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.appstatesynckeyshare_ = appstatesynckeyshare; - // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.appStateSyncKeyShare) -} - -// optional .proto.Message.AppStateSyncKeyRequest appStateSyncKeyRequest = 8; -inline bool Message_ProtocolMessage::_internal_has_appstatesynckeyrequest() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - PROTOBUF_ASSUME(!value || _impl_.appstatesynckeyrequest_ != nullptr); - return value; -} -inline bool Message_ProtocolMessage::has_appstatesynckeyrequest() const { - return _internal_has_appstatesynckeyrequest(); -} -inline void Message_ProtocolMessage::clear_appstatesynckeyrequest() { - if (_impl_.appstatesynckeyrequest_ != nullptr) _impl_.appstatesynckeyrequest_->Clear(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const ::proto::Message_AppStateSyncKeyRequest& Message_ProtocolMessage::_internal_appstatesynckeyrequest() const { - const ::proto::Message_AppStateSyncKeyRequest* p = _impl_.appstatesynckeyrequest_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_AppStateSyncKeyRequest_default_instance_); -} -inline const ::proto::Message_AppStateSyncKeyRequest& Message_ProtocolMessage::appstatesynckeyrequest() const { - // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.appStateSyncKeyRequest) - return _internal_appstatesynckeyrequest(); -} -inline void Message_ProtocolMessage::unsafe_arena_set_allocated_appstatesynckeyrequest( - ::proto::Message_AppStateSyncKeyRequest* appstatesynckeyrequest) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.appstatesynckeyrequest_); - } - _impl_.appstatesynckeyrequest_ = appstatesynckeyrequest; - if (appstatesynckeyrequest) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.appStateSyncKeyRequest) -} -inline ::proto::Message_AppStateSyncKeyRequest* Message_ProtocolMessage::release_appstatesynckeyrequest() { - _impl_._has_bits_[0] &= ~0x00000008u; - ::proto::Message_AppStateSyncKeyRequest* temp = _impl_.appstatesynckeyrequest_; - _impl_.appstatesynckeyrequest_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_AppStateSyncKeyRequest* Message_ProtocolMessage::unsafe_arena_release_appstatesynckeyrequest() { - // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.appStateSyncKeyRequest) - _impl_._has_bits_[0] &= ~0x00000008u; - ::proto::Message_AppStateSyncKeyRequest* temp = _impl_.appstatesynckeyrequest_; - _impl_.appstatesynckeyrequest_ = nullptr; - return temp; -} -inline ::proto::Message_AppStateSyncKeyRequest* Message_ProtocolMessage::_internal_mutable_appstatesynckeyrequest() { - _impl_._has_bits_[0] |= 0x00000008u; - if (_impl_.appstatesynckeyrequest_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_AppStateSyncKeyRequest>(GetArenaForAllocation()); - _impl_.appstatesynckeyrequest_ = p; - } - return _impl_.appstatesynckeyrequest_; -} -inline ::proto::Message_AppStateSyncKeyRequest* Message_ProtocolMessage::mutable_appstatesynckeyrequest() { - ::proto::Message_AppStateSyncKeyRequest* _msg = _internal_mutable_appstatesynckeyrequest(); - // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.appStateSyncKeyRequest) - return _msg; -} -inline void Message_ProtocolMessage::set_allocated_appstatesynckeyrequest(::proto::Message_AppStateSyncKeyRequest* appstatesynckeyrequest) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.appstatesynckeyrequest_; - } - if (appstatesynckeyrequest) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(appstatesynckeyrequest); - if (message_arena != submessage_arena) { - appstatesynckeyrequest = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, appstatesynckeyrequest, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.appstatesynckeyrequest_ = appstatesynckeyrequest; - // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.appStateSyncKeyRequest) -} - -// optional .proto.Message.InitialSecurityNotificationSettingSync initialSecurityNotificationSettingSync = 9; -inline bool Message_ProtocolMessage::_internal_has_initialsecuritynotificationsettingsync() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - PROTOBUF_ASSUME(!value || _impl_.initialsecuritynotificationsettingsync_ != nullptr); - return value; -} -inline bool Message_ProtocolMessage::has_initialsecuritynotificationsettingsync() const { - return _internal_has_initialsecuritynotificationsettingsync(); -} -inline void Message_ProtocolMessage::clear_initialsecuritynotificationsettingsync() { - if (_impl_.initialsecuritynotificationsettingsync_ != nullptr) _impl_.initialsecuritynotificationsettingsync_->Clear(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const ::proto::Message_InitialSecurityNotificationSettingSync& Message_ProtocolMessage::_internal_initialsecuritynotificationsettingsync() const { - const ::proto::Message_InitialSecurityNotificationSettingSync* p = _impl_.initialsecuritynotificationsettingsync_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_InitialSecurityNotificationSettingSync_default_instance_); -} -inline const ::proto::Message_InitialSecurityNotificationSettingSync& Message_ProtocolMessage::initialsecuritynotificationsettingsync() const { - // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.initialSecurityNotificationSettingSync) - return _internal_initialsecuritynotificationsettingsync(); -} -inline void Message_ProtocolMessage::unsafe_arena_set_allocated_initialsecuritynotificationsettingsync( - ::proto::Message_InitialSecurityNotificationSettingSync* initialsecuritynotificationsettingsync) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.initialsecuritynotificationsettingsync_); - } - _impl_.initialsecuritynotificationsettingsync_ = initialsecuritynotificationsettingsync; - if (initialsecuritynotificationsettingsync) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.initialSecurityNotificationSettingSync) -} -inline ::proto::Message_InitialSecurityNotificationSettingSync* Message_ProtocolMessage::release_initialsecuritynotificationsettingsync() { - _impl_._has_bits_[0] &= ~0x00000010u; - ::proto::Message_InitialSecurityNotificationSettingSync* temp = _impl_.initialsecuritynotificationsettingsync_; - _impl_.initialsecuritynotificationsettingsync_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_InitialSecurityNotificationSettingSync* Message_ProtocolMessage::unsafe_arena_release_initialsecuritynotificationsettingsync() { - // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.initialSecurityNotificationSettingSync) - _impl_._has_bits_[0] &= ~0x00000010u; - ::proto::Message_InitialSecurityNotificationSettingSync* temp = _impl_.initialsecuritynotificationsettingsync_; - _impl_.initialsecuritynotificationsettingsync_ = nullptr; - return temp; -} -inline ::proto::Message_InitialSecurityNotificationSettingSync* Message_ProtocolMessage::_internal_mutable_initialsecuritynotificationsettingsync() { - _impl_._has_bits_[0] |= 0x00000010u; - if (_impl_.initialsecuritynotificationsettingsync_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_InitialSecurityNotificationSettingSync>(GetArenaForAllocation()); - _impl_.initialsecuritynotificationsettingsync_ = p; - } - return _impl_.initialsecuritynotificationsettingsync_; -} -inline ::proto::Message_InitialSecurityNotificationSettingSync* Message_ProtocolMessage::mutable_initialsecuritynotificationsettingsync() { - ::proto::Message_InitialSecurityNotificationSettingSync* _msg = _internal_mutable_initialsecuritynotificationsettingsync(); - // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.initialSecurityNotificationSettingSync) - return _msg; -} -inline void Message_ProtocolMessage::set_allocated_initialsecuritynotificationsettingsync(::proto::Message_InitialSecurityNotificationSettingSync* initialsecuritynotificationsettingsync) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.initialsecuritynotificationsettingsync_; - } - if (initialsecuritynotificationsettingsync) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(initialsecuritynotificationsettingsync); - if (message_arena != submessage_arena) { - initialsecuritynotificationsettingsync = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, initialsecuritynotificationsettingsync, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.initialsecuritynotificationsettingsync_ = initialsecuritynotificationsettingsync; - // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.initialSecurityNotificationSettingSync) -} - -// optional .proto.Message.AppStateFatalExceptionNotification appStateFatalExceptionNotification = 10; -inline bool Message_ProtocolMessage::_internal_has_appstatefatalexceptionnotification() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - PROTOBUF_ASSUME(!value || _impl_.appstatefatalexceptionnotification_ != nullptr); - return value; -} -inline bool Message_ProtocolMessage::has_appstatefatalexceptionnotification() const { - return _internal_has_appstatefatalexceptionnotification(); -} -inline void Message_ProtocolMessage::clear_appstatefatalexceptionnotification() { - if (_impl_.appstatefatalexceptionnotification_ != nullptr) _impl_.appstatefatalexceptionnotification_->Clear(); - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline const ::proto::Message_AppStateFatalExceptionNotification& Message_ProtocolMessage::_internal_appstatefatalexceptionnotification() const { - const ::proto::Message_AppStateFatalExceptionNotification* p = _impl_.appstatefatalexceptionnotification_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_AppStateFatalExceptionNotification_default_instance_); -} -inline const ::proto::Message_AppStateFatalExceptionNotification& Message_ProtocolMessage::appstatefatalexceptionnotification() const { - // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.appStateFatalExceptionNotification) - return _internal_appstatefatalexceptionnotification(); -} -inline void Message_ProtocolMessage::unsafe_arena_set_allocated_appstatefatalexceptionnotification( - ::proto::Message_AppStateFatalExceptionNotification* appstatefatalexceptionnotification) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.appstatefatalexceptionnotification_); - } - _impl_.appstatefatalexceptionnotification_ = appstatefatalexceptionnotification; - if (appstatefatalexceptionnotification) { - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.appStateFatalExceptionNotification) -} -inline ::proto::Message_AppStateFatalExceptionNotification* Message_ProtocolMessage::release_appstatefatalexceptionnotification() { - _impl_._has_bits_[0] &= ~0x00000020u; - ::proto::Message_AppStateFatalExceptionNotification* temp = _impl_.appstatefatalexceptionnotification_; - _impl_.appstatefatalexceptionnotification_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_AppStateFatalExceptionNotification* Message_ProtocolMessage::unsafe_arena_release_appstatefatalexceptionnotification() { - // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.appStateFatalExceptionNotification) - _impl_._has_bits_[0] &= ~0x00000020u; - ::proto::Message_AppStateFatalExceptionNotification* temp = _impl_.appstatefatalexceptionnotification_; - _impl_.appstatefatalexceptionnotification_ = nullptr; - return temp; -} -inline ::proto::Message_AppStateFatalExceptionNotification* Message_ProtocolMessage::_internal_mutable_appstatefatalexceptionnotification() { - _impl_._has_bits_[0] |= 0x00000020u; - if (_impl_.appstatefatalexceptionnotification_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_AppStateFatalExceptionNotification>(GetArenaForAllocation()); - _impl_.appstatefatalexceptionnotification_ = p; - } - return _impl_.appstatefatalexceptionnotification_; -} -inline ::proto::Message_AppStateFatalExceptionNotification* Message_ProtocolMessage::mutable_appstatefatalexceptionnotification() { - ::proto::Message_AppStateFatalExceptionNotification* _msg = _internal_mutable_appstatefatalexceptionnotification(); - // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.appStateFatalExceptionNotification) - return _msg; -} -inline void Message_ProtocolMessage::set_allocated_appstatefatalexceptionnotification(::proto::Message_AppStateFatalExceptionNotification* appstatefatalexceptionnotification) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.appstatefatalexceptionnotification_; - } - if (appstatefatalexceptionnotification) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(appstatefatalexceptionnotification); - if (message_arena != submessage_arena) { - appstatefatalexceptionnotification = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, appstatefatalexceptionnotification, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - _impl_.appstatefatalexceptionnotification_ = appstatefatalexceptionnotification; - // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.appStateFatalExceptionNotification) -} - -// optional .proto.DisappearingMode disappearingMode = 11; -inline bool Message_ProtocolMessage::_internal_has_disappearingmode() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - PROTOBUF_ASSUME(!value || _impl_.disappearingmode_ != nullptr); - return value; -} -inline bool Message_ProtocolMessage::has_disappearingmode() const { - return _internal_has_disappearingmode(); -} -inline void Message_ProtocolMessage::clear_disappearingmode() { - if (_impl_.disappearingmode_ != nullptr) _impl_.disappearingmode_->Clear(); - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline const ::proto::DisappearingMode& Message_ProtocolMessage::_internal_disappearingmode() const { - const ::proto::DisappearingMode* p = _impl_.disappearingmode_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_DisappearingMode_default_instance_); -} -inline const ::proto::DisappearingMode& Message_ProtocolMessage::disappearingmode() const { - // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.disappearingMode) - return _internal_disappearingmode(); -} -inline void Message_ProtocolMessage::unsafe_arena_set_allocated_disappearingmode( - ::proto::DisappearingMode* disappearingmode) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.disappearingmode_); - } - _impl_.disappearingmode_ = disappearingmode; - if (disappearingmode) { - _impl_._has_bits_[0] |= 0x00000040u; - } else { - _impl_._has_bits_[0] &= ~0x00000040u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.disappearingMode) -} -inline ::proto::DisappearingMode* Message_ProtocolMessage::release_disappearingmode() { - _impl_._has_bits_[0] &= ~0x00000040u; - ::proto::DisappearingMode* temp = _impl_.disappearingmode_; - _impl_.disappearingmode_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::DisappearingMode* Message_ProtocolMessage::unsafe_arena_release_disappearingmode() { - // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.disappearingMode) - _impl_._has_bits_[0] &= ~0x00000040u; - ::proto::DisappearingMode* temp = _impl_.disappearingmode_; - _impl_.disappearingmode_ = nullptr; - return temp; -} -inline ::proto::DisappearingMode* Message_ProtocolMessage::_internal_mutable_disappearingmode() { - _impl_._has_bits_[0] |= 0x00000040u; - if (_impl_.disappearingmode_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::DisappearingMode>(GetArenaForAllocation()); - _impl_.disappearingmode_ = p; - } - return _impl_.disappearingmode_; -} -inline ::proto::DisappearingMode* Message_ProtocolMessage::mutable_disappearingmode() { - ::proto::DisappearingMode* _msg = _internal_mutable_disappearingmode(); - // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.disappearingMode) - return _msg; -} -inline void Message_ProtocolMessage::set_allocated_disappearingmode(::proto::DisappearingMode* disappearingmode) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.disappearingmode_; - } - if (disappearingmode) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(disappearingmode); - if (message_arena != submessage_arena) { - disappearingmode = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, disappearingmode, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000040u; - } else { - _impl_._has_bits_[0] &= ~0x00000040u; - } - _impl_.disappearingmode_ = disappearingmode; - // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.disappearingMode) -} - -// optional .proto.Message.RequestMediaUploadMessage requestMediaUploadMessage = 12; -inline bool Message_ProtocolMessage::_internal_has_requestmediauploadmessage() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - PROTOBUF_ASSUME(!value || _impl_.requestmediauploadmessage_ != nullptr); - return value; -} -inline bool Message_ProtocolMessage::has_requestmediauploadmessage() const { - return _internal_has_requestmediauploadmessage(); -} -inline void Message_ProtocolMessage::clear_requestmediauploadmessage() { - if (_impl_.requestmediauploadmessage_ != nullptr) _impl_.requestmediauploadmessage_->Clear(); - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline const ::proto::Message_RequestMediaUploadMessage& Message_ProtocolMessage::_internal_requestmediauploadmessage() const { - const ::proto::Message_RequestMediaUploadMessage* p = _impl_.requestmediauploadmessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_RequestMediaUploadMessage_default_instance_); -} -inline const ::proto::Message_RequestMediaUploadMessage& Message_ProtocolMessage::requestmediauploadmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.requestMediaUploadMessage) - return _internal_requestmediauploadmessage(); -} -inline void Message_ProtocolMessage::unsafe_arena_set_allocated_requestmediauploadmessage( - ::proto::Message_RequestMediaUploadMessage* requestmediauploadmessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.requestmediauploadmessage_); - } - _impl_.requestmediauploadmessage_ = requestmediauploadmessage; - if (requestmediauploadmessage) { - _impl_._has_bits_[0] |= 0x00000080u; - } else { - _impl_._has_bits_[0] &= ~0x00000080u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.requestMediaUploadMessage) -} -inline ::proto::Message_RequestMediaUploadMessage* Message_ProtocolMessage::release_requestmediauploadmessage() { - _impl_._has_bits_[0] &= ~0x00000080u; - ::proto::Message_RequestMediaUploadMessage* temp = _impl_.requestmediauploadmessage_; - _impl_.requestmediauploadmessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_RequestMediaUploadMessage* Message_ProtocolMessage::unsafe_arena_release_requestmediauploadmessage() { - // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.requestMediaUploadMessage) - _impl_._has_bits_[0] &= ~0x00000080u; - ::proto::Message_RequestMediaUploadMessage* temp = _impl_.requestmediauploadmessage_; - _impl_.requestmediauploadmessage_ = nullptr; - return temp; -} -inline ::proto::Message_RequestMediaUploadMessage* Message_ProtocolMessage::_internal_mutable_requestmediauploadmessage() { - _impl_._has_bits_[0] |= 0x00000080u; - if (_impl_.requestmediauploadmessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_RequestMediaUploadMessage>(GetArenaForAllocation()); - _impl_.requestmediauploadmessage_ = p; - } - return _impl_.requestmediauploadmessage_; -} -inline ::proto::Message_RequestMediaUploadMessage* Message_ProtocolMessage::mutable_requestmediauploadmessage() { - ::proto::Message_RequestMediaUploadMessage* _msg = _internal_mutable_requestmediauploadmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.requestMediaUploadMessage) - return _msg; -} -inline void Message_ProtocolMessage::set_allocated_requestmediauploadmessage(::proto::Message_RequestMediaUploadMessage* requestmediauploadmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.requestmediauploadmessage_; - } - if (requestmediauploadmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(requestmediauploadmessage); - if (message_arena != submessage_arena) { - requestmediauploadmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, requestmediauploadmessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000080u; - } else { - _impl_._has_bits_[0] &= ~0x00000080u; - } - _impl_.requestmediauploadmessage_ = requestmediauploadmessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.requestMediaUploadMessage) -} - -// optional .proto.Message.RequestMediaUploadResponseMessage requestMediaUploadResponseMessage = 13; -inline bool Message_ProtocolMessage::_internal_has_requestmediauploadresponsemessage() const { - bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; - PROTOBUF_ASSUME(!value || _impl_.requestmediauploadresponsemessage_ != nullptr); - return value; -} -inline bool Message_ProtocolMessage::has_requestmediauploadresponsemessage() const { - return _internal_has_requestmediauploadresponsemessage(); -} -inline void Message_ProtocolMessage::clear_requestmediauploadresponsemessage() { - if (_impl_.requestmediauploadresponsemessage_ != nullptr) _impl_.requestmediauploadresponsemessage_->Clear(); - _impl_._has_bits_[0] &= ~0x00000100u; -} -inline const ::proto::Message_RequestMediaUploadResponseMessage& Message_ProtocolMessage::_internal_requestmediauploadresponsemessage() const { - const ::proto::Message_RequestMediaUploadResponseMessage* p = _impl_.requestmediauploadresponsemessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_RequestMediaUploadResponseMessage_default_instance_); -} -inline const ::proto::Message_RequestMediaUploadResponseMessage& Message_ProtocolMessage::requestmediauploadresponsemessage() const { - // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.requestMediaUploadResponseMessage) - return _internal_requestmediauploadresponsemessage(); -} -inline void Message_ProtocolMessage::unsafe_arena_set_allocated_requestmediauploadresponsemessage( - ::proto::Message_RequestMediaUploadResponseMessage* requestmediauploadresponsemessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.requestmediauploadresponsemessage_); - } - _impl_.requestmediauploadresponsemessage_ = requestmediauploadresponsemessage; - if (requestmediauploadresponsemessage) { - _impl_._has_bits_[0] |= 0x00000100u; - } else { - _impl_._has_bits_[0] &= ~0x00000100u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.requestMediaUploadResponseMessage) -} -inline ::proto::Message_RequestMediaUploadResponseMessage* Message_ProtocolMessage::release_requestmediauploadresponsemessage() { - _impl_._has_bits_[0] &= ~0x00000100u; - ::proto::Message_RequestMediaUploadResponseMessage* temp = _impl_.requestmediauploadresponsemessage_; - _impl_.requestmediauploadresponsemessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_RequestMediaUploadResponseMessage* Message_ProtocolMessage::unsafe_arena_release_requestmediauploadresponsemessage() { - // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.requestMediaUploadResponseMessage) - _impl_._has_bits_[0] &= ~0x00000100u; - ::proto::Message_RequestMediaUploadResponseMessage* temp = _impl_.requestmediauploadresponsemessage_; - _impl_.requestmediauploadresponsemessage_ = nullptr; - return temp; -} -inline ::proto::Message_RequestMediaUploadResponseMessage* Message_ProtocolMessage::_internal_mutable_requestmediauploadresponsemessage() { - _impl_._has_bits_[0] |= 0x00000100u; - if (_impl_.requestmediauploadresponsemessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_RequestMediaUploadResponseMessage>(GetArenaForAllocation()); - _impl_.requestmediauploadresponsemessage_ = p; - } - return _impl_.requestmediauploadresponsemessage_; -} -inline ::proto::Message_RequestMediaUploadResponseMessage* Message_ProtocolMessage::mutable_requestmediauploadresponsemessage() { - ::proto::Message_RequestMediaUploadResponseMessage* _msg = _internal_mutable_requestmediauploadresponsemessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.requestMediaUploadResponseMessage) - return _msg; -} -inline void Message_ProtocolMessage::set_allocated_requestmediauploadresponsemessage(::proto::Message_RequestMediaUploadResponseMessage* requestmediauploadresponsemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.requestmediauploadresponsemessage_; - } - if (requestmediauploadresponsemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(requestmediauploadresponsemessage); - if (message_arena != submessage_arena) { - requestmediauploadresponsemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, requestmediauploadresponsemessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000100u; - } else { - _impl_._has_bits_[0] &= ~0x00000100u; - } - _impl_.requestmediauploadresponsemessage_ = requestmediauploadresponsemessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.requestMediaUploadResponseMessage) -} - -// ------------------------------------------------------------------- - -// Message_ReactionMessage - -// optional .proto.MessageKey key = 1; -inline bool Message_ReactionMessage::_internal_has_key() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr); - return value; -} -inline bool Message_ReactionMessage::has_key() const { - return _internal_has_key(); -} -inline void Message_ReactionMessage::clear_key() { - if (_impl_.key_ != nullptr) _impl_.key_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const ::proto::MessageKey& Message_ReactionMessage::_internal_key() const { - const ::proto::MessageKey* p = _impl_.key_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_MessageKey_default_instance_); -} -inline const ::proto::MessageKey& Message_ReactionMessage::key() const { - // @@protoc_insertion_point(field_get:proto.Message.ReactionMessage.key) - return _internal_key(); -} -inline void Message_ReactionMessage::unsafe_arena_set_allocated_key( - ::proto::MessageKey* key) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_); - } - _impl_.key_ = key; - if (key) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ReactionMessage.key) -} -inline ::proto::MessageKey* Message_ReactionMessage::release_key() { - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::MessageKey* temp = _impl_.key_; - _impl_.key_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::MessageKey* Message_ReactionMessage::unsafe_arena_release_key() { - // @@protoc_insertion_point(field_release:proto.Message.ReactionMessage.key) - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::MessageKey* temp = _impl_.key_; - _impl_.key_ = nullptr; - return temp; -} -inline ::proto::MessageKey* Message_ReactionMessage::_internal_mutable_key() { - _impl_._has_bits_[0] |= 0x00000004u; - if (_impl_.key_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation()); - _impl_.key_ = p; - } - return _impl_.key_; -} -inline ::proto::MessageKey* Message_ReactionMessage::mutable_key() { - ::proto::MessageKey* _msg = _internal_mutable_key(); - // @@protoc_insertion_point(field_mutable:proto.Message.ReactionMessage.key) - return _msg; -} -inline void Message_ReactionMessage::set_allocated_key(::proto::MessageKey* key) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.key_; - } - if (key) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key); - if (message_arena != submessage_arena) { - key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, key, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.key_ = key; - // @@protoc_insertion_point(field_set_allocated:proto.Message.ReactionMessage.key) -} - -// optional string text = 2; -inline bool Message_ReactionMessage::_internal_has_text() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_ReactionMessage::has_text() const { - return _internal_has_text(); -} -inline void Message_ReactionMessage::clear_text() { - _impl_.text_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_ReactionMessage::text() const { - // @@protoc_insertion_point(field_get:proto.Message.ReactionMessage.text) - return _internal_text(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ReactionMessage::set_text(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.text_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ReactionMessage.text) -} -inline std::string* Message_ReactionMessage::mutable_text() { - std::string* _s = _internal_mutable_text(); - // @@protoc_insertion_point(field_mutable:proto.Message.ReactionMessage.text) - return _s; -} -inline const std::string& Message_ReactionMessage::_internal_text() const { - return _impl_.text_.Get(); -} -inline void Message_ReactionMessage::_internal_set_text(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.text_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ReactionMessage::_internal_mutable_text() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.text_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ReactionMessage::release_text() { - // @@protoc_insertion_point(field_release:proto.Message.ReactionMessage.text) - if (!_internal_has_text()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.text_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.text_.IsDefault()) { - _impl_.text_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ReactionMessage::set_allocated_text(std::string* text) { - if (text != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.text_.SetAllocated(text, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.text_.IsDefault()) { - _impl_.text_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ReactionMessage.text) -} - -// optional string groupingKey = 3; -inline bool Message_ReactionMessage::_internal_has_groupingkey() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_ReactionMessage::has_groupingkey() const { - return _internal_has_groupingkey(); -} -inline void Message_ReactionMessage::clear_groupingkey() { - _impl_.groupingkey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_ReactionMessage::groupingkey() const { - // @@protoc_insertion_point(field_get:proto.Message.ReactionMessage.groupingKey) - return _internal_groupingkey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_ReactionMessage::set_groupingkey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.groupingkey_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.ReactionMessage.groupingKey) -} -inline std::string* Message_ReactionMessage::mutable_groupingkey() { - std::string* _s = _internal_mutable_groupingkey(); - // @@protoc_insertion_point(field_mutable:proto.Message.ReactionMessage.groupingKey) - return _s; -} -inline const std::string& Message_ReactionMessage::_internal_groupingkey() const { - return _impl_.groupingkey_.Get(); -} -inline void Message_ReactionMessage::_internal_set_groupingkey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.groupingkey_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_ReactionMessage::_internal_mutable_groupingkey() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.groupingkey_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_ReactionMessage::release_groupingkey() { - // @@protoc_insertion_point(field_release:proto.Message.ReactionMessage.groupingKey) - if (!_internal_has_groupingkey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.groupingkey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.groupingkey_.IsDefault()) { - _impl_.groupingkey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_ReactionMessage::set_allocated_groupingkey(std::string* groupingkey) { - if (groupingkey != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.groupingkey_.SetAllocated(groupingkey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.groupingkey_.IsDefault()) { - _impl_.groupingkey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.ReactionMessage.groupingKey) -} - -// optional int64 senderTimestampMs = 4; -inline bool Message_ReactionMessage::_internal_has_sendertimestampms() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool Message_ReactionMessage::has_sendertimestampms() const { - return _internal_has_sendertimestampms(); -} -inline void Message_ReactionMessage::clear_sendertimestampms() { - _impl_.sendertimestampms_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline int64_t Message_ReactionMessage::_internal_sendertimestampms() const { - return _impl_.sendertimestampms_; -} -inline int64_t Message_ReactionMessage::sendertimestampms() const { - // @@protoc_insertion_point(field_get:proto.Message.ReactionMessage.senderTimestampMs) - return _internal_sendertimestampms(); -} -inline void Message_ReactionMessage::_internal_set_sendertimestampms(int64_t value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.sendertimestampms_ = value; -} -inline void Message_ReactionMessage::set_sendertimestampms(int64_t value) { - _internal_set_sendertimestampms(value); - // @@protoc_insertion_point(field_set:proto.Message.ReactionMessage.senderTimestampMs) -} - -// ------------------------------------------------------------------- - -// Message_RequestMediaUploadMessage - -// repeated string fileSha256 = 1; -inline int Message_RequestMediaUploadMessage::_internal_filesha256_size() const { - return _impl_.filesha256_.size(); -} -inline int Message_RequestMediaUploadMessage::filesha256_size() const { - return _internal_filesha256_size(); -} -inline void Message_RequestMediaUploadMessage::clear_filesha256() { - _impl_.filesha256_.Clear(); -} -inline std::string* Message_RequestMediaUploadMessage::add_filesha256() { - std::string* _s = _internal_add_filesha256(); - // @@protoc_insertion_point(field_add_mutable:proto.Message.RequestMediaUploadMessage.fileSha256) - return _s; -} -inline const std::string& Message_RequestMediaUploadMessage::_internal_filesha256(int index) const { - return _impl_.filesha256_.Get(index); -} -inline const std::string& Message_RequestMediaUploadMessage::filesha256(int index) const { - // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadMessage.fileSha256) - return _internal_filesha256(index); -} -inline std::string* Message_RequestMediaUploadMessage::mutable_filesha256(int index) { - // @@protoc_insertion_point(field_mutable:proto.Message.RequestMediaUploadMessage.fileSha256) - return _impl_.filesha256_.Mutable(index); -} -inline void Message_RequestMediaUploadMessage::set_filesha256(int index, const std::string& value) { - _impl_.filesha256_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:proto.Message.RequestMediaUploadMessage.fileSha256) -} -inline void Message_RequestMediaUploadMessage::set_filesha256(int index, std::string&& value) { - _impl_.filesha256_.Mutable(index)->assign(std::move(value)); - // @@protoc_insertion_point(field_set:proto.Message.RequestMediaUploadMessage.fileSha256) -} -inline void Message_RequestMediaUploadMessage::set_filesha256(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - _impl_.filesha256_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:proto.Message.RequestMediaUploadMessage.fileSha256) -} -inline void Message_RequestMediaUploadMessage::set_filesha256(int index, const char* value, size_t size) { - _impl_.filesha256_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:proto.Message.RequestMediaUploadMessage.fileSha256) -} -inline std::string* Message_RequestMediaUploadMessage::_internal_add_filesha256() { - return _impl_.filesha256_.Add(); -} -inline void Message_RequestMediaUploadMessage::add_filesha256(const std::string& value) { - _impl_.filesha256_.Add()->assign(value); - // @@protoc_insertion_point(field_add:proto.Message.RequestMediaUploadMessage.fileSha256) -} -inline void Message_RequestMediaUploadMessage::add_filesha256(std::string&& value) { - _impl_.filesha256_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:proto.Message.RequestMediaUploadMessage.fileSha256) -} -inline void Message_RequestMediaUploadMessage::add_filesha256(const char* value) { - GOOGLE_DCHECK(value != nullptr); - _impl_.filesha256_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:proto.Message.RequestMediaUploadMessage.fileSha256) -} -inline void Message_RequestMediaUploadMessage::add_filesha256(const char* value, size_t size) { - _impl_.filesha256_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:proto.Message.RequestMediaUploadMessage.fileSha256) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -Message_RequestMediaUploadMessage::filesha256() const { - // @@protoc_insertion_point(field_list:proto.Message.RequestMediaUploadMessage.fileSha256) - return _impl_.filesha256_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -Message_RequestMediaUploadMessage::mutable_filesha256() { - // @@protoc_insertion_point(field_mutable_list:proto.Message.RequestMediaUploadMessage.fileSha256) - return &_impl_.filesha256_; -} - -// optional .proto.Message.RmrSource rmrSource = 2; -inline bool Message_RequestMediaUploadMessage::_internal_has_rmrsource() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_RequestMediaUploadMessage::has_rmrsource() const { - return _internal_has_rmrsource(); -} -inline void Message_RequestMediaUploadMessage::clear_rmrsource() { - _impl_.rmrsource_ = 0; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline ::proto::Message_RmrSource Message_RequestMediaUploadMessage::_internal_rmrsource() const { - return static_cast< ::proto::Message_RmrSource >(_impl_.rmrsource_); -} -inline ::proto::Message_RmrSource Message_RequestMediaUploadMessage::rmrsource() const { - // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadMessage.rmrSource) - return _internal_rmrsource(); -} -inline void Message_RequestMediaUploadMessage::_internal_set_rmrsource(::proto::Message_RmrSource value) { - assert(::proto::Message_RmrSource_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.rmrsource_ = value; -} -inline void Message_RequestMediaUploadMessage::set_rmrsource(::proto::Message_RmrSource value) { - _internal_set_rmrsource(value); - // @@protoc_insertion_point(field_set:proto.Message.RequestMediaUploadMessage.rmrSource) -} - -// ------------------------------------------------------------------- - -// Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult - -// optional string fileSha256 = 1; -inline bool Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_has_filesha256() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::has_filesha256() const { - return _internal_has_filesha256(); -} -inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::clear_filesha256() { - _impl_.filesha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::filesha256() const { - // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.fileSha256) - return _internal_filesha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::set_filesha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.filesha256_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.fileSha256) -} -inline std::string* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::mutable_filesha256() { - std::string* _s = _internal_mutable_filesha256(); - // @@protoc_insertion_point(field_mutable:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.fileSha256) - return _s; -} -inline const std::string& Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_filesha256() const { - return _impl_.filesha256_.Get(); -} -inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_set_filesha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.filesha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_mutable_filesha256() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.filesha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::release_filesha256() { - // @@protoc_insertion_point(field_release:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.fileSha256) - if (!_internal_has_filesha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.filesha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.filesha256_.IsDefault()) { - _impl_.filesha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::set_allocated_filesha256(std::string* filesha256) { - if (filesha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.filesha256_.IsDefault()) { - _impl_.filesha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.fileSha256) -} - -// optional .proto.MediaRetryNotification.ResultType mediaUploadResult = 2; -inline bool Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_has_mediauploadresult() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::has_mediauploadresult() const { - return _internal_has_mediauploadresult(); -} -inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::clear_mediauploadresult() { - _impl_.mediauploadresult_ = 0; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline ::proto::MediaRetryNotification_ResultType Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_mediauploadresult() const { - return static_cast< ::proto::MediaRetryNotification_ResultType >(_impl_.mediauploadresult_); -} -inline ::proto::MediaRetryNotification_ResultType Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::mediauploadresult() const { - // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.mediaUploadResult) - return _internal_mediauploadresult(); -} -inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_set_mediauploadresult(::proto::MediaRetryNotification_ResultType value) { - assert(::proto::MediaRetryNotification_ResultType_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.mediauploadresult_ = value; -} -inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::set_mediauploadresult(::proto::MediaRetryNotification_ResultType value) { - _internal_set_mediauploadresult(value); - // @@protoc_insertion_point(field_set:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.mediaUploadResult) -} - -// optional .proto.Message.StickerMessage stickerMessage = 3; -inline bool Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_has_stickermessage() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.stickermessage_ != nullptr); - return value; -} -inline bool Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::has_stickermessage() const { - return _internal_has_stickermessage(); -} -inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::clear_stickermessage() { - if (_impl_.stickermessage_ != nullptr) _impl_.stickermessage_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::Message_StickerMessage& Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_stickermessage() const { - const ::proto::Message_StickerMessage* p = _impl_.stickermessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_StickerMessage_default_instance_); -} -inline const ::proto::Message_StickerMessage& Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::stickermessage() const { - // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.stickerMessage) - return _internal_stickermessage(); -} -inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::unsafe_arena_set_allocated_stickermessage( - ::proto::Message_StickerMessage* stickermessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.stickermessage_); - } - _impl_.stickermessage_ = stickermessage; - if (stickermessage) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.stickerMessage) -} -inline ::proto::Message_StickerMessage* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::release_stickermessage() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::Message_StickerMessage* temp = _impl_.stickermessage_; - _impl_.stickermessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_StickerMessage* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::unsafe_arena_release_stickermessage() { - // @@protoc_insertion_point(field_release:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.stickerMessage) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::Message_StickerMessage* temp = _impl_.stickermessage_; - _impl_.stickermessage_ = nullptr; - return temp; -} -inline ::proto::Message_StickerMessage* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_mutable_stickermessage() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.stickermessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_StickerMessage>(GetArenaForAllocation()); - _impl_.stickermessage_ = p; - } - return _impl_.stickermessage_; -} -inline ::proto::Message_StickerMessage* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::mutable_stickermessage() { - ::proto::Message_StickerMessage* _msg = _internal_mutable_stickermessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.stickerMessage) - return _msg; -} -inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::set_allocated_stickermessage(::proto::Message_StickerMessage* stickermessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.stickermessage_; - } - if (stickermessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(stickermessage); - if (message_arena != submessage_arena) { - stickermessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, stickermessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.stickermessage_ = stickermessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.stickerMessage) -} - -// ------------------------------------------------------------------- - -// Message_RequestMediaUploadResponseMessage - -// optional .proto.Message.RmrSource rmrSource = 1; -inline bool Message_RequestMediaUploadResponseMessage::_internal_has_rmrsource() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_RequestMediaUploadResponseMessage::has_rmrsource() const { - return _internal_has_rmrsource(); -} -inline void Message_RequestMediaUploadResponseMessage::clear_rmrsource() { - _impl_.rmrsource_ = 0; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline ::proto::Message_RmrSource Message_RequestMediaUploadResponseMessage::_internal_rmrsource() const { - return static_cast< ::proto::Message_RmrSource >(_impl_.rmrsource_); -} -inline ::proto::Message_RmrSource Message_RequestMediaUploadResponseMessage::rmrsource() const { - // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadResponseMessage.rmrSource) - return _internal_rmrsource(); -} -inline void Message_RequestMediaUploadResponseMessage::_internal_set_rmrsource(::proto::Message_RmrSource value) { - assert(::proto::Message_RmrSource_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.rmrsource_ = value; -} -inline void Message_RequestMediaUploadResponseMessage::set_rmrsource(::proto::Message_RmrSource value) { - _internal_set_rmrsource(value); - // @@protoc_insertion_point(field_set:proto.Message.RequestMediaUploadResponseMessage.rmrSource) -} - -// optional string stanzaId = 2; -inline bool Message_RequestMediaUploadResponseMessage::_internal_has_stanzaid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_RequestMediaUploadResponseMessage::has_stanzaid() const { - return _internal_has_stanzaid(); -} -inline void Message_RequestMediaUploadResponseMessage::clear_stanzaid() { - _impl_.stanzaid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_RequestMediaUploadResponseMessage::stanzaid() const { - // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadResponseMessage.stanzaId) - return _internal_stanzaid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_RequestMediaUploadResponseMessage::set_stanzaid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.stanzaid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.RequestMediaUploadResponseMessage.stanzaId) -} -inline std::string* Message_RequestMediaUploadResponseMessage::mutable_stanzaid() { - std::string* _s = _internal_mutable_stanzaid(); - // @@protoc_insertion_point(field_mutable:proto.Message.RequestMediaUploadResponseMessage.stanzaId) - return _s; -} -inline const std::string& Message_RequestMediaUploadResponseMessage::_internal_stanzaid() const { - return _impl_.stanzaid_.Get(); -} -inline void Message_RequestMediaUploadResponseMessage::_internal_set_stanzaid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.stanzaid_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_RequestMediaUploadResponseMessage::_internal_mutable_stanzaid() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.stanzaid_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_RequestMediaUploadResponseMessage::release_stanzaid() { - // @@protoc_insertion_point(field_release:proto.Message.RequestMediaUploadResponseMessage.stanzaId) - if (!_internal_has_stanzaid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.stanzaid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.stanzaid_.IsDefault()) { - _impl_.stanzaid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_RequestMediaUploadResponseMessage::set_allocated_stanzaid(std::string* stanzaid) { - if (stanzaid != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.stanzaid_.SetAllocated(stanzaid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.stanzaid_.IsDefault()) { - _impl_.stanzaid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestMediaUploadResponseMessage.stanzaId) -} - -// repeated .proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult reuploadResult = 3; -inline int Message_RequestMediaUploadResponseMessage::_internal_reuploadresult_size() const { - return _impl_.reuploadresult_.size(); -} -inline int Message_RequestMediaUploadResponseMessage::reuploadresult_size() const { - return _internal_reuploadresult_size(); -} -inline void Message_RequestMediaUploadResponseMessage::clear_reuploadresult() { - _impl_.reuploadresult_.Clear(); -} -inline ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* Message_RequestMediaUploadResponseMessage::mutable_reuploadresult(int index) { - // @@protoc_insertion_point(field_mutable:proto.Message.RequestMediaUploadResponseMessage.reuploadResult) - return _impl_.reuploadresult_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult >* -Message_RequestMediaUploadResponseMessage::mutable_reuploadresult() { - // @@protoc_insertion_point(field_mutable_list:proto.Message.RequestMediaUploadResponseMessage.reuploadResult) - return &_impl_.reuploadresult_; -} -inline const ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& Message_RequestMediaUploadResponseMessage::_internal_reuploadresult(int index) const { - return _impl_.reuploadresult_.Get(index); -} -inline const ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& Message_RequestMediaUploadResponseMessage::reuploadresult(int index) const { - // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadResponseMessage.reuploadResult) - return _internal_reuploadresult(index); -} -inline ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* Message_RequestMediaUploadResponseMessage::_internal_add_reuploadresult() { - return _impl_.reuploadresult_.Add(); -} -inline ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* Message_RequestMediaUploadResponseMessage::add_reuploadresult() { - ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* _add = _internal_add_reuploadresult(); - // @@protoc_insertion_point(field_add:proto.Message.RequestMediaUploadResponseMessage.reuploadResult) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult >& -Message_RequestMediaUploadResponseMessage::reuploadresult() const { - // @@protoc_insertion_point(field_list:proto.Message.RequestMediaUploadResponseMessage.reuploadResult) - return _impl_.reuploadresult_; -} - -// ------------------------------------------------------------------- - -// Message_RequestPaymentMessage - -// optional .proto.Message noteMessage = 4; -inline bool Message_RequestPaymentMessage::_internal_has_notemessage() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - PROTOBUF_ASSUME(!value || _impl_.notemessage_ != nullptr); - return value; -} -inline bool Message_RequestPaymentMessage::has_notemessage() const { - return _internal_has_notemessage(); -} -inline void Message_RequestPaymentMessage::clear_notemessage() { - if (_impl_.notemessage_ != nullptr) _impl_.notemessage_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const ::proto::Message& Message_RequestPaymentMessage::_internal_notemessage() const { - const ::proto::Message* p = _impl_.notemessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_default_instance_); -} -inline const ::proto::Message& Message_RequestPaymentMessage::notemessage() const { - // @@protoc_insertion_point(field_get:proto.Message.RequestPaymentMessage.noteMessage) - return _internal_notemessage(); -} -inline void Message_RequestPaymentMessage::unsafe_arena_set_allocated_notemessage( - ::proto::Message* notemessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.notemessage_); - } - _impl_.notemessage_ = notemessage; - if (notemessage) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.RequestPaymentMessage.noteMessage) -} -inline ::proto::Message* Message_RequestPaymentMessage::release_notemessage() { - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::Message* temp = _impl_.notemessage_; - _impl_.notemessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message* Message_RequestPaymentMessage::unsafe_arena_release_notemessage() { - // @@protoc_insertion_point(field_release:proto.Message.RequestPaymentMessage.noteMessage) - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::Message* temp = _impl_.notemessage_; - _impl_.notemessage_ = nullptr; - return temp; -} -inline ::proto::Message* Message_RequestPaymentMessage::_internal_mutable_notemessage() { - _impl_._has_bits_[0] |= 0x00000004u; - if (_impl_.notemessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message>(GetArenaForAllocation()); - _impl_.notemessage_ = p; - } - return _impl_.notemessage_; -} -inline ::proto::Message* Message_RequestPaymentMessage::mutable_notemessage() { - ::proto::Message* _msg = _internal_mutable_notemessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.RequestPaymentMessage.noteMessage) - return _msg; -} -inline void Message_RequestPaymentMessage::set_allocated_notemessage(::proto::Message* notemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.notemessage_; - } - if (notemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(notemessage); - if (message_arena != submessage_arena) { - notemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, notemessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.notemessage_ = notemessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestPaymentMessage.noteMessage) -} - -// optional string currencyCodeIso4217 = 1; -inline bool Message_RequestPaymentMessage::_internal_has_currencycodeiso4217() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_RequestPaymentMessage::has_currencycodeiso4217() const { - return _internal_has_currencycodeiso4217(); -} -inline void Message_RequestPaymentMessage::clear_currencycodeiso4217() { - _impl_.currencycodeiso4217_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_RequestPaymentMessage::currencycodeiso4217() const { - // @@protoc_insertion_point(field_get:proto.Message.RequestPaymentMessage.currencyCodeIso4217) - return _internal_currencycodeiso4217(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_RequestPaymentMessage::set_currencycodeiso4217(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.currencycodeiso4217_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.RequestPaymentMessage.currencyCodeIso4217) -} -inline std::string* Message_RequestPaymentMessage::mutable_currencycodeiso4217() { - std::string* _s = _internal_mutable_currencycodeiso4217(); - // @@protoc_insertion_point(field_mutable:proto.Message.RequestPaymentMessage.currencyCodeIso4217) - return _s; -} -inline const std::string& Message_RequestPaymentMessage::_internal_currencycodeiso4217() const { - return _impl_.currencycodeiso4217_.Get(); -} -inline void Message_RequestPaymentMessage::_internal_set_currencycodeiso4217(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.currencycodeiso4217_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_RequestPaymentMessage::_internal_mutable_currencycodeiso4217() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.currencycodeiso4217_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_RequestPaymentMessage::release_currencycodeiso4217() { - // @@protoc_insertion_point(field_release:proto.Message.RequestPaymentMessage.currencyCodeIso4217) - if (!_internal_has_currencycodeiso4217()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.currencycodeiso4217_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.currencycodeiso4217_.IsDefault()) { - _impl_.currencycodeiso4217_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_RequestPaymentMessage::set_allocated_currencycodeiso4217(std::string* currencycodeiso4217) { - if (currencycodeiso4217 != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.currencycodeiso4217_.SetAllocated(currencycodeiso4217, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.currencycodeiso4217_.IsDefault()) { - _impl_.currencycodeiso4217_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestPaymentMessage.currencyCodeIso4217) -} - -// optional uint64 amount1000 = 2; -inline bool Message_RequestPaymentMessage::_internal_has_amount1000() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool Message_RequestPaymentMessage::has_amount1000() const { - return _internal_has_amount1000(); -} -inline void Message_RequestPaymentMessage::clear_amount1000() { - _impl_.amount1000_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline uint64_t Message_RequestPaymentMessage::_internal_amount1000() const { - return _impl_.amount1000_; -} -inline uint64_t Message_RequestPaymentMessage::amount1000() const { - // @@protoc_insertion_point(field_get:proto.Message.RequestPaymentMessage.amount1000) - return _internal_amount1000(); -} -inline void Message_RequestPaymentMessage::_internal_set_amount1000(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.amount1000_ = value; -} -inline void Message_RequestPaymentMessage::set_amount1000(uint64_t value) { - _internal_set_amount1000(value); - // @@protoc_insertion_point(field_set:proto.Message.RequestPaymentMessage.amount1000) -} - -// optional string requestFrom = 3; -inline bool Message_RequestPaymentMessage::_internal_has_requestfrom() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_RequestPaymentMessage::has_requestfrom() const { - return _internal_has_requestfrom(); -} -inline void Message_RequestPaymentMessage::clear_requestfrom() { - _impl_.requestfrom_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_RequestPaymentMessage::requestfrom() const { - // @@protoc_insertion_point(field_get:proto.Message.RequestPaymentMessage.requestFrom) - return _internal_requestfrom(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_RequestPaymentMessage::set_requestfrom(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.requestfrom_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.RequestPaymentMessage.requestFrom) -} -inline std::string* Message_RequestPaymentMessage::mutable_requestfrom() { - std::string* _s = _internal_mutable_requestfrom(); - // @@protoc_insertion_point(field_mutable:proto.Message.RequestPaymentMessage.requestFrom) - return _s; -} -inline const std::string& Message_RequestPaymentMessage::_internal_requestfrom() const { - return _impl_.requestfrom_.Get(); -} -inline void Message_RequestPaymentMessage::_internal_set_requestfrom(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.requestfrom_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_RequestPaymentMessage::_internal_mutable_requestfrom() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.requestfrom_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_RequestPaymentMessage::release_requestfrom() { - // @@protoc_insertion_point(field_release:proto.Message.RequestPaymentMessage.requestFrom) - if (!_internal_has_requestfrom()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.requestfrom_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.requestfrom_.IsDefault()) { - _impl_.requestfrom_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_RequestPaymentMessage::set_allocated_requestfrom(std::string* requestfrom) { - if (requestfrom != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.requestfrom_.SetAllocated(requestfrom, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.requestfrom_.IsDefault()) { - _impl_.requestfrom_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestPaymentMessage.requestFrom) -} - -// optional int64 expiryTimestamp = 5; -inline bool Message_RequestPaymentMessage::_internal_has_expirytimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool Message_RequestPaymentMessage::has_expirytimestamp() const { - return _internal_has_expirytimestamp(); -} -inline void Message_RequestPaymentMessage::clear_expirytimestamp() { - _impl_.expirytimestamp_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline int64_t Message_RequestPaymentMessage::_internal_expirytimestamp() const { - return _impl_.expirytimestamp_; -} -inline int64_t Message_RequestPaymentMessage::expirytimestamp() const { - // @@protoc_insertion_point(field_get:proto.Message.RequestPaymentMessage.expiryTimestamp) - return _internal_expirytimestamp(); -} -inline void Message_RequestPaymentMessage::_internal_set_expirytimestamp(int64_t value) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.expirytimestamp_ = value; -} -inline void Message_RequestPaymentMessage::set_expirytimestamp(int64_t value) { - _internal_set_expirytimestamp(value); - // @@protoc_insertion_point(field_set:proto.Message.RequestPaymentMessage.expiryTimestamp) -} - -// optional .proto.Money amount = 6; -inline bool Message_RequestPaymentMessage::_internal_has_amount() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - PROTOBUF_ASSUME(!value || _impl_.amount_ != nullptr); - return value; -} -inline bool Message_RequestPaymentMessage::has_amount() const { - return _internal_has_amount(); -} -inline void Message_RequestPaymentMessage::clear_amount() { - if (_impl_.amount_ != nullptr) _impl_.amount_->Clear(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const ::proto::Money& Message_RequestPaymentMessage::_internal_amount() const { - const ::proto::Money* p = _impl_.amount_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Money_default_instance_); -} -inline const ::proto::Money& Message_RequestPaymentMessage::amount() const { - // @@protoc_insertion_point(field_get:proto.Message.RequestPaymentMessage.amount) - return _internal_amount(); -} -inline void Message_RequestPaymentMessage::unsafe_arena_set_allocated_amount( - ::proto::Money* amount) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.amount_); - } - _impl_.amount_ = amount; - if (amount) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.RequestPaymentMessage.amount) -} -inline ::proto::Money* Message_RequestPaymentMessage::release_amount() { - _impl_._has_bits_[0] &= ~0x00000008u; - ::proto::Money* temp = _impl_.amount_; - _impl_.amount_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Money* Message_RequestPaymentMessage::unsafe_arena_release_amount() { - // @@protoc_insertion_point(field_release:proto.Message.RequestPaymentMessage.amount) - _impl_._has_bits_[0] &= ~0x00000008u; - ::proto::Money* temp = _impl_.amount_; - _impl_.amount_ = nullptr; - return temp; -} -inline ::proto::Money* Message_RequestPaymentMessage::_internal_mutable_amount() { - _impl_._has_bits_[0] |= 0x00000008u; - if (_impl_.amount_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Money>(GetArenaForAllocation()); - _impl_.amount_ = p; - } - return _impl_.amount_; -} -inline ::proto::Money* Message_RequestPaymentMessage::mutable_amount() { - ::proto::Money* _msg = _internal_mutable_amount(); - // @@protoc_insertion_point(field_mutable:proto.Message.RequestPaymentMessage.amount) - return _msg; -} -inline void Message_RequestPaymentMessage::set_allocated_amount(::proto::Money* amount) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.amount_; - } - if (amount) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(amount); - if (message_arena != submessage_arena) { - amount = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, amount, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.amount_ = amount; - // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestPaymentMessage.amount) -} - -// optional .proto.PaymentBackground background = 7; -inline bool Message_RequestPaymentMessage::_internal_has_background() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - PROTOBUF_ASSUME(!value || _impl_.background_ != nullptr); - return value; -} -inline bool Message_RequestPaymentMessage::has_background() const { - return _internal_has_background(); -} -inline void Message_RequestPaymentMessage::clear_background() { - if (_impl_.background_ != nullptr) _impl_.background_->Clear(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const ::proto::PaymentBackground& Message_RequestPaymentMessage::_internal_background() const { - const ::proto::PaymentBackground* p = _impl_.background_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_PaymentBackground_default_instance_); -} -inline const ::proto::PaymentBackground& Message_RequestPaymentMessage::background() const { - // @@protoc_insertion_point(field_get:proto.Message.RequestPaymentMessage.background) - return _internal_background(); -} -inline void Message_RequestPaymentMessage::unsafe_arena_set_allocated_background( - ::proto::PaymentBackground* background) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.background_); - } - _impl_.background_ = background; - if (background) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.RequestPaymentMessage.background) -} -inline ::proto::PaymentBackground* Message_RequestPaymentMessage::release_background() { - _impl_._has_bits_[0] &= ~0x00000010u; - ::proto::PaymentBackground* temp = _impl_.background_; - _impl_.background_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::PaymentBackground* Message_RequestPaymentMessage::unsafe_arena_release_background() { - // @@protoc_insertion_point(field_release:proto.Message.RequestPaymentMessage.background) - _impl_._has_bits_[0] &= ~0x00000010u; - ::proto::PaymentBackground* temp = _impl_.background_; - _impl_.background_ = nullptr; - return temp; -} -inline ::proto::PaymentBackground* Message_RequestPaymentMessage::_internal_mutable_background() { - _impl_._has_bits_[0] |= 0x00000010u; - if (_impl_.background_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::PaymentBackground>(GetArenaForAllocation()); - _impl_.background_ = p; - } - return _impl_.background_; -} -inline ::proto::PaymentBackground* Message_RequestPaymentMessage::mutable_background() { - ::proto::PaymentBackground* _msg = _internal_mutable_background(); - // @@protoc_insertion_point(field_mutable:proto.Message.RequestPaymentMessage.background) - return _msg; -} -inline void Message_RequestPaymentMessage::set_allocated_background(::proto::PaymentBackground* background) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.background_; - } - if (background) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(background); - if (message_arena != submessage_arena) { - background = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, background, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.background_ = background; - // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestPaymentMessage.background) -} - -// ------------------------------------------------------------------- - -// Message_RequestPhoneNumberMessage - -// optional .proto.ContextInfo contextInfo = 1; -inline bool Message_RequestPhoneNumberMessage::_internal_has_contextinfo() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); - return value; -} -inline bool Message_RequestPhoneNumberMessage::has_contextinfo() const { - return _internal_has_contextinfo(); -} -inline void Message_RequestPhoneNumberMessage::clear_contextinfo() { - if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::ContextInfo& Message_RequestPhoneNumberMessage::_internal_contextinfo() const { - const ::proto::ContextInfo* p = _impl_.contextinfo_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ContextInfo_default_instance_); -} -inline const ::proto::ContextInfo& Message_RequestPhoneNumberMessage::contextinfo() const { - // @@protoc_insertion_point(field_get:proto.Message.RequestPhoneNumberMessage.contextInfo) - return _internal_contextinfo(); -} -inline void Message_RequestPhoneNumberMessage::unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); - } - _impl_.contextinfo_ = contextinfo; - if (contextinfo) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.RequestPhoneNumberMessage.contextInfo) -} -inline ::proto::ContextInfo* Message_RequestPhoneNumberMessage::release_contextinfo() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ContextInfo* Message_RequestPhoneNumberMessage::unsafe_arena_release_contextinfo() { - // @@protoc_insertion_point(field_release:proto.Message.RequestPhoneNumberMessage.contextInfo) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; - return temp; -} -inline ::proto::ContextInfo* Message_RequestPhoneNumberMessage::_internal_mutable_contextinfo() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.contextinfo_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); - _impl_.contextinfo_ = p; - } - return _impl_.contextinfo_; -} -inline ::proto::ContextInfo* Message_RequestPhoneNumberMessage::mutable_contextinfo() { - ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); - // @@protoc_insertion_point(field_mutable:proto.Message.RequestPhoneNumberMessage.contextInfo) - return _msg; -} -inline void Message_RequestPhoneNumberMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.contextinfo_; - } - if (contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); - if (message_arena != submessage_arena) { - contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, contextinfo, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.contextinfo_ = contextinfo; - // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestPhoneNumberMessage.contextInfo) -} - -// ------------------------------------------------------------------- - -// Message_SendPaymentMessage - -// optional .proto.Message noteMessage = 2; -inline bool Message_SendPaymentMessage::_internal_has_notemessage() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.notemessage_ != nullptr); - return value; -} -inline bool Message_SendPaymentMessage::has_notemessage() const { - return _internal_has_notemessage(); -} -inline void Message_SendPaymentMessage::clear_notemessage() { - if (_impl_.notemessage_ != nullptr) _impl_.notemessage_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::Message& Message_SendPaymentMessage::_internal_notemessage() const { - const ::proto::Message* p = _impl_.notemessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_default_instance_); -} -inline const ::proto::Message& Message_SendPaymentMessage::notemessage() const { - // @@protoc_insertion_point(field_get:proto.Message.SendPaymentMessage.noteMessage) - return _internal_notemessage(); -} -inline void Message_SendPaymentMessage::unsafe_arena_set_allocated_notemessage( - ::proto::Message* notemessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.notemessage_); - } - _impl_.notemessage_ = notemessage; - if (notemessage) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.SendPaymentMessage.noteMessage) -} -inline ::proto::Message* Message_SendPaymentMessage::release_notemessage() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::Message* temp = _impl_.notemessage_; - _impl_.notemessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message* Message_SendPaymentMessage::unsafe_arena_release_notemessage() { - // @@protoc_insertion_point(field_release:proto.Message.SendPaymentMessage.noteMessage) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::Message* temp = _impl_.notemessage_; - _impl_.notemessage_ = nullptr; - return temp; -} -inline ::proto::Message* Message_SendPaymentMessage::_internal_mutable_notemessage() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.notemessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message>(GetArenaForAllocation()); - _impl_.notemessage_ = p; - } - return _impl_.notemessage_; -} -inline ::proto::Message* Message_SendPaymentMessage::mutable_notemessage() { - ::proto::Message* _msg = _internal_mutable_notemessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.SendPaymentMessage.noteMessage) - return _msg; -} -inline void Message_SendPaymentMessage::set_allocated_notemessage(::proto::Message* notemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.notemessage_; - } - if (notemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(notemessage); - if (message_arena != submessage_arena) { - notemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, notemessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.notemessage_ = notemessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.SendPaymentMessage.noteMessage) -} - -// optional .proto.MessageKey requestMessageKey = 3; -inline bool Message_SendPaymentMessage::_internal_has_requestmessagekey() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.requestmessagekey_ != nullptr); - return value; -} -inline bool Message_SendPaymentMessage::has_requestmessagekey() const { - return _internal_has_requestmessagekey(); -} -inline void Message_SendPaymentMessage::clear_requestmessagekey() { - if (_impl_.requestmessagekey_ != nullptr) _impl_.requestmessagekey_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::MessageKey& Message_SendPaymentMessage::_internal_requestmessagekey() const { - const ::proto::MessageKey* p = _impl_.requestmessagekey_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_MessageKey_default_instance_); -} -inline const ::proto::MessageKey& Message_SendPaymentMessage::requestmessagekey() const { - // @@protoc_insertion_point(field_get:proto.Message.SendPaymentMessage.requestMessageKey) - return _internal_requestmessagekey(); -} -inline void Message_SendPaymentMessage::unsafe_arena_set_allocated_requestmessagekey( - ::proto::MessageKey* requestmessagekey) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.requestmessagekey_); - } - _impl_.requestmessagekey_ = requestmessagekey; - if (requestmessagekey) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.SendPaymentMessage.requestMessageKey) -} -inline ::proto::MessageKey* Message_SendPaymentMessage::release_requestmessagekey() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::MessageKey* temp = _impl_.requestmessagekey_; - _impl_.requestmessagekey_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::MessageKey* Message_SendPaymentMessage::unsafe_arena_release_requestmessagekey() { - // @@protoc_insertion_point(field_release:proto.Message.SendPaymentMessage.requestMessageKey) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::MessageKey* temp = _impl_.requestmessagekey_; - _impl_.requestmessagekey_ = nullptr; - return temp; -} -inline ::proto::MessageKey* Message_SendPaymentMessage::_internal_mutable_requestmessagekey() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.requestmessagekey_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation()); - _impl_.requestmessagekey_ = p; - } - return _impl_.requestmessagekey_; -} -inline ::proto::MessageKey* Message_SendPaymentMessage::mutable_requestmessagekey() { - ::proto::MessageKey* _msg = _internal_mutable_requestmessagekey(); - // @@protoc_insertion_point(field_mutable:proto.Message.SendPaymentMessage.requestMessageKey) - return _msg; -} -inline void Message_SendPaymentMessage::set_allocated_requestmessagekey(::proto::MessageKey* requestmessagekey) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.requestmessagekey_; - } - if (requestmessagekey) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(requestmessagekey); - if (message_arena != submessage_arena) { - requestmessagekey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, requestmessagekey, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.requestmessagekey_ = requestmessagekey; - // @@protoc_insertion_point(field_set_allocated:proto.Message.SendPaymentMessage.requestMessageKey) -} - -// optional .proto.PaymentBackground background = 4; -inline bool Message_SendPaymentMessage::_internal_has_background() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - PROTOBUF_ASSUME(!value || _impl_.background_ != nullptr); - return value; -} -inline bool Message_SendPaymentMessage::has_background() const { - return _internal_has_background(); -} -inline void Message_SendPaymentMessage::clear_background() { - if (_impl_.background_ != nullptr) _impl_.background_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const ::proto::PaymentBackground& Message_SendPaymentMessage::_internal_background() const { - const ::proto::PaymentBackground* p = _impl_.background_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_PaymentBackground_default_instance_); -} -inline const ::proto::PaymentBackground& Message_SendPaymentMessage::background() const { - // @@protoc_insertion_point(field_get:proto.Message.SendPaymentMessage.background) - return _internal_background(); -} -inline void Message_SendPaymentMessage::unsafe_arena_set_allocated_background( - ::proto::PaymentBackground* background) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.background_); - } - _impl_.background_ = background; - if (background) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.SendPaymentMessage.background) -} -inline ::proto::PaymentBackground* Message_SendPaymentMessage::release_background() { - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::PaymentBackground* temp = _impl_.background_; - _impl_.background_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::PaymentBackground* Message_SendPaymentMessage::unsafe_arena_release_background() { - // @@protoc_insertion_point(field_release:proto.Message.SendPaymentMessage.background) - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::PaymentBackground* temp = _impl_.background_; - _impl_.background_ = nullptr; - return temp; -} -inline ::proto::PaymentBackground* Message_SendPaymentMessage::_internal_mutable_background() { - _impl_._has_bits_[0] |= 0x00000004u; - if (_impl_.background_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::PaymentBackground>(GetArenaForAllocation()); - _impl_.background_ = p; - } - return _impl_.background_; -} -inline ::proto::PaymentBackground* Message_SendPaymentMessage::mutable_background() { - ::proto::PaymentBackground* _msg = _internal_mutable_background(); - // @@protoc_insertion_point(field_mutable:proto.Message.SendPaymentMessage.background) - return _msg; -} -inline void Message_SendPaymentMessage::set_allocated_background(::proto::PaymentBackground* background) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.background_; - } - if (background) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(background); - if (message_arena != submessage_arena) { - background = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, background, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.background_ = background; - // @@protoc_insertion_point(field_set_allocated:proto.Message.SendPaymentMessage.background) -} - -// ------------------------------------------------------------------- - -// Message_SenderKeyDistributionMessage - -// optional string groupId = 1; -inline bool Message_SenderKeyDistributionMessage::_internal_has_groupid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_SenderKeyDistributionMessage::has_groupid() const { - return _internal_has_groupid(); -} -inline void Message_SenderKeyDistributionMessage::clear_groupid() { - _impl_.groupid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_SenderKeyDistributionMessage::groupid() const { - // @@protoc_insertion_point(field_get:proto.Message.SenderKeyDistributionMessage.groupId) - return _internal_groupid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_SenderKeyDistributionMessage::set_groupid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.groupid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.SenderKeyDistributionMessage.groupId) -} -inline std::string* Message_SenderKeyDistributionMessage::mutable_groupid() { - std::string* _s = _internal_mutable_groupid(); - // @@protoc_insertion_point(field_mutable:proto.Message.SenderKeyDistributionMessage.groupId) - return _s; -} -inline const std::string& Message_SenderKeyDistributionMessage::_internal_groupid() const { - return _impl_.groupid_.Get(); -} -inline void Message_SenderKeyDistributionMessage::_internal_set_groupid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.groupid_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_SenderKeyDistributionMessage::_internal_mutable_groupid() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.groupid_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_SenderKeyDistributionMessage::release_groupid() { - // @@protoc_insertion_point(field_release:proto.Message.SenderKeyDistributionMessage.groupId) - if (!_internal_has_groupid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.groupid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.groupid_.IsDefault()) { - _impl_.groupid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_SenderKeyDistributionMessage::set_allocated_groupid(std::string* groupid) { - if (groupid != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.groupid_.SetAllocated(groupid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.groupid_.IsDefault()) { - _impl_.groupid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.SenderKeyDistributionMessage.groupId) -} - -// optional bytes axolotlSenderKeyDistributionMessage = 2; -inline bool Message_SenderKeyDistributionMessage::_internal_has_axolotlsenderkeydistributionmessage() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_SenderKeyDistributionMessage::has_axolotlsenderkeydistributionmessage() const { - return _internal_has_axolotlsenderkeydistributionmessage(); -} -inline void Message_SenderKeyDistributionMessage::clear_axolotlsenderkeydistributionmessage() { - _impl_.axolotlsenderkeydistributionmessage_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_SenderKeyDistributionMessage::axolotlsenderkeydistributionmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.SenderKeyDistributionMessage.axolotlSenderKeyDistributionMessage) - return _internal_axolotlsenderkeydistributionmessage(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_SenderKeyDistributionMessage::set_axolotlsenderkeydistributionmessage(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.axolotlsenderkeydistributionmessage_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.SenderKeyDistributionMessage.axolotlSenderKeyDistributionMessage) -} -inline std::string* Message_SenderKeyDistributionMessage::mutable_axolotlsenderkeydistributionmessage() { - std::string* _s = _internal_mutable_axolotlsenderkeydistributionmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.SenderKeyDistributionMessage.axolotlSenderKeyDistributionMessage) - return _s; -} -inline const std::string& Message_SenderKeyDistributionMessage::_internal_axolotlsenderkeydistributionmessage() const { - return _impl_.axolotlsenderkeydistributionmessage_.Get(); -} -inline void Message_SenderKeyDistributionMessage::_internal_set_axolotlsenderkeydistributionmessage(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.axolotlsenderkeydistributionmessage_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_SenderKeyDistributionMessage::_internal_mutable_axolotlsenderkeydistributionmessage() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.axolotlsenderkeydistributionmessage_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_SenderKeyDistributionMessage::release_axolotlsenderkeydistributionmessage() { - // @@protoc_insertion_point(field_release:proto.Message.SenderKeyDistributionMessage.axolotlSenderKeyDistributionMessage) - if (!_internal_has_axolotlsenderkeydistributionmessage()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.axolotlsenderkeydistributionmessage_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.axolotlsenderkeydistributionmessage_.IsDefault()) { - _impl_.axolotlsenderkeydistributionmessage_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_SenderKeyDistributionMessage::set_allocated_axolotlsenderkeydistributionmessage(std::string* axolotlsenderkeydistributionmessage) { - if (axolotlsenderkeydistributionmessage != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.axolotlsenderkeydistributionmessage_.SetAllocated(axolotlsenderkeydistributionmessage, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.axolotlsenderkeydistributionmessage_.IsDefault()) { - _impl_.axolotlsenderkeydistributionmessage_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.SenderKeyDistributionMessage.axolotlSenderKeyDistributionMessage) -} - -// ------------------------------------------------------------------- - -// Message_StickerMessage - -// optional string url = 1; -inline bool Message_StickerMessage::_internal_has_url() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_StickerMessage::has_url() const { - return _internal_has_url(); -} -inline void Message_StickerMessage::clear_url() { - _impl_.url_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_StickerMessage::url() const { - // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.url) - return _internal_url(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_StickerMessage::set_url(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.url_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.url) -} -inline std::string* Message_StickerMessage::mutable_url() { - std::string* _s = _internal_mutable_url(); - // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.url) - return _s; -} -inline const std::string& Message_StickerMessage::_internal_url() const { - return _impl_.url_.Get(); -} -inline void Message_StickerMessage::_internal_set_url(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.url_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_StickerMessage::_internal_mutable_url() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.url_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_StickerMessage::release_url() { - // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.url) - if (!_internal_has_url()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.url_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.url_.IsDefault()) { - _impl_.url_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_StickerMessage::set_allocated_url(std::string* url) { - if (url != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.url_.SetAllocated(url, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.url_.IsDefault()) { - _impl_.url_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.url) -} - -// optional bytes fileSha256 = 2; -inline bool Message_StickerMessage::_internal_has_filesha256() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_StickerMessage::has_filesha256() const { - return _internal_has_filesha256(); -} -inline void Message_StickerMessage::clear_filesha256() { - _impl_.filesha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_StickerMessage::filesha256() const { - // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.fileSha256) - return _internal_filesha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_StickerMessage::set_filesha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.filesha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.fileSha256) -} -inline std::string* Message_StickerMessage::mutable_filesha256() { - std::string* _s = _internal_mutable_filesha256(); - // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.fileSha256) - return _s; -} -inline const std::string& Message_StickerMessage::_internal_filesha256() const { - return _impl_.filesha256_.Get(); -} -inline void Message_StickerMessage::_internal_set_filesha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.filesha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_StickerMessage::_internal_mutable_filesha256() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.filesha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_StickerMessage::release_filesha256() { - // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.fileSha256) - if (!_internal_has_filesha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.filesha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.filesha256_.IsDefault()) { - _impl_.filesha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_StickerMessage::set_allocated_filesha256(std::string* filesha256) { - if (filesha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.filesha256_.IsDefault()) { - _impl_.filesha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.fileSha256) -} - -// optional bytes fileEncSha256 = 3; -inline bool Message_StickerMessage::_internal_has_fileencsha256() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool Message_StickerMessage::has_fileencsha256() const { - return _internal_has_fileencsha256(); -} -inline void Message_StickerMessage::clear_fileencsha256() { - _impl_.fileencsha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& Message_StickerMessage::fileencsha256() const { - // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.fileEncSha256) - return _internal_fileencsha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_StickerMessage::set_fileencsha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.fileencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.fileEncSha256) -} -inline std::string* Message_StickerMessage::mutable_fileencsha256() { - std::string* _s = _internal_mutable_fileencsha256(); - // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.fileEncSha256) - return _s; -} -inline const std::string& Message_StickerMessage::_internal_fileencsha256() const { - return _impl_.fileencsha256_.Get(); -} -inline void Message_StickerMessage::_internal_set_fileencsha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.fileencsha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_StickerMessage::_internal_mutable_fileencsha256() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.fileencsha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_StickerMessage::release_fileencsha256() { - // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.fileEncSha256) - if (!_internal_has_fileencsha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.fileencsha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fileencsha256_.IsDefault()) { - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_StickerMessage::set_allocated_fileencsha256(std::string* fileencsha256) { - if (fileencsha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fileencsha256_.IsDefault()) { - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.fileEncSha256) -} - -// optional bytes mediaKey = 4; -inline bool Message_StickerMessage::_internal_has_mediakey() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool Message_StickerMessage::has_mediakey() const { - return _internal_has_mediakey(); -} -inline void Message_StickerMessage::clear_mediakey() { - _impl_.mediakey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const std::string& Message_StickerMessage::mediakey() const { - // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.mediaKey) - return _internal_mediakey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_StickerMessage::set_mediakey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.mediakey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.mediaKey) -} -inline std::string* Message_StickerMessage::mutable_mediakey() { - std::string* _s = _internal_mutable_mediakey(); - // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.mediaKey) - return _s; -} -inline const std::string& Message_StickerMessage::_internal_mediakey() const { - return _impl_.mediakey_.Get(); -} -inline void Message_StickerMessage::_internal_set_mediakey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.mediakey_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_StickerMessage::_internal_mutable_mediakey() { - _impl_._has_bits_[0] |= 0x00000008u; - return _impl_.mediakey_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_StickerMessage::release_mediakey() { - // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.mediaKey) - if (!_internal_has_mediakey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000008u; - auto* p = _impl_.mediakey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mediakey_.IsDefault()) { - _impl_.mediakey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_StickerMessage::set_allocated_mediakey(std::string* mediakey) { - if (mediakey != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mediakey_.IsDefault()) { - _impl_.mediakey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.mediaKey) -} - -// optional string mimetype = 5; -inline bool Message_StickerMessage::_internal_has_mimetype() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool Message_StickerMessage::has_mimetype() const { - return _internal_has_mimetype(); -} -inline void Message_StickerMessage::clear_mimetype() { - _impl_.mimetype_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const std::string& Message_StickerMessage::mimetype() const { - // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.mimetype) - return _internal_mimetype(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_StickerMessage::set_mimetype(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.mimetype_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.mimetype) -} -inline std::string* Message_StickerMessage::mutable_mimetype() { - std::string* _s = _internal_mutable_mimetype(); - // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.mimetype) - return _s; -} -inline const std::string& Message_StickerMessage::_internal_mimetype() const { - return _impl_.mimetype_.Get(); -} -inline void Message_StickerMessage::_internal_set_mimetype(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.mimetype_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_StickerMessage::_internal_mutable_mimetype() { - _impl_._has_bits_[0] |= 0x00000010u; - return _impl_.mimetype_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_StickerMessage::release_mimetype() { - // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.mimetype) - if (!_internal_has_mimetype()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000010u; - auto* p = _impl_.mimetype_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mimetype_.IsDefault()) { - _impl_.mimetype_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_StickerMessage::set_allocated_mimetype(std::string* mimetype) { - if (mimetype != nullptr) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mimetype_.IsDefault()) { - _impl_.mimetype_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.mimetype) -} - -// optional uint32 height = 6; -inline bool Message_StickerMessage::_internal_has_height() const { - bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; - return value; -} -inline bool Message_StickerMessage::has_height() const { - return _internal_has_height(); -} -inline void Message_StickerMessage::clear_height() { - _impl_.height_ = 0u; - _impl_._has_bits_[0] &= ~0x00000200u; -} -inline uint32_t Message_StickerMessage::_internal_height() const { - return _impl_.height_; -} -inline uint32_t Message_StickerMessage::height() const { - // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.height) - return _internal_height(); -} -inline void Message_StickerMessage::_internal_set_height(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.height_ = value; -} -inline void Message_StickerMessage::set_height(uint32_t value) { - _internal_set_height(value); - // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.height) -} - -// optional uint32 width = 7; -inline bool Message_StickerMessage::_internal_has_width() const { - bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; - return value; -} -inline bool Message_StickerMessage::has_width() const { - return _internal_has_width(); -} -inline void Message_StickerMessage::clear_width() { - _impl_.width_ = 0u; - _impl_._has_bits_[0] &= ~0x00000400u; -} -inline uint32_t Message_StickerMessage::_internal_width() const { - return _impl_.width_; -} -inline uint32_t Message_StickerMessage::width() const { - // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.width) - return _internal_width(); -} -inline void Message_StickerMessage::_internal_set_width(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000400u; - _impl_.width_ = value; -} -inline void Message_StickerMessage::set_width(uint32_t value) { - _internal_set_width(value); - // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.width) -} - -// optional string directPath = 8; -inline bool Message_StickerMessage::_internal_has_directpath() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool Message_StickerMessage::has_directpath() const { - return _internal_has_directpath(); -} -inline void Message_StickerMessage::clear_directpath() { - _impl_.directpath_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline const std::string& Message_StickerMessage::directpath() const { - // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.directPath) - return _internal_directpath(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_StickerMessage::set_directpath(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.directpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.directPath) -} -inline std::string* Message_StickerMessage::mutable_directpath() { - std::string* _s = _internal_mutable_directpath(); - // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.directPath) - return _s; -} -inline const std::string& Message_StickerMessage::_internal_directpath() const { - return _impl_.directpath_.Get(); -} -inline void Message_StickerMessage::_internal_set_directpath(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.directpath_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_StickerMessage::_internal_mutable_directpath() { - _impl_._has_bits_[0] |= 0x00000020u; - return _impl_.directpath_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_StickerMessage::release_directpath() { - // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.directPath) - if (!_internal_has_directpath()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000020u; - auto* p = _impl_.directpath_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.directpath_.IsDefault()) { - _impl_.directpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_StickerMessage::set_allocated_directpath(std::string* directpath) { - if (directpath != nullptr) { - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.directpath_.IsDefault()) { - _impl_.directpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.directPath) -} - -// optional uint64 fileLength = 9; -inline bool Message_StickerMessage::_internal_has_filelength() const { - bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; - return value; -} -inline bool Message_StickerMessage::has_filelength() const { - return _internal_has_filelength(); -} -inline void Message_StickerMessage::clear_filelength() { - _impl_.filelength_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000800u; -} -inline uint64_t Message_StickerMessage::_internal_filelength() const { - return _impl_.filelength_; -} -inline uint64_t Message_StickerMessage::filelength() const { - // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.fileLength) - return _internal_filelength(); -} -inline void Message_StickerMessage::_internal_set_filelength(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000800u; - _impl_.filelength_ = value; -} -inline void Message_StickerMessage::set_filelength(uint64_t value) { - _internal_set_filelength(value); - // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.fileLength) -} - -// optional int64 mediaKeyTimestamp = 10; -inline bool Message_StickerMessage::_internal_has_mediakeytimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; - return value; -} -inline bool Message_StickerMessage::has_mediakeytimestamp() const { - return _internal_has_mediakeytimestamp(); -} -inline void Message_StickerMessage::clear_mediakeytimestamp() { - _impl_.mediakeytimestamp_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00001000u; -} -inline int64_t Message_StickerMessage::_internal_mediakeytimestamp() const { - return _impl_.mediakeytimestamp_; -} -inline int64_t Message_StickerMessage::mediakeytimestamp() const { - // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.mediaKeyTimestamp) - return _internal_mediakeytimestamp(); -} -inline void Message_StickerMessage::_internal_set_mediakeytimestamp(int64_t value) { - _impl_._has_bits_[0] |= 0x00001000u; - _impl_.mediakeytimestamp_ = value; -} -inline void Message_StickerMessage::set_mediakeytimestamp(int64_t value) { - _internal_set_mediakeytimestamp(value); - // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.mediaKeyTimestamp) -} - -// optional uint32 firstFrameLength = 11; -inline bool Message_StickerMessage::_internal_has_firstframelength() const { - bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0; - return value; -} -inline bool Message_StickerMessage::has_firstframelength() const { - return _internal_has_firstframelength(); -} -inline void Message_StickerMessage::clear_firstframelength() { - _impl_.firstframelength_ = 0u; - _impl_._has_bits_[0] &= ~0x00002000u; -} -inline uint32_t Message_StickerMessage::_internal_firstframelength() const { - return _impl_.firstframelength_; -} -inline uint32_t Message_StickerMessage::firstframelength() const { - // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.firstFrameLength) - return _internal_firstframelength(); -} -inline void Message_StickerMessage::_internal_set_firstframelength(uint32_t value) { - _impl_._has_bits_[0] |= 0x00002000u; - _impl_.firstframelength_ = value; -} -inline void Message_StickerMessage::set_firstframelength(uint32_t value) { - _internal_set_firstframelength(value); - // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.firstFrameLength) -} - -// optional bytes firstFrameSidecar = 12; -inline bool Message_StickerMessage::_internal_has_firstframesidecar() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool Message_StickerMessage::has_firstframesidecar() const { - return _internal_has_firstframesidecar(); -} -inline void Message_StickerMessage::clear_firstframesidecar() { - _impl_.firstframesidecar_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline const std::string& Message_StickerMessage::firstframesidecar() const { - // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.firstFrameSidecar) - return _internal_firstframesidecar(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_StickerMessage::set_firstframesidecar(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.firstframesidecar_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.firstFrameSidecar) -} -inline std::string* Message_StickerMessage::mutable_firstframesidecar() { - std::string* _s = _internal_mutable_firstframesidecar(); - // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.firstFrameSidecar) - return _s; -} -inline const std::string& Message_StickerMessage::_internal_firstframesidecar() const { - return _impl_.firstframesidecar_.Get(); -} -inline void Message_StickerMessage::_internal_set_firstframesidecar(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.firstframesidecar_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_StickerMessage::_internal_mutable_firstframesidecar() { - _impl_._has_bits_[0] |= 0x00000040u; - return _impl_.firstframesidecar_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_StickerMessage::release_firstframesidecar() { - // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.firstFrameSidecar) - if (!_internal_has_firstframesidecar()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000040u; - auto* p = _impl_.firstframesidecar_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.firstframesidecar_.IsDefault()) { - _impl_.firstframesidecar_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_StickerMessage::set_allocated_firstframesidecar(std::string* firstframesidecar) { - if (firstframesidecar != nullptr) { - _impl_._has_bits_[0] |= 0x00000040u; - } else { - _impl_._has_bits_[0] &= ~0x00000040u; - } - _impl_.firstframesidecar_.SetAllocated(firstframesidecar, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.firstframesidecar_.IsDefault()) { - _impl_.firstframesidecar_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.firstFrameSidecar) -} - -// optional bool isAnimated = 13; -inline bool Message_StickerMessage::_internal_has_isanimated() const { - bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0; - return value; -} -inline bool Message_StickerMessage::has_isanimated() const { - return _internal_has_isanimated(); -} -inline void Message_StickerMessage::clear_isanimated() { - _impl_.isanimated_ = false; - _impl_._has_bits_[0] &= ~0x00004000u; -} -inline bool Message_StickerMessage::_internal_isanimated() const { - return _impl_.isanimated_; -} -inline bool Message_StickerMessage::isanimated() const { - // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.isAnimated) - return _internal_isanimated(); -} -inline void Message_StickerMessage::_internal_set_isanimated(bool value) { - _impl_._has_bits_[0] |= 0x00004000u; - _impl_.isanimated_ = value; -} -inline void Message_StickerMessage::set_isanimated(bool value) { - _internal_set_isanimated(value); - // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.isAnimated) -} - -// optional bytes pngThumbnail = 16; -inline bool Message_StickerMessage::_internal_has_pngthumbnail() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - return value; -} -inline bool Message_StickerMessage::has_pngthumbnail() const { - return _internal_has_pngthumbnail(); -} -inline void Message_StickerMessage::clear_pngthumbnail() { - _impl_.pngthumbnail_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline const std::string& Message_StickerMessage::pngthumbnail() const { - // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.pngThumbnail) - return _internal_pngthumbnail(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_StickerMessage::set_pngthumbnail(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.pngthumbnail_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.pngThumbnail) -} -inline std::string* Message_StickerMessage::mutable_pngthumbnail() { - std::string* _s = _internal_mutable_pngthumbnail(); - // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.pngThumbnail) - return _s; -} -inline const std::string& Message_StickerMessage::_internal_pngthumbnail() const { - return _impl_.pngthumbnail_.Get(); -} -inline void Message_StickerMessage::_internal_set_pngthumbnail(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.pngthumbnail_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_StickerMessage::_internal_mutable_pngthumbnail() { - _impl_._has_bits_[0] |= 0x00000080u; - return _impl_.pngthumbnail_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_StickerMessage::release_pngthumbnail() { - // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.pngThumbnail) - if (!_internal_has_pngthumbnail()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000080u; - auto* p = _impl_.pngthumbnail_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.pngthumbnail_.IsDefault()) { - _impl_.pngthumbnail_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_StickerMessage::set_allocated_pngthumbnail(std::string* pngthumbnail) { - if (pngthumbnail != nullptr) { - _impl_._has_bits_[0] |= 0x00000080u; - } else { - _impl_._has_bits_[0] &= ~0x00000080u; - } - _impl_.pngthumbnail_.SetAllocated(pngthumbnail, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.pngthumbnail_.IsDefault()) { - _impl_.pngthumbnail_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.pngThumbnail) -} - -// optional .proto.ContextInfo contextInfo = 17; -inline bool Message_StickerMessage::_internal_has_contextinfo() const { - bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; - PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); - return value; -} -inline bool Message_StickerMessage::has_contextinfo() const { - return _internal_has_contextinfo(); -} -inline void Message_StickerMessage::clear_contextinfo() { - if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); - _impl_._has_bits_[0] &= ~0x00000100u; -} -inline const ::proto::ContextInfo& Message_StickerMessage::_internal_contextinfo() const { - const ::proto::ContextInfo* p = _impl_.contextinfo_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ContextInfo_default_instance_); -} -inline const ::proto::ContextInfo& Message_StickerMessage::contextinfo() const { - // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.contextInfo) - return _internal_contextinfo(); -} -inline void Message_StickerMessage::unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); - } - _impl_.contextinfo_ = contextinfo; - if (contextinfo) { - _impl_._has_bits_[0] |= 0x00000100u; - } else { - _impl_._has_bits_[0] &= ~0x00000100u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.StickerMessage.contextInfo) -} -inline ::proto::ContextInfo* Message_StickerMessage::release_contextinfo() { - _impl_._has_bits_[0] &= ~0x00000100u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ContextInfo* Message_StickerMessage::unsafe_arena_release_contextinfo() { - // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.contextInfo) - _impl_._has_bits_[0] &= ~0x00000100u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; - return temp; -} -inline ::proto::ContextInfo* Message_StickerMessage::_internal_mutable_contextinfo() { - _impl_._has_bits_[0] |= 0x00000100u; - if (_impl_.contextinfo_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); - _impl_.contextinfo_ = p; - } - return _impl_.contextinfo_; -} -inline ::proto::ContextInfo* Message_StickerMessage::mutable_contextinfo() { - ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); - // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.contextInfo) - return _msg; -} -inline void Message_StickerMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.contextinfo_; - } - if (contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); - if (message_arena != submessage_arena) { - contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, contextinfo, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000100u; - } else { - _impl_._has_bits_[0] &= ~0x00000100u; - } - _impl_.contextinfo_ = contextinfo; - // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.contextInfo) -} - -// ------------------------------------------------------------------- - -// Message_StickerSyncRMRMessage - -// repeated string filehash = 1; -inline int Message_StickerSyncRMRMessage::_internal_filehash_size() const { - return _impl_.filehash_.size(); -} -inline int Message_StickerSyncRMRMessage::filehash_size() const { - return _internal_filehash_size(); -} -inline void Message_StickerSyncRMRMessage::clear_filehash() { - _impl_.filehash_.Clear(); -} -inline std::string* Message_StickerSyncRMRMessage::add_filehash() { - std::string* _s = _internal_add_filehash(); - // @@protoc_insertion_point(field_add_mutable:proto.Message.StickerSyncRMRMessage.filehash) - return _s; -} -inline const std::string& Message_StickerSyncRMRMessage::_internal_filehash(int index) const { - return _impl_.filehash_.Get(index); -} -inline const std::string& Message_StickerSyncRMRMessage::filehash(int index) const { - // @@protoc_insertion_point(field_get:proto.Message.StickerSyncRMRMessage.filehash) - return _internal_filehash(index); -} -inline std::string* Message_StickerSyncRMRMessage::mutable_filehash(int index) { - // @@protoc_insertion_point(field_mutable:proto.Message.StickerSyncRMRMessage.filehash) - return _impl_.filehash_.Mutable(index); -} -inline void Message_StickerSyncRMRMessage::set_filehash(int index, const std::string& value) { - _impl_.filehash_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:proto.Message.StickerSyncRMRMessage.filehash) -} -inline void Message_StickerSyncRMRMessage::set_filehash(int index, std::string&& value) { - _impl_.filehash_.Mutable(index)->assign(std::move(value)); - // @@protoc_insertion_point(field_set:proto.Message.StickerSyncRMRMessage.filehash) -} -inline void Message_StickerSyncRMRMessage::set_filehash(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - _impl_.filehash_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:proto.Message.StickerSyncRMRMessage.filehash) -} -inline void Message_StickerSyncRMRMessage::set_filehash(int index, const char* value, size_t size) { - _impl_.filehash_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:proto.Message.StickerSyncRMRMessage.filehash) -} -inline std::string* Message_StickerSyncRMRMessage::_internal_add_filehash() { - return _impl_.filehash_.Add(); -} -inline void Message_StickerSyncRMRMessage::add_filehash(const std::string& value) { - _impl_.filehash_.Add()->assign(value); - // @@protoc_insertion_point(field_add:proto.Message.StickerSyncRMRMessage.filehash) -} -inline void Message_StickerSyncRMRMessage::add_filehash(std::string&& value) { - _impl_.filehash_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:proto.Message.StickerSyncRMRMessage.filehash) -} -inline void Message_StickerSyncRMRMessage::add_filehash(const char* value) { - GOOGLE_DCHECK(value != nullptr); - _impl_.filehash_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:proto.Message.StickerSyncRMRMessage.filehash) -} -inline void Message_StickerSyncRMRMessage::add_filehash(const char* value, size_t size) { - _impl_.filehash_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:proto.Message.StickerSyncRMRMessage.filehash) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -Message_StickerSyncRMRMessage::filehash() const { - // @@protoc_insertion_point(field_list:proto.Message.StickerSyncRMRMessage.filehash) - return _impl_.filehash_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -Message_StickerSyncRMRMessage::mutable_filehash() { - // @@protoc_insertion_point(field_mutable_list:proto.Message.StickerSyncRMRMessage.filehash) - return &_impl_.filehash_; -} - -// optional string rmrSource = 2; -inline bool Message_StickerSyncRMRMessage::_internal_has_rmrsource() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_StickerSyncRMRMessage::has_rmrsource() const { - return _internal_has_rmrsource(); -} -inline void Message_StickerSyncRMRMessage::clear_rmrsource() { - _impl_.rmrsource_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_StickerSyncRMRMessage::rmrsource() const { - // @@protoc_insertion_point(field_get:proto.Message.StickerSyncRMRMessage.rmrSource) - return _internal_rmrsource(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_StickerSyncRMRMessage::set_rmrsource(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.rmrsource_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.StickerSyncRMRMessage.rmrSource) -} -inline std::string* Message_StickerSyncRMRMessage::mutable_rmrsource() { - std::string* _s = _internal_mutable_rmrsource(); - // @@protoc_insertion_point(field_mutable:proto.Message.StickerSyncRMRMessage.rmrSource) - return _s; -} -inline const std::string& Message_StickerSyncRMRMessage::_internal_rmrsource() const { - return _impl_.rmrsource_.Get(); -} -inline void Message_StickerSyncRMRMessage::_internal_set_rmrsource(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.rmrsource_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_StickerSyncRMRMessage::_internal_mutable_rmrsource() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.rmrsource_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_StickerSyncRMRMessage::release_rmrsource() { - // @@protoc_insertion_point(field_release:proto.Message.StickerSyncRMRMessage.rmrSource) - if (!_internal_has_rmrsource()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.rmrsource_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.rmrsource_.IsDefault()) { - _impl_.rmrsource_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_StickerSyncRMRMessage::set_allocated_rmrsource(std::string* rmrsource) { - if (rmrsource != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.rmrsource_.SetAllocated(rmrsource, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.rmrsource_.IsDefault()) { - _impl_.rmrsource_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerSyncRMRMessage.rmrSource) -} - -// optional int64 requestTimestamp = 3; -inline bool Message_StickerSyncRMRMessage::_internal_has_requesttimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_StickerSyncRMRMessage::has_requesttimestamp() const { - return _internal_has_requesttimestamp(); -} -inline void Message_StickerSyncRMRMessage::clear_requesttimestamp() { - _impl_.requesttimestamp_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline int64_t Message_StickerSyncRMRMessage::_internal_requesttimestamp() const { - return _impl_.requesttimestamp_; -} -inline int64_t Message_StickerSyncRMRMessage::requesttimestamp() const { - // @@protoc_insertion_point(field_get:proto.Message.StickerSyncRMRMessage.requestTimestamp) - return _internal_requesttimestamp(); -} -inline void Message_StickerSyncRMRMessage::_internal_set_requesttimestamp(int64_t value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.requesttimestamp_ = value; -} -inline void Message_StickerSyncRMRMessage::set_requesttimestamp(int64_t value) { - _internal_set_requesttimestamp(value); - // @@protoc_insertion_point(field_set:proto.Message.StickerSyncRMRMessage.requestTimestamp) -} - -// ------------------------------------------------------------------- - -// Message_TemplateButtonReplyMessage - -// optional string selectedId = 1; -inline bool Message_TemplateButtonReplyMessage::_internal_has_selectedid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_TemplateButtonReplyMessage::has_selectedid() const { - return _internal_has_selectedid(); -} -inline void Message_TemplateButtonReplyMessage::clear_selectedid() { - _impl_.selectedid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_TemplateButtonReplyMessage::selectedid() const { - // @@protoc_insertion_point(field_get:proto.Message.TemplateButtonReplyMessage.selectedId) - return _internal_selectedid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_TemplateButtonReplyMessage::set_selectedid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.selectedid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.TemplateButtonReplyMessage.selectedId) -} -inline std::string* Message_TemplateButtonReplyMessage::mutable_selectedid() { - std::string* _s = _internal_mutable_selectedid(); - // @@protoc_insertion_point(field_mutable:proto.Message.TemplateButtonReplyMessage.selectedId) - return _s; -} -inline const std::string& Message_TemplateButtonReplyMessage::_internal_selectedid() const { - return _impl_.selectedid_.Get(); -} -inline void Message_TemplateButtonReplyMessage::_internal_set_selectedid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.selectedid_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_TemplateButtonReplyMessage::_internal_mutable_selectedid() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.selectedid_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_TemplateButtonReplyMessage::release_selectedid() { - // @@protoc_insertion_point(field_release:proto.Message.TemplateButtonReplyMessage.selectedId) - if (!_internal_has_selectedid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.selectedid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.selectedid_.IsDefault()) { - _impl_.selectedid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_TemplateButtonReplyMessage::set_allocated_selectedid(std::string* selectedid) { - if (selectedid != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.selectedid_.SetAllocated(selectedid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.selectedid_.IsDefault()) { - _impl_.selectedid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateButtonReplyMessage.selectedId) -} - -// optional string selectedDisplayText = 2; -inline bool Message_TemplateButtonReplyMessage::_internal_has_selecteddisplaytext() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_TemplateButtonReplyMessage::has_selecteddisplaytext() const { - return _internal_has_selecteddisplaytext(); -} -inline void Message_TemplateButtonReplyMessage::clear_selecteddisplaytext() { - _impl_.selecteddisplaytext_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_TemplateButtonReplyMessage::selecteddisplaytext() const { - // @@protoc_insertion_point(field_get:proto.Message.TemplateButtonReplyMessage.selectedDisplayText) - return _internal_selecteddisplaytext(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_TemplateButtonReplyMessage::set_selecteddisplaytext(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.selecteddisplaytext_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.TemplateButtonReplyMessage.selectedDisplayText) -} -inline std::string* Message_TemplateButtonReplyMessage::mutable_selecteddisplaytext() { - std::string* _s = _internal_mutable_selecteddisplaytext(); - // @@protoc_insertion_point(field_mutable:proto.Message.TemplateButtonReplyMessage.selectedDisplayText) - return _s; -} -inline const std::string& Message_TemplateButtonReplyMessage::_internal_selecteddisplaytext() const { - return _impl_.selecteddisplaytext_.Get(); -} -inline void Message_TemplateButtonReplyMessage::_internal_set_selecteddisplaytext(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.selecteddisplaytext_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_TemplateButtonReplyMessage::_internal_mutable_selecteddisplaytext() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.selecteddisplaytext_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_TemplateButtonReplyMessage::release_selecteddisplaytext() { - // @@protoc_insertion_point(field_release:proto.Message.TemplateButtonReplyMessage.selectedDisplayText) - if (!_internal_has_selecteddisplaytext()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.selecteddisplaytext_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.selecteddisplaytext_.IsDefault()) { - _impl_.selecteddisplaytext_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_TemplateButtonReplyMessage::set_allocated_selecteddisplaytext(std::string* selecteddisplaytext) { - if (selecteddisplaytext != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.selecteddisplaytext_.SetAllocated(selecteddisplaytext, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.selecteddisplaytext_.IsDefault()) { - _impl_.selecteddisplaytext_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateButtonReplyMessage.selectedDisplayText) -} - -// optional .proto.ContextInfo contextInfo = 3; -inline bool Message_TemplateButtonReplyMessage::_internal_has_contextinfo() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); - return value; -} -inline bool Message_TemplateButtonReplyMessage::has_contextinfo() const { - return _internal_has_contextinfo(); -} -inline void Message_TemplateButtonReplyMessage::clear_contextinfo() { - if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const ::proto::ContextInfo& Message_TemplateButtonReplyMessage::_internal_contextinfo() const { - const ::proto::ContextInfo* p = _impl_.contextinfo_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ContextInfo_default_instance_); -} -inline const ::proto::ContextInfo& Message_TemplateButtonReplyMessage::contextinfo() const { - // @@protoc_insertion_point(field_get:proto.Message.TemplateButtonReplyMessage.contextInfo) - return _internal_contextinfo(); -} -inline void Message_TemplateButtonReplyMessage::unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); - } - _impl_.contextinfo_ = contextinfo; - if (contextinfo) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateButtonReplyMessage.contextInfo) -} -inline ::proto::ContextInfo* Message_TemplateButtonReplyMessage::release_contextinfo() { - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ContextInfo* Message_TemplateButtonReplyMessage::unsafe_arena_release_contextinfo() { - // @@protoc_insertion_point(field_release:proto.Message.TemplateButtonReplyMessage.contextInfo) - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; - return temp; -} -inline ::proto::ContextInfo* Message_TemplateButtonReplyMessage::_internal_mutable_contextinfo() { - _impl_._has_bits_[0] |= 0x00000004u; - if (_impl_.contextinfo_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); - _impl_.contextinfo_ = p; - } - return _impl_.contextinfo_; -} -inline ::proto::ContextInfo* Message_TemplateButtonReplyMessage::mutable_contextinfo() { - ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); - // @@protoc_insertion_point(field_mutable:proto.Message.TemplateButtonReplyMessage.contextInfo) - return _msg; -} -inline void Message_TemplateButtonReplyMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.contextinfo_; - } - if (contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); - if (message_arena != submessage_arena) { - contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, contextinfo, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.contextinfo_ = contextinfo; - // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateButtonReplyMessage.contextInfo) -} - -// optional uint32 selectedIndex = 4; -inline bool Message_TemplateButtonReplyMessage::_internal_has_selectedindex() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool Message_TemplateButtonReplyMessage::has_selectedindex() const { - return _internal_has_selectedindex(); -} -inline void Message_TemplateButtonReplyMessage::clear_selectedindex() { - _impl_.selectedindex_ = 0u; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline uint32_t Message_TemplateButtonReplyMessage::_internal_selectedindex() const { - return _impl_.selectedindex_; -} -inline uint32_t Message_TemplateButtonReplyMessage::selectedindex() const { - // @@protoc_insertion_point(field_get:proto.Message.TemplateButtonReplyMessage.selectedIndex) - return _internal_selectedindex(); -} -inline void Message_TemplateButtonReplyMessage::_internal_set_selectedindex(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.selectedindex_ = value; -} -inline void Message_TemplateButtonReplyMessage::set_selectedindex(uint32_t value) { - _internal_set_selectedindex(value); - // @@protoc_insertion_point(field_set:proto.Message.TemplateButtonReplyMessage.selectedIndex) -} - -// ------------------------------------------------------------------- - -// Message_TemplateMessage_FourRowTemplate - -// optional .proto.Message.HighlyStructuredMessage content = 6; -inline bool Message_TemplateMessage_FourRowTemplate::_internal_has_content() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.content_ != nullptr); - return value; -} -inline bool Message_TemplateMessage_FourRowTemplate::has_content() const { - return _internal_has_content(); -} -inline void Message_TemplateMessage_FourRowTemplate::clear_content() { - if (_impl_.content_ != nullptr) _impl_.content_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::Message_HighlyStructuredMessage& Message_TemplateMessage_FourRowTemplate::_internal_content() const { - const ::proto::Message_HighlyStructuredMessage* p = _impl_.content_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_HighlyStructuredMessage_default_instance_); -} -inline const ::proto::Message_HighlyStructuredMessage& Message_TemplateMessage_FourRowTemplate::content() const { - // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.content) - return _internal_content(); -} -inline void Message_TemplateMessage_FourRowTemplate::unsafe_arena_set_allocated_content( - ::proto::Message_HighlyStructuredMessage* content) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.content_); - } - _impl_.content_ = content; - if (content) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.content) -} -inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::release_content() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::Message_HighlyStructuredMessage* temp = _impl_.content_; - _impl_.content_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::unsafe_arena_release_content() { - // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.FourRowTemplate.content) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::Message_HighlyStructuredMessage* temp = _impl_.content_; - _impl_.content_ = nullptr; - return temp; -} -inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::_internal_mutable_content() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.content_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation()); - _impl_.content_ = p; - } - return _impl_.content_; -} -inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::mutable_content() { - ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_content(); - // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.content) - return _msg; -} -inline void Message_TemplateMessage_FourRowTemplate::set_allocated_content(::proto::Message_HighlyStructuredMessage* content) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.content_; - } - if (content) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(content); - if (message_arena != submessage_arena) { - content = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, content, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.content_ = content; - // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.content) -} - -// optional .proto.Message.HighlyStructuredMessage footer = 7; -inline bool Message_TemplateMessage_FourRowTemplate::_internal_has_footer() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.footer_ != nullptr); - return value; -} -inline bool Message_TemplateMessage_FourRowTemplate::has_footer() const { - return _internal_has_footer(); -} -inline void Message_TemplateMessage_FourRowTemplate::clear_footer() { - if (_impl_.footer_ != nullptr) _impl_.footer_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::Message_HighlyStructuredMessage& Message_TemplateMessage_FourRowTemplate::_internal_footer() const { - const ::proto::Message_HighlyStructuredMessage* p = _impl_.footer_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_HighlyStructuredMessage_default_instance_); -} -inline const ::proto::Message_HighlyStructuredMessage& Message_TemplateMessage_FourRowTemplate::footer() const { - // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.footer) - return _internal_footer(); -} -inline void Message_TemplateMessage_FourRowTemplate::unsafe_arena_set_allocated_footer( - ::proto::Message_HighlyStructuredMessage* footer) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.footer_); - } - _impl_.footer_ = footer; - if (footer) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.footer) -} -inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::release_footer() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::Message_HighlyStructuredMessage* temp = _impl_.footer_; - _impl_.footer_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::unsafe_arena_release_footer() { - // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.FourRowTemplate.footer) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::Message_HighlyStructuredMessage* temp = _impl_.footer_; - _impl_.footer_ = nullptr; - return temp; -} -inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::_internal_mutable_footer() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.footer_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation()); - _impl_.footer_ = p; - } - return _impl_.footer_; -} -inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::mutable_footer() { - ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_footer(); - // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.footer) - return _msg; -} -inline void Message_TemplateMessage_FourRowTemplate::set_allocated_footer(::proto::Message_HighlyStructuredMessage* footer) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.footer_; - } - if (footer) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(footer); - if (message_arena != submessage_arena) { - footer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, footer, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.footer_ = footer; - // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.footer) -} - -// repeated .proto.TemplateButton buttons = 8; -inline int Message_TemplateMessage_FourRowTemplate::_internal_buttons_size() const { - return _impl_.buttons_.size(); -} -inline int Message_TemplateMessage_FourRowTemplate::buttons_size() const { - return _internal_buttons_size(); -} -inline void Message_TemplateMessage_FourRowTemplate::clear_buttons() { - _impl_.buttons_.Clear(); -} -inline ::proto::TemplateButton* Message_TemplateMessage_FourRowTemplate::mutable_buttons(int index) { - // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.buttons) - return _impl_.buttons_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::TemplateButton >* -Message_TemplateMessage_FourRowTemplate::mutable_buttons() { - // @@protoc_insertion_point(field_mutable_list:proto.Message.TemplateMessage.FourRowTemplate.buttons) - return &_impl_.buttons_; -} -inline const ::proto::TemplateButton& Message_TemplateMessage_FourRowTemplate::_internal_buttons(int index) const { - return _impl_.buttons_.Get(index); -} -inline const ::proto::TemplateButton& Message_TemplateMessage_FourRowTemplate::buttons(int index) const { - // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.buttons) - return _internal_buttons(index); -} -inline ::proto::TemplateButton* Message_TemplateMessage_FourRowTemplate::_internal_add_buttons() { - return _impl_.buttons_.Add(); -} -inline ::proto::TemplateButton* Message_TemplateMessage_FourRowTemplate::add_buttons() { - ::proto::TemplateButton* _add = _internal_add_buttons(); - // @@protoc_insertion_point(field_add:proto.Message.TemplateMessage.FourRowTemplate.buttons) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::TemplateButton >& -Message_TemplateMessage_FourRowTemplate::buttons() const { - // @@protoc_insertion_point(field_list:proto.Message.TemplateMessage.FourRowTemplate.buttons) - return _impl_.buttons_; -} - -// .proto.Message.DocumentMessage documentMessage = 1; -inline bool Message_TemplateMessage_FourRowTemplate::_internal_has_documentmessage() const { - return title_case() == kDocumentMessage; -} -inline bool Message_TemplateMessage_FourRowTemplate::has_documentmessage() const { - return _internal_has_documentmessage(); -} -inline void Message_TemplateMessage_FourRowTemplate::set_has_documentmessage() { - _impl_._oneof_case_[0] = kDocumentMessage; -} -inline void Message_TemplateMessage_FourRowTemplate::clear_documentmessage() { - if (_internal_has_documentmessage()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.title_.documentmessage_; - } - clear_has_title(); - } -} -inline ::proto::Message_DocumentMessage* Message_TemplateMessage_FourRowTemplate::release_documentmessage() { - // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.FourRowTemplate.documentMessage) - if (_internal_has_documentmessage()) { - clear_has_title(); - ::proto::Message_DocumentMessage* temp = _impl_.title_.documentmessage_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.title_.documentmessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::Message_DocumentMessage& Message_TemplateMessage_FourRowTemplate::_internal_documentmessage() const { - return _internal_has_documentmessage() - ? *_impl_.title_.documentmessage_ - : reinterpret_cast< ::proto::Message_DocumentMessage&>(::proto::_Message_DocumentMessage_default_instance_); -} -inline const ::proto::Message_DocumentMessage& Message_TemplateMessage_FourRowTemplate::documentmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.documentMessage) - return _internal_documentmessage(); -} -inline ::proto::Message_DocumentMessage* Message_TemplateMessage_FourRowTemplate::unsafe_arena_release_documentmessage() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.FourRowTemplate.documentMessage) - if (_internal_has_documentmessage()) { - clear_has_title(); - ::proto::Message_DocumentMessage* temp = _impl_.title_.documentmessage_; - _impl_.title_.documentmessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Message_TemplateMessage_FourRowTemplate::unsafe_arena_set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) { - clear_title(); - if (documentmessage) { - set_has_documentmessage(); - _impl_.title_.documentmessage_ = documentmessage; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.documentMessage) -} -inline ::proto::Message_DocumentMessage* Message_TemplateMessage_FourRowTemplate::_internal_mutable_documentmessage() { - if (!_internal_has_documentmessage()) { - clear_title(); - set_has_documentmessage(); - _impl_.title_.documentmessage_ = CreateMaybeMessage< ::proto::Message_DocumentMessage >(GetArenaForAllocation()); - } - return _impl_.title_.documentmessage_; -} -inline ::proto::Message_DocumentMessage* Message_TemplateMessage_FourRowTemplate::mutable_documentmessage() { - ::proto::Message_DocumentMessage* _msg = _internal_mutable_documentmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.documentMessage) - return _msg; -} - -// .proto.Message.HighlyStructuredMessage highlyStructuredMessage = 2; -inline bool Message_TemplateMessage_FourRowTemplate::_internal_has_highlystructuredmessage() const { - return title_case() == kHighlyStructuredMessage; -} -inline bool Message_TemplateMessage_FourRowTemplate::has_highlystructuredmessage() const { - return _internal_has_highlystructuredmessage(); -} -inline void Message_TemplateMessage_FourRowTemplate::set_has_highlystructuredmessage() { - _impl_._oneof_case_[0] = kHighlyStructuredMessage; -} -inline void Message_TemplateMessage_FourRowTemplate::clear_highlystructuredmessage() { - if (_internal_has_highlystructuredmessage()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.title_.highlystructuredmessage_; - } - clear_has_title(); - } -} -inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::release_highlystructuredmessage() { - // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.FourRowTemplate.highlyStructuredMessage) - if (_internal_has_highlystructuredmessage()) { - clear_has_title(); - ::proto::Message_HighlyStructuredMessage* temp = _impl_.title_.highlystructuredmessage_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.title_.highlystructuredmessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::Message_HighlyStructuredMessage& Message_TemplateMessage_FourRowTemplate::_internal_highlystructuredmessage() const { - return _internal_has_highlystructuredmessage() - ? *_impl_.title_.highlystructuredmessage_ - : reinterpret_cast< ::proto::Message_HighlyStructuredMessage&>(::proto::_Message_HighlyStructuredMessage_default_instance_); -} -inline const ::proto::Message_HighlyStructuredMessage& Message_TemplateMessage_FourRowTemplate::highlystructuredmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.highlyStructuredMessage) - return _internal_highlystructuredmessage(); -} -inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::unsafe_arena_release_highlystructuredmessage() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.FourRowTemplate.highlyStructuredMessage) - if (_internal_has_highlystructuredmessage()) { - clear_has_title(); - ::proto::Message_HighlyStructuredMessage* temp = _impl_.title_.highlystructuredmessage_; - _impl_.title_.highlystructuredmessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Message_TemplateMessage_FourRowTemplate::unsafe_arena_set_allocated_highlystructuredmessage(::proto::Message_HighlyStructuredMessage* highlystructuredmessage) { - clear_title(); - if (highlystructuredmessage) { - set_has_highlystructuredmessage(); - _impl_.title_.highlystructuredmessage_ = highlystructuredmessage; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.highlyStructuredMessage) -} -inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::_internal_mutable_highlystructuredmessage() { - if (!_internal_has_highlystructuredmessage()) { - clear_title(); - set_has_highlystructuredmessage(); - _impl_.title_.highlystructuredmessage_ = CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage >(GetArenaForAllocation()); - } - return _impl_.title_.highlystructuredmessage_; -} -inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::mutable_highlystructuredmessage() { - ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_highlystructuredmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.highlyStructuredMessage) - return _msg; -} - -// .proto.Message.ImageMessage imageMessage = 3; -inline bool Message_TemplateMessage_FourRowTemplate::_internal_has_imagemessage() const { - return title_case() == kImageMessage; -} -inline bool Message_TemplateMessage_FourRowTemplate::has_imagemessage() const { - return _internal_has_imagemessage(); -} -inline void Message_TemplateMessage_FourRowTemplate::set_has_imagemessage() { - _impl_._oneof_case_[0] = kImageMessage; -} -inline void Message_TemplateMessage_FourRowTemplate::clear_imagemessage() { - if (_internal_has_imagemessage()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.title_.imagemessage_; - } - clear_has_title(); - } -} -inline ::proto::Message_ImageMessage* Message_TemplateMessage_FourRowTemplate::release_imagemessage() { - // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.FourRowTemplate.imageMessage) - if (_internal_has_imagemessage()) { - clear_has_title(); - ::proto::Message_ImageMessage* temp = _impl_.title_.imagemessage_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.title_.imagemessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::Message_ImageMessage& Message_TemplateMessage_FourRowTemplate::_internal_imagemessage() const { - return _internal_has_imagemessage() - ? *_impl_.title_.imagemessage_ - : reinterpret_cast< ::proto::Message_ImageMessage&>(::proto::_Message_ImageMessage_default_instance_); -} -inline const ::proto::Message_ImageMessage& Message_TemplateMessage_FourRowTemplate::imagemessage() const { - // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.imageMessage) - return _internal_imagemessage(); -} -inline ::proto::Message_ImageMessage* Message_TemplateMessage_FourRowTemplate::unsafe_arena_release_imagemessage() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.FourRowTemplate.imageMessage) - if (_internal_has_imagemessage()) { - clear_has_title(); - ::proto::Message_ImageMessage* temp = _impl_.title_.imagemessage_; - _impl_.title_.imagemessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Message_TemplateMessage_FourRowTemplate::unsafe_arena_set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) { - clear_title(); - if (imagemessage) { - set_has_imagemessage(); - _impl_.title_.imagemessage_ = imagemessage; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.imageMessage) -} -inline ::proto::Message_ImageMessage* Message_TemplateMessage_FourRowTemplate::_internal_mutable_imagemessage() { - if (!_internal_has_imagemessage()) { - clear_title(); - set_has_imagemessage(); - _impl_.title_.imagemessage_ = CreateMaybeMessage< ::proto::Message_ImageMessage >(GetArenaForAllocation()); - } - return _impl_.title_.imagemessage_; -} -inline ::proto::Message_ImageMessage* Message_TemplateMessage_FourRowTemplate::mutable_imagemessage() { - ::proto::Message_ImageMessage* _msg = _internal_mutable_imagemessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.imageMessage) - return _msg; -} - -// .proto.Message.VideoMessage videoMessage = 4; -inline bool Message_TemplateMessage_FourRowTemplate::_internal_has_videomessage() const { - return title_case() == kVideoMessage; -} -inline bool Message_TemplateMessage_FourRowTemplate::has_videomessage() const { - return _internal_has_videomessage(); -} -inline void Message_TemplateMessage_FourRowTemplate::set_has_videomessage() { - _impl_._oneof_case_[0] = kVideoMessage; -} -inline void Message_TemplateMessage_FourRowTemplate::clear_videomessage() { - if (_internal_has_videomessage()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.title_.videomessage_; - } - clear_has_title(); - } -} -inline ::proto::Message_VideoMessage* Message_TemplateMessage_FourRowTemplate::release_videomessage() { - // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.FourRowTemplate.videoMessage) - if (_internal_has_videomessage()) { - clear_has_title(); - ::proto::Message_VideoMessage* temp = _impl_.title_.videomessage_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.title_.videomessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::Message_VideoMessage& Message_TemplateMessage_FourRowTemplate::_internal_videomessage() const { - return _internal_has_videomessage() - ? *_impl_.title_.videomessage_ - : reinterpret_cast< ::proto::Message_VideoMessage&>(::proto::_Message_VideoMessage_default_instance_); -} -inline const ::proto::Message_VideoMessage& Message_TemplateMessage_FourRowTemplate::videomessage() const { - // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.videoMessage) - return _internal_videomessage(); -} -inline ::proto::Message_VideoMessage* Message_TemplateMessage_FourRowTemplate::unsafe_arena_release_videomessage() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.FourRowTemplate.videoMessage) - if (_internal_has_videomessage()) { - clear_has_title(); - ::proto::Message_VideoMessage* temp = _impl_.title_.videomessage_; - _impl_.title_.videomessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Message_TemplateMessage_FourRowTemplate::unsafe_arena_set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) { - clear_title(); - if (videomessage) { - set_has_videomessage(); - _impl_.title_.videomessage_ = videomessage; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.videoMessage) -} -inline ::proto::Message_VideoMessage* Message_TemplateMessage_FourRowTemplate::_internal_mutable_videomessage() { - if (!_internal_has_videomessage()) { - clear_title(); - set_has_videomessage(); - _impl_.title_.videomessage_ = CreateMaybeMessage< ::proto::Message_VideoMessage >(GetArenaForAllocation()); - } - return _impl_.title_.videomessage_; -} -inline ::proto::Message_VideoMessage* Message_TemplateMessage_FourRowTemplate::mutable_videomessage() { - ::proto::Message_VideoMessage* _msg = _internal_mutable_videomessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.videoMessage) - return _msg; -} - -// .proto.Message.LocationMessage locationMessage = 5; -inline bool Message_TemplateMessage_FourRowTemplate::_internal_has_locationmessage() const { - return title_case() == kLocationMessage; -} -inline bool Message_TemplateMessage_FourRowTemplate::has_locationmessage() const { - return _internal_has_locationmessage(); -} -inline void Message_TemplateMessage_FourRowTemplate::set_has_locationmessage() { - _impl_._oneof_case_[0] = kLocationMessage; -} -inline void Message_TemplateMessage_FourRowTemplate::clear_locationmessage() { - if (_internal_has_locationmessage()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.title_.locationmessage_; - } - clear_has_title(); - } -} -inline ::proto::Message_LocationMessage* Message_TemplateMessage_FourRowTemplate::release_locationmessage() { - // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.FourRowTemplate.locationMessage) - if (_internal_has_locationmessage()) { - clear_has_title(); - ::proto::Message_LocationMessage* temp = _impl_.title_.locationmessage_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.title_.locationmessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::Message_LocationMessage& Message_TemplateMessage_FourRowTemplate::_internal_locationmessage() const { - return _internal_has_locationmessage() - ? *_impl_.title_.locationmessage_ - : reinterpret_cast< ::proto::Message_LocationMessage&>(::proto::_Message_LocationMessage_default_instance_); -} -inline const ::proto::Message_LocationMessage& Message_TemplateMessage_FourRowTemplate::locationmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.locationMessage) - return _internal_locationmessage(); -} -inline ::proto::Message_LocationMessage* Message_TemplateMessage_FourRowTemplate::unsafe_arena_release_locationmessage() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.FourRowTemplate.locationMessage) - if (_internal_has_locationmessage()) { - clear_has_title(); - ::proto::Message_LocationMessage* temp = _impl_.title_.locationmessage_; - _impl_.title_.locationmessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Message_TemplateMessage_FourRowTemplate::unsafe_arena_set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage) { - clear_title(); - if (locationmessage) { - set_has_locationmessage(); - _impl_.title_.locationmessage_ = locationmessage; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.locationMessage) -} -inline ::proto::Message_LocationMessage* Message_TemplateMessage_FourRowTemplate::_internal_mutable_locationmessage() { - if (!_internal_has_locationmessage()) { - clear_title(); - set_has_locationmessage(); - _impl_.title_.locationmessage_ = CreateMaybeMessage< ::proto::Message_LocationMessage >(GetArenaForAllocation()); - } - return _impl_.title_.locationmessage_; -} -inline ::proto::Message_LocationMessage* Message_TemplateMessage_FourRowTemplate::mutable_locationmessage() { - ::proto::Message_LocationMessage* _msg = _internal_mutable_locationmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.locationMessage) - return _msg; -} - -inline bool Message_TemplateMessage_FourRowTemplate::has_title() const { - return title_case() != TITLE_NOT_SET; -} -inline void Message_TemplateMessage_FourRowTemplate::clear_has_title() { - _impl_._oneof_case_[0] = TITLE_NOT_SET; -} -inline Message_TemplateMessage_FourRowTemplate::TitleCase Message_TemplateMessage_FourRowTemplate::title_case() const { - return Message_TemplateMessage_FourRowTemplate::TitleCase(_impl_._oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// Message_TemplateMessage_HydratedFourRowTemplate - -// optional string hydratedContentText = 6; -inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_hydratedcontenttext() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_hydratedcontenttext() const { - return _internal_has_hydratedcontenttext(); -} -inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_hydratedcontenttext() { - _impl_.hydratedcontenttext_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::hydratedcontenttext() const { - // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedContentText) - return _internal_hydratedcontenttext(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_TemplateMessage_HydratedFourRowTemplate::set_hydratedcontenttext(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.hydratedcontenttext_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedContentText) -} -inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::mutable_hydratedcontenttext() { - std::string* _s = _internal_mutable_hydratedcontenttext(); - // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedContentText) - return _s; -} -inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::_internal_hydratedcontenttext() const { - return _impl_.hydratedcontenttext_.Get(); -} -inline void Message_TemplateMessage_HydratedFourRowTemplate::_internal_set_hydratedcontenttext(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.hydratedcontenttext_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_hydratedcontenttext() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.hydratedcontenttext_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::release_hydratedcontenttext() { - // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedContentText) - if (!_internal_has_hydratedcontenttext()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.hydratedcontenttext_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.hydratedcontenttext_.IsDefault()) { - _impl_.hydratedcontenttext_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_TemplateMessage_HydratedFourRowTemplate::set_allocated_hydratedcontenttext(std::string* hydratedcontenttext) { - if (hydratedcontenttext != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.hydratedcontenttext_.SetAllocated(hydratedcontenttext, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.hydratedcontenttext_.IsDefault()) { - _impl_.hydratedcontenttext_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedContentText) -} - -// optional string hydratedFooterText = 7; -inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_hydratedfootertext() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_hydratedfootertext() const { - return _internal_has_hydratedfootertext(); -} -inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_hydratedfootertext() { - _impl_.hydratedfootertext_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::hydratedfootertext() const { - // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedFooterText) - return _internal_hydratedfootertext(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_TemplateMessage_HydratedFourRowTemplate::set_hydratedfootertext(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.hydratedfootertext_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedFooterText) -} -inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::mutable_hydratedfootertext() { - std::string* _s = _internal_mutable_hydratedfootertext(); - // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedFooterText) - return _s; -} -inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::_internal_hydratedfootertext() const { - return _impl_.hydratedfootertext_.Get(); -} -inline void Message_TemplateMessage_HydratedFourRowTemplate::_internal_set_hydratedfootertext(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.hydratedfootertext_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_hydratedfootertext() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.hydratedfootertext_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::release_hydratedfootertext() { - // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedFooterText) - if (!_internal_has_hydratedfootertext()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.hydratedfootertext_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.hydratedfootertext_.IsDefault()) { - _impl_.hydratedfootertext_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_TemplateMessage_HydratedFourRowTemplate::set_allocated_hydratedfootertext(std::string* hydratedfootertext) { - if (hydratedfootertext != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.hydratedfootertext_.SetAllocated(hydratedfootertext, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.hydratedfootertext_.IsDefault()) { - _impl_.hydratedfootertext_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedFooterText) -} - -// repeated .proto.HydratedTemplateButton hydratedButtons = 8; -inline int Message_TemplateMessage_HydratedFourRowTemplate::_internal_hydratedbuttons_size() const { - return _impl_.hydratedbuttons_.size(); -} -inline int Message_TemplateMessage_HydratedFourRowTemplate::hydratedbuttons_size() const { - return _internal_hydratedbuttons_size(); -} -inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_hydratedbuttons() { - _impl_.hydratedbuttons_.Clear(); -} -inline ::proto::HydratedTemplateButton* Message_TemplateMessage_HydratedFourRowTemplate::mutable_hydratedbuttons(int index) { - // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedButtons) - return _impl_.hydratedbuttons_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HydratedTemplateButton >* -Message_TemplateMessage_HydratedFourRowTemplate::mutable_hydratedbuttons() { - // @@protoc_insertion_point(field_mutable_list:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedButtons) - return &_impl_.hydratedbuttons_; -} -inline const ::proto::HydratedTemplateButton& Message_TemplateMessage_HydratedFourRowTemplate::_internal_hydratedbuttons(int index) const { - return _impl_.hydratedbuttons_.Get(index); -} -inline const ::proto::HydratedTemplateButton& Message_TemplateMessage_HydratedFourRowTemplate::hydratedbuttons(int index) const { - // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedButtons) - return _internal_hydratedbuttons(index); -} -inline ::proto::HydratedTemplateButton* Message_TemplateMessage_HydratedFourRowTemplate::_internal_add_hydratedbuttons() { - return _impl_.hydratedbuttons_.Add(); -} -inline ::proto::HydratedTemplateButton* Message_TemplateMessage_HydratedFourRowTemplate::add_hydratedbuttons() { - ::proto::HydratedTemplateButton* _add = _internal_add_hydratedbuttons(); - // @@protoc_insertion_point(field_add:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedButtons) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HydratedTemplateButton >& -Message_TemplateMessage_HydratedFourRowTemplate::hydratedbuttons() const { - // @@protoc_insertion_point(field_list:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedButtons) - return _impl_.hydratedbuttons_; -} - -// optional string templateId = 9; -inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_templateid() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_templateid() const { - return _internal_has_templateid(); -} -inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_templateid() { - _impl_.templateid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::templateid() const { - // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.templateId) - return _internal_templateid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_TemplateMessage_HydratedFourRowTemplate::set_templateid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.templateid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.TemplateMessage.HydratedFourRowTemplate.templateId) -} -inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::mutable_templateid() { - std::string* _s = _internal_mutable_templateid(); - // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.templateId) - return _s; -} -inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::_internal_templateid() const { - return _impl_.templateid_.Get(); -} -inline void Message_TemplateMessage_HydratedFourRowTemplate::_internal_set_templateid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.templateid_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_templateid() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.templateid_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::release_templateid() { - // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.templateId) - if (!_internal_has_templateid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.templateid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.templateid_.IsDefault()) { - _impl_.templateid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_TemplateMessage_HydratedFourRowTemplate::set_allocated_templateid(std::string* templateid) { - if (templateid != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.templateid_.SetAllocated(templateid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.templateid_.IsDefault()) { - _impl_.templateid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.templateId) -} - -// .proto.Message.DocumentMessage documentMessage = 1; -inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_documentmessage() const { - return title_case() == kDocumentMessage; -} -inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_documentmessage() const { - return _internal_has_documentmessage(); -} -inline void Message_TemplateMessage_HydratedFourRowTemplate::set_has_documentmessage() { - _impl_._oneof_case_[0] = kDocumentMessage; -} -inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_documentmessage() { - if (_internal_has_documentmessage()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.title_.documentmessage_; - } - clear_has_title(); - } -} -inline ::proto::Message_DocumentMessage* Message_TemplateMessage_HydratedFourRowTemplate::release_documentmessage() { - // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.documentMessage) - if (_internal_has_documentmessage()) { - clear_has_title(); - ::proto::Message_DocumentMessage* temp = _impl_.title_.documentmessage_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.title_.documentmessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::Message_DocumentMessage& Message_TemplateMessage_HydratedFourRowTemplate::_internal_documentmessage() const { - return _internal_has_documentmessage() - ? *_impl_.title_.documentmessage_ - : reinterpret_cast< ::proto::Message_DocumentMessage&>(::proto::_Message_DocumentMessage_default_instance_); -} -inline const ::proto::Message_DocumentMessage& Message_TemplateMessage_HydratedFourRowTemplate::documentmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.documentMessage) - return _internal_documentmessage(); -} -inline ::proto::Message_DocumentMessage* Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_release_documentmessage() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.documentMessage) - if (_internal_has_documentmessage()) { - clear_has_title(); - ::proto::Message_DocumentMessage* temp = _impl_.title_.documentmessage_; - _impl_.title_.documentmessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) { - clear_title(); - if (documentmessage) { - set_has_documentmessage(); - _impl_.title_.documentmessage_ = documentmessage; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.documentMessage) -} -inline ::proto::Message_DocumentMessage* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_documentmessage() { - if (!_internal_has_documentmessage()) { - clear_title(); - set_has_documentmessage(); - _impl_.title_.documentmessage_ = CreateMaybeMessage< ::proto::Message_DocumentMessage >(GetArenaForAllocation()); - } - return _impl_.title_.documentmessage_; -} -inline ::proto::Message_DocumentMessage* Message_TemplateMessage_HydratedFourRowTemplate::mutable_documentmessage() { - ::proto::Message_DocumentMessage* _msg = _internal_mutable_documentmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.documentMessage) - return _msg; -} - -// string hydratedTitleText = 2; -inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_hydratedtitletext() const { - return title_case() == kHydratedTitleText; -} -inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_hydratedtitletext() const { - return _internal_has_hydratedtitletext(); -} -inline void Message_TemplateMessage_HydratedFourRowTemplate::set_has_hydratedtitletext() { - _impl_._oneof_case_[0] = kHydratedTitleText; -} -inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_hydratedtitletext() { - if (_internal_has_hydratedtitletext()) { - _impl_.title_.hydratedtitletext_.Destroy(); - clear_has_title(); - } -} -inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::hydratedtitletext() const { - // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedTitleText) - return _internal_hydratedtitletext(); -} -template -inline void Message_TemplateMessage_HydratedFourRowTemplate::set_hydratedtitletext(ArgT0&& arg0, ArgT... args) { - if (!_internal_has_hydratedtitletext()) { - clear_title(); - set_has_hydratedtitletext(); - _impl_.title_.hydratedtitletext_.InitDefault(); - } - _impl_.title_.hydratedtitletext_.Set( static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedTitleText) -} -inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::mutable_hydratedtitletext() { - std::string* _s = _internal_mutable_hydratedtitletext(); - // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedTitleText) - return _s; -} -inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::_internal_hydratedtitletext() const { - if (_internal_has_hydratedtitletext()) { - return _impl_.title_.hydratedtitletext_.Get(); - } - return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); -} -inline void Message_TemplateMessage_HydratedFourRowTemplate::_internal_set_hydratedtitletext(const std::string& value) { - if (!_internal_has_hydratedtitletext()) { - clear_title(); - set_has_hydratedtitletext(); - _impl_.title_.hydratedtitletext_.InitDefault(); - } - _impl_.title_.hydratedtitletext_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_hydratedtitletext() { - if (!_internal_has_hydratedtitletext()) { - clear_title(); - set_has_hydratedtitletext(); - _impl_.title_.hydratedtitletext_.InitDefault(); - } - return _impl_.title_.hydratedtitletext_.Mutable( GetArenaForAllocation()); -} -inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::release_hydratedtitletext() { - // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedTitleText) - if (_internal_has_hydratedtitletext()) { - clear_has_title(); - return _impl_.title_.hydratedtitletext_.Release(); - } else { - return nullptr; - } -} -inline void Message_TemplateMessage_HydratedFourRowTemplate::set_allocated_hydratedtitletext(std::string* hydratedtitletext) { - if (has_title()) { - clear_title(); - } - if (hydratedtitletext != nullptr) { - set_has_hydratedtitletext(); - _impl_.title_.hydratedtitletext_.InitAllocated(hydratedtitletext, GetArenaForAllocation()); - } - // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedTitleText) -} - -// .proto.Message.ImageMessage imageMessage = 3; -inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_imagemessage() const { - return title_case() == kImageMessage; -} -inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_imagemessage() const { - return _internal_has_imagemessage(); -} -inline void Message_TemplateMessage_HydratedFourRowTemplate::set_has_imagemessage() { - _impl_._oneof_case_[0] = kImageMessage; -} -inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_imagemessage() { - if (_internal_has_imagemessage()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.title_.imagemessage_; - } - clear_has_title(); - } -} -inline ::proto::Message_ImageMessage* Message_TemplateMessage_HydratedFourRowTemplate::release_imagemessage() { - // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.imageMessage) - if (_internal_has_imagemessage()) { - clear_has_title(); - ::proto::Message_ImageMessage* temp = _impl_.title_.imagemessage_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.title_.imagemessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::Message_ImageMessage& Message_TemplateMessage_HydratedFourRowTemplate::_internal_imagemessage() const { - return _internal_has_imagemessage() - ? *_impl_.title_.imagemessage_ - : reinterpret_cast< ::proto::Message_ImageMessage&>(::proto::_Message_ImageMessage_default_instance_); -} -inline const ::proto::Message_ImageMessage& Message_TemplateMessage_HydratedFourRowTemplate::imagemessage() const { - // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.imageMessage) - return _internal_imagemessage(); -} -inline ::proto::Message_ImageMessage* Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_release_imagemessage() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.imageMessage) - if (_internal_has_imagemessage()) { - clear_has_title(); - ::proto::Message_ImageMessage* temp = _impl_.title_.imagemessage_; - _impl_.title_.imagemessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) { - clear_title(); - if (imagemessage) { - set_has_imagemessage(); - _impl_.title_.imagemessage_ = imagemessage; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.imageMessage) -} -inline ::proto::Message_ImageMessage* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_imagemessage() { - if (!_internal_has_imagemessage()) { - clear_title(); - set_has_imagemessage(); - _impl_.title_.imagemessage_ = CreateMaybeMessage< ::proto::Message_ImageMessage >(GetArenaForAllocation()); - } - return _impl_.title_.imagemessage_; -} -inline ::proto::Message_ImageMessage* Message_TemplateMessage_HydratedFourRowTemplate::mutable_imagemessage() { - ::proto::Message_ImageMessage* _msg = _internal_mutable_imagemessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.imageMessage) - return _msg; -} - -// .proto.Message.VideoMessage videoMessage = 4; -inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_videomessage() const { - return title_case() == kVideoMessage; -} -inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_videomessage() const { - return _internal_has_videomessage(); -} -inline void Message_TemplateMessage_HydratedFourRowTemplate::set_has_videomessage() { - _impl_._oneof_case_[0] = kVideoMessage; -} -inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_videomessage() { - if (_internal_has_videomessage()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.title_.videomessage_; - } - clear_has_title(); - } -} -inline ::proto::Message_VideoMessage* Message_TemplateMessage_HydratedFourRowTemplate::release_videomessage() { - // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.videoMessage) - if (_internal_has_videomessage()) { - clear_has_title(); - ::proto::Message_VideoMessage* temp = _impl_.title_.videomessage_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.title_.videomessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::Message_VideoMessage& Message_TemplateMessage_HydratedFourRowTemplate::_internal_videomessage() const { - return _internal_has_videomessage() - ? *_impl_.title_.videomessage_ - : reinterpret_cast< ::proto::Message_VideoMessage&>(::proto::_Message_VideoMessage_default_instance_); -} -inline const ::proto::Message_VideoMessage& Message_TemplateMessage_HydratedFourRowTemplate::videomessage() const { - // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.videoMessage) - return _internal_videomessage(); -} -inline ::proto::Message_VideoMessage* Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_release_videomessage() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.videoMessage) - if (_internal_has_videomessage()) { - clear_has_title(); - ::proto::Message_VideoMessage* temp = _impl_.title_.videomessage_; - _impl_.title_.videomessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) { - clear_title(); - if (videomessage) { - set_has_videomessage(); - _impl_.title_.videomessage_ = videomessage; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.videoMessage) -} -inline ::proto::Message_VideoMessage* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_videomessage() { - if (!_internal_has_videomessage()) { - clear_title(); - set_has_videomessage(); - _impl_.title_.videomessage_ = CreateMaybeMessage< ::proto::Message_VideoMessage >(GetArenaForAllocation()); - } - return _impl_.title_.videomessage_; -} -inline ::proto::Message_VideoMessage* Message_TemplateMessage_HydratedFourRowTemplate::mutable_videomessage() { - ::proto::Message_VideoMessage* _msg = _internal_mutable_videomessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.videoMessage) - return _msg; -} - -// .proto.Message.LocationMessage locationMessage = 5; -inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_locationmessage() const { - return title_case() == kLocationMessage; -} -inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_locationmessage() const { - return _internal_has_locationmessage(); -} -inline void Message_TemplateMessage_HydratedFourRowTemplate::set_has_locationmessage() { - _impl_._oneof_case_[0] = kLocationMessage; -} -inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_locationmessage() { - if (_internal_has_locationmessage()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.title_.locationmessage_; - } - clear_has_title(); - } -} -inline ::proto::Message_LocationMessage* Message_TemplateMessage_HydratedFourRowTemplate::release_locationmessage() { - // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.locationMessage) - if (_internal_has_locationmessage()) { - clear_has_title(); - ::proto::Message_LocationMessage* temp = _impl_.title_.locationmessage_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.title_.locationmessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::Message_LocationMessage& Message_TemplateMessage_HydratedFourRowTemplate::_internal_locationmessage() const { - return _internal_has_locationmessage() - ? *_impl_.title_.locationmessage_ - : reinterpret_cast< ::proto::Message_LocationMessage&>(::proto::_Message_LocationMessage_default_instance_); -} -inline const ::proto::Message_LocationMessage& Message_TemplateMessage_HydratedFourRowTemplate::locationmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.locationMessage) - return _internal_locationmessage(); -} -inline ::proto::Message_LocationMessage* Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_release_locationmessage() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.locationMessage) - if (_internal_has_locationmessage()) { - clear_has_title(); - ::proto::Message_LocationMessage* temp = _impl_.title_.locationmessage_; - _impl_.title_.locationmessage_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage) { - clear_title(); - if (locationmessage) { - set_has_locationmessage(); - _impl_.title_.locationmessage_ = locationmessage; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.locationMessage) -} -inline ::proto::Message_LocationMessage* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_locationmessage() { - if (!_internal_has_locationmessage()) { - clear_title(); - set_has_locationmessage(); - _impl_.title_.locationmessage_ = CreateMaybeMessage< ::proto::Message_LocationMessage >(GetArenaForAllocation()); - } - return _impl_.title_.locationmessage_; -} -inline ::proto::Message_LocationMessage* Message_TemplateMessage_HydratedFourRowTemplate::mutable_locationmessage() { - ::proto::Message_LocationMessage* _msg = _internal_mutable_locationmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.locationMessage) - return _msg; -} - -inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_title() const { - return title_case() != TITLE_NOT_SET; -} -inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_has_title() { - _impl_._oneof_case_[0] = TITLE_NOT_SET; -} -inline Message_TemplateMessage_HydratedFourRowTemplate::TitleCase Message_TemplateMessage_HydratedFourRowTemplate::title_case() const { - return Message_TemplateMessage_HydratedFourRowTemplate::TitleCase(_impl_._oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// Message_TemplateMessage - -// optional .proto.ContextInfo contextInfo = 3; -inline bool Message_TemplateMessage::_internal_has_contextinfo() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); - return value; -} -inline bool Message_TemplateMessage::has_contextinfo() const { - return _internal_has_contextinfo(); -} -inline void Message_TemplateMessage::clear_contextinfo() { - if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::ContextInfo& Message_TemplateMessage::_internal_contextinfo() const { - const ::proto::ContextInfo* p = _impl_.contextinfo_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ContextInfo_default_instance_); -} -inline const ::proto::ContextInfo& Message_TemplateMessage::contextinfo() const { - // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.contextInfo) - return _internal_contextinfo(); -} -inline void Message_TemplateMessage::unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); - } - _impl_.contextinfo_ = contextinfo; - if (contextinfo) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.contextInfo) -} -inline ::proto::ContextInfo* Message_TemplateMessage::release_contextinfo() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ContextInfo* Message_TemplateMessage::unsafe_arena_release_contextinfo() { - // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.contextInfo) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; - return temp; -} -inline ::proto::ContextInfo* Message_TemplateMessage::_internal_mutable_contextinfo() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.contextinfo_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); - _impl_.contextinfo_ = p; - } - return _impl_.contextinfo_; -} -inline ::proto::ContextInfo* Message_TemplateMessage::mutable_contextinfo() { - ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); - // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.contextInfo) - return _msg; -} -inline void Message_TemplateMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.contextinfo_; - } - if (contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); - if (message_arena != submessage_arena) { - contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, contextinfo, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.contextinfo_ = contextinfo; - // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.contextInfo) -} - -// optional .proto.Message.TemplateMessage.HydratedFourRowTemplate hydratedTemplate = 4; -inline bool Message_TemplateMessage::_internal_has_hydratedtemplate() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.hydratedtemplate_ != nullptr); - return value; -} -inline bool Message_TemplateMessage::has_hydratedtemplate() const { - return _internal_has_hydratedtemplate(); -} -inline void Message_TemplateMessage::clear_hydratedtemplate() { - if (_impl_.hydratedtemplate_ != nullptr) _impl_.hydratedtemplate_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& Message_TemplateMessage::_internal_hydratedtemplate() const { - const ::proto::Message_TemplateMessage_HydratedFourRowTemplate* p = _impl_.hydratedtemplate_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_TemplateMessage_HydratedFourRowTemplate_default_instance_); -} -inline const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& Message_TemplateMessage::hydratedtemplate() const { - // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.hydratedTemplate) - return _internal_hydratedtemplate(); -} -inline void Message_TemplateMessage::unsafe_arena_set_allocated_hydratedtemplate( - ::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedtemplate) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.hydratedtemplate_); - } - _impl_.hydratedtemplate_ = hydratedtemplate; - if (hydratedtemplate) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.hydratedTemplate) -} -inline ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::release_hydratedtemplate() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::Message_TemplateMessage_HydratedFourRowTemplate* temp = _impl_.hydratedtemplate_; - _impl_.hydratedtemplate_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::unsafe_arena_release_hydratedtemplate() { - // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.hydratedTemplate) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::Message_TemplateMessage_HydratedFourRowTemplate* temp = _impl_.hydratedtemplate_; - _impl_.hydratedtemplate_ = nullptr; - return temp; -} -inline ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::_internal_mutable_hydratedtemplate() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.hydratedtemplate_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_TemplateMessage_HydratedFourRowTemplate>(GetArenaForAllocation()); - _impl_.hydratedtemplate_ = p; - } - return _impl_.hydratedtemplate_; -} -inline ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::mutable_hydratedtemplate() { - ::proto::Message_TemplateMessage_HydratedFourRowTemplate* _msg = _internal_mutable_hydratedtemplate(); - // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.hydratedTemplate) - return _msg; -} -inline void Message_TemplateMessage::set_allocated_hydratedtemplate(::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedtemplate) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.hydratedtemplate_; - } - if (hydratedtemplate) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(hydratedtemplate); - if (message_arena != submessage_arena) { - hydratedtemplate = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, hydratedtemplate, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.hydratedtemplate_ = hydratedtemplate; - // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.hydratedTemplate) -} - -// .proto.Message.TemplateMessage.FourRowTemplate fourRowTemplate = 1; -inline bool Message_TemplateMessage::_internal_has_fourrowtemplate() const { - return format_case() == kFourRowTemplate; -} -inline bool Message_TemplateMessage::has_fourrowtemplate() const { - return _internal_has_fourrowtemplate(); -} -inline void Message_TemplateMessage::set_has_fourrowtemplate() { - _impl_._oneof_case_[0] = kFourRowTemplate; -} -inline void Message_TemplateMessage::clear_fourrowtemplate() { - if (_internal_has_fourrowtemplate()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.format_.fourrowtemplate_; - } - clear_has_format(); - } -} -inline ::proto::Message_TemplateMessage_FourRowTemplate* Message_TemplateMessage::release_fourrowtemplate() { - // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.fourRowTemplate) - if (_internal_has_fourrowtemplate()) { - clear_has_format(); - ::proto::Message_TemplateMessage_FourRowTemplate* temp = _impl_.format_.fourrowtemplate_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.format_.fourrowtemplate_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::Message_TemplateMessage_FourRowTemplate& Message_TemplateMessage::_internal_fourrowtemplate() const { - return _internal_has_fourrowtemplate() - ? *_impl_.format_.fourrowtemplate_ - : reinterpret_cast< ::proto::Message_TemplateMessage_FourRowTemplate&>(::proto::_Message_TemplateMessage_FourRowTemplate_default_instance_); -} -inline const ::proto::Message_TemplateMessage_FourRowTemplate& Message_TemplateMessage::fourrowtemplate() const { - // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.fourRowTemplate) - return _internal_fourrowtemplate(); -} -inline ::proto::Message_TemplateMessage_FourRowTemplate* Message_TemplateMessage::unsafe_arena_release_fourrowtemplate() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.fourRowTemplate) - if (_internal_has_fourrowtemplate()) { - clear_has_format(); - ::proto::Message_TemplateMessage_FourRowTemplate* temp = _impl_.format_.fourrowtemplate_; - _impl_.format_.fourrowtemplate_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Message_TemplateMessage::unsafe_arena_set_allocated_fourrowtemplate(::proto::Message_TemplateMessage_FourRowTemplate* fourrowtemplate) { - clear_format(); - if (fourrowtemplate) { - set_has_fourrowtemplate(); - _impl_.format_.fourrowtemplate_ = fourrowtemplate; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.fourRowTemplate) -} -inline ::proto::Message_TemplateMessage_FourRowTemplate* Message_TemplateMessage::_internal_mutable_fourrowtemplate() { - if (!_internal_has_fourrowtemplate()) { - clear_format(); - set_has_fourrowtemplate(); - _impl_.format_.fourrowtemplate_ = CreateMaybeMessage< ::proto::Message_TemplateMessage_FourRowTemplate >(GetArenaForAllocation()); - } - return _impl_.format_.fourrowtemplate_; -} -inline ::proto::Message_TemplateMessage_FourRowTemplate* Message_TemplateMessage::mutable_fourrowtemplate() { - ::proto::Message_TemplateMessage_FourRowTemplate* _msg = _internal_mutable_fourrowtemplate(); - // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.fourRowTemplate) - return _msg; -} - -// .proto.Message.TemplateMessage.HydratedFourRowTemplate hydratedFourRowTemplate = 2; -inline bool Message_TemplateMessage::_internal_has_hydratedfourrowtemplate() const { - return format_case() == kHydratedFourRowTemplate; -} -inline bool Message_TemplateMessage::has_hydratedfourrowtemplate() const { - return _internal_has_hydratedfourrowtemplate(); -} -inline void Message_TemplateMessage::set_has_hydratedfourrowtemplate() { - _impl_._oneof_case_[0] = kHydratedFourRowTemplate; -} -inline void Message_TemplateMessage::clear_hydratedfourrowtemplate() { - if (_internal_has_hydratedfourrowtemplate()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.format_.hydratedfourrowtemplate_; - } - clear_has_format(); - } -} -inline ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::release_hydratedfourrowtemplate() { - // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.hydratedFourRowTemplate) - if (_internal_has_hydratedfourrowtemplate()) { - clear_has_format(); - ::proto::Message_TemplateMessage_HydratedFourRowTemplate* temp = _impl_.format_.hydratedfourrowtemplate_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.format_.hydratedfourrowtemplate_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& Message_TemplateMessage::_internal_hydratedfourrowtemplate() const { - return _internal_has_hydratedfourrowtemplate() - ? *_impl_.format_.hydratedfourrowtemplate_ - : reinterpret_cast< ::proto::Message_TemplateMessage_HydratedFourRowTemplate&>(::proto::_Message_TemplateMessage_HydratedFourRowTemplate_default_instance_); -} -inline const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& Message_TemplateMessage::hydratedfourrowtemplate() const { - // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.hydratedFourRowTemplate) - return _internal_hydratedfourrowtemplate(); -} -inline ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::unsafe_arena_release_hydratedfourrowtemplate() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.hydratedFourRowTemplate) - if (_internal_has_hydratedfourrowtemplate()) { - clear_has_format(); - ::proto::Message_TemplateMessage_HydratedFourRowTemplate* temp = _impl_.format_.hydratedfourrowtemplate_; - _impl_.format_.hydratedfourrowtemplate_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Message_TemplateMessage::unsafe_arena_set_allocated_hydratedfourrowtemplate(::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedfourrowtemplate) { - clear_format(); - if (hydratedfourrowtemplate) { - set_has_hydratedfourrowtemplate(); - _impl_.format_.hydratedfourrowtemplate_ = hydratedfourrowtemplate; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.hydratedFourRowTemplate) -} -inline ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::_internal_mutable_hydratedfourrowtemplate() { - if (!_internal_has_hydratedfourrowtemplate()) { - clear_format(); - set_has_hydratedfourrowtemplate(); - _impl_.format_.hydratedfourrowtemplate_ = CreateMaybeMessage< ::proto::Message_TemplateMessage_HydratedFourRowTemplate >(GetArenaForAllocation()); - } - return _impl_.format_.hydratedfourrowtemplate_; -} -inline ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::mutable_hydratedfourrowtemplate() { - ::proto::Message_TemplateMessage_HydratedFourRowTemplate* _msg = _internal_mutable_hydratedfourrowtemplate(); - // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.hydratedFourRowTemplate) - return _msg; -} - -inline bool Message_TemplateMessage::has_format() const { - return format_case() != FORMAT_NOT_SET; -} -inline void Message_TemplateMessage::clear_has_format() { - _impl_._oneof_case_[0] = FORMAT_NOT_SET; -} -inline Message_TemplateMessage::FormatCase Message_TemplateMessage::format_case() const { - return Message_TemplateMessage::FormatCase(_impl_._oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// Message_VideoMessage - -// optional string url = 1; -inline bool Message_VideoMessage::_internal_has_url() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message_VideoMessage::has_url() const { - return _internal_has_url(); -} -inline void Message_VideoMessage::clear_url() { - _impl_.url_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message_VideoMessage::url() const { - // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.url) - return _internal_url(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_VideoMessage::set_url(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.url_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.url) -} -inline std::string* Message_VideoMessage::mutable_url() { - std::string* _s = _internal_mutable_url(); - // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.url) - return _s; -} -inline const std::string& Message_VideoMessage::_internal_url() const { - return _impl_.url_.Get(); -} -inline void Message_VideoMessage::_internal_set_url(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.url_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_VideoMessage::_internal_mutable_url() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.url_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_VideoMessage::release_url() { - // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.url) - if (!_internal_has_url()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.url_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.url_.IsDefault()) { - _impl_.url_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_VideoMessage::set_allocated_url(std::string* url) { - if (url != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.url_.SetAllocated(url, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.url_.IsDefault()) { - _impl_.url_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.url) -} - -// optional string mimetype = 2; -inline bool Message_VideoMessage::_internal_has_mimetype() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Message_VideoMessage::has_mimetype() const { - return _internal_has_mimetype(); -} -inline void Message_VideoMessage::clear_mimetype() { - _impl_.mimetype_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Message_VideoMessage::mimetype() const { - // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.mimetype) - return _internal_mimetype(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_VideoMessage::set_mimetype(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.mimetype_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.mimetype) -} -inline std::string* Message_VideoMessage::mutable_mimetype() { - std::string* _s = _internal_mutable_mimetype(); - // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.mimetype) - return _s; -} -inline const std::string& Message_VideoMessage::_internal_mimetype() const { - return _impl_.mimetype_.Get(); -} -inline void Message_VideoMessage::_internal_set_mimetype(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.mimetype_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_VideoMessage::_internal_mutable_mimetype() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.mimetype_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_VideoMessage::release_mimetype() { - // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.mimetype) - if (!_internal_has_mimetype()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.mimetype_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mimetype_.IsDefault()) { - _impl_.mimetype_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_VideoMessage::set_allocated_mimetype(std::string* mimetype) { - if (mimetype != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mimetype_.IsDefault()) { - _impl_.mimetype_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.mimetype) -} - -// optional bytes fileSha256 = 3; -inline bool Message_VideoMessage::_internal_has_filesha256() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool Message_VideoMessage::has_filesha256() const { - return _internal_has_filesha256(); -} -inline void Message_VideoMessage::clear_filesha256() { - _impl_.filesha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& Message_VideoMessage::filesha256() const { - // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.fileSha256) - return _internal_filesha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_VideoMessage::set_filesha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.filesha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.fileSha256) -} -inline std::string* Message_VideoMessage::mutable_filesha256() { - std::string* _s = _internal_mutable_filesha256(); - // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.fileSha256) - return _s; -} -inline const std::string& Message_VideoMessage::_internal_filesha256() const { - return _impl_.filesha256_.Get(); -} -inline void Message_VideoMessage::_internal_set_filesha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.filesha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_VideoMessage::_internal_mutable_filesha256() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.filesha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_VideoMessage::release_filesha256() { - // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.fileSha256) - if (!_internal_has_filesha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.filesha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.filesha256_.IsDefault()) { - _impl_.filesha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_VideoMessage::set_allocated_filesha256(std::string* filesha256) { - if (filesha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.filesha256_.IsDefault()) { - _impl_.filesha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.fileSha256) -} - -// optional uint64 fileLength = 4; -inline bool Message_VideoMessage::_internal_has_filelength() const { - bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0; - return value; -} -inline bool Message_VideoMessage::has_filelength() const { - return _internal_has_filelength(); -} -inline void Message_VideoMessage::clear_filelength() { - _impl_.filelength_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00004000u; -} -inline uint64_t Message_VideoMessage::_internal_filelength() const { - return _impl_.filelength_; -} -inline uint64_t Message_VideoMessage::filelength() const { - // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.fileLength) - return _internal_filelength(); -} -inline void Message_VideoMessage::_internal_set_filelength(uint64_t value) { - _impl_._has_bits_[0] |= 0x00004000u; - _impl_.filelength_ = value; -} -inline void Message_VideoMessage::set_filelength(uint64_t value) { - _internal_set_filelength(value); - // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.fileLength) -} - -// optional uint32 seconds = 5; -inline bool Message_VideoMessage::_internal_has_seconds() const { - bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0; - return value; -} -inline bool Message_VideoMessage::has_seconds() const { - return _internal_has_seconds(); -} -inline void Message_VideoMessage::clear_seconds() { - _impl_.seconds_ = 0u; - _impl_._has_bits_[0] &= ~0x00008000u; -} -inline uint32_t Message_VideoMessage::_internal_seconds() const { - return _impl_.seconds_; -} -inline uint32_t Message_VideoMessage::seconds() const { - // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.seconds) - return _internal_seconds(); -} -inline void Message_VideoMessage::_internal_set_seconds(uint32_t value) { - _impl_._has_bits_[0] |= 0x00008000u; - _impl_.seconds_ = value; -} -inline void Message_VideoMessage::set_seconds(uint32_t value) { - _internal_set_seconds(value); - // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.seconds) -} - -// optional bytes mediaKey = 6; -inline bool Message_VideoMessage::_internal_has_mediakey() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool Message_VideoMessage::has_mediakey() const { - return _internal_has_mediakey(); -} -inline void Message_VideoMessage::clear_mediakey() { - _impl_.mediakey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const std::string& Message_VideoMessage::mediakey() const { - // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.mediaKey) - return _internal_mediakey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_VideoMessage::set_mediakey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.mediakey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.mediaKey) -} -inline std::string* Message_VideoMessage::mutable_mediakey() { - std::string* _s = _internal_mutable_mediakey(); - // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.mediaKey) - return _s; -} -inline const std::string& Message_VideoMessage::_internal_mediakey() const { - return _impl_.mediakey_.Get(); -} -inline void Message_VideoMessage::_internal_set_mediakey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.mediakey_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_VideoMessage::_internal_mutable_mediakey() { - _impl_._has_bits_[0] |= 0x00000008u; - return _impl_.mediakey_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_VideoMessage::release_mediakey() { - // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.mediaKey) - if (!_internal_has_mediakey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000008u; - auto* p = _impl_.mediakey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mediakey_.IsDefault()) { - _impl_.mediakey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_VideoMessage::set_allocated_mediakey(std::string* mediakey) { - if (mediakey != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mediakey_.IsDefault()) { - _impl_.mediakey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.mediaKey) -} - -// optional string caption = 7; -inline bool Message_VideoMessage::_internal_has_caption() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool Message_VideoMessage::has_caption() const { - return _internal_has_caption(); -} -inline void Message_VideoMessage::clear_caption() { - _impl_.caption_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const std::string& Message_VideoMessage::caption() const { - // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.caption) - return _internal_caption(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_VideoMessage::set_caption(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.caption_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.caption) -} -inline std::string* Message_VideoMessage::mutable_caption() { - std::string* _s = _internal_mutable_caption(); - // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.caption) - return _s; -} -inline const std::string& Message_VideoMessage::_internal_caption() const { - return _impl_.caption_.Get(); -} -inline void Message_VideoMessage::_internal_set_caption(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.caption_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_VideoMessage::_internal_mutable_caption() { - _impl_._has_bits_[0] |= 0x00000010u; - return _impl_.caption_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_VideoMessage::release_caption() { - // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.caption) - if (!_internal_has_caption()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000010u; - auto* p = _impl_.caption_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.caption_.IsDefault()) { - _impl_.caption_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_VideoMessage::set_allocated_caption(std::string* caption) { - if (caption != nullptr) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.caption_.SetAllocated(caption, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.caption_.IsDefault()) { - _impl_.caption_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.caption) -} - -// optional bool gifPlayback = 8; -inline bool Message_VideoMessage::_internal_has_gifplayback() const { - bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0; - return value; -} -inline bool Message_VideoMessage::has_gifplayback() const { - return _internal_has_gifplayback(); -} -inline void Message_VideoMessage::clear_gifplayback() { - _impl_.gifplayback_ = false; - _impl_._has_bits_[0] &= ~0x00040000u; -} -inline bool Message_VideoMessage::_internal_gifplayback() const { - return _impl_.gifplayback_; -} -inline bool Message_VideoMessage::gifplayback() const { - // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.gifPlayback) - return _internal_gifplayback(); -} -inline void Message_VideoMessage::_internal_set_gifplayback(bool value) { - _impl_._has_bits_[0] |= 0x00040000u; - _impl_.gifplayback_ = value; -} -inline void Message_VideoMessage::set_gifplayback(bool value) { - _internal_set_gifplayback(value); - // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.gifPlayback) -} - -// optional uint32 height = 9; -inline bool Message_VideoMessage::_internal_has_height() const { - bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0; - return value; -} -inline bool Message_VideoMessage::has_height() const { - return _internal_has_height(); -} -inline void Message_VideoMessage::clear_height() { - _impl_.height_ = 0u; - _impl_._has_bits_[0] &= ~0x00010000u; -} -inline uint32_t Message_VideoMessage::_internal_height() const { - return _impl_.height_; -} -inline uint32_t Message_VideoMessage::height() const { - // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.height) - return _internal_height(); -} -inline void Message_VideoMessage::_internal_set_height(uint32_t value) { - _impl_._has_bits_[0] |= 0x00010000u; - _impl_.height_ = value; -} -inline void Message_VideoMessage::set_height(uint32_t value) { - _internal_set_height(value); - // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.height) -} - -// optional uint32 width = 10; -inline bool Message_VideoMessage::_internal_has_width() const { - bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0; - return value; -} -inline bool Message_VideoMessage::has_width() const { - return _internal_has_width(); -} -inline void Message_VideoMessage::clear_width() { - _impl_.width_ = 0u; - _impl_._has_bits_[0] &= ~0x00020000u; -} -inline uint32_t Message_VideoMessage::_internal_width() const { - return _impl_.width_; -} -inline uint32_t Message_VideoMessage::width() const { - // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.width) - return _internal_width(); -} -inline void Message_VideoMessage::_internal_set_width(uint32_t value) { - _impl_._has_bits_[0] |= 0x00020000u; - _impl_.width_ = value; -} -inline void Message_VideoMessage::set_width(uint32_t value) { - _internal_set_width(value); - // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.width) -} - -// optional bytes fileEncSha256 = 11; -inline bool Message_VideoMessage::_internal_has_fileencsha256() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool Message_VideoMessage::has_fileencsha256() const { - return _internal_has_fileencsha256(); -} -inline void Message_VideoMessage::clear_fileencsha256() { - _impl_.fileencsha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline const std::string& Message_VideoMessage::fileencsha256() const { - // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.fileEncSha256) - return _internal_fileencsha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_VideoMessage::set_fileencsha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.fileencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.fileEncSha256) -} -inline std::string* Message_VideoMessage::mutable_fileencsha256() { - std::string* _s = _internal_mutable_fileencsha256(); - // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.fileEncSha256) - return _s; -} -inline const std::string& Message_VideoMessage::_internal_fileencsha256() const { - return _impl_.fileencsha256_.Get(); -} -inline void Message_VideoMessage::_internal_set_fileencsha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.fileencsha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_VideoMessage::_internal_mutable_fileencsha256() { - _impl_._has_bits_[0] |= 0x00000020u; - return _impl_.fileencsha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_VideoMessage::release_fileencsha256() { - // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.fileEncSha256) - if (!_internal_has_fileencsha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000020u; - auto* p = _impl_.fileencsha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fileencsha256_.IsDefault()) { - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_VideoMessage::set_allocated_fileencsha256(std::string* fileencsha256) { - if (fileencsha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fileencsha256_.IsDefault()) { - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.fileEncSha256) -} - -// repeated .proto.InteractiveAnnotation interactiveAnnotations = 12; -inline int Message_VideoMessage::_internal_interactiveannotations_size() const { - return _impl_.interactiveannotations_.size(); -} -inline int Message_VideoMessage::interactiveannotations_size() const { - return _internal_interactiveannotations_size(); -} -inline void Message_VideoMessage::clear_interactiveannotations() { - _impl_.interactiveannotations_.Clear(); -} -inline ::proto::InteractiveAnnotation* Message_VideoMessage::mutable_interactiveannotations(int index) { - // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.interactiveAnnotations) - return _impl_.interactiveannotations_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >* -Message_VideoMessage::mutable_interactiveannotations() { - // @@protoc_insertion_point(field_mutable_list:proto.Message.VideoMessage.interactiveAnnotations) - return &_impl_.interactiveannotations_; -} -inline const ::proto::InteractiveAnnotation& Message_VideoMessage::_internal_interactiveannotations(int index) const { - return _impl_.interactiveannotations_.Get(index); -} -inline const ::proto::InteractiveAnnotation& Message_VideoMessage::interactiveannotations(int index) const { - // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.interactiveAnnotations) - return _internal_interactiveannotations(index); -} -inline ::proto::InteractiveAnnotation* Message_VideoMessage::_internal_add_interactiveannotations() { - return _impl_.interactiveannotations_.Add(); -} -inline ::proto::InteractiveAnnotation* Message_VideoMessage::add_interactiveannotations() { - ::proto::InteractiveAnnotation* _add = _internal_add_interactiveannotations(); - // @@protoc_insertion_point(field_add:proto.Message.VideoMessage.interactiveAnnotations) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >& -Message_VideoMessage::interactiveannotations() const { - // @@protoc_insertion_point(field_list:proto.Message.VideoMessage.interactiveAnnotations) - return _impl_.interactiveannotations_; -} - -// optional string directPath = 13; -inline bool Message_VideoMessage::_internal_has_directpath() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool Message_VideoMessage::has_directpath() const { - return _internal_has_directpath(); -} -inline void Message_VideoMessage::clear_directpath() { - _impl_.directpath_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline const std::string& Message_VideoMessage::directpath() const { - // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.directPath) - return _internal_directpath(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_VideoMessage::set_directpath(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.directpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.directPath) -} -inline std::string* Message_VideoMessage::mutable_directpath() { - std::string* _s = _internal_mutable_directpath(); - // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.directPath) - return _s; -} -inline const std::string& Message_VideoMessage::_internal_directpath() const { - return _impl_.directpath_.Get(); -} -inline void Message_VideoMessage::_internal_set_directpath(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.directpath_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_VideoMessage::_internal_mutable_directpath() { - _impl_._has_bits_[0] |= 0x00000040u; - return _impl_.directpath_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_VideoMessage::release_directpath() { - // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.directPath) - if (!_internal_has_directpath()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000040u; - auto* p = _impl_.directpath_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.directpath_.IsDefault()) { - _impl_.directpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_VideoMessage::set_allocated_directpath(std::string* directpath) { - if (directpath != nullptr) { - _impl_._has_bits_[0] |= 0x00000040u; - } else { - _impl_._has_bits_[0] &= ~0x00000040u; - } - _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.directpath_.IsDefault()) { - _impl_.directpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.directPath) -} - -// optional int64 mediaKeyTimestamp = 14; -inline bool Message_VideoMessage::_internal_has_mediakeytimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0; - return value; -} -inline bool Message_VideoMessage::has_mediakeytimestamp() const { - return _internal_has_mediakeytimestamp(); -} -inline void Message_VideoMessage::clear_mediakeytimestamp() { - _impl_.mediakeytimestamp_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00100000u; -} -inline int64_t Message_VideoMessage::_internal_mediakeytimestamp() const { - return _impl_.mediakeytimestamp_; -} -inline int64_t Message_VideoMessage::mediakeytimestamp() const { - // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.mediaKeyTimestamp) - return _internal_mediakeytimestamp(); -} -inline void Message_VideoMessage::_internal_set_mediakeytimestamp(int64_t value) { - _impl_._has_bits_[0] |= 0x00100000u; - _impl_.mediakeytimestamp_ = value; -} -inline void Message_VideoMessage::set_mediakeytimestamp(int64_t value) { - _internal_set_mediakeytimestamp(value); - // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.mediaKeyTimestamp) -} - -// optional bytes jpegThumbnail = 16; -inline bool Message_VideoMessage::_internal_has_jpegthumbnail() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - return value; -} -inline bool Message_VideoMessage::has_jpegthumbnail() const { - return _internal_has_jpegthumbnail(); -} -inline void Message_VideoMessage::clear_jpegthumbnail() { - _impl_.jpegthumbnail_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline const std::string& Message_VideoMessage::jpegthumbnail() const { - // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.jpegThumbnail) - return _internal_jpegthumbnail(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_VideoMessage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.jpegthumbnail_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.jpegThumbnail) -} -inline std::string* Message_VideoMessage::mutable_jpegthumbnail() { - std::string* _s = _internal_mutable_jpegthumbnail(); - // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.jpegThumbnail) - return _s; -} -inline const std::string& Message_VideoMessage::_internal_jpegthumbnail() const { - return _impl_.jpegthumbnail_.Get(); -} -inline void Message_VideoMessage::_internal_set_jpegthumbnail(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_VideoMessage::_internal_mutable_jpegthumbnail() { - _impl_._has_bits_[0] |= 0x00000080u; - return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_VideoMessage::release_jpegthumbnail() { - // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.jpegThumbnail) - if (!_internal_has_jpegthumbnail()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000080u; - auto* p = _impl_.jpegthumbnail_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.jpegthumbnail_.IsDefault()) { - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_VideoMessage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) { - if (jpegthumbnail != nullptr) { - _impl_._has_bits_[0] |= 0x00000080u; - } else { - _impl_._has_bits_[0] &= ~0x00000080u; - } - _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.jpegthumbnail_.IsDefault()) { - _impl_.jpegthumbnail_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.jpegThumbnail) -} - -// optional .proto.ContextInfo contextInfo = 17; -inline bool Message_VideoMessage::_internal_has_contextinfo() const { - bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr); - return value; -} -inline bool Message_VideoMessage::has_contextinfo() const { - return _internal_has_contextinfo(); -} -inline void Message_VideoMessage::clear_contextinfo() { - if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear(); - _impl_._has_bits_[0] &= ~0x00002000u; -} -inline const ::proto::ContextInfo& Message_VideoMessage::_internal_contextinfo() const { - const ::proto::ContextInfo* p = _impl_.contextinfo_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ContextInfo_default_instance_); -} -inline const ::proto::ContextInfo& Message_VideoMessage::contextinfo() const { - // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.contextInfo) - return _internal_contextinfo(); -} -inline void Message_VideoMessage::unsafe_arena_set_allocated_contextinfo( - ::proto::ContextInfo* contextinfo) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_); - } - _impl_.contextinfo_ = contextinfo; - if (contextinfo) { - _impl_._has_bits_[0] |= 0x00002000u; - } else { - _impl_._has_bits_[0] &= ~0x00002000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.VideoMessage.contextInfo) -} -inline ::proto::ContextInfo* Message_VideoMessage::release_contextinfo() { - _impl_._has_bits_[0] &= ~0x00002000u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ContextInfo* Message_VideoMessage::unsafe_arena_release_contextinfo() { - // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.contextInfo) - _impl_._has_bits_[0] &= ~0x00002000u; - ::proto::ContextInfo* temp = _impl_.contextinfo_; - _impl_.contextinfo_ = nullptr; - return temp; -} -inline ::proto::ContextInfo* Message_VideoMessage::_internal_mutable_contextinfo() { - _impl_._has_bits_[0] |= 0x00002000u; - if (_impl_.contextinfo_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation()); - _impl_.contextinfo_ = p; - } - return _impl_.contextinfo_; -} -inline ::proto::ContextInfo* Message_VideoMessage::mutable_contextinfo() { - ::proto::ContextInfo* _msg = _internal_mutable_contextinfo(); - // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.contextInfo) - return _msg; -} -inline void Message_VideoMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.contextinfo_; - } - if (contextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo); - if (message_arena != submessage_arena) { - contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, contextinfo, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00002000u; - } else { - _impl_._has_bits_[0] &= ~0x00002000u; - } - _impl_.contextinfo_ = contextinfo; - // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.contextInfo) -} - -// optional bytes streamingSidecar = 18; -inline bool Message_VideoMessage::_internal_has_streamingsidecar() const { - bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; - return value; -} -inline bool Message_VideoMessage::has_streamingsidecar() const { - return _internal_has_streamingsidecar(); -} -inline void Message_VideoMessage::clear_streamingsidecar() { - _impl_.streamingsidecar_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000100u; -} -inline const std::string& Message_VideoMessage::streamingsidecar() const { - // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.streamingSidecar) - return _internal_streamingsidecar(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_VideoMessage::set_streamingsidecar(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000100u; - _impl_.streamingsidecar_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.streamingSidecar) -} -inline std::string* Message_VideoMessage::mutable_streamingsidecar() { - std::string* _s = _internal_mutable_streamingsidecar(); - // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.streamingSidecar) - return _s; -} -inline const std::string& Message_VideoMessage::_internal_streamingsidecar() const { - return _impl_.streamingsidecar_.Get(); -} -inline void Message_VideoMessage::_internal_set_streamingsidecar(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000100u; - _impl_.streamingsidecar_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_VideoMessage::_internal_mutable_streamingsidecar() { - _impl_._has_bits_[0] |= 0x00000100u; - return _impl_.streamingsidecar_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_VideoMessage::release_streamingsidecar() { - // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.streamingSidecar) - if (!_internal_has_streamingsidecar()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000100u; - auto* p = _impl_.streamingsidecar_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.streamingsidecar_.IsDefault()) { - _impl_.streamingsidecar_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_VideoMessage::set_allocated_streamingsidecar(std::string* streamingsidecar) { - if (streamingsidecar != nullptr) { - _impl_._has_bits_[0] |= 0x00000100u; - } else { - _impl_._has_bits_[0] &= ~0x00000100u; - } - _impl_.streamingsidecar_.SetAllocated(streamingsidecar, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.streamingsidecar_.IsDefault()) { - _impl_.streamingsidecar_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.streamingSidecar) -} - -// optional .proto.Message.VideoMessage.Attribution gifAttribution = 19; -inline bool Message_VideoMessage::_internal_has_gifattribution() const { - bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0; - return value; -} -inline bool Message_VideoMessage::has_gifattribution() const { - return _internal_has_gifattribution(); -} -inline void Message_VideoMessage::clear_gifattribution() { - _impl_.gifattribution_ = 0; - _impl_._has_bits_[0] &= ~0x00200000u; -} -inline ::proto::Message_VideoMessage_Attribution Message_VideoMessage::_internal_gifattribution() const { - return static_cast< ::proto::Message_VideoMessage_Attribution >(_impl_.gifattribution_); -} -inline ::proto::Message_VideoMessage_Attribution Message_VideoMessage::gifattribution() const { - // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.gifAttribution) - return _internal_gifattribution(); -} -inline void Message_VideoMessage::_internal_set_gifattribution(::proto::Message_VideoMessage_Attribution value) { - assert(::proto::Message_VideoMessage_Attribution_IsValid(value)); - _impl_._has_bits_[0] |= 0x00200000u; - _impl_.gifattribution_ = value; -} -inline void Message_VideoMessage::set_gifattribution(::proto::Message_VideoMessage_Attribution value) { - _internal_set_gifattribution(value); - // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.gifAttribution) -} - -// optional bool viewOnce = 20; -inline bool Message_VideoMessage::_internal_has_viewonce() const { - bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0; - return value; -} -inline bool Message_VideoMessage::has_viewonce() const { - return _internal_has_viewonce(); -} -inline void Message_VideoMessage::clear_viewonce() { - _impl_.viewonce_ = false; - _impl_._has_bits_[0] &= ~0x00080000u; -} -inline bool Message_VideoMessage::_internal_viewonce() const { - return _impl_.viewonce_; -} -inline bool Message_VideoMessage::viewonce() const { - // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.viewOnce) - return _internal_viewonce(); -} -inline void Message_VideoMessage::_internal_set_viewonce(bool value) { - _impl_._has_bits_[0] |= 0x00080000u; - _impl_.viewonce_ = value; -} -inline void Message_VideoMessage::set_viewonce(bool value) { - _internal_set_viewonce(value); - // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.viewOnce) -} - -// optional string thumbnailDirectPath = 21; -inline bool Message_VideoMessage::_internal_has_thumbnaildirectpath() const { - bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; - return value; -} -inline bool Message_VideoMessage::has_thumbnaildirectpath() const { - return _internal_has_thumbnaildirectpath(); -} -inline void Message_VideoMessage::clear_thumbnaildirectpath() { - _impl_.thumbnaildirectpath_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000200u; -} -inline const std::string& Message_VideoMessage::thumbnaildirectpath() const { - // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.thumbnailDirectPath) - return _internal_thumbnaildirectpath(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_VideoMessage::set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.thumbnaildirectpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.thumbnailDirectPath) -} -inline std::string* Message_VideoMessage::mutable_thumbnaildirectpath() { - std::string* _s = _internal_mutable_thumbnaildirectpath(); - // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.thumbnailDirectPath) - return _s; -} -inline const std::string& Message_VideoMessage::_internal_thumbnaildirectpath() const { - return _impl_.thumbnaildirectpath_.Get(); -} -inline void Message_VideoMessage::_internal_set_thumbnaildirectpath(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.thumbnaildirectpath_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_VideoMessage::_internal_mutable_thumbnaildirectpath() { - _impl_._has_bits_[0] |= 0x00000200u; - return _impl_.thumbnaildirectpath_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_VideoMessage::release_thumbnaildirectpath() { - // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.thumbnailDirectPath) - if (!_internal_has_thumbnaildirectpath()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000200u; - auto* p = _impl_.thumbnaildirectpath_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.thumbnaildirectpath_.IsDefault()) { - _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_VideoMessage::set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath) { - if (thumbnaildirectpath != nullptr) { - _impl_._has_bits_[0] |= 0x00000200u; - } else { - _impl_._has_bits_[0] &= ~0x00000200u; - } - _impl_.thumbnaildirectpath_.SetAllocated(thumbnaildirectpath, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.thumbnaildirectpath_.IsDefault()) { - _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.thumbnailDirectPath) -} - -// optional bytes thumbnailSha256 = 22; -inline bool Message_VideoMessage::_internal_has_thumbnailsha256() const { - bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; - return value; -} -inline bool Message_VideoMessage::has_thumbnailsha256() const { - return _internal_has_thumbnailsha256(); -} -inline void Message_VideoMessage::clear_thumbnailsha256() { - _impl_.thumbnailsha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000400u; -} -inline const std::string& Message_VideoMessage::thumbnailsha256() const { - // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.thumbnailSha256) - return _internal_thumbnailsha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_VideoMessage::set_thumbnailsha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000400u; - _impl_.thumbnailsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.thumbnailSha256) -} -inline std::string* Message_VideoMessage::mutable_thumbnailsha256() { - std::string* _s = _internal_mutable_thumbnailsha256(); - // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.thumbnailSha256) - return _s; -} -inline const std::string& Message_VideoMessage::_internal_thumbnailsha256() const { - return _impl_.thumbnailsha256_.Get(); -} -inline void Message_VideoMessage::_internal_set_thumbnailsha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000400u; - _impl_.thumbnailsha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_VideoMessage::_internal_mutable_thumbnailsha256() { - _impl_._has_bits_[0] |= 0x00000400u; - return _impl_.thumbnailsha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_VideoMessage::release_thumbnailsha256() { - // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.thumbnailSha256) - if (!_internal_has_thumbnailsha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000400u; - auto* p = _impl_.thumbnailsha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.thumbnailsha256_.IsDefault()) { - _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_VideoMessage::set_allocated_thumbnailsha256(std::string* thumbnailsha256) { - if (thumbnailsha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00000400u; - } else { - _impl_._has_bits_[0] &= ~0x00000400u; - } - _impl_.thumbnailsha256_.SetAllocated(thumbnailsha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.thumbnailsha256_.IsDefault()) { - _impl_.thumbnailsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.thumbnailSha256) -} - -// optional bytes thumbnailEncSha256 = 23; -inline bool Message_VideoMessage::_internal_has_thumbnailencsha256() const { - bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; - return value; -} -inline bool Message_VideoMessage::has_thumbnailencsha256() const { - return _internal_has_thumbnailencsha256(); -} -inline void Message_VideoMessage::clear_thumbnailencsha256() { - _impl_.thumbnailencsha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000800u; -} -inline const std::string& Message_VideoMessage::thumbnailencsha256() const { - // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.thumbnailEncSha256) - return _internal_thumbnailencsha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_VideoMessage::set_thumbnailencsha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000800u; - _impl_.thumbnailencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.thumbnailEncSha256) -} -inline std::string* Message_VideoMessage::mutable_thumbnailencsha256() { - std::string* _s = _internal_mutable_thumbnailencsha256(); - // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.thumbnailEncSha256) - return _s; -} -inline const std::string& Message_VideoMessage::_internal_thumbnailencsha256() const { - return _impl_.thumbnailencsha256_.Get(); -} -inline void Message_VideoMessage::_internal_set_thumbnailencsha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000800u; - _impl_.thumbnailencsha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_VideoMessage::_internal_mutable_thumbnailencsha256() { - _impl_._has_bits_[0] |= 0x00000800u; - return _impl_.thumbnailencsha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_VideoMessage::release_thumbnailencsha256() { - // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.thumbnailEncSha256) - if (!_internal_has_thumbnailencsha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000800u; - auto* p = _impl_.thumbnailencsha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.thumbnailencsha256_.IsDefault()) { - _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_VideoMessage::set_allocated_thumbnailencsha256(std::string* thumbnailencsha256) { - if (thumbnailencsha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00000800u; - } else { - _impl_._has_bits_[0] &= ~0x00000800u; - } - _impl_.thumbnailencsha256_.SetAllocated(thumbnailencsha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.thumbnailencsha256_.IsDefault()) { - _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.thumbnailEncSha256) -} - -// optional string staticUrl = 24; -inline bool Message_VideoMessage::_internal_has_staticurl() const { - bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; - return value; -} -inline bool Message_VideoMessage::has_staticurl() const { - return _internal_has_staticurl(); -} -inline void Message_VideoMessage::clear_staticurl() { - _impl_.staticurl_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00001000u; -} -inline const std::string& Message_VideoMessage::staticurl() const { - // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.staticUrl) - return _internal_staticurl(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message_VideoMessage::set_staticurl(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00001000u; - _impl_.staticurl_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.staticUrl) -} -inline std::string* Message_VideoMessage::mutable_staticurl() { - std::string* _s = _internal_mutable_staticurl(); - // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.staticUrl) - return _s; -} -inline const std::string& Message_VideoMessage::_internal_staticurl() const { - return _impl_.staticurl_.Get(); -} -inline void Message_VideoMessage::_internal_set_staticurl(const std::string& value) { - _impl_._has_bits_[0] |= 0x00001000u; - _impl_.staticurl_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message_VideoMessage::_internal_mutable_staticurl() { - _impl_._has_bits_[0] |= 0x00001000u; - return _impl_.staticurl_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message_VideoMessage::release_staticurl() { - // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.staticUrl) - if (!_internal_has_staticurl()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00001000u; - auto* p = _impl_.staticurl_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.staticurl_.IsDefault()) { - _impl_.staticurl_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message_VideoMessage::set_allocated_staticurl(std::string* staticurl) { - if (staticurl != nullptr) { - _impl_._has_bits_[0] |= 0x00001000u; - } else { - _impl_._has_bits_[0] &= ~0x00001000u; - } - _impl_.staticurl_.SetAllocated(staticurl, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.staticurl_.IsDefault()) { - _impl_.staticurl_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.staticUrl) -} - -// ------------------------------------------------------------------- - -// Message - -// optional string conversation = 1; -inline bool Message::_internal_has_conversation() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Message::has_conversation() const { - return _internal_has_conversation(); -} -inline void Message::clear_conversation() { - _impl_.conversation_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Message::conversation() const { - // @@protoc_insertion_point(field_get:proto.Message.conversation) - return _internal_conversation(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Message::set_conversation(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.conversation_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Message.conversation) -} -inline std::string* Message::mutable_conversation() { - std::string* _s = _internal_mutable_conversation(); - // @@protoc_insertion_point(field_mutable:proto.Message.conversation) - return _s; -} -inline const std::string& Message::_internal_conversation() const { - return _impl_.conversation_.Get(); -} -inline void Message::_internal_set_conversation(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.conversation_.Set(value, GetArenaForAllocation()); -} -inline std::string* Message::_internal_mutable_conversation() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.conversation_.Mutable(GetArenaForAllocation()); -} -inline std::string* Message::release_conversation() { - // @@protoc_insertion_point(field_release:proto.Message.conversation) - if (!_internal_has_conversation()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.conversation_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.conversation_.IsDefault()) { - _impl_.conversation_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Message::set_allocated_conversation(std::string* conversation) { - if (conversation != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.conversation_.SetAllocated(conversation, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.conversation_.IsDefault()) { - _impl_.conversation_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Message.conversation) -} - -// optional .proto.Message.SenderKeyDistributionMessage senderKeyDistributionMessage = 2; -inline bool Message::_internal_has_senderkeydistributionmessage() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.senderkeydistributionmessage_ != nullptr); - return value; -} -inline bool Message::has_senderkeydistributionmessage() const { - return _internal_has_senderkeydistributionmessage(); -} -inline void Message::clear_senderkeydistributionmessage() { - if (_impl_.senderkeydistributionmessage_ != nullptr) _impl_.senderkeydistributionmessage_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::Message_SenderKeyDistributionMessage& Message::_internal_senderkeydistributionmessage() const { - const ::proto::Message_SenderKeyDistributionMessage* p = _impl_.senderkeydistributionmessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_SenderKeyDistributionMessage_default_instance_); -} -inline const ::proto::Message_SenderKeyDistributionMessage& Message::senderkeydistributionmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.senderKeyDistributionMessage) - return _internal_senderkeydistributionmessage(); -} -inline void Message::unsafe_arena_set_allocated_senderkeydistributionmessage( - ::proto::Message_SenderKeyDistributionMessage* senderkeydistributionmessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.senderkeydistributionmessage_); - } - _impl_.senderkeydistributionmessage_ = senderkeydistributionmessage; - if (senderkeydistributionmessage) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.senderKeyDistributionMessage) -} -inline ::proto::Message_SenderKeyDistributionMessage* Message::release_senderkeydistributionmessage() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::Message_SenderKeyDistributionMessage* temp = _impl_.senderkeydistributionmessage_; - _impl_.senderkeydistributionmessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_SenderKeyDistributionMessage* Message::unsafe_arena_release_senderkeydistributionmessage() { - // @@protoc_insertion_point(field_release:proto.Message.senderKeyDistributionMessage) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::Message_SenderKeyDistributionMessage* temp = _impl_.senderkeydistributionmessage_; - _impl_.senderkeydistributionmessage_ = nullptr; - return temp; -} -inline ::proto::Message_SenderKeyDistributionMessage* Message::_internal_mutable_senderkeydistributionmessage() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.senderkeydistributionmessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_SenderKeyDistributionMessage>(GetArenaForAllocation()); - _impl_.senderkeydistributionmessage_ = p; - } - return _impl_.senderkeydistributionmessage_; -} -inline ::proto::Message_SenderKeyDistributionMessage* Message::mutable_senderkeydistributionmessage() { - ::proto::Message_SenderKeyDistributionMessage* _msg = _internal_mutable_senderkeydistributionmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.senderKeyDistributionMessage) - return _msg; -} -inline void Message::set_allocated_senderkeydistributionmessage(::proto::Message_SenderKeyDistributionMessage* senderkeydistributionmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.senderkeydistributionmessage_; - } - if (senderkeydistributionmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(senderkeydistributionmessage); - if (message_arena != submessage_arena) { - senderkeydistributionmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, senderkeydistributionmessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.senderkeydistributionmessage_ = senderkeydistributionmessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.senderKeyDistributionMessage) -} - -// optional .proto.Message.ImageMessage imageMessage = 3; -inline bool Message::_internal_has_imagemessage() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - PROTOBUF_ASSUME(!value || _impl_.imagemessage_ != nullptr); - return value; -} -inline bool Message::has_imagemessage() const { - return _internal_has_imagemessage(); -} -inline void Message::clear_imagemessage() { - if (_impl_.imagemessage_ != nullptr) _impl_.imagemessage_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const ::proto::Message_ImageMessage& Message::_internal_imagemessage() const { - const ::proto::Message_ImageMessage* p = _impl_.imagemessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_ImageMessage_default_instance_); -} -inline const ::proto::Message_ImageMessage& Message::imagemessage() const { - // @@protoc_insertion_point(field_get:proto.Message.imageMessage) - return _internal_imagemessage(); -} -inline void Message::unsafe_arena_set_allocated_imagemessage( - ::proto::Message_ImageMessage* imagemessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.imagemessage_); - } - _impl_.imagemessage_ = imagemessage; - if (imagemessage) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.imageMessage) -} -inline ::proto::Message_ImageMessage* Message::release_imagemessage() { - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::Message_ImageMessage* temp = _impl_.imagemessage_; - _impl_.imagemessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_ImageMessage* Message::unsafe_arena_release_imagemessage() { - // @@protoc_insertion_point(field_release:proto.Message.imageMessage) - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::Message_ImageMessage* temp = _impl_.imagemessage_; - _impl_.imagemessage_ = nullptr; - return temp; -} -inline ::proto::Message_ImageMessage* Message::_internal_mutable_imagemessage() { - _impl_._has_bits_[0] |= 0x00000004u; - if (_impl_.imagemessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_ImageMessage>(GetArenaForAllocation()); - _impl_.imagemessage_ = p; - } - return _impl_.imagemessage_; -} -inline ::proto::Message_ImageMessage* Message::mutable_imagemessage() { - ::proto::Message_ImageMessage* _msg = _internal_mutable_imagemessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.imageMessage) - return _msg; -} -inline void Message::set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.imagemessage_; - } - if (imagemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(imagemessage); - if (message_arena != submessage_arena) { - imagemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, imagemessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.imagemessage_ = imagemessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.imageMessage) -} - -// optional .proto.Message.ContactMessage contactMessage = 4; -inline bool Message::_internal_has_contactmessage() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - PROTOBUF_ASSUME(!value || _impl_.contactmessage_ != nullptr); - return value; -} -inline bool Message::has_contactmessage() const { - return _internal_has_contactmessage(); -} -inline void Message::clear_contactmessage() { - if (_impl_.contactmessage_ != nullptr) _impl_.contactmessage_->Clear(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const ::proto::Message_ContactMessage& Message::_internal_contactmessage() const { - const ::proto::Message_ContactMessage* p = _impl_.contactmessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_ContactMessage_default_instance_); -} -inline const ::proto::Message_ContactMessage& Message::contactmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.contactMessage) - return _internal_contactmessage(); -} -inline void Message::unsafe_arena_set_allocated_contactmessage( - ::proto::Message_ContactMessage* contactmessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contactmessage_); - } - _impl_.contactmessage_ = contactmessage; - if (contactmessage) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.contactMessage) -} -inline ::proto::Message_ContactMessage* Message::release_contactmessage() { - _impl_._has_bits_[0] &= ~0x00000008u; - ::proto::Message_ContactMessage* temp = _impl_.contactmessage_; - _impl_.contactmessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_ContactMessage* Message::unsafe_arena_release_contactmessage() { - // @@protoc_insertion_point(field_release:proto.Message.contactMessage) - _impl_._has_bits_[0] &= ~0x00000008u; - ::proto::Message_ContactMessage* temp = _impl_.contactmessage_; - _impl_.contactmessage_ = nullptr; - return temp; -} -inline ::proto::Message_ContactMessage* Message::_internal_mutable_contactmessage() { - _impl_._has_bits_[0] |= 0x00000008u; - if (_impl_.contactmessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_ContactMessage>(GetArenaForAllocation()); - _impl_.contactmessage_ = p; - } - return _impl_.contactmessage_; -} -inline ::proto::Message_ContactMessage* Message::mutable_contactmessage() { - ::proto::Message_ContactMessage* _msg = _internal_mutable_contactmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.contactMessage) - return _msg; -} -inline void Message::set_allocated_contactmessage(::proto::Message_ContactMessage* contactmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.contactmessage_; - } - if (contactmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contactmessage); - if (message_arena != submessage_arena) { - contactmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, contactmessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.contactmessage_ = contactmessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.contactMessage) -} - -// optional .proto.Message.LocationMessage locationMessage = 5; -inline bool Message::_internal_has_locationmessage() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - PROTOBUF_ASSUME(!value || _impl_.locationmessage_ != nullptr); - return value; -} -inline bool Message::has_locationmessage() const { - return _internal_has_locationmessage(); -} -inline void Message::clear_locationmessage() { - if (_impl_.locationmessage_ != nullptr) _impl_.locationmessage_->Clear(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const ::proto::Message_LocationMessage& Message::_internal_locationmessage() const { - const ::proto::Message_LocationMessage* p = _impl_.locationmessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_LocationMessage_default_instance_); -} -inline const ::proto::Message_LocationMessage& Message::locationmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.locationMessage) - return _internal_locationmessage(); -} -inline void Message::unsafe_arena_set_allocated_locationmessage( - ::proto::Message_LocationMessage* locationmessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.locationmessage_); - } - _impl_.locationmessage_ = locationmessage; - if (locationmessage) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.locationMessage) -} -inline ::proto::Message_LocationMessage* Message::release_locationmessage() { - _impl_._has_bits_[0] &= ~0x00000010u; - ::proto::Message_LocationMessage* temp = _impl_.locationmessage_; - _impl_.locationmessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_LocationMessage* Message::unsafe_arena_release_locationmessage() { - // @@protoc_insertion_point(field_release:proto.Message.locationMessage) - _impl_._has_bits_[0] &= ~0x00000010u; - ::proto::Message_LocationMessage* temp = _impl_.locationmessage_; - _impl_.locationmessage_ = nullptr; - return temp; -} -inline ::proto::Message_LocationMessage* Message::_internal_mutable_locationmessage() { - _impl_._has_bits_[0] |= 0x00000010u; - if (_impl_.locationmessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_LocationMessage>(GetArenaForAllocation()); - _impl_.locationmessage_ = p; - } - return _impl_.locationmessage_; -} -inline ::proto::Message_LocationMessage* Message::mutable_locationmessage() { - ::proto::Message_LocationMessage* _msg = _internal_mutable_locationmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.locationMessage) - return _msg; -} -inline void Message::set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.locationmessage_; - } - if (locationmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(locationmessage); - if (message_arena != submessage_arena) { - locationmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, locationmessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.locationmessage_ = locationmessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.locationMessage) -} - -// optional .proto.Message.ExtendedTextMessage extendedTextMessage = 6; -inline bool Message::_internal_has_extendedtextmessage() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - PROTOBUF_ASSUME(!value || _impl_.extendedtextmessage_ != nullptr); - return value; -} -inline bool Message::has_extendedtextmessage() const { - return _internal_has_extendedtextmessage(); -} -inline void Message::clear_extendedtextmessage() { - if (_impl_.extendedtextmessage_ != nullptr) _impl_.extendedtextmessage_->Clear(); - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline const ::proto::Message_ExtendedTextMessage& Message::_internal_extendedtextmessage() const { - const ::proto::Message_ExtendedTextMessage* p = _impl_.extendedtextmessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_ExtendedTextMessage_default_instance_); -} -inline const ::proto::Message_ExtendedTextMessage& Message::extendedtextmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.extendedTextMessage) - return _internal_extendedtextmessage(); -} -inline void Message::unsafe_arena_set_allocated_extendedtextmessage( - ::proto::Message_ExtendedTextMessage* extendedtextmessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.extendedtextmessage_); - } - _impl_.extendedtextmessage_ = extendedtextmessage; - if (extendedtextmessage) { - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.extendedTextMessage) -} -inline ::proto::Message_ExtendedTextMessage* Message::release_extendedtextmessage() { - _impl_._has_bits_[0] &= ~0x00000020u; - ::proto::Message_ExtendedTextMessage* temp = _impl_.extendedtextmessage_; - _impl_.extendedtextmessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_ExtendedTextMessage* Message::unsafe_arena_release_extendedtextmessage() { - // @@protoc_insertion_point(field_release:proto.Message.extendedTextMessage) - _impl_._has_bits_[0] &= ~0x00000020u; - ::proto::Message_ExtendedTextMessage* temp = _impl_.extendedtextmessage_; - _impl_.extendedtextmessage_ = nullptr; - return temp; -} -inline ::proto::Message_ExtendedTextMessage* Message::_internal_mutable_extendedtextmessage() { - _impl_._has_bits_[0] |= 0x00000020u; - if (_impl_.extendedtextmessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_ExtendedTextMessage>(GetArenaForAllocation()); - _impl_.extendedtextmessage_ = p; - } - return _impl_.extendedtextmessage_; -} -inline ::proto::Message_ExtendedTextMessage* Message::mutable_extendedtextmessage() { - ::proto::Message_ExtendedTextMessage* _msg = _internal_mutable_extendedtextmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.extendedTextMessage) - return _msg; -} -inline void Message::set_allocated_extendedtextmessage(::proto::Message_ExtendedTextMessage* extendedtextmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.extendedtextmessage_; - } - if (extendedtextmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(extendedtextmessage); - if (message_arena != submessage_arena) { - extendedtextmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, extendedtextmessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - _impl_.extendedtextmessage_ = extendedtextmessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.extendedTextMessage) -} - -// optional .proto.Message.DocumentMessage documentMessage = 7; -inline bool Message::_internal_has_documentmessage() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - PROTOBUF_ASSUME(!value || _impl_.documentmessage_ != nullptr); - return value; -} -inline bool Message::has_documentmessage() const { - return _internal_has_documentmessage(); -} -inline void Message::clear_documentmessage() { - if (_impl_.documentmessage_ != nullptr) _impl_.documentmessage_->Clear(); - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline const ::proto::Message_DocumentMessage& Message::_internal_documentmessage() const { - const ::proto::Message_DocumentMessage* p = _impl_.documentmessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_DocumentMessage_default_instance_); -} -inline const ::proto::Message_DocumentMessage& Message::documentmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.documentMessage) - return _internal_documentmessage(); -} -inline void Message::unsafe_arena_set_allocated_documentmessage( - ::proto::Message_DocumentMessage* documentmessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.documentmessage_); - } - _impl_.documentmessage_ = documentmessage; - if (documentmessage) { - _impl_._has_bits_[0] |= 0x00000040u; - } else { - _impl_._has_bits_[0] &= ~0x00000040u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.documentMessage) -} -inline ::proto::Message_DocumentMessage* Message::release_documentmessage() { - _impl_._has_bits_[0] &= ~0x00000040u; - ::proto::Message_DocumentMessage* temp = _impl_.documentmessage_; - _impl_.documentmessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_DocumentMessage* Message::unsafe_arena_release_documentmessage() { - // @@protoc_insertion_point(field_release:proto.Message.documentMessage) - _impl_._has_bits_[0] &= ~0x00000040u; - ::proto::Message_DocumentMessage* temp = _impl_.documentmessage_; - _impl_.documentmessage_ = nullptr; - return temp; -} -inline ::proto::Message_DocumentMessage* Message::_internal_mutable_documentmessage() { - _impl_._has_bits_[0] |= 0x00000040u; - if (_impl_.documentmessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_DocumentMessage>(GetArenaForAllocation()); - _impl_.documentmessage_ = p; - } - return _impl_.documentmessage_; -} -inline ::proto::Message_DocumentMessage* Message::mutable_documentmessage() { - ::proto::Message_DocumentMessage* _msg = _internal_mutable_documentmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.documentMessage) - return _msg; -} -inline void Message::set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.documentmessage_; - } - if (documentmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(documentmessage); - if (message_arena != submessage_arena) { - documentmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, documentmessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000040u; - } else { - _impl_._has_bits_[0] &= ~0x00000040u; - } - _impl_.documentmessage_ = documentmessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.documentMessage) -} - -// optional .proto.Message.AudioMessage audioMessage = 8; -inline bool Message::_internal_has_audiomessage() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - PROTOBUF_ASSUME(!value || _impl_.audiomessage_ != nullptr); - return value; -} -inline bool Message::has_audiomessage() const { - return _internal_has_audiomessage(); -} -inline void Message::clear_audiomessage() { - if (_impl_.audiomessage_ != nullptr) _impl_.audiomessage_->Clear(); - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline const ::proto::Message_AudioMessage& Message::_internal_audiomessage() const { - const ::proto::Message_AudioMessage* p = _impl_.audiomessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_AudioMessage_default_instance_); -} -inline const ::proto::Message_AudioMessage& Message::audiomessage() const { - // @@protoc_insertion_point(field_get:proto.Message.audioMessage) - return _internal_audiomessage(); -} -inline void Message::unsafe_arena_set_allocated_audiomessage( - ::proto::Message_AudioMessage* audiomessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.audiomessage_); - } - _impl_.audiomessage_ = audiomessage; - if (audiomessage) { - _impl_._has_bits_[0] |= 0x00000080u; - } else { - _impl_._has_bits_[0] &= ~0x00000080u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.audioMessage) -} -inline ::proto::Message_AudioMessage* Message::release_audiomessage() { - _impl_._has_bits_[0] &= ~0x00000080u; - ::proto::Message_AudioMessage* temp = _impl_.audiomessage_; - _impl_.audiomessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_AudioMessage* Message::unsafe_arena_release_audiomessage() { - // @@protoc_insertion_point(field_release:proto.Message.audioMessage) - _impl_._has_bits_[0] &= ~0x00000080u; - ::proto::Message_AudioMessage* temp = _impl_.audiomessage_; - _impl_.audiomessage_ = nullptr; - return temp; -} -inline ::proto::Message_AudioMessage* Message::_internal_mutable_audiomessage() { - _impl_._has_bits_[0] |= 0x00000080u; - if (_impl_.audiomessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_AudioMessage>(GetArenaForAllocation()); - _impl_.audiomessage_ = p; - } - return _impl_.audiomessage_; -} -inline ::proto::Message_AudioMessage* Message::mutable_audiomessage() { - ::proto::Message_AudioMessage* _msg = _internal_mutable_audiomessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.audioMessage) - return _msg; -} -inline void Message::set_allocated_audiomessage(::proto::Message_AudioMessage* audiomessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.audiomessage_; - } - if (audiomessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(audiomessage); - if (message_arena != submessage_arena) { - audiomessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, audiomessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000080u; - } else { - _impl_._has_bits_[0] &= ~0x00000080u; - } - _impl_.audiomessage_ = audiomessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.audioMessage) -} - -// optional .proto.Message.VideoMessage videoMessage = 9; -inline bool Message::_internal_has_videomessage() const { - bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; - PROTOBUF_ASSUME(!value || _impl_.videomessage_ != nullptr); - return value; -} -inline bool Message::has_videomessage() const { - return _internal_has_videomessage(); -} -inline void Message::clear_videomessage() { - if (_impl_.videomessage_ != nullptr) _impl_.videomessage_->Clear(); - _impl_._has_bits_[0] &= ~0x00000100u; -} -inline const ::proto::Message_VideoMessage& Message::_internal_videomessage() const { - const ::proto::Message_VideoMessage* p = _impl_.videomessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_VideoMessage_default_instance_); -} -inline const ::proto::Message_VideoMessage& Message::videomessage() const { - // @@protoc_insertion_point(field_get:proto.Message.videoMessage) - return _internal_videomessage(); -} -inline void Message::unsafe_arena_set_allocated_videomessage( - ::proto::Message_VideoMessage* videomessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.videomessage_); - } - _impl_.videomessage_ = videomessage; - if (videomessage) { - _impl_._has_bits_[0] |= 0x00000100u; - } else { - _impl_._has_bits_[0] &= ~0x00000100u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.videoMessage) -} -inline ::proto::Message_VideoMessage* Message::release_videomessage() { - _impl_._has_bits_[0] &= ~0x00000100u; - ::proto::Message_VideoMessage* temp = _impl_.videomessage_; - _impl_.videomessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_VideoMessage* Message::unsafe_arena_release_videomessage() { - // @@protoc_insertion_point(field_release:proto.Message.videoMessage) - _impl_._has_bits_[0] &= ~0x00000100u; - ::proto::Message_VideoMessage* temp = _impl_.videomessage_; - _impl_.videomessage_ = nullptr; - return temp; -} -inline ::proto::Message_VideoMessage* Message::_internal_mutable_videomessage() { - _impl_._has_bits_[0] |= 0x00000100u; - if (_impl_.videomessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_VideoMessage>(GetArenaForAllocation()); - _impl_.videomessage_ = p; - } - return _impl_.videomessage_; -} -inline ::proto::Message_VideoMessage* Message::mutable_videomessage() { - ::proto::Message_VideoMessage* _msg = _internal_mutable_videomessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.videoMessage) - return _msg; -} -inline void Message::set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.videomessage_; - } - if (videomessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(videomessage); - if (message_arena != submessage_arena) { - videomessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, videomessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000100u; - } else { - _impl_._has_bits_[0] &= ~0x00000100u; - } - _impl_.videomessage_ = videomessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.videoMessage) -} - -// optional .proto.Message.Call call = 10; -inline bool Message::_internal_has_call() const { - bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; - PROTOBUF_ASSUME(!value || _impl_.call_ != nullptr); - return value; -} -inline bool Message::has_call() const { - return _internal_has_call(); -} -inline void Message::clear_call() { - if (_impl_.call_ != nullptr) _impl_.call_->Clear(); - _impl_._has_bits_[0] &= ~0x00000200u; -} -inline const ::proto::Message_Call& Message::_internal_call() const { - const ::proto::Message_Call* p = _impl_.call_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_Call_default_instance_); -} -inline const ::proto::Message_Call& Message::call() const { - // @@protoc_insertion_point(field_get:proto.Message.call) - return _internal_call(); -} -inline void Message::unsafe_arena_set_allocated_call( - ::proto::Message_Call* call) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.call_); - } - _impl_.call_ = call; - if (call) { - _impl_._has_bits_[0] |= 0x00000200u; - } else { - _impl_._has_bits_[0] &= ~0x00000200u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.call) -} -inline ::proto::Message_Call* Message::release_call() { - _impl_._has_bits_[0] &= ~0x00000200u; - ::proto::Message_Call* temp = _impl_.call_; - _impl_.call_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_Call* Message::unsafe_arena_release_call() { - // @@protoc_insertion_point(field_release:proto.Message.call) - _impl_._has_bits_[0] &= ~0x00000200u; - ::proto::Message_Call* temp = _impl_.call_; - _impl_.call_ = nullptr; - return temp; -} -inline ::proto::Message_Call* Message::_internal_mutable_call() { - _impl_._has_bits_[0] |= 0x00000200u; - if (_impl_.call_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_Call>(GetArenaForAllocation()); - _impl_.call_ = p; - } - return _impl_.call_; -} -inline ::proto::Message_Call* Message::mutable_call() { - ::proto::Message_Call* _msg = _internal_mutable_call(); - // @@protoc_insertion_point(field_mutable:proto.Message.call) - return _msg; -} -inline void Message::set_allocated_call(::proto::Message_Call* call) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.call_; - } - if (call) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(call); - if (message_arena != submessage_arena) { - call = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, call, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000200u; - } else { - _impl_._has_bits_[0] &= ~0x00000200u; - } - _impl_.call_ = call; - // @@protoc_insertion_point(field_set_allocated:proto.Message.call) -} - -// optional .proto.Message.Chat chat = 11; -inline bool Message::_internal_has_chat() const { - bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; - PROTOBUF_ASSUME(!value || _impl_.chat_ != nullptr); - return value; -} -inline bool Message::has_chat() const { - return _internal_has_chat(); -} -inline void Message::clear_chat() { - if (_impl_.chat_ != nullptr) _impl_.chat_->Clear(); - _impl_._has_bits_[0] &= ~0x00000400u; -} -inline const ::proto::Message_Chat& Message::_internal_chat() const { - const ::proto::Message_Chat* p = _impl_.chat_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_Chat_default_instance_); -} -inline const ::proto::Message_Chat& Message::chat() const { - // @@protoc_insertion_point(field_get:proto.Message.chat) - return _internal_chat(); -} -inline void Message::unsafe_arena_set_allocated_chat( - ::proto::Message_Chat* chat) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.chat_); - } - _impl_.chat_ = chat; - if (chat) { - _impl_._has_bits_[0] |= 0x00000400u; - } else { - _impl_._has_bits_[0] &= ~0x00000400u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.chat) -} -inline ::proto::Message_Chat* Message::release_chat() { - _impl_._has_bits_[0] &= ~0x00000400u; - ::proto::Message_Chat* temp = _impl_.chat_; - _impl_.chat_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_Chat* Message::unsafe_arena_release_chat() { - // @@protoc_insertion_point(field_release:proto.Message.chat) - _impl_._has_bits_[0] &= ~0x00000400u; - ::proto::Message_Chat* temp = _impl_.chat_; - _impl_.chat_ = nullptr; - return temp; -} -inline ::proto::Message_Chat* Message::_internal_mutable_chat() { - _impl_._has_bits_[0] |= 0x00000400u; - if (_impl_.chat_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_Chat>(GetArenaForAllocation()); - _impl_.chat_ = p; - } - return _impl_.chat_; -} -inline ::proto::Message_Chat* Message::mutable_chat() { - ::proto::Message_Chat* _msg = _internal_mutable_chat(); - // @@protoc_insertion_point(field_mutable:proto.Message.chat) - return _msg; -} -inline void Message::set_allocated_chat(::proto::Message_Chat* chat) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.chat_; - } - if (chat) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(chat); - if (message_arena != submessage_arena) { - chat = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, chat, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000400u; - } else { - _impl_._has_bits_[0] &= ~0x00000400u; - } - _impl_.chat_ = chat; - // @@protoc_insertion_point(field_set_allocated:proto.Message.chat) -} - -// optional .proto.Message.ProtocolMessage protocolMessage = 12; -inline bool Message::_internal_has_protocolmessage() const { - bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; - PROTOBUF_ASSUME(!value || _impl_.protocolmessage_ != nullptr); - return value; -} -inline bool Message::has_protocolmessage() const { - return _internal_has_protocolmessage(); -} -inline void Message::clear_protocolmessage() { - if (_impl_.protocolmessage_ != nullptr) _impl_.protocolmessage_->Clear(); - _impl_._has_bits_[0] &= ~0x00000800u; -} -inline const ::proto::Message_ProtocolMessage& Message::_internal_protocolmessage() const { - const ::proto::Message_ProtocolMessage* p = _impl_.protocolmessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_ProtocolMessage_default_instance_); -} -inline const ::proto::Message_ProtocolMessage& Message::protocolmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.protocolMessage) - return _internal_protocolmessage(); -} -inline void Message::unsafe_arena_set_allocated_protocolmessage( - ::proto::Message_ProtocolMessage* protocolmessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.protocolmessage_); - } - _impl_.protocolmessage_ = protocolmessage; - if (protocolmessage) { - _impl_._has_bits_[0] |= 0x00000800u; - } else { - _impl_._has_bits_[0] &= ~0x00000800u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.protocolMessage) -} -inline ::proto::Message_ProtocolMessage* Message::release_protocolmessage() { - _impl_._has_bits_[0] &= ~0x00000800u; - ::proto::Message_ProtocolMessage* temp = _impl_.protocolmessage_; - _impl_.protocolmessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_ProtocolMessage* Message::unsafe_arena_release_protocolmessage() { - // @@protoc_insertion_point(field_release:proto.Message.protocolMessage) - _impl_._has_bits_[0] &= ~0x00000800u; - ::proto::Message_ProtocolMessage* temp = _impl_.protocolmessage_; - _impl_.protocolmessage_ = nullptr; - return temp; -} -inline ::proto::Message_ProtocolMessage* Message::_internal_mutable_protocolmessage() { - _impl_._has_bits_[0] |= 0x00000800u; - if (_impl_.protocolmessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_ProtocolMessage>(GetArenaForAllocation()); - _impl_.protocolmessage_ = p; - } - return _impl_.protocolmessage_; -} -inline ::proto::Message_ProtocolMessage* Message::mutable_protocolmessage() { - ::proto::Message_ProtocolMessage* _msg = _internal_mutable_protocolmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.protocolMessage) - return _msg; -} -inline void Message::set_allocated_protocolmessage(::proto::Message_ProtocolMessage* protocolmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.protocolmessage_; - } - if (protocolmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(protocolmessage); - if (message_arena != submessage_arena) { - protocolmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, protocolmessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000800u; - } else { - _impl_._has_bits_[0] &= ~0x00000800u; - } - _impl_.protocolmessage_ = protocolmessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.protocolMessage) -} - -// optional .proto.Message.ContactsArrayMessage contactsArrayMessage = 13; -inline bool Message::_internal_has_contactsarraymessage() const { - bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.contactsarraymessage_ != nullptr); - return value; -} -inline bool Message::has_contactsarraymessage() const { - return _internal_has_contactsarraymessage(); -} -inline void Message::clear_contactsarraymessage() { - if (_impl_.contactsarraymessage_ != nullptr) _impl_.contactsarraymessage_->Clear(); - _impl_._has_bits_[0] &= ~0x00001000u; -} -inline const ::proto::Message_ContactsArrayMessage& Message::_internal_contactsarraymessage() const { - const ::proto::Message_ContactsArrayMessage* p = _impl_.contactsarraymessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_ContactsArrayMessage_default_instance_); -} -inline const ::proto::Message_ContactsArrayMessage& Message::contactsarraymessage() const { - // @@protoc_insertion_point(field_get:proto.Message.contactsArrayMessage) - return _internal_contactsarraymessage(); -} -inline void Message::unsafe_arena_set_allocated_contactsarraymessage( - ::proto::Message_ContactsArrayMessage* contactsarraymessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contactsarraymessage_); - } - _impl_.contactsarraymessage_ = contactsarraymessage; - if (contactsarraymessage) { - _impl_._has_bits_[0] |= 0x00001000u; - } else { - _impl_._has_bits_[0] &= ~0x00001000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.contactsArrayMessage) -} -inline ::proto::Message_ContactsArrayMessage* Message::release_contactsarraymessage() { - _impl_._has_bits_[0] &= ~0x00001000u; - ::proto::Message_ContactsArrayMessage* temp = _impl_.contactsarraymessage_; - _impl_.contactsarraymessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_ContactsArrayMessage* Message::unsafe_arena_release_contactsarraymessage() { - // @@protoc_insertion_point(field_release:proto.Message.contactsArrayMessage) - _impl_._has_bits_[0] &= ~0x00001000u; - ::proto::Message_ContactsArrayMessage* temp = _impl_.contactsarraymessage_; - _impl_.contactsarraymessage_ = nullptr; - return temp; -} -inline ::proto::Message_ContactsArrayMessage* Message::_internal_mutable_contactsarraymessage() { - _impl_._has_bits_[0] |= 0x00001000u; - if (_impl_.contactsarraymessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_ContactsArrayMessage>(GetArenaForAllocation()); - _impl_.contactsarraymessage_ = p; - } - return _impl_.contactsarraymessage_; -} -inline ::proto::Message_ContactsArrayMessage* Message::mutable_contactsarraymessage() { - ::proto::Message_ContactsArrayMessage* _msg = _internal_mutable_contactsarraymessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.contactsArrayMessage) - return _msg; -} -inline void Message::set_allocated_contactsarraymessage(::proto::Message_ContactsArrayMessage* contactsarraymessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.contactsarraymessage_; - } - if (contactsarraymessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contactsarraymessage); - if (message_arena != submessage_arena) { - contactsarraymessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, contactsarraymessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00001000u; - } else { - _impl_._has_bits_[0] &= ~0x00001000u; - } - _impl_.contactsarraymessage_ = contactsarraymessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.contactsArrayMessage) -} - -// optional .proto.Message.HighlyStructuredMessage highlyStructuredMessage = 14; -inline bool Message::_internal_has_highlystructuredmessage() const { - bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.highlystructuredmessage_ != nullptr); - return value; -} -inline bool Message::has_highlystructuredmessage() const { - return _internal_has_highlystructuredmessage(); -} -inline void Message::clear_highlystructuredmessage() { - if (_impl_.highlystructuredmessage_ != nullptr) _impl_.highlystructuredmessage_->Clear(); - _impl_._has_bits_[0] &= ~0x00002000u; -} -inline const ::proto::Message_HighlyStructuredMessage& Message::_internal_highlystructuredmessage() const { - const ::proto::Message_HighlyStructuredMessage* p = _impl_.highlystructuredmessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_HighlyStructuredMessage_default_instance_); -} -inline const ::proto::Message_HighlyStructuredMessage& Message::highlystructuredmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.highlyStructuredMessage) - return _internal_highlystructuredmessage(); -} -inline void Message::unsafe_arena_set_allocated_highlystructuredmessage( - ::proto::Message_HighlyStructuredMessage* highlystructuredmessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.highlystructuredmessage_); - } - _impl_.highlystructuredmessage_ = highlystructuredmessage; - if (highlystructuredmessage) { - _impl_._has_bits_[0] |= 0x00002000u; - } else { - _impl_._has_bits_[0] &= ~0x00002000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.highlyStructuredMessage) -} -inline ::proto::Message_HighlyStructuredMessage* Message::release_highlystructuredmessage() { - _impl_._has_bits_[0] &= ~0x00002000u; - ::proto::Message_HighlyStructuredMessage* temp = _impl_.highlystructuredmessage_; - _impl_.highlystructuredmessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_HighlyStructuredMessage* Message::unsafe_arena_release_highlystructuredmessage() { - // @@protoc_insertion_point(field_release:proto.Message.highlyStructuredMessage) - _impl_._has_bits_[0] &= ~0x00002000u; - ::proto::Message_HighlyStructuredMessage* temp = _impl_.highlystructuredmessage_; - _impl_.highlystructuredmessage_ = nullptr; - return temp; -} -inline ::proto::Message_HighlyStructuredMessage* Message::_internal_mutable_highlystructuredmessage() { - _impl_._has_bits_[0] |= 0x00002000u; - if (_impl_.highlystructuredmessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation()); - _impl_.highlystructuredmessage_ = p; - } - return _impl_.highlystructuredmessage_; -} -inline ::proto::Message_HighlyStructuredMessage* Message::mutable_highlystructuredmessage() { - ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_highlystructuredmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.highlyStructuredMessage) - return _msg; -} -inline void Message::set_allocated_highlystructuredmessage(::proto::Message_HighlyStructuredMessage* highlystructuredmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.highlystructuredmessage_; - } - if (highlystructuredmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(highlystructuredmessage); - if (message_arena != submessage_arena) { - highlystructuredmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, highlystructuredmessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00002000u; - } else { - _impl_._has_bits_[0] &= ~0x00002000u; - } - _impl_.highlystructuredmessage_ = highlystructuredmessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.highlyStructuredMessage) -} - -// optional .proto.Message.SenderKeyDistributionMessage fastRatchetKeySenderKeyDistributionMessage = 15; -inline bool Message::_internal_has_fastratchetkeysenderkeydistributionmessage() const { - bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.fastratchetkeysenderkeydistributionmessage_ != nullptr); - return value; -} -inline bool Message::has_fastratchetkeysenderkeydistributionmessage() const { - return _internal_has_fastratchetkeysenderkeydistributionmessage(); -} -inline void Message::clear_fastratchetkeysenderkeydistributionmessage() { - if (_impl_.fastratchetkeysenderkeydistributionmessage_ != nullptr) _impl_.fastratchetkeysenderkeydistributionmessage_->Clear(); - _impl_._has_bits_[0] &= ~0x00004000u; -} -inline const ::proto::Message_SenderKeyDistributionMessage& Message::_internal_fastratchetkeysenderkeydistributionmessage() const { - const ::proto::Message_SenderKeyDistributionMessage* p = _impl_.fastratchetkeysenderkeydistributionmessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_SenderKeyDistributionMessage_default_instance_); -} -inline const ::proto::Message_SenderKeyDistributionMessage& Message::fastratchetkeysenderkeydistributionmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.fastRatchetKeySenderKeyDistributionMessage) - return _internal_fastratchetkeysenderkeydistributionmessage(); -} -inline void Message::unsafe_arena_set_allocated_fastratchetkeysenderkeydistributionmessage( - ::proto::Message_SenderKeyDistributionMessage* fastratchetkeysenderkeydistributionmessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.fastratchetkeysenderkeydistributionmessage_); - } - _impl_.fastratchetkeysenderkeydistributionmessage_ = fastratchetkeysenderkeydistributionmessage; - if (fastratchetkeysenderkeydistributionmessage) { - _impl_._has_bits_[0] |= 0x00004000u; - } else { - _impl_._has_bits_[0] &= ~0x00004000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.fastRatchetKeySenderKeyDistributionMessage) -} -inline ::proto::Message_SenderKeyDistributionMessage* Message::release_fastratchetkeysenderkeydistributionmessage() { - _impl_._has_bits_[0] &= ~0x00004000u; - ::proto::Message_SenderKeyDistributionMessage* temp = _impl_.fastratchetkeysenderkeydistributionmessage_; - _impl_.fastratchetkeysenderkeydistributionmessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_SenderKeyDistributionMessage* Message::unsafe_arena_release_fastratchetkeysenderkeydistributionmessage() { - // @@protoc_insertion_point(field_release:proto.Message.fastRatchetKeySenderKeyDistributionMessage) - _impl_._has_bits_[0] &= ~0x00004000u; - ::proto::Message_SenderKeyDistributionMessage* temp = _impl_.fastratchetkeysenderkeydistributionmessage_; - _impl_.fastratchetkeysenderkeydistributionmessage_ = nullptr; - return temp; -} -inline ::proto::Message_SenderKeyDistributionMessage* Message::_internal_mutable_fastratchetkeysenderkeydistributionmessage() { - _impl_._has_bits_[0] |= 0x00004000u; - if (_impl_.fastratchetkeysenderkeydistributionmessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_SenderKeyDistributionMessage>(GetArenaForAllocation()); - _impl_.fastratchetkeysenderkeydistributionmessage_ = p; - } - return _impl_.fastratchetkeysenderkeydistributionmessage_; -} -inline ::proto::Message_SenderKeyDistributionMessage* Message::mutable_fastratchetkeysenderkeydistributionmessage() { - ::proto::Message_SenderKeyDistributionMessage* _msg = _internal_mutable_fastratchetkeysenderkeydistributionmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.fastRatchetKeySenderKeyDistributionMessage) - return _msg; -} -inline void Message::set_allocated_fastratchetkeysenderkeydistributionmessage(::proto::Message_SenderKeyDistributionMessage* fastratchetkeysenderkeydistributionmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.fastratchetkeysenderkeydistributionmessage_; - } - if (fastratchetkeysenderkeydistributionmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(fastratchetkeysenderkeydistributionmessage); - if (message_arena != submessage_arena) { - fastratchetkeysenderkeydistributionmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, fastratchetkeysenderkeydistributionmessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00004000u; - } else { - _impl_._has_bits_[0] &= ~0x00004000u; - } - _impl_.fastratchetkeysenderkeydistributionmessage_ = fastratchetkeysenderkeydistributionmessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.fastRatchetKeySenderKeyDistributionMessage) -} - -// optional .proto.Message.SendPaymentMessage sendPaymentMessage = 16; -inline bool Message::_internal_has_sendpaymentmessage() const { - bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.sendpaymentmessage_ != nullptr); - return value; -} -inline bool Message::has_sendpaymentmessage() const { - return _internal_has_sendpaymentmessage(); -} -inline void Message::clear_sendpaymentmessage() { - if (_impl_.sendpaymentmessage_ != nullptr) _impl_.sendpaymentmessage_->Clear(); - _impl_._has_bits_[0] &= ~0x00008000u; -} -inline const ::proto::Message_SendPaymentMessage& Message::_internal_sendpaymentmessage() const { - const ::proto::Message_SendPaymentMessage* p = _impl_.sendpaymentmessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_SendPaymentMessage_default_instance_); -} -inline const ::proto::Message_SendPaymentMessage& Message::sendpaymentmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.sendPaymentMessage) - return _internal_sendpaymentmessage(); -} -inline void Message::unsafe_arena_set_allocated_sendpaymentmessage( - ::proto::Message_SendPaymentMessage* sendpaymentmessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.sendpaymentmessage_); - } - _impl_.sendpaymentmessage_ = sendpaymentmessage; - if (sendpaymentmessage) { - _impl_._has_bits_[0] |= 0x00008000u; - } else { - _impl_._has_bits_[0] &= ~0x00008000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.sendPaymentMessage) -} -inline ::proto::Message_SendPaymentMessage* Message::release_sendpaymentmessage() { - _impl_._has_bits_[0] &= ~0x00008000u; - ::proto::Message_SendPaymentMessage* temp = _impl_.sendpaymentmessage_; - _impl_.sendpaymentmessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_SendPaymentMessage* Message::unsafe_arena_release_sendpaymentmessage() { - // @@protoc_insertion_point(field_release:proto.Message.sendPaymentMessage) - _impl_._has_bits_[0] &= ~0x00008000u; - ::proto::Message_SendPaymentMessage* temp = _impl_.sendpaymentmessage_; - _impl_.sendpaymentmessage_ = nullptr; - return temp; -} -inline ::proto::Message_SendPaymentMessage* Message::_internal_mutable_sendpaymentmessage() { - _impl_._has_bits_[0] |= 0x00008000u; - if (_impl_.sendpaymentmessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_SendPaymentMessage>(GetArenaForAllocation()); - _impl_.sendpaymentmessage_ = p; - } - return _impl_.sendpaymentmessage_; -} -inline ::proto::Message_SendPaymentMessage* Message::mutable_sendpaymentmessage() { - ::proto::Message_SendPaymentMessage* _msg = _internal_mutable_sendpaymentmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.sendPaymentMessage) - return _msg; -} -inline void Message::set_allocated_sendpaymentmessage(::proto::Message_SendPaymentMessage* sendpaymentmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.sendpaymentmessage_; - } - if (sendpaymentmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(sendpaymentmessage); - if (message_arena != submessage_arena) { - sendpaymentmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, sendpaymentmessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00008000u; - } else { - _impl_._has_bits_[0] &= ~0x00008000u; - } - _impl_.sendpaymentmessage_ = sendpaymentmessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.sendPaymentMessage) -} - -// optional .proto.Message.LiveLocationMessage liveLocationMessage = 18; -inline bool Message::_internal_has_livelocationmessage() const { - bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.livelocationmessage_ != nullptr); - return value; -} -inline bool Message::has_livelocationmessage() const { - return _internal_has_livelocationmessage(); -} -inline void Message::clear_livelocationmessage() { - if (_impl_.livelocationmessage_ != nullptr) _impl_.livelocationmessage_->Clear(); - _impl_._has_bits_[0] &= ~0x00010000u; -} -inline const ::proto::Message_LiveLocationMessage& Message::_internal_livelocationmessage() const { - const ::proto::Message_LiveLocationMessage* p = _impl_.livelocationmessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_LiveLocationMessage_default_instance_); -} -inline const ::proto::Message_LiveLocationMessage& Message::livelocationmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.liveLocationMessage) - return _internal_livelocationmessage(); -} -inline void Message::unsafe_arena_set_allocated_livelocationmessage( - ::proto::Message_LiveLocationMessage* livelocationmessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.livelocationmessage_); - } - _impl_.livelocationmessage_ = livelocationmessage; - if (livelocationmessage) { - _impl_._has_bits_[0] |= 0x00010000u; - } else { - _impl_._has_bits_[0] &= ~0x00010000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.liveLocationMessage) -} -inline ::proto::Message_LiveLocationMessage* Message::release_livelocationmessage() { - _impl_._has_bits_[0] &= ~0x00010000u; - ::proto::Message_LiveLocationMessage* temp = _impl_.livelocationmessage_; - _impl_.livelocationmessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_LiveLocationMessage* Message::unsafe_arena_release_livelocationmessage() { - // @@protoc_insertion_point(field_release:proto.Message.liveLocationMessage) - _impl_._has_bits_[0] &= ~0x00010000u; - ::proto::Message_LiveLocationMessage* temp = _impl_.livelocationmessage_; - _impl_.livelocationmessage_ = nullptr; - return temp; -} -inline ::proto::Message_LiveLocationMessage* Message::_internal_mutable_livelocationmessage() { - _impl_._has_bits_[0] |= 0x00010000u; - if (_impl_.livelocationmessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_LiveLocationMessage>(GetArenaForAllocation()); - _impl_.livelocationmessage_ = p; - } - return _impl_.livelocationmessage_; -} -inline ::proto::Message_LiveLocationMessage* Message::mutable_livelocationmessage() { - ::proto::Message_LiveLocationMessage* _msg = _internal_mutable_livelocationmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.liveLocationMessage) - return _msg; -} -inline void Message::set_allocated_livelocationmessage(::proto::Message_LiveLocationMessage* livelocationmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.livelocationmessage_; - } - if (livelocationmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(livelocationmessage); - if (message_arena != submessage_arena) { - livelocationmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, livelocationmessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00010000u; - } else { - _impl_._has_bits_[0] &= ~0x00010000u; - } - _impl_.livelocationmessage_ = livelocationmessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.liveLocationMessage) -} - -// optional .proto.Message.RequestPaymentMessage requestPaymentMessage = 22; -inline bool Message::_internal_has_requestpaymentmessage() const { - bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.requestpaymentmessage_ != nullptr); - return value; -} -inline bool Message::has_requestpaymentmessage() const { - return _internal_has_requestpaymentmessage(); -} -inline void Message::clear_requestpaymentmessage() { - if (_impl_.requestpaymentmessage_ != nullptr) _impl_.requestpaymentmessage_->Clear(); - _impl_._has_bits_[0] &= ~0x00020000u; -} -inline const ::proto::Message_RequestPaymentMessage& Message::_internal_requestpaymentmessage() const { - const ::proto::Message_RequestPaymentMessage* p = _impl_.requestpaymentmessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_RequestPaymentMessage_default_instance_); -} -inline const ::proto::Message_RequestPaymentMessage& Message::requestpaymentmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.requestPaymentMessage) - return _internal_requestpaymentmessage(); -} -inline void Message::unsafe_arena_set_allocated_requestpaymentmessage( - ::proto::Message_RequestPaymentMessage* requestpaymentmessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.requestpaymentmessage_); - } - _impl_.requestpaymentmessage_ = requestpaymentmessage; - if (requestpaymentmessage) { - _impl_._has_bits_[0] |= 0x00020000u; - } else { - _impl_._has_bits_[0] &= ~0x00020000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.requestPaymentMessage) -} -inline ::proto::Message_RequestPaymentMessage* Message::release_requestpaymentmessage() { - _impl_._has_bits_[0] &= ~0x00020000u; - ::proto::Message_RequestPaymentMessage* temp = _impl_.requestpaymentmessage_; - _impl_.requestpaymentmessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_RequestPaymentMessage* Message::unsafe_arena_release_requestpaymentmessage() { - // @@protoc_insertion_point(field_release:proto.Message.requestPaymentMessage) - _impl_._has_bits_[0] &= ~0x00020000u; - ::proto::Message_RequestPaymentMessage* temp = _impl_.requestpaymentmessage_; - _impl_.requestpaymentmessage_ = nullptr; - return temp; -} -inline ::proto::Message_RequestPaymentMessage* Message::_internal_mutable_requestpaymentmessage() { - _impl_._has_bits_[0] |= 0x00020000u; - if (_impl_.requestpaymentmessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_RequestPaymentMessage>(GetArenaForAllocation()); - _impl_.requestpaymentmessage_ = p; - } - return _impl_.requestpaymentmessage_; -} -inline ::proto::Message_RequestPaymentMessage* Message::mutable_requestpaymentmessage() { - ::proto::Message_RequestPaymentMessage* _msg = _internal_mutable_requestpaymentmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.requestPaymentMessage) - return _msg; -} -inline void Message::set_allocated_requestpaymentmessage(::proto::Message_RequestPaymentMessage* requestpaymentmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.requestpaymentmessage_; - } - if (requestpaymentmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(requestpaymentmessage); - if (message_arena != submessage_arena) { - requestpaymentmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, requestpaymentmessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00020000u; - } else { - _impl_._has_bits_[0] &= ~0x00020000u; - } - _impl_.requestpaymentmessage_ = requestpaymentmessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.requestPaymentMessage) -} - -// optional .proto.Message.DeclinePaymentRequestMessage declinePaymentRequestMessage = 23; -inline bool Message::_internal_has_declinepaymentrequestmessage() const { - bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.declinepaymentrequestmessage_ != nullptr); - return value; -} -inline bool Message::has_declinepaymentrequestmessage() const { - return _internal_has_declinepaymentrequestmessage(); -} -inline void Message::clear_declinepaymentrequestmessage() { - if (_impl_.declinepaymentrequestmessage_ != nullptr) _impl_.declinepaymentrequestmessage_->Clear(); - _impl_._has_bits_[0] &= ~0x00040000u; -} -inline const ::proto::Message_DeclinePaymentRequestMessage& Message::_internal_declinepaymentrequestmessage() const { - const ::proto::Message_DeclinePaymentRequestMessage* p = _impl_.declinepaymentrequestmessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_DeclinePaymentRequestMessage_default_instance_); -} -inline const ::proto::Message_DeclinePaymentRequestMessage& Message::declinepaymentrequestmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.declinePaymentRequestMessage) - return _internal_declinepaymentrequestmessage(); -} -inline void Message::unsafe_arena_set_allocated_declinepaymentrequestmessage( - ::proto::Message_DeclinePaymentRequestMessage* declinepaymentrequestmessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.declinepaymentrequestmessage_); - } - _impl_.declinepaymentrequestmessage_ = declinepaymentrequestmessage; - if (declinepaymentrequestmessage) { - _impl_._has_bits_[0] |= 0x00040000u; - } else { - _impl_._has_bits_[0] &= ~0x00040000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.declinePaymentRequestMessage) -} -inline ::proto::Message_DeclinePaymentRequestMessage* Message::release_declinepaymentrequestmessage() { - _impl_._has_bits_[0] &= ~0x00040000u; - ::proto::Message_DeclinePaymentRequestMessage* temp = _impl_.declinepaymentrequestmessage_; - _impl_.declinepaymentrequestmessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_DeclinePaymentRequestMessage* Message::unsafe_arena_release_declinepaymentrequestmessage() { - // @@protoc_insertion_point(field_release:proto.Message.declinePaymentRequestMessage) - _impl_._has_bits_[0] &= ~0x00040000u; - ::proto::Message_DeclinePaymentRequestMessage* temp = _impl_.declinepaymentrequestmessage_; - _impl_.declinepaymentrequestmessage_ = nullptr; - return temp; -} -inline ::proto::Message_DeclinePaymentRequestMessage* Message::_internal_mutable_declinepaymentrequestmessage() { - _impl_._has_bits_[0] |= 0x00040000u; - if (_impl_.declinepaymentrequestmessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_DeclinePaymentRequestMessage>(GetArenaForAllocation()); - _impl_.declinepaymentrequestmessage_ = p; - } - return _impl_.declinepaymentrequestmessage_; -} -inline ::proto::Message_DeclinePaymentRequestMessage* Message::mutable_declinepaymentrequestmessage() { - ::proto::Message_DeclinePaymentRequestMessage* _msg = _internal_mutable_declinepaymentrequestmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.declinePaymentRequestMessage) - return _msg; -} -inline void Message::set_allocated_declinepaymentrequestmessage(::proto::Message_DeclinePaymentRequestMessage* declinepaymentrequestmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.declinepaymentrequestmessage_; - } - if (declinepaymentrequestmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(declinepaymentrequestmessage); - if (message_arena != submessage_arena) { - declinepaymentrequestmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, declinepaymentrequestmessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00040000u; - } else { - _impl_._has_bits_[0] &= ~0x00040000u; - } - _impl_.declinepaymentrequestmessage_ = declinepaymentrequestmessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.declinePaymentRequestMessage) -} - -// optional .proto.Message.CancelPaymentRequestMessage cancelPaymentRequestMessage = 24; -inline bool Message::_internal_has_cancelpaymentrequestmessage() const { - bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.cancelpaymentrequestmessage_ != nullptr); - return value; -} -inline bool Message::has_cancelpaymentrequestmessage() const { - return _internal_has_cancelpaymentrequestmessage(); -} -inline void Message::clear_cancelpaymentrequestmessage() { - if (_impl_.cancelpaymentrequestmessage_ != nullptr) _impl_.cancelpaymentrequestmessage_->Clear(); - _impl_._has_bits_[0] &= ~0x00080000u; -} -inline const ::proto::Message_CancelPaymentRequestMessage& Message::_internal_cancelpaymentrequestmessage() const { - const ::proto::Message_CancelPaymentRequestMessage* p = _impl_.cancelpaymentrequestmessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_CancelPaymentRequestMessage_default_instance_); -} -inline const ::proto::Message_CancelPaymentRequestMessage& Message::cancelpaymentrequestmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.cancelPaymentRequestMessage) - return _internal_cancelpaymentrequestmessage(); -} -inline void Message::unsafe_arena_set_allocated_cancelpaymentrequestmessage( - ::proto::Message_CancelPaymentRequestMessage* cancelpaymentrequestmessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cancelpaymentrequestmessage_); - } - _impl_.cancelpaymentrequestmessage_ = cancelpaymentrequestmessage; - if (cancelpaymentrequestmessage) { - _impl_._has_bits_[0] |= 0x00080000u; - } else { - _impl_._has_bits_[0] &= ~0x00080000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.cancelPaymentRequestMessage) -} -inline ::proto::Message_CancelPaymentRequestMessage* Message::release_cancelpaymentrequestmessage() { - _impl_._has_bits_[0] &= ~0x00080000u; - ::proto::Message_CancelPaymentRequestMessage* temp = _impl_.cancelpaymentrequestmessage_; - _impl_.cancelpaymentrequestmessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_CancelPaymentRequestMessage* Message::unsafe_arena_release_cancelpaymentrequestmessage() { - // @@protoc_insertion_point(field_release:proto.Message.cancelPaymentRequestMessage) - _impl_._has_bits_[0] &= ~0x00080000u; - ::proto::Message_CancelPaymentRequestMessage* temp = _impl_.cancelpaymentrequestmessage_; - _impl_.cancelpaymentrequestmessage_ = nullptr; - return temp; -} -inline ::proto::Message_CancelPaymentRequestMessage* Message::_internal_mutable_cancelpaymentrequestmessage() { - _impl_._has_bits_[0] |= 0x00080000u; - if (_impl_.cancelpaymentrequestmessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_CancelPaymentRequestMessage>(GetArenaForAllocation()); - _impl_.cancelpaymentrequestmessage_ = p; - } - return _impl_.cancelpaymentrequestmessage_; -} -inline ::proto::Message_CancelPaymentRequestMessage* Message::mutable_cancelpaymentrequestmessage() { - ::proto::Message_CancelPaymentRequestMessage* _msg = _internal_mutable_cancelpaymentrequestmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.cancelPaymentRequestMessage) - return _msg; -} -inline void Message::set_allocated_cancelpaymentrequestmessage(::proto::Message_CancelPaymentRequestMessage* cancelpaymentrequestmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.cancelpaymentrequestmessage_; - } - if (cancelpaymentrequestmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(cancelpaymentrequestmessage); - if (message_arena != submessage_arena) { - cancelpaymentrequestmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, cancelpaymentrequestmessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00080000u; - } else { - _impl_._has_bits_[0] &= ~0x00080000u; - } - _impl_.cancelpaymentrequestmessage_ = cancelpaymentrequestmessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.cancelPaymentRequestMessage) -} - -// optional .proto.Message.TemplateMessage templateMessage = 25; -inline bool Message::_internal_has_templatemessage() const { - bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.templatemessage_ != nullptr); - return value; -} -inline bool Message::has_templatemessage() const { - return _internal_has_templatemessage(); -} -inline void Message::clear_templatemessage() { - if (_impl_.templatemessage_ != nullptr) _impl_.templatemessage_->Clear(); - _impl_._has_bits_[0] &= ~0x00100000u; -} -inline const ::proto::Message_TemplateMessage& Message::_internal_templatemessage() const { - const ::proto::Message_TemplateMessage* p = _impl_.templatemessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_TemplateMessage_default_instance_); -} -inline const ::proto::Message_TemplateMessage& Message::templatemessage() const { - // @@protoc_insertion_point(field_get:proto.Message.templateMessage) - return _internal_templatemessage(); -} -inline void Message::unsafe_arena_set_allocated_templatemessage( - ::proto::Message_TemplateMessage* templatemessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.templatemessage_); - } - _impl_.templatemessage_ = templatemessage; - if (templatemessage) { - _impl_._has_bits_[0] |= 0x00100000u; - } else { - _impl_._has_bits_[0] &= ~0x00100000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.templateMessage) -} -inline ::proto::Message_TemplateMessage* Message::release_templatemessage() { - _impl_._has_bits_[0] &= ~0x00100000u; - ::proto::Message_TemplateMessage* temp = _impl_.templatemessage_; - _impl_.templatemessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_TemplateMessage* Message::unsafe_arena_release_templatemessage() { - // @@protoc_insertion_point(field_release:proto.Message.templateMessage) - _impl_._has_bits_[0] &= ~0x00100000u; - ::proto::Message_TemplateMessage* temp = _impl_.templatemessage_; - _impl_.templatemessage_ = nullptr; - return temp; -} -inline ::proto::Message_TemplateMessage* Message::_internal_mutable_templatemessage() { - _impl_._has_bits_[0] |= 0x00100000u; - if (_impl_.templatemessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_TemplateMessage>(GetArenaForAllocation()); - _impl_.templatemessage_ = p; - } - return _impl_.templatemessage_; -} -inline ::proto::Message_TemplateMessage* Message::mutable_templatemessage() { - ::proto::Message_TemplateMessage* _msg = _internal_mutable_templatemessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.templateMessage) - return _msg; -} -inline void Message::set_allocated_templatemessage(::proto::Message_TemplateMessage* templatemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.templatemessage_; - } - if (templatemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(templatemessage); - if (message_arena != submessage_arena) { - templatemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, templatemessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00100000u; - } else { - _impl_._has_bits_[0] &= ~0x00100000u; - } - _impl_.templatemessage_ = templatemessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.templateMessage) -} - -// optional .proto.Message.StickerMessage stickerMessage = 26; -inline bool Message::_internal_has_stickermessage() const { - bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.stickermessage_ != nullptr); - return value; -} -inline bool Message::has_stickermessage() const { - return _internal_has_stickermessage(); -} -inline void Message::clear_stickermessage() { - if (_impl_.stickermessage_ != nullptr) _impl_.stickermessage_->Clear(); - _impl_._has_bits_[0] &= ~0x00200000u; -} -inline const ::proto::Message_StickerMessage& Message::_internal_stickermessage() const { - const ::proto::Message_StickerMessage* p = _impl_.stickermessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_StickerMessage_default_instance_); -} -inline const ::proto::Message_StickerMessage& Message::stickermessage() const { - // @@protoc_insertion_point(field_get:proto.Message.stickerMessage) - return _internal_stickermessage(); -} -inline void Message::unsafe_arena_set_allocated_stickermessage( - ::proto::Message_StickerMessage* stickermessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.stickermessage_); - } - _impl_.stickermessage_ = stickermessage; - if (stickermessage) { - _impl_._has_bits_[0] |= 0x00200000u; - } else { - _impl_._has_bits_[0] &= ~0x00200000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.stickerMessage) -} -inline ::proto::Message_StickerMessage* Message::release_stickermessage() { - _impl_._has_bits_[0] &= ~0x00200000u; - ::proto::Message_StickerMessage* temp = _impl_.stickermessage_; - _impl_.stickermessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_StickerMessage* Message::unsafe_arena_release_stickermessage() { - // @@protoc_insertion_point(field_release:proto.Message.stickerMessage) - _impl_._has_bits_[0] &= ~0x00200000u; - ::proto::Message_StickerMessage* temp = _impl_.stickermessage_; - _impl_.stickermessage_ = nullptr; - return temp; -} -inline ::proto::Message_StickerMessage* Message::_internal_mutable_stickermessage() { - _impl_._has_bits_[0] |= 0x00200000u; - if (_impl_.stickermessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_StickerMessage>(GetArenaForAllocation()); - _impl_.stickermessage_ = p; - } - return _impl_.stickermessage_; -} -inline ::proto::Message_StickerMessage* Message::mutable_stickermessage() { - ::proto::Message_StickerMessage* _msg = _internal_mutable_stickermessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.stickerMessage) - return _msg; -} -inline void Message::set_allocated_stickermessage(::proto::Message_StickerMessage* stickermessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.stickermessage_; - } - if (stickermessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(stickermessage); - if (message_arena != submessage_arena) { - stickermessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, stickermessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00200000u; - } else { - _impl_._has_bits_[0] &= ~0x00200000u; - } - _impl_.stickermessage_ = stickermessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.stickerMessage) -} - -// optional .proto.Message.GroupInviteMessage groupInviteMessage = 28; -inline bool Message::_internal_has_groupinvitemessage() const { - bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.groupinvitemessage_ != nullptr); - return value; -} -inline bool Message::has_groupinvitemessage() const { - return _internal_has_groupinvitemessage(); -} -inline void Message::clear_groupinvitemessage() { - if (_impl_.groupinvitemessage_ != nullptr) _impl_.groupinvitemessage_->Clear(); - _impl_._has_bits_[0] &= ~0x00400000u; -} -inline const ::proto::Message_GroupInviteMessage& Message::_internal_groupinvitemessage() const { - const ::proto::Message_GroupInviteMessage* p = _impl_.groupinvitemessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_GroupInviteMessage_default_instance_); -} -inline const ::proto::Message_GroupInviteMessage& Message::groupinvitemessage() const { - // @@protoc_insertion_point(field_get:proto.Message.groupInviteMessage) - return _internal_groupinvitemessage(); -} -inline void Message::unsafe_arena_set_allocated_groupinvitemessage( - ::proto::Message_GroupInviteMessage* groupinvitemessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.groupinvitemessage_); - } - _impl_.groupinvitemessage_ = groupinvitemessage; - if (groupinvitemessage) { - _impl_._has_bits_[0] |= 0x00400000u; - } else { - _impl_._has_bits_[0] &= ~0x00400000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.groupInviteMessage) -} -inline ::proto::Message_GroupInviteMessage* Message::release_groupinvitemessage() { - _impl_._has_bits_[0] &= ~0x00400000u; - ::proto::Message_GroupInviteMessage* temp = _impl_.groupinvitemessage_; - _impl_.groupinvitemessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_GroupInviteMessage* Message::unsafe_arena_release_groupinvitemessage() { - // @@protoc_insertion_point(field_release:proto.Message.groupInviteMessage) - _impl_._has_bits_[0] &= ~0x00400000u; - ::proto::Message_GroupInviteMessage* temp = _impl_.groupinvitemessage_; - _impl_.groupinvitemessage_ = nullptr; - return temp; -} -inline ::proto::Message_GroupInviteMessage* Message::_internal_mutable_groupinvitemessage() { - _impl_._has_bits_[0] |= 0x00400000u; - if (_impl_.groupinvitemessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_GroupInviteMessage>(GetArenaForAllocation()); - _impl_.groupinvitemessage_ = p; - } - return _impl_.groupinvitemessage_; -} -inline ::proto::Message_GroupInviteMessage* Message::mutable_groupinvitemessage() { - ::proto::Message_GroupInviteMessage* _msg = _internal_mutable_groupinvitemessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.groupInviteMessage) - return _msg; -} -inline void Message::set_allocated_groupinvitemessage(::proto::Message_GroupInviteMessage* groupinvitemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.groupinvitemessage_; - } - if (groupinvitemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(groupinvitemessage); - if (message_arena != submessage_arena) { - groupinvitemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, groupinvitemessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00400000u; - } else { - _impl_._has_bits_[0] &= ~0x00400000u; - } - _impl_.groupinvitemessage_ = groupinvitemessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.groupInviteMessage) -} - -// optional .proto.Message.TemplateButtonReplyMessage templateButtonReplyMessage = 29; -inline bool Message::_internal_has_templatebuttonreplymessage() const { - bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.templatebuttonreplymessage_ != nullptr); - return value; -} -inline bool Message::has_templatebuttonreplymessage() const { - return _internal_has_templatebuttonreplymessage(); -} -inline void Message::clear_templatebuttonreplymessage() { - if (_impl_.templatebuttonreplymessage_ != nullptr) _impl_.templatebuttonreplymessage_->Clear(); - _impl_._has_bits_[0] &= ~0x00800000u; -} -inline const ::proto::Message_TemplateButtonReplyMessage& Message::_internal_templatebuttonreplymessage() const { - const ::proto::Message_TemplateButtonReplyMessage* p = _impl_.templatebuttonreplymessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_TemplateButtonReplyMessage_default_instance_); -} -inline const ::proto::Message_TemplateButtonReplyMessage& Message::templatebuttonreplymessage() const { - // @@protoc_insertion_point(field_get:proto.Message.templateButtonReplyMessage) - return _internal_templatebuttonreplymessage(); -} -inline void Message::unsafe_arena_set_allocated_templatebuttonreplymessage( - ::proto::Message_TemplateButtonReplyMessage* templatebuttonreplymessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.templatebuttonreplymessage_); - } - _impl_.templatebuttonreplymessage_ = templatebuttonreplymessage; - if (templatebuttonreplymessage) { - _impl_._has_bits_[0] |= 0x00800000u; - } else { - _impl_._has_bits_[0] &= ~0x00800000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.templateButtonReplyMessage) -} -inline ::proto::Message_TemplateButtonReplyMessage* Message::release_templatebuttonreplymessage() { - _impl_._has_bits_[0] &= ~0x00800000u; - ::proto::Message_TemplateButtonReplyMessage* temp = _impl_.templatebuttonreplymessage_; - _impl_.templatebuttonreplymessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_TemplateButtonReplyMessage* Message::unsafe_arena_release_templatebuttonreplymessage() { - // @@protoc_insertion_point(field_release:proto.Message.templateButtonReplyMessage) - _impl_._has_bits_[0] &= ~0x00800000u; - ::proto::Message_TemplateButtonReplyMessage* temp = _impl_.templatebuttonreplymessage_; - _impl_.templatebuttonreplymessage_ = nullptr; - return temp; -} -inline ::proto::Message_TemplateButtonReplyMessage* Message::_internal_mutable_templatebuttonreplymessage() { - _impl_._has_bits_[0] |= 0x00800000u; - if (_impl_.templatebuttonreplymessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_TemplateButtonReplyMessage>(GetArenaForAllocation()); - _impl_.templatebuttonreplymessage_ = p; - } - return _impl_.templatebuttonreplymessage_; -} -inline ::proto::Message_TemplateButtonReplyMessage* Message::mutable_templatebuttonreplymessage() { - ::proto::Message_TemplateButtonReplyMessage* _msg = _internal_mutable_templatebuttonreplymessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.templateButtonReplyMessage) - return _msg; -} -inline void Message::set_allocated_templatebuttonreplymessage(::proto::Message_TemplateButtonReplyMessage* templatebuttonreplymessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.templatebuttonreplymessage_; - } - if (templatebuttonreplymessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(templatebuttonreplymessage); - if (message_arena != submessage_arena) { - templatebuttonreplymessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, templatebuttonreplymessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00800000u; - } else { - _impl_._has_bits_[0] &= ~0x00800000u; - } - _impl_.templatebuttonreplymessage_ = templatebuttonreplymessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.templateButtonReplyMessage) -} - -// optional .proto.Message.ProductMessage productMessage = 30; -inline bool Message::_internal_has_productmessage() const { - bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.productmessage_ != nullptr); - return value; -} -inline bool Message::has_productmessage() const { - return _internal_has_productmessage(); -} -inline void Message::clear_productmessage() { - if (_impl_.productmessage_ != nullptr) _impl_.productmessage_->Clear(); - _impl_._has_bits_[0] &= ~0x01000000u; -} -inline const ::proto::Message_ProductMessage& Message::_internal_productmessage() const { - const ::proto::Message_ProductMessage* p = _impl_.productmessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_ProductMessage_default_instance_); -} -inline const ::proto::Message_ProductMessage& Message::productmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.productMessage) - return _internal_productmessage(); -} -inline void Message::unsafe_arena_set_allocated_productmessage( - ::proto::Message_ProductMessage* productmessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.productmessage_); - } - _impl_.productmessage_ = productmessage; - if (productmessage) { - _impl_._has_bits_[0] |= 0x01000000u; - } else { - _impl_._has_bits_[0] &= ~0x01000000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.productMessage) -} -inline ::proto::Message_ProductMessage* Message::release_productmessage() { - _impl_._has_bits_[0] &= ~0x01000000u; - ::proto::Message_ProductMessage* temp = _impl_.productmessage_; - _impl_.productmessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_ProductMessage* Message::unsafe_arena_release_productmessage() { - // @@protoc_insertion_point(field_release:proto.Message.productMessage) - _impl_._has_bits_[0] &= ~0x01000000u; - ::proto::Message_ProductMessage* temp = _impl_.productmessage_; - _impl_.productmessage_ = nullptr; - return temp; -} -inline ::proto::Message_ProductMessage* Message::_internal_mutable_productmessage() { - _impl_._has_bits_[0] |= 0x01000000u; - if (_impl_.productmessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_ProductMessage>(GetArenaForAllocation()); - _impl_.productmessage_ = p; - } - return _impl_.productmessage_; -} -inline ::proto::Message_ProductMessage* Message::mutable_productmessage() { - ::proto::Message_ProductMessage* _msg = _internal_mutable_productmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.productMessage) - return _msg; -} -inline void Message::set_allocated_productmessage(::proto::Message_ProductMessage* productmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.productmessage_; - } - if (productmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(productmessage); - if (message_arena != submessage_arena) { - productmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, productmessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x01000000u; - } else { - _impl_._has_bits_[0] &= ~0x01000000u; - } - _impl_.productmessage_ = productmessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.productMessage) -} - -// optional .proto.Message.DeviceSentMessage deviceSentMessage = 31; -inline bool Message::_internal_has_devicesentmessage() const { - bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.devicesentmessage_ != nullptr); - return value; -} -inline bool Message::has_devicesentmessage() const { - return _internal_has_devicesentmessage(); -} -inline void Message::clear_devicesentmessage() { - if (_impl_.devicesentmessage_ != nullptr) _impl_.devicesentmessage_->Clear(); - _impl_._has_bits_[0] &= ~0x02000000u; -} -inline const ::proto::Message_DeviceSentMessage& Message::_internal_devicesentmessage() const { - const ::proto::Message_DeviceSentMessage* p = _impl_.devicesentmessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_DeviceSentMessage_default_instance_); -} -inline const ::proto::Message_DeviceSentMessage& Message::devicesentmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.deviceSentMessage) - return _internal_devicesentmessage(); -} -inline void Message::unsafe_arena_set_allocated_devicesentmessage( - ::proto::Message_DeviceSentMessage* devicesentmessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.devicesentmessage_); - } - _impl_.devicesentmessage_ = devicesentmessage; - if (devicesentmessage) { - _impl_._has_bits_[0] |= 0x02000000u; - } else { - _impl_._has_bits_[0] &= ~0x02000000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.deviceSentMessage) -} -inline ::proto::Message_DeviceSentMessage* Message::release_devicesentmessage() { - _impl_._has_bits_[0] &= ~0x02000000u; - ::proto::Message_DeviceSentMessage* temp = _impl_.devicesentmessage_; - _impl_.devicesentmessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_DeviceSentMessage* Message::unsafe_arena_release_devicesentmessage() { - // @@protoc_insertion_point(field_release:proto.Message.deviceSentMessage) - _impl_._has_bits_[0] &= ~0x02000000u; - ::proto::Message_DeviceSentMessage* temp = _impl_.devicesentmessage_; - _impl_.devicesentmessage_ = nullptr; - return temp; -} -inline ::proto::Message_DeviceSentMessage* Message::_internal_mutable_devicesentmessage() { - _impl_._has_bits_[0] |= 0x02000000u; - if (_impl_.devicesentmessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_DeviceSentMessage>(GetArenaForAllocation()); - _impl_.devicesentmessage_ = p; - } - return _impl_.devicesentmessage_; -} -inline ::proto::Message_DeviceSentMessage* Message::mutable_devicesentmessage() { - ::proto::Message_DeviceSentMessage* _msg = _internal_mutable_devicesentmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.deviceSentMessage) - return _msg; -} -inline void Message::set_allocated_devicesentmessage(::proto::Message_DeviceSentMessage* devicesentmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.devicesentmessage_; - } - if (devicesentmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(devicesentmessage); - if (message_arena != submessage_arena) { - devicesentmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, devicesentmessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x02000000u; - } else { - _impl_._has_bits_[0] &= ~0x02000000u; - } - _impl_.devicesentmessage_ = devicesentmessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.deviceSentMessage) -} - -// optional .proto.MessageContextInfo messageContextInfo = 35; -inline bool Message::_internal_has_messagecontextinfo() const { - bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.messagecontextinfo_ != nullptr); - return value; -} -inline bool Message::has_messagecontextinfo() const { - return _internal_has_messagecontextinfo(); -} -inline void Message::clear_messagecontextinfo() { - if (_impl_.messagecontextinfo_ != nullptr) _impl_.messagecontextinfo_->Clear(); - _impl_._has_bits_[0] &= ~0x04000000u; -} -inline const ::proto::MessageContextInfo& Message::_internal_messagecontextinfo() const { - const ::proto::MessageContextInfo* p = _impl_.messagecontextinfo_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_MessageContextInfo_default_instance_); -} -inline const ::proto::MessageContextInfo& Message::messagecontextinfo() const { - // @@protoc_insertion_point(field_get:proto.Message.messageContextInfo) - return _internal_messagecontextinfo(); -} -inline void Message::unsafe_arena_set_allocated_messagecontextinfo( - ::proto::MessageContextInfo* messagecontextinfo) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.messagecontextinfo_); - } - _impl_.messagecontextinfo_ = messagecontextinfo; - if (messagecontextinfo) { - _impl_._has_bits_[0] |= 0x04000000u; - } else { - _impl_._has_bits_[0] &= ~0x04000000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.messageContextInfo) -} -inline ::proto::MessageContextInfo* Message::release_messagecontextinfo() { - _impl_._has_bits_[0] &= ~0x04000000u; - ::proto::MessageContextInfo* temp = _impl_.messagecontextinfo_; - _impl_.messagecontextinfo_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::MessageContextInfo* Message::unsafe_arena_release_messagecontextinfo() { - // @@protoc_insertion_point(field_release:proto.Message.messageContextInfo) - _impl_._has_bits_[0] &= ~0x04000000u; - ::proto::MessageContextInfo* temp = _impl_.messagecontextinfo_; - _impl_.messagecontextinfo_ = nullptr; - return temp; -} -inline ::proto::MessageContextInfo* Message::_internal_mutable_messagecontextinfo() { - _impl_._has_bits_[0] |= 0x04000000u; - if (_impl_.messagecontextinfo_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::MessageContextInfo>(GetArenaForAllocation()); - _impl_.messagecontextinfo_ = p; - } - return _impl_.messagecontextinfo_; -} -inline ::proto::MessageContextInfo* Message::mutable_messagecontextinfo() { - ::proto::MessageContextInfo* _msg = _internal_mutable_messagecontextinfo(); - // @@protoc_insertion_point(field_mutable:proto.Message.messageContextInfo) - return _msg; -} -inline void Message::set_allocated_messagecontextinfo(::proto::MessageContextInfo* messagecontextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.messagecontextinfo_; - } - if (messagecontextinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(messagecontextinfo); - if (message_arena != submessage_arena) { - messagecontextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, messagecontextinfo, submessage_arena); - } - _impl_._has_bits_[0] |= 0x04000000u; - } else { - _impl_._has_bits_[0] &= ~0x04000000u; - } - _impl_.messagecontextinfo_ = messagecontextinfo; - // @@protoc_insertion_point(field_set_allocated:proto.Message.messageContextInfo) -} - -// optional .proto.Message.ListMessage listMessage = 36; -inline bool Message::_internal_has_listmessage() const { - bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.listmessage_ != nullptr); - return value; -} -inline bool Message::has_listmessage() const { - return _internal_has_listmessage(); -} -inline void Message::clear_listmessage() { - if (_impl_.listmessage_ != nullptr) _impl_.listmessage_->Clear(); - _impl_._has_bits_[0] &= ~0x08000000u; -} -inline const ::proto::Message_ListMessage& Message::_internal_listmessage() const { - const ::proto::Message_ListMessage* p = _impl_.listmessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_ListMessage_default_instance_); -} -inline const ::proto::Message_ListMessage& Message::listmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.listMessage) - return _internal_listmessage(); -} -inline void Message::unsafe_arena_set_allocated_listmessage( - ::proto::Message_ListMessage* listmessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.listmessage_); - } - _impl_.listmessage_ = listmessage; - if (listmessage) { - _impl_._has_bits_[0] |= 0x08000000u; - } else { - _impl_._has_bits_[0] &= ~0x08000000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.listMessage) -} -inline ::proto::Message_ListMessage* Message::release_listmessage() { - _impl_._has_bits_[0] &= ~0x08000000u; - ::proto::Message_ListMessage* temp = _impl_.listmessage_; - _impl_.listmessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_ListMessage* Message::unsafe_arena_release_listmessage() { - // @@protoc_insertion_point(field_release:proto.Message.listMessage) - _impl_._has_bits_[0] &= ~0x08000000u; - ::proto::Message_ListMessage* temp = _impl_.listmessage_; - _impl_.listmessage_ = nullptr; - return temp; -} -inline ::proto::Message_ListMessage* Message::_internal_mutable_listmessage() { - _impl_._has_bits_[0] |= 0x08000000u; - if (_impl_.listmessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_ListMessage>(GetArenaForAllocation()); - _impl_.listmessage_ = p; - } - return _impl_.listmessage_; -} -inline ::proto::Message_ListMessage* Message::mutable_listmessage() { - ::proto::Message_ListMessage* _msg = _internal_mutable_listmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.listMessage) - return _msg; -} -inline void Message::set_allocated_listmessage(::proto::Message_ListMessage* listmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.listmessage_; - } - if (listmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(listmessage); - if (message_arena != submessage_arena) { - listmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, listmessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x08000000u; - } else { - _impl_._has_bits_[0] &= ~0x08000000u; - } - _impl_.listmessage_ = listmessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.listMessage) -} - -// optional .proto.Message.FutureProofMessage viewOnceMessage = 37; -inline bool Message::_internal_has_viewoncemessage() const { - bool value = (_impl_._has_bits_[0] & 0x10000000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.viewoncemessage_ != nullptr); - return value; -} -inline bool Message::has_viewoncemessage() const { - return _internal_has_viewoncemessage(); -} -inline void Message::clear_viewoncemessage() { - if (_impl_.viewoncemessage_ != nullptr) _impl_.viewoncemessage_->Clear(); - _impl_._has_bits_[0] &= ~0x10000000u; -} -inline const ::proto::Message_FutureProofMessage& Message::_internal_viewoncemessage() const { - const ::proto::Message_FutureProofMessage* p = _impl_.viewoncemessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_FutureProofMessage_default_instance_); -} -inline const ::proto::Message_FutureProofMessage& Message::viewoncemessage() const { - // @@protoc_insertion_point(field_get:proto.Message.viewOnceMessage) - return _internal_viewoncemessage(); -} -inline void Message::unsafe_arena_set_allocated_viewoncemessage( - ::proto::Message_FutureProofMessage* viewoncemessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.viewoncemessage_); - } - _impl_.viewoncemessage_ = viewoncemessage; - if (viewoncemessage) { - _impl_._has_bits_[0] |= 0x10000000u; - } else { - _impl_._has_bits_[0] &= ~0x10000000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.viewOnceMessage) -} -inline ::proto::Message_FutureProofMessage* Message::release_viewoncemessage() { - _impl_._has_bits_[0] &= ~0x10000000u; - ::proto::Message_FutureProofMessage* temp = _impl_.viewoncemessage_; - _impl_.viewoncemessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_FutureProofMessage* Message::unsafe_arena_release_viewoncemessage() { - // @@protoc_insertion_point(field_release:proto.Message.viewOnceMessage) - _impl_._has_bits_[0] &= ~0x10000000u; - ::proto::Message_FutureProofMessage* temp = _impl_.viewoncemessage_; - _impl_.viewoncemessage_ = nullptr; - return temp; -} -inline ::proto::Message_FutureProofMessage* Message::_internal_mutable_viewoncemessage() { - _impl_._has_bits_[0] |= 0x10000000u; - if (_impl_.viewoncemessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_FutureProofMessage>(GetArenaForAllocation()); - _impl_.viewoncemessage_ = p; - } - return _impl_.viewoncemessage_; -} -inline ::proto::Message_FutureProofMessage* Message::mutable_viewoncemessage() { - ::proto::Message_FutureProofMessage* _msg = _internal_mutable_viewoncemessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.viewOnceMessage) - return _msg; -} -inline void Message::set_allocated_viewoncemessage(::proto::Message_FutureProofMessage* viewoncemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.viewoncemessage_; - } - if (viewoncemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(viewoncemessage); - if (message_arena != submessage_arena) { - viewoncemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, viewoncemessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x10000000u; - } else { - _impl_._has_bits_[0] &= ~0x10000000u; - } - _impl_.viewoncemessage_ = viewoncemessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.viewOnceMessage) -} - -// optional .proto.Message.OrderMessage orderMessage = 38; -inline bool Message::_internal_has_ordermessage() const { - bool value = (_impl_._has_bits_[0] & 0x20000000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.ordermessage_ != nullptr); - return value; -} -inline bool Message::has_ordermessage() const { - return _internal_has_ordermessage(); -} -inline void Message::clear_ordermessage() { - if (_impl_.ordermessage_ != nullptr) _impl_.ordermessage_->Clear(); - _impl_._has_bits_[0] &= ~0x20000000u; -} -inline const ::proto::Message_OrderMessage& Message::_internal_ordermessage() const { - const ::proto::Message_OrderMessage* p = _impl_.ordermessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_OrderMessage_default_instance_); -} -inline const ::proto::Message_OrderMessage& Message::ordermessage() const { - // @@protoc_insertion_point(field_get:proto.Message.orderMessage) - return _internal_ordermessage(); -} -inline void Message::unsafe_arena_set_allocated_ordermessage( - ::proto::Message_OrderMessage* ordermessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.ordermessage_); - } - _impl_.ordermessage_ = ordermessage; - if (ordermessage) { - _impl_._has_bits_[0] |= 0x20000000u; - } else { - _impl_._has_bits_[0] &= ~0x20000000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.orderMessage) -} -inline ::proto::Message_OrderMessage* Message::release_ordermessage() { - _impl_._has_bits_[0] &= ~0x20000000u; - ::proto::Message_OrderMessage* temp = _impl_.ordermessage_; - _impl_.ordermessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_OrderMessage* Message::unsafe_arena_release_ordermessage() { - // @@protoc_insertion_point(field_release:proto.Message.orderMessage) - _impl_._has_bits_[0] &= ~0x20000000u; - ::proto::Message_OrderMessage* temp = _impl_.ordermessage_; - _impl_.ordermessage_ = nullptr; - return temp; -} -inline ::proto::Message_OrderMessage* Message::_internal_mutable_ordermessage() { - _impl_._has_bits_[0] |= 0x20000000u; - if (_impl_.ordermessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_OrderMessage>(GetArenaForAllocation()); - _impl_.ordermessage_ = p; - } - return _impl_.ordermessage_; -} -inline ::proto::Message_OrderMessage* Message::mutable_ordermessage() { - ::proto::Message_OrderMessage* _msg = _internal_mutable_ordermessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.orderMessage) - return _msg; -} -inline void Message::set_allocated_ordermessage(::proto::Message_OrderMessage* ordermessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.ordermessage_; - } - if (ordermessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(ordermessage); - if (message_arena != submessage_arena) { - ordermessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, ordermessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x20000000u; - } else { - _impl_._has_bits_[0] &= ~0x20000000u; - } - _impl_.ordermessage_ = ordermessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.orderMessage) -} - -// optional .proto.Message.ListResponseMessage listResponseMessage = 39; -inline bool Message::_internal_has_listresponsemessage() const { - bool value = (_impl_._has_bits_[0] & 0x40000000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.listresponsemessage_ != nullptr); - return value; -} -inline bool Message::has_listresponsemessage() const { - return _internal_has_listresponsemessage(); -} -inline void Message::clear_listresponsemessage() { - if (_impl_.listresponsemessage_ != nullptr) _impl_.listresponsemessage_->Clear(); - _impl_._has_bits_[0] &= ~0x40000000u; -} -inline const ::proto::Message_ListResponseMessage& Message::_internal_listresponsemessage() const { - const ::proto::Message_ListResponseMessage* p = _impl_.listresponsemessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_ListResponseMessage_default_instance_); -} -inline const ::proto::Message_ListResponseMessage& Message::listresponsemessage() const { - // @@protoc_insertion_point(field_get:proto.Message.listResponseMessage) - return _internal_listresponsemessage(); -} -inline void Message::unsafe_arena_set_allocated_listresponsemessage( - ::proto::Message_ListResponseMessage* listresponsemessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.listresponsemessage_); - } - _impl_.listresponsemessage_ = listresponsemessage; - if (listresponsemessage) { - _impl_._has_bits_[0] |= 0x40000000u; - } else { - _impl_._has_bits_[0] &= ~0x40000000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.listResponseMessage) -} -inline ::proto::Message_ListResponseMessage* Message::release_listresponsemessage() { - _impl_._has_bits_[0] &= ~0x40000000u; - ::proto::Message_ListResponseMessage* temp = _impl_.listresponsemessage_; - _impl_.listresponsemessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_ListResponseMessage* Message::unsafe_arena_release_listresponsemessage() { - // @@protoc_insertion_point(field_release:proto.Message.listResponseMessage) - _impl_._has_bits_[0] &= ~0x40000000u; - ::proto::Message_ListResponseMessage* temp = _impl_.listresponsemessage_; - _impl_.listresponsemessage_ = nullptr; - return temp; -} -inline ::proto::Message_ListResponseMessage* Message::_internal_mutable_listresponsemessage() { - _impl_._has_bits_[0] |= 0x40000000u; - if (_impl_.listresponsemessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_ListResponseMessage>(GetArenaForAllocation()); - _impl_.listresponsemessage_ = p; - } - return _impl_.listresponsemessage_; -} -inline ::proto::Message_ListResponseMessage* Message::mutable_listresponsemessage() { - ::proto::Message_ListResponseMessage* _msg = _internal_mutable_listresponsemessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.listResponseMessage) - return _msg; -} -inline void Message::set_allocated_listresponsemessage(::proto::Message_ListResponseMessage* listresponsemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.listresponsemessage_; - } - if (listresponsemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(listresponsemessage); - if (message_arena != submessage_arena) { - listresponsemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, listresponsemessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x40000000u; - } else { - _impl_._has_bits_[0] &= ~0x40000000u; - } - _impl_.listresponsemessage_ = listresponsemessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.listResponseMessage) -} - -// optional .proto.Message.FutureProofMessage ephemeralMessage = 40; -inline bool Message::_internal_has_ephemeralmessage() const { - bool value = (_impl_._has_bits_[0] & 0x80000000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.ephemeralmessage_ != nullptr); - return value; -} -inline bool Message::has_ephemeralmessage() const { - return _internal_has_ephemeralmessage(); -} -inline void Message::clear_ephemeralmessage() { - if (_impl_.ephemeralmessage_ != nullptr) _impl_.ephemeralmessage_->Clear(); - _impl_._has_bits_[0] &= ~0x80000000u; -} -inline const ::proto::Message_FutureProofMessage& Message::_internal_ephemeralmessage() const { - const ::proto::Message_FutureProofMessage* p = _impl_.ephemeralmessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_FutureProofMessage_default_instance_); -} -inline const ::proto::Message_FutureProofMessage& Message::ephemeralmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.ephemeralMessage) - return _internal_ephemeralmessage(); -} -inline void Message::unsafe_arena_set_allocated_ephemeralmessage( - ::proto::Message_FutureProofMessage* ephemeralmessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.ephemeralmessage_); - } - _impl_.ephemeralmessage_ = ephemeralmessage; - if (ephemeralmessage) { - _impl_._has_bits_[0] |= 0x80000000u; - } else { - _impl_._has_bits_[0] &= ~0x80000000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ephemeralMessage) -} -inline ::proto::Message_FutureProofMessage* Message::release_ephemeralmessage() { - _impl_._has_bits_[0] &= ~0x80000000u; - ::proto::Message_FutureProofMessage* temp = _impl_.ephemeralmessage_; - _impl_.ephemeralmessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_FutureProofMessage* Message::unsafe_arena_release_ephemeralmessage() { - // @@protoc_insertion_point(field_release:proto.Message.ephemeralMessage) - _impl_._has_bits_[0] &= ~0x80000000u; - ::proto::Message_FutureProofMessage* temp = _impl_.ephemeralmessage_; - _impl_.ephemeralmessage_ = nullptr; - return temp; -} -inline ::proto::Message_FutureProofMessage* Message::_internal_mutable_ephemeralmessage() { - _impl_._has_bits_[0] |= 0x80000000u; - if (_impl_.ephemeralmessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_FutureProofMessage>(GetArenaForAllocation()); - _impl_.ephemeralmessage_ = p; - } - return _impl_.ephemeralmessage_; -} -inline ::proto::Message_FutureProofMessage* Message::mutable_ephemeralmessage() { - ::proto::Message_FutureProofMessage* _msg = _internal_mutable_ephemeralmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.ephemeralMessage) - return _msg; -} -inline void Message::set_allocated_ephemeralmessage(::proto::Message_FutureProofMessage* ephemeralmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.ephemeralmessage_; - } - if (ephemeralmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(ephemeralmessage); - if (message_arena != submessage_arena) { - ephemeralmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, ephemeralmessage, submessage_arena); - } - _impl_._has_bits_[0] |= 0x80000000u; - } else { - _impl_._has_bits_[0] &= ~0x80000000u; - } - _impl_.ephemeralmessage_ = ephemeralmessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.ephemeralMessage) -} - -// optional .proto.Message.InvoiceMessage invoiceMessage = 41; -inline bool Message::_internal_has_invoicemessage() const { - bool value = (_impl_._has_bits_[1] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.invoicemessage_ != nullptr); - return value; -} -inline bool Message::has_invoicemessage() const { - return _internal_has_invoicemessage(); -} -inline void Message::clear_invoicemessage() { - if (_impl_.invoicemessage_ != nullptr) _impl_.invoicemessage_->Clear(); - _impl_._has_bits_[1] &= ~0x00000001u; -} -inline const ::proto::Message_InvoiceMessage& Message::_internal_invoicemessage() const { - const ::proto::Message_InvoiceMessage* p = _impl_.invoicemessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_InvoiceMessage_default_instance_); -} -inline const ::proto::Message_InvoiceMessage& Message::invoicemessage() const { - // @@protoc_insertion_point(field_get:proto.Message.invoiceMessage) - return _internal_invoicemessage(); -} -inline void Message::unsafe_arena_set_allocated_invoicemessage( - ::proto::Message_InvoiceMessage* invoicemessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.invoicemessage_); - } - _impl_.invoicemessage_ = invoicemessage; - if (invoicemessage) { - _impl_._has_bits_[1] |= 0x00000001u; - } else { - _impl_._has_bits_[1] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.invoiceMessage) -} -inline ::proto::Message_InvoiceMessage* Message::release_invoicemessage() { - _impl_._has_bits_[1] &= ~0x00000001u; - ::proto::Message_InvoiceMessage* temp = _impl_.invoicemessage_; - _impl_.invoicemessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_InvoiceMessage* Message::unsafe_arena_release_invoicemessage() { - // @@protoc_insertion_point(field_release:proto.Message.invoiceMessage) - _impl_._has_bits_[1] &= ~0x00000001u; - ::proto::Message_InvoiceMessage* temp = _impl_.invoicemessage_; - _impl_.invoicemessage_ = nullptr; - return temp; -} -inline ::proto::Message_InvoiceMessage* Message::_internal_mutable_invoicemessage() { - _impl_._has_bits_[1] |= 0x00000001u; - if (_impl_.invoicemessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_InvoiceMessage>(GetArenaForAllocation()); - _impl_.invoicemessage_ = p; - } - return _impl_.invoicemessage_; -} -inline ::proto::Message_InvoiceMessage* Message::mutable_invoicemessage() { - ::proto::Message_InvoiceMessage* _msg = _internal_mutable_invoicemessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.invoiceMessage) - return _msg; -} -inline void Message::set_allocated_invoicemessage(::proto::Message_InvoiceMessage* invoicemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.invoicemessage_; - } - if (invoicemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(invoicemessage); - if (message_arena != submessage_arena) { - invoicemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, invoicemessage, submessage_arena); - } - _impl_._has_bits_[1] |= 0x00000001u; - } else { - _impl_._has_bits_[1] &= ~0x00000001u; - } - _impl_.invoicemessage_ = invoicemessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.invoiceMessage) -} - -// optional .proto.Message.ButtonsMessage buttonsMessage = 42; -inline bool Message::_internal_has_buttonsmessage() const { - bool value = (_impl_._has_bits_[1] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.buttonsmessage_ != nullptr); - return value; -} -inline bool Message::has_buttonsmessage() const { - return _internal_has_buttonsmessage(); -} -inline void Message::clear_buttonsmessage() { - if (_impl_.buttonsmessage_ != nullptr) _impl_.buttonsmessage_->Clear(); - _impl_._has_bits_[1] &= ~0x00000002u; -} -inline const ::proto::Message_ButtonsMessage& Message::_internal_buttonsmessage() const { - const ::proto::Message_ButtonsMessage* p = _impl_.buttonsmessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_ButtonsMessage_default_instance_); -} -inline const ::proto::Message_ButtonsMessage& Message::buttonsmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.buttonsMessage) - return _internal_buttonsmessage(); -} -inline void Message::unsafe_arena_set_allocated_buttonsmessage( - ::proto::Message_ButtonsMessage* buttonsmessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.buttonsmessage_); - } - _impl_.buttonsmessage_ = buttonsmessage; - if (buttonsmessage) { - _impl_._has_bits_[1] |= 0x00000002u; - } else { - _impl_._has_bits_[1] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.buttonsMessage) -} -inline ::proto::Message_ButtonsMessage* Message::release_buttonsmessage() { - _impl_._has_bits_[1] &= ~0x00000002u; - ::proto::Message_ButtonsMessage* temp = _impl_.buttonsmessage_; - _impl_.buttonsmessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_ButtonsMessage* Message::unsafe_arena_release_buttonsmessage() { - // @@protoc_insertion_point(field_release:proto.Message.buttonsMessage) - _impl_._has_bits_[1] &= ~0x00000002u; - ::proto::Message_ButtonsMessage* temp = _impl_.buttonsmessage_; - _impl_.buttonsmessage_ = nullptr; - return temp; -} -inline ::proto::Message_ButtonsMessage* Message::_internal_mutable_buttonsmessage() { - _impl_._has_bits_[1] |= 0x00000002u; - if (_impl_.buttonsmessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_ButtonsMessage>(GetArenaForAllocation()); - _impl_.buttonsmessage_ = p; - } - return _impl_.buttonsmessage_; -} -inline ::proto::Message_ButtonsMessage* Message::mutable_buttonsmessage() { - ::proto::Message_ButtonsMessage* _msg = _internal_mutable_buttonsmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.buttonsMessage) - return _msg; -} -inline void Message::set_allocated_buttonsmessage(::proto::Message_ButtonsMessage* buttonsmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.buttonsmessage_; - } - if (buttonsmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(buttonsmessage); - if (message_arena != submessage_arena) { - buttonsmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, buttonsmessage, submessage_arena); - } - _impl_._has_bits_[1] |= 0x00000002u; - } else { - _impl_._has_bits_[1] &= ~0x00000002u; - } - _impl_.buttonsmessage_ = buttonsmessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.buttonsMessage) -} - -// optional .proto.Message.ButtonsResponseMessage buttonsResponseMessage = 43; -inline bool Message::_internal_has_buttonsresponsemessage() const { - bool value = (_impl_._has_bits_[1] & 0x00000004u) != 0; - PROTOBUF_ASSUME(!value || _impl_.buttonsresponsemessage_ != nullptr); - return value; -} -inline bool Message::has_buttonsresponsemessage() const { - return _internal_has_buttonsresponsemessage(); -} -inline void Message::clear_buttonsresponsemessage() { - if (_impl_.buttonsresponsemessage_ != nullptr) _impl_.buttonsresponsemessage_->Clear(); - _impl_._has_bits_[1] &= ~0x00000004u; -} -inline const ::proto::Message_ButtonsResponseMessage& Message::_internal_buttonsresponsemessage() const { - const ::proto::Message_ButtonsResponseMessage* p = _impl_.buttonsresponsemessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_ButtonsResponseMessage_default_instance_); -} -inline const ::proto::Message_ButtonsResponseMessage& Message::buttonsresponsemessage() const { - // @@protoc_insertion_point(field_get:proto.Message.buttonsResponseMessage) - return _internal_buttonsresponsemessage(); -} -inline void Message::unsafe_arena_set_allocated_buttonsresponsemessage( - ::proto::Message_ButtonsResponseMessage* buttonsresponsemessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.buttonsresponsemessage_); - } - _impl_.buttonsresponsemessage_ = buttonsresponsemessage; - if (buttonsresponsemessage) { - _impl_._has_bits_[1] |= 0x00000004u; - } else { - _impl_._has_bits_[1] &= ~0x00000004u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.buttonsResponseMessage) -} -inline ::proto::Message_ButtonsResponseMessage* Message::release_buttonsresponsemessage() { - _impl_._has_bits_[1] &= ~0x00000004u; - ::proto::Message_ButtonsResponseMessage* temp = _impl_.buttonsresponsemessage_; - _impl_.buttonsresponsemessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_ButtonsResponseMessage* Message::unsafe_arena_release_buttonsresponsemessage() { - // @@protoc_insertion_point(field_release:proto.Message.buttonsResponseMessage) - _impl_._has_bits_[1] &= ~0x00000004u; - ::proto::Message_ButtonsResponseMessage* temp = _impl_.buttonsresponsemessage_; - _impl_.buttonsresponsemessage_ = nullptr; - return temp; -} -inline ::proto::Message_ButtonsResponseMessage* Message::_internal_mutable_buttonsresponsemessage() { - _impl_._has_bits_[1] |= 0x00000004u; - if (_impl_.buttonsresponsemessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_ButtonsResponseMessage>(GetArenaForAllocation()); - _impl_.buttonsresponsemessage_ = p; - } - return _impl_.buttonsresponsemessage_; -} -inline ::proto::Message_ButtonsResponseMessage* Message::mutable_buttonsresponsemessage() { - ::proto::Message_ButtonsResponseMessage* _msg = _internal_mutable_buttonsresponsemessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.buttonsResponseMessage) - return _msg; -} -inline void Message::set_allocated_buttonsresponsemessage(::proto::Message_ButtonsResponseMessage* buttonsresponsemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.buttonsresponsemessage_; - } - if (buttonsresponsemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(buttonsresponsemessage); - if (message_arena != submessage_arena) { - buttonsresponsemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, buttonsresponsemessage, submessage_arena); - } - _impl_._has_bits_[1] |= 0x00000004u; - } else { - _impl_._has_bits_[1] &= ~0x00000004u; - } - _impl_.buttonsresponsemessage_ = buttonsresponsemessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.buttonsResponseMessage) -} - -// optional .proto.Message.PaymentInviteMessage paymentInviteMessage = 44; -inline bool Message::_internal_has_paymentinvitemessage() const { - bool value = (_impl_._has_bits_[1] & 0x00000008u) != 0; - PROTOBUF_ASSUME(!value || _impl_.paymentinvitemessage_ != nullptr); - return value; -} -inline bool Message::has_paymentinvitemessage() const { - return _internal_has_paymentinvitemessage(); -} -inline void Message::clear_paymentinvitemessage() { - if (_impl_.paymentinvitemessage_ != nullptr) _impl_.paymentinvitemessage_->Clear(); - _impl_._has_bits_[1] &= ~0x00000008u; -} -inline const ::proto::Message_PaymentInviteMessage& Message::_internal_paymentinvitemessage() const { - const ::proto::Message_PaymentInviteMessage* p = _impl_.paymentinvitemessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_PaymentInviteMessage_default_instance_); -} -inline const ::proto::Message_PaymentInviteMessage& Message::paymentinvitemessage() const { - // @@protoc_insertion_point(field_get:proto.Message.paymentInviteMessage) - return _internal_paymentinvitemessage(); -} -inline void Message::unsafe_arena_set_allocated_paymentinvitemessage( - ::proto::Message_PaymentInviteMessage* paymentinvitemessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.paymentinvitemessage_); - } - _impl_.paymentinvitemessage_ = paymentinvitemessage; - if (paymentinvitemessage) { - _impl_._has_bits_[1] |= 0x00000008u; - } else { - _impl_._has_bits_[1] &= ~0x00000008u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.paymentInviteMessage) -} -inline ::proto::Message_PaymentInviteMessage* Message::release_paymentinvitemessage() { - _impl_._has_bits_[1] &= ~0x00000008u; - ::proto::Message_PaymentInviteMessage* temp = _impl_.paymentinvitemessage_; - _impl_.paymentinvitemessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_PaymentInviteMessage* Message::unsafe_arena_release_paymentinvitemessage() { - // @@protoc_insertion_point(field_release:proto.Message.paymentInviteMessage) - _impl_._has_bits_[1] &= ~0x00000008u; - ::proto::Message_PaymentInviteMessage* temp = _impl_.paymentinvitemessage_; - _impl_.paymentinvitemessage_ = nullptr; - return temp; -} -inline ::proto::Message_PaymentInviteMessage* Message::_internal_mutable_paymentinvitemessage() { - _impl_._has_bits_[1] |= 0x00000008u; - if (_impl_.paymentinvitemessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_PaymentInviteMessage>(GetArenaForAllocation()); - _impl_.paymentinvitemessage_ = p; - } - return _impl_.paymentinvitemessage_; -} -inline ::proto::Message_PaymentInviteMessage* Message::mutable_paymentinvitemessage() { - ::proto::Message_PaymentInviteMessage* _msg = _internal_mutable_paymentinvitemessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.paymentInviteMessage) - return _msg; -} -inline void Message::set_allocated_paymentinvitemessage(::proto::Message_PaymentInviteMessage* paymentinvitemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.paymentinvitemessage_; - } - if (paymentinvitemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(paymentinvitemessage); - if (message_arena != submessage_arena) { - paymentinvitemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, paymentinvitemessage, submessage_arena); - } - _impl_._has_bits_[1] |= 0x00000008u; - } else { - _impl_._has_bits_[1] &= ~0x00000008u; - } - _impl_.paymentinvitemessage_ = paymentinvitemessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.paymentInviteMessage) -} - -// optional .proto.Message.InteractiveMessage interactiveMessage = 45; -inline bool Message::_internal_has_interactivemessage() const { - bool value = (_impl_._has_bits_[1] & 0x00000010u) != 0; - PROTOBUF_ASSUME(!value || _impl_.interactivemessage_ != nullptr); - return value; -} -inline bool Message::has_interactivemessage() const { - return _internal_has_interactivemessage(); -} -inline void Message::clear_interactivemessage() { - if (_impl_.interactivemessage_ != nullptr) _impl_.interactivemessage_->Clear(); - _impl_._has_bits_[1] &= ~0x00000010u; -} -inline const ::proto::Message_InteractiveMessage& Message::_internal_interactivemessage() const { - const ::proto::Message_InteractiveMessage* p = _impl_.interactivemessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_InteractiveMessage_default_instance_); -} -inline const ::proto::Message_InteractiveMessage& Message::interactivemessage() const { - // @@protoc_insertion_point(field_get:proto.Message.interactiveMessage) - return _internal_interactivemessage(); -} -inline void Message::unsafe_arena_set_allocated_interactivemessage( - ::proto::Message_InteractiveMessage* interactivemessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.interactivemessage_); - } - _impl_.interactivemessage_ = interactivemessage; - if (interactivemessage) { - _impl_._has_bits_[1] |= 0x00000010u; - } else { - _impl_._has_bits_[1] &= ~0x00000010u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.interactiveMessage) -} -inline ::proto::Message_InteractiveMessage* Message::release_interactivemessage() { - _impl_._has_bits_[1] &= ~0x00000010u; - ::proto::Message_InteractiveMessage* temp = _impl_.interactivemessage_; - _impl_.interactivemessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_InteractiveMessage* Message::unsafe_arena_release_interactivemessage() { - // @@protoc_insertion_point(field_release:proto.Message.interactiveMessage) - _impl_._has_bits_[1] &= ~0x00000010u; - ::proto::Message_InteractiveMessage* temp = _impl_.interactivemessage_; - _impl_.interactivemessage_ = nullptr; - return temp; -} -inline ::proto::Message_InteractiveMessage* Message::_internal_mutable_interactivemessage() { - _impl_._has_bits_[1] |= 0x00000010u; - if (_impl_.interactivemessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_InteractiveMessage>(GetArenaForAllocation()); - _impl_.interactivemessage_ = p; - } - return _impl_.interactivemessage_; -} -inline ::proto::Message_InteractiveMessage* Message::mutable_interactivemessage() { - ::proto::Message_InteractiveMessage* _msg = _internal_mutable_interactivemessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.interactiveMessage) - return _msg; -} -inline void Message::set_allocated_interactivemessage(::proto::Message_InteractiveMessage* interactivemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.interactivemessage_; - } - if (interactivemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(interactivemessage); - if (message_arena != submessage_arena) { - interactivemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, interactivemessage, submessage_arena); - } - _impl_._has_bits_[1] |= 0x00000010u; - } else { - _impl_._has_bits_[1] &= ~0x00000010u; - } - _impl_.interactivemessage_ = interactivemessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.interactiveMessage) -} - -// optional .proto.Message.ReactionMessage reactionMessage = 46; -inline bool Message::_internal_has_reactionmessage() const { - bool value = (_impl_._has_bits_[1] & 0x00000020u) != 0; - PROTOBUF_ASSUME(!value || _impl_.reactionmessage_ != nullptr); - return value; -} -inline bool Message::has_reactionmessage() const { - return _internal_has_reactionmessage(); -} -inline void Message::clear_reactionmessage() { - if (_impl_.reactionmessage_ != nullptr) _impl_.reactionmessage_->Clear(); - _impl_._has_bits_[1] &= ~0x00000020u; -} -inline const ::proto::Message_ReactionMessage& Message::_internal_reactionmessage() const { - const ::proto::Message_ReactionMessage* p = _impl_.reactionmessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_ReactionMessage_default_instance_); -} -inline const ::proto::Message_ReactionMessage& Message::reactionmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.reactionMessage) - return _internal_reactionmessage(); -} -inline void Message::unsafe_arena_set_allocated_reactionmessage( - ::proto::Message_ReactionMessage* reactionmessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.reactionmessage_); - } - _impl_.reactionmessage_ = reactionmessage; - if (reactionmessage) { - _impl_._has_bits_[1] |= 0x00000020u; - } else { - _impl_._has_bits_[1] &= ~0x00000020u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.reactionMessage) -} -inline ::proto::Message_ReactionMessage* Message::release_reactionmessage() { - _impl_._has_bits_[1] &= ~0x00000020u; - ::proto::Message_ReactionMessage* temp = _impl_.reactionmessage_; - _impl_.reactionmessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_ReactionMessage* Message::unsafe_arena_release_reactionmessage() { - // @@protoc_insertion_point(field_release:proto.Message.reactionMessage) - _impl_._has_bits_[1] &= ~0x00000020u; - ::proto::Message_ReactionMessage* temp = _impl_.reactionmessage_; - _impl_.reactionmessage_ = nullptr; - return temp; -} -inline ::proto::Message_ReactionMessage* Message::_internal_mutable_reactionmessage() { - _impl_._has_bits_[1] |= 0x00000020u; - if (_impl_.reactionmessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_ReactionMessage>(GetArenaForAllocation()); - _impl_.reactionmessage_ = p; - } - return _impl_.reactionmessage_; -} -inline ::proto::Message_ReactionMessage* Message::mutable_reactionmessage() { - ::proto::Message_ReactionMessage* _msg = _internal_mutable_reactionmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.reactionMessage) - return _msg; -} -inline void Message::set_allocated_reactionmessage(::proto::Message_ReactionMessage* reactionmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.reactionmessage_; - } - if (reactionmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(reactionmessage); - if (message_arena != submessage_arena) { - reactionmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, reactionmessage, submessage_arena); - } - _impl_._has_bits_[1] |= 0x00000020u; - } else { - _impl_._has_bits_[1] &= ~0x00000020u; - } - _impl_.reactionmessage_ = reactionmessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.reactionMessage) -} - -// optional .proto.Message.StickerSyncRMRMessage stickerSyncRmrMessage = 47; -inline bool Message::_internal_has_stickersyncrmrmessage() const { - bool value = (_impl_._has_bits_[1] & 0x00000040u) != 0; - PROTOBUF_ASSUME(!value || _impl_.stickersyncrmrmessage_ != nullptr); - return value; -} -inline bool Message::has_stickersyncrmrmessage() const { - return _internal_has_stickersyncrmrmessage(); -} -inline void Message::clear_stickersyncrmrmessage() { - if (_impl_.stickersyncrmrmessage_ != nullptr) _impl_.stickersyncrmrmessage_->Clear(); - _impl_._has_bits_[1] &= ~0x00000040u; -} -inline const ::proto::Message_StickerSyncRMRMessage& Message::_internal_stickersyncrmrmessage() const { - const ::proto::Message_StickerSyncRMRMessage* p = _impl_.stickersyncrmrmessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_StickerSyncRMRMessage_default_instance_); -} -inline const ::proto::Message_StickerSyncRMRMessage& Message::stickersyncrmrmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.stickerSyncRmrMessage) - return _internal_stickersyncrmrmessage(); -} -inline void Message::unsafe_arena_set_allocated_stickersyncrmrmessage( - ::proto::Message_StickerSyncRMRMessage* stickersyncrmrmessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.stickersyncrmrmessage_); - } - _impl_.stickersyncrmrmessage_ = stickersyncrmrmessage; - if (stickersyncrmrmessage) { - _impl_._has_bits_[1] |= 0x00000040u; - } else { - _impl_._has_bits_[1] &= ~0x00000040u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.stickerSyncRmrMessage) -} -inline ::proto::Message_StickerSyncRMRMessage* Message::release_stickersyncrmrmessage() { - _impl_._has_bits_[1] &= ~0x00000040u; - ::proto::Message_StickerSyncRMRMessage* temp = _impl_.stickersyncrmrmessage_; - _impl_.stickersyncrmrmessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_StickerSyncRMRMessage* Message::unsafe_arena_release_stickersyncrmrmessage() { - // @@protoc_insertion_point(field_release:proto.Message.stickerSyncRmrMessage) - _impl_._has_bits_[1] &= ~0x00000040u; - ::proto::Message_StickerSyncRMRMessage* temp = _impl_.stickersyncrmrmessage_; - _impl_.stickersyncrmrmessage_ = nullptr; - return temp; -} -inline ::proto::Message_StickerSyncRMRMessage* Message::_internal_mutable_stickersyncrmrmessage() { - _impl_._has_bits_[1] |= 0x00000040u; - if (_impl_.stickersyncrmrmessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_StickerSyncRMRMessage>(GetArenaForAllocation()); - _impl_.stickersyncrmrmessage_ = p; - } - return _impl_.stickersyncrmrmessage_; -} -inline ::proto::Message_StickerSyncRMRMessage* Message::mutable_stickersyncrmrmessage() { - ::proto::Message_StickerSyncRMRMessage* _msg = _internal_mutable_stickersyncrmrmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.stickerSyncRmrMessage) - return _msg; -} -inline void Message::set_allocated_stickersyncrmrmessage(::proto::Message_StickerSyncRMRMessage* stickersyncrmrmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.stickersyncrmrmessage_; - } - if (stickersyncrmrmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(stickersyncrmrmessage); - if (message_arena != submessage_arena) { - stickersyncrmrmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, stickersyncrmrmessage, submessage_arena); - } - _impl_._has_bits_[1] |= 0x00000040u; - } else { - _impl_._has_bits_[1] &= ~0x00000040u; - } - _impl_.stickersyncrmrmessage_ = stickersyncrmrmessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.stickerSyncRmrMessage) -} - -// optional .proto.Message.InteractiveResponseMessage interactiveResponseMessage = 48; -inline bool Message::_internal_has_interactiveresponsemessage() const { - bool value = (_impl_._has_bits_[1] & 0x00000080u) != 0; - PROTOBUF_ASSUME(!value || _impl_.interactiveresponsemessage_ != nullptr); - return value; -} -inline bool Message::has_interactiveresponsemessage() const { - return _internal_has_interactiveresponsemessage(); -} -inline void Message::clear_interactiveresponsemessage() { - if (_impl_.interactiveresponsemessage_ != nullptr) _impl_.interactiveresponsemessage_->Clear(); - _impl_._has_bits_[1] &= ~0x00000080u; -} -inline const ::proto::Message_InteractiveResponseMessage& Message::_internal_interactiveresponsemessage() const { - const ::proto::Message_InteractiveResponseMessage* p = _impl_.interactiveresponsemessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_InteractiveResponseMessage_default_instance_); -} -inline const ::proto::Message_InteractiveResponseMessage& Message::interactiveresponsemessage() const { - // @@protoc_insertion_point(field_get:proto.Message.interactiveResponseMessage) - return _internal_interactiveresponsemessage(); -} -inline void Message::unsafe_arena_set_allocated_interactiveresponsemessage( - ::proto::Message_InteractiveResponseMessage* interactiveresponsemessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.interactiveresponsemessage_); - } - _impl_.interactiveresponsemessage_ = interactiveresponsemessage; - if (interactiveresponsemessage) { - _impl_._has_bits_[1] |= 0x00000080u; - } else { - _impl_._has_bits_[1] &= ~0x00000080u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.interactiveResponseMessage) -} -inline ::proto::Message_InteractiveResponseMessage* Message::release_interactiveresponsemessage() { - _impl_._has_bits_[1] &= ~0x00000080u; - ::proto::Message_InteractiveResponseMessage* temp = _impl_.interactiveresponsemessage_; - _impl_.interactiveresponsemessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_InteractiveResponseMessage* Message::unsafe_arena_release_interactiveresponsemessage() { - // @@protoc_insertion_point(field_release:proto.Message.interactiveResponseMessage) - _impl_._has_bits_[1] &= ~0x00000080u; - ::proto::Message_InteractiveResponseMessage* temp = _impl_.interactiveresponsemessage_; - _impl_.interactiveresponsemessage_ = nullptr; - return temp; -} -inline ::proto::Message_InteractiveResponseMessage* Message::_internal_mutable_interactiveresponsemessage() { - _impl_._has_bits_[1] |= 0x00000080u; - if (_impl_.interactiveresponsemessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_InteractiveResponseMessage>(GetArenaForAllocation()); - _impl_.interactiveresponsemessage_ = p; - } - return _impl_.interactiveresponsemessage_; -} -inline ::proto::Message_InteractiveResponseMessage* Message::mutable_interactiveresponsemessage() { - ::proto::Message_InteractiveResponseMessage* _msg = _internal_mutable_interactiveresponsemessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.interactiveResponseMessage) - return _msg; -} -inline void Message::set_allocated_interactiveresponsemessage(::proto::Message_InteractiveResponseMessage* interactiveresponsemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.interactiveresponsemessage_; - } - if (interactiveresponsemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(interactiveresponsemessage); - if (message_arena != submessage_arena) { - interactiveresponsemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, interactiveresponsemessage, submessage_arena); - } - _impl_._has_bits_[1] |= 0x00000080u; - } else { - _impl_._has_bits_[1] &= ~0x00000080u; - } - _impl_.interactiveresponsemessage_ = interactiveresponsemessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.interactiveResponseMessage) -} - -// optional .proto.Message.PollCreationMessage pollCreationMessage = 49; -inline bool Message::_internal_has_pollcreationmessage() const { - bool value = (_impl_._has_bits_[1] & 0x00000100u) != 0; - PROTOBUF_ASSUME(!value || _impl_.pollcreationmessage_ != nullptr); - return value; -} -inline bool Message::has_pollcreationmessage() const { - return _internal_has_pollcreationmessage(); -} -inline void Message::clear_pollcreationmessage() { - if (_impl_.pollcreationmessage_ != nullptr) _impl_.pollcreationmessage_->Clear(); - _impl_._has_bits_[1] &= ~0x00000100u; -} -inline const ::proto::Message_PollCreationMessage& Message::_internal_pollcreationmessage() const { - const ::proto::Message_PollCreationMessage* p = _impl_.pollcreationmessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_PollCreationMessage_default_instance_); -} -inline const ::proto::Message_PollCreationMessage& Message::pollcreationmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.pollCreationMessage) - return _internal_pollcreationmessage(); -} -inline void Message::unsafe_arena_set_allocated_pollcreationmessage( - ::proto::Message_PollCreationMessage* pollcreationmessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pollcreationmessage_); - } - _impl_.pollcreationmessage_ = pollcreationmessage; - if (pollcreationmessage) { - _impl_._has_bits_[1] |= 0x00000100u; - } else { - _impl_._has_bits_[1] &= ~0x00000100u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.pollCreationMessage) -} -inline ::proto::Message_PollCreationMessage* Message::release_pollcreationmessage() { - _impl_._has_bits_[1] &= ~0x00000100u; - ::proto::Message_PollCreationMessage* temp = _impl_.pollcreationmessage_; - _impl_.pollcreationmessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_PollCreationMessage* Message::unsafe_arena_release_pollcreationmessage() { - // @@protoc_insertion_point(field_release:proto.Message.pollCreationMessage) - _impl_._has_bits_[1] &= ~0x00000100u; - ::proto::Message_PollCreationMessage* temp = _impl_.pollcreationmessage_; - _impl_.pollcreationmessage_ = nullptr; - return temp; -} -inline ::proto::Message_PollCreationMessage* Message::_internal_mutable_pollcreationmessage() { - _impl_._has_bits_[1] |= 0x00000100u; - if (_impl_.pollcreationmessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_PollCreationMessage>(GetArenaForAllocation()); - _impl_.pollcreationmessage_ = p; - } - return _impl_.pollcreationmessage_; -} -inline ::proto::Message_PollCreationMessage* Message::mutable_pollcreationmessage() { - ::proto::Message_PollCreationMessage* _msg = _internal_mutable_pollcreationmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.pollCreationMessage) - return _msg; -} -inline void Message::set_allocated_pollcreationmessage(::proto::Message_PollCreationMessage* pollcreationmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.pollcreationmessage_; - } - if (pollcreationmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pollcreationmessage); - if (message_arena != submessage_arena) { - pollcreationmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, pollcreationmessage, submessage_arena); - } - _impl_._has_bits_[1] |= 0x00000100u; - } else { - _impl_._has_bits_[1] &= ~0x00000100u; - } - _impl_.pollcreationmessage_ = pollcreationmessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.pollCreationMessage) -} - -// optional .proto.Message.PollUpdateMessage pollUpdateMessage = 50; -inline bool Message::_internal_has_pollupdatemessage() const { - bool value = (_impl_._has_bits_[1] & 0x00000200u) != 0; - PROTOBUF_ASSUME(!value || _impl_.pollupdatemessage_ != nullptr); - return value; -} -inline bool Message::has_pollupdatemessage() const { - return _internal_has_pollupdatemessage(); -} -inline void Message::clear_pollupdatemessage() { - if (_impl_.pollupdatemessage_ != nullptr) _impl_.pollupdatemessage_->Clear(); - _impl_._has_bits_[1] &= ~0x00000200u; -} -inline const ::proto::Message_PollUpdateMessage& Message::_internal_pollupdatemessage() const { - const ::proto::Message_PollUpdateMessage* p = _impl_.pollupdatemessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_PollUpdateMessage_default_instance_); -} -inline const ::proto::Message_PollUpdateMessage& Message::pollupdatemessage() const { - // @@protoc_insertion_point(field_get:proto.Message.pollUpdateMessage) - return _internal_pollupdatemessage(); -} -inline void Message::unsafe_arena_set_allocated_pollupdatemessage( - ::proto::Message_PollUpdateMessage* pollupdatemessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pollupdatemessage_); - } - _impl_.pollupdatemessage_ = pollupdatemessage; - if (pollupdatemessage) { - _impl_._has_bits_[1] |= 0x00000200u; - } else { - _impl_._has_bits_[1] &= ~0x00000200u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.pollUpdateMessage) -} -inline ::proto::Message_PollUpdateMessage* Message::release_pollupdatemessage() { - _impl_._has_bits_[1] &= ~0x00000200u; - ::proto::Message_PollUpdateMessage* temp = _impl_.pollupdatemessage_; - _impl_.pollupdatemessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_PollUpdateMessage* Message::unsafe_arena_release_pollupdatemessage() { - // @@protoc_insertion_point(field_release:proto.Message.pollUpdateMessage) - _impl_._has_bits_[1] &= ~0x00000200u; - ::proto::Message_PollUpdateMessage* temp = _impl_.pollupdatemessage_; - _impl_.pollupdatemessage_ = nullptr; - return temp; -} -inline ::proto::Message_PollUpdateMessage* Message::_internal_mutable_pollupdatemessage() { - _impl_._has_bits_[1] |= 0x00000200u; - if (_impl_.pollupdatemessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_PollUpdateMessage>(GetArenaForAllocation()); - _impl_.pollupdatemessage_ = p; - } - return _impl_.pollupdatemessage_; -} -inline ::proto::Message_PollUpdateMessage* Message::mutable_pollupdatemessage() { - ::proto::Message_PollUpdateMessage* _msg = _internal_mutable_pollupdatemessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.pollUpdateMessage) - return _msg; -} -inline void Message::set_allocated_pollupdatemessage(::proto::Message_PollUpdateMessage* pollupdatemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.pollupdatemessage_; - } - if (pollupdatemessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pollupdatemessage); - if (message_arena != submessage_arena) { - pollupdatemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, pollupdatemessage, submessage_arena); - } - _impl_._has_bits_[1] |= 0x00000200u; - } else { - _impl_._has_bits_[1] &= ~0x00000200u; - } - _impl_.pollupdatemessage_ = pollupdatemessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.pollUpdateMessage) -} - -// optional .proto.Message.KeepInChatMessage keepInChatMessage = 51; -inline bool Message::_internal_has_keepinchatmessage() const { - bool value = (_impl_._has_bits_[1] & 0x00000400u) != 0; - PROTOBUF_ASSUME(!value || _impl_.keepinchatmessage_ != nullptr); - return value; -} -inline bool Message::has_keepinchatmessage() const { - return _internal_has_keepinchatmessage(); -} -inline void Message::clear_keepinchatmessage() { - if (_impl_.keepinchatmessage_ != nullptr) _impl_.keepinchatmessage_->Clear(); - _impl_._has_bits_[1] &= ~0x00000400u; -} -inline const ::proto::Message_KeepInChatMessage& Message::_internal_keepinchatmessage() const { - const ::proto::Message_KeepInChatMessage* p = _impl_.keepinchatmessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_KeepInChatMessage_default_instance_); -} -inline const ::proto::Message_KeepInChatMessage& Message::keepinchatmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.keepInChatMessage) - return _internal_keepinchatmessage(); -} -inline void Message::unsafe_arena_set_allocated_keepinchatmessage( - ::proto::Message_KeepInChatMessage* keepinchatmessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keepinchatmessage_); - } - _impl_.keepinchatmessage_ = keepinchatmessage; - if (keepinchatmessage) { - _impl_._has_bits_[1] |= 0x00000400u; - } else { - _impl_._has_bits_[1] &= ~0x00000400u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.keepInChatMessage) -} -inline ::proto::Message_KeepInChatMessage* Message::release_keepinchatmessage() { - _impl_._has_bits_[1] &= ~0x00000400u; - ::proto::Message_KeepInChatMessage* temp = _impl_.keepinchatmessage_; - _impl_.keepinchatmessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_KeepInChatMessage* Message::unsafe_arena_release_keepinchatmessage() { - // @@protoc_insertion_point(field_release:proto.Message.keepInChatMessage) - _impl_._has_bits_[1] &= ~0x00000400u; - ::proto::Message_KeepInChatMessage* temp = _impl_.keepinchatmessage_; - _impl_.keepinchatmessage_ = nullptr; - return temp; -} -inline ::proto::Message_KeepInChatMessage* Message::_internal_mutable_keepinchatmessage() { - _impl_._has_bits_[1] |= 0x00000400u; - if (_impl_.keepinchatmessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_KeepInChatMessage>(GetArenaForAllocation()); - _impl_.keepinchatmessage_ = p; - } - return _impl_.keepinchatmessage_; -} -inline ::proto::Message_KeepInChatMessage* Message::mutable_keepinchatmessage() { - ::proto::Message_KeepInChatMessage* _msg = _internal_mutable_keepinchatmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.keepInChatMessage) - return _msg; -} -inline void Message::set_allocated_keepinchatmessage(::proto::Message_KeepInChatMessage* keepinchatmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.keepinchatmessage_; - } - if (keepinchatmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keepinchatmessage); - if (message_arena != submessage_arena) { - keepinchatmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, keepinchatmessage, submessage_arena); - } - _impl_._has_bits_[1] |= 0x00000400u; - } else { - _impl_._has_bits_[1] &= ~0x00000400u; - } - _impl_.keepinchatmessage_ = keepinchatmessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.keepInChatMessage) -} - -// optional .proto.Message.FutureProofMessage documentWithCaptionMessage = 53; -inline bool Message::_internal_has_documentwithcaptionmessage() const { - bool value = (_impl_._has_bits_[1] & 0x00000800u) != 0; - PROTOBUF_ASSUME(!value || _impl_.documentwithcaptionmessage_ != nullptr); - return value; -} -inline bool Message::has_documentwithcaptionmessage() const { - return _internal_has_documentwithcaptionmessage(); -} -inline void Message::clear_documentwithcaptionmessage() { - if (_impl_.documentwithcaptionmessage_ != nullptr) _impl_.documentwithcaptionmessage_->Clear(); - _impl_._has_bits_[1] &= ~0x00000800u; -} -inline const ::proto::Message_FutureProofMessage& Message::_internal_documentwithcaptionmessage() const { - const ::proto::Message_FutureProofMessage* p = _impl_.documentwithcaptionmessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_FutureProofMessage_default_instance_); -} -inline const ::proto::Message_FutureProofMessage& Message::documentwithcaptionmessage() const { - // @@protoc_insertion_point(field_get:proto.Message.documentWithCaptionMessage) - return _internal_documentwithcaptionmessage(); -} -inline void Message::unsafe_arena_set_allocated_documentwithcaptionmessage( - ::proto::Message_FutureProofMessage* documentwithcaptionmessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.documentwithcaptionmessage_); - } - _impl_.documentwithcaptionmessage_ = documentwithcaptionmessage; - if (documentwithcaptionmessage) { - _impl_._has_bits_[1] |= 0x00000800u; - } else { - _impl_._has_bits_[1] &= ~0x00000800u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.documentWithCaptionMessage) -} -inline ::proto::Message_FutureProofMessage* Message::release_documentwithcaptionmessage() { - _impl_._has_bits_[1] &= ~0x00000800u; - ::proto::Message_FutureProofMessage* temp = _impl_.documentwithcaptionmessage_; - _impl_.documentwithcaptionmessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_FutureProofMessage* Message::unsafe_arena_release_documentwithcaptionmessage() { - // @@protoc_insertion_point(field_release:proto.Message.documentWithCaptionMessage) - _impl_._has_bits_[1] &= ~0x00000800u; - ::proto::Message_FutureProofMessage* temp = _impl_.documentwithcaptionmessage_; - _impl_.documentwithcaptionmessage_ = nullptr; - return temp; -} -inline ::proto::Message_FutureProofMessage* Message::_internal_mutable_documentwithcaptionmessage() { - _impl_._has_bits_[1] |= 0x00000800u; - if (_impl_.documentwithcaptionmessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_FutureProofMessage>(GetArenaForAllocation()); - _impl_.documentwithcaptionmessage_ = p; - } - return _impl_.documentwithcaptionmessage_; -} -inline ::proto::Message_FutureProofMessage* Message::mutable_documentwithcaptionmessage() { - ::proto::Message_FutureProofMessage* _msg = _internal_mutable_documentwithcaptionmessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.documentWithCaptionMessage) - return _msg; -} -inline void Message::set_allocated_documentwithcaptionmessage(::proto::Message_FutureProofMessage* documentwithcaptionmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.documentwithcaptionmessage_; - } - if (documentwithcaptionmessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(documentwithcaptionmessage); - if (message_arena != submessage_arena) { - documentwithcaptionmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, documentwithcaptionmessage, submessage_arena); - } - _impl_._has_bits_[1] |= 0x00000800u; - } else { - _impl_._has_bits_[1] &= ~0x00000800u; - } - _impl_.documentwithcaptionmessage_ = documentwithcaptionmessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.documentWithCaptionMessage) -} - -// optional .proto.Message.RequestPhoneNumberMessage requestPhoneNumberMessage = 54; -inline bool Message::_internal_has_requestphonenumbermessage() const { - bool value = (_impl_._has_bits_[1] & 0x00001000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.requestphonenumbermessage_ != nullptr); - return value; -} -inline bool Message::has_requestphonenumbermessage() const { - return _internal_has_requestphonenumbermessage(); -} -inline void Message::clear_requestphonenumbermessage() { - if (_impl_.requestphonenumbermessage_ != nullptr) _impl_.requestphonenumbermessage_->Clear(); - _impl_._has_bits_[1] &= ~0x00001000u; -} -inline const ::proto::Message_RequestPhoneNumberMessage& Message::_internal_requestphonenumbermessage() const { - const ::proto::Message_RequestPhoneNumberMessage* p = _impl_.requestphonenumbermessage_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_RequestPhoneNumberMessage_default_instance_); -} -inline const ::proto::Message_RequestPhoneNumberMessage& Message::requestphonenumbermessage() const { - // @@protoc_insertion_point(field_get:proto.Message.requestPhoneNumberMessage) - return _internal_requestphonenumbermessage(); -} -inline void Message::unsafe_arena_set_allocated_requestphonenumbermessage( - ::proto::Message_RequestPhoneNumberMessage* requestphonenumbermessage) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.requestphonenumbermessage_); - } - _impl_.requestphonenumbermessage_ = requestphonenumbermessage; - if (requestphonenumbermessage) { - _impl_._has_bits_[1] |= 0x00001000u; - } else { - _impl_._has_bits_[1] &= ~0x00001000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.requestPhoneNumberMessage) -} -inline ::proto::Message_RequestPhoneNumberMessage* Message::release_requestphonenumbermessage() { - _impl_._has_bits_[1] &= ~0x00001000u; - ::proto::Message_RequestPhoneNumberMessage* temp = _impl_.requestphonenumbermessage_; - _impl_.requestphonenumbermessage_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_RequestPhoneNumberMessage* Message::unsafe_arena_release_requestphonenumbermessage() { - // @@protoc_insertion_point(field_release:proto.Message.requestPhoneNumberMessage) - _impl_._has_bits_[1] &= ~0x00001000u; - ::proto::Message_RequestPhoneNumberMessage* temp = _impl_.requestphonenumbermessage_; - _impl_.requestphonenumbermessage_ = nullptr; - return temp; -} -inline ::proto::Message_RequestPhoneNumberMessage* Message::_internal_mutable_requestphonenumbermessage() { - _impl_._has_bits_[1] |= 0x00001000u; - if (_impl_.requestphonenumbermessage_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_RequestPhoneNumberMessage>(GetArenaForAllocation()); - _impl_.requestphonenumbermessage_ = p; - } - return _impl_.requestphonenumbermessage_; -} -inline ::proto::Message_RequestPhoneNumberMessage* Message::mutable_requestphonenumbermessage() { - ::proto::Message_RequestPhoneNumberMessage* _msg = _internal_mutable_requestphonenumbermessage(); - // @@protoc_insertion_point(field_mutable:proto.Message.requestPhoneNumberMessage) - return _msg; -} -inline void Message::set_allocated_requestphonenumbermessage(::proto::Message_RequestPhoneNumberMessage* requestphonenumbermessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.requestphonenumbermessage_; - } - if (requestphonenumbermessage) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(requestphonenumbermessage); - if (message_arena != submessage_arena) { - requestphonenumbermessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, requestphonenumbermessage, submessage_arena); - } - _impl_._has_bits_[1] |= 0x00001000u; - } else { - _impl_._has_bits_[1] &= ~0x00001000u; - } - _impl_.requestphonenumbermessage_ = requestphonenumbermessage; - // @@protoc_insertion_point(field_set_allocated:proto.Message.requestPhoneNumberMessage) -} - -// optional .proto.Message.FutureProofMessage viewOnceMessageV2 = 55; -inline bool Message::_internal_has_viewoncemessagev2() const { - bool value = (_impl_._has_bits_[1] & 0x00002000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.viewoncemessagev2_ != nullptr); - return value; -} -inline bool Message::has_viewoncemessagev2() const { - return _internal_has_viewoncemessagev2(); -} -inline void Message::clear_viewoncemessagev2() { - if (_impl_.viewoncemessagev2_ != nullptr) _impl_.viewoncemessagev2_->Clear(); - _impl_._has_bits_[1] &= ~0x00002000u; -} -inline const ::proto::Message_FutureProofMessage& Message::_internal_viewoncemessagev2() const { - const ::proto::Message_FutureProofMessage* p = _impl_.viewoncemessagev2_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_FutureProofMessage_default_instance_); -} -inline const ::proto::Message_FutureProofMessage& Message::viewoncemessagev2() const { - // @@protoc_insertion_point(field_get:proto.Message.viewOnceMessageV2) - return _internal_viewoncemessagev2(); -} -inline void Message::unsafe_arena_set_allocated_viewoncemessagev2( - ::proto::Message_FutureProofMessage* viewoncemessagev2) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.viewoncemessagev2_); - } - _impl_.viewoncemessagev2_ = viewoncemessagev2; - if (viewoncemessagev2) { - _impl_._has_bits_[1] |= 0x00002000u; - } else { - _impl_._has_bits_[1] &= ~0x00002000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.viewOnceMessageV2) -} -inline ::proto::Message_FutureProofMessage* Message::release_viewoncemessagev2() { - _impl_._has_bits_[1] &= ~0x00002000u; - ::proto::Message_FutureProofMessage* temp = _impl_.viewoncemessagev2_; - _impl_.viewoncemessagev2_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_FutureProofMessage* Message::unsafe_arena_release_viewoncemessagev2() { - // @@protoc_insertion_point(field_release:proto.Message.viewOnceMessageV2) - _impl_._has_bits_[1] &= ~0x00002000u; - ::proto::Message_FutureProofMessage* temp = _impl_.viewoncemessagev2_; - _impl_.viewoncemessagev2_ = nullptr; - return temp; -} -inline ::proto::Message_FutureProofMessage* Message::_internal_mutable_viewoncemessagev2() { - _impl_._has_bits_[1] |= 0x00002000u; - if (_impl_.viewoncemessagev2_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_FutureProofMessage>(GetArenaForAllocation()); - _impl_.viewoncemessagev2_ = p; - } - return _impl_.viewoncemessagev2_; -} -inline ::proto::Message_FutureProofMessage* Message::mutable_viewoncemessagev2() { - ::proto::Message_FutureProofMessage* _msg = _internal_mutable_viewoncemessagev2(); - // @@protoc_insertion_point(field_mutable:proto.Message.viewOnceMessageV2) - return _msg; -} -inline void Message::set_allocated_viewoncemessagev2(::proto::Message_FutureProofMessage* viewoncemessagev2) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.viewoncemessagev2_; - } - if (viewoncemessagev2) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(viewoncemessagev2); - if (message_arena != submessage_arena) { - viewoncemessagev2 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, viewoncemessagev2, submessage_arena); - } - _impl_._has_bits_[1] |= 0x00002000u; - } else { - _impl_._has_bits_[1] &= ~0x00002000u; - } - _impl_.viewoncemessagev2_ = viewoncemessagev2; - // @@protoc_insertion_point(field_set_allocated:proto.Message.viewOnceMessageV2) -} - -// ------------------------------------------------------------------- - -// MessageContextInfo - -// optional .proto.DeviceListMetadata deviceListMetadata = 1; -inline bool MessageContextInfo::_internal_has_devicelistmetadata() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - PROTOBUF_ASSUME(!value || _impl_.devicelistmetadata_ != nullptr); - return value; -} -inline bool MessageContextInfo::has_devicelistmetadata() const { - return _internal_has_devicelistmetadata(); -} -inline void MessageContextInfo::clear_devicelistmetadata() { - if (_impl_.devicelistmetadata_ != nullptr) _impl_.devicelistmetadata_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const ::proto::DeviceListMetadata& MessageContextInfo::_internal_devicelistmetadata() const { - const ::proto::DeviceListMetadata* p = _impl_.devicelistmetadata_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_DeviceListMetadata_default_instance_); -} -inline const ::proto::DeviceListMetadata& MessageContextInfo::devicelistmetadata() const { - // @@protoc_insertion_point(field_get:proto.MessageContextInfo.deviceListMetadata) - return _internal_devicelistmetadata(); -} -inline void MessageContextInfo::unsafe_arena_set_allocated_devicelistmetadata( - ::proto::DeviceListMetadata* devicelistmetadata) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.devicelistmetadata_); - } - _impl_.devicelistmetadata_ = devicelistmetadata; - if (devicelistmetadata) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.MessageContextInfo.deviceListMetadata) -} -inline ::proto::DeviceListMetadata* MessageContextInfo::release_devicelistmetadata() { - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::DeviceListMetadata* temp = _impl_.devicelistmetadata_; - _impl_.devicelistmetadata_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::DeviceListMetadata* MessageContextInfo::unsafe_arena_release_devicelistmetadata() { - // @@protoc_insertion_point(field_release:proto.MessageContextInfo.deviceListMetadata) - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::DeviceListMetadata* temp = _impl_.devicelistmetadata_; - _impl_.devicelistmetadata_ = nullptr; - return temp; -} -inline ::proto::DeviceListMetadata* MessageContextInfo::_internal_mutable_devicelistmetadata() { - _impl_._has_bits_[0] |= 0x00000004u; - if (_impl_.devicelistmetadata_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::DeviceListMetadata>(GetArenaForAllocation()); - _impl_.devicelistmetadata_ = p; - } - return _impl_.devicelistmetadata_; -} -inline ::proto::DeviceListMetadata* MessageContextInfo::mutable_devicelistmetadata() { - ::proto::DeviceListMetadata* _msg = _internal_mutable_devicelistmetadata(); - // @@protoc_insertion_point(field_mutable:proto.MessageContextInfo.deviceListMetadata) - return _msg; -} -inline void MessageContextInfo::set_allocated_devicelistmetadata(::proto::DeviceListMetadata* devicelistmetadata) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.devicelistmetadata_; - } - if (devicelistmetadata) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(devicelistmetadata); - if (message_arena != submessage_arena) { - devicelistmetadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, devicelistmetadata, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.devicelistmetadata_ = devicelistmetadata; - // @@protoc_insertion_point(field_set_allocated:proto.MessageContextInfo.deviceListMetadata) -} - -// optional int32 deviceListMetadataVersion = 2; -inline bool MessageContextInfo::_internal_has_devicelistmetadataversion() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool MessageContextInfo::has_devicelistmetadataversion() const { - return _internal_has_devicelistmetadataversion(); -} -inline void MessageContextInfo::clear_devicelistmetadataversion() { - _impl_.devicelistmetadataversion_ = 0; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline int32_t MessageContextInfo::_internal_devicelistmetadataversion() const { - return _impl_.devicelistmetadataversion_; -} -inline int32_t MessageContextInfo::devicelistmetadataversion() const { - // @@protoc_insertion_point(field_get:proto.MessageContextInfo.deviceListMetadataVersion) - return _internal_devicelistmetadataversion(); -} -inline void MessageContextInfo::_internal_set_devicelistmetadataversion(int32_t value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.devicelistmetadataversion_ = value; -} -inline void MessageContextInfo::set_devicelistmetadataversion(int32_t value) { - _internal_set_devicelistmetadataversion(value); - // @@protoc_insertion_point(field_set:proto.MessageContextInfo.deviceListMetadataVersion) -} - -// optional bytes messageSecret = 3; -inline bool MessageContextInfo::_internal_has_messagesecret() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool MessageContextInfo::has_messagesecret() const { - return _internal_has_messagesecret(); -} -inline void MessageContextInfo::clear_messagesecret() { - _impl_.messagesecret_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& MessageContextInfo::messagesecret() const { - // @@protoc_insertion_point(field_get:proto.MessageContextInfo.messageSecret) - return _internal_messagesecret(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void MessageContextInfo::set_messagesecret(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.messagesecret_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.MessageContextInfo.messageSecret) -} -inline std::string* MessageContextInfo::mutable_messagesecret() { - std::string* _s = _internal_mutable_messagesecret(); - // @@protoc_insertion_point(field_mutable:proto.MessageContextInfo.messageSecret) - return _s; -} -inline const std::string& MessageContextInfo::_internal_messagesecret() const { - return _impl_.messagesecret_.Get(); -} -inline void MessageContextInfo::_internal_set_messagesecret(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.messagesecret_.Set(value, GetArenaForAllocation()); -} -inline std::string* MessageContextInfo::_internal_mutable_messagesecret() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.messagesecret_.Mutable(GetArenaForAllocation()); -} -inline std::string* MessageContextInfo::release_messagesecret() { - // @@protoc_insertion_point(field_release:proto.MessageContextInfo.messageSecret) - if (!_internal_has_messagesecret()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.messagesecret_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.messagesecret_.IsDefault()) { - _impl_.messagesecret_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void MessageContextInfo::set_allocated_messagesecret(std::string* messagesecret) { - if (messagesecret != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.messagesecret_.SetAllocated(messagesecret, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.messagesecret_.IsDefault()) { - _impl_.messagesecret_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.MessageContextInfo.messageSecret) -} - -// optional bytes paddingBytes = 4; -inline bool MessageContextInfo::_internal_has_paddingbytes() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool MessageContextInfo::has_paddingbytes() const { - return _internal_has_paddingbytes(); -} -inline void MessageContextInfo::clear_paddingbytes() { - _impl_.paddingbytes_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& MessageContextInfo::paddingbytes() const { - // @@protoc_insertion_point(field_get:proto.MessageContextInfo.paddingBytes) - return _internal_paddingbytes(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void MessageContextInfo::set_paddingbytes(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.paddingbytes_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.MessageContextInfo.paddingBytes) -} -inline std::string* MessageContextInfo::mutable_paddingbytes() { - std::string* _s = _internal_mutable_paddingbytes(); - // @@protoc_insertion_point(field_mutable:proto.MessageContextInfo.paddingBytes) - return _s; -} -inline const std::string& MessageContextInfo::_internal_paddingbytes() const { - return _impl_.paddingbytes_.Get(); -} -inline void MessageContextInfo::_internal_set_paddingbytes(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.paddingbytes_.Set(value, GetArenaForAllocation()); -} -inline std::string* MessageContextInfo::_internal_mutable_paddingbytes() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.paddingbytes_.Mutable(GetArenaForAllocation()); -} -inline std::string* MessageContextInfo::release_paddingbytes() { - // @@protoc_insertion_point(field_release:proto.MessageContextInfo.paddingBytes) - if (!_internal_has_paddingbytes()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.paddingbytes_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.paddingbytes_.IsDefault()) { - _impl_.paddingbytes_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void MessageContextInfo::set_allocated_paddingbytes(std::string* paddingbytes) { - if (paddingbytes != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.paddingbytes_.SetAllocated(paddingbytes, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.paddingbytes_.IsDefault()) { - _impl_.paddingbytes_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.MessageContextInfo.paddingBytes) -} - -// ------------------------------------------------------------------- - -// MessageKey - -// optional string remoteJid = 1; -inline bool MessageKey::_internal_has_remotejid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool MessageKey::has_remotejid() const { - return _internal_has_remotejid(); -} -inline void MessageKey::clear_remotejid() { - _impl_.remotejid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& MessageKey::remotejid() const { - // @@protoc_insertion_point(field_get:proto.MessageKey.remoteJid) - return _internal_remotejid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void MessageKey::set_remotejid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.remotejid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.MessageKey.remoteJid) -} -inline std::string* MessageKey::mutable_remotejid() { - std::string* _s = _internal_mutable_remotejid(); - // @@protoc_insertion_point(field_mutable:proto.MessageKey.remoteJid) - return _s; -} -inline const std::string& MessageKey::_internal_remotejid() const { - return _impl_.remotejid_.Get(); -} -inline void MessageKey::_internal_set_remotejid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.remotejid_.Set(value, GetArenaForAllocation()); -} -inline std::string* MessageKey::_internal_mutable_remotejid() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.remotejid_.Mutable(GetArenaForAllocation()); -} -inline std::string* MessageKey::release_remotejid() { - // @@protoc_insertion_point(field_release:proto.MessageKey.remoteJid) - if (!_internal_has_remotejid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.remotejid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.remotejid_.IsDefault()) { - _impl_.remotejid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void MessageKey::set_allocated_remotejid(std::string* remotejid) { - if (remotejid != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.remotejid_.SetAllocated(remotejid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.remotejid_.IsDefault()) { - _impl_.remotejid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.MessageKey.remoteJid) -} - -// optional bool fromMe = 2; -inline bool MessageKey::_internal_has_fromme() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool MessageKey::has_fromme() const { - return _internal_has_fromme(); -} -inline void MessageKey::clear_fromme() { - _impl_.fromme_ = false; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline bool MessageKey::_internal_fromme() const { - return _impl_.fromme_; -} -inline bool MessageKey::fromme() const { - // @@protoc_insertion_point(field_get:proto.MessageKey.fromMe) - return _internal_fromme(); -} -inline void MessageKey::_internal_set_fromme(bool value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.fromme_ = value; -} -inline void MessageKey::set_fromme(bool value) { - _internal_set_fromme(value); - // @@protoc_insertion_point(field_set:proto.MessageKey.fromMe) -} - -// optional string id = 3; -inline bool MessageKey::_internal_has_id() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool MessageKey::has_id() const { - return _internal_has_id(); -} -inline void MessageKey::clear_id() { - _impl_.id_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& MessageKey::id() const { - // @@protoc_insertion_point(field_get:proto.MessageKey.id) - return _internal_id(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void MessageKey::set_id(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.id_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.MessageKey.id) -} -inline std::string* MessageKey::mutable_id() { - std::string* _s = _internal_mutable_id(); - // @@protoc_insertion_point(field_mutable:proto.MessageKey.id) - return _s; -} -inline const std::string& MessageKey::_internal_id() const { - return _impl_.id_.Get(); -} -inline void MessageKey::_internal_set_id(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.id_.Set(value, GetArenaForAllocation()); -} -inline std::string* MessageKey::_internal_mutable_id() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.id_.Mutable(GetArenaForAllocation()); -} -inline std::string* MessageKey::release_id() { - // @@protoc_insertion_point(field_release:proto.MessageKey.id) - if (!_internal_has_id()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.id_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.id_.IsDefault()) { - _impl_.id_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void MessageKey::set_allocated_id(std::string* id) { - if (id != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.id_.SetAllocated(id, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.id_.IsDefault()) { - _impl_.id_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.MessageKey.id) -} - -// optional string participant = 4; -inline bool MessageKey::_internal_has_participant() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool MessageKey::has_participant() const { - return _internal_has_participant(); -} -inline void MessageKey::clear_participant() { - _impl_.participant_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& MessageKey::participant() const { - // @@protoc_insertion_point(field_get:proto.MessageKey.participant) - return _internal_participant(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void MessageKey::set_participant(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.participant_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.MessageKey.participant) -} -inline std::string* MessageKey::mutable_participant() { - std::string* _s = _internal_mutable_participant(); - // @@protoc_insertion_point(field_mutable:proto.MessageKey.participant) - return _s; -} -inline const std::string& MessageKey::_internal_participant() const { - return _impl_.participant_.Get(); -} -inline void MessageKey::_internal_set_participant(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.participant_.Set(value, GetArenaForAllocation()); -} -inline std::string* MessageKey::_internal_mutable_participant() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.participant_.Mutable(GetArenaForAllocation()); -} -inline std::string* MessageKey::release_participant() { - // @@protoc_insertion_point(field_release:proto.MessageKey.participant) - if (!_internal_has_participant()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.participant_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.participant_.IsDefault()) { - _impl_.participant_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void MessageKey::set_allocated_participant(std::string* participant) { - if (participant != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.participant_.SetAllocated(participant, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.participant_.IsDefault()) { - _impl_.participant_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.MessageKey.participant) -} - -// ------------------------------------------------------------------- - -// Money - -// optional int64 value = 1; -inline bool Money::_internal_has_value() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Money::has_value() const { - return _internal_has_value(); -} -inline void Money::clear_value() { - _impl_.value_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline int64_t Money::_internal_value() const { - return _impl_.value_; -} -inline int64_t Money::value() const { - // @@protoc_insertion_point(field_get:proto.Money.value) - return _internal_value(); -} -inline void Money::_internal_set_value(int64_t value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.value_ = value; -} -inline void Money::set_value(int64_t value) { - _internal_set_value(value); - // @@protoc_insertion_point(field_set:proto.Money.value) -} - -// optional uint32 offset = 2; -inline bool Money::_internal_has_offset() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool Money::has_offset() const { - return _internal_has_offset(); -} -inline void Money::clear_offset() { - _impl_.offset_ = 0u; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline uint32_t Money::_internal_offset() const { - return _impl_.offset_; -} -inline uint32_t Money::offset() const { - // @@protoc_insertion_point(field_get:proto.Money.offset) - return _internal_offset(); -} -inline void Money::_internal_set_offset(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.offset_ = value; -} -inline void Money::set_offset(uint32_t value) { - _internal_set_offset(value); - // @@protoc_insertion_point(field_set:proto.Money.offset) -} - -// optional string currencyCode = 3; -inline bool Money::_internal_has_currencycode() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Money::has_currencycode() const { - return _internal_has_currencycode(); -} -inline void Money::clear_currencycode() { - _impl_.currencycode_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Money::currencycode() const { - // @@protoc_insertion_point(field_get:proto.Money.currencyCode) - return _internal_currencycode(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Money::set_currencycode(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.currencycode_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Money.currencyCode) -} -inline std::string* Money::mutable_currencycode() { - std::string* _s = _internal_mutable_currencycode(); - // @@protoc_insertion_point(field_mutable:proto.Money.currencyCode) - return _s; -} -inline const std::string& Money::_internal_currencycode() const { - return _impl_.currencycode_.Get(); -} -inline void Money::_internal_set_currencycode(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.currencycode_.Set(value, GetArenaForAllocation()); -} -inline std::string* Money::_internal_mutable_currencycode() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.currencycode_.Mutable(GetArenaForAllocation()); -} -inline std::string* Money::release_currencycode() { - // @@protoc_insertion_point(field_release:proto.Money.currencyCode) - if (!_internal_has_currencycode()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.currencycode_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.currencycode_.IsDefault()) { - _impl_.currencycode_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Money::set_allocated_currencycode(std::string* currencycode) { - if (currencycode != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.currencycode_.SetAllocated(currencycode, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.currencycode_.IsDefault()) { - _impl_.currencycode_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Money.currencyCode) -} - -// ------------------------------------------------------------------- - -// MsgOpaqueData_PollOption - -// optional string name = 1; -inline bool MsgOpaqueData_PollOption::_internal_has_name() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool MsgOpaqueData_PollOption::has_name() const { - return _internal_has_name(); -} -inline void MsgOpaqueData_PollOption::clear_name() { - _impl_.name_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& MsgOpaqueData_PollOption::name() const { - // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.PollOption.name) - return _internal_name(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void MsgOpaqueData_PollOption::set_name(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.PollOption.name) -} -inline std::string* MsgOpaqueData_PollOption::mutable_name() { - std::string* _s = _internal_mutable_name(); - // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.PollOption.name) - return _s; -} -inline const std::string& MsgOpaqueData_PollOption::_internal_name() const { - return _impl_.name_.Get(); -} -inline void MsgOpaqueData_PollOption::_internal_set_name(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.name_.Set(value, GetArenaForAllocation()); -} -inline std::string* MsgOpaqueData_PollOption::_internal_mutable_name() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.name_.Mutable(GetArenaForAllocation()); -} -inline std::string* MsgOpaqueData_PollOption::release_name() { - // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.PollOption.name) - if (!_internal_has_name()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.name_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.name_.IsDefault()) { - _impl_.name_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void MsgOpaqueData_PollOption::set_allocated_name(std::string* name) { - if (name != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.name_.SetAllocated(name, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.name_.IsDefault()) { - _impl_.name_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.PollOption.name) -} - -// ------------------------------------------------------------------- - -// MsgOpaqueData - -// optional string body = 1; -inline bool MsgOpaqueData::_internal_has_body() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool MsgOpaqueData::has_body() const { - return _internal_has_body(); -} -inline void MsgOpaqueData::clear_body() { - _impl_.body_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& MsgOpaqueData::body() const { - // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.body) - return _internal_body(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void MsgOpaqueData::set_body(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.body_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.body) -} -inline std::string* MsgOpaqueData::mutable_body() { - std::string* _s = _internal_mutable_body(); - // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.body) - return _s; -} -inline const std::string& MsgOpaqueData::_internal_body() const { - return _impl_.body_.Get(); -} -inline void MsgOpaqueData::_internal_set_body(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.body_.Set(value, GetArenaForAllocation()); -} -inline std::string* MsgOpaqueData::_internal_mutable_body() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.body_.Mutable(GetArenaForAllocation()); -} -inline std::string* MsgOpaqueData::release_body() { - // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.body) - if (!_internal_has_body()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.body_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.body_.IsDefault()) { - _impl_.body_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void MsgOpaqueData::set_allocated_body(std::string* body) { - if (body != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.body_.SetAllocated(body, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.body_.IsDefault()) { - _impl_.body_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.body) -} - -// optional string caption = 3; -inline bool MsgOpaqueData::_internal_has_caption() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool MsgOpaqueData::has_caption() const { - return _internal_has_caption(); -} -inline void MsgOpaqueData::clear_caption() { - _impl_.caption_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& MsgOpaqueData::caption() const { - // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.caption) - return _internal_caption(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void MsgOpaqueData::set_caption(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.caption_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.caption) -} -inline std::string* MsgOpaqueData::mutable_caption() { - std::string* _s = _internal_mutable_caption(); - // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.caption) - return _s; -} -inline const std::string& MsgOpaqueData::_internal_caption() const { - return _impl_.caption_.Get(); -} -inline void MsgOpaqueData::_internal_set_caption(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.caption_.Set(value, GetArenaForAllocation()); -} -inline std::string* MsgOpaqueData::_internal_mutable_caption() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.caption_.Mutable(GetArenaForAllocation()); -} -inline std::string* MsgOpaqueData::release_caption() { - // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.caption) - if (!_internal_has_caption()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.caption_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.caption_.IsDefault()) { - _impl_.caption_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void MsgOpaqueData::set_allocated_caption(std::string* caption) { - if (caption != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.caption_.SetAllocated(caption, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.caption_.IsDefault()) { - _impl_.caption_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.caption) -} - -// optional double lng = 5; -inline bool MsgOpaqueData::_internal_has_lng() const { - bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0; - return value; -} -inline bool MsgOpaqueData::has_lng() const { - return _internal_has_lng(); -} -inline void MsgOpaqueData::clear_lng() { - _impl_.lng_ = 0; - _impl_._has_bits_[0] &= ~0x00004000u; -} -inline double MsgOpaqueData::_internal_lng() const { - return _impl_.lng_; -} -inline double MsgOpaqueData::lng() const { - // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.lng) - return _internal_lng(); -} -inline void MsgOpaqueData::_internal_set_lng(double value) { - _impl_._has_bits_[0] |= 0x00004000u; - _impl_.lng_ = value; -} -inline void MsgOpaqueData::set_lng(double value) { - _internal_set_lng(value); - // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.lng) -} - -// optional bool isLive = 6; -inline bool MsgOpaqueData::_internal_has_islive() const { - bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0; - return value; -} -inline bool MsgOpaqueData::has_islive() const { - return _internal_has_islive(); -} -inline void MsgOpaqueData::clear_islive() { - _impl_.islive_ = false; - _impl_._has_bits_[0] &= ~0x00010000u; -} -inline bool MsgOpaqueData::_internal_islive() const { - return _impl_.islive_; -} -inline bool MsgOpaqueData::islive() const { - // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.isLive) - return _internal_islive(); -} -inline void MsgOpaqueData::_internal_set_islive(bool value) { - _impl_._has_bits_[0] |= 0x00010000u; - _impl_.islive_ = value; -} -inline void MsgOpaqueData::set_islive(bool value) { - _internal_set_islive(value); - // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.isLive) -} - -// optional double lat = 7; -inline bool MsgOpaqueData::_internal_has_lat() const { - bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0; - return value; -} -inline bool MsgOpaqueData::has_lat() const { - return _internal_has_lat(); -} -inline void MsgOpaqueData::clear_lat() { - _impl_.lat_ = 0; - _impl_._has_bits_[0] &= ~0x00008000u; -} -inline double MsgOpaqueData::_internal_lat() const { - return _impl_.lat_; -} -inline double MsgOpaqueData::lat() const { - // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.lat) - return _internal_lat(); -} -inline void MsgOpaqueData::_internal_set_lat(double value) { - _impl_._has_bits_[0] |= 0x00008000u; - _impl_.lat_ = value; -} -inline void MsgOpaqueData::set_lat(double value) { - _internal_set_lat(value); - // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.lat) -} - -// optional int32 paymentAmount1000 = 8; -inline bool MsgOpaqueData::_internal_has_paymentamount1000() const { - bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0; - return value; -} -inline bool MsgOpaqueData::has_paymentamount1000() const { - return _internal_has_paymentamount1000(); -} -inline void MsgOpaqueData::clear_paymentamount1000() { - _impl_.paymentamount1000_ = 0; - _impl_._has_bits_[0] &= ~0x00020000u; -} -inline int32_t MsgOpaqueData::_internal_paymentamount1000() const { - return _impl_.paymentamount1000_; -} -inline int32_t MsgOpaqueData::paymentamount1000() const { - // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.paymentAmount1000) - return _internal_paymentamount1000(); -} -inline void MsgOpaqueData::_internal_set_paymentamount1000(int32_t value) { - _impl_._has_bits_[0] |= 0x00020000u; - _impl_.paymentamount1000_ = value; -} -inline void MsgOpaqueData::set_paymentamount1000(int32_t value) { - _internal_set_paymentamount1000(value); - // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.paymentAmount1000) -} - -// optional string paymentNoteMsgBody = 9; -inline bool MsgOpaqueData::_internal_has_paymentnotemsgbody() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool MsgOpaqueData::has_paymentnotemsgbody() const { - return _internal_has_paymentnotemsgbody(); -} -inline void MsgOpaqueData::clear_paymentnotemsgbody() { - _impl_.paymentnotemsgbody_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& MsgOpaqueData::paymentnotemsgbody() const { - // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.paymentNoteMsgBody) - return _internal_paymentnotemsgbody(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void MsgOpaqueData::set_paymentnotemsgbody(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.paymentnotemsgbody_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.paymentNoteMsgBody) -} -inline std::string* MsgOpaqueData::mutable_paymentnotemsgbody() { - std::string* _s = _internal_mutable_paymentnotemsgbody(); - // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.paymentNoteMsgBody) - return _s; -} -inline const std::string& MsgOpaqueData::_internal_paymentnotemsgbody() const { - return _impl_.paymentnotemsgbody_.Get(); -} -inline void MsgOpaqueData::_internal_set_paymentnotemsgbody(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.paymentnotemsgbody_.Set(value, GetArenaForAllocation()); -} -inline std::string* MsgOpaqueData::_internal_mutable_paymentnotemsgbody() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.paymentnotemsgbody_.Mutable(GetArenaForAllocation()); -} -inline std::string* MsgOpaqueData::release_paymentnotemsgbody() { - // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.paymentNoteMsgBody) - if (!_internal_has_paymentnotemsgbody()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.paymentnotemsgbody_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.paymentnotemsgbody_.IsDefault()) { - _impl_.paymentnotemsgbody_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void MsgOpaqueData::set_allocated_paymentnotemsgbody(std::string* paymentnotemsgbody) { - if (paymentnotemsgbody != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.paymentnotemsgbody_.SetAllocated(paymentnotemsgbody, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.paymentnotemsgbody_.IsDefault()) { - _impl_.paymentnotemsgbody_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.paymentNoteMsgBody) -} - -// optional string canonicalUrl = 10; -inline bool MsgOpaqueData::_internal_has_canonicalurl() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool MsgOpaqueData::has_canonicalurl() const { - return _internal_has_canonicalurl(); -} -inline void MsgOpaqueData::clear_canonicalurl() { - _impl_.canonicalurl_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const std::string& MsgOpaqueData::canonicalurl() const { - // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.canonicalUrl) - return _internal_canonicalurl(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void MsgOpaqueData::set_canonicalurl(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.canonicalurl_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.canonicalUrl) -} -inline std::string* MsgOpaqueData::mutable_canonicalurl() { - std::string* _s = _internal_mutable_canonicalurl(); - // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.canonicalUrl) - return _s; -} -inline const std::string& MsgOpaqueData::_internal_canonicalurl() const { - return _impl_.canonicalurl_.Get(); -} -inline void MsgOpaqueData::_internal_set_canonicalurl(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.canonicalurl_.Set(value, GetArenaForAllocation()); -} -inline std::string* MsgOpaqueData::_internal_mutable_canonicalurl() { - _impl_._has_bits_[0] |= 0x00000008u; - return _impl_.canonicalurl_.Mutable(GetArenaForAllocation()); -} -inline std::string* MsgOpaqueData::release_canonicalurl() { - // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.canonicalUrl) - if (!_internal_has_canonicalurl()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000008u; - auto* p = _impl_.canonicalurl_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.canonicalurl_.IsDefault()) { - _impl_.canonicalurl_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void MsgOpaqueData::set_allocated_canonicalurl(std::string* canonicalurl) { - if (canonicalurl != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.canonicalurl_.SetAllocated(canonicalurl, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.canonicalurl_.IsDefault()) { - _impl_.canonicalurl_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.canonicalUrl) -} - -// optional string matchedText = 11; -inline bool MsgOpaqueData::_internal_has_matchedtext() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool MsgOpaqueData::has_matchedtext() const { - return _internal_has_matchedtext(); -} -inline void MsgOpaqueData::clear_matchedtext() { - _impl_.matchedtext_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const std::string& MsgOpaqueData::matchedtext() const { - // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.matchedText) - return _internal_matchedtext(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void MsgOpaqueData::set_matchedtext(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.matchedtext_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.matchedText) -} -inline std::string* MsgOpaqueData::mutable_matchedtext() { - std::string* _s = _internal_mutable_matchedtext(); - // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.matchedText) - return _s; -} -inline const std::string& MsgOpaqueData::_internal_matchedtext() const { - return _impl_.matchedtext_.Get(); -} -inline void MsgOpaqueData::_internal_set_matchedtext(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.matchedtext_.Set(value, GetArenaForAllocation()); -} -inline std::string* MsgOpaqueData::_internal_mutable_matchedtext() { - _impl_._has_bits_[0] |= 0x00000010u; - return _impl_.matchedtext_.Mutable(GetArenaForAllocation()); -} -inline std::string* MsgOpaqueData::release_matchedtext() { - // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.matchedText) - if (!_internal_has_matchedtext()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000010u; - auto* p = _impl_.matchedtext_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.matchedtext_.IsDefault()) { - _impl_.matchedtext_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void MsgOpaqueData::set_allocated_matchedtext(std::string* matchedtext) { - if (matchedtext != nullptr) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.matchedtext_.SetAllocated(matchedtext, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.matchedtext_.IsDefault()) { - _impl_.matchedtext_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.matchedText) -} - -// optional string title = 12; -inline bool MsgOpaqueData::_internal_has_title() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool MsgOpaqueData::has_title() const { - return _internal_has_title(); -} -inline void MsgOpaqueData::clear_title() { - _impl_.title_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline const std::string& MsgOpaqueData::title() const { - // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.title) - return _internal_title(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void MsgOpaqueData::set_title(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.title_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.title) -} -inline std::string* MsgOpaqueData::mutable_title() { - std::string* _s = _internal_mutable_title(); - // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.title) - return _s; -} -inline const std::string& MsgOpaqueData::_internal_title() const { - return _impl_.title_.Get(); -} -inline void MsgOpaqueData::_internal_set_title(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.title_.Set(value, GetArenaForAllocation()); -} -inline std::string* MsgOpaqueData::_internal_mutable_title() { - _impl_._has_bits_[0] |= 0x00000020u; - return _impl_.title_.Mutable(GetArenaForAllocation()); -} -inline std::string* MsgOpaqueData::release_title() { - // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.title) - if (!_internal_has_title()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000020u; - auto* p = _impl_.title_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.title_.IsDefault()) { - _impl_.title_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void MsgOpaqueData::set_allocated_title(std::string* title) { - if (title != nullptr) { - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - _impl_.title_.SetAllocated(title, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.title_.IsDefault()) { - _impl_.title_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.title) -} - -// optional string description = 13; -inline bool MsgOpaqueData::_internal_has_description() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool MsgOpaqueData::has_description() const { - return _internal_has_description(); -} -inline void MsgOpaqueData::clear_description() { - _impl_.description_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline const std::string& MsgOpaqueData::description() const { - // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.description) - return _internal_description(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void MsgOpaqueData::set_description(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.description_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.description) -} -inline std::string* MsgOpaqueData::mutable_description() { - std::string* _s = _internal_mutable_description(); - // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.description) - return _s; -} -inline const std::string& MsgOpaqueData::_internal_description() const { - return _impl_.description_.Get(); -} -inline void MsgOpaqueData::_internal_set_description(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.description_.Set(value, GetArenaForAllocation()); -} -inline std::string* MsgOpaqueData::_internal_mutable_description() { - _impl_._has_bits_[0] |= 0x00000040u; - return _impl_.description_.Mutable(GetArenaForAllocation()); -} -inline std::string* MsgOpaqueData::release_description() { - // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.description) - if (!_internal_has_description()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000040u; - auto* p = _impl_.description_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.description_.IsDefault()) { - _impl_.description_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void MsgOpaqueData::set_allocated_description(std::string* description) { - if (description != nullptr) { - _impl_._has_bits_[0] |= 0x00000040u; - } else { - _impl_._has_bits_[0] &= ~0x00000040u; - } - _impl_.description_.SetAllocated(description, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.description_.IsDefault()) { - _impl_.description_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.description) -} - -// optional bytes futureproofBuffer = 14; -inline bool MsgOpaqueData::_internal_has_futureproofbuffer() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - return value; -} -inline bool MsgOpaqueData::has_futureproofbuffer() const { - return _internal_has_futureproofbuffer(); -} -inline void MsgOpaqueData::clear_futureproofbuffer() { - _impl_.futureproofbuffer_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline const std::string& MsgOpaqueData::futureproofbuffer() const { - // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.futureproofBuffer) - return _internal_futureproofbuffer(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void MsgOpaqueData::set_futureproofbuffer(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.futureproofbuffer_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.futureproofBuffer) -} -inline std::string* MsgOpaqueData::mutable_futureproofbuffer() { - std::string* _s = _internal_mutable_futureproofbuffer(); - // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.futureproofBuffer) - return _s; -} -inline const std::string& MsgOpaqueData::_internal_futureproofbuffer() const { - return _impl_.futureproofbuffer_.Get(); -} -inline void MsgOpaqueData::_internal_set_futureproofbuffer(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.futureproofbuffer_.Set(value, GetArenaForAllocation()); -} -inline std::string* MsgOpaqueData::_internal_mutable_futureproofbuffer() { - _impl_._has_bits_[0] |= 0x00000080u; - return _impl_.futureproofbuffer_.Mutable(GetArenaForAllocation()); -} -inline std::string* MsgOpaqueData::release_futureproofbuffer() { - // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.futureproofBuffer) - if (!_internal_has_futureproofbuffer()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000080u; - auto* p = _impl_.futureproofbuffer_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.futureproofbuffer_.IsDefault()) { - _impl_.futureproofbuffer_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void MsgOpaqueData::set_allocated_futureproofbuffer(std::string* futureproofbuffer) { - if (futureproofbuffer != nullptr) { - _impl_._has_bits_[0] |= 0x00000080u; - } else { - _impl_._has_bits_[0] &= ~0x00000080u; - } - _impl_.futureproofbuffer_.SetAllocated(futureproofbuffer, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.futureproofbuffer_.IsDefault()) { - _impl_.futureproofbuffer_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.futureproofBuffer) -} - -// optional string clientUrl = 15; -inline bool MsgOpaqueData::_internal_has_clienturl() const { - bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; - return value; -} -inline bool MsgOpaqueData::has_clienturl() const { - return _internal_has_clienturl(); -} -inline void MsgOpaqueData::clear_clienturl() { - _impl_.clienturl_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000100u; -} -inline const std::string& MsgOpaqueData::clienturl() const { - // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.clientUrl) - return _internal_clienturl(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void MsgOpaqueData::set_clienturl(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000100u; - _impl_.clienturl_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.clientUrl) -} -inline std::string* MsgOpaqueData::mutable_clienturl() { - std::string* _s = _internal_mutable_clienturl(); - // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.clientUrl) - return _s; -} -inline const std::string& MsgOpaqueData::_internal_clienturl() const { - return _impl_.clienturl_.Get(); -} -inline void MsgOpaqueData::_internal_set_clienturl(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000100u; - _impl_.clienturl_.Set(value, GetArenaForAllocation()); -} -inline std::string* MsgOpaqueData::_internal_mutable_clienturl() { - _impl_._has_bits_[0] |= 0x00000100u; - return _impl_.clienturl_.Mutable(GetArenaForAllocation()); -} -inline std::string* MsgOpaqueData::release_clienturl() { - // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.clientUrl) - if (!_internal_has_clienturl()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000100u; - auto* p = _impl_.clienturl_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.clienturl_.IsDefault()) { - _impl_.clienturl_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void MsgOpaqueData::set_allocated_clienturl(std::string* clienturl) { - if (clienturl != nullptr) { - _impl_._has_bits_[0] |= 0x00000100u; - } else { - _impl_._has_bits_[0] &= ~0x00000100u; - } - _impl_.clienturl_.SetAllocated(clienturl, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.clienturl_.IsDefault()) { - _impl_.clienturl_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.clientUrl) -} - -// optional string loc = 16; -inline bool MsgOpaqueData::_internal_has_loc() const { - bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; - return value; -} -inline bool MsgOpaqueData::has_loc() const { - return _internal_has_loc(); -} -inline void MsgOpaqueData::clear_loc() { - _impl_.loc_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000200u; -} -inline const std::string& MsgOpaqueData::loc() const { - // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.loc) - return _internal_loc(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void MsgOpaqueData::set_loc(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.loc_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.loc) -} -inline std::string* MsgOpaqueData::mutable_loc() { - std::string* _s = _internal_mutable_loc(); - // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.loc) - return _s; -} -inline const std::string& MsgOpaqueData::_internal_loc() const { - return _impl_.loc_.Get(); -} -inline void MsgOpaqueData::_internal_set_loc(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.loc_.Set(value, GetArenaForAllocation()); -} -inline std::string* MsgOpaqueData::_internal_mutable_loc() { - _impl_._has_bits_[0] |= 0x00000200u; - return _impl_.loc_.Mutable(GetArenaForAllocation()); -} -inline std::string* MsgOpaqueData::release_loc() { - // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.loc) - if (!_internal_has_loc()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000200u; - auto* p = _impl_.loc_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.loc_.IsDefault()) { - _impl_.loc_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void MsgOpaqueData::set_allocated_loc(std::string* loc) { - if (loc != nullptr) { - _impl_._has_bits_[0] |= 0x00000200u; - } else { - _impl_._has_bits_[0] &= ~0x00000200u; - } - _impl_.loc_.SetAllocated(loc, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.loc_.IsDefault()) { - _impl_.loc_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.loc) -} - -// optional string pollName = 17; -inline bool MsgOpaqueData::_internal_has_pollname() const { - bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; - return value; -} -inline bool MsgOpaqueData::has_pollname() const { - return _internal_has_pollname(); -} -inline void MsgOpaqueData::clear_pollname() { - _impl_.pollname_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000400u; -} -inline const std::string& MsgOpaqueData::pollname() const { - // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.pollName) - return _internal_pollname(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void MsgOpaqueData::set_pollname(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000400u; - _impl_.pollname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.pollName) -} -inline std::string* MsgOpaqueData::mutable_pollname() { - std::string* _s = _internal_mutable_pollname(); - // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.pollName) - return _s; -} -inline const std::string& MsgOpaqueData::_internal_pollname() const { - return _impl_.pollname_.Get(); -} -inline void MsgOpaqueData::_internal_set_pollname(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000400u; - _impl_.pollname_.Set(value, GetArenaForAllocation()); -} -inline std::string* MsgOpaqueData::_internal_mutable_pollname() { - _impl_._has_bits_[0] |= 0x00000400u; - return _impl_.pollname_.Mutable(GetArenaForAllocation()); -} -inline std::string* MsgOpaqueData::release_pollname() { - // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.pollName) - if (!_internal_has_pollname()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000400u; - auto* p = _impl_.pollname_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.pollname_.IsDefault()) { - _impl_.pollname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void MsgOpaqueData::set_allocated_pollname(std::string* pollname) { - if (pollname != nullptr) { - _impl_._has_bits_[0] |= 0x00000400u; - } else { - _impl_._has_bits_[0] &= ~0x00000400u; - } - _impl_.pollname_.SetAllocated(pollname, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.pollname_.IsDefault()) { - _impl_.pollname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.pollName) -} - -// repeated .proto.MsgOpaqueData.PollOption pollOptions = 18; -inline int MsgOpaqueData::_internal_polloptions_size() const { - return _impl_.polloptions_.size(); -} -inline int MsgOpaqueData::polloptions_size() const { - return _internal_polloptions_size(); -} -inline void MsgOpaqueData::clear_polloptions() { - _impl_.polloptions_.Clear(); -} -inline ::proto::MsgOpaqueData_PollOption* MsgOpaqueData::mutable_polloptions(int index) { - // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.pollOptions) - return _impl_.polloptions_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MsgOpaqueData_PollOption >* -MsgOpaqueData::mutable_polloptions() { - // @@protoc_insertion_point(field_mutable_list:proto.MsgOpaqueData.pollOptions) - return &_impl_.polloptions_; -} -inline const ::proto::MsgOpaqueData_PollOption& MsgOpaqueData::_internal_polloptions(int index) const { - return _impl_.polloptions_.Get(index); -} -inline const ::proto::MsgOpaqueData_PollOption& MsgOpaqueData::polloptions(int index) const { - // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.pollOptions) - return _internal_polloptions(index); -} -inline ::proto::MsgOpaqueData_PollOption* MsgOpaqueData::_internal_add_polloptions() { - return _impl_.polloptions_.Add(); -} -inline ::proto::MsgOpaqueData_PollOption* MsgOpaqueData::add_polloptions() { - ::proto::MsgOpaqueData_PollOption* _add = _internal_add_polloptions(); - // @@protoc_insertion_point(field_add:proto.MsgOpaqueData.pollOptions) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MsgOpaqueData_PollOption >& -MsgOpaqueData::polloptions() const { - // @@protoc_insertion_point(field_list:proto.MsgOpaqueData.pollOptions) - return _impl_.polloptions_; -} - -// optional uint32 pollSelectableOptionsCount = 20; -inline bool MsgOpaqueData::_internal_has_pollselectableoptionscount() const { - bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0; - return value; -} -inline bool MsgOpaqueData::has_pollselectableoptionscount() const { - return _internal_has_pollselectableoptionscount(); -} -inline void MsgOpaqueData::clear_pollselectableoptionscount() { - _impl_.pollselectableoptionscount_ = 0u; - _impl_._has_bits_[0] &= ~0x00080000u; -} -inline uint32_t MsgOpaqueData::_internal_pollselectableoptionscount() const { - return _impl_.pollselectableoptionscount_; -} -inline uint32_t MsgOpaqueData::pollselectableoptionscount() const { - // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.pollSelectableOptionsCount) - return _internal_pollselectableoptionscount(); -} -inline void MsgOpaqueData::_internal_set_pollselectableoptionscount(uint32_t value) { - _impl_._has_bits_[0] |= 0x00080000u; - _impl_.pollselectableoptionscount_ = value; -} -inline void MsgOpaqueData::set_pollselectableoptionscount(uint32_t value) { - _internal_set_pollselectableoptionscount(value); - // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.pollSelectableOptionsCount) -} - -// optional bytes messageSecret = 21; -inline bool MsgOpaqueData::_internal_has_messagesecret() const { - bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; - return value; -} -inline bool MsgOpaqueData::has_messagesecret() const { - return _internal_has_messagesecret(); -} -inline void MsgOpaqueData::clear_messagesecret() { - _impl_.messagesecret_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000800u; -} -inline const std::string& MsgOpaqueData::messagesecret() const { - // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.messageSecret) - return _internal_messagesecret(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void MsgOpaqueData::set_messagesecret(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000800u; - _impl_.messagesecret_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.messageSecret) -} -inline std::string* MsgOpaqueData::mutable_messagesecret() { - std::string* _s = _internal_mutable_messagesecret(); - // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.messageSecret) - return _s; -} -inline const std::string& MsgOpaqueData::_internal_messagesecret() const { - return _impl_.messagesecret_.Get(); -} -inline void MsgOpaqueData::_internal_set_messagesecret(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000800u; - _impl_.messagesecret_.Set(value, GetArenaForAllocation()); -} -inline std::string* MsgOpaqueData::_internal_mutable_messagesecret() { - _impl_._has_bits_[0] |= 0x00000800u; - return _impl_.messagesecret_.Mutable(GetArenaForAllocation()); -} -inline std::string* MsgOpaqueData::release_messagesecret() { - // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.messageSecret) - if (!_internal_has_messagesecret()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000800u; - auto* p = _impl_.messagesecret_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.messagesecret_.IsDefault()) { - _impl_.messagesecret_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void MsgOpaqueData::set_allocated_messagesecret(std::string* messagesecret) { - if (messagesecret != nullptr) { - _impl_._has_bits_[0] |= 0x00000800u; - } else { - _impl_._has_bits_[0] &= ~0x00000800u; - } - _impl_.messagesecret_.SetAllocated(messagesecret, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.messagesecret_.IsDefault()) { - _impl_.messagesecret_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.messageSecret) -} - -// optional int64 senderTimestampMs = 22; -inline bool MsgOpaqueData::_internal_has_sendertimestampms() const { - bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0; - return value; -} -inline bool MsgOpaqueData::has_sendertimestampms() const { - return _internal_has_sendertimestampms(); -} -inline void MsgOpaqueData::clear_sendertimestampms() { - _impl_.sendertimestampms_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00040000u; -} -inline int64_t MsgOpaqueData::_internal_sendertimestampms() const { - return _impl_.sendertimestampms_; -} -inline int64_t MsgOpaqueData::sendertimestampms() const { - // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.senderTimestampMs) - return _internal_sendertimestampms(); -} -inline void MsgOpaqueData::_internal_set_sendertimestampms(int64_t value) { - _impl_._has_bits_[0] |= 0x00040000u; - _impl_.sendertimestampms_ = value; -} -inline void MsgOpaqueData::set_sendertimestampms(int64_t value) { - _internal_set_sendertimestampms(value); - // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.senderTimestampMs) -} - -// optional string pollUpdateParentKey = 23; -inline bool MsgOpaqueData::_internal_has_pollupdateparentkey() const { - bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; - return value; -} -inline bool MsgOpaqueData::has_pollupdateparentkey() const { - return _internal_has_pollupdateparentkey(); -} -inline void MsgOpaqueData::clear_pollupdateparentkey() { - _impl_.pollupdateparentkey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00001000u; -} -inline const std::string& MsgOpaqueData::pollupdateparentkey() const { - // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.pollUpdateParentKey) - return _internal_pollupdateparentkey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void MsgOpaqueData::set_pollupdateparentkey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00001000u; - _impl_.pollupdateparentkey_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.pollUpdateParentKey) -} -inline std::string* MsgOpaqueData::mutable_pollupdateparentkey() { - std::string* _s = _internal_mutable_pollupdateparentkey(); - // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.pollUpdateParentKey) - return _s; -} -inline const std::string& MsgOpaqueData::_internal_pollupdateparentkey() const { - return _impl_.pollupdateparentkey_.Get(); -} -inline void MsgOpaqueData::_internal_set_pollupdateparentkey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00001000u; - _impl_.pollupdateparentkey_.Set(value, GetArenaForAllocation()); -} -inline std::string* MsgOpaqueData::_internal_mutable_pollupdateparentkey() { - _impl_._has_bits_[0] |= 0x00001000u; - return _impl_.pollupdateparentkey_.Mutable(GetArenaForAllocation()); -} -inline std::string* MsgOpaqueData::release_pollupdateparentkey() { - // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.pollUpdateParentKey) - if (!_internal_has_pollupdateparentkey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00001000u; - auto* p = _impl_.pollupdateparentkey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.pollupdateparentkey_.IsDefault()) { - _impl_.pollupdateparentkey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void MsgOpaqueData::set_allocated_pollupdateparentkey(std::string* pollupdateparentkey) { - if (pollupdateparentkey != nullptr) { - _impl_._has_bits_[0] |= 0x00001000u; - } else { - _impl_._has_bits_[0] &= ~0x00001000u; - } - _impl_.pollupdateparentkey_.SetAllocated(pollupdateparentkey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.pollupdateparentkey_.IsDefault()) { - _impl_.pollupdateparentkey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.pollUpdateParentKey) -} - -// optional .proto.PollEncValue encPollVote = 24; -inline bool MsgOpaqueData::_internal_has_encpollvote() const { - bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.encpollvote_ != nullptr); - return value; -} -inline bool MsgOpaqueData::has_encpollvote() const { - return _internal_has_encpollvote(); -} -inline void MsgOpaqueData::clear_encpollvote() { - if (_impl_.encpollvote_ != nullptr) _impl_.encpollvote_->Clear(); - _impl_._has_bits_[0] &= ~0x00002000u; -} -inline const ::proto::PollEncValue& MsgOpaqueData::_internal_encpollvote() const { - const ::proto::PollEncValue* p = _impl_.encpollvote_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_PollEncValue_default_instance_); -} -inline const ::proto::PollEncValue& MsgOpaqueData::encpollvote() const { - // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.encPollVote) - return _internal_encpollvote(); -} -inline void MsgOpaqueData::unsafe_arena_set_allocated_encpollvote( - ::proto::PollEncValue* encpollvote) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.encpollvote_); - } - _impl_.encpollvote_ = encpollvote; - if (encpollvote) { - _impl_._has_bits_[0] |= 0x00002000u; - } else { - _impl_._has_bits_[0] &= ~0x00002000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.MsgOpaqueData.encPollVote) -} -inline ::proto::PollEncValue* MsgOpaqueData::release_encpollvote() { - _impl_._has_bits_[0] &= ~0x00002000u; - ::proto::PollEncValue* temp = _impl_.encpollvote_; - _impl_.encpollvote_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::PollEncValue* MsgOpaqueData::unsafe_arena_release_encpollvote() { - // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.encPollVote) - _impl_._has_bits_[0] &= ~0x00002000u; - ::proto::PollEncValue* temp = _impl_.encpollvote_; - _impl_.encpollvote_ = nullptr; - return temp; -} -inline ::proto::PollEncValue* MsgOpaqueData::_internal_mutable_encpollvote() { - _impl_._has_bits_[0] |= 0x00002000u; - if (_impl_.encpollvote_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::PollEncValue>(GetArenaForAllocation()); - _impl_.encpollvote_ = p; - } - return _impl_.encpollvote_; -} -inline ::proto::PollEncValue* MsgOpaqueData::mutable_encpollvote() { - ::proto::PollEncValue* _msg = _internal_mutable_encpollvote(); - // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.encPollVote) - return _msg; -} -inline void MsgOpaqueData::set_allocated_encpollvote(::proto::PollEncValue* encpollvote) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.encpollvote_; - } - if (encpollvote) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(encpollvote); - if (message_arena != submessage_arena) { - encpollvote = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, encpollvote, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00002000u; - } else { - _impl_._has_bits_[0] &= ~0x00002000u; - } - _impl_.encpollvote_ = encpollvote; - // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.encPollVote) -} - -// ------------------------------------------------------------------- - -// MsgRowOpaqueData - -// optional .proto.MsgOpaqueData currentMsg = 1; -inline bool MsgRowOpaqueData::_internal_has_currentmsg() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.currentmsg_ != nullptr); - return value; -} -inline bool MsgRowOpaqueData::has_currentmsg() const { - return _internal_has_currentmsg(); -} -inline void MsgRowOpaqueData::clear_currentmsg() { - if (_impl_.currentmsg_ != nullptr) _impl_.currentmsg_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::MsgOpaqueData& MsgRowOpaqueData::_internal_currentmsg() const { - const ::proto::MsgOpaqueData* p = _impl_.currentmsg_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_MsgOpaqueData_default_instance_); -} -inline const ::proto::MsgOpaqueData& MsgRowOpaqueData::currentmsg() const { - // @@protoc_insertion_point(field_get:proto.MsgRowOpaqueData.currentMsg) - return _internal_currentmsg(); -} -inline void MsgRowOpaqueData::unsafe_arena_set_allocated_currentmsg( - ::proto::MsgOpaqueData* currentmsg) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.currentmsg_); - } - _impl_.currentmsg_ = currentmsg; - if (currentmsg) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.MsgRowOpaqueData.currentMsg) -} -inline ::proto::MsgOpaqueData* MsgRowOpaqueData::release_currentmsg() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::MsgOpaqueData* temp = _impl_.currentmsg_; - _impl_.currentmsg_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::MsgOpaqueData* MsgRowOpaqueData::unsafe_arena_release_currentmsg() { - // @@protoc_insertion_point(field_release:proto.MsgRowOpaqueData.currentMsg) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::MsgOpaqueData* temp = _impl_.currentmsg_; - _impl_.currentmsg_ = nullptr; - return temp; -} -inline ::proto::MsgOpaqueData* MsgRowOpaqueData::_internal_mutable_currentmsg() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.currentmsg_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::MsgOpaqueData>(GetArenaForAllocation()); - _impl_.currentmsg_ = p; - } - return _impl_.currentmsg_; -} -inline ::proto::MsgOpaqueData* MsgRowOpaqueData::mutable_currentmsg() { - ::proto::MsgOpaqueData* _msg = _internal_mutable_currentmsg(); - // @@protoc_insertion_point(field_mutable:proto.MsgRowOpaqueData.currentMsg) - return _msg; -} -inline void MsgRowOpaqueData::set_allocated_currentmsg(::proto::MsgOpaqueData* currentmsg) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.currentmsg_; - } - if (currentmsg) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(currentmsg); - if (message_arena != submessage_arena) { - currentmsg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, currentmsg, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.currentmsg_ = currentmsg; - // @@protoc_insertion_point(field_set_allocated:proto.MsgRowOpaqueData.currentMsg) -} - -// optional .proto.MsgOpaqueData quotedMsg = 2; -inline bool MsgRowOpaqueData::_internal_has_quotedmsg() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.quotedmsg_ != nullptr); - return value; -} -inline bool MsgRowOpaqueData::has_quotedmsg() const { - return _internal_has_quotedmsg(); -} -inline void MsgRowOpaqueData::clear_quotedmsg() { - if (_impl_.quotedmsg_ != nullptr) _impl_.quotedmsg_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::MsgOpaqueData& MsgRowOpaqueData::_internal_quotedmsg() const { - const ::proto::MsgOpaqueData* p = _impl_.quotedmsg_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_MsgOpaqueData_default_instance_); -} -inline const ::proto::MsgOpaqueData& MsgRowOpaqueData::quotedmsg() const { - // @@protoc_insertion_point(field_get:proto.MsgRowOpaqueData.quotedMsg) - return _internal_quotedmsg(); -} -inline void MsgRowOpaqueData::unsafe_arena_set_allocated_quotedmsg( - ::proto::MsgOpaqueData* quotedmsg) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quotedmsg_); - } - _impl_.quotedmsg_ = quotedmsg; - if (quotedmsg) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.MsgRowOpaqueData.quotedMsg) -} -inline ::proto::MsgOpaqueData* MsgRowOpaqueData::release_quotedmsg() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::MsgOpaqueData* temp = _impl_.quotedmsg_; - _impl_.quotedmsg_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::MsgOpaqueData* MsgRowOpaqueData::unsafe_arena_release_quotedmsg() { - // @@protoc_insertion_point(field_release:proto.MsgRowOpaqueData.quotedMsg) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::MsgOpaqueData* temp = _impl_.quotedmsg_; - _impl_.quotedmsg_ = nullptr; - return temp; -} -inline ::proto::MsgOpaqueData* MsgRowOpaqueData::_internal_mutable_quotedmsg() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.quotedmsg_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::MsgOpaqueData>(GetArenaForAllocation()); - _impl_.quotedmsg_ = p; - } - return _impl_.quotedmsg_; -} -inline ::proto::MsgOpaqueData* MsgRowOpaqueData::mutable_quotedmsg() { - ::proto::MsgOpaqueData* _msg = _internal_mutable_quotedmsg(); - // @@protoc_insertion_point(field_mutable:proto.MsgRowOpaqueData.quotedMsg) - return _msg; -} -inline void MsgRowOpaqueData::set_allocated_quotedmsg(::proto::MsgOpaqueData* quotedmsg) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.quotedmsg_; - } - if (quotedmsg) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quotedmsg); - if (message_arena != submessage_arena) { - quotedmsg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, quotedmsg, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.quotedmsg_ = quotedmsg; - // @@protoc_insertion_point(field_set_allocated:proto.MsgRowOpaqueData.quotedMsg) -} - -// ------------------------------------------------------------------- - -// NoiseCertificate_Details - -// optional uint32 serial = 1; -inline bool NoiseCertificate_Details::_internal_has_serial() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool NoiseCertificate_Details::has_serial() const { - return _internal_has_serial(); -} -inline void NoiseCertificate_Details::clear_serial() { - _impl_.serial_ = 0u; - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline uint32_t NoiseCertificate_Details::_internal_serial() const { - return _impl_.serial_; -} -inline uint32_t NoiseCertificate_Details::serial() const { - // @@protoc_insertion_point(field_get:proto.NoiseCertificate.Details.serial) - return _internal_serial(); -} -inline void NoiseCertificate_Details::_internal_set_serial(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.serial_ = value; -} -inline void NoiseCertificate_Details::set_serial(uint32_t value) { - _internal_set_serial(value); - // @@protoc_insertion_point(field_set:proto.NoiseCertificate.Details.serial) -} - -// optional string issuer = 2; -inline bool NoiseCertificate_Details::_internal_has_issuer() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool NoiseCertificate_Details::has_issuer() const { - return _internal_has_issuer(); -} -inline void NoiseCertificate_Details::clear_issuer() { - _impl_.issuer_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& NoiseCertificate_Details::issuer() const { - // @@protoc_insertion_point(field_get:proto.NoiseCertificate.Details.issuer) - return _internal_issuer(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void NoiseCertificate_Details::set_issuer(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.issuer_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.NoiseCertificate.Details.issuer) -} -inline std::string* NoiseCertificate_Details::mutable_issuer() { - std::string* _s = _internal_mutable_issuer(); - // @@protoc_insertion_point(field_mutable:proto.NoiseCertificate.Details.issuer) - return _s; -} -inline const std::string& NoiseCertificate_Details::_internal_issuer() const { - return _impl_.issuer_.Get(); -} -inline void NoiseCertificate_Details::_internal_set_issuer(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.issuer_.Set(value, GetArenaForAllocation()); -} -inline std::string* NoiseCertificate_Details::_internal_mutable_issuer() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.issuer_.Mutable(GetArenaForAllocation()); -} -inline std::string* NoiseCertificate_Details::release_issuer() { - // @@protoc_insertion_point(field_release:proto.NoiseCertificate.Details.issuer) - if (!_internal_has_issuer()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.issuer_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.issuer_.IsDefault()) { - _impl_.issuer_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void NoiseCertificate_Details::set_allocated_issuer(std::string* issuer) { - if (issuer != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.issuer_.SetAllocated(issuer, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.issuer_.IsDefault()) { - _impl_.issuer_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.NoiseCertificate.Details.issuer) -} - -// optional uint64 expires = 3; -inline bool NoiseCertificate_Details::_internal_has_expires() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool NoiseCertificate_Details::has_expires() const { - return _internal_has_expires(); -} -inline void NoiseCertificate_Details::clear_expires() { - _impl_.expires_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline uint64_t NoiseCertificate_Details::_internal_expires() const { - return _impl_.expires_; -} -inline uint64_t NoiseCertificate_Details::expires() const { - // @@protoc_insertion_point(field_get:proto.NoiseCertificate.Details.expires) - return _internal_expires(); -} -inline void NoiseCertificate_Details::_internal_set_expires(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.expires_ = value; -} -inline void NoiseCertificate_Details::set_expires(uint64_t value) { - _internal_set_expires(value); - // @@protoc_insertion_point(field_set:proto.NoiseCertificate.Details.expires) -} - -// optional string subject = 4; -inline bool NoiseCertificate_Details::_internal_has_subject() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool NoiseCertificate_Details::has_subject() const { - return _internal_has_subject(); -} -inline void NoiseCertificate_Details::clear_subject() { - _impl_.subject_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& NoiseCertificate_Details::subject() const { - // @@protoc_insertion_point(field_get:proto.NoiseCertificate.Details.subject) - return _internal_subject(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void NoiseCertificate_Details::set_subject(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.subject_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.NoiseCertificate.Details.subject) -} -inline std::string* NoiseCertificate_Details::mutable_subject() { - std::string* _s = _internal_mutable_subject(); - // @@protoc_insertion_point(field_mutable:proto.NoiseCertificate.Details.subject) - return _s; -} -inline const std::string& NoiseCertificate_Details::_internal_subject() const { - return _impl_.subject_.Get(); -} -inline void NoiseCertificate_Details::_internal_set_subject(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.subject_.Set(value, GetArenaForAllocation()); -} -inline std::string* NoiseCertificate_Details::_internal_mutable_subject() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.subject_.Mutable(GetArenaForAllocation()); -} -inline std::string* NoiseCertificate_Details::release_subject() { - // @@protoc_insertion_point(field_release:proto.NoiseCertificate.Details.subject) - if (!_internal_has_subject()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.subject_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.subject_.IsDefault()) { - _impl_.subject_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void NoiseCertificate_Details::set_allocated_subject(std::string* subject) { - if (subject != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.subject_.SetAllocated(subject, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.subject_.IsDefault()) { - _impl_.subject_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.NoiseCertificate.Details.subject) -} - -// optional bytes key = 5; -inline bool NoiseCertificate_Details::_internal_has_key() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool NoiseCertificate_Details::has_key() const { - return _internal_has_key(); -} -inline void NoiseCertificate_Details::clear_key() { - _impl_.key_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& NoiseCertificate_Details::key() const { - // @@protoc_insertion_point(field_get:proto.NoiseCertificate.Details.key) - return _internal_key(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void NoiseCertificate_Details::set_key(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.key_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.NoiseCertificate.Details.key) -} -inline std::string* NoiseCertificate_Details::mutable_key() { - std::string* _s = _internal_mutable_key(); - // @@protoc_insertion_point(field_mutable:proto.NoiseCertificate.Details.key) - return _s; -} -inline const std::string& NoiseCertificate_Details::_internal_key() const { - return _impl_.key_.Get(); -} -inline void NoiseCertificate_Details::_internal_set_key(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.key_.Set(value, GetArenaForAllocation()); -} -inline std::string* NoiseCertificate_Details::_internal_mutable_key() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.key_.Mutable(GetArenaForAllocation()); -} -inline std::string* NoiseCertificate_Details::release_key() { - // @@protoc_insertion_point(field_release:proto.NoiseCertificate.Details.key) - if (!_internal_has_key()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.key_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.key_.IsDefault()) { - _impl_.key_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void NoiseCertificate_Details::set_allocated_key(std::string* key) { - if (key != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.key_.SetAllocated(key, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.key_.IsDefault()) { - _impl_.key_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.NoiseCertificate.Details.key) -} - -// ------------------------------------------------------------------- - -// NoiseCertificate - -// optional bytes details = 1; -inline bool NoiseCertificate::_internal_has_details() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool NoiseCertificate::has_details() const { - return _internal_has_details(); -} -inline void NoiseCertificate::clear_details() { - _impl_.details_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& NoiseCertificate::details() const { - // @@protoc_insertion_point(field_get:proto.NoiseCertificate.details) - return _internal_details(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void NoiseCertificate::set_details(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.details_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.NoiseCertificate.details) -} -inline std::string* NoiseCertificate::mutable_details() { - std::string* _s = _internal_mutable_details(); - // @@protoc_insertion_point(field_mutable:proto.NoiseCertificate.details) - return _s; -} -inline const std::string& NoiseCertificate::_internal_details() const { - return _impl_.details_.Get(); -} -inline void NoiseCertificate::_internal_set_details(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.details_.Set(value, GetArenaForAllocation()); -} -inline std::string* NoiseCertificate::_internal_mutable_details() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.details_.Mutable(GetArenaForAllocation()); -} -inline std::string* NoiseCertificate::release_details() { - // @@protoc_insertion_point(field_release:proto.NoiseCertificate.details) - if (!_internal_has_details()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.details_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.details_.IsDefault()) { - _impl_.details_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void NoiseCertificate::set_allocated_details(std::string* details) { - if (details != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.details_.SetAllocated(details, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.details_.IsDefault()) { - _impl_.details_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.NoiseCertificate.details) -} - -// optional bytes signature = 2; -inline bool NoiseCertificate::_internal_has_signature() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool NoiseCertificate::has_signature() const { - return _internal_has_signature(); -} -inline void NoiseCertificate::clear_signature() { - _impl_.signature_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& NoiseCertificate::signature() const { - // @@protoc_insertion_point(field_get:proto.NoiseCertificate.signature) - return _internal_signature(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void NoiseCertificate::set_signature(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.signature_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.NoiseCertificate.signature) -} -inline std::string* NoiseCertificate::mutable_signature() { - std::string* _s = _internal_mutable_signature(); - // @@protoc_insertion_point(field_mutable:proto.NoiseCertificate.signature) - return _s; -} -inline const std::string& NoiseCertificate::_internal_signature() const { - return _impl_.signature_.Get(); -} -inline void NoiseCertificate::_internal_set_signature(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.signature_.Set(value, GetArenaForAllocation()); -} -inline std::string* NoiseCertificate::_internal_mutable_signature() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.signature_.Mutable(GetArenaForAllocation()); -} -inline std::string* NoiseCertificate::release_signature() { - // @@protoc_insertion_point(field_release:proto.NoiseCertificate.signature) - if (!_internal_has_signature()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.signature_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.signature_.IsDefault()) { - _impl_.signature_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void NoiseCertificate::set_allocated_signature(std::string* signature) { - if (signature != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.signature_.SetAllocated(signature, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.signature_.IsDefault()) { - _impl_.signature_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.NoiseCertificate.signature) -} - -// ------------------------------------------------------------------- - -// NotificationMessageInfo - -// optional .proto.MessageKey key = 1; -inline bool NotificationMessageInfo::_internal_has_key() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr); - return value; -} -inline bool NotificationMessageInfo::has_key() const { - return _internal_has_key(); -} -inline void NotificationMessageInfo::clear_key() { - if (_impl_.key_ != nullptr) _impl_.key_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::MessageKey& NotificationMessageInfo::_internal_key() const { - const ::proto::MessageKey* p = _impl_.key_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_MessageKey_default_instance_); -} -inline const ::proto::MessageKey& NotificationMessageInfo::key() const { - // @@protoc_insertion_point(field_get:proto.NotificationMessageInfo.key) - return _internal_key(); -} -inline void NotificationMessageInfo::unsafe_arena_set_allocated_key( - ::proto::MessageKey* key) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_); - } - _impl_.key_ = key; - if (key) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.NotificationMessageInfo.key) -} -inline ::proto::MessageKey* NotificationMessageInfo::release_key() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::MessageKey* temp = _impl_.key_; - _impl_.key_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::MessageKey* NotificationMessageInfo::unsafe_arena_release_key() { - // @@protoc_insertion_point(field_release:proto.NotificationMessageInfo.key) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::MessageKey* temp = _impl_.key_; - _impl_.key_ = nullptr; - return temp; -} -inline ::proto::MessageKey* NotificationMessageInfo::_internal_mutable_key() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.key_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation()); - _impl_.key_ = p; - } - return _impl_.key_; -} -inline ::proto::MessageKey* NotificationMessageInfo::mutable_key() { - ::proto::MessageKey* _msg = _internal_mutable_key(); - // @@protoc_insertion_point(field_mutable:proto.NotificationMessageInfo.key) - return _msg; -} -inline void NotificationMessageInfo::set_allocated_key(::proto::MessageKey* key) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.key_; - } - if (key) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key); - if (message_arena != submessage_arena) { - key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, key, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.key_ = key; - // @@protoc_insertion_point(field_set_allocated:proto.NotificationMessageInfo.key) -} - -// optional .proto.Message message = 2; -inline bool NotificationMessageInfo::_internal_has_message() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - PROTOBUF_ASSUME(!value || _impl_.message_ != nullptr); - return value; -} -inline bool NotificationMessageInfo::has_message() const { - return _internal_has_message(); -} -inline void NotificationMessageInfo::clear_message() { - if (_impl_.message_ != nullptr) _impl_.message_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const ::proto::Message& NotificationMessageInfo::_internal_message() const { - const ::proto::Message* p = _impl_.message_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_default_instance_); -} -inline const ::proto::Message& NotificationMessageInfo::message() const { - // @@protoc_insertion_point(field_get:proto.NotificationMessageInfo.message) - return _internal_message(); -} -inline void NotificationMessageInfo::unsafe_arena_set_allocated_message( - ::proto::Message* message) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.message_); - } - _impl_.message_ = message; - if (message) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.NotificationMessageInfo.message) -} -inline ::proto::Message* NotificationMessageInfo::release_message() { - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::Message* temp = _impl_.message_; - _impl_.message_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message* NotificationMessageInfo::unsafe_arena_release_message() { - // @@protoc_insertion_point(field_release:proto.NotificationMessageInfo.message) - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::Message* temp = _impl_.message_; - _impl_.message_ = nullptr; - return temp; -} -inline ::proto::Message* NotificationMessageInfo::_internal_mutable_message() { - _impl_._has_bits_[0] |= 0x00000004u; - if (_impl_.message_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message>(GetArenaForAllocation()); - _impl_.message_ = p; - } - return _impl_.message_; -} -inline ::proto::Message* NotificationMessageInfo::mutable_message() { - ::proto::Message* _msg = _internal_mutable_message(); - // @@protoc_insertion_point(field_mutable:proto.NotificationMessageInfo.message) - return _msg; -} -inline void NotificationMessageInfo::set_allocated_message(::proto::Message* message) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.message_; - } - if (message) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(message); - if (message_arena != submessage_arena) { - message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, message, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.message_ = message; - // @@protoc_insertion_point(field_set_allocated:proto.NotificationMessageInfo.message) -} - -// optional uint64 messageTimestamp = 3; -inline bool NotificationMessageInfo::_internal_has_messagetimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool NotificationMessageInfo::has_messagetimestamp() const { - return _internal_has_messagetimestamp(); -} -inline void NotificationMessageInfo::clear_messagetimestamp() { - _impl_.messagetimestamp_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline uint64_t NotificationMessageInfo::_internal_messagetimestamp() const { - return _impl_.messagetimestamp_; -} -inline uint64_t NotificationMessageInfo::messagetimestamp() const { - // @@protoc_insertion_point(field_get:proto.NotificationMessageInfo.messageTimestamp) - return _internal_messagetimestamp(); -} -inline void NotificationMessageInfo::_internal_set_messagetimestamp(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.messagetimestamp_ = value; -} -inline void NotificationMessageInfo::set_messagetimestamp(uint64_t value) { - _internal_set_messagetimestamp(value); - // @@protoc_insertion_point(field_set:proto.NotificationMessageInfo.messageTimestamp) -} - -// optional string participant = 4; -inline bool NotificationMessageInfo::_internal_has_participant() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool NotificationMessageInfo::has_participant() const { - return _internal_has_participant(); -} -inline void NotificationMessageInfo::clear_participant() { - _impl_.participant_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& NotificationMessageInfo::participant() const { - // @@protoc_insertion_point(field_get:proto.NotificationMessageInfo.participant) - return _internal_participant(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void NotificationMessageInfo::set_participant(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.participant_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.NotificationMessageInfo.participant) -} -inline std::string* NotificationMessageInfo::mutable_participant() { - std::string* _s = _internal_mutable_participant(); - // @@protoc_insertion_point(field_mutable:proto.NotificationMessageInfo.participant) - return _s; -} -inline const std::string& NotificationMessageInfo::_internal_participant() const { - return _impl_.participant_.Get(); -} -inline void NotificationMessageInfo::_internal_set_participant(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.participant_.Set(value, GetArenaForAllocation()); -} -inline std::string* NotificationMessageInfo::_internal_mutable_participant() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.participant_.Mutable(GetArenaForAllocation()); -} -inline std::string* NotificationMessageInfo::release_participant() { - // @@protoc_insertion_point(field_release:proto.NotificationMessageInfo.participant) - if (!_internal_has_participant()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.participant_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.participant_.IsDefault()) { - _impl_.participant_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void NotificationMessageInfo::set_allocated_participant(std::string* participant) { - if (participant != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.participant_.SetAllocated(participant, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.participant_.IsDefault()) { - _impl_.participant_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.NotificationMessageInfo.participant) -} - -// ------------------------------------------------------------------- - -// PastParticipant - -// required string userJid = 1; -inline bool PastParticipant::_internal_has_userjid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool PastParticipant::has_userjid() const { - return _internal_has_userjid(); -} -inline void PastParticipant::clear_userjid() { - _impl_.userjid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& PastParticipant::userjid() const { - // @@protoc_insertion_point(field_get:proto.PastParticipant.userJid) - return _internal_userjid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void PastParticipant::set_userjid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.userjid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.PastParticipant.userJid) -} -inline std::string* PastParticipant::mutable_userjid() { - std::string* _s = _internal_mutable_userjid(); - // @@protoc_insertion_point(field_mutable:proto.PastParticipant.userJid) - return _s; -} -inline const std::string& PastParticipant::_internal_userjid() const { - return _impl_.userjid_.Get(); -} -inline void PastParticipant::_internal_set_userjid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.userjid_.Set(value, GetArenaForAllocation()); -} -inline std::string* PastParticipant::_internal_mutable_userjid() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.userjid_.Mutable(GetArenaForAllocation()); -} -inline std::string* PastParticipant::release_userjid() { - // @@protoc_insertion_point(field_release:proto.PastParticipant.userJid) - if (!_internal_has_userjid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.userjid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.userjid_.IsDefault()) { - _impl_.userjid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void PastParticipant::set_allocated_userjid(std::string* userjid) { - if (userjid != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.userjid_.SetAllocated(userjid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.userjid_.IsDefault()) { - _impl_.userjid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.PastParticipant.userJid) -} - -// required .proto.PastParticipant.LeaveReason leaveReason = 2; -inline bool PastParticipant::_internal_has_leavereason() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool PastParticipant::has_leavereason() const { - return _internal_has_leavereason(); -} -inline void PastParticipant::clear_leavereason() { - _impl_.leavereason_ = 0; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline ::proto::PastParticipant_LeaveReason PastParticipant::_internal_leavereason() const { - return static_cast< ::proto::PastParticipant_LeaveReason >(_impl_.leavereason_); -} -inline ::proto::PastParticipant_LeaveReason PastParticipant::leavereason() const { - // @@protoc_insertion_point(field_get:proto.PastParticipant.leaveReason) - return _internal_leavereason(); -} -inline void PastParticipant::_internal_set_leavereason(::proto::PastParticipant_LeaveReason value) { - assert(::proto::PastParticipant_LeaveReason_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.leavereason_ = value; -} -inline void PastParticipant::set_leavereason(::proto::PastParticipant_LeaveReason value) { - _internal_set_leavereason(value); - // @@protoc_insertion_point(field_set:proto.PastParticipant.leaveReason) -} - -// required uint64 leaveTs = 3; -inline bool PastParticipant::_internal_has_leavets() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool PastParticipant::has_leavets() const { - return _internal_has_leavets(); -} -inline void PastParticipant::clear_leavets() { - _impl_.leavets_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline uint64_t PastParticipant::_internal_leavets() const { - return _impl_.leavets_; -} -inline uint64_t PastParticipant::leavets() const { - // @@protoc_insertion_point(field_get:proto.PastParticipant.leaveTs) - return _internal_leavets(); -} -inline void PastParticipant::_internal_set_leavets(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.leavets_ = value; -} -inline void PastParticipant::set_leavets(uint64_t value) { - _internal_set_leavets(value); - // @@protoc_insertion_point(field_set:proto.PastParticipant.leaveTs) -} - -// ------------------------------------------------------------------- - -// PastParticipants - -// required string groupJid = 1; -inline bool PastParticipants::_internal_has_groupjid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool PastParticipants::has_groupjid() const { - return _internal_has_groupjid(); -} -inline void PastParticipants::clear_groupjid() { - _impl_.groupjid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& PastParticipants::groupjid() const { - // @@protoc_insertion_point(field_get:proto.PastParticipants.groupJid) - return _internal_groupjid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void PastParticipants::set_groupjid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.groupjid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.PastParticipants.groupJid) -} -inline std::string* PastParticipants::mutable_groupjid() { - std::string* _s = _internal_mutable_groupjid(); - // @@protoc_insertion_point(field_mutable:proto.PastParticipants.groupJid) - return _s; -} -inline const std::string& PastParticipants::_internal_groupjid() const { - return _impl_.groupjid_.Get(); -} -inline void PastParticipants::_internal_set_groupjid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.groupjid_.Set(value, GetArenaForAllocation()); -} -inline std::string* PastParticipants::_internal_mutable_groupjid() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.groupjid_.Mutable(GetArenaForAllocation()); -} -inline std::string* PastParticipants::release_groupjid() { - // @@protoc_insertion_point(field_release:proto.PastParticipants.groupJid) - if (!_internal_has_groupjid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.groupjid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.groupjid_.IsDefault()) { - _impl_.groupjid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void PastParticipants::set_allocated_groupjid(std::string* groupjid) { - if (groupjid != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.groupjid_.SetAllocated(groupjid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.groupjid_.IsDefault()) { - _impl_.groupjid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.PastParticipants.groupJid) -} - -// repeated .proto.PastParticipant pastParticipants = 2; -inline int PastParticipants::_internal_pastparticipants_size() const { - return _impl_.pastparticipants_.size(); -} -inline int PastParticipants::pastparticipants_size() const { - return _internal_pastparticipants_size(); -} -inline void PastParticipants::clear_pastparticipants() { - _impl_.pastparticipants_.Clear(); -} -inline ::proto::PastParticipant* PastParticipants::mutable_pastparticipants(int index) { - // @@protoc_insertion_point(field_mutable:proto.PastParticipants.pastParticipants) - return _impl_.pastparticipants_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipant >* -PastParticipants::mutable_pastparticipants() { - // @@protoc_insertion_point(field_mutable_list:proto.PastParticipants.pastParticipants) - return &_impl_.pastparticipants_; -} -inline const ::proto::PastParticipant& PastParticipants::_internal_pastparticipants(int index) const { - return _impl_.pastparticipants_.Get(index); -} -inline const ::proto::PastParticipant& PastParticipants::pastparticipants(int index) const { - // @@protoc_insertion_point(field_get:proto.PastParticipants.pastParticipants) - return _internal_pastparticipants(index); -} -inline ::proto::PastParticipant* PastParticipants::_internal_add_pastparticipants() { - return _impl_.pastparticipants_.Add(); -} -inline ::proto::PastParticipant* PastParticipants::add_pastparticipants() { - ::proto::PastParticipant* _add = _internal_add_pastparticipants(); - // @@protoc_insertion_point(field_add:proto.PastParticipants.pastParticipants) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipant >& -PastParticipants::pastparticipants() const { - // @@protoc_insertion_point(field_list:proto.PastParticipants.pastParticipants) - return _impl_.pastparticipants_; -} - -// ------------------------------------------------------------------- - -// PaymentBackground_MediaData - -// optional bytes mediaKey = 1; -inline bool PaymentBackground_MediaData::_internal_has_mediakey() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool PaymentBackground_MediaData::has_mediakey() const { - return _internal_has_mediakey(); -} -inline void PaymentBackground_MediaData::clear_mediakey() { - _impl_.mediakey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& PaymentBackground_MediaData::mediakey() const { - // @@protoc_insertion_point(field_get:proto.PaymentBackground.MediaData.mediaKey) - return _internal_mediakey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void PaymentBackground_MediaData::set_mediakey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.mediakey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.PaymentBackground.MediaData.mediaKey) -} -inline std::string* PaymentBackground_MediaData::mutable_mediakey() { - std::string* _s = _internal_mutable_mediakey(); - // @@protoc_insertion_point(field_mutable:proto.PaymentBackground.MediaData.mediaKey) - return _s; -} -inline const std::string& PaymentBackground_MediaData::_internal_mediakey() const { - return _impl_.mediakey_.Get(); -} -inline void PaymentBackground_MediaData::_internal_set_mediakey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.mediakey_.Set(value, GetArenaForAllocation()); -} -inline std::string* PaymentBackground_MediaData::_internal_mutable_mediakey() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.mediakey_.Mutable(GetArenaForAllocation()); -} -inline std::string* PaymentBackground_MediaData::release_mediakey() { - // @@protoc_insertion_point(field_release:proto.PaymentBackground.MediaData.mediaKey) - if (!_internal_has_mediakey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.mediakey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mediakey_.IsDefault()) { - _impl_.mediakey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void PaymentBackground_MediaData::set_allocated_mediakey(std::string* mediakey) { - if (mediakey != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mediakey_.IsDefault()) { - _impl_.mediakey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.PaymentBackground.MediaData.mediaKey) -} - -// optional int64 mediaKeyTimestamp = 2; -inline bool PaymentBackground_MediaData::_internal_has_mediakeytimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool PaymentBackground_MediaData::has_mediakeytimestamp() const { - return _internal_has_mediakeytimestamp(); -} -inline void PaymentBackground_MediaData::clear_mediakeytimestamp() { - _impl_.mediakeytimestamp_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline int64_t PaymentBackground_MediaData::_internal_mediakeytimestamp() const { - return _impl_.mediakeytimestamp_; -} -inline int64_t PaymentBackground_MediaData::mediakeytimestamp() const { - // @@protoc_insertion_point(field_get:proto.PaymentBackground.MediaData.mediaKeyTimestamp) - return _internal_mediakeytimestamp(); -} -inline void PaymentBackground_MediaData::_internal_set_mediakeytimestamp(int64_t value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.mediakeytimestamp_ = value; -} -inline void PaymentBackground_MediaData::set_mediakeytimestamp(int64_t value) { - _internal_set_mediakeytimestamp(value); - // @@protoc_insertion_point(field_set:proto.PaymentBackground.MediaData.mediaKeyTimestamp) -} - -// optional bytes fileSha256 = 3; -inline bool PaymentBackground_MediaData::_internal_has_filesha256() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool PaymentBackground_MediaData::has_filesha256() const { - return _internal_has_filesha256(); -} -inline void PaymentBackground_MediaData::clear_filesha256() { - _impl_.filesha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& PaymentBackground_MediaData::filesha256() const { - // @@protoc_insertion_point(field_get:proto.PaymentBackground.MediaData.fileSha256) - return _internal_filesha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void PaymentBackground_MediaData::set_filesha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.filesha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.PaymentBackground.MediaData.fileSha256) -} -inline std::string* PaymentBackground_MediaData::mutable_filesha256() { - std::string* _s = _internal_mutable_filesha256(); - // @@protoc_insertion_point(field_mutable:proto.PaymentBackground.MediaData.fileSha256) - return _s; -} -inline const std::string& PaymentBackground_MediaData::_internal_filesha256() const { - return _impl_.filesha256_.Get(); -} -inline void PaymentBackground_MediaData::_internal_set_filesha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.filesha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* PaymentBackground_MediaData::_internal_mutable_filesha256() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.filesha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* PaymentBackground_MediaData::release_filesha256() { - // @@protoc_insertion_point(field_release:proto.PaymentBackground.MediaData.fileSha256) - if (!_internal_has_filesha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.filesha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.filesha256_.IsDefault()) { - _impl_.filesha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void PaymentBackground_MediaData::set_allocated_filesha256(std::string* filesha256) { - if (filesha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.filesha256_.IsDefault()) { - _impl_.filesha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.PaymentBackground.MediaData.fileSha256) -} - -// optional bytes fileEncSha256 = 4; -inline bool PaymentBackground_MediaData::_internal_has_fileencsha256() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool PaymentBackground_MediaData::has_fileencsha256() const { - return _internal_has_fileencsha256(); -} -inline void PaymentBackground_MediaData::clear_fileencsha256() { - _impl_.fileencsha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& PaymentBackground_MediaData::fileencsha256() const { - // @@protoc_insertion_point(field_get:proto.PaymentBackground.MediaData.fileEncSha256) - return _internal_fileencsha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void PaymentBackground_MediaData::set_fileencsha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.fileencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.PaymentBackground.MediaData.fileEncSha256) -} -inline std::string* PaymentBackground_MediaData::mutable_fileencsha256() { - std::string* _s = _internal_mutable_fileencsha256(); - // @@protoc_insertion_point(field_mutable:proto.PaymentBackground.MediaData.fileEncSha256) - return _s; -} -inline const std::string& PaymentBackground_MediaData::_internal_fileencsha256() const { - return _impl_.fileencsha256_.Get(); -} -inline void PaymentBackground_MediaData::_internal_set_fileencsha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.fileencsha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* PaymentBackground_MediaData::_internal_mutable_fileencsha256() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.fileencsha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* PaymentBackground_MediaData::release_fileencsha256() { - // @@protoc_insertion_point(field_release:proto.PaymentBackground.MediaData.fileEncSha256) - if (!_internal_has_fileencsha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.fileencsha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fileencsha256_.IsDefault()) { - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void PaymentBackground_MediaData::set_allocated_fileencsha256(std::string* fileencsha256) { - if (fileencsha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fileencsha256_.IsDefault()) { - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.PaymentBackground.MediaData.fileEncSha256) -} - -// optional string directPath = 5; -inline bool PaymentBackground_MediaData::_internal_has_directpath() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool PaymentBackground_MediaData::has_directpath() const { - return _internal_has_directpath(); -} -inline void PaymentBackground_MediaData::clear_directpath() { - _impl_.directpath_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const std::string& PaymentBackground_MediaData::directpath() const { - // @@protoc_insertion_point(field_get:proto.PaymentBackground.MediaData.directPath) - return _internal_directpath(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void PaymentBackground_MediaData::set_directpath(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.directpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.PaymentBackground.MediaData.directPath) -} -inline std::string* PaymentBackground_MediaData::mutable_directpath() { - std::string* _s = _internal_mutable_directpath(); - // @@protoc_insertion_point(field_mutable:proto.PaymentBackground.MediaData.directPath) - return _s; -} -inline const std::string& PaymentBackground_MediaData::_internal_directpath() const { - return _impl_.directpath_.Get(); -} -inline void PaymentBackground_MediaData::_internal_set_directpath(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.directpath_.Set(value, GetArenaForAllocation()); -} -inline std::string* PaymentBackground_MediaData::_internal_mutable_directpath() { - _impl_._has_bits_[0] |= 0x00000008u; - return _impl_.directpath_.Mutable(GetArenaForAllocation()); -} -inline std::string* PaymentBackground_MediaData::release_directpath() { - // @@protoc_insertion_point(field_release:proto.PaymentBackground.MediaData.directPath) - if (!_internal_has_directpath()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000008u; - auto* p = _impl_.directpath_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.directpath_.IsDefault()) { - _impl_.directpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void PaymentBackground_MediaData::set_allocated_directpath(std::string* directpath) { - if (directpath != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.directpath_.IsDefault()) { - _impl_.directpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.PaymentBackground.MediaData.directPath) -} - -// ------------------------------------------------------------------- - -// PaymentBackground - -// optional string id = 1; -inline bool PaymentBackground::_internal_has_id() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool PaymentBackground::has_id() const { - return _internal_has_id(); -} -inline void PaymentBackground::clear_id() { - _impl_.id_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& PaymentBackground::id() const { - // @@protoc_insertion_point(field_get:proto.PaymentBackground.id) - return _internal_id(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void PaymentBackground::set_id(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.id_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.PaymentBackground.id) -} -inline std::string* PaymentBackground::mutable_id() { - std::string* _s = _internal_mutable_id(); - // @@protoc_insertion_point(field_mutable:proto.PaymentBackground.id) - return _s; -} -inline const std::string& PaymentBackground::_internal_id() const { - return _impl_.id_.Get(); -} -inline void PaymentBackground::_internal_set_id(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.id_.Set(value, GetArenaForAllocation()); -} -inline std::string* PaymentBackground::_internal_mutable_id() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.id_.Mutable(GetArenaForAllocation()); -} -inline std::string* PaymentBackground::release_id() { - // @@protoc_insertion_point(field_release:proto.PaymentBackground.id) - if (!_internal_has_id()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.id_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.id_.IsDefault()) { - _impl_.id_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void PaymentBackground::set_allocated_id(std::string* id) { - if (id != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.id_.SetAllocated(id, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.id_.IsDefault()) { - _impl_.id_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.PaymentBackground.id) -} - -// optional uint64 fileLength = 2; -inline bool PaymentBackground::_internal_has_filelength() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool PaymentBackground::has_filelength() const { - return _internal_has_filelength(); -} -inline void PaymentBackground::clear_filelength() { - _impl_.filelength_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline uint64_t PaymentBackground::_internal_filelength() const { - return _impl_.filelength_; -} -inline uint64_t PaymentBackground::filelength() const { - // @@protoc_insertion_point(field_get:proto.PaymentBackground.fileLength) - return _internal_filelength(); -} -inline void PaymentBackground::_internal_set_filelength(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.filelength_ = value; -} -inline void PaymentBackground::set_filelength(uint64_t value) { - _internal_set_filelength(value); - // @@protoc_insertion_point(field_set:proto.PaymentBackground.fileLength) -} - -// optional uint32 width = 3; -inline bool PaymentBackground::_internal_has_width() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool PaymentBackground::has_width() const { - return _internal_has_width(); -} -inline void PaymentBackground::clear_width() { - _impl_.width_ = 0u; - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline uint32_t PaymentBackground::_internal_width() const { - return _impl_.width_; -} -inline uint32_t PaymentBackground::width() const { - // @@protoc_insertion_point(field_get:proto.PaymentBackground.width) - return _internal_width(); -} -inline void PaymentBackground::_internal_set_width(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.width_ = value; -} -inline void PaymentBackground::set_width(uint32_t value) { - _internal_set_width(value); - // @@protoc_insertion_point(field_set:proto.PaymentBackground.width) -} - -// optional uint32 height = 4; -inline bool PaymentBackground::_internal_has_height() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool PaymentBackground::has_height() const { - return _internal_has_height(); -} -inline void PaymentBackground::clear_height() { - _impl_.height_ = 0u; - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline uint32_t PaymentBackground::_internal_height() const { - return _impl_.height_; -} -inline uint32_t PaymentBackground::height() const { - // @@protoc_insertion_point(field_get:proto.PaymentBackground.height) - return _internal_height(); -} -inline void PaymentBackground::_internal_set_height(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.height_ = value; -} -inline void PaymentBackground::set_height(uint32_t value) { - _internal_set_height(value); - // @@protoc_insertion_point(field_set:proto.PaymentBackground.height) -} - -// optional string mimetype = 5; -inline bool PaymentBackground::_internal_has_mimetype() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool PaymentBackground::has_mimetype() const { - return _internal_has_mimetype(); -} -inline void PaymentBackground::clear_mimetype() { - _impl_.mimetype_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& PaymentBackground::mimetype() const { - // @@protoc_insertion_point(field_get:proto.PaymentBackground.mimetype) - return _internal_mimetype(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void PaymentBackground::set_mimetype(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.mimetype_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.PaymentBackground.mimetype) -} -inline std::string* PaymentBackground::mutable_mimetype() { - std::string* _s = _internal_mutable_mimetype(); - // @@protoc_insertion_point(field_mutable:proto.PaymentBackground.mimetype) - return _s; -} -inline const std::string& PaymentBackground::_internal_mimetype() const { - return _impl_.mimetype_.Get(); -} -inline void PaymentBackground::_internal_set_mimetype(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.mimetype_.Set(value, GetArenaForAllocation()); -} -inline std::string* PaymentBackground::_internal_mutable_mimetype() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.mimetype_.Mutable(GetArenaForAllocation()); -} -inline std::string* PaymentBackground::release_mimetype() { - // @@protoc_insertion_point(field_release:proto.PaymentBackground.mimetype) - if (!_internal_has_mimetype()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.mimetype_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mimetype_.IsDefault()) { - _impl_.mimetype_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void PaymentBackground::set_allocated_mimetype(std::string* mimetype) { - if (mimetype != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mimetype_.IsDefault()) { - _impl_.mimetype_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.PaymentBackground.mimetype) -} - -// optional fixed32 placeholderArgb = 6; -inline bool PaymentBackground::_internal_has_placeholderargb() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool PaymentBackground::has_placeholderargb() const { - return _internal_has_placeholderargb(); -} -inline void PaymentBackground::clear_placeholderargb() { - _impl_.placeholderargb_ = 0u; - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline uint32_t PaymentBackground::_internal_placeholderargb() const { - return _impl_.placeholderargb_; -} -inline uint32_t PaymentBackground::placeholderargb() const { - // @@protoc_insertion_point(field_get:proto.PaymentBackground.placeholderArgb) - return _internal_placeholderargb(); -} -inline void PaymentBackground::_internal_set_placeholderargb(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.placeholderargb_ = value; -} -inline void PaymentBackground::set_placeholderargb(uint32_t value) { - _internal_set_placeholderargb(value); - // @@protoc_insertion_point(field_set:proto.PaymentBackground.placeholderArgb) -} - -// optional fixed32 textArgb = 7; -inline bool PaymentBackground::_internal_has_textargb() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - return value; -} -inline bool PaymentBackground::has_textargb() const { - return _internal_has_textargb(); -} -inline void PaymentBackground::clear_textargb() { - _impl_.textargb_ = 0u; - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline uint32_t PaymentBackground::_internal_textargb() const { - return _impl_.textargb_; -} -inline uint32_t PaymentBackground::textargb() const { - // @@protoc_insertion_point(field_get:proto.PaymentBackground.textArgb) - return _internal_textargb(); -} -inline void PaymentBackground::_internal_set_textargb(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.textargb_ = value; -} -inline void PaymentBackground::set_textargb(uint32_t value) { - _internal_set_textargb(value); - // @@protoc_insertion_point(field_set:proto.PaymentBackground.textArgb) -} - -// optional fixed32 subtextArgb = 8; -inline bool PaymentBackground::_internal_has_subtextargb() const { - bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; - return value; -} -inline bool PaymentBackground::has_subtextargb() const { - return _internal_has_subtextargb(); -} -inline void PaymentBackground::clear_subtextargb() { - _impl_.subtextargb_ = 0u; - _impl_._has_bits_[0] &= ~0x00000100u; -} -inline uint32_t PaymentBackground::_internal_subtextargb() const { - return _impl_.subtextargb_; -} -inline uint32_t PaymentBackground::subtextargb() const { - // @@protoc_insertion_point(field_get:proto.PaymentBackground.subtextArgb) - return _internal_subtextargb(); -} -inline void PaymentBackground::_internal_set_subtextargb(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000100u; - _impl_.subtextargb_ = value; -} -inline void PaymentBackground::set_subtextargb(uint32_t value) { - _internal_set_subtextargb(value); - // @@protoc_insertion_point(field_set:proto.PaymentBackground.subtextArgb) -} - -// optional .proto.PaymentBackground.MediaData mediaData = 9; -inline bool PaymentBackground::_internal_has_mediadata() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - PROTOBUF_ASSUME(!value || _impl_.mediadata_ != nullptr); - return value; -} -inline bool PaymentBackground::has_mediadata() const { - return _internal_has_mediadata(); -} -inline void PaymentBackground::clear_mediadata() { - if (_impl_.mediadata_ != nullptr) _impl_.mediadata_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const ::proto::PaymentBackground_MediaData& PaymentBackground::_internal_mediadata() const { - const ::proto::PaymentBackground_MediaData* p = _impl_.mediadata_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_PaymentBackground_MediaData_default_instance_); -} -inline const ::proto::PaymentBackground_MediaData& PaymentBackground::mediadata() const { - // @@protoc_insertion_point(field_get:proto.PaymentBackground.mediaData) - return _internal_mediadata(); -} -inline void PaymentBackground::unsafe_arena_set_allocated_mediadata( - ::proto::PaymentBackground_MediaData* mediadata) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.mediadata_); - } - _impl_.mediadata_ = mediadata; - if (mediadata) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.PaymentBackground.mediaData) -} -inline ::proto::PaymentBackground_MediaData* PaymentBackground::release_mediadata() { - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::PaymentBackground_MediaData* temp = _impl_.mediadata_; - _impl_.mediadata_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::PaymentBackground_MediaData* PaymentBackground::unsafe_arena_release_mediadata() { - // @@protoc_insertion_point(field_release:proto.PaymentBackground.mediaData) - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::PaymentBackground_MediaData* temp = _impl_.mediadata_; - _impl_.mediadata_ = nullptr; - return temp; -} -inline ::proto::PaymentBackground_MediaData* PaymentBackground::_internal_mutable_mediadata() { - _impl_._has_bits_[0] |= 0x00000004u; - if (_impl_.mediadata_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::PaymentBackground_MediaData>(GetArenaForAllocation()); - _impl_.mediadata_ = p; - } - return _impl_.mediadata_; -} -inline ::proto::PaymentBackground_MediaData* PaymentBackground::mutable_mediadata() { - ::proto::PaymentBackground_MediaData* _msg = _internal_mutable_mediadata(); - // @@protoc_insertion_point(field_mutable:proto.PaymentBackground.mediaData) - return _msg; -} -inline void PaymentBackground::set_allocated_mediadata(::proto::PaymentBackground_MediaData* mediadata) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.mediadata_; - } - if (mediadata) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(mediadata); - if (message_arena != submessage_arena) { - mediadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, mediadata, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.mediadata_ = mediadata; - // @@protoc_insertion_point(field_set_allocated:proto.PaymentBackground.mediaData) -} - -// optional .proto.PaymentBackground.Type type = 10; -inline bool PaymentBackground::_internal_has_type() const { - bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; - return value; -} -inline bool PaymentBackground::has_type() const { - return _internal_has_type(); -} -inline void PaymentBackground::clear_type() { - _impl_.type_ = 0; - _impl_._has_bits_[0] &= ~0x00000200u; -} -inline ::proto::PaymentBackground_Type PaymentBackground::_internal_type() const { - return static_cast< ::proto::PaymentBackground_Type >(_impl_.type_); -} -inline ::proto::PaymentBackground_Type PaymentBackground::type() const { - // @@protoc_insertion_point(field_get:proto.PaymentBackground.type) - return _internal_type(); -} -inline void PaymentBackground::_internal_set_type(::proto::PaymentBackground_Type value) { - assert(::proto::PaymentBackground_Type_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.type_ = value; -} -inline void PaymentBackground::set_type(::proto::PaymentBackground_Type value) { - _internal_set_type(value); - // @@protoc_insertion_point(field_set:proto.PaymentBackground.type) -} - -// ------------------------------------------------------------------- - -// PaymentInfo - -// optional .proto.PaymentInfo.Currency currencyDeprecated = 1; -inline bool PaymentInfo::_internal_has_currencydeprecated() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool PaymentInfo::has_currencydeprecated() const { - return _internal_has_currencydeprecated(); -} -inline void PaymentInfo::clear_currencydeprecated() { - _impl_.currencydeprecated_ = 0; - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline ::proto::PaymentInfo_Currency PaymentInfo::_internal_currencydeprecated() const { - return static_cast< ::proto::PaymentInfo_Currency >(_impl_.currencydeprecated_); -} -inline ::proto::PaymentInfo_Currency PaymentInfo::currencydeprecated() const { - // @@protoc_insertion_point(field_get:proto.PaymentInfo.currencyDeprecated) - return _internal_currencydeprecated(); -} -inline void PaymentInfo::_internal_set_currencydeprecated(::proto::PaymentInfo_Currency value) { - assert(::proto::PaymentInfo_Currency_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.currencydeprecated_ = value; -} -inline void PaymentInfo::set_currencydeprecated(::proto::PaymentInfo_Currency value) { - _internal_set_currencydeprecated(value); - // @@protoc_insertion_point(field_set:proto.PaymentInfo.currencyDeprecated) -} - -// optional uint64 amount1000 = 2; -inline bool PaymentInfo::_internal_has_amount1000() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool PaymentInfo::has_amount1000() const { - return _internal_has_amount1000(); -} -inline void PaymentInfo::clear_amount1000() { - _impl_.amount1000_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline uint64_t PaymentInfo::_internal_amount1000() const { - return _impl_.amount1000_; -} -inline uint64_t PaymentInfo::amount1000() const { - // @@protoc_insertion_point(field_get:proto.PaymentInfo.amount1000) - return _internal_amount1000(); -} -inline void PaymentInfo::_internal_set_amount1000(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.amount1000_ = value; -} -inline void PaymentInfo::set_amount1000(uint64_t value) { - _internal_set_amount1000(value); - // @@protoc_insertion_point(field_set:proto.PaymentInfo.amount1000) -} - -// optional string receiverJid = 3; -inline bool PaymentInfo::_internal_has_receiverjid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool PaymentInfo::has_receiverjid() const { - return _internal_has_receiverjid(); -} -inline void PaymentInfo::clear_receiverjid() { - _impl_.receiverjid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& PaymentInfo::receiverjid() const { - // @@protoc_insertion_point(field_get:proto.PaymentInfo.receiverJid) - return _internal_receiverjid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void PaymentInfo::set_receiverjid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.receiverjid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.PaymentInfo.receiverJid) -} -inline std::string* PaymentInfo::mutable_receiverjid() { - std::string* _s = _internal_mutable_receiverjid(); - // @@protoc_insertion_point(field_mutable:proto.PaymentInfo.receiverJid) - return _s; -} -inline const std::string& PaymentInfo::_internal_receiverjid() const { - return _impl_.receiverjid_.Get(); -} -inline void PaymentInfo::_internal_set_receiverjid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.receiverjid_.Set(value, GetArenaForAllocation()); -} -inline std::string* PaymentInfo::_internal_mutable_receiverjid() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.receiverjid_.Mutable(GetArenaForAllocation()); -} -inline std::string* PaymentInfo::release_receiverjid() { - // @@protoc_insertion_point(field_release:proto.PaymentInfo.receiverJid) - if (!_internal_has_receiverjid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.receiverjid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.receiverjid_.IsDefault()) { - _impl_.receiverjid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void PaymentInfo::set_allocated_receiverjid(std::string* receiverjid) { - if (receiverjid != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.receiverjid_.SetAllocated(receiverjid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.receiverjid_.IsDefault()) { - _impl_.receiverjid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.PaymentInfo.receiverJid) -} - -// optional .proto.PaymentInfo.Status status = 4; -inline bool PaymentInfo::_internal_has_status() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - return value; -} -inline bool PaymentInfo::has_status() const { - return _internal_has_status(); -} -inline void PaymentInfo::clear_status() { - _impl_.status_ = 0; - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline ::proto::PaymentInfo_Status PaymentInfo::_internal_status() const { - return static_cast< ::proto::PaymentInfo_Status >(_impl_.status_); -} -inline ::proto::PaymentInfo_Status PaymentInfo::status() const { - // @@protoc_insertion_point(field_get:proto.PaymentInfo.status) - return _internal_status(); -} -inline void PaymentInfo::_internal_set_status(::proto::PaymentInfo_Status value) { - assert(::proto::PaymentInfo_Status_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.status_ = value; -} -inline void PaymentInfo::set_status(::proto::PaymentInfo_Status value) { - _internal_set_status(value); - // @@protoc_insertion_point(field_set:proto.PaymentInfo.status) -} - -// optional uint64 transactionTimestamp = 5; -inline bool PaymentInfo::_internal_has_transactiontimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; - return value; -} -inline bool PaymentInfo::has_transactiontimestamp() const { - return _internal_has_transactiontimestamp(); -} -inline void PaymentInfo::clear_transactiontimestamp() { - _impl_.transactiontimestamp_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000100u; -} -inline uint64_t PaymentInfo::_internal_transactiontimestamp() const { - return _impl_.transactiontimestamp_; -} -inline uint64_t PaymentInfo::transactiontimestamp() const { - // @@protoc_insertion_point(field_get:proto.PaymentInfo.transactionTimestamp) - return _internal_transactiontimestamp(); -} -inline void PaymentInfo::_internal_set_transactiontimestamp(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000100u; - _impl_.transactiontimestamp_ = value; -} -inline void PaymentInfo::set_transactiontimestamp(uint64_t value) { - _internal_set_transactiontimestamp(value); - // @@protoc_insertion_point(field_set:proto.PaymentInfo.transactionTimestamp) -} - -// optional .proto.MessageKey requestMessageKey = 6; -inline bool PaymentInfo::_internal_has_requestmessagekey() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - PROTOBUF_ASSUME(!value || _impl_.requestmessagekey_ != nullptr); - return value; -} -inline bool PaymentInfo::has_requestmessagekey() const { - return _internal_has_requestmessagekey(); -} -inline void PaymentInfo::clear_requestmessagekey() { - if (_impl_.requestmessagekey_ != nullptr) _impl_.requestmessagekey_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const ::proto::MessageKey& PaymentInfo::_internal_requestmessagekey() const { - const ::proto::MessageKey* p = _impl_.requestmessagekey_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_MessageKey_default_instance_); -} -inline const ::proto::MessageKey& PaymentInfo::requestmessagekey() const { - // @@protoc_insertion_point(field_get:proto.PaymentInfo.requestMessageKey) - return _internal_requestmessagekey(); -} -inline void PaymentInfo::unsafe_arena_set_allocated_requestmessagekey( - ::proto::MessageKey* requestmessagekey) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.requestmessagekey_); - } - _impl_.requestmessagekey_ = requestmessagekey; - if (requestmessagekey) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.PaymentInfo.requestMessageKey) -} -inline ::proto::MessageKey* PaymentInfo::release_requestmessagekey() { - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::MessageKey* temp = _impl_.requestmessagekey_; - _impl_.requestmessagekey_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::MessageKey* PaymentInfo::unsafe_arena_release_requestmessagekey() { - // @@protoc_insertion_point(field_release:proto.PaymentInfo.requestMessageKey) - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::MessageKey* temp = _impl_.requestmessagekey_; - _impl_.requestmessagekey_ = nullptr; - return temp; -} -inline ::proto::MessageKey* PaymentInfo::_internal_mutable_requestmessagekey() { - _impl_._has_bits_[0] |= 0x00000004u; - if (_impl_.requestmessagekey_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation()); - _impl_.requestmessagekey_ = p; - } - return _impl_.requestmessagekey_; -} -inline ::proto::MessageKey* PaymentInfo::mutable_requestmessagekey() { - ::proto::MessageKey* _msg = _internal_mutable_requestmessagekey(); - // @@protoc_insertion_point(field_mutable:proto.PaymentInfo.requestMessageKey) - return _msg; -} -inline void PaymentInfo::set_allocated_requestmessagekey(::proto::MessageKey* requestmessagekey) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.requestmessagekey_; - } - if (requestmessagekey) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(requestmessagekey); - if (message_arena != submessage_arena) { - requestmessagekey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, requestmessagekey, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.requestmessagekey_ = requestmessagekey; - // @@protoc_insertion_point(field_set_allocated:proto.PaymentInfo.requestMessageKey) -} - -// optional uint64 expiryTimestamp = 7; -inline bool PaymentInfo::_internal_has_expirytimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; - return value; -} -inline bool PaymentInfo::has_expirytimestamp() const { - return _internal_has_expirytimestamp(); -} -inline void PaymentInfo::clear_expirytimestamp() { - _impl_.expirytimestamp_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000200u; -} -inline uint64_t PaymentInfo::_internal_expirytimestamp() const { - return _impl_.expirytimestamp_; -} -inline uint64_t PaymentInfo::expirytimestamp() const { - // @@protoc_insertion_point(field_get:proto.PaymentInfo.expiryTimestamp) - return _internal_expirytimestamp(); -} -inline void PaymentInfo::_internal_set_expirytimestamp(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.expirytimestamp_ = value; -} -inline void PaymentInfo::set_expirytimestamp(uint64_t value) { - _internal_set_expirytimestamp(value); - // @@protoc_insertion_point(field_set:proto.PaymentInfo.expiryTimestamp) -} - -// optional bool futureproofed = 8; -inline bool PaymentInfo::_internal_has_futureproofed() const { - bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; - return value; -} -inline bool PaymentInfo::has_futureproofed() const { - return _internal_has_futureproofed(); -} -inline void PaymentInfo::clear_futureproofed() { - _impl_.futureproofed_ = false; - _impl_._has_bits_[0] &= ~0x00000400u; -} -inline bool PaymentInfo::_internal_futureproofed() const { - return _impl_.futureproofed_; -} -inline bool PaymentInfo::futureproofed() const { - // @@protoc_insertion_point(field_get:proto.PaymentInfo.futureproofed) - return _internal_futureproofed(); -} -inline void PaymentInfo::_internal_set_futureproofed(bool value) { - _impl_._has_bits_[0] |= 0x00000400u; - _impl_.futureproofed_ = value; -} -inline void PaymentInfo::set_futureproofed(bool value) { - _internal_set_futureproofed(value); - // @@protoc_insertion_point(field_set:proto.PaymentInfo.futureproofed) -} - -// optional string currency = 9; -inline bool PaymentInfo::_internal_has_currency() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool PaymentInfo::has_currency() const { - return _internal_has_currency(); -} -inline void PaymentInfo::clear_currency() { - _impl_.currency_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& PaymentInfo::currency() const { - // @@protoc_insertion_point(field_get:proto.PaymentInfo.currency) - return _internal_currency(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void PaymentInfo::set_currency(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.currency_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.PaymentInfo.currency) -} -inline std::string* PaymentInfo::mutable_currency() { - std::string* _s = _internal_mutable_currency(); - // @@protoc_insertion_point(field_mutable:proto.PaymentInfo.currency) - return _s; -} -inline const std::string& PaymentInfo::_internal_currency() const { - return _impl_.currency_.Get(); -} -inline void PaymentInfo::_internal_set_currency(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.currency_.Set(value, GetArenaForAllocation()); -} -inline std::string* PaymentInfo::_internal_mutable_currency() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.currency_.Mutable(GetArenaForAllocation()); -} -inline std::string* PaymentInfo::release_currency() { - // @@protoc_insertion_point(field_release:proto.PaymentInfo.currency) - if (!_internal_has_currency()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.currency_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.currency_.IsDefault()) { - _impl_.currency_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void PaymentInfo::set_allocated_currency(std::string* currency) { - if (currency != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.currency_.SetAllocated(currency, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.currency_.IsDefault()) { - _impl_.currency_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.PaymentInfo.currency) -} - -// optional .proto.PaymentInfo.TxnStatus txnStatus = 10; -inline bool PaymentInfo::_internal_has_txnstatus() const { - bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; - return value; -} -inline bool PaymentInfo::has_txnstatus() const { - return _internal_has_txnstatus(); -} -inline void PaymentInfo::clear_txnstatus() { - _impl_.txnstatus_ = 0; - _impl_._has_bits_[0] &= ~0x00001000u; -} -inline ::proto::PaymentInfo_TxnStatus PaymentInfo::_internal_txnstatus() const { - return static_cast< ::proto::PaymentInfo_TxnStatus >(_impl_.txnstatus_); -} -inline ::proto::PaymentInfo_TxnStatus PaymentInfo::txnstatus() const { - // @@protoc_insertion_point(field_get:proto.PaymentInfo.txnStatus) - return _internal_txnstatus(); -} -inline void PaymentInfo::_internal_set_txnstatus(::proto::PaymentInfo_TxnStatus value) { - assert(::proto::PaymentInfo_TxnStatus_IsValid(value)); - _impl_._has_bits_[0] |= 0x00001000u; - _impl_.txnstatus_ = value; -} -inline void PaymentInfo::set_txnstatus(::proto::PaymentInfo_TxnStatus value) { - _internal_set_txnstatus(value); - // @@protoc_insertion_point(field_set:proto.PaymentInfo.txnStatus) -} - -// optional bool useNoviFiatFormat = 11; -inline bool PaymentInfo::_internal_has_usenovifiatformat() const { - bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; - return value; -} -inline bool PaymentInfo::has_usenovifiatformat() const { - return _internal_has_usenovifiatformat(); -} -inline void PaymentInfo::clear_usenovifiatformat() { - _impl_.usenovifiatformat_ = false; - _impl_._has_bits_[0] &= ~0x00000800u; -} -inline bool PaymentInfo::_internal_usenovifiatformat() const { - return _impl_.usenovifiatformat_; -} -inline bool PaymentInfo::usenovifiatformat() const { - // @@protoc_insertion_point(field_get:proto.PaymentInfo.useNoviFiatFormat) - return _internal_usenovifiatformat(); -} -inline void PaymentInfo::_internal_set_usenovifiatformat(bool value) { - _impl_._has_bits_[0] |= 0x00000800u; - _impl_.usenovifiatformat_ = value; -} -inline void PaymentInfo::set_usenovifiatformat(bool value) { - _internal_set_usenovifiatformat(value); - // @@protoc_insertion_point(field_set:proto.PaymentInfo.useNoviFiatFormat) -} - -// optional .proto.Money primaryAmount = 12; -inline bool PaymentInfo::_internal_has_primaryamount() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - PROTOBUF_ASSUME(!value || _impl_.primaryamount_ != nullptr); - return value; -} -inline bool PaymentInfo::has_primaryamount() const { - return _internal_has_primaryamount(); -} -inline void PaymentInfo::clear_primaryamount() { - if (_impl_.primaryamount_ != nullptr) _impl_.primaryamount_->Clear(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const ::proto::Money& PaymentInfo::_internal_primaryamount() const { - const ::proto::Money* p = _impl_.primaryamount_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Money_default_instance_); -} -inline const ::proto::Money& PaymentInfo::primaryamount() const { - // @@protoc_insertion_point(field_get:proto.PaymentInfo.primaryAmount) - return _internal_primaryamount(); -} -inline void PaymentInfo::unsafe_arena_set_allocated_primaryamount( - ::proto::Money* primaryamount) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.primaryamount_); - } - _impl_.primaryamount_ = primaryamount; - if (primaryamount) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.PaymentInfo.primaryAmount) -} -inline ::proto::Money* PaymentInfo::release_primaryamount() { - _impl_._has_bits_[0] &= ~0x00000008u; - ::proto::Money* temp = _impl_.primaryamount_; - _impl_.primaryamount_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Money* PaymentInfo::unsafe_arena_release_primaryamount() { - // @@protoc_insertion_point(field_release:proto.PaymentInfo.primaryAmount) - _impl_._has_bits_[0] &= ~0x00000008u; - ::proto::Money* temp = _impl_.primaryamount_; - _impl_.primaryamount_ = nullptr; - return temp; -} -inline ::proto::Money* PaymentInfo::_internal_mutable_primaryamount() { - _impl_._has_bits_[0] |= 0x00000008u; - if (_impl_.primaryamount_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Money>(GetArenaForAllocation()); - _impl_.primaryamount_ = p; - } - return _impl_.primaryamount_; -} -inline ::proto::Money* PaymentInfo::mutable_primaryamount() { - ::proto::Money* _msg = _internal_mutable_primaryamount(); - // @@protoc_insertion_point(field_mutable:proto.PaymentInfo.primaryAmount) - return _msg; -} -inline void PaymentInfo::set_allocated_primaryamount(::proto::Money* primaryamount) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.primaryamount_; - } - if (primaryamount) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(primaryamount); - if (message_arena != submessage_arena) { - primaryamount = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, primaryamount, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.primaryamount_ = primaryamount; - // @@protoc_insertion_point(field_set_allocated:proto.PaymentInfo.primaryAmount) -} - -// optional .proto.Money exchangeAmount = 13; -inline bool PaymentInfo::_internal_has_exchangeamount() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - PROTOBUF_ASSUME(!value || _impl_.exchangeamount_ != nullptr); - return value; -} -inline bool PaymentInfo::has_exchangeamount() const { - return _internal_has_exchangeamount(); -} -inline void PaymentInfo::clear_exchangeamount() { - if (_impl_.exchangeamount_ != nullptr) _impl_.exchangeamount_->Clear(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const ::proto::Money& PaymentInfo::_internal_exchangeamount() const { - const ::proto::Money* p = _impl_.exchangeamount_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Money_default_instance_); -} -inline const ::proto::Money& PaymentInfo::exchangeamount() const { - // @@protoc_insertion_point(field_get:proto.PaymentInfo.exchangeAmount) - return _internal_exchangeamount(); -} -inline void PaymentInfo::unsafe_arena_set_allocated_exchangeamount( - ::proto::Money* exchangeamount) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.exchangeamount_); - } - _impl_.exchangeamount_ = exchangeamount; - if (exchangeamount) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.PaymentInfo.exchangeAmount) -} -inline ::proto::Money* PaymentInfo::release_exchangeamount() { - _impl_._has_bits_[0] &= ~0x00000010u; - ::proto::Money* temp = _impl_.exchangeamount_; - _impl_.exchangeamount_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Money* PaymentInfo::unsafe_arena_release_exchangeamount() { - // @@protoc_insertion_point(field_release:proto.PaymentInfo.exchangeAmount) - _impl_._has_bits_[0] &= ~0x00000010u; - ::proto::Money* temp = _impl_.exchangeamount_; - _impl_.exchangeamount_ = nullptr; - return temp; -} -inline ::proto::Money* PaymentInfo::_internal_mutable_exchangeamount() { - _impl_._has_bits_[0] |= 0x00000010u; - if (_impl_.exchangeamount_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Money>(GetArenaForAllocation()); - _impl_.exchangeamount_ = p; - } - return _impl_.exchangeamount_; -} -inline ::proto::Money* PaymentInfo::mutable_exchangeamount() { - ::proto::Money* _msg = _internal_mutable_exchangeamount(); - // @@protoc_insertion_point(field_mutable:proto.PaymentInfo.exchangeAmount) - return _msg; -} -inline void PaymentInfo::set_allocated_exchangeamount(::proto::Money* exchangeamount) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.exchangeamount_; - } - if (exchangeamount) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(exchangeamount); - if (message_arena != submessage_arena) { - exchangeamount = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, exchangeamount, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.exchangeamount_ = exchangeamount; - // @@protoc_insertion_point(field_set_allocated:proto.PaymentInfo.exchangeAmount) -} - -// ------------------------------------------------------------------- - -// PendingKeyExchange - -// optional uint32 sequence = 1; -inline bool PendingKeyExchange::_internal_has_sequence() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool PendingKeyExchange::has_sequence() const { - return _internal_has_sequence(); -} -inline void PendingKeyExchange::clear_sequence() { - _impl_.sequence_ = 0u; - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline uint32_t PendingKeyExchange::_internal_sequence() const { - return _impl_.sequence_; -} -inline uint32_t PendingKeyExchange::sequence() const { - // @@protoc_insertion_point(field_get:proto.PendingKeyExchange.sequence) - return _internal_sequence(); -} -inline void PendingKeyExchange::_internal_set_sequence(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.sequence_ = value; -} -inline void PendingKeyExchange::set_sequence(uint32_t value) { - _internal_set_sequence(value); - // @@protoc_insertion_point(field_set:proto.PendingKeyExchange.sequence) -} - -// optional bytes localBaseKey = 2; -inline bool PendingKeyExchange::_internal_has_localbasekey() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool PendingKeyExchange::has_localbasekey() const { - return _internal_has_localbasekey(); -} -inline void PendingKeyExchange::clear_localbasekey() { - _impl_.localbasekey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& PendingKeyExchange::localbasekey() const { - // @@protoc_insertion_point(field_get:proto.PendingKeyExchange.localBaseKey) - return _internal_localbasekey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void PendingKeyExchange::set_localbasekey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.localbasekey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.PendingKeyExchange.localBaseKey) -} -inline std::string* PendingKeyExchange::mutable_localbasekey() { - std::string* _s = _internal_mutable_localbasekey(); - // @@protoc_insertion_point(field_mutable:proto.PendingKeyExchange.localBaseKey) - return _s; -} -inline const std::string& PendingKeyExchange::_internal_localbasekey() const { - return _impl_.localbasekey_.Get(); -} -inline void PendingKeyExchange::_internal_set_localbasekey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.localbasekey_.Set(value, GetArenaForAllocation()); -} -inline std::string* PendingKeyExchange::_internal_mutable_localbasekey() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.localbasekey_.Mutable(GetArenaForAllocation()); -} -inline std::string* PendingKeyExchange::release_localbasekey() { - // @@protoc_insertion_point(field_release:proto.PendingKeyExchange.localBaseKey) - if (!_internal_has_localbasekey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.localbasekey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.localbasekey_.IsDefault()) { - _impl_.localbasekey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void PendingKeyExchange::set_allocated_localbasekey(std::string* localbasekey) { - if (localbasekey != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.localbasekey_.SetAllocated(localbasekey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.localbasekey_.IsDefault()) { - _impl_.localbasekey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.PendingKeyExchange.localBaseKey) -} - -// optional bytes localBaseKeyPrivate = 3; -inline bool PendingKeyExchange::_internal_has_localbasekeyprivate() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool PendingKeyExchange::has_localbasekeyprivate() const { - return _internal_has_localbasekeyprivate(); -} -inline void PendingKeyExchange::clear_localbasekeyprivate() { - _impl_.localbasekeyprivate_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& PendingKeyExchange::localbasekeyprivate() const { - // @@protoc_insertion_point(field_get:proto.PendingKeyExchange.localBaseKeyPrivate) - return _internal_localbasekeyprivate(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void PendingKeyExchange::set_localbasekeyprivate(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.localbasekeyprivate_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.PendingKeyExchange.localBaseKeyPrivate) -} -inline std::string* PendingKeyExchange::mutable_localbasekeyprivate() { - std::string* _s = _internal_mutable_localbasekeyprivate(); - // @@protoc_insertion_point(field_mutable:proto.PendingKeyExchange.localBaseKeyPrivate) - return _s; -} -inline const std::string& PendingKeyExchange::_internal_localbasekeyprivate() const { - return _impl_.localbasekeyprivate_.Get(); -} -inline void PendingKeyExchange::_internal_set_localbasekeyprivate(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.localbasekeyprivate_.Set(value, GetArenaForAllocation()); -} -inline std::string* PendingKeyExchange::_internal_mutable_localbasekeyprivate() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.localbasekeyprivate_.Mutable(GetArenaForAllocation()); -} -inline std::string* PendingKeyExchange::release_localbasekeyprivate() { - // @@protoc_insertion_point(field_release:proto.PendingKeyExchange.localBaseKeyPrivate) - if (!_internal_has_localbasekeyprivate()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.localbasekeyprivate_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.localbasekeyprivate_.IsDefault()) { - _impl_.localbasekeyprivate_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void PendingKeyExchange::set_allocated_localbasekeyprivate(std::string* localbasekeyprivate) { - if (localbasekeyprivate != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.localbasekeyprivate_.SetAllocated(localbasekeyprivate, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.localbasekeyprivate_.IsDefault()) { - _impl_.localbasekeyprivate_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.PendingKeyExchange.localBaseKeyPrivate) -} - -// optional bytes localRatchetKey = 4; -inline bool PendingKeyExchange::_internal_has_localratchetkey() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool PendingKeyExchange::has_localratchetkey() const { - return _internal_has_localratchetkey(); -} -inline void PendingKeyExchange::clear_localratchetkey() { - _impl_.localratchetkey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& PendingKeyExchange::localratchetkey() const { - // @@protoc_insertion_point(field_get:proto.PendingKeyExchange.localRatchetKey) - return _internal_localratchetkey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void PendingKeyExchange::set_localratchetkey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.localratchetkey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.PendingKeyExchange.localRatchetKey) -} -inline std::string* PendingKeyExchange::mutable_localratchetkey() { - std::string* _s = _internal_mutable_localratchetkey(); - // @@protoc_insertion_point(field_mutable:proto.PendingKeyExchange.localRatchetKey) - return _s; -} -inline const std::string& PendingKeyExchange::_internal_localratchetkey() const { - return _impl_.localratchetkey_.Get(); -} -inline void PendingKeyExchange::_internal_set_localratchetkey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.localratchetkey_.Set(value, GetArenaForAllocation()); -} -inline std::string* PendingKeyExchange::_internal_mutable_localratchetkey() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.localratchetkey_.Mutable(GetArenaForAllocation()); -} -inline std::string* PendingKeyExchange::release_localratchetkey() { - // @@protoc_insertion_point(field_release:proto.PendingKeyExchange.localRatchetKey) - if (!_internal_has_localratchetkey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.localratchetkey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.localratchetkey_.IsDefault()) { - _impl_.localratchetkey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void PendingKeyExchange::set_allocated_localratchetkey(std::string* localratchetkey) { - if (localratchetkey != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.localratchetkey_.SetAllocated(localratchetkey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.localratchetkey_.IsDefault()) { - _impl_.localratchetkey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.PendingKeyExchange.localRatchetKey) -} - -// optional bytes localRatchetKeyPrivate = 5; -inline bool PendingKeyExchange::_internal_has_localratchetkeyprivate() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool PendingKeyExchange::has_localratchetkeyprivate() const { - return _internal_has_localratchetkeyprivate(); -} -inline void PendingKeyExchange::clear_localratchetkeyprivate() { - _impl_.localratchetkeyprivate_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const std::string& PendingKeyExchange::localratchetkeyprivate() const { - // @@protoc_insertion_point(field_get:proto.PendingKeyExchange.localRatchetKeyPrivate) - return _internal_localratchetkeyprivate(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void PendingKeyExchange::set_localratchetkeyprivate(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.localratchetkeyprivate_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.PendingKeyExchange.localRatchetKeyPrivate) -} -inline std::string* PendingKeyExchange::mutable_localratchetkeyprivate() { - std::string* _s = _internal_mutable_localratchetkeyprivate(); - // @@protoc_insertion_point(field_mutable:proto.PendingKeyExchange.localRatchetKeyPrivate) - return _s; -} -inline const std::string& PendingKeyExchange::_internal_localratchetkeyprivate() const { - return _impl_.localratchetkeyprivate_.Get(); -} -inline void PendingKeyExchange::_internal_set_localratchetkeyprivate(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.localratchetkeyprivate_.Set(value, GetArenaForAllocation()); -} -inline std::string* PendingKeyExchange::_internal_mutable_localratchetkeyprivate() { - _impl_._has_bits_[0] |= 0x00000008u; - return _impl_.localratchetkeyprivate_.Mutable(GetArenaForAllocation()); -} -inline std::string* PendingKeyExchange::release_localratchetkeyprivate() { - // @@protoc_insertion_point(field_release:proto.PendingKeyExchange.localRatchetKeyPrivate) - if (!_internal_has_localratchetkeyprivate()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000008u; - auto* p = _impl_.localratchetkeyprivate_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.localratchetkeyprivate_.IsDefault()) { - _impl_.localratchetkeyprivate_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void PendingKeyExchange::set_allocated_localratchetkeyprivate(std::string* localratchetkeyprivate) { - if (localratchetkeyprivate != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.localratchetkeyprivate_.SetAllocated(localratchetkeyprivate, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.localratchetkeyprivate_.IsDefault()) { - _impl_.localratchetkeyprivate_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.PendingKeyExchange.localRatchetKeyPrivate) -} - -// optional bytes localIdentityKey = 7; -inline bool PendingKeyExchange::_internal_has_localidentitykey() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool PendingKeyExchange::has_localidentitykey() const { - return _internal_has_localidentitykey(); -} -inline void PendingKeyExchange::clear_localidentitykey() { - _impl_.localidentitykey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const std::string& PendingKeyExchange::localidentitykey() const { - // @@protoc_insertion_point(field_get:proto.PendingKeyExchange.localIdentityKey) - return _internal_localidentitykey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void PendingKeyExchange::set_localidentitykey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.localidentitykey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.PendingKeyExchange.localIdentityKey) -} -inline std::string* PendingKeyExchange::mutable_localidentitykey() { - std::string* _s = _internal_mutable_localidentitykey(); - // @@protoc_insertion_point(field_mutable:proto.PendingKeyExchange.localIdentityKey) - return _s; -} -inline const std::string& PendingKeyExchange::_internal_localidentitykey() const { - return _impl_.localidentitykey_.Get(); -} -inline void PendingKeyExchange::_internal_set_localidentitykey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.localidentitykey_.Set(value, GetArenaForAllocation()); -} -inline std::string* PendingKeyExchange::_internal_mutable_localidentitykey() { - _impl_._has_bits_[0] |= 0x00000010u; - return _impl_.localidentitykey_.Mutable(GetArenaForAllocation()); -} -inline std::string* PendingKeyExchange::release_localidentitykey() { - // @@protoc_insertion_point(field_release:proto.PendingKeyExchange.localIdentityKey) - if (!_internal_has_localidentitykey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000010u; - auto* p = _impl_.localidentitykey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.localidentitykey_.IsDefault()) { - _impl_.localidentitykey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void PendingKeyExchange::set_allocated_localidentitykey(std::string* localidentitykey) { - if (localidentitykey != nullptr) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.localidentitykey_.SetAllocated(localidentitykey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.localidentitykey_.IsDefault()) { - _impl_.localidentitykey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.PendingKeyExchange.localIdentityKey) -} - -// optional bytes localIdentityKeyPrivate = 8; -inline bool PendingKeyExchange::_internal_has_localidentitykeyprivate() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool PendingKeyExchange::has_localidentitykeyprivate() const { - return _internal_has_localidentitykeyprivate(); -} -inline void PendingKeyExchange::clear_localidentitykeyprivate() { - _impl_.localidentitykeyprivate_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline const std::string& PendingKeyExchange::localidentitykeyprivate() const { - // @@protoc_insertion_point(field_get:proto.PendingKeyExchange.localIdentityKeyPrivate) - return _internal_localidentitykeyprivate(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void PendingKeyExchange::set_localidentitykeyprivate(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.localidentitykeyprivate_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.PendingKeyExchange.localIdentityKeyPrivate) -} -inline std::string* PendingKeyExchange::mutable_localidentitykeyprivate() { - std::string* _s = _internal_mutable_localidentitykeyprivate(); - // @@protoc_insertion_point(field_mutable:proto.PendingKeyExchange.localIdentityKeyPrivate) - return _s; -} -inline const std::string& PendingKeyExchange::_internal_localidentitykeyprivate() const { - return _impl_.localidentitykeyprivate_.Get(); -} -inline void PendingKeyExchange::_internal_set_localidentitykeyprivate(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.localidentitykeyprivate_.Set(value, GetArenaForAllocation()); -} -inline std::string* PendingKeyExchange::_internal_mutable_localidentitykeyprivate() { - _impl_._has_bits_[0] |= 0x00000020u; - return _impl_.localidentitykeyprivate_.Mutable(GetArenaForAllocation()); -} -inline std::string* PendingKeyExchange::release_localidentitykeyprivate() { - // @@protoc_insertion_point(field_release:proto.PendingKeyExchange.localIdentityKeyPrivate) - if (!_internal_has_localidentitykeyprivate()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000020u; - auto* p = _impl_.localidentitykeyprivate_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.localidentitykeyprivate_.IsDefault()) { - _impl_.localidentitykeyprivate_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void PendingKeyExchange::set_allocated_localidentitykeyprivate(std::string* localidentitykeyprivate) { - if (localidentitykeyprivate != nullptr) { - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - _impl_.localidentitykeyprivate_.SetAllocated(localidentitykeyprivate, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.localidentitykeyprivate_.IsDefault()) { - _impl_.localidentitykeyprivate_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.PendingKeyExchange.localIdentityKeyPrivate) -} - -// ------------------------------------------------------------------- - -// PendingPreKey - -// optional uint32 preKeyId = 1; -inline bool PendingPreKey::_internal_has_prekeyid() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool PendingPreKey::has_prekeyid() const { - return _internal_has_prekeyid(); -} -inline void PendingPreKey::clear_prekeyid() { - _impl_.prekeyid_ = 0u; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline uint32_t PendingPreKey::_internal_prekeyid() const { - return _impl_.prekeyid_; -} -inline uint32_t PendingPreKey::prekeyid() const { - // @@protoc_insertion_point(field_get:proto.PendingPreKey.preKeyId) - return _internal_prekeyid(); -} -inline void PendingPreKey::_internal_set_prekeyid(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.prekeyid_ = value; -} -inline void PendingPreKey::set_prekeyid(uint32_t value) { - _internal_set_prekeyid(value); - // @@protoc_insertion_point(field_set:proto.PendingPreKey.preKeyId) -} - -// optional int32 signedPreKeyId = 3; -inline bool PendingPreKey::_internal_has_signedprekeyid() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool PendingPreKey::has_signedprekeyid() const { - return _internal_has_signedprekeyid(); -} -inline void PendingPreKey::clear_signedprekeyid() { - _impl_.signedprekeyid_ = 0; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline int32_t PendingPreKey::_internal_signedprekeyid() const { - return _impl_.signedprekeyid_; -} -inline int32_t PendingPreKey::signedprekeyid() const { - // @@protoc_insertion_point(field_get:proto.PendingPreKey.signedPreKeyId) - return _internal_signedprekeyid(); -} -inline void PendingPreKey::_internal_set_signedprekeyid(int32_t value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.signedprekeyid_ = value; -} -inline void PendingPreKey::set_signedprekeyid(int32_t value) { - _internal_set_signedprekeyid(value); - // @@protoc_insertion_point(field_set:proto.PendingPreKey.signedPreKeyId) -} - -// optional bytes baseKey = 2; -inline bool PendingPreKey::_internal_has_basekey() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool PendingPreKey::has_basekey() const { - return _internal_has_basekey(); -} -inline void PendingPreKey::clear_basekey() { - _impl_.basekey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& PendingPreKey::basekey() const { - // @@protoc_insertion_point(field_get:proto.PendingPreKey.baseKey) - return _internal_basekey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void PendingPreKey::set_basekey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.basekey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.PendingPreKey.baseKey) -} -inline std::string* PendingPreKey::mutable_basekey() { - std::string* _s = _internal_mutable_basekey(); - // @@protoc_insertion_point(field_mutable:proto.PendingPreKey.baseKey) - return _s; -} -inline const std::string& PendingPreKey::_internal_basekey() const { - return _impl_.basekey_.Get(); -} -inline void PendingPreKey::_internal_set_basekey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.basekey_.Set(value, GetArenaForAllocation()); -} -inline std::string* PendingPreKey::_internal_mutable_basekey() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.basekey_.Mutable(GetArenaForAllocation()); -} -inline std::string* PendingPreKey::release_basekey() { - // @@protoc_insertion_point(field_release:proto.PendingPreKey.baseKey) - if (!_internal_has_basekey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.basekey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.basekey_.IsDefault()) { - _impl_.basekey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void PendingPreKey::set_allocated_basekey(std::string* basekey) { - if (basekey != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.basekey_.SetAllocated(basekey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.basekey_.IsDefault()) { - _impl_.basekey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.PendingPreKey.baseKey) -} - -// ------------------------------------------------------------------- - -// PhotoChange - -// optional bytes oldPhoto = 1; -inline bool PhotoChange::_internal_has_oldphoto() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool PhotoChange::has_oldphoto() const { - return _internal_has_oldphoto(); -} -inline void PhotoChange::clear_oldphoto() { - _impl_.oldphoto_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& PhotoChange::oldphoto() const { - // @@protoc_insertion_point(field_get:proto.PhotoChange.oldPhoto) - return _internal_oldphoto(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void PhotoChange::set_oldphoto(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.oldphoto_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.PhotoChange.oldPhoto) -} -inline std::string* PhotoChange::mutable_oldphoto() { - std::string* _s = _internal_mutable_oldphoto(); - // @@protoc_insertion_point(field_mutable:proto.PhotoChange.oldPhoto) - return _s; -} -inline const std::string& PhotoChange::_internal_oldphoto() const { - return _impl_.oldphoto_.Get(); -} -inline void PhotoChange::_internal_set_oldphoto(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.oldphoto_.Set(value, GetArenaForAllocation()); -} -inline std::string* PhotoChange::_internal_mutable_oldphoto() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.oldphoto_.Mutable(GetArenaForAllocation()); -} -inline std::string* PhotoChange::release_oldphoto() { - // @@protoc_insertion_point(field_release:proto.PhotoChange.oldPhoto) - if (!_internal_has_oldphoto()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.oldphoto_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.oldphoto_.IsDefault()) { - _impl_.oldphoto_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void PhotoChange::set_allocated_oldphoto(std::string* oldphoto) { - if (oldphoto != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.oldphoto_.SetAllocated(oldphoto, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.oldphoto_.IsDefault()) { - _impl_.oldphoto_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.PhotoChange.oldPhoto) -} - -// optional bytes newPhoto = 2; -inline bool PhotoChange::_internal_has_newphoto() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool PhotoChange::has_newphoto() const { - return _internal_has_newphoto(); -} -inline void PhotoChange::clear_newphoto() { - _impl_.newphoto_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& PhotoChange::newphoto() const { - // @@protoc_insertion_point(field_get:proto.PhotoChange.newPhoto) - return _internal_newphoto(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void PhotoChange::set_newphoto(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.newphoto_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.PhotoChange.newPhoto) -} -inline std::string* PhotoChange::mutable_newphoto() { - std::string* _s = _internal_mutable_newphoto(); - // @@protoc_insertion_point(field_mutable:proto.PhotoChange.newPhoto) - return _s; -} -inline const std::string& PhotoChange::_internal_newphoto() const { - return _impl_.newphoto_.Get(); -} -inline void PhotoChange::_internal_set_newphoto(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.newphoto_.Set(value, GetArenaForAllocation()); -} -inline std::string* PhotoChange::_internal_mutable_newphoto() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.newphoto_.Mutable(GetArenaForAllocation()); -} -inline std::string* PhotoChange::release_newphoto() { - // @@protoc_insertion_point(field_release:proto.PhotoChange.newPhoto) - if (!_internal_has_newphoto()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.newphoto_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.newphoto_.IsDefault()) { - _impl_.newphoto_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void PhotoChange::set_allocated_newphoto(std::string* newphoto) { - if (newphoto != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.newphoto_.SetAllocated(newphoto, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.newphoto_.IsDefault()) { - _impl_.newphoto_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.PhotoChange.newPhoto) -} - -// optional uint32 newPhotoId = 3; -inline bool PhotoChange::_internal_has_newphotoid() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool PhotoChange::has_newphotoid() const { - return _internal_has_newphotoid(); -} -inline void PhotoChange::clear_newphotoid() { - _impl_.newphotoid_ = 0u; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline uint32_t PhotoChange::_internal_newphotoid() const { - return _impl_.newphotoid_; -} -inline uint32_t PhotoChange::newphotoid() const { - // @@protoc_insertion_point(field_get:proto.PhotoChange.newPhotoId) - return _internal_newphotoid(); -} -inline void PhotoChange::_internal_set_newphotoid(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.newphotoid_ = value; -} -inline void PhotoChange::set_newphotoid(uint32_t value) { - _internal_set_newphotoid(value); - // @@protoc_insertion_point(field_set:proto.PhotoChange.newPhotoId) -} - -// ------------------------------------------------------------------- - -// Point - -// optional int32 xDeprecated = 1; -inline bool Point::_internal_has_xdeprecated() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Point::has_xdeprecated() const { - return _internal_has_xdeprecated(); -} -inline void Point::clear_xdeprecated() { - _impl_.xdeprecated_ = 0; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline int32_t Point::_internal_xdeprecated() const { - return _impl_.xdeprecated_; -} -inline int32_t Point::xdeprecated() const { - // @@protoc_insertion_point(field_get:proto.Point.xDeprecated) - return _internal_xdeprecated(); -} -inline void Point::_internal_set_xdeprecated(int32_t value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.xdeprecated_ = value; -} -inline void Point::set_xdeprecated(int32_t value) { - _internal_set_xdeprecated(value); - // @@protoc_insertion_point(field_set:proto.Point.xDeprecated) -} - -// optional int32 yDeprecated = 2; -inline bool Point::_internal_has_ydeprecated() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Point::has_ydeprecated() const { - return _internal_has_ydeprecated(); -} -inline void Point::clear_ydeprecated() { - _impl_.ydeprecated_ = 0; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline int32_t Point::_internal_ydeprecated() const { - return _impl_.ydeprecated_; -} -inline int32_t Point::ydeprecated() const { - // @@protoc_insertion_point(field_get:proto.Point.yDeprecated) - return _internal_ydeprecated(); -} -inline void Point::_internal_set_ydeprecated(int32_t value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.ydeprecated_ = value; -} -inline void Point::set_ydeprecated(int32_t value) { - _internal_set_ydeprecated(value); - // @@protoc_insertion_point(field_set:proto.Point.yDeprecated) -} - -// optional double x = 3; -inline bool Point::_internal_has_x() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool Point::has_x() const { - return _internal_has_x(); -} -inline void Point::clear_x() { - _impl_.x_ = 0; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline double Point::_internal_x() const { - return _impl_.x_; -} -inline double Point::x() const { - // @@protoc_insertion_point(field_get:proto.Point.x) - return _internal_x(); -} -inline void Point::_internal_set_x(double value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.x_ = value; -} -inline void Point::set_x(double value) { - _internal_set_x(value); - // @@protoc_insertion_point(field_set:proto.Point.x) -} - -// optional double y = 4; -inline bool Point::_internal_has_y() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool Point::has_y() const { - return _internal_has_y(); -} -inline void Point::clear_y() { - _impl_.y_ = 0; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline double Point::_internal_y() const { - return _impl_.y_; -} -inline double Point::y() const { - // @@protoc_insertion_point(field_get:proto.Point.y) - return _internal_y(); -} -inline void Point::_internal_set_y(double value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.y_ = value; -} -inline void Point::set_y(double value) { - _internal_set_y(value); - // @@protoc_insertion_point(field_set:proto.Point.y) -} - -// ------------------------------------------------------------------- - -// PollAdditionalMetadata - -// optional bool pollInvalidated = 1; -inline bool PollAdditionalMetadata::_internal_has_pollinvalidated() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool PollAdditionalMetadata::has_pollinvalidated() const { - return _internal_has_pollinvalidated(); -} -inline void PollAdditionalMetadata::clear_pollinvalidated() { - _impl_.pollinvalidated_ = false; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline bool PollAdditionalMetadata::_internal_pollinvalidated() const { - return _impl_.pollinvalidated_; -} -inline bool PollAdditionalMetadata::pollinvalidated() const { - // @@protoc_insertion_point(field_get:proto.PollAdditionalMetadata.pollInvalidated) - return _internal_pollinvalidated(); -} -inline void PollAdditionalMetadata::_internal_set_pollinvalidated(bool value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.pollinvalidated_ = value; -} -inline void PollAdditionalMetadata::set_pollinvalidated(bool value) { - _internal_set_pollinvalidated(value); - // @@protoc_insertion_point(field_set:proto.PollAdditionalMetadata.pollInvalidated) -} - -// ------------------------------------------------------------------- - -// PollEncValue - -// optional bytes encPayload = 1; -inline bool PollEncValue::_internal_has_encpayload() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool PollEncValue::has_encpayload() const { - return _internal_has_encpayload(); -} -inline void PollEncValue::clear_encpayload() { - _impl_.encpayload_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& PollEncValue::encpayload() const { - // @@protoc_insertion_point(field_get:proto.PollEncValue.encPayload) - return _internal_encpayload(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void PollEncValue::set_encpayload(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.encpayload_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.PollEncValue.encPayload) -} -inline std::string* PollEncValue::mutable_encpayload() { - std::string* _s = _internal_mutable_encpayload(); - // @@protoc_insertion_point(field_mutable:proto.PollEncValue.encPayload) - return _s; -} -inline const std::string& PollEncValue::_internal_encpayload() const { - return _impl_.encpayload_.Get(); -} -inline void PollEncValue::_internal_set_encpayload(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.encpayload_.Set(value, GetArenaForAllocation()); -} -inline std::string* PollEncValue::_internal_mutable_encpayload() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.encpayload_.Mutable(GetArenaForAllocation()); -} -inline std::string* PollEncValue::release_encpayload() { - // @@protoc_insertion_point(field_release:proto.PollEncValue.encPayload) - if (!_internal_has_encpayload()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.encpayload_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.encpayload_.IsDefault()) { - _impl_.encpayload_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void PollEncValue::set_allocated_encpayload(std::string* encpayload) { - if (encpayload != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.encpayload_.SetAllocated(encpayload, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.encpayload_.IsDefault()) { - _impl_.encpayload_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.PollEncValue.encPayload) -} - -// optional bytes encIv = 2; -inline bool PollEncValue::_internal_has_enciv() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool PollEncValue::has_enciv() const { - return _internal_has_enciv(); -} -inline void PollEncValue::clear_enciv() { - _impl_.enciv_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& PollEncValue::enciv() const { - // @@protoc_insertion_point(field_get:proto.PollEncValue.encIv) - return _internal_enciv(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void PollEncValue::set_enciv(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.enciv_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.PollEncValue.encIv) -} -inline std::string* PollEncValue::mutable_enciv() { - std::string* _s = _internal_mutable_enciv(); - // @@protoc_insertion_point(field_mutable:proto.PollEncValue.encIv) - return _s; -} -inline const std::string& PollEncValue::_internal_enciv() const { - return _impl_.enciv_.Get(); -} -inline void PollEncValue::_internal_set_enciv(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.enciv_.Set(value, GetArenaForAllocation()); -} -inline std::string* PollEncValue::_internal_mutable_enciv() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.enciv_.Mutable(GetArenaForAllocation()); -} -inline std::string* PollEncValue::release_enciv() { - // @@protoc_insertion_point(field_release:proto.PollEncValue.encIv) - if (!_internal_has_enciv()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.enciv_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.enciv_.IsDefault()) { - _impl_.enciv_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void PollEncValue::set_allocated_enciv(std::string* enciv) { - if (enciv != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.enciv_.SetAllocated(enciv, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.enciv_.IsDefault()) { - _impl_.enciv_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.PollEncValue.encIv) -} - -// ------------------------------------------------------------------- - -// PollUpdate - -// optional .proto.MessageKey pollUpdateMessageKey = 1; -inline bool PollUpdate::_internal_has_pollupdatemessagekey() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.pollupdatemessagekey_ != nullptr); - return value; -} -inline bool PollUpdate::has_pollupdatemessagekey() const { - return _internal_has_pollupdatemessagekey(); -} -inline void PollUpdate::clear_pollupdatemessagekey() { - if (_impl_.pollupdatemessagekey_ != nullptr) _impl_.pollupdatemessagekey_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::MessageKey& PollUpdate::_internal_pollupdatemessagekey() const { - const ::proto::MessageKey* p = _impl_.pollupdatemessagekey_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_MessageKey_default_instance_); -} -inline const ::proto::MessageKey& PollUpdate::pollupdatemessagekey() const { - // @@protoc_insertion_point(field_get:proto.PollUpdate.pollUpdateMessageKey) - return _internal_pollupdatemessagekey(); -} -inline void PollUpdate::unsafe_arena_set_allocated_pollupdatemessagekey( - ::proto::MessageKey* pollupdatemessagekey) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pollupdatemessagekey_); - } - _impl_.pollupdatemessagekey_ = pollupdatemessagekey; - if (pollupdatemessagekey) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.PollUpdate.pollUpdateMessageKey) -} -inline ::proto::MessageKey* PollUpdate::release_pollupdatemessagekey() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::MessageKey* temp = _impl_.pollupdatemessagekey_; - _impl_.pollupdatemessagekey_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::MessageKey* PollUpdate::unsafe_arena_release_pollupdatemessagekey() { - // @@protoc_insertion_point(field_release:proto.PollUpdate.pollUpdateMessageKey) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::MessageKey* temp = _impl_.pollupdatemessagekey_; - _impl_.pollupdatemessagekey_ = nullptr; - return temp; -} -inline ::proto::MessageKey* PollUpdate::_internal_mutable_pollupdatemessagekey() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.pollupdatemessagekey_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation()); - _impl_.pollupdatemessagekey_ = p; - } - return _impl_.pollupdatemessagekey_; -} -inline ::proto::MessageKey* PollUpdate::mutable_pollupdatemessagekey() { - ::proto::MessageKey* _msg = _internal_mutable_pollupdatemessagekey(); - // @@protoc_insertion_point(field_mutable:proto.PollUpdate.pollUpdateMessageKey) - return _msg; -} -inline void PollUpdate::set_allocated_pollupdatemessagekey(::proto::MessageKey* pollupdatemessagekey) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.pollupdatemessagekey_; - } - if (pollupdatemessagekey) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pollupdatemessagekey); - if (message_arena != submessage_arena) { - pollupdatemessagekey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, pollupdatemessagekey, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.pollupdatemessagekey_ = pollupdatemessagekey; - // @@protoc_insertion_point(field_set_allocated:proto.PollUpdate.pollUpdateMessageKey) -} - -// optional .proto.Message.PollVoteMessage vote = 2; -inline bool PollUpdate::_internal_has_vote() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.vote_ != nullptr); - return value; -} -inline bool PollUpdate::has_vote() const { - return _internal_has_vote(); -} -inline void PollUpdate::clear_vote() { - if (_impl_.vote_ != nullptr) _impl_.vote_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::Message_PollVoteMessage& PollUpdate::_internal_vote() const { - const ::proto::Message_PollVoteMessage* p = _impl_.vote_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_PollVoteMessage_default_instance_); -} -inline const ::proto::Message_PollVoteMessage& PollUpdate::vote() const { - // @@protoc_insertion_point(field_get:proto.PollUpdate.vote) - return _internal_vote(); -} -inline void PollUpdate::unsafe_arena_set_allocated_vote( - ::proto::Message_PollVoteMessage* vote) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.vote_); - } - _impl_.vote_ = vote; - if (vote) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.PollUpdate.vote) -} -inline ::proto::Message_PollVoteMessage* PollUpdate::release_vote() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::Message_PollVoteMessage* temp = _impl_.vote_; - _impl_.vote_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_PollVoteMessage* PollUpdate::unsafe_arena_release_vote() { - // @@protoc_insertion_point(field_release:proto.PollUpdate.vote) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::Message_PollVoteMessage* temp = _impl_.vote_; - _impl_.vote_ = nullptr; - return temp; -} -inline ::proto::Message_PollVoteMessage* PollUpdate::_internal_mutable_vote() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.vote_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_PollVoteMessage>(GetArenaForAllocation()); - _impl_.vote_ = p; - } - return _impl_.vote_; -} -inline ::proto::Message_PollVoteMessage* PollUpdate::mutable_vote() { - ::proto::Message_PollVoteMessage* _msg = _internal_mutable_vote(); - // @@protoc_insertion_point(field_mutable:proto.PollUpdate.vote) - return _msg; -} -inline void PollUpdate::set_allocated_vote(::proto::Message_PollVoteMessage* vote) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.vote_; - } - if (vote) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(vote); - if (message_arena != submessage_arena) { - vote = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, vote, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.vote_ = vote; - // @@protoc_insertion_point(field_set_allocated:proto.PollUpdate.vote) -} - -// optional int64 senderTimestampMs = 3; -inline bool PollUpdate::_internal_has_sendertimestampms() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool PollUpdate::has_sendertimestampms() const { - return _internal_has_sendertimestampms(); -} -inline void PollUpdate::clear_sendertimestampms() { - _impl_.sendertimestampms_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline int64_t PollUpdate::_internal_sendertimestampms() const { - return _impl_.sendertimestampms_; -} -inline int64_t PollUpdate::sendertimestampms() const { - // @@protoc_insertion_point(field_get:proto.PollUpdate.senderTimestampMs) - return _internal_sendertimestampms(); -} -inline void PollUpdate::_internal_set_sendertimestampms(int64_t value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.sendertimestampms_ = value; -} -inline void PollUpdate::set_sendertimestampms(int64_t value) { - _internal_set_sendertimestampms(value); - // @@protoc_insertion_point(field_set:proto.PollUpdate.senderTimestampMs) -} - -// ------------------------------------------------------------------- - -// PreKeyRecordStructure - -// optional uint32 id = 1; -inline bool PreKeyRecordStructure::_internal_has_id() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool PreKeyRecordStructure::has_id() const { - return _internal_has_id(); -} -inline void PreKeyRecordStructure::clear_id() { - _impl_.id_ = 0u; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline uint32_t PreKeyRecordStructure::_internal_id() const { - return _impl_.id_; -} -inline uint32_t PreKeyRecordStructure::id() const { - // @@protoc_insertion_point(field_get:proto.PreKeyRecordStructure.id) - return _internal_id(); -} -inline void PreKeyRecordStructure::_internal_set_id(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.id_ = value; -} -inline void PreKeyRecordStructure::set_id(uint32_t value) { - _internal_set_id(value); - // @@protoc_insertion_point(field_set:proto.PreKeyRecordStructure.id) -} - -// optional bytes publicKey = 2; -inline bool PreKeyRecordStructure::_internal_has_publickey() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool PreKeyRecordStructure::has_publickey() const { - return _internal_has_publickey(); -} -inline void PreKeyRecordStructure::clear_publickey() { - _impl_.publickey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& PreKeyRecordStructure::publickey() const { - // @@protoc_insertion_point(field_get:proto.PreKeyRecordStructure.publicKey) - return _internal_publickey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void PreKeyRecordStructure::set_publickey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.publickey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.PreKeyRecordStructure.publicKey) -} -inline std::string* PreKeyRecordStructure::mutable_publickey() { - std::string* _s = _internal_mutable_publickey(); - // @@protoc_insertion_point(field_mutable:proto.PreKeyRecordStructure.publicKey) - return _s; -} -inline const std::string& PreKeyRecordStructure::_internal_publickey() const { - return _impl_.publickey_.Get(); -} -inline void PreKeyRecordStructure::_internal_set_publickey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.publickey_.Set(value, GetArenaForAllocation()); -} -inline std::string* PreKeyRecordStructure::_internal_mutable_publickey() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.publickey_.Mutable(GetArenaForAllocation()); -} -inline std::string* PreKeyRecordStructure::release_publickey() { - // @@protoc_insertion_point(field_release:proto.PreKeyRecordStructure.publicKey) - if (!_internal_has_publickey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.publickey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.publickey_.IsDefault()) { - _impl_.publickey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void PreKeyRecordStructure::set_allocated_publickey(std::string* publickey) { - if (publickey != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.publickey_.SetAllocated(publickey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.publickey_.IsDefault()) { - _impl_.publickey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.PreKeyRecordStructure.publicKey) -} - -// optional bytes privateKey = 3; -inline bool PreKeyRecordStructure::_internal_has_privatekey() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool PreKeyRecordStructure::has_privatekey() const { - return _internal_has_privatekey(); -} -inline void PreKeyRecordStructure::clear_privatekey() { - _impl_.privatekey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& PreKeyRecordStructure::privatekey() const { - // @@protoc_insertion_point(field_get:proto.PreKeyRecordStructure.privateKey) - return _internal_privatekey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void PreKeyRecordStructure::set_privatekey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.privatekey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.PreKeyRecordStructure.privateKey) -} -inline std::string* PreKeyRecordStructure::mutable_privatekey() { - std::string* _s = _internal_mutable_privatekey(); - // @@protoc_insertion_point(field_mutable:proto.PreKeyRecordStructure.privateKey) - return _s; -} -inline const std::string& PreKeyRecordStructure::_internal_privatekey() const { - return _impl_.privatekey_.Get(); -} -inline void PreKeyRecordStructure::_internal_set_privatekey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.privatekey_.Set(value, GetArenaForAllocation()); -} -inline std::string* PreKeyRecordStructure::_internal_mutable_privatekey() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.privatekey_.Mutable(GetArenaForAllocation()); -} -inline std::string* PreKeyRecordStructure::release_privatekey() { - // @@protoc_insertion_point(field_release:proto.PreKeyRecordStructure.privateKey) - if (!_internal_has_privatekey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.privatekey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.privatekey_.IsDefault()) { - _impl_.privatekey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void PreKeyRecordStructure::set_allocated_privatekey(std::string* privatekey) { - if (privatekey != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.privatekey_.SetAllocated(privatekey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.privatekey_.IsDefault()) { - _impl_.privatekey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.PreKeyRecordStructure.privateKey) -} - -// ------------------------------------------------------------------- - -// Pushname - -// optional string id = 1; -inline bool Pushname::_internal_has_id() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Pushname::has_id() const { - return _internal_has_id(); -} -inline void Pushname::clear_id() { - _impl_.id_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Pushname::id() const { - // @@protoc_insertion_point(field_get:proto.Pushname.id) - return _internal_id(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Pushname::set_id(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.id_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Pushname.id) -} -inline std::string* Pushname::mutable_id() { - std::string* _s = _internal_mutable_id(); - // @@protoc_insertion_point(field_mutable:proto.Pushname.id) - return _s; -} -inline const std::string& Pushname::_internal_id() const { - return _impl_.id_.Get(); -} -inline void Pushname::_internal_set_id(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.id_.Set(value, GetArenaForAllocation()); -} -inline std::string* Pushname::_internal_mutable_id() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.id_.Mutable(GetArenaForAllocation()); -} -inline std::string* Pushname::release_id() { - // @@protoc_insertion_point(field_release:proto.Pushname.id) - if (!_internal_has_id()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.id_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.id_.IsDefault()) { - _impl_.id_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Pushname::set_allocated_id(std::string* id) { - if (id != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.id_.SetAllocated(id, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.id_.IsDefault()) { - _impl_.id_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Pushname.id) -} - -// optional string pushname = 2; -inline bool Pushname::_internal_has_pushname() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Pushname::has_pushname() const { - return _internal_has_pushname(); -} -inline void Pushname::clear_pushname() { - _impl_.pushname_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Pushname::pushname() const { - // @@protoc_insertion_point(field_get:proto.Pushname.pushname) - return _internal_pushname(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Pushname::set_pushname(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.pushname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Pushname.pushname) -} -inline std::string* Pushname::mutable_pushname() { - std::string* _s = _internal_mutable_pushname(); - // @@protoc_insertion_point(field_mutable:proto.Pushname.pushname) - return _s; -} -inline const std::string& Pushname::_internal_pushname() const { - return _impl_.pushname_.Get(); -} -inline void Pushname::_internal_set_pushname(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.pushname_.Set(value, GetArenaForAllocation()); -} -inline std::string* Pushname::_internal_mutable_pushname() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.pushname_.Mutable(GetArenaForAllocation()); -} -inline std::string* Pushname::release_pushname() { - // @@protoc_insertion_point(field_release:proto.Pushname.pushname) - if (!_internal_has_pushname()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.pushname_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.pushname_.IsDefault()) { - _impl_.pushname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Pushname::set_allocated_pushname(std::string* pushname) { - if (pushname != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.pushname_.SetAllocated(pushname, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.pushname_.IsDefault()) { - _impl_.pushname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Pushname.pushname) -} - -// ------------------------------------------------------------------- - -// Reaction - -// optional .proto.MessageKey key = 1; -inline bool Reaction::_internal_has_key() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr); - return value; -} -inline bool Reaction::has_key() const { - return _internal_has_key(); -} -inline void Reaction::clear_key() { - if (_impl_.key_ != nullptr) _impl_.key_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const ::proto::MessageKey& Reaction::_internal_key() const { - const ::proto::MessageKey* p = _impl_.key_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_MessageKey_default_instance_); -} -inline const ::proto::MessageKey& Reaction::key() const { - // @@protoc_insertion_point(field_get:proto.Reaction.key) - return _internal_key(); -} -inline void Reaction::unsafe_arena_set_allocated_key( - ::proto::MessageKey* key) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_); - } - _impl_.key_ = key; - if (key) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Reaction.key) -} -inline ::proto::MessageKey* Reaction::release_key() { - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::MessageKey* temp = _impl_.key_; - _impl_.key_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::MessageKey* Reaction::unsafe_arena_release_key() { - // @@protoc_insertion_point(field_release:proto.Reaction.key) - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::MessageKey* temp = _impl_.key_; - _impl_.key_ = nullptr; - return temp; -} -inline ::proto::MessageKey* Reaction::_internal_mutable_key() { - _impl_._has_bits_[0] |= 0x00000004u; - if (_impl_.key_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation()); - _impl_.key_ = p; - } - return _impl_.key_; -} -inline ::proto::MessageKey* Reaction::mutable_key() { - ::proto::MessageKey* _msg = _internal_mutable_key(); - // @@protoc_insertion_point(field_mutable:proto.Reaction.key) - return _msg; -} -inline void Reaction::set_allocated_key(::proto::MessageKey* key) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.key_; - } - if (key) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key); - if (message_arena != submessage_arena) { - key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, key, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.key_ = key; - // @@protoc_insertion_point(field_set_allocated:proto.Reaction.key) -} - -// optional string text = 2; -inline bool Reaction::_internal_has_text() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool Reaction::has_text() const { - return _internal_has_text(); -} -inline void Reaction::clear_text() { - _impl_.text_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& Reaction::text() const { - // @@protoc_insertion_point(field_get:proto.Reaction.text) - return _internal_text(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Reaction::set_text(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.text_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Reaction.text) -} -inline std::string* Reaction::mutable_text() { - std::string* _s = _internal_mutable_text(); - // @@protoc_insertion_point(field_mutable:proto.Reaction.text) - return _s; -} -inline const std::string& Reaction::_internal_text() const { - return _impl_.text_.Get(); -} -inline void Reaction::_internal_set_text(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.text_.Set(value, GetArenaForAllocation()); -} -inline std::string* Reaction::_internal_mutable_text() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.text_.Mutable(GetArenaForAllocation()); -} -inline std::string* Reaction::release_text() { - // @@protoc_insertion_point(field_release:proto.Reaction.text) - if (!_internal_has_text()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.text_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.text_.IsDefault()) { - _impl_.text_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Reaction::set_allocated_text(std::string* text) { - if (text != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.text_.SetAllocated(text, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.text_.IsDefault()) { - _impl_.text_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Reaction.text) -} - -// optional string groupingKey = 3; -inline bool Reaction::_internal_has_groupingkey() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool Reaction::has_groupingkey() const { - return _internal_has_groupingkey(); -} -inline void Reaction::clear_groupingkey() { - _impl_.groupingkey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& Reaction::groupingkey() const { - // @@protoc_insertion_point(field_get:proto.Reaction.groupingKey) - return _internal_groupingkey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Reaction::set_groupingkey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.groupingkey_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.Reaction.groupingKey) -} -inline std::string* Reaction::mutable_groupingkey() { - std::string* _s = _internal_mutable_groupingkey(); - // @@protoc_insertion_point(field_mutable:proto.Reaction.groupingKey) - return _s; -} -inline const std::string& Reaction::_internal_groupingkey() const { - return _impl_.groupingkey_.Get(); -} -inline void Reaction::_internal_set_groupingkey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.groupingkey_.Set(value, GetArenaForAllocation()); -} -inline std::string* Reaction::_internal_mutable_groupingkey() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.groupingkey_.Mutable(GetArenaForAllocation()); -} -inline std::string* Reaction::release_groupingkey() { - // @@protoc_insertion_point(field_release:proto.Reaction.groupingKey) - if (!_internal_has_groupingkey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.groupingkey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.groupingkey_.IsDefault()) { - _impl_.groupingkey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void Reaction::set_allocated_groupingkey(std::string* groupingkey) { - if (groupingkey != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.groupingkey_.SetAllocated(groupingkey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.groupingkey_.IsDefault()) { - _impl_.groupingkey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.Reaction.groupingKey) -} - -// optional int64 senderTimestampMs = 4; -inline bool Reaction::_internal_has_sendertimestampms() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool Reaction::has_sendertimestampms() const { - return _internal_has_sendertimestampms(); -} -inline void Reaction::clear_sendertimestampms() { - _impl_.sendertimestampms_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline int64_t Reaction::_internal_sendertimestampms() const { - return _impl_.sendertimestampms_; -} -inline int64_t Reaction::sendertimestampms() const { - // @@protoc_insertion_point(field_get:proto.Reaction.senderTimestampMs) - return _internal_sendertimestampms(); -} -inline void Reaction::_internal_set_sendertimestampms(int64_t value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.sendertimestampms_ = value; -} -inline void Reaction::set_sendertimestampms(int64_t value) { - _internal_set_sendertimestampms(value); - // @@protoc_insertion_point(field_set:proto.Reaction.senderTimestampMs) -} - -// optional bool unread = 5; -inline bool Reaction::_internal_has_unread() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool Reaction::has_unread() const { - return _internal_has_unread(); -} -inline void Reaction::clear_unread() { - _impl_.unread_ = false; - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline bool Reaction::_internal_unread() const { - return _impl_.unread_; -} -inline bool Reaction::unread() const { - // @@protoc_insertion_point(field_get:proto.Reaction.unread) - return _internal_unread(); -} -inline void Reaction::_internal_set_unread(bool value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.unread_ = value; -} -inline void Reaction::set_unread(bool value) { - _internal_set_unread(value); - // @@protoc_insertion_point(field_set:proto.Reaction.unread) -} - -// ------------------------------------------------------------------- - -// RecentEmojiWeight - -// optional string emoji = 1; -inline bool RecentEmojiWeight::_internal_has_emoji() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool RecentEmojiWeight::has_emoji() const { - return _internal_has_emoji(); -} -inline void RecentEmojiWeight::clear_emoji() { - _impl_.emoji_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& RecentEmojiWeight::emoji() const { - // @@protoc_insertion_point(field_get:proto.RecentEmojiWeight.emoji) - return _internal_emoji(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void RecentEmojiWeight::set_emoji(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.emoji_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.RecentEmojiWeight.emoji) -} -inline std::string* RecentEmojiWeight::mutable_emoji() { - std::string* _s = _internal_mutable_emoji(); - // @@protoc_insertion_point(field_mutable:proto.RecentEmojiWeight.emoji) - return _s; -} -inline const std::string& RecentEmojiWeight::_internal_emoji() const { - return _impl_.emoji_.Get(); -} -inline void RecentEmojiWeight::_internal_set_emoji(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.emoji_.Set(value, GetArenaForAllocation()); -} -inline std::string* RecentEmojiWeight::_internal_mutable_emoji() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.emoji_.Mutable(GetArenaForAllocation()); -} -inline std::string* RecentEmojiWeight::release_emoji() { - // @@protoc_insertion_point(field_release:proto.RecentEmojiWeight.emoji) - if (!_internal_has_emoji()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.emoji_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.emoji_.IsDefault()) { - _impl_.emoji_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void RecentEmojiWeight::set_allocated_emoji(std::string* emoji) { - if (emoji != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.emoji_.SetAllocated(emoji, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.emoji_.IsDefault()) { - _impl_.emoji_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.RecentEmojiWeight.emoji) -} - -// optional float weight = 2; -inline bool RecentEmojiWeight::_internal_has_weight() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool RecentEmojiWeight::has_weight() const { - return _internal_has_weight(); -} -inline void RecentEmojiWeight::clear_weight() { - _impl_.weight_ = 0; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline float RecentEmojiWeight::_internal_weight() const { - return _impl_.weight_; -} -inline float RecentEmojiWeight::weight() const { - // @@protoc_insertion_point(field_get:proto.RecentEmojiWeight.weight) - return _internal_weight(); -} -inline void RecentEmojiWeight::_internal_set_weight(float value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.weight_ = value; -} -inline void RecentEmojiWeight::set_weight(float value) { - _internal_set_weight(value); - // @@protoc_insertion_point(field_set:proto.RecentEmojiWeight.weight) -} - -// ------------------------------------------------------------------- - -// RecordStructure - -// optional .proto.SessionStructure currentSession = 1; -inline bool RecordStructure::_internal_has_currentsession() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.currentsession_ != nullptr); - return value; -} -inline bool RecordStructure::has_currentsession() const { - return _internal_has_currentsession(); -} -inline void RecordStructure::clear_currentsession() { - if (_impl_.currentsession_ != nullptr) _impl_.currentsession_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::SessionStructure& RecordStructure::_internal_currentsession() const { - const ::proto::SessionStructure* p = _impl_.currentsession_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SessionStructure_default_instance_); -} -inline const ::proto::SessionStructure& RecordStructure::currentsession() const { - // @@protoc_insertion_point(field_get:proto.RecordStructure.currentSession) - return _internal_currentsession(); -} -inline void RecordStructure::unsafe_arena_set_allocated_currentsession( - ::proto::SessionStructure* currentsession) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.currentsession_); - } - _impl_.currentsession_ = currentsession; - if (currentsession) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.RecordStructure.currentSession) -} -inline ::proto::SessionStructure* RecordStructure::release_currentsession() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::SessionStructure* temp = _impl_.currentsession_; - _impl_.currentsession_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SessionStructure* RecordStructure::unsafe_arena_release_currentsession() { - // @@protoc_insertion_point(field_release:proto.RecordStructure.currentSession) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::SessionStructure* temp = _impl_.currentsession_; - _impl_.currentsession_ = nullptr; - return temp; -} -inline ::proto::SessionStructure* RecordStructure::_internal_mutable_currentsession() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.currentsession_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SessionStructure>(GetArenaForAllocation()); - _impl_.currentsession_ = p; - } - return _impl_.currentsession_; -} -inline ::proto::SessionStructure* RecordStructure::mutable_currentsession() { - ::proto::SessionStructure* _msg = _internal_mutable_currentsession(); - // @@protoc_insertion_point(field_mutable:proto.RecordStructure.currentSession) - return _msg; -} -inline void RecordStructure::set_allocated_currentsession(::proto::SessionStructure* currentsession) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.currentsession_; - } - if (currentsession) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(currentsession); - if (message_arena != submessage_arena) { - currentsession = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, currentsession, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.currentsession_ = currentsession; - // @@protoc_insertion_point(field_set_allocated:proto.RecordStructure.currentSession) -} - -// repeated .proto.SessionStructure previousSessions = 2; -inline int RecordStructure::_internal_previoussessions_size() const { - return _impl_.previoussessions_.size(); -} -inline int RecordStructure::previoussessions_size() const { - return _internal_previoussessions_size(); -} -inline void RecordStructure::clear_previoussessions() { - _impl_.previoussessions_.Clear(); -} -inline ::proto::SessionStructure* RecordStructure::mutable_previoussessions(int index) { - // @@protoc_insertion_point(field_mutable:proto.RecordStructure.previousSessions) - return _impl_.previoussessions_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SessionStructure >* -RecordStructure::mutable_previoussessions() { - // @@protoc_insertion_point(field_mutable_list:proto.RecordStructure.previousSessions) - return &_impl_.previoussessions_; -} -inline const ::proto::SessionStructure& RecordStructure::_internal_previoussessions(int index) const { - return _impl_.previoussessions_.Get(index); -} -inline const ::proto::SessionStructure& RecordStructure::previoussessions(int index) const { - // @@protoc_insertion_point(field_get:proto.RecordStructure.previousSessions) - return _internal_previoussessions(index); -} -inline ::proto::SessionStructure* RecordStructure::_internal_add_previoussessions() { - return _impl_.previoussessions_.Add(); -} -inline ::proto::SessionStructure* RecordStructure::add_previoussessions() { - ::proto::SessionStructure* _add = _internal_add_previoussessions(); - // @@protoc_insertion_point(field_add:proto.RecordStructure.previousSessions) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SessionStructure >& -RecordStructure::previoussessions() const { - // @@protoc_insertion_point(field_list:proto.RecordStructure.previousSessions) - return _impl_.previoussessions_; -} - -// ------------------------------------------------------------------- - -// SenderChainKey - -// optional uint32 iteration = 1; -inline bool SenderChainKey::_internal_has_iteration() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool SenderChainKey::has_iteration() const { - return _internal_has_iteration(); -} -inline void SenderChainKey::clear_iteration() { - _impl_.iteration_ = 0u; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline uint32_t SenderChainKey::_internal_iteration() const { - return _impl_.iteration_; -} -inline uint32_t SenderChainKey::iteration() const { - // @@protoc_insertion_point(field_get:proto.SenderChainKey.iteration) - return _internal_iteration(); -} -inline void SenderChainKey::_internal_set_iteration(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.iteration_ = value; -} -inline void SenderChainKey::set_iteration(uint32_t value) { - _internal_set_iteration(value); - // @@protoc_insertion_point(field_set:proto.SenderChainKey.iteration) -} - -// optional bytes seed = 2; -inline bool SenderChainKey::_internal_has_seed() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SenderChainKey::has_seed() const { - return _internal_has_seed(); -} -inline void SenderChainKey::clear_seed() { - _impl_.seed_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& SenderChainKey::seed() const { - // @@protoc_insertion_point(field_get:proto.SenderChainKey.seed) - return _internal_seed(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SenderChainKey::set_seed(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.seed_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SenderChainKey.seed) -} -inline std::string* SenderChainKey::mutable_seed() { - std::string* _s = _internal_mutable_seed(); - // @@protoc_insertion_point(field_mutable:proto.SenderChainKey.seed) - return _s; -} -inline const std::string& SenderChainKey::_internal_seed() const { - return _impl_.seed_.Get(); -} -inline void SenderChainKey::_internal_set_seed(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.seed_.Set(value, GetArenaForAllocation()); -} -inline std::string* SenderChainKey::_internal_mutable_seed() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.seed_.Mutable(GetArenaForAllocation()); -} -inline std::string* SenderChainKey::release_seed() { - // @@protoc_insertion_point(field_release:proto.SenderChainKey.seed) - if (!_internal_has_seed()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.seed_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.seed_.IsDefault()) { - _impl_.seed_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SenderChainKey::set_allocated_seed(std::string* seed) { - if (seed != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.seed_.SetAllocated(seed, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.seed_.IsDefault()) { - _impl_.seed_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SenderChainKey.seed) -} - -// ------------------------------------------------------------------- - -// SenderKeyRecordStructure - -// repeated .proto.SenderKeyStateStructure senderKeyStates = 1; -inline int SenderKeyRecordStructure::_internal_senderkeystates_size() const { - return _impl_.senderkeystates_.size(); -} -inline int SenderKeyRecordStructure::senderkeystates_size() const { - return _internal_senderkeystates_size(); -} -inline void SenderKeyRecordStructure::clear_senderkeystates() { - _impl_.senderkeystates_.Clear(); -} -inline ::proto::SenderKeyStateStructure* SenderKeyRecordStructure::mutable_senderkeystates(int index) { - // @@protoc_insertion_point(field_mutable:proto.SenderKeyRecordStructure.senderKeyStates) - return _impl_.senderkeystates_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderKeyStateStructure >* -SenderKeyRecordStructure::mutable_senderkeystates() { - // @@protoc_insertion_point(field_mutable_list:proto.SenderKeyRecordStructure.senderKeyStates) - return &_impl_.senderkeystates_; -} -inline const ::proto::SenderKeyStateStructure& SenderKeyRecordStructure::_internal_senderkeystates(int index) const { - return _impl_.senderkeystates_.Get(index); -} -inline const ::proto::SenderKeyStateStructure& SenderKeyRecordStructure::senderkeystates(int index) const { - // @@protoc_insertion_point(field_get:proto.SenderKeyRecordStructure.senderKeyStates) - return _internal_senderkeystates(index); -} -inline ::proto::SenderKeyStateStructure* SenderKeyRecordStructure::_internal_add_senderkeystates() { - return _impl_.senderkeystates_.Add(); -} -inline ::proto::SenderKeyStateStructure* SenderKeyRecordStructure::add_senderkeystates() { - ::proto::SenderKeyStateStructure* _add = _internal_add_senderkeystates(); - // @@protoc_insertion_point(field_add:proto.SenderKeyRecordStructure.senderKeyStates) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderKeyStateStructure >& -SenderKeyRecordStructure::senderkeystates() const { - // @@protoc_insertion_point(field_list:proto.SenderKeyRecordStructure.senderKeyStates) - return _impl_.senderkeystates_; -} - -// ------------------------------------------------------------------- - -// SenderKeyStateStructure - -// optional uint32 senderKeyId = 1; -inline bool SenderKeyStateStructure::_internal_has_senderkeyid() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool SenderKeyStateStructure::has_senderkeyid() const { - return _internal_has_senderkeyid(); -} -inline void SenderKeyStateStructure::clear_senderkeyid() { - _impl_.senderkeyid_ = 0u; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline uint32_t SenderKeyStateStructure::_internal_senderkeyid() const { - return _impl_.senderkeyid_; -} -inline uint32_t SenderKeyStateStructure::senderkeyid() const { - // @@protoc_insertion_point(field_get:proto.SenderKeyStateStructure.senderKeyId) - return _internal_senderkeyid(); -} -inline void SenderKeyStateStructure::_internal_set_senderkeyid(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.senderkeyid_ = value; -} -inline void SenderKeyStateStructure::set_senderkeyid(uint32_t value) { - _internal_set_senderkeyid(value); - // @@protoc_insertion_point(field_set:proto.SenderKeyStateStructure.senderKeyId) -} - -// optional .proto.SenderChainKey senderChainKey = 2; -inline bool SenderKeyStateStructure::_internal_has_senderchainkey() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.senderchainkey_ != nullptr); - return value; -} -inline bool SenderKeyStateStructure::has_senderchainkey() const { - return _internal_has_senderchainkey(); -} -inline void SenderKeyStateStructure::clear_senderchainkey() { - if (_impl_.senderchainkey_ != nullptr) _impl_.senderchainkey_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::SenderChainKey& SenderKeyStateStructure::_internal_senderchainkey() const { - const ::proto::SenderChainKey* p = _impl_.senderchainkey_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SenderChainKey_default_instance_); -} -inline const ::proto::SenderChainKey& SenderKeyStateStructure::senderchainkey() const { - // @@protoc_insertion_point(field_get:proto.SenderKeyStateStructure.senderChainKey) - return _internal_senderchainkey(); -} -inline void SenderKeyStateStructure::unsafe_arena_set_allocated_senderchainkey( - ::proto::SenderChainKey* senderchainkey) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.senderchainkey_); - } - _impl_.senderchainkey_ = senderchainkey; - if (senderchainkey) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SenderKeyStateStructure.senderChainKey) -} -inline ::proto::SenderChainKey* SenderKeyStateStructure::release_senderchainkey() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::SenderChainKey* temp = _impl_.senderchainkey_; - _impl_.senderchainkey_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SenderChainKey* SenderKeyStateStructure::unsafe_arena_release_senderchainkey() { - // @@protoc_insertion_point(field_release:proto.SenderKeyStateStructure.senderChainKey) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::SenderChainKey* temp = _impl_.senderchainkey_; - _impl_.senderchainkey_ = nullptr; - return temp; -} -inline ::proto::SenderChainKey* SenderKeyStateStructure::_internal_mutable_senderchainkey() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.senderchainkey_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SenderChainKey>(GetArenaForAllocation()); - _impl_.senderchainkey_ = p; - } - return _impl_.senderchainkey_; -} -inline ::proto::SenderChainKey* SenderKeyStateStructure::mutable_senderchainkey() { - ::proto::SenderChainKey* _msg = _internal_mutable_senderchainkey(); - // @@protoc_insertion_point(field_mutable:proto.SenderKeyStateStructure.senderChainKey) - return _msg; -} -inline void SenderKeyStateStructure::set_allocated_senderchainkey(::proto::SenderChainKey* senderchainkey) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.senderchainkey_; - } - if (senderchainkey) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(senderchainkey); - if (message_arena != submessage_arena) { - senderchainkey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, senderchainkey, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.senderchainkey_ = senderchainkey; - // @@protoc_insertion_point(field_set_allocated:proto.SenderKeyStateStructure.senderChainKey) -} - -// optional .proto.SenderSigningKey senderSigningKey = 3; -inline bool SenderKeyStateStructure::_internal_has_sendersigningkey() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.sendersigningkey_ != nullptr); - return value; -} -inline bool SenderKeyStateStructure::has_sendersigningkey() const { - return _internal_has_sendersigningkey(); -} -inline void SenderKeyStateStructure::clear_sendersigningkey() { - if (_impl_.sendersigningkey_ != nullptr) _impl_.sendersigningkey_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::SenderSigningKey& SenderKeyStateStructure::_internal_sendersigningkey() const { - const ::proto::SenderSigningKey* p = _impl_.sendersigningkey_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SenderSigningKey_default_instance_); -} -inline const ::proto::SenderSigningKey& SenderKeyStateStructure::sendersigningkey() const { - // @@protoc_insertion_point(field_get:proto.SenderKeyStateStructure.senderSigningKey) - return _internal_sendersigningkey(); -} -inline void SenderKeyStateStructure::unsafe_arena_set_allocated_sendersigningkey( - ::proto::SenderSigningKey* sendersigningkey) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.sendersigningkey_); - } - _impl_.sendersigningkey_ = sendersigningkey; - if (sendersigningkey) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SenderKeyStateStructure.senderSigningKey) -} -inline ::proto::SenderSigningKey* SenderKeyStateStructure::release_sendersigningkey() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::SenderSigningKey* temp = _impl_.sendersigningkey_; - _impl_.sendersigningkey_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SenderSigningKey* SenderKeyStateStructure::unsafe_arena_release_sendersigningkey() { - // @@protoc_insertion_point(field_release:proto.SenderKeyStateStructure.senderSigningKey) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::SenderSigningKey* temp = _impl_.sendersigningkey_; - _impl_.sendersigningkey_ = nullptr; - return temp; -} -inline ::proto::SenderSigningKey* SenderKeyStateStructure::_internal_mutable_sendersigningkey() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.sendersigningkey_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SenderSigningKey>(GetArenaForAllocation()); - _impl_.sendersigningkey_ = p; - } - return _impl_.sendersigningkey_; -} -inline ::proto::SenderSigningKey* SenderKeyStateStructure::mutable_sendersigningkey() { - ::proto::SenderSigningKey* _msg = _internal_mutable_sendersigningkey(); - // @@protoc_insertion_point(field_mutable:proto.SenderKeyStateStructure.senderSigningKey) - return _msg; -} -inline void SenderKeyStateStructure::set_allocated_sendersigningkey(::proto::SenderSigningKey* sendersigningkey) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.sendersigningkey_; - } - if (sendersigningkey) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(sendersigningkey); - if (message_arena != submessage_arena) { - sendersigningkey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, sendersigningkey, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.sendersigningkey_ = sendersigningkey; - // @@protoc_insertion_point(field_set_allocated:proto.SenderKeyStateStructure.senderSigningKey) -} - -// repeated .proto.SenderMessageKey senderMessageKeys = 4; -inline int SenderKeyStateStructure::_internal_sendermessagekeys_size() const { - return _impl_.sendermessagekeys_.size(); -} -inline int SenderKeyStateStructure::sendermessagekeys_size() const { - return _internal_sendermessagekeys_size(); -} -inline void SenderKeyStateStructure::clear_sendermessagekeys() { - _impl_.sendermessagekeys_.Clear(); -} -inline ::proto::SenderMessageKey* SenderKeyStateStructure::mutable_sendermessagekeys(int index) { - // @@protoc_insertion_point(field_mutable:proto.SenderKeyStateStructure.senderMessageKeys) - return _impl_.sendermessagekeys_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderMessageKey >* -SenderKeyStateStructure::mutable_sendermessagekeys() { - // @@protoc_insertion_point(field_mutable_list:proto.SenderKeyStateStructure.senderMessageKeys) - return &_impl_.sendermessagekeys_; -} -inline const ::proto::SenderMessageKey& SenderKeyStateStructure::_internal_sendermessagekeys(int index) const { - return _impl_.sendermessagekeys_.Get(index); -} -inline const ::proto::SenderMessageKey& SenderKeyStateStructure::sendermessagekeys(int index) const { - // @@protoc_insertion_point(field_get:proto.SenderKeyStateStructure.senderMessageKeys) - return _internal_sendermessagekeys(index); -} -inline ::proto::SenderMessageKey* SenderKeyStateStructure::_internal_add_sendermessagekeys() { - return _impl_.sendermessagekeys_.Add(); -} -inline ::proto::SenderMessageKey* SenderKeyStateStructure::add_sendermessagekeys() { - ::proto::SenderMessageKey* _add = _internal_add_sendermessagekeys(); - // @@protoc_insertion_point(field_add:proto.SenderKeyStateStructure.senderMessageKeys) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderMessageKey >& -SenderKeyStateStructure::sendermessagekeys() const { - // @@protoc_insertion_point(field_list:proto.SenderKeyStateStructure.senderMessageKeys) - return _impl_.sendermessagekeys_; -} - -// ------------------------------------------------------------------- - -// SenderMessageKey - -// optional uint32 iteration = 1; -inline bool SenderMessageKey::_internal_has_iteration() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool SenderMessageKey::has_iteration() const { - return _internal_has_iteration(); -} -inline void SenderMessageKey::clear_iteration() { - _impl_.iteration_ = 0u; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline uint32_t SenderMessageKey::_internal_iteration() const { - return _impl_.iteration_; -} -inline uint32_t SenderMessageKey::iteration() const { - // @@protoc_insertion_point(field_get:proto.SenderMessageKey.iteration) - return _internal_iteration(); -} -inline void SenderMessageKey::_internal_set_iteration(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.iteration_ = value; -} -inline void SenderMessageKey::set_iteration(uint32_t value) { - _internal_set_iteration(value); - // @@protoc_insertion_point(field_set:proto.SenderMessageKey.iteration) -} - -// optional bytes seed = 2; -inline bool SenderMessageKey::_internal_has_seed() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SenderMessageKey::has_seed() const { - return _internal_has_seed(); -} -inline void SenderMessageKey::clear_seed() { - _impl_.seed_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& SenderMessageKey::seed() const { - // @@protoc_insertion_point(field_get:proto.SenderMessageKey.seed) - return _internal_seed(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SenderMessageKey::set_seed(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.seed_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SenderMessageKey.seed) -} -inline std::string* SenderMessageKey::mutable_seed() { - std::string* _s = _internal_mutable_seed(); - // @@protoc_insertion_point(field_mutable:proto.SenderMessageKey.seed) - return _s; -} -inline const std::string& SenderMessageKey::_internal_seed() const { - return _impl_.seed_.Get(); -} -inline void SenderMessageKey::_internal_set_seed(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.seed_.Set(value, GetArenaForAllocation()); -} -inline std::string* SenderMessageKey::_internal_mutable_seed() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.seed_.Mutable(GetArenaForAllocation()); -} -inline std::string* SenderMessageKey::release_seed() { - // @@protoc_insertion_point(field_release:proto.SenderMessageKey.seed) - if (!_internal_has_seed()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.seed_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.seed_.IsDefault()) { - _impl_.seed_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SenderMessageKey::set_allocated_seed(std::string* seed) { - if (seed != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.seed_.SetAllocated(seed, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.seed_.IsDefault()) { - _impl_.seed_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SenderMessageKey.seed) -} - -// ------------------------------------------------------------------- - -// SenderSigningKey - -// optional bytes public = 1; -inline bool SenderSigningKey::_internal_has_public_() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SenderSigningKey::has_public_() const { - return _internal_has_public_(); -} -inline void SenderSigningKey::clear_public_() { - _impl_.public__.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& SenderSigningKey::public_() const { - // @@protoc_insertion_point(field_get:proto.SenderSigningKey.public) - return _internal_public_(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SenderSigningKey::set_public_(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.public__.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SenderSigningKey.public) -} -inline std::string* SenderSigningKey::mutable_public_() { - std::string* _s = _internal_mutable_public_(); - // @@protoc_insertion_point(field_mutable:proto.SenderSigningKey.public) - return _s; -} -inline const std::string& SenderSigningKey::_internal_public_() const { - return _impl_.public__.Get(); -} -inline void SenderSigningKey::_internal_set_public_(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.public__.Set(value, GetArenaForAllocation()); -} -inline std::string* SenderSigningKey::_internal_mutable_public_() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.public__.Mutable(GetArenaForAllocation()); -} -inline std::string* SenderSigningKey::release_public_() { - // @@protoc_insertion_point(field_release:proto.SenderSigningKey.public) - if (!_internal_has_public_()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.public__.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.public__.IsDefault()) { - _impl_.public__.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SenderSigningKey::set_allocated_public_(std::string* public_) { - if (public_ != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.public__.SetAllocated(public_, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.public__.IsDefault()) { - _impl_.public__.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SenderSigningKey.public) -} - -// optional bytes private = 2; -inline bool SenderSigningKey::_internal_has_private_() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool SenderSigningKey::has_private_() const { - return _internal_has_private_(); -} -inline void SenderSigningKey::clear_private_() { - _impl_.private__.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& SenderSigningKey::private_() const { - // @@protoc_insertion_point(field_get:proto.SenderSigningKey.private) - return _internal_private_(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SenderSigningKey::set_private_(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.private__.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SenderSigningKey.private) -} -inline std::string* SenderSigningKey::mutable_private_() { - std::string* _s = _internal_mutable_private_(); - // @@protoc_insertion_point(field_mutable:proto.SenderSigningKey.private) - return _s; -} -inline const std::string& SenderSigningKey::_internal_private_() const { - return _impl_.private__.Get(); -} -inline void SenderSigningKey::_internal_set_private_(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.private__.Set(value, GetArenaForAllocation()); -} -inline std::string* SenderSigningKey::_internal_mutable_private_() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.private__.Mutable(GetArenaForAllocation()); -} -inline std::string* SenderSigningKey::release_private_() { - // @@protoc_insertion_point(field_release:proto.SenderSigningKey.private) - if (!_internal_has_private_()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.private__.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.private__.IsDefault()) { - _impl_.private__.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SenderSigningKey::set_allocated_private_(std::string* private_) { - if (private_ != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.private__.SetAllocated(private_, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.private__.IsDefault()) { - _impl_.private__.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SenderSigningKey.private) -} - -// ------------------------------------------------------------------- - -// ServerErrorReceipt - -// optional string stanzaId = 1; -inline bool ServerErrorReceipt::_internal_has_stanzaid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool ServerErrorReceipt::has_stanzaid() const { - return _internal_has_stanzaid(); -} -inline void ServerErrorReceipt::clear_stanzaid() { - _impl_.stanzaid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& ServerErrorReceipt::stanzaid() const { - // @@protoc_insertion_point(field_get:proto.ServerErrorReceipt.stanzaId) - return _internal_stanzaid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ServerErrorReceipt::set_stanzaid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.stanzaid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.ServerErrorReceipt.stanzaId) -} -inline std::string* ServerErrorReceipt::mutable_stanzaid() { - std::string* _s = _internal_mutable_stanzaid(); - // @@protoc_insertion_point(field_mutable:proto.ServerErrorReceipt.stanzaId) - return _s; -} -inline const std::string& ServerErrorReceipt::_internal_stanzaid() const { - return _impl_.stanzaid_.Get(); -} -inline void ServerErrorReceipt::_internal_set_stanzaid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.stanzaid_.Set(value, GetArenaForAllocation()); -} -inline std::string* ServerErrorReceipt::_internal_mutable_stanzaid() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.stanzaid_.Mutable(GetArenaForAllocation()); -} -inline std::string* ServerErrorReceipt::release_stanzaid() { - // @@protoc_insertion_point(field_release:proto.ServerErrorReceipt.stanzaId) - if (!_internal_has_stanzaid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.stanzaid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.stanzaid_.IsDefault()) { - _impl_.stanzaid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void ServerErrorReceipt::set_allocated_stanzaid(std::string* stanzaid) { - if (stanzaid != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.stanzaid_.SetAllocated(stanzaid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.stanzaid_.IsDefault()) { - _impl_.stanzaid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.ServerErrorReceipt.stanzaId) -} - -// ------------------------------------------------------------------- - -// SessionStructure - -// optional uint32 sessionVersion = 1; -inline bool SessionStructure::_internal_has_sessionversion() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - return value; -} -inline bool SessionStructure::has_sessionversion() const { - return _internal_has_sessionversion(); -} -inline void SessionStructure::clear_sessionversion() { - _impl_.sessionversion_ = 0u; - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline uint32_t SessionStructure::_internal_sessionversion() const { - return _impl_.sessionversion_; -} -inline uint32_t SessionStructure::sessionversion() const { - // @@protoc_insertion_point(field_get:proto.SessionStructure.sessionVersion) - return _internal_sessionversion(); -} -inline void SessionStructure::_internal_set_sessionversion(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.sessionversion_ = value; -} -inline void SessionStructure::set_sessionversion(uint32_t value) { - _internal_set_sessionversion(value); - // @@protoc_insertion_point(field_set:proto.SessionStructure.sessionVersion) -} - -// optional bytes localIdentityPublic = 2; -inline bool SessionStructure::_internal_has_localidentitypublic() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SessionStructure::has_localidentitypublic() const { - return _internal_has_localidentitypublic(); -} -inline void SessionStructure::clear_localidentitypublic() { - _impl_.localidentitypublic_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& SessionStructure::localidentitypublic() const { - // @@protoc_insertion_point(field_get:proto.SessionStructure.localIdentityPublic) - return _internal_localidentitypublic(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SessionStructure::set_localidentitypublic(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.localidentitypublic_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SessionStructure.localIdentityPublic) -} -inline std::string* SessionStructure::mutable_localidentitypublic() { - std::string* _s = _internal_mutable_localidentitypublic(); - // @@protoc_insertion_point(field_mutable:proto.SessionStructure.localIdentityPublic) - return _s; -} -inline const std::string& SessionStructure::_internal_localidentitypublic() const { - return _impl_.localidentitypublic_.Get(); -} -inline void SessionStructure::_internal_set_localidentitypublic(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.localidentitypublic_.Set(value, GetArenaForAllocation()); -} -inline std::string* SessionStructure::_internal_mutable_localidentitypublic() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.localidentitypublic_.Mutable(GetArenaForAllocation()); -} -inline std::string* SessionStructure::release_localidentitypublic() { - // @@protoc_insertion_point(field_release:proto.SessionStructure.localIdentityPublic) - if (!_internal_has_localidentitypublic()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.localidentitypublic_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.localidentitypublic_.IsDefault()) { - _impl_.localidentitypublic_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SessionStructure::set_allocated_localidentitypublic(std::string* localidentitypublic) { - if (localidentitypublic != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.localidentitypublic_.SetAllocated(localidentitypublic, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.localidentitypublic_.IsDefault()) { - _impl_.localidentitypublic_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SessionStructure.localIdentityPublic) -} - -// optional bytes remoteIdentityPublic = 3; -inline bool SessionStructure::_internal_has_remoteidentitypublic() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool SessionStructure::has_remoteidentitypublic() const { - return _internal_has_remoteidentitypublic(); -} -inline void SessionStructure::clear_remoteidentitypublic() { - _impl_.remoteidentitypublic_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& SessionStructure::remoteidentitypublic() const { - // @@protoc_insertion_point(field_get:proto.SessionStructure.remoteIdentityPublic) - return _internal_remoteidentitypublic(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SessionStructure::set_remoteidentitypublic(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.remoteidentitypublic_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SessionStructure.remoteIdentityPublic) -} -inline std::string* SessionStructure::mutable_remoteidentitypublic() { - std::string* _s = _internal_mutable_remoteidentitypublic(); - // @@protoc_insertion_point(field_mutable:proto.SessionStructure.remoteIdentityPublic) - return _s; -} -inline const std::string& SessionStructure::_internal_remoteidentitypublic() const { - return _impl_.remoteidentitypublic_.Get(); -} -inline void SessionStructure::_internal_set_remoteidentitypublic(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.remoteidentitypublic_.Set(value, GetArenaForAllocation()); -} -inline std::string* SessionStructure::_internal_mutable_remoteidentitypublic() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.remoteidentitypublic_.Mutable(GetArenaForAllocation()); -} -inline std::string* SessionStructure::release_remoteidentitypublic() { - // @@protoc_insertion_point(field_release:proto.SessionStructure.remoteIdentityPublic) - if (!_internal_has_remoteidentitypublic()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.remoteidentitypublic_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.remoteidentitypublic_.IsDefault()) { - _impl_.remoteidentitypublic_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SessionStructure::set_allocated_remoteidentitypublic(std::string* remoteidentitypublic) { - if (remoteidentitypublic != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.remoteidentitypublic_.SetAllocated(remoteidentitypublic, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.remoteidentitypublic_.IsDefault()) { - _impl_.remoteidentitypublic_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SessionStructure.remoteIdentityPublic) -} - -// optional bytes rootKey = 4; -inline bool SessionStructure::_internal_has_rootkey() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool SessionStructure::has_rootkey() const { - return _internal_has_rootkey(); -} -inline void SessionStructure::clear_rootkey() { - _impl_.rootkey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& SessionStructure::rootkey() const { - // @@protoc_insertion_point(field_get:proto.SessionStructure.rootKey) - return _internal_rootkey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SessionStructure::set_rootkey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.rootkey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SessionStructure.rootKey) -} -inline std::string* SessionStructure::mutable_rootkey() { - std::string* _s = _internal_mutable_rootkey(); - // @@protoc_insertion_point(field_mutable:proto.SessionStructure.rootKey) - return _s; -} -inline const std::string& SessionStructure::_internal_rootkey() const { - return _impl_.rootkey_.Get(); -} -inline void SessionStructure::_internal_set_rootkey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.rootkey_.Set(value, GetArenaForAllocation()); -} -inline std::string* SessionStructure::_internal_mutable_rootkey() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.rootkey_.Mutable(GetArenaForAllocation()); -} -inline std::string* SessionStructure::release_rootkey() { - // @@protoc_insertion_point(field_release:proto.SessionStructure.rootKey) - if (!_internal_has_rootkey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.rootkey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.rootkey_.IsDefault()) { - _impl_.rootkey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SessionStructure::set_allocated_rootkey(std::string* rootkey) { - if (rootkey != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.rootkey_.SetAllocated(rootkey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.rootkey_.IsDefault()) { - _impl_.rootkey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SessionStructure.rootKey) -} - -// optional uint32 previousCounter = 5; -inline bool SessionStructure::_internal_has_previouscounter() const { - bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; - return value; -} -inline bool SessionStructure::has_previouscounter() const { - return _internal_has_previouscounter(); -} -inline void SessionStructure::clear_previouscounter() { - _impl_.previouscounter_ = 0u; - _impl_._has_bits_[0] &= ~0x00000100u; -} -inline uint32_t SessionStructure::_internal_previouscounter() const { - return _impl_.previouscounter_; -} -inline uint32_t SessionStructure::previouscounter() const { - // @@protoc_insertion_point(field_get:proto.SessionStructure.previousCounter) - return _internal_previouscounter(); -} -inline void SessionStructure::_internal_set_previouscounter(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000100u; - _impl_.previouscounter_ = value; -} -inline void SessionStructure::set_previouscounter(uint32_t value) { - _internal_set_previouscounter(value); - // @@protoc_insertion_point(field_set:proto.SessionStructure.previousCounter) -} - -// optional .proto.Chain senderChain = 6; -inline bool SessionStructure::_internal_has_senderchain() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - PROTOBUF_ASSUME(!value || _impl_.senderchain_ != nullptr); - return value; -} -inline bool SessionStructure::has_senderchain() const { - return _internal_has_senderchain(); -} -inline void SessionStructure::clear_senderchain() { - if (_impl_.senderchain_ != nullptr) _impl_.senderchain_->Clear(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const ::proto::Chain& SessionStructure::_internal_senderchain() const { - const ::proto::Chain* p = _impl_.senderchain_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Chain_default_instance_); -} -inline const ::proto::Chain& SessionStructure::senderchain() const { - // @@protoc_insertion_point(field_get:proto.SessionStructure.senderChain) - return _internal_senderchain(); -} -inline void SessionStructure::unsafe_arena_set_allocated_senderchain( - ::proto::Chain* senderchain) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.senderchain_); - } - _impl_.senderchain_ = senderchain; - if (senderchain) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SessionStructure.senderChain) -} -inline ::proto::Chain* SessionStructure::release_senderchain() { - _impl_._has_bits_[0] &= ~0x00000010u; - ::proto::Chain* temp = _impl_.senderchain_; - _impl_.senderchain_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Chain* SessionStructure::unsafe_arena_release_senderchain() { - // @@protoc_insertion_point(field_release:proto.SessionStructure.senderChain) - _impl_._has_bits_[0] &= ~0x00000010u; - ::proto::Chain* temp = _impl_.senderchain_; - _impl_.senderchain_ = nullptr; - return temp; -} -inline ::proto::Chain* SessionStructure::_internal_mutable_senderchain() { - _impl_._has_bits_[0] |= 0x00000010u; - if (_impl_.senderchain_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Chain>(GetArenaForAllocation()); - _impl_.senderchain_ = p; - } - return _impl_.senderchain_; -} -inline ::proto::Chain* SessionStructure::mutable_senderchain() { - ::proto::Chain* _msg = _internal_mutable_senderchain(); - // @@protoc_insertion_point(field_mutable:proto.SessionStructure.senderChain) - return _msg; -} -inline void SessionStructure::set_allocated_senderchain(::proto::Chain* senderchain) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.senderchain_; - } - if (senderchain) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(senderchain); - if (message_arena != submessage_arena) { - senderchain = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, senderchain, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.senderchain_ = senderchain; - // @@protoc_insertion_point(field_set_allocated:proto.SessionStructure.senderChain) -} - -// repeated .proto.Chain receiverChains = 7; -inline int SessionStructure::_internal_receiverchains_size() const { - return _impl_.receiverchains_.size(); -} -inline int SessionStructure::receiverchains_size() const { - return _internal_receiverchains_size(); -} -inline void SessionStructure::clear_receiverchains() { - _impl_.receiverchains_.Clear(); -} -inline ::proto::Chain* SessionStructure::mutable_receiverchains(int index) { - // @@protoc_insertion_point(field_mutable:proto.SessionStructure.receiverChains) - return _impl_.receiverchains_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Chain >* -SessionStructure::mutable_receiverchains() { - // @@protoc_insertion_point(field_mutable_list:proto.SessionStructure.receiverChains) - return &_impl_.receiverchains_; -} -inline const ::proto::Chain& SessionStructure::_internal_receiverchains(int index) const { - return _impl_.receiverchains_.Get(index); -} -inline const ::proto::Chain& SessionStructure::receiverchains(int index) const { - // @@protoc_insertion_point(field_get:proto.SessionStructure.receiverChains) - return _internal_receiverchains(index); -} -inline ::proto::Chain* SessionStructure::_internal_add_receiverchains() { - return _impl_.receiverchains_.Add(); -} -inline ::proto::Chain* SessionStructure::add_receiverchains() { - ::proto::Chain* _add = _internal_add_receiverchains(); - // @@protoc_insertion_point(field_add:proto.SessionStructure.receiverChains) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Chain >& -SessionStructure::receiverchains() const { - // @@protoc_insertion_point(field_list:proto.SessionStructure.receiverChains) - return _impl_.receiverchains_; -} - -// optional .proto.PendingKeyExchange pendingKeyExchange = 8; -inline bool SessionStructure::_internal_has_pendingkeyexchange() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - PROTOBUF_ASSUME(!value || _impl_.pendingkeyexchange_ != nullptr); - return value; -} -inline bool SessionStructure::has_pendingkeyexchange() const { - return _internal_has_pendingkeyexchange(); -} -inline void SessionStructure::clear_pendingkeyexchange() { - if (_impl_.pendingkeyexchange_ != nullptr) _impl_.pendingkeyexchange_->Clear(); - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline const ::proto::PendingKeyExchange& SessionStructure::_internal_pendingkeyexchange() const { - const ::proto::PendingKeyExchange* p = _impl_.pendingkeyexchange_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_PendingKeyExchange_default_instance_); -} -inline const ::proto::PendingKeyExchange& SessionStructure::pendingkeyexchange() const { - // @@protoc_insertion_point(field_get:proto.SessionStructure.pendingKeyExchange) - return _internal_pendingkeyexchange(); -} -inline void SessionStructure::unsafe_arena_set_allocated_pendingkeyexchange( - ::proto::PendingKeyExchange* pendingkeyexchange) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pendingkeyexchange_); - } - _impl_.pendingkeyexchange_ = pendingkeyexchange; - if (pendingkeyexchange) { - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SessionStructure.pendingKeyExchange) -} -inline ::proto::PendingKeyExchange* SessionStructure::release_pendingkeyexchange() { - _impl_._has_bits_[0] &= ~0x00000020u; - ::proto::PendingKeyExchange* temp = _impl_.pendingkeyexchange_; - _impl_.pendingkeyexchange_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::PendingKeyExchange* SessionStructure::unsafe_arena_release_pendingkeyexchange() { - // @@protoc_insertion_point(field_release:proto.SessionStructure.pendingKeyExchange) - _impl_._has_bits_[0] &= ~0x00000020u; - ::proto::PendingKeyExchange* temp = _impl_.pendingkeyexchange_; - _impl_.pendingkeyexchange_ = nullptr; - return temp; -} -inline ::proto::PendingKeyExchange* SessionStructure::_internal_mutable_pendingkeyexchange() { - _impl_._has_bits_[0] |= 0x00000020u; - if (_impl_.pendingkeyexchange_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::PendingKeyExchange>(GetArenaForAllocation()); - _impl_.pendingkeyexchange_ = p; - } - return _impl_.pendingkeyexchange_; -} -inline ::proto::PendingKeyExchange* SessionStructure::mutable_pendingkeyexchange() { - ::proto::PendingKeyExchange* _msg = _internal_mutable_pendingkeyexchange(); - // @@protoc_insertion_point(field_mutable:proto.SessionStructure.pendingKeyExchange) - return _msg; -} -inline void SessionStructure::set_allocated_pendingkeyexchange(::proto::PendingKeyExchange* pendingkeyexchange) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.pendingkeyexchange_; - } - if (pendingkeyexchange) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pendingkeyexchange); - if (message_arena != submessage_arena) { - pendingkeyexchange = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, pendingkeyexchange, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - _impl_.pendingkeyexchange_ = pendingkeyexchange; - // @@protoc_insertion_point(field_set_allocated:proto.SessionStructure.pendingKeyExchange) -} - -// optional .proto.PendingPreKey pendingPreKey = 9; -inline bool SessionStructure::_internal_has_pendingprekey() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - PROTOBUF_ASSUME(!value || _impl_.pendingprekey_ != nullptr); - return value; -} -inline bool SessionStructure::has_pendingprekey() const { - return _internal_has_pendingprekey(); -} -inline void SessionStructure::clear_pendingprekey() { - if (_impl_.pendingprekey_ != nullptr) _impl_.pendingprekey_->Clear(); - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline const ::proto::PendingPreKey& SessionStructure::_internal_pendingprekey() const { - const ::proto::PendingPreKey* p = _impl_.pendingprekey_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_PendingPreKey_default_instance_); -} -inline const ::proto::PendingPreKey& SessionStructure::pendingprekey() const { - // @@protoc_insertion_point(field_get:proto.SessionStructure.pendingPreKey) - return _internal_pendingprekey(); -} -inline void SessionStructure::unsafe_arena_set_allocated_pendingprekey( - ::proto::PendingPreKey* pendingprekey) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pendingprekey_); - } - _impl_.pendingprekey_ = pendingprekey; - if (pendingprekey) { - _impl_._has_bits_[0] |= 0x00000040u; - } else { - _impl_._has_bits_[0] &= ~0x00000040u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SessionStructure.pendingPreKey) -} -inline ::proto::PendingPreKey* SessionStructure::release_pendingprekey() { - _impl_._has_bits_[0] &= ~0x00000040u; - ::proto::PendingPreKey* temp = _impl_.pendingprekey_; - _impl_.pendingprekey_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::PendingPreKey* SessionStructure::unsafe_arena_release_pendingprekey() { - // @@protoc_insertion_point(field_release:proto.SessionStructure.pendingPreKey) - _impl_._has_bits_[0] &= ~0x00000040u; - ::proto::PendingPreKey* temp = _impl_.pendingprekey_; - _impl_.pendingprekey_ = nullptr; - return temp; -} -inline ::proto::PendingPreKey* SessionStructure::_internal_mutable_pendingprekey() { - _impl_._has_bits_[0] |= 0x00000040u; - if (_impl_.pendingprekey_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::PendingPreKey>(GetArenaForAllocation()); - _impl_.pendingprekey_ = p; - } - return _impl_.pendingprekey_; -} -inline ::proto::PendingPreKey* SessionStructure::mutable_pendingprekey() { - ::proto::PendingPreKey* _msg = _internal_mutable_pendingprekey(); - // @@protoc_insertion_point(field_mutable:proto.SessionStructure.pendingPreKey) - return _msg; -} -inline void SessionStructure::set_allocated_pendingprekey(::proto::PendingPreKey* pendingprekey) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.pendingprekey_; - } - if (pendingprekey) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pendingprekey); - if (message_arena != submessage_arena) { - pendingprekey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, pendingprekey, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000040u; - } else { - _impl_._has_bits_[0] &= ~0x00000040u; - } - _impl_.pendingprekey_ = pendingprekey; - // @@protoc_insertion_point(field_set_allocated:proto.SessionStructure.pendingPreKey) -} - -// optional uint32 remoteRegistrationId = 10; -inline bool SessionStructure::_internal_has_remoteregistrationid() const { - bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; - return value; -} -inline bool SessionStructure::has_remoteregistrationid() const { - return _internal_has_remoteregistrationid(); -} -inline void SessionStructure::clear_remoteregistrationid() { - _impl_.remoteregistrationid_ = 0u; - _impl_._has_bits_[0] &= ~0x00000200u; -} -inline uint32_t SessionStructure::_internal_remoteregistrationid() const { - return _impl_.remoteregistrationid_; -} -inline uint32_t SessionStructure::remoteregistrationid() const { - // @@protoc_insertion_point(field_get:proto.SessionStructure.remoteRegistrationId) - return _internal_remoteregistrationid(); -} -inline void SessionStructure::_internal_set_remoteregistrationid(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.remoteregistrationid_ = value; -} -inline void SessionStructure::set_remoteregistrationid(uint32_t value) { - _internal_set_remoteregistrationid(value); - // @@protoc_insertion_point(field_set:proto.SessionStructure.remoteRegistrationId) -} - -// optional uint32 localRegistrationId = 11; -inline bool SessionStructure::_internal_has_localregistrationid() const { - bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; - return value; -} -inline bool SessionStructure::has_localregistrationid() const { - return _internal_has_localregistrationid(); -} -inline void SessionStructure::clear_localregistrationid() { - _impl_.localregistrationid_ = 0u; - _impl_._has_bits_[0] &= ~0x00000400u; -} -inline uint32_t SessionStructure::_internal_localregistrationid() const { - return _impl_.localregistrationid_; -} -inline uint32_t SessionStructure::localregistrationid() const { - // @@protoc_insertion_point(field_get:proto.SessionStructure.localRegistrationId) - return _internal_localregistrationid(); -} -inline void SessionStructure::_internal_set_localregistrationid(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000400u; - _impl_.localregistrationid_ = value; -} -inline void SessionStructure::set_localregistrationid(uint32_t value) { - _internal_set_localregistrationid(value); - // @@protoc_insertion_point(field_set:proto.SessionStructure.localRegistrationId) -} - -// optional bool needsRefresh = 12; -inline bool SessionStructure::_internal_has_needsrefresh() const { - bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; - return value; -} -inline bool SessionStructure::has_needsrefresh() const { - return _internal_has_needsrefresh(); -} -inline void SessionStructure::clear_needsrefresh() { - _impl_.needsrefresh_ = false; - _impl_._has_bits_[0] &= ~0x00000800u; -} -inline bool SessionStructure::_internal_needsrefresh() const { - return _impl_.needsrefresh_; -} -inline bool SessionStructure::needsrefresh() const { - // @@protoc_insertion_point(field_get:proto.SessionStructure.needsRefresh) - return _internal_needsrefresh(); -} -inline void SessionStructure::_internal_set_needsrefresh(bool value) { - _impl_._has_bits_[0] |= 0x00000800u; - _impl_.needsrefresh_ = value; -} -inline void SessionStructure::set_needsrefresh(bool value) { - _internal_set_needsrefresh(value); - // @@protoc_insertion_point(field_set:proto.SessionStructure.needsRefresh) -} - -// optional bytes aliceBaseKey = 13; -inline bool SessionStructure::_internal_has_alicebasekey() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool SessionStructure::has_alicebasekey() const { - return _internal_has_alicebasekey(); -} -inline void SessionStructure::clear_alicebasekey() { - _impl_.alicebasekey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const std::string& SessionStructure::alicebasekey() const { - // @@protoc_insertion_point(field_get:proto.SessionStructure.aliceBaseKey) - return _internal_alicebasekey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SessionStructure::set_alicebasekey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.alicebasekey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SessionStructure.aliceBaseKey) -} -inline std::string* SessionStructure::mutable_alicebasekey() { - std::string* _s = _internal_mutable_alicebasekey(); - // @@protoc_insertion_point(field_mutable:proto.SessionStructure.aliceBaseKey) - return _s; -} -inline const std::string& SessionStructure::_internal_alicebasekey() const { - return _impl_.alicebasekey_.Get(); -} -inline void SessionStructure::_internal_set_alicebasekey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.alicebasekey_.Set(value, GetArenaForAllocation()); -} -inline std::string* SessionStructure::_internal_mutable_alicebasekey() { - _impl_._has_bits_[0] |= 0x00000008u; - return _impl_.alicebasekey_.Mutable(GetArenaForAllocation()); -} -inline std::string* SessionStructure::release_alicebasekey() { - // @@protoc_insertion_point(field_release:proto.SessionStructure.aliceBaseKey) - if (!_internal_has_alicebasekey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000008u; - auto* p = _impl_.alicebasekey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.alicebasekey_.IsDefault()) { - _impl_.alicebasekey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SessionStructure::set_allocated_alicebasekey(std::string* alicebasekey) { - if (alicebasekey != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.alicebasekey_.SetAllocated(alicebasekey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.alicebasekey_.IsDefault()) { - _impl_.alicebasekey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SessionStructure.aliceBaseKey) -} - -// ------------------------------------------------------------------- - -// SignedPreKeyRecordStructure - -// optional uint32 id = 1; -inline bool SignedPreKeyRecordStructure::_internal_has_id() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool SignedPreKeyRecordStructure::has_id() const { - return _internal_has_id(); -} -inline void SignedPreKeyRecordStructure::clear_id() { - _impl_.id_ = 0u; - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline uint32_t SignedPreKeyRecordStructure::_internal_id() const { - return _impl_.id_; -} -inline uint32_t SignedPreKeyRecordStructure::id() const { - // @@protoc_insertion_point(field_get:proto.SignedPreKeyRecordStructure.id) - return _internal_id(); -} -inline void SignedPreKeyRecordStructure::_internal_set_id(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.id_ = value; -} -inline void SignedPreKeyRecordStructure::set_id(uint32_t value) { - _internal_set_id(value); - // @@protoc_insertion_point(field_set:proto.SignedPreKeyRecordStructure.id) -} - -// optional bytes publicKey = 2; -inline bool SignedPreKeyRecordStructure::_internal_has_publickey() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SignedPreKeyRecordStructure::has_publickey() const { - return _internal_has_publickey(); -} -inline void SignedPreKeyRecordStructure::clear_publickey() { - _impl_.publickey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& SignedPreKeyRecordStructure::publickey() const { - // @@protoc_insertion_point(field_get:proto.SignedPreKeyRecordStructure.publicKey) - return _internal_publickey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SignedPreKeyRecordStructure::set_publickey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.publickey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SignedPreKeyRecordStructure.publicKey) -} -inline std::string* SignedPreKeyRecordStructure::mutable_publickey() { - std::string* _s = _internal_mutable_publickey(); - // @@protoc_insertion_point(field_mutable:proto.SignedPreKeyRecordStructure.publicKey) - return _s; -} -inline const std::string& SignedPreKeyRecordStructure::_internal_publickey() const { - return _impl_.publickey_.Get(); -} -inline void SignedPreKeyRecordStructure::_internal_set_publickey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.publickey_.Set(value, GetArenaForAllocation()); -} -inline std::string* SignedPreKeyRecordStructure::_internal_mutable_publickey() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.publickey_.Mutable(GetArenaForAllocation()); -} -inline std::string* SignedPreKeyRecordStructure::release_publickey() { - // @@protoc_insertion_point(field_release:proto.SignedPreKeyRecordStructure.publicKey) - if (!_internal_has_publickey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.publickey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.publickey_.IsDefault()) { - _impl_.publickey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SignedPreKeyRecordStructure::set_allocated_publickey(std::string* publickey) { - if (publickey != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.publickey_.SetAllocated(publickey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.publickey_.IsDefault()) { - _impl_.publickey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SignedPreKeyRecordStructure.publicKey) -} - -// optional bytes privateKey = 3; -inline bool SignedPreKeyRecordStructure::_internal_has_privatekey() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool SignedPreKeyRecordStructure::has_privatekey() const { - return _internal_has_privatekey(); -} -inline void SignedPreKeyRecordStructure::clear_privatekey() { - _impl_.privatekey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& SignedPreKeyRecordStructure::privatekey() const { - // @@protoc_insertion_point(field_get:proto.SignedPreKeyRecordStructure.privateKey) - return _internal_privatekey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SignedPreKeyRecordStructure::set_privatekey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.privatekey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SignedPreKeyRecordStructure.privateKey) -} -inline std::string* SignedPreKeyRecordStructure::mutable_privatekey() { - std::string* _s = _internal_mutable_privatekey(); - // @@protoc_insertion_point(field_mutable:proto.SignedPreKeyRecordStructure.privateKey) - return _s; -} -inline const std::string& SignedPreKeyRecordStructure::_internal_privatekey() const { - return _impl_.privatekey_.Get(); -} -inline void SignedPreKeyRecordStructure::_internal_set_privatekey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.privatekey_.Set(value, GetArenaForAllocation()); -} -inline std::string* SignedPreKeyRecordStructure::_internal_mutable_privatekey() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.privatekey_.Mutable(GetArenaForAllocation()); -} -inline std::string* SignedPreKeyRecordStructure::release_privatekey() { - // @@protoc_insertion_point(field_release:proto.SignedPreKeyRecordStructure.privateKey) - if (!_internal_has_privatekey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.privatekey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.privatekey_.IsDefault()) { - _impl_.privatekey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SignedPreKeyRecordStructure::set_allocated_privatekey(std::string* privatekey) { - if (privatekey != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.privatekey_.SetAllocated(privatekey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.privatekey_.IsDefault()) { - _impl_.privatekey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SignedPreKeyRecordStructure.privateKey) -} - -// optional bytes signature = 4; -inline bool SignedPreKeyRecordStructure::_internal_has_signature() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool SignedPreKeyRecordStructure::has_signature() const { - return _internal_has_signature(); -} -inline void SignedPreKeyRecordStructure::clear_signature() { - _impl_.signature_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& SignedPreKeyRecordStructure::signature() const { - // @@protoc_insertion_point(field_get:proto.SignedPreKeyRecordStructure.signature) - return _internal_signature(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SignedPreKeyRecordStructure::set_signature(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.signature_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SignedPreKeyRecordStructure.signature) -} -inline std::string* SignedPreKeyRecordStructure::mutable_signature() { - std::string* _s = _internal_mutable_signature(); - // @@protoc_insertion_point(field_mutable:proto.SignedPreKeyRecordStructure.signature) - return _s; -} -inline const std::string& SignedPreKeyRecordStructure::_internal_signature() const { - return _impl_.signature_.Get(); -} -inline void SignedPreKeyRecordStructure::_internal_set_signature(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.signature_.Set(value, GetArenaForAllocation()); -} -inline std::string* SignedPreKeyRecordStructure::_internal_mutable_signature() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.signature_.Mutable(GetArenaForAllocation()); -} -inline std::string* SignedPreKeyRecordStructure::release_signature() { - // @@protoc_insertion_point(field_release:proto.SignedPreKeyRecordStructure.signature) - if (!_internal_has_signature()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.signature_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.signature_.IsDefault()) { - _impl_.signature_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SignedPreKeyRecordStructure::set_allocated_signature(std::string* signature) { - if (signature != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.signature_.SetAllocated(signature, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.signature_.IsDefault()) { - _impl_.signature_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SignedPreKeyRecordStructure.signature) -} - -// optional fixed64 timestamp = 5; -inline bool SignedPreKeyRecordStructure::_internal_has_timestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool SignedPreKeyRecordStructure::has_timestamp() const { - return _internal_has_timestamp(); -} -inline void SignedPreKeyRecordStructure::clear_timestamp() { - _impl_.timestamp_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline uint64_t SignedPreKeyRecordStructure::_internal_timestamp() const { - return _impl_.timestamp_; -} -inline uint64_t SignedPreKeyRecordStructure::timestamp() const { - // @@protoc_insertion_point(field_get:proto.SignedPreKeyRecordStructure.timestamp) - return _internal_timestamp(); -} -inline void SignedPreKeyRecordStructure::_internal_set_timestamp(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.timestamp_ = value; -} -inline void SignedPreKeyRecordStructure::set_timestamp(uint64_t value) { - _internal_set_timestamp(value); - // @@protoc_insertion_point(field_set:proto.SignedPreKeyRecordStructure.timestamp) -} - -// ------------------------------------------------------------------- - -// StatusPSA - -// required uint64 campaignId = 44; -inline bool StatusPSA::_internal_has_campaignid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool StatusPSA::has_campaignid() const { - return _internal_has_campaignid(); -} -inline void StatusPSA::clear_campaignid() { - _impl_.campaignid_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline uint64_t StatusPSA::_internal_campaignid() const { - return _impl_.campaignid_; -} -inline uint64_t StatusPSA::campaignid() const { - // @@protoc_insertion_point(field_get:proto.StatusPSA.campaignId) - return _internal_campaignid(); -} -inline void StatusPSA::_internal_set_campaignid(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.campaignid_ = value; -} -inline void StatusPSA::set_campaignid(uint64_t value) { - _internal_set_campaignid(value); - // @@protoc_insertion_point(field_set:proto.StatusPSA.campaignId) -} - -// optional uint64 campaignExpirationTimestamp = 45; -inline bool StatusPSA::_internal_has_campaignexpirationtimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool StatusPSA::has_campaignexpirationtimestamp() const { - return _internal_has_campaignexpirationtimestamp(); -} -inline void StatusPSA::clear_campaignexpirationtimestamp() { - _impl_.campaignexpirationtimestamp_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline uint64_t StatusPSA::_internal_campaignexpirationtimestamp() const { - return _impl_.campaignexpirationtimestamp_; -} -inline uint64_t StatusPSA::campaignexpirationtimestamp() const { - // @@protoc_insertion_point(field_get:proto.StatusPSA.campaignExpirationTimestamp) - return _internal_campaignexpirationtimestamp(); -} -inline void StatusPSA::_internal_set_campaignexpirationtimestamp(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.campaignexpirationtimestamp_ = value; -} -inline void StatusPSA::set_campaignexpirationtimestamp(uint64_t value) { - _internal_set_campaignexpirationtimestamp(value); - // @@protoc_insertion_point(field_set:proto.StatusPSA.campaignExpirationTimestamp) -} - -// ------------------------------------------------------------------- - -// StickerMetadata - -// optional string url = 1; -inline bool StickerMetadata::_internal_has_url() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool StickerMetadata::has_url() const { - return _internal_has_url(); -} -inline void StickerMetadata::clear_url() { - _impl_.url_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& StickerMetadata::url() const { - // @@protoc_insertion_point(field_get:proto.StickerMetadata.url) - return _internal_url(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void StickerMetadata::set_url(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.url_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.StickerMetadata.url) -} -inline std::string* StickerMetadata::mutable_url() { - std::string* _s = _internal_mutable_url(); - // @@protoc_insertion_point(field_mutable:proto.StickerMetadata.url) - return _s; -} -inline const std::string& StickerMetadata::_internal_url() const { - return _impl_.url_.Get(); -} -inline void StickerMetadata::_internal_set_url(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.url_.Set(value, GetArenaForAllocation()); -} -inline std::string* StickerMetadata::_internal_mutable_url() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.url_.Mutable(GetArenaForAllocation()); -} -inline std::string* StickerMetadata::release_url() { - // @@protoc_insertion_point(field_release:proto.StickerMetadata.url) - if (!_internal_has_url()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.url_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.url_.IsDefault()) { - _impl_.url_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void StickerMetadata::set_allocated_url(std::string* url) { - if (url != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.url_.SetAllocated(url, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.url_.IsDefault()) { - _impl_.url_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.StickerMetadata.url) -} - -// optional bytes fileSha256 = 2; -inline bool StickerMetadata::_internal_has_filesha256() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool StickerMetadata::has_filesha256() const { - return _internal_has_filesha256(); -} -inline void StickerMetadata::clear_filesha256() { - _impl_.filesha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& StickerMetadata::filesha256() const { - // @@protoc_insertion_point(field_get:proto.StickerMetadata.fileSha256) - return _internal_filesha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void StickerMetadata::set_filesha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.filesha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.StickerMetadata.fileSha256) -} -inline std::string* StickerMetadata::mutable_filesha256() { - std::string* _s = _internal_mutable_filesha256(); - // @@protoc_insertion_point(field_mutable:proto.StickerMetadata.fileSha256) - return _s; -} -inline const std::string& StickerMetadata::_internal_filesha256() const { - return _impl_.filesha256_.Get(); -} -inline void StickerMetadata::_internal_set_filesha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.filesha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* StickerMetadata::_internal_mutable_filesha256() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.filesha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* StickerMetadata::release_filesha256() { - // @@protoc_insertion_point(field_release:proto.StickerMetadata.fileSha256) - if (!_internal_has_filesha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.filesha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.filesha256_.IsDefault()) { - _impl_.filesha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void StickerMetadata::set_allocated_filesha256(std::string* filesha256) { - if (filesha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.filesha256_.IsDefault()) { - _impl_.filesha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.StickerMetadata.fileSha256) -} - -// optional bytes fileEncSha256 = 3; -inline bool StickerMetadata::_internal_has_fileencsha256() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool StickerMetadata::has_fileencsha256() const { - return _internal_has_fileencsha256(); -} -inline void StickerMetadata::clear_fileencsha256() { - _impl_.fileencsha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& StickerMetadata::fileencsha256() const { - // @@protoc_insertion_point(field_get:proto.StickerMetadata.fileEncSha256) - return _internal_fileencsha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void StickerMetadata::set_fileencsha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.fileencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.StickerMetadata.fileEncSha256) -} -inline std::string* StickerMetadata::mutable_fileencsha256() { - std::string* _s = _internal_mutable_fileencsha256(); - // @@protoc_insertion_point(field_mutable:proto.StickerMetadata.fileEncSha256) - return _s; -} -inline const std::string& StickerMetadata::_internal_fileencsha256() const { - return _impl_.fileencsha256_.Get(); -} -inline void StickerMetadata::_internal_set_fileencsha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.fileencsha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* StickerMetadata::_internal_mutable_fileencsha256() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.fileencsha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* StickerMetadata::release_fileencsha256() { - // @@protoc_insertion_point(field_release:proto.StickerMetadata.fileEncSha256) - if (!_internal_has_fileencsha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.fileencsha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fileencsha256_.IsDefault()) { - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void StickerMetadata::set_allocated_fileencsha256(std::string* fileencsha256) { - if (fileencsha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fileencsha256_.IsDefault()) { - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.StickerMetadata.fileEncSha256) -} - -// optional bytes mediaKey = 4; -inline bool StickerMetadata::_internal_has_mediakey() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool StickerMetadata::has_mediakey() const { - return _internal_has_mediakey(); -} -inline void StickerMetadata::clear_mediakey() { - _impl_.mediakey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const std::string& StickerMetadata::mediakey() const { - // @@protoc_insertion_point(field_get:proto.StickerMetadata.mediaKey) - return _internal_mediakey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void StickerMetadata::set_mediakey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.mediakey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.StickerMetadata.mediaKey) -} -inline std::string* StickerMetadata::mutable_mediakey() { - std::string* _s = _internal_mutable_mediakey(); - // @@protoc_insertion_point(field_mutable:proto.StickerMetadata.mediaKey) - return _s; -} -inline const std::string& StickerMetadata::_internal_mediakey() const { - return _impl_.mediakey_.Get(); -} -inline void StickerMetadata::_internal_set_mediakey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.mediakey_.Set(value, GetArenaForAllocation()); -} -inline std::string* StickerMetadata::_internal_mutable_mediakey() { - _impl_._has_bits_[0] |= 0x00000008u; - return _impl_.mediakey_.Mutable(GetArenaForAllocation()); -} -inline std::string* StickerMetadata::release_mediakey() { - // @@protoc_insertion_point(field_release:proto.StickerMetadata.mediaKey) - if (!_internal_has_mediakey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000008u; - auto* p = _impl_.mediakey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mediakey_.IsDefault()) { - _impl_.mediakey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void StickerMetadata::set_allocated_mediakey(std::string* mediakey) { - if (mediakey != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mediakey_.IsDefault()) { - _impl_.mediakey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.StickerMetadata.mediaKey) -} - -// optional string mimetype = 5; -inline bool StickerMetadata::_internal_has_mimetype() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool StickerMetadata::has_mimetype() const { - return _internal_has_mimetype(); -} -inline void StickerMetadata::clear_mimetype() { - _impl_.mimetype_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const std::string& StickerMetadata::mimetype() const { - // @@protoc_insertion_point(field_get:proto.StickerMetadata.mimetype) - return _internal_mimetype(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void StickerMetadata::set_mimetype(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.mimetype_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.StickerMetadata.mimetype) -} -inline std::string* StickerMetadata::mutable_mimetype() { - std::string* _s = _internal_mutable_mimetype(); - // @@protoc_insertion_point(field_mutable:proto.StickerMetadata.mimetype) - return _s; -} -inline const std::string& StickerMetadata::_internal_mimetype() const { - return _impl_.mimetype_.Get(); -} -inline void StickerMetadata::_internal_set_mimetype(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.mimetype_.Set(value, GetArenaForAllocation()); -} -inline std::string* StickerMetadata::_internal_mutable_mimetype() { - _impl_._has_bits_[0] |= 0x00000010u; - return _impl_.mimetype_.Mutable(GetArenaForAllocation()); -} -inline std::string* StickerMetadata::release_mimetype() { - // @@protoc_insertion_point(field_release:proto.StickerMetadata.mimetype) - if (!_internal_has_mimetype()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000010u; - auto* p = _impl_.mimetype_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mimetype_.IsDefault()) { - _impl_.mimetype_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void StickerMetadata::set_allocated_mimetype(std::string* mimetype) { - if (mimetype != nullptr) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mimetype_.IsDefault()) { - _impl_.mimetype_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.StickerMetadata.mimetype) -} - -// optional uint32 height = 6; -inline bool StickerMetadata::_internal_has_height() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool StickerMetadata::has_height() const { - return _internal_has_height(); -} -inline void StickerMetadata::clear_height() { - _impl_.height_ = 0u; - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline uint32_t StickerMetadata::_internal_height() const { - return _impl_.height_; -} -inline uint32_t StickerMetadata::height() const { - // @@protoc_insertion_point(field_get:proto.StickerMetadata.height) - return _internal_height(); -} -inline void StickerMetadata::_internal_set_height(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.height_ = value; -} -inline void StickerMetadata::set_height(uint32_t value) { - _internal_set_height(value); - // @@protoc_insertion_point(field_set:proto.StickerMetadata.height) -} - -// optional uint32 width = 7; -inline bool StickerMetadata::_internal_has_width() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - return value; -} -inline bool StickerMetadata::has_width() const { - return _internal_has_width(); -} -inline void StickerMetadata::clear_width() { - _impl_.width_ = 0u; - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline uint32_t StickerMetadata::_internal_width() const { - return _impl_.width_; -} -inline uint32_t StickerMetadata::width() const { - // @@protoc_insertion_point(field_get:proto.StickerMetadata.width) - return _internal_width(); -} -inline void StickerMetadata::_internal_set_width(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.width_ = value; -} -inline void StickerMetadata::set_width(uint32_t value) { - _internal_set_width(value); - // @@protoc_insertion_point(field_set:proto.StickerMetadata.width) -} - -// optional string directPath = 8; -inline bool StickerMetadata::_internal_has_directpath() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool StickerMetadata::has_directpath() const { - return _internal_has_directpath(); -} -inline void StickerMetadata::clear_directpath() { - _impl_.directpath_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline const std::string& StickerMetadata::directpath() const { - // @@protoc_insertion_point(field_get:proto.StickerMetadata.directPath) - return _internal_directpath(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void StickerMetadata::set_directpath(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.directpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.StickerMetadata.directPath) -} -inline std::string* StickerMetadata::mutable_directpath() { - std::string* _s = _internal_mutable_directpath(); - // @@protoc_insertion_point(field_mutable:proto.StickerMetadata.directPath) - return _s; -} -inline const std::string& StickerMetadata::_internal_directpath() const { - return _impl_.directpath_.Get(); -} -inline void StickerMetadata::_internal_set_directpath(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.directpath_.Set(value, GetArenaForAllocation()); -} -inline std::string* StickerMetadata::_internal_mutable_directpath() { - _impl_._has_bits_[0] |= 0x00000020u; - return _impl_.directpath_.Mutable(GetArenaForAllocation()); -} -inline std::string* StickerMetadata::release_directpath() { - // @@protoc_insertion_point(field_release:proto.StickerMetadata.directPath) - if (!_internal_has_directpath()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000020u; - auto* p = _impl_.directpath_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.directpath_.IsDefault()) { - _impl_.directpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void StickerMetadata::set_allocated_directpath(std::string* directpath) { - if (directpath != nullptr) { - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.directpath_.IsDefault()) { - _impl_.directpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.StickerMetadata.directPath) -} - -// optional uint64 fileLength = 9; -inline bool StickerMetadata::_internal_has_filelength() const { - bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; - return value; -} -inline bool StickerMetadata::has_filelength() const { - return _internal_has_filelength(); -} -inline void StickerMetadata::clear_filelength() { - _impl_.filelength_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000100u; -} -inline uint64_t StickerMetadata::_internal_filelength() const { - return _impl_.filelength_; -} -inline uint64_t StickerMetadata::filelength() const { - // @@protoc_insertion_point(field_get:proto.StickerMetadata.fileLength) - return _internal_filelength(); -} -inline void StickerMetadata::_internal_set_filelength(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000100u; - _impl_.filelength_ = value; -} -inline void StickerMetadata::set_filelength(uint64_t value) { - _internal_set_filelength(value); - // @@protoc_insertion_point(field_set:proto.StickerMetadata.fileLength) -} - -// optional float weight = 10; -inline bool StickerMetadata::_internal_has_weight() const { - bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; - return value; -} -inline bool StickerMetadata::has_weight() const { - return _internal_has_weight(); -} -inline void StickerMetadata::clear_weight() { - _impl_.weight_ = 0; - _impl_._has_bits_[0] &= ~0x00000200u; -} -inline float StickerMetadata::_internal_weight() const { - return _impl_.weight_; -} -inline float StickerMetadata::weight() const { - // @@protoc_insertion_point(field_get:proto.StickerMetadata.weight) - return _internal_weight(); -} -inline void StickerMetadata::_internal_set_weight(float value) { - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.weight_ = value; -} -inline void StickerMetadata::set_weight(float value) { - _internal_set_weight(value); - // @@protoc_insertion_point(field_set:proto.StickerMetadata.weight) -} - -// ------------------------------------------------------------------- - -// SyncActionData - -// optional bytes index = 1; -inline bool SyncActionData::_internal_has_index() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SyncActionData::has_index() const { - return _internal_has_index(); -} -inline void SyncActionData::clear_index() { - _impl_.index_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& SyncActionData::index() const { - // @@protoc_insertion_point(field_get:proto.SyncActionData.index) - return _internal_index(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SyncActionData::set_index(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.index_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SyncActionData.index) -} -inline std::string* SyncActionData::mutable_index() { - std::string* _s = _internal_mutable_index(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionData.index) - return _s; -} -inline const std::string& SyncActionData::_internal_index() const { - return _impl_.index_.Get(); -} -inline void SyncActionData::_internal_set_index(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.index_.Set(value, GetArenaForAllocation()); -} -inline std::string* SyncActionData::_internal_mutable_index() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.index_.Mutable(GetArenaForAllocation()); -} -inline std::string* SyncActionData::release_index() { - // @@protoc_insertion_point(field_release:proto.SyncActionData.index) - if (!_internal_has_index()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.index_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.index_.IsDefault()) { - _impl_.index_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SyncActionData::set_allocated_index(std::string* index) { - if (index != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.index_.SetAllocated(index, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.index_.IsDefault()) { - _impl_.index_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionData.index) -} - -// optional .proto.SyncActionValue value = 2; -inline bool SyncActionData::_internal_has_value() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - PROTOBUF_ASSUME(!value || _impl_.value_ != nullptr); - return value; -} -inline bool SyncActionData::has_value() const { - return _internal_has_value(); -} -inline void SyncActionData::clear_value() { - if (_impl_.value_ != nullptr) _impl_.value_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const ::proto::SyncActionValue& SyncActionData::_internal_value() const { - const ::proto::SyncActionValue* p = _impl_.value_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_default_instance_); -} -inline const ::proto::SyncActionValue& SyncActionData::value() const { - // @@protoc_insertion_point(field_get:proto.SyncActionData.value) - return _internal_value(); -} -inline void SyncActionData::unsafe_arena_set_allocated_value( - ::proto::SyncActionValue* value) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.value_); - } - _impl_.value_ = value; - if (value) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionData.value) -} -inline ::proto::SyncActionValue* SyncActionData::release_value() { - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::SyncActionValue* temp = _impl_.value_; - _impl_.value_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue* SyncActionData::unsafe_arena_release_value() { - // @@protoc_insertion_point(field_release:proto.SyncActionData.value) - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::SyncActionValue* temp = _impl_.value_; - _impl_.value_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue* SyncActionData::_internal_mutable_value() { - _impl_._has_bits_[0] |= 0x00000004u; - if (_impl_.value_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue>(GetArenaForAllocation()); - _impl_.value_ = p; - } - return _impl_.value_; -} -inline ::proto::SyncActionValue* SyncActionData::mutable_value() { - ::proto::SyncActionValue* _msg = _internal_mutable_value(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionData.value) - return _msg; -} -inline void SyncActionData::set_allocated_value(::proto::SyncActionValue* value) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.value_; - } - if (value) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(value); - if (message_arena != submessage_arena) { - value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, value, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.value_ = value; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionData.value) -} - -// optional bytes padding = 3; -inline bool SyncActionData::_internal_has_padding() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool SyncActionData::has_padding() const { - return _internal_has_padding(); -} -inline void SyncActionData::clear_padding() { - _impl_.padding_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& SyncActionData::padding() const { - // @@protoc_insertion_point(field_get:proto.SyncActionData.padding) - return _internal_padding(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SyncActionData::set_padding(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.padding_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SyncActionData.padding) -} -inline std::string* SyncActionData::mutable_padding() { - std::string* _s = _internal_mutable_padding(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionData.padding) - return _s; -} -inline const std::string& SyncActionData::_internal_padding() const { - return _impl_.padding_.Get(); -} -inline void SyncActionData::_internal_set_padding(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.padding_.Set(value, GetArenaForAllocation()); -} -inline std::string* SyncActionData::_internal_mutable_padding() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.padding_.Mutable(GetArenaForAllocation()); -} -inline std::string* SyncActionData::release_padding() { - // @@protoc_insertion_point(field_release:proto.SyncActionData.padding) - if (!_internal_has_padding()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.padding_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.padding_.IsDefault()) { - _impl_.padding_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SyncActionData::set_allocated_padding(std::string* padding) { - if (padding != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.padding_.SetAllocated(padding, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.padding_.IsDefault()) { - _impl_.padding_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionData.padding) -} - -// optional int32 version = 4; -inline bool SyncActionData::_internal_has_version() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool SyncActionData::has_version() const { - return _internal_has_version(); -} -inline void SyncActionData::clear_version() { - _impl_.version_ = 0; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline int32_t SyncActionData::_internal_version() const { - return _impl_.version_; -} -inline int32_t SyncActionData::version() const { - // @@protoc_insertion_point(field_get:proto.SyncActionData.version) - return _internal_version(); -} -inline void SyncActionData::_internal_set_version(int32_t value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.version_ = value; -} -inline void SyncActionData::set_version(int32_t value) { - _internal_set_version(value); - // @@protoc_insertion_point(field_set:proto.SyncActionData.version) -} - -// ------------------------------------------------------------------- - -// SyncActionValue_AgentAction - -// optional string name = 1; -inline bool SyncActionValue_AgentAction::_internal_has_name() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SyncActionValue_AgentAction::has_name() const { - return _internal_has_name(); -} -inline void SyncActionValue_AgentAction::clear_name() { - _impl_.name_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& SyncActionValue_AgentAction::name() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.AgentAction.name) - return _internal_name(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SyncActionValue_AgentAction::set_name(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.AgentAction.name) -} -inline std::string* SyncActionValue_AgentAction::mutable_name() { - std::string* _s = _internal_mutable_name(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.AgentAction.name) - return _s; -} -inline const std::string& SyncActionValue_AgentAction::_internal_name() const { - return _impl_.name_.Get(); -} -inline void SyncActionValue_AgentAction::_internal_set_name(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.name_.Set(value, GetArenaForAllocation()); -} -inline std::string* SyncActionValue_AgentAction::_internal_mutable_name() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.name_.Mutable(GetArenaForAllocation()); -} -inline std::string* SyncActionValue_AgentAction::release_name() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.AgentAction.name) - if (!_internal_has_name()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.name_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.name_.IsDefault()) { - _impl_.name_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SyncActionValue_AgentAction::set_allocated_name(std::string* name) { - if (name != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.name_.SetAllocated(name, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.name_.IsDefault()) { - _impl_.name_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.AgentAction.name) -} - -// optional int32 deviceID = 2; -inline bool SyncActionValue_AgentAction::_internal_has_deviceid() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool SyncActionValue_AgentAction::has_deviceid() const { - return _internal_has_deviceid(); -} -inline void SyncActionValue_AgentAction::clear_deviceid() { - _impl_.deviceid_ = 0; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline int32_t SyncActionValue_AgentAction::_internal_deviceid() const { - return _impl_.deviceid_; -} -inline int32_t SyncActionValue_AgentAction::deviceid() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.AgentAction.deviceID) - return _internal_deviceid(); -} -inline void SyncActionValue_AgentAction::_internal_set_deviceid(int32_t value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.deviceid_ = value; -} -inline void SyncActionValue_AgentAction::set_deviceid(int32_t value) { - _internal_set_deviceid(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.AgentAction.deviceID) -} - -// optional bool isDeleted = 3; -inline bool SyncActionValue_AgentAction::_internal_has_isdeleted() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool SyncActionValue_AgentAction::has_isdeleted() const { - return _internal_has_isdeleted(); -} -inline void SyncActionValue_AgentAction::clear_isdeleted() { - _impl_.isdeleted_ = false; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline bool SyncActionValue_AgentAction::_internal_isdeleted() const { - return _impl_.isdeleted_; -} -inline bool SyncActionValue_AgentAction::isdeleted() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.AgentAction.isDeleted) - return _internal_isdeleted(); -} -inline void SyncActionValue_AgentAction::_internal_set_isdeleted(bool value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.isdeleted_ = value; -} -inline void SyncActionValue_AgentAction::set_isdeleted(bool value) { - _internal_set_isdeleted(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.AgentAction.isDeleted) -} - -// ------------------------------------------------------------------- - -// SyncActionValue_AndroidUnsupportedActions - -// optional bool allowed = 1; -inline bool SyncActionValue_AndroidUnsupportedActions::_internal_has_allowed() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SyncActionValue_AndroidUnsupportedActions::has_allowed() const { - return _internal_has_allowed(); -} -inline void SyncActionValue_AndroidUnsupportedActions::clear_allowed() { - _impl_.allowed_ = false; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline bool SyncActionValue_AndroidUnsupportedActions::_internal_allowed() const { - return _impl_.allowed_; -} -inline bool SyncActionValue_AndroidUnsupportedActions::allowed() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.AndroidUnsupportedActions.allowed) - return _internal_allowed(); -} -inline void SyncActionValue_AndroidUnsupportedActions::_internal_set_allowed(bool value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.allowed_ = value; -} -inline void SyncActionValue_AndroidUnsupportedActions::set_allowed(bool value) { - _internal_set_allowed(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.AndroidUnsupportedActions.allowed) -} - -// ------------------------------------------------------------------- - -// SyncActionValue_ArchiveChatAction - -// optional bool archived = 1; -inline bool SyncActionValue_ArchiveChatAction::_internal_has_archived() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool SyncActionValue_ArchiveChatAction::has_archived() const { - return _internal_has_archived(); -} -inline void SyncActionValue_ArchiveChatAction::clear_archived() { - _impl_.archived_ = false; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline bool SyncActionValue_ArchiveChatAction::_internal_archived() const { - return _impl_.archived_; -} -inline bool SyncActionValue_ArchiveChatAction::archived() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.ArchiveChatAction.archived) - return _internal_archived(); -} -inline void SyncActionValue_ArchiveChatAction::_internal_set_archived(bool value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.archived_ = value; -} -inline void SyncActionValue_ArchiveChatAction::set_archived(bool value) { - _internal_set_archived(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.ArchiveChatAction.archived) -} - -// optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2; -inline bool SyncActionValue_ArchiveChatAction::_internal_has_messagerange() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.messagerange_ != nullptr); - return value; -} -inline bool SyncActionValue_ArchiveChatAction::has_messagerange() const { - return _internal_has_messagerange(); -} -inline void SyncActionValue_ArchiveChatAction::clear_messagerange() { - if (_impl_.messagerange_ != nullptr) _impl_.messagerange_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_ArchiveChatAction::_internal_messagerange() const { - const ::proto::SyncActionValue_SyncActionMessageRange* p = _impl_.messagerange_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_SyncActionMessageRange_default_instance_); -} -inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_ArchiveChatAction::messagerange() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.ArchiveChatAction.messageRange) - return _internal_messagerange(); -} -inline void SyncActionValue_ArchiveChatAction::unsafe_arena_set_allocated_messagerange( - ::proto::SyncActionValue_SyncActionMessageRange* messagerange) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.messagerange_); - } - _impl_.messagerange_ = messagerange; - if (messagerange) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.ArchiveChatAction.messageRange) -} -inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ArchiveChatAction::release_messagerange() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_; - _impl_.messagerange_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ArchiveChatAction::unsafe_arena_release_messagerange() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.ArchiveChatAction.messageRange) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_; - _impl_.messagerange_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ArchiveChatAction::_internal_mutable_messagerange() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.messagerange_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue_SyncActionMessageRange>(GetArenaForAllocation()); - _impl_.messagerange_ = p; - } - return _impl_.messagerange_; -} -inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ArchiveChatAction::mutable_messagerange() { - ::proto::SyncActionValue_SyncActionMessageRange* _msg = _internal_mutable_messagerange(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.ArchiveChatAction.messageRange) - return _msg; -} -inline void SyncActionValue_ArchiveChatAction::set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.messagerange_; - } - if (messagerange) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(messagerange); - if (message_arena != submessage_arena) { - messagerange = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, messagerange, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.messagerange_ = messagerange; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.ArchiveChatAction.messageRange) -} - -// ------------------------------------------------------------------- - -// SyncActionValue_ClearChatAction - -// optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1; -inline bool SyncActionValue_ClearChatAction::_internal_has_messagerange() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.messagerange_ != nullptr); - return value; -} -inline bool SyncActionValue_ClearChatAction::has_messagerange() const { - return _internal_has_messagerange(); -} -inline void SyncActionValue_ClearChatAction::clear_messagerange() { - if (_impl_.messagerange_ != nullptr) _impl_.messagerange_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_ClearChatAction::_internal_messagerange() const { - const ::proto::SyncActionValue_SyncActionMessageRange* p = _impl_.messagerange_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_SyncActionMessageRange_default_instance_); -} -inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_ClearChatAction::messagerange() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.ClearChatAction.messageRange) - return _internal_messagerange(); -} -inline void SyncActionValue_ClearChatAction::unsafe_arena_set_allocated_messagerange( - ::proto::SyncActionValue_SyncActionMessageRange* messagerange) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.messagerange_); - } - _impl_.messagerange_ = messagerange; - if (messagerange) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.ClearChatAction.messageRange) -} -inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ClearChatAction::release_messagerange() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_; - _impl_.messagerange_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ClearChatAction::unsafe_arena_release_messagerange() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.ClearChatAction.messageRange) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_; - _impl_.messagerange_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ClearChatAction::_internal_mutable_messagerange() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.messagerange_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue_SyncActionMessageRange>(GetArenaForAllocation()); - _impl_.messagerange_ = p; - } - return _impl_.messagerange_; -} -inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ClearChatAction::mutable_messagerange() { - ::proto::SyncActionValue_SyncActionMessageRange* _msg = _internal_mutable_messagerange(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.ClearChatAction.messageRange) - return _msg; -} -inline void SyncActionValue_ClearChatAction::set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.messagerange_; - } - if (messagerange) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(messagerange); - if (message_arena != submessage_arena) { - messagerange = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, messagerange, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.messagerange_ = messagerange; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.ClearChatAction.messageRange) -} - -// ------------------------------------------------------------------- - -// SyncActionValue_ContactAction - -// optional string fullName = 1; -inline bool SyncActionValue_ContactAction::_internal_has_fullname() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SyncActionValue_ContactAction::has_fullname() const { - return _internal_has_fullname(); -} -inline void SyncActionValue_ContactAction::clear_fullname() { - _impl_.fullname_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& SyncActionValue_ContactAction::fullname() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.ContactAction.fullName) - return _internal_fullname(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SyncActionValue_ContactAction::set_fullname(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.fullname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.ContactAction.fullName) -} -inline std::string* SyncActionValue_ContactAction::mutable_fullname() { - std::string* _s = _internal_mutable_fullname(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.ContactAction.fullName) - return _s; -} -inline const std::string& SyncActionValue_ContactAction::_internal_fullname() const { - return _impl_.fullname_.Get(); -} -inline void SyncActionValue_ContactAction::_internal_set_fullname(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.fullname_.Set(value, GetArenaForAllocation()); -} -inline std::string* SyncActionValue_ContactAction::_internal_mutable_fullname() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.fullname_.Mutable(GetArenaForAllocation()); -} -inline std::string* SyncActionValue_ContactAction::release_fullname() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.ContactAction.fullName) - if (!_internal_has_fullname()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.fullname_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fullname_.IsDefault()) { - _impl_.fullname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SyncActionValue_ContactAction::set_allocated_fullname(std::string* fullname) { - if (fullname != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.fullname_.SetAllocated(fullname, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fullname_.IsDefault()) { - _impl_.fullname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.ContactAction.fullName) -} - -// optional string firstName = 2; -inline bool SyncActionValue_ContactAction::_internal_has_firstname() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool SyncActionValue_ContactAction::has_firstname() const { - return _internal_has_firstname(); -} -inline void SyncActionValue_ContactAction::clear_firstname() { - _impl_.firstname_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& SyncActionValue_ContactAction::firstname() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.ContactAction.firstName) - return _internal_firstname(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SyncActionValue_ContactAction::set_firstname(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.firstname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.ContactAction.firstName) -} -inline std::string* SyncActionValue_ContactAction::mutable_firstname() { - std::string* _s = _internal_mutable_firstname(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.ContactAction.firstName) - return _s; -} -inline const std::string& SyncActionValue_ContactAction::_internal_firstname() const { - return _impl_.firstname_.Get(); -} -inline void SyncActionValue_ContactAction::_internal_set_firstname(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.firstname_.Set(value, GetArenaForAllocation()); -} -inline std::string* SyncActionValue_ContactAction::_internal_mutable_firstname() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.firstname_.Mutable(GetArenaForAllocation()); -} -inline std::string* SyncActionValue_ContactAction::release_firstname() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.ContactAction.firstName) - if (!_internal_has_firstname()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.firstname_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.firstname_.IsDefault()) { - _impl_.firstname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SyncActionValue_ContactAction::set_allocated_firstname(std::string* firstname) { - if (firstname != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.firstname_.SetAllocated(firstname, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.firstname_.IsDefault()) { - _impl_.firstname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.ContactAction.firstName) -} - -// ------------------------------------------------------------------- - -// SyncActionValue_DeleteChatAction - -// optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1; -inline bool SyncActionValue_DeleteChatAction::_internal_has_messagerange() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.messagerange_ != nullptr); - return value; -} -inline bool SyncActionValue_DeleteChatAction::has_messagerange() const { - return _internal_has_messagerange(); -} -inline void SyncActionValue_DeleteChatAction::clear_messagerange() { - if (_impl_.messagerange_ != nullptr) _impl_.messagerange_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_DeleteChatAction::_internal_messagerange() const { - const ::proto::SyncActionValue_SyncActionMessageRange* p = _impl_.messagerange_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_SyncActionMessageRange_default_instance_); -} -inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_DeleteChatAction::messagerange() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.DeleteChatAction.messageRange) - return _internal_messagerange(); -} -inline void SyncActionValue_DeleteChatAction::unsafe_arena_set_allocated_messagerange( - ::proto::SyncActionValue_SyncActionMessageRange* messagerange) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.messagerange_); - } - _impl_.messagerange_ = messagerange; - if (messagerange) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.DeleteChatAction.messageRange) -} -inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_DeleteChatAction::release_messagerange() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_; - _impl_.messagerange_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_DeleteChatAction::unsafe_arena_release_messagerange() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.DeleteChatAction.messageRange) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_; - _impl_.messagerange_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_DeleteChatAction::_internal_mutable_messagerange() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.messagerange_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue_SyncActionMessageRange>(GetArenaForAllocation()); - _impl_.messagerange_ = p; - } - return _impl_.messagerange_; -} -inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_DeleteChatAction::mutable_messagerange() { - ::proto::SyncActionValue_SyncActionMessageRange* _msg = _internal_mutable_messagerange(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.DeleteChatAction.messageRange) - return _msg; -} -inline void SyncActionValue_DeleteChatAction::set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.messagerange_; - } - if (messagerange) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(messagerange); - if (message_arena != submessage_arena) { - messagerange = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, messagerange, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.messagerange_ = messagerange; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.DeleteChatAction.messageRange) -} - -// ------------------------------------------------------------------- - -// SyncActionValue_DeleteMessageForMeAction - -// optional bool deleteMedia = 1; -inline bool SyncActionValue_DeleteMessageForMeAction::_internal_has_deletemedia() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool SyncActionValue_DeleteMessageForMeAction::has_deletemedia() const { - return _internal_has_deletemedia(); -} -inline void SyncActionValue_DeleteMessageForMeAction::clear_deletemedia() { - _impl_.deletemedia_ = false; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline bool SyncActionValue_DeleteMessageForMeAction::_internal_deletemedia() const { - return _impl_.deletemedia_; -} -inline bool SyncActionValue_DeleteMessageForMeAction::deletemedia() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.DeleteMessageForMeAction.deleteMedia) - return _internal_deletemedia(); -} -inline void SyncActionValue_DeleteMessageForMeAction::_internal_set_deletemedia(bool value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.deletemedia_ = value; -} -inline void SyncActionValue_DeleteMessageForMeAction::set_deletemedia(bool value) { - _internal_set_deletemedia(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.DeleteMessageForMeAction.deleteMedia) -} - -// optional int64 messageTimestamp = 2; -inline bool SyncActionValue_DeleteMessageForMeAction::_internal_has_messagetimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SyncActionValue_DeleteMessageForMeAction::has_messagetimestamp() const { - return _internal_has_messagetimestamp(); -} -inline void SyncActionValue_DeleteMessageForMeAction::clear_messagetimestamp() { - _impl_.messagetimestamp_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline int64_t SyncActionValue_DeleteMessageForMeAction::_internal_messagetimestamp() const { - return _impl_.messagetimestamp_; -} -inline int64_t SyncActionValue_DeleteMessageForMeAction::messagetimestamp() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.DeleteMessageForMeAction.messageTimestamp) - return _internal_messagetimestamp(); -} -inline void SyncActionValue_DeleteMessageForMeAction::_internal_set_messagetimestamp(int64_t value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.messagetimestamp_ = value; -} -inline void SyncActionValue_DeleteMessageForMeAction::set_messagetimestamp(int64_t value) { - _internal_set_messagetimestamp(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.DeleteMessageForMeAction.messageTimestamp) -} - -// ------------------------------------------------------------------- - -// SyncActionValue_KeyExpiration - -// optional int32 expiredKeyEpoch = 1; -inline bool SyncActionValue_KeyExpiration::_internal_has_expiredkeyepoch() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SyncActionValue_KeyExpiration::has_expiredkeyepoch() const { - return _internal_has_expiredkeyepoch(); -} -inline void SyncActionValue_KeyExpiration::clear_expiredkeyepoch() { - _impl_.expiredkeyepoch_ = 0; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline int32_t SyncActionValue_KeyExpiration::_internal_expiredkeyepoch() const { - return _impl_.expiredkeyepoch_; -} -inline int32_t SyncActionValue_KeyExpiration::expiredkeyepoch() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.KeyExpiration.expiredKeyEpoch) - return _internal_expiredkeyepoch(); -} -inline void SyncActionValue_KeyExpiration::_internal_set_expiredkeyepoch(int32_t value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.expiredkeyepoch_ = value; -} -inline void SyncActionValue_KeyExpiration::set_expiredkeyepoch(int32_t value) { - _internal_set_expiredkeyepoch(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.KeyExpiration.expiredKeyEpoch) -} - -// ------------------------------------------------------------------- - -// SyncActionValue_LabelAssociationAction - -// optional bool labeled = 1; -inline bool SyncActionValue_LabelAssociationAction::_internal_has_labeled() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SyncActionValue_LabelAssociationAction::has_labeled() const { - return _internal_has_labeled(); -} -inline void SyncActionValue_LabelAssociationAction::clear_labeled() { - _impl_.labeled_ = false; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline bool SyncActionValue_LabelAssociationAction::_internal_labeled() const { - return _impl_.labeled_; -} -inline bool SyncActionValue_LabelAssociationAction::labeled() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.LabelAssociationAction.labeled) - return _internal_labeled(); -} -inline void SyncActionValue_LabelAssociationAction::_internal_set_labeled(bool value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.labeled_ = value; -} -inline void SyncActionValue_LabelAssociationAction::set_labeled(bool value) { - _internal_set_labeled(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.LabelAssociationAction.labeled) -} - -// ------------------------------------------------------------------- - -// SyncActionValue_LabelEditAction - -// optional string name = 1; -inline bool SyncActionValue_LabelEditAction::_internal_has_name() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SyncActionValue_LabelEditAction::has_name() const { - return _internal_has_name(); -} -inline void SyncActionValue_LabelEditAction::clear_name() { - _impl_.name_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& SyncActionValue_LabelEditAction::name() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.LabelEditAction.name) - return _internal_name(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SyncActionValue_LabelEditAction::set_name(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.LabelEditAction.name) -} -inline std::string* SyncActionValue_LabelEditAction::mutable_name() { - std::string* _s = _internal_mutable_name(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.LabelEditAction.name) - return _s; -} -inline const std::string& SyncActionValue_LabelEditAction::_internal_name() const { - return _impl_.name_.Get(); -} -inline void SyncActionValue_LabelEditAction::_internal_set_name(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.name_.Set(value, GetArenaForAllocation()); -} -inline std::string* SyncActionValue_LabelEditAction::_internal_mutable_name() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.name_.Mutable(GetArenaForAllocation()); -} -inline std::string* SyncActionValue_LabelEditAction::release_name() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.LabelEditAction.name) - if (!_internal_has_name()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.name_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.name_.IsDefault()) { - _impl_.name_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SyncActionValue_LabelEditAction::set_allocated_name(std::string* name) { - if (name != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.name_.SetAllocated(name, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.name_.IsDefault()) { - _impl_.name_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.LabelEditAction.name) -} - -// optional int32 color = 2; -inline bool SyncActionValue_LabelEditAction::_internal_has_color() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool SyncActionValue_LabelEditAction::has_color() const { - return _internal_has_color(); -} -inline void SyncActionValue_LabelEditAction::clear_color() { - _impl_.color_ = 0; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline int32_t SyncActionValue_LabelEditAction::_internal_color() const { - return _impl_.color_; -} -inline int32_t SyncActionValue_LabelEditAction::color() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.LabelEditAction.color) - return _internal_color(); -} -inline void SyncActionValue_LabelEditAction::_internal_set_color(int32_t value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.color_ = value; -} -inline void SyncActionValue_LabelEditAction::set_color(int32_t value) { - _internal_set_color(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.LabelEditAction.color) -} - -// optional int32 predefinedId = 3; -inline bool SyncActionValue_LabelEditAction::_internal_has_predefinedid() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool SyncActionValue_LabelEditAction::has_predefinedid() const { - return _internal_has_predefinedid(); -} -inline void SyncActionValue_LabelEditAction::clear_predefinedid() { - _impl_.predefinedid_ = 0; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline int32_t SyncActionValue_LabelEditAction::_internal_predefinedid() const { - return _impl_.predefinedid_; -} -inline int32_t SyncActionValue_LabelEditAction::predefinedid() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.LabelEditAction.predefinedId) - return _internal_predefinedid(); -} -inline void SyncActionValue_LabelEditAction::_internal_set_predefinedid(int32_t value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.predefinedid_ = value; -} -inline void SyncActionValue_LabelEditAction::set_predefinedid(int32_t value) { - _internal_set_predefinedid(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.LabelEditAction.predefinedId) -} - -// optional bool deleted = 4; -inline bool SyncActionValue_LabelEditAction::_internal_has_deleted() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool SyncActionValue_LabelEditAction::has_deleted() const { - return _internal_has_deleted(); -} -inline void SyncActionValue_LabelEditAction::clear_deleted() { - _impl_.deleted_ = false; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline bool SyncActionValue_LabelEditAction::_internal_deleted() const { - return _impl_.deleted_; -} -inline bool SyncActionValue_LabelEditAction::deleted() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.LabelEditAction.deleted) - return _internal_deleted(); -} -inline void SyncActionValue_LabelEditAction::_internal_set_deleted(bool value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.deleted_ = value; -} -inline void SyncActionValue_LabelEditAction::set_deleted(bool value) { - _internal_set_deleted(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.LabelEditAction.deleted) -} - -// ------------------------------------------------------------------- - -// SyncActionValue_LocaleSetting - -// optional string locale = 1; -inline bool SyncActionValue_LocaleSetting::_internal_has_locale() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SyncActionValue_LocaleSetting::has_locale() const { - return _internal_has_locale(); -} -inline void SyncActionValue_LocaleSetting::clear_locale() { - _impl_.locale_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& SyncActionValue_LocaleSetting::locale() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.LocaleSetting.locale) - return _internal_locale(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SyncActionValue_LocaleSetting::set_locale(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.locale_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.LocaleSetting.locale) -} -inline std::string* SyncActionValue_LocaleSetting::mutable_locale() { - std::string* _s = _internal_mutable_locale(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.LocaleSetting.locale) - return _s; -} -inline const std::string& SyncActionValue_LocaleSetting::_internal_locale() const { - return _impl_.locale_.Get(); -} -inline void SyncActionValue_LocaleSetting::_internal_set_locale(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.locale_.Set(value, GetArenaForAllocation()); -} -inline std::string* SyncActionValue_LocaleSetting::_internal_mutable_locale() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.locale_.Mutable(GetArenaForAllocation()); -} -inline std::string* SyncActionValue_LocaleSetting::release_locale() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.LocaleSetting.locale) - if (!_internal_has_locale()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.locale_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.locale_.IsDefault()) { - _impl_.locale_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SyncActionValue_LocaleSetting::set_allocated_locale(std::string* locale) { - if (locale != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.locale_.SetAllocated(locale, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.locale_.IsDefault()) { - _impl_.locale_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.LocaleSetting.locale) -} - -// ------------------------------------------------------------------- - -// SyncActionValue_MarkChatAsReadAction - -// optional bool read = 1; -inline bool SyncActionValue_MarkChatAsReadAction::_internal_has_read() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool SyncActionValue_MarkChatAsReadAction::has_read() const { - return _internal_has_read(); -} -inline void SyncActionValue_MarkChatAsReadAction::clear_read() { - _impl_.read_ = false; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline bool SyncActionValue_MarkChatAsReadAction::_internal_read() const { - return _impl_.read_; -} -inline bool SyncActionValue_MarkChatAsReadAction::read() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.MarkChatAsReadAction.read) - return _internal_read(); -} -inline void SyncActionValue_MarkChatAsReadAction::_internal_set_read(bool value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.read_ = value; -} -inline void SyncActionValue_MarkChatAsReadAction::set_read(bool value) { - _internal_set_read(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.MarkChatAsReadAction.read) -} - -// optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2; -inline bool SyncActionValue_MarkChatAsReadAction::_internal_has_messagerange() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.messagerange_ != nullptr); - return value; -} -inline bool SyncActionValue_MarkChatAsReadAction::has_messagerange() const { - return _internal_has_messagerange(); -} -inline void SyncActionValue_MarkChatAsReadAction::clear_messagerange() { - if (_impl_.messagerange_ != nullptr) _impl_.messagerange_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_MarkChatAsReadAction::_internal_messagerange() const { - const ::proto::SyncActionValue_SyncActionMessageRange* p = _impl_.messagerange_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_SyncActionMessageRange_default_instance_); -} -inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_MarkChatAsReadAction::messagerange() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.MarkChatAsReadAction.messageRange) - return _internal_messagerange(); -} -inline void SyncActionValue_MarkChatAsReadAction::unsafe_arena_set_allocated_messagerange( - ::proto::SyncActionValue_SyncActionMessageRange* messagerange) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.messagerange_); - } - _impl_.messagerange_ = messagerange; - if (messagerange) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.MarkChatAsReadAction.messageRange) -} -inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_MarkChatAsReadAction::release_messagerange() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_; - _impl_.messagerange_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_MarkChatAsReadAction::unsafe_arena_release_messagerange() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.MarkChatAsReadAction.messageRange) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_; - _impl_.messagerange_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_MarkChatAsReadAction::_internal_mutable_messagerange() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.messagerange_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue_SyncActionMessageRange>(GetArenaForAllocation()); - _impl_.messagerange_ = p; - } - return _impl_.messagerange_; -} -inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_MarkChatAsReadAction::mutable_messagerange() { - ::proto::SyncActionValue_SyncActionMessageRange* _msg = _internal_mutable_messagerange(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.MarkChatAsReadAction.messageRange) - return _msg; -} -inline void SyncActionValue_MarkChatAsReadAction::set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.messagerange_; - } - if (messagerange) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(messagerange); - if (message_arena != submessage_arena) { - messagerange = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, messagerange, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.messagerange_ = messagerange; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.MarkChatAsReadAction.messageRange) -} - -// ------------------------------------------------------------------- - -// SyncActionValue_MuteAction - -// optional bool muted = 1; -inline bool SyncActionValue_MuteAction::_internal_has_muted() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool SyncActionValue_MuteAction::has_muted() const { - return _internal_has_muted(); -} -inline void SyncActionValue_MuteAction::clear_muted() { - _impl_.muted_ = false; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline bool SyncActionValue_MuteAction::_internal_muted() const { - return _impl_.muted_; -} -inline bool SyncActionValue_MuteAction::muted() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.MuteAction.muted) - return _internal_muted(); -} -inline void SyncActionValue_MuteAction::_internal_set_muted(bool value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.muted_ = value; -} -inline void SyncActionValue_MuteAction::set_muted(bool value) { - _internal_set_muted(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.MuteAction.muted) -} - -// optional int64 muteEndTimestamp = 2; -inline bool SyncActionValue_MuteAction::_internal_has_muteendtimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SyncActionValue_MuteAction::has_muteendtimestamp() const { - return _internal_has_muteendtimestamp(); -} -inline void SyncActionValue_MuteAction::clear_muteendtimestamp() { - _impl_.muteendtimestamp_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline int64_t SyncActionValue_MuteAction::_internal_muteendtimestamp() const { - return _impl_.muteendtimestamp_; -} -inline int64_t SyncActionValue_MuteAction::muteendtimestamp() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.MuteAction.muteEndTimestamp) - return _internal_muteendtimestamp(); -} -inline void SyncActionValue_MuteAction::_internal_set_muteendtimestamp(int64_t value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.muteendtimestamp_ = value; -} -inline void SyncActionValue_MuteAction::set_muteendtimestamp(int64_t value) { - _internal_set_muteendtimestamp(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.MuteAction.muteEndTimestamp) -} - -// ------------------------------------------------------------------- - -// SyncActionValue_NuxAction - -// optional bool acknowledged = 1; -inline bool SyncActionValue_NuxAction::_internal_has_acknowledged() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SyncActionValue_NuxAction::has_acknowledged() const { - return _internal_has_acknowledged(); -} -inline void SyncActionValue_NuxAction::clear_acknowledged() { - _impl_.acknowledged_ = false; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline bool SyncActionValue_NuxAction::_internal_acknowledged() const { - return _impl_.acknowledged_; -} -inline bool SyncActionValue_NuxAction::acknowledged() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.NuxAction.acknowledged) - return _internal_acknowledged(); -} -inline void SyncActionValue_NuxAction::_internal_set_acknowledged(bool value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.acknowledged_ = value; -} -inline void SyncActionValue_NuxAction::set_acknowledged(bool value) { - _internal_set_acknowledged(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.NuxAction.acknowledged) -} - -// ------------------------------------------------------------------- - -// SyncActionValue_PinAction - -// optional bool pinned = 1; -inline bool SyncActionValue_PinAction::_internal_has_pinned() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SyncActionValue_PinAction::has_pinned() const { - return _internal_has_pinned(); -} -inline void SyncActionValue_PinAction::clear_pinned() { - _impl_.pinned_ = false; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline bool SyncActionValue_PinAction::_internal_pinned() const { - return _impl_.pinned_; -} -inline bool SyncActionValue_PinAction::pinned() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.PinAction.pinned) - return _internal_pinned(); -} -inline void SyncActionValue_PinAction::_internal_set_pinned(bool value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.pinned_ = value; -} -inline void SyncActionValue_PinAction::set_pinned(bool value) { - _internal_set_pinned(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.PinAction.pinned) -} - -// ------------------------------------------------------------------- - -// SyncActionValue_PrimaryFeature - -// repeated string flags = 1; -inline int SyncActionValue_PrimaryFeature::_internal_flags_size() const { - return _impl_.flags_.size(); -} -inline int SyncActionValue_PrimaryFeature::flags_size() const { - return _internal_flags_size(); -} -inline void SyncActionValue_PrimaryFeature::clear_flags() { - _impl_.flags_.Clear(); -} -inline std::string* SyncActionValue_PrimaryFeature::add_flags() { - std::string* _s = _internal_add_flags(); - // @@protoc_insertion_point(field_add_mutable:proto.SyncActionValue.PrimaryFeature.flags) - return _s; -} -inline const std::string& SyncActionValue_PrimaryFeature::_internal_flags(int index) const { - return _impl_.flags_.Get(index); -} -inline const std::string& SyncActionValue_PrimaryFeature::flags(int index) const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.PrimaryFeature.flags) - return _internal_flags(index); -} -inline std::string* SyncActionValue_PrimaryFeature::mutable_flags(int index) { - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.PrimaryFeature.flags) - return _impl_.flags_.Mutable(index); -} -inline void SyncActionValue_PrimaryFeature::set_flags(int index, const std::string& value) { - _impl_.flags_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.PrimaryFeature.flags) -} -inline void SyncActionValue_PrimaryFeature::set_flags(int index, std::string&& value) { - _impl_.flags_.Mutable(index)->assign(std::move(value)); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.PrimaryFeature.flags) -} -inline void SyncActionValue_PrimaryFeature::set_flags(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - _impl_.flags_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:proto.SyncActionValue.PrimaryFeature.flags) -} -inline void SyncActionValue_PrimaryFeature::set_flags(int index, const char* value, size_t size) { - _impl_.flags_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:proto.SyncActionValue.PrimaryFeature.flags) -} -inline std::string* SyncActionValue_PrimaryFeature::_internal_add_flags() { - return _impl_.flags_.Add(); -} -inline void SyncActionValue_PrimaryFeature::add_flags(const std::string& value) { - _impl_.flags_.Add()->assign(value); - // @@protoc_insertion_point(field_add:proto.SyncActionValue.PrimaryFeature.flags) -} -inline void SyncActionValue_PrimaryFeature::add_flags(std::string&& value) { - _impl_.flags_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:proto.SyncActionValue.PrimaryFeature.flags) -} -inline void SyncActionValue_PrimaryFeature::add_flags(const char* value) { - GOOGLE_DCHECK(value != nullptr); - _impl_.flags_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:proto.SyncActionValue.PrimaryFeature.flags) -} -inline void SyncActionValue_PrimaryFeature::add_flags(const char* value, size_t size) { - _impl_.flags_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:proto.SyncActionValue.PrimaryFeature.flags) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -SyncActionValue_PrimaryFeature::flags() const { - // @@protoc_insertion_point(field_list:proto.SyncActionValue.PrimaryFeature.flags) - return _impl_.flags_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -SyncActionValue_PrimaryFeature::mutable_flags() { - // @@protoc_insertion_point(field_mutable_list:proto.SyncActionValue.PrimaryFeature.flags) - return &_impl_.flags_; -} - -// ------------------------------------------------------------------- - -// SyncActionValue_PrimaryVersionAction - -// optional string version = 1; -inline bool SyncActionValue_PrimaryVersionAction::_internal_has_version() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SyncActionValue_PrimaryVersionAction::has_version() const { - return _internal_has_version(); -} -inline void SyncActionValue_PrimaryVersionAction::clear_version() { - _impl_.version_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& SyncActionValue_PrimaryVersionAction::version() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.PrimaryVersionAction.version) - return _internal_version(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SyncActionValue_PrimaryVersionAction::set_version(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.version_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.PrimaryVersionAction.version) -} -inline std::string* SyncActionValue_PrimaryVersionAction::mutable_version() { - std::string* _s = _internal_mutable_version(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.PrimaryVersionAction.version) - return _s; -} -inline const std::string& SyncActionValue_PrimaryVersionAction::_internal_version() const { - return _impl_.version_.Get(); -} -inline void SyncActionValue_PrimaryVersionAction::_internal_set_version(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.version_.Set(value, GetArenaForAllocation()); -} -inline std::string* SyncActionValue_PrimaryVersionAction::_internal_mutable_version() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.version_.Mutable(GetArenaForAllocation()); -} -inline std::string* SyncActionValue_PrimaryVersionAction::release_version() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.PrimaryVersionAction.version) - if (!_internal_has_version()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.version_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.version_.IsDefault()) { - _impl_.version_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SyncActionValue_PrimaryVersionAction::set_allocated_version(std::string* version) { - if (version != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.version_.SetAllocated(version, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.version_.IsDefault()) { - _impl_.version_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.PrimaryVersionAction.version) -} - -// ------------------------------------------------------------------- - -// SyncActionValue_PushNameSetting - -// optional string name = 1; -inline bool SyncActionValue_PushNameSetting::_internal_has_name() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SyncActionValue_PushNameSetting::has_name() const { - return _internal_has_name(); -} -inline void SyncActionValue_PushNameSetting::clear_name() { - _impl_.name_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& SyncActionValue_PushNameSetting::name() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.PushNameSetting.name) - return _internal_name(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SyncActionValue_PushNameSetting::set_name(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.PushNameSetting.name) -} -inline std::string* SyncActionValue_PushNameSetting::mutable_name() { - std::string* _s = _internal_mutable_name(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.PushNameSetting.name) - return _s; -} -inline const std::string& SyncActionValue_PushNameSetting::_internal_name() const { - return _impl_.name_.Get(); -} -inline void SyncActionValue_PushNameSetting::_internal_set_name(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.name_.Set(value, GetArenaForAllocation()); -} -inline std::string* SyncActionValue_PushNameSetting::_internal_mutable_name() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.name_.Mutable(GetArenaForAllocation()); -} -inline std::string* SyncActionValue_PushNameSetting::release_name() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.PushNameSetting.name) - if (!_internal_has_name()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.name_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.name_.IsDefault()) { - _impl_.name_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SyncActionValue_PushNameSetting::set_allocated_name(std::string* name) { - if (name != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.name_.SetAllocated(name, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.name_.IsDefault()) { - _impl_.name_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.PushNameSetting.name) -} - -// ------------------------------------------------------------------- - -// SyncActionValue_QuickReplyAction - -// optional string shortcut = 1; -inline bool SyncActionValue_QuickReplyAction::_internal_has_shortcut() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SyncActionValue_QuickReplyAction::has_shortcut() const { - return _internal_has_shortcut(); -} -inline void SyncActionValue_QuickReplyAction::clear_shortcut() { - _impl_.shortcut_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& SyncActionValue_QuickReplyAction::shortcut() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.QuickReplyAction.shortcut) - return _internal_shortcut(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SyncActionValue_QuickReplyAction::set_shortcut(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.shortcut_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.QuickReplyAction.shortcut) -} -inline std::string* SyncActionValue_QuickReplyAction::mutable_shortcut() { - std::string* _s = _internal_mutable_shortcut(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.QuickReplyAction.shortcut) - return _s; -} -inline const std::string& SyncActionValue_QuickReplyAction::_internal_shortcut() const { - return _impl_.shortcut_.Get(); -} -inline void SyncActionValue_QuickReplyAction::_internal_set_shortcut(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.shortcut_.Set(value, GetArenaForAllocation()); -} -inline std::string* SyncActionValue_QuickReplyAction::_internal_mutable_shortcut() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.shortcut_.Mutable(GetArenaForAllocation()); -} -inline std::string* SyncActionValue_QuickReplyAction::release_shortcut() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.QuickReplyAction.shortcut) - if (!_internal_has_shortcut()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.shortcut_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.shortcut_.IsDefault()) { - _impl_.shortcut_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SyncActionValue_QuickReplyAction::set_allocated_shortcut(std::string* shortcut) { - if (shortcut != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.shortcut_.SetAllocated(shortcut, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.shortcut_.IsDefault()) { - _impl_.shortcut_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.QuickReplyAction.shortcut) -} - -// optional string message = 2; -inline bool SyncActionValue_QuickReplyAction::_internal_has_message() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool SyncActionValue_QuickReplyAction::has_message() const { - return _internal_has_message(); -} -inline void SyncActionValue_QuickReplyAction::clear_message() { - _impl_.message_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& SyncActionValue_QuickReplyAction::message() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.QuickReplyAction.message) - return _internal_message(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SyncActionValue_QuickReplyAction::set_message(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.message_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.QuickReplyAction.message) -} -inline std::string* SyncActionValue_QuickReplyAction::mutable_message() { - std::string* _s = _internal_mutable_message(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.QuickReplyAction.message) - return _s; -} -inline const std::string& SyncActionValue_QuickReplyAction::_internal_message() const { - return _impl_.message_.Get(); -} -inline void SyncActionValue_QuickReplyAction::_internal_set_message(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.message_.Set(value, GetArenaForAllocation()); -} -inline std::string* SyncActionValue_QuickReplyAction::_internal_mutable_message() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.message_.Mutable(GetArenaForAllocation()); -} -inline std::string* SyncActionValue_QuickReplyAction::release_message() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.QuickReplyAction.message) - if (!_internal_has_message()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.message_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.message_.IsDefault()) { - _impl_.message_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SyncActionValue_QuickReplyAction::set_allocated_message(std::string* message) { - if (message != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.message_.SetAllocated(message, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.message_.IsDefault()) { - _impl_.message_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.QuickReplyAction.message) -} - -// repeated string keywords = 3; -inline int SyncActionValue_QuickReplyAction::_internal_keywords_size() const { - return _impl_.keywords_.size(); -} -inline int SyncActionValue_QuickReplyAction::keywords_size() const { - return _internal_keywords_size(); -} -inline void SyncActionValue_QuickReplyAction::clear_keywords() { - _impl_.keywords_.Clear(); -} -inline std::string* SyncActionValue_QuickReplyAction::add_keywords() { - std::string* _s = _internal_add_keywords(); - // @@protoc_insertion_point(field_add_mutable:proto.SyncActionValue.QuickReplyAction.keywords) - return _s; -} -inline const std::string& SyncActionValue_QuickReplyAction::_internal_keywords(int index) const { - return _impl_.keywords_.Get(index); -} -inline const std::string& SyncActionValue_QuickReplyAction::keywords(int index) const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.QuickReplyAction.keywords) - return _internal_keywords(index); -} -inline std::string* SyncActionValue_QuickReplyAction::mutable_keywords(int index) { - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.QuickReplyAction.keywords) - return _impl_.keywords_.Mutable(index); -} -inline void SyncActionValue_QuickReplyAction::set_keywords(int index, const std::string& value) { - _impl_.keywords_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.QuickReplyAction.keywords) -} -inline void SyncActionValue_QuickReplyAction::set_keywords(int index, std::string&& value) { - _impl_.keywords_.Mutable(index)->assign(std::move(value)); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.QuickReplyAction.keywords) -} -inline void SyncActionValue_QuickReplyAction::set_keywords(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - _impl_.keywords_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:proto.SyncActionValue.QuickReplyAction.keywords) -} -inline void SyncActionValue_QuickReplyAction::set_keywords(int index, const char* value, size_t size) { - _impl_.keywords_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:proto.SyncActionValue.QuickReplyAction.keywords) -} -inline std::string* SyncActionValue_QuickReplyAction::_internal_add_keywords() { - return _impl_.keywords_.Add(); -} -inline void SyncActionValue_QuickReplyAction::add_keywords(const std::string& value) { - _impl_.keywords_.Add()->assign(value); - // @@protoc_insertion_point(field_add:proto.SyncActionValue.QuickReplyAction.keywords) -} -inline void SyncActionValue_QuickReplyAction::add_keywords(std::string&& value) { - _impl_.keywords_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:proto.SyncActionValue.QuickReplyAction.keywords) -} -inline void SyncActionValue_QuickReplyAction::add_keywords(const char* value) { - GOOGLE_DCHECK(value != nullptr); - _impl_.keywords_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:proto.SyncActionValue.QuickReplyAction.keywords) -} -inline void SyncActionValue_QuickReplyAction::add_keywords(const char* value, size_t size) { - _impl_.keywords_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:proto.SyncActionValue.QuickReplyAction.keywords) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -SyncActionValue_QuickReplyAction::keywords() const { - // @@protoc_insertion_point(field_list:proto.SyncActionValue.QuickReplyAction.keywords) - return _impl_.keywords_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -SyncActionValue_QuickReplyAction::mutable_keywords() { - // @@protoc_insertion_point(field_mutable_list:proto.SyncActionValue.QuickReplyAction.keywords) - return &_impl_.keywords_; -} - -// optional int32 count = 4; -inline bool SyncActionValue_QuickReplyAction::_internal_has_count() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool SyncActionValue_QuickReplyAction::has_count() const { - return _internal_has_count(); -} -inline void SyncActionValue_QuickReplyAction::clear_count() { - _impl_.count_ = 0; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline int32_t SyncActionValue_QuickReplyAction::_internal_count() const { - return _impl_.count_; -} -inline int32_t SyncActionValue_QuickReplyAction::count() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.QuickReplyAction.count) - return _internal_count(); -} -inline void SyncActionValue_QuickReplyAction::_internal_set_count(int32_t value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.count_ = value; -} -inline void SyncActionValue_QuickReplyAction::set_count(int32_t value) { - _internal_set_count(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.QuickReplyAction.count) -} - -// optional bool deleted = 5; -inline bool SyncActionValue_QuickReplyAction::_internal_has_deleted() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool SyncActionValue_QuickReplyAction::has_deleted() const { - return _internal_has_deleted(); -} -inline void SyncActionValue_QuickReplyAction::clear_deleted() { - _impl_.deleted_ = false; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline bool SyncActionValue_QuickReplyAction::_internal_deleted() const { - return _impl_.deleted_; -} -inline bool SyncActionValue_QuickReplyAction::deleted() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.QuickReplyAction.deleted) - return _internal_deleted(); -} -inline void SyncActionValue_QuickReplyAction::_internal_set_deleted(bool value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.deleted_ = value; -} -inline void SyncActionValue_QuickReplyAction::set_deleted(bool value) { - _internal_set_deleted(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.QuickReplyAction.deleted) -} - -// ------------------------------------------------------------------- - -// SyncActionValue_RecentEmojiWeightsAction - -// repeated .proto.RecentEmojiWeight weights = 1; -inline int SyncActionValue_RecentEmojiWeightsAction::_internal_weights_size() const { - return _impl_.weights_.size(); -} -inline int SyncActionValue_RecentEmojiWeightsAction::weights_size() const { - return _internal_weights_size(); -} -inline void SyncActionValue_RecentEmojiWeightsAction::clear_weights() { - _impl_.weights_.Clear(); -} -inline ::proto::RecentEmojiWeight* SyncActionValue_RecentEmojiWeightsAction::mutable_weights(int index) { - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.RecentEmojiWeightsAction.weights) - return _impl_.weights_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::RecentEmojiWeight >* -SyncActionValue_RecentEmojiWeightsAction::mutable_weights() { - // @@protoc_insertion_point(field_mutable_list:proto.SyncActionValue.RecentEmojiWeightsAction.weights) - return &_impl_.weights_; -} -inline const ::proto::RecentEmojiWeight& SyncActionValue_RecentEmojiWeightsAction::_internal_weights(int index) const { - return _impl_.weights_.Get(index); -} -inline const ::proto::RecentEmojiWeight& SyncActionValue_RecentEmojiWeightsAction::weights(int index) const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.RecentEmojiWeightsAction.weights) - return _internal_weights(index); -} -inline ::proto::RecentEmojiWeight* SyncActionValue_RecentEmojiWeightsAction::_internal_add_weights() { - return _impl_.weights_.Add(); -} -inline ::proto::RecentEmojiWeight* SyncActionValue_RecentEmojiWeightsAction::add_weights() { - ::proto::RecentEmojiWeight* _add = _internal_add_weights(); - // @@protoc_insertion_point(field_add:proto.SyncActionValue.RecentEmojiWeightsAction.weights) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::RecentEmojiWeight >& -SyncActionValue_RecentEmojiWeightsAction::weights() const { - // @@protoc_insertion_point(field_list:proto.SyncActionValue.RecentEmojiWeightsAction.weights) - return _impl_.weights_; -} - -// ------------------------------------------------------------------- - -// SyncActionValue_SecurityNotificationSetting - -// optional bool showNotification = 1; -inline bool SyncActionValue_SecurityNotificationSetting::_internal_has_shownotification() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SyncActionValue_SecurityNotificationSetting::has_shownotification() const { - return _internal_has_shownotification(); -} -inline void SyncActionValue_SecurityNotificationSetting::clear_shownotification() { - _impl_.shownotification_ = false; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline bool SyncActionValue_SecurityNotificationSetting::_internal_shownotification() const { - return _impl_.shownotification_; -} -inline bool SyncActionValue_SecurityNotificationSetting::shownotification() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.SecurityNotificationSetting.showNotification) - return _internal_shownotification(); -} -inline void SyncActionValue_SecurityNotificationSetting::_internal_set_shownotification(bool value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.shownotification_ = value; -} -inline void SyncActionValue_SecurityNotificationSetting::set_shownotification(bool value) { - _internal_set_shownotification(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.SecurityNotificationSetting.showNotification) -} - -// ------------------------------------------------------------------- - -// SyncActionValue_StarAction - -// optional bool starred = 1; -inline bool SyncActionValue_StarAction::_internal_has_starred() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SyncActionValue_StarAction::has_starred() const { - return _internal_has_starred(); -} -inline void SyncActionValue_StarAction::clear_starred() { - _impl_.starred_ = false; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline bool SyncActionValue_StarAction::_internal_starred() const { - return _impl_.starred_; -} -inline bool SyncActionValue_StarAction::starred() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.StarAction.starred) - return _internal_starred(); -} -inline void SyncActionValue_StarAction::_internal_set_starred(bool value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.starred_ = value; -} -inline void SyncActionValue_StarAction::set_starred(bool value) { - _internal_set_starred(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.StarAction.starred) -} - -// ------------------------------------------------------------------- - -// SyncActionValue_StickerAction - -// optional string url = 1; -inline bool SyncActionValue_StickerAction::_internal_has_url() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SyncActionValue_StickerAction::has_url() const { - return _internal_has_url(); -} -inline void SyncActionValue_StickerAction::clear_url() { - _impl_.url_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& SyncActionValue_StickerAction::url() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.url) - return _internal_url(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SyncActionValue_StickerAction::set_url(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.url_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.url) -} -inline std::string* SyncActionValue_StickerAction::mutable_url() { - std::string* _s = _internal_mutable_url(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.StickerAction.url) - return _s; -} -inline const std::string& SyncActionValue_StickerAction::_internal_url() const { - return _impl_.url_.Get(); -} -inline void SyncActionValue_StickerAction::_internal_set_url(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.url_.Set(value, GetArenaForAllocation()); -} -inline std::string* SyncActionValue_StickerAction::_internal_mutable_url() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.url_.Mutable(GetArenaForAllocation()); -} -inline std::string* SyncActionValue_StickerAction::release_url() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.StickerAction.url) - if (!_internal_has_url()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.url_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.url_.IsDefault()) { - _impl_.url_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SyncActionValue_StickerAction::set_allocated_url(std::string* url) { - if (url != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.url_.SetAllocated(url, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.url_.IsDefault()) { - _impl_.url_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.StickerAction.url) -} - -// optional bytes fileEncSha256 = 2; -inline bool SyncActionValue_StickerAction::_internal_has_fileencsha256() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool SyncActionValue_StickerAction::has_fileencsha256() const { - return _internal_has_fileencsha256(); -} -inline void SyncActionValue_StickerAction::clear_fileencsha256() { - _impl_.fileencsha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& SyncActionValue_StickerAction::fileencsha256() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.fileEncSha256) - return _internal_fileencsha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SyncActionValue_StickerAction::set_fileencsha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.fileencsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.fileEncSha256) -} -inline std::string* SyncActionValue_StickerAction::mutable_fileencsha256() { - std::string* _s = _internal_mutable_fileencsha256(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.StickerAction.fileEncSha256) - return _s; -} -inline const std::string& SyncActionValue_StickerAction::_internal_fileencsha256() const { - return _impl_.fileencsha256_.Get(); -} -inline void SyncActionValue_StickerAction::_internal_set_fileencsha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.fileencsha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* SyncActionValue_StickerAction::_internal_mutable_fileencsha256() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.fileencsha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* SyncActionValue_StickerAction::release_fileencsha256() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.StickerAction.fileEncSha256) - if (!_internal_has_fileencsha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.fileencsha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fileencsha256_.IsDefault()) { - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SyncActionValue_StickerAction::set_allocated_fileencsha256(std::string* fileencsha256) { - if (fileencsha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.fileencsha256_.IsDefault()) { - _impl_.fileencsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.StickerAction.fileEncSha256) -} - -// optional bytes mediaKey = 3; -inline bool SyncActionValue_StickerAction::_internal_has_mediakey() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool SyncActionValue_StickerAction::has_mediakey() const { - return _internal_has_mediakey(); -} -inline void SyncActionValue_StickerAction::clear_mediakey() { - _impl_.mediakey_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& SyncActionValue_StickerAction::mediakey() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.mediaKey) - return _internal_mediakey(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SyncActionValue_StickerAction::set_mediakey(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.mediakey_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.mediaKey) -} -inline std::string* SyncActionValue_StickerAction::mutable_mediakey() { - std::string* _s = _internal_mutable_mediakey(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.StickerAction.mediaKey) - return _s; -} -inline const std::string& SyncActionValue_StickerAction::_internal_mediakey() const { - return _impl_.mediakey_.Get(); -} -inline void SyncActionValue_StickerAction::_internal_set_mediakey(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.mediakey_.Set(value, GetArenaForAllocation()); -} -inline std::string* SyncActionValue_StickerAction::_internal_mutable_mediakey() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.mediakey_.Mutable(GetArenaForAllocation()); -} -inline std::string* SyncActionValue_StickerAction::release_mediakey() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.StickerAction.mediaKey) - if (!_internal_has_mediakey()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.mediakey_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mediakey_.IsDefault()) { - _impl_.mediakey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SyncActionValue_StickerAction::set_allocated_mediakey(std::string* mediakey) { - if (mediakey != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mediakey_.IsDefault()) { - _impl_.mediakey_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.StickerAction.mediaKey) -} - -// optional string mimetype = 4; -inline bool SyncActionValue_StickerAction::_internal_has_mimetype() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool SyncActionValue_StickerAction::has_mimetype() const { - return _internal_has_mimetype(); -} -inline void SyncActionValue_StickerAction::clear_mimetype() { - _impl_.mimetype_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const std::string& SyncActionValue_StickerAction::mimetype() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.mimetype) - return _internal_mimetype(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SyncActionValue_StickerAction::set_mimetype(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.mimetype_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.mimetype) -} -inline std::string* SyncActionValue_StickerAction::mutable_mimetype() { - std::string* _s = _internal_mutable_mimetype(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.StickerAction.mimetype) - return _s; -} -inline const std::string& SyncActionValue_StickerAction::_internal_mimetype() const { - return _impl_.mimetype_.Get(); -} -inline void SyncActionValue_StickerAction::_internal_set_mimetype(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.mimetype_.Set(value, GetArenaForAllocation()); -} -inline std::string* SyncActionValue_StickerAction::_internal_mutable_mimetype() { - _impl_._has_bits_[0] |= 0x00000008u; - return _impl_.mimetype_.Mutable(GetArenaForAllocation()); -} -inline std::string* SyncActionValue_StickerAction::release_mimetype() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.StickerAction.mimetype) - if (!_internal_has_mimetype()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000008u; - auto* p = _impl_.mimetype_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mimetype_.IsDefault()) { - _impl_.mimetype_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SyncActionValue_StickerAction::set_allocated_mimetype(std::string* mimetype) { - if (mimetype != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mimetype_.IsDefault()) { - _impl_.mimetype_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.StickerAction.mimetype) -} - -// optional uint32 height = 5; -inline bool SyncActionValue_StickerAction::_internal_has_height() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool SyncActionValue_StickerAction::has_height() const { - return _internal_has_height(); -} -inline void SyncActionValue_StickerAction::clear_height() { - _impl_.height_ = 0u; - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline uint32_t SyncActionValue_StickerAction::_internal_height() const { - return _impl_.height_; -} -inline uint32_t SyncActionValue_StickerAction::height() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.height) - return _internal_height(); -} -inline void SyncActionValue_StickerAction::_internal_set_height(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.height_ = value; -} -inline void SyncActionValue_StickerAction::set_height(uint32_t value) { - _internal_set_height(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.height) -} - -// optional uint32 width = 6; -inline bool SyncActionValue_StickerAction::_internal_has_width() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool SyncActionValue_StickerAction::has_width() const { - return _internal_has_width(); -} -inline void SyncActionValue_StickerAction::clear_width() { - _impl_.width_ = 0u; - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline uint32_t SyncActionValue_StickerAction::_internal_width() const { - return _impl_.width_; -} -inline uint32_t SyncActionValue_StickerAction::width() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.width) - return _internal_width(); -} -inline void SyncActionValue_StickerAction::_internal_set_width(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.width_ = value; -} -inline void SyncActionValue_StickerAction::set_width(uint32_t value) { - _internal_set_width(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.width) -} - -// optional string directPath = 7; -inline bool SyncActionValue_StickerAction::_internal_has_directpath() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool SyncActionValue_StickerAction::has_directpath() const { - return _internal_has_directpath(); -} -inline void SyncActionValue_StickerAction::clear_directpath() { - _impl_.directpath_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const std::string& SyncActionValue_StickerAction::directpath() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.directPath) - return _internal_directpath(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SyncActionValue_StickerAction::set_directpath(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.directpath_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.directPath) -} -inline std::string* SyncActionValue_StickerAction::mutable_directpath() { - std::string* _s = _internal_mutable_directpath(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.StickerAction.directPath) - return _s; -} -inline const std::string& SyncActionValue_StickerAction::_internal_directpath() const { - return _impl_.directpath_.Get(); -} -inline void SyncActionValue_StickerAction::_internal_set_directpath(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.directpath_.Set(value, GetArenaForAllocation()); -} -inline std::string* SyncActionValue_StickerAction::_internal_mutable_directpath() { - _impl_._has_bits_[0] |= 0x00000010u; - return _impl_.directpath_.Mutable(GetArenaForAllocation()); -} -inline std::string* SyncActionValue_StickerAction::release_directpath() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.StickerAction.directPath) - if (!_internal_has_directpath()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000010u; - auto* p = _impl_.directpath_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.directpath_.IsDefault()) { - _impl_.directpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SyncActionValue_StickerAction::set_allocated_directpath(std::string* directpath) { - if (directpath != nullptr) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.directpath_.IsDefault()) { - _impl_.directpath_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.StickerAction.directPath) -} - -// optional uint64 fileLength = 8; -inline bool SyncActionValue_StickerAction::_internal_has_filelength() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - return value; -} -inline bool SyncActionValue_StickerAction::has_filelength() const { - return _internal_has_filelength(); -} -inline void SyncActionValue_StickerAction::clear_filelength() { - _impl_.filelength_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline uint64_t SyncActionValue_StickerAction::_internal_filelength() const { - return _impl_.filelength_; -} -inline uint64_t SyncActionValue_StickerAction::filelength() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.fileLength) - return _internal_filelength(); -} -inline void SyncActionValue_StickerAction::_internal_set_filelength(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.filelength_ = value; -} -inline void SyncActionValue_StickerAction::set_filelength(uint64_t value) { - _internal_set_filelength(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.fileLength) -} - -// optional bool isFavorite = 9; -inline bool SyncActionValue_StickerAction::_internal_has_isfavorite() const { - bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; - return value; -} -inline bool SyncActionValue_StickerAction::has_isfavorite() const { - return _internal_has_isfavorite(); -} -inline void SyncActionValue_StickerAction::clear_isfavorite() { - _impl_.isfavorite_ = false; - _impl_._has_bits_[0] &= ~0x00000100u; -} -inline bool SyncActionValue_StickerAction::_internal_isfavorite() const { - return _impl_.isfavorite_; -} -inline bool SyncActionValue_StickerAction::isfavorite() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.isFavorite) - return _internal_isfavorite(); -} -inline void SyncActionValue_StickerAction::_internal_set_isfavorite(bool value) { - _impl_._has_bits_[0] |= 0x00000100u; - _impl_.isfavorite_ = value; -} -inline void SyncActionValue_StickerAction::set_isfavorite(bool value) { - _internal_set_isfavorite(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.isFavorite) -} - -// optional uint32 deviceIdHint = 10; -inline bool SyncActionValue_StickerAction::_internal_has_deviceidhint() const { - bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; - return value; -} -inline bool SyncActionValue_StickerAction::has_deviceidhint() const { - return _internal_has_deviceidhint(); -} -inline void SyncActionValue_StickerAction::clear_deviceidhint() { - _impl_.deviceidhint_ = 0u; - _impl_._has_bits_[0] &= ~0x00000200u; -} -inline uint32_t SyncActionValue_StickerAction::_internal_deviceidhint() const { - return _impl_.deviceidhint_; -} -inline uint32_t SyncActionValue_StickerAction::deviceidhint() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.deviceIdHint) - return _internal_deviceidhint(); -} -inline void SyncActionValue_StickerAction::_internal_set_deviceidhint(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.deviceidhint_ = value; -} -inline void SyncActionValue_StickerAction::set_deviceidhint(uint32_t value) { - _internal_set_deviceidhint(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.deviceIdHint) -} - -// ------------------------------------------------------------------- - -// SyncActionValue_SubscriptionAction - -// optional bool isDeactivated = 1; -inline bool SyncActionValue_SubscriptionAction::_internal_has_isdeactivated() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool SyncActionValue_SubscriptionAction::has_isdeactivated() const { - return _internal_has_isdeactivated(); -} -inline void SyncActionValue_SubscriptionAction::clear_isdeactivated() { - _impl_.isdeactivated_ = false; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline bool SyncActionValue_SubscriptionAction::_internal_isdeactivated() const { - return _impl_.isdeactivated_; -} -inline bool SyncActionValue_SubscriptionAction::isdeactivated() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.SubscriptionAction.isDeactivated) - return _internal_isdeactivated(); -} -inline void SyncActionValue_SubscriptionAction::_internal_set_isdeactivated(bool value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.isdeactivated_ = value; -} -inline void SyncActionValue_SubscriptionAction::set_isdeactivated(bool value) { - _internal_set_isdeactivated(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.SubscriptionAction.isDeactivated) -} - -// optional bool isAutoRenewing = 2; -inline bool SyncActionValue_SubscriptionAction::_internal_has_isautorenewing() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool SyncActionValue_SubscriptionAction::has_isautorenewing() const { - return _internal_has_isautorenewing(); -} -inline void SyncActionValue_SubscriptionAction::clear_isautorenewing() { - _impl_.isautorenewing_ = false; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline bool SyncActionValue_SubscriptionAction::_internal_isautorenewing() const { - return _impl_.isautorenewing_; -} -inline bool SyncActionValue_SubscriptionAction::isautorenewing() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.SubscriptionAction.isAutoRenewing) - return _internal_isautorenewing(); -} -inline void SyncActionValue_SubscriptionAction::_internal_set_isautorenewing(bool value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.isautorenewing_ = value; -} -inline void SyncActionValue_SubscriptionAction::set_isautorenewing(bool value) { - _internal_set_isautorenewing(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.SubscriptionAction.isAutoRenewing) -} - -// optional int64 expirationDate = 3; -inline bool SyncActionValue_SubscriptionAction::_internal_has_expirationdate() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SyncActionValue_SubscriptionAction::has_expirationdate() const { - return _internal_has_expirationdate(); -} -inline void SyncActionValue_SubscriptionAction::clear_expirationdate() { - _impl_.expirationdate_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline int64_t SyncActionValue_SubscriptionAction::_internal_expirationdate() const { - return _impl_.expirationdate_; -} -inline int64_t SyncActionValue_SubscriptionAction::expirationdate() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.SubscriptionAction.expirationDate) - return _internal_expirationdate(); -} -inline void SyncActionValue_SubscriptionAction::_internal_set_expirationdate(int64_t value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.expirationdate_ = value; -} -inline void SyncActionValue_SubscriptionAction::set_expirationdate(int64_t value) { - _internal_set_expirationdate(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.SubscriptionAction.expirationDate) -} - -// ------------------------------------------------------------------- - -// SyncActionValue_SyncActionMessageRange - -// optional int64 lastMessageTimestamp = 1; -inline bool SyncActionValue_SyncActionMessageRange::_internal_has_lastmessagetimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SyncActionValue_SyncActionMessageRange::has_lastmessagetimestamp() const { - return _internal_has_lastmessagetimestamp(); -} -inline void SyncActionValue_SyncActionMessageRange::clear_lastmessagetimestamp() { - _impl_.lastmessagetimestamp_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline int64_t SyncActionValue_SyncActionMessageRange::_internal_lastmessagetimestamp() const { - return _impl_.lastmessagetimestamp_; -} -inline int64_t SyncActionValue_SyncActionMessageRange::lastmessagetimestamp() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.SyncActionMessageRange.lastMessageTimestamp) - return _internal_lastmessagetimestamp(); -} -inline void SyncActionValue_SyncActionMessageRange::_internal_set_lastmessagetimestamp(int64_t value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.lastmessagetimestamp_ = value; -} -inline void SyncActionValue_SyncActionMessageRange::set_lastmessagetimestamp(int64_t value) { - _internal_set_lastmessagetimestamp(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.SyncActionMessageRange.lastMessageTimestamp) -} - -// optional int64 lastSystemMessageTimestamp = 2; -inline bool SyncActionValue_SyncActionMessageRange::_internal_has_lastsystemmessagetimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool SyncActionValue_SyncActionMessageRange::has_lastsystemmessagetimestamp() const { - return _internal_has_lastsystemmessagetimestamp(); -} -inline void SyncActionValue_SyncActionMessageRange::clear_lastsystemmessagetimestamp() { - _impl_.lastsystemmessagetimestamp_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline int64_t SyncActionValue_SyncActionMessageRange::_internal_lastsystemmessagetimestamp() const { - return _impl_.lastsystemmessagetimestamp_; -} -inline int64_t SyncActionValue_SyncActionMessageRange::lastsystemmessagetimestamp() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.SyncActionMessageRange.lastSystemMessageTimestamp) - return _internal_lastsystemmessagetimestamp(); -} -inline void SyncActionValue_SyncActionMessageRange::_internal_set_lastsystemmessagetimestamp(int64_t value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.lastsystemmessagetimestamp_ = value; -} -inline void SyncActionValue_SyncActionMessageRange::set_lastsystemmessagetimestamp(int64_t value) { - _internal_set_lastsystemmessagetimestamp(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.SyncActionMessageRange.lastSystemMessageTimestamp) -} - -// repeated .proto.SyncActionValue.SyncActionMessage messages = 3; -inline int SyncActionValue_SyncActionMessageRange::_internal_messages_size() const { - return _impl_.messages_.size(); -} -inline int SyncActionValue_SyncActionMessageRange::messages_size() const { - return _internal_messages_size(); -} -inline void SyncActionValue_SyncActionMessageRange::clear_messages() { - _impl_.messages_.Clear(); -} -inline ::proto::SyncActionValue_SyncActionMessage* SyncActionValue_SyncActionMessageRange::mutable_messages(int index) { - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.SyncActionMessageRange.messages) - return _impl_.messages_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncActionValue_SyncActionMessage >* -SyncActionValue_SyncActionMessageRange::mutable_messages() { - // @@protoc_insertion_point(field_mutable_list:proto.SyncActionValue.SyncActionMessageRange.messages) - return &_impl_.messages_; -} -inline const ::proto::SyncActionValue_SyncActionMessage& SyncActionValue_SyncActionMessageRange::_internal_messages(int index) const { - return _impl_.messages_.Get(index); -} -inline const ::proto::SyncActionValue_SyncActionMessage& SyncActionValue_SyncActionMessageRange::messages(int index) const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.SyncActionMessageRange.messages) - return _internal_messages(index); -} -inline ::proto::SyncActionValue_SyncActionMessage* SyncActionValue_SyncActionMessageRange::_internal_add_messages() { - return _impl_.messages_.Add(); -} -inline ::proto::SyncActionValue_SyncActionMessage* SyncActionValue_SyncActionMessageRange::add_messages() { - ::proto::SyncActionValue_SyncActionMessage* _add = _internal_add_messages(); - // @@protoc_insertion_point(field_add:proto.SyncActionValue.SyncActionMessageRange.messages) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncActionValue_SyncActionMessage >& -SyncActionValue_SyncActionMessageRange::messages() const { - // @@protoc_insertion_point(field_list:proto.SyncActionValue.SyncActionMessageRange.messages) - return _impl_.messages_; -} - -// ------------------------------------------------------------------- - -// SyncActionValue_SyncActionMessage - -// optional .proto.MessageKey key = 1; -inline bool SyncActionValue_SyncActionMessage::_internal_has_key() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr); - return value; -} -inline bool SyncActionValue_SyncActionMessage::has_key() const { - return _internal_has_key(); -} -inline void SyncActionValue_SyncActionMessage::clear_key() { - if (_impl_.key_ != nullptr) _impl_.key_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::MessageKey& SyncActionValue_SyncActionMessage::_internal_key() const { - const ::proto::MessageKey* p = _impl_.key_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_MessageKey_default_instance_); -} -inline const ::proto::MessageKey& SyncActionValue_SyncActionMessage::key() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.SyncActionMessage.key) - return _internal_key(); -} -inline void SyncActionValue_SyncActionMessage::unsafe_arena_set_allocated_key( - ::proto::MessageKey* key) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_); - } - _impl_.key_ = key; - if (key) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.SyncActionMessage.key) -} -inline ::proto::MessageKey* SyncActionValue_SyncActionMessage::release_key() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::MessageKey* temp = _impl_.key_; - _impl_.key_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::MessageKey* SyncActionValue_SyncActionMessage::unsafe_arena_release_key() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.SyncActionMessage.key) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::MessageKey* temp = _impl_.key_; - _impl_.key_ = nullptr; - return temp; -} -inline ::proto::MessageKey* SyncActionValue_SyncActionMessage::_internal_mutable_key() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.key_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation()); - _impl_.key_ = p; - } - return _impl_.key_; -} -inline ::proto::MessageKey* SyncActionValue_SyncActionMessage::mutable_key() { - ::proto::MessageKey* _msg = _internal_mutable_key(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.SyncActionMessage.key) - return _msg; -} -inline void SyncActionValue_SyncActionMessage::set_allocated_key(::proto::MessageKey* key) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.key_; - } - if (key) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key); - if (message_arena != submessage_arena) { - key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, key, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.key_ = key; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.SyncActionMessage.key) -} - -// optional int64 timestamp = 2; -inline bool SyncActionValue_SyncActionMessage::_internal_has_timestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool SyncActionValue_SyncActionMessage::has_timestamp() const { - return _internal_has_timestamp(); -} -inline void SyncActionValue_SyncActionMessage::clear_timestamp() { - _impl_.timestamp_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline int64_t SyncActionValue_SyncActionMessage::_internal_timestamp() const { - return _impl_.timestamp_; -} -inline int64_t SyncActionValue_SyncActionMessage::timestamp() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.SyncActionMessage.timestamp) - return _internal_timestamp(); -} -inline void SyncActionValue_SyncActionMessage::_internal_set_timestamp(int64_t value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.timestamp_ = value; -} -inline void SyncActionValue_SyncActionMessage::set_timestamp(int64_t value) { - _internal_set_timestamp(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.SyncActionMessage.timestamp) -} - -// ------------------------------------------------------------------- - -// SyncActionValue_TimeFormatAction - -// optional bool isTwentyFourHourFormatEnabled = 1; -inline bool SyncActionValue_TimeFormatAction::_internal_has_istwentyfourhourformatenabled() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SyncActionValue_TimeFormatAction::has_istwentyfourhourformatenabled() const { - return _internal_has_istwentyfourhourformatenabled(); -} -inline void SyncActionValue_TimeFormatAction::clear_istwentyfourhourformatenabled() { - _impl_.istwentyfourhourformatenabled_ = false; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline bool SyncActionValue_TimeFormatAction::_internal_istwentyfourhourformatenabled() const { - return _impl_.istwentyfourhourformatenabled_; -} -inline bool SyncActionValue_TimeFormatAction::istwentyfourhourformatenabled() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.TimeFormatAction.isTwentyFourHourFormatEnabled) - return _internal_istwentyfourhourformatenabled(); -} -inline void SyncActionValue_TimeFormatAction::_internal_set_istwentyfourhourformatenabled(bool value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.istwentyfourhourformatenabled_ = value; -} -inline void SyncActionValue_TimeFormatAction::set_istwentyfourhourformatenabled(bool value) { - _internal_set_istwentyfourhourformatenabled(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.TimeFormatAction.isTwentyFourHourFormatEnabled) -} - -// ------------------------------------------------------------------- - -// SyncActionValue_UnarchiveChatsSetting - -// optional bool unarchiveChats = 1; -inline bool SyncActionValue_UnarchiveChatsSetting::_internal_has_unarchivechats() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SyncActionValue_UnarchiveChatsSetting::has_unarchivechats() const { - return _internal_has_unarchivechats(); -} -inline void SyncActionValue_UnarchiveChatsSetting::clear_unarchivechats() { - _impl_.unarchivechats_ = false; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline bool SyncActionValue_UnarchiveChatsSetting::_internal_unarchivechats() const { - return _impl_.unarchivechats_; -} -inline bool SyncActionValue_UnarchiveChatsSetting::unarchivechats() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.UnarchiveChatsSetting.unarchiveChats) - return _internal_unarchivechats(); -} -inline void SyncActionValue_UnarchiveChatsSetting::_internal_set_unarchivechats(bool value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.unarchivechats_ = value; -} -inline void SyncActionValue_UnarchiveChatsSetting::set_unarchivechats(bool value) { - _internal_set_unarchivechats(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.UnarchiveChatsSetting.unarchiveChats) -} - -// ------------------------------------------------------------------- - -// SyncActionValue_UserStatusMuteAction - -// optional bool muted = 1; -inline bool SyncActionValue_UserStatusMuteAction::_internal_has_muted() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SyncActionValue_UserStatusMuteAction::has_muted() const { - return _internal_has_muted(); -} -inline void SyncActionValue_UserStatusMuteAction::clear_muted() { - _impl_.muted_ = false; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline bool SyncActionValue_UserStatusMuteAction::_internal_muted() const { - return _impl_.muted_; -} -inline bool SyncActionValue_UserStatusMuteAction::muted() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.UserStatusMuteAction.muted) - return _internal_muted(); -} -inline void SyncActionValue_UserStatusMuteAction::_internal_set_muted(bool value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.muted_ = value; -} -inline void SyncActionValue_UserStatusMuteAction::set_muted(bool value) { - _internal_set_muted(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.UserStatusMuteAction.muted) -} - -// ------------------------------------------------------------------- - -// SyncActionValue - -// optional int64 timestamp = 1; -inline bool SyncActionValue::_internal_has_timestamp() const { - bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0; - return value; -} -inline bool SyncActionValue::has_timestamp() const { - return _internal_has_timestamp(); -} -inline void SyncActionValue::clear_timestamp() { - _impl_.timestamp_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x08000000u; -} -inline int64_t SyncActionValue::_internal_timestamp() const { - return _impl_.timestamp_; -} -inline int64_t SyncActionValue::timestamp() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.timestamp) - return _internal_timestamp(); -} -inline void SyncActionValue::_internal_set_timestamp(int64_t value) { - _impl_._has_bits_[0] |= 0x08000000u; - _impl_.timestamp_ = value; -} -inline void SyncActionValue::set_timestamp(int64_t value) { - _internal_set_timestamp(value); - // @@protoc_insertion_point(field_set:proto.SyncActionValue.timestamp) -} - -// optional .proto.SyncActionValue.StarAction starAction = 2; -inline bool SyncActionValue::_internal_has_staraction() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.staraction_ != nullptr); - return value; -} -inline bool SyncActionValue::has_staraction() const { - return _internal_has_staraction(); -} -inline void SyncActionValue::clear_staraction() { - if (_impl_.staraction_ != nullptr) _impl_.staraction_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::SyncActionValue_StarAction& SyncActionValue::_internal_staraction() const { - const ::proto::SyncActionValue_StarAction* p = _impl_.staraction_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_StarAction_default_instance_); -} -inline const ::proto::SyncActionValue_StarAction& SyncActionValue::staraction() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.starAction) - return _internal_staraction(); -} -inline void SyncActionValue::unsafe_arena_set_allocated_staraction( - ::proto::SyncActionValue_StarAction* staraction) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.staraction_); - } - _impl_.staraction_ = staraction; - if (staraction) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.starAction) -} -inline ::proto::SyncActionValue_StarAction* SyncActionValue::release_staraction() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::SyncActionValue_StarAction* temp = _impl_.staraction_; - _impl_.staraction_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue_StarAction* SyncActionValue::unsafe_arena_release_staraction() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.starAction) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::SyncActionValue_StarAction* temp = _impl_.staraction_; - _impl_.staraction_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue_StarAction* SyncActionValue::_internal_mutable_staraction() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.staraction_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue_StarAction>(GetArenaForAllocation()); - _impl_.staraction_ = p; - } - return _impl_.staraction_; -} -inline ::proto::SyncActionValue_StarAction* SyncActionValue::mutable_staraction() { - ::proto::SyncActionValue_StarAction* _msg = _internal_mutable_staraction(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.starAction) - return _msg; -} -inline void SyncActionValue::set_allocated_staraction(::proto::SyncActionValue_StarAction* staraction) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.staraction_; - } - if (staraction) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(staraction); - if (message_arena != submessage_arena) { - staraction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, staraction, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.staraction_ = staraction; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.starAction) -} - -// optional .proto.SyncActionValue.ContactAction contactAction = 3; -inline bool SyncActionValue::_internal_has_contactaction() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.contactaction_ != nullptr); - return value; -} -inline bool SyncActionValue::has_contactaction() const { - return _internal_has_contactaction(); -} -inline void SyncActionValue::clear_contactaction() { - if (_impl_.contactaction_ != nullptr) _impl_.contactaction_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::SyncActionValue_ContactAction& SyncActionValue::_internal_contactaction() const { - const ::proto::SyncActionValue_ContactAction* p = _impl_.contactaction_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_ContactAction_default_instance_); -} -inline const ::proto::SyncActionValue_ContactAction& SyncActionValue::contactaction() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.contactAction) - return _internal_contactaction(); -} -inline void SyncActionValue::unsafe_arena_set_allocated_contactaction( - ::proto::SyncActionValue_ContactAction* contactaction) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contactaction_); - } - _impl_.contactaction_ = contactaction; - if (contactaction) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.contactAction) -} -inline ::proto::SyncActionValue_ContactAction* SyncActionValue::release_contactaction() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::SyncActionValue_ContactAction* temp = _impl_.contactaction_; - _impl_.contactaction_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue_ContactAction* SyncActionValue::unsafe_arena_release_contactaction() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.contactAction) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::SyncActionValue_ContactAction* temp = _impl_.contactaction_; - _impl_.contactaction_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue_ContactAction* SyncActionValue::_internal_mutable_contactaction() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.contactaction_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue_ContactAction>(GetArenaForAllocation()); - _impl_.contactaction_ = p; - } - return _impl_.contactaction_; -} -inline ::proto::SyncActionValue_ContactAction* SyncActionValue::mutable_contactaction() { - ::proto::SyncActionValue_ContactAction* _msg = _internal_mutable_contactaction(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.contactAction) - return _msg; -} -inline void SyncActionValue::set_allocated_contactaction(::proto::SyncActionValue_ContactAction* contactaction) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.contactaction_; - } - if (contactaction) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contactaction); - if (message_arena != submessage_arena) { - contactaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, contactaction, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.contactaction_ = contactaction; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.contactAction) -} - -// optional .proto.SyncActionValue.MuteAction muteAction = 4; -inline bool SyncActionValue::_internal_has_muteaction() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - PROTOBUF_ASSUME(!value || _impl_.muteaction_ != nullptr); - return value; -} -inline bool SyncActionValue::has_muteaction() const { - return _internal_has_muteaction(); -} -inline void SyncActionValue::clear_muteaction() { - if (_impl_.muteaction_ != nullptr) _impl_.muteaction_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const ::proto::SyncActionValue_MuteAction& SyncActionValue::_internal_muteaction() const { - const ::proto::SyncActionValue_MuteAction* p = _impl_.muteaction_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_MuteAction_default_instance_); -} -inline const ::proto::SyncActionValue_MuteAction& SyncActionValue::muteaction() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.muteAction) - return _internal_muteaction(); -} -inline void SyncActionValue::unsafe_arena_set_allocated_muteaction( - ::proto::SyncActionValue_MuteAction* muteaction) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.muteaction_); - } - _impl_.muteaction_ = muteaction; - if (muteaction) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.muteAction) -} -inline ::proto::SyncActionValue_MuteAction* SyncActionValue::release_muteaction() { - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::SyncActionValue_MuteAction* temp = _impl_.muteaction_; - _impl_.muteaction_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue_MuteAction* SyncActionValue::unsafe_arena_release_muteaction() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.muteAction) - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::SyncActionValue_MuteAction* temp = _impl_.muteaction_; - _impl_.muteaction_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue_MuteAction* SyncActionValue::_internal_mutable_muteaction() { - _impl_._has_bits_[0] |= 0x00000004u; - if (_impl_.muteaction_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue_MuteAction>(GetArenaForAllocation()); - _impl_.muteaction_ = p; - } - return _impl_.muteaction_; -} -inline ::proto::SyncActionValue_MuteAction* SyncActionValue::mutable_muteaction() { - ::proto::SyncActionValue_MuteAction* _msg = _internal_mutable_muteaction(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.muteAction) - return _msg; -} -inline void SyncActionValue::set_allocated_muteaction(::proto::SyncActionValue_MuteAction* muteaction) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.muteaction_; - } - if (muteaction) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(muteaction); - if (message_arena != submessage_arena) { - muteaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, muteaction, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.muteaction_ = muteaction; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.muteAction) -} - -// optional .proto.SyncActionValue.PinAction pinAction = 5; -inline bool SyncActionValue::_internal_has_pinaction() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - PROTOBUF_ASSUME(!value || _impl_.pinaction_ != nullptr); - return value; -} -inline bool SyncActionValue::has_pinaction() const { - return _internal_has_pinaction(); -} -inline void SyncActionValue::clear_pinaction() { - if (_impl_.pinaction_ != nullptr) _impl_.pinaction_->Clear(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const ::proto::SyncActionValue_PinAction& SyncActionValue::_internal_pinaction() const { - const ::proto::SyncActionValue_PinAction* p = _impl_.pinaction_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_PinAction_default_instance_); -} -inline const ::proto::SyncActionValue_PinAction& SyncActionValue::pinaction() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.pinAction) - return _internal_pinaction(); -} -inline void SyncActionValue::unsafe_arena_set_allocated_pinaction( - ::proto::SyncActionValue_PinAction* pinaction) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pinaction_); - } - _impl_.pinaction_ = pinaction; - if (pinaction) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.pinAction) -} -inline ::proto::SyncActionValue_PinAction* SyncActionValue::release_pinaction() { - _impl_._has_bits_[0] &= ~0x00000008u; - ::proto::SyncActionValue_PinAction* temp = _impl_.pinaction_; - _impl_.pinaction_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue_PinAction* SyncActionValue::unsafe_arena_release_pinaction() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.pinAction) - _impl_._has_bits_[0] &= ~0x00000008u; - ::proto::SyncActionValue_PinAction* temp = _impl_.pinaction_; - _impl_.pinaction_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue_PinAction* SyncActionValue::_internal_mutable_pinaction() { - _impl_._has_bits_[0] |= 0x00000008u; - if (_impl_.pinaction_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue_PinAction>(GetArenaForAllocation()); - _impl_.pinaction_ = p; - } - return _impl_.pinaction_; -} -inline ::proto::SyncActionValue_PinAction* SyncActionValue::mutable_pinaction() { - ::proto::SyncActionValue_PinAction* _msg = _internal_mutable_pinaction(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.pinAction) - return _msg; -} -inline void SyncActionValue::set_allocated_pinaction(::proto::SyncActionValue_PinAction* pinaction) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.pinaction_; - } - if (pinaction) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pinaction); - if (message_arena != submessage_arena) { - pinaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, pinaction, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.pinaction_ = pinaction; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.pinAction) -} - -// optional .proto.SyncActionValue.SecurityNotificationSetting securityNotificationSetting = 6; -inline bool SyncActionValue::_internal_has_securitynotificationsetting() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - PROTOBUF_ASSUME(!value || _impl_.securitynotificationsetting_ != nullptr); - return value; -} -inline bool SyncActionValue::has_securitynotificationsetting() const { - return _internal_has_securitynotificationsetting(); -} -inline void SyncActionValue::clear_securitynotificationsetting() { - if (_impl_.securitynotificationsetting_ != nullptr) _impl_.securitynotificationsetting_->Clear(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const ::proto::SyncActionValue_SecurityNotificationSetting& SyncActionValue::_internal_securitynotificationsetting() const { - const ::proto::SyncActionValue_SecurityNotificationSetting* p = _impl_.securitynotificationsetting_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_SecurityNotificationSetting_default_instance_); -} -inline const ::proto::SyncActionValue_SecurityNotificationSetting& SyncActionValue::securitynotificationsetting() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.securityNotificationSetting) - return _internal_securitynotificationsetting(); -} -inline void SyncActionValue::unsafe_arena_set_allocated_securitynotificationsetting( - ::proto::SyncActionValue_SecurityNotificationSetting* securitynotificationsetting) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.securitynotificationsetting_); - } - _impl_.securitynotificationsetting_ = securitynotificationsetting; - if (securitynotificationsetting) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.securityNotificationSetting) -} -inline ::proto::SyncActionValue_SecurityNotificationSetting* SyncActionValue::release_securitynotificationsetting() { - _impl_._has_bits_[0] &= ~0x00000010u; - ::proto::SyncActionValue_SecurityNotificationSetting* temp = _impl_.securitynotificationsetting_; - _impl_.securitynotificationsetting_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue_SecurityNotificationSetting* SyncActionValue::unsafe_arena_release_securitynotificationsetting() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.securityNotificationSetting) - _impl_._has_bits_[0] &= ~0x00000010u; - ::proto::SyncActionValue_SecurityNotificationSetting* temp = _impl_.securitynotificationsetting_; - _impl_.securitynotificationsetting_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue_SecurityNotificationSetting* SyncActionValue::_internal_mutable_securitynotificationsetting() { - _impl_._has_bits_[0] |= 0x00000010u; - if (_impl_.securitynotificationsetting_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue_SecurityNotificationSetting>(GetArenaForAllocation()); - _impl_.securitynotificationsetting_ = p; - } - return _impl_.securitynotificationsetting_; -} -inline ::proto::SyncActionValue_SecurityNotificationSetting* SyncActionValue::mutable_securitynotificationsetting() { - ::proto::SyncActionValue_SecurityNotificationSetting* _msg = _internal_mutable_securitynotificationsetting(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.securityNotificationSetting) - return _msg; -} -inline void SyncActionValue::set_allocated_securitynotificationsetting(::proto::SyncActionValue_SecurityNotificationSetting* securitynotificationsetting) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.securitynotificationsetting_; - } - if (securitynotificationsetting) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(securitynotificationsetting); - if (message_arena != submessage_arena) { - securitynotificationsetting = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, securitynotificationsetting, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.securitynotificationsetting_ = securitynotificationsetting; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.securityNotificationSetting) -} - -// optional .proto.SyncActionValue.PushNameSetting pushNameSetting = 7; -inline bool SyncActionValue::_internal_has_pushnamesetting() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - PROTOBUF_ASSUME(!value || _impl_.pushnamesetting_ != nullptr); - return value; -} -inline bool SyncActionValue::has_pushnamesetting() const { - return _internal_has_pushnamesetting(); -} -inline void SyncActionValue::clear_pushnamesetting() { - if (_impl_.pushnamesetting_ != nullptr) _impl_.pushnamesetting_->Clear(); - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline const ::proto::SyncActionValue_PushNameSetting& SyncActionValue::_internal_pushnamesetting() const { - const ::proto::SyncActionValue_PushNameSetting* p = _impl_.pushnamesetting_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_PushNameSetting_default_instance_); -} -inline const ::proto::SyncActionValue_PushNameSetting& SyncActionValue::pushnamesetting() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.pushNameSetting) - return _internal_pushnamesetting(); -} -inline void SyncActionValue::unsafe_arena_set_allocated_pushnamesetting( - ::proto::SyncActionValue_PushNameSetting* pushnamesetting) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pushnamesetting_); - } - _impl_.pushnamesetting_ = pushnamesetting; - if (pushnamesetting) { - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.pushNameSetting) -} -inline ::proto::SyncActionValue_PushNameSetting* SyncActionValue::release_pushnamesetting() { - _impl_._has_bits_[0] &= ~0x00000020u; - ::proto::SyncActionValue_PushNameSetting* temp = _impl_.pushnamesetting_; - _impl_.pushnamesetting_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue_PushNameSetting* SyncActionValue::unsafe_arena_release_pushnamesetting() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.pushNameSetting) - _impl_._has_bits_[0] &= ~0x00000020u; - ::proto::SyncActionValue_PushNameSetting* temp = _impl_.pushnamesetting_; - _impl_.pushnamesetting_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue_PushNameSetting* SyncActionValue::_internal_mutable_pushnamesetting() { - _impl_._has_bits_[0] |= 0x00000020u; - if (_impl_.pushnamesetting_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue_PushNameSetting>(GetArenaForAllocation()); - _impl_.pushnamesetting_ = p; - } - return _impl_.pushnamesetting_; -} -inline ::proto::SyncActionValue_PushNameSetting* SyncActionValue::mutable_pushnamesetting() { - ::proto::SyncActionValue_PushNameSetting* _msg = _internal_mutable_pushnamesetting(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.pushNameSetting) - return _msg; -} -inline void SyncActionValue::set_allocated_pushnamesetting(::proto::SyncActionValue_PushNameSetting* pushnamesetting) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.pushnamesetting_; - } - if (pushnamesetting) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pushnamesetting); - if (message_arena != submessage_arena) { - pushnamesetting = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, pushnamesetting, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - _impl_.pushnamesetting_ = pushnamesetting; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.pushNameSetting) -} - -// optional .proto.SyncActionValue.QuickReplyAction quickReplyAction = 8; -inline bool SyncActionValue::_internal_has_quickreplyaction() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - PROTOBUF_ASSUME(!value || _impl_.quickreplyaction_ != nullptr); - return value; -} -inline bool SyncActionValue::has_quickreplyaction() const { - return _internal_has_quickreplyaction(); -} -inline void SyncActionValue::clear_quickreplyaction() { - if (_impl_.quickreplyaction_ != nullptr) _impl_.quickreplyaction_->Clear(); - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline const ::proto::SyncActionValue_QuickReplyAction& SyncActionValue::_internal_quickreplyaction() const { - const ::proto::SyncActionValue_QuickReplyAction* p = _impl_.quickreplyaction_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_QuickReplyAction_default_instance_); -} -inline const ::proto::SyncActionValue_QuickReplyAction& SyncActionValue::quickreplyaction() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.quickReplyAction) - return _internal_quickreplyaction(); -} -inline void SyncActionValue::unsafe_arena_set_allocated_quickreplyaction( - ::proto::SyncActionValue_QuickReplyAction* quickreplyaction) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quickreplyaction_); - } - _impl_.quickreplyaction_ = quickreplyaction; - if (quickreplyaction) { - _impl_._has_bits_[0] |= 0x00000040u; - } else { - _impl_._has_bits_[0] &= ~0x00000040u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.quickReplyAction) -} -inline ::proto::SyncActionValue_QuickReplyAction* SyncActionValue::release_quickreplyaction() { - _impl_._has_bits_[0] &= ~0x00000040u; - ::proto::SyncActionValue_QuickReplyAction* temp = _impl_.quickreplyaction_; - _impl_.quickreplyaction_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue_QuickReplyAction* SyncActionValue::unsafe_arena_release_quickreplyaction() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.quickReplyAction) - _impl_._has_bits_[0] &= ~0x00000040u; - ::proto::SyncActionValue_QuickReplyAction* temp = _impl_.quickreplyaction_; - _impl_.quickreplyaction_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue_QuickReplyAction* SyncActionValue::_internal_mutable_quickreplyaction() { - _impl_._has_bits_[0] |= 0x00000040u; - if (_impl_.quickreplyaction_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue_QuickReplyAction>(GetArenaForAllocation()); - _impl_.quickreplyaction_ = p; - } - return _impl_.quickreplyaction_; -} -inline ::proto::SyncActionValue_QuickReplyAction* SyncActionValue::mutable_quickreplyaction() { - ::proto::SyncActionValue_QuickReplyAction* _msg = _internal_mutable_quickreplyaction(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.quickReplyAction) - return _msg; -} -inline void SyncActionValue::set_allocated_quickreplyaction(::proto::SyncActionValue_QuickReplyAction* quickreplyaction) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.quickreplyaction_; - } - if (quickreplyaction) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quickreplyaction); - if (message_arena != submessage_arena) { - quickreplyaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, quickreplyaction, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000040u; - } else { - _impl_._has_bits_[0] &= ~0x00000040u; - } - _impl_.quickreplyaction_ = quickreplyaction; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.quickReplyAction) -} - -// optional .proto.SyncActionValue.RecentEmojiWeightsAction recentEmojiWeightsAction = 11; -inline bool SyncActionValue::_internal_has_recentemojiweightsaction() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - PROTOBUF_ASSUME(!value || _impl_.recentemojiweightsaction_ != nullptr); - return value; -} -inline bool SyncActionValue::has_recentemojiweightsaction() const { - return _internal_has_recentemojiweightsaction(); -} -inline void SyncActionValue::clear_recentemojiweightsaction() { - if (_impl_.recentemojiweightsaction_ != nullptr) _impl_.recentemojiweightsaction_->Clear(); - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline const ::proto::SyncActionValue_RecentEmojiWeightsAction& SyncActionValue::_internal_recentemojiweightsaction() const { - const ::proto::SyncActionValue_RecentEmojiWeightsAction* p = _impl_.recentemojiweightsaction_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_RecentEmojiWeightsAction_default_instance_); -} -inline const ::proto::SyncActionValue_RecentEmojiWeightsAction& SyncActionValue::recentemojiweightsaction() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.recentEmojiWeightsAction) - return _internal_recentemojiweightsaction(); -} -inline void SyncActionValue::unsafe_arena_set_allocated_recentemojiweightsaction( - ::proto::SyncActionValue_RecentEmojiWeightsAction* recentemojiweightsaction) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.recentemojiweightsaction_); - } - _impl_.recentemojiweightsaction_ = recentemojiweightsaction; - if (recentemojiweightsaction) { - _impl_._has_bits_[0] |= 0x00000080u; - } else { - _impl_._has_bits_[0] &= ~0x00000080u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.recentEmojiWeightsAction) -} -inline ::proto::SyncActionValue_RecentEmojiWeightsAction* SyncActionValue::release_recentemojiweightsaction() { - _impl_._has_bits_[0] &= ~0x00000080u; - ::proto::SyncActionValue_RecentEmojiWeightsAction* temp = _impl_.recentemojiweightsaction_; - _impl_.recentemojiweightsaction_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue_RecentEmojiWeightsAction* SyncActionValue::unsafe_arena_release_recentemojiweightsaction() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.recentEmojiWeightsAction) - _impl_._has_bits_[0] &= ~0x00000080u; - ::proto::SyncActionValue_RecentEmojiWeightsAction* temp = _impl_.recentemojiweightsaction_; - _impl_.recentemojiweightsaction_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue_RecentEmojiWeightsAction* SyncActionValue::_internal_mutable_recentemojiweightsaction() { - _impl_._has_bits_[0] |= 0x00000080u; - if (_impl_.recentemojiweightsaction_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue_RecentEmojiWeightsAction>(GetArenaForAllocation()); - _impl_.recentemojiweightsaction_ = p; - } - return _impl_.recentemojiweightsaction_; -} -inline ::proto::SyncActionValue_RecentEmojiWeightsAction* SyncActionValue::mutable_recentemojiweightsaction() { - ::proto::SyncActionValue_RecentEmojiWeightsAction* _msg = _internal_mutable_recentemojiweightsaction(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.recentEmojiWeightsAction) - return _msg; -} -inline void SyncActionValue::set_allocated_recentemojiweightsaction(::proto::SyncActionValue_RecentEmojiWeightsAction* recentemojiweightsaction) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.recentemojiweightsaction_; - } - if (recentemojiweightsaction) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(recentemojiweightsaction); - if (message_arena != submessage_arena) { - recentemojiweightsaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, recentemojiweightsaction, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000080u; - } else { - _impl_._has_bits_[0] &= ~0x00000080u; - } - _impl_.recentemojiweightsaction_ = recentemojiweightsaction; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.recentEmojiWeightsAction) -} - -// optional .proto.SyncActionValue.LabelEditAction labelEditAction = 14; -inline bool SyncActionValue::_internal_has_labeleditaction() const { - bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; - PROTOBUF_ASSUME(!value || _impl_.labeleditaction_ != nullptr); - return value; -} -inline bool SyncActionValue::has_labeleditaction() const { - return _internal_has_labeleditaction(); -} -inline void SyncActionValue::clear_labeleditaction() { - if (_impl_.labeleditaction_ != nullptr) _impl_.labeleditaction_->Clear(); - _impl_._has_bits_[0] &= ~0x00000100u; -} -inline const ::proto::SyncActionValue_LabelEditAction& SyncActionValue::_internal_labeleditaction() const { - const ::proto::SyncActionValue_LabelEditAction* p = _impl_.labeleditaction_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_LabelEditAction_default_instance_); -} -inline const ::proto::SyncActionValue_LabelEditAction& SyncActionValue::labeleditaction() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.labelEditAction) - return _internal_labeleditaction(); -} -inline void SyncActionValue::unsafe_arena_set_allocated_labeleditaction( - ::proto::SyncActionValue_LabelEditAction* labeleditaction) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.labeleditaction_); - } - _impl_.labeleditaction_ = labeleditaction; - if (labeleditaction) { - _impl_._has_bits_[0] |= 0x00000100u; - } else { - _impl_._has_bits_[0] &= ~0x00000100u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.labelEditAction) -} -inline ::proto::SyncActionValue_LabelEditAction* SyncActionValue::release_labeleditaction() { - _impl_._has_bits_[0] &= ~0x00000100u; - ::proto::SyncActionValue_LabelEditAction* temp = _impl_.labeleditaction_; - _impl_.labeleditaction_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue_LabelEditAction* SyncActionValue::unsafe_arena_release_labeleditaction() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.labelEditAction) - _impl_._has_bits_[0] &= ~0x00000100u; - ::proto::SyncActionValue_LabelEditAction* temp = _impl_.labeleditaction_; - _impl_.labeleditaction_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue_LabelEditAction* SyncActionValue::_internal_mutable_labeleditaction() { - _impl_._has_bits_[0] |= 0x00000100u; - if (_impl_.labeleditaction_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue_LabelEditAction>(GetArenaForAllocation()); - _impl_.labeleditaction_ = p; - } - return _impl_.labeleditaction_; -} -inline ::proto::SyncActionValue_LabelEditAction* SyncActionValue::mutable_labeleditaction() { - ::proto::SyncActionValue_LabelEditAction* _msg = _internal_mutable_labeleditaction(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.labelEditAction) - return _msg; -} -inline void SyncActionValue::set_allocated_labeleditaction(::proto::SyncActionValue_LabelEditAction* labeleditaction) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.labeleditaction_; - } - if (labeleditaction) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(labeleditaction); - if (message_arena != submessage_arena) { - labeleditaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, labeleditaction, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000100u; - } else { - _impl_._has_bits_[0] &= ~0x00000100u; - } - _impl_.labeleditaction_ = labeleditaction; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.labelEditAction) -} - -// optional .proto.SyncActionValue.LabelAssociationAction labelAssociationAction = 15; -inline bool SyncActionValue::_internal_has_labelassociationaction() const { - bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; - PROTOBUF_ASSUME(!value || _impl_.labelassociationaction_ != nullptr); - return value; -} -inline bool SyncActionValue::has_labelassociationaction() const { - return _internal_has_labelassociationaction(); -} -inline void SyncActionValue::clear_labelassociationaction() { - if (_impl_.labelassociationaction_ != nullptr) _impl_.labelassociationaction_->Clear(); - _impl_._has_bits_[0] &= ~0x00000200u; -} -inline const ::proto::SyncActionValue_LabelAssociationAction& SyncActionValue::_internal_labelassociationaction() const { - const ::proto::SyncActionValue_LabelAssociationAction* p = _impl_.labelassociationaction_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_LabelAssociationAction_default_instance_); -} -inline const ::proto::SyncActionValue_LabelAssociationAction& SyncActionValue::labelassociationaction() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.labelAssociationAction) - return _internal_labelassociationaction(); -} -inline void SyncActionValue::unsafe_arena_set_allocated_labelassociationaction( - ::proto::SyncActionValue_LabelAssociationAction* labelassociationaction) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.labelassociationaction_); - } - _impl_.labelassociationaction_ = labelassociationaction; - if (labelassociationaction) { - _impl_._has_bits_[0] |= 0x00000200u; - } else { - _impl_._has_bits_[0] &= ~0x00000200u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.labelAssociationAction) -} -inline ::proto::SyncActionValue_LabelAssociationAction* SyncActionValue::release_labelassociationaction() { - _impl_._has_bits_[0] &= ~0x00000200u; - ::proto::SyncActionValue_LabelAssociationAction* temp = _impl_.labelassociationaction_; - _impl_.labelassociationaction_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue_LabelAssociationAction* SyncActionValue::unsafe_arena_release_labelassociationaction() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.labelAssociationAction) - _impl_._has_bits_[0] &= ~0x00000200u; - ::proto::SyncActionValue_LabelAssociationAction* temp = _impl_.labelassociationaction_; - _impl_.labelassociationaction_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue_LabelAssociationAction* SyncActionValue::_internal_mutable_labelassociationaction() { - _impl_._has_bits_[0] |= 0x00000200u; - if (_impl_.labelassociationaction_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue_LabelAssociationAction>(GetArenaForAllocation()); - _impl_.labelassociationaction_ = p; - } - return _impl_.labelassociationaction_; -} -inline ::proto::SyncActionValue_LabelAssociationAction* SyncActionValue::mutable_labelassociationaction() { - ::proto::SyncActionValue_LabelAssociationAction* _msg = _internal_mutable_labelassociationaction(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.labelAssociationAction) - return _msg; -} -inline void SyncActionValue::set_allocated_labelassociationaction(::proto::SyncActionValue_LabelAssociationAction* labelassociationaction) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.labelassociationaction_; - } - if (labelassociationaction) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(labelassociationaction); - if (message_arena != submessage_arena) { - labelassociationaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, labelassociationaction, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000200u; - } else { - _impl_._has_bits_[0] &= ~0x00000200u; - } - _impl_.labelassociationaction_ = labelassociationaction; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.labelAssociationAction) -} - -// optional .proto.SyncActionValue.LocaleSetting localeSetting = 16; -inline bool SyncActionValue::_internal_has_localesetting() const { - bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; - PROTOBUF_ASSUME(!value || _impl_.localesetting_ != nullptr); - return value; -} -inline bool SyncActionValue::has_localesetting() const { - return _internal_has_localesetting(); -} -inline void SyncActionValue::clear_localesetting() { - if (_impl_.localesetting_ != nullptr) _impl_.localesetting_->Clear(); - _impl_._has_bits_[0] &= ~0x00000400u; -} -inline const ::proto::SyncActionValue_LocaleSetting& SyncActionValue::_internal_localesetting() const { - const ::proto::SyncActionValue_LocaleSetting* p = _impl_.localesetting_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_LocaleSetting_default_instance_); -} -inline const ::proto::SyncActionValue_LocaleSetting& SyncActionValue::localesetting() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.localeSetting) - return _internal_localesetting(); -} -inline void SyncActionValue::unsafe_arena_set_allocated_localesetting( - ::proto::SyncActionValue_LocaleSetting* localesetting) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.localesetting_); - } - _impl_.localesetting_ = localesetting; - if (localesetting) { - _impl_._has_bits_[0] |= 0x00000400u; - } else { - _impl_._has_bits_[0] &= ~0x00000400u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.localeSetting) -} -inline ::proto::SyncActionValue_LocaleSetting* SyncActionValue::release_localesetting() { - _impl_._has_bits_[0] &= ~0x00000400u; - ::proto::SyncActionValue_LocaleSetting* temp = _impl_.localesetting_; - _impl_.localesetting_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue_LocaleSetting* SyncActionValue::unsafe_arena_release_localesetting() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.localeSetting) - _impl_._has_bits_[0] &= ~0x00000400u; - ::proto::SyncActionValue_LocaleSetting* temp = _impl_.localesetting_; - _impl_.localesetting_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue_LocaleSetting* SyncActionValue::_internal_mutable_localesetting() { - _impl_._has_bits_[0] |= 0x00000400u; - if (_impl_.localesetting_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue_LocaleSetting>(GetArenaForAllocation()); - _impl_.localesetting_ = p; - } - return _impl_.localesetting_; -} -inline ::proto::SyncActionValue_LocaleSetting* SyncActionValue::mutable_localesetting() { - ::proto::SyncActionValue_LocaleSetting* _msg = _internal_mutable_localesetting(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.localeSetting) - return _msg; -} -inline void SyncActionValue::set_allocated_localesetting(::proto::SyncActionValue_LocaleSetting* localesetting) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.localesetting_; - } - if (localesetting) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(localesetting); - if (message_arena != submessage_arena) { - localesetting = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, localesetting, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000400u; - } else { - _impl_._has_bits_[0] &= ~0x00000400u; - } - _impl_.localesetting_ = localesetting; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.localeSetting) -} - -// optional .proto.SyncActionValue.ArchiveChatAction archiveChatAction = 17; -inline bool SyncActionValue::_internal_has_archivechataction() const { - bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; - PROTOBUF_ASSUME(!value || _impl_.archivechataction_ != nullptr); - return value; -} -inline bool SyncActionValue::has_archivechataction() const { - return _internal_has_archivechataction(); -} -inline void SyncActionValue::clear_archivechataction() { - if (_impl_.archivechataction_ != nullptr) _impl_.archivechataction_->Clear(); - _impl_._has_bits_[0] &= ~0x00000800u; -} -inline const ::proto::SyncActionValue_ArchiveChatAction& SyncActionValue::_internal_archivechataction() const { - const ::proto::SyncActionValue_ArchiveChatAction* p = _impl_.archivechataction_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_ArchiveChatAction_default_instance_); -} -inline const ::proto::SyncActionValue_ArchiveChatAction& SyncActionValue::archivechataction() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.archiveChatAction) - return _internal_archivechataction(); -} -inline void SyncActionValue::unsafe_arena_set_allocated_archivechataction( - ::proto::SyncActionValue_ArchiveChatAction* archivechataction) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.archivechataction_); - } - _impl_.archivechataction_ = archivechataction; - if (archivechataction) { - _impl_._has_bits_[0] |= 0x00000800u; - } else { - _impl_._has_bits_[0] &= ~0x00000800u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.archiveChatAction) -} -inline ::proto::SyncActionValue_ArchiveChatAction* SyncActionValue::release_archivechataction() { - _impl_._has_bits_[0] &= ~0x00000800u; - ::proto::SyncActionValue_ArchiveChatAction* temp = _impl_.archivechataction_; - _impl_.archivechataction_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue_ArchiveChatAction* SyncActionValue::unsafe_arena_release_archivechataction() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.archiveChatAction) - _impl_._has_bits_[0] &= ~0x00000800u; - ::proto::SyncActionValue_ArchiveChatAction* temp = _impl_.archivechataction_; - _impl_.archivechataction_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue_ArchiveChatAction* SyncActionValue::_internal_mutable_archivechataction() { - _impl_._has_bits_[0] |= 0x00000800u; - if (_impl_.archivechataction_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue_ArchiveChatAction>(GetArenaForAllocation()); - _impl_.archivechataction_ = p; - } - return _impl_.archivechataction_; -} -inline ::proto::SyncActionValue_ArchiveChatAction* SyncActionValue::mutable_archivechataction() { - ::proto::SyncActionValue_ArchiveChatAction* _msg = _internal_mutable_archivechataction(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.archiveChatAction) - return _msg; -} -inline void SyncActionValue::set_allocated_archivechataction(::proto::SyncActionValue_ArchiveChatAction* archivechataction) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.archivechataction_; - } - if (archivechataction) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(archivechataction); - if (message_arena != submessage_arena) { - archivechataction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, archivechataction, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000800u; - } else { - _impl_._has_bits_[0] &= ~0x00000800u; - } - _impl_.archivechataction_ = archivechataction; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.archiveChatAction) -} - -// optional .proto.SyncActionValue.DeleteMessageForMeAction deleteMessageForMeAction = 18; -inline bool SyncActionValue::_internal_has_deletemessageformeaction() const { - bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.deletemessageformeaction_ != nullptr); - return value; -} -inline bool SyncActionValue::has_deletemessageformeaction() const { - return _internal_has_deletemessageformeaction(); -} -inline void SyncActionValue::clear_deletemessageformeaction() { - if (_impl_.deletemessageformeaction_ != nullptr) _impl_.deletemessageformeaction_->Clear(); - _impl_._has_bits_[0] &= ~0x00001000u; -} -inline const ::proto::SyncActionValue_DeleteMessageForMeAction& SyncActionValue::_internal_deletemessageformeaction() const { - const ::proto::SyncActionValue_DeleteMessageForMeAction* p = _impl_.deletemessageformeaction_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_DeleteMessageForMeAction_default_instance_); -} -inline const ::proto::SyncActionValue_DeleteMessageForMeAction& SyncActionValue::deletemessageformeaction() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.deleteMessageForMeAction) - return _internal_deletemessageformeaction(); -} -inline void SyncActionValue::unsafe_arena_set_allocated_deletemessageformeaction( - ::proto::SyncActionValue_DeleteMessageForMeAction* deletemessageformeaction) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.deletemessageformeaction_); - } - _impl_.deletemessageformeaction_ = deletemessageformeaction; - if (deletemessageformeaction) { - _impl_._has_bits_[0] |= 0x00001000u; - } else { - _impl_._has_bits_[0] &= ~0x00001000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.deleteMessageForMeAction) -} -inline ::proto::SyncActionValue_DeleteMessageForMeAction* SyncActionValue::release_deletemessageformeaction() { - _impl_._has_bits_[0] &= ~0x00001000u; - ::proto::SyncActionValue_DeleteMessageForMeAction* temp = _impl_.deletemessageformeaction_; - _impl_.deletemessageformeaction_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue_DeleteMessageForMeAction* SyncActionValue::unsafe_arena_release_deletemessageformeaction() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.deleteMessageForMeAction) - _impl_._has_bits_[0] &= ~0x00001000u; - ::proto::SyncActionValue_DeleteMessageForMeAction* temp = _impl_.deletemessageformeaction_; - _impl_.deletemessageformeaction_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue_DeleteMessageForMeAction* SyncActionValue::_internal_mutable_deletemessageformeaction() { - _impl_._has_bits_[0] |= 0x00001000u; - if (_impl_.deletemessageformeaction_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue_DeleteMessageForMeAction>(GetArenaForAllocation()); - _impl_.deletemessageformeaction_ = p; - } - return _impl_.deletemessageformeaction_; -} -inline ::proto::SyncActionValue_DeleteMessageForMeAction* SyncActionValue::mutable_deletemessageformeaction() { - ::proto::SyncActionValue_DeleteMessageForMeAction* _msg = _internal_mutable_deletemessageformeaction(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.deleteMessageForMeAction) - return _msg; -} -inline void SyncActionValue::set_allocated_deletemessageformeaction(::proto::SyncActionValue_DeleteMessageForMeAction* deletemessageformeaction) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.deletemessageformeaction_; - } - if (deletemessageformeaction) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(deletemessageformeaction); - if (message_arena != submessage_arena) { - deletemessageformeaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, deletemessageformeaction, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00001000u; - } else { - _impl_._has_bits_[0] &= ~0x00001000u; - } - _impl_.deletemessageformeaction_ = deletemessageformeaction; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.deleteMessageForMeAction) -} - -// optional .proto.SyncActionValue.KeyExpiration keyExpiration = 19; -inline bool SyncActionValue::_internal_has_keyexpiration() const { - bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.keyexpiration_ != nullptr); - return value; -} -inline bool SyncActionValue::has_keyexpiration() const { - return _internal_has_keyexpiration(); -} -inline void SyncActionValue::clear_keyexpiration() { - if (_impl_.keyexpiration_ != nullptr) _impl_.keyexpiration_->Clear(); - _impl_._has_bits_[0] &= ~0x00002000u; -} -inline const ::proto::SyncActionValue_KeyExpiration& SyncActionValue::_internal_keyexpiration() const { - const ::proto::SyncActionValue_KeyExpiration* p = _impl_.keyexpiration_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_KeyExpiration_default_instance_); -} -inline const ::proto::SyncActionValue_KeyExpiration& SyncActionValue::keyexpiration() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.keyExpiration) - return _internal_keyexpiration(); -} -inline void SyncActionValue::unsafe_arena_set_allocated_keyexpiration( - ::proto::SyncActionValue_KeyExpiration* keyexpiration) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keyexpiration_); - } - _impl_.keyexpiration_ = keyexpiration; - if (keyexpiration) { - _impl_._has_bits_[0] |= 0x00002000u; - } else { - _impl_._has_bits_[0] &= ~0x00002000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.keyExpiration) -} -inline ::proto::SyncActionValue_KeyExpiration* SyncActionValue::release_keyexpiration() { - _impl_._has_bits_[0] &= ~0x00002000u; - ::proto::SyncActionValue_KeyExpiration* temp = _impl_.keyexpiration_; - _impl_.keyexpiration_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue_KeyExpiration* SyncActionValue::unsafe_arena_release_keyexpiration() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.keyExpiration) - _impl_._has_bits_[0] &= ~0x00002000u; - ::proto::SyncActionValue_KeyExpiration* temp = _impl_.keyexpiration_; - _impl_.keyexpiration_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue_KeyExpiration* SyncActionValue::_internal_mutable_keyexpiration() { - _impl_._has_bits_[0] |= 0x00002000u; - if (_impl_.keyexpiration_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue_KeyExpiration>(GetArenaForAllocation()); - _impl_.keyexpiration_ = p; - } - return _impl_.keyexpiration_; -} -inline ::proto::SyncActionValue_KeyExpiration* SyncActionValue::mutable_keyexpiration() { - ::proto::SyncActionValue_KeyExpiration* _msg = _internal_mutable_keyexpiration(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.keyExpiration) - return _msg; -} -inline void SyncActionValue::set_allocated_keyexpiration(::proto::SyncActionValue_KeyExpiration* keyexpiration) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.keyexpiration_; - } - if (keyexpiration) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keyexpiration); - if (message_arena != submessage_arena) { - keyexpiration = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, keyexpiration, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00002000u; - } else { - _impl_._has_bits_[0] &= ~0x00002000u; - } - _impl_.keyexpiration_ = keyexpiration; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.keyExpiration) -} - -// optional .proto.SyncActionValue.MarkChatAsReadAction markChatAsReadAction = 20; -inline bool SyncActionValue::_internal_has_markchatasreadaction() const { - bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.markchatasreadaction_ != nullptr); - return value; -} -inline bool SyncActionValue::has_markchatasreadaction() const { - return _internal_has_markchatasreadaction(); -} -inline void SyncActionValue::clear_markchatasreadaction() { - if (_impl_.markchatasreadaction_ != nullptr) _impl_.markchatasreadaction_->Clear(); - _impl_._has_bits_[0] &= ~0x00004000u; -} -inline const ::proto::SyncActionValue_MarkChatAsReadAction& SyncActionValue::_internal_markchatasreadaction() const { - const ::proto::SyncActionValue_MarkChatAsReadAction* p = _impl_.markchatasreadaction_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_MarkChatAsReadAction_default_instance_); -} -inline const ::proto::SyncActionValue_MarkChatAsReadAction& SyncActionValue::markchatasreadaction() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.markChatAsReadAction) - return _internal_markchatasreadaction(); -} -inline void SyncActionValue::unsafe_arena_set_allocated_markchatasreadaction( - ::proto::SyncActionValue_MarkChatAsReadAction* markchatasreadaction) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.markchatasreadaction_); - } - _impl_.markchatasreadaction_ = markchatasreadaction; - if (markchatasreadaction) { - _impl_._has_bits_[0] |= 0x00004000u; - } else { - _impl_._has_bits_[0] &= ~0x00004000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.markChatAsReadAction) -} -inline ::proto::SyncActionValue_MarkChatAsReadAction* SyncActionValue::release_markchatasreadaction() { - _impl_._has_bits_[0] &= ~0x00004000u; - ::proto::SyncActionValue_MarkChatAsReadAction* temp = _impl_.markchatasreadaction_; - _impl_.markchatasreadaction_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue_MarkChatAsReadAction* SyncActionValue::unsafe_arena_release_markchatasreadaction() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.markChatAsReadAction) - _impl_._has_bits_[0] &= ~0x00004000u; - ::proto::SyncActionValue_MarkChatAsReadAction* temp = _impl_.markchatasreadaction_; - _impl_.markchatasreadaction_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue_MarkChatAsReadAction* SyncActionValue::_internal_mutable_markchatasreadaction() { - _impl_._has_bits_[0] |= 0x00004000u; - if (_impl_.markchatasreadaction_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue_MarkChatAsReadAction>(GetArenaForAllocation()); - _impl_.markchatasreadaction_ = p; - } - return _impl_.markchatasreadaction_; -} -inline ::proto::SyncActionValue_MarkChatAsReadAction* SyncActionValue::mutable_markchatasreadaction() { - ::proto::SyncActionValue_MarkChatAsReadAction* _msg = _internal_mutable_markchatasreadaction(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.markChatAsReadAction) - return _msg; -} -inline void SyncActionValue::set_allocated_markchatasreadaction(::proto::SyncActionValue_MarkChatAsReadAction* markchatasreadaction) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.markchatasreadaction_; - } - if (markchatasreadaction) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(markchatasreadaction); - if (message_arena != submessage_arena) { - markchatasreadaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, markchatasreadaction, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00004000u; - } else { - _impl_._has_bits_[0] &= ~0x00004000u; - } - _impl_.markchatasreadaction_ = markchatasreadaction; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.markChatAsReadAction) -} - -// optional .proto.SyncActionValue.ClearChatAction clearChatAction = 21; -inline bool SyncActionValue::_internal_has_clearchataction() const { - bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.clearchataction_ != nullptr); - return value; -} -inline bool SyncActionValue::has_clearchataction() const { - return _internal_has_clearchataction(); -} -inline void SyncActionValue::clear_clearchataction() { - if (_impl_.clearchataction_ != nullptr) _impl_.clearchataction_->Clear(); - _impl_._has_bits_[0] &= ~0x00008000u; -} -inline const ::proto::SyncActionValue_ClearChatAction& SyncActionValue::_internal_clearchataction() const { - const ::proto::SyncActionValue_ClearChatAction* p = _impl_.clearchataction_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_ClearChatAction_default_instance_); -} -inline const ::proto::SyncActionValue_ClearChatAction& SyncActionValue::clearchataction() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.clearChatAction) - return _internal_clearchataction(); -} -inline void SyncActionValue::unsafe_arena_set_allocated_clearchataction( - ::proto::SyncActionValue_ClearChatAction* clearchataction) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.clearchataction_); - } - _impl_.clearchataction_ = clearchataction; - if (clearchataction) { - _impl_._has_bits_[0] |= 0x00008000u; - } else { - _impl_._has_bits_[0] &= ~0x00008000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.clearChatAction) -} -inline ::proto::SyncActionValue_ClearChatAction* SyncActionValue::release_clearchataction() { - _impl_._has_bits_[0] &= ~0x00008000u; - ::proto::SyncActionValue_ClearChatAction* temp = _impl_.clearchataction_; - _impl_.clearchataction_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue_ClearChatAction* SyncActionValue::unsafe_arena_release_clearchataction() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.clearChatAction) - _impl_._has_bits_[0] &= ~0x00008000u; - ::proto::SyncActionValue_ClearChatAction* temp = _impl_.clearchataction_; - _impl_.clearchataction_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue_ClearChatAction* SyncActionValue::_internal_mutable_clearchataction() { - _impl_._has_bits_[0] |= 0x00008000u; - if (_impl_.clearchataction_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue_ClearChatAction>(GetArenaForAllocation()); - _impl_.clearchataction_ = p; - } - return _impl_.clearchataction_; -} -inline ::proto::SyncActionValue_ClearChatAction* SyncActionValue::mutable_clearchataction() { - ::proto::SyncActionValue_ClearChatAction* _msg = _internal_mutable_clearchataction(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.clearChatAction) - return _msg; -} -inline void SyncActionValue::set_allocated_clearchataction(::proto::SyncActionValue_ClearChatAction* clearchataction) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.clearchataction_; - } - if (clearchataction) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(clearchataction); - if (message_arena != submessage_arena) { - clearchataction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, clearchataction, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00008000u; - } else { - _impl_._has_bits_[0] &= ~0x00008000u; - } - _impl_.clearchataction_ = clearchataction; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.clearChatAction) -} - -// optional .proto.SyncActionValue.DeleteChatAction deleteChatAction = 22; -inline bool SyncActionValue::_internal_has_deletechataction() const { - bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.deletechataction_ != nullptr); - return value; -} -inline bool SyncActionValue::has_deletechataction() const { - return _internal_has_deletechataction(); -} -inline void SyncActionValue::clear_deletechataction() { - if (_impl_.deletechataction_ != nullptr) _impl_.deletechataction_->Clear(); - _impl_._has_bits_[0] &= ~0x00010000u; -} -inline const ::proto::SyncActionValue_DeleteChatAction& SyncActionValue::_internal_deletechataction() const { - const ::proto::SyncActionValue_DeleteChatAction* p = _impl_.deletechataction_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_DeleteChatAction_default_instance_); -} -inline const ::proto::SyncActionValue_DeleteChatAction& SyncActionValue::deletechataction() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.deleteChatAction) - return _internal_deletechataction(); -} -inline void SyncActionValue::unsafe_arena_set_allocated_deletechataction( - ::proto::SyncActionValue_DeleteChatAction* deletechataction) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.deletechataction_); - } - _impl_.deletechataction_ = deletechataction; - if (deletechataction) { - _impl_._has_bits_[0] |= 0x00010000u; - } else { - _impl_._has_bits_[0] &= ~0x00010000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.deleteChatAction) -} -inline ::proto::SyncActionValue_DeleteChatAction* SyncActionValue::release_deletechataction() { - _impl_._has_bits_[0] &= ~0x00010000u; - ::proto::SyncActionValue_DeleteChatAction* temp = _impl_.deletechataction_; - _impl_.deletechataction_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue_DeleteChatAction* SyncActionValue::unsafe_arena_release_deletechataction() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.deleteChatAction) - _impl_._has_bits_[0] &= ~0x00010000u; - ::proto::SyncActionValue_DeleteChatAction* temp = _impl_.deletechataction_; - _impl_.deletechataction_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue_DeleteChatAction* SyncActionValue::_internal_mutable_deletechataction() { - _impl_._has_bits_[0] |= 0x00010000u; - if (_impl_.deletechataction_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue_DeleteChatAction>(GetArenaForAllocation()); - _impl_.deletechataction_ = p; - } - return _impl_.deletechataction_; -} -inline ::proto::SyncActionValue_DeleteChatAction* SyncActionValue::mutable_deletechataction() { - ::proto::SyncActionValue_DeleteChatAction* _msg = _internal_mutable_deletechataction(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.deleteChatAction) - return _msg; -} -inline void SyncActionValue::set_allocated_deletechataction(::proto::SyncActionValue_DeleteChatAction* deletechataction) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.deletechataction_; - } - if (deletechataction) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(deletechataction); - if (message_arena != submessage_arena) { - deletechataction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, deletechataction, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00010000u; - } else { - _impl_._has_bits_[0] &= ~0x00010000u; - } - _impl_.deletechataction_ = deletechataction; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.deleteChatAction) -} - -// optional .proto.SyncActionValue.UnarchiveChatsSetting unarchiveChatsSetting = 23; -inline bool SyncActionValue::_internal_has_unarchivechatssetting() const { - bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.unarchivechatssetting_ != nullptr); - return value; -} -inline bool SyncActionValue::has_unarchivechatssetting() const { - return _internal_has_unarchivechatssetting(); -} -inline void SyncActionValue::clear_unarchivechatssetting() { - if (_impl_.unarchivechatssetting_ != nullptr) _impl_.unarchivechatssetting_->Clear(); - _impl_._has_bits_[0] &= ~0x00020000u; -} -inline const ::proto::SyncActionValue_UnarchiveChatsSetting& SyncActionValue::_internal_unarchivechatssetting() const { - const ::proto::SyncActionValue_UnarchiveChatsSetting* p = _impl_.unarchivechatssetting_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_UnarchiveChatsSetting_default_instance_); -} -inline const ::proto::SyncActionValue_UnarchiveChatsSetting& SyncActionValue::unarchivechatssetting() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.unarchiveChatsSetting) - return _internal_unarchivechatssetting(); -} -inline void SyncActionValue::unsafe_arena_set_allocated_unarchivechatssetting( - ::proto::SyncActionValue_UnarchiveChatsSetting* unarchivechatssetting) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.unarchivechatssetting_); - } - _impl_.unarchivechatssetting_ = unarchivechatssetting; - if (unarchivechatssetting) { - _impl_._has_bits_[0] |= 0x00020000u; - } else { - _impl_._has_bits_[0] &= ~0x00020000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.unarchiveChatsSetting) -} -inline ::proto::SyncActionValue_UnarchiveChatsSetting* SyncActionValue::release_unarchivechatssetting() { - _impl_._has_bits_[0] &= ~0x00020000u; - ::proto::SyncActionValue_UnarchiveChatsSetting* temp = _impl_.unarchivechatssetting_; - _impl_.unarchivechatssetting_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue_UnarchiveChatsSetting* SyncActionValue::unsafe_arena_release_unarchivechatssetting() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.unarchiveChatsSetting) - _impl_._has_bits_[0] &= ~0x00020000u; - ::proto::SyncActionValue_UnarchiveChatsSetting* temp = _impl_.unarchivechatssetting_; - _impl_.unarchivechatssetting_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue_UnarchiveChatsSetting* SyncActionValue::_internal_mutable_unarchivechatssetting() { - _impl_._has_bits_[0] |= 0x00020000u; - if (_impl_.unarchivechatssetting_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue_UnarchiveChatsSetting>(GetArenaForAllocation()); - _impl_.unarchivechatssetting_ = p; - } - return _impl_.unarchivechatssetting_; -} -inline ::proto::SyncActionValue_UnarchiveChatsSetting* SyncActionValue::mutable_unarchivechatssetting() { - ::proto::SyncActionValue_UnarchiveChatsSetting* _msg = _internal_mutable_unarchivechatssetting(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.unarchiveChatsSetting) - return _msg; -} -inline void SyncActionValue::set_allocated_unarchivechatssetting(::proto::SyncActionValue_UnarchiveChatsSetting* unarchivechatssetting) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.unarchivechatssetting_; - } - if (unarchivechatssetting) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(unarchivechatssetting); - if (message_arena != submessage_arena) { - unarchivechatssetting = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, unarchivechatssetting, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00020000u; - } else { - _impl_._has_bits_[0] &= ~0x00020000u; - } - _impl_.unarchivechatssetting_ = unarchivechatssetting; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.unarchiveChatsSetting) -} - -// optional .proto.SyncActionValue.PrimaryFeature primaryFeature = 24; -inline bool SyncActionValue::_internal_has_primaryfeature() const { - bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.primaryfeature_ != nullptr); - return value; -} -inline bool SyncActionValue::has_primaryfeature() const { - return _internal_has_primaryfeature(); -} -inline void SyncActionValue::clear_primaryfeature() { - if (_impl_.primaryfeature_ != nullptr) _impl_.primaryfeature_->Clear(); - _impl_._has_bits_[0] &= ~0x00040000u; -} -inline const ::proto::SyncActionValue_PrimaryFeature& SyncActionValue::_internal_primaryfeature() const { - const ::proto::SyncActionValue_PrimaryFeature* p = _impl_.primaryfeature_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_PrimaryFeature_default_instance_); -} -inline const ::proto::SyncActionValue_PrimaryFeature& SyncActionValue::primaryfeature() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.primaryFeature) - return _internal_primaryfeature(); -} -inline void SyncActionValue::unsafe_arena_set_allocated_primaryfeature( - ::proto::SyncActionValue_PrimaryFeature* primaryfeature) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.primaryfeature_); - } - _impl_.primaryfeature_ = primaryfeature; - if (primaryfeature) { - _impl_._has_bits_[0] |= 0x00040000u; - } else { - _impl_._has_bits_[0] &= ~0x00040000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.primaryFeature) -} -inline ::proto::SyncActionValue_PrimaryFeature* SyncActionValue::release_primaryfeature() { - _impl_._has_bits_[0] &= ~0x00040000u; - ::proto::SyncActionValue_PrimaryFeature* temp = _impl_.primaryfeature_; - _impl_.primaryfeature_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue_PrimaryFeature* SyncActionValue::unsafe_arena_release_primaryfeature() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.primaryFeature) - _impl_._has_bits_[0] &= ~0x00040000u; - ::proto::SyncActionValue_PrimaryFeature* temp = _impl_.primaryfeature_; - _impl_.primaryfeature_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue_PrimaryFeature* SyncActionValue::_internal_mutable_primaryfeature() { - _impl_._has_bits_[0] |= 0x00040000u; - if (_impl_.primaryfeature_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue_PrimaryFeature>(GetArenaForAllocation()); - _impl_.primaryfeature_ = p; - } - return _impl_.primaryfeature_; -} -inline ::proto::SyncActionValue_PrimaryFeature* SyncActionValue::mutable_primaryfeature() { - ::proto::SyncActionValue_PrimaryFeature* _msg = _internal_mutable_primaryfeature(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.primaryFeature) - return _msg; -} -inline void SyncActionValue::set_allocated_primaryfeature(::proto::SyncActionValue_PrimaryFeature* primaryfeature) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.primaryfeature_; - } - if (primaryfeature) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(primaryfeature); - if (message_arena != submessage_arena) { - primaryfeature = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, primaryfeature, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00040000u; - } else { - _impl_._has_bits_[0] &= ~0x00040000u; - } - _impl_.primaryfeature_ = primaryfeature; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.primaryFeature) -} - -// optional .proto.SyncActionValue.AndroidUnsupportedActions androidUnsupportedActions = 26; -inline bool SyncActionValue::_internal_has_androidunsupportedactions() const { - bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.androidunsupportedactions_ != nullptr); - return value; -} -inline bool SyncActionValue::has_androidunsupportedactions() const { - return _internal_has_androidunsupportedactions(); -} -inline void SyncActionValue::clear_androidunsupportedactions() { - if (_impl_.androidunsupportedactions_ != nullptr) _impl_.androidunsupportedactions_->Clear(); - _impl_._has_bits_[0] &= ~0x00080000u; -} -inline const ::proto::SyncActionValue_AndroidUnsupportedActions& SyncActionValue::_internal_androidunsupportedactions() const { - const ::proto::SyncActionValue_AndroidUnsupportedActions* p = _impl_.androidunsupportedactions_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_AndroidUnsupportedActions_default_instance_); -} -inline const ::proto::SyncActionValue_AndroidUnsupportedActions& SyncActionValue::androidunsupportedactions() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.androidUnsupportedActions) - return _internal_androidunsupportedactions(); -} -inline void SyncActionValue::unsafe_arena_set_allocated_androidunsupportedactions( - ::proto::SyncActionValue_AndroidUnsupportedActions* androidunsupportedactions) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.androidunsupportedactions_); - } - _impl_.androidunsupportedactions_ = androidunsupportedactions; - if (androidunsupportedactions) { - _impl_._has_bits_[0] |= 0x00080000u; - } else { - _impl_._has_bits_[0] &= ~0x00080000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.androidUnsupportedActions) -} -inline ::proto::SyncActionValue_AndroidUnsupportedActions* SyncActionValue::release_androidunsupportedactions() { - _impl_._has_bits_[0] &= ~0x00080000u; - ::proto::SyncActionValue_AndroidUnsupportedActions* temp = _impl_.androidunsupportedactions_; - _impl_.androidunsupportedactions_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue_AndroidUnsupportedActions* SyncActionValue::unsafe_arena_release_androidunsupportedactions() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.androidUnsupportedActions) - _impl_._has_bits_[0] &= ~0x00080000u; - ::proto::SyncActionValue_AndroidUnsupportedActions* temp = _impl_.androidunsupportedactions_; - _impl_.androidunsupportedactions_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue_AndroidUnsupportedActions* SyncActionValue::_internal_mutable_androidunsupportedactions() { - _impl_._has_bits_[0] |= 0x00080000u; - if (_impl_.androidunsupportedactions_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue_AndroidUnsupportedActions>(GetArenaForAllocation()); - _impl_.androidunsupportedactions_ = p; - } - return _impl_.androidunsupportedactions_; -} -inline ::proto::SyncActionValue_AndroidUnsupportedActions* SyncActionValue::mutable_androidunsupportedactions() { - ::proto::SyncActionValue_AndroidUnsupportedActions* _msg = _internal_mutable_androidunsupportedactions(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.androidUnsupportedActions) - return _msg; -} -inline void SyncActionValue::set_allocated_androidunsupportedactions(::proto::SyncActionValue_AndroidUnsupportedActions* androidunsupportedactions) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.androidunsupportedactions_; - } - if (androidunsupportedactions) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(androidunsupportedactions); - if (message_arena != submessage_arena) { - androidunsupportedactions = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, androidunsupportedactions, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00080000u; - } else { - _impl_._has_bits_[0] &= ~0x00080000u; - } - _impl_.androidunsupportedactions_ = androidunsupportedactions; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.androidUnsupportedActions) -} - -// optional .proto.SyncActionValue.AgentAction agentAction = 27; -inline bool SyncActionValue::_internal_has_agentaction() const { - bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.agentaction_ != nullptr); - return value; -} -inline bool SyncActionValue::has_agentaction() const { - return _internal_has_agentaction(); -} -inline void SyncActionValue::clear_agentaction() { - if (_impl_.agentaction_ != nullptr) _impl_.agentaction_->Clear(); - _impl_._has_bits_[0] &= ~0x00100000u; -} -inline const ::proto::SyncActionValue_AgentAction& SyncActionValue::_internal_agentaction() const { - const ::proto::SyncActionValue_AgentAction* p = _impl_.agentaction_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_AgentAction_default_instance_); -} -inline const ::proto::SyncActionValue_AgentAction& SyncActionValue::agentaction() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.agentAction) - return _internal_agentaction(); -} -inline void SyncActionValue::unsafe_arena_set_allocated_agentaction( - ::proto::SyncActionValue_AgentAction* agentaction) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.agentaction_); - } - _impl_.agentaction_ = agentaction; - if (agentaction) { - _impl_._has_bits_[0] |= 0x00100000u; - } else { - _impl_._has_bits_[0] &= ~0x00100000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.agentAction) -} -inline ::proto::SyncActionValue_AgentAction* SyncActionValue::release_agentaction() { - _impl_._has_bits_[0] &= ~0x00100000u; - ::proto::SyncActionValue_AgentAction* temp = _impl_.agentaction_; - _impl_.agentaction_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue_AgentAction* SyncActionValue::unsafe_arena_release_agentaction() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.agentAction) - _impl_._has_bits_[0] &= ~0x00100000u; - ::proto::SyncActionValue_AgentAction* temp = _impl_.agentaction_; - _impl_.agentaction_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue_AgentAction* SyncActionValue::_internal_mutable_agentaction() { - _impl_._has_bits_[0] |= 0x00100000u; - if (_impl_.agentaction_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue_AgentAction>(GetArenaForAllocation()); - _impl_.agentaction_ = p; - } - return _impl_.agentaction_; -} -inline ::proto::SyncActionValue_AgentAction* SyncActionValue::mutable_agentaction() { - ::proto::SyncActionValue_AgentAction* _msg = _internal_mutable_agentaction(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.agentAction) - return _msg; -} -inline void SyncActionValue::set_allocated_agentaction(::proto::SyncActionValue_AgentAction* agentaction) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.agentaction_; - } - if (agentaction) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(agentaction); - if (message_arena != submessage_arena) { - agentaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, agentaction, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00100000u; - } else { - _impl_._has_bits_[0] &= ~0x00100000u; - } - _impl_.agentaction_ = agentaction; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.agentAction) -} - -// optional .proto.SyncActionValue.SubscriptionAction subscriptionAction = 28; -inline bool SyncActionValue::_internal_has_subscriptionaction() const { - bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.subscriptionaction_ != nullptr); - return value; -} -inline bool SyncActionValue::has_subscriptionaction() const { - return _internal_has_subscriptionaction(); -} -inline void SyncActionValue::clear_subscriptionaction() { - if (_impl_.subscriptionaction_ != nullptr) _impl_.subscriptionaction_->Clear(); - _impl_._has_bits_[0] &= ~0x00200000u; -} -inline const ::proto::SyncActionValue_SubscriptionAction& SyncActionValue::_internal_subscriptionaction() const { - const ::proto::SyncActionValue_SubscriptionAction* p = _impl_.subscriptionaction_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_SubscriptionAction_default_instance_); -} -inline const ::proto::SyncActionValue_SubscriptionAction& SyncActionValue::subscriptionaction() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.subscriptionAction) - return _internal_subscriptionaction(); -} -inline void SyncActionValue::unsafe_arena_set_allocated_subscriptionaction( - ::proto::SyncActionValue_SubscriptionAction* subscriptionaction) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.subscriptionaction_); - } - _impl_.subscriptionaction_ = subscriptionaction; - if (subscriptionaction) { - _impl_._has_bits_[0] |= 0x00200000u; - } else { - _impl_._has_bits_[0] &= ~0x00200000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.subscriptionAction) -} -inline ::proto::SyncActionValue_SubscriptionAction* SyncActionValue::release_subscriptionaction() { - _impl_._has_bits_[0] &= ~0x00200000u; - ::proto::SyncActionValue_SubscriptionAction* temp = _impl_.subscriptionaction_; - _impl_.subscriptionaction_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue_SubscriptionAction* SyncActionValue::unsafe_arena_release_subscriptionaction() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.subscriptionAction) - _impl_._has_bits_[0] &= ~0x00200000u; - ::proto::SyncActionValue_SubscriptionAction* temp = _impl_.subscriptionaction_; - _impl_.subscriptionaction_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue_SubscriptionAction* SyncActionValue::_internal_mutable_subscriptionaction() { - _impl_._has_bits_[0] |= 0x00200000u; - if (_impl_.subscriptionaction_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue_SubscriptionAction>(GetArenaForAllocation()); - _impl_.subscriptionaction_ = p; - } - return _impl_.subscriptionaction_; -} -inline ::proto::SyncActionValue_SubscriptionAction* SyncActionValue::mutable_subscriptionaction() { - ::proto::SyncActionValue_SubscriptionAction* _msg = _internal_mutable_subscriptionaction(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.subscriptionAction) - return _msg; -} -inline void SyncActionValue::set_allocated_subscriptionaction(::proto::SyncActionValue_SubscriptionAction* subscriptionaction) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.subscriptionaction_; - } - if (subscriptionaction) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(subscriptionaction); - if (message_arena != submessage_arena) { - subscriptionaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, subscriptionaction, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00200000u; - } else { - _impl_._has_bits_[0] &= ~0x00200000u; - } - _impl_.subscriptionaction_ = subscriptionaction; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.subscriptionAction) -} - -// optional .proto.SyncActionValue.UserStatusMuteAction userStatusMuteAction = 29; -inline bool SyncActionValue::_internal_has_userstatusmuteaction() const { - bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.userstatusmuteaction_ != nullptr); - return value; -} -inline bool SyncActionValue::has_userstatusmuteaction() const { - return _internal_has_userstatusmuteaction(); -} -inline void SyncActionValue::clear_userstatusmuteaction() { - if (_impl_.userstatusmuteaction_ != nullptr) _impl_.userstatusmuteaction_->Clear(); - _impl_._has_bits_[0] &= ~0x00400000u; -} -inline const ::proto::SyncActionValue_UserStatusMuteAction& SyncActionValue::_internal_userstatusmuteaction() const { - const ::proto::SyncActionValue_UserStatusMuteAction* p = _impl_.userstatusmuteaction_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_UserStatusMuteAction_default_instance_); -} -inline const ::proto::SyncActionValue_UserStatusMuteAction& SyncActionValue::userstatusmuteaction() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.userStatusMuteAction) - return _internal_userstatusmuteaction(); -} -inline void SyncActionValue::unsafe_arena_set_allocated_userstatusmuteaction( - ::proto::SyncActionValue_UserStatusMuteAction* userstatusmuteaction) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.userstatusmuteaction_); - } - _impl_.userstatusmuteaction_ = userstatusmuteaction; - if (userstatusmuteaction) { - _impl_._has_bits_[0] |= 0x00400000u; - } else { - _impl_._has_bits_[0] &= ~0x00400000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.userStatusMuteAction) -} -inline ::proto::SyncActionValue_UserStatusMuteAction* SyncActionValue::release_userstatusmuteaction() { - _impl_._has_bits_[0] &= ~0x00400000u; - ::proto::SyncActionValue_UserStatusMuteAction* temp = _impl_.userstatusmuteaction_; - _impl_.userstatusmuteaction_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue_UserStatusMuteAction* SyncActionValue::unsafe_arena_release_userstatusmuteaction() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.userStatusMuteAction) - _impl_._has_bits_[0] &= ~0x00400000u; - ::proto::SyncActionValue_UserStatusMuteAction* temp = _impl_.userstatusmuteaction_; - _impl_.userstatusmuteaction_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue_UserStatusMuteAction* SyncActionValue::_internal_mutable_userstatusmuteaction() { - _impl_._has_bits_[0] |= 0x00400000u; - if (_impl_.userstatusmuteaction_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue_UserStatusMuteAction>(GetArenaForAllocation()); - _impl_.userstatusmuteaction_ = p; - } - return _impl_.userstatusmuteaction_; -} -inline ::proto::SyncActionValue_UserStatusMuteAction* SyncActionValue::mutable_userstatusmuteaction() { - ::proto::SyncActionValue_UserStatusMuteAction* _msg = _internal_mutable_userstatusmuteaction(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.userStatusMuteAction) - return _msg; -} -inline void SyncActionValue::set_allocated_userstatusmuteaction(::proto::SyncActionValue_UserStatusMuteAction* userstatusmuteaction) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.userstatusmuteaction_; - } - if (userstatusmuteaction) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(userstatusmuteaction); - if (message_arena != submessage_arena) { - userstatusmuteaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, userstatusmuteaction, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00400000u; - } else { - _impl_._has_bits_[0] &= ~0x00400000u; - } - _impl_.userstatusmuteaction_ = userstatusmuteaction; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.userStatusMuteAction) -} - -// optional .proto.SyncActionValue.TimeFormatAction timeFormatAction = 30; -inline bool SyncActionValue::_internal_has_timeformataction() const { - bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.timeformataction_ != nullptr); - return value; -} -inline bool SyncActionValue::has_timeformataction() const { - return _internal_has_timeformataction(); -} -inline void SyncActionValue::clear_timeformataction() { - if (_impl_.timeformataction_ != nullptr) _impl_.timeformataction_->Clear(); - _impl_._has_bits_[0] &= ~0x00800000u; -} -inline const ::proto::SyncActionValue_TimeFormatAction& SyncActionValue::_internal_timeformataction() const { - const ::proto::SyncActionValue_TimeFormatAction* p = _impl_.timeformataction_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_TimeFormatAction_default_instance_); -} -inline const ::proto::SyncActionValue_TimeFormatAction& SyncActionValue::timeformataction() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.timeFormatAction) - return _internal_timeformataction(); -} -inline void SyncActionValue::unsafe_arena_set_allocated_timeformataction( - ::proto::SyncActionValue_TimeFormatAction* timeformataction) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.timeformataction_); - } - _impl_.timeformataction_ = timeformataction; - if (timeformataction) { - _impl_._has_bits_[0] |= 0x00800000u; - } else { - _impl_._has_bits_[0] &= ~0x00800000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.timeFormatAction) -} -inline ::proto::SyncActionValue_TimeFormatAction* SyncActionValue::release_timeformataction() { - _impl_._has_bits_[0] &= ~0x00800000u; - ::proto::SyncActionValue_TimeFormatAction* temp = _impl_.timeformataction_; - _impl_.timeformataction_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue_TimeFormatAction* SyncActionValue::unsafe_arena_release_timeformataction() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.timeFormatAction) - _impl_._has_bits_[0] &= ~0x00800000u; - ::proto::SyncActionValue_TimeFormatAction* temp = _impl_.timeformataction_; - _impl_.timeformataction_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue_TimeFormatAction* SyncActionValue::_internal_mutable_timeformataction() { - _impl_._has_bits_[0] |= 0x00800000u; - if (_impl_.timeformataction_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue_TimeFormatAction>(GetArenaForAllocation()); - _impl_.timeformataction_ = p; - } - return _impl_.timeformataction_; -} -inline ::proto::SyncActionValue_TimeFormatAction* SyncActionValue::mutable_timeformataction() { - ::proto::SyncActionValue_TimeFormatAction* _msg = _internal_mutable_timeformataction(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.timeFormatAction) - return _msg; -} -inline void SyncActionValue::set_allocated_timeformataction(::proto::SyncActionValue_TimeFormatAction* timeformataction) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.timeformataction_; - } - if (timeformataction) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(timeformataction); - if (message_arena != submessage_arena) { - timeformataction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, timeformataction, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00800000u; - } else { - _impl_._has_bits_[0] &= ~0x00800000u; - } - _impl_.timeformataction_ = timeformataction; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.timeFormatAction) -} - -// optional .proto.SyncActionValue.NuxAction nuxAction = 31; -inline bool SyncActionValue::_internal_has_nuxaction() const { - bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.nuxaction_ != nullptr); - return value; -} -inline bool SyncActionValue::has_nuxaction() const { - return _internal_has_nuxaction(); -} -inline void SyncActionValue::clear_nuxaction() { - if (_impl_.nuxaction_ != nullptr) _impl_.nuxaction_->Clear(); - _impl_._has_bits_[0] &= ~0x01000000u; -} -inline const ::proto::SyncActionValue_NuxAction& SyncActionValue::_internal_nuxaction() const { - const ::proto::SyncActionValue_NuxAction* p = _impl_.nuxaction_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_NuxAction_default_instance_); -} -inline const ::proto::SyncActionValue_NuxAction& SyncActionValue::nuxaction() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.nuxAction) - return _internal_nuxaction(); -} -inline void SyncActionValue::unsafe_arena_set_allocated_nuxaction( - ::proto::SyncActionValue_NuxAction* nuxaction) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.nuxaction_); - } - _impl_.nuxaction_ = nuxaction; - if (nuxaction) { - _impl_._has_bits_[0] |= 0x01000000u; - } else { - _impl_._has_bits_[0] &= ~0x01000000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.nuxAction) -} -inline ::proto::SyncActionValue_NuxAction* SyncActionValue::release_nuxaction() { - _impl_._has_bits_[0] &= ~0x01000000u; - ::proto::SyncActionValue_NuxAction* temp = _impl_.nuxaction_; - _impl_.nuxaction_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue_NuxAction* SyncActionValue::unsafe_arena_release_nuxaction() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.nuxAction) - _impl_._has_bits_[0] &= ~0x01000000u; - ::proto::SyncActionValue_NuxAction* temp = _impl_.nuxaction_; - _impl_.nuxaction_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue_NuxAction* SyncActionValue::_internal_mutable_nuxaction() { - _impl_._has_bits_[0] |= 0x01000000u; - if (_impl_.nuxaction_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue_NuxAction>(GetArenaForAllocation()); - _impl_.nuxaction_ = p; - } - return _impl_.nuxaction_; -} -inline ::proto::SyncActionValue_NuxAction* SyncActionValue::mutable_nuxaction() { - ::proto::SyncActionValue_NuxAction* _msg = _internal_mutable_nuxaction(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.nuxAction) - return _msg; -} -inline void SyncActionValue::set_allocated_nuxaction(::proto::SyncActionValue_NuxAction* nuxaction) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.nuxaction_; - } - if (nuxaction) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(nuxaction); - if (message_arena != submessage_arena) { - nuxaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, nuxaction, submessage_arena); - } - _impl_._has_bits_[0] |= 0x01000000u; - } else { - _impl_._has_bits_[0] &= ~0x01000000u; - } - _impl_.nuxaction_ = nuxaction; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.nuxAction) -} - -// optional .proto.SyncActionValue.PrimaryVersionAction primaryVersionAction = 32; -inline bool SyncActionValue::_internal_has_primaryversionaction() const { - bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.primaryversionaction_ != nullptr); - return value; -} -inline bool SyncActionValue::has_primaryversionaction() const { - return _internal_has_primaryversionaction(); -} -inline void SyncActionValue::clear_primaryversionaction() { - if (_impl_.primaryversionaction_ != nullptr) _impl_.primaryversionaction_->Clear(); - _impl_._has_bits_[0] &= ~0x02000000u; -} -inline const ::proto::SyncActionValue_PrimaryVersionAction& SyncActionValue::_internal_primaryversionaction() const { - const ::proto::SyncActionValue_PrimaryVersionAction* p = _impl_.primaryversionaction_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_PrimaryVersionAction_default_instance_); -} -inline const ::proto::SyncActionValue_PrimaryVersionAction& SyncActionValue::primaryversionaction() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.primaryVersionAction) - return _internal_primaryversionaction(); -} -inline void SyncActionValue::unsafe_arena_set_allocated_primaryversionaction( - ::proto::SyncActionValue_PrimaryVersionAction* primaryversionaction) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.primaryversionaction_); - } - _impl_.primaryversionaction_ = primaryversionaction; - if (primaryversionaction) { - _impl_._has_bits_[0] |= 0x02000000u; - } else { - _impl_._has_bits_[0] &= ~0x02000000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.primaryVersionAction) -} -inline ::proto::SyncActionValue_PrimaryVersionAction* SyncActionValue::release_primaryversionaction() { - _impl_._has_bits_[0] &= ~0x02000000u; - ::proto::SyncActionValue_PrimaryVersionAction* temp = _impl_.primaryversionaction_; - _impl_.primaryversionaction_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue_PrimaryVersionAction* SyncActionValue::unsafe_arena_release_primaryversionaction() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.primaryVersionAction) - _impl_._has_bits_[0] &= ~0x02000000u; - ::proto::SyncActionValue_PrimaryVersionAction* temp = _impl_.primaryversionaction_; - _impl_.primaryversionaction_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue_PrimaryVersionAction* SyncActionValue::_internal_mutable_primaryversionaction() { - _impl_._has_bits_[0] |= 0x02000000u; - if (_impl_.primaryversionaction_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue_PrimaryVersionAction>(GetArenaForAllocation()); - _impl_.primaryversionaction_ = p; - } - return _impl_.primaryversionaction_; -} -inline ::proto::SyncActionValue_PrimaryVersionAction* SyncActionValue::mutable_primaryversionaction() { - ::proto::SyncActionValue_PrimaryVersionAction* _msg = _internal_mutable_primaryversionaction(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.primaryVersionAction) - return _msg; -} -inline void SyncActionValue::set_allocated_primaryversionaction(::proto::SyncActionValue_PrimaryVersionAction* primaryversionaction) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.primaryversionaction_; - } - if (primaryversionaction) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(primaryversionaction); - if (message_arena != submessage_arena) { - primaryversionaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, primaryversionaction, submessage_arena); - } - _impl_._has_bits_[0] |= 0x02000000u; - } else { - _impl_._has_bits_[0] &= ~0x02000000u; - } - _impl_.primaryversionaction_ = primaryversionaction; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.primaryVersionAction) -} - -// optional .proto.SyncActionValue.StickerAction stickerAction = 33; -inline bool SyncActionValue::_internal_has_stickeraction() const { - bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.stickeraction_ != nullptr); - return value; -} -inline bool SyncActionValue::has_stickeraction() const { - return _internal_has_stickeraction(); -} -inline void SyncActionValue::clear_stickeraction() { - if (_impl_.stickeraction_ != nullptr) _impl_.stickeraction_->Clear(); - _impl_._has_bits_[0] &= ~0x04000000u; -} -inline const ::proto::SyncActionValue_StickerAction& SyncActionValue::_internal_stickeraction() const { - const ::proto::SyncActionValue_StickerAction* p = _impl_.stickeraction_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncActionValue_StickerAction_default_instance_); -} -inline const ::proto::SyncActionValue_StickerAction& SyncActionValue::stickeraction() const { - // @@protoc_insertion_point(field_get:proto.SyncActionValue.stickerAction) - return _internal_stickeraction(); -} -inline void SyncActionValue::unsafe_arena_set_allocated_stickeraction( - ::proto::SyncActionValue_StickerAction* stickeraction) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.stickeraction_); - } - _impl_.stickeraction_ = stickeraction; - if (stickeraction) { - _impl_._has_bits_[0] |= 0x04000000u; - } else { - _impl_._has_bits_[0] &= ~0x04000000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.stickerAction) -} -inline ::proto::SyncActionValue_StickerAction* SyncActionValue::release_stickeraction() { - _impl_._has_bits_[0] &= ~0x04000000u; - ::proto::SyncActionValue_StickerAction* temp = _impl_.stickeraction_; - _impl_.stickeraction_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncActionValue_StickerAction* SyncActionValue::unsafe_arena_release_stickeraction() { - // @@protoc_insertion_point(field_release:proto.SyncActionValue.stickerAction) - _impl_._has_bits_[0] &= ~0x04000000u; - ::proto::SyncActionValue_StickerAction* temp = _impl_.stickeraction_; - _impl_.stickeraction_ = nullptr; - return temp; -} -inline ::proto::SyncActionValue_StickerAction* SyncActionValue::_internal_mutable_stickeraction() { - _impl_._has_bits_[0] |= 0x04000000u; - if (_impl_.stickeraction_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncActionValue_StickerAction>(GetArenaForAllocation()); - _impl_.stickeraction_ = p; - } - return _impl_.stickeraction_; -} -inline ::proto::SyncActionValue_StickerAction* SyncActionValue::mutable_stickeraction() { - ::proto::SyncActionValue_StickerAction* _msg = _internal_mutable_stickeraction(); - // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.stickerAction) - return _msg; -} -inline void SyncActionValue::set_allocated_stickeraction(::proto::SyncActionValue_StickerAction* stickeraction) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.stickeraction_; - } - if (stickeraction) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(stickeraction); - if (message_arena != submessage_arena) { - stickeraction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, stickeraction, submessage_arena); - } - _impl_._has_bits_[0] |= 0x04000000u; - } else { - _impl_._has_bits_[0] &= ~0x04000000u; - } - _impl_.stickeraction_ = stickeraction; - // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.stickerAction) -} - -// ------------------------------------------------------------------- - -// SyncdIndex - -// optional bytes blob = 1; -inline bool SyncdIndex::_internal_has_blob() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SyncdIndex::has_blob() const { - return _internal_has_blob(); -} -inline void SyncdIndex::clear_blob() { - _impl_.blob_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& SyncdIndex::blob() const { - // @@protoc_insertion_point(field_get:proto.SyncdIndex.blob) - return _internal_blob(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SyncdIndex::set_blob(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.blob_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SyncdIndex.blob) -} -inline std::string* SyncdIndex::mutable_blob() { - std::string* _s = _internal_mutable_blob(); - // @@protoc_insertion_point(field_mutable:proto.SyncdIndex.blob) - return _s; -} -inline const std::string& SyncdIndex::_internal_blob() const { - return _impl_.blob_.Get(); -} -inline void SyncdIndex::_internal_set_blob(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.blob_.Set(value, GetArenaForAllocation()); -} -inline std::string* SyncdIndex::_internal_mutable_blob() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.blob_.Mutable(GetArenaForAllocation()); -} -inline std::string* SyncdIndex::release_blob() { - // @@protoc_insertion_point(field_release:proto.SyncdIndex.blob) - if (!_internal_has_blob()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.blob_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.blob_.IsDefault()) { - _impl_.blob_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SyncdIndex::set_allocated_blob(std::string* blob) { - if (blob != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.blob_.SetAllocated(blob, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.blob_.IsDefault()) { - _impl_.blob_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SyncdIndex.blob) -} - -// ------------------------------------------------------------------- - -// SyncdMutation - -// optional .proto.SyncdMutation.SyncdOperation operation = 1; -inline bool SyncdMutation::_internal_has_operation() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool SyncdMutation::has_operation() const { - return _internal_has_operation(); -} -inline void SyncdMutation::clear_operation() { - _impl_.operation_ = 0; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline ::proto::SyncdMutation_SyncdOperation SyncdMutation::_internal_operation() const { - return static_cast< ::proto::SyncdMutation_SyncdOperation >(_impl_.operation_); -} -inline ::proto::SyncdMutation_SyncdOperation SyncdMutation::operation() const { - // @@protoc_insertion_point(field_get:proto.SyncdMutation.operation) - return _internal_operation(); -} -inline void SyncdMutation::_internal_set_operation(::proto::SyncdMutation_SyncdOperation value) { - assert(::proto::SyncdMutation_SyncdOperation_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.operation_ = value; -} -inline void SyncdMutation::set_operation(::proto::SyncdMutation_SyncdOperation value) { - _internal_set_operation(value); - // @@protoc_insertion_point(field_set:proto.SyncdMutation.operation) -} - -// optional .proto.SyncdRecord record = 2; -inline bool SyncdMutation::_internal_has_record() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.record_ != nullptr); - return value; -} -inline bool SyncdMutation::has_record() const { - return _internal_has_record(); -} -inline void SyncdMutation::clear_record() { - if (_impl_.record_ != nullptr) _impl_.record_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::SyncdRecord& SyncdMutation::_internal_record() const { - const ::proto::SyncdRecord* p = _impl_.record_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncdRecord_default_instance_); -} -inline const ::proto::SyncdRecord& SyncdMutation::record() const { - // @@protoc_insertion_point(field_get:proto.SyncdMutation.record) - return _internal_record(); -} -inline void SyncdMutation::unsafe_arena_set_allocated_record( - ::proto::SyncdRecord* record) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.record_); - } - _impl_.record_ = record; - if (record) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdMutation.record) -} -inline ::proto::SyncdRecord* SyncdMutation::release_record() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::SyncdRecord* temp = _impl_.record_; - _impl_.record_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncdRecord* SyncdMutation::unsafe_arena_release_record() { - // @@protoc_insertion_point(field_release:proto.SyncdMutation.record) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::SyncdRecord* temp = _impl_.record_; - _impl_.record_ = nullptr; - return temp; -} -inline ::proto::SyncdRecord* SyncdMutation::_internal_mutable_record() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.record_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncdRecord>(GetArenaForAllocation()); - _impl_.record_ = p; - } - return _impl_.record_; -} -inline ::proto::SyncdRecord* SyncdMutation::mutable_record() { - ::proto::SyncdRecord* _msg = _internal_mutable_record(); - // @@protoc_insertion_point(field_mutable:proto.SyncdMutation.record) - return _msg; -} -inline void SyncdMutation::set_allocated_record(::proto::SyncdRecord* record) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.record_; - } - if (record) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(record); - if (message_arena != submessage_arena) { - record = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, record, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.record_ = record; - // @@protoc_insertion_point(field_set_allocated:proto.SyncdMutation.record) -} - -// ------------------------------------------------------------------- - -// SyncdMutations - -// repeated .proto.SyncdMutation mutations = 1; -inline int SyncdMutations::_internal_mutations_size() const { - return _impl_.mutations_.size(); -} -inline int SyncdMutations::mutations_size() const { - return _internal_mutations_size(); -} -inline void SyncdMutations::clear_mutations() { - _impl_.mutations_.Clear(); -} -inline ::proto::SyncdMutation* SyncdMutations::mutable_mutations(int index) { - // @@protoc_insertion_point(field_mutable:proto.SyncdMutations.mutations) - return _impl_.mutations_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >* -SyncdMutations::mutable_mutations() { - // @@protoc_insertion_point(field_mutable_list:proto.SyncdMutations.mutations) - return &_impl_.mutations_; -} -inline const ::proto::SyncdMutation& SyncdMutations::_internal_mutations(int index) const { - return _impl_.mutations_.Get(index); -} -inline const ::proto::SyncdMutation& SyncdMutations::mutations(int index) const { - // @@protoc_insertion_point(field_get:proto.SyncdMutations.mutations) - return _internal_mutations(index); -} -inline ::proto::SyncdMutation* SyncdMutations::_internal_add_mutations() { - return _impl_.mutations_.Add(); -} -inline ::proto::SyncdMutation* SyncdMutations::add_mutations() { - ::proto::SyncdMutation* _add = _internal_add_mutations(); - // @@protoc_insertion_point(field_add:proto.SyncdMutations.mutations) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >& -SyncdMutations::mutations() const { - // @@protoc_insertion_point(field_list:proto.SyncdMutations.mutations) - return _impl_.mutations_; -} - -// ------------------------------------------------------------------- - -// SyncdPatch - -// optional .proto.SyncdVersion version = 1; -inline bool SyncdPatch::_internal_has_version() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - PROTOBUF_ASSUME(!value || _impl_.version_ != nullptr); - return value; -} -inline bool SyncdPatch::has_version() const { - return _internal_has_version(); -} -inline void SyncdPatch::clear_version() { - if (_impl_.version_ != nullptr) _impl_.version_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const ::proto::SyncdVersion& SyncdPatch::_internal_version() const { - const ::proto::SyncdVersion* p = _impl_.version_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncdVersion_default_instance_); -} -inline const ::proto::SyncdVersion& SyncdPatch::version() const { - // @@protoc_insertion_point(field_get:proto.SyncdPatch.version) - return _internal_version(); -} -inline void SyncdPatch::unsafe_arena_set_allocated_version( - ::proto::SyncdVersion* version) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.version_); - } - _impl_.version_ = version; - if (version) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdPatch.version) -} -inline ::proto::SyncdVersion* SyncdPatch::release_version() { - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::SyncdVersion* temp = _impl_.version_; - _impl_.version_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncdVersion* SyncdPatch::unsafe_arena_release_version() { - // @@protoc_insertion_point(field_release:proto.SyncdPatch.version) - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::SyncdVersion* temp = _impl_.version_; - _impl_.version_ = nullptr; - return temp; -} -inline ::proto::SyncdVersion* SyncdPatch::_internal_mutable_version() { - _impl_._has_bits_[0] |= 0x00000004u; - if (_impl_.version_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncdVersion>(GetArenaForAllocation()); - _impl_.version_ = p; - } - return _impl_.version_; -} -inline ::proto::SyncdVersion* SyncdPatch::mutable_version() { - ::proto::SyncdVersion* _msg = _internal_mutable_version(); - // @@protoc_insertion_point(field_mutable:proto.SyncdPatch.version) - return _msg; -} -inline void SyncdPatch::set_allocated_version(::proto::SyncdVersion* version) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.version_; - } - if (version) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(version); - if (message_arena != submessage_arena) { - version = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, version, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.version_ = version; - // @@protoc_insertion_point(field_set_allocated:proto.SyncdPatch.version) -} - -// repeated .proto.SyncdMutation mutations = 2; -inline int SyncdPatch::_internal_mutations_size() const { - return _impl_.mutations_.size(); -} -inline int SyncdPatch::mutations_size() const { - return _internal_mutations_size(); -} -inline void SyncdPatch::clear_mutations() { - _impl_.mutations_.Clear(); -} -inline ::proto::SyncdMutation* SyncdPatch::mutable_mutations(int index) { - // @@protoc_insertion_point(field_mutable:proto.SyncdPatch.mutations) - return _impl_.mutations_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >* -SyncdPatch::mutable_mutations() { - // @@protoc_insertion_point(field_mutable_list:proto.SyncdPatch.mutations) - return &_impl_.mutations_; -} -inline const ::proto::SyncdMutation& SyncdPatch::_internal_mutations(int index) const { - return _impl_.mutations_.Get(index); -} -inline const ::proto::SyncdMutation& SyncdPatch::mutations(int index) const { - // @@protoc_insertion_point(field_get:proto.SyncdPatch.mutations) - return _internal_mutations(index); -} -inline ::proto::SyncdMutation* SyncdPatch::_internal_add_mutations() { - return _impl_.mutations_.Add(); -} -inline ::proto::SyncdMutation* SyncdPatch::add_mutations() { - ::proto::SyncdMutation* _add = _internal_add_mutations(); - // @@protoc_insertion_point(field_add:proto.SyncdPatch.mutations) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >& -SyncdPatch::mutations() const { - // @@protoc_insertion_point(field_list:proto.SyncdPatch.mutations) - return _impl_.mutations_; -} - -// optional .proto.ExternalBlobReference externalMutations = 3; -inline bool SyncdPatch::_internal_has_externalmutations() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - PROTOBUF_ASSUME(!value || _impl_.externalmutations_ != nullptr); - return value; -} -inline bool SyncdPatch::has_externalmutations() const { - return _internal_has_externalmutations(); -} -inline void SyncdPatch::clear_externalmutations() { - if (_impl_.externalmutations_ != nullptr) _impl_.externalmutations_->Clear(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const ::proto::ExternalBlobReference& SyncdPatch::_internal_externalmutations() const { - const ::proto::ExternalBlobReference* p = _impl_.externalmutations_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ExternalBlobReference_default_instance_); -} -inline const ::proto::ExternalBlobReference& SyncdPatch::externalmutations() const { - // @@protoc_insertion_point(field_get:proto.SyncdPatch.externalMutations) - return _internal_externalmutations(); -} -inline void SyncdPatch::unsafe_arena_set_allocated_externalmutations( - ::proto::ExternalBlobReference* externalmutations) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.externalmutations_); - } - _impl_.externalmutations_ = externalmutations; - if (externalmutations) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdPatch.externalMutations) -} -inline ::proto::ExternalBlobReference* SyncdPatch::release_externalmutations() { - _impl_._has_bits_[0] &= ~0x00000008u; - ::proto::ExternalBlobReference* temp = _impl_.externalmutations_; - _impl_.externalmutations_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ExternalBlobReference* SyncdPatch::unsafe_arena_release_externalmutations() { - // @@protoc_insertion_point(field_release:proto.SyncdPatch.externalMutations) - _impl_._has_bits_[0] &= ~0x00000008u; - ::proto::ExternalBlobReference* temp = _impl_.externalmutations_; - _impl_.externalmutations_ = nullptr; - return temp; -} -inline ::proto::ExternalBlobReference* SyncdPatch::_internal_mutable_externalmutations() { - _impl_._has_bits_[0] |= 0x00000008u; - if (_impl_.externalmutations_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ExternalBlobReference>(GetArenaForAllocation()); - _impl_.externalmutations_ = p; - } - return _impl_.externalmutations_; -} -inline ::proto::ExternalBlobReference* SyncdPatch::mutable_externalmutations() { - ::proto::ExternalBlobReference* _msg = _internal_mutable_externalmutations(); - // @@protoc_insertion_point(field_mutable:proto.SyncdPatch.externalMutations) - return _msg; -} -inline void SyncdPatch::set_allocated_externalmutations(::proto::ExternalBlobReference* externalmutations) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.externalmutations_; - } - if (externalmutations) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(externalmutations); - if (message_arena != submessage_arena) { - externalmutations = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, externalmutations, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.externalmutations_ = externalmutations; - // @@protoc_insertion_point(field_set_allocated:proto.SyncdPatch.externalMutations) -} - -// optional bytes snapshotMac = 4; -inline bool SyncdPatch::_internal_has_snapshotmac() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SyncdPatch::has_snapshotmac() const { - return _internal_has_snapshotmac(); -} -inline void SyncdPatch::clear_snapshotmac() { - _impl_.snapshotmac_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& SyncdPatch::snapshotmac() const { - // @@protoc_insertion_point(field_get:proto.SyncdPatch.snapshotMac) - return _internal_snapshotmac(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SyncdPatch::set_snapshotmac(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.snapshotmac_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SyncdPatch.snapshotMac) -} -inline std::string* SyncdPatch::mutable_snapshotmac() { - std::string* _s = _internal_mutable_snapshotmac(); - // @@protoc_insertion_point(field_mutable:proto.SyncdPatch.snapshotMac) - return _s; -} -inline const std::string& SyncdPatch::_internal_snapshotmac() const { - return _impl_.snapshotmac_.Get(); -} -inline void SyncdPatch::_internal_set_snapshotmac(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.snapshotmac_.Set(value, GetArenaForAllocation()); -} -inline std::string* SyncdPatch::_internal_mutable_snapshotmac() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.snapshotmac_.Mutable(GetArenaForAllocation()); -} -inline std::string* SyncdPatch::release_snapshotmac() { - // @@protoc_insertion_point(field_release:proto.SyncdPatch.snapshotMac) - if (!_internal_has_snapshotmac()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.snapshotmac_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.snapshotmac_.IsDefault()) { - _impl_.snapshotmac_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SyncdPatch::set_allocated_snapshotmac(std::string* snapshotmac) { - if (snapshotmac != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.snapshotmac_.SetAllocated(snapshotmac, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.snapshotmac_.IsDefault()) { - _impl_.snapshotmac_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SyncdPatch.snapshotMac) -} - -// optional bytes patchMac = 5; -inline bool SyncdPatch::_internal_has_patchmac() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool SyncdPatch::has_patchmac() const { - return _internal_has_patchmac(); -} -inline void SyncdPatch::clear_patchmac() { - _impl_.patchmac_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& SyncdPatch::patchmac() const { - // @@protoc_insertion_point(field_get:proto.SyncdPatch.patchMac) - return _internal_patchmac(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SyncdPatch::set_patchmac(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.patchmac_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SyncdPatch.patchMac) -} -inline std::string* SyncdPatch::mutable_patchmac() { - std::string* _s = _internal_mutable_patchmac(); - // @@protoc_insertion_point(field_mutable:proto.SyncdPatch.patchMac) - return _s; -} -inline const std::string& SyncdPatch::_internal_patchmac() const { - return _impl_.patchmac_.Get(); -} -inline void SyncdPatch::_internal_set_patchmac(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.patchmac_.Set(value, GetArenaForAllocation()); -} -inline std::string* SyncdPatch::_internal_mutable_patchmac() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.patchmac_.Mutable(GetArenaForAllocation()); -} -inline std::string* SyncdPatch::release_patchmac() { - // @@protoc_insertion_point(field_release:proto.SyncdPatch.patchMac) - if (!_internal_has_patchmac()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.patchmac_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.patchmac_.IsDefault()) { - _impl_.patchmac_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SyncdPatch::set_allocated_patchmac(std::string* patchmac) { - if (patchmac != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.patchmac_.SetAllocated(patchmac, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.patchmac_.IsDefault()) { - _impl_.patchmac_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SyncdPatch.patchMac) -} - -// optional .proto.KeyId keyId = 6; -inline bool SyncdPatch::_internal_has_keyid() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - PROTOBUF_ASSUME(!value || _impl_.keyid_ != nullptr); - return value; -} -inline bool SyncdPatch::has_keyid() const { - return _internal_has_keyid(); -} -inline void SyncdPatch::clear_keyid() { - if (_impl_.keyid_ != nullptr) _impl_.keyid_->Clear(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const ::proto::KeyId& SyncdPatch::_internal_keyid() const { - const ::proto::KeyId* p = _impl_.keyid_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_KeyId_default_instance_); -} -inline const ::proto::KeyId& SyncdPatch::keyid() const { - // @@protoc_insertion_point(field_get:proto.SyncdPatch.keyId) - return _internal_keyid(); -} -inline void SyncdPatch::unsafe_arena_set_allocated_keyid( - ::proto::KeyId* keyid) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keyid_); - } - _impl_.keyid_ = keyid; - if (keyid) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdPatch.keyId) -} -inline ::proto::KeyId* SyncdPatch::release_keyid() { - _impl_._has_bits_[0] &= ~0x00000010u; - ::proto::KeyId* temp = _impl_.keyid_; - _impl_.keyid_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::KeyId* SyncdPatch::unsafe_arena_release_keyid() { - // @@protoc_insertion_point(field_release:proto.SyncdPatch.keyId) - _impl_._has_bits_[0] &= ~0x00000010u; - ::proto::KeyId* temp = _impl_.keyid_; - _impl_.keyid_ = nullptr; - return temp; -} -inline ::proto::KeyId* SyncdPatch::_internal_mutable_keyid() { - _impl_._has_bits_[0] |= 0x00000010u; - if (_impl_.keyid_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::KeyId>(GetArenaForAllocation()); - _impl_.keyid_ = p; - } - return _impl_.keyid_; -} -inline ::proto::KeyId* SyncdPatch::mutable_keyid() { - ::proto::KeyId* _msg = _internal_mutable_keyid(); - // @@protoc_insertion_point(field_mutable:proto.SyncdPatch.keyId) - return _msg; -} -inline void SyncdPatch::set_allocated_keyid(::proto::KeyId* keyid) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.keyid_; - } - if (keyid) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keyid); - if (message_arena != submessage_arena) { - keyid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, keyid, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.keyid_ = keyid; - // @@protoc_insertion_point(field_set_allocated:proto.SyncdPatch.keyId) -} - -// optional .proto.ExitCode exitCode = 7; -inline bool SyncdPatch::_internal_has_exitcode() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - PROTOBUF_ASSUME(!value || _impl_.exitcode_ != nullptr); - return value; -} -inline bool SyncdPatch::has_exitcode() const { - return _internal_has_exitcode(); -} -inline void SyncdPatch::clear_exitcode() { - if (_impl_.exitcode_ != nullptr) _impl_.exitcode_->Clear(); - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline const ::proto::ExitCode& SyncdPatch::_internal_exitcode() const { - const ::proto::ExitCode* p = _impl_.exitcode_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_ExitCode_default_instance_); -} -inline const ::proto::ExitCode& SyncdPatch::exitcode() const { - // @@protoc_insertion_point(field_get:proto.SyncdPatch.exitCode) - return _internal_exitcode(); -} -inline void SyncdPatch::unsafe_arena_set_allocated_exitcode( - ::proto::ExitCode* exitcode) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.exitcode_); - } - _impl_.exitcode_ = exitcode; - if (exitcode) { - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdPatch.exitCode) -} -inline ::proto::ExitCode* SyncdPatch::release_exitcode() { - _impl_._has_bits_[0] &= ~0x00000020u; - ::proto::ExitCode* temp = _impl_.exitcode_; - _impl_.exitcode_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::ExitCode* SyncdPatch::unsafe_arena_release_exitcode() { - // @@protoc_insertion_point(field_release:proto.SyncdPatch.exitCode) - _impl_._has_bits_[0] &= ~0x00000020u; - ::proto::ExitCode* temp = _impl_.exitcode_; - _impl_.exitcode_ = nullptr; - return temp; -} -inline ::proto::ExitCode* SyncdPatch::_internal_mutable_exitcode() { - _impl_._has_bits_[0] |= 0x00000020u; - if (_impl_.exitcode_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::ExitCode>(GetArenaForAllocation()); - _impl_.exitcode_ = p; - } - return _impl_.exitcode_; -} -inline ::proto::ExitCode* SyncdPatch::mutable_exitcode() { - ::proto::ExitCode* _msg = _internal_mutable_exitcode(); - // @@protoc_insertion_point(field_mutable:proto.SyncdPatch.exitCode) - return _msg; -} -inline void SyncdPatch::set_allocated_exitcode(::proto::ExitCode* exitcode) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.exitcode_; - } - if (exitcode) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(exitcode); - if (message_arena != submessage_arena) { - exitcode = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, exitcode, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - _impl_.exitcode_ = exitcode; - // @@protoc_insertion_point(field_set_allocated:proto.SyncdPatch.exitCode) -} - -// optional uint32 deviceIndex = 8; -inline bool SyncdPatch::_internal_has_deviceindex() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool SyncdPatch::has_deviceindex() const { - return _internal_has_deviceindex(); -} -inline void SyncdPatch::clear_deviceindex() { - _impl_.deviceindex_ = 0u; - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline uint32_t SyncdPatch::_internal_deviceindex() const { - return _impl_.deviceindex_; -} -inline uint32_t SyncdPatch::deviceindex() const { - // @@protoc_insertion_point(field_get:proto.SyncdPatch.deviceIndex) - return _internal_deviceindex(); -} -inline void SyncdPatch::_internal_set_deviceindex(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.deviceindex_ = value; -} -inline void SyncdPatch::set_deviceindex(uint32_t value) { - _internal_set_deviceindex(value); - // @@protoc_insertion_point(field_set:proto.SyncdPatch.deviceIndex) -} - -// ------------------------------------------------------------------- - -// SyncdRecord - -// optional .proto.SyncdIndex index = 1; -inline bool SyncdRecord::_internal_has_index() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.index_ != nullptr); - return value; -} -inline bool SyncdRecord::has_index() const { - return _internal_has_index(); -} -inline void SyncdRecord::clear_index() { - if (_impl_.index_ != nullptr) _impl_.index_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::SyncdIndex& SyncdRecord::_internal_index() const { - const ::proto::SyncdIndex* p = _impl_.index_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncdIndex_default_instance_); -} -inline const ::proto::SyncdIndex& SyncdRecord::index() const { - // @@protoc_insertion_point(field_get:proto.SyncdRecord.index) - return _internal_index(); -} -inline void SyncdRecord::unsafe_arena_set_allocated_index( - ::proto::SyncdIndex* index) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.index_); - } - _impl_.index_ = index; - if (index) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdRecord.index) -} -inline ::proto::SyncdIndex* SyncdRecord::release_index() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::SyncdIndex* temp = _impl_.index_; - _impl_.index_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncdIndex* SyncdRecord::unsafe_arena_release_index() { - // @@protoc_insertion_point(field_release:proto.SyncdRecord.index) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::SyncdIndex* temp = _impl_.index_; - _impl_.index_ = nullptr; - return temp; -} -inline ::proto::SyncdIndex* SyncdRecord::_internal_mutable_index() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.index_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncdIndex>(GetArenaForAllocation()); - _impl_.index_ = p; - } - return _impl_.index_; -} -inline ::proto::SyncdIndex* SyncdRecord::mutable_index() { - ::proto::SyncdIndex* _msg = _internal_mutable_index(); - // @@protoc_insertion_point(field_mutable:proto.SyncdRecord.index) - return _msg; -} -inline void SyncdRecord::set_allocated_index(::proto::SyncdIndex* index) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.index_; - } - if (index) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(index); - if (message_arena != submessage_arena) { - index = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, index, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.index_ = index; - // @@protoc_insertion_point(field_set_allocated:proto.SyncdRecord.index) -} - -// optional .proto.SyncdValue value = 2; -inline bool SyncdRecord::_internal_has_value() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.value_ != nullptr); - return value; -} -inline bool SyncdRecord::has_value() const { - return _internal_has_value(); -} -inline void SyncdRecord::clear_value() { - if (_impl_.value_ != nullptr) _impl_.value_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::SyncdValue& SyncdRecord::_internal_value() const { - const ::proto::SyncdValue* p = _impl_.value_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncdValue_default_instance_); -} -inline const ::proto::SyncdValue& SyncdRecord::value() const { - // @@protoc_insertion_point(field_get:proto.SyncdRecord.value) - return _internal_value(); -} -inline void SyncdRecord::unsafe_arena_set_allocated_value( - ::proto::SyncdValue* value) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.value_); - } - _impl_.value_ = value; - if (value) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdRecord.value) -} -inline ::proto::SyncdValue* SyncdRecord::release_value() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::SyncdValue* temp = _impl_.value_; - _impl_.value_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncdValue* SyncdRecord::unsafe_arena_release_value() { - // @@protoc_insertion_point(field_release:proto.SyncdRecord.value) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::SyncdValue* temp = _impl_.value_; - _impl_.value_ = nullptr; - return temp; -} -inline ::proto::SyncdValue* SyncdRecord::_internal_mutable_value() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.value_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncdValue>(GetArenaForAllocation()); - _impl_.value_ = p; - } - return _impl_.value_; -} -inline ::proto::SyncdValue* SyncdRecord::mutable_value() { - ::proto::SyncdValue* _msg = _internal_mutable_value(); - // @@protoc_insertion_point(field_mutable:proto.SyncdRecord.value) - return _msg; -} -inline void SyncdRecord::set_allocated_value(::proto::SyncdValue* value) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.value_; - } - if (value) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(value); - if (message_arena != submessage_arena) { - value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, value, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.value_ = value; - // @@protoc_insertion_point(field_set_allocated:proto.SyncdRecord.value) -} - -// optional .proto.KeyId keyId = 3; -inline bool SyncdRecord::_internal_has_keyid() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - PROTOBUF_ASSUME(!value || _impl_.keyid_ != nullptr); - return value; -} -inline bool SyncdRecord::has_keyid() const { - return _internal_has_keyid(); -} -inline void SyncdRecord::clear_keyid() { - if (_impl_.keyid_ != nullptr) _impl_.keyid_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const ::proto::KeyId& SyncdRecord::_internal_keyid() const { - const ::proto::KeyId* p = _impl_.keyid_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_KeyId_default_instance_); -} -inline const ::proto::KeyId& SyncdRecord::keyid() const { - // @@protoc_insertion_point(field_get:proto.SyncdRecord.keyId) - return _internal_keyid(); -} -inline void SyncdRecord::unsafe_arena_set_allocated_keyid( - ::proto::KeyId* keyid) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keyid_); - } - _impl_.keyid_ = keyid; - if (keyid) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdRecord.keyId) -} -inline ::proto::KeyId* SyncdRecord::release_keyid() { - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::KeyId* temp = _impl_.keyid_; - _impl_.keyid_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::KeyId* SyncdRecord::unsafe_arena_release_keyid() { - // @@protoc_insertion_point(field_release:proto.SyncdRecord.keyId) - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::KeyId* temp = _impl_.keyid_; - _impl_.keyid_ = nullptr; - return temp; -} -inline ::proto::KeyId* SyncdRecord::_internal_mutable_keyid() { - _impl_._has_bits_[0] |= 0x00000004u; - if (_impl_.keyid_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::KeyId>(GetArenaForAllocation()); - _impl_.keyid_ = p; - } - return _impl_.keyid_; -} -inline ::proto::KeyId* SyncdRecord::mutable_keyid() { - ::proto::KeyId* _msg = _internal_mutable_keyid(); - // @@protoc_insertion_point(field_mutable:proto.SyncdRecord.keyId) - return _msg; -} -inline void SyncdRecord::set_allocated_keyid(::proto::KeyId* keyid) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.keyid_; - } - if (keyid) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keyid); - if (message_arena != submessage_arena) { - keyid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, keyid, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.keyid_ = keyid; - // @@protoc_insertion_point(field_set_allocated:proto.SyncdRecord.keyId) -} - -// ------------------------------------------------------------------- - -// SyncdSnapshot - -// optional .proto.SyncdVersion version = 1; -inline bool SyncdSnapshot::_internal_has_version() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.version_ != nullptr); - return value; -} -inline bool SyncdSnapshot::has_version() const { - return _internal_has_version(); -} -inline void SyncdSnapshot::clear_version() { - if (_impl_.version_ != nullptr) _impl_.version_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::SyncdVersion& SyncdSnapshot::_internal_version() const { - const ::proto::SyncdVersion* p = _impl_.version_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_SyncdVersion_default_instance_); -} -inline const ::proto::SyncdVersion& SyncdSnapshot::version() const { - // @@protoc_insertion_point(field_get:proto.SyncdSnapshot.version) - return _internal_version(); -} -inline void SyncdSnapshot::unsafe_arena_set_allocated_version( - ::proto::SyncdVersion* version) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.version_); - } - _impl_.version_ = version; - if (version) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdSnapshot.version) -} -inline ::proto::SyncdVersion* SyncdSnapshot::release_version() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::SyncdVersion* temp = _impl_.version_; - _impl_.version_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::SyncdVersion* SyncdSnapshot::unsafe_arena_release_version() { - // @@protoc_insertion_point(field_release:proto.SyncdSnapshot.version) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::SyncdVersion* temp = _impl_.version_; - _impl_.version_ = nullptr; - return temp; -} -inline ::proto::SyncdVersion* SyncdSnapshot::_internal_mutable_version() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.version_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::SyncdVersion>(GetArenaForAllocation()); - _impl_.version_ = p; - } - return _impl_.version_; -} -inline ::proto::SyncdVersion* SyncdSnapshot::mutable_version() { - ::proto::SyncdVersion* _msg = _internal_mutable_version(); - // @@protoc_insertion_point(field_mutable:proto.SyncdSnapshot.version) - return _msg; -} -inline void SyncdSnapshot::set_allocated_version(::proto::SyncdVersion* version) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.version_; - } - if (version) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(version); - if (message_arena != submessage_arena) { - version = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, version, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.version_ = version; - // @@protoc_insertion_point(field_set_allocated:proto.SyncdSnapshot.version) -} - -// repeated .proto.SyncdRecord records = 2; -inline int SyncdSnapshot::_internal_records_size() const { - return _impl_.records_.size(); -} -inline int SyncdSnapshot::records_size() const { - return _internal_records_size(); -} -inline void SyncdSnapshot::clear_records() { - _impl_.records_.Clear(); -} -inline ::proto::SyncdRecord* SyncdSnapshot::mutable_records(int index) { - // @@protoc_insertion_point(field_mutable:proto.SyncdSnapshot.records) - return _impl_.records_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdRecord >* -SyncdSnapshot::mutable_records() { - // @@protoc_insertion_point(field_mutable_list:proto.SyncdSnapshot.records) - return &_impl_.records_; -} -inline const ::proto::SyncdRecord& SyncdSnapshot::_internal_records(int index) const { - return _impl_.records_.Get(index); -} -inline const ::proto::SyncdRecord& SyncdSnapshot::records(int index) const { - // @@protoc_insertion_point(field_get:proto.SyncdSnapshot.records) - return _internal_records(index); -} -inline ::proto::SyncdRecord* SyncdSnapshot::_internal_add_records() { - return _impl_.records_.Add(); -} -inline ::proto::SyncdRecord* SyncdSnapshot::add_records() { - ::proto::SyncdRecord* _add = _internal_add_records(); - // @@protoc_insertion_point(field_add:proto.SyncdSnapshot.records) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdRecord >& -SyncdSnapshot::records() const { - // @@protoc_insertion_point(field_list:proto.SyncdSnapshot.records) - return _impl_.records_; -} - -// optional bytes mac = 3; -inline bool SyncdSnapshot::_internal_has_mac() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SyncdSnapshot::has_mac() const { - return _internal_has_mac(); -} -inline void SyncdSnapshot::clear_mac() { - _impl_.mac_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& SyncdSnapshot::mac() const { - // @@protoc_insertion_point(field_get:proto.SyncdSnapshot.mac) - return _internal_mac(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SyncdSnapshot::set_mac(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.mac_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SyncdSnapshot.mac) -} -inline std::string* SyncdSnapshot::mutable_mac() { - std::string* _s = _internal_mutable_mac(); - // @@protoc_insertion_point(field_mutable:proto.SyncdSnapshot.mac) - return _s; -} -inline const std::string& SyncdSnapshot::_internal_mac() const { - return _impl_.mac_.Get(); -} -inline void SyncdSnapshot::_internal_set_mac(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.mac_.Set(value, GetArenaForAllocation()); -} -inline std::string* SyncdSnapshot::_internal_mutable_mac() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.mac_.Mutable(GetArenaForAllocation()); -} -inline std::string* SyncdSnapshot::release_mac() { - // @@protoc_insertion_point(field_release:proto.SyncdSnapshot.mac) - if (!_internal_has_mac()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.mac_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mac_.IsDefault()) { - _impl_.mac_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SyncdSnapshot::set_allocated_mac(std::string* mac) { - if (mac != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.mac_.SetAllocated(mac, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mac_.IsDefault()) { - _impl_.mac_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SyncdSnapshot.mac) -} - -// optional .proto.KeyId keyId = 4; -inline bool SyncdSnapshot::_internal_has_keyid() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - PROTOBUF_ASSUME(!value || _impl_.keyid_ != nullptr); - return value; -} -inline bool SyncdSnapshot::has_keyid() const { - return _internal_has_keyid(); -} -inline void SyncdSnapshot::clear_keyid() { - if (_impl_.keyid_ != nullptr) _impl_.keyid_->Clear(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const ::proto::KeyId& SyncdSnapshot::_internal_keyid() const { - const ::proto::KeyId* p = _impl_.keyid_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_KeyId_default_instance_); -} -inline const ::proto::KeyId& SyncdSnapshot::keyid() const { - // @@protoc_insertion_point(field_get:proto.SyncdSnapshot.keyId) - return _internal_keyid(); -} -inline void SyncdSnapshot::unsafe_arena_set_allocated_keyid( - ::proto::KeyId* keyid) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keyid_); - } - _impl_.keyid_ = keyid; - if (keyid) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdSnapshot.keyId) -} -inline ::proto::KeyId* SyncdSnapshot::release_keyid() { - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::KeyId* temp = _impl_.keyid_; - _impl_.keyid_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::KeyId* SyncdSnapshot::unsafe_arena_release_keyid() { - // @@protoc_insertion_point(field_release:proto.SyncdSnapshot.keyId) - _impl_._has_bits_[0] &= ~0x00000004u; - ::proto::KeyId* temp = _impl_.keyid_; - _impl_.keyid_ = nullptr; - return temp; -} -inline ::proto::KeyId* SyncdSnapshot::_internal_mutable_keyid() { - _impl_._has_bits_[0] |= 0x00000004u; - if (_impl_.keyid_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::KeyId>(GetArenaForAllocation()); - _impl_.keyid_ = p; - } - return _impl_.keyid_; -} -inline ::proto::KeyId* SyncdSnapshot::mutable_keyid() { - ::proto::KeyId* _msg = _internal_mutable_keyid(); - // @@protoc_insertion_point(field_mutable:proto.SyncdSnapshot.keyId) - return _msg; -} -inline void SyncdSnapshot::set_allocated_keyid(::proto::KeyId* keyid) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.keyid_; - } - if (keyid) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keyid); - if (message_arena != submessage_arena) { - keyid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, keyid, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.keyid_ = keyid; - // @@protoc_insertion_point(field_set_allocated:proto.SyncdSnapshot.keyId) -} - -// ------------------------------------------------------------------- - -// SyncdValue - -// optional bytes blob = 1; -inline bool SyncdValue::_internal_has_blob() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SyncdValue::has_blob() const { - return _internal_has_blob(); -} -inline void SyncdValue::clear_blob() { - _impl_.blob_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& SyncdValue::blob() const { - // @@protoc_insertion_point(field_get:proto.SyncdValue.blob) - return _internal_blob(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SyncdValue::set_blob(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.blob_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.SyncdValue.blob) -} -inline std::string* SyncdValue::mutable_blob() { - std::string* _s = _internal_mutable_blob(); - // @@protoc_insertion_point(field_mutable:proto.SyncdValue.blob) - return _s; -} -inline const std::string& SyncdValue::_internal_blob() const { - return _impl_.blob_.Get(); -} -inline void SyncdValue::_internal_set_blob(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.blob_.Set(value, GetArenaForAllocation()); -} -inline std::string* SyncdValue::_internal_mutable_blob() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.blob_.Mutable(GetArenaForAllocation()); -} -inline std::string* SyncdValue::release_blob() { - // @@protoc_insertion_point(field_release:proto.SyncdValue.blob) - if (!_internal_has_blob()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.blob_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.blob_.IsDefault()) { - _impl_.blob_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void SyncdValue::set_allocated_blob(std::string* blob) { - if (blob != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.blob_.SetAllocated(blob, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.blob_.IsDefault()) { - _impl_.blob_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.SyncdValue.blob) -} - -// ------------------------------------------------------------------- - -// SyncdVersion - -// optional uint64 version = 1; -inline bool SyncdVersion::_internal_has_version() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool SyncdVersion::has_version() const { - return _internal_has_version(); -} -inline void SyncdVersion::clear_version() { - _impl_.version_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline uint64_t SyncdVersion::_internal_version() const { - return _impl_.version_; -} -inline uint64_t SyncdVersion::version() const { - // @@protoc_insertion_point(field_get:proto.SyncdVersion.version) - return _internal_version(); -} -inline void SyncdVersion::_internal_set_version(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.version_ = value; -} -inline void SyncdVersion::set_version(uint64_t value) { - _internal_set_version(value); - // @@protoc_insertion_point(field_set:proto.SyncdVersion.version) -} - -// ------------------------------------------------------------------- - -// TemplateButton_CallButton - -// optional .proto.Message.HighlyStructuredMessage displayText = 1; -inline bool TemplateButton_CallButton::_internal_has_displaytext() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.displaytext_ != nullptr); - return value; -} -inline bool TemplateButton_CallButton::has_displaytext() const { - return _internal_has_displaytext(); -} -inline void TemplateButton_CallButton::clear_displaytext() { - if (_impl_.displaytext_ != nullptr) _impl_.displaytext_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_CallButton::_internal_displaytext() const { - const ::proto::Message_HighlyStructuredMessage* p = _impl_.displaytext_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_HighlyStructuredMessage_default_instance_); -} -inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_CallButton::displaytext() const { - // @@protoc_insertion_point(field_get:proto.TemplateButton.CallButton.displayText) - return _internal_displaytext(); -} -inline void TemplateButton_CallButton::unsafe_arena_set_allocated_displaytext( - ::proto::Message_HighlyStructuredMessage* displaytext) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.displaytext_); - } - _impl_.displaytext_ = displaytext; - if (displaytext) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.CallButton.displayText) -} -inline ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::release_displaytext() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::Message_HighlyStructuredMessage* temp = _impl_.displaytext_; - _impl_.displaytext_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::unsafe_arena_release_displaytext() { - // @@protoc_insertion_point(field_release:proto.TemplateButton.CallButton.displayText) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::Message_HighlyStructuredMessage* temp = _impl_.displaytext_; - _impl_.displaytext_ = nullptr; - return temp; -} -inline ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::_internal_mutable_displaytext() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.displaytext_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation()); - _impl_.displaytext_ = p; - } - return _impl_.displaytext_; -} -inline ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::mutable_displaytext() { - ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_displaytext(); - // @@protoc_insertion_point(field_mutable:proto.TemplateButton.CallButton.displayText) - return _msg; -} -inline void TemplateButton_CallButton::set_allocated_displaytext(::proto::Message_HighlyStructuredMessage* displaytext) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.displaytext_; - } - if (displaytext) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(displaytext); - if (message_arena != submessage_arena) { - displaytext = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, displaytext, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.displaytext_ = displaytext; - // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.CallButton.displayText) -} - -// optional .proto.Message.HighlyStructuredMessage phoneNumber = 2; -inline bool TemplateButton_CallButton::_internal_has_phonenumber() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.phonenumber_ != nullptr); - return value; -} -inline bool TemplateButton_CallButton::has_phonenumber() const { - return _internal_has_phonenumber(); -} -inline void TemplateButton_CallButton::clear_phonenumber() { - if (_impl_.phonenumber_ != nullptr) _impl_.phonenumber_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_CallButton::_internal_phonenumber() const { - const ::proto::Message_HighlyStructuredMessage* p = _impl_.phonenumber_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_HighlyStructuredMessage_default_instance_); -} -inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_CallButton::phonenumber() const { - // @@protoc_insertion_point(field_get:proto.TemplateButton.CallButton.phoneNumber) - return _internal_phonenumber(); -} -inline void TemplateButton_CallButton::unsafe_arena_set_allocated_phonenumber( - ::proto::Message_HighlyStructuredMessage* phonenumber) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.phonenumber_); - } - _impl_.phonenumber_ = phonenumber; - if (phonenumber) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.CallButton.phoneNumber) -} -inline ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::release_phonenumber() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::Message_HighlyStructuredMessage* temp = _impl_.phonenumber_; - _impl_.phonenumber_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::unsafe_arena_release_phonenumber() { - // @@protoc_insertion_point(field_release:proto.TemplateButton.CallButton.phoneNumber) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::Message_HighlyStructuredMessage* temp = _impl_.phonenumber_; - _impl_.phonenumber_ = nullptr; - return temp; -} -inline ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::_internal_mutable_phonenumber() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.phonenumber_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation()); - _impl_.phonenumber_ = p; - } - return _impl_.phonenumber_; -} -inline ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::mutable_phonenumber() { - ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_phonenumber(); - // @@protoc_insertion_point(field_mutable:proto.TemplateButton.CallButton.phoneNumber) - return _msg; -} -inline void TemplateButton_CallButton::set_allocated_phonenumber(::proto::Message_HighlyStructuredMessage* phonenumber) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.phonenumber_; - } - if (phonenumber) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(phonenumber); - if (message_arena != submessage_arena) { - phonenumber = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, phonenumber, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.phonenumber_ = phonenumber; - // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.CallButton.phoneNumber) -} - -// ------------------------------------------------------------------- - -// TemplateButton_QuickReplyButton - -// optional .proto.Message.HighlyStructuredMessage displayText = 1; -inline bool TemplateButton_QuickReplyButton::_internal_has_displaytext() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.displaytext_ != nullptr); - return value; -} -inline bool TemplateButton_QuickReplyButton::has_displaytext() const { - return _internal_has_displaytext(); -} -inline void TemplateButton_QuickReplyButton::clear_displaytext() { - if (_impl_.displaytext_ != nullptr) _impl_.displaytext_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_QuickReplyButton::_internal_displaytext() const { - const ::proto::Message_HighlyStructuredMessage* p = _impl_.displaytext_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_HighlyStructuredMessage_default_instance_); -} -inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_QuickReplyButton::displaytext() const { - // @@protoc_insertion_point(field_get:proto.TemplateButton.QuickReplyButton.displayText) - return _internal_displaytext(); -} -inline void TemplateButton_QuickReplyButton::unsafe_arena_set_allocated_displaytext( - ::proto::Message_HighlyStructuredMessage* displaytext) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.displaytext_); - } - _impl_.displaytext_ = displaytext; - if (displaytext) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.QuickReplyButton.displayText) -} -inline ::proto::Message_HighlyStructuredMessage* TemplateButton_QuickReplyButton::release_displaytext() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::Message_HighlyStructuredMessage* temp = _impl_.displaytext_; - _impl_.displaytext_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_HighlyStructuredMessage* TemplateButton_QuickReplyButton::unsafe_arena_release_displaytext() { - // @@protoc_insertion_point(field_release:proto.TemplateButton.QuickReplyButton.displayText) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::Message_HighlyStructuredMessage* temp = _impl_.displaytext_; - _impl_.displaytext_ = nullptr; - return temp; -} -inline ::proto::Message_HighlyStructuredMessage* TemplateButton_QuickReplyButton::_internal_mutable_displaytext() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.displaytext_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation()); - _impl_.displaytext_ = p; - } - return _impl_.displaytext_; -} -inline ::proto::Message_HighlyStructuredMessage* TemplateButton_QuickReplyButton::mutable_displaytext() { - ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_displaytext(); - // @@protoc_insertion_point(field_mutable:proto.TemplateButton.QuickReplyButton.displayText) - return _msg; -} -inline void TemplateButton_QuickReplyButton::set_allocated_displaytext(::proto::Message_HighlyStructuredMessage* displaytext) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.displaytext_; - } - if (displaytext) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(displaytext); - if (message_arena != submessage_arena) { - displaytext = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, displaytext, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.displaytext_ = displaytext; - // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.QuickReplyButton.displayText) -} - -// optional string id = 2; -inline bool TemplateButton_QuickReplyButton::_internal_has_id() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool TemplateButton_QuickReplyButton::has_id() const { - return _internal_has_id(); -} -inline void TemplateButton_QuickReplyButton::clear_id() { - _impl_.id_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& TemplateButton_QuickReplyButton::id() const { - // @@protoc_insertion_point(field_get:proto.TemplateButton.QuickReplyButton.id) - return _internal_id(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void TemplateButton_QuickReplyButton::set_id(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.id_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.TemplateButton.QuickReplyButton.id) -} -inline std::string* TemplateButton_QuickReplyButton::mutable_id() { - std::string* _s = _internal_mutable_id(); - // @@protoc_insertion_point(field_mutable:proto.TemplateButton.QuickReplyButton.id) - return _s; -} -inline const std::string& TemplateButton_QuickReplyButton::_internal_id() const { - return _impl_.id_.Get(); -} -inline void TemplateButton_QuickReplyButton::_internal_set_id(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.id_.Set(value, GetArenaForAllocation()); -} -inline std::string* TemplateButton_QuickReplyButton::_internal_mutable_id() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.id_.Mutable(GetArenaForAllocation()); -} -inline std::string* TemplateButton_QuickReplyButton::release_id() { - // @@protoc_insertion_point(field_release:proto.TemplateButton.QuickReplyButton.id) - if (!_internal_has_id()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.id_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.id_.IsDefault()) { - _impl_.id_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void TemplateButton_QuickReplyButton::set_allocated_id(std::string* id) { - if (id != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.id_.SetAllocated(id, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.id_.IsDefault()) { - _impl_.id_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.QuickReplyButton.id) -} - -// ------------------------------------------------------------------- - -// TemplateButton_URLButton - -// optional .proto.Message.HighlyStructuredMessage displayText = 1; -inline bool TemplateButton_URLButton::_internal_has_displaytext() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - PROTOBUF_ASSUME(!value || _impl_.displaytext_ != nullptr); - return value; -} -inline bool TemplateButton_URLButton::has_displaytext() const { - return _internal_has_displaytext(); -} -inline void TemplateButton_URLButton::clear_displaytext() { - if (_impl_.displaytext_ != nullptr) _impl_.displaytext_->Clear(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_URLButton::_internal_displaytext() const { - const ::proto::Message_HighlyStructuredMessage* p = _impl_.displaytext_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_HighlyStructuredMessage_default_instance_); -} -inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_URLButton::displaytext() const { - // @@protoc_insertion_point(field_get:proto.TemplateButton.URLButton.displayText) - return _internal_displaytext(); -} -inline void TemplateButton_URLButton::unsafe_arena_set_allocated_displaytext( - ::proto::Message_HighlyStructuredMessage* displaytext) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.displaytext_); - } - _impl_.displaytext_ = displaytext; - if (displaytext) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.URLButton.displayText) -} -inline ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::release_displaytext() { - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::Message_HighlyStructuredMessage* temp = _impl_.displaytext_; - _impl_.displaytext_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::unsafe_arena_release_displaytext() { - // @@protoc_insertion_point(field_release:proto.TemplateButton.URLButton.displayText) - _impl_._has_bits_[0] &= ~0x00000001u; - ::proto::Message_HighlyStructuredMessage* temp = _impl_.displaytext_; - _impl_.displaytext_ = nullptr; - return temp; -} -inline ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::_internal_mutable_displaytext() { - _impl_._has_bits_[0] |= 0x00000001u; - if (_impl_.displaytext_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation()); - _impl_.displaytext_ = p; - } - return _impl_.displaytext_; -} -inline ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::mutable_displaytext() { - ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_displaytext(); - // @@protoc_insertion_point(field_mutable:proto.TemplateButton.URLButton.displayText) - return _msg; -} -inline void TemplateButton_URLButton::set_allocated_displaytext(::proto::Message_HighlyStructuredMessage* displaytext) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.displaytext_; - } - if (displaytext) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(displaytext); - if (message_arena != submessage_arena) { - displaytext = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, displaytext, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.displaytext_ = displaytext; - // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.URLButton.displayText) -} - -// optional .proto.Message.HighlyStructuredMessage url = 2; -inline bool TemplateButton_URLButton::_internal_has_url() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - PROTOBUF_ASSUME(!value || _impl_.url_ != nullptr); - return value; -} -inline bool TemplateButton_URLButton::has_url() const { - return _internal_has_url(); -} -inline void TemplateButton_URLButton::clear_url() { - if (_impl_.url_ != nullptr) _impl_.url_->Clear(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_URLButton::_internal_url() const { - const ::proto::Message_HighlyStructuredMessage* p = _impl_.url_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_HighlyStructuredMessage_default_instance_); -} -inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_URLButton::url() const { - // @@protoc_insertion_point(field_get:proto.TemplateButton.URLButton.url) - return _internal_url(); -} -inline void TemplateButton_URLButton::unsafe_arena_set_allocated_url( - ::proto::Message_HighlyStructuredMessage* url) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.url_); - } - _impl_.url_ = url; - if (url) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.URLButton.url) -} -inline ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::release_url() { - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::Message_HighlyStructuredMessage* temp = _impl_.url_; - _impl_.url_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::unsafe_arena_release_url() { - // @@protoc_insertion_point(field_release:proto.TemplateButton.URLButton.url) - _impl_._has_bits_[0] &= ~0x00000002u; - ::proto::Message_HighlyStructuredMessage* temp = _impl_.url_; - _impl_.url_ = nullptr; - return temp; -} -inline ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::_internal_mutable_url() { - _impl_._has_bits_[0] |= 0x00000002u; - if (_impl_.url_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation()); - _impl_.url_ = p; - } - return _impl_.url_; -} -inline ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::mutable_url() { - ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_url(); - // @@protoc_insertion_point(field_mutable:proto.TemplateButton.URLButton.url) - return _msg; -} -inline void TemplateButton_URLButton::set_allocated_url(::proto::Message_HighlyStructuredMessage* url) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.url_; - } - if (url) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(url); - if (message_arena != submessage_arena) { - url = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, url, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.url_ = url; - // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.URLButton.url) -} - -// ------------------------------------------------------------------- - -// TemplateButton - -// optional uint32 index = 4; -inline bool TemplateButton::_internal_has_index() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool TemplateButton::has_index() const { - return _internal_has_index(); -} -inline void TemplateButton::clear_index() { - _impl_.index_ = 0u; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline uint32_t TemplateButton::_internal_index() const { - return _impl_.index_; -} -inline uint32_t TemplateButton::index() const { - // @@protoc_insertion_point(field_get:proto.TemplateButton.index) - return _internal_index(); -} -inline void TemplateButton::_internal_set_index(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.index_ = value; -} -inline void TemplateButton::set_index(uint32_t value) { - _internal_set_index(value); - // @@protoc_insertion_point(field_set:proto.TemplateButton.index) -} - -// .proto.TemplateButton.QuickReplyButton quickReplyButton = 1; -inline bool TemplateButton::_internal_has_quickreplybutton() const { - return button_case() == kQuickReplyButton; -} -inline bool TemplateButton::has_quickreplybutton() const { - return _internal_has_quickreplybutton(); -} -inline void TemplateButton::set_has_quickreplybutton() { - _impl_._oneof_case_[0] = kQuickReplyButton; -} -inline void TemplateButton::clear_quickreplybutton() { - if (_internal_has_quickreplybutton()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.button_.quickreplybutton_; - } - clear_has_button(); - } -} -inline ::proto::TemplateButton_QuickReplyButton* TemplateButton::release_quickreplybutton() { - // @@protoc_insertion_point(field_release:proto.TemplateButton.quickReplyButton) - if (_internal_has_quickreplybutton()) { - clear_has_button(); - ::proto::TemplateButton_QuickReplyButton* temp = _impl_.button_.quickreplybutton_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.button_.quickreplybutton_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::TemplateButton_QuickReplyButton& TemplateButton::_internal_quickreplybutton() const { - return _internal_has_quickreplybutton() - ? *_impl_.button_.quickreplybutton_ - : reinterpret_cast< ::proto::TemplateButton_QuickReplyButton&>(::proto::_TemplateButton_QuickReplyButton_default_instance_); -} -inline const ::proto::TemplateButton_QuickReplyButton& TemplateButton::quickreplybutton() const { - // @@protoc_insertion_point(field_get:proto.TemplateButton.quickReplyButton) - return _internal_quickreplybutton(); -} -inline ::proto::TemplateButton_QuickReplyButton* TemplateButton::unsafe_arena_release_quickreplybutton() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.TemplateButton.quickReplyButton) - if (_internal_has_quickreplybutton()) { - clear_has_button(); - ::proto::TemplateButton_QuickReplyButton* temp = _impl_.button_.quickreplybutton_; - _impl_.button_.quickreplybutton_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void TemplateButton::unsafe_arena_set_allocated_quickreplybutton(::proto::TemplateButton_QuickReplyButton* quickreplybutton) { - clear_button(); - if (quickreplybutton) { - set_has_quickreplybutton(); - _impl_.button_.quickreplybutton_ = quickreplybutton; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.quickReplyButton) -} -inline ::proto::TemplateButton_QuickReplyButton* TemplateButton::_internal_mutable_quickreplybutton() { - if (!_internal_has_quickreplybutton()) { - clear_button(); - set_has_quickreplybutton(); - _impl_.button_.quickreplybutton_ = CreateMaybeMessage< ::proto::TemplateButton_QuickReplyButton >(GetArenaForAllocation()); - } - return _impl_.button_.quickreplybutton_; -} -inline ::proto::TemplateButton_QuickReplyButton* TemplateButton::mutable_quickreplybutton() { - ::proto::TemplateButton_QuickReplyButton* _msg = _internal_mutable_quickreplybutton(); - // @@protoc_insertion_point(field_mutable:proto.TemplateButton.quickReplyButton) - return _msg; -} - -// .proto.TemplateButton.URLButton urlButton = 2; -inline bool TemplateButton::_internal_has_urlbutton() const { - return button_case() == kUrlButton; -} -inline bool TemplateButton::has_urlbutton() const { - return _internal_has_urlbutton(); -} -inline void TemplateButton::set_has_urlbutton() { - _impl_._oneof_case_[0] = kUrlButton; -} -inline void TemplateButton::clear_urlbutton() { - if (_internal_has_urlbutton()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.button_.urlbutton_; - } - clear_has_button(); - } -} -inline ::proto::TemplateButton_URLButton* TemplateButton::release_urlbutton() { - // @@protoc_insertion_point(field_release:proto.TemplateButton.urlButton) - if (_internal_has_urlbutton()) { - clear_has_button(); - ::proto::TemplateButton_URLButton* temp = _impl_.button_.urlbutton_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.button_.urlbutton_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::TemplateButton_URLButton& TemplateButton::_internal_urlbutton() const { - return _internal_has_urlbutton() - ? *_impl_.button_.urlbutton_ - : reinterpret_cast< ::proto::TemplateButton_URLButton&>(::proto::_TemplateButton_URLButton_default_instance_); -} -inline const ::proto::TemplateButton_URLButton& TemplateButton::urlbutton() const { - // @@protoc_insertion_point(field_get:proto.TemplateButton.urlButton) - return _internal_urlbutton(); -} -inline ::proto::TemplateButton_URLButton* TemplateButton::unsafe_arena_release_urlbutton() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.TemplateButton.urlButton) - if (_internal_has_urlbutton()) { - clear_has_button(); - ::proto::TemplateButton_URLButton* temp = _impl_.button_.urlbutton_; - _impl_.button_.urlbutton_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void TemplateButton::unsafe_arena_set_allocated_urlbutton(::proto::TemplateButton_URLButton* urlbutton) { - clear_button(); - if (urlbutton) { - set_has_urlbutton(); - _impl_.button_.urlbutton_ = urlbutton; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.urlButton) -} -inline ::proto::TemplateButton_URLButton* TemplateButton::_internal_mutable_urlbutton() { - if (!_internal_has_urlbutton()) { - clear_button(); - set_has_urlbutton(); - _impl_.button_.urlbutton_ = CreateMaybeMessage< ::proto::TemplateButton_URLButton >(GetArenaForAllocation()); - } - return _impl_.button_.urlbutton_; -} -inline ::proto::TemplateButton_URLButton* TemplateButton::mutable_urlbutton() { - ::proto::TemplateButton_URLButton* _msg = _internal_mutable_urlbutton(); - // @@protoc_insertion_point(field_mutable:proto.TemplateButton.urlButton) - return _msg; -} - -// .proto.TemplateButton.CallButton callButton = 3; -inline bool TemplateButton::_internal_has_callbutton() const { - return button_case() == kCallButton; -} -inline bool TemplateButton::has_callbutton() const { - return _internal_has_callbutton(); -} -inline void TemplateButton::set_has_callbutton() { - _impl_._oneof_case_[0] = kCallButton; -} -inline void TemplateButton::clear_callbutton() { - if (_internal_has_callbutton()) { - if (GetArenaForAllocation() == nullptr) { - delete _impl_.button_.callbutton_; - } - clear_has_button(); - } -} -inline ::proto::TemplateButton_CallButton* TemplateButton::release_callbutton() { - // @@protoc_insertion_point(field_release:proto.TemplateButton.callButton) - if (_internal_has_callbutton()) { - clear_has_button(); - ::proto::TemplateButton_CallButton* temp = _impl_.button_.callbutton_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - _impl_.button_.callbutton_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::proto::TemplateButton_CallButton& TemplateButton::_internal_callbutton() const { - return _internal_has_callbutton() - ? *_impl_.button_.callbutton_ - : reinterpret_cast< ::proto::TemplateButton_CallButton&>(::proto::_TemplateButton_CallButton_default_instance_); -} -inline const ::proto::TemplateButton_CallButton& TemplateButton::callbutton() const { - // @@protoc_insertion_point(field_get:proto.TemplateButton.callButton) - return _internal_callbutton(); -} -inline ::proto::TemplateButton_CallButton* TemplateButton::unsafe_arena_release_callbutton() { - // @@protoc_insertion_point(field_unsafe_arena_release:proto.TemplateButton.callButton) - if (_internal_has_callbutton()) { - clear_has_button(); - ::proto::TemplateButton_CallButton* temp = _impl_.button_.callbutton_; - _impl_.button_.callbutton_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void TemplateButton::unsafe_arena_set_allocated_callbutton(::proto::TemplateButton_CallButton* callbutton) { - clear_button(); - if (callbutton) { - set_has_callbutton(); - _impl_.button_.callbutton_ = callbutton; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.callButton) -} -inline ::proto::TemplateButton_CallButton* TemplateButton::_internal_mutable_callbutton() { - if (!_internal_has_callbutton()) { - clear_button(); - set_has_callbutton(); - _impl_.button_.callbutton_ = CreateMaybeMessage< ::proto::TemplateButton_CallButton >(GetArenaForAllocation()); - } - return _impl_.button_.callbutton_; -} -inline ::proto::TemplateButton_CallButton* TemplateButton::mutable_callbutton() { - ::proto::TemplateButton_CallButton* _msg = _internal_mutable_callbutton(); - // @@protoc_insertion_point(field_mutable:proto.TemplateButton.callButton) - return _msg; -} - -inline bool TemplateButton::has_button() const { - return button_case() != BUTTON_NOT_SET; -} -inline void TemplateButton::clear_has_button() { - _impl_._oneof_case_[0] = BUTTON_NOT_SET; -} -inline TemplateButton::ButtonCase TemplateButton::button_case() const { - return TemplateButton::ButtonCase(_impl_._oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// UserReceipt - -// required string userJid = 1; -inline bool UserReceipt::_internal_has_userjid() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool UserReceipt::has_userjid() const { - return _internal_has_userjid(); -} -inline void UserReceipt::clear_userjid() { - _impl_.userjid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& UserReceipt::userjid() const { - // @@protoc_insertion_point(field_get:proto.UserReceipt.userJid) - return _internal_userjid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void UserReceipt::set_userjid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.userjid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.UserReceipt.userJid) -} -inline std::string* UserReceipt::mutable_userjid() { - std::string* _s = _internal_mutable_userjid(); - // @@protoc_insertion_point(field_mutable:proto.UserReceipt.userJid) - return _s; -} -inline const std::string& UserReceipt::_internal_userjid() const { - return _impl_.userjid_.Get(); -} -inline void UserReceipt::_internal_set_userjid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.userjid_.Set(value, GetArenaForAllocation()); -} -inline std::string* UserReceipt::_internal_mutable_userjid() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.userjid_.Mutable(GetArenaForAllocation()); -} -inline std::string* UserReceipt::release_userjid() { - // @@protoc_insertion_point(field_release:proto.UserReceipt.userJid) - if (!_internal_has_userjid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.userjid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.userjid_.IsDefault()) { - _impl_.userjid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void UserReceipt::set_allocated_userjid(std::string* userjid) { - if (userjid != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.userjid_.SetAllocated(userjid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.userjid_.IsDefault()) { - _impl_.userjid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.UserReceipt.userJid) -} - -// optional int64 receiptTimestamp = 2; -inline bool UserReceipt::_internal_has_receipttimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool UserReceipt::has_receipttimestamp() const { - return _internal_has_receipttimestamp(); -} -inline void UserReceipt::clear_receipttimestamp() { - _impl_.receipttimestamp_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline int64_t UserReceipt::_internal_receipttimestamp() const { - return _impl_.receipttimestamp_; -} -inline int64_t UserReceipt::receipttimestamp() const { - // @@protoc_insertion_point(field_get:proto.UserReceipt.receiptTimestamp) - return _internal_receipttimestamp(); -} -inline void UserReceipt::_internal_set_receipttimestamp(int64_t value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.receipttimestamp_ = value; -} -inline void UserReceipt::set_receipttimestamp(int64_t value) { - _internal_set_receipttimestamp(value); - // @@protoc_insertion_point(field_set:proto.UserReceipt.receiptTimestamp) -} - -// optional int64 readTimestamp = 3; -inline bool UserReceipt::_internal_has_readtimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool UserReceipt::has_readtimestamp() const { - return _internal_has_readtimestamp(); -} -inline void UserReceipt::clear_readtimestamp() { - _impl_.readtimestamp_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline int64_t UserReceipt::_internal_readtimestamp() const { - return _impl_.readtimestamp_; -} -inline int64_t UserReceipt::readtimestamp() const { - // @@protoc_insertion_point(field_get:proto.UserReceipt.readTimestamp) - return _internal_readtimestamp(); -} -inline void UserReceipt::_internal_set_readtimestamp(int64_t value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.readtimestamp_ = value; -} -inline void UserReceipt::set_readtimestamp(int64_t value) { - _internal_set_readtimestamp(value); - // @@protoc_insertion_point(field_set:proto.UserReceipt.readTimestamp) -} - -// optional int64 playedTimestamp = 4; -inline bool UserReceipt::_internal_has_playedtimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool UserReceipt::has_playedtimestamp() const { - return _internal_has_playedtimestamp(); -} -inline void UserReceipt::clear_playedtimestamp() { - _impl_.playedtimestamp_ = int64_t{0}; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline int64_t UserReceipt::_internal_playedtimestamp() const { - return _impl_.playedtimestamp_; -} -inline int64_t UserReceipt::playedtimestamp() const { - // @@protoc_insertion_point(field_get:proto.UserReceipt.playedTimestamp) - return _internal_playedtimestamp(); -} -inline void UserReceipt::_internal_set_playedtimestamp(int64_t value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.playedtimestamp_ = value; -} -inline void UserReceipt::set_playedtimestamp(int64_t value) { - _internal_set_playedtimestamp(value); - // @@protoc_insertion_point(field_set:proto.UserReceipt.playedTimestamp) -} - -// repeated string pendingDeviceJid = 5; -inline int UserReceipt::_internal_pendingdevicejid_size() const { - return _impl_.pendingdevicejid_.size(); -} -inline int UserReceipt::pendingdevicejid_size() const { - return _internal_pendingdevicejid_size(); -} -inline void UserReceipt::clear_pendingdevicejid() { - _impl_.pendingdevicejid_.Clear(); -} -inline std::string* UserReceipt::add_pendingdevicejid() { - std::string* _s = _internal_add_pendingdevicejid(); - // @@protoc_insertion_point(field_add_mutable:proto.UserReceipt.pendingDeviceJid) - return _s; -} -inline const std::string& UserReceipt::_internal_pendingdevicejid(int index) const { - return _impl_.pendingdevicejid_.Get(index); -} -inline const std::string& UserReceipt::pendingdevicejid(int index) const { - // @@protoc_insertion_point(field_get:proto.UserReceipt.pendingDeviceJid) - return _internal_pendingdevicejid(index); -} -inline std::string* UserReceipt::mutable_pendingdevicejid(int index) { - // @@protoc_insertion_point(field_mutable:proto.UserReceipt.pendingDeviceJid) - return _impl_.pendingdevicejid_.Mutable(index); -} -inline void UserReceipt::set_pendingdevicejid(int index, const std::string& value) { - _impl_.pendingdevicejid_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:proto.UserReceipt.pendingDeviceJid) -} -inline void UserReceipt::set_pendingdevicejid(int index, std::string&& value) { - _impl_.pendingdevicejid_.Mutable(index)->assign(std::move(value)); - // @@protoc_insertion_point(field_set:proto.UserReceipt.pendingDeviceJid) -} -inline void UserReceipt::set_pendingdevicejid(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - _impl_.pendingdevicejid_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:proto.UserReceipt.pendingDeviceJid) -} -inline void UserReceipt::set_pendingdevicejid(int index, const char* value, size_t size) { - _impl_.pendingdevicejid_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:proto.UserReceipt.pendingDeviceJid) -} -inline std::string* UserReceipt::_internal_add_pendingdevicejid() { - return _impl_.pendingdevicejid_.Add(); -} -inline void UserReceipt::add_pendingdevicejid(const std::string& value) { - _impl_.pendingdevicejid_.Add()->assign(value); - // @@protoc_insertion_point(field_add:proto.UserReceipt.pendingDeviceJid) -} -inline void UserReceipt::add_pendingdevicejid(std::string&& value) { - _impl_.pendingdevicejid_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:proto.UserReceipt.pendingDeviceJid) -} -inline void UserReceipt::add_pendingdevicejid(const char* value) { - GOOGLE_DCHECK(value != nullptr); - _impl_.pendingdevicejid_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:proto.UserReceipt.pendingDeviceJid) -} -inline void UserReceipt::add_pendingdevicejid(const char* value, size_t size) { - _impl_.pendingdevicejid_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:proto.UserReceipt.pendingDeviceJid) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -UserReceipt::pendingdevicejid() const { - // @@protoc_insertion_point(field_list:proto.UserReceipt.pendingDeviceJid) - return _impl_.pendingdevicejid_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -UserReceipt::mutable_pendingdevicejid() { - // @@protoc_insertion_point(field_mutable_list:proto.UserReceipt.pendingDeviceJid) - return &_impl_.pendingdevicejid_; -} - -// repeated string deliveredDeviceJid = 6; -inline int UserReceipt::_internal_delivereddevicejid_size() const { - return _impl_.delivereddevicejid_.size(); -} -inline int UserReceipt::delivereddevicejid_size() const { - return _internal_delivereddevicejid_size(); -} -inline void UserReceipt::clear_delivereddevicejid() { - _impl_.delivereddevicejid_.Clear(); -} -inline std::string* UserReceipt::add_delivereddevicejid() { - std::string* _s = _internal_add_delivereddevicejid(); - // @@protoc_insertion_point(field_add_mutable:proto.UserReceipt.deliveredDeviceJid) - return _s; -} -inline const std::string& UserReceipt::_internal_delivereddevicejid(int index) const { - return _impl_.delivereddevicejid_.Get(index); -} -inline const std::string& UserReceipt::delivereddevicejid(int index) const { - // @@protoc_insertion_point(field_get:proto.UserReceipt.deliveredDeviceJid) - return _internal_delivereddevicejid(index); -} -inline std::string* UserReceipt::mutable_delivereddevicejid(int index) { - // @@protoc_insertion_point(field_mutable:proto.UserReceipt.deliveredDeviceJid) - return _impl_.delivereddevicejid_.Mutable(index); -} -inline void UserReceipt::set_delivereddevicejid(int index, const std::string& value) { - _impl_.delivereddevicejid_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:proto.UserReceipt.deliveredDeviceJid) -} -inline void UserReceipt::set_delivereddevicejid(int index, std::string&& value) { - _impl_.delivereddevicejid_.Mutable(index)->assign(std::move(value)); - // @@protoc_insertion_point(field_set:proto.UserReceipt.deliveredDeviceJid) -} -inline void UserReceipt::set_delivereddevicejid(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - _impl_.delivereddevicejid_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:proto.UserReceipt.deliveredDeviceJid) -} -inline void UserReceipt::set_delivereddevicejid(int index, const char* value, size_t size) { - _impl_.delivereddevicejid_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:proto.UserReceipt.deliveredDeviceJid) -} -inline std::string* UserReceipt::_internal_add_delivereddevicejid() { - return _impl_.delivereddevicejid_.Add(); -} -inline void UserReceipt::add_delivereddevicejid(const std::string& value) { - _impl_.delivereddevicejid_.Add()->assign(value); - // @@protoc_insertion_point(field_add:proto.UserReceipt.deliveredDeviceJid) -} -inline void UserReceipt::add_delivereddevicejid(std::string&& value) { - _impl_.delivereddevicejid_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:proto.UserReceipt.deliveredDeviceJid) -} -inline void UserReceipt::add_delivereddevicejid(const char* value) { - GOOGLE_DCHECK(value != nullptr); - _impl_.delivereddevicejid_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:proto.UserReceipt.deliveredDeviceJid) -} -inline void UserReceipt::add_delivereddevicejid(const char* value, size_t size) { - _impl_.delivereddevicejid_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:proto.UserReceipt.deliveredDeviceJid) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -UserReceipt::delivereddevicejid() const { - // @@protoc_insertion_point(field_list:proto.UserReceipt.deliveredDeviceJid) - return _impl_.delivereddevicejid_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -UserReceipt::mutable_delivereddevicejid() { - // @@protoc_insertion_point(field_mutable_list:proto.UserReceipt.deliveredDeviceJid) - return &_impl_.delivereddevicejid_; -} - -// ------------------------------------------------------------------- - -// VerifiedNameCertificate_Details - -// optional uint64 serial = 1; -inline bool VerifiedNameCertificate_Details::_internal_has_serial() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool VerifiedNameCertificate_Details::has_serial() const { - return _internal_has_serial(); -} -inline void VerifiedNameCertificate_Details::clear_serial() { - _impl_.serial_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline uint64_t VerifiedNameCertificate_Details::_internal_serial() const { - return _impl_.serial_; -} -inline uint64_t VerifiedNameCertificate_Details::serial() const { - // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.Details.serial) - return _internal_serial(); -} -inline void VerifiedNameCertificate_Details::_internal_set_serial(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.serial_ = value; -} -inline void VerifiedNameCertificate_Details::set_serial(uint64_t value) { - _internal_set_serial(value); - // @@protoc_insertion_point(field_set:proto.VerifiedNameCertificate.Details.serial) -} - -// optional string issuer = 2; -inline bool VerifiedNameCertificate_Details::_internal_has_issuer() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool VerifiedNameCertificate_Details::has_issuer() const { - return _internal_has_issuer(); -} -inline void VerifiedNameCertificate_Details::clear_issuer() { - _impl_.issuer_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& VerifiedNameCertificate_Details::issuer() const { - // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.Details.issuer) - return _internal_issuer(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void VerifiedNameCertificate_Details::set_issuer(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.issuer_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.VerifiedNameCertificate.Details.issuer) -} -inline std::string* VerifiedNameCertificate_Details::mutable_issuer() { - std::string* _s = _internal_mutable_issuer(); - // @@protoc_insertion_point(field_mutable:proto.VerifiedNameCertificate.Details.issuer) - return _s; -} -inline const std::string& VerifiedNameCertificate_Details::_internal_issuer() const { - return _impl_.issuer_.Get(); -} -inline void VerifiedNameCertificate_Details::_internal_set_issuer(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.issuer_.Set(value, GetArenaForAllocation()); -} -inline std::string* VerifiedNameCertificate_Details::_internal_mutable_issuer() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.issuer_.Mutable(GetArenaForAllocation()); -} -inline std::string* VerifiedNameCertificate_Details::release_issuer() { - // @@protoc_insertion_point(field_release:proto.VerifiedNameCertificate.Details.issuer) - if (!_internal_has_issuer()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.issuer_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.issuer_.IsDefault()) { - _impl_.issuer_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void VerifiedNameCertificate_Details::set_allocated_issuer(std::string* issuer) { - if (issuer != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.issuer_.SetAllocated(issuer, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.issuer_.IsDefault()) { - _impl_.issuer_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.VerifiedNameCertificate.Details.issuer) -} - -// optional string verifiedName = 4; -inline bool VerifiedNameCertificate_Details::_internal_has_verifiedname() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool VerifiedNameCertificate_Details::has_verifiedname() const { - return _internal_has_verifiedname(); -} -inline void VerifiedNameCertificate_Details::clear_verifiedname() { - _impl_.verifiedname_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& VerifiedNameCertificate_Details::verifiedname() const { - // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.Details.verifiedName) - return _internal_verifiedname(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void VerifiedNameCertificate_Details::set_verifiedname(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.verifiedname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.VerifiedNameCertificate.Details.verifiedName) -} -inline std::string* VerifiedNameCertificate_Details::mutable_verifiedname() { - std::string* _s = _internal_mutable_verifiedname(); - // @@protoc_insertion_point(field_mutable:proto.VerifiedNameCertificate.Details.verifiedName) - return _s; -} -inline const std::string& VerifiedNameCertificate_Details::_internal_verifiedname() const { - return _impl_.verifiedname_.Get(); -} -inline void VerifiedNameCertificate_Details::_internal_set_verifiedname(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.verifiedname_.Set(value, GetArenaForAllocation()); -} -inline std::string* VerifiedNameCertificate_Details::_internal_mutable_verifiedname() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.verifiedname_.Mutable(GetArenaForAllocation()); -} -inline std::string* VerifiedNameCertificate_Details::release_verifiedname() { - // @@protoc_insertion_point(field_release:proto.VerifiedNameCertificate.Details.verifiedName) - if (!_internal_has_verifiedname()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.verifiedname_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.verifiedname_.IsDefault()) { - _impl_.verifiedname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void VerifiedNameCertificate_Details::set_allocated_verifiedname(std::string* verifiedname) { - if (verifiedname != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.verifiedname_.SetAllocated(verifiedname, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.verifiedname_.IsDefault()) { - _impl_.verifiedname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.VerifiedNameCertificate.Details.verifiedName) -} - -// repeated .proto.LocalizedName localizedNames = 8; -inline int VerifiedNameCertificate_Details::_internal_localizednames_size() const { - return _impl_.localizednames_.size(); -} -inline int VerifiedNameCertificate_Details::localizednames_size() const { - return _internal_localizednames_size(); -} -inline void VerifiedNameCertificate_Details::clear_localizednames() { - _impl_.localizednames_.Clear(); -} -inline ::proto::LocalizedName* VerifiedNameCertificate_Details::mutable_localizednames(int index) { - // @@protoc_insertion_point(field_mutable:proto.VerifiedNameCertificate.Details.localizedNames) - return _impl_.localizednames_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::LocalizedName >* -VerifiedNameCertificate_Details::mutable_localizednames() { - // @@protoc_insertion_point(field_mutable_list:proto.VerifiedNameCertificate.Details.localizedNames) - return &_impl_.localizednames_; -} -inline const ::proto::LocalizedName& VerifiedNameCertificate_Details::_internal_localizednames(int index) const { - return _impl_.localizednames_.Get(index); -} -inline const ::proto::LocalizedName& VerifiedNameCertificate_Details::localizednames(int index) const { - // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.Details.localizedNames) - return _internal_localizednames(index); -} -inline ::proto::LocalizedName* VerifiedNameCertificate_Details::_internal_add_localizednames() { - return _impl_.localizednames_.Add(); -} -inline ::proto::LocalizedName* VerifiedNameCertificate_Details::add_localizednames() { - ::proto::LocalizedName* _add = _internal_add_localizednames(); - // @@protoc_insertion_point(field_add:proto.VerifiedNameCertificate.Details.localizedNames) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::LocalizedName >& -VerifiedNameCertificate_Details::localizednames() const { - // @@protoc_insertion_point(field_list:proto.VerifiedNameCertificate.Details.localizedNames) - return _impl_.localizednames_; -} - -// optional uint64 issueTime = 10; -inline bool VerifiedNameCertificate_Details::_internal_has_issuetime() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool VerifiedNameCertificate_Details::has_issuetime() const { - return _internal_has_issuetime(); -} -inline void VerifiedNameCertificate_Details::clear_issuetime() { - _impl_.issuetime_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline uint64_t VerifiedNameCertificate_Details::_internal_issuetime() const { - return _impl_.issuetime_; -} -inline uint64_t VerifiedNameCertificate_Details::issuetime() const { - // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.Details.issueTime) - return _internal_issuetime(); -} -inline void VerifiedNameCertificate_Details::_internal_set_issuetime(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.issuetime_ = value; -} -inline void VerifiedNameCertificate_Details::set_issuetime(uint64_t value) { - _internal_set_issuetime(value); - // @@protoc_insertion_point(field_set:proto.VerifiedNameCertificate.Details.issueTime) -} - -// ------------------------------------------------------------------- - -// VerifiedNameCertificate - -// optional bytes details = 1; -inline bool VerifiedNameCertificate::_internal_has_details() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool VerifiedNameCertificate::has_details() const { - return _internal_has_details(); -} -inline void VerifiedNameCertificate::clear_details() { - _impl_.details_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& VerifiedNameCertificate::details() const { - // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.details) - return _internal_details(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void VerifiedNameCertificate::set_details(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.details_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.VerifiedNameCertificate.details) -} -inline std::string* VerifiedNameCertificate::mutable_details() { - std::string* _s = _internal_mutable_details(); - // @@protoc_insertion_point(field_mutable:proto.VerifiedNameCertificate.details) - return _s; -} -inline const std::string& VerifiedNameCertificate::_internal_details() const { - return _impl_.details_.Get(); -} -inline void VerifiedNameCertificate::_internal_set_details(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.details_.Set(value, GetArenaForAllocation()); -} -inline std::string* VerifiedNameCertificate::_internal_mutable_details() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.details_.Mutable(GetArenaForAllocation()); -} -inline std::string* VerifiedNameCertificate::release_details() { - // @@protoc_insertion_point(field_release:proto.VerifiedNameCertificate.details) - if (!_internal_has_details()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.details_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.details_.IsDefault()) { - _impl_.details_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void VerifiedNameCertificate::set_allocated_details(std::string* details) { - if (details != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.details_.SetAllocated(details, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.details_.IsDefault()) { - _impl_.details_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.VerifiedNameCertificate.details) -} - -// optional bytes signature = 2; -inline bool VerifiedNameCertificate::_internal_has_signature() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool VerifiedNameCertificate::has_signature() const { - return _internal_has_signature(); -} -inline void VerifiedNameCertificate::clear_signature() { - _impl_.signature_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& VerifiedNameCertificate::signature() const { - // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.signature) - return _internal_signature(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void VerifiedNameCertificate::set_signature(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.signature_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.VerifiedNameCertificate.signature) -} -inline std::string* VerifiedNameCertificate::mutable_signature() { - std::string* _s = _internal_mutable_signature(); - // @@protoc_insertion_point(field_mutable:proto.VerifiedNameCertificate.signature) - return _s; -} -inline const std::string& VerifiedNameCertificate::_internal_signature() const { - return _impl_.signature_.Get(); -} -inline void VerifiedNameCertificate::_internal_set_signature(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.signature_.Set(value, GetArenaForAllocation()); -} -inline std::string* VerifiedNameCertificate::_internal_mutable_signature() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.signature_.Mutable(GetArenaForAllocation()); -} -inline std::string* VerifiedNameCertificate::release_signature() { - // @@protoc_insertion_point(field_release:proto.VerifiedNameCertificate.signature) - if (!_internal_has_signature()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.signature_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.signature_.IsDefault()) { - _impl_.signature_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void VerifiedNameCertificate::set_allocated_signature(std::string* signature) { - if (signature != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.signature_.SetAllocated(signature, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.signature_.IsDefault()) { - _impl_.signature_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.VerifiedNameCertificate.signature) -} - -// optional bytes serverSignature = 3; -inline bool VerifiedNameCertificate::_internal_has_serversignature() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool VerifiedNameCertificate::has_serversignature() const { - return _internal_has_serversignature(); -} -inline void VerifiedNameCertificate::clear_serversignature() { - _impl_.serversignature_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& VerifiedNameCertificate::serversignature() const { - // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.serverSignature) - return _internal_serversignature(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void VerifiedNameCertificate::set_serversignature(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.serversignature_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.VerifiedNameCertificate.serverSignature) -} -inline std::string* VerifiedNameCertificate::mutable_serversignature() { - std::string* _s = _internal_mutable_serversignature(); - // @@protoc_insertion_point(field_mutable:proto.VerifiedNameCertificate.serverSignature) - return _s; -} -inline const std::string& VerifiedNameCertificate::_internal_serversignature() const { - return _impl_.serversignature_.Get(); -} -inline void VerifiedNameCertificate::_internal_set_serversignature(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.serversignature_.Set(value, GetArenaForAllocation()); -} -inline std::string* VerifiedNameCertificate::_internal_mutable_serversignature() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.serversignature_.Mutable(GetArenaForAllocation()); -} -inline std::string* VerifiedNameCertificate::release_serversignature() { - // @@protoc_insertion_point(field_release:proto.VerifiedNameCertificate.serverSignature) - if (!_internal_has_serversignature()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.serversignature_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.serversignature_.IsDefault()) { - _impl_.serversignature_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void VerifiedNameCertificate::set_allocated_serversignature(std::string* serversignature) { - if (serversignature != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.serversignature_.SetAllocated(serversignature, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.serversignature_.IsDefault()) { - _impl_.serversignature_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.VerifiedNameCertificate.serverSignature) -} - -// ------------------------------------------------------------------- - -// WallpaperSettings - -// optional string filename = 1; -inline bool WallpaperSettings::_internal_has_filename() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool WallpaperSettings::has_filename() const { - return _internal_has_filename(); -} -inline void WallpaperSettings::clear_filename() { - _impl_.filename_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& WallpaperSettings::filename() const { - // @@protoc_insertion_point(field_get:proto.WallpaperSettings.filename) - return _internal_filename(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void WallpaperSettings::set_filename(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.filename_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.WallpaperSettings.filename) -} -inline std::string* WallpaperSettings::mutable_filename() { - std::string* _s = _internal_mutable_filename(); - // @@protoc_insertion_point(field_mutable:proto.WallpaperSettings.filename) - return _s; -} -inline const std::string& WallpaperSettings::_internal_filename() const { - return _impl_.filename_.Get(); -} -inline void WallpaperSettings::_internal_set_filename(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.filename_.Set(value, GetArenaForAllocation()); -} -inline std::string* WallpaperSettings::_internal_mutable_filename() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.filename_.Mutable(GetArenaForAllocation()); -} -inline std::string* WallpaperSettings::release_filename() { - // @@protoc_insertion_point(field_release:proto.WallpaperSettings.filename) - if (!_internal_has_filename()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.filename_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.filename_.IsDefault()) { - _impl_.filename_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void WallpaperSettings::set_allocated_filename(std::string* filename) { - if (filename != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.filename_.SetAllocated(filename, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.filename_.IsDefault()) { - _impl_.filename_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.WallpaperSettings.filename) -} - -// optional uint32 opacity = 2; -inline bool WallpaperSettings::_internal_has_opacity() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool WallpaperSettings::has_opacity() const { - return _internal_has_opacity(); -} -inline void WallpaperSettings::clear_opacity() { - _impl_.opacity_ = 0u; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline uint32_t WallpaperSettings::_internal_opacity() const { - return _impl_.opacity_; -} -inline uint32_t WallpaperSettings::opacity() const { - // @@protoc_insertion_point(field_get:proto.WallpaperSettings.opacity) - return _internal_opacity(); -} -inline void WallpaperSettings::_internal_set_opacity(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.opacity_ = value; -} -inline void WallpaperSettings::set_opacity(uint32_t value) { - _internal_set_opacity(value); - // @@protoc_insertion_point(field_set:proto.WallpaperSettings.opacity) -} - -// ------------------------------------------------------------------- - -// WebFeatures - -// optional .proto.WebFeatures.Flag labelsDisplay = 1; -inline bool WebFeatures::_internal_has_labelsdisplay() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool WebFeatures::has_labelsdisplay() const { - return _internal_has_labelsdisplay(); -} -inline void WebFeatures::clear_labelsdisplay() { - _impl_.labelsdisplay_ = 0; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_labelsdisplay() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.labelsdisplay_); -} -inline ::proto::WebFeatures_Flag WebFeatures::labelsdisplay() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.labelsDisplay) - return _internal_labelsdisplay(); -} -inline void WebFeatures::_internal_set_labelsdisplay(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.labelsdisplay_ = value; -} -inline void WebFeatures::set_labelsdisplay(::proto::WebFeatures_Flag value) { - _internal_set_labelsdisplay(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.labelsDisplay) -} - -// optional .proto.WebFeatures.Flag voipIndividualOutgoing = 2; -inline bool WebFeatures::_internal_has_voipindividualoutgoing() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool WebFeatures::has_voipindividualoutgoing() const { - return _internal_has_voipindividualoutgoing(); -} -inline void WebFeatures::clear_voipindividualoutgoing() { - _impl_.voipindividualoutgoing_ = 0; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_voipindividualoutgoing() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.voipindividualoutgoing_); -} -inline ::proto::WebFeatures_Flag WebFeatures::voipindividualoutgoing() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.voipIndividualOutgoing) - return _internal_voipindividualoutgoing(); -} -inline void WebFeatures::_internal_set_voipindividualoutgoing(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.voipindividualoutgoing_ = value; -} -inline void WebFeatures::set_voipindividualoutgoing(::proto::WebFeatures_Flag value) { - _internal_set_voipindividualoutgoing(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.voipIndividualOutgoing) -} - -// optional .proto.WebFeatures.Flag groupsV3 = 3; -inline bool WebFeatures::_internal_has_groupsv3() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool WebFeatures::has_groupsv3() const { - return _internal_has_groupsv3(); -} -inline void WebFeatures::clear_groupsv3() { - _impl_.groupsv3_ = 0; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_groupsv3() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.groupsv3_); -} -inline ::proto::WebFeatures_Flag WebFeatures::groupsv3() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.groupsV3) - return _internal_groupsv3(); -} -inline void WebFeatures::_internal_set_groupsv3(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.groupsv3_ = value; -} -inline void WebFeatures::set_groupsv3(::proto::WebFeatures_Flag value) { - _internal_set_groupsv3(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.groupsV3) -} - -// optional .proto.WebFeatures.Flag groupsV3Create = 4; -inline bool WebFeatures::_internal_has_groupsv3create() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool WebFeatures::has_groupsv3create() const { - return _internal_has_groupsv3create(); -} -inline void WebFeatures::clear_groupsv3create() { - _impl_.groupsv3create_ = 0; - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_groupsv3create() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.groupsv3create_); -} -inline ::proto::WebFeatures_Flag WebFeatures::groupsv3create() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.groupsV3Create) - return _internal_groupsv3create(); -} -inline void WebFeatures::_internal_set_groupsv3create(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.groupsv3create_ = value; -} -inline void WebFeatures::set_groupsv3create(::proto::WebFeatures_Flag value) { - _internal_set_groupsv3create(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.groupsV3Create) -} - -// optional .proto.WebFeatures.Flag changeNumberV2 = 5; -inline bool WebFeatures::_internal_has_changenumberv2() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool WebFeatures::has_changenumberv2() const { - return _internal_has_changenumberv2(); -} -inline void WebFeatures::clear_changenumberv2() { - _impl_.changenumberv2_ = 0; - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_changenumberv2() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.changenumberv2_); -} -inline ::proto::WebFeatures_Flag WebFeatures::changenumberv2() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.changeNumberV2) - return _internal_changenumberv2(); -} -inline void WebFeatures::_internal_set_changenumberv2(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.changenumberv2_ = value; -} -inline void WebFeatures::set_changenumberv2(::proto::WebFeatures_Flag value) { - _internal_set_changenumberv2(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.changeNumberV2) -} - -// optional .proto.WebFeatures.Flag queryStatusV3Thumbnail = 6; -inline bool WebFeatures::_internal_has_querystatusv3thumbnail() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool WebFeatures::has_querystatusv3thumbnail() const { - return _internal_has_querystatusv3thumbnail(); -} -inline void WebFeatures::clear_querystatusv3thumbnail() { - _impl_.querystatusv3thumbnail_ = 0; - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_querystatusv3thumbnail() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.querystatusv3thumbnail_); -} -inline ::proto::WebFeatures_Flag WebFeatures::querystatusv3thumbnail() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.queryStatusV3Thumbnail) - return _internal_querystatusv3thumbnail(); -} -inline void WebFeatures::_internal_set_querystatusv3thumbnail(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.querystatusv3thumbnail_ = value; -} -inline void WebFeatures::set_querystatusv3thumbnail(::proto::WebFeatures_Flag value) { - _internal_set_querystatusv3thumbnail(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.queryStatusV3Thumbnail) -} - -// optional .proto.WebFeatures.Flag liveLocations = 7; -inline bool WebFeatures::_internal_has_livelocations() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool WebFeatures::has_livelocations() const { - return _internal_has_livelocations(); -} -inline void WebFeatures::clear_livelocations() { - _impl_.livelocations_ = 0; - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_livelocations() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.livelocations_); -} -inline ::proto::WebFeatures_Flag WebFeatures::livelocations() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.liveLocations) - return _internal_livelocations(); -} -inline void WebFeatures::_internal_set_livelocations(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.livelocations_ = value; -} -inline void WebFeatures::set_livelocations(::proto::WebFeatures_Flag value) { - _internal_set_livelocations(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.liveLocations) -} - -// optional .proto.WebFeatures.Flag queryVname = 8; -inline bool WebFeatures::_internal_has_queryvname() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - return value; -} -inline bool WebFeatures::has_queryvname() const { - return _internal_has_queryvname(); -} -inline void WebFeatures::clear_queryvname() { - _impl_.queryvname_ = 0; - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_queryvname() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.queryvname_); -} -inline ::proto::WebFeatures_Flag WebFeatures::queryvname() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.queryVname) - return _internal_queryvname(); -} -inline void WebFeatures::_internal_set_queryvname(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.queryvname_ = value; -} -inline void WebFeatures::set_queryvname(::proto::WebFeatures_Flag value) { - _internal_set_queryvname(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.queryVname) -} - -// optional .proto.WebFeatures.Flag voipIndividualIncoming = 9; -inline bool WebFeatures::_internal_has_voipindividualincoming() const { - bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; - return value; -} -inline bool WebFeatures::has_voipindividualincoming() const { - return _internal_has_voipindividualincoming(); -} -inline void WebFeatures::clear_voipindividualincoming() { - _impl_.voipindividualincoming_ = 0; - _impl_._has_bits_[0] &= ~0x00000100u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_voipindividualincoming() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.voipindividualincoming_); -} -inline ::proto::WebFeatures_Flag WebFeatures::voipindividualincoming() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.voipIndividualIncoming) - return _internal_voipindividualincoming(); -} -inline void WebFeatures::_internal_set_voipindividualincoming(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000100u; - _impl_.voipindividualincoming_ = value; -} -inline void WebFeatures::set_voipindividualincoming(::proto::WebFeatures_Flag value) { - _internal_set_voipindividualincoming(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.voipIndividualIncoming) -} - -// optional .proto.WebFeatures.Flag quickRepliesQuery = 10; -inline bool WebFeatures::_internal_has_quickrepliesquery() const { - bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; - return value; -} -inline bool WebFeatures::has_quickrepliesquery() const { - return _internal_has_quickrepliesquery(); -} -inline void WebFeatures::clear_quickrepliesquery() { - _impl_.quickrepliesquery_ = 0; - _impl_._has_bits_[0] &= ~0x00000200u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_quickrepliesquery() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.quickrepliesquery_); -} -inline ::proto::WebFeatures_Flag WebFeatures::quickrepliesquery() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.quickRepliesQuery) - return _internal_quickrepliesquery(); -} -inline void WebFeatures::_internal_set_quickrepliesquery(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000200u; - _impl_.quickrepliesquery_ = value; -} -inline void WebFeatures::set_quickrepliesquery(::proto::WebFeatures_Flag value) { - _internal_set_quickrepliesquery(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.quickRepliesQuery) -} - -// optional .proto.WebFeatures.Flag payments = 11; -inline bool WebFeatures::_internal_has_payments() const { - bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; - return value; -} -inline bool WebFeatures::has_payments() const { - return _internal_has_payments(); -} -inline void WebFeatures::clear_payments() { - _impl_.payments_ = 0; - _impl_._has_bits_[0] &= ~0x00000400u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_payments() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.payments_); -} -inline ::proto::WebFeatures_Flag WebFeatures::payments() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.payments) - return _internal_payments(); -} -inline void WebFeatures::_internal_set_payments(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000400u; - _impl_.payments_ = value; -} -inline void WebFeatures::set_payments(::proto::WebFeatures_Flag value) { - _internal_set_payments(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.payments) -} - -// optional .proto.WebFeatures.Flag stickerPackQuery = 12; -inline bool WebFeatures::_internal_has_stickerpackquery() const { - bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; - return value; -} -inline bool WebFeatures::has_stickerpackquery() const { - return _internal_has_stickerpackquery(); -} -inline void WebFeatures::clear_stickerpackquery() { - _impl_.stickerpackquery_ = 0; - _impl_._has_bits_[0] &= ~0x00000800u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_stickerpackquery() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.stickerpackquery_); -} -inline ::proto::WebFeatures_Flag WebFeatures::stickerpackquery() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.stickerPackQuery) - return _internal_stickerpackquery(); -} -inline void WebFeatures::_internal_set_stickerpackquery(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x00000800u; - _impl_.stickerpackquery_ = value; -} -inline void WebFeatures::set_stickerpackquery(::proto::WebFeatures_Flag value) { - _internal_set_stickerpackquery(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.stickerPackQuery) -} - -// optional .proto.WebFeatures.Flag liveLocationsFinal = 13; -inline bool WebFeatures::_internal_has_livelocationsfinal() const { - bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; - return value; -} -inline bool WebFeatures::has_livelocationsfinal() const { - return _internal_has_livelocationsfinal(); -} -inline void WebFeatures::clear_livelocationsfinal() { - _impl_.livelocationsfinal_ = 0; - _impl_._has_bits_[0] &= ~0x00001000u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_livelocationsfinal() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.livelocationsfinal_); -} -inline ::proto::WebFeatures_Flag WebFeatures::livelocationsfinal() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.liveLocationsFinal) - return _internal_livelocationsfinal(); -} -inline void WebFeatures::_internal_set_livelocationsfinal(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x00001000u; - _impl_.livelocationsfinal_ = value; -} -inline void WebFeatures::set_livelocationsfinal(::proto::WebFeatures_Flag value) { - _internal_set_livelocationsfinal(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.liveLocationsFinal) -} - -// optional .proto.WebFeatures.Flag labelsEdit = 14; -inline bool WebFeatures::_internal_has_labelsedit() const { - bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0; - return value; -} -inline bool WebFeatures::has_labelsedit() const { - return _internal_has_labelsedit(); -} -inline void WebFeatures::clear_labelsedit() { - _impl_.labelsedit_ = 0; - _impl_._has_bits_[0] &= ~0x00002000u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_labelsedit() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.labelsedit_); -} -inline ::proto::WebFeatures_Flag WebFeatures::labelsedit() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.labelsEdit) - return _internal_labelsedit(); -} -inline void WebFeatures::_internal_set_labelsedit(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x00002000u; - _impl_.labelsedit_ = value; -} -inline void WebFeatures::set_labelsedit(::proto::WebFeatures_Flag value) { - _internal_set_labelsedit(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.labelsEdit) -} - -// optional .proto.WebFeatures.Flag mediaUpload = 15; -inline bool WebFeatures::_internal_has_mediaupload() const { - bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0; - return value; -} -inline bool WebFeatures::has_mediaupload() const { - return _internal_has_mediaupload(); -} -inline void WebFeatures::clear_mediaupload() { - _impl_.mediaupload_ = 0; - _impl_._has_bits_[0] &= ~0x00004000u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_mediaupload() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.mediaupload_); -} -inline ::proto::WebFeatures_Flag WebFeatures::mediaupload() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.mediaUpload) - return _internal_mediaupload(); -} -inline void WebFeatures::_internal_set_mediaupload(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x00004000u; - _impl_.mediaupload_ = value; -} -inline void WebFeatures::set_mediaupload(::proto::WebFeatures_Flag value) { - _internal_set_mediaupload(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.mediaUpload) -} - -// optional .proto.WebFeatures.Flag mediaUploadRichQuickReplies = 18; -inline bool WebFeatures::_internal_has_mediauploadrichquickreplies() const { - bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0; - return value; -} -inline bool WebFeatures::has_mediauploadrichquickreplies() const { - return _internal_has_mediauploadrichquickreplies(); -} -inline void WebFeatures::clear_mediauploadrichquickreplies() { - _impl_.mediauploadrichquickreplies_ = 0; - _impl_._has_bits_[0] &= ~0x00008000u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_mediauploadrichquickreplies() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.mediauploadrichquickreplies_); -} -inline ::proto::WebFeatures_Flag WebFeatures::mediauploadrichquickreplies() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.mediaUploadRichQuickReplies) - return _internal_mediauploadrichquickreplies(); -} -inline void WebFeatures::_internal_set_mediauploadrichquickreplies(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x00008000u; - _impl_.mediauploadrichquickreplies_ = value; -} -inline void WebFeatures::set_mediauploadrichquickreplies(::proto::WebFeatures_Flag value) { - _internal_set_mediauploadrichquickreplies(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.mediaUploadRichQuickReplies) -} - -// optional .proto.WebFeatures.Flag vnameV2 = 19; -inline bool WebFeatures::_internal_has_vnamev2() const { - bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0; - return value; -} -inline bool WebFeatures::has_vnamev2() const { - return _internal_has_vnamev2(); -} -inline void WebFeatures::clear_vnamev2() { - _impl_.vnamev2_ = 0; - _impl_._has_bits_[0] &= ~0x00010000u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_vnamev2() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.vnamev2_); -} -inline ::proto::WebFeatures_Flag WebFeatures::vnamev2() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.vnameV2) - return _internal_vnamev2(); -} -inline void WebFeatures::_internal_set_vnamev2(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x00010000u; - _impl_.vnamev2_ = value; -} -inline void WebFeatures::set_vnamev2(::proto::WebFeatures_Flag value) { - _internal_set_vnamev2(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.vnameV2) -} - -// optional .proto.WebFeatures.Flag videoPlaybackUrl = 20; -inline bool WebFeatures::_internal_has_videoplaybackurl() const { - bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0; - return value; -} -inline bool WebFeatures::has_videoplaybackurl() const { - return _internal_has_videoplaybackurl(); -} -inline void WebFeatures::clear_videoplaybackurl() { - _impl_.videoplaybackurl_ = 0; - _impl_._has_bits_[0] &= ~0x00020000u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_videoplaybackurl() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.videoplaybackurl_); -} -inline ::proto::WebFeatures_Flag WebFeatures::videoplaybackurl() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.videoPlaybackUrl) - return _internal_videoplaybackurl(); -} -inline void WebFeatures::_internal_set_videoplaybackurl(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x00020000u; - _impl_.videoplaybackurl_ = value; -} -inline void WebFeatures::set_videoplaybackurl(::proto::WebFeatures_Flag value) { - _internal_set_videoplaybackurl(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.videoPlaybackUrl) -} - -// optional .proto.WebFeatures.Flag statusRanking = 21; -inline bool WebFeatures::_internal_has_statusranking() const { - bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0; - return value; -} -inline bool WebFeatures::has_statusranking() const { - return _internal_has_statusranking(); -} -inline void WebFeatures::clear_statusranking() { - _impl_.statusranking_ = 0; - _impl_._has_bits_[0] &= ~0x00040000u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_statusranking() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.statusranking_); -} -inline ::proto::WebFeatures_Flag WebFeatures::statusranking() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.statusRanking) - return _internal_statusranking(); -} -inline void WebFeatures::_internal_set_statusranking(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x00040000u; - _impl_.statusranking_ = value; -} -inline void WebFeatures::set_statusranking(::proto::WebFeatures_Flag value) { - _internal_set_statusranking(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.statusRanking) -} - -// optional .proto.WebFeatures.Flag voipIndividualVideo = 22; -inline bool WebFeatures::_internal_has_voipindividualvideo() const { - bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0; - return value; -} -inline bool WebFeatures::has_voipindividualvideo() const { - return _internal_has_voipindividualvideo(); -} -inline void WebFeatures::clear_voipindividualvideo() { - _impl_.voipindividualvideo_ = 0; - _impl_._has_bits_[0] &= ~0x00080000u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_voipindividualvideo() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.voipindividualvideo_); -} -inline ::proto::WebFeatures_Flag WebFeatures::voipindividualvideo() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.voipIndividualVideo) - return _internal_voipindividualvideo(); -} -inline void WebFeatures::_internal_set_voipindividualvideo(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x00080000u; - _impl_.voipindividualvideo_ = value; -} -inline void WebFeatures::set_voipindividualvideo(::proto::WebFeatures_Flag value) { - _internal_set_voipindividualvideo(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.voipIndividualVideo) -} - -// optional .proto.WebFeatures.Flag thirdPartyStickers = 23; -inline bool WebFeatures::_internal_has_thirdpartystickers() const { - bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0; - return value; -} -inline bool WebFeatures::has_thirdpartystickers() const { - return _internal_has_thirdpartystickers(); -} -inline void WebFeatures::clear_thirdpartystickers() { - _impl_.thirdpartystickers_ = 0; - _impl_._has_bits_[0] &= ~0x00100000u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_thirdpartystickers() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.thirdpartystickers_); -} -inline ::proto::WebFeatures_Flag WebFeatures::thirdpartystickers() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.thirdPartyStickers) - return _internal_thirdpartystickers(); -} -inline void WebFeatures::_internal_set_thirdpartystickers(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x00100000u; - _impl_.thirdpartystickers_ = value; -} -inline void WebFeatures::set_thirdpartystickers(::proto::WebFeatures_Flag value) { - _internal_set_thirdpartystickers(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.thirdPartyStickers) -} - -// optional .proto.WebFeatures.Flag frequentlyForwardedSetting = 24; -inline bool WebFeatures::_internal_has_frequentlyforwardedsetting() const { - bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0; - return value; -} -inline bool WebFeatures::has_frequentlyforwardedsetting() const { - return _internal_has_frequentlyforwardedsetting(); -} -inline void WebFeatures::clear_frequentlyforwardedsetting() { - _impl_.frequentlyforwardedsetting_ = 0; - _impl_._has_bits_[0] &= ~0x00200000u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_frequentlyforwardedsetting() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.frequentlyforwardedsetting_); -} -inline ::proto::WebFeatures_Flag WebFeatures::frequentlyforwardedsetting() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.frequentlyForwardedSetting) - return _internal_frequentlyforwardedsetting(); -} -inline void WebFeatures::_internal_set_frequentlyforwardedsetting(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x00200000u; - _impl_.frequentlyforwardedsetting_ = value; -} -inline void WebFeatures::set_frequentlyforwardedsetting(::proto::WebFeatures_Flag value) { - _internal_set_frequentlyforwardedsetting(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.frequentlyForwardedSetting) -} - -// optional .proto.WebFeatures.Flag groupsV4JoinPermission = 25; -inline bool WebFeatures::_internal_has_groupsv4joinpermission() const { - bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0; - return value; -} -inline bool WebFeatures::has_groupsv4joinpermission() const { - return _internal_has_groupsv4joinpermission(); -} -inline void WebFeatures::clear_groupsv4joinpermission() { - _impl_.groupsv4joinpermission_ = 0; - _impl_._has_bits_[0] &= ~0x00400000u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_groupsv4joinpermission() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.groupsv4joinpermission_); -} -inline ::proto::WebFeatures_Flag WebFeatures::groupsv4joinpermission() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.groupsV4JoinPermission) - return _internal_groupsv4joinpermission(); -} -inline void WebFeatures::_internal_set_groupsv4joinpermission(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x00400000u; - _impl_.groupsv4joinpermission_ = value; -} -inline void WebFeatures::set_groupsv4joinpermission(::proto::WebFeatures_Flag value) { - _internal_set_groupsv4joinpermission(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.groupsV4JoinPermission) -} - -// optional .proto.WebFeatures.Flag recentStickers = 26; -inline bool WebFeatures::_internal_has_recentstickers() const { - bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0; - return value; -} -inline bool WebFeatures::has_recentstickers() const { - return _internal_has_recentstickers(); -} -inline void WebFeatures::clear_recentstickers() { - _impl_.recentstickers_ = 0; - _impl_._has_bits_[0] &= ~0x00800000u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_recentstickers() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.recentstickers_); -} -inline ::proto::WebFeatures_Flag WebFeatures::recentstickers() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.recentStickers) - return _internal_recentstickers(); -} -inline void WebFeatures::_internal_set_recentstickers(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x00800000u; - _impl_.recentstickers_ = value; -} -inline void WebFeatures::set_recentstickers(::proto::WebFeatures_Flag value) { - _internal_set_recentstickers(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.recentStickers) -} - -// optional .proto.WebFeatures.Flag catalog = 27; -inline bool WebFeatures::_internal_has_catalog() const { - bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0; - return value; -} -inline bool WebFeatures::has_catalog() const { - return _internal_has_catalog(); -} -inline void WebFeatures::clear_catalog() { - _impl_.catalog_ = 0; - _impl_._has_bits_[0] &= ~0x01000000u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_catalog() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.catalog_); -} -inline ::proto::WebFeatures_Flag WebFeatures::catalog() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.catalog) - return _internal_catalog(); -} -inline void WebFeatures::_internal_set_catalog(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x01000000u; - _impl_.catalog_ = value; -} -inline void WebFeatures::set_catalog(::proto::WebFeatures_Flag value) { - _internal_set_catalog(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.catalog) -} - -// optional .proto.WebFeatures.Flag starredStickers = 28; -inline bool WebFeatures::_internal_has_starredstickers() const { - bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0; - return value; -} -inline bool WebFeatures::has_starredstickers() const { - return _internal_has_starredstickers(); -} -inline void WebFeatures::clear_starredstickers() { - _impl_.starredstickers_ = 0; - _impl_._has_bits_[0] &= ~0x02000000u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_starredstickers() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.starredstickers_); -} -inline ::proto::WebFeatures_Flag WebFeatures::starredstickers() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.starredStickers) - return _internal_starredstickers(); -} -inline void WebFeatures::_internal_set_starredstickers(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x02000000u; - _impl_.starredstickers_ = value; -} -inline void WebFeatures::set_starredstickers(::proto::WebFeatures_Flag value) { - _internal_set_starredstickers(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.starredStickers) -} - -// optional .proto.WebFeatures.Flag voipGroupCall = 29; -inline bool WebFeatures::_internal_has_voipgroupcall() const { - bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0; - return value; -} -inline bool WebFeatures::has_voipgroupcall() const { - return _internal_has_voipgroupcall(); -} -inline void WebFeatures::clear_voipgroupcall() { - _impl_.voipgroupcall_ = 0; - _impl_._has_bits_[0] &= ~0x04000000u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_voipgroupcall() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.voipgroupcall_); -} -inline ::proto::WebFeatures_Flag WebFeatures::voipgroupcall() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.voipGroupCall) - return _internal_voipgroupcall(); -} -inline void WebFeatures::_internal_set_voipgroupcall(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x04000000u; - _impl_.voipgroupcall_ = value; -} -inline void WebFeatures::set_voipgroupcall(::proto::WebFeatures_Flag value) { - _internal_set_voipgroupcall(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.voipGroupCall) -} - -// optional .proto.WebFeatures.Flag templateMessage = 30; -inline bool WebFeatures::_internal_has_templatemessage() const { - bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0; - return value; -} -inline bool WebFeatures::has_templatemessage() const { - return _internal_has_templatemessage(); -} -inline void WebFeatures::clear_templatemessage() { - _impl_.templatemessage_ = 0; - _impl_._has_bits_[0] &= ~0x08000000u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_templatemessage() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.templatemessage_); -} -inline ::proto::WebFeatures_Flag WebFeatures::templatemessage() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.templateMessage) - return _internal_templatemessage(); -} -inline void WebFeatures::_internal_set_templatemessage(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x08000000u; - _impl_.templatemessage_ = value; -} -inline void WebFeatures::set_templatemessage(::proto::WebFeatures_Flag value) { - _internal_set_templatemessage(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.templateMessage) -} - -// optional .proto.WebFeatures.Flag templateMessageInteractivity = 31; -inline bool WebFeatures::_internal_has_templatemessageinteractivity() const { - bool value = (_impl_._has_bits_[0] & 0x10000000u) != 0; - return value; -} -inline bool WebFeatures::has_templatemessageinteractivity() const { - return _internal_has_templatemessageinteractivity(); -} -inline void WebFeatures::clear_templatemessageinteractivity() { - _impl_.templatemessageinteractivity_ = 0; - _impl_._has_bits_[0] &= ~0x10000000u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_templatemessageinteractivity() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.templatemessageinteractivity_); -} -inline ::proto::WebFeatures_Flag WebFeatures::templatemessageinteractivity() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.templateMessageInteractivity) - return _internal_templatemessageinteractivity(); -} -inline void WebFeatures::_internal_set_templatemessageinteractivity(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x10000000u; - _impl_.templatemessageinteractivity_ = value; -} -inline void WebFeatures::set_templatemessageinteractivity(::proto::WebFeatures_Flag value) { - _internal_set_templatemessageinteractivity(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.templateMessageInteractivity) -} - -// optional .proto.WebFeatures.Flag ephemeralMessages = 32; -inline bool WebFeatures::_internal_has_ephemeralmessages() const { - bool value = (_impl_._has_bits_[0] & 0x20000000u) != 0; - return value; -} -inline bool WebFeatures::has_ephemeralmessages() const { - return _internal_has_ephemeralmessages(); -} -inline void WebFeatures::clear_ephemeralmessages() { - _impl_.ephemeralmessages_ = 0; - _impl_._has_bits_[0] &= ~0x20000000u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_ephemeralmessages() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.ephemeralmessages_); -} -inline ::proto::WebFeatures_Flag WebFeatures::ephemeralmessages() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.ephemeralMessages) - return _internal_ephemeralmessages(); -} -inline void WebFeatures::_internal_set_ephemeralmessages(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x20000000u; - _impl_.ephemeralmessages_ = value; -} -inline void WebFeatures::set_ephemeralmessages(::proto::WebFeatures_Flag value) { - _internal_set_ephemeralmessages(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.ephemeralMessages) -} - -// optional .proto.WebFeatures.Flag e2ENotificationSync = 33; -inline bool WebFeatures::_internal_has_e2enotificationsync() const { - bool value = (_impl_._has_bits_[0] & 0x40000000u) != 0; - return value; -} -inline bool WebFeatures::has_e2enotificationsync() const { - return _internal_has_e2enotificationsync(); -} -inline void WebFeatures::clear_e2enotificationsync() { - _impl_.e2enotificationsync_ = 0; - _impl_._has_bits_[0] &= ~0x40000000u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_e2enotificationsync() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.e2enotificationsync_); -} -inline ::proto::WebFeatures_Flag WebFeatures::e2enotificationsync() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.e2ENotificationSync) - return _internal_e2enotificationsync(); -} -inline void WebFeatures::_internal_set_e2enotificationsync(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x40000000u; - _impl_.e2enotificationsync_ = value; -} -inline void WebFeatures::set_e2enotificationsync(::proto::WebFeatures_Flag value) { - _internal_set_e2enotificationsync(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.e2ENotificationSync) -} - -// optional .proto.WebFeatures.Flag recentStickersV2 = 34; -inline bool WebFeatures::_internal_has_recentstickersv2() const { - bool value = (_impl_._has_bits_[0] & 0x80000000u) != 0; - return value; -} -inline bool WebFeatures::has_recentstickersv2() const { - return _internal_has_recentstickersv2(); -} -inline void WebFeatures::clear_recentstickersv2() { - _impl_.recentstickersv2_ = 0; - _impl_._has_bits_[0] &= ~0x80000000u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_recentstickersv2() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.recentstickersv2_); -} -inline ::proto::WebFeatures_Flag WebFeatures::recentstickersv2() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.recentStickersV2) - return _internal_recentstickersv2(); -} -inline void WebFeatures::_internal_set_recentstickersv2(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[0] |= 0x80000000u; - _impl_.recentstickersv2_ = value; -} -inline void WebFeatures::set_recentstickersv2(::proto::WebFeatures_Flag value) { - _internal_set_recentstickersv2(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.recentStickersV2) -} - -// optional .proto.WebFeatures.Flag recentStickersV3 = 36; -inline bool WebFeatures::_internal_has_recentstickersv3() const { - bool value = (_impl_._has_bits_[1] & 0x00000001u) != 0; - return value; -} -inline bool WebFeatures::has_recentstickersv3() const { - return _internal_has_recentstickersv3(); -} -inline void WebFeatures::clear_recentstickersv3() { - _impl_.recentstickersv3_ = 0; - _impl_._has_bits_[1] &= ~0x00000001u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_recentstickersv3() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.recentstickersv3_); -} -inline ::proto::WebFeatures_Flag WebFeatures::recentstickersv3() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.recentStickersV3) - return _internal_recentstickersv3(); -} -inline void WebFeatures::_internal_set_recentstickersv3(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[1] |= 0x00000001u; - _impl_.recentstickersv3_ = value; -} -inline void WebFeatures::set_recentstickersv3(::proto::WebFeatures_Flag value) { - _internal_set_recentstickersv3(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.recentStickersV3) -} - -// optional .proto.WebFeatures.Flag userNotice = 37; -inline bool WebFeatures::_internal_has_usernotice() const { - bool value = (_impl_._has_bits_[1] & 0x00000002u) != 0; - return value; -} -inline bool WebFeatures::has_usernotice() const { - return _internal_has_usernotice(); -} -inline void WebFeatures::clear_usernotice() { - _impl_.usernotice_ = 0; - _impl_._has_bits_[1] &= ~0x00000002u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_usernotice() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.usernotice_); -} -inline ::proto::WebFeatures_Flag WebFeatures::usernotice() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.userNotice) - return _internal_usernotice(); -} -inline void WebFeatures::_internal_set_usernotice(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[1] |= 0x00000002u; - _impl_.usernotice_ = value; -} -inline void WebFeatures::set_usernotice(::proto::WebFeatures_Flag value) { - _internal_set_usernotice(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.userNotice) -} - -// optional .proto.WebFeatures.Flag support = 39; -inline bool WebFeatures::_internal_has_support() const { - bool value = (_impl_._has_bits_[1] & 0x00000004u) != 0; - return value; -} -inline bool WebFeatures::has_support() const { - return _internal_has_support(); -} -inline void WebFeatures::clear_support() { - _impl_.support_ = 0; - _impl_._has_bits_[1] &= ~0x00000004u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_support() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.support_); -} -inline ::proto::WebFeatures_Flag WebFeatures::support() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.support) - return _internal_support(); -} -inline void WebFeatures::_internal_set_support(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[1] |= 0x00000004u; - _impl_.support_ = value; -} -inline void WebFeatures::set_support(::proto::WebFeatures_Flag value) { - _internal_set_support(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.support) -} - -// optional .proto.WebFeatures.Flag groupUiiCleanup = 40; -inline bool WebFeatures::_internal_has_groupuiicleanup() const { - bool value = (_impl_._has_bits_[1] & 0x00000008u) != 0; - return value; -} -inline bool WebFeatures::has_groupuiicleanup() const { - return _internal_has_groupuiicleanup(); -} -inline void WebFeatures::clear_groupuiicleanup() { - _impl_.groupuiicleanup_ = 0; - _impl_._has_bits_[1] &= ~0x00000008u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_groupuiicleanup() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.groupuiicleanup_); -} -inline ::proto::WebFeatures_Flag WebFeatures::groupuiicleanup() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.groupUiiCleanup) - return _internal_groupuiicleanup(); -} -inline void WebFeatures::_internal_set_groupuiicleanup(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[1] |= 0x00000008u; - _impl_.groupuiicleanup_ = value; -} -inline void WebFeatures::set_groupuiicleanup(::proto::WebFeatures_Flag value) { - _internal_set_groupuiicleanup(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.groupUiiCleanup) -} - -// optional .proto.WebFeatures.Flag groupDogfoodingInternalOnly = 41; -inline bool WebFeatures::_internal_has_groupdogfoodinginternalonly() const { - bool value = (_impl_._has_bits_[1] & 0x00000010u) != 0; - return value; -} -inline bool WebFeatures::has_groupdogfoodinginternalonly() const { - return _internal_has_groupdogfoodinginternalonly(); -} -inline void WebFeatures::clear_groupdogfoodinginternalonly() { - _impl_.groupdogfoodinginternalonly_ = 0; - _impl_._has_bits_[1] &= ~0x00000010u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_groupdogfoodinginternalonly() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.groupdogfoodinginternalonly_); -} -inline ::proto::WebFeatures_Flag WebFeatures::groupdogfoodinginternalonly() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.groupDogfoodingInternalOnly) - return _internal_groupdogfoodinginternalonly(); -} -inline void WebFeatures::_internal_set_groupdogfoodinginternalonly(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[1] |= 0x00000010u; - _impl_.groupdogfoodinginternalonly_ = value; -} -inline void WebFeatures::set_groupdogfoodinginternalonly(::proto::WebFeatures_Flag value) { - _internal_set_groupdogfoodinginternalonly(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.groupDogfoodingInternalOnly) -} - -// optional .proto.WebFeatures.Flag settingsSync = 42; -inline bool WebFeatures::_internal_has_settingssync() const { - bool value = (_impl_._has_bits_[1] & 0x00000020u) != 0; - return value; -} -inline bool WebFeatures::has_settingssync() const { - return _internal_has_settingssync(); -} -inline void WebFeatures::clear_settingssync() { - _impl_.settingssync_ = 0; - _impl_._has_bits_[1] &= ~0x00000020u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_settingssync() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.settingssync_); -} -inline ::proto::WebFeatures_Flag WebFeatures::settingssync() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.settingsSync) - return _internal_settingssync(); -} -inline void WebFeatures::_internal_set_settingssync(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[1] |= 0x00000020u; - _impl_.settingssync_ = value; -} -inline void WebFeatures::set_settingssync(::proto::WebFeatures_Flag value) { - _internal_set_settingssync(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.settingsSync) -} - -// optional .proto.WebFeatures.Flag archiveV2 = 43; -inline bool WebFeatures::_internal_has_archivev2() const { - bool value = (_impl_._has_bits_[1] & 0x00000040u) != 0; - return value; -} -inline bool WebFeatures::has_archivev2() const { - return _internal_has_archivev2(); -} -inline void WebFeatures::clear_archivev2() { - _impl_.archivev2_ = 0; - _impl_._has_bits_[1] &= ~0x00000040u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_archivev2() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.archivev2_); -} -inline ::proto::WebFeatures_Flag WebFeatures::archivev2() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.archiveV2) - return _internal_archivev2(); -} -inline void WebFeatures::_internal_set_archivev2(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[1] |= 0x00000040u; - _impl_.archivev2_ = value; -} -inline void WebFeatures::set_archivev2(::proto::WebFeatures_Flag value) { - _internal_set_archivev2(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.archiveV2) -} - -// optional .proto.WebFeatures.Flag ephemeralAllowGroupMembers = 44; -inline bool WebFeatures::_internal_has_ephemeralallowgroupmembers() const { - bool value = (_impl_._has_bits_[1] & 0x00000080u) != 0; - return value; -} -inline bool WebFeatures::has_ephemeralallowgroupmembers() const { - return _internal_has_ephemeralallowgroupmembers(); -} -inline void WebFeatures::clear_ephemeralallowgroupmembers() { - _impl_.ephemeralallowgroupmembers_ = 0; - _impl_._has_bits_[1] &= ~0x00000080u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_ephemeralallowgroupmembers() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.ephemeralallowgroupmembers_); -} -inline ::proto::WebFeatures_Flag WebFeatures::ephemeralallowgroupmembers() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.ephemeralAllowGroupMembers) - return _internal_ephemeralallowgroupmembers(); -} -inline void WebFeatures::_internal_set_ephemeralallowgroupmembers(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[1] |= 0x00000080u; - _impl_.ephemeralallowgroupmembers_ = value; -} -inline void WebFeatures::set_ephemeralallowgroupmembers(::proto::WebFeatures_Flag value) { - _internal_set_ephemeralallowgroupmembers(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.ephemeralAllowGroupMembers) -} - -// optional .proto.WebFeatures.Flag ephemeral24HDuration = 45; -inline bool WebFeatures::_internal_has_ephemeral24hduration() const { - bool value = (_impl_._has_bits_[1] & 0x00000100u) != 0; - return value; -} -inline bool WebFeatures::has_ephemeral24hduration() const { - return _internal_has_ephemeral24hduration(); -} -inline void WebFeatures::clear_ephemeral24hduration() { - _impl_.ephemeral24hduration_ = 0; - _impl_._has_bits_[1] &= ~0x00000100u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_ephemeral24hduration() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.ephemeral24hduration_); -} -inline ::proto::WebFeatures_Flag WebFeatures::ephemeral24hduration() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.ephemeral24HDuration) - return _internal_ephemeral24hduration(); -} -inline void WebFeatures::_internal_set_ephemeral24hduration(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[1] |= 0x00000100u; - _impl_.ephemeral24hduration_ = value; -} -inline void WebFeatures::set_ephemeral24hduration(::proto::WebFeatures_Flag value) { - _internal_set_ephemeral24hduration(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.ephemeral24HDuration) -} - -// optional .proto.WebFeatures.Flag mdForceUpgrade = 46; -inline bool WebFeatures::_internal_has_mdforceupgrade() const { - bool value = (_impl_._has_bits_[1] & 0x00000200u) != 0; - return value; -} -inline bool WebFeatures::has_mdforceupgrade() const { - return _internal_has_mdforceupgrade(); -} -inline void WebFeatures::clear_mdforceupgrade() { - _impl_.mdforceupgrade_ = 0; - _impl_._has_bits_[1] &= ~0x00000200u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_mdforceupgrade() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.mdforceupgrade_); -} -inline ::proto::WebFeatures_Flag WebFeatures::mdforceupgrade() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.mdForceUpgrade) - return _internal_mdforceupgrade(); -} -inline void WebFeatures::_internal_set_mdforceupgrade(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[1] |= 0x00000200u; - _impl_.mdforceupgrade_ = value; -} -inline void WebFeatures::set_mdforceupgrade(::proto::WebFeatures_Flag value) { - _internal_set_mdforceupgrade(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.mdForceUpgrade) -} - -// optional .proto.WebFeatures.Flag disappearingMode = 47; -inline bool WebFeatures::_internal_has_disappearingmode() const { - bool value = (_impl_._has_bits_[1] & 0x00000400u) != 0; - return value; -} -inline bool WebFeatures::has_disappearingmode() const { - return _internal_has_disappearingmode(); -} -inline void WebFeatures::clear_disappearingmode() { - _impl_.disappearingmode_ = 0; - _impl_._has_bits_[1] &= ~0x00000400u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_disappearingmode() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.disappearingmode_); -} -inline ::proto::WebFeatures_Flag WebFeatures::disappearingmode() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.disappearingMode) - return _internal_disappearingmode(); -} -inline void WebFeatures::_internal_set_disappearingmode(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[1] |= 0x00000400u; - _impl_.disappearingmode_ = value; -} -inline void WebFeatures::set_disappearingmode(::proto::WebFeatures_Flag value) { - _internal_set_disappearingmode(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.disappearingMode) -} - -// optional .proto.WebFeatures.Flag externalMdOptInAvailable = 48; -inline bool WebFeatures::_internal_has_externalmdoptinavailable() const { - bool value = (_impl_._has_bits_[1] & 0x00000800u) != 0; - return value; -} -inline bool WebFeatures::has_externalmdoptinavailable() const { - return _internal_has_externalmdoptinavailable(); -} -inline void WebFeatures::clear_externalmdoptinavailable() { - _impl_.externalmdoptinavailable_ = 0; - _impl_._has_bits_[1] &= ~0x00000800u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_externalmdoptinavailable() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.externalmdoptinavailable_); -} -inline ::proto::WebFeatures_Flag WebFeatures::externalmdoptinavailable() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.externalMdOptInAvailable) - return _internal_externalmdoptinavailable(); -} -inline void WebFeatures::_internal_set_externalmdoptinavailable(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[1] |= 0x00000800u; - _impl_.externalmdoptinavailable_ = value; -} -inline void WebFeatures::set_externalmdoptinavailable(::proto::WebFeatures_Flag value) { - _internal_set_externalmdoptinavailable(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.externalMdOptInAvailable) -} - -// optional .proto.WebFeatures.Flag noDeleteMessageTimeLimit = 49; -inline bool WebFeatures::_internal_has_nodeletemessagetimelimit() const { - bool value = (_impl_._has_bits_[1] & 0x00001000u) != 0; - return value; -} -inline bool WebFeatures::has_nodeletemessagetimelimit() const { - return _internal_has_nodeletemessagetimelimit(); -} -inline void WebFeatures::clear_nodeletemessagetimelimit() { - _impl_.nodeletemessagetimelimit_ = 0; - _impl_._has_bits_[1] &= ~0x00001000u; -} -inline ::proto::WebFeatures_Flag WebFeatures::_internal_nodeletemessagetimelimit() const { - return static_cast< ::proto::WebFeatures_Flag >(_impl_.nodeletemessagetimelimit_); -} -inline ::proto::WebFeatures_Flag WebFeatures::nodeletemessagetimelimit() const { - // @@protoc_insertion_point(field_get:proto.WebFeatures.noDeleteMessageTimeLimit) - return _internal_nodeletemessagetimelimit(); -} -inline void WebFeatures::_internal_set_nodeletemessagetimelimit(::proto::WebFeatures_Flag value) { - assert(::proto::WebFeatures_Flag_IsValid(value)); - _impl_._has_bits_[1] |= 0x00001000u; - _impl_.nodeletemessagetimelimit_ = value; -} -inline void WebFeatures::set_nodeletemessagetimelimit(::proto::WebFeatures_Flag value) { - _internal_set_nodeletemessagetimelimit(value); - // @@protoc_insertion_point(field_set:proto.WebFeatures.noDeleteMessageTimeLimit) -} - -// ------------------------------------------------------------------- - -// WebMessageInfo - -// required .proto.MessageKey key = 1; -inline bool WebMessageInfo::_internal_has_key() const { - bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0; - PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr); - return value; -} -inline bool WebMessageInfo::has_key() const { - return _internal_has_key(); -} -inline void WebMessageInfo::clear_key() { - if (_impl_.key_ != nullptr) _impl_.key_->Clear(); - _impl_._has_bits_[0] &= ~0x00000100u; -} -inline const ::proto::MessageKey& WebMessageInfo::_internal_key() const { - const ::proto::MessageKey* p = _impl_.key_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_MessageKey_default_instance_); -} -inline const ::proto::MessageKey& WebMessageInfo::key() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.key) - return _internal_key(); -} -inline void WebMessageInfo::unsafe_arena_set_allocated_key( - ::proto::MessageKey* key) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_); - } - _impl_.key_ = key; - if (key) { - _impl_._has_bits_[0] |= 0x00000100u; - } else { - _impl_._has_bits_[0] &= ~0x00000100u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.key) -} -inline ::proto::MessageKey* WebMessageInfo::release_key() { - _impl_._has_bits_[0] &= ~0x00000100u; - ::proto::MessageKey* temp = _impl_.key_; - _impl_.key_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::MessageKey* WebMessageInfo::unsafe_arena_release_key() { - // @@protoc_insertion_point(field_release:proto.WebMessageInfo.key) - _impl_._has_bits_[0] &= ~0x00000100u; - ::proto::MessageKey* temp = _impl_.key_; - _impl_.key_ = nullptr; - return temp; -} -inline ::proto::MessageKey* WebMessageInfo::_internal_mutable_key() { - _impl_._has_bits_[0] |= 0x00000100u; - if (_impl_.key_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation()); - _impl_.key_ = p; - } - return _impl_.key_; -} -inline ::proto::MessageKey* WebMessageInfo::mutable_key() { - ::proto::MessageKey* _msg = _internal_mutable_key(); - // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.key) - return _msg; -} -inline void WebMessageInfo::set_allocated_key(::proto::MessageKey* key) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.key_; - } - if (key) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key); - if (message_arena != submessage_arena) { - key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, key, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000100u; - } else { - _impl_._has_bits_[0] &= ~0x00000100u; - } - _impl_.key_ = key; - // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.key) -} - -// optional .proto.Message message = 2; -inline bool WebMessageInfo::_internal_has_message() const { - bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0; - PROTOBUF_ASSUME(!value || _impl_.message_ != nullptr); - return value; -} -inline bool WebMessageInfo::has_message() const { - return _internal_has_message(); -} -inline void WebMessageInfo::clear_message() { - if (_impl_.message_ != nullptr) _impl_.message_->Clear(); - _impl_._has_bits_[0] &= ~0x00000200u; -} -inline const ::proto::Message& WebMessageInfo::_internal_message() const { - const ::proto::Message* p = _impl_.message_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_default_instance_); -} -inline const ::proto::Message& WebMessageInfo::message() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.message) - return _internal_message(); -} -inline void WebMessageInfo::unsafe_arena_set_allocated_message( - ::proto::Message* message) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.message_); - } - _impl_.message_ = message; - if (message) { - _impl_._has_bits_[0] |= 0x00000200u; - } else { - _impl_._has_bits_[0] &= ~0x00000200u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.message) -} -inline ::proto::Message* WebMessageInfo::release_message() { - _impl_._has_bits_[0] &= ~0x00000200u; - ::proto::Message* temp = _impl_.message_; - _impl_.message_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message* WebMessageInfo::unsafe_arena_release_message() { - // @@protoc_insertion_point(field_release:proto.WebMessageInfo.message) - _impl_._has_bits_[0] &= ~0x00000200u; - ::proto::Message* temp = _impl_.message_; - _impl_.message_ = nullptr; - return temp; -} -inline ::proto::Message* WebMessageInfo::_internal_mutable_message() { - _impl_._has_bits_[0] |= 0x00000200u; - if (_impl_.message_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message>(GetArenaForAllocation()); - _impl_.message_ = p; - } - return _impl_.message_; -} -inline ::proto::Message* WebMessageInfo::mutable_message() { - ::proto::Message* _msg = _internal_mutable_message(); - // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.message) - return _msg; -} -inline void WebMessageInfo::set_allocated_message(::proto::Message* message) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.message_; - } - if (message) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(message); - if (message_arena != submessage_arena) { - message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, message, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000200u; - } else { - _impl_._has_bits_[0] &= ~0x00000200u; - } - _impl_.message_ = message; - // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.message) -} - -// optional uint64 messageTimestamp = 3; -inline bool WebMessageInfo::_internal_has_messagetimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0; - return value; -} -inline bool WebMessageInfo::has_messagetimestamp() const { - return _internal_has_messagetimestamp(); -} -inline void WebMessageInfo::clear_messagetimestamp() { - _impl_.messagetimestamp_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00080000u; -} -inline uint64_t WebMessageInfo::_internal_messagetimestamp() const { - return _impl_.messagetimestamp_; -} -inline uint64_t WebMessageInfo::messagetimestamp() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.messageTimestamp) - return _internal_messagetimestamp(); -} -inline void WebMessageInfo::_internal_set_messagetimestamp(uint64_t value) { - _impl_._has_bits_[0] |= 0x00080000u; - _impl_.messagetimestamp_ = value; -} -inline void WebMessageInfo::set_messagetimestamp(uint64_t value) { - _internal_set_messagetimestamp(value); - // @@protoc_insertion_point(field_set:proto.WebMessageInfo.messageTimestamp) -} - -// optional .proto.WebMessageInfo.Status status = 4; -inline bool WebMessageInfo::_internal_has_status() const { - bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0; - return value; -} -inline bool WebMessageInfo::has_status() const { - return _internal_has_status(); -} -inline void WebMessageInfo::clear_status() { - _impl_.status_ = 0; - _impl_._has_bits_[0] &= ~0x00200000u; -} -inline ::proto::WebMessageInfo_Status WebMessageInfo::_internal_status() const { - return static_cast< ::proto::WebMessageInfo_Status >(_impl_.status_); -} -inline ::proto::WebMessageInfo_Status WebMessageInfo::status() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.status) - return _internal_status(); -} -inline void WebMessageInfo::_internal_set_status(::proto::WebMessageInfo_Status value) { - assert(::proto::WebMessageInfo_Status_IsValid(value)); - _impl_._has_bits_[0] |= 0x00200000u; - _impl_.status_ = value; -} -inline void WebMessageInfo::set_status(::proto::WebMessageInfo_Status value) { - _internal_set_status(value); - // @@protoc_insertion_point(field_set:proto.WebMessageInfo.status) -} - -// optional string participant = 5; -inline bool WebMessageInfo::_internal_has_participant() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool WebMessageInfo::has_participant() const { - return _internal_has_participant(); -} -inline void WebMessageInfo::clear_participant() { - _impl_.participant_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline const std::string& WebMessageInfo::participant() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.participant) - return _internal_participant(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void WebMessageInfo::set_participant(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.participant_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.WebMessageInfo.participant) -} -inline std::string* WebMessageInfo::mutable_participant() { - std::string* _s = _internal_mutable_participant(); - // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.participant) - return _s; -} -inline const std::string& WebMessageInfo::_internal_participant() const { - return _impl_.participant_.Get(); -} -inline void WebMessageInfo::_internal_set_participant(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.participant_.Set(value, GetArenaForAllocation()); -} -inline std::string* WebMessageInfo::_internal_mutable_participant() { - _impl_._has_bits_[0] |= 0x00000001u; - return _impl_.participant_.Mutable(GetArenaForAllocation()); -} -inline std::string* WebMessageInfo::release_participant() { - // @@protoc_insertion_point(field_release:proto.WebMessageInfo.participant) - if (!_internal_has_participant()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000001u; - auto* p = _impl_.participant_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.participant_.IsDefault()) { - _impl_.participant_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void WebMessageInfo::set_allocated_participant(std::string* participant) { - if (participant != nullptr) { - _impl_._has_bits_[0] |= 0x00000001u; - } else { - _impl_._has_bits_[0] &= ~0x00000001u; - } - _impl_.participant_.SetAllocated(participant, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.participant_.IsDefault()) { - _impl_.participant_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.participant) -} - -// optional uint64 messageC2STimestamp = 6; -inline bool WebMessageInfo::_internal_has_messagec2stimestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0; - return value; -} -inline bool WebMessageInfo::has_messagec2stimestamp() const { - return _internal_has_messagec2stimestamp(); -} -inline void WebMessageInfo::clear_messagec2stimestamp() { - _impl_.messagec2stimestamp_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00100000u; -} -inline uint64_t WebMessageInfo::_internal_messagec2stimestamp() const { - return _impl_.messagec2stimestamp_; -} -inline uint64_t WebMessageInfo::messagec2stimestamp() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.messageC2STimestamp) - return _internal_messagec2stimestamp(); -} -inline void WebMessageInfo::_internal_set_messagec2stimestamp(uint64_t value) { - _impl_._has_bits_[0] |= 0x00100000u; - _impl_.messagec2stimestamp_ = value; -} -inline void WebMessageInfo::set_messagec2stimestamp(uint64_t value) { - _internal_set_messagec2stimestamp(value); - // @@protoc_insertion_point(field_set:proto.WebMessageInfo.messageC2STimestamp) -} - -// optional bool ignore = 16; -inline bool WebMessageInfo::_internal_has_ignore() const { - bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0; - return value; -} -inline bool WebMessageInfo::has_ignore() const { - return _internal_has_ignore(); -} -inline void WebMessageInfo::clear_ignore() { - _impl_.ignore_ = false; - _impl_._has_bits_[0] &= ~0x00400000u; -} -inline bool WebMessageInfo::_internal_ignore() const { - return _impl_.ignore_; -} -inline bool WebMessageInfo::ignore() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.ignore) - return _internal_ignore(); -} -inline void WebMessageInfo::_internal_set_ignore(bool value) { - _impl_._has_bits_[0] |= 0x00400000u; - _impl_.ignore_ = value; -} -inline void WebMessageInfo::set_ignore(bool value) { - _internal_set_ignore(value); - // @@protoc_insertion_point(field_set:proto.WebMessageInfo.ignore) -} - -// optional bool starred = 17; -inline bool WebMessageInfo::_internal_has_starred() const { - bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0; - return value; -} -inline bool WebMessageInfo::has_starred() const { - return _internal_has_starred(); -} -inline void WebMessageInfo::clear_starred() { - _impl_.starred_ = false; - _impl_._has_bits_[0] &= ~0x00800000u; -} -inline bool WebMessageInfo::_internal_starred() const { - return _impl_.starred_; -} -inline bool WebMessageInfo::starred() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.starred) - return _internal_starred(); -} -inline void WebMessageInfo::_internal_set_starred(bool value) { - _impl_._has_bits_[0] |= 0x00800000u; - _impl_.starred_ = value; -} -inline void WebMessageInfo::set_starred(bool value) { - _internal_set_starred(value); - // @@protoc_insertion_point(field_set:proto.WebMessageInfo.starred) -} - -// optional bool broadcast = 18; -inline bool WebMessageInfo::_internal_has_broadcast() const { - bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0; - return value; -} -inline bool WebMessageInfo::has_broadcast() const { - return _internal_has_broadcast(); -} -inline void WebMessageInfo::clear_broadcast() { - _impl_.broadcast_ = false; - _impl_._has_bits_[0] &= ~0x01000000u; -} -inline bool WebMessageInfo::_internal_broadcast() const { - return _impl_.broadcast_; -} -inline bool WebMessageInfo::broadcast() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.broadcast) - return _internal_broadcast(); -} -inline void WebMessageInfo::_internal_set_broadcast(bool value) { - _impl_._has_bits_[0] |= 0x01000000u; - _impl_.broadcast_ = value; -} -inline void WebMessageInfo::set_broadcast(bool value) { - _internal_set_broadcast(value); - // @@protoc_insertion_point(field_set:proto.WebMessageInfo.broadcast) -} - -// optional string pushName = 19; -inline bool WebMessageInfo::_internal_has_pushname() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool WebMessageInfo::has_pushname() const { - return _internal_has_pushname(); -} -inline void WebMessageInfo::clear_pushname() { - _impl_.pushname_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline const std::string& WebMessageInfo::pushname() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.pushName) - return _internal_pushname(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void WebMessageInfo::set_pushname(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.pushname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.WebMessageInfo.pushName) -} -inline std::string* WebMessageInfo::mutable_pushname() { - std::string* _s = _internal_mutable_pushname(); - // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.pushName) - return _s; -} -inline const std::string& WebMessageInfo::_internal_pushname() const { - return _impl_.pushname_.Get(); -} -inline void WebMessageInfo::_internal_set_pushname(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.pushname_.Set(value, GetArenaForAllocation()); -} -inline std::string* WebMessageInfo::_internal_mutable_pushname() { - _impl_._has_bits_[0] |= 0x00000002u; - return _impl_.pushname_.Mutable(GetArenaForAllocation()); -} -inline std::string* WebMessageInfo::release_pushname() { - // @@protoc_insertion_point(field_release:proto.WebMessageInfo.pushName) - if (!_internal_has_pushname()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000002u; - auto* p = _impl_.pushname_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.pushname_.IsDefault()) { - _impl_.pushname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void WebMessageInfo::set_allocated_pushname(std::string* pushname) { - if (pushname != nullptr) { - _impl_._has_bits_[0] |= 0x00000002u; - } else { - _impl_._has_bits_[0] &= ~0x00000002u; - } - _impl_.pushname_.SetAllocated(pushname, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.pushname_.IsDefault()) { - _impl_.pushname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.pushName) -} - -// optional bytes mediaCiphertextSha256 = 20; -inline bool WebMessageInfo::_internal_has_mediaciphertextsha256() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool WebMessageInfo::has_mediaciphertextsha256() const { - return _internal_has_mediaciphertextsha256(); -} -inline void WebMessageInfo::clear_mediaciphertextsha256() { - _impl_.mediaciphertextsha256_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline const std::string& WebMessageInfo::mediaciphertextsha256() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.mediaCiphertextSha256) - return _internal_mediaciphertextsha256(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void WebMessageInfo::set_mediaciphertextsha256(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.mediaciphertextsha256_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.WebMessageInfo.mediaCiphertextSha256) -} -inline std::string* WebMessageInfo::mutable_mediaciphertextsha256() { - std::string* _s = _internal_mutable_mediaciphertextsha256(); - // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.mediaCiphertextSha256) - return _s; -} -inline const std::string& WebMessageInfo::_internal_mediaciphertextsha256() const { - return _impl_.mediaciphertextsha256_.Get(); -} -inline void WebMessageInfo::_internal_set_mediaciphertextsha256(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.mediaciphertextsha256_.Set(value, GetArenaForAllocation()); -} -inline std::string* WebMessageInfo::_internal_mutable_mediaciphertextsha256() { - _impl_._has_bits_[0] |= 0x00000004u; - return _impl_.mediaciphertextsha256_.Mutable(GetArenaForAllocation()); -} -inline std::string* WebMessageInfo::release_mediaciphertextsha256() { - // @@protoc_insertion_point(field_release:proto.WebMessageInfo.mediaCiphertextSha256) - if (!_internal_has_mediaciphertextsha256()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000004u; - auto* p = _impl_.mediaciphertextsha256_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mediaciphertextsha256_.IsDefault()) { - _impl_.mediaciphertextsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void WebMessageInfo::set_allocated_mediaciphertextsha256(std::string* mediaciphertextsha256) { - if (mediaciphertextsha256 != nullptr) { - _impl_._has_bits_[0] |= 0x00000004u; - } else { - _impl_._has_bits_[0] &= ~0x00000004u; - } - _impl_.mediaciphertextsha256_.SetAllocated(mediaciphertextsha256, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.mediaciphertextsha256_.IsDefault()) { - _impl_.mediaciphertextsha256_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.mediaCiphertextSha256) -} - -// optional bool multicast = 21; -inline bool WebMessageInfo::_internal_has_multicast() const { - bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0; - return value; -} -inline bool WebMessageInfo::has_multicast() const { - return _internal_has_multicast(); -} -inline void WebMessageInfo::clear_multicast() { - _impl_.multicast_ = false; - _impl_._has_bits_[0] &= ~0x02000000u; -} -inline bool WebMessageInfo::_internal_multicast() const { - return _impl_.multicast_; -} -inline bool WebMessageInfo::multicast() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.multicast) - return _internal_multicast(); -} -inline void WebMessageInfo::_internal_set_multicast(bool value) { - _impl_._has_bits_[0] |= 0x02000000u; - _impl_.multicast_ = value; -} -inline void WebMessageInfo::set_multicast(bool value) { - _internal_set_multicast(value); - // @@protoc_insertion_point(field_set:proto.WebMessageInfo.multicast) -} - -// optional bool urlText = 22; -inline bool WebMessageInfo::_internal_has_urltext() const { - bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0; - return value; -} -inline bool WebMessageInfo::has_urltext() const { - return _internal_has_urltext(); -} -inline void WebMessageInfo::clear_urltext() { - _impl_.urltext_ = false; - _impl_._has_bits_[0] &= ~0x08000000u; -} -inline bool WebMessageInfo::_internal_urltext() const { - return _impl_.urltext_; -} -inline bool WebMessageInfo::urltext() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.urlText) - return _internal_urltext(); -} -inline void WebMessageInfo::_internal_set_urltext(bool value) { - _impl_._has_bits_[0] |= 0x08000000u; - _impl_.urltext_ = value; -} -inline void WebMessageInfo::set_urltext(bool value) { - _internal_set_urltext(value); - // @@protoc_insertion_point(field_set:proto.WebMessageInfo.urlText) -} - -// optional bool urlNumber = 23; -inline bool WebMessageInfo::_internal_has_urlnumber() const { - bool value = (_impl_._has_bits_[0] & 0x10000000u) != 0; - return value; -} -inline bool WebMessageInfo::has_urlnumber() const { - return _internal_has_urlnumber(); -} -inline void WebMessageInfo::clear_urlnumber() { - _impl_.urlnumber_ = false; - _impl_._has_bits_[0] &= ~0x10000000u; -} -inline bool WebMessageInfo::_internal_urlnumber() const { - return _impl_.urlnumber_; -} -inline bool WebMessageInfo::urlnumber() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.urlNumber) - return _internal_urlnumber(); -} -inline void WebMessageInfo::_internal_set_urlnumber(bool value) { - _impl_._has_bits_[0] |= 0x10000000u; - _impl_.urlnumber_ = value; -} -inline void WebMessageInfo::set_urlnumber(bool value) { - _internal_set_urlnumber(value); - // @@protoc_insertion_point(field_set:proto.WebMessageInfo.urlNumber) -} - -// optional .proto.WebMessageInfo.StubType messageStubType = 24; -inline bool WebMessageInfo::_internal_has_messagestubtype() const { - bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0; - return value; -} -inline bool WebMessageInfo::has_messagestubtype() const { - return _internal_has_messagestubtype(); -} -inline void WebMessageInfo::clear_messagestubtype() { - _impl_.messagestubtype_ = 0; - _impl_._has_bits_[0] &= ~0x04000000u; -} -inline ::proto::WebMessageInfo_StubType WebMessageInfo::_internal_messagestubtype() const { - return static_cast< ::proto::WebMessageInfo_StubType >(_impl_.messagestubtype_); -} -inline ::proto::WebMessageInfo_StubType WebMessageInfo::messagestubtype() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.messageStubType) - return _internal_messagestubtype(); -} -inline void WebMessageInfo::_internal_set_messagestubtype(::proto::WebMessageInfo_StubType value) { - assert(::proto::WebMessageInfo_StubType_IsValid(value)); - _impl_._has_bits_[0] |= 0x04000000u; - _impl_.messagestubtype_ = value; -} -inline void WebMessageInfo::set_messagestubtype(::proto::WebMessageInfo_StubType value) { - _internal_set_messagestubtype(value); - // @@protoc_insertion_point(field_set:proto.WebMessageInfo.messageStubType) -} - -// optional bool clearMedia = 25; -inline bool WebMessageInfo::_internal_has_clearmedia() const { - bool value = (_impl_._has_bits_[0] & 0x20000000u) != 0; - return value; -} -inline bool WebMessageInfo::has_clearmedia() const { - return _internal_has_clearmedia(); -} -inline void WebMessageInfo::clear_clearmedia() { - _impl_.clearmedia_ = false; - _impl_._has_bits_[0] &= ~0x20000000u; -} -inline bool WebMessageInfo::_internal_clearmedia() const { - return _impl_.clearmedia_; -} -inline bool WebMessageInfo::clearmedia() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.clearMedia) - return _internal_clearmedia(); -} -inline void WebMessageInfo::_internal_set_clearmedia(bool value) { - _impl_._has_bits_[0] |= 0x20000000u; - _impl_.clearmedia_ = value; -} -inline void WebMessageInfo::set_clearmedia(bool value) { - _internal_set_clearmedia(value); - // @@protoc_insertion_point(field_set:proto.WebMessageInfo.clearMedia) -} - -// repeated string messageStubParameters = 26; -inline int WebMessageInfo::_internal_messagestubparameters_size() const { - return _impl_.messagestubparameters_.size(); -} -inline int WebMessageInfo::messagestubparameters_size() const { - return _internal_messagestubparameters_size(); -} -inline void WebMessageInfo::clear_messagestubparameters() { - _impl_.messagestubparameters_.Clear(); -} -inline std::string* WebMessageInfo::add_messagestubparameters() { - std::string* _s = _internal_add_messagestubparameters(); - // @@protoc_insertion_point(field_add_mutable:proto.WebMessageInfo.messageStubParameters) - return _s; -} -inline const std::string& WebMessageInfo::_internal_messagestubparameters(int index) const { - return _impl_.messagestubparameters_.Get(index); -} -inline const std::string& WebMessageInfo::messagestubparameters(int index) const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.messageStubParameters) - return _internal_messagestubparameters(index); -} -inline std::string* WebMessageInfo::mutable_messagestubparameters(int index) { - // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.messageStubParameters) - return _impl_.messagestubparameters_.Mutable(index); -} -inline void WebMessageInfo::set_messagestubparameters(int index, const std::string& value) { - _impl_.messagestubparameters_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:proto.WebMessageInfo.messageStubParameters) -} -inline void WebMessageInfo::set_messagestubparameters(int index, std::string&& value) { - _impl_.messagestubparameters_.Mutable(index)->assign(std::move(value)); - // @@protoc_insertion_point(field_set:proto.WebMessageInfo.messageStubParameters) -} -inline void WebMessageInfo::set_messagestubparameters(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - _impl_.messagestubparameters_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:proto.WebMessageInfo.messageStubParameters) -} -inline void WebMessageInfo::set_messagestubparameters(int index, const char* value, size_t size) { - _impl_.messagestubparameters_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:proto.WebMessageInfo.messageStubParameters) -} -inline std::string* WebMessageInfo::_internal_add_messagestubparameters() { - return _impl_.messagestubparameters_.Add(); -} -inline void WebMessageInfo::add_messagestubparameters(const std::string& value) { - _impl_.messagestubparameters_.Add()->assign(value); - // @@protoc_insertion_point(field_add:proto.WebMessageInfo.messageStubParameters) -} -inline void WebMessageInfo::add_messagestubparameters(std::string&& value) { - _impl_.messagestubparameters_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:proto.WebMessageInfo.messageStubParameters) -} -inline void WebMessageInfo::add_messagestubparameters(const char* value) { - GOOGLE_DCHECK(value != nullptr); - _impl_.messagestubparameters_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:proto.WebMessageInfo.messageStubParameters) -} -inline void WebMessageInfo::add_messagestubparameters(const char* value, size_t size) { - _impl_.messagestubparameters_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:proto.WebMessageInfo.messageStubParameters) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -WebMessageInfo::messagestubparameters() const { - // @@protoc_insertion_point(field_list:proto.WebMessageInfo.messageStubParameters) - return _impl_.messagestubparameters_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -WebMessageInfo::mutable_messagestubparameters() { - // @@protoc_insertion_point(field_mutable_list:proto.WebMessageInfo.messageStubParameters) - return &_impl_.messagestubparameters_; -} - -// optional uint32 duration = 27; -inline bool WebMessageInfo::_internal_has_duration() const { - bool value = (_impl_._has_bits_[0] & 0x80000000u) != 0; - return value; -} -inline bool WebMessageInfo::has_duration() const { - return _internal_has_duration(); -} -inline void WebMessageInfo::clear_duration() { - _impl_.duration_ = 0u; - _impl_._has_bits_[0] &= ~0x80000000u; -} -inline uint32_t WebMessageInfo::_internal_duration() const { - return _impl_.duration_; -} -inline uint32_t WebMessageInfo::duration() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.duration) - return _internal_duration(); -} -inline void WebMessageInfo::_internal_set_duration(uint32_t value) { - _impl_._has_bits_[0] |= 0x80000000u; - _impl_.duration_ = value; -} -inline void WebMessageInfo::set_duration(uint32_t value) { - _internal_set_duration(value); - // @@protoc_insertion_point(field_set:proto.WebMessageInfo.duration) -} - -// repeated string labels = 28; -inline int WebMessageInfo::_internal_labels_size() const { - return _impl_.labels_.size(); -} -inline int WebMessageInfo::labels_size() const { - return _internal_labels_size(); -} -inline void WebMessageInfo::clear_labels() { - _impl_.labels_.Clear(); -} -inline std::string* WebMessageInfo::add_labels() { - std::string* _s = _internal_add_labels(); - // @@protoc_insertion_point(field_add_mutable:proto.WebMessageInfo.labels) - return _s; -} -inline const std::string& WebMessageInfo::_internal_labels(int index) const { - return _impl_.labels_.Get(index); -} -inline const std::string& WebMessageInfo::labels(int index) const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.labels) - return _internal_labels(index); -} -inline std::string* WebMessageInfo::mutable_labels(int index) { - // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.labels) - return _impl_.labels_.Mutable(index); -} -inline void WebMessageInfo::set_labels(int index, const std::string& value) { - _impl_.labels_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:proto.WebMessageInfo.labels) -} -inline void WebMessageInfo::set_labels(int index, std::string&& value) { - _impl_.labels_.Mutable(index)->assign(std::move(value)); - // @@protoc_insertion_point(field_set:proto.WebMessageInfo.labels) -} -inline void WebMessageInfo::set_labels(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - _impl_.labels_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:proto.WebMessageInfo.labels) -} -inline void WebMessageInfo::set_labels(int index, const char* value, size_t size) { - _impl_.labels_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:proto.WebMessageInfo.labels) -} -inline std::string* WebMessageInfo::_internal_add_labels() { - return _impl_.labels_.Add(); -} -inline void WebMessageInfo::add_labels(const std::string& value) { - _impl_.labels_.Add()->assign(value); - // @@protoc_insertion_point(field_add:proto.WebMessageInfo.labels) -} -inline void WebMessageInfo::add_labels(std::string&& value) { - _impl_.labels_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:proto.WebMessageInfo.labels) -} -inline void WebMessageInfo::add_labels(const char* value) { - GOOGLE_DCHECK(value != nullptr); - _impl_.labels_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:proto.WebMessageInfo.labels) -} -inline void WebMessageInfo::add_labels(const char* value, size_t size) { - _impl_.labels_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:proto.WebMessageInfo.labels) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -WebMessageInfo::labels() const { - // @@protoc_insertion_point(field_list:proto.WebMessageInfo.labels) - return _impl_.labels_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -WebMessageInfo::mutable_labels() { - // @@protoc_insertion_point(field_mutable_list:proto.WebMessageInfo.labels) - return &_impl_.labels_; -} - -// optional .proto.PaymentInfo paymentInfo = 29; -inline bool WebMessageInfo::_internal_has_paymentinfo() const { - bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0; - PROTOBUF_ASSUME(!value || _impl_.paymentinfo_ != nullptr); - return value; -} -inline bool WebMessageInfo::has_paymentinfo() const { - return _internal_has_paymentinfo(); -} -inline void WebMessageInfo::clear_paymentinfo() { - if (_impl_.paymentinfo_ != nullptr) _impl_.paymentinfo_->Clear(); - _impl_._has_bits_[0] &= ~0x00000400u; -} -inline const ::proto::PaymentInfo& WebMessageInfo::_internal_paymentinfo() const { - const ::proto::PaymentInfo* p = _impl_.paymentinfo_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_PaymentInfo_default_instance_); -} -inline const ::proto::PaymentInfo& WebMessageInfo::paymentinfo() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.paymentInfo) - return _internal_paymentinfo(); -} -inline void WebMessageInfo::unsafe_arena_set_allocated_paymentinfo( - ::proto::PaymentInfo* paymentinfo) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.paymentinfo_); - } - _impl_.paymentinfo_ = paymentinfo; - if (paymentinfo) { - _impl_._has_bits_[0] |= 0x00000400u; - } else { - _impl_._has_bits_[0] &= ~0x00000400u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.paymentInfo) -} -inline ::proto::PaymentInfo* WebMessageInfo::release_paymentinfo() { - _impl_._has_bits_[0] &= ~0x00000400u; - ::proto::PaymentInfo* temp = _impl_.paymentinfo_; - _impl_.paymentinfo_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::PaymentInfo* WebMessageInfo::unsafe_arena_release_paymentinfo() { - // @@protoc_insertion_point(field_release:proto.WebMessageInfo.paymentInfo) - _impl_._has_bits_[0] &= ~0x00000400u; - ::proto::PaymentInfo* temp = _impl_.paymentinfo_; - _impl_.paymentinfo_ = nullptr; - return temp; -} -inline ::proto::PaymentInfo* WebMessageInfo::_internal_mutable_paymentinfo() { - _impl_._has_bits_[0] |= 0x00000400u; - if (_impl_.paymentinfo_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::PaymentInfo>(GetArenaForAllocation()); - _impl_.paymentinfo_ = p; - } - return _impl_.paymentinfo_; -} -inline ::proto::PaymentInfo* WebMessageInfo::mutable_paymentinfo() { - ::proto::PaymentInfo* _msg = _internal_mutable_paymentinfo(); - // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.paymentInfo) - return _msg; -} -inline void WebMessageInfo::set_allocated_paymentinfo(::proto::PaymentInfo* paymentinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.paymentinfo_; - } - if (paymentinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(paymentinfo); - if (message_arena != submessage_arena) { - paymentinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, paymentinfo, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000400u; - } else { - _impl_._has_bits_[0] &= ~0x00000400u; - } - _impl_.paymentinfo_ = paymentinfo; - // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.paymentInfo) -} - -// optional .proto.Message.LiveLocationMessage finalLiveLocation = 30; -inline bool WebMessageInfo::_internal_has_finallivelocation() const { - bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0; - PROTOBUF_ASSUME(!value || _impl_.finallivelocation_ != nullptr); - return value; -} -inline bool WebMessageInfo::has_finallivelocation() const { - return _internal_has_finallivelocation(); -} -inline void WebMessageInfo::clear_finallivelocation() { - if (_impl_.finallivelocation_ != nullptr) _impl_.finallivelocation_->Clear(); - _impl_._has_bits_[0] &= ~0x00000800u; -} -inline const ::proto::Message_LiveLocationMessage& WebMessageInfo::_internal_finallivelocation() const { - const ::proto::Message_LiveLocationMessage* p = _impl_.finallivelocation_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_Message_LiveLocationMessage_default_instance_); -} -inline const ::proto::Message_LiveLocationMessage& WebMessageInfo::finallivelocation() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.finalLiveLocation) - return _internal_finallivelocation(); -} -inline void WebMessageInfo::unsafe_arena_set_allocated_finallivelocation( - ::proto::Message_LiveLocationMessage* finallivelocation) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.finallivelocation_); - } - _impl_.finallivelocation_ = finallivelocation; - if (finallivelocation) { - _impl_._has_bits_[0] |= 0x00000800u; - } else { - _impl_._has_bits_[0] &= ~0x00000800u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.finalLiveLocation) -} -inline ::proto::Message_LiveLocationMessage* WebMessageInfo::release_finallivelocation() { - _impl_._has_bits_[0] &= ~0x00000800u; - ::proto::Message_LiveLocationMessage* temp = _impl_.finallivelocation_; - _impl_.finallivelocation_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::Message_LiveLocationMessage* WebMessageInfo::unsafe_arena_release_finallivelocation() { - // @@protoc_insertion_point(field_release:proto.WebMessageInfo.finalLiveLocation) - _impl_._has_bits_[0] &= ~0x00000800u; - ::proto::Message_LiveLocationMessage* temp = _impl_.finallivelocation_; - _impl_.finallivelocation_ = nullptr; - return temp; -} -inline ::proto::Message_LiveLocationMessage* WebMessageInfo::_internal_mutable_finallivelocation() { - _impl_._has_bits_[0] |= 0x00000800u; - if (_impl_.finallivelocation_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::Message_LiveLocationMessage>(GetArenaForAllocation()); - _impl_.finallivelocation_ = p; - } - return _impl_.finallivelocation_; -} -inline ::proto::Message_LiveLocationMessage* WebMessageInfo::mutable_finallivelocation() { - ::proto::Message_LiveLocationMessage* _msg = _internal_mutable_finallivelocation(); - // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.finalLiveLocation) - return _msg; -} -inline void WebMessageInfo::set_allocated_finallivelocation(::proto::Message_LiveLocationMessage* finallivelocation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.finallivelocation_; - } - if (finallivelocation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(finallivelocation); - if (message_arena != submessage_arena) { - finallivelocation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, finallivelocation, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00000800u; - } else { - _impl_._has_bits_[0] &= ~0x00000800u; - } - _impl_.finallivelocation_ = finallivelocation; - // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.finalLiveLocation) -} - -// optional .proto.PaymentInfo quotedPaymentInfo = 31; -inline bool WebMessageInfo::_internal_has_quotedpaymentinfo() const { - bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.quotedpaymentinfo_ != nullptr); - return value; -} -inline bool WebMessageInfo::has_quotedpaymentinfo() const { - return _internal_has_quotedpaymentinfo(); -} -inline void WebMessageInfo::clear_quotedpaymentinfo() { - if (_impl_.quotedpaymentinfo_ != nullptr) _impl_.quotedpaymentinfo_->Clear(); - _impl_._has_bits_[0] &= ~0x00001000u; -} -inline const ::proto::PaymentInfo& WebMessageInfo::_internal_quotedpaymentinfo() const { - const ::proto::PaymentInfo* p = _impl_.quotedpaymentinfo_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_PaymentInfo_default_instance_); -} -inline const ::proto::PaymentInfo& WebMessageInfo::quotedpaymentinfo() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.quotedPaymentInfo) - return _internal_quotedpaymentinfo(); -} -inline void WebMessageInfo::unsafe_arena_set_allocated_quotedpaymentinfo( - ::proto::PaymentInfo* quotedpaymentinfo) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quotedpaymentinfo_); - } - _impl_.quotedpaymentinfo_ = quotedpaymentinfo; - if (quotedpaymentinfo) { - _impl_._has_bits_[0] |= 0x00001000u; - } else { - _impl_._has_bits_[0] &= ~0x00001000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.quotedPaymentInfo) -} -inline ::proto::PaymentInfo* WebMessageInfo::release_quotedpaymentinfo() { - _impl_._has_bits_[0] &= ~0x00001000u; - ::proto::PaymentInfo* temp = _impl_.quotedpaymentinfo_; - _impl_.quotedpaymentinfo_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::PaymentInfo* WebMessageInfo::unsafe_arena_release_quotedpaymentinfo() { - // @@protoc_insertion_point(field_release:proto.WebMessageInfo.quotedPaymentInfo) - _impl_._has_bits_[0] &= ~0x00001000u; - ::proto::PaymentInfo* temp = _impl_.quotedpaymentinfo_; - _impl_.quotedpaymentinfo_ = nullptr; - return temp; -} -inline ::proto::PaymentInfo* WebMessageInfo::_internal_mutable_quotedpaymentinfo() { - _impl_._has_bits_[0] |= 0x00001000u; - if (_impl_.quotedpaymentinfo_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::PaymentInfo>(GetArenaForAllocation()); - _impl_.quotedpaymentinfo_ = p; - } - return _impl_.quotedpaymentinfo_; -} -inline ::proto::PaymentInfo* WebMessageInfo::mutable_quotedpaymentinfo() { - ::proto::PaymentInfo* _msg = _internal_mutable_quotedpaymentinfo(); - // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.quotedPaymentInfo) - return _msg; -} -inline void WebMessageInfo::set_allocated_quotedpaymentinfo(::proto::PaymentInfo* quotedpaymentinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.quotedpaymentinfo_; - } - if (quotedpaymentinfo) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quotedpaymentinfo); - if (message_arena != submessage_arena) { - quotedpaymentinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, quotedpaymentinfo, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00001000u; - } else { - _impl_._has_bits_[0] &= ~0x00001000u; - } - _impl_.quotedpaymentinfo_ = quotedpaymentinfo; - // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.quotedPaymentInfo) -} - -// optional uint64 ephemeralStartTimestamp = 32; -inline bool WebMessageInfo::_internal_has_ephemeralstarttimestamp() const { - bool value = (_impl_._has_bits_[1] & 0x00000002u) != 0; - return value; -} -inline bool WebMessageInfo::has_ephemeralstarttimestamp() const { - return _internal_has_ephemeralstarttimestamp(); -} -inline void WebMessageInfo::clear_ephemeralstarttimestamp() { - _impl_.ephemeralstarttimestamp_ = uint64_t{0u}; - _impl_._has_bits_[1] &= ~0x00000002u; -} -inline uint64_t WebMessageInfo::_internal_ephemeralstarttimestamp() const { - return _impl_.ephemeralstarttimestamp_; -} -inline uint64_t WebMessageInfo::ephemeralstarttimestamp() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.ephemeralStartTimestamp) - return _internal_ephemeralstarttimestamp(); -} -inline void WebMessageInfo::_internal_set_ephemeralstarttimestamp(uint64_t value) { - _impl_._has_bits_[1] |= 0x00000002u; - _impl_.ephemeralstarttimestamp_ = value; -} -inline void WebMessageInfo::set_ephemeralstarttimestamp(uint64_t value) { - _internal_set_ephemeralstarttimestamp(value); - // @@protoc_insertion_point(field_set:proto.WebMessageInfo.ephemeralStartTimestamp) -} - -// optional uint32 ephemeralDuration = 33; -inline bool WebMessageInfo::_internal_has_ephemeralduration() const { - bool value = (_impl_._has_bits_[1] & 0x00000001u) != 0; - return value; -} -inline bool WebMessageInfo::has_ephemeralduration() const { - return _internal_has_ephemeralduration(); -} -inline void WebMessageInfo::clear_ephemeralduration() { - _impl_.ephemeralduration_ = 0u; - _impl_._has_bits_[1] &= ~0x00000001u; -} -inline uint32_t WebMessageInfo::_internal_ephemeralduration() const { - return _impl_.ephemeralduration_; -} -inline uint32_t WebMessageInfo::ephemeralduration() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.ephemeralDuration) - return _internal_ephemeralduration(); -} -inline void WebMessageInfo::_internal_set_ephemeralduration(uint32_t value) { - _impl_._has_bits_[1] |= 0x00000001u; - _impl_.ephemeralduration_ = value; -} -inline void WebMessageInfo::set_ephemeralduration(uint32_t value) { - _internal_set_ephemeralduration(value); - // @@protoc_insertion_point(field_set:proto.WebMessageInfo.ephemeralDuration) -} - -// optional bool ephemeralOffToOn = 34; -inline bool WebMessageInfo::_internal_has_ephemeralofftoon() const { - bool value = (_impl_._has_bits_[0] & 0x40000000u) != 0; - return value; -} -inline bool WebMessageInfo::has_ephemeralofftoon() const { - return _internal_has_ephemeralofftoon(); -} -inline void WebMessageInfo::clear_ephemeralofftoon() { - _impl_.ephemeralofftoon_ = false; - _impl_._has_bits_[0] &= ~0x40000000u; -} -inline bool WebMessageInfo::_internal_ephemeralofftoon() const { - return _impl_.ephemeralofftoon_; -} -inline bool WebMessageInfo::ephemeralofftoon() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.ephemeralOffToOn) - return _internal_ephemeralofftoon(); -} -inline void WebMessageInfo::_internal_set_ephemeralofftoon(bool value) { - _impl_._has_bits_[0] |= 0x40000000u; - _impl_.ephemeralofftoon_ = value; -} -inline void WebMessageInfo::set_ephemeralofftoon(bool value) { - _internal_set_ephemeralofftoon(value); - // @@protoc_insertion_point(field_set:proto.WebMessageInfo.ephemeralOffToOn) -} - -// optional bool ephemeralOutOfSync = 35; -inline bool WebMessageInfo::_internal_has_ephemeraloutofsync() const { - bool value = (_impl_._has_bits_[1] & 0x00000008u) != 0; - return value; -} -inline bool WebMessageInfo::has_ephemeraloutofsync() const { - return _internal_has_ephemeraloutofsync(); -} -inline void WebMessageInfo::clear_ephemeraloutofsync() { - _impl_.ephemeraloutofsync_ = false; - _impl_._has_bits_[1] &= ~0x00000008u; -} -inline bool WebMessageInfo::_internal_ephemeraloutofsync() const { - return _impl_.ephemeraloutofsync_; -} -inline bool WebMessageInfo::ephemeraloutofsync() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.ephemeralOutOfSync) - return _internal_ephemeraloutofsync(); -} -inline void WebMessageInfo::_internal_set_ephemeraloutofsync(bool value) { - _impl_._has_bits_[1] |= 0x00000008u; - _impl_.ephemeraloutofsync_ = value; -} -inline void WebMessageInfo::set_ephemeraloutofsync(bool value) { - _internal_set_ephemeraloutofsync(value); - // @@protoc_insertion_point(field_set:proto.WebMessageInfo.ephemeralOutOfSync) -} - -// optional .proto.WebMessageInfo.BizPrivacyStatus bizPrivacyStatus = 36; -inline bool WebMessageInfo::_internal_has_bizprivacystatus() const { - bool value = (_impl_._has_bits_[1] & 0x00000004u) != 0; - return value; -} -inline bool WebMessageInfo::has_bizprivacystatus() const { - return _internal_has_bizprivacystatus(); -} -inline void WebMessageInfo::clear_bizprivacystatus() { - _impl_.bizprivacystatus_ = 0; - _impl_._has_bits_[1] &= ~0x00000004u; -} -inline ::proto::WebMessageInfo_BizPrivacyStatus WebMessageInfo::_internal_bizprivacystatus() const { - return static_cast< ::proto::WebMessageInfo_BizPrivacyStatus >(_impl_.bizprivacystatus_); -} -inline ::proto::WebMessageInfo_BizPrivacyStatus WebMessageInfo::bizprivacystatus() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.bizPrivacyStatus) - return _internal_bizprivacystatus(); -} -inline void WebMessageInfo::_internal_set_bizprivacystatus(::proto::WebMessageInfo_BizPrivacyStatus value) { - assert(::proto::WebMessageInfo_BizPrivacyStatus_IsValid(value)); - _impl_._has_bits_[1] |= 0x00000004u; - _impl_.bizprivacystatus_ = value; -} -inline void WebMessageInfo::set_bizprivacystatus(::proto::WebMessageInfo_BizPrivacyStatus value) { - _internal_set_bizprivacystatus(value); - // @@protoc_insertion_point(field_set:proto.WebMessageInfo.bizPrivacyStatus) -} - -// optional string verifiedBizName = 37; -inline bool WebMessageInfo::_internal_has_verifiedbizname() const { - bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0; - return value; -} -inline bool WebMessageInfo::has_verifiedbizname() const { - return _internal_has_verifiedbizname(); -} -inline void WebMessageInfo::clear_verifiedbizname() { - _impl_.verifiedbizname_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000008u; -} -inline const std::string& WebMessageInfo::verifiedbizname() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.verifiedBizName) - return _internal_verifiedbizname(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void WebMessageInfo::set_verifiedbizname(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.verifiedbizname_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.WebMessageInfo.verifiedBizName) -} -inline std::string* WebMessageInfo::mutable_verifiedbizname() { - std::string* _s = _internal_mutable_verifiedbizname(); - // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.verifiedBizName) - return _s; -} -inline const std::string& WebMessageInfo::_internal_verifiedbizname() const { - return _impl_.verifiedbizname_.Get(); -} -inline void WebMessageInfo::_internal_set_verifiedbizname(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000008u; - _impl_.verifiedbizname_.Set(value, GetArenaForAllocation()); -} -inline std::string* WebMessageInfo::_internal_mutable_verifiedbizname() { - _impl_._has_bits_[0] |= 0x00000008u; - return _impl_.verifiedbizname_.Mutable(GetArenaForAllocation()); -} -inline std::string* WebMessageInfo::release_verifiedbizname() { - // @@protoc_insertion_point(field_release:proto.WebMessageInfo.verifiedBizName) - if (!_internal_has_verifiedbizname()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000008u; - auto* p = _impl_.verifiedbizname_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.verifiedbizname_.IsDefault()) { - _impl_.verifiedbizname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void WebMessageInfo::set_allocated_verifiedbizname(std::string* verifiedbizname) { - if (verifiedbizname != nullptr) { - _impl_._has_bits_[0] |= 0x00000008u; - } else { - _impl_._has_bits_[0] &= ~0x00000008u; - } - _impl_.verifiedbizname_.SetAllocated(verifiedbizname, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.verifiedbizname_.IsDefault()) { - _impl_.verifiedbizname_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.verifiedBizName) -} - -// optional .proto.MediaData mediaData = 38; -inline bool WebMessageInfo::_internal_has_mediadata() const { - bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.mediadata_ != nullptr); - return value; -} -inline bool WebMessageInfo::has_mediadata() const { - return _internal_has_mediadata(); -} -inline void WebMessageInfo::clear_mediadata() { - if (_impl_.mediadata_ != nullptr) _impl_.mediadata_->Clear(); - _impl_._has_bits_[0] &= ~0x00002000u; -} -inline const ::proto::MediaData& WebMessageInfo::_internal_mediadata() const { - const ::proto::MediaData* p = _impl_.mediadata_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_MediaData_default_instance_); -} -inline const ::proto::MediaData& WebMessageInfo::mediadata() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.mediaData) - return _internal_mediadata(); -} -inline void WebMessageInfo::unsafe_arena_set_allocated_mediadata( - ::proto::MediaData* mediadata) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.mediadata_); - } - _impl_.mediadata_ = mediadata; - if (mediadata) { - _impl_._has_bits_[0] |= 0x00002000u; - } else { - _impl_._has_bits_[0] &= ~0x00002000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.mediaData) -} -inline ::proto::MediaData* WebMessageInfo::release_mediadata() { - _impl_._has_bits_[0] &= ~0x00002000u; - ::proto::MediaData* temp = _impl_.mediadata_; - _impl_.mediadata_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::MediaData* WebMessageInfo::unsafe_arena_release_mediadata() { - // @@protoc_insertion_point(field_release:proto.WebMessageInfo.mediaData) - _impl_._has_bits_[0] &= ~0x00002000u; - ::proto::MediaData* temp = _impl_.mediadata_; - _impl_.mediadata_ = nullptr; - return temp; -} -inline ::proto::MediaData* WebMessageInfo::_internal_mutable_mediadata() { - _impl_._has_bits_[0] |= 0x00002000u; - if (_impl_.mediadata_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::MediaData>(GetArenaForAllocation()); - _impl_.mediadata_ = p; - } - return _impl_.mediadata_; -} -inline ::proto::MediaData* WebMessageInfo::mutable_mediadata() { - ::proto::MediaData* _msg = _internal_mutable_mediadata(); - // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.mediaData) - return _msg; -} -inline void WebMessageInfo::set_allocated_mediadata(::proto::MediaData* mediadata) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.mediadata_; - } - if (mediadata) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(mediadata); - if (message_arena != submessage_arena) { - mediadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, mediadata, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00002000u; - } else { - _impl_._has_bits_[0] &= ~0x00002000u; - } - _impl_.mediadata_ = mediadata; - // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.mediaData) -} - -// optional .proto.PhotoChange photoChange = 39; -inline bool WebMessageInfo::_internal_has_photochange() const { - bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.photochange_ != nullptr); - return value; -} -inline bool WebMessageInfo::has_photochange() const { - return _internal_has_photochange(); -} -inline void WebMessageInfo::clear_photochange() { - if (_impl_.photochange_ != nullptr) _impl_.photochange_->Clear(); - _impl_._has_bits_[0] &= ~0x00004000u; -} -inline const ::proto::PhotoChange& WebMessageInfo::_internal_photochange() const { - const ::proto::PhotoChange* p = _impl_.photochange_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_PhotoChange_default_instance_); -} -inline const ::proto::PhotoChange& WebMessageInfo::photochange() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.photoChange) - return _internal_photochange(); -} -inline void WebMessageInfo::unsafe_arena_set_allocated_photochange( - ::proto::PhotoChange* photochange) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.photochange_); - } - _impl_.photochange_ = photochange; - if (photochange) { - _impl_._has_bits_[0] |= 0x00004000u; - } else { - _impl_._has_bits_[0] &= ~0x00004000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.photoChange) -} -inline ::proto::PhotoChange* WebMessageInfo::release_photochange() { - _impl_._has_bits_[0] &= ~0x00004000u; - ::proto::PhotoChange* temp = _impl_.photochange_; - _impl_.photochange_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::PhotoChange* WebMessageInfo::unsafe_arena_release_photochange() { - // @@protoc_insertion_point(field_release:proto.WebMessageInfo.photoChange) - _impl_._has_bits_[0] &= ~0x00004000u; - ::proto::PhotoChange* temp = _impl_.photochange_; - _impl_.photochange_ = nullptr; - return temp; -} -inline ::proto::PhotoChange* WebMessageInfo::_internal_mutable_photochange() { - _impl_._has_bits_[0] |= 0x00004000u; - if (_impl_.photochange_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::PhotoChange>(GetArenaForAllocation()); - _impl_.photochange_ = p; - } - return _impl_.photochange_; -} -inline ::proto::PhotoChange* WebMessageInfo::mutable_photochange() { - ::proto::PhotoChange* _msg = _internal_mutable_photochange(); - // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.photoChange) - return _msg; -} -inline void WebMessageInfo::set_allocated_photochange(::proto::PhotoChange* photochange) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.photochange_; - } - if (photochange) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(photochange); - if (message_arena != submessage_arena) { - photochange = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, photochange, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00004000u; - } else { - _impl_._has_bits_[0] &= ~0x00004000u; - } - _impl_.photochange_ = photochange; - // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.photoChange) -} - -// repeated .proto.UserReceipt userReceipt = 40; -inline int WebMessageInfo::_internal_userreceipt_size() const { - return _impl_.userreceipt_.size(); -} -inline int WebMessageInfo::userreceipt_size() const { - return _internal_userreceipt_size(); -} -inline void WebMessageInfo::clear_userreceipt() { - _impl_.userreceipt_.Clear(); -} -inline ::proto::UserReceipt* WebMessageInfo::mutable_userreceipt(int index) { - // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.userReceipt) - return _impl_.userreceipt_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::UserReceipt >* -WebMessageInfo::mutable_userreceipt() { - // @@protoc_insertion_point(field_mutable_list:proto.WebMessageInfo.userReceipt) - return &_impl_.userreceipt_; -} -inline const ::proto::UserReceipt& WebMessageInfo::_internal_userreceipt(int index) const { - return _impl_.userreceipt_.Get(index); -} -inline const ::proto::UserReceipt& WebMessageInfo::userreceipt(int index) const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.userReceipt) - return _internal_userreceipt(index); -} -inline ::proto::UserReceipt* WebMessageInfo::_internal_add_userreceipt() { - return _impl_.userreceipt_.Add(); -} -inline ::proto::UserReceipt* WebMessageInfo::add_userreceipt() { - ::proto::UserReceipt* _add = _internal_add_userreceipt(); - // @@protoc_insertion_point(field_add:proto.WebMessageInfo.userReceipt) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::UserReceipt >& -WebMessageInfo::userreceipt() const { - // @@protoc_insertion_point(field_list:proto.WebMessageInfo.userReceipt) - return _impl_.userreceipt_; -} - -// repeated .proto.Reaction reactions = 41; -inline int WebMessageInfo::_internal_reactions_size() const { - return _impl_.reactions_.size(); -} -inline int WebMessageInfo::reactions_size() const { - return _internal_reactions_size(); -} -inline void WebMessageInfo::clear_reactions() { - _impl_.reactions_.Clear(); -} -inline ::proto::Reaction* WebMessageInfo::mutable_reactions(int index) { - // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.reactions) - return _impl_.reactions_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Reaction >* -WebMessageInfo::mutable_reactions() { - // @@protoc_insertion_point(field_mutable_list:proto.WebMessageInfo.reactions) - return &_impl_.reactions_; -} -inline const ::proto::Reaction& WebMessageInfo::_internal_reactions(int index) const { - return _impl_.reactions_.Get(index); -} -inline const ::proto::Reaction& WebMessageInfo::reactions(int index) const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.reactions) - return _internal_reactions(index); -} -inline ::proto::Reaction* WebMessageInfo::_internal_add_reactions() { - return _impl_.reactions_.Add(); -} -inline ::proto::Reaction* WebMessageInfo::add_reactions() { - ::proto::Reaction* _add = _internal_add_reactions(); - // @@protoc_insertion_point(field_add:proto.WebMessageInfo.reactions) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Reaction >& -WebMessageInfo::reactions() const { - // @@protoc_insertion_point(field_list:proto.WebMessageInfo.reactions) - return _impl_.reactions_; -} - -// optional .proto.MediaData quotedStickerData = 42; -inline bool WebMessageInfo::_internal_has_quotedstickerdata() const { - bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.quotedstickerdata_ != nullptr); - return value; -} -inline bool WebMessageInfo::has_quotedstickerdata() const { - return _internal_has_quotedstickerdata(); -} -inline void WebMessageInfo::clear_quotedstickerdata() { - if (_impl_.quotedstickerdata_ != nullptr) _impl_.quotedstickerdata_->Clear(); - _impl_._has_bits_[0] &= ~0x00008000u; -} -inline const ::proto::MediaData& WebMessageInfo::_internal_quotedstickerdata() const { - const ::proto::MediaData* p = _impl_.quotedstickerdata_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_MediaData_default_instance_); -} -inline const ::proto::MediaData& WebMessageInfo::quotedstickerdata() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.quotedStickerData) - return _internal_quotedstickerdata(); -} -inline void WebMessageInfo::unsafe_arena_set_allocated_quotedstickerdata( - ::proto::MediaData* quotedstickerdata) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quotedstickerdata_); - } - _impl_.quotedstickerdata_ = quotedstickerdata; - if (quotedstickerdata) { - _impl_._has_bits_[0] |= 0x00008000u; - } else { - _impl_._has_bits_[0] &= ~0x00008000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.quotedStickerData) -} -inline ::proto::MediaData* WebMessageInfo::release_quotedstickerdata() { - _impl_._has_bits_[0] &= ~0x00008000u; - ::proto::MediaData* temp = _impl_.quotedstickerdata_; - _impl_.quotedstickerdata_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::MediaData* WebMessageInfo::unsafe_arena_release_quotedstickerdata() { - // @@protoc_insertion_point(field_release:proto.WebMessageInfo.quotedStickerData) - _impl_._has_bits_[0] &= ~0x00008000u; - ::proto::MediaData* temp = _impl_.quotedstickerdata_; - _impl_.quotedstickerdata_ = nullptr; - return temp; -} -inline ::proto::MediaData* WebMessageInfo::_internal_mutable_quotedstickerdata() { - _impl_._has_bits_[0] |= 0x00008000u; - if (_impl_.quotedstickerdata_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::MediaData>(GetArenaForAllocation()); - _impl_.quotedstickerdata_ = p; - } - return _impl_.quotedstickerdata_; -} -inline ::proto::MediaData* WebMessageInfo::mutable_quotedstickerdata() { - ::proto::MediaData* _msg = _internal_mutable_quotedstickerdata(); - // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.quotedStickerData) - return _msg; -} -inline void WebMessageInfo::set_allocated_quotedstickerdata(::proto::MediaData* quotedstickerdata) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.quotedstickerdata_; - } - if (quotedstickerdata) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quotedstickerdata); - if (message_arena != submessage_arena) { - quotedstickerdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, quotedstickerdata, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00008000u; - } else { - _impl_._has_bits_[0] &= ~0x00008000u; - } - _impl_.quotedstickerdata_ = quotedstickerdata; - // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.quotedStickerData) -} - -// optional bytes futureproofData = 43; -inline bool WebMessageInfo::_internal_has_futureproofdata() const { - bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0; - return value; -} -inline bool WebMessageInfo::has_futureproofdata() const { - return _internal_has_futureproofdata(); -} -inline void WebMessageInfo::clear_futureproofdata() { - _impl_.futureproofdata_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000010u; -} -inline const std::string& WebMessageInfo::futureproofdata() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.futureproofData) - return _internal_futureproofdata(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void WebMessageInfo::set_futureproofdata(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.futureproofdata_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.WebMessageInfo.futureproofData) -} -inline std::string* WebMessageInfo::mutable_futureproofdata() { - std::string* _s = _internal_mutable_futureproofdata(); - // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.futureproofData) - return _s; -} -inline const std::string& WebMessageInfo::_internal_futureproofdata() const { - return _impl_.futureproofdata_.Get(); -} -inline void WebMessageInfo::_internal_set_futureproofdata(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000010u; - _impl_.futureproofdata_.Set(value, GetArenaForAllocation()); -} -inline std::string* WebMessageInfo::_internal_mutable_futureproofdata() { - _impl_._has_bits_[0] |= 0x00000010u; - return _impl_.futureproofdata_.Mutable(GetArenaForAllocation()); -} -inline std::string* WebMessageInfo::release_futureproofdata() { - // @@protoc_insertion_point(field_release:proto.WebMessageInfo.futureproofData) - if (!_internal_has_futureproofdata()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000010u; - auto* p = _impl_.futureproofdata_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.futureproofdata_.IsDefault()) { - _impl_.futureproofdata_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void WebMessageInfo::set_allocated_futureproofdata(std::string* futureproofdata) { - if (futureproofdata != nullptr) { - _impl_._has_bits_[0] |= 0x00000010u; - } else { - _impl_._has_bits_[0] &= ~0x00000010u; - } - _impl_.futureproofdata_.SetAllocated(futureproofdata, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.futureproofdata_.IsDefault()) { - _impl_.futureproofdata_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.futureproofData) -} - -// optional .proto.StatusPSA statusPsa = 44; -inline bool WebMessageInfo::_internal_has_statuspsa() const { - bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.statuspsa_ != nullptr); - return value; -} -inline bool WebMessageInfo::has_statuspsa() const { - return _internal_has_statuspsa(); -} -inline void WebMessageInfo::clear_statuspsa() { - if (_impl_.statuspsa_ != nullptr) _impl_.statuspsa_->Clear(); - _impl_._has_bits_[0] &= ~0x00010000u; -} -inline const ::proto::StatusPSA& WebMessageInfo::_internal_statuspsa() const { - const ::proto::StatusPSA* p = _impl_.statuspsa_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_StatusPSA_default_instance_); -} -inline const ::proto::StatusPSA& WebMessageInfo::statuspsa() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.statusPsa) - return _internal_statuspsa(); -} -inline void WebMessageInfo::unsafe_arena_set_allocated_statuspsa( - ::proto::StatusPSA* statuspsa) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.statuspsa_); - } - _impl_.statuspsa_ = statuspsa; - if (statuspsa) { - _impl_._has_bits_[0] |= 0x00010000u; - } else { - _impl_._has_bits_[0] &= ~0x00010000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.statusPsa) -} -inline ::proto::StatusPSA* WebMessageInfo::release_statuspsa() { - _impl_._has_bits_[0] &= ~0x00010000u; - ::proto::StatusPSA* temp = _impl_.statuspsa_; - _impl_.statuspsa_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::StatusPSA* WebMessageInfo::unsafe_arena_release_statuspsa() { - // @@protoc_insertion_point(field_release:proto.WebMessageInfo.statusPsa) - _impl_._has_bits_[0] &= ~0x00010000u; - ::proto::StatusPSA* temp = _impl_.statuspsa_; - _impl_.statuspsa_ = nullptr; - return temp; -} -inline ::proto::StatusPSA* WebMessageInfo::_internal_mutable_statuspsa() { - _impl_._has_bits_[0] |= 0x00010000u; - if (_impl_.statuspsa_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::StatusPSA>(GetArenaForAllocation()); - _impl_.statuspsa_ = p; - } - return _impl_.statuspsa_; -} -inline ::proto::StatusPSA* WebMessageInfo::mutable_statuspsa() { - ::proto::StatusPSA* _msg = _internal_mutable_statuspsa(); - // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.statusPsa) - return _msg; -} -inline void WebMessageInfo::set_allocated_statuspsa(::proto::StatusPSA* statuspsa) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.statuspsa_; - } - if (statuspsa) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(statuspsa); - if (message_arena != submessage_arena) { - statuspsa = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, statuspsa, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00010000u; - } else { - _impl_._has_bits_[0] &= ~0x00010000u; - } - _impl_.statuspsa_ = statuspsa; - // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.statusPsa) -} - -// repeated .proto.PollUpdate pollUpdates = 45; -inline int WebMessageInfo::_internal_pollupdates_size() const { - return _impl_.pollupdates_.size(); -} -inline int WebMessageInfo::pollupdates_size() const { - return _internal_pollupdates_size(); -} -inline void WebMessageInfo::clear_pollupdates() { - _impl_.pollupdates_.Clear(); -} -inline ::proto::PollUpdate* WebMessageInfo::mutable_pollupdates(int index) { - // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.pollUpdates) - return _impl_.pollupdates_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PollUpdate >* -WebMessageInfo::mutable_pollupdates() { - // @@protoc_insertion_point(field_mutable_list:proto.WebMessageInfo.pollUpdates) - return &_impl_.pollupdates_; -} -inline const ::proto::PollUpdate& WebMessageInfo::_internal_pollupdates(int index) const { - return _impl_.pollupdates_.Get(index); -} -inline const ::proto::PollUpdate& WebMessageInfo::pollupdates(int index) const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.pollUpdates) - return _internal_pollupdates(index); -} -inline ::proto::PollUpdate* WebMessageInfo::_internal_add_pollupdates() { - return _impl_.pollupdates_.Add(); -} -inline ::proto::PollUpdate* WebMessageInfo::add_pollupdates() { - ::proto::PollUpdate* _add = _internal_add_pollupdates(); - // @@protoc_insertion_point(field_add:proto.WebMessageInfo.pollUpdates) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PollUpdate >& -WebMessageInfo::pollupdates() const { - // @@protoc_insertion_point(field_list:proto.WebMessageInfo.pollUpdates) - return _impl_.pollupdates_; -} - -// optional .proto.PollAdditionalMetadata pollAdditionalMetadata = 46; -inline bool WebMessageInfo::_internal_has_polladditionalmetadata() const { - bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.polladditionalmetadata_ != nullptr); - return value; -} -inline bool WebMessageInfo::has_polladditionalmetadata() const { - return _internal_has_polladditionalmetadata(); -} -inline void WebMessageInfo::clear_polladditionalmetadata() { - if (_impl_.polladditionalmetadata_ != nullptr) _impl_.polladditionalmetadata_->Clear(); - _impl_._has_bits_[0] &= ~0x00020000u; -} -inline const ::proto::PollAdditionalMetadata& WebMessageInfo::_internal_polladditionalmetadata() const { - const ::proto::PollAdditionalMetadata* p = _impl_.polladditionalmetadata_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_PollAdditionalMetadata_default_instance_); -} -inline const ::proto::PollAdditionalMetadata& WebMessageInfo::polladditionalmetadata() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.pollAdditionalMetadata) - return _internal_polladditionalmetadata(); -} -inline void WebMessageInfo::unsafe_arena_set_allocated_polladditionalmetadata( - ::proto::PollAdditionalMetadata* polladditionalmetadata) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.polladditionalmetadata_); - } - _impl_.polladditionalmetadata_ = polladditionalmetadata; - if (polladditionalmetadata) { - _impl_._has_bits_[0] |= 0x00020000u; - } else { - _impl_._has_bits_[0] &= ~0x00020000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.pollAdditionalMetadata) -} -inline ::proto::PollAdditionalMetadata* WebMessageInfo::release_polladditionalmetadata() { - _impl_._has_bits_[0] &= ~0x00020000u; - ::proto::PollAdditionalMetadata* temp = _impl_.polladditionalmetadata_; - _impl_.polladditionalmetadata_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::PollAdditionalMetadata* WebMessageInfo::unsafe_arena_release_polladditionalmetadata() { - // @@protoc_insertion_point(field_release:proto.WebMessageInfo.pollAdditionalMetadata) - _impl_._has_bits_[0] &= ~0x00020000u; - ::proto::PollAdditionalMetadata* temp = _impl_.polladditionalmetadata_; - _impl_.polladditionalmetadata_ = nullptr; - return temp; -} -inline ::proto::PollAdditionalMetadata* WebMessageInfo::_internal_mutable_polladditionalmetadata() { - _impl_._has_bits_[0] |= 0x00020000u; - if (_impl_.polladditionalmetadata_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::PollAdditionalMetadata>(GetArenaForAllocation()); - _impl_.polladditionalmetadata_ = p; - } - return _impl_.polladditionalmetadata_; -} -inline ::proto::PollAdditionalMetadata* WebMessageInfo::mutable_polladditionalmetadata() { - ::proto::PollAdditionalMetadata* _msg = _internal_mutable_polladditionalmetadata(); - // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.pollAdditionalMetadata) - return _msg; -} -inline void WebMessageInfo::set_allocated_polladditionalmetadata(::proto::PollAdditionalMetadata* polladditionalmetadata) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.polladditionalmetadata_; - } - if (polladditionalmetadata) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(polladditionalmetadata); - if (message_arena != submessage_arena) { - polladditionalmetadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, polladditionalmetadata, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00020000u; - } else { - _impl_._has_bits_[0] &= ~0x00020000u; - } - _impl_.polladditionalmetadata_ = polladditionalmetadata; - // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.pollAdditionalMetadata) -} - -// optional string agentId = 47; -inline bool WebMessageInfo::_internal_has_agentid() const { - bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0; - return value; -} -inline bool WebMessageInfo::has_agentid() const { - return _internal_has_agentid(); -} -inline void WebMessageInfo::clear_agentid() { - _impl_.agentid_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000020u; -} -inline const std::string& WebMessageInfo::agentid() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.agentId) - return _internal_agentid(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void WebMessageInfo::set_agentid(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.agentid_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.WebMessageInfo.agentId) -} -inline std::string* WebMessageInfo::mutable_agentid() { - std::string* _s = _internal_mutable_agentid(); - // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.agentId) - return _s; -} -inline const std::string& WebMessageInfo::_internal_agentid() const { - return _impl_.agentid_.Get(); -} -inline void WebMessageInfo::_internal_set_agentid(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000020u; - _impl_.agentid_.Set(value, GetArenaForAllocation()); -} -inline std::string* WebMessageInfo::_internal_mutable_agentid() { - _impl_._has_bits_[0] |= 0x00000020u; - return _impl_.agentid_.Mutable(GetArenaForAllocation()); -} -inline std::string* WebMessageInfo::release_agentid() { - // @@protoc_insertion_point(field_release:proto.WebMessageInfo.agentId) - if (!_internal_has_agentid()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000020u; - auto* p = _impl_.agentid_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.agentid_.IsDefault()) { - _impl_.agentid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void WebMessageInfo::set_allocated_agentid(std::string* agentid) { - if (agentid != nullptr) { - _impl_._has_bits_[0] |= 0x00000020u; - } else { - _impl_._has_bits_[0] &= ~0x00000020u; - } - _impl_.agentid_.SetAllocated(agentid, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.agentid_.IsDefault()) { - _impl_.agentid_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.agentId) -} - -// optional bool statusAlreadyViewed = 48; -inline bool WebMessageInfo::_internal_has_statusalreadyviewed() const { - bool value = (_impl_._has_bits_[1] & 0x00000010u) != 0; - return value; -} -inline bool WebMessageInfo::has_statusalreadyviewed() const { - return _internal_has_statusalreadyviewed(); -} -inline void WebMessageInfo::clear_statusalreadyviewed() { - _impl_.statusalreadyviewed_ = false; - _impl_._has_bits_[1] &= ~0x00000010u; -} -inline bool WebMessageInfo::_internal_statusalreadyviewed() const { - return _impl_.statusalreadyviewed_; -} -inline bool WebMessageInfo::statusalreadyviewed() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.statusAlreadyViewed) - return _internal_statusalreadyviewed(); -} -inline void WebMessageInfo::_internal_set_statusalreadyviewed(bool value) { - _impl_._has_bits_[1] |= 0x00000010u; - _impl_.statusalreadyviewed_ = value; -} -inline void WebMessageInfo::set_statusalreadyviewed(bool value) { - _internal_set_statusalreadyviewed(value); - // @@protoc_insertion_point(field_set:proto.WebMessageInfo.statusAlreadyViewed) -} - -// optional bytes messageSecret = 49; -inline bool WebMessageInfo::_internal_has_messagesecret() const { - bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0; - return value; -} -inline bool WebMessageInfo::has_messagesecret() const { - return _internal_has_messagesecret(); -} -inline void WebMessageInfo::clear_messagesecret() { - _impl_.messagesecret_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000040u; -} -inline const std::string& WebMessageInfo::messagesecret() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.messageSecret) - return _internal_messagesecret(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void WebMessageInfo::set_messagesecret(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.messagesecret_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.WebMessageInfo.messageSecret) -} -inline std::string* WebMessageInfo::mutable_messagesecret() { - std::string* _s = _internal_mutable_messagesecret(); - // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.messageSecret) - return _s; -} -inline const std::string& WebMessageInfo::_internal_messagesecret() const { - return _impl_.messagesecret_.Get(); -} -inline void WebMessageInfo::_internal_set_messagesecret(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000040u; - _impl_.messagesecret_.Set(value, GetArenaForAllocation()); -} -inline std::string* WebMessageInfo::_internal_mutable_messagesecret() { - _impl_._has_bits_[0] |= 0x00000040u; - return _impl_.messagesecret_.Mutable(GetArenaForAllocation()); -} -inline std::string* WebMessageInfo::release_messagesecret() { - // @@protoc_insertion_point(field_release:proto.WebMessageInfo.messageSecret) - if (!_internal_has_messagesecret()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000040u; - auto* p = _impl_.messagesecret_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.messagesecret_.IsDefault()) { - _impl_.messagesecret_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void WebMessageInfo::set_allocated_messagesecret(std::string* messagesecret) { - if (messagesecret != nullptr) { - _impl_._has_bits_[0] |= 0x00000040u; - } else { - _impl_._has_bits_[0] &= ~0x00000040u; - } - _impl_.messagesecret_.SetAllocated(messagesecret, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.messagesecret_.IsDefault()) { - _impl_.messagesecret_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.messageSecret) -} - -// optional .proto.KeepInChat keepInChat = 50; -inline bool WebMessageInfo::_internal_has_keepinchat() const { - bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0; - PROTOBUF_ASSUME(!value || _impl_.keepinchat_ != nullptr); - return value; -} -inline bool WebMessageInfo::has_keepinchat() const { - return _internal_has_keepinchat(); -} -inline void WebMessageInfo::clear_keepinchat() { - if (_impl_.keepinchat_ != nullptr) _impl_.keepinchat_->Clear(); - _impl_._has_bits_[0] &= ~0x00040000u; -} -inline const ::proto::KeepInChat& WebMessageInfo::_internal_keepinchat() const { - const ::proto::KeepInChat* p = _impl_.keepinchat_; - return p != nullptr ? *p : reinterpret_cast( - ::proto::_KeepInChat_default_instance_); -} -inline const ::proto::KeepInChat& WebMessageInfo::keepinchat() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.keepInChat) - return _internal_keepinchat(); -} -inline void WebMessageInfo::unsafe_arena_set_allocated_keepinchat( - ::proto::KeepInChat* keepinchat) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keepinchat_); - } - _impl_.keepinchat_ = keepinchat; - if (keepinchat) { - _impl_._has_bits_[0] |= 0x00040000u; - } else { - _impl_._has_bits_[0] &= ~0x00040000u; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.keepInChat) -} -inline ::proto::KeepInChat* WebMessageInfo::release_keepinchat() { - _impl_._has_bits_[0] &= ~0x00040000u; - ::proto::KeepInChat* temp = _impl_.keepinchat_; - _impl_.keepinchat_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::proto::KeepInChat* WebMessageInfo::unsafe_arena_release_keepinchat() { - // @@protoc_insertion_point(field_release:proto.WebMessageInfo.keepInChat) - _impl_._has_bits_[0] &= ~0x00040000u; - ::proto::KeepInChat* temp = _impl_.keepinchat_; - _impl_.keepinchat_ = nullptr; - return temp; -} -inline ::proto::KeepInChat* WebMessageInfo::_internal_mutable_keepinchat() { - _impl_._has_bits_[0] |= 0x00040000u; - if (_impl_.keepinchat_ == nullptr) { - auto* p = CreateMaybeMessage<::proto::KeepInChat>(GetArenaForAllocation()); - _impl_.keepinchat_ = p; - } - return _impl_.keepinchat_; -} -inline ::proto::KeepInChat* WebMessageInfo::mutable_keepinchat() { - ::proto::KeepInChat* _msg = _internal_mutable_keepinchat(); - // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.keepInChat) - return _msg; -} -inline void WebMessageInfo::set_allocated_keepinchat(::proto::KeepInChat* keepinchat) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete _impl_.keepinchat_; - } - if (keepinchat) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keepinchat); - if (message_arena != submessage_arena) { - keepinchat = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, keepinchat, submessage_arena); - } - _impl_._has_bits_[0] |= 0x00040000u; - } else { - _impl_._has_bits_[0] &= ~0x00040000u; - } - _impl_.keepinchat_ = keepinchat; - // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.keepInChat) -} - -// optional string originalSelfAuthorUserJidString = 51; -inline bool WebMessageInfo::_internal_has_originalselfauthoruserjidstring() const { - bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0; - return value; -} -inline bool WebMessageInfo::has_originalselfauthoruserjidstring() const { - return _internal_has_originalselfauthoruserjidstring(); -} -inline void WebMessageInfo::clear_originalselfauthoruserjidstring() { - _impl_.originalselfauthoruserjidstring_.ClearToEmpty(); - _impl_._has_bits_[0] &= ~0x00000080u; -} -inline const std::string& WebMessageInfo::originalselfauthoruserjidstring() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.originalSelfAuthorUserJidString) - return _internal_originalselfauthoruserjidstring(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void WebMessageInfo::set_originalselfauthoruserjidstring(ArgT0&& arg0, ArgT... args) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.originalselfauthoruserjidstring_.Set(static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:proto.WebMessageInfo.originalSelfAuthorUserJidString) -} -inline std::string* WebMessageInfo::mutable_originalselfauthoruserjidstring() { - std::string* _s = _internal_mutable_originalselfauthoruserjidstring(); - // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.originalSelfAuthorUserJidString) - return _s; -} -inline const std::string& WebMessageInfo::_internal_originalselfauthoruserjidstring() const { - return _impl_.originalselfauthoruserjidstring_.Get(); -} -inline void WebMessageInfo::_internal_set_originalselfauthoruserjidstring(const std::string& value) { - _impl_._has_bits_[0] |= 0x00000080u; - _impl_.originalselfauthoruserjidstring_.Set(value, GetArenaForAllocation()); -} -inline std::string* WebMessageInfo::_internal_mutable_originalselfauthoruserjidstring() { - _impl_._has_bits_[0] |= 0x00000080u; - return _impl_.originalselfauthoruserjidstring_.Mutable(GetArenaForAllocation()); -} -inline std::string* WebMessageInfo::release_originalselfauthoruserjidstring() { - // @@protoc_insertion_point(field_release:proto.WebMessageInfo.originalSelfAuthorUserJidString) - if (!_internal_has_originalselfauthoruserjidstring()) { - return nullptr; - } - _impl_._has_bits_[0] &= ~0x00000080u; - auto* p = _impl_.originalselfauthoruserjidstring_.Release(); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.originalselfauthoruserjidstring_.IsDefault()) { - _impl_.originalselfauthoruserjidstring_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - return p; -} -inline void WebMessageInfo::set_allocated_originalselfauthoruserjidstring(std::string* originalselfauthoruserjidstring) { - if (originalselfauthoruserjidstring != nullptr) { - _impl_._has_bits_[0] |= 0x00000080u; - } else { - _impl_._has_bits_[0] &= ~0x00000080u; - } - _impl_.originalselfauthoruserjidstring_.SetAllocated(originalselfauthoruserjidstring, GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (_impl_.originalselfauthoruserjidstring_.IsDefault()) { - _impl_.originalselfauthoruserjidstring_.Set("", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.originalSelfAuthorUserJidString) -} - -// optional uint64 revokeMessageTimestamp = 52; -inline bool WebMessageInfo::_internal_has_revokemessagetimestamp() const { - bool value = (_impl_._has_bits_[1] & 0x00000020u) != 0; - return value; -} -inline bool WebMessageInfo::has_revokemessagetimestamp() const { - return _internal_has_revokemessagetimestamp(); -} -inline void WebMessageInfo::clear_revokemessagetimestamp() { - _impl_.revokemessagetimestamp_ = uint64_t{0u}; - _impl_._has_bits_[1] &= ~0x00000020u; -} -inline uint64_t WebMessageInfo::_internal_revokemessagetimestamp() const { - return _impl_.revokemessagetimestamp_; -} -inline uint64_t WebMessageInfo::revokemessagetimestamp() const { - // @@protoc_insertion_point(field_get:proto.WebMessageInfo.revokeMessageTimestamp) - return _internal_revokemessagetimestamp(); -} -inline void WebMessageInfo::_internal_set_revokemessagetimestamp(uint64_t value) { - _impl_._has_bits_[1] |= 0x00000020u; - _impl_.revokemessagetimestamp_ = value; -} -inline void WebMessageInfo::set_revokemessagetimestamp(uint64_t value) { - _internal_set_revokemessagetimestamp(value); - // @@protoc_insertion_point(field_set:proto.WebMessageInfo.revokeMessageTimestamp) -} - -// ------------------------------------------------------------------- - -// WebNotificationsInfo - -// optional uint64 timestamp = 2; -inline bool WebNotificationsInfo::_internal_has_timestamp() const { - bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0; - return value; -} -inline bool WebNotificationsInfo::has_timestamp() const { - return _internal_has_timestamp(); -} -inline void WebNotificationsInfo::clear_timestamp() { - _impl_.timestamp_ = uint64_t{0u}; - _impl_._has_bits_[0] &= ~0x00000001u; -} -inline uint64_t WebNotificationsInfo::_internal_timestamp() const { - return _impl_.timestamp_; -} -inline uint64_t WebNotificationsInfo::timestamp() const { - // @@protoc_insertion_point(field_get:proto.WebNotificationsInfo.timestamp) - return _internal_timestamp(); -} -inline void WebNotificationsInfo::_internal_set_timestamp(uint64_t value) { - _impl_._has_bits_[0] |= 0x00000001u; - _impl_.timestamp_ = value; -} -inline void WebNotificationsInfo::set_timestamp(uint64_t value) { - _internal_set_timestamp(value); - // @@protoc_insertion_point(field_set:proto.WebNotificationsInfo.timestamp) -} - -// optional uint32 unreadChats = 3; -inline bool WebNotificationsInfo::_internal_has_unreadchats() const { - bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0; - return value; -} -inline bool WebNotificationsInfo::has_unreadchats() const { - return _internal_has_unreadchats(); -} -inline void WebNotificationsInfo::clear_unreadchats() { - _impl_.unreadchats_ = 0u; - _impl_._has_bits_[0] &= ~0x00000002u; -} -inline uint32_t WebNotificationsInfo::_internal_unreadchats() const { - return _impl_.unreadchats_; -} -inline uint32_t WebNotificationsInfo::unreadchats() const { - // @@protoc_insertion_point(field_get:proto.WebNotificationsInfo.unreadChats) - return _internal_unreadchats(); -} -inline void WebNotificationsInfo::_internal_set_unreadchats(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000002u; - _impl_.unreadchats_ = value; -} -inline void WebNotificationsInfo::set_unreadchats(uint32_t value) { - _internal_set_unreadchats(value); - // @@protoc_insertion_point(field_set:proto.WebNotificationsInfo.unreadChats) -} - -// optional uint32 notifyMessageCount = 4; -inline bool WebNotificationsInfo::_internal_has_notifymessagecount() const { - bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0; - return value; -} -inline bool WebNotificationsInfo::has_notifymessagecount() const { - return _internal_has_notifymessagecount(); -} -inline void WebNotificationsInfo::clear_notifymessagecount() { - _impl_.notifymessagecount_ = 0u; - _impl_._has_bits_[0] &= ~0x00000004u; -} -inline uint32_t WebNotificationsInfo::_internal_notifymessagecount() const { - return _impl_.notifymessagecount_; -} -inline uint32_t WebNotificationsInfo::notifymessagecount() const { - // @@protoc_insertion_point(field_get:proto.WebNotificationsInfo.notifyMessageCount) - return _internal_notifymessagecount(); -} -inline void WebNotificationsInfo::_internal_set_notifymessagecount(uint32_t value) { - _impl_._has_bits_[0] |= 0x00000004u; - _impl_.notifymessagecount_ = value; -} -inline void WebNotificationsInfo::set_notifymessagecount(uint32_t value) { - _internal_set_notifymessagecount(value); - // @@protoc_insertion_point(field_set:proto.WebNotificationsInfo.notifyMessageCount) -} - -// repeated .proto.WebMessageInfo notifyMessages = 5; -inline int WebNotificationsInfo::_internal_notifymessages_size() const { - return _impl_.notifymessages_.size(); -} -inline int WebNotificationsInfo::notifymessages_size() const { - return _internal_notifymessages_size(); -} -inline void WebNotificationsInfo::clear_notifymessages() { - _impl_.notifymessages_.Clear(); -} -inline ::proto::WebMessageInfo* WebNotificationsInfo::mutable_notifymessages(int index) { - // @@protoc_insertion_point(field_mutable:proto.WebNotificationsInfo.notifyMessages) - return _impl_.notifymessages_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >* -WebNotificationsInfo::mutable_notifymessages() { - // @@protoc_insertion_point(field_mutable_list:proto.WebNotificationsInfo.notifyMessages) - return &_impl_.notifymessages_; -} -inline const ::proto::WebMessageInfo& WebNotificationsInfo::_internal_notifymessages(int index) const { - return _impl_.notifymessages_.Get(index); -} -inline const ::proto::WebMessageInfo& WebNotificationsInfo::notifymessages(int index) const { - // @@protoc_insertion_point(field_get:proto.WebNotificationsInfo.notifyMessages) - return _internal_notifymessages(index); -} -inline ::proto::WebMessageInfo* WebNotificationsInfo::_internal_add_notifymessages() { - return _impl_.notifymessages_.Add(); -} -inline ::proto::WebMessageInfo* WebNotificationsInfo::add_notifymessages() { - ::proto::WebMessageInfo* _add = _internal_add_notifymessages(); - // @@protoc_insertion_point(field_add:proto.WebNotificationsInfo.notifyMessages) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >& -WebNotificationsInfo::notifymessages() const { - // @@protoc_insertion_point(field_list:proto.WebNotificationsInfo.notifyMessages) - return _impl_.notifymessages_; -} - -#ifdef __GNUC__ - #pragma GCC diagnostic pop -#endif // __GNUC__ -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - - -// @@protoc_insertion_point(namespace_scope) - -} // namespace proto - -PROTOBUF_NAMESPACE_OPEN - -template <> struct is_proto_enum< ::proto::BizAccountLinkInfo_AccountType> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::BizAccountLinkInfo_AccountType>() { - return ::proto::BizAccountLinkInfo_AccountType_descriptor(); -} -template <> struct is_proto_enum< ::proto::BizAccountLinkInfo_HostStorageType> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::BizAccountLinkInfo_HostStorageType>() { - return ::proto::BizAccountLinkInfo_HostStorageType_descriptor(); -} -template <> struct is_proto_enum< ::proto::BizIdentityInfo_ActualActorsType> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::BizIdentityInfo_ActualActorsType>() { - return ::proto::BizIdentityInfo_ActualActorsType_descriptor(); -} -template <> struct is_proto_enum< ::proto::BizIdentityInfo_HostStorageType> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::BizIdentityInfo_HostStorageType>() { - return ::proto::BizIdentityInfo_HostStorageType_descriptor(); -} -template <> struct is_proto_enum< ::proto::BizIdentityInfo_VerifiedLevelValue> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::BizIdentityInfo_VerifiedLevelValue>() { - return ::proto::BizIdentityInfo_VerifiedLevelValue_descriptor(); -} -template <> struct is_proto_enum< ::proto::ClientPayload_DNSSource_DNSResolutionMethod> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_DNSSource_DNSResolutionMethod>() { - return ::proto::ClientPayload_DNSSource_DNSResolutionMethod_descriptor(); -} -template <> struct is_proto_enum< ::proto::ClientPayload_UserAgent_Platform> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_UserAgent_Platform>() { - return ::proto::ClientPayload_UserAgent_Platform_descriptor(); -} -template <> struct is_proto_enum< ::proto::ClientPayload_UserAgent_ReleaseChannel> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_UserAgent_ReleaseChannel>() { - return ::proto::ClientPayload_UserAgent_ReleaseChannel_descriptor(); -} -template <> struct is_proto_enum< ::proto::ClientPayload_WebInfo_WebSubPlatform> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_WebInfo_WebSubPlatform>() { - return ::proto::ClientPayload_WebInfo_WebSubPlatform_descriptor(); -} -template <> struct is_proto_enum< ::proto::ClientPayload_ConnectReason> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_ConnectReason>() { - return ::proto::ClientPayload_ConnectReason_descriptor(); -} -template <> struct is_proto_enum< ::proto::ClientPayload_ConnectType> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_ConnectType>() { - return ::proto::ClientPayload_ConnectType_descriptor(); -} -template <> struct is_proto_enum< ::proto::ClientPayload_IOSAppExtension> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_IOSAppExtension>() { - return ::proto::ClientPayload_IOSAppExtension_descriptor(); -} -template <> struct is_proto_enum< ::proto::ClientPayload_Product> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_Product>() { - return ::proto::ClientPayload_Product_descriptor(); -} -template <> struct is_proto_enum< ::proto::ContextInfo_AdReplyInfo_MediaType> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::ContextInfo_AdReplyInfo_MediaType>() { - return ::proto::ContextInfo_AdReplyInfo_MediaType_descriptor(); -} -template <> struct is_proto_enum< ::proto::ContextInfo_ExternalAdReplyInfo_MediaType> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::ContextInfo_ExternalAdReplyInfo_MediaType>() { - return ::proto::ContextInfo_ExternalAdReplyInfo_MediaType_descriptor(); -} -template <> struct is_proto_enum< ::proto::Conversation_EndOfHistoryTransferType> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::Conversation_EndOfHistoryTransferType>() { - return ::proto::Conversation_EndOfHistoryTransferType_descriptor(); -} -template <> struct is_proto_enum< ::proto::DeviceProps_PlatformType> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::DeviceProps_PlatformType>() { - return ::proto::DeviceProps_PlatformType_descriptor(); -} -template <> struct is_proto_enum< ::proto::DisappearingMode_Initiator> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::DisappearingMode_Initiator>() { - return ::proto::DisappearingMode_Initiator_descriptor(); -} -template <> struct is_proto_enum< ::proto::GroupParticipant_Rank> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::GroupParticipant_Rank>() { - return ::proto::GroupParticipant_Rank_descriptor(); -} -template <> struct is_proto_enum< ::proto::HistorySync_HistorySyncType> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::HistorySync_HistorySyncType>() { - return ::proto::HistorySync_HistorySyncType_descriptor(); -} -template <> struct is_proto_enum< ::proto::MediaRetryNotification_ResultType> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::MediaRetryNotification_ResultType>() { - return ::proto::MediaRetryNotification_ResultType_descriptor(); -} -template <> struct is_proto_enum< ::proto::Message_ButtonsMessage_Button_Type> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ButtonsMessage_Button_Type>() { - return ::proto::Message_ButtonsMessage_Button_Type_descriptor(); -} -template <> struct is_proto_enum< ::proto::Message_ButtonsMessage_HeaderType> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ButtonsMessage_HeaderType>() { - return ::proto::Message_ButtonsMessage_HeaderType_descriptor(); -} -template <> struct is_proto_enum< ::proto::Message_ButtonsResponseMessage_Type> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ButtonsResponseMessage_Type>() { - return ::proto::Message_ButtonsResponseMessage_Type_descriptor(); -} -template <> struct is_proto_enum< ::proto::Message_ExtendedTextMessage_FontType> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ExtendedTextMessage_FontType>() { - return ::proto::Message_ExtendedTextMessage_FontType_descriptor(); -} -template <> struct is_proto_enum< ::proto::Message_ExtendedTextMessage_InviteLinkGroupType> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ExtendedTextMessage_InviteLinkGroupType>() { - return ::proto::Message_ExtendedTextMessage_InviteLinkGroupType_descriptor(); -} -template <> struct is_proto_enum< ::proto::Message_ExtendedTextMessage_PreviewType> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ExtendedTextMessage_PreviewType>() { - return ::proto::Message_ExtendedTextMessage_PreviewType_descriptor(); -} -template <> struct is_proto_enum< ::proto::Message_GroupInviteMessage_GroupType> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_GroupInviteMessage_GroupType>() { - return ::proto::Message_GroupInviteMessage_GroupType_descriptor(); -} -template <> struct is_proto_enum< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType>() { - return ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_descriptor(); -} -template <> struct is_proto_enum< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType>() { - return ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_descriptor(); -} -template <> struct is_proto_enum< ::proto::Message_HistorySyncNotification_HistorySyncType> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_HistorySyncNotification_HistorySyncType>() { - return ::proto::Message_HistorySyncNotification_HistorySyncType_descriptor(); -} -template <> struct is_proto_enum< ::proto::Message_InteractiveMessage_ShopMessage_Surface> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_InteractiveMessage_ShopMessage_Surface>() { - return ::proto::Message_InteractiveMessage_ShopMessage_Surface_descriptor(); -} -template <> struct is_proto_enum< ::proto::Message_InvoiceMessage_AttachmentType> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_InvoiceMessage_AttachmentType>() { - return ::proto::Message_InvoiceMessage_AttachmentType_descriptor(); -} -template <> struct is_proto_enum< ::proto::Message_ListMessage_ListType> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ListMessage_ListType>() { - return ::proto::Message_ListMessage_ListType_descriptor(); -} -template <> struct is_proto_enum< ::proto::Message_ListResponseMessage_ListType> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ListResponseMessage_ListType>() { - return ::proto::Message_ListResponseMessage_ListType_descriptor(); -} -template <> struct is_proto_enum< ::proto::Message_OrderMessage_OrderStatus> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_OrderMessage_OrderStatus>() { - return ::proto::Message_OrderMessage_OrderStatus_descriptor(); -} -template <> struct is_proto_enum< ::proto::Message_OrderMessage_OrderSurface> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_OrderMessage_OrderSurface>() { - return ::proto::Message_OrderMessage_OrderSurface_descriptor(); -} -template <> struct is_proto_enum< ::proto::Message_PaymentInviteMessage_ServiceType> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_PaymentInviteMessage_ServiceType>() { - return ::proto::Message_PaymentInviteMessage_ServiceType_descriptor(); -} -template <> struct is_proto_enum< ::proto::Message_ProtocolMessage_Type> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ProtocolMessage_Type>() { - return ::proto::Message_ProtocolMessage_Type_descriptor(); -} -template <> struct is_proto_enum< ::proto::Message_VideoMessage_Attribution> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_VideoMessage_Attribution>() { - return ::proto::Message_VideoMessage_Attribution_descriptor(); -} -template <> struct is_proto_enum< ::proto::Message_RmrSource> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_RmrSource>() { - return ::proto::Message_RmrSource_descriptor(); -} -template <> struct is_proto_enum< ::proto::PastParticipant_LeaveReason> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::PastParticipant_LeaveReason>() { - return ::proto::PastParticipant_LeaveReason_descriptor(); -} -template <> struct is_proto_enum< ::proto::PaymentBackground_Type> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::PaymentBackground_Type>() { - return ::proto::PaymentBackground_Type_descriptor(); -} -template <> struct is_proto_enum< ::proto::PaymentInfo_Currency> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::PaymentInfo_Currency>() { - return ::proto::PaymentInfo_Currency_descriptor(); -} -template <> struct is_proto_enum< ::proto::PaymentInfo_Status> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::PaymentInfo_Status>() { - return ::proto::PaymentInfo_Status_descriptor(); -} -template <> struct is_proto_enum< ::proto::PaymentInfo_TxnStatus> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::PaymentInfo_TxnStatus>() { - return ::proto::PaymentInfo_TxnStatus_descriptor(); -} -template <> struct is_proto_enum< ::proto::SyncdMutation_SyncdOperation> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::SyncdMutation_SyncdOperation>() { - return ::proto::SyncdMutation_SyncdOperation_descriptor(); -} -template <> struct is_proto_enum< ::proto::WebFeatures_Flag> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::WebFeatures_Flag>() { - return ::proto::WebFeatures_Flag_descriptor(); -} -template <> struct is_proto_enum< ::proto::WebMessageInfo_BizPrivacyStatus> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::WebMessageInfo_BizPrivacyStatus>() { - return ::proto::WebMessageInfo_BizPrivacyStatus_descriptor(); -} -template <> struct is_proto_enum< ::proto::WebMessageInfo_Status> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::WebMessageInfo_Status>() { - return ::proto::WebMessageInfo_Status_descriptor(); -} -template <> struct is_proto_enum< ::proto::WebMessageInfo_StubType> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::WebMessageInfo_StubType>() { - return ::proto::WebMessageInfo_StubType_descriptor(); -} -template <> struct is_proto_enum< ::proto::KeepType> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::KeepType>() { - return ::proto::KeepType_descriptor(); -} -template <> struct is_proto_enum< ::proto::MediaVisibility> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::proto::MediaVisibility>() { - return ::proto::MediaVisibility_descriptor(); -} - -PROTOBUF_NAMESPACE_CLOSE - -// @@protoc_insertion_point(global_scope) - -#include -#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_pmsg_2eproto diff --git a/protocols/WhatsAppWeb/src/pmsg.proto b/protocols/WhatsAppWeb/src/pmsg.proto deleted file mode 100644 index e874f35591..0000000000 --- a/protocols/WhatsAppWeb/src/pmsg.proto +++ /dev/null @@ -1,2361 +0,0 @@ -syntax = "proto2"; -package proto; - -message ADVDeviceIdentity { - optional uint32 rawId = 1; - optional uint64 timestamp = 2; - optional uint32 keyIndex = 3; -} - -message ADVKeyIndexList { - optional uint32 rawId = 1; - optional uint64 timestamp = 2; - optional uint32 currentIndex = 3; - repeated uint32 validIndexes = 4 [packed=true]; -} - -message ADVSignedDeviceIdentity { - optional bytes details = 1; - optional bytes accountSignatureKey = 2; - optional bytes accountSignature = 3; - optional bytes deviceSignature = 4; -} - -message ADVSignedDeviceIdentityHMAC { - optional bytes details = 1; - optional bytes hmac = 2; -} - -message ADVSignedKeyIndexList { - optional bytes details = 1; - optional bytes accountSignature = 2; -} - -message ActionLink { - optional string url = 1; - optional string buttonTitle = 2; -} - -message AutoDownloadSettings { - optional bool downloadImages = 1; - optional bool downloadAudio = 2; - optional bool downloadVideo = 3; - optional bool downloadDocuments = 4; -} - -message BizAccountLinkInfo { - optional uint64 whatsappBizAcctFbid = 1; - optional string whatsappAcctNumber = 2; - optional uint64 issueTime = 3; - optional HostStorageType hostStorage = 4; - optional AccountType accountType = 5; - enum AccountType { - ENTERPRISE = 0; - } - enum HostStorageType { - ON_PREMISE = 0; - FACEBOOK = 1; - } -} - -message BizAccountPayload { - optional VerifiedNameCertificate vnameCert = 1; - optional bytes bizAcctLinkInfo = 2; -} - -message BizIdentityInfo { - optional VerifiedLevelValue vlevel = 1; - optional VerifiedNameCertificate vnameCert = 2; - optional bool signed = 3; - optional bool revoked = 4; - optional HostStorageType hostStorage = 5; - optional ActualActorsType actualActors = 6; - optional uint64 privacyModeTs = 7; - optional uint64 featureControls = 8; - enum ActualActorsType { - SELF = 0; - BSP = 1; - } - enum HostStorageType { - ON_PREMISE = 0; - FACEBOOK = 1; - } - enum VerifiedLevelValue { - UNKNOWN = 0; - LOW = 1; - HIGH = 2; - } -} - -message CertChain { - optional NoiseCertificate leaf = 1; - optional NoiseCertificate intermediate = 2; - message NoiseCertificate { - optional bytes details = 1; - optional bytes signature = 2; - message Details { - optional uint32 serial = 1; - optional uint32 issuerSerial = 2; - optional bytes key = 3; - optional uint64 notBefore = 4; - optional uint64 notAfter = 5; - } - - } - -} - -message Chain { - optional bytes senderRatchetKey = 1; - optional bytes senderRatchetKeyPrivate = 2; - optional ChainKey chainKey = 3; - repeated MessageKey messageKeys = 4; -} - -message ChainKey { - optional uint32 index = 1; - optional bytes key = 2; -} - -message ClientPayload { - optional uint64 username = 1; - optional bool passive = 3; - optional UserAgent userAgent = 5; - optional WebInfo webInfo = 6; - optional string pushName = 7; - optional sfixed32 sessionId = 9; - optional bool shortConnect = 10; - optional ConnectType connectType = 12; - optional ConnectReason connectReason = 13; - repeated int32 shards = 14; - optional DNSSource dnsSource = 15; - optional uint32 connectAttemptCount = 16; - optional uint32 device = 18; - optional DevicePairingRegistrationData devicePairingData = 19; - optional Product product = 20; - optional bytes fbCat = 21; - optional bytes fbUserAgent = 22; - optional bool oc = 23; - optional int32 lc = 24; - optional IOSAppExtension iosAppExtension = 30; - optional uint64 fbAppId = 31; - optional bytes fbDeviceId = 32; - optional bool pull = 33; - optional bytes paddingBytes = 34; - enum ConnectReason { - PUSH = 0; - USER_ACTIVATED = 1; - SCHEDULED = 2; - ERROR_RECONNECT = 3; - NETWORK_SWITCH = 4; - PING_RECONNECT = 5; - } - enum ConnectType { - CELLULAR_UNKNOWN = 0; - WIFI_UNKNOWN = 1; - CELLULAR_EDGE = 100; - CELLULAR_IDEN = 101; - CELLULAR_UMTS = 102; - CELLULAR_EVDO = 103; - CELLULAR_GPRS = 104; - CELLULAR_HSDPA = 105; - CELLULAR_HSUPA = 106; - CELLULAR_HSPA = 107; - CELLULAR_CDMA = 108; - CELLULAR_1XRTT = 109; - CELLULAR_EHRPD = 110; - CELLULAR_LTE = 111; - CELLULAR_HSPAP = 112; - } - message DNSSource { - optional DNSResolutionMethod dnsMethod = 15; - optional bool appCached = 16; - enum DNSResolutionMethod { - SYSTEM = 0; - GOOGLE = 1; - HARDCODED = 2; - OVERRIDE = 3; - FALLBACK = 4; - } - } - - message DevicePairingRegistrationData { - optional bytes eRegid = 1; - optional bytes eKeytype = 2; - optional bytes eIdent = 3; - optional bytes eSkeyId = 4; - optional bytes eSkeyVal = 5; - optional bytes eSkeySig = 6; - optional bytes buildHash = 7; - optional bytes deviceProps = 8; - } - - enum IOSAppExtension { - SHARE_EXTENSION = 0; - SERVICE_EXTENSION = 1; - INTENTS_EXTENSION = 2; - } - enum Product { - WHATSAPP = 0; - MESSENGER = 1; - } - message UserAgent { - optional Platform platform = 1; - optional AppVersion appVersion = 2; - optional string mcc = 3; - optional string mnc = 4; - optional string osVersion = 5; - optional string manufacturer = 6; - optional string device = 7; - optional string osBuildNumber = 8; - optional string phoneId = 9; - optional ReleaseChannel releaseChannel = 10; - optional string localeLanguageIso6391 = 11; - optional string localeCountryIso31661Alpha2 = 12; - optional string deviceBoard = 13; - message AppVersion { - optional uint32 primary = 1; - optional uint32 secondary = 2; - optional uint32 tertiary = 3; - optional uint32 quaternary = 4; - optional uint32 quinary = 5; - } - - enum Platform { - ANDROID = 0; - IOS = 1; - WINDOWS_PHONE = 2; - BLACKBERRY = 3; - BLACKBERRYX = 4; - S40 = 5; - S60 = 6; - PYTHON_CLIENT = 7; - TIZEN = 8; - ENTERPRISE = 9; - SMB_ANDROID = 10; - KAIOS = 11; - SMB_IOS = 12; - WINDOWS = 13; - WEB = 14; - PORTAL = 15; - GREEN_ANDROID = 16; - GREEN_IPHONE = 17; - BLUE_ANDROID = 18; - BLUE_IPHONE = 19; - FBLITE_ANDROID = 20; - MLITE_ANDROID = 21; - IGLITE_ANDROID = 22; - PAGE = 23; - MACOS = 24; - OCULUS_MSG = 25; - OCULUS_CALL = 26; - MILAN = 27; - CAPI = 28; - } - enum ReleaseChannel { - RELEASE = 0; - BETA = 1; - ALPHA = 2; - DEBUG = 3; - } - } - - message WebInfo { - optional string refToken = 1; - optional string version = 2; - optional WebdPayload webdPayload = 3; - optional WebSubPlatform webSubPlatform = 4; - enum WebSubPlatform { - WEB_BROWSER = 0; - APP_STORE = 1; - WIN_STORE = 2; - DARWIN = 3; - WINDA = 4; - } - message WebdPayload { - optional bool usesParticipantInKey = 1; - optional bool supportsStarredMessages = 2; - optional bool supportsDocumentMessages = 3; - optional bool supportsUrlMessages = 4; - optional bool supportsMediaRetry = 5; - optional bool supportsE2EImage = 6; - optional bool supportsE2EVideo = 7; - optional bool supportsE2EAudio = 8; - optional bool supportsE2EDocument = 9; - optional string documentTypes = 10; - optional bytes features = 11; - } - - } - -} - -message ContextInfo { - optional string stanzaId = 1; - optional string participant = 2; - optional Message quotedMessage = 3; - optional string remoteJid = 4; - repeated string mentionedJid = 15; - optional string conversionSource = 18; - optional bytes conversionData = 19; - optional uint32 conversionDelaySeconds = 20; - optional uint32 forwardingScore = 21; - optional bool isForwarded = 22; - optional AdReplyInfo quotedAd = 23; - optional MessageKey placeholderKey = 24; - optional uint32 expiration = 25; - optional int64 ephemeralSettingTimestamp = 26; - optional bytes ephemeralSharedSecret = 27; - optional ExternalAdReplyInfo externalAdReply = 28; - optional string entryPointConversionSource = 29; - optional string entryPointConversionApp = 30; - optional uint32 entryPointConversionDelaySeconds = 31; - optional DisappearingMode disappearingMode = 32; - optional ActionLink actionLink = 33; - optional string groupSubject = 34; - optional string parentGroupJid = 35; - message AdReplyInfo { - optional string advertiserName = 1; - optional MediaType mediaType = 2; - optional bytes jpegThumbnail = 16; - optional string caption = 17; - enum MediaType { - NONE = 0; - IMAGE = 1; - VIDEO = 2; - } - } - - message ExternalAdReplyInfo { - optional string title = 1; - optional string body = 2; - optional MediaType mediaType = 3; - optional string thumbnailUrl = 4; - optional string mediaUrl = 5; - optional bytes thumbnail = 6; - optional string sourceType = 7; - optional string sourceId = 8; - optional string sourceUrl = 9; - optional bool containsAutoReply = 10; - optional bool renderLargerThumbnail = 11; - optional bool showAdAttribution = 12; - enum MediaType { - NONE = 0; - IMAGE = 1; - VIDEO = 2; - } - } - -} - -message Conversation { - required string id = 1; - repeated HistorySyncMsg messages = 2; - optional string newJid = 3; - optional string oldJid = 4; - optional uint64 lastMsgTimestamp = 5; - optional uint32 unreadCount = 6; - optional bool readOnly = 7; - optional bool endOfHistoryTransfer = 8; - optional uint32 ephemeralExpiration = 9; - optional int64 ephemeralSettingTimestamp = 10; - optional EndOfHistoryTransferType endOfHistoryTransferType = 11; - optional uint64 conversationTimestamp = 12; - optional string name = 13; - optional string pHash = 14; - optional bool notSpam = 15; - optional bool archived = 16; - optional DisappearingMode disappearingMode = 17; - optional uint32 unreadMentionCount = 18; - optional bool markedAsUnread = 19; - repeated GroupParticipant participant = 20; - optional bytes tcToken = 21; - optional uint64 tcTokenTimestamp = 22; - optional bytes contactPrimaryIdentityKey = 23; - optional uint32 pinned = 24; - optional uint64 muteEndTime = 25; - optional WallpaperSettings wallpaper = 26; - optional MediaVisibility mediaVisibility = 27; - optional uint64 tcTokenSenderTimestamp = 28; - optional bool suspended = 29; - optional bool terminated = 30; - optional uint64 createdAt = 31; - optional string createdBy = 32; - optional string description = 33; - optional bool support = 34; - optional bool isParentGroup = 35; - optional bool isDefaultSubgroup = 36; - optional string parentGroupId = 37; - optional string displayName = 38; - optional string pnJid = 39; - optional bool selfPnExposed = 40; - enum EndOfHistoryTransferType { - COMPLETE_BUT_MORE_MESSAGES_REMAIN_ON_PRIMARY = 0; - COMPLETE_AND_NO_MORE_MESSAGE_REMAIN_ON_PRIMARY = 1; - } -} - -message DeviceListMetadata { - optional bytes senderKeyHash = 1; - optional uint64 senderTimestamp = 2; - repeated uint32 senderKeyIndexes = 3 [packed=true]; - optional bytes recipientKeyHash = 8; - optional uint64 recipientTimestamp = 9; - repeated uint32 recipientKeyIndexes = 10 [packed=true]; -} - -message DeviceProps { - optional string os = 1; - optional AppVersion version = 2; - optional PlatformType platformType = 3; - optional bool requireFullSync = 4; - message AppVersion { - optional uint32 primary = 1; - optional uint32 secondary = 2; - optional uint32 tertiary = 3; - optional uint32 quaternary = 4; - optional uint32 quinary = 5; - } - - enum PlatformType { - UNKNOWN = 0; - CHROME = 1; - FIREFOX = 2; - IE = 3; - OPERA = 4; - SAFARI = 5; - EDGE = 6; - DESKTOP = 7; - IPAD = 8; - ANDROID_TABLET = 9; - OHANA = 10; - ALOHA = 11; - CATALINA = 12; - TCL_TV = 13; - } -} - -message DisappearingMode { - optional Initiator initiator = 1; - enum Initiator { - CHANGED_IN_CHAT = 0; - INITIATED_BY_ME = 1; - INITIATED_BY_OTHER = 2; - } -} - -message EphemeralSetting { - optional sfixed32 duration = 1; - optional sfixed64 timestamp = 2; -} - -message ExitCode { - optional uint64 code = 1; - optional string text = 2; -} - -message ExternalBlobReference { - optional bytes mediaKey = 1; - optional string directPath = 2; - optional string handle = 3; - optional uint64 fileSizeBytes = 4; - optional bytes fileSha256 = 5; - optional bytes fileEncSha256 = 6; -} - -message GlobalSettings { - optional WallpaperSettings lightThemeWallpaper = 1; - optional MediaVisibility mediaVisibility = 2; - optional WallpaperSettings darkThemeWallpaper = 3; - optional AutoDownloadSettings autoDownloadWiFi = 4; - optional AutoDownloadSettings autoDownloadCellular = 5; - optional AutoDownloadSettings autoDownloadRoaming = 6; - optional bool showIndividualNotificationsPreview = 7; - optional bool showGroupNotificationsPreview = 8; - optional int32 disappearingModeDuration = 9; - optional int64 disappearingModeTimestamp = 10; -} - -message GroupParticipant { - required string userJid = 1; - optional Rank rank = 2; - enum Rank { - REGULAR = 0; - ADMIN = 1; - SUPERADMIN = 2; - } -} - -message HandshakeMessage { - optional ClientHello clientHello = 2; - optional ServerHello serverHello = 3; - optional ClientFinish clientFinish = 4; - message ClientFinish { - optional bytes static = 1; - optional bytes payload = 2; - } - - message ClientHello { - optional bytes ephemeral = 1; - optional bytes static = 2; - optional bytes payload = 3; - } - - message ServerHello { - optional bytes ephemeral = 1; - optional bytes static = 2; - optional bytes payload = 3; - } - -} - -message HistorySync { - required HistorySyncType syncType = 1; - repeated Conversation conversations = 2; - repeated WebMessageInfo statusV3Messages = 3; - optional uint32 chunkOrder = 5; - optional uint32 progress = 6; - repeated Pushname pushnames = 7; - optional GlobalSettings globalSettings = 8; - optional bytes threadIdUserSecret = 9; - optional uint32 threadDsTimeframeOffset = 10; - repeated StickerMetadata recentStickers = 11; - repeated PastParticipants pastParticipants = 12; - enum HistorySyncType { - INITIAL_BOOTSTRAP = 0; - INITIAL_STATUS_V3 = 1; - FULL = 2; - RECENT = 3; - PUSH_NAME = 4; - UNBLOCKING_DATA = 5; - } -} - -message HistorySyncMsg { - optional WebMessageInfo message = 1; - optional uint64 msgOrderId = 2; -} - -message HydratedTemplateButton { - optional uint32 index = 4; - oneof hydratedButton { - HydratedTemplateButton.HydratedQuickReplyButton quickReplyButton = 1; - HydratedTemplateButton.HydratedURLButton urlButton = 2; - HydratedTemplateButton.HydratedCallButton callButton = 3; - } - message HydratedCallButton { - optional string displayText = 1; - optional string phoneNumber = 2; - } - - message HydratedQuickReplyButton { - optional string displayText = 1; - optional string id = 2; - } - - message HydratedURLButton { - optional string displayText = 1; - optional string url = 2; - } - -} - -message IdentityKeyPairStructure { - optional bytes publicKey = 1; - optional bytes privateKey = 2; -} - -message InteractiveAnnotation { - repeated Point polygonVertices = 1; - oneof action { - Location location = 2; - } -} - -message KeepInChat { - optional KeepType keepType = 1; - optional int64 serverTimestamp = 2; - optional MessageKey key = 3; - optional string deviceJid = 4; -} - -enum KeepType { - UNKNOWN = 0; - KEEP_FOR_ALL = 1; - UNDO_KEEP_FOR_ALL = 2; -} -message KeyId { - optional bytes id = 1; -} - -message LocalizedName { - optional string lg = 1; - optional string lc = 2; - optional string verifiedName = 3; -} - -message Location { - optional double degreesLatitude = 1; - optional double degreesLongitude = 2; - optional string name = 3; -} - -message MediaData { - optional string localPath = 1; -} - -message MediaRetryNotification { - optional string stanzaId = 1; - optional string directPath = 2; - optional ResultType result = 3; - enum ResultType { - GENERAL_ERROR = 0; - SUCCESS = 1; - NOT_FOUND = 2; - DECRYPTION_ERROR = 3; - } -} - -enum MediaVisibility { - DEFAULT = 0; - OFF = 1; - ON = 2; -} -message Message { - optional string conversation = 1; - optional SenderKeyDistributionMessage senderKeyDistributionMessage = 2; - optional ImageMessage imageMessage = 3; - optional ContactMessage contactMessage = 4; - optional LocationMessage locationMessage = 5; - optional ExtendedTextMessage extendedTextMessage = 6; - optional DocumentMessage documentMessage = 7; - optional AudioMessage audioMessage = 8; - optional VideoMessage videoMessage = 9; - optional Call call = 10; - optional Chat chat = 11; - optional ProtocolMessage protocolMessage = 12; - optional ContactsArrayMessage contactsArrayMessage = 13; - optional HighlyStructuredMessage highlyStructuredMessage = 14; - optional SenderKeyDistributionMessage fastRatchetKeySenderKeyDistributionMessage = 15; - optional SendPaymentMessage sendPaymentMessage = 16; - optional LiveLocationMessage liveLocationMessage = 18; - optional RequestPaymentMessage requestPaymentMessage = 22; - optional DeclinePaymentRequestMessage declinePaymentRequestMessage = 23; - optional CancelPaymentRequestMessage cancelPaymentRequestMessage = 24; - optional TemplateMessage templateMessage = 25; - optional StickerMessage stickerMessage = 26; - optional GroupInviteMessage groupInviteMessage = 28; - optional TemplateButtonReplyMessage templateButtonReplyMessage = 29; - optional ProductMessage productMessage = 30; - optional DeviceSentMessage deviceSentMessage = 31; - optional MessageContextInfo messageContextInfo = 35; - optional ListMessage listMessage = 36; - optional FutureProofMessage viewOnceMessage = 37; - optional OrderMessage orderMessage = 38; - optional ListResponseMessage listResponseMessage = 39; - optional FutureProofMessage ephemeralMessage = 40; - optional InvoiceMessage invoiceMessage = 41; - optional ButtonsMessage buttonsMessage = 42; - optional ButtonsResponseMessage buttonsResponseMessage = 43; - optional PaymentInviteMessage paymentInviteMessage = 44; - optional InteractiveMessage interactiveMessage = 45; - optional ReactionMessage reactionMessage = 46; - optional StickerSyncRMRMessage stickerSyncRmrMessage = 47; - optional InteractiveResponseMessage interactiveResponseMessage = 48; - optional PollCreationMessage pollCreationMessage = 49; - optional PollUpdateMessage pollUpdateMessage = 50; - optional KeepInChatMessage keepInChatMessage = 51; - optional FutureProofMessage documentWithCaptionMessage = 53; - optional RequestPhoneNumberMessage requestPhoneNumberMessage = 54; - optional FutureProofMessage viewOnceMessageV2 = 55; - message AppStateFatalExceptionNotification { - repeated string collectionNames = 1; - optional int64 timestamp = 2; - } - - message AppStateSyncKeyData { - optional bytes keyData = 1; - optional Message.AppStateSyncKeyFingerprint fingerprint = 2; - optional int64 timestamp = 3; - } - - message AppStateSyncKeyFingerprint { - optional uint32 rawId = 1; - optional uint32 currentIndex = 2; - repeated uint32 deviceIndexes = 3 [packed=true]; - } - - message AppStateSyncKeyId { - optional bytes keyId = 1; - } - - message AppStateSyncKeyRequest { - repeated Message.AppStateSyncKeyId keyIds = 1; - } - - message AppStateSyncKeyShare { - repeated Message.AppStateSyncKey keys = 1; - } - - message AppStateSyncKey { - optional Message.AppStateSyncKeyId keyId = 1; - optional Message.AppStateSyncKeyData keyData = 2; - } - - message AudioMessage { - optional string url = 1; - optional string mimetype = 2; - optional bytes fileSha256 = 3; - optional uint64 fileLength = 4; - optional uint32 seconds = 5; - optional bool ptt = 6; - optional bytes mediaKey = 7; - optional bytes fileEncSha256 = 8; - optional string directPath = 9; - optional int64 mediaKeyTimestamp = 10; - optional ContextInfo contextInfo = 17; - optional bytes streamingSidecar = 18; - optional bytes waveform = 19; - } - - message ButtonsMessage { - optional string contentText = 6; - optional string footerText = 7; - optional ContextInfo contextInfo = 8; - repeated Button buttons = 9; - optional HeaderType headerType = 10; - oneof header { - string text = 1; - Message.DocumentMessage documentMessage = 2; - Message.ImageMessage imageMessage = 3; - Message.VideoMessage videoMessage = 4; - Message.LocationMessage locationMessage = 5; - } - message Button { - optional string buttonId = 1; - optional ButtonText buttonText = 2; - optional Type type = 3; - optional NativeFlowInfo nativeFlowInfo = 4; - message ButtonText { - optional string displayText = 1; - } - - message NativeFlowInfo { - optional string name = 1; - optional string paramsJson = 2; - } - - enum Type { - UNKNOWN = 0; - RESPONSE = 1; - NATIVE_FLOW = 2; - } - } - - enum HeaderType { - UNKNOWN = 0; - EMPTY = 1; - TEXT = 2; - DOCUMENT = 3; - IMAGE = 4; - VIDEO = 5; - LOCATION = 6; - } - } - - message ButtonsResponseMessage { - optional string selectedButtonId = 1; - optional ContextInfo contextInfo = 3; - optional Type type = 4; - oneof response { - string selectedDisplayText = 2; - } - enum Type { - UNKNOWN = 0; - DISPLAY_TEXT = 1; - } - } - - message Call { - optional bytes callKey = 1; - optional string conversionSource = 2; - optional bytes conversionData = 3; - optional uint32 conversionDelaySeconds = 4; - } - - message CancelPaymentRequestMessage { - optional MessageKey key = 1; - } - - message Chat { - optional string displayName = 1; - optional string id = 2; - } - - message ContactMessage { - optional string displayName = 1; - optional string vcard = 16; - optional ContextInfo contextInfo = 17; - } - - message ContactsArrayMessage { - optional string displayName = 1; - repeated Message.ContactMessage contacts = 2; - optional ContextInfo contextInfo = 17; - } - - message DeclinePaymentRequestMessage { - optional MessageKey key = 1; - } - - message DeviceSentMessage { - optional string destinationJid = 1; - optional Message message = 2; - optional string phash = 3; - } - - message DocumentMessage { - optional string url = 1; - optional string mimetype = 2; - optional string title = 3; - optional bytes fileSha256 = 4; - optional uint64 fileLength = 5; - optional uint32 pageCount = 6; - optional bytes mediaKey = 7; - optional string fileName = 8; - optional bytes fileEncSha256 = 9; - optional string directPath = 10; - optional int64 mediaKeyTimestamp = 11; - optional bool contactVcard = 12; - optional string thumbnailDirectPath = 13; - optional bytes thumbnailSha256 = 14; - optional bytes thumbnailEncSha256 = 15; - optional bytes jpegThumbnail = 16; - optional ContextInfo contextInfo = 17; - optional uint32 thumbnailHeight = 18; - optional uint32 thumbnailWidth = 19; - optional string caption = 20; - } - - message ExtendedTextMessage { - optional string text = 1; - optional string matchedText = 2; - optional string canonicalUrl = 4; - optional string description = 5; - optional string title = 6; - optional fixed32 textArgb = 7; - optional fixed32 backgroundArgb = 8; - optional FontType font = 9; - optional PreviewType previewType = 10; - optional bytes jpegThumbnail = 16; - optional ContextInfo contextInfo = 17; - optional bool doNotPlayInline = 18; - optional string thumbnailDirectPath = 19; - optional bytes thumbnailSha256 = 20; - optional bytes thumbnailEncSha256 = 21; - optional bytes mediaKey = 22; - optional int64 mediaKeyTimestamp = 23; - optional uint32 thumbnailHeight = 24; - optional uint32 thumbnailWidth = 25; - optional InviteLinkGroupType inviteLinkGroupType = 26; - optional string inviteLinkParentGroupSubjectV2 = 27; - optional bytes inviteLinkParentGroupThumbnailV2 = 28; - optional InviteLinkGroupType inviteLinkGroupTypeV2 = 29; - enum FontType { - SANS_SERIF = 0; - SERIF = 1; - NORICAN_REGULAR = 2; - BRYNDAN_WRITE = 3; - BEBASNEUE_REGULAR = 4; - OSWALD_HEAVY = 5; - } - enum InviteLinkGroupType { - DEFAULT = 0; - PARENT = 1; - SUB = 2; - DEFAULT_SUB = 3; - } - enum PreviewType { - NONE = 0; - VIDEO = 1; - } - } - - message FutureProofMessage { - optional Message message = 1; - } - - message GroupInviteMessage { - optional string groupJid = 1; - optional string inviteCode = 2; - optional int64 inviteExpiration = 3; - optional string groupName = 4; - optional bytes jpegThumbnail = 5; - optional string caption = 6; - optional ContextInfo contextInfo = 7; - optional GroupType groupType = 8; - enum GroupType { - DEFAULT = 0; - PARENT = 1; - } - } - - message HighlyStructuredMessage { - optional string namespace = 1; - optional string elementName = 2; - repeated string params = 3; - optional string fallbackLg = 4; - optional string fallbackLc = 5; - repeated HSMLocalizableParameter localizableParams = 6; - optional string deterministicLg = 7; - optional string deterministicLc = 8; - optional Message.TemplateMessage hydratedHsm = 9; - message HSMLocalizableParameter { - optional string default = 1; - oneof paramOneof { - Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency currency = 2; - Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime dateTime = 3; - } - message HSMCurrency { - optional string currencyCode = 1; - optional int64 amount1000 = 2; - } - - message HSMDateTime { - oneof datetimeOneof { - Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent component = 1; - Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch unixEpoch = 2; - } - message HSMDateTimeComponent { - optional DayOfWeekType dayOfWeek = 1; - optional uint32 year = 2; - optional uint32 month = 3; - optional uint32 dayOfMonth = 4; - optional uint32 hour = 5; - optional uint32 minute = 6; - optional CalendarType calendar = 7; - enum CalendarType { - GREGORIAN = 1; - SOLAR_HIJRI = 2; - } - enum DayOfWeekType { - MONDAY = 1; - TUESDAY = 2; - WEDNESDAY = 3; - THURSDAY = 4; - FRIDAY = 5; - SATURDAY = 6; - SUNDAY = 7; - } - } - - message HSMDateTimeUnixEpoch { - optional int64 timestamp = 1; - } - - } - - } - - } - - message HistorySyncNotification { - optional bytes fileSha256 = 1; - optional uint64 fileLength = 2; - optional bytes mediaKey = 3; - optional bytes fileEncSha256 = 4; - optional string directPath = 5; - optional HistorySyncType syncType = 6; - optional uint32 chunkOrder = 7; - optional string originalMessageId = 8; - optional uint32 progress = 9; - enum HistorySyncType { - INITIAL_BOOTSTRAP = 0; - INITIAL_STATUS_V3 = 1; - FULL = 2; - RECENT = 3; - PUSH_NAME = 4; - } - } - - message ImageMessage { - optional string url = 1; - optional string mimetype = 2; - optional string caption = 3; - optional bytes fileSha256 = 4; - optional uint64 fileLength = 5; - optional uint32 height = 6; - optional uint32 width = 7; - optional bytes mediaKey = 8; - optional bytes fileEncSha256 = 9; - repeated InteractiveAnnotation interactiveAnnotations = 10; - optional string directPath = 11; - optional int64 mediaKeyTimestamp = 12; - optional bytes jpegThumbnail = 16; - optional ContextInfo contextInfo = 17; - optional bytes firstScanSidecar = 18; - optional uint32 firstScanLength = 19; - optional uint32 experimentGroupId = 20; - optional bytes scansSidecar = 21; - repeated uint32 scanLengths = 22; - optional bytes midQualityFileSha256 = 23; - optional bytes midQualityFileEncSha256 = 24; - optional bool viewOnce = 25; - optional string thumbnailDirectPath = 26; - optional bytes thumbnailSha256 = 27; - optional bytes thumbnailEncSha256 = 28; - optional string staticUrl = 29; - } - - message InitialSecurityNotificationSettingSync { - optional bool securityNotificationEnabled = 1; - } - - message InteractiveMessage { - optional Header header = 1; - optional Body body = 2; - optional Footer footer = 3; - optional ContextInfo contextInfo = 15; - oneof interactiveMessage { - Message.InteractiveMessage.ShopMessage shopStorefrontMessage = 4; - Message.InteractiveMessage.CollectionMessage collectionMessage = 5; - Message.InteractiveMessage.NativeFlowMessage nativeFlowMessage = 6; - } - message Body { - optional string text = 1; - } - - message CollectionMessage { - optional string bizJid = 1; - optional string id = 2; - optional int32 messageVersion = 3; - } - - message Footer { - optional string text = 1; - } - - message Header { - optional string title = 1; - optional string subtitle = 2; - optional bool hasMediaAttachment = 5; - oneof media { - Message.DocumentMessage documentMessage = 3; - Message.ImageMessage imageMessage = 4; - bytes jpegThumbnail = 6; - Message.VideoMessage videoMessage = 7; - } - } - - message NativeFlowMessage { - repeated NativeFlowButton buttons = 1; - optional string messageParamsJson = 2; - optional int32 messageVersion = 3; - message NativeFlowButton { - optional string name = 1; - optional string buttonParamsJson = 2; - } - - } - - message ShopMessage { - optional string id = 1; - optional Surface surface = 2; - optional int32 messageVersion = 3; - enum Surface { - UNKNOWN_SURFACE = 0; - FB = 1; - IG = 2; - WA = 3; - } - } - - } - - message InteractiveResponseMessage { - optional Body body = 1; - optional ContextInfo contextInfo = 15; - oneof interactiveResponseMessage { - Message.InteractiveResponseMessage.NativeFlowResponseMessage nativeFlowResponseMessage = 2; - } - message Body { - optional string text = 1; - } - - message NativeFlowResponseMessage { - optional string name = 1; - optional string paramsJson = 2; - optional int32 version = 3; - } - - } - - message InvoiceMessage { - optional string note = 1; - optional string token = 2; - optional AttachmentType attachmentType = 3; - optional string attachmentMimetype = 4; - optional bytes attachmentMediaKey = 5; - optional int64 attachmentMediaKeyTimestamp = 6; - optional bytes attachmentFileSha256 = 7; - optional bytes attachmentFileEncSha256 = 8; - optional string attachmentDirectPath = 9; - optional bytes attachmentJpegThumbnail = 10; - enum AttachmentType { - IMAGE = 0; - PDF = 1; - } - } - - message KeepInChatMessage { - optional MessageKey key = 1; - optional KeepType keepType = 2; - optional int64 timestampMs = 3; - } - - message ListMessage { - optional string title = 1; - optional string description = 2; - optional string buttonText = 3; - optional ListType listType = 4; - repeated Section sections = 5; - optional ProductListInfo productListInfo = 6; - optional string footerText = 7; - optional ContextInfo contextInfo = 8; - enum ListType { - UNKNOWN = 0; - SINGLE_SELECT = 1; - PRODUCT_LIST = 2; - } - message ProductListHeaderImage { - optional string productId = 1; - optional bytes jpegThumbnail = 2; - } - - message ProductListInfo { - repeated Message.ListMessage.ProductSection productSections = 1; - optional Message.ListMessage.ProductListHeaderImage headerImage = 2; - optional string businessOwnerJid = 3; - } - - message ProductSection { - optional string title = 1; - repeated Message.ListMessage.Product products = 2; - } - - message Product { - optional string productId = 1; - } - - message Row { - optional string title = 1; - optional string description = 2; - optional string rowId = 3; - } - - message Section { - optional string title = 1; - repeated Message.ListMessage.Row rows = 2; - } - - } - - message ListResponseMessage { - optional string title = 1; - optional ListType listType = 2; - optional SingleSelectReply singleSelectReply = 3; - optional ContextInfo contextInfo = 4; - optional string description = 5; - enum ListType { - UNKNOWN = 0; - SINGLE_SELECT = 1; - } - message SingleSelectReply { - optional string selectedRowId = 1; - } - - } - - message LiveLocationMessage { - optional double degreesLatitude = 1; - optional double degreesLongitude = 2; - optional uint32 accuracyInMeters = 3; - optional float speedInMps = 4; - optional uint32 degreesClockwiseFromMagneticNorth = 5; - optional string caption = 6; - optional int64 sequenceNumber = 7; - optional uint32 timeOffset = 8; - optional bytes jpegThumbnail = 16; - optional ContextInfo contextInfo = 17; - } - - message LocationMessage { - optional double degreesLatitude = 1; - optional double degreesLongitude = 2; - optional string name = 3; - optional string address = 4; - optional string url = 5; - optional bool isLive = 6; - optional uint32 accuracyInMeters = 7; - optional float speedInMps = 8; - optional uint32 degreesClockwiseFromMagneticNorth = 9; - optional string comment = 11; - optional bytes jpegThumbnail = 16; - optional ContextInfo contextInfo = 17; - } - - message OrderMessage { - optional string orderId = 1; - optional bytes thumbnail = 2; - optional int32 itemCount = 3; - optional OrderStatus status = 4; - optional OrderSurface surface = 5; - optional string message = 6; - optional string orderTitle = 7; - optional string sellerJid = 8; - optional string token = 9; - optional int64 totalAmount1000 = 10; - optional string totalCurrencyCode = 11; - optional ContextInfo contextInfo = 17; - enum OrderStatus { - INQUIRY = 1; - } - enum OrderSurface { - CATALOG = 1; - } - } - - message PaymentInviteMessage { - optional ServiceType serviceType = 1; - optional int64 expiryTimestamp = 2; - enum ServiceType { - UNKNOWN = 0; - FBPAY = 1; - NOVI = 2; - UPI = 3; - } - } - - message PollCreationMessage { - optional bytes encKey = 1; - optional string name = 2; - repeated Option options = 3; - optional uint32 selectableOptionsCount = 4; - optional ContextInfo contextInfo = 5; - message Option { - optional string optionName = 1; - } - - } - - message PollEncValue { - optional bytes encPayload = 1; - optional bytes encIv = 2; - } - - message PollUpdateMessageMetadata { - } - - message PollUpdateMessage { - optional MessageKey pollCreationMessageKey = 1; - optional Message.PollEncValue vote = 2; - optional Message.PollUpdateMessageMetadata metadata = 3; - optional int64 senderTimestampMs = 4; - } - - message PollVoteMessage { - repeated bytes selectedOptions = 1; - } - - message ProductMessage { - optional ProductSnapshot product = 1; - optional string businessOwnerJid = 2; - optional CatalogSnapshot catalog = 4; - optional string body = 5; - optional string footer = 6; - optional ContextInfo contextInfo = 17; - message CatalogSnapshot { - optional Message.ImageMessage catalogImage = 1; - optional string title = 2; - optional string description = 3; - } - - message ProductSnapshot { - optional Message.ImageMessage productImage = 1; - optional string productId = 2; - optional string title = 3; - optional string description = 4; - optional string currencyCode = 5; - optional int64 priceAmount1000 = 6; - optional string retailerId = 7; - optional string url = 8; - optional uint32 productImageCount = 9; - optional string firstImageId = 11; - optional int64 salePriceAmount1000 = 12; - } - - } - - message ProtocolMessage { - optional MessageKey key = 1; - optional Type type = 2; - optional uint32 ephemeralExpiration = 4; - optional int64 ephemeralSettingTimestamp = 5; - optional Message.HistorySyncNotification historySyncNotification = 6; - optional Message.AppStateSyncKeyShare appStateSyncKeyShare = 7; - optional Message.AppStateSyncKeyRequest appStateSyncKeyRequest = 8; - optional Message.InitialSecurityNotificationSettingSync initialSecurityNotificationSettingSync = 9; - optional Message.AppStateFatalExceptionNotification appStateFatalExceptionNotification = 10; - optional DisappearingMode disappearingMode = 11; - optional Message.RequestMediaUploadMessage requestMediaUploadMessage = 12; - optional Message.RequestMediaUploadResponseMessage requestMediaUploadResponseMessage = 13; - enum Type { - REVOKE = 0; - EPHEMERAL_SETTING = 3; - EPHEMERAL_SYNC_RESPONSE = 4; - HISTORY_SYNC_NOTIFICATION = 5; - APP_STATE_SYNC_KEY_SHARE = 6; - APP_STATE_SYNC_KEY_REQUEST = 7; - MSG_FANOUT_BACKFILL_REQUEST = 8; - INITIAL_SECURITY_NOTIFICATION_SETTING_SYNC = 9; - APP_STATE_FATAL_EXCEPTION_NOTIFICATION = 10; - SHARE_PHONE_NUMBER = 11; - REQUEST_MEDIA_UPLOAD_MESSAGE = 12; - REQUEST_MEDIA_UPLOAD_RESPONSE_MESSAGE = 13; - } - } - - message ReactionMessage { - optional MessageKey key = 1; - optional string text = 2; - optional string groupingKey = 3; - optional int64 senderTimestampMs = 4; - } - - message RequestMediaUploadMessage { - repeated string fileSha256 = 1; - optional Message.RmrSource rmrSource = 2; - } - - message RequestMediaUploadResponseMessage { - optional Message.RmrSource rmrSource = 1; - optional string stanzaId = 2; - repeated RequestMediaUploadResult reuploadResult = 3; - message RequestMediaUploadResult { - optional string fileSha256 = 1; - optional MediaRetryNotification.ResultType mediaUploadResult = 2; - optional Message.StickerMessage stickerMessage = 3; - } - - } - - message RequestPaymentMessage { - optional Message noteMessage = 4; - optional string currencyCodeIso4217 = 1; - optional uint64 amount1000 = 2; - optional string requestFrom = 3; - optional int64 expiryTimestamp = 5; - optional Money amount = 6; - optional PaymentBackground background = 7; - } - - message RequestPhoneNumberMessage { - optional ContextInfo contextInfo = 1; - } - - enum RmrSource { - FAVORITE_STICKER = 0; - RECENT_STICKER = 1; - } - message SendPaymentMessage { - optional Message noteMessage = 2; - optional MessageKey requestMessageKey = 3; - optional PaymentBackground background = 4; - } - - message SenderKeyDistributionMessage { - optional string groupId = 1; - optional bytes axolotlSenderKeyDistributionMessage = 2; - } - - message StickerMessage { - optional string url = 1; - optional bytes fileSha256 = 2; - optional bytes fileEncSha256 = 3; - optional bytes mediaKey = 4; - optional string mimetype = 5; - optional uint32 height = 6; - optional uint32 width = 7; - optional string directPath = 8; - optional uint64 fileLength = 9; - optional int64 mediaKeyTimestamp = 10; - optional uint32 firstFrameLength = 11; - optional bytes firstFrameSidecar = 12; - optional bool isAnimated = 13; - optional bytes pngThumbnail = 16; - optional ContextInfo contextInfo = 17; - } - - message StickerSyncRMRMessage { - repeated string filehash = 1; - optional string rmrSource = 2; - optional int64 requestTimestamp = 3; - } - - message TemplateButtonReplyMessage { - optional string selectedId = 1; - optional string selectedDisplayText = 2; - optional ContextInfo contextInfo = 3; - optional uint32 selectedIndex = 4; - } - - message TemplateMessage { - optional ContextInfo contextInfo = 3; - optional HydratedFourRowTemplate hydratedTemplate = 4; - oneof format { - Message.TemplateMessage.FourRowTemplate fourRowTemplate = 1; - Message.TemplateMessage.HydratedFourRowTemplate hydratedFourRowTemplate = 2; - } - message FourRowTemplate { - optional Message.HighlyStructuredMessage content = 6; - optional Message.HighlyStructuredMessage footer = 7; - repeated TemplateButton buttons = 8; - oneof title { - Message.DocumentMessage documentMessage = 1; - Message.HighlyStructuredMessage highlyStructuredMessage = 2; - Message.ImageMessage imageMessage = 3; - Message.VideoMessage videoMessage = 4; - Message.LocationMessage locationMessage = 5; - } - } - - message HydratedFourRowTemplate { - optional string hydratedContentText = 6; - optional string hydratedFooterText = 7; - repeated HydratedTemplateButton hydratedButtons = 8; - optional string templateId = 9; - oneof title { - Message.DocumentMessage documentMessage = 1; - string hydratedTitleText = 2; - Message.ImageMessage imageMessage = 3; - Message.VideoMessage videoMessage = 4; - Message.LocationMessage locationMessage = 5; - } - } - - } - - message VideoMessage { - optional string url = 1; - optional string mimetype = 2; - optional bytes fileSha256 = 3; - optional uint64 fileLength = 4; - optional uint32 seconds = 5; - optional bytes mediaKey = 6; - optional string caption = 7; - optional bool gifPlayback = 8; - optional uint32 height = 9; - optional uint32 width = 10; - optional bytes fileEncSha256 = 11; - repeated InteractiveAnnotation interactiveAnnotations = 12; - optional string directPath = 13; - optional int64 mediaKeyTimestamp = 14; - optional bytes jpegThumbnail = 16; - optional ContextInfo contextInfo = 17; - optional bytes streamingSidecar = 18; - optional Attribution gifAttribution = 19; - optional bool viewOnce = 20; - optional string thumbnailDirectPath = 21; - optional bytes thumbnailSha256 = 22; - optional bytes thumbnailEncSha256 = 23; - optional string staticUrl = 24; - enum Attribution { - NONE = 0; - GIPHY = 1; - TENOR = 2; - } - } - -} - -message MessageContextInfo { - optional DeviceListMetadata deviceListMetadata = 1; - optional int32 deviceListMetadataVersion = 2; - optional bytes messageSecret = 3; - optional bytes paddingBytes = 4; -} - -message MessageKey { - optional string remoteJid = 1; - optional bool fromMe = 2; - optional string id = 3; - optional string participant = 4; -} - -message Money { - optional int64 value = 1; - optional uint32 offset = 2; - optional string currencyCode = 3; -} - -message MsgOpaqueData { - optional string body = 1; - optional string caption = 3; - optional double lng = 5; - optional bool isLive = 6; - optional double lat = 7; - optional int32 paymentAmount1000 = 8; - optional string paymentNoteMsgBody = 9; - optional string canonicalUrl = 10; - optional string matchedText = 11; - optional string title = 12; - optional string description = 13; - optional bytes futureproofBuffer = 14; - optional string clientUrl = 15; - optional string loc = 16; - optional string pollName = 17; - repeated PollOption pollOptions = 18; - optional uint32 pollSelectableOptionsCount = 20; - optional bytes messageSecret = 21; - optional int64 senderTimestampMs = 22; - optional string pollUpdateParentKey = 23; - optional PollEncValue encPollVote = 24; - message PollOption { - optional string name = 1; - } - -} - -message MsgRowOpaqueData { - optional MsgOpaqueData currentMsg = 1; - optional MsgOpaqueData quotedMsg = 2; -} - -message NoiseCertificate { - optional bytes details = 1; - optional bytes signature = 2; - message Details { - optional uint32 serial = 1; - optional string issuer = 2; - optional uint64 expires = 3; - optional string subject = 4; - optional bytes key = 5; - } - -} - -message NotificationMessageInfo { - optional MessageKey key = 1; - optional Message message = 2; - optional uint64 messageTimestamp = 3; - optional string participant = 4; -} - -message PastParticipant { - required string userJid = 1; - required LeaveReason leaveReason = 2; - required uint64 leaveTs = 3; - enum LeaveReason { - LEFT = 0; - REMOVED = 1; - } -} - -message PastParticipants { - required string groupJid = 1; - repeated PastParticipant pastParticipants = 2; -} - -message PaymentBackground { - optional string id = 1; - optional uint64 fileLength = 2; - optional uint32 width = 3; - optional uint32 height = 4; - optional string mimetype = 5; - optional fixed32 placeholderArgb = 6; - optional fixed32 textArgb = 7; - optional fixed32 subtextArgb = 8; - optional MediaData mediaData = 9; - optional Type type = 10; - message MediaData { - optional bytes mediaKey = 1; - optional int64 mediaKeyTimestamp = 2; - optional bytes fileSha256 = 3; - optional bytes fileEncSha256 = 4; - optional string directPath = 5; - } - - enum Type { - UNKNOWN = 0; - DEFAULT = 1; - } -} - -message PaymentInfo { - optional Currency currencyDeprecated = 1; - optional uint64 amount1000 = 2; - optional string receiverJid = 3; - optional Status status = 4; - optional uint64 transactionTimestamp = 5; - optional MessageKey requestMessageKey = 6; - optional uint64 expiryTimestamp = 7; - optional bool futureproofed = 8; - optional string currency = 9; - optional TxnStatus txnStatus = 10; - optional bool useNoviFiatFormat = 11; - optional Money primaryAmount = 12; - optional Money exchangeAmount = 13; - enum Currency { - UNKNOWN_CURRENCY = 0; - INR = 1; - } - enum Status { - UNKNOWN_STATUS = 0; - PROCESSING = 1; - SENT = 2; - NEED_TO_ACCEPT = 3; - COMPLETE = 4; - COULD_NOT_COMPLETE = 5; - REFUNDED = 6; - EXPIRED = 7; - REJECTED = 8; - CANCELLED = 9; - WAITING_FOR_PAYER = 10; - WAITING = 11; - } - enum TxnStatus { - UNKNOWN = 0; - PENDING_SETUP = 1; - PENDING_RECEIVER_SETUP = 2; - INIT = 3; - SUCCESS = 4; - COMPLETED = 5; - FAILED = 6; - FAILED_RISK = 7; - FAILED_PROCESSING = 8; - FAILED_RECEIVER_PROCESSING = 9; - FAILED_DA = 10; - FAILED_DA_FINAL = 11; - REFUNDED_TXN = 12; - REFUND_FAILED = 13; - REFUND_FAILED_PROCESSING = 14; - REFUND_FAILED_DA = 15; - EXPIRED_TXN = 16; - AUTH_CANCELED = 17; - AUTH_CANCEL_FAILED_PROCESSING = 18; - AUTH_CANCEL_FAILED = 19; - COLLECT_INIT = 20; - COLLECT_SUCCESS = 21; - COLLECT_FAILED = 22; - COLLECT_FAILED_RISK = 23; - COLLECT_REJECTED = 24; - COLLECT_EXPIRED = 25; - COLLECT_CANCELED = 26; - COLLECT_CANCELLING = 27; - IN_REVIEW = 28; - REVERSAL_SUCCESS = 29; - REVERSAL_PENDING = 30; - REFUND_PENDING = 31; - } -} - -message PendingKeyExchange { - optional uint32 sequence = 1; - optional bytes localBaseKey = 2; - optional bytes localBaseKeyPrivate = 3; - optional bytes localRatchetKey = 4; - optional bytes localRatchetKeyPrivate = 5; - optional bytes localIdentityKey = 7; - optional bytes localIdentityKeyPrivate = 8; -} - -message PendingPreKey { - optional uint32 preKeyId = 1; - optional int32 signedPreKeyId = 3; - optional bytes baseKey = 2; -} - -message PhotoChange { - optional bytes oldPhoto = 1; - optional bytes newPhoto = 2; - optional uint32 newPhotoId = 3; -} - -message Point { - optional int32 xDeprecated = 1; - optional int32 yDeprecated = 2; - optional double x = 3; - optional double y = 4; -} - -message PollAdditionalMetadata { - optional bool pollInvalidated = 1; -} - -message PollEncValue { - optional bytes encPayload = 1; - optional bytes encIv = 2; -} - -message PollUpdate { - optional MessageKey pollUpdateMessageKey = 1; - optional Message.PollVoteMessage vote = 2; - optional int64 senderTimestampMs = 3; -} - -message PreKeyRecordStructure { - optional uint32 id = 1; - optional bytes publicKey = 2; - optional bytes privateKey = 3; -} - -message Pushname { - optional string id = 1; - optional string pushname = 2; -} - -message Reaction { - optional MessageKey key = 1; - optional string text = 2; - optional string groupingKey = 3; - optional int64 senderTimestampMs = 4; - optional bool unread = 5; -} - -message RecentEmojiWeight { - optional string emoji = 1; - optional float weight = 2; -} - -message RecordStructure { - optional SessionStructure currentSession = 1; - repeated SessionStructure previousSessions = 2; -} - -message SenderChainKey { - optional uint32 iteration = 1; - optional bytes seed = 2; -} - -message SenderKeyRecordStructure { - repeated SenderKeyStateStructure senderKeyStates = 1; -} - -message SenderKeyStateStructure { - optional uint32 senderKeyId = 1; - optional SenderChainKey senderChainKey = 2; - optional SenderSigningKey senderSigningKey = 3; - repeated SenderMessageKey senderMessageKeys = 4; -} - -message SenderMessageKey { - optional uint32 iteration = 1; - optional bytes seed = 2; -} - -message SenderSigningKey { - optional bytes public = 1; - optional bytes private = 2; -} - -message ServerErrorReceipt { - optional string stanzaId = 1; -} - -message SessionStructure { - optional uint32 sessionVersion = 1; - optional bytes localIdentityPublic = 2; - optional bytes remoteIdentityPublic = 3; - optional bytes rootKey = 4; - optional uint32 previousCounter = 5; - optional Chain senderChain = 6; - repeated Chain receiverChains = 7; - optional PendingKeyExchange pendingKeyExchange = 8; - optional PendingPreKey pendingPreKey = 9; - optional uint32 remoteRegistrationId = 10; - optional uint32 localRegistrationId = 11; - optional bool needsRefresh = 12; - optional bytes aliceBaseKey = 13; -} - -message SignedPreKeyRecordStructure { - optional uint32 id = 1; - optional bytes publicKey = 2; - optional bytes privateKey = 3; - optional bytes signature = 4; - optional fixed64 timestamp = 5; -} - -message StatusPSA { - required uint64 campaignId = 44; - optional uint64 campaignExpirationTimestamp = 45; -} - -message StickerMetadata { - optional string url = 1; - optional bytes fileSha256 = 2; - optional bytes fileEncSha256 = 3; - optional bytes mediaKey = 4; - optional string mimetype = 5; - optional uint32 height = 6; - optional uint32 width = 7; - optional string directPath = 8; - optional uint64 fileLength = 9; - optional float weight = 10; -} - -message SyncActionData { - optional bytes index = 1; - optional SyncActionValue value = 2; - optional bytes padding = 3; - optional int32 version = 4; -} - -message SyncActionValue { - optional int64 timestamp = 1; - optional StarAction starAction = 2; - optional ContactAction contactAction = 3; - optional MuteAction muteAction = 4; - optional PinAction pinAction = 5; - optional SecurityNotificationSetting securityNotificationSetting = 6; - optional PushNameSetting pushNameSetting = 7; - optional QuickReplyAction quickReplyAction = 8; - optional RecentEmojiWeightsAction recentEmojiWeightsAction = 11; - optional LabelEditAction labelEditAction = 14; - optional LabelAssociationAction labelAssociationAction = 15; - optional LocaleSetting localeSetting = 16; - optional ArchiveChatAction archiveChatAction = 17; - optional DeleteMessageForMeAction deleteMessageForMeAction = 18; - optional KeyExpiration keyExpiration = 19; - optional MarkChatAsReadAction markChatAsReadAction = 20; - optional ClearChatAction clearChatAction = 21; - optional DeleteChatAction deleteChatAction = 22; - optional UnarchiveChatsSetting unarchiveChatsSetting = 23; - optional PrimaryFeature primaryFeature = 24; - optional AndroidUnsupportedActions androidUnsupportedActions = 26; - optional AgentAction agentAction = 27; - optional SubscriptionAction subscriptionAction = 28; - optional UserStatusMuteAction userStatusMuteAction = 29; - optional TimeFormatAction timeFormatAction = 30; - optional NuxAction nuxAction = 31; - optional PrimaryVersionAction primaryVersionAction = 32; - optional StickerAction stickerAction = 33; - message AgentAction { - optional string name = 1; - optional int32 deviceID = 2; - optional bool isDeleted = 3; - } - - message AndroidUnsupportedActions { - optional bool allowed = 1; - } - - message ArchiveChatAction { - optional bool archived = 1; - optional SyncActionValue.SyncActionMessageRange messageRange = 2; - } - - message ClearChatAction { - optional SyncActionValue.SyncActionMessageRange messageRange = 1; - } - - message ContactAction { - optional string fullName = 1; - optional string firstName = 2; - } - - message DeleteChatAction { - optional SyncActionValue.SyncActionMessageRange messageRange = 1; - } - - message DeleteMessageForMeAction { - optional bool deleteMedia = 1; - optional int64 messageTimestamp = 2; - } - - message KeyExpiration { - optional int32 expiredKeyEpoch = 1; - } - - message LabelAssociationAction { - optional bool labeled = 1; - } - - message LabelEditAction { - optional string name = 1; - optional int32 color = 2; - optional int32 predefinedId = 3; - optional bool deleted = 4; - } - - message LocaleSetting { - optional string locale = 1; - } - - message MarkChatAsReadAction { - optional bool read = 1; - optional SyncActionValue.SyncActionMessageRange messageRange = 2; - } - - message MuteAction { - optional bool muted = 1; - optional int64 muteEndTimestamp = 2; - } - - message NuxAction { - optional bool acknowledged = 1; - } - - message PinAction { - optional bool pinned = 1; - } - - message PrimaryFeature { - repeated string flags = 1; - } - - message PrimaryVersionAction { - optional string version = 1; - } - - message PushNameSetting { - optional string name = 1; - } - - message QuickReplyAction { - optional string shortcut = 1; - optional string message = 2; - repeated string keywords = 3; - optional int32 count = 4; - optional bool deleted = 5; - } - - message RecentEmojiWeightsAction { - repeated RecentEmojiWeight weights = 1; - } - - message SecurityNotificationSetting { - optional bool showNotification = 1; - } - - message StarAction { - optional bool starred = 1; - } - - message StickerAction { - optional string url = 1; - optional bytes fileEncSha256 = 2; - optional bytes mediaKey = 3; - optional string mimetype = 4; - optional uint32 height = 5; - optional uint32 width = 6; - optional string directPath = 7; - optional uint64 fileLength = 8; - optional bool isFavorite = 9; - optional uint32 deviceIdHint = 10; - } - - message SubscriptionAction { - optional bool isDeactivated = 1; - optional bool isAutoRenewing = 2; - optional int64 expirationDate = 3; - } - - message SyncActionMessageRange { - optional int64 lastMessageTimestamp = 1; - optional int64 lastSystemMessageTimestamp = 2; - repeated SyncActionValue.SyncActionMessage messages = 3; - } - - message SyncActionMessage { - optional MessageKey key = 1; - optional int64 timestamp = 2; - } - - message TimeFormatAction { - optional bool isTwentyFourHourFormatEnabled = 1; - } - - message UnarchiveChatsSetting { - optional bool unarchiveChats = 1; - } - - message UserStatusMuteAction { - optional bool muted = 1; - } - -} - -message SyncdIndex { - optional bytes blob = 1; -} - -message SyncdMutation { - optional SyncdOperation operation = 1; - optional SyncdRecord record = 2; - enum SyncdOperation { - SET = 0; - REMOVE = 1; - } -} - -message SyncdMutations { - repeated SyncdMutation mutations = 1; -} - -message SyncdPatch { - optional SyncdVersion version = 1; - repeated SyncdMutation mutations = 2; - optional ExternalBlobReference externalMutations = 3; - optional bytes snapshotMac = 4; - optional bytes patchMac = 5; - optional KeyId keyId = 6; - optional ExitCode exitCode = 7; - optional uint32 deviceIndex = 8; -} - -message SyncdRecord { - optional SyncdIndex index = 1; - optional SyncdValue value = 2; - optional KeyId keyId = 3; -} - -message SyncdSnapshot { - optional SyncdVersion version = 1; - repeated SyncdRecord records = 2; - optional bytes mac = 3; - optional KeyId keyId = 4; -} - -message SyncdValue { - optional bytes blob = 1; -} - -message SyncdVersion { - optional uint64 version = 1; -} - -message TemplateButton { - optional uint32 index = 4; - oneof button { - TemplateButton.QuickReplyButton quickReplyButton = 1; - TemplateButton.URLButton urlButton = 2; - TemplateButton.CallButton callButton = 3; - } - message CallButton { - optional Message.HighlyStructuredMessage displayText = 1; - optional Message.HighlyStructuredMessage phoneNumber = 2; - } - - message QuickReplyButton { - optional Message.HighlyStructuredMessage displayText = 1; - optional string id = 2; - } - - message URLButton { - optional Message.HighlyStructuredMessage displayText = 1; - optional Message.HighlyStructuredMessage url = 2; - } - -} - -message UserReceipt { - required string userJid = 1; - optional int64 receiptTimestamp = 2; - optional int64 readTimestamp = 3; - optional int64 playedTimestamp = 4; - repeated string pendingDeviceJid = 5; - repeated string deliveredDeviceJid = 6; -} - -message VerifiedNameCertificate { - optional bytes details = 1; - optional bytes signature = 2; - optional bytes serverSignature = 3; - message Details { - optional uint64 serial = 1; - optional string issuer = 2; - optional string verifiedName = 4; - repeated LocalizedName localizedNames = 8; - optional uint64 issueTime = 10; - } - -} - -message WallpaperSettings { - optional string filename = 1; - optional uint32 opacity = 2; -} - -message WebFeatures { - optional Flag labelsDisplay = 1; - optional Flag voipIndividualOutgoing = 2; - optional Flag groupsV3 = 3; - optional Flag groupsV3Create = 4; - optional Flag changeNumberV2 = 5; - optional Flag queryStatusV3Thumbnail = 6; - optional Flag liveLocations = 7; - optional Flag queryVname = 8; - optional Flag voipIndividualIncoming = 9; - optional Flag quickRepliesQuery = 10; - optional Flag payments = 11; - optional Flag stickerPackQuery = 12; - optional Flag liveLocationsFinal = 13; - optional Flag labelsEdit = 14; - optional Flag mediaUpload = 15; - optional Flag mediaUploadRichQuickReplies = 18; - optional Flag vnameV2 = 19; - optional Flag videoPlaybackUrl = 20; - optional Flag statusRanking = 21; - optional Flag voipIndividualVideo = 22; - optional Flag thirdPartyStickers = 23; - optional Flag frequentlyForwardedSetting = 24; - optional Flag groupsV4JoinPermission = 25; - optional Flag recentStickers = 26; - optional Flag catalog = 27; - optional Flag starredStickers = 28; - optional Flag voipGroupCall = 29; - optional Flag templateMessage = 30; - optional Flag templateMessageInteractivity = 31; - optional Flag ephemeralMessages = 32; - optional Flag e2ENotificationSync = 33; - optional Flag recentStickersV2 = 34; - optional Flag recentStickersV3 = 36; - optional Flag userNotice = 37; - optional Flag support = 39; - optional Flag groupUiiCleanup = 40; - optional Flag groupDogfoodingInternalOnly = 41; - optional Flag settingsSync = 42; - optional Flag archiveV2 = 43; - optional Flag ephemeralAllowGroupMembers = 44; - optional Flag ephemeral24HDuration = 45; - optional Flag mdForceUpgrade = 46; - optional Flag disappearingMode = 47; - optional Flag externalMdOptInAvailable = 48; - optional Flag noDeleteMessageTimeLimit = 49; - enum Flag { - NOT_STARTED = 0; - FORCE_UPGRADE = 1; - DEVELOPMENT = 2; - PRODUCTION = 3; - } -} - -message WebMessageInfo { - required MessageKey key = 1; - optional Message message = 2; - optional uint64 messageTimestamp = 3; - optional Status status = 4; - optional string participant = 5; - optional uint64 messageC2STimestamp = 6; - optional bool ignore = 16; - optional bool starred = 17; - optional bool broadcast = 18; - optional string pushName = 19; - optional bytes mediaCiphertextSha256 = 20; - optional bool multicast = 21; - optional bool urlText = 22; - optional bool urlNumber = 23; - optional StubType messageStubType = 24; - optional bool clearMedia = 25; - repeated string messageStubParameters = 26; - optional uint32 duration = 27; - repeated string labels = 28; - optional PaymentInfo paymentInfo = 29; - optional Message.LiveLocationMessage finalLiveLocation = 30; - optional PaymentInfo quotedPaymentInfo = 31; - optional uint64 ephemeralStartTimestamp = 32; - optional uint32 ephemeralDuration = 33; - optional bool ephemeralOffToOn = 34; - optional bool ephemeralOutOfSync = 35; - optional BizPrivacyStatus bizPrivacyStatus = 36; - optional string verifiedBizName = 37; - optional MediaData mediaData = 38; - optional PhotoChange photoChange = 39; - repeated UserReceipt userReceipt = 40; - repeated Reaction reactions = 41; - optional MediaData quotedStickerData = 42; - optional bytes futureproofData = 43; - optional StatusPSA statusPsa = 44; - repeated PollUpdate pollUpdates = 45; - optional PollAdditionalMetadata pollAdditionalMetadata = 46; - optional string agentId = 47; - optional bool statusAlreadyViewed = 48; - optional bytes messageSecret = 49; - optional KeepInChat keepInChat = 50; - optional string originalSelfAuthorUserJidString = 51; - optional uint64 revokeMessageTimestamp = 52; - enum BizPrivacyStatus { - E2EE = 0; - FB = 2; - BSP = 1; - BSP_AND_FB = 3; - } - enum Status { - ERROR = 0; - PENDING = 1; - SERVER_ACK = 2; - DELIVERY_ACK = 3; - READ = 4; - PLAYED = 5; - } - enum StubType { - UNKNOWN = 0; - REVOKE = 1; - CIPHERTEXT = 2; - FUTUREPROOF = 3; - NON_VERIFIED_TRANSITION = 4; - UNVERIFIED_TRANSITION = 5; - VERIFIED_TRANSITION = 6; - VERIFIED_LOW_UNKNOWN = 7; - VERIFIED_HIGH = 8; - VERIFIED_INITIAL_UNKNOWN = 9; - VERIFIED_INITIAL_LOW = 10; - VERIFIED_INITIAL_HIGH = 11; - VERIFIED_TRANSITION_ANY_TO_NONE = 12; - VERIFIED_TRANSITION_ANY_TO_HIGH = 13; - VERIFIED_TRANSITION_HIGH_TO_LOW = 14; - VERIFIED_TRANSITION_HIGH_TO_UNKNOWN = 15; - VERIFIED_TRANSITION_UNKNOWN_TO_LOW = 16; - VERIFIED_TRANSITION_LOW_TO_UNKNOWN = 17; - VERIFIED_TRANSITION_NONE_TO_LOW = 18; - VERIFIED_TRANSITION_NONE_TO_UNKNOWN = 19; - GROUP_CREATE = 20; - GROUP_CHANGE_SUBJECT = 21; - GROUP_CHANGE_ICON = 22; - GROUP_CHANGE_INVITE_LINK = 23; - GROUP_CHANGE_DESCRIPTION = 24; - GROUP_CHANGE_RESTRICT = 25; - GROUP_CHANGE_ANNOUNCE = 26; - GROUP_PARTICIPANT_ADD = 27; - GROUP_PARTICIPANT_REMOVE = 28; - GROUP_PARTICIPANT_PROMOTE = 29; - GROUP_PARTICIPANT_DEMOTE = 30; - GROUP_PARTICIPANT_INVITE = 31; - GROUP_PARTICIPANT_LEAVE = 32; - GROUP_PARTICIPANT_CHANGE_NUMBER = 33; - BROADCAST_CREATE = 34; - BROADCAST_ADD = 35; - BROADCAST_REMOVE = 36; - GENERIC_NOTIFICATION = 37; - E2E_IDENTITY_CHANGED = 38; - E2E_ENCRYPTED = 39; - CALL_MISSED_VOICE = 40; - CALL_MISSED_VIDEO = 41; - INDIVIDUAL_CHANGE_NUMBER = 42; - GROUP_DELETE = 43; - GROUP_ANNOUNCE_MODE_MESSAGE_BOUNCE = 44; - CALL_MISSED_GROUP_VOICE = 45; - CALL_MISSED_GROUP_VIDEO = 46; - PAYMENT_CIPHERTEXT = 47; - PAYMENT_FUTUREPROOF = 48; - PAYMENT_TRANSACTION_STATUS_UPDATE_FAILED = 49; - PAYMENT_TRANSACTION_STATUS_UPDATE_REFUNDED = 50; - PAYMENT_TRANSACTION_STATUS_UPDATE_REFUND_FAILED = 51; - PAYMENT_TRANSACTION_STATUS_RECEIVER_PENDING_SETUP = 52; - PAYMENT_TRANSACTION_STATUS_RECEIVER_SUCCESS_AFTER_HICCUP = 53; - PAYMENT_ACTION_ACCOUNT_SETUP_REMINDER = 54; - PAYMENT_ACTION_SEND_PAYMENT_REMINDER = 55; - PAYMENT_ACTION_SEND_PAYMENT_INVITATION = 56; - PAYMENT_ACTION_REQUEST_DECLINED = 57; - PAYMENT_ACTION_REQUEST_EXPIRED = 58; - PAYMENT_ACTION_REQUEST_CANCELLED = 59; - BIZ_VERIFIED_TRANSITION_TOP_TO_BOTTOM = 60; - BIZ_VERIFIED_TRANSITION_BOTTOM_TO_TOP = 61; - BIZ_INTRO_TOP = 62; - BIZ_INTRO_BOTTOM = 63; - BIZ_NAME_CHANGE = 64; - BIZ_MOVE_TO_CONSUMER_APP = 65; - BIZ_TWO_TIER_MIGRATION_TOP = 66; - BIZ_TWO_TIER_MIGRATION_BOTTOM = 67; - OVERSIZED = 68; - GROUP_CHANGE_NO_FREQUENTLY_FORWARDED = 69; - GROUP_V4_ADD_INVITE_SENT = 70; - GROUP_PARTICIPANT_ADD_REQUEST_JOIN = 71; - CHANGE_EPHEMERAL_SETTING = 72; - E2E_DEVICE_CHANGED = 73; - VIEWED_ONCE = 74; - E2E_ENCRYPTED_NOW = 75; - BLUE_MSG_BSP_FB_TO_BSP_PREMISE = 76; - BLUE_MSG_BSP_FB_TO_SELF_FB = 77; - BLUE_MSG_BSP_FB_TO_SELF_PREMISE = 78; - BLUE_MSG_BSP_FB_UNVERIFIED = 79; - BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED = 80; - BLUE_MSG_BSP_FB_VERIFIED = 81; - BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED = 82; - BLUE_MSG_BSP_PREMISE_TO_SELF_PREMISE = 83; - BLUE_MSG_BSP_PREMISE_UNVERIFIED = 84; - BLUE_MSG_BSP_PREMISE_UNVERIFIED_TO_SELF_PREMISE_VERIFIED = 85; - BLUE_MSG_BSP_PREMISE_VERIFIED = 86; - BLUE_MSG_BSP_PREMISE_VERIFIED_TO_SELF_PREMISE_UNVERIFIED = 87; - BLUE_MSG_CONSUMER_TO_BSP_FB_UNVERIFIED = 88; - BLUE_MSG_CONSUMER_TO_BSP_PREMISE_UNVERIFIED = 89; - BLUE_MSG_CONSUMER_TO_SELF_FB_UNVERIFIED = 90; - BLUE_MSG_CONSUMER_TO_SELF_PREMISE_UNVERIFIED = 91; - BLUE_MSG_SELF_FB_TO_BSP_PREMISE = 92; - BLUE_MSG_SELF_FB_TO_SELF_PREMISE = 93; - BLUE_MSG_SELF_FB_UNVERIFIED = 94; - BLUE_MSG_SELF_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED = 95; - BLUE_MSG_SELF_FB_VERIFIED = 96; - BLUE_MSG_SELF_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED = 97; - BLUE_MSG_SELF_PREMISE_TO_BSP_PREMISE = 98; - BLUE_MSG_SELF_PREMISE_UNVERIFIED = 99; - BLUE_MSG_SELF_PREMISE_VERIFIED = 100; - BLUE_MSG_TO_BSP_FB = 101; - BLUE_MSG_TO_CONSUMER = 102; - BLUE_MSG_TO_SELF_FB = 103; - BLUE_MSG_UNVERIFIED_TO_BSP_FB_VERIFIED = 104; - BLUE_MSG_UNVERIFIED_TO_BSP_PREMISE_VERIFIED = 105; - BLUE_MSG_UNVERIFIED_TO_SELF_FB_VERIFIED = 106; - BLUE_MSG_UNVERIFIED_TO_VERIFIED = 107; - BLUE_MSG_VERIFIED_TO_BSP_FB_UNVERIFIED = 108; - BLUE_MSG_VERIFIED_TO_BSP_PREMISE_UNVERIFIED = 109; - BLUE_MSG_VERIFIED_TO_SELF_FB_UNVERIFIED = 110; - BLUE_MSG_VERIFIED_TO_UNVERIFIED = 111; - BLUE_MSG_BSP_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED = 112; - BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_FB_VERIFIED = 113; - BLUE_MSG_BSP_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED = 114; - BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_FB_UNVERIFIED = 115; - BLUE_MSG_SELF_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED = 116; - BLUE_MSG_SELF_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED = 117; - E2E_IDENTITY_UNAVAILABLE = 118; - GROUP_CREATING = 119; - GROUP_CREATE_FAILED = 120; - GROUP_BOUNCED = 121; - BLOCK_CONTACT = 122; - EPHEMERAL_SETTING_NOT_APPLIED = 123; - SYNC_FAILED = 124; - SYNCING = 125; - BIZ_PRIVACY_MODE_INIT_FB = 126; - BIZ_PRIVACY_MODE_INIT_BSP = 127; - BIZ_PRIVACY_MODE_TO_FB = 128; - BIZ_PRIVACY_MODE_TO_BSP = 129; - DISAPPEARING_MODE = 130; - E2E_DEVICE_FETCH_FAILED = 131; - ADMIN_REVOKE = 132; - GROUP_INVITE_LINK_GROWTH_LOCKED = 133; - COMMUNITY_LINK_PARENT_GROUP = 134; - COMMUNITY_LINK_SIBLING_GROUP = 135; - COMMUNITY_LINK_SUB_GROUP = 136; - COMMUNITY_UNLINK_PARENT_GROUP = 137; - COMMUNITY_UNLINK_SIBLING_GROUP = 138; - COMMUNITY_UNLINK_SUB_GROUP = 139; - GROUP_PARTICIPANT_ACCEPT = 140; - GROUP_PARTICIPANT_LINKED_GROUP_JOIN = 141; - COMMUNITY_CREATE = 142; - EPHEMERAL_KEEP_IN_CHAT = 143; - GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST = 144; - GROUP_MEMBERSHIP_JOIN_APPROVAL_MODE = 145; - INTEGRITY_UNLINK_PARENT_GROUP = 146; - COMMUNITY_PARTICIPANT_PROMOTE = 147; - COMMUNITY_PARTICIPANT_DEMOTE = 148; - COMMUNITY_PARENT_GROUP_DELETED = 149; - } -} - -message WebNotificationsInfo { - optional uint64 timestamp = 2; - optional uint32 unreadChats = 3; - optional uint32 notifyMessageCount = 4; - repeated WebMessageInfo notifyMessages = 5; -} diff --git a/protocols/WhatsAppWeb/src/proto.cpp b/protocols/WhatsAppWeb/src/proto.cpp deleted file mode 100644 index 5e797c6431..0000000000 --- a/protocols/WhatsAppWeb/src/proto.cpp +++ /dev/null @@ -1,333 +0,0 @@ -/* - -WhatsAppWeb plugin for Miranda NG -Copyright © 2019-22 George Hazan - -*/ - -#include "stdafx.h" - -struct SearchParam -{ - SearchParam(const wchar_t *_jid, LONG _id) : - jid(_jid), id(_id) - {} - - std::wstring jid; - LONG id; -}; - -static int CompareOwnMsgs(const WAOwnMessage *p1, const WAOwnMessage *p2) -{ - return strcmp(p1->szPrefix, p2->szPrefix); -} - -static int CompareUsers(const WAUser *p1, const WAUser *p2) -{ - return strcmp(p1->szId, p2->szId); -} - -static int CompareCollections(const WACollection *p1, const WACollection *p2) -{ - return strcmp(p1->szName, p2->szName); -} - -WhatsAppProto::WhatsAppProto(const char *proto_name, const wchar_t *username) : - PROTO(proto_name, username), - m_impl(*this), - m_signalStore(this, ""), - m_szJid(getMStringA(DBKEY_JID)), - m_tszDefaultGroup(getWStringA(DBKEY_DEF_GROUP)), - m_arUsers(10, CompareUsers), - m_arDevices(1), - m_arOwnMsgs(1, CompareOwnMsgs), - m_arPersistent(1), - m_arPacketQueue(10), - m_arCollections(10, CompareCollections), - - m_wszNick(this, "Nick"), - m_wszDefaultGroup(this, "DefaultGroup", L"WhatsApp"), - m_bUsePopups(this, "UsePopups", true), - m_bHideGroupchats(this, "HideChats", true) -{ - db_set_resident(m_szModuleName, "StatusMsg"); - - CreateProtoService(PS_CREATEACCMGRUI, &WhatsAppProto::SvcCreateAccMgrUI); - - CreateProtoService(PS_GETAVATARINFO, &WhatsAppProto::GetAvatarInfo); - CreateProtoService(PS_GETAVATARCAPS, &WhatsAppProto::GetAvatarCaps); - CreateProtoService(PS_GETMYAVATAR, &WhatsAppProto::GetMyAvatar); - CreateProtoService(PS_SETMYAVATAR, &WhatsAppProto::SetMyAvatar); - - HookProtoEvent(ME_OPT_INITIALISE, &WhatsAppProto::OnOptionsInit); - - InitCollections(); - InitPopups(); - InitPersistentHandlers(); - - // Create standard network connection - wchar_t descr[512]; - mir_snwprintf(descr, TranslateT("%s (server)"), m_tszUserName); - - NETLIBUSER nlu = {}; - nlu.flags = NUF_INCOMING | NUF_OUTGOING | NUF_HTTPCONNS | NUF_UNICODE; - nlu.szSettingsModule = m_szModuleName; - nlu.szDescriptiveName.w = descr; - m_hNetlibUser = Netlib_RegisterUser(&nlu); - - // Temporary folder - CreateDirectoryTreeW(CMStringW(VARSW(L"%miranda_userdata%")) + L"\\" + _A2T(m_szModuleName)); - - // Avatars folder - m_tszAvatarFolder = CMStringW(VARSW(L"%miranda_avatarcache%")) + L"\\" + m_tszUserName; - DWORD dwAttributes = GetFileAttributes(m_tszAvatarFolder.c_str()); - if (dwAttributes == 0xffffffff || (dwAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) - CreateDirectoryTreeW(m_tszAvatarFolder.c_str()); - - // default contacts group - if (m_tszDefaultGroup == NULL) - m_tszDefaultGroup = mir_wstrdup(L"WhatsApp"); - Clist_GroupCreate(0, m_tszDefaultGroup); - - // groupchat initialization - GCREGISTER gcr = {}; - gcr.dwFlags = GC_TYPNOTIF; - gcr.ptszDispName = m_tszUserName; - gcr.pszModule = m_szModuleName; - Chat_Register(&gcr); -} - -WhatsAppProto::~WhatsAppProto() -{ -} - -///////////////////////////////////////////////////////////////////////////////////////// -// OnModulesLoaded emulator for an account - -void WhatsAppProto::OnModulesLoaded() -{ - // initialize contacts cache - m_arUsers.insert(new WAUser(0, m_szJid, false)); - - for (auto &cc : AccContacts()) { - bool bIsChat = isChatRoom(cc); - CMStringA szId(getMStringA(cc, bIsChat ? "ChatRoomID" : DBKEY_JID)); - if (!szId.IsEmpty()) - m_arUsers.insert(new WAUser(cc, szId, bIsChat)); - } -} - -///////////////////////////////////////////////////////////////////////////////////////// -// PROTO_INTERFACE implementation - -MCONTACT WhatsAppProto::AddToList(int flags, PROTOSEARCHRESULT *psr) -{ - if (psr->id.w == nullptr) - return NULL; - - auto *pUser = AddUser(T2Utf(psr->id.w), (flags & PALF_TEMPORARY) != 0); - db_unset(pUser->hContact, "CList", "NotOnList"); - - return pUser->hContact; -} - -INT_PTR WhatsAppProto::GetCaps(int type, MCONTACT) -{ - switch (type) { - case PFLAGNUM_1: - return PF1_IM | PF1_FILE | PF1_CHAT | PF1_BASICSEARCH | PF1_ADDSEARCHRES | PF1_MODEMSGRECV; - case PFLAGNUM_2: - return PF2_ONLINE; - case PFLAGNUM_3: - return 0; - case PFLAGNUM_4: - return PF4_NOCUSTOMAUTH | PF4_NOAUTHDENYREASON | PF4_IMSENDOFFLINE | PF4_OFFLINEFILES | PF4_SUPPORTTYPING | PF4_AVATARS | PF4_SERVERMSGID; - case PFLAGNUM_5: - return 0; - case PFLAG_UNIQUEIDTEXT: - return (DWORD_PTR)"WhatsApp ID"; - } - return 0; -} - -int WhatsAppProto::SetStatus(int new_status) -{ - if (m_iDesiredStatus == new_status) - return 0; - - if (!mir_wstrlen(m_wszNick)) { - Popup(0, LPGENW("You need to specify nick name in the Options dialog"), LPGENW("Error")); - return 0; - } - - int oldStatus = m_iStatus; - - // Routing statuses not supported by WhatsApp - switch (new_status) { - case ID_STATUS_OFFLINE: - m_iDesiredStatus = new_status; - break; - - case ID_STATUS_ONLINE: - case ID_STATUS_FREECHAT: - default: - m_iDesiredStatus = ID_STATUS_ONLINE; - break; - } - - if (m_iDesiredStatus == ID_STATUS_OFFLINE) { - SetServerStatus(m_iDesiredStatus); - - if (m_hServerConn != nullptr) - Netlib_Shutdown(m_hServerConn); - - m_iStatus = m_iDesiredStatus = ID_STATUS_OFFLINE; - ProtoBroadcastAck(NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE)oldStatus, m_iStatus); - } - else if (m_hServerConn == nullptr && !IsStatusConnecting(m_iStatus)) { - m_iStatus = ID_STATUS_CONNECTING; - ProtoBroadcastAck(NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE)oldStatus, m_iStatus); - - ForkThread(&WhatsAppProto::ServerThread); - } - else if (m_hServerConn != nullptr) { - SetServerStatus(m_iDesiredStatus); - - m_iStatus = m_iDesiredStatus; - ProtoBroadcastAck(0, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE)oldStatus, m_iStatus); - } - else ProtoBroadcastAck(NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE)oldStatus, m_iStatus); - - return 0; -} - -///////////////////////////////////////////////////////////////////////////////////////// - -void WhatsAppProto::OnSendMessage(const JSONNode &node, void*) -{ - CMStringA szPrefix= node["$id$"].as_mstring(); - - WAOwnMessage tmp(0, 0, szPrefix); - { - mir_cslock lck(m_csOwnMessages); - auto *pOwn = m_arOwnMsgs.find(&tmp); - if (pOwn == nullptr) - return; - - tmp.pktId = pOwn->pktId; - tmp.hContact = pOwn->hContact; - m_arOwnMsgs.remove(pOwn); - } - - int status = node["status"].as_int(); - if (status == 200) - ProtoBroadcastAck(tmp.hContact, ACKTYPE_MESSAGE, ACKRESULT_SUCCESS, (HANDLE)tmp.pktId); - else { - CMStringW wszError(FORMAT, TranslateT("Operation failed with server error status %d"), status); - ProtoBroadcastAck(tmp.hContact, ACKTYPE_MESSAGE, ACKRESULT_FAILED, (HANDLE)tmp.pktId, LPARAM(wszError.c_str())); - } -} - -int WhatsAppProto::SendMsg(MCONTACT hContact, int, const char *pszMsg) -{ - ptrA jid(getStringA(hContact, DBKEY_JID)); - if (jid == nullptr || pszMsg == nullptr) - return 0; - - if (!isOnline()) { - debugLogA("No connection"); - return 0; - } - - char msgId[16], szMsgId[33]; - Utils_GetRandom(msgId, sizeof(msgId)); - bin2hex(msgId, sizeof(msgId), szMsgId); - - auto *key = new proto::MessageKey(); - key->set_remotejid(jid); - key->set_fromme(true); - key->set_id(szMsgId); - - proto::WebMessageInfo msg; - msg.set_allocated_key(key); - msg.mutable_message()->set_conversation(pszMsg); - msg.set_messagetimestamp(_time64(0)); - - size_t cbBinaryLen = msg.ByteSizeLong(); - mir_ptr pBuf((BYTE *)mir_alloc(cbBinaryLen)); - msg.SerializeToArray(pBuf, (int)cbBinaryLen); - - WANode payLoad; - payLoad.title = "action"; - payLoad.addAttr("type", "relay"); - payLoad.content.assign(pBuf, cbBinaryLen); - - int pktId = WSSendNode(payLoad); - - mir_cslock lck(m_csOwnMessages); - m_arOwnMsgs.insert(new WAOwnMessage(pktId, hContact, szMsgId)); - return pktId; -} - -int WhatsAppProto::UserIsTyping(MCONTACT hContact, int) -{ - if (hContact && isOnline()) { - ptrA jid(getStringA(hContact, DBKEY_JID)); - if (jid && isOnline()) { - } - } - - return 0; -} - -///////////////////////////////////////////////////////////////////////////////////////// -// contacts search - -void WhatsAppProto::SearchAckThread(void *targ) -{ - Sleep(100); - - SearchParam *param = (SearchParam*)targ; - PROTOSEARCHRESULT psr = {}; - psr.cbSize = sizeof(psr); - psr.flags = PSR_UNICODE; - psr.nick.w = psr.firstName.w = psr.lastName.w = L""; - psr.id.w = (wchar_t*)param->jid.c_str(); - - ProtoBroadcastAck(NULL, ACKTYPE_SEARCH, ACKRESULT_DATA, (HANDLE)param->id, (LPARAM)&psr); - ProtoBroadcastAck(NULL, ACKTYPE_SEARCH, ACKRESULT_SUCCESS, (HANDLE)param->id, 0); - - delete param; -} - -HANDLE WhatsAppProto::SearchBasic(const wchar_t* id) -{ - if (!isOnline()) - return nullptr; - - // fake - we always accept search - SearchParam *param = new SearchParam(id, -1); - ForkThread(&WhatsAppProto::SearchAckThread, param); - return (HANDLE)param->id; -} - -////////////////////////////////////////////////////////////////////////////// - -static int enumCollections(const char *szSetting, void *param) -{ - auto *pList = (LIST *)param; - if (!memcmp(szSetting, "Collection_", 11)) - pList->insert(mir_strdup(szSetting)); - return 0; -} - -void WhatsAppProto::InitCollections() -{ - LIST settings(10); - db_enum_settings(0, enumCollections, m_szModuleName, &settings); - - for (auto &it : settings) { - m_arCollections.insert(new WACollection(it + 11, getDword(it))); - mir_free(it); - } -} diff --git a/protocols/WhatsAppWeb/src/proto.h b/protocols/WhatsAppWeb/src/proto.h deleted file mode 100644 index 6a6a97589b..0000000000 --- a/protocols/WhatsAppWeb/src/proto.h +++ /dev/null @@ -1,425 +0,0 @@ -/* - -WhatsAppWeb plugin for Miranda NG -Copyright © 2019-22 George Hazan - -*/ - -#if !defined(PROTO_H) -#define PROTO_H - -#define S_WHATSAPP_NET "@s.whatsapp.net" -#define APP_VERSION "2.2230.15" -#define KEY_BUNDLE_TYPE "\x05" - -class WhatsAppProto; -typedef void (WhatsAppProto:: *WA_PKT_HANDLER)(const WANode &node); - -struct WAMSG -{ - union { - uint32_t dwFlags = 0; - struct { - bool bPrivateChat : 1; - bool bGroupChat : 1; - bool bDirectStatus : 1; - bool bOtherStatus : 1; - bool bPeerBroadcast : 1; - bool bOtherBroadcast : 1; - bool bOffline : 1; - }; - }; -}; - -struct WARequest -{ - WARequest(const CMStringA &_1, WA_PKT_HANDLER _2, void *_3 = nullptr) : - szPacketId(_1), - pHandler(_2), - pUserInfo(_3) - {} - - CMStringA szPacketId; - WA_PKT_HANDLER pHandler; - void *pUserInfo; -}; - -struct WADevice -{ - WADevice(const char *_1, int _2) : - jid(_1), - key_index(_2) - {} - - WAJid jid; - int key_index; -}; - -struct WAPersistentHandler -{ - WAPersistentHandler(const char *_1, const char *_2, const char *_3, const char *_4, WA_PKT_HANDLER _5) : - pszTitle(_1), pszType(_2), pszXmlns(_3), pszChild(_4), pHandler(_5) - {} - - const char *pszTitle, *pszType, *pszXmlns, *pszChild; - WA_PKT_HANDLER pHandler; -}; - -struct WAHistoryMessage -{ - CMStringA jid, text; - DWORD timestamp; -}; - -struct WAUser -{ - WAUser(MCONTACT _1, const char *_2, bool _3 = false) : - hContact(_1), - szId(mir_strdup(_2)), - bIsGroupChat(_3), - arHistory(1) - { - } - - ~WAUser() - { - mir_free(szId); - } - - MCONTACT hContact; - DWORD dwModifyTag = 0; - char *szId; - bool bInited = false, bIsGroupChat; - SESSION_INFO *si = 0; - DWORD m_time1 = 0, m_time2 = 0; - OBJLIST arHistory; -}; - -struct WAOwnMessage -{ - WAOwnMessage(int _1, MCONTACT _2, const char *_3) : - pktId(_1), - hContact(_2), - szPrefix(_3) - {} - - int pktId; - MCONTACT hContact; - CMStringA szPrefix; -}; - -struct WACollection -{ - WACollection(const char *_1, int _2) : - szName(mir_strdup(_1)), - version(_2) - {} - - ptrA szName; - int version; - - MBinBuffer hash; - std::map indexValueMap; - - void parseRecord(const proto::SyncdRecord &rec, bool bSet); -}; - -class WANoise -{ - friend class WhatsAppProto; - - WhatsAppProto *ppro; - int readCounter = 0, writeCounter = 0; - bool bInitFinished = false, bSendIntro = false; - MBinBuffer salt, encKey, decKey; - uint8_t hash[32]; - - struct { - MBinBuffer priv, pub; - } noiseKeys, ephemeral; - - void deriveKey(const void *pData, size_t cbLen, MBinBuffer &write, MBinBuffer &read); - void mixIntoKey(const void *n, const void *p); - void updateHash(const void *pData, size_t cbLen); - -public: - WANoise(WhatsAppProto *_ppro); - - void finish(); - void init(); - - MBinBuffer decrypt(const void *pData, size_t cbLen); - MBinBuffer encrypt(const void *pData, size_t cbLen); - - size_t decodeFrame(const void *&pData, size_t &cbLen); - MBinBuffer encodeFrame(const void *pData, size_t cbLen); -}; - -class MSignalSession : public MZeroedObject -{ - friend class MSignalStore; - signal_protocol_address address; - session_cipher *cipher = nullptr; - -public: - CMStringA szName; - MBinBuffer sessionData, userData; - - MSignalSession(const CMStringA &_1, int _2); - ~MSignalSession(); - - bool hasAddress(const char *name, size_t name_len) const; - - __forceinline session_cipher* getCipher(void) const { return cipher; } - __forceinline int getDeviceId() const { return address.device_id; } -}; - -class MSignalStore -{ - void init(); - - signal_context *m_pContext; - signal_protocol_store_context *m_pStore; - -public: - PROTO_INTERFACE *pProto; - const char *prefix; - - OBJLIST arSessions; - - struct - { - MBinBuffer priv, pub; - } - signedIdentity; - - struct - { - MBinBuffer priv, pub, signature; - uint32_t keyid; - } preKey; - - MSignalStore(PROTO_INTERFACE *_1, const char *_2); - ~MSignalStore(); - - __forceinline signal_context *CTX() const { return m_pContext; } - - MSignalSession *createSession(const CMStringA &szName, int deviceId); - - signal_buffer* decryptSignalProto(const CMStringA &from, const char *pszType, const MBinBuffer &encrypted); - signal_buffer* decryptGroupSignalProto(const CMStringA &from, const CMStringA &author, const MBinBuffer &encrypted); - - void generatePrekeys(int count); - - void processSenderKeyMessage(const proto::Message_SenderKeyDistributionMessage &msg); -}; - -class WhatsAppProto : public PROTO -{ - friend class WANoise; - - class CWhatsAppProtoImpl - { - friend class WhatsAppProto; - WhatsAppProto &m_proto; - - CTimer m_keepAlive; - void OnKeepAlive(CTimer *) { - m_proto.SendKeepAlive(); - } - - CWhatsAppProtoImpl(WhatsAppProto &pro) : - m_proto(pro), - m_keepAlive(Miranda_GetSystemWindow(), UINT_PTR(this)) - { - m_keepAlive.OnEvent = Callback(this, &CWhatsAppProtoImpl::OnKeepAlive); - } - } m_impl; - - - bool m_bTerminated, m_bRespawn; - ptrW m_tszDefaultGroup; - - CMStringA m_szJid; - CMStringW m_tszAvatarFolder; - - EVP_PKEY *m_pKeys; // private & public keys - WANoise *m_noise; - - void UploadMorePrekeys(); - - // App state management - OBJLIST m_arCollections; - - void InitCollections(); - void ResyncServer(const OBJLIST &task); - - __forceinline WACollection *FindCollection(const char *pszName) - { return m_arCollections.find((WACollection *)&pszName); - } - - // Contacts management ///////////////////////////////////////////////////////////////// - - mir_cs m_csUsers; - OBJLIST m_arUsers; - - mir_cs m_csOwnMessages; - OBJLIST m_arOwnMsgs; - - OBJLIST m_arDevices; - - WAUser* FindUser(const char *szId); - WAUser* AddUser(const char *szId, bool bTemporary, bool isChat = false); - - // Group chats ///////////////////////////////////////////////////////////////////////// - - void InitChat(WAUser *pUser); - - // UI ////////////////////////////////////////////////////////////////////////////////// - - void CloseQrDialog(); - bool ShowQrCode(const CMStringA &ref); - - /// Network //////////////////////////////////////////////////////////////////////////// - - time_t m_lastRecvTime; - HNETLIBCONN m_hServerConn; - - mir_cs m_csPacketQueue; - OBJLIST m_arPacketQueue; - - LIST m_arPersistent; - WA_PKT_HANDLER FindPersistentHandler(const WANode &node); - - int m_iPacketId; - uint16_t m_wMsgPrefix[2]; - CMStringA GenerateMessageId(); - void ProcessMessage(WAMSG type, const proto::WebMessageInfo &msg); - - bool WSReadPacket(const WSHeader &hdr, MBinBuffer &buf); - int WSSend(const MessageLite &msg); - int WSSendNode(WANode &node, WA_PKT_HANDLER = nullptr); - - MBinBuffer DownloadEncryptedFile(const char *url, const std::string &mediaKeys, const char *pszType); - CMStringW GetTmpFileName(const char *pszClass, const char *addition); - - void OnLoggedIn(void); - void OnLoggedOut(void); - void ServerThreadWorker(void); - void ShutdownSession(void); - - void SendReceipt(const char *pszTo, const char *pszParticipant, const char *pszId, const char *pszType); - void SendKeepAlive(); - void SetServerStatus(int iStatus); - - /// Popups ///////////////////////////////////////////////////////////////////////////// - - HANDLE m_hPopupClass; - CMOption m_bUsePopups; - - void InitPopups(void); - void Popup(MCONTACT hContact, const wchar_t *szMsg, const wchar_t *szTitle); - - /// Request handlers /////////////////////////////////////////////////////////////////// - - void OnGetAvatarInfo(const JSONNode &node, void*); - void OnGetChatInfo(const JSONNode &node, void*); - void OnSendMessage(const JSONNode &node, void*); - - void OnProcessHandshake(const void *pData, int cbLen); - - void InitPersistentHandlers(); - void OnAccountSync(const WANode &node); - void OnIqBlockList(const WANode &node); - void OnIqCountPrekeys(const WANode &node); - void OnIqDoNothing(const WANode &node); - void OnIqPairDevice(const WANode &node); - void OnIqPairSuccess(const WANode &node); - void OnIqResult(const WANode &node); - void OnIqServerSync(const WANode &node); - void OnNotifyEncrypt(const WANode &node); - void OnReceiveInfo(const WANode &node); - void OnReceiveMessage(const WANode &node); - void OnServerSync(const WANode &node); - void OnStreamError(const WANode &node); - void OnSuccess(const WANode &node); - - // Signal - MSignalStore m_signalStore; - - // Binary packets - void ProcessBinaryPacket(const void *pData, size_t cbLen); - - // unzip operations - MBinBuffer unzip(const MBinBuffer &src); - - /// Avatars //////////////////////////////////////////////////////////////////////////// - CMStringW GetAvatarFileName(MCONTACT hContact); - - INT_PTR __cdecl GetAvatarInfo(WPARAM, LPARAM); - INT_PTR __cdecl GetAvatarCaps(WPARAM, LPARAM); - INT_PTR __cdecl GetMyAvatar(WPARAM, LPARAM); - INT_PTR __cdecl SetMyAvatar(WPARAM, LPARAM); - -public: - WhatsAppProto(const char *proto_name, const wchar_t *username); - ~WhatsAppProto(); - - __forceinline bool isOnline() const - { return m_hServerConn != 0; - } - - __forceinline void writeStr(const char *pszSetting, const JSONNode &node) - { - CMStringW str(node.as_mstring()); - if (!str.IsEmpty()) - setWString(pszSetting, str); - } - - class CWhatsAppQRDlg *m_pQRDlg; - - // PROTO_INTERFACE ///////////////////////////////////////////////////////////////////// - - MCONTACT AddToList(int flags, PROTOSEARCHRESULT *psr) override; - INT_PTR GetCaps(int type, MCONTACT hContact = NULL) override; - HANDLE SearchBasic(const wchar_t* id) override; - int SendMsg(MCONTACT hContact, int flags, const char* msg) override; - int SetStatus(int iNewStatus) override; - int UserIsTyping(MCONTACT hContact, int type) override; - - void OnModulesLoaded() override; - - // Services //////////////////////////////////////////////////////////////////////////// - - INT_PTR __cdecl SvcCreateAccMgrUI(WPARAM, LPARAM); - - // Events ////////////////////////////////////////////////////////////////////////////// - - int __cdecl OnOptionsInit(WPARAM, LPARAM); - int __cdecl OnBuildStatusMenu(WPARAM, LPARAM); - - // Options ///////////////////////////////////////////////////////////////////////////// - - CMOption m_wszNick; // your nick name in presence - CMOption m_wszDefaultGroup; // clist group to store contacts - CMOption m_bHideGroupchats; // do not open chat windows on creation - - // Processing Threads ////////////////////////////////////////////////////////////////// - - void __cdecl SearchAckThread(void*); - void __cdecl ServerThread(void*); -}; - -struct CMPlugin : public ACCPROTOPLUGIN -{ - HNETLIBUSER hAvatarUser = nullptr; - HNETLIBCONN hAvatarConn = nullptr; - bool SaveFile(const char *pszUrl, PROTO_AVATAR_INFORMATION &ai); - - CMPlugin(); - - int Load() override; - int Unload() override; -}; - -#endif diff --git a/protocols/WhatsAppWeb/src/qrcode.cpp b/protocols/WhatsAppWeb/src/qrcode.cpp deleted file mode 100644 index daea9d5380..0000000000 --- a/protocols/WhatsAppWeb/src/qrcode.cpp +++ /dev/null @@ -1,124 +0,0 @@ -/* - -WhatsAppWeb plugin for Miranda NG -Copyright © 2019-22 George Hazan - -*/ - -#include "stdafx.h" - -class CWhatsAppQRDlg : public CProtoDlgBase -{ -public: - CWhatsAppQRDlg(WhatsAppProto *ppro) : - CProtoDlgBase(ppro, IDD_SHOWQR) - {} - - void SetData(const CMStringA &str) - { - auto *pQR = QRcode_encodeString(str, 0, QR_ECLEVEL_L, QR_MODE_8, 1); - - HWND hwndRc = GetDlgItem(m_hwnd, IDC_QRPIC); - RECT rc; - GetClientRect(hwndRc, &rc); - - ::SetForegroundWindow(m_hwnd); - - int scale = 8; // (rc.bottom - rc.top) / pQR->width; - int rowLen = pQR->width * scale * 3; - if (rowLen % 4) - rowLen = (rowLen / 4 + 1) * 4; - int dataLen = rowLen * pQR->width * scale; - - mir_ptr pData((BYTE *)mir_alloc(dataLen)); - if (pData == nullptr) { - QRcode_free(pQR); - return; - } - - memset(pData, 0xFF, dataLen); // white background by default - - const BYTE *s = pQR->data; - for (int y = 0; y < pQR->width; y++) { - BYTE *d = pData.get() + rowLen * y * scale; - for (int x = 0; x < pQR->width; x++) { - if (*s & 1) - for (int i = 0; i < scale; i++) - for (int j = 0; j < scale; j++) { - d[j * 3 + i * rowLen] = 0; - d[1 + j * 3 + i * rowLen] = 0; - d[2 + j * 3 + i * rowLen] = 0; - } - - d += scale * 3; - s++; - } - } - - BITMAPFILEHEADER fih = {}; - fih.bfType = 0x4d42; // "BM" - fih.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + dataLen; - fih.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER); - - BITMAPINFOHEADER bih = {}; - bih.biSize = sizeof(BITMAPINFOHEADER); - bih.biWidth = pQR->width * scale; - bih.biHeight = -bih.biWidth; - bih.biPlanes = 1; - bih.biBitCount = 24; - bih.biCompression = BI_RGB; - - wchar_t wszTempPath[MAX_PATH], wszTempFile[MAX_PATH]; - GetTempPathW(_countof(wszTempPath), wszTempPath); - GetTempFileNameW(wszTempPath, L"wa_", TRUE, wszTempFile); - FILE *f = _wfopen(wszTempFile, L"wb"); - fwrite(&fih, sizeof(BITMAPFILEHEADER), 1, f); - fwrite(&bih, sizeof(BITMAPINFOHEADER), 1, f); - fwrite(pData, sizeof(unsigned char), dataLen, f); - fclose(f); - - SendMessage(hwndRc, STM_SETIMAGE, IMAGE_BITMAP, (LPARAM)Image_Load(wszTempFile)); - - DeleteFileW(wszTempFile); - QRcode_free(pQR); - } -}; - -static INT_PTR __stdcall sttShowDialog(void *param) -{ - WhatsAppProto *ppro = (WhatsAppProto *)param; - - if (ppro->m_pQRDlg == nullptr) { - ppro->m_pQRDlg = new CWhatsAppQRDlg(ppro); - ppro->m_pQRDlg->Show(); - } - else { - SetForegroundWindow(ppro->m_pQRDlg->GetHwnd()); - SetActiveWindow(ppro->m_pQRDlg->GetHwnd()); - } - return 0; -} - -///////////////////////////////////////////////////////////////////////////////////////// - -void WhatsAppProto::CloseQrDialog() -{ - if (m_pQRDlg) { - m_pQRDlg->Close(); - m_pQRDlg = nullptr; - } -} - -bool WhatsAppProto::ShowQrCode(const CMStringA &ref) -{ - CallFunctionSync(sttShowDialog, this); - - MBinBuffer secret(getBlob(DBKEY_SECRET_KEY)); - - ptrA s1(mir_base64_encode(m_noise->noiseKeys.pub)); - ptrA s2(mir_base64_encode(m_signalStore.signedIdentity.pub)); - ptrA s3(mir_base64_encode(secret)); - CMStringA szQrData(FORMAT, "%s,%s,%s,%s", ref.c_str(), s1.get(), s2.get(), s3.get()); - m_pQRDlg->SetData(szQrData); - return true; -} diff --git a/protocols/WhatsAppWeb/src/resource.h b/protocols/WhatsAppWeb/src/resource.h deleted file mode 100644 index c09b549e42..0000000000 --- a/protocols/WhatsAppWeb/src/resource.h +++ /dev/null @@ -1,26 +0,0 @@ -//{{NO_DEPENDENCIES}} -// Microsoft Visual C++ generated include file. -// Used by W:\miranda-ng\protocols\WhatsAppWeb\res\whatsapp.rc -// -#define IDI_WHATSAPP 100 -#define IDD_ACCMGRUI 101 -#define IDD_OPTIONS 102 -#define IDD_SHOWQR 103 -#define IDC_HIDECHATS 1000 -#define IDC_DEFGROUP 1001 -#define IDC_QRPIC 1002 -#define IDC_DEFGROUP2 1002 -#define IDC_CLIST 1003 -#define IDC_NEWJID 1004 -#define IDC_NICK 1005 - -// Next default values for new objects -// -#ifdef APSTUDIO_INVOKED -#ifndef APSTUDIO_READONLY_SYMBOLS -#define _APS_NEXT_RESOURCE_VALUE 104 -#define _APS_NEXT_COMMAND_VALUE 40001 -#define _APS_NEXT_CONTROL_VALUE 1006 -#define _APS_NEXT_SYMED_VALUE 101 -#endif -#endif diff --git a/protocols/WhatsAppWeb/src/server.cpp b/protocols/WhatsAppWeb/src/server.cpp deleted file mode 100644 index 91f36b7df7..0000000000 --- a/protocols/WhatsAppWeb/src/server.cpp +++ /dev/null @@ -1,329 +0,0 @@ -/* - -WhatsAppWeb plugin for Miranda NG -Copyright © 2019-22 George Hazan - -*/ - -#include "stdafx.h" - -///////////////////////////////////////////////////////////////////////////////////////// -// gateway worker thread - -void WhatsAppProto::ServerThread(void *) -{ - do { - m_bRespawn = false; - ServerThreadWorker(); - } - while (m_bRespawn); - - OnLoggedOut(); -} - -void WhatsAppProto::ServerThreadWorker() -{ - // connect websocket - NETLIBHTTPHEADER hdrs[] = - { - { "Origin", "https://web.whatsapp.com" }, - { 0, 0 } - }; - - NLHR_PTR pReply(WebSocket_Connect(m_hNetlibUser, "web.whatsapp.com/ws/chat", hdrs)); - if (pReply == nullptr) { - debugLogA("Server connection failed, exiting"); - return; - } - - if (pReply->resultCode != 101) - return; - - delete m_noise; - m_noise = new WANoise(this); - m_noise->init(); - - debugLogA("Server connection succeeded"); - m_hServerConn = pReply->nlc; - m_lastRecvTime = time(0); - m_iPacketId = 1; - - Utils_GetRandom(m_wMsgPrefix, sizeof(m_wMsgPrefix)); - - auto &pubKey = m_noise->ephemeral.pub; - auto *client = new proto::HandshakeMessage::ClientHello(); client->set_ephemeral(pubKey.data(), pubKey.length()); - proto::HandshakeMessage msg; msg.set_allocated_clienthello(client); - WSSend(msg); - - MBinBuffer netbuf; - - for (m_bTerminated = false; !m_bTerminated;) { - unsigned char buf[2048]; - int bufSize = Netlib_Recv(m_hServerConn, (char *)buf, _countof(buf), MSG_NODUMP); - if (bufSize == 0) { - debugLogA("Gateway connection gracefully closed"); - break; - } - if (bufSize < 0) { - debugLogA("Gateway connection error, exiting"); - break; - } - - netbuf.append(buf, bufSize); - - WSHeader hdr; - if (!WebSocket_InitHeader(hdr, netbuf.data(), netbuf.length())) - continue; - - // we lack some data, let's read them - if (netbuf.length() < hdr.headerSize + hdr.payloadSize) - if (!WSReadPacket(hdr, netbuf)) - break; - - // debugLogA("Got packet: buffer = %d, opcode = %d, headerSize = %d, payloadSize = %d, final = %d, masked = %d", - // netbuf.length(), hdr.opCode, hdr.headerSize, hdr.payloadSize, hdr.bIsFinal, hdr.bIsMasked); - // Netlib_Dump(m_hServerConn, netbuf.data(), netbuf.length(), false, 0); - - m_lastRecvTime = time(0); - - // read all payloads from the current buffer, one by one - while (true) { - MBinBuffer currPacket; - currPacket.assign(netbuf.data() + hdr.headerSize, hdr.payloadSize); - - switch (hdr.opCode) { - case 1: // json packet - debugLogA("Text packet, skipping"); - /* - currPacket.append("", 1); // add 0 to use strchr safely - CMStringA szJson(pos, (int)dataSize); - - JSONNode root = JSONNode::parse(szJson); - if (root) { - debugLogA("JSON received:\n%s", start); - - CMStringA szPrefix(start, int(pos - start - 1)); - auto *pReq = m_arPacketQueue.find((WARequest *)&szPrefix); - if (pReq != nullptr) { - root << CHAR_PARAM("$id$", szPrefix); - } - } - } - */ - break; - - case 2: // binary packet - if (hdr.payloadSize > 32) - ProcessBinaryPacket(currPacket.data(), hdr.payloadSize); - break; - - case 8: // close - debugLogA("server required to exit"); - m_bRespawn = m_bTerminated = true; // simply reconnect, don't exit - break; - - default: - Netlib_Dump(m_hServerConn, currPacket.data(), hdr.payloadSize, false, 0); - } - - netbuf.remove(hdr.headerSize + hdr.payloadSize); - // debugLogA("%d bytes removed from network buffer, %d bytes remain", hdr.headerSize + hdr.payloadSize, netbuf.length()); - if (netbuf.length() == 0) - break; - - // if we have not enough data for header, continue reading - if (!WebSocket_InitHeader(hdr, netbuf.data(), netbuf.length())) { - debugLogA("not enough data for header, continue reading"); - break; - } - - // if we have not enough data for data, continue reading - if (hdr.headerSize + hdr.payloadSize > netbuf.length()) { - debugLogA("not enough place for data (%d+%d > %d), continue reading", hdr.headerSize, hdr.payloadSize, netbuf.length()); - break; - } - - debugLogA("Got inner packet: buffer = %d, opcode = %d, headerSize = %d, payloadSize = %d, final = %d, masked = %d", - netbuf.length(), hdr.opCode, hdr.headerSize, hdr.payloadSize, hdr.bIsFinal, hdr.bIsMasked); - } - } - - debugLogA("Server connection dropped"); - Netlib_CloseHandle(m_hServerConn); - m_hServerConn = nullptr; -} - -bool WhatsAppProto::WSReadPacket(const WSHeader &hdr, MBinBuffer &res) -{ - size_t currPacketSize = res.length() - hdr.headerSize; - - char buf[1024]; - while (currPacketSize < hdr.payloadSize) { - int result = Netlib_Recv(m_hServerConn, buf, _countof(buf), MSG_NODUMP); - if (result == 0) { - debugLogA("Gateway connection gracefully closed"); - return false; - } - if (result < 0) { - debugLogA("Gateway connection error, exiting"); - return false; - } - - currPacketSize += result; - res.append(buf, result); - } - return true; -} - -///////////////////////////////////////////////////////////////////////////////////////// -// Binary data processing - -void WhatsAppProto::ProcessBinaryPacket(const void *pData, size_t cbDataLen) -{ - while (size_t payloadLen = m_noise->decodeFrame(pData, cbDataLen)) { - if (m_noise->bInitFinished) { - MBinBuffer buf = m_noise->decrypt(pData, payloadLen); - - WAReader rdr(buf.data(), buf.length()); - auto b = rdr.readInt8(); - if (b & 2) { - buf.remove(1); - buf = unzip(buf); - rdr = WAReader(buf.data(), buf.length()); - } - - if (WANode *pNode = rdr.readNode()) { - CMStringA szText; - pNode->print(szText); - debugLogA("Got binary node:\n%s", szText.c_str()); - - auto pHandler = FindPersistentHandler(*pNode); - if (pHandler) - (this->*pHandler)(*pNode); - else - debugLogA("cannot handle incoming message"); - - delete pNode; - } - else { - debugLogA("wrong or broken payload"); - Netlib_Dump(m_hServerConn, pData, cbDataLen, false, 0); - } - } - else OnProcessHandshake(pData, (int)payloadLen); - - pData = (BYTE*)pData + payloadLen; - cbDataLen -= payloadLen; - } -} - -///////////////////////////////////////////////////////////////////////////////////////// - -void WhatsAppProto::OnLoggedIn() -{ - debugLogA("WhatsAppProto::OnLoggedIn"); - - SetServerStatus(m_iDesiredStatus); - - ProtoBroadcastAck(0, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE)m_iStatus, m_iDesiredStatus); - m_iStatus = m_iDesiredStatus; - - m_impl.m_keepAlive.Start(1000); - - // retrieve loaded prekeys count - WSSendNode( - WANodeIq(IQ::GET, "encrypt") << XCHILD("count"), - &WhatsAppProto::OnIqCountPrekeys); - - // retrieve initial info - WANodeIq abt(IQ::GET, "abt"); - abt.addChild("props")->addAttr("protocol", "1"); - WSSendNode(abt, &WhatsAppProto::OnIqDoNothing); - - WSSendNode( - WANodeIq(IQ::GET, "w") << XCHILD("props"), - &WhatsAppProto::OnIqDoNothing); - - WSSendNode( - WANodeIq(IQ::GET, "blocklist"), - &WhatsAppProto::OnIqBlockList); - - WSSendNode( - WANodeIq(IQ::GET, "privacy") << XCHILD("privacy"), - &WhatsAppProto::OnIqDoNothing); - - /* - OBJLIST task(1); - task.insert(new WACollection("regular_high", 9)); - task.insert(new WACollection("regular_low", 11)); - ResyncServer(task); - */ -} - -void WhatsAppProto::OnLoggedOut(void) -{ - m_impl.m_keepAlive.Stop(); - - debugLogA("WhatsAppProto::OnLoggedOut"); - m_bTerminated = true; - - ProtoBroadcastAck(0, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE)m_iStatus, ID_STATUS_OFFLINE); - m_iStatus = m_iDesiredStatus = ID_STATUS_OFFLINE; - - setAllContactStatuses(ID_STATUS_OFFLINE, false); -} - -void WhatsAppProto::SendKeepAlive() -{ - time_t now = time(0); - if (now - m_lastRecvTime > 20) { - WSSendNode(WANodeIq(IQ::GET, "w:p") << XCHILD("ping"), &WhatsAppProto::OnIqDoNothing); - - m_lastRecvTime = now; - } -} - -void WhatsAppProto::SendReceipt(const char *pszTo, const char *pszParticipant, const char *pszId, const char *pszType) -{ - WANode receipt("receipt"); - receipt << CHAR_PARAM("id", pszId); - - if (!mir_strcmp(pszType, "read") || !mir_strcmp(pszType, "read-self")) - receipt << INT_PARAM("t", time(0)); - - if (!mir_strcmp(pszType, "sender") && WAJid(pszTo).isUser()) - receipt << CHAR_PARAM("to", pszParticipant) << CHAR_PARAM("recipient", pszTo); - else { - receipt << CHAR_PARAM("to", pszTo); - if (pszParticipant) - receipt << CHAR_PARAM("participant", pszParticipant); - } - - if (pszType) - receipt << CHAR_PARAM("type", pszType); - WSSendNode(receipt, &WhatsAppProto::OnIqDoNothing); -} - -void WhatsAppProto::SetServerStatus(int iStatus) -{ - if (mir_wstrlen(m_wszNick)) - WSSendNode( - WANode("presence") << CHAR_PARAM("name", T2Utf(m_wszNick)) << CHAR_PARAM("type", (iStatus == ID_STATUS_ONLINE) ? "available" : "unavailable"), - &WhatsAppProto::OnIqDoNothing); -} - -///////////////////////////////////////////////////////////////////////////////////////// - -void WhatsAppProto::ShutdownSession() -{ - if (m_bTerminated) - return; - - debugLogA("WhatsAppProto::ShutdownSession"); - - // shutdown all resources - if (m_hServerConn) - Netlib_Shutdown(m_hServerConn); - - OnLoggedOut(); -} diff --git a/protocols/WhatsAppWeb/src/signal.cpp b/protocols/WhatsAppWeb/src/signal.cpp deleted file mode 100644 index bd75f0ff3a..0000000000 --- a/protocols/WhatsAppWeb/src/signal.cpp +++ /dev/null @@ -1,529 +0,0 @@ -/* - -WhatsAppWeb plugin for Miranda NG -Copyright © 2019-22 George Hazan - -*/ - -#include "stdafx.h" - -///////////////////////////////////////////////////////////////////////////////////////// -// MSignalStore members - -static int CompareSessions(const MSignalSession *p1, const MSignalSession *p2) -{ - if (int ret = mir_strcmp(p1->szName, p2->szName)) - return ret; - - return p1->getDeviceId() - p2->getDeviceId(); -} - -MSignalStore::MSignalStore(PROTO_INTERFACE *_1, const char *_2) : - pProto(_1), - prefix(_2), - arSessions(1, &CompareSessions) -{ - init(); -} - -MSignalStore::~MSignalStore() -{ - signal_protocol_store_context_destroy(m_pStore); - signal_context_destroy(m_pContext); -} - -///////////////////////////////////////////////////////////////////////////////////////// - -static void log_func(int level, const char *pmsg, size_t /*msgLen*/, void *pUserData) -{ - auto *pStore = (MSignalStore *)pUserData; - pStore->pProto->debugLogA("libsignal {%d}: %s", level, pmsg); -} - -static int hmac_sha256_init(void **hmac_context, const uint8_t *key, size_t key_len, void *) -{ - HMAC_CTX *ctx = HMAC_CTX_new(); - *hmac_context = ctx; - HMAC_Init(ctx, key, (int)key_len, EVP_sha256()); - return 0; -} - -static int hmac_sha256_update(void *hmac_context, const uint8_t *data, size_t data_len, void *) -{ - return HMAC_Update((HMAC_CTX *)hmac_context, data, data_len); -} - -static int hmac_sha256_final(void *hmac_context, signal_buffer **output, void *) -{ - BYTE data[200]; - unsigned len = 0; - if (!HMAC_Final((HMAC_CTX *)hmac_context, data, &len)) - return 1; - - *output = signal_buffer_create(data, len); - return 0; -} - -static void hmac_sha256_cleanup(void *hmac_context, void *) -{ - HMAC_CTX_free((HMAC_CTX *)hmac_context); -} - -static int random_func(uint8_t *pData, size_t size, void *) -{ - Utils_GetRandom(pData, size); - return 0; -} - -static int decrypt_func(signal_buffer **output, - int /*cipher*/, - const uint8_t *key, size_t /*key_len*/, - const uint8_t *iv, size_t /*iv_len*/, - const uint8_t *ciphertext, size_t ciphertext_len, - void * /*user_data*/) -{ - MBinBuffer res = aesDecrypt(EVP_aes_256_cbc(), key, iv, ciphertext, ciphertext_len); - *output = signal_buffer_create(res.data(), res.length()); - return SG_SUCCESS; -} - -static int contains_session_func(const signal_protocol_address *address, void *user_data) -{ - auto *pStore = (MSignalStore *)user_data; - - MSignalSession tmp(CMStringA(address->name, (int)address->name_len), address->device_id); - return pStore->arSessions.find(&tmp) == nullptr; -} - -static int delete_all_sessions_func(const char *name, size_t name_len, void *user_data) -{ - auto *pStore = (MSignalStore *)user_data; - auto &pList = pStore->arSessions; - - int count = 0; - for (auto &it : pList.rev_iter()) { - if (it->hasAddress(name, name_len)) { - pList.remove(pList.indexOf(&it)); - count++; - } - } - return count; -} - -int delete_session_func(const signal_protocol_address *address, void *user_data) -{ - auto *pStore = (MSignalStore *)user_data; - auto &pList = pStore->arSessions; - - MSignalSession tmp(CMStringA(address->name, (int)address->name_len), address->device_id); - int idx = pList.getIndex(&tmp); - if (idx != -1) - pList.remove(idx); - return 0; -} - -static int get_sub_device_sessions_func(signal_int_list **sessions, const char *name, size_t name_len, void *user_data) -{ - auto *pStore = (MSignalStore *)user_data; - CMStringA szName(name, (int)name_len); - - signal_int_list *l = signal_int_list_alloc(); - unsigned int array_size = 0; - - for (auto &it : pStore->arSessions) - if (it->szName == szName) { - array_size++; - signal_int_list_push_back(l, it->getDeviceId()); - } - - *sessions = l; - return array_size; -} - -static void destroy_func(void *) -{} - -int load_session_func(signal_buffer **record, signal_buffer **user_data_storage, const signal_protocol_address *address, void *user_data) -{ - auto *pStore = (MSignalStore *)user_data; - - MSignalSession tmp(CMStringA(address->name, (int)address->name_len), address->device_id); - if (auto *pSession = pStore->arSessions.find(&tmp)) { - *record = signal_buffer_create((uint8_t *)pSession->sessionData.data(), pSession->sessionData.length()); - *user_data_storage = signal_buffer_create((uint8_t *)pSession->userData.data(), pSession->userData.length()); - return 1; - } - - return 0; -} - -static int store_session_func(const signal_protocol_address *address, uint8_t *record, size_t record_len, uint8_t *user_record, size_t user_record_len, void *user_data) -{ - auto *pStore = (MSignalStore *)user_data; - - MSignalSession tmp(CMStringA(address->name, (int)address->name_len), address->device_id); - auto *pSession = pStore->arSessions.find(&tmp); - if (pSession == nullptr) { - pSession = new MSignalSession(tmp); - pStore->arSessions.insert(pSession); - } - - pSession->sessionData.assign(record, record_len); - pSession->userData.assign(user_record, user_record_len); - return 0; -} - -static int contains_pre_key(uint32_t pre_key_id, void *user_data) -{ - auto *pStore = (MSignalStore *)user_data; - - CMStringA szSetting(FORMAT, "%s%d", "PreKey", pre_key_id); - MBinBuffer blob(pStore->pProto->getBlob(szSetting)); - return (blob.data() != 0); -} - -static int load_pre_key(signal_buffer **record, uint32_t pre_key_id, void *user_data) -{ - auto *pStore = (MSignalStore *)user_data; - - CMStringA szSetting(FORMAT, "%s%d", "PreKey", pre_key_id); - MBinBuffer blob(pStore->pProto->getBlob(szSetting)); - if (blob.data() == 0) - return SG_ERR_INVALID_KEY_ID; - - *record = signal_buffer_create((uint8_t *)blob.data(), blob.length()); - return SG_SUCCESS; //key exists and succesfully loaded -} - -static int remove_pre_key(uint32_t pre_key_id, void *user_data) -{ - auto *pStore = (MSignalStore *)user_data; - - CMStringA szSetting(FORMAT, "%s%d", "PreKey", pre_key_id); - pStore->pProto->delSetting(szSetting); - - szSetting.Format("PreKey%uPublic", pre_key_id); - pStore->pProto->delSetting(szSetting); - - szSetting.Format("PreKey%uPrivate", pre_key_id); - pStore->pProto->delSetting(szSetting); - return 0; -} - -static int store_pre_key(uint32_t pre_key_id, uint8_t *record, size_t record_len, void *user_data) -{ - auto *pStore = (MSignalStore *)user_data; - - CMStringA szSetting(FORMAT, "%s%d", "PreKey", pre_key_id); - db_set_blob(0, pStore->pProto->m_szModuleName, szSetting, record, (unsigned int)record_len); - - session_pre_key *prekey = nullptr; - session_pre_key_deserialize(&prekey, record, record_len, pStore->CTX()); //TODO: handle error - if (prekey) { - ec_key_pair *pre_key_pair = session_pre_key_get_key_pair(prekey); - - SignalBuffer key_buf(ec_key_pair_get_public(pre_key_pair)); - szSetting.Format("PreKey%uPublic", pre_key_id); - db_set_blob(0, pStore->pProto->m_szModuleName, szSetting, key_buf.data(), key_buf.len()); - } - - return 0; -} - -static int contains_signed_pre_key(uint32_t signed_pre_key_id, void *user_data) -{ - auto *pStore = (MSignalStore *)user_data; - - CMStringA szSetting(FORMAT, "%s%d", "SignedPreKey", signed_pre_key_id); - MBinBuffer blob(pStore->pProto->getBlob(szSetting)); - return blob.data() != 0; -} - -static int load_signed_pre_key(signal_buffer **record, uint32_t signed_pre_key_id, void *user_data) -{ - auto *pStore = (MSignalStore *)user_data; - - CMStringA szSetting(FORMAT, "%s%d", "SignedPreKey", signed_pre_key_id); - MBinBuffer blob(pStore->pProto->getBlob(szSetting)); - if (blob.data() == 0) - return SG_ERR_INVALID_KEY_ID; - - *record = signal_buffer_create(blob.data(), blob.length()); - return SG_SUCCESS; //key exist and succesfully loaded -} - -static int store_signed_pre_key(uint32_t signed_pre_key_id, uint8_t *record, size_t record_len, void *user_data) -{ - auto *pStore = (MSignalStore *)user_data; - - CMStringA szSetting(FORMAT, "%s%d", "SignedPreKey", signed_pre_key_id); - db_set_blob(0, pStore->pProto->m_szModuleName, szSetting, record, (unsigned int)record_len); - return 0; -} - -static int remove_signed_pre_key(uint32_t signed_pre_key_id, void *user_data) -{ - auto *pStore = (MSignalStore *)user_data; - - CMStringA szSetting(FORMAT, "%s%d", "SignedPreKey", signed_pre_key_id); - pStore->pProto->delSetting(szSetting); - return 0; -} - -static int get_identity_key_pair(signal_buffer **public_data, signal_buffer **private_data, void *user_data) -{ - auto *pStore = (MSignalStore *)user_data; - - MBinBuffer buf; - buf.append(KEY_BUNDLE_TYPE, 1); - buf.append(pStore->signedIdentity.pub); - *public_data = signal_buffer_create(buf.data(), (int)buf.length()); - - *private_data = signal_buffer_create((uint8_t *)pStore->signedIdentity.priv.data(), (int)pStore->signedIdentity.priv.length()); - return 0; -} - -static int get_local_registration_id(void *user_data, uint32_t *registration_id) -{ - auto *pStore = (MSignalStore *)user_data; - *registration_id = pStore->pProto->getDword(DBKEY_REG_ID); - return 0; -} - -static int save_identity(const signal_protocol_address *address, uint8_t *key_data, size_t key_len, void *user_data) -{ - auto *pStore = (MSignalStore *)user_data; - - CMStringA szSetting(FORMAT, "%s_%s_%d", "SignalIdentity", CMStringA(address->name, (int)address->name_len).c_str(), address->device_id); - if (key_data != nullptr) - db_set_blob(0, pStore->pProto->m_szModuleName, szSetting, key_data, (unsigned int)key_len); //TODO: check return value - else - pStore->pProto->delSetting(szSetting); - return 0; -} - -static int is_trusted_identity(const signal_protocol_address * /*address*/, uint8_t * /*key_data*/, size_t /*key_len*/, void * /*user_data*/) -{ - return 1; -} - -void MSignalStore::init() -{ - signal_context_create(&m_pContext, this); - signal_context_set_log_function(m_pContext, log_func); - - signal_crypto_provider prov; - memset(&prov, 0xFF, sizeof(prov)); - prov.hmac_sha256_init_func = hmac_sha256_init; - prov.hmac_sha256_final_func = hmac_sha256_final; - prov.hmac_sha256_update_func = hmac_sha256_update; - prov.hmac_sha256_cleanup_func = hmac_sha256_cleanup; - prov.random_func = random_func; - prov.decrypt_func = decrypt_func; - signal_context_set_crypto_provider(m_pContext, &prov); - - // default values calculation - if (pProto->getDword(DBKEY_PREKEY_NEXT_ID, 0xFFFF) == 0xFFFF) { - // generate signed identity keys (private & public) - ratchet_identity_key_pair *keyPair; - signal_protocol_key_helper_generate_identity_key_pair(&keyPair, m_pContext); - - auto *pPubKey = ratchet_identity_key_pair_get_public(keyPair); - db_set_blob(0, pProto->m_szModuleName, DBKEY_SIGNED_IDENTITY_PUB, pPubKey->data, sizeof(pPubKey->data)); - - auto *pPrivKey = ratchet_identity_key_pair_get_private(keyPair); - db_set_blob(0, pProto->m_szModuleName, DBKEY_SIGNED_IDENTITY_PRIV, pPrivKey->data, sizeof(pPrivKey->data)); - - session_signed_pre_key *signed_pre_key; - signal_protocol_key_helper_generate_signed_pre_key(&signed_pre_key, keyPair, 1, time(0), m_pContext); - - SignalBuffer prekeyBuf(signed_pre_key); - db_set_blob(0, pProto->m_szModuleName, DBKEY_PREKEY, prekeyBuf.data(), prekeyBuf.len()); - SIGNAL_UNREF(signed_pre_key); - SIGNAL_UNREF(keyPair); - } - - // read resident data from database - signedIdentity.pub = pProto->getBlob(DBKEY_SIGNED_IDENTITY_PUB); - signedIdentity.priv = pProto->getBlob(DBKEY_SIGNED_IDENTITY_PRIV); - - MBinBuffer blob(pProto->getBlob(DBKEY_PREKEY)); - session_signed_pre_key *signed_pre_key; - session_signed_pre_key_deserialize(&signed_pre_key, blob.data(), blob.length(), m_pContext); - - ec_key_pair *pKeys = session_signed_pre_key_get_key_pair(signed_pre_key); - auto *pPubKey = ec_key_pair_get_public(pKeys); - preKey.pub.assign(pPubKey->data, sizeof(pPubKey->data)); - - auto *pPrivKey = ec_key_pair_get_private(pKeys); - preKey.priv.assign(pPrivKey->data, sizeof(pPrivKey->data)); - - preKey.signature.assign(session_signed_pre_key_get_signature(signed_pre_key), session_signed_pre_key_get_signature_len(signed_pre_key)); - preKey.keyid = session_signed_pre_key_get_id(signed_pre_key); - SIGNAL_UNREF(signed_pre_key); - - // create store with callbacks - signal_protocol_store_context_create(&m_pStore, m_pContext); - - signal_protocol_session_store ss; - ss.contains_session_func = &contains_session_func; - ss.delete_all_sessions_func = &delete_all_sessions_func; - ss.delete_session_func = &delete_session_func; - ss.destroy_func = &destroy_func; - ss.get_sub_device_sessions_func = &get_sub_device_sessions_func; - ss.load_session_func = &load_session_func; - ss.store_session_func = &store_session_func; - ss.user_data = this; - signal_protocol_store_context_set_session_store(m_pStore, &ss); - - signal_protocol_pre_key_store sp; - sp.contains_pre_key = &contains_pre_key; - sp.destroy_func = &destroy_func; - sp.load_pre_key = &load_pre_key; - sp.remove_pre_key = &remove_pre_key; - sp.store_pre_key = &store_pre_key; - sp.user_data = this; - signal_protocol_store_context_set_pre_key_store(m_pStore, &sp); - - signal_protocol_signed_pre_key_store ssp; - ssp.contains_signed_pre_key = &contains_signed_pre_key; - ssp.destroy_func = &destroy_func; - ssp.load_signed_pre_key = &load_signed_pre_key; - ssp.remove_signed_pre_key = &remove_signed_pre_key; - ssp.store_signed_pre_key = &store_signed_pre_key; - ssp.user_data = this; - signal_protocol_store_context_set_signed_pre_key_store(m_pStore, &ssp); - - signal_protocol_identity_key_store sip; - sip.destroy_func = &destroy_func; - sip.get_identity_key_pair = &get_identity_key_pair; - sip.get_local_registration_id = &get_local_registration_id; - sip.is_trusted_identity = &is_trusted_identity; - sip.save_identity = &save_identity; - sip.user_data = this; - signal_protocol_store_context_set_identity_key_store(m_pStore, &sip); -} - -///////////////////////////////////////////////////////////////////////////////////////// -// MSignalSession members - -MSignalSession::MSignalSession(const CMStringA &_1, int _2) : - szName(_1) -{ - address.name = szName.GetBuffer(); - address.name_len = szName.GetLength(); - address.device_id = _2; -} - -MSignalSession::~MSignalSession() -{ - session_cipher_free(cipher); -} - -bool MSignalSession::hasAddress(const char *name, size_t name_len) const -{ - if (address.name_len != name_len) - return false; - return memcmp(address.name, name, name_len) == 0; -} - -///////////////////////////////////////////////////////////////////////////////////////// - -MSignalSession* MSignalStore::createSession(const CMStringA &szName, int deviceId) -{ - MSignalSession tmp(szName, deviceId); - auto *pSession = arSessions.find(&tmp); - if (pSession == nullptr) { - pSession = new MSignalSession(szName, deviceId); - arSessions.insert(pSession); - } - - if (pSession->cipher == nullptr) - if (session_cipher_create(&pSession->cipher, m_pStore, &pSession->address, m_pContext) < 0) - throw "session_cipher_create failure"; - - return pSession; -} - -///////////////////////////////////////////////////////////////////////////////////////// - -signal_buffer* MSignalStore::decryptSignalProto(const CMStringA &from, const char *pszType, const MBinBuffer &encrypted) -{ - WAJid jid(from); - auto *pSession = createSession(jid.user, 0); - - signal_buffer *result = nullptr; - if (!mir_strcmp(pszType, "pkmsg")) { - pre_key_signal_message *pMsg; - if (pre_key_signal_message_deserialize(&pMsg, (BYTE *)encrypted.data(), encrypted.length(), m_pContext) < 0) - throw "unable to deserialize prekey message"; - - if (session_cipher_decrypt_pre_key_signal_message(pSession->getCipher(), pMsg, this, &result) < 0) - throw "unable to decrypt prekey message"; - - pre_key_signal_message_destroy((signal_type_base*)pMsg); - } - else { - signal_message *pMsg; - if (signal_message_deserialize(&pMsg, (BYTE *)encrypted.data(), encrypted.length(), m_pContext) < 0) - throw "unable to deserialize signal message"; - - if (session_cipher_decrypt_signal_message(pSession->getCipher(), pMsg, this, &result) < 0) - throw "unable to decrypt signal message"; - - signal_message_destroy((signal_type_base *)pMsg); - } - - return result; -} - -signal_buffer* MSignalStore::decryptGroupSignalProto(const CMStringA &group, const CMStringA &sender, const MBinBuffer &encrypted) -{ - WAJid jid(sender); - auto *pSession = createSession(group + CMStringA(FORMAT, "::%s::%d", jid.user.c_str(), jid.device), 0); - - signal_message *pMsg; - if (signal_message_deserialize(&pMsg, (BYTE *)encrypted.data(), encrypted.length(), m_pContext) < 0) - throw "unable to deserialize signal message"; - - signal_buffer *result = nullptr; - if (session_cipher_decrypt_signal_message(pSession->getCipher(), pMsg, this, &result) < 0) - throw "unable to decrypt signal message"; - - signal_message_destroy((signal_type_base *)pMsg); - return result; -} - -///////////////////////////////////////////////////////////////////////////////////////// -// generate and save pre keys set - -void MSignalStore::generatePrekeys(int count) -{ - int iNextKeyId = pProto->getDword(DBKEY_PREKEY_NEXT_ID, 1); - - CMStringA szSetting; - signal_protocol_key_helper_pre_key_list_node *keys_root; - signal_protocol_key_helper_generate_pre_keys(&keys_root, iNextKeyId, count, m_pContext); - for (auto *it = keys_root; it; it = signal_protocol_key_helper_key_list_next(it)) { - session_pre_key *pre_key = signal_protocol_key_helper_key_list_element(it); - uint32_t pre_key_id = session_pre_key_get_id(pre_key); - - SignalBuffer buf(pre_key); - szSetting.Format("PreKey%d", pre_key_id); - db_set_blob(0, pProto->m_szModuleName, szSetting, buf.data(), buf.len()); - - ec_key_pair *pre_key_pair = session_pre_key_get_key_pair(pre_key); - auto *pPubKey = ec_key_pair_get_public(pre_key_pair); - szSetting.Format("PreKey%dPublic", pre_key_id); - db_set_blob(0, pProto->m_szModuleName, szSetting, pPubKey->data, sizeof(pPubKey->data)); - } - signal_protocol_key_helper_key_list_free(keys_root); - - pProto->setDword(DBKEY_PREKEY_NEXT_ID, iNextKeyId + count); -} - -///////////////////////////////////////////////////////////////////////////////////////// - -void MSignalStore::processSenderKeyMessage(const proto::Message_SenderKeyDistributionMessage &) -{ -} diff --git a/protocols/WhatsAppWeb/src/stdafx.cxx b/protocols/WhatsAppWeb/src/stdafx.cxx deleted file mode 100644 index 8784e33705..0000000000 --- a/protocols/WhatsAppWeb/src/stdafx.cxx +++ /dev/null @@ -1,8 +0,0 @@ -/* - -WhatsAppWeb plugin for Miranda NG -Copyright © 2019-22 George Hazan - -*/ - -#include "stdafx.h" diff --git a/protocols/WhatsAppWeb/src/stdafx.h b/protocols/WhatsAppWeb/src/stdafx.h deleted file mode 100644 index 98fea4f388..0000000000 --- a/protocols/WhatsAppWeb/src/stdafx.h +++ /dev/null @@ -1,81 +0,0 @@ -/* - -WhatsAppWeb plugin for Miranda NG -Copyright © 2019-22 George Hazan - -*/ - -#pragma once -#pragma warning(disable:4996 4290 4200 4239 4324) - -#include -#include -#include -#include -#include - -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include - -#include "../../libs/libqrencode/src/qrencode.h" -#include "../../libs/zlib/src/zlib.h" - -#include "../../utils/mir_signal.h" - -///////////////////////////////////////////////////////////////////////////////////////// -// to obtain protobuf library do the following -// - install vcpkg (https://github.com/microsoft/vcpkg); -// - integrage vcpkg into Visual Studio: -// >vcpkg.exe integrate install -// - install dynamic libraries of protobuf: -// >vcpkg.exe install protobuf:x86-windows -// >vcpkg.exe install protobuf:x64-windows - -#include "google/protobuf/message.h" -#include "pmsg.pb.h" - -using namespace google::protobuf; - -///////////////////////////////////////////////////////////////////////////////////////// - -#include "db.h" -#include "utils.h" -#include "proto.h" -#include "resource.h" - -#pragma comment(lib, "libcrypto.lib") diff --git a/protocols/WhatsAppWeb/src/utils.cpp b/protocols/WhatsAppWeb/src/utils.cpp deleted file mode 100644 index c176a894fe..0000000000 --- a/protocols/WhatsAppWeb/src/utils.cpp +++ /dev/null @@ -1,373 +0,0 @@ -/* - -WhatsAppWeb plugin for Miranda NG -Copyright © 2019-22 George Hazan - -*/ - -#include "stdafx.h" - -WAJid::WAJid(const char *pszUser, const char *pszServer, int iDevice, int iAgent) : - user(pszUser ? pszUser : ""), - server(pszServer ? pszServer : ""), - device(iDevice), - agent(iAgent) -{} - -WAJid::WAJid(const char *pszJid) -{ - if (pszJid == nullptr) - pszJid = ""; - - auto *tmp = NEWSTR_ALLOCA(pszJid); - auto *p = strrchr(tmp, '@'); - if (p) { - *p = 0; - server = p + 1; - } - - if (p = strrchr(tmp, ':')) { - *p = 0; - device = atoi(p + 1); - } - else device = 0; - - if (p = strrchr(tmp, '_')) { - *p = 0; - agent = atoi(p + 1); - } - else agent = 0; - - user = tmp; -} - -bool WAJid::isUser() const -{ return server == "s.whatsapp.net"; -} - -bool WAJid::isGroup() const -{ return server == "g.us"; -} - -bool WAJid::isBroadcast() const -{ - return server == "broadcast"; -} - -bool WAJid::isStatusBroadcast() const -{ - return isBroadcast() && user == "status"; -} - -CMStringA WAJid::toString() const -{ - CMStringA ret(user); - if (agent > 0) - ret.AppendFormat("_%d", agent); - if (device > 0) - ret.AppendFormat(":%d", device); - ret.AppendFormat("@%s", server.c_str()); - return ret; -} - -///////////////////////////////////////////////////////////////////////////////////////// - -WAUser* WhatsAppProto::FindUser(const char *szId) -{ - mir_cslock lck(m_csUsers); - auto *tmp = (WAUser *)_alloca(sizeof(WAUser)); - tmp->szId = (char*)szId; - return m_arUsers.find(tmp); -} - -WAUser* WhatsAppProto::AddUser(const char *szId, bool bTemporary, bool isChat) -{ - auto *pUser = FindUser(szId); - if (pUser != nullptr) - return pUser; - - MCONTACT hContact = db_add_contact(); - Proto_AddToContact(hContact, m_szModuleName); - - if (isChat) { - setByte(hContact, "ChatRoom", 1); - setString(hContact, "ChatRoomID", szId); - } - else { - setString(hContact, DBKEY_JID, szId); - if (m_wszDefaultGroup) - Clist_SetGroup(hContact, m_wszDefaultGroup); - } - - if (bTemporary) - Contact::RemoveFromList(hContact); - - pUser = new WAUser(hContact, mir_strdup(szId)); - pUser->bIsGroupChat = isChat; - - mir_cslock lck(m_csUsers); - m_arUsers.insert(pUser); - return pUser; -} - -///////////////////////////////////////////////////////////////////////////////////////// - -WA_PKT_HANDLER WhatsAppProto::FindPersistentHandler(const WANode &pNode) -{ - auto *pChild = pNode.getFirstChild(); - CMStringA szChild = (pChild) ? pChild->title : ""; - CMStringA szTitle = pNode.title; - CMStringA szType = pNode.getAttr("type"); - CMStringA szXmlns = pNode.getAttr("xmlns"); - - for (auto &it : m_arPersistent) { - if (it->pszTitle && szTitle != it->pszTitle) - continue; - if (it->pszType && szType != it->pszType) - continue; - if (it->pszXmlns && szXmlns != it->pszXmlns) - continue; - if (it->pszChild && szChild != it->pszChild) - continue; - return it->pHandler; - } - - return nullptr; -} - -///////////////////////////////////////////////////////////////////////////////////////// - -CMStringA WhatsAppProto::GenerateMessageId() -{ - return CMStringA(FORMAT, "%d.%d-%d", m_wMsgPrefix[0], m_wMsgPrefix[1], m_iPacketId++); -} - -///////////////////////////////////////////////////////////////////////////////////////// -// sends a piece of JSON to a server via a websocket, masked - -int WhatsAppProto::WSSend(const MessageLite &msg) -{ - if (m_hServerConn == nullptr) - return -1; - - int cbLen = msg.ByteSize(); - ptrA protoBuf((char *)mir_alloc(cbLen)); - msg.SerializeToArray(protoBuf, cbLen); - - Netlib_Dump(m_hServerConn, protoBuf, cbLen, true, 0); - - MBinBuffer payload = m_noise->encodeFrame(protoBuf, cbLen); - WebSocket_SendBinary(m_hServerConn, payload.data(), payload.length()); - return 0; -} - -///////////////////////////////////////////////////////////////////////////////////////// - -static char zeroData[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; - -int WhatsAppProto::WSSendNode(WANode &node, WA_PKT_HANDLER pHandler) -{ - if (m_hServerConn == nullptr) - return 0; - - if (pHandler != nullptr) { - CMStringA id(GenerateMessageId()); - node.addAttr("id", id); - - mir_cslock lck(m_csPacketQueue); - m_arPacketQueue.insert(new WARequest(id, pHandler)); - } - - CMStringA szText; - node.print(szText); - debugLogA("Sending binary node:\n%s", szText.c_str()); - - WAWriter writer; - writer.writeNode(&node); - - MBinBuffer encData = m_noise->encrypt(writer.body.data(), writer.body.length()); - MBinBuffer payload = m_noise->encodeFrame(encData.data(), encData.length()); - WebSocket_SendBinary(m_hServerConn, payload.data(), payload.length()); - return 1; -} - -///////////////////////////////////////////////////////////////////////////////////////// - -uint32_t decodeBigEndian(const std::string &buf) -{ - uint32_t ret = 0; - for (auto &cc : buf) { - ret <<= 8; - ret += (uint8_t)cc; - } - - return ret; -} - -std::string encodeBigEndian(uint32_t num, size_t len) -{ - std::string res; - for (int i = 0; i < len; i++) { - char c = num & 0xFF; - res = c + res; - num >>= 8; - } - return res; -} - -void generateIV(uint8_t *iv, int &pVar) -{ - auto counter = encodeBigEndian(pVar); - memset(iv, 0, sizeof(iv)); - memcpy(iv + 8, counter.c_str(), sizeof(int)); - - pVar++; -} - -///////////////////////////////////////////////////////////////////////////////////////// -// Popups - -void WhatsAppProto::InitPopups(void) -{ - g_plugin.addPopupOption(CMStringW(FORMAT, TranslateT("%s error notifications"), m_tszUserName), m_bUsePopups); - - char name[256]; - mir_snprintf(name, "%s_%s", m_szModuleName, "Error"); - - wchar_t desc[256]; - mir_snwprintf(desc, L"%s/%s", m_tszUserName, TranslateT("Errors")); - - POPUPCLASS ppc = {}; - ppc.flags = PCF_UNICODE; - ppc.pszName = name; - ppc.pszDescription.w = desc; - ppc.hIcon = IcoLib_GetIconByHandle(m_hProtoIcon); - ppc.colorBack = RGB(191, 0, 0); //Red - ppc.colorText = RGB(255, 245, 225); //Yellow - ppc.iSeconds = 60; - m_hPopupClass = Popup_RegisterClass(&ppc); - - IcoLib_ReleaseIcon(ppc.hIcon); -} - -void WhatsAppProto::Popup(MCONTACT hContact, const wchar_t *szMsg, const wchar_t *szTitle) -{ - if (!m_bUsePopups) - return; - - char name[256]; - mir_snprintf(name, "%s_%s", m_szModuleName, "Error"); - - CMStringW wszTitle(szTitle); - if (hContact == 0) { - wszTitle.Insert(0, L": "); - wszTitle.Insert(0, m_tszUserName); - } - - POPUPDATACLASS ppd = {}; - ppd.szTitle.w = wszTitle; - ppd.szText.w = szMsg; - ppd.pszClassName = name; - ppd.hContact = hContact; - Popup_AddClass(&ppd); -} - -///////////////////////////////////////////////////////////////////////////////////////// - -MBinBuffer WhatsAppProto::unzip(const MBinBuffer &src) -{ - z_stream strm = {}; - inflateInit(&strm); - - strm.avail_in = (uInt)src.length(); - strm.next_in = (Bytef *)src.data(); - - MBinBuffer res; - Bytef buf[2048]; - - while (strm.avail_in > 0) { - strm.avail_out = sizeof(buf); - strm.next_out = buf; - - int ret = inflate(&strm, Z_NO_FLUSH); - switch (ret) { - case Z_NEED_DICT: - ret = Z_DATA_ERROR; - __fallthrough; - - case Z_DATA_ERROR: - case Z_MEM_ERROR: - inflateEnd(&strm); - return res; - } - - res.append(buf, sizeof(buf) - strm.avail_out); - } - - inflateEnd(&strm); - return res; -} - -///////////////////////////////////////////////////////////////////////////////////////// - -void bin2file(const MBinBuffer &buf, const wchar_t *pwszFileName) -{ - int fileId = _wopen(pwszFileName, _O_WRONLY | _O_TRUNC | _O_BINARY | _O_CREAT, _S_IREAD | _S_IWRITE); - if (fileId != -1) { - write(fileId, buf.data(), (unsigned)buf.length()); - close(fileId); - } -} - -void string2file(const std::string &str, const wchar_t *pwszFileName) -{ - int fileId = _wopen(pwszFileName, _O_WRONLY | _O_TRUNC | _O_BINARY | _O_CREAT, _S_IREAD | _S_IWRITE); - if (fileId != -1) { - write(fileId, str.c_str(), (unsigned)str.size()); - close(fileId); - } -} - -CMStringA directPath2url(const char *pszDirectPath) -{ - return CMStringA("https://mmg.whatsapp.net") + pszDirectPath; -} - -MBinBuffer WhatsAppProto::DownloadEncryptedFile(const char *url, const std::string &mediaKeys, const char *pszMediaType) -{ - NETLIBHTTPHEADER headers[1] = {{"Origin", "https://web.whatsapp.com"}}; - - NETLIBHTTPREQUEST req = {}; - req.cbSize = sizeof(req); - req.requestType = REQUEST_GET; - req.szUrl = (char*)url; - req.headersCount = _countof(headers); - req.headers = headers; - - MBinBuffer ret; - auto *pResp = Netlib_HttpTransaction(m_hNetlibUser, &req); - if (pResp) { - if (pResp->resultCode == 200) { - CMStringA pszHkdfString = pszMediaType; - pszHkdfString.SetAt(_toupper(pszHkdfString[0]), 0); - pszHkdfString = "WhatsApp " + pszHkdfString + " Keys"; - - // 0 - 15: iv - // 16 - 47: cipherKey - // 48 - 111: macKey - uint8_t out[112]; - HKDF(EVP_sha256(), (BYTE *)"", 0, (BYTE *)mediaKeys.c_str(), (int)mediaKeys.size(), (BYTE *)pszHkdfString.c_str(), pszHkdfString.GetLength(), out, sizeof(out)); - - ret = aesDecrypt(EVP_aes_256_cbc(), out + 16, out, pResp->pData, pResp->dataLength); - } - } - - return ret; -} - -CMStringW WhatsAppProto::GetTmpFileName(const char *pszClass, const char *pszAddition) -{ - CMStringW ret(VARSW(L"%miranda_userdata%")); - ret.AppendFormat(L"/%S/%S_%S", m_szModuleName, pszClass, pszAddition); - return ret; -} diff --git a/protocols/WhatsAppWeb/src/utils.h b/protocols/WhatsAppWeb/src/utils.h deleted file mode 100644 index b8ab1ee155..0000000000 --- a/protocols/WhatsAppWeb/src/utils.h +++ /dev/null @@ -1,199 +0,0 @@ -/* - -WhatsAppWeb plugin for Miranda NG -Copyright © 2019-22 George Hazan - -*/ - -#define DICT_VERSION 2 - -#define LIST_EMPTY 0 -#define STREAM_END 2 -#define DICTIONARY_0 236 -#define DICTIONARY_1 237 -#define DICTIONARY_2 238 -#define DICTIONARY_3 239 -#define AD_JID 247 -#define LIST_8 248 -#define LIST_16 249 -#define JID_PAIR 250 -#define HEX_8 251 -#define BINARY_8 252 -#define BINARY_20 253 -#define BINARY_32 254 -#define NIBBLE_8 255 - -class WANode // kinda XML -{ - friend class WAReader; - friend class WAWriter; - - WANode *pParent = nullptr; - OBJLIST attrs; - OBJLIST children; - -public: - WANode(); - WANode(const char *pszTitle); - ~WANode(); - - void addAttr(const char *pszName, const char *pszValue); - void addAttr(const char *pszName, int iValue); - int getAttrInt(const char *pszName) const; - const char *getAttr(const char *pszName) const; - - CMStringA getBody() const; - - WANode *addChild(const char *pszName); - WANode *getChild(const char *pszName) const; - WANode *getFirstChild(void) const; - const OBJLIST &getChildren(void) const - { return children; - } - - void print(CMStringA &dest, int level = 0) const; - - CMStringA title; - MBinBuffer content; -}; - -__forceinline WANode &operator<<(WANode &node, const CHAR_PARAM ¶m) -{ - node.addAttr(param.szName, param.szValue); - return node; -} - -__forceinline WANode &operator<<(WANode &node, const INT_PARAM ¶m) -{ - node.addAttr(param.szName, param.iValue); - return node; -} - -///////////////////////////////////////////////////////////////////////////////////////// - -namespace IQ -{ - enum Type { GET, SET, RESULT }; -}; - -struct WANodeIq : public WANode -{ - WANodeIq(IQ::Type type, const char *pszXmlns = nullptr, const char *pszTo = nullptr); -}; - -///////////////////////////////////////////////////////////////////////////////////////// - -struct XCHILD -{ - const char *name, *value; - - __forceinline XCHILD(const char *_name) : - name(_name) - {} -}; - -__forceinline WANode& operator<<(WANode &node, const XCHILD &child) -{ - node.addChild(child.name); - return node; -} - -///////////////////////////////////////////////////////////////////////////////////////// -// WAReader - -class WAReader -{ - const BYTE *m_buf, *m_limit; - - uint32_t readIntN(int i); - CMStringA readStringFromChars(int size); - - bool readAttributes(WANode *node, int count); - uint32_t readInt20(); - bool readList(WANode *pParent, int tag); - int readListSize(int tag); - CMStringA readPacked(int tag); - CMStringA readString(int tag); - -public: - WAReader(const void *buf, size_t cbLen) : - m_buf((BYTE*)buf), - m_limit((BYTE*)buf + cbLen) - {} - - WANode* readNode(); - - __forceinline uint32_t readInt8() { return readIntN(1); } - __forceinline uint32_t readInt16() { return readIntN(2); } - __forceinline uint32_t readInt32() { return readIntN(4); } -}; - -///////////////////////////////////////////////////////////////////////////////////////// -// WAWriter - -class WAWriter -{ - __forceinline void writeInt8(int value) { writeIntN(value, 1); } - __forceinline void writeInt16(int value) { writeIntN(value, 2); } - __forceinline void writeInt32(int value) { writeIntN(value, 4); } - - void writeByte(uint8_t b); - void writeIntN(int value, int i); - void writeInt20(int value); - void writeLength(int value); - void writeListSize(int tag); - void writePacked(const CMStringA &str, int tag); - void writeString(const char *str); - bool writeToken(const char *str); - -public: - void writeNode(const WANode *pNode); - - MBinBuffer body; -}; - -///////////////////////////////////////////////////////////////////////////////////////// - -struct WAJid -{ - int device, agent; - CMStringA user, server; - - WAJid(const char *pszJid); - WAJid(const char *pszUser, const char *pszServer, int device = 0, int agent = 0); - - CMStringA toString() const; - - bool isUser() const; - bool isGroup() const; - bool isBroadcast() const; - bool isStatusBroadcast() const; -}; - -///////////////////////////////////////////////////////////////////////////////////////// - -void bin2file(const MBinBuffer &buf, const wchar_t *pwszFileName); -void string2file(const std::string &str, const wchar_t *pwszFileName); -CMStringA directPath2url(const char *pszDirectPath); - -MBinBuffer aesDecrypt( - const EVP_CIPHER *cipher, - const uint8_t *key, - const uint8_t *iv, - const void *data, size_t dataLen, - const void *additionalData = 0, size_t additionalLen = 0); - -uint32_t decodeBigEndian(const std::string &buf); -std::string encodeBigEndian(uint32_t num, size_t len = sizeof(uint32_t)); - -void generateIV(uint8_t *iv, int &pVar); - -__forceinline bool operator<<(MessageLite &msg, const MBinBuffer &buf) -{ return msg.ParseFromArray(buf.data(), (int)buf.length()); -} - -unsigned char* HKDF(const EVP_MD *evp_md, - const unsigned char *salt, size_t salt_len, - const unsigned char *key, size_t key_len, - const unsigned char *info, size_t info_len, - unsigned char *okm, size_t okm_len); diff --git a/protocols/WhatsAppWeb/src/version.h b/protocols/WhatsAppWeb/src/version.h deleted file mode 100644 index 7d230a73bf..0000000000 --- a/protocols/WhatsAppWeb/src/version.h +++ /dev/null @@ -1,14 +0,0 @@ -#define __MAJOR_VERSION 0 -#define __MINOR_VERSION 0 -#define __RELEASE_NUM 1 -#define __BUILD_NUM 1 - -#include - -#define __PLUGIN_NAME "WhatsAppWeb protocol" -#define __FILENAME "WhatsAppWeb.dll" -#define __DESCRIPTION "WhatsApp Web protocol support for Miranda NG." -#define __AUTHOR "George Hazan" -#define __AUTHOREMAIL "" -#define __AUTHORWEB "https://miranda-ng.org/p/WhatsApp/" -#define __COPYRIGHT "© 2019-22 Miranda NG Team" diff --git a/protocols/WhatsAppWeb/src/wanode.cpp b/protocols/WhatsAppWeb/src/wanode.cpp deleted file mode 100644 index 5bc78d32cc..0000000000 --- a/protocols/WhatsAppWeb/src/wanode.cpp +++ /dev/null @@ -1,599 +0,0 @@ -/* - -WhatsAppWeb plugin for Miranda NG -Copyright © 2019-22 George Hazan - -*/ - -#include "stdafx.h" -#include "dicts.h" - -struct Attr -{ - Attr(const char *pszName, const char *pszValue) : - name(pszName), - value(pszValue) - {} - - Attr(const char *pszName, int iValue) : - name(pszName), - value(FORMAT, "%d", iValue) - {} - - CMStringA name, value; -}; - -///////////////////////////////////////////////////////////////////////////////////////// -// WANodeIq members - -WANodeIq::WANodeIq(IQ::Type type, const char *pszXmlns, const char *pszTo) : - WANode("iq") -{ - switch (type) { - case IQ::GET: addAttr("type", "get"); break; - case IQ::SET: addAttr("type", "set"); break; - case IQ::RESULT: addAttr("type", "result"); break; - } - - if (pszXmlns) - addAttr("xmlns", pszXmlns); - - addAttr("to", pszTo ? pszTo : S_WHATSAPP_NET); -} - -///////////////////////////////////////////////////////////////////////////////////////// -// WANode members - -WANode::WANode() : - attrs(1), - children(1) -{} - -WANode::WANode(const char *pszTitle) : - attrs(1), - children(1), - title(pszTitle) -{} - -WANode::~WANode() -{ -} - -const char *WANode::getAttr(const char *pszName) const -{ - if (this != nullptr) - for (auto &p : attrs) - if (p->name == pszName) - return p->value.c_str(); - - return nullptr; -} - -int WANode::getAttrInt(const char *pszName) const -{ - if (this != nullptr) - for (auto &p : attrs) - if (p->name == pszName) - return atoi(p->value.c_str()); - - return 0; -} - -void WANode::addAttr(const char *pszName, const char *pszValue) -{ - attrs.insert(new Attr(pszName, pszValue)); -} - -void WANode::addAttr(const char *pszName, int iValue) -{ - attrs.insert(new Attr(pszName, iValue)); -} - -CMStringA WANode::getBody() const -{ - return CMStringA((char *)content.data(), (int)content.length()); -} - -WANode *WANode::addChild(const char *pszName) -{ - auto *pNew = new WANode(pszName); - pNew->pParent = this; - children.insert(pNew); - return pNew; -} - -WANode* WANode::getChild(const char *pszName) const -{ - for (auto &it : children) - if (it->title == pszName) - return it; - - return nullptr; -} - -WANode* WANode::getFirstChild(void) const -{ - return (children.getCount()) ? &children[0] : nullptr; -} - -void WANode::print(CMStringA &dest, int level) const -{ - for (int i = 0; i < level; i++) - dest.Append(" "); - - dest.AppendFormat("<%s ", title.c_str()); - for (auto &p : attrs) - dest.AppendFormat("%s=\"%s\" ", p->name.c_str(), p->value.c_str()); - dest.Truncate(dest.GetLength() - 1); - - if (content.isEmpty() && !children.getCount()) { - dest.Append("/>\n"); - return; - } - - dest.Append(">"); - if (!content.isEmpty()) { - ptrA tmp((char *)mir_alloc(content.length() * 2 + 1)); - bin2hex(content.data(), content.length(), tmp); - dest.AppendFormat("%s", tmp.get()); - } - - if (children.getCount()) { - dest.Append("\n"); - - for (auto &p : children) - p->print(dest, level + 1); - - for (int i = 0; i < level; i++) - dest.Append(" "); - } - - dest.AppendFormat("\n", title.c_str()); -} - -///////////////////////////////////////////////////////////////////////////////////////// -// WAReader class members - -bool WAReader::readAttributes(WANode *pNode, int count) -{ - if (count == 0) - return true; - - for (int i = 0; i < count; i++) { - CMStringA name = readString(readInt8()); - if (name.IsEmpty()) - return false; - - CMStringA value = readString(readInt8()); - if (value.IsEmpty()) - return false; - - pNode->addAttr(name, value); - } - return true; -} - -uint32_t WAReader::readInt20() -{ - if (m_limit - m_buf < 3) - return 0; - - int ret = (int(m_buf[0] & 0x0F) << 16) + (int(m_buf[1]) << 8) + int(m_buf[2]); - m_buf += 3; - return ret; -} - -uint32_t WAReader::readIntN(int n) -{ - if (m_limit - m_buf < n) - return 0; - - uint32_t res = 0; - for (int i = 0; i < n; i++, m_buf++) - res = (res <<= 8) + *m_buf; - return res; -} - -bool WAReader::readList(WANode *pParent, int tag) -{ - int size = readListSize(tag); - if (size == -1) - return false; - - for (int i = 0; i < size; i++) { - WANode *pNew = readNode(); - if (pNew == nullptr) - return false; - pParent->children.insert(pNew); - } - - return true; -} - -int WAReader::readListSize(int tag) -{ - switch (tag) { - case LIST_EMPTY: - return 0; - case LIST_8: - return readInt8(); - case LIST_16: - return readInt16(); - } - return -1; -} - -WANode *WAReader::readNode() -{ - int listSize = readListSize(readInt8()); - if (listSize == -1) - return nullptr; - - int descrTag = readInt8(); - if (descrTag == STREAM_END) - return nullptr; - - CMStringA name = readString(descrTag); - if (name.IsEmpty()) - return nullptr; - - std::unique_ptr ret(new WANode()); - ret->title = name.c_str(); - - if (!readAttributes(ret.get(), (listSize - 1) >> 1)) - return nullptr; - - if ((listSize % 2) == 1) - return ret.release(); - - int size, tag = readInt8(); - switch (tag) { - case LIST_EMPTY: case LIST_8: case LIST_16: - readList(ret.get(), tag); - break; - - case BINARY_8: - size = readInt8(); - -LBL_Binary: - if (m_limit - m_buf < size) - return false; - - ret->content.assign((void *)m_buf, size); - m_buf += size; - break; - - case BINARY_20: - size = readInt20(); - goto LBL_Binary; - - case BINARY_32: - size = readInt32(); - goto LBL_Binary; - - default: - CMStringA str = readString(tag); - ret->content.assign(str.GetBuffer(), str.GetLength() + 1); - } - - return ret.release(); -} - -///////////////////////////////////////////////////////////////////////////////////////// - -static int unpackHex(int val) -{ - if (val < 0 || val > 15) - return -1; - - return (val < 10) ? val + '0' : val - 10 + 'A'; -} - -static int unpackNibble(int val) -{ - if (val < 0 || val > 15) - return -1; - - switch (val) { - case 10: return '-'; - case 11: return '.'; - case 15: return 0; - default: return '0' + val; - } -} - -CMStringA WAReader::readPacked(int tag) -{ - int startByte = readInt8(); - bool bTrim = false; - if (startByte & 0x80) { - startByte &= ~0x80; - bTrim = true; - } - - CMStringA ret; - for (int i = 0; i < startByte; i++) { - BYTE b = readInt8(); - int lower = (tag == NIBBLE_8) ? unpackNibble(b >> 4) : unpackHex(b >> 4); - if (lower == -1) - return ""; - - int higher = (tag == NIBBLE_8) ? unpackNibble(b & 0x0F) : unpackHex(b & 0x0F); - if (higher == -1) - return ""; - - ret.AppendChar(lower); - ret.AppendChar(higher); - } - - if (bTrim && !ret.IsEmpty()) - ret.Truncate(ret.GetLength() - 1); - return ret; -} - -CMStringA WAReader::readString(int tag) -{ - if (tag >= 1 && tag < _countof(SingleByteTokens)) - return SingleByteTokens[tag]; - - int idx; - switch (tag) { - case DICTIONARY_0: - idx = readInt8(); - return (idx < _countof(dict0)) ? dict0[idx] : ""; - - case DICTIONARY_1: - idx = readInt8(); - return (idx < _countof(dict1)) ? dict1[idx] : ""; - - case DICTIONARY_2: - idx = readInt8(); - return (idx < _countof(dict2)) ? dict2[idx] : ""; - - case DICTIONARY_3: - idx = readInt8(); - return (idx < _countof(dict3)) ? dict3[idx] : ""; - - case LIST_EMPTY: - return ""; - - case BINARY_8: - return readStringFromChars(readInt8()); - - case BINARY_20: - return readStringFromChars(readInt20()); - - case BINARY_32: - return readStringFromChars(readInt32()); - - case NIBBLE_8: - case HEX_8: - return readPacked(tag); - - case AD_JID: - { - int agent = readInt8(); - int device = readInt8(); - WAJid jid(readString(readInt8()), "s.whatsapp.net", device, agent); - return jid.toString(); - } - - case JID_PAIR: - CMStringA s1 = readString(readInt8()); - CMStringA s2 = readString(readInt8()); - if (s1.IsEmpty() && s2.IsEmpty()) - break; - - return CMStringA(FORMAT, "%s@%s", s1.c_str(), s2.c_str()); - } - - // error - return ""; -} - -CMStringA WAReader::readStringFromChars(int size) -{ - if (m_limit - m_buf < size) - return ""; - - CMStringA ret((char *)m_buf, size); - m_buf += size; - return ret; -} - -///////////////////////////////////////////////////////////////////////////////////////// -// WAWriter class members - -void WAWriter::writeByte(uint8_t b) -{ - body.append(&b, 1); -} - -void WAWriter::writeIntN(int value, int n) -{ - for (int i = n - 1; i >= 0; i--) - writeByte((value >> i * 8) & 0xFF); -} - -void WAWriter::writeInt20(int value) -{ - writeByte((value >> 16) & 0xFF); - writeByte((value >> 8) & 0xFF); - writeByte(value & 0xFF); -} - -void WAWriter::writeLength(int value) -{ - if (value >= (1 << 20)) { - writeByte(BINARY_32); - writeInt32(value); - } - else if (value >= 256) { - writeByte(BINARY_20); - writeInt20(value); - } - else { - writeByte(BINARY_8); - writeInt8(value); - } -} - -void WAWriter::writeListSize(int length) -{ - if (length == 0) - writeByte(LIST_EMPTY); - else if (length < 256) { - writeByte(LIST_8); - writeInt8(length); - } - else { - writeByte(LIST_16); - writeInt16(length); - } -} - -void WAWriter::writeNode(const WANode *pNode) -{ - // we never send zipped content - if (pNode->pParent == nullptr) - writeByte(0); - - int numAttrs = (int)pNode->attrs.getCount(); - int hasContent = pNode->content.length() != 0 || pNode->children.getCount() != 0; - writeListSize(2 * numAttrs + 1 + hasContent); - - writeString(pNode->title.c_str()); - - // write attributes - for (auto &it : pNode->attrs) { - if (it->value.IsEmpty()) - continue; - - writeString(it->name.c_str()); - writeString(it->value.c_str()); - } - - // write contents - if (pNode->content.length()) { - writeLength((int)pNode->content.length()); - body.append(pNode->content.data(), pNode->content.length()); - } - // write children - else if (pNode->children.getCount()) { - writeListSize(pNode->children.getCount()); - for (auto &it : pNode->children) - writeNode(it); - } -} - -bool WAWriter::writeToken(const char *str) -{ - for (auto &it : SingleByteTokens) - if (!strcmp(str, it)) { - writeByte(int(&it - SingleByteTokens)); - return true; - } - - return false; -} - -///////////////////////////////////////////////////////////////////////////////////////// - -static BYTE packNibble(char c) -{ - if (c >= '0' && c <= '9') - return c - '0'; - - switch (c) { - case '-': return 10; - case '.': return 11; - case 0: return 15; - } - - return -1; -} - -static BYTE packHex(char c) -{ - if (c == 0) - return 15; - - if (c >= '0' && c <= '9') - return c - '0'; - - if (c >= 'A' && c <= 'F') - return c - 'A'; - - if (c >= 'a' && c <= 'f') - return c - 'a'; - - return -1; -} - -static BYTE packPair(int type, char c1, char c2) -{ - BYTE b1 = (type == NIBBLE_8) ? packNibble(c1) : packHex(c1); - BYTE b2 = (type == NIBBLE_8) ? packNibble(c2) : packHex(c2); - return (b1 << 4) + b2; -} - -static bool isNibble(const CMStringA &str) -{ - return strspn(str, "0123456789-.") == str.GetLength(); -} - -static bool isHex(const CMStringA &str) -{ - return strspn(str, "0123456789abcdefABCDEF-.") == str.GetLength(); -} - -void WAWriter::writePacked(const CMStringA &str, int tag) -{ - if (str.GetLength() > 254) - return; - - writeByte(tag); - - int len = str.GetLength() / 2; - BYTE firstByte = (str.GetLength() % 2) == 0 ? 0 : 0x81; - writeByte(firstByte + len); - - const char *p = str; - for (int i = 0; i < len; i++, p += 2) - writeByte(packPair(tag, p[0], p[1])); - - if (firstByte != 0) - writeByte(packPair(tag, p[0], 0)); -} - -void WAWriter::writeString(const char *str) -{ - if (writeToken(str)) - return; - - auto *pszDelimiter = strchr(str, '@'); - if (pszDelimiter) { - writeByte(JID_PAIR); - - if (pszDelimiter == str) // empty jid - writeByte(LIST_EMPTY); - else - writeString(CMStringA(str, int(pszDelimiter - str))); - - if (pszDelimiter[1] == 0) // empty jid - writeByte(LIST_EMPTY); - else - writeString(pszDelimiter + 1); - } - else { - CMStringA buf(str); - if (isNibble(buf)) - writePacked(buf, NIBBLE_8); - else if (isHex(buf)) - writePacked(buf, HEX_8); - else { - writeLength(buf.GetLength()); - body.append(buf, buf.GetLength()); - } - } -} -- cgit v1.2.3